OpenCores
URL https://opencores.org/ocsvn/openrisc_me/openrisc_me/trunk

Subversion Repositories openrisc_me

[/] [openrisc/] [trunk/] [gnu-src/] [gdb-6.8/] [gdb/] [tui/] [tui-io.c] - Blame information for rev 157

Details | Compare with Previous | View Log

Line No. Rev Author Line
1 24 jeremybenn
/* TUI support I/O functions.
2
 
3
   Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2007, 2008
4
   Free Software Foundation, Inc.
5
 
6
   Contributed by Hewlett-Packard Company.
7
 
8
   This file is part of GDB.
9
 
10
   This program is free software; you can redistribute it and/or modify
11
   it under the terms of the GNU General Public License as published by
12
   the Free Software Foundation; either version 3 of the License, or
13
   (at your option) any later version.
14
 
15
   This program is distributed in the hope that it will be useful,
16
   but WITHOUT ANY WARRANTY; without even the implied warranty of
17
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
18
   GNU General Public License for more details.
19
 
20
   You should have received a copy of the GNU General Public License
21
   along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
22
 
23
#include "defs.h"
24
#include "target.h"
25
#include "event-loop.h"
26
#include "event-top.h"
27
#include "command.h"
28
#include "top.h"
29
#include "tui/tui.h"
30
#include "tui/tui-data.h"
31
#include "tui/tui-io.h"
32
#include "tui/tui-command.h"
33
#include "tui/tui-win.h"
34
#include "tui/tui-wingeneral.h"
35
#include "tui/tui-file.h"
36
#include "ui-out.h"
37
#include "cli-out.h"
38
#include <fcntl.h>
39
#include <signal.h>
40
#include <stdio.h>
41
 
42
#include "gdb_curses.h"
43
 
44
/* This redefines CTRL if it is not already defined, so it must come
45
   after terminal state releated include files like <term.h> and
46
   "gdb_curses.h".  */
47
#include "readline/readline.h"
48
 
49
int
50
key_is_start_sequence (int ch)
51
{
52
  return (ch == 27);
53
}
54
 
55
int
56
key_is_end_sequence (int ch)
57
{
58
  return (ch == 126);
59
}
60
 
61
int
62
key_is_backspace (int ch)
63
{
64
  return (ch == 8);
65
}
66
 
67
int
68
key_is_command_char (int ch)
69
{
70
  return ((ch == KEY_NPAGE) || (ch == KEY_PPAGE)
71
          || (ch == KEY_LEFT) || (ch == KEY_RIGHT)
72
          || (ch == KEY_UP) || (ch == KEY_DOWN)
73
          || (ch == KEY_SF) || (ch == KEY_SR)
74
          || (ch == (int)'\f')
75
          || key_is_start_sequence (ch));
76
}
77
 
78
/* Use definition from readline 4.3.  */
79
#undef CTRL_CHAR
80
#define CTRL_CHAR(c) \
81
     ((c) < control_character_threshold && (((c) & 0x80) == 0))
82
 
83
/* This file controls the IO interactions between gdb and curses.
84
   When the TUI is enabled, gdb has two modes a curses and a standard
85
   mode.
86
 
87
   In curses mode, the gdb outputs are made in a curses command
88
   window.  For this, the gdb_stdout and gdb_stderr are redirected to
89
   the specific ui_file implemented by TUI.  The output is handled by
90
   tui_puts().  The input is also controlled by curses with
91
   tui_getc().  The readline library uses this function to get its
92
   input.  Several readline hooks are installed to redirect readline
93
   output to the TUI (see also the note below).
94
 
95
   In normal mode, the gdb outputs are restored to their origin, that
96
   is as if TUI is not used.  Readline also uses its original getc()
97
   function with stdin.
98
 
99
   Note SCz/2001-07-21: the current readline is not clean in its
100
   management of the output.  Even if we install a redisplay handler,
101
   it sometimes writes on a stdout file.  It is important to redirect
102
   every output produced by readline, otherwise the curses window will
103
   be garbled.  This is implemented with a pipe that TUI reads and
104
   readline writes to.  A gdb input handler is created so that reading
105
   the pipe is handled automatically.  This will probably not work on
106
   non-Unix platforms.  The best fix is to make readline clean enougth
107
   so that is never write on stdout.
108
 
109
   Note SCz/2002-09-01: we now use more readline hooks and it seems
110
   that with them we don't need the pipe anymore (verified by creating
111
   the pipe and closing its end so that write causes a SIGPIPE).  The
112
   old pipe code is still there and can be conditionally removed by
113
   #undef TUI_USE_PIPE_FOR_READLINE.  */
114
 
115
/* For gdb 5.3, prefer to continue the pipe hack as a backup wheel.  */
116
#define TUI_USE_PIPE_FOR_READLINE
117
/* #undef TUI_USE_PIPE_FOR_READLINE */
118
 
119
/* TUI output files.  */
120
static struct ui_file *tui_stdout;
121
static struct ui_file *tui_stderr;
122
struct ui_out *tui_out;
123
 
124
/* GDB output files in non-curses mode.  */
125
static struct ui_file *tui_old_stdout;
126
static struct ui_file *tui_old_stderr;
127
struct ui_out *tui_old_uiout;
128
 
129
/* Readline previous hooks.  */
130
static Function *tui_old_rl_getc_function;
131
static VFunction *tui_old_rl_redisplay_function;
132
static VFunction *tui_old_rl_prep_terminal;
133
static VFunction *tui_old_rl_deprep_terminal;
134
static int tui_old_readline_echoing_p;
135
 
136
/* Readline output stream.
137
   Should be removed when readline is clean.  */
138
static FILE *tui_rl_outstream;
139
static FILE *tui_old_rl_outstream;
140
#ifdef TUI_USE_PIPE_FOR_READLINE
141
static int tui_readline_pipe[2];
142
#endif
143
 
144
/* The last gdb prompt that was registered in readline.
145
   This may be the main gdb prompt or a secondary prompt.  */
146
static char *tui_rl_saved_prompt;
147
 
148
static unsigned int tui_handle_resize_during_io (unsigned int);
149
 
150
static void
151
tui_putc (char c)
152
{
153
  char buf[2];
154
 
155
  buf[0] = c;
156
  buf[1] = 0;
157
  tui_puts (buf);
158
}
159
 
160
/* Print the string in the curses command window.  */
161
void
162
tui_puts (const char *string)
163
{
164
  static int tui_skip_line = -1;
165
  char c;
166
  WINDOW *w;
167
 
168
  w = TUI_CMD_WIN->generic.handle;
169
  while ((c = *string++) != 0)
170
    {
171
      /* Catch annotation and discard them.  We need two \032 and
172
         discard until a \n is seen.  */
173
      if (c == '\032')
174
        {
175
          tui_skip_line++;
176
        }
177
      else if (tui_skip_line != 1)
178
        {
179
          tui_skip_line = -1;
180
          waddch (w, c);
181
        }
182
      else if (c == '\n')
183
        tui_skip_line = -1;
184
    }
185
  getyx (w, TUI_CMD_WIN->detail.command_info.cur_line,
186
         TUI_CMD_WIN->detail.command_info.curch);
187
  TUI_CMD_WIN->detail.command_info.start_line = TUI_CMD_WIN->detail.command_info.cur_line;
188
 
189
  /* We could defer the following.  */
190
  wrefresh (w);
191
  fflush (stdout);
192
}
193
 
194
/* Readline callback.
195
   Redisplay the command line with its prompt after readline has
196
   changed the edited text.  */
197
void
198
tui_redisplay_readline (void)
199
{
200
  int prev_col;
201
  int height;
202
  int col, line;
203
  int c_pos;
204
  int c_line;
205
  int in;
206
  WINDOW *w;
207
  char *prompt;
208
  int start_line;
209
 
210
  /* Detect when we temporarily left SingleKey and now the readline
211
     edit buffer is empty, automatically restore the SingleKey
212
     mode.  */
213
  if (tui_current_key_mode == TUI_ONE_COMMAND_MODE && rl_end == 0)
214
    tui_set_key_mode (TUI_SINGLE_KEY_MODE);
215
 
216
  if (tui_current_key_mode == TUI_SINGLE_KEY_MODE)
217
    prompt = "";
218
  else
219
    prompt = tui_rl_saved_prompt;
220
 
221
  c_pos = -1;
222
  c_line = -1;
223
  w = TUI_CMD_WIN->generic.handle;
224
  start_line = TUI_CMD_WIN->detail.command_info.start_line;
225
  wmove (w, start_line, 0);
226
  prev_col = 0;
227
  height = 1;
228
  for (in = 0; prompt && prompt[in]; in++)
229
    {
230
      waddch (w, prompt[in]);
231
      getyx (w, line, col);
232
      if (col < prev_col)
233
        height++;
234
      prev_col = col;
235
    }
236
  for (in = 0; in < rl_end; in++)
237
    {
238
      unsigned char c;
239
 
240
      c = (unsigned char) rl_line_buffer[in];
241
      if (in == rl_point)
242
        {
243
          getyx (w, c_line, c_pos);
244
        }
245
 
246
      if (CTRL_CHAR (c) || c == RUBOUT)
247
        {
248
          waddch (w, '^');
249
          waddch (w, CTRL_CHAR (c) ? UNCTRL (c) : '?');
250
        }
251
      else
252
        {
253
          waddch (w, c);
254
        }
255
      if (c == '\n')
256
        {
257
          getyx (w, TUI_CMD_WIN->detail.command_info.start_line,
258
                 TUI_CMD_WIN->detail.command_info.curch);
259
        }
260
      getyx (w, line, col);
261
      if (col < prev_col)
262
        height++;
263
      prev_col = col;
264
    }
265
  wclrtobot (w);
266
  getyx (w, TUI_CMD_WIN->detail.command_info.start_line,
267
         TUI_CMD_WIN->detail.command_info.curch);
268
  if (c_line >= 0)
269
    {
270
      wmove (w, c_line, c_pos);
271
      TUI_CMD_WIN->detail.command_info.cur_line = c_line;
272
      TUI_CMD_WIN->detail.command_info.curch = c_pos;
273
    }
274
  TUI_CMD_WIN->detail.command_info.start_line -= height - 1;
275
 
276
  wrefresh (w);
277
  fflush(stdout);
278
}
279
 
280
/* Readline callback to prepare the terminal.  It is called once each
281
   time we enter readline.  Terminal is already setup in curses
282
   mode.  */
283
static void
284
tui_prep_terminal (int notused1)
285
{
286
  /* Save the prompt registered in readline to correctly display it.
287
     (we can't use gdb_prompt() due to secondary prompts and can't use
288
     rl_prompt because it points to an alloca buffer).  */
289
  xfree (tui_rl_saved_prompt);
290
  tui_rl_saved_prompt = xstrdup (rl_prompt);
291
}
292
 
293
/* Readline callback to restore the terminal.  It is called once each
294
   time we leave readline.  There is nothing to do in curses mode.  */
295
static void
296
tui_deprep_terminal (void)
297
{
298
}
299
 
300
#ifdef TUI_USE_PIPE_FOR_READLINE
301
/* Read readline output pipe and feed the command window with it.
302
   Should be removed when readline is clean.  */
303
static void
304
tui_readline_output (int code, gdb_client_data data)
305
{
306
  int size;
307
  char buf[256];
308
 
309
  size = read (tui_readline_pipe[0], buf, sizeof (buf) - 1);
310
  if (size > 0 && tui_active)
311
    {
312
      buf[size] = 0;
313
      tui_puts (buf);
314
    }
315
}
316
#endif
317
 
318
/* Return the portion of PATHNAME that should be output when listing
319
   possible completions.  If we are hacking filename completion, we
320
   are only interested in the basename, the portion following the
321
   final slash.  Otherwise, we return what we were passed.
322
 
323
   Comes from readline/complete.c.  */
324
static char *
325
printable_part (char *pathname)
326
{
327
  char *temp;
328
 
329
  temp = rl_filename_completion_desired ? strrchr (pathname, '/') : (char *)NULL;
330
#if defined (__MSDOS__)
331
  if (rl_filename_completion_desired
332
      && temp == 0 && isalpha (pathname[0])
333
      && pathname[1] == ':')
334
    temp = pathname + 1;
335
#endif
336
  return (temp ? ++temp : pathname);
337
}
338
 
339
/* Output TO_PRINT to rl_outstream.  If VISIBLE_STATS is defined and
340
   we are using it, check for and output a single character for
341
   `special' filenames.  Return the number of characters we
342
   output.  */
343
 
344
#define PUTX(c) \
345
    do { \
346
      if (CTRL_CHAR (c)) \
347
        { \
348
          tui_puts ("^"); \
349
          tui_putc (UNCTRL (c)); \
350
          printed_len += 2; \
351
        } \
352
      else if (c == RUBOUT) \
353
        { \
354
          tui_puts ("^?"); \
355
          printed_len += 2; \
356
        } \
357
      else \
358
        { \
359
          tui_putc (c); \
360
          printed_len++; \
361
        } \
362
    } while (0)
363
 
364
static int
365
print_filename (char *to_print, char *full_pathname)
366
{
367
  int printed_len = 0;
368
  char *s;
369
 
370
  for (s = to_print; *s; s++)
371
    {
372
      PUTX (*s);
373
    }
374
  return printed_len;
375
}
376
 
377
/* The user must press "y" or "n".  Non-zero return means "y" pressed.
378
   Comes from readline/complete.c.  */
379
static int
380
get_y_or_n (void)
381
{
382
  extern int _rl_abort_internal ();
383
  int c;
384
 
385
  for (;;)
386
    {
387
      c = rl_read_key ();
388
      if (c == 'y' || c == 'Y' || c == ' ')
389
        return (1);
390
      if (c == 'n' || c == 'N' || c == RUBOUT)
391
        return (0);
392
      if (c == ABORT_CHAR)
393
        _rl_abort_internal ();
394
      beep ();
395
    }
396
}
397
 
398
/* A convenience function for displaying a list of strings in
399
   columnar format on readline's output stream.  MATCHES is the list
400
   of strings, in argv format, LEN is the number of strings in MATCHES,
401
   and MAX is the length of the longest string in MATCHES.
402
 
403
   Comes from readline/complete.c and modified to write in
404
   the TUI command window using tui_putc/tui_puts.  */
405
static void
406
tui_rl_display_match_list (char **matches, int len, int max)
407
{
408
  typedef int QSFUNC (const void *, const void *);
409
  extern int _rl_qsort_string_compare (const void *,
410
                                       const void *);
411
  extern int _rl_print_completions_horizontally;
412
 
413
  int count, limit, printed_len;
414
  int i, j, k, l;
415
  char *temp;
416
 
417
  /* Screen dimension correspond to the TUI command window.  */
418
  int screenwidth = TUI_CMD_WIN->generic.width;
419
 
420
  /* If there are many items, then ask the user if she really wants to
421
     see them all.  */
422
  if (len >= rl_completion_query_items)
423
    {
424
      char msg[256];
425
 
426
      sprintf (msg, "\nDisplay all %d possibilities? (y or n)", len);
427
      tui_puts (msg);
428
      if (get_y_or_n () == 0)
429
        {
430
          tui_puts ("\n");
431
          return;
432
        }
433
    }
434
 
435
  /* How many items of MAX length can we fit in the screen window?  */
436
  max += 2;
437
  limit = screenwidth / max;
438
  if (limit != 1 && (limit * max == screenwidth))
439
    limit--;
440
 
441
  /* Avoid a possible floating exception.  If max > screenwidth, limit
442
     will be 0 and a divide-by-zero fault will result.  */
443
  if (limit == 0)
444
    limit = 1;
445
 
446
  /* How many iterations of the printing loop?  */
447
  count = (len + (limit - 1)) / limit;
448
 
449
  /* Watch out for special case.  If LEN is less than LIMIT, then
450
     just do the inner printing loop.
451
 
452
 
453
  /* Sort the items if they are not already sorted.  */
454
  if (rl_ignore_completion_duplicates == 0)
455
    qsort (matches + 1, len, sizeof (char *),
456
           (QSFUNC *)_rl_qsort_string_compare);
457
 
458
  tui_putc ('\n');
459
 
460
  if (_rl_print_completions_horizontally == 0)
461
    {
462
      /* Print the sorted items, up-and-down alphabetically, like ls.  */
463
      for (i = 1; i <= count; i++)
464
        {
465
          for (j = 0, l = i; j < limit; j++)
466
            {
467
              if (l > len || matches[l] == 0)
468
                break;
469
              else
470
                {
471
                  temp = printable_part (matches[l]);
472
                  printed_len = print_filename (temp, matches[l]);
473
 
474
                  if (j + 1 < limit)
475
                    for (k = 0; k < max - printed_len; k++)
476
                      tui_putc (' ');
477
                }
478
              l += count;
479
            }
480
          tui_putc ('\n');
481
        }
482
    }
483
  else
484
    {
485
      /* Print the sorted items, across alphabetically, like ls -x.  */
486
      for (i = 1; matches[i]; i++)
487
        {
488
          temp = printable_part (matches[i]);
489
          printed_len = print_filename (temp, matches[i]);
490
          /* Have we reached the end of this line?  */
491
          if (matches[i+1])
492
            {
493
              if (i && (limit > 1) && (i % limit) == 0)
494
                tui_putc ('\n');
495
              else
496
                for (k = 0; k < max - printed_len; k++)
497
                  tui_putc (' ');
498
            }
499
        }
500
      tui_putc ('\n');
501
    }
502
}
503
 
504
/* Setup the IO for curses or non-curses mode.
505
   - In non-curses mode, readline and gdb use the standard input and
506
   standard output/error directly.
507
   - In curses mode, the standard output/error is controlled by TUI
508
   with the tui_stdout and tui_stderr.  The output is redirected in
509
   the curses command window.  Several readline callbacks are installed
510
   so that readline asks for its input to the curses command window
511
   with wgetch().  */
512
void
513
tui_setup_io (int mode)
514
{
515
  extern int readline_echoing_p;
516
 
517
  if (mode)
518
    {
519
      /* Redirect readline to TUI.  */
520
      tui_old_rl_redisplay_function = rl_redisplay_function;
521
      tui_old_rl_deprep_terminal = rl_deprep_term_function;
522
      tui_old_rl_prep_terminal = rl_prep_term_function;
523
      tui_old_rl_getc_function = rl_getc_function;
524
      tui_old_rl_outstream = rl_outstream;
525
      tui_old_readline_echoing_p = readline_echoing_p;
526
      rl_redisplay_function = tui_redisplay_readline;
527
      rl_deprep_term_function = tui_deprep_terminal;
528
      rl_prep_term_function = tui_prep_terminal;
529
      rl_getc_function = tui_getc;
530
      readline_echoing_p = 0;
531
      rl_outstream = tui_rl_outstream;
532
      rl_prompt = 0;
533
      rl_completion_display_matches_hook = tui_rl_display_match_list;
534
      rl_already_prompted = 0;
535
 
536
      /* Keep track of previous gdb output.  */
537
      tui_old_stdout = gdb_stdout;
538
      tui_old_stderr = gdb_stderr;
539
      tui_old_uiout = uiout;
540
 
541
      /* Reconfigure gdb output.  */
542
      gdb_stdout = tui_stdout;
543
      gdb_stderr = tui_stderr;
544
      gdb_stdlog = gdb_stdout;  /* for moment */
545
      gdb_stdtarg = gdb_stderr; /* for moment */
546
      uiout = tui_out;
547
 
548
      /* Save tty for SIGCONT.  */
549
      savetty ();
550
    }
551
  else
552
    {
553
      /* Restore gdb output.  */
554
      gdb_stdout = tui_old_stdout;
555
      gdb_stderr = tui_old_stderr;
556
      gdb_stdlog = gdb_stdout;  /* for moment */
557
      gdb_stdtarg = gdb_stderr; /* for moment */
558
      uiout = tui_old_uiout;
559
 
560
      /* Restore readline.  */
561
      rl_redisplay_function = tui_old_rl_redisplay_function;
562
      rl_deprep_term_function = tui_old_rl_deprep_terminal;
563
      rl_prep_term_function = tui_old_rl_prep_terminal;
564
      rl_getc_function = tui_old_rl_getc_function;
565
      rl_outstream = tui_old_rl_outstream;
566
      rl_completion_display_matches_hook = 0;
567
      readline_echoing_p = tui_old_readline_echoing_p;
568
      rl_already_prompted = 0;
569
 
570
      /* Save tty for SIGCONT.  */
571
      savetty ();
572
    }
573
}
574
 
575
#ifdef SIGCONT
576
/* Catch SIGCONT to restore the terminal and refresh the screen.  */
577
static void
578
tui_cont_sig (int sig)
579
{
580
  if (tui_active)
581
    {
582
      /* Restore the terminal setting because another process (shell)
583
         might have changed it.  */
584
      resetty ();
585
 
586
      /* Force a refresh of the screen.  */
587
      tui_refresh_all_win ();
588
 
589
      /* Update cursor position on the screen.  */
590
      wmove (TUI_CMD_WIN->generic.handle,
591
             TUI_CMD_WIN->detail.command_info.start_line,
592
             TUI_CMD_WIN->detail.command_info.curch);
593
      wrefresh (TUI_CMD_WIN->generic.handle);
594
    }
595
  signal (sig, tui_cont_sig);
596
}
597
#endif
598
 
599
/* Initialize the IO for gdb in curses mode.  */
600
void
601
tui_initialize_io (void)
602
{
603
#ifdef SIGCONT
604
  signal (SIGCONT, tui_cont_sig);
605
#endif
606
 
607
  /* Create tui output streams.  */
608
  tui_stdout = tui_fileopen (stdout);
609
  tui_stderr = tui_fileopen (stderr);
610
  tui_out = tui_out_new (tui_stdout);
611
 
612
  /* Create the default UI.  It is not created because we installed a
613
     deprecated_init_ui_hook.  */
614
  tui_old_uiout = uiout = cli_out_new (gdb_stdout);
615
 
616
#ifdef TUI_USE_PIPE_FOR_READLINE
617
  /* Temporary solution for readline writing to stdout: redirect
618
     readline output in a pipe, read that pipe and output the content
619
     in the curses command window.  */
620
  if (pipe (tui_readline_pipe) != 0)
621
    {
622
      fprintf_unfiltered (gdb_stderr, "Cannot create pipe for readline");
623
      exit (1);
624
    }
625
  tui_rl_outstream = fdopen (tui_readline_pipe[1], "w");
626
  if (tui_rl_outstream == 0)
627
    {
628
      fprintf_unfiltered (gdb_stderr, "Cannot redirect readline output");
629
      exit (1);
630
    }
631
  setvbuf (tui_rl_outstream, (char*) NULL, _IOLBF, 0);
632
 
633
#ifdef O_NONBLOCK
634
  (void) fcntl (tui_readline_pipe[0], F_SETFL, O_NONBLOCK);
635
#else
636
#ifdef O_NDELAY
637
  (void) fcntl (tui_readline_pipe[0], F_SETFL, O_NDELAY);
638
#endif
639
#endif
640
  add_file_handler (tui_readline_pipe[0], tui_readline_output, 0);
641
#else
642
  tui_rl_outstream = stdout;
643
#endif
644
}
645
 
646
/* Get a character from the command window.  This is called from the
647
   readline package.  */
648
int
649
tui_getc (FILE *fp)
650
{
651
  int ch;
652
  WINDOW *w;
653
 
654
  w = TUI_CMD_WIN->generic.handle;
655
 
656
#ifdef TUI_USE_PIPE_FOR_READLINE
657
  /* Flush readline output.  */
658
  tui_readline_output (GDB_READABLE, 0);
659
#endif
660
 
661
  ch = wgetch (w);
662
  ch = tui_handle_resize_during_io (ch);
663
 
664
  /* The \n must be echoed because it will not be printed by
665
     readline.  */
666
  if (ch == '\n')
667
    {
668
      /* When hitting return with an empty input, gdb executes the last
669
         command.  If we emit a newline, this fills up the command window
670
         with empty lines with gdb prompt at beginning.  Instead of that,
671
         stay on the same line but provide a visual effect to show the
672
         user we recognized the command.  */
673
      if (rl_end == 0)
674
        {
675
          wmove (w, TUI_CMD_WIN->detail.command_info.cur_line, 0);
676
 
677
          /* Clear the line.  This will blink the gdb prompt since
678
             it will be redrawn at the same line.  */
679
          wclrtoeol (w);
680
          wrefresh (w);
681
          napms (20);
682
        }
683
      else
684
        {
685
          wmove (w, TUI_CMD_WIN->detail.command_info.cur_line,
686
                 TUI_CMD_WIN->detail.command_info.curch);
687
          waddch (w, ch);
688
        }
689
    }
690
 
691
  if (key_is_command_char (ch))
692
    {                           /* Handle prev/next/up/down here.  */
693
      ch = tui_dispatch_ctrl_char (ch);
694
    }
695
 
696
  if (ch == '\n' || ch == '\r' || ch == '\f')
697
    TUI_CMD_WIN->detail.command_info.curch = 0;
698
  if (ch == KEY_BACKSPACE)
699
    return '\b';
700
 
701
  return ch;
702
}
703
 
704
 
705
/* Cleanup when a resize has occured.
706
   Returns the character that must be processed.  */
707
static unsigned int
708
tui_handle_resize_during_io (unsigned int original_ch)
709
{
710
  if (tui_win_resized ())
711
    {
712
      tui_refresh_all_win ();
713
      dont_repeat ();
714
      tui_set_win_resized_to (FALSE);
715
      return '\n';
716
    }
717
  else
718
    return original_ch;
719
}

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.