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

Subversion Repositories or1k

[/] [or1k/] [trunk/] [gdb-5.0/] [gdb/] [tui/] [tuiWin.c] - Blame information for rev 106

Go to most recent revision | Details | Compare with Previous | View Log

Line No. Rev Author Line
1 106 markom
/*
2
   ** tuiWin.c
3
   **    This module contains procedures for handling tui window functions
4
   **    like resize, scrolling, scrolling, changing focus, etc.
5
   **
6
   ** Author: Susan B. Macchia
7
 */
8
 
9
 
10
#include <string.h>
11
#include "defs.h"
12
#include "command.h"
13
#include "symtab.h"
14
#include "breakpoint.h"
15
#include "frame.h"
16
 
17
#include "tui.h"
18
#include "tuiData.h"
19
#include "tuiGeneralWin.h"
20
#include "tuiStack.h"
21
#include "tuiSourceWin.h"
22
#include "tuiDataWin.h"
23
 
24
/*******************************
25
** External Declarations
26
********************************/
27
extern void init_page_info ();
28
 
29
/*******************************
30
** Static Local Decls
31
********************************/
32
static void _makeVisibleWithNewHeight PARAMS ((TuiWinInfoPtr));
33
static void _makeInvisibleAndSetNewHeight PARAMS ((TuiWinInfoPtr, int));
34
static TuiStatus _tuiAdjustWinHeights PARAMS ((TuiWinInfoPtr, int));
35
static int _newHeightOk PARAMS ((TuiWinInfoPtr, int));
36
static void _tuiSetTabWidth_command PARAMS ((char *, int));
37
static void _tuiRefreshAll_command PARAMS ((char *, int));
38
static void _tuiSetWinHeight_command PARAMS ((char *, int));
39
static void _tuiXDBsetWinHeight_command PARAMS ((char *, int));
40
static void _tuiAllWindowsInfo PARAMS ((char *, int));
41
static void _tuiSetFocus_command PARAMS ((char *, int));
42
static void _tuiScrollForward_command PARAMS ((char *, int));
43
static void _tuiScrollBackward_command PARAMS ((char *, int));
44
static void _tuiScrollLeft_command PARAMS ((char *, int));
45
static void _tuiScrollRight_command PARAMS ((char *, int));
46
static void _parseScrollingArgs PARAMS ((char *, TuiWinInfoPtr *, int *));
47
 
48
 
49
/***************************************
50
** DEFINITIONS
51
***************************************/
52
#define WIN_HEIGHT_USAGE      "Usage: winheight <win_name> [+ | -] <#lines>\n"
53
#define XDBWIN_HEIGHT_USAGE   "Usage: w <#lines>\n"
54
#define FOCUS_USAGE           "Usage: focus {<win> | next | prev}\n"
55
 
56
/***************************************
57
** PUBLIC FUNCTIONS
58
***************************************/
59
 
60
/*
61
   ** _initialize_tuiWin().
62
   **        Function to initialize gdb commands, for tui window manipulation.
63
 */
64
void
65
_initialize_tuiWin ()
66
{
67
  if (tui_version)
68
    {
69
      add_com ("refresh", class_tui, _tuiRefreshAll_command,
70
               "Refresh the terminal display.\n");
71
      if (xdb_commands)
72
        add_com_alias ("U", "refresh", class_tui, 0);
73
      add_com ("tabset", class_tui, _tuiSetTabWidth_command,
74
               "Set the width (in characters) of tab stops.\n\
75
Usage: tabset <n>\n");
76
      add_com ("winheight", class_tui, _tuiSetWinHeight_command,
77
               "Set the height of a specified window.\n\
78
Usage: winheight <win_name> [+ | -] <#lines>\n\
79
Window names are:\n\
80
src  : the source window\n\
81
cmd  : the command window\n\
82
asm  : the disassembly window\n\
83
regs : the register display\n");
84
      add_com_alias ("wh", "winheight", class_tui, 0);
85
      add_info ("win", _tuiAllWindowsInfo,
86
                "List of all displayed windows.\n");
87
      add_com ("focus", class_tui, _tuiSetFocus_command,
88
               "Set focus to named window or next/prev window.\n\
89
Usage: focus {<win> | next | prev}\n\
90
Valid Window names are:\n\
91
src  : the source window\n\
92
asm  : the disassembly window\n\
93
regs : the register display\n\
94
cmd  : the command window\n");
95
      add_com_alias ("fs", "focus", class_tui, 0);
96
      add_com ("+", class_tui, _tuiScrollForward_command,
97
               "Scroll window forward.\nUsage: + [win] [n]\n");
98
      add_com ("-", class_tui, _tuiScrollBackward_command,
99
               "Scroll window backward.\nUsage: - [win] [n]\n");
100
      add_com ("<", class_tui, _tuiScrollLeft_command,
101
               "Scroll window forward.\nUsage: < [win] [n]\n");
102
      add_com (">", class_tui, _tuiScrollRight_command,
103
               "Scroll window backward.\nUsage: > [win] [n]\n");
104
      if (xdb_commands)
105
        add_com ("w", class_xdb, _tuiXDBsetWinHeight_command,
106
                 "XDB compatibility command for setting the height of a command window.\n\
107
Usage: w <#lines>\n");
108
    }
109
 
110
  return;
111
}                               /* _intialize_tuiWin */
112
 
113
 
114
/*
115
   ** tuiClearWinFocusFrom
116
   **        Clear the logical focus from winInfo
117
 */
118
void
119
#ifdef __STDC__
120
tuiClearWinFocusFrom (
121
                       TuiWinInfoPtr winInfo)
122
#else
123
tuiClearWinFocusFrom (winInfo)
124
     TuiWinInfoPtr winInfo;
125
#endif
126
{
127
  if (m_winPtrNotNull (winInfo))
128
    {
129
      if (winInfo->generic.type != CMD_WIN)
130
        unhighlightWin (winInfo);
131
      tuiSetWinWithFocus ((TuiWinInfoPtr) NULL);
132
    }
133
 
134
  return;
135
}                               /* tuiClearWinFocusFrom */
136
 
137
 
138
/*
139
   ** tuiClearWinFocus().
140
   **        Clear the window that has focus.
141
 */
142
void
143
#ifdef __STDC__
144
tuiClearWinFocus (void)
145
#else
146
tuiClearWinFocus ()
147
#endif
148
{
149
  tuiClearWinFocusFrom (tuiWinWithFocus ());
150
 
151
  return;
152
}                               /* tuiClearWinFocus */
153
 
154
 
155
/*
156
   ** tuiSetWinFocusTo
157
   **        Set the logical focus to winInfo
158
 */
159
void
160
#ifdef __STDC__
161
tuiSetWinFocusTo (
162
                   TuiWinInfoPtr winInfo)
163
#else
164
tuiSetWinFocusTo (winInfo)
165
     TuiWinInfoPtr winInfo;
166
#endif
167
{
168
  if (m_winPtrNotNull (winInfo))
169
    {
170
      TuiWinInfoPtr winWithFocus = tuiWinWithFocus ();
171
 
172
      if (m_winPtrNotNull (winWithFocus) &&
173
          winWithFocus->generic.type != CMD_WIN)
174
        unhighlightWin (winWithFocus);
175
      tuiSetWinWithFocus (winInfo);
176
      if (winInfo->generic.type != CMD_WIN)
177
        highlightWin (winInfo);
178
    }
179
 
180
  return;
181
}                               /* tuiSetWinFocusTo */
182
 
183
 
184
char *
185
#ifdef __STDC__
186
tuiStrDup (
187
            char *str)
188
#else
189
tuiStrDup (str)
190
     char *str;
191
#endif
192
{
193
  char *newStr = (char *) NULL;
194
 
195
  if (str != (char *) NULL)
196
    {
197
      newStr = (char *) xmalloc (strlen (str) + 1);
198
      strcpy (newStr, str);
199
    }
200
 
201
  return newStr;
202
}                               /* tuiStrDup */
203
 
204
 
205
/*
206
   ** tuiScrollForward().
207
 */
208
void
209
#ifdef __STDC__
210
tuiScrollForward (
211
                   TuiWinInfoPtr winToScroll,
212
                   int numToScroll)
213
#else
214
tuiScrollForward (winToScroll, numToScroll)
215
     TuiWinInfoPtr winToScroll;
216
     int numToScroll;
217
#endif
218
{
219
  if (winToScroll != cmdWin)
220
    {
221
      int _numToScroll = numToScroll;
222
 
223
      if (numToScroll == 0)
224
        _numToScroll = winToScroll->generic.height - 3;
225
      /*
226
         ** If we are scrolling the source or disassembly window, do a
227
         ** "psuedo" scroll since not all of the source is in memory,
228
         ** only what is in the viewport.  If winToScroll is the
229
         ** command window do nothing since the term should handle it.
230
       */
231
      if (winToScroll == srcWin)
232
        tuiVerticalSourceScroll (FORWARD_SCROLL, _numToScroll);
233
      else if (winToScroll == disassemWin)
234
        tuiVerticalDisassemScroll (FORWARD_SCROLL, _numToScroll);
235
      else if (winToScroll == dataWin)
236
        tuiVerticalDataScroll (FORWARD_SCROLL, _numToScroll);
237
    }
238
 
239
  return;
240
}                               /* tuiScrollForward */
241
 
242
 
243
/*
244
   ** tuiScrollBackward().
245
 */
246
void
247
#ifdef __STDC__
248
tuiScrollBackward (
249
                    TuiWinInfoPtr winToScroll,
250
                    int numToScroll)
251
#else
252
tuiScrollBackward (winToScroll, numToScroll)
253
     TuiWinInfoPtr winToScroll;
254
     int numToScroll;
255
#endif
256
{
257
  if (winToScroll != cmdWin)
258
    {
259
      int _numToScroll = numToScroll;
260
 
261
      if (numToScroll == 0)
262
        _numToScroll = winToScroll->generic.height - 3;
263
      /*
264
         ** If we are scrolling the source or disassembly window, do a
265
         ** "psuedo" scroll since not all of the source is in memory,
266
         ** only what is in the viewport.  If winToScroll is the
267
         ** command window do nothing since the term should handle it.
268
       */
269
      if (winToScroll == srcWin)
270
        tuiVerticalSourceScroll (BACKWARD_SCROLL, _numToScroll);
271
      else if (winToScroll == disassemWin)
272
        tuiVerticalDisassemScroll (BACKWARD_SCROLL, _numToScroll);
273
      else if (winToScroll == dataWin)
274
        tuiVerticalDataScroll (BACKWARD_SCROLL, _numToScroll);
275
    }
276
  return;
277
}                               /* tuiScrollBackward */
278
 
279
 
280
/*
281
   ** tuiScrollLeft().
282
 */
283
void
284
#ifdef __STDC__
285
tuiScrollLeft (
286
                TuiWinInfoPtr winToScroll,
287
                int numToScroll)
288
#else
289
tuiScrollLeft (winToScroll, numToScroll)
290
     TuiWinInfoPtr winToScroll;
291
     int numToScroll;
292
#endif
293
{
294
  if (winToScroll != cmdWin)
295
    {
296
      int _numToScroll = numToScroll;
297
 
298
      if (_numToScroll == 0)
299
        _numToScroll = 1;
300
      /*
301
         ** If we are scrolling the source or disassembly window, do a
302
         ** "psuedo" scroll since not all of the source is in memory,
303
         ** only what is in the viewport. If winToScroll is the
304
         ** command window do nothing since the term should handle it.
305
       */
306
      if (winToScroll == srcWin || winToScroll == disassemWin)
307
        tuiHorizontalSourceScroll (winToScroll, LEFT_SCROLL, _numToScroll);
308
    }
309
  return;
310
}                               /* tuiScrollLeft */
311
 
312
 
313
/*
314
   ** tuiScrollRight().
315
 */
316
void
317
#ifdef __STDC__
318
tuiScrollRight (
319
                 TuiWinInfoPtr winToScroll,
320
                 int numToScroll)
321
#else
322
tuiScrollRight (winToScroll, numToScroll)
323
     TuiWinInfoPtr winToScroll;
324
     int numToScroll;
325
#endif
326
{
327
  if (winToScroll != cmdWin)
328
    {
329
      int _numToScroll = numToScroll;
330
 
331
      if (_numToScroll == 0)
332
        _numToScroll = 1;
333
      /*
334
         ** If we are scrolling the source or disassembly window, do a
335
         ** "psuedo" scroll since not all of the source is in memory,
336
         ** only what is in the viewport. If winToScroll is the
337
         ** command window do nothing since the term should handle it.
338
       */
339
      if (winToScroll == srcWin || winToScroll == disassemWin)
340
        tuiHorizontalSourceScroll (winToScroll, RIGHT_SCROLL, _numToScroll);
341
    }
342
  return;
343
}                               /* tuiScrollRight */
344
 
345
 
346
/*
347
   ** tui_vScroll().
348
   **    Scroll a window.  Arguments are passed through a va_list.
349
 */
350
void
351
#ifdef __STDC__
352
tui_vScroll (
353
              va_list args)
354
#else
355
tui_vScroll (args)
356
     va_list args;
357
#endif
358
{
359
  TuiScrollDirection direction = va_arg (args, TuiScrollDirection);
360
  TuiWinInfoPtr winToScroll = va_arg (args, TuiWinInfoPtr);
361
  int numToScroll = va_arg (args, int);
362
 
363
  switch (direction)
364
    {
365
    case FORWARD_SCROLL:
366
      tuiScrollForward (winToScroll, numToScroll);
367
      break;
368
    case BACKWARD_SCROLL:
369
      tuiScrollBackward (winToScroll, numToScroll);
370
      break;
371
    case LEFT_SCROLL:
372
      tuiScrollLeft (winToScroll, numToScroll);
373
      break;
374
    case RIGHT_SCROLL:
375
      tuiScrollRight (winToScroll, numToScroll);
376
      break;
377
    default:
378
      break;
379
    }
380
 
381
  return;
382
}                               /* tui_vScroll */
383
 
384
 
385
/*
386
   ** tuiRefreshAll().
387
 */
388
void
389
#ifdef __STDC__
390
tuiRefreshAll (void)
391
#else
392
tuiRefreshAll ()
393
#endif
394
{
395
  TuiWinType type;
396
 
397
  refreshAll (winList);
398
  for (type = SRC_WIN; type < MAX_MAJOR_WINDOWS; type++)
399
    {
400
      if (winList[type]->generic.isVisible)
401
        {
402
          switch (type)
403
            {
404
            case SRC_WIN:
405
            case DISASSEM_WIN:
406
              tuiClearWin (&winList[type]->generic);
407
              if (winList[type]->detail.sourceInfo.hasLocator)
408
                tuiClearLocatorDisplay ();
409
              tuiShowSourceContent (winList[type]);
410
              checkAndDisplayHighlightIfNeeded (winList[type]);
411
              tuiEraseExecInfoContent (winList[type]);
412
              tuiUpdateExecInfo (winList[type]);
413
              break;
414
            case DATA_WIN:
415
              tuiRefreshDataWin ();
416
              break;
417
            default:
418
              break;
419
            }
420
        }
421
    }
422
  tuiClearLocatorDisplay ();
423
  tuiShowLocatorContent ();
424
 
425
  return;
426
}                               /* tuiRefreshAll */
427
 
428
 
429
/*
430
   ** tuiResizeAll().
431
   **      Resize all the windows based on the the terminal size.  This
432
   **      function gets called from within the readline sinwinch handler.
433
 */
434
void
435
#ifdef __STDC__
436
tuiResizeAll (void)
437
#else
438
tuiResizeAll ()
439
#endif
440
{
441
  int heightDiff, widthDiff;
442
  extern int screenheight, screenwidth;         /* in readline */
443
 
444
  widthDiff = screenwidth - termWidth ();
445
  heightDiff = screenheight - termHeight ();
446
  if (heightDiff || widthDiff)
447
    {
448
      TuiLayoutType curLayout = currentLayout ();
449
      TuiWinInfoPtr winWithFocus = tuiWinWithFocus ();
450
      TuiWinInfoPtr firstWin, secondWin;
451
      TuiGenWinInfoPtr locator = locatorWinInfoPtr ();
452
      TuiWinType winType;
453
      int i, newHeight, splitDiff, cmdSplitDiff, numWinsDisplayed = 2;
454
 
455
      /* turn keypad off while we resize */
456
      if (winWithFocus != cmdWin)
457
        keypad (cmdWin->generic.handle, FALSE);
458
      init_page_info ();
459
      setTermHeightTo (screenheight);
460
      setTermWidthTo (screenwidth);
461
      if (curLayout == SRC_DISASSEM_COMMAND ||
462
        curLayout == SRC_DATA_COMMAND || curLayout == DISASSEM_DATA_COMMAND)
463
        numWinsDisplayed++;
464
      splitDiff = heightDiff / numWinsDisplayed;
465
      cmdSplitDiff = splitDiff;
466
      if (heightDiff % numWinsDisplayed)
467
        {
468
          if (heightDiff < 0)
469
            cmdSplitDiff--;
470
          else
471
            cmdSplitDiff++;
472
        }
473
      /* now adjust each window */
474
      clear ();
475
      refresh ();
476
      switch (curLayout)
477
        {
478
        case SRC_COMMAND:
479
        case DISASSEM_COMMAND:
480
          firstWin = (TuiWinInfoPtr) (sourceWindows ())->list[0];
481
          firstWin->generic.width += widthDiff;
482
          locator->width += widthDiff;
483
          /* check for invalid heights */
484
          if (heightDiff == 0)
485
            newHeight = firstWin->generic.height;
486
          else if ((firstWin->generic.height + splitDiff) >=
487
                   (screenheight - MIN_CMD_WIN_HEIGHT - 1))
488
            newHeight = screenheight - MIN_CMD_WIN_HEIGHT - 1;
489
          else if ((firstWin->generic.height + splitDiff) <= 0)
490
            newHeight = MIN_WIN_HEIGHT;
491
          else
492
            newHeight = firstWin->generic.height + splitDiff;
493
 
494
          _makeInvisibleAndSetNewHeight (firstWin, newHeight);
495
          cmdWin->generic.origin.y = locator->origin.y + 1;
496
          cmdWin->generic.width += widthDiff;
497
          newHeight = screenheight - cmdWin->generic.origin.y;
498
          _makeInvisibleAndSetNewHeight (cmdWin, newHeight);
499
          _makeVisibleWithNewHeight (firstWin);
500
          _makeVisibleWithNewHeight (cmdWin);
501
          if (firstWin->generic.contentSize <= 0)
502
            tuiEraseSourceContent (firstWin, EMPTY_SOURCE_PROMPT);
503
          break;
504
        default:
505
          if (curLayout == SRC_DISASSEM_COMMAND)
506
            {
507
              firstWin = srcWin;
508
              firstWin->generic.width += widthDiff;
509
              secondWin = disassemWin;
510
              secondWin->generic.width += widthDiff;
511
            }
512
          else
513
            {
514
              firstWin = dataWin;
515
              firstWin->generic.width += widthDiff;
516
              secondWin = (TuiWinInfoPtr) (sourceWindows ())->list[0];
517
              secondWin->generic.width += widthDiff;
518
            }
519
          /* Change the first window's height/width */
520
          /* check for invalid heights */
521
          if (heightDiff == 0)
522
            newHeight = firstWin->generic.height;
523
          else if ((firstWin->generic.height +
524
                    secondWin->generic.height + (splitDiff * 2)) >=
525
                   (screenheight - MIN_CMD_WIN_HEIGHT - 1))
526
            newHeight = (screenheight - MIN_CMD_WIN_HEIGHT - 1) / 2;
527
          else if ((firstWin->generic.height + splitDiff) <= 0)
528
            newHeight = MIN_WIN_HEIGHT;
529
          else
530
            newHeight = firstWin->generic.height + splitDiff;
531
          _makeInvisibleAndSetNewHeight (firstWin, newHeight);
532
 
533
          if (firstWin == dataWin && widthDiff != 0)
534
            firstWin->detail.dataDisplayInfo.regsColumnCount =
535
              tuiCalculateRegsColumnCount (
536
                          firstWin->detail.dataDisplayInfo.regsDisplayType);
537
          locator->width += widthDiff;
538
 
539
          /* Change the second window's height/width */
540
          /* check for invalid heights */
541
          if (heightDiff == 0)
542
            newHeight = secondWin->generic.height;
543
          else if ((firstWin->generic.height +
544
                    secondWin->generic.height + (splitDiff * 2)) >=
545
                   (screenheight - MIN_CMD_WIN_HEIGHT - 1))
546
            {
547
              newHeight = screenheight - MIN_CMD_WIN_HEIGHT - 1;
548
              if (newHeight % 2)
549
                newHeight = (newHeight / 2) + 1;
550
              else
551
                newHeight /= 2;
552
            }
553
          else if ((secondWin->generic.height + splitDiff) <= 0)
554
            newHeight = MIN_WIN_HEIGHT;
555
          else
556
            newHeight = secondWin->generic.height + splitDiff;
557
          secondWin->generic.origin.y = firstWin->generic.height - 1;
558
          _makeInvisibleAndSetNewHeight (secondWin, newHeight);
559
 
560
          /* Change the command window's height/width */
561
          cmdWin->generic.origin.y = locator->origin.y + 1;
562
          _makeInvisibleAndSetNewHeight (
563
                             cmdWin, cmdWin->generic.height + cmdSplitDiff);
564
          _makeVisibleWithNewHeight (firstWin);
565
          _makeVisibleWithNewHeight (secondWin);
566
          _makeVisibleWithNewHeight (cmdWin);
567
          if (firstWin->generic.contentSize <= 0)
568
            tuiEraseSourceContent (firstWin, EMPTY_SOURCE_PROMPT);
569
          if (secondWin->generic.contentSize <= 0)
570
            tuiEraseSourceContent (secondWin, EMPTY_SOURCE_PROMPT);
571
          break;
572
        }
573
      /*
574
         ** Now remove all invisible windows, and their content so that they get
575
         ** created again when called for with the new size
576
       */
577
      for (winType = SRC_WIN; (winType < MAX_MAJOR_WINDOWS); winType++)
578
        {
579
          if (winType != CMD_WIN && m_winPtrNotNull (winList[winType]) &&
580
              !winList[winType]->generic.isVisible)
581
            {
582
              freeWindow (winList[winType]);
583
              winList[winType] = (TuiWinInfoPtr) NULL;
584
            }
585
        }
586
      tuiSetWinResizedTo (TRUE);
587
      /* turn keypad back on, unless focus is in the command window */
588
      if (winWithFocus != cmdWin)
589
        keypad (cmdWin->generic.handle, TRUE);
590
    }
591
  return;
592
}                               /* tuiResizeAll */
593
 
594
 
595
/*
596
   ** tuiSigwinchHandler()
597
   **    SIGWINCH signal handler for the tui.  This signal handler is
598
   **    always called, even when the readline package clears signals
599
   **    because it is set as the old_sigwinch() (TUI only)
600
 */
601
void
602
#ifdef __STDC__
603
tuiSigwinchHandler (
604
                     int signal)
605
#else
606
tuiSigwinchHandler (signal)
607
     int signal;
608
#endif
609
{
610
  /*
611
     ** Say that a resize was done so that the readline can do it
612
     ** later when appropriate.
613
   */
614
  tuiSetWinResizedTo (TRUE);
615
 
616
  return;
617
}                               /* tuiSigwinchHandler */
618
 
619
 
620
 
621
/*************************
622
** STATIC LOCAL FUNCTIONS
623
**************************/
624
 
625
 
626
/*
627
   ** _tuiScrollForward_command().
628
 */
629
static void
630
#ifdef __STDC__
631
_tuiScrollForward_command (
632
                            char *arg,
633
                            int fromTTY)
634
#else
635
_tuiScrollForward_command (arg, fromTTY)
636
     char *arg;
637
     int fromTTY;
638
#endif
639
{
640
  int numToScroll = 1;
641
  TuiWinInfoPtr winToScroll;
642
 
643
  if (arg == (char *) NULL)
644
    _parseScrollingArgs (arg, &winToScroll, (int *) NULL);
645
  else
646
    _parseScrollingArgs (arg, &winToScroll, &numToScroll);
647
  tuiDo ((TuiOpaqueFuncPtr) tui_vScroll,
648
         FORWARD_SCROLL,
649
         winToScroll,
650
         numToScroll);
651
 
652
  return;
653
}                               /* _tuiScrollForward_command */
654
 
655
 
656
/*
657
   ** _tuiScrollBackward_command().
658
 */
659
static void
660
#ifdef __STDC__
661
_tuiScrollBackward_command (
662
                             char *arg,
663
                             int fromTTY)
664
#else
665
_tuiScrollBackward_command (arg, fromTTY)
666
     char *arg;
667
     int fromTTY;
668
#endif
669
{
670
  int numToScroll = 1;
671
  TuiWinInfoPtr winToScroll;
672
 
673
  if (arg == (char *) NULL)
674
    _parseScrollingArgs (arg, &winToScroll, (int *) NULL);
675
  else
676
    _parseScrollingArgs (arg, &winToScroll, &numToScroll);
677
  tuiDo ((TuiOpaqueFuncPtr) tui_vScroll,
678
         BACKWARD_SCROLL,
679
         winToScroll,
680
         numToScroll);
681
 
682
  return;
683
}                               /* _tuiScrollBackward_command */
684
 
685
 
686
/*
687
   ** _tuiScrollLeft_command().
688
 */
689
static void
690
#ifdef __STDC__
691
_tuiScrollLeft_command (
692
                         char *arg,
693
                         int fromTTY)
694
#else
695
_tuiScrollLeft_command (arg, fromTTY)
696
     char *arg;
697
     int fromTTY;
698
#endif
699
{
700
  int numToScroll;
701
  TuiWinInfoPtr winToScroll;
702
 
703
  _parseScrollingArgs (arg, &winToScroll, &numToScroll);
704
  tuiDo ((TuiOpaqueFuncPtr) tui_vScroll,
705
         LEFT_SCROLL,
706
         winToScroll,
707
         numToScroll);
708
 
709
  return;
710
}                               /* _tuiScrollLeft_command */
711
 
712
 
713
/*
714
   ** _tuiScrollRight_command().
715
 */
716
static void
717
#ifdef __STDC__
718
_tuiScrollRight_command (
719
                          char *arg,
720
                          int fromTTY)
721
#else
722
_tuiScrollRight_command (arg, fromTTY)
723
     char *arg;
724
     int fromTTY;
725
#endif
726
{
727
  int numToScroll;
728
  TuiWinInfoPtr winToScroll;
729
 
730
  _parseScrollingArgs (arg, &winToScroll, &numToScroll);
731
  tuiDo ((TuiOpaqueFuncPtr) tui_vScroll,
732
         RIGHT_SCROLL,
733
         winToScroll,
734
         numToScroll);
735
 
736
  return;
737
}                               /* _tuiScrollRight_command */
738
 
739
 
740
/*
741
   ** _tuiSetFocus().
742
   **     Set focus to the window named by 'arg'
743
 */
744
static void
745
#ifdef __STDC__
746
_tuiSetFocus (
747
               char *arg,
748
               int fromTTY)
749
#else
750
_tuiSetFocus (arg, fromTTY)
751
     char *arg;
752
     int fromTTY;
753
#endif
754
{
755
  if (arg != (char *) NULL)
756
    {
757
      char *bufPtr = (char *) tuiStrDup (arg);
758
      int i;
759
      TuiWinInfoPtr winInfo = (TuiWinInfoPtr) NULL;
760
 
761
      for (i = 0; (i < strlen (bufPtr)); i++)
762
        bufPtr[i] = toupper (arg[i]);
763
 
764
      if (subsetCompare (bufPtr, "NEXT"))
765
        winInfo = tuiNextWin (tuiWinWithFocus ());
766
      else if (subsetCompare (bufPtr, "PREV"))
767
        winInfo = tuiPrevWin (tuiWinWithFocus ());
768
      else
769
        winInfo = partialWinByName (bufPtr);
770
 
771
      if (winInfo == (TuiWinInfoPtr) NULL || !winInfo->generic.isVisible)
772
        warning ("Invalid window specified. \n\
773
The window name specified must be valid and visible.\n");
774
      else
775
        {
776
          tuiSetWinFocusTo (winInfo);
777
          keypad (cmdWin->generic.handle, (winInfo != cmdWin));
778
        }
779
 
780
      if (dataWin->generic.isVisible)
781
        tuiRefreshDataWin ();
782
      tuiFree (bufPtr);
783
      printf_filtered ("Focus set to %s window.\n",
784
                       winName ((TuiGenWinInfoPtr) tuiWinWithFocus ()));
785
    }
786
  else
787
    warning ("Incorrect Number of Arguments.\n%s", FOCUS_USAGE);
788
 
789
  return;
790
}                               /* _tuiSetFocus */
791
 
792
 
793
/*
794
   ** _tui_vSetFocus()
795
 */
796
static void
797
#ifdef __STDC__
798
_tui_vSetFocus (
799
                 va_list args)
800
#else
801
_tui_vSetFocus (args)
802
     va_list args;
803
#endif
804
{
805
  char *arg = va_arg (args, char *);
806
  int fromTTY = va_arg (args, int);
807
 
808
  _tuiSetFocus (arg, fromTTY);
809
 
810
  return;
811
}                               /* tui_vSetFocus */
812
 
813
 
814
/*
815
   ** _tuiSetFocus_command()
816
 */
817
static void
818
#ifdef __STDC__
819
_tuiSetFocus_command (
820
                       char *arg,
821
                       int fromTTY)
822
#else
823
_tuiSetFocus_command (arg, fromTTY)
824
     char *arg;
825
     int fromTTY;
826
#endif
827
{
828
  tuiDo ((TuiOpaqueFuncPtr) _tui_vSetFocus, arg, fromTTY);
829
 
830
  return;
831
}                               /* tui_SetFocus */
832
 
833
 
834
/*
835
   ** _tuiAllWindowsInfo().
836
 */
837
static void
838
#ifdef __STDC__
839
_tuiAllWindowsInfo (
840
                     char *arg,
841
                     int fromTTY)
842
#else
843
_tuiAllWindowsInfo (arg, fromTTY)
844
     char *arg;
845
     int fromTTY;
846
#endif
847
{
848
  TuiWinType type;
849
  TuiWinInfoPtr winWithFocus = tuiWinWithFocus ();
850
 
851
  for (type = SRC_WIN; (type < MAX_MAJOR_WINDOWS); type++)
852
    if (winList[type]->generic.isVisible)
853
      {
854
        if (winWithFocus == winList[type])
855
          printf_filtered ("        %s\t(%d lines)  <has focus>\n",
856
                           winName (&winList[type]->generic),
857
                           winList[type]->generic.height);
858
        else
859
          printf_filtered ("        %s\t(%d lines)\n",
860
                           winName (&winList[type]->generic),
861
                           winList[type]->generic.height);
862
      }
863
 
864
  return;
865
}                               /* _tuiAllWindowsInfo */
866
 
867
 
868
/*
869
   ** _tuiRefreshAll_command().
870
 */
871
static void
872
#ifdef __STDC__
873
_tuiRefreshAll_command (
874
                         char *arg,
875
                         int fromTTY)
876
#else
877
_tuiRefreshAll_command (arg, fromTTY)
878
     char *arg;
879
     int fromTTY;
880
#endif
881
{
882
  tuiDo ((TuiOpaqueFuncPtr) tuiRefreshAll);
883
}
884
 
885
 
886
/*
887
   ** _tuiSetWinTabWidth_command().
888
   **        Set the height of the specified window.
889
 */
890
static void
891
#ifdef __STDC__
892
_tuiSetTabWidth_command (
893
                          char *arg,
894
                          int fromTTY)
895
#else
896
_tuiSetTabWidth_command (arg, fromTTY)
897
     char *arg;
898
     int fromTTY;
899
#endif
900
{
901
  if (arg != (char *) NULL)
902
    {
903
      int ts;
904
 
905
      ts = atoi (arg);
906
      if (ts > 0)
907
        tuiSetDefaultTabLen (ts);
908
      else
909
        warning ("Tab widths greater than 0 must be specified.\n");
910
    }
911
 
912
  return;
913
}                               /* _tuiSetTabWidth_command */
914
 
915
 
916
/*
917
   ** _tuiSetWinHeight().
918
   **        Set the height of the specified window.
919
 */
920
static void
921
#ifdef __STDC__
922
_tuiSetWinHeight (
923
                   char *arg,
924
                   int fromTTY)
925
#else
926
_tuiSetWinHeight (arg, fromTTY)
927
     char *arg;
928
     int fromTTY;
929
#endif
930
{
931
  if (arg != (char *) NULL)
932
    {
933
      char *buf = tuiStrDup (arg);
934
      char *bufPtr = buf;
935
      char *wname = (char *) NULL;
936
      int newHeight, i;
937
      TuiWinInfoPtr winInfo;
938
 
939
      wname = bufPtr;
940
      bufPtr = strchr (bufPtr, ' ');
941
      if (bufPtr != (char *) NULL)
942
        {
943
          *bufPtr = (char) 0;
944
 
945
          /*
946
             ** Validate the window name
947
           */
948
          for (i = 0; i < strlen (wname); i++)
949
            wname[i] = toupper (wname[i]);
950
          winInfo = partialWinByName (wname);
951
 
952
          if (winInfo == (TuiWinInfoPtr) NULL || !winInfo->generic.isVisible)
953
            warning ("Invalid window specified. \n\
954
The window name specified must be valid and visible.\n");
955
          else
956
            {
957
              /* Process the size */
958
              while (*(++bufPtr) == ' ')
959
                ;
960
 
961
              if (*bufPtr != (char) 0)
962
                {
963
                  int negate = FALSE;
964
                  int fixedSize = TRUE;
965
                  int inputNo;;
966
 
967
                  if (*bufPtr == '+' || *bufPtr == '-')
968
                    {
969
                      if (*bufPtr == '-')
970
                        negate = TRUE;
971
                      fixedSize = FALSE;
972
                      bufPtr++;
973
                    }
974
                  inputNo = atoi (bufPtr);
975
                  if (inputNo > 0)
976
                    {
977
                      if (negate)
978
                        inputNo *= (-1);
979
                      if (fixedSize)
980
                        newHeight = inputNo;
981
                      else
982
                        newHeight = winInfo->generic.height + inputNo;
983
                      /*
984
                         ** Now change the window's height, and adjust all
985
                         ** other windows around it
986
                       */
987
                      if (_tuiAdjustWinHeights (winInfo,
988
                                                newHeight) == TUI_FAILURE)
989
                        warning ("Invalid window height specified.\n%s",
990
                                 WIN_HEIGHT_USAGE);
991
                      else
992
                        init_page_info ();
993
                    }
994
                  else
995
                    warning ("Invalid window height specified.\n%s",
996
                             WIN_HEIGHT_USAGE);
997
                }
998
            }
999
        }
1000
      else
1001
        printf_filtered (WIN_HEIGHT_USAGE);
1002
 
1003
      if (buf != (char *) NULL)
1004
        tuiFree (buf);
1005
    }
1006
  else
1007
    printf_filtered (WIN_HEIGHT_USAGE);
1008
 
1009
  return;
1010
}                               /* _tuiSetWinHeight */
1011
 
1012
 
1013
/*
1014
   ** _tui_vSetWinHeight().
1015
   **        Set the height of the specified window, with va_list.
1016
 */
1017
static void
1018
#ifdef __STDC__
1019
_tui_vSetWinHeight (
1020
                     va_list args)
1021
#else
1022
_tui_vSetWinHeight (args)
1023
     va_list args;
1024
#endif
1025
{
1026
  char *arg = va_arg (args, char *);
1027
  int fromTTY = va_arg (args, int);
1028
 
1029
  _tuiSetWinHeight (arg, fromTTY);
1030
 
1031
  return;
1032
}                               /* _tui_vSetWinHeight */
1033
 
1034
 
1035
/*
1036
   ** _tuiSetWinHeight_command().
1037
   **        Set the height of the specified window, with va_list.
1038
 */
1039
static void
1040
#ifdef __STDC__
1041
_tuiSetWinHeight_command (
1042
                           char *arg,
1043
                           int fromTTY)
1044
#else
1045
_tuiSetWinHeight_command (arg, fromTTY)
1046
     char *arg;
1047
     int fromTTY;
1048
#endif
1049
{
1050
  tuiDo ((TuiOpaqueFuncPtr) _tui_vSetWinHeight, arg, fromTTY);
1051
 
1052
  return;
1053
}                               /* _tuiSetWinHeight_command */
1054
 
1055
 
1056
/*
1057
   ** _tuiXDBsetWinHeight().
1058
   **        XDB Compatibility command for setting the window height.  This will
1059
   **        increase or decrease the command window by the specified amount.
1060
 */
1061
static void
1062
#ifdef __STDC__
1063
_tuiXDBsetWinHeight (
1064
                      char *arg,
1065
                      int fromTTY)
1066
#else
1067
_tuiXDBsetWinHeight (arg, fromTTY)
1068
     char *arg;
1069
     int fromTTY;
1070
#endif
1071
{
1072
  if (arg != (char *) NULL)
1073
    {
1074
      int inputNo = atoi (arg);
1075
 
1076
      if (inputNo > 0)
1077
        {                       /* Add 1 for the locator */
1078
          int newHeight = termHeight () - (inputNo + 1);
1079
 
1080
          if (!_newHeightOk (winList[CMD_WIN], newHeight) ||
1081
              _tuiAdjustWinHeights (winList[CMD_WIN],
1082
                                    newHeight) == TUI_FAILURE)
1083
            warning ("Invalid window height specified.\n%s",
1084
                     XDBWIN_HEIGHT_USAGE);
1085
        }
1086
      else
1087
        warning ("Invalid window height specified.\n%s",
1088
                 XDBWIN_HEIGHT_USAGE);
1089
    }
1090
  else
1091
    warning ("Invalid window height specified.\n%s", XDBWIN_HEIGHT_USAGE);
1092
 
1093
  return;
1094
}                               /* _tuiXDBsetWinHeight */
1095
 
1096
 
1097
/*
1098
   ** _tui_vXDBsetWinHeight().
1099
   **        Set the height of the specified window, with va_list.
1100
 */
1101
static void
1102
#ifdef __STDC__
1103
_tui_vXDBsetWinHeight (
1104
                        va_list args)
1105
#else
1106
_tui_vXDBsetWinHeight (args)
1107
     va_list args;
1108
#endif
1109
{
1110
  char *arg = va_arg (args, char *);
1111
  int fromTTY = va_arg (args, int);
1112
 
1113
  _tuiXDBsetWinHeight (arg, fromTTY);
1114
 
1115
  return;
1116
}                               /* _tui_vXDBsetWinHeight */
1117
 
1118
 
1119
/*
1120
   ** _tuiSetWinHeight_command().
1121
   **        Set the height of the specified window, with va_list.
1122
 */
1123
static void
1124
#ifdef __STDC__
1125
_tuiXDBsetWinHeight_command (
1126
                              char *arg,
1127
                              int fromTTY)
1128
#else
1129
_tuiXDBsetWinHeight_command (arg, fromTTY)
1130
     char *arg;
1131
     int fromTTY;
1132
#endif
1133
{
1134
  tuiDo ((TuiOpaqueFuncPtr) _tui_vXDBsetWinHeight, arg, fromTTY);
1135
 
1136
  return;
1137
}                               /* _tuiXDBsetWinHeight_command */
1138
 
1139
 
1140
/*
1141
   ** _tuiAdjustWinHeights().
1142
   **        Function to adjust all window heights around the primary
1143
 */
1144
static TuiStatus
1145
#ifdef __STDC__
1146
_tuiAdjustWinHeights (
1147
                       TuiWinInfoPtr primaryWinInfo,
1148
                       int newHeight)
1149
#else
1150
_tuiAdjustWinHeights (primaryWinInfo, newHeight)
1151
     TuiWinInfoPtr primaryWinInfo;
1152
     int newHeight;
1153
#endif
1154
{
1155
  TuiStatus status = TUI_FAILURE;
1156
 
1157
  if (_newHeightOk (primaryWinInfo, newHeight))
1158
    {
1159
      status = TUI_SUCCESS;
1160
      if (newHeight != primaryWinInfo->generic.height)
1161
        {
1162
          int i, diff;
1163
          TuiWinInfoPtr winInfo;
1164
          TuiGenWinInfoPtr locator = locatorWinInfoPtr ();
1165
          TuiLayoutType curLayout = currentLayout ();
1166
 
1167
          diff = (newHeight - primaryWinInfo->generic.height) * (-1);
1168
          if (curLayout == SRC_COMMAND || curLayout == DISASSEM_COMMAND)
1169
            {
1170
              TuiWinInfoPtr srcWinInfo;
1171
 
1172
              _makeInvisibleAndSetNewHeight (primaryWinInfo, newHeight);
1173
              if (primaryWinInfo->generic.type == CMD_WIN)
1174
                {
1175
                  winInfo = (TuiWinInfoPtr) (sourceWindows ())->list[0];
1176
                  srcWinInfo = winInfo;
1177
                }
1178
              else
1179
                {
1180
                  winInfo = winList[CMD_WIN];
1181
                  srcWinInfo = primaryWinInfo;
1182
                }
1183
              _makeInvisibleAndSetNewHeight (winInfo,
1184
                                             winInfo->generic.height + diff);
1185
              cmdWin->generic.origin.y = locator->origin.y + 1;
1186
              _makeVisibleWithNewHeight (winInfo);
1187
              _makeVisibleWithNewHeight (primaryWinInfo);
1188
              if (srcWinInfo->generic.contentSize <= 0)
1189
                tuiEraseSourceContent (srcWinInfo, EMPTY_SOURCE_PROMPT);
1190
            }
1191
          else
1192
            {
1193
              TuiWinInfoPtr firstWin, secondWin;
1194
 
1195
              if (curLayout == SRC_DISASSEM_COMMAND)
1196
                {
1197
                  firstWin = srcWin;
1198
                  secondWin = disassemWin;
1199
                }
1200
              else
1201
                {
1202
                  firstWin = dataWin;
1203
                  secondWin = (TuiWinInfoPtr) (sourceWindows ())->list[0];
1204
                }
1205
              if (primaryWinInfo == cmdWin)
1206
                {               /*
1207
                                   ** Split the change in height accross the 1st & 2nd windows
1208
                                   ** adjusting them as well.
1209
                                 */
1210
                  int firstSplitDiff = diff / 2;        /* subtract the locator */
1211
                  int secondSplitDiff = firstSplitDiff;
1212
 
1213
                  if (diff % 2)
1214
                    {
1215
                      if (firstWin->generic.height >
1216
                          secondWin->generic.height)
1217
                        if (diff < 0)
1218
                          firstSplitDiff--;
1219
                        else
1220
                          firstSplitDiff++;
1221
                      else
1222
                        {
1223
                          if (diff < 0)
1224
                            secondSplitDiff--;
1225
                          else
1226
                            secondSplitDiff++;
1227
                        }
1228
                    }
1229
                  /* make sure that the minimum hieghts are honored */
1230
                  while ((firstWin->generic.height + firstSplitDiff) < 3)
1231
                    {
1232
                      firstSplitDiff++;
1233
                      secondSplitDiff--;
1234
                    }
1235
                  while ((secondWin->generic.height + secondSplitDiff) < 3)
1236
                    {
1237
                      secondSplitDiff++;
1238
                      firstSplitDiff--;
1239
                    }
1240
                  _makeInvisibleAndSetNewHeight (
1241
                                                  firstWin,
1242
                                 firstWin->generic.height + firstSplitDiff);
1243
                  secondWin->generic.origin.y = firstWin->generic.height - 1;
1244
                  _makeInvisibleAndSetNewHeight (
1245
                    secondWin, secondWin->generic.height + secondSplitDiff);
1246
                  cmdWin->generic.origin.y = locator->origin.y + 1;
1247
                  _makeInvisibleAndSetNewHeight (cmdWin, newHeight);
1248
                }
1249
              else
1250
                {
1251
                  if ((cmdWin->generic.height + diff) < 1)
1252
                    {           /*
1253
                                   ** If there is no way to increase the command window
1254
                                   ** take real estate from the 1st or 2nd window.
1255
                                 */
1256
                      if ((cmdWin->generic.height + diff) < 1)
1257
                        {
1258
                          int i;
1259
                          for (i = cmdWin->generic.height + diff;
1260
                               (i < 1); i++)
1261
                            if (primaryWinInfo == firstWin)
1262
                              secondWin->generic.height--;
1263
                            else
1264
                              firstWin->generic.height--;
1265
                        }
1266
                    }
1267
                  if (primaryWinInfo == firstWin)
1268
                    _makeInvisibleAndSetNewHeight (firstWin, newHeight);
1269
                  else
1270
                    _makeInvisibleAndSetNewHeight (
1271
                                                    firstWin,
1272
                                                  firstWin->generic.height);
1273
                  secondWin->generic.origin.y = firstWin->generic.height - 1;
1274
                  if (primaryWinInfo == secondWin)
1275
                    _makeInvisibleAndSetNewHeight (secondWin, newHeight);
1276
                  else
1277
                    _makeInvisibleAndSetNewHeight (
1278
                                      secondWin, secondWin->generic.height);
1279
                  cmdWin->generic.origin.y = locator->origin.y + 1;
1280
                  if ((cmdWin->generic.height + diff) < 1)
1281
                    _makeInvisibleAndSetNewHeight (cmdWin, 1);
1282
                  else
1283
                    _makeInvisibleAndSetNewHeight (
1284
                                     cmdWin, cmdWin->generic.height + diff);
1285
                }
1286
              _makeVisibleWithNewHeight (cmdWin);
1287
              _makeVisibleWithNewHeight (secondWin);
1288
              _makeVisibleWithNewHeight (firstWin);
1289
              if (firstWin->generic.contentSize <= 0)
1290
                tuiEraseSourceContent (firstWin, EMPTY_SOURCE_PROMPT);
1291
              if (secondWin->generic.contentSize <= 0)
1292
                tuiEraseSourceContent (secondWin, EMPTY_SOURCE_PROMPT);
1293
            }
1294
        }
1295
    }
1296
 
1297
  return status;
1298
}                               /* _tuiAdjustWinHeights */
1299
 
1300
 
1301
/*
1302
   ** _makeInvisibleAndSetNewHeight().
1303
   **        Function make the target window (and auxillary windows associated
1304
   **        with the targer) invisible, and set the new height and location.
1305
 */
1306
static void
1307
#ifdef __STDC__
1308
_makeInvisibleAndSetNewHeight (
1309
                                TuiWinInfoPtr winInfo,
1310
                                int height)
1311
#else
1312
_makeInvisibleAndSetNewHeight (winInfo, height)
1313
     TuiWinInfoPtr winInfo;
1314
     int height;
1315
#endif
1316
{
1317
  int i;
1318
  struct symtab *s;
1319
  TuiGenWinInfoPtr genWinInfo;
1320
 
1321
 
1322
  m_beInvisible (&winInfo->generic);
1323
  winInfo->generic.height = height;
1324
  if (height > 1)
1325
    winInfo->generic.viewportHeight = height - 1;
1326
  else
1327
    winInfo->generic.viewportHeight = height;
1328
  if (winInfo != cmdWin)
1329
    winInfo->generic.viewportHeight--;
1330
 
1331
  /* Now deal with the auxillary windows associated with winInfo */
1332
  switch (winInfo->generic.type)
1333
    {
1334
    case SRC_WIN:
1335
    case DISASSEM_WIN:
1336
      genWinInfo = winInfo->detail.sourceInfo.executionInfo;
1337
      m_beInvisible (genWinInfo);
1338
      genWinInfo->height = height;
1339
      genWinInfo->origin.y = winInfo->generic.origin.y;
1340
      if (height > 1)
1341
        genWinInfo->viewportHeight = height - 1;
1342
      else
1343
        genWinInfo->viewportHeight = height;
1344
      if (winInfo != cmdWin)
1345
        genWinInfo->viewportHeight--;
1346
 
1347
      if (m_hasLocator (winInfo))
1348
        {
1349
          genWinInfo = locatorWinInfoPtr ();
1350
          m_beInvisible (genWinInfo);
1351
          genWinInfo->origin.y = winInfo->generic.origin.y + height;
1352
        }
1353
      break;
1354
    case DATA_WIN:
1355
      /* delete all data item windows */
1356
      for (i = 0; i < winInfo->generic.contentSize; i++)
1357
        {
1358
          genWinInfo = (TuiGenWinInfoPtr) & ((TuiWinElementPtr)
1359
                      winInfo->generic.content[i])->whichElement.dataWindow;
1360
          tuiDelwin (genWinInfo->handle);
1361
          genWinInfo->handle = (WINDOW *) NULL;
1362
        }
1363
      break;
1364
    default:
1365
      break;
1366
    }
1367
 
1368
  return;
1369
}                               /* _makeInvisibleAndSetNewHeight */
1370
 
1371
 
1372
/*
1373
   ** _makeVisibleWithNewHeight().
1374
   **        Function to make the windows with new heights visible.
1375
   **        This means re-creating the windows' content since the window
1376
   **        had to be destroyed to be made invisible.
1377
 */
1378
static void
1379
#ifdef __STDC__
1380
_makeVisibleWithNewHeight (
1381
                            TuiWinInfoPtr winInfo)
1382
#else
1383
_makeVisibleWithNewHeight (winInfo)
1384
     TuiWinInfoPtr winInfo;
1385
#endif
1386
{
1387
  int i;
1388
  struct symtab *s;
1389
 
1390
  m_beVisible (&winInfo->generic);
1391
  checkAndDisplayHighlightIfNeeded (winInfo);
1392
  switch (winInfo->generic.type)
1393
    {
1394
    case SRC_WIN:
1395
    case DISASSEM_WIN:
1396
      freeWinContent (winInfo->detail.sourceInfo.executionInfo);
1397
      m_beVisible (winInfo->detail.sourceInfo.executionInfo);
1398
      if (winInfo->generic.content != (OpaquePtr) NULL)
1399
        {
1400
          TuiLineOrAddress lineOrAddr;
1401
 
1402
          if (winInfo->generic.type == SRC_WIN)
1403
            lineOrAddr.lineNo =
1404
              winInfo->detail.sourceInfo.startLineOrAddr.lineNo;
1405
          else
1406
            lineOrAddr.addr =
1407
              winInfo->detail.sourceInfo.startLineOrAddr.addr;
1408
          freeWinContent (&winInfo->generic);
1409
          tuiUpdateSourceWindow (winInfo,
1410
                                 current_source_symtab,
1411
                                 ((winInfo->generic.type == SRC_WIN) ?
1412
                                  (Opaque) lineOrAddr.lineNo :
1413
                                  lineOrAddr.addr),
1414
                                 TRUE);
1415
        }
1416
      else if (selected_frame != (struct frame_info *) NULL)
1417
        {
1418
          Opaque line = 0;
1419
          extern int current_source_line;
1420
 
1421
          s = find_pc_symtab (selected_frame->pc);
1422
          if (winInfo->generic.type == SRC_WIN)
1423
            line = (Opaque) current_source_line;
1424
          else
1425
            line = (Opaque) find_line_pc (s, current_source_line);
1426
          tuiUpdateSourceWindow (winInfo, s, line, TRUE);
1427
        }
1428
      if (m_hasLocator (winInfo))
1429
        {
1430
          m_beVisible (locatorWinInfoPtr ());
1431
          tuiClearLocatorDisplay ();
1432
          tuiShowLocatorContent ();
1433
        }
1434
      break;
1435
    case DATA_WIN:
1436
      tuiDisplayAllData ();
1437
      break;
1438
    case CMD_WIN:
1439
      winInfo->detail.commandInfo.curLine = 0;
1440
      winInfo->detail.commandInfo.curch = 0;
1441
      wmove (winInfo->generic.handle,
1442
             winInfo->detail.commandInfo.curLine,
1443
             winInfo->detail.commandInfo.curch);
1444
      break;
1445
    default:
1446
      break;
1447
    }
1448
 
1449
  return;
1450
}                               /* _makeVisibleWithNewHeight */
1451
 
1452
 
1453
static int
1454
#ifdef __STDC__
1455
_newHeightOk (
1456
               TuiWinInfoPtr primaryWinInfo,
1457
               int newHeight)
1458
#else
1459
_newHeightOk (primaryWinInfo, newHeight)
1460
     TuiWinInfoPtr primaryWinInfo;
1461
     int newHeight;
1462
#endif
1463
{
1464
  int ok = (newHeight < termHeight ());
1465
 
1466
  if (ok)
1467
    {
1468
      int diff, curHeight;
1469
      TuiLayoutType curLayout = currentLayout ();
1470
 
1471
      diff = (newHeight - primaryWinInfo->generic.height) * (-1);
1472
      if (curLayout == SRC_COMMAND || curLayout == DISASSEM_COMMAND)
1473
        {
1474
          ok = ((primaryWinInfo->generic.type == CMD_WIN &&
1475
                 newHeight <= (termHeight () - 4) &&
1476
                 newHeight >= MIN_CMD_WIN_HEIGHT) ||
1477
                (primaryWinInfo->generic.type != CMD_WIN &&
1478
                 newHeight <= (termHeight () - 2) &&
1479
                 newHeight >= MIN_WIN_HEIGHT));
1480
          if (ok)
1481
            {                   /* check the total height */
1482
              TuiWinInfoPtr winInfo;
1483
 
1484
              if (primaryWinInfo == cmdWin)
1485
                winInfo = (TuiWinInfoPtr) (sourceWindows ())->list[0];
1486
              else
1487
                winInfo = cmdWin;
1488
              ok = ((newHeight +
1489
                     (winInfo->generic.height + diff)) <= termHeight ());
1490
            }
1491
        }
1492
      else
1493
        {
1494
          int curTotalHeight, totalHeight, minHeight;
1495
          TuiWinInfoPtr firstWin, secondWin;
1496
 
1497
          if (curLayout == SRC_DISASSEM_COMMAND)
1498
            {
1499
              firstWin = srcWin;
1500
              secondWin = disassemWin;
1501
            }
1502
          else
1503
            {
1504
              firstWin = dataWin;
1505
              secondWin = (TuiWinInfoPtr) (sourceWindows ())->list[0];
1506
            }
1507
          /*
1508
             ** We could simply add all the heights to obtain the same result
1509
             ** but below is more explicit since we subtract 1 for the
1510
             ** line that the first and second windows share, and add one
1511
             ** for the locator.
1512
           */
1513
          curTotalHeight =
1514
            (firstWin->generic.height + secondWin->generic.height - 1)
1515
            + cmdWin->generic.height + 1 /*locator */ ;
1516
          if (primaryWinInfo == cmdWin)
1517
            {
1518
              /* locator included since first & second win share a line */
1519
              ok = ((firstWin->generic.height +
1520
                     secondWin->generic.height + diff) >=
1521
                    (MIN_WIN_HEIGHT * 2) &&
1522
                    newHeight >= MIN_CMD_WIN_HEIGHT);
1523
              if (ok)
1524
                {
1525
                  totalHeight = newHeight + (firstWin->generic.height +
1526
                                          secondWin->generic.height + diff);
1527
                  minHeight = MIN_CMD_WIN_HEIGHT;
1528
                }
1529
            }
1530
          else
1531
            {
1532
              minHeight = MIN_WIN_HEIGHT;
1533
              /*
1534
                 ** First see if we can increase/decrease the command
1535
                 ** window.  And make sure that the command window is
1536
                 ** at least 1 line
1537
               */
1538
              ok = ((cmdWin->generic.height + diff) > 0);
1539
              if (!ok)
1540
                {               /*
1541
                                   ** Looks like we have to increase/decrease one of
1542
                                   ** the other windows
1543
                                 */
1544
                  if (primaryWinInfo == firstWin)
1545
                    ok = (secondWin->generic.height + diff) >= minHeight;
1546
                  else
1547
                    ok = (firstWin->generic.height + diff) >= minHeight;
1548
                }
1549
              if (ok)
1550
                {
1551
                  if (primaryWinInfo == firstWin)
1552
                    totalHeight = newHeight +
1553
                      secondWin->generic.height +
1554
                      cmdWin->generic.height + diff;
1555
                  else
1556
                    totalHeight = newHeight +
1557
                      firstWin->generic.height +
1558
                      cmdWin->generic.height + diff;
1559
                }
1560
            }
1561
          /*
1562
             ** Now make sure that the proposed total height doesn't exceed
1563
             ** the old total height.
1564
           */
1565
          if (ok)
1566
            ok = (newHeight >= minHeight && totalHeight <= curTotalHeight);
1567
        }
1568
    }
1569
 
1570
  return ok;
1571
}                               /* _newHeightOk */
1572
 
1573
 
1574
/*
1575
   ** _parseScrollingArgs().
1576
 */
1577
static void
1578
#ifdef __STDC__
1579
_parseScrollingArgs (
1580
                      char *arg,
1581
                      TuiWinInfoPtr * winToScroll,
1582
                      int *numToScroll)
1583
#else
1584
_parseScrollingArgs (arg, winToScroll, numToScroll)
1585
     char *arg;
1586
     TuiWinInfoPtr *winToScroll;
1587
     int *numToScroll;
1588
#endif
1589
{
1590
  if (numToScroll)
1591
    *numToScroll = 0;
1592
  *winToScroll = tuiWinWithFocus ();
1593
 
1594
  /*
1595
     ** First set up the default window to scroll, in case there is no
1596
     ** window name arg
1597
   */
1598
  if (arg != (char *) NULL)
1599
    {
1600
      char *buf, *bufPtr;
1601
 
1602
      /* process the number of lines to scroll */
1603
      buf = bufPtr = tuiStrDup (arg);
1604
      if (isdigit (*bufPtr))
1605
        {
1606
          char *numStr;
1607
 
1608
          numStr = bufPtr;
1609
          bufPtr = strchr (bufPtr, ' ');
1610
          if (bufPtr != (char *) NULL)
1611
            {
1612
              *bufPtr = (char) 0;
1613
              if (numToScroll)
1614
                *numToScroll = atoi (numStr);
1615
              bufPtr++;
1616
            }
1617
          else if (numToScroll)
1618
            *numToScroll = atoi (numStr);
1619
        }
1620
 
1621
      /* process the window name if one is specified */
1622
      if (bufPtr != (char *) NULL)
1623
        {
1624
          char *wname;
1625
          int i;
1626
 
1627
          if (*bufPtr == ' ')
1628
            while (*(++bufPtr) == ' ')
1629
              ;
1630
 
1631
          if (*bufPtr != (char) 0)
1632
            wname = bufPtr;
1633
 
1634
          /* Validate the window name */
1635
          for (i = 0; i < strlen (wname); i++)
1636
            wname[i] = toupper (wname[i]);
1637
          *winToScroll = partialWinByName (wname);
1638
 
1639
          if (*winToScroll == (TuiWinInfoPtr) NULL ||
1640
              !(*winToScroll)->generic.isVisible)
1641
            warning ("Invalid window specified. \n\
1642
The window name specified must be valid and visible.\n");
1643
          else if (*winToScroll == cmdWin)
1644
            *winToScroll = (TuiWinInfoPtr) (sourceWindows ())->list[0];
1645
        }
1646
      tuiFree (buf);
1647
    }
1648
 
1649
  return;
1650
}                               /* _parseScrollingArgs */

powered by: WebSVN 2.1.0

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