---

msmouse.c

Go to the documentation of this file.

/*************************************************************************
*   FILE: msmouse.c
* AUTHOR: Weiskamp, Heiny, Flamig
* DATE: 18 April 1993
* PURPOSE:
*   MSMouse functions to interface with Microsoft mouse driver
**************************************************************************
*     REVISION HISTORY
*
*  Rev  Date    Analyst
*
*    0  ??    Weiskamp, Heiny, Flamig
*       Designed.
*    1  16 Apr 1993   Wilson T, Steven W
*       Added 640x480 support, a few additional features.
*    2  18 Apr 1993 CAL
*       Added support for my message-passing protocols.
**************************************************************************/

#include <dos.h>
#include <stdlib.h>
#include "msmouse.h"

const int MsCall  = 0x33;
const int Iret    = 0xcf;

// Initializes mouse to a know state.  Mouse is not turned on yet
MSMouse::MSMouse(void)
{
  OK    = False;
  MouseOff  = True;
}

MSMouse::MSMouse (VideoModeType VideoMode)
{
  OK = False;  MouseOff = True;
  Setup (VideoMode);
}


/***************************************************************************
 *
 *  Returns true if a mouse driver is installed. This function makes sure
 *    the interrupt vector location serviced by the mouse is pointing to
 *    something-hopefully the mouse driver.
 *
 ***************************************************************************/


bool MSMouse::DriverExists(void)
{
  void far *address;
  address = getvect(MsCall);
  return (bool) ((address != NULL) &&
          (*(unsigned char far *)address != Iret));
}


void MSMouse::Setup(VideoModeType VideoMode)
{
  REGS regs;

  OK = DriverExists();
  if (OK) {
    regs.x.ax = 0;
    int86(MsCall, &regs, &regs);
    if (regs.x.ax == 0)
      OK = False;
  }
  if (!OK) {  // Mouse initialization failed. Set
    TurnOff();  // the mouse state off and return.
    return;

  }
  TurnOn();   // Set the mouse state on

  if (VideoMode == TextScrn) TextMode = True; else TextMode = False;
  if (VideoMode == LowResGr) LowRes = True; else LowRes = False;
  if (VideoMode == HighResGr) HighRes = True; else HighRes = False;

  OldX = 0;  OldY = 0;
  X = 0;   Y = 0;
  Dx = 0;  Dy = 0;
  Move (0,0);

  SetSpeed2();
}


void MSMouse::Hide(void)
{
  REGS regs;

  if (!Operating())
    return;
  regs.x.ax = 2;
  int86(MsCall, &regs, &regs);
}

void MSMouse::Show(void)
{
  REGS regs;

  if (!Operating())
    return;
  regs.x.ax = 1;
  int86 (MsCall, &regs, &regs);
}


unsigned MSMouse::Status (int &Mx, int &My)
// This general function returns the location of the mouse in Mx, My
// and the current status of the buttons in the function
{
  REGS regs;

  if (!Operating()) {
    Mx = My = 0;
    return 0;
  }

  regs.x.ax = 3;
  int86(MsCall, &regs, &regs);

  Mx = regs.x.cx;
  My = regs.x.dx;

  if (TextMode)  {
    Mx >>= 3;  // Adjusts for text coordinates
    My >>= 3;
  }

  if (LowRes)
    Mx >>= 1;

  return regs.x.bx;
}


unsigned MSMouse::ButtonStatus(void)
{
  int Mx, My;

  if (!Operating())
    return 0;
  else
    return Status(Mx, My);
}

int MSMouse::PressCnt(unsigned ButtonMask)
{
  REGS regs;
  if (!Operating())
    return 0;

  regs.x.ax = 5;
  regs.x.bx = ButtonMask >> 1; // Button selector
  int86(MsCall, &regs, &regs);

  return regs.x.bx;
}

int MSMouse::ReleaseCnt(unsigned ButtonMask)
{
  REGS regs;

  if (!Operating())
    return 0;

  regs.x.ax = 6;
  regs.x.bx = ButtonMask >> 1;
  int86(MsCall, &regs, &regs);

  return regs.x.bx;
}

Message MSMouse::Event (void)
{
  unsigned E;
  int Mx, My;

  if (!Operating())
    return NullMsg;

  // Get current status of buttons
  E = Status(Mx,My);

  // No mouse button downm, but maybe there was a button press that was
  // missed.  If not, check to see whether a buttton release was missed.
  // Favor the left button

  if (E == 0)  {
    if (PressCnt(LeftButton) > 0)
      E = LMouseDown;
  else
    if (PressCnt (RightButton) > 0)
      E = RMouseDown;
  // Maybe left one was just released
  else
    if (ReleaseCnt (LeftButton) > 0)
      E = LMouseUp;
  // Maybe rightr one was just released
  else
    if (ReleaseCnt(RightButton) > 0)
      E = RMouseDown;
  else
    E = Idle;
  }

  else { // a mouse button is down
  // was left already down?!?!??!
  if (E & LeftButton) {
  //not down
    if (PressCnt(LeftButton) > 0)
      E = LMouseDown;
    else
      E = LMouseStillDown;
  }
  else
    if (PressCnt(RightButton) > 0)
      E = RMouseDown;
  else
    E = RMouseStillDown;
  }

  return Message (MouseMsg, E, Mx, My);
}

Message MSMouse::WaitForAnyEvent (void)
{
  Message msg;

  if (!Operating()) return NullMsg;

  do {
    msg = Event();
  } while (msg.code == Idle);

  return msg;
}


Message MSMouse::WaitForEvent (Message& msg)
{
  Message try;

  if (!Operating()) return NullMsg;

  do {
     try = Event ();
  } while (try.code != msg.code);

  return try;
}


bool MSMouse::Moved(void)
{
  if (!Operating())
    return False;
  OldX = X;
  OldY = Y;
  Status(X,Y);
  Dx = X - OldX;
  Dy = Y - OldY;

  return (bool) ((Dx != 0) || (Dy != 0));
}

void MSMouse::Move(int Mx, int My)
{
  REGS regs;

  if (!Operating())
    return;

  regs.x.ax = 4;
  regs.x.cx = Mx;
  regs.x.dx = My;

  if (TextMode) {
    regs.x.cx <<= 3;
    regs.x.dx <<= 3;
  }

  if (LowRes)
    regs.x.cx <<= 1;
  if (HighRes)
    regs.x.cx <<= 1;

  int86 (MsCall, &regs, &regs);
}

void MSMouse::TurnOn(void)
{
  if (OK && MouseOff) {
    MouseOff = False;
    Show();
  }
}

void MSMouse::TurnOff(void)
{
  if (OK && !MouseOff) {
    Hide();
    MouseOff = True;
  }
}

void MSMouse::SetGCursor(const MouseCursor &NewCursor)
{
  REGS regs;
  SREGS sregs;

  if (!Operating())
    return;

  regs.x.ax = 9;
  regs.x.bx = NewCursor.HotSpot.X;
  regs.x.cx = NewCursor.HotSpot.Y;
  regs.x.dx = FP_OFF(NewCursor.ScreenMask);
  sregs.es = FP_SEG(NewCursor.ScreenMask);

  int86x(MsCall, &regs, &regs, &sregs);
}

void MSMouse::SetMouseCursor(int Mx, int My)
{
  REGS regs;

  regs.x.ax = 0x4;
  regs.x.cx = Mx;
  regs.x.dx = My;

  int86(MsCall, &regs, &regs);
}

void MSMouse::SetSpeed2()
{
  REGS regs;

  regs.x.ax = 0x13;
  regs.x.dx = THRESHOLD;

  int86(MsCall, &regs, &regs);
}


void MSMouse::Flush (void)
{
  Message m;
  do {
    m = Event ();
  } while (m.code != Idle);
}

---