Commit | Line | Data |
---|---|---|
03b93bdc DT |
1 | /* |
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 */ |