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