gdb/tui/tuiGeneralWin.c

   1 /*
   2    ** TuiGeneralWin.c
   3    ** This module supports general window behavior
   4  */
   5
   6 #include <curses.h>
   7 #include "defs.h"
   8 #include "tui.h"
   9 #include "tuiData.h"
  10 #include "tuiGeneralWin.h"
  11
  12
  13 /*
  14    ** local support functions
  15  */
  16 static void _winResize PARAMS ((void));
  17
  18
  19 /***********************
  20 ** PUBLIC FUNCTIONS
  21 ***********************/
  22 /*
  23    ** tuiRefreshWin()
  24    **        Refresh the window
  25  */
  26 void
  27 #ifdef __STDC__
  28 tuiRefreshWin (
  29                 TuiGenWinInfoPtr winInfo)
  30 #else
  31 tuiRefreshWin (winInfo)
  32      TuiGenWinInfoPtr winInfo;
  33 #endif
  34 {
  35   if (winInfo->type == DATA_WIN && winInfo->contentSize > 0)
  36     {
  37       int i;
  38
  39       for (i = 0; (i < winInfo->contentSize); i++)
  40         {
  41           TuiGenWinInfoPtr dataItemWinPtr;
  42
  43           dataItemWinPtr = &((TuiWinContent)
  44                              winInfo->content)[i]->whichElement.dataWindow;
  45           if (m_genWinPtrNotNull (dataItemWinPtr) &&
  46               dataItemWinPtr->handle != (WINDOW *) NULL)
  47             wrefresh (dataItemWinPtr->handle);
  48         }
  49     }
  50   else if (winInfo->type == CMD_WIN)
  51     {
  52       /* Do nothing */
  53     }
  54   else
  55     {
  56       if (winInfo->handle != (WINDOW *) NULL)
  57         wrefresh (winInfo->handle);
  58     }
  59
  60   return;
  61 }                               /* tuiRefreshWin */
  62
  63
  64 /*
  65    ** tuiDelwin()
  66    **        Function to delete the curses window, checking for null
  67  */
  68 void
  69 #ifdef __STDC__
  70 tuiDelwin (
  71             WINDOW * window)
  72 #else
  73 tuiDelwin (window)
  74      WINDOW *window;
  75 #endif
  76 {
  77   if (window != (WINDOW *) NULL)
  78     delwin (window);
  79
  80   return;
  81 }                               /* tuiDelwin */
  82
  83
  84 /*
  85    ** boxWin().
  86  */
  87 void
  88 #ifdef __STDC__
  89 boxWin (
  90          TuiGenWinInfoPtr winInfo,
  91          int highlightFlag)
  92 #else
  93 boxWin (winInfo, highlightFlag)
  94      TuiGenWinInfoPtr winInfo;
  95      int highlightFlag;
  96 #endif
  97 {
  98   if (m_genWinPtrNotNull (winInfo) && winInfo->handle != (WINDOW *) NULL)
  99     {
 100       if (highlightFlag == HILITE)
 101         box (winInfo->handle, '|', '-');
 102       else
 103         {
 104 /*            wattron(winInfo->handle, A_DIM); */
 105           box (winInfo->handle, ':', '.');
 106 /*            wattroff(winInfo->handle, A_DIM); */
 107         }
 108     }
 109
 110   return;
 111 }                               /* boxWin */
 112
 113
 114 /*
 115    ** unhighlightWin().
 116  */
 117 void
 118 #ifdef __STDC__
 119 unhighlightWin (
 120                  TuiWinInfoPtr winInfo)
 121 #else
 122 unhighlightWin (winInfo)
 123      TuiWinInfoPtr winInfo;
 124 #endif
 125 {
 126   if (m_winPtrNotNull (winInfo) && winInfo->generic.handle != (WINDOW *) NULL)
 127     {
 128       boxWin ((TuiGenWinInfoPtr) winInfo, NO_HILITE);
 129       wrefresh (winInfo->generic.handle);
 130       m_setWinHighlightOff (winInfo);
 131     }
 132 }                               /* unhighlightWin */
 133
 134
 135 /*
 136    ** highlightWin().
 137  */
 138 void
 139 #ifdef __STDC__
 140 highlightWin (
 141                TuiWinInfoPtr winInfo)
 142 #else
 143 highlightWin (winInfo)
 144      TuiWinInfoPtr winInfo;
 145 #endif
 146 {
 147   if (m_winPtrNotNull (winInfo) &&
 148       winInfo->canHighlight && winInfo->generic.handle != (WINDOW *) NULL)
 149     {
 150       boxWin ((TuiGenWinInfoPtr) winInfo, HILITE);
 151       wrefresh (winInfo->generic.handle);
 152       m_setWinHighlightOn (winInfo);
 153     }
 154 }                               /* highlightWin */
 155
 156
 157 /*
 158    ** checkAndDisplayHighlightIfNecessay
 159  */
 160 void
 161 #ifdef __STDC__
 162 checkAndDisplayHighlightIfNeeded (
 163                                    TuiWinInfoPtr winInfo)
 164 #else
 165 checkAndDisplayHighlightIfNeeded (winInfo)
 166      TuiWinInfoPtr winInfo;
 167 #endif
 168 {
 169   if (m_winPtrNotNull (winInfo) && winInfo->generic.type != CMD_WIN)
 170     {
 171       if (winInfo->isHighlighted)
 172         highlightWin (winInfo);
 173       else
 174         unhighlightWin (winInfo);
 175
 176     }
 177   return;
 178 }                               /* checkAndDisplayHighlightIfNeeded */
 179
 180
 181 /*
 182    ** makeWindow().
 183  */
 184 void
 185 #ifdef __STDC__
 186 makeWindow (
 187              TuiGenWinInfoPtr winInfo,
 188              int boxIt)
 189 #else
 190 makeWindow (winInfo, boxIt)
 191      TuiGenWinInfoPtr winInfo;
 192      int boxIt;
 193 #endif
 194 {
 195   WINDOW *handle;
 196
 197   handle = newwin (winInfo->height,
 198                    winInfo->width,
 199                    winInfo->origin.y,
 200                    winInfo->origin.x);
 201   winInfo->handle = handle;
 202   if (handle != (WINDOW *) NULL)
 203     {
 204       if (boxIt == BOX_WINDOW)
 205         boxWin (winInfo, NO_HILITE);
 206       winInfo->isVisible = TRUE;
 207       scrollok (handle, TRUE);
 208       tuiRefreshWin (winInfo);
 209
 210 #ifndef FOR_TEST
 211       if (                      /*!m_WinIsAuxillary(winInfo->type) && */
 212            (winInfo->type != CMD_WIN) &&
 213            (winInfo->content == (OpaquePtr) NULL))
 214         {
 215           mvwaddstr (handle, 1, 1, winName (winInfo));
 216           tuiRefreshWin (winInfo);
 217         }
 218 #endif /*FOR_TEST */
 219     }
 220
 221   return;
 222 }                               /* makeWindow */
 223
 224
 225 /*
 226    ** tuiClearWin().
 227    **        Clear the window of all contents without calling wclear.
 228  */
 229 void
 230 #ifdef __STDC__
 231 tuiClearWin (
 232               TuiGenWinInfoPtr winInfo)
 233 #else
 234 tuiClearWin (winInfo)
 235      TuiGenWinInfoPtr winInfo;
 236 #endif
 237 {
 238   if (m_genWinPtrNotNull (winInfo) && winInfo->handle != (WINDOW *) NULL)
 239     {
 240       int curRow, curCol;
 241
 242       for (curRow = 0; (curRow < winInfo->height); curRow++)
 243         for (curCol = 0; (curCol < winInfo->width); curCol++)
 244           mvwaddch (winInfo->handle, curRow, curCol, ' ');
 245
 246       tuiRefreshWin (winInfo);
 247     }
 248
 249   return;
 250 }                               /* tuiClearWin */
 251
 252
 253 /*
 254    ** makeVisible().
 255    **        We can't really make windows visible, or invisible.  So we
 256    **        have to delete the entire window when making it visible,
 257    **        and create it again when making it visible.
 258  */
 259 void
 260 #ifdef __STDC__
 261 makeVisible (
 262               TuiGenWinInfoPtr winInfo,
 263               int visible)
 264 #else
 265 makeVisible (winInfo, visible)
 266      TuiGenWinInfoPtr winInfo;
 267      int visible;
 268 #endif
 269 {
 270   /* Don't tear down/recreate command window */
 271   if (winInfo->type == CMD_WIN)
 272     return;
 273
 274   if (visible)
 275     {
 276       if (!winInfo->isVisible)
 277         {
 278           makeWindow (
 279                        winInfo,
 280            (winInfo->type != CMD_WIN && !m_winIsAuxillary (winInfo->type)));
 281           winInfo->isVisible = TRUE;
 282         }
 283       tuiRefreshWin (winInfo);
 284     }
 285   else if (!visible &&
 286            winInfo->isVisible && winInfo->handle != (WINDOW *) NULL)
 287     {
 288       winInfo->isVisible = FALSE;
 289       tuiClearWin (winInfo);
 290       tuiDelwin (winInfo->handle);
 291       winInfo->handle = (WINDOW *) NULL;
 292     }
 293
 294   return;
 295 }                               /* makeVisible */
 296
 297
 298 /*
 299    ** makeAllVisible().
 300    **        Makes all windows invisible (except the command and locator windows)
 301  */
 302 void
 303 #ifdef __STDC__
 304 makeAllVisible (
 305                  int visible)
 306 #else
 307 makeAllVisible (visible)
 308      int visible;
 309 #endif
 310 {
 311   int i;
 312
 313   for (i = 0; i < MAX_MAJOR_WINDOWS; i++)
 314     {
 315       if (m_winPtrNotNull (winList[i]) &&
 316           ((winList[i])->generic.type) != CMD_WIN)
 317         {
 318           if (m_winIsSourceType ((winList[i])->generic.type))
 319             makeVisible ((winList[i])->detail.sourceInfo.executionInfo,
 320                          visible);
 321           makeVisible ((TuiGenWinInfoPtr) winList[i], visible);
 322         }
 323     }
 324
 325   return;
 326 }                               /* makeAllVisible */
 327
 328
 329 /*
 330    ** scrollWinForward
 331  */
 332 void
 333 #ifdef __STDC__
 334 scrollWinForward (
 335                    TuiGenWinInfoPtr winInfo,
 336                    int numLines)
 337 #else
 338 scrollWinForward (winInfo, numLines)
 339      TuiGenWinInfoPtr winInfo;
 340      int numLines;
 341 #endif
 342 {
 343   if (winInfo->content != (OpaquePtr) NULL &&
 344       winInfo->lastVisibleLine < winInfo->contentSize - 1)
 345     {
 346       int i, firstLine, newLastLine;
 347
 348       firstLine = winInfo->lastVisibleLine - winInfo->viewportHeight + 1;
 349       if (winInfo->lastVisibleLine + numLines > winInfo->contentSize)
 350         newLastLine = winInfo->contentSize - 1;
 351       else
 352         newLastLine = winInfo->lastVisibleLine + numLines - 1;
 353
 354       for (i = (newLastLine - winInfo->viewportHeight);
 355            (i <= newLastLine); i++)
 356         {
 357           TuiWinElementPtr line;
 358           int lineHeight;
 359
 360           line = (TuiWinElementPtr) winInfo->content[i];
 361           if (line->highlight)
 362             wstandout (winInfo->handle);
 363           mvwaddstr (winInfo->handle,
 364                      i - (newLastLine - winInfo->viewportHeight),
 365                      1,
 366                      displayableWinContentOf (winInfo, line));
 367           if (line->highlight)
 368             wstandend (winInfo->handle);
 369           lineHeight = winElementHeight (winInfo, line);
 370           newLastLine += (lineHeight - 1);
 371         }
 372       winInfo->lastVisibleLine = newLastLine;
 373     }
 374
 375   return;
 376 }                               /* scrollWinForward */
 377
 378
 379 /*
 380    ** scrollWinBackward
 381  */
 382 void
 383 #ifdef __STDC__
 384 scrollWinBackward (
 385                     TuiGenWinInfoPtr winInfo,
 386                     int numLines)
 387 #else
 388 scrollWinBackward (winInfo, numLines)
 389      TuiGenWinInfoPtr winInfo;
 390      int numLines;
 391 #endif
 392 {
 393   if (winInfo->content != (OpaquePtr) NULL &&
 394       (winInfo->lastVisibleLine - winInfo->viewportHeight) > 0)
 395     {
 396       int i, newLastLine, firstLine;
 397
 398       firstLine = winInfo->lastVisibleLine - winInfo->viewportHeight + 1;
 399       if ((firstLine - numLines) < 0)
 400         newLastLine = winInfo->viewportHeight - 1;
 401       else
 402         newLastLine = winInfo->lastVisibleLine - numLines + 1;
 403
 404       for (i = newLastLine - winInfo->viewportHeight; (i <= newLastLine); i++)
 405         {
 406           TuiWinElementPtr line;
 407           int lineHeight;
 408
 409           line = (TuiWinElementPtr) winInfo->content[i];
 410           if (line->highlight)
 411             wstandout (winInfo->handle);
 412           mvwaddstr (winInfo->handle,
 413                      i - (newLastLine - winInfo->viewportHeight),
 414                      1,
 415                      displayableWinContentOf (winInfo, line));
 416           if (line->highlight)
 417             wstandend (winInfo->handle);
 418           lineHeight = winElementHeight (winInfo, line);
 419           newLastLine += (lineHeight - 1);
 420         }
 421       winInfo->lastVisibleLine = newLastLine;
 422     }
 423
 424   return;
 425 }                               /* scrollWinBackward */
 426
 427
 428 /*
 429    ** refreshAll().
 430    **        Function to refresh all the windows currently displayed
 431  */
 432 void
 433 #ifdef __STDC__
 434 refreshAll (
 435              TuiWinInfoPtr * list)
 436 #else
 437 refreshAll (list)
 438      TuiWinInfoPtr *list;
 439 #endif
 440 {
 441   TuiWinType type;
 442   TuiGenWinInfoPtr locator = locatorWinInfoPtr ();
 443
 444   for (type = SRC_WIN; (type < MAX_MAJOR_WINDOWS); type++)
 445     {
 446       if (list[type]->generic.isVisible)
 447         {
 448           if (type == SRC_WIN || type == DISASSEM_WIN)
 449             {
 450               touchwin (list[type]->detail.sourceInfo.executionInfo->handle);
 451               tuiRefreshWin (list[type]->detail.sourceInfo.executionInfo);
 452             }
 453           touchwin (list[type]->generic.handle);
 454           tuiRefreshWin (&list[type]->generic);
 455         }
 456     }
 457   if (locator->isVisible)
 458     {
 459       touchwin (locator->handle);
 460       tuiRefreshWin (locator);
 461     }
 462
 463   return;
 464 }                               /* refreshAll */
 465
 466
 467 /*********************************
 468 ** Local Static Functions
 469 *********************************/