home *** CD-ROM | disk | FTP | other *** search
/ ARM Club 1 / ARM_CLUB_CD.iso / contents / apps / clib / progs / haswinlib / c / pollwind < prev    next >
Encoding:
Text File  |  1991-02-04  |  16.1 KB  |  388 lines
  1. /* > $.CLIB.C.pollwind
  2.  *
  3.  *      HASWIN Graphics Library
  4.  *     =========================
  5.  *
  6.  *      Copyright (C) H.A.Shaw 1990.
  7.  *              Howard A. Shaw.
  8.  *              The Unit for Space Sciences,
  9.  *              Room 165,
  10.  *              Physics Building,
  11.  *              University of Kent at Canterbury.
  12.  *              Canterbury.
  13.  *              Kent.  CT2 7NJ
  14.  *      You may use and distribute this code freely, however please leave
  15.  *      it alone.  If you find bugs (and there will be many) please contact
  16.  *      me and the master source can be modified.  If you keep me informed
  17.  *      of who you give copies of this to then I can get release upgrades
  18.  *      to them.
  19.  *
  20.  *      routine to perform windows related reason code returns from
  21.  *      SWI(Wimp_Poll)
  22.  */
  23. #include "c.poll_h"
  24.  
  25. /*
  26.  *      this routine handles window redrawing called from SWI(Wimp_Poll)
  27.  *      reason code 1.  It checks to see if output must be redirected to
  28.  *      a sprite.
  29.  */
  30. int haswin_poll_redraw(int (*user)(int, buffer *), buffer *pbuf) {
  31.  
  32.         int                     adjx, adjy, whandle, more;
  33.         window                  *wptr;
  34.         _kernel_swi_regs        regs;
  35.         buffer                  buff;
  36.  
  37.         if ((user) && (!((*user)(HASWIN_POLL_Redraw, pbuf))))
  38.                 return(HASWIN_FALSE);
  39.         whandle = pbuf->i[0];
  40.         if (haswin_spritejob.win == whandle) {
  41.                 regs.r[0] = 0x3C;
  42.                 regs.r[3] = (int)haswin_spritejob.savearea;
  43.                 haswin_spriteop(haswin_spritejob.name, ®s);
  44.                 haswin_spritejob.r0 = regs.r[0];
  45.                 haswin_spritejob.r1 = regs.r[1];
  46.                 haswin_spritejob.r2 = regs.r[2];
  47.                 haswin_spritejob.r3 = regs.r[3];
  48.         }
  49.         buff.i[0] = whandle;
  50.         regs.r[1] = (int)&buff;
  51.         if (!haswin_swi(HASWIN_Redraw_window, ®s)) {
  52.                 if (haswin_spritejob.win == whandle) {
  53.                         /* switch output back to screen */
  54.                         regs.r[0] = haswin_spritejob.r0;
  55.                         regs.r[1] = haswin_spritejob.r1;
  56.                         regs.r[2] = haswin_spritejob.r2;
  57.                         regs.r[3] = haswin_spritejob.r3;
  58.                         haswin_spriteop(0, ®s);
  59.                 }
  60.                 return(HASWIN_FALSE);
  61.         }
  62.         more = regs.r[0];
  63.         if (haswin_spritejob.win == whandle) {
  64.                 /* switch output back to screen */
  65.                 regs.r[0] = haswin_spritejob.r0;
  66.                 regs.r[1] = haswin_spritejob.r1;
  67.                 regs.r[2] = haswin_spritejob.r2;
  68.                 regs.r[3] = haswin_spritejob.r3;
  69.                 haswin_spriteop(0, ®s);
  70.         }
  71.         while (more) {
  72.                 whandle = buff.i[0];
  73.                 if ((int)(wptr=haswin_findwindowhandle(whandle)) > 0) {
  74.                         haswin_updatewindowinfo(wptr);
  75.                         if (haswin_spritejob.win == whandle) {
  76.                                 regs.r[0] = 0x3C;
  77.                                 regs.r[3] = (int)haswin_spritejob.savearea;
  78.                                 haswin_spriteop(haswin_spritejob.name, ®s);
  79.                                 haswin_spritejob.r0 = regs.r[0];
  80.                                 haswin_spritejob.r1 = regs.r[1];
  81.                                 haswin_spritejob.r2 = regs.r[2];
  82.                                 haswin_spritejob.r3 = regs.r[3];
  83.                         }
  84.                         if (!((wptr->drawroutine) &&
  85.                              (!wptr->drawroutine(wptr, &buff)))) {
  86.                                 if (wptr->text) {
  87.                                         adjx=buff.i[1]-buff.i[5]+wptr->orgx;
  88.                                         adjy=buff.i[4]-buff.i[6]+wptr->orgy;
  89.                                         text_plot(wptr->text, adjx,
  90.                                                adjy, buff.i[7], buff.i[ 9],
  91.                                                      buff.i[8], buff.i[10]);
  92.                                 }
  93.                                 if (wptr->picture) {
  94.                                         adjx=buff.i[1]-buff.i[5]+wptr->orgx;
  95.                                         adjy=buff.i[4]-buff.i[6]+wptr->orgy;
  96.                                         graphics_plot(wptr->picture, adjx,
  97.                                                adjy, buff.i[7], buff.i[ 9],
  98.                                                      buff.i[8], buff.i[10]);
  99.                                 }
  100.                         }
  101.                 }
  102.                 buff.i[0] = whandle;
  103.                 regs.r[1] = (int)&buff;
  104.                 if (!haswin_swi(HASWIN_Get_rectangle, ®s)) {
  105.                         if (haswin_spritejob.win == whandle) {
  106.                                 /* switch output back to screen */
  107.                                 regs.r[0] = haswin_spritejob.r0;
  108.                                 regs.r[1] = haswin_spritejob.r1;
  109.                                 regs.r[2] = haswin_spritejob.r2;
  110.                                 regs.r[3] = haswin_spritejob.r3;
  111.                                 haswin_spriteop(0, ®s);
  112.                         }
  113.                         return(HASWIN_FALSE);
  114.                 }
  115.                 more = regs.r[0];
  116.                 if (haswin_spritejob.win == whandle) {
  117.                         /* switch output back to screen */
  118.                         regs.r[0] = haswin_spritejob.r0;
  119.                         regs.r[1] = haswin_spritejob.r1;
  120.                         regs.r[2] = haswin_spritejob.r2;
  121.                         regs.r[3] = haswin_spritejob.r3;
  122.                         haswin_spriteop(0, ®s);
  123.                 }
  124.         }
  125.         if (haswin_spritejob.win == whandle)
  126.                 haswin_spritejob.win=0;    /* sprite drawn in, finished */
  127.         if ((user) && (!((*user)(HASWIN_POLL_PostRedraw, pbuf))))
  128.                 return(HASWIN_FALSE);
  129.         return(HASWIN_TRUE);
  130. }
  131.  
  132. void haswin_redrawwindow(window *win, int x0, int x1, int y0, int y1) {
  133.  
  134.         _kernel_swi_regs  regs;
  135.         int               whandle, adjx, adjy, more;
  136.         buffer            buff;
  137.         window            *wptr;
  138.  
  139.         if ((int)win <= 0)
  140.                 whandle = (int)win;
  141.         else
  142.                 whandle = win->handle;
  143.         if (!(haswin_getwindowflags(win) & WINDOW_OPEN))
  144.                 /* nothing to do if window is not open */
  145.                 return;
  146.         if (haswin_spritejob.win == whandle) {
  147.                 regs.r[0] = 0x3C;
  148.                 regs.r[3] = (int)haswin_spritejob.savearea;
  149.                 haswin_spriteop(haswin_spritejob.name, ®s);
  150.                 haswin_spritejob.r0 = regs.r[0];
  151.                 haswin_spritejob.r1 = regs.r[1];
  152.                 haswin_spritejob.r2 = regs.r[2];
  153.                 haswin_spritejob.r3 = regs.r[3];
  154.         }
  155.         buff.i[0] = whandle;
  156.         buff.i[1] = x0 + win->orgx;
  157.         buff.i[2] = y0 + win->orgy;
  158.         buff.i[3] = x1 + win->orgx;
  159.         buff.i[4] = y1 + win->orgy;
  160.         regs.r[1] = (int)&buff;
  161.         if (!haswin_swi(HASWIN_Update_window, ®s))
  162.                 return;
  163.         more = regs.r[0];
  164.         if (haswin_spritejob.win == whandle) {
  165.                 /* switch output back to screen */
  166.                 regs.r[0] = haswin_spritejob.r0;
  167.                 regs.r[1] = haswin_spritejob.r1;
  168.                 regs.r[2] = haswin_spritejob.r2;
  169.                 regs.r[3] = haswin_spritejob.r3;
  170.                 haswin_spriteop(0, ®s);
  171.         }
  172.         while (more) {
  173.                 whandle = buff.i[0];
  174.                 if ((int)(wptr=haswin_findwindowhandle(whandle)) > 0) {
  175.                         haswin_updatewindowinfo(wptr);
  176.                         if (haswin_spritejob.win == whandle) {
  177.                                 regs.r[0] = 0x3C;
  178.                                 regs.r[3] = (int)haswin_spritejob.savearea;
  179.                                 haswin_spriteop(haswin_spritejob.name, ®s);
  180.                                 haswin_spritejob.r0 = regs.r[0];
  181.                                 haswin_spritejob.r1 = regs.r[1];
  182.                                 haswin_spritejob.r2 = regs.r[2];
  183.                                 haswin_spritejob.r3 = regs.r[3];
  184.                         }
  185.                         graphics_gcol(0, wptr->win[35]);
  186.                         graphics_rectanglefill(buff.i[7], buff.i[8],
  187.                                 buff.i[ 9]-buff.i[ 7],
  188.                                 buff.i[10]-buff.i[ 8]);
  189.                         if (!((wptr->drawroutine) &&
  190.                              (!wptr->drawroutine(wptr, &buff)))) {
  191.                                 if (wptr->text) {
  192.                                         adjx=buff.i[1]-buff.i[5]+wptr->orgx;
  193.                                         adjy=buff.i[4]-buff.i[6]+wptr->orgy;
  194.                                         text_plot(wptr->text, adjx,
  195.                                                adjy, buff.i[7], buff.i[ 9],
  196.                                                      buff.i[8], buff.i[10]);
  197.                                 }
  198.                                 if (wptr->picture) {
  199.                                         adjx=buff.i[1]-buff.i[5]+wptr->orgx;
  200.                                         adjy=buff.i[4]-buff.i[6]+wptr->orgy;
  201.                                         graphics_plot(wptr->picture, adjx,
  202.                                                adjy, buff.i[7], buff.i[ 9],
  203.                                                      buff.i[8], buff.i[10]);
  204.                                 }
  205.                         }
  206.                         if (haswin_spritejob.win == whandle) {
  207.                                 /* switch output back to screen */
  208.                                 regs.r[0] = haswin_spritejob.r0;
  209.                                 regs.r[1] = haswin_spritejob.r1;
  210.                                 regs.r[2] = haswin_spritejob.r2;
  211.                                 regs.r[3] = haswin_spritejob.r3;
  212.                                 haswin_spriteop(0, ®s);
  213.                         }
  214.                 }
  215.                 buff.i[0] = whandle;
  216.                 regs.r[1] = (int)&buff;
  217.                 if (!haswin_swi(HASWIN_Get_rectangle, ®s))
  218.                         return;
  219.                 more = regs.r[0];
  220.         }
  221. }
  222.  
  223. int haswin_poll_open(int (*user)(int, buffer *), buffer *pbuf) {
  224.  
  225.         window  *wptr;
  226.  
  227.         wptr = haswin_findwindowhandle(pbuf->i[0]);
  228.         pbuf->i[8] = (int)wptr;
  229.         if ((user) && (!((*user)(HASWIN_POLL_Open, pbuf))))
  230.                 return(HASWIN_FALSE);
  231.         if ((int)wptr > 0) {
  232.                 return(haswin_openwindow(wptr, pbuf->i[1], pbuf->i[2], pbuf->i[3], pbuf->i[4], pbuf->i[5], pbuf->i[6], pbuf->i[7]));
  233.         }
  234.         return(HASWIN_FALSE);
  235. }
  236.  
  237. int haswin_poll_close(int (*user)(int, buffer *), buffer *pbuf) {
  238.  
  239.         pointer *mouse;
  240.         window  *wptr;
  241.  
  242.         wptr = haswin_findwindowhandle(pbuf->i[0]);
  243.         pbuf->i[1] = (int)wptr;
  244.         if ((user) && (!((*user)(HASWIN_POLL_Close, pbuf))))
  245.                 return(HASWIN_FALSE);
  246.         if ((int)wptr > 0) {
  247.                 if (wptr->flags&WINDOW_FILER) {
  248.                         mouse = haswin_getpointerinfo(0);
  249.                         if ((mouse->buttons&POINTER_MOUSEBUTTONS) == POINTER_MOUSE_R)
  250.                                 haswin_openfiler("adfs", haswin_getwindowname(wptr));
  251.                         haswin_free(mouse);
  252.                 }
  253.                 haswin_closewindow(wptr);
  254.                 return(HASWIN_TRUE);
  255.         } else
  256.                 return(HASWIN_FALSE);
  257. }
  258.  
  259. int haswin_poll_leaving(int (*user)(int, buffer *), buffer *pbuf) {
  260.  
  261.         window  *wptr;
  262.         caret   car;
  263.  
  264.         wptr = haswin_findwindowhandle(pbuf->i[0]);
  265.         pbuf->i[1] = (int)wptr;
  266.         if ((user) && (!((*user)(HASWIN_POLL_Leaving, pbuf))))
  267.                 return(HASWIN_FALSE);
  268.         if ((int)wptr > 0) {
  269.                 if (wptr->flags & WINDOW_SELECT) {
  270.                         haswin_getcaretinfo(&car);
  271.                         if (wptr == car.win)
  272.                                 haswin_popcaret();
  273.                 }
  274.                 if (wptr->pointer)
  275.                         haswin_poppointer(HASWIN_FALSE);
  276.         }
  277.         return(HASWIN_TRUE);
  278. }
  279.  
  280. int haswin_poll_entering(int (*user)(int, buffer *), buffer *pbuf) {
  281.  
  282.         window  *wptr;
  283.         caret   car;
  284.  
  285.         wptr = haswin_findwindowhandle(pbuf->i[0]);
  286.         pbuf->i[1] = (int)wptr;
  287.         if ((user) && (!((*user)(HASWIN_POLL_Entering, pbuf))))
  288.                 return(HASWIN_FALSE);
  289.         if ((int)wptr > 0) {
  290.                 if (wptr->flags & WINDOW_SELECT) {
  291.                         if (wptr->caret)
  292.                                 haswin_pushcaret(wptr->caret);
  293.                         else {
  294.                                 car.win = wptr;
  295.                                 car.ic = (icon *)(-1);
  296.                                 car.x = 5;
  297.                                 car.y = -45;
  298.                                 car.flags = 0;
  299.                                 car.index = 0;
  300.                                 car.height = 40;
  301.                                 car.colour = 11;
  302.                                 haswin_pushcaret(&car);
  303.                         }
  304.                 }
  305.                 if (wptr->pointer) {
  306.                         haswin_pushpointer(wptr->pointer, HASWIN_FALSE);
  307.                 }
  308.         }
  309.         return(HASWIN_TRUE);
  310. }
  311.  
  312. int haswin_poll_key(int (*user)(int, buffer *), buffer *pbuf) {
  313.  
  314.         window                  *wptr;
  315.         icon                    *iptr;
  316.         pointer                 *mouse;
  317.         _kernel_swi_regs        regs;
  318.  
  319.         wptr = haswin_findwindowhandle(pbuf->i[0]);
  320.         iptr = haswin_findiconhandle(wptr, pbuf->i[1]);
  321.         pbuf->i[7] = (int)wptr;
  322.         pbuf->i[8] = (int)iptr;
  323.         if ((user) && (!((*user)(HASWIN_POLL_Key, pbuf))))
  324.                 return(HASWIN_FALSE);
  325.         if ((wptr) && (!iptr) && (wptr->text)) {
  326.                 /* key pressed while in a window with text, add it */
  327.                 haswin_textvdu(wptr, pbuf->i[6]);
  328.                 return(HASWIN_TRUE);
  329.         }
  330.         if (pbuf->i[6] == 13) {
  331.                 /* CR used to complete entry, pretend to be mouse SELECT */
  332.                 mouse = haswin_getpointerinfo(0);
  333.                 regs.r[0] = HASWIN_POLL_Mouse;
  334.                 regs.r[1] = (int)pbuf;
  335.                 regs.r[2] = pbuf->i[0];
  336.                 regs.r[3] = pbuf->i[1];
  337.                 pbuf->i[3] = pbuf->i[0];
  338.                 pbuf->i[4] = pbuf->i[1];
  339.                 pbuf->i[0] = mouse->mx;
  340.                 pbuf->i[1] = mouse->my;
  341.                 pbuf->i[2] = haswin_buttonHASWINtoWIMP(wptr, iptr, HASWIN_MOUSE_L);
  342.                 if (!haswin_swi(HASWIN_Send_message, ®s))
  343.                         return(HASWIN_FALSE);
  344.                 return(HASWIN_TRUE);
  345.         }
  346.         if ((pbuf->i[6] >= 0x181) && (pbuf->i[6] <= 0x189)) {
  347.                 /* F1 - F9, find icon 0 - 8 and pretend to be mouse SELECT */
  348.                 iptr = haswin_findiconhandle(wptr, (pbuf->i[6]&0x00F)-1);
  349.                 if (iptr) {
  350.                         mouse = haswin_getpointerinfo(0);
  351.                         mouse->win = wptr;
  352.                         mouse->ic  = iptr;
  353.                         haswin_setpointer(mouse, HASWIN_TRUE);
  354.                         regs.r[0] = HASWIN_POLL_Mouse;
  355.                         regs.r[1] = (int)pbuf;
  356.                         regs.r[2] = iptr->whandle;
  357.                         regs.r[3] = iptr->ihandle;
  358.                         pbuf->i[4] = iptr->ihandle;
  359.                         pbuf->i[3] = iptr->whandle;
  360.                         pbuf->i[1] = mouse->my;
  361.                         pbuf->i[0] = mouse->mx;
  362.                         pbuf->i[2] = haswin_buttonHASWINtoWIMP(wptr, iptr, HASWIN_MOUSE_L);
  363.                         if (!haswin_swi(HASWIN_Send_message, ®s))
  364.                                 return(HASWIN_FALSE);
  365.                         return(HASWIN_TRUE);
  366.                 }
  367.         }
  368.         /* can't handle key, so pass it on */
  369.         regs.r[0] = pbuf->i[6];
  370.         haswin_swi(HASWIN_Process_key, ®s);
  371.         return(HASWIN_TRUE);
  372. }
  373.  
  374. int haswin_poll_lcaret(int (*user)(int, buffer *), buffer *pbuf) {
  375.  
  376.         if ((user) && (!((*user)(HASWIN_POLL_Lose_Caret, pbuf))))
  377.                 return(HASWIN_FALSE);
  378.         return(HASWIN_TRUE);
  379. }
  380.  
  381. int haswin_poll_gcaret(int (*user)(int, buffer *), buffer *pbuf) {
  382.  
  383.         if ((user) && (!((*user)(HASWIN_POLL_Gane_Caret, pbuf))))
  384.                 return(HASWIN_FALSE);
  385.         return(HASWIN_TRUE);
  386. }
  387.  
  388.