query.c

一个开源著名的TDE编辑器源代码

   /*
    * set the case sensitivity of history completion
    */
   sort.order_array = (mode.search_case == IGNORE) ?
                      sort_order.ignore : sort_order.match;

   /*
    * check if a dialog has already been paused.
    */
   if (dlg_active && g_status.macro_executing && g_status.macro_next > 1 &&
       g_status.macro_next-1 < g_status.current_macro->len &&
       getfunc( g_status.current_macro->key.keys[g_status.macro_next-1] )
                == Pause)
      paused = TRUE;

   /*
    * let user edit default string
    */
   scol = col;
   len  = strlen( answer );
   col += len;
   old_cp = cp = answer + len;

   for (stop = FALSE; stop == FALSE;) {
      if (displayed) {
         col += (int)(cp - old_cp);
         old_cp = cp;
         if (reset) {
            if (dlg_active)
               display_dialog( );
            else if (prompt_len >= 0)
               display_prompt( );
            disp = cp - (col - scol);
            dcol = scol;
            dlen = cols;
            reset = FALSE;
         }
         if (col < scol) {
            disp = cp;
            dcol = col = scol;
            dlen = cols;
         } else if (col > max_col) {
            disp = cp - cols + 1;
            col  = max_col;
            dcol = scol;
            dlen = cols;
         }
         if (dlen > 0) {
            if (dcol + dlen > max_col + 1)
               dlen = max_col + 1 - dcol;
            for (; dlen > 0 && *disp; --dlen)
               c_output( *disp++, dcol++, line, color );
            c_repeat( blank, dlen, dcol, line, normal );
            dlen = 0;
         }
         xygoto( col, line );

         if (dlg_proc) {
            if (len == 0) {
               if (!done_empty) {
                  dlg_proc( -dlg_id, answer );
                  done_empty = TRUE;
                  done_one   = FALSE;
               }
            } else {
               if (!done_one) {
                  dlg_proc( -dlg_id, answer );
                  done_one   = TRUE;
                  done_empty = FALSE;
               }
            }
         }
      }
      pos = (int)(cp - answer);

      if (local_macro == NULL) {
         if (g_status.macro_executing && !paused) {
            if (g_status.macro_next < g_status.current_macro->len) {
               c    = g_status.current_macro->key.keys[g_status.macro_next++];
               func = getfunc( c );
               if (func == Pause)
                  paused = TRUE;
            } else if (g_status.current_macro->len == 1) {
               c      = _FUNCTION;
               func   = Pause;
               paused = TRUE;
            } else {
               c    = RTURN;
               func = Rturn;
            }
         } else {
            if (!displayed) {
               displayed = TRUE;
               continue;
            }
            c = getkey( );
            /*
             * User may have redefined the Enter and ESC keys.  Make the Enter
             *  key perform a Rturn in this function.  Make the ESC key do an
             *  AbortCommand.
             * jmh 980809: test for F1/Help here as well.
             */
            func = (c == RTURN) ? Rturn        :
                   (c == ESC)   ? AbortCommand :
                   (c == _F1)   ? Help         :
                   getfunc( c );

            if (mode.record && !paused) {
               record_key( c, (dlg_active && _F1 <= c && c <= _F9)
                              ? PlayBack : func );
               if (func == Pause) {
                  paused = TRUE;
                  macro_pause( NULL );  /* dummy argument */
               }
            }
         }
         if (func == PlayBack && !(dlg_active && _F1 <= c && c <= _F9)) {
            local_macro = g_status.key_macro;
            if (local_macro->len == 1) {
               c = local_macro->key.key;
               local_macro = NULL;
            } else {
               next = 0;
               c    = local_macro->key.keys[next++];
            }
            func = getfunc( c );
         }
      } else {
         if (next < local_macro->len) {
            c = local_macro->key.keys[next++];
            func = getfunc( c );
         } else {
            local_macro = NULL;
            c = _FUNCTION;
            func = 0;
         }
      }

      if (dlg_active && _F1 <= c && c <= _F9)  {
         func = 0;
         i = (int)c - _F1;
         if (i < num_cbox) {
            i += first_cbox;
            if (check_box( i ))
               if (dlg_proc)
                  dlg_proc( i, NULL );
         }
      }

      switch (func) {
         case Help :
            if (show_help( ) == ERROR) {
               reset = TRUE;
               dlg_drawn = FALSE;
            }
            break;

         case ToggleSearchCase :
            toggle_search_case( NULL );      /* Note: dummy argument */
            sort.order_array = (mode.search_case == IGNORE) ?
                               sort_order.ignore : sort_order.match;
            break;

         case ToggleOverWrite :
            toggle_overwrite( NULL );        /* Note: dummy argument */
            break;

         case SetDirectory:
            set_path( g_status.current_window );
            break;

         case ToggleCWD: {
            char cwd[PATH_MAX];
            char buf[PATH_MAX];
            if (get_current_directory( cwd ) == ERROR)
               strcpy( cwd, "." );
            error( INFO, (dlg_active) ? g_display.end_line :
                         (line == 0) ? 1 : line - 1,
                   reduce_string( buf, cwd, g_display.ncols, MIDDLE ) );
            break;
         }

#if defined( __DJGPP__ ) || defined( __WIN32__ )
         case CopyToClipboard:
         case KopyToClipboard:
         case CutToClipboard:
            if (len)
               set_clipboard( answer, len + 1 );
            break;

         case PasteFromClipboard:
#endif
         case CopyWord   :
         case CopyString :
            if (g_status.current_window != NULL
#if defined( __DJGPP__ ) || defined( __WIN32__ )
                ||  func == PasteFromClipboard
#endif
               ) {
               if (first) {
                  old_cp = cp = answer;
                  *cp = '\0';
                  dlen = len;
                  len = 0;
                  pos = 0;
                  col = scol;
               }
               disp = cp;
               dcol = col;
#if defined( __DJGPP__ ) || defined( __WIN32__ )
               if (func == PasteFromClipboard)
                  i = copy_clipboard( cp, max - (mode.insert ? len : pos) );
               else
#endif
                  i = copy_word( g_status.current_window, cp,
                                 max - (mode.insert ? len : pos),
                                 func == CopyString );
               if (i > 0) {
                  if (mode.insert) {
                     DLEN( len - pos + i );
                     len += i;
                  } else {
                     DLEN( i );
                     if (i + pos > len)
                        len = i + pos;
                  }
                  answer[len] = '\0';
                  cp += i;
               }
            }
            break;

         case GotoMark1  :
         case GotoMark2  :
         case GotoMark3  :
            if (!dlg_tab)
               break;
            dlg_move = first_edit + func - GotoMark1 - dlg_id;
            if (dlg_move)
               goto done;
            break;

         case ScreenUp   :
         case ScreenDown :
            if (!dlg_tab)
               break;
            /*
             * finished (with this edit field)
             */
         case Rturn      :
            if (dlg_tab)
               dlg_move = (func == ScreenUp) ? -1 : (func == ScreenDown);
         done:
            if (dlg_proc && dlg_proc( dlg_id, answer ) != OK)
               break;
            strcpy( name, answer );
            add_to_history( name, hist );
            /*
             * finished
             */
         case AbortCommand :
            stop = TRUE;
            break;

         case BackSpace :
            /*
             * delete to left of cursor
             */
            if (pos > 0) {
               for (p = cp-1; p < answer+len; p++)
                  *p = *(p+1);
               if (pos > col - scol) {
                  dlen = col++ - scol;
                  dcol = scol;
                  disp = --cp - dlen;
               } else {
                  disp = --cp;
                  dcol = col - 1;
                  dlen = len - pos + 1;
               }
               --len;
            }
            break;

         case DeleteChar :
         case StreamDeleteChar :
            /*
             * delete char under cursor
             */
            if (first) {
               /*
                * delete previous answer
                */
               disp = cp = answer;
               dcol = scol;
               dlen = len;
               *cp = '\0';
               len = 0;

            } else if (*cp) {
               for (p = cp; p < answer+len; p++)
                  *p = *(p+1);
               disp = cp;
               dcol = col;
               dlen = len-- - pos;
            }
            break;

         case DeleteLine :
            /*
             * delete current line
             */
            add_to_history( answer, hist );
            disp = cp = answer;
            dcol = scol;
            dlen = len;
            *cp = '\0';
            len = 0;
            break;

         case DelEndOfLine :
            /*
             * delete from the cursor to the end
             */
            disp = cp;
            dcol = col;
            dlen = len - pos;
            *cp = '\0';
            len = pos;
            break;

         case DelBegOfLine :
            /*
             * delete from before the cursor to the start
             */
            disp = answer;
            dcol = scol;
            dlen = len;
            len -= pos;
            memcpy( answer, cp, len + 1 );
            cp = answer;
            break;

         case CharLeft :
         case StreamCharLeft :
            /*
             * move cursor left
             */
            if (pos > 0)
               cp--;
            break;

         case CharRight :
         case StreamCharRight :
            /*
             * move cursor right
             */
            if (*cp)
               cp++;
            break;

         case WordLeft       :
         case WordDeleteBack :
            /*
             * move cursor to beginning of word
             */
            if (pos > 0) {
               p = cp--;
               while (cp >= answer && myiswhitespc( *cp ))
                  --cp;
               if (func != WordDeleteBack || cp == p-1)
                  while (cp >= answer && !myiswhitespc( *cp ))
                     --cp;
               ++cp;
               if (func == WordDeleteBack) {
                  i = (int)(p - cp);
                  disp = cp;
                  dcol = col - i;
                  dlen = len - pos + i;
                  len -= i;
                  for (i = len+i - pos; i >= 0; --i)
                     *cp++ = *p++;
                  cp = disp;
               }
            }
            break;

         case WordRight  :
         case WordDelete :
            /*
             * move cursor to beginning of next word.
             * if the next word is off-screen, display eight characters.
             */
            if (*cp) {
               p = cp;
               while (*cp && !myiswhitespc( *cp ))
                  ++cp;
               if (func != WordDelete || cp == p)
                  while (*cp && myiswhitespc( *cp ))
                     ++cp;
               i = (int)(cp - p);
               if (func == WordDelete) {
                  disp = p;
                  dcol = col;
                  dlen = len - pos;
                  len -= i;
                  for (i = len - pos; i >= 0; --i)
                     *p++ = *cp++;
                  cp = disp;
               } else if (col + i > max_col && *cp) {
                  col = max_col - 7;
                  old_cp = cp;
                  disp = cp - (cols - 8);
                  dcol = scol;
                  dlen = cols;
               }
            }
            break;

         case Transpose :
            if (len >= 2) {
             char temp;
               disp = p = cp;
               dcol = col;
               dlen = 2;
               if (pos == 0)
                  ++p;
               else if (!*cp) {
                  --p;
                  disp -= 2;
                  dcol -= 2;
               } else {
                  if (col == scol)
                     dlen = 1;
                  else {
                     --disp;
                     --dcol;
                  }
               }
               temp = *p;
               *p = *(p-1);
               *(p-1) = temp;
            }
            break;

         case BegOfLine :
            /*
             * move cursor to start of line
             */
            cp = answer;
            break;

         case EndOfLine :
            /*
             * move cursor to end of line