home *** CD-ROM | disk | FTP | other *** search
/ The Best of Mecomp Multimedia 1 / Mecomp-CD.iso / amiga / tools / utillities / tinymeter / source / tinymeter_main / launchclass.c < prev    next >
C/C++ Source or Header  |  1996-05-31  |  16KB  |  547 lines
  1. #include <exec/types.h>
  2. #include <exec/memory.h>
  3. #include <dos/dos.h>
  4. #include <dos/dosextens.h>
  5. #include <intuition/intuition.h>
  6. #include <intuition/gadgetclass.h>
  7. #include <intuition/intuitionbase.h>
  8. #include <intuition/classusr.h>
  9. #include <intuition/imageclass.h>
  10. #include <intuition/gadgetclass.h>
  11. #include <intuition/cghooks.h>
  12. #include <intuition/icclass.h>
  13. #include <intuition/classes.h>
  14. #include <intuition/sghooks.h>
  15. #include <intuition/screens.h>
  16. #include <graphics/gfxbase.h>
  17. #include <graphics/text.h>
  18. #include <graphics/gfxmacros.h>
  19. #include <utility/tagitem.h>
  20. #include <utility/hooks.h>
  21. #include <datatypes/datatypesclass.h>
  22. #include <datatypes/datatypes.h>
  23. #include <datatypes/pictureclass.h>
  24. #include <string.h>
  25. #include "launchclass.h"
  26. #include "tinymeter.h"
  27.  
  28. #define err_nolis       7
  29.  
  30. #define col_entry       1
  31. #define col_hbright     2
  32. #define col_hdark       3
  33. #define col_cursor      4
  34.  
  35. struct LauncherData
  36. {
  37.     struct  Screen *scr;
  38.     char    *txtlbl;
  39.     char    *file;
  40.     struct  LAU_Color Colors[LAU_UsedColors+1];
  41.     BOOL    Style3D;
  42.     BOOL    StyleBorder;
  43.     BOOL    StyleBackground;
  44.     BOOL    StyleShadowLabel;
  45.     BOOL    StyleTransparent;
  46.     struct  TextFont *textFont;
  47.     ULONG   Pens[LAU_UsedColors];
  48.     BOOL    PorC[LAU_UsedColors];
  49.     BOOL    InitNotDone;
  50.     UWORD   text_y;
  51.     UWORD   indent;
  52.     struct  lau_entry *list;
  53.     ULONG   x_pos;
  54.     ULONG   down;
  55.     ULONG   diswhat;
  56.     Object  *img;
  57. };
  58.  
  59. __saveds ULONG dispatchLauncherGadget(Class *cl,Object *o, Msg msg)
  60. {
  61.     switch( msg->MethodID )
  62.     {
  63.     case    OM_NEW:
  64.         if(o = (Object *)DoSuperMethodA(cl, o, msg) )
  65.         {
  66.             newLauncher(cl,(struct Gadget *)o,(struct gpRender *)msg);
  67.         }
  68.         return((ULONG)o);
  69.     case    GM_RENDER:
  70.         return(renderLauncher(cl,(struct Gadget *)o,(struct gpRender *)msg));
  71.     case    OM_SET:
  72.         setLauncher((Class *)cl,(struct Gadget *)o,(struct gpRender *)msg);
  73.         return(DoSuperMethodA(cl,o,msg));
  74.     case    OM_GET:
  75.         return((ULONG)getLauncher(cl,(struct Gadget *)o,(struct gpRender *)msg));
  76.     case    GM_HITTEST:
  77.         return(GMR_GADGETHIT);
  78.     case    GM_GOACTIVE:
  79.         if( ((struct gpInput *)msg)->gpi_IEvent )
  80.         {
  81.             struct LauncherData *inst=INST_DATA(cl,o);
  82.             ((struct Gadget *)o)->Flags |= GFLG_SELECTED;
  83.             if(inst->diswhat!=typ_iconlauncher) renderLauncher(cl,(struct Gadget *)o, (struct gpRender *)msg);
  84.             return(GMR_MEACTIVE);
  85.         }
  86.         return(GMR_NOREUSE);
  87.     case    GM_GOINACTIVE:
  88.         {
  89.             struct LauncherData *inst=INST_DATA(cl,o);
  90.             ((struct Gadget *)o)->Flags &= ~GFLG_SELECTED;
  91.             if(inst->diswhat!=typ_iconlauncher) renderLauncher(cl,(struct Gadget *) o, (struct gpRender *)msg);
  92.         }
  93.         return(NULL);
  94.     case    GM_HANDLEINPUT:
  95.         {
  96.             struct Gadget *g = (struct Gadget *)o;
  97.             struct gpInput *gpi = (struct gpInput *)msg;
  98.             struct InputEvent *ie = gpi->gpi_IEvent;
  99.             ULONG  retval=GMR_MEACTIVE;
  100.  
  101.             if( ie->ie_Class==IECLASS_RAWMOUSE)
  102.             {
  103.             switch( ie->ie_Code )
  104.             {
  105.                 case SELECTUP:
  106.                     if( (gpi->gpi_Mouse.X < g->LeftEdge ) ||
  107.                     (gpi->gpi_Mouse.X > g->LeftEdge + g->Width) ||
  108.                     (gpi->gpi_Mouse.Y < g->TopEdge ) ||
  109.                     (gpi->gpi_Mouse.Y > g->TopEdge  + g->Height) )
  110.                     {
  111.                         retval= GMR_NOREUSE | GMR_VERIFY;
  112.                     }
  113.                     else    retval= GMR_NOREUSE ;
  114.                     break;
  115.                 case MENUUP:
  116.                 case MENUDOWN:
  117.                     retval=GMR_NOREUSE;
  118.                     break;
  119.                 default:
  120.                     retval=GMR_MEACTIVE;
  121.                     break;
  122.             }
  123.             }
  124.             return(retval);
  125.         }
  126.     case    OM_DISPOSE:
  127.         {
  128.             struct lau_entry *entry;
  129.             struct LauncherData *inst=INST_DATA(cl,o);
  130.             int w;
  131.             if(inst->diswhat!=typ_iconlauncher) for(w=0;w<LAU_UsedColors;w++)FreePenNew(inst->scr,&inst->Colors[w],w,inst->Pens);
  132.             pFreeVec((ULONG *)inst->txtlbl);
  133.             DisposeDTObject(inst->img);
  134.             while(inst->list)
  135.             {
  136.             entry = inst->list->next;
  137.             DisposeDTObject(inst->list->img);
  138.             pFreeVec  ((ULONG *)inst->list->lau_lbl);
  139.             pFreeVec  ((ULONG *)inst->list->lau_cmd);
  140.             pFreeVec  ((ULONG *)inst->list->lau_pth);
  141.             pFreeVec  ((ULONG *)inst->list->lau_out);
  142.             pFreeVec  ((ULONG *)inst->list);
  143.             inst->list=entry;
  144.             }
  145.         }
  146.     default:
  147.         return(DoSuperMethodA(cl,o,msg));
  148.     }
  149. }
  150.  
  151. Class *initLauncherGadgetClass(void)
  152. {
  153.     Class *cl;
  154.     if( cl = (Class *)MakeClass( NULL, "gadgetclass", NULL, sizeof(struct LauncherData), 0) )
  155.     {
  156.     cl->cl_Dispatcher.h_Entry    = HookEntry;
  157.     cl->cl_Dispatcher.h_SubEntry = (HOOKFUNC)dispatchLauncherGadget;
  158.     }
  159.     return(cl);
  160. }
  161.  
  162. void setLauncher(Class *cl,struct Gadget *g,struct gpRender *msg)
  163. {
  164.     struct LauncherData    *inst=INST_DATA(cl,g);
  165.     if ( FindTagItem(GA_Width,  ((struct opSet *)msg)->ops_AttrList) ||
  166.      FindTagItem(GA_Height, ((struct opSet *)msg)->ops_AttrList) ||
  167.      FindTagItem(GA_Top,    ((struct opSet *)msg)->ops_AttrList) ||
  168.      FindTagItem(GA_Left,   ((struct opSet *)msg)->ops_AttrList) )
  169.     {
  170.     inst->InitNotDone=TRUE;
  171.     }
  172. }
  173.  
  174. ULONG getLauncher(Class *cl,struct Gadget *g,struct gpRender *msg)
  175. {
  176.     struct LauncherData *inst=INST_DATA(cl,g);
  177.     switch (((struct opGet *)msg)->opg_AttrID)
  178.     {
  179.     case    LAU_Down:
  180.         *(((struct opGet *)msg)->opg_Storage)=(ULONG)inst->down;
  181.         break;
  182.     case    LAU_List:
  183.         *(((struct opGet *)msg)->opg_Storage)=(ULONG)inst->list;
  184.         break;
  185.     case    LAU_ColLabel:
  186.         *(((struct opGet *)msg)->opg_Storage)=(ULONG)inst->Pens[0];
  187.         break;
  188.     case    LAU_ColEntry:
  189.         *(((struct opGet *)msg)->opg_Storage)=(ULONG)inst->Pens[1];
  190.         break;
  191.     case    LAU_ColHalfBright:
  192.         *(((struct opGet *)msg)->opg_Storage)=(ULONG)inst->Pens[2];
  193.         break;
  194.     case    LAU_ColHalfShadow:
  195.         *(((struct opGet *)msg)->opg_Storage)=(ULONG)inst->Pens[3];
  196.         break;
  197.     case    LAU_ColCursor:
  198.         *(((struct opGet *)msg)->opg_Storage)=(ULONG)inst->Pens[4];
  199.         break;
  200.     case    LAU_ColBrightEdg:
  201.         *(((struct opGet *)msg)->opg_Storage)=(ULONG)inst->Pens[5];
  202.         break;
  203.     case    LAU_ColDarkEdg:
  204.         *(((struct opGet *)msg)->opg_Storage)=(ULONG)inst->Pens[6];
  205.         break;
  206.     case    LAU_ColBackground:
  207.         *(((struct opGet *)msg)->opg_Storage)=(ULONG)inst->Pens[7];
  208.         break;
  209.     case    LAU_Type:
  210.         *(((struct opGet *)msg)->opg_Storage)=(ULONG)inst->diswhat;
  211.         break;
  212.     case    LAU_Transparent:
  213.         *(((struct opGet *)msg)->opg_Storage)=(ULONG)inst->StyleTransparent;
  214.         break;
  215.     case    LAU_XPos:
  216.         *(((struct opGet *)msg)->opg_Storage)=(ULONG)inst->x_pos;
  217.         break;
  218.     case    LAU_ImgHeight:
  219.         {
  220.             struct BitMapHeader *bmhd;
  221.             if(inst->img)
  222.             {
  223.             GetDTAttrs(inst->img,PDTA_BitMapHeader,&bmhd,TAG_DONE);
  224.             *(((struct opGet *)msg)->opg_Storage)=(ULONG)bmhd->bmh_Height;
  225.             }
  226.             else *(((struct opGet *)msg)->opg_Storage)=0L;
  227.         }
  228.         break;
  229.     default:
  230.         *(((struct opGet *)msg)->opg_Storage)=0;
  231.         break;
  232.     }
  233.     return((ULONG)TRUE);
  234. }
  235.  
  236.  
  237. BOOL freeLauncherGadgetClass( Class *cl )
  238. {
  239.     return(FreeClass(cl));
  240. }
  241.  
  242. void CleanString(char *buffer)
  243. {
  244.     int i=my_strlen(buffer);
  245.     if(i>0)
  246.     if(buffer[i-1]==0x0a) buffer[i-1]=0x00;
  247. }
  248.  
  249. void StripSpaces(char *src, char *dest)
  250. {
  251.     int  i,j,len=my_strlen(src);
  252.     BOOL foo=FALSE;
  253.     if(len>0)
  254.     {
  255.     if(src[len-1]==0x20)
  256.     {
  257.         for(i=len-1;i>-1;i--)
  258.         if(src[i]==0x20)
  259.             src[i]=0x0;
  260.             else break;
  261.     }
  262.     for(i=0,j=0;i<len;i++) if((src[i]!=0x20)||(foo==TRUE))
  263.     {
  264.         if(src[i]!=0x0a) dest[j++]=src[i]; foo=TRUE;
  265.     }
  266.     dest[j]=0x00;
  267.     }
  268.     else dest[0]=0x00;
  269. }
  270.  
  271. void CopyString(char *src, char **dest, struct LauncherData *inst)
  272. {
  273.     if(my_strlen(src))
  274.     {
  275.     *dest=(char *)pAllocVec(my_strlen(src)+1L);
  276.     StripSpaces(src,*dest);
  277.     }
  278.     else *dest=(char *)pAllocVec(1L);
  279. }
  280.  
  281. ULONG newLauncher(Class *cl,struct Gadget *g,struct gpRender *msg)
  282. {
  283.     struct   TagItem *ti;
  284.     struct   LauncherData *inst=INST_DATA(cl,g);
  285.     BPTR     file;
  286.  
  287.     ti      = ((struct opSet *)msg)->ops_AttrList;
  288.     if(inst->scr = (struct Screen *)GetTagData(LAU_Screen, 0, ti))
  289.     {
  290.     if(inst->textFont = (struct TextFont *)GetTagData(LAU_TextFont,(ULONG)OpenTopaz(),ti))
  291.     {
  292.         char *dummy;
  293.         if(dummy=(char *)pAllocVec(256L))
  294.         {
  295.         int     i;
  296.         UWORD   def_pens[]={ 2, 2, 1, 3, 1, 2, 1, 0 };
  297.         ULONG   lau_tags[]={LAU_ColLabel,LAU_ColEntry,LAU_ColHalfBright,LAU_ColHalfShadow,LAU_ColCursor,LAU_ColBrightEdg,LAU_ColDarkEdg,LAU_ColBackground};
  298.  
  299.         inst->file              = (char *)GetTagData(LAU_File,(ULONG)" ", ti);
  300.         inst->Style3D           = GetTagData(LAU_3D,  TRUE, ti);
  301.         inst->StyleBorder       = GetTagData(LAU_Border, TRUE, ti);
  302.         inst->StyleBackground   = GetTagData(LAU_Background, FALSE, ti);
  303.         inst->StyleShadowLabel  = GetTagData(LAU_ShadowLabel, FALSE, ti);
  304.         inst->StyleTransparent  = GetTagData(LAU_Transparent, FALSE, ti);
  305.         inst->down              = GetTagData(LAU_Down, FALSE, ti);
  306.         inst->indent            = GetTagData(LAU_Indent, lind_realcenter, ti);
  307.         inst->diswhat           = GetTagData(LAU_Type, 0, ti);
  308.         for(i=0;i<LAU_UsedColors;i++) CopyMem((APTR)GetTagData(lau_tags[i],(ULONG)GetGaugePen(def_pens[i]), ti),(APTR)&inst->Colors[i], sizeof(struct LAU_Color));
  309.         inst->InitNotDone=TRUE;
  310.         if(file=Open(inst->file,MODE_OLDFILE))
  311.         {
  312.             if(FGets(file,dummy,254))
  313.             {
  314.             if(*((ULONG *)dummy)==0x544D4C49)
  315.             {
  316.                 if(FGets(file,dummy,254))
  317.                 {
  318.                 CopyString(dummy,&inst->txtlbl,inst);
  319.                 if(FGets(file,dummy,254))
  320.                 {
  321.                     CleanString(dummy);
  322.                     if(dummy[0])inst->img=(Object *)LoadImage(dummy,inst->scr);
  323.                     else        inst->img=0L;
  324.                     if(inst->list=(struct lau_entry *)pAllocVec(sizeof(struct lau_entry)))
  325.                     {
  326.                     struct lau_entry *oldentry,*actentry=inst->list;
  327.                     while(FGets(file,dummy,32))
  328.                     {
  329.                         CopyString(dummy,&actentry->lau_lbl,inst);
  330.                         FGets(file,dummy,254);
  331.                         CopyString(dummy,&actentry->lau_cmd,inst);
  332.                         FGets(file,dummy,8);
  333.                         CleanString(dummy);
  334.                         actentry->lau_type=dummy[0]-0x30;
  335.                         FGets(file,dummy,254);
  336.                         CopyString(dummy,&actentry->lau_pth,inst);
  337.                         FGets(file,dummy,254);
  338.                         CopyString(dummy,&actentry->lau_out,inst);
  339.                         FGets(file,dummy,16);
  340.                         CleanString(dummy);
  341.                         {
  342.                         LONG i,len=my_strlen(dummy),j=1,out=0L;
  343.                         if(len>0) /* Shit... that was a trap... */
  344.                         for(i=len-1;i>-1;i--)
  345.                         {
  346.                             if((dummy[i]>0x29)&&(dummy[i]<0x3A))
  347.                             {
  348.                             out+=((dummy[i]-0x30)*j); j*=10;
  349.                             }
  350.                         }
  351.                         actentry->lau_stack=out;
  352.                         }
  353.                         FGets(file,dummy,254);
  354.                         CleanString(dummy);
  355.                         if(dummy[0]) actentry->img=(Object *)LoadImage(dummy,inst->scr);
  356.                         else         actentry->img=0L;
  357.                         oldentry=actentry;
  358.                         actentry=(struct lau_entry *)pAllocVec(sizeof(struct lau_entry));
  359.                         oldentry->next=actentry;
  360.                     }
  361.                     pFreeVec((ULONG *)actentry);
  362.                     oldentry->next=NULL;
  363.                     }
  364.                     else
  365.                     {
  366.                     pFreeVec((ULONG *)inst->list);
  367.                     inst->list=NULL;
  368.                     }
  369.                 }
  370.                 }
  371.                 else show(err_nolis);
  372.             }
  373.             else show(err_nolis);
  374.             }
  375.             else show(err_nolis);
  376.             Close(file);
  377.         }
  378.         pFreeVec((ULONG *)dummy);
  379.         return((ULONG)g);
  380.         }
  381.     }
  382.     }
  383.     return(0L);
  384. }
  385.  
  386. ULONG renderLauncher(Class *cl,struct Gadget *g,struct gpRender *msg)
  387. {
  388.     struct RastPort         *rp;
  389.     struct BitMapHeader     *bmhd;
  390.     struct LauncherData     *inst=INST_DATA(cl,(Object *)g);
  391.  
  392.     if(msg->gpr_GInfo)
  393.     if(rp = ( msg->MethodID == GM_RENDER ) ? msg->gpr_RPort : (struct RastPort *) ObtainGIRPort(msg->gpr_GInfo) )
  394.     {
  395.     switch (inst->diswhat)
  396.     {
  397.         case    typ_simplelauncher:
  398.             {
  399.             UWORD text_x,w,t_length;
  400.             if(inst->InitNotDone) for(w=0;w<LAU_UsedColors;w++) GetPenNew(msg->gpr_GInfo->gi_Screen,&inst->Colors[w],w,inst->PorC,inst->Pens);
  401.  
  402.             SetDrMd(rp,JAM1);
  403.             SetFont(rp,inst->textFont);
  404.  
  405.             inst->text_y=((g->Height-((inst->textFont->tf_Baseline+inst->textFont->tf_YSize)>>1))>>1);
  406.             if(inst->textFont->tf_Baseline<inst->textFont->tf_YSize)
  407.             {
  408.                 inst->text_y+=inst->textFont->tf_Baseline-1;
  409.                 if(inst->text_y<inst->textFont->tf_Baseline)inst->text_y=inst->textFont->tf_Baseline;
  410.             }
  411.             else
  412.             {
  413.                 inst->text_y+=inst->textFont->tf_YSize-1;
  414.                 if(inst->text_y<inst->textFont->tf_YSize)   inst->text_y=inst->textFont->tf_YSize;
  415.             }
  416.             SetAPen(rp,inst->Pens[col_bg]);
  417.             if(inst->StyleBackground) my_RectFill(rp,g->LeftEdge,g->TopEdge,g->Width,g->Height);
  418.             if(inst->img)
  419.             {
  420.                 UWORD y,height,ypos;
  421.                 GetDTAttrs(inst->img,PDTA_BitMapHeader,&bmhd,TAG_DONE);
  422.                 if(bmhd->bmh_Height>(g->Height-6))
  423.                 {
  424.                 height=(g->Height-6);
  425.                 y=(bmhd->bmh_Height-height)>>1;
  426.                 ypos=3;
  427.                 }
  428.                 else
  429.                 {
  430.                 height=bmhd->bmh_Height;
  431.                 y=0;
  432.                 ypos=(g->Height/2)-(height/2);
  433.                 }
  434.                 DrawDTObject(inst->img,0,y,rp,g->LeftEdge+4,g->TopEdge+ypos,-1,height,inst->StyleTransparent);
  435.             }
  436.             if(inst->StyleBorder)
  437.             {
  438.                 if(inst->Style3D)
  439.                 {
  440.                 draw_border_new(rp,g->LeftEdge,g->TopEdge,g->Width,g->Height,inst->Pens[col_dark],inst->Pens[col_dark]);
  441.                 if(g->Flags & GFLG_SELECTED)draw_border_new(rp,g->LeftEdge+1,g->TopEdge+1,g->Width-2,g->Height-2,inst->Pens[col_hdark],inst->Pens[col_bright]);
  442.                 else                        draw_border_new(rp,g->LeftEdge+1,g->TopEdge+1,g->Width-2,g->Height-2,inst->Pens[col_bright],inst->Pens[col_hdark]);
  443.                 }
  444.                 else
  445.                 {
  446.                 if(g->Flags & GFLG_SELECTED)draw_border_new(rp,g->LeftEdge,g->TopEdge,g->Width,g->Height,inst->Pens[col_hdark],inst->Pens[col_bright]);
  447.                 else                        draw_border_new(rp,g->LeftEdge,g->TopEdge,g->Width,g->Height,inst->Pens[col_bright],inst->Pens[col_hdark]);
  448.                 }
  449.             }
  450.             t_length=TextLength(rp,inst->txtlbl,my_strlen(inst->txtlbl));
  451.             if(t_length<(g->Width - ((inst->indent==lind_left)||(inst->indent==lind_center) ? ( bmhd ? bmhd->bmh_Width : 0 )  : 0)))
  452.             {
  453.                 switch(inst->indent)
  454.                 {
  455.                 case    lind_center:
  456.                     if(bmhd) text_x=bmhd->bmh_Width+((g->Width-t_length-bmhd->bmh_Width)>>1);
  457.                     else     text_x=((g->Width-t_length)>>1);
  458.                     break;
  459.                 case    lind_left:
  460.                     if(bmhd) text_x=bmhd->bmh_Width+11;
  461.                     else     text_x=5;
  462.                     break;
  463.                 case    lind_right:
  464.                     text_x=g->Width-t_length-5;
  465.                     break;
  466.                 default :
  467.                     text_x=((g->Width-t_length)>>1);
  468.                     break;
  469.                 }
  470.                 if(inst->StyleShadowLabel)
  471.                 {
  472.                 SetAPen(rp,inst->Pens[col_dark]);
  473.                 Move(rp,text_x+g->LeftEdge+1,inst->text_y+g->TopEdge+1);
  474.                 Text(rp,inst->txtlbl,my_strlen(inst->txtlbl));
  475.                 }
  476.                 if(g->Flags & GFLG_SELECTED)
  477.                 {
  478.                 Move(rp,text_x+g->LeftEdge+1,inst->text_y+g->TopEdge+1);
  479.                 }
  480.                 else
  481.                 {
  482.                 Move(rp,text_x+g->LeftEdge,inst->text_y+g->TopEdge);
  483.                 }
  484.                 SetAPen(rp,inst->Pens[col_label]);
  485.                 Text(rp,inst->txtlbl,my_strlen(inst->txtlbl));
  486.             }
  487.             }
  488.             break;
  489.         case    typ_iconlauncher:
  490.             {
  491.             struct  lau_entry       *foobar;
  492.             ULONG                   fullness=0;
  493.             if(foobar=inst->list)
  494.             {
  495.                 do
  496.                 {
  497.                 if(foobar->img)
  498.                 {
  499.                     GetDTAttrs(foobar->img,PDTA_BitMapHeader,&bmhd,TAG_DONE);
  500.                     if(bmhd)
  501.                     {
  502.                     if((fullness+bmhd->bmh_Width)>g->Width) break;
  503.                     fullness+=bmhd->bmh_Width;
  504.                     }
  505.                 }
  506.                 }
  507.                 while(foobar=foobar->next);
  508.                 switch (inst->indent)
  509.                 {
  510.                 case    lind_right:
  511.                     inst->x_pos=g->Width-fullness;
  512.                     break;
  513.                 case    lind_left:
  514.                     inst->x_pos=0;
  515.                     break;
  516.                 case    lind_center:
  517.                 default:
  518.                     inst->x_pos=(g->Width-fullness)>>1;
  519.                     break;
  520.                 }
  521.                 foobar=inst->list;
  522.                 fullness=0;
  523.                 do
  524.                 {
  525.                 if(foobar->img)
  526.                 {
  527.                     GetDTAttrs(foobar->img,PDTA_BitMapHeader,&bmhd,TAG_DONE);
  528.                     if(bmhd)
  529.                     {
  530.                     if((fullness+bmhd->bmh_Width)>g->Width) break;;
  531.                     DrawDTObject(foobar->img,0,0,rp,g->LeftEdge+fullness+inst->x_pos,g->TopEdge+((g->Height-bmhd->bmh_Height)>>1),-1,-1,inst->StyleTransparent);
  532.                     fullness+=bmhd->bmh_Width;
  533.                     }
  534.                 }
  535.                 }
  536.                 while(foobar=foobar->next);
  537.             }
  538.             }
  539.             break;
  540.     }
  541.     inst->InitNotDone=FALSE;
  542.     if(msg->MethodID !=GM_RENDER) ReleaseGIRPort(rp);
  543.     return(TRUE);
  544.     }
  545.     return(FALSE);
  546. }
  547.