home *** CD-ROM | disk | FTP | other *** search
/ The Best of Mecomp Multimedia 1 / Mecomp-CD.iso / amiga / systempatch / urouhack / source / urouhack.c < prev   
Encoding:
C/C++ Source or Header  |  1996-04-09  |  53.6 KB  |  1,853 lines
  1. /********************************************************************************/
  2. /* Urouhack V1.7 by Tinic Urou 08.04.96                                         */
  3. /*                                                                              */
  4. /* Please leave me a mail, if you are using this code.                          */
  5. /* And, it would be nice, if you could send me a copy of your modified codes    */
  6. /* uuencoded via mail.                                                          */
  7. /*                                                                              */
  8. /* 5uro@informatik.uni-hamburg.de                                               */
  9. /********************************************************************************/
  10.  
  11. /********************************************************************************/
  12. /* Some macros for class creation handling                                      */
  13. /********************************************************************************/
  14.  
  15. #define BOOPSI_Class( initName, dispatchName, ClassID, SuperClass, SuperClassPtr, InstantStruct, Flags)\
  16. Class  *initName(void);\
  17. ULONG   dispatchName(struct IClass *, Object *, Msg);\
  18. Class * initName(void)\
  19. {\
  20.     Class *cl;\
  21.     extern ULONG HookEntry();\
  22.     if(cl=MakeClass(ClassID,SuperClass,SuperClassPtr,sizeof(struct InstantStruct), Flags))\
  23.     {\
  24.         cl->cl_Dispatcher.h_Entry   = HookEntry;\
  25.         cl->cl_Dispatcher.h_SubEntry= dispatchName;\
  26.     }\
  27.     return(cl);\
  28. }\
  29. __geta4 ULONG dispatchName(struct IClass *cl, Object *object,Msg msg)\
  30. {\
  31.     struct InstantStruct *data;\
  32.     data=(struct *InstantStruct)0;\
  33.     switch(msg->MethodID)\
  34.     {
  35.  
  36. #define BOOPSI_Method( MethodID)\
  37.         case MethodID:
  38.  
  39. #define BOOPSI_Method_End\
  40.         break;
  41.  
  42. #define BOOPSI_InitData\
  43.         data=INST_DATA(cl,object);
  44.  
  45. #define BOOPSI_Method_SuperDefault\
  46.         default : return(DoSuperMethodA(cl,object,msg));
  47.  
  48. #define BOOPSI_Method_SuperReturn\
  49.         return(DoSuperMethodA(cl,object,msg));
  50.  
  51. #define BOOPSI_Method_OldH(oldH)\
  52.         return(oldH);
  53.  
  54. #define BOOPSI_Method_dOldH(oldH)\
  55.         default : return(oldH);
  56.  
  57.  
  58. #define BOOPSI_End\
  59.     }\
  60. }
  61.  
  62. /********************************************************************************/
  63. /* Includes and libbases                                                        */
  64. /********************************************************************************/
  65.  
  66. #include <exec/types.h>
  67. #include <intuition/intuition.h>
  68. #include <intuition/classes.h>
  69. #include <intuition/classusr.h>
  70. #include <intuition/imageclass.h>
  71. #include <intuition/gadgetclass.h>
  72. #include <intuition/cghooks.h>
  73. #include <intuition/icclass.h>
  74. #include <utility/tagitem.h>
  75. #include <utility/hooks.h>
  76. #include <clib/intuition_protos.h>
  77. #include <clib/utility_protos.h>
  78. #include <clib/alib_protos.h>
  79. #include <clib/alib_stdio_protos.h>
  80. #include <intuition/IntuitionBase.h>
  81. #include <graphics/gfxbase.h>
  82. #include <graphics/text.h>
  83. #include <graphics/scale.h>
  84. #include <datatypes/datatypes.h>
  85. #include <datatypes/pictureclass.h>
  86. #include <dos/dos.h>
  87. #include <dos/rdargs.h>
  88. #include <exec/memory.h>
  89. #include <exec/tasks.h>
  90. #include <clib/macros.h>
  91. #include <datatypes/datatypesclass.h>
  92. #include <datatypes/datatypes.h>
  93. #include <datatypes/pictureclass.h>
  94. #include <dos/dostags.h>
  95.  
  96. extern       struct IntuitionBase *IntuitionBase;
  97. extern       struct Library       *UtilityBase;
  98.              struct Library       *DataTypesBase;
  99. static const char                 *version="$VER: Urouhack V1.7 by Tinic Urou. This is GIFTWARE!";
  100.  
  101. ULONG       *swim_in_my_pool;
  102.  
  103. BOOL    pframes         = TRUE,
  104.         psysi           = TRUE,
  105.         sysihackstyle   = FALSE,
  106.         pwin            = TRUE,
  107.         trymwb          = FALSE,
  108.         XStyle          = FALSE;
  109.  
  110. /********************************************************************************/
  111. /* Append new pens to the DrawInfo and allocate them                            */
  112. /********************************************************************************/
  113.  
  114. #define HALFSHADOWPEN   (0x000C)
  115. #define HALFSHINEPEN    (0x000D)
  116. #define DARKPAINTPEN    (0x000E)    /* Brown  on MagicWB */
  117. #define SHINEPAINTPEN   (0x000F)    /* Orange on MagicWB */
  118.  
  119. #define NEWNUMDRIPENS   (0x0010)
  120. #define NEWDRIVERSION   (0x0003)
  121. #define GADMAGIC        ((APTR)(0xFFDEADED))
  122.  
  123. struct NewPenStruct
  124. {
  125.     UWORD halfdark;
  126.     UWORD halfshine;
  127.     UWORD darkpaint;
  128.     UWORD shinepaint;
  129. };
  130.  
  131. struct ExtNewPenStruct
  132. {
  133.     ULONG   c1r;
  134.     ULONG   c1g;
  135.     ULONG   c1b;
  136.     ULONG   c2r;
  137.     ULONG   c2g;
  138.     ULONG   c2b;
  139.     ULONG   c3r;
  140.     ULONG   c3g;
  141.     ULONG   c3b;
  142.     ULONG   c4r;
  143.     ULONG   c4g;
  144.     ULONG   c4b;
  145. };
  146.  
  147. /********************************************************************************/
  148. /* Default shit                                                                 */
  149. /********************************************************************************/
  150.  
  151. BYTE    b_top   = 3,
  152.         b_bottom= 3,
  153.         b_left  = 3,
  154.         b_right = 3,
  155.  
  156.         b_height=14,
  157.         b_width =18;
  158.  
  159. struct NewPenStruct p1={1,0,1,1};
  160. struct NewPenStruct p2={4,5,6,7};
  161.  
  162. struct NewPenStruct *penlist[256]=
  163. {
  164.     &p1,
  165.     &p2
  166. };
  167.  
  168. BOOL exttrymwb[256];
  169.  
  170. char *namelist[256]=
  171. {
  172.     "Free Britanny!",
  173.     "Workbench"
  174. };
  175.  
  176. char    *imagestyle;
  177.  
  178. BOOL    onlywb=FALSE;
  179.  
  180. /********************************************************************************/
  181. /* Patch area                                                                   */
  182. /********************************************************************************/
  183.  
  184. static ULONG AllocVecPooled(ULONG *pool, ULONG memsize)
  185. {
  186.     ULONG *memory;
  187.     memsize += ( sizeof(ULONG) + sizeof(ULONG) );
  188.     if(memory=(ULONG *)AllocPooled(pool,memsize))
  189.     {
  190.         memory[0]=pool;
  191.         memory[1]=memsize;
  192.         memory+=2L;       
  193.     }                    
  194.     return(memory);
  195. }
  196. static void  FreeVecPooled(ULONG *memory)
  197. {
  198.     FreePooled(memory[-2L],memory-2L,memory[-1L]);
  199. }
  200.  
  201. int GetPubScreens(struct Screen *src, char *namelist[])
  202. {
  203.     struct List     *PubScreenList;
  204.     struct PubScreenNode *ScreenNode;
  205.  
  206.     PubScreenList = LockPubScreenList();
  207.     for(ScreenNode=(struct PubScreenNode *)PubScreenList->lh_Head;ScreenNode->psn_Node.ln_Succ;ScreenNode=(struct PubScreenNode *)ScreenNode->psn_Node.ln_Succ)
  208.     {
  209.         if(ScreenNode->psn_Screen==src)
  210.         {
  211.             int i=0;
  212.  
  213.             while(namelist[i])
  214.             {
  215.                 if(strcmp(ScreenNode->psn_Node.ln_Name,namelist[i])==0)
  216.                 {
  217.                     UnlockPubScreenList();
  218.                     return(i);
  219.                 }
  220.                 i++;
  221.             }
  222.             UnlockPubScreenList();
  223.             return(0);
  224.         }
  225.     }
  226.     UnlockPubScreenList();
  227.     return(0);
  228. }
  229.  
  230. /* Extra pen information array */
  231.  
  232. #define OLD_PENS        (0x00)
  233. #define IMG_SCREEN      (0x01)
  234. #define MAX_EXT         (0x03)
  235.  
  236. __geta4 void allocNewPens(__A2 struct Screen *scr)
  237. {
  238.     struct DrawInfo *dr;
  239.     int              i;
  240.     BOOL             doit=TRUE;
  241.  
  242.     static struct ExtNewPenStruct defpens=
  243.     {
  244.         0x80808080,0x80808080,0x80808080,
  245.         0xafafafaf,0xafafafaf,0xafafafaf,
  246.         0xaaaaaaaa,0x99999999,0x77777777,
  247.         0xffffffff,0xa9a9a9a9,0x97979797
  248.     };
  249.  
  250.     if(dr=GetScreenDrawInfo(scr))
  251.     {
  252.         if(dr->dri_Version==DRI_VERSION)
  253.         {
  254.             UWORD   *newpens;
  255.             if(newpens=(UWORD *)AllocVecPooled(swim_in_my_pool, (NEWNUMDRIPENS+1) * sizeof(UWORD) + sizeof(ULONG) * MAX_EXT ))
  256.             {
  257.                 ((ULONG *)newpens)[OLD_PENS     ]   = dr->dri_Pens;
  258.                 ((ULONG *)newpens)[IMG_SCREEN   ]   = scr;
  259.                 ((ULONG *)newpens)                 += MAX_EXT;
  260.  
  261.                 CopyMem(dr->dri_Pens,newpens,NUMDRIPENS<<1);
  262.                 dr->dri_Pens            = newpens;
  263.                 dr->dri_Version         = NEWDRIVERSION;
  264.                 newpens[NEWNUMDRIPENS]  = ~0;
  265.  
  266.                 if(i=GetPubScreens(scr,namelist))
  267.                 {
  268.                     if(exttrymwb[i])
  269.                     {
  270.                         i=ObtainBestPen(scr->ViewPort.ColorMap,defpens.c1r,defpens.c1g, defpens.c1b,OBP_Precision,PRECISION_IMAGE,TAG_DONE);
  271.                         newpens[HALFSHADOWPEN]= i>-1 ? i : penlist[0]->halfdark;
  272.                         i=ObtainBestPen(scr->ViewPort.ColorMap,defpens.c2r,defpens.c2g, defpens.c2b,OBP_Precision,PRECISION_IMAGE,TAG_DONE);
  273.                         newpens[HALFSHINEPEN] = i>-1 ? i : penlist[0]->halfshine;
  274.                         i=ObtainBestPen(scr->ViewPort.ColorMap,defpens.c3r,defpens.c3g, defpens.c3b,OBP_Precision,PRECISION_IMAGE,TAG_DONE);
  275.                         newpens[DARKPAINTPEN] = i>-1 ? i : penlist[0]->darkpaint;
  276.                         i=ObtainBestPen(scr->ViewPort.ColorMap,defpens.c4r,defpens.c4g, defpens.c4b,OBP_Precision,PRECISION_IMAGE,TAG_DONE);
  277.                         newpens[SHINEPAINTPEN]= i>-1 ? i : penlist[0]->shinepaint;
  278.                     }
  279.                     else
  280.                     {
  281.                         newpens[HALFSHADOWPEN]=penlist[i]->halfdark;
  282.                         newpens[HALFSHINEPEN]= penlist[i]->halfshine;
  283.                         newpens[DARKPAINTPEN]= penlist[i]->darkpaint;
  284.                         newpens[SHINEPAINTPEN]=penlist[i]->shinepaint;
  285.                     }
  286.                 }
  287.                 else
  288.                 {
  289.                     if(trymwb)
  290.                     {
  291.                         i=ObtainBestPen(scr->ViewPort.ColorMap,defpens.c1r,defpens.c1g, defpens.c1b,OBP_Precision,PRECISION_IMAGE,OBP_FailIfBad,TRUE,TAG_DONE);
  292.                         newpens[HALFSHADOWPEN]= i>-1 ? i : penlist[0]->halfdark;
  293.                         i=ObtainBestPen(scr->ViewPort.ColorMap,defpens.c2r,defpens.c2g, defpens.c2b,OBP_Precision,PRECISION_IMAGE,OBP_FailIfBad,TRUE,TAG_DONE);
  294.                         newpens[HALFSHINEPEN] = i>-1 ? i : penlist[0]->halfshine;
  295.                         i=ObtainBestPen(scr->ViewPort.ColorMap,defpens.c3r,defpens.c3g, defpens.c3b,OBP_Precision,PRECISION_IMAGE,OBP_FailIfBad,TRUE,TAG_DONE);
  296.                         newpens[DARKPAINTPEN] = i>-1 ? i : penlist[0]->darkpaint;
  297.                         i=ObtainBestPen(scr->ViewPort.ColorMap,defpens.c4r,defpens.c4g, defpens.c4b,OBP_Precision,PRECISION_IMAGE,OBP_FailIfBad,TRUE,TAG_DONE);
  298.                         newpens[SHINEPAINTPEN]= i>-1 ? i : penlist[0]->shinepaint;
  299.                     }
  300.                     else
  301.                     {
  302.                         newpens[HALFSHADOWPEN]= penlist[0]->halfdark;
  303.                         newpens[HALFSHINEPEN] = penlist[0]->halfshine;
  304.                         newpens[DARKPAINTPEN] = penlist[0]->darkpaint;
  305.                         newpens[SHINEPAINTPEN]= penlist[0]->shinepaint;
  306.                     }
  307.                 }
  308.             }
  309.         }
  310.         FreeScreenDrawInfo(scr,dr);
  311.     }
  312. }
  313.  
  314. __geta4 freeNewPens(__A0 struct Screen *scr)
  315. {
  316.     struct DrawInfo *dr;
  317.     if(dr=GetScreenDrawInfo(scr))
  318.     {
  319.         if(dr->dri_Version==NEWDRIVERSION)
  320.         {
  321.             UWORD *newpens  = dr->dri_Pens;
  322.             dr->dri_Pens    = (UWORD *)((ULONG *)newpens)[(-MAX_EXT)+OLD_PENS];
  323.             dr->dri_Version = DRI_VERSION;
  324.  
  325.             FreeVecPooled     (((ULONG *)newpens)-MAX_EXT);
  326.         }
  327.         FreeScreenDrawInfo(scr,dr);
  328.     }
  329. }
  330.  
  331. #define GM_EXTIMG       0x0FAD
  332.  
  333. __geta4 AddGadgetExtra(__A0 struct Window *win, __A1 struct Gadget *gad)
  334. {
  335.     do
  336.     {
  337.         if(gad->UserData==GADMAGIC)DoMethod(gad,GM_EXTIMG,win->WScreen);
  338.     }
  339.     while(gad=gad->NextGadget);
  340. }
  341.  
  342.  
  343. /********************************************************************************/
  344. /* This change is needed for some programs like DeliTrackerII etc...            */
  345. /********************************************************************************/
  346.  
  347. __geta4 void changeSize(__A0 struct NewWindow *win,__A1 struct TagItem *tags)
  348. {
  349.     struct TagItem  *ti;
  350.     if(tags)
  351.     {
  352.         ULONG flags=GetTagData(WA_Flags,win ? win->Flags : 0 ,tags); /* Oh yeah, I forgot to check if win was TRUE in 1.3 8)) */
  353.         if(flags&WFLG_SIZEGADGET)
  354.         {
  355.             if(flags&WFLG_SIZEBBOTTOM)
  356.             {
  357.                 if(ti=FindTagItem(WA_InnerHeight,tags))
  358.                 {
  359.                     ti->ti_Data+=(b_height-10);
  360.                 }
  361.             }
  362.             if(flags&WFLG_SIZEBRIGHT)
  363.             {
  364.                 if(ti=FindTagItem(WA_InnerWidth,tags))
  365.                 {
  366.                     ti->ti_Data+=(b_width-10);
  367.                 }
  368.             }
  369.         }
  370.     }
  371. }
  372.  
  373. /********************************************************************************/
  374. /* standard function for drawing frames, I should convert this to assembler.... */
  375. /********************************************************************************/
  376.  
  377. void draw_frame(struct RastPort *rp, UWORD x, UWORD y, UWORD width, UWORD height, UWORD col1, UWORD col2, UWORD col3, UWORD col4, UWORD col5, BOOL bg)
  378. {
  379.     if((width>x)&&(height>y))
  380.     {
  381.         UWORD *ptr=rp->AreaPtrn; rp->AreaPtrn=0L;
  382.         SetAPen(rp,col1);
  383.         RectFill(rp,x,y,width,y);
  384.         RectFill(rp,x,y,x,height);
  385.         SetAPen(rp,col2);
  386.         RectFill(rp,width,y,width,height);
  387.         RectFill(rp,x,height,width,height);
  388.         x++;y++;height--;width--;
  389.         if(bg)
  390.         {
  391.             SetAPen(rp,col5);
  392.             RectFill(rp,x+1,y+1,width-1,height-1);
  393.         }
  394.         SetAPen(rp,col3);
  395.         RectFill(rp,x,y,width,y);
  396.         RectFill(rp,x,y,x,height);
  397.         SetAPen(rp,col4);
  398.         RectFill(rp,x,height,width,height);
  399.         RectFill(rp,width,y,width,height);
  400.         rp->AreaPtrn=ptr;
  401.     }
  402. }
  403.  
  404. void draw_simple(struct RastPort *rp,UWORD x, UWORD y, UWORD width, UWORD height, UWORD col1, UWORD col2)
  405. {
  406.     if((width>x)&&(height>y))
  407.     {
  408.         SetAPen(rp,col1);
  409.         RectFill(rp,x,y,width,y);
  410.         RectFill(rp,x,y,x,height);
  411.         SetAPen(rp,col2);
  412.         RectFill(rp,width,y,width,height);
  413.         RectFill(rp,x,height,width,height);
  414.     }
  415. }
  416.  
  417. /******************************************************************/
  418. /* FRAMEICLASS Hack                                               */
  419. /******************************************************************/
  420.  
  421. struct FRAMEData
  422. {
  423.     ULONG type;
  424.     ULONG edgesonly;
  425.     ULONG recessed;
  426.     ULONG data;
  427.     BOOL  yes;
  428. };
  429.  
  430. BOOL DrawXEN(struct impDraw *imsg,struct FRAMEData *data, struct RastPort *rp, UWORD minx, UWORD miny, UWORD maxx, UWORD maxy, UWORD *pens)
  431. {
  432.     switch (data->type)
  433.     {
  434.         case    FRAME_BUTTON:
  435.                 if (imsg->imp_State==IDS_NORMAL)
  436.                 {
  437.                     if(data->edgesonly)
  438.                     {
  439.                         if(!data->recessed) draw_frame (rp,minx,miny,maxx,maxy,pens[SHINEPEN],pens[SHADOWPEN],pens[HALFSHINEPEN],pens[HALFSHADOWPEN],0,FALSE);
  440.                         else                draw_frame (rp,minx,miny,maxx,maxy,pens[SHADOWPEN],pens[SHINEPEN],pens[HALFSHADOWPEN],pens[HALFSHINEPEN],0,FALSE);
  441.                     }
  442.                     else
  443.                     {
  444.                         if(!data->recessed) draw_frame (rp,minx,miny,maxx,maxy,pens[SHADOWPEN],pens[SHADOWPEN],pens[SHINEPEN],pens[HALFSHADOWPEN],pens[HALFSHINEPEN],TRUE);
  445.                         else                draw_frame (rp,minx,miny,maxx,maxy,pens[SHADOWPEN],pens[SHADOWPEN],pens[HALFSHADOWPEN],pens[SHINEPEN],pens[BACKGROUNDPEN],TRUE);
  446.                     }
  447.                 }
  448.                 else
  449.                 {
  450.                     if(data->edgesonly)     draw_frame (rp,minx,miny,maxx,maxy,pens[SHADOWPEN],pens[SHINEPEN],pens[HALFSHADOWPEN],pens[HALFSHINEPEN],0,FALSE);
  451.                     else                    draw_frame (rp,minx,miny,maxx,maxy,pens[SHADOWPEN],pens[SHADOWPEN],pens[HALFSHADOWPEN],pens[SHINEPEN],pens[BACKGROUNDPEN],TRUE);
  452.                 }
  453.                 break;
  454.         case    FRAME_RIDGE:
  455.                 if(data->edgesonly)
  456.                 {
  457.                     if(!data->recessed)     draw_frame (rp,minx,miny,maxx,maxy,pens[SHINEPEN],pens[SHADOWPEN],pens[SHADOWPEN],pens[SHINEPEN],0,FALSE);
  458.                     else                    draw_frame (rp,minx,miny,maxx,maxy,pens[SHADOWPEN],pens[SHINEPEN],pens[SHINEPEN],pens[SHADOWPEN],0,FALSE);
  459.                 }
  460.                 else
  461.                 {
  462.                     if(!data->recessed)     draw_frame (rp,minx,miny,maxx,maxy,pens[SHINEPEN],pens[SHADOWPEN],pens[SHADOWPEN],pens[SHINEPEN],pens[BACKGROUNDPEN],TRUE);
  463.                     else                    draw_frame (rp,minx,miny,maxx,maxy,pens[SHADOWPEN],pens[SHINEPEN],pens[SHINEPEN],pens[SHADOWPEN],pens[BACKGROUNDPEN],TRUE);
  464.                 }
  465.                 break;
  466.     }
  467.     return(TRUE);
  468. }
  469.  
  470. BOOL DrawX(struct impDraw *imsg,struct FRAMEData *data, struct RastPort *rp, UWORD minx, UWORD miny, UWORD maxx, UWORD maxy, UWORD *pens)
  471. {
  472.     switch (data->type)
  473.     {
  474.         case    FRAME_DEFAULT:
  475.         case    FRAME_BUTTON:
  476.                 if (imsg->imp_State==IDS_NORMAL)
  477.                 {
  478.                     if(data->edgesonly)
  479.                     {
  480.                         if(!data->recessed) draw_frame (rp,minx,miny,maxx,maxy,pens[SHINEPEN],pens[HALFSHADOWPEN],pens[SHINEPEN],pens[HALFSHADOWPEN],0,FALSE);
  481.                         else                draw_frame (rp,minx,miny,maxx,maxy,pens[HALFSHADOWPEN],pens[SHINEPEN],pens[HALFSHADOWPEN],pens[SHINEPEN],0,FALSE);
  482.                     }
  483.                     else
  484.                     {
  485.                         if(!data->recessed) draw_frame (rp,minx,miny,maxx,maxy,pens[SHINEPEN],pens[HALFSHADOWPEN],pens[SHINEPEN],pens[HALFSHADOWPEN],pens[HALFSHINEPEN],TRUE);
  486.                         else                draw_frame (rp,minx,miny,maxx,maxy,pens[HALFSHADOWPEN],pens[SHINEPEN],pens[HALFSHADOWPEN],pens[SHINEPEN],pens[BACKGROUNDPEN],TRUE);
  487.                     }
  488.                 }
  489.                 else
  490.                 {
  491.                     if(data->edgesonly)     draw_frame (rp,minx,miny,maxx,maxy,pens[HALFSHADOWPEN],pens[SHINEPEN],pens[HALFSHADOWPEN],pens[SHINEPEN],0,FALSE);
  492.                     else                    draw_frame (rp,minx,miny,maxx,maxy,pens[HALFSHADOWPEN],pens[SHINEPEN],pens[HALFSHADOWPEN],pens[SHINEPEN],pens[BACKGROUNDPEN],TRUE);
  493.                 }
  494.                 break;
  495.         case    FRAME_RIDGE:
  496.                 if(data->edgesonly)
  497.                 {
  498.                     if(!data->recessed)     draw_frame (rp,minx,miny,maxx,maxy,pens[SHINEPEN],pens[HALFSHADOWPEN],pens[HALFSHADOWPEN],pens[SHINEPEN],0,FALSE);
  499.                     else                    draw_frame (rp,minx,miny,maxx,maxy,pens[HALFSHADOWPEN],pens[SHINEPEN],pens[SHINEPEN],pens[HALFSHADOWPEN],0,FALSE);
  500.                 }
  501.                 else
  502.                 {
  503.                     if(!data->recessed)     draw_frame (rp,minx,miny,maxx,maxy,pens[SHINEPEN],pens[HALFSHADOWPEN],pens[HALFSHADOWPEN],pens[SHINEPEN],pens[BACKGROUNDPEN],TRUE);
  504.                     else                    draw_frame (rp,minx,miny,maxx,maxy,pens[HALFSHADOWPEN],pens[SHINEPEN],pens[SHINEPEN],pens[HALFSHADOWPEN],pens[BACKGROUNDPEN],TRUE);
  505.                 }
  506.                 break;
  507.     }
  508.     return(TRUE);
  509. }
  510.  
  511. BOOL fstrcmp(UBYTE *str1, UBYTE *str2)
  512. {
  513.     int i;
  514.     for(i=0;str1[i]&&str2[i];i++) if(str1[i]!=str2[i])  return(FALSE);
  515.     if((!str1[i])&&(!str2[i]))                          return(TRUE);
  516.     else                                                return(FALSE);
  517. }
  518.  
  519. BOOPSI_Class(initFRAMEClass,dispatchFRAME,"frameiclass","breizhclass",NULL,FRAMEData, 0)
  520.  
  521.     BOOPSI_Method(OM_NEW)
  522.     {
  523.         ULONG   type,edgesonly,recessed;
  524.         type      =GetTagData(IA_FrameType,0L,((struct opSet *)msg)->ops_AttrList);
  525.         edgesonly =GetTagData(IA_EdgesOnly,0L,((struct opSet *)msg)->ops_AttrList);
  526.         recessed  =GetTagData(IA_Recessed ,0L,((struct opSet *)msg)->ops_AttrList);
  527.         if(object=(Object *)DoSuperMethodA(cl,object,msg))
  528.         {
  529.             struct Task *task=(struct Task *)FindTask(NULL);
  530.  
  531.             BOOPSI_InitData
  532.             data->type      =type;
  533.             data->edgesonly =edgesonly;
  534.             data->recessed  =recessed;
  535.             data->yes       =TRUE;
  536.         }
  537.         return(object);
  538.     }
  539.     BOOPSI_Method_End
  540.  
  541.     BOOPSI_Method(IM_DRAWFRAME)
  542.     BOOPSI_Method(IM_DRAW)
  543.     {
  544.         BOOPSI_InitData
  545.  
  546.         if(data->yes)
  547.         if((data->type==FRAME_BUTTON)|(data->type==FRAME_RIDGE))
  548.         {
  549.             struct  impDraw     *imsg;
  550.             imsg=(struct impDraw *)msg;
  551.             if(imsg->imp_DrInfo)
  552.             {
  553.                 UWORD   *pens;
  554.                 pens=imsg->imp_DrInfo->dri_Pens;
  555.                 if(imsg->imp_DrInfo->dri_Version==NEWDRIVERSION)
  556.                 {
  557.                     UWORD   minx,miny,maxx,maxy;
  558.                     struct  RastPort    *rp;
  559.                     rp  =imsg->imp_RPort;
  560.                     minx=imsg->imp_Offset.X+((struct Image *)object)->LeftEdge;
  561.                     miny=imsg->imp_Offset.Y+((struct Image *)object)->TopEdge;
  562.                     maxx=minx+((msg->MethodID==IM_DRAWFRAME) ? imsg->imp_Dimensions.Width  : ((struct Image *)object)->Width )-1;
  563.                     maxy=miny+((msg->MethodID==IM_DRAWFRAME) ? imsg->imp_Dimensions.Height : ((struct Image *)object)->Height)-1;
  564.                     if(XStyle)
  565.                     {
  566.                         return(DrawX(imsg,data,rp,minx,miny,maxx,maxy,pens));
  567.                     }
  568.                     else
  569.                     {
  570.                         return(DrawXEN(imsg,data,rp,minx,miny,maxx,maxy,pens));
  571.                     }
  572.                 }
  573.             }
  574.         }
  575.         BOOPSI_Method_SuperReturn
  576.     }
  577.     BOOPSI_Method_End
  578.  
  579.     BOOPSI_Method_SuperDefault
  580.  
  581. BOOPSI_End
  582.  
  583. /******************************************************************/
  584. /* ImageLoadTask                                                  */
  585. /******************************************************************/
  586.  
  587. #define IML_LOAD    1
  588. #define IML_FREE    0
  589.  
  590. struct iht_msg
  591. {
  592.     struct  Message ts_Message;
  593.  
  594.     ULONG           MethodID;
  595.  
  596.     char            *file;
  597.     char            *screen;
  598.     Object          *object;
  599.     struct  BitMap  *bitmap;
  600.     struct BitMapHeader *bmhd;
  601. };
  602.  
  603. BOOL PutToPort(struct Message *message)
  604. {
  605.     struct MsgPort *port;
  606.  
  607.     Forbid();
  608.     port = (struct MsgPort *)FindPort("UrouHack ImageLoader");
  609.     if (port) PutMsg(port, (struct Message *) message);
  610.     Permit();
  611.     return(port ? TRUE : FALSE);
  612. }
  613.  
  614. __geta4 void ImageLoaderTask(void)
  615. {
  616.     struct MsgPort  *ilt_port;
  617.     ULONG            ilt_mask;
  618.     struct iht_msg  *msg;
  619.  
  620.     if(ilt_port=(struct MsgPort *)CreatePort("UrouHack ImageLoader",0))
  621.     {
  622.         ilt_mask = 1L << (ilt_port->mp_SigBit);
  623.         for(;;)
  624.         {
  625.             Wait(ilt_mask);
  626.             while(msg=(struct iht_msg *)GetMsg(ilt_port))
  627.             {
  628.                 if(DataTypesBase==(struct Library *)2L)DataTypesBase=(struct Library *)OpenLibrary("datatypes.library",0L);
  629.                 if(DataTypesBase)
  630.                 {
  631.                     if(msg->MethodID==IML_LOAD)
  632.                     {
  633.                         msg->object=NULL;
  634.                         if(msg->file&&msg->screen)
  635.                         {
  636.                             if (msg->object = (Object *)NewDTObject(msg->file,
  637.                                 DTA_GroupID          ,GID_PICTURE,
  638.                                 PDTA_Screen          ,msg->screen,
  639.                                 PDTA_FreeSourceBitMap,TRUE,
  640.                                 OBP_Precision        ,PRECISION_GUI,
  641.                                 TAG_DONE))
  642.                             if (!DoDTMethod(msg->object,NULL,NULL,DTM_PROCLAYOUT,NULL,1))
  643.                             {
  644.                                 DisposeDTObject(msg->object);
  645.                                 msg->object=NULL;
  646.                             }
  647.                                                 GetDTAttrs(msg->object,PDTA_BitMapHeader,&msg->bmhd,PDTA_DestBitMap,&msg->bitmap,TAG_DONE);
  648.                             if (&msg->bitmap)   GetDTAttrs(msg->object,PDTA_BitMap,                                 &msg->bitmap,TAG_DONE);
  649.                         }
  650.                     }
  651.                     else
  652.                     {
  653.                         if(msg->object) DisposeDTObject(msg->object);
  654.                     }
  655.                 }
  656.                 ReplyMsg(msg);
  657.             }
  658.         }
  659.     }
  660.     Wait(0L);
  661. }
  662.  
  663. /********************************************************************/
  664. /* GADCLASS Hack                                                    */
  665. /********************************************************************/
  666.  
  667. #define BTOP_NONE       0
  668. #define BTOP_KINGCON    1
  669.  
  670. #define ICONIFYIMAGE    (0x12L)
  671. #define SNAPIMAGE       (0x13L)
  672. #define POPIMAGE        (0x14L)
  673. #define MUIIMAGE        (0x15L)
  674.  
  675. struct GADData
  676. {
  677.     UWORD           btop;
  678.     UWORD           load;
  679.     Object         *image;
  680. };
  681.  
  682. struct gpExtra
  683. {
  684.     ULONG           MethodID;
  685.     struct Screen  *scr;
  686. }
  687.  
  688. show(char *msg)
  689. {
  690.     static struct EasyStruct easymsg =
  691.     {
  692.     sizeof(struct EasyStruct),
  693.     0,
  694.     "UrouHack information",
  695.     0L,
  696.     "OK"
  697.     };
  698.     easymsg.es_TextFormat=msg;
  699.     EasyRequest(NULL, &easymsg, NULL);
  700. }
  701.  
  702. BOOPSI_Class(initGADClass, dispatchGADClass, "buttongclass","tinicclass",NULL,GADData, 0)
  703.  
  704.     BOOPSI_Method(OM_NEW)
  705.     {
  706.         ULONG type          = GetTagData  (GA_SysGType,0L,((struct opSet *)msg)->ops_AttrList);
  707.         ULONG btop          = FindTagItem (GA_TopBorder,((struct opSet *)msg)->ops_AttrList);
  708.         ULONG *bd           = (struct Image *)GetTagData  (GA_Image,0L,((struct opSet *)msg)->ops_AttrList);
  709.  
  710.         if(object=(Object *)DoSuperMethodA(cl,object,msg))
  711.         {
  712.             BOOPSI_InitData
  713.  
  714.             data->btop=BTOP_NONE;
  715.             if(type==GTYP_SIZING)
  716.             {
  717.                 SetAttrs(object,GA_RelBottom,1-((struct Gadget *)(object))->Height,
  718.                                 GA_RelRight, 1-((struct Gadget *)(object))->Width,
  719.                                 TAG_DONE);
  720.             }           
  721.             else if(btop)
  722.             {
  723.                 struct Task *task=(struct Task *)FindTask(NULL);
  724.                 if(fstrcmp("CON",task->tc_Node.ln_Name))
  725.                 {
  726.                     data->btop =BTOP_KINGCON;
  727.                     data->load =TRUE;
  728.                     ((struct Gadget *)object)->UserData=GADMAGIC;
  729.                 }
  730.             }
  731.         }
  732.         return(object);
  733.     }
  734.     BOOPSI_Method_End
  735.  
  736.     BOOPSI_Method(GM_EXTIMG)
  737.  
  738.         struct DrawInfo *dr;
  739.  
  740.         BOOPSI_InitData
  741.  
  742.         if(dr=GetScreenDrawInfo(((struct gpExtra *)msg)->scr))
  743.         {
  744.             if(data->btop==BTOP_KINGCON)
  745.             {
  746.                 ((struct Gadget *)object)->LeftEdge++;
  747.                 if(data->load)
  748.                 {
  749.                     if(data->image=(Object *)NewObject(NULL, "sysiclass",
  750.                         IA_Top,         0,
  751.                         IA_Left,        0,
  752.                         IA_Height,      ((struct Gadget *)object)->Height,
  753.                         IA_Width,       ((struct Gadget *)object)->Width,
  754.                         SYSIA_Which,    ICONIFYIMAGE,
  755.                         SYSIA_DrawInfo, dr,
  756.                     TAG_DONE))
  757.                     SetAttrs(object,GA_Image,data->image,TAG_DONE);
  758.                     data->load=FALSE;
  759.                 }
  760.             }
  761.             FreeScreenDrawInfo(((struct gpExtra *)msg)->scr,dr);
  762.         }
  763.         return(NULL);
  764.  
  765.     BOOPSI_Method_End
  766.  
  767.     BOOPSI_Method(OM_DISPOSE)
  768.  
  769.         BOOPSI_InitData
  770.  
  771.         if(data->image)DisposeObject(data->image);
  772.  
  773.         BOOPSI_Method_SuperReturn
  774.  
  775.     BOOPSI_Method_End
  776.  
  777.     BOOPSI_Method_SuperDefault
  778.  
  779. BOOPSI_End
  780.  
  781. /********************************************************************/
  782. /* PROPCLASS Hack                                                   */
  783. /********************************************************************/
  784.  
  785. struct PROPData
  786. {
  787.     ULONG dummy;
  788. };
  789.  
  790. BOOPSI_Class(initPROPClass, dispatchPROPClass, "propgclass","gwenclass",NULL,PROPData, 0)
  791.  
  792.     BOOPSI_Method(GM_HANDLEINPUT)
  793.  
  794.         BOOPSI_Method_SuperReturn;
  795.  
  796.     BOOPSI_Method_End
  797.  
  798.     BOOPSI_Method(GM_GOACTIVE)
  799.  
  800.         BOOPSI_Method_SuperReturn;
  801.  
  802.     BOOPSI_Method_End
  803.  
  804.     BOOPSI_Method(GM_GOINACTIVE)
  805.  
  806.         BOOPSI_Method_SuperReturn;
  807.  
  808.     BOOPSI_Method_End
  809.  
  810.     BOOPSI_Method(GM_RENDER)
  811.     {
  812.         WORD    minx,miny,maxx,maxy;
  813.         struct  RastPort    *rp     = ((struct gpRender *)msg)->gpr_RPort;
  814.         struct  DrawInfo    *di     = ((struct gpRender *)msg)->gpr_GInfo->gi_DrInfo;
  815.         UWORD               *pens   = di->dri_Pens;
  816.  
  817.         if(di&&rp)
  818.         {
  819.             if(di->dri_Version==NEWDRIVERSION)
  820.             {
  821.                 minx=((struct Gadget *)object)->LeftEdge;
  822.                 miny=((struct Gadget *)object)->TopEdge;
  823.                 maxx=((struct Gadget *)object)->Width  - 1;
  824.                 maxy=((struct Gadget *)object)->Height - 1;                
  825.                 if(minx<0)
  826.                 {
  827.                     minx=((struct gpRender *)msg)->gpr_GInfo->gi_Window->Width+minx-1;
  828.                 }
  829.                 if(maxx<0)
  830.                 {
  831.                     maxx=((struct gpRender *)msg)->gpr_GInfo->gi_Window->Width+maxx+((struct gpRender *)msg)->gpr_GInfo->gi_Window->BorderLeft;
  832.                 }
  833.                 else maxx+=minx;
  834.                 if(miny<0)
  835.                 {
  836.                     miny=((struct gpRender *)msg)->gpr_GInfo->gi_Window->Height+miny-1;
  837.                 }
  838.                 if(maxy<0)
  839.                 {
  840.                     maxy=((struct gpRender *)msg)->gpr_GInfo->gi_Window->Height+maxy+((struct gpRender *)msg)->gpr_GInfo->gi_Window->BorderTop;
  841.                 }
  842.                 else maxy+=miny;
  843.                 draw_frame (rp,minx,miny,maxx,maxy,pens[SHADOWPEN],pens[SHADOWPEN],pens[HALFSHADOWPEN],pens[SHINEPEN],pens[BACKGROUNDPEN],TRUE);
  844.                 return(NULL);
  845.             }
  846.         }
  847.         BOOPSI_Method_SuperReturn;
  848.     }
  849.     BOOPSI_Method_End
  850.  
  851.     BOOPSI_Method_SuperDefault
  852.  
  853. BOOPSI_End
  854.  
  855. /******************************************************************/
  856. /* SYSIClass Hack                                                 */
  857. /******************************************************************/
  858.  
  859. struct SYSIData
  860. {
  861.     UWORD            what;
  862.     struct  BitMap  *image;
  863.     Object          *dtobj;
  864.     BOOL             fixed;
  865.     UWORD            w,h;
  866.     struct Screen   *scr;
  867.     BOOL             init;
  868. };
  869.  
  870. struct BitMap *allocBM(Object *object, char *type_sel, struct SYSIData *data )
  871. {
  872.     struct  BitMap       *srcbmp=NULL;
  873.     char    filnam[256]="s:urouhack/", foo[32];
  874.     ULONG   w,h;
  875.  
  876.     GetAttr(IA_Height,object,&h);
  877.     GetAttr(IA_Width, object,&w);
  878.  
  879.     if(imagestyle)
  880.     {
  881.         struct MsgPort *port;
  882.         if(port= CreatePort(0,0))
  883.         {
  884.             struct iht_msg  *msg;
  885.             if(msg = (struct iht_msg *)AllocVecPooled(swim_in_my_pool,sizeof(struct iht_msg)))
  886.             {
  887.                 strcat(filnam,imagestyle); strcat(filnam,type_sel); sprintf(foo,"%dx%d",w,h); strcat(filnam,foo);
  888.                 msg->ts_Message.mn_Node.ln_Type  = NT_MESSAGE;
  889.                 msg->ts_Message.mn_ReplyPort     = port;
  890.                 msg->ts_Message.mn_Length        = sizeof ( struct iht_msg );
  891.                 msg->file                        = filnam;
  892.                 msg->screen                      = data->scr;
  893.                 msg->MethodID                    = IML_LOAD;
  894.                 if(PutToPort(msg))
  895.                 {
  896.                     WaitPort(port);
  897.                     if(msg=(struct iht_msg *)GetMsg(port))
  898.                     {
  899.                         if(data->dtobj=msg->object)
  900.                         {
  901.                             srcbmp=msg->bitmap;
  902.                             data->fixed=FALSE;
  903.                         }
  904.                         else
  905.                         {
  906.                             strcpy(filnam,"s:urouhack/"); strcat(filnam,imagestyle); strcat(filnam,type_sel); strcat(filnam,"fixed");
  907.                             msg->ts_Message.mn_Node.ln_Type  = NT_MESSAGE;
  908.                             msg->ts_Message.mn_ReplyPort     = port;
  909.                             msg->ts_Message.mn_Length        = sizeof ( struct iht_msg );
  910.                             msg->file                        = filnam;
  911.                             msg->screen                      = data->scr;
  912.                             msg->MethodID                    = IML_LOAD;
  913.                             if(PutToPort(msg))
  914.                             {
  915.                                 WaitPort(port);
  916.                                 if(msg=(struct iht_msg *)GetMsg(port))
  917.                                 {
  918.                                     if(data->dtobj=msg->object)
  919.                                     {
  920.                                         struct BitMapHeader *bmhd=msg->bmhd;
  921.                                         srcbmp                   =msg->bitmap;
  922.                                         data->w=bmhd->bmh_Width/3;
  923.                                         data->h=bmhd->bmh_Height;
  924.                                         data->fixed=TRUE;
  925.                                     }
  926.                                     else
  927.                                     {
  928.                                         strcpy(filnam,"s:urouhack/"); strcat(filnam,imagestyle); strcat(filnam,type_sel); strcat(filnam,"scale");
  929.                                         msg->ts_Message.mn_Node.ln_Type  = NT_MESSAGE;
  930.                                         msg->ts_Message.mn_ReplyPort     = port;
  931.                                         msg->ts_Message.mn_Length        = sizeof ( struct iht_msg );
  932.                                         msg->file                        = filnam;
  933.                                         msg->screen                      = data->scr;
  934.                                         msg->MethodID                    = IML_LOAD;
  935.                                         if(PutToPort(msg))
  936.                                         {
  937.                                             WaitPort(port);
  938.                                             if(msg=(struct iht_msg *)GetMsg(port))
  939.                                             {
  940.                                                 if(data->dtobj=msg->object)
  941.                                                 {
  942.                                                     struct BitMapHeader *bmhd=NULL;
  943.                                                     struct BitMap       *bm=NULL;
  944.                                                     srcbmp=msg->bitmap;
  945.                                                     bmhd  =msg->bmhd;
  946.                                                     if(srcbmp&&bmhd)
  947.                                                     {
  948.                                                         if(bm = (struct BitMap *)AllocBitMap(w+w+w,h,srcbmp->Depth,NULL,NULL))
  949.                                                         {
  950.                                                             struct BitScaleArgs bsa=
  951.                                                             {
  952.                                                                 0,0,
  953.                                                                 bmhd->bmh_Width,bmhd->bmh_Height,
  954.                                                                 bmhd->bmh_Width,bmhd->bmh_Height,
  955.                                                                 0,0,
  956.                                                                 0,0,
  957.                                                                 w+w+w,h,
  958.                                                                 srcbmp,
  959.                                                                 bm,
  960.                                                                 NULL,
  961.                                                                 NULL,NULL,
  962.                                                                 NULL,
  963.                                                                 NULL
  964.                                                             };
  965.                                                             BitMapScale(&bsa);
  966.                                                             FreeVecPooled(msg);
  967.                                                             DeletePort(port);
  968.                                                             return(bm);
  969.                                                         }
  970.                                                         else
  971.                                                         {
  972.                                                             bm=NULL;
  973.                                                             srcbmp=NULL;
  974.                                                         }
  975.                                                     }
  976.                                                 }
  977.                                             }
  978.                                         }
  979.                                     }
  980.                                 }
  981.                             }
  982.                         }
  983.                     }
  984.                 }
  985.                 FreeVecPooled(msg);
  986.             }
  987.             DeletePort(port);
  988.         }
  989.     }
  990.     return(srcbmp);
  991. }
  992.  
  993. ULONG DrawUrou(struct SYSIData *data,struct impDraw *imsg,Object *object, Class *cl, Msg msg)
  994. {
  995.     UWORD   y_size,dummy,minx,miny,maxx,maxy;
  996.     struct  RastPort    *rp;
  997.     UWORD   *pens;
  998.     pens=imsg->imp_DrInfo->dri_Pens;
  999.     rp=imsg->imp_RPort;
  1000.     y_size=((struct Image *)object)->Height-1;
  1001.     dummy=(y_size+1)>>1;
  1002.     minx=imsg->imp_Offset.X+((struct Image *)object)->LeftEdge;
  1003.     miny=imsg->imp_Offset.Y+((struct Image *)object)->TopEdge;
  1004.     maxx=minx+((struct Image *)object)->Width-1;
  1005.     maxy=miny+((struct Image *)object)->Height-1;
  1006.  
  1007.     switch (data->what)
  1008.     {
  1009.         case    SDEPTHIMAGE:
  1010.                 SetAPen(rp,pens[BACKGROUNDPEN]);
  1011.                 RectFill(rp,minx+1,miny+1,maxx-1,maxy-1);
  1012.         case    ZOOMIMAGE:
  1013.         case    DEPTHIMAGE:
  1014.         case    ICONIFYIMAGE:
  1015.                 minx++;
  1016.         case    LEFTIMAGE:
  1017.         case    UPIMAGE:
  1018.         case    DOWNIMAGE:
  1019.         case    RIGHTIMAGE:
  1020.         case    SIZEIMAGE:
  1021.         case    CLOSEIMAGE:
  1022.                 if(XStyle)
  1023.                 {
  1024.                     if(imsg->imp_State==IDS_SELECTED) draw_frame (rp,minx,miny,maxx,maxy,pens[HALFSHADOWPEN],pens[SHINEPEN],pens[HALFSHADOWPEN],pens[SHINEPEN],pens[HALFSHINEPEN],TRUE);
  1025.                     else                              draw_frame (rp,minx,miny,maxx,maxy,pens[SHINEPEN],pens[HALFSHADOWPEN],pens[SHINEPEN],pens[HALFSHADOWPEN],pens[HALFSHINEPEN],TRUE);
  1026.                 }
  1027.                 else
  1028.                 {
  1029.                     if(imsg->imp_State==IDS_SELECTED) draw_frame (rp,minx,miny,maxx,maxy,pens[SHADOWPEN],pens[SHINEPEN],pens[HALFSHADOWPEN],pens[HALFSHINEPEN],pens[BACKGROUNDPEN],TRUE);
  1030.                     else                              draw_frame (rp,minx,miny,maxx,maxy,pens[SHINEPEN],pens[SHADOWPEN],pens[HALFSHINEPEN],pens[HALFSHADOWPEN],pens[BACKGROUNDPEN],TRUE);
  1031.                 }
  1032.                 break;
  1033.     };
  1034.     switch (data->what)
  1035.     {
  1036.         case    LEFTIMAGE:
  1037.                 SetAPen(rp,pens[SHADOWPEN]);
  1038.                 Move(rp,minx+3,miny+dummy);
  1039.                 Draw(rp,maxx-3,maxy-3);
  1040.                 Draw(rp,maxx-3,miny+3);
  1041.                 SetAPen(rp,pens[SHINEPEN]);
  1042.                 Draw(rp,minx+3,maxy-dummy);
  1043.                 return(0L);
  1044.         case    RIGHTIMAGE:
  1045.                 SetAPen(rp,pens[SHINEPEN]);
  1046.                 Move(rp,maxx-3,maxy-dummy);
  1047.                 Draw(rp,minx+3,miny+3);
  1048.                 Draw(rp,minx+3,maxy-3);
  1049.                 SetAPen(rp,pens[SHADOWPEN]);
  1050.                 Draw(rp,maxx-3,miny+dummy);
  1051.                 return(0L);
  1052.         case    UPIMAGE:
  1053.                 SetAPen(rp,pens[SHADOWPEN]);
  1054.                 Move(rp,maxx-((maxx-minx)>>1),miny+3);
  1055.                 Draw(rp,maxx-3,maxy-3);
  1056.                 Draw(rp,minx+3,maxy-3);
  1057.                 SetAPen(rp,pens[SHINEPEN]);
  1058.                 Draw(rp,minx+((maxx-minx)>>1),miny+3);
  1059.                 return(0L);
  1060.         case    DOWNIMAGE:
  1061.                 SetAPen(rp,pens[SHADOWPEN]);
  1062.                 Move(rp,maxx-((maxx-minx)>>1),maxy-3);
  1063.                 Draw(rp,maxx-3,miny+3);
  1064.                 SetAPen(rp,pens[SHINEPEN]);
  1065.                 Draw(rp,minx+3,miny+3);
  1066.                 Draw(rp,minx+((maxx-minx)>>1),maxy-3);
  1067.                 return(0L);
  1068.                 break;
  1069.         case    SIZEIMAGE:
  1070.                 switch (imsg->imp_State)
  1071.                 {
  1072.                     case    IDS_NORMAL:
  1073.                     case    IDS_SELECTED:
  1074.                             SetAPen(rp,pens[FILLPEN]);
  1075.                             RectFill(rp,minx+1,miny+1,minx+((maxx-minx)>>1)-1,miny+dummy-1);
  1076.                             break;
  1077.                 }
  1078.                 SetAPen(rp,pens[SHADOWPEN]);
  1079.                 RectFill(rp,minx+1,miny+dummy,minx+((maxx-minx)>>1),miny+dummy);
  1080.                 RectFill(rp,minx+((maxx-minx)>>1),miny+1,minx+((maxx-minx)>>1),miny+dummy);
  1081.                 SetAPen(rp,pens[SHINEPEN]);
  1082.                 RectFill(rp,minx+1,miny+dummy+1,minx+((maxx-minx)>>1)+1,miny+dummy+1);
  1083.                 RectFill(rp,minx+((maxx-minx)>>1)+1,miny+1,minx+((maxx-minx)>>1)+1,miny+dummy+1);
  1084.                 return(0L);
  1085.         case    CLOSEIMAGE:
  1086.                 SetAPen(rp,pens[SHINEPEN]);
  1087.                 RectFill(rp,maxx+1,miny+1,maxx+1,maxy);
  1088.                 switch (imsg->imp_State)
  1089.                 {
  1090.                     case    IDS_NORMAL:
  1091.                             SetAPen(rp,pens[SHINEPEN]);
  1092.                             RectFill(rp,minx+4,miny+dummy-2,maxx-4,miny+dummy-2);
  1093.                             RectFill(rp,minx+4,miny+dummy-2,minx+4,miny+dummy+1);
  1094.                             SetAPen(rp,pens[SHADOWPEN]);
  1095.                             RectFill(rp,minx+4,miny+dummy+1,maxx-4,miny+dummy+1);
  1096.                             RectFill(rp,maxx-4,miny+dummy-2,maxx-4,miny+dummy+1);
  1097.                             SetAPen(rp,pens[FILLPEN]);
  1098.                             RectFill(rp,minx+5,miny+dummy-1,maxx-5,miny+dummy);
  1099.                             break;
  1100.                     case    IDS_SELECTED:
  1101.                             RectFill(rp,minx+6,miny+dummy-2,maxx-6,miny+dummy-2);
  1102.                             RectFill(rp,minx+6,miny+dummy-2,minx+6,miny+dummy+1);
  1103.                             SetAPen(rp,pens[SHADOWPEN]);
  1104.                             RectFill(rp,minx+6,miny+dummy+1,maxx-6,miny+dummy+1);
  1105.                             RectFill(rp,maxx-6,miny+dummy-2,maxx-6,miny+dummy+1);
  1106.                             SetAPen(rp,pens[FILLPEN]);
  1107.                             RectFill(rp,minx+7,miny+dummy-1,maxx-7,miny+dummy);
  1108.                             break;
  1109.                     default:
  1110.                             SetAPen(rp,pens[SHINEPEN]);
  1111.                             RectFill(rp,minx+4,miny+dummy-2,maxx-4,miny+dummy-2);
  1112.                             RectFill(rp,minx+4,miny+dummy-2,minx+4,miny+dummy+1);
  1113.                             SetAPen(rp,pens[SHADOWPEN]);
  1114.                             RectFill(rp,minx+4,miny+dummy+1,maxx-4,miny+dummy+1);
  1115.                             RectFill(rp,maxx-4,miny+dummy-2,maxx-4,miny+dummy+1);
  1116.                             break;
  1117.                 }
  1118.                 return(0L);
  1119.         case    DEPTHIMAGE:
  1120.         case    SDEPTHIMAGE:
  1121.                 minx--;
  1122.                 SetAPen(rp,pens[SHADOWPEN]);
  1123.                 RectFill(rp,minx,miny+1,minx,maxy);
  1124.                 switch (imsg->imp_State)
  1125.                 {
  1126.                     case    IDS_NORMAL:
  1127.                             draw_simple(rp,minx+((maxx-minx)>>1)-1,miny+5,maxx-3,maxy-3,pens[SHINEPEN],pens[SHADOWPEN]);
  1128.                             draw_simple(rp,minx+4,miny+3,minx+((maxx-minx)>>1)+3,maxy-5,pens[SHINEPEN],pens[SHADOWPEN]);
  1129.                             SetAPen(rp,pens[FILLPEN]);
  1130.                             RectFill(rp,minx+5,miny+4,minx+((maxx-minx)>>1)+2,maxy-6);
  1131.                             break;
  1132.                     case    IDS_SELECTED:
  1133.                             draw_simple(rp,minx+4,miny+3,minx+((maxx-minx)>>1)+3,maxy-5,pens[SHINEPEN],pens[SHADOWPEN]);
  1134.                             draw_simple(rp,minx+((maxx-minx)>>1)-1,miny+5,maxx-3,maxy-3,pens[SHINEPEN],pens[SHADOWPEN]);
  1135.                             SetAPen(rp,pens[FILLPEN]);
  1136.                             RectFill(rp,minx+((maxx-minx)>>1),miny+6,maxx-4,maxy-4);
  1137.                             break;
  1138.                     default:
  1139.                             draw_simple(rp,minx+((maxx-minx)>>1)-1,miny+5,maxx-3,maxy-3,pens[SHINEPEN],pens[SHADOWPEN]);
  1140.                             draw_simple(rp,minx+4,miny+3,minx+((maxx-minx)>>1)+3,maxy-5,pens[SHINEPEN],pens[SHADOWPEN]);
  1141.                             SetAPen(rp,pens[BACKGROUNDPEN]);
  1142.                             RectFill(rp,minx+5,miny+4,minx+((maxx-minx)>>1)+2,maxy-6);
  1143.                             break;
  1144.                 }
  1145.                 return(0L);
  1146.         case    ZOOMIMAGE:
  1147.                 minx--;
  1148.                 SetAPen(rp,pens[SHADOWPEN]);
  1149.                 RectFill(rp,minx,miny+1,minx,maxy);
  1150.                 draw_simple(rp,minx+((maxx-minx)>>1)-1,miny+dummy-1,maxx-((maxx-minx)>>1)+2,miny+dummy,pens[SHADOWPEN],pens[SHINEPEN]);
  1151.                 return(0L);
  1152.         case    ICONIFYIMAGE:
  1153.                 minx--;
  1154.                 SetAPen(rp,pens[SHADOWPEN]);
  1155.                 RectFill(rp,minx,miny+1,minx,maxy);
  1156.                 draw_simple(rp,minx+5,maxy-((y_size-3)>>1)-1,maxx-(((maxx-minx)-2)>>1),maxy-4,pens[SHINEPEN],pens[SHADOWPEN]);
  1157.                 return(0L);
  1158.         default:
  1159.                 BOOPSI_Method_SuperReturn
  1160.     }
  1161. }
  1162.  
  1163. ULONG DrawSysiHack(struct SYSIData *data,struct impDraw *imsg,Object *object, Class *cl, Msg msg)
  1164. {
  1165.     UWORD   y_size,dummy,minx,miny,maxx,maxy,h,w;
  1166.     struct  RastPort    *rp;
  1167.     UWORD   *pens;
  1168.     pens=imsg->imp_DrInfo->dri_Pens;
  1169.     rp=imsg->imp_RPort;
  1170.     y_size=((struct Image *)object)->Height-1;
  1171.     dummy=(y_size+1)>>1;
  1172.     minx=imsg->imp_Offset.X+((struct Image *)object)->LeftEdge;
  1173.     miny=imsg->imp_Offset.Y+((struct Image *)object)->TopEdge;
  1174.     w=((struct Image *)object)->Width;
  1175.     h=((struct Image *)object)->Height;
  1176.     maxx=minx+w-1;
  1177.     maxy=miny+h-1;
  1178.  
  1179.     switch (data->what)
  1180.     {
  1181.         case    ZOOMIMAGE:
  1182.         case    DEPTHIMAGE:
  1183.         case    ICONIFYIMAGE:
  1184.                 minx++;
  1185.         case    LEFTIMAGE:
  1186.         case    UPIMAGE:
  1187.         case    DOWNIMAGE:
  1188.         case    RIGHTIMAGE:
  1189.         case    SIZEIMAGE:
  1190.         case    CLOSEIMAGE:
  1191.                 switch(imsg->imp_State)
  1192.                 {
  1193.                     case    IDS_SELECTED:
  1194.                     case    IDS_NORMAL:
  1195.                             SetAPen(rp,pens[FILLPEN]);
  1196.                             break;
  1197.                     default:
  1198.                             SetAPen(rp,pens[BACKGROUNDPEN]);
  1199.                             break;
  1200.                 }
  1201.                 RectFill(rp,minx+1,miny+1,maxx-1,maxy-1);
  1202.                 draw_simple(rp,minx,miny,maxx,maxy,pens[SHINEPEN],pens[SHADOWPEN]);
  1203.                 break;
  1204.         case    SDEPTHIMAGE:
  1205.                 SetAPen(rp,pens[BACKGROUNDPEN]);
  1206.                 RectFill(rp,minx+1,miny+1,maxx-1,maxy-1);
  1207.                 if(imsg->imp_State==IDS_SELECTED) draw_simple(rp,minx+1,miny,maxx,maxy,pens[SHADOWPEN],pens[SHINEPEN]);
  1208.                 else                              draw_simple(rp,minx+1,miny,maxx,maxy,pens[SHINEPEN],pens[SHADOWPEN]);
  1209.                 break;
  1210.     };
  1211.     switch (data->what)
  1212.     {
  1213.         case    LEFTIMAGE:
  1214.                 SetAPen(rp,pens[SHADOWPEN]);
  1215.                 Move(rp,minx+3,miny+dummy);
  1216.                 Draw(rp,maxx-3,maxy-3);
  1217.                 Draw(rp,maxx-3,miny+3);
  1218.                 SetAPen(rp,pens[SHINEPEN]);
  1219.                 Draw(rp,minx+3,maxy-dummy);
  1220.                 return(0L);
  1221.         case    RIGHTIMAGE:
  1222.                 SetAPen(rp,pens[SHINEPEN]);
  1223.                 Move(rp,maxx-3,maxy-dummy);
  1224.                 Draw(rp,minx+3,miny+3);
  1225.                 Draw(rp,minx+3,maxy-3);
  1226.                 SetAPen(rp,pens[SHADOWPEN]);
  1227.                 Draw(rp,maxx-3,miny+dummy);
  1228.                 return(0L);
  1229.         case    UPIMAGE:
  1230.                 SetAPen(rp,pens[SHADOWPEN]);
  1231.                 Move(rp,maxx-((maxx-minx)>>1),miny+3);
  1232.                 Draw(rp,maxx-3,maxy-3);
  1233.                 Draw(rp,minx+3,maxy-3);
  1234.                 SetAPen(rp,pens[SHINEPEN]);
  1235.                 Draw(rp,minx+((maxx-minx)>>1),miny+3);
  1236.                 return(0L);
  1237.         case    DOWNIMAGE:
  1238.                 SetAPen(rp,pens[SHADOWPEN]);
  1239.                 Move(rp,maxx-((maxx-minx)>>1),maxy-3);
  1240.                 Draw(rp,maxx-3,miny+3);
  1241.                 SetAPen(rp,pens[SHINEPEN]);
  1242.                 Draw(rp,minx+3,miny+3);
  1243.                 Draw(rp,minx+((maxx-minx)>>1),maxy-3);
  1244.                 return(0L);
  1245.                 break;
  1246.         case    ZOOMIMAGE:
  1247.                 minx--;
  1248.                 SetAPen(rp,pens[SHADOWPEN]);
  1249.                 RectFill(rp,minx,miny+1,minx,maxy);
  1250.                 if(imsg->imp_State==IDS_SELECTED)
  1251.                 {
  1252.                     draw_simple(rp,minx+4,miny+3,maxx-4,maxy-3,pens[SHINEPEN],pens[SHADOWPEN]);
  1253.                     draw_simple(rp,minx+5,miny+4,maxx-((w-4)>>1),maxy-((h-4)>>1)-1,pens[SHADOWPEN],pens[SHINEPEN]);
  1254.                 }
  1255.                 else
  1256.                 {
  1257.                     draw_simple(rp,minx+4,miny+3,maxx-4,maxy-3,pens[SHADOWPEN],pens[SHINEPEN]);
  1258.                     draw_simple(rp,minx+5,miny+4,maxx-((w-4)>>1),maxy-((h-4)>>1)-1,pens[SHINEPEN],pens[SHADOWPEN]);
  1259.                 }
  1260.                 return(0L);
  1261.         case    CLOSEIMAGE:
  1262.                 {
  1263.                     UWORD foo,fao;
  1264.                     SetAPen(rp,pens[SHINEPEN]);
  1265.                     RectFill(rp,maxx+1,miny+1,maxx+1,maxy);
  1266.                     foo=(h-1)/3;
  1267.                     fao=(w-1)/3;
  1268.                     if(imsg->imp_State==IDS_SELECTED)
  1269.                     {
  1270.  
  1271.                         draw_simple(rp,minx+fao+1,miny+foo+1,maxx-fao-1,maxy-foo-1,pens[SHADOWPEN],pens[SHINEPEN]);
  1272.                     }
  1273.                     else
  1274.                     {
  1275.                         draw_simple(rp,minx+fao,miny+foo,maxx-fao,maxy-foo,pens[SHADOWPEN],pens[SHINEPEN]);
  1276.                     }
  1277.                 }
  1278.                 return(0L);
  1279.         case    DEPTHIMAGE:
  1280.                 minx--;
  1281.                 SetAPen(rp,pens[SHADOWPEN]);
  1282.                 RectFill(rp,minx,miny+1,minx,maxy);
  1283.                 switch (imsg->imp_State)
  1284.                 {
  1285.                     case    IDS_NORMAL:
  1286.                             draw_simple(rp,minx+((maxx-minx)>>1)-1,miny+5,maxx-3,maxy-2,pens[SHINEPEN],pens[SHADOWPEN]);
  1287.                             draw_simple(rp,minx+4,miny+3,minx+((maxx-minx)>>1)+3,maxy-4,pens[SHADOWPEN],pens[SHINEPEN]);
  1288.                             SetAPen(rp,pens[FILLPEN]);
  1289.                             RectFill(rp,minx+((maxx-minx)>>1),miny+6,maxx-4,maxy-3);
  1290.                             break;
  1291.                     case    IDS_SELECTED:
  1292.                             draw_simple(rp,minx+4,miny+3,minx+((maxx-minx)>>1)+3,maxy-4,pens[SHINEPEN],pens[SHADOWPEN]);
  1293.                             draw_simple(rp,minx+((maxx-minx)>>1)-1,miny+5,maxx-3,maxy-2,pens[SHINEPEN],pens[SHADOWPEN]);
  1294.                             break;
  1295.                     default:
  1296.                             draw_simple(rp,minx+((maxx-minx)>>1)-1,miny+5,maxx-3,maxy-2,pens[SHINEPEN],pens[SHADOWPEN]);
  1297.                             draw_simple(rp,minx+4,miny+3,minx+((maxx-minx)>>1)+3,maxy-4,pens[SHADOWPEN],pens[SHINEPEN]);
  1298.                             SetAPen(rp,pens[BACKGROUNDPEN]);
  1299.                             RectFill(rp,minx+((maxx-minx)>>1),miny+6,maxx-4,maxy-3);
  1300.                             break;
  1301.                 }
  1302.                 return(0L);
  1303.         case    ICONIFYIMAGE:
  1304.                 minx--;
  1305.                 SetAPen(rp,pens[SHADOWPEN]);
  1306.                 RectFill(rp,minx,miny+1,minx,maxy);
  1307.                 if(imsg->imp_State==IDS_SELECTED)
  1308.                 {
  1309.                     draw_simple(rp,minx+4,miny+3,maxx-4,maxy-3,pens[SHINEPEN],pens[SHADOWPEN]);
  1310.                     draw_simple(rp,minx+5,maxy-((h-4)>>1)-1,maxx-((w-4)>>1),maxy-4,pens[SHADOWPEN],pens[SHINEPEN]);
  1311.                 }
  1312.                 else
  1313.                 {
  1314.                     draw_simple(rp,minx+4,miny+3,maxx-4,maxy-3,pens[SHADOWPEN],pens[SHINEPEN]);
  1315.                     draw_simple(rp,minx+5,maxy-((h-4)>>1)-1,maxx-((w-4)>>1),maxy-4,pens[SHINEPEN],pens[SHADOWPEN]);
  1316.                 }
  1317.                 return(0L);
  1318.         case    SDEPTHIMAGE:
  1319.                 SetAPen(rp,pens[SHADOWPEN]);
  1320.                 RectFill(rp,minx,miny+1,minx,maxy);
  1321.                 switch (imsg->imp_State)
  1322.                 {
  1323.                     case    IDS_NORMAL:
  1324.                             draw_simple(rp,minx+((maxx-minx)>>1)-1,miny+5,maxx-3,maxy-2,pens[SHINEPEN],pens[SHADOWPEN]);
  1325.                             draw_simple(rp,minx+4,miny+3,minx+((maxx-minx)>>1)+3,maxy-4,pens[SHADOWPEN],pens[SHINEPEN]);
  1326.                             SetAPen(rp,pens[BACKGROUNDPEN]);
  1327.                             RectFill(rp,minx+((maxx-minx)>>1),miny+6,maxx-4,maxy-3);
  1328.                             break;
  1329.                     case    IDS_SELECTED:
  1330.                             draw_simple(rp,minx+4,miny+3,minx+((maxx-minx)>>1)+3,maxy-4,pens[SHINEPEN],pens[SHADOWPEN]);
  1331.                             draw_simple(rp,minx+((maxx-minx)>>1)-1,miny+5,maxx-3,maxy-2,pens[SHINEPEN],pens[SHADOWPEN]);
  1332.                             break;
  1333.                     default:
  1334.                             draw_simple(rp,minx+((maxx-minx)>>1)-1,miny+5,maxx-3,maxy-2,pens[SHINEPEN],pens[SHADOWPEN]);
  1335.                             draw_simple(rp,minx+4,miny+3,minx+((maxx-minx)>>1)+3,maxy-4,pens[SHADOWPEN],pens[SHINEPEN]);
  1336.                             SetAPen(rp,pens[BACKGROUNDPEN]);
  1337.                             RectFill(rp,minx+((maxx-minx)>>1),miny+6,maxx-4,maxy-3);
  1338.                             break;
  1339.                 }
  1340.                 return(0L);
  1341.         case    SIZEIMAGE:
  1342.                 minx--;
  1343.                 SetAPen(rp,pens[SHADOWPEN]);
  1344.                 Move(rp,maxx-3,miny+3);
  1345.                 Draw(rp,maxx-3,maxy-3);
  1346.                 Draw(rp,minx+3,maxy-3);
  1347.                 SetAPen(rp,pens[SHINEPEN]);
  1348.                 Draw(rp,maxx-3,miny+3);
  1349.                 return(0L);
  1350.         default:
  1351.                 BOOPSI_Method_SuperReturn
  1352.     }
  1353. }
  1354.  
  1355. BOOPSI_Class(initSYSIClass,dispatchSYSIClass,"sysiclass","urouclass",NULL,SYSIData, 0)
  1356.  
  1357.     static char *types[]=
  1358.     {
  1359.         "/depth/",
  1360.         "/zoom/",
  1361.         "/size/",
  1362.         "/close/",
  1363.         "/sdepth/",
  1364.         "",
  1365.         "",
  1366.         "",
  1367.         "",
  1368.         "",
  1369.         "/left/",
  1370.         "/up/",
  1371.         "/right/",
  1372.         "/down/",
  1373.         "/checkmark/",
  1374.         "/mx/",
  1375.         "",
  1376.         "",
  1377.         "/iconify/"
  1378.     };
  1379.  
  1380.     BOOPSI_Method(OM_NEW)
  1381.     {
  1382.         ULONG               what;
  1383.         BOOL                adjust_h=TRUE;
  1384.         BOOL                adjust_w=TRUE;
  1385.         struct  DrawInfo    *mydr;
  1386.         ULONG               type=TRUE;
  1387.  
  1388.         if(FindTagItem(IA_Height,((struct opSet *)msg)->ops_AttrList))adjust_h=FALSE;
  1389.         if(FindTagItem(IA_Width, ((struct opSet *)msg)->ops_AttrList))adjust_w=FALSE;
  1390.  
  1391.         what=GetTagData(SYSIA_Which, 0x0, ((struct opSet *)msg)->ops_AttrList);
  1392.         if(what>(0x11L))
  1393.         {
  1394.             struct TagItem *tag;
  1395.             if(what=ICONIFYIMAGE)
  1396.             {
  1397.                 if(tag=FindTagItem(SYSIA_Which,((struct opSet *)msg)->ops_AttrList))
  1398.                 {
  1399.                     tag->ti_Data=DEPTHIMAGE;
  1400.                 }
  1401.             }
  1402.         }
  1403.         mydr=(struct DrawInfo *)GetTagData(SYSIA_DrawInfo,0x0,((struct opSet *)msg)->ops_AttrList);
  1404.         if(object=(Object *)DoSuperMethodA(cl,object,msg))
  1405.         {
  1406.             BOOPSI_InitData
  1407.             data->what  = what;
  1408.             data->image = NULL;
  1409.             data->init  = FALSE;
  1410.             if(mydr->dri_Version==NEWDRIVERSION)
  1411.             {
  1412.                 switch(what)
  1413.                 {
  1414.                     case    SIZEIMAGE:
  1415.                             SetAttrs(object,IA_Width,b_width,IA_Height,b_height,TAG_DONE);
  1416.                             break;
  1417.                     case    LEFTIMAGE:
  1418.                     case    RIGHTIMAGE:
  1419.                     case    UPIMAGE:
  1420.                     case    DOWNIMAGE:
  1421.                             if(adjust_h)
  1422.                             {
  1423.                                 SetAttrs(object,IA_Height,b_height,TAG_DONE);
  1424.                             }
  1425.                             if(adjust_w)
  1426.                             {
  1427.                                 SetAttrs(object,IA_Width,b_width,TAG_DONE);
  1428.                             }
  1429.                             break;
  1430.                     case    CLOSEIMAGE:
  1431.                     case    ZOOMIMAGE:
  1432.                     case    DEPTHIMAGE:
  1433.                             {
  1434.                                 LONG    tmp;
  1435.                                 GetAttr(IA_Height,object,&tmp);
  1436.                                 if(tmp)  SetAttrs(object,IA_Height,tmp+(b_top-2),TAG_DONE);
  1437.                             }
  1438.                             break;
  1439.                 }
  1440.                 if(data->scr=(struct Screen *)((ULONG *)mydr->dri_Pens)[(-MAX_EXT)+IMG_SCREEN])
  1441.                 {
  1442.                     data->image = (struct BitMap *)allocBM(object,types[data->what],data);
  1443.                 }
  1444.             }
  1445.         }
  1446.         return(object);
  1447.     }
  1448.     BOOPSI_Method_End
  1449.  
  1450.     BOOPSI_Method(IM_DRAW)
  1451.     {
  1452.         BOOPSI_InitData;
  1453.  
  1454.         if(((struct impDraw *)msg)->imp_DrInfo->dri_Version==NEWDRIVERSION)
  1455.         {
  1456.             if(data->image)
  1457.             {
  1458.  
  1459.                 UWORD   minx,miny,maxx,maxy;
  1460.                 struct  RastPort    *rp=((struct impDraw *)msg)->imp_RPort;
  1461.  
  1462.                 minx=((struct impDraw *)msg)->imp_Offset.X+((struct Image *)object)->LeftEdge;
  1463.                 miny=((struct impDraw *)msg)->imp_Offset.Y+((struct Image *)object)->TopEdge;
  1464.                 maxx=((struct Image *)object)->Width ;
  1465.                 maxy=((struct Image *)object)->Height;
  1466.  
  1467.                 if(!data->fixed)
  1468.                 {
  1469.                     switch(((struct impDraw *)msg)->imp_State)
  1470.                     {
  1471.                         case    IDS_SELECTED:
  1472.                                 BltBitMapRastPort(data->image,maxx+maxx ,0,rp,minx,miny,maxx,maxy,0xc0);
  1473.                                 break;
  1474.                         case    IDS_NORMAL:
  1475.                                 BltBitMapRastPort(data->image,maxx      ,0,rp,minx,miny,maxx,maxy,0xc0);
  1476.                                 break;
  1477.                         default:
  1478.                                 BltBitMapRastPort(data->image,0         ,0,rp,minx,miny,maxx,maxy,0xc0);
  1479.                                 break;
  1480.                     }
  1481.                 }
  1482.                 else switch(((struct impDraw *)msg)->imp_State)
  1483.                 {
  1484.                     case    IDS_SELECTED:
  1485.                             BltBitMapRastPort(data->image,data->w+data->w,0,rp,minx+((maxx-data->w)>>1),miny+((maxy-data->h)>>1),data->w,data->h,0xc0);
  1486.                             break;
  1487.                     case    IDS_NORMAL:
  1488.                             BltBitMapRastPort(data->image,data->w        ,0,rp,minx+((maxx-data->w)>>1),miny+((maxy-data->h)>>1),data->w,data->h,0xc0);
  1489.                             break;
  1490.                     default:
  1491.                             BltBitMapRastPort(data->image,0              ,0,rp,minx+((maxx-data->w)>>1),miny+((maxy-data->h)>>1),data->w,data->h,0xc0);
  1492.                             break;
  1493.                 }
  1494.                 return(TRUE);
  1495.             }
  1496.             else switch (data->what)
  1497.             {
  1498.                 case    CHECKIMAGE:
  1499.                 case    MXIMAGE:
  1500.                         {
  1501.                             UWORD   minx,miny,maxx,maxy;
  1502.                             struct  RastPort    *rp=((struct impDraw *)msg)->imp_RPort;
  1503.                             UWORD   *pens=((struct impDraw *)msg)->imp_DrInfo->dri_Pens;
  1504.                             minx=((struct impDraw *)msg)->imp_Offset.X+((struct Image *)object)->LeftEdge;
  1505.                             miny=((struct impDraw *)msg)->imp_Offset.Y+((struct Image *)object)->TopEdge;
  1506.                             maxx=minx+((struct Image *)object)->Width -1;
  1507.                             maxy=miny+((struct Image *)object)->Height-1;
  1508.                             if(XStyle)
  1509.                             {
  1510.                                 if(((struct impDraw *)msg)->imp_State==IDS_SELECTED) draw_frame (rp,minx,miny,maxx,maxy,pens[HALFSHADOWPEN],pens[SHINEPEN],pens[HALFSHADOWPEN],pens[SHINEPEN],pens[HALFSHINEPEN],TRUE);
  1511.                                 else                              draw_frame (rp,minx,miny,maxx,maxy,pens[SHINEPEN],pens[HALFSHADOWPEN],pens[SHINEPEN],pens[HALFSHADOWPEN],pens[HALFSHINEPEN],TRUE);
  1512.                             }
  1513.                             else
  1514.                             {
  1515.                                 if(((struct impDraw *)msg)->imp_State==IDS_SELECTED) draw_frame (rp,minx,miny,maxx,maxy,pens[SHADOWPEN],pens[SHADOWPEN],pens[HALFSHADOWPEN],pens[SHINEPEN],pens[HALFSHINEPEN],TRUE);
  1516.                                 else                              draw_frame (rp,minx,miny,maxx,maxy,pens[SHADOWPEN],pens[SHADOWPEN],pens[SHINEPEN],pens[HALFSHADOWPEN],pens[HALFSHINEPEN],TRUE);
  1517.                             }
  1518.                             if(((struct impDraw *)msg)->imp_State==IDS_SELECTED)
  1519.                             {
  1520.                                 SetAPen(rp,pens[FILLPEN]);
  1521.                                 if(((maxx-minx)>5)&&((maxy-miny)>5)) RectFill(rp,minx+3,miny+3,maxx-3,maxy-3);
  1522.                             }
  1523.                         }
  1524.                         return(TRUE);
  1525.                         break;
  1526.                 default:
  1527.                         if(sysihackstyle)
  1528.                         {
  1529.                             return(DrawSysiHack(data,((struct impDraw *)msg),object,cl,msg));
  1530.                         }
  1531.                         else
  1532.                         {
  1533.                             return(DrawUrou    (data,((struct impDraw *)msg),object,cl,msg));
  1534.                         }
  1535.                         break;
  1536.             }
  1537.         }
  1538.         BOOPSI_Method_SuperReturn
  1539.     }
  1540.     BOOPSI_Method_End
  1541.  
  1542.     BOOPSI_Method(OM_DISPOSE)
  1543.         struct MsgPort *port;
  1544.  
  1545.         BOOPSI_InitData;
  1546.         if(data->dtobj)
  1547.         if(port= CreatePort(0,0))
  1548.         {
  1549.             struct iht_msg  *imsg;
  1550.             if(imsg = (struct iht_msg *)AllocVecPooled(swim_in_my_pool,sizeof(struct iht_msg)))
  1551.             {
  1552.                 imsg->ts_Message.mn_Node.ln_Type  = NT_MESSAGE;
  1553.                 imsg->ts_Message.mn_ReplyPort     = port;
  1554.                 imsg->ts_Message.mn_Length        = sizeof ( struct iht_msg );
  1555.                 imsg->object                      = data->dtobj;
  1556.                 imsg->MethodID                    = IML_FREE;
  1557.                 if(PutToPort(imsg))
  1558.                 {
  1559.                     WaitPort(port);
  1560.                     GetMsg(port);
  1561.                 }
  1562.                 FreeVecPooled(imsg);
  1563.             }
  1564.             DeletePort(port);
  1565.         }
  1566.         BOOPSI_Method_SuperReturn
  1567.     BOOPSI_Method_End
  1568.  
  1569.     BOOPSI_Method_SuperDefault
  1570.  
  1571. BOOPSI_End
  1572.  
  1573. /************************************************************************/
  1574. /* Patched functions                                                    */
  1575. /************************************************************************/
  1576.  
  1577. ULONG  oldAGRoutine;
  1578. extern newAGRoutine();
  1579. ULONG  oldAGLRoutine;
  1580. extern newAGLRoutine();
  1581. ULONG  oldNMPRoutine;
  1582. extern newNMPRoutine();
  1583. ULONG  oldOTLRoutine;
  1584. extern newOTLRoutine();
  1585. ULONG  oldOSRoutine;
  1586. extern newOSRoutine();
  1587. ULONG  oldCSRoutine;
  1588. extern newCSRoutine();
  1589. ULONG  oldOWTLRoutine;
  1590. extern newOWTLRoutine();
  1591. ULONG  oldOWRoutine;
  1592. extern newOWRoutine();
  1593.  
  1594. fail()
  1595. {
  1596.     PutStr("***uRøURAçK sUCKS! Please run it before any screen was opened or IPrefs was started!\n\nPlease reboot your machine now, the system could be unstable!");
  1597.     exit(0);
  1598. }
  1599.  
  1600. enum{SCRFIL,IMG_STYLE,WIN_TOP,WIN_BOT,WIN_LEF,WIN_RIG,FINBOT,FINRIG,PATFRAME,PATSYSI,ONLYWIN,TRYMWB,SYSISTYLE,XWIN,ONLYWB,ARG_COUNT};
  1601. #define ARGTEMPLATE "SCREENFILE,IMGSTYLE/K,WTOP/K/N,WBOTTOM/K/N,WLEFT/K/N,WRIGHT/K/N,SBOTTOM/K/N,SRIGHT/K/N,NOFRAME/S,NOSYSI/S,ONLYWINIMG/S,TRYMAGICWB/S,SYSIHACK/S,XWIN/S,ONLYWB/S"
  1602.  
  1603. enum{SCRNAME,SCRPEN1,SCRPEN2,SCRPEN3,SCRPEN4,ALLMWB,SCRARG_COUNT};
  1604. #define SCRARGTMPL "SCREEN,PEN1/N,PEN2/N,PEN3/N,PEN4/N,ALLOCATEMWB/S"
  1605.  
  1606. getscreenlist(char *filename)
  1607. {
  1608.     BPTR    file;
  1609.     STRPTR  *ArgArray;
  1610.     char    *line,*name;
  1611.  
  1612.     if(line=(char *)AllocVecPooled(swim_in_my_pool,256L))
  1613.     {
  1614.         if(file=(BPTR)Open(filename,MODE_OLDFILE))
  1615.         {
  1616.             int i=0;
  1617.             while(FGets(file,line,255))
  1618.             {
  1619.                 i++;
  1620.                 if(penlist[i]=(struct NewPenStruct *)AllocVecPooled(swim_in_my_pool,sizeof(struct NewPenStruct)))
  1621.                 {
  1622.                     if(ArgArray = (STRPTR *)AllocVecPooled(swim_in_my_pool,(sizeof(STRPTR) * (SCRARG_COUNT)) + 16L))
  1623.                     {
  1624.                         struct RDArgs *rd;
  1625.                         if(rd=(struct RDArgs *)AllocDosObject(DOS_RDARGS,TAG_DONE))
  1626.                         {
  1627.                             rd->RDA_Source.CS_Buffer=line;
  1628.                             rd->RDA_Source.CS_Length=strlen(line);
  1629.                             rd->RDA_Source.CS_CurChr=0L;
  1630.  
  1631.                             if(ReadArgs(SCRARGTMPL,(LONG *)ArgArray,rd))
  1632.                             {
  1633.                                 if(ArgArray[SCRNAME])
  1634.                                 {
  1635.                                     if(name = (char *)ArgArray[SCRNAME])
  1636.                                     {
  1637.                                         if(namelist[i]=(char *)AllocVecPooled(swim_in_my_pool,strlen(name)+1L))
  1638.                                         {
  1639.                                             strcpy(namelist[i],name);
  1640.                                         }
  1641.                                     }
  1642.                                 }
  1643.                                 if(ArgArray[SCRPEN1])
  1644.                                 {
  1645.                                     penlist[i]->halfdark   = (UWORD)(*(LONG *)ArgArray[SCRPEN1])&0xFFFF;
  1646.                                 }
  1647.                                 if(ArgArray[SCRPEN2])
  1648.                                 {
  1649.                                     penlist[i]->halfshine  = (UWORD)(*(LONG *)ArgArray[SCRPEN2])&0xFFFF;
  1650.                                 }
  1651.                                 if(ArgArray[SCRPEN3])
  1652.                                 {
  1653.                                     penlist[i]->darkpaint  = (UWORD)(*(LONG *)ArgArray[SCRPEN3])&0xFFFF;
  1654.                                 }
  1655.                                 if(ArgArray[SCRPEN4])
  1656.                                 {
  1657.                                     penlist[i]->shinepaint = (UWORD)(*(LONG *)ArgArray[SCRPEN4])&0xFFFF;
  1658.                                 }
  1659.                                 if(ArgArray[ALLMWB])
  1660.                                 {
  1661.                                     exttrymwb[i]=TRUE;
  1662.                                 }
  1663.                                 FreeArgs(rd);
  1664.                             }
  1665.                             FreeDosObject(rd);
  1666.                         }
  1667.                         FreeVecPooled(ArgArray);
  1668.                     }
  1669.                 }
  1670.             }
  1671.             Close(file);
  1672.         }
  1673.         else PutStr("***UROUHACK: Could not open screenlist file!");
  1674.         FreeVecPooled(line);
  1675.     }
  1676. }
  1677.  
  1678. getconfig()
  1679. {
  1680.     ULONG *ArgArray;
  1681.     if(ArgArray = (STRPTR *)AllocVecPooled(swim_in_my_pool,(sizeof(ULONG)*(ARG_COUNT)) + 16L))
  1682.     {
  1683.         struct RDArgs *rd;
  1684.         if(rd=(struct RDArgs *)ReadArgs(ARGTEMPLATE,(LONG *)ArgArray,NULL))
  1685.         {
  1686.             if(ArgArray[SCRFIL])
  1687.             {
  1688.                 getscreenlist((char *)ArgArray[SCRFIL]);
  1689.             }
  1690.             if(ArgArray[IMG_STYLE])
  1691.             {
  1692.                 if(imagestyle=(char *)AllocVecPooled(swim_in_my_pool,strlen(ArgArray[IMG_STYLE])+4L))
  1693.                 {
  1694.                     strcpy(imagestyle,ArgArray[IMG_STYLE]);
  1695.                 }
  1696.             }
  1697.             if(ArgArray[WIN_TOP])
  1698.             {
  1699.                 b_top = (BYTE)(*(LONG *)ArgArray[WIN_TOP])&0xFF;
  1700.             }
  1701.             if(ArgArray[WIN_BOT])
  1702.             {
  1703.                 b_bottom = (BYTE)(*(LONG *)ArgArray[WIN_BOT])&0xFF;
  1704.             }
  1705.             if(ArgArray[WIN_LEF])
  1706.             {
  1707.                 b_left = (BYTE)(*(LONG *)ArgArray[WIN_LEF])&0xFF;
  1708.             }
  1709.             if(ArgArray[WIN_RIG])
  1710.             {
  1711.                 b_right = (BYTE)(*(LONG *)ArgArray[WIN_RIG])&0xFF;
  1712.             }
  1713.             if(ArgArray[FINBOT])
  1714.             {
  1715.                 b_height = (*(LONG *)ArgArray[FINBOT])&0xFF;
  1716.             }
  1717.             if(ArgArray[FINRIG])
  1718.             {
  1719.                 b_width = (*(LONG *)ArgArray[FINBOT])&0xFF;
  1720.             }
  1721.             if(ArgArray[PATFRAME])
  1722.             {
  1723.                 pframes=FALSE;
  1724.             }
  1725.             if(ArgArray[PATSYSI])
  1726.             {
  1727.                 psysi=FALSE;
  1728.             }
  1729.             if(ArgArray[ONLYWIN])
  1730.             {
  1731.                 pwin=FALSE;
  1732.             }
  1733.             if(ArgArray[TRYMWB])
  1734.             {
  1735.                 trymwb=TRUE;
  1736.             }
  1737.             if(ArgArray[SYSISTYLE])
  1738.             {
  1739.                 sysihackstyle=TRUE;
  1740.             }
  1741.             if(ArgArray[XWIN])
  1742.             {
  1743.                 XStyle=TRUE;
  1744.             }
  1745.             if(ArgArray[ONLYWB])
  1746.             {
  1747.                 onlywb=TRUE;
  1748.             }
  1749.             FreeArgs(rd);
  1750.         }
  1751.         else PutStr("***UROUHACK: Unknown arguments or error in commandline!");
  1752.         FreeVecPooled(ArgArray);
  1753.     }
  1754. }
  1755.  
  1756. void main(int argc, char *argv[])
  1757. {
  1758.     Class       *my_cl,
  1759.                 *oldcl;
  1760.     Object      *g;
  1761.  
  1762.     if(swim_in_my_pool=(ULONG *)CreatePool(MEMF_CLEAR|MEMF_PUBLIC,8192L,4096L))
  1763.     {
  1764.         getconfig();
  1765.  
  1766.         Forbid();
  1767.         oldOTLRoutine = SetFunction(IntuitionBase,(WORD)-612,newOTLRoutine);
  1768.         oldOSRoutine  = SetFunction(IntuitionBase,(WORD)-198,newOSRoutine);
  1769.         oldCSRoutine  = SetFunction(IntuitionBase,(WORD)-66 ,newCSRoutine);
  1770.         Permit();
  1771.  
  1772.         if(pframes)
  1773.         {
  1774.             if( g=(Object *)NewObject(NULL,"frameiclass",IA_Width,10,IA_Height,10, TAG_DONE))
  1775.             {
  1776.                 oldcl=OCLASS(g); DisposeObject(g);
  1777.                 Forbid();
  1778.  
  1779.                 oldcl->cl_ID="breizhclass";
  1780.  
  1781.                 if(my_cl=initFRAMEClass())
  1782.                 {
  1783.                     AddClass(my_cl);
  1784.                     Permit();
  1785.                 }
  1786.                 else fail();
  1787.             }
  1788.             else fail();
  1789.         }
  1790.         if(psysi)
  1791.         {
  1792.             DataTypesBase=(struct Library *)2L;
  1793.             if(CreateNewProcTags(
  1794.                     NP_Entry,       ImageLoaderTask,
  1795.                     NP_Name,        "UrouHack ImageLoaderProcess",
  1796.                     NP_Priority,    0,
  1797.                     TAG_DONE
  1798.               ))
  1799.             {
  1800.                 static UWORD   pens[8];
  1801.                 static struct  TextAttr topaz_font = { "topaz.font", 8, 0, FPF_ROMFONT, };
  1802.                 static struct  DrawInfo mydrawinfo = { DRI_VERSION, 9, &pens[BACKGROUNDPEN], 0, 2, 1, 1, NULL, NULL, NULL, 0, 0, 0, 0, 0 };
  1803.  
  1804.                 mydrawinfo.dri_Font=(struct TextFont *)OpenFont(&topaz_font);
  1805.  
  1806.                 Forbid();
  1807.                 oldOWTLRoutine= SetFunction(IntuitionBase,(WORD)-606,newOWTLRoutine);
  1808.                 oldOWRoutine  = SetFunction(IntuitionBase,(WORD)-204,newOWRoutine);
  1809.                 Permit();
  1810.  
  1811.                 if( g=(Object *)NewObject(NULL, "sysiclass", SYSIA_Which, RIGHTIMAGE, SYSIA_DrawInfo, &mydrawinfo, TAG_DONE))
  1812.                 {
  1813.                     oldcl=OCLASS(g); DisposeObject(g);
  1814.                     Forbid();
  1815.  
  1816.                     oldcl->cl_ID="urouclass";
  1817.  
  1818.                     if(my_cl=initSYSIClass())
  1819.                     {
  1820.                         AddClass(my_cl);
  1821.                         Permit();
  1822.                     }
  1823.                     else fail();
  1824.  
  1825.                 }
  1826.                 else fail();
  1827.  
  1828.                 if( g=(Object *)NewObject(NULL,"buttongclass",GA_Width,10,GA_Height,10,TAG_DONE))
  1829.                 {
  1830.                     oldcl=OCLASS(g); DisposeObject(g);
  1831.                     Forbid();
  1832.  
  1833.                     oldcl->cl_ID="tinicclass";
  1834.  
  1835.                     if(my_cl=initGADClass())
  1836.                     {
  1837.                         AddClass(my_cl);
  1838.                         Permit();
  1839.                     }
  1840.                     else fail();
  1841.                 }
  1842.                 else fail();
  1843.  
  1844.                 oldAGRoutine = SetFunction(IntuitionBase,(WORD)-42, newAGRoutine);
  1845.             }
  1846.         }
  1847.         if(Cli()) ((struct CommandLineInterface *)Cli())->cli_Module=0L; /* That wwas a good tip ;-)) */
  1848.         else      Wait(0L);
  1849.     }
  1850.     else PutStr("***UROUHACK: Could not create memory pool!");
  1851. }
  1852.  
  1853.