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