home *** CD-ROM | disk | FTP | other *** search
/ OS/2 Shareware BBS: 8 Other / 08-Other.zip / pmvnc100.zip / keyst.c < prev    next >
C/C++ Source or Header  |  1999-09-10  |  8KB  |  339 lines
  1. /*
  2.  * keyst.c - PM VNC Viewer, Modal key status window
  3.  */
  4.  
  5. #include <stdio.h>
  6. #include <stdlib.h>
  7. #include <string.h>
  8.  
  9. #define INCL_PM
  10. #include <os2.h>
  11.  
  12. #include "pmvncdef.h"
  13. #include "pmvncres.h"
  14.  
  15. /*
  16.  * use two status windows
  17.  */
  18.  
  19. static  HWND    hwndStateCtl = NULLHANDLE ;
  20. static  HWND    hwndStateAlt = NULLHANDLE ;
  21.  
  22. #define WM_KST_UPDATE   (WM_USER + 1)
  23. #define WM_KST_KEYDN    (WM_USER + 2)
  24. #define WM_KST_KEYUP    (WM_USER + 3)
  25.  
  26. /*
  27.  * control data for Modal Key Status
  28.  */
  29.  
  30. typedef struct _KSTREC {
  31.     UCHAR   keyName[8] ;
  32.     BOOL    keyDown    ;
  33.     COLOR   clrFore    ;
  34.     COLOR   clrDn      ;
  35.     COLOR   clrUp      ;
  36.     HWND    hwndMn     ;
  37.     HWND    hwndEv     ;
  38.     SHORT   evKeyTgl   ;
  39.     SHORT   evKeyDn    ;
  40.     SHORT   evKeyUp    ;
  41. } KSTREC, *KSTPTR ;
  42.  
  43. static  KSTREC  kstCtl = {
  44.     "CTL",
  45.     FALSE,
  46.     CLR_BLACK,
  47.     CLR_WHITE,
  48.     CLR_DARKGRAY,
  49.     NULLHANDLE, 
  50.     NULLHANDLE, 
  51.     IDM_CTLTGL,
  52.     IDM_CTLDN,
  53.     IDM_CTLUP
  54. } ;
  55.  
  56. static  KSTREC  kstAlt = {
  57.     "ALT",
  58.     FALSE,
  59.     CLR_BLACK,
  60.     CLR_WHITE,
  61.     CLR_DARKGRAY,
  62.     NULLHANDLE, 
  63.     NULLHANDLE, 
  64.     IDM_ALTTGL,
  65.     IDM_ALTDN,
  66.     IDM_ALTUP
  67. } ;
  68.  
  69. /*
  70.  * kstDraw - draw modal key state
  71.  */
  72.  
  73. static  void    kstDraw(HWND hwnd, KSTPTR p)
  74. {
  75.     HPS     hps    ;
  76.     RECTL   rct    ;
  77.     LONG    fore, back ;
  78.     
  79.     TRACE("kstDraw %s\n", p->keyName) ; fflush(stdout) ;
  80.     fore = p->clrFore ;
  81.     back = p->keyDown ? p->clrDn : p->clrUp ;
  82.     hps = WinBeginPaint(hwnd, NULLHANDLE, NULL) ;
  83.     WinQueryWindowRect(hwnd, &rct) ;
  84.     WinDrawText(hps, strlen(p->keyName), p->keyName, &rct, 
  85.                     fore, back, (DT_CENTER | DT_VCENTER | DT_ERASERECT)) ;
  86.     WinEndPaint(hps) ;
  87. }
  88.  
  89. /*
  90.  * kstSend - Send Event
  91.  */
  92.  
  93. static  void    kstSend(HWND hwnd, KSTPTR p, SHORT cmd)
  94. {
  95.     SHORT   ev ;
  96.     
  97.     TRACE("kstSend %s %d\n", p->keyName, cmd) ;
  98.     
  99.     switch (cmd) {
  100.         case IDM_KEYTGL : ev = p->evKeyTgl ; break ;
  101.     case IDM_KEYDN  : ev = p->evKeyDn  ; break ;
  102.     case IDM_KEYUP  : ev = p->evKeyUp  ; break ;
  103.     default         : ev = 0           ; break ;
  104.     }
  105.     if (p->hwndEv == NULLHANDLE || ev == 0) {
  106.         return ;
  107.     }
  108.     WinSendMsg(p->hwndEv, WM_COMMAND, MPFROM2SHORT(ev, 0), NULL) ;
  109. }
  110.  
  111. /*
  112.  * kstMenu - context menu on Status Window
  113.  */
  114.  
  115. static  void    kstMenu(HWND hwnd, KSTPTR p)
  116. {
  117.     POINTL  pt   ;
  118.     ULONG   opts ;
  119.  
  120.     if (p->hwndMn == NULLHANDLE) {
  121.         p->hwndMn = WinLoadMenu(hwnd, NULLHANDLE, IDM_KEYST) ;
  122.     }
  123.     if (p->hwndMn == NULLHANDLE) {
  124.         return ;
  125.     }
  126.  
  127.     WinQueryPointerPos(HWND_DESKTOP, &pt) ;
  128.  
  129.     opts = PU_HCONSTRAIN | PU_VCONSTRAIN |
  130.              PU_KEYBOARD | PU_MOUSEBUTTON1 | PU_MOUSEBUTTON2 ;
  131.  
  132.     WinPopupMenu(HWND_DESKTOP, hwnd, p->hwndMn,
  133.                                      pt.x, pt.y, IDM_KEYTGL, opts) ;
  134. }
  135.  
  136. /*
  137.  * kstProc - window procedure for Modal Key Status window
  138.  */
  139.  
  140. static  UCHAR   kstName[] = "KeyStateWindow" ;
  141.  
  142. static MRESULT EXPENTRY kstProc(HWND hwnd, ULONG msg, MPARAM mp1, MPARAM mp2)
  143. {
  144.     KSTPTR  p      ;
  145.     HPS     hps    ;
  146.     RECTL   rct    ;
  147.     UCHAR   buf[2] ;
  148.     
  149.     p = (KSTPTR) WinQueryWindowPtr(hwnd, 0) ;
  150.     
  151.     TRACE("keyst  %08x\n", msg) ;
  152.     
  153.     switch (msg) {
  154.     
  155.     case WM_CREATE :
  156.         WinSetWindowPtr(hwnd, 0, (PVOID) mp1) ;
  157.         return (MRESULT) 0 ;
  158.  
  159.     case WM_PAINT :
  160.         kstDraw(hwnd, p) ;
  161.         return (MRESULT) 0 ;
  162.  
  163.     case WM_SINGLESELECT :
  164.         kstSend(hwnd, p, IDM_KEYTGL) ;
  165.     return (MRESULT) 0 ;
  166.     
  167.     case WM_CONTEXTMENU  :
  168.         kstMenu(hwnd, p) ;
  169.     return (MRESULT) 0 ;
  170.  
  171.     case WM_COMMAND :
  172.         kstSend(hwnd, p, SHORT1FROMMP(mp1)) ;
  173.         return (MRESULT) 0 ;
  174.  
  175.     case WM_KST_UPDATE :
  176.     WinInvalidateRect(hwnd, NULL, FALSE) ;
  177.     return (MRESULT) 0 ;
  178.  
  179.     case WM_KST_KEYDN :
  180.     case WM_KST_KEYUP :
  181.         p->keyDown = (msg == WM_KST_KEYDN) ? TRUE : FALSE ;
  182.     WinInvalidateRect(hwnd, NULL, FALSE) ;
  183.     return (MRESULT) 0 ;
  184.     }
  185.     return WinDefWindowProc(hwnd, msg, mp1, mp2) ;
  186. }
  187.  
  188. /*
  189.  * kstDestroy - destroy key state windows
  190.  */
  191.  
  192. void    kstDestroy(void)
  193. {
  194.     if (hwndStateCtl != NULLHANDLE) {
  195.         WinDestroyWindow(hwndStateCtl) ;
  196.     hwndStateCtl = NULLHANDLE ;
  197.     }
  198.     if (hwndStateAlt != NULLHANDLE) {
  199.         WinDestroyWindow(hwndStateAlt) ;
  200.     hwndStateAlt = NULLHANDLE ;
  201.     }
  202. }
  203.  
  204. /*
  205.  * kstCreate - create key state windows
  206.  */
  207.  
  208. BOOL    kstCreate(HWND hwndFrame)
  209. {
  210.     HWND    hwndTitle = WinWindowFromID(hwndFrame, FID_TITLEBAR) ;
  211.     ULONG   flStyle ;
  212.  
  213.     TRACE("kstCreate\n") ;
  214.     
  215.     /*
  216.      * notify to Frame Window
  217.      */
  218.      
  219.     kstCtl.hwndEv = hwndFrame ;
  220.     kstAlt.hwndEv = hwndFrame ;
  221.     
  222.     /*
  223.      * Disable title-bar to paint over siblings
  224.      */
  225.  
  226.     flStyle = WinQueryWindowULong(hwndTitle, QWL_STYLE) ;
  227.     flStyle |= WS_CLIPCHILDREN ;
  228.     WinSetWindowULong(hwndTitle, QWL_STYLE, flStyle) ;
  229.  
  230.     /*
  231.      * Create Modal Key State Windows
  232.      */
  233.      
  234.     WinRegisterClass(WinQueryAnchorBlock(hwndFrame), kstName, kstProc,
  235.             (CS_CLIPSIBLINGS | CS_SYNCPAINT), sizeof(PVOID)) ;
  236.  
  237.     hwndStateCtl = WinCreateWindow(
  238.             hwndTitle,
  239.         kstName,
  240.         NULL,
  241.             0,
  242.         0, 0, 0, 0,
  243.         hwndFrame,
  244.         HWND_TOP,
  245.         IDW_CTLST,
  246.         &kstCtl,
  247.         NULL) ;
  248.     hwndStateAlt = WinCreateWindow(
  249.             hwndTitle,
  250.         kstName,
  251.         NULL,
  252.             0,
  253.         0, 0, 0, 0,
  254.         hwndFrame,
  255.         HWND_TOP,
  256.         IDW_ALTST,
  257.         &kstAlt,
  258.         NULL) ;
  259.  
  260.     if (hwndStateCtl == NULLHANDLE || hwndStateAlt == NULLHANDLE) {
  261.         TRACE("kstCreate - failed %08x, %08x\n", hwndStateCtl, hwndStateAlt) ;
  262.         kstDestroy() ;
  263.     return FALSE ;
  264.     }
  265.     return TRUE ;
  266. }
  267.  
  268. /*
  269.  * kstAdjust - re-position to title window
  270.  */
  271.  
  272. void    kstAdjust(HWND hwndFrame)
  273. {
  274.     HWND    hwndTitle = WinWindowFromID(hwndFrame, FID_TITLEBAR) ;
  275.     SWP     swpTitle, swpCtl, swpAlt ;
  276.     int     w, h ;
  277.     
  278.     WinQueryWindowPos(hwndTitle, &swpTitle) ;
  279.     
  280.     TRACE("kstAdjust : Title (%d,%d), %dx%d\n", 
  281.             swpTitle.x, swpTitle.y, swpTitle.cx, swpTitle.cy) ;
  282.  
  283.     if (swpTitle.cx == 0 || swpTitle.cy == 0) {
  284.         TRACE("kstAdjust - not visible title\n") ;
  285.         return ;
  286.     }
  287.     if ((h = swpTitle.cy - 4) <= 0) {
  288.         TRACE("kstAdjust - not enough title height\n") ;
  289.     return ;
  290.     }
  291.     w = h * 2 ;
  292.     
  293.     swpCtl.x = swpTitle.cx - (w + 2) * 2 ;
  294.     if (swpCtl.x < 0) {
  295.         TRACE("kstAdjust - not enough width\n") ;
  296.     return ;
  297.     }
  298.     swpCtl.y = 2 ;
  299.     if (swpCtl.y < 0) {
  300.         TRACE("kstAdjust - not enough height\n") ;
  301.     return ;
  302.     }
  303.     swpCtl.cx = w ;
  304.     swpCtl.cy = h ;
  305.     
  306.     swpAlt.x = swpCtl.x + (w + 2) ;
  307.     swpAlt.y = swpCtl.y ;
  308.     swpAlt.cx = w ;
  309.     swpAlt.cy = h ;
  310.  
  311.     WinSetWindowPos(hwndStateCtl, HWND_TOP,
  312.             swpCtl.x, swpCtl.y, swpCtl.cx, swpCtl.cy, 
  313.             SWP_SIZE | SWP_MOVE | SWP_SHOW | SWP_ZORDER) ;
  314.     WinSetWindowPos(hwndStateAlt, HWND_TOP,
  315.             swpAlt.x, swpAlt.y, swpAlt.cx, swpAlt.cy,
  316.         SWP_SIZE | SWP_MOVE | SWP_SHOW | SWP_ZORDER) ;
  317.  
  318.     WinPostMsg(hwndStateCtl, WM_KST_UPDATE, NULL, NULL) ;
  319.     WinPostMsg(hwndStateAlt, WM_KST_UPDATE, NULL, NULL) ;
  320. }
  321.  
  322. /*
  323.  * kstCtlState, kstAltState - state change
  324.  */
  325.  
  326. void    kstCtlState(BOOL down)
  327. {
  328.     ULONG   msg ;
  329.     msg = down ? WM_KST_KEYDN : WM_KST_KEYUP  ;
  330.     WinSendMsg(hwndStateCtl, msg, NULL, NULL) ;
  331. }
  332.  
  333. void    kstAltState(BOOL down)
  334. {
  335.     ULONG   msg ;
  336.     msg = down ? WM_KST_KEYDN : WM_KST_KEYUP  ;
  337.     WinSendMsg(hwndStateAlt, msg, NULL, NULL) ;
  338. }
  339.