home *** CD-ROM | disk | FTP | other *** search
/ Atari Mega Archive 1 / Atari Mega Archive - Volume 1.iso / gnu / gscript / gs261s.zoo / atari / gp_atari.c < prev    next >
Encoding:
C/C++ Source or Header  |  1994-01-06  |  70.1 KB  |  3,161 lines
  1. /* Copyright (C) 1989, 1992, 1993 Aladdin Enterprises.  All rights reserved.
  2.  
  3. This file is part of Ghostscript.
  4.  
  5. Ghostscript is distributed in the hope that it will be useful, but
  6. WITHOUT ANY WARRANTY.  No author or distributor accepts responsibility
  7. to anyone for the consequences of using it or for whether it serves any
  8. particular purpose or works at all, unless he says so in writing.  Refer
  9. to the Ghostscript General Public License for full details.
  10.  
  11. Everyone is granted permission to copy, modify and redistribute
  12. Ghostscript, but only under the conditions described in the Ghostscript
  13. General Public License.  A copy of this license is supposed to have been
  14. given to you along with Ghostscript so you can know your rights and
  15. responsibilities.  It should be in a file named COPYING.  Among other
  16. things, the copyright notice and this notice must be preserved on all
  17. copies.  */
  18.  
  19. /* gp_atari.c */
  20.  
  21. /* Atari-specific routines for Ghostscript */
  22.  
  23. #include "gp_atari.h"
  24.  
  25. /* popen isn't POSIX-standard, so we declare it here. */
  26.  
  27. extern FILE *popen();
  28. extern int pclose();
  29. extern char *getenv(P1(const char *));
  30.  
  31. extern void gs_exit(P1(int exit_status));    /* from gsmain.c */
  32. extern stream *gs_stream_stdin;            /* from zfiledev.c */
  33. extern stream *gs_stream_stdout;        /* from zfiledev.c */
  34. extern stream *gs_stream_stderr;        /* from zfiledev.c */
  35.  
  36. extern int plot_x, plot_y, step_dx, step_dy;    /* from gdevvdi.c */
  37. extern int width, height;            /* from gdevvdi.c */
  38.  
  39. /* Use a pseudo file device to get win_stdio_init called at the right time. */
  40. /* This is bad architecture; we'll fix it later. */
  41.  
  42. private fdev_proc_init(win_std_init);
  43. private int win_std_read_buf();
  44. private int win_std_write_buf();
  45. private int cons_redraw(int, TEXTWIN *);
  46. private int objw_redraw(int, OBJECT *, WINDOW *);
  47. private int form_redraw(int, WINDOW *);
  48.  
  49. const file_device gs_fdev_wstdio = {
  50.     "wstdio", {
  51.     win_std_init, fdev_no_open_device,
  52.     fdev_no_open_file, fdev_no_fopen, fdev_no_fclose,
  53.     fdev_no_delete_file, fdev_no_rename_file,
  54.     fdev_no_enumerate_files }
  55. };
  56.  
  57. WINDOW twin = {
  58.     0,
  59.     T_GADGETS,
  60.     0,
  61.     T_TITL,
  62.     {0, 0, 0, 0},
  63.     {0, 0, 0, 0},
  64.     {0, 0, 0, 0},
  65.     {0, 0, 0, 0},
  66.     cons_redraw
  67. };
  68.  
  69. TEXTWIN cons = {
  70.     &twin,
  71.     {},
  72.     0,
  73.     0,
  74.     0, 0,
  75.     0, 0,
  76.     0,
  77.     0, 0,
  78.     0, 0,
  79.     0, 0,
  80.     0, LINES-1,
  81.     0, INITLINES-1,
  82.     0, 0,
  83.     0
  84. };
  85.  
  86. WINDOW icon = {
  87.     0,
  88.     I_GADGETS,
  89.     0,
  90.     I_TITL,
  91.     {0, 0, 0, 0},
  92.     {0, 0, 0, 0},
  93.     {0, 0, 0, 0},
  94.     {0, 0, 0, 0},
  95.     objw_redraw
  96. };
  97.  
  98. WINDOW dial = {
  99.     0,
  100.     D_GADGETS,
  101.     0,
  102.     D_TITL,
  103.     {0, 0, 0, 0},
  104.     {0, 0, 0, 0},
  105.     {0, 0, 0, 0},
  106.     {0, 0, 0, 0},
  107.     objw_redraw
  108. };
  109.  
  110. WINDOW imag = {
  111.     0,
  112.     W_GADGETS,
  113.     0,
  114.     W_TITL,
  115.     {0, 0, 0, 0},
  116.     {0, 0, 0, 0},
  117.     {0, 0, 0, 0},
  118.     {0, 0, 0, 0},
  119.     form_redraw
  120. };
  121.  
  122. void GetPalette(), SetPalette();
  123.  
  124. short GSPalette=0;
  125. uint PaletteSize=0;
  126. int *Palette, *OldPalette;
  127. int *ColorReg;
  128.  
  129. char command[MAXLEN]="";            /* GS command string      */
  130. char infile[MAXLEN]="";                /* input file          */
  131. char current_dir[MAXLEN]="";            /* current directory      */
  132. char dir_spec[MAXLEN]="";            /* used for file selector */
  133. char file_sel[MAXLEN]="";            /* selected file      */
  134. char *sptr;                    /* generic string pointer */
  135.  
  136. gx_color_value MaxRGB;
  137. int ChangeX, ChangeY;
  138.  
  139. /* GEM variables. */
  140.  
  141. short TrueColor=0;
  142. short Chunky8=0;
  143. short Gdebug=0, Debug8=0, Debug16=0;
  144.  
  145. ushort SendMsg[8];
  146.  
  147. int ApId, ExitButton;
  148. int XRes, YRes, ColorBits;
  149. int msgbuff[8], pxy[8];
  150. int GemHandle, VdiHandle;
  151. int window=1;
  152.  
  153. char    prgname[] = "  ST-GS";                    /* CF */
  154. int    MultiTOS = 0;                /* true : AES-Version >=0x400 */
  155. #ifdef USE_RSC                    /* use resource-file */
  156. OBJECT    *menu, *about, *noghost;
  157. #endif
  158.  
  159. float AspectRatio;
  160.  
  161. GRECT full;
  162.  
  163. MFDB plane_image, image, screen;
  164.  
  165. /* Do platform-dependent initialization. */
  166.  
  167. void
  168. gp_init(void)
  169. {
  170.     char *env;
  171.  
  172.     int i, j;
  173.     int wchar, hchar, wbox, hbox;
  174.     int work_out[57], rgb[3];
  175.     int work_in[11] = {1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2};
  176.  
  177.     /* Check the GS_WIN environment variable to decide what to
  178.      * do about windows. Windows are used unless GS_WIN contains
  179.      * the string "off".
  180.      */
  181.  
  182.     if ((env = getenv("GS_WIN")) != NULL) {
  183.     if (!strcmp(env, "off") || !strcmp(env, "OFF")) {
  184.         window = 0;        
  185.         }
  186.     }
  187.  
  188.     /* Check the GS_DISPLAY environment variable. Chunky8/16
  189.      * tell the screen driver that the screen hardware uses chunky
  190.      * pixel format (each pixel is one byte or one word). This
  191.      *  knowledge allows some image transformations to be skipped.
  192.      */
  193.  
  194.     if ((env = getenv("GS_DISPLAY")) != NULL) {
  195.     if (!strcmp(env, "chunky8") || !strcmp(env, "CHUNKY8")) {
  196.         Chunky8 = 1;
  197.     }
  198.     }
  199.  
  200.     if ((env = getenv("GS_DEBUG")) != NULL) {
  201.     if (!strcmp(env, "gdebug")) {
  202.         Gdebug = 1;
  203.     }
  204.     else if (!strcmp(env, "debug8")) {
  205.         Debug8 = 1;
  206.     }
  207.     else if (!strcmp(env, "debug16")) {
  208.         Debug16 = 1;
  209.     }
  210.     }
  211.  
  212.     /* Find the current directory. */
  213.  
  214.     getcwd(current_dir, MAXLEN);
  215.     while ((sptr = strchr(current_dir, '/')) != NULL) {
  216.        *sptr = '\\';    /* change forward to backward slashes */
  217.     }
  218.     strcat(current_dir, "\\");
  219.  
  220.     /* Call appl_init() to initialize the aes before using any aes
  221.      * functions.
  222.      */
  223.  
  224.     if ((ApId = appl_init()) == -1) {
  225.     eprintf("stvdi_open: appl_init() failed!\n");
  226.     gs_exit(-1);
  227.     }
  228.  
  229.     MultiTOS = (gl_ap_version >= 0x400);            /* CF */
  230.     
  231.     /* Open a virtual workstation and get the screen resolution. */
  232.  
  233.     GemHandle = graf_handle(&wchar, &hchar, &wbox, &hbox);
  234.     VdiHandle = GemHandle;
  235.     v_opnvwk(work_in, &VdiHandle, work_out);
  236.  
  237.     if (VdiHandle == 0) {
  238.     eprintf("stvdi_open: Could not open virtual screen workstation");
  239.     gs_exit(-1);
  240.     }
  241.  
  242.     /* Get the character size, screen resolution, aspect ratio, and
  243.      * palette size.
  244.      */
  245.  
  246.     cons.wc = wchar;
  247.     cons.hc = hchar;
  248.  
  249.     XRes = work_out[0];
  250.     YRes = work_out[1];
  251.  
  252.     AspectRatio = (float)(work_out[3])/(float)(work_out[4]);
  253.  
  254.     /* Get the number of color planes. */
  255.  
  256.     vq_extnd(VdiHandle, 1, work_out);
  257.  
  258.     if (Debug8) {
  259.     ColorBits = 8;
  260.     }
  261.     else if (Debug16) {
  262.     ColorBits = 16;
  263.     }
  264.     else {
  265.     ColorBits = work_out[4];
  266.     }
  267.  
  268.     TrueColor = (!work_out[5] || (ColorBits >= 16));
  269.  
  270.     if ((env = getenv("GS_DISPLAY")) != NULL) {
  271.     if (!strcmp(env, "truecolor")) {
  272.         TrueColor = 1;        
  273.         }
  274.     }
  275.  
  276.     if (ColorBits != 1 && ColorBits != 2 &&
  277.     ColorBits != 4 && ColorBits != 8 && ColorBits != 16) {
  278.     eprintf1("stvdi_open: %d bit color is not supported.\n", ColorBits);
  279.     gs_exit(-1);
  280.     }
  281.  
  282.     MaxRGB = DITH_RGB(ColorBits) - 1;
  283.     
  284.     if ((ColorBits > 1) && !TrueColor) {
  285.  
  286.     int psize;
  287.  
  288.     psize = (int)(pow(2, ColorBits) + .5);
  289.     PaletteSize = 3 * psize;
  290.  
  291.     /* Set up the palette--a sequence of rgb values. */
  292.  
  293.     if ((Palette = (int *)gs_malloc((uint)PaletteSize,
  294.         sizeof(int), "Palette")) == NULL) {
  295.         eprintf("stvdi_open: No memory for color palette!\n");
  296.         gs_exit(-1);
  297.     }
  298.  
  299.     if ((OldPalette = (int *)gs_malloc((uint)PaletteSize,
  300.         sizeof(int), "OldPalette")) == NULL) {
  301.         eprintf("stvdi_open: No memory for color palette!\n");
  302.         gs_exit(-1);
  303.     }
  304.  
  305.     if ((ColorReg = (int *)gs_malloc((uint)psize,
  306.         sizeof(int), "ColorReg")) == NULL) {
  307.         eprintf("stvdi_open: No memory for color map array!\n");
  308.         gs_exit(-1);
  309.     }
  310.  
  311.     if (Debug8) {
  312.  
  313.         Palette[0] = 0;
  314.         Palette[1] = 0;
  315.         Palette[2] = 0;
  316.  
  317.         for (i=3; i<PaletteSize; i++) {
  318.         Palette[i] = 1;
  319.         }
  320.  
  321.     }
  322.     else {
  323.  
  324.         /* Fill the array ColorReg. The value of ColorReg[i]
  325.          * will be the hardware color register which corresponds
  326.          * to the ith vdi color index.
  327.          */
  328.  
  329.         reg_to_index(ColorReg, ColorBits, psize);
  330.  
  331.         GetPalette(psize, Palette);        /* Get the current palette. */
  332.         GetPalette(psize, OldPalette);    /* Save it for restoration. */
  333.         GSPalette = 1;
  334.  
  335.     }
  336.  
  337.     }
  338.  
  339.     if (Gdebug) {
  340.     eprintf1("Color Bits   = %ld\n", ColorBits);
  341.     eprintf1("True Color   = %ld\n", TrueColor);
  342.     eprintf1("Max RGB      = %ld\n", MaxRGB);
  343.     eprintf1("Palette Size = %ld\n", PaletteSize);
  344.     }
  345.  
  346.     /* Window initialization. */
  347.  
  348.     if (window) {
  349.  
  350.     wind_get(0, WF_WORKXYWH,
  351.         &full.g_x, &full.g_y,
  352.         &full.g_w, &full.g_h);
  353.  
  354.     /* Set up the image window. */
  355.  
  356.     imag.handle = wind_create(imag.gadgets + (MultiTOS ? SMALLER : 0),
  357.         full.g_x, full.g_y,
  358.         full.g_w, full.g_h);
  359.  
  360.     if (imag.handle == -1) {
  361.         form_alert(1,
  362.         "[3][Fatal Error !|Window not available.][Abort]");
  363.         gs_exit(-1);
  364.     }
  365.  
  366.     wind_set(imag.handle, WF_NAME, imag.title, imag.title, 0, 0);
  367.  
  368.     wind_set(imag.handle, WF_CURRXYWH,             /* CF */
  369.         5, 25, 100, 60);        /* initial window-size !!*/
  370.         
  371.     wind_get(imag.handle, WF_WORKXYWH,
  372.         &imag.canvas.g_x, &imag.canvas.g_y,
  373.         &imag.canvas.g_w, &imag.canvas.g_h);
  374.  
  375.     /* Set up the console window. */
  376.  
  377.     wind_calc(0, cons.win->gadgets, full.g_x, full.g_y,
  378.         (COLUMNS + 4)*cons.wc, (LINES + 1)*cons.hc,
  379.         &cons.win->mframe.g_x, &cons.win->mframe.g_y,
  380.         &cons.win->mframe.g_w, &cons.win->mframe.g_h);
  381.  
  382.     cons.win->handle = wind_create(
  383.         cons.win->gadgets + (MultiTOS ? SMALLER : 0),
  384.         cons.win->mframe.g_x, cons.win->mframe.g_y,
  385.         MIN(cons.win->mframe.g_w, full.g_w),
  386.         MIN(cons.win->mframe.g_h, full.g_h));
  387.  
  388.     if (cons.win->handle == -1) {
  389.         form_alert(1,
  390.         "[3][Fatal Error !|Window not available.][Abort]");
  391.         gs_exit(-1);
  392.     }
  393.  
  394.     wind_set(cons.win->handle, WF_NAME, cons.win->title,
  395.          cons.win->title, 0, 0);
  396.  
  397.     /* Set up the icon window. */
  398.  
  399.     icon.handle = wind_create(icon.gadgets,
  400.         full.g_x, full.g_y,
  401.         full.g_w, full.g_h);
  402.  
  403.     if (icon.handle == -1) {
  404.         form_alert(1,
  405.         "[3][Fatal Error !|Window not available.][Abort]");
  406.         gs_exit(-1);
  407.     }
  408.  
  409.     wind_set(icon.handle, WF_NAME, icon.title, icon.title, 0, 0);
  410.  
  411.  
  412. #ifdef USE_RSC                            /* CF */
  413.     {
  414.         char    name[255];
  415.         
  416.         (void) strcpy(name, current_dir);
  417.         (void) strcat(name, rscname);
  418.         if (rsrc_load(name))
  419.         {
  420.             rsrc_gaddr(R_TREE, MENUBAR, &menu);
  421.             rsrc_gaddr(R_TREE, ABOUTBOX, &about);
  422.             rsrc_gaddr(R_TREE, ICONBOX, &noghost);
  423.         }
  424.         else
  425.         {
  426.                   (void) form_alert(1,
  427.                 "[3][Fatal Error !|Can't load resource.][Abort]");
  428.             gs_exit(-1);
  429.         }
  430.     }
  431. #else
  432.     /* Fix object sizes for current resolution. */
  433.  
  434.     objc_fix(menu);
  435.     objc_fix(about);
  436.     for(i=0; i<2; i++) rsrc_obfix(noghost, i);
  437. #endif
  438.  
  439.     icon.canvas.g_x = noghost[0].ob_x = full.g_w / 2;
  440.     icon.canvas.g_y = noghost[0].ob_y = full.g_h / 2;
  441.     icon.canvas.g_w = noghost[0].ob_width;
  442.     icon.canvas.g_h = noghost[0].ob_height;
  443.  
  444.     wind_calc(0, icon.gadgets,
  445.         icon.canvas.g_x, icon.canvas.g_y,
  446.         icon.canvas.g_w, icon.canvas.g_h,
  447.         &icon.frame.g_x, &icon.frame.g_y,
  448.         &icon.frame.g_w, &icon.frame.g_h);
  449.  
  450.     icon.frame.g_x = full.g_w - icon.frame.g_w - 5;
  451.     icon.frame.g_y = full.g_y + 5;
  452.  
  453.     wind_calc(1, icon.gadgets,
  454.         icon.frame.g_x, icon.frame.g_y,
  455.         icon.frame.g_w, icon.frame.g_h,
  456.         &icon.canvas.g_x, &icon.canvas.g_y,
  457.         &icon.canvas.g_w, &icon.canvas.g_h);
  458.  
  459.     noghost[0].ob_x = icon.canvas.g_x;
  460.     noghost[0].ob_y = icon.canvas.g_y;
  461.  
  462.     /* Set up the dialog window. */
  463.  
  464.     dial.handle = wind_create(dial.gadgets,
  465.         full.g_x, full.g_y,
  466.         full.g_w, full.g_h);
  467.  
  468.     if (dial.handle == -1) {
  469.         form_alert(1,
  470.         "[3][Fatal Error !|Window not available.][Abort]");
  471.         gs_exit(-1);
  472.     }
  473.  
  474.     wind_set(dial.handle, WF_NAME, dial.title, dial.title, 0, 0);
  475.  
  476.     }
  477.  
  478.     /* Display the menu and open the console window. */
  479.  
  480.     if (window && !cons.win->opened) {
  481.  
  482.     int dummy;
  483.  
  484.     restore_bg();
  485.     graf_mouse(M_OFF, 0L );
  486.  
  487.     menu_bar(menu, 1);
  488.  
  489.     if (MultiTOS)                        /* CF */
  490.     {
  491.         menu_register(gl_apid, prgname);
  492.         menu_ienable(menu, ICON, 0);        /* use iconifier! */
  493.     }    
  494.     
  495.     wind_calc(0, cons.win->gadgets, full.g_x, full.g_y,
  496.         (COLUMNS + 4)*cons.wc, (INITLINES + 1)*cons.hc,
  497.         &cons.win->frame.g_x, &cons.win->frame.g_y,
  498.         &cons.win->frame.g_w, &cons.win->frame.g_h);
  499.  
  500.     cons.win->frame.g_x = full.g_x;
  501.     cons.win->frame.g_y = full.g_y;
  502.  
  503.     wind_open(cons.win->handle,
  504.         cons.win->frame.g_x, cons.win->frame.g_y,
  505.         MIN(cons.win->frame.g_w, full.g_w),
  506.         MIN(cons.win->frame.g_h, full.g_h));
  507.     cons.win->opened = 1;
  508.  
  509.     wind_get(cons.win->handle, WF_CURRXYWH,
  510.         &cons.win->oframe.g_x, &cons.win->oframe.g_y,
  511.         &cons.win->oframe.g_w, &cons.win->oframe.g_h);
  512.  
  513.     wind_get(cons.win->handle, WF_WORKXYWH,
  514.         &cons.win->canvas.g_x, &cons.win->canvas.g_y,
  515.         &cons.win->canvas.g_w, &cons.win->canvas.g_h);
  516.  
  517.     cons.edge = cons.win->canvas.g_x;
  518.     cons.top = cons.win->canvas.g_y;
  519.  
  520.     cons.xoff = cons.wc/2;
  521.     cons.yoff = cons.hc/2;
  522.  
  523.     cons.lins = visible_lines();
  524.     cons.cols = visible_cols();
  525.     cons.ldl = cons.fdl + cons.lins - 1;
  526.  
  527.     cons.cx = align(cons.edge + cons.xoff);
  528.     cons.cy = cons.top + cons.yoff;
  529.  
  530.     vst_alignment(VdiHandle, 0, 5, &dummy, &dummy);
  531.  
  532.     clear_win(&cons.win->canvas);
  533.     update_scroll(cons.win->handle);
  534.  
  535.     graf_mouse(BUSY_BEE, 0L);
  536.     graf_mouse(M_ON, 0L);
  537.  
  538.     }
  539.  
  540. }
  541.  
  542. void GetPalette(int DefinedColors, int *Palette)
  543. {
  544.     int ColorIndex;
  545.     int ColorEntry[3];
  546.  
  547.     for (ColorIndex = 0; ColorIndex < DefinedColors; ColorIndex++) {
  548.     vq_color(VdiHandle, ColorIndex, DEFINED_INTENSITY, ColorEntry);
  549.  
  550.     Palette[3*ColorIndex]   = ColorEntry[0];
  551.     Palette[3*ColorIndex+1] = ColorEntry[1];
  552.     Palette[3*ColorIndex+2] = ColorEntry[2];
  553.       
  554.     }
  555. }
  556.  
  557. void SetPalette(int DefinedColors, int *Palette)
  558. { 
  559.   
  560.     int ColorIndex;
  561.     int ColorEntry[3];
  562.  
  563.     for (ColorIndex = 0; ColorIndex < DefinedColors; ColorIndex++) {
  564.     ColorEntry[0] = Palette[3*ColorIndex];
  565.     ColorEntry[1] = Palette[3*ColorIndex+1];
  566.     ColorEntry[2] = Palette[3*ColorIndex+2];
  567.   
  568.     vs_color(VdiHandle, ColorIndex, ColorEntry);
  569.     }
  570. }
  571.  
  572. /* Do platform-dependent cleanup */
  573.  
  574. void
  575. gp_exit(int exit_status, int code)
  576. {
  577.     graf_mouse(ARROW, 0L);
  578.  
  579.     /* Restore the palette and free the allocated memory. */
  580.  
  581.     if (ColorBits > 1 && !TrueColor) {
  582.     int psize = PaletteSize/3;
  583.  
  584.     if (GSPalette) {
  585.         SetPalette(psize, OldPalette);
  586.         GSPalette = 0;
  587.     }
  588.  
  589.     gs_free((char *)Palette, PaletteSize, sizeof(int), "Palette");
  590.     gs_free((char *)OldPalette, PaletteSize, sizeof(int), "OldPalette");
  591.  
  592.     }
  593.  
  594.     /* Free the resources used by the aes. */
  595.  
  596.     if (window) {
  597.         menu_bar(menu, 0);
  598.  
  599.     if (imag.opened) wind_close(imag.handle);
  600.     if (icon.opened) wind_close(icon.handle);
  601.     if (dial.opened) wind_close(dial.handle);
  602.     if (cons.win->opened) wind_close(cons.win->handle);
  603.  
  604.     wind_delete(imag.handle);
  605.     wind_delete(icon.handle);
  606.     wind_delete(dial.handle);
  607.     wind_delete(cons.win->handle);
  608.     }
  609.  
  610.     v_clsvwk(VdiHandle);
  611.  
  612. #ifdef USE_RSC                            /* CF */
  613.     rsrc_free();
  614. #endif
  615.  
  616.     if (appl_exit() == 0) {
  617.     eprintf("stvdi_close: appl_exit() failed!\n");
  618.     exit_status = -1;
  619.     }
  620.  
  621. }
  622.  
  623. /* ------ Date and time ------ */
  624.  
  625. /* Read the current date (in days since Jan. 1, 1980) */
  626. /* and time (in milliseconds since midnight). */
  627.  
  628. void
  629. gp_get_clock(long *pdt)
  630. {    long secs_since_1970, secs_since_1980;
  631.     struct tm *tm, *localtime();
  632.  
  633.     if ( (secs_since_1970 = time(NULL)) == 0 )
  634.        {    perror("Ghostscript: gettimeofday failed:");
  635.         exit(-1);
  636.        }
  637.  
  638.     /* secs_since_1970 is #secs since Jan 1, 1970 */
  639.  
  640.     /* subtract off number of seconds in 10 years */
  641.     /* leap seconds are not accounted for */
  642.     secs_since_1980 = secs_since_1970 - (long)(60 * 60 * 24 * 365.25 * 10);
  643.  
  644.     /* there is no time zone adjustment for the atari st */
  645.  
  646.     /* adjust for daylight savings time - assume dst offset is 1 hour */
  647.     tm = localtime(&(secs_since_1970));
  648.     if ( tm->tm_isdst )
  649.         secs_since_1980 += (60 * 60);
  650.  
  651.     /* divide secs by #secs/day to get #days (integer division truncates) */
  652.     pdt[0] = secs_since_1980 / (60 * 60 * 24);
  653.     /* modulo * 1000 gives number of millisecs since midnight */
  654.     pdt[1] = (secs_since_1980 % (60 * 60 * 24)) * 1000;
  655. #ifdef DEBUG_CLOCK
  656.     printf("secs_since_1970 = %d  usecs_since_1970 = %d  pdt[0] = %ld\
  657.   pdt[1] = %ld\n", secs_since_1970, pdt[1], pdt[0], pdt[1]);
  658. #endif
  659. }
  660.  
  661. /* ------ Screen management ------ */
  662.  
  663. /* Write a string to the console. */
  664.  
  665. void
  666. gp_console_puts(const char *str, uint size)
  667. {
  668.     fwrite(str, 1, size, stdout);
  669. }
  670.  
  671. /* Check whether a file is the console. */
  672.  
  673. int
  674. gp_file_is_console(FILE *f)
  675. {
  676.     if (!f) return 0;
  677.     if (fileno(f) >= 0 && fileno(f) <= 2) return 1;
  678.  
  679.     return 0;
  680. }
  681.  
  682. /* Make the console current on the screen. */
  683.  
  684. int
  685. gp_make_console_current(struct gx_device_s *dev)
  686. {
  687.     return 0;
  688. }
  689.  
  690. /* Make the graphics current on the screen. */
  691.  
  692. int
  693. gp_make_graphics_current(struct gx_device_s *dev)
  694. {
  695.     return 0;
  696. }
  697.  
  698. /* ====== Substitute for stdio ====== */
  699.  
  700. /* This method for redirecting stdio to a window was stolen from the
  701.  * Microsoft Windows driver.
  702.  */
  703.  
  704. /* reinitialize stdin/out/err to use windows */
  705. /* assume stream has already been initialized for the real stdin */
  706.  
  707. #define win_stdin_buf_size 160
  708.  
  709. int
  710. win_std_init(file_device *fdev)
  711. {
  712.  
  713.     if (window) {
  714.  
  715.     if ( gp_file_is_console(gs_stream_stdin->file) ) {
  716.  
  717.         /* Allocate a real buffer for stdin. */
  718.         /* The size must not exceed the size of the */
  719.         /* lineedit buffer.  (This is a hack.) */
  720.     
  721.         static const stream_procs pin = {
  722.         s_std_noavailable, s_std_noseek,
  723.         s_std_read_flush, s_std_close,
  724.         win_std_read_buf, NULL
  725.         };
  726.  
  727.         byte *buf = (byte *)gs_malloc(win_stdin_buf_size, 1,
  728.         "win_stdin_init");
  729.  
  730.         s_std_init(gs_stream_stdin, buf, win_stdin_buf_size,
  731.         &pin, s_mode_read);
  732.  
  733.         gs_stream_stdin->file = NULL;
  734.  
  735.     }
  736.  
  737.     {
  738.         static const stream_procs pout = {
  739.         s_std_noavailable, s_std_noseek,
  740.         s_std_write_flush, s_std_close,
  741.         NULL, win_std_write_buf 
  742.         };
  743.  
  744.         if ( gp_file_is_console(gs_stream_stdout->file) ) {
  745.         gs_stream_stdout->procs = pout;
  746.         gs_stream_stdout->file = NULL;
  747.         }
  748.  
  749.         if ( gp_file_is_console(gs_stream_stderr->file) ) {
  750.         gs_stream_stderr->procs = pout;
  751.         gs_stream_stderr->file = NULL;
  752.         }
  753.     }
  754.     }
  755. }
  756.  
  757. #define ERASELINE 21        /* ^U */
  758. #define ERASECHAR1 8        /* ^H */
  759. #define ERASECHAR2 127        /* DEL */
  760.  
  761. /* Handle all user input. This contains the main event loop for
  762.  * Atari windows.
  763.  */
  764.  
  765. private int
  766. win_std_read_buf(register stream *s)
  767. {
  768.  
  769.     byte *buf = s->cbuf;
  770.  
  771.     byte *dest = buf - 1;
  772.     byte *limit = dest + s->bsize - 1;  /* always leave room for \n */
  773.  
  774.     uint ch;
  775.  
  776.     int ret;
  777.     int psize = PaletteSize/3;
  778.     int event, obj_ind, loop_end=0, menuitem=0, scrollitem=-1;
  779.     int wait_event, button_state, mx, my, mb, mk, key, clicks;
  780.  
  781.     TEXTWIN *cw = &cons;
  782.  
  783.     char *inf = infile, *curd = current_dir, *dspec = dir_spec;
  784.     char *fs  = file_sel;
  785.  
  786.     /* Copy the appropriate portion of the image to the screen. */
  787.  
  788.     if (window) {
  789.         wait_event = MU_MESAG | MU_KEYBD | MU_BUTTON;
  790.         button_state = 1;
  791.     }
  792.  
  793.     while (!loop_end && window) {
  794.  
  795.         graf_mouse(ARROW, 0L);
  796.  
  797.         step_dx = .9 * imag.canvas.g_w;
  798.         step_dy = .9 * imag.canvas.g_h;
  799.  
  800.         if (menuitem) {        /* fake menu events for hot keys */
  801.  
  802.         event = MU_MESAG;
  803.         msgbuff[0] = MN_SELECTED;
  804.         msgbuff[3] = -1;
  805.         msgbuff[4] = menuitem;
  806.         menuitem = 0;
  807.  
  808.         }
  809.         else if (scrollitem >= 0) {
  810.  
  811.         event = MU_MESAG;
  812.         msgbuff[0] = WM_ARROWED;
  813.         msgbuff[3] = imag.handle;
  814.         msgbuff[4] = scrollitem;
  815.         scrollitem = -1;
  816.  
  817.         }
  818.         else {
  819.  
  820.         event = evnt_multi(wait_event, 2, 1, button_state,
  821.             1, mx, my, 1, 1, 0, 0, 0, 0, 0,
  822.             msgbuff, 0L, &mx, &my, &mb, &mk,
  823.             &key, &clicks);
  824.  
  825.         }
  826.  
  827.         if (event & MU_BUTTON) {        /* button events */
  828.  
  829.         if ((obj_ind = objc_find(about, OK, 0, mx, my)) >= 0) {
  830.  
  831.             objc_change(about, OK, 0,
  832.             dial.canvas.g_x, dial.canvas.g_y,
  833.             dial.canvas.g_w, dial.canvas.g_h, 1, 1);
  834.  
  835.             wind_close(dial.handle);
  836.  
  837.             objc_change(about, OK, 0,
  838.             dial.canvas.g_x, dial.canvas.g_y,
  839.             dial.canvas.g_w, dial.canvas.g_h, 0, 0);
  840.  
  841.             dial.opened = 0;
  842.  
  843.         }
  844.         }
  845.  
  846.         if (event & MU_KEYBD) {        /* keyboard input */
  847.  
  848.         ch = (uint)( key & 255 );
  849.  
  850.         switch (key) {
  851.  
  852.         case 0x1300:            /* alt-r */
  853.             menuitem = RUN;
  854.             break;
  855.  
  856.         case 0x3100:            /* alt-n */
  857.             menuitem = NEXT;
  858.             break;
  859.  
  860.         case 0x1000:            /* alt-q */
  861.             menuitem = QUIT;
  862.             break;
  863.  
  864.         case 0x1700:            /* alt-i */
  865.             menuitem = ICON;
  866.             break;
  867.  
  868.         case 0x1400:            /* alt-t */
  869.             menuitem = TOGTOP;
  870.             break;
  871.  
  872.         case 0x4800:            /* up arrow */
  873.             scrollitem = WA_UPPAGE;
  874.             break;
  875.  
  876.         case 0x5000:            /* down arrow */
  877.             scrollitem = WA_DNPAGE;
  878.             break;
  879.  
  880.         case 0x4b00:            /* left arrow */
  881.             scrollitem = WA_LFPAGE;
  882.             break;
  883.  
  884.         case 0x4d00:            /* right arrow */
  885.             scrollitem = WA_RTPAGE;
  886.             break;
  887.  
  888.         case 0x1c0d:            /* return */
  889.  
  890.             /* Close dialog if opened. Otherwise exit
  891.              * the event loop so the interpreter can
  892.              * read the input buffer.
  893.              */
  894.  
  895.             if (dial.opened) {
  896.  
  897.             objc_change(about, OK, 0,
  898.                 dial.canvas.g_x, dial.canvas.g_y,
  899.                 dial.canvas.g_w, dial.canvas.g_h, 1, 1);
  900.  
  901.             wind_close(dial.handle);
  902.  
  903.             objc_change(about, OK, 0,
  904.                 dial.canvas.g_x, dial.canvas.g_y,
  905.                 dial.canvas.g_w, dial.canvas.g_h, 0, 0);
  906.  
  907.             dial.opened = 0;
  908.  
  909.             }
  910.             else {
  911.  
  912.             /* If return is pressed after a showpage,
  913.              * send a message to redraw the image window.
  914.              */
  915.  
  916.             int prevline = (cons.ln > 0) ? cons.ln-1 : LINES-1;
  917.  
  918.             if ((sptr = strstr(cons.text[prevline], ">>"))
  919.                 != NULL) {
  920.  
  921.                 SendMsg[0] = WM_REDRAW;
  922.                 SendMsg[3] = imag.handle;
  923.                 SendMsg[4] = imag.canvas.g_x;
  924.                 SendMsg[5] = imag.canvas.g_y;
  925.                 SendMsg[6] = imag.canvas.g_w;
  926.                 SendMsg[7] = imag.canvas.g_h;
  927.                 appl_write(ApId, 16, SendMsg);
  928.  
  929.             }
  930.         
  931.             *++dest = '\n';
  932.             gemputc(ch);
  933.             s->cptr = buf - 1;
  934.             s->end_status = 0;
  935.             s->endptr = dest;
  936.  
  937.             graf_mouse(BUSY_BEE, 0L);
  938.             loop_end = 1;
  939.  
  940.             }
  941.             break;
  942.  
  943.         default:    /* handle the input character. */
  944.  
  945.             switch (ch) {
  946.  
  947.             default:        /* put char in the input buffer. */
  948.             if ( dest == limit ) {
  949.                 ; /* MessageBeep(-1); */
  950.             }
  951.             else {
  952.                 *++dest = ch;
  953.                 gemputc(ch);
  954.             }
  955.             break;
  956.  
  957.             case ERASELINE:
  958.             clear_line(dest - buf + 1);
  959.             dest = buf - 1;
  960.             break;
  961.  
  962.             case ERASECHAR1:
  963.             case ERASECHAR2:
  964.             if ( dest >= buf ) {
  965.                 gemputc('\b');
  966.                 gemputc(' ');
  967.                 gemputc('\b');
  968.                 dest--;
  969.             }
  970.             break;
  971.  
  972.             }
  973.  
  974.         }
  975.  
  976.         }
  977.  
  978.         if (event & MU_MESAG) {    /* message events */
  979.  
  980.             switch (msgbuff[0]) {
  981.  
  982.             case MN_SELECTED:
  983.  
  984.             if (msgbuff[3] != -1) {
  985.             menu_tnormal(menu, msgbuff[3], 1);
  986.             }
  987.  
  988.             switch (msgbuff[4]) {
  989.  
  990.             case ABOUT:
  991.  
  992.             if (!dial.opened) {
  993.  
  994.                 form_center(about,
  995.                 &dial.canvas.g_x, &dial.canvas.g_y,
  996.                 &dial.canvas.g_w, &dial.canvas.g_h);
  997.  
  998.                 wind_calc(0, dial.gadgets,
  999.                 dial.canvas.g_x, dial.canvas.g_y,
  1000.                 dial.canvas.g_w, dial.canvas.g_h,
  1001.                 &dial.frame.g_x, &dial.frame.g_y,
  1002.                 &dial.frame.g_w, &dial.frame.g_h);
  1003.  
  1004.                 wind_open(dial.handle,
  1005.                 dial.frame.g_x, dial.frame.g_y,
  1006.                 dial.frame.g_w, dial.frame.g_h);
  1007.  
  1008.                 dial.opened = 1;
  1009.             }
  1010.  
  1011.             break;
  1012.  
  1013.             case RUN:
  1014.  
  1015.             {
  1016.  
  1017.             /* If return was not pressed after a showpage,
  1018.              * then enter a return and send a message to
  1019.              * redraw the image window and run a new program
  1020.              * the next time through the event loop.
  1021.              */
  1022.  
  1023.             int prevline = (cons.ln > 0) ? cons.ln-1 : LINES-1;
  1024.  
  1025.             if ((sptr = strstr(cons.text[prevline], ">>"))
  1026.                 != NULL) {
  1027.  
  1028.                 *++dest = '\n';
  1029.                 gemputc('\n');
  1030.                 graf_mouse(BUSY_BEE, 0L);
  1031.                 loop_end = 1;
  1032.  
  1033.                 SendMsg[0] = WM_REDRAW;
  1034.                 SendMsg[3] = imag.handle;
  1035.                 SendMsg[4] = imag.canvas.g_x;
  1036.                 SendMsg[5] = imag.canvas.g_y;
  1037.                 SendMsg[6] = imag.canvas.g_w;
  1038.                 SendMsg[7] = imag.canvas.g_h;
  1039.                 appl_write(ApId, 16, SendMsg);
  1040.  
  1041.                 SendMsg[0] = MN_SELECTED;
  1042.                 SendMsg[3] = -1;
  1043.                 SendMsg[4] = RUN;
  1044.                 appl_write(ApId, 16, SendMsg);
  1045.  
  1046.                 break;
  1047.             }
  1048.  
  1049.             sprintf(dir_spec, "%s%s", current_dir, "*.PS");
  1050.  
  1051.             /* If a single input file has been specified,
  1052.              * make it the default selection. If more than
  1053.              * one input file exists, or no input is selected,
  1054.              * use no default.
  1055.              */
  1056.  
  1057.             if (strlen(infile)) {
  1058.                 strcpy(file_sel, infile);
  1059.             }
  1060.             else {
  1061.                 strcpy(file_sel, "");
  1062.             }
  1063.  
  1064.                 ret = fsel_input(dir_spec, file_sel, &ExitButton);
  1065.  
  1066.             if (ExitButton && strlen(file_sel)) {
  1067.  
  1068.                 sptr = strrchr(dir_spec, '\\');
  1069.                 *++sptr = '\0';
  1070.  
  1071.                 strcpy(current_dir, dir_spec);
  1072.                 strcpy(infile, file_sel);
  1073.  
  1074.                 sprintf(command, "(%s%s) run\n",
  1075.                 dir_spec, file_sel);
  1076.  
  1077.                 /* change back slashes to forward */
  1078.  
  1079.                 while ((sptr = strchr(command, '\\')) != NULL) {
  1080.                 *sptr = '/';
  1081.                 }
  1082.  
  1083.                 for (sptr = command; *sptr; sptr++) {
  1084.                 *++dest = *sptr;
  1085.                 }
  1086.  
  1087.                 s->cptr = buf - 1;
  1088.                 s->end_status = 0;
  1089.                 s->endptr = dest;
  1090.  
  1091.                 /* Send a message to output the command after
  1092.                  * all pending events have been dispatched.
  1093.                  */
  1094.  
  1095.                 SendMsg[0] = COMMAND;
  1096.                 appl_write(ApId, 16, SendMsg);
  1097.  
  1098.             }
  1099.             }
  1100.  
  1101.             break;
  1102.  
  1103.             case NEXT:
  1104.             if (imag.opened) {
  1105.                 wind_get(imag.handle, WF_CURRXYWH,
  1106.                 &imag.oframe.g_x, &imag.oframe.g_y,
  1107.                 &imag.oframe.g_w, &imag.oframe.g_h);
  1108.             }
  1109.  
  1110.             if (icon.opened) {
  1111.                 wind_close(icon.handle);
  1112.                 icon.opened = 0;
  1113.             }
  1114.  
  1115.             if (dial.opened) {
  1116.                 wind_close(dial.handle);
  1117.                 dial.opened = 0;
  1118.             }
  1119.  
  1120.             graf_mouse(BUSY_BEE, 0L);
  1121.  
  1122.             loop_end = 1;
  1123.             break;
  1124.  
  1125.             case QUIT:
  1126.             gs_exit(0);
  1127.             break;
  1128.  
  1129.             case ICON:
  1130.                 if (!MultiTOS)                /* CF */
  1131.             if (icon.opened) {
  1132.  
  1133.                 wind_get(icon.handle, WF_CURRXYWH,
  1134.                 &icon.frame.g_x, &icon.frame.g_y,
  1135.                 &icon.frame.g_w, &icon.frame.g_h);
  1136.  
  1137.                 wind_close(icon.handle);
  1138.  
  1139.                     wind_open(imag.handle,
  1140.                 imag.oframe.g_x, imag.oframe.g_y,
  1141.                 imag.oframe.g_w, imag.oframe.g_h);
  1142.  
  1143.                     wind_open(cons.win->handle,
  1144.                 cons.win->frame.g_x, cons.win->frame.g_y,
  1145.                 cons.win->frame.g_w, cons.win->frame.g_h);
  1146.  
  1147.                 menu[ICON].ob_spec = UL"  Iconify    ❎i ";
  1148.                 
  1149.                     icon.opened = 0;
  1150.                     imag.opened = 1;
  1151.                 cons.win->opened = 1;
  1152.  
  1153.             }
  1154.             else {
  1155.  
  1156.                 if (imag.opened) {
  1157.                 wind_get(imag.handle, WF_CURRXYWH,
  1158.                     &imag.oframe.g_x, &imag.oframe.g_y,
  1159.                     &imag.oframe.g_w, &imag.oframe.g_h);
  1160.  
  1161.                 wind_close(imag.handle);
  1162.                 imag.opened = 0;
  1163.                 }
  1164.  
  1165.                 if (cons.win->opened) {
  1166.                 wind_get(cons.win->handle, WF_CURRXYWH,
  1167.                     &cons.win->frame.g_x, &cons.win->frame.g_y,
  1168.                     &cons.win->frame.g_w, &cons.win->frame.g_h);
  1169.  
  1170.                 wind_close(cons.win->handle);
  1171.                 cons.win->opened = 0;
  1172.                 }
  1173.  
  1174.                     wind_open(icon.handle,
  1175.                 icon.frame.g_x, icon.frame.g_y,
  1176.                 icon.frame.g_w, icon.frame.g_h);
  1177.  
  1178.                 menu[ICON].ob_spec = UL"  DeIconify  ❎i ";
  1179.  
  1180.                 icon.opened = 1;
  1181.             }
  1182.             break;
  1183.  
  1184.             case TOGTOP:
  1185.             {
  1186.                 int topwin, empty;
  1187.  
  1188.                 wind_get(0, WF_TOP, &topwin, &empty,
  1189.                     &empty, &empty);
  1190.  
  1191.                 if (topwin == cons.win->handle && imag.opened) {
  1192.                 wind_set(imag.handle, WF_TOP, 0, 0, 0, 0);
  1193.                 }
  1194.                 else if (cons.win->opened) {
  1195.                 wind_set(cons.win->handle, WF_TOP, 0, 0, 0, 0);
  1196.                 }
  1197.             }
  1198.  
  1199.             break;
  1200.  
  1201.             }
  1202.  
  1203.             break;
  1204.  
  1205.             case WM_REDRAW:
  1206.             cursor(OFF);
  1207.             gp_win_redraw(DIRT_RECT);
  1208.             cursor(ON);
  1209.             break;
  1210.  
  1211.             case WM_ARROWED:
  1212.  
  1213.             switch (msgbuff[4]) {
  1214.  
  1215.             case WA_UPLINE:    /* up line or top of page */
  1216.             if (msgbuff[3] == imag.handle) {
  1217.                 plot_y = 0;
  1218.             }
  1219.             else if (msgbuff[3] == cons.win->handle) {
  1220.                 if (cons.fdl != cons.fl) {
  1221.                 cons.top += cons.hc;
  1222.                 cons.cy += cons.hc;
  1223.                 if (--cons.fdl < 0) cons.fdl += LINES;
  1224.                 if (--cons.ldl < 0) cons.fdl += LINES;
  1225.                 }
  1226.             }
  1227.             break;
  1228.  
  1229.             case WA_DNLINE:    /* down line or bottom of page */
  1230.             if (msgbuff[3] == imag.handle) {
  1231.                 plot_y = (height-1) - imag.canvas.g_h;
  1232.             }
  1233.             else if (msgbuff[3] == cons.win->handle) {
  1234.                 if (cons.ldl != cons.ll) {
  1235.                 cons.top -= cons.hc;
  1236.                 cons.cy  -= cons.hc;
  1237.                 if (++cons.fdl >= LINES) cons.fdl = 0;
  1238.                 if (++cons.ldl >= LINES) cons.ldl = 0;
  1239.                 }
  1240.             }
  1241.             break;
  1242.  
  1243.             case WA_LFLINE:
  1244.             if (msgbuff[3] == imag.handle) {
  1245.                 plot_x = 0;
  1246.             }
  1247.             else if (msgbuff[3] == cons.win->handle) {
  1248.                 if (cons.fdc > 0) {
  1249.                 cons.edge += cons.wc;
  1250.                 cons.cx  += cons.wc;
  1251.                 cons.fdc--;
  1252.                 }
  1253.             }
  1254.             break;
  1255.  
  1256.             case WA_RTLINE:
  1257.             if (msgbuff[3] == imag.handle) {
  1258.                 plot_x = (width-1) - imag.canvas.g_w;
  1259.             }
  1260.             else if (msgbuff[3] == cons.win->handle) {
  1261.                 if ((cons.fdc + cons.cols) < CLIMIT) {
  1262.                 cons.edge -= cons.wc;
  1263.                 cons.cx  -= cons.wc;
  1264.                 cons.fdc++;
  1265.                 }
  1266.             }
  1267.             break;
  1268.  
  1269.             case WA_UPPAGE:
  1270.             if (msgbuff[3] == imag.handle) {
  1271.                 plot_y = MAX(plot_y - step_dy, 0);
  1272.             }
  1273.             else if (msgbuff[3] == cons.win->handle) {
  1274.                 int to_top = cons.fdl - cons.fl;
  1275.                 to_top = (to_top >= 0) ? to_top : to_top + LINES;
  1276.  
  1277.                 if (to_top >= (cons.lins - 1)) {
  1278.                 cons.top += (cons.lins - 1) * cons.hc;
  1279.                 cons.cy  += (cons.lins - 1) * cons.hc;
  1280.                 cons.fdl -= (cons.lins - 1);
  1281.                 cons.ldl  -= (cons.lins - 1);
  1282.                 if (cons.fdl < 0) cons.fdl += LINES;
  1283.                 if (cons.ldl < 0) cons.ldl += LINES;
  1284.                 }
  1285.                 else {
  1286.                 ChangeY = cons.win->canvas.g_y - cons.top;
  1287.                 cons.top += ChangeY;
  1288.                 cons.cy  += ChangeY;
  1289.                 cons.fdl = cons.fl;
  1290.                 cons.ldl = cons.fl + cons.lins - 1;
  1291.                 if (cons.ldl >= LINES) cons.ldl -= LINES;
  1292.                 }
  1293.             }
  1294.             break;
  1295.  
  1296.             case WA_DNPAGE:
  1297.             if (msgbuff[3] == imag.handle) {
  1298.                 plot_y = plot_y + step_dy;
  1299.             }
  1300.             else if (msgbuff[3] == cons.win->handle) {
  1301.                 int to_bot = cons.ll - cons.ldl;
  1302.                 to_bot = (to_bot >= 0) ? to_bot : to_bot + LINES;
  1303.  
  1304.                 if (to_bot >= (cons.lins - 1)) {
  1305.                 cons.top -= (cons.lins - 1) * cons.hc;
  1306.                 cons.cy  -= (cons.lins - 1) * cons.hc;
  1307.                 cons.fdl += (cons.lins - 1);
  1308.                 cons.ldl += (cons.lins - 1);
  1309.                 if (cons.fdl >= LINES) cons.fdl -= LINES;
  1310.                 if (cons.ldl >= LINES) cons.ldl -= LINES;
  1311.                 }
  1312.                 else {
  1313.                 ChangeY = cons.win->canvas.g_y
  1314.                     - (LINES - cons.lins) * cons.hc
  1315.                     - cons.top;
  1316.                 cons.top += ChangeY;
  1317.                 cons.cy  += ChangeY;
  1318.                 cons.fdl = cons.ll - cons.lins + 1;
  1319.                 cons.ldl = cons.ll;
  1320.                 if (cons.fdl < 0) cons.fdl += LINES;
  1321.                 }
  1322.             }
  1323.             break;
  1324.  
  1325.             case WA_LFPAGE:
  1326.             if (msgbuff[3] == imag.handle) {
  1327.                 plot_x = MAX(plot_x - step_dx, 0);
  1328.             }
  1329.             else if (msgbuff[3] == cons.win->handle) {
  1330.                 if (cons.fdc  >= (cons.cols - 1)) {
  1331.                 cons.edge += (cons.cols - 1) * cons.wc;
  1332.                 cons.cx   += (cons.cols - 1) * cons.wc;
  1333.                 cons.fdc  -= (cons.cols - 1);
  1334.                 }
  1335.                 else {
  1336.                 ChangeX = cons.win->canvas.g_x - cons.edge;
  1337.                 cons.edge += ChangeX;
  1338.                 cons.cx   += ChangeX;
  1339.                 cons.fdc = 0;
  1340.                 }
  1341.             }
  1342.             break;
  1343.  
  1344.             case WA_RTPAGE:
  1345.             if (msgbuff[3] == imag.handle) {
  1346.                 plot_x = plot_x + step_dx;
  1347.             }
  1348.             else if (msgbuff[3] == cons.win->handle) {
  1349.                 if (cons.fdc <= (CLIMIT - 2*cons.cols + 1)) {
  1350.                 cons.edge -= (cons.cols - 1) * cons.wc;
  1351.                 cons.cx  -= (cons.cols - 1) * cons.wc;
  1352.                 cons.fdc += (cons.cols - 1);
  1353.                 }
  1354.                 else {
  1355.                 ChangeX = cons.win->canvas.g_x
  1356.                     - (CLIMIT - cons.cols) * cons.wc
  1357.                     - cons.edge;
  1358.                 cons.edge += ChangeX;
  1359.                 cons.cx   += ChangeX;
  1360.                 cons.fdc = (CLIMIT - cons.cols);
  1361.                 }
  1362.             }
  1363.             break;
  1364.  
  1365.             }
  1366.             update_scroll(msgbuff[3]);
  1367.             cursor(OFF);
  1368.             gp_win_redraw(FULL_WIN);
  1369.             cursor(ON);
  1370.             break;
  1371.  
  1372.         case WM_HSLID:
  1373.             if (msgbuff[3] == imag.handle) {
  1374.             plot_x = (width - imag.canvas.g_w) * msgbuff[4]/1000;
  1375.             }
  1376.             else if (msgbuff[3] == cons.win->handle) {
  1377.             cons.fdc =
  1378.                 (CLIMIT - cons.cols) * msgbuff[4]/1000;
  1379.             ChangeX = cons.win->canvas.g_x
  1380.                 - cons.fdc * cons.wc
  1381.                 - cons.edge;
  1382.             cons.edge += ChangeX;
  1383.             cons.cx   += ChangeX;
  1384.  
  1385.             }
  1386.             update_scroll(msgbuff[3]);
  1387.             cursor(OFF);
  1388.             gp_win_redraw(FULL_WIN);
  1389.             cursor(ON);
  1390.             break;
  1391.  
  1392.         case WM_VSLID:
  1393.             if (msgbuff[3] == imag.handle) {
  1394.             plot_y = (height - imag.canvas.g_h) * msgbuff[4]/1000;
  1395.             }
  1396.             else if (msgbuff[3] == cons.win->handle) {
  1397.             int OldOffset = cons.fdl - cons.fl;
  1398.             int NewOffset = (LINES - cons.lins) * msgbuff[4]/1000;
  1399.  
  1400.             if (OldOffset < 0) OldOffset += LINES;
  1401.  
  1402.             cons.fdl = cons.fl + NewOffset;
  1403.             if (cons.fdl >= LINES) cons.fdl -= LINES;
  1404.  
  1405.             cons.ldl = cons.fdl + cons.lins - 1;
  1406.             if (cons.ldl >= LINES) cons.ldl -= LINES;
  1407.  
  1408.             ChangeY = (OldOffset - NewOffset) * cons.hc;
  1409.             cons.top += ChangeY;
  1410.             cons.cy  += ChangeY;
  1411.             }
  1412.             update_scroll(msgbuff[3]);
  1413.             cursor(OFF);
  1414.             gp_win_redraw(FULL_WIN);
  1415.             cursor(ON);
  1416.             break;
  1417.  
  1418.             case WM_TOPPED:
  1419.             wind_set(msgbuff[3], WF_TOP, 0, 0, 0, 0);
  1420.             /* intentional fall-through */
  1421.  
  1422.         case WM_ONTOP:
  1423.             if (ColorBits > 1 && !GSPalette && !TrueColor) {
  1424.             SetPalette(psize, Palette);  /* Restore GS palette. */
  1425.             GSPalette = 1;
  1426.             }
  1427.             break;
  1428.  
  1429.         case WM_UNTOPPED:
  1430.             {
  1431.             int topwin, empty;
  1432.  
  1433.             wind_get(0, WF_TOP, &topwin, &empty,
  1434.                     &empty, &empty);
  1435.  
  1436.             if (GSPalette &&        /* Release palette. */
  1437.                 topwin != cons.win->handle &&
  1438.                 topwin != imag.handle &&
  1439.                 topwin != icon.handle &&
  1440.                 topwin != dial.handle) {
  1441.  
  1442.                 SetPalette(psize, OldPalette);
  1443.                 GSPalette = 0;
  1444.             }
  1445.  
  1446.             }
  1447.             break;
  1448.  
  1449.             case WM_CLOSED:
  1450.             if (msgbuff[3] == dial.handle) {
  1451.             dial.opened = 0;
  1452.             wind_close(msgbuff[3]);
  1453.             }
  1454.             else if (msgbuff[3] == imag.handle) {
  1455.             int prevline = (cons.ln > 0) ? cons.ln-1 : LINES-1;
  1456.  
  1457.             wind_get(imag.handle, WF_CURRXYWH,
  1458.                 &imag.oframe.g_x, &imag.oframe.g_y,
  1459.                 &imag.oframe.g_w, &imag.oframe.g_h);
  1460.             imag.opened = 0;
  1461.  
  1462.             wind_close(msgbuff[3]);
  1463.  
  1464.             /* If a return has not been entered after a
  1465.              * showpage, then enter one.
  1466.              */
  1467.  
  1468.             if ((sptr = strstr(cons.text[prevline], ">>"))
  1469.                 != NULL) {
  1470.  
  1471.                 *++dest = '\n';
  1472.                 gemputc('\n');
  1473.                 loop_end = 1;
  1474.             }
  1475.  
  1476.             }
  1477.             else {
  1478.             gs_exit(0);
  1479.             }
  1480.  
  1481.             break;
  1482.  
  1483.             case WM_FULLED:
  1484.             if (msgbuff[3] == icon.handle) {
  1485.             menuitem = ICON;
  1486.             }
  1487.             else {
  1488.  
  1489.             WINDOW *win;
  1490.  
  1491.             if (msgbuff[3] == imag.handle) {
  1492.                 win = &imag;
  1493.             }
  1494.             else if (msgbuff[3] == cons.win->handle) {
  1495.                 win = cons.win;
  1496.             }
  1497.  
  1498.             SendMsg[0] = WM_SIZED;
  1499.             SendMsg[3] = win->handle;
  1500.  
  1501.             wind_get(win->handle, WF_CURRXYWH,
  1502.                 &win->frame.g_x, &win->frame.g_y,
  1503.                 &win->frame.g_w, &win->frame.g_h);
  1504.  
  1505.             if (win->frame.g_x == full.g_x &&
  1506.                 win->frame.g_y == full.g_y &&
  1507.                     win->frame.g_w == MIN(win->mframe.g_w, full.g_w) &&
  1508.                 win->frame.g_h == MIN(win->mframe.g_h, full.g_h)) {
  1509.  
  1510.                 SendMsg[4] = win->oframe.g_x;
  1511.                 SendMsg[5] = win->oframe.g_y;
  1512.                 SendMsg[6] = win->oframe.g_w;
  1513.                 SendMsg[7] = win->oframe.g_h;
  1514.  
  1515.             }
  1516.             else {
  1517.                 win->oframe.g_x = win->frame.g_x;
  1518.                 win->oframe.g_y = win->frame.g_y;
  1519.                 win->oframe.g_w = win->frame.g_w;
  1520.                 win->oframe.g_h = win->frame.g_h;
  1521.  
  1522.                 SendMsg[4] = full.g_x;
  1523.                 SendMsg[5] = full.g_y;
  1524.                 SendMsg[6] = MIN(win->mframe.g_w, full.g_w);
  1525.                 SendMsg[7] = MIN(win->mframe.g_h, full.g_h);
  1526.  
  1527.             }
  1528.  
  1529.             /* Send a message to handle the window resizing. */
  1530.  
  1531.             appl_write(ApId, 16, SendMsg);
  1532.  
  1533.             }
  1534.  
  1535.             break;
  1536.  
  1537.             case WM_MOVED:
  1538.  
  1539.             if (msgbuff[3] == icon.handle) {
  1540.  
  1541.             wind_set(icon.handle, WF_CURRXYWH,
  1542.                 msgbuff[4], msgbuff[5],
  1543.                 msgbuff[6], msgbuff[7]);
  1544.  
  1545.             wind_get(icon.handle, WF_WORKXYWH,
  1546.                 &icon.canvas.g_x, &icon.canvas.g_y,
  1547.                 &icon.canvas.g_w, &icon.canvas.g_h);
  1548.  
  1549.             noghost[0].ob_x = icon.canvas.g_x;
  1550.             noghost[0].ob_y = icon.canvas.g_y;
  1551.  
  1552.             }
  1553.             else if (msgbuff[3] == dial.handle) {
  1554.  
  1555.             wind_set(dial.handle, WF_CURRXYWH,
  1556.                 msgbuff[4], msgbuff[5],
  1557.                 msgbuff[6], msgbuff[7]);
  1558.  
  1559.             ChangeX = msgbuff[4] - dial.frame.g_x;
  1560.             ChangeY = msgbuff[5] - dial.frame.g_y;
  1561.  
  1562.             dial.canvas.g_x += ChangeX;
  1563.             dial.canvas.g_y += ChangeY;
  1564.  
  1565.             about[0].ob_x += ChangeX;
  1566.             about[0].ob_y += ChangeY;
  1567.  
  1568.             wind_get(dial.handle, WF_CURRXYWH,
  1569.                 &dial.frame.g_x, &dial.frame.g_y,
  1570.                 &dial.frame.g_w, &dial.frame.g_h);
  1571.             }
  1572.             else if (msgbuff[3] == imag.handle) {
  1573.  
  1574.             wind_set(imag.handle, WF_CURRXYWH,
  1575.                 msgbuff[4], msgbuff[5],
  1576.                 MIN(imag.mframe.g_w, msgbuff[6]),
  1577.                 MIN(imag.mframe.g_h, msgbuff[7]));
  1578.  
  1579.             wind_get(imag.handle, WF_WORKXYWH,
  1580.                 &imag.canvas.g_x, &imag.canvas.g_y,
  1581.                 &imag.canvas.g_w, &imag.canvas.g_h);
  1582.  
  1583.             }
  1584.             else {
  1585.  
  1586.             int oldterm_x = cons.win->canvas.g_x;
  1587.             int oldterm_y = cons.win->canvas.g_y;
  1588.  
  1589.             wind_set(cons.win->handle, WF_CURRXYWH,
  1590.                 align(msgbuff[4]), msgbuff[5],
  1591.                 MIN(cons.win->mframe.g_w, msgbuff[6]),
  1592.                 MIN(cons.win->mframe.g_w, msgbuff[7]));
  1593.  
  1594.             wind_get(cons.win->handle, WF_WORKXYWH,
  1595.                 &cons.win->canvas.g_x, &cons.win->canvas.g_y,
  1596.                 &cons.win->canvas.g_w, &cons.win->canvas.g_h);
  1597.  
  1598.             ChangeX = cons.win->canvas.g_x - oldterm_x;
  1599.             ChangeY = cons.win->canvas.g_y - oldterm_y;
  1600.  
  1601.             cons.edge += ChangeX;
  1602.             cons.top  += ChangeY;
  1603.  
  1604.             cons.cx += ChangeX;
  1605.             cons.cy += ChangeY;
  1606.  
  1607.             }
  1608.  
  1609.             break;
  1610.  
  1611.             case WM_SIZED:
  1612.  
  1613.             if (msgbuff[3] == imag.handle) {
  1614.  
  1615.             wind_set(imag.handle, WF_CURRXYWH,
  1616.                 msgbuff[4], msgbuff[5],
  1617.                 MIN(imag.mframe.g_w, msgbuff[6]),
  1618.                 MIN(imag.mframe.g_h, msgbuff[7]));
  1619.  
  1620.             wind_get(imag.handle, WF_WORKXYWH,
  1621.                 &imag.canvas.g_x, &imag.canvas.g_y,
  1622.                 &imag.canvas.g_w, &imag.canvas.g_h);
  1623.  
  1624.             }
  1625.             else if (msgbuff[3] == cons.win->handle) {
  1626.             int offset;
  1627.             int old_x = cons.win->canvas.g_x;
  1628.             int old_y = cons.win->canvas.g_y;
  1629.             int old_w = cons.win->canvas.g_w;
  1630.             int old_h = cons.win->canvas.g_h;
  1631.  
  1632.             wind_set(cons.win->handle, WF_CURRXYWH,
  1633.                 msgbuff[4], msgbuff[5],
  1634.                 MIN(cons.win->mframe.g_w, msgbuff[6]),
  1635.                 MIN(cons.win->mframe.g_h, msgbuff[7]));
  1636.  
  1637.             wind_get(cons.win->handle, WF_WORKXYWH,
  1638.                 &cons.win->canvas.g_x, &cons.win->canvas.g_y,
  1639.                 &cons.win->canvas.g_w, &cons.win->canvas.g_h);
  1640.  
  1641.             cons.lins = visible_lines();
  1642.             cons.cols = visible_cols();
  1643.  
  1644.             cons.fdl = cons.ln - cons.lins + 1;
  1645.  
  1646.             if (cons.fdl > LINES) {
  1647.                 cons.fdl -= LINES;
  1648.             }
  1649.             else if (cons.fdl < 0 && !cons.scrolled) {
  1650.                 cons.fdl = 0;
  1651.             }
  1652.             else if (cons.fdl < 0 && cons.scrolled) {
  1653.                 cons.fdl += LINES;
  1654.             }
  1655.  
  1656.             cons.ldl = cons.fdl + cons.lins - 1;
  1657.             if (cons.ldl >= LINES) cons.ldl -= LINES;
  1658.  
  1659.             offset = cons.ln - cons.fdl;
  1660.             if (offset < 0) offset += LINES;
  1661.             if (offset >= LINES) offset -= LINES;
  1662.             cons.cy = cons.win->canvas.g_y
  1663.                 + cons.yoff + offset * cons.hc;
  1664.  
  1665.             offset = cons.fdl - cons.fl;
  1666.             if (offset < 0) offset += LINES;
  1667.             if (offset >= LINES) offset -= LINES;
  1668.             cons.top = cons.win->canvas.g_y - offset * cons.hc;
  1669.  
  1670.             /* Redraw the window if the OS won't. */
  1671.  
  1672.             if (old_x <= cons.win->canvas.g_x &&
  1673.                 old_y <= cons.win->canvas.g_y &&
  1674.                 old_w >= cons.win->canvas.g_w &&
  1675.                 old_h >= cons.win->canvas.g_h) {
  1676.  
  1677.                 cursor(OFF);
  1678.                 gp_win_redraw(FULL_WIN);
  1679.                 cursor(ON);
  1680.             }
  1681.             }
  1682.  
  1683.             update_scroll(msgbuff[3]);
  1684.             break;
  1685.         
  1686.         case WM_BOTTOM:                    /* CF */
  1687.             wind_set(msgbuff[3], WF_BOTTOM, 0, 0, 0, 0);
  1688.             break;
  1689.         
  1690.         case WM_ICONIFY:
  1691.         case WM_ALLICONIFY:                /* CF */
  1692.             if (imag.opened) 
  1693.             {
  1694.                 wind_get(imag.handle, WF_CURRXYWH,
  1695.                         &imag.oframe.g_x, &imag.oframe.g_y,
  1696.                         &imag.oframe.g_w, &imag.oframe.g_h);
  1697.                 wind_close(imag.handle);
  1698.                 imag.opened = 0;
  1699.             }
  1700.  
  1701.             if (cons.win->opened) 
  1702.             {
  1703.                 wind_get(cons.win->handle, WF_CURRXYWH,
  1704.                         &cons.win->frame.g_x, &cons.win->frame.g_y,
  1705.                         &cons.win->frame.g_w, &cons.win->frame.g_h);
  1706.                 wind_close(cons.win->handle);
  1707.                 cons.win->opened = 0;
  1708.             }
  1709.  
  1710.             wind_set(icon.handle, WF_ICONIFY,
  1711.                 msgbuff[4], msgbuff[5], msgbuff[6], msgbuff[7]);
  1712.  
  1713.             wind_get(icon.handle, WF_CURRXYWH,
  1714.                 &icon.frame.g_x, &icon.frame.g_y,
  1715.                 &icon.frame.g_w, &icon.frame.g_h);
  1716.                 
  1717.                 wind_open(icon.handle, icon.frame.g_x, icon.frame.g_y,
  1718.                     icon.frame.g_w, icon.frame.g_h);
  1719.  
  1720.             wind_get(icon.handle, WF_WORKXYWH,
  1721.                     &icon.canvas.g_x, &icon.canvas.g_y,
  1722.                     &icon.canvas.g_w, &icon.canvas.g_h);
  1723.  
  1724.             noghost[0].ob_x = icon.canvas.g_x;
  1725.             noghost[0].ob_y = icon.canvas.g_y;
  1726.             icon.opened = 1;
  1727.             break;
  1728.             
  1729.         case WM_UNICONIFY:                /* CF */
  1730.             wind_set(icon.handle, WF_UNICONIFY,
  1731.                 icon.frame.g_x, icon.frame.g_y,
  1732.                 icon.frame.g_w, icon.frame.g_h);
  1733.                 
  1734.             wind_get(icon.handle, WF_CURRXYWH,
  1735.                 &icon.frame.g_x, &icon.frame.g_y,
  1736.                 &icon.frame.g_w, &icon.frame.g_h);
  1737.             wind_close(icon.handle);
  1738.  
  1739.             wind_open(imag.handle, imag.oframe.g_x, 
  1740.                        imag.oframe.g_y, imag.oframe.g_w, imag.oframe.g_h);
  1741.                         
  1742.                 wind_open(cons.win->handle, cons.win->frame.g_x, cons.win->frame.g_y,
  1743.                     cons.win->frame.g_w, cons.win->frame.g_h);
  1744.  
  1745.             icon.opened = 0;
  1746.             imag.opened = 1;
  1747.             cons.win->opened = 1;
  1748.             break;
  1749.                         
  1750.         case COMMAND:
  1751.             dprintf1("%s", command);
  1752.             graf_mouse(BUSY_BEE, 0L);
  1753.             loop_end = 1;
  1754.             break;
  1755.  
  1756.         }
  1757.  
  1758.         }
  1759.  
  1760.     }
  1761.  
  1762.     return 0;
  1763. }
  1764.  
  1765. private int
  1766. win_std_write_buf(register stream *s)
  1767. {
  1768.  
  1769.     char string[COLUMNS+1];
  1770.  
  1771.     char *ptr = s->cbuf;
  1772.  
  1773.     int i, j, tempcol;
  1774.  
  1775.     uint count = s->cptr + 1 - s->cbuf;
  1776.         
  1777.     cursor(OFF);
  1778.     msgbuff[3] = cons.win->handle;
  1779.  
  1780.     for (i=0, tempcol=0; i<count; i++) {
  1781.  
  1782.         switch(*ptr) {
  1783.  
  1784.         case '\r':
  1785.         case '\n':
  1786.         newline:
  1787.  
  1788.         string[tempcol] = '\0';
  1789.         strcat(cons.text[cons.ln], string);
  1790.         next_line();
  1791.  
  1792.         tempcol = 0;
  1793.  
  1794.         ptr++;
  1795.         break;
  1796.  
  1797.         case '\t':
  1798.  
  1799.         for(j=0; j<8; j++) {        
  1800.             string[tempcol++] = ' ';
  1801.             cons.cn++;
  1802.         }
  1803.         
  1804.         ptr++;
  1805.         break;
  1806.  
  1807.         case '\b':
  1808.         --tempcol;
  1809.         if (--cons.cn < 0) cons.cn = 0;
  1810.         else --ptr;
  1811.         break;
  1812.  
  1813.         default:
  1814.  
  1815.         string[tempcol++] = *ptr;
  1816.         if (++cons.cn >= COLUMNS) goto newline;
  1817.  
  1818.         ptr++;
  1819.         break;
  1820.  
  1821.         }
  1822.  
  1823.     }
  1824.  
  1825.     if (tempcol) {
  1826.         int dirtw;
  1827.  
  1828.         string[tempcol] = '\0';
  1829.         strcat(cons.text[cons.ln], string);
  1830.  
  1831.         dirtw = strlen(string) * cons.wc;
  1832.         msgbuff[4] = cons.cx;
  1833.         msgbuff[5] = cons.cy;
  1834.         msgbuff[6] = dirtw;
  1835.         msgbuff[7] = cons.hc;
  1836.  
  1837.         gp_win_redraw(DIRT_RECT);
  1838.  
  1839.         cons.cx += dirtw;
  1840.  
  1841.     }
  1842.  
  1843.     cursor(ON);
  1844.     s->cptr = s->cbuf - 1;
  1845.     s->endptr = s->cptr + s->bsize;
  1846.  
  1847.     return 0;
  1848. }
  1849.  
  1850. int
  1851. gemputc(uint ch)
  1852. {
  1853.     char c[2];
  1854.  
  1855.     cursor(OFF);
  1856.     msgbuff[3] = cons.win->handle;
  1857.  
  1858.     switch (ch) {
  1859.  
  1860.     default:
  1861.  
  1862.     c[0] = ch;
  1863.     c[1] = '\0';
  1864.  
  1865.     strcat(cons.text[cons.ln], c);
  1866.  
  1867.     msgbuff[4] = cons.cx;
  1868.     msgbuff[5] = cons.cy;
  1869.     msgbuff[6] = cons.wc;
  1870.     msgbuff[7] = cons.hc;
  1871.  
  1872.     gp_win_redraw(DIRT_RECT);
  1873.  
  1874.     if (++cons.cn >= COLUMNS) goto newline;
  1875.     cons.cx += cons.wc;
  1876.     break;
  1877.  
  1878.     case '\r':
  1879.     case '\n':
  1880.     newline:
  1881.  
  1882.     cons.text[cons.ln][cons.cn] = '\0';
  1883.  
  1884.     if (++cons.ln >= LINES) {
  1885.         cons.ln = 0;
  1886.         cons.scrolled = 1;
  1887.     }
  1888.  
  1889.     *cons.text[cons.ln] = '\0';
  1890.  
  1891.     if (cons.scrolled) {
  1892.         if (++cons.fl >= LINES) cons.fl = 0;
  1893.         if (++cons.fdl >= LINES) cons.fdl = 0;
  1894.         if (++cons.ll >= LINES) cons.ll = 0;
  1895.         if (++cons.ldl >= LINES) cons.ldl = 0;
  1896.         gp_win_redraw(FULL_WIN);
  1897.     }
  1898.     else if (cons.ln == (cons.ldl + 1)) {
  1899.         cons.top -= cons.hc;
  1900.         cons.fdl++;
  1901.         cons.ldl++;
  1902.         gp_win_redraw(FULL_WIN);
  1903.         update_scroll(cons.win->handle);
  1904.     }
  1905.     else {
  1906.         cons.cy += cons.hc;
  1907.     }
  1908.  
  1909.     cons.cx = align(cons.edge + cons.xoff);
  1910.     cons.cn = 0;
  1911.  
  1912.     break;
  1913.  
  1914.     case '\b':
  1915.     cons.text[cons.ln][--cons.cn] = '\0';
  1916.     cons.cx -= cons.wc;
  1917.     break;
  1918.  
  1919.     }
  1920.  
  1921.     cursor(ON);
  1922. }
  1923.  
  1924. int clear_line(int cnt)
  1925. {
  1926.     int x, w;
  1927.  
  1928.     cursor(OFF);
  1929.     msgbuff[3] = cons.win->handle;
  1930.  
  1931.     if (cnt < 0) {
  1932.         *cons.text[cons.ln] = '\0';
  1933.     x = cons.win->canvas.g_x;
  1934.     w = cons.win->canvas.g_w;
  1935.     cons.cx = align(cons.edge + cons.xoff);
  1936.     cons.cn = 0;
  1937.     }
  1938.     else {
  1939.     cons.cn = MAX(cons.cn - cnt, 0);
  1940.     cons.cx -= cnt * cons.wc;
  1941.     cons.text[cons.ln][cons.cn] = '\0';
  1942.     x = MAX(cons.cx, cons.win->canvas.g_x);
  1943.     w = MIN(cnt * cons.wc, cons.win->canvas.g_w);
  1944.     }
  1945.  
  1946.     msgbuff[4] = x;
  1947.     msgbuff[5] = cons.cy;
  1948.     msgbuff[6] = w;
  1949.     msgbuff[7] = cons.hc;
  1950.  
  1951.     gp_win_redraw(DIRT_RECT);
  1952.  
  1953.     cursor(ON);
  1954.  
  1955. }
  1956.  
  1957. int next_line(void)
  1958. {
  1959.  
  1960.     if (++cons.ln >= LINES) {
  1961.     cons.ln = 0;
  1962.     cons.scrolled = 1;
  1963.     }
  1964.  
  1965.     *cons.text[cons.ln] = '\0';
  1966.  
  1967.     if (cons.scrolled) {
  1968.     if (++cons.fl  >= LINES) cons.fl  = 0;
  1969.     if (++cons.fdl >= LINES) cons.fdl = 0;
  1970.     if (++cons.ll  >= LINES) cons.ll  = 0;
  1971.     if (++cons.ldl >= LINES) cons.ldl = 0;
  1972.     gp_win_redraw(FULL_WIN);
  1973.     }
  1974.     else if (cons.ln == (cons.ldl + 1)) {
  1975.     cons.top -= cons.hc;
  1976.     cons.fdl++;
  1977.     cons.ldl++;
  1978.     gp_win_redraw(FULL_WIN);
  1979.     update_scroll(cons.win->handle);
  1980.     }
  1981.     else {
  1982.     msgbuff[4] = cons.cx;
  1983.     msgbuff[5] = cons.cy;
  1984.     msgbuff[6] = cons.win->canvas.g_x + cons.win->canvas.g_w - cons.cx;
  1985.     msgbuff[7] = cons.hc;
  1986.     gp_win_redraw(DIRT_RECT);
  1987.  
  1988.     cons.cy += cons.hc;
  1989.     }
  1990.  
  1991.     cons.cx = align(cons.edge + cons.xoff);
  1992.     cons.cn = 0;
  1993.  
  1994. }
  1995.  
  1996. /* ------ Printer accessing ------ */
  1997.  
  1998. /* Open a file or a printing device. A null file name will cause
  1999.  * output to be sent to "PRN:". If gp_open_printer returns
  2000.  * a NULL, the file will be sent directly to the centronics port.
  2001.  * This happens if fname = "CEN:" or if gp_open_scratch_file()
  2002.  * fails. Usually, GS wants to interpret a NULL return value as
  2003.  * an error, so this is slightly incompatible.
  2004.  * "|command" opens an output pipe.
  2005.  */
  2006.  
  2007. FILE *
  2008. gp_open_printer(char *fname, int binary_mode)
  2009. {
  2010.     if (!strcmp(fname, "CEN:")) {    /* Direct Centronics printing. */
  2011.        return NULL;
  2012.     }
  2013.     else {
  2014.        return
  2015.          (strlen(fname) == 0 ?
  2016.           gp_open_scratch_file(gp_scratch_file_name_prefix, fname, "wb") :
  2017.           fname[0] == '|' ?
  2018.           popen(fname + 1, "wb") :
  2019.           fopen(fname, "wb"));
  2020.     }
  2021. }
  2022.  
  2023. /* Close the connection to the printer. */
  2024. void
  2025. gp_close_printer(FILE *pfile, const char *fname)
  2026. {    if ( fname[0] == '|' )
  2027.         pclose(pfile);
  2028.     else
  2029.         fclose(pfile);
  2030. }
  2031.  
  2032. /* ------ File name syntax ------ */
  2033.  
  2034. /* Define the character used for separating file names in a list. */
  2035. char gp_file_name_list_separator = ',';
  2036.  
  2037. /* Define the default scratch file name prefix. */
  2038. const char gp_scratch_file_name_prefix[] = "gs_pr.";
  2039.  
  2040. /* Define the string to be concatenated with the file mode */
  2041. /* for opening files without end-of-line conversion. */
  2042. const char gp_fmode_binary_suffix[] = "b";
  2043.  
  2044. /* Define the file modes for binary reading or writing. */
  2045. const char gp_fmode_rb[] = "rb";
  2046. const char gp_fmode_wb[] = "wb";
  2047.  
  2048. /* Define whether case is insignificant in file names. */
  2049. const int gp_file_names_ignore_case = 1;
  2050.  
  2051. /* Create and open a scratch file with a given name prefix. */
  2052. /* Write the actual file name at fname. */
  2053.  
  2054. #if 0
  2055.  
  2056. FILE *
  2057. gp_open_scratch_file(const char *prefix, char *fname, const char *mode)
  2058. {
  2059.     strcpy(fname, prefix);
  2060.     strcat(fname, "XXX");
  2061.     mktemp(fname);
  2062.     return fopen(fname, mode);
  2063. }
  2064.  
  2065. #endif
  2066.  
  2067. FILE *
  2068. gp_open_scratch_file(const char *prefix, char *fname, const char *mode)
  2069. {    char *temp;
  2070.  
  2071.     if ( (temp = getenv("TEMP")) != NULL )
  2072.         strcpy(fname, temp);
  2073.     else
  2074.         strcpy(fname, "");
  2075.  
  2076.     strcat(fname, prefix);
  2077.  
  2078.     /* Prevent trailing X's in path from being converted by mktemp. */
  2079.     if ( *fname != 0 && fname[strlen(fname) - 1] == 'X' )
  2080.         strcat(fname, "-");
  2081.  
  2082.     strcat(fname, "XXX");
  2083.     mktemp(fname);
  2084.     return fopen(fname, mode);
  2085. }
  2086.  
  2087. /* Answer whether a file name contains a directory/device specification, */
  2088. /* i.e. is absolute (not directory- or device-relative). */
  2089. int
  2090. gp_file_name_is_absolute(const char *fname, uint len)
  2091. {    /* A file name is absolute if it contains a drive specification */
  2092.     /* (second character is a :) or if it start with / or \. */
  2093.     return ( len >= 1 && (*fname == '/' || *fname == '\\' ||
  2094.         (len >= 2 && fname[1] == ':')) );
  2095. }
  2096.  
  2097. /* Answer the string to be used for combining a directory/device prefix */
  2098. /* with a base file name.  The file name is known to not be absolute. */
  2099. const char *
  2100. gp_file_name_concat_string(const char *prefix, uint plen,
  2101.                const char *fname, uint len)
  2102. {    if ( plen > 0 )
  2103.       switch ( prefix[plen - 1] )
  2104.        {    case ':': case '/': case '\\': return "";
  2105.        };
  2106.     return "\\";
  2107. }
  2108.  
  2109. /* ------ File operations ------ */
  2110.  
  2111. /* If the file given by fname exists, fill in its status and return 1; */
  2112. /* otherwise return 0. */
  2113. int
  2114. gp_file_status(const char *fname, file_status *pstatus)
  2115. {    struct stat sbuf;
  2116.     /* The RS/6000 prototype for stat doesn't include const, */
  2117.     /* so we have to explicitly remove the const modifier. */
  2118.     if ( stat((char *)fname, &sbuf) < 0 ) return 0;
  2119.     pstatus->size_pages = stat_blocks(&sbuf);    /* st_blocks is */
  2120.                     /* missing on some systems, */
  2121.                     /* see stat_.h */
  2122.     pstatus->size_bytes = sbuf.st_size;
  2123.     pstatus->time_referenced = sbuf.st_mtime;
  2124.     pstatus->time_created = sbuf.st_ctime;
  2125.     return 1;
  2126. }
  2127.  
  2128. /* ------ File enumeration ------ */
  2129.  
  2130. /****** THIS IS NOT SUPPORTED ON UNIX SYSTEMS. ******/
  2131. /* Amazingly enough, there is no standard Unix library routine */
  2132. /* for enumerating the files matching a pattern, */
  2133. /* or even for enumerating (conveniently) the files in a directory. */
  2134.  
  2135. struct file_enum_s {
  2136.     char *pattern;
  2137.     int first_time;
  2138.     const gs_memory_procs *mprocs;
  2139. };
  2140.  
  2141. /* Initialize an enumeration.  NEEDS WORK ON HANDLING * ? \. */
  2142.  
  2143. file_enum *
  2144. gp_enumerate_files_init(const char *pat, uint patlen,
  2145.   const gs_memory_procs *mprocs)
  2146. {    file_enum *pfen = (file_enum *)(*mprocs->alloc)(1, sizeof(file_enum), "gp_enumerate_files");
  2147.     char *pattern;
  2148.     if ( pfen == 0 ) return 0;
  2149.     pattern = (*mprocs->alloc)(patlen + 1, 1,
  2150.                 "gp_enumerate_files(pattern)");
  2151.     if ( pattern == 0 ) return 0;
  2152.     memcpy(pattern, pat, patlen);
  2153.     pattern[patlen] = 0;
  2154.     pfen->pattern = pattern;
  2155.     pfen->mprocs = mprocs;
  2156.     pfen->first_time = 1;
  2157.     return pfen;
  2158. }
  2159.  
  2160. /* Enumerate the next file. */
  2161. /* PUNT: JUST RETURN THE PATTERN. */
  2162.  
  2163. uint
  2164. gp_enumerate_files_next(file_enum *pfen, char *ptr, uint maxlen)
  2165. {    if ( pfen->first_time )
  2166.     {    char *pattern = pfen->pattern;
  2167.         uint len = strlen(pattern);
  2168.         pfen->first_time = 0;
  2169.         if ( len > maxlen )
  2170.             return maxlen + 1;
  2171.         strcpy(ptr, pattern);
  2172.         return len;
  2173.     }
  2174.     return -1;
  2175. }
  2176.  
  2177. /* Clean up the file enumeration. */
  2178.  
  2179. void
  2180. gp_enumerate_files_close(file_enum *pfen)
  2181. {    const gs_memory_procs *mprocs = pfen->mprocs;
  2182.     (*mprocs->free)(pfen->pattern, strlen(pfen->pattern) + 1, 1,
  2183.             "gp_enumerate_files_close(pattern)");
  2184.     (*mprocs->free)((char *)pfen, 1, sizeof(file_enum),
  2185.             "gp_enumerate_files_close");
  2186. }
  2187.  
  2188.  
  2189. int
  2190. gp_win_redraw(int flag)
  2191. {
  2192.  
  2193.     wind_update(BEG_UPDATE);    /* lock the screen */
  2194.  
  2195.     if (msgbuff[3] == icon.handle) {
  2196.     (icon.redraw)(flag, noghost, &icon);
  2197.     }
  2198.     else if (msgbuff[3] == dial.handle) {
  2199.     (dial.redraw)(flag, about, &dial);
  2200.     }
  2201.     else if (msgbuff[3] == cons.win->handle) {
  2202.     (cons.win->redraw)(flag, &cons);
  2203.     }
  2204.     else {
  2205.     (imag.redraw)(flag, &imag);
  2206.     }
  2207.  
  2208.     wind_update(END_UPDATE);    /* release screen */
  2209.  
  2210. }
  2211.  
  2212. int
  2213. cons_redraw(int full_win, TEXTWIN *tw)
  2214. {
  2215.  
  2216.     int i, cnt;
  2217.     int x = align(tw->win->canvas.g_x + tw->xoff);
  2218.     int fcol = tw->fdc;
  2219.     int y, ln, *tpxy = pxy;
  2220.  
  2221.     GRECT redraw, rect;
  2222.  
  2223.     graf_mouse(M_OFF, 0L );
  2224.  
  2225.     if (full_win) {
  2226.     redraw.g_x = tw->win->canvas.g_x;
  2227.     redraw.g_y = tw->win->canvas.g_y;
  2228.     redraw.g_w = tw->win->canvas.g_w;
  2229.     redraw.g_h = tw->win->canvas.g_h;
  2230.     }
  2231.     else {
  2232.     redraw.g_x = msgbuff[4];
  2233.     redraw.g_y = msgbuff[5];
  2234.     redraw.g_w = msgbuff[6];
  2235.     redraw.g_h = msgbuff[7];
  2236.     }
  2237.  
  2238.     cnt = tw->ln - tw->fdl + 1;
  2239.     cnt = (cnt > 0) ? cnt : cnt + LINES;
  2240.     cnt = MIN(cnt, tw->lins);
  2241.  
  2242.     wind_get(tw->win->handle, WF_FIRSTXYWH,
  2243.     &rect.g_x, &rect.g_y,
  2244.     &rect.g_w, &rect.g_h);
  2245.  
  2246.     while (rect.g_w && rect.g_h) {
  2247.  
  2248.     if (intersect(&redraw, &rect)) {
  2249.         if (intersect(&tw->win->canvas, &rect)) {
  2250.         
  2251.         grect_to_array(&rect, pxy);
  2252.         vs_clip(VdiHandle, 1, pxy);
  2253.         
  2254.         clear_win(&rect);
  2255.  
  2256.         y = tw->win->canvas.g_y + tw->yoff;
  2257.  
  2258.         for (ln=tw->fdl, i=cnt; i; i--, ln++, y+=cons.hc) {
  2259.             if (ln >= LINES) ln -= LINES;
  2260.             if (strlen(cons.text[ln]) > fcol)
  2261.             v_gtext(VdiHandle, x, y, cons.text[ln]+fcol);
  2262.         }
  2263.  
  2264.         vs_clip(VdiHandle, 0, pxy);
  2265.  
  2266.         }
  2267.     }
  2268.  
  2269.     wind_get(tw->win->handle, WF_NEXTXYWH,
  2270.         &rect.g_x, &rect.g_y,
  2271.         &rect.g_w, &rect.g_h);
  2272.     }
  2273.  
  2274.     graf_mouse(M_ON, 0L );
  2275.  
  2276. }
  2277.  
  2278. int
  2279. objw_redraw(int full_win, OBJECT *object, WINDOW *w)
  2280. {
  2281.  
  2282.     GRECT redraw, rect;
  2283.  
  2284.     graf_mouse(M_OFF, 0L );
  2285.  
  2286.     if (full_win) {
  2287.     redraw.g_x = w->canvas.g_x;
  2288.     redraw.g_y = w->canvas.g_y;
  2289.     redraw.g_w = w->canvas.g_w;
  2290.     redraw.g_h = w->canvas.g_h;
  2291.     }
  2292.     else {
  2293.     redraw.g_x = msgbuff[4];
  2294.     redraw.g_y = msgbuff[5];
  2295.     redraw.g_w = msgbuff[6];
  2296.     redraw.g_h = msgbuff[7];
  2297.     }
  2298.  
  2299.     wind_get(msgbuff[3], WF_FIRSTXYWH,
  2300.     &rect.g_x, &rect.g_y,
  2301.     &rect.g_w, &rect.g_h);
  2302.  
  2303.     while (rect.g_w && rect.g_h) {
  2304.  
  2305.     if (intersect(&redraw, &rect)) {
  2306.         if (intersect(&w->canvas, &rect)) {
  2307.         objc_draw(object, 0, 1,
  2308.             rect.g_x, rect.g_y,
  2309.             rect.g_w, rect.g_h);
  2310.         }
  2311.     }
  2312.  
  2313.     wind_get(msgbuff[3], WF_NEXTXYWH,
  2314.         &rect.g_x, &rect.g_y,
  2315.         &rect.g_w, &rect.g_h);
  2316.  
  2317.     }
  2318.  
  2319.     graf_mouse(M_ON, 0L );
  2320.  
  2321. }
  2322.  
  2323. int
  2324. form_redraw(int full_win, WINDOW *w)
  2325. {
  2326.  
  2327.     int tpxy[4];
  2328.  
  2329.     GRECT redraw, rect;
  2330.  
  2331.     graf_mouse(M_OFF, 0L );
  2332.  
  2333.     if (full_win) {
  2334.     redraw.g_x = w->canvas.g_x;
  2335.     redraw.g_y = w->canvas.g_y;
  2336.     redraw.g_w = w->canvas.g_w;
  2337.     redraw.g_h = w->canvas.g_h;
  2338.     }
  2339.     else {
  2340.     redraw.g_x = msgbuff[4];
  2341.     redraw.g_y = msgbuff[5];
  2342.     redraw.g_w = msgbuff[6];
  2343.     redraw.g_h = msgbuff[7];
  2344.     }
  2345.  
  2346.     if (plot_x >= width - w->canvas.g_w)
  2347.     plot_x = (width - 1) - w->canvas.g_w;
  2348.     if (plot_x < 0) plot_x = 0;
  2349.  
  2350.     if (plot_y >= height - w->canvas.g_h)
  2351.     plot_y = (height - 1) - w->canvas.g_h;
  2352.     if (plot_y < 0) plot_y = 0;
  2353.  
  2354.     wind_get(msgbuff[3], WF_FIRSTXYWH,
  2355.     &rect.g_x, &rect.g_y,
  2356.     &rect.g_w, &rect.g_h);
  2357.  
  2358.     while (rect.g_w && rect.g_h) {
  2359.     if (intersect(&redraw, &rect)) {
  2360.         if (intersect(&w->canvas, &rect)) {
  2361.         
  2362.         pxy[0] = plot_x + (rect.g_x - w->canvas.g_x);
  2363.         pxy[1] = plot_y + (rect.g_y - w->canvas.g_y);
  2364.         pxy[2] = pxy[0] + rect.g_w - 1;
  2365.         pxy[3] = pxy[1] + rect.g_h - 1;
  2366.  
  2367.         grect_to_array(&rect, &pxy[4]);
  2368.  
  2369.         vs_clip(VdiHandle, 1, &pxy[4]);
  2370.         vro_cpyfm(VdiHandle, 3, pxy, &image, &screen);
  2371.         vs_clip(VdiHandle, 0, &pxy[4]);
  2372.  
  2373.         }
  2374.     }
  2375.  
  2376.     wind_get(w->handle, WF_NEXTXYWH,
  2377.         &rect.g_x, &rect.g_y,
  2378.         &rect.g_w, &rect.g_h);
  2379.     }
  2380.  
  2381.     graf_mouse(M_ON, 0L );
  2382.  
  2383. }
  2384.  
  2385. int align(int x)
  2386. {
  2387.     return ((x & 0xfffffff0) + ((x & 0xf) ? 0x10 : 0));
  2388. /*    return ((x & 0xfffffff8) + ((x & 0x07) ? 0x08 : 0)); */
  2389. }
  2390.  
  2391. int visible_lines(void)
  2392. {
  2393.     return ((cons.win->canvas.g_h - cons.yoff) / cons.hc);
  2394. }
  2395.  
  2396. int visible_cols(void)
  2397. {
  2398.     return ((cons.win->canvas.g_w - align(cons.xoff)) / cons.wc);
  2399. }
  2400.  
  2401. int cursor(int state)
  2402. {
  2403.     int xy[4], txy[4];
  2404.     GRECT rect;
  2405.  
  2406.     if ((state == OFF && cons.cstate == ON) ||
  2407.     (state == ON  && cons.cstate == OFF)) {
  2408.  
  2409.     vsf_interior(VdiHandle, 1);    /* set fill mode to solid */
  2410.     vswr_mode(VdiHandle, 3);    /* set write mode to XOR */
  2411.  
  2412.     xy[0] = cons.cx;
  2413.     xy[1] = cons.cy;
  2414.     xy[2] = xy[0] + cons.wc - 1;
  2415.     xy[3] = xy[1] + cons.hc - 1;
  2416.  
  2417.     wind_get(cons.win->handle, WF_FIRSTXYWH,
  2418.         &rect.g_x, &rect.g_y,
  2419.         &rect.g_w, &rect.g_h);
  2420.  
  2421.     while (rect.g_w && rect.g_h) {
  2422.  
  2423.         if (intersect(&cons.win->canvas, &rect)) {
  2424.  
  2425.         grect_to_array(&rect, txy);
  2426.         vs_clip(VdiHandle, 1, txy);
  2427.  
  2428.         vr_recfl(VdiHandle, xy);    /* draw the cursor */
  2429.  
  2430.         vs_clip(VdiHandle, 0, txy);
  2431.  
  2432.         }
  2433.  
  2434.         wind_get(cons.win->handle, WF_NEXTXYWH,
  2435.         &rect.g_x, &rect.g_y,
  2436.         &rect.g_w, &rect.g_h);
  2437.  
  2438.     }
  2439.  
  2440.     vs_clip(VdiHandle, 0, xy);
  2441.     vswr_mode(VdiHandle, 1);        /* restore replace mode */
  2442.     cons.cstate = !cons.cstate;        /* toggle cursor state  */
  2443.  
  2444.     }
  2445. }
  2446.  
  2447. int update_scroll(int handle)
  2448. {
  2449.  
  2450.     int hslide_pos, hslide_siz, vslide_pos, vslide_siz;
  2451.  
  2452.     if (handle == imag.handle) {
  2453.  
  2454.     if (width != imag.canvas.g_w) {
  2455.         hslide_pos = 1000 * plot_x/(width - imag.canvas.g_w);
  2456.     }
  2457.     else {
  2458.         hslide_pos = 0;
  2459.     }
  2460.  
  2461.     if (height != imag.canvas.g_h) {
  2462.         vslide_pos = 1000 * plot_y/(height - imag.canvas.g_h);
  2463.     }
  2464.     else {
  2465.         vslide_pos = 0;
  2466.     }
  2467.  
  2468.     hslide_siz = 1000 * imag.canvas.g_w/width;
  2469.     vslide_siz = 1000 * imag.canvas.g_h/height;
  2470.  
  2471.  
  2472.     }
  2473.     else if (handle == cons.win->handle) {
  2474.     int offset = cons.fdl - cons.fl;
  2475.  
  2476.     if (offset < 0) offset += LINES;
  2477.  
  2478.     if (cons.cols != CLIMIT) {
  2479.         hslide_pos = 1000 * cons.fdc/(CLIMIT - cons.cols);
  2480.     }
  2481.     else {
  2482.         hslide_pos = 0;
  2483.     }
  2484.  
  2485.     if (cons.lins < LINES) {
  2486.         vslide_pos = 1000 * offset/(LINES - cons.lins);
  2487.     }
  2488.     else {
  2489.         vslide_pos = 0;
  2490.     }
  2491.  
  2492.     hslide_siz = 1000 * cons.cols/CLIMIT;
  2493.     vslide_siz = 1000 * cons.lins/LINES;
  2494.  
  2495.     }
  2496.  
  2497.     wind_set(handle, WF_HSLIDE,  hslide_pos);
  2498.     wind_set(handle, WF_VSLIDE,  vslide_pos);
  2499.     wind_set(handle, WF_HSLSIZE, hslide_siz);
  2500.     wind_set(handle, WF_VSLSIZE, vslide_siz);
  2501.  
  2502. }
  2503.  
  2504.  
  2505. int intersect(GRECT *rec1, GRECT *rec2)
  2506. {
  2507.     GRECT temp;
  2508.  
  2509.     temp.g_x = MAX(rec1->g_x, rec2->g_x);
  2510.     temp.g_y = MAX(rec1->g_y, rec2->g_y);
  2511.     temp.g_w = MIN(rec1->g_x + rec1->g_w, rec2->g_x + rec2->g_w);
  2512.     temp.g_h = MIN(rec1->g_y + rec1->g_h, rec2->g_y + rec2->g_h);
  2513.  
  2514.     rec2->g_x = temp.g_x;
  2515.     rec2->g_y = temp.g_y;
  2516.     rec2->g_w = temp.g_w - temp.g_x;
  2517.     rec2->g_h = temp.g_h - temp.g_y;
  2518.  
  2519.     return ((temp.g_w > temp.g_x) && (temp.g_h > temp.g_y));
  2520. }
  2521.  
  2522. /* Adjust the size of an object for the current screen resolution. */
  2523.  
  2524. int objc_fix(OBJECT *object)
  2525. {
  2526.     int i=-1;
  2527.  
  2528.     do {
  2529.     i++;
  2530.  
  2531.     if      (object[i].ob_x == 769) object[i].ob_x = full.g_y;
  2532.     else if (object[i].ob_x == 513) object[i].ob_x = full.g_y;
  2533.     else                object[i].ob_x *= cons.wc;
  2534.  
  2535.     if      (object[i].ob_y == 769) object[i].ob_y = full.g_y;
  2536.     else if (object[i].ob_y == 513) object[i].ob_y = full.g_y;
  2537.     else                object[i].ob_y *= cons.hc;
  2538.  
  2539.     if      (object[i].ob_width == 769) object[i].ob_width = full.g_y;
  2540.     else if (object[i].ob_width == 513) object[i].ob_width = full.g_y;
  2541.     else if (object[i].ob_width == 80)  object[i].ob_width = full.g_w;
  2542.     else                    object[i].ob_width *= cons.wc;
  2543.  
  2544.     if      (object[i].ob_height == 769) object[i].ob_height = full.g_y;
  2545.     else if (object[i].ob_height == 513) object[i].ob_height = full.g_y;
  2546.     else                     object[i].ob_height *= cons.hc;
  2547.  
  2548.     }
  2549.     while (!(object[i].ob_flags & LASTOB));
  2550.  
  2551. }
  2552.  
  2553. int clear_win(GRECT *area)
  2554. {
  2555.     int xy[4];
  2556.  
  2557.     xy[0] = area->g_x;
  2558.     xy[1] = area->g_y;
  2559.     xy[2] = xy[0] + area->g_w - 1;
  2560.     xy[3] = xy[1] + area->g_h - 1;
  2561.  
  2562.     vsf_interior(VdiHandle, 0);    /* set fill mode to hollow */
  2563.     vr_recfl(VdiHandle, xy);        /* clear the window */
  2564. }
  2565.  
  2566. /*
  2567.  * The remainder of this file contains printer output routines, most of
  2568.  * which were contributed by Chris Strunk (some of them were written by me).
  2569.  * I made some modifications to the following code (with permission), and
  2570.  * may have introduced errors not in the original code.
  2571.  * Tim Gallivan, 3/92.
  2572.  */
  2573.  
  2574. /*
  2575.  * This file is Copyright (C) 1990 Christoph Strunk.
  2576.  *
  2577.  * You are not allowed to copy or modify it.
  2578.  */
  2579.  
  2580. #define ATARI_TOS    (1)
  2581. #define MAKE_VOID    (void *)
  2582. #define MAXLEN        (256)
  2583.  
  2584. void con_flush();
  2585. int OutputIsAscii = 0, RTX_Found = 0;
  2586. long *old_ssp = NULL;
  2587. FILE *OutFile = NULL;
  2588.  
  2589. #if PC_DOS || ATARI_TOS
  2590. #  define DIRECT    1    /* 1 = Direct Centronics port programming */
  2591. #endif
  2592.  
  2593. #if ATARI_TOS || ( PC_DOS && DIRECT )
  2594. static short prn_out ( int );
  2595. #endif
  2596.  
  2597. #if ATARI_TOS && LATTICE
  2598. #include <dos.h>
  2599. #endif
  2600.  
  2601. #ifdef __GNUC__
  2602. #include <osbind.h>
  2603. #endif
  2604.  
  2605. #if PC_DOS && DIRECT
  2606. #include <bios.h>
  2607. #endif
  2608.  
  2609. /* output one character */
  2610.  
  2611. static int fatal_output_error = 0;
  2612.  
  2613. void
  2614. lputc(c)
  2615. int c;
  2616. {
  2617.     static short rc;
  2618.     static unsigned char global_count = 0; /* other processes every 256 chars */
  2619.     void l_stop(), fatal();
  2620.  
  2621.     if ( fatal_output_error ) return;
  2622.  
  2623.     global_count += 1;
  2624.  
  2625.     c &= 255;            /* New in 2.9.44: avoid signed char problems */
  2626.  
  2627. #if ATARI_TOS || PC_DOS
  2628.     if ( ( c == '\n' ) && OutputIsAscii ) {
  2629.       lputc ( '\r' );    /* recursion */
  2630.     }
  2631. #endif
  2632.  
  2633.     if ( OutFile ) {
  2634.        rc = ( fputc ( c, OutFile ) == EOF );
  2635.     } else {
  2636. #if ATARI_TOS || ( PC_DOS && DIRECT )
  2637.                    rc = prn_out ( c );
  2638. #else
  2639.                    rc = -1;
  2640. #endif
  2641.     }
  2642.  
  2643.     if ( rc ) {
  2644.         if ( OutFile ) {
  2645.             perror ( "\nlputc" );
  2646.             fprintf ( stderr, "\nOutput error -- %s ?\n",
  2647.                       "Disk full or printer not ready" );
  2648.             fclose ( OutFile );
  2649.             OutFile = NULL;
  2650.         } else {
  2651.             fprintf ( stderr, "\nOutput error -- Printer not ready ?\n" );
  2652.         }
  2653.         l_stop();
  2654.         fatal_output_error = 1;
  2655.         fatal ( "Output error" );
  2656.     }
  2657.  
  2658. #if ATARI_TOS
  2659.     if ( RTX_Found && ! global_count ) call_yield(); /* allow other processes */
  2660. #endif
  2661. }
  2662.  
  2663. /* output a string */
  2664.  
  2665. void
  2666. lputs ( s )
  2667. char *s;
  2668. {
  2669.     while ( *s ) lputc ( *s++ );
  2670. }
  2671.  
  2672. void
  2673. lflush()
  2674. {
  2675.    if ( OutFile ) fflush ( OutFile );
  2676. }
  2677.  
  2678. /* start/stop lputc device */
  2679.  
  2680. void
  2681. l_start()
  2682. {
  2683.   void l_stop(), fatal();
  2684.  
  2685. #if ATARI_TOS && DIRECT
  2686.   volatile char *gpip = (char *) 0xFFFFFA01L;
  2687.   int cnt;
  2688.  
  2689.   if ( OutFile == NULL && old_ssp == NULL ) {
  2690.     old_ssp = (void *) call_super ( NULL );
  2691.     cnt = 0;
  2692. /*    for ( cnt=0; ( *gpip & 1 ) && ( ++cnt <= 10 ); ) {
  2693.      printf("cnt = %d\n", cnt); */
  2694.      Ongibit(0x20);                                        /* set strobe bit */
  2695. /*    } */
  2696.     if ( cnt > 10 ) {
  2697.       l_stop();
  2698.       puts ( "\n" );
  2699.       fatal_output_error = 1;
  2700.       fatal ( "Printer not ready" );
  2701.     }
  2702.   }
  2703. #endif
  2704. #if ATARI_TOS && ! DIRECT
  2705.   int cnt;
  2706.  
  2707.   if ( OutFile == NULL && old_ssp == NULL ) {
  2708.     old_ssp = (void *) call_super ( NULL );
  2709.  
  2710.     for ( cnt=0; ( ! prt_ready(0) ) && ( ++cnt <= 10 ); ) {
  2711.      Ongibit(0x20);                                        /* set strobe bit */
  2712.     }
  2713.     if ( cnt > 10 ) {
  2714.       l_stop();
  2715.       puts ( "\n" );
  2716.       fatal_output_error = 1;
  2717.       fatal ( "Printer not ready" );
  2718.     }
  2719.   }
  2720. #endif
  2721. #if PC_DOS && DIRECT
  2722.   if ( OutFile == NULL && ( biosprint ( 2, 0, BiosChannel ) & 0x29 ) ) {
  2723.     l_stop();
  2724.     puts ( "\n" );
  2725.     fatal_output_error = 1;
  2726.     fatal ( "Printer not ready" );
  2727.   }
  2728. #endif
  2729. }
  2730.  
  2731. void l_stop()
  2732. {
  2733.     lflush();
  2734. #if ATARI_TOS
  2735.     if ( old_ssp != NULL ) {
  2736.         MAKE_VOID call_super ( old_ssp );
  2737.         old_ssp = NULL;
  2738.     }
  2739. #endif
  2740. }
  2741.  
  2742. #if ATARI_TOS && DIRECT
  2743.  
  2744. extern void int_off __PROTO( ( void ) );
  2745.  
  2746. /* int_off:  ori.w  #$0700,sr
  2747.  *           ret
  2748.  */
  2749.  
  2750. extern void int_on __PROTO( ( void ) );
  2751.  
  2752. /* int_on:   andi.w #$F8FF,sr
  2753.  *           ret
  2754.  */
  2755.  
  2756. static short prn_out ( c )
  2757. int c;
  2758. {
  2759.   volatile unsigned long *hz_200;
  2760.   register unsigned long end_time;
  2761.   volatile char *gpip = (char *) 0xFFFFFA01L;
  2762.   register char g;
  2763.  
  2764. #if OLD
  2765.   unsigned char loop_count = 0;
  2766. #endif
  2767.  
  2768.   if ( old_ssp == NULL ) l_start();
  2769.  
  2770.   hz_200 = (unsigned long *) 0x04BAL;
  2771. #if OLD
  2772.   end_time = *hz_200 + 200;        /* check once per second */
  2773. #else
  2774.   end_time = *hz_200 + 2;          /* check 100 times per second */
  2775. #endif
  2776.  
  2777.   while ( *gpip & 1 ) {  /* wait */
  2778. #if OLD
  2779.     /* Printer 1 sec. or more not ready ? */
  2780.     if ( ( end_time < *hz_200 ) ||
  2781.          ( ( ( ++loop_count & 7 ) == 0 ) && ( BatchMode || RTX_Found ) ) ) {
  2782.         con_flush();         /* allow Control_C, other Processes etc. */
  2783.         end_time = *hz_200 + 2;          /* check 100 times per second */
  2784.     }
  2785. #else
  2786.     if ( end_time <= *hz_200 ) {
  2787.         con_flush();               /* allow Control_C, other Processes etc. */
  2788.         end_time = *hz_200 + 1;              /* check 200 times per second */
  2789.     }
  2790. #endif
  2791.   }
  2792.  
  2793.   int_off();                   /* disable interrupts */
  2794.  
  2795.   gpip = (char *) 0xFFFF8800L; /* load sound chip adress now */
  2796.  
  2797.   *gpip = 15;                  /* select port B */
  2798.   gpip[2] = (char) c;          /* write out char */
  2799.   *gpip = 14;                  /* select port A */
  2800.   g = *gpip;                   /* get old value */
  2801. #if OLD
  2802.   g &= 0xDF;                   /* clear strobe bit */
  2803. #else
  2804.   g &= ~0x20;                  /* clear strobe bit */
  2805. #endif
  2806.   gpip[2] = g;
  2807.   g |= 0x20;                   /* set strobe bit */
  2808.   g |= 0x20;                   /* short delay */
  2809.   gpip[2] = g;
  2810.  
  2811.   int_on();                    /* enable interrupts */
  2812.  
  2813.   return 0;
  2814. }
  2815. #endif
  2816.  
  2817. #if ATARI_TOS && ! DIRECT
  2818. static short prn_out ( c )
  2819. int c;
  2820. {
  2821.   volatile unsigned long *hz_200 = (unsigned long *) 0x04BAL;
  2822.   register unsigned long end_time;
  2823.  
  2824.   if ( old_ssp == NULL ) l_start();
  2825.  
  2826.   end_time = *hz_200 + 2;          /* check 200 times per second */
  2827.  
  2828.   while ( ! prt_ready(0) ) {  /* wait */
  2829.     if ( end_time <= *hz_200 ) {
  2830.         con_flush();               /* allow Control_C, other Processes etc. */
  2831.         end_time = *hz_200 + 1;              /* check 200 times per second */
  2832.     }
  2833.   }
  2834.  
  2835.   prt_out ( 0, c );
  2836.  
  2837.   return 0;
  2838. }
  2839. #endif
  2840.  
  2841. #if PC_DOS && DIRECT
  2842.  
  2843. static short prn_out ( c )
  2844. int c;
  2845. {
  2846.   while ( biosprint ( 0, c, BiosChannel ) & 0x29 ) {
  2847.     /* wait until Ok or Control-C pressed */
  2848.     con_flush();
  2849.   }
  2850.  
  2851.   return 0;
  2852. }
  2853.  
  2854. #endif
  2855.  
  2856. void
  2857. con_flush()
  2858. {
  2859.     int chin;
  2860.     void fatal();
  2861.  
  2862.     chin = Crawio(0xFF);
  2863.     if ((chin & 0xFF) == 3) fatal("Keyboard Interrupt");
  2864. }
  2865.  
  2866. void
  2867. fatal(char *message)
  2868. {
  2869.     fprintf(stderr, "%s\n", message);
  2870.     l_stop();
  2871.     exit(-1);
  2872. }
  2873.  
  2874. /* The following routines are generic interfaces to Chris Strunk's
  2875.  * fast printing routines. Tim Gallivan 3/92.
  2876.  */
  2877.  
  2878. int
  2879. csputc(int c, FILE *stream)
  2880. {
  2881.     if (gp_file_is_console(stream) && window) {    /* console I/O to a window */
  2882.     gemputc(c);
  2883.     }
  2884.     else {
  2885.     OutFile = stream;
  2886.     l_start();
  2887.     lputc(c);
  2888.     l_stop();
  2889.     }
  2890.  
  2891.     return c;
  2892. }
  2893.  
  2894. int
  2895. csputs(const char *s, FILE *stream)
  2896. {
  2897.     if (gp_file_is_console(stream) && window) {    /* console I/O to a window */
  2898.     gemprintf(stream, s);
  2899.     }
  2900.     else {
  2901.     OutFile = stream;
  2902.     l_start();
  2903.     lputs(s);
  2904.     l_stop();
  2905.     }
  2906.  
  2907.     return 1;
  2908. }
  2909.  
  2910. size_t
  2911. cswrite(const void *ptr, size_t size, size_t nobj, FILE *stream)
  2912. {
  2913.     int count;
  2914.  
  2915.     if (stream == NULL) {
  2916.         OutFile = stream;
  2917.         l_start();
  2918.         for (count=0; count < size*nobj; count++) {
  2919.             lputc(*(char *)(ptr++));       /* send the data */
  2920.         }
  2921.         l_stop();
  2922.         return count;
  2923.     }
  2924.     else {
  2925.         int ret;
  2926.         ret = fwrite(ptr, size, nobj, stream);
  2927.         con_flush();
  2928.         return ret;
  2929.     }
  2930.         
  2931. }
  2932.  
  2933. #if 0
  2934. int
  2935. csprintf(FILE *stream, char *format, ...)
  2936. {
  2937.     va_list args;
  2938.     char line[MAXLEN];
  2939.  
  2940.     va_start(args, format);
  2941.  
  2942.     if (stream == NULL) {
  2943.         OutFile = stream;
  2944.         vsprintf(line, format, args);
  2945.         l_start();
  2946.         lputs(line);
  2947.         l_stop();
  2948.         va_end(args);
  2949.         return 0;
  2950.     }
  2951.     else {
  2952.         vfprintf(stream, format, args);
  2953.         va_end(args);
  2954.         con_flush();
  2955.         return 0;
  2956.     }
  2957.  
  2958. }
  2959. #endif
  2960.  
  2961. int
  2962. gemprintf(FILE *stream, const char *format, ...)
  2963. {
  2964.     va_list args;
  2965.  
  2966.     char c, *lptr, *bptr;
  2967.     char buffer[1024], line[COLUMNS+1];
  2968.     
  2969.     int i, count;
  2970.  
  2971.     va_start(args, format);
  2972.  
  2973.     lptr = line;
  2974.     bptr = buffer;
  2975.  
  2976.     if (gp_file_is_console(stream) && window) {    /* console I/O to a window */
  2977.  
  2978.     msgbuff[3] = cons.win->handle;
  2979.     cursor(OFF);
  2980.  
  2981.     count = vsprintf(buffer, format, args);
  2982.  
  2983.     for (; (c = *bptr) != '\0'; bptr++) {
  2984.       switch (c) {
  2985.  
  2986.         case '\r':
  2987.         case '\n':
  2988.         newline:
  2989.         *lptr = '\0';
  2990.         strcat(cons.text[cons.ln], line);
  2991.         next_line();
  2992.  
  2993.         lptr = line;
  2994.         break;
  2995.  
  2996.         default:
  2997.         *lptr++ = c;
  2998.         if (++cons.cn >= COLUMNS) goto newline;
  2999.  
  3000.       }
  3001.  
  3002.     }
  3003.  
  3004.     if (lptr != line) {
  3005.         int dirtw;
  3006.  
  3007.         *lptr = '\0';
  3008.         strcat(cons.text[cons.ln], line);
  3009.  
  3010.         dirtw = strlen(line) * cons.wc;
  3011.         msgbuff[4] = cons.cx;
  3012.         msgbuff[5] = cons.cy;
  3013.         msgbuff[6] = dirtw;
  3014.         msgbuff[7] = cons.hc;
  3015.  
  3016.         gp_win_redraw(DIRT_RECT);
  3017.  
  3018.         cons.cx += dirtw;
  3019.  
  3020.     }
  3021.  
  3022.     cursor(ON);
  3023.  
  3024.     }
  3025.     else if (stream == NULL) {        /* output for the centronics port */
  3026.     OutFile = stream;
  3027.     count = vsprintf(buffer, format, args);
  3028.     l_start();
  3029.     lputs(buffer);
  3030.     l_stop();
  3031.     }
  3032.     else {                /* print to other streams normally */
  3033.     count = vfprintf(stream, format, args);
  3034.     con_flush();
  3035.     }
  3036.  
  3037.     va_end(args);
  3038.     return count;
  3039.  
  3040. }
  3041.  
  3042. /* Restore the usual desktop background. */
  3043.  
  3044. #undef puts
  3045.  
  3046. int restore_bg()
  3047. {
  3048.     puts("\033f");
  3049.     v_hide_c(VdiHandle);
  3050.     form_dial(FMD_FINISH, 0, 0, 8, 16, 0, 0, XRes, YRes);
  3051.     v_show_c(VdiHandle, 0);
  3052. }
  3053.  
  3054. /*
  3055. #-----------------------------------------------------------------------------#
  3056. #:    Simple support routines for LATTICE C 5.04.01 and other C compilers
  3057. #
  3058. #:    Lattice C Assembler
  3059. #
  3060. #:    The parameter comes on the stack for functions starting with '_'.
  3061. #
  3062. #:    void *call_super ( void * );  supervisor mode on/off
  3063. #
  3064. #:    Original code by Chris Strunk. Modified for use with gcc in
  3065. #:    Ghostscript by Tim Gallivan, 3/92.
  3066. #-----------------------------------------------------------------------------#
  3067. */
  3068.     asm("\
  3069.  
  3070.     .text 0
  3071.  
  3072.     .globl _int_off
  3073.     .globl _int_on
  3074.     .globl _call_super
  3075.     .globl _call_yield
  3076.     .globl _call_nice
  3077.     .globl _user_trace
  3078.     .globl _prt_ready
  3079.     .globl _prt_out
  3080.  
  3081. _get_la:
  3082.     moveml   d2/a2,sp@- 
  3083.     .byte    0xA0,0x00            | Adresse Line-A-Var nach A0 & D0
  3084.     moveml   sp@+,d2/a2
  3085.     rts
  3086.  
  3087. _int_off:
  3088.     oriw     #0x0700,sr
  3089.     rts
  3090.  
  3091. _int_on:
  3092.     andiw    #0xF8FF,sr
  3093.     rts
  3094.  
  3095. _call_super:
  3096.     movel    a7@(4),a0
  3097.     moveml   d2/a2-a3,sp@-
  3098.     movel    a0,sp@-
  3099.     movew    #0x20,sp@-
  3100.     movel    a7,a3     | save current stack pointer
  3101.     trap      #1
  3102.     movel    a3,a7     | make bad stack pointer good again !!!!!!!
  3103.     addql    #6,sp
  3104.     movel    d0,a0     | return value in both: d0 and a0
  3105.     moveml   sp@+,d2/a2-a3
  3106.     rts
  3107.  
  3108. _call_yield:
  3109.     moveml   d2/a2,sp@-
  3110.     movew    #0x00ff,sp@-   | MiNT Syield()  --  TOS illegal (rc -32)
  3111.     trap      #1
  3112.     addql    #2,sp
  3113.     moveml   sp@+,d2/a2
  3114.     rts
  3115.  
  3116. _call_nice:
  3117.     movel    a7@(4),d0
  3118.     moveml   d2/a2,sp@-
  3119.     movew    d0,sp@-
  3120.     movew    #0x10A,sp@-
  3121.     trap      #1
  3122.     addql    #4,sp
  3123.     moveml   sp@+,d2/a2
  3124.     rts
  3125.  
  3126. _user_trace:
  3127.     moveml   d1-d7/a0-a6,sp@-
  3128.     moveql   #0,d0
  3129.     movel    0x3F0,a1     | TEMPLMON user trace vector
  3130.     cmpal    #0,a1       | not installed ?
  3131.     beqs     end_trace
  3132.     jsr      a1@        | execute it !
  3133.     extl     d0
  3134.  
  3135. end_trace:
  3136.     moveml   sp@+,d1-d7/a0-a6
  3137.     rts
  3138.  
  3139. _prt_ready:
  3140.     moveml    d3/a3/a5,a7@-
  3141.     subl    a5,a5
  3142.     movew    d0,a7@-
  3143.     movel    0x506,a0
  3144.     jsr    a0@
  3145.     addql    #2,a7
  3146.     moveml    a7@+,d3/a3/a5
  3147.     rts
  3148.  
  3149. _prt_out:
  3150.     moveml    d3/a3/a5,a7@-
  3151.     subl    a5,a5
  3152.     movew    d1,a7@-
  3153.     movew    d0,a7@-
  3154.     movel    0x50A,a0
  3155.     jsr    a0@
  3156.     addql    #4,a7
  3157.     moveml    a7@+,d3/a3/a5
  3158.     rts
  3159.  
  3160.     ");
  3161.