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