mousec.c

功能强大的文本编辑器

/***********************************************************************
*  Funktion         : M o u I G e t Y                                  *
**--------------------------------------------------------------------**
*  Aufgabe          : Ermittelt die (Text-) Zeile, in der sich der     *
*                     Maus-Cursor befindet.                            *
*  Eingabe-Parameter: keine                                            *
*  Return-Wert      : die Maus-Zeile in Bezug auf den Textbildschirm   *
***********************************************************************/

static BYTE MouIGetY( void )
{
 union REGS regs;                /* Prozessorregs f乺 Interruptaufruf */

 regs.x.ax= 0x0003;               /* Fktnr.: f乺 "Get mouse position" */
 MOUINT(regs, regs);                         /* Maus-Treiber aufrufen */
 return (BYTE) YTOROW(regs.x.dx);     /* Zeile umrechnen und zur乧kl. */
}


/***********************************************************************/

int mouse_get_left_button (void)
{
   return MouIsLeftPress();
}

/***********************************************************************
*  Funktion         : M o u S h o w M o u s e                          *
**--------------------------------------------------------------------**
*  Aufgabe          : Maus-Cursor auf dem Bildschirm anzeigen.         *
*  Eingabe-Parameter: keine                                            *
*  Return-Wert      : keiner                                           *
*  Info             : Die Aufrufe von MouHidemMouse() und MouShow-     *
*                     Mouse() m乻sen ausbalanciert sein, damit sie     *
*                     Wirkung zeigen.                                  *
***********************************************************************/

static int mouse_on_off_status;

void MouShowMouse( void )
{
 union REGS regs;                /* Prozessorregs f乺 Interruptaufruf */

 if (mouse_on_off_status == 0)
 {
    mouse_on_off_status++;

    regs.x.ax = 0x0001;                   /* Fktnr.: f乺 "Show Mouse" */
    MOUINT(regs, regs);                      /* Maus-Treiber aufrufen */
 }
}

/***********************************************************************
*  Funktion         : M o u H i d e M o u s e                          *
**--------------------------------------------------------------------**
*  Aufgabe          : Maus-Cursor vom dem Bildschirm entfernen.        *
*  Eingabe-Parameter: keine                                            *
*  Return-Wert      : keiner                                           *
*  Info             : Die Aufrufe von MouHidemMouse() und MouShow-     *
*                     Mouse() m乻sen ausbalanciert sein, damit sie     *
*                     Wirkung zeigen.                                  *
***********************************************************************/

void MouHideMouse( void )
{
 union REGS regs;                /* Prozessorregs f乺 Interruptaufruf */

 if (mouse_on_off_status == 1)
 {
    mouse_on_off_status--;
    regs.x.ax = 0x0002;                    /* Fktnr. f乺 "Hide Mouse" */
    MOUINT(regs, regs);                      /* Maus-Treiber aufrufen */
 }
}

/***********************************************************************
*  Funktion         : M o u S e t M o v e A r e a                      *
**--------------------------------------------------------------------**
*  Aufgabe          : Definiert den Bildschirmbereich, innerhalb dessen*
*                     sich der Maus-Cursor bewegen darf.               *
*  Eingabe-Parameter: x1, y1 = Koordinaten der oberen linken Ecke      *
*                     x2, y2 = Koordinaten der unteren rechten Ecke    *
*  Return-Wert      : keiner                                           *
*  Info             : - Beide Angaben beziehen sich auf den Textbild-  *
*                       schirm und nicht auf den virtuellen Grafik-    *
*                       bildschirm des Maustreibers                    *
***********************************************************************/

#define STACK_SIZE 3

struct WORK_AREA
   {
      byte x1, y1, x2, y2;
      byte save_row, save_col;
      int  win_flag;
   };

static struct WORK_AREA work_area [STACK_SIZE];
static int stack_ind;


void MouSetMoveArea( BYTE x1, BYTE y1, BYTE x2, BYTE y2,
                     int window_flag )
{
/* window_flag = 0 : normal text editing */
/*               1 : inside history window */
/*               2 : inside wildname window */
/*               3 : inside get_line_2_string */
/*               4 : inside hex view/edit */
/*              -1 : return to next lower level */

union REGS regs;                /* Prozessorregs f乺 Interruptaufruf */

/* handle display windows (history, wildname) */  
   center_col = (byte) ((x1 + x2) / 2);
   center_row = (byte) ((y1 + y2) / 2);

   if (window_flag == 0)
   {
      work_area[stack_ind].save_row = mourow;
      work_area[stack_ind].save_col = moucol;

      work_area[stack_ind].x1 = x1;
      work_area[stack_ind].y1 = y1;
      work_area[stack_ind].x2 = x2;
      work_area[stack_ind].y2 = y2;

      work_area[stack_ind].win_flag = window_flag;
   }

   if (window_flag > 0)   /* save old cursor position */
   {
      work_area[stack_ind].save_row = mourow;
      work_area[stack_ind].save_col = moucol;

      stack_ind++;
      stack_ind = min (stack_ind, (STACK_SIZE-1));

      work_area[stack_ind].x1 = x1;
      work_area[stack_ind].y1 = y1;
      work_area[stack_ind].x2 = x2;
      work_area[stack_ind].y2 = y2;

      work_area[stack_ind].win_flag = window_flag;

      moucol = center_col;
      mourow = center_row;
   }

   if (window_flag < 0)   /* restore old cursor position */
   {
      stack_ind--;
      stack_ind = max (stack_ind, 0);

      mourow = work_area[stack_ind].save_row;
      moucol = work_area[stack_ind].save_col;

      x1 = work_area[stack_ind].x1;
      y1 = work_area[stack_ind].y1;
      x2 = work_area[stack_ind].x2;
      y2 = work_area[stack_ind].y2;
   }

   disp_window_active = work_area[stack_ind].win_flag;


/* set hardware registers */
   regs.x.ax = 0x0008;              /* Fktnr. f乺 "Set vertical Limits" */
   regs.x.cx = ROWTOY( y1 );                /* Umrechnung in virtuellen */
   regs.x.dx = ROWTOY( y2 );                /* Mausbildschirm           */
   MOUINT(regs, regs);                         /* Maus-Treiber aufrufen */
   regs.x.ax = 0x0007;            /* Fktnr. f乺 "Set horizontal Limits" */
   regs.x.cx = COLTOX( x1 );                /* Umrechnung in virtuellen */
   regs.x.dx = COLTOX( x2 );                /* Mausbildschirm           */
   MOUINT(regs, regs);                         /* Maus-Treiber aufrufen */

   MouMovePtr (moucol, mourow);

   return; 
}

/***********************************************************************
*  Funktion         : M o u S e t S p e e d                            *
**--------------------------------------------------------------------**
*  Aufgabe          : Legt das Verh刲tnis zwischen der L刵ge einer     *
*                     Mausbewegung und der daraus resultierenden Be-   *
*                     wegung des Maus-Cursors fest.                    *
*  Eingabe-Parameter: - XSPEED = Geschwindigkeit horizontal            *
*                     - YSPEED = Geschwindigkeit vertikal              *
*  Return-Wert      : keiner                                           *
*  Info             : - Beide Angaben beziehen sich auf die Einheit    *
*                       Mickey / 8 Pixel.                              *
***********************************************************************/

void MouSetSpeed( int xspeed, int yspeed )
{
 union REGS regs;                /* Prozessorregs f乺 Interruptaufruf */

 regs.x.ax = 0x000f;           /* Fktnr. "Set mickeys to pixel ratio" */
 regs.x.cx = xspeed;
 regs.x.dx = yspeed;
 MOUINT(regs, regs);                         /* Maus-Treiber aufrufen */
}

/***********************************************************************
*  Funktion         : M o u M o v e P t r                              *
**--------------------------------------------------------------------**
*  Aufgabe          : Bewegt den Maus-Cursor an eine bestimmte Bild-   *
*                     schirmposition.                                  *
*  Eingabe-Parameter: - COL = neue Bildschirmspalte                    *
*                     - ROW = neue Bildschirmzeile                     *
*  Return-Wert      : keiner                                           *
*  Info             : - Beide Angaben beziehen sich auf den Textbild-  *
*                       schirm und nicht auf den virtuellen Grafik-    *
*                       bildschirm des Maustreibers                    *
***********************************************************************/

static void MouMovePtr( BYTE col, BYTE row )
{
 union REGS regs;                /* Prozessorregs f乺 Interruptaufruf */


 regs.x.ax = 0x0004;           /* Fktnr. "Set mouse pointer position" */
 regs.x.cx = COLTOX( moucol = col );  /* Koordinaten umrechnen und in */
 regs.x.dx = ROWTOY( mourow = row );  /* globalen Variablen speichern */
 MOUINT(regs, regs);                         /* Maus-Treiber aufrufen */


 old_win_col = moucol;
 old_win_row = mourow;
}


/***********************************************************************
*  Funktion         : M o u S e t D e f a u l t P t r                  *
**--------------------------------------------------------------------**
*  Aufgabe          : Definiert das Erscheinungsbild des Maus-Cursors  *
*                     f乺 Bildschirmbereiche, die nicht mit Hilfe von  *
*                     MouDefBereich definiert wurden.                  *
*  Eingabe-Parameter: STANDARD = Bit-Maske f乺 den Standard-Maus-Cursor*
*  Return-Wert      : keiner                                           *
***********************************************************************/

void MouSetDefaultPtr( PTRVIEW standard )
{
 stdptr = standard;              /* Bit-Maske in globaler Var. merken */

 /*-- befindet sich die Maus im Augenblick in keinem Bereich, wird ---*/
 /*-- direkt auf das neue Erscheinungsbild umgeschaltet            ---*/


  MouDefinePtr( standard );                                   /* Nein */
}

/***********************************************************************
*  Funktion         : M o u E n d                                      *
**--------------------------------------------------------------------**
*  Aufgabe          : Beendet die Arbeit mit den Funktionen des Mousec-*
*                     Moduls.                                          *
*  Eingabe-Parameter: keine                                            *
*  Return-Wert      : keiner                                           *
*  Info             : Die Funktion wird bei der Beendigung eines Pro-  *
*                     gramms automatisch aufgerufen, sofern zuvor      *
*                     MouInstall aufgerufen wurde.                     *
***********************************************************************/

void MouEnd( void )
{
 union REGS regs;                /* Prozessorregs f乺 Interruptaufruf */

 MouHideMouse();              /* Maus-Cursor vom Bildschirm entfernen */
 regs.x.ax = 0;                            /* Reset des Maus-Treibers */
 MOUINT(regs, regs);                         /* Maus-Treiber aufrufen */

}

/***********************************************************************
*  Funktion         : M o u I n i t                                    *
**--------------------------------------------------------------------**
*  Aufgabe          : Leitet die Arbeit mit dem Mousec-Modul ein und   *
*                     initialisiert die verschiedenen Variablen        *
*  Eingabe-Parameter: Spalten, = die Aufl攕ung des Textbildschirms     *
*                     Zeilen                                           *
*  Return-Wert      : TRUE, wenn eine Maus installiert ist,sonst FALSE *
*  Info             : Diese Funktion mu