Commit | Line | Data |
---|---|---|
f377b406 | 1 | /* Data/register window display. |
f33c6cbf | 2 | |
96ec9981 | 3 | Copyright 1998, 1999, 2000, 2001, 2002, 2003 Free Software Foundation, |
f33c6cbf AC |
4 | Inc. |
5 | ||
f377b406 SC |
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. */ | |
c906108c | 24 | |
96ec9981 DJ |
25 | #include "defs.h" |
26 | #include "tui.h" | |
27 | #include "tuiData.h" | |
28 | #include "tuiGeneralWin.h" | |
29 | #include "tuiRegs.h" | |
f33c6cbf | 30 | |
4e8f7a8b DJ |
31 | #ifdef HAVE_NCURSES_H |
32 | #include <ncurses.h> | |
33 | #else | |
34 | #ifdef HAVE_CURSES_H | |
35 | #include <curses.h> | |
36 | #endif | |
37 | #endif | |
38 | ||
c906108c SS |
39 | |
40 | /***************************************** | |
41 | ** STATIC LOCAL FUNCTIONS FORWARD DECLS ** | |
42 | ******************************************/ | |
43 | ||
44 | ||
45 | ||
46 | /***************************************** | |
47 | ** PUBLIC FUNCTIONS ** | |
48 | ******************************************/ | |
49 | ||
50 | ||
51 | /* | |
c5aa993b JM |
52 | ** tuiFirstDataItemDisplayed() |
53 | ** Answer the index first element displayed. | |
54 | ** If none are displayed, then return (-1). | |
55 | */ | |
c906108c | 56 | int |
c906108c | 57 | tuiFirstDataItemDisplayed (void) |
c906108c SS |
58 | { |
59 | int elementNo = (-1); | |
60 | int i; | |
61 | ||
62 | for (i = 0; (i < dataWin->generic.contentSize && elementNo < 0); i++) | |
63 | { | |
64 | TuiGenWinInfoPtr dataItemWin; | |
65 | ||
66 | dataItemWin = &((TuiWinContent) | |
67 | dataWin->generic.content)[i]->whichElement.dataWindow; | |
68 | if (dataItemWin->handle != (WINDOW *) NULL && dataItemWin->isVisible) | |
69 | elementNo = i; | |
70 | } | |
71 | ||
72 | return elementNo; | |
73 | } /* tuiFirstDataItemDisplayed */ | |
74 | ||
75 | ||
76 | /* | |
c5aa993b JM |
77 | ** tuiFirstDataElementNoInLine() |
78 | ** Answer the index of the first element in lineNo. If lineNo is | |
79 | ** past the data area (-1) is returned. | |
80 | */ | |
c906108c | 81 | int |
eca6576c | 82 | tuiFirstDataElementNoInLine (int lineNo) |
c906108c SS |
83 | { |
84 | int firstElementNo = (-1); | |
85 | ||
86 | /* | |
c5aa993b JM |
87 | ** First see if there is a register on lineNo, and if so, set the |
88 | ** first element number | |
89 | */ | |
c906108c SS |
90 | if ((firstElementNo = tuiFirstRegElementNoInLine (lineNo)) == -1) |
91 | { /* | |
c5aa993b JM |
92 | ** Looking at the general data, the 1st element on lineNo |
93 | */ | |
c906108c SS |
94 | } |
95 | ||
96 | return firstElementNo; | |
97 | } /* tuiFirstDataElementNoInLine */ | |
98 | ||
99 | ||
100 | /* | |
c5aa993b JM |
101 | ** tuiDeleteDataContentWindows() |
102 | ** Function to delete all the item windows in the data window. | |
103 | ** This is usually done when the data window is scrolled. | |
104 | */ | |
c906108c | 105 | void |
c906108c | 106 | tuiDeleteDataContentWindows (void) |
c906108c SS |
107 | { |
108 | int i; | |
109 | TuiGenWinInfoPtr dataItemWinPtr; | |
110 | ||
111 | for (i = 0; (i < dataWin->generic.contentSize); i++) | |
112 | { | |
113 | dataItemWinPtr = &((TuiWinContent) | |
114 | dataWin->generic.content)[i]->whichElement.dataWindow; | |
115 | tuiDelwin (dataItemWinPtr->handle); | |
116 | dataItemWinPtr->handle = (WINDOW *) NULL; | |
117 | dataItemWinPtr->isVisible = FALSE; | |
118 | } | |
119 | ||
120 | return; | |
121 | } /* tuiDeleteDataContentWindows */ | |
122 | ||
123 | ||
124 | void | |
eca6576c | 125 | tuiEraseDataContent (char *prompt) |
c906108c SS |
126 | { |
127 | werase (dataWin->generic.handle); | |
128 | checkAndDisplayHighlightIfNeeded (dataWin); | |
129 | if (prompt != (char *) NULL) | |
130 | { | |
131 | int halfWidth = (dataWin->generic.width - 2) / 2; | |
132 | int xPos; | |
133 | ||
134 | if (strlen (prompt) >= halfWidth) | |
135 | xPos = 1; | |
136 | else | |
137 | xPos = halfWidth - strlen (prompt); | |
138 | mvwaddstr (dataWin->generic.handle, | |
139 | (dataWin->generic.height / 2), | |
140 | xPos, | |
141 | prompt); | |
142 | } | |
143 | wrefresh (dataWin->generic.handle); | |
144 | ||
145 | return; | |
146 | } /* tuiEraseDataContent */ | |
147 | ||
148 | ||
149 | /* | |
c5aa993b JM |
150 | ** tuiDisplayAllData(). |
151 | ** This function displays the data that is in the data window's | |
152 | ** content. It does not set the content. | |
153 | */ | |
c906108c | 154 | void |
c906108c | 155 | tuiDisplayAllData (void) |
c906108c SS |
156 | { |
157 | if (dataWin->generic.contentSize <= 0) | |
158 | tuiEraseDataContent (NO_DATA_STRING); | |
159 | else | |
160 | { | |
161 | tuiEraseDataContent ((char *) NULL); | |
162 | tuiDeleteDataContentWindows (); | |
163 | checkAndDisplayHighlightIfNeeded (dataWin); | |
164 | tuiDisplayRegistersFrom (0); | |
165 | /* | |
c5aa993b JM |
166 | ** Then display the other data |
167 | */ | |
c906108c SS |
168 | if (dataWin->detail.dataDisplayInfo.dataContent != |
169 | (TuiWinContent) NULL && | |
170 | dataWin->detail.dataDisplayInfo.dataContentCount > 0) | |
171 | { | |
172 | } | |
173 | } | |
174 | return; | |
175 | } /* tuiDisplayAllData */ | |
176 | ||
177 | ||
178 | /* | |
c5aa993b JM |
179 | ** tuiDisplayDataFromLine() |
180 | ** Function to display the data starting at line, lineNo, in the | |
181 | ** data window. | |
182 | */ | |
c906108c | 183 | void |
eca6576c | 184 | tuiDisplayDataFromLine (int lineNo) |
c906108c SS |
185 | { |
186 | int _lineNo = lineNo; | |
187 | ||
188 | if (lineNo < 0) | |
189 | _lineNo = 0; | |
190 | ||
191 | checkAndDisplayHighlightIfNeeded (dataWin); | |
192 | ||
193 | /* there is no general data, force regs to display (if there are any) */ | |
194 | if (dataWin->detail.dataDisplayInfo.dataContentCount <= 0) | |
195 | tuiDisplayRegistersFromLine (_lineNo, TRUE); | |
196 | else | |
197 | { | |
198 | int elementNo, startLineNo; | |
199 | int regsLastLine = tuiLastRegsLineNo (); | |
200 | ||
201 | ||
202 | /* display regs if we can */ | |
203 | if (tuiDisplayRegistersFromLine (_lineNo, FALSE) < 0) | |
204 | { /* | |
c5aa993b JM |
205 | ** _lineNo is past the regs display, so calc where the |
206 | ** start data element is | |
207 | */ | |
c906108c SS |
208 | if (regsLastLine < _lineNo) |
209 | { /* figure out how many lines each element is to obtain | |
c5aa993b | 210 | the start elementNo */ |
c906108c SS |
211 | } |
212 | } | |
213 | else | |
214 | { /* | |
c5aa993b JM |
215 | ** calculate the starting element of the data display, given |
216 | ** regsLastLine and how many lines each element is, up to | |
217 | ** _lineNo | |
218 | */ | |
c906108c SS |
219 | } |
220 | /* Now display the data , starting at elementNo */ | |
221 | } | |
222 | ||
223 | return; | |
224 | } /* tuiDisplayDataFromLine */ | |
225 | ||
226 | ||
227 | /* | |
c5aa993b JM |
228 | ** tuiDisplayDataFrom() |
229 | ** Display data starting at element elementNo | |
230 | */ | |
c906108c | 231 | void |
eca6576c | 232 | tuiDisplayDataFrom (int elementNo, int reuseWindows) |
c906108c SS |
233 | { |
234 | int firstLine = (-1); | |
235 | ||
236 | if (elementNo < dataWin->detail.dataDisplayInfo.regsContentCount) | |
237 | firstLine = tuiLineFromRegElementNo (elementNo); | |
238 | else | |
239 | { /* calculate the firstLine from the element number */ | |
240 | } | |
241 | ||
242 | if (firstLine >= 0) | |
243 | { | |
244 | tuiEraseDataContent ((char *) NULL); | |
245 | if (!reuseWindows) | |
246 | tuiDeleteDataContentWindows (); | |
247 | tuiDisplayDataFromLine (firstLine); | |
248 | } | |
249 | ||
250 | return; | |
251 | } /* tuiDisplayDataFrom */ | |
252 | ||
253 | ||
254 | /* | |
c5aa993b JM |
255 | ** tuiRefreshDataWin() |
256 | ** Function to redisplay the contents of the data window. | |
257 | */ | |
c906108c | 258 | void |
c906108c | 259 | tuiRefreshDataWin (void) |
c906108c SS |
260 | { |
261 | tuiEraseDataContent ((char *) NULL); | |
262 | if (dataWin->generic.contentSize > 0) | |
263 | { | |
264 | int firstElement = tuiFirstDataItemDisplayed (); | |
265 | ||
266 | if (firstElement >= 0) /* re-use existing windows */ | |
267 | tuiDisplayDataFrom (firstElement, TRUE); | |
268 | } | |
269 | ||
270 | return; | |
271 | } /* tuiRefreshDataWin */ | |
272 | ||
273 | ||
274 | /* | |
c5aa993b JM |
275 | ** tuiCheckDataValues(). |
276 | ** Function to check the data values and hilite any that have changed | |
277 | */ | |
c906108c | 278 | void |
eca6576c | 279 | tuiCheckDataValues (struct frame_info *frame) |
c906108c SS |
280 | { |
281 | tuiCheckRegisterValues (frame); | |
282 | ||
283 | /* Now check any other data values that there are */ | |
284 | if (m_winPtrNotNull (dataWin) && dataWin->generic.isVisible) | |
285 | { | |
286 | int i; | |
287 | ||
288 | for (i = 0; dataWin->detail.dataDisplayInfo.dataContentCount; i++) | |
289 | { | |
290 | #ifdef LATER | |
291 | TuiDataElementPtr dataElementPtr; | |
292 | TuiGenWinInfoPtr dataItemWinPtr; | |
293 | Opaque newValue; | |
294 | ||
295 | dataItemPtr = &dataWin->detail.dataDisplayInfo. | |
296 | dataContent[i]->whichElement.dataWindow; | |
297 | dataElementPtr = &((TuiWinContent) | |
298 | dataItemWinPtr->content)[0]->whichElement.data; | |
299 | if value | |
300 | has changed (dataElementPtr, frame, &newValue) | |
301 | { | |
302 | dataElementPtr->value = newValue; | |
303 | update the display with the new value, hiliting it. | |
304 | } | |
305 | #endif | |
306 | } | |
307 | } | |
308 | } /* tuiCheckDataValues */ | |
309 | ||
310 | ||
c906108c | 311 | /* |
c5aa993b JM |
312 | ** tuiVerticalDataScroll() |
313 | ** Scroll the data window vertically forward or backward. | |
314 | */ | |
c906108c | 315 | void |
eca6576c | 316 | tuiVerticalDataScroll (TuiScrollDirection scrollDirection, int numToScroll) |
c906108c SS |
317 | { |
318 | int firstElementNo; | |
319 | int firstLine = (-1); | |
320 | ||
321 | firstElementNo = tuiFirstDataItemDisplayed (); | |
322 | if (firstElementNo < dataWin->detail.dataDisplayInfo.regsContentCount) | |
323 | firstLine = tuiLineFromRegElementNo (firstElementNo); | |
324 | else | |
325 | { /* calculate the first line from the element number which is in | |
c5aa993b JM |
326 | ** the general data content |
327 | */ | |
c906108c SS |
328 | } |
329 | ||
330 | if (firstLine >= 0) | |
331 | { | |
332 | int lastElementNo, lastLine; | |
333 | ||
334 | if (scrollDirection == FORWARD_SCROLL) | |
335 | firstLine += numToScroll; | |
336 | else | |
337 | firstLine -= numToScroll; | |
338 | tuiEraseDataContent ((char *) NULL); | |
339 | tuiDeleteDataContentWindows (); | |
340 | tuiDisplayDataFromLine (firstLine); | |
341 | } | |
342 | ||
343 | return; | |
344 | } /* tuiVerticalDataScroll */ | |
345 | ||
346 | ||
347 | /***************************************** | |
348 | ** STATIC LOCAL FUNCTIONS ** | |
349 | ******************************************/ |