home *** CD-ROM | disk | FTP | other *** search
/ The Datafile PD-CD 5 / DATAFILE_PDCD5.iso / utilities / g / gs / !GS / ps / Source / WimpPlus / c / wimpio < prev    next >
Encoding:
Text File  |  1991-12-05  |  22.9 KB  |  798 lines
  1. /* wimpio.c */
  2.  
  3. /* Copyright (C) David Elworthy 1991. No warranty is given on this code. */
  4.  
  5. /*
  6.    1.0  --  April 1991  --  First working version
  7.    2.0  --  July  1991  --  Added extra handle to w_event
  8.                         --  Allow file drop on read window
  9.                         --  Use control block
  10.    2.1  --  Oct   1991  --  Change drop handler
  11.                             Reading from input icon changed
  12.    2.2   -- Dec   1991   -- Fix menu bug: menus can now only be put up
  13.                             when we are waiting for input.
  14.  
  15.  * This file contains code for implementing printf and read via the WIMP.
  16.  * The external functions, create, show, hide and delete the printf
  17.  * window.
  18.  * It would be nice to implement scanf as well, but the lack of a vsscanf function
  19.  * in the ANSI library makes this next to impossible.
  20.  *
  21.  * PRINTF
  22.  * We keep a buffer of text in memory. On a redraw event, we plot it into the
  23.  * window.
  24.  * The text is held as an array of characters, with newlines as character
  25.  * separators. Control characters are kept in the text but not displayed.
  26.  * This allows us to use a buffer supplied by the user.
  27.  *
  28.  * In plotting, we have line breaks on newlines and on filling the width of the
  29.  * work area. To allow for mode changes, the physical line length is
  30.  * recalculated every time. We assume the window work area will not change --
  31.  * reasonable in most cases.
  32.  *
  33.  * READ
  34.  * Input is read through a writeable icon in a window, returning on return or OK.
  35.  * The text is read into a local buffer initially. Close or CANCEL causes the function
  36.  * to return as if there had been no input.
  37.  * If there are any extra icons, then a click on them has the same effect as entering their
  38.  * text into the writeable icon. This applies for icons number > the input icon.
  39.  */
  40.  
  41.  
  42. #include "wimp.h"
  43. #include "wimpt.h"
  44. #include "win.h"
  45. #include "template.h"
  46. #include "werr.h"
  47. #include "bbc.h"
  48. #include "coords.h"
  49. #include "event.h"
  50. #include "heap.h"
  51. #include "xferrecv.h"
  52. #include "baricon.h"
  53. #include "menu.h"
  54.  
  55. #include <stdio.h>
  56. #include <stdlib.h>
  57. #include <string.h>
  58. #include <stdarg.h>
  59. #include "wimpio.h"
  60.  
  61. /*---------------------------------------- CONTROL BLOCK---------------------------------*/
  62.  
  63. wimpio_cb wimpio_control =
  64. {
  65.     -1,    /* Printf window handle */
  66.     -1     /* Read window handle */
  67. };
  68.  
  69. /* Close icon string */
  70. static char *close_string = NULL;
  71.  
  72. /*---------------------------------------- COMMON ----------------------------------------*/
  73.  
  74. /* Show the window */
  75. static void w_show(BOOL exists, wimp_w handle)
  76. {
  77.     wimp_wstate  state;
  78.  
  79.     if (exists)
  80.     {
  81.         /* Get the state of the window */
  82.         if (wimpt_complain(wimp_get_wind_state(handle, &state)) == 0)
  83.         {
  84.             state.o.behind = -1;          /* Make sure window is opened in front */
  85.             wimpt_noerr(wimp_open_wind(&state.o));
  86.         }
  87.     }
  88. }
  89.  
  90. /* Hide the window */
  91. static void w_hide(BOOL exists, wimp_w handle)
  92. {
  93.     if (exists)
  94.         wimpt_noerr(wimp_close_wind(handle));
  95. }
  96.  
  97. /* Delete the window */
  98. static void w_delete(BOOL *exists, wimp_w *handle)
  99. {
  100.     if (*exists)
  101.     {
  102.         wimpt_noerr(wimp_delete_wind(*handle));
  103.         *handle = -1;
  104.         *exists = FALSE;
  105.         win_activedec();
  106.     }
  107. }
  108.  
  109. void w_event(wimp_eventstr *e, w_redraw_fn redraw, BOOL *closed, void *handle)
  110. {
  111.     if (closed) *closed = FALSE;
  112.  
  113.     /* Deal with event */
  114.     switch (e->e)
  115.     {
  116.         case wimp_EREDRAW:
  117.         {
  118.             int            more;
  119.             wimp_redrawstr r;
  120.  
  121.             wimpt_checkmode(); /* This means wimpt_mode will work */
  122.  
  123.             r.w = e->data.o.w;
  124.             wimpt_noerr(wimp_redraw_wind(&r, &more));
  125.             while (more)
  126.             {
  127.                 if (redraw != NULL) redraw(&r, handle);
  128.                 wimp_get_rectangle(&r, &more);
  129.             }
  130.             break;
  131.         }
  132.  
  133.         case wimp_EOPEN: /* Pass on open request */
  134.             wimpt_noerr(wimp_open_wind(&e->data.o));
  135.             break;
  136.  
  137.         case wimp_ECLOSE:
  138.             wimpt_noerr(wimp_close_wind(e->data.o.w));
  139.             if (closed) *closed = TRUE;
  140.             break;
  141.  
  142.         default:   /* Ignore any other event */
  143.             break;
  144.     }
  145. }
  146.  
  147. /* Standard window creator */
  148. wimp_w w_create(char *title, char *templatename, int *nicons)
  149. {
  150.     wimp_wind *window;    /* Pointer to window definition */
  151.     wimp_w    handle;
  152.  
  153.     /* Find template for the window */
  154.     window = template_syshandle(templatename);
  155.     if (window == 0)
  156.     {
  157.         werr(0, "Template not found");
  158.         return -1;
  159.     }
  160.  
  161.     /* Set title string (must be indirect and long enough) */
  162.     strcpy(window->title.indirecttext.buffer, title);
  163.  
  164.     /* Create the window, dealing with errors */
  165.     if (wimpt_complain(wimp_create_wind(window, &handle)))
  166.         return -1;
  167.  
  168.     win_activeinc();
  169.     if (nicons) *nicons = window->nicons;
  170.     return handle;
  171. }
  172.  
  173. /*---------------------------------------- PRINTF ----------------------------------------*/
  174.  
  175. /* Flag - does window exist */
  176. static BOOL printf_window_exists = FALSE;
  177.  
  178. /* Bottom left of window work area, and width */
  179. static int wa_base, wa_left, wa_width;
  180.  
  181. /* Buffer for text - may be supplied by user */
  182. static char *main_buffer = NULL;
  183. static int  main_end; /* Index of terminating null */
  184. static int  main_buf_len = 0;
  185. static BOOL locally_allocated = FALSE;
  186.  
  187. #define BUF_LEN_DEFAULT 10000
  188.  
  189. /* Size of the local buffer for wimpio */
  190. #define MAX_LOCAL_BUFFER 4096
  191.  
  192. /* Main part of the display routine */
  193. /* Must be a null at buffer[len], i.e. length including null = len+1 */
  194. static void low_w_write(char *buffer, int len)
  195. {
  196.     len += 1; /* Output length including null */
  197.  
  198.     /* Transfer to main buffer. First check it will all fit */
  199.     if (len > main_buf_len)
  200.     {
  201.         /* Replace entire main buffer */
  202.         strcpy(main_buffer, buffer + len - main_buf_len);
  203.         main_end = main_buf_len-1;
  204.     }
  205.     else
  206.     {
  207.         if (main_end + len > main_buf_len)
  208.         {   /* Move existing text up */
  209.             char *to   = main_buffer;
  210.             char *from = main_buffer + len + main_end - main_buf_len;
  211.             while (*from) *to++ = *from++;
  212.             strcpy(to, buffer);
  213.             main_end = main_buf_len - 1;
  214.         }
  215.         else
  216.         {
  217.             /* Text will fit */
  218.             strcpy(main_buffer+main_end, buffer);
  219.             main_end += len - 1;
  220.         }
  221.     }
  222.  
  223.     /* Force redraw */
  224.     {   wimp_redrawstr r;
  225.         r.w = wimpio_control.printf_win_handle;
  226.         r.box.x0 = r.box.y0 = -1000000;
  227.         r.box.x1 = r.box.y1 =  1000000;
  228.         wimpt_noerr(wimp_force_redraw(&r));
  229.     }
  230. } 
  231.  
  232. /* printf interface */
  233. int wprintf(const char *format, va_list arg)
  234. {
  235.     char    local_buffer[MAX_LOCAL_BUFFER];
  236.     int     chars_out;
  237.  
  238.     chars_out = vsprintf(local_buffer, format, arg);
  239.  
  240.     if (chars_out >= MAX_LOCAL_BUFFER)
  241.     {   /* Dangerous error, but untrappable! */
  242.         werr(0, "Warning: local buffer overflowed. Who know what might happen now!");
  243.     }
  244.     else
  245.         low_w_write(local_buffer, chars_out);
  246.     return chars_out;
  247. }
  248.  
  249. /* write interface */
  250. void w_write(char *buffer, int bufflen)
  251. {
  252.     if (buffer[bufflen - 1] == 0)
  253.         low_w_write(buffer, bufflen-1);
  254.     else
  255.     {
  256.         char local_buffer[MAX_LOCAL_BUFFER];
  257.  
  258.         memcpy(local_buffer, buffer, bufflen);
  259.         local_buffer[bufflen] = 0;
  260.         low_w_write(local_buffer, bufflen);
  261.     }
  262. }
  263.  
  264. /* Given an address of the last character in some text (e.g. just before \n),
  265.    this returns the start of the line (at \n, or start of buffer - 1),
  266.    and the number of physical lines it represents, excluding newline effect.
  267.    The number of lines is 1 for an empty line, or for 1...line_length
  268.    characters.
  269. */
  270. static char *find_lines(char *end, int line_length, int *lines)
  271. {
  272.     char *c;
  273.     int  chars = 0;
  274.  
  275.     /* Scan back for start, counting non-control characters */
  276.     for (c = end ; c - main_buffer >= 0 && *c != '\n' ; c--)
  277.         if (*c >= ' ') chars += 1;
  278.  
  279.     /* Lines is chars / line_length, rounded up. Special case for zero characters */
  280.     if (chars == 0) *lines = 1;
  281.     else *lines = (chars + line_length - 1) / line_length;
  282.  
  283.     return c;
  284. }
  285.  
  286. /* Given the address of the start of a line, returns the the end of it
  287.    as an index: either the line length or where the \n is.
  288. */
  289. static int find_line_end(char *c, int line_length)
  290. {
  291.     int index;
  292.  
  293.     for (index = 0 ; *c != 0 && *c != '\n' && index < line_length ; c++)
  294.         if (*c >= ' ') index += 1;
  295.     return index;
  296. }
  297.  
  298. /* Draw the text window */
  299. static void wprintf_draw(wimp_redrawstr *r, void *handle)
  300. {
  301.     int        xgap, ygap; /* Character spacings */
  302.     coords_pointstr base;  /* BL of clip region (widened) */
  303.     coords_cvtstr *cvt = (coords_cvtstr *)&(r->box);
  304.     div_t      d;
  305.     int        xpos, ypos, maxx, line_length, lines;
  306.     int        yline = 0;
  307.     int        endy;
  308.     char       *c;
  309.  
  310.     handle = handle;
  311.  
  312.     /* Calculate character gaps in OS units */
  313.     xgap  = bbc_vduvar(bbc_GCharSpaceX) << bbc_vduvar(bbc_XEigFactor);
  314.     ygap  = bbc_vduvar(bbc_GCharSpaceY) << bbc_vduvar(bbc_YEigFactor);
  315.  
  316.     /* Find line length */
  317.     line_length = wa_width / xgap;
  318.  
  319.     /* Convert clip window (screen coords) to work area coords */
  320.     base.x = r->g.x0;
  321.     base.y = r->g.y0;
  322.     coords_point_toworkarea(&base, cvt);
  323.  
  324.     /* Widen to character boundary relative to BL of work area */
  325.     d       = div(base.x - wa_left , xgap);
  326.     base.x -= d.rem;
  327.     d       = div(base.y - wa_base , ygap);
  328.     base.y -= d.rem;
  329.  
  330.     /* Change BL of widended box to a character position in the buffer */
  331.     xpos = base.x / xgap;
  332.     ypos = base.y / ygap;
  333.  
  334.     /* Set base coordinate - x from clip region, y from work area */
  335.     base.y = wa_base;
  336.     coords_point_toscreen(&base, cvt);
  337.  
  338.     c = main_buffer + main_end;
  339.     if (*(c-1) == '\n') c -= 1;
  340.  
  341.     endy = r->g.y1 + ygap;                         /* y coord at which to stop */
  342.     maxx = xpos + (r->g.x1 - base.x + xgap) / xgap; /* Max index to display */
  343.  
  344.     /* Display lines until out of clip window */
  345.     while (base.y < endy)
  346.     {
  347.         int   len;
  348.         char  *end = c - 1;
  349.  
  350.         c       = find_lines(end, line_length, &lines);
  351.         yline  += lines;
  352.         base.y += ygap * lines;
  353.  
  354.         /* Display if line is not empty ... */
  355.         if (c < end)
  356.         {
  357.             /* ... and if in clip region */
  358.             if (yline >= ypos)
  359.             {
  360.                 char *from = c + 1;
  361.                 int   y1 = base.y;
  362.  
  363.                 do
  364.                 {
  365.                     /* Get a physical line to display, unless empty */
  366.                     if (*from != '\n')
  367.                     {
  368.                         len = find_line_end(from, line_length);
  369.  
  370.                         /* Check there is enough text on the line */
  371.                         if (len >= xpos)
  372.                         {
  373.                             int limit = (len < maxx) ? len : maxx;
  374.                             int index = xpos - 1;
  375.  
  376.                             /* Display text */
  377.                             bbc_move(base.x, y1);
  378.                             while (++index < limit)
  379.                                 if (from[index] >= ' ') bbc_vdu(from[index]);
  380.                         }
  381.  
  382.                         y1   -= ygap;
  383.                         from += len;
  384.                     }
  385.                 } while (--lines > 0);
  386.             }
  387.         }
  388.     }
  389. }
  390.  
  391. /***************************** WINDOW FUNCTIONS *****************************/
  392.  
  393. static void wprintf_event_handler(wimp_eventstr *e, void *handle)
  394. {
  395.     /* Deal with close event */
  396.     if (e->e == wimp_ECLOSE && close_string != NULL)
  397.         wread_fake_input(close_string);
  398.     else
  399.         w_event(e, wprintf_draw, NULL, handle);
  400. }
  401.  
  402. int wprintf_create(char *title, char *buffer, int bufflen)
  403. {
  404.     wimp_wind *window;    /* Pointer to window definition */
  405.  
  406.     /* Do nothing if already initialised */
  407.     if (printf_window_exists) return TRUE;
  408.  
  409.     /* Allocate buffer if asked to */
  410.     if (buffer == NULL)
  411.     {
  412.         if (bufflen == 0) bufflen = BUF_LEN_DEFAULT;
  413.         if ((buffer = heap_alloc(bufflen)) == NULL)
  414.         {
  415.             werr(0, "Unable to allocate memory for buffer");
  416.             return FALSE;
  417.         }
  418.         locally_allocated = TRUE;
  419.     }
  420.     main_buffer  = buffer;
  421.     main_buf_len = bufflen;
  422.     main_buffer[0] = 0;
  423.     main_end       = 0;
  424.  
  425.     /* Find template for the window */
  426.     window = template_syshandle("wprintf");
  427.     if (window == 0)
  428.     {
  429.         werr(0, "Template wprintf not found");
  430.         return FALSE;
  431.     }
  432.  
  433.     /* Set title string (must be indirect and long enough) */
  434.     strcpy(window->title.indirecttext.buffer, title);
  435.  
  436.     /* Note work area sizes */
  437.     wa_left  = window->ex.x0;
  438.     wa_base  = window->ex.y0;
  439.     wa_width = window->ex.x1 - window->ex.x0;
  440.  
  441.     /* Create the window, dealing with errors */
  442.     if (wimpt_complain(wimp_create_wind(window, &wimpio_control.printf_win_handle)))
  443.         return FALSE;
  444.  
  445.     win_register_event_handler(wimpio_control.printf_win_handle, wprintf_event_handler, NULL);
  446.     win_activeinc();
  447.     printf_window_exists = TRUE;
  448.  
  449.     /* Let the print window have idle events, so it can update */
  450.     win_claim_idle_events(wimpio_control.printf_win_handle);
  451.     event_setmask(event_getmask() & ~wimp_EMNULL);
  452.     return TRUE;
  453. }
  454.  
  455. /* Show the window */
  456. void wprintf_show(void)
  457. {
  458.     w_show(printf_window_exists, wimpio_control.printf_win_handle);
  459. }
  460.  
  461. /* Hide the window */
  462. void wprintf_hide(void)
  463. {
  464.     w_hide(printf_window_exists, wimpio_control.printf_win_handle);
  465. }
  466.  
  467. /* Delete the window */
  468. void wprintf_delete(void)
  469. {
  470.     if (printf_window_exists && locally_allocated)
  471.         heap_free(main_buffer);
  472.     win_claim_idle_events((wimp_w)-1);
  473.     event_setmask(event_getmask() | wimp_EMNULL);
  474.     w_delete(&printf_window_exists, &wimpio_control.printf_win_handle);
  475. }
  476.  
  477. /*---------------------------------------- READ ----------------------------------------*/
  478.  
  479. /* Number of icons in the read window */
  480. static int n_read_icons;
  481.  
  482. /* Flag - does window exist */
  483. static BOOL read_window_exists = FALSE;
  484.  
  485. static BOOL read_printf_flag;
  486.  
  487. #define icon_OK      (0)
  488. #define icon_Input   (1)
  489.  
  490. /* Type ahead buffer - characters are moved here on return */
  491. #define MaxReadBuffer (1000)
  492. static char read_buffer[MaxReadBuffer+1];
  493. static int  read_index = 0; /* Where to put next character */
  494.  
  495. /* Drop handler globals */
  496. static char read_drop_format[WRead_MaxFormat];
  497. static w_drop_handler read_drop_handler = NULL;
  498. static void *read_drop_handle = NULL;
  499. static w_drop_handler icon_drop_handler = NULL;
  500. static void *icon_drop_handle = NULL;
  501.  
  502. /* Place the caret in the read window. */
  503. static void place_caret()
  504. {
  505.     wimp_caretstr caretstr;
  506.  
  507.     /* Set the caret into the icon */
  508.     caretstr.w = wimpio_control.read_win_handle;
  509.     caretstr.i = icon_Input;
  510.     caretstr.height = -1;
  511.     caretstr.index  = 0;
  512.     wimpt_noerr(wimp_set_caret_pos(&caretstr));
  513. }
  514.  
  515. /* Transfer as much data as we can to the local buffer, and add a newline.
  516.    Data from this buffer gets picked up in wread */
  517. static void buffer_input(char *source)
  518. {
  519.     int i;
  520.  
  521.     for (i = 0 ; source[i] >= ' ' && read_index < MaxReadBuffer-1 ; i++)
  522.         read_buffer[read_index++] = source[i];
  523.     read_buffer[read_index++] = '\n';
  524.     read_buffer[read_index] = 0;
  525. }
  526.  
  527. /* Are menus enabled? */
  528. static BOOL menu_enable;
  529.  
  530. /* Menu maker and processor */
  531. static event_menu_maker read_menu_maker = NULL;
  532. static event_menu_proc  read_menu_proc  = NULL;
  533. static void *read_menu_h = NULL;
  534.  
  535. /* Local menu routines */
  536. static menu menu_maker(void *handle)
  537. {
  538.     return (menu_enable) ? (*read_menu_maker)(read_menu_h) : (menu)-1;
  539. }
  540.  
  541. static void menu_proc(void *handle, char *hit)
  542. {
  543.     if (menu_enable) (*read_menu_proc)(read_menu_h, hit);
  544. }
  545.  
  546. /* Enable/disable menus */
  547. static void enable_menus(BOOL enable)
  548. {
  549.     menu_enable = enable;
  550.  
  551.     event_attachmenumaker(wimpio_control.printf_win_handle,
  552.                           (enable) ? menu_maker : 0,
  553.                           (enable) ? menu_proc : 0, read_menu_h);
  554.     event_attachmenumaker(wimpio_control.read_win_handle,
  555.                           (enable) ? menu_maker : 0,
  556.                           (enable) ? menu_proc : 0, read_menu_h);
  557.     event_attachmenumaker(win_ICONBAR,
  558.                           (enable) ? menu_maker : 0,
  559.                           (enable) ? menu_proc : 0, read_menu_h);
  560. }
  561.  
  562.  
  563. /* The read routine itself. Bytes read if successful, -1 if not. */
  564. int wread(char *buffer, int bufflen)
  565. {
  566.     int i, j, to_move;
  567.  
  568.     if (read_index <= 0) enable_menus(TRUE);
  569.     while (read_index <= 0) event_process();
  570.  
  571.     to_move = (bufflen < read_index) ? bufflen : read_index;
  572.     memcpy(buffer, read_buffer, to_move);
  573.  
  574.     for (i = 0, j = bufflen ; j <= read_index ; i++, j++)
  575.         read_buffer[i] = read_buffer[j];
  576.     read_index = i;
  577.  
  578.     /* Echo what we read into the print buffer */
  579.     if (read_printf_flag && to_move > 0)
  580.     {
  581.         w_write(buffer, to_move);
  582.         if (event_anywindows()) event_process();
  583.     }
  584.  
  585.     enable_menus(FALSE);
  586.     return to_move;
  587. }
  588.  
  589. /* Return processor - move characters to buffer and clear icon */
  590. static void process_return()
  591. {
  592.     char *icontext;
  593.     wimp_icon result;
  594.     int  i;
  595.  
  596.     wimpt_noerr(wimp_get_icon_info(wimpio_control.read_win_handle, icon_Input, &result));
  597.     icontext = result.data.indirecttext.buffer;
  598.     buffer_input(icontext);
  599.  
  600.     for (i = 0 ; i < result.data.indirecttext.bufflen ; i++) icontext[i] = 0;
  601.     wimpt_noerr(wimp_set_icon_state(wimpio_control.read_win_handle, icon_Input, 0, 0));
  602.     place_caret();   
  603. }
  604.  
  605. /* Register a file drop handler for the read window.
  606.    If you drop a file onto the read window, and you have given a non-null
  607.    string to this routine, and the icons are not grayed, then it treats
  608.    the string as a format string, and simulates the effect of typing that
  609.    in to the window. For example, to get "(<filname>) run", you would give
  610.    a string of "(%s) run". The format must be less than 80 characters -
  611.    it is ignored if not. Passing NULL removes the drop handling.
  612.    The second parameter allows a function to be called before this string is
  613.    issued, for example to display menus. At the moment it passes no parameters on:
  614.    future versions might pass the string in, or allow the process to be halted.
  615. */
  616. void w_register_drop(char *format, w_drop_handler handler, void *handle)
  617. {
  618.     if (format == NULL)
  619.         read_drop_format[0] = 0;
  620.     else if (strlen(format) < WRead_MaxFormat)
  621.         strcpy(read_drop_format, format);
  622.     read_drop_handler = handler;
  623.     read_drop_handle  = handle;
  624. }
  625.  
  626. /* Fake input */
  627. void wread_fake_input(char *text)
  628. {
  629.     buffer_input(text);
  630. }
  631.  
  632. /***************************** WINDOW FUNCTIONS *****************************/
  633.  
  634. static void wread_event_handler(wimp_eventstr *e, void *handle)
  635. {
  636.     switch (e->e)
  637.     {
  638.         case wimp_ECLOSE:
  639.             if (close_string != NULL)
  640.             {
  641.                 wread_fake_input(close_string);
  642.                 return;
  643.             }
  644.             else
  645.                 break;
  646.                 
  647.         case wimp_EBUT:
  648.             if (e->data.but.m.i >= icon_Input)
  649.             {
  650.                 wimp_icon result;
  651.                 char *icontext;
  652.  
  653.                 wimpt_noerr(wimp_get_icon_info(wimpio_control.read_win_handle,
  654.                                                e->data.but.m.i, &result));
  655.                 icontext = result.data.indirecttext.buffer;
  656.                 buffer_input(icontext);
  657.                 return;
  658.             }
  659.             else break;
  660.  
  661.         case wimp_EKEY:
  662.             if (e->data.key.chcode == 13)
  663.                 process_return();
  664.             /* Otherwise pass the key on */
  665.             else wimp_processkey(e->data.key.chcode);
  666.             return;
  667.  
  668.         case wimp_ESEND:
  669.         case wimp_ESENDWANTACK:
  670.             if (e->data.msg.hdr.action == wimp_MDATALOAD)
  671.             {    /* File load - only respond to DATALOAD because it is the only one
  672.                     which guarantees a persistent file name */
  673.                 char *filename;
  674.  
  675.                 if (xferrecv_checkinsert(&filename) != -1)
  676.                 {
  677.                     if (read_drop_handler) (*read_drop_handler)(read_drop_handle);
  678.  
  679.                     if (read_drop_format[0] != 0)
  680.                     {
  681.                         /* Fill the icon buffer, so it gets picked up on the next read */
  682.                         /* No buffer overflow check */
  683.                         char temp_buffer[1000];
  684.  
  685.                         sprintf(temp_buffer, read_drop_format, filename);
  686.                         wread_fake_input(temp_buffer);
  687.                     }
  688.                 }
  689.                 return;
  690.         }
  691.     }
  692.  
  693.     /* Default and fall through case */
  694.     w_event(e, NULL, NULL, handle);
  695. }
  696.  
  697. BOOL wread_create(char *title, BOOL printf_flag)
  698. {
  699.     /* Do nothing if already initialised */
  700.     if (read_window_exists) return TRUE;
  701.  
  702.     if ((wimpio_control.read_win_handle = w_create(title, "wread", &n_read_icons)) == -1)
  703.         return FALSE;
  704.  
  705.     win_register_event_handler(wimpio_control.read_win_handle, wread_event_handler, NULL);
  706.  
  707.     read_window_exists = TRUE;
  708.     read_printf_flag   = printf_flag;
  709.     enable_menus(FALSE);
  710.     return TRUE;
  711. }
  712.  
  713. /* Show the window */
  714. void wread_show(void)
  715. {
  716.     w_show(read_window_exists, wimpio_control.read_win_handle);
  717. }
  718.  
  719. /* Hide the window */
  720. void wread_hide(void)
  721. {
  722.     w_hide(read_window_exists, wimpio_control.read_win_handle);
  723. }
  724.  
  725. /* Delete the window */
  726. void wread_delete(void)
  727. {
  728.     w_delete(&read_window_exists, &wimpio_control.read_win_handle);
  729. }
  730.  
  731. char *w_close_string(char *text)
  732. {
  733.     char *old = close_string;
  734.     close_string = text;
  735.     return old;
  736. }
  737.  
  738. /***************************** ICON BAR *************************************/
  739.  
  740. static void clickproc(wimp_i i)
  741. {
  742.     /* Open the print and scan windows */
  743.     wprintf_show();
  744.     wread_show();
  745.     place_caret();
  746. }
  747.  
  748. /* Call on file drop onto icon bar */
  749. static void icon_drop(wimp_eventstr *e, void *handle)
  750. {
  751.     char *command = (char *)handle;
  752.     
  753.     switch (e->e)
  754.     {
  755.         case wimp_ESEND:
  756.         case wimp_ESENDWANTACK:
  757.         {
  758.             if (e->data.msg.hdr.action == wimp_MDATALOAD)
  759.             {    /* File load - only respond to DATALOAD because it is the only one
  760.                     which guarantees a persistent file name */
  761.                 char *filename;
  762.  
  763.                 if (xferrecv_checkinsert(&filename) != -1)
  764.                 {
  765.                     if (icon_drop_handler) (*icon_drop_handler)(icon_drop_handle);
  766.  
  767.                     if (command)
  768.                     {
  769.                         /* Fill the icon buffer, so it gets picked up on the next read */
  770.                         /* No buffer overflow check */
  771.                         char temp_buffer[1000];
  772.  
  773.                         sprintf(temp_buffer, command, filename);
  774.                         wread_fake_input(temp_buffer);
  775.                     }
  776.                 }
  777.                 return;
  778.             }
  779.         }
  780.     }
  781. }
  782.  
  783. void w_baricon(char *command, w_drop_handler handler, void *handle)
  784. {
  785.     /* Register icon on icon bar */
  786.     baricon(wimpt_programname(), 1, clickproc);
  787.     win_register_event_handler(win_ICONBARLOAD, icon_drop, command);
  788.     icon_drop_handler = handler;
  789.     icon_drop_handle  = handle;
  790. }
  791.  
  792. void w_register_menu(event_menu_maker maker, event_menu_proc proc, void *handle)
  793. {
  794.     read_menu_maker = maker;
  795.     read_menu_proc  = proc;
  796.     read_menu_h     = handle;
  797. }
  798.