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