home *** CD-ROM | disk | FTP | other *** search
/ Frozen Fish 1: Amiga / FrozenFish-Apr94.iso / bbs / alib / d5xx / d547 / powersource.lha / PowerSource / source.lzh / source / gfunc.c < prev    next >
Encoding:
C/C++ Source or Header  |  1991-09-16  |  31.8 KB  |  1,185 lines
  1. /*----------------------------------------------------------------------*
  2.   gfunc.c Version 3.0 - © Copyright 1990-91 Jaba Development
  3.  
  4.   Author : Jan van den Baard
  5.   Purpose: functions called by user via menu and keyboard
  6.  *----------------------------------------------------------------------*/
  7.  
  8. extern struct Window        *MainWindow;
  9. extern struct Screen        *MainScreen;
  10. extern struct RastPort      *MainRP;
  11. extern struct FileSelector  *IODir;
  12. extern struct Library       *SysBase;
  13. extern struct GadgetList     Gadgets;
  14. extern struct ge_prefs       prefs;
  15. extern struct Gadget         TextGadget;
  16. extern struct NewWindow      nw_main;
  17. extern struct MemoryChain    Memory;
  18. extern struct SharedList     Images;
  19. extern ULONG                 IDCMPFlags, WindowFlags, Class;
  20. extern BOOL                  Saved, REQUESTER, WBSCREEN;
  21. extern USHORT                FrontPen, Code, GadgetCount, id, BackFill;
  22. extern USHORT                Colors[32],DEPTH, WDBackFill;
  23. extern SHORT                 MainX,MainY,text_num;
  24. extern UBYTE                 name[256], wdt[80], wlb[MAXLABEL];
  25.  
  26. struct Gadget *wait_for_gadget();
  27.  
  28. BOOL    bo_added            = TRUE;
  29.  
  30. /*
  31.  * switch on/off the coords.
  32.  */
  33. void switch_coords( long how )
  34. {
  35.     Forbid();
  36.     if(NOT how) {
  37.         if(TestBits((ULONG)prefs.flag_bits,GP_COORDS))
  38.             MainWindow->Flags &= ~REPORTMOUSE;
  39.     } else {
  40.         if(TestBits((ULONG)prefs.flag_bits,GP_COORDS))
  41.             MainWindow->Flags |= REPORTMOUSE;
  42.     }
  43.     Permit();
  44. }
  45.  
  46. /*
  47.  * remove all 'BORDERONLY' gadgets from the edit window
  48.  * so they won't interferre with your editing
  49.  */
  50. void rem_bo( void )
  51. {
  52.     register struct MyGadget *g;
  53.  
  54.     if(NOT Gadgets.Head->Succ) return;
  55.  
  56.     if(bo_added) {
  57.         for(g = Gadgets.Head; g->Succ; g = g->Succ) {
  58.             if(TestBits((ULONG)g->SpecialFlags,BORDERONLY)) {
  59.                 bo_added = FALSE;
  60.                 RemoveGList(MainWindow,&g->Gadget,1);
  61.             }
  62.         }
  63.     }
  64. }
  65.  
  66. /*
  67.  * put back all 'BORDERONLY' gadgets in the edit window
  68.  * so they may be selected to be moved, re-sized, deleted,
  69.  * copied and edited
  70.  */
  71. void add_bo( void )
  72. {
  73.     register struct MyGadget *g;
  74.  
  75.     if(NOT Gadgets.Head->Succ) return;
  76.  
  77.     if(NOT bo_added) {
  78.         for(g = Gadgets.Head; g->Succ; g = g->Succ) {
  79.             if(TestBits((ULONG)g->SpecialFlags,BORDERONLY)) {
  80.                 bo_added = TRUE;
  81.                 AddGList(MainWindow,&g->Gadget,-1L,1,NULL);
  82.             }
  83.         }
  84.     }
  85. }
  86.  
  87. /*
  88.  * remove all normal gadgets from the edit window
  89.  * so they won't interferre with text placing and gadget resizing.
  90.  */
  91. void rem_no( void )
  92. {
  93.     register struct MyGadget *g;
  94.  
  95.     if(NOT Gadgets.Head->Succ) return;
  96.  
  97.     for(g = Gadgets.Head; g->Succ; g = g->Succ) {
  98.         if(NOT TestBits((ULONG)g->SpecialFlags,BORDERONLY))
  99.             RemoveGList(MainWindow,&g->Gadget,1);
  100.     }
  101. }
  102.  
  103. /*
  104.  * put back all normal gadgets in the edit window
  105.  * so they may be selected to be moved, re-sized, deleted,
  106.  * copied and edited
  107.  */
  108. void add_no( void )
  109. {
  110.     register struct MyGadget *g;
  111.  
  112.     if(NOT Gadgets.Head->Succ) return;
  113.  
  114.     for(g = Gadgets.Head; g->Succ; g = g->Succ) {
  115.         if(NOT TestBits((ULONG)g->SpecialFlags,BORDERONLY))
  116.             AddGList(MainWindow,&g->Gadget,-1L,1,NULL);
  117.     }
  118. }
  119.  
  120. /*
  121.  * refresh the complete display
  122.  */
  123. void refresh( void )
  124. {
  125.     USHORT br,bt,bb,bl;
  126.  
  127.     Forbid();
  128.     while(read_msg(MainWindow));
  129.     Permit();
  130.  
  131.     ModifyIDCMP(MainWindow,SIZEVERIFY);
  132.  
  133.     buisy();
  134.  
  135.     SetDrMd(MainRP,JAM1);
  136.  
  137.     add_bo();
  138.  
  139.     if(REQUESTER) {
  140.         SetAPen(MainRP,BackFill);
  141.         RectFill(MainRP,0,0,MainWindow->GZZWidth,MainWindow->GZZHeight);
  142.         RefreshWindowFrame(MainWindow);
  143.     } else {
  144.         RefreshWindowFrame(MainWindow);
  145.         SetAPen(MainRP,WDBackFill);
  146.         br = MainWindow->BorderRight;
  147.         bt = MainWindow->BorderTop;
  148.         bb = MainWindow->BorderBottom;
  149.         bl = MainWindow->BorderLeft;
  150.         if(SysBase->lib_Version < 36)
  151.             RectFill(MainRP,bl-2,bt-1,MainWindow->Width-bl+1,MainWindow->Height-2);
  152.         else
  153.             RectFill(MainRP,bl,bt,MainWindow->Width-br-1,MainWindow->Height-bb-1);
  154.  
  155.         RefreshGList(MainWindow->FirstGadget,MainWindow,NULL,-1L);
  156.     }
  157.     if(TextGadget.GadgetText) PrintIText(MainRP,TextGadget.GadgetText,0,0);
  158.     rem_bo();
  159.  
  160.     ok();
  161.  
  162.     if(NOT strlen(&wdt[0]))
  163.         SetWindowTitles(MainWindow,(char *)-1L,(char *)TITLE);
  164.     else
  165.         SetWindowTitles(MainWindow,(char *)&wdt[0],(char *)TITLE);
  166.  
  167.     Forbid();
  168.     while(read_msg(MainWindow));
  169.     Permit();
  170.  
  171.     ModifyIDCMP(MainWindow,nw_main.IDCMPFlags);
  172. }
  173.  
  174. /*
  175.  * get the pointer to the MyGadget structure in which gadget 'g'
  176.  * is defined
  177.  */
  178. struct MyGadget *get_mg( struct Gadget *g )
  179. {
  180.     register struct MyGadget *ret;
  181.  
  182.     for(ret = Gadgets.Head; ret ->Succ; ret = ret->Succ)
  183.         if(g == &ret->Gadget) return(ret);
  184. }
  185.  
  186. /*
  187.  * check to see if there are already gadgets on the
  188.  * edit window that are not 'BORDERONLY'
  189.  */
  190. long is_gadget( void )
  191. {
  192.     register struct MyGadget *tmp;
  193.  
  194.     for(tmp = Gadgets.Head; tmp->Succ ; tmp = tmp->Succ) {
  195.         if(NOT TestBits((ULONG)tmp->SpecialFlags,BORDERONLY)) return(TRUE);
  196.     }
  197.     return(FALSE);
  198. }
  199.  
  200. /*
  201.  * make a copy of a gadget
  202.  */
  203. void copy_gadget( void )
  204. {
  205.     struct Gadget     *gad;
  206.     struct MyGadget   *gadget, *mg;
  207.     struct Border     *border,*border1;
  208.     struct StringInfo *sinfo, *sinfo1;
  209.     struct PropInfo   *pinfo;
  210.     struct Image      *image, *image1;
  211.     struct IntuiText  *to, *tn, *tnl;
  212.     SHORT              x,y,w,h,xo,yo,ls,ds;
  213.     ULONG              ps;
  214.  
  215.     if(NOT Gadgets.Head->Succ) return;
  216.  
  217.     add_bo();
  218.     sst("PICK GADGET TO COPY....");
  219.     if(NOT(gad = wait_for_gadget(MainWindow))) {
  220.         rem_bo();
  221.         return;
  222.     }
  223.  
  224.     rem_bo();
  225.     rem_no();
  226.  
  227.     Saved = FALSE;
  228.     mg    = get_mg(gad);
  229.  
  230.     if(NOT(gadget = (struct MyGadget *)Alloc(&Memory,(ULONG)sizeof(struct MyGadget)))) {
  231.         Error("Out of Memory !");
  232.         return;
  233.     }
  234.  
  235.     un_grel(MainWindow,gad);
  236.     CopyMem((void *)gad,(void *)&gadget->Gadget,sizeof(struct Gadget));
  237.  
  238.     gadget->Gadget.GadgetText   = NULL;
  239.     gadget->Gadget.GadgetRender = NULL;
  240.     gadget->Gadget.SelectRender = NULL;
  241.     gadget->Gadget.SpecialInfo  = NULL;
  242.     gadget->Gadget.LeftEdge     = gad->LeftEdge + 5;
  243.     gadget->Gadget.TopEdge      = gad->TopEdge  + 5;
  244.     gadget->SpecialFlags        = mg->SpecialFlags;
  245.  
  246.     if(TestBits((ULONG)gadget->SpecialFlags,USERLABEL))
  247.         gadget->SpecialFlags       ^= USERLABEL;
  248.  
  249.     GadgetCount++;
  250.  
  251.     if(NOT TestBits((ULONG)gad->GadgetType,PROPGADGET)) {
  252.         if((NOT TestBits((ULONG)gad->Flags,GADGIMAGE)) OR
  253.            (NOT prefs.image_copy)) {
  254.             border = (struct Border *)gad->GadgetRender;
  255.             if((NOT TestBits((ULONG)gadget->SpecialFlags,BORDERONLY)) AND
  256.                (NOT TestBits((ULONG)gadget->SpecialFlags,NOBORDER))) {
  257.                 AddUser(border);
  258.                 gadget->Gadget.GadgetRender = (APTR)border;
  259.             } else {
  260.                 if(NOT add_border(gadget))
  261.                     goto NoMem;
  262.                 ((struct Border *)gadget->Gadget.GadgetRender)->FrontPen = border->FrontPen;
  263.                 if(TestBits((ULONG)gadget->SpecialFlags,OS20BORDER))
  264.                     ((struct Border *)gadget->Gadget.GadgetRender)->NextBorder->FrontPen = border->NextBorder->FrontPen;
  265.             }
  266.         }
  267.         if(TestBits(gadget->SpecialFlags,OS20HIGHBORDER)) {
  268.             border  = (struct Border *)gad->SelectRender;
  269.             AddUser(border);
  270.             gadget->Gadget.SelectRender = (APTR)border;
  271.         }
  272.     } else {
  273.         if(NOT(pinfo = (struct PropInfo *)Alloc(&Memory,(ULONG)sizeof(struct PropInfo))))
  274.             goto NoMem;
  275.         CopyMem((void *)gad->SpecialInfo,(void *)pinfo,sizeof(struct PropInfo));
  276.  
  277.         if((NOT(TestBits((ULONG)gad->Flags,GADGIMAGE))) OR
  278.            (prefs.image_copy == FALSE)) {
  279.             if(NOT(gadget->Gadget.GadgetRender = Alloc(&Memory,(ULONG)sizeof(struct Image))))
  280.                 goto NoMem;
  281.             pinfo->Flags |= AUTOKNOB;
  282.         }
  283.         gadget->Gadget.SpecialInfo = (APTR)pinfo;
  284.     }
  285.  
  286.     if((TestBits((ULONG)gad->Flags,GADGIMAGE)) AND (prefs.image_copy == TRUE)) {
  287.         image = (struct Image *)gad->GadgetRender;
  288.         add_user(image);
  289.         gadget->Gadget.GadgetRender = (APTR)image;
  290.     } else if((TestBits((ULONG)gad->Flags,GADGIMAGE)) AND (prefs.image_copy == FALSE))
  291.         gadget->Gadget.Flags ^= GADGIMAGE;
  292.  
  293.     if((TestBits((ULONG)gad->Flags,GADGHIMAGE)) AND
  294.        (prefs.image_copy == TRUE) AND
  295.        (NOT TestBits((ULONG)gad->Flags,GADGHBOX)) AND
  296.        (NOT TestBits((ULONG)gadget->SpecialFlags,OS20HIGHBORDER))) {
  297.         image = (struct Image *)gad->SelectRender;
  298.         add_user(image);
  299.         gadget->Gadget.SelectRender = (APTR)image;
  300.     } else if((TestBits((ULONG)gad->Flags,GADGHIMAGE)) AND
  301.               (NOT TestBits(gadget->SpecialFlags,OS20HIGHBORDER)) AND
  302.               (prefs.image_copy == FALSE)) {
  303.         gadget->Gadget.SelectRender = NULL;
  304.         gadget->Gadget.Flags ^= GADGHIMAGE;
  305.     }
  306.  
  307.     if((gad->GadgetText) AND (prefs.text_copy == TRUE)) {
  308.         to = gad->GadgetText;
  309.         if(NOT(tn = (struct IntuiText *)Alloc(&Memory,(ULONG)sizeof(struct IntuiText))))
  310.             goto NoMem;
  311.         CopyMem((char *)to,(char *)tn,(ULONG)sizeof(struct IntuiText));
  312.         if(NOT(tn->IText = (UBYTE *)Alloc(&Memory,80L)))
  313.             goto NoMem;
  314.         CopyMem((char *)to->IText,(char *)tn->IText,80L);
  315.         gadget->Gadget.GadgetText = tn;
  316.         if(to = to->NextText) {
  317.             while(1) {
  318.                 if(NOT(tnl = (struct IntuiText *)Alloc(&Memory,(ULONG)sizeof(struct IntuiText))))
  319.                     goto NoMem;
  320.                 CopyMem((char *)to,(char *)tnl,(ULONG)sizeof(struct IntuiText));
  321.                 if(NOT(tnl->IText = (UBYTE *)Alloc(&Memory,80L)))
  322.                     goto NoMem;
  323.                 CopyMem((char *)to->IText,(char *)tnl->IText,80L);
  324.                 tn->NextText = tnl;
  325.                 tn = tnl;
  326.                 if(NOT(to = to->NextText)) break;
  327.             }
  328.         }
  329.     }
  330.  
  331.     if((TestBits((ULONG)gad->GadgetType,STRGADGET))) {
  332.         sinfo1 = (struct StringInfo *)gad->SpecialInfo;
  333.         if(NOT(sinfo = (struct StringInfo *)Alloc(&Memory,(ULONG)sizeof(struct StringInfo))))
  334.             goto NoMem;
  335.         CopyMem((void *)sinfo1,(void *)sinfo,sizeof(struct StringInfo));
  336.         if(NOT(sinfo->Buffer = (UBYTE *)Alloc(&Memory,sinfo->MaxChars)))
  337.             goto NoMem;
  338.         CopyMem((void *)sinfo1->Buffer,(void *)sinfo->Buffer,sinfo->MaxChars);
  339.         if(sinfo->UndoBuffer) {
  340.             if(NOT(sinfo1->UndoBuffer = (UBYTE *)Alloc(&Memory,sinfo->MaxChars)))
  341.                 goto NoMem;
  342.         }
  343.         gadget->Gadget.SpecialInfo = (APTR)sinfo;
  344.     }
  345.  
  346.     switch_coords(FALSE);
  347.     set_info(0);
  348.     x = gadget->Gadget.LeftEdge-1;
  349.     y = gadget->Gadget.TopEdge-1;
  350.     w = gadget->Gadget.Width+1;
  351.     h = gadget->Gadget.Height+1;
  352.     SetDrMd(MainRP,COMPLEMENT);
  353.     SetAPen(MainRP,FrontPen);
  354.     draw_box(MainWindow,x,y,x+w,y+h);
  355.     do_info(0,x,y,x+w,y+h);
  356.     xo = MainX-x;
  357.     yo = MainY-y;
  358.  
  359.     while(Code != SELECTDOWN) {
  360.         while(read_msg(MainWindow)) {
  361.             if(Class == MENUPICK) set_info(0);
  362.             do_info(0,x,y,x+w,y+h);
  363.         }
  364.         get_xy(&MainX,&MainY);
  365.         if((MainX != (x + xo)) OR (MainY != (y + yo))) {
  366.             draw_box(MainWindow,x,y,x+w,y+h);
  367.             x = MainX - xo;
  368.             y = MainY - yo;
  369.             draw_box(MainWindow,x,y,x+w,y+h);
  370.             do_info(0,x,y,x+w,y+h);
  371.         }
  372.     }
  373.  
  374.     gadget->Gadget.LeftEdge = x+1;
  375.     gadget->Gadget.TopEdge  = y+1;
  376.     AddHead((void *)&Gadgets,(void *)gadget);
  377.     grel(MainWindow,&gadget->Gadget);
  378.     grel(MainWindow,gad);
  379.     add_no();
  380.     switch_coords(TRUE);
  381.     renumber();
  382.     refresh();
  383.     return;
  384. NoMem:
  385.     FreeGadget(gadget);
  386.     Error("Out of Memory !");
  387. }
  388.  
  389. /*
  390.  * delete a gadget
  391.  */
  392. void delete( void )
  393. {
  394.     struct Gadget   *gd;
  395.     struct MyGadget *gadget;
  396.     USHORT           i=0;
  397.  
  398.     if(NOT Gadgets.Head->Succ) return;
  399.  
  400.     add_bo();
  401.     sst("PICK GADGET TO DELETE.....");
  402.     if(NOT(gd = wait_for_gadget(MainWindow))) {
  403.         rem_bo();
  404.         return;
  405.     }
  406.  
  407.     Saved = FALSE;
  408.  
  409.     for(gadget = Gadgets.Head; gadget->Succ; gadget = gadget->Succ) {
  410.         if(gd == &gadget->Gadget) {
  411.             Remove((void *)gadget);
  412.             un_grel(MainWindow,gd);
  413.             RemoveGList(MainWindow,gd,1);
  414.             FreeGadget(gadget);
  415.             break;
  416.         }
  417.     }
  418.     GadgetCount--;
  419.     renumber();
  420.     rem_bo();
  421.     refresh();
  422. }
  423.  
  424. /*
  425.  * Get a IFF ILBM brush as gadget render
  426.  */
  427. void render( void )
  428. {
  429.     struct MyGadget *mg;
  430.     struct Gadget   *gadget;
  431.     struct PropInfo *info;
  432.     struct Border   *border;
  433.     struct Image    *image, *image1, *image_bank();
  434.     ULONG            Pos, ps, rc;
  435.  
  436.     if(NOT Gadgets.Head->Succ) return;
  437.     if(NOT is_gadget()) return;
  438.     sst("PICK GADGET TO RENDER.....");
  439.     if(NOT(gadget = wait_for_gadget(MainWindow))) return;
  440.  
  441.     if(TestBits((ULONG)gadget->Flags,GADGIMAGE)) {
  442.         if(Ask("Gadget already has an Image !",
  443.                "Do you wish to over-write it ?") == FALSE) return;
  444.     }
  445.  
  446.     Saved = FALSE;
  447.  
  448.     if(NOT(image = image_bank(TRUE)))
  449.         return;
  450.  
  451.     add_user(image);
  452.  
  453.     disable_window();
  454.  
  455.     mg = get_mg(gadget);
  456.  
  457.     Pos = RemoveGList(MainWindow,gadget,1);
  458.     un_grel(MainWindow,gadget);
  459.  
  460.     if(TestBits((ULONG)gadget->Flags,GADGIMAGE)) {
  461.         image1 = (struct Image *)gadget->GadgetRender;
  462.         rem_user(image1);
  463.     } else if(TestBits((ULONG)gadget->GadgetType,PROPGADGET))
  464.         FreeItem(&Memory,gadget->GadgetRender,(long)sizeof(struct Image));
  465.     else {
  466.         FreeRender(mg);
  467.         if(TestBits((ULONG)mg->SpecialFlags,OS20HIGHBORDER)) {
  468.             mg->SpecialFlags ^= OS20HIGHBORDER;
  469.             mg->SpecialFlags ^= OS20BORDER;
  470.             gadget->Flags    ^= GADGHIMAGE;
  471.         }
  472.     }
  473.  
  474.     if(NOT(TestBits((ULONG)gadget->GadgetType,PROPGADGET))) {
  475.         if(prefs.auto_size) {
  476.             gadget->Width  = image->Width;
  477.             gadget->Height = image->Height;
  478.         }
  479.     } else {
  480.         info = (struct PropInfo *)gadget->SpecialInfo;
  481.         info->Flags ^= AUTOKNOB;
  482.     }
  483.  
  484.     gadget->Flags       |= GADGIMAGE;
  485.     gadget->GadgetRender = (APTR)image;
  486.     grel(MainWindow,gadget);
  487.     AddGList(MainWindow,gadget,Pos,1,NULL);
  488.     enable_window();
  489.     refresh();
  490. }
  491.  
  492. /*
  493.  * read an IFF ILBM brush as select render
  494.  */
  495. void sel_render( void )
  496. {
  497.     struct MyGadget *mg;
  498.     struct Gadget   *gadget;
  499.     struct PropInfo *info;
  500.     struct Image    *image, *image1, *image_bank();
  501.     ULONG            Pos, ps, rc;
  502.  
  503.     if(NOT Gadgets.Head->Succ) return;
  504.     if(NOT is_gadget()) return;
  505.     sst("PICK GADGET TO SELECT RENDER.....");
  506.     if(NOT(gadget = wait_for_gadget(MainWindow))) return;
  507.  
  508.     mg = get_mg(gadget);
  509.  
  510.     if(NOT(TestBits((ULONG)gadget->Flags,GADGIMAGE))) {
  511.         Error("Not an Image Gadget !");
  512.         return;
  513.     }
  514.  
  515.     if((TestBits((ULONG)gadget->Flags,GADGHIMAGE)) AND
  516.        (NOT TestBits((ULONG)gadget->Flags,GADGHBOX)) AND
  517.        (NOT TestBits((ULONG)mg->SpecialFlags,OS20HIGHBORDER))) {
  518.         if(Ask("Gadget already has an Image !",
  519.                "Do you wish to over-write it ?") == FALSE) return;
  520.     }
  521.  
  522.     Saved = FALSE;
  523.  
  524.     if(NOT(image = image_bank(TRUE)))
  525.         return;
  526.  
  527.     add_user(image);
  528.  
  529.     disable_window();
  530.  
  531.     Pos = RemoveGList(MainWindow,gadget,1);
  532.     un_grel(MainWindow,gadget);
  533.  
  534.     if((TestBits((ULONG)gadget->Flags,GADGHBOX)) AND
  535.        (NOT TestBits((ULONG)gadget->Flags,GADGHIMAGE)))
  536.            gadget->Flags ^= GADGHBOX;
  537.  
  538.     if((TestBits((ULONG)gadget->Flags,GADGHIMAGE)) AND
  539.        (NOT TestBits((ULONG)gadget->Flags,GADGHBOX))) {
  540.         image1 = (struct Image *)gadget->SelectRender;
  541.         rem_user(image1);
  542.     }
  543.  
  544.     gadget->Flags       |= GADGHIMAGE;
  545.     gadget->SelectRender = (APTR)image;
  546.     grel(MainWindow,gadget);
  547.     AddGList(MainWindow,gadget,Pos,1,NULL);
  548.     enable_window();
  549.     refresh();
  550. }
  551.  
  552. /*
  553.  * read and set the CMAP of an IFF ILBM picture
  554.  */
  555. void do_cmap( void )
  556. {
  557.     ULONG rc;
  558.  
  559.     strcpy((char *)IODir->fr_HeadLine,"Load IFF ColorMap");
  560.  
  561.     IODir->fr_Screen = MainScreen;
  562.     IODir->fr_Caller = MainWindow;
  563.     IODir->fr_Flags |= FR_NoInfo;
  564.  
  565.     rc = FileRequest(IODir);
  566.  
  567.     strcpy((char *)&name,(char *)IODir->fr_DirName);
  568.     strcat((char *)&name,(char *)IODir->fr_FileName);
  569.  
  570.     if(rc == FREQ_CANCELED) return;
  571.     else if(rc) {
  572.         Error("FileRequester Won't Open !");
  573.         return;
  574.     }
  575.  
  576.     Saved = FALSE;
  577.     disable_window();
  578.     ReadCMAP(name,NULL);
  579.     enable_window();
  580. }
  581.  
  582. /*
  583.  * resize a gadget
  584.  */
  585. void size_gadget( void )
  586. {
  587.     struct MyGadget *mg;
  588.     struct Gadget   *gadget;
  589.     SHORT            x,y,w,h,xo,yo, *XY;
  590.     ULONG            Pos;
  591.  
  592.     if(NOT Gadgets.Head->Succ) return;
  593.  
  594.     add_bo();
  595.     sst("PICK GADGET TO RE-SIZE.....");
  596.     if(NOT(gadget = wait_for_gadget(MainWindow))) {
  597.         rem_bo();
  598.         return;
  599.     }
  600.  
  601.     rem_bo();
  602.     rem_no();
  603.  
  604.     mg    = get_mg(gadget);
  605.     Saved = FALSE;
  606.  
  607.     un_grel(MainWindow,gadget);
  608.     x = gadget->LeftEdge-1;
  609.     y = gadget->TopEdge-1;
  610.     w = gadget->Width+1;
  611.     h = gadget->Height+1;
  612.  
  613.     switch_coords(FALSE);
  614.     set_info(0);
  615.     SetDrMd(MainRP,COMPLEMENT);
  616.     SetAPen(MainRP,FrontPen);
  617.     draw_box(MainWindow,x,y,x+w,y+h);
  618.     do_info(0,x,y,x+w,y+h);
  619.     xo = (x+w)-MainX;
  620.     yo = (y+h)-MainY;
  621.  
  622.  
  623.     while(Code != SELECTDOWN) {
  624.         while(read_msg(MainWindow)) {
  625.             if(Class == MENUPICK) set_info(0);
  626.             do_info(0,x,y,x+w,y+h);
  627.         }
  628.         get_xy(&MainX,&MainY);
  629.         if((MainX != ((x + w) - xo)) OR (MainY != ((y + h) - yo))) {
  630.             draw_box(MainWindow,x,y,x+w,y+h);
  631.             if(((MainX - x) + xo) >= 9)  w = (MainX - x) + xo;
  632.             if(((MainY - y) + yo) >= 9)  h = (MainY - y) + yo;
  633.             draw_box(MainWindow,x,y,x+w,y+h);
  634.             do_info(0,x,y,x+w,y+h);
  635.         }
  636.     }
  637.  
  638.     add_bo();
  639.     add_no();
  640.     draw_box(MainWindow,x,y,x+w,y+h);
  641.  
  642.     if(NOT(TestBits((ULONG)gadget->GadgetType,PROPGADGET))) {
  643.         if(NOT(TestBits((ULONG)gadget->Flags,GADGIMAGE))) {
  644.             if(NOT TestBits((ULONG)mg->SpecialFlags,OS20BORDER)) {
  645.                 XY = (((struct Border *)gadget->GadgetRender)->XY);
  646.                 XY[2] = XY[4] = w-1;
  647.                 XY[5] = XY[7] = h-1;
  648.             } else {
  649.                 if(NOT TestBits((ULONG)gadget->GadgetType,STRGADGET)) {
  650.                     w -= 2;
  651.                     h -= 2;
  652.                 } else {
  653.                     w--;
  654.                     h--;
  655.                 }
  656.                 XY = (((struct Border *)gadget->GadgetRender)->XY);
  657.                 XY[3] = h;
  658.                 XY[5] = h-1;
  659.                 XY[8] = w-1;
  660.                 XY = ((((struct Border *)gadget->GadgetRender)->NextBorder)->XY);
  661.                 XY[1] = XY[3] = XY[9] = h;
  662.                 XY[2] = XY[4] = w-1;
  663.                 XY[6] = XY[8] = w;
  664.             }
  665.         }
  666.     }
  667.  
  668.     if(TestBits((ULONG)mg->SpecialFlags,OS20BORDER)) {
  669.         if(NOT TestBits((ULONG)gadget->GadgetType,STRGADGET)) {
  670.             w += 2;
  671.             h += 2;
  672.         } else {
  673.             w++;
  674.             h++;
  675.         }
  676.     }
  677.  
  678.     for(mg = Gadgets.Head; mg; mg = mg->Succ) {
  679.         if(mg->Gadget.GadgetRender == gadget->GadgetRender) {
  680.             mg->Gadget.Width  = w-1;
  681.             mg->Gadget.Height = h-1;
  682.         }
  683.     }
  684.  
  685.     grel(MainWindow,gadget);
  686.     switch_coords(TRUE);
  687.     rem_bo();
  688.     refresh();
  689. }
  690.  
  691. /*
  692.  * move a gadget
  693.  */
  694. void move_gadget( void )
  695. {
  696.     struct MyGadget *mg;
  697.     struct Gadget   *gadget;
  698.     SHORT            x,y,w,h,xo,yo;
  699.     ULONG            Pos;
  700.  
  701.     if(NOT Gadgets.Head->Succ) return;
  702.  
  703.     add_bo();
  704.     sst("PICK GADGET TO MOVE....");
  705.     if(NOT(gadget = wait_for_gadget(MainWindow))) {
  706.         rem_bo();
  707.         return;
  708.     }
  709.  
  710.     Saved = FALSE;
  711.  
  712.     rem_bo();
  713.     rem_no();
  714.  
  715.     mg = get_mg(gadget);
  716.     switch_coords(FALSE);
  717.     set_info(0);
  718.     un_grel(MainWindow,gadget);
  719.     x = gadget->LeftEdge-1;
  720.     y = gadget->TopEdge-1;
  721.     w = gadget->Width+1;
  722.     h = gadget->Height+1;
  723.     SetDrMd(MainRP,COMPLEMENT);
  724.     SetAPen(MainRP,FrontPen);
  725.     draw_box(MainWindow,x,y,x+w,y+h);
  726.     do_info(0,x,y,x+w,y+h);
  727.     xo = MainX-x;
  728.     yo = MainY-y;
  729.  
  730.     while(Code != SELECTDOWN) {
  731.         while(read_msg(MainWindow)) {
  732.             if(Class == MENUPICK) set_info(0);
  733.             do_info(0,x,y,x+w,y+h);
  734.         }
  735.         get_xy(&MainX,&MainY);
  736.         if((MainX != (x + xo)) OR (MainY != (y + yo))) {
  737.             draw_box(MainWindow,x,y,x+w,y+h);
  738.             x = MainX - xo;
  739.             y = MainY - yo;
  740.             draw_box(MainWindow,x,y,x+w,y+h);
  741.             do_info(0,x,y,x+w,y+h);
  742.         }
  743.     }
  744.  
  745.     add_bo();
  746.     add_no();
  747.     draw_box(MainWindow,x,y,x+w,y+h);
  748.     gadget->LeftEdge = x+1;
  749.     gadget->TopEdge  = y+1;
  750.     grel(MainWindow,gadget);
  751.     switch_coords(TRUE);
  752.     rem_bo();
  753.     refresh();
  754. }
  755.  
  756. /*
  757.  * edit a gadget
  758.  */
  759. void edit( void )
  760. {
  761.     struct MyGadget *mg;
  762.     struct Gadget   *g;
  763.     ULONG            Pos;
  764.     BOOL             suc;
  765.  
  766.     if(NOT Gadgets.Head->Succ) return;
  767.  
  768.     add_bo();
  769.     sst("PICK GADGET TO EDIT....");
  770.     if(NOT(g = wait_for_gadget(MainWindow))) {
  771.         rem_bo();
  772.         return;
  773.     }
  774.  
  775.     Saved = FALSE;
  776.  
  777.     mg = get_mg(g);
  778.     Pos = RemoveGList(MainWindow,g,1);
  779.     un_grel(MainWindow,g);
  780.     disable_window();
  781.     suc = edit_gadget(mg);
  782.     enable_window();
  783.     grel(MainWindow,g);
  784.  
  785.     if(NOT suc) {
  786.         Remove((void *)mg);
  787.         FreeGadget(mg);
  788.     }
  789.     else
  790.         AddGList(MainWindow,g,Pos,1,NULL);
  791.  
  792.     rem_bo();
  793.     refresh();
  794. }
  795.  
  796. /*
  797.  * erase all gadgets and set the window to default
  798.  */
  799. void new( void )
  800. {
  801.     if(Saved == FALSE) {
  802.         if(Ask("Current work isn't saved !","Are you sure ?") == FALSE)
  803.             return;
  804.     }
  805.  
  806.     FreeGList();
  807.     FreeMenuStrip();
  808.  
  809.     if(Images.Head->Succ) {
  810.         if(Ask("There are images in the Image Bank!","Delete them too ?") == TRUE)
  811.             free_all();
  812.     }
  813.  
  814.     nw_main.LeftEdge    = 50;
  815.     nw_main.TopEdge     = 25;
  816.     nw_main.Width       = 175;
  817.     nw_main.Height      = 50;
  818.     WDBackFill          = 0;
  819.     BackFill            = 1;
  820.  
  821.     if(get_config(TRUE)) {
  822.         change_depth(DEPTH);
  823.         WindowFlags = WINDOWDRAG+WINDOWSIZING+WINDOWCLOSE+WINDOWDEPTH+NOCAREREFRESH+SMART_REFRESH+ACTIVATE;
  824.         IDCMPFlags  = GADGETUP+GADGETDOWN+CLOSEWINDOW;
  825.     } else {
  826.         ClearMenuStrip(MainWindow);
  827.         CloseWindow(MainWindow);
  828.         MainWindow = NULL;
  829.         if(REQUESTER) {
  830.             strcpy((char *)&wlb[0],"requester");
  831.             strcpy((char *)&wdt[0],"Requester");
  832.             nw_main.Flags = WINDOWDRAG+WINDOWSIZING+SIZEBRIGHT+SIZEBBOTTOM+GIMMEZEROZERO+BORDERLESS+NOCAREREFRESH+SMART_REFRESH+ACTIVATE;
  833.         } else {
  834.             strcpy((char *)&wlb[0],"new_window");
  835.             strcpy((char *)&wdt[0],"Work Window");
  836.             nw_main.Flags = WINDOWSIZING+WINDOWDRAG+WINDOWCLOSE+WINDOWDEPTH+NOCAREREFRESH+SMART_REFRESH+ACTIVATE;
  837.         }
  838.         WindowFlags = WINDOWDRAG+WINDOWSIZING+WINDOWCLOSE+WINDOWDEPTH+NOCAREREFRESH+SMART_REFRESH+ACTIVATE;
  839.         IDCMPFlags  = GADGETUP+GADGETDOWN+CLOSEWINDOW;
  840.         open_display();
  841.         SetMenu(MainWindow);
  842.     }
  843.  
  844.     if(!WBSCREEN)
  845.         LoadRGB4(&MainScreen->ViewPort,(void *)&Colors,(1 << DEPTH));
  846.     bo_added = TRUE;
  847.     refresh();
  848. }
  849.  
  850. /*
  851.  * delete the render images of a gadget
  852.  */
  853. void delete_images( void )
  854. {
  855.     struct MyGadget *mg;
  856.     struct Gadget   *g;
  857.     struct Image    *i;
  858.     struct PropInfo *p;
  859.     ULONG            pos,ds;
  860.  
  861.     if(NOT Gadgets.Head->Succ) return;
  862.  
  863.     if(NOT is_gadget()) return;
  864.     sst("PICK GADGET TO DELETE IMAGES....");
  865.     if(NOT(g = wait_for_gadget(MainWindow))) return;
  866.  
  867.     if(NOT(TestBits((ULONG)g->Flags,GADGIMAGE))) {
  868.         Error("Gadget has no Images to delete !");
  869.         return;
  870.     }
  871.  
  872.     mg = get_mg(g);
  873.  
  874.     Saved = FALSE;
  875.  
  876.     pos = RemoveGList(MainWindow,g,1);
  877.     un_grel(MainWindow,g);
  878.     i = (struct Image *)g->GadgetRender;
  879.     rem_user(i);
  880.     g->Flags ^= GADGIMAGE;
  881.     if((TestBits((ULONG)g->Flags,GADGHIMAGE)) AND
  882.        (NOT TestBits((ULONG)g->Flags,GADGHBOX))AND
  883.        (NOT TestBits((ULONG)mg->SpecialFlags,OS20HIGHBORDER))) {
  884.         i = (struct Image *)g->SelectRender;
  885.         rem_user(i);
  886.         g->Flags ^= GADGHIMAGE;
  887.         g->SelectRender = NULL;
  888.     }
  889.  
  890.     if(TestBits((ULONG)g->GadgetType,PROPGADGET)) {
  891.         g->GadgetRender = (APTR)Alloc(&Memory,(ULONG)sizeof(struct Image));
  892.         p = (struct PropInfo *)g->SpecialInfo;
  893.         p->Flags |= AUTOKNOB;
  894.     } else
  895.         add_border(get_mg(g));
  896.  
  897.     grel(MainWindow,g);
  898.     AddGList(MainWindow,g,pos,1,NULL);
  899.     refresh();
  900. }
  901.  
  902. long center( struct IntuiText *t, long which )
  903. {
  904.     long ret;
  905.  
  906.     disable_window();
  907.     if(REQUESTER) {
  908.         if(NOT which)
  909.             ret = ((MainWindow->GZZWidth >> 1) - (IntuiTextLength(t) >> 1));
  910.         else
  911.             ret = ((MainWindow->GZZHeight >> 1) - 3);
  912.     } else {
  913.         if(NOT which)
  914.             ret = ((MainWindow->Width >> 1) - (IntuiTextLength(t) >> 1));
  915.         else
  916.             ret = ((MainWindow->Height >> 1) - 3);
  917.     }
  918.     enable_window();
  919.     return(ret);
  920. }
  921.  
  922. /*
  923.  * add a text to a gadget or the window/requester
  924.  */
  925. void add_text( ULONG which )
  926. {
  927.     struct Gadget    *g;
  928.     struct IntuiText *t, *edit_text();
  929.     ULONG             pos;
  930.     SHORT             x,y,le,te;
  931.  
  932.     if(NOT which) {
  933.         if(NOT Gadgets.Head->Succ) return;
  934.         if(NOT is_gadget()) return;
  935.         sst("PICK GADGET TO ADD TEXT....");
  936.         if(NOT(g = wait_for_gadget(MainWindow))) return;
  937.     } else
  938.         g = &TextGadget;
  939.  
  940.     if(NOT(t = edit_text(g,0,0,which))) return;
  941.  
  942.     Delay(5);
  943.  
  944.     rem_no();
  945.     Saved = FALSE;
  946.  
  947.     le = g->LeftEdge;
  948.     te = g->TopEdge;
  949.  
  950.     un_grel(MainWindow,g);
  951.     switch_coords(FALSE);
  952.     get_xy(&x,&y);
  953.     SetDrMd(MainRP,COMPLEMENT);
  954.     SetAPen(MainRP,FrontPen);
  955.     Move(MainRP,x,y);
  956.     Text(MainRP,(char *)t->IText,strlen((char *)t->IText));
  957.     set_info(1);
  958.     do_info(1,x-le,y-te,x-le,y-te);
  959.  
  960.     while(Code != SELECTDOWN) {
  961.         while(read_msg(MainWindow)) {
  962.             if(Class == MENUPICK) set_info(1);
  963.             do_info(1,x-le,y-te,x-le,y-te);
  964.             if(Class == RAWKEY) {
  965.                 switch(Code) {
  966.                     case F1:
  967.                         if(NOT which) {
  968.                             t->LeftEdge = ((g->Width >> 1) - (IntuiTextLength(t) >> 1));
  969.                             t->TopEdge  = ((g->Height >> 1) - 3);
  970.                             while(read_msg(MainWindow));
  971.                             goto placeText;
  972.                         }
  973.                         break;
  974.                     case F2:
  975.                         if(which) {
  976.                             t->TopEdge  = y - te - 6;
  977.                             t->LeftEdge = center(t,0);
  978.                             while(read_msg(MainWindow));
  979.                             goto placeText;
  980.                         }
  981.                         break;
  982.                     case F3:
  983.                         if(which) {
  984.                             t->TopEdge  = center(t,1);
  985.                             t->LeftEdge = x-le;
  986.                             while(read_msg(MainWindow));
  987.                             goto placeText;
  988.                         }
  989.                     break;
  990.                 }
  991.             }
  992.         }
  993.         get_xy(&MainX,&MainY);
  994.         if((MainX != x) OR (MainY != y)) {
  995.             Move(MainRP,x,y);
  996.             Text(MainRP,(char *)t->IText,strlen((char *)t->IText));
  997.             x = MainX;
  998.             y = MainY;
  999.             Move(MainRP,x,y);
  1000.             Text(MainRP,(char *)t->IText,strlen((char *)t->IText));
  1001.             do_info(1,x-le,y-te,x-le,y-te);
  1002.         }
  1003.     }
  1004.  
  1005.     Move(MainRP,x,y);
  1006.     Text(MainRP,(char *)t->IText,strlen((char *)t->IText));
  1007.  
  1008.     t->LeftEdge = x - le;
  1009.     t->TopEdge  = y - te - 6;
  1010.  
  1011. placeText:
  1012.  
  1013.     if(NOT which)
  1014.         grel(MainWindow,g);
  1015.     switch_coords(TRUE);
  1016.     add_no();
  1017.     refresh();
  1018. }
  1019.  
  1020. /*
  1021.  * move a gadget or window/requester text
  1022.  */
  1023. void move_text( ULONG which )
  1024. {
  1025.     struct Gadget    *g;
  1026.     struct IntuiText *t, *GetPtr();
  1027.     ULONG             pos;
  1028.     LONG              tnum;
  1029.     SHORT             x,y,le,te;
  1030.  
  1031.     if(NOT which) {
  1032.         if(NOT Gadgets.Head->Succ) return;
  1033.         if(NOT is_gadget()) return;
  1034.         sst("PICK GADGET TO MOVE TEXT....");
  1035.         if(NOT(g = wait_for_gadget(MainWindow))) return;
  1036.     } else
  1037.         g = &TextGadget;
  1038.  
  1039.     if(NOT g->GadgetText) {
  1040.         if(NOT which)       Error("Gadget has no text(s) to move !");
  1041.         else if(which == 1) Error("Window has no text(s) to move !");
  1042.         else                Error("Requester has no text(s) to move !");
  1043.         return;
  1044.     }
  1045.  
  1046.     if((tnum = text_select(g,1,which)) == -1L) return;
  1047.  
  1048.     Saved = FALSE;
  1049.  
  1050.     Delay(5);
  1051.  
  1052.     le = g->LeftEdge;
  1053.     te = g->TopEdge;
  1054.  
  1055.     t = GetPtr(g,tnum);
  1056.  
  1057.     rem_no();
  1058.     switch_coords(FALSE);
  1059.     set_info(1);
  1060.     un_grel(MainWindow,g);
  1061.     get_xy(&x,&y);
  1062.     SetDrMd(MainRP,COMPLEMENT);
  1063.     SetAPen(MainRP,FrontPen);
  1064.     Move(MainRP,x,y);
  1065.     Text(MainRP,(char *)t->IText,strlen((char *)t->IText));
  1066.     do_info(1,x-le,y-te,x-le,y-te);
  1067.  
  1068.     while(Code != SELECTDOWN) {
  1069.         while(read_msg(MainWindow)) {
  1070.             if(Class == MENUPICK) set_info(1);
  1071.             do_info(1,x-le,y-te,x-le,y-te);
  1072.             if(Class == RAWKEY) {
  1073.                 switch(Code) {
  1074.                     case F1:
  1075.                         if(NOT which) {
  1076.                             t->LeftEdge = ((g->Width >> 1) - (IntuiTextLength(t) >> 1));
  1077.                             t->TopEdge  = ((g->Height >> 1) - 3);
  1078.                             while(read_msg(MainWindow));
  1079.                             goto placeText;
  1080.                         }
  1081.                         break;
  1082.                     case F2:
  1083.                         if(which) {
  1084.                             t->TopEdge  = y - te - 6;
  1085.                             t->LeftEdge = center(t,0);
  1086.                             while(read_msg(MainWindow));
  1087.                             goto placeText;
  1088.                         }
  1089.                         break;
  1090.                     case F3:
  1091.                         if(which) {
  1092.                             t->TopEdge  = center(t,1);
  1093.                             t->LeftEdge = x-le;
  1094.                             while(read_msg(MainWindow));
  1095.                             goto placeText;
  1096.                         }
  1097.                     break;
  1098.                 }
  1099.             }
  1100.         }
  1101.         get_xy(&MainX,&MainY);
  1102.         if((MainX != x) OR (MainY != y)) {
  1103.             Move(MainRP,x,y);
  1104.             Text(MainRP,(char *)t->IText,strlen((char *)t->IText));
  1105.             x = MainX;
  1106.             y = MainY;
  1107.             Move(MainRP,x,y);
  1108.             Text(MainRP,(char *)t->IText,strlen((char *)t->IText));
  1109.             do_info(1,x-le,y-te,x-le,y-te);
  1110.         }
  1111.     }
  1112.  
  1113.     Move(MainRP,x,y);
  1114.     Text(MainRP,(char *)t->IText,strlen((char *)t->IText));
  1115.     text_num = tnum;
  1116.     clear_text(g);
  1117.     t->LeftEdge = x - le;
  1118.     t->TopEdge  = y - te - 6;
  1119. placeText:
  1120.     if(NOT which)
  1121.         grel(MainWindow,g);
  1122.     switch_coords(TRUE);
  1123.     add_no();
  1124.     refresh();
  1125. }
  1126.  
  1127. /*
  1128.  * modify a gadget or window/requester text
  1129.  */
  1130. void modify( ULONG which )
  1131. {
  1132.     struct Gadget *g;
  1133.     ULONG          pos;
  1134.  
  1135.     if(NOT which) {
  1136.         if(NOT Gadgets.Head->Succ) return;
  1137.         if(NOT is_gadget()) return;
  1138.         sst("PICK GADGET TO MODIFY TEXT....");
  1139.         if(NOT(g = wait_for_gadget(MainWindow))) return;
  1140.     } else
  1141.         g = &TextGadget;
  1142.  
  1143.     if(NOT g->GadgetText) {
  1144.         if(NOT which)       Error("Gadget has no text(s) to modify !");
  1145.         else if(which == 1) Error("Window has no text(s) to modify !");
  1146.         else                Error("Requester has no text(s) to modify !");
  1147.         return;
  1148.     }
  1149.  
  1150.     Saved = FALSE;
  1151.     rem_no();
  1152.     text_select(g,2,which);
  1153.     add_no();
  1154.     refresh();
  1155. }
  1156.  
  1157. /*
  1158.  * delete a gadget or window/requester text
  1159.  */
  1160. void text_delete( ULONG which )
  1161. {
  1162.     struct Gadget *g;
  1163.     ULONG          pos;
  1164.  
  1165.     if(NOT which) {
  1166.         if(NOT Gadgets.Head->Succ) return;
  1167.         if(NOT is_gadget()) return;
  1168.         sst("PICK GADGET TO DELETE TEXT....");
  1169.         if(NOT(g = wait_for_gadget(MainWindow))) return;
  1170.     } else
  1171.         g = &TextGadget;
  1172.  
  1173.     if(NOT g->GadgetText) {
  1174.         if(NOT which)       Error("Gadget has no text(s) to delete !");
  1175.         else if(which == 1) Error("Window has no text(s) to delete !");
  1176.         else                Error("Requester has no text(s) to delete !");
  1177.         return;
  1178.     }
  1179.     Saved = FALSE;
  1180.     rem_no();
  1181.     text_select(g,3,which);
  1182.     add_no();
  1183.     refresh();
  1184. }
  1185.