utils.c

该内容是《》一书的光盘内容

{
int  rc = OK;
register WINDOW *win;   

   win = window;
   entab_linebuff( );
   if (un_copy_line( win->ll, win, TRUE ) == ERROR)
      return( ERROR );
   if (win->cline == win->top_line + win->ruler) {
      if (win->ll->next != NULL) {
         ++win->rline;
         win->bin_offset += win->ll->len;
         win->ll = win->ll->next;
         win->file_info->dirty = LOCAL;
      } else
         rc = ERROR;
   } else {
      --win->cline;
      win->file_info->dirty = LOCAL;
   }
   sync( win );
   return( rc );
}



int  scroll_up( WINDOW *window )
{
int  rc = OK;
register WINDOW *win;   

   win = window;
   entab_linebuff( );
   if (un_copy_line( win->ll, win, TRUE ) == ERROR)
      return( ERROR );
   if (win->rline > 1) {
      if (win->rline == (win->cline - (win->top_line + win->ruler - 1))) {
         if (!mode.sync)
            update_line( win );
         win->ll = win->ll->prev;
         win->bin_offset -= win->ll->len;
         --win->rline;
         --win->cline;
         if (!mode.sync)
            show_curl_line( win );
      } else {
         if (win->cline == win->bottom_line) {
            --win->rline;
            win->ll = win->ll->prev;
            win->bin_offset -= win->ll->len;
            win->file_info->dirty = LOCAL;
         } else {
            ++win->cline;
            win->file_info->dirty = LOCAL;
         }
      }
   } else
     rc = ERROR;
   sync( win );
   return( rc );
}



int  pan_up( WINDOW *window )
{
int  rc = OK;
register WINDOW *win;   

   win = window;
   entab_linebuff( );
   if (un_copy_line( win->ll, win, TRUE ) == ERROR)
      return( ERROR );

   
   if (win->rline != (win->cline+1 - (win->top_line + win->ruler))) {
      if (win->rline > 1) {
         --win->rline;
         win->ll = win->ll->prev;
         win->bin_offset -= win->ll->len;
         win->file_info->dirty = LOCAL;
      }
   } else
      rc = ERROR;
   sync( win );
   return( rc );
}



int  pan_down( WINDOW *window )
{
int  rc = OK;
register WINDOW *win;   

   win = window;
   entab_linebuff( );
   if (un_copy_line( win->ll, win, TRUE ) == ERROR)
      return( ERROR );
   if (win->ll->len != EOF) {
      ++win->rline;
      win->bin_offset += win->ll->len;
      win->ll = win->ll->next;
      win->file_info->dirty = LOCAL;
   } else
      rc = ERROR;
   sync( win );
   return( rc );
}



void show_window_header( WINDOW *window )
{
char status_line[MAX_COLS+2];   
register WINDOW *win;           
int  len;

   win = window;
   len = win->vertical ? win->end_col + 1 - win->start_col : win->end_col;

   assert( len >= 0 );
   assert( len <= MAX_COLS );

   memset( status_line, ' ', len );
   status_line[len] = '\0';
   s_output( status_line, win->top_line-1, win->start_col,g_display.head_color);
   show_window_number_letter( win );
   show_window_fname( win );
   show_crlf_mode( win );
   show_size( win );
   show_line_col( win );
}


void show_window_number_letter( WINDOW *window )
{
int  col;
char temp[10];
register WINDOW *win;   

   win = window;
   col = win->start_col;
   s_output( "   ", win->top_line-1, col, g_display.head_color );
   itoa( win->file_info->file_no, temp, 10 );
   s_output( temp, win->top_line-1, strlen( temp ) > 1 ? col : col+1,
             g_display.head_color );
   c_output( win->letter, col+2, win->top_line-1, g_display.head_color );
}



void show_window_fname( WINDOW *window )
{
char status_line[MAX_COLS+2];   
register int  fattr;
char *p;
register WINDOW *win;          
int  col;
int  len;

   win = window;
   col = win->start_col;
   len = win->vertical ? 11 : FNAME_LENGTH;

   assert( len >= 0 );
   assert( len <= MAX_COLS );

   memset( status_line, ' ', len );
   status_line[len] = '\0';
   s_output( status_line, win->top_line-1, col+5, g_display.head_color );

   assert( strlen( win->file_info->file_name ) < MAX_COLS );

   strcpy( status_line, win->file_info->file_name );
   p = status_line;
   if (win->vertical) {
      len = strlen( status_line );
      for (p=status_line+len;*(p-1) != ':' && *(p-1) != '\\' && p>status_line;)
         --p;
   } else {
      status_line[FNAME_LENGTH] = '\0';
      p = status_line;
   }
   s_output( p, win->top_line-1, col+5, g_display.head_color );
   if (!win->vertical) {
      fattr = win->file_info->file_attrib;
      p = status_line;
      *p++ = (char)(fattr & ARCHIVE   ? 'A' : '-');
      *p++ = (char)(fattr & SYSTEM    ? 'S' : '-');
      *p++ = (char)(fattr & HIDDEN    ? 'H' : '-');
      *p++ = (char)(fattr & READ_ONLY ? 'R' : '-');
      *p   = '\0';
      s_output( status_line, win->top_line-1, col+51, g_display.head_color );
   }
}



void show_crlf_mode( WINDOW *window )
{
char status_line[MAX_COLS+2];   

   if (!window->vertical) {
      switch (window->file_info->crlf) {
         case LF :
            strcpy( status_line, "lf  " );
            break;
         case CRLF :
            strcpy( status_line, "crlf" );
            break;
         case BINARY :
            strcpy( status_line, "BIN " );
            break;
         default :
            assert( FALSE );
      }
      s_output( status_line, window->top_line-1, window->start_col+56,
                g_display.head_color );
   }
}



void show_size( WINDOW *window )
{
char csize[20];

   if (!window->vertical  &&  window->file_info->crlf != BINARY) {
      s_output( "       ", window->top_line-1, 61, g_display.head_color );
      ltoa( window->file_info->length, csize, 10 );
      s_output( csize, window->top_line-1, 61, g_display.head_color );
   }
}



int  quit( WINDOW *window )
{
int  prompt_line;
char line_buff[(MAX_COLS+2)*2]; 
register file_infos *file;
WINDOW *wp;
int  count = 0;
int  rc = OK;

   entab_linebuff( );
   if (un_copy_line( window->ll, window, TRUE ) == ERROR)
      return( ERROR );
   prompt_line = window->bottom_line;
   file = window->file_info;
   for (wp=g_status.window_list; wp != NULL; wp=wp->next) {
      if (wp->file_info == file && wp->visible)
         ++count;
   }
   if (file->modified && count == 1) {
      save_screen_line( 0, prompt_line, line_buff );
      /*
       * abandon changes (y/n)
       */
      set_prompt( utils12, prompt_line );
      if (get_yn( ) != A_YES)
         rc = ERROR;
      restore_screen_line( 0, prompt_line, line_buff );
   }

   
   if (rc == OK)
      finish( window );
   return( OK );
}


int  move_up( WINDOW *window )
{
int  rc = OK;
register WINDOW *win;   
int  at_top = FALSE;    

   win = window;
   entab_linebuff( );
   if (un_copy_line( win->ll, win, TRUE ) == ERROR)
      return( ERROR );

   
   if (win->rline > 1) {
      if (win->cline == win->top_line + win->ruler) {
         win->file_info->dirty = LOCAL;
         at_top = TRUE;
      }
      if (!at_top)
         update_line( win );
      --win->rline;             
      win->ll = win->ll->prev;
      win->bin_offset -= win->ll->len;
      if (!at_top) {
         --win->cline;          
         show_curl_line( win );
      }
   } else
      rc = ERROR;
   sync( win );
   return( rc );
}



int  move_down( WINDOW *window )
{
int  rc;

   rc = prepare_move_down( window );
   sync( window );
   return( rc );
}


int  prepare_move_down( WINDOW *window )
{
int  rc = OK;
register WINDOW *win;   
int  at_bottom = FALSE; 

   win = window;
   entab_linebuff( );
   if (un_copy_line( win->ll, win, TRUE ) == ERROR)
      return( ERROR );
   if (win->cline == win->bottom_line) {
      win->file_info->dirty = LOCAL;
      at_bottom = TRUE;
   }
   if (!at_bottom)
      update_line( win );
   if (win->ll->len != EOF) {
      win->bin_offset += win->ll->len;
      ++win->rline;             
      win->ll = win->ll->next;
      if (!at_bottom) {
         ++win->cline;          
         show_curl_line( win );
      }
   } else if (win->cline > win->top_line + win->ruler) {
      --win->cline;
      win->file_info->dirty = LOCAL;
      rc = ERROR;
   } else
      rc = ERROR;
   return( rc );
}



int  move_left( WINDOW *window )
{
int  new_ruler = FALSE;

   if (window->ccol > window->start_col) {
      show_ruler_char( window );
      --window->ccol;
      --window->rcol;
   } else if (window->ccol == window->start_col && window->rcol > 0) {
      --window->rcol;
      --window->bcol;
      window->file_info->dirty = LOCAL;
      new_ruler = TRUE;
   }
   sync( window );
   if (new_ruler) {
      make_ruler( window );
      show_ruler( window );
   }
   return( OK );
}



int  move_right( WINDOW *window )
{
int  new_ruler = FALSE;

   if (window->rcol < g_display.line_length - 1) {
      if (window->ccol < window->end_col) {
         show_ruler_char( window );
         ++window->ccol;
         ++window->rcol;
      } else if (window->ccol == window->end_col) {
         ++window->rcol;
         ++window->bcol;
         window->file_info->dirty = LOCAL;
         new_ruler = TRUE;
      }
   }
   sync( window );
   if (new_ruler) {
      make_ruler( window );
      show_ruler( window );
   }
   return( OK );
}



int  pan_left( WINDOW *window )
{

   if (window->bcol > 0 ) {
      --window->bcol;
      --window->rcol;
      window->file_info->dirty = LOCAL;
      make_ruler( window );
      show_ruler( window );
   }
   sync( window );
   return( OK );
}



int  pan_right( WINDOW *window )
{
   if (window->rcol < g_display.line_length - 1) {

      ++window->rcol;
      ++window->bcol;
      window->file_info->dirty = LOCAL;
      make_ruler( window );
      show_ruler( window );
   }
   sync( window );
   return( OK );
}



int  word_left( WINDOW *window )
{
text_ptr p;             
int  len;               
int  rc;
register int rcol;
long rline;
line_list_ptr ll;
WINDOW w;

   entab_linebuff( );
   if (un_copy_line( window->ll, window, TRUE ) == ERROR)
      return( ERROR );
   rc = OK;
   dup_window_info( &w, window );
   rline = window->rline;
   rcol  = window->rcol;
   ll = window->ll;
   if (ll->len != EOF) {
      p = ll->line;
      len = ll->len;

      if (p != NULL  &&  rcol > 0  &&  rcol >= len  &&
                                      !myiswhitespc( *(p + len - 1) )) {
         rcol = len - 1;
         p += rcol;
         for (; rcol >= 0 && !myiswhitespc( *p ); rcol--, p--);
         ++rcol;
         check_virtual_col( window, rcol, rcol );
         make_ruler( window );
         show_ruler( window );
      } else {
         rcol = rcol >= len ? len-1 : rcol;
         if (rcol >= 0)
            p += rcol;
         if (p != NULL  &&  rcol > 0  &&  !myiswhitespc( *p )  &&
                                          !myiswhitespc( *(p-1) )) {
            for (; rcol >= 0 && !myiswhitespc( *p ); rcol--, p--);
            ++rcol;
            check_virtual_col( window, rcol, rcol );
            make_ruler( window );
            show_ruler( window );
         } else {

          
            if (p != NULL)
               for (; rcol >= 0 && !myiswhitespc( *p ); rcol--, p--);

           
            if (rcol < 0) {
               if (ll->prev != NULL) {
                  --rline;
                  ll = ll->prev;
                  p = ll->line;
                  rcol = ll->len - 1;
                  if (rcol >= 0)
                     p += rcol;
               } else
                  rc = ERROR;
            }

            
            while (rc == OK  &&  (p == NULL  ||  (p != NULL  &&
                                                  myiswhitespc( *p )))) {
               for (; rcol >= 0 && myiswhitespc( *p ); rcol--, p--);
               if (rcol < 0) {
                  if (ll->prev != NULL) {
                     --rline;
                     ll = ll->prev;
                     p = ll->line;
                     rcol = ll->len - 1;
                     if (rcol >= 0)
                        p += rcol;
                  } else
                     rc = ERROR;
               } else
                  break;
            }

         
            if (rc == OK  &&  p != NULL) {
               for (; rcol >= 0 && !myiswhitespc( *p ); rcol--, p--);
               bin_offset_adjust( window, rline );
               find_adjust( window, ll, rline, rcol+1 );
               if (rline != w.rline && !window->file_info->dirty) {
                  update_line( &w );
                  show_curl_line( window );
               }
               make_ruler( window );
               show_ruler( window );
            } else
               rc = ERROR;
         }
      }
   } else
      rc = ERROR;

   sync( window );
   return( rc );
}



int  word_right( WINDOW *window )
{
int  len;               
text_ptr p;             
int  rc;
WINDOW w;
register int rcol;
line_list_ptr ll;
long rline;

   entab_linebuff( );
   if (un_copy_line( window->ll, window, TRUE ) == ERROR)
      return( ERROR );
   rc = OK;
   dup_window_info( &w, window );
   rline = window->rline;
   rcol  = window->rcol;
   ll = window->ll;
   if (ll->len != EOF) {