gdb/tui/tuiGeneralWin.c

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