gdb/tui/tuiDataWin.c

   1 /* Data/register window display.
   2
   3    Copyright 1998, 1999, 2000, 2001, 2002 Free Software Foundation,
   4    Inc.
   5
   6    Contributed by Hewlett-Packard Company.
   7
   8    This file is part of GDB.
   9
  10    This program is free software; you can redistribute it and/or modify
  11    it under the terms of the GNU General Public License as published by
  12    the Free Software Foundation; either version 2 of the License, or
  13    (at your option) any later version.
  14
  15    This program is distributed in the hope that it will be useful,
  16    but WITHOUT ANY WARRANTY; without even the implied warranty of
  17    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  18    GNU General Public License for more details.
  19
  20    You should have received a copy of the GNU General Public License
  21    along with this program; if not, write to the Free Software
  22    Foundation, Inc., 59 Temple Place - Suite 330,
  23    Boston, MA 02111-1307, USA.  */
  24
  25 /* FIXME: cagney/2002-02-28: The GDB coding standard indicates that
  26    "defs.h" should be included first.  Unfortunatly some systems
  27    (currently Debian GNU/Linux) include the <stdbool.h> via <curses.h>
  28    and they clash with "bfd.h"'s definiton of true/false.  The correct
  29    fix is to remove true/false from "bfd.h", however, until that
  30    happens, hack around it by including "config.h" and <curses.h>
  31    first.  */
  32
  33 #include "config.h"
  34 #ifdef HAVE_NCURSES_H
  35 #include <ncurses.h>
  36 #else
  37 #ifdef HAVE_CURSES_H
  38 #include <curses.h>
  39 #endif
  40 #endif
  41
  42 #include "defs.h"
  43 #include "tui.h"
  44 #include "tuiData.h"
  45 #include "tuiGeneralWin.h"
  46 #include "tuiRegs.h"
  47
  48
  49 /*****************************************
  50 ** STATIC LOCAL FUNCTIONS FORWARD DECLS    **
  51 ******************************************/
  52
  53
  54
  55 /*****************************************
  56 ** PUBLIC FUNCTIONS                        **
  57 ******************************************/
  58
  59
  60 /*
  61    ** tuiFirstDataItemDisplayed()
  62    **    Answer the index first element displayed.
  63    **    If none are displayed, then return (-1).
  64  */
  65 int
  66 tuiFirstDataItemDisplayed (void)
  67 {
  68   int elementNo = (-1);
  69   int i;
  70
  71   for (i = 0; (i < dataWin->generic.contentSize && elementNo < 0); i++)
  72     {
  73       TuiGenWinInfoPtr dataItemWin;
  74
  75       dataItemWin = &((TuiWinContent)
  76                       dataWin->generic.content)[i]->whichElement.dataWindow;
  77       if (dataItemWin->handle != (WINDOW *) NULL && dataItemWin->isVisible)
  78         elementNo = i;
  79     }
  80
  81   return elementNo;
  82 }                               /* tuiFirstDataItemDisplayed */
  83
  84
  85 /*
  86    ** tuiFirstDataElementNoInLine()
  87    **        Answer the index of the first element in lineNo.  If lineNo is
  88    **        past the data area (-1) is returned.
  89  */
  90 int
  91 tuiFirstDataElementNoInLine (int lineNo)
  92 {
  93   int firstElementNo = (-1);
  94
  95   /*
  96      ** First see if there is a register on lineNo, and if so, set the
  97      ** first element number
  98    */
  99   if ((firstElementNo = tuiFirstRegElementNoInLine (lineNo)) == -1)
 100     {                           /*
 101                                    ** Looking at the general data, the 1st element on lineNo
 102                                  */
 103     }
 104
 105   return firstElementNo;
 106 }                               /* tuiFirstDataElementNoInLine */
 107
 108
 109 /*
 110    ** tuiDeleteDataContentWindows()
 111    **        Function to delete all the item windows in the data window.
 112    **        This is usually done when the data window is scrolled.
 113  */
 114 void
 115 tuiDeleteDataContentWindows (void)
 116 {
 117   int i;
 118   TuiGenWinInfoPtr dataItemWinPtr;
 119
 120   for (i = 0; (i < dataWin->generic.contentSize); i++)
 121     {
 122       dataItemWinPtr = &((TuiWinContent)
 123                       dataWin->generic.content)[i]->whichElement.dataWindow;
 124       tuiDelwin (dataItemWinPtr->handle);
 125       dataItemWinPtr->handle = (WINDOW *) NULL;
 126       dataItemWinPtr->isVisible = FALSE;
 127     }
 128
 129   return;
 130 }                               /* tuiDeleteDataContentWindows */
 131
 132
 133 void
 134 tuiEraseDataContent (char *prompt)
 135 {
 136   werase (dataWin->generic.handle);
 137   checkAndDisplayHighlightIfNeeded (dataWin);
 138   if (prompt != (char *) NULL)
 139     {
 140       int halfWidth = (dataWin->generic.width - 2) / 2;
 141       int xPos;
 142
 143       if (strlen (prompt) >= halfWidth)
 144         xPos = 1;
 145       else
 146         xPos = halfWidth - strlen (prompt);
 147       mvwaddstr (dataWin->generic.handle,
 148                  (dataWin->generic.height / 2),
 149                  xPos,
 150                  prompt);
 151     }
 152   wrefresh (dataWin->generic.handle);
 153
 154   return;
 155 }                               /* tuiEraseDataContent */
 156
 157
 158 /*
 159    ** tuiDisplayAllData().
 160    **        This function displays the data that is in the data window's
 161    **        content.  It does not set the content.
 162  */
 163 void
 164 tuiDisplayAllData (void)
 165 {
 166   if (dataWin->generic.contentSize <= 0)
 167     tuiEraseDataContent (NO_DATA_STRING);
 168   else
 169     {
 170       tuiEraseDataContent ((char *) NULL);
 171       tuiDeleteDataContentWindows ();
 172       checkAndDisplayHighlightIfNeeded (dataWin);
 173       tuiDisplayRegistersFrom (0);
 174       /*
 175          ** Then display the other data
 176        */
 177       if (dataWin->detail.dataDisplayInfo.dataContent !=
 178           (TuiWinContent) NULL &&
 179           dataWin->detail.dataDisplayInfo.dataContentCount > 0)
 180         {
 181         }
 182     }
 183   return;
 184 }                               /* tuiDisplayAllData */
 185
 186
 187 /*
 188    ** tuiDisplayDataFromLine()
 189    **        Function to display the data starting at line, lineNo, in the
 190    **        data window.
 191  */
 192 void
 193 tuiDisplayDataFromLine (int lineNo)
 194 {
 195   int _lineNo = lineNo;
 196
 197   if (lineNo < 0)
 198     _lineNo = 0;
 199
 200   checkAndDisplayHighlightIfNeeded (dataWin);
 201
 202   /* there is no general data, force regs to display (if there are any) */
 203   if (dataWin->detail.dataDisplayInfo.dataContentCount <= 0)
 204     tuiDisplayRegistersFromLine (_lineNo, TRUE);
 205   else
 206     {
 207       int elementNo, startLineNo;
 208       int regsLastLine = tuiLastRegsLineNo ();
 209
 210
 211       /* display regs if we can */
 212       if (tuiDisplayRegistersFromLine (_lineNo, FALSE) < 0)
 213         {                       /*
 214                                    ** _lineNo is past the regs display, so calc where the
 215                                    ** start data element is
 216                                  */
 217           if (regsLastLine < _lineNo)
 218             {                   /* figure out how many lines each element is to obtain
 219                                    the start elementNo */
 220             }
 221         }
 222       else
 223         {                       /*
 224                                    ** calculate the starting element of the data display, given
 225                                    ** regsLastLine and how many lines each element is, up to
 226                                    ** _lineNo
 227                                  */
 228         }
 229       /* Now display the data , starting at elementNo */
 230     }
 231
 232   return;
 233 }                               /* tuiDisplayDataFromLine */
 234
 235
 236 /*
 237    ** tuiDisplayDataFrom()
 238    **        Display data starting at element elementNo
 239  */
 240 void
 241 tuiDisplayDataFrom (int elementNo, int reuseWindows)
 242 {
 243   int firstLine = (-1);
 244
 245   if (elementNo < dataWin->detail.dataDisplayInfo.regsContentCount)
 246     firstLine = tuiLineFromRegElementNo (elementNo);
 247   else
 248     {                           /* calculate the firstLine from the element number */
 249     }
 250
 251   if (firstLine >= 0)
 252     {
 253       tuiEraseDataContent ((char *) NULL);
 254       if (!reuseWindows)
 255         tuiDeleteDataContentWindows ();
 256       tuiDisplayDataFromLine (firstLine);
 257     }
 258
 259   return;
 260 }                               /* tuiDisplayDataFrom */
 261
 262
 263 /*
 264    ** tuiRefreshDataWin()
 265    **        Function to redisplay the contents of the data window.
 266  */
 267 void
 268 tuiRefreshDataWin (void)
 269 {
 270   tuiEraseDataContent ((char *) NULL);
 271   if (dataWin->generic.contentSize > 0)
 272     {
 273       int firstElement = tuiFirstDataItemDisplayed ();
 274
 275       if (firstElement >= 0)    /* re-use existing windows */
 276         tuiDisplayDataFrom (firstElement, TRUE);
 277     }
 278
 279   return;
 280 }                               /* tuiRefreshDataWin */
 281
 282
 283 /*
 284    ** tuiCheckDataValues().
 285    **        Function to check the data values and hilite any that have changed
 286  */
 287 void
 288 tuiCheckDataValues (struct frame_info *frame)
 289 {
 290   tuiCheckRegisterValues (frame);
 291
 292   /* Now check any other data values that there are */
 293   if (m_winPtrNotNull (dataWin) && dataWin->generic.isVisible)
 294     {
 295       int i;
 296
 297       for (i = 0; dataWin->detail.dataDisplayInfo.dataContentCount; i++)
 298         {
 299 #ifdef LATER
 300           TuiDataElementPtr dataElementPtr;
 301           TuiGenWinInfoPtr dataItemWinPtr;
 302           Opaque newValue;
 303
 304           dataItemPtr = &dataWin->detail.dataDisplayInfo.
 305             dataContent[i]->whichElement.dataWindow;
 306           dataElementPtr = &((TuiWinContent)
 307                              dataItemWinPtr->content)[0]->whichElement.data;
 308           if value
 309             has changed (dataElementPtr, frame, &newValue)
 310             {
 311               dataElementPtr->value = newValue;
 312               update the display with the new value, hiliting it.
 313             }
 314 #endif
 315         }
 316     }
 317 }                               /* tuiCheckDataValues */
 318
 319
 320 /*
 321    ** tuiVerticalDataScroll()
 322    **        Scroll the data window vertically forward or backward.
 323  */
 324 void
 325 tuiVerticalDataScroll (TuiScrollDirection scrollDirection, int numToScroll)
 326 {
 327   int firstElementNo;
 328   int firstLine = (-1);
 329
 330   firstElementNo = tuiFirstDataItemDisplayed ();
 331   if (firstElementNo < dataWin->detail.dataDisplayInfo.regsContentCount)
 332     firstLine = tuiLineFromRegElementNo (firstElementNo);
 333   else
 334     {                           /* calculate the first line from the element number which is in
 335                                    ** the general data content
 336                                  */
 337     }
 338
 339   if (firstLine >= 0)
 340     {
 341       int lastElementNo, lastLine;
 342
 343       if (scrollDirection == FORWARD_SCROLL)
 344         firstLine += numToScroll;
 345       else
 346         firstLine -= numToScroll;
 347       tuiEraseDataContent ((char *) NULL);
 348       tuiDeleteDataContentWindows ();
 349       tuiDisplayDataFromLine (firstLine);
 350     }
 351
 352   return;
 353 }                               /* tuiVerticalDataScroll */
 354
 355
 356 /*****************************************
 357 ** STATIC LOCAL FUNCTIONS               **
 358 ******************************************/