mousec.c

功能强大的文本编辑器

int mouse_event (void)
{
   return (event_count != 0);
}  /* mouse_event */


int mouse_event_handler_c (int repeat)
{
static int old_col, phase;
static struct dostime_t time_start, time_act;
static int msec10_start, msec10_act;
#define TIME_DELAY 20    /* LSB = 10 msec */

int  new_col, delta_line, key, ii;
long new_line, new_index;
#define SLOW_DOWN  1    /* 1: max. mouse speed */
                        /* 2: reduced "    "   */

static int left_button_tab [] =
           {
              0x00,     /* 0: normal mode */
              0x0d,     /* 1: history window */
              0x0d,     /* 2: filename window */
              0x1b,     /* 3: get_line_2_string */
               'E',     /* 4: hex_view */
              0x09,     /* 5: hex_edit */
           };


#if (TEST_MOUSE)
static int  row, column;
static char text [100];
#endif


   if (event_count > 0)
      event_count--;

   key = 0;  /* default for standard text mode */

/* -----------------------------------------------------------------------*/

/* fallunterscheidung */
   if (disp_window_active)
   {
   /* simulate keys cursor up/down, <enter> + <esc> */

      key = KEY_DO_NOTHING;    /* default for display window */

      if (MouIsRightPress())
         key = 0x03;   /* ^C   */

      if (MouIsLeftPress())
      {
         key = left_button_tab [disp_window_active];
      }
   
      if ((disp_window_active <= 2) ||     /* history/filename window */
          (disp_window_active >= 4))       /* hex view/edit  */
      {
         if (mourow > old_win_row)
         {
            delta_line = mourow - old_win_row;
            for (ii = 1 ; ii < (delta_line/SLOW_DOWN) ; ii++)
            {
               set_key_fifo (KEY_DOWN);
            }
            key = KEY_DOWN;
         }
   
         if (mourow < old_win_row)
         {
            delta_line = old_win_row - mourow;
            for (ii = 1 ; ii < (delta_line/SLOW_DOWN) ; ii++)
            {
               set_key_fifo (KEY_UP);
            }
            key = KEY_UP;
         }
      }

      if (disp_window_active >= 3)    /* get_status_line_2_... */
      {                               /* hex editor            */
         if (moucol > old_win_col)
         {
            delta_line = moucol - old_win_col;
            for (ii = 1 ; ii < (delta_line/SLOW_DOWN) ; ii++)
            {
               set_key_fifo (KEY_RIGHT);
            }
            key = KEY_RIGHT;
         }
   
         if (moucol < old_win_col)
         {
            delta_line = old_win_col - moucol;
            for (ii = 1 ; ii < (delta_line/SLOW_DOWN) ; ii++)
            {
               set_key_fifo (KEY_LEFT);
            }
            key = KEY_LEFT;
         }
      }

      MouMovePtr (center_col, center_row);
      old_win_col = moucol;
      old_win_row = mourow;

   /* @@ prevent multiple reads of mouse buttons !! */
      mouevent &= ~(EV_LEFT_PRESS | EV_RIGHT_PRESS);

      return (key);
   }

/* -----------------------------------------------------------------------*/

/* control repetition behaviour (delay time at begin) */
   if (!repeat)
   {
      phase = 0;        /* no repetition at all */
   }
   else
   {
      if (phase == 0)
      {
         _dos_gettime (&time_start);
         msec10_start = (int) time_start.second * 100 +
                        (int) time_start.hsecond;
         phase = 1;     /* begin of time delay */
      }

      if (phase == 1)
      {
         _dos_gettime(&time_act);
         msec10_act = (int) time_act.second * 100 +
                      (int) time_act.hsecond;

      /* before completion of time delay: abort repetition */
         if ((((msec10_act - msec10_start) + 6000) % 6000) >= TIME_DELAY)
            phase = 2;  /* time delay completed */
      }
   }

/* incompleted time delay: abort repetition */
   if (phase == 1)
      return 0;

/* -----------------------------------------------------------------------*/

/* start handling */
   if (MouIsLeftPress())
   {
   /* set cursor to mouse position */
      check_dirty_cursor ();

   /* set row */
                /* diese klammern muessen sein !! */
                /*          v        v            */
      delta_line = mourow - (fc->lrow);
      if (delta_line)
      {
         new_line = fc->line_index + (long) delta_line;
         new_line = max (0L, min (fc->line_anz, new_line));
         new_index= line_to_index (fc->buff_0, 0L,
                                   fc->byte_anz, new_line);
         if (new_index < 0L)       /* behind EOF */
            new_index = fc->byte_anz;  /* set to EOF */
         perform_move (new_index);
      }

   /* set column */
      new_col = moucol + fc->left_col;
      new_col = max (0, new_col);
      new_index = act_index (fc->buff_0, fc->lin_left,
                             fc->byte_anz, new_col);
      perform_move (new_index);
      fc->column = new_col;

   /* scroll screen up/down */
      if (delta_line == 0)
      {
         if (mourow == (BYTE) MIN_ROW)
            perform_key_up (1);

         if (mourow == (BYTE) MAX_ROW)
            perform_key_down (1);
   
         update_entire_window (fc->top_left);
         perform_update (fc->buff_0, fc->byte_anz, fc->left_col);

      /* set cursor */
         if (get_video_active (0))
            set_cursor_to (fc->lrow, REL_COLUMN);
      }


   /* scroll screen left/right */
      if ((BYTE) old_col == moucol)
      {
         if (moucol >= (BYTE) (COLUMNS-1))
            fc->left_col++;
   
         if (moucol <= 0)
            fc->left_col--;
   
         fc->left_col = max (0, fc->left_col);
      }
      old_col = moucol;


   /* show screen, set cursor */
      refresh_1_window ();
      if (get_video_active (0))
         set_cursor_to (fc->lrow, REL_COLUMN);
   }  /* if left button pressed */


#if (TEST_MOUSE)
   /* status line 1 missbrauchen */
      get_cursor_pos (&row, &column);
      sprintf (text, " <%3d,%3d> <%2d,%2d> ",
                       x_sav, y_sav, moucol, mourow);
      set_cursor_to (BOT_ROW, 0);
      out_string (text);
      set_cursor_to (row, column);
#endif


/* set flag for check_dirty_cursor() in mbedit.c */
   set_mouse_moved ();

   return key;
}  /* mouse_event_handler_c */


#pragma check_stack              /* alten Zustand im Hinblick auf das */
#pragma check_stack              /* Stack-Checking wieder herstellen  */



/***********************************************************************
*  Funktion         : M o u I S e t E v e n t H a n d l e r            *
**--------------------------------------------------------------------**
*  Aufgabe          : Installiert einen Event-Handler, der beim Ein-   *
*                     tritt eines bestimmten Maus-Ereignisses vom      *
*                     Maus-Treiber aufgerufen wird.                    *
*  Eingabe-Parameter: EVENT = Bit-Maske, die das Ereignis spezifi-     *
*                             ziert, bei dessen Eintritt der Event-    *
*                             Handler aufgerufen werden soll.          *
*                     PTR   = Pointer auf den Maus-Handler             *
*  Return-Wert      : keiner                                           *
*  Info             : - EVENT kann durch Oder-Verkn乸fung der ver-     *
*                       schiedenen Konstanten wie z.B. EV_MOU_MOVE     *
*                       oder EV_LEFT_PRESS aus der Datei gebildet      *
*                       werden                                         *
***********************************************************************/

static void MouISetEventHandler( unsigned event, MOUHAPTR ptr )
{
 union REGS regs;                /* Prozessorregs f乺 Interruptaufruf */
 struct SREGS sregs;           /* Segmentregister f乺 Interruptaufruf */

 regs.x.ax = 0x000C;                /* Fktnr. f乺 "Set Mouse Handler" */
 regs.x.cx = event;                              /* Event-Maske laden */
 regs.x.dx = FP_OFF( ptr );             /* Offsetadresse des Handlers */
 sregs.es  = FP_SEG( ptr );            /* Segmentadresse des Handlers */
 MOUINTX( regs, regs, sregs );               /* Maus-Treiber aufrufen */
}

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

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

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