home *** CD-ROM | disk | FTP | other *** search
/ AmigActive 15 / AACD15.ISO / AACD / Programming / MultiDesktop / sgad.c < prev    next >
Encoding:
C/C++ Source or Header  |  1997-03-27  |  28.3 KB  |  1,221 lines
  1. /* MultiWindows-Gadgets */
  2. #include "multiwindows.h"
  3. #include <math.h>
  4.  
  5. extern struct ExecBase         *SysBase;
  6. extern struct MultiWindowsBase *MultiWindowsBase;
  7.  
  8. void ShowText();
  9. void ShowNumber();
  10. void ShowWheel();
  11. void ShowSelectBox();
  12. void ShowIcon();
  13. void ShowImage();
  14. void UpdateNumber();
  15. void UpdateText();
  16. void UpdateStatus();
  17. struct Image *CenterImage();
  18.  
  19. /* ---- Special-Gadget initialisieren */
  20. struct MWGadget *InitSGadget(gadgetID,helpID,kind,x,y,w,h,textID,flags,extSize)
  21.  ULONG          gadgetID;
  22.  ULONG          helpID;
  23.  UWORD          kind;
  24.  UWORD          x,y,w,h;
  25.  ULONG          textID;
  26.  ULONG          flags;
  27.  ULONG          extSize;
  28. {
  29.  register struct MultiWindowsUser *mw;
  30.  register struct MWGadget         *gad;
  31.  register struct WindowEntry      *we;
  32.  
  33.  USER;
  34.  WE;
  35.  if(we==NULL) return(NULL);
  36.  
  37.  gad=ALLOC2(sizeof(struct MWGadget)+extSize);
  38.  if(gad==NULL) return(NULL);
  39.  if(extSize) gad->ExtData=(ULONG)gad+(ULONG)sizeof(struct MWGadget);
  40.  
  41.  gad->WindowEntry=we;
  42.  gad->GadgetID=gadgetID;
  43.  gad->HelpID=helpID;
  44.  gad->Type=MWGAD_SPECIAL;
  45.  gad->Kind=kind;
  46.  gad->LeftEdge=x;
  47.  gad->TopEdge=y;
  48.  gad->Width=w;
  49.  gad->Height=h;
  50.  gad->NewGadget.ng_LeftEdge=INewX(we,x);
  51.  gad->NewGadget.ng_TopEdge=INewY(we,y);
  52.  gad->NewGadget.ng_Width=INewWidth(we,w);
  53.  gad->NewGadget.ng_Height=INewHeight(we,h);
  54.  gad->NewGadget.ng_GadgetText=FindID(mw->Catalog,textID);
  55.  gad->NewGadget.ng_TextAttr=mw->TextAttr;
  56.  gad->NewGadget.ng_Flags=flags;
  57.  gad->NewGadget.ng_UserData=gad;
  58.  return(gad);
  59. }
  60.  
  61. /* ---- Standard-Gadget initialisieren */
  62. void InitGadget(gad,g,firstTime)
  63.  struct MWGadget *gad;
  64.  struct Gadget   *g;
  65.  BOOL             firstTime;
  66. {
  67.  g->NextGadget=NULL;
  68.  g->LeftEdge=gad->NewGadget.ng_LeftEdge;
  69.  g->TopEdge=gad->NewGadget.ng_TopEdge;
  70.  g->Width=gad->NewGadget.ng_Width;
  71.  g->Height=gad->NewGadget.ng_Height;
  72.  if(firstTime)
  73.   {
  74.    g->Flags=GADGHNONE;
  75.    g->Activation=RELVERIFY|GADGIMMEDIATE;
  76.    g->GadgetType=BOOLGADGET;
  77.    g->GadgetID=0xffff;
  78.    g->UserData=gad;
  79.    gad->Gadget=g;
  80.   }
  81. }
  82.  
  83. /* ---- Text-Gadget zeichnen */
  84. void ShowText(gad)
  85.  struct MWGadget *gad;
  86. {
  87.  struct TextData    *td;
  88.  REGISTER BOOL       rec;
  89.  
  90.  td=gad->ExtData;
  91.  if(!(td->Flags & CTX_NOBORDER))
  92.   {
  93.    if(td->Flags & CGA_RECESSED) rec=TRUE; else rec=FALSE;
  94.    DrawIt(gad->WindowEntry,
  95.           gad->NewGadget.ng_LeftEdge,gad->NewGadget.ng_TopEdge,
  96.           gad->NewGadget.ng_Width,gad->NewGadget.ng_Height,rec,FALSE,FALSE);
  97.   }
  98.  
  99.  WriteMText(gad->WindowEntry,
  100.             gad->NewGadget.ng_LeftEdge+3,gad->NewGadget.ng_TopEdge,
  101.             gad->NewGadget.ng_Width-6,gad->NewGadget.ng_Height,
  102.             gad->TagList[STEXT_TEXT].ti_Data,
  103.             td->Justification,TRUE);
  104.  PrintPP(gad);
  105. }
  106.  
  107. /* ---- Text-Gadget erstellen */
  108. BOOL AddText(gadgetID,helpID,x,y,w,h,textID,flags,text,justification)
  109.  ULONG       gadgetID;
  110.  ULONG       helpID;
  111.  UWORD       x,y,w,h;
  112.  ULONG       textID;
  113.  UWORD       flags;
  114.  UBYTE      *text;
  115.  UBYTE       justification;
  116. {
  117.  struct MWGadget         *gad;
  118.  struct WindowEntry      *we;
  119.  struct TextData         *td;
  120.  
  121.  WE;
  122.  if(we==NULL) return(NULL);
  123.  
  124.  gad=InitSGadget(gadgetID,helpID,STEXT_KIND,x,y,w,h,textID,PlaceText(flags,PLACETEXT_ABOVE),sizeof(struct TextData));
  125.  if(gad==NULL) { NoMemory(); return(FALSE); }
  126.  
  127.  td=gad->ExtData;
  128.  td->Flags=flags;
  129.  td->Justification=justification;
  130.  
  131.  gad->TagList[STEXT_TEXT].ti_Data=text;
  132.  
  133.  if(!we->Iconify) ShowText(gad);
  134.  return(AddMWGadget(gad));
  135. }
  136.  
  137. /* ---- Text-Anzeige abfragen */
  138. UBYTE *AskText(gadgetID)
  139.  ULONG gadgetID;
  140. {
  141.  struct MWGadget    *gad;
  142.  
  143.  gad=GetGadget(gadgetID,MWGAD_SPECIAL,STEXT_KIND);
  144.  if(gad)
  145.    return(gad->TagList[STEXT_TEXT].ti_Data);
  146.  return(0L);
  147. }
  148.  
  149. /* ---- Text-Anzeige updaten */
  150. void UpdateText(gadgetID,text)
  151.  ULONG  gadgetID;
  152.  UBYTE *text;
  153. {
  154.  struct MWGadget    *gad;
  155.  struct WindowEntry *we;
  156.  UBYTE              *old;
  157.  
  158.  gad=GetGadget(gadgetID,MWGAD_SPECIAL,STEXT_KIND);
  159.  if(gad)
  160.   {
  161.    we=gad->WindowEntry;
  162.    gad->TagList[STEXT_TEXT].ti_Data=text;
  163.    if(!we->Iconify) ShowText(gad);
  164.   }
  165. }
  166.  
  167. /* ---- Number-Gadget zeichnen */
  168. void ShowNumber(gad)
  169.  struct MWGadget *gad;
  170. {
  171.  struct MultiWindowsUser *mw;
  172.  struct NumberData       *nd;
  173.  REGISTER BOOL            rec;
  174.  UBYTE                   *format;
  175.  UBYTE                    text[200];
  176.  
  177.  USER;
  178.  nd=gad->ExtData;
  179.  if(!(nd->Flags & CNM_NOBORDER))
  180.   {
  181.    if(nd->Flags & CGA_RECESSED) rec=TRUE; else rec=FALSE;
  182.    DrawIt(gad->WindowEntry,
  183.           gad->NewGadget.ng_LeftEdge,gad->NewGadget.ng_TopEdge,
  184.           gad->NewGadget.ng_Width,gad->NewGadget.ng_Height,rec,FALSE,FALSE);
  185.   }
  186.  
  187.  format=nd->FormatString;
  188.  if(format==NULL)
  189.    format="%ld";
  190.  
  191.  if((mw->Locale!=NULL)&&(!(nd->Flags & CNM_NOLOCALE)))
  192.    LocaleSFormat(&text,format,&gad->TagList[SNUMBER_NUMBER].ti_Data);
  193.  else
  194.    sprintf(&text,format,gad->TagList[SNUMBER_NUMBER].ti_Data);
  195.  
  196.  WriteMText(gad->WindowEntry,
  197.             gad->NewGadget.ng_LeftEdge+3,gad->NewGadget.ng_TopEdge,
  198.             gad->NewGadget.ng_Width-6,gad->NewGadget.ng_Height,
  199.             &text,
  200.             nd->Justification,TRUE);
  201.  PrintPP(gad);
  202. }
  203.  
  204. /* ---- Number-Gadget erstellen */
  205. BOOL AddNumber(gadgetID,helpID,x,y,w,h,textID,flags,format,number,justification)
  206.  ULONG       gadgetID;
  207.  ULONG       helpID;
  208.  UWORD       x,y,w,h;
  209.  ULONG       textID;
  210.  UWORD       flags;
  211.  UBYTE      *format;
  212.  LONG        number;
  213.  UBYTE       justification;
  214. {
  215.  struct MWGadget         *gad;
  216.  struct WindowEntry      *we;
  217.  struct NumberData       *nd;
  218.  
  219.  WE;
  220.  if(we==NULL) return(NULL);
  221.  
  222.  gad=InitSGadget(gadgetID,helpID,SNUMBER_KIND,x,y,w,h,textID,PlaceText(flags,PLACETEXT_ABOVE),sizeof(struct NumberData));
  223.  if(gad==NULL) { NoMemory(); return(FALSE); }
  224.  
  225.  nd=gad->ExtData;
  226.  nd->FormatString=format;
  227.  nd->Flags=flags;
  228.  nd->Justification=justification;
  229.  
  230.  gad->TagList[SNUMBER_NUMBER].ti_Data=number;
  231.  
  232.  if(!we->Iconify) ShowNumber(gad);
  233.  return(AddMWGadget(gad));
  234. }
  235.  
  236. /* ---- Zahl-Anzeige abfragen */
  237. LONG AskNumber(gadgetID)
  238.  ULONG gadgetID;
  239. {
  240.  struct MWGadget    *gad;
  241.  
  242.  gad=GetGadget(gadgetID,MWGAD_SPECIAL,SNUMBER_KIND);
  243.  if(gad)
  244.    return((LONG)gad->TagList[SNUMBER_NUMBER].ti_Data);
  245.  return(0L);
  246. }
  247.  
  248. /* ---- Zahl-Anzeige updaten */
  249. void UpdateNumber(gadgetID,number)
  250.  ULONG  gadgetID;
  251.  LONG   number;
  252. {
  253.  struct MWGadget    *gad;
  254.  struct WindowEntry *we;
  255.  UBYTE              *old;
  256.  
  257.  gad=GetGadget(gadgetID,MWGAD_SPECIAL,SNUMBER_KIND);
  258.  if(gad)
  259.   {
  260.    we=gad->WindowEntry;
  261.  
  262.    old=gad->TagList[SNUMBER_NUMBER].ti_Data;
  263.    if(old==number)
  264.      return;
  265.  
  266.    gad->TagList[SNUMBER_NUMBER].ti_Data=number;
  267.    if(!we->Iconify) ShowNumber(gad);
  268.   }
  269. }
  270.  
  271. /* ---- Status-Gadget zeichnen */
  272. void ShowStatus(gad)
  273.  struct MWGadget *gad;
  274. {
  275.  struct WindowEntry *we;
  276.  struct RastPort    *rp;
  277.  struct StatusData  *sd;
  278.  UBYTE               text[200];
  279.  ULONG               p,l,percent;
  280.  int                 x,y,w,h,rec;
  281.  
  282.  sd=gad->ExtData;
  283.  if(sd->Flags & CGA_RECESSED) rec=TRUE; else rec=FALSE;
  284.  DrawIt(gad->WindowEntry,
  285.         gad->NewGadget.ng_LeftEdge,gad->NewGadget.ng_TopEdge,
  286.         gad->NewGadget.ng_Width,gad->NewGadget.ng_Height,rec,FALSE,FALSE);
  287.  
  288.  we=gad->WindowEntry;
  289.  rp=we->RastPort;
  290.  BackupRP(we);
  291.  
  292.  w=gad->NewGadget.ng_Width-5;
  293.  h=gad->NewGadget.ng_Height-3;
  294.  x=gad->NewGadget.ng_LeftEdge+2;
  295.  y=gad->NewGadget.ng_TopEdge+1;
  296.  l=gad->TagList[STATUS_LEVEL].ti_Data;
  297.  
  298.  if(l>sd->Max) l=sd->Max;
  299.  if(l<sd->Min) l=sd->Min;
  300.  if((sd->Max-sd->Min)==0)
  301.    p=0;
  302.  else {
  303.    percent=(l*100)/(sd->Max-sd->Min);
  304.    p=(l*w)/(sd->Max-sd->Min); }
  305.  
  306.  if(p>0)
  307.   {
  308.    SetAPen(rp,we->DrawInfo->dri_Pens[FILLPEN]);
  309.    rec=SetTaskPri(SysBase->ThisTask,127);
  310.    WaitBOVP(we->ViewPort);
  311.    RectFill(rp,x,y,x+p,y+h);
  312.    SetAPen(rp,0);
  313.    if(x+p+1<x+w)
  314.      RectFill(rp,x+p+1,y,x+w,y+h);
  315.    SetTaskPri(SysBase->ThisTask,rec);
  316.   }
  317.  else
  318.   {
  319.    rec=SetTaskPri(SysBase->ThisTask,127);
  320.    WaitBOVP(we->ViewPort);
  321.    SetAPen(rp,0);
  322.    RectFill(rp,x,y,x+w,y+h);
  323.    SetTaskPri(SysBase->ThisTask,rec);
  324.   }
  325.  
  326.  sprintf(&text,sd->FormatString,percent);
  327.  WriteMText(gad->WindowEntry,
  328.             gad->NewGadget.ng_LeftEdge+3,gad->NewGadget.ng_TopEdge,
  329.             gad->NewGadget.ng_Width-6,gad->NewGadget.ng_Height,
  330.             &text,JSF_CENTER,FALSE);
  331.  
  332.  RestoreRP(we);
  333.  PrintPP(gad);
  334. }
  335.  
  336. /* ---- Status-Gadget erstellen */
  337. BOOL AddStatus(gadgetID,helpID,x,y,w,h,textID,flags,format,level,min,max)
  338.  ULONG       gadgetID;
  339.  ULONG       helpID;
  340.  UWORD       x,y,w,h;
  341.  ULONG       textID;
  342.  UWORD       flags;
  343.  UBYTE      *format;
  344.  ULONG       level;
  345.  ULONG       min,max;
  346. {
  347.  struct MWGadget         *gad;
  348.  struct WindowEntry      *we;
  349.  struct StatusData       *sd;
  350.  
  351.  WE;
  352.  if(we==NULL) return(NULL);
  353.  
  354.  gad=InitSGadget(gadgetID,helpID,STATUS_KIND,x,y,w,h,textID,PlaceText(flags,PLACETEXT_ABOVE),sizeof(struct StatusData));
  355.  if(gad==NULL) { NoMemory(); return(FALSE); }
  356.  
  357.  sd=gad->ExtData;
  358.  sd->Flags=flags;
  359.  sd->FormatString=format;
  360.  sd->Min=min;
  361.  sd->Max=max;
  362.  
  363.  gad->TagList[STATUS_LEVEL].ti_Data=level;
  364.  
  365.  if(!we->Iconify) ShowStatus(gad);
  366.  return(AddMWGadget(gad));
  367. }
  368.  
  369. /* ---- Prozent-Gadget erstellen */
  370. BOOL AddStatus100(gadgetID,helpID,x,y,w,h,textID,flags,percent)
  371.  ULONG       gadgetID;
  372.  ULONG       helpID;
  373.  UWORD       x,y,w,h;
  374.  ULONG       textID;
  375.  UWORD       flags;
  376.  ULONG       percent;
  377. {
  378.  return(AddStatus(gadgetID,helpID,x,y,w,h,textID,flags,"%ld%%",percent,0,100));
  379. }
  380.  
  381. ULONG AskStatus(gadgetID)
  382.  ULONG gadgetID;
  383. {
  384.  struct MWGadget    *gad;
  385.  
  386.  gad=GetGadget(gadgetID,MWGAD_SPECIAL,STATUS_KIND);
  387.  if(gad)
  388.    return((ULONG)gad->TagList[STATUS_LEVEL].ti_Data);
  389.  return(0L);
  390. }
  391.  
  392. /* ---- Status-Anzeige updaten */
  393. void UpdateStatus(gadgetID,level)
  394.  ULONG gadgetID;
  395.  ULONG level;
  396. {
  397.  struct MWGadget    *gad;
  398.  struct WindowEntry *we;
  399.  struct StatusData  *sd;
  400.  ULONG               old;
  401.  
  402.  gad=GetGadget(gadgetID,MWGAD_SPECIAL,STATUS_KIND);
  403.  if(gad)
  404.   {
  405.    we=gad->WindowEntry;
  406.    sd=gad->ExtData;
  407.  
  408.    if(level<sd->Min) level=sd->Min;
  409.    if(level>sd->Max) level=sd->Max;
  410.  
  411.    old=gad->TagList[STATUS_LEVEL].ti_Data;
  412.    if(old==level)
  413.      return;
  414.  
  415.    gad->TagList[STATUS_LEVEL].ti_Data=level;
  416.    if(!we->Iconify)
  417.     {
  418.      if(sd->Flags & CSG_ANIMPOINTER) NextPointer(gad->WindowEntry);
  419.      ShowStatus(gad);
  420.     }
  421.   }
  422. }
  423.  
  424. /* ---- Status-Anzeige updaten */
  425. void UpdateStatusLimits(gadgetID,min,max)
  426.  ULONG gadgetID;
  427.  ULONG min,max;
  428. {
  429.  struct MWGadget    *gad;
  430.  struct WindowEntry *we;
  431.  struct StatusData  *sd;
  432.  ULONG               level;
  433.  
  434.  gad=GetGadget(gadgetID,MWGAD_SPECIAL,STATUS_KIND);
  435.  if(gad)
  436.   {
  437.    we=gad->WindowEntry;
  438.    sd=gad->ExtData;
  439.    sd->Min=min;
  440.    sd->Max=max;
  441.  
  442.    level=gad->TagList[STATUS_LEVEL].ti_Data;
  443.    if(level<sd->Min) level=sd->Min;
  444.    if(level>sd->Max) level=sd->Max;
  445.    gad->TagList[STATUS_LEVEL].ti_Data=level;
  446.  
  447.    if(!we->Iconify)
  448.     {
  449.      if(sd->Flags & CSG_ANIMPOINTER) NextPointer(gad->WindowEntry);
  450.      ShowStatus(gad);
  451.     }
  452.   }
  453. }
  454.  
  455. /* ---- ClickBox-Gadget zeichnen */
  456. void ShowClickBox(gad)
  457.  struct MWGadget *gad;
  458. {
  459.  struct ClickBoxData *cd;
  460.  struct WindowEntry  *we;
  461.  struct RastPort     *rp;
  462.  register int         x1,y1,x2,y2;
  463.  REGISTER BOOL        rec;
  464.  
  465.  cd=gad->ExtData;
  466.  if(!(cd->Flags & CCB_NOBORDER))
  467.   {
  468.    if(cd->Flags & CGA_RECESSED) rec=TRUE; else rec=FALSE;
  469.    DrawIt(gad->WindowEntry,
  470.           gad->NewGadget.ng_LeftEdge,gad->NewGadget.ng_TopEdge,
  471.           gad->NewGadget.ng_Width,gad->NewGadget.ng_Height,rec,FALSE,FALSE);
  472.   }
  473.  
  474.  we=gad->WindowEntry;
  475.  rp=we->RastPort;
  476.  
  477.  BackupRP(we);
  478.  
  479.  if(gad->TagList[CLICKBOX_STATUS].ti_Data==TRUE)
  480.    SetAPen(rp,we->DrawInfo->dri_Pens[TEXTPEN]);
  481.  else
  482.    SetAPen(rp,0);
  483.  
  484.  x1=gad->NewGadget.ng_LeftEdge+4;
  485.  y1=gad->NewGadget.ng_TopEdge+4;
  486.  x2=gad->NewGadget.ng_LeftEdge+gad->NewGadget.ng_Width-5;
  487.  y2=gad->NewGadget.ng_TopEdge+gad->NewGadget.ng_Height-4;
  488.  
  489.  rec=FALSE;
  490.  
  491.  if(cd->Flags & CCB_STAR)
  492.   {
  493.    rec=TRUE;
  494.    Move(rp,x1,y1);
  495.    Draw(rp,x2,y2);
  496.    Move(rp,x2,y1);
  497.    Draw(rp,x1,y2);
  498.  
  499.    Move(rp,x1,(y1+y2)/2);
  500.    Draw(rp,x2,(y1+y2)/2);
  501.    Move(rp,(x1+x2)/2,y1);
  502.    Draw(rp,(x1+x2)/2,y2);
  503.   }
  504.  
  505.  if(cd->Flags & CCB_CIRCLE)
  506.   {
  507.    rec=TRUE;
  508.    DrawEllipse(rp,(x1+x2)/2,(y1+y2)/2,(x2-x1)/2,(y2-y1)/2);
  509.   }
  510.  
  511.  if(rec==FALSE)
  512.   {
  513.    Move(rp,x1,y1);
  514.    Draw(rp,x2,y2);
  515.    Move(rp,x2,y1);
  516.    Draw(rp,x1,y2);
  517.   }
  518.  
  519.  RestoreRP(we);
  520.  PrintPP(gad);
  521. }
  522.  
  523. /* ---- Status-Gadget erstellen */
  524. BOOL AddClickBox(gadgetID,helpID,x,y,w,h,textID,flags,checked)
  525.  ULONG       gadgetID;
  526.  ULONG       helpID;
  527.  UWORD       x,y,w,h;
  528.  ULONG       textID;
  529.  UWORD       flags;
  530.  BOOL        checked;
  531. {
  532.  struct MWGadget         *gad;
  533.  struct WindowEntry      *we;
  534.  struct ClickBoxData     *cd;
  535.  
  536.  WE;
  537.  if(we==NULL) return(NULL);
  538.  
  539.  gad=InitSGadget(gadgetID,helpID,CLICKBOX_KIND,x,y,w,h,textID,PlaceText(flags,PLACETEXT_RIGHT),sizeof(struct ClickBoxData));
  540.  if(gad==NULL) { NoMemory(); return(FALSE); }
  541.  
  542.  cd=gad->ExtData;
  543.  cd->Flags=flags;
  544.  InitGadget(gad,&cd->Gadget,TRUE);
  545.  cd->Gadget.Activation |= TOGGLESELECT;
  546.  if(checked)
  547.    cd->Gadget.Flags |= SELECTED;
  548.  
  549.  gad->TagList[CLICKBOX_STATUS].ti_Data=checked;
  550.  
  551.  if(!we->Iconify) ShowClickBox(gad);
  552.  return(AddMWGadget(gad));
  553. }
  554.  
  555. /* ---- ClickBox-Status abfragen */
  556. BOOL AskClickBox(gadgetID)
  557.  ULONG gadgetID;
  558. {
  559.  struct MWGadget    *gad;
  560.  
  561.  gad=GetGadget(gadgetID,MWGAD_SPECIAL,CLICKBOX_KIND);
  562.  if(gad)
  563.    return((BOOL)gad->TagList[CLICKBOX_STATUS].ti_Data);
  564.  return(FALSE);
  565. }
  566.  
  567. /* ---- ClickBox-Status updaten */
  568. void UpdateClickBox(gadgetID,status)
  569.  ULONG gadgetID;
  570.  BOOL  status;
  571. {
  572.  struct MWGadget    *gad;
  573.  struct WindowEntry *we;
  574.  
  575.  gad=GetGadget(gadgetID,MWGAD_SPECIAL,CLICKBOX_KIND);
  576.  if(gad)
  577.   {
  578.    gad->TagList[CLICKBOX_STATUS].ti_Data=status;
  579.  
  580.    if(!we->Iconify)
  581.      ShowClickBox(gad);
  582.   }
  583. }
  584.  
  585. /* ---- Wheel-Gadget erstellen */
  586. BOOL AddWheel(gadgetID,helpID,x,y,w,h,textID,flags,current,min,max)
  587.  ULONG       gadgetID;
  588.  ULONG       helpID;
  589.  UWORD       x,y,w,h;
  590.  ULONG       textID;
  591.  UWORD       flags;
  592.  ULONG       current,min,max;
  593. {
  594.  struct MWGadget         *gad;
  595.  struct WindowEntry      *we;
  596.  struct WheelData        *wd;
  597.  
  598.  WE;
  599.  if(we==NULL) return(NULL);
  600.  
  601.  gad=InitSGadget(gadgetID,helpID,WHEEL_KIND,x,y,w,h,textID,PlaceText(flags,PLACETEXT_ABOVE),sizeof(struct WheelData));
  602.  if(gad==NULL) { NoMemory(); return(FALSE); }
  603.  
  604.  wd=gad->ExtData;
  605.  wd->Flags=flags;
  606.  wd->Min=min;
  607.  wd->Max=max;
  608.  wd->Current=current;
  609.  wd->OldX=0xffff;
  610.  wd->OldY=0xffff;
  611.  InitGadget(gad,&wd->Gadget,TRUE);
  612.  if(flags & CGA_DISABLE) wd->Gadget.Flags |= GADGDISABLED;
  613.  
  614.  if(!we->Iconify) ShowWheel(gad,TRUE);
  615.  return(AddMWGadget(gad));
  616. }
  617.  
  618. /* ---- Wheel-Status abfragen */
  619. ULONG AskWheel(gadgetID)
  620.  ULONG gadgetID;
  621. {
  622.  struct MWGadget    *gad;
  623.  struct WheelData   *wd;
  624.  
  625.  gad=GetGadget(gadgetID,MWGAD_SPECIAL,WHEEL_KIND);
  626.  if(gad)
  627.   {
  628.    wd=gad->ExtData;
  629.    return(wd->Current);
  630.   }
  631.  return(0);
  632. }
  633.  
  634. /* ---- Wheel-Gadget zeichnen */
  635. void ShowWheel(gad,fullUpdate)
  636.  struct MWGadget *gad;
  637.  BOOL             fullUpdate;
  638. {
  639.  struct WheelData    *wd;
  640.  struct WindowEntry  *we;
  641.  struct RastPort     *rp;
  642.  int                  x1,y1,x2,y2;
  643.  register int         vx,vy,mx,my;
  644.  FLOAT                w;
  645.  BOOL                 rec;
  646.  
  647.  wd=gad->ExtData;
  648.  if(!(wd->Flags & CWH_NOBORDER))
  649.   {
  650.    if(wd->Flags & CGA_RECESSED) rec=TRUE; else rec=FALSE;
  651.    DrawIt(gad->WindowEntry,
  652.           gad->NewGadget.ng_LeftEdge,gad->NewGadget.ng_TopEdge,
  653.           gad->NewGadget.ng_Width,gad->NewGadget.ng_Height,rec,FALSE,FALSE);
  654.   }
  655.  
  656.  we=gad->WindowEntry;
  657.  rp=we->RastPort;
  658.  
  659.  BackupRP(we);
  660.  
  661.  x1=gad->NewGadget.ng_LeftEdge+4;
  662.  y1=gad->NewGadget.ng_TopEdge+4;
  663.  x2=gad->NewGadget.ng_LeftEdge+gad->NewGadget.ng_Width-5;
  664.  y2=gad->NewGadget.ng_TopEdge+gad->NewGadget.ng_Height-4;
  665.  vx=((x2-x1)/2)-3;
  666.  vy=((y2-y1)/2)-3;
  667.  mx=(x1+x2)/2;
  668.  my=(y1+y2)/2;
  669.  
  670.  w=(((FLOAT)wd->Current-(FLOAT)wd->Min)*360.0)/((FLOAT)wd->Max-(FLOAT)wd->Min);
  671.  
  672.  WaitBOVP(we->ViewPort);
  673.  if(wd->OldX!=0xffff)
  674.   {
  675.    SetAPen(rp,0);
  676.    Move(rp,mx,my);
  677.    Draw(rp,wd->OldX,wd->OldY);
  678.   }
  679.  wd->OldX=mx+(int)((FLOAT)vx*cos(w*PI/180.0));
  680.  wd->OldY=my+(int)((FLOAT)vy*sin(w*PI/180.0));
  681.  
  682.  SetAPen(rp,we->DrawInfo->dri_Pens[TEXTPEN]);
  683.  Move(rp,mx,my);
  684.  Draw(rp,wd->OldX,wd->OldY);
  685.  if(fullUpdate)
  686.    DrawEllipse(rp,mx,my,vx+3,vy+3);
  687.  
  688.  RestoreRP(we);
  689.  PrintPP(gad);
  690. }
  691.  
  692. /* ---- Wheel-Gadget wurde angeklickt */
  693. void WheelHandler(gad,msg,mm)
  694.  struct MWGadget     *gad;
  695.  struct IntuiMessage *msg;
  696.  struct MultiMessage *mm;
  697. {
  698.  int               x1,y1,x2,y2,i,winkel;
  699.  register int      vx,vy,mx,my,x,y;
  700.  FLOAT             a,b,f1,f2;
  701.  BOOL              x90;
  702.  struct WheelData *wd;
  703.  
  704.  wd=gad->ExtData;
  705.  x1=gad->NewGadget.ng_LeftEdge+4;
  706.  y1=gad->NewGadget.ng_TopEdge+4;
  707.  x2=gad->NewGadget.ng_LeftEdge+gad->NewGadget.ng_Width-5;
  708.  y2=gad->NewGadget.ng_TopEdge+gad->NewGadget.ng_Height-4;
  709.  mx=(x1+x2)/2;
  710.  my=(y1+y2)/2;
  711.  vx=((x2-x1)/2)-3;
  712.  vy=((y2-y1)/2)-3;
  713.  
  714.  x=msg->MouseX;
  715.  y=msg->MouseY;
  716.  a=(FLOAT)(x-mx)/(FLOAT)vx;
  717.  b=(FLOAT)(y-my)/(FLOAT)vy;
  718.  
  719.  winkel=0;
  720.  x90=FALSE;
  721.  if((a<0)&&(b<0)) winkel+=180;
  722.  if((a<0)&&(b>0)) { winkel+=90; x90=TRUE; }
  723.  if((a>0)&&(b<0)) { winkel+=270; x90=TRUE; }
  724.  
  725.  if(a<0) a=-a;
  726.  if(b<0) b=-b;
  727.  
  728.  for(i=0;i<362;i+=3)
  729.   {
  730.    f1=sin((FLOAT)i*PI/180.0);
  731.    f2=sin((FLOAT)(i+2)*PI/180.0);
  732.    if((f1>=b)&&(b<=f2))
  733.     { i++; break; }
  734.   }
  735.  
  736.  if(x90)
  737.    winkel+=(90-i);
  738.  else
  739.    winkel+=i;
  740.  
  741.  wd->Current=((ULONG)winkel*(wd->Max-wd->Min))/360+wd->Min;
  742.  if(wd->Current>wd->Max) wd->Current=wd->Max;
  743.  if(wd->Current<wd->Min) wd->Current=wd->Min;
  744.  
  745.  mm->ObjectID=gad->GadgetID;
  746.  mm->ObjectAddress=gad;
  747.  mm->ObjectCode=wd->Current;
  748.  switch(msg->Class)
  749.   {
  750.    case MOUSEMOVE:
  751.      mm->Class=MULTI_GADGETMOUSE;
  752.     break;
  753.    case GADGETUP:
  754.      mm->Class=MULTI_GADGETUP;
  755.     break;
  756.    default:
  757.      mm->Class=MULTI_GADGETDOWN;
  758.     break;
  759.   }
  760.  ShowWheel(gad,FALSE);
  761. }
  762.  
  763. /* ---- Wheel-Gadget updaten */
  764. void UpdateWheel(gadgetID,current)
  765.  ULONG gadgetID;
  766.  ULONG current;
  767. {
  768.  struct MWGadget    *gad;
  769.  struct WindowEntry *we;
  770.  struct WheelData   *wd;
  771.  
  772.  gad=GetGadget(gadgetID,MWGAD_SPECIAL,WHEEL_KIND);
  773.  if(gad)
  774.   {
  775.    wd=gad->ExtData;
  776.    wd->Current=current;
  777.    if(wd->Current>wd->Max) wd->Current=wd->Max;
  778.    if(wd->Current<wd->Min) wd->Current=wd->Min;
  779.    if(!we->Iconify)
  780.      ShowWheel(gad);
  781.   }
  782. }
  783.  
  784. /* ---- Wheel-Gadget updaten */
  785. void UpdateWheelLimits(gadgetID,min,max)
  786.  ULONG gadgetID;
  787.  ULONG min,max;
  788. {
  789.  struct MWGadget    *gad;
  790.  struct WindowEntry *we;
  791.  struct WheelData   *wd;
  792.  
  793.  gad=GetGadget(gadgetID,MWGAD_SPECIAL,WHEEL_KIND);
  794.  if(gad)
  795.   {
  796.    wd=gad->ExtData;
  797.    wd->Min=min;
  798.    wd->Max=max;
  799.    if(wd->Current>wd->Max) wd->Current=wd->Max;
  800.    if(wd->Current<wd->Min) wd->Current=wd->Min;
  801.  
  802.    if(!we->Iconify)
  803.      ShowWheel(gad);
  804.   }
  805. }
  806.  
  807. /* ---- SelectBox-Gadget erstellen */
  808. BOOL AddSelectBox(gadgetID,helpID,x,y,w,h,textID,flags,titleArray,selected)
  809.  ULONG       gadgetID;
  810.  ULONG       helpID;
  811.  UWORD       x,y,w,h;
  812.  ULONG       textID;
  813.  UWORD       flags;
  814.  ULONG      *titleArray;
  815.  UBYTE       selected;
  816. {
  817.  struct MultiWindowsUser      *mw;
  818.  struct MWGadget              *gad;
  819.  struct WindowEntry           *we;
  820.  struct SelectBoxData         *sd;
  821.  register struct ExtNewWindow *nw;
  822.  int                           i,j;
  823.  
  824.  WE;
  825.  USER;
  826.  if(we==NULL) return(NULL);
  827.  
  828.  flags &= ~CGA_IN;
  829.  gad=InitSGadget(gadgetID,helpID,SELECTBOX_KIND,x,y,w,h,textID,PlaceText(flags,PLACETEXT_ABOVE),sizeof(struct SelectBoxData));
  830.  if(gad==NULL) { NoMemory(); return(FALSE); }
  831.  
  832.  sd=gad->ExtData;
  833.  sd->Flags=flags;
  834.  sd->TitleArray=titleArray;
  835.  sd->Selected=selected;
  836.  
  837.  while(titleArray[sd->TitleCount]!=0L)
  838.   {
  839.    sd->TitleCount++;
  840.    if(sd->TitleCount>30) break;
  841.   }
  842.  
  843.  nw=&sd->NewWindow;
  844.  nw->Width=50;
  845.  for(i=0;i<sd->TitleCount;i++)
  846.   {
  847.    j=20+PixelLength(mw->TextFont,FindID(mw->Catalog,sd->TitleArray[i]));
  848.    if(j>nw->Width) nw->Width=j;
  849.   }
  850.  
  851.  nw->Height=mw->TextFont->tf_YSize*sd->TitleCount+2*(gad->WindowEntry->Screen->WBorTop+1);
  852.  nw->BlockPen=1;
  853.  nw->IDCMPFlags=MOUSEMOVE|MOUSEBUTTONS|VANILLAKEY|INACTIVEWINDOW;
  854.  nw->Flags=ACTIVATE|NOCAREREFRESH|RMBTRAP|WFLG_NW_EXTENDED;
  855.  nw->Screen=gad->WindowEntry->Screen;
  856.  nw->Type=CUSTOMSCREEN;
  857.  nw->Extension=&sd->TagList;
  858.  
  859.  sd->TagList[0].ti_Tag=WA_InnerWidth;
  860.  sd->TagList[0].ti_Data=nw->Width;
  861.  sd->TagList[1].ti_Tag=WA_InnerHeight;
  862.  sd->TagList[1].ti_Data=nw->Height;
  863.  sd->TagList[2].ti_Tag=WA_AutoAdjust;
  864.  sd->TagList[2].ti_Data=TRUE;
  865.  sd->TagList[3].ti_Tag=TAG_DONE;
  866.  sd->TagList[3].ti_Data=0;
  867.  
  868.  InitGadget(gad,&sd->Gadget,TRUE);
  869.  if(flags & CGA_DISABLE)
  870.    sd->Gadget.Flags |= GADGDISABLED;
  871.  
  872.  if(!we->Iconify) ShowSelectBox(gad,TRUE);
  873.  return(AddMWGadget(gad));
  874. }
  875.  
  876. /* ---- SelectBox-Gadget zeichnen */
  877. void ShowSelectBox(gad)
  878.  struct MWGadget *gad;
  879. {
  880.  REGISTER BOOL            rec;
  881.  struct SelectBoxData    *sd;
  882.  struct MultiWindowsUser *mw;
  883.  
  884.  USER;
  885.  sd=gad->ExtData;
  886.  if(!(sd->Flags & CSB_NOBORDER))
  887.   {
  888.    if(sd->Flags & CGA_RECESSED) rec=TRUE; else rec=FALSE;
  889.    DrawIt(gad->WindowEntry,
  890.           gad->NewGadget.ng_LeftEdge,gad->NewGadget.ng_TopEdge,
  891.           gad->NewGadget.ng_Width,gad->NewGadget.ng_Height,rec,FALSE,FALSE);
  892.   }
  893.  WriteMText(gad->WindowEntry,
  894.             gad->NewGadget.ng_LeftEdge+3,gad->NewGadget.ng_TopEdge,
  895.             gad->NewGadget.ng_Width-6,gad->NewGadget.ng_Height,
  896.             FindID(mw->Catalog,sd->TitleArray[sd->Selected]),
  897.             JSF_CENTER,TRUE);
  898.  PrintPP(gad);
  899. }
  900.  
  901. /* ---- SelectBox wird geöffnet */
  902. void SelectBoxHandler(gad,mm)
  903.  struct MWGadget     *gad;
  904.  struct MultiMessage *mm;
  905. {
  906.  struct MultiWindowsUser *mw;
  907.  struct SelectBoxData    *sd;
  908.  struct Window           *win;
  909.  struct RastPort         *rp;
  910.  struct IntuiMessage     *m;
  911.  ULONG                    class;
  912.  UWORD                    code,i,l,old;
  913.  BOOL                     okay;
  914.  ULONG                   *array;
  915.  UBYTE                   *t,low;
  916.  
  917.  USER;
  918.  sd=gad->ExtData;
  919.  array=sd->TitleArray;
  920.  if(array==NULL) return;
  921.  
  922.  old=sd->Selected;
  923.  sd->NewWindow.TopEdge=gad->NewGadget.ng_TopEdge;
  924.  sd->NewWindow.LeftEdge=gad->NewGadget.ng_LeftEdge;
  925.  win=OpenWindow(&sd->NewWindow);
  926.  if(win)
  927.   {
  928.    rp=win->RPort;
  929.    SetFont(rp,mw->TextFont);
  930.    for(i=0;i<sd->TitleCount;i++)
  931.     {
  932.      t=FindID(mw->Catalog,sd->TitleArray[i]);
  933.      l=strlen(t);
  934.      if(sd->Selected!=i)
  935.        SetAPen(rp,gad->WindowEntry->DrawInfo->dri_Pens[TEXTPEN]);
  936.      else
  937.        SetAPen(rp,gad->WindowEntry->DrawInfo->dri_Pens[HIGHLIGHTTEXTPEN]);
  938.      Move(rp,10+win->BorderLeft,((i+1)*mw->TextFont->tf_YSize)+win->BorderTop);
  939.      Text(rp,t,l);
  940.     }
  941.  
  942.    okay=FALSE;
  943.    while(okay==FALSE)
  944.     {
  945.      WaitPort(win->UserPort);
  946.      m=GetMsg(win->UserPort);
  947.      class=m->Class;
  948.      code=m->Code;
  949.      ReplyMsg(m);
  950.      switch(class)
  951.       {
  952.        case MOUSEBUTTONS:
  953.          i=m->MouseY;
  954.          i-=(win->BorderTop+win->BorderTop);
  955.          i/=mw->TextFont->tf_YSize;
  956.          if(i>=sd->TitleCount) i=sd->TitleCount-1;
  957.          sd->Selected=i;
  958.          okay=TRUE;
  959.         break;
  960.        case VANILLAKEY:
  961.          low=tolower(code);
  962.          if(low==tolower(gad->CommandKey))
  963.           {
  964.            SetAPen(rp,gad->WindowEntry->DrawInfo->dri_Pens[TEXTPEN]);
  965.            Move(rp,10+win->BorderLeft,((sd->Selected+1)*mw->TextFont->tf_YSize)+win->BorderTop);
  966.            t=FindID(mw->Catalog,sd->TitleArray[sd->Selected]);
  967.            Text(rp,t,strlen(t));
  968.  
  969.            if(low==code)
  970.             {
  971.              sd->Selected++;
  972.              if(sd->Selected>=sd->TitleCount) sd->Selected=0;
  973.             }
  974.            else
  975.             {
  976.              if(sd->Selected>0)
  977.                sd->Selected--;
  978.              else
  979.                sd->Selected=sd->TitleCount-1;
  980.             }
  981.  
  982.            SetAPen(rp,gad->WindowEntry->DrawInfo->dri_Pens[HIGHLIGHTTEXTPEN]);
  983.            Move(rp,10+win->BorderLeft,((sd->Selected+1)*mw->TextFont->tf_YSize)+win->BorderTop);
  984.            t=FindID(mw->Catalog,sd->TitleArray[sd->Selected]);
  985.            Text(rp,t,strlen(t));
  986.           }
  987.          else if(code==13)
  988.            okay=TRUE;
  989.         break;
  990.        case INACTIVEWINDOW:
  991.          okay=TRUE;
  992.         break;
  993.       }
  994.     }
  995.    CloseWindow(win);
  996.    if(sd->Selected!=old)
  997.      ShowSelectBox(gad);
  998.   }
  999.  mm->Class=MULTI_GADGETUP;
  1000.  mm->ObjectCode=sd->Selected;
  1001. }
  1002.  
  1003. /* ---- SelectBox abfragen */
  1004. UBYTE AskSelectBox(gadgetID)
  1005.  ULONG gadgetID;
  1006. {
  1007.  struct MWGadget      *gad;
  1008.  struct SelectBoxData *sd;
  1009.  
  1010.  gad=GetGadget(gadgetID,MWGAD_SPECIAL,SELECTBOX_KIND);
  1011.  if(gad)
  1012.   {
  1013.    sd=gad->ExtData;
  1014.    return(sd->Selected);
  1015.   }
  1016.  return(0);
  1017. }
  1018.  
  1019. /* ---- SelectBox updaten */
  1020. void UpdateSelectBox(gadgetID,selected)
  1021.  ULONG gadgetID;
  1022.  UBYTE selected;
  1023. {
  1024.  struct MWGadget      *gad;
  1025.  struct WindowEntry   *we;
  1026.  struct SelectBoxData *sd;
  1027.  
  1028.  gad=GetGadget(gadgetID,MWGAD_SPECIAL,SELECTBOX_KIND);
  1029.  if(gad)
  1030.   {
  1031.    sd=gad->ExtData;
  1032.    if(selected>=sd->TitleCount) selected=sd->TitleCount-1;
  1033.    if(sd->Selected!=selected)
  1034.     {
  1035.      sd->Selected=selected;
  1036.      if(!we->Iconify)
  1037.        ShowSelectBox(gad);
  1038.     }
  1039.   }
  1040. }
  1041.  
  1042. /* ---- Icon-Gadget hinzufügen */
  1043. BOOL AddIcon(gadgetID,helpID,x,y,w,h,textID,flags,name)
  1044.  ULONG       gadgetID;
  1045.  ULONG       helpID;
  1046.  UWORD       x,y,w,h;
  1047.  ULONG       textID;
  1048.  UWORD       flags;
  1049.  UBYTE      *name;
  1050. {
  1051.  struct MWGadget    *gad;
  1052.  struct WindowEntry *we;
  1053.  struct IconData    *id;
  1054.  
  1055.  WE;
  1056.  if(we==NULL) return(NULL);
  1057.  
  1058.  gad=InitSGadget(gadgetID,helpID,ICON_KIND,x,y,w,h,textID,PlaceText(flags,PLACETEXT_ABOVE),sizeof(struct IconData));
  1059.  if(gad==NULL) { NoMemory(); return(FALSE); }
  1060.  
  1061.  id=gad->ExtData;
  1062.  id->Flags=flags;
  1063.  id->Icon=GetDiskObject(name);
  1064.  InitGadget(gad,&id->Gadget,TRUE);
  1065.  if(id->Icon!=NULL)
  1066.   {
  1067.    id->Gadget.GadgetRender=CenterImage(id->Icon->do_Gadget.GadgetRender,
  1068.                                        gad->NewGadget.ng_Width,
  1069.                                        gad->NewGadget.ng_Height);
  1070.    id->Gadget.SelectRender=CenterImage(id->Icon->do_Gadget.SelectRender,
  1071.                                        gad->NewGadget.ng_Width,
  1072.                                        gad->NewGadget.ng_Height);
  1073.    id->Gadget.Flags=id->Icon->do_Gadget.Flags;
  1074.   }
  1075.  if(flags & CGA_DISABLE)
  1076.    id->Gadget.Flags |= GADGDISABLED;
  1077.  
  1078.  if(!we->Iconify)
  1079.    ShowIcon(gad);
  1080.  
  1081.  return(AddMWGadget(gad));
  1082. }
  1083.  
  1084. /* ---- Image-Gadget hinzufügen */
  1085. BOOL AddImage(gadgetID,helpID,x,y,w,h,textID,flags,number)
  1086.  ULONG       gadgetID;
  1087.  ULONG       helpID;
  1088.  UWORD       x,y,w,h;
  1089.  ULONG       textID;
  1090.  UWORD       flags;
  1091.  UWORD       number;
  1092. {
  1093.  struct TagItem      tags[10];
  1094.  struct MWGadget    *gad;
  1095.  struct WindowEntry *we;
  1096.  struct ImageData   *id;
  1097.  APTR                image,gadget;
  1098.  
  1099.  WE;
  1100.  if(we==NULL) return(NULL);
  1101.  
  1102.  tags[0].ti_Tag=SYSIA_Which;
  1103.  tags[0].ti_Data=number;
  1104.  tags[1].ti_Tag=SYSIA_Size;
  1105.  tags[1].ti_Data=SYSISIZE_HIRES;
  1106.  tags[2].ti_Tag=SYSIA_DrawInfo;
  1107.  tags[2].ti_Data=we->DrawInfo;
  1108.  tags[3].ti_Tag=TAG_DONE;
  1109.  tags[3].ti_Data=0;
  1110.  image=NewObjectA(NULL,"sysiclass",&tags);
  1111.  if(image==NULL) {
  1112.    NoMemory(); return(FALSE);
  1113.   }
  1114.  
  1115.  tags[0].ti_Tag=GA_Left;
  1116.  tags[0].ti_Data=INewX(we,x);
  1117.  tags[1].ti_Tag=GA_Top;
  1118.  tags[1].ti_Data=INewY(we,y);
  1119.  tags[2].ti_Tag=GA_Width;
  1120.  tags[2].ti_Data=INewWidth(we,w);
  1121.  tags[3].ti_Tag=GA_Height;
  1122.  tags[3].ti_Data=INewX(we,h);
  1123.  tags[4].ti_Tag=GA_Image;
  1124.  tags[4].ti_Data=image;
  1125.  tags[5].ti_Tag=GA_RelVerify;
  1126.  tags[5].ti_Data=TRUE;
  1127.  tags[6].ti_Tag=GA_Immediate;
  1128.  tags[6].ti_Data=TRUE;
  1129.  tags[7].ti_Tag=GA_Disabled;
  1130.  if(flags & CGA_DISABLE)
  1131.    tags[7].ti_Data=TRUE;
  1132.  else
  1133.    tags[7].ti_Data=FALSE;
  1134.  tags[8].ti_Tag=GA_DrawInfo;
  1135.  tags[8].ti_Data=we->DrawInfo;
  1136.  tags[9].ti_Tag=TAG_DONE;
  1137.  tags[9].ti_Data=0;
  1138.  gadget=NewObjectA(NULL,"buttongclass",&tags);
  1139.  if(gadget==NULL)
  1140.   {
  1141.    DisposeObject(image);
  1142.    NoMemory(); return(FALSE);
  1143.   }
  1144.  
  1145.  gad=InitSGadget(gadgetID,helpID,IMAGE_KIND,x,y,w,h,textID,PlaceText(flags,PLACETEXT_ABOVE),sizeof(struct IconData));
  1146.  if(gad==NULL) {
  1147.    DisposeObject(image);
  1148.    DisposeObject(gadget);
  1149.    NoMemory(); return(FALSE);
  1150.   }
  1151.  
  1152.  id=gad->ExtData;
  1153.  id->Flags=flags;
  1154.  
  1155.  id->Gadget=gadget;
  1156.  id->Image=image;
  1157.  gad->Gadget=gadget;
  1158.  gad->Gadget->UserData=gad;
  1159.  gad->Gadget->GadgetID=0xffff;
  1160.  gad->Gadget->GadgetRender=CenterImage(gad->Gadget->GadgetRender,
  1161.                                        gad->NewGadget.ng_Width,
  1162.                                        gad->NewGadget.ng_Height);
  1163.  gad->Gadget->SelectRender=CenterImage(gad->Gadget->SelectRender,
  1164.                                        gad->NewGadget.ng_Width,
  1165.                                        gad->NewGadget.ng_Height);
  1166.  
  1167.  if(!we->Iconify)
  1168.    ShowImage(gad);
  1169.  
  1170.  return(AddMWGadget(gad));
  1171. }
  1172.  
  1173. /* ---- Image zentrieren */
  1174. struct Image *CenterImage(image,w,h)
  1175.  struct Image *image;
  1176.  int           w,h;
  1177. {
  1178.  if(image==NULL) return(NULL);
  1179.  
  1180.  image->LeftEdge=(w-image->Width)/2;
  1181.  image->TopEdge=(h-image->Height)/2;
  1182.  return(image);
  1183. }
  1184.  
  1185. /* ---- Icon-Gadget zeigen */
  1186. void ShowImage(gad)
  1187.  struct MWGadget *gad;
  1188. {
  1189.  struct ImageData *id;
  1190.  REGISTER BOOL     rec;
  1191.  
  1192.  id=gad->ExtData;
  1193.  if(!(id->Flags & CIM_NOBORDER))
  1194.   {
  1195.    if(id->Flags & CGA_RECESSED) rec=TRUE; else rec=FALSE;
  1196.    DrawIt(gad->WindowEntry,
  1197.           gad->NewGadget.ng_LeftEdge,gad->NewGadget.ng_TopEdge,
  1198.           gad->NewGadget.ng_Width,gad->NewGadget.ng_Height,rec,FALSE,FALSE);
  1199.   }
  1200.  PrintPP(gad);
  1201. }
  1202.  
  1203. /* ---- Icon-Gadget zeigen */
  1204. void ShowIcon(gad)
  1205.  struct MWGadget *gad;
  1206. {
  1207.  struct IconData *id;
  1208.  REGISTER BOOL    rec;
  1209.  
  1210.  id=gad->ExtData;
  1211.  if(!(id->Flags & CIC_NOBORDER))
  1212.   {
  1213.    if(id->Flags & CGA_RECESSED) rec=TRUE; else rec=FALSE;
  1214.    DrawIt(gad->WindowEntry,
  1215.           gad->NewGadget.ng_LeftEdge,gad->NewGadget.ng_TopEdge,
  1216.           gad->NewGadget.ng_Width,gad->NewGadget.ng_Height,rec,FALSE,FALSE);
  1217.   }
  1218.  PrintPP(gad);
  1219. }
  1220.  
  1221.