home *** CD-ROM | disk | FTP | other *** search
/ Creative Computers / CreativeComputers.iso / shareware / fractals / treegrow / sources / treegrow.c < prev    next >
Encoding:
C/C++ Source or Header  |  1994-11-17  |  29.0 KB  |  1,441 lines
  1. #include <exec/types.h>
  2. #include <exec/libraries.h>
  3. #include <intuition/intuition.h>
  4. #include <libraries/reqbase.h>
  5. #include <libraries/ilbm_lib.h>
  6. #include <workbench/startup.h>
  7. #include <stdio.h>
  8. #include <stdlib.h>
  9. #include <math.h>
  10.  
  11. #define rad(x) ( (x) * (float)3.14159 / (float)180.0 )
  12.  
  13. /************************/
  14. /* STRUCTURES        */
  15. /************************/
  16.  
  17. struct Memory
  18.     {
  19.     float x, y;
  20.     float angle, size;
  21.     };
  22.  
  23. struct LibEntry
  24.     {
  25.     struct LibEntry *Next;
  26.     struct LibEntry *Prev;
  27.  
  28.     char Name[40];
  29.  
  30.     char Init[40];
  31.     char Zero[40];
  32.     char One[40];
  33.     char Two[40];
  34.     char Three[40];
  35.  
  36.     SHORT Size;
  37.     SHORT Rate;
  38.     SHORT AngleStart;
  39.     SHORT AngleEnd;
  40.     SHORT Generations;
  41.     };
  42.  
  43. /************************/
  44. /* PROTOTYPES        */
  45. /************************/
  46.  
  47. void main();
  48. void wbmain();
  49. void CloseAll(__A0 char *, __A1 char *);
  50.  
  51. void ClearWindow();
  52. void DrawMainMenu();
  53. void RedrawLibList();
  54. void TreeGrow();
  55.  
  56. void CorrectString(__A0 char *);
  57.  
  58. void SingleGadgetRefresh(__A0 struct Gadget *, __A1 struct Window *);
  59. void DrawFrame(__A0 struct RastPort *, __D0 SHORT, __D1 SHORT, __D2 SHORT, __D3 SHORT);
  60. void PrintAt(__A0 struct RastPort *, __D0 SHORT, __D1 SHORT, __D2 SHORT, __A1 char *);
  61. void ScrollPrint(__D0 SHORT, __D1 SHORT, __A0 char *);
  62.  
  63. /************************/
  64. /* GLOBALS        */
  65. /************************/
  66.  
  67. /*************** Graphics ****************/
  68.  
  69. #include "TreeGrowGfx.h"
  70.  
  71. struct Image *Leaf[4] =
  72.     {
  73.     &Leaf1Image, &Leaf2Image, &Leaf3Image, &Leaf4Image
  74.     };
  75.  
  76. struct Image *Red[4] =
  77.     {
  78.     &Red1Image, &Red2Image, &Red3Image, &Red4Image
  79.     };
  80.  
  81. struct Image *Yellow[4] =
  82.     {
  83.     &Yellow1Image, &Yellow2Image, &Yellow3Image, &Yellow4Image
  84.     };
  85.  
  86. USHORT ColorDef[] =
  87.     {
  88.     0x000, 0xb70, 0x960, 0x0a0, 0x080, 0xf20, 0x800, 0xfd0
  89.     };
  90.  
  91. /*************** Gadgets ****************/
  92.  
  93. #include "TreeGrowGadgets.h"
  94.  
  95. /*************** FileRequester ****************/
  96.  
  97. char DirName[DSIZE+1];
  98. char FileName[FCHARS+1];
  99. char PathName[DSIZE+FCHARS+2];
  100.  
  101. struct ReqFileRequester ReqFileRequester =
  102.     {
  103.     REQVERSION,
  104.     "Save IFF-Picture",
  105.     DirName,
  106.     FileName,
  107.     PathName,
  108.  
  109.     NULL,
  110.  
  111.     0,
  112.     10, 30, 20,
  113.     FRQSHOWINFOM | FRQINFOGADGETM | FRQSAVINGM,
  114.     3, 1, 1, 0, 0,
  115.     0, 1,
  116.     1, 1, 3, 3, 3, 3,
  117.  
  118.     { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
  119.     { 0, 0, 0 },
  120.  
  121.     0, 0,
  122.     0, 0,
  123.  
  124.     NULL,
  125.     NULL,
  126.     NULL,
  127.     0, 0, 0, 0, 0, 0, 0, 0,
  128.  
  129.     NULL, NULL, NULL,
  130.     NULL,
  131.     NULL,
  132.     0, 0, 0, 0
  133.     };
  134.  
  135. /*************** ControlWindow ****************/
  136.  
  137. struct NewWindow ControlWindowDef =
  138.     {
  139.     155, 46, 365, 170,
  140.     0, 1,
  141.     GADGETUP | CLOSEWINDOW | MOUSEBUTTONS,
  142.     WINDOWCLOSE | WINDOWDRAG | WINDOWDEPTH | SMART_REFRESH | NOCAREREFRESH | RMBTRAP | ACTIVATE,
  143.     NULL,
  144.     NULL,
  145.     "TreeGrow V1.0",
  146.     NULL,
  147.     NULL,
  148.     0, 0, 0, 0,
  149.     WBENCHSCREEN
  150.     };
  151.  
  152. struct Window *ControlWindow = NULL;
  153. struct RastPort *conrp;
  154.  
  155. /*************** DrawWindow ****************/
  156.  
  157. struct NewWindow DrawWindowDef =
  158.     {
  159.     0, 0, 640, 512,
  160.     0, 1,
  161.     MOUSEBUTTONS,
  162.     BORDERLESS | SMART_REFRESH | NOCAREREFRESH | RMBTRAP | ACTIVATE,
  163.     NULL,
  164.     NULL,
  165.     NULL,
  166.     NULL,
  167.     NULL,
  168.     0, 0, 0, 0,
  169.     CUSTOMSCREEN
  170.     };
  171.  
  172. struct Window *DrawWindow = NULL;
  173. struct RastPort *drawrp;
  174.  
  175. /*************** DrawScreen ****************/
  176.  
  177. struct NewScreen DrawScreenDef =
  178.     {
  179.     0, 0, 640, 512,
  180.     3,
  181.     0, 1,
  182.     HIRES | LACE,
  183.     CUSTOMSCREEN,
  184.     NULL,
  185.     "TreeGrow V1.0",
  186.     NULL,
  187.     NULL
  188.     };
  189.  
  190. struct Screen *DrawScreen = NULL;
  191.  
  192. /*************** Parameters ****************/
  193.  
  194. SHORT Size = 20;
  195. SHORT Rate = 95;
  196. SHORT AngleStart = 5;
  197. SHORT AngleEnd = 20;
  198. SHORT Generations = 3;
  199.  
  200. /*************** Misc ****************/
  201.  
  202. struct LibEntry *FirstLibEntry = NULL;
  203. struct LibEntry *ActLibEntry = NULL;
  204.  
  205. struct Library *ILBMBase = NULL;
  206. struct Library *ReqBase = NULL;
  207.  
  208. char Buffer[256];
  209.  
  210. /************************/
  211. /* main()               */
  212. /************************/
  213.  
  214. void wbmain(struct WBStartup *wbenchmsg)
  215.     {
  216.     CurrentDir(wbenchmsg->sm_ArgList->wa_Lock);
  217.  
  218.     main();
  219.     }
  220.  
  221. void main()
  222.     {
  223.     /*************/
  224.     /* open libs */
  225.     /*************/
  226.  
  227.     ILBMBase = (struct Library *)OpenLibrary("ilbm.library", 0);
  228.     if ( ILBMBase == NULL )
  229.         CloseAll("no ilbm.library", "Use InstallLibs !");
  230.  
  231.     ReqBase = (struct Library *)OpenLibrary("req.library", 0);
  232.     if ( ReqBase == NULL )
  233.         CloseAll("no req.library", "Use InstallLibs !");
  234.  
  235.     /***********************/
  236.     /* open control window */
  237.     /***********************/
  238.  
  239.     ControlWindow = (struct Window *)OpenWindow(&ControlWindowDef);
  240.     if ( ControlWindow == NULL )
  241.         CloseAll("can't open window", "Free some memory !");
  242.  
  243.     ReqFileRequester.Window = ControlWindow;
  244.  
  245.     conrp = ControlWindow->RPort;
  246.  
  247.     /****************/
  248.     /* load library */
  249.     /****************/
  250.         {
  251.         FILE *file;
  252.  
  253.         file = fopen("TreeGrow.lib", "r");
  254.         if ( file )
  255.             {
  256.             struct LibEntry entry;
  257.             struct LibEntry *new, *last = NULL;
  258.             SHORT i;
  259.  
  260.             do  {
  261.                 i = fread(&entry, sizeof(struct LibEntry), 1, file);
  262.                 if ( i == 1 )
  263.                     {
  264.                     new = malloc(sizeof(struct LibEntry));
  265.                     if ( new )
  266.                         {
  267.                         memmove(new, &entry, sizeof(struct LibEntry));
  268.  
  269.                         if ( last == NULL )
  270.                             {
  271.                             FirstLibEntry = new;
  272.                             new->Prev = NULL;
  273.                             }
  274.                         else
  275.                             {
  276.                             last->Next = new;
  277.                             new->Prev = last;
  278.                             }
  279.  
  280.                         new->Next = NULL;
  281.                         last = new;
  282.                         }
  283.                     else
  284.                         {
  285.                         fclose(file);
  286.                         CloseAll("no memory for new library entry", "Free some memory !");
  287.                         }
  288.                     }
  289.                 } while ( i == 1 );
  290.  
  291.             fclose(file);
  292.  
  293.             ActLibEntry = FirstLibEntry;
  294.             }
  295.         }
  296.  
  297.     DrawMainMenu();
  298.  
  299.     while ( TRUE )
  300.         {
  301.         struct IntuiMessage *msg;
  302.  
  303.         Wait(1 << ControlWindow->UserPort->mp_SigBit );
  304.  
  305.         while ( msg = (struct IntuiMessage *)GetMsg(ControlWindow->UserPort) )
  306.             {
  307.             ULONG class = msg->Class;
  308.             struct Gadget *iaddr = msg->IAddress;
  309.  
  310.             ReplyMsg(msg);
  311.  
  312.             switch ( class )
  313.                 {
  314.                 case CLOSEWINDOW :
  315.                     CloseAll(NULL, NULL);
  316.  
  317.                 case GADGETUP :
  318.                     switch ( iaddr->GadgetID )
  319.                     {
  320.                         case 1 :
  321.                         /********/
  322.                         /* Init */
  323.                         /********/
  324.  
  325.                         CorrectString(Init_Buffer);
  326.                         if ( strlen(Init_Buffer) == 0 )
  327.                             strcpy(Init_Buffer, "01");
  328.  
  329.                         SingleGadgetRefresh(&Init_Gadget, ControlWindow);
  330.  
  331.                         ActivateGadget(&Zero_Gadget, ControlWindow, NULL);
  332.  
  333.                         break;
  334.  
  335.                         case 2 :
  336.                         /********/
  337.                         /* Zero */
  338.                         /********/
  339.  
  340.                         CorrectString(Zero_Buffer);
  341.                         if ( strlen(Zero_Buffer) == 0 )
  342.                             strcpy(Zero_Buffer, "0");
  343.  
  344.                         SingleGadgetRefresh(&Zero_Gadget, ControlWindow);
  345.  
  346.                         ActivateGadget(&One_Gadget, ControlWindow, NULL);
  347.  
  348.                         break;
  349.  
  350.                         case 3 :
  351.                         /*******/
  352.                         /* One */
  353.                         /*******/
  354.  
  355.                         CorrectString(One_Buffer);
  356.                         if ( strlen(One_Buffer) == 0 )
  357.                             strcpy(One_Buffer, "1");
  358.  
  359.                         SingleGadgetRefresh(&One_Gadget, ControlWindow);
  360.  
  361.                         ActivateGadget(&Two_Gadget, ControlWindow, NULL);
  362.  
  363.                         break;
  364.  
  365.                         case 4 :
  366.                         /*******/
  367.                         /* Two */
  368.                         /*******/
  369.  
  370.                         CorrectString(Two_Buffer);
  371.                         if ( strlen(Two_Buffer) == 0 )
  372.                             strcpy(Two_Buffer, "2");
  373.  
  374.                         SingleGadgetRefresh(&Two_Gadget, ControlWindow);
  375.  
  376.                         ActivateGadget(&Three_Gadget, ControlWindow, NULL);
  377.  
  378.                         break;
  379.  
  380.                         case 5 :
  381.                         /*********/
  382.                         /* Three */
  383.                         /*********/
  384.  
  385.                         CorrectString(Three_Buffer);
  386.                         if ( strlen(Three_Buffer) == 0 )
  387.                             strcpy(Three_Buffer, "3");
  388.  
  389.                         SingleGadgetRefresh(&Three_Gadget, ControlWindow);
  390.  
  391.                         ActivateGadget(&Size_Gadget, ControlWindow, NULL);
  392.  
  393.                         break;
  394.  
  395.                         case 6 :
  396.                         /********/
  397.                         /* Size */
  398.                         /********/
  399.  
  400.                         Size = atoi(Size_Buffer);
  401.  
  402.                         if ( Size < 5 )
  403.                             Size = 5;
  404.                         else if ( Size > 100 )
  405.                             Size = 100;
  406.  
  407.                         sprintf(Size_Buffer, "%u", Size);
  408.  
  409.                         SingleGadgetRefresh(&Size_Gadget, ControlWindow);
  410.  
  411.                         ActivateGadget(&Rate_Gadget, ControlWindow, NULL);
  412.  
  413.                         break;
  414.  
  415.                         case 18 :
  416.                         /********/
  417.                         /* rate */
  418.                         /********/
  419.  
  420.                         Rate = atoi(Rate_Buffer);
  421.  
  422.                         if ( Rate < 1 )
  423.                             Rate = 1;
  424.                         else if ( Rate > 100 )
  425.                             Rate = 100;
  426.  
  427.                         sprintf(Rate_Buffer, "%u", Rate);
  428.  
  429.                         SingleGadgetRefresh(&Rate_Gadget, ControlWindow);
  430.  
  431.                         ActivateGadget(&AngleStart_Gadget, ControlWindow, NULL);
  432.  
  433.                         break;
  434.  
  435.                         case 7 :
  436.                         /**************/
  437.                         /* AngleStart */
  438.                         /**************/
  439.  
  440.                         AngleStart = atoi(AngleStart_Buffer);
  441.  
  442.                         if ( AngleStart < -180 )
  443.                             AngleStart = -180;
  444.                         else if ( AngleStart > 180 )
  445.                             AngleStart = 180;
  446.  
  447.                         if ( AngleStart >= AngleEnd)
  448.                             {
  449.                             AngleEnd = AngleStart + 10;
  450.                             sprintf(AngleEnd_Buffer, "%d", AngleEnd);
  451.  
  452.                             SingleGadgetRefresh(&AngleEnd_Gadget, ControlWindow);
  453.                             }
  454.  
  455.                         sprintf(AngleStart_Buffer, "%d", AngleStart);
  456.  
  457.                         SingleGadgetRefresh(&AngleStart_Gadget, ControlWindow);
  458.  
  459.                         ActivateGadget(&AngleEnd_Gadget, ControlWindow, NULL);
  460.  
  461.                         break;
  462.  
  463.                         case 8 :
  464.                         /************/
  465.                         /* AngleEnd */
  466.                         /************/
  467.  
  468.                         AngleEnd = atoi(AngleEnd_Buffer);
  469.  
  470.                         if ( AngleEnd < -180 )
  471.                             AngleEnd = -180;
  472.                         else if ( AngleEnd > 180 )
  473.                             AngleEnd = 180;
  474.  
  475.                         if ( AngleStart >= AngleEnd)
  476.                             {
  477.                             AngleStart = AngleEnd - 10;
  478.                             sprintf(AngleStart_Buffer, "%d", AngleStart);
  479.  
  480.                             SingleGadgetRefresh(&AngleStart_Gadget, ControlWindow);
  481.                             }
  482.  
  483.                         sprintf(AngleEnd_Buffer, "%d", AngleEnd);
  484.  
  485.                         SingleGadgetRefresh(&AngleEnd_Gadget, ControlWindow);
  486.  
  487.                         ActivateGadget(&Generations_Gadget, ControlWindow, NULL);
  488.  
  489.                         break;
  490.  
  491.                         case 9 :
  492.                         /***************/
  493.                         /* Generations */
  494.                         /***************/
  495.  
  496.                         Generations = atoi(Generations_Buffer);
  497.  
  498.                         if ( Generations < 1 )
  499.                             Generations = 1;
  500.                         else if ( Generations > 50 )
  501.                             Generations = 50;
  502.  
  503.                         sprintf(Generations_Buffer, "%u", Generations);
  504.  
  505.                         SingleGadgetRefresh(&Generations_Gadget, ControlWindow);
  506.  
  507.                         ActivateGadget(&Name_Gadget, ControlWindow, NULL);
  508.  
  509.                         break;
  510.  
  511.                         case 10 :
  512.                         /********/
  513.                         /* Name */
  514.                         /********/
  515.  
  516.                         ActivateGadget(&Init_Gadget, ControlWindow, NULL);
  517.  
  518.                         break;
  519.  
  520.                         case 11 :
  521.                         /********/
  522.                         /* Save */
  523.                         /********/
  524.                             {
  525.                             FILE *file;
  526.  
  527.                             file = fopen("TreeGrow.lib", "w");
  528.                             if ( file )
  529.                                 {
  530.                                 struct LibEntry *scan;
  531.  
  532.                                 for ( scan = FirstLibEntry ; scan ; scan = scan->Next )
  533.                                     fwrite(scan, sizeof(struct LibEntry), 1, file);
  534.  
  535.                                 fclose(file);
  536.                                 }
  537.                             else
  538.                                 {
  539.                                 SetWindowTitles(ControlWindow, "Can't open file.", -1);
  540.                                 DisplayBeep(NULL);
  541.                                 }
  542.  
  543.                             SetWindowTitles(ControlWindow, "Library saved.", -1);
  544.                             }
  545.                         break;
  546.  
  547.                         case 12 :
  548.                         /*******/
  549.                         /* Add */
  550.                         /*******/
  551.                             {
  552.                             struct LibEntry *new, *scan;
  553.  
  554.                             scan = FirstLibEntry;
  555.  
  556.                             while ( stricmp(scan->Name, Name_Buffer) && scan)
  557.                                 scan = scan->Next;
  558.  
  559.                             if ( scan )
  560.                                 {
  561.                                 strcpy(scan->Name, Name_Buffer);
  562.                                 strcpy(scan->Init, Init_Buffer);
  563.                                 strcpy(scan->Zero, Zero_Buffer);
  564.                                 strcpy(scan->One, One_Buffer);
  565.                                 strcpy(scan->Two, Two_Buffer);
  566.                                 strcpy(scan->Three, Three_Buffer);
  567.                                 scan->Size = Size;
  568.                                 scan->Rate = Rate;
  569.                                 scan->AngleStart = AngleStart;
  570.                                 scan->AngleEnd = AngleEnd;
  571.                                 scan->Generations = Generations;
  572.  
  573.                                 ActLibEntry = scan;
  574.                                 RedrawLibList();
  575.                                 }
  576.                             else
  577.                                 {
  578.                                 new = malloc(sizeof(struct LibEntry));
  579.                                 if ( new )
  580.                                     {
  581.                                     strcpy(new->Name, Name_Buffer);
  582.                                     strcpy(new->Init, Init_Buffer);
  583.                                     strcpy(new->Zero, Zero_Buffer);
  584.                                     strcpy(new->One, One_Buffer);
  585.                                     strcpy(new->Two, Two_Buffer);
  586.                                     strcpy(new->Three, Three_Buffer);
  587.                                     new->Size = Size;
  588.                                     new->Rate = Rate;
  589.                                     new->AngleStart = AngleStart;
  590.                                     new->AngleEnd = AngleEnd;
  591.                                     new->Generations = Generations;
  592.  
  593.                                     if ( FirstLibEntry == NULL )
  594.                                         {
  595.                                         FirstLibEntry = new;
  596.  
  597.                                         new->Prev = NULL;
  598.                                         new->Next = NULL;
  599.                                         }
  600.                                     else
  601.                                         {
  602.                                         scan = FirstLibEntry;
  603.  
  604.                                         while ( (stricmp(scan->Name, Name_Buffer) < 0) && scan )
  605.                                             scan = scan->Next;
  606.  
  607.                                         if ( scan == NULL )
  608.                                             {
  609.                                             scan = FirstLibEntry;
  610.  
  611.                                             while ( scan->Next )
  612.                                                 scan = scan->Next;
  613.  
  614.                                             scan->Next = new;
  615.                                             new->Prev = scan;
  616.                                             new->Next = NULL;
  617.                                             }
  618.                                         else if ( scan == FirstLibEntry )
  619.                                             {
  620.                                             new->Next = scan;
  621.                                             new->Prev = NULL;
  622.                                             FirstLibEntry = new;
  623.                                             scan->Prev = new;
  624.                                             }
  625.                                         else
  626.                                             {
  627.                                             scan->Prev->Next = new;
  628.                                             new->Prev = scan->Prev;
  629.                                             new->Next = scan;
  630.                                             scan->Prev = new;
  631.                                             }
  632.                                         }
  633.  
  634.                                     ActLibEntry = new;
  635.                                     RedrawLibList();
  636.                                     }
  637.                                 else
  638.                                     {
  639.                                     SetWindowTitles(ControlWindow, "No memory for new entry.", -1);
  640.                                     DisplayBeep(NULL);
  641.                                     }
  642.                                 }
  643.                             }
  644.  
  645.                         break;
  646.  
  647.                         case 13 :
  648.                         /*******/
  649.                         /* Del */
  650.                         /*******/
  651.  
  652.                         if ( ActLibEntry )
  653.                             {
  654.                             struct LibEntry *entry = ActLibEntry;
  655.  
  656.                             ActLibEntry = entry->Prev;
  657.                             if ( ActLibEntry == NULL )
  658.                                 ActLibEntry = entry->Next;
  659.  
  660.                             if ( entry->Next )
  661.                                 entry->Next->Prev = entry->Prev;
  662.  
  663.                             if ( entry->Prev )
  664.                                 entry->Prev->Next = entry->Next;
  665.                             else
  666.                                 {
  667.                                 FirstLibEntry = entry->Next;
  668.                                 if ( FirstLibEntry )
  669.                                     FirstLibEntry->Prev = NULL;
  670.                                 }
  671.  
  672.                             free(entry);
  673.  
  674.                             RedrawLibList();
  675.                             }
  676.                         break;
  677.  
  678.                         case 14 :
  679.                         /*******/
  680.                         /* Use */
  681.                         /*******/
  682.  
  683.                         if ( ActLibEntry )
  684.                             {
  685.                             strcpy(Name_Buffer, ActLibEntry->Name);
  686.                             strcpy(Init_Buffer, ActLibEntry->Init);
  687.                             strcpy(Zero_Buffer, ActLibEntry->Zero);
  688.                             strcpy(One_Buffer, ActLibEntry->One);
  689.                             strcpy(Two_Buffer, ActLibEntry->Two);
  690.                             strcpy(Three_Buffer, ActLibEntry->Three);
  691.  
  692.                             Size = ActLibEntry->Size;
  693.                             Rate = ActLibEntry->Rate;
  694.                             AngleStart = ActLibEntry->AngleStart;
  695.                             AngleEnd = ActLibEntry->AngleEnd;
  696.                             Generations = ActLibEntry->Generations;
  697.  
  698.                             sprintf(Size_Buffer, "%u", Size);
  699.                             sprintf(Rate_Buffer, "%u", Rate);
  700.                             sprintf(AngleStart_Buffer, "%d", AngleStart);
  701.                             sprintf(AngleEnd_Buffer, "%d", AngleEnd);
  702.                             sprintf(Generations_Buffer, "%u", Generations);
  703.  
  704.                             RefreshGadgets(&Init_Gadget, ControlWindow, NULL);
  705.                             }
  706.                         break;
  707.  
  708.                         case 15 :
  709.                         /******/
  710.                         /* Up */
  711.                         /******/
  712.  
  713.                         if ( ActLibEntry->Prev )
  714.                             ActLibEntry = ActLibEntry->Prev;
  715.  
  716.                         RedrawLibList();
  717.                         break;
  718.  
  719.                         case 16 :
  720.                         /********/
  721.                         /* Down */
  722.                         /********/
  723.  
  724.                         if ( ActLibEntry->Next )
  725.                             ActLibEntry = ActLibEntry->Next;
  726.  
  727.                         RedrawLibList();
  728.                         break;
  729.  
  730.                         case 17 :
  731.                         /*********/
  732.                         /* Start */
  733.                         /*********/
  734.                             {
  735.                             BOOL bool = TRUE;
  736.  
  737.                             ClearWindow();
  738.  
  739.                             TreeGrow();
  740.  
  741.                             ScrollPrint(2, 10, "Press mousebutton to continue.");
  742.  
  743.                             while ( bool )
  744.                                 {
  745.                                 Wait(1 << ControlWindow->UserPort->mp_SigBit );
  746.  
  747.                                 while ( msg = (struct IntuiMessage *)GetMsg(ControlWindow->UserPort) )
  748.                                     {
  749.                                     if ( (msg->Class == MOUSEBUTTONS) && (msg->Code == SELECTUP) )
  750.                                         bool = FALSE;
  751.  
  752.                                     ReplyMsg(msg);
  753.                                     }
  754.                                 }
  755.  
  756.                             DrawMainMenu();
  757.                             }
  758.                         break;
  759.  
  760.                         case 19 :
  761.                         /********/
  762.                         /* Save */
  763.                         /********/
  764.  
  765.                         if ( DrawWindow )
  766.                             {
  767.                             if ( FileRequester(&ReqFileRequester) )
  768.                                 {
  769.                                 ScreenToFront(DrawScreen);
  770.  
  771.                                 if ( SaveWindowToIFF(PathName, DrawWindow) < 0 )
  772.                                     {
  773.                                     SetWindowTitles(ControlWindow, "Error writing file.", -1);
  774.                                     DisplayBeep(NULL);
  775.                                     }
  776.                                 else
  777.                                     {
  778.                                     SetWindowTitles(ControlWindow, "Picture saved.", -1);
  779.                                     DisplayBeep(NULL);
  780.                                     }
  781.  
  782.                                 WBenchToFront();
  783.                                 }
  784.                             }
  785.                         else
  786.                             {
  787.                             SetWindowTitles(ControlWindow, "There's no tree to save..", -1);
  788.                             DisplayBeep(NULL);
  789.                             }
  790.                         break;
  791.                     }
  792.                     break;
  793.                 }
  794.             }
  795.         }
  796.     }
  797.  
  798. /************************/
  799. /* CloseAll()           */
  800. /************************/
  801.  
  802. void CloseAll(__A0 char *text1, __A1 char *text2)
  803.     {
  804.     if ( text1 )
  805.         {
  806.         char String[256];
  807.         SHORT x1, x2, i, j;
  808.  
  809.         sprintf(String, "xxyTreeGrow says : %s0Txxy%s0F", text1, text2);
  810.         x1 = 320 - ( (strlen(text1) + 16) << 2 );
  811.         x2 = 320 - ( strlen(text2)  << 2 );
  812.         i = 19 + strlen(text1);
  813.         j = i + 5 + strlen(text2);
  814.  
  815.         String[0] = (char)(x1 >> 8);
  816.         String[1] = (char)(x1 & 0xFF);
  817.         String[2] = 23;
  818.         String[i] = 0;
  819.         String[i+1] = TRUE;
  820.         String[i+2] = (char)(x2 >> 8);
  821.         String[i+3] = (char)(x2 & 0xFF);
  822.         String[i+4] = 31;
  823.         String[j] = 0;
  824.         String[j] = FALSE;
  825.  
  826.         DisplayAlert(RECOVERY_ALERT, String, 50);
  827.         }
  828.  
  829.     if ( DrawWindow ) CloseWindow(DrawWindow);
  830.     if ( DrawScreen ) CloseScreen(DrawScreen);
  831.     if ( ControlWindow ) CloseWindow(ControlWindow);
  832.  
  833.     if ( ILBMBase ) CloseLibrary(ILBMBase);
  834.     if ( ReqBase ) CloseLibrary(ReqBase);
  835.  
  836.     /* free library */
  837.         {
  838.         struct LibEntry *scan, *next;
  839.  
  840.         for ( scan = FirstLibEntry ; scan ; scan = next )
  841.             {
  842.             next = scan->Next;
  843.  
  844.             free(scan);
  845.             }
  846.         }
  847.  
  848.     exit(0);
  849.     }
  850.  
  851. /************************/
  852. /* ClearWindow()        */
  853. /************************/
  854.  
  855. void ClearWindow()
  856.     {
  857.     ControlWindow->FirstGadget = Start_Gadget.NextGadget;
  858.     Start_Gadget.NextGadget = NULL;
  859.  
  860.     SetAPen(conrp, 0);
  861.     RectFill(conrp, 2, 10, 362, 168);
  862.     }
  863.  
  864. /************************/
  865. /* DrawMainMenu()       */
  866. /************************/
  867.  
  868. void DrawMainMenu()
  869.     {
  870.     SetAPen(conrp, 0);
  871.     RectFill(conrp, 2, 10, 362, 168);
  872.  
  873.     Start_Gadget.NextGadget = ControlWindow->FirstGadget;
  874.     ControlWindow->FirstGadget = &Init_Gadget;
  875.  
  876.     RefreshGadgets(&Init_Gadget, ControlWindow, NULL);
  877.  
  878.     DrawFrame(conrp, 70, 11, 277, 22); /*init*/
  879.     DrawFrame(conrp, 46, 23, 277, 34); /*zero*/
  880.     DrawFrame(conrp, 46, 35, 277, 46); /*one*/
  881.     DrawFrame(conrp, 46, 47, 277, 58); /*two*/
  882.     DrawFrame(conrp, 46, 59, 277, 70); /*three*/
  883.     DrawFrame(conrp, 117, 71, 164, 82); /*size*/
  884.     DrawFrame(conrp, 230, 71, 277, 82); /*rate*/
  885.     DrawFrame(conrp, 117, 83, 164, 94); /*anglestart*/
  886.     DrawFrame(conrp, 187, 83, 234, 94); /*angleend*/
  887.     DrawFrame(conrp, 117, 95, 164, 106); /*generations*/
  888.     DrawFrame(conrp, 62, 112, 277, 123); /*name*/
  889.     DrawFrame(conrp, 10, 124, 73, 135); /*save*/
  890.     DrawFrame(conrp, 80, 124, 143, 135); /*add*/
  891.     DrawFrame(conrp, 150, 124, 213, 135); /*del*/
  892.     DrawFrame(conrp, 220, 124, 283, 135); /*use*/
  893.     DrawFrame(conrp, 10, 140, 25, 152); /*up*/
  894.     DrawFrame(conrp, 10, 153, 25, 165); /*down*/
  895.     DrawFrame(conrp, 280, 52, 359, 91); /*save*/
  896.     DrawFrame(conrp, 280, 11, 359, 50); /*start*/
  897.  
  898.     SetAPen(conrp, 1);
  899.     PrintAt(conrp, 70, 19, 1, "Init : ");
  900.     PrintAt(conrp, 46, 31, 1, "0 -> ");
  901.     PrintAt(conrp, 46, 43, 1, "1 -> ");
  902.     PrintAt(conrp, 46, 55, 1, "2 -> ");
  903.     PrintAt(conrp, 46, 67, 1, "3 -> ");
  904.     PrintAt(conrp, 117, 79, 1, "Size........: ");
  905.     PrintAt(conrp, 230, 79, 1, "Rate : ");
  906.     PrintAt(conrp, 117, 91, 1, "Angle.......: ");
  907.     PrintAt(conrp, 175, 91, 0, "to");
  908.     PrintAt(conrp, 117, 103, 1, "Generations.: ");
  909.     PrintAt(conrp, 62, 120, 1, "Name : ");
  910.     PrintAt(conrp, 42, 132, 0, "Save");
  911.     PrintAt(conrp, 112, 132, 0, "Add");
  912.     PrintAt(conrp, 182, 132, 0, "Del");
  913.     PrintAt(conrp, 252, 132, 0, "Use");
  914.     PrintAt(conrp, 320, 74, 0, "Save");
  915.     PrintAt(conrp, 320, 33, 0, "Start");
  916.  
  917.     Move(conrp, 2, 109);
  918.     Draw(conrp, 362, 109);
  919.  
  920.     RedrawLibList();
  921.     };
  922.  
  923. /************************/
  924. /* RedrawLibList()      */
  925. /************************/
  926.  
  927. void RedrawLibList()
  928.     {
  929.     SetAPen(conrp, 0);
  930.     RectFill(conrp, 30, 141, 362, 164);
  931.  
  932.     if ( ActLibEntry )
  933.         {
  934.         SetAPen(conrp, 1);
  935.         PrintAt(conrp, 30, 155, -1, ActLibEntry->Name);
  936.  
  937.         SetAPen(conrp, 2);
  938.         if ( ActLibEntry->Prev )
  939.             PrintAt(conrp, 30, 147, -1, ActLibEntry->Prev->Name);
  940.  
  941.         if ( ActLibEntry->Next )
  942.             PrintAt(conrp, 30, 163, -1, ActLibEntry->Next->Name);
  943.         }
  944.     }
  945.  
  946. /************************/
  947. /* CorrectString()      */
  948. /************************/
  949.  
  950. void CorrectString(__A0 char *string)
  951.     {
  952.     char *s = string;
  953.     SHORT i = 0;
  954.  
  955.     while ( *s )
  956.         {
  957.         switch ( *s )
  958.             {
  959.             case '0' :
  960.             case '1' :
  961.             case '2' :
  962.             case '3' :
  963.             case '\\' :
  964.             case '/' :
  965.             case '[' :
  966.             case ']' :
  967.                 Buffer[i] = *s;
  968.                 i++;
  969.                 break;
  970.             }
  971.  
  972.         s++;
  973.         }
  974.  
  975.     Buffer[i] = 0;
  976.  
  977.     strcpy(string, Buffer);
  978.     }
  979.  
  980. /*************************/
  981. /* SingleGadgetRefresh() */
  982. /*************************/
  983.  
  984. void SingleGadgetRefresh(__A0 struct Gadget *gad, __A1 struct Window *win)
  985.     {
  986.     struct Gadget *next;
  987.  
  988.     next = gad->NextGadget;
  989.     gad->NextGadget = NULL;
  990.  
  991.     RefreshGadgets(gad, win, NULL);
  992.  
  993.     gad->NextGadget = next;
  994.     }
  995.  
  996. /************************/
  997. /* DrawFrame()          */
  998. /************************/
  999.  
  1000. void DrawFrame(__A0 struct RastPort *rp, __D0 SHORT x1, __D1 SHORT y1, __D2 SHORT x2, __D3 SHORT y2)
  1001.     {
  1002.     SetAPen(rp, 1);
  1003.     Move(rp, x1, y1);
  1004.     Draw(rp, x1, y2);
  1005.     Draw(rp, x1+1, y2-1);
  1006.     Draw(rp, x1+1, y1);
  1007.     Draw(rp, x2-1, y1);
  1008.  
  1009.     SetAPen(rp, 2);
  1010.     Move(rp, x2, y2);
  1011.     Draw(rp, x2, y1);
  1012.     Draw(rp, x2-1, y1+1);
  1013.     Draw(rp, x2-1, y2);
  1014.     Draw(rp, x1+1, y2);
  1015.     }
  1016.  
  1017. /************************/
  1018. /* PrintAt()            */
  1019. /************************/
  1020.  
  1021. void PrintAt(__A0 struct RastPort *rp, __D0 SHORT x, __D1 SHORT y, __D2 SHORT m, __A1 char *text)
  1022.     {
  1023.     SHORT l = strlen(text);
  1024.     SHORT tl = TextLength(rp, text, l);
  1025.  
  1026.     switch ( m )
  1027.         {
  1028.         case 0 :
  1029.             x -= tl/2;
  1030.             break;
  1031.         case 1 :
  1032.             x -= tl;
  1033.             break;
  1034.         }
  1035.  
  1036.     Move(rp, x, y);
  1037.     Text(rp, text, l);
  1038.     }
  1039.  
  1040. /************************/
  1041. /* ScrollPrint()        */
  1042. /************************/
  1043.  
  1044. void ScrollPrint(__D0 SHORT c, __D1 SHORT x, __A0 char *text)
  1045.     {
  1046.     ScrollRaster(conrp, 0, 8, 2, 10, 327, 168);
  1047.  
  1048.     SetAPen(conrp, c);
  1049.     Move(conrp, x, 160);
  1050.     Text(conrp, text, strlen(text));
  1051.     }
  1052.  
  1053. /************************/
  1054. /* TreeGrow()           */
  1055. /************************/
  1056.  
  1057. void TreeGrow()
  1058.     {
  1059.     char *source;
  1060.     struct Memory *mem;
  1061.  
  1062.     /****************/
  1063.     /* alloc memory */
  1064.     /****************/
  1065.         {
  1066.         mem = malloc(5000 * sizeof(struct Memory));
  1067.         if ( mem == NULL )
  1068.             {
  1069.             ScrollPrint(3, 10, "Ran out of memory.");
  1070.             return();
  1071.             }
  1072.         }
  1073.  
  1074.     /*****************/
  1075.     /* generate tree */
  1076.     /*****************/
  1077.         {
  1078.         char *dest;
  1079.         SHORT gen = 1;
  1080.         LONG size;
  1081.         LONG zero = strlen(Zero_Buffer);
  1082.         LONG one = strlen(One_Buffer);
  1083.         LONG two = strlen(Two_Buffer);
  1084.         LONG three = strlen(Three_Buffer);
  1085.  
  1086.         source = malloc(strlen(Init_Buffer)+1);
  1087.         if ( source == NULL )
  1088.             {
  1089.             ScrollPrint(3, 10, "Ran out of memory.");
  1090.             return();
  1091.             }
  1092.  
  1093.         strcpy(source, Init_Buffer);
  1094.  
  1095.         while ( gen <= Generations )
  1096.             {
  1097.             char *scan, *next;
  1098.  
  1099.             size = 0;
  1100.  
  1101.             for ( scan = source ; *scan ; scan++ )
  1102.                 switch ( *scan )
  1103.                 {
  1104.                     case '0' :
  1105.                     size += zero;
  1106.                     break;
  1107.                     case '1' :
  1108.                     size += one;
  1109.                     break;
  1110.                     case '2' :
  1111.                     size += two;
  1112.                     break;
  1113.                     case '3' :
  1114.                     size += three;
  1115.                     break;
  1116.                     case '\\' :
  1117.                     case '/' :
  1118.                     case '[' :
  1119.                     case ']' :
  1120.                     size++;
  1121.                     break;
  1122.                     default :
  1123.                     ScrollPrint(3, 10, "Error in source string.");
  1124.                     return();
  1125.                 }
  1126.  
  1127.             sprintf(Buffer, "% 2u. Generation : % 7u chars", gen, size);
  1128.             ScrollPrint(1, 10, Buffer);
  1129.  
  1130.             dest = malloc(size + 1);
  1131.             if ( dest == NULL )
  1132.                 {
  1133.                 ScrollPrint(3, 10, "Ran out of memory.");
  1134.                 return();
  1135.                 }
  1136.  
  1137.             next = dest;
  1138.  
  1139.             for ( scan = source ; *scan ; scan++ )
  1140.                 switch ( *scan )
  1141.                 {
  1142.                     case '0' :
  1143.                     strcpy(next, Zero_Buffer);
  1144.                     next += zero;
  1145.                     break;
  1146.                     case '1' :
  1147.                     strcpy(next, One_Buffer);
  1148.                     next += one;
  1149.                     break;
  1150.                     case '2' :
  1151.                     strcpy(next, Two_Buffer);
  1152.                     next += two;
  1153.                     break;
  1154.                     case '3' :
  1155.                     strcpy(next, Three_Buffer);
  1156.                     next += three;
  1157.                     break;
  1158.                     case '\\' :
  1159.                     *next = '\\';
  1160.                     next++;
  1161.                     break;
  1162.                     case '/' :
  1163.                     *next = '/';
  1164.                     next++;
  1165.                     break;
  1166.                     case '[' :
  1167.                     *next = '[';
  1168.                     next++;
  1169.                     break;
  1170.                     case ']' :
  1171.                     *next = ']';
  1172.                     next++;
  1173.                     break;
  1174.                     default :
  1175.                     ScrollPrint(3, 10, "Error in source string.");
  1176.                     return();
  1177.                 }
  1178.  
  1179.             *next = 0;
  1180.  
  1181.             free(source);
  1182.             source = dest;
  1183.             dest = NULL;
  1184.  
  1185.             gen++;
  1186.             }
  1187.  
  1188.         ScrollPrint(1, 10, "Generation completed.");
  1189.         }
  1190.  
  1191.     /*************/
  1192.     /* draw tree */
  1193.     /*************/
  1194.         {
  1195.         BOOL bool = TRUE;
  1196.         SHORT actmem = -1;
  1197.         SHORT AngleDiff = AngleEnd - AngleStart;
  1198.  
  1199.         float x = 320, y = 510;
  1200.         float angle = 90;
  1201.         float size = (float)Size;
  1202.         float rate = (float)Rate/100;
  1203.         char *scan;
  1204.  
  1205.         ScrollPrint(1, 10, "Drawing..");
  1206.  
  1207.         if ( DrawWindow ) CloseWindow(DrawWindow);
  1208.         if ( DrawScreen ) CloseScreen(DrawScreen);
  1209.         DrawWindow = NULL;
  1210.         DrawScreen = NULL;
  1211.  
  1212.         DrawScreen = (struct Screen *)OpenScreen(&DrawScreenDef);
  1213.         if ( DrawScreen == NULL )
  1214.             {
  1215.             ScrollPrint(3, 10, "Can't open screen.");
  1216.             return();
  1217.             }
  1218.  
  1219.         LoadRGB4(&DrawScreen->ViewPort, ColorDef, 8);
  1220.  
  1221.         DrawWindowDef.Screen = DrawScreen;
  1222.  
  1223.         DrawWindow = (struct Window *)OpenWindow(&DrawWindowDef);
  1224.         if ( DrawWindow == NULL )
  1225.             {
  1226.             CloseScreen(DrawScreen);
  1227.             DrawScreen = NULL;
  1228.  
  1229.             ScrollPrint(3, 10, "Can't open window.");
  1230.             return();
  1231.             }
  1232.  
  1233.         drawrp = DrawWindow->RPort;
  1234.         Move(drawrp, (int)x, (int)y);
  1235.  
  1236.         for ( scan = source ; *scan && bool ; scan++ )
  1237.             {
  1238.             struct IntuiMessage *msg;
  1239.  
  1240.             while ( msg = (struct IntuiMessage *)GetMsg(DrawWindow->UserPort) )
  1241.                 {
  1242.                 if ( (msg->Class == MOUSEBUTTONS) && (msg->Code == MENUUP) )
  1243.                     bool = FALSE;
  1244.  
  1245.                 ReplyMsg(msg);
  1246.                 }
  1247.  
  1248.             switch ( *scan )
  1249.                 {
  1250.                 case '0' :
  1251.                     x += fcos(rad(angle)) * size;
  1252.                     y -= fsin(rad(angle)) * size;
  1253.                     size *= rate;
  1254.  
  1255.                     SetAPen(drawrp, (rand() & 1)+1);
  1256.                     Draw(drawrp, (int)x, (int)y);
  1257.                     break;
  1258.  
  1259.                 case '1' :
  1260.                     x += fcos(rad(angle)) * size;
  1261.                     y -= fsin(rad(angle)) * size;
  1262.                     size *= rate;
  1263.  
  1264.                     SetAPen(drawrp, (rand() & 1)+1);
  1265.                     Draw(drawrp, (int)x, (int)y);
  1266.  
  1267.                     DrawImage(drawrp, Leaf[rand() & 3], (int)x, (int)y);
  1268.                     break;
  1269.  
  1270.                 case '2' :
  1271.                     x += fcos(rad(angle)) * size;
  1272.                     y -= fsin(rad(angle)) * size;
  1273.                     size *= rate;
  1274.  
  1275.                     SetAPen(drawrp, (rand() & 1)+1);
  1276.                     Draw(drawrp, (int)x, (int)y);
  1277.  
  1278.                     DrawImage(drawrp, Red[rand() & 3], (int)x, (int)y);
  1279.                     break;
  1280.  
  1281.                 case '3' :
  1282.                     x += fcos(rad(angle)) * size;
  1283.                     y -= fsin(rad(angle)) * size;
  1284.                     size *= rate;
  1285.  
  1286.                     SetAPen(drawrp, (rand() & 1)+1);
  1287.                     Draw(drawrp, (int)x, (int)y);
  1288.  
  1289.                     DrawImage(drawrp, Yellow[rand() & 3], (int)x, (int)y);
  1290.                     break;
  1291.  
  1292.                 case '\\' :
  1293.                     {
  1294.                     actmem++;
  1295.  
  1296.                     if ( actmem >= 5000 )
  1297.                         {
  1298.                         CloseWindow(DrawWindow);
  1299.                         CloseScreen(DrawScreen);
  1300.                         DrawWindow = NULL;
  1301.                         DrawScreen = NULL;
  1302.  
  1303.                         ScrollPrint(3, 10, "More than 5000 branches.");
  1304.                         return();
  1305.                         }
  1306.  
  1307.                     struct Memory *m = mem + actmem*sizeof(struct Memory);
  1308.                     m->x = x;
  1309.                     m->y = y;
  1310.                     m->angle = angle;
  1311.                     m->size = size;
  1312.  
  1313.                     angle += (float)( AngleStart + (rand() % AngleDiff) );
  1314.                     }
  1315.                     break;
  1316.  
  1317.                 case '/' :
  1318.                     {
  1319.                     actmem++;
  1320.  
  1321.                     if ( actmem >= 5000 )
  1322.                         {
  1323.                         CloseWindow(DrawWindow);
  1324.                         CloseScreen(DrawScreen);
  1325.                         DrawWindow = NULL;
  1326.                         DrawScreen = NULL;
  1327.  
  1328.                         ScrollPrint(3, 10, "More than 5000 branches.");
  1329.                         return();
  1330.                         }
  1331.  
  1332.                     struct Memory *m = mem + actmem*sizeof(struct Memory);
  1333.                     m->x = x;
  1334.                     m->y = y;
  1335.                     m->angle = angle;
  1336.                     m->size = size;
  1337.  
  1338.                     angle -= (float)( AngleStart + (rand() % AngleDiff) );
  1339.                     }
  1340.                     break;
  1341.  
  1342.                 case '[' :
  1343.                     {
  1344.                     actmem++;
  1345.  
  1346.                     if ( actmem >= 5000 )
  1347.                         {
  1348.                         CloseWindow(DrawWindow);
  1349.                         CloseScreen(DrawScreen);
  1350.                         DrawWindow = NULL;
  1351.                         DrawScreen = NULL;
  1352.  
  1353.                         ScrollPrint(3, 10, "More than 5000 branches.");
  1354.                         return();
  1355.                         }
  1356.  
  1357.                     struct Memory *m = mem + actmem*sizeof(struct Memory);
  1358.                     m->x = x;
  1359.                     m->y = y;
  1360.                     m->angle = angle;
  1361.                     m->size = size;
  1362.  
  1363.                     if ( rand() & 1 )
  1364.                         angle -= (float)( AngleStart + (rand() % AngleDiff) );
  1365.                     else
  1366.                         angle += (float)( AngleStart + (rand() % AngleDiff) );
  1367.                     }
  1368.                     break;
  1369.  
  1370.                 case ']' :
  1371.                     {
  1372.                     if ( actmem < 0 )
  1373.                         {
  1374.                         CloseWindow(DrawWindow);
  1375.                         CloseScreen(DrawScreen);
  1376.                         DrawWindow = NULL;
  1377.                         DrawScreen = NULL;
  1378.  
  1379.                         ScrollPrint(3, 10, "']' without '\\' or '/' occured.");
  1380.                         return();
  1381.                         }
  1382.  
  1383.                     struct Memory *m = mem + actmem*sizeof(struct Memory);
  1384.                     x = m->x;
  1385.                     y = m->y;
  1386.                     angle = m->angle;
  1387.                     size = m->size;
  1388.  
  1389.                     Move(drawrp, (int)x, (int)y);
  1390.  
  1391.                     actmem--;
  1392.                     }
  1393.                     break;
  1394.  
  1395.                 default :
  1396.                     CloseWindow(DrawWindow);
  1397.                     CloseScreen(DrawScreen);
  1398.                     DrawWindow = NULL;
  1399.                     DrawScreen = NULL;
  1400.  
  1401.                     ScrollPrint(3, 10, "Error in source string");
  1402.                     return();
  1403.                 }
  1404.             }
  1405.         }
  1406.  
  1407.     /**********/
  1408.     /* finish */
  1409.     /**********/
  1410.         {
  1411.         BOOL bool = TRUE;
  1412.         struct IntuiMessage *msg;
  1413.  
  1414.         free(source);
  1415.         free(mem);
  1416.  
  1417.         DisplayBeep(NULL);
  1418.         SetAPen(drawrp, 1);
  1419.         PrintAt(drawrp, 0, 6, -1, "Press LMB");
  1420.  
  1421.         while ( msg = (struct IntuiMessage *)GetMsg(DrawWindow->UserPort) )
  1422.             ReplyMsg(msg);
  1423.  
  1424.         while ( bool )
  1425.             {
  1426.             Wait(1 << DrawWindow->UserPort->mp_SigBit );
  1427.  
  1428.             while ( msg = (struct IntuiMessage *)GetMsg(DrawWindow->UserPort) )
  1429.                 {
  1430.                 if ( (msg->Class == MOUSEBUTTONS) && (msg->Code == SELECTUP) )
  1431.                     bool = FALSE;
  1432.  
  1433.                 ReplyMsg(msg);
  1434.                 }
  1435.             }
  1436.  
  1437.         WBenchToFront();
  1438.         }
  1439.     }
  1440.  
  1441.