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