home *** CD-ROM | disk | FTP | other *** search
/ Enigma Amiga Life 113 / EnigmaAmiga113CD.iso / software / sviluppo / fm2000 / gadgets.c < prev    next >
Encoding:
C/C++ Source or Header  |  2000-02-04  |  27.5 KB  |  1,127 lines
  1. /*
  2.      Filemaster - Multitasking directory utility.
  3.      Copyright (C) 2000  Toni Wilen
  4.      
  5.      This program is free software; you can redistribute it and/or
  6.      modify it under the terms of the GNU General Public License
  7.      as published by the Free Software Foundation; either version 2
  8.      of the License, or (at your option) any later version.
  9.      
  10.      This program is distributed in the hope that it will be useful,
  11.      but WITHOUT ANY WARRANTY; without even the implied warranty of
  12.      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13.      GNU General Public License for more details.
  14.      
  15.      You should have received a copy of the GNU General Public License
  16.      along with this program; if not, write to the Free Software
  17.      Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
  18. */
  19.  
  20.  
  21. #include <exec/types.h>
  22. #include <intuition/intuition.h>
  23. #include <intuition/intuitionbase.h>
  24. #include <intuition/gadgetclass.h>
  25. #include <libraries/bgui.h>
  26. #include <libraries/bgui_macros.h>
  27. #include <exec/memory.h>
  28. #include <proto/all.h>
  29. #include <proto/bgui.h>
  30. #include <string.h>
  31. #include <stdarg.h>
  32. #include "fmnode.h"
  33. #include "fmlocale.h"
  34. #include "gadgets.h"
  35.  
  36. extern struct FMMain fmmain;
  37. extern struct FMConfig *fmconfig;
  38. void textextent(struct RastPort*,UBYTE*,WORD*,WORD*);
  39. void textextentuc(struct RastPort*,UBYTE*,WORD*,WORD*);
  40. ULONG power2(WORD);
  41. void supercheck(struct Window*,ULONG*,ULONG*,ULONG*);
  42. void copyus(UBYTE*,UBYTE*);
  43. void getwinposition(struct Screen*,struct NewWindow*,WORD,WORD,WORD);
  44.  
  45. static UBYTE gadnumbers[]={'0',0,'1',0,'2',0,'3',0,'4',0,'5',0,'6',0,'7',0,'8',0,'9',0};
  46.  
  47. UBYTE *scanchar(UBYTE*,UBYTE);
  48.  
  49. void draw3dbox(struct RastPort *rp,WORD x,WORD y,WORD w,WORD h,WORD type)
  50. {
  51. UBYTE col1,col2;
  52.  
  53. //1=raised 0=lowered
  54.  
  55. SetAPen(rp,fmconfig->backpen);
  56. RectFill(rp,x,y,x+w,y+h);
  57. if (type) {
  58.     col1=fmconfig->whitepen; col2=fmconfig->blackpen;
  59.     } else {
  60.     col1=fmconfig->blackpen; col2=fmconfig->whitepen;
  61. }
  62. x--;y--;w++;h++;
  63. if (fmconfig->flags&MDOUBLED) { x--; w+=2; }
  64. Move(rp,x,y);
  65. SetAPen(rp,col1);
  66. Draw(rp,x+w,y);
  67. SetAPen(rp,col2);
  68. Draw(rp,x+w,y+h);
  69. Draw(rp,x,y+h);
  70. SetAPen(rp,col1);
  71. Draw(rp,x,y);
  72. if (fmconfig->flags&MDOUBLED) {
  73.     Move(rp,x+1,y);
  74.     Draw(rp,x+1,y+h-1);
  75.     SetAPen(rp,col2);
  76.     Move(rp,x+w-1,y+1);
  77.     Draw(rp,x+w-1,y+h);
  78. }
  79. }
  80.  
  81. void reqwindowtext(UBYTE *txt)
  82. {
  83. struct Window *window;
  84. struct NewWindow newwindow;
  85. struct RastPort rp;
  86. WORD lines,apu1,apu2,quit,rows;
  87. UBYTE *txtptr;
  88. UBYTE title[40];
  89. UBYTE extstring[100];
  90. UBYTE *ptr1;
  91. ULONG class;
  92. UWORD code;
  93. WORD trycnt;
  94. WORD tfh,tfb;
  95.  
  96. if(SetSignal(0,0)&SIGBREAKF_CTRL_C) return;
  97.  
  98. InitRastPort(&rp);
  99. trycnt=0;
  100. gretry:
  101. switch(trycnt) {
  102.     case 0:
  103.     SetFont(&rp,fmmain.listfont);
  104.     tfh=fmmain.reqysize;
  105.     tfb=fmmain.reqbaseline;
  106.     break;
  107.     case 1:
  108.     SetFont(&rp,fmmain.smallfont);
  109.     tfh=fmmain.smallfont->tf_YSize;
  110.     tfb=fmmain.smallfont->tf_Baseline;
  111.     break;
  112. }
  113. txtptr=txt;
  114. ptr1=title;
  115. while(*txtptr!='\n') *ptr1++=*txtptr++;
  116. *ptr1=0; txtptr++;
  117. rows=0; lines=0;
  118. while(*txtptr) {
  119.     ptr1=extstring;
  120.     while(*txtptr!='\n') *ptr1++=*txtptr++;
  121.     textextent(&rp,extstring,&apu1,&apu2);
  122.     if (apu1>rows) rows=apu1;
  123.     lines++;
  124.     while(*txtptr++!='\n');
  125. }
  126.  
  127. newwindow.Height=lines*(tfh+1)+fmmain.naytto->WBorTop+fmmain.naytto->Font->ta_YSize+1+2*fmconfig->spaceh;
  128. newwindow.Width=rows+fmconfig->spacew*4;
  129. newwindow.Flags=WFLG_DRAGBAR|WFLG_DEPTHGADGET|WFLG_CLOSEGADGET|WFLG_SMART_REFRESH|WFLG_RMBTRAP|WFLG_ACTIVATE,
  130. newwindow.IDCMPFlags=IDCMP_CLOSEWINDOW|IDCMP_VANILLAKEY|IDCMP_MOUSEBUTTONS,
  131. newwindow.DetailPen=fmconfig->txtpen;
  132. newwindow.BlockPen=fmconfig->hilipen;
  133. newwindow.FirstGadget=0;
  134. //newwindow.CheckMark=0;
  135. newwindow.Title=title;
  136. newwindow.Screen=fmmain.naytto;
  137. newwindow.Type=CUSTOMSCREEN;
  138. newwindow.BitMap=0;
  139.  
  140. if(newwindow.Height>fmmain.naytto->Height||newwindow.Width>fmmain.naytto->Width) {
  141.     trycnt++;
  142.     if(trycnt==1) goto gretry;
  143. }
  144. getwinposition(fmmain.naytto,&newwindow,0,newwindow.Width/2,newwindow.Height/2);
  145.  
  146. txtptr=txt;
  147. while(*txtptr++!='\n');
  148. if (window=OpenWindow(&newwindow)) {
  149.     SetAPen(window->RPort,fmconfig->backfillpen);
  150.     RectFill(window->RPort,window->BorderLeft,window->BorderTop,window->Width-window->BorderRight-1,window->Height-window->BorderBottom-1);
  151.     if(trycnt==0) SetFont(window->RPort,fmmain.listfont); else SetFont(window->RPort,fmmain.smallfont);
  152.     SetAPen(window->RPort,fmconfig->txtpen);
  153.     SetDrMd(window->RPort,JAM1);
  154.     apu1=fmmain.naytto->WBorTop+fmmain.naytto->Font->ta_YSize+1+fmconfig->spaceh+tfb;
  155.     while(lines--) {
  156.         Move(window->RPort,2*fmconfig->spacew,apu1);
  157.         Text(window->RPort,txtptr,scanchar(txtptr,'\n')-txtptr);
  158.         while(*txtptr++!='\n');
  159.         apu1+=tfh+1;
  160.     }
  161.     quit=-2;
  162.     while (quit==-2) {
  163.         if(smallevent(window,&class,&code)) quit=0;
  164.         if(class==IDCMP_CLOSEWINDOW||class==IDCMP_VANILLAKEY||(class==IDCMP_MOUSEBUTTONS&&code==SELECTDOWN)) quit=0;
  165.     }
  166.     CloseWindow(window);
  167. }
  168. }
  169.  
  170. void getwinposition(struct Screen *scr,struct NewWindow *win,WORD flag,WORD apu1,WORD apu2)
  171. {
  172. WORD mousex,mousey;
  173. struct Rectangle rect;
  174. WORD dwidth,dheight,dxoffset,dyoffset;
  175.  
  176. QueryOverscan(GetVPModeID(&scr->ViewPort),&rect,OSCAN_TEXT);
  177.  
  178. dwidth=rect.MaxX-rect.MinX;
  179. dheight=rect.MaxY-rect.MinY;
  180. dxoffset=-scr->ViewPort.DxOffset;
  181. dyoffset=-scr->ViewPort.DyOffset;
  182.  
  183. if(!flag) {
  184.     mousex=scr->MouseX-apu1;
  185.     mousey=scr->MouseY-apu2;
  186. } else {
  187.     mousex=(dwidth-win->Width)/2+dxoffset;
  188.     mousey=(dheight-win->Height)/2+dyoffset;
  189. }
  190. if(mousex+win->Width>dwidth+dxoffset) mousex=dwidth+dxoffset-win->Width;
  191. if(mousey+win->Height>dheight+dyoffset) mousey=dheight+dyoffset-win->Height;
  192. if(mousex<dxoffset) mousex=dxoffset;
  193. if(mousey<dyoffset) mousey=dyoffset;
  194. if(mousex+win->Width>scr->Width) mousex=scr->Width-win->Width;
  195. if(mousey+win->Height>scr->Height) mousey=scr->Height-win->Height;
  196. if(mousex<0) mousex=0;
  197. if(mousey<0) mousey=0;
  198. win->LeftEdge=mousex;
  199. win->TopEdge=mousey;
  200. }
  201.  
  202. /*
  203. taulu[0]==0 screen in taulu[1]
  204. taulu[0]==1 center all requesters
  205. taulu[0]==2 super list in taulu[1]
  206.  
  207. taulu[0]=window title
  208. taulu[1]=#kind,taulu[2]=number of kind values taulu[3]=kind values....
  209. taulu[..]=next #kind....
  210. endofline=100,endoftaulu=101
  211. */
  212.  
  213. extern struct IntuitionBase *IntuitionBase;
  214.  
  215. void initproc(void); //HC
  216.  
  217. WORD reqwindow(ULONG *taulu)
  218. {
  219. struct NewWindow newwindow;
  220. struct NewGadget ngad;
  221. struct Window *window;
  222. struct Gadget *glist,*gtgad,*vgad,*fstringgad;
  223. struct IntuiMessage *message;
  224. struct Screen *screen,*oldscreen;
  225. struct RastPort rp;
  226.  
  227. UWORD tfh,tfw,spaceh=4,spacew=8;
  228. WORD gadhnum;
  229. WORD kplcnt1,kplcnt2;
  230. WORD quit=0,gadgetnum,txoffset,maxgadw,valikoko;
  231. WORD apu1,apu2,apu3,apu4,apu5,center=0;
  232. struct IntString *is;
  233. ULONG class;
  234. UWORD code;
  235. ULONG *tauluptr,*realtaulu,*super=0;
  236. ULONG gadgettype;
  237. UBYTE asciicode;
  238. WORD txtlentab[72];        //gadget widths
  239. WORD txtmaxlentab[64];        //maximum widths (cleared)
  240. WORD rowwidth[64];
  241. UBYTE shortcuts[72];
  242. ULONG addressi[144];
  243. ULONG tags[9];
  244. ULONG array[64];
  245. WORD arrayptr,retgadget;
  246. UBYTE *vptr;
  247. UBYTE chartab[2];
  248. struct InputEvent ie;
  249. ULONG ilock;
  250. WORD opened=0;
  251. WORD trycnt=0;
  252. ULONG sigs;
  253.  
  254. if(SetSignal(0,0)&SIGBREAKF_CTRL_C) return(0);
  255.  
  256. memseti(txtmaxlentab,0,32*2);
  257. ie.ie_Class=IECLASS_RAWKEY;
  258. ie.ie_SubClass=0;
  259. InitRastPort(&rp);
  260. ilock=LockIBase(0);
  261. oldscreen=IntuitionBase->FirstScreen;
  262. UnlockIBase(ilock);
  263. screen=fmmain.naytto;
  264. while(*taulu<4) {
  265.     switch(*taulu)
  266.     {
  267.     case GADSCREEN:
  268.     screen=(struct Screen*)*(taulu+1);
  269.     taulu+=2;
  270.     break;
  271.     case GADCENTER:
  272.     center=1;
  273.     taulu++;
  274.     break;
  275.     case GADSUPER:
  276.     super=(ULONG*)*(taulu+1);
  277.     taulu+=2;
  278.     break;
  279.     }
  280. }
  281. realtaulu=taulu;
  282.  
  283. gretry:
  284. glist=0; gadhnum=0; fstringgad=0;
  285. retgadget=-1;
  286. window=0;
  287. switch(trycnt) {
  288.     case 0:
  289.     SetFont(&rp,fmmain.reqfont);
  290.     tfh=fmmain.reqysize;
  291.     tfw=fmmain.reqxsize;
  292.     valikoko=spaceh+2;
  293.     break;
  294.     case 1:
  295.     valikoko=spaceh;
  296.     break;
  297.     case 2:
  298.     SetFont(&rp,fmmain.smallfont);
  299.     tfh=fmmain.smallfont->tf_YSize;
  300.     tfw=fmmain.smallfont->tf_XSize;
  301.     break;
  302. }
  303. kplcnt1=0;
  304. tauluptr=realtaulu+1;
  305. while(*tauluptr!=101) {
  306.     while(*tauluptr!=100) {
  307.         switch(*tauluptr) {
  308.             case STRING_KIND:
  309.             apu1=20;
  310.             if(*(tauluptr+3)<20) apu1=*(tauluptr+3)+1;
  311.             apu1=apu1*tfw+2*spacew;
  312.             break;
  313.             case INTEGER_KIND:
  314.             apu1=tfw*8+2*spacew;
  315.             break;
  316.             case TEXT_KIND:
  317.             if((*(tauluptr+1)&GADGTEXTNUC)==0)
  318.                 textextent(&rp,(UBYTE*)(*(tauluptr+2)),&apu1,&txoffset);
  319.                 else
  320.                 textextentuc(&rp,(UBYTE*)(*(tauluptr+2)),&apu1,&txoffset);
  321.             break;
  322.             case BUTTON_KIND:
  323.             textextentuc(&rp,(UBYTE*)(*(tauluptr+2)),&apu1,&txoffset);
  324.             apu1+=4*spacew;
  325.             break;
  326.             case CHECKBOX_KIND:
  327.             apu1=32;
  328.             break;
  329.             case TOGGLE_KIND:
  330.             textextentuc(&rp,(UBYTE*)(*(tauluptr+2)),&apu1,&txoffset);
  331.             apu1+=2*spacew;
  332.             break;
  333.             case CYCLE_KIND:
  334.             apu1=0;
  335.             for(apu2=0;apu2<((*(tauluptr+1))&0xff)-1;apu2++) {
  336.                 textextentuc(&rp,(UBYTE*)(*(tauluptr+2+apu2)),&apu3,&txoffset);
  337.                 apu3+=8*spacew;
  338.                 if(apu3>apu1) apu1=apu3;
  339.             }
  340.             break;
  341.             case PALETTE_KIND:
  342.             apu1=power2(fmconfig->mainscreen.depth)*14+2*spacew;
  343.             break;
  344.         }
  345.         txtlentab[kplcnt1++]=apu1;
  346.         tauluptr+=((*(tauluptr+1))&0xff)+2;
  347.     }
  348.     txtlentab[kplcnt1++]=0;
  349.     gadhnum++;
  350.     tauluptr++;
  351. }
  352. txtlentab[kplcnt1]=-1;
  353.  
  354.  
  355. kplcnt1=0;
  356. tauluptr=realtaulu+1;
  357. while(*tauluptr!=101) {
  358.     while(*tauluptr!=100) {
  359.         apu1=(*(tauluptr+1)>>16)&0xff;
  360.         if(apu1) {
  361.             if(txtlentab[kplcnt1]>txtmaxlentab[apu1]) txtmaxlentab[apu1]=txtlentab[kplcnt1];
  362.         }
  363.         kplcnt1++;
  364.         tauluptr+=((*(tauluptr+1))&0xff)+2;
  365.     }
  366.     kplcnt1++;
  367.     tauluptr++;
  368. }
  369. maxgadw=0;
  370. kplcnt1=0;kplcnt2=0;
  371. tauluptr=realtaulu+1;
  372. while(*tauluptr!=101) {
  373.     apu2=0;
  374.     rowwidth[kplcnt2]=0;
  375.     while(*tauluptr!=100) {
  376.         apu1=(*(tauluptr+1)>>16)&0xff;
  377.         if(apu1) {
  378.             txtlentab[kplcnt1]=txtmaxlentab[apu1];
  379.         }
  380.         apu2+=txtlentab[kplcnt1];
  381.         rowwidth[kplcnt2]+=txtlentab[kplcnt1];
  382.         kplcnt1++;
  383.         tauluptr+=((*(tauluptr+1))&0xff)+2;
  384.     }
  385.     if(apu2>maxgadw) maxgadw=apu2;
  386.     kplcnt1++;
  387.     tauluptr++;
  388.     kplcnt2++;
  389. }
  390. do {
  391.     apu2=0;
  392.     kplcnt1=0; kplcnt2=0;
  393.     tauluptr=realtaulu+1;
  394.     while(*tauluptr!=101) {
  395.         while(*tauluptr!=100) {
  396.             if(*(tauluptr+1)&GADGMAXSIZE) {
  397.                 apu1=maxgadw-rowwidth[kplcnt2];
  398.                 if(apu1) {
  399.                     if(apu1>tfw) apu1=tfw;
  400.                     txtlentab[kplcnt1]+=apu1;
  401.                     rowwidth[kplcnt2]+=apu1;
  402.                     apu2=1;
  403.                 }
  404.             }
  405.             kplcnt1++;
  406.             tauluptr+=((*(tauluptr+1))&0xff)+2;
  407.         }
  408.         kplcnt1++;
  409.         kplcnt2++;
  410.         tauluptr++;
  411.     }
  412. } while(apu2);
  413.  
  414. newwindow.Height=fmmain.naytto->WBorTop+fmmain.naytto->Font->ta_YSize+1+gadhnum*(tfh+valikoko)+2*spaceh;
  415. newwindow.Width=maxgadw+3*spacew;
  416. newwindow.Flags=WFLG_DRAGBAR|WFLG_DEPTHGADGET|WFLG_CLOSEGADGET|WFLG_SMART_REFRESH|WFLG_ACTIVATE|WFLG_RMBTRAP,
  417. newwindow.IDCMPFlags=IDCMP_REFRESHWINDOW|IDCMP_GADGETDOWN|IDCMP_GADGETUP|IDCMP_CLOSEWINDOW|IDCMP_ACTIVEWINDOW|IDCMP_RAWKEY,
  418. newwindow.DetailPen=fmconfig->txtpen; newwindow.BlockPen=fmconfig->hilipen;
  419. newwindow.FirstGadget=0;
  420. //newwindow.CheckMark=0;
  421. newwindow.Title=(UBYTE*)(*realtaulu);
  422. newwindow.Screen=screen;
  423. newwindow.Type=CUSTOMSCREEN;
  424. newwindow.BitMap=0;
  425.  
  426. if(newwindow.Height>fmmain.naytto->Height||newwindow.Width>fmmain.naytto->Width) {
  427.     trycnt++;
  428.     if(trycnt<=2) goto gretry;
  429.     if(trycnt==3) goto endreq;
  430. }
  431. if (!(gtgad=CreateContext(&glist))) goto endreq;
  432.  
  433. arrayptr=0;
  434. gadhnum=fmmain.naytto->WBorTop+fmmain.naytto->Font->ta_YSize+1+spaceh;
  435. kplcnt1=0; kplcnt2=0;
  436. gadgetnum=0;
  437. tauluptr=realtaulu+1;
  438. while(txtlentab[kplcnt1]!=-1) {
  439.     apu5=(maxgadw-rowwidth[kplcnt2]+1)/2+2*spacew;
  440.     while(txtlentab[kplcnt1]) {
  441.         gadgettype=*tauluptr;
  442.         memseti(tags,0,9*4);
  443.         switch(gadgettype) {
  444.             case INTEGER_KIND:
  445.             tags[0]=GTIN_Number;
  446.             tags[1]=((struct IntString*)*(tauluptr+2))->value;
  447.             tags[2]=STRINGA_Justification;
  448.             tags[3]=STRINGCENTER;
  449.             break;
  450.             case STRING_KIND:
  451.             tags[0]=GTST_String;
  452.             tags[1]=*(tauluptr+2);
  453.             tags[2]=GTST_MaxChars;
  454.             tags[3]=*(tauluptr+3);
  455.             tags[4]=STRINGA_Justification;
  456.             tags[5]=STRINGCENTER;
  457.             break;
  458.             case TEXT_KIND:
  459.             if((*(tauluptr+1)&GADGTEXTNUC)==0) {
  460.                 tags[0]=GT_Underscore;
  461.                 tags[1]='_';
  462.             }
  463.             vptr=scanchar((UBYTE*)*(tauluptr+2),'_');
  464.             shortcuts[gadgetnum]=0;
  465.             if(vptr) shortcuts[gadgetnum]=ToUpper(*(vptr+1));
  466.             break;
  467.             case CHECKBOX_KIND:
  468.             tags[0]=GT_Underscore;
  469.             tags[1]='_';
  470.             tags[2]=GTCB_Scaled;
  471.             tags[3]=1;
  472.             vptr=scanchar((UBYTE*)*(tauluptr+2),'_');
  473.             shortcuts[gadgetnum]=0;
  474.             if(vptr) shortcuts[gadgetnum]=ToUpper(*(vptr+1));
  475.             break;
  476.             case TOGGLE_KIND:
  477.             case BUTTON_KIND:
  478.             tags[0]=GT_Underscore;
  479.             tags[1]='_';
  480.             vptr=scanchar((UBYTE*)*(tauluptr+2),'_');
  481.             shortcuts[gadgetnum]=0;
  482.             if(vptr) shortcuts[gadgetnum]=ToUpper(*(vptr+1));
  483.             break;
  484.             case CYCLE_KIND:
  485.             tags[0]=GTCY_Labels;
  486.             tags[1]=(ULONG)&array[arrayptr];
  487.             tags[2]=GTCY_Active;
  488.             tags[3]=*(tauluptr+((*(tauluptr+1))&0xff)+1);
  489.             for(apu1=0;apu1<((*(tauluptr+1))&0xff)-1;apu1++) {
  490.                 array[arrayptr++]=*(tauluptr+2+apu1);
  491.             }
  492.             array[arrayptr++]=0;
  493.             break;
  494.             case PALETTE_KIND:
  495.             tags[0]=GTPA_Depth;
  496.             tags[1]=fmconfig->mainscreen.depth;
  497.             tags[2]=GTPA_Color;
  498.             *(tauluptr+2)&=(power2(fmconfig->mainscreen.depth)-1);
  499.             tags[3]=*(tauluptr+2);
  500.             tags[4]=GTPA_IndicatorWidth;
  501.             tags[5]=16;
  502.             tags[6]=GTPA_IndicatorHeight;
  503.             tags[7]=tfh+5;
  504.             break;
  505.         }
  506.         ngad.ng_TopEdge=apu1=gadhnum;
  507.         ngad.ng_LeftEdge=apu2=apu5;
  508.         ngad.ng_Height=apu3=tfh+spaceh;
  509.         ngad.ng_Width=apu4=txtlentab[kplcnt1]-spacew;
  510.         if (gadgettype!=TEXT_KIND) {
  511.             ngad.ng_GadgetID=shortcuts[gadgetnum];
  512.             if((*(tauluptr+1))>>24) ngad.ng_GadgetID=((*(tauluptr+1))>>24)|0x100;
  513.         } else {
  514.             ngad.ng_GadgetID=0;
  515.             if((*(tauluptr+1))&(GADGTEXTRIGHT|GADGTEXTLEFT)) {
  516.                 textextentuc(&rp,(UBYTE*)(*(tauluptr+2)),&ngad.ng_Width,&txoffset);
  517.                 if((*(tauluptr+1))&GADGTEXTRIGHT) ngad.ng_LeftEdge+=apu4-ngad.ng_Width;
  518.             }
  519.         }
  520.         if (trycnt<=1) ngad.ng_TextAttr=&fmconfig->reqfontattr; else ngad.ng_TextAttr=&fmconfig->smallfontattr;
  521.         if(gadgettype==BUTTON_KIND&&(*(tauluptr+1))&GADGDEFAULT) {
  522.             ngad.ng_TextAttr->ta_Style=FSF_BOLD;
  523.             retgadget=ngad.ng_GadgetID;
  524.         }
  525.         ngad.ng_UserData=0;
  526.         if (gadgettype==TEXT_KIND||gadgettype==BUTTON_KIND||gadgettype==TOGGLE_KIND) {
  527.             ngad.ng_GadgetText=(UBYTE*)(*(tauluptr+2));
  528.         } else {
  529.             ngad.ng_GadgetText=0;
  530.         }
  531.         ngad.ng_Flags=PLACETEXT_IN;
  532.         ngad.ng_VisualInfo=fmmain.gtvisual;
  533.         if(gadgettype==TOGGLE_KIND) {
  534.             if(!(gtgad=CreateGadgetA(BUTTON_KIND,gtgad,&ngad,(struct TagItem*)tags))) goto endreq;
  535.             gtgad->Activation|=TOGGLESELECT;
  536.             if (*(tauluptr+3)) gtgad->Flags|=SELECTED;
  537.         } else {
  538.             if(!(gtgad=CreateGadgetA(gadgettype,gtgad,&ngad,(struct TagItem*)tags))) goto endreq;
  539.         }
  540.         ngad.ng_TextAttr->ta_Style=0;
  541.         addressi[gadgetnum*2]=(ULONG)tauluptr;
  542.         addressi[gadgetnum*2+1]=(ULONG)gtgad;
  543.         if(gadgettype!=TEXT_KIND) gadgetnum++;
  544.         if ((gadgettype==STRING_KIND||gadgettype==INTEGER_KIND)&&!fstringgad) fstringgad=gtgad;
  545.         tauluptr+=((*(tauluptr+1))&0xff)+2;
  546.         apu5+=txtlentab[kplcnt1++];
  547.     }
  548.     gadhnum+=tfh+valikoko;
  549.     tauluptr++;
  550.     kplcnt1++;
  551.     kplcnt2++;
  552. }
  553.  
  554. getwinposition(screen,&newwindow,center,apu2+apu4/2,apu1+apu3/2);
  555. if (!(window=OpenWindowTagList(&newwindow,0))) goto endreq;
  556.  
  557. SetAPen(window->RPort,fmconfig->backfillpen);
  558. RectFill(window->RPort,window->BorderLeft,window->BorderTop,window->Width-window->BorderRight-1,window->Height-window->BorderBottom-1);
  559. /*
  560. SetAPen(window->RPort,fmconfig->backpen);
  561. gadhnum=fmmain.naytto->WBorTop+fmmain.naytto->Font->ta_YSize+1+spaceh;
  562. kplcnt1=0; kplcnt2=0;
  563. while(txtlentab[kplcnt1]!=-1) {
  564.     apu5=(maxgadw-rowwidth[kplcnt2]+1)/2+2*spacew;
  565.     while(txtlentab[kplcnt1]) {
  566.         RectFill(window->RPort,apu5,gadhnum,txtlentab[kplcnt1]-spacew+apu5-1,tfh+spaceh+gadhnum-1);
  567.         apu5+=txtlentab[kplcnt1++];
  568.     }
  569.     gadhnum+=tfh+valikoko;
  570.     kplcnt1++;
  571.     kplcnt2++;
  572. }
  573. */
  574.  
  575. if(trycnt==2) SetFont(window->RPort,fmmain.smallfont);
  576.  
  577. fmconfig->dosbuffersize|=(hcsum&0xff000000);
  578.  
  579. ScreenToFront(screen);
  580. AddGList(window,glist,-1,-1,0);
  581. RefreshGList(glist,window,0,-1);
  582. GT_RefreshWindow(window,0);
  583. supercheck(window,super,taulu,addressi);
  584. opened=1;
  585.  
  586. quit=-2;
  587. while (quit==-2) {
  588.     while(!(message=GT_GetIMsg(window->UserPort))) {
  589.             sigs=Wait((1L<<window->UserPort->mp_SigBit)|SIGBREAKF_CTRL_C);
  590.             if(sigs&SIGBREAKF_CTRL_C) {
  591.                 SetSignal(SIGBREAKF_CTRL_C,SIGBREAKF_CTRL_C);
  592.                 quit=0;
  593.                 continue;
  594.             }
  595.     }
  596.     class=message->Class;
  597.     code=message->Code;
  598.     switch(class) {
  599.         case IDCMP_ACTIVEWINDOW:
  600.         if (fstringgad&&!(fstringgad->Flags&GADGDISABLED)) ActivateGadget(fstringgad,window,0);
  601.         break;
  602.         case IDCMP_RAWKEY:
  603.         if(code&0x80) break;
  604.         ie.ie_Code=code;
  605.         ie.ie_Qualifier=message->Qualifier;
  606.         ie.ie_EventAddress=(APTR*)*((ULONG*)message->IAddress);
  607.         if (MapRawKey(&ie,chartab,2,0)==1) asciicode=ToUpper(chartab[0]); else break;
  608.  
  609.         if(asciicode==27) {
  610.             quit=0;
  611.             break;
  612.         }
  613.         for(apu1=0;apu1<gadgetnum;apu1++) {
  614.             if(shortcuts[apu1]==asciicode||(asciicode==13&&retgadget==shortcuts[apu1])) {
  615.                 asciicode=shortcuts[apu1];
  616.                 tauluptr=(ULONG*)addressi[apu1*2];
  617.                 vgad=(struct Gadget*)addressi[apu1*2+1];
  618.                 if(*tauluptr!=BUTTON_KIND&&(vgad->Flags&GADGDISABLED)) break;
  619.                 switch(*tauluptr)
  620.                 {
  621.                     case STRING_KIND:
  622.                     case INTEGER_KIND:
  623.                     if (vgad->Flags&GADGDISABLED) {
  624.                         fstringgad=vgad;
  625.                         ActivateGadget(fstringgad,window,0);
  626.                     }
  627.                     break;
  628.                     case BUTTON_KIND:
  629.                     quit=asciicode;
  630.                     break;
  631.                     case TOGGLE_KIND:
  632.                     RemoveGadget(window,vgad);
  633.                     vgad->Flags^=SELECTED;
  634.                     if (vgad->Flags&SELECTED) *(tauluptr+3)=1; else *(tauluptr+3)=0;
  635.                     AddGadget(window,vgad,-1);
  636.                     RefreshGList(vgad,window,0,1);
  637.                     break;
  638.                     case CYCLE_KIND:
  639.                     apu1=*(tauluptr+((*(tauluptr+1))&0xff)+1);
  640.                     if(message->Qualifier&0x03)
  641.                         apu1--;
  642.                         else
  643.                         apu1++;
  644.                     if(apu1<0) apu1=((*(tauluptr+1))&0xff)-2;
  645.                     if(apu1>=((*(tauluptr+1))&0xff)-1) apu1=0;
  646.                     GT_SetGadgetAttrs(vgad,window,0,GTCY_Active,apu1,TAG_DONE);
  647.                     *(tauluptr+((*(tauluptr+1))&0xff)+1)=apu1;
  648.                     break;
  649.                     case PALETTE_KIND:
  650.                     apu1=*(tauluptr+2);
  651.                     if(message->Qualifier&0x03)
  652.                         apu1--;
  653.                         else
  654.                         apu1++;
  655.                     apu1&=(power2(fmconfig->mainscreen.depth)-1);
  656.                     GT_SetGadgetAttrs(vgad,window,0,GTPA_Color,apu1,TAG_DONE);
  657.                     *(tauluptr+2)=apu1;
  658.                     break;
  659.                 }
  660.                 supercheck(window,super,taulu,addressi);
  661.                 break;
  662.             }
  663.         }
  664.         break;
  665.         case IDCMP_REFRESHWINDOW:
  666.         GT_BeginRefresh(window);
  667.         GT_EndRefresh(window,1);
  668.         break;
  669.         case IDCMP_CLOSEWINDOW:
  670.         quit=0;
  671.         break;
  672.         case IDCMP_GADGETUP:        
  673.         vgad=(struct Gadget*)message->IAddress;
  674.         for(apu1=0;apu1<gadgetnum;apu1++) {
  675.             if(addressi[apu1*2+1]==(ULONG)vgad) {
  676.                 tauluptr=(ULONG*)addressi[apu1*2];
  677.                 switch(*tauluptr)
  678.                 {
  679.                     case INTEGER_KIND:
  680.                     is=((struct IntString*)(*(tauluptr+2)));
  681.                     is->value=((struct StringInfo*)vgad->SpecialInfo)->LongInt;
  682.                     if(is->value<is->min) is->value=is->min;
  683.                     if(is->value>is->max) is->value=is->max;
  684.                     ((struct StringInfo*)vgad->SpecialInfo)->LongInt=is->value;
  685.                     sformat(((struct StringInfo*)vgad->SpecialInfo)->Buffer,"%ld",is->value);
  686.                     RefreshGList(vgad,window,0,1);
  687.                     case STRING_KIND:
  688.                     if(code!=0x09) quit=retgadget;
  689.                     break;
  690. /*
  691.                     apu2=apu1;
  692.                     for(;;) {
  693.                         if (message->Qualifier&0x03) apu2--; else apu2++;
  694.                         if(apu2>=gadgetnum) {
  695.                             apu2=apu1;
  696.                             break;
  697.                         }
  698.                         if(apu2<0) apu2=gadgetnum-1;
  699.                         if(*((ULONG*)addressi[apu2*2])==INTEGER_KIND||*((ULONG*)addressi[apu2*2])==STRING_KIND) {
  700.                             fstringgad=(struct Gadget*)addressi[apu2*2+1];
  701.                             ActivateGadget(fstringgad,window,0);
  702.                             break;
  703.                         }
  704.                     }
  705.                     if(apu2==apu1) quit=retgadget;
  706. */
  707.                     case TOGGLE_KIND:
  708.                     if (*(tauluptr+3)) *(tauluptr+3)=0; else *(tauluptr+3)=1;
  709.                     break;
  710.                     case BUTTON_KIND:
  711.                     quit=vgad->GadgetID; //shortcuts[apu1];
  712.                     break;
  713.                     case CYCLE_KIND:
  714.                     *(tauluptr+((*(tauluptr+1))&0xff)+1)=code;
  715.                     break;
  716.                     case PALETTE_KIND:
  717.                     *(tauluptr+2)=code;
  718.                     break;
  719.                 }
  720.                 supercheck(window,super,taulu,addressi);
  721.                 if(fstringgad&&!(fstringgad->Flags&GADGDISABLED)) ActivateGadget(fstringgad,window,0);
  722.                 break;
  723.             }
  724.         }
  725.         break;
  726.     }
  727.     GT_ReplyIMsg(message);
  728.  
  729. }
  730.  
  731. for(apu1=0;apu1<gadgetnum;apu1++) {
  732.     vgad=(struct Gadget*)addressi[apu1*2+1];
  733.     tauluptr=(ULONG*)addressi[apu1*2];
  734.     switch(*tauluptr) {
  735.         case STRING_KIND:
  736.         memseti((void*)*(tauluptr+2),0,*(tauluptr+3));
  737.         strcpy((UBYTE*)*(tauluptr+2),(UBYTE*)(((struct StringInfo*)vgad->SpecialInfo)->Buffer));
  738.         break;
  739.         case INTEGER_KIND:
  740.         is=((struct IntString*)(*(tauluptr+2)));
  741.         is->value=((struct StringInfo*)vgad->SpecialInfo)->LongInt;
  742.         if(is->value<is->min) is->value=is->min;
  743.         if(is->value>is->max) is->value=is->max;
  744.         break;
  745.     }
  746. }
  747.  
  748. endreq:
  749. ilock=LockIBase(0);
  750. if (IntuitionBase->FirstScreen==screen) {
  751.     UnlockIBase(ilock);
  752.     ScreenToFront(oldscreen);
  753. } else {
  754.     UnlockIBase(ilock);
  755. }
  756. if (window) CloseWindow(window);
  757. if (glist) FreeGadgets(glist);
  758. if(!opened) DisplayBeep(screen);
  759. return(quit);
  760. }
  761.  
  762. WORD pressgadget(struct Window *win,struct Gadget *gad)
  763. {
  764. WORD pos;
  765.  
  766. if(gad<(struct Gadget*)4) return(1);
  767. if(!(gad->Activation&TOGGLESELECT)&&!(gad->Flags&GADGDISABLED)) {
  768.     pos=RemoveGadget(win,gad);
  769.     gad->Flags|=SELECTED;
  770.     gad->Activation|=TOGGLESELECT;
  771.     AddGadget(win,gad,pos);
  772.     RefreshGList(gad,win,0,1);
  773.     pos=RemoveGadget(win,gad);
  774.     gad->Flags|=GADGDISABLED;
  775.     AddGadget(win,gad,pos);
  776.     return(1);
  777. }
  778. return(0);
  779. }
  780. void unpressgadget(struct Window *win,struct Gadget *gad)
  781. {
  782. WORD pos;
  783.  
  784. if(gad<(struct Gadget*)4) return;
  785. if(gad->Activation&TOGGLESELECT) {
  786.     pos=RemoveGadget(win,gad);
  787.     gad->Flags&=~(SELECTED|GADGDISABLED);
  788.     gad->Activation&=~TOGGLESELECT;
  789.     AddGadget(win,gad,pos);
  790.     RefreshGList(gad,win,0,1);
  791. }
  792. }
  793.  
  794. UBYTE *scanchar(UBYTE *ptr,UBYTE ch)
  795. {
  796. while(*ptr) {
  797.     if (*ptr==ch) return(ptr);
  798.     ptr++;
  799. }
  800. return(0);
  801. }
  802.  
  803. void textextent(struct RastPort *rp,UBYTE *ptr,WORD *width,WORD *offset)
  804. {
  805. struct TextExtent te;
  806.  
  807. TextExtent(rp,ptr,strlen(ptr),&te);
  808. *offset=te.te_Extent.MinX;
  809. *width=te.te_Extent.MaxX+te.te_Extent.MinX;
  810. }
  811. void textextentuc(struct RastPort *rp,UBYTE *ptr,WORD *width,WORD *offset)
  812. {
  813. struct TextExtent te;
  814. UBYTE varaptr[100];
  815.  
  816. copyus(varaptr,ptr);
  817. TextExtent(rp,varaptr,strlen(varaptr),&te);
  818. *width=te.te_Extent.MaxX+te.te_Extent.MinX;
  819. *offset=te.te_Extent.MinX;
  820. }
  821.  
  822. void dotext(WORD *c,ULONG *t,WORD msg,ULONG type)
  823. {
  824. t+=*c;
  825. *t++=TEXT_KIND;
  826. *t++=1|(type&0xffffff00);
  827. *t++=(ULONG)getstring(msg);
  828. (*c)+=3;
  829. if(type&1) { *t=100; (*c)++; }
  830. }
  831. void dostring(WORD *c,ULONG *t,UBYTE *msg,ULONG type)
  832. {
  833. UBYTE *ptr;
  834. ULONG *tt;
  835.  
  836. tt=t;
  837. t+=*c;
  838. *t++=TEXT_KIND;
  839. *t++=1|(type&0xffffff00);
  840. *t++=(ULONG)msg;
  841. (*c)+=3;
  842. if(type&1) { *t=100; (*c)++; }
  843. ptr=scanchar(msg,'\n');
  844. if(ptr) {
  845.     *ptr++=0;
  846.     dostring(c,tt,ptr,type);
  847. }
  848. }
  849. void dobutton(WORD *c,ULONG *t,WORD msg,ULONG type)
  850. {
  851. dobuttonstring(c,t,getstring(msg),type);
  852. }
  853. void dobuttonstring(WORD *c,ULONG *t,UBYTE *msg,ULONG type)
  854. {
  855. t+=*c;
  856. *t++=BUTTON_KIND;
  857. *t++=1|(type&0xffffff00);
  858. *t++=(ULONG)msg;
  859. (*c)+=3;
  860. if(type&GADGEOF) { *t=100; (*c)++; }
  861. }
  862. void doletterbutton(WORD *c,ULONG *t,WORD msg,WORD letter,ULONG type)
  863. {
  864. donumbuttonstring(c,t,getstring(msg),letter+'A'-'0',type);
  865. }
  866. void doletterbuttonstring(WORD *c,ULONG *t,UBYTE *msg,WORD letter,ULONG type)
  867. {
  868. donumbuttonstring(c,t,msg,letter+'A'-'0',type);
  869. }
  870. void donumbutton(WORD *c,ULONG *t,WORD msg,WORD num,ULONG type)
  871. {
  872. donumbuttonstring(c,t,getstring(msg),num,type);
  873. }
  874. void donumbuttonstring(WORD *c,ULONG *t,UBYTE *msg,WORD num,ULONG type)
  875. {
  876. UBYTE *txt;
  877.  
  878. t+=*c;
  879. *t++=BUTTON_KIND;
  880. *t++=15L<<16|2;
  881. *t=(ULONG)(t+1);
  882. t++;
  883. txt=(UBYTE*)t++;
  884. *txt++='_';
  885. *txt++=num+'0';
  886. *txt=0;
  887.  
  888. *t++=BUTTON_KIND;
  889. *t++=(LONG)(num+'0')<<24|14L<<16|1|GADGTEXTNUC|(type&0xffffff00);
  890. *t++=(ULONG)msg;
  891.  
  892. (*c)+=7;
  893. if(type&GADGEOF) { *t=100; (*c)++; }
  894. }
  895.  
  896.  
  897. ULONG *docyclenumber(WORD *c,ULONG *t,ULONG type,WORD sel,WORD s,WORD e)
  898. {
  899. WORD cnt,num;
  900. ULONG *dat;
  901.  
  902. num=e-s+1;
  903. t+=*c;
  904. *t++=CYCLE_KIND;
  905. *t++=(num+1)|(type&0xffffff00);
  906. for(cnt=s;cnt<=e;cnt++) *t++=(ULONG)(&gadnumbers[cnt*2]);
  907. dat=t;
  908. if(sel>=num) sel=num-1;
  909. *t++=sel;
  910. (*c)+=3+num;
  911. if(type&GADGEOF) { *t=100; (*c)++; }
  912. return(dat);
  913. }
  914.  
  915. ULONG *docyclestring(WORD *c,ULONG *t,WORD num,ULONG type,WORD sel,UBYTE *txt1,...)
  916. {
  917. WORD cnt;
  918. ULONG *dat;
  919.  
  920. t+=*c;
  921. *t++=CYCLE_KIND;
  922. *t++=(num+1)|(type&0xffffff00);
  923. for(cnt=0;cnt<num;cnt++) *t++=(ULONG)(*(&txt1+cnt));
  924. dat=t;
  925. if(sel>=num) sel=num-1;
  926. *t++=sel;
  927. (*c)+=3+num;
  928. if(type&GADGEOF) { *t=100; (*c)++; }
  929. return(dat);
  930. }
  931.  
  932. ULONG *docycle(WORD *c,ULONG *t,WORD num,ULONG type,WORD sel,WORD msg1,...)
  933. {
  934. WORD cnt;
  935. ULONG *dat;
  936.  
  937. t+=*c;
  938. *t++=CYCLE_KIND;
  939. *t++=(num+1)|(type&0xffffff00);
  940. for(cnt=0;cnt<num;cnt++) *t++=(ULONG)getstring(*(&msg1+cnt));
  941. dat=t;
  942. if(sel>=num) sel=num-1;
  943. *t++=sel;
  944. (*c)+=3+num;
  945. if(type&GADGEOF) { *t=100; (*c)++; }
  946. return(dat);
  947. }
  948. ULONG *doswitch(WORD *c,ULONG *t,WORD msg,WORD num,ULONG type)
  949. {
  950. return(doswitchstring(c,t,getstring(msg),num,type));
  951. }
  952. ULONG *doswitchstring(WORD *c,ULONG *t,UBYTE *msg,WORD num,ULONG type)
  953. {
  954. ULONG *dat;
  955.  
  956. if(num) num=1;
  957. t+=*c;
  958. *t++=TOGGLE_KIND;
  959. *t++=2;
  960. *t++=(ULONG)msg;
  961. dat=t;
  962. *t++=num;
  963. (*c)+=4;
  964. if(type&GADGEOF) { *t=100; (*c)++; }
  965. return(dat);
  966. }
  967. ULONG *dotoggle(WORD *c,ULONG *t,WORD msg,WORD num,ULONG type)
  968. {
  969. return(dotogglestring(c,t,getstring(msg),num,type));
  970. }
  971. ULONG *dotogglestring(WORD *c,ULONG *t,UBYTE *msg,WORD num,ULONG type)
  972. {
  973. ULONG *dat;
  974. WORD numi=num?1:0;
  975.  
  976. dostring(c,t,msg,(type&0xffffff00)|GADGTEXTRIGHT);
  977. dat=docycle(c,t,2,(type&1)|GADGMAXSIZE,numi,MSG_NON,MSG_YESN);
  978. return(dat);
  979. }
  980.  
  981. ULONG *dointegergad(WORD *c,ULONG *t,struct IntString *is,ULONG type)
  982. {
  983. ULONG *dat;
  984.  
  985. t+=*c;
  986. *t++=INTEGER_KIND;
  987. *t++=1|(type&0xffffff00);
  988. dat=t;
  989. *t++=(ULONG)is;
  990. (*c)+=3;
  991. if(type&GADGEOF) { *t=100; (*c)++; }
  992. return(dat);
  993. }
  994. void dostringgad(WORD *c,ULONG *t,UBYTE *string,WORD maxlen,ULONG type)
  995. {
  996. t+=*c;
  997. *t++=STRING_KIND;
  998. *t++=2|(type&0xffffff00);
  999. *t++=(ULONG)string;
  1000. *t++=maxlen;
  1001. (*c)+=4;
  1002. if(type&GADGEOF) { *t=100; (*c)++; }
  1003. }
  1004.  
  1005. /*
  1006.  
  1007. 1.ulong gadgetnum<<16 | gadget value <<8 | number of modified gadgets
  1008.  
  1009. number of modified gadgets amount of ulongs
  1010. 2.ulong
  1011.     bit 31, 1=disable,0=enable
  1012.     bit 30, 1=change gadget value,0=don't change
  1013.     bits 15-8 new gadget value  (only if bit 30 = 1)
  1014.     bits 0-7 gadget number to be set
  1015. 3.ulong -- : --
  1016.  
  1017. */
  1018.  
  1019. void supercheck(struct Window *win,ULONG *super,ULONG *taulu,ULONG *addressi)
  1020. {
  1021. struct Gadget *vgad;
  1022. ULONG *tauluptr;
  1023. WORD gadnum,gadvalue,listnum;
  1024. WORD cnt=0,apu1,apu2;
  1025. UBYTE selected,sel2;
  1026. ULONG lapu;
  1027.  
  1028. while(super&&super[cnt]) {
  1029.     selected=0;
  1030.     lapu=super[cnt++];
  1031.     gadnum=(lapu>>16)&0xff;
  1032.     gadvalue=(lapu>>8)&0xff;
  1033.     sel2=gadvalue&0x80; gadvalue&=~0x80;
  1034.     listnum=(lapu)&0xff;
  1035.     tauluptr=(ULONG*)addressi[gadnum*2];
  1036.     vgad=(struct Gadget*)addressi[gadnum*2+1];
  1037.     switch(*tauluptr)
  1038.     {
  1039.     case TOGGLE_KIND:
  1040.     if((vgad->Flags&SELECTED&&gadvalue)||(!(vgad->Flags&SELECTED)&&!gadvalue)) selected=1;
  1041.     break;
  1042.     case CYCLE_KIND:
  1043.     if (*(tauluptr+((*(tauluptr+1))&0xff)+1)==gadvalue) selected=1;
  1044.     break;
  1045.     case PALETTE_KIND:
  1046.     if (*(tauluptr+2)==gadvalue) selected=1;
  1047.     break;
  1048.     }
  1049.     if((selected&&!sel2)||(!selected&&sel2)) {
  1050.         for(apu1=0;apu1<listnum;apu1++) {
  1051.             lapu=super[cnt++];
  1052.             gadnum=lapu&0xff;
  1053.             apu2=(lapu>>8)&0xff;
  1054.             vgad=(struct Gadget*)addressi[gadnum*2+1];
  1055.             tauluptr=(ULONG*)addressi[gadnum*2];
  1056.             if(lapu&SDISABLE && !(vgad->Flags&GADGDISABLED)) {
  1057.                 RemoveGadget(win,vgad);
  1058.                 vgad->Flags|=GADGDISABLED;
  1059.                 AddGadget(win,vgad,-1);
  1060.                 RefreshGList(vgad,win,0,1);
  1061.             } else if(!(lapu&SDISABLE) && (vgad->Flags&GADGDISABLED)) {
  1062.                 RemoveGadget(win,vgad);
  1063.                 vgad->Flags&=~GADGDISABLED;
  1064.                 AddGadget(win,vgad,-1);
  1065.                 RefreshGList(vgad,win,0,1);
  1066.                 if((vgad->GadgetType&7)==STRGADGET) ActivateGadget(vgad,win,0);
  1067.             }
  1068.             if(lapu&SCHANGE) {
  1069.                 switch(*tauluptr)
  1070.                 {
  1071.                 case TOGGLE_KIND:
  1072.                 if(*(tauluptr+3)!=apu2) {
  1073.                     RemoveGadget(win,vgad);
  1074.                     *(tauluptr+3)=apu2;
  1075.                     if(apu2) vgad->Flags|=SELECTED; else vgad->Flags&=~SELECTED;
  1076.                     AddGadget(win,vgad,-1);
  1077.                     RefreshGList(vgad,win,0,1);
  1078.                 }
  1079.                 break;
  1080.                 case CYCLE_KIND:
  1081.                 if(*(tauluptr+((*(tauluptr+1))&0xff)+1)!=apu2) {
  1082.                     *(tauluptr+((*(tauluptr+1))&0xff)+1)=apu2;
  1083.                     GT_SetGadgetAttrs(vgad,win,0,GTCY_Active,apu2,TAG_DONE);
  1084.                 }
  1085.                 break;
  1086.                 case PALETTE_KIND:
  1087.                 if(*(tauluptr+2)!=apu2) {
  1088.                     *(tauluptr+2)=apu2;
  1089.                     GT_SetGadgetAttrs(vgad,win,0,GTPA_Color,apu2,TAG_DONE);
  1090.                 }
  1091.                 break;
  1092.                 }
  1093.             }
  1094.         }
  1095.     } else {
  1096.         cnt+=listnum;
  1097.     }
  1098. }
  1099. }
  1100.  
  1101. WORD simplebguirequest(Object *o)
  1102. {
  1103. struct Window *w;
  1104. ULONG signal,sigs,rc;
  1105. WORD ret=0;
  1106.  
  1107. if(o) {
  1108.     w=WindowOpen(o);
  1109.     if(w) {
  1110.         ret=-1;
  1111.         GetAttr(WINDOW_SigMask,o,&signal);
  1112.         while(ret==-1) {
  1113.             sigs=Wait(signal|SIGBREAKF_CTRL_C);
  1114.             if(sigs&SIGBREAKF_CTRL_C) ret=0;
  1115.             while((rc=HandleEvent(o))!=WMHI_NOMORE) {
  1116.                 if(rc==WMHI_CLOSEWINDOW) ret=0;
  1117.                 if(rc>=20&&rc<=30) ret=rc-19;
  1118.             }                        
  1119.         }
  1120.     }
  1121.     DisposeObject(o);
  1122. }
  1123. return(ret);
  1124. }
  1125.  
  1126.  
  1127.