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