home *** CD-ROM | disk | FTP | other *** search
/ Club Amiga de Montreal - CAM / CAM_CD_1.iso / files / 514b.lha / GadgetED_v2.3 / Source / gfunc.c < prev    next >
C/C++ Source or Header  |  1991-06-08  |  28KB  |  974 lines
  1. /*----------------------------------------------------------------------*
  2.   gfunc.c Version 2.3 -  © 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 GadgetList     Gadgets;
  12. extern struct ge_prefs       prefs;
  13. extern struct Gadget         TextGadget;
  14. extern struct NewWindow      nw_main;
  15. extern struct FileRequester *IODir;
  16. extern struct MemoryChain    Memory;
  17. extern BOOL                  Saved, REQUESTER, WBSCREEN;
  18. extern USHORT                FrontPen, Code, GadgetCount, id, BackFill;
  19. extern USHORT                Colors[32],DEPTH, WDBackFill;
  20. extern UBYTE                 name[256], wdt[80], wlb[MAXLABEL];
  21. extern SHORT                 MainX,MainY,text_num;
  22. extern ULONG                 IDCMPFlags, WindowFlags, Class;
  23.  
  24. struct Gadget *wait_for_gadget();
  25.  
  26. /*
  27.  * remove all 'BORDERONLY' gadgets from the edit window
  28.  * so they won't interferre with your editing
  29.  */
  30. VOID rem_bo()
  31. {
  32.     register struct MyGadget *g;
  33.  
  34.     if(Gadgets.TailPred == (struct MyGadget *)&Gadgets) return;
  35.  
  36.     for(g = Gadgets.Head; g->Succ; g = g->Succ)
  37.     {   if(TestBits((ULONG)g->SpecialFlags,BORDERONLY))
  38.             RemoveGList(MainWindow,&g->Gadget,1);
  39.     }
  40. }
  41.  
  42. /*
  43.  * put back all 'BORDERONLY' gadgets in the edit window
  44.  * so they may be selected to be moved, re-sized, deleted,
  45.  * copied and edited
  46.  */
  47. VOID add_bo()
  48. {
  49.     register struct MyGadget *g;
  50.  
  51.     if(Gadgets.TailPred == (struct MyGadget *)&Gadgets) return;
  52.  
  53.     for(g = Gadgets.Head; g->Succ; g = g->Succ)
  54.     {   if(TestBits((ULONG)g->SpecialFlags,BORDERONLY))
  55.             AddGList(MainWindow,&g->Gadget,-1L,1,NULL);
  56.     }
  57. }
  58.  
  59. /*
  60.  * remove all normal gadgets from the edit window
  61.  * so they won't interferre with text palcing and gadget resizing.
  62.  */
  63. VOID rem_no()
  64. {
  65.     register struct MyGadget *g;
  66.  
  67.     if(Gadgets.TailPred == (struct MyGadget *)&Gadgets) return;
  68.  
  69.     for(g = Gadgets.Head; g->Succ; g = g->Succ)
  70.     {   if(NOT TestBits((ULONG)g->SpecialFlags,BORDERONLY))
  71.             RemoveGList(MainWindow,&g->Gadget,1);
  72.     }
  73. }
  74.  
  75. /*
  76.  * put back all normal gadgets in the edit window
  77.  * so they may be selected to be moved, re-sized, deleted,
  78.  * copied and edited
  79.  */
  80. VOID add_no()
  81. {
  82.     register struct MyGadget *g;
  83.  
  84.     if(Gadgets.TailPred == (struct MyGadget *)&Gadgets) return;
  85.  
  86.     for(g = Gadgets.Head; g->Succ; g = g->Succ)
  87.     {   if(NOT TestBits((ULONG)g->SpecialFlags,BORDERONLY))
  88.             AddGList(MainWindow,&g->Gadget,-1L,1,NULL);
  89.     }
  90. }
  91.  
  92. /*
  93.  * refresh the complete display
  94.  */
  95. VOID refresh()
  96. {
  97.     USHORT br,bt,bb,bl;
  98.  
  99.     br = MainWindow->BorderRight;
  100.     bt = MainWindow->BorderTop;
  101.     bb = MainWindow->BorderBottom;
  102.     bl = MainWindow->BorderLeft;
  103.  
  104.     SetDrMd(MainRP,JAM1);
  105.  
  106.     if(REQUESTER)
  107.     {   add_bo();
  108.         SetAPen(MainRP,BackFill);
  109.         RectFill(MainRP,0,0,MainWindow->GZZWidth,MainWindow->GZZHeight);
  110.         RefreshWindowFrame(MainWindow);
  111.         rem_bo();
  112.     }
  113.     else
  114.     {   RefreshWindowFrame(MainWindow);
  115.         SetAPen(MainRP,WDBackFill);
  116.         RectFill(MainRP,bl-2,bt-1,MainWindow->Width-bl+1,MainWindow->Height-2);
  117.         add_bo();
  118.         RefreshGList(MainWindow->FirstGadget,MainWindow,NULL,-1L);
  119.         rem_bo();
  120.     }
  121.     if(TextGadget.GadgetText) PrintIText(MainRP,TextGadget.GadgetText,0,0);
  122. }
  123.  
  124. /*
  125.  * get the pointer to the MyGadget structure in which gadget 'g'
  126.  * is defined
  127.  */
  128. struct MyGadget *get_mg(g)
  129.     struct Gadget *g;
  130. {
  131.     register struct MyGadget *ret;
  132.  
  133.     for(ret = Gadgets.Head; ret ->Succ; ret = ret->Succ)
  134.         if(g == &ret->Gadget) return(ret);
  135. }
  136.  
  137. /*
  138.  * check to see if there are already gadgets on the
  139.  * edit window that are not 'BORDERONLY'
  140.  */
  141. BOOL is_gadget()
  142. {
  143.     register struct MyGadget *tmp;
  144.  
  145.     for(tmp = Gadgets.Head; tmp->Succ ; tmp = tmp->Succ)
  146.     {   if(NOT TestBits((ULONG)tmp->SpecialFlags,BORDERONLY)) return(TRUE);
  147.     }
  148.     return(FALSE);
  149. }
  150.  
  151. /*
  152.  * make a copy of a gadget
  153.  */
  154. VOID copy_gadget()
  155. {
  156.     struct Gadget *gad;
  157.     SHORT             x,y,w,h,xo,yo,ls,ds;
  158.     ULONG             ps;
  159.     struct MyGadget   *gadget, *mg;
  160.     struct Border     *border,*border1;
  161.     struct StringInfo *sinfo, *sinfo1;
  162.     struct PropInfo   *pinfo;
  163.     struct Image      *image, *image1;
  164.     struct IntuiText  *to, *tn, *tnl;
  165.  
  166.     if(Gadgets.TailPred == (struct MyGadget *)&Gadgets) return;
  167.     add_bo();
  168.     sst("PICK GADGET TO COPY....");
  169.     if(NOT(gad = wait_for_gadget(MainWindow)))
  170.     {   rem_bo();
  171.         return;
  172.     }
  173.  
  174.     rem_bo();
  175.     rem_no();
  176.     Saved = FALSE;
  177.     mg = get_mg(gad);
  178.  
  179.     if(NOT(gadget = (struct MyGadget *)Alloc(&Memory,(ULONG)sizeof(struct MyGadget))))
  180.     {   Error("Out of Memory !");
  181.         return;
  182.     }
  183.  
  184.     un_grel(MainWindow,gad);
  185.     CopyMem((void *)gad,(void *)&gadget->Gadget,sizeof(struct Gadget));
  186.  
  187.     gadget->Gadget.GadgetText   = NULL;
  188.     gadget->Gadget.GadgetRender = NULL;
  189.     gadget->Gadget.SelectRender = NULL;
  190.     gadget->Gadget.SpecialInfo  = NULL;
  191.     gadget->Gadget.GadgetID     = GadgetCount++;
  192.     Format((char *)&gadget->GadgetLabel,"Gadget%ld",id++);
  193.     gadget->Gadget.LeftEdge     = gad->LeftEdge + 5;
  194.     gadget->Gadget.TopEdge      = gad->TopEdge  + 5;
  195.     gadget->SpecialFlags        = mg->SpecialFlags;
  196.  
  197.  
  198.     if(NOT TestBits((ULONG)gad->GadgetType,PROPGADGET))
  199.     {   if((NOT TestBits((ULONG)gad->Flags,GADGIMAGE)) OR
  200.            (NOT prefs.image_copy))
  201.         {   border = (struct Border *)gad->GadgetRender;
  202.             if(add_border(gadget) == FALSE)
  203.                 goto NoMem;
  204.             border1 = (struct Border *)gadget->Gadget.GadgetRender;
  205.             border1->FrontPen = border->FrontPen;
  206.             if(TestBits((ULONG)gadget->SpecialFlags,OS20BORDER))
  207.                 border1->NextBorder->FrontPen = border->NextBorder->FrontPen;
  208.         }
  209.     }
  210.     else
  211.     {   if(NOT(pinfo = (struct PropInfo *)Alloc(&Memory,(ULONG)sizeof(struct PropInfo))))
  212.             goto NoMem;
  213.         CopyMem((void *)gad->SpecialInfo,(void *)pinfo,sizeof(struct PropInfo));
  214.         if((NOT(TestBits((ULONG)gad->Flags,GADGIMAGE))) OR
  215.            (prefs.image_copy == FALSE))
  216.         {   if(NOT(gadget->Gadget.GadgetRender = Alloc(&Memory,(ULONG)sizeof(struct Image))))
  217.                 goto NoMem;
  218.             pinfo->Flags |= AUTOKNOB;
  219.         }
  220.         gadget->Gadget.SpecialInfo = (APTR)pinfo;
  221.     }
  222.  
  223.     if((TestBits((ULONG)gad->Flags,GADGIMAGE)) AND
  224.        (prefs.image_copy == TRUE))
  225.     {   image = (struct Image *)gad->GadgetRender;
  226.         ps = (ULONG)(RASSIZE(image->Width,image->Height) * image->Depth);
  227.         if(NOT(image1 = (struct Image *)Alloc(&Memory,(ULONG)sizeof(struct Image))))
  228.             goto NoMem;
  229.         CopyMem((void *)image,(void *)image1,sizeof(struct Image));
  230.         if(NOT(image1->ImageData = (USHORT *)AllocMem(ps,MEMF_CHIP+MEMF_CLEAR)))
  231.             goto NoMem;
  232.         CopyMem((void *)image->ImageData,(void *)image1->ImageData,ps);
  233.         gadget->Gadget.GadgetRender = (APTR)image1;
  234.     }
  235.     else if((TestBits((ULONG)gad->Flags,GADGIMAGE)) AND
  236.             (prefs.image_copy == FALSE))
  237.                   gadget->Gadget.Flags ^= GADGIMAGE;
  238.  
  239.     if((TestBits((ULONG)gad->Flags,GADGHIMAGE)) AND
  240.        (prefs.image_copy == TRUE) AND
  241.        (NOT TestBits((ULONG)gad->Flags,GADGHBOX)))
  242.     {   image = (struct Image *)gad->SelectRender;
  243.         ps = (ULONG)(RASSIZE(image->Width,image->Height) * image->Depth);
  244.         if(NOT(image1 = (struct Image *)Alloc(&Memory,(ULONG)sizeof(struct Image))))
  245.             goto NoMem;
  246.         CopyMem((void *)image,(void *)image1,sizeof(struct Image));
  247.         if(NOT(image1->ImageData = (USHORT *)AllocMem(ps,MEMF_CHIP+MEMF_CLEAR)))
  248.             goto NoMem;
  249.         CopyMem((void *)image->ImageData,(void *)image1->ImageData,ps);
  250.         gadget->Gadget.SelectRender = (APTR)image1;
  251.     }
  252.     else if((TestBits((ULONG)gad->Flags,GADGHIMAGE)) AND
  253.             (prefs.image_copy == FALSE))
  254.     {   gadget->Gadget.SelectRender = NULL;
  255.         gadget->Gadget.Flags ^= GADGHIMAGE;
  256.     }
  257.  
  258.     if((gad->GadgetText) AND (prefs.text_copy == TRUE))
  259.     {   to = gad->GadgetText;
  260.         if(NOT(tn = (struct IntuiText *)Alloc(&Memory,(ULONG)sizeof(struct IntuiText))))
  261.             goto NoMem;
  262.         CopyMem((char *)to,(char *)tn,(ULONG)sizeof(struct IntuiText));
  263.         if(NOT(tn->IText = (UBYTE *)Alloc(&Memory,80L)))
  264.             goto NoMem;
  265.         CopyMem((char *)to->IText,(char *)tn->IText,80L);
  266.         gadget->Gadget.GadgetText = tn;
  267.         if(to = to->NextText)
  268.         {   while(1)
  269.             {   if(NOT(tnl = (struct IntuiText *)Alloc(&Memory,(ULONG)sizeof(struct IntuiText))))
  270.                     goto NoMem;
  271.                 CopyMem((char *)to,(char *)tnl,(ULONG)sizeof(struct IntuiText));
  272.                 if(NOT(tnl->IText = (UBYTE *)Alloc(&Memory,80L)))
  273.                     goto NoMem;
  274.                 CopyMem((char *)to->IText,(char *)tnl->IText,80L);
  275.                 tn->NextText = tnl;
  276.                 tn = tnl;
  277.                 if(NOT(to = to->NextText)) break;
  278.             }
  279.         }
  280.     }
  281.     if((TestBits((ULONG)gad->GadgetType,STRGADGET)))
  282.     {   sinfo1 = (struct StringInfo *)gad->SpecialInfo;
  283.         if(NOT(sinfo = (struct StringInfo *)Alloc(&Memory,(ULONG)sizeof(struct StringInfo))))
  284.             goto NoMem;
  285.         CopyMem((void *)sinfo1,(void *)sinfo,sizeof(struct StringInfo));
  286.         if(NOT(sinfo->Buffer = (UBYTE *)Alloc(&Memory,sinfo->MaxChars)))
  287.             goto NoMem;
  288.         CopyMem((void *)sinfo1->Buffer,(void *)sinfo->Buffer,sinfo->MaxChars);
  289.         if(sinfo->UndoBuffer)
  290.         {   if(NOT(sinfo1->UndoBuffer = (UBYTE *)Alloc(&Memory,sinfo->MaxChars)))
  291.                 goto NoMem;
  292.         }
  293.         gadget->Gadget.SpecialInfo = (APTR)sinfo;
  294.     }
  295.     set_info();
  296.     x = gadget->Gadget.LeftEdge-1;
  297.     y = gadget->Gadget.TopEdge-1;
  298.     w = gadget->Gadget.Width+1;
  299.     h = gadget->Gadget.Height+1;
  300.     SetDrMd(MainRP,COMPLEMENT);
  301.     SetAPen(MainRP,FrontPen);
  302.     draw_box(MainWindow,x,y,x+w,y+h);
  303.     do_info(x,y,x+w,y+w);
  304.     xo = MainX-x;
  305.     yo = MainY-y;
  306.     while(Code != SELECTDOWN)
  307.     {   while(read_msg(MainWindow))
  308.         {   if(Class == MENUPICK) set_info();
  309.             do_info(x,y,x+w,y+h);
  310.         }
  311.         get_xy(&MainX,&MainY);
  312.         if((MainX != (x + xo)) OR (MainY != (y + yo)))
  313.         {   draw_box(MainWindow,x,y,x+w,y+h);
  314.             x = MainX - xo;
  315.             y = MainY - yo;
  316.             draw_box(MainWindow,x,y,x+w,y+h);
  317.             do_info(x,y,x+w,y+w);
  318.         }
  319.     }
  320.     gadget->Gadget.LeftEdge = x+1;
  321.     gadget->Gadget.TopEdge  = y+1;
  322.     AddHead((void *)&Gadgets,(void *)gadget);
  323.     grel(MainWindow,&gadget->Gadget);
  324.     grel(MainWindow,gad);
  325.     add_no();
  326.     refresh();
  327.     return;
  328. NoMem:
  329.     FreeGadget(gadget);
  330.     Error("Out of Memory !");
  331. }
  332.  
  333. /*
  334.  * delete a gadget
  335.  */
  336. VOID delete()
  337. {
  338.     struct Gadget   *gd;
  339.     struct MyGadget *gadget;
  340.     UCOUNT          i=0;
  341.  
  342.     if(Gadgets.TailPred == (struct MyGadget *)&Gadgets) return;
  343.  
  344.     add_bo();
  345.     sst("PICK GADGET TO DELETE.....");
  346.     if(NOT(gd = wait_for_gadget(MainWindow))) { rem_bo(); return; }
  347.  
  348.     Saved = FALSE;
  349.  
  350.     for(gadget = Gadgets.Head; gadget->Succ; gadget = gadget->Succ)
  351.     {   if(gd == &gadget->Gadget)
  352.         {   Remove((void *)gadget);
  353.             un_grel(MainWindow,gd);
  354.             RemoveGList(MainWindow,gd,1);
  355.             FreeGadget(gadget);
  356.             break;
  357.         }
  358.     }
  359.     for(gadget = Gadgets.TailPred; gadget != (struct MyGadget *)&Gadgets.Head; gadget = gadget->Pred)
  360.        gadget->Gadget.GadgetID = i++;
  361.     rem_bo();
  362.     refresh();
  363. }
  364.  
  365. /*
  366.  * load a IFF ILBM brush as gadget render
  367.  */
  368. VOID render()
  369. {
  370.     struct Gadget   *gadget;
  371.     struct PropInfo *info;
  372.     struct Border   *border;
  373.     struct Image    *image, *image1, *ReadImage();
  374.     ULONG            Pos, ps, rc;
  375.  
  376.     if(Gadgets.TailPred == (struct MyGadget *)&Gadgets) return;
  377.     if(NOT is_gadget()) return;
  378.     sst("PICK GADGET TO RENDER.....");
  379.     if(NOT(gadget = wait_for_gadget(MainWindow))) return;
  380.  
  381.     if(TestBits((ULONG)gadget->Flags,GADGIMAGE))
  382.     {   if(Ask("Gadget already has an Image !",
  383.                "Do you wish to over-write it ?") == FALSE) return;
  384.     }
  385.  
  386.     strcpy((char *)IODir->fr_HeadLine,"Load Gadget Render");
  387.     IODir->fr_Screen  = MainScreen;
  388.     IODir->fr_Caller  = MainWindow;
  389.     IODir->fr_Flags  |= FR_NoInfo;
  390.     rc = FileRequest(IODir);
  391.     strcpy((char *)&name,(char *)IODir->fr_DirName);
  392.     strcat((char *)&name,(char *)IODir->fr_FileName);
  393.  
  394.     if(rc == FREQ_CANCELED) return;
  395.     else if(rc)
  396.     {   Error("FileRequester Won't Open !");
  397.         return;
  398.     }
  399.     Saved = FALSE;
  400.     disable_window();
  401.     if(NOT(image = ReadImage(name)))
  402.     {   enable_window();
  403.         return;
  404.     }
  405.  
  406.     Pos = RemoveGList(MainWindow,gadget,1);
  407.     un_grel(MainWindow,gadget);
  408.  
  409.     if(TestBits((ULONG)gadget->Flags,GADGIMAGE))
  410.     {   image1 = (struct Image *)gadget->GadgetRender;
  411.         ps     = (ULONG)(RASSIZE(image1->Width,image1->Height) * image1->Depth);
  412.         FreeMem(image1->ImageData,ps);
  413.         FreeItem(&Memory,image1,(long)sizeof(struct Image));
  414.     }
  415.     else if(TestBits((ULONG)gadget->GadgetType,PROPGADGET))
  416.         FreeItem(&Memory,gadget->GadgetRender,(long)sizeof(struct Image));
  417.     else
  418.     {   border = (struct Border *)gadget->GadgetRender;
  419.         FreeItem(&Memory,border->XY,20L);
  420.         FreeItem(&Memory,border,(long)sizeof(struct Border));
  421.     }
  422.     if(NOT(TestBits((ULONG)gadget->GadgetType,PROPGADGET)))
  423.     {   if(prefs.auto_size)
  424.         {   gadget->Width  = image->Width;
  425.             gadget->Height = image->Height;
  426.         }
  427.     }
  428.     else
  429.     {   info = (struct PropInfo *)gadget->SpecialInfo;
  430.         info->Flags ^= AUTOKNOB;
  431.     }
  432.     gadget->Flags       |= GADGIMAGE;
  433.     gadget->GadgetRender = (APTR)image;
  434.     grel(MainWindow,gadget);
  435.     AddGList(MainWindow,gadget,Pos,1,NULL);
  436.     enable_window();
  437.     refresh();
  438. }
  439.  
  440. /*
  441.  * read an IFF ILBM brush as select render
  442.  */
  443. VOID sel_render()
  444. {
  445.     struct Gadget   *gadget;
  446.     struct PropInfo *info;
  447.     struct Image    *image, *image1, *ReadImage();
  448.     ULONG           Pos, ps, rc;
  449.  
  450.     if(Gadgets.TailPred == (struct MyGadget *)&Gadgets) return;
  451.     if(NOT is_gadget()) return;
  452.     sst("PICK GADGET TO SELECT RENDER.....");
  453.     if(NOT(gadget = wait_for_gadget(MainWindow))) return;
  454.  
  455.     if((TestBits((ULONG)gadget->Flags,GADGHIMAGE)) AND
  456.        (NOT TestBits((ULONG)gadget->Flags,GADGHBOX)))
  457.     {   if(Ask("Gadget already has an Image !",
  458.                "Do you wish to over-write it ?") == FALSE) return;
  459.     }
  460.  
  461.     if(NOT(TestBits((ULONG)gadget->Flags,GADGIMAGE)))
  462.     {   Error("Not an Image Gadget !");
  463.         return;
  464.     }
  465.  
  466.     strcpy((char *)IODir->fr_HeadLine,"Load Select Render");
  467.     IODir->fr_Screen  = MainScreen;
  468.     IODir->fr_Caller  = MainWindow;
  469.     IODir->fr_Flags  |= FR_NoInfo;
  470.     rc = FileRequest(IODir);
  471.     strcpy((char *)&name,(char *)IODir->fr_DirName);
  472.     strcat((char *)&name,(char *)IODir->fr_FileName);
  473.     if(rc == FREQ_CANCELED) return;
  474.     else if(rc)
  475.     {   Error("FileRequester Won't Open");
  476.         return;
  477.     }
  478.  
  479.     Saved = FALSE;
  480.  
  481.     disable_window();
  482.     if(NOT(image = ReadImage(name)))
  483.     {   enable_window();
  484.         return;
  485.     }
  486.     Pos = RemoveGList(MainWindow,gadget,1);
  487.     un_grel(MainWindow,gadget);
  488.     if((TestBits((ULONG)gadget->Flags,GADGHBOX)) AND
  489.        (NOT TestBits((ULONG)gadget->Flags,GADGHIMAGE)))
  490.            gadget->Flags ^= GADGHBOX;
  491.  
  492.     if((TestBits((ULONG)gadget->Flags,GADGHIMAGE)) AND
  493.        (NOT TestBits((ULONG)gadget->Flags,GADGHBOX)))
  494.     {   image1 = (struct Image *)gadget->SelectRender;
  495.         ps     = (ULONG)(RASSIZE(image1->Width,image1->Height) * image1->Depth);
  496.         FreeMem(image1->ImageData,ps);
  497.         FreeItem(&Memory,image1,(long)sizeof(struct Image));
  498.     }
  499.  
  500.     gadget->Flags       |= GADGHIMAGE;
  501.     gadget->SelectRender = (APTR)image;
  502.     grel(MainWindow,gadget);
  503.     AddGList(MainWindow,gadget,Pos,1,NULL);
  504.     enable_window();
  505.     refresh();
  506. }
  507.  
  508. /*
  509.  * read and set the CMAP of an IFF ILBM picture
  510.  */
  511. VOID do_cmap()
  512. {
  513.     ULONG rc;
  514.  
  515.     strcpy((char *)IODir->fr_HeadLine,"Load IFF ColorMap");
  516.     IODir->fr_Screen = MainScreen;
  517.     IODir->fr_Caller = MainWindow;
  518.     rc = FileRequest(IODir);
  519.     strcpy((char *)&name,(char *)IODir->fr_DirName);
  520.     strcat((char *)&name,(char *)IODir->fr_FileName);
  521.     if(rc == FREQ_CANCELED) return;
  522.     else if(rc)
  523.     {   Error("FileRequester Won't Open !");
  524.         return;
  525.     }
  526.     Saved = FALSE;
  527.     disable_window();
  528.     ReadCMAP(name);
  529.     enable_window();
  530. }
  531.  
  532. /*
  533.  * resize a gadget
  534.  */
  535. VOID size_gadget()
  536. {
  537.     struct MyGadget *mg;
  538.     struct Gadget *gadget;
  539.     SHORT         x,y,w,h,xo,yo, *XY;
  540.     ULONG         Pos;
  541.  
  542.     if(Gadgets.TailPred == (struct MyGadget *)&Gadgets) return;
  543.     add_bo();
  544.     sst("PICK GADGET TO RE-SIZE.....");
  545.     if(NOT(gadget = wait_for_gadget(MainWindow))) { rem_bo(); return; }
  546.  
  547.     rem_bo();
  548.     rem_no();
  549.  
  550.     Saved = FALSE;
  551.  
  552.     mg = get_mg(gadget);
  553.     un_grel(MainWindow,gadget);
  554.     x = gadget->LeftEdge-1;
  555.     y = gadget->TopEdge-1;
  556.     w = gadget->Width+1;
  557.     h = gadget->Height+1;
  558.     set_info();
  559.     SetDrMd(MainRP,COMPLEMENT);
  560.     SetAPen(MainRP,FrontPen);
  561.     draw_box(MainWindow,x,y,x+w,y+h);
  562.     do_info(x,y,x+w,y+h);
  563.     xo = (x+w)-MainX;
  564.     yo = (y+h)-MainY;
  565.  
  566.     while(Code != SELECTDOWN)
  567.     {   while(read_msg(MainWindow))
  568.         {   if(Class == MENUPICK) set_info();
  569.             do_info(x,y,x+w,y+h);
  570.         }
  571.         get_xy(&MainX,&MainY);
  572.         if((MainX != ((x + w) - xo)) OR (MainY != ((y + h) - yo)))
  573.         {   draw_box(MainWindow,x,y,x+w,y+h);
  574.             if(((MainX - x) + xo) >= 9)  w = (MainX - x) + xo;
  575.             if(((MainY - y) + yo) >= 9)  h = (MainY - y) + yo;
  576.             draw_box(MainWindow,x,y,x+w,y+h);
  577.             do_info(x,y,x+w,y+h);
  578.         }
  579.     }
  580.     add_bo();
  581.     add_no();
  582.     draw_box(MainWindow,x,y,x+w,y+h);
  583.     gadget->Width  = w-1;
  584.     gadget->Height = h-1;
  585.     if((TestBits((ULONG)gadget->GadgetType,STRGADGET)) &&
  586.        (TestBits((ULONG)mg->SpecialFlags,OS20BORDER)))
  587.         { w++; h++; }
  588.     if(NOT(TestBits((ULONG)gadget->GadgetType,PROPGADGET)))
  589.     {   if(NOT TestBits((ULONG)mg->SpecialFlags,OS20BORDER))
  590.         {   XY = (((struct Border *)gadget->GadgetRender)->XY);
  591.             XY[2] = XY[4] = w-1;
  592.             XY[5] = XY[7] = h-1;
  593.         }
  594.         else
  595.         {   w-=2; h-=2;
  596.             XY = (((struct Border *)gadget->GadgetRender)->XY);
  597.             XY[3] = h;
  598.             XY[5] = h-1;
  599.             XY[8] = w-1;
  600.             XY = ((((struct Border *)gadget->GadgetRender)->NextBorder)->XY);
  601.             XY[1] = XY[3] = XY[9] = h;
  602.             XY[2] = XY[4] = w-1;
  603.             XY[6] = XY[8] = w;
  604.         }
  605.     }
  606.     grel(MainWindow,gadget);
  607.     rem_bo();
  608.     refresh();
  609. }
  610.  
  611. /*
  612.  * move a gadget
  613.  */
  614. VOID move_gadget()
  615. {
  616.     struct MyGadget *mg;
  617.     struct Gadget *gadget;
  618.     SHORT x,y,w,h,xo,yo;
  619.     ULONG Pos;
  620.  
  621.     if(Gadgets.TailPred == (struct MyGadget *)&Gadgets) return;
  622.     add_bo();
  623.     sst("PICK GADGET TO MOVE....");
  624.     if(NOT(gadget = wait_for_gadget(MainWindow))) { rem_bo(); return; }
  625.  
  626.     Saved = FALSE;
  627.     rem_bo();
  628.     rem_no();
  629.     mg = get_mg(gadget);
  630.     set_info();
  631.     un_grel(MainWindow,gadget);
  632.     x = gadget->LeftEdge-1;
  633.     y = gadget->TopEdge-1;
  634.     w = gadget->Width+1;
  635.     h = gadget->Height+1;
  636.     SetDrMd(MainRP,COMPLEMENT);
  637.     SetAPen(MainRP,FrontPen);
  638.     draw_box(MainWindow,x,y,x+w,y+h);
  639.     do_info(x,y,x+w,y+h);
  640.     xo = MainX-x;
  641.     yo = MainY-y;
  642.  
  643.     while(Code != SELECTDOWN)
  644.     {   while(read_msg(MainWindow))
  645.         {   if(Class == MENUPICK) set_info();
  646.             do_info(x,y,x+w,y+h);
  647.         }
  648.         get_xy(&MainX,&MainY);
  649.         if((MainX != (x + xo)) OR (MainY != (y + yo)))
  650.         {   draw_box(MainWindow,x,y,x+w,y+h);
  651.             x = MainX - xo;
  652.             y = MainY - yo;
  653.             draw_box(MainWindow,x,y,x+w,y+h);
  654.             do_info(x,y,x+w,y+h);
  655.         }
  656.     }
  657.     add_bo();
  658.     add_no();
  659.     draw_box(MainWindow,x,y,x+w,y+h);
  660.     gadget->LeftEdge = x+1;
  661.     gadget->TopEdge  = y+1;
  662.     grel(MainWindow,gadget);
  663.     rem_bo();
  664.     refresh();
  665. }
  666.  
  667. /*
  668.  * edit a gadget
  669.  */
  670. VOID edit()
  671. {
  672.     struct MyGadget *mg;
  673.     struct Gadget   *g;
  674.     ULONG  Pos;
  675.     BOOL   suc;
  676.  
  677.     if(Gadgets.TailPred == (struct MyGadget *)&Gadgets) return;
  678.     add_bo();
  679.     sst("PICK GADGET TO EDIT....");
  680.     if(NOT(g = wait_for_gadget(MainWindow))) { rem_bo(); return; }
  681.  
  682.     Saved = FALSE;
  683.  
  684.     mg = get_mg(g);
  685.     Pos = RemoveGList(MainWindow,g,1);
  686.     un_grel(MainWindow,g);
  687.     disable_window();
  688.     suc = edit_gadget(mg);
  689.     enable_window();
  690.     grel(MainWindow,g);
  691.     if(NOT suc)
  692.     {   Remove((void *)mg);
  693.         FreeGadget(mg);
  694.     }
  695.     else AddGList(MainWindow,g,Pos,1,NULL);
  696.     rem_bo();
  697.     refresh();
  698. }
  699.  
  700. /*
  701.  * erase all gadgets and set the window to default
  702.  */
  703. VOID new()
  704. {
  705.     if(Saved == FALSE)
  706.     {   if(Ask("Current work isn't saved !",
  707.                "Are you sure ?") == FALSE) return;
  708.     }
  709.  
  710.     FreeGList();
  711.  
  712.     if(REQUESTER)
  713.     {   nw_main.Flags     = WINDOWDRAG+WINDOWSIZING+SIZEBRIGHT+SIZEBBOTTOM+BORDERLESS+GIMMEZEROZERO;
  714.         strcpy((char *)&wdt,"Requester");
  715.         strcpy((char *)&wlb,"requester");
  716.         BackFill = 1;
  717.     }
  718.     else
  719.     {   nw_main.Flags    = WINDOWDRAG+WINDOWSIZING+WINDOWDEPTH+WINDOWCLOSE;
  720.         strcpy((char *)&wdt,"Work Window");
  721.         strcpy((char *)&wlb,"new_window");
  722.     }
  723.     nw_main.LeftEdge    = 50;
  724.     nw_main.TopEdge     = 25;
  725.     nw_main.Width       = 175;
  726.     nw_main.Height      = 50;
  727.     nw_main.BlockPen    = 1;
  728.     nw_main.DetailPen   = 0;
  729.     nw_main.FirstGadget = NULL;
  730.     nw_main.Title       = (UBYTE *)&wdt;
  731.     nw_main.MinWidth    = 150;
  732.     nw_main.MinHeight   = 50;
  733.     nw_main.MaxWidth    = MainScreen->Width;
  734.     nw_main.MaxHeight   = MainScreen->Height;
  735.     nw_main.Flags      |= NOCAREREFRESH+SMART_REFRESH+ACTIVATE;
  736.  
  737.     WindowFlags = WINDOWCLOSE+WINDOWDRAG+WINDOWDEPTH+WINDOWSIZING+NOCAREREFRESH+SMART_REFRESH+ACTIVATE;
  738.     IDCMPFlags  = GADGETUP+GADGETDOWN+CLOSEWINDOW;
  739.     CloseWindow(MainWindow);
  740.     open_display();
  741.     SetMenu(MainWindow);
  742.     if(!WBSCREEN)
  743.         LoadRGB4(&MainScreen->ViewPort,(void *)&Colors,(1 << DEPTH));
  744.     refresh();
  745. }
  746.  
  747. /*
  748.  * delete the render images of a gadget
  749.  */
  750. VOID delete_images()
  751. {
  752.     struct Gadget   *g;
  753.     struct Image    *i;
  754.     struct PropInfo *p;
  755.     ULONG            pos,ds;
  756.  
  757.     if(Gadgets.TailPred == (struct MyGadget *)&Gadgets) return;
  758.     if(NOT is_gadget()) return;
  759.     sst("PICK GADGET TO DELETE IMAGES....");
  760.     if(NOT(g = wait_for_gadget(MainWindow))) return;
  761.  
  762.     if(NOT(TestBits((ULONG)g->Flags,GADGIMAGE)))
  763.     {   Error("Gadget has no Images to delete !");
  764.         return;
  765.     }
  766.  
  767.     Saved = FALSE;
  768.  
  769.     pos = RemoveGList(MainWindow,g,1);
  770.     un_grel(MainWindow,g);
  771.     i = (struct Image *)g->GadgetRender;
  772.     ds = (ULONG)(RASSIZE(i->Width,i->Height) * i->Depth);
  773.     FreeMem(i->ImageData,ds);
  774.     if(NOT TestBits(g->GadgetType,PROPGADGET))
  775.        FreeItem(&Memory,i,(long)sizeof(struct Image));
  776.     g->Flags ^= GADGIMAGE;
  777.     if((TestBits((ULONG)g->Flags,GADGHIMAGE)) AND
  778.        (NOT TestBits((ULONG)g->Flags,GADGHBOX)))
  779.     {   i = (struct Image *)g->SelectRender;
  780.         ds = (ULONG)(RASSIZE(i->Width,i->Height) * i->Depth);
  781.         FreeMem(i->ImageData,ds);
  782.         FreeItem(&Memory,i,(long)sizeof(struct Image));
  783.         g->Flags ^= GADGHIMAGE;
  784.         g->SelectRender = NULL;
  785.     }
  786.     if(TestBits((ULONG)g->GadgetType,PROPGADGET))
  787.     {   p = (struct PropInfo *)g->SpecialInfo;
  788.         p->Flags |= AUTOKNOB;
  789.     }
  790.     else add_border(get_mg(g));
  791.     grel(MainWindow,g);
  792.     AddGList(MainWindow,g,pos,1,NULL);
  793.     refresh();
  794. }
  795.  
  796. /*
  797.  * add a text to a gadget or the window/requester
  798.  */
  799. VOID add_text(which)
  800.     USHORT which;
  801. {
  802.     struct Gadget *g;
  803.     struct IntuiText *t, *edit_text();
  804.     ULONG pos;
  805.     SHORT x,y;
  806.  
  807.     if(NOT which)
  808.     {   if(Gadgets.TailPred == (struct MyGadget *)&Gadgets) return;
  809.         if(NOT is_gadget()) return;
  810.         sst("PICK GADGET TO ADD TEXT....");
  811.         if(NOT(g = wait_for_gadget(MainWindow))) return;
  812.     }
  813.     else g = &TextGadget;
  814.  
  815.     if(NOT(t = edit_text(g,0,0,which))) return;
  816.  
  817.     rem_no();
  818.     Saved = FALSE;
  819.  
  820.     un_grel(MainWindow,g);
  821.     get_xy(&x,&y);
  822.     SetDrMd(MainRP,COMPLEMENT);
  823.     SetAPen(MainRP,FrontPen);
  824.     Move(MainRP,x,y);
  825.     Text(MainRP,(char *)t->IText,strlen((char *)t->IText));
  826.  
  827.     while(Code != SELECTDOWN)
  828.     {   while(read_msg(MainWindow));
  829.         get_xy(&MainX,&MainY);
  830.         if((MainX != x) OR (MainY != y))
  831.         {   Move(MainRP,x,y);
  832.             Text(MainRP,(char *)t->IText,strlen((char *)t->IText));
  833.             x = MainX;
  834.             y = MainY;
  835.             Move(MainRP,x,y);
  836.             Text(MainRP,(char *)t->IText,strlen((char *)t->IText));
  837.         }
  838.     }
  839.     Move(MainRP,x,y);
  840.     Text(MainRP,(char *)t->IText,strlen((char *)t->IText));
  841.  
  842.     t->LeftEdge = x - g->LeftEdge;
  843.     t->TopEdge  = y - g->TopEdge - 6;
  844.  
  845.     if(NOT which)
  846.         grel(MainWindow,g);
  847.     add_no();
  848.     refresh();
  849. }
  850.  
  851. /*
  852.  * move a gadget or window/requester text
  853.  */
  854. VOID move_text(which)
  855.     USHORT which;
  856. {
  857.     struct Gadget    *g;
  858.     struct IntuiText *t, *GetPtr();
  859.     ULONG            pos;
  860.     LONG             tnum;
  861.     SHORT            x,y;
  862.  
  863.     if(NOT which)
  864.     {   if(Gadgets.TailPred == (struct MyGadget *)&Gadgets) return;
  865.         if(NOT is_gadget()) return;
  866.         sst("PICK GADGET TO MOVE TEXT....");
  867.         if(NOT(g = wait_for_gadget(MainWindow))) return;
  868.  
  869.     }
  870.     else g = &TextGadget;
  871.  
  872.     if(NOT g->GadgetText)
  873.     {   if(NOT which) Error("Gadget has no text(s) to move !");
  874.         else if(which == 1) Error("Window has no text(s) to move !");
  875.         else Error("Requester has no text(s) to move !");
  876.         return;
  877.     }
  878.     if((tnum = text_select(g,1,which)) == -1L) return;
  879.  
  880.     Saved = FALSE;
  881.     t = GetPtr(g,tnum);
  882.  
  883.     rem_no();
  884.     un_grel(MainWindow,g);
  885.     get_xy(&x,&y);
  886.     SetDrMd(MainRP,COMPLEMENT);
  887.     SetAPen(MainRP,FrontPen);
  888.     Move(MainRP,x,y);
  889.     Text(MainRP,(char *)t->IText,strlen((char *)t->IText));
  890.  
  891.     while(Code != SELECTDOWN)
  892.     {   while(read_msg(MainWindow));
  893.         get_xy(&MainX,&MainY);
  894.         if((MainX != x) OR (MainY != y))
  895.         {   Move(MainRP,x,y);
  896.             Text(MainRP,(char *)t->IText,strlen((char *)t->IText));
  897.             x = MainX;
  898.             y = MainY;
  899.             Move(MainRP,x,y);
  900.             Text(MainRP,(char *)t->IText,strlen((char *)t->IText));
  901.         }
  902.     }
  903.     Move(MainRP,x,y);
  904.     Text(MainRP,(char *)t->IText,strlen((char *)t->IText));
  905.     text_num = tnum;
  906.     clear_text(g);
  907.     t->LeftEdge = x - g->LeftEdge;
  908.     t->TopEdge  = y - g->TopEdge - 6;
  909.     if(NOT which)
  910.         grel(MainWindow,g);
  911.     add_no();
  912.     refresh();
  913. }
  914.  
  915. /*
  916.  * modify a gadget or window/requester text
  917.  */
  918. VOID modify(which)
  919.     USHORT which;
  920. {
  921.     struct Gadget *g;
  922.     ULONG pos;
  923.  
  924.     if(NOT which)
  925.     {   if(Gadgets.TailPred == (struct MyGadget *)&Gadgets) return;
  926.         if(NOT is_gadget()) return;
  927.         sst("PICK GADGET TO MODIFY TEXT....");
  928.         if(NOT(g = wait_for_gadget(MainWindow))) return;
  929.     }
  930.     else g = &TextGadget;
  931.  
  932.     if(NOT g->GadgetText)
  933.     {   if(NOT which) Error("Gadget has no text(s) to modify !");
  934.         else if(which == 1) Error("Window has no text(s) to modify !");
  935.         else Error("Requester has no text(s) to modify !");
  936.         return;
  937.     }
  938.     Saved = FALSE;
  939.     rem_no();
  940.     text_select(g,2,which);
  941.     add_no();
  942.     refresh();
  943. }
  944.  
  945. /*
  946.  * delete a gadget or window/requester text
  947.  */
  948. VOID text_delete(which)
  949.     USHORT which;
  950. {
  951.     struct Gadget *g;
  952.     ULONG pos;
  953.  
  954.     if(NOT which)
  955.     {   if(Gadgets.TailPred == (struct MyGadget *)&Gadgets) return;
  956.         if(NOT is_gadget()) return;
  957.         sst("PICK GADGET TO DELETE TEXT....");
  958.         if(NOT(g = wait_for_gadget(MainWindow))) return;
  959.     }
  960.     else g = &TextGadget;
  961.     if(NOT g->GadgetText)
  962.     {   if(NOT which) Error("Gadget has no text(s) to delete !");
  963.         else if(which == 1) Error("Window has no text(s) to delete !");
  964.         else Error("Requester has no text(s) to delete !");
  965.         return;
  966.     }
  967.     Saved = FALSE;
  968.     rem_no();
  969.     text_select(g,3,which);
  970.     if(NOT which)
  971.     add_no();
  972.     refresh();
  973. }
  974.