![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to ee.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [contributed] / dgamelaunch-openbsd|
Return to ee.c CVS log | Up to [contributed] / dgamelaunch-openbsd |
1.1 ! rubenllo 1: /*
! 2: | ee (easy editor)
! 3: |
! 4: | An easy to use, simple screen oriented editor.
! 5: |
! 6: | written by Hugh Mahon
! 7: |
! 8: | THIS MATERIAL IS PROVIDED "AS IS". THERE ARE
! 9: | NO WARRANTIES OF ANY KIND WITH REGARD TO THIS
! 10: | MATERIAL, INCLUDING, BUT NOT LIMITED TO, THE
! 11: | IMPLIED WARRANTIES OF MERCHANTABILITY AND
! 12: | FITNESS FOR A PARTICULAR PURPOSE. Neither
! 13: | Hewlett-Packard nor Hugh Mahon shall be liable
! 14: | for errors contained herein, nor for
! 15: | incidental or consequential damages in
! 16: | connection with the furnishing, performance or
! 17: | use of this material. Neither Hewlett-Packard
! 18: | nor Hugh Mahon assumes any responsibility for
! 19: | the use or reliability of this software or
! 20: | documentation. This software and
! 21: | documentation is totally UNSUPPORTED. There
! 22: | is no support contract available. Hewlett-
! 23: | Packard has done NO Quality Assurance on ANY
! 24: | of the program or documentation. You may find
! 25: | the quality of the materials inferior to
! 26: | supported materials.
! 27: |
! 28: | This software is not a product of Hewlett-Packard, Co., or any
! 29: | other company. No support is implied or offered with this software.
! 30: | You've got the source, and you're on your own.
! 31: |
! 32: | This software may be distributed under the terms of Larry Wall's
! 33: | Artistic license, a copy of which is included in this distribution.
! 34: |
! 35: | This notice must be included with this software and any derivatives.
! 36: |
! 37: | This editor was purposely developed to be simple, both in
! 38: | interface and implementation. This editor was developed to
! 39: | address a specific audience: the user who is new to computers
! 40: | (especially UNIX).
! 41: |
! 42: | ee is not aimed at technical users; for that reason more
! 43: | complex features were intentionally left out. In addition,
! 44: | ee is intended to be compiled by people with little computer
! 45: | experience, which means that it needs to be small, relatively
! 46: | simple in implementation, and portable.
! 47: |
! 48: | This software and documentation contains
! 49: | proprietary information which is protected by
! 50: | copyright. All rights are reserved.
! 51: |
! 52: | $Header: /var/cvs/dgamelaunch/ee.c,v 1.10 2004/01/26 16:54:02 joshk Exp $
! 53: |
! 54: */
! 55:
! 56: #include <wchar.h>
! 57: wchar_t *ee_copyright_message =
! 58: L"Copyright (c) 1986, 1990, 1991, 1992, 1993, 1994, 1995, 1996 Hugh Mahon ";
! 59:
! 60: wchar_t *ee_long_notice[] = {
! 61: L"This software and documentation contains",
! 62: L"proprietary information which is protected by",
! 63: L"copyright. All rights are reserved."
! 64: };
! 65:
! 66: wchar_t *version = L"@(#) ee, version 1.4.1 $Revision: 1.10 $";
! 67:
! 68: #include <locale.h>
! 69: #include <curses.h>
! 70: #include <signal.h>
! 71: #include <fcntl.h>
! 72: #include <sys/types.h>
! 73: #include <sys/stat.h>
! 74: #include <errno.h>
! 75: #include <string.h>
! 76: #include <pwd.h>
! 77:
! 78: #include <sys/wait.h>
! 79: #include <stdlib.h>
! 80: #include <stdarg.h>
! 81: #include <unistd.h>
! 82: #include <ctype.h>
! 83:
! 84: #ifndef SIGCHLD
! 85: #define SIGCHLD SIGCLD
! 86: #endif
! 87:
! 88: #define MAX_FILE 1048576
! 89:
! 90: #define TAB 9
! 91: #define max(a, b) (a > b ? a : b)
! 92: #define min(a, b) (a < b ? a : b)
! 93:
! 94: /*
! 95: | defines for type of data to show in info window
! 96: */
! 97:
! 98: #define CONTROL_KEYS 1
! 99: #define COMMANDS 2
! 100:
! 101: struct text {
! 102: wchar_t *line; /* line of characters */
! 103: int line_number; /* line number */
! 104: int line_length; /* actual number of characters in the line */
! 105: int max_length; /* maximum number of characters the line handles */
! 106: struct text *next_line; /* next line of text */
! 107: struct text *prev_line; /* previous line of text */
! 108: };
! 109:
! 110: struct text *first_line; /* first line of current buffer */
! 111: struct text *dlt_line; /* structure for info on deleted line */
! 112: struct text *curr_line; /* current line cursor is on */
! 113: struct text *tmp_line; /* temporary line pointer */
! 114: struct text *srch_line; /* temporary pointer for search routine */
! 115:
! 116: int d_wrd_len; /* length of deleted word */
! 117: int position; /* offset in bytes from begin of line */
! 118: int scr_pos; /* horizontal position */
! 119: int scr_vert; /* vertical position on screen */
! 120: int scr_horz; /* horizontal position on screen */
! 121: int tmp_vert, tmp_horz;
! 122: int input_file; /* indicate to read input file */
! 123: int recv_file; /* indicate reading a file */
! 124: int edit; /* continue executing while true */
! 125: int gold; /* 'gold' function key pressed */
! 126: int fildes; /* file descriptor */
! 127: int case_sen; /* case sensitive search flag */
! 128: int last_line; /* last line for text display */
! 129: int last_col; /* last column for text display */
! 130: int horiz_offset = 0; /* offset from left edge of text */
! 131: int clear_com_win; /* flag to indicate com_win needs clearing */
! 132: int text_changes = FALSE; /* indicate changes have been made to text */
! 133: int get_fd; /* file descriptor for reading a file */
! 134: int info_window = TRUE; /* flag to indicate if help window visible */
! 135: int info_type = CONTROL_KEYS; /* flag to indicate type of info to display */
! 136: int expand_tabs = TRUE; /* flag for expanding tabs */
! 137: int right_margin = 0; /* the right margin */
! 138: int observ_margins = TRUE; /* flag for whether margins are observed */
! 139: int out_pipe; /* flag that info is piped out */
! 140: int in_pipe; /* flag that info is piped in */
! 141: int formatted = FALSE; /* flag indicating paragraph formatted */
! 142: int nohighlight = FALSE; /* turns off highlighting */
! 143: int eightbit = TRUE; /* eight bit character flag */
! 144: int local_LINES = 0; /* copy of LINES, to detect when win resizes */
! 145: int local_COLS = 0; /* copy of COLS, to detect when win resizes */
! 146: int curses_initialized = FALSE; /* flag indicating if curses has been started*/
! 147: int emacs_keys_mode = TRUE; /* mode for if emacs key binings are used */
! 148:
! 149: wchar_t *point; /* points to current position in line */
! 150: wchar_t *srch_str; /* pointer for search string */
! 151: wchar_t *u_srch_str; /* pointer to non-case sensitive search */
! 152: wchar_t *srch_1; /* pointer to start of suspect string */
! 153: wchar_t *srch_2; /* pointer to next character of string */
! 154: wchar_t *srch_3;
! 155: char *in_file_name = NULL; /* name of input file */
! 156: char *tmp_file; /* temporary file name */
! 157: wchar_t *d_char; /* deleted character */
! 158: wchar_t *d_word; /* deleted word */
! 159: wchar_t *d_line; /* deleted line */
! 160: wchar_t *start_at_line = NULL; /* move to this line at start of session*/
! 161: int in; /* input character */
! 162:
! 163: FILE *temp_fp; /* temporary file pointer */
! 164:
! 165: wchar_t *table[] = {
! 166: L"^@", L"^A", L"^B", L"^C", L"^D", L"^E", L"^F", L"^G", L"^H", L"\t", L"^J",
! 167: L"^K", L"^L", L"^M", L"^N", L"^O", L"^P", L"^Q", L"^R", L"^S", L"^T", L"^U",
! 168: L"^V", L"^W", L"^X", L"^Y", L"^Z", L"^[", L"^\\", L"^]", L"^^", L"^_"
! 169: };
! 170:
! 171: WINDOW *com_win;
! 172: WINDOW *text_win;
! 173: WINDOW *help_win;
! 174: WINDOW *info_win;
! 175:
! 176: #if defined(__STDC__) || defined(__cplusplus)
! 177: #define P_(s) s
! 178: #else
! 179: #define P_(s) ()
! 180: #endif
! 181:
! 182:
! 183: /*
! 184: | The following structure allows menu items to be flexibly declared.
! 185: | The first item is the string describing the selection, the second
! 186: | is the address of the procedure to call when the item is selected,
! 187: | and the third is the argument for the procedure.
! 188: |
! 189: | For those systems with i18n, the string should be accompanied by a
! 190: | catalog number. The 'int *' should be replaced with 'void *' on
! 191: | systems with that type.
! 192: |
! 193: | The first menu item will be the title of the menu, with NULL
! 194: | parameters for the procedure and argument, followed by the menu items.
! 195: |
! 196: | If the procedure value is NULL, the menu item is displayed, but no
! 197: | procedure is called when the item is selected. The number of the
! 198: | item will be returned. If the third (argument) parameter is -1, no
! 199: | argument is given to the procedure when it is called.
! 200: */
! 201:
! 202: struct menu_entries
! 203: {
! 204: wchar_t *item_string;
! 205: int (*procedure)P_((struct menu_entries *));
! 206: struct menu_entries *ptr_argument;
! 207: int (*iprocedure)P_((int));
! 208: void (*nprocedure)P_((void));
! 209: int argument;
! 210: };
! 211:
! 212: int main(int argc, char *argv[]);
! 213: wchar_t *resiz_line(int factor, struct text *rline, int rpos);
! 214: void insert(int character);
! 215: void delete(int disp);
! 216: void scanline(wchar_t *pos);
! 217: int tabshift(int temp_int);
! 218: int out_char(WINDOW *window, int character, int column);
! 219: int len_char(wchar_t character, int column);
! 220: void draw_line(int vertical, int horiz, wchar_t *ptr, int t_pos, int length);
! 221: void insert_line(int disp);
! 222: struct text *txtalloc(void);
! 223: wchar_t *next_word(wchar_t *string);
! 224: void prev_word(void);
! 225: void control(void);
! 226: void emacs_control(void);
! 227: void bottom(void);
! 228: void top(void);
! 229: void nextline(void);
! 230: void prevline(void);
! 231: void left(int disp);
! 232: void right(int disp);
! 233: void find_pos(void);
! 234: void up(void);
! 235: void down(void);
! 236: void function_key(void);
! 237: void command_prompt(void);
! 238: void command(wchar_t *cmd_str1);
! 239: int scan(wchar_t *line, int offset, int column);
! 240: wchar_t *get_string(wchar_t *prompt, int advance);
! 241: int compare(wchar_t *string1, wchar_t *string2, int sensitive);
! 242: void goto_line(wchar_t *cmd_str);
! 243: void midscreen(int line, wchar_t *pnt);
! 244: void check_fp(void);
! 245: void get_file(char *file_name);
! 246: void get_line(int length, char *in_string, int *append);
! 247: void draw_screen(void);
! 248: void ee_finish(void);
! 249: int quit(int noverify);
! 250: void edit_abort(int arg);
! 251: void delete_text(void);
! 252: int write_file(char *file_name, int fd);
! 253: int search(int display_message);
! 254: void search_prompt(void);
! 255: void del_char(void);
! 256: void undel_char(void);
! 257: void del_word(void);
! 258: void undel_word(void);
! 259: void del_line(void);
! 260: void undel_line(void);
! 261: void adv_word(void);
! 262: void move_rel(char direction, int lines);
! 263: void eol(void);
! 264: void bol(void);
! 265: void adv_line(void);
! 266: void set_up_term(void);
! 267: void resize_check(void);
! 268: int menu_op(struct menu_entries menu_list[]);
! 269: void paint_menu(struct menu_entries menu_list[], int max_width, int max_height, int list_size, int top_offset, WINDOW *menu_win, int off_start, int vert_size);
! 270: void help(void);
! 271: void paint_info_win(void);
! 272: void no_info_window(void);
! 273: void create_info_window(void);
! 274: int file_op(int arg);
! 275: void leave_op(void);
! 276: void redraw(void);
! 277: int Blank_Line(struct text *test_line);
! 278: void echo_string(wchar_t *string);
! 279: int first_word_len(struct text *test_line);
! 280: wchar_t *is_in_string(wchar_t *string, wchar_t *substring);
! 281: int unique_test(wchar_t *string, wchar_t *list[]);
! 282: void strings_init(void);
! 283:
! 284: #undef P_
! 285: /*
! 286: | allocate space here for the strings that will be in the menu
! 287: */
! 288:
! 289: struct menu_entries leave_menu[] = {
! 290: {L"", NULL, NULL, NULL, NULL, -1},
! 291: {L"", NULL, NULL, NULL, ee_finish, -1},
! 292: {L"", NULL, NULL, quit, NULL, TRUE},
! 293: {NULL, NULL, NULL, NULL, NULL, -1}
! 294: };
! 295:
! 296: #define READ_FILE 1
! 297: #define WRITE_FILE 2
! 298: #define SAVE_FILE 3
! 299:
! 300: struct menu_entries search_menu[] = {
! 301: {L"", NULL, NULL, NULL, NULL, 0},
! 302: {L"", NULL, NULL, NULL, search_prompt, -1},
! 303: {L"", NULL, NULL, search, NULL, TRUE},
! 304: {NULL, NULL, NULL, NULL, NULL, -1}
! 305: };
! 306:
! 307: struct menu_entries main_menu[] = {
! 308: {L"", NULL, NULL, NULL, NULL, -1},
! 309: {L"", NULL, NULL, NULL, leave_op, -1},
! 310: {L"", NULL, NULL, NULL, help, -1},
! 311: {L"", NULL, NULL, file_op, NULL, SAVE_FILE},
! 312: {L"", NULL, NULL, NULL, redraw, -1},
! 313: {L"", menu_op, search_menu, NULL, NULL, -1},
! 314: {NULL, NULL, NULL, NULL, NULL, -1}
! 315: };
! 316:
! 317: wchar_t *help_text[23];
! 318: wchar_t *control_keys[5];
! 319:
! 320: wchar_t *emacs_help_text[22];
! 321: wchar_t *emacs_control_keys[5];
! 322:
! 323: wchar_t *command_strings[5];
! 324: wchar_t *commands[32];
! 325:
! 326: #define MENU_WARN 1
! 327:
! 328: #define max_alpha_char 36
! 329:
! 330: /*
! 331: | Declarations for strings for localization
! 332: */
! 333:
! 334: wchar_t *com_win_message; /* to be shown in com_win if no info window */
! 335: char *no_file_string;
! 336: wchar_t *ascii_code_str;
! 337: wchar_t *command_str;
! 338: char *char_str;
! 339: char *unkn_cmd_str;
! 340: wchar_t *non_unique_cmd_msg;
! 341: char *line_num_str;
! 342: char *line_len_str;
! 343: char *current_file_str;
! 344: wchar_t *usage0;
! 345: wchar_t *usage1;
! 346: wchar_t *usage2;
! 347: wchar_t *usage3;
! 348: wchar_t *usage4;
! 349: char *file_is_dir_msg;
! 350: char *new_file_msg;
! 351: char *cant_open_msg;
! 352: wchar_t *open_file_msg;
! 353: char *file_read_fin_msg;
! 354: char *reading_file_msg;
! 355: char *read_only_msg;
! 356: char *file_read_lines_msg;
! 357: wchar_t *save_file_name_prompt;
! 358: char *file_not_saved_msg;
! 359: wchar_t *changes_made_prompt;
! 360: wchar_t *yes_char;
! 361: wchar_t *file_exists_prompt;
! 362: char *create_file_fail_msg;
! 363: char *writing_file_msg;
! 364: char *file_written_msg;
! 365: char *searching_msg;
! 366: char *str_not_found_msg;
! 367: wchar_t *search_prompt_str;
! 368: wchar_t *continue_msg;
! 369: wchar_t *menu_cancel_msg;
! 370: wchar_t *menu_size_err_msg;
! 371: wchar_t *press_any_key_msg;
! 372: wchar_t *ON;
! 373: wchar_t *OFF;
! 374: wchar_t *HELP;
! 375: wchar_t *SAVE;
! 376: wchar_t *READ;
! 377: wchar_t *LINE;
! 378: wchar_t *FILE_str;
! 379: wchar_t *CHARACTER;
! 380: wchar_t *REDRAW;
! 381: wchar_t *RESEQUENCE;
! 382: wchar_t *AUTHOR;
! 383: wchar_t *ee_VERSION;
! 384: wchar_t *CASE;
! 385: wchar_t *NOCASE;
! 386: wchar_t *EXPAND;
! 387: wchar_t *NOEXPAND;
! 388: wchar_t *Exit_string;
! 389: wchar_t *QUIT_string;
! 390: wchar_t *INFO;
! 391: wchar_t *NOINFO;
! 392: wchar_t *MARGINS;
! 393: wchar_t *NOMARGINS;
! 394: wchar_t *AUTOFORMAT;
! 395: wchar_t *NOAUTOFORMAT;
! 396: wchar_t *Echo;
! 397: wchar_t *PRINTCOMMAND;
! 398: wchar_t *RIGHTMARGIN;
! 399: wchar_t *HIGHLIGHT;
! 400: wchar_t *NOHIGHLIGHT;
! 401: wchar_t *EIGHTBIT;
! 402: wchar_t *NOEIGHTBIT;
! 403: wchar_t *EMACS_string;
! 404: wchar_t *NOEMACS_string;
! 405: wchar_t *cancel_string;
! 406: char *menu_too_lrg_msg;
! 407: wchar_t *more_above_str, *more_below_str;
! 408:
! 409: #ifndef __STDC__
! 410: #ifndef HAS_STDLIB
! 411: extern char *malloc();
! 412: extern char *realloc();
! 413: extern char *getenv();
! 414: FILE *fopen(); /* declaration for open function */
! 415: #endif /* HAS_STDLIB */
! 416: #endif /* __STDC__ */
! 417:
! 418: int
! 419: main(argc, argv) /* beginning of main program */
! 420: int argc;
! 421: char *argv[];
! 422: {
! 423: int counter;
! 424:
! 425: setlocale(LC_ALL, "");
! 426: for (counter = 1; counter < 24; counter++)
! 427: {
! 428: if (!(counter == SIGKILL || counter == SIGSTOP))
! 429: signal(counter, SIG_IGN);
! 430: }
! 431:
! 432: signal(SIGCHLD, SIG_DFL);
! 433: signal(SIGSEGV, SIG_DFL);
! 434: signal(SIGINT, edit_abort);
! 435: d_char = malloc(3 * sizeof(wchar_t)); /* provide a buffer for multi-byte chars */
! 436: d_word = malloc(150 * sizeof(wchar_t));
! 437: *d_word = '\0';
! 438: d_line = NULL;
! 439: dlt_line = txtalloc();
! 440: dlt_line->line = d_line;
! 441: dlt_line->line_length = 0;
! 442: curr_line = first_line = txtalloc();
! 443: curr_line->line = point = malloc(10 * sizeof(wchar_t));
! 444: curr_line->line_length = 1;
! 445: curr_line->max_length = 10;
! 446: curr_line->prev_line = NULL;
! 447: curr_line->next_line = NULL;
! 448: curr_line->line_number = 1;
! 449: srch_str = NULL;
! 450: u_srch_str = NULL;
! 451: position = 1;
! 452: scr_pos =0;
! 453: scr_vert = 0;
! 454: scr_horz = 0;
! 455: edit = TRUE;
! 456: gold = case_sen = FALSE;
! 457: strings_init();
! 458:
! 459: if (argc != 2)
! 460: {
! 461: puts("need a filename! bailing out.");
! 462: return 1;
! 463: }
! 464: else
! 465: {
! 466: tmp_file = strdup(argv[1]);
! 467: input_file = recv_file = TRUE;
! 468: }
! 469:
! 470: set_up_term();
! 471: if (right_margin == 0)
! 472: right_margin = COLS - 1;
! 473:
! 474: if (!tmp_file)
! 475: {
! 476: wprintw(com_win, no_file_string);
! 477: wrefresh(com_win);
! 478: }
! 479: else
! 480: check_fp();
! 481:
! 482: clear_com_win = TRUE;
! 483:
! 484: while(edit)
! 485: {
! 486: int keyt;
! 487: wrefresh(text_win);
! 488: keyt = wget_wch(text_win, &in);
! 489: if (keyt == ERR)
! 490: exit(0);
! 491:
! 492: resize_check();
! 493:
! 494: if (clear_com_win)
! 495: {
! 496: clear_com_win = FALSE;
! 497: wmove(com_win, 0, 0);
! 498: werase(com_win);
! 499: if (!info_window)
! 500: {
! 501: wprintw(com_win, "%S", com_win_message);
! 502: }
! 503: wrefresh(com_win);
! 504: }
! 505:
! 506: if (keyt == KEY_CODE_YES)
! 507: function_key();
! 508: else if ((in == '\10') || (in == 127))
! 509: {
! 510: in = 8; /* make sure key is set to backspace */
! 511: delete(TRUE);
! 512: }
! 513: else if ((in > 31) || (in == 9))
! 514: insert(in);
! 515: else if ((in >= 0) && (in <= 31))
! 516: {
! 517: if (emacs_keys_mode)
! 518: emacs_control();
! 519: else
! 520: control();
! 521: }
! 522: }
! 523: return(0);
! 524: }
! 525:
! 526: wchar_t *
! 527: resiz_line(factor, rline, rpos) /* resize the line to length + factor*/
! 528: int factor; /* resize factor */
! 529: struct text *rline; /* position in line */
! 530: int rpos;
! 531: {
! 532: wchar_t *rpoint;
! 533: int resiz_var;
! 534:
! 535: rline->max_length += factor;
! 536: rpoint = rline->line = realloc(rline->line, rline->max_length * sizeof(wchar_t));
! 537: for (resiz_var = 1 ; (resiz_var < rpos) ; resiz_var++)
! 538: rpoint++;
! 539: return(rpoint);
! 540: }
! 541:
! 542: void
! 543: insert(character) /* insert character into line */
! 544: int character; /* new character */
! 545: {
! 546: int counter;
! 547: int value;
! 548: wchar_t *temp; /* temporary pointer */
! 549: wchar_t *temp2; /* temporary pointer */
! 550:
! 551: if ((character == '\011') && (expand_tabs))
! 552: {
! 553: counter = len_char('\011', scr_horz);
! 554: for (; counter > 0; counter--)
! 555: insert(' ');
! 556: return;
! 557: }
! 558: text_changes = TRUE;
! 559: if ((curr_line->max_length - curr_line->line_length) < 5)
! 560: point = resiz_line(10, curr_line, position);
! 561: curr_line->line_length++;
! 562: temp = point;
! 563: counter = position;
! 564: while (counter < curr_line->line_length) /* find end of line */
! 565: {
! 566: counter++;
! 567: temp++;
! 568: }
! 569: temp++; /* increase length of line by one */
! 570: while (point < temp)
! 571: {
! 572: temp2=temp - 1;
! 573: *temp= *temp2; /* shift characters over by one */
! 574: temp--;
! 575: }
! 576: *point = character; /* insert new character */
! 577: wclrtoeol(text_win);
! 578: if ((character >= 0) && (character < ' ')) /* check for TAB character*/
! 579: {
! 580: scr_pos = scr_horz += out_char(text_win, character, scr_horz);
! 581: point++;
! 582: position++;
! 583: }
! 584: else
! 585: {
! 586: waddnwstr(text_win, &character, 1);
! 587: scr_pos = ++scr_horz;
! 588: point++;
! 589: position ++;
! 590: }
! 591:
! 592: if ((observ_margins) && (right_margin < scr_pos))
! 593: {
! 594: counter = position;
! 595: while (scr_pos > right_margin)
! 596: prev_word();
! 597: if (scr_pos == 0)
! 598: {
! 599: while (position < counter)
! 600: right(TRUE);
! 601: }
! 602: else
! 603: {
! 604: counter -= position;
! 605: insert_line(TRUE);
! 606: for (value = 0; value < counter; value++)
! 607: right(TRUE);
! 608: }
! 609: }
! 610:
! 611: if ((scr_horz - horiz_offset) > last_col)
! 612: {
! 613: horiz_offset += 8;
! 614: midscreen(scr_vert, point);
! 615: }
! 616:
! 617: else if ((character != ' ') && (character != '\t'))
! 618: formatted = FALSE;
! 619:
! 620: draw_line(scr_vert, scr_horz, point, position, curr_line->line_length);
! 621: }
! 622:
! 623: void
! 624: delete(disp) /* delete character */
! 625: int disp;
! 626: {
! 627: wchar_t *tp;
! 628: wchar_t *temp2;
! 629: struct text *temp_buff;
! 630: int temp_vert;
! 631: int temp_pos;
! 632: int del_width = 1;
! 633:
! 634: if (point != curr_line->line) /* if not at beginning of line */
! 635: {
! 636: text_changes = TRUE;
! 637: temp2 = tp = point;
! 638: tp -= del_width;
! 639: point -= del_width;
! 640: position -= del_width;
! 641: temp_pos = position;
! 642: curr_line->line_length -= del_width;
! 643: if ((*tp < ' ') || (*tp >= 127)) /* check for TAB */
! 644: scanline(tp);
! 645: else
! 646: scr_horz -= del_width;
! 647: scr_pos = scr_horz;
! 648: if (in == 8)
! 649: {
! 650: if (del_width == 1)
! 651: *d_char = *point; /* save deleted character */
! 652: else
! 653: {
! 654: d_char[0] = *point;
! 655: d_char[1] = *(point + 1);
! 656: }
! 657: d_char[del_width] = '\0';
! 658: }
! 659: while (temp_pos <= curr_line->line_length)
! 660: {
! 661: temp_pos++;
! 662: *tp = *temp2;
! 663: tp++;
! 664: temp2++;
! 665: }
! 666: if (scr_horz < horiz_offset)
! 667: {
! 668: horiz_offset -= 8;
! 669: midscreen(scr_vert, point);
! 670: }
! 671: }
! 672: else if (curr_line->prev_line != NULL)
! 673: {
! 674: text_changes = TRUE;
! 675: left(disp); /* go to previous line */
! 676: temp_buff = curr_line->next_line;
! 677: point = resiz_line(temp_buff->line_length, curr_line, position);
! 678: if (temp_buff->next_line != NULL)
! 679: temp_buff->next_line->prev_line = curr_line;
! 680: curr_line->next_line = temp_buff->next_line;
! 681: temp2 = temp_buff->line;
! 682: if (in == 8)
! 683: {
! 684: d_char[0] = '\n';
! 685: d_char[1] = '\0';
! 686: }
! 687: tp = point;
! 688: temp_pos = 1;
! 689: while (temp_pos < temp_buff->line_length)
! 690: {
! 691: curr_line->line_length++;
! 692: temp_pos++;
! 693: *tp = *temp2;
! 694: tp++;
! 695: temp2++;
! 696: }
! 697: *tp = '\0';
! 698: free(temp_buff->line);
! 699: free(temp_buff);
! 700: temp_buff = curr_line;
! 701: temp_vert = scr_vert;
! 702: scr_pos = scr_horz;
! 703: if (scr_vert < last_line)
! 704: {
! 705: wmove(text_win, scr_vert + 1, 0);
! 706: wdeleteln(text_win);
! 707: }
! 708: while ((temp_buff != NULL) && (temp_vert < last_line))
! 709: {
! 710: temp_buff = temp_buff->next_line;
! 711: temp_vert++;
! 712: }
! 713: if ((temp_vert == last_line) && (temp_buff != NULL))
! 714: {
! 715: tp = temp_buff->line;
! 716: wmove(text_win, last_line,0);
! 717: wclrtobot(text_win);
! 718: draw_line(last_line, 0, tp, 1, temp_buff->line_length);
! 719: wmove(text_win, scr_vert, (scr_horz - horiz_offset));
! 720: }
! 721: }
! 722: draw_line(scr_vert, scr_horz, point, position, curr_line->line_length);
! 723: formatted = FALSE;
! 724: }
! 725:
! 726: void
! 727: scanline(pos) /* find the proper horizontal position for the pointer */
! 728: wchar_t *pos;
! 729: {
! 730: int temp;
! 731: wchar_t *ptr;
! 732:
! 733: ptr = curr_line->line;
! 734: temp = 0;
! 735: while (ptr < pos)
! 736: {
! 737: if (*ptr <= 8)
! 738: temp += 2;
! 739: else if (*ptr == 9)
! 740: temp += tabshift(temp);
! 741: else if ((*ptr >= 10) && (*ptr <= 31))
! 742: temp += 2;
! 743: else if ((*ptr >= 32) && (*ptr < 127))
! 744: temp++;
! 745: else if (*ptr == 127)
! 746: temp += 2;
! 747: else if (!eightbit)
! 748: temp += 5;
! 749: else
! 750: temp++;
! 751: ptr++;
! 752: }
! 753: scr_horz = temp;
! 754: if ((scr_horz - horiz_offset) > last_col)
! 755: {
! 756: horiz_offset = (scr_horz - (scr_horz % 8)) - (COLS - 8);
! 757: midscreen(scr_vert, point);
! 758: }
! 759: else if (scr_horz < horiz_offset)
! 760: {
! 761: horiz_offset = max(0, (scr_horz - (scr_horz % 8)));
! 762: midscreen(scr_vert, point);
! 763: }
! 764: }
! 765:
! 766: int
! 767: tabshift(temp_int) /* give the number of spaces to shift */
! 768: int temp_int;
! 769: {
! 770: int leftover;
! 771:
! 772: leftover = ((temp_int + 1) % 8);
! 773: if (leftover == 0)
! 774: return (1);
! 775: else
! 776: return (9 - leftover);
! 777: }
! 778:
! 779: int
! 780: out_char(window, character, column) /* output non-printing character */
! 781: WINDOW *window;
! 782: int character;
! 783: int column;
! 784: {
! 785: int i1, i2;
! 786: wchar_t *string;
! 787:
! 788: if (character == TAB)
! 789: {
! 790: i1 = tabshift(column);
! 791: for (i2 = 0;
! 792: (i2 < i1) && (((column+i2+1)-horiz_offset) < last_col); i2++)
! 793: {
! 794: waddch(window, ' ');
! 795: }
! 796: return(i1);
! 797: }
! 798: else if ((character >= '\0') && (character < ' '))
! 799: {
! 800: string = table[(int) character];
! 801: }
! 802: else
! 803: {
! 804: waddnwstr(window, &character, 1);
! 805: return(1);
! 806: }
! 807: for (i2 = 0; (string[i2] != '\0') && (((column+i2+1)-horiz_offset) < last_col); i2++)
! 808: waddch(window, string[i2]);
! 809: return(wcslen(string));
! 810: }
! 811:
! 812: int
! 813: len_char(character, column) /* return the length of the character */
! 814: wchar_t character;
! 815: int column; /* the column must be known to provide spacing for tabs */
! 816: {
! 817: int length;
! 818:
! 819: if (character == '\t')
! 820: length = tabshift(column);
! 821: else if ((character >= 0) && (character < 32))
! 822: length = 2;
! 823: else if ((character >= 32) && (character <= 126))
! 824: length = 1;
! 825: else if (character == 127)
! 826: length = 2;
! 827: else if (((character > 126) || (character < 0)) && (!eightbit))
! 828: length = 5;
! 829: else
! 830: length = 1;
! 831:
! 832: return(length);
! 833: }
! 834:
! 835: void
! 836: draw_line(vertical, horiz, ptr, t_pos, length) /* redraw line from current position */
! 837: int vertical; /* current vertical position on screen */
! 838: int horiz; /* current horizontal position on screen */
! 839: wchar_t *ptr; /* pointer to line */
! 840: int t_pos; /* current position (offset in bytes) from bol */
! 841: int length; /* length (in bytes) of line */
! 842: {
! 843: int d; /* partial length of special or tab char to display */
! 844: wchar_t *temp; /* temporary pointer to position in line */
! 845: int abs_column; /* offset in screen units from begin of line */
! 846: int column; /* horizontal position on screen */
! 847: int row; /* vertical position on screen */
! 848: int posit; /* temporary position indicator within line */
! 849:
! 850: abs_column = horiz;
! 851: column = horiz - horiz_offset;
! 852: row = vertical;
! 853: temp = ptr;
! 854: d = 0;
! 855: posit = t_pos;
! 856: if (column < 0)
! 857: {
! 858: wmove(text_win, row, 0);
! 859: wclrtoeol(text_win);
! 860: }
! 861: while (column < 0)
! 862: {
! 863: d = len_char(*temp, abs_column);
! 864: abs_column += d;
! 865: column += d;
! 866: posit++;
! 867: temp++;
! 868: }
! 869: wmove(text_win, row, column);
! 870: wclrtoeol(text_win);
! 871: while ((posit < length) && (column <= last_col))
! 872: {
! 873: if (*temp < 32)
! 874: {
! 875: column += len_char(*temp, abs_column);
! 876: abs_column += out_char(text_win, *temp, abs_column);
! 877: }
! 878: else
! 879: {
! 880: abs_column++;
! 881: column++;
! 882: waddnwstr(text_win, temp, 1);
! 883: }
! 884: posit++;
! 885: temp++;
! 886: }
! 887: if (column < last_col)
! 888: wclrtoeol(text_win);
! 889: wmove(text_win, vertical, (horiz - horiz_offset));
! 890: }
! 891:
! 892: void
! 893: insert_line(disp) /* insert new line */
! 894: int disp;
! 895: {
! 896: int temp_pos;
! 897: int temp_pos2;
! 898: wchar_t *temp;
! 899: wchar_t *extra;
! 900: struct text *temp_nod;
! 901:
! 902: text_changes = TRUE;
! 903: wmove(text_win, scr_vert, (scr_horz - horiz_offset));
! 904: wclrtoeol(text_win);
! 905: temp_nod= txtalloc();
! 906: temp_nod->line = extra= malloc(10 * sizeof(wchar_t));
! 907: temp_nod->line_length = 1;
! 908: temp_nod->max_length = 10;
! 909: temp_nod->line_number = curr_line->line_number + 1;
! 910: temp_nod->next_line = curr_line->next_line;
! 911: if (temp_nod->next_line != NULL)
! 912: temp_nod->next_line->prev_line = temp_nod;
! 913: temp_nod->prev_line = curr_line;
! 914: curr_line->next_line = temp_nod;
! 915: temp_pos2 = position;
! 916: temp = point;
! 917: if (temp_pos2 < curr_line->line_length)
! 918: {
! 919: temp_pos = 1;
! 920: while (temp_pos2 < curr_line->line_length)
! 921: {
! 922: if ((temp_nod->max_length - temp_nod->line_length)< 5)
! 923: extra = resiz_line(10, temp_nod, temp_pos);
! 924: temp_nod->line_length++;
! 925: temp_pos++;
! 926: temp_pos2++;
! 927: *extra= *temp;
! 928: extra++;
! 929: temp++;
! 930: }
! 931: temp=point;
! 932: *temp = '\0';
! 933: temp = resiz_line((1 - temp_nod->line_length), curr_line, position);
! 934: curr_line->line_length = 1 + temp - curr_line->line;
! 935: }
! 936: curr_line->line_length = position;
! 937: curr_line = temp_nod;
! 938: *extra = '\0';
! 939: position = 1;
! 940: point= curr_line->line;
! 941: if (disp)
! 942: {
! 943: if (scr_vert < last_line)
! 944: {
! 945: scr_vert++;
! 946: wclrtoeol(text_win);
! 947: wmove(text_win, scr_vert, 0);
! 948: winsertln(text_win);
! 949: }
! 950: else
! 951: {
! 952: wmove(text_win, 0,0);
! 953: wdeleteln(text_win);
! 954: wmove(text_win, last_line,0);
! 955: wclrtobot(text_win);
! 956: }
! 957: scr_pos = scr_horz = 0;
! 958: if (horiz_offset)
! 959: {
! 960: horiz_offset = 0;
! 961: midscreen(scr_vert, point);
! 962: }
! 963: draw_line(scr_vert, scr_horz, point, position,
! 964: curr_line->line_length);
! 965: }
! 966: }
! 967:
! 968: struct text *txtalloc() /* allocate space for line structure */
! 969: {
! 970: return((struct text *) malloc(sizeof( struct text)));
! 971: }
! 972:
! 973: wchar_t *next_word(string) /* move to next word in string */
! 974: wchar_t *string;
! 975: {
! 976: while ((*string != '\0') && ((*string != 32) && (*string != 9)))
! 977: string++;
! 978: while ((*string != '\0') && ((*string == 32) || (*string == 9)))
! 979: string++;
! 980: return(string);
! 981: }
! 982:
! 983: int watoi(wchar_t *s)
! 984: {
! 985: int x = 0;
! 986: while (*s >= '0' && *s <= '9')
! 987: x = x * 10 + *s++ - '0';
! 988: return x;
! 989: }
! 990:
! 991: void
! 992: prev_word() /* move to start of previous word in text */
! 993: {
! 994: if (position != 1)
! 995: {
! 996: if ((position != 1) && ((point[-1] == ' ') || (point[-1] == '\t')))
! 997: { /* if at the start of a word */
! 998: while ((position != 1) && ((*point != ' ') && (*point != '\t')))
! 999: left(TRUE);
! 1000: }
! 1001: while ((position != 1) && ((*point == ' ') || (*point == '\t')))
! 1002: left(TRUE);
! 1003: while ((position != 1) && ((*point != ' ') && (*point != '\t')))
! 1004: left(TRUE);
! 1005: if ((position != 1) && ((*point == ' ') || (*point == '\t')))
! 1006: right(TRUE);
! 1007: }
! 1008: else
! 1009: left(TRUE);
! 1010: }
! 1011:
! 1012: void
! 1013: control() /* use control for commands */
! 1014: {
! 1015: wchar_t *string;
! 1016:
! 1017: if (in == 1) /* control a */
! 1018: {
! 1019: string = get_string(ascii_code_str, TRUE);
! 1020: if (*string != '\0')
! 1021: {
! 1022: in = watoi(string);
! 1023: wmove(text_win, scr_vert, (scr_horz - horiz_offset));
! 1024: insert(in);
! 1025: }
! 1026: free(string);
! 1027: }
! 1028: else if (in == 2) /* control b */
! 1029: bottom();
! 1030: else if (in == 3) /* control c */
! 1031: {
! 1032: command_prompt();
! 1033: }
! 1034: else if (in == 4) /* control d */
! 1035: down();
! 1036: else if (in == 5) /* control e */
! 1037: search_prompt();
! 1038: else if (in == 6) /* control f */
! 1039: undel_char();
! 1040: else if (in == 7) /* control g */
! 1041: bol();
! 1042: else if (in == 8) /* control h */
! 1043: delete(TRUE);
! 1044: else if (in == 9) /* control i */
! 1045: ;
! 1046: else if (in == 10) /* control j */
! 1047: insert_line(TRUE);
! 1048: else if (in == 11) /* control k */
! 1049: del_char();
! 1050: else if (in == 12) /* control l */
! 1051: left(TRUE);
! 1052: else if (in == 13) /* control m */
! 1053: insert_line(TRUE);
! 1054: else if (in == 14) /* control n */
! 1055: move_rel('d', max(5, (last_line - 5)));
! 1056: else if (in == 15) /* control o */
! 1057: eol();
! 1058: else if (in == 16) /* control p */
! 1059: move_rel('u', max(5, (last_line - 5)));
! 1060: else if (in == 17) /* control q */
! 1061: ;
! 1062: else if (in == 18) /* control r */
! 1063: right(TRUE);
! 1064: else if (in == 19) /* control s */
! 1065: ;
! 1066: else if (in == 20) /* control t */
! 1067: top();
! 1068: else if (in == 21) /* control u */
! 1069: up();
! 1070: else if (in == 22) /* control v */
! 1071: undel_word();
! 1072: else if (in == 23) /* control w */
! 1073: del_word();
! 1074: else if (in == 24) /* control x */
! 1075: search(TRUE);
! 1076: else if (in == 25) /* control y */
! 1077: del_line();
! 1078: else if (in == 26) /* control z */
! 1079: undel_line();
! 1080: else if (in == 27) /* control [ (escape) */
! 1081: {
! 1082: menu_op(main_menu);
! 1083: }
! 1084: }
! 1085:
! 1086: /*
! 1087: | Emacs control-key bindings
! 1088: */
! 1089:
! 1090: void
! 1091: emacs_control()
! 1092: {
! 1093: wchar_t *string;
! 1094:
! 1095: if (in == 1) /* control a */
! 1096: bol();
! 1097: else if (in == 2) /* control b */
! 1098: left(TRUE);
! 1099: else if (in == 3) /* control c */
! 1100: {
! 1101: command_prompt();
! 1102: }
! 1103: else if (in == 4) /* control d */
! 1104: del_char();
! 1105: else if (in == 5) /* control e */
! 1106: eol();
! 1107: else if (in == 6) /* control f */
! 1108: right(TRUE);
! 1109: else if (in == 7) /* control g */
! 1110: move_rel('u', max(5, (last_line - 5)));
! 1111: else if (in == 8) /* control h */
! 1112: delete(TRUE);
! 1113: else if (in == 9) /* control i */
! 1114: ;
! 1115: else if (in == 10) /* control j */
! 1116: undel_char();
! 1117: else if (in == 11) /* control k */
! 1118: del_line();
! 1119: else if (in == 12) /* control l */
! 1120: undel_line();
! 1121: else if (in == 13) /* control m */
! 1122: insert_line(TRUE);
! 1123: else if (in == 14) /* control n */
! 1124: down();
! 1125: else if (in == 15) /* control o */
! 1126: {
! 1127: string = get_string(ascii_code_str, TRUE);
! 1128: if (*string != '\0')
! 1129: {
! 1130: in = watoi(string);
! 1131: wmove(text_win, scr_vert, (scr_horz - horiz_offset));
! 1132: insert(in);
! 1133: }
! 1134: free(string);
! 1135: }
! 1136: else if (in == 16) /* control p */
! 1137: up();
! 1138: else if (in == 17) /* control q */
! 1139: ;
! 1140: else if (in == 18) /* control r */
! 1141: undel_word();
! 1142: else if (in == 19) /* control s */
! 1143: ;
! 1144: else if (in == 20) /* control t */
! 1145: top();
! 1146: else if (in == 21) /* control u */
! 1147: bottom();
! 1148: else if (in == 22) /* control v */
! 1149: move_rel('d', max(5, (last_line - 5)));
! 1150: else if (in == 23) /* control w */
! 1151: del_word();
! 1152: else if (in == 24) /* control x */
! 1153: search(TRUE);
! 1154: else if (in == 25) /* control y */
! 1155: search_prompt();
! 1156: else if (in == 26) /* control z */
! 1157: adv_word();
! 1158: else if (in == 27) /* control [ (escape) */
! 1159: {
! 1160: menu_op(main_menu);
! 1161: }
! 1162: }
! 1163:
! 1164: void
! 1165: bottom() /* go to bottom of file */
! 1166: {
! 1167: while (curr_line->next_line != NULL)
! 1168: curr_line = curr_line->next_line;
! 1169: point = curr_line->line;
! 1170: if (horiz_offset)
! 1171: horiz_offset = 0;
! 1172: position = 1;
! 1173: midscreen(last_line, point);
! 1174: scr_pos = scr_horz;
! 1175: }
! 1176:
! 1177: void
! 1178: top() /* go to top of file */
! 1179: {
! 1180: while (curr_line->prev_line != NULL)
! 1181: curr_line = curr_line->prev_line;
! 1182: point = curr_line->line;
! 1183: if (horiz_offset)
! 1184: horiz_offset = 0;
! 1185: position = 1;
! 1186: midscreen(0, point);
! 1187: scr_pos = scr_horz;
! 1188: }
! 1189:
! 1190: void
! 1191: nextline() /* move pointers to start of next line */
! 1192: {
! 1193: curr_line = curr_line->next_line;
! 1194: point = curr_line->line;
! 1195: position = 1;
! 1196: if (scr_vert == last_line)
! 1197: {
! 1198: wmove(text_win, 0,0);
! 1199: wdeleteln(text_win);
! 1200: wmove(text_win, last_line,0);
! 1201: wclrtobot(text_win);
! 1202: draw_line(last_line,0,point,1,curr_line->line_length);
! 1203: }
! 1204: else
! 1205: scr_vert++;
! 1206: }
! 1207:
! 1208: void
! 1209: prevline() /* move pointers to start of previous line*/
! 1210: {
! 1211: curr_line = curr_line->prev_line;
! 1212: point = curr_line->line;
! 1213: position = 1;
! 1214: if (scr_vert == 0)
! 1215: {
! 1216: winsertln(text_win);
! 1217: draw_line(0,0,point,1,curr_line->line_length);
! 1218: }
! 1219: else
! 1220: scr_vert--;
! 1221: while (position < curr_line->line_length)
! 1222: {
! 1223: position++;
! 1224: point++;
! 1225: }
! 1226: }
! 1227:
! 1228: void
! 1229: left(disp) /* move left one character */
! 1230: int disp;
! 1231: {
! 1232: if (point != curr_line->line) /* if not at begin of line */
! 1233: {
! 1234: point--;
! 1235: position--;
! 1236: scanline(point);
! 1237: wmove(text_win, scr_vert, (scr_horz - horiz_offset));
! 1238: scr_pos = scr_horz;
! 1239: }
! 1240: else if (curr_line->prev_line != NULL)
! 1241: {
! 1242: if (!disp)
! 1243: {
! 1244: curr_line = curr_line->prev_line;
! 1245: point = curr_line->line + curr_line->line_length;
! 1246: position = curr_line->line_length;
! 1247: return;
! 1248: }
! 1249: position = 1;
! 1250: prevline();
! 1251: scanline(point);
! 1252: scr_pos = scr_horz;
! 1253: wmove(text_win, scr_vert, (scr_horz - horiz_offset));
! 1254: }
! 1255: }
! 1256:
! 1257: void
! 1258: right(disp) /* move right one character */
! 1259: int disp;
! 1260: {
! 1261: if (position < curr_line->line_length)
! 1262: {
! 1263: point++;
! 1264: position++;
! 1265: scanline(point);
! 1266: wmove(text_win, scr_vert, (scr_horz - horiz_offset));
! 1267: scr_pos = scr_horz;
! 1268: }
! 1269: else if (curr_line->next_line != NULL)
! 1270: {
! 1271: if (!disp)
! 1272: {
! 1273: curr_line = curr_line->next_line;
! 1274: point = curr_line->line;
! 1275: position = 1;
! 1276: return;
! 1277: }
! 1278: nextline();
! 1279: scr_pos = scr_horz = 0;
! 1280: if (horiz_offset)
! 1281: {
! 1282: horiz_offset = 0;
! 1283: midscreen(scr_vert, point);
! 1284: }
! 1285: wmove(text_win, scr_vert, (scr_horz - horiz_offset));
! 1286: position = 1;
! 1287: }
! 1288: }
! 1289:
! 1290: void
! 1291: find_pos() /* move to the same column as on other line */
! 1292: {
! 1293: scr_horz = 0;
! 1294: position = 1;
! 1295: while ((scr_horz < scr_pos) && (position < curr_line->line_length))
! 1296: {
! 1297: if (*point == 9)
! 1298: scr_horz += tabshift(scr_horz);
! 1299: else if (*point < ' ')
! 1300: scr_horz += 2;
! 1301: else if ((*point > 127) && ((curr_line->line_length - position) >= 2))
! 1302: {
! 1303: scr_horz += 2;
! 1304: point++;
! 1305: position++;
! 1306: }
! 1307: else
! 1308: scr_horz++;
! 1309: position++;
! 1310: point++;
! 1311: }
! 1312: if ((scr_horz - horiz_offset) > last_col)
! 1313: {
! 1314: horiz_offset = (scr_horz - (scr_horz % 8)) - (COLS - 8);
! 1315: midscreen(scr_vert, point);
! 1316: }
! 1317: else if (scr_horz < horiz_offset)
! 1318: {
! 1319: horiz_offset = max(0, (scr_horz - (scr_horz % 8)));
! 1320: midscreen(scr_vert, point);
! 1321: }
! 1322: wmove(text_win, scr_vert, (scr_horz - horiz_offset));
! 1323: }
! 1324:
! 1325: void
! 1326: up() /* move up one line */
! 1327: {
! 1328: if (curr_line->prev_line != NULL)
! 1329: {
! 1330: prevline();
! 1331: point = curr_line->line;
! 1332: find_pos();
! 1333: }
! 1334: }
! 1335:
! 1336: void
! 1337: down() /* move down one line */
! 1338: {
! 1339: if (curr_line->next_line != NULL)
! 1340: {
! 1341: nextline();
! 1342: find_pos();
! 1343: }
! 1344: }
! 1345:
! 1346: void
! 1347: function_key() /* process function key */
! 1348: {
! 1349: if (in == KEY_LEFT)
! 1350: left(TRUE);
! 1351: else if (in == KEY_RIGHT)
! 1352: right(TRUE);
! 1353: else if ( in == KEY_HOME)
! 1354: top();
! 1355: else if ( in == KEY_UP)
! 1356: up();
! 1357: else if (in == KEY_DOWN)
! 1358: down();
! 1359: else if (in == KEY_NPAGE)
! 1360: move_rel('d', max( 5, (last_line - 5)));
! 1361: else if (in == KEY_PPAGE)
! 1362: move_rel('u', max(5, (last_line - 5)));
! 1363: else if (in == KEY_DL)
! 1364: del_line();
! 1365: else if (in == KEY_DC)
! 1366: del_char();
! 1367: else if (in == KEY_BACKSPACE)
! 1368: delete(TRUE);
! 1369: else if (in == KEY_IL)
! 1370: { /* insert a line before current line */
! 1371: insert_line(TRUE);
! 1372: left(TRUE);
! 1373: }
! 1374: else if (in == KEY_F(1))
! 1375: gold = !gold;
! 1376: else if (in == KEY_F(2))
! 1377: {
! 1378: if (gold)
! 1379: {
! 1380: gold = FALSE;
! 1381: undel_line();
! 1382: }
! 1383: else
! 1384: undel_char();
! 1385: }
! 1386: else if (in == KEY_F(3))
! 1387: {
! 1388: if (gold)
! 1389: {
! 1390: gold = FALSE;
! 1391: undel_word();
! 1392: }
! 1393: else
! 1394: del_word();
! 1395: }
! 1396: else if (in == KEY_F(4))
! 1397: {
! 1398: if (gold)
! 1399: {
! 1400: gold = FALSE;
! 1401: paint_info_win();
! 1402: midscreen(scr_vert, point);
! 1403: }
! 1404: else
! 1405: adv_word();
! 1406: }
! 1407: else if (in == KEY_F(5))
! 1408: {
! 1409: if (gold)
! 1410: {
! 1411: gold = FALSE;
! 1412: search_prompt();
! 1413: }
! 1414: else
! 1415: search(TRUE);
! 1416: }
! 1417: else if (in == KEY_F(6))
! 1418: {
! 1419: if (gold)
! 1420: {
! 1421: gold = FALSE;
! 1422: bottom();
! 1423: }
! 1424: else
! 1425: top();
! 1426: }
! 1427: else if (in == KEY_F(7))
! 1428: {
! 1429: if (gold)
! 1430: {
! 1431: gold = FALSE;
! 1432: eol();
! 1433: }
! 1434: else
! 1435: bol();
! 1436: }
! 1437: else if (in == KEY_F(8))
! 1438: {
! 1439: if (gold)
! 1440: {
! 1441: gold = FALSE;
! 1442: command_prompt();
! 1443: }
! 1444: else
! 1445: adv_line();
! 1446: }
! 1447: }
! 1448:
! 1449: void
! 1450: command_prompt()
! 1451: {
! 1452: wchar_t *cmd_str;
! 1453: int result;
! 1454:
! 1455: info_type = COMMANDS;
! 1456: paint_info_win();
! 1457: cmd_str = get_string(command_str, TRUE);
! 1458: if ((result = unique_test(cmd_str, commands)) != 1)
! 1459: {
! 1460: werase(com_win);
! 1461: wmove(com_win, 0, 0);
! 1462: if (result == 0)
! 1463: wprintw(com_win, unkn_cmd_str, cmd_str);
! 1464: else
! 1465: wprintw(com_win, "%S", non_unique_cmd_msg);
! 1466:
! 1467: wrefresh(com_win);
! 1468:
! 1469: info_type = CONTROL_KEYS;
! 1470: paint_info_win();
! 1471:
! 1472: if (cmd_str != NULL)
! 1473: free(cmd_str);
! 1474: return;
! 1475: }
! 1476: command(cmd_str);
! 1477: wrefresh(com_win);
! 1478: wmove(text_win, scr_vert, (scr_horz - horiz_offset));
! 1479: info_type = CONTROL_KEYS;
! 1480: paint_info_win();
! 1481: if (cmd_str != NULL)
! 1482: free(cmd_str);
! 1483: }
! 1484:
! 1485: void command(wchar_t *cmd_str1) /* process commands from keyboard */
! 1486: {
! 1487: wchar_t *cmd_str2 = NULL;
! 1488: wchar_t *cmd_str = cmd_str1;
! 1489:
! 1490: clear_com_win = TRUE;
! 1491: if (compare(cmd_str, HELP, FALSE))
! 1492: help();
! 1493: else if (compare(cmd_str, LINE, FALSE))
! 1494: {
! 1495: wmove(com_win, 0, 0);
! 1496: wclrtoeol(com_win);
! 1497: wprintw(com_win, line_num_str, curr_line->line_number);
! 1498: wprintw(com_win, line_len_str, curr_line->line_length);
! 1499: }
! 1500: else if (compare(cmd_str, FILE_str, FALSE))
! 1501: {
! 1502: wmove(com_win, 0, 0);
! 1503: wclrtoeol(com_win);
! 1504: if (in_file_name == NULL)
! 1505: wprintw(com_win, no_file_string);
! 1506: else
! 1507: wprintw(com_win, current_file_str, in_file_name);
! 1508: }
! 1509: else if ((*cmd_str >= '0') && (*cmd_str <= '9'))
! 1510: goto_line(cmd_str);
! 1511: else if (compare(cmd_str, CHARACTER, FALSE))
! 1512: {
! 1513: wmove(com_win, 0, 0);
! 1514: wclrtoeol(com_win);
! 1515: wprintw(com_win, char_str, *point);
! 1516: }
! 1517: else if (compare(cmd_str, REDRAW, FALSE))
! 1518: redraw();
! 1519: else if (compare(cmd_str, RESEQUENCE, FALSE))
! 1520: {
! 1521: tmp_line = first_line->next_line;
! 1522: while (tmp_line != NULL)
! 1523: {
! 1524: tmp_line->line_number = tmp_line->prev_line->line_number + 1;
! 1525: tmp_line = tmp_line->next_line;
! 1526: }
! 1527: }
! 1528: else if (compare(cmd_str, SAVE, FALSE))
! 1529: write_file(tmp_file, -1);
! 1530: else if (compare(cmd_str, AUTHOR, FALSE))
! 1531: {
! 1532: wmove(com_win, 0, 0);
! 1533: wclrtoeol(com_win);
! 1534: wprintw(com_win, "written by Hugh Mahon");
! 1535: }
! 1536: else if (compare(cmd_str, ee_VERSION, FALSE))
! 1537: {
! 1538: wmove(com_win, 0, 0);
! 1539: wclrtoeol(com_win);
! 1540: wprintw(com_win, "%s", version);
! 1541: }
! 1542: else if (compare(cmd_str, CASE, FALSE))
! 1543: case_sen = TRUE;
! 1544: else if (compare(cmd_str, NOCASE, FALSE))
! 1545: case_sen = FALSE;
! 1546: else if (compare(cmd_str, EXPAND, FALSE))
! 1547: expand_tabs = TRUE;
! 1548: else if (compare(cmd_str, NOEXPAND, FALSE))
! 1549: expand_tabs = FALSE;
! 1550: else if (compare(cmd_str, Exit_string, FALSE))
! 1551: ee_finish();
! 1552: else if (compare(cmd_str, QUIT_string, FALSE))
! 1553: quit(0);
! 1554: else if ((*cmd_str == '<') && (!in_pipe))
! 1555: {
! 1556: in_pipe = TRUE;
! 1557: cmd_str++;
! 1558: if ((*cmd_str == ' ') || (*cmd_str == '\t'))
! 1559: cmd_str = next_word((wchar_t*)cmd_str);
! 1560: command(cmd_str);
! 1561: in_pipe = FALSE;
! 1562: }
! 1563: else if ((*cmd_str == '>') && (!out_pipe))
! 1564: {
! 1565: out_pipe = TRUE;
! 1566: cmd_str++;
! 1567: if ((*cmd_str == ' ') || (*cmd_str == '\t'))
! 1568: cmd_str = next_word((wchar_t*)cmd_str);
! 1569: command(cmd_str);
! 1570: out_pipe = FALSE;
! 1571: }
! 1572: else
! 1573: {
! 1574: wmove(com_win, 0, 0);
! 1575: wclrtoeol(com_win);
! 1576: wprintw(com_win, unkn_cmd_str, cmd_str);
! 1577: }
! 1578: if (cmd_str2 != NULL)
! 1579: free(cmd_str2);
! 1580: }
! 1581:
! 1582: int
! 1583: scan(line, offset, column) /* determine horizontal position for get_string */
! 1584: wchar_t *line;
! 1585: int offset;
! 1586: int column;
! 1587: {
! 1588: wchar_t *stemp;
! 1589: int i;
! 1590: int j;
! 1591:
! 1592: stemp = line;
! 1593: i = 0;
! 1594: j = column;
! 1595: while (i < offset)
! 1596: {
! 1597: i++;
! 1598: j += len_char(*stemp, j);
! 1599: stemp++;
! 1600: }
! 1601: return(j);
! 1602: }
! 1603:
! 1604: wchar_t *
! 1605: get_string(prompt, advance) /* read string from input on command line */
! 1606: wchar_t *prompt; /* string containing user prompt message */
! 1607: int advance; /* if true, skip leading spaces and tabs */
! 1608: {
! 1609: wchar_t *string;
! 1610: wchar_t *tmp_string;
! 1611: wchar_t *nam_str;
! 1612: wchar_t *g_point;
! 1613: int tmp_int;
! 1614: int g_horz, g_position, g_pos;
! 1615: int esc_flag;
! 1616:
! 1617: g_point = tmp_string = malloc(512 * sizeof(wchar_t));
! 1618: wmove(com_win,0,0);
! 1619: wclrtoeol(com_win);
! 1620: waddwstr(com_win, prompt);
! 1621: wrefresh(com_win);
! 1622: nam_str = tmp_string;
! 1623: clear_com_win = TRUE;
! 1624: g_horz = g_position = scan(prompt, wcslen(prompt), 0);
! 1625: g_pos = 0;
! 1626: do
! 1627: {
! 1628: int keyt;
! 1629: esc_flag = FALSE;
! 1630: keyt = wget_wch(com_win, &in);
! 1631: if (keyt == ERR)
! 1632: exit(0);
! 1633: if (keyt == KEY_CODE_YES)
! 1634: {
! 1635: if (in == KEY_BACKSPACE)
! 1636: in = 8;
! 1637: else
! 1638: continue;
! 1639: }
! 1640: if (((in == 8) || (in == 127)) && (g_pos > 0))
! 1641: {
! 1642: tmp_int = g_horz;
! 1643: g_pos--;
! 1644: g_horz = scan(g_point, g_pos, g_position);
! 1645: tmp_int = tmp_int - g_horz;
! 1646: for (; 0 < tmp_int; tmp_int--)
! 1647: {
! 1648: if ((g_horz+tmp_int) < (last_col - 1))
! 1649: {
! 1650: waddch(com_win, '\010');
! 1651: waddch(com_win, ' ');
! 1652: waddch(com_win, '\010');
! 1653: }
! 1654: }
! 1655: nam_str--;
! 1656: }
! 1657: else if ((in != 8) && (in != 127) && (in != '\n') && (in != '\r'))
! 1658: {
! 1659: if (in == '\026') /* control-v, accept next character verbatim */
! 1660: { /* allows entry of ^m, ^j, and ^h */
! 1661: int keyt;
! 1662: esc_flag = TRUE;
! 1663: do
! 1664: {
! 1665: keyt = wget_wch(com_win, &in);
! 1666:
! 1667: if (keyt == ERR)
! 1668: exit(0);
! 1669: } while (keyt != OK);
! 1670: }
! 1671: *nam_str = in;
! 1672: g_pos++;
! 1673: if (in < ' ')
! 1674: g_horz += out_char(com_win, in, g_horz);
! 1675: else
! 1676: {
! 1677: g_horz++;
! 1678: if (g_horz < (last_col - 1))
! 1679: waddnwstr(com_win, &in, 1);
! 1680: }
! 1681: nam_str++;
! 1682: }
! 1683: wrefresh(com_win);
! 1684: if (esc_flag)
! 1685: in = '\0';
! 1686: } while ((in != '\n') && (in != '\r'));
! 1687: *nam_str = '\0';
! 1688: nam_str = tmp_string;
! 1689: if (((*nam_str == ' ') || (*nam_str == 9)) && (advance))
! 1690: nam_str = next_word(nam_str);
! 1691: string = malloc((wcslen(nam_str) + 1) * sizeof(wchar_t));
! 1692: wcscpy(string, nam_str);
! 1693: free(tmp_string);
! 1694: wrefresh(com_win);
! 1695: return(string);
! 1696: }
! 1697:
! 1698: int
! 1699: compare(string1, string2, sensitive) /* compare two strings */
! 1700: wchar_t *string1;
! 1701: wchar_t *string2;
! 1702: int sensitive;
! 1703: {
! 1704: wchar_t *strng1;
! 1705: wchar_t *strng2;
! 1706: int tmp;
! 1707: int equal;
! 1708:
! 1709: strng1 = string1;
! 1710: strng2 = string2;
! 1711: tmp = 0;
! 1712: if ((strng1 == NULL) || (strng2 == NULL) || (*strng1 == '\0') || (*strng2 == '\0'))
! 1713: return(FALSE);
! 1714: equal = TRUE;
! 1715: while (equal)
! 1716: {
! 1717: if (sensitive)
! 1718: {
! 1719: if (*strng1 != *strng2)
! 1720: equal = FALSE;
! 1721: }
! 1722: else
! 1723: {
! 1724: if (toupper(*strng1) != toupper(*strng2))
! 1725: equal = FALSE;
! 1726: }
! 1727: strng1++;
! 1728: strng2++;
! 1729: if ((*strng1 == '\0') || (*strng2 == '\0') || (*strng1 == ' ') || (*strng2 == ' '))
! 1730: break;
! 1731: tmp++;
! 1732: }
! 1733: return(equal);
! 1734: }
! 1735:
! 1736: void goto_line(wchar_t *cmd_str)
! 1737: {
! 1738: int number;
! 1739: int i;
! 1740: wchar_t *ptr;
! 1741: char direction = 0;
! 1742: struct text *t_line;
! 1743:
! 1744: ptr = cmd_str;
! 1745: i= 0;
! 1746: while ((*ptr >='0') && (*ptr <= '9'))
! 1747: {
! 1748: i= i * 10 + (*ptr - '0');
! 1749: ptr++;
! 1750: }
! 1751: number = i;
! 1752: i = 0;
! 1753: t_line = curr_line;
! 1754: while ((t_line->line_number > number) && (t_line->prev_line != NULL))
! 1755: {
! 1756: i++;
! 1757: t_line = t_line->prev_line;
! 1758: direction = 'u';
! 1759: }
! 1760: while ((t_line->line_number < number) && (t_line->next_line != NULL))
! 1761: {
! 1762: i++;
! 1763: direction = 'd';
! 1764: t_line = t_line->next_line;
! 1765: }
! 1766: if ((i < 30) && (i > 0))
! 1767: {
! 1768: move_rel(direction, i);
! 1769: }
! 1770: else
! 1771: {
! 1772: curr_line = t_line;
! 1773: point = curr_line->line;
! 1774: position = 1;
! 1775: midscreen((last_line / 2), point);
! 1776: scr_pos = scr_horz;
! 1777: }
! 1778: wmove(com_win, 0, 0);
! 1779: wclrtoeol(com_win);
! 1780: wprintw(com_win, line_num_str, curr_line->line_number);
! 1781: wmove(text_win, scr_vert, (scr_horz - horiz_offset));
! 1782: }
! 1783:
! 1784: void
! 1785: midscreen(line, pnt) /* put current line in middle of screen */
! 1786: int line;
! 1787: wchar_t *pnt;
! 1788: {
! 1789: struct text *mid_line;
! 1790: int i;
! 1791:
! 1792: line = min(line, last_line);
! 1793: mid_line = curr_line;
! 1794: for (i = 0; ((i < line) && (curr_line->prev_line != NULL)); i++)
! 1795: curr_line = curr_line->prev_line;
! 1796: scr_vert = scr_horz = 0;
! 1797: wmove(text_win, 0, 0);
! 1798: draw_screen();
! 1799: scr_vert = i;
! 1800: curr_line = mid_line;
! 1801: scanline(pnt);
! 1802: wmove(text_win, scr_vert, (scr_horz - horiz_offset));
! 1803: }
! 1804:
! 1805: void
! 1806: check_fp() /* open or close files according to flags */
! 1807: {
! 1808: int line_num;
! 1809: int temp;
! 1810: struct stat buf;
! 1811:
! 1812: clear_com_win = TRUE;
! 1813: tmp_vert = scr_vert;
! 1814: tmp_horz = scr_horz;
! 1815: tmp_line = curr_line;
! 1816: if (input_file)
! 1817: in_file_name = tmp_file;
! 1818:
! 1819: temp = stat(tmp_file, &buf);
! 1820: buf.st_mode &= ~07777;
! 1821: if ((temp != -1) && (buf.st_mode != 0100000) && (buf.st_mode != 0))
! 1822: {
! 1823: wprintw(com_win, file_is_dir_msg, tmp_file);
! 1824: wrefresh(com_win);
! 1825: if (input_file)
! 1826: {
! 1827: quit(0);
! 1828: return;
! 1829: }
! 1830: else
! 1831: return;
! 1832: }
! 1833: if ((get_fd = open(tmp_file, O_RDONLY)) == -1)
! 1834: {
! 1835: wmove(com_win, 0, 0);
! 1836: wclrtoeol(com_win);
! 1837: if (input_file)
! 1838: wprintw(com_win, new_file_msg, tmp_file);
! 1839: else
! 1840: wprintw(com_win, cant_open_msg, tmp_file);
! 1841: wrefresh(com_win);
! 1842: wmove(text_win, scr_vert, (scr_horz - horiz_offset));
! 1843: wrefresh(text_win);
! 1844: recv_file = FALSE;
! 1845: input_file = FALSE;
! 1846: return;
! 1847: }
! 1848: else
! 1849: get_file(tmp_file);
! 1850:
! 1851: recv_file = FALSE;
! 1852: line_num = curr_line->line_number;
! 1853: scr_vert = tmp_vert;
! 1854: scr_horz = tmp_horz;
! 1855: if (input_file)
! 1856: curr_line= first_line;
! 1857: else
! 1858: curr_line = tmp_line;
! 1859: point = curr_line->line;
! 1860: draw_screen();
! 1861: if (input_file)
! 1862: {
! 1863: input_file = FALSE;
! 1864: if (start_at_line != NULL)
! 1865: {
! 1866: line_num = watoi(start_at_line) - 1;
! 1867: move_rel('d', line_num);
! 1868: line_num = 0;
! 1869: start_at_line = NULL;
! 1870: }
! 1871: }
! 1872: else
! 1873: {
! 1874: wmove(com_win, 0, 0);
! 1875: wclrtoeol(com_win);
! 1876: text_changes = TRUE;
! 1877: if ((tmp_file != NULL) && (*tmp_file != '\0'))
! 1878: wprintw(com_win, file_read_fin_msg, tmp_file);
! 1879: }
! 1880: wrefresh(com_win);
! 1881: wmove(text_win, scr_vert, (scr_horz - horiz_offset));
! 1882: wrefresh(text_win);
! 1883: }
! 1884:
! 1885: void
! 1886: get_file(file_name) /* read specified file into current buffer */
! 1887: char *file_name;
! 1888: {
! 1889: int can_read; /* file has at least one character */
! 1890: int length; /* length of line read by read */
! 1891: int append; /* should text be appended to current line */
! 1892: struct text *temp_line;
! 1893: char ro_flag = FALSE;
! 1894: char in_string[MAX_FILE+1];
! 1895:
! 1896: if (recv_file) /* if reading a file */
! 1897: {
! 1898: wmove(com_win, 0, 0);
! 1899: wclrtoeol(com_win);
! 1900: wprintw(com_win, reading_file_msg, file_name);
! 1901: if (access(file_name, 2)) /* check permission to write */
! 1902: {
! 1903: if ((errno == ENOTDIR) || (errno == EACCES) || (errno == EROFS) || (errno == ETXTBSY) || (errno == EFAULT))
! 1904: {
! 1905: wprintw(com_win, read_only_msg);
! 1906: ro_flag = TRUE;
! 1907: }
! 1908: }
! 1909: wrefresh(com_win);
! 1910: }
! 1911: if (curr_line->line_length > 1) /* if current line is not blank */
! 1912: {
! 1913: insert_line(FALSE);
! 1914: left(FALSE);
! 1915: append = FALSE;
! 1916: }
! 1917: else
! 1918: append = TRUE;
! 1919: can_read = FALSE; /* test if file has any characters */
! 1920: length = read(get_fd, in_string, sizeof(in_string) - 1);
! 1921: // in DGL, config files are better capped
! 1922: if (length != -1)
! 1923: {
! 1924: can_read = TRUE; /* if set file has at least 1 character */
! 1925: in_string[length] = 0;
! 1926: get_line(length, in_string, &append);
! 1927: }
! 1928: if ((can_read) && (curr_line->line_length == 1) && (curr_line->prev_line))
! 1929: {
! 1930: temp_line = curr_line->prev_line;
! 1931: temp_line->next_line = curr_line->next_line;
! 1932: if (temp_line->next_line != NULL)
! 1933: temp_line->next_line->prev_line = temp_line;
! 1934: if (curr_line->line != NULL)
! 1935: free(curr_line->line);
! 1936: free(curr_line);
! 1937: curr_line = temp_line;
! 1938: }
! 1939: if (input_file) /* if this is the file to be edited display number of lines */
! 1940: {
! 1941: wmove(com_win, 0, 0);
! 1942: wclrtoeol(com_win);
! 1943: wprintw(com_win, file_read_lines_msg, in_file_name, curr_line->line_number);
! 1944: if (ro_flag)
! 1945: wprintw(com_win, read_only_msg);
! 1946: wrefresh(com_win);
! 1947: }
! 1948: else if (can_read) /* not input_file and file is non-zero size */
! 1949: text_changes = TRUE;
! 1950:
! 1951: if (recv_file) /* if reading a file */
! 1952: {
! 1953: in = EOF;
! 1954: }
! 1955: }
! 1956:
! 1957: void
! 1958: get_line(length, in_str, append) /* read string and split into lines */
! 1959: int length; /* length of string read by read */
! 1960: char *in_str; /* string read by read */
! 1961: int *append; /* TRUE if must append more text to end of current line */
! 1962: {
! 1963: wchar_t *str1;
! 1964: wchar_t *str2;
! 1965: int num; /* offset from start of string */
! 1966: int char_count; /* length of new line (or added portion */
! 1967: int temp_counter; /* temporary counter value */
! 1968: struct text *tline; /* temporary pointer to new line */
! 1969: int first_time; /* if TRUE, the first time through the loop */
! 1970: wchar_t in_string[MAX_FILE];
! 1971: length = mbstowcs(in_string, in_str, sizeof(in_string)/sizeof(wchar_t));
! 1972:
! 1973: if (length == -1) {
! 1974: wmove(com_win, 0, 0);
! 1975: wprintw(com_win, "ERROR: Encountered a strange character. --more--");
! 1976: wclrtoeol(com_win);
! 1977: wrefresh(com_win);
! 1978: (void) wget_wch(com_win, &in);
! 1979: resetty();
! 1980: endwin();
! 1981: exit(0);
! 1982: }
! 1983:
! 1984: str2 = in_string;
! 1985: num = 0;
! 1986: first_time = TRUE;
! 1987: while (num < length)
! 1988: {
! 1989: if (!first_time)
! 1990: {
! 1991: if (num < length)
! 1992: {
! 1993: str2++;
! 1994: num++;
! 1995: }
! 1996: }
! 1997: else
! 1998: first_time = FALSE;
! 1999: str1 = str2;
! 2000: char_count = 1;
! 2001: /* find end of line */
! 2002: while ((*str2 != '\n') && (num < length))
! 2003: {
! 2004: str2++;
! 2005: num++;
! 2006: char_count++;
! 2007: }
! 2008: if (!(*append)) /* if not append to current line, insert new one */
! 2009: {
! 2010: tline = txtalloc(); /* allocate data structure for next line */
! 2011: tline->line_number = curr_line->line_number + 1;
! 2012: tline->next_line = curr_line->next_line;
! 2013: tline->prev_line = curr_line;
! 2014: curr_line->next_line = tline;
! 2015: if (tline->next_line != NULL)
! 2016: tline->next_line->prev_line = tline;
! 2017: curr_line = tline;
! 2018: curr_line->line = point = (wchar_t *) malloc(char_count * sizeof(wchar_t));
! 2019: curr_line->line_length = char_count;
! 2020: curr_line->max_length = char_count;
! 2021: }
! 2022: else
! 2023: {
! 2024: point = resiz_line(char_count, curr_line, curr_line->line_length);
! 2025: curr_line->line_length += (char_count - 1);
! 2026: }
! 2027: for (temp_counter = 1; temp_counter < char_count; temp_counter++)
! 2028: {
! 2029: *point = *str1;
! 2030: point++;
! 2031: str1++;
! 2032: }
! 2033: *point = '\0';
! 2034: *append = FALSE;
! 2035: if ((num == length) && (*str2 != '\n'))
! 2036: *append = TRUE;
! 2037: }
! 2038: }
! 2039:
! 2040: void
! 2041: draw_screen() /* redraw the screen from current postion */
! 2042: {
! 2043: struct text *temp_line;
! 2044: wchar_t *line_out;
! 2045: int temp_vert;
! 2046:
! 2047: temp_line = curr_line;
! 2048: temp_vert = scr_vert;
! 2049: wclrtobot(text_win);
! 2050: while ((temp_line != NULL) && (temp_vert <= last_line))
! 2051: {
! 2052: line_out = temp_line->line;
! 2053: draw_line(temp_vert, 0, line_out, 1, temp_line->line_length);
! 2054: temp_vert++;
! 2055: temp_line = temp_line->next_line;
! 2056: }
! 2057: wmove(text_win, temp_vert, 0);
! 2058: wmove(text_win, scr_vert, (scr_horz - horiz_offset));
! 2059: }
! 2060:
! 2061: void
! 2062: ee_finish() /* prepare to exit edit session */
! 2063: {
! 2064: char *file_name = in_file_name;
! 2065:
! 2066: /*
! 2067: | changes made here should be reflected in the 'save'
! 2068: | portion of file_op()
! 2069: */
! 2070:
! 2071: // if ((file_name == NULL) || (*file_name == '\0'))
! 2072: // file_name = get_string(save_file_name_prompt, TRUE);
! 2073:
! 2074: if ((file_name == NULL) || (*file_name == '\0'))
! 2075: {
! 2076: wmove(com_win, 0, 0);
! 2077: wprintw(com_win, file_not_saved_msg);
! 2078: wclrtoeol(com_win);
! 2079: wrefresh(com_win);
! 2080: clear_com_win = TRUE;
! 2081: return;
! 2082: }
! 2083:
! 2084: if (write_file(file_name, -1))
! 2085: {
! 2086: text_changes = FALSE;
! 2087: quit(0);
! 2088: }
! 2089: }
! 2090:
! 2091: int
! 2092: quit(noverify) /* exit editor */
! 2093: int noverify;
! 2094: {
! 2095: wchar_t *ans;
! 2096:
! 2097: touchwin(text_win);
! 2098: wrefresh(text_win);
! 2099: if ((text_changes) && (!noverify))
! 2100: {
! 2101: ans = get_string(changes_made_prompt, TRUE);
! 2102: if (toupper(*ans) == toupper(*yes_char))
! 2103: text_changes = FALSE;
! 2104: else
! 2105: return(0);
! 2106: free(ans);
! 2107: }
! 2108:
! 2109: if (info_window)
! 2110: wrefresh(info_win);
! 2111: wrefresh(com_win);
! 2112: resetty();
! 2113: endwin();
! 2114: putchar('\n');
! 2115: exit(0);
! 2116: }
! 2117:
! 2118: void
! 2119: edit_abort(arg)
! 2120: int arg;
! 2121: {
! 2122: wrefresh(com_win);
! 2123: resetty();
! 2124: endwin();
! 2125: putchar('\n');
! 2126: exit(1);
! 2127: }
! 2128:
! 2129: void
! 2130: delete_text()
! 2131: {
! 2132: while (curr_line->next_line != NULL)
! 2133: curr_line = curr_line->next_line;
! 2134: while (curr_line != first_line)
! 2135: {
! 2136: free(curr_line->line);
! 2137: curr_line = curr_line->prev_line;
! 2138: free(curr_line->next_line);
! 2139: }
! 2140: curr_line->next_line = NULL;
! 2141: *curr_line->line = '\0';
! 2142: curr_line->line_length = 1;
! 2143: curr_line->line_number = 1;
! 2144: point = curr_line->line;
! 2145: scr_pos = scr_vert = scr_horz = 0;
! 2146: position = 1;
! 2147: }
! 2148:
! 2149: /* If fd >= 0, then use the previously opened file. This is a
! 2150: hack to get safe tempfile handling in ispell.*/
! 2151: int write_file(char *file_name, int fd)
! 2152: {
! 2153: wchar_t cr;
! 2154: wchar_t *tmp_point;
! 2155: struct text *out_line;
! 2156: int lines, charac;
! 2157: int temp_pos;
! 2158: int write_flag = TRUE;
! 2159:
! 2160: charac = lines = 0;
! 2161: if ((fd < 0) &&
! 2162: ((in_file_name == NULL) || strcmp(in_file_name, file_name)))
! 2163: {
! 2164: if ((temp_fp = fopen(file_name, "r")))
! 2165: {
! 2166: tmp_point = get_string(file_exists_prompt, TRUE);
! 2167: if (toupper(*tmp_point) == toupper(*yes_char))
! 2168: write_flag = TRUE;
! 2169: else
! 2170: write_flag = FALSE;
! 2171: fclose(temp_fp);
! 2172: free(tmp_point);
! 2173: }
! 2174: }
! 2175:
! 2176: clear_com_win = TRUE;
! 2177:
! 2178: if (write_flag)
! 2179: {
! 2180: if (fd < 0)
! 2181: {
! 2182: temp_fp = fopen(file_name, "w");
! 2183: }
! 2184: else
! 2185: {
! 2186: temp_fp = fdopen(fd, "w");
! 2187: }
! 2188:
! 2189: if (temp_fp == NULL)
! 2190: {
! 2191: clear_com_win = TRUE;
! 2192: wmove(com_win,0,0);
! 2193: wclrtoeol(com_win);
! 2194: wprintw(com_win, create_file_fail_msg, file_name);
! 2195: wrefresh(com_win);
! 2196: return(FALSE);
! 2197: }
! 2198: else
! 2199: {
! 2200: wmove(com_win,0,0);
! 2201: wclrtoeol(com_win);
! 2202: wprintw(com_win, writing_file_msg, file_name);
! 2203: wrefresh(com_win);
! 2204: cr = '\n';
! 2205: out_line = first_line;
! 2206: while (out_line != NULL)
! 2207: {
! 2208: temp_pos = 1;
! 2209: tmp_point= out_line->line;
! 2210: while (temp_pos < out_line->line_length)
! 2211: {
! 2212: fputwc(*tmp_point, temp_fp);
! 2213: tmp_point++;
! 2214: temp_pos++;
! 2215: }
! 2216: charac += out_line->line_length;
! 2217: out_line = out_line->next_line;
! 2218: fputwc(cr, temp_fp);
! 2219: lines++;
! 2220: }
! 2221: fclose(temp_fp);
! 2222: wmove(com_win,0,0);
! 2223: wclrtoeol(com_win);
! 2224: wprintw(com_win, file_written_msg, file_name, lines, charac);
! 2225: wrefresh(com_win);
! 2226: return(TRUE);
! 2227: }
! 2228: }
! 2229: else
! 2230: return(FALSE);
! 2231: }
! 2232:
! 2233: int
! 2234: search(display_message) /* search for string in srch_str */
! 2235: int display_message;
! 2236: {
! 2237: int lines_moved;
! 2238: int iter;
! 2239: int found;
! 2240:
! 2241: if ((srch_str == NULL) || (*srch_str == '\0'))
! 2242: return(FALSE);
! 2243: if (display_message)
! 2244: {
! 2245: wmove(com_win, 0, 0);
! 2246: wclrtoeol(com_win);
! 2247: wprintw(com_win, searching_msg);
! 2248: wrefresh(com_win);
! 2249: clear_com_win = TRUE;
! 2250: }
! 2251: lines_moved = 0;
! 2252: found = FALSE;
! 2253: srch_line = curr_line;
! 2254: srch_1 = point;
! 2255: if (position < curr_line->line_length)
! 2256: srch_1++;
! 2257: iter = position + 1;
! 2258: while ((!found) && (srch_line != NULL))
! 2259: {
! 2260: while ((iter < srch_line->line_length) && (!found))
! 2261: {
! 2262: srch_2 = srch_1;
! 2263: if (case_sen) /* if case sensitive */
! 2264: {
! 2265: srch_3 = srch_str;
! 2266: while ((*srch_2 == *srch_3) && (*srch_3 != '\0'))
! 2267: {
! 2268: found = TRUE;
! 2269: srch_2++;
! 2270: srch_3++;
! 2271: } /* end while */
! 2272: }
! 2273: else /* if not case sensitive */
! 2274: {
! 2275: srch_3 = u_srch_str;
! 2276: while ((toupper(*srch_2) == *srch_3) && (*srch_3 != '\0'))
! 2277: {
! 2278: found = TRUE;
! 2279: srch_2++;
! 2280: srch_3++;
! 2281: }
! 2282: } /* end else */
! 2283: if (!((*srch_3 == '\0') && (found)))
! 2284: {
! 2285: found = FALSE;
! 2286: if (iter < srch_line->line_length)
! 2287: srch_1++;
! 2288: iter++;
! 2289: }
! 2290: }
! 2291: if (!found)
! 2292: {
! 2293: srch_line = srch_line->next_line;
! 2294: if (srch_line != NULL)
! 2295: srch_1 = srch_line->line;
! 2296: iter = 1;
! 2297: lines_moved++;
! 2298: }
! 2299: }
! 2300: if (found)
! 2301: {
! 2302: if (display_message)
! 2303: {
! 2304: wmove(com_win, 0, 0);
! 2305: wclrtoeol(com_win);
! 2306: wrefresh(com_win);
! 2307: }
! 2308: if (lines_moved == 0)
! 2309: {
! 2310: while (position < iter)
! 2311: right(TRUE);
! 2312: }
! 2313: else
! 2314: {
! 2315: if (lines_moved < 30)
! 2316: {
! 2317: move_rel('d', lines_moved);
! 2318: while (position < iter)
! 2319: right(TRUE);
! 2320: }
! 2321: else
! 2322: {
! 2323: curr_line = srch_line;
! 2324: point = srch_1;
! 2325: position = iter;
! 2326: scanline(point);
! 2327: scr_pos = scr_horz;
! 2328: midscreen((last_line / 2), point);
! 2329: }
! 2330: }
! 2331: }
! 2332: else
! 2333: {
! 2334: if (display_message)
! 2335: {
! 2336: wmove(com_win, 0, 0);
! 2337: wclrtoeol(com_win);
! 2338: wprintw(com_win, str_not_found_msg, srch_str);
! 2339: wrefresh(com_win);
! 2340: }
! 2341: wmove(text_win, scr_vert,(scr_horz - horiz_offset));
! 2342: }
! 2343: return(found);
! 2344: }
! 2345:
! 2346: void
! 2347: search_prompt() /* prompt and read search string (srch_str) */
! 2348: {
! 2349: if (srch_str != NULL)
! 2350: free(srch_str);
! 2351: if ((u_srch_str != NULL) && (*u_srch_str != '\0'))
! 2352: free(u_srch_str);
! 2353: srch_str = get_string(search_prompt_str, FALSE);
! 2354: gold = FALSE;
! 2355: srch_3 = srch_str;
! 2356: srch_1 = u_srch_str = (wchar_t*)malloc((wcslen(srch_str) + 1) * sizeof(wchar_t));
! 2357: while (*srch_3 != '\0')
! 2358: {
! 2359: *srch_1 = toupper(*srch_3);
! 2360: srch_1++;
! 2361: srch_3++;
! 2362: }
! 2363: *srch_1 = '\0';
! 2364: search(TRUE);
! 2365: }
! 2366:
! 2367: void
! 2368: del_char() /* delete current character */
! 2369: {
! 2370: in = 8; /* backspace */
! 2371: if (position < curr_line->line_length) /* if not end of line */
! 2372: {
! 2373: if ((*point > 127) && ((curr_line->line_length - position) >= 2))
! 2374: {
! 2375: point++;
! 2376: position++;
! 2377: }
! 2378: position++;
! 2379: point++;
! 2380: scanline(point);
! 2381: delete(TRUE);
! 2382: }
! 2383: else
! 2384: {
! 2385: right(FALSE);
! 2386: delete(FALSE);
! 2387: }
! 2388: }
! 2389:
! 2390: void
! 2391: undel_char() /* undelete last deleted character */
! 2392: {
! 2393: if (d_char[0] == '\n') /* insert line if last del_char deleted eol */
! 2394: insert_line(TRUE);
! 2395: else
! 2396: {
! 2397: in = d_char[0];
! 2398: insert(in);
! 2399: if (d_char[1] != '\0')
! 2400: {
! 2401: in = d_char[1];
! 2402: insert(in);
! 2403: }
! 2404: }
! 2405: }
! 2406:
! 2407: void
! 2408: del_word() /* delete word in front of cursor */
! 2409: {
! 2410: int tposit;
! 2411: int difference;
! 2412: wchar_t *d_word2;
! 2413: wchar_t *d_word3;
! 2414: wchar_t tmp_char[3];
! 2415:
! 2416: if (d_word != NULL)
! 2417: free(d_word);
! 2418: d_word = (wchar_t*)malloc(curr_line->line_length * sizeof(wchar_t));
! 2419: tmp_char[0] = d_char[0];
! 2420: tmp_char[1] = d_char[1];
! 2421: tmp_char[2] = d_char[2];
! 2422: d_word3 = point;
! 2423: d_word2 = d_word;
! 2424: tposit = position;
! 2425: while ((tposit < curr_line->line_length) &&
! 2426: ((*d_word3 != ' ') && (*d_word3 != '\t')))
! 2427: {
! 2428: tposit++;
! 2429: *d_word2 = *d_word3;
! 2430: d_word2++;
! 2431: d_word3++;
! 2432: }
! 2433: while ((tposit < curr_line->line_length) &&
! 2434: ((*d_word3 == ' ') || (*d_word3 == '\t')))
! 2435: {
! 2436: tposit++;
! 2437: *d_word2 = *d_word3;
! 2438: d_word2++;
! 2439: d_word3++;
! 2440: }
! 2441: *d_word2 = '\0';
! 2442: d_wrd_len = difference = d_word2 - d_word;
! 2443: d_word2 = point;
! 2444: while (tposit < curr_line->line_length)
! 2445: {
! 2446: tposit++;
! 2447: *d_word2 = *d_word3;
! 2448: d_word2++;
! 2449: d_word3++;
! 2450: }
! 2451: curr_line->line_length -= difference;
! 2452: *d_word2 = '\0';
! 2453: draw_line(scr_vert, scr_horz,point,position,curr_line->line_length);
! 2454: d_char[0] = tmp_char[0];
! 2455: d_char[1] = tmp_char[1];
! 2456: d_char[2] = tmp_char[2];
! 2457: text_changes = TRUE;
! 2458: formatted = FALSE;
! 2459: }
! 2460:
! 2461: void
! 2462: undel_word() /* undelete last deleted word */
! 2463: {
! 2464: int temp;
! 2465: int tposit;
! 2466: wchar_t *tmp_old_ptr;
! 2467: wchar_t *tmp_space;
! 2468: wchar_t *tmp_ptr;
! 2469: wchar_t *d_word_ptr;
! 2470:
! 2471: /*
! 2472: | resize line to handle undeleted word
! 2473: */
! 2474: if ((curr_line->max_length - (curr_line->line_length + d_wrd_len)) < 5)
! 2475: point = resiz_line(d_wrd_len, curr_line, position);
! 2476: tmp_ptr = tmp_space = (wchar_t*)malloc((curr_line->line_length + d_wrd_len) * sizeof(wchar_t));
! 2477: d_word_ptr = d_word;
! 2478: temp = 1;
! 2479: /*
! 2480: | copy d_word contents into temp space
! 2481: */
! 2482: while (temp <= d_wrd_len)
! 2483: {
! 2484: temp++;
! 2485: *tmp_ptr = *d_word_ptr;
! 2486: tmp_ptr++;
! 2487: d_word_ptr++;
! 2488: }
! 2489: tmp_old_ptr = point;
! 2490: tposit = position;
! 2491: /*
! 2492: | copy contents of line from curent position to eol into
! 2493: | temp space
! 2494: */
! 2495: while (tposit < curr_line->line_length)
! 2496: {
! 2497: temp++;
! 2498: tposit++;
! 2499: *tmp_ptr = *tmp_old_ptr;
! 2500: tmp_ptr++;
! 2501: tmp_old_ptr++;
! 2502: }
! 2503: curr_line->line_length += d_wrd_len;
! 2504: tmp_old_ptr = point;
! 2505: *tmp_ptr = '\0';
! 2506: tmp_ptr = tmp_space;
! 2507: tposit = 1;
! 2508: /*
! 2509: | now copy contents from temp space back to original line
! 2510: */
! 2511: while (tposit < temp)
! 2512: {
! 2513: tposit++;
! 2514: *tmp_old_ptr = *tmp_ptr;
! 2515: tmp_ptr++;
! 2516: tmp_old_ptr++;
! 2517: }
! 2518: *tmp_old_ptr = '\0';
! 2519: free(tmp_space);
! 2520: draw_line(scr_vert, scr_horz, point, position, curr_line->line_length);
! 2521: }
! 2522:
! 2523: void
! 2524: del_line() /* delete from cursor to end of line */
! 2525: {
! 2526: wchar_t *dl1;
! 2527: wchar_t *dl2;
! 2528: int tposit;
! 2529:
! 2530: if (d_line != NULL)
! 2531: free(d_line);
! 2532: d_line = (wchar_t*)malloc(curr_line->line_length * sizeof(wchar_t));
! 2533: dl1 = d_line;
! 2534: dl2 = point;
! 2535: tposit = position;
! 2536: while (tposit < curr_line->line_length)
! 2537: {
! 2538: *dl1 = *dl2;
! 2539: dl1++;
! 2540: dl2++;
! 2541: tposit++;
! 2542: }
! 2543: dlt_line->line_length = 1 + tposit - position;
! 2544: *dl1 = *point = '\0';
! 2545: curr_line->line_length = position;
! 2546: wclrtoeol(text_win);
! 2547: if (curr_line->next_line != NULL)
! 2548: {
! 2549: right(FALSE);
! 2550: delete(FALSE);
! 2551: }
! 2552: text_changes = TRUE;
! 2553: }
! 2554:
! 2555: void
! 2556: undel_line() /* undelete last deleted line */
! 2557: {
! 2558: wchar_t *ud1;
! 2559: wchar_t *ud2;
! 2560: int tposit;
! 2561:
! 2562: if (dlt_line->line_length == 0)
! 2563: return;
! 2564:
! 2565: insert_line(TRUE);
! 2566: left(TRUE);
! 2567: point = resiz_line(dlt_line->line_length, curr_line, position);
! 2568: curr_line->line_length += dlt_line->line_length - 1;
! 2569: ud1 = point;
! 2570: ud2 = d_line;
! 2571: tposit = 1;
! 2572: while (tposit < dlt_line->line_length)
! 2573: {
! 2574: tposit++;
! 2575: *ud1 = *ud2;
! 2576: ud1++;
! 2577: ud2++;
! 2578: }
! 2579: *ud1 = '\0';
! 2580: draw_line(scr_vert, scr_horz,point,position,curr_line->line_length);
! 2581: }
! 2582:
! 2583: void
! 2584: adv_word() /* advance to next word */
! 2585: {
! 2586: while ((position < curr_line->line_length) && ((*point != 32) && (*point != 9)))
! 2587: right(TRUE);
! 2588: while ((position < curr_line->line_length) && ((*point == 32) || (*point == 9)))
! 2589: right(TRUE);
! 2590: }
! 2591:
! 2592: void move_rel(char direction, int lines) /* move relative to current line */
! 2593: {
! 2594: int i;
! 2595: wchar_t *tmp;
! 2596:
! 2597: if (direction == 'u')
! 2598: {
! 2599: scr_pos = 0;
! 2600: while (position > 1)
! 2601: left(TRUE);
! 2602: for (i = 0; i < lines; i++)
! 2603: {
! 2604: up();
! 2605: }
! 2606: if ((last_line > 5) && ( scr_vert < 4))
! 2607: {
! 2608: tmp = point;
! 2609: tmp_line = curr_line;
! 2610: for (i= 0;(i<5)&&(curr_line->prev_line != NULL); i++)
! 2611: {
! 2612: up();
! 2613: }
! 2614: scr_vert = scr_vert + i;
! 2615: curr_line = tmp_line;
! 2616: point = tmp;
! 2617: scanline(point);
! 2618: }
! 2619: }
! 2620: else
! 2621: {
! 2622: if ((position != 1) && (curr_line->next_line != NULL))
! 2623: {
! 2624: nextline();
! 2625: scr_pos = scr_horz = 0;
! 2626: if (horiz_offset)
! 2627: {
! 2628: horiz_offset = 0;
! 2629: midscreen(scr_vert, point);
! 2630: }
! 2631: }
! 2632: else
! 2633: adv_line();
! 2634: for (i = 1; i < lines; i++)
! 2635: {
! 2636: down();
! 2637: }
! 2638: if ((last_line > 10) && (scr_vert > (last_line - 5)))
! 2639: {
! 2640: tmp = point;
! 2641: tmp_line = curr_line;
! 2642: for (i=0; (i<5) && (curr_line->next_line != NULL); i++)
! 2643: {
! 2644: down();
! 2645: }
! 2646: scr_vert = scr_vert - i;
! 2647: curr_line = tmp_line;
! 2648: point = tmp;
! 2649: scanline(point);
! 2650: }
! 2651: }
! 2652: wmove(text_win, scr_vert, (scr_horz - horiz_offset));
! 2653: }
! 2654:
! 2655: void
! 2656: eol() /* go to end of line */
! 2657: {
! 2658: if (position < curr_line->line_length)
! 2659: {
! 2660: while (position < curr_line->line_length)
! 2661: right(TRUE);
! 2662: }
! 2663: else if (curr_line->next_line != NULL)
! 2664: {
! 2665: right(TRUE);
! 2666: while (position < curr_line->line_length)
! 2667: right(TRUE);
! 2668: }
! 2669: }
! 2670:
! 2671: void
! 2672: bol() /* move to beginning of line */
! 2673: {
! 2674: if (point != curr_line->line)
! 2675: {
! 2676: while (point != curr_line->line)
! 2677: left(TRUE);
! 2678: }
! 2679: else if (curr_line->prev_line != NULL)
! 2680: {
! 2681: scr_pos = 0;
! 2682: up();
! 2683: }
! 2684: }
! 2685:
! 2686: void
! 2687: adv_line() /* advance to beginning of next line */
! 2688: {
! 2689: if ((point != curr_line->line) || (scr_pos > 0))
! 2690: {
! 2691: while (position < curr_line->line_length)
! 2692: right(TRUE);
! 2693: right(TRUE);
! 2694: }
! 2695: else if (curr_line->next_line != NULL)
! 2696: {
! 2697: scr_pos = 0;
! 2698: down();
! 2699: }
! 2700: }
! 2701:
! 2702: void
! 2703: set_up_term() /* set up the terminal for operating with ae */
! 2704: {
! 2705: if (!curses_initialized)
! 2706: {
! 2707: initscr();
! 2708: savetty();
! 2709: noecho();
! 2710: raw();
! 2711: nonl();
! 2712: curses_initialized = TRUE;
! 2713: }
! 2714:
! 2715: if (((LINES > 15) && (COLS >= 80)) && info_window)
! 2716: last_line = LINES - 8;
! 2717: else
! 2718: {
! 2719: info_window = FALSE;
! 2720: last_line = LINES - 2;
! 2721: }
! 2722:
! 2723: idlok(stdscr, TRUE);
! 2724: com_win = newwin(1, COLS, (LINES - 1), 0);
! 2725: keypad(com_win, TRUE);
! 2726: idlok(com_win, TRUE);
! 2727: wrefresh(com_win);
! 2728: if (!info_window)
! 2729: text_win = newwin((LINES - 1), COLS, 0, 0);
! 2730: else
! 2731: text_win = newwin((LINES - 7), COLS, 6, 0);
! 2732: keypad(text_win, TRUE);
! 2733: idlok(text_win, TRUE);
! 2734: wrefresh(text_win);
! 2735: help_win = newwin((LINES - 1), COLS, 0, 0);
! 2736: keypad(help_win, TRUE);
! 2737: idlok(help_win, TRUE);
! 2738: if (info_window)
! 2739: {
! 2740: info_type = CONTROL_KEYS;
! 2741: info_win = newwin(6, COLS, 0, 0);
! 2742: werase(info_win);
! 2743: paint_info_win();
! 2744: }
! 2745:
! 2746: last_col = COLS - 1;
! 2747: local_LINES = LINES;
! 2748: local_COLS = COLS;
! 2749: }
! 2750:
! 2751: void
! 2752: resize_check()
! 2753: {
! 2754: if ((LINES == local_LINES) && (COLS == local_COLS))
! 2755: return;
! 2756:
! 2757: if (info_window)
! 2758: delwin(info_win);
! 2759: delwin(text_win);
! 2760: delwin(com_win);
! 2761: delwin(help_win);
! 2762: set_up_term();
! 2763: redraw();
! 2764: wrefresh(text_win);
! 2765: }
! 2766:
! 2767: static char item_alpha[] = "abcdefghijklmnopqrstuvwxyz0123456789 ";
! 2768:
! 2769: int menu_op(struct menu_entries menu_list[])
! 2770: {
! 2771: WINDOW *temp_win;
! 2772: int max_width, max_height;
! 2773: int x_off, y_off;
! 2774: int counter;
! 2775: int length;
! 2776: int input;
! 2777: int temp = 0;
! 2778: int list_size;
! 2779: int top_offset; /* offset from top where menu items start */
! 2780: int vert_size; /* vertical size for menu list item display */
! 2781: int off_start = 1; /* offset from start of menu items to start display */
! 2782:
! 2783:
! 2784: /*
! 2785: | determine number and width of menu items
! 2786: */
! 2787:
! 2788: list_size = 1;
! 2789: while (menu_list[list_size + 1].item_string != NULL)
! 2790: list_size++;
! 2791: max_width = 0;
! 2792: for (counter = 0; counter <= list_size; counter++)
! 2793: {
! 2794: if ((length = wcslen(menu_list[counter].item_string)) > max_width)
! 2795: max_width = length;
! 2796: }
! 2797: max_width += 3;
! 2798: max_width = max(max_width, wcslen(menu_cancel_msg));
! 2799: max_width = max(max_width, max(wcslen(more_above_str), wcslen(more_below_str)));
! 2800: max_width += 6;
! 2801:
! 2802: /*
! 2803: | make sure that window is large enough to handle menu
! 2804: | if not, print error message and return to calling function
! 2805: */
! 2806:
! 2807: if (max_width > COLS)
! 2808: {
! 2809: wmove(com_win, 0, 0);
! 2810: werase(com_win);
! 2811: wprintw(com_win, menu_too_lrg_msg);
! 2812: wrefresh(com_win);
! 2813: clear_com_win = TRUE;
! 2814: return(0);
! 2815: }
! 2816:
! 2817: top_offset = 0;
! 2818:
! 2819: if (list_size > LINES)
! 2820: {
! 2821: max_height = LINES;
! 2822: if (max_height > 11)
! 2823: vert_size = max_height - 8;
! 2824: else
! 2825: vert_size = max_height;
! 2826: }
! 2827: else
! 2828: {
! 2829: vert_size = list_size;
! 2830: max_height = list_size;
! 2831: }
! 2832:
! 2833: if (LINES >= (vert_size + 8))
! 2834: {
! 2835: if (menu_list[0].argument != MENU_WARN)
! 2836: max_height = vert_size + 8;
! 2837: else
! 2838: max_height = vert_size + 7;
! 2839: top_offset = 4;
! 2840: }
! 2841: x_off = (COLS - max_width) / 2;
! 2842: y_off = (LINES - max_height - 1) / 2;
! 2843: temp_win = newwin(max_height, max_width, y_off, x_off);
! 2844: keypad(temp_win, TRUE);
! 2845:
! 2846: paint_menu(menu_list, max_width, max_height, list_size, top_offset, temp_win, off_start, vert_size);
! 2847:
! 2848: counter = 1;
! 2849: do
! 2850: {
! 2851: int keyt;
! 2852: if (off_start > 2)
! 2853: wmove(temp_win, (1 + counter + top_offset - off_start), 3);
! 2854: else
! 2855: wmove(temp_win, (counter + top_offset - off_start), 3);
! 2856:
! 2857: wrefresh(temp_win);
! 2858: keyt = wget_wch(temp_win, &in);
! 2859: input = in;
! 2860: if (keyt == ERR)
! 2861: exit(0);
! 2862:
! 2863: if (keyt == OK && isalnum(tolower(input)))
! 2864: {
! 2865: if (isalpha(tolower(input)))
! 2866: {
! 2867: temp = 1 + tolower(input) - 'a';
! 2868: }
! 2869: else if (isdigit(input))
! 2870: {
! 2871: temp = (2 + 'z' - 'a') + (input - '0');
! 2872: }
! 2873:
! 2874: if (temp <= list_size)
! 2875: {
! 2876: input = '\n';
! 2877: counter = temp;
! 2878: }
! 2879: }
! 2880: else if (keyt == OK)
! 2881: {
! 2882: switch (input)
! 2883: {
! 2884: case ' ': /* space */
! 2885: case '\004': /* ^d, down */
! 2886: counter++;
! 2887: if (counter > list_size)
! 2888: counter = 1;
! 2889: break;
! 2890: case '\010': /* ^h, backspace*/
! 2891: case '\025': /* ^u, up */
! 2892: case 127: /* ^?, delete */
! 2893: counter--;
! 2894: if (counter == 0)
! 2895: counter = list_size;
! 2896: break;
! 2897: case '\033': /* escape key */
! 2898: if (menu_list[0].argument != MENU_WARN)
! 2899: counter = 0;
! 2900: break;
! 2901: case '\014': /* ^l */
! 2902: case '\022': /* ^r, redraw */
! 2903: paint_menu(menu_list, max_width, max_height,
! 2904: list_size, top_offset, temp_win,
! 2905: off_start, vert_size);
! 2906: break;
! 2907: default:
! 2908: break;
! 2909: }
! 2910: }
! 2911: else
! 2912: {
! 2913: switch (input)
! 2914: {
! 2915: case KEY_RIGHT:
! 2916: case KEY_DOWN:
! 2917: counter++;
! 2918: if (counter > list_size)
! 2919: counter = 1;
! 2920: break;
! 2921: case 127: /* ^?, delete */
! 2922: case KEY_BACKSPACE:
! 2923: case KEY_LEFT:
! 2924: case KEY_UP:
! 2925: counter--;
! 2926: if (counter == 0)
! 2927: counter = list_size;
! 2928: break;
! 2929: case '\033': /* escape key */
! 2930: if (menu_list[0].argument != MENU_WARN)
! 2931: counter = 0;
! 2932: break;
! 2933: case '\014': /* ^l */
! 2934: case '\022': /* ^r, redraw */
! 2935: paint_menu(menu_list, max_width, max_height,
! 2936: list_size, top_offset, temp_win,
! 2937: off_start, vert_size);
! 2938: break;
! 2939: default:
! 2940: break;
! 2941: }
! 2942: }
! 2943:
! 2944: if (((list_size - off_start) >= (vert_size - 1)) &&
! 2945: (counter > (off_start + vert_size - 3)) &&
! 2946: (off_start > 1))
! 2947: {
! 2948: if (counter == list_size)
! 2949: off_start = (list_size - vert_size) + 2;
! 2950: else
! 2951: off_start++;
! 2952:
! 2953: paint_menu(menu_list, max_width, max_height,
! 2954: list_size, top_offset, temp_win, off_start,
! 2955: vert_size);
! 2956: }
! 2957: else if ((list_size != vert_size) &&
! 2958: (counter > (off_start + vert_size - 2)))
! 2959: {
! 2960: if (counter == list_size)
! 2961: off_start = 2 + (list_size - vert_size);
! 2962: else if (off_start == 1)
! 2963: off_start = 3;
! 2964: else
! 2965: off_start++;
! 2966:
! 2967: paint_menu(menu_list, max_width, max_height,
! 2968: list_size, top_offset, temp_win, off_start,
! 2969: vert_size);
! 2970: }
! 2971: else if (counter < off_start)
! 2972: {
! 2973: if (counter <= 2)
! 2974: off_start = 1;
! 2975: else
! 2976: off_start = counter;
! 2977:
! 2978: paint_menu(menu_list, max_width, max_height,
! 2979: list_size, top_offset, temp_win, off_start,
! 2980: vert_size);
! 2981: }
! 2982: }
! 2983: while ((input != '\r') && (input != '\n') && (counter != 0));
! 2984:
! 2985: werase(temp_win);
! 2986: wrefresh(temp_win);
! 2987: delwin(temp_win);
! 2988:
! 2989: if ((menu_list[counter].procedure != NULL) ||
! 2990: (menu_list[counter].iprocedure != NULL) ||
! 2991: (menu_list[counter].nprocedure != NULL))
! 2992: {
! 2993: if (menu_list[counter].argument != -1)
! 2994: (*menu_list[counter].iprocedure)(menu_list[counter].argument);
! 2995: else if (menu_list[counter].ptr_argument != NULL)
! 2996: (*menu_list[counter].procedure)(menu_list[counter].ptr_argument);
! 2997: else
! 2998: (*menu_list[counter].nprocedure)();
! 2999: }
! 3000:
! 3001: if (info_window)
! 3002: paint_info_win();
! 3003: redraw();
! 3004:
! 3005: return(counter);
! 3006: }
! 3007:
! 3008: void
! 3009: paint_menu(menu_list, max_width, max_height, list_size, top_offset, menu_win,
! 3010: off_start, vert_size)
! 3011: struct menu_entries menu_list[];
! 3012: int max_width, max_height, list_size, top_offset;
! 3013: WINDOW *menu_win;
! 3014: int off_start, vert_size;
! 3015: {
! 3016: int counter, temp_int;
! 3017:
! 3018: werase(menu_win);
! 3019:
! 3020: /*
! 3021: | output top and bottom portions of menu box only if window
! 3022: | large enough
! 3023: */
! 3024:
! 3025: if (max_height > vert_size)
! 3026: {
! 3027: wmove(menu_win, 1, 1);
! 3028: if (!nohighlight)
! 3029: wstandout(menu_win);
! 3030: waddch(menu_win, '+');
! 3031: for (counter = 0; counter < (max_width - 4); counter++)
! 3032: waddch(menu_win, '-');
! 3033: waddch(menu_win, '+');
! 3034:
! 3035: wmove(menu_win, (max_height - 2), 1);
! 3036: waddch(menu_win, '+');
! 3037: for (counter = 0; counter < (max_width - 4); counter++)
! 3038: waddch(menu_win, '-');
! 3039: waddch(menu_win, '+');
! 3040: wstandend(menu_win);
! 3041: wmove(menu_win, 2, 3);
! 3042: waddwstr(menu_win, menu_list[0].item_string);
! 3043: wmove(menu_win, (max_height - 3), 3);
! 3044: if (menu_list[0].argument != MENU_WARN)
! 3045: waddwstr(menu_win, menu_cancel_msg);
! 3046: }
! 3047: if (!nohighlight)
! 3048: wstandout(menu_win);
! 3049:
! 3050: for (counter = 0; counter < (vert_size + top_offset); counter++)
! 3051: {
! 3052: if (top_offset == 4)
! 3053: {
! 3054: temp_int = counter + 2;
! 3055: }
! 3056: else
! 3057: temp_int = counter;
! 3058:
! 3059: wmove(menu_win, temp_int, 1);
! 3060: waddch(menu_win, '|');
! 3061: wmove(menu_win, temp_int, (max_width - 2));
! 3062: waddch(menu_win, '|');
! 3063: }
! 3064: wstandend(menu_win);
! 3065:
! 3066: if (list_size > vert_size)
! 3067: {
! 3068: if (off_start >= 3)
! 3069: {
! 3070: temp_int = 1;
! 3071: wmove(menu_win, top_offset, 3);
! 3072: waddwstr(menu_win, more_above_str);
! 3073: }
! 3074: else
! 3075: temp_int = 0;
! 3076:
! 3077: for (counter = off_start;
! 3078: ((temp_int + counter - off_start) < (vert_size - 1));
! 3079: counter++)
! 3080: {
! 3081: wmove(menu_win, (top_offset + temp_int +
! 3082: (counter - off_start)), 3);
! 3083: if (list_size > 1)
! 3084: wprintw(menu_win, "%c) ", item_alpha[min((counter - 1), max_alpha_char)]);
! 3085: waddwstr(menu_win, menu_list[counter].item_string);
! 3086: }
! 3087:
! 3088: wmove(menu_win, (top_offset + (vert_size - 1)), 3);
! 3089:
! 3090: if (counter == list_size)
! 3091: {
! 3092: if (list_size > 1)
! 3093: wprintw(menu_win, "%c) ", item_alpha[min((counter - 1), max_alpha_char)]);
! 3094: waddwstr(menu_win, menu_list[counter].item_string);
! 3095: }
! 3096: else
! 3097: waddwstr(menu_win, more_below_str);
! 3098: }
! 3099: else
! 3100: {
! 3101: for (counter = 1; counter <= list_size; counter++)
! 3102: {
! 3103: wmove(menu_win, (top_offset + counter - 1), 3);
! 3104: if (list_size > 1)
! 3105: wprintw(menu_win, "%c) ", item_alpha[min((counter - 1), max_alpha_char)]);
! 3106: waddwstr(menu_win, menu_list[counter].item_string);
! 3107: }
! 3108: }
! 3109: }
! 3110:
! 3111: void
! 3112: help()
! 3113: {
! 3114: int counter, dummy;
! 3115:
! 3116: werase(help_win);
! 3117: clearok(help_win, TRUE);
! 3118: for (counter = 0; counter < 22; counter++)
! 3119: {
! 3120: wmove(help_win, counter, 0);
! 3121: waddwstr(help_win, (emacs_keys_mode) ?
! 3122: emacs_help_text[counter] : help_text[counter]);
! 3123: }
! 3124: wrefresh(help_win);
! 3125: werase(com_win);
! 3126: wmove(com_win, 0, 0);
! 3127: waddwstr(com_win, press_any_key_msg);
! 3128: wrefresh(com_win);
! 3129: counter = wget_wch(com_win, &dummy);
! 3130: if (counter == ERR)
! 3131: exit(0);
! 3132: werase(com_win);
! 3133: wmove(com_win, 0, 0);
! 3134: werase(help_win);
! 3135: wrefresh(help_win);
! 3136: wrefresh(com_win);
! 3137: redraw();
! 3138: }
! 3139:
! 3140: void
! 3141: paint_info_win()
! 3142: {
! 3143: int counter;
! 3144:
! 3145: if (!info_window)
! 3146: return;
! 3147:
! 3148: werase(info_win);
! 3149: for (counter = 0; counter < 5; counter++)
! 3150: {
! 3151: wmove(info_win, counter, 0);
! 3152: wclrtoeol(info_win);
! 3153: if (info_type == CONTROL_KEYS)
! 3154: waddwstr(info_win, (emacs_keys_mode) ?
! 3155: emacs_control_keys[counter] : control_keys[counter]);
! 3156: else if (info_type == COMMANDS)
! 3157: waddwstr(info_win, command_strings[counter]);
! 3158: }
! 3159: wmove(info_win, 5, 0);
! 3160: if (!nohighlight)
! 3161: wstandout(info_win);
! 3162: waddstr(info_win, "===============================================================================");
! 3163: wstandend(info_win);
! 3164: wrefresh(info_win);
! 3165: }
! 3166:
! 3167: void
! 3168: no_info_window()
! 3169: {
! 3170: if (!info_window)
! 3171: return;
! 3172: delwin(info_win);
! 3173: delwin(text_win);
! 3174: info_window = FALSE;
! 3175: last_line = LINES - 2;
! 3176: text_win = newwin((LINES - 1), COLS, 0, 0);
! 3177: keypad(text_win, TRUE);
! 3178: idlok(text_win, TRUE);
! 3179: clearok(text_win, TRUE);
! 3180: midscreen(scr_vert, point);
! 3181: wrefresh(text_win);
! 3182: clear_com_win = TRUE;
! 3183: }
! 3184:
! 3185: void
! 3186: create_info_window()
! 3187: {
! 3188: if (info_window)
! 3189: return;
! 3190: last_line = LINES - 8;
! 3191: delwin(text_win);
! 3192: text_win = newwin((LINES - 7), COLS, 6, 0);
! 3193: keypad(text_win, TRUE);
! 3194: idlok(text_win, TRUE);
! 3195: werase(text_win);
! 3196: info_window = TRUE;
! 3197: info_win = newwin(6, COLS, 0, 0);
! 3198: werase(info_win);
! 3199: info_type = CONTROL_KEYS;
! 3200: midscreen(min(scr_vert, last_line), point);
! 3201: clearok(info_win, TRUE);
! 3202: paint_info_win();
! 3203: wrefresh(text_win);
! 3204: clear_com_win = TRUE;
! 3205: }
! 3206:
! 3207: int
! 3208: file_op(arg)
! 3209: int arg;
! 3210: {
! 3211: char *string;
! 3212: int flag;
! 3213:
! 3214: if (arg == SAVE_FILE)
! 3215: {
! 3216: /*
! 3217: | changes made here should be reflected in ee_finish()
! 3218: */
! 3219:
! 3220: if (in_file_name)
! 3221: flag = TRUE;
! 3222: else
! 3223: flag = FALSE;
! 3224:
! 3225: string = in_file_name;
! 3226: // if ((string == NULL) || (*string == '\0'))
! 3227: // string = get_string(save_file_name_prompt, TRUE);
! 3228: if ((string == NULL) || (*string == '\0'))
! 3229: {
! 3230: wmove(com_win, 0, 0);
! 3231: wprintw(com_win, file_not_saved_msg);
! 3232: wclrtoeol(com_win);
! 3233: wrefresh(com_win);
! 3234: clear_com_win = TRUE;
! 3235: return(0);
! 3236: }
! 3237: if (write_file(string, -1))
! 3238: {
! 3239: in_file_name = string;
! 3240: text_changes = FALSE;
! 3241: }
! 3242: else if (!flag)
! 3243: free(string);
! 3244: }
! 3245: return(0);
! 3246: }
! 3247:
! 3248: void
! 3249: leave_op()
! 3250: {
! 3251: if (text_changes)
! 3252: {
! 3253: menu_op(leave_menu);
! 3254: }
! 3255: else
! 3256: quit(TRUE);
! 3257: }
! 3258:
! 3259: void
! 3260: redraw()
! 3261: {
! 3262: if (info_window)
! 3263: {
! 3264: clearok(info_win, TRUE);
! 3265: paint_info_win();
! 3266: }
! 3267: else
! 3268: clearok(text_win, TRUE);
! 3269: midscreen(scr_vert, point);
! 3270: }
! 3271:
! 3272: /*
! 3273: | The following routines will "format" a paragraph (as defined by a
! 3274: | block of text with blank lines before and after the block).
! 3275: */
! 3276:
! 3277: int
! 3278: Blank_Line(test_line) /* test if line has any non-space characters */
! 3279: struct text *test_line;
! 3280: {
! 3281: wchar_t *line;
! 3282: int length;
! 3283:
! 3284: if (test_line == NULL)
! 3285: return(TRUE);
! 3286:
! 3287: length = 1;
! 3288: line = test_line->line;
! 3289:
! 3290: /*
! 3291: | To handle troff/nroff documents, consider a line with a
! 3292: | period ('.') in the first column to be blank. To handle mail
! 3293: | messages with included text, consider a line with a '>' blank.
! 3294: */
! 3295:
! 3296: if ((*line == '.') || (*line == '>'))
! 3297: return(TRUE);
! 3298:
! 3299: while (((*line == ' ') || (*line == '\t')) && (length < test_line->line_length))
! 3300: {
! 3301: length++;
! 3302: line++;
! 3303: }
! 3304: if (length != test_line->line_length)
! 3305: return(FALSE);
! 3306: else
! 3307: return(TRUE);
! 3308: }
! 3309:
! 3310: void
! 3311: echo_string(string) /* echo the given string */
! 3312: wchar_t *string;
! 3313: {
! 3314: wchar_t *temp;
! 3315: int Counter;
! 3316:
! 3317: temp = string;
! 3318: while (*temp != '\0')
! 3319: {
! 3320: if (*temp == '\\')
! 3321: {
! 3322: temp++;
! 3323: if (*temp == 'n')
! 3324: putchar('\n');
! 3325: else if (*temp == 't')
! 3326: putchar('\t');
! 3327: else if (*temp == 'b')
! 3328: putchar('\b');
! 3329: else if (*temp == 'r')
! 3330: putchar('\r');
! 3331: else if (*temp == 'f')
! 3332: putchar('\f');
! 3333: else if ((*temp == 'e') || (*temp == 'E'))
! 3334: putchar('\033'); /* escape */
! 3335: else if (*temp == '\\')
! 3336: putchar('\\');
! 3337: else if (*temp == '\'')
! 3338: putchar('\'');
! 3339: else if ((*temp >= '0') && (*temp <= '9'))
! 3340: {
! 3341: Counter = 0;
! 3342: while ((*temp >= '0') && (*temp <= '9'))
! 3343: {
! 3344: Counter = (8 * Counter) + (*temp - '0');
! 3345: temp++;
! 3346: }
! 3347: putchar(Counter);
! 3348: temp--;
! 3349: }
! 3350: temp++;
! 3351: }
! 3352: else
! 3353: {
! 3354: putchar(*temp);
! 3355: temp++;
! 3356: }
! 3357: }
! 3358:
! 3359: fflush(stdout);
! 3360: }
! 3361:
! 3362: int
! 3363: first_word_len(test_line)
! 3364: struct text *test_line;
! 3365: {
! 3366: int counter;
! 3367: wchar_t *pnt;
! 3368:
! 3369: if (test_line == NULL)
! 3370: return(0);
! 3371:
! 3372: pnt = test_line->line;
! 3373: if ((pnt == NULL) || (*pnt == '\0') ||
! 3374: (*pnt == '.') || (*pnt == '>'))
! 3375: return(0);
! 3376:
! 3377: if ((*pnt == ' ') || (*pnt == '\t'))
! 3378: {
! 3379: pnt = next_word(pnt);
! 3380: }
! 3381:
! 3382: if (*pnt == '\0')
! 3383: return(0);
! 3384:
! 3385: counter = 0;
! 3386: while ((*pnt != '\0') && ((*pnt != ' ') && (*pnt != '\t')))
! 3387: {
! 3388: pnt++;
! 3389: counter++;
! 3390: }
! 3391: while ((*pnt != '\0') && ((*pnt == ' ') || (*pnt == '\t')))
! 3392: {
! 3393: pnt++;
! 3394: counter++;
! 3395: }
! 3396: return(counter);
! 3397: }
! 3398:
! 3399: wchar_t *
! 3400: is_in_string(string, substring) /* a strchr() look-alike for systems without
! 3401: strchr() */
! 3402: wchar_t * string, *substring;
! 3403: {
! 3404: wchar_t *full, *sub;
! 3405:
! 3406: for (sub = substring; (sub != NULL) && (*sub != '\0'); sub++)
! 3407: {
! 3408: for (full = string; (full != NULL) && (*full != '\0');
! 3409: full++)
! 3410: {
! 3411: if (*sub == *full)
! 3412: return(full);
! 3413: }
! 3414: }
! 3415: return(NULL);
! 3416: }
! 3417:
! 3418: /*
! 3419: | The following routine tests the input string against the list of
! 3420: | strings, to determine if the string is a unique match with one of the
! 3421: | valid values.
! 3422: */
! 3423:
! 3424: int
! 3425: unique_test(string, list)
! 3426: wchar_t *string;
! 3427: wchar_t *list[];
! 3428: {
! 3429: int counter;
! 3430: int num_match;
! 3431: int result;
! 3432:
! 3433: num_match = 0;
! 3434: counter = 0;
! 3435: while (list[counter] != NULL)
! 3436: {
! 3437: result = compare(string, list[counter], FALSE);
! 3438: if (result)
! 3439: num_match++;
! 3440: counter++;
! 3441: }
! 3442: return(num_match);
! 3443: }
! 3444:
! 3445: /*
! 3446: | The following is to allow for using message catalogs which allow
! 3447: | the software to be 'localized', that is, to use different languages
! 3448: | all with the same binary. For more information, see your system
! 3449: | documentation, or the X/Open Internationalization Guide.
! 3450: */
! 3451:
! 3452: void
! 3453: strings_init()
! 3454: {
! 3455: leave_menu[0].item_string = L"leave menu";
! 3456: leave_menu[1].item_string = L"save changes";
! 3457: leave_menu[2].item_string = L"no save";
! 3458: search_menu[0].item_string = L"search menu";
! 3459: search_menu[1].item_string = L"search for ...";
! 3460: search_menu[2].item_string = L"search";
! 3461: main_menu[0].item_string = L"main menu";
! 3462: main_menu[1].item_string = L"leave editor";
! 3463: main_menu[2].item_string = L"help";
! 3464: main_menu[3].item_string = L"save file";
! 3465: main_menu[4].item_string = L"redraw screen";
! 3466: main_menu[5].item_string = L"search";
! 3467: help_text[0] = L"Control keys: ";
! 3468: help_text[1] = L"^a ascii code ^i tab ^r right ";
! 3469: help_text[2] = L"^b bottom of text ^j newline ^t top of text ";
! 3470: help_text[3] = L"^c command ^k delete char ^u up ";
! 3471: help_text[4] = L"^d down ^l left ^v undelete word ";
! 3472: help_text[5] = L"^e search prompt ^m newline ^w delete word ";
! 3473: help_text[6] = L"^f undelete char ^n next page ^x search ";
! 3474: help_text[7] = L"^g begin of line ^o end of line ^y delete line ";
! 3475: help_text[8] = L"^h backspace ^p prev page ^z undelete line ";
! 3476: help_text[9] = L"^[ (escape) menu ";
! 3477: help_text[10] = L" ";
! 3478: help_text[11] = L"Commands: ";
! 3479: help_text[12] = L"help : get this info file : print file name ";
! 3480: help_text[13] = L"read : (disabled) char : ascii code of char ";
! 3481: help_text[14] = L"write : (disabled) case : case sensitive search ";
! 3482: help_text[15] = L"exit : leave and save nocase : case insensitive search ";
! 3483: help_text[16] = L"quit : leave, no save !cmd : (disabled) ";
! 3484: help_text[17] = L"line : display line # 0-9 : go to line \"#\" ";
! 3485: help_text[18] = L"expand : expand tabs noexpand: do not expand tabs ";
! 3486: help_text[19] = L" ";
! 3487: help_text[20] = L" ee [+#] [-i] [-e] [-h] [file(s)] ";
! 3488: help_text[21] = L"+# :go to line # -i :no info window -e : don't expand tabs -h :no highlight";
! 3489: control_keys[0] = L"^[ (escape) menu ^e search prompt ^y delete line ^u up ^p prev page ";
! 3490: control_keys[1] = L"^a ascii code ^x search ^z undelete line ^d down ^n next page ";
! 3491: control_keys[2] = L"^b bottom of text ^g begin of line ^w delete word ^l left ";
! 3492: control_keys[3] = L"^t top of text ^o end of line ^v undelete word ^r right ";
! 3493: control_keys[4] = L"^c command ^k delete char ^f undelete char ";
! 3494: command_strings[0] = L"help : get help info |file : print file name |line : print line # ";
! 3495: command_strings[1] = L"read : (disabled) |char : ascii code of char |0-9 : go to line \"#\"";
! 3496: command_strings[2] = L"save: save changes |case : case sensitive search |exit : leave and save ";
! 3497: command_strings[3] = L"!cmd : (disabled) |nocase: ignore case in search |quit : leave, no save";
! 3498: command_strings[4] = L"expand: expand tabs |noexpand: do not expand tabs ";
! 3499: com_win_message = L" press Escape (^[) for menu";
! 3500: no_file_string = "no file";
! 3501: ascii_code_str = L"ascii code: ";
! 3502: command_str = L"command: ";
! 3503: char_str = "character = %d";
! 3504: unkn_cmd_str = "unknown command \"%S\"";
! 3505: non_unique_cmd_msg = L"entered command is not unique";
! 3506: line_num_str = "line %d ";
! 3507: line_len_str = "length = %d";
! 3508: current_file_str = "current file is \"%S\" ";
! 3509: usage0 = L"usage: %s [-i] [-e] [-h] [+line_number] [file(s)]\n";
! 3510: usage1 = L" -i turn off info window\n";
! 3511: usage2 = L" -e do not convert tabs to spaces\n";
! 3512: usage3 = L" -h do not use highlighting\n";
! 3513: file_is_dir_msg = "file \"%s\" is a directory";
! 3514: new_file_msg = "new file \"%s\"";
! 3515: cant_open_msg = "can't open \"%s\"";
! 3516: open_file_msg = L"file \"%s\", %d lines";
! 3517: file_read_fin_msg = "finished reading file \"%s\"";
! 3518: reading_file_msg = "reading file \"%s\"";
! 3519: read_only_msg = ", read only";
! 3520: file_read_lines_msg = "file \"%s\", %d lines";
! 3521: save_file_name_prompt = L"enter name of file: ";
! 3522: file_not_saved_msg = "no filename entered: file not saved";
! 3523: changes_made_prompt = L"changes have been made, are you sure? (y/n [n]) ";
! 3524: yes_char = L"y";
! 3525: file_exists_prompt = L"file already exists, overwrite? (y/n) [n] ";
! 3526: create_file_fail_msg = "unable to create file \"%s\"";
! 3527: writing_file_msg = "writing file \"%s\"";
! 3528: file_written_msg = "\"%s\" %d lines, %d characters";
! 3529: searching_msg = " ...searching";
! 3530: str_not_found_msg = "string \"%S\" not found";
! 3531: search_prompt_str = L"search for: ";
! 3532: continue_msg = L"press return to continue ";
! 3533: menu_cancel_msg = L"press Esc to cancel";
! 3534: menu_size_err_msg = L"menu too large for window";
! 3535: press_any_key_msg = L"press any key to continue ";
! 3536: ON = L"ON";
! 3537: OFF = L"OFF";
! 3538: HELP = L"HELP";
! 3539: SAVE = L"SAVE";
! 3540: READ = L"READ";
! 3541: LINE = L"LINE";
! 3542: FILE_str = L"FILE";
! 3543: CHARACTER = L"CHARACTER";
! 3544: REDRAW = L"REDRAW";
! 3545: RESEQUENCE = L"RESEQUENCE";
! 3546: AUTHOR = L"AUTHOR";
! 3547: ee_VERSION = L"VERSION";
! 3548: CASE = L"CASE";
! 3549: NOCASE = L"NOCASE";
! 3550: EXPAND = L"EXPAND";
! 3551: NOEXPAND = L"NOEXPAND";
! 3552: Exit_string = L"EXIT";
! 3553: QUIT_string = L"QUIT";
! 3554: INFO = L"INFO";
! 3555: NOINFO = L"NOINFO";
! 3556: MARGINS = L"MARGINS";
! 3557: NOMARGINS = L"NOMARGINS";
! 3558: AUTOFORMAT = L"AUTOFORMAT";
! 3559: NOAUTOFORMAT = L"NOAUTOFORMAT";
! 3560: Echo = L"ECHO";
! 3561: PRINTCOMMAND = L"PRINTCOMMAND";
! 3562: RIGHTMARGIN = L"RIGHTMARGIN";
! 3563: HIGHLIGHT = L"HIGHLIGHT";
! 3564: NOHIGHLIGHT = L"NOHIGHLIGHT";
! 3565: EIGHTBIT = L"EIGHTBIT";
! 3566: NOEIGHTBIT = L"NOEIGHTBIT";
! 3567: /*
! 3568: | additions
! 3569: */
! 3570: emacs_help_text[0] = help_text[0];
! 3571: emacs_help_text[1] = L"^a beginning of line ^i tab ^r restore word ";
! 3572: emacs_help_text[2] = L"^b back 1 char ^j undel char ^t top of text ";
! 3573: emacs_help_text[3] = L"^c command ^k delete line ^u bottom of text ";
! 3574: emacs_help_text[4] = L"^d delete char ^l undelete line ^v next page ";
! 3575: emacs_help_text[5] = L"^e end of line ^m newline ^w delete word ";
! 3576: emacs_help_text[6] = L"^f forward 1 char ^n next line ^x search ";
! 3577: emacs_help_text[7] = L"^g go back 1 page ^o ascii char insert ^y search prompt ";
! 3578: emacs_help_text[8] = L"^h backspace ^p prev line ^z next word ";
! 3579: emacs_help_text[9] = help_text[9];
! 3580: emacs_help_text[10] = help_text[10];
! 3581: emacs_help_text[11] = help_text[11];
! 3582: emacs_help_text[12] = help_text[12];
! 3583: emacs_help_text[13] = help_text[13];
! 3584: emacs_help_text[14] = help_text[14];
! 3585: emacs_help_text[15] = help_text[15];
! 3586: emacs_help_text[16] = help_text[16];
! 3587: emacs_help_text[17] = help_text[17];
! 3588: emacs_help_text[18] = help_text[18];
! 3589: emacs_help_text[19] = help_text[19];
! 3590: emacs_help_text[20] = help_text[20];
! 3591: emacs_help_text[21] = help_text[21];
! 3592: emacs_control_keys[0] = L"^[ (escape) menu ^y search prompt ^k delete line ^p prev li ^g prev page";
! 3593: emacs_control_keys[1] = L"^o ascii code ^x search ^l undelete line ^n next li ^v next page";
! 3594: emacs_control_keys[2] = L"^u end of file ^a begin of line ^w delete word ^b back 1 char ";
! 3595: emacs_control_keys[3] = L"^t top of text ^e end of line ^r restore word ^f forward 1 char ";
! 3596: emacs_control_keys[4] = L"^c command ^d delete char ^j undelete char ^z next word ";
! 3597: EMACS_string = L"EMACS";
! 3598: NOEMACS_string = L"NOEMACS";
! 3599: usage4 = L" +# put cursor at line #\n";
! 3600: menu_too_lrg_msg = "menu too large for window";
! 3601: more_above_str = L"^^more^^";
! 3602: more_below_str = L"VVmoreVV";
! 3603:
! 3604:
! 3605: commands[0] = HELP;
! 3606: commands[1] = SAVE;
! 3607: commands[2] = READ;
! 3608: commands[3] = LINE;
! 3609: commands[4] = FILE_str;
! 3610: commands[5] = REDRAW;
! 3611: commands[6] = RESEQUENCE;
! 3612: commands[7] = AUTHOR;
! 3613: commands[8] = ee_VERSION;
! 3614: commands[9] = CASE;
! 3615: commands[10] = NOCASE;
! 3616: commands[11] = EXPAND;
! 3617: commands[12] = NOEXPAND;
! 3618: commands[13] = Exit_string;
! 3619: commands[14] = QUIT_string;
! 3620: commands[15] = L"<";
! 3621: commands[16] = L">";
! 3622: commands[17] = L"!";
! 3623: commands[18] = L"0";
! 3624: commands[19] = L"1";
! 3625: commands[20] = L"2";
! 3626: commands[21] = L"3";
! 3627: commands[22] = L"4";
! 3628: commands[23] = L"5";
! 3629: commands[24] = L"6";
! 3630: commands[25] = L"7";
! 3631: commands[26] = L"8";
! 3632: commands[27] = L"9";
! 3633: commands[28] = CHARACTER;
! 3634: commands[29] = NULL;
! 3635: }
! 3636: