?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Let Int09 routines remember a keystroke's ASCII code, if available.
[wine/multimedia.git] / dlls / comctl32 / header.c
blobe83add61eab60ad9acbebf25e617214fa9c8aa4c
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 <string.h>
23
24 #include "winbase.h"
25 #include "commctrl.h"
26 #include "header.h"
27 #include "debugtools.h"
28
29 DEFAULT_DEBUG_CHANNEL(header)
30
31
32 #define VERT_BORDER 4
33 #define DIVIDER_WIDTH 10
34
35 #define HEADER_GetInfoPtr(hwnd) ((HEADER_INFO *)GetWindowLongA(hwnd,0))
36
37
38 static void
39 HEADER_SetItemBounds (HWND hwnd)
40 {
41 HEADER_INFO *infoPtr = HEADER_GetInfoPtr (hwnd);
42 HEADER_ITEM *phdi;
43 RECT rect;
44 int i, x;
45
46 infoPtr->bRectsValid = TRUE;
47
48 if (infoPtr->uNumItem == 0)
49 return;
50
51 GetClientRect (hwnd, &rect);
52
53 x = rect.left;
54 for (i = 0; i < infoPtr->uNumItem; i++) {
55 phdi = &infoPtr->items[i];
56 phdi->rect.top = rect.top;
57 phdi->rect.bottom = rect.bottom;
58 phdi->rect.left = x;
59 phdi->rect.right = phdi->rect.left + phdi->cxy;
60 x = phdi->rect.right;
61 }
62 }
63
64 static LRESULT
65 HEADER_Size (HWND hwnd, WPARAM wParam)
66 {
67 HEADER_INFO *infoPtr = HEADER_GetInfoPtr (hwnd);
68
69 infoPtr->bRectsValid = FALSE;
70
71 return 0;
72 }
73
74
75 static INT
76 HEADER_DrawItem (HWND hwnd, HDC hdc, INT iItem, BOOL bHotTrack)
77 {
78 HEADER_INFO *infoPtr = HEADER_GetInfoPtr (hwnd);
79 HEADER_ITEM *phdi = &infoPtr->items[iItem];
80 RECT r;
81 INT oldBkMode;
82
83 if (!infoPtr->bRectsValid)
84 HEADER_SetItemBounds(hwnd);
85
86 r = phdi->rect;
87 if (r.right - r.left == 0)
88 return phdi->rect.right;
89
90 if (GetWindowLongA (hwnd, GWL_STYLE) & HDS_BUTTONS) {
91 if (phdi->bDown) {
92 DrawEdge (hdc, &r, BDR_RAISEDOUTER,
93 BF_RECT | BF_FLAT | BF_MIDDLE | BF_ADJUST);
94 r.left += 2;
95 r.top += 2;
96 }
97 else
98 DrawEdge (hdc, &r, EDGE_RAISED,
99 BF_RECT | BF_SOFT | BF_MIDDLE | BF_ADJUST);
100 }
101 else
102 DrawEdge (hdc, &r, EDGE_ETCHED, BF_BOTTOM | BF_RIGHT | BF_ADJUST);
103
104 if (phdi->fmt & HDF_OWNERDRAW) {
105 DRAWITEMSTRUCT dis;
106 dis.CtlType = ODT_HEADER;
107 dis.CtlID = GetWindowLongA (hwnd, GWL_ID);
108 dis.itemID = iItem;
109 dis.itemAction = ODA_DRAWENTIRE;
110 dis.itemState = phdi->bDown ? ODS_SELECTED : 0;
111 dis.hwndItem = hwnd;
112 dis.hDC = hdc;
113 dis.rcItem = r;
114 dis.itemData = phdi->lParam;
115 SendMessageA (GetParent (hwnd), WM_DRAWITEM,
116 (WPARAM)dis.CtlID, (LPARAM)&dis);
117 }
118 else {
119 UINT uTextJustify = DT_LEFT;
120
121 if ((phdi->fmt & HDF_JUSTIFYMASK) == HDF_CENTER)
122 uTextJustify = DT_CENTER;
123 else if ((phdi->fmt & HDF_JUSTIFYMASK) == HDF_RIGHT)
124 uTextJustify = DT_RIGHT;
125
126 if ((phdi->fmt & HDF_BITMAP) && (phdi->hbm)) {
127 BITMAP bmp;
128 HDC hdcBitmap;
129 INT yD, yS, cx, cy, rx, ry;
130
131 GetObjectA (phdi->hbm, sizeof(BITMAP), (LPVOID)&bmp);
132
133 ry = r.bottom - r.top;
134 rx = r.right - r.left;
135
136 if (ry >= bmp.bmHeight) {
137 cy = bmp.bmHeight;
138 yD = r.top + (ry - bmp.bmHeight) / 2;
139 yS = 0;
140 }
141 else {
142 cy = ry;
143 yD = r.top;
144 yS = (bmp.bmHeight - ry) / 2;
145
146 }
147
148 if (rx >= bmp.bmWidth + 6) {
149 cx = bmp.bmWidth;
150 }
151 else {
152 cx = rx - 6;
153 }
154
155 hdcBitmap = CreateCompatibleDC (hdc);
156 SelectObject (hdcBitmap, phdi->hbm);
157 BitBlt (hdc, r.left + 3, yD, cx, cy, hdcBitmap, 0, yS, SRCCOPY);
158 DeleteDC (hdcBitmap);
159
160 r.left += (bmp.bmWidth + 3);
161 }
162
163
164 if ((phdi->fmt & HDF_BITMAP_ON_RIGHT) && (phdi->hbm)) {
165 BITMAP bmp;
166 HDC hdcBitmap;
167 INT xD, yD, yS, cx, cy, rx, ry, tx;
168 RECT textRect;
169
170 GetObjectA (phdi->hbm, sizeof(BITMAP), (LPVOID)&bmp);
171
172 textRect = r;
173 DrawTextW (hdc, phdi->pszText, lstrlenW (phdi->pszText),
174 &textRect, DT_LEFT|DT_VCENTER|DT_SINGLELINE|DT_CALCRECT);
175 tx = textRect.right - textRect.left;
176 ry = r.bottom - r.top;
177 rx = r.right - r.left;
178
179 if (ry >= bmp.bmHeight) {
180 cy = bmp.bmHeight;
181 yD = r.top + (ry - bmp.bmHeight) / 2;
182 yS = 0;
183 }
184 else {
185 cy = ry;
186 yD = r.top;
187 yS = (bmp.bmHeight - ry) / 2;
188
189 }
190
191 if (r.left + tx + bmp.bmWidth + 9 <= r.right) {
192 cx = bmp.bmWidth;
193 xD = r.left + tx + 6;
194 }
195 else {
196 if (rx >= bmp.bmWidth + 6) {
197 cx = bmp.bmWidth;
198 xD = r.right - bmp.bmWidth - 3;
199 r.right = xD - 3;
200 }
201 else {
202 cx = rx - 3;
203 xD = r.left;
204 r.right = r.left;
205 }
206 }
207
208 hdcBitmap = CreateCompatibleDC (hdc);
209 SelectObject (hdcBitmap, phdi->hbm);
210 BitBlt (hdc, xD, yD, cx, cy, hdcBitmap, 0, yS, SRCCOPY);
211 DeleteDC (hdcBitmap);
212 }
213
214 if (phdi->fmt & HDF_IMAGE) {
215
216
217 /* ImageList_Draw (infoPtr->himl, phdi->iImage,...); */
218 }
219
220 if (((phdi->fmt & HDF_STRING)
221 || (!(phdi->fmt & (HDF_OWNERDRAW|HDF_STRING|HDF_BITMAP|
222 HDF_BITMAP_ON_RIGHT|HDF_IMAGE)))) /* no explicit format specified? */
223 && (phdi->pszText)) {
224 oldBkMode = SetBkMode(hdc, TRANSPARENT);
225 r.left += 3;
226 r.right -= 3;
227 SetTextColor (hdc, bHotTrack ? COLOR_HIGHLIGHT : COLOR_BTNTEXT);
228 DrawTextW (hdc, phdi->pszText, lstrlenW (phdi->pszText),
229 &r, uTextJustify|DT_VCENTER|DT_SINGLELINE);
230 if (oldBkMode != TRANSPARENT)
231 SetBkMode(hdc, oldBkMode);
232 }
233 }
234
235 return phdi->rect.right;
236 }
237
238
239 static void
240 HEADER_Refresh (HWND hwnd, HDC hdc)
241 {
242 HEADER_INFO *infoPtr = HEADER_GetInfoPtr (hwnd);
243 HFONT hFont, hOldFont;
244 RECT rect;
245 HBRUSH hbrBk;
246 INT i, x;
247
248 /* get rect for the bar, adjusted for the border */
249 GetClientRect (hwnd, &rect);
250
251 hFont = infoPtr->hFont ? infoPtr->hFont : GetStockObject (SYSTEM_FONT);
252 hOldFont = SelectObject (hdc, hFont);
253
254 /* draw Background */
255 hbrBk = GetSysColorBrush(COLOR_3DFACE);
256 FillRect(hdc, &rect, hbrBk);
257
258 x = rect.left;
259 for (i = 0; i < infoPtr->uNumItem; i++) {
260 x = HEADER_DrawItem (hwnd, hdc, i, FALSE);
261 }
262
263 if ((x <= rect.right) && (infoPtr->uNumItem > 0)) {
264 rect.left = x;
265 if (GetWindowLongA (hwnd, GWL_STYLE) & HDS_BUTTONS)
266 DrawEdge (hdc, &rect, EDGE_RAISED, BF_TOP|BF_LEFT|BF_BOTTOM|BF_SOFT);
267 else
268 DrawEdge (hdc, &rect, EDGE_ETCHED, BF_BOTTOM);
269 }
270
271 SelectObject (hdc, hOldFont);
272 }
273
274
275 static void
276 HEADER_RefreshItem (HWND hwnd, HDC hdc, INT iItem)
277 {
278 HEADER_INFO *infoPtr = HEADER_GetInfoPtr (hwnd);
279 HFONT hFont, hOldFont;
280
281 hFont = infoPtr->hFont ? infoPtr->hFont : GetStockObject (SYSTEM_FONT);
282 hOldFont = SelectObject (hdc, hFont);
283 HEADER_DrawItem (hwnd, hdc, iItem, FALSE);
284 SelectObject (hdc, hOldFont);
285 }
286
287
288 static void
289 HEADER_InternalHitTest (HWND hwnd, LPPOINT lpPt, UINT *pFlags, INT *pItem)
290 {
291 HEADER_INFO *infoPtr = HEADER_GetInfoPtr (hwnd);
292 RECT rect, rcTest;
293 INT iCount, width;
294 BOOL bNoWidth;
295
296 GetClientRect (hwnd, &rect);
297
298 *pFlags = 0;
299 bNoWidth = FALSE;
300 if (PtInRect (&rect, *lpPt))
301 {
302 if (infoPtr->uNumItem == 0) {
303 *pFlags |= HHT_NOWHERE;
304 *pItem = 1;
305 TRACE("NOWHERE\n");
306 return;
307 }
308 else {
309 /* somewhere inside */
310 for (iCount = 0; iCount < infoPtr->uNumItem; iCount++) {
311 rect = infoPtr->items[iCount].rect;
312 width = rect.right - rect.left;
313 if (width == 0) {
314 bNoWidth = TRUE;
315 continue;
316 }
317 if (PtInRect (&rect, *lpPt)) {
318 if (width <= 2 * DIVIDER_WIDTH) {
319 *pFlags |= HHT_ONHEADER;
320 *pItem = iCount;
321 TRACE("ON HEADER %d\n", iCount);
322 return;
323 }
324 if (iCount > 0) {
325 rcTest = rect;
326 rcTest.right = rcTest.left + DIVIDER_WIDTH;
327 if (PtInRect (&rcTest, *lpPt)) {
328 if (bNoWidth) {
329 *pFlags |= HHT_ONDIVOPEN;
330 *pItem = iCount - 1;
331 TRACE("ON DIVOPEN %d\n", *pItem);
332 return;
333 }
334 else {
335 *pFlags |= HHT_ONDIVIDER;
336 *pItem = iCount - 1;
337 TRACE("ON DIVIDER %d\n", *pItem);
338 return;
339 }
340 }
341 }
342 rcTest = rect;
343 rcTest.left = rcTest.right - DIVIDER_WIDTH;
344 if (PtInRect (&rcTest, *lpPt)) {
345 *pFlags |= HHT_ONDIVIDER;
346 *pItem = iCount;
347 TRACE("ON DIVIDER %d\n", *pItem);
348 return;
349 }
350
351 *pFlags |= HHT_ONHEADER;
352 *pItem = iCount;
353 TRACE("ON HEADER %d\n", iCount);
354 return;
355 }
356 }
357
358 /* check for last divider part (on nowhere) */
359 rect = infoPtr->items[infoPtr->uNumItem-1].rect;
360 rect.left = rect.right;
361 rect.right += DIVIDER_WIDTH;
362 if (PtInRect (&rect, *lpPt)) {
363 if (bNoWidth) {
364 *pFlags |= HHT_ONDIVOPEN;
365 *pItem = infoPtr->uNumItem - 1;
366 TRACE("ON DIVOPEN %d\n", *pItem);
367 return;
368 }
369 else {
370 *pFlags |= HHT_ONDIVIDER;
371 *pItem = infoPtr->uNumItem-1;
372 TRACE("ON DIVIDER %d\n", *pItem);
373 return;
374 }
375 }
376
377 *pFlags |= HHT_NOWHERE;
378 *pItem = 1;
379 TRACE("NOWHERE\n");
380 return;
381 }
382 }
383 else {
384 if (lpPt->x < rect.left) {
385 TRACE("TO LEFT\n");
386 *pFlags |= HHT_TOLEFT;
387 }
388 else if (lpPt->x > rect.right) {
389 TRACE("TO RIGHT\n");
390 *pFlags |= HHT_TORIGHT;
391 }
392
393 if (lpPt->y < rect.top) {
394 TRACE("ABOVE\n");
395 *pFlags |= HHT_ABOVE;
396 }
397 else if (lpPt->y > rect.bottom) {
398 TRACE("BELOW\n");
399 *pFlags |= HHT_BELOW;
400 }
401 }
402
403 *pItem = 1;
404 TRACE("flags=0x%X\n", *pFlags);
405 return;
406 }
407
408
409 static void
410 HEADER_DrawTrackLine (HWND hwnd, HDC hdc, INT x)
411 {
412 RECT rect;
413 HPEN hOldPen;
414 INT oldRop;
415
416 GetClientRect (hwnd, &rect);
417
418 hOldPen = SelectObject (hdc, GetStockObject (BLACK_PEN));
419 oldRop = SetROP2 (hdc, R2_XORPEN);
420 MoveToEx (hdc, x, rect.top, NULL);
421 LineTo (hdc, x, rect.bottom);
422 SetROP2 (hdc, oldRop);
423 SelectObject (hdc, hOldPen);
424 }
425
426
427 static BOOL
428 HEADER_SendSimpleNotify (HWND hwnd, UINT code)
429 {
430 NMHDR nmhdr;
431
432 nmhdr.hwndFrom = hwnd;
433 nmhdr.idFrom = GetWindowLongA (hwnd, GWL_ID);
434 nmhdr.code = code;
435
436 return (BOOL)SendMessageA (GetParent (hwnd), WM_NOTIFY,
437 (WPARAM)nmhdr.idFrom, (LPARAM)&nmhdr);
438 }
439
440 static BOOL
441 HEADER_SendItemChange(HWND hwnd, INT iItem, UINT mask, UINT msg)
442 {
443 HEADER_INFO *infoPtr = HEADER_GetInfoPtr (hwnd);
444 NMHEADERA nmhdr;
445 HDITEMA nmitem;
446
447 nmhdr.hdr.hwndFrom = hwnd;
448 nmhdr.hdr.idFrom = GetWindowLongA (hwnd, GWL_ID);
449 nmhdr.hdr.code = msg;
450 nmhdr.iItem = iItem;
451 nmhdr.iButton = 0;
452 nmhdr.pitem = &nmitem;
453 nmitem.mask = mask;
454 nmitem.cxy = infoPtr->items[iItem].cxy;
455 nmitem.hbm = infoPtr->items[iItem].hbm;
456 nmitem.pszText = NULL;
457 nmitem.cchTextMax = 0;
458 nmitem.fmt = infoPtr->items[iItem].fmt;
459 nmitem.lParam = infoPtr->items[iItem].lParam;
460 nmitem.iOrder = infoPtr->items[iItem].iOrder;
461 nmitem.iImage = infoPtr->items[iItem].iImage;
462
463 return (BOOL)SendMessageA (GetParent (hwnd), WM_NOTIFY,
464 (WPARAM)nmhdr.hdr.idFrom, (LPARAM)&nmhdr);
465 }
466
467 static BOOL
468 HEADER_SendHeaderNotify (HWND hwnd, UINT code, INT iItem)
469 {
470 HEADER_INFO *infoPtr = HEADER_GetInfoPtr (hwnd);
471 NMHEADERA nmhdr;
472 HDITEMA nmitem;
473
474 nmhdr.hdr.hwndFrom = hwnd;
475 nmhdr.hdr.idFrom = GetWindowLongA (hwnd, GWL_ID);
476 nmhdr.hdr.code = code;
477 nmhdr.iItem = iItem;
478 nmhdr.iButton = 0;
479 nmhdr.pitem = &nmitem;
480 nmitem.mask = 0;
481 nmitem.cxy = infoPtr->items[iItem].cxy;
482 nmitem.hbm = infoPtr->items[iItem].hbm;
483 nmitem.pszText = NULL;
484 nmitem.cchTextMax = 0;
485 /* nmitem.pszText = infoPtr->items[iItem].pszText; */
486 /* nmitem.cchTextMax = infoPtr->items[iItem].cchTextMax; */
487 nmitem.fmt = infoPtr->items[iItem].fmt;
488 nmitem.lParam = infoPtr->items[iItem].lParam;
489 nmitem.iOrder = infoPtr->items[iItem].iOrder;
490 nmitem.iImage = infoPtr->items[iItem].iImage;
491
492 return (BOOL)SendMessageA (GetParent (hwnd), WM_NOTIFY,
493 (WPARAM)nmhdr.hdr.idFrom, (LPARAM)&nmhdr);
494 }
495
496
497 static BOOL
498 HEADER_SendClickNotify (HWND hwnd, UINT code, INT iItem)
499 {
500 NMHEADERA nmhdr;
501
502 nmhdr.hdr.hwndFrom = hwnd;
503 nmhdr.hdr.idFrom = GetWindowLongA (hwnd, GWL_ID);
504 nmhdr.hdr.code = code;
505 nmhdr.iItem = iItem;
506 nmhdr.iButton = 0;
507 nmhdr.pitem = NULL;
508
509 return (BOOL)SendMessageA (GetParent (hwnd), WM_NOTIFY,
510 (WPARAM)nmhdr.hdr.idFrom, (LPARAM)&nmhdr);
511 }
512
513
514 static LRESULT
515 HEADER_CreateDragImage (HWND hwnd, WPARAM wParam)
516 {
517 FIXME("empty stub!\n");
518 return 0;
519 }
520
521
522 static LRESULT
523 HEADER_DeleteItem (HWND hwnd, WPARAM wParam)
524 {
525 HEADER_INFO *infoPtr = HEADER_GetInfoPtr(hwnd);
526 INT iItem = (INT)wParam;
527
528 TRACE("[iItem=%d]\n", iItem);
529
530 if ((iItem < 0) || (iItem >= (INT)infoPtr->uNumItem))
531 return FALSE;
532
533 if (infoPtr->uNumItem == 1) {
534 TRACE("Simple delete!\n");
535 if (infoPtr->items[0].pszText)
536 COMCTL32_Free (infoPtr->items[0].pszText);
537 COMCTL32_Free (infoPtr->items);
538 infoPtr->items = 0;
539 infoPtr->uNumItem = 0;
540 }
541 else {
542 HEADER_ITEM *oldItems = infoPtr->items;
543 TRACE("Complex delete! [iItem=%d]\n", iItem);
544
545 if (infoPtr->items[iItem].pszText)
546 COMCTL32_Free (infoPtr->items[iItem].pszText);
547
548 infoPtr->uNumItem--;
549 infoPtr->items = COMCTL32_Alloc (sizeof (HEADER_ITEM) * infoPtr->uNumItem);
550 /* pre delete copy */
551 if (iItem > 0) {
552 memcpy (&infoPtr->items[0], &oldItems[0],
553 iItem * sizeof(HEADER_ITEM));
554 }
555
556 /* post delete copy */
557 if (iItem < infoPtr->uNumItem) {
558 memcpy (&infoPtr->items[iItem], &oldItems[iItem+1],
559 (infoPtr->uNumItem - iItem) * sizeof(HEADER_ITEM));
560 }
561
562 COMCTL32_Free (oldItems);
563 }
564
565 HEADER_SetItemBounds (hwnd);
566
567 InvalidateRect(hwnd, NULL, FALSE);
568
569 return TRUE;
570 }
571
572
573 static LRESULT
574 HEADER_GetImageList (HWND hwnd)
575 {
576 HEADER_INFO *infoPtr = HEADER_GetInfoPtr (hwnd);
577
578 return (LRESULT)infoPtr->himl;
579 }
580
581
582 static LRESULT
583 HEADER_GetItemA (HWND hwnd, WPARAM wParam, LPARAM lParam)
584 {
585 HEADER_INFO *infoPtr = HEADER_GetInfoPtr (hwnd);
586 HDITEMA *phdi = (HDITEMA*)lParam;
587 INT nItem = (INT)wParam;
588 HEADER_ITEM *lpItem;
589
590 if (!phdi)
591 return FALSE;
592 if ((nItem < 0) || (nItem >= (INT)infoPtr->uNumItem))
593 return FALSE;
594
595 TRACE("[nItem=%d]\n", nItem);
596
597 if (phdi->mask == 0)
598 return TRUE;
599
600 lpItem = (HEADER_ITEM*)&infoPtr->items[nItem];
601 if (phdi->mask & HDI_BITMAP)
602 phdi->hbm = lpItem->hbm;
603
604 if (phdi->mask & HDI_FORMAT)
605 phdi->fmt = lpItem->fmt;
606
607 if (phdi->mask & HDI_WIDTH)
608 phdi->cxy = lpItem->cxy;
609
610 if (phdi->mask & HDI_LPARAM)
611 phdi->lParam = lpItem->lParam;
612
613 if (phdi->mask & HDI_TEXT) {
614 if (lpItem->pszText != LPSTR_TEXTCALLBACKW)
615 lstrcpynWtoA (phdi->pszText, lpItem->pszText, phdi->cchTextMax);
616 else
617 phdi->pszText = LPSTR_TEXTCALLBACKA;
618 }
619
620 if (phdi->mask & HDI_IMAGE)
621 phdi->iImage = lpItem->iImage;
622
623 if (phdi->mask & HDI_ORDER)
624 phdi->iOrder = lpItem->iOrder;
625
626 return TRUE;
627 }
628
629
630 static LRESULT
631 HEADER_GetItemW (HWND hwnd, WPARAM wParam, LPARAM lParam)
632 {
633 HEADER_INFO *infoPtr = HEADER_GetInfoPtr (hwnd);
634 HDITEMW *phdi = (HDITEMW*)lParam;
635 INT nItem = (INT)wParam;
636 HEADER_ITEM *lpItem;
637
638 if (!phdi)
639 return FALSE;
640 if ((nItem < 0) || (nItem >= (INT)infoPtr->uNumItem))
641 return FALSE;
642
643 TRACE("[nItem=%d]\n", nItem);
644
645 if (phdi->mask == 0)
646 return TRUE;
647
648 lpItem = (HEADER_ITEM*)&infoPtr->items[nItem];
649 if (phdi->mask & HDI_BITMAP)
650 phdi->hbm = lpItem->hbm;
651
652 if (phdi->mask & HDI_FORMAT)
653 phdi->fmt = lpItem->fmt;
654
655 if (phdi->mask & HDI_WIDTH)
656 phdi->cxy = lpItem->cxy;
657
658 if (phdi->mask & HDI_LPARAM)
659 phdi->lParam = lpItem->lParam;
660
661 if (phdi->mask & HDI_TEXT) {
662 if (lpItem->pszText != LPSTR_TEXTCALLBACKW)
663 lstrcpynW (phdi->pszText, lpItem->pszText, phdi->cchTextMax);
664 else
665 phdi->pszText = LPSTR_TEXTCALLBACKW;
666 }
667
668 if (phdi->mask & HDI_IMAGE)
669 phdi->iImage = lpItem->iImage;
670
671 if (phdi->mask & HDI_ORDER)
672 phdi->iOrder = lpItem->iOrder;
673
674 return TRUE;
675 }
676
677
678 inline static LRESULT
679 HEADER_GetItemCount (HWND hwnd)
680 {
681 HEADER_INFO *infoPtr = HEADER_GetInfoPtr (hwnd);
682 return infoPtr->uNumItem;
683 }
684
685
686 static LRESULT
687 HEADER_GetItemRect (HWND hwnd, WPARAM wParam, LPARAM lParam)
688 {
689 HEADER_INFO *infoPtr = HEADER_GetInfoPtr (hwnd);
690 INT iItem = (INT)wParam;
691 LPRECT lpRect = (LPRECT)lParam;
692
693 if ((iItem < 0) || (iItem >= (INT)infoPtr->uNumItem))
694 return FALSE;
695
696 lpRect->left = infoPtr->items[iItem].rect.left;
697 lpRect->right = infoPtr->items[iItem].rect.right;
698 lpRect->top = infoPtr->items[iItem].rect.top;
699 lpRect->bottom = infoPtr->items[iItem].rect.bottom;
700
701 return TRUE;
702 }
703
704
705 /* << HEADER_GetOrderArray >> */
706
707
708 inline static LRESULT
709 HEADER_GetUnicodeFormat (HWND hwnd)
710 {
711 HEADER_INFO *infoPtr = HEADER_GetInfoPtr (hwnd);
712 return infoPtr->bUnicode;
713 }
714
715
716 static LRESULT
717 HEADER_HitTest (HWND hwnd, WPARAM wParam, LPARAM lParam)
718 {
719 LPHDHITTESTINFO phti = (LPHDHITTESTINFO)lParam;
720
721 HEADER_InternalHitTest (hwnd, &phti->pt, &phti->flags, &phti->iItem);
722
723 if (phti->flags == HHT_ONHEADER)
724 return phti->iItem;
725 else
726 return -1;
727 }
728
729
730 static LRESULT
731 HEADER_InsertItemA (HWND hwnd, WPARAM wParam, LPARAM lParam)
732 {
733 HEADER_INFO *infoPtr = HEADER_GetInfoPtr (hwnd);
734 HDITEMA *phdi = (HDITEMA*)lParam;
735 INT nItem = (INT)wParam;
736 HEADER_ITEM *lpItem;
737 INT len;
738
739 if ((phdi == NULL) || (nItem < 0))
740 return -1;
741
742 if (nItem > infoPtr->uNumItem)
743 nItem = infoPtr->uNumItem;
744
745 if (infoPtr->uNumItem == 0) {
746 infoPtr->items = COMCTL32_Alloc (sizeof (HEADER_ITEM));
747 infoPtr->uNumItem++;
748 }
749 else {
750 HEADER_ITEM *oldItems = infoPtr->items;
751
752 infoPtr->uNumItem++;
753 infoPtr->items = COMCTL32_Alloc (sizeof (HEADER_ITEM) * infoPtr->uNumItem);
754 if (nItem == 0) {
755 memcpy (&infoPtr->items[1], &oldItems[0],
756 (infoPtr->uNumItem-1) * sizeof(HEADER_ITEM));
757 }
758 else
759 {
760 /* pre insert copy */
761 if (nItem > 0) {
762 memcpy (&infoPtr->items[0], &oldItems[0],
763 nItem * sizeof(HEADER_ITEM));
764 }
765
766 /* post insert copy */
767 if (nItem < infoPtr->uNumItem - 1) {
768 memcpy (&infoPtr->items[nItem+1], &oldItems[nItem],
769 (infoPtr->uNumItem - nItem - 1) * sizeof(HEADER_ITEM));
770 }
771 }
772
773 COMCTL32_Free (oldItems);
774 }
775
776 lpItem = (HEADER_ITEM*)&infoPtr->items[nItem];
777 lpItem->bDown = FALSE;
778
779 if (phdi->mask & HDI_WIDTH)
780 lpItem->cxy = phdi->cxy;
781
782 if (phdi->mask & HDI_TEXT) {
783 if (!phdi->pszText) /* null pointer check */
784 phdi->pszText = "";
785 if (phdi->pszText != LPSTR_TEXTCALLBACKA) {
786 len = lstrlenA (phdi->pszText);
787 lpItem->pszText = COMCTL32_Alloc ((len+1)*sizeof(WCHAR));
788 lstrcpyAtoW (lpItem->pszText, phdi->pszText);
789 }
790 else
791 lpItem->pszText = LPSTR_TEXTCALLBACKW;
792 }
793
794 if (phdi->mask & HDI_FORMAT)
795 lpItem->fmt = phdi->fmt;
796
797 if (lpItem->fmt == 0)
798 lpItem->fmt = HDF_LEFT;
799
800 if (phdi->mask & HDI_BITMAP)
801 lpItem->hbm = phdi->hbm;
802
803 if (phdi->mask & HDI_LPARAM)
804 lpItem->lParam = phdi->lParam;
805
806 if (phdi->mask & HDI_IMAGE)
807 lpItem->iImage = phdi->iImage;
808
809 if (phdi->mask & HDI_ORDER)
810 lpItem->iOrder = phdi->iOrder;
811
812 HEADER_SetItemBounds (hwnd);
813
814 InvalidateRect(hwnd, NULL, FALSE);
815
816 return nItem;
817 }
818
819
820 static LRESULT
821 HEADER_InsertItemW (HWND hwnd, WPARAM wParam, LPARAM lParam)
822 {
823 HEADER_INFO *infoPtr = HEADER_GetInfoPtr (hwnd);
824 HDITEMW *phdi = (HDITEMW*)lParam;
825 INT nItem = (INT)wParam;
826 HEADER_ITEM *lpItem;
827 INT len;
828
829 if ((phdi == NULL) || (nItem < 0))
830 return -1;
831
832 if (nItem > infoPtr->uNumItem)
833 nItem = infoPtr->uNumItem;
834
835 if (infoPtr->uNumItem == 0) {
836 infoPtr->items = COMCTL32_Alloc (sizeof (HEADER_ITEM));
837 infoPtr->uNumItem++;
838 }
839 else {
840 HEADER_ITEM *oldItems = infoPtr->items;
841
842 infoPtr->uNumItem++;
843 infoPtr->items = COMCTL32_Alloc (sizeof (HEADER_ITEM) * infoPtr->uNumItem);
844 /* pre insert copy */
845 if (nItem > 0) {
846 memcpy (&infoPtr->items[0], &oldItems[0],
847 nItem * sizeof(HEADER_ITEM));
848 }
849
850 /* post insert copy */
851 if (nItem < infoPtr->uNumItem - 1) {
852 memcpy (&infoPtr->items[nItem+1], &oldItems[nItem],
853 (infoPtr->uNumItem - nItem) * sizeof(HEADER_ITEM));
854 }
855
856 COMCTL32_Free (oldItems);
857 }
858
859 lpItem = (HEADER_ITEM*)&infoPtr->items[nItem];
860 lpItem->bDown = FALSE;
861
862 if (phdi->mask & HDI_WIDTH)
863 lpItem->cxy = phdi->cxy;
864
865 if (phdi->mask & HDI_TEXT) {
866 WCHAR wide_null_char = 0;
867 if (!phdi->pszText) /* null pointer check */
868 phdi->pszText = &wide_null_char;
869 if (phdi->pszText != LPSTR_TEXTCALLBACKW) {
870 len = lstrlenW (phdi->pszText);
871 lpItem->pszText = COMCTL32_Alloc ((len+1)*sizeof(WCHAR));
872 lstrcpyW (lpItem->pszText, phdi->pszText);
873 }
874 else
875 lpItem->pszText = LPSTR_TEXTCALLBACKW;
876 }
877
878 if (phdi->mask & HDI_FORMAT)
879 lpItem->fmt = phdi->fmt;
880
881 if (lpItem->fmt == 0)
882 lpItem->fmt = HDF_LEFT;
883
884 if (phdi->mask & HDI_BITMAP)
885 lpItem->hbm = phdi->hbm;
886
887 if (phdi->mask & HDI_LPARAM)
888 lpItem->lParam = phdi->lParam;
889
890 if (phdi->mask & HDI_IMAGE)
891 lpItem->iImage = phdi->iImage;
892
893 if (phdi->mask & HDI_ORDER)
894 lpItem->iOrder = phdi->iOrder;
895
896 HEADER_SetItemBounds (hwnd);
897
898 InvalidateRect(hwnd, NULL, FALSE);
899
900 return nItem;
901 }
902
903
904 static LRESULT
905 HEADER_Layout (HWND hwnd, WPARAM wParam, LPARAM lParam)
906 {
907 HEADER_INFO *infoPtr = HEADER_GetInfoPtr (hwnd);
908 LPHDLAYOUT lpLayout = (LPHDLAYOUT)lParam;
909
910 lpLayout->pwpos->hwnd = hwnd;
911 lpLayout->pwpos->hwndInsertAfter = 0;
912 lpLayout->pwpos->x = lpLayout->prc->left;
913 lpLayout->pwpos->y = lpLayout->prc->top;
914 lpLayout->pwpos->cx = lpLayout->prc->right - lpLayout->prc->left;
915 if (GetWindowLongA (hwnd, GWL_STYLE) & HDS_HIDDEN)
916 lpLayout->pwpos->cy = 0;
917 else {
918 lpLayout->pwpos->cy = infoPtr->nHeight;
919 lpLayout->prc->top += infoPtr->nHeight;
920 }
921 lpLayout->pwpos->flags = SWP_NOZORDER;
922
923 TRACE("Layout x=%d y=%d cx=%d cy=%d\n",
924 lpLayout->pwpos->x, lpLayout->pwpos->y,
925 lpLayout->pwpos->cx, lpLayout->pwpos->cy);
926
927 infoPtr->bRectsValid = FALSE;
928
929 return TRUE;
930 }
931
932
933 static LRESULT
934 HEADER_SetImageList (HWND hwnd, WPARAM wParam, LPARAM lParam)
935 {
936 HEADER_INFO *infoPtr = HEADER_GetInfoPtr (hwnd);
937 HIMAGELIST himlOld;
938
939 himlOld = infoPtr->himl;
940 infoPtr->himl = (HIMAGELIST)lParam;
941
942 /* FIXME: Refresh needed??? */
943
944 return (LRESULT)himlOld;
945 }
946
947
948 static LRESULT
949 HEADER_SetItemA (HWND hwnd, WPARAM wParam, LPARAM lParam)
950 {
951 HEADER_INFO *infoPtr = HEADER_GetInfoPtr (hwnd);
952 HDITEMA *phdi = (HDITEMA*)lParam;
953 INT nItem = (INT)wParam;
954 HEADER_ITEM *lpItem;
955
956 if (phdi == NULL)
957 return FALSE;
958 if ((nItem < 0) || (nItem >= (INT)infoPtr->uNumItem))
959 return FALSE;
960
961 TRACE("[nItem=%d]\n", nItem);
962
963 if (HEADER_SendItemChange(hwnd, nItem, phdi->mask,HDN_ITEMCHANGINGA))
964 return FALSE;
965
966 lpItem = (HEADER_ITEM*)&infoPtr->items[nItem];
967 if (phdi->mask & HDI_BITMAP)
968 lpItem->hbm = phdi->hbm;
969
970 if (phdi->mask & HDI_FORMAT)
971 lpItem->fmt = phdi->fmt;
972
973 if (phdi->mask & HDI_LPARAM)
974 lpItem->lParam = phdi->lParam;
975
976 if (phdi->mask & HDI_TEXT) {
977 if (phdi->pszText != LPSTR_TEXTCALLBACKA) {
978 if (lpItem->pszText) {
979 COMCTL32_Free (lpItem->pszText);
980 lpItem->pszText = NULL;
981 }
982 if (phdi->pszText) {
983 INT len = lstrlenA (phdi->pszText);
984 lpItem->pszText = COMCTL32_Alloc ((len+1)*sizeof(WCHAR));
985 lstrcpyAtoW (lpItem->pszText, phdi->pszText);
986 }
987 }
988 else
989 lpItem->pszText = LPSTR_TEXTCALLBACKW;
990 }
991
992 if (phdi->mask & HDI_WIDTH)
993 lpItem->cxy = phdi->cxy;
994
995 if (phdi->mask & HDI_IMAGE)
996 lpItem->iImage = phdi->iImage;
997
998 if (phdi->mask & HDI_ORDER)
999 lpItem->iOrder = phdi->iOrder;
1000
1001 HEADER_SendItemChange(hwnd,nItem,phdi->mask,HDN_ITEMCHANGEDA);
1002
1003 HEADER_SetItemBounds (hwnd);
1004
1005 InvalidateRect(hwnd, NULL, FALSE);
1006
1007 return TRUE;
1008 }
1009
1010
1011 static LRESULT
1012 HEADER_SetItemW (HWND hwnd, WPARAM wParam, LPARAM lParam)
1013 {
1014 HEADER_INFO *infoPtr = HEADER_GetInfoPtr (hwnd);
1015 HDITEMW *phdi = (HDITEMW*)lParam;
1016 INT nItem = (INT)wParam;
1017 HEADER_ITEM *lpItem;
1018
1019 if (phdi == NULL)
1020 return FALSE;
1021 if ((nItem < 0) || (nItem >= (INT)infoPtr->uNumItem))
1022 return FALSE;
1023
1024 TRACE("[nItem=%d]\n", nItem);
1025
1026 if (HEADER_SendItemChange(hwnd,nItem,phdi->mask,HDN_ITEMCHANGINGW))
1027 return FALSE;
1028
1029 lpItem = (HEADER_ITEM*)&infoPtr->items[nItem];
1030 if (phdi->mask & HDI_BITMAP)
1031 lpItem->hbm = phdi->hbm;
1032
1033 if (phdi->mask & HDI_FORMAT)
1034 lpItem->fmt = phdi->fmt;
1035
1036 if (phdi->mask & HDI_LPARAM)
1037 lpItem->lParam = phdi->lParam;
1038
1039 if (phdi->mask & HDI_TEXT) {
1040 if (phdi->pszText != LPSTR_TEXTCALLBACKW) {
1041 if (lpItem->pszText) {
1042 COMCTL32_Free (lpItem->pszText);
1043 lpItem->pszText = NULL;
1044 }
1045 if (phdi->pszText) {
1046 INT len = lstrlenW (phdi->pszText);
1047 lpItem->pszText = COMCTL32_Alloc ((len+1)*sizeof(WCHAR));
1048 lstrcpyW (lpItem->pszText, phdi->pszText);
1049 }
1050 }
1051 else
1052 lpItem->pszText = LPSTR_TEXTCALLBACKW;
1053 }
1054
1055 if (phdi->mask & HDI_WIDTH)
1056 lpItem->cxy = phdi->cxy;
1057
1058 if (phdi->mask & HDI_IMAGE)
1059 lpItem->iImage = phdi->iImage;
1060
1061 if (phdi->mask & HDI_ORDER)
1062 lpItem->iOrder = phdi->iOrder;
1063
1064 HEADER_SendItemChange(hwnd, nItem, phdi->mask,HDN_ITEMCHANGEDW);
1065
1066 HEADER_SetItemBounds (hwnd);
1067
1068 InvalidateRect(hwnd, NULL, FALSE);
1069
1070 return TRUE;
1071 }
1072
1073
1074 /* << HEADER_SetOrderArray >> */
1075
1076
1077 inline static LRESULT
1078 HEADER_SetUnicodeFormat (HWND hwnd, WPARAM wParam)
1079 {
1080 HEADER_INFO *infoPtr = HEADER_GetInfoPtr (hwnd);
1081 BOOL bTemp = infoPtr->bUnicode;
1082
1083 infoPtr->bUnicode = (BOOL)wParam;
1084
1085 return bTemp;
1086 }
1087
1088
1089 static LRESULT
1090 HEADER_Create (HWND hwnd, WPARAM wParam, LPARAM lParam)
1091 {
1092 HEADER_INFO *infoPtr;
1093 TEXTMETRICA tm;
1094 HFONT hOldFont;
1095 HDC hdc;
1096
1097 infoPtr = (HEADER_INFO *)COMCTL32_Alloc (sizeof(HEADER_INFO));
1098 SetWindowLongA (hwnd, 0, (DWORD)infoPtr);
1099
1100 infoPtr->uNumItem = 0;
1101 infoPtr->nHeight = 20;
1102 infoPtr->hFont = 0;
1103 infoPtr->items = 0;
1104 infoPtr->bRectsValid = FALSE;
1105 infoPtr->hcurArrow = LoadCursorA (0, IDC_ARROWA);
1106 infoPtr->hcurDivider = LoadCursorA (0, IDC_SIZEWEA);
1107 infoPtr->hcurDivopen = LoadCursorA (0, IDC_SIZENSA);
1108 infoPtr->bPressed = FALSE;
1109 infoPtr->bTracking = FALSE;
1110 infoPtr->iMoveItem = 0;
1111 infoPtr->himl = 0;
1112 infoPtr->iHotItem = -1;
1113 infoPtr->bUnicode = IsWindowUnicode (hwnd);
1114
1115 hdc = GetDC (0);
1116 hOldFont = SelectObject (hdc, GetStockObject (SYSTEM_FONT));
1117 GetTextMetricsA (hdc, &tm);
1118 infoPtr->nHeight = tm.tmHeight + VERT_BORDER;
1119 SelectObject (hdc, hOldFont);
1120 ReleaseDC (0, hdc);
1121
1122 return 0;
1123 }
1124
1125
1126 static LRESULT
1127 HEADER_Destroy (HWND hwnd, WPARAM wParam, LPARAM lParam)
1128 {
1129 HEADER_INFO *infoPtr = HEADER_GetInfoPtr (hwnd);
1130 HEADER_ITEM *lpItem;
1131 INT nItem;
1132
1133 if (infoPtr->items) {
1134 lpItem = (HEADER_ITEM*)infoPtr->items;
1135 for (nItem = 0; nItem < infoPtr->uNumItem; nItem++, lpItem++) {
1136 if ((lpItem->pszText) && (lpItem->pszText != LPSTR_TEXTCALLBACKW))
1137 COMCTL32_Free (lpItem->pszText);
1138 }
1139 COMCTL32_Free (infoPtr->items);
1140 }
1141
1142 if (infoPtr->himl)
1143 ImageList_Destroy (infoPtr->himl);
1144
1145 COMCTL32_Free (infoPtr);
1146 SetWindowLongA (hwnd, 0, 0);
1147 return 0;
1148 }
1149
1150
1151 static inline LRESULT
1152 HEADER_GetFont (HWND hwnd)
1153 {
1154 HEADER_INFO *infoPtr = HEADER_GetInfoPtr (hwnd);
1155
1156 return (LRESULT)infoPtr->hFont;
1157 }
1158
1159
1160 static LRESULT
1161 HEADER_LButtonDblClk (HWND hwnd, WPARAM wParam, LPARAM lParam)
1162 {
1163 POINT pt;
1164 UINT flags;
1165 INT nItem;
1166
1167 pt.x = (INT)LOWORD(lParam);
1168 pt.y = (INT)HIWORD(lParam);
1169 HEADER_InternalHitTest (hwnd, &pt, &flags, &nItem);
1170
1171 if ((GetWindowLongA (hwnd, GWL_STYLE) & HDS_BUTTONS) && (flags == HHT_ONHEADER))
1172 HEADER_SendHeaderNotify (hwnd, HDN_ITEMDBLCLICKA, nItem);
1173 else if ((flags == HHT_ONDIVIDER) || (flags == HHT_ONDIVOPEN))
1174 HEADER_SendHeaderNotify (hwnd, HDN_DIVIDERDBLCLICKA, nItem);
1175
1176 return 0;
1177 }
1178
1179
1180 static LRESULT
1181 HEADER_LButtonDown (HWND hwnd, WPARAM wParam, LPARAM lParam)
1182 {
1183 HEADER_INFO *infoPtr = HEADER_GetInfoPtr (hwnd);
1184 DWORD dwStyle = GetWindowLongA (hwnd, GWL_STYLE);
1185 POINT pt;
1186 UINT flags;
1187 INT nItem;
1188 HDC hdc;
1189
1190 pt.x = (INT)LOWORD(lParam);
1191 pt.y = (INT)HIWORD(lParam);
1192 HEADER_InternalHitTest (hwnd, &pt, &flags, &nItem);
1193
1194 if ((dwStyle & HDS_BUTTONS) && (flags == HHT_ONHEADER)) {
1195 SetCapture (hwnd);
1196 infoPtr->bCaptured = TRUE;
1197 infoPtr->bPressed = TRUE;
1198 infoPtr->iMoveItem = nItem;
1199
1200 infoPtr->items[nItem].bDown = TRUE;
1201
1202 /* Send WM_CUSTOMDRAW */
1203 hdc = GetDC (hwnd);
1204 HEADER_RefreshItem (hwnd, hdc, nItem);
1205 ReleaseDC (hwnd, hdc);
1206
1207 TRACE("Pressed item %d!\n", nItem);
1208 }
1209 else if ((flags == HHT_ONDIVIDER) || (flags == HHT_ONDIVOPEN)) {
1210 if (!(HEADER_SendHeaderNotify (hwnd, HDN_BEGINTRACKA, nItem))) {
1211 SetCapture (hwnd);
1212 infoPtr->bCaptured = TRUE;
1213 infoPtr->bTracking = TRUE;
1214 infoPtr->iMoveItem = nItem;
1215 infoPtr->nOldWidth = infoPtr->items[nItem].cxy;
1216 infoPtr->xTrackOffset = infoPtr->items[nItem].rect.right - pt.x;
1217
1218 if (!(dwStyle & HDS_FULLDRAG)) {
1219 infoPtr->xOldTrack = infoPtr->items[nItem].rect.right;
1220 hdc = GetDC (hwnd);
1221 HEADER_DrawTrackLine (hwnd, hdc, infoPtr->xOldTrack);
1222 ReleaseDC (hwnd, hdc);
1223 }
1224
1225 TRACE("Begin tracking item %d!\n", nItem);
1226 }
1227 }
1228
1229 return 0;
1230 }
1231
1232
1233 static LRESULT
1234 HEADER_LButtonUp (HWND hwnd, WPARAM wParam, LPARAM lParam)
1235 {
1236 HEADER_INFO *infoPtr = HEADER_GetInfoPtr (hwnd);
1237 /*
1238 *DWORD dwStyle = GetWindowLongA (hwnd, GWL_STYLE);
1239 */
1240 POINT pt;
1241 UINT flags;
1242 INT nItem, nWidth;
1243 HDC hdc;
1244
1245 pt.x = (INT)SLOWORD(lParam);
1246 pt.y = (INT)SHIWORD(lParam);
1247 HEADER_InternalHitTest (hwnd, &pt, &flags, &nItem);
1248
1249 if (infoPtr->bPressed) {
1250 if ((nItem == infoPtr->iMoveItem) && (flags == HHT_ONHEADER)) {
1251 infoPtr->items[infoPtr->iMoveItem].bDown = FALSE;
1252 hdc = GetDC (hwnd);
1253 HEADER_RefreshItem (hwnd, hdc, infoPtr->iMoveItem);
1254 ReleaseDC (hwnd, hdc);
1255
1256 HEADER_SendClickNotify (hwnd, HDN_ITEMCLICKA, infoPtr->iMoveItem);
1257 }
1258 TRACE("Released item %d!\n", infoPtr->iMoveItem);
1259 infoPtr->bPressed = FALSE;
1260 }
1261 else if (infoPtr->bTracking) {
1262 TRACE("End tracking item %d!\n", infoPtr->iMoveItem);
1263 infoPtr->bTracking = FALSE;
1264
1265 HEADER_SendHeaderNotify (hwnd, HDN_ENDTRACKA, infoPtr->iMoveItem);
1266
1267 /*
1268 * we want to do this even for HDS_FULLDRAG because this is where
1269 * we send the HDN_ITEMCHANGING and HDN_ITEMCHANGED notifications
1270 *
1271 * if (!(dwStyle & HDS_FULLDRAG)) {
1272 */
1273
1274 hdc = GetDC (hwnd);
1275 HEADER_DrawTrackLine (hwnd, hdc, infoPtr->xOldTrack);
1276 ReleaseDC (hwnd, hdc);
1277 if (HEADER_SendItemChange(hwnd, infoPtr->iMoveItem,HDI_WIDTH,
1278 HDN_ITEMCHANGINGA))
1279 infoPtr->items[infoPtr->iMoveItem].cxy = infoPtr->nOldWidth;
1280 else {
1281 nWidth = pt.x - infoPtr->items[infoPtr->iMoveItem].rect.left + infoPtr->xTrackOffset;
1282 if (nWidth < 0)
1283 nWidth = 0;
1284 infoPtr->items[infoPtr->iMoveItem].cxy = nWidth;
1285 }
1286
1287 HEADER_SendItemChange(hwnd,infoPtr->iMoveItem,HDI_WIDTH,
1288 HDN_ITEMCHANGEDA);
1289 HEADER_SetItemBounds (hwnd);
1290 InvalidateRect(hwnd, NULL, FALSE);
1291 /*
1292 * }
1293 */
1294 }
1295
1296 if (infoPtr->bCaptured) {
1297 infoPtr->bCaptured = FALSE;
1298 ReleaseCapture ();
1299 HEADER_SendSimpleNotify (hwnd, NM_RELEASEDCAPTURE);
1300 }
1301
1302 return 0;
1303 }
1304
1305
1306 static LRESULT
1307 HEADER_MouseMove (HWND hwnd, WPARAM wParam, LPARAM lParam)
1308 {
1309 HEADER_INFO *infoPtr = HEADER_GetInfoPtr (hwnd);
1310 DWORD dwStyle = GetWindowLongA (hwnd, GWL_STYLE);
1311 POINT pt;
1312 UINT flags;
1313 INT nItem, nWidth;
1314 HDC hdc;
1315
1316 pt.x = (INT)SLOWORD(lParam);
1317 pt.y = (INT)SHIWORD(lParam);
1318 HEADER_InternalHitTest (hwnd, &pt, &flags, &nItem);
1319
1320 if ((dwStyle & HDS_BUTTONS) && (dwStyle & HDS_HOTTRACK)) {
1321 if (flags & (HHT_ONHEADER | HHT_ONDIVIDER | HHT_ONDIVOPEN))
1322 infoPtr->iHotItem = nItem;
1323 else
1324 infoPtr->iHotItem = -1;
1325 InvalidateRect(hwnd, NULL, FALSE);
1326 }
1327
1328 if (infoPtr->bCaptured) {
1329 if (infoPtr->bPressed) {
1330 if ((nItem == infoPtr->iMoveItem) && (flags == HHT_ONHEADER))
1331 infoPtr->items[infoPtr->iMoveItem].bDown = TRUE;
1332 else
1333 infoPtr->items[infoPtr->iMoveItem].bDown = FALSE;
1334 hdc = GetDC (hwnd);
1335 HEADER_RefreshItem (hwnd, hdc, infoPtr->iMoveItem);
1336 ReleaseDC (hwnd, hdc);
1337
1338 TRACE("Moving pressed item %d!\n", infoPtr->iMoveItem);
1339 }
1340 else if (infoPtr->bTracking) {
1341 if (dwStyle & HDS_FULLDRAG) {
1342 /*
1343 * Investigation shows that the changing message occure only
1344 * after tracking is done
1345 *
1346 *if (HEADER_SendHeaderNotify (hwnd, HDN_ITEMCHANGINGA, infoPtr->iMoveItem))
1347 * infoPtr->items[infoPtr->iMoveItem].cxy = infoPtr->nOldWidth;
1348 *else {
1349 *
1350 */
1351 nWidth = pt.x - infoPtr->items[infoPtr->iMoveItem].rect.left + infoPtr->xTrackOffset;
1352 if (nWidth < 0)
1353 nWidth = 0;
1354 infoPtr->items[infoPtr->iMoveItem].cxy = nWidth;
1355 /*
1356 * Invistigation shows that the item changed only occures
1357 * after the tracking is done
1358 *
1359 * HEADER_SendItemChanged(FALSE,hwnd,infoPtr->iMoveItem,HDI_WIDTH);
1360 *}
1361 */
1362
1363 HEADER_SetItemBounds (hwnd);
1364 InvalidateRect(hwnd, NULL, FALSE);
1365 }
1366 else {
1367 hdc = GetDC (hwnd);
1368 HEADER_DrawTrackLine (hwnd, hdc, infoPtr->xOldTrack);
1369 infoPtr->xOldTrack = pt.x + infoPtr->xTrackOffset;
1370 if (infoPtr->xOldTrack < infoPtr->items[infoPtr->iMoveItem].rect.left)
1371 infoPtr->xOldTrack = infoPtr->items[infoPtr->iMoveItem].rect.left;
1372 infoPtr->items[infoPtr->iMoveItem].cxy =
1373 infoPtr->xOldTrack - infoPtr->items[infoPtr->iMoveItem].rect.left;
1374 HEADER_DrawTrackLine (hwnd, hdc, infoPtr->xOldTrack);
1375 ReleaseDC (hwnd, hdc);
1376 }
1377
1378 HEADER_SendHeaderNotify (hwnd, HDN_TRACKA, infoPtr->iMoveItem);
1379 TRACE("Tracking item %d!\n", infoPtr->iMoveItem);
1380 }
1381 }
1382
1383 if ((dwStyle & HDS_BUTTONS) && (dwStyle & HDS_HOTTRACK)) {
1384 FIXME("hot track support!\n");
1385 }
1386
1387 return 0;
1388 }
1389
1390
1391 static LRESULT
1392 HEADER_Paint (HWND hwnd, WPARAM wParam)
1393 {
1394 HDC hdc;
1395 PAINTSTRUCT ps;
1396
1397 hdc = wParam==0 ? BeginPaint (hwnd, &ps) : (HDC)wParam;
1398 HEADER_Refresh (hwnd, hdc);
1399 if(!wParam)
1400 EndPaint (hwnd, &ps);
1401 return 0;
1402 }
1403
1404
1405 static LRESULT
1406 HEADER_RButtonUp (HWND hwnd, WPARAM wParam, LPARAM lParam)
1407 {
1408 BOOL bRet;
1409 POINT pt;
1410
1411 pt.x = LOWORD(lParam);
1412 pt.y = HIWORD(lParam);
1413
1414 /* Send a Notify message */
1415 bRet = HEADER_SendSimpleNotify (hwnd, NM_RCLICK);
1416
1417 /* Change to screen coordinate for WM_CONTEXTMENU */
1418 ClientToScreen(hwnd, &pt);
1419
1420 /* Send a WM_CONTEXTMENU message in response to the RBUTTONUP */
1421 SendMessageA( hwnd, WM_CONTEXTMENU, (WPARAM) hwnd, MAKELPARAM(pt.x, pt.y));
1422
1423 return bRet;
1424 }
1425
1426
1427 static LRESULT
1428 HEADER_SetCursor (HWND hwnd, WPARAM wParam, LPARAM lParam)
1429 {
1430 HEADER_INFO *infoPtr = HEADER_GetInfoPtr (hwnd);
1431 POINT pt;
1432 UINT flags;
1433 INT nItem;
1434
1435 TRACE("code=0x%X id=0x%X\n", LOWORD(lParam), HIWORD(lParam));
1436
1437 GetCursorPos (&pt);
1438 ScreenToClient (hwnd, &pt);
1439
1440 HEADER_InternalHitTest (hwnd, &pt, &flags, &nItem);
1441
1442 if (flags == HHT_ONDIVIDER)
1443 SetCursor (infoPtr->hcurDivider);
1444 else if (flags == HHT_ONDIVOPEN)
1445 SetCursor (infoPtr->hcurDivopen);
1446 else
1447 SetCursor (infoPtr->hcurArrow);
1448
1449 return 0;
1450 }
1451
1452
1453 static LRESULT
1454 HEADER_SetFont (HWND hwnd, WPARAM wParam, LPARAM lParam)
1455 {
1456 HEADER_INFO *infoPtr = HEADER_GetInfoPtr (hwnd);
1457 TEXTMETRICA tm;
1458 HFONT hFont, hOldFont;
1459 HDC hdc;
1460
1461 infoPtr->hFont = (HFONT)wParam;
1462
1463 hFont = infoPtr->hFont ? infoPtr->hFont : GetStockObject (SYSTEM_FONT);
1464
1465 hdc = GetDC (0);
1466 hOldFont = SelectObject (hdc, hFont);
1467 GetTextMetricsA (hdc, &tm);
1468 infoPtr->nHeight = tm.tmHeight + VERT_BORDER;
1469 SelectObject (hdc, hOldFont);
1470 ReleaseDC (0, hdc);
1471
1472 infoPtr->bRectsValid = FALSE;
1473
1474 if (lParam) {
1475 InvalidateRect(hwnd, NULL, FALSE);
1476 }
1477
1478 return 0;
1479 }
1480
1481
1482 static LRESULT WINAPI
1483 HEADER_WindowProc (HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam)
1484 {
1485 TRACE("hwnd=%x msg=%x wparam=%x lParam=%lx\n", hwnd, msg, wParam, lParam);
1486 if (!HEADER_GetInfoPtr (hwnd) && (msg != WM_CREATE))
1487 return DefWindowProcA (hwnd, msg, wParam, lParam);
1488 switch (msg) {
1489 case HDM_CREATEDRAGIMAGE:
1490 return HEADER_CreateDragImage (hwnd, wParam);
1491
1492 case HDM_DELETEITEM:
1493 return HEADER_DeleteItem (hwnd, wParam);
1494
1495 case HDM_GETIMAGELIST:
1496 return HEADER_GetImageList (hwnd);
1497
1498 case HDM_GETITEMA:
1499 return HEADER_GetItemA (hwnd, wParam, lParam);
1500
1501 case HDM_GETITEMW:
1502 return HEADER_GetItemW (hwnd, wParam, lParam);
1503
1504 case HDM_GETITEMCOUNT:
1505 return HEADER_GetItemCount (hwnd);
1506
1507 case HDM_GETITEMRECT:
1508 return HEADER_GetItemRect (hwnd, wParam, lParam);
1509
1510 /* case HDM_GETORDERARRAY: */
1511
1512 case HDM_GETUNICODEFORMAT:
1513 return HEADER_GetUnicodeFormat (hwnd);
1514
1515 case HDM_HITTEST:
1516 return HEADER_HitTest (hwnd, wParam, lParam);
1517
1518 case HDM_INSERTITEMA:
1519 return HEADER_InsertItemA (hwnd, wParam, lParam);
1520
1521 case HDM_INSERTITEMW:
1522 return HEADER_InsertItemW (hwnd, wParam, lParam);
1523
1524 case HDM_LAYOUT:
1525 return HEADER_Layout (hwnd, wParam, lParam);
1526
1527 case HDM_SETIMAGELIST:
1528 return HEADER_SetImageList (hwnd, wParam, lParam);
1529
1530 case HDM_SETITEMA:
1531 return HEADER_SetItemA (hwnd, wParam, lParam);
1532
1533 case HDM_SETITEMW:
1534 return HEADER_SetItemW (hwnd, wParam, lParam);
1535
1536 /* case HDM_SETORDERARRAY: */
1537
1538 case HDM_SETUNICODEFORMAT:
1539 return HEADER_SetUnicodeFormat (hwnd, wParam);
1540
1541 case WM_CREATE:
1542 return HEADER_Create (hwnd, wParam, lParam);
1543
1544 case WM_DESTROY:
1545 return HEADER_Destroy (hwnd, wParam, lParam);
1546
1547 case WM_ERASEBKGND:
1548 return 1;
1549
1550 case WM_GETDLGCODE:
1551 return DLGC_WANTTAB | DLGC_WANTARROWS;
1552
1553 case WM_GETFONT:
1554 return HEADER_GetFont (hwnd);
1555
1556 case WM_LBUTTONDBLCLK:
1557 return HEADER_LButtonDblClk (hwnd, wParam, lParam);
1558
1559 case WM_LBUTTONDOWN:
1560 return HEADER_LButtonDown (hwnd, wParam, lParam);
1561
1562 case WM_LBUTTONUP:
1563 return HEADER_LButtonUp (hwnd, wParam, lParam);
1564
1565 case WM_MOUSEMOVE:
1566 return HEADER_MouseMove (hwnd, wParam, lParam);
1567
1568 /* case WM_NOTIFYFORMAT: */
1569
1570 case WM_SIZE:
1571 return HEADER_Size (hwnd, wParam);
1572
1573 case WM_PAINT:
1574 return HEADER_Paint (hwnd, wParam);
1575
1576 case WM_RBUTTONUP:
1577 return HEADER_RButtonUp (hwnd, wParam, lParam);
1578
1579 case WM_SETCURSOR:
1580 return HEADER_SetCursor (hwnd, wParam, lParam);
1581
1582 case WM_SETFONT:
1583 return HEADER_SetFont (hwnd, wParam, lParam);
1584
1585 default:
1586 if (msg >= WM_USER)
1587 ERR("unknown msg %04x wp=%04x lp=%08lx\n",
1588 msg, wParam, lParam );
1589 return DefWindowProcA (hwnd, msg, wParam, lParam);
1590 }
1591 return 0;
1592 }
1593
1594
1595 VOID
1596 HEADER_Register (void)
1597 {
1598 WNDCLASSA wndClass;
1599
1600 ZeroMemory (&wndClass, sizeof(WNDCLASSA));
1601 wndClass.style = CS_GLOBALCLASS | CS_DBLCLKS;
1602 wndClass.lpfnWndProc = (WNDPROC)HEADER_WindowProc;
1603 wndClass.cbClsExtra = 0;
1604 wndClass.cbWndExtra = sizeof(HEADER_INFO *);
1605 wndClass.hCursor = LoadCursorA (0, IDC_ARROWA);
1606 wndClass.lpszClassName = WC_HEADERA;
1607
1608 RegisterClassA (&wndClass);
1609 }
1610
1611
1612 VOID
1613 HEADER_Unregister (void)
1614 {
1615 UnregisterClassA (WC_HEADERA, (HINSTANCE)NULL);
1616 }
1617
Maarten's multimedia branch