perform.c

功能强大的文本编辑器

   return byte_num;
}  /* perform_key_right */

/* -FF-  */

int perform_key_up (byte update_cursor)
{
long new_index;
int llen, delta;

   if (fc->line_index > 0)
   {
   /* pointer auf zeile darueber */
      llen = line_length (fc->buff_0, (fc->lin_left - 1 /* - (EOLN_LEN_2) */),
                          fc->byte_anz, 1);
      fc->lin_left -= llen;

      new_index = act_index (fc->buff_0, fc->lin_left, fc->byte_anz, fc->column);
      delta = (int)(fc->byte_index - new_index);

      fc->byte_index -= delta;
      fc->buffer     -= delta;
   
      fc->line_index--;
   
      if (fc->lrow > MIN_ROW)
      {
         fc->arow--;
         if ((update_cursor) && (get_video_active (0)))
            set_cursor_to (fc->lrow, REL_COLUMN);
      }
      else  /* scroll down */
      {
         fc->top_left -= llen;
         update_entire_window (fc->top_left);
      }

      return 1;  /* we have moved */
   }
   else
   {
      return 0;  /* we didn't */
   }
}  /* perform_key_up */

/* -FF-  */

int perform_key_down (byte update_cursor)
{
long new_index;
int llen, delta;

   if ((fc->line_index) < fc->line_anz)
   {
      llen = line_length (fc->buff_0, fc->lin_left  , fc->byte_anz, 1);

      fc->lin_left += llen;

      new_index = act_index (fc->buff_0, fc->lin_left, fc->byte_anz, fc->column);
      delta = (int)(new_index - fc->byte_index);

      fc->byte_index += delta;
      fc->buffer     += delta;

      fc->line_index++;
         
      if (fc->lrow < MAX_ROW)
      {
         fc->arow++;
         if ((update_cursor) && (get_video_active (0)))
            set_cursor_to (fc->lrow, REL_COLUMN);
      }
      else  /* scroll up */
      {
         llen = line_length (fc->buff_0, fc->top_left, fc->byte_anz, 1);
         fc->top_left += llen; 
         update_entire_window (fc->top_left);
      }

      return 1;  /* we have moved */
   }
   else
   {
      return 0;  /* we didn't */
   }
}  /* perform_key_down */

/* -FF-  */

void perform_begin_of_line (byte update_cursor)
{
int delta;

   delta = (int) (fc->byte_index - fc->lin_left);

   if ((fc->byte_index - delta) >= 0)
   {
      fc->byte_index -= delta;  /* pointer auf anfang dieser zeile */
      fc->buffer     -= delta;
   }

   if (fc->column > 0)
   {
      fc->column = 0;
      if ((update_cursor) && (get_video_active (0)))
         set_cursor_to (fc->lrow, REL_COLUMN);
   }

   return;
}  /* perform_begin_of_line */


void perform_end_of_line (byte update_cursor)
{
int llen, delta;

   llen = line_length (fc->buff_0, fc->lin_left  , fc->byte_anz, 0);

   delta = llen - (int)(fc->byte_index - fc->lin_left);

   if ((fc->byte_index + delta) <= fc->byte_anz)
   {
      fc->byte_index += delta;     /* pointer auf ende dieser zeile */
      fc->buffer     += delta;

      fc->column = line_columns (fc->buff_0, fc->byte_index, fc->byte_anz);
      if ((update_cursor) && (get_video_active (0)))
         set_cursor_to (fc->lrow, REL_COLUMN);
   }

   return;
}  /* perform_end_of_line */

/* -FF-  */

int  perform_page_up (void)
{
int ii;

#if CURSOR_STABIL
int start_row, move_flag;

/* cursor auf obere zeile */
   start_row = fc->lrow;
   for (ii = MIN_ROW ; ii < start_row ; ii++)
   {
      perform_key_up (0);
   }
#endif

/* bildschirm scrollen */
   for (ii = MIN_ROW ; ii <= MAX_ROW ; ii++)
   {
      move_flag = perform_key_up (0);
      if (!move_flag) return 0;                   /* ready ! */
   }

#if CURSOR_STABIL
/* ggf. cursor zurueck auf alte zeile */
   for (ii = MIN_ROW ; ii < start_row ; ii++)
   {
      perform_key_down (0);
   }
#endif

   update_entire_window (fc->top_left);

   return 1;
}  /* perform_page_up */


int  perform_page_down (void)
{
int ii;

#if CURSOR_STABIL
int start_row, move_flag;

/* cursor auf untere zeile */
   start_row = fc->lrow;
   for (ii = start_row ; ii < MAX_ROW ; ii++)
   {
      perform_key_down (0);
   }
#endif

/* bildschirm scrollen */
   for (ii = MIN_ROW ; ii <= MAX_ROW ; ii++)
   {
      move_flag = perform_key_down (0);
      if (!move_flag) return 0;                   /* ready ! */
   }

#if CURSOR_STABIL
/* ggf. cursor zurueck auf alte zeile */
   for (ii = start_row ; ii < MAX_ROW ; ii++)
   {
      perform_key_up (0);
   }
#endif

   update_entire_window (fc->top_left);

   return 1;
}  /* perform_page_down */

/* -FF-  */

void view_or_update (void)
{
   if ((fc->lrow <= MIN_ROW) || (fc->lrow >= MAX_ROW))
      perform_view ();
   else
      update_entire_window (fc->top_left);

   return;
}  /* view_or_update */

/* -FF-  */

void perform_scroll_screen (int delta)
{
int ii, count;
int start_row, move_flag;
long save_byte_index;
char FA_HU *save_buffer;

   count = 0;
   start_row = fc->lrow;
   save_byte_index = fc->byte_index;
   save_buffer     = fc->buffer;

/* fallunterscheidung */
   if (delta < 0)
   {                    /* analog page up */
   /* cursor auf obere zeile */
      for (ii = MIN_ROW ; ii < start_row ; ii++)
      {
         perform_key_up (0);    /* geht immer */
         count++;
      }
   
   /* bildschirm scrollen */
      for (ii = 0 ; ii < -delta ; ii++)
      {
         move_flag = perform_key_up (0);
         if (move_flag)
            count++;
         else
            break;
      }
   
   /* cursor zurueck auf alte zeile */
      for (ii = 0 ; ii < count ; ii++)
      {
         perform_key_down (0);
      }
   }
   else
   {                    /* analog page down */
   /* cursor auf untere zeile */
      for (ii = start_row ; ii < MAX_ROW ; ii++)
      {
         move_flag = perform_key_down (0);   /* geht nur, wenn file mind. */
         if (move_flag)                      /* soviel zeilen wie screen  */
            count++;
         else
            break;
      }
   
   /* bildschirm scrollen */
      for (ii = 0 ; ii < delta ; ii++)
      {
         move_flag = perform_key_down (0);
         if (move_flag)
            count++;
         else
            break;
      }
   
   /* cursor zurueck auf alte zeile */
      for (ii = 0 ; ii < count ; ii++)
      {
         perform_key_up (0);
      }
   }

   fc->byte_index = save_byte_index;
   fc->buffer     = save_buffer;

   return;
}  /* perform_scroll_screen */

/* -FF-  */

void perform_view (void)
{
int delta;
int start_row;
int rel_viewrow;


#if WINDOW_COMMAND
/* ggf. cursor ins bild schieben */
   window_adjust ();
#endif


/* abstand aktuelle zeile / soll-zeile */
   start_row = fc->lrow;
   rel_viewrow = set.viewrow
                 * (w_bot[act_window] - w_top[act_window] - STATUS_LINES)
          / max(1, (w_bot[         0] - w_top[         0] - STATUS_LINES));
   delta = start_row - MIN_ROW - rel_viewrow;


/* shift image on screen */
   perform_scroll_screen (delta);


/* reset optimized output */
   clear_text_buffers ();

/* und endlich anzeigen */
   refresh_whole_screen ();

   return;
}  /* perform_view */

/* -FF-  */

void view_unconditionally (void)
{

/* display window, even if suppressed */
   if (!get_video_active (0))
   {
      set.display |= 0x02;
      perform_view ();
      set.display &= ~0x02;
   }

   return;
}  /* view_unconditionally */

/* -FF-  */

void perform_delete_left_char (void)
{
long last_la;
int  old_bytes, old_eoln;

/* save last values */
   last_la = fc->line_anz;

/* 1 or 2 bytes ? */
    old_bytes = 1;

    if (EOLN_LEN_2)
    {
       if ((perform_test_eol (fc->buffer, -2)) &&
           (fc->byte_index > 1))
          old_bytes = 2;
    }

   if (fc->byte_index > (old_bytes-1))
   {
      perform_key_left (1, 1);
   
      if (mode_flag == 2)
      {
      /* alten inhalt restaurieren */
         if (save_x.index > 0)
         {
            old_eoln = (*fc->buffer == (char) EOLN);

            save_x.index--;
            *fc->buffer = save_x.buffer [save_x.index];

         /* war vorher <cr><lf> ? */
            if (old_bytes == 2)
            {
               fc->byte_index++;
               fc->buffer++;
               perform_delete_right_char ();
               fc->byte_index--;
               fc->buffer--;
            }
            else
            {
               if (old_eoln)
                  fc->line_anz--;
            }

         /* war einfuegung am zeilen-ende / file-ende ? */
            if (*fc->buffer == '\0')
            {
               perform_delete_right_char ();
            }

         /* display new memory content */
            if (fc->line_anz != last_la)
               update_rest_of_window (fc->lin_left, fc->lrow);
            else
               update_this_line (fc->lin_left, fc->lrow);
         }
      }
      else
      {
         perform_delete_right_char ();
      }
   }

   return;
}  /* delete_left_char */


void perform_delete_right_char (void)
{
long last_la;
int  old_bytes, nl_flag;

/* save last values */
   last_la = fc->line_anz;

/* 1 or 2 bytes ? */
   old_bytes = 1;
   nl_flag = 0;

   if ((perform_test_eol (fc->buffer, 0)) &&
       (fc->byte_index < (fc->byte_anz-(EOLN_LEN_2))))
      nl_flag = 1;

   if (EOLN_LEN_2)
   {
      if (nl_flag)
         old_bytes = 2;
   }

   if (perform_test_eol1 (fc->buffer, 0))
      nl_flag = 1;

   if (nl_flag)                 /* old <new line> */
      fc->line_anz--;

   if (fc->byte_index < fc->byte_anz - (old_bytes-1))
   {
   /* delete 1/2 bytes (shift to left the rest of the memory) */
      memcpy_rev (fc->buffer, (fc->buffer + old_bytes),
                 (fc->byte_anz - fc->byte_index));
      fc->byte_anz -= old_bytes;
      check_tag_index (fc->byte_index, (long)(-old_bytes));

   /* display new memory content */
      if (fc->line_anz != last_la)
         update_rest_of_window (fc->lin_left, fc->lrow);
      else
         update_this_line (fc->lin_left, fc->lrow);
   }

   return;
}  /* delete_right_char */


void perform_delete_start_of_line (int save_flag)
{
int delta;

   delta = (int) (fc->byte_index - fc->lin_left);
   if (delta > sizeof(save_u.buffer))
   {
      delta = sizeof(save_u.buffer);     /* sicher ist sicher */
      err_message (LINE_TOO_LONG);
   }

/* save old buffer before delete */
   if (save_flag)
   {
      save_u.anz   = delta;
      save_u.index = delta;
      save_u.command = 'X';
      memcpy (save_u.buffer, (fc->buffer - delta), delta);
   }

/* delete n bytes (shift to left the rest of the memory) */
   memcpy_rev ((fc->buffer - delta), fc->buffer,
               (fc->byte_anz - fc->byte_index + 1));
   fc->byte_anz   -= delta;
   fc->buffer     -= delta;
   fc->byte_index -= delta;                          /* bugfix:         */
   check_tag_index (fc->byte_index, (long) -delta);  /* lines exchanged */

/* cursor to begin of line */
   fc->column = act_column (fc->buff_0, fc->byte_index);    /* bugfix */


/* display new memory content */
   update_this_line (fc->lin_left, fc->lrow);

   return;
}  /* perform_delete_start_of_line */


void perform_delete_rest_of_line (void)
{
int llen, aind, delta;

   llen = line_length (fc->buff_0, fc->lin_left  , fc->byte_anz, 0);

   aind = (int) (fc->byte_index - fc->lin_left);
   delta = max (0, (llen - aind));
   if (delta > sizeof(save_u.buffer))
   {
      delta = sizeof(save_u.buffer);     /* sicher ist sicher */
      err_message (LINE_TOO_LONG);
   }

/* save old buffer before delete */
   save_u.anz   = delta;
   save_u.index = 0;
   save_u.command = 'A';
   memcpy (save_u.buffer, fc->buffer, delta);

/* delete n bytes (shift to left the rest of the memory) */
   memcpy_rev (fc->buffer, (fc->buffer + delta), 
              (fc->byte_anz - fc->byte_index + 1 - delta));
   fc->byte_anz -= delta;
   check_tag_index (fc->byte_index, (long) -delta);

/* display new memory content */
   update_this_line (fc->lin_left, fc->lrow);

   return;
}  /* perform_delete_rest_of_line */


void perform_delete_whole_line (void)
{
int sav_ind;
int llen, delta;
long new_index;

   delta = (int) (fc->byte_index - fc->lin_left);
   sav_ind = delta;

   fc->byte_index -= delta;  /* pointer auf anfang dieser zeile */
   fc->buffer     -= delta;

/* laenge der zeile incl. <lf> */
   llen = line_length (fc->buff_0, fc->lin_left  , fc->byte_anz, 1);

   delta = llen;
   if (delta > sizeof(save_u.buffer))
   {
      delta = sizeof(save_u.buffer);     /* sicher ist sicher */
      err_message (LINE_TOO_LONG);
   }

/* save old buffer before delete */
   save_u.anz   = delta;
   save_u.index = sav_ind;
   save_u.command = 'Z';
   memcpy (save_u.buffer, fc->buffer, delta);

/* anzahl zeilen mitzaehlen (bugfix, nur wenn mit end of line: 14.06.94 @@) */