?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Release 980927
[wine.git] / dlls / comctl32 / header.c
bloba2d86fc2ef7612a1bdac0d6956852f7ce3db381f
1 /*
2 * Header control
3 *
4 * Copyright 1998 Eric Kohl
5 *
6 * TODO:
7 * - Imagelist support (partially).
8 * - Callback items (under construction).
9 * - Order list support.
10 * - Control specific cursors (over dividers).
11 * - Hottrack support (partially).
12 * - Custom draw support (including Notifications).
13 * - Drag and Drop support (including Notifications).
14 * - Unicode support.
15 *
16 * FIXME:
17 * - Replace DrawText32A by DrawTextEx32A(...|DT_ENDELLIPSIS) in
18 * HEADER_DrawItem.
19 * - Little flaw when drawing a bitmap on the right side of the text.
20 */
21
22 #include "windows.h"
23 #include "commctrl.h"
24 #include "header.h"
25 #include "win.h"
26 #include "debug.h"
27
28
29 #define __HDM_LAYOUT_HACK__
30
31
32 #define VERT_BORDER 4
33 #define DIVIDER_WIDTH 10
34
35 #define HEADER_GetInfoPtr(wndPtr) ((HEADER_INFO *)wndPtr->wExtra[0])
36
37
38 static INT32
39 HEADER_DrawItem (WND *wndPtr, HDC32 hdc, INT32 iItem, BOOL32 bHotTrack)
40 {
41 HEADER_INFO *infoPtr = HEADER_GetInfoPtr(wndPtr);
42 HEADER_ITEM *phdi = &infoPtr->items[iItem];
43 RECT32 r;
44 INT32 oldBkMode;
45
46 r = phdi->rect;
47 if (r.right - r.left == 0)
48 return phdi->rect.right;
49
50 if (wndPtr->dwStyle & HDS_BUTTONS) {
51 if (phdi->bDown) {
52 DrawEdge32 (hdc, &r, BDR_RAISEDOUTER,
53 BF_RECT | BF_FLAT | BF_MIDDLE | BF_ADJUST);
54 r.left += 2;
55 r.top += 2;
56 }
57 else
58 DrawEdge32 (hdc, &r, EDGE_RAISED,
59 BF_RECT | BF_SOFT | BF_MIDDLE | BF_ADJUST);
60 }
61 else
62 DrawEdge32 (hdc, &r, EDGE_ETCHED, BF_BOTTOM | BF_RIGHT | BF_ADJUST);
63
64 if (phdi->fmt & HDF_OWNERDRAW) {
65 DRAWITEMSTRUCT32 dis;
66 dis.CtlType = ODT_HEADER;
67 dis.CtlID = wndPtr->wIDmenu;
68 dis.itemID = iItem;
69 dis.itemAction = ODA_DRAWENTIRE;
70 dis.itemState = phdi->bDown ? ODS_SELECTED : 0;
71 dis.hwndItem = wndPtr->hwndSelf;
72 dis.hDC = hdc;
73 dis.rcItem = r;
74 dis.itemData = phdi->lParam;
75 SendMessage32A (GetParent32 (wndPtr->hwndSelf), WM_DRAWITEM,
76 (WPARAM32)wndPtr->wIDmenu, (LPARAM)&dis);
77 }
78 else {
79 UINT32 uTextJustify = DT_LEFT;
80
81 if ((phdi->fmt & HDF_JUSTIFYMASK) == HDF_CENTER)
82 uTextJustify = DT_CENTER;
83 else if ((phdi->fmt & HDF_JUSTIFYMASK) == HDF_RIGHT)
84 uTextJustify = DT_RIGHT;
85
86 if ((phdi->fmt & HDF_BITMAP) && (phdi->hbm)) {
87 BITMAP32 bmp;
88 HDC32 hdcBitmap;
89 INT32 yD, yS, cx, cy, rx, ry;
90
91 GetObject32A (phdi->hbm, sizeof(BITMAP32), (LPVOID)&bmp);
92
93 ry = r.bottom - r.top;
94 rx = r.right - r.left;
95
96 if (ry >= bmp.bmHeight) {
97 cy = bmp.bmHeight;
98 yD = r.top + (ry - bmp.bmHeight) / 2;
99 yS = 0;
100 }
101 else {
102 cy = ry;
103 yD = r.top;
104 yS = (bmp.bmHeight - ry) / 2;
105
106 }
107
108 if (rx >= bmp.bmWidth + 6) {
109 cx = bmp.bmWidth;
110 }
111 else {
112 cx = rx - 6;
113 }
114
115 hdcBitmap = CreateCompatibleDC32 (hdc);
116 SelectObject32 (hdcBitmap, phdi->hbm);
117 BitBlt32 (hdc, r.left + 3, yD, cx, cy, hdcBitmap, 0, yS, SRCCOPY);
118 DeleteDC32 (hdcBitmap);
119
120 r.left += (bmp.bmWidth + 3);
121 }
122
123
124 if ((phdi->fmt & HDF_BITMAP_ON_RIGHT) && (phdi->hbm)) {
125 BITMAP32 bmp;
126 HDC32 hdcBitmap;
127 INT32 xD, yD, yS, cx, cy, rx, ry, tx;
128 RECT32 textRect;
129
130 GetObject32A (phdi->hbm, sizeof(BITMAP32), (LPVOID)&bmp);
131
132 textRect = r;
133 DrawText32A(hdc, phdi->pszText, lstrlen32A(phdi->pszText),
134 &textRect, DT_LEFT|DT_VCENTER|DT_SINGLELINE|DT_CALCRECT);
135 tx = textRect.right - textRect.left;
136 ry = r.bottom - r.top;
137 rx = r.right - r.left;
138
139 if (ry >= bmp.bmHeight) {
140 cy = bmp.bmHeight;
141 yD = r.top + (ry - bmp.bmHeight) / 2;
142 yS = 0;
143 }
144 else {
145 cy = ry;
146 yD = r.top;
147 yS = (bmp.bmHeight - ry) / 2;
148
149 }
150
151 if (r.left + tx + bmp.bmWidth + 9 <= r.right) {
152 cx = bmp.bmWidth;
153 xD = r.left + tx + 6;
154 }
155 else {
156 if (rx >= bmp.bmWidth + 6) {
157 cx = bmp.bmWidth;
158 xD = r.right - bmp.bmWidth - 3;
159 r.right = xD - 3;
160 }
161 else {
162 cx = rx - 3;
163 xD = r.left;
164 r.right = r.left;
165 }
166 }
167
168 hdcBitmap = CreateCompatibleDC32 (hdc);
169 SelectObject32 (hdcBitmap, phdi->hbm);
170 BitBlt32 (hdc, xD, yD, cx, cy, hdcBitmap, 0, yS, SRCCOPY);
171 DeleteDC32 (hdcBitmap);
172 }
173
174 if (phdi->fmt & HDF_IMAGE) {
175
176
177 // ImageList_Draw (infoPtr->himl, phdi->iImage,...);
178 }
179
180 if ((phdi->fmt & HDF_STRING) && (phdi->pszText)) {
181 oldBkMode = SetBkMode32(hdc, TRANSPARENT);
182 r.left += 3;
183 r.right -= 3;
184 SetTextColor32 (hdc, bHotTrack ? COLOR_HIGHLIGHT : COLOR_BTNTEXT);
185 DrawText32A(hdc, phdi->pszText, lstrlen32A(phdi->pszText),
186 &r, uTextJustify|DT_VCENTER|DT_SINGLELINE);
187 if (oldBkMode != TRANSPARENT)
188 SetBkMode32(hdc, oldBkMode);
189 }
190 }
191 return phdi->rect.right;
192 }
193
194
195 static void
196 HEADER_Refresh (WND *wndPtr, HDC32 hdc)
197 {
198 HEADER_INFO *infoPtr = HEADER_GetInfoPtr(wndPtr);
199 HFONT32 hFont, hOldFont;
200 RECT32 rect;
201 HBRUSH32 hbrBk;
202 INT32 i, x;
203
204 /* get rect for the bar, adjusted for the border */
205 GetClientRect32 (wndPtr->hwndSelf, &rect);
206
207 hFont = infoPtr->hFont ? infoPtr->hFont : GetStockObject32 (SYSTEM_FONT);
208 hOldFont = SelectObject32 (hdc, hFont);
209
210 /* draw Background */
211 hbrBk = GetSysColorBrush32(COLOR_3DFACE);
212 FillRect32(hdc, &rect, hbrBk);
213
214 x = rect.left;
215 for (i = 0; i < infoPtr->uNumItem; i++) {
216 x = HEADER_DrawItem (wndPtr, hdc, i, FALSE);
217 }
218
219 if ((x <= rect.right) && (infoPtr->uNumItem > 0)) {
220 rect.left = x;
221 if (wndPtr->dwStyle & HDS_BUTTONS)
222 DrawEdge32 (hdc, &rect, EDGE_RAISED, BF_TOP|BF_LEFT|BF_BOTTOM|BF_SOFT);
223 else
224 DrawEdge32 (hdc, &rect, EDGE_ETCHED, BF_BOTTOM);
225 }
226
227 SelectObject32 (hdc, hOldFont);
228 }
229
230
231 static void
232 HEADER_RefreshItem (WND *wndPtr, HDC32 hdc, INT32 iItem)
233 {
234 HEADER_INFO *infoPtr = HEADER_GetInfoPtr(wndPtr);
235 HFONT32 hFont, hOldFont;
236
237 hFont = infoPtr->hFont ? infoPtr->hFont : GetStockObject32 (SYSTEM_FONT);
238 hOldFont = SelectObject32 (hdc, hFont);
239 HEADER_DrawItem (wndPtr, hdc, iItem, FALSE);
240 SelectObject32 (hdc, hOldFont);
241 }
242
243
244 static void
245 HEADER_SetItemBounds (WND *wndPtr)
246 {
247 HEADER_INFO *infoPtr = HEADER_GetInfoPtr(wndPtr);
248 HEADER_ITEM *phdi;
249 RECT32 rect;
250 int i, x;
251
252 if (infoPtr->uNumItem == 0)
253 return;
254
255 GetClientRect32 (wndPtr->hwndSelf, &rect);
256
257 x = rect.left;
258 for (i = 0; i < infoPtr->uNumItem; i++) {
259 phdi = &infoPtr->items[i];
260 phdi->rect.top = rect.top;
261 phdi->rect.bottom = rect.bottom;
262 phdi->rect.left = x;
263 phdi->rect.right = phdi->rect.left + phdi->cxy;
264 x = phdi->rect.right;
265 }
266 }
267
268
269 static void
270 HEADER_ForceItemBounds (WND *wndPtr, INT32 cy)
271 {
272 HEADER_INFO *infoPtr = HEADER_GetInfoPtr(wndPtr);
273 HEADER_ITEM *phdi;
274 int i, x;
275
276 if (infoPtr->uNumItem == 0)
277 return;
278
279 x = 0;
280 for (i = 0; i < infoPtr->uNumItem; i++) {
281 phdi = &infoPtr->items[i];
282 phdi->rect.top = 0;
283 phdi->rect.bottom = cy;
284 phdi->rect.left = x;
285 phdi->rect.right = phdi->rect.left + phdi->cxy;
286 x = phdi->rect.right;
287 }
288 }
289
290
291 static void
292 HEADER_InternalHitTest (WND *wndPtr, LPPOINT32 lpPt, UINT32 *pFlags, INT32 *pItem)
293 {
294 HEADER_INFO *infoPtr = HEADER_GetInfoPtr(wndPtr);
295 RECT32 rect, rcTest;
296 INT32 iCount, width;
297 BOOL32 bNoWidth;
298
299 GetClientRect32 (wndPtr->hwndSelf, &rect);
300
301 *pFlags = 0;
302 bNoWidth = FALSE;
303 if (PtInRect32 (&rect, *lpPt))
304 {
305 if (infoPtr->uNumItem == 0) {
306 *pFlags |= HHT_NOWHERE;
307 *pItem = 1;
308 TRACE (header, "NOWHERE\n");
309 return;
310 }
311 else {
312 /* somewhere inside */
313 for (iCount = 0; iCount < infoPtr->uNumItem; iCount++) {
314 rect = infoPtr->items[iCount].rect;
315 width = rect.right - rect.left;
316 if (width == 0) {
317 bNoWidth = TRUE;
318 continue;
319 }
320 if (PtInRect32 (&rect, *lpPt)) {
321 if (width <= 2 * DIVIDER_WIDTH) {
322 *pFlags |= HHT_ONHEADER;
323 *pItem = iCount;
324 TRACE (header, "ON HEADER %d\n", iCount);
325 return;
326 }
327 if (iCount > 0) {
328 rcTest = rect;
329 rcTest.right = rcTest.left + DIVIDER_WIDTH;
330 if (PtInRect32 (&rcTest, *lpPt)) {
331 if (bNoWidth) {
332 *pFlags |= HHT_ONDIVOPEN;
333 *pItem = iCount - 1;
334 TRACE (header, "ON DIVOPEN %d\n", *pItem);
335 return;
336 }
337 else {
338 *pFlags |= HHT_ONDIVIDER;
339 *pItem = iCount - 1;
340 TRACE (header, "ON DIVIDER %d\n", *pItem);
341 return;
342 }
343 }
344 }
345 rcTest = rect;
346 rcTest.left = rcTest.right - DIVIDER_WIDTH;
347 if (PtInRect32 (&rcTest, *lpPt)) {
348 *pFlags |= HHT_ONDIVIDER;
349 *pItem = iCount;
350 TRACE (header, "ON DIVIDER %d\n", *pItem);
351 return;
352 }
353
354 *pFlags |= HHT_ONHEADER;
355 *pItem = iCount;
356 TRACE (header, "ON HEADER %d\n", iCount);
357 return;
358 }
359 }
360
361 /* check for last divider part (on nowhere) */
362 rect = infoPtr->items[infoPtr->uNumItem-1].rect;
363 rect.left = rect.right;
364 rect.right += DIVIDER_WIDTH;
365 if (PtInRect32 (&rect, *lpPt)) {
366 if (bNoWidth) {
367 *pFlags |= HHT_ONDIVOPEN;
368 *pItem = infoPtr->uNumItem - 1;
369 TRACE (header, "ON DIVOPEN %d\n", *pItem);
370 return;
371 }
372 else {
373 *pFlags |= HHT_ONDIVIDER;
374 *pItem = infoPtr->uNumItem-1;
375 TRACE (header, "ON DIVIDER %d\n", *pItem);
376 return;
377 }
378 }
379
380 *pFlags |= HHT_NOWHERE;
381 *pItem = 1;
382 TRACE (header, "NOWHERE\n");
383 return;
384 }
385 }
386 else {
387 if (lpPt->x < rect.left) {
388 TRACE (header, "TO LEFT\n");
389 *pFlags |= HHT_TOLEFT;
390 }
391 else if (lpPt->x > rect.right) {
392 TRACE (header, "TO LEFT\n");
393 *pFlags |= HHT_TORIGHT;
394 }
395
396 if (lpPt->y < rect.top) {
397 TRACE (header, "ABOVE\n");
398 *pFlags |= HHT_ABOVE;
399 }
400 else if (lpPt->y > rect.bottom) {
401 TRACE (header, "BELOW\n");
402 *pFlags |= HHT_BELOW;
403 }
404 }
405
406 *pItem = 1;
407 TRACE (header, "flags=0x%X\n", *pFlags);
408 return;
409 }
410
411
412 static void
413 HEADER_DrawTrackLine (WND *wndPtr, HDC32 hdc, INT32 x)
414 {
415 RECT32 rect;
416 HPEN32 hOldPen;
417 INT32 oldRop;
418
419 GetClientRect32 (wndPtr->hwndSelf, &rect);
420
421 hOldPen = SelectObject32 (hdc, GetStockObject32 (BLACK_PEN));
422 oldRop = SetROP232 (hdc, R2_XORPEN);
423 MoveToEx32 (hdc, x, rect.top, NULL);
424 LineTo32 (hdc, x, rect.bottom);
425 SetROP232 (hdc, oldRop);
426 SelectObject32 (hdc, hOldPen);
427 }
428
429
430 static BOOL32
431 HEADER_SendSimpleNotify (WND *wndPtr, UINT32 code)
432 {
433 NMHDR nmhdr;
434
435 nmhdr.hwndFrom = wndPtr->hwndSelf;
436 nmhdr.idFrom = wndPtr->wIDmenu;
437 nmhdr.code = code;
438
439 return (BOOL32)SendMessage32A (GetParent32 (wndPtr->hwndSelf), WM_NOTIFY,
440 (WPARAM32)nmhdr.idFrom, (LPARAM)&nmhdr);
441 }
442
443
444 static BOOL32
445 HEADER_SendHeaderNotify (WND *wndPtr, UINT32 code, INT32 iItem)
446 {
447 HEADER_INFO *infoPtr = HEADER_GetInfoPtr(wndPtr);
448 NMHEADER32A nmhdr;
449 HDITEM32A nmitem;
450
451 nmhdr.hdr.hwndFrom = wndPtr->hwndSelf;
452 nmhdr.hdr.idFrom = wndPtr->wIDmenu;
453 nmhdr.hdr.code = code;
454 nmhdr.iItem = iItem;
455 nmhdr.iButton = 0;
456 nmhdr.pitem = &nmitem;
457 nmitem.mask = 0;
458 nmitem.cxy = infoPtr->items[iItem].cxy;
459 nmitem.hbm = infoPtr->items[iItem].hbm;
460 nmitem.pszText = NULL;
461 nmitem.cchTextMax = 0;
462 // nmitem.pszText = infoPtr->items[iItem].pszText;
463 // nmitem.cchTextMax = infoPtr->items[iItem].cchTextMax;
464 nmitem.fmt = infoPtr->items[iItem].fmt;
465 nmitem.lParam = infoPtr->items[iItem].lParam;
466 nmitem.iOrder = infoPtr->items[iItem].iOrder;
467 nmitem.iImage = infoPtr->items[iItem].iImage;
468
469 return (BOOL32)SendMessage32A (GetParent32 (wndPtr->hwndSelf), WM_NOTIFY,
470 (WPARAM32)wndPtr->wIDmenu, (LPARAM)&nmhdr);
471 }
472
473
474 static BOOL32
475 HEADER_SendClickNotify (WND *wndPtr, UINT32 code, INT32 iItem)
476 {
477 NMHEADER32A nmhdr;
478
479 nmhdr.hdr.hwndFrom = wndPtr->hwndSelf;
480 nmhdr.hdr.idFrom = wndPtr->wIDmenu;
481 nmhdr.hdr.code = code;
482 nmhdr.iItem = iItem;
483 nmhdr.iButton = 0;
484 nmhdr.pitem = NULL;
485
486 return (BOOL32)SendMessage32A (GetParent32 (wndPtr->hwndSelf), WM_NOTIFY,
487 (WPARAM32)wndPtr->wIDmenu, (LPARAM)&nmhdr);
488 }
489
490
491 static LRESULT
492 HEADER_CreateDragImage (WND *wndPtr, WPARAM32 wParam)
493 {
494 FIXME (header, "empty stub!\n");
495 return 0;
496 }
497
498
499 static LRESULT
500 HEADER_DeleteItem (WND *wndPtr, WPARAM32 wParam)
501 {
502 HEADER_INFO *infoPtr = HEADER_GetInfoPtr(wndPtr);
503 INT32 iItem = (INT32)wParam;
504 HDC32 hdc;
505
506 TRACE(header, "[iItem=%d]\n", iItem);
507
508 if ((iItem < 0) || (iItem >= (INT32)infoPtr->uNumItem))
509 return FALSE;
510
511 if (infoPtr->uNumItem == 1) {
512 TRACE(header, "Simple delete!\n");
513 if (infoPtr->items[0].pszText)
514 COMCTL32_Free (infoPtr->items[0].pszText);
515 COMCTL32_Free (infoPtr->items);
516 infoPtr->items = 0;
517 infoPtr->uNumItem = 0;
518 }
519 else {
520 HEADER_ITEM *oldItems = infoPtr->items;
521 TRACE(header, "Complex delete! [iItem=%d]\n", iItem);
522
523 if (infoPtr->items[iItem].pszText)
524 COMCTL32_Free (infoPtr->items[iItem].pszText);
525
526 infoPtr->uNumItem--;
527 infoPtr->items = COMCTL32_Alloc (sizeof (HEADER_ITEM) * infoPtr->uNumItem);
528 /* pre delete copy */
529 if (iItem > 0) {
530 memcpy (&infoPtr->items[0], &oldItems[0],
531 iItem * sizeof(HEADER_ITEM));
532 }
533
534 /* post delete copy */
535 if (iItem < infoPtr->uNumItem) {
536 memcpy (&infoPtr->items[iItem], &oldItems[iItem+1],
537 (infoPtr->uNumItem - iItem) * sizeof(HEADER_ITEM));
538 }
539
540 COMCTL32_Free (oldItems);
541 }
542
543 HEADER_SetItemBounds (wndPtr);
544
545 hdc = GetDC32 (wndPtr->hwndSelf);
546 HEADER_Refresh (wndPtr, hdc);
547 ReleaseDC32 (wndPtr->hwndSelf, hdc);
548
549 return TRUE;
550 }
551
552
553 static LRESULT
554 HEADER_GetImageList (WND *wndPtr)
555 {
556 HEADER_INFO *infoPtr = HEADER_GetInfoPtr(wndPtr);
557
558 return (LRESULT)infoPtr->himl;
559 }
560
561
562 static LRESULT
563 HEADER_GetItem32A (WND *wndPtr, WPARAM32 wParam, LPARAM lParam)
564 {
565 HEADER_INFO *infoPtr = HEADER_GetInfoPtr(wndPtr);
566 HDITEM32A *phdi = (HDITEM32A*)lParam;
567 INT32 nItem = (INT32)wParam;
568 HEADER_ITEM *lpItem;
569
570 if (!phdi)
571 return FALSE;
572 if ((nItem < 0) || (nItem >= (INT32)infoPtr->uNumItem))
573 return FALSE;
574
575 TRACE (header, "[nItem=%d]\n", nItem);
576
577 if (phdi->mask == 0)
578 return TRUE;
579
580 lpItem = (HEADER_ITEM*)&infoPtr->items[nItem];
581 if (phdi->mask & HDI_BITMAP)
582 phdi->hbm = lpItem->hbm;
583
584 if (phdi->mask & HDI_FORMAT)
585 phdi->fmt = lpItem->fmt;
586
587 if (phdi->mask & HDI_WIDTH)
588 phdi->cxy = lpItem->cxy;
589
590 if (phdi->mask & HDI_LPARAM)
591 phdi->lParam = lpItem->lParam;
592
593 if (phdi->mask & HDI_TEXT) {
594 if (lpItem->pszText != LPSTR_TEXTCALLBACK32A)
595 lstrcpyn32A (phdi->pszText, lpItem->pszText, phdi->cchTextMax);
596 else
597 phdi->pszText = LPSTR_TEXTCALLBACK32A;
598 }
599
600 if (phdi->mask & HDI_IMAGE)
601 phdi->iImage = lpItem->iImage;
602
603 if (phdi->mask & HDI_ORDER)
604 phdi->iOrder = lpItem->iOrder;
605
606 return TRUE;
607 }
608
609
610 static LRESULT
611 HEADER_GetItemCount (WND *wndPtr)
612 {
613 HEADER_INFO *infoPtr = HEADER_GetInfoPtr(wndPtr);
614
615 return (infoPtr->uNumItem);
616 }
617
618
619 static LRESULT
620 HEADER_GetItemRect (WND *wndPtr, WPARAM32 wParam, LPARAM lParam)
621 {
622 HEADER_INFO *infoPtr = HEADER_GetInfoPtr(wndPtr);
623 INT32 iItem = (INT32)wParam;
624 LPRECT32 lpRect = (LPRECT32)lParam;
625
626 if ((iItem < 0) || (iItem >= (INT32)infoPtr->uNumItem))
627 return FALSE;
628
629 lpRect->left = infoPtr->items[iItem].rect.left;
630 lpRect->right = infoPtr->items[iItem].rect.right;
631 lpRect->top = infoPtr->items[iItem].rect.top;
632 lpRect->bottom = infoPtr->items[iItem].rect.bottom;
633
634 return TRUE;
635 }
636
637
638 static LRESULT
639 HEADER_HitTest (WND *wndPtr, WPARAM32 wParam, LPARAM lParam)
640 {
641 LPHDHITTESTINFO phti = (LPHDHITTESTINFO)lParam;
642
643 HEADER_InternalHitTest (wndPtr, &phti->pt, &phti->flags, &phti->iItem);
644
645 return phti->flags;
646 }
647
648
649 static LRESULT
650 HEADER_InsertItem32A (WND *wndPtr, WPARAM32 wParam, LPARAM lParam)
651 {
652 HEADER_INFO *infoPtr = HEADER_GetInfoPtr(wndPtr);
653 HDITEM32A *phdi = (HDITEM32A*)lParam;
654 INT32 nItem = (INT32)wParam;
655 HEADER_ITEM *lpItem;
656 HDC32 hdc;
657 INT32 len;
658
659 if ((phdi == NULL) || (nItem < 0))
660 return -1;
661
662 if (nItem > infoPtr->uNumItem)
663 nItem = infoPtr->uNumItem;
664
665 if (infoPtr->uNumItem == 0) {
666 infoPtr->items = COMCTL32_Alloc (sizeof (HEADER_ITEM));
667 infoPtr->uNumItem++;
668 }
669 else {
670 HEADER_ITEM *oldItems = infoPtr->items;
671
672 infoPtr->uNumItem++;
673 infoPtr->items = COMCTL32_Alloc (sizeof (HEADER_ITEM) * infoPtr->uNumItem);
674 /* pre insert copy */
675 if (nItem > 0) {
676 memcpy (&infoPtr->items[0], &oldItems[0],
677 nItem * sizeof(HEADER_ITEM));
678 }
679
680 /* post insert copy */
681 if (nItem < infoPtr->uNumItem - 1) {
682 memcpy (&infoPtr->items[nItem+1], &oldItems[nItem],
683 (infoPtr->uNumItem - nItem) * sizeof(HEADER_ITEM));
684 }
685
686 COMCTL32_Free (oldItems);
687 }
688
689 lpItem = (HEADER_ITEM*)&infoPtr->items[nItem];
690 lpItem->bDown = FALSE;
691
692 if (phdi->mask & HDI_WIDTH)
693 lpItem->cxy = phdi->cxy;
694
695 if (phdi->mask & HDI_TEXT) {
696 if (phdi->pszText != LPSTR_TEXTCALLBACK32A) {
697 len = lstrlen32A (phdi->pszText);
698 lpItem->pszText = COMCTL32_Alloc (len+1);
699 lstrcpy32A (lpItem->pszText, phdi->pszText);
700 }
701 else
702 lpItem->pszText = LPSTR_TEXTCALLBACK32A;
703 }
704
705 if (phdi->mask & HDI_FORMAT)
706 lpItem->fmt = phdi->fmt;
707
708 if (phdi->mask & HDI_BITMAP)
709 lpItem->hbm = phdi->hbm;
710
711 if (phdi->mask & HDI_LPARAM)
712 lpItem->lParam = phdi->lParam;
713
714 if (phdi->mask & HDI_IMAGE)
715 lpItem->iImage = phdi->iImage;
716
717 if (phdi->mask & HDI_ORDER)
718 lpItem->iOrder = phdi->iOrder;
719
720 HEADER_SetItemBounds (wndPtr);
721
722 hdc = GetDC32 (wndPtr->hwndSelf);
723 HEADER_Refresh (wndPtr, hdc);
724 ReleaseDC32 (wndPtr->hwndSelf, hdc);
725
726 return nItem;
727 }
728
729
730 static LRESULT
731 HEADER_Layout (WND *wndPtr, WPARAM32 wParam, LPARAM lParam)
732 {
733 HEADER_INFO *infoPtr = HEADER_GetInfoPtr(wndPtr);
734 LPHDLAYOUT lpLayout = (LPHDLAYOUT)lParam;
735
736 lpLayout->pwpos->hwnd = wndPtr->hwndSelf;
737 lpLayout->pwpos->hwndInsertAfter = 0;
738 lpLayout->pwpos->x = lpLayout->prc->left;
739 lpLayout->pwpos->y = lpLayout->prc->top;
740 lpLayout->pwpos->cx = lpLayout->prc->right - lpLayout->prc->left;
741 if (wndPtr->dwStyle & HDS_HIDDEN)
742 lpLayout->pwpos->cy = 0;
743 else
744 lpLayout->pwpos->cy = infoPtr->nHeight;
745 lpLayout->pwpos->flags = SWP_NOZORDER;
746
747 TRACE (header, "Layout x=%d y=%d cx=%d cy=%d\n",
748 lpLayout->pwpos->x, lpLayout->pwpos->y,
749 lpLayout->pwpos->cx, lpLayout->pwpos->cy);
750
751 HEADER_ForceItemBounds (wndPtr, lpLayout->pwpos->cy);
752
753 /* hack */
754 #ifdef __HDM_LAYOUT_HACK__
755 MoveWindow32 (lpLayout->pwpos->hwnd, lpLayout->pwpos->x, lpLayout->pwpos->y,
756 lpLayout->pwpos->cx, lpLayout->pwpos->cy, TRUE);
757 #endif
758
759 return TRUE;
760 }
761
762
763 static LRESULT
764 HEADER_SetImageList (WND *wndPtr, WPARAM32 wParam, LPARAM lParam)
765 {
766 HEADER_INFO *infoPtr = HEADER_GetInfoPtr(wndPtr);
767 HIMAGELIST himlOld;
768
769 himlOld = infoPtr->himl;
770 infoPtr->himl = (HIMAGELIST)lParam;
771
772 /* FIXME: Refresh needed??? */
773
774 return (LRESULT)himlOld;
775 }
776
777
778 static LRESULT
779 HEADER_SetItem32A (WND *wndPtr, WPARAM32 wParam, LPARAM lParam)
780 {
781 HEADER_INFO *infoPtr = HEADER_GetInfoPtr(wndPtr);
782 HDITEM32A *phdi = (HDITEM32A*)lParam;
783 INT32 nItem = (INT32)wParam;
784 HEADER_ITEM *lpItem;
785 HDC32 hdc;
786
787 if (phdi == NULL)
788 return FALSE;
789 if ((nItem < 0) || (nItem >= (INT32)infoPtr->uNumItem))
790 return FALSE;
791
792 TRACE (header, "[nItem=%d]\n", nItem);
793
794 if (HEADER_SendHeaderNotify (wndPtr, HDN_ITEMCHANGING32A, nItem))
795 return FALSE;
796
797 lpItem = (HEADER_ITEM*)&infoPtr->items[nItem];
798 if (phdi->mask & HDI_BITMAP)
799 lpItem->hbm = phdi->hbm;
800
801 if (phdi->mask & HDI_FORMAT)
802 lpItem->fmt = phdi->fmt;
803
804 if (phdi->mask & HDI_LPARAM)
805 lpItem->lParam = phdi->lParam;
806
807 if (phdi->mask & HDI_TEXT) {
808 if (phdi->pszText != LPSTR_TEXTCALLBACK32A) {
809 INT32 len = lstrlen32A (phdi->pszText);
810 if (lpItem->pszText)
811 COMCTL32_Free (lpItem->pszText);
812 lpItem->pszText = COMCTL32_Alloc (len+1);
813 lstrcpy32A (lpItem->pszText, phdi->pszText);
814 }
815 else
816 lpItem->pszText = LPSTR_TEXTCALLBACK32A;
817 }
818
819 if (phdi->mask & HDI_WIDTH)
820 lpItem->cxy = phdi->cxy;
821
822 if (phdi->mask & HDI_IMAGE)
823 lpItem->iImage = phdi->iImage;
824
825 if (phdi->mask & HDI_ORDER)
826 lpItem->iOrder = phdi->iOrder;
827
828 HEADER_SendHeaderNotify (wndPtr, HDN_ITEMCHANGED32A, nItem);
829
830 HEADER_SetItemBounds (wndPtr);
831 hdc = GetDC32 (wndPtr->hwndSelf);
832 HEADER_Refresh (wndPtr, hdc);
833 ReleaseDC32 (wndPtr->hwndSelf, hdc);
834
835 return TRUE;
836 }
837
838
839 static LRESULT
840 HEADER_Create (WND *wndPtr, WPARAM32 wParam, LPARAM lParam)
841 {
842 HEADER_INFO *infoPtr;
843 TEXTMETRIC32A tm;
844 HFONT32 hOldFont;
845 HDC32 hdc;
846
847 infoPtr = (HEADER_INFO *)COMCTL32_Alloc (sizeof(HEADER_INFO));
848 wndPtr->wExtra[0] = (DWORD)infoPtr;
849
850 infoPtr->uNumItem = 0;
851 infoPtr->nHeight = 20;
852 infoPtr->hFont = 0;
853 infoPtr->items = 0;
854 infoPtr->hcurArrow = LoadCursor32A (0, IDC_ARROW32A);
855 infoPtr->hcurDivider = LoadCursor32A (0, IDC_SIZEWE32A);
856 infoPtr->hcurDivopen = LoadCursor32A (0, IDC_SIZENS32A);
857 infoPtr->bPressed = FALSE;
858 infoPtr->bTracking = FALSE;
859 infoPtr->iMoveItem = 0;
860 infoPtr->himl = 0;
861 infoPtr->iHotItem = -1;
862
863 hdc = GetDC32 (0);
864 hOldFont = SelectObject32 (hdc, GetStockObject32 (SYSTEM_FONT));
865 GetTextMetrics32A (hdc, &tm);
866 infoPtr->nHeight = tm.tmHeight + VERT_BORDER;
867 SelectObject32 (hdc, hOldFont);
868 ReleaseDC32 (0, hdc);
869
870 return 0;
871 }
872
873
874 static LRESULT
875 HEADER_Destroy (WND *wndPtr, WPARAM32 wParam, LPARAM lParam)
876 {
877 HEADER_INFO *infoPtr = HEADER_GetInfoPtr(wndPtr);
878 HEADER_ITEM *lpItem;
879 INT32 nItem;
880
881 if (infoPtr->items) {
882 lpItem = (HEADER_ITEM*)infoPtr->items;
883 for (nItem = 0; nItem < infoPtr->uNumItem; nItem++, lpItem++) {
884 if ((lpItem->pszText) && (lpItem->pszText != LPSTR_TEXTCALLBACK32A))
885 COMCTL32_Free (lpItem->pszText);
886 }
887 COMCTL32_Free (infoPtr->items);
888 }
889
890 if (infoPtr->himl)
891 ImageList_Destroy (infoPtr->himl);
892
893 COMCTL32_Free (infoPtr);
894
895 return 0;
896 }
897
898
899 static __inline__ LRESULT
900 HEADER_GetFont (WND *wndPtr)
901 {
902 HEADER_INFO *infoPtr = HEADER_GetInfoPtr(wndPtr);
903
904 return (LRESULT)infoPtr->hFont;
905 }
906
907
908 static LRESULT
909 HEADER_LButtonDblClk (WND *wndPtr, WPARAM32 wParam, LPARAM lParam)
910 {
911 POINT32 pt;
912 UINT32 flags;
913 INT32 nItem;
914
915 pt.x = (INT32)LOWORD(lParam);
916 pt.y = (INT32)HIWORD(lParam);
917 HEADER_InternalHitTest (wndPtr, &pt, &flags, &nItem);
918
919 if ((wndPtr->dwStyle & HDS_BUTTONS) && (flags == HHT_ONHEADER))
920 HEADER_SendHeaderNotify (wndPtr, HDN_ITEMDBLCLICK32A, nItem);
921 else if ((flags == HHT_ONDIVIDER) || (flags == HHT_ONDIVOPEN))
922 HEADER_SendHeaderNotify (wndPtr, HDN_DIVIDERDBLCLICK32A, nItem);
923
924 return 0;
925 }
926
927
928 static LRESULT
929 HEADER_LButtonDown (WND *wndPtr, WPARAM32 wParam, LPARAM lParam)
930 {
931 HEADER_INFO *infoPtr = HEADER_GetInfoPtr(wndPtr);
932 POINT32 pt;
933 UINT32 flags;
934 INT32 nItem;
935 HDC32 hdc;
936
937 pt.x = (INT32)LOWORD(lParam);
938 pt.y = (INT32)HIWORD(lParam);
939 HEADER_InternalHitTest (wndPtr, &pt, &flags, &nItem);
940
941 if ((wndPtr->dwStyle & HDS_BUTTONS) && (flags == HHT_ONHEADER)) {
942 SetCapture32 (wndPtr->hwndSelf);
943 infoPtr->bCaptured = TRUE;
944 infoPtr->bPressed = TRUE;
945 infoPtr->iMoveItem = nItem;
946
947 infoPtr->items[nItem].bDown = TRUE;
948
949 /* Send WM_CUSTOMDRAW */
950 hdc = GetDC32 (wndPtr->hwndSelf);
951 HEADER_RefreshItem (wndPtr, hdc, nItem);
952 ReleaseDC32 (wndPtr->hwndSelf, hdc);
953
954 TRACE (header, "Pressed item %d!\n", nItem);
955 }
956 else if ((flags == HHT_ONDIVIDER) || (flags == HHT_ONDIVOPEN)) {
957 if (!(HEADER_SendHeaderNotify (wndPtr, HDN_BEGINTRACK32A, nItem))) {
958 SetCapture32 (wndPtr->hwndSelf);
959 infoPtr->bCaptured = TRUE;
960 infoPtr->bTracking = TRUE;
961 infoPtr->iMoveItem = nItem;
962 infoPtr->nOldWidth = infoPtr->items[nItem].cxy;
963 infoPtr->xTrackOffset = infoPtr->items[nItem].rect.right - pt.x;
964
965 if (!(wndPtr->dwStyle & HDS_FULLDRAG)) {
966 infoPtr->xOldTrack = infoPtr->items[nItem].rect.right;
967 hdc = GetDC32 (wndPtr->hwndSelf);
968 HEADER_DrawTrackLine (wndPtr, hdc, infoPtr->xOldTrack);
969 ReleaseDC32 (wndPtr->hwndSelf, hdc);
970 }
971
972 TRACE (header, "Begin tracking item %d!\n", nItem);
973 }
974 }
975
976 return 0;
977 }
978
979
980 static LRESULT
981 HEADER_LButtonUp (WND *wndPtr, WPARAM32 wParam, LPARAM lParam)
982 {
983 HEADER_INFO *infoPtr = HEADER_GetInfoPtr(wndPtr);
984 POINT32 pt;
985 UINT32 flags;
986 INT32 nItem, nWidth;
987 HDC32 hdc;
988
989 pt.x = (INT32)LOWORD(lParam);
990 pt.y = (INT32)HIWORD(lParam);
991 HEADER_InternalHitTest (wndPtr, &pt, &flags, &nItem);
992
993 if (infoPtr->bPressed) {
994 if ((nItem == infoPtr->iMoveItem) && (flags == HHT_ONHEADER)) {
995 infoPtr->items[infoPtr->iMoveItem].bDown = FALSE;
996 hdc = GetDC32 (wndPtr->hwndSelf);
997 HEADER_RefreshItem (wndPtr, hdc, infoPtr->iMoveItem);
998 ReleaseDC32 (wndPtr->hwndSelf, hdc);
999
1000 HEADER_SendClickNotify (wndPtr, HDN_ITEMCLICK32A, infoPtr->iMoveItem);
1001 }
1002 TRACE (header, "Released item %d!\n", infoPtr->iMoveItem);
1003 infoPtr->bPressed = FALSE;
1004 }
1005 else if (infoPtr->bTracking) {
1006 TRACE (header, "End tracking item %d!\n", infoPtr->iMoveItem);
1007 infoPtr->bTracking = FALSE;
1008
1009 HEADER_SendHeaderNotify (wndPtr, HDN_ENDTRACK32A, infoPtr->iMoveItem);
1010
1011 if (!(wndPtr->dwStyle & HDS_FULLDRAG)) {
1012 hdc = GetDC32 (wndPtr->hwndSelf);
1013 HEADER_DrawTrackLine (wndPtr, hdc, infoPtr->xOldTrack);
1014 ReleaseDC32 (wndPtr->hwndSelf, hdc);
1015 if (HEADER_SendHeaderNotify (wndPtr, HDN_ITEMCHANGING32A, infoPtr->iMoveItem))
1016 infoPtr->items[infoPtr->iMoveItem].cxy = infoPtr->nOldWidth;
1017 else {
1018 nWidth = pt.x - infoPtr->items[infoPtr->iMoveItem].rect.left + infoPtr->xTrackOffset;
1019 if (nWidth < 0)
1020 nWidth = 0;
1021 infoPtr->items[infoPtr->iMoveItem].cxy = nWidth;
1022 HEADER_SendHeaderNotify (wndPtr, HDN_ITEMCHANGED32A, infoPtr->iMoveItem);
1023 }
1024
1025 HEADER_SetItemBounds (wndPtr);
1026 hdc = GetDC32 (wndPtr->hwndSelf);
1027 HEADER_Refresh (wndPtr, hdc);
1028 ReleaseDC32 (wndPtr->hwndSelf, hdc);
1029 }
1030 }
1031
1032 if (infoPtr->bCaptured) {
1033 infoPtr->bCaptured = FALSE;
1034 ReleaseCapture ();
1035 HEADER_SendSimpleNotify (wndPtr, NM_RELEASEDCAPTURE);
1036 }
1037
1038 return 0;
1039 }
1040
1041
1042 static LRESULT
1043 HEADER_MouseMove (WND *wndPtr, WPARAM32 wParam, LPARAM lParam)
1044 {
1045 HEADER_INFO *infoPtr = HEADER_GetInfoPtr(wndPtr);
1046 POINT32 pt;
1047 UINT32 flags;
1048 INT32 nItem, nWidth;
1049 HDC32 hdc;
1050
1051 pt.x = (INT32)LOWORD(lParam);
1052 pt.y = (INT32)HIWORD(lParam);
1053 HEADER_InternalHitTest (wndPtr, &pt, &flags, &nItem);
1054
1055 if ((wndPtr->dwStyle & HDS_BUTTONS) && (wndPtr->dwStyle & HDS_HOTTRACK)) {
1056 if (flags & (HHT_ONHEADER | HHT_ONDIVIDER | HHT_ONDIVOPEN))
1057 infoPtr->iHotItem = nItem;
1058 else
1059 infoPtr->iHotItem = -1;
1060 hdc = GetDC32 (wndPtr->hwndSelf);
1061 HEADER_Refresh (wndPtr, hdc);
1062 ReleaseDC32 (wndPtr->hwndSelf, hdc);
1063 }
1064
1065 if (infoPtr->bCaptured) {
1066 if (infoPtr->bPressed) {
1067 if ((nItem == infoPtr->iMoveItem) && (flags == HHT_ONHEADER))
1068 infoPtr->items[infoPtr->iMoveItem].bDown = TRUE;
1069 else
1070 infoPtr->items[infoPtr->iMoveItem].bDown = FALSE;
1071 hdc = GetDC32 (wndPtr->hwndSelf);
1072 HEADER_RefreshItem (wndPtr, hdc, infoPtr->iMoveItem);
1073 ReleaseDC32 (wndPtr->hwndSelf, hdc);
1074
1075 TRACE (header, "Moving pressed item %d!\n", infoPtr->iMoveItem);
1076 }
1077 else if (infoPtr->bTracking) {
1078 if (wndPtr->dwStyle & HDS_FULLDRAG) {
1079 if (HEADER_SendHeaderNotify (wndPtr, HDN_ITEMCHANGING32A, infoPtr->iMoveItem))
1080 infoPtr->items[infoPtr->iMoveItem].cxy = infoPtr->nOldWidth;
1081 else {
1082 nWidth = pt.x - infoPtr->items[infoPtr->iMoveItem].rect.left + infoPtr->xTrackOffset;
1083 if (nWidth < 0)
1084 nWidth = 0;
1085 infoPtr->items[infoPtr->iMoveItem].cxy = nWidth;
1086 HEADER_SendHeaderNotify (wndPtr, HDN_ITEMCHANGED32A,
1087 infoPtr->iMoveItem);
1088 }
1089 HEADER_SetItemBounds (wndPtr);
1090 hdc = GetDC32 (wndPtr->hwndSelf);
1091 HEADER_Refresh (wndPtr, hdc);
1092 ReleaseDC32 (wndPtr->hwndSelf, hdc);
1093 }
1094 else {
1095 hdc = GetDC32 (wndPtr->hwndSelf);
1096 HEADER_DrawTrackLine (wndPtr, hdc, infoPtr->xOldTrack);
1097 infoPtr->xOldTrack = pt.x + infoPtr->xTrackOffset;
1098 if (infoPtr->xOldTrack < infoPtr->items[infoPtr->iMoveItem].rect.left)
1099 infoPtr->xOldTrack = infoPtr->items[infoPtr->iMoveItem].rect.left;
1100 infoPtr->items[infoPtr->iMoveItem].cxy =
1101 infoPtr->xOldTrack - infoPtr->items[infoPtr->iMoveItem].rect.left;
1102 HEADER_DrawTrackLine (wndPtr, hdc, infoPtr->xOldTrack);
1103 ReleaseDC32 (wndPtr->hwndSelf, hdc);
1104 }
1105
1106 HEADER_SendHeaderNotify (wndPtr, HDN_TRACK32A, infoPtr->iMoveItem);
1107 TRACE (header, "Tracking item %d!\n", infoPtr->iMoveItem);
1108 }
1109 }
1110
1111 if ((wndPtr->dwStyle & HDS_BUTTONS) && (wndPtr->dwStyle & HDS_HOTTRACK)) {
1112 FIXME (header, "hot track support!\n");
1113 }
1114
1115 return 0;
1116 }
1117
1118
1119 static LRESULT
1120 HEADER_Paint (WND *wndPtr, WPARAM32 wParam)
1121 {
1122 HDC32 hdc;
1123 PAINTSTRUCT32 ps;
1124
1125 hdc = wParam==0 ? BeginPaint32 (wndPtr->hwndSelf, &ps) : (HDC32)wParam;
1126 HEADER_Refresh (wndPtr, hdc);
1127 if(!wParam)
1128 EndPaint32 (wndPtr->hwndSelf, &ps);
1129 return 0;
1130 }
1131
1132
1133 static LRESULT
1134 HEADER_RButtonUp (WND *wndPtr, WPARAM32 wParam, LPARAM lParam)
1135 {
1136 return HEADER_SendSimpleNotify (wndPtr, NM_RCLICK);
1137 }
1138
1139
1140 static LRESULT
1141 HEADER_SetCursor (WND *wndPtr, WPARAM32 wParam, LPARAM lParam)
1142 {
1143 HEADER_INFO *infoPtr = HEADER_GetInfoPtr(wndPtr);
1144 POINT32 pt;
1145 UINT32 flags;
1146 INT32 nItem;
1147
1148 TRACE (header, "code=0x%X id=0x%X\n", LOWORD(lParam), HIWORD(lParam));
1149
1150 GetCursorPos32 (&pt);
1151 ScreenToClient32 (wndPtr->hwndSelf, &pt);
1152
1153 HEADER_InternalHitTest (wndPtr, &pt, &flags, &nItem);
1154
1155 if (flags == HHT_ONDIVIDER)
1156 SetCursor32 (infoPtr->hcurDivider);
1157 else if (flags == HHT_ONDIVOPEN)
1158 SetCursor32 (infoPtr->hcurDivopen);
1159 else
1160 SetCursor32 (infoPtr->hcurArrow);
1161
1162 return 0;
1163 }
1164
1165
1166 static LRESULT
1167 HEADER_SetFont (WND *wndPtr, WPARAM32 wParam, LPARAM lParam)
1168 {
1169 HEADER_INFO *infoPtr = HEADER_GetInfoPtr(wndPtr);
1170 TEXTMETRIC32A tm;
1171 HFONT32 hFont, hOldFont;
1172 HDC32 hdc;
1173
1174 infoPtr->hFont = (HFONT32)wParam;
1175
1176 hFont = infoPtr->hFont ? infoPtr->hFont : GetStockObject32 (SYSTEM_FONT);
1177
1178 hdc = GetDC32 (0);
1179 hOldFont = SelectObject32 (hdc, hFont);
1180 GetTextMetrics32A (hdc, &tm);
1181 infoPtr->nHeight = tm.tmHeight + VERT_BORDER;
1182 SelectObject32 (hdc, hOldFont);
1183 ReleaseDC32 (0, hdc);
1184
1185 if (lParam) {
1186 HEADER_ForceItemBounds (wndPtr, infoPtr->nHeight);
1187 hdc = GetDC32 (wndPtr->hwndSelf);
1188 HEADER_Refresh (wndPtr, hdc);
1189 ReleaseDC32 (wndPtr->hwndSelf, hdc);
1190 }
1191
1192 return 0;
1193 }
1194
1195
1196 LRESULT WINAPI
1197 HEADER_WindowProc (HWND32 hwnd, UINT32 msg, WPARAM32 wParam, LPARAM lParam)
1198 {
1199 WND *wndPtr = WIN_FindWndPtr(hwnd);
1200
1201 switch (msg) {
1202 case HDM_CREATEDRAGIMAGE:
1203 return HEADER_CreateDragImage (wndPtr, wParam);
1204
1205 case HDM_DELETEITEM:
1206 return HEADER_DeleteItem (wndPtr, wParam);
1207
1208 case HDM_GETIMAGELIST:
1209 return HEADER_GetImageList (wndPtr);
1210
1211 case HDM_GETITEM32A:
1212 return HEADER_GetItem32A (wndPtr, wParam, lParam);
1213
1214 // case HDM_GETITEM32W:
1215
1216 case HDM_GETITEMCOUNT:
1217 return HEADER_GetItemCount (wndPtr);
1218
1219 case HDM_GETITEMRECT:
1220 return HEADER_GetItemRect (wndPtr, wParam, lParam);
1221
1222 // case HDM_GETORDERARRAY:
1223 // case HDM_GETUNICODEFORMAT:
1224
1225 case HDM_HITTEST:
1226 return HEADER_HitTest (wndPtr, wParam, lParam);
1227
1228 case HDM_INSERTITEM32A:
1229 return HEADER_InsertItem32A (wndPtr, wParam, lParam);
1230
1231 // case HDM_INSERTITEM32W:
1232
1233 case HDM_LAYOUT:
1234 return HEADER_Layout (wndPtr, wParam, lParam);
1235
1236 case HDM_SETIMAGELIST:
1237 return HEADER_SetImageList (wndPtr, wParam, lParam);
1238
1239 case HDM_SETITEM32A:
1240 return HEADER_SetItem32A (wndPtr, wParam, lParam);
1241
1242 // case HDM_SETITEM32W:
1243 // case HDM_SETORDERARRAY:
1244 // case HDM_SETUNICODEFORMAT:
1245
1246
1247 case WM_CREATE:
1248 return HEADER_Create (wndPtr, wParam, lParam);
1249
1250 case WM_DESTROY:
1251 return HEADER_Destroy (wndPtr, wParam, lParam);
1252
1253 case WM_ERASEBKGND:
1254 return 1;
1255
1256 case WM_GETDLGCODE:
1257 return DLGC_WANTTAB | DLGC_WANTARROWS;
1258
1259 case WM_GETFONT:
1260 return HEADER_GetFont (wndPtr);
1261
1262 case WM_LBUTTONDBLCLK:
1263 return HEADER_LButtonDblClk (wndPtr, wParam, lParam);
1264
1265 case WM_LBUTTONDOWN:
1266 return HEADER_LButtonDown (wndPtr, wParam, lParam);
1267
1268 case WM_LBUTTONUP:
1269 return HEADER_LButtonUp (wndPtr, wParam, lParam);
1270
1271 case WM_MOUSEMOVE:
1272 return HEADER_MouseMove (wndPtr, wParam, lParam);
1273
1274 case WM_PAINT:
1275 return HEADER_Paint (wndPtr, wParam);
1276
1277 case WM_RBUTTONUP:
1278 return HEADER_RButtonUp (wndPtr, wParam, lParam);
1279
1280 case WM_SETCURSOR:
1281 return HEADER_SetCursor (wndPtr, wParam, lParam);
1282
1283 case WM_SETFONT:
1284 return HEADER_SetFont (wndPtr, wParam, lParam);
1285
1286 default:
1287 if (msg >= WM_USER)
1288 ERR (header, "unknown msg %04x wp=%04x lp=%08lx\n",
1289 msg, wParam, lParam );
1290 return DefWindowProc32A (hwnd, msg, wParam, lParam);
1291 }
1292 return 0;
1293 }
1294
1295
1296 void HEADER_Register( void )
1297 {
1298 WNDCLASS32A wndClass;
1299
1300 if (GlobalFindAtom32A (WC_HEADER32A)) return;
1301
1302 ZeroMemory (&wndClass, sizeof(WNDCLASS32A));
1303 wndClass.style = CS_GLOBALCLASS | CS_DBLCLKS;
1304 wndClass.lpfnWndProc = (WNDPROC32)HEADER_WindowProc;
1305 wndClass.cbClsExtra = 0;
1306 wndClass.cbWndExtra = sizeof(HEADER_INFO *);
1307 wndClass.hCursor = LoadCursor32A (0, IDC_ARROW32A);
1308 wndClass.lpszClassName = WC_HEADER32A;
1309
1310 RegisterClass32A (&wndClass);
1311 }
1312
Windows API implementation