Ignore:
Timestamp:
Jun 28, 1999, 5:46:28 PM (26 years ago)
Author:
cbratschi
Message:

bug fixes (unicode) and improvements

File:
1 edited

Legend:

Unmodified
Added
Removed

  • trunk/src/comctl32/header.c

    r94 r236  
    1 /* $Id: header.c,v 1.5 1999-06-10 16:21:58 achimha Exp $ */
     1/* $Id: header.c,v 1.6 1999-06-28 15:46:24 cbratschi Exp $ */
    22/*
    33 *  Header control
    … …  
    55 *  Copyright 1998 Eric Kohl
    66 *  Copyright 1999 Achim Hasenmueller
     7 *  Copyright 1999 Christoph Bratschi
    78 *
    89 *  TODO:
    … …  
    4950    r = phdi->rect;
    5051    if (r.right - r.left == 0)
    51         return phdi->rect.right;
     52        return phdi->rect.right;
    5253
    5354    if (GetWindowLongA (hwnd, GWL_STYLE) & HDS_BUTTONS) {
    54         if (phdi->bDown) {
    55             DrawEdge (hdc, &r, BDR_RAISEDOUTER,
    56                         BF_RECT | BF_FLAT | BF_MIDDLE | BF_ADJUST);
    57             r.left += 2;
     55        if (phdi->bDown) {
     56            DrawEdge (hdc, &r, BDR_RAISEDOUTER,
     57                        BF_RECT | BF_FLAT | BF_MIDDLE | BF_ADJUST);
     58            r.left += 2;
    5859            r.top  += 2;
    59         }
    60         else
    61             DrawEdge (hdc, &r, EDGE_RAISED,
    62                         BF_RECT | BF_SOFT | BF_MIDDLE | BF_ADJUST);
     60        }
     61        else
     62            DrawEdge (hdc, &r, EDGE_RAISED,
     63                        BF_RECT | BF_SOFT | BF_MIDDLE | BF_ADJUST);
    6364    }
    6465    else
    … …  
    6667
    6768    if (phdi->fmt & HDF_OWNERDRAW) {
    68         DRAWITEMSTRUCT dis;
    69         dis.CtlType    = ODT_HEADER;
    70         dis.CtlID      = GetWindowLongA (hwnd, GWL_ID);
    71         dis.itemID     = iItem;
    72         dis.itemAction = ODA_DRAWENTIRE;
    73         dis.itemState  = phdi->bDown ? ODS_SELECTED : 0;
    74         dis.hwndItem   = hwnd;
    75         dis.hDC        = hdc;
    76         dis.rcItem     = r;
    77         dis.itemData   = phdi->lParam;
    78         SendMessageA (GetParent (hwnd), WM_DRAWITEM,
    79                         (WPARAM)dis.CtlID, (LPARAM)&dis);
     69        DRAWITEMSTRUCT dis;
     70        dis.CtlType    = ODT_HEADER;
     71        dis.CtlID      = GetWindowLongA (hwnd, GWL_ID);
     72        dis.itemID     = iItem;
     73        dis.itemAction = ODA_DRAWENTIRE;
     74        dis.itemState  = phdi->bDown ? ODS_SELECTED : 0;
     75        dis.hwndItem   = hwnd;
     76        dis.hDC        = hdc;
     77        dis.rcItem     = r;
     78        dis.itemData   = phdi->lParam;
     79        SendMessageA (GetParent (hwnd), WM_DRAWITEM,
     80                        (WPARAM)dis.CtlID, (LPARAM)&dis);
    8081    }
    8182    else {
    … …  
    8788            uTextJustify = DT_RIGHT;
    8889
    89         if ((phdi->fmt & HDF_BITMAP) && (phdi->hbm)) {
    90             BITMAP bmp;
    91             HDC    hdcBitmap;
    92             INT    yD, yS, cx, cy, rx, ry;
    93 
    94             GetObjectA (phdi->hbm, sizeof(BITMAP), (LPVOID)&bmp);
    95 
    96             ry = r.bottom - r.top;
    97             rx = r.right - r.left;
    98 
    99             if (ry >= bmp.bmHeight) {
    100                 cy = bmp.bmHeight;
    101                 yD = r.top + (ry - bmp.bmHeight) / 2;
    102                 yS = 0;
    103             }
    104             else {
    105                 cy = ry;
    106                 yD = r.top;
    107                 yS = (bmp.bmHeight - ry) / 2;
    108 
    109             }
    110 
    111             if (rx >= bmp.bmWidth + 6) {
    112                 cx = bmp.bmWidth;
    113             }
    114             else {
    115                 cx = rx - 6;
    116             }
    117 
    118             hdcBitmap = CreateCompatibleDC (hdc);
    119             SelectObject (hdcBitmap, phdi->hbm);
    120             BitBlt (hdc, r.left + 3, yD, cx, cy, hdcBitmap, 0, yS, SRCCOPY);
    121             DeleteDC (hdcBitmap);
    122 
    123             r.left += (bmp.bmWidth + 3);
    124         }
    125 
    126 
    127         if ((phdi->fmt & HDF_BITMAP_ON_RIGHT) && (phdi->hbm)) {
    128             BITMAP bmp;
    129             HDC    hdcBitmap;
    130             INT    xD, yD, yS, cx, cy, rx, ry, tx;
    131             RECT   textRect;
    132 
    133             GetObjectA (phdi->hbm, sizeof(BITMAP), (LPVOID)&bmp);
    134 
    135             textRect = r;
     90        if ((phdi->fmt & HDF_BITMAP) && (phdi->hbm)) {
     91            BITMAP bmp;
     92            HDC    hdcBitmap;
     93            INT    yD, yS, cx, cy, rx, ry;
     94
     95            GetObjectA (phdi->hbm, sizeof(BITMAP), (LPVOID)&bmp);
     96
     97            ry = r.bottom - r.top;
     98            rx = r.right - r.left;
     99
     100            if (ry >= bmp.bmHeight) {
     101                cy = bmp.bmHeight;
     102                yD = r.top + (ry - bmp.bmHeight) / 2;
     103                yS = 0;
     104            }
     105            else {
     106                cy = ry;
     107                yD = r.top;
     108                yS = (bmp.bmHeight - ry) / 2;
     109
     110            }
     111
     112            if (rx >= bmp.bmWidth + 6) {
     113                cx = bmp.bmWidth;
     114            }
     115            else {
     116                cx = rx - 6;
     117            }
     118
     119            hdcBitmap = CreateCompatibleDC (hdc);
     120            SelectObject (hdcBitmap, phdi->hbm);
     121            BitBlt (hdc, r.left + 3, yD, cx, cy, hdcBitmap, 0, yS, SRCCOPY);
     122            DeleteDC (hdcBitmap);
     123
     124            r.left += (bmp.bmWidth + 3);
     125        }
     126
     127
     128        if ((phdi->fmt & HDF_BITMAP_ON_RIGHT) && (phdi->hbm)) {
     129            BITMAP bmp;
     130            HDC    hdcBitmap;
     131            INT    xD, yD, yS, cx, cy, rx, ry, tx;
     132            RECT   textRect;
     133
     134            GetObjectA (phdi->hbm, sizeof(BITMAP), (LPVOID)&bmp);
     135
     136            textRect = r;
    136137            DrawTextW (hdc, phdi->pszText, lstrlenW (phdi->pszText),
    137                   &textRect, DT_LEFT|DT_VCENTER|DT_SINGLELINE|DT_CALCRECT);
    138             tx = textRect.right - textRect.left;
    139             ry = r.bottom - r.top;
    140             rx = r.right - r.left;
    141 
    142             if (ry >= bmp.bmHeight) {
    143                 cy = bmp.bmHeight;
    144                 yD = r.top + (ry - bmp.bmHeight) / 2;
    145                 yS = 0;
    146             }
    147             else {
    148                 cy = ry;
    149                 yD = r.top;
    150                 yS = (bmp.bmHeight - ry) / 2;
    151 
    152             }
    153 
    154             if (r.left + tx + bmp.bmWidth + 9 <= r.right) {
    155                 cx = bmp.bmWidth;
    156                 xD = r.left + tx + 6;
    157             }
    158             else {
    159                 if (rx >= bmp.bmWidth + 6) {
    160                     cx = bmp.bmWidth;
    161                     xD = r.right - bmp.bmWidth - 3;
    162                     r.right = xD - 3;
    163                 }
    164                 else {
    165                     cx = rx - 3;
    166                     xD = r.left;
    167                     r.right = r.left;
    168                 }
    169             }
    170 
    171             hdcBitmap = CreateCompatibleDC (hdc);
    172             SelectObject (hdcBitmap, phdi->hbm);
    173             BitBlt (hdc, xD, yD, cx, cy, hdcBitmap, 0, yS, SRCCOPY);
    174             DeleteDC (hdcBitmap);
    175         }
    176 
    177         if (phdi->fmt & HDF_IMAGE) {
    178 
    179 
    180 /*          ImageList_Draw (infoPtr->himl, phdi->iImage,...); */
    181         }
     138                  &textRect, DT_LEFT|DT_VCENTER|DT_SINGLELINE|DT_CALCRECT);
     139            tx = textRect.right - textRect.left;
     140            ry = r.bottom - r.top;
     141            rx = r.right - r.left;
     142
     143            if (ry >= bmp.bmHeight) {
     144                cy = bmp.bmHeight;
     145                yD = r.top + (ry - bmp.bmHeight) / 2;
     146                yS = 0;
     147            }
     148            else {
     149                cy = ry;
     150                yD = r.top;
     151                yS = (bmp.bmHeight - ry) / 2;
     152
     153            }
     154
     155            if (r.left + tx + bmp.bmWidth + 9 <= r.right) {
     156                cx = bmp.bmWidth;
     157                xD = r.left + tx + 6;
     158            }
     159            else {
     160                if (rx >= bmp.bmWidth + 6) {
     161                    cx = bmp.bmWidth;
     162                    xD = r.right - bmp.bmWidth - 3;
     163                    r.right = xD - 3;
     164                }
     165                else {
     166                    cx = rx - 3;
     167                    xD = r.left;
     168                    r.right = r.left;
     169                }
     170            }
     171
     172            hdcBitmap = CreateCompatibleDC (hdc);
     173            SelectObject (hdcBitmap, phdi->hbm);
     174            BitBlt (hdc, xD, yD, cx, cy, hdcBitmap, 0, yS, SRCCOPY);
     175            DeleteDC (hdcBitmap);
     176        }
     177
     178        if (phdi->fmt & HDF_IMAGE) {
     179
     180
     181/*          ImageList_Draw (infoPtr->himl, phdi->iImage,...); */
     182        }
    182183
    183184        if ((phdi->fmt & HDF_STRING) && (phdi->pszText)) {
    184185            oldBkMode = SetBkMode(hdc, TRANSPARENT);
    185186            r.left += 3;
    186             r.right -= 3;
    187             SetTextColor (hdc, bHotTrack ? COLOR_HIGHLIGHT : COLOR_BTNTEXT);
     187            r.right -= 3;
     188            SetTextColor (hdc, bHotTrack ? COLOR_HIGHLIGHT : COLOR_BTNTEXT);
    188189            DrawTextW (hdc, phdi->pszText, lstrlenW (phdi->pszText),
    189                   &r, uTextJustify|DT_VCENTER|DT_SINGLELINE);
     190                  &r, uTextJustify|DT_VCENTER|DT_SINGLELINE);
    190191            if (oldBkMode != TRANSPARENT)
    191192                SetBkMode(hdc, oldBkMode);
    … …  
    197198
    198199
    199 static void 
     200static void
    200201HEADER_Refresh (HWND hwnd, HDC hdc)
    201202{
    … …  
    279280
    280281    if (infoPtr->uNumItem == 0)
    281         return;
     282        return;
    282283
    283284    x = 0;
    284285    for (i = 0; i < infoPtr->uNumItem; i++) {
    285         phdi = &infoPtr->items[i];
    286         phdi->rect.top = 0;
    287         phdi->rect.bottom = cy;
    288         phdi->rect.left = x;
    289         phdi->rect.right = phdi->rect.left + phdi->cxy;
    290         x = phdi->rect.right;
     286        phdi = &infoPtr->items[i];
     287        phdi->rect.top = 0;
     288        phdi->rect.bottom = cy;
     289        phdi->rect.left = x;
     290        phdi->rect.right = phdi->rect.left + phdi->cxy;
     291        x = phdi->rect.right;
    291292    }
    292293}
    … …  
    307308    if (PtInRect (&rect, *lpPt))
    308309    {
    309         if (infoPtr->uNumItem == 0) {
    310             *pFlags |= HHT_NOWHERE;
    311             *pItem = 1;
    312 //          TRACE (header, "NOWHERE\n");
    313             return;
    314         }
    315         else {
    316             /* somewhere inside */
    317             for (iCount = 0; iCount < infoPtr->uNumItem; iCount++) {
    318                 rect = infoPtr->items[iCount].rect;
    319                 width = rect.right - rect.left;
    320                 if (width == 0) {
    321                     bNoWidth = TRUE;
    322                     continue;
    323                 }
    324                 if (PtInRect (&rect, *lpPt)) {
    325                     if (width <= 2 * DIVIDER_WIDTH) {
    326                         *pFlags |= HHT_ONHEADER;
    327                         *pItem = iCount;
    328 //                      TRACE (header, "ON HEADER %d\n", iCount);
    329                         return;
    330                     }
    331                     if (iCount > 0) {
    332                         rcTest = rect;
    333                         rcTest.right = rcTest.left + DIVIDER_WIDTH;
    334                         if (PtInRect (&rcTest, *lpPt)) {
    335                             if (bNoWidth) {
    336                                 *pFlags |= HHT_ONDIVOPEN;
    337                                 *pItem = iCount - 1;
    338 //                              TRACE (header, "ON DIVOPEN %d\n", *pItem);
    339                                 return;
    340                             }
    341                             else {
    342                                 *pFlags |= HHT_ONDIVIDER;
    343                                 *pItem = iCount - 1;
    344 //                              TRACE (header, "ON DIVIDER %d\n", *pItem);
    345                                 return;
    346                             }
    347                         }
    348                     }
    349                     rcTest = rect;
    350                     rcTest.left = rcTest.right - DIVIDER_WIDTH;
    351                     if (PtInRect (&rcTest, *lpPt)) {
    352                         *pFlags |= HHT_ONDIVIDER;
    353                         *pItem = iCount;
    354 //                      TRACE (header, "ON DIVIDER %d\n", *pItem);
    355                         return;
    356                     }
    357 
    358                     *pFlags |= HHT_ONHEADER;
    359                     *pItem = iCount;
    360 //                  TRACE (header, "ON HEADER %d\n", iCount);
    361                     return;
    362                 }
    363             }
    364 
    365             /* check for last divider part (on nowhere) */
    366             rect = infoPtr->items[infoPtr->uNumItem-1].rect;
    367             rect.left = rect.right;
    368             rect.right += DIVIDER_WIDTH;
    369             if (PtInRect (&rect, *lpPt)) {
    370                 if (bNoWidth) {
    371                     *pFlags |= HHT_ONDIVOPEN;
    372                     *pItem = infoPtr->uNumItem - 1;
    373 //                  TRACE (header, "ON DIVOPEN %d\n", *pItem);
    374                     return;
    375                 }
    376                 else {
    377                     *pFlags |= HHT_ONDIVIDER;
    378                     *pItem = infoPtr->uNumItem-1;
    379 //                  TRACE (header, "ON DIVIDER %d\n", *pItem);
    380                     return;
    381                 }
    382             }
    383 
    384             *pFlags |= HHT_NOWHERE;
    385             *pItem = 1;
    386 //          TRACE (header, "NOWHERE\n");
    387             return;
    388         }
     310        if (infoPtr->uNumItem == 0) {
     311            *pFlags |= HHT_NOWHERE;
     312            *pItem = 1;
     313//          TRACE (header, "NOWHERE\n");
     314            return;
     315        }
     316        else {
     317            /* somewhere inside */
     318            for (iCount = 0; iCount < infoPtr->uNumItem; iCount++) {
     319                rect = infoPtr->items[iCount].rect;
     320                width = rect.right - rect.left;
     321                if (width == 0) {
     322                    bNoWidth = TRUE;
     323                    continue;
     324                }
     325                if (PtInRect (&rect, *lpPt)) {
     326                    if (width <= 2 * DIVIDER_WIDTH) {
     327                        *pFlags |= HHT_ONHEADER;
     328                        *pItem = iCount;
     329//                      TRACE (header, "ON HEADER %d\n", iCount);
     330                        return;
     331                    }
     332                    if (iCount > 0) {
     333                        rcTest = rect;
     334                        rcTest.right = rcTest.left + DIVIDER_WIDTH;
     335                        if (PtInRect (&rcTest, *lpPt)) {
     336                            if (bNoWidth) {
     337                                *pFlags |= HHT_ONDIVOPEN;
     338                                *pItem = iCount - 1;
     339//                              TRACE (header, "ON DIVOPEN %d\n", *pItem);
     340                                return;
     341                            }
     342                            else {
     343                                *pFlags |= HHT_ONDIVIDER;
     344                                *pItem = iCount - 1;
     345//                              TRACE (header, "ON DIVIDER %d\n", *pItem);
     346                                return;
     347                            }
     348                        }
     349                    }
     350                    rcTest = rect;
     351                    rcTest.left = rcTest.right - DIVIDER_WIDTH;
     352                    if (PtInRect (&rcTest, *lpPt)) {
     353                        *pFlags |= HHT_ONDIVIDER;
     354                        *pItem = iCount;
     355//                      TRACE (header, "ON DIVIDER %d\n", *pItem);
     356                        return;
     357                    }
     358
     359                    *pFlags |= HHT_ONHEADER;
     360                    *pItem = iCount;
     361//                  TRACE (header, "ON HEADER %d\n", iCount);
     362                    return;
     363                }
     364            }
     365
     366            /* check for last divider part (on nowhere) */
     367            rect = infoPtr->items[infoPtr->uNumItem-1].rect;
     368            rect.left = rect.right;
     369            rect.right += DIVIDER_WIDTH;
     370            if (PtInRect (&rect, *lpPt)) {
     371                if (bNoWidth) {
     372                    *pFlags |= HHT_ONDIVOPEN;
     373                    *pItem = infoPtr->uNumItem - 1;
     374//                  TRACE (header, "ON DIVOPEN %d\n", *pItem);
     375                    return;
     376                }
     377                else {
     378                    *pFlags |= HHT_ONDIVIDER;
     379                    *pItem = infoPtr->uNumItem-1;
     380//                  TRACE (header, "ON DIVIDER %d\n", *pItem);
     381                    return;
     382                }
     383            }
     384
     385            *pFlags |= HHT_NOWHERE;
     386            *pItem = 1;
     387//          TRACE (header, "NOWHERE\n");
     388            return;
     389        }
    389390    }
    390391    else {
    391         if (lpPt->x < rect.left) {
    392 //         TRACE (header, "TO LEFT\n");
    393            *pFlags |= HHT_TOLEFT;
    394         }
    395         else if (lpPt->x > rect.right) {
    396 //          TRACE (header, "TO LEFT\n");
    397             *pFlags |= HHT_TORIGHT;
    398         }
    399 
    400         if (lpPt->y < rect.top) {
    401 //          TRACE (header, "ABOVE\n");
    402             *pFlags |= HHT_ABOVE;
    403         }
    404         else if (lpPt->y > rect.bottom) {
    405 //          TRACE (header, "BELOW\n");
    406             *pFlags |= HHT_BELOW;
    407         }
     392        if (lpPt->x < rect.left) {
     393//         TRACE (header, "TO LEFT\n");
     394           *pFlags |= HHT_TOLEFT;
     395        }
     396        else if (lpPt->x > rect.right) {
     397//          TRACE (header, "TO LEFT\n");
     398            *pFlags |= HHT_TORIGHT;
     399        }
     400
     401        if (lpPt->y < rect.top) {
     402//          TRACE (header, "ABOVE\n");
     403            *pFlags |= HHT_ABOVE;
     404        }
     405        else if (lpPt->y > rect.bottom) {
     406//          TRACE (header, "BELOW\n");
     407            *pFlags |= HHT_BELOW;
     408        }
    408409    }
    409410
    … …  
    442443
    443444    return (BOOL)SendMessageA (GetParent (hwnd), WM_NOTIFY,
    444                                    (WPARAM)nmhdr.idFrom, (LPARAM)&nmhdr);
     445                                   (WPARAM)nmhdr.idFrom, (LPARAM)&nmhdr);
    445446}
    446447
    … …  
    472473
    473474    return (BOOL)SendMessageA (GetParent (hwnd), WM_NOTIFY,
    474                                (WPARAM)nmhdr.hdr.idFrom, (LPARAM)&nmhdr);
     475                               (WPARAM)nmhdr.hdr.idFrom, (LPARAM)&nmhdr);
    475476}
    476477
    … …  
    489490
    490491    return (BOOL)SendMessageA (GetParent (hwnd), WM_NOTIFY,
    491                                (WPARAM)nmhdr.hdr.idFrom, (LPARAM)&nmhdr);
     492                               (WPARAM)nmhdr.hdr.idFrom, (LPARAM)&nmhdr);
    492493}
    493494
    … …  
    509510
    510511//    TRACE(header, "[iItem=%d]\n", iItem);
    511    
     512
    512513    if ((iItem < 0) || (iItem >= (INT)infoPtr->uNumItem))
    513514        return FALSE;
    … …  
    550551    HEADER_Refresh (hwnd, hdc);
    551552    ReleaseDC (hwnd, hdc);
    552    
     553
    553554    return TRUE;
    554555}
    … …  
    573574
    574575    if (!phdi)
    575         return FALSE;
     576        return FALSE;
    576577    if ((nItem < 0) || (nItem >= (INT)infoPtr->uNumItem))
    577578        return FALSE;
    … …  
    580581
    581582    if (phdi->mask == 0)
    582         return TRUE;
     583        return TRUE;
    583584
    584585    lpItem = (HEADER_ITEM*)&infoPtr->items[nItem];
    585586    if (phdi->mask & HDI_BITMAP)
    586         phdi->hbm = lpItem->hbm;
     587        phdi->hbm = lpItem->hbm;
    587588
    588589    if (phdi->mask & HDI_FORMAT)
    589         phdi->fmt = lpItem->fmt;
     590        phdi->fmt = lpItem->fmt;
    590591
    591592    if (phdi->mask & HDI_WIDTH)
    592         phdi->cxy = lpItem->cxy;
     593        phdi->cxy = lpItem->cxy;
    593594
    594595    if (phdi->mask & HDI_LPARAM)
    595         phdi->lParam = lpItem->lParam;
     596        phdi->lParam = lpItem->lParam;
    596597
    597598    if (phdi->mask & HDI_TEXT) {
    598         if (lpItem->pszText != LPSTR_TEXTCALLBACKW)
    599             lstrcpynWtoA (phdi->pszText, lpItem->pszText, phdi->cchTextMax);
    600         else
    601             phdi->pszText = LPSTR_TEXTCALLBACKA;
     599        if (lpItem->pszText != LPSTR_TEXTCALLBACKW)
     600            lstrcpynWtoA (phdi->pszText, lpItem->pszText, MIN(phdi->cchTextMax,lstrlenW(lpItem->pszText)));
     601        else
     602            phdi->pszText = LPSTR_TEXTCALLBACKA;
    602603    }
    603604
    604605    if (phdi->mask & HDI_IMAGE)
    605         phdi->iImage = lpItem->iImage;
     606        phdi->iImage = lpItem->iImage;
    606607
    607608    if (phdi->mask & HDI_ORDER)
    608         phdi->iOrder = lpItem->iOrder;
     609        phdi->iOrder = lpItem->iOrder;
    609610
    610611    return TRUE;
    … …  
    621622
    622623    if (!phdi)
    623         return FALSE;
     624        return FALSE;
    624625    if ((nItem < 0) || (nItem >= (INT)infoPtr->uNumItem))
    625626        return FALSE;
    … …  
    628629
    629630    if (phdi->mask == 0)
    630         return TRUE;
     631        return TRUE;
    631632
    632633    lpItem = (HEADER_ITEM*)&infoPtr->items[nItem];
    633634    if (phdi->mask & HDI_BITMAP)
    634         phdi->hbm = lpItem->hbm;
     635        phdi->hbm = lpItem->hbm;
    635636
    636637    if (phdi->mask & HDI_FORMAT)
    637         phdi->fmt = lpItem->fmt;
     638        phdi->fmt = lpItem->fmt;
    638639
    639640    if (phdi->mask & HDI_WIDTH)
    640         phdi->cxy = lpItem->cxy;
     641        phdi->cxy = lpItem->cxy;
    641642
    642643    if (phdi->mask & HDI_LPARAM)
    643         phdi->lParam = lpItem->lParam;
     644        phdi->lParam = lpItem->lParam;
    644645
    645646    if (phdi->mask & HDI_TEXT) {
    646         if (lpItem->pszText != LPSTR_TEXTCALLBACKW)
    647             lstrcpynW (phdi->pszText, lpItem->pszText, phdi->cchTextMax);
    648         else
    649             phdi->pszText = LPSTR_TEXTCALLBACKW;
     647        if (lpItem->pszText != LPSTR_TEXTCALLBACKW)
     648            lstrcpynW (phdi->pszText, lpItem->pszText, MIN(phdi->cchTextMax,lstrlenW(lpItem->pszText)));
     649        else
     650            phdi->pszText = LPSTR_TEXTCALLBACKW;
    650651    }
    651652
    652653    if (phdi->mask & HDI_IMAGE)
    653         phdi->iImage = lpItem->iImage;
     654        phdi->iImage = lpItem->iImage;
    654655
    655656    if (phdi->mask & HDI_ORDER)
    656         phdi->iOrder = lpItem->iOrder;
     657        phdi->iOrder = lpItem->iOrder;
    657658
    658659    return TRUE;
    … …  
    720721
    721722    if ((phdi == NULL) || (nItem < 0))
    722         return -1;
     723        return -1;
    723724
    724725    if (nItem > infoPtr->uNumItem)
    … …  
    752753            }
    753754        }
    754    
     755
    755756        COMCTL32_Free (oldItems);
    756757    }
    … …  
    760761
    761762    if (phdi->mask & HDI_WIDTH)
    762         lpItem->cxy = phdi->cxy;
     763        lpItem->cxy = phdi->cxy;
    763764
    764765    if (phdi->mask & HDI_TEXT) {
    765         if (!phdi->pszText) /* null pointer check */
    766             phdi->pszText = "";
    767         if (phdi->pszText != LPSTR_TEXTCALLBACKA) {
    768             len = lstrlenA (phdi->pszText);
    769             lpItem->pszText = COMCTL32_Alloc ((len+1)*sizeof(WCHAR));
    770             lstrcpyAtoW (lpItem->pszText, phdi->pszText);
    771         }
    772         else
    773             lpItem->pszText = LPSTR_TEXTCALLBACKW;
     766        if (!phdi->pszText) /* null pointer check */
     767            phdi->pszText = "";
     768        if (phdi->pszText != LPSTR_TEXTCALLBACKA) {
     769            len = lstrlenA (phdi->pszText);
     770            lpItem->pszText = COMCTL32_Alloc ((len+1)*sizeof(WCHAR));
     771            lstrcpyAtoW (lpItem->pszText, phdi->pszText);
     772        }
     773        else
     774            lpItem->pszText = LPSTR_TEXTCALLBACKW;
    774775    }
    775776
    776777    if (phdi->mask & HDI_FORMAT)
    777         lpItem->fmt = phdi->fmt;
     778        lpItem->fmt = phdi->fmt;
    778779
    779780    if (lpItem->fmt == 0)
    780         lpItem->fmt = HDF_LEFT;
     781        lpItem->fmt = HDF_LEFT;
    781782
    782783    if (phdi->mask & HDI_BITMAP)
    … …  
    813814
    814815    if ((phdi == NULL) || (nItem < 0))
    815         return -1;
     816        return -1;
    816817
    817818    if (nItem > infoPtr->uNumItem)
    … …  
    839840        }
    840841
    841         COMCTL32_Free (oldItems);
     842        COMCTL32_Free (oldItems);
    842843    }
    843844
    … …  
    846847
    847848    if (phdi->mask & HDI_WIDTH)
    848         lpItem->cxy = phdi->cxy;
     849        lpItem->cxy = phdi->cxy;
    849850
    850851    if (phdi->mask & HDI_TEXT) {
    851         WCHAR wide_null_char = 0;
    852         if (!phdi->pszText) /* null pointer check */
    853             phdi->pszText = &wide_null_char;   
    854         if (phdi->pszText != LPSTR_TEXTCALLBACKW) {
    855             len = lstrlenW (phdi->pszText);
    856             lpItem->pszText = COMCTL32_Alloc ((len+1)*sizeof(WCHAR));
    857             lstrcpyW (lpItem->pszText, phdi->pszText);
    858         }
    859         else
    860             lpItem->pszText = LPSTR_TEXTCALLBACKW;
     852        WCHAR wide_null_char = 0;
     853        if (!phdi->pszText) /* null pointer check */
     854            phdi->pszText = &wide_null_char;
     855        if (phdi->pszText != LPSTR_TEXTCALLBACKW) {
     856            len = lstrlenW (phdi->pszText);
     857            lpItem->pszText = COMCTL32_Alloc ((len+1)*sizeof(WCHAR));
     858            lstrcpyW (lpItem->pszText, phdi->pszText);
     859        }
     860        else
     861            lpItem->pszText = LPSTR_TEXTCALLBACKW;
    861862    }
    862863
    863864    if (phdi->mask & HDI_FORMAT)
    864         lpItem->fmt = phdi->fmt;
     865        lpItem->fmt = phdi->fmt;
    865866
    866867    if (lpItem->fmt == 0)
    867         lpItem->fmt = HDF_LEFT;
     868        lpItem->fmt = HDF_LEFT;
    868869
    869870    if (phdi->mask & HDI_BITMAP)
    … …  
    947948
    948949    if (phdi == NULL)
    949         return FALSE;
     950        return FALSE;
    950951    if ((nItem < 0) || (nItem >= (INT)infoPtr->uNumItem))
    951952        return FALSE;
    … …  
    954955
    955956    if (HEADER_SendHeaderNotify (hwnd, HDN_ITEMCHANGINGA, nItem))
    956         return FALSE;
     957        return FALSE;
    957958
    958959    lpItem = (HEADER_ITEM*)&infoPtr->items[nItem];
    959960    if (phdi->mask & HDI_BITMAP)
    960         lpItem->hbm = phdi->hbm;
     961        lpItem->hbm = phdi->hbm;
    961962
    962963    if (phdi->mask & HDI_FORMAT)
    963         lpItem->fmt = phdi->fmt;
     964        lpItem->fmt = phdi->fmt;
    964965
    965966    if (phdi->mask & HDI_LPARAM)
    966         lpItem->lParam = phdi->lParam;
     967        lpItem->lParam = phdi->lParam;
    967968
    968969    if (phdi->mask & HDI_TEXT) {
    969         if (phdi->pszText != LPSTR_TEXTCALLBACKA) {
    970             if (lpItem->pszText) {
    971                 COMCTL32_Free (lpItem->pszText);
    972                 lpItem->pszText = NULL;
    973             }
    974             if (phdi->pszText) {
    975                 INT len = lstrlenA (phdi->pszText);
    976                 lpItem->pszText = COMCTL32_Alloc ((len+1)*sizeof(WCHAR));
    977                 lstrcpyAtoW (lpItem->pszText, phdi->pszText);
    978             }
    979         }
    980         else
    981             lpItem->pszText = LPSTR_TEXTCALLBACKW;
     970        if (phdi->pszText != LPSTR_TEXTCALLBACKA) {
     971            if (lpItem->pszText) {
     972                COMCTL32_Free (lpItem->pszText);
     973                lpItem->pszText = NULL;
     974            }
     975            if (phdi->pszText) {
     976                INT len = lstrlenA (phdi->pszText);
     977                lpItem->pszText = COMCTL32_Alloc ((len+1)*sizeof(WCHAR));
     978                lstrcpyAtoW (lpItem->pszText, phdi->pszText);
     979            }
     980        }
     981        else
     982            lpItem->pszText = LPSTR_TEXTCALLBACKW;
    982983    }
    983984
    984985    if (phdi->mask & HDI_WIDTH)
    985         lpItem->cxy = phdi->cxy;
     986        lpItem->cxy = phdi->cxy;
    986987
    987988    if (phdi->mask & HDI_IMAGE)
    988         lpItem->iImage = phdi->iImage;
     989        lpItem->iImage = phdi->iImage;
    989990
    990991    if (phdi->mask & HDI_ORDER)
    991         lpItem->iOrder = phdi->iOrder;
     992        lpItem->iOrder = phdi->iOrder;
    992993
    993994    HEADER_SendHeaderNotify (hwnd, HDN_ITEMCHANGEDA, nItem);
    … …  
    10121013
    10131014    if (phdi == NULL)
    1014         return FALSE;
     1015        return FALSE;
    10151016    if ((nItem < 0) || (nItem >= (INT)infoPtr->uNumItem))
    10161017        return FALSE;
    … …  
    10191020
    10201021    if (HEADER_SendHeaderNotify (hwnd, HDN_ITEMCHANGINGA, nItem))
    1021         return FALSE;
     1022        return FALSE;
    10221023
    10231024    lpItem = (HEADER_ITEM*)&infoPtr->items[nItem];
    10241025    if (phdi->mask & HDI_BITMAP)
    1025         lpItem->hbm = phdi->hbm;
     1026        lpItem->hbm = phdi->hbm;
    10261027
    10271028    if (phdi->mask & HDI_FORMAT)
    1028         lpItem->fmt = phdi->fmt;
     1029        lpItem->fmt = phdi->fmt;
    10291030
    10301031    if (phdi->mask & HDI_LPARAM)
    1031         lpItem->lParam = phdi->lParam;
     1032        lpItem->lParam = phdi->lParam;
    10321033
    10331034    if (phdi->mask & HDI_TEXT) {
    1034         if (phdi->pszText != LPSTR_TEXTCALLBACKW) {
    1035             if (lpItem->pszText) {
    1036                 COMCTL32_Free (lpItem->pszText);
    1037                 lpItem->pszText = NULL;
    1038             }
    1039             if (phdi->pszText) {
    1040                 INT len = lstrlenW (phdi->pszText);
    1041                 lpItem->pszText = COMCTL32_Alloc ((len+1)*sizeof(WCHAR));
    1042                 lstrcpyW (lpItem->pszText, phdi->pszText);
    1043             }
    1044         }
    1045         else
    1046             lpItem->pszText = LPSTR_TEXTCALLBACKW;
     1035        if (phdi->pszText != LPSTR_TEXTCALLBACKW) {
     1036            if (lpItem->pszText) {
     1037                COMCTL32_Free (lpItem->pszText);
     1038                lpItem->pszText = NULL;
     1039            }
     1040            if (phdi->pszText) {
     1041                INT len = lstrlenW (phdi->pszText);
     1042                lpItem->pszText = COMCTL32_Alloc ((len+1)*sizeof(WCHAR));
     1043                lstrcpyW (lpItem->pszText, phdi->pszText);
     1044            }
     1045        }
     1046        else
     1047            lpItem->pszText = LPSTR_TEXTCALLBACKW;
    10471048    }
    10481049
    10491050    if (phdi->mask & HDI_WIDTH)
    1050         lpItem->cxy = phdi->cxy;
     1051        lpItem->cxy = phdi->cxy;
    10511052
    10521053    if (phdi->mask & HDI_IMAGE)
    1053         lpItem->iImage = phdi->iImage;
     1054        lpItem->iImage = phdi->iImage;
    10541055
    10551056    if (phdi->mask & HDI_ORDER)
    1056         lpItem->iOrder = phdi->iOrder;
     1057        lpItem->iOrder = phdi->iOrder;
    10571058
    10581059    HEADER_SendHeaderNotify (hwnd, HDN_ITEMCHANGEDA, nItem);
    … …  
    11261127
    11271128    if (infoPtr->items) {
    1128         lpItem = (HEADER_ITEM*)infoPtr->items;
     1129        lpItem = (HEADER_ITEM*)infoPtr->items;
    11291130        for (nItem = 0; nItem < infoPtr->uNumItem; nItem++, lpItem++) {
    1130             if ((lpItem->pszText) && (lpItem->pszText != LPSTR_TEXTCALLBACKW))
    1131                 COMCTL32_Free (lpItem->pszText);
     1131            if ((lpItem->pszText) && (lpItem->pszText != LPSTR_TEXTCALLBACKW))
     1132                COMCTL32_Free (lpItem->pszText);
    11321133        }
    11331134        COMCTL32_Free (infoPtr->items);
    … …  
    11351136
    11361137    if (infoPtr->himl)
    1137         ImageList_Destroy (infoPtr->himl);
     1138        ImageList_Destroy (infoPtr->himl);
    11381139
    11391140    COMCTL32_Free (infoPtr);
    … …  
    11591160    INT   nItem;
    11601161
    1161     pt.x = (INT)LOWORD(lParam); 
     1162    pt.x = (INT)LOWORD(lParam);
    11621163    pt.y = (INT)HIWORD(lParam);
    11631164    HEADER_InternalHitTest (hwnd, &pt, &flags, &nItem);
    11641165
    11651166    if ((GetWindowLongA (hwnd, GWL_STYLE) & HDS_BUTTONS) && (flags == HHT_ONHEADER))
    1166         HEADER_SendHeaderNotify (hwnd, HDN_ITEMDBLCLICKA, nItem);
     1167        HEADER_SendHeaderNotify (hwnd, HDN_ITEMDBLCLICKA, nItem);
    11671168    else if ((flags == HHT_ONDIVIDER) || (flags == HHT_ONDIVOPEN))
    1168         HEADER_SendHeaderNotify (hwnd, HDN_DIVIDERDBLCLICKA, nItem);
     1169        HEADER_SendHeaderNotify (hwnd, HDN_DIVIDERDBLCLICKA, nItem);
    11691170
    11701171    return 0;
    … …  
    11821183    HDC   hdc;
    11831184
    1184     pt.x = (INT)LOWORD(lParam); 
     1185    pt.x = (INT)LOWORD(lParam);
    11851186    pt.y = (INT)HIWORD(lParam);
    11861187    HEADER_InternalHitTest (hwnd, &pt, &flags, &nItem);
    11871188
    11881189    if ((dwStyle & HDS_BUTTONS) && (flags == HHT_ONHEADER)) {
    1189         SetCapture (hwnd);
    1190         infoPtr->bCaptured = TRUE;   
    1191         infoPtr->bPressed  = TRUE;
    1192         infoPtr->iMoveItem = nItem;
    1193 
    1194         infoPtr->items[nItem].bDown = TRUE;
    1195 
    1196         /* Send WM_CUSTOMDRAW */
    1197         hdc = GetDC (hwnd);
    1198         HEADER_RefreshItem (hwnd, hdc, nItem);
    1199         ReleaseDC (hwnd, hdc);
    1200 
    1201 //      TRACE (header, "Pressed item %d!\n", nItem);
    1202     } 
     1190        SetCapture (hwnd);
     1191        infoPtr->bCaptured = TRUE;
     1192        infoPtr->bPressed  = TRUE;
     1193        infoPtr->iMoveItem = nItem;
     1194
     1195        infoPtr->items[nItem].bDown = TRUE;
     1196
     1197        /* Send WM_CUSTOMDRAW */
     1198        hdc = GetDC (hwnd);
     1199        HEADER_RefreshItem (hwnd, hdc, nItem);
     1200        ReleaseDC (hwnd, hdc);
     1201
     1202//      TRACE (header, "Pressed item %d!\n", nItem);
     1203    }
    12031204    else if ((flags == HHT_ONDIVIDER) || (flags == HHT_ONDIVOPEN)) {
    1204         if (!(HEADER_SendHeaderNotify (hwnd, HDN_BEGINTRACKA, nItem))) {
    1205             SetCapture (hwnd);
    1206             infoPtr->bCaptured = TRUE;   
    1207             infoPtr->bTracking = TRUE;
    1208             infoPtr->iMoveItem = nItem;
    1209             infoPtr->nOldWidth = infoPtr->items[nItem].cxy;
    1210             infoPtr->xTrackOffset = infoPtr->items[nItem].rect.right - pt.x;
    1211 
    1212             if (!(dwStyle & HDS_FULLDRAG)) {
    1213                 infoPtr->xOldTrack = infoPtr->items[nItem].rect.right;
    1214                 hdc = GetDC (hwnd);
    1215                 HEADER_DrawTrackLine (hwnd, hdc, infoPtr->xOldTrack);
    1216                 ReleaseDC (hwnd, hdc);
    1217             }
    1218 
    1219 //          TRACE (header, "Begin tracking item %d!\n", nItem);
    1220         }
     1205        if (!(HEADER_SendHeaderNotify (hwnd, HDN_BEGINTRACKA, nItem))) {
     1206            SetCapture (hwnd);
     1207            infoPtr->bCaptured = TRUE;
     1208            infoPtr->bTracking = TRUE;
     1209            infoPtr->iMoveItem = nItem;
     1210            infoPtr->nOldWidth = infoPtr->items[nItem].cxy;
     1211            infoPtr->xTrackOffset = infoPtr->items[nItem].rect.right - pt.x;
     1212
     1213            if (!(dwStyle & HDS_FULLDRAG)) {
     1214                infoPtr->xOldTrack = infoPtr->items[nItem].rect.right;
     1215                hdc = GetDC (hwnd);
     1216                HEADER_DrawTrackLine (hwnd, hdc, infoPtr->xOldTrack);
     1217                ReleaseDC (hwnd, hdc);
     1218            }
     1219
     1220//          TRACE (header, "Begin tracking item %d!\n", nItem);
     1221        }
    12211222    }
    12221223
    … …  
    12401241
    12411242    if (infoPtr->bPressed) {
    1242         if ((nItem == infoPtr->iMoveItem) && (flags == HHT_ONHEADER)) {
    1243             infoPtr->items[infoPtr->iMoveItem].bDown = FALSE;
    1244             hdc = GetDC (hwnd);
    1245             HEADER_RefreshItem (hwnd, hdc, infoPtr->iMoveItem);
    1246             ReleaseDC (hwnd, hdc);
    1247 
    1248             HEADER_SendClickNotify (hwnd, HDN_ITEMCLICKA, infoPtr->iMoveItem);
    1249         }
    1250 //      TRACE (header, "Released item %d!\n", infoPtr->iMoveItem);
    1251         infoPtr->bPressed = FALSE;
     1243        if ((nItem == infoPtr->iMoveItem) && (flags == HHT_ONHEADER)) {
     1244            infoPtr->items[infoPtr->iMoveItem].bDown = FALSE;
     1245            hdc = GetDC (hwnd);
     1246            HEADER_RefreshItem (hwnd, hdc, infoPtr->iMoveItem);
     1247            ReleaseDC (hwnd, hdc);
     1248
     1249            HEADER_SendClickNotify (hwnd, HDN_ITEMCLICKA, infoPtr->iMoveItem);
     1250        }
     1251//      TRACE (header, "Released item %d!\n", infoPtr->iMoveItem);
     1252        infoPtr->bPressed = FALSE;
    12521253    }
    12531254    else if (infoPtr->bTracking) {
    1254 //      TRACE (header, "End tracking item %d!\n", infoPtr->iMoveItem);
    1255         infoPtr->bTracking = FALSE;
    1256 
    1257         HEADER_SendHeaderNotify (hwnd, HDN_ENDTRACKA, infoPtr->iMoveItem);
    1258 
    1259         if (!(dwStyle & HDS_FULLDRAG)) {
    1260             hdc = GetDC (hwnd);
    1261             HEADER_DrawTrackLine (hwnd, hdc, infoPtr->xOldTrack);
    1262             ReleaseDC (hwnd, hdc);
    1263             if (HEADER_SendHeaderNotify (hwnd, HDN_ITEMCHANGINGA, infoPtr->iMoveItem))
    1264                 infoPtr->items[infoPtr->iMoveItem].cxy = infoPtr->nOldWidth;
    1265             else {
    1266                 nWidth = pt.x - infoPtr->items[infoPtr->iMoveItem].rect.left + infoPtr->xTrackOffset;
    1267                 if (nWidth < 0)
    1268                     nWidth = 0;
    1269                 infoPtr->items[infoPtr->iMoveItem].cxy = nWidth;
    1270                 HEADER_SendHeaderNotify (hwnd, HDN_ITEMCHANGEDA, infoPtr->iMoveItem);
    1271             }
    1272 
    1273             HEADER_SetItemBounds (hwnd);
    1274             hdc = GetDC (hwnd);
    1275             HEADER_Refresh (hwnd, hdc);
    1276             ReleaseDC (hwnd, hdc);
    1277         }
     1255//      TRACE (header, "End tracking item %d!\n", infoPtr->iMoveItem);
     1256        infoPtr->bTracking = FALSE;
     1257
     1258        HEADER_SendHeaderNotify (hwnd, HDN_ENDTRACKA, infoPtr->iMoveItem);
     1259
     1260        if (!(dwStyle & HDS_FULLDRAG)) {
     1261            hdc = GetDC (hwnd);
     1262            HEADER_DrawTrackLine (hwnd, hdc, infoPtr->xOldTrack);
     1263            ReleaseDC (hwnd, hdc);
     1264            if (HEADER_SendHeaderNotify (hwnd, HDN_ITEMCHANGINGA, infoPtr->iMoveItem))
     1265                infoPtr->items[infoPtr->iMoveItem].cxy = infoPtr->nOldWidth;
     1266            else {
     1267                nWidth = pt.x - infoPtr->items[infoPtr->iMoveItem].rect.left + infoPtr->xTrackOffset;
     1268                if (nWidth < 0)
     1269                    nWidth = 0;
     1270                infoPtr->items[infoPtr->iMoveItem].cxy = nWidth;
     1271                HEADER_SendHeaderNotify (hwnd, HDN_ITEMCHANGEDA, infoPtr->iMoveItem);
     1272            }
     1273
     1274            HEADER_SetItemBounds (hwnd);
     1275            hdc = GetDC (hwnd);
     1276            HEADER_Refresh (hwnd, hdc);
     1277            ReleaseDC (hwnd, hdc);
     1278        }
    12781279    }
    12791280
    12801281    if (infoPtr->bCaptured) {
    1281         infoPtr->bCaptured = FALSE;
    1282         ReleaseCapture ();
    1283         HEADER_SendSimpleNotify (hwnd, NM_RELEASEDCAPTURE);
     1282        infoPtr->bCaptured = FALSE;
     1283        ReleaseCapture ();
     1284        HEADER_SendSimpleNotify (hwnd, NM_RELEASEDCAPTURE);
    12841285    }
    12851286
    … …  
    13031304
    13041305    if ((dwStyle & HDS_BUTTONS) && (dwStyle & HDS_HOTTRACK)) {
    1305         if (flags & (HHT_ONHEADER | HHT_ONDIVIDER | HHT_ONDIVOPEN))
    1306             infoPtr->iHotItem = nItem;
    1307         else
    1308             infoPtr->iHotItem = -1;
    1309         hdc = GetDC (hwnd);
    1310         HEADER_Refresh (hwnd, hdc);
    1311         ReleaseDC (hwnd, hdc);
     1306        if (flags & (HHT_ONHEADER | HHT_ONDIVIDER | HHT_ONDIVOPEN))
     1307            infoPtr->iHotItem = nItem;
     1308        else
     1309            infoPtr->iHotItem = -1;
     1310        hdc = GetDC (hwnd);
     1311        HEADER_Refresh (hwnd, hdc);
     1312        ReleaseDC (hwnd, hdc);
    13121313    }
    13131314
    13141315    if (infoPtr->bCaptured) {
    1315         if (infoPtr->bPressed) {
    1316             if ((nItem == infoPtr->iMoveItem) && (flags == HHT_ONHEADER))
    1317                 infoPtr->items[infoPtr->iMoveItem].bDown = TRUE;
    1318             else
    1319                 infoPtr->items[infoPtr->iMoveItem].bDown = FALSE;
    1320             hdc = GetDC (hwnd);
    1321             HEADER_RefreshItem (hwnd, hdc, infoPtr->iMoveItem);
    1322             ReleaseDC (hwnd, hdc);
    1323 
    1324 //          TRACE (header, "Moving pressed item %d!\n", infoPtr->iMoveItem);
    1325         }
    1326         else if (infoPtr->bTracking) {
    1327             if (dwStyle & HDS_FULLDRAG) {
    1328                 if (HEADER_SendHeaderNotify (hwnd, HDN_ITEMCHANGINGA, infoPtr->iMoveItem))
    1329                     infoPtr->items[infoPtr->iMoveItem].cxy = infoPtr->nOldWidth;
    1330                 else {
    1331                     nWidth = pt.x - infoPtr->items[infoPtr->iMoveItem].rect.left + infoPtr->xTrackOffset;
    1332                     if (nWidth < 0)
    1333                         nWidth = 0;
    1334                     infoPtr->items[infoPtr->iMoveItem].cxy = nWidth;
    1335                     HEADER_SendHeaderNotify (hwnd, HDN_ITEMCHANGEDA,
    1336                                              infoPtr->iMoveItem);
    1337                 }
    1338                 HEADER_SetItemBounds (hwnd);
    1339                 hdc = GetDC (hwnd);
    1340                 HEADER_Refresh (hwnd, hdc);
    1341                 ReleaseDC (hwnd, hdc);
    1342             }
    1343             else {
    1344                 hdc = GetDC (hwnd);
    1345                 HEADER_DrawTrackLine (hwnd, hdc, infoPtr->xOldTrack);
    1346                 infoPtr->xOldTrack = pt.x + infoPtr->xTrackOffset;
    1347                 if (infoPtr->xOldTrack < infoPtr->items[infoPtr->iMoveItem].rect.left)
    1348                     infoPtr->xOldTrack = infoPtr->items[infoPtr->iMoveItem].rect.left;
    1349                 infoPtr->items[infoPtr->iMoveItem].cxy =
    1350                     infoPtr->xOldTrack - infoPtr->items[infoPtr->iMoveItem].rect.left;
    1351                 HEADER_DrawTrackLine (hwnd, hdc, infoPtr->xOldTrack);
    1352                 ReleaseDC (hwnd, hdc);
    1353             }
    1354 
    1355             HEADER_SendHeaderNotify (hwnd, HDN_TRACKA, infoPtr->iMoveItem);
    1356 //          TRACE (header, "Tracking item %d!\n", infoPtr->iMoveItem);
    1357         }
     1316        if (infoPtr->bPressed) {
     1317            if ((nItem == infoPtr->iMoveItem) && (flags == HHT_ONHEADER))
     1318                infoPtr->items[infoPtr->iMoveItem].bDown = TRUE;
     1319            else
     1320                infoPtr->items[infoPtr->iMoveItem].bDown = FALSE;
     1321            hdc = GetDC (hwnd);
     1322            HEADER_RefreshItem (hwnd, hdc, infoPtr->iMoveItem);
     1323            ReleaseDC (hwnd, hdc);
     1324
     1325//          TRACE (header, "Moving pressed item %d!\n", infoPtr->iMoveItem);
     1326        }
     1327        else if (infoPtr->bTracking) {
     1328            if (dwStyle & HDS_FULLDRAG) {
     1329                if (HEADER_SendHeaderNotify (hwnd, HDN_ITEMCHANGINGA, infoPtr->iMoveItem))
     1330                    infoPtr->items[infoPtr->iMoveItem].cxy = infoPtr->nOldWidth;
     1331                else {
     1332                    nWidth = pt.x - infoPtr->items[infoPtr->iMoveItem].rect.left + infoPtr->xTrackOffset;
     1333                    if (nWidth < 0)
     1334                        nWidth = 0;
     1335                    infoPtr->items[infoPtr->iMoveItem].cxy = nWidth;
     1336                    HEADER_SendHeaderNotify (hwnd, HDN_ITEMCHANGEDA,
     1337                                             infoPtr->iMoveItem);
     1338                }
     1339                HEADER_SetItemBounds (hwnd);
     1340                hdc = GetDC (hwnd);
     1341                HEADER_Refresh (hwnd, hdc);
     1342                ReleaseDC (hwnd, hdc);
     1343            }
     1344            else {
     1345                hdc = GetDC (hwnd);
     1346                HEADER_DrawTrackLine (hwnd, hdc, infoPtr->xOldTrack);
     1347                infoPtr->xOldTrack = pt.x + infoPtr->xTrackOffset;
     1348                if (infoPtr->xOldTrack < infoPtr->items[infoPtr->iMoveItem].rect.left)
     1349                    infoPtr->xOldTrack = infoPtr->items[infoPtr->iMoveItem].rect.left;
     1350                infoPtr->items[infoPtr->iMoveItem].cxy =
     1351                    infoPtr->xOldTrack - infoPtr->items[infoPtr->iMoveItem].rect.left;
     1352                HEADER_DrawTrackLine (hwnd, hdc, infoPtr->xOldTrack);
     1353                ReleaseDC (hwnd, hdc);
     1354            }
     1355
     1356            HEADER_SendHeaderNotify (hwnd, HDN_TRACKA, infoPtr->iMoveItem);
     1357//          TRACE (header, "Tracking item %d!\n", infoPtr->iMoveItem);
     1358        }
    13581359    }
    13591360
    13601361    if ((dwStyle & HDS_BUTTONS) && (dwStyle & HDS_HOTTRACK)) {
    1361 //      FIXME (header, "hot track support!\n");
     1362//      FIXME (header, "hot track support!\n");
    13621363    }
    13631364
    … …  
    13751376    HEADER_Refresh (hwnd, hdc);
    13761377    if(!wParam)
    1377         EndPaint (hwnd, &ps);
     1378        EndPaint (hwnd, &ps);
    13781379    return 0;
    13791380}
    … …  
    14471448{
    14481449    switch (msg) {
    1449         case HDM_CREATEDRAGIMAGE:
    1450             return HEADER_CreateDragImage (hwnd, wParam);
    1451 
    1452         case HDM_DELETEITEM:
    1453             return HEADER_DeleteItem (hwnd, wParam);
    1454 
    1455         case HDM_GETIMAGELIST:
    1456             return HEADER_GetImageList (hwnd);
    1457 
    1458         case HDM_GETITEMA:
    1459             return HEADER_GetItemA (hwnd, wParam, lParam);
    1460 
    1461         case HDM_GETITEMW:
    1462             return HEADER_GetItemW (hwnd, wParam, lParam);
    1463 
    1464         case HDM_GETITEMCOUNT:
    1465             return HEADER_GetItemCount (hwnd);
    1466 
    1467         case HDM_GETITEMRECT:
    1468             return HEADER_GetItemRect (hwnd, wParam, lParam);
    1469 
    1470 /*      case HDM_GETORDERARRAY: */
    1471 
    1472         case HDM_GETUNICODEFORMAT:
    1473             return HEADER_GetUnicodeFormat (hwnd);
    1474 
    1475         case HDM_HITTEST:
    1476             return HEADER_HitTest (hwnd, wParam, lParam);
    1477 
    1478         case HDM_INSERTITEMA:
    1479             return HEADER_InsertItemA (hwnd, wParam, lParam);
    1480 
    1481         case HDM_INSERTITEMW:
    1482             return HEADER_InsertItemW (hwnd, wParam, lParam);
    1483 
    1484         case HDM_LAYOUT:
    1485             return HEADER_Layout (hwnd, wParam, lParam);
    1486 
    1487         case HDM_SETIMAGELIST:
    1488             return HEADER_SetImageList (hwnd, wParam, lParam);
    1489 
    1490         case HDM_SETITEMA:
    1491             return HEADER_SetItemA (hwnd, wParam, lParam);
    1492 
    1493         case HDM_SETITEMW:
    1494             return HEADER_SetItemW (hwnd, wParam, lParam);
    1495 
    1496 /*      case HDM_SETORDERARRAY: */
    1497 
    1498         case HDM_SETUNICODEFORMAT:
    1499             return HEADER_SetUnicodeFormat (hwnd, wParam);
     1450        case HDM_CREATEDRAGIMAGE:
     1451            return HEADER_CreateDragImage (hwnd, wParam);
     1452
     1453        case HDM_DELETEITEM:
     1454            return HEADER_DeleteItem (hwnd, wParam);
     1455
     1456        case HDM_GETIMAGELIST:
     1457            return HEADER_GetImageList (hwnd);
     1458
     1459        case HDM_GETITEMA:
     1460            return HEADER_GetItemA (hwnd, wParam, lParam);
     1461
     1462        case HDM_GETITEMW:
     1463            return HEADER_GetItemW (hwnd, wParam, lParam);
     1464
     1465        case HDM_GETITEMCOUNT:
     1466            return HEADER_GetItemCount (hwnd);
     1467
     1468        case HDM_GETITEMRECT:
     1469            return HEADER_GetItemRect (hwnd, wParam, lParam);
     1470
     1471/*      case HDM_GETORDERARRAY: */
     1472
     1473        case HDM_GETUNICODEFORMAT:
     1474            return HEADER_GetUnicodeFormat (hwnd);
     1475
     1476        case HDM_HITTEST:
     1477            return HEADER_HitTest (hwnd, wParam, lParam);
     1478
     1479        case HDM_INSERTITEMA:
     1480            return HEADER_InsertItemA (hwnd, wParam, lParam);
     1481
     1482        case HDM_INSERTITEMW:
     1483            return HEADER_InsertItemW (hwnd, wParam, lParam);
     1484
     1485        case HDM_LAYOUT:
     1486            return HEADER_Layout (hwnd, wParam, lParam);
     1487
     1488        case HDM_SETIMAGELIST:
     1489            return HEADER_SetImageList (hwnd, wParam, lParam);
     1490
     1491        case HDM_SETITEMA:
     1492            return HEADER_SetItemA (hwnd, wParam, lParam);
     1493
     1494        case HDM_SETITEMW:
     1495            return HEADER_SetItemW (hwnd, wParam, lParam);
     1496
     1497/*      case HDM_SETORDERARRAY: */
     1498
     1499        case HDM_SETUNICODEFORMAT:
     1500            return HEADER_SetUnicodeFormat (hwnd, wParam);
    15001501
    15011502
    … …  
    15271528            return HEADER_MouseMove (hwnd, wParam, lParam);
    15281529
    1529 /*      case WM_NOTIFYFORMAT: */
     1530/*      case WM_NOTIFYFORMAT: */
    15301531
    15311532        case WM_PAINT:
    … …  
    15421543
    15431544        default:
    1544 //            if (msg >= WM_USER) 
    1545 //              ERR (header, "unknown msg %04x wp=%04x lp=%08lx\n",
    1546 //                   msg, wParam, lParam );
    1547             return DefWindowProcA (hwnd, msg, wParam, lParam);
     1545//            if (msg >= WM_USER)
     1546//              ERR (header, "unknown msg %04x wp=%04x lp=%08lx\n",
     1547//                   msg, wParam, lParam );
     1548            return DefWindowProcA (hwnd, msg, wParam, lParam);
    15481549    }
    15491550    return 0;
    … …  
    15651566    wndClass.hCursor       = LoadCursorA (0, IDC_ARROWA);
    15661567    wndClass.lpszClassName = WC_HEADERA;
    1567  
     1568
    15681569    RegisterClassA (&wndClass);
    15691570}
    … …  
    15741575{
    15751576    if (GlobalFindAtomA (WC_HEADERA))
    1576         UnregisterClassA (WC_HEADERA, (HINSTANCE)NULL);
    1577 }
    1578 
     1577        UnregisterClassA (WC_HEADERA, (HINSTANCE)NULL);
     1578}
     1579
Note: See TracChangeset for help on using the changeset viewer.