home *** CD-ROM | disk | FTP | other *** search
/ Graphics Plus / Graphics Plus.iso / general / plotting / imagetoo / imagetl1.lha / Imagetool / src+obj / canvas.c < prev    next >
Encoding:
C/C++ Source or Header  |  1991-03-11  |  16.3 KB  |  690 lines
  1. /* cat > headers/canvas.h << "EOF" */
  2. /* ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ */
  3. /* canvas.h: header for canvas.c file            */
  4. /* ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ */
  5. /* SCCS information: %W%    %G% - NCSA */
  6.  
  7. #define canvas_h    1
  8.  
  9. #include "all.h"
  10. #include "newext.h"
  11.  
  12. /* EOF */
  13. /* cat > src+obj/canvas/box_drawing.c << "EOF" */
  14. /* ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ */
  15. /* box_drawing: draw a box                */
  16. /* ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ */
  17. /* SCCS information: %W%    %G% - NCSA */
  18.  
  19. /* #include "canvas.h" */
  20.  
  21. box_drawing (x, y, xdim, ydim)
  22.     int        x, y, xdim, ydim;
  23. {
  24.     register        x1, x2, y1, y2;
  25.  
  26.     x1 = x - xdim / 2;
  27.     y1 = y - ydim / 2;
  28.     x2 = x1 + xdim;
  29.     y2 = y1 + ydim;
  30.     pw_vector (pw, x1, y1, x2, y1, PIX_NOT (PIX_DST), 255);
  31.     pw_vector (pw, x1, y1, x1, y2, PIX_NOT (PIX_DST), 255);
  32.     pw_vector (pw, x2, y1, x2, y2, PIX_NOT (PIX_DST), 255);
  33.     pw_vector (pw, x1, y2, x2, y2, PIX_NOT (PIX_DST), 255);
  34. }
  35. /* EOF */
  36. /* cat > src+obj/canvas/can_controller.c << "EOF" */
  37. /* ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ */
  38. /* can_controller: Canvas controller to react to     */
  39. /*           different input events        */
  40. /* ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ */
  41. /* SCCS information: %W%    %G% - NCSA */
  42.  
  43. /* #include "canvas.h" */
  44.  
  45. can_controller (can, event)
  46.     Canvas          can;
  47.     Event          *event;
  48. {
  49.     int             eid = event_id (event);
  50.  
  51.     middle_button_down = event_is_down (event);
  52.  
  53.         /* right button to reset position picked */
  54.     if (eid == MS_RIGHT && event_is_down (event))
  55.     {
  56.             /* reset position */
  57.         reset_pos ();
  58.     }
  59.  
  60.         /* special button assignment in color editing mode */
  61.     switch (color_edit_mode)
  62.     {
  63.         case CEDIT_NONE:
  64.             break;
  65.         case CEDIT_CONT:
  66.             whiteout (eid, event);
  67.             return;
  68.         case CEDIT_FIDDLE:
  69.             fiddle_proc (eid, event);
  70.             return;
  71.     }
  72.  
  73.         /* special button assignment in graphing mode */
  74.     if (graph_mode == PLOT_XY)
  75.     {        /* plotting mode */
  76.         plot_proc (eid, event);
  77.         return;
  78.     }
  79.  
  80.         /* if one down already, second middle button down may cause
  81.            to move a cutout or draw a new square */
  82.     if (first_middle_down)
  83.     {        /* moving cutout image */
  84.         switch (eid)
  85.         {
  86.             case MS_MIDDLE:
  87.                 if (middle_button_down)
  88.                 {
  89.                     if (event_ctrl_is_down (event))
  90.                         copy_request = 1;
  91.                     if (inarea (event, &square) || paste_request)
  92.                     {        /* inside, then move */
  93.                         if (square_drawn)
  94.                             draw_square (&square);
  95.                         is_moving = 1;
  96.                         move_image (eid, event);
  97.                     }
  98.                     else
  99.                     {        /* outside, get another square */
  100.                         if (square_drawn)
  101.                             draw_square (&square);
  102.                         square_drawn = first_point = first_middle_down = 0;
  103.                         get_square (eid, event);
  104.                     }
  105.                 }
  106.                 else        /* button released, moving done */
  107.                     move_image (eid, event);
  108.                 break;
  109.             case LOC_DRAG:
  110.                 if (is_moving)
  111.                     move_image (eid, event);
  112.                 break;
  113.             default:
  114.                 break;
  115.         }
  116.         return;
  117.     }
  118.  
  119.         /* normal mode */
  120.     switch (eid)
  121.     {
  122.         case MS_LEFT:    /* to pick a starting position */
  123.             if (event_is_down (event))
  124.                 pick_position (event);
  125.             break;
  126.         case MS_MIDDLE:    /* drawing a square */
  127.             if (!square_drawn)
  128.                 get_square (eid, event);
  129.             else
  130.             {        /* square exists */
  131.                 square_drawn = 0;
  132.                 first_point = 0;
  133.                 draw_square (&square);    /* erase square */
  134.                 get_square (eid, event);
  135.             }
  136.             break;
  137.         case LOC_DRAG:    /* drawing a square */
  138.             if (first_point)
  139.             {
  140.                 get_square (eid, event);
  141.             }
  142.             break;
  143.         default:
  144.             break;
  145.     }
  146. }
  147. /* EOF */
  148. /* cat > src+obj/canvas/coor_adjust.c << "EOF" */
  149. /* ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ */
  150. /* coor_adjust: adjust coordinates            */
  151. /* ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ */
  152. /* SCCS information: %W%    %G% - NCSA */
  153.  
  154. /* #include "canvas.h" */
  155.  
  156. coor_adjust (p)
  157.     struct square_rec *p;
  158. {
  159.     register        tmp;
  160.  
  161.     if (p->startx > p->endx)
  162.     {
  163.         tmp = p->startx;
  164.         p->startx = p->endx;
  165.         p->endx = tmp;
  166.     }
  167.     if (p->starty > p->endy)
  168.     {
  169.         tmp = p->starty;
  170.         p->starty = p->endy;
  171.         p->endy = tmp;
  172.     }
  173. }
  174. /* EOF */
  175. /* cat > src+obj/canvas/create_edit_menu.c << "EOF" */
  176. /* ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ */
  177. /* creat_edit_menu: create edit menu            */
  178. /* ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ */
  179. /* SCCS information: %W%    %G% - NCSA */
  180.  
  181. /* #include "canvas.h" */
  182.  
  183. create_edit_menu ()
  184. {
  185.     void            edit_proc ();
  186.  
  187.     edit_menu = menu_create (
  188.                  MENU_FONT, font_menu,
  189.                  MENU_STRINGS, "Cut", "Copy", "Paste", "Clear", 0,
  190.                  MENU_NOTIFY_PROC, edit_proc,
  191.                  0);
  192. }
  193. /* EOF */
  194. /* cat > src+obj/canvas/display_panel_menu.c << "EOF" */
  195. /* ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ */
  196. /* display_panel_menu: routine to display menu m on    */
  197. /*               event from panel named panel    */
  198. /* ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ */
  199. /* SCCS information: %W%    %G% - NCSA */
  200.  
  201. /* #include "canvas.h" */
  202.  
  203. bool
  204. display_panel_menu (item, event, panel, m)
  205.     Panel_item      item;
  206.     Event          *event;
  207.     Panel           panel;
  208.     Menu            m;
  209. {
  210.     Rect           *enclose;
  211.  
  212.     static bool     hilite = FALSE;
  213.     static Panel_item hi_item = NULL;
  214.  
  215.     switch (event_action (event))
  216.     {
  217.             /* display menu on right button down */
  218.         case MS_RIGHT:
  219.             if (event_is_down (event))
  220.                 menu_show (m, panel, event, 0);
  221.             break;
  222.  
  223.         case LOC_WINEXIT:
  224.             if (hilite)
  225.             {
  226.                 panel_cancel_preview (item, event);
  227.                 window_set (panel, WIN_IGNORE_PICK_EVENTS, LOC_DRAG, LOC_WINEXIT, 0, 0);
  228.                 hilite = FALSE;
  229.             }
  230.             break;
  231.  
  232.         case LOC_DRAG:
  233.             enclose = (Rect *) panel_get (item, PANEL_ITEM_RECT);
  234.             if (in_rect (event_x (event), event_y (event), enclose))
  235.             {
  236.                 if (!hilite)
  237.                 {
  238.                     panel_begin_preview (item, event);
  239.                     hi_item = item;
  240.                     hilite = TRUE;
  241.                 }
  242.             }
  243.             else if (hilite)
  244.             {
  245.                 panel_cancel_preview (hi_item, event);
  246.                 hilite = FALSE;
  247.             }
  248.             break;
  249.  
  250.         case MS_LEFT:
  251.             enclose = (Rect *) panel_get (item, PANEL_ITEM_RECT);
  252.             if (event_is_down (event))
  253.             {
  254.                 window_set (panel, WIN_CONSUME_PICK_EVENTS, LOC_WINEXIT, LOC_DRAG, 0, 0);
  255.  
  256.                     /* click in the button rectangle? */
  257.                 if (in_rect (event_x (event), event_y (event), enclose))
  258.                 {
  259.                     if (!hilite)
  260.                     {
  261.                         panel_begin_preview (item, event);
  262.                         hi_item = item;
  263.                         hilite = TRUE;
  264.                     }
  265.                 }
  266.                 else if (hilite)
  267.                 {
  268.                     panel_cancel_preview (hi_item, event);
  269.                     hilite = FALSE;
  270.                 }
  271.             }
  272.             else if (event_is_up (event))
  273.             {
  274.                 window_set (panel, WIN_IGNORE_PICK_EVENTS, LOC_DRAG, LOC_WINEXIT, 0, 0);
  275.                 if (in_rect (event_x (event), event_y (event), enclose))
  276.                 {
  277.                     panel_accept_preview (hi_item, event);
  278.                     hilite = FALSE;
  279.                     return (TRUE);
  280.                 }
  281.             }
  282.             break;
  283.  
  284.         default:
  285.             break;
  286.     }
  287.     return (FALSE);
  288. }
  289. /* EOF */
  290. /* cat > src+obj/canvas/draw_line.c << "EOF" */
  291. /* ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ */
  292. /* draw_line: plot a straight line             */
  293. /* ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ */
  294. /* SCCS information: %W%    %G% - NCSA */
  295.  
  296. /* #include "canvas.h" */
  297.  
  298. draw_line (eid, event)
  299.     int             eid;
  300.     Event          *event;
  301. {
  302.     int             newx, newy;
  303.  
  304.     switch (eid)
  305.     {
  306.         case MS_LEFT:
  307.             if (!first_point)
  308.             {        /* get first point */
  309.                 if (event_is_down (event))
  310.                 {
  311.                     newx = event_x (event);
  312.                     newy = event_y (event);
  313.                     line_rec.x1 = line_rec.x2 = newx;
  314.                     line_rec.y1 = line_rec.y2 = newy;
  315.                     first_point = 1;
  316.                     line_drawn = 0;
  317.                     pw_vector (pw, line_rec.x1, line_rec.y1, line_rec.x2, line_rec.y2,
  318.                            PIX_NOT (PIX_DST), 255);
  319.                 }
  320.             }
  321.             else if (event_is_up (event))
  322.             {        /* line done */
  323.                 line_drawn = 1;
  324.                 first_point = 0;
  325.             }
  326.             break;
  327.         case LOC_DRAG:    /* drawing when dragging */
  328.             newx = event_x (event);
  329.             newy = event_y (event);
  330.  
  331.             pw_vector (pw, line_rec.x1, line_rec.y1, line_rec.x2, line_rec.y2,
  332.                    PIX_NOT (PIX_DST), 255);
  333.  
  334.  
  335.             if (abs (newx - line_rec.x1) > ERANGE)
  336.                 line_rec.x2 = newx;
  337.             else
  338.                 line_rec.x2 = line_rec.x1;;
  339.  
  340.             if (abs (newy - line_rec.y1) > ERANGE)
  341.                 line_rec.y2 = newy;
  342.             else
  343.                 line_rec.y2 = line_rec.y1;;
  344.  
  345.             pw_vector (pw, line_rec.x1, line_rec.y1, line_rec.x2, line_rec.y2,
  346.                    PIX_NOT (PIX_DST), 255);
  347.             break;
  348.         default:
  349.             break;
  350.     }
  351. }
  352. /* EOF */
  353. /* cat > src+obj/canvas/draw_square.c << "EOF" */
  354. /* ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ */
  355. /* draw_square: plot a square                */
  356. /* ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ */
  357. /* SCCS information: %W%    %G% - NCSA */
  358.  
  359. /* #include "canvas.h" */
  360.  
  361. draw_square (p)
  362.     struct square_rec *p;
  363. {
  364.     register        sx, sy, ex, ey;
  365.  
  366.     sx = p->startx;
  367.     sy = p->starty;
  368.     ex = p->endx;
  369.     ey = p->endy;
  370.  
  371.     pw_vector (pw, sx, sy, sx, ey, PIX_NOT (PIX_DST), 255);
  372.     pw_vector (pw, sx, sy, ex, sy, PIX_NOT (PIX_DST), 255);
  373.     pw_vector (pw, sx, ey, ex, ey, PIX_NOT (PIX_DST), 255);
  374.     pw_vector (pw, ex, sy, ex, ey, PIX_NOT (PIX_DST), 255);
  375. }
  376. /* EOF */
  377. /* cat > src+obj/canvas/edit_handler.c << "EOF" */
  378. /* ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ */
  379. /* edit_handler: handler for Edit Menu            */
  380. /* ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ */
  381. /* SCCS information: %W%    %G% - NCSA */
  382.  
  383. /* #include "canvas.h" */
  384.  
  385. edit_handler (item, event)
  386.     Panel_item      item;
  387.     Event          *event;
  388. {
  389.     if (display_panel_menu (item, event, menu_panel, edit_menu))
  390.         edit_proc (edit_menu, menu_get (edit_menu, MENU_NTH_ITEM, 1));
  391. }
  392. /* EOF */
  393. /* cat > src+obj/canvas/edit_proc.c << "EOF" */
  394. /* ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ */
  395. /* edit_proc: handler to process imae editing request:  */
  396. /*          copy, cut, paste, and clear        */
  397. /* ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ */
  398. /* SCCS information: %W%    %G% - NCSA */
  399.  
  400. /* #include "canvas.h" */
  401.  
  402. void
  403. edit_proc (m, mi)
  404.     Menu            m;
  405.     Menu_item       mi;
  406. {
  407.     char            str[MAXNAMELEN];
  408.  
  409.     strcpy (str, (char *) menu_get (mi, MENU_STRING));
  410.     if (!strcmp ("Cut", str))
  411.     {        /* cut, store to clipboard */
  412.         if (load_clipboard () == 0)
  413.             erase_last ();
  414.         square_drawn = 0;
  415.     }
  416.     else if (!strcmp ("Copy", str))
  417.     {        /* copy to clipboard */
  418.         if (load_clipboard () == 0)
  419.             copy_request = 1;
  420.     }
  421.     else if (!strcmp ("Paste", str))
  422.     {        /* paste from clipboard */
  423.         paste_request = 1;
  424.         first_middle_down = 1;
  425.     }
  426.     else if (!strcmp ("Clear", str))
  427.         erase_last ();
  428.     return;
  429. }
  430. /* EOF */
  431. /* cat > src+obj/canvas/get_square.c << "EOF" */
  432. /* ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ */
  433. /* get_square: get the square                */
  434. /* ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ */
  435. /* SCCS information: %W%    %G% - NCSA */
  436.  
  437. /* #include "canvas.h" */
  438.  
  439. get_square (eid, event)
  440.     Event          *event;
  441.     int             eid;
  442. {
  443.     int             newx, newy, xdim, ydim;
  444.  
  445.     if (!first_point)
  446.     {        /* get first point */
  447.         if (middle_button_down && eid == MS_MIDDLE)
  448.         {
  449.             square.startx = event_x (event);
  450.             square.starty = event_y (event);
  451.             square.endx = square.startx;
  452.             square.endy = square.starty;
  453.             first_point = 1;
  454.             square_drawn = 0;
  455.         }
  456.     }
  457.     else
  458.     {        /* updating squares when dragging */
  459.         if (middle_button_down && eid == LOC_DRAG)
  460.         {
  461.             newx = event_x (event);
  462.             newy = event_y (event);
  463.             if (newx != square.endx && newy != square.endy)
  464.             {
  465.                 draw_square (&square);
  466.                 square.endx = newx;
  467.                 square.endy = newy;
  468.                 draw_square (&square);
  469.             }
  470.         }
  471.         else if (!middle_button_down)
  472.         {        /* finish a square */
  473.             first_point = 0;
  474.             if ((square.endx - square.startx) == 0 ||
  475.                 (square.endy - square.starty) == 0)
  476.                 square_drawn = 0;
  477.             else
  478.             {
  479.                 coor_adjust (&square);
  480.                 xdim = square.endx - square.startx - 2;
  481.                 ydim = square.endy - square.starty - 2;
  482.                 switch (xdim % 4)
  483.                 {
  484.                     case 0:
  485.                     case 2:
  486.                         break;
  487.                     case 1:
  488.                         draw_square (&square);
  489.                         (square.endx)--;
  490.                         xdim--;
  491.                         draw_square (&square);
  492.                         break;
  493.                     case 3:
  494.                         draw_square (&square);
  495.                         (square.endx)++;
  496.                         xdim++;
  497.                         draw_square (&square);
  498.                 }
  499.                 curr_image.startx = square.startx + 1;
  500.                 curr_image.starty = square.starty + 1;
  501.                 curr_image.org_xdim = curr_image.xdim = xdim;
  502.                 curr_image.org_ydim = curr_image.ydim = ydim;
  503.                 curr_image.zoomx = curr_image.zoomy = 1;
  504.                 curr_image.expanded = 0;
  505.                 curr_image.cutout = 1;
  506.                 curr_image.in_use = 0;
  507.  
  508.                 clear_request = 0;
  509.                 square_drawn = 1;
  510.                 if (graph_mode == PLOT_CON || graph_mode == PLOT_3D)
  511.                     first_middle_down = 0;
  512.                 else
  513.                     first_middle_down = 1;
  514.             }
  515.         }
  516.     }
  517. }
  518. /* EOF */
  519. /* cat > src+obj/canvas/inarea.c << "EOF" */
  520. /* ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ */
  521. /* inarea: event in the area                */
  522. /* ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ */
  523. /* SCCS information: %W%    %G% - NCSA */
  524.  
  525. /* #include "canvas.h" */
  526.  
  527. inarea (event, sp)
  528.     Event          *event;
  529.     struct square_rec *sp;
  530. {
  531.     register        x, y;
  532.  
  533.     x = event_x (event);
  534.     y = event_y (event);
  535.  
  536.     if (x >= sp->startx && x <= sp->endx &&
  537.         y >= sp->starty && y <= sp->endy)
  538.         return (1);    /* inside */
  539.     return (0);        /* outside */
  540. }
  541. /* EOF */
  542. /* cat > src+obj/canvas/load_clipboard.c << "EOF" */
  543. /* ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ */
  544. /* load_clipboard: store a cutout image onto clipboard  */
  545. /*           memory                */
  546. /* ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ */
  547. /* SCCS information: %W%    %G% - NCSA */
  548.  
  549. /* #include "canvas.h" */
  550.  
  551. load_clipboard ()
  552. {
  553.     int             lastw = curr_image.xdim;
  554.     int             lasth = curr_image.ydim;
  555.     int             lastx = curr_image.startx;
  556.     int             lasty = curr_image.starty;
  557.  
  558.     if (clipboard.pr != NULL)
  559.         pr_close (clipboard.pr);
  560.     if ((clipboard.pr = mem_create (lastw, lasth, 8)) == NULL)
  561.     {
  562.         msg_write ("Error: Not enough memory to create clipboard pixrect for image.");
  563.         return (-1);
  564.     }
  565.     pw_read (clipboard.pr, 0, 0, lastw, lasth, PIX_SRC, pw, lastx, lasty);
  566.     clipboard.xdim = lastw;
  567.     clipboard.ydim = lasth;
  568.     return (0);
  569. }
  570. /* EOF */
  571. /* cat > src+obj/canvas/move_image.c << "EOF" */
  572. /* ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ */
  573. /* move_image: moving image around on canvas        */
  574. /* ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ */
  575. /* SCCS information: %W%    %G% - NCSA */
  576.  
  577. /* #include "canvas.h" */
  578.  
  579. move_image (eid, event)
  580.     int             eid;
  581.     Event          *event;
  582. {
  583.     static struct pixrect *pr;
  584.     static          xdim, ydim, oldx, oldy;
  585.     register        x, y;
  586.  
  587.     if (paste_request && clipboard.pr != NULL)
  588.     {
  589.         xdim = clipboard.xdim;
  590.         ydim = clipboard.ydim;
  591.     }
  592.     else
  593.     {
  594.         xdim = curr_image.xdim;
  595.         ydim = curr_image.ydim;
  596.     }
  597.  
  598.     switch (eid)
  599.     {
  600.         case MS_MIDDLE:
  601.             if (event_is_down (event))
  602.             {
  603.                 if (paste_request && clipboard.pr != NULL)
  604.                     pr = clipboard.pr;
  605.                 else
  606.                 {
  607.                     if ((pr = mem_create (xdim, ydim, 8)) == NULL)
  608.                     {
  609.                         msg_write ("Error: Not enough memory to create clipboard pixrect for image.");
  610.                         return (-1);
  611.                     }
  612.                     pw_read (pr, 0, 0, xdim, ydim, PIX_SRC, pw,
  613.                          curr_image.startx, curr_image.starty);
  614.                 }
  615.                 if (!copy_request && !paste_request)
  616.                     erase_last ();
  617.             }
  618.             else
  619.             {        /* button released, moving done */
  620.                 x = event_x (event);
  621.                 y = event_y (event);
  622.                 box_drawing (x, y, xdim, ydim);
  623.                 startx = x - xdim / 2;
  624.                 starty = y - ydim / 2;
  625.                 pw_write (pw, startx, starty, xdim, ydim, PIX_SRC, pr, 0, 0);
  626.                 if (pr != clipboard.pr)
  627.                     pr_close (pr);
  628.                 square_drawn = first_middle_down = 0;
  629.                 copy_request = paste_request = 0;
  630.                 oldx = oldy = 0;
  631.                 is_moving = 0;
  632.                 curr_image.startx = startx;
  633.                 curr_image.starty = starty;
  634.                 curr_image.org_xdim = curr_image.xdim = xdim;
  635.                 curr_image.org_ydim = curr_image.ydim = ydim;
  636.                 curr_image.zoomx = curr_image.zoomy = 1;
  637.                 curr_image.expanded = 0;
  638.                 curr_image.cutout = 1;
  639.                 curr_image.in_use = 0;
  640.             }
  641.             break;
  642.         case LOC_DRAG:
  643.             if (oldx != 0 && oldy != 0)
  644.                 box_drawing (oldx, oldy, xdim, ydim);
  645.             x = event_x (event);
  646.             y = event_y (event);
  647.             box_drawing (x, y, xdim, ydim);
  648.             oldx = x;
  649.             oldy = y;
  650.             break;
  651.         default:
  652.             break;
  653.     }            /* end switch */
  654.  
  655.     return;
  656. }
  657. /* EOF */
  658. /* cat > src+obj/canvas/pick_position.c << "EOF" */
  659. /* ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ */
  660. /* pick_position: select a position as origin for image */
  661. /*          display                */
  662. /* ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ */
  663. /* SCCS information: %W%    %G% - NCSA */
  664.  
  665. /* #include "canvas.h" */
  666.  
  667. pick_position (event)
  668.     Event          *event;
  669. {
  670.         /* first click on canvas picks a position -- upper left corner */
  671.     if (!pos_picked)
  672.     {
  673.         startx = event_x (event);
  674.         starty = event_y (event);
  675.         pos_picked = 1;
  676.         sprintf (msgstr, "Note: Picked position - (x, y) = (%d, %d).", startx, starty);
  677.         msg_write (msgstr);
  678.     }
  679.     else
  680.     {            /* second click loads image */
  681.         msg_write ("Note: Loading image . . . .");  
  682.         if (load_proc2 ((int) panel_get_value (load_toggle)))
  683.             return;
  684.         clear_request = 0;
  685.         reset_pos ();
  686.     }
  687.     return;
  688. }
  689. /* EOF */
  690.