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

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