home *** CD-ROM | disk | FTP | other *** search
/ Enigma Amiga Life 113 / EnigmaAmiga113CD.iso / software / sviluppo / fm2000 / fmgui.c < prev    next >
Encoding:
C/C++ Source or Header  |  2000-02-04  |  17.2 KB  |  878 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. #include <exec/memory.h>
  21. #include <proto/all.h>
  22. #include <stdio.h>
  23. #include <string.h>
  24. #include <intuition/gadgetclass.h>
  25. #include "fmgui.h"
  26. #include "fmlocale.h"
  27. #include "fmnode.h"
  28. #include "config.h"
  29. #include "fmdos.h"
  30.  
  31. /* #define GUIDEBUG */
  32.  
  33. extern struct FMConfig *fmconfig;
  34. extern struct FMMain fmmain;
  35.  
  36. struct GUISlot *getguislotonly(struct GUIBase *gb)
  37. {
  38. struct GUIGroup *gg;
  39. struct GUISlot *gs;
  40.  
  41. if(!gb) return(0);
  42. gg=gb->groups[gb->currentgroup];
  43. if(!gg) return(0);
  44. gs=&gg->slots[gg->used];
  45. gg->used++;
  46. return(gs);
  47. }
  48.  
  49. struct GUISlot *getguislot(struct GUIBase *gb,Object *obj,WORD id,WORD type,void *data)
  50. {
  51. struct GUISlot *gs;
  52. gs=getguislotonly(gb);
  53. if(gs) {
  54.     gs->obj=obj;
  55.     gs->id=id;
  56.     gs->type=type;
  57.     gs->data=data;
  58. }
  59. return(gs);
  60. }
  61.  
  62. static void guimulticonvert2(void **text,LONG *msgs)
  63. {
  64. void **txtptr;
  65. txtptr=text;
  66. while(*msgs) {
  67.     *txtptr++=getstring(*msgs++);
  68.     *txtptr++=(UBYTE*)*msgs++;
  69. }
  70. *txtptr=0;
  71. }
  72.  
  73. static void guimulticonvert(UBYTE **text,LONG *msgs)
  74. {
  75. UBYTE **txtptr;
  76. txtptr=text;
  77. while(*msgs) {
  78.     *txtptr++=getstring(*msgs++);
  79. }
  80. *txtptr=0;
  81. }
  82.  
  83. /* INFO */
  84.  
  85. static UBYTE infocen[]={"\33c"};
  86. static UBYTE infoleft[]={"\33l"};
  87. static UBYTE infouc1[]={"\33z"};
  88. static UBYTE infouc2[]={"\33-z"};
  89.  
  90. static struct GUISlot *reqinfo2(struct GUIBase *gb,UBYTE *txt,WORD id,UWORD flags)
  91. {
  92. WORD numlines;
  93. UBYTE *ptr1,*mem;
  94. struct GUISlot *gs;
  95. UBYTE sh;
  96.  
  97. #ifdef GUIDEBUG
  98. printf("INFO:\n");
  99. #endif
  100.  
  101. sh=0;
  102. numlines=1;
  103. ptr1=txt;
  104. while(*ptr1) {
  105.     if(*ptr1=='\n') numlines++;
  106.     ptr1++;
  107. }
  108. mem=allocmem(strlen(txt)+16);
  109. if(!mem) return(0);
  110. ptr1=mem;
  111. *ptr1=0;
  112. if(flags&guiLEFT) strcpy(ptr1,infoleft);
  113. ptr1+=strlen(ptr1);
  114. if(flags&guiCENTER) strcpy(ptr1,infocen);
  115. ptr1+=strlen(ptr1);
  116. if(flags&guiUC) {
  117.     while(*txt) {
  118.         if(*txt=='_') {
  119.             sh=ToUpper(txt[1]);
  120.             strcpy(ptr1,infouc1);
  121.             ptr1+=strlen(ptr1);
  122.             *ptr1++=txt[1];
  123.             strcpy(ptr1,infouc2);
  124.             ptr1+=strlen(ptr1);
  125.             txt+=2;
  126.         } else *ptr1++=*txt++;
  127.     }
  128.     *ptr1=0;
  129. } else {
  130.     strcpy(ptr1,txt);
  131. }
  132.  
  133. gs=getguislot(gb,BGUI_NewObject(BGUI_INFO_GADGET,
  134.     INFO_HorizOffset,4,INFO_VertOffset,4,
  135.     INFO_TextFormat,mem,
  136.     INFO_MinLines,numlines,
  137.     INFO_FixTextWidth,TRUE,
  138.     FRM_Type,FRTYPE_BUTTON,
  139.     FRM_Flags,FRF_RECESSED,
  140.     TAG_DONE),id,0,mem);
  141. if(gs) gs->shortcut[0]=sh;
  142. return(gs);
  143. }
  144.  
  145. struct GUISlot *reqinfo(struct GUIBase *gb,UBYTE *txt,WORD id,UWORD flags)
  146. {
  147. return(reqinfo2(gb,txt,id,flags));
  148. }
  149.  
  150. struct GUISlot *reqinfomsg(struct GUIBase *gb,WORD msg,WORD id,UWORD flags)
  151. {
  152. return(reqinfo2(gb,getstring(msg),id,flags));
  153. }
  154.  
  155. /* CYCLE */
  156.  
  157. struct CycleData {
  158.     WORD *selected;
  159.     UBYTE *cycles[64];
  160.     UBYTE data;
  161. };
  162.  
  163. static struct GUISlot *reqcyclei(struct GUIBase *gb,WORD id,WORD *selected,UBYTE **cycles)
  164. {
  165. struct CycleData *cd;
  166. WORD num,len;
  167. UBYTE **cycs;
  168. UBYTE *ptr;
  169.  
  170. cycs=cycles;
  171. len=0;
  172. while(*cycs) {
  173.     len+=strlen(*cycs)+1;
  174.     cycs++;
  175. }
  176. cd=allocmem(sizeof(struct CycleData)+len);
  177. if(!cd) return(0);
  178. cd->selected=selected;
  179. cycs=cycles;
  180. num=0;
  181. ptr=&cd->data;
  182. while(*cycs) {
  183.     cd->cycles[num]=ptr;
  184.     strcpy(ptr,*cycs);
  185.     ptr+=strlen(ptr)+1;
  186.     num++;
  187.     cycs++;
  188. }
  189. #ifdef GUIDEBUG
  190. printf("CYCLE:\n");
  191. #endif
  192. return(getguislot(gb,BGUI_NewObject(BGUI_CYCLE_GADGET,
  193.     CYC_Active,*cd->selected,
  194.     CYC_Labels,&cd->cycles[0],
  195.     CYC_Popup,TRUE,
  196.     GA_ID,id,
  197.     TAG_DONE),id,CYCLE_KIND,cd));
  198. }
  199.  
  200. struct GUISlot *reqcycle2msg(struct GUIBase *gb,WORD id,WORD *selected)
  201. {
  202. UBYTE *cycletab[3];
  203. cycletab[0]=getstring(MSG_NON);
  204. cycletab[1]=getstring(MSG_YESN);
  205. cycletab[2]=0;
  206. return(reqcyclei(gb,id,selected,cycletab));
  207. }
  208.  
  209. struct GUISlot *reqcyclemsg(struct GUIBase *gb,WORD id,WORD *selected,LONG cycles,...)
  210. {
  211. UBYTE *cycletab[64];
  212. guimulticonvert(cycletab,&cycles);
  213. return(reqcyclei(gb,id,selected,cycletab));
  214. }
  215.  
  216. struct GUISlot *reqcycle(struct GUIBase *gb,WORD id,WORD *selected,UBYTE *cycles,...)
  217. {
  218. return(reqcyclei(gb,id,selected,&cycles));
  219. }
  220.  
  221. /* TOGGLE */
  222.  
  223. struct GUISlot *reqtoggle(struct GUIBase *gb,UBYTE *txt,WORD id,UWORD flags,BOOL *selected)
  224. {
  225. #ifdef GUIDEBUG
  226. printf("TOGGLE:\n");
  227. #endif
  228. return(getguislot(gb,BGUI_NewObject(BGUI_BUTTON_GADGET,
  229.     GA_ToggleSelect,TRUE,
  230.     LAB_Label,txt,
  231.     LAB_Underscore,'_',
  232.     GA_Selected,*selected,
  233.     GA_ID,id,
  234.     TAG_DONE),id,10,selected));
  235. }
  236.  
  237. struct GUISlot *reqtogglemsg(struct GUIBase *gb,WORD txt,WORD id,UWORD flags,BOOL *selected)
  238. {
  239. return(reqtoggle(gb,getstring(txt),id,flags,selected));
  240. }
  241.  
  242. /*  BUTTON */
  243.  
  244. struct GUISlot *reqbutton(struct GUIBase *gb,UBYTE *txt,WORD id,UWORD flags)
  245. {
  246. #ifdef GUIDEBUG
  247. printf("BUTTON:\n");
  248. #endif
  249. return(getguislot(gb,BGUI_NewObject(BGUI_BUTTON_GADGET,
  250.     LAB_Label,txt,
  251.     LAB_Underscore,'_',
  252.     GA_ID,id,
  253.     TAG_DONE),
  254.     id,BUTTON_KIND,0));
  255. }
  256.  
  257. struct GUISlot *reqbuttonmsg(struct GUIBase *gb,WORD msg,WORD id,UWORD flags)
  258. {
  259. return(reqbutton(gb,getstring(msg),id,flags));
  260. }
  261.  
  262. /* STRING */
  263.  
  264. struct GUISlot *reqstring(struct GUIBase *gb,WORD id,UBYTE *str,WORD max)
  265. {
  266. WORD vis;
  267.  
  268. #ifdef GUIDEBUG
  269. printf("STRING:\n");
  270. #endif
  271. vis=max;
  272. if(max>16) vis=16;
  273. return(getguislot(gb,BGUI_NewObject(BGUI_STRING_GADGET,
  274.     STRINGA_Justification,GACT_STRINGCENTER,
  275.     STRINGA_TextVal,str,
  276.     STRINGA_MinCharsVisible,vis,
  277.     STRINGA_MaxChars,max,
  278.     GA_TabCycle,TRUE,
  279.     GA_ID,id,
  280.     TAG_DONE),id,STRING_KIND,str));
  281. }
  282.  
  283. /* INTEGER */
  284.  
  285. struct GUISlot *reqinteger(struct GUIBase *gb,WORD id,LONG *value,LONG min,LONG max)
  286. {
  287. #ifdef GUIDEBUG
  288. printf("INTEGER:\n");
  289. #endif
  290. return(getguislot(gb,BGUI_NewObject(BGUI_STRING_GADGET,
  291.     STRINGA_IntegerMin,min,
  292.     STRINGA_IntegerMax,max,
  293.     STRINGA_Justification,GACT_STRINGCENTER,
  294.     STRINGA_LongVal,*value,
  295.     STRINGA_MaxChars,10,
  296.     STRINGA_MinCharsVisible,10,
  297.     GA_TabCycle,TRUE,
  298.     GA_ID,id,
  299.     TAG_DONE),id,INTEGER_KIND,value));
  300. }
  301.  
  302. /* PALETTE */
  303.  
  304. struct GUISlot *reqpalette(struct GUIBase *gb,WORD id,UBYTE *col)
  305. {
  306. #ifdef GUIDEBUG
  307. printf("PALETTE:\n");
  308. #endif
  309. return(getguislot(gb,BGUI_NewObject(BGUI_PALETTE_GADGET,
  310.     FRM_Type,FRTYPE_BUTTON,
  311.     FRM_Recessed,TRUE,
  312.     PALETTE_Depth,fmconfig->mainscreen.depth,
  313.     PALETTE_CurrentColor,*col,
  314.     GA_ID,id,
  315.     TAG_DONE),id,PALETTE_KIND,col));
  316. }
  317.  
  318. /* ------------------------------------------------------ */
  319.  
  320. static void activatestrings(struct GUIBase *gb)
  321. {
  322. WORD cnt1,cnt2;
  323. struct GUIGroup *gg;
  324. struct GUISlot *gs;
  325.  
  326. for(cnt1=0;cnt1<GUIGROUPS;cnt1++) {
  327.     gg=gb->groups[cnt1];
  328.     if(gg) {
  329.         for(cnt2=0;cnt2<gg->used;cnt2++) {
  330.             gs=&gg->slots[cnt2];
  331.             if(gs->type==STRING_KIND||gs->type==INTEGER_KIND) {
  332.                 ActivateGadget((struct Gadget*)gs->obj,gb->win,0);
  333.                 return;
  334.             }
  335.         }
  336.     }
  337. }
  338. }
  339.  
  340. static void settabcycle(struct GUIBase *gb)
  341. {
  342. ULONG ss[64];
  343. WORD cnt1,cnt2,cnt3,cnt11,cnt22;
  344. struct GUISlot *gs,*gs2;
  345. struct GUIGroup *gg,*gg2;
  346. struct wmGadgetKey wmg;
  347. Object *obj;
  348.  
  349. cnt3=0;
  350. ss[cnt3++]=WM_TABCYCLE_ORDER;
  351. for(cnt1=0;cnt1<GUIGROUPS;cnt1++) {
  352.     gg=gb->groups[cnt1];
  353.     if(gg) {
  354.         for(cnt2=0;cnt2<gg->used;cnt2++) {
  355.             gs=&gg->slots[cnt2];
  356.             if(gs->type==0&&gs->shortcut[0]&&gs->id>0) {
  357.                 obj=0;
  358.                 for(cnt11=0;cnt11<GUIGROUPS;cnt11++) {
  359.                     gg2=gb->groups[cnt11];
  360.                     if(gg2) {
  361.                         for(cnt22=0;cnt22<gg2->used;cnt22++) {
  362.                             gs2=&gg2->slots[cnt22];
  363.                             if(gs2!=gs&&gs2->id==gs->id) {
  364.                                 obj=gs2->obj;
  365.                                 break;
  366.                             }
  367.                         }
  368.                     }
  369.                     if(obj) break;
  370.                 }
  371.                 if(obj) {
  372.                     wmg.MethodID=WM_GADGETKEY;
  373.                     wmg.wmgk_Requester=0;
  374.                     wmg.wmgk_Object=obj;
  375.                     wmg.wmgk_Key=gs->shortcut;
  376.                     DoMethodA(gb->obj,(Msg)&wmg);
  377.                 }
  378.             }
  379.             if(gs->type==STRING_KIND||gs->type==INTEGER_KIND) {
  380.                 ss[cnt3++]=(ULONG)gs->obj;
  381.             }
  382.         }
  383.     }
  384. }
  385. ss[cnt3++]=0;
  386. if(cnt3>2) DoMethodA(gb->obj,(Msg)ss);
  387. }
  388.  
  389. void setconnectgroup(struct GUIBase *gb,WORD group,WORD alignment,WORD dest)
  390. {
  391. setguigroup(gb,group,alignment);
  392. connectgroups(gb,dest,group);
  393. }
  394.  
  395. void connectgroups(struct GUIBase *gb,WORD destgroup,WORD srcgroup)
  396. {
  397. struct GUISlot *gs;
  398. WORD apu1;
  399.  
  400. apu1=gb->currentgroup;
  401. gb->currentgroup=destgroup;
  402. gs=getguislotonly(gb);
  403. gs->type=1000+srcgroup;
  404. gb->currentgroup=apu1;
  405. #ifdef GUIDEBUG
  406. printf("CONNECTED: %ld -> %ld\n",srcgroup,destgroup);
  407. #endif
  408. }
  409.  
  410. struct GUIBase *getguibase(UBYTE *title)
  411. {
  412. struct GUIBase *gb;
  413. gb=allocmem(sizeof(struct GUIBase));
  414. if(gb) {
  415.     gb->title=title;
  416. }
  417. setguigroup(gb,0,1);
  418. return(gb);
  419. }
  420.  
  421. void setguigroup(struct GUIBase *gb,WORD group,WORD alignment)
  422. {
  423. struct GUIGroup **ggptr;
  424. struct GUIGroup *gg;
  425.  
  426. gb->currentgroup=group;
  427. ggptr=&gb->groups[gb->currentgroup];
  428. if(!ggptr[0]) {
  429.     gg=allocmem(sizeof(struct GUIGroup));
  430.     gg->alignment=alignment;
  431.     ggptr[0]=gg;
  432. }
  433. #ifdef GUIDEBUG
  434. printf("SETGROUP %ld, alignment %ld\n",group,alignment);
  435. #endif
  436. }
  437.  
  438. void freereq(struct GUIBase *gb)
  439. {
  440. WORD cnt1,cnt2;
  441. struct GUIGroup *gg;
  442. WORD dispo=1;
  443.  
  444. closereq(gb);
  445. #ifdef GUIDEBUG
  446. printf("FREEREQ\n");
  447. #endif
  448. if(!gb) return;
  449. if(gb->obj) {
  450.     DisposeObject(gb->obj);
  451.     dispo=0;
  452. }
  453. for(cnt1=0;cnt1<GUIGROUPS;cnt1++) {
  454.     gg=gb->groups[cnt1];
  455.     if(gg) {
  456.         for(cnt2=0;cnt2<gg->used;cnt2++) {
  457.             if(dispo&&gg->slots[cnt2].obj) DisposeObject(gg->slots[cnt2].obj);
  458.             if(gg->slots[cnt2].data) {
  459.                 switch(gg->slots[cnt2].type)
  460.                 {
  461.                 case 0:    // INFO
  462.                 case CYCLE_KIND:
  463.                 freemem(gg->slots[cnt2].data);
  464.                 break;
  465.                 }
  466.             }
  467.         }
  468.         freemem(gg);
  469.     }
  470. }
  471. freemem(gb);
  472. }
  473.  
  474. ULONG initgroup[]={
  475.     GROUP_BackFill,4,
  476.     GROUP_HorizOffset,4,
  477.     GROUP_VertOffset,4,
  478.     GROUP_Spacing,GRSPACE_NORMAL
  479. };
  480.  
  481. Object *recurseslot(struct GUIBase *gb,WORD group)
  482. {
  483. Object *obj=0;
  484. struct GUIGroup *gg;
  485. struct GUISlot *gs;
  486. ULONG *memtag;
  487. ULONG *tptr;
  488. WORD cnt1;
  489.  
  490. #ifdef GUIDEBUG
  491. printf("RECURSESLOT: %ld:\n",group);
  492. #endif
  493. memtag=allocmem(sizeof(ULONG)*256);
  494. if(!memtag) goto error;
  495. tptr=memtag;
  496. gg=gb->groups[group];
  497. if(!gg) goto error;
  498. if(gg->alignment) {
  499.     *tptr++=GROUP_Style;
  500.     *tptr++=GRSTYLE_VERTICAL;
  501. }
  502. if(!group) {
  503.     CopyMem(initgroup,tptr,sizeof(initgroup));
  504.     tptr+=sizeof(initgroup)/sizeof(ULONG);
  505. } else {
  506.     *tptr++=GROUP_Spacing;
  507.     *tptr++=GRSPACE_NORMAL;
  508. }
  509.  
  510. if(group==GUIGROUPS-1) {
  511.     *tptr++=GROUP_EqualWidth;
  512.     *tptr++=TRUE;
  513. }
  514.  
  515. for(cnt1=0;cnt1<gg->used;cnt1++) {
  516.     gs=&gg->slots[cnt1];
  517.     if(gs->type>=1000) {
  518.         *tptr++=GROUP_Member;
  519.         *tptr++=(ULONG)recurseslot(gb,gs->type-1000);
  520.         *tptr++=TAG_END;
  521.         *tptr++=0;
  522.     } else {
  523.         *tptr++=GROUP_Member;
  524.         *tptr++=(ULONG)gs->obj;
  525.         *tptr++=TAG_END;
  526.         *tptr++=0;
  527.         #ifdef GUIDEBUG
  528.         printf("- Object %08.8lx (%ld) added\n",gs->obj,gs->type);
  529.         #endif
  530.     }
  531. }
  532. *tptr=TAG_DONE;
  533. #ifdef GUIDEBUG
  534. printf("- %ld longs\n",tptr-memtag);
  535. #endif
  536. obj=BGUI_NewObjectA(BGUI_GROUP_GADGET,(struct TagItem*)memtag);
  537. #ifdef GUIDEBUG
  538. printf("-> Object %08.8lx\n",obj);
  539. #endif
  540. error:
  541. freemem(memtag);
  542. return(obj);
  543. }
  544.  
  545. ULONG initrequtags[]={
  546.     WINDOW_Title,0,
  547.     WINDOW_Screen,0,
  548.     WINDOW_Font,0,
  549.     WINDOW_FallBackFont,0,
  550.     WINDOW_Position,POS_CENTERSCREEN,
  551.     WINDOW_SizeGadget,FALSE,
  552.     WINDOW_Activate,TRUE,
  553.     WINDOW_RMBTrap,TRUE,
  554.     WINDOW_SmartRefresh,TRUE,
  555.     WINDOW_AutoKeyLabel,TRUE,
  556.     WINDOW_MasterGroup
  557. };
  558.  
  559. BOOL initrequ(struct GUIBase *gb)
  560. {
  561. ULONG memtag[sizeof(initrequtags)+32*sizeof(ULONG)];
  562. ULONG *tptr;
  563.  
  564. #ifdef GUIDEBUG
  565. printf("INITREQU");
  566. #endif
  567. if(!gb) return(0);
  568. tptr=memtag;
  569. CopyMem(initrequtags,tptr,sizeof(initrequtags));
  570. tptr[1]=(ULONG)gb->title;
  571. if(gb->screen) tptr[3]=(ULONG)gb->screen; else tptr[3]=(ULONG)fmmain.naytto;
  572. tptr[5]=(ULONG)&fmconfig->reqfontattr;
  573. tptr[7]=(ULONG)&fmconfig->smallfontattr;
  574. tptr+=sizeof(initrequtags)/sizeof(ULONG);
  575. *tptr++=(ULONG)recurseslot(gb,0);
  576. *tptr++=0;
  577. *tptr=0;
  578. gb->obj=BGUI_NewObjectA(BGUI_WINDOW_OBJECT,(struct TagItem*)memtag);
  579. #ifdef GUIDEBUG
  580. printf("INITREQU -> %08.8lx\n",gb->obj);
  581. #endif
  582. settabcycle(gb);
  583. return((BOOL)(gb->obj?1:0));
  584. }
  585.  
  586. BOOL openreq(struct GUIBase *gb)
  587. {
  588. #ifdef GUIDEBUG
  589. printf("OPENREQ\n");
  590. #endif
  591. if(gb&&gb->obj) {
  592.     if((gb->win=(struct Window*)DoMethod(gb->obj,WM_OPEN))) return(1);
  593. }
  594. return(0);
  595. }
  596.  
  597. void closereq(struct GUIBase *gb)
  598. {
  599. #ifdef GUIDEBUG
  600. printf("CLOSEREQ\n");
  601. #endif
  602. if(!gb||!gb->obj) return;
  603. gb->win=0;
  604. DoMethod(gb->obj,WM_CLOSE);
  605. }
  606.  
  607. void sleepreq(struct GUIBase *gb)
  608. {
  609. if(!gb||!gb->obj) return;
  610. DoMethod(gb->obj,WM_SLEEP);
  611. }
  612. void wakereq(struct GUIBase *gb)
  613. {
  614. if(!gb||!gb->obj) return;
  615. DoMethod(gb->obj,WM_WAKEUP);
  616. }
  617.  
  618. BOOL openinitreq(struct GUIBase *gb)
  619. {
  620. if(!gb->obj) initrequ(gb);
  621. if(!gb->obj) return(0);
  622. if(openreq(gb)) return(1);
  623. return(0);
  624. }
  625.  
  626. BOOL initreq(struct GUIBase *gb)
  627. {
  628. return(initrequ(gb));
  629. }
  630.  
  631. WORD quickreq(struct GUIBase *gb)
  632. {
  633. WORD ret;
  634.  
  635. ret=0;
  636. if(openinitreq(gb)) {
  637.     for(;;) {
  638.         ret=reqmsghandler(gb);
  639.         if(ret<100) break;
  640.     }
  641. }
  642. freereq(gb);
  643. return(ret);
  644. }
  645.  
  646. void startbuttonbar(struct GUIBase *gb)
  647. {
  648. setguigroup(gb,GUIGROUPS-1,0);
  649. connectgroups(gb,0,GUIGROUPS-1);
  650. }
  651. void buttonbari(struct GUIBase *gb,void **buttons)
  652. {
  653. startbuttonbar(gb);
  654. while(*buttons) {
  655.     reqbutton(gb,buttons[0],(WORD)buttons[1],guiUC);
  656.     buttons+=2;
  657. }
  658. }
  659.  
  660. void buttonbar(struct GUIBase *gb,void *button,...)
  661. {
  662. buttonbari(gb,&button);
  663. }
  664. void buttonbarmsg(struct GUIBase *gb,LONG button,...)
  665. {
  666. void *text[32];
  667. guimulticonvert2(text,&button);
  668. buttonbari(gb,text);
  669. }
  670.  
  671. WORD reqinfowindow(UBYTE *title,UBYTE *body,UWORD flags,LONG button,...)
  672. {
  673. struct GUIBase *gb;
  674. void *text[32];
  675. WORD ret;
  676.  
  677. ret=0;
  678. guimulticonvert2(text,&button);
  679. gb=getguibase(title);
  680. reqinfo(gb,body,-1,flags);
  681. buttonbari(gb,text);
  682. if(openinitreq(gb)) ret=reqmsghandler(gb);
  683. freereq(gb);
  684. return(ret);
  685. }
  686.  
  687. static void checkgui(struct GUIBase *gb,WORD id)
  688. {
  689. struct GUISlot *gs;
  690. struct GUIGroup *gg;
  691. struct CycleData *cd;
  692. WORD cnt1,cnt2;
  693. ULONG data;
  694.  
  695. for(cnt1=0;cnt1<GUIGROUPS;cnt1++) {
  696.     gg=gb->groups[cnt1];
  697.     if(gg) {
  698.         for(cnt2=0;cnt2<gg->used;cnt2++) {
  699.             gs=&gg->slots[cnt2];
  700.             if(id==-1||gs->id==id) {
  701.                 switch(gs->type)
  702.                 {
  703.                 case STRING_KIND:
  704.                 GetAttr(STRINGA_TextVal,gs->obj,&data);
  705.                 strcpy((UBYTE*)gs->data,(UBYTE*)data);
  706.                 break;
  707.                 case INTEGER_KIND:
  708.                 GetAttr(STRINGA_LongVal,gs->obj,gs->data);
  709.                 break;
  710.                 case CYCLE_KIND:
  711.                 cd=(struct CycleData*)gs->data;
  712.                 GetAttr(CYC_Active,gs->obj,&data);
  713.                 *cd->selected=data;
  714.                 break;
  715.                 case 10:
  716.                 GetAttr(GA_SELECTED,gs->obj,&data);
  717.                 *((BOOL*)gs->data)=data;
  718.                 break;
  719.                 case PALETTE_KIND:
  720.                 GetAttr(PALETTE_CurrentColor,gs->obj,&data);
  721.                 *((UBYTE*)gs->data)=data;
  722.                 break;
  723.                 }
  724.             }
  725.         }
  726.     }
  727. }
  728. }
  729.  
  730.  
  731. LONG getobject(struct GUIBase *gb,WORD id)
  732. {
  733. WORD cnt1,cnt2;
  734. struct GUISlot *gs;
  735. struct GUIGroup *gg;
  736. struct CycleData *cd;
  737. LONG data=-1;
  738.  
  739. for(cnt1=0;cnt1<GUIGROUPS;cnt1++) {
  740.     gg=gb->groups[cnt1];
  741.     if(gg) {
  742.         for(cnt2=0;cnt2<gg->used;cnt2++) {
  743.             gs=&gg->slots[cnt2];
  744.             if(gs->id==id) {
  745.                 switch(gs->type)
  746.                 {
  747.                 case STRING_KIND:
  748.                 GetAttr(STRINGA_TextVal,gs->obj,(ULONG*)gs->data);
  749.                 break;
  750.                 case INTEGER_KIND:
  751.                 GetAttr(STRINGA_LongVal,gs->obj,(ULONG*)gs->data);
  752.                 break;
  753.                 case CYCLE_KIND:
  754.                 cd=(struct CycleData*)gs->data;
  755.                 GetAttr(CYC_Active,gs->obj,(ULONG*)&data);
  756.                 *cd->selected=data;
  757.                 break;
  758.                 case 10:
  759.                 GetAttr(GA_SELECTED,gs->obj,(ULONG*)&data);
  760.                 break;
  761.                 case PALETTE_KIND:
  762.                 GetAttr(PALETTE_CurrentColor,gs->obj,(ULONG*)&data);
  763.                 break;
  764.                 }
  765.             }
  766.         }
  767.     }
  768. }
  769. #ifdef GUIDEBUG
  770. printf("GETOBJ: %ld, %ld\n",id,data);
  771. #endif
  772. return(data);
  773. }
  774.  
  775. void setobject(struct GUIBase *gb,WORD id,LONG data)
  776. {
  777. WORD cnt1,cnt2;
  778. struct GUISlot *gs;
  779. struct GUIGroup *gg;
  780. struct CycleData *cd;
  781.  
  782. #ifdef GUIDEBUG
  783. printf("SETOBJ: %ld, %ld\n",id,data);
  784. #endif
  785.  
  786. for(cnt1=0;cnt1<GUIGROUPS;cnt1++) {
  787.     gg=gb->groups[cnt1];
  788.     if(gg) {
  789.         for(cnt2=0;cnt2<gg->used;cnt2++) {
  790.             gs=&gg->slots[cnt2];
  791.             if(gs->id==id) {
  792.                 switch(gs->type)
  793.                 {
  794.                 case STRING_KIND:
  795.                 SetGadgetAttrs((struct Gadget*)gs->obj,gb->win,0,STRINGA_TextVal,data,TAG_DONE);
  796.                 break;
  797.                 case INTEGER_KIND:
  798.                 SetGadgetAttrs((struct Gadget*)gs->obj,gb->win,0,STRINGA_LongVal,data,TAG_DONE);
  799.                 *((LONG*)gs->data)=data;
  800.                 break;
  801.                 case CYCLE_KIND:
  802.                 cd=(struct CycleData*)gs->data;
  803.                 SetGadgetAttrs((struct Gadget*)gs->obj,gb->win,0,CYC_Active,data,TAG_DONE);
  804.                 *cd->selected=data;
  805.                 break;
  806.                 case 10:
  807.                 SetGadgetAttrs((struct Gadget*)gs->obj,gb->win,0,GA_SELECTED,data,TAG_DONE);
  808.                 *((BOOL*)gs->data)=data;
  809.                 break;
  810.                 case PALETTE_KIND:
  811.                 SetGadgetAttrs((struct Gadget*)gs->obj,gb->win,0,PALETTE_CurrentColor,data,TAG_DONE);
  812.                 break;
  813.                 }
  814.             }
  815.         }
  816.     }
  817. }
  818. }
  819.  
  820. void denaobject(struct GUIBase *gb,WORD id,BOOL flag)
  821. {
  822. WORD cnt1,cnt2;
  823. struct GUISlot *gs;
  824. struct GUIGroup *gg;
  825.  
  826. #ifdef GUIDEBUG
  827. printf("DENAOBJ: %ld, %ld\n",id,flag);
  828. #endif
  829.  
  830. for(cnt1=0;cnt1<GUIGROUPS;cnt1++) {
  831.     gg=gb->groups[cnt1];
  832.     if(gg) {
  833.         for(cnt2=0;cnt2<gg->used;cnt2++) {
  834.             gs=&gg->slots[cnt2];
  835.             if(gs->id==id) {
  836.                 SetGadgetAttrs((struct Gadget*)gs->obj,gb->win,0,GA_Disabled,flag,TAG_DONE);
  837.             }
  838.         }
  839.     }
  840. }
  841. }
  842.  
  843.  
  844. WORD reqmsghandler(struct GUIBase *gb)
  845. {
  846. Object *obj;
  847. ULONG signal,sigs;
  848. ULONG rc;
  849. WORD ret;
  850.  
  851. #ifdef GUIDEBUG
  852. printf("MSGHANDLER\n");
  853. #endif
  854. if(!gb) return(0);
  855. obj=gb->obj;
  856. if(!obj) return(0);
  857. GetAttr(WINDOW_SigMask,obj,&signal);
  858. ret=-2;
  859. while(ret==-2) {
  860.     sigs=Wait(signal|SIGBREAKF_CTRL_C);
  861.     if(sigs&SIGBREAKF_CTRL_C) ret=-1;
  862.     if(sigs&signal) {
  863.         while((rc=HandleEvent(obj))!=WMHI_NOMORE) {
  864.             if(rc!=WMHI_IGNORE) {
  865.                 if(rc==WMHI_ACTIVE) activatestrings(gb);
  866.                 if(rc==WMHI_CLOSEWINDOW) {
  867.                     ret=0;
  868.                 } else if(rc<1000) {
  869.                     ret=rc;
  870.                 }
  871.             }
  872.         }
  873.     }
  874. }
  875. checkgui(gb,-1);
  876. return(ret);
  877. }
  878.