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