source: trunk/src/comctl32/comctl32.cpp@ 2912

Last change on this file since 2912 was 2875, checked in by cbratschi, 26 years ago

C -> C++, WINE animate, treeview WM_VSCROLL fixed
File size: 25.4 KB
Line 
1/* $Id: comctl32.cpp,v 1.1 2000-02-23 17:09:40 cbratschi Exp $ */
2/*
3 * Win32 common controls implementation
4 *
5 * Copyright (C) 1999 Achim Hasenmueller
6 *
7 * Based on the work of the WINE group (www.winehq.com)
8 *
9 *
10 * Project Odin Software License can be found in LICENSE.TXT
11 *
12 */
13
14/*
15 - Corel 20000212 level
16 - WINE 20000130 level (commctrl.c)
17*/
18
19#include "comctl32.h"
20#include "ccbase.h"
21#include "winerror.h"
22#include "progress.h"
23#include "comboex.h"
24#include "animate.h"
25#include "datetime.h"
26#include "flatsb.h"
27#include "hotkey.h"
28#include "ipaddress.h"
29#include "monthcal.h"
30#include "nativefont.h"
31#include "pager.h"
32#include "tab.h"
33#include "status.h"
34#include "header.h"
35#include "updown.h"
36#include "rebar.h"
37#include "trackbar.h"
38#include "tooltips.h"
39#include "toolbar.h"
40#include "treeview.h"
41#include "listview.h"
42
43HANDLE COMCTL32_hHeap = (HANDLE)NULL;
44HMODULE COMCTL32_hModule = 0;
45LPSTR COMCTL32_aSubclass = (LPSTR)NULL;
46
47void CDECL RegisterCOMCTL32WindowClasses(unsigned long hinstDLL)
48{
49 /* create private heap */
50 COMCTL32_hHeap = HeapCreate(0, 0x10000, 0);
51 /* add global subclassing atom (used by 'tooltip' and 'updown') */
52 COMCTL32_aSubclass = (LPSTR)(DWORD)GlobalAddAtomA ("CC32SubclassInfo");
53 /* This will be wrong for any other process attching in this address-space! */
54 COMCTL32_hModule = (HMODULE)hinstDLL;
55
56 /* register controls */
57 PROGRESS_Register();
58 COMBOEX_Register();
59 ANIMATE_Register();
60 DATETIME_Register();
61 FLATSB_Register();
62 HOTKEY_Register();
63 IPADDRESS_Register();
64 MONTHCAL_Register();
65 NATIVEFONT_Register();
66 PAGER_Register();
67 TAB_Register();
68 STATUS_Register();
69 HEADER_Register();
70 UPDOWN_Register();
71 REBAR_Register();
72 TRACKBAR_Register();
73 TOOLTIPS_Register();
74 TOOLBAR_Register();
75 TREEVIEW_Register();
76 LISTVIEW_Register();
77}
78
79void CDECL UnregisterCOMCTL32WindowClasses(void)
80{
81 /* unregister controls */
82 PROGRESS_Unregister();
83 COMBOEX_Unregister();
84 ANIMATE_Unregister();
85 DATETIME_Unregister();
86 FLATSB_Unregister();
87 HOTKEY_Unregister();
88 IPADDRESS_Unregister();
89 MONTHCAL_Unregister();
90 NATIVEFONT_Unregister();
91 PAGER_Unregister();
92 TAB_Unregister();
93 STATUS_Unregister();
94 HEADER_Unregister();
95 UPDOWN_Unregister();
96 REBAR_Unregister();
97 TRACKBAR_Unregister();
98 TOOLTIPS_Unregister();
99 TOOLBAR_Unregister();
100 TREEVIEW_Unregister();
101 LISTVIEW_Unregister();
102
103 /* destroy private heap */
104 HeapDestroy(COMCTL32_hHeap);
105 COMCTL32_hHeap = (HANDLE)NULL;
106}
107
108/***********************************************************************
109 * MenuHelp [COMCTL32.2]
110 *
111 * PARAMS
112 * uMsg [I] message (WM_MENUSELECT) (see NOTES)
113 * wParam [I] wParam of the message uMsg
114 * lParam [I] lParam of the message uMsg
115 * hMainMenu [I] handle to the application's main menu
116 * hInst [I] handle to the module that contains string resources
117 * hwndStatus [I] handle to the status bar window
118 * lpwIDs [I] pointer to an array of intergers (see NOTES)
119 *
120 * RETURNS
121 * No return value
122 *
123 * NOTES
124 * The official documentation is incomplete!
125 * This is the correct documentation:
126 *
127 * uMsg:
128 * MenuHelp() does NOT handle WM_COMMAND messages! It only handes
129 * WM_MENUSELECT messages.
130 *
131 * lpwIDs:
132 * (will be written ...)
133 */
134
135VOID WINAPI
136MenuHelp (UINT uMsg, WPARAM wParam, LPARAM lParam, HMENU hMainMenu,
137 HINSTANCE hInst, HWND hwndStatus, LPUINT lpwIDs)
138{
139 UINT uMenuID = 0;
140
141 dprintf(("COMCTL32: MenuHelp"));
142
143 if (!IsWindow (hwndStatus))
144 return;
145
146 switch (uMsg) {
147 case WM_MENUSELECT:
148// TRACE (commctrl, "WM_MENUSELECT wParam=0x%X lParam=0x%lX\n",
149// wParam, lParam);
150
151 if ((HIWORD(wParam) == 0xFFFF) && (lParam == 0)) {
152 /* menu was closed */
153// TRACE (commctrl, "menu was closed!\n");
154 SendMessageA (hwndStatus, SB_SIMPLE, FALSE, 0);
155 }
156 else {
157 /* menu item was selected */
158 if (HIWORD(wParam) & MF_POPUP)
159 uMenuID = (UINT)*(lpwIDs+1);
160 else
161 uMenuID = (UINT)LOWORD(wParam);
162// TRACE (commctrl, "uMenuID = %u\n", uMenuID);
163
164 if (uMenuID) {
165 CHAR szText[256];
166
167 if (!LoadStringA (hInst, uMenuID, szText, 256))
168 szText[0] = '\0';
169
170 SendMessageA (hwndStatus, SB_SETTEXTA,
171 255 | SBT_NOBORDERS, (LPARAM)szText);
172 SendMessageA (hwndStatus, SB_SIMPLE, TRUE, 0);
173 }
174 }
175 break;
176
177 case WM_COMMAND :
178// TRACE("WM_COMMAND wParam=0x%X lParam=0x%lX\n",
179// wParam, lParam);
180 /* WM_COMMAND is not invalid since it is documented
181 * in the windows api reference. So don't output
182 * any FIXME for WM_COMMAND
183 */
184// WARN("We don't care about the WM_COMMAND\n");
185 break;
186
187 default:
188// FIXME (commctrl, "Invalid Message 0x%x!\n", uMsg);
189 break;
190 }
191}
192
193/***********************************************************************
194 * ShowHideMenuCtl [COMCTL32.3]
195 *
196 * Shows or hides controls and updates the corresponding menu item.
197 *
198 * PARAMS
199 * hwnd [I] handle to the client window.
200 * uFlags [I] menu command id.
201 * lpInfo [I] pointer to an array of integers. (See NOTES.)
202 *
203 * RETURNS
204 * Success: TRUE
205 * Failure: FALSE
206 *
207 * NOTES
208 * The official documentation is incomplete!
209 * This is the correct documentation:
210 *
211 * hwnd
212 * Handle to the window that contains the menu and controls.
213 *
214 * uFlags
215 * Identifier of the menu item to receive or loose a check mark.
216 *
217 * lpInfo
218 * The array of integers contains pairs of values. BOTH values of
219 * the first pair must be the handles to the application's main menu.
220 * Each subsequent pair consists of a menu id and control id.
221 */
222
223BOOL WINAPI
224ShowHideMenuCtl (HWND hwnd, UINT uFlags, LPINT lpInfo)
225{
226 LPINT lpMenuId;
227
228 dprintf(("COMCTL32: ShowHideMenuCtl"));
229
230 if (lpInfo == NULL)
231 return FALSE;
232
233 if (!(lpInfo[0]) || !(lpInfo[1]))
234 return FALSE;
235
236 /* search for control */
237 lpMenuId = &lpInfo[2];
238 while (*lpMenuId != uFlags)
239 lpMenuId += 2;
240
241 if (GetMenuState (lpInfo[1], uFlags, MF_BYCOMMAND) & MFS_CHECKED) {
242 /* uncheck menu item */
243 CheckMenuItem (lpInfo[0], *lpMenuId, MF_BYCOMMAND | MF_UNCHECKED);
244
245 /* hide control */
246 lpMenuId++;
247 SetWindowPos (GetDlgItem (hwnd, *lpMenuId), 0, 0, 0, 0, 0,
248 SWP_HIDEWINDOW);
249 }
250 else {
251 /* check menu item */
252 CheckMenuItem (lpInfo[0], *lpMenuId, MF_BYCOMMAND | MF_CHECKED);
253
254 /* show control */
255 lpMenuId++;
256 SetWindowPos (GetDlgItem (hwnd, *lpMenuId), 0, 0, 0, 0, 0,
257 SWP_SHOWWINDOW);
258 }
259
260 return TRUE;
261}
262
263/***********************************************************************
264 * GetEffectiveClientRect [COMCTL32.4]
265 *
266 * PARAMS
267 * hwnd [I] handle to the client window.
268 * lpRect [O] pointer to the rectangle of the client window
269 * lpInfo [I] pointer to an array of integers (see NOTES)
270 *
271 * RETURNS
272 * No return value.
273 *
274 * NOTES
275 * The official documentation is incomplete!
276 * This is the correct documentation:
277 *
278 * lpInfo
279 * (will be written...)
280 */
281
282VOID WINAPI
283GetEffectiveClientRect (HWND hwnd, LPRECT lpRect, LPINT lpInfo)
284{
285 RECT rcCtrl;
286 INT *lpRun;
287 HWND hwndCtrl;
288
289 dprintf(("COMCTL32: GetEffectiveClientRect"));
290
291 GetClientRect (hwnd, lpRect);
292 lpRun = lpInfo;
293
294 do {
295 lpRun += 2;
296 if (*lpRun == 0)
297 return;
298 lpRun++;
299 hwndCtrl = GetDlgItem (hwnd, *lpRun);
300 if (GetWindowLongA (hwndCtrl, GWL_STYLE) & WS_VISIBLE) {
301// TRACE (commctrl, "control id 0x%x\n", *lpRun);
302 GetWindowRect (hwndCtrl, &rcCtrl);
303 MapWindowPoints ((HWND)0, hwnd, (LPPOINT)&rcCtrl, 2);
304 SubtractRect (lpRect, lpRect, &rcCtrl);
305 }
306 lpRun++;
307 } while (*lpRun);
308}
309
310/***********************************************************************
311 * DrawStatusText32A [COMCTL32.5][COMCTL32.27]
312 *
313 * Draws text with borders, like in a status bar.
314 *
315 * PARAMS
316 * hdc [I] handle to the window's display context
317 * lprc [I] pointer to a rectangle
318 * text [I] pointer to the text
319 * style [I] drawing style
320 *
321 * RETURNS
322 * No return value.
323 *
324 * NOTES
325 * The style variable can have one of the following values:
326 * (will be written ...)
327 */
328
329VOID WINAPI
330DrawStatusTextA (HDC hdc, LPRECT lprc, LPCSTR text, UINT style)
331{
332 RECT r = *lprc;
333 UINT border = BDR_SUNKENOUTER;
334
335 dprintf(("COMCTL32: DrawStatusTextA"));
336
337 if (style & SBT_POPOUT)
338 border = BDR_RAISEDOUTER;
339 else if (style & SBT_NOBORDERS)
340 border = 0;
341
342 DrawEdge (hdc, &r, border, BF_RECT|BF_ADJUST|BF_MIDDLE);
343
344 /* now draw text */
345 if (text) {
346 int oldbkmode = SetBkMode (hdc, TRANSPARENT);
347 r.left += 3;
348 DrawTextA (hdc, text, lstrlenA(text),
349 &r, DT_LEFT|DT_VCENTER|DT_SINGLELINE);
350 if (oldbkmode != TRANSPARENT)
351 SetBkMode(hdc, oldbkmode);
352 }
353}
354
355
356/***********************************************************************
357 * DrawStatusText32W [COMCTL32.28]
358 *
359 * Draws text with borders, like in a status bar.
360 *
361 * PARAMS
362 * hdc [I] handle to the window's display context
363 * lprc [I] pointer to a rectangle
364 * text [I] pointer to the text
365 * style [I] drawing style
366 *
367 * RETURNS
368 * No return value.
369 */
370
371VOID WINAPI
372DrawStatusTextW (HDC hdc, LPRECT lprc, LPCWSTR text, UINT style)
373{
374 LPSTR p = HEAP_strdupWtoA (GetProcessHeap (), 0, text);
375
376 dprintf(("COMCTL32: DrawStatusTextW"));
377
378 DrawStatusTextA (hdc, lprc, p, style);
379 HeapFree (GetProcessHeap (), 0, p );
380}
381
382
383/***********************************************************************
384 * CreateStatusWindow32A [COMCTL32.6][COMCTL32.21]
385 *
386 * Creates a status bar
387 *
388 * PARAMS
389 * style [I] window style
390 * text [I] pointer to the window text
391 * parent [I] handle to the parent window
392 * wid [I] control id of the status bar
393 *
394 * RETURNS
395 * Success: handle to the status window
396 * Failure: 0
397 */
398
399HWND WINAPI
400CreateStatusWindowA (INT style, LPCSTR text, HWND parent, UINT wid)
401{
402 dprintf(("COMCTL32: CreateStatusWindowA"));
403
404 return CreateWindowA(STATUSCLASSNAMEA, text, style,
405 CW_USEDEFAULT, CW_USEDEFAULT,
406 CW_USEDEFAULT, CW_USEDEFAULT,
407 parent, wid, 0, 0);
408}
409
410
411/***********************************************************************
412 * CreateStatusWindow32W [COMCTL32.22] Creates a status bar control
413 *
414 * PARAMS
415 * style [I] window style
416 * text [I] pointer to the window text
417 * parent [I] handle to the parent window
418 * wid [I] control id of the status bar
419 *
420 * RETURNS
421 * Success: handle to the status window
422 * Failure: 0
423 */
424
425HWND WINAPI
426CreateStatusWindowW (INT style, LPCWSTR text, HWND parent, UINT wid)
427{
428 dprintf(("COMCTL32: CreateStatusWindowW"));
429
430 return CreateWindowW(STATUSCLASSNAMEW, text, style,
431 CW_USEDEFAULT, CW_USEDEFAULT,
432 CW_USEDEFAULT, CW_USEDEFAULT,
433 parent, wid, 0, 0);
434}
435
436
437/***********************************************************************
438 * CreateUpDownControl [COMCTL32.16] Creates an up-down control
439 *
440 * PARAMS
441 * style [I] window styles
442 * x [I] horizontal position of the control
443 * y [I] vertical position of the control
444 * cx [I] with of the control
445 * cy [I] height of the control
446 * parent [I] handle to the parent window
447 * id [I] the control's identifier
448 * inst [I] handle to the application's module instance
449 * buddy [I] handle to the buddy window, can be NULL
450 * maxVal [I] upper limit of the control
451 * minVal [I] lower limit of the control
452 * curVal [I] current value of the control
453 *
454 * RETURNS
455 * Success: handle to the updown control
456 * Failure: 0
457 */
458
459HWND WINAPI
460CreateUpDownControl (DWORD style, INT x, INT y, INT cx, INT cy,
461 HWND parent, INT id, HINSTANCE inst,
462 HWND buddy, INT maxVal, INT minVal, INT curVal)
463{
464 HWND hUD;
465
466 dprintf(("COMCTL32: CreateUpDownControl"));
467
468 hUD = CreateWindowA (UPDOWN_CLASSA, 0, style, x, y, cx, cy,
469 parent, id, inst, 0);
470 if (hUD) {
471 SendMessageA (hUD, UDM_SETBUDDY, buddy, 0);
472 SendMessageA (hUD, UDM_SETRANGE, 0, MAKELONG(maxVal, minVal));
473 SendMessageA (hUD, UDM_SETPOS, 0, MAKELONG(curVal, 0));
474 }
475
476 return hUD;
477}
478
479/***********************************************************************
480 * InitCommonControls [COMCTL32.17]
481 *
482 * Registers the common controls.
483 *
484 * PARAMS
485 * No parameters.
486 *
487 * RETURNS
488 * No return values.
489 *
490 * NOTES
491 * This function is just a dummy.
492 * The Win95 controls are registered at the DLL's initialization.
493 * To register other controls InitCommonControlsEx() must be used.
494 */
495
496VOID WINAPI InitCommonControls(VOID)
497{
498 dprintf(("COMCTL32: InitCommonControls"));
499}
500
501/***********************************************************************
502 * InitCommonControlsEx [COMCTL32.81]
503 *
504 * Registers the common controls.
505 *
506 * PARAMS
507 * lpInitCtrls [I] pointer to an INITCOMMONCONTROLS structure.
508 *
509 * RETURNS
510 * Success: TRUE
511 * Failure: FALSE
512 *
513 * NOTES
514 * Only the additinal common controls are registered by this function.
515 * The Win95 controls are registered at the DLL's initialization.
516 */
517
518BOOL WINAPI
519InitCommonControlsEx (LPINITCOMMONCONTROLSEX lpInitCtrls)
520{
521 INT cCount;
522 DWORD dwMask;
523
524 dprintf(("COMCTL32: InitCommonControlsEx"));
525
526 if (!lpInitCtrls)
527 return FALSE;
528 if (lpInitCtrls->dwSize != sizeof(INITCOMMONCONTROLSEX))
529 return FALSE;
530
531// TRACE(commctrl,"(0x%08lx)\n", lpInitCtrls->dwICC);
532
533 for (cCount = 0; cCount < 32; cCount++) {
534 dwMask = 1 << cCount;
535 if (!(lpInitCtrls->dwICC & dwMask))
536 continue;
537
538 switch (lpInitCtrls->dwICC & dwMask) {
539 /* dummy initialization */
540 case ICC_ANIMATE_CLASS:
541 case ICC_BAR_CLASSES:
542 case ICC_LISTVIEW_CLASSES:
543 case ICC_TREEVIEW_CLASSES:
544 case ICC_TAB_CLASSES:
545 case ICC_UPDOWN_CLASS:
546 case ICC_PROGRESS_CLASS:
547 case ICC_HOTKEY_CLASS:
548 break;
549
550 /* advanced classes - not included in Win95 */
551 case ICC_DATE_CLASSES:
552 MONTHCAL_Register ();
553 DATETIME_Register ();
554 break;
555
556 case ICC_USEREX_CLASSES:
557 COMBOEX_Register ();
558 break;
559
560 case ICC_COOL_CLASSES:
561 REBAR_Register ();
562 break;
563
564 case ICC_INTERNET_CLASSES:
565 IPADDRESS_Register ();
566 break;
567
568 case ICC_PAGESCROLLER_CLASS:
569 PAGER_Register ();
570 break;
571
572 case ICC_NATIVEFNTCTL_CLASS:
573 NATIVEFONT_Register ();
574 break;
575
576 default:
577// FIXME (commctrl, "Unknown class! dwICC=0x%lX\n", dwMask);
578 break;
579 }
580 }
581
582 return TRUE;
583}
584
585/***********************************************************************
586 * CreateToolbarEx [COMCTL32.32] Creates a tool bar window
587 *
588 * PARAMS
589 * hwnd
590 * style
591 * wID
592 * nBitmaps
593 * hBMInst
594 * wBMID
595 * lpButtons
596 * iNumButtons
597 * dxButton
598 * dyButton
599 * dxBitmap
600 * dyBitmap
601 * uStructSize
602 *
603 * RETURNS
604 * Success: handle to the tool bar control
605 * Failure: 0
606 */
607
608HWND WINAPI
609CreateToolbarEx (HWND hwnd, DWORD style, UINT wID, INT nBitmaps,
610 HINSTANCE hBMInst, UINT wBMID, LPCTBBUTTON lpButtons,
611 INT iNumButtons, INT dxButton, INT dyButton,
612 INT dxBitmap, INT dyBitmap, UINT uStructSize)
613{
614 HWND hwndTB;
615
616 dprintf(("COMCTL32: CreateToolbarEx"));
617
618 hwndTB = CreateWindowExA (0, TOOLBARCLASSNAMEA, "", style, 0, 0, 0, 0,
619 hwnd, (HMENU)wID, 0, NULL);
620 if(hwndTB) {
621 TBADDBITMAP tbab;
622
623 SendMessageA (hwndTB, TB_BUTTONSTRUCTSIZE,
624 (WPARAM)uStructSize, 0);
625
626 /* set bitmap and button size */
627 /*If CreateToolbarEx receive 0, windows set default values*/
628 if (dyBitmap <= 0)
629 dyBitmap = 16;
630 if (dxBitmap <= 0)
631 dxBitmap = 16;
632
633 SendMessageA (hwndTB, TB_SETBITMAPSIZE, 0,
634 MAKELPARAM((WORD)dxBitmap, (WORD)dyBitmap));
635 SendMessageA (hwndTB, TB_SETBUTTONSIZE, 0,
636 MAKELPARAM((WORD)dxButton, (WORD)dyButton));
637
638
639 /* add bitmaps */
640 if (nBitmaps > 0)
641 {
642 tbab.hInst = hBMInst;
643 tbab.nID = wBMID;
644
645 SendMessageA (hwndTB, TB_ADDBITMAP,
646 (WPARAM)nBitmaps, (LPARAM)&tbab);
647 }
648 /* add buttons */
649 if(iNumButtons > 0)
650 SendMessageA (hwndTB, TB_ADDBUTTONSA,
651 (WPARAM)iNumButtons, (LPARAM)lpButtons);
652 }
653
654 return hwndTB;
655}
656
657
658/***********************************************************************
659 * CreateMappedBitmap [COMCTL32.8]
660 *
661 * PARAMS
662 * hInstance [I]
663 * idBitmap [I]
664 * wFlags [I]
665 * lpColorMap [I]
666 * iNumMaps [I]
667 *
668 * RETURNS
669 * Success: handle to the new bitmap
670 * Failure: 0
671 */
672
673HBITMAP WINAPI
674CreateMappedBitmap (HINSTANCE hInstance, INT idBitmap, UINT wFlags,
675 LPCOLORMAP lpColorMap, INT iNumMaps)
676{
677 HGLOBAL hglb;
678 HRSRC hRsrc;
679 LPBITMAPINFOHEADER lpBitmap, lpBitmapInfo;
680 UINT nSize, nColorTableSize;
681 RGBQUAD *pColorTable;
682 INT iColor, i, iMaps, nWidth, nHeight;
683 HDC hdcScreen;
684 HBITMAP hbm;
685 LPCOLORMAP sysColorMap;
686 COLORREF cRef;
687 COLORMAP internalColorMap[4] =
688 {{0x000000, 0}, {0x808080, 0}, {0xC0C0C0, 0}, {0xFFFFFF, 0}};
689
690 dprintf(("COMCTL32: CreateMappedBitmap"));
691
692 /* initialize pointer to colortable and default color table */
693 if (lpColorMap) {
694 iMaps = iNumMaps;
695 sysColorMap = lpColorMap;
696 }
697 else {
698 internalColorMap[0].to = GetSysColor (COLOR_BTNTEXT);
699 internalColorMap[1].to = GetSysColor (COLOR_BTNSHADOW);
700 internalColorMap[2].to = GetSysColor (COLOR_BTNFACE);
701 internalColorMap[3].to = GetSysColor (COLOR_BTNHIGHLIGHT);
702 iMaps = 4;
703 sysColorMap = (LPCOLORMAP)internalColorMap;
704 }
705
706 hRsrc = FindResourceA (hInstance, (LPSTR)idBitmap, RT_BITMAPA);
707 if (hRsrc == 0)
708 return 0;
709 hglb = LoadResource (hInstance, hRsrc);
710 if (hglb == 0)
711 return 0;
712 lpBitmap = (LPBITMAPINFOHEADER)LockResource (hglb);
713 if (lpBitmap == NULL)
714 return 0;
715
716 nColorTableSize = (1 << lpBitmap->biBitCount);
717 nSize = lpBitmap->biSize + nColorTableSize * sizeof(RGBQUAD);
718 lpBitmapInfo = (LPBITMAPINFOHEADER)GlobalAlloc (GMEM_FIXED, nSize);
719 if (lpBitmapInfo == NULL)
720 return 0;
721 RtlMoveMemory (lpBitmapInfo, lpBitmap, nSize);
722
723 pColorTable = (RGBQUAD*)(((LPBYTE)lpBitmapInfo)+(UINT)lpBitmapInfo->biSize);
724
725 for (iColor = 0; iColor < nColorTableSize; iColor++) {
726 for (i = 0; i < iMaps; i++) {
727 cRef = RGB(pColorTable[iColor].rgbRed,
728 pColorTable[iColor].rgbGreen,
729 pColorTable[iColor].rgbBlue);
730 if ( cRef == sysColorMap[i].from) {
731#if 0
732 if (wFlags & CBS_MASKED) {
733 if (sysColorMap[i].to != COLOR_BTNTEXT)
734 pColorTable[iColor] = RGB(255, 255, 255);
735 }
736 else
737#endif
738 pColorTable[iColor].rgbBlue = GetBValue(sysColorMap[i].to);
739 pColorTable[iColor].rgbGreen = GetGValue(sysColorMap[i].to);
740 pColorTable[iColor].rgbRed = GetRValue(sysColorMap[i].to);
741 break;
742 }
743 }
744 }
745 nWidth = (INT)lpBitmapInfo->biWidth;
746 nHeight = (INT)lpBitmapInfo->biHeight;
747 hdcScreen = GetDC ((HWND)0);
748 hbm = CreateCompatibleBitmap (hdcScreen, nWidth, nHeight);
749 if (hbm) {
750 HDC hdcDst = CreateCompatibleDC (hdcScreen);
751 HBITMAP hbmOld = SelectObject (hdcDst, hbm);
752 LPBYTE lpBits = (LPBYTE)(lpBitmap + 1);
753 lpBits += (1 << (lpBitmapInfo->biBitCount)) * sizeof(RGBQUAD);
754 StretchDIBits (hdcDst, 0, 0, nWidth, nHeight, 0, 0, nWidth, nHeight,
755 lpBits, (LPBITMAPINFO)lpBitmapInfo, DIB_RGB_COLORS,
756 SRCCOPY);
757 SelectObject (hdcDst, hbmOld);
758 DeleteDC (hdcDst);
759 }
760 ReleaseDC ((HWND)0, hdcScreen);
761 GlobalFree ((HGLOBAL)lpBitmapInfo);
762 FreeResource (hglb);
763
764 return hbm;
765}
766
767
768/***********************************************************************
769 * CreateToolbar [COMCTL32.7] Creates a tool bar control
770 *
771 * PARAMS
772 * hwnd
773 * style
774 * wID
775 * nBitmaps
776 * hBMInst
777 * wBMID
778 * lpButtons
779 * iNumButtons
780 *
781 * RETURNS
782 * Success: handle to the tool bar control
783 * Failure: 0
784 *
785 * NOTES
786 * Do not use this functions anymore. Use CreateToolbarEx instead.
787 */
788
789HWND WINAPI
790CreateToolbar (HWND hwnd, DWORD style, UINT wID, INT nBitmaps,
791 HINSTANCE hBMInst, UINT wBMID,
792 LPCOLDTBBUTTON lpButtons,INT iNumButtons)
793{
794 dprintf(("COMCTL32: CreateToolbar"));
795
796 return CreateToolbarEx (hwnd, style | CCS_NODIVIDER, wID, nBitmaps,
797 hBMInst, wBMID, (LPCTBBUTTON)lpButtons,
798 iNumButtons, 0, 0, 0, 0, sizeof (OLDTBBUTTON));
799}
800
801
802/***********************************************************************
803 * DllGetVersion [COMCTL32.25]
804 *
805 * Retrieves version information of the 'COMCTL32.DLL'
806 *
807 * PARAMS
808 * pdvi [O] pointer to version information structure.
809 *
810 * RETURNS
811 * Success: S_OK
812 * Failure: E_INVALIDARG
813 *
814 * NOTES
815 * Returns version of a comctl32.dll from IE4.01 SP1.
816 */
817
818HRESULT WINAPI
819COMCTL32_DllGetVersion (DLLVERSIONINFO *pdvi)
820{
821 dprintf(("COMCTL32: COMCTL32_DllGetVersion"));
822
823 if (pdvi->cbSize != sizeof(DLLVERSIONINFO)) {
824// WARN (commctrl, "wrong DLLVERSIONINFO size from app");
825 return E_INVALIDARG;
826 }
827
828 pdvi->dwMajorVersion = 4;
829 pdvi->dwMinorVersion = 72;
830 pdvi->dwBuildNumber = 3110;
831 pdvi->dwPlatformID = 1;
832
833// TRACE (commctrl, "%lu.%lu.%lu.%lu\n",
834// pdvi->dwMajorVersion, pdvi->dwMinorVersion,
835// pdvi->dwBuildNumber, pdvi->dwPlatformID);
836
837 return S_OK;
838}
839
840static int iTrackMax = 0;
841static HWND TrackingList[10];
842static UINT timer;
843
844static void CALLBACK TrackMouseEventProc(HWND hwndUnused, UINT uMsg, UINT idEvent, DWORD dwTime) {
845 int i = 0;
846 POINT pos;
847 HWND hwnd;
848 BOOL keepTracking = FALSE;
849 GetCursorPos(&pos);
850 hwnd = WindowFromPoint(pos);
851 /* Loop through the list of windows waiting on mouse exit */
852 while (i < iTrackMax) {
853 if (TrackingList[i] != hwnd)
854 PostMessageA(TrackingList[i], WM_MOUSELEAVE, 0, 0);
855 else
856 keepTracking = TRUE;
857
858
859 i++;
860 }
861
862 if (keepTracking) {
863 iTrackMax = 1;
864 TrackingList[0] = hwnd;
865 }
866 else
867 KillTimer(0, timer);
868}
869
870/***********************************************************************
871 * _TrackMouseEvent [COMCTL32.25]
872 *
873 * Requests notification of mouse events
874 *
875 * PARAMS
876 * ptme [I,O] pointer to TRACKMOUSEEVENT information structure.
877 *
878 * RETURNS
879 * Success: non-zero
880 * Failure: zero
881 *
882 */
883
884BOOL WINAPI
885_TrackMouseEvent (TRACKMOUSEEVENT *ptme)
886{
887 DWORD flags = 0;
888 int i;
889 BOOL cancel = 0, hover = 0, leave = 0, query = 0;
890
891 dprintf(("COMCTL32: _TrackMouseEvent"));
892
893 if (ptme->cbSize != sizeof(TRACKMOUSEEVENT)) {
894 //WARN("wrong TRACKMOUSEEVENT size from app");
895 return E_INVALIDARG;
896 }
897
898 flags = ptme->dwFlags;
899 if ( flags & TME_CANCEL ) {
900 cancel = 1;
901 flags &= ~ TME_CANCEL;
902 }
903 if ( flags & TME_HOVER ) {
904 hover = 1;
905 flags &= ~ TME_HOVER;
906 //FIXME("TME_HOVER unimplemented\n" );
907 }
908 if ( flags & TME_LEAVE ) {
909 leave = 1;
910 flags &= ~ TME_LEAVE;
911 }
912 if ( flags & TME_QUERY ) {
913 query = 1;
914 flags &= ~ TME_QUERY;
915 //FIXME("TME_QUERY unimplemented\n" );
916 }
917
918 //if ( flags )
919 // FIXME("Unknown flag(s) %ld\n", flags & ~(TME_CANCEL | TME_HOVER | TME_LEAVE | TME_QUERY) );
920
921 if (leave) {
922 if (cancel) {
923 for (i = 0; i < iTrackMax; i++)
924 if (TrackingList[i] == ptme->hwndTrack)
925 TrackingList[i] = TrackingList[--iTrackMax];
926 }
927 else {
928 if (iTrackMax == sizeof (TrackingList) / sizeof *TrackingList)
929 return FALSE;
930
931 /* Add hwndTrack to the track list */
932 TrackingList[iTrackMax++] = ptme->hwndTrack;
933 if (!timer)
934 timer = SetTimer(0, 0, 50, TrackMouseEventProc);
935 }
936 }
937
938 return TRUE;
939}
940
941
Note: See TracBrowser for help on using the repository browser.