git.oblomov.eu Git - wine/blob - dlls/comctl32/header.c

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