home *** CD-ROM | disk | FTP | other *** search
/ The Datafile PD-CD 3 / PDCD_3.iso / utilities / utilsp / pbmtk / !PBMtk / c / RunImage
Encoding:
Text File  |  1993-12-02  |  91.7 KB  |  3,432 lines
  1. /* Title:   RunImage.c
  2.  *
  3.  * WIMP frontend for the PBMplus toolkit !PBMtk
  4.  *
  5.  * (c) Copyright 1993 Terry Duell
  6.  *
  7.  */
  8.  
  9. #include "wimp.h"
  10. #include "wimpt.h"
  11. #include "win.h"
  12. #include "event.h"
  13. #include "baricon.h"
  14. #include "res.h"
  15. #include "resspr.h"
  16. #include "menu.h"
  17. #include "template.h"
  18. #include "dbox.h"
  19. #include "werr.h"
  20. #include "xferrecv.h"
  21. #include "xfersend.h"
  22. #include "visdelay.h"
  23. #include "saveas.h"
  24. #include "os.h"
  25.  
  26. #include <stdlib.h>
  27. #include <string.h>
  28. #include <stdio.h>
  29. #include <limits.h>
  30.  
  31. /********************************* CONSTANTS ********************************/
  32.  
  33. /*  Icon bar menu items */
  34. #define Icon_menu_info     1
  35. #define Icon_menu_quit     2
  36.  
  37. /*  Window menu items--main menu */
  38. #define Win_menu_read      1
  39. #define Win_menu_write     2
  40. #define Win_menu_pbm       3
  41. #define Win_menu_pgm       4
  42. #define Win_menu_ppm       5
  43. #define Win_menu_pnm       6
  44. #define Win_menu_help      7
  45. #define Win_menu_images    8
  46. #define Win_menu_filters   9
  47. #define Win_menu_quit      10
  48.  
  49.  
  50. /*  Read-in submenu items */
  51. #define Rd_menu_FITS          1
  52. #define Rd_menu_RawtoPGM      2
  53. #define Rd_menu_RawtoPPM      3
  54. #define Rd_menu_YUVtoPPM      4
  55.  
  56. /* Write-out submenu items */
  57. #define Wr_menu_toFITS     1
  58. #define Wr_menu_toACAD     2
  59. #define Wr_menu_toPS       3
  60. #define Wr_menu_PPMtoyuv   4
  61.  
  62. /* PBM-process submenu items */ 
  63. #define PBM_menu_make      1
  64. #define PBM_menu_mask      2
  65. #define PBM_menu_reduce    3
  66. #define PBM_menu_text      4
  67.  
  68. /* PGM-process submenu items */
  69. #define PGM_menu_Bentley   1
  70. #define PGM_menu_Crater    2
  71. #define PGM_menu_Edge      3
  72. #define PGM_menu_Enhance   4
  73. #define PGM_menu_Histo     5
  74. #define PGM_menu_Norm      6
  75. #define PGM_menu_Oil       7
  76. #define PGM_menu_Ramp      8
  77. #define PGM_menu_toPBM     9 
  78. #define PGM_menu_RGB3toPPM 10
  79.  
  80. /* PPM-process submenu items */
  81. #define PPM_menu_Dither    1
  82. #define PPM_menu_Forge     2
  83. #define PPM_menu_Histo     3
  84. #define PPM_menu_Make      4
  85. #define PPM_menu_Pattern   5
  86. #define PPM_menu_Quantize  6
  87. #define PPM_menu_Relief    7
  88. #define PPM_menu_toPGM     8
  89.  
  90.  
  91. /* PNM-process submenu items */
  92. #define PNM_menu_Arith     1
  93. #define PNM_menu_Concat    2
  94. #define PNM_menu_Convol    3
  95. #define PNM_menu_Crop      4
  96. #define PNM_menu_Cut       5
  97. #define PNM_menu_Depth     6
  98. #define PNM_menu_File      7
  99. #define PNM_menu_Flip      8
  100. #define PNM_menu_Gamma     9
  101. #define PNM_menu_NoRaw     10
  102. #define PNM_menu_Paste     11
  103. #define PNM_menu_Rotate    12
  104. #define PNM_menu_Scale     13
  105. #define PNM_menu_Shear     14
  106. #define PNM_menu_Tile      15
  107.  
  108. /* Info box field for the version string */
  109. #define Example_info_field    4
  110.  
  111. #define cmdstr 256
  112.  
  113. /* PGMenhance dbox icons */
  114.  
  115. #define enhminus     7
  116. #define enhplus      8
  117. #define enhlevel     6
  118.  
  119. /* PNMconvol dbox icons */
  120.  
  121. #define Image        5
  122. #define Filter       3
  123. #define RUN          0
  124. #define CANCEL       1
  125.  
  126. /* PNMarith dbox icons */
  127.  
  128. #define FileA        3
  129. #define FileB        5
  130. #define Plus         6
  131. #define Minus        7
  132. #define Mult         8
  133.  
  134. /* PNMcat dbox icons */
  135.  
  136. #define White        6
  137. #define Black        7
  138. #define Leftright    8
  139. #define Topbottom    9
  140. #define Top          10
  141. #define Bottom       11
  142. #define Left         12
  143. #define Right        13
  144.  
  145. /* PNMcut dbox icons */
  146.  
  147. #define cutx           7
  148. #define minuscutx      8
  149. #define pluscutx       9
  150. #define cuty           11
  151. #define minuscuty      12
  152. #define pluscuty       13
  153. #define cutwidth       16
  154. #define cutheight      17
  155. #define minuscutwidth  18
  156. #define pluscutwidth   19
  157. #define minuscutheight 20
  158. #define pluscutheight  21
  159.  
  160. /* PNMpaste dbox icons */
  161.  
  162. #define replace        6
  163. #define or             7
  164. #define and            8
  165. #define xor            10
  166. #define pastex         11
  167. #define minusx         12
  168. #define plusx          13
  169. #define pastey         14
  170. #define minusy         15
  171. #define plusy          16
  172.  
  173. /* PPMpat dbox icons */
  174.  
  175. #define minuspatx      2
  176. #define patx           3
  177. #define pluspatx       4
  178. #define minuspaty      5
  179. #define paty           6
  180. #define pluspaty       7
  181. #define ging2          8
  182. #define ging3          9
  183. #define madras         10
  184. #define tartan         11
  185. #define poles          12
  186. #define squig          13
  187. #define camo           14
  188. #define anticamo       15
  189.  
  190. /* YUVtoPPM dbox icons */
  191.  
  192. #define YUVwidthminus  7
  193. #define YUVwidth       8
  194. #define YUVwidthplus   9
  195. #define YUVheightminus 11
  196. #define YUVheight      12
  197. #define YUVheightplus  13
  198.  
  199. /* PGMcrater dbox icons */
  200.  
  201. #define CraterXminus     2
  202. #define CraterX          3
  203. #define CraterXplus      4
  204. #define CraterYminus     5
  205. #define CraterY          6
  206. #define CraterYplus      7
  207. #define Craternumber     8
  208. #define Craternumminus   9
  209. #define Craternumplus    10
  210. #define Cratergammaminus 11
  211. #define Cratergamma      12
  212. #define Cratergammaplus  13
  213.  
  214. /* PNMtile dbox icons */
  215.  
  216. #define TileXminus       7
  217. #define TileX            8
  218. #define TileXplus        9
  219. #define TileYminus       11
  220. #define TileY            12
  221. #define TileYplus        13
  222.  
  223. /* PBMmake dbox icons */
  224.  
  225. #define PBMmakeminusx    2
  226. #define PBMmakex         3
  227. #define PBMmakeplusx     4 
  228. #define PBMmakeminusy    5
  229. #define PBMmakey         6
  230. #define PBMmakeplusy     7
  231. #define PBMmakewhite     8
  232. #define PBMmakeblack     10
  233. #define PBMmakegrey      11
  234.  
  235.  
  236. /*PNmscale dbox icons */
  237.  
  238. #define factors          6
  239. #define regscale         8
  240. #define regfactminus     9
  241. #define regfact          10
  242. #define regfactplus      11
  243. #define iregfact         13
  244. #define xfactminus       14
  245. #define xfact            15
  246. #define xfactplus        16
  247. #define yfactminus       18
  248. #define yfact            19
  249. #define yfactplus        20
  250. #define sizes            22
  251. #define square           25
  252. #define squareminus      26
  253. #define squaresize       27
  254. #define squareplus       28
  255. #define rect             30
  256. #define rectwidminus     31
  257. #define rectwid          32
  258. #define rectwidplus      33
  259. #define rectheightminus  34
  260. #define rectheight       35
  261. #define rectheightplus   36
  262.  
  263. /* define filetype */
  264.  
  265. #define PBMplus      0x69e
  266. #define TXTtype      0xfff
  267.  
  268. /******************************** GLOBAL DATA *******************************/
  269.  
  270. /* Application version */
  271. static char *Version_String = "0.17 (14 Nov 1993)";
  272.  
  273. /* The top of the menu tree */
  274. static menu Icon_menu;
  275. static menu Win_menu;
  276.  
  277. static menu Rd_menu;
  278. static menu Wr_menu;
  279. static menu PBM_menu;
  280. static menu PGM_menu;
  281. static menu PPM_menu;
  282. static menu PNM_menu;
  283.  
  284. /* Handle for the window */
  285. static wimp_w win_handle;
  286.  
  287. /* the global constant for the output filename */
  288.  
  289. static char *outfile;
  290.  
  291. /* Flag - is the window open */
  292. static BOOL window_open = FALSE;
  293.  
  294.  
  295. /* ************************************************************/
  296.  
  297. /* Save file */
  298.  
  299. BOOL saver_proc(char *filename, void *handle)
  300.  
  301. {
  302.  
  303.   os_filestr file;
  304.   BOOL ok;
  305.  
  306.   visdelay_begin();
  307.  
  308. /* create a file of given type and size (empty)
  309.    and then have output redirected to this file
  310.    by the command in Runtask().
  311.  
  312.    If we click OK, then output is redirected to
  313.    this file. If we drag the 'saveas' icon to
  314.    a directory viewer, the wimp provides the
  315.    full pathname of the destination, and we use
  316.    this to reset the pathname of the redirected
  317.    output from the command, hence in both cases
  318.    the file is saved OK. There is one outstanding
  319.    problem. If the command exits with an error
  320.    there is unlikely to be any output written.
  321.    In this case the dummy file has been created
  322.    and it should not have!
  323.    The only solution to this may be to have a standard
  324.    filename for all redirected output (to a scrap dir)
  325.    and if command exits without error, then rename the file
  326.    to either one appropriate for the command, or the 
  327.    pathname of the drag destination. if exit with error
  328.    then delete the file. */
  329.  
  330.   file.action = 0x0b;     
  331.   file.name = filename;
  332.   file.loadaddr = PBMplus;
  333.   file.start = 0;
  334.   file.end = 256;
  335.  
  336.   ok = ( wimpt_complain(os_file(&file)) == 0);
  337.   outfile = filename;
  338.   visdelay_end();
  339.  
  340.   return ok;
  341. }
  342.  
  343. /******************************************************/
  344. /* run a task */
  345.  
  346. void Runtask (char *cmd)
  347.  
  348. {
  349.    /* os_error errdata;*/
  350.  
  351.  
  352.         visdelay_begin();
  353.        /* errdata.errnum = wimp_starttask(cmd); */
  354.         wimp_starttask(cmd);
  355.         visdelay_end();
  356.  
  357.  
  358.         /*if (errdata.errnum != 0)
  359.            werr(0,"error..error!!");*/
  360. }
  361.  
  362. /********************************************************/
  363.  
  364. BOOL Arithhandler( dbox d, wimp_eventstr *e, void *handle)
  365.  
  366. /* handle events in PNMArith Dbox, particularly input file drags*/
  367. {
  368.   int filetype;
  369.   char *Arithfile;
  370.  
  371.   handle = handle; /* We don't need handle: this stops compiler warning */
  372.  
  373.   /* Deal with event */
  374.   switch (e->e)
  375.   {
  376.     case wimp_ECLOSE:  
  377.        {
  378.        return FALSE;
  379.        break;
  380.        }
  381.     case wimp_ESEND:
  382.     case wimp_ESENDWANTACK:
  383.     {
  384.       /* We deal only with messages for loading and saving files here, using
  385.          essentially the skeleton code given in the manual
  386.       */
  387.       switch (e->data.msg.hdr.action)
  388.       {
  389.  
  390.         case wimp_MDATALOAD:   /* insert data */
  391.           
  392.           switch(e->data.msg.data.dataload.i)
  393.           {
  394.  
  395.               case FileA:
  396.               {
  397.               filetype = xferrecv_checkinsert(&Arithfile);
  398.               dbox_setfield(d,FileA,Arithfile);
  399.               xferrecv_insertfileok();
  400.               return TRUE;
  401.               break;
  402.               }
  403.               case FileB:
  404.               {
  405.               filetype = xferrecv_checkinsert(&Arithfile);
  406.               dbox_setfield(d,FileB,Arithfile);
  407.               xferrecv_insertfileok();
  408.               return TRUE;
  409.               break;
  410.               }
  411.               default:
  412.               return FALSE;
  413.               break;
  414.           }
  415.  
  416.         default:
  417.         return FALSE;
  418.         break;       /* ignore other messages */
  419.       }
  420.  
  421.     }
  422.     default:   /* Ignore any other event */
  423.     return FALSE;
  424.     break;
  425.   }
  426. return FALSE;
  427. }
  428.  
  429. /*********************************************************/
  430.  
  431. BOOL Pastehandler( dbox d, wimp_eventstr *e, void *handle)
  432.  
  433. /* handle events in PNMPaste Dbox, particularly input file drags*/
  434. {
  435.   int filetype;
  436.   char *Pastefile;
  437.  
  438.   handle = handle; /* We don't need handle: this stops compiler warning */
  439.  
  440.   /* Deal with event */
  441.   switch (e->e)
  442.   {
  443.  
  444.     case wimp_ECLOSE:  
  445.        {
  446.        return FALSE;
  447.        break;
  448.        }
  449.     case wimp_ESEND:
  450.     case wimp_ESENDWANTACK:
  451.     {
  452.       /* We deal only with messages for loading and saving files here, using
  453.          essentially the skeleton code given in the manual
  454.       */
  455.       switch (e->data.msg.hdr.action)
  456.       {
  457.  
  458.         case wimp_MDATALOAD:   /* insert data */
  459.           
  460.           switch(e->data.msg.data.dataload.i)
  461.           {
  462.  
  463.               case FileA:
  464.               {
  465.               filetype = xferrecv_checkinsert(&Pastefile);
  466.               dbox_setfield(d,FileA,Pastefile);
  467.               xferrecv_insertfileok();
  468.               return TRUE;
  469.               break;
  470.               }
  471.               case FileB:
  472.               {
  473.               filetype = xferrecv_checkinsert(&Pastefile);
  474.               dbox_setfield(d,FileB,Pastefile);
  475.               xferrecv_insertfileok();
  476.               return TRUE;
  477.               break;
  478.               }
  479.               default:
  480.               return FALSE;
  481.               break;
  482.           }
  483.         default:
  484.         return FALSE;
  485.         break;       /* ignore other messages */
  486.       }
  487.     }
  488.     default:   /* Ignore any other event */
  489.     return FALSE;
  490.     break;
  491.   }
  492. return FALSE;
  493. }
  494. /******************************************************/
  495.  
  496.  
  497. BOOL Cuthandler( dbox d, wimp_eventstr *e, void *handle)
  498.  
  499. /* handle events in PNMcut Dbox, particularly input file drags*/
  500. {
  501.   int filetype;
  502.   char *Cutfile;
  503.  
  504.   handle = handle; /* We don't need handle: this stops compiler warning */
  505.  
  506.   /* Deal with event */
  507.   switch (e->e)
  508.   {
  509.     case wimp_ECLOSE:  
  510.        {
  511.        return FALSE;
  512.        break;
  513.        }
  514.     case wimp_ESEND:
  515.     case wimp_ESENDWANTACK:
  516.     {
  517.       /* We deal only with messages for loading and saving files here, using
  518.          essentially the skeleton code given in the manual
  519.       */
  520.       switch (e->data.msg.hdr.action)
  521.       {
  522.  
  523.         case wimp_MDATALOAD:   /* insert data */
  524.           
  525.           switch(e->data.msg.data.dataload.i)
  526.           {
  527.  
  528.               case FileA:
  529.               {
  530.               filetype = xferrecv_checkinsert(&Cutfile);
  531.               dbox_setfield(d,FileA,Cutfile);
  532.               xferrecv_insertfileok();
  533.               return TRUE;
  534.               break;
  535.               }
  536.               default:
  537.               return FALSE;
  538.               break;
  539.           }
  540.         default:
  541.         return FALSE;
  542.         break;       /* ignore other messages */
  543.       }
  544.     }
  545.     default:   /* Ignore any other event */
  546.     return FALSE;
  547.     break;
  548.   }
  549. return FALSE;
  550. }
  551.  
  552. /***********************************/
  553.  
  554. BOOL YUVtoPPMhandler( dbox d, wimp_eventstr *e, void *handle)
  555.  
  556. /* handle events in YUVtoPPM Dbox, particularly input file drags*/
  557. {
  558.   int filetype;
  559.   char *YUVfile;
  560.  
  561.   handle = handle; /* We don't need handle: this stops compiler warning */
  562.  
  563.   /* Deal with event */
  564.   switch (e->e)
  565.   {
  566.     case wimp_ECLOSE:  
  567.        {
  568.        return FALSE;
  569.        break;
  570.        }
  571.     case wimp_ESEND:
  572.     case wimp_ESENDWANTACK:
  573.     {
  574.       /* We deal only with messages for loading and saving files here, using
  575.          essentially the skeleton code given in the manual
  576.       */
  577.       switch (e->data.msg.hdr.action)
  578.       {
  579.  
  580.         case wimp_MDATALOAD:   /* insert data */
  581.           
  582.           switch(e->data.msg.data.dataload.i)
  583.           {
  584.  
  585.               case FileA:
  586.               {
  587.               filetype = xferrecv_checkinsert(&YUVfile);
  588.               dbox_setfield(d,FileA,YUVfile);
  589.               xferrecv_insertfileok();
  590.               return TRUE;
  591.               break;
  592.               }
  593.               default:
  594.               return FALSE;
  595.               break;
  596.           }
  597.         default:
  598.         return FALSE;
  599.         break;       /* ignore other messages */
  600.       }
  601.     }
  602.     default:   /* Ignore any other event */
  603.     return FALSE;
  604.     break;
  605.   }
  606. return FALSE;
  607. }
  608.  
  609. /***********************************/
  610.  
  611. BOOL PNMtilehandler( dbox d, wimp_eventstr *e, void *handle)
  612.  
  613. /* handle events in PNMtile Dbox, particularly input file drags*/
  614. {
  615.   int filetype;
  616.   char *PNMfile;
  617.  
  618.   handle = handle; /* We don't need handle: this stops compiler warning */
  619.  
  620.   /* Deal with event */
  621.   switch (e->e)
  622.   {
  623.     case wimp_ECLOSE:  
  624.        {
  625.        return FALSE;
  626.        break;
  627.        }
  628.     case wimp_ESEND:
  629.     case wimp_ESENDWANTACK:
  630.     {
  631.       /* We deal only with messages for loading and saving files here, using
  632.          essentially the skeleton code given in the manual
  633.       */
  634.       switch (e->data.msg.hdr.action)
  635.       {
  636.  
  637.         case wimp_MDATALOAD:   /* insert data */
  638.           
  639.           switch(e->data.msg.data.dataload.i)
  640.           {
  641.  
  642.               case FileA:
  643.               {
  644.               filetype = xferrecv_checkinsert(&PNMfile);
  645.               dbox_setfield(d,FileA,PNMfile);
  646.               xferrecv_insertfileok();
  647.               return TRUE;
  648.               break;
  649.               }
  650.               default:
  651.               return FALSE;
  652.               break;
  653.           }
  654.         default:
  655.         return FALSE;
  656.         break;       /* ignore other messages */
  657.       }
  658.     }
  659.     default:   /* Ignore any other event */
  660.     return FALSE;
  661.     break;
  662.   }
  663. return FALSE;
  664. }
  665. /****************************************************/
  666.  
  667. BOOL PNMscalehandler( dbox d, wimp_eventstr *e, void *handle)
  668.  
  669. /* handle events in PNMscale Dbox, particularly input file drags*/
  670. {
  671.   int filetype;
  672.   char *Scalefile;
  673.  
  674.   handle = handle; /* We don't need handle: this stops compiler warning */
  675.  
  676.   /* Deal with event */
  677.   switch (e->e)
  678.   {
  679.     case wimp_ECLOSE:  
  680.        {
  681.        return FALSE;
  682.        break;
  683.        }
  684.     case wimp_ESEND:
  685.     case wimp_ESENDWANTACK:
  686.     {
  687.       /* We deal only with messages for loading and saving files here, using
  688.          essentially the skeleton code given in the manual
  689.       */
  690.       switch (e->data.msg.hdr.action)
  691.       {
  692.  
  693.         case wimp_MDATALOAD:   /* insert data */
  694.           
  695.           switch(e->data.msg.data.dataload.i)
  696.           {
  697.  
  698.               case FileA:
  699.               {
  700.               filetype = xferrecv_checkinsert(&Scalefile);
  701.               dbox_setfield(d,FileA,Scalefile);
  702.               xferrecv_insertfileok();
  703.               return TRUE;
  704.               break;
  705.               }
  706.               default:
  707.               return FALSE;
  708.               break;
  709.           }
  710.         default:
  711.         return FALSE;
  712.         break;       /* ignore other messages */
  713.       }
  714.     }
  715.     default:   /* Ignore any other event */
  716.     return FALSE;
  717.     break;
  718.   }
  719. return FALSE;
  720. }
  721. /***********************************/
  722.  
  723. BOOL PGMenhancehandler( dbox d, wimp_eventstr *e, void *handle)
  724.  
  725. /* handle events in PGMenhance Dbox, particularly input file drags*/
  726. {
  727.   int filetype;
  728.   char *PGMfile;
  729.  
  730.   handle = handle; /* We don't need handle: this stops compiler warning */
  731.  
  732.   /* Deal with event */
  733.   switch (e->e)
  734.   {
  735.     case wimp_ECLOSE:  
  736.        {
  737.        return FALSE;
  738.        break;
  739.        }
  740.     case wimp_ESEND:
  741.     case wimp_ESENDWANTACK:
  742.     {
  743.       /* We deal only with messages for loading and saving files here, using
  744.          essentially the skeleton code given in the manual
  745.       */
  746.       switch (e->data.msg.hdr.action)
  747.       {
  748.  
  749.         case wimp_MDATALOAD:   /* insert data */
  750.           
  751.           switch(e->data.msg.data.dataload.i)
  752.           {
  753.  
  754.               case FileA:
  755.               {
  756.               filetype = xferrecv_checkinsert(&PGMfile);
  757.               dbox_setfield(d,FileA,PGMfile);
  758.               xferrecv_insertfileok();
  759.               return TRUE;
  760.               break;
  761.               }
  762.               default:
  763.               return FALSE;
  764.               break;
  765.           }
  766.         default:
  767.         return FALSE;
  768.         break;       /* ignore other messages */
  769.       }
  770.     }
  771.     default:   /* Ignore any other event */
  772.     return FALSE;
  773.     break;
  774.   }
  775. return FALSE;
  776. }
  777. /******************************************************/
  778.  
  779.  
  780. BOOL Cathandler( dbox d, wimp_eventstr *e, void *handle)
  781.  
  782. /* handle events in PNMcat Dbox, particularly input file drags*/
  783. {
  784.   int filetype;
  785.   char *Catfile;
  786.   char str1[24];
  787.   char str2[256];
  788.   int size = 256;
  789.   int n;
  790.  
  791.   handle = handle; /* We don't need handle: this stops compiler warning */
  792.  
  793.   /* Deal with event */
  794.   switch (e->e)
  795.   {
  796.     case wimp_ECLOSE:  
  797.        {
  798.        return FALSE;
  799.        break;
  800.        }
  801.     case wimp_ESEND:
  802.     case wimp_ESENDWANTACK:
  803.     {
  804.       /* We deal only with messages for loading and saving files here, using
  805.          essentially the skeleton code given in the manual
  806.       */
  807.       switch (e->data.msg.hdr.action)
  808.       {
  809.         case wimp_MDATALOAD:   /* insert data */          
  810.           switch(e->data.msg.data.dataload.i)
  811.           {
  812.               case FileA:
  813.               {
  814.               filetype = xferrecv_checkinsert(&Catfile);
  815.  
  816.  
  817.               dbox_getfield(d,FileA,str2,size);
  818.  
  819.  
  820.               sprintf(str1," %s",Catfile);
  821.               n = strlen (str1);
  822.  
  823.               strncat(str2,str1,n+1);
  824.  
  825.               dbox_setfield(d,FileA,str2);
  826.               xferrecv_insertfileok();
  827.               return TRUE;
  828.               break;
  829.               }
  830.  
  831.               default:
  832.               return FALSE;
  833.               break;
  834.           }
  835.  
  836.         default:
  837.         return FALSE;
  838.         break;       /* ignore other messages */
  839.       }
  840.     }
  841.     default:   /* Ignore any other event */
  842.     return FALSE;
  843.     break;
  844.   }
  845. return FALSE;
  846. }
  847. /******************************************************/
  848.  
  849.  
  850. BOOL Convolhandler( dbox d, wimp_eventstr *e, void *handle)
  851.  
  852.  
  853. /* handle events in PNMconvol Dbox, particularly input file drags*/
  854. {
  855.   int filetype;
  856.   char *PNMfile;
  857.  
  858.   handle = handle; /* We don't need handle: this stops compiler warning */
  859.  
  860.   /* Deal with event */
  861.   switch (e->e)
  862.   {
  863.     case wimp_ECLOSE:  
  864.        {
  865.        return FALSE;
  866.        break;
  867.        }
  868.     case wimp_ESEND:
  869.     case wimp_ESENDWANTACK:
  870.     {
  871.       /* We deal only with messages for loading and saving files here, using
  872.          essentially the skeleton code given in the manual
  873.       */
  874.       switch (e->data.msg.hdr.action)
  875.       {
  876.         case wimp_MDATALOAD:   /* insert data */         
  877.           switch(e->data.msg.data.dataload.i)
  878.           {
  879.               case Image:
  880.               {
  881.               filetype = xferrecv_checkinsert(&PNMfile);
  882.               dbox_setfield(d,Image,PNMfile);
  883.               xferrecv_insertfileok();
  884.               return TRUE;
  885.               break;
  886.               }
  887.               case Filter:
  888.               {
  889.               filetype = xferrecv_checkinsert(&PNMfile);
  890.               dbox_setfield(d,Filter,PNMfile);
  891.               xferrecv_insertfileok();
  892.               return TRUE;
  893.               break;
  894.               }
  895.               default:
  896.               return FALSE;
  897.               break;
  898.           }
  899.  
  900.         default:
  901.         return FALSE;
  902.         break;       /* ignore other messages */
  903.       }
  904.     }
  905.     default:   /* Ignore any other event */
  906.     return FALSE;
  907.     break;
  908.   }
  909. return FALSE;
  910. }
  911.  
  912. /********************************************/
  913.  
  914. BOOL Norawhandler( dbox d, wimp_eventstr *e, void *handle)
  915.  
  916. /* handle events in PNMnoraw Dbox, particularly input file drags*/
  917. {
  918.   int filetype;
  919.   char *PNMfile;
  920.  
  921.   handle = handle; /* We don't need handle: this stops compiler warning */
  922.  
  923.   /* Deal with event */
  924.   switch (e->e)
  925.   {
  926.     case wimp_ECLOSE:  
  927.        {
  928.        return FALSE;
  929.        break;
  930.        }
  931.     case wimp_ESEND:
  932.     case wimp_ESENDWANTACK:
  933.     {
  934.       /* We deal only with messages for loading and saving files here, using
  935.          essentially the skeleton code given in the manual
  936.       */
  937.       switch (e->data.msg.hdr.action)
  938.       {
  939.         case wimp_MDATALOAD:   /* insert data */         
  940.           switch(e->data.msg.data.dataload.i)
  941.           {
  942.               case FileA:
  943.               {
  944.               filetype = xferrecv_checkinsert(&PNMfile);
  945.               dbox_setfield(d,FileA,PNMfile);
  946.               xferrecv_insertfileok();
  947.               return TRUE;
  948.               break;
  949.               }
  950.               default:
  951.               return FALSE;
  952.               break;
  953.           }
  954.  
  955.         default:
  956.         return FALSE;
  957.         break;       /* ignore other messages */
  958.       }
  959.     }
  960.     default:   /* Ignore any other event */
  961.     return FALSE;
  962.     break;
  963.   }
  964. return FALSE;
  965. }
  966.  
  967. /*********************************/
  968.  
  969. BOOL PPMtopgmhandler( dbox d, wimp_eventstr *e, void *handle)
  970.  
  971. /* handle events in PPMtopgm Dbox, particularly input file drags*/
  972. {
  973.   int filetype;
  974.   char *PPMfile;
  975.  
  976.   handle = handle; /* We don't need handle: this stops compiler warning */
  977.  
  978.   /* Deal with event */
  979.   switch (e->e)
  980.   {
  981.     case wimp_ECLOSE:  
  982.        {
  983.        return FALSE;
  984.        break;
  985.        }
  986.     case wimp_ESEND:
  987.     case wimp_ESENDWANTACK:
  988.     {
  989.       /* We deal only with messages for loading and saving files here, using
  990.          essentially the skeleton code given in the manual
  991.       */
  992.       switch (e->data.msg.hdr.action)
  993.       {
  994.         case wimp_MDATALOAD:   /* insert data */         
  995.           switch(e->data.msg.data.dataload.i)
  996.           {
  997.               case FileA:
  998.               {
  999.               filetype = xferrecv_checkinsert(&PPMfile);
  1000.               dbox_setfield(d,FileA,PPMfile);
  1001.               xferrecv_insertfileok();
  1002.               return TRUE;
  1003.               break;
  1004.               }
  1005.               default:
  1006.               return FALSE;
  1007.               break;
  1008.           }
  1009.  
  1010.         default:
  1011.         return FALSE;
  1012.         break;       /* ignore other messages */
  1013.       }
  1014.     }
  1015.     default:   /* Ignore any other event */
  1016.     return FALSE;
  1017.     break;
  1018.   }
  1019. return FALSE;
  1020. }
  1021.  
  1022. /************************************/
  1023.  
  1024. BOOL PGMedgehandler( dbox d, wimp_eventstr *e, void *handle)
  1025.  
  1026. /* handle events in PGMedge Dbox, particularly input file drags*/
  1027. {
  1028.   int filetype;
  1029.   char *PGMfile;
  1030.  
  1031.   handle = handle; /* We don't need handle: this stops compiler warning */
  1032.  
  1033.   /* Deal with event */
  1034.   switch (e->e)
  1035.   {
  1036.     case wimp_ECLOSE:  
  1037.        {
  1038.        return FALSE;
  1039.        break;
  1040.        }
  1041.     case wimp_ESEND:
  1042.     case wimp_ESENDWANTACK:
  1043.     {
  1044.       /* We deal only with messages for loading and saving files here, using
  1045.          essentially the skeleton code given in the manual
  1046.       */
  1047.       switch (e->data.msg.hdr.action)
  1048.       {
  1049.         case wimp_MDATALOAD:   /* insert data */         
  1050.           switch(e->data.msg.data.dataload.i)
  1051.           {
  1052.               case FileA:
  1053.               {
  1054.               filetype = xferrecv_checkinsert(&PGMfile);
  1055.               dbox_setfield(d,FileA,PGMfile);
  1056.               xferrecv_insertfileok();
  1057.               return TRUE;
  1058.               break;
  1059.               }
  1060.               default:
  1061.               return FALSE;
  1062.               break;
  1063.           }
  1064.  
  1065.         default:
  1066.         return FALSE;
  1067.         break;       /* ignore other messages */
  1068.       }
  1069.     }
  1070.     default:   /* Ignore any other event */
  1071.     return FALSE;
  1072.     break;
  1073.   }
  1074. return FALSE;
  1075. }
  1076. /************************************/
  1077.  
  1078. BOOL PPMreliefhandler( dbox d, wimp_eventstr *e, void *handle)
  1079.  
  1080. /* handle events in PPMrelief Dbox, particularly input file drags*/
  1081. {
  1082.   int filetype;
  1083.   char *PPMfile;
  1084.  
  1085.   handle = handle; /* We don't need handle: this stops compiler warning */
  1086.  
  1087.   /* Deal with event */
  1088.   switch (e->e)
  1089.   {
  1090.     case wimp_ECLOSE:  
  1091.        {
  1092.        return FALSE;
  1093.        break;
  1094.        }
  1095.     case wimp_ESEND:
  1096.     case wimp_ESENDWANTACK:
  1097.     {
  1098.       /* We deal only with messages for loading and saving files here, using
  1099.          essentially the skeleton code given in the manual
  1100.       */
  1101.       switch (e->data.msg.hdr.action)
  1102.       {
  1103.         case wimp_MDATALOAD:   /* insert data */         
  1104.           switch(e->data.msg.data.dataload.i)
  1105.           {
  1106.               case FileA:
  1107.               {
  1108.               filetype = xferrecv_checkinsert(&PPMfile);
  1109.               dbox_setfield(d,FileA,PPMfile);
  1110.               xferrecv_insertfileok();
  1111.               return TRUE;
  1112.               break;
  1113.               }
  1114.               default:
  1115.               return FALSE;
  1116.               break;
  1117.           }
  1118.  
  1119.         default:
  1120.         return FALSE;
  1121.         break;       /* ignore other messages */
  1122.       }
  1123.     }
  1124.     default:   /* Ignore any other event */
  1125.     return FALSE;
  1126.     break;
  1127.   }
  1128. return FALSE;
  1129. }
  1130. /****************************************/
  1131.  
  1132. BOOL ToYUVhandler( dbox d, wimp_eventstr *e, void *handle)
  1133.  
  1134. /* handle events in PPMtoyuv Dbox, particularly input file drags*/
  1135. {
  1136.   int filetype;
  1137.   char *PPMfile;
  1138.  
  1139.   handle = handle; /* We don't need handle: this stops compiler warning */
  1140.  
  1141.   /* Deal with event */
  1142.   switch (e->e)
  1143.   {
  1144.     case wimp_ECLOSE:  
  1145.        {
  1146.        return FALSE;
  1147.        break;
  1148.        }
  1149.     case wimp_ESEND:
  1150.     case wimp_ESENDWANTACK:
  1151.     {
  1152.       /* We deal only with messages for loading and saving files here, using
  1153.          essentially the skeleton code given in the manual
  1154.       */
  1155.       switch (e->data.msg.hdr.action)
  1156.       {
  1157.         case wimp_MDATALOAD:   /* insert data */         
  1158.           switch(e->data.msg.data.dataload.i)
  1159.           {
  1160.               case FileA:
  1161.               {
  1162.               filetype = xferrecv_checkinsert(&PPMfile);
  1163.               dbox_setfield(d,FileA,PPMfile);
  1164.               xferrecv_insertfileok();
  1165.               return TRUE;
  1166.               break;
  1167.               }
  1168.               default:
  1169.               return FALSE;
  1170.               break;
  1171.           }
  1172.  
  1173.         default:
  1174.         return FALSE;
  1175.         break;       /* ignore other messages */
  1176.       }
  1177.     }
  1178.     default:   /* Ignore any other event */
  1179.     return FALSE;
  1180.     break;
  1181.   }
  1182. return FALSE;
  1183. }
  1184. /******************************************************/
  1185.  
  1186. void RunPNMConvol(void)
  1187.  
  1188. /* build the PNMconvol command  and call Runtask(cmd)*/
  1189. {
  1190.     char cmd[cmdstr];
  1191.     char Ffile[128];
  1192.     char Pfile[128];
  1193.     dbox ConvolDbox;
  1194.     BOOL filling = TRUE;
  1195.     BOOL done    = FALSE;
  1196.     int size = 128;
  1197.  
  1198.     int filetype = PBMplus;
  1199.     char *name = "<PBMfiles$Dir>.convolOUT";
  1200.     int estsize = 256;
  1201.     char *data = "convolout";
  1202.     void *fred;
  1203.  
  1204.     ConvolDbox = dbox_new("PNMConvol");
  1205.     dbox_raw_eventhandler(ConvolDbox, (dbox_raw_handler_proc)Convolhandler, fred);
  1206.  
  1207.     /*dbox_raw_eventhandler(ConvolDbox,Convolhandler,"CONVOL");*/
  1208.  
  1209.     dbox_showstatic(ConvolDbox);
  1210.  
  1211.     while (filling)
  1212.     {
  1213.         switch (dbox_fillin(ConvolDbox))
  1214.         {
  1215.            case RUN:
  1216.                 {
  1217.                 dbox_getfield(ConvolDbox,Filter,Ffile,size);
  1218.                 dbox_getfield(ConvolDbox,Image,Pfile,size);
  1219.                 saveas(filetype,name,estsize,saver_proc,0,0,data);
  1220.  
  1221.                 if ( name != outfile)
  1222.                    name = outfile;
  1223.  
  1224.                 sprintf(cmd,"<PBMtkAPP$Dir>.PNMconvol %s %s > %s" , Ffile , Pfile, name);                
  1225.                 Runtask(cmd);
  1226.                 done    = TRUE;
  1227.                 filling = FALSE;
  1228.                 break;
  1229.                 }
  1230.            case CANCEL:
  1231.                 {
  1232.                 dbox_setfield(ConvolDbox,Filter," ");
  1233.                 dbox_setfield(ConvolDbox,Image," ");
  1234.                 filling = FALSE;
  1235.                 break;
  1236.                 }
  1237.            default:
  1238.            break;
  1239.          }    
  1240.     }
  1241.    dbox_dispose(&ConvolDbox);
  1242. }
  1243.  
  1244. /****************************************/
  1245.  
  1246. void RunPNMnoraw(void)
  1247.  
  1248. /* build the PNMnoraw command  and call Runtask(cmd)*/
  1249. {
  1250.     char cmd[cmdstr];
  1251.     char Pfile[128];
  1252.     dbox NorawDbox;
  1253.     BOOL filling = TRUE;
  1254.     BOOL done    = FALSE;
  1255.     int size = 128;
  1256.  
  1257.     int filetype = PBMplus;
  1258.     char *name = "<PBMfiles$Dir>.norawOUT";
  1259.     int estsize = 256;
  1260.     char *data = "norawout";
  1261.     void *fred;
  1262.  
  1263.     NorawDbox = dbox_new("PNMnoraw");
  1264.     dbox_raw_eventhandler(NorawDbox,(dbox_raw_handler_proc)Norawhandler,fred);
  1265.  
  1266.     /*dbox_raw_eventhandler(NorawDbox,Norawhandler,"NORAW");*/
  1267.  
  1268.     dbox_showstatic(NorawDbox);
  1269.  
  1270.     while (filling)
  1271.     {
  1272.         switch (dbox_fillin(NorawDbox))
  1273.         {
  1274.            case RUN:
  1275.                 {
  1276.                 dbox_getfield(NorawDbox,FileA,Pfile,size);
  1277.                 saveas(filetype,name,estsize,saver_proc,0,0,data);
  1278.  
  1279.                 if ( name != outfile)
  1280.                    name = outfile;
  1281.  
  1282.                 sprintf(cmd,"<PBMtkAPP$Dir>.PNMnoraw %s > %s", Pfile, name);                
  1283.                 Runtask(cmd);
  1284.                 done    = TRUE;
  1285.                 filling = FALSE;
  1286.                 break;
  1287.                 }
  1288.            case CANCEL:
  1289.                 {
  1290.                 dbox_setfield(NorawDbox,FileA," ");
  1291.                 filling = FALSE;
  1292.                 break;
  1293.                 }
  1294.            default:
  1295.            break;
  1296.          }    
  1297.     }
  1298.    dbox_dispose(&NorawDbox);
  1299. }
  1300.  
  1301. /***************************************/
  1302.  
  1303. void RunPPMtopgm(void)
  1304.  
  1305. /* build the PPMtopgm command  and call Runtask(cmd)*/
  1306. {
  1307.     char cmd[cmdstr];
  1308.     char Pfile[128];
  1309.     dbox PPMtopgmDbox;
  1310.     BOOL filling = TRUE;
  1311.     BOOL done    = FALSE;
  1312.     int size = 128;
  1313.  
  1314.     int filetype = PBMplus;
  1315.     char *name = "<PBMfiles$Dir>.pgmOUT";
  1316.     int estsize = 256;
  1317.     char *data = "pgmout";
  1318.     void *fred;
  1319.  
  1320.     PPMtopgmDbox = dbox_new("PPMtopgm");
  1321.     dbox_raw_eventhandler(PPMtopgmDbox,(dbox_raw_handler_proc)PPMtopgmhandler,fred);
  1322.  
  1323.     /*dbox_raw_eventhandler(PPMtopgmDbox,PPMtopgmhandler,"PPMTOPGM");*/
  1324.  
  1325.     dbox_showstatic(PPMtopgmDbox);
  1326.  
  1327.     while (filling)
  1328.     {
  1329.         switch (dbox_fillin(PPMtopgmDbox))
  1330.         {
  1331.            case RUN:
  1332.                 {
  1333.                 dbox_getfield(PPMtopgmDbox,FileA,Pfile,size);
  1334.                 saveas(filetype,name,estsize,saver_proc,0,0,data);
  1335.  
  1336.                 if ( name != outfile)
  1337.                    name = outfile;
  1338.  
  1339.                 sprintf(cmd,"<PBMtkAPP$Dir>.PPMtopgm %s > %s", Pfile, name);                
  1340.                 Runtask(cmd);
  1341.                 done    = TRUE;
  1342.                 filling = FALSE;
  1343.                 break;
  1344.                 }
  1345.            case CANCEL:
  1346.                 {
  1347.                 dbox_setfield(PPMtopgmDbox,FileA," ");
  1348.                 filling = FALSE;
  1349.                 break;
  1350.                 }
  1351.            default:
  1352.            break;
  1353.          }    
  1354.     }
  1355.    dbox_dispose(&PPMtopgmDbox);
  1356. }
  1357.  
  1358. /**************************************/
  1359.  
  1360. void RunPGMedge(void)
  1361.  
  1362. /* build the PGMedge command  and call Runtask(cmd)*/
  1363. {
  1364.     char cmd[cmdstr];
  1365.     char Pfile[128];
  1366.     dbox PGMedgeDbox;
  1367.     BOOL filling = TRUE;
  1368.     BOOL done    = FALSE;
  1369.     int size = 128;
  1370.  
  1371.     int filetype = PBMplus;
  1372.     char *name = "<PBMfiles$Dir>.edgeOUT";
  1373.     int estsize = 256;
  1374.     char *data = "edge";
  1375.     void *fred;
  1376.  
  1377.     PGMedgeDbox = dbox_new("PGMedge");
  1378.     dbox_raw_eventhandler(PGMedgeDbox,(dbox_raw_handler_proc)PGMedgehandler,fred);
  1379.  
  1380.     /*dbox_raw_eventhandler(PGMedgeDbox,PGMedgehandler,"PGMEDGE");*/
  1381.  
  1382.     dbox_showstatic(PGMedgeDbox);
  1383.  
  1384.     while (filling)
  1385.     {
  1386.         switch (dbox_fillin(PGMedgeDbox))
  1387.         {
  1388.            case RUN:
  1389.                 {
  1390.                 dbox_getfield(PGMedgeDbox,FileA,Pfile,size);
  1391.                 saveas(filetype,name,estsize,saver_proc,0,0,data);
  1392.  
  1393.                 if ( name != outfile)
  1394.                    name = outfile;
  1395.  
  1396.                 sprintf(cmd,"<PBMtkAPP$Dir>.PGMedge %s > %s", Pfile, name);                
  1397.                 Runtask(cmd);
  1398.                 done    = TRUE;
  1399.                 filling = FALSE;
  1400.                 break;
  1401.                 }
  1402.            case CANCEL:
  1403.                 {
  1404.                 dbox_setfield(PGMedgeDbox,FileA," ");
  1405.                 filling = FALSE;
  1406.                 break;
  1407.                 }
  1408.            default:
  1409.            break;
  1410.          }    
  1411.     }
  1412.    dbox_dispose(&PGMedgeDbox);
  1413. }
  1414. /**************************************/
  1415.  
  1416. void RunPPMrelief(void)
  1417.  
  1418. /* build the PPMrelief command  and call Runtask(cmd)*/
  1419. {
  1420.     char cmd[cmdstr];
  1421.     char Pfile[128];
  1422.     dbox PPMreliefDbox;
  1423.     BOOL filling = TRUE;
  1424.     BOOL done    = FALSE;
  1425.     int size = 128;
  1426.  
  1427.     int filetype = PBMplus;
  1428.     char *name = "<PBMfiles$Dir>.reliefOUT";
  1429.     int estsize = 256;
  1430.     char *data = "relief";
  1431.     void *fred;
  1432.  
  1433.     PPMreliefDbox = dbox_new("PPMrelief");
  1434.     dbox_raw_eventhandler(PPMreliefDbox,(dbox_raw_handler_proc)PPMreliefhandler,fred);
  1435.  
  1436.     /*dbox_raw_eventhandler(PPMreliefDbox,PPMreliefhandler,"PPMRELIEF");*/
  1437.  
  1438.     dbox_showstatic(PPMreliefDbox);
  1439.  
  1440.     while (filling)
  1441.     {
  1442.         switch (dbox_fillin(PPMreliefDbox))
  1443.         {
  1444.            case RUN:
  1445.                 {
  1446.                 dbox_getfield(PPMreliefDbox,FileA,Pfile,size);
  1447.                 saveas(filetype,name,estsize,saver_proc,0,0,data);
  1448.  
  1449.                 if ( name != outfile)
  1450.                    name = outfile;
  1451.  
  1452.                 sprintf(cmd,"<PBMtkAPP$Dir>.PPMrelief %s > %s", Pfile, name);                
  1453.                 Runtask(cmd);
  1454.                 done    = TRUE;
  1455.                 filling = FALSE;
  1456.                 break;
  1457.                 }
  1458.            case CANCEL:
  1459.                 {
  1460.                 dbox_setfield(PPMreliefDbox,FileA," ");
  1461.                 filling = FALSE;
  1462.                 break;
  1463.                 }
  1464.            default:
  1465.            break;
  1466.          }    
  1467.     }
  1468.    dbox_dispose(&PPMreliefDbox);
  1469. }
  1470. /*******************************************/
  1471.  
  1472. void RunPPMtoyuv(void)
  1473.  
  1474. /* build the PNMconvol command  and call Runtask(cmd)*/
  1475. {
  1476.     char cmd[cmdstr];
  1477.     char Pfile[128];
  1478.     dbox ToYUVDbox;
  1479.     BOOL filling = TRUE;
  1480.     BOOL done    = FALSE;
  1481.     int size = 128;
  1482.  
  1483.     int filetype = PBMplus;
  1484.     char *name = "<PBMfiles$Dir>.yuvOUT";
  1485.     int estsize = 256;
  1486.     char *data = "yuvout";
  1487.  
  1488.     ToYUVDbox = dbox_new("PPMtoyuv");
  1489.     dbox_raw_eventhandler(ToYUVDbox,(dbox_raw_handler_proc)ToYUVhandler,"TOYUV");
  1490.     dbox_showstatic(ToYUVDbox);
  1491.  
  1492.     while (filling)
  1493.     {
  1494.         switch (dbox_fillin(ToYUVDbox))
  1495.         {
  1496.            case RUN:
  1497.                 {
  1498.                 dbox_getfield(ToYUVDbox,FileA,Pfile,size);
  1499.                 saveas(filetype,name,estsize,saver_proc,0,0,data);
  1500.  
  1501.                 if ( name != outfile)
  1502.                    name = outfile;
  1503.  
  1504.                 sprintf(cmd,"<PBMtkAPP$Dir>.PPMtoyuv %s > %s" , Pfile , name);                
  1505.                 Runtask(cmd);
  1506.                 done    = TRUE;
  1507.                 filling = FALSE;
  1508.                 break;
  1509.                 }
  1510.            case CANCEL:
  1511.                 {
  1512.                 dbox_setfield(ToYUVDbox,FileA," ");  
  1513.                 filling = FALSE;
  1514.                 break;
  1515.                 }
  1516.            default:
  1517.            break;
  1518.          }    
  1519.     }
  1520.    dbox_dispose(&ToYUVDbox);
  1521. }
  1522. /******************************************************/
  1523.  
  1524.  
  1525. void RunPNMArith(void)
  1526.  
  1527. /* build the PNMArith command  and call Runtask(cmd)*/
  1528. {
  1529.     char cmd[cmdstr];
  1530.     char Afile[100];
  1531.     char Bfile[100];
  1532.     char OP[5];
  1533.  
  1534.     dbox ArithDbox;
  1535.     BOOL filling = TRUE;
  1536.     BOOL done    = FALSE;
  1537.     int size = 100;
  1538.  
  1539.     int filetype = PBMplus;
  1540.     char *name = "<PBMfiles$Dir>.arithOUT";
  1541.     int estsize = 256;
  1542.     char *data = "arithout";
  1543.  
  1544.     ArithDbox = dbox_new("PNMArith");
  1545.     dbox_raw_eventhandler(ArithDbox,(dbox_raw_handler_proc)Arithhandler,"ARITH");
  1546.     dbox_showstatic(ArithDbox);
  1547.  
  1548.     while (filling)
  1549.     {
  1550.         switch (dbox_fillin(ArithDbox))
  1551.         {
  1552.            case Plus:
  1553.                 {
  1554.                 dbox_setnumeric(ArithDbox,Plus,1);
  1555.                 dbox_setnumeric(ArithDbox,Minus,0);
  1556.                 dbox_setnumeric(ArithDbox,Mult,0);
  1557.                 sprintf(OP,"-add ");
  1558.                 break;
  1559.                 }
  1560.            case Minus:
  1561.                 {
  1562.                 dbox_setnumeric(ArithDbox,Plus,0);
  1563.                 dbox_setnumeric(ArithDbox,Minus,1);
  1564.                 dbox_setnumeric(ArithDbox,Mult,0);
  1565.                 sprintf(OP,"-sub ");
  1566.                 break;
  1567.                 }
  1568.            case Mult:
  1569.                 {
  1570.                 dbox_setnumeric(ArithDbox,Plus,0);
  1571.                 dbox_setnumeric(ArithDbox,Minus,0);
  1572.                 dbox_setnumeric(ArithDbox,Mult,1);
  1573.                 sprintf(OP,"-mul ");
  1574.                 break;
  1575.                 }
  1576.            case RUN:
  1577.                 {
  1578.                 dbox_getfield(ArithDbox,FileA,Afile,size);
  1579.                 dbox_getfield(ArithDbox,FileB,Bfile,size);
  1580.                 saveas(filetype,name,estsize,saver_proc,0,0,data);                
  1581.  
  1582.                 if ( name != outfile)
  1583.                    name = outfile;
  1584.  
  1585.                 sprintf(cmd,"<PBMtkAPP$Dir>.PNMarith %s %s %s > %s",OP,Afile,Bfile,name);                
  1586.                 Runtask(cmd);
  1587.                 filling = FALSE;
  1588.                 done    = TRUE;
  1589.                 break;
  1590.  
  1591.                 }
  1592.            case CANCEL:
  1593.                 {
  1594.                 dbox_setfield(ArithDbox,FileA," ");
  1595.                 dbox_setfield(ArithDbox,FileB," ");
  1596.                 filling = FALSE;
  1597.                 break;
  1598.                 }
  1599.            default:
  1600.            break;
  1601.          }    
  1602.     }
  1603.    dbox_dispose(&ArithDbox);
  1604. }
  1605.  
  1606. /******************************************************/
  1607.  
  1608.  
  1609. void RunPNMPaste(void)
  1610.  
  1611. /* build the PNMPaste command  and call Runtask(cmd)*/
  1612. {
  1613.     char cmd[cmdstr];
  1614.     char Afile[100];
  1615.     char Bfile[100];
  1616.     char OP[5];
  1617.  
  1618.     int x;
  1619.     int y;
  1620.  
  1621.     dbox PasteDbox;
  1622.     BOOL filling = TRUE;
  1623.     BOOL done    = FALSE;
  1624.     int size = 100;
  1625.  
  1626.     int filetype = PBMplus;
  1627.     char *name = "<PBMfiles$Dir>.pasteOUT";
  1628.     int estsize = 256;
  1629.     char *data = "pasteout";
  1630.  
  1631.     PasteDbox = dbox_new("PNMPaste");
  1632.     dbox_raw_eventhandler(PasteDbox,(dbox_raw_handler_proc)Pastehandler,"PASTE");
  1633.     dbox_showstatic(PasteDbox);
  1634.     x = dbox_getnumeric(PasteDbox,pastex);
  1635.     y = dbox_getnumeric(PasteDbox,pastey);
  1636.  
  1637.     while (filling)
  1638.     {
  1639.         switch (dbox_fillin(PasteDbox))
  1640.         {
  1641.            case minusx:
  1642.                 {
  1643.                 x = dbox_getnumeric(PasteDbox,pastex);
  1644.                 x -= 1;
  1645.                 dbox_setnumeric(PasteDbox,pastex,x);
  1646.                 break;
  1647.                 }
  1648.            case plusx:
  1649.                 {
  1650.                 x = dbox_getnumeric(PasteDbox,pastex);
  1651.                 x += 1;
  1652.                 dbox_setnumeric(PasteDbox,pastex,x);
  1653.                 break;
  1654.                 }
  1655.            case minusy:
  1656.                 {
  1657.                 y = dbox_getnumeric(PasteDbox,pastey);
  1658.                 y -= 1;
  1659.                 dbox_setnumeric(PasteDbox,pastey,y);
  1660.                 break;
  1661.                 }
  1662.            case plusy:
  1663.                 {
  1664.                 y = dbox_getnumeric(PasteDbox,pastey);
  1665.                 y += 1;
  1666.                 dbox_setnumeric(PasteDbox,pastey,y);
  1667.                 break;
  1668.                 }
  1669.            case replace:
  1670.                 {
  1671.                 dbox_setnumeric(PasteDbox,replace,1);
  1672.                 dbox_setnumeric(PasteDbox,or,0);
  1673.                 dbox_setnumeric(PasteDbox,and,0);
  1674.                 dbox_setnumeric(PasteDbox,xor,0);
  1675.                 sprintf(OP,"-rep ");
  1676.                 break;
  1677.                 }
  1678.            case or:
  1679.                 {
  1680.                 dbox_setnumeric(PasteDbox,replace,0);
  1681.                 dbox_setnumeric(PasteDbox,or,1);
  1682.                 dbox_setnumeric(PasteDbox,and,0);
  1683.                 dbox_setnumeric(PasteDbox,xor,0);
  1684.                 sprintf(OP,"-or ");
  1685.                 break;
  1686.                 }
  1687.            case and:
  1688.                 {
  1689.                 dbox_setnumeric(PasteDbox,replace,0);
  1690.                 dbox_setnumeric(PasteDbox,or,0);
  1691.                 dbox_setnumeric(PasteDbox,and,1);
  1692.                 dbox_setnumeric(PasteDbox,xor,0);
  1693.                 sprintf(OP,"-and ");
  1694.                 break;
  1695.                 }
  1696.            case xor:
  1697.                 {
  1698.                 dbox_setnumeric(PasteDbox,replace,0);
  1699.                 dbox_setnumeric(PasteDbox,or,0);
  1700.                 dbox_setnumeric(PasteDbox,and,0);
  1701.                 dbox_setnumeric(PasteDbox,xor,1);
  1702.                 sprintf(OP,"-xor ");
  1703.                 break;
  1704.                 }
  1705.            case RUN:
  1706.                 {
  1707.                 x = dbox_getnumeric(PasteDbox,pastex);
  1708.                 y = dbox_getnumeric(PasteDbox,pastey);
  1709.                 dbox_getfield(PasteDbox,FileA,Afile,size);
  1710.                 dbox_getfield(PasteDbox,FileB,Bfile,size);
  1711.                 saveas(filetype,name,estsize,saver_proc,0,0,data);                
  1712.  
  1713.                 if ( name != outfile)
  1714.                    name = outfile;
  1715.  
  1716.                 sprintf(cmd,"<PBMtkAPP$Dir>.PNMpaste %s %s %d %d %s > %s",OP,Afile,x,y,Bfile,name);                
  1717.                 Runtask(cmd);
  1718.                 filling = FALSE;
  1719.                 done    = TRUE;
  1720.                 break;
  1721.                 }
  1722.            case CANCEL:
  1723.                 {
  1724.                 dbox_setfield(PasteDbox,FileA," ");
  1725.                 dbox_setfield(PasteDbox,FileB," ");
  1726.                 filling = FALSE;
  1727.                 break;
  1728.                 }
  1729.            default:
  1730.            break;
  1731.          }    
  1732.     }
  1733.    dbox_dispose(&PasteDbox);
  1734. }
  1735.  
  1736. /******************************************************/
  1737.  
  1738.  
  1739. void RunPPMPat(void)
  1740.  
  1741. /* build the PPMPat command  and call Runtask(cmd)*/
  1742. {
  1743.     char cmd[cmdstr];
  1744.     char OP[5];
  1745.  
  1746.     int x;
  1747.     int y;
  1748.  
  1749.     dbox PatDbox;
  1750.     BOOL filling = TRUE;
  1751.  
  1752.     int filetype = PBMplus;
  1753.     char *name = "<PBMfiles$Dir>.patOUT";
  1754.     int estsize = 256;
  1755.     char *data = "patout";
  1756.  
  1757.     PatDbox = dbox_new("PPMPat");
  1758.     dbox_showstatic(PatDbox);
  1759.     x = dbox_getnumeric(PatDbox,patx);
  1760.     y = dbox_getnumeric(PatDbox,paty);
  1761.  
  1762.     while (filling)
  1763.     {
  1764.         switch (dbox_fillin(PatDbox))
  1765.         {
  1766.            case minuspatx:
  1767.                 {
  1768.                 x = dbox_getnumeric(PatDbox,patx);
  1769.                 if (x > 1) 
  1770.                    x -= 1;
  1771.                 dbox_setnumeric(PatDbox,patx,x);
  1772.                 break;
  1773.                 }
  1774.            case pluspatx:
  1775.                 {
  1776.                 x = dbox_getnumeric(PatDbox,patx);
  1777.                 x += 1;
  1778.                 dbox_setnumeric(PatDbox,patx,x);
  1779.                 break;
  1780.                 }
  1781.            case minuspaty:
  1782.                 {
  1783.                 y = dbox_getnumeric(PatDbox,paty);
  1784.                 if(y > 1)
  1785.                    y -= 1;
  1786.                 dbox_setnumeric(PatDbox,paty,y);
  1787.                 break;
  1788.                 }
  1789.            case pluspaty:
  1790.                 {
  1791.                 y = dbox_getnumeric(PatDbox,paty);
  1792.                 y += 1;
  1793.                 dbox_setnumeric(PatDbox,paty,y);
  1794.                 break;
  1795.                 }
  1796.            case ging2:
  1797.                 {
  1798.                 dbox_setnumeric(PatDbox,ging2,1);
  1799.                 dbox_setnumeric(PatDbox,ging3,0);
  1800.                 dbox_setnumeric(PatDbox,madras,0);
  1801.                 dbox_setnumeric(PatDbox,tartan,0);
  1802.                 dbox_setnumeric(PatDbox,poles,0);
  1803.                 dbox_setnumeric(PatDbox,squig,0);
  1804.                 dbox_setnumeric(PatDbox,camo,0);
  1805.                 dbox_setnumeric(PatDbox,anticamo,0);
  1806.                 sprintf(OP,"-g2  ");
  1807.                 break;
  1808.                 }
  1809.            case ging3:
  1810.                 {
  1811.                 dbox_setnumeric(PatDbox,ging2,0);
  1812.                 dbox_setnumeric(PatDbox,ging3,1);
  1813.                 dbox_setnumeric(PatDbox,madras,0);
  1814.                 dbox_setnumeric(PatDbox,tartan,0);
  1815.                 dbox_setnumeric(PatDbox,poles,0);
  1816.                 dbox_setnumeric(PatDbox,squig,0);
  1817.                 dbox_setnumeric(PatDbox,camo,0);
  1818.                 dbox_setnumeric(PatDbox,anticamo,0);
  1819.                 sprintf(OP,"-g3  ");
  1820.                 break;
  1821.                 }
  1822.            case madras:
  1823.                 {
  1824.                 dbox_setnumeric(PatDbox,ging2,0);
  1825.                 dbox_setnumeric(PatDbox,ging3,0);
  1826.                 dbox_setnumeric(PatDbox,madras,1);
  1827.                 dbox_setnumeric(PatDbox,tartan,0);
  1828.                 dbox_setnumeric(PatDbox,poles,0);
  1829.                 dbox_setnumeric(PatDbox,squig,0);
  1830.                 dbox_setnumeric(PatDbox,camo,0);
  1831.                 dbox_setnumeric(PatDbox,anticamo,0);
  1832.                 sprintf(OP,"-mad ");
  1833.                 break;
  1834.                 }
  1835.            case tartan:
  1836.                 {
  1837.                 dbox_setnumeric(PatDbox,ging2,0);
  1838.                 dbox_setnumeric(PatDbox,ging3,0);
  1839.                 dbox_setnumeric(PatDbox,madras,0);
  1840.                 dbox_setnumeric(PatDbox,tartan,1);
  1841.                 dbox_setnumeric(PatDbox,poles,0);
  1842.                 dbox_setnumeric(PatDbox,squig,0);
  1843.                 dbox_setnumeric(PatDbox,camo,0);
  1844.                 dbox_setnumeric(PatDbox,anticamo,0);
  1845.                 sprintf(OP,"-tar ");
  1846.                 break;
  1847.                 }
  1848.            case poles:
  1849.                 {
  1850.                 dbox_setnumeric(PatDbox,ging2,0);
  1851.                 dbox_setnumeric(PatDbox,ging3,0);
  1852.                 dbox_setnumeric(PatDbox,madras,0);
  1853.                 dbox_setnumeric(PatDbox,tartan,0);
  1854.                 dbox_setnumeric(PatDbox,poles,1);
  1855.                 dbox_setnumeric(PatDbox,squig,0);
  1856.                 dbox_setnumeric(PatDbox,camo,0);
  1857.                 dbox_setnumeric(PatDbox,anticamo,0);
  1858.                 sprintf(OP,"-pol ");
  1859.                 break;
  1860.                 }
  1861.            case squig:
  1862.                 {
  1863.                 dbox_setnumeric(PatDbox,ging2,0);
  1864.                 dbox_setnumeric(PatDbox,ging3,0);
  1865.                 dbox_setnumeric(PatDbox,madras,0);
  1866.                 dbox_setnumeric(PatDbox,tartan,0);
  1867.                 dbox_setnumeric(PatDbox,poles,0);
  1868.                 dbox_setnumeric(PatDbox,squig,1);
  1869.                 dbox_setnumeric(PatDbox,camo,0);
  1870.                 dbox_setnumeric(PatDbox,anticamo,0);
  1871.                 sprintf(OP,"-squ ");
  1872.                 break;
  1873.                 }
  1874.            case camo:
  1875.                 {
  1876.                 dbox_setnumeric(PatDbox,ging2,0);
  1877.                 dbox_setnumeric(PatDbox,ging3,0);
  1878.                 dbox_setnumeric(PatDbox,madras,0);
  1879.                 dbox_setnumeric(PatDbox,tartan,0);
  1880.                 dbox_setnumeric(PatDbox,poles,0);
  1881.                 dbox_setnumeric(PatDbox,squig,0);
  1882.                 dbox_setnumeric(PatDbox,camo,1);
  1883.                 dbox_setnumeric(PatDbox,anticamo,0);
  1884.                 sprintf(OP,"-cam ");
  1885.                 break;
  1886.                 }
  1887.            case anticamo:
  1888.                 {
  1889.                 dbox_setnumeric(PatDbox,ging2,0);
  1890.                 dbox_setnumeric(PatDbox,ging3,0);
  1891.                 dbox_setnumeric(PatDbox,madras,0);
  1892.                 dbox_setnumeric(PatDbox,tartan,0);
  1893.                 dbox_setnumeric(PatDbox,poles,0);
  1894.                 dbox_setnumeric(PatDbox,squig,0);
  1895.                 dbox_setnumeric(PatDbox,camo,0);
  1896.                 dbox_setnumeric(PatDbox,anticamo,1);
  1897.                 sprintf(OP,"-ant ");
  1898.                 break;
  1899.                 }
  1900.            case RUN:
  1901.                 {
  1902.                 x = dbox_getnumeric(PatDbox,patx);
  1903.                 y = dbox_getnumeric(PatDbox,paty);
  1904.                 saveas(filetype,name,estsize,saver_proc,0,0,data);
  1905.  
  1906.                 if ( name != outfile)
  1907.                    name = outfile;
  1908.  
  1909.                 sprintf(cmd,"<PBMtkAPP$Dir>.PPMPat %s %d %d > %s",OP,x,y,name);                 
  1910.                 Runtask(cmd);
  1911.                 filling = FALSE;
  1912.                 break;
  1913.                 }
  1914.            case CANCEL:
  1915.                 {
  1916.                 filling = FALSE;
  1917.                 break;
  1918.                 }
  1919.            default:
  1920.            break;
  1921.          }    
  1922.     }
  1923.    dbox_dispose(&PatDbox);
  1924. }
  1925.  
  1926. /*****************************************************************/
  1927.  
  1928.  
  1929. void RunPBMmake(void)
  1930.  
  1931.  /*build the PBMmake command  and call Runtask(cmd)*/
  1932. {
  1933.     char makecmd[cmdstr];
  1934.     char OPmake[5];
  1935.  
  1936.     int makex;
  1937.     int makey;
  1938.  
  1939.     dbox PBMmakeDbox;
  1940.     BOOL makefill = TRUE;
  1941.  
  1942.     int makefile = PBMplus;
  1943.     char *makename = "<PBMfiles$Dir>.PBMout";
  1944.     int makesize = 256;
  1945.     char *makedata = "pbmout";
  1946.  
  1947.     PBMmakeDbox = dbox_new("PBMmake");
  1948.     dbox_showstatic(PBMmakeDbox);
  1949.     makex = dbox_getnumeric(PBMmakeDbox,PBMmakex);
  1950.     makey = dbox_getnumeric(PBMmakeDbox,PBMmakey);
  1951.  
  1952.     while (makefill)
  1953.     {
  1954.         switch (dbox_fillin(PBMmakeDbox))
  1955.         {
  1956.            case PBMmakeminusx:
  1957.                 {
  1958.                 makex = dbox_getnumeric(PBMmakeDbox,PBMmakex);
  1959.                 if (makex > 1) 
  1960.                    makex -= 1;
  1961.                 dbox_setnumeric(PBMmakeDbox,PBMmakex,makex);
  1962.                 break;
  1963.                 }
  1964.            case PBMmakeplusx:
  1965.                 {
  1966.                 makex = dbox_getnumeric(PBMmakeDbox,PBMmakex);
  1967.                 makex += 1;
  1968.                 dbox_setnumeric(PBMmakeDbox,PBMmakex,makex);
  1969.                 break;
  1970.                 }
  1971.            case PBMmakeminusy:
  1972.                 {
  1973.                 makey = dbox_getnumeric(PBMmakeDbox,PBMmakey);
  1974.                 if(makey > 1)
  1975.                    makey -= 1;
  1976.                 dbox_setnumeric(PBMmakeDbox,PBMmakey,makey);
  1977.                 break;
  1978.                 }
  1979.            case PBMmakeplusy:
  1980.                 {
  1981.                 makey = dbox_getnumeric(PBMmakeDbox,PBMmakey);
  1982.                 makey += 1;
  1983.                 dbox_setnumeric(PBMmakeDbox,PBMmakey,makey);
  1984.                 break;
  1985.                 }
  1986.            case PBMmakewhite:
  1987.                 {
  1988.                 dbox_setnumeric(PBMmakeDbox,PBMmakewhite,1);
  1989.                 dbox_setnumeric(PBMmakeDbox,PBMmakeblack,0);
  1990.                 dbox_setnumeric(PBMmakeDbox,PBMmakegrey,0);
  1991.                 sprintf(OPmake,"-wh  ");
  1992.                 break;
  1993.                 }
  1994.            case PBMmakeblack:
  1995.                 {
  1996.                 dbox_setnumeric(PBMmakeDbox,PBMmakewhite,0);
  1997.                 dbox_setnumeric(PBMmakeDbox,PBMmakeblack,1);
  1998.                 dbox_setnumeric(PBMmakeDbox,PBMmakegrey,0);
  1999.                 sprintf(OPmake,"-bl  ");
  2000.                 break;
  2001.                 }
  2002.            case PBMmakegrey:
  2003.                 {
  2004.                 dbox_setnumeric(PBMmakeDbox,PBMmakewhite,0);
  2005.                 dbox_setnumeric(PBMmakeDbox,PBMmakeblack,0);
  2006.                 dbox_setnumeric(PBMmakeDbox,PBMmakegrey,1);
  2007.                 sprintf(OPmake,"-gr  ");
  2008.                 break;
  2009.                 }
  2010.            case RUN:
  2011.                 {
  2012.                 makex = dbox_getnumeric(PBMmakeDbox,PBMmakex);
  2013.                 makey = dbox_getnumeric(PBMmakeDbox,PBMmakey);
  2014.                 saveas(makefile,makename,makesize,saver_proc,0,0,makedata);
  2015.  
  2016.                 if ( makename != outfile)
  2017.                    makename = outfile;
  2018.  
  2019.                 sprintf(makecmd,"<PBMtkAPP$Dir>.PBMmake %s %d %d > %s",OPmake,makex,makey,makename);                 
  2020.                 Runtask(makecmd);
  2021.                 makefill = FALSE;
  2022.                 break;
  2023.                 }
  2024.            case CANCEL:
  2025.                 {
  2026.                 makefill = FALSE;
  2027.                 break;
  2028.                 }
  2029.            default:
  2030.            break;
  2031.          }    
  2032.     }
  2033.    dbox_dispose(&PBMmakeDbox);
  2034. }
  2035.  
  2036.  
  2037. /******************************************************/
  2038.  
  2039.  
  2040. void RunPGMcrater(void)
  2041.  
  2042. /* build the PGMcrater command  and call Runtask(cmd)*/
  2043. {
  2044.     char cmd[cmdstr];
  2045.  
  2046.     char OP1[4];
  2047.     char OP2[4];
  2048.     char OP3[4];
  2049.     char OP4[4];
  2050.  
  2051.  
  2052.     int x;
  2053.     int y;
  2054.     int num;
  2055.     int g;
  2056.     double gamma;
  2057.  
  2058.     dbox CraterDbox;
  2059.     BOOL filling = TRUE;
  2060.  
  2061.     int filetype = PBMplus;
  2062.     char *name = "<PBMfiles$Dir>.craterOUT";
  2063.     int estsize = 256;
  2064.     char *data = "craterout";
  2065.     char *gammbuf;
  2066.     int bufsiz = 6;
  2067.  
  2068.     CraterDbox = dbox_new("PGMcrater");
  2069.     dbox_showstatic(CraterDbox);
  2070.     x = dbox_getnumeric(CraterDbox,CraterX);
  2071.     y = dbox_getnumeric(CraterDbox,CraterY);
  2072.  
  2073.     sprintf(OP1,"-n ");
  2074.     sprintf(OP2,"-h ");
  2075.     sprintf(OP3,"-w ");
  2076.     sprintf(OP4,"-g ");
  2077.  
  2078.     while (filling)
  2079.     {
  2080.         switch (dbox_fillin(CraterDbox))
  2081.         {
  2082.            case CraterXminus:
  2083.                 {
  2084.                 x = dbox_getnumeric(CraterDbox,CraterX);
  2085.                 if (x > 1) 
  2086.                    x -= 1;
  2087.                 dbox_setnumeric(CraterDbox,CraterX,x);
  2088.                 break;
  2089.                 }
  2090.            case CraterXplus:
  2091.                 {
  2092.                 x = dbox_getnumeric(CraterDbox,CraterX);
  2093.                 x += 1;
  2094.                 dbox_setnumeric(CraterDbox,CraterX,x);
  2095.                 break;
  2096.                 }
  2097.            case CraterYminus:
  2098.                 {
  2099.                 y = dbox_getnumeric(CraterDbox,CraterY);
  2100.                 if(y > 1)
  2101.                    y -= 1;
  2102.                 dbox_setnumeric(CraterDbox,CraterY,y);
  2103.                 break;
  2104.                 }
  2105.            case CraterYplus:
  2106.                 {
  2107.                 y = dbox_getnumeric(CraterDbox,CraterY);
  2108.                 y += 1;
  2109.                 dbox_setnumeric(CraterDbox,CraterY,y);
  2110.                 break;
  2111.                 }
  2112.            case Craternumminus:
  2113.                 {
  2114.                 num = dbox_getnumeric(CraterDbox,Craternumber);
  2115.                 if(num > 1)
  2116.                    num -= 1;
  2117.                 dbox_setnumeric(CraterDbox,Craternumber,num);
  2118.                 break;
  2119.                 }
  2120.            case Craternumplus:
  2121.                 {
  2122.                 num = dbox_getnumeric(CraterDbox,Craternumber);
  2123.                 num += 1;
  2124.                 dbox_setnumeric(CraterDbox,Craternumber,num);
  2125.                 break;
  2126.                 }
  2127.            case Cratergammaminus:
  2128.                 {
  2129.                 /*g = dbox_getnumeric(CraterDbox,Cratergamma);
  2130.                 if(g > 0)
  2131.                    g -= 1;
  2132.                 dbox_setnumeric(CraterDbox,Cratergamma,g);*/
  2133.                 dbox_getfield(CraterDbox,Cratergamma,gammbuf,bufsiz);
  2134.                 gamma = atof(gammbuf);
  2135.                 if(gamma > 0)
  2136.                    gamma -= 0.1;
  2137.                 sprintf(gammbuf,"%f",gamma);
  2138.                 dbox_setfield(CraterDbox,Cratergamma,gammbuf);
  2139.                 break;
  2140.                 }
  2141.            case Cratergammaplus:
  2142.                 {
  2143.                 /*g = dbox_getnumeric(CraterDbox,Cratergamma);
  2144.                 g += 1;
  2145.                 dbox_setnumeric(CraterDbox,Cratergamma,g);*/
  2146.                 dbox_getfield(CraterDbox,Cratergamma,gammbuf,bufsiz);
  2147.                 gamma = atof(gammbuf);
  2148.                 gamma += 0.1;
  2149.                 sprintf(gammbuf,"%f",gamma);
  2150.                 dbox_setfield(CraterDbox,Cratergamma,gammbuf);
  2151.                 break;
  2152.                 }
  2153.            case RUN:
  2154.                 {
  2155.                 x = dbox_getnumeric(CraterDbox,CraterX);
  2156.                 y = dbox_getnumeric(CraterDbox,CraterY);
  2157.                 num = dbox_getnumeric(CraterDbox,Craternumber);
  2158.                 /*g = dbox_getnumeric(CraterDbox,Cratergamma);
  2159.                 gamma = (float) g / 10.0;*/
  2160.                 dbox_getfield(CraterDbox,Cratergamma,gammbuf,bufsiz);
  2161.                 gamma = atof(gammbuf);
  2162.  
  2163.                 saveas(filetype,name,estsize,saver_proc,0,0,data);
  2164.  
  2165.                 if ( name != outfile)
  2166.                    name = outfile;
  2167.  
  2168.                 sprintf(cmd,"<PBMtkAPP$Dir>.PGMcrater %s %d %s %d %s %d %s %2.2lf > %s",OP1,num,OP2,y,OP3,x,OP4,gamma,name);                 
  2169.                 Runtask(cmd);
  2170.                 filling = FALSE;
  2171.                 break;
  2172.                 }
  2173.            case CANCEL:
  2174.                 {
  2175.                 filling = FALSE;
  2176.                 break;
  2177.                 }
  2178.            default:
  2179.            break;
  2180.          }    
  2181.     }
  2182.    dbox_dispose(&CraterDbox);
  2183. }
  2184. /******************************************************/
  2185.  
  2186.  
  2187. void RunPNMCat(void)
  2188.  
  2189. /* build the PNMcat command  and call Runtask(cmd)*/
  2190. {
  2191.     char cmd[cmdstr];
  2192.     char Afile[550];
  2193.  
  2194.  
  2195.     char OP1[8] = " ";
  2196.     char OP2[5] = " ";
  2197.     char OP3[7] = " ";
  2198.  
  2199.     dbox CatDbox;
  2200.     BOOL filling = TRUE;
  2201.     BOOL done    = FALSE;
  2202.     int size = 550;
  2203.  
  2204.     int filetype = PBMplus;
  2205.     char *name = "<PBMfiles$Dir>.catOUT";
  2206.     int estsize = 256;
  2207.     char *data = "catout";
  2208.  
  2209.     CatDbox = dbox_new("PNMCat");
  2210.     dbox_raw_eventhandler(CatDbox,(dbox_raw_handler_proc)Cathandler,"CAT");
  2211.     dbox_showstatic(CatDbox);
  2212.  
  2213.  
  2214.  
  2215.     while (filling)
  2216.     {
  2217.         switch (dbox_fillin(CatDbox))
  2218.         {
  2219.            case White:
  2220.                 {
  2221.                 dbox_setnumeric(CatDbox,White,1);
  2222.                 dbox_setnumeric(CatDbox,Black,0);
  2223.                 strcpy(OP1,"-white ");
  2224.                 break;
  2225.                 }
  2226.            case Black:
  2227.                 {
  2228.                 dbox_setnumeric(CatDbox,White,0);
  2229.                 dbox_setnumeric(CatDbox,Black,1);
  2230.                 strcpy(OP1,"-black ");
  2231.                 break;
  2232.                 }
  2233.            case Leftright:
  2234.                 {
  2235.                 dbox_setnumeric(CatDbox,Leftright,1);
  2236.                 dbox_setnumeric(CatDbox,Topbottom,0);
  2237.                 sprintf(OP2,"-lr ");
  2238.                 break;
  2239.                 }
  2240.            case Topbottom:
  2241.                 {
  2242.                 dbox_setnumeric(CatDbox,Leftright,0);
  2243.                 dbox_setnumeric(CatDbox,Topbottom,1);
  2244.                 sprintf(OP2,"-tb ");
  2245.                 break;
  2246.                 }
  2247.            case Top:
  2248.                 {
  2249.                 dbox_setnumeric(CatDbox,Top,1);
  2250.                 dbox_setnumeric(CatDbox,Bottom,0);
  2251.                 dbox_setnumeric(CatDbox,Left,0);
  2252.                 dbox_setnumeric(CatDbox,Right,0);
  2253.                 dbox_setnumeric(CatDbox,Topbottom,0);
  2254.                 sprintf(OP3,"-jtop ");
  2255.                 break;
  2256.                 }
  2257.            case Bottom:
  2258.                 dbox_setnumeric(CatDbox,Top,0);
  2259.                 dbox_setnumeric(CatDbox,Bottom,1);
  2260.                 dbox_setnumeric(CatDbox,Left,0);
  2261.                 dbox_setnumeric(CatDbox,Right,0);
  2262.                 dbox_setnumeric(CatDbox,Topbottom,0);
  2263.                 sprintf(OP3,"-jbot ");
  2264.                 break;
  2265.            case Left:
  2266.                 dbox_setnumeric(CatDbox,Top,0);
  2267.                 dbox_setnumeric(CatDbox,Bottom,0);
  2268.                 dbox_setnumeric(CatDbox,Left,1);
  2269.                 dbox_setnumeric(CatDbox,Right,0);
  2270.                 dbox_setnumeric(CatDbox,Leftright,0);
  2271.                 sprintf(OP3,"-jlef ");
  2272.                 break;
  2273.            case Right:
  2274.                 dbox_setnumeric(CatDbox,Top,0);
  2275.                 dbox_setnumeric(CatDbox,Bottom,0);
  2276.                 dbox_setnumeric(CatDbox,Left,0);
  2277.                 dbox_setnumeric(CatDbox,Right,1);
  2278.                 dbox_setnumeric(CatDbox,Leftright,0);
  2279.                 sprintf(OP3,"-jrig ");
  2280.                 break;
  2281.            case RUN:
  2282.                 {
  2283.                 dbox_getfield(CatDbox,FileA,Afile,size);
  2284.                 saveas(filetype,name,estsize,saver_proc,0,0,data);
  2285.  
  2286.                 if ( name != outfile)
  2287.                    name = outfile;
  2288.  
  2289.                 sprintf(cmd,"<PBMtkAPP$Dir>.PNMcat %s %s %s %s > %s",OP1,OP2,OP3,Afile,name);                
  2290.                 Runtask(cmd);
  2291.                 filling = FALSE;
  2292.                 done    = TRUE;
  2293.                 break;
  2294.                 }
  2295.            case CANCEL:
  2296.                 {
  2297.                 dbox_setfield(CatDbox,FileA," ");
  2298.                 filling = FALSE;
  2299.                 break;
  2300.                 }
  2301.            default:
  2302.            break;
  2303.          }    
  2304.     }
  2305.    dbox_dispose(&CatDbox);
  2306. }
  2307. /******************************************************/
  2308.  
  2309.  
  2310. void RunPNMCut(void)
  2311.  
  2312. /* build the PNMcut command  and call Runtask(cmd)*/
  2313. {
  2314.     char cmd[cmdstr];
  2315.     char Afile[200];
  2316.  
  2317.  
  2318.     int x;
  2319.     int y;
  2320.     int width;
  2321.     int height;
  2322.  
  2323.     dbox CutDbox;
  2324.     BOOL filling = TRUE;
  2325.     BOOL done    = FALSE;
  2326.     int size = 200;
  2327.  
  2328.     int filetype = PBMplus;
  2329.     char *name = "<PBMfiles$Dir>.cutOUT";
  2330.     int estsize = 256;
  2331.     char *data = "cutout";
  2332.  
  2333.  
  2334.     CutDbox = dbox_new("PNMCut");
  2335.     dbox_raw_eventhandler(CutDbox,(dbox_raw_handler_proc)Cuthandler,"CUT");
  2336.     dbox_showstatic(CutDbox);
  2337.     x = dbox_getnumeric(CutDbox,cutx); 
  2338.     y = dbox_getnumeric(CutDbox,cuty);
  2339.     width = dbox_getnumeric(CutDbox,cutwidth);
  2340.     height = dbox_getnumeric(CutDbox,cutheight);
  2341.  
  2342.     while (filling)
  2343.     {
  2344.         switch (dbox_fillin(CutDbox))
  2345.         {
  2346.            case minuscutx:
  2347.                 {
  2348.                 x = dbox_getnumeric(CutDbox,cutx);
  2349.                 x -= 1;
  2350.                 dbox_setnumeric(CutDbox,cutx,x);
  2351.                 break;
  2352.                 }
  2353.            case pluscutx:
  2354.                 {
  2355.                 x = dbox_getnumeric(CutDbox,cutx);
  2356.                 x += 1;
  2357.                 dbox_setnumeric(CutDbox,cutx,x);
  2358.                 break;
  2359.                 }
  2360.            case minuscuty:
  2361.                 {
  2362.                 y = dbox_getnumeric(CutDbox,cuty);
  2363.                 y -= 1;
  2364.                 dbox_setnumeric(CutDbox,cuty,y);
  2365.                 break;
  2366.                 }
  2367.            case pluscuty:
  2368.                 {
  2369.                 y = dbox_getnumeric(CutDbox,cuty);
  2370.                 y += 1;
  2371.                 dbox_setnumeric(CutDbox,cuty,y);
  2372.                 break;
  2373.                 }
  2374.            case minuscutwidth:
  2375.                 {
  2376.                 width = dbox_getnumeric(CutDbox,cutwidth);
  2377.                 width -= 1;
  2378.                 dbox_setnumeric(CutDbox,cutwidth,width);
  2379.                 break;
  2380.                 }
  2381.            case pluscutwidth:
  2382.                 {
  2383.                 width = dbox_getnumeric(CutDbox,cutwidth);
  2384.                 width += 1;
  2385.                 dbox_setnumeric(CutDbox,cutwidth,width);
  2386.                 break;
  2387.                 }
  2388.            case minuscutheight:
  2389.                 {
  2390.                 height = dbox_getnumeric(CutDbox,cutheight);
  2391.                 height -= 1;
  2392.                 dbox_setnumeric(CutDbox,cutheight,height);
  2393.                 break;
  2394.                 }
  2395.            case pluscutheight:
  2396.                 {
  2397.                 height = dbox_getnumeric(CutDbox,cutheight);
  2398.                 height += 1;
  2399.                 dbox_setnumeric(CutDbox,cutheight,height);
  2400.                 break;
  2401.                 }
  2402.            case RUN:
  2403.                 {
  2404.                 x = dbox_getnumeric(CutDbox,cutx); 
  2405.                 y = dbox_getnumeric(CutDbox,cuty);
  2406.                 width = dbox_getnumeric(CutDbox,cutwidth);
  2407.                 height = dbox_getnumeric(CutDbox,cutheight);
  2408.                 dbox_getfield(CutDbox,FileA,Afile,size);
  2409.                 saveas(filetype,name,estsize,saver_proc,0,0,data);
  2410.  
  2411.                 if ( name != outfile)
  2412.                    name = outfile;
  2413.  
  2414.                 sprintf(cmd,"<PBMtkAPP$Dir>.PNMcut %d %d %d %d %s > %s",x,y,width,height,Afile,name);                
  2415.                 Runtask(cmd);
  2416.                 filling = FALSE;
  2417.                 done    = TRUE;
  2418.                 break;
  2419.                 }
  2420.            case CANCEL:
  2421.                 {
  2422.                 dbox_setfield(CutDbox,FileA," ");
  2423.                 filling = FALSE;
  2424.                 break;
  2425.                 }
  2426.            default:
  2427.            break;
  2428.          }    
  2429.  
  2430.     }
  2431.  
  2432.    dbox_dispose(&CutDbox);
  2433. }
  2434.  
  2435. /**************************************/
  2436.  
  2437. void RunYUVtoPPM(void)
  2438.  
  2439. /* build the YUVtoPPM command  and call Runtask(cmd)*/
  2440. {
  2441.     char cmd[cmdstr];
  2442.     char Afile[200];
  2443.  
  2444.     int width;
  2445.     int height;
  2446.  
  2447.     dbox YUVDbox;
  2448.     BOOL filling = TRUE;
  2449.     BOOL done    = FALSE;
  2450.     int size = 200;
  2451.  
  2452.     int filetype = PBMplus;
  2453.     char *name = "<PBMfiles$Dir>.ppmOUT";
  2454.     int estsize = 256;
  2455.     char *data = "ppmout";
  2456.  
  2457.  
  2458.     YUVDbox = dbox_new("YUVtoPPM");
  2459.     dbox_raw_eventhandler(YUVDbox,(dbox_raw_handler_proc)YUVtoPPMhandler,"YUVtoPPM");
  2460.     dbox_showstatic(YUVDbox);
  2461.     width = dbox_getnumeric(YUVDbox,YUVwidth);
  2462.     height = dbox_getnumeric(YUVDbox,YUVheight);
  2463.  
  2464.     while (filling)
  2465.     {
  2466.         switch (dbox_fillin(YUVDbox))
  2467.         {
  2468.  
  2469.            case YUVwidthminus:
  2470.                 {
  2471.                 width = dbox_getnumeric(YUVDbox,YUVwidth);
  2472.                 width -= 1;
  2473.                 dbox_setnumeric(YUVDbox,YUVwidth,width);
  2474.                 break;
  2475.                 }
  2476.            case YUVwidthplus:
  2477.                 {
  2478.                 width = dbox_getnumeric(YUVDbox,YUVwidth);
  2479.                 width += 1;
  2480.                 dbox_setnumeric(YUVDbox,YUVwidth,width);
  2481.                 break;
  2482.                 }
  2483.            case YUVheightminus:
  2484.                 {
  2485.                 height = dbox_getnumeric(YUVDbox,YUVheight);
  2486.                 height -= 1;
  2487.                 dbox_setnumeric(YUVDbox,YUVheight,height);
  2488.                 break;
  2489.                 }
  2490.            case YUVheightplus:
  2491.                 {
  2492.                 height = dbox_getnumeric(YUVDbox,YUVheight);
  2493.                 height += 1;
  2494.                 dbox_setnumeric(YUVDbox,YUVheight,height);
  2495.                 break;
  2496.                 }
  2497.            case RUN:
  2498.                 {
  2499.                 width = dbox_getnumeric(YUVDbox,YUVwidth);
  2500.                 height = dbox_getnumeric(YUVDbox,YUVheight);
  2501.                 dbox_getfield(YUVDbox,FileA,Afile,size);
  2502.                 saveas(filetype,name,estsize,saver_proc,0,0,data);
  2503.  
  2504.                 if ( name != outfile)
  2505.                    name = outfile;
  2506.  
  2507.                 sprintf(cmd,"<PBMtkAPP$Dir>.YUVtoppm %d %d %s > %s",width,height,Afile,name);                
  2508.                 Runtask(cmd);
  2509.                 filling = FALSE;
  2510.                 done    = TRUE;
  2511.                 break;
  2512.                 }
  2513.            case CANCEL:
  2514.                 {
  2515.                 dbox_setfield(YUVDbox,FileA," ");
  2516.                 filling = FALSE;
  2517.                 break;
  2518.                 }
  2519.            default:
  2520.            break;
  2521.          }    
  2522.  
  2523.     }
  2524.  
  2525.    dbox_dispose(&YUVDbox);
  2526. }
  2527.  
  2528.  
  2529. /**************************************/
  2530.  
  2531. void RunPNMtile(void)
  2532.  
  2533. /* build the PNMtile command  and call Runtask(cmd)*/
  2534. {
  2535.     char cmd[cmdstr];
  2536.     char Afile[200];
  2537.  
  2538.     int width;
  2539.     int height;
  2540.  
  2541.     dbox TileDbox;
  2542.     BOOL filling = TRUE;
  2543.     BOOL done    = FALSE;
  2544.     int size = 200;
  2545.  
  2546.     int filetype = PBMplus;
  2547.     char *name = "<PBMfiles$Dir>.tileOUT";
  2548.     int estsize = 256;
  2549.     char *data = "tileout";
  2550.  
  2551.  
  2552.     TileDbox = dbox_new("PNMtile");
  2553.     dbox_raw_eventhandler(TileDbox,(dbox_raw_handler_proc)PNMtilehandler,"PNMtile");
  2554.     dbox_showstatic(TileDbox);
  2555.     width = dbox_getnumeric(TileDbox,TileX);
  2556.     height = dbox_getnumeric(TileDbox,TileY);
  2557.  
  2558.     while (filling)
  2559.     {
  2560.         switch (dbox_fillin(TileDbox))
  2561.         {
  2562.  
  2563.            case TileXminus:
  2564.                 {
  2565.                 width = dbox_getnumeric(TileDbox,TileX);
  2566.                 width -= 1;
  2567.                 dbox_setnumeric(TileDbox,TileX,width);
  2568.                 break;
  2569.                 }
  2570.            case TileXplus:
  2571.                 {
  2572.                 width = dbox_getnumeric(TileDbox,TileX);
  2573.                 width += 1;
  2574.                 dbox_setnumeric(TileDbox,TileX,width);
  2575.                 break;
  2576.                 }
  2577.            case TileYminus:
  2578.                 {
  2579.                 height = dbox_getnumeric(TileDbox,TileY);
  2580.                 height -= 1;
  2581.                 dbox_setnumeric(TileDbox,TileY,height);
  2582.                 break;
  2583.                 }
  2584.            case TileYplus:
  2585.                 {
  2586.                 height = dbox_getnumeric(TileDbox,TileY);
  2587.                 height += 1;
  2588.                 dbox_setnumeric(TileDbox,TileY,height);
  2589.                 break;
  2590.                 }
  2591.            case RUN:
  2592.                 {
  2593.                 width = dbox_getnumeric(TileDbox,TileX);
  2594.                 height = dbox_getnumeric(TileDbox,TileY);
  2595.                 dbox_getfield(TileDbox,FileA,Afile,size);
  2596.                 saveas(filetype,name,estsize,saver_proc,0,0,data);
  2597.  
  2598.                 if ( name != outfile)
  2599.                    name = outfile;
  2600.  
  2601.                 sprintf(cmd,"<PBMtkAPP$Dir>.PNMtile %d %d %s > %s",width,height,Afile,name);                
  2602.                 Runtask(cmd);
  2603.                 filling = FALSE;
  2604.                 done    = TRUE;
  2605.                 break;
  2606.                 }
  2607.            case CANCEL:
  2608.                 {
  2609.                 dbox_setfield(TileDbox,FileA," ");
  2610.                 filling = FALSE;
  2611.                 break;
  2612.                 }
  2613.            default:
  2614.            break;
  2615.          }    
  2616.  
  2617.     }
  2618.  
  2619.    dbox_dispose(&TileDbox);
  2620. }
  2621.  
  2622. /**************************************/
  2623.  
  2624. void RunPGMenhance(void)
  2625.  
  2626. /* build the PGMenhance command  and call Runtask(cmd)*/
  2627. {
  2628.     char cmd[cmdstr];
  2629.     char Afile[200];
  2630.  
  2631.     int level;
  2632.  
  2633.  
  2634.     dbox PGMenhance;
  2635.     BOOL filling = TRUE;
  2636.     BOOL done    = FALSE;
  2637.     int size = 200;
  2638.  
  2639.     int filetype = PBMplus;
  2640.     char *name = "<PBMfiles$Dir>.pgmenhOUT";
  2641.     int estsize = 256;
  2642.     char *data = "pgmenhout";
  2643.  
  2644.  
  2645.     PGMenhance = dbox_new("PGMenhance");
  2646.     dbox_raw_eventhandler(PGMenhance,(dbox_raw_handler_proc)PGMenhancehandler,"PGMenhance");
  2647.     dbox_showstatic(PGMenhance);
  2648.     level = dbox_getnumeric(PGMenhance,enhlevel);
  2649.  
  2650.  
  2651.     while (filling)
  2652.     {
  2653.         switch (dbox_fillin(PGMenhance))
  2654.         {
  2655.  
  2656.            case enhminus:
  2657.                 {
  2658.                 level = dbox_getnumeric(PGMenhance,enhlevel);
  2659.                 if (level > 1)
  2660.                    level -= 1;
  2661.                 dbox_setnumeric(PGMenhance,enhlevel,level);
  2662.                 break;
  2663.                 }
  2664.            case enhplus:
  2665.                 {
  2666.                 level = dbox_getnumeric(PGMenhance,enhlevel);
  2667.                 if (level < 9)
  2668.                    level += 1;
  2669.                 dbox_setnumeric(PGMenhance,enhlevel,level);
  2670.                 break;
  2671.                 }
  2672.            case RUN:
  2673.                 {
  2674.                 level = dbox_getnumeric(PGMenhance,enhlevel);
  2675.                 dbox_getfield(PGMenhance,FileA,Afile,size);
  2676.                 saveas(filetype,name,estsize,saver_proc,0,0,data);
  2677.  
  2678.                 if ( name != outfile)
  2679.                    name = outfile;
  2680.  
  2681.                 sprintf(cmd,"<PBMtkAPP$Dir>.PGMenhance -%d %s > %s",level,Afile,name);                
  2682.                 Runtask(cmd);
  2683.                 filling = FALSE;
  2684.                 done    = TRUE;
  2685.                 break;
  2686.                 }
  2687.            case CANCEL:
  2688.                 {
  2689.                 dbox_setfield(PGMenhance,FileA," ");
  2690.                 filling = FALSE;
  2691.                 break;
  2692.                 }
  2693.            default:
  2694.            break;
  2695.          }    
  2696.  
  2697.     }
  2698.  
  2699.    dbox_dispose(&PGMenhance);
  2700. }
  2701.  
  2702.  
  2703. /**************************************/
  2704.  
  2705. void RunPNMscale(void)
  2706.  
  2707. /* build the PNMscale command  and call Runtask(cmd)*/
  2708. {
  2709.     char cmd[cmdstr];
  2710.     char Afile[256];
  2711.  
  2712.     int choice = 1;
  2713.     double realxyfact;
  2714.     double realxfact;
  2715.     double realyfact;
  2716.     int    intxysize;
  2717.     int    intxsize;
  2718.     int    intysize;
  2719.  
  2720.  
  2721.     dbox ScaleDbox;
  2722.     BOOL filling = TRUE;
  2723.     int size = 256;
  2724.  
  2725.     int filetype = PBMplus;
  2726.     char *name = "<PBMfiles$Dir>.scaleOUT";
  2727.     int estsize = 256;
  2728.     char *data = "scaleout";
  2729.     char *scalebuf;
  2730.     int bufsiz = 6;
  2731.  
  2732.     ScaleDbox = dbox_new("PNMscale");
  2733.     dbox_raw_eventhandler(ScaleDbox,(dbox_raw_handler_proc)PNMscalehandler,"PNMscale");
  2734.     dbox_showstatic(ScaleDbox);
  2735.  
  2736.     
  2737.  
  2738.     while (filling)
  2739.     {
  2740.         switch (dbox_fillin(ScaleDbox))
  2741.         {
  2742.  
  2743.            case regfactminus:
  2744.                 {
  2745.                 dbox_getfield(ScaleDbox,regfact,scalebuf,bufsiz);
  2746.                 realxyfact = atof(scalebuf);
  2747.                 if (realxyfact > 0.1)
  2748.                    realxyfact -= 0.1;
  2749.                 sprintf(scalebuf,"%2.1f",realxyfact);
  2750.                 dbox_setfield(ScaleDbox,regfact,scalebuf);
  2751.                 break;
  2752.                 }
  2753.            case regfactplus:
  2754.                 {
  2755.                 dbox_getfield(ScaleDbox,regfact,scalebuf,bufsiz);
  2756.                 realxyfact = atof(scalebuf);
  2757.                 realxyfact += 0.1;
  2758.                 sprintf(scalebuf,"%2.1f",realxyfact);
  2759.                 dbox_setfield(ScaleDbox,regfact,scalebuf);
  2760.                 break;
  2761.                 }
  2762.            case xfactplus:
  2763.                 {
  2764.                 dbox_getfield(ScaleDbox,xfact,scalebuf,bufsiz);
  2765.                 realxfact = atof(scalebuf);
  2766.                 realxfact += 0.1;
  2767.                 sprintf(scalebuf,"%2.1f",realxfact);
  2768.                 dbox_setfield(ScaleDbox,xfact,scalebuf);
  2769.                 break;
  2770.                 }
  2771.            case xfactminus:
  2772.                 {
  2773.                 dbox_getfield(ScaleDbox,xfact,scalebuf,bufsiz);
  2774.                 realxfact = atof(scalebuf);
  2775.                 if (realxfact > 0.1)
  2776.                    realxfact -= 0.1;
  2777.                 sprintf(scalebuf,"%2.1f",realxfact);
  2778.                 dbox_setfield(ScaleDbox,xfact,scalebuf);
  2779.                 break;
  2780.                 }
  2781.            case yfactminus:
  2782.                 {
  2783.                 dbox_getfield(ScaleDbox,yfact,scalebuf,bufsiz);
  2784.                 realyfact = atof(scalebuf);
  2785.                 if (realyfact > 0.1)
  2786.                    realyfact -= 0.1;
  2787.                 sprintf(scalebuf,"%2.1f",realyfact);
  2788.                 dbox_setfield(ScaleDbox,yfact,scalebuf);
  2789.                 break;
  2790.                 }
  2791.            case yfactplus:
  2792.                 {
  2793.                 dbox_getfield(ScaleDbox,yfact,scalebuf,bufsiz);
  2794.                 realyfact = atof(scalebuf);
  2795.                 realyfact += 0.1;
  2796.                 sprintf(scalebuf,"%2.1f",realyfact);
  2797.                 dbox_setfield(ScaleDbox,yfact,scalebuf);
  2798.                 break;
  2799.                 }
  2800.            case squareminus:
  2801.                 {
  2802.                 intxysize = dbox_getnumeric(ScaleDbox,squaresize);
  2803.                 if (intxysize > 1)
  2804.                    intxysize -= 1;
  2805.                 dbox_setnumeric(ScaleDbox,squaresize,intxysize);
  2806.                 break;
  2807.                 }
  2808.            case squareplus:
  2809.                 {
  2810.                 intxysize = dbox_getnumeric(ScaleDbox,squaresize);
  2811.                 intxysize += 1;
  2812.                 dbox_setnumeric(ScaleDbox,squaresize,intxysize);
  2813.                 break;
  2814.                 }
  2815.            case rectwidminus:
  2816.                 {
  2817.                 intxsize = dbox_getnumeric(ScaleDbox,rectwid);
  2818.                 if (intxsize > 1)
  2819.                    intxsize -= 1;
  2820.                 dbox_setnumeric(ScaleDbox,rectwid,intxsize);
  2821.                 break;
  2822.                 }
  2823.            case rectwidplus:
  2824.                 {
  2825.                 intxsize = dbox_getnumeric(ScaleDbox,rectwid);
  2826.                 intxsize += 1;
  2827.                 dbox_setnumeric(ScaleDbox,rectwid,intxsize);
  2828.                 break;
  2829.                 }
  2830.            case rectheightminus:
  2831.                 {
  2832.                 intysize = dbox_getnumeric(ScaleDbox,rectheight);
  2833.                 if (intysize > 1)
  2834.                    intysize -= 1;
  2835.                 dbox_setnumeric(ScaleDbox,rectheight,intysize);
  2836.                 break;
  2837.                 }
  2838.            case rectheightplus:
  2839.                 {
  2840.                 intysize = dbox_getnumeric(ScaleDbox,rectheight);
  2841.                 intysize += 1;
  2842.                 dbox_setnumeric(ScaleDbox,rectheight,intysize);
  2843.                 break;
  2844.                 }
  2845.            case regscale:
  2846.                 {
  2847.                 dbox_setnumeric(ScaleDbox,regscale,1);
  2848.                 dbox_setnumeric(ScaleDbox,iregfact,0);
  2849.                 dbox_setnumeric(ScaleDbox,square,0);
  2850.                 dbox_setnumeric(ScaleDbox,rect,0);
  2851.                 choice = 1;
  2852.                 break;
  2853.                 }
  2854.            case iregfact:
  2855.                 {
  2856.                 dbox_setnumeric(ScaleDbox,regscale,0);
  2857.                 dbox_setnumeric(ScaleDbox,iregfact,1);
  2858.                 dbox_setnumeric(ScaleDbox,square,0);
  2859.                 dbox_setnumeric(ScaleDbox,rect,0);
  2860.                 choice = 2;
  2861.                 break;
  2862.                 }
  2863.            case square:
  2864.                 {
  2865.                 dbox_setnumeric(ScaleDbox,regscale,0);
  2866.                 dbox_setnumeric(ScaleDbox,iregfact,0);
  2867.                 dbox_setnumeric(ScaleDbox,square,1);
  2868.                 dbox_setnumeric(ScaleDbox,rect,0);
  2869.                 choice = 3;
  2870.                 break;
  2871.                 }
  2872.            case rect:
  2873.                 {
  2874.                 dbox_setnumeric(ScaleDbox,regscale,0);
  2875.                 dbox_setnumeric(ScaleDbox,iregfact,0);
  2876.                 dbox_setnumeric(ScaleDbox,square,0);
  2877.                 dbox_setnumeric(ScaleDbox,rect,1);
  2878.                 choice = 4;
  2879.                 break;
  2880.                 }
  2881.            case RUN:
  2882.                 {
  2883.                 dbox_getfield(ScaleDbox,FileA,Afile,size);
  2884.                 saveas(filetype,name,estsize,saver_proc,0,0,data);
  2885.                 if ( name != outfile)
  2886.                    name = outfile;
  2887.                 switch (choice)
  2888.                 {
  2889.                 case 1:
  2890.                     {
  2891.                     dbox_getfield(ScaleDbox,regfact,scalebuf,bufsiz);
  2892.                     realxyfact = atof(scalebuf);
  2893.                     sprintf(cmd,"<PBMtkAPP$Dir>.PNMscale %2.1f %s > %s",realxyfact,Afile,name);                
  2894.                     Runtask(cmd);
  2895.                     filling = FALSE;
  2896.                     break;
  2897.                     }
  2898.                 case 2:
  2899.                     {
  2900.                     dbox_getfield(ScaleDbox,xfact,scalebuf,bufsiz);
  2901.                     realxfact = atof(scalebuf);
  2902.                     dbox_getfield(ScaleDbox,yfact,scalebuf,bufsiz);
  2903.                     realyfact = atof(scalebuf);
  2904.                     sprintf(cmd,"<PBMtkAPP$Dir>.PNMscale -xscale %2.1f -yscale %2.2lf %s > %s", realxfact,realyfact,Afile,name);
  2905.                     Runtask(cmd);
  2906.                     filling = FALSE;
  2907.                     break;
  2908.                     }
  2909.                  case 3:
  2910.                     {
  2911.                     intxysize = dbox_getnumeric(ScaleDbox,squaresize);
  2912.                     sprintf(cmd,"<PBMtkAPP$Dir>.PNMscale -xysize %d %d %s > %s", intxysize,intxysize,Afile,name);
  2913.                     Runtask(cmd);
  2914.                     filling = FALSE;
  2915.                     break;
  2916.                     }
  2917.                  case 4:
  2918.                     {
  2919.                     intxsize = dbox_getnumeric(ScaleDbox,rectwid);
  2920.                     intysize = dbox_getnumeric(ScaleDbox,rectheight);
  2921.                     sprintf(cmd,"<PBMtkAPP$Dir>.PNMscale -xsize %d -ysize %d %s > %s", intxsize,intysize,Afile,name);
  2922.                     Runtask(cmd);
  2923.                     filling = FALSE;
  2924.                     break;
  2925.                     }
  2926.                     break;
  2927.                   }
  2928.                  }
  2929.            case CANCEL:
  2930.                 {
  2931.                 dbox_setfield(ScaleDbox,FileA," ");
  2932.                 filling = FALSE;
  2933.                 break;
  2934.                 }
  2935.            default:
  2936.            break;
  2937.          }    
  2938.  
  2939.     }
  2940.  
  2941.    dbox_dispose(&ScaleDbox);
  2942. }
  2943.  
  2944.  
  2945. /***open the directory which is the default storage area for images***/
  2946.  
  2947. void openimagedir (void)
  2948.  
  2949. {
  2950.   wimp_eventstr   *ev;
  2951.   ev->data.msg.hdr.action = 0x0400;
  2952.   ev->data.msg.hdr.size =128;
  2953.   ev->data.msg.hdr.your_ref=0;
  2954.   sprintf(ev->data.msg.data.chars,"        <PBMtk$Dir>.PBMfiles");
  2955.   wimpt_noerr(wimp_sendmessage (wimp_ESEND, &ev->data.msg, 0));
  2956. }
  2957.  
  2958. /***************************************/
  2959. /***open the directory which is the default storage area for images***/
  2960.  
  2961. void openfiltersdir (void)
  2962.  
  2963. {
  2964.   wimp_eventstr   *ev;
  2965.   ev->data.msg.hdr.action = 0x0400;
  2966.   ev->data.msg.hdr.size =128;
  2967.   ev->data.msg.hdr.your_ref=0;
  2968.   sprintf(ev->data.msg.data.chars,"        <PBMtk$Dir>.Filters");
  2969.   wimpt_noerr(wimp_sendmessage (wimp_ESEND, &ev->data.msg, 0));
  2970. }
  2971. /***************************** WINDOW FUNCTIONS *****************************/
  2972.  
  2973.  
  2974. /*--- Create the window, yielding its handle. Return TRUE if ok. ---*/
  2975. static BOOL create_window(char *name, wimp_w *handle)
  2976. {
  2977.   wimp_wind *window;    /* Pointer to window definition */
  2978.  
  2979.   /* Find template for the window */
  2980.     window = template_syshandle(name);
  2981.     if (window == 0)
  2982.       return FALSE;
  2983.  
  2984.   /* Create the window, dealing with errors */
  2985.   return (wimpt_complain(wimp_create_wind(window, handle)) == 0);
  2986. }
  2987. /******************************************************/
  2988.  
  2989.  
  2990. /*--- Individual event routines for the window ---*/
  2991. static void example_redraw_window(wimp_w handle)
  2992. {
  2993.   /* Redrawing the window here does nothing - just go through the loop */
  2994.   int         more;
  2995.   wimp_redrawstr r;
  2996.  
  2997.   /* Start the redraw */
  2998.   r.w = handle;
  2999.   wimpt_noerr(wimp_redraw_wind(&r, &more));
  3000.  
  3001.   /* Do the redraw loop */
  3002.   while (more)
  3003.   {
  3004.     wimp_get_rectangle(&r, &more);
  3005.   }
  3006. }
  3007. /******************************************************/
  3008.  
  3009.  
  3010. static void open_window(wimp_openstr *o)
  3011. {
  3012.   /* Just pass the open request on to the wimp */
  3013.   wimpt_noerr(wimp_open_wind(o));
  3014. }
  3015.  
  3016.  
  3017.  
  3018. /*--- Event handler called on a left click on the icon. ---*/
  3019. static void example_iconclick(wimp_i icon)
  3020. {
  3021.   icon = icon; /* We don't need the handle: this stops compiler warning */
  3022.  
  3023.   /* Open the window - only one allowed */
  3024.   if (window_open)
  3025.     werr(FALSE, "Only one window may be opened");
  3026.   else
  3027.   {
  3028.     wimp_wstate  state;
  3029.  
  3030.     /* Get the state of the window */
  3031.     if (wimpt_complain(wimp_get_wind_state(win_handle, &state)) == 0)
  3032.     {
  3033.       state.o.behind = -1;          /* Make sure window is opened in front */
  3034.       wimpt_noerr(wimp_open_wind(&state.o));
  3035.       window_open = TRUE;
  3036.     }
  3037.   }
  3038. }
  3039. /******************************************************/
  3040.  
  3041.  
  3042. /*--- Display the program info box - called from the menu processor. ---*/
  3043. static void example_info_about_program(void)
  3044. {
  3045.   dbox  d;  /* Dialogue box handle */
  3046.  
  3047.   /* Create the dialogue box */
  3048.   if (d = dbox_new("ProgInfo"), d != NULL)
  3049.   {
  3050.     /* Fill in the version number */
  3051.     dbox_setfield(d, Example_info_field, Version_String);
  3052.  
  3053.     /* Show the dialogue box */
  3054.     dbox_show(d);
  3055.  
  3056.     /* Keep it on the screen as long as needed */
  3057.     dbox_fillin(d);
  3058.  
  3059.     /* Dispose of the dialogue box */
  3060.     dbox_dispose(&d);
  3061.   }
  3062. }
  3063. /******************************************************/
  3064.  
  3065.  
  3066. /*--- Event handler for the menu. ---*/
  3067. static void Icon_menuproc(void *handle, char *hit)
  3068. {
  3069.   handle = handle; /* We don't need handle: this stops compiler warning */
  3070.  
  3071.   /* Find which menu item was hit and take action as appropriate */
  3072.   switch (hit[0])
  3073.   {
  3074.     case Icon_menu_info:
  3075.       example_info_about_program();
  3076.       break;
  3077.  
  3078.     case Icon_menu_quit:
  3079.       /* Exit from the program. The wimp gets rid of the window and icon */
  3080.       exit(0);
  3081.   }
  3082. }
  3083. /******************************************************/
  3084.  
  3085.  
  3086. static menu Win_menumaker(void *handle)
  3087.  
  3088. /*---Menu maker for the window-------*/
  3089.  
  3090. {
  3091.   handle = handle;
  3092.  
  3093.  /* menu_setflags(Win_menu,Win_menu_read,0,1);
  3094.   menu_setflags(Win_menu,Win_menu_write,0,1);
  3095.   menu_setflags(Win_menu,Win_menu_pbm,0,1);
  3096.   menu_setflags(Win_menu,Win_menu_pgm,0,1);
  3097.   menu_setflags(Win_menu,Win_menu_pgm,0,1);
  3098.   menu_setflags(Win_menu,Win_menu_ppm,0,1);
  3099.   menu_setflags(Win_menu,Win_menu_help,0,1);*/
  3100.  
  3101.   menu_setflags(Rd_menu,Rd_menu_FITS,0,1);
  3102.   menu_setflags(Rd_menu,Rd_menu_RawtoPGM,0,1);
  3103.   menu_setflags(Rd_menu,Rd_menu_RawtoPPM,0,1);
  3104.  
  3105.   menu_setflags(Wr_menu,Wr_menu_toFITS,0,1);
  3106.   menu_setflags(Wr_menu,Wr_menu_toACAD,0,1);
  3107.   menu_setflags(Wr_menu,Wr_menu_toPS,0,1);
  3108.  
  3109.   /*menu_setflags(PBM_menu,PBM_menu_make,0,1);*/
  3110.  
  3111.   menu_setflags(PBM_menu,PBM_menu_mask,0,1);
  3112.   menu_setflags(PBM_menu,PBM_menu_reduce,0,1);
  3113.   menu_setflags(PBM_menu,PBM_menu_text,0,1);
  3114.  
  3115.   menu_setflags(PGM_menu,PGM_menu_Bentley,0,1);
  3116.  
  3117.   /*menu_setflags(PGM_menu,PGM_menu_Crater,0,1);*/
  3118.  
  3119.   /*menu_setflags(PGM_menu,PGM_menu_Edge,0,1);*/
  3120.  
  3121.   /*menu_setflags(PGM_menu,PGM_menu_Enhance,0,1);*/
  3122.  
  3123.   menu_setflags(PGM_menu,PGM_menu_Histo,0,1);
  3124.   menu_setflags(PGM_menu,PGM_menu_Norm,0,1);
  3125.   menu_setflags(PGM_menu,PGM_menu_Oil,0,1);
  3126.   menu_setflags(PGM_menu,PGM_menu_Ramp,0,1);
  3127.   menu_setflags(PGM_menu,PGM_menu_toPBM,0,1);
  3128.   menu_setflags(PGM_menu,PGM_menu_RGB3toPPM,0,1);
  3129.  
  3130.   menu_setflags(PPM_menu,PPM_menu_Dither,0,1);
  3131.   menu_setflags(PPM_menu,PPM_menu_Forge,0,1);
  3132.   menu_setflags(PPM_menu,PPM_menu_Histo,0,1);
  3133.   menu_setflags(PPM_menu,PPM_menu_Make,0,1);
  3134.  
  3135.   /*menu_setflags(PPM_menu,PPM_menu_Pattern,0,1);*/
  3136.  
  3137.   menu_setflags(PPM_menu,PPM_menu_Quantize,0,1);
  3138.  
  3139.  /* menu_setflags(PPM_menu,PPM_menu_Relief,0,1);
  3140.   menu_setflags(PPM_menu,PPM_menu_toPGM,0,1);*/
  3141.  
  3142.  
  3143.   menu_setflags(PNM_menu,PNM_menu_Crop,0,1);
  3144.   menu_setflags(PNM_menu,PNM_menu_Depth,0,1);
  3145.   menu_setflags(PNM_menu,PNM_menu_File,0,1);
  3146.   menu_setflags(PNM_menu,PNM_menu_Flip,0,1);
  3147.   menu_setflags(PNM_menu,PNM_menu_Gamma,0,1);
  3148.  
  3149.   /*menu_setflags(PNM_menu,PNM_menu_NoRaw,0,1);*/
  3150.  
  3151.   /*menu_setflags(PNM_menu,PNM_menu_Paste,0,1);*/
  3152.  
  3153.   menu_setflags(PNM_menu,PNM_menu_Rotate,0,1);
  3154.  
  3155.   /*menu_setflags(PNM_menu,PNM_menu_Scale,0,1);*/
  3156.  
  3157.   menu_setflags(PNM_menu,PNM_menu_Shear,0,1);
  3158.  
  3159.   /*menu_setflags(PNM_menu,PNM_menu_Tile,0,1);*/
  3160.  
  3161.   return handle;
  3162. }
  3163. /******************************************************/
  3164.  
  3165.  
  3166. /*--- Event handler for the menu. ---*/
  3167. static void Win_menuproc(void *handle, char *hit)
  3168. {
  3169.   handle = handle; /* We don't need handle: this stops compiler warning */
  3170.  
  3171.   /* Find which menu item was hit and take action as appropriate */
  3172.   switch (hit[0])
  3173.   {
  3174.     case Win_menu_read:
  3175.                       switch (hit[1])
  3176.                       {
  3177.                                 /*case Rd_menu_FITS:
  3178.                                 case Rd_menu_RawtoPGM:                               
  3179.                                 case Rd_menu_RawtoPPM:*/
  3180.                                 case Rd_menu_YUVtoPPM:
  3181.                                         RunYUVtoPPM();
  3182.                                         break;
  3183.                       }
  3184.       break;
  3185.  
  3186.     case Win_menu_write:
  3187.                      switch (hit[1])
  3188.                      {
  3189.                                /* case Wr_menu_toFITS:
  3190.                                 case Wr_menu_toACAD:
  3191.                                 case Wr_menu_toPS:*/
  3192.                                 case Wr_menu_PPMtoyuv:
  3193.                                         RunPPMtoyuv();
  3194.                                         break;
  3195.  
  3196.                      }
  3197.       break;
  3198.  
  3199.     case Win_menu_pbm:       
  3200.                      switch (hit[1])
  3201.                      {
  3202.                                 case PBM_menu_make:
  3203.                                      RunPBMmake();
  3204.                                      break;
  3205.  
  3206.                                 /*case PBM_menu_mask:
  3207.                                 case PBM_menu_reduce:
  3208.                                 case PBM_menu_text:*/
  3209.                      }
  3210.       break;
  3211.  
  3212.     case Win_menu_pgm:
  3213.                      switch (hit[1])
  3214.                      {
  3215.                                 /*case PGM_menu_Bentley:*/
  3216.  
  3217.                                 case PGM_menu_Crater:
  3218.                                         RunPGMcrater();
  3219.                                         break;
  3220.  
  3221.                                 case PGM_menu_Edge:
  3222.                                         RunPGMedge();
  3223.                                         break;
  3224.  
  3225.                                 case PGM_menu_Enhance:
  3226.                                         RunPGMenhance();
  3227.                                         break;
  3228.  
  3229.                                 /*case PGM_menu_Histo:
  3230.                                 case PGM_menu_Norm:
  3231.                                 case PGM_menu_Oil:
  3232.                                 case PGM_menu_Ramp:
  3233.                                 case PGM_menu_toPBM:
  3234.                                 case PGM_menu_RGB3toPPM:*/
  3235.                      }
  3236.       break;
  3237.  
  3238.     case Win_menu_ppm:
  3239.                      switch (hit[1])
  3240.                      {
  3241.                                 /*case PPM_menu_Dither:
  3242.                                 case PPM_menu_Forge:
  3243.                                 case PPM_menu_Histo:
  3244.                                 case PPM_menu_Make:*/
  3245.  
  3246.                                 case PPM_menu_Pattern:
  3247.                                         RunPPMPat();
  3248.                                         break;
  3249.  
  3250.                                 /*case PPM_menu_Quantize:*/
  3251.  
  3252.                                 case PPM_menu_Relief:
  3253.                                         RunPPMrelief();
  3254.                                         break;
  3255.  
  3256.                                 case PPM_menu_toPGM:
  3257.                                         RunPPMtopgm();
  3258.                                         break;
  3259.  
  3260.                      }
  3261.       break;
  3262.  
  3263.      case Win_menu_pnm:
  3264.                      switch (hit[1])
  3265.                      {
  3266.                         case PNM_menu_Arith:
  3267.                                 RunPNMArith();
  3268.                                 break;
  3269.  
  3270.                         case PNM_menu_Concat:
  3271.                                 RunPNMCat();
  3272.                                 break;
  3273.  
  3274.                         case PNM_menu_Convol:
  3275.                                 RunPNMConvol();
  3276.                                 break;
  3277.                         case PNM_menu_Cut:
  3278.                                 RunPNMCut();
  3279.                                 break;
  3280.                         case PNM_menu_Paste:
  3281.                                 RunPNMPaste();
  3282.                                 break;
  3283.                         case PNM_menu_NoRaw:
  3284.                                 RunPNMnoraw();
  3285.                                 break;
  3286.                         case PNM_menu_Scale:
  3287.                                 RunPNMscale();
  3288.                                 break;
  3289.                         case PNM_menu_Tile:
  3290.                                 RunPNMtile();
  3291.                                 break;
  3292.                      }
  3293.     case Win_menu_help:
  3294.       break;
  3295.  
  3296.     case Win_menu_images:
  3297.       openimagedir();
  3298.       break;
  3299.  
  3300.     case Win_menu_filters:
  3301.       openfiltersdir();
  3302.       break;
  3303.  
  3304.     case Win_menu_quit:
  3305.       exit(0);
  3306.       break;
  3307.  
  3308.  
  3309.     default:
  3310.       break;
  3311.   }
  3312. }
  3313. /******************************************************/
  3314.  
  3315.  
  3316. /*--- Event handler for window. ---*/
  3317. static void PBMtk_win_event_handler(wimp_eventstr *e, void *handle)
  3318. {
  3319.   handle = handle; /* We don't need handle: this stops compiler warning */
  3320.  
  3321.   /* Deal with event */
  3322.   switch (e->e)
  3323.   {
  3324.     case wimp_EREDRAW:
  3325.       example_redraw_window(e->data.o.w);
  3326.       break;
  3327.  
  3328.     case wimp_EOPEN:
  3329.       open_window(&e->data.o);
  3330.       break;
  3331.  
  3332.     case wimp_ECLOSE:  /* Pass on close request */
  3333.       wimpt_noerr(wimp_close_wind(e->data.o.w));
  3334.       window_open = FALSE;
  3335.  
  3336.     case wimp_EUSERDRAG:
  3337.        /*werr(0,"EUSERDRAG");*/
  3338.        switch (e->data.msg.hdr.action)
  3339.           case wimp_MDATASAVE:
  3340.             {
  3341.                /*werr(0,"datasave message");*/
  3342.                break;
  3343.             } 
  3344.     default:   /* Ignore any other event */
  3345.       break;
  3346.   }
  3347. }
  3348.  
  3349. /****************************** INITIALISATION ******************************/
  3350.  
  3351. /*--- Initialise the program, returning TRUE if it was all OK. ---*/
  3352. static BOOL PBMtk_initialise(void)
  3353. {
  3354.   /* RISC_OSlib initialisation */
  3355.   wimpt_init("PBMtk");             /* Main Wimp initialisation */
  3356.   res_init("PBMtk");               /* Resources */
  3357.   resspr_init();                   /* Application sprites */
  3358.   template_init();                 /* Templates */
  3359.   dbox_init();                     /* Dialogue boxes */
  3360.   win_init();                      /* window event system */
  3361.   visdelay_init();
  3362.  
  3363.   /* Create the main window, and declare its event handler */
  3364.   if (!create_window("Output", &win_handle))
  3365.     return FALSE; /* Window creation failed */
  3366.   win_register_event_handler(win_handle, PBMtk_win_event_handler, 0);
  3367.  
  3368.  
  3369.   /* Create the menu tree */
  3370.   if (Icon_menu = menu_new("PBMtk", ">Info,Quit"), Icon_menu == NULL)
  3371.     return FALSE; /* Menu create failed */
  3372.  
  3373.   if (Win_menu = menu_new("PBMtk","Readin,Writeout|PBM,PGM,PPM,PNM|Help,Images,Filters,Quit"), Win_menu == NULL)
  3374.     return FALSE; /* Menu create failed */
  3375.  
  3376.   if (Rd_menu = menu_new("Readin","FITStoPGM,RawtoPGM,RawtoPPM,YUVtoPPM"),Rd_menu == NULL)
  3377.     return FALSE; /* menu create failed*/
  3378.  
  3379.   menu_submenu(Win_menu,Win_menu_read,Rd_menu);
  3380.  
  3381.   if (Wr_menu = menu_new("Writeout","PGMtoFITS,PPMtoACAD,PNMtoPS,PPMtoYUV"),Wr_menu == NULL)
  3382.     return FALSE; /* menu create failed */
  3383.  
  3384.   menu_submenu(Win_menu,Win_menu_write,Wr_menu);
  3385.  
  3386.   if(PBM_menu = menu_new("PBM","Make,Mask,Reduce,Text"),PBM_menu == NULL)
  3387.     return FALSE; /* menu create failed */
  3388.  
  3389.   menu_submenu(Win_menu,Win_menu_pbm,PBM_menu);
  3390.  
  3391.   if(PGM_menu = menu_new("PGM","Bentley,Crater,Edge,Enhance,Histogram,Normalize,Oil,Ramp,To-PBM,RGB3toPPM"),PGM_menu == NULL)
  3392.     return FALSE; /* menu create failed */
  3393.  
  3394.   menu_submenu(Win_menu,Win_menu_pgm,PGM_menu);
  3395.  
  3396.    if(PPM_menu = menu_new("PPM","Dither,Forge,Histogram,Make,Pattern,Quantize,Relief,To-PGM"),PPM_menu == NULL)
  3397.     return FALSE; /* menu create failed */
  3398.  
  3399.    menu_submenu(Win_menu,Win_menu_ppm,PPM_menu);
  3400.  
  3401.     if(PNM_menu = menu_new("PNM","Arithmetic,Concatenate,Convolution,Crop,Cut,Depth,File,Flip,Gamma,NoRaw,Paste,Rotate,Scale,Shear,Tile"),PNM_menu == NULL)
  3402.      return FALSE; /* menu create failed */
  3403.  
  3404.     menu_submenu(Win_menu,Win_menu_pnm,PNM_menu);
  3405.  
  3406.   /* Set up the icon on the icon bar, and declare its event handlers */
  3407.   baricon("!PBMtk", (int)resspr_area(), example_iconclick);
  3408.   if (!event_attachmenu(win_ICONBAR, Icon_menu, Icon_menuproc, 0))
  3409.     return FALSE; /* Unable to attach menu */
  3410.  
  3411.   if (!event_attachmenumaker(win_handle, Win_menumaker, Win_menuproc, Win_menu))
  3412.     return FALSE; /* Unable to attach menu */
  3413.  
  3414.   /* All went ok */
  3415.   return TRUE;
  3416. }
  3417.  
  3418. /******************************* MAIN PROGRAM ********************************/
  3419.  
  3420. /*--- Main entry point. ---*/
  3421. int main()
  3422. {
  3423.   if (PBMtk_initialise())
  3424.   {
  3425.     /* The main event loop */
  3426.     while (TRUE)
  3427.       event_process();
  3428.   }
  3429.  
  3430.   return 0;
  3431. }
  3432.