home *** CD-ROM | disk | FTP | other *** search
/ OS/2 Shareware BBS: 10 Tools / 10-Tools.zip / tvos200.zip / TVISION / HARDOS2.CPP < prev    next >
C/C++ Source or Header  |  1995-04-25  |  10KB  |  315 lines
  1. /*------------------------------------------------------------*/
  2. /* filename -       hardos2.cpp                               */
  3. /*                                                            */
  4. /* function(s)                                                */
  5. /*                  Member variables for THardwareInfo class  */
  6. /*                  under the OS/2 OS.                        */
  7. /*                                                            */
  8. /*------------------------------------------------------------*/
  9. /*
  10.  *      Turbo Vision - Version 2.0
  11.  *
  12.  *      Copyright (c) 1994 by Borland International
  13.  *      All Rights Reserved.
  14.  *
  15.  */
  16. #if defined(__OS2__)                    // Compile module for DOS only.
  17.  
  18. #define Uses_TKeys
  19. #define Uses_TEvent
  20. #define Uses_TScreen
  21. #define Uses_THardwareInfo
  22. #define Uses_TSystemError
  23. #include    <tvision\tv.h>
  24.  
  25. #include    <tvision/os2stuff.h>
  26. #include    <assert.h>
  27.  
  28. //** OS/2-specific THardwareInfo stuff..
  29. Boolean THardwareInfo::insertState = True;
  30. THardwareInfo::PlatformType THardwareInfo::platform = THardwareInfo::plOS2;
  31.  
  32.  
  33. static Boolean initMouse();
  34.  
  35.  
  36. /*
  37.  *  Constructor()..
  38.  */
  39. THardwareInfo::THardwareInfo()
  40. {
  41.     platform = plOS2;                   // Just define the OS/2 platform.
  42.     initMouse();                        // Open the mouse interface
  43. }
  44.  
  45. /****************************************************************************/
  46. /*                                                                          */
  47. /*  CODING: Screen functions.                                               */
  48. /*                                                                          */
  49. /****************************************************************************/
  50. ushort THardwareInfo::getScreenMode()
  51. {
  52.     VIOCONFIGINFO   vci;
  53.     VIOMODEINFO     vmi;
  54.     int             mono;
  55.     USHORT          mode;
  56.  
  57.     vci.cb  = sizeof(vci);
  58.     VioGetConfig(0, &vci, 0);
  59.     vmi.cb  = sizeof(vmi);
  60.     VioGetMode(&vmi, 0);
  61.     mono = vci.display == MONITOR_MONOCHROME;   /* Set T when in MONO mode, */
  62.  
  63.     switch(vci.adapter)
  64.     {
  65.         case DISPLAY_MONOCHROME:    mode = TDisplay::smMono;    break;
  66.         case DISPLAY_CGA:           mode = TDisplay::smCO80;    break;
  67.         case DISPLAY_EGA:           mode = TDisplay::smCO80;    break;
  68.  
  69.         default:
  70.             if(vci.adapter < 7)
  71.             {
  72.                 mode = TDisplay::smMono;
  73.                 break;
  74.             }
  75.             /**** Else continue & use VGA. ****/
  76.  
  77.         case 8:                                 // ?? Reported by OS/2 2.0??
  78.         case DISPLAY_VGA:
  79.             mode = TDisplay::smCO80;
  80.             break;
  81.     }
  82.     if(getScreenRows() > 25)
  83.         mode |= TDisplay::smFont8x8;        // Stupid hardware dependent stuff
  84.     return mode;
  85. }
  86.  
  87. void THardwareInfo::setScreenMode( ushort mode )
  88. {
  89.     //** $NI$: Currently not implemented.
  90. }
  91.  
  92. void THardwareInfo::screenWrite( ushort x, ushort y, ushort *buf, unsigned len )
  93. {
  94.     VioWrtCellStr((PCH) buf, ushort(len), y, x, 0);
  95. }
  96.  
  97.  
  98. ushort THardwareInfo::getScreenCols()
  99. {
  100.     ushort          errc;
  101.     VIOMODEINFO     vmi;
  102.  
  103.     vmi.cb  = sizeof(vmi);
  104.     errc= VioGetMode(&vmi, 0);          // Get Mode Info,
  105.     if(errc) return 25;                 // On error return default #rows,
  106.     return vmi.row < 80 ? 80 : vmi.col; // Return #rows, at least 25!
  107. }
  108.  
  109. ushort THardwareInfo::getScreenRows()
  110. {
  111.     ushort          errc;
  112.     VIOMODEINFO     vmi;
  113.  
  114.     vmi.cb  = sizeof(vmi);
  115.     errc= VioGetMode(&vmi, 0);          // Get Mode Info,
  116.     if(errc) return 25;                 // On error return default #rows,
  117.     return vmi.row < 25 ? 25 : vmi.row; // Return #rows, at least 25!
  118. }
  119.  
  120.  
  121.  
  122. /****************************************************************************/
  123. /*                                                                          */
  124. /*  CODING: Caret (hardware cursor) functions.                              */
  125. /*                                                                          */
  126. /****************************************************************************/
  127.  
  128. ushort THardwareInfo::getCaretSize()
  129. {
  130.     VIOCURSORINFO   vci;
  131.  
  132.     VioGetCurType(&vci, 0);             // Get cursor shape,
  133.     return (vci.yStart << 8) | vci.cEnd;
  134. }
  135.  
  136. void THardwareInfo::setCaretPosition( ushort x, ushort y )
  137. {
  138.     VioSetCurPos(y, x, 0);              // Set cursor position,
  139. }
  140.  
  141. void THardwareInfo::setCaretSize(ushort ct)
  142. {
  143.     VIOCURSORINFO   vci;
  144.  
  145.     /**** The HIGH part of ct contains the TOP line, the LOW part == count, ****/
  146.     VioGetCurType(&vci, 0);             // Get cursor shape,
  147.     if(ct == 0 || (ct >> 8) > 8)        // Cursor OFF request?
  148.         vci.attr    = 0xffff;           // Then switch OFF the cursor!!
  149.     else
  150.     {
  151.         vci.yStart  = ct >> 8;
  152.         vci.cEnd    = ct & 0xff;
  153.     }
  154.     VioSetCurType(&vci, 0);
  155. }
  156.  
  157.  
  158. /****************************************************************************/
  159. /*                                                                          */
  160. /*  CODING: Event functions - keyboard interface.                           */
  161. /*                                                                          */
  162. /****************************************************************************/
  163.  
  164.  
  165. Boolean THardwareInfo::getKeyEvent( TEvent& event )
  166. {
  167.     ushort  key, state;
  168.  
  169.     key = osKeyFast(& state);           // Get keycode && state, no block,
  170.     if(key == 0)                        // No key was pressed?
  171.     {
  172.         event.what = evNothing;
  173.         return False;
  174.     }
  175.  
  176.     /**** Translate the OS/2 state to the Turbo Vision defines.. ****/
  177.     /*
  178.      *  The OS/2 values are the same as the DOS values, so leave'm!! This is
  179.      *  NOT portable but fast..
  180.      */
  181.     event.what = evKeyDown;
  182.     event.keyDown.charScan.scanCode = uchar( key >> 8 );
  183.     event.keyDown.charScan.charCode = uchar( key );
  184.     event.keyDown.controlKeyState   = state;
  185.     return True;
  186. }
  187.  
  188.  
  189. /****************************************************************************/
  190. /*                                                                          */
  191. /*  CODING: Mouse events.                                                   */
  192. /*                                                                          */
  193. /****************************************************************************/
  194. /*
  195.  *  Mouse event handler. This mouse event handler uses Mou* subsystem calls to
  196.  *  manipulate the rodent. This is not reentrant. To find mouse state
  197.  *  differences the routines keep a global "state" variable which contains the
  198.  *  last known mouse state. When the new state is read it is compared with the
  199.  *  previous state, and from that comparison the events are generated.
  200.  */
  201. static Boolean          Initialized = False;    // T when 1st call is done.
  202. static MouseEventType   LastMouse;              // Last event gotten,
  203. static HMOU             Handle;
  204. static Boolean          HasMouse = False;
  205.  
  206.  
  207. /*
  208.  *  initMouse() initializes the mouse for OS/2. Called from the constructor.
  209.  */
  210. static Boolean initMouse()
  211. {
  212.     USHORT  msk = MOUSE_MOTION | MOUSE_BN1_DOWN | MOUSE_MOTION_WITH_BN1_DOWN |
  213.                   MOUSE_MOTION_WITH_BN2_DOWN | MOUSE_BN2_DOWN;
  214.  
  215.     assert(! HasMouse);                     // Cannot have mouse yet!
  216.     if(MouOpen(NULL, &Handle) == 0)         // Open the MOUSE device,
  217.     {
  218.         HasMouse = True;
  219.         MouSetEventMask(&msk, Handle);      // Set events we need,
  220.         MouFlushQue(Handle);                // Release current queue,
  221.         return True;
  222.     }
  223.     return False;
  224. }
  225.  
  226.  
  227. /*
  228.  *  hasMouseEvent() checks if a mouse event has occured and, if so, retrieves
  229.  *  the event.
  230.  */
  231. static Boolean hasMouseEvent(MouseEventType& me)
  232. {
  233.     USHORT          errc;
  234.     MOUEVENTINFO    mei;
  235.     MOUQUEINFO      qi;
  236.     USHORT          flg = MOU_NOWAIT;
  237.  
  238.     if(! HasMouse)
  239.     {
  240.         if(! initMouse()) return False;
  241.     }
  242.  
  243.     errc= MouGetNumQueEl(&qi, Handle);              // Are there elements?
  244.     if(errc != 0 || qi.cEvents <= 0) return False;  // No-> no events.
  245.     errc= MouReadEventQue(&mei, &flg, Handle);      // Read queue. OK?
  246.     if(errc != 0) return False;                     // Failed-> no events.
  247.  
  248.     me.where.x  = mei.col;
  249.     me.where.y  = mei.row;
  250.     me.controlKeyState = osKeyState();              // Get keystate at time of event
  251.     me.buttons  = 0;
  252.     if((mei.fs & (MOUSE_MOTION_WITH_BN1_DOWN|MOUSE_BN1_DOWN)) != 0)
  253.         me.buttons |= mbLeftButton;
  254.     if((mei.fs & (MOUSE_MOTION_WITH_BN2_DOWN|MOUSE_BN2_DOWN)) != 0)
  255.         me.buttons |= mbRightButton;
  256.     return True;
  257. }
  258.  
  259.  
  260. ulong THardwareInfo::getButtonCount()
  261. {
  262.     return HasMouse ? 2 : 0;
  263. }
  264.  
  265. Boolean THardwareInfo::getMouseEvent( MouseEventType& ev )
  266. {
  267.     if(! hasMouseEvent(ev)) return False;           // No event-> exit.
  268.  
  269.     //** An event has occured. If this is the 1st event we see then init the
  270.     //** event variable..
  271.     if(! Initialized)
  272.     {
  273.         LastMouse = ev;                             // Initialize last mouse;
  274.         LastMouse.buttons   = 0;                    // No buttons pressed, though,
  275.         Initialized = True;
  276.     }
  277.     return True;
  278. }
  279.  
  280.  
  281. ulong THardwareInfo::getTickCount()
  282. {
  283.     return osTimeGetRunning() / 55;         // Get ticks from ms counter. Bah.
  284. }
  285.  
  286.  
  287. void THardwareInfo::cursorOn()
  288. {
  289.     MouDrawPtr(Handle);                     // Display mouse.
  290. }
  291.  
  292. void THardwareInfo::cursorOff()
  293. {
  294.     NOPTRRECT   nr;
  295.  
  296.     nr.row  = 0;
  297.     nr.col  = 0;
  298.     nr.cRow = TScreen::screenHeight-1;
  299.     nr.cCol = TScreen::screenWidth-1;
  300.  
  301.     MouRemovePtr(&nr, Handle);              // Remove mouse in this rect,
  302. }
  303.  
  304.  
  305. void THardwareInfo::clearScreen(ushort, ushort)
  306. {
  307.     static char s[] = "\x1b" "[2J";
  308.  
  309.     VioWrtTTY((PCH)s, sizeof(s)-1, 0);
  310. }
  311.  
  312.  
  313. #endif                              // __OS2__ defined.
  314.  
  315.