gdb/tui/tuiGeneralWin.c

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