?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Release 940405
[wine/gsoc-2012-control.git] / controls / listbox.c
bloba20eea90138621a848df110ca6de9edb8f6d5150
1 /*
2 * Interface code to listbox widgets
3 *
4 * Copyright Martin Ayotte, 1993
5 *
6 */
7
8 /*
9 #define DEBUG_LISTBOX
10 */
11
12 static char Copyright[] = "Copyright Martin Ayotte, 1993";
13
14 #include <stdio.h>
15 #include <stdlib.h>
16 #include <sys/types.h>
17 #include <sys/stat.h>
18 #include "windows.h"
19 #include "user.h"
20 #include "heap.h"
21 #include "win.h"
22 #include "msdos.h"
23 #include "wine.h"
24 #include "listbox.h"
25 #include "scroll.h"
26 #include "prototypes.h"
27
28 #define GMEM_ZEROINIT 0x0040
29
30
31 LPHEADLIST ListBoxGetWindowAndStorage(HWND hwnd, WND **wndPtr);
32 LPHEADLIST ListBoxGetStorageHeader(HWND hwnd);
33 void StdDrawListBox(HWND hwnd);
34 void OwnerDrawListBox(HWND hwnd);
35 int ListBoxFindMouse(HWND hwnd, int X, int Y);
36 int CreateListBoxStruct(HWND hwnd);
37 void ListBoxAskMeasure(WND *wndPtr, LPHEADLIST lphl, LPLISTSTRUCT lpls);
38 int ListBoxAddString(HWND hwnd, LPSTR newstr);
39 int ListBoxInsertString(HWND hwnd, UINT uIndex, LPSTR newstr);
40 int ListBoxGetText(HWND hwnd, UINT uIndex, LPSTR OutStr);
41 int ListBoxDeleteString(HWND hwnd, UINT uIndex);
42 int ListBoxFindString(HWND hwnd, UINT nFirst, LPSTR MatchStr);
43 int ListBoxResetContent(HWND hwnd);
44 int ListBoxSetCurSel(HWND hwnd, WORD wIndex);
45 int ListBoxSetSel(HWND hwnd, WORD wIndex, WORD state);
46 int ListBoxGetSel(HWND hwnd, WORD wIndex);
47 int ListBoxDirectory(HWND hwnd, UINT attrib, LPSTR filespec);
48 int ListBoxGetItemRect(HWND hwnd, WORD wIndex, LPRECT rect);
49 int ListBoxSetItemHeight(HWND hwnd, WORD wIndex, long height);
50 int ListBoxDefaultItem(HWND hwnd, WND *wndPtr,
51 LPHEADLIST lphl, LPLISTSTRUCT lpls);
52 int ListBoxFindNextMatch(HWND hwnd, WORD wChar);
53
54
55 /***********************************************************************
56 * ListBoxWndProc
57 */
58 LONG ListBoxWndProc( HWND hwnd, WORD message, WORD wParam, LONG lParam )
59 {
60 WND *wndPtr;
61 LPHEADLIST lphl;
62 HWND hWndCtl;
63 WORD wRet;
64 RECT rect;
65 int y;
66 CREATESTRUCT *createStruct;
67 static RECT rectsel;
68 switch(message) {
69 case WM_CREATE:
70 CreateListBoxStruct(hwnd);
71 lphl = ListBoxGetWindowAndStorage(hwnd, &wndPtr);
72 #ifdef DEBUG_LISTBOX
73 printf("ListBox WM_CREATE %lX !\n", lphl);
74 #endif
75 createStruct = (CREATESTRUCT *)lParam;
76 if (HIWORD(createStruct->lpCreateParams) != 0)
77 lphl->hWndLogicParent = (HWND)HIWORD(createStruct->lpCreateParams);
78 else
79 lphl->hWndLogicParent = GetParent(hwnd);
80 lphl->ColumnsWidth = wndPtr->rectClient.right - wndPtr->rectClient.left;
81 if (wndPtr->dwStyle & WS_VSCROLL) {
82 SetScrollRange(hwnd, SB_VERT, 1, lphl->ItemsCount, TRUE);
83 ShowScrollBar(hwnd, SB_VERT, FALSE);
84 }
85 if (wndPtr->dwStyle & WS_HSCROLL) {
86 SetScrollRange(hwnd, SB_HORZ, 1, 1, TRUE);
87 ShowScrollBar(hwnd, SB_HORZ, FALSE);
88 }
89 if ((wndPtr->dwStyle & LBS_OWNERDRAWFIXED) == LBS_OWNERDRAWFIXED) {
90 }
91 return 0;
92 case WM_DESTROY:
93 lphl = ListBoxGetWindowAndStorage(hwnd, &wndPtr);
94 if (lphl == 0) return 0;
95 ListBoxResetContent(hwnd);
96 free(lphl);
97 *((LPHEADLIST *)&wndPtr->wExtra[1]) = 0;
98 #ifdef DEBUG_LISTBOX
99 printf("ListBox WM_DESTROY %lX !\n", lphl);
100 #endif
101 return 0;
102
103 case WM_VSCROLL:
104 #ifdef DEBUG_LISTBOX
105 printf("ListBox WM_VSCROLL w=%04X l=%08X !\n", wParam, lParam);
106 #endif
107 lphl = ListBoxGetStorageHeader(hwnd);
108 if (lphl == NULL) return 0;
109 y = lphl->FirstVisible;
110 switch(wParam) {
111 case SB_LINEUP:
112 if (lphl->FirstVisible > 1)
113 lphl->FirstVisible--;
114 break;
115 case SB_LINEDOWN:
116 if (lphl->FirstVisible < lphl->ItemsCount)
117 lphl->FirstVisible++;
118 break;
119 case SB_PAGEUP:
120 if (lphl->FirstVisible > 1)
121 lphl->FirstVisible -= lphl->ItemsVisible;
122 break;
123 case SB_PAGEDOWN:
124 if (lphl->FirstVisible < lphl->ItemsCount)
125 lphl->FirstVisible += lphl->ItemsVisible;
126 break;
127 case SB_THUMBTRACK:
128 lphl->FirstVisible = LOWORD(lParam);
129 break;
130 }
131 if (lphl->FirstVisible < 1) lphl->FirstVisible = 1;
132 if (lphl->FirstVisible > lphl->ItemsCount)
133 lphl->FirstVisible = lphl->ItemsCount;
134 if (y != lphl->FirstVisible) {
135 SetScrollPos(hwnd, SB_VERT, lphl->FirstVisible, TRUE);
136 InvalidateRect(hwnd, NULL, TRUE);
137 UpdateWindow(hwnd);
138 }
139 return 0;
140
141 case WM_HSCROLL:
142 #ifdef DEBUG_LISTBOX
143 printf("ListBox WM_HSCROLL w=%04X l=%08X !\n", wParam, lParam);
144 #endif
145 lphl = ListBoxGetStorageHeader(hwnd);
146 if (lphl == NULL) return 0;
147 y = lphl->FirstVisible;
148 switch(wParam) {
149 case SB_LINEUP:
150 if (lphl->FirstVisible > 1)
151 lphl->FirstVisible -= lphl->ItemsPerColumn;
152 break;
153 case SB_LINEDOWN:
154 if (lphl->FirstVisible < lphl->ItemsCount)
155 lphl->FirstVisible += lphl->ItemsPerColumn;
156 break;
157 case SB_PAGEUP:
158 if (lphl->FirstVisible > 1 && lphl->ItemsPerColumn != 0)
159 lphl->FirstVisible -= lphl->ItemsVisible /
160 lphl->ItemsPerColumn * lphl->ItemsPerColumn;
161 break;
162 case SB_PAGEDOWN:
163 if (lphl->FirstVisible < lphl->ItemsCount &&
164 lphl->ItemsPerColumn != 0)
165 lphl->FirstVisible += lphl->ItemsVisible /
166 lphl->ItemsPerColumn * lphl->ItemsPerColumn;
167 break;
168 case SB_THUMBTRACK:
169 lphl->FirstVisible = lphl->ItemsPerColumn *
170 (LOWORD(lParam) - 1) + 1;
171 break;
172 }
173 if (lphl->FirstVisible < 1) lphl->FirstVisible = 1;
174 if (lphl->FirstVisible > lphl->ItemsCount)
175 lphl->FirstVisible = lphl->ItemsCount;
176 if (lphl->ItemsPerColumn != 0) {
177 lphl->FirstVisible = lphl->FirstVisible /
178 lphl->ItemsPerColumn * lphl->ItemsPerColumn + 1;
179 if (y != lphl->FirstVisible) {
180 SetScrollPos(hwnd, SB_HORZ, lphl->FirstVisible /
181 lphl->ItemsPerColumn + 1, TRUE);
182 InvalidateRect(hwnd, NULL, TRUE);
183 UpdateWindow(hwnd);
184 }
185 }
186 return 0;
187
188 case WM_LBUTTONDOWN:
189 SetFocus(hwnd);
190 SetCapture(hwnd);
191 lphl = ListBoxGetWindowAndStorage(hwnd, &wndPtr);
192 if (lphl == NULL) return 0;
193 lphl->PrevFocused = lphl->ItemFocused;
194 y = ListBoxFindMouse(hwnd, LOWORD(lParam), HIWORD(lParam));
195 if ((wndPtr->dwStyle & LBS_MULTIPLESEL) == LBS_MULTIPLESEL) {
196 lphl->ItemFocused = y;
197 wRet = ListBoxGetSel(hwnd, y);
198 ListBoxSetSel(hwnd, y, !wRet);
199 }
200 else {
201 ListBoxSetCurSel(hwnd, y);
202 }
203 ListBoxGetItemRect(hwnd, y, &rectsel);
204 InvalidateRect(hwnd, NULL, TRUE);
205 UpdateWindow(hwnd);
206 return 0;
207 case WM_LBUTTONUP:
208 ReleaseCapture();
209 lphl = ListBoxGetWindowAndStorage(hwnd, &wndPtr);
210 if (lphl == NULL) return 0;
211 if (lphl->PrevFocused != lphl->ItemFocused)
212 SendMessage(lphl->hWndLogicParent, WM_COMMAND, wndPtr->wIDmenu,
213 MAKELONG(hwnd, LBN_SELCHANGE));
214 return 0;
215 case WM_RBUTTONUP:
216 case WM_LBUTTONDBLCLK:
217 lphl = ListBoxGetWindowAndStorage(hwnd, &wndPtr);
218 if (lphl == NULL) return 0;
219 SendMessage(lphl->hWndLogicParent, WM_COMMAND, wndPtr->wIDmenu,
220 MAKELONG(hwnd, LBN_DBLCLK));
221 printf("ListBox Send LBN_DBLCLK !\n");
222 return 0;
223 case WM_MOUSEMOVE:
224 if ((wParam & MK_LBUTTON) != 0) {
225 y = HIWORD(lParam);
226 if (y < 4) {
227 lphl = ListBoxGetStorageHeader(hwnd);
228 if (lphl->FirstVisible > 1) {
229 lphl->FirstVisible--;
230 if (wndPtr->dwStyle & WS_VSCROLL)
231 SetScrollPos(hwnd, SB_VERT, lphl->FirstVisible, TRUE);
232 InvalidateRect(hwnd, NULL, TRUE);
233 UpdateWindow(hwnd);
234 break;
235 }
236 }
237 GetClientRect(hwnd, &rect);
238 if (y > (rect.bottom - 4)) {
239 lphl = ListBoxGetStorageHeader(hwnd);
240 if (lphl->FirstVisible < lphl->ItemsCount) {
241 lphl->FirstVisible++;
242 if (wndPtr->dwStyle & WS_VSCROLL)
243 SetScrollPos(hwnd, SB_VERT, lphl->FirstVisible, TRUE);
244 InvalidateRect(hwnd, NULL, TRUE);
245 UpdateWindow(hwnd);
246 break;
247 }
248 }
249 if ((y > 0) && (y < (rect.bottom - 4))) {
250 if ((y < rectsel.top) || (y > rectsel.bottom)) {
251 wRet = ListBoxFindMouse(hwnd, LOWORD(lParam), HIWORD(lParam));
252 if ((wndPtr->dwStyle & LBS_MULTIPLESEL) == LBS_MULTIPLESEL) {
253 lphl->ItemFocused = wRet;
254 }
255 else {
256 ListBoxSetCurSel(hwnd, wRet);
257 }
258 ListBoxGetItemRect(hwnd, wRet, &rectsel);
259 InvalidateRect(hwnd, NULL, TRUE);
260 UpdateWindow(hwnd);
261 }
262 }
263 }
264 break;
265 case WM_KEYDOWN:
266 lphl = ListBoxGetWindowAndStorage(hwnd, &wndPtr);
267 if (lphl == NULL) return 0;
268 switch(wParam) {
269 case VK_TAB:
270 hWndCtl = GetNextDlgTabItem(lphl->hWndLogicParent,
271 hwnd, !(GetKeyState(VK_SHIFT) < 0));
272 SetFocus(hWndCtl);
273 if ((GetKeyState(VK_SHIFT) < 0))
274 printf("ListBox PreviousDlgTabItem %04X !\n", hWndCtl);
275 else
276 printf("ListBox NextDlgTabItem %04X !\n", hWndCtl);
277 break;
278 case VK_HOME:
279 lphl->ItemFocused = 0;
280 break;
281 case VK_END:
282 lphl->ItemFocused = lphl->ItemsCount - 1;
283 break;
284 case VK_LEFT:
285 if ((wndPtr->dwStyle & LBS_MULTICOLUMN) == LBS_MULTICOLUMN) {
286 lphl->ItemFocused -= lphl->ItemsPerColumn;
287 }
288 break;
289 case VK_UP:
290 lphl->ItemFocused--;
291 break;
292 case VK_RIGHT:
293 if ((wndPtr->dwStyle & LBS_MULTICOLUMN) == LBS_MULTICOLUMN) {
294 lphl->ItemFocused += lphl->ItemsPerColumn;
295 }
296 break;
297 case VK_DOWN:
298 lphl->ItemFocused++;
299 break;
300 case VK_PRIOR:
301 lphl->ItemFocused -= lphl->ItemsVisible;
302 break;
303 case VK_NEXT:
304 lphl->ItemFocused += lphl->ItemsVisible;
305 break;
306 case VK_SPACE:
307 wRet = ListBoxGetSel(hwnd, lphl->ItemFocused);
308 ListBoxSetSel(hwnd, lphl->ItemFocused, !wRet);
309 break;
310 default:
311 ListBoxFindNextMatch(hwnd, wParam);
312 return 0;
313 }
314 if (lphl->ItemFocused < 0) lphl->ItemFocused = 0;
315 if (lphl->ItemFocused >= lphl->ItemsCount)
316 lphl->ItemFocused = lphl->ItemsCount - 1;
317 lphl->FirstVisible = lphl->ItemFocused / lphl->ItemsVisible *
318 lphl->ItemsVisible + 1;
319 if (lphl->FirstVisible < 1) lphl->FirstVisible = 1;
320 if ((wndPtr->dwStyle & LBS_MULTIPLESEL) != LBS_MULTIPLESEL) {
321 ListBoxSetCurSel(hwnd, lphl->ItemFocused);
322 }
323 if (wndPtr->dwStyle & WS_VSCROLL)
324 SetScrollPos(hwnd, SB_VERT, lphl->FirstVisible, TRUE);
325 InvalidateRect(hwnd, NULL, TRUE);
326 UpdateWindow(hwnd);
327 break;
328 case WM_PAINT:
329 wndPtr = WIN_FindWndPtr(hwnd);
330 if ((wndPtr->dwStyle & LBS_OWNERDRAWFIXED) == LBS_OWNERDRAWFIXED) {
331 OwnerDrawListBox(hwnd);
332 break;
333 }
334 if ((wndPtr->dwStyle & LBS_OWNERDRAWVARIABLE) == LBS_OWNERDRAWVARIABLE) {
335 OwnerDrawListBox(hwnd);
336 break;
337 }
338 StdDrawListBox(hwnd);
339 break;
340 case WM_SETFOCUS:
341 #ifdef DEBUG_LISTBOX
342 printf("ListBox WM_SETFOCUS !\n");
343 #endif
344 lphl = ListBoxGetWindowAndStorage(hwnd, &wndPtr);
345 break;
346 case WM_KILLFOCUS:
347 #ifdef DEBUG_LISTBOX
348 printf("ListBox WM_KILLFOCUS !\n");
349 #endif
350 InvalidateRect(hwnd, NULL, TRUE);
351 UpdateWindow(hwnd);
352 break;
353
354 case LB_RESETCONTENT:
355 #ifdef DEBUG_LISTBOX
356 printf("ListBox LB_RESETCONTENT !\n");
357 #endif
358 ListBoxResetContent(hwnd);
359 return 0;
360 case LB_DIR:
361 #ifdef DEBUG_LISTBOX
362 printf("ListBox LB_DIR !\n");
363 #endif
364 wRet = ListBoxDirectory(hwnd, wParam, (LPSTR)lParam);
365 InvalidateRect(hwnd, NULL, TRUE);
366 UpdateWindow(hwnd);
367 return wRet;
368 case LB_ADDSTRING:
369 wRet = ListBoxAddString(hwnd, (LPSTR)lParam);
370 return wRet;
371 case LB_GETTEXT:
372 wRet = ListBoxGetText(hwnd, wParam, (LPSTR)lParam);
373 #ifdef DEBUG_LISTBOX
374 printf("ListBox LB_GETTEXT #%u '%s' !\n", wParam, (LPSTR)lParam);
375 #endif
376 return wRet;
377 case LB_INSERTSTRING:
378 wRet = ListBoxInsertString(hwnd, wParam, (LPSTR)lParam);
379 return wRet;
380 case LB_DELETESTRING:
381 printf("ListBox LB_DELETESTRING #%u !\n", wParam);
382 wRet = ListBoxDeleteString(hwnd, wParam);
383 return wRet;
384 case LB_FINDSTRING:
385 wRet = ListBoxFindString(hwnd, wParam, (LPSTR)lParam);
386 return wRet;
387 case LB_GETCARETINDEX:
388 return wRet;
389 case LB_GETCOUNT:
390 lphl = ListBoxGetStorageHeader(hwnd);
391 return lphl->ItemsCount;
392 case LB_GETCURSEL:
393 lphl = ListBoxGetStorageHeader(hwnd);
394 #ifdef DEBUG_LISTBOX
395 printf("ListBox LB_GETCURSEL %u !\n", lphl->ItemFocused);
396 #endif
397 return lphl->ItemFocused;
398 case LB_GETHORIZONTALEXTENT:
399 return wRet;
400 case LB_GETITEMDATA:
401 return wRet;
402 case LB_GETITEMHEIGHT:
403 return wRet;
404 case LB_GETITEMRECT:
405 return wRet;
406 case LB_GETSEL:
407 wRet = ListBoxGetSel(hwnd, wParam);
408 return wRet;
409 case LB_GETSELCOUNT:
410 return wRet;
411 case LB_GETSELITEMS:
412 return wRet;
413 case LB_GETTEXTLEN:
414 return wRet;
415 case LB_GETTOPINDEX:
416 return wRet;
417 case LB_SELECTSTRING:
418 return wRet;
419 case LB_SELITEMRANGE:
420 return wRet;
421 case LB_SETCARETINDEX:
422 return wRet;
423 case LB_SETCOLUMNWIDTH:
424 lphl = ListBoxGetStorageHeader(hwnd);
425 lphl->ColumnsWidth = wParam;
426 break;
427 case LB_SETHORIZONTALEXTENT:
428 return wRet;
429 case LB_SETITEMDATA:
430 return wRet;
431 case LB_SETTABSTOPS:
432 return wRet;
433 case LB_SETCURSEL:
434 #ifdef DEBUG_LISTBOX
435 printf("ListBox LB_SETCURSEL wParam=%x !\n", wParam);
436 #endif
437 wRet = ListBoxSetCurSel(hwnd, wParam);
438 InvalidateRect(hwnd, NULL, TRUE);
439 UpdateWindow(hwnd);
440 return wRet;
441 case LB_SETSEL:
442 printf("ListBox LB_SETSEL wParam=%x lParam=%lX !\n", wParam, lParam);
443 wRet = ListBoxSetSel(hwnd, LOWORD(lParam), wParam);
444 InvalidateRect(hwnd, NULL, TRUE);
445 UpdateWindow(hwnd);
446 return wRet;
447 case LB_SETTOPINDEX:
448 printf("ListBox LB_SETTOPINDEX wParam=%x !\n", wParam);
449 lphl = ListBoxGetStorageHeader(hwnd);
450 lphl->FirstVisible = wParam;
451 if (wndPtr->dwStyle & WS_VSCROLL)
452 SetScrollPos(hwnd, SB_VERT, lphl->FirstVisible, TRUE);
453 InvalidateRect(hwnd, NULL, TRUE);
454 UpdateWindow(hwnd);
455 break;
456 case LB_SETITEMHEIGHT:
457 #ifdef DEBUG_LISTBOX
458 printf("ListBox LB_SETITEMHEIGHT wParam=%x lParam=%lX !\n", wParam, lParam);
459 #endif
460 wRet = ListBoxSetItemHeight(hwnd, wParam, lParam);
461 return wRet;
462
463 default:
464 return DefWindowProc( hwnd, message, wParam, lParam );
465 }
466 return 0;
467 }
468
469
470 LPHEADLIST ListBoxGetWindowAndStorage(HWND hwnd, WND **wndPtr)
471 {
472 WND *Ptr;
473 LPHEADLIST lphl;
474 *(wndPtr) = Ptr = WIN_FindWndPtr(hwnd);
475 lphl = *((LPHEADLIST *)&Ptr->wExtra[1]);
476 return lphl;
477 }
478
479
480 LPHEADLIST ListBoxGetStorageHeader(HWND hwnd)
481 {
482 WND *wndPtr;
483 LPHEADLIST lphl;
484 wndPtr = WIN_FindWndPtr(hwnd);
485 lphl = *((LPHEADLIST *)&wndPtr->wExtra[1]);
486 return lphl;
487 }
488
489
490 void StdDrawListBox(HWND hwnd)
491 {
492 WND *wndPtr;
493 LPHEADLIST lphl;
494 LPLISTSTRUCT lpls;
495 PAINTSTRUCT ps;
496 HBRUSH hBrush;
497 int OldBkMode;
498 DWORD dwOldTextColor;
499 HWND hWndParent;
500 HDC hdc;
501 RECT rect;
502 UINT i, h, h2, maxwidth, ipc;
503 char C[128];
504 h = 0;
505 hdc = BeginPaint( hwnd, &ps );
506 if (!IsWindowVisible(hwnd)) {
507 EndPaint( hwnd, &ps );
508 return;
509 }
510 lphl = ListBoxGetWindowAndStorage(hwnd, &wndPtr);
511 if (lphl == NULL) goto EndOfPaint;
512 hBrush = SendMessage(lphl->hWndLogicParent, WM_CTLCOLOR, (WORD)hdc,
513 MAKELONG(hwnd, CTLCOLOR_LISTBOX));
514 if (hBrush == (HBRUSH)NULL) hBrush = GetStockObject(WHITE_BRUSH);
515 GetClientRect(hwnd, &rect);
516 /*
517 if (wndPtr->dwStyle & WS_VSCROLL) rect.right -= 16;
518 if (wndPtr->dwStyle & WS_HSCROLL) rect.bottom -= 16;
519 */
520 FillRect(hdc, &rect, hBrush);
521 maxwidth = rect.right;
522 rect.right = lphl->ColumnsWidth;
523 if (lphl->ItemsCount == 0) goto EndOfPaint;
524 lpls = lphl->lpFirst;
525 if (lpls == NULL) goto EndOfPaint;
526 lphl->ItemsVisible = 0;
527 lphl->ItemsPerColumn = ipc = 0;
528 for(i = 1; i <= lphl->ItemsCount; i++) {
529 if (i >= lphl->FirstVisible) {
530 if (lpls == NULL) break;
531 if ((h + lpls->dis.rcItem.bottom - lpls->dis.rcItem.top) > rect.bottom) {
532 if ((wndPtr->dwStyle & LBS_MULTICOLUMN) == LBS_MULTICOLUMN) {
533 lphl->ItemsPerColumn = max(lphl->ItemsPerColumn, ipc);
534 ipc = 0;
535 h = 0;
536 rect.left += lphl->ColumnsWidth;
537 rect.right += lphl->ColumnsWidth;
538 if (rect.left > maxwidth) break;
539 }
540 else
541 break;
542 }
543 h2 = lpls->dis.rcItem.bottom - lpls->dis.rcItem.top;
544 lpls->dis.rcItem.top = h;
545 lpls->dis.rcItem.bottom = h + h2;
546 lpls->dis.rcItem.left = rect.left;
547 lpls->dis.rcItem.right = rect.right;
548 OldBkMode = SetBkMode(hdc, TRANSPARENT);
549 if (lpls->dis.itemState != 0) {
550 dwOldTextColor = SetTextColor(hdc, 0x00FFFFFFL);
551 FillRect(hdc, &lpls->dis.rcItem, GetStockObject(BLACK_BRUSH));
552 }
553 TextOut(hdc, rect.left + 5, h + 2, (char *)lpls->dis.itemData,
554 strlen((char *)lpls->dis.itemData));
555 if (lpls->dis.itemState != 0) {
556 SetTextColor(hdc, dwOldTextColor);
557 }
558 SetBkMode(hdc, OldBkMode);
559 if ((lphl->ItemFocused == i - 1) && GetFocus() == hwnd) {
560 DrawFocusRect(hdc, &lpls->dis.rcItem);
561 }
562 h += h2;
563 lphl->ItemsVisible++;
564 ipc++;
565 }
566 if (lpls->lpNext == NULL) goto EndOfPaint;
567 lpls = (LPLISTSTRUCT)lpls->lpNext;
568 }
569 EndOfPaint:
570 EndPaint( hwnd, &ps );
571 if ((lphl->ItemsCount > lphl->ItemsVisible) &
572 (wndPtr->dwStyle & WS_VSCROLL)) {
573 /*
574 InvalidateRect(wndPtr->hWndVScroll, NULL, TRUE);
575 UpdateWindow(wndPtr->hWndVScroll);
576 */
577 }
578 }
579
580
581
582 void OwnerDrawListBox(HWND hwnd)
583 {
584 WND *wndPtr;
585 LPHEADLIST lphl;
586 LPLISTSTRUCT lpls;
587 PAINTSTRUCT ps;
588 HBRUSH hBrush;
589 HWND hWndParent;
590 HDC hdc;
591 RECT rect;
592 UINT i, h, h2, maxwidth;
593 char C[128];
594 h = 0;
595 hdc = BeginPaint(hwnd, &ps);
596 if (!IsWindowVisible(hwnd)) {
597 EndPaint( hwnd, &ps );
598 return;
599 }
600 lphl = ListBoxGetWindowAndStorage(hwnd, &wndPtr);
601 if (lphl == NULL) goto EndOfPaint;
602 hBrush = SendMessage(lphl->hWndLogicParent, WM_CTLCOLOR, (WORD)hdc,
603 MAKELONG(hwnd, CTLCOLOR_LISTBOX));
604 if (hBrush == (HBRUSH)NULL) hBrush = GetStockObject(WHITE_BRUSH);
605 GetClientRect(hwnd, &rect);
606 if (wndPtr->dwStyle & WS_VSCROLL) rect.right -= 16;
607 if (wndPtr->dwStyle & WS_HSCROLL) rect.bottom -= 16;
608 FillRect(hdc, &rect, hBrush);
609 maxwidth = rect.right;
610 rect.right = lphl->ColumnsWidth;
611 if (lphl->ItemsCount == 0) goto EndOfPaint;
612 lpls = lphl->lpFirst;
613 if (lpls == NULL) goto EndOfPaint;
614 lphl->ItemsVisible = 0;
615 for (i = 1; i <= lphl->ItemsCount; i++) {
616 if (i >= lphl->FirstVisible) {
617 lpls->dis.hDC = hdc;
618 lpls->dis.itemID = i - 1;
619 h2 = lpls->dis.rcItem.bottom - lpls->dis.rcItem.top;
620 lpls->dis.rcItem.top = h;
621 lpls->dis.rcItem.bottom = h + h2;
622 lpls->dis.rcItem.left = rect.left;
623 lpls->dis.rcItem.right = rect.right;
624 lpls->dis.itemAction = ODA_DRAWENTIRE;
625 if (lpls->dis.itemState != 0) {
626 lpls->dis.itemAction |= ODA_SELECT;
627 }
628 if (lphl->ItemFocused == i - 1) {
629 lpls->dis.itemAction |= ODA_FOCUS;
630 }
631 #ifdef DEBUT_LISTBOX
632 printf("LBOX WM_DRAWITEM #%d left=%d top=%d right=%d bottom=%d !\n",
633 i, lpls->dis.rcItem.left, lpls->dis.rcItem.top,
634 lpls->dis.rcItem.right, lpls->dis.rcItem.bottom);
635 printf("LBOX WM_DRAWITEM Parent=%X &dis=%lX CtlID=%u !\n",
636 hWndParent, (LONG)&lpls->dis, lpls->dis.CtlID);
637 printf("LBOX WM_DRAWITEM '%s' !\n", lpls->dis.itemData);
638 #endif
639 SendMessage(lphl->hWndLogicParent, WM_DRAWITEM, i, (LPARAM)&lpls->dis);
640 if (lpls->dis.itemState != 0) {
641 InvertRect(hdc, &lpls->dis.rcItem);
642 }
643 h += h2;
644 lphl->ItemsVisible++;
645 if (h > rect.bottom) goto EndOfPaint;
646 }
647 if (lpls->lpNext == NULL) goto EndOfPaint;
648 lpls = (LPLISTSTRUCT)lpls->lpNext;
649 }
650 EndOfPaint:
651 EndPaint( hwnd, &ps );
652 if ((lphl->ItemsCount > lphl->ItemsVisible) &
653 (wndPtr->dwStyle & WS_VSCROLL)) {
654 /*
655 InvalidateRect(wndPtr->hWndVScroll, NULL, TRUE);
656 UpdateWindow(wndPtr->hWndVScroll);
657 */
658 }
659 }
660
661
662
663 int ListBoxFindMouse(HWND hwnd, int X, int Y)
664 {
665 WND *wndPtr;
666 LPHEADLIST lphl;
667 LPLISTSTRUCT lpls;
668 RECT rect;
669 UINT i, h, h2, w, w2;
670 char C[128];
671 lphl = ListBoxGetWindowAndStorage(hwnd, &wndPtr);
672 if (lphl == NULL) return LB_ERR;
673 if (lphl->ItemsCount == 0) return LB_ERR;
674 lpls = lphl->lpFirst;
675 if (lpls == NULL) return LB_ERR;
676 GetClientRect(hwnd, &rect);
677 if (wndPtr->dwStyle & WS_VSCROLL) rect.right -= 16;
678 if (wndPtr->dwStyle & WS_HSCROLL) rect.bottom -= 16;
679 h = w2 = 0;
680 w = lphl->ColumnsWidth;
681 for(i = 1; i <= lphl->ItemsCount; i++) {
682 if (i >= lphl->FirstVisible) {
683 h2 = h;
684 h += lpls->dis.rcItem.bottom - lpls->dis.rcItem.top;
685 if ((Y > h2) && (Y < h) &&
686 (X > w2) && (X < w)) return(i - 1);
687 if (h > rect.bottom) {
688 if ((wndPtr->dwStyle & LBS_MULTICOLUMN) != LBS_MULTICOLUMN) return LB_ERR;
689 h = 0;
690 w2 = w;
691 w += lphl->ColumnsWidth;
692 if (w2 > rect.right) return LB_ERR;
693 }
694 }
695 if (lpls->lpNext == NULL) return LB_ERR;
696 lpls = (LPLISTSTRUCT)lpls->lpNext;
697 }
698 return(LB_ERR);
699 }
700
701
702
703 int CreateListBoxStruct(HWND hwnd)
704 {
705 WND *wndPtr;
706 LPHEADLIST lphl;
707 wndPtr = WIN_FindWndPtr(hwnd);
708 lphl = (LPHEADLIST)malloc(sizeof(HEADLIST));
709 lphl->lpFirst = NULL;
710 *((LPHEADLIST *)&wndPtr->wExtra[1]) = lphl; /* HEAD of List */
711 lphl->ItemsCount = 0;
712 lphl->ItemsVisible = 0;
713 lphl->FirstVisible = 1;
714 lphl->StdItemHeight = 15;
715 lphl->DrawCtlType = ODT_LISTBOX;
716 return TRUE;
717 }
718
719
720 void ListBoxAskMeasure(WND *wndPtr, LPHEADLIST lphl, LPLISTSTRUCT lpls)
721 {
722 MEASUREITEMSTRUCT *measure;
723 HANDLE hTemp = USER_HEAP_ALLOC(GMEM_MOVEABLE, sizeof(MEASUREITEMSTRUCT));
724 measure = (MEASUREITEMSTRUCT *) USER_HEAP_ADDR(hTemp);
725 if (measure == NULL) return;
726 measure->CtlType = ODT_LISTBOX;
727 measure->CtlID = wndPtr->wIDmenu;
728 measure->itemID = lpls->dis.itemID;
729 measure->itemWidth = wndPtr->rectWindow.right - wndPtr->rectWindow.left;
730 measure->itemHeight = 0;
731 measure->itemData = lpls->dis.itemData;
732 SendMessage(lphl->hWndLogicParent, WM_MEASUREITEM, 0, (DWORD)measure);
733 lpls->dis.rcItem.right = lpls->dis.rcItem.left + measure->itemWidth;
734 lpls->dis.rcItem.bottom = lpls->dis.rcItem.top + measure->itemHeight;
735 USER_HEAP_FREE(hTemp);
736 }
737
738
739 int ListBoxAddString(HWND hwnd, LPSTR newstr)
740 {
741 WND *wndPtr;
742 LPHEADLIST lphl;
743 LPLISTSTRUCT lpls, lplsnew;
744 HANDLE hTemp;
745 LPSTR str;
746 lphl = ListBoxGetWindowAndStorage(hwnd, &wndPtr);
747 if (lphl == NULL) return LB_ERR;
748 hTemp = USER_HEAP_ALLOC(GMEM_MOVEABLE, sizeof(LISTSTRUCT));
749 lplsnew = (LPLISTSTRUCT) USER_HEAP_ADDR(hTemp);
750 lpls = lphl->lpFirst;
751 if (lpls != NULL) {
752 while(lpls->lpNext != NULL) {
753 lpls = (LPLISTSTRUCT)lpls->lpNext;
754 }
755 lpls->lpNext = lplsnew;
756 }
757 else
758 lphl->lpFirst = lplsnew;
759 lphl->ItemsCount++;
760 #ifdef DEBUG_LISTBOX
761 printf("Items Count = %u\n", lphl->ItemsCount);
762 #endif
763 hTemp = 0;
764 if ((wndPtr->dwStyle & LBS_HASSTRINGS) != LBS_HASSTRINGS) {
765 if (((wndPtr->dwStyle & LBS_OWNERDRAWFIXED) != LBS_OWNERDRAWFIXED) &&
766 ((wndPtr->dwStyle & LBS_OWNERDRAWVARIABLE) != LBS_OWNERDRAWVARIABLE)) {
767 hTemp = USER_HEAP_ALLOC(GMEM_MOVEABLE, strlen(newstr) + 1);
768 str = (LPSTR)USER_HEAP_ADDR(hTemp);
769 if (str == NULL) return LB_ERRSPACE;
770 strcpy(str, newstr);
771 newstr = str;
772 #ifdef DEBUG_LISTBOX
773 printf("ListBoxAddString// after strcpy '%s'\n", str);
774 #endif
775 }
776 }
777 ListBoxDefaultItem(hwnd, wndPtr, lphl, lplsnew);
778 lplsnew->hMem = hTemp;
779 lplsnew->lpNext = NULL;
780 lplsnew->dis.itemID = lphl->ItemsCount;
781 lplsnew->dis.itemData = (DWORD)newstr;
782 lplsnew->hData = hTemp;
783 if ((wndPtr->dwStyle & LBS_OWNERDRAWVARIABLE) == LBS_OWNERDRAWVARIABLE)
784 ListBoxAskMeasure(wndPtr, lphl, lplsnew);
785 if (wndPtr->dwStyle & WS_VSCROLL)
786 SetScrollRange(hwnd, SB_VERT, 1, lphl->ItemsCount,
787 (lphl->FirstVisible != 1));
788 if ((wndPtr->dwStyle & WS_HSCROLL) && lphl->ItemsPerColumn != 0)
789 SetScrollRange(hwnd, SB_HORZ, 1, lphl->ItemsVisible /
790 lphl->ItemsPerColumn + 1, (lphl->FirstVisible != 1));
791 if (lphl->FirstVisible >= (lphl->ItemsCount - lphl->ItemsVisible)) {
792 InvalidateRect(hwnd, NULL, TRUE);
793 UpdateWindow(hwnd);
794 }
795 if ((lphl->ItemsCount - lphl->FirstVisible) == lphl->ItemsVisible) {
796 if (wndPtr->dwStyle & WS_VSCROLL)
797 ShowScrollBar(hwnd, SB_VERT, TRUE);
798 if (wndPtr->dwStyle & WS_HSCROLL)
799 ShowScrollBar(hwnd, SB_HORZ, TRUE);
800 }
801 return lphl->ItemsCount;
802 }
803
804
805 int ListBoxInsertString(HWND hwnd, UINT uIndex, LPSTR newstr)
806 {
807 WND *wndPtr;
808 LPHEADLIST lphl;
809 LPLISTSTRUCT lpls, lplsnew;
810 HANDLE hTemp;
811 LPSTR str;
812 UINT Count;
813 lphl = ListBoxGetWindowAndStorage(hwnd, &wndPtr);
814 if (lphl == NULL) return LB_ERR;
815 if (uIndex >= lphl->ItemsCount) return LB_ERR;
816 lpls = lphl->lpFirst;
817 if (lpls == NULL) return LB_ERR;
818 if (uIndex > lphl->ItemsCount) return LB_ERR;
819 for(Count = 1; Count < uIndex; Count++) {
820 if (lpls->lpNext == NULL) return LB_ERR;
821 lpls = (LPLISTSTRUCT)lpls->lpNext;
822 }
823 hTemp = USER_HEAP_ALLOC(GMEM_MOVEABLE, sizeof(LISTSTRUCT));
824 lplsnew = (LPLISTSTRUCT) USER_HEAP_ADDR(hTemp);
825 ListBoxDefaultItem(hwnd, wndPtr, lphl, lplsnew);
826 lplsnew->hMem = hTemp;
827 lpls->lpNext = lplsnew;
828 lphl->ItemsCount++;
829 hTemp = 0;
830 if ((wndPtr->dwStyle & LBS_HASSTRINGS) != LBS_HASSTRINGS) {
831 if (((wndPtr->dwStyle & LBS_OWNERDRAWFIXED) != LBS_OWNERDRAWFIXED) &&
832 ((wndPtr->dwStyle & LBS_OWNERDRAWVARIABLE) != LBS_OWNERDRAWVARIABLE)) {
833 hTemp = USER_HEAP_ALLOC(GMEM_MOVEABLE, strlen(newstr) + 1);
834 str = (LPSTR)USER_HEAP_ADDR(hTemp);
835 if (str == NULL) return LB_ERRSPACE;
836 strcpy(str, newstr);
837 newstr = str;
838 }
839 }
840 lplsnew->lpNext = NULL;
841 lplsnew->dis.itemID = lphl->ItemsCount;
842 lplsnew->dis.itemData = (DWORD)newstr;
843 lplsnew->hData = hTemp;
844 if ((wndPtr->dwStyle & LBS_OWNERDRAWVARIABLE) == LBS_OWNERDRAWVARIABLE)
845 ListBoxAskMeasure(wndPtr, lphl, lplsnew);
846 if (wndPtr->dwStyle & WS_VSCROLL)
847 SetScrollRange(hwnd, SB_VERT, 1, lphl->ItemsCount,
848 (lphl->FirstVisible != 1));
849 if ((wndPtr->dwStyle & WS_HSCROLL) && lphl->ItemsPerColumn != 0)
850 SetScrollRange(hwnd, SB_HORZ, 1, lphl->ItemsVisible /
851 lphl->ItemsPerColumn + 1, (lphl->FirstVisible != 1));
852 if (((lphl->ItemsCount - lphl->FirstVisible) == lphl->ItemsVisible) &&
853 (lphl->ItemsVisible != 0)) {
854 if (wndPtr->dwStyle & WS_VSCROLL) ShowScrollBar(hwnd, SB_VERT, TRUE);
855 if (wndPtr->dwStyle & WS_HSCROLL) ShowScrollBar(hwnd, SB_HORZ, TRUE);
856 }
857 if ((lphl->FirstVisible <= uIndex) &&
858 ((lphl->FirstVisible + lphl->ItemsVisible) >= uIndex)) {
859 InvalidateRect(hwnd, NULL, TRUE);
860 UpdateWindow(hwnd);
861 }
862 return lphl->ItemsCount;
863 }
864
865
866 int ListBoxGetText(HWND hwnd, UINT uIndex, LPSTR OutStr)
867 {
868 WND *wndPtr;
869 LPHEADLIST lphl;
870 LPLISTSTRUCT lpls;
871 UINT Count;
872 lphl = ListBoxGetWindowAndStorage(hwnd, &wndPtr);
873 if (lphl == NULL) return LB_ERR;
874 if (uIndex >= lphl->ItemsCount) return LB_ERR;
875 lpls = lphl->lpFirst;
876 if (lpls == NULL) return LB_ERR;
877 if (uIndex > lphl->ItemsCount) return LB_ERR;
878 for(Count = 0; Count < uIndex; Count++) {
879 if (lpls->lpNext == NULL) return LB_ERR;
880 lpls = (LPLISTSTRUCT)lpls->lpNext;
881 }
882 if (((wndPtr->dwStyle & LBS_OWNERDRAWFIXED) == LBS_OWNERDRAWFIXED) ||
883 ((wndPtr->dwStyle & LBS_OWNERDRAWVARIABLE) == LBS_OWNERDRAWVARIABLE)) {
884 if ((wndPtr->dwStyle & LBS_HASSTRINGS) != LBS_HASSTRINGS) {
885 *((long *)OutStr) = lpls->dis.itemData;
886 return 4;
887 }
888 }
889
890 strcpy(OutStr, (char *)lpls->dis.itemData);
891 return strlen(OutStr);
892 }
893
894
895 int ListBoxDeleteString(HWND hwnd, UINT uIndex)
896 {
897 WND *wndPtr;
898 LPHEADLIST lphl;
899 LPLISTSTRUCT lpls, lpls2;
900 UINT Count;
901 lphl = ListBoxGetWindowAndStorage(hwnd, &wndPtr);
902 if (lphl == NULL) return LB_ERR;
903 if (uIndex >= lphl->ItemsCount) return LB_ERR;
904 lpls = lphl->lpFirst;
905 if (lpls == NULL) return LB_ERR;
906 if (uIndex > lphl->ItemsCount) return LB_ERR;
907 for(Count = 1; Count < uIndex; Count++) {
908 if (lpls->lpNext == NULL) return LB_ERR;
909 lpls2 = lpls;
910 lpls = (LPLISTSTRUCT)lpls->lpNext;
911 }
912 lpls2->lpNext = (LPLISTSTRUCT)lpls->lpNext;
913 lphl->ItemsCount--;
914 if (lpls->hData != 0) USER_HEAP_FREE(lpls->hData);
915 if (lpls->hMem != 0) USER_HEAP_FREE(lpls->hMem);
916 if (wndPtr->dwStyle & WS_VSCROLL)
917 SetScrollRange(hwnd, SB_VERT, 1, lphl->ItemsCount, TRUE);
918 if ((wndPtr->dwStyle & WS_HSCROLL) && lphl->ItemsPerColumn != 0)
919 SetScrollRange(hwnd, SB_HORZ, 1, lphl->ItemsVisible /
920 lphl->ItemsPerColumn + 1, TRUE);
921 if (lphl->ItemsCount < lphl->ItemsVisible) {
922 if (wndPtr->dwStyle & WS_VSCROLL)
923 ShowScrollBar(hwnd, SB_VERT, FALSE);
924 if (wndPtr->dwStyle & WS_HSCROLL)
925 ShowScrollBar(hwnd, SB_HORZ, FALSE);
926 }
927 if ((lphl->FirstVisible <= uIndex) &&
928 ((lphl->FirstVisible + lphl->ItemsVisible) >= uIndex)) {
929 InvalidateRect(hwnd, NULL, TRUE);
930 UpdateWindow(hwnd);
931 }
932 return lphl->ItemsCount;
933 }
934
935
936 int ListBoxFindString(HWND hwnd, UINT nFirst, LPSTR MatchStr)
937 {
938 LPHEADLIST lphl;
939 LPLISTSTRUCT lpls;
940 UINT Count;
941 lphl = ListBoxGetStorageHeader(hwnd);
942 if (lphl == NULL) return LB_ERR;
943 if (nFirst > lphl->ItemsCount) return LB_ERR;
944 lpls = lphl->lpFirst;
945 if (lpls == NULL) return LB_ERR;
946 Count = 0;
947 while(lpls != NULL) {
948 if (strcmp((char *)lpls->dis.itemData, MatchStr) == 0) return Count;
949 lpls = (LPLISTSTRUCT)lpls->lpNext;
950 Count++;
951 }
952 return LB_ERR;
953 }
954
955
956 int ListBoxResetContent(HWND hwnd)
957 {
958 WND *wndPtr;
959 LPHEADLIST lphl;
960 LPLISTSTRUCT lpls, lpls2;
961 UINT i;
962 lphl = ListBoxGetWindowAndStorage(hwnd, &wndPtr);
963 if (lphl == NULL) return LB_ERR;
964 lpls = lphl->lpFirst;
965 if (lpls == NULL) return LB_ERR;
966 for(i = 0; i <= lphl->ItemsCount; i++) {
967 lpls2 = lpls;
968 lpls = (LPLISTSTRUCT)lpls->lpNext;
969 if (i != 0) {
970 #ifdef DEBUG_LISTBOX
971 printf("ResetContent #%u\n", i);
972 #endif
973 if (lpls2->hData != 0) USER_HEAP_FREE(lpls->hData);
974 if (lpls2->hMem != 0) USER_HEAP_FREE(lpls->hMem);
975 }
976 if (lpls == NULL) break;
977 }
978 lphl->lpFirst = NULL;
979 lphl->FirstVisible = 1;
980 lphl->ItemsCount = 0;
981 lphl->ItemFocused = 0;
982 lphl->PrevFocused = 0;
983 if ((wndPtr->dwStyle && LBS_NOTIFY) != 0)
984 SendMessage(wndPtr->hwndParent, WM_COMMAND,
985 wndPtr->wIDmenu, MAKELONG(hwnd, LBN_SELCHANGE));
986
987 if (wndPtr->dwStyle & WS_VSCROLL)
988 SetScrollRange(hwnd, SB_VERT, 1, lphl->ItemsCount, TRUE);
989 if ((wndPtr->dwStyle & WS_HSCROLL) && lphl->ItemsPerColumn != 0)
990 SetScrollRange(hwnd, SB_HORZ, 1, lphl->ItemsVisible /
991 lphl->ItemsPerColumn + 1, TRUE);
992 if (wndPtr->dwStyle & WS_VSCROLL)
993 ShowScrollBar(hwnd, SB_VERT, FALSE);
994 if (wndPtr->dwStyle & WS_HSCROLL)
995 ShowScrollBar(hwnd, SB_HORZ, FALSE);
996 InvalidateRect(hwnd, NULL, TRUE);
997 UpdateWindow(hwnd);
998 return TRUE;
999 }
1000
1001
1002 int ListBoxSetCurSel(HWND hwnd, WORD wIndex)
1003 {
1004 WND *wndPtr;
1005 LPHEADLIST lphl;
1006 LPLISTSTRUCT lpls, lpls2;
1007 UINT i;
1008 lphl = ListBoxGetWindowAndStorage(hwnd, &wndPtr);
1009 if (lphl == NULL) return LB_ERR;
1010 lphl->ItemFocused = LB_ERR;
1011 if (wIndex >= lphl->ItemsCount) return LB_ERR;
1012 lpls = lphl->lpFirst;
1013 if (lpls == NULL) return LB_ERR;
1014 for(i = 0; i < lphl->ItemsCount; i++) {
1015 lpls2 = lpls;
1016 lpls = (LPLISTSTRUCT)lpls->lpNext;
1017 if (i == wIndex)
1018 lpls2->dis.itemState = 1;
1019 else
1020 if (lpls2->dis.itemState != 0)
1021 lpls2->dis.itemState = 0;
1022 if (lpls == NULL) break;
1023 }
1024 lphl->ItemFocused = wIndex;
1025 if ((wndPtr->dwStyle && LBS_NOTIFY) != 0)
1026 SendMessage(wndPtr->hwndParent, WM_COMMAND,
1027 wndPtr->wIDmenu, MAKELONG(hwnd, LBN_SELCHANGE));
1028 return LB_ERR;
1029 }
1030
1031
1032
1033 int ListBoxSetSel(HWND hwnd, WORD wIndex, WORD state)
1034 {
1035 LPHEADLIST lphl;
1036 LPLISTSTRUCT lpls, lpls2;
1037 UINT i;
1038 lphl = ListBoxGetStorageHeader(hwnd);
1039 if (lphl == NULL) return LB_ERR;
1040 if (wIndex >= lphl->ItemsCount) return LB_ERR;
1041 lpls = lphl->lpFirst;
1042 if (lpls == NULL) return LB_ERR;
1043 for(i = 0; i < lphl->ItemsCount; i++) {
1044 lpls2 = lpls;
1045 lpls = (LPLISTSTRUCT)lpls->lpNext;
1046 if ((i == wIndex) || (wIndex == (WORD)-1)) {
1047 lpls2->dis.itemState = state;
1048 break;
1049 }
1050 if (lpls == NULL) break;
1051 }
1052 return LB_ERR;
1053 }
1054
1055
1056 int ListBoxGetSel(HWND hwnd, WORD wIndex)
1057 {
1058 LPHEADLIST lphl;
1059 LPLISTSTRUCT lpls, lpls2;
1060 UINT i;
1061 lphl = ListBoxGetStorageHeader(hwnd);
1062 if (lphl == NULL) return LB_ERR;
1063 if (wIndex >= lphl->ItemsCount) return LB_ERR;
1064 lpls = lphl->lpFirst;
1065 if (lpls == NULL) return LB_ERR;
1066 for(i = 0; i < lphl->ItemsCount; i++) {
1067 lpls2 = lpls;
1068 lpls = (LPLISTSTRUCT)lpls->lpNext;
1069 if (i == wIndex) {
1070 return lpls2->dis.itemState;
1071 }
1072 if (lpls == NULL) break;
1073 }
1074 return LB_ERR;
1075 }
1076
1077
1078 int ListBoxDirectory(HWND hwnd, UINT attrib, LPSTR filespec)
1079 {
1080 struct dosdirent *dp;
1081 struct stat st;
1082 int x, wRet;
1083 char temp[256];
1084 #ifdef DEBUG_LISTBOX
1085 fprintf(stderr,"ListBoxDirectory: %s, %4x\n",filespec,attrib);
1086 #endif
1087 if ((dp = (struct dosdirent *)DOS_opendir(filespec)) ==NULL) return 0;
1088 while (1) {
1089 dp = (struct dosdirent *)DOS_readdir(dp);
1090 if (!dp->inuse) break;
1091 #ifdef DEBUG_LISTBOX
1092 printf("ListBoxDirectory %08X '%s' !\n", dp->filename, dp->filename);
1093 #endif
1094 if (dp->attribute & FA_DIREC) {
1095 if (attrib & DDL_DIRECTORY) {
1096 sprintf(temp, "[%s]", dp->filename);
1097 if ( (wRet = ListBoxAddString(hwnd, temp)) == LB_ERR) break;
1098 }
1099 } else
1100 if (attrib & DDL_EXCLUSIVE) {
1101 if (attrib & (DDL_READWRITE | DDL_READONLY | DDL_HIDDEN | DDL_SYSTEM) )
1102 if ( (wRet = ListBoxAddString(hwnd, dp->filename)) == LB_ERR)
1103 break;
1104 } else {
1105 if ( (wRet = ListBoxAddString(hwnd, dp->filename)) == LB_ERR)
1106 break;
1107 }
1108 }
1109 DOS_closedir(dp);
1110
1111 if (attrib & DDL_DRIVES)
1112 {
1113 for (x=0;x!=MAX_DOS_DRIVES;x++)
1114 {
1115 if (DOS_ValidDrive(x))
1116 {
1117 sprintf(temp, "[-%c-]", 'A'+x);
1118 if ( (wRet = ListBoxAddString(hwnd, temp)) == LB_ERR)
1119 break;
1120 }
1121 }
1122 }
1123 #ifdef DEBUG_LISTBOX
1124 printf("End of ListBoxDirectory !\n");
1125 #endif
1126 return wRet;
1127 }
1128
1129
1130 int ListBoxGetItemRect(HWND hwnd, WORD wIndex, LPRECT lprect)
1131 {
1132 LPHEADLIST lphl;
1133 LPLISTSTRUCT lpls, lpls2;
1134 UINT i;
1135 lphl = ListBoxGetStorageHeader(hwnd);
1136 if (lphl == NULL) return LB_ERR;
1137 if (wIndex > lphl->ItemsCount) return LB_ERR;
1138 lpls = lphl->lpFirst;
1139 if (lpls == NULL) return LB_ERR;
1140 for(i = 0; i < lphl->ItemsCount; i++) {
1141 lpls2 = lpls;
1142 lpls = (LPLISTSTRUCT)lpls->lpNext;
1143 if (i == wIndex) {
1144 *(lprect) = lpls2->dis.rcItem;
1145 break;
1146 }
1147 if (lpls == NULL) break;
1148 }
1149 return LB_ERR;
1150 }
1151
1152
1153
1154 int ListBoxSetItemHeight(HWND hwnd, WORD wIndex, long height)
1155 {
1156 LPHEADLIST lphl;
1157 LPLISTSTRUCT lpls, lpls2;
1158 UINT i;
1159 lphl = ListBoxGetStorageHeader(hwnd);
1160 if (lphl == NULL) return LB_ERR;
1161 if (wIndex > lphl->ItemsCount) return LB_ERR;
1162 lpls = lphl->lpFirst;
1163 if (lpls == NULL) return LB_ERR;
1164 for(i = 0; i < lphl->ItemsCount; i++) {
1165 lpls2 = lpls;
1166 lpls = (LPLISTSTRUCT)lpls->lpNext;
1167 if (i == wIndex) {
1168 lpls2->dis.rcItem.bottom = lpls2->dis.rcItem.top + (short)height;
1169 InvalidateRect(hwnd, NULL, TRUE);
1170 UpdateWindow(hwnd);
1171 break;
1172 }
1173 if (lpls == NULL) break;
1174 }
1175 return LB_ERR;
1176 }
1177
1178
1179
1180
1181
1182 int ListBoxDefaultItem(HWND hwnd, WND *wndPtr,
1183 LPHEADLIST lphl, LPLISTSTRUCT lpls)
1184 {
1185 RECT rect;
1186 GetClientRect(hwnd, &rect);
1187 SetRect(&lpls->dis.rcItem, 0, 0, rect.right, lphl->StdItemHeight);
1188 lpls->dis.CtlType = lphl->DrawCtlType;
1189 lpls->dis.CtlID = wndPtr->wIDmenu;
1190 lpls->dis.itemID = 0;
1191 lpls->dis.itemAction = 0;
1192 lpls->dis.itemState = 0;
1193 lpls->dis.hwndItem = hwnd;
1194 lpls->dis.hDC = 0;
1195 lpls->dis.itemData = 0;
1196 }
1197
1198
1199
1200 int ListBoxFindNextMatch(HWND hwnd, WORD wChar)
1201 {
1202 WND *wndPtr;
1203 LPHEADLIST lphl;
1204 LPLISTSTRUCT lpls;
1205 UINT Count;
1206 lphl = ListBoxGetWindowAndStorage(hwnd, &wndPtr);
1207 if (lphl == NULL) return LB_ERR;
1208 lpls = lphl->lpFirst;
1209 if (lpls == NULL) return LB_ERR;
1210 if (wChar < ' ') return LB_ERR;
1211 if (((wndPtr->dwStyle & LBS_OWNERDRAWFIXED) == LBS_OWNERDRAWFIXED) ||
1212 ((wndPtr->dwStyle & LBS_OWNERDRAWVARIABLE) == LBS_OWNERDRAWVARIABLE)) {
1213 if ((wndPtr->dwStyle & LBS_HASSTRINGS) != LBS_HASSTRINGS) {
1214 return LB_ERR;
1215 }
1216 }
1217 Count = 0;
1218 while(lpls != NULL) {
1219 if (Count > lphl->ItemFocused) {
1220 if (*((char *)lpls->dis.itemData) == (char)wChar) {
1221 lphl->FirstVisible = Count - lphl->ItemsVisible / 2;
1222 if (lphl->FirstVisible < 1) lphl->FirstVisible = 1;
1223 if ((wndPtr->dwStyle & LBS_MULTIPLESEL) == LBS_MULTIPLESEL) {
1224 lphl->ItemFocused = Count;
1225 }
1226 else {
1227 ListBoxSetCurSel(hwnd, Count);
1228 }
1229 SetScrollPos(hwnd, SB_VERT, lphl->FirstVisible, TRUE);
1230 InvalidateRect(hwnd, NULL, TRUE);
1231 UpdateWindow(hwnd);
1232 return Count;
1233 }
1234 }
1235 lpls = (LPLISTSTRUCT)lpls->lpNext;
1236 Count++;
1237 }
1238 Count = 0;
1239 lpls = lphl->lpFirst;
1240 while(lpls != NULL) {
1241 if (*((char *)lpls->dis.itemData) == (char)wChar) {
1242 if (Count == lphl->ItemFocused) return LB_ERR;
1243 lphl->FirstVisible = Count - lphl->ItemsVisible / 2;
1244 if (lphl->FirstVisible < 1) lphl->FirstVisible = 1;
1245 if ((wndPtr->dwStyle & LBS_MULTIPLESEL) == LBS_MULTIPLESEL) {
1246 lphl->ItemFocused = Count;
1247 }
1248 else {
1249 ListBoxSetCurSel(hwnd, Count);
1250 }
1251 SetScrollPos(hwnd, SB_VERT, lphl->FirstVisible, TRUE);
1252 InvalidateRect(hwnd, NULL, TRUE);
1253 UpdateWindow(hwnd);
1254 return Count;
1255 }
1256 lpls = (LPLISTSTRUCT)lpls->lpNext;
1257 Count++;
1258 }
1259 return LB_ERR;
1260 }
1261
1262
GSOC 2012 project to enhance the control panel