Ignore:
Timestamp:
Jun 16, 1999, 10:25:45 PM (26 years ago)
Author:
cbratschi
Message:

comctl32 wine conversion bugs fixed
trackbar: TRACKBAR_Draw prototype

File:
1 edited

Legend:

Unmodified
Added
Removed

  • trunk/src/comctl32/toolbar.c

    r94 r110  
    1 /* $Id: toolbar.c,v 1.4 1999-06-10 16:22:02 achimha Exp $ */
     1/* $Id: toolbar.c,v 1.5 1999-06-16 20:25:43 cbratschi Exp $ */
    22/*
    33 * Toolbar control
    … …  
    55 * Copyright 1998,1999 Eric Kohl
    66 * Copyright 1999 Achim Hasenmueller
     7 * Copyright 1999 Christoph Bratschi
    78 *
    89 * TODO:
    … …  
    6566static void
    6667TOOLBAR_DrawString (TOOLBAR_INFO *infoPtr, TBUTTON_INFO *btnPtr,
    67                     HDC hdc, INT nState)
     68                    HDC hdc, INT nState)
    6869{
    6970    RECT   rcText = btnPtr->rect;
    … …  
    7475    /* draw text */
    7576    if ((btnPtr->iString > -1) && (btnPtr->iString < infoPtr->nNumStrings)) {
    76         InflateRect (&rcText, -3, -3);
    77         rcText.top += infoPtr->nBitmapHeight;
    78         if (nState & (TBSTATE_PRESSED | TBSTATE_CHECKED))
    79             OffsetRect (&rcText, 1, 1);
    80 
    81         hOldFont = SelectObject (hdc, infoPtr->hFont);
    82         nOldBkMode = SetBkMode (hdc, TRANSPARENT);
    83         if (!(nState & TBSTATE_ENABLED)) {
    84             clrOld = SetTextColor (hdc, GetSysColor (COLOR_3DHILIGHT));
    85             OffsetRect (&rcText, 1, 1);
    86             DrawTextW (hdc, infoPtr->strings[btnPtr->iString], -1,
    87                         &rcText, infoPtr->dwDTFlags);
    88             SetTextColor (hdc, GetSysColor (COLOR_3DSHADOW));
    89             OffsetRect (&rcText, -1, -1);
    90             DrawTextW (hdc, infoPtr->strings[btnPtr->iString], -1,
    91                         &rcText, infoPtr->dwDTFlags);
    92         }
    93         else if (nState & TBSTATE_INDETERMINATE) {
    94             clrOld = SetTextColor (hdc, GetSysColor (COLOR_3DSHADOW));
    95             DrawTextW (hdc, infoPtr->strings[btnPtr->iString], -1,
    96                         &rcText, infoPtr->dwDTFlags);
    97         }
    98         else {
    99             clrOld = SetTextColor (hdc, GetSysColor (COLOR_BTNTEXT));
    100             DrawTextW (hdc, infoPtr->strings[btnPtr->iString], -1,
    101                         &rcText, infoPtr->dwDTFlags);
    102         }
    103 
    104         SetTextColor (hdc, clrOld);
    105         SelectObject (hdc, hOldFont);
    106         if (nOldBkMode != TRANSPARENT)
    107             SetBkMode (hdc, nOldBkMode);
     77        InflateRect (&rcText, -3, -3);
     78        rcText.top += infoPtr->nBitmapHeight;
     79        if (nState & (TBSTATE_PRESSED | TBSTATE_CHECKED))
     80            OffsetRect (&rcText, 1, 1);
     81
     82        hOldFont = SelectObject (hdc, infoPtr->hFont);
     83        nOldBkMode = SetBkMode (hdc, TRANSPARENT);
     84        if (!(nState & TBSTATE_ENABLED)) {
     85            clrOld = SetTextColor (hdc, GetSysColor (COLOR_3DHILIGHT));
     86            OffsetRect (&rcText, 1, 1);
     87            DrawTextW (hdc, infoPtr->strings[btnPtr->iString], -1,
     88                        &rcText, infoPtr->dwDTFlags);
     89            SetTextColor (hdc, GetSysColor (COLOR_3DSHADOW));
     90            OffsetRect (&rcText, -1, -1);
     91            DrawTextW (hdc, infoPtr->strings[btnPtr->iString], -1,
     92                        &rcText, infoPtr->dwDTFlags);
     93        }
     94        else if (nState & TBSTATE_INDETERMINATE) {
     95            clrOld = SetTextColor (hdc, GetSysColor (COLOR_3DSHADOW));
     96            DrawTextW (hdc, infoPtr->strings[btnPtr->iString], -1,
     97                        &rcText, infoPtr->dwDTFlags);
     98        }
     99        else {
     100            clrOld = SetTextColor (hdc, GetSysColor (COLOR_BTNTEXT));
     101            DrawTextW (hdc, infoPtr->strings[btnPtr->iString], -1,
     102                        &rcText, infoPtr->dwDTFlags);
     103        }
     104
     105        SetTextColor (hdc, clrOld);
     106        SelectObject (hdc, hOldFont);
     107        if (nOldBkMode != TRANSPARENT)
     108            SetBkMode (hdc, nOldBkMode);
    108109    }
    109110}
    … …  
    123124static void
    124125TOOLBAR_DrawMasked (TOOLBAR_INFO *infoPtr, TBUTTON_INFO *btnPtr,
    125                     HDC hdc, INT x, INT y)
     126                    HDC hdc, INT x, INT y)
    126127{
    127128    /* FIXME: this function is a hack since it uses image list
    128               internals directly */
     129              internals directly */
    129130
    130131    HDC hdcImageList = CreateCompatibleDC (0);
    … …  
    142143    SetTextColor (hdcImageList, RGB(0, 0, 0));
    143144    BitBlt (hdcMask, 0, 0, himl->cx, himl->cy,
    144               hdcImageList, himl->cx * btnPtr->iBitmap, 0, SRCCOPY);
     145              hdcImageList, himl->cx * btnPtr->iBitmap, 0, SRCCOPY);
    145146
    146147#if 0
    … …  
    149150    SetBkColor (hdcImageList, RGB(0, 0, 0));
    150151    BitBlt (hdcMask, 0, 0, himl->cx, himl->cy,
    151               hdcImageList, himl->cx * btnPtr->iBitmap, 0, MERGEPAINT);
     152              hdcImageList, himl->cx * btnPtr->iBitmap, 0, MERGEPAINT);
    152153#endif
    153154
    … …  
    155156    SelectObject (hdc, GetSysColorBrush (COLOR_3DHILIGHT));
    156157    BitBlt (hdc, x+1, y+1, himl->cx, himl->cy,
    157               hdcMask, 0, 0, 0xB8074A);
     158              hdcMask, 0, 0, 0xB8074A);
    158159
    159160    SelectObject (hdc, GetSysColorBrush (COLOR_3DSHADOW));
    160161    BitBlt (hdc, x, y, himl->cx, himl->cy,
    161               hdcMask, 0, 0, 0xB8074A);
     162              hdcMask, 0, 0, 0xB8074A);
    162163
    163164    DeleteObject (hbmMask);
    … …  
    175176
    176177    if (btnPtr->fsState & TBSTATE_HIDDEN)
    177         return;
     178        return;
    178179
    179180    rc = btnPtr->rect;
    180181    if (btnPtr->fsStyle & TBSTYLE_SEP) {
    181         if ((dwStyle & TBSTYLE_FLAT) && (btnPtr->idCommand == 0))
    182             TOOLBAR_DrawFlatSeparator (&btnPtr->rect, hdc);
    183         return;
     182        if ((dwStyle & TBSTYLE_FLAT) && (btnPtr->idCommand == 0))
     183            TOOLBAR_DrawFlatSeparator (&btnPtr->rect, hdc);
     184        return;
    184185    }
    185186
    186187    /* disabled */
    187188    if (!(btnPtr->fsState & TBSTATE_ENABLED)) {
    188         DrawEdge (hdc, &rc, EDGE_RAISED,
    189                     BF_SOFT | BF_RECT | BF_MIDDLE | BF_ADJUST);
    190 
    191         if (dwStyle & TBSTYLE_FLAT) {
    192 /*          if (infoPtr->himlDis) */
    193                 ImageList_Draw (infoPtr->himlDis, btnPtr->iBitmap, hdc,
    194                                 rc.left+1, rc.top+1, ILD_NORMAL);
    195 /*          else */
    196 /*              TOOLBAR_DrawMasked (infoPtr, btnPtr, hdc, rc.left+1, rc.top+1); */
    197         }
    198         else
    199             TOOLBAR_DrawMasked (infoPtr, btnPtr, hdc, rc.left+1, rc.top+1);
    200 
    201         TOOLBAR_DrawString (infoPtr, btnPtr, hdc, btnPtr->fsState);
    202         return;
     189        DrawEdge (hdc, &rc, EDGE_RAISED,
     190                    BF_SOFT | BF_RECT | BF_MIDDLE | BF_ADJUST);
     191
     192        if (dwStyle & TBSTYLE_FLAT) {
     193/*          if (infoPtr->himlDis) */
     194                ImageList_Draw (infoPtr->himlDis, btnPtr->iBitmap, hdc,
     195                                rc.left+1, rc.top+1, ILD_NORMAL);
     196/*          else */
     197/*              TOOLBAR_DrawMasked (infoPtr, btnPtr, hdc, rc.left+1, rc.top+1); */
     198        }
     199        else
     200            TOOLBAR_DrawMasked (infoPtr, btnPtr, hdc, rc.left+1, rc.top+1);
     201
     202        TOOLBAR_DrawString (infoPtr, btnPtr, hdc, btnPtr->fsState);
     203        return;
    203204    }
    204205
    205206    /* pressed TBSTYLE_BUTTON */
    206207    if (btnPtr->fsState & TBSTATE_PRESSED) {
    207         DrawEdge (hdc, &rc, EDGE_SUNKEN, BF_RECT | BF_MIDDLE | BF_ADJUST);
    208         ImageList_Draw (infoPtr->himlStd, btnPtr->iBitmap, hdc,
    209                         rc.left+2, rc.top+2, ILD_NORMAL);
    210         TOOLBAR_DrawString (infoPtr, btnPtr, hdc, btnPtr->fsState);
    211         return;
     208        DrawEdge (hdc, &rc, EDGE_SUNKEN, BF_RECT | BF_MIDDLE | BF_ADJUST);
     209        ImageList_Draw (infoPtr->himlStd, btnPtr->iBitmap, hdc,
     210                        rc.left+2, rc.top+2, ILD_NORMAL);
     211        TOOLBAR_DrawString (infoPtr, btnPtr, hdc, btnPtr->fsState);
     212        return;
    212213    }
    213214
    214215    /* checked TBSTYLE_CHECK*/
    215216    if ((btnPtr->fsStyle & TBSTYLE_CHECK) &&
    216         (btnPtr->fsState & TBSTATE_CHECKED)) {
    217         if (dwStyle & TBSTYLE_FLAT)
    218             DrawEdge (hdc, &rc, BDR_SUNKENOUTER,
    219                         BF_RECT | BF_MIDDLE | BF_ADJUST);
    220         else
    221             DrawEdge (hdc, &rc, EDGE_SUNKEN,
    222                         BF_RECT | BF_MIDDLE | BF_ADJUST);
    223 
    224         TOOLBAR_DrawPattern (hdc, &rc);
    225         if (dwStyle & TBSTYLE_FLAT)
    226         {
    227             if (infoPtr->himlDef != NULL)
    228             ImageList_Draw (infoPtr->himlDef, btnPtr->iBitmap, hdc,
    229                             rc.left+2, rc.top+2, ILD_NORMAL);
    230         else
    231             ImageList_Draw (infoPtr->himlStd, btnPtr->iBitmap, hdc,
    232                             rc.left+2, rc.top+2, ILD_NORMAL);
    233         }
    234         else
    235             ImageList_Draw (infoPtr->himlStd, btnPtr->iBitmap, hdc,
    236                             rc.left+2, rc.top+2, ILD_NORMAL);
    237         TOOLBAR_DrawString (infoPtr, btnPtr, hdc, btnPtr->fsState);
    238         return;
    239     }
    240 
    241     /* indeterminate */ 
     217        (btnPtr->fsState & TBSTATE_CHECKED)) {
     218        if (dwStyle & TBSTYLE_FLAT)
     219            DrawEdge (hdc, &rc, BDR_SUNKENOUTER,
     220                        BF_RECT | BF_MIDDLE | BF_ADJUST);
     221        else
     222            DrawEdge (hdc, &rc, EDGE_SUNKEN,
     223                        BF_RECT | BF_MIDDLE | BF_ADJUST);
     224
     225        TOOLBAR_DrawPattern (hdc, &rc);
     226        if (dwStyle & TBSTYLE_FLAT)
     227        {
     228            if (infoPtr->himlDef != NULL)
     229            ImageList_Draw (infoPtr->himlDef, btnPtr->iBitmap, hdc,
     230                            rc.left+2, rc.top+2, ILD_NORMAL);
     231        else
     232            ImageList_Draw (infoPtr->himlStd, btnPtr->iBitmap, hdc,
     233                            rc.left+2, rc.top+2, ILD_NORMAL);
     234        }
     235        else
     236            ImageList_Draw (infoPtr->himlStd, btnPtr->iBitmap, hdc,
     237                            rc.left+2, rc.top+2, ILD_NORMAL);
     238        TOOLBAR_DrawString (infoPtr, btnPtr, hdc, btnPtr->fsState);
     239        return;
     240    }
     241
     242    /* indeterminate */
    242243    if (btnPtr->fsState & TBSTATE_INDETERMINATE) {
    243         DrawEdge (hdc, &rc, EDGE_RAISED,
    244                     BF_SOFT | BF_RECT | BF_MIDDLE | BF_ADJUST);
    245 
    246         TOOLBAR_DrawPattern (hdc, &rc);
    247         TOOLBAR_DrawMasked (infoPtr, btnPtr, hdc, rc.left+1, rc.top+1);
    248         TOOLBAR_DrawString (infoPtr, btnPtr, hdc, btnPtr->fsState);
    249         return;
     244        DrawEdge (hdc, &rc, EDGE_RAISED,
     245                    BF_SOFT | BF_RECT | BF_MIDDLE | BF_ADJUST);
     246
     247        TOOLBAR_DrawPattern (hdc, &rc);
     248        TOOLBAR_DrawMasked (infoPtr, btnPtr, hdc, rc.left+1, rc.top+1);
     249        TOOLBAR_DrawString (infoPtr, btnPtr, hdc, btnPtr->fsState);
     250        return;
    250251    }
    251252
    252253    if (dwStyle & TBSTYLE_FLAT)
    253254    {
    254         if(btnPtr->bHot)
    255             DrawEdge (hdc, &rc, BDR_RAISEDINNER,
    256                        BF_RECT | BF_MIDDLE | BF_SOFT);
    257 
    258         if(infoPtr->himlDef != NULL)
    259             ImageList_Draw (infoPtr->himlDef, btnPtr->iBitmap, hdc,
    260                             rc.left +2, rc.top +2, ILD_NORMAL);
    261         else
    262             ImageList_Draw (infoPtr->himlStd, btnPtr->iBitmap, hdc,
    263                             rc.left +2, rc.top +2, ILD_NORMAL);
     255        if(btnPtr->bHot)
     256            DrawEdge (hdc, &rc, BDR_RAISEDINNER,
     257                       BF_RECT | BF_MIDDLE | BF_SOFT);
     258
     259        if(infoPtr->himlDef != NULL)
     260            ImageList_Draw (infoPtr->himlDef, btnPtr->iBitmap, hdc,
     261                            rc.left +2, rc.top +2, ILD_NORMAL);
     262        else
     263            ImageList_Draw (infoPtr->himlStd, btnPtr->iBitmap, hdc,
     264                            rc.left +2, rc.top +2, ILD_NORMAL);
    264265    }
    265266    else{
    266267    /* normal state */
    267268    DrawEdge (hdc, &rc, EDGE_RAISED,
    268                 BF_SOFT | BF_RECT | BF_MIDDLE | BF_ADJUST);
    269 
    270         ImageList_Draw (infoPtr->himlStd, btnPtr->iBitmap, hdc,
    271                         rc.left+1, rc.top+1, ILD_NORMAL);
     269                BF_SOFT | BF_RECT | BF_MIDDLE | BF_ADJUST);
     270
     271        ImageList_Draw (infoPtr->himlStd, btnPtr->iBitmap, hdc,
     272                        rc.left+1, rc.top+1, ILD_NORMAL);
    272273    }
    273274
    … …  
    286287    btnPtr = infoPtr->buttons;
    287288    for (i = 0; i < infoPtr->nNumButtons; i++, btnPtr++)
    288         TOOLBAR_DrawButton (hwnd, btnPtr, hdc);
     289        TOOLBAR_DrawButton (hwnd, btnPtr, hdc);
    289290}
    290291
    … …  
    307308    btnPtr = infoPtr->buttons;
    308309    for (i = 0; i < infoPtr->nNumButtons; i++, btnPtr++) {
    309         if (!(btnPtr->fsState & TBSTATE_HIDDEN) &&
    310             (btnPtr->iString > -1) &&
    311             (btnPtr->iString < infoPtr->nNumStrings)) {
    312             LPWSTR lpText = infoPtr->strings[btnPtr->iString];
    313             GetTextExtentPoint32W (hdc, lpText, lstrlenW (lpText), &sz);
    314             if (sz.cx > lpSize->cx)
    315                 lpSize->cx = sz.cx;
    316             if (sz.cy > lpSize->cy)
    317                 lpSize->cy = sz.cy;
    318         }
     310        if (!(btnPtr->fsState & TBSTATE_HIDDEN) &&
     311            (btnPtr->iString > -1) &&
     312            (btnPtr->iString < infoPtr->nNumStrings)) {
     313            LPWSTR lpText = infoPtr->strings[btnPtr->iString];
     314            GetTextExtentPoint32W (hdc, lpText, lstrlenW (lpText), &sz);
     315            if (sz.cx > lpSize->cx)
     316                lpSize->cx = sz.cx;
     317            if (sz.cy > lpSize->cy)
     318                lpSize->cy = sz.cy;
     319        }
    319320    }
    320321
    … …  
    326327
    327328/***********************************************************************
    328 *               TOOLBAR_WrapToolbar
     329*               TOOLBAR_WrapToolbar
    329330*
    330 * This function walks through the buttons and seperators in the 
    331 * toolbar, and sets the TBSTATE_WRAP flag only on those items where 
    332 * wrapping should occur based on the width of the toolbar window. 
    333 * It does *not* calculate button placement itself.  That task 
    334 * takes place in TOOLBAR_CalcToolbar. If the program wants to manage 
    335 * the toolbar wrapping on it's own, it can use the TBSTYLE_WRAPPABLE 
     331* This function walks through the buttons and seperators in the
     332* toolbar, and sets the TBSTATE_WRAP flag only on those items where
     333* wrapping should occur based on the width of the toolbar window.
     334* It does *not* calculate button placement itself.  That task
     335* takes place in TOOLBAR_CalcToolbar. If the program wants to manage
     336* the toolbar wrapping on it's own, it can use the TBSTYLE_WRAPPABLE
    336337* flag, and set the TBSTATE_WRAP flags manually on the appropriate items.
    337 */ 
     338*/
    338339
    339340static void
    … …  
    347348    BOOL bWrap, bButtonWrap;
    348349
    349     /*  When the toolbar window style is not TBSTYLE_WRAPABLE,  */
    350     /*  no layout is necessary. Applications may use this style */
    351     /*  to perform their own layout on the toolbar.             */
     350    /*  When the toolbar window style is not TBSTYLE_WRAPABLE,  */
     351    /*  no layout is necessary. Applications may use this style */
     352    /*  to perform their own layout on the toolbar.             */
    352353    if( !(dwStyle & TBSTYLE_WRAPABLE) )
    353         return;
     354        return;
    354355
    355356    btnPtr = infoPtr->buttons;
    … …  
    362363    for (i = 0; i < infoPtr->nNumButtons; i++ )
    363364    {
    364         bWrap = FALSE;
    365         btnPtr[i].fsState &= ~TBSTATE_WRAP;
    366        
    367         if (btnPtr[i].fsState & TBSTATE_HIDDEN)
    368             continue;
    369 
    370         /* UNDOCUMENTED: If a separator has a non zero bitmap index, */
    371         /* it is the actual width of the separator. This is used for */
    372         /* custom controls in toolbars.                              */
    373         if (btnPtr[i].fsStyle & TBSTYLE_SEP)
    374             cx = (btnPtr[i].iBitmap > 0) ? 
    375                         btnPtr[i].iBitmap : SEPARATOR_WIDTH;
    376         else
    377             cx = infoPtr->nButtonWidth;
    378 
    379         /* Two or more adjacent separators form a separator group.   */
    380         /* The first separator in a group should be wrapped to the   */
    381         /* next row if the previous wrapping is on a button.         */
    382         if( bButtonWrap &&
    383                 (btnPtr[i].fsStyle & TBSTYLE_SEP) &&
    384                 (i + 1 < infoPtr->nNumButtons ) &&
    385                 (btnPtr[i + 1].fsStyle & TBSTYLE_SEP) )
    386         {
    387             btnPtr[i].fsState |= TBSTATE_WRAP;
    388             x = infoPtr->nIndent;
    389             i++;
    390             bButtonWrap = FALSE;
    391             continue;
    392         }
    393 
    394         /* The layout makes sure the bitmap is visible, but not the button. */
    395         if ( x + cx - (infoPtr->nButtonWidth - infoPtr->nBitmapWidth) / 2
    396                  > infoPtr->nWidth )
    397         {
    398             BOOL bFound = FALSE;
    399 
    400             /*  If the current button is a separator and not hidden,  */
    401             /*  go to the next until it reaches a non separator.      */
    402             /*  Wrap the last separator if it is before a button.     */
    403             while( ( (btnPtr[i].fsStyle & TBSTYLE_SEP) ||
    404                         (btnPtr[i].fsState & TBSTATE_HIDDEN) ) &&
    405                         i < infoPtr->nNumButtons )
    406             {
    407                 i++;
    408                 bFound = TRUE;
    409             }
    410    
    411             if( bFound && i < infoPtr->nNumButtons )
    412             {
    413                 i--;
    414                 btnPtr[i].fsState |= TBSTATE_WRAP;
    415                 x = infoPtr->nIndent;
    416                 bButtonWrap = FALSE;
    417                 continue;
    418             }
    419             else if ( i >= infoPtr->nNumButtons)
    420                 break;
    421 
    422             /*  If the current button is not a separator, find the last  */
    423             /*  separator and wrap it.                                  */
    424             for ( j = i - 1; j >= 0  &&  !(btnPtr[j].fsState & TBSTATE_WRAP); j--)
    425             {
    426                 if ((btnPtr[j].fsStyle & TBSTYLE_SEP) &&
    427                         !(btnPtr[j].fsState & TBSTATE_HIDDEN))
    428                 {
    429                     bFound = TRUE;
    430                     i = j;
    431                     x = infoPtr->nIndent;
    432                     btnPtr[j].fsState |= TBSTATE_WRAP;
    433                     bButtonWrap = FALSE;
    434                     break;
    435                 }
    436             }
    437 
    438             /*  If no separator available for wrapping, wrap one of     */
    439             /*  non-hidden previous button.                             */
    440             if (!bFound)
    441             {
    442                 for ( j = i - 1;
    443                         j >= 0 && !(btnPtr[j].fsState & TBSTATE_WRAP); j--)
    444                 {
    445                     if (btnPtr[j].fsState & TBSTATE_HIDDEN)
    446                         continue;
    447 
    448                     bFound = TRUE;
    449                     i = j;
    450                     x = infoPtr->nIndent;
    451                     btnPtr[j].fsState |= TBSTATE_WRAP;
    452                     bButtonWrap = TRUE;
    453                     break;
    454                 }
    455             }
    456 
    457             /* If all above failed, wrap the current button. */
    458             if (!bFound) 
    459             {
    460                 btnPtr[i].fsState |= TBSTATE_WRAP;
    461                 bFound = TRUE;
    462                 x = infoPtr->nIndent;
    463                 if (btnPtr[i].fsState & TBSTYLE_SEP )
    464                     bButtonWrap = FALSE;
    465                 else
    466                     bButtonWrap = TRUE;
    467             }               
    468         }
    469         else
    470             x += cx;
    471     }
    472 }
    473                                                                                        
     365        bWrap = FALSE;
     366        btnPtr[i].fsState &= ~TBSTATE_WRAP;
     367
     368        if (btnPtr[i].fsState & TBSTATE_HIDDEN)
     369            continue;
     370
     371        /* UNDOCUMENTED: If a separator has a non zero bitmap index, */
     372        /* it is the actual width of the separator. This is used for */
     373        /* custom controls in toolbars.                              */
     374        if (btnPtr[i].fsStyle & TBSTYLE_SEP)
     375            cx = (btnPtr[i].iBitmap > 0) ?
     376                        btnPtr[i].iBitmap : SEPARATOR_WIDTH;
     377        else
     378            cx = infoPtr->nButtonWidth;
     379
     380        /* Two or more adjacent separators form a separator group.   */
     381        /* The first separator in a group should be wrapped to the   */
     382        /* next row if the previous wrapping is on a button.         */
     383        if( bButtonWrap &&
     384                (btnPtr[i].fsStyle & TBSTYLE_SEP) &&
     385                (i + 1 < infoPtr->nNumButtons ) &&
     386                (btnPtr[i + 1].fsStyle & TBSTYLE_SEP) )
     387        {
     388            btnPtr[i].fsState |= TBSTATE_WRAP;
     389            x = infoPtr->nIndent;
     390            i++;
     391            bButtonWrap = FALSE;
     392            continue;
     393        }
     394
     395        /* The layout makes sure the bitmap is visible, but not the button. */
     396        if ( x + cx - (infoPtr->nButtonWidth - infoPtr->nBitmapWidth) / 2
     397                 > infoPtr->nWidth )
     398        {
     399            BOOL bFound = FALSE;
     400
     401            /*  If the current button is a separator and not hidden,  */
     402            /*  go to the next until it reaches a non separator.      */
     403            /*  Wrap the last separator if it is before a button.     */
     404            while( ( (btnPtr[i].fsStyle & TBSTYLE_SEP) ||
     405                        (btnPtr[i].fsState & TBSTATE_HIDDEN) ) &&
     406                        i < infoPtr->nNumButtons )
     407            {
     408                i++;
     409                bFound = TRUE;
     410            }
     411
     412            if( bFound && i < infoPtr->nNumButtons )
     413            {
     414                i--;
     415                btnPtr[i].fsState |= TBSTATE_WRAP;
     416                x = infoPtr->nIndent;
     417                bButtonWrap = FALSE;
     418                continue;
     419            }
     420            else if ( i >= infoPtr->nNumButtons)
     421                break;
     422
     423            /*  If the current button is not a separator, find the last  */
     424            /*  separator and wrap it.                                  */
     425            for ( j = i - 1; j >= 0  &&  !(btnPtr[j].fsState & TBSTATE_WRAP); j--)
     426            {
     427                if ((btnPtr[j].fsStyle & TBSTYLE_SEP) &&
     428                        !(btnPtr[j].fsState & TBSTATE_HIDDEN))
     429                {
     430                    bFound = TRUE;
     431                    i = j;
     432                    x = infoPtr->nIndent;
     433                    btnPtr[j].fsState |= TBSTATE_WRAP;
     434                    bButtonWrap = FALSE;
     435                    break;
     436                }
     437            }
     438
     439            /*  If no separator available for wrapping, wrap one of     */
     440            /*  non-hidden previous button.                             */
     441            if (!bFound)
     442            {
     443                for ( j = i - 1;
     444                        j >= 0 && !(btnPtr[j].fsState & TBSTATE_WRAP); j--)
     445                {
     446                    if (btnPtr[j].fsState & TBSTATE_HIDDEN)
     447                        continue;
     448
     449                    bFound = TRUE;
     450                    i = j;
     451                    x = infoPtr->nIndent;
     452                    btnPtr[j].fsState |= TBSTATE_WRAP;
     453                    bButtonWrap = TRUE;
     454                    break;
     455                }
     456            }
     457
     458            /* If all above failed, wrap the current button. */
     459            if (!bFound)
     460            {
     461                btnPtr[i].fsState |= TBSTATE_WRAP;
     462                bFound = TRUE;
     463                x = infoPtr->nIndent;
     464                if (btnPtr[i].fsState & TBSTYLE_SEP )
     465                    bButtonWrap = FALSE;
     466                else
     467                    bButtonWrap = TRUE;
     468            }
     469        }
     470        else
     471            x += cx;
     472    }
     473}
     474
    474475/***********************************************************************
    475 *               TOOLBAR_CalcToolbar
     476*               TOOLBAR_CalcToolbar
    476477*
    477 * This function calculates button and separator placement. It first 
    478 * calculates the button sizes, gets the toolbar window width and then 
    479 * calls TOOLBAR_WrapToolbar to determine which buttons we need to wrap 
     478* This function calculates button and separator placement. It first
     479* calculates the button sizes, gets the toolbar window width and then
     480* calls TOOLBAR_WrapToolbar to determine which buttons we need to wrap
    480481* on. It assigns a new location to each item and sends this location to
    481 * the tooltip window if appropriate. Finally, it updates the rcBound 
    482 * rect and calculates the new required toolbar window height. 
    483 */ 
     482* the tooltip window if appropriate. Finally, it updates the rcBound
     483* rect and calculates the new required toolbar window height.
     484*/
    484485
    485486static void
    … …  
    497498
    498499    if (sizeString.cy > 0)
    499         infoPtr->nButtonHeight = sizeString.cy + infoPtr->nBitmapHeight + 6;
     500        infoPtr->nButtonHeight = sizeString.cy + infoPtr->nBitmapHeight + 6;
    500501    else if (infoPtr->nButtonHeight < infoPtr->nBitmapHeight + 6)
    501         infoPtr->nButtonHeight = infoPtr->nBitmapHeight + 6;
     502        infoPtr->nButtonHeight = infoPtr->nBitmapHeight + 6;
    502503
    503504    if (sizeString.cx > infoPtr->nBitmapWidth)
    504         infoPtr->nButtonWidth = sizeString.cx + 6;
     505        infoPtr->nButtonWidth = sizeString.cx + 6;
    505506    else if (infoPtr->nButtonWidth < infoPtr->nBitmapWidth + 6)
    506         infoPtr->nButtonWidth = infoPtr->nBitmapWidth + 6;
     507        infoPtr->nButtonWidth = infoPtr->nBitmapWidth + 6;
    507508
    508509    TOOLBAR_WrapToolbar( hwnd );
    … …  
    525526    for (i = 0; i < infoPtr->nNumButtons; i++, btnPtr++ )
    526527    {
    527         bWrap = FALSE;
    528         if (btnPtr->fsState & TBSTATE_HIDDEN)
    529         {
    530             SetRectEmpty (&btnPtr->rect);
    531             continue;
    532         }
    533 
    534             /* UNDOCUMENTED: If a separator has a non zero bitmap index, */
    535             /* it is the actual width of the separator. This is used for */
    536             /* custom controls in toolbars.                              */
    537         if (btnPtr->fsStyle & TBSTYLE_SEP)
    538                 cx = (btnPtr->iBitmap > 0) ?
    539                      btnPtr->iBitmap : SEPARATOR_WIDTH;
    540         else
    541             cx = infoPtr->nButtonWidth;
    542 
    543         if (btnPtr->fsState & TBSTATE_WRAP )
    544                     bWrap = TRUE;
    545 
    546         SetRect (&btnPtr->rect, x, y, x + cx, y + cy);
    547 
    548         if (infoPtr->rcBound.left > x)
    549             infoPtr->rcBound.left = x;
    550         if (infoPtr->rcBound.right < x + cx)
    551             infoPtr->rcBound.right = x + cx;
    552         if (infoPtr->rcBound.bottom < y + cy)
    553             infoPtr->rcBound.bottom = y + cy;
    554 
    555         /* Set the toolTip only for non-hidden, non-separator button */
    556         if (infoPtr->hwndToolTip && !(btnPtr->fsStyle & TBSTYLE_SEP ))
    557         {
    558             TTTOOLINFOA ti;
    559 
    560             ZeroMemory (&ti, sizeof(TTTOOLINFOA));
    561             ti.cbSize = sizeof(TTTOOLINFOA);
    562             ti.hwnd = hwnd;
    563             ti.uId = btnPtr->idCommand;
    564             ti.rect = btnPtr->rect;
    565             SendMessageA (infoPtr->hwndToolTip, TTM_NEWTOOLRECTA,
    566                             0, (LPARAM)&ti);
    567         }
    568 
    569         /* btnPtr->nRow is zero based. The space between the rows is    */
    570         /* also considered as a row.                                    */
    571         btnPtr->nRow = nRows + nSepRows;
    572         if( bWrap )
    573         {
    574             if ( !(btnPtr->fsStyle & TBSTYLE_SEP) )
    575             y += cy;
    576             else
    577             {   
    578                 /* UNDOCUMENTED: If a separator has a non zero bitmap index, */
    579                 /* it is the actual width of the separator. This is used for */
    580                 /* custom controls in toolbars.                              */
    581                 y += cy + ( (btnPtr->iBitmap > 0 ) ?
    582                         btnPtr->iBitmap : SEPARATOR_WIDTH) * 2 /3;
    583              
    584                 /* nSepRows is used to calculate the extra height follwoing  */         
    585                 /* the last row.                                             */
    586                 nSepRows++;
    587             }
    588             x = infoPtr->nIndent;
    589                 nRows++;
    590         }
    591         else
    592             x += cx;
     528        bWrap = FALSE;
     529        if (btnPtr->fsState & TBSTATE_HIDDEN)
     530        {
     531            SetRectEmpty (&btnPtr->rect);
     532            continue;
     533        }
     534
     535            /* UNDOCUMENTED: If a separator has a non zero bitmap index, */
     536            /* it is the actual width of the separator. This is used for */
     537            /* custom controls in toolbars.                              */
     538        if (btnPtr->fsStyle & TBSTYLE_SEP)
     539                cx = (btnPtr->iBitmap > 0) ?
     540                     btnPtr->iBitmap : SEPARATOR_WIDTH;
     541        else
     542            cx = infoPtr->nButtonWidth;
     543
     544        if (btnPtr->fsState & TBSTATE_WRAP )
     545                    bWrap = TRUE;
     546
     547        SetRect (&btnPtr->rect, x, y, x + cx, y + cy);
     548
     549        if (infoPtr->rcBound.left > x)
     550            infoPtr->rcBound.left = x;
     551        if (infoPtr->rcBound.right < x + cx)
     552            infoPtr->rcBound.right = x + cx;
     553        if (infoPtr->rcBound.bottom < y + cy)
     554            infoPtr->rcBound.bottom = y + cy;
     555
     556        /* Set the toolTip only for non-hidden, non-separator button */
     557        if (infoPtr->hwndToolTip && !(btnPtr->fsStyle & TBSTYLE_SEP ))
     558        {
     559            TTTOOLINFOA ti;
     560
     561            ZeroMemory (&ti, sizeof(TTTOOLINFOA));
     562            ti.cbSize = sizeof(TTTOOLINFOA);
     563            ti.hwnd = hwnd;
     564            ti.uId = btnPtr->idCommand;
     565            ti.rect = btnPtr->rect;
     566            SendMessageA (infoPtr->hwndToolTip, TTM_NEWTOOLRECTA,
     567                            0, (LPARAM)&ti);
     568        }
     569
     570        /* btnPtr->nRow is zero based. The space between the rows is    */
     571        /* also considered as a row.                                    */
     572        btnPtr->nRow = nRows + nSepRows;
     573        if( bWrap )
     574        {
     575            if ( !(btnPtr->fsStyle & TBSTYLE_SEP) )
     576            y += cy;
     577            else
     578            {
     579                /* UNDOCUMENTED: If a separator has a non zero bitmap index, */
     580                /* it is the actual width of the separator. This is used for */
     581                /* custom controls in toolbars.                              */
     582                y += cy + ( (btnPtr->iBitmap > 0 ) ?
     583                        btnPtr->iBitmap : SEPARATOR_WIDTH) * 2 /3;
     584
     585                /* nSepRows is used to calculate the extra height follwoing  */
     586                /* the last row.                                             */
     587                nSepRows++;
     588            }
     589            x = infoPtr->nIndent;
     590                nRows++;
     591        }
     592        else
     593            x += cx;
    593594    }
    594595
    … …  
    596597    infoPtr->nRows = nRows + nSepRows + 1;
    597598
    598     /* nSepRows * (infoPtr->nBitmapHeight + 1) is the space following   */
    599     /* the last row.                                                    */
    600     infoPtr->nHeight = TOP_BORDER + (nRows + 1) * infoPtr->nButtonHeight + 
    601                         nSepRows * SEPARATOR_WIDTH * 2 / 3 +
    602                         nSepRows * (infoPtr->nBitmapHeight + 1) +
    603                         BOTTOM_BORDER;
     599    /* nSepRows * (infoPtr->nBitmapHeight + 1) is the space following   */
     600    /* the last row.                                                    */
     601    infoPtr->nHeight = TOP_BORDER + (nRows + 1) * infoPtr->nButtonHeight +
     602                        nSepRows * SEPARATOR_WIDTH * 2 / 3 +
     603                        nSepRows * (infoPtr->nBitmapHeight + 1) +
     604                        BOTTOM_BORDER;
    604605//    TRACE (toolbar, "toolbar height %d\n", infoPtr->nHeight);
    605606}
    … …  
    612613    TBUTTON_INFO *btnPtr;
    613614    INT i;
    614    
     615
    615616    btnPtr = infoPtr->buttons;
    616617    for (i = 0; i < infoPtr->nNumButtons; i++, btnPtr++) {
    617         if (btnPtr->fsState & TBSTATE_HIDDEN)
    618             continue;
    619 
    620         if (btnPtr->fsStyle & TBSTYLE_SEP) {
    621             if (PtInRect (&btnPtr->rect, *lpPt)) {
    622 //              TRACE (toolbar, " ON SEPARATOR %d!\n", i);
    623                 return -i;
    624             }
    625         }
    626         else {
    627             if (PtInRect (&btnPtr->rect, *lpPt)) {
    628 //              TRACE (toolbar, " ON BUTTON %d!\n", i);
    629                 return i;
    630             }
    631         }
     618        if (btnPtr->fsState & TBSTATE_HIDDEN)
     619            continue;
     620
     621        if (btnPtr->fsStyle & TBSTYLE_SEP) {
     622            if (PtInRect (&btnPtr->rect, *lpPt)) {
     623//              TRACE (toolbar, " ON SEPARATOR %d!\n", i);
     624                return -i;
     625            }
     626        }
     627        else {
     628            if (PtInRect (&btnPtr->rect, *lpPt)) {
     629//              TRACE (toolbar, " ON BUTTON %d!\n", i);
     630                return i;
     631            }
     632        }
    632633    }
    633634
    … …  
    645646    btnPtr = infoPtr->buttons;
    646647    for (i = 0; i < infoPtr->nNumButtons; i++, btnPtr++) {
    647         if (btnPtr->idCommand == idCommand) {
    648 //          TRACE (toolbar, "command=%d index=%d\n", idCommand, i);
    649             return i;
    650         }
     648        if (btnPtr->idCommand == idCommand) {
     649//          TRACE (toolbar, "command=%d index=%d\n", idCommand, i);
     650            return i;
     651        }
    651652    }
    652653//    TRACE (toolbar, "no index found for command=%d\n", idCommand);
    … …  
    662663
    663664    if ((nIndex < 0) || (nIndex > infoPtr->nNumButtons))
    664         return -1;
     665        return -1;
    665666
    666667    /* check index button */
    667668    btnPtr = &infoPtr->buttons[nIndex];
    668669    if ((btnPtr->fsStyle & TBSTYLE_CHECKGROUP) == TBSTYLE_CHECKGROUP) {
    669         if (btnPtr->fsState & TBSTATE_CHECKED)
    670             return nIndex;
     670        if (btnPtr->fsState & TBSTATE_CHECKED)
     671            return nIndex;
    671672    }
    672673
    … …  
    674675    nRunIndex = nIndex - 1;
    675676    while (nRunIndex >= 0) {
    676         btnPtr = &infoPtr->buttons[nRunIndex];
    677         if ((btnPtr->fsStyle & TBSTYLE_CHECKGROUP) == TBSTYLE_CHECKGROUP) {
    678             if (btnPtr->fsState & TBSTATE_CHECKED)
    679                 return nRunIndex;
    680         }
    681         else
    682             break;
    683         nRunIndex--;
     677        btnPtr = &infoPtr->buttons[nRunIndex];
     678        if ((btnPtr->fsStyle & TBSTYLE_CHECKGROUP) == TBSTYLE_CHECKGROUP) {
     679            if (btnPtr->fsState & TBSTATE_CHECKED)
     680                return nRunIndex;
     681        }
     682        else
     683            break;
     684        nRunIndex--;
    684685    }
    685686
    … …  
    687688    nRunIndex = nIndex + 1;
    688689    while (nRunIndex < infoPtr->nNumButtons) {
    689         btnPtr = &infoPtr->buttons[nRunIndex]; 
    690         if ((btnPtr->fsStyle & TBSTYLE_CHECKGROUP) == TBSTYLE_CHECKGROUP) {
    691             if (btnPtr->fsState & TBSTATE_CHECKED)
    692                 return nRunIndex;
    693         }
    694         else
    695             break;
    696         nRunIndex++;
     690        btnPtr = &infoPtr->buttons[nRunIndex];
     691        if ((btnPtr->fsStyle & TBSTYLE_CHECKGROUP) == TBSTYLE_CHECKGROUP) {
     692            if (btnPtr->fsState & TBSTATE_CHECKED)
     693                return nRunIndex;
     694        }
     695        else
     696            break;
     697        nRunIndex++;
    697698    }
    698699
    … …  
    703704static VOID
    704705TOOLBAR_RelayEvent (HWND hwndTip, HWND hwndMsg, UINT uMsg,
    705                     WPARAM wParam, LPARAM lParam)
     706                    WPARAM wParam, LPARAM lParam)
    706707{
    707708    MSG msg;
    … …  
    731732    switch (uMsg)
    732733    {
    733         case WM_INITDIALOG:
    734             infoPtr = (TOOLBAR_INFO *)lParam;
    735             SetWindowLongA (hwnd, DWL_USER, (DWORD)infoPtr);
    736 
    737             hDsa = DSA_Create (sizeof(TBUTTON_INFO), 5);
    738 
    739             if (infoPtr)
    740             {
    741                 TBUTTON_INFO *btnPtr;
    742                 INT i;
    743 
    744                 /* insert 'virtual' separator button into 'available buttons' list */
    745                 SendDlgItemMessageA (hwnd, IDC_AVAILBTN_LBOX, LB_ADDSTRING, 0, (LPARAM)"");
    746 
    747                 /* copy all buttons and append them to the right listbox */             
    748                 btnPtr = infoPtr->buttons;
    749                 for (i = 0; i < infoPtr->nNumButtons; i++, btnPtr++)
    750                 {
    751                     DSA_InsertItem (hDsa, i, btnPtr);
    752 
    753                     if (btnPtr->fsState & TBSTATE_HIDDEN)
    754                     {
    755                         SendDlgItemMessageA (hwnd, IDC_AVAILBTN_LBOX, LB_ADDSTRING, 0, (LPARAM)"");
    756                     }
    757                     else
    758                     {
    759                         SendDlgItemMessageA (hwnd, IDC_TOOLBARBTN_LBOX, LB_ADDSTRING, 0, (LPARAM)"");
    760                     }
    761                 }
    762 
    763                 /* append 'virtual' sepatator button to the 'toolbar buttons' list */
    764                 /* TODO */
    765             }
    766             return TRUE;
    767 
    768         case WM_CLOSE:
    769             EndDialog(hwnd, FALSE);
    770             return TRUE;
    771 
    772         case WM_COMMAND:
    773             switch (LOWORD(wParam))
    774             {
    775                 case IDCANCEL:
    776                     EndDialog(hwnd, FALSE);
    777                     break;
    778             }
    779             return TRUE;
    780 
    781         case WM_DESTROY:
    782             if (hDsa)
    783                 DSA_Destroy (hDsa);
    784             return TRUE;
    785 
    786         case WM_DRAWITEM:
    787             if (wParam == IDC_AVAILBTN_LBOX || wParam == IDC_TOOLBARBTN_LBOX)
    788             {
    789                 LPDRAWITEMSTRUCT lpdis = (LPDRAWITEMSTRUCT)lParam;
    790                 RECT rcButton;
    791                 RECT rcText;
    792                 HPEN hOldPen;
    793                 HBRUSH hOldBrush;
    794                 COLORREF oldText = 0;
    795                 COLORREF oldBk = 0;
    796 
    797 //              FIXME(toolbar, "action: %x itemState: %x\n",
    798 //                    lpdis->itemAction, lpdis->itemState);             
    799 
    800                 if (lpdis->itemState & ODS_FOCUS)
    801                 {
    802                     oldBk = SetBkColor (lpdis->hDC, GetSysColor(COLOR_HIGHLIGHT));
    803                     oldText = SetTextColor (lpdis->hDC, GetSysColor(COLOR_HIGHLIGHTTEXT));
    804                 }
    805 
    806                 hOldPen = SelectObject (lpdis->hDC, GetSysColorPen ((lpdis->itemState & ODS_SELECTED)?COLOR_HIGHLIGHT:COLOR_WINDOW));
    807                 hOldBrush = SelectObject (lpdis->hDC, GetSysColorBrush ((lpdis->itemState & ODS_FOCUS)?COLOR_HIGHLIGHT:COLOR_WINDOW));
    808 
    809                 /* fill background rectangle */
    810                 Rectangle (lpdis->hDC, lpdis->rcItem.left, lpdis->rcItem.top,
    811                            lpdis->rcItem.right, lpdis->rcItem.bottom);
    812 
    813                 /* calculate button and text rectangles */
    814                 CopyRect (&rcButton, &lpdis->rcItem);
    815                 InflateRect (&rcButton, -1, -1);
    816                 CopyRect (&rcText, &rcButton);
    817                 rcButton.right = rcButton.left + infoPtr->nBitmapWidth + 6;
    818                 rcText.left = rcButton.right + 2;
    819 
    820                 /* draw focus rectangle */
    821                 if (lpdis->itemState & ODS_FOCUS)
    822                     DrawFocusRect (lpdis->hDC, &lpdis->rcItem);
    823 
    824                 /* draw button */
    825                 DrawEdge (lpdis->hDC, &rcButton, EDGE_RAISED, BF_RECT|BF_MIDDLE|BF_SOFT);
    826 
    827                 /* draw text */
    828                 if (wParam == IDC_AVAILBTN_LBOX && lpdis->itemID == 0)
    829                     DrawTextA (lpdis->hDC, "Separator", -1, &rcText,
    830                                DT_LEFT | DT_VCENTER | DT_SINGLELINE);
    831 
    832                 if (lpdis->itemState & ODS_FOCUS)
    833                 {
    834                     SetBkColor (lpdis->hDC, oldBk);
    835                     SetTextColor (lpdis->hDC, oldText);
    836                 }
    837 
    838                 SelectObject (lpdis->hDC, hOldBrush);
    839                 SelectObject (lpdis->hDC, hOldPen);
    840 
    841                 return TRUE;
    842             }
    843             return FALSE;
    844 
    845         case WM_MEASUREITEM:
    846             if (wParam == IDC_AVAILBTN_LBOX || wParam == IDC_TOOLBARBTN_LBOX)
    847             {
    848                 MEASUREITEMSTRUCT *lpmis = (MEASUREITEMSTRUCT*)lParam;
    849 
    850                 if (infoPtr)
    851                     lpmis->itemHeight = infoPtr->nBitmapHeight + 8;
    852                 else
    853                     lpmis->itemHeight = 16 + 8; /* default height */
    854 
    855                 return TRUE;
    856             }
    857             return FALSE;
    858 
    859         default:
    860             return FALSE;
     734        case WM_INITDIALOG:
     735            infoPtr = (TOOLBAR_INFO *)lParam;
     736            SetWindowLongA (hwnd, DWL_USER, (DWORD)infoPtr);
     737
     738            hDsa = DSA_Create (sizeof(TBUTTON_INFO), 5);
     739
     740            if (infoPtr)
     741            {
     742                TBUTTON_INFO *btnPtr;
     743                INT i;
     744
     745                /* insert 'virtual' separator button into 'available buttons' list */
     746                SendDlgItemMessageA (hwnd, IDC_AVAILBTN_LBOX, LB_ADDSTRING, 0, (LPARAM)"");
     747
     748                /* copy all buttons and append them to the right listbox */
     749                btnPtr = infoPtr->buttons;
     750                for (i = 0; i < infoPtr->nNumButtons; i++, btnPtr++)
     751                {
     752                    DSA_InsertItem (hDsa, i, btnPtr);
     753
     754                    if (btnPtr->fsState & TBSTATE_HIDDEN)
     755                    {
     756                        SendDlgItemMessageA (hwnd, IDC_AVAILBTN_LBOX, LB_ADDSTRING, 0, (LPARAM)"");
     757                    }
     758                    else
     759                    {
     760                        SendDlgItemMessageA (hwnd, IDC_TOOLBARBTN_LBOX, LB_ADDSTRING, 0, (LPARAM)"");
     761                    }
     762                }
     763
     764                /* append 'virtual' sepatator button to the 'toolbar buttons' list */
     765                /* TODO */
     766            }
     767            return TRUE;
     768
     769        case WM_CLOSE:
     770            EndDialog(hwnd, FALSE);
     771            return TRUE;
     772
     773        case WM_COMMAND:
     774            switch (LOWORD(wParam))
     775            {
     776                case IDCANCEL:
     777                    EndDialog(hwnd, FALSE);
     778                    break;
     779            }
     780            return TRUE;
     781
     782        case WM_DESTROY:
     783            if (hDsa)
     784                DSA_Destroy (hDsa);
     785            return TRUE;
     786
     787        case WM_DRAWITEM:
     788            if (wParam == IDC_AVAILBTN_LBOX || wParam == IDC_TOOLBARBTN_LBOX)
     789            {
     790                LPDRAWITEMSTRUCT lpdis = (LPDRAWITEMSTRUCT)lParam;
     791                RECT rcButton;
     792                RECT rcText;
     793                HPEN hOldPen;
     794                HBRUSH hOldBrush;
     795                COLORREF oldText = 0;
     796                COLORREF oldBk = 0;
     797
     798//              FIXME(toolbar, "action: %x itemState: %x\n",
     799//                    lpdis->itemAction, lpdis->itemState);
     800
     801                if (lpdis->itemState & ODS_FOCUS)
     802                {
     803                    oldBk = SetBkColor (lpdis->hDC, GetSysColor(COLOR_HIGHLIGHT));
     804                    oldText = SetTextColor (lpdis->hDC, GetSysColor(COLOR_HIGHLIGHTTEXT));
     805                }
     806
     807                hOldPen = SelectObject (lpdis->hDC, GetSysColorPen ((lpdis->itemState & ODS_SELECTED)?COLOR_HIGHLIGHT:COLOR_WINDOW));
     808                hOldBrush = SelectObject (lpdis->hDC, GetSysColorBrush ((lpdis->itemState & ODS_FOCUS)?COLOR_HIGHLIGHT:COLOR_WINDOW));
     809
     810                /* fill background rectangle */
     811                Rectangle (lpdis->hDC, lpdis->rcItem.left, lpdis->rcItem.top,
     812                           lpdis->rcItem.right, lpdis->rcItem.bottom);
     813
     814                /* calculate button and text rectangles */
     815                CopyRect (&rcButton, &lpdis->rcItem);
     816                InflateRect (&rcButton, -1, -1);
     817                CopyRect (&rcText, &rcButton);
     818                rcButton.right = rcButton.left + infoPtr->nBitmapWidth + 6;
     819                rcText.left = rcButton.right + 2;
     820
     821                /* draw focus rectangle */
     822                if (lpdis->itemState & ODS_FOCUS)
     823                    DrawFocusRect (lpdis->hDC, &lpdis->rcItem);
     824
     825                /* draw button */
     826                DrawEdge (lpdis->hDC, &rcButton, EDGE_RAISED, BF_RECT|BF_MIDDLE|BF_SOFT);
     827
     828                /* draw text */
     829                if (wParam == IDC_AVAILBTN_LBOX && lpdis->itemID == 0)
     830                    DrawTextA (lpdis->hDC, "Separator", -1, &rcText,
     831                               DT_LEFT | DT_VCENTER | DT_SINGLELINE);
     832
     833                if (lpdis->itemState & ODS_FOCUS)
     834                {
     835                    SetBkColor (lpdis->hDC, oldBk);
     836                    SetTextColor (lpdis->hDC, oldText);
     837                }
     838
     839                SelectObject (lpdis->hDC, hOldBrush);
     840                SelectObject (lpdis->hDC, hOldPen);
     841
     842                return TRUE;
     843            }
     844            return FALSE;
     845
     846        case WM_MEASUREITEM:
     847            if (wParam == IDC_AVAILBTN_LBOX || wParam == IDC_TOOLBARBTN_LBOX)
     848            {
     849                MEASUREITEMSTRUCT *lpmis = (MEASUREITEMSTRUCT*)lParam;
     850
     851                if (infoPtr)
     852                    lpmis->itemHeight = infoPtr->nBitmapHeight + 8;
     853                else
     854                    lpmis->itemHeight = 16 + 8; /* default height */
     855
     856                return TRUE;
     857            }
     858            return FALSE;
     859
     860        default:
     861            return FALSE;
    861862    }
    862863}
    … …  
    875876
    876877    if ((!lpAddBmp) || ((INT)wParam <= 0))
    877         return -1;
     878        return -1;
    878879
    879880//    TRACE (toolbar, "adding %d bitmaps!\n", wParam);
    880881
    881882    if (!(infoPtr->himlStd)) {
    882         /* create new standard image list */
    883 
    884 //      TRACE (toolbar, "creating standard image list!\n");
    885 
    886 
    887         /* Windows resize all the buttons to the size of a newly added STandard Image*/
    888         /* TODO: The resizing  should be done each time a standard image is added*/
    889         if (lpAddBmp->hInst == HINST_COMMCTRL)
    890         {
    891 
    892             if (lpAddBmp->nID & 1)
    893             {
    894                 SendMessageA (hwnd, TB_SETBITMAPSIZE, 0,
    895                               MAKELPARAM((WORD)26, (WORD)26));
    896                 SendMessageA (hwnd, TB_SETBUTTONSIZE, 0,
    897                               MAKELPARAM((WORD)33, (WORD)33));
    898             }
    899             else
    900             {
    901                 SendMessageA (hwnd, TB_SETBITMAPSIZE, 0,
    902                               MAKELPARAM((WORD)16, (WORD)16));
    903 
    904                 SendMessageA (hwnd, TB_SETBUTTONSIZE, 0,
    905                               MAKELPARAM((WORD)22, (WORD)22));
    906             }
    907 
    908             TOOLBAR_CalcToolbar (hwnd);
    909         }
    910 
    911         infoPtr->himlStd =
    912             ImageList_Create (infoPtr->nBitmapWidth, infoPtr->nBitmapHeight,
    913                               ILC_COLOR | ILC_MASK, (INT)wParam, 2);
     883        /* create new standard image list */
     884
     885//      TRACE (toolbar, "creating standard image list!\n");
     886
     887
     888        /* Windows resize all the buttons to the size of a newly added STandard Image*/
     889        /* TODO: The resizing  should be done each time a standard image is added*/
     890        if (lpAddBmp->hInst == HINST_COMMCTRL)
     891        {
     892
     893            if (lpAddBmp->nID & 1)
     894            {
     895                SendMessageA (hwnd, TB_SETBITMAPSIZE, 0,
     896                              MAKELPARAM((WORD)26, (WORD)26));
     897                SendMessageA (hwnd, TB_SETBUTTONSIZE, 0,
     898                              MAKELPARAM((WORD)33, (WORD)33));
     899            }
     900            else
     901            {
     902                SendMessageA (hwnd, TB_SETBITMAPSIZE, 0,
     903                              MAKELPARAM((WORD)16, (WORD)16));
     904
     905                SendMessageA (hwnd, TB_SETBUTTONSIZE, 0,
     906                              MAKELPARAM((WORD)22, (WORD)22));
     907            }
     908
     909            TOOLBAR_CalcToolbar (hwnd);
     910        }
     911
     912        infoPtr->himlStd =
     913            ImageList_Create (infoPtr->nBitmapWidth, infoPtr->nBitmapHeight,
     914                              ILC_COLOR | ILC_MASK, (INT)wParam, 2);
    914915    }
    915916
    916917    /* Add bitmaps to the standard image list */
    917918    if (lpAddBmp->hInst == (HINSTANCE)0) {
    918         nIndex =
    919             ImageList_AddMasked (infoPtr->himlStd, (HBITMAP)lpAddBmp->nID,
    920                                 CLR_DEFAULT);
     919        nIndex =
     920            ImageList_AddMasked (infoPtr->himlStd, (HBITMAP)lpAddBmp->nID,
     921                                CLR_DEFAULT);
    921922    }
    922923    else if (lpAddBmp->hInst == HINST_COMMCTRL) {
    923         /* add internal bitmaps */
    924        
    925 //      FIXME (toolbar, "internal bitmaps not supported!\n");
    926         /* TODO: Resize all the buttons when a new standard image is added */
    927 
    928         /* Hack to "add" some reserved images within the image list
    929            to get the right image indices */
    930         nIndex = ImageList_GetImageCount (infoPtr->himlStd);
    931         ImageList_SetImageCount (infoPtr->himlStd, nIndex + (INT)wParam);
    932        
     924        /* add internal bitmaps */
     925
     926//      FIXME (toolbar, "internal bitmaps not supported!\n");
     927        /* TODO: Resize all the buttons when a new standard image is added */
     928
     929        /* Hack to "add" some reserved images within the image list
     930           to get the right image indices */
     931        nIndex = ImageList_GetImageCount (infoPtr->himlStd);
     932        ImageList_SetImageCount (infoPtr->himlStd, nIndex + (INT)wParam);
     933
    933934    }
    934935    else {
    935         HBITMAP hBmp =
    936             LoadBitmapA (lpAddBmp->hInst, (LPSTR)lpAddBmp->nID);
    937         nIndex = ImageList_AddMasked (infoPtr->himlStd, hBmp, CLR_DEFAULT);
    938 
    939         DeleteObject (hBmp);
     936        HBITMAP hBmp =
     937            LoadBitmapA (lpAddBmp->hInst, (LPSTR)lpAddBmp->nID);
     938        nIndex = ImageList_AddMasked (infoPtr->himlStd, hBmp, CLR_DEFAULT);
     939
     940        DeleteObject (hBmp);
    940941    }
    941942
    … …  
    960961
    961962    if (infoPtr->nNumButtons == 0) {
    962         infoPtr->buttons =
    963             COMCTL32_Alloc (sizeof(TBUTTON_INFO) * nNewButtons);
     963        infoPtr->buttons =
     964            COMCTL32_Alloc (sizeof(TBUTTON_INFO) * nNewButtons);
    964965    }
    965966    else {
    966         TBUTTON_INFO *oldButtons = infoPtr->buttons;
    967         infoPtr->buttons =
    968             COMCTL32_Alloc (sizeof(TBUTTON_INFO) * nNewButtons);
    969         memcpy (&infoPtr->buttons[0], &oldButtons[0],
    970                 nOldButtons * sizeof(TBUTTON_INFO));
     967        TBUTTON_INFO *oldButtons = infoPtr->buttons;
     968        infoPtr->buttons =
     969            COMCTL32_Alloc (sizeof(TBUTTON_INFO) * nNewButtons);
     970        memcpy (&infoPtr->buttons[0], &oldButtons[0],
     971                nOldButtons * sizeof(TBUTTON_INFO));
    971972        COMCTL32_Free (oldButtons);
    972973    }
    … …  
    976977    /* insert new button data */
    977978    for (nCount = 0; nCount < nAddButtons; nCount++) {
    978         TBUTTON_INFO *btnPtr = &infoPtr->buttons[nOldButtons+nCount];
    979         btnPtr->iBitmap   = lpTbb[nCount].iBitmap;
    980         btnPtr->idCommand = lpTbb[nCount].idCommand;
    981         btnPtr->fsState   = lpTbb[nCount].fsState;
    982         btnPtr->fsStyle   = lpTbb[nCount].fsStyle;
    983         btnPtr->dwData    = lpTbb[nCount].dwData;
    984         btnPtr->iString   = lpTbb[nCount].iString;
    985         btnPtr->bHot      = FALSE;
    986 
    987         if ((infoPtr->hwndToolTip) && !(btnPtr->fsStyle & TBSTYLE_SEP)) {
    988             TTTOOLINFOA ti;
    989 
    990             ZeroMemory (&ti, sizeof(TTTOOLINFOA));
    991             ti.cbSize   = sizeof (TTTOOLINFOA);
    992             ti.hwnd     = hwnd;
    993             ti.uId      = btnPtr->idCommand;
    994             ti.hinst    = 0;
    995             ti.lpszText = LPSTR_TEXTCALLBACKA;
    996 
    997             SendMessageA (infoPtr->hwndToolTip, TTM_ADDTOOLA,
    998                             0, (LPARAM)&ti);
    999         }
     979        TBUTTON_INFO *btnPtr = &infoPtr->buttons[nOldButtons+nCount];
     980        btnPtr->iBitmap   = lpTbb[nCount].iBitmap;
     981        btnPtr->idCommand = lpTbb[nCount].idCommand;
     982        btnPtr->fsState   = lpTbb[nCount].fsState;
     983        btnPtr->fsStyle   = lpTbb[nCount].fsStyle;
     984        btnPtr->dwData    = lpTbb[nCount].dwData;
     985        btnPtr->iString   = lpTbb[nCount].iString;
     986        btnPtr->bHot      = FALSE;
     987
     988        if ((infoPtr->hwndToolTip) && !(btnPtr->fsStyle & TBSTYLE_SEP)) {
     989            TTTOOLINFOA ti;
     990
     991            ZeroMemory (&ti, sizeof(TTTOOLINFOA));
     992            ti.cbSize   = sizeof (TTTOOLINFOA);
     993            ti.hwnd     = hwnd;
     994            ti.uId      = btnPtr->idCommand;
     995            ti.hinst    = 0;
     996            ti.lpszText = LPSTR_TEXTCALLBACKA;
     997
     998            SendMessageA (infoPtr->hwndToolTip, TTM_ADDTOOLA,
     999                            0, (LPARAM)&ti);
     1000        }
    10001001    }
    10011002
    … …  
    10181019
    10191020    if ((wParam) && (HIWORD(lParam) == 0)) {
    1020         char szString[256];
    1021         INT len;
    1022 //      TRACE (toolbar, "adding string from resource!\n");
    1023 
    1024         len = LoadStringA ((HINSTANCE)wParam, (UINT)lParam,
    1025                              szString, 256);
    1026 
    1027 //      TRACE (toolbar, "len=%d \"%s\"\n", len, szString);
    1028         nIndex = infoPtr->nNumStrings;
    1029         if (infoPtr->nNumStrings == 0) {
    1030             infoPtr->strings =
    1031                 COMCTL32_Alloc (sizeof(LPWSTR));
    1032         }
    1033         else {
    1034             LPWSTR *oldStrings = infoPtr->strings;
    1035             infoPtr->strings =
    1036                 COMCTL32_Alloc (sizeof(LPWSTR) * (infoPtr->nNumStrings + 1));
    1037             memcpy (&infoPtr->strings[0], &oldStrings[0],
    1038                     sizeof(LPWSTR) * infoPtr->nNumStrings);
    1039             COMCTL32_Free (oldStrings);
    1040         }
    1041 
    1042         infoPtr->strings[infoPtr->nNumStrings] =
    1043             COMCTL32_Alloc (sizeof(WCHAR)*(len+1));
    1044         lstrcpyAtoW (infoPtr->strings[infoPtr->nNumStrings], szString);
    1045         infoPtr->nNumStrings++;
     1021        char szString[256];
     1022        INT len;
     1023//      TRACE (toolbar, "adding string from resource!\n");
     1024
     1025        len = LoadStringA ((HINSTANCE)wParam, (UINT)lParam,
     1026                             szString, 256);
     1027
     1028//      TRACE (toolbar, "len=%d \"%s\"\n", len, szString);
     1029        nIndex = infoPtr->nNumStrings;
     1030        if (infoPtr->nNumStrings == 0) {
     1031            infoPtr->strings =
     1032                COMCTL32_Alloc (sizeof(LPWSTR));
     1033        }
     1034        else {
     1035            LPWSTR *oldStrings = infoPtr->strings;
     1036            infoPtr->strings =
     1037                COMCTL32_Alloc (sizeof(LPWSTR) * (infoPtr->nNumStrings + 1));
     1038            memcpy (&infoPtr->strings[0], &oldStrings[0],
     1039                    sizeof(LPWSTR) * infoPtr->nNumStrings);
     1040            COMCTL32_Free (oldStrings);
     1041        }
     1042
     1043        infoPtr->strings[infoPtr->nNumStrings] =
     1044            COMCTL32_Alloc (sizeof(WCHAR)*(len+1));
     1045        lstrcpyAtoW (infoPtr->strings[infoPtr->nNumStrings], szString);
     1046        infoPtr->nNumStrings++;
    10461047    }
    10471048    else {
    1048         LPSTR p = (LPSTR)lParam;
    1049         INT len;
    1050 
    1051         if (p == NULL)
    1052             return -1;
    1053 //      TRACE (toolbar, "adding string(s) from array!\n");
    1054         nIndex = infoPtr->nNumStrings;
    1055         while (*p) {
    1056             len = lstrlenA (p);
    1057 //          TRACE (toolbar, "len=%d \"%s\"\n", len, p);
    1058 
    1059             if (infoPtr->nNumStrings == 0) {
    1060                 infoPtr->strings =
    1061                     COMCTL32_Alloc (sizeof(LPWSTR));
    1062             }
    1063             else {
    1064                 LPWSTR *oldStrings = infoPtr->strings;
    1065                 infoPtr->strings =
    1066                     COMCTL32_Alloc (sizeof(LPWSTR) * (infoPtr->nNumStrings + 1));
    1067                 memcpy (&infoPtr->strings[0], &oldStrings[0],
    1068                         sizeof(LPWSTR) * infoPtr->nNumStrings);
    1069                 COMCTL32_Free (oldStrings);
    1070             }
    1071 
    1072             infoPtr->strings[infoPtr->nNumStrings] =
    1073                 COMCTL32_Alloc (sizeof(WCHAR)*(len+1));
    1074             lstrcpyAtoW (infoPtr->strings[infoPtr->nNumStrings], p);
    1075             infoPtr->nNumStrings++;
    1076 
    1077             p += (len+1);
    1078         }
     1049        LPSTR p = (LPSTR)lParam;
     1050        INT len;
     1051
     1052        if (p == NULL)
     1053            return -1;
     1054//      TRACE (toolbar, "adding string(s) from array!\n");
     1055        nIndex = infoPtr->nNumStrings;
     1056        while (*p) {
     1057            len = lstrlenA (p);
     1058//          TRACE (toolbar, "len=%d \"%s\"\n", len, p);
     1059
     1060            if (infoPtr->nNumStrings == 0) {
     1061                infoPtr->strings =
     1062                    COMCTL32_Alloc (sizeof(LPWSTR));
     1063            }
     1064            else {
     1065                LPWSTR *oldStrings = infoPtr->strings;
     1066                infoPtr->strings =
     1067                    COMCTL32_Alloc (sizeof(LPWSTR) * (infoPtr->nNumStrings + 1));
     1068                memcpy (&infoPtr->strings[0], &oldStrings[0],
     1069                        sizeof(LPWSTR) * infoPtr->nNumStrings);
     1070                COMCTL32_Free (oldStrings);
     1071            }
     1072
     1073            infoPtr->strings[infoPtr->nNumStrings] =
     1074                COMCTL32_Alloc (sizeof(WCHAR)*(len+1));
     1075            lstrcpyAtoW (infoPtr->strings[infoPtr->nNumStrings], p);
     1076            infoPtr->nNumStrings++;
     1077
     1078            p += (len+1);
     1079        }
    10791080    }
    10801081
    … …  
    10901091
    10911092    if ((wParam) && (HIWORD(lParam) == 0)) {
    1092         WCHAR szString[256];
    1093         INT len;
    1094 //      TRACE (toolbar, "adding string from resource!\n");
    1095 
    1096         len = LoadStringW ((HINSTANCE)wParam, (UINT)lParam,
    1097                              szString, 256);
    1098 
    1099 //      TRACE (toolbar, "len=%d \"%s\"\n", len, debugstr_w(szString));
    1100         nIndex = infoPtr->nNumStrings;
    1101         if (infoPtr->nNumStrings == 0) {
    1102             infoPtr->strings =
    1103                 COMCTL32_Alloc (sizeof(LPWSTR));
    1104         }
    1105         else {
    1106             LPWSTR *oldStrings = infoPtr->strings;
    1107             infoPtr->strings =
    1108                 COMCTL32_Alloc (sizeof(LPWSTR) * (infoPtr->nNumStrings + 1));
    1109             memcpy (&infoPtr->strings[0], &oldStrings[0],
    1110                     sizeof(LPWSTR) * infoPtr->nNumStrings);
    1111             COMCTL32_Free (oldStrings);
    1112         }
    1113 
    1114         infoPtr->strings[infoPtr->nNumStrings] =
    1115             COMCTL32_Alloc (sizeof(WCHAR)*(len+1));
    1116         lstrcpyW (infoPtr->strings[infoPtr->nNumStrings], szString);
    1117         infoPtr->nNumStrings++;
     1093        WCHAR szString[256];
     1094        INT len;
     1095//      TRACE (toolbar, "adding string from resource!\n");
     1096
     1097        len = LoadStringW ((HINSTANCE)wParam, (UINT)lParam,
     1098                             szString, 256);
     1099
     1100//      TRACE (toolbar, "len=%d \"%s\"\n", len, debugstr_w(szString));
     1101        nIndex = infoPtr->nNumStrings;
     1102        if (infoPtr->nNumStrings == 0) {
     1103            infoPtr->strings =
     1104                COMCTL32_Alloc (sizeof(LPWSTR));
     1105        }
     1106        else {
     1107            LPWSTR *oldStrings = infoPtr->strings;
     1108            infoPtr->strings =
     1109                COMCTL32_Alloc (sizeof(LPWSTR) * (infoPtr->nNumStrings + 1));
     1110            memcpy (&infoPtr->strings[0], &oldStrings[0],
     1111                    sizeof(LPWSTR) * infoPtr->nNumStrings);
     1112            COMCTL32_Free (oldStrings);
     1113        }
     1114
     1115        infoPtr->strings[infoPtr->nNumStrings] =
     1116            COMCTL32_Alloc (sizeof(WCHAR)*(len+1));
     1117        lstrcpyW (infoPtr->strings[infoPtr->nNumStrings], szString);
     1118        infoPtr->nNumStrings++;
    11181119    }
    11191120    else {
    1120         LPWSTR p = (LPWSTR)lParam;
    1121         INT len;
    1122 
    1123         if (p == NULL)
    1124             return -1;
    1125 //      TRACE (toolbar, "adding string(s) from array!\n");
    1126         nIndex = infoPtr->nNumStrings;
    1127         while (*p) {
    1128             len = lstrlenW (p);
    1129 //          TRACE (toolbar, "len=%d \"%s\"\n", len, debugstr_w(p));
    1130 
    1131             if (infoPtr->nNumStrings == 0) {
    1132                 infoPtr->strings =
    1133                     COMCTL32_Alloc (sizeof(LPWSTR));
    1134             }
    1135             else {
    1136                 LPWSTR *oldStrings = infoPtr->strings;
    1137                 infoPtr->strings =
    1138                     COMCTL32_Alloc (sizeof(LPWSTR) * (infoPtr->nNumStrings + 1));
    1139                 memcpy (&infoPtr->strings[0], &oldStrings[0],
    1140                         sizeof(LPWSTR) * infoPtr->nNumStrings);
    1141                 COMCTL32_Free (oldStrings);
    1142             }
    1143 
    1144             infoPtr->strings[infoPtr->nNumStrings] =
    1145                 COMCTL32_Alloc (sizeof(WCHAR)*(len+1));
    1146             lstrcpyW (infoPtr->strings[infoPtr->nNumStrings], p);
    1147             infoPtr->nNumStrings++;
    1148 
    1149             p += (len+1);
    1150         }
     1121        LPWSTR p = (LPWSTR)lParam;
     1122        INT len;
     1123
     1124        if (p == NULL)
     1125            return -1;
     1126//      TRACE (toolbar, "adding string(s) from array!\n");
     1127        nIndex = infoPtr->nNumStrings;
     1128        while (*p) {
     1129            len = lstrlenW (p);
     1130//          TRACE (toolbar, "len=%d \"%s\"\n", len, debugstr_w(p));
     1131
     1132            if (infoPtr->nNumStrings == 0) {
     1133                infoPtr->strings =
     1134                    COMCTL32_Alloc (sizeof(LPWSTR));
     1135            }
     1136            else {
     1137                LPWSTR *oldStrings = infoPtr->strings;
     1138                infoPtr->strings =
     1139                    COMCTL32_Alloc (sizeof(LPWSTR) * (infoPtr->nNumStrings + 1));
     1140                memcpy (&infoPtr->strings[0], &oldStrings[0],
     1141                        sizeof(LPWSTR) * infoPtr->nNumStrings);
     1142                COMCTL32_Free (oldStrings);
     1143            }
     1144
     1145            infoPtr->strings[infoPtr->nNumStrings] =
     1146                COMCTL32_Alloc (sizeof(WCHAR)*(len+1));
     1147            lstrcpyW (infoPtr->strings[infoPtr->nNumStrings], p);
     1148            infoPtr->nNumStrings++;
     1149
     1150            p += (len+1);
     1151        }
    11511152    }
    11521153
    … …  
    11721173
    11731174    if (dwStyle & CCS_NORESIZE) {
    1174         uPosFlags |= (SWP_NOSIZE | SWP_NOMOVE);
    1175         cx = 0;
    1176         cy = 0;
     1175        uPosFlags |= (SWP_NOSIZE | SWP_NOMOVE);
     1176        cx = 0;
     1177        cy = 0;
    11771178    }
    11781179    else {
    1179         infoPtr->nWidth = parent_rect.right - parent_rect.left;
    1180         TOOLBAR_CalcToolbar (hwnd);
    1181         InvalidateRect( hwnd, NULL, TRUE );
    1182         cy = infoPtr->nHeight;
    1183         cx = infoPtr->nWidth;
     1180        infoPtr->nWidth = parent_rect.right - parent_rect.left;
     1181        TOOLBAR_CalcToolbar (hwnd);
     1182        InvalidateRect( hwnd, NULL, TRUE );
     1183        cy = infoPtr->nHeight;
     1184        cx = infoPtr->nWidth;
    11841185    }
    11851186
    11861187    if (dwStyle & CCS_NOPARENTALIGN)
    1187         uPosFlags |= SWP_NOMOVE;
     1188        uPosFlags |= SWP_NOMOVE;
    11881189
    11891190    if (!(dwStyle & CCS_NODIVIDER))
    1190         cy += GetSystemMetrics(SM_CYEDGE);
     1191        cy += GetSystemMetrics(SM_CYEDGE);
    11911192
    11921193    infoPtr->bAutoSize = TRUE;
    11931194    SetWindowPos (hwnd, HWND_TOP, parent_rect.left, parent_rect.top,
    1194                     cx, cy, uPosFlags);
     1195                    cx, cy, uPosFlags);
    11951196
    11961197    return 0;
    … …  
    12131214
    12141215    if (infoPtr == NULL) {
    1215 //      ERR (toolbar, "(0x%x, 0x%x, 0x%lx)\n", hwnd, wParam, lParam);
    1216 //      ERR (toolbar, "infoPtr == NULL!\n");
    1217         return 0;
     1216//      ERR (toolbar, "(0x%x, 0x%x, 0x%lx)\n", hwnd, wParam, lParam);
     1217//      ERR (toolbar, "infoPtr == NULL!\n");
     1218        return 0;
    12181219    }
    12191220
    … …  
    12341235    nIndex = TOOLBAR_GetButtonIndex (infoPtr, (INT)wParam);
    12351236    if (nIndex == -1)
    1236         return FALSE;
     1237        return FALSE;
    12371238
    12381239    btnPtr = &infoPtr->buttons[nIndex];
    … …  
    12581259    nIndex = TOOLBAR_GetButtonIndex (infoPtr, (INT)wParam);
    12591260    if (nIndex == -1)
    1260         return FALSE;
     1261        return FALSE;
    12611262
    12621263    btnPtr = &infoPtr->buttons[nIndex];
    12631264
    12641265    if (!(btnPtr->fsStyle & TBSTYLE_CHECK))
    1265         return FALSE;
     1266        return FALSE;
    12661267
    12671268    if (LOWORD(lParam) == FALSE)
    1268         btnPtr->fsState &= ~TBSTATE_CHECKED;
     1269        btnPtr->fsState &= ~TBSTATE_CHECKED;
    12691270    else {
    1270         if (btnPtr->fsStyle & TBSTYLE_GROUP) {
    1271             nOldIndex =
    1272                 TOOLBAR_GetCheckedGroupButtonIndex (infoPtr, nIndex);
    1273             if (nOldIndex == nIndex)
    1274                 return 0;
    1275             if (nOldIndex != -1)
    1276                 infoPtr->buttons[nOldIndex].fsState &= ~TBSTATE_CHECKED;
    1277         }
    1278         btnPtr->fsState |= TBSTATE_CHECKED;
     1271        if (btnPtr->fsStyle & TBSTYLE_GROUP) {
     1272            nOldIndex =
     1273                TOOLBAR_GetCheckedGroupButtonIndex (infoPtr, nIndex);
     1274            if (nOldIndex == nIndex)
     1275                return 0;
     1276            if (nOldIndex != -1)
     1277                infoPtr->buttons[nOldIndex].fsState &= ~TBSTATE_CHECKED;
     1278        }
     1279        btnPtr->fsState |= TBSTATE_CHECKED;
    12791280    }
    12801281
    12811282    hdc = GetDC (hwnd);
    12821283    if (nOldIndex != -1)
    1283         TOOLBAR_DrawButton (hwnd, &infoPtr->buttons[nOldIndex], hdc);
     1284        TOOLBAR_DrawButton (hwnd, &infoPtr->buttons[nOldIndex], hdc);
    12841285    TOOLBAR_DrawButton (hwnd, btnPtr, hdc);
    12851286    ReleaseDC (hwnd, hdc);
    … …  
    13151316
    13161317    SendMessageA (infoPtr->hwndNotify, WM_NOTIFY,
    1317                   (WPARAM)nmhdr.idFrom, (LPARAM)&nmhdr);
     1318                  (WPARAM)nmhdr.idFrom, (LPARAM)&nmhdr);
    13181319
    13191320    if (!(hRes = FindResourceA (COMCTL32_hModule,
    13201321                                MAKEINTRESOURCEA(IDD_TBCUSTOMIZE),
    13211322                                RT_DIALOGA)))
    1322         return FALSE;
     1323        return FALSE;
    13231324
    13241325    if(!(template = (LPVOID)LoadResource (COMCTL32_hModule, hRes)))
    1325         return FALSE;
     1326        return FALSE;
    13261327
    13271328    ret = DialogBoxIndirectParamA (GetWindowLongA (hwnd, GWL_HINSTANCE),
    … …  
    13351336
    13361337    SendMessageA (infoPtr->hwndNotify, WM_NOTIFY,
    1337                   (WPARAM)nmhdr.idFrom, (LPARAM)&nmhdr);
     1338                  (WPARAM)nmhdr.idFrom, (LPARAM)&nmhdr);
    13381339
    13391340    return ret;
    … …  
    13481349
    13491350    if ((nIndex < 0) || (nIndex >= infoPtr->nNumButtons))
    1350         return FALSE;
    1351 
    1352     if ((infoPtr->hwndToolTip) && 
    1353         !(infoPtr->buttons[nIndex].fsStyle & TBSTYLE_SEP)) {
    1354         TTTOOLINFOA ti;
    1355 
    1356         ZeroMemory (&ti, sizeof(TTTOOLINFOA));
    1357         ti.cbSize   = sizeof (TTTOOLINFOA);
    1358         ti.hwnd     = hwnd;
    1359         ti.uId      = infoPtr->buttons[nIndex].idCommand;
    1360 
    1361         SendMessageA (infoPtr->hwndToolTip, TTM_DELTOOLA, 0, (LPARAM)&ti);
     1351        return FALSE;
     1352
     1353    if ((infoPtr->hwndToolTip) &&
     1354        !(infoPtr->buttons[nIndex].fsStyle & TBSTYLE_SEP)) {
     1355        TTTOOLINFOA ti;
     1356
     1357        ZeroMemory (&ti, sizeof(TTTOOLINFOA));
     1358        ti.cbSize   = sizeof (TTTOOLINFOA);
     1359        ti.hwnd     = hwnd;
     1360        ti.uId      = infoPtr->buttons[nIndex].idCommand;
     1361
     1362        SendMessageA (infoPtr->hwndToolTip, TTM_DELTOOLA, 0, (LPARAM)&ti);
    13621363    }
    13631364
    13641365    if (infoPtr->nNumButtons == 1) {
    1365 //      TRACE (toolbar, " simple delete!\n");
    1366         COMCTL32_Free (infoPtr->buttons);
    1367         infoPtr->buttons = NULL;
    1368         infoPtr->nNumButtons = 0;
     1366//      TRACE (toolbar, " simple delete!\n");
     1367        COMCTL32_Free (infoPtr->buttons);
     1368        infoPtr->buttons = NULL;
     1369        infoPtr->nNumButtons = 0;
    13691370    }
    13701371    else {
    1371         TBUTTON_INFO *oldButtons = infoPtr->buttons;
     1372        TBUTTON_INFO *oldButtons = infoPtr->buttons;
    13721373//        TRACE(toolbar, "complex delete! [nIndex=%d]\n", nIndex);
    13731374
    1374         infoPtr->nNumButtons--;
    1375         infoPtr->buttons = COMCTL32_Alloc (sizeof (TBUTTON_INFO) * infoPtr->nNumButtons);
     1375        infoPtr->nNumButtons--;
     1376        infoPtr->buttons = COMCTL32_Alloc (sizeof (TBUTTON_INFO) * infoPtr->nNumButtons);
    13761377        if (nIndex > 0) {
    13771378            memcpy (&infoPtr->buttons[0], &oldButtons[0],
    … …  
    13841385        }
    13851386
    1386         COMCTL32_Free (oldButtons);
     1387        COMCTL32_Free (oldButtons);
    13871388    }
    13881389
    … …  
    14051406    nIndex = TOOLBAR_GetButtonIndex (infoPtr, (INT)wParam);
    14061407    if (nIndex == -1)
    1407         return FALSE;
     1408        return FALSE;
    14081409
    14091410    btnPtr = &infoPtr->buttons[nIndex];
    14101411    if (LOWORD(lParam) == FALSE)
    1411         btnPtr->fsState &= ~(TBSTATE_ENABLED | TBSTATE_PRESSED);
     1412        btnPtr->fsState &= ~(TBSTATE_ENABLED | TBSTATE_PRESSED);
    14121413    else
    1413         btnPtr->fsState |= TBSTATE_ENABLED;
     1414        btnPtr->fsState |= TBSTATE_ENABLED;
    14141415
    14151416    hdc = GetDC (hwnd);
    … …  
    14321433    nIndex = TOOLBAR_GetButtonIndex (infoPtr, (INT)wParam);
    14331434    if (nIndex == -1)
    1434         return -1;
     1435        return -1;
    14351436
    14361437    return infoPtr->buttons[nIndex].iBitmap;
    … …  
    14541455
    14551456    if (infoPtr == NULL)
    1456         return FALSE;
     1457        return FALSE;
    14571458
    14581459    if (lpTbb == NULL)
    1459         return FALSE;
     1460        return FALSE;
    14601461
    14611462    if ((nIndex < 0) || (nIndex >= infoPtr->nNumButtons))
    1462         return FALSE;
     1463        return FALSE;
    14631464
    14641465    btnPtr = &infoPtr->buttons[nIndex];
    … …  
    14831484
    14841485    if (infoPtr == NULL)
    1485         return -1;
     1486        return -1;
    14861487    if (lpTbInfo == NULL)
    1487         return -1;
     1488        return -1;
    14881489    if (lpTbInfo->cbSize < sizeof(TBBUTTONINFOA))
    1489         return -1;
     1490        return -1;
    14901491
    14911492    nIndex = TOOLBAR_GetButtonIndex (infoPtr, (INT)wParam);
    14921493    if (nIndex == -1)
    1493         return -1;
     1494        return -1;
    14941495
    14951496    btnPtr = &infoPtr->buttons[nIndex];
    14961497
    14971498    if (lpTbInfo->dwMask & TBIF_COMMAND)
    1498         lpTbInfo->idCommand = btnPtr->idCommand;
     1499        lpTbInfo->idCommand = btnPtr->idCommand;
    14991500    if (lpTbInfo->dwMask & TBIF_IMAGE)
    1500         lpTbInfo->iImage = btnPtr->iBitmap;
     1501        lpTbInfo->iImage = btnPtr->iBitmap;
    15011502    if (lpTbInfo->dwMask & TBIF_LPARAM)
    1502         lpTbInfo->lParam = btnPtr->dwData;
     1503        lpTbInfo->lParam = btnPtr->dwData;
    15031504    if (lpTbInfo->dwMask & TBIF_SIZE)
    1504         lpTbInfo->cx = (WORD)(btnPtr->rect.right - btnPtr->rect.left);
     1505        lpTbInfo->cx = (WORD)(btnPtr->rect.right - btnPtr->rect.left);
    15051506    if (lpTbInfo->dwMask & TBIF_STATE)
    1506         lpTbInfo->fsState = btnPtr->fsState;
     1507        lpTbInfo->fsState = btnPtr->fsState;
    15071508    if (lpTbInfo->dwMask & TBIF_STYLE)
    1508         lpTbInfo->fsStyle = btnPtr->fsStyle;
     1509        lpTbInfo->fsStyle = btnPtr->fsStyle;
    15091510    if (lpTbInfo->dwMask & TBIF_TEXT) {
    1510         if ((btnPtr->iString >= 0) || (btnPtr->iString < infoPtr->nNumStrings))
    1511             lstrcpynA (lpTbInfo->pszText,
    1512                         (LPSTR)infoPtr->strings[btnPtr->iString],
    1513                         lpTbInfo->cchText);
     1511        if ((btnPtr->iString >= 0) || (btnPtr->iString < infoPtr->nNumStrings))
     1512            lstrcpynA (lpTbInfo->pszText,
     1513                        (LPSTR)infoPtr->strings[btnPtr->iString],
     1514                        lpTbInfo->cchText);
    15141515    }
    15151516
    … …  
    15271528
    15281529    return MAKELONG((WORD)infoPtr->nButtonWidth,
    1529                     (WORD)infoPtr->nButtonHeight);
     1530                    (WORD)infoPtr->nButtonHeight);
    15301531}
    15311532
    … …  
    15391540    nIndex = TOOLBAR_GetButtonIndex (infoPtr, (INT)wParam);
    15401541    if (nIndex == -1)
    1541         return -1;
     1542        return -1;
    15421543
    15431544    nStringIndex = infoPtr->buttons[nIndex].iString;
    … …  
    15461547
    15471548    if ((nStringIndex < 0) || (nStringIndex >= infoPtr->nNumStrings))
    1548         return -1;
     1549        return -1;
    15491550
    15501551    if (lParam == 0) return -1;
    … …  
    15661567
    15671568    if (GetWindowLongA (hwnd, GWL_STYLE) & TBSTYLE_FLAT)
    1568         return (LRESULT)infoPtr->himlDis;
     1569        return (LRESULT)infoPtr->himlDis;
    15691570    else
    1570         return 0;
     1571        return 0;
    15711572}
    15721573
    … …  
    15871588
    15881589    if (GetWindowLongA (hwnd, GWL_STYLE) & TBSTYLE_FLAT)
    1589         return (LRESULT)infoPtr->himlHot;
     1590        return (LRESULT)infoPtr->himlHot;
    15901591    else
    1591         return 0;
     1592        return 0;
    15921593}
    15931594
    … …  
    16021603
    16031604    if (GetWindowLongA (hwnd, GWL_STYLE) & TBSTYLE_FLAT)
    1604         return (LRESULT)infoPtr->himlDef;
     1605        return (LRESULT)infoPtr->himlDef;
    16051606    else
    1606         return 0;
     1607        return 0;
    16071608}
    16081609
    … …  
    16211622
    16221623    if (infoPtr == NULL)
    1623         return FALSE;
     1624        return FALSE;
    16241625    nIndex = (INT)wParam;
    16251626    btnPtr = &infoPtr->buttons[nIndex];
    16261627    if ((nIndex < 0) || (nIndex >= infoPtr->nNumButtons))
    1627         return FALSE;
     1628        return FALSE;
    16281629    lpRect = (LPRECT)lParam;
    16291630    if (lpRect == NULL)
    1630         return FALSE;
     1631        return FALSE;
    16311632    if (btnPtr->fsState & TBSTATE_HIDDEN)
    1632         return FALSE;
    1633    
     1633        return FALSE;
     1634
    16341635    TOOLBAR_CalcToolbar( hwnd );
    1635    
     1636
    16361637    lpRect->left   = btnPtr->rect.left;
    16371638    lpRect->right  = btnPtr->rect.right;
    … …  
    16501651
    16511652    if (lpSize == NULL)
    1652         return FALSE;
     1653        return FALSE;
    16531654
    16541655    lpSize->cx = infoPtr->rcBound.right - infoPtr->rcBound.left;
    … …  
    16561657
    16571658//    TRACE (toolbar, "maximum size %d x %d\n",
    1658 //         infoPtr->rcBound.right - infoPtr->rcBound.left,
    1659 //         infoPtr->rcBound.bottom - infoPtr->rcBound.top);
     1659//         infoPtr->rcBound.right - infoPtr->rcBound.left,
     1660//         infoPtr->rcBound.bottom - infoPtr->rcBound.top);
    16601661
    16611662    return TRUE;
    … …  
    16761677
    16771678    if (infoPtr == NULL)
    1678         return FALSE;
     1679        return FALSE;
    16791680    nIndex = (INT)wParam;
    16801681    btnPtr = &infoPtr->buttons[nIndex];
    16811682    if ((nIndex < 0) || (nIndex >= infoPtr->nNumButtons))
    1682         return FALSE;
     1683        return FALSE;
    16831684    lpRect = (LPRECT)lParam;
    16841685    if (lpRect == NULL)
    1685         return FALSE;
    1686    
     1686        return FALSE;
     1687
    16871688    lpRect->left   = btnPtr->rect.left;
    16881689    lpRect->right  = btnPtr->rect.right;
    … …  
    17001701
    17011702    if (GetWindowLongA (hwnd, GWL_STYLE) & TBSTYLE_WRAPABLE)
    1702         return infoPtr->nRows;
     1703        return infoPtr->nRows;
    17031704    else
    1704         return 1;
     1705        return 1;
    17051706}
    17061707
    … …  
    17141715    nIndex = TOOLBAR_GetButtonIndex (infoPtr, (INT)wParam);
    17151716    if (nIndex == -1)
    1716         return -1;
     1717        return -1;
    17171718
    17181719    return infoPtr->buttons[nIndex].fsState;
    … …  
    17281729    nIndex = TOOLBAR_GetButtonIndex (infoPtr, (INT)wParam);
    17291730    if (nIndex == -1)
    1730         return -1;
     1731        return -1;
    17311732
    17321733    return infoPtr->buttons[nIndex].fsStyle;
    … …  
    17401741
    17411742    if (infoPtr == NULL)
    1742         return 0;
     1743        return 0;
    17431744
    17441745    return infoPtr->nMaxTextRows;
    … …  
    17521753
    17531754    if (infoPtr == NULL)
    1754         return 0;
     1755        return 0;
    17551756    return infoPtr->hwndToolTip;
    17561757}
    … …  
    17621763    TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr (hwnd);
    17631764
    1764 //    TRACE (toolbar, "%s hwnd=0x%x stub!\n", 
    1765 //         infoPtr->bUnicode ? "TRUE" : "FALSE", hwnd);
     1765//    TRACE (toolbar, "%s hwnd=0x%x stub!\n",
     1766//         infoPtr->bUnicode ? "TRUE" : "FALSE", hwnd);
    17661767
    17671768    return infoPtr->bUnicode;
    … …  
    17781779    nIndex = TOOLBAR_GetButtonIndex (infoPtr, (INT)wParam);
    17791780    if (nIndex == -1)
    1780         return FALSE;
     1781        return FALSE;
    17811782
    17821783    btnPtr = &infoPtr->buttons[nIndex];
    17831784    if (LOWORD(lParam) == FALSE)
    1784         btnPtr->fsState &= ~TBSTATE_HIDDEN;
     1785        btnPtr->fsState &= ~TBSTATE_HIDDEN;
    17851786    else
    1786         btnPtr->fsState |= TBSTATE_HIDDEN;
     1787        btnPtr->fsState |= TBSTATE_HIDDEN;
    17871788
    17881789    TOOLBAR_CalcToolbar (hwnd);
    … …  
    18111812    nIndex = TOOLBAR_GetButtonIndex (infoPtr, (INT)wParam);
    18121813    if (nIndex == -1)
    1813         return FALSE;
     1814        return FALSE;
    18141815
    18151816    btnPtr = &infoPtr->buttons[nIndex];
    18161817    if (LOWORD(lParam) == FALSE)
    1817         btnPtr->fsState &= ~TBSTATE_INDETERMINATE;
     1818        btnPtr->fsState &= ~TBSTATE_INDETERMINATE;
    18181819    else
    1819         btnPtr->fsState |= TBSTATE_INDETERMINATE;
     1820        btnPtr->fsState |= TBSTATE_INDETERMINATE;
    18201821
    18211822    hdc = GetDC (hwnd);
    … …  
    18361837
    18371838    if (lpTbb == NULL)
    1838         return FALSE;
     1839        return FALSE;
    18391840    if (nIndex < 0)
    1840         return FALSE;
     1841        return FALSE;
    18411842
    18421843//    TRACE (toolbar, "inserting button index=%d\n", nIndex);
    18431844    if (nIndex > infoPtr->nNumButtons) {
    1844         nIndex = infoPtr->nNumButtons;
    1845 //      TRACE (toolbar, "adjust index=%d\n", nIndex);
     1845        nIndex = infoPtr->nNumButtons;
     1846//      TRACE (toolbar, "adjust index=%d\n", nIndex);
    18461847    }
    18471848
    … …  
    18511852    /* pre insert copy */
    18521853    if (nIndex > 0) {
    1853         memcpy (&infoPtr->buttons[0], &oldButtons[0],
    1854                 nIndex * sizeof(TBUTTON_INFO));
     1854        memcpy (&infoPtr->buttons[0], &oldButtons[0],
     1855                nIndex * sizeof(TBUTTON_INFO));
    18551856    }
    18561857
    … …  
    18641865
    18651866    if ((infoPtr->hwndToolTip) && !(lpTbb->fsStyle & TBSTYLE_SEP)) {
    1866         TTTOOLINFOA ti;
    1867 
    1868         ZeroMemory (&ti, sizeof(TTTOOLINFOA));
    1869         ti.cbSize   = sizeof (TTTOOLINFOA);
    1870         ti.hwnd     = hwnd;
    1871         ti.uId      = lpTbb->idCommand;
    1872         ti.hinst    = 0;
    1873         ti.lpszText = LPSTR_TEXTCALLBACKA;
    1874 
    1875         SendMessageA (infoPtr->hwndToolTip, TTM_ADDTOOLA,
    1876                         0, (LPARAM)&ti);
     1867        TTTOOLINFOA ti;
     1868
     1869        ZeroMemory (&ti, sizeof(TTTOOLINFOA));
     1870        ti.cbSize   = sizeof (TTTOOLINFOA);
     1871        ti.hwnd     = hwnd;
     1872        ti.uId      = lpTbb->idCommand;
     1873        ti.hinst    = 0;
     1874        ti.lpszText = LPSTR_TEXTCALLBACKA;
     1875
     1876        SendMessageA (infoPtr->hwndToolTip, TTM_ADDTOOLA,
     1877                        0, (LPARAM)&ti);
    18771878    }
    18781879
    18791880    /* post insert copy */
    18801881    if (nIndex < infoPtr->nNumButtons - 1) {
    1881         memcpy (&infoPtr->buttons[nIndex+1], &oldButtons[nIndex],
    1882                 (infoPtr->nNumButtons - nIndex - 1) * sizeof(TBUTTON_INFO));
     1882        memcpy (&infoPtr->buttons[nIndex+1], &oldButtons[nIndex],
     1883                (infoPtr->nNumButtons - nIndex - 1) * sizeof(TBUTTON_INFO));
    18831884    }
    18841885
    … …  
    19051906    nIndex = TOOLBAR_GetButtonIndex (infoPtr, (INT)wParam);
    19061907    if (nIndex == -1)
    1907         return FALSE;
     1908        return FALSE;
    19081909
    19091910    return (infoPtr->buttons[nIndex].fsState & TBSTATE_CHECKED);
    … …  
    19191920    nIndex = TOOLBAR_GetButtonIndex (infoPtr, (INT)wParam);
    19201921    if (nIndex == -1)
    1921         return FALSE;
     1922        return FALSE;
    19221923
    19231924    return (infoPtr->buttons[nIndex].fsState & TBSTATE_ENABLED);
    … …  
    19331934    nIndex = TOOLBAR_GetButtonIndex (infoPtr, (INT)wParam);
    19341935    if (nIndex == -1)
    1935         return FALSE;
     1936        return FALSE;
    19361937
    19371938    return (infoPtr->buttons[nIndex].fsState & TBSTATE_HIDDEN);
    … …  
    19471948    nIndex = TOOLBAR_GetButtonIndex (infoPtr, (INT)wParam);
    19481949    if (nIndex == -1)
    1949         return FALSE;
     1950        return FALSE;
    19501951
    19511952    return (infoPtr->buttons[nIndex].fsState & TBSTATE_MARKED);
    … …  
    19611962    nIndex = TOOLBAR_GetButtonIndex (infoPtr, (INT)wParam);
    19621963    if (nIndex == -1)
    1963         return FALSE;
     1964        return FALSE;
    19641965
    19651966    return (infoPtr->buttons[nIndex].fsState & TBSTATE_INDETERMINATE);
    … …  
    19751976    nIndex = TOOLBAR_GetButtonIndex (infoPtr, (INT)wParam);
    19761977    if (nIndex == -1)
    1977         return FALSE;
     1978        return FALSE;
    19781979
    19791980    return (infoPtr->buttons[nIndex].fsState & TBSTATE_PRESSED);
    … …  
    19971998    nIndex = TOOLBAR_GetButtonIndex (infoPtr, (INT)wParam);
    19981999    if (nIndex == -1)
    1999         return FALSE;
     2000        return FALSE;
    20002001
    20012002    btnPtr = &infoPtr->buttons[nIndex];
    20022003    if (LOWORD(lParam) == FALSE)
    2003         btnPtr->fsState &= ~TBSTATE_PRESSED;
     2004        btnPtr->fsState &= ~TBSTATE_PRESSED;
    20042005    else
    2005         btnPtr->fsState |= TBSTATE_PRESSED;
     2006        btnPtr->fsState |= TBSTATE_PRESSED;
    20062007
    20072008    hdc = GetDC (hwnd);
    … …  
    20262027
    20272028    if ((BOOL)wParam) {
    2028         /* save toolbar information */
    2029 //      FIXME (toolbar, "save to \"%s\" \"%s\"\n",
    2030 //             lpSave->pszSubKey, lpSave->pszValueName);
     2029        /* save toolbar information */
     2030//      FIXME (toolbar, "save to \"%s\" \"%s\"\n",
     2031//             lpSave->pszSubKey, lpSave->pszValueName);
    20312032
    20322033
    20332034    }
    20342035    else {
    2035         /* restore toolbar information */
    2036 
    2037 //      FIXME (toolbar, "restore from \"%s\" \"%s\"\n",
    2038 //             lpSave->pszSubKey, lpSave->pszValueName);
     2036        /* restore toolbar information */
     2037
     2038//      FIXME (toolbar, "restore from \"%s\" \"%s\"\n",
     2039//             lpSave->pszSubKey, lpSave->pszValueName);
    20392040
    20402041
    … …  
    20562057
    20572058    if ((LOWORD(lParam) <= 0) || (HIWORD(lParam)<=0))
    2058         return FALSE;
     2059        return FALSE;
    20592060
    20602061    infoPtr->nBitmapWidth = (INT)LOWORD(lParam);
    … …  
    20742075
    20752076    if (lptbbi == NULL)
    2076         return FALSE;
     2077        return FALSE;
    20772078    if (lptbbi->cbSize < sizeof(TBBUTTONINFOA))
    2078         return FALSE;
    2079    
     2079        return FALSE;
     2080
    20802081    nIndex = TOOLBAR_GetButtonIndex (infoPtr, (INT)wParam);
    20812082    if (nIndex == -1)
    2082         return FALSE;
     2083        return FALSE;
    20832084
    20842085    btnPtr = &infoPtr->buttons[nIndex];
    20852086    if (lptbbi->dwMask & TBIF_COMMAND)
    2086         btnPtr->idCommand = lptbbi->idCommand;
     2087        btnPtr->idCommand = lptbbi->idCommand;
    20872088    if (lptbbi->dwMask & TBIF_IMAGE)
    2088         btnPtr->iBitmap = lptbbi->iImage;
     2089        btnPtr->iBitmap = lptbbi->iImage;
    20892090    if (lptbbi->dwMask & TBIF_LPARAM)
    2090         btnPtr->dwData = lptbbi->lParam;
     2091        btnPtr->dwData = lptbbi->lParam;
    20912092/*    if (lptbbi->dwMask & TBIF_SIZE) */
    2092 /*      btnPtr->cx = lptbbi->cx; */
     2093/*      btnPtr->cx = lptbbi->cx; */
    20932094    if (lptbbi->dwMask & TBIF_STATE)
    2094         btnPtr->fsState = lptbbi->fsState;
     2095        btnPtr->fsState = lptbbi->fsState;
    20952096    if (lptbbi->dwMask & TBIF_STYLE)
    2096         btnPtr->fsStyle = lptbbi->fsStyle;
     2097        btnPtr->fsStyle = lptbbi->fsStyle;
    20972098
    20982099    if (lptbbi->dwMask & TBIF_TEXT) {
    2099         if ((btnPtr->iString >= 0) ||
    2100             (btnPtr->iString < infoPtr->nNumStrings)) {
     2100        if ((btnPtr->iString >= 0) ||
     2101            (btnPtr->iString < infoPtr->nNumStrings)) {
    21012102#if 0
    2102             CHAR **lpString = &infoPtr->strings[btnPtr->iString];
    2103             INT len = lstrlenA (lptbbi->pszText);
    2104             *lpString = COMCTL32_ReAlloc (lpString, sizeof(char)*(len+1));
     2103            CHAR **lpString = &infoPtr->strings[btnPtr->iString];
     2104            INT len = lstrlenA (lptbbi->pszText);
     2105            *lpString = COMCTL32_ReAlloc (lpString, sizeof(char)*(len+1));
    21052106#endif
    21062107
    2107             /* this is the ultimate sollution */
    2108 /*          Str_SetPtrA (&infoPtr->strings[btnPtr->iString], lptbbi->pszText); */
    2109         }
     2108            /* this is the ultimate sollution */
     2109/*          Str_SetPtrA (&infoPtr->strings[btnPtr->iString], lptbbi->pszText); */
     2110        }
    21102111    }
    21112112
    … …  
    21232124
    21242125    if ((LOWORD(lParam) <= 0) || (HIWORD(lParam)<=0))
    2125         return FALSE;
     2126        return FALSE;
    21262127
    21272128    infoPtr->nButtonWidth = (INT)LOWORD(lParam);
    … …  
    21382139
    21392140    if (infoPtr == NULL)
    2140         return FALSE;
     2141        return FALSE;
    21412142
    21422143    infoPtr->cxMin = (INT)LOWORD(lParam);
    … …  
    21542155
    21552156    if ((nIndex < 0) || (nIndex >= infoPtr->nNumButtons))
    2156         return FALSE;
     2157        return FALSE;
    21572158
    21582159    infoPtr->buttons[nIndex].idCommand = (INT)lParam;
    … …  
    21602161    if (infoPtr->hwndToolTip) {
    21612162
    2162 //      FIXME (toolbar, "change tool tip!\n");
     2163//      FIXME (toolbar, "change tool tip!\n");
    21632164
    21642165    }
    … …  
    21782179
    21792180    if (!(GetWindowLongA (hwnd, GWL_STYLE) & TBSTYLE_FLAT))
    2180         return 0;
     2181        return 0;
    21812182
    21822183    himlTemp = infoPtr->himlDis;
    … …  
    21852186    /* FIXME: redraw ? */
    21862187
    2187     return (LRESULT)himlTemp; 
     2188    return (LRESULT)himlTemp;
    21882189}
    21892190
    … …  
    21972198    dwTemp = infoPtr->dwDTFlags;
    21982199    infoPtr->dwDTFlags =
    2199         (infoPtr->dwDTFlags & (DWORD)wParam) | (DWORD)lParam;
     2200        (infoPtr->dwDTFlags & (DWORD)wParam) | (DWORD)lParam;
    22002201
    22012202    return (LRESULT)dwTemp;
    … …  
    22122213    infoPtr->dwExStyle = (DWORD)lParam;
    22132214
    2214     return (LRESULT)dwTemp; 
     2215    return (LRESULT)dwTemp;
    22152216}
    22162217
    … …  
    22232224
    22242225    if (!(GetWindowLongA (hwnd, GWL_STYLE) & TBSTYLE_FLAT))
    2225         return 0;
     2226        return 0;
    22262227
    22272228    himlTemp = infoPtr->himlHot;
    … …  
    22302231    /* FIXME: redraw ? */
    22312232
    2232     return (LRESULT)himlTemp; 
     2233    return (LRESULT)himlTemp;
    22332234}
    22342235
    … …  
    22442245
    22452246    if (!(GetWindowLongA (hwnd, GWL_STYLE) & TBSTYLE_FLAT))
    2246         return 0;
     2247        return 0;
    22472248
    22482249    himlTemp = infoPtr->himlDef;
    … …  
    22512252    /* FIXME: redraw ? */
    22522253
    2253     return (LRESULT)himlTemp; 
     2254    return (LRESULT)himlTemp;
    22542255}
    22552256
    … …  
    22922293
    22932294    if (infoPtr == NULL)
    2294         return FALSE;
     2295        return FALSE;
    22952296
    22962297    infoPtr->nMaxTextRows = (INT)wParam;
    … …  
    23102311
    23112312    if (infoPtr == NULL)
    2312         return 0;
     2313        return 0;
    23132314    hwndOldNotify = infoPtr->hwndNotify;
    23142315    infoPtr->hwndNotify = (HWND)wParam;
    … …  
    23262327    if (LOWORD(wParam) > 1) {
    23272328
    2328 //      FIXME (toolbar, "multiple rows not supported!\n");
     2329//      FIXME (toolbar, "multiple rows not supported!\n");
    23292330
    23302331    }
    … …  
    23352336    /* return bounding rectangle */
    23362337    if (lprc) {
    2337         lprc->left   = infoPtr->rcBound.left;
    2338         lprc->right  = infoPtr->rcBound.right;
    2339         lprc->top    = infoPtr->rcBound.top;
    2340         lprc->bottom = infoPtr->rcBound.bottom;
     2338        lprc->left   = infoPtr->rcBound.left;
     2339        lprc->right  = infoPtr->rcBound.right;
     2340        lprc->top    = infoPtr->rcBound.top;
     2341        lprc->bottom = infoPtr->rcBound.bottom;
    23412342    }
    23422343
    … …  
    23582359    nIndex = TOOLBAR_GetButtonIndex (infoPtr, (INT)wParam);
    23592360    if (nIndex == -1)
    2360         return FALSE;
     2361        return FALSE;
    23612362
    23622363    btnPtr = &infoPtr->buttons[nIndex];
    … …  
    23812382    nIndex = TOOLBAR_GetButtonIndex (infoPtr, (INT)wParam);
    23822383    if (nIndex == -1)
    2383         return FALSE;
     2384        return FALSE;
    23842385
    23852386    btnPtr = &infoPtr->buttons[nIndex];
    … …  
    23922393    if (infoPtr->hwndToolTip) {
    23932394
    2394 //      FIXME (toolbar, "change tool tip!\n");
     2395//      FIXME (toolbar, "change tool tip!\n");
    23952396
    23962397    }
    … …  
    24062407
    24072408    if (infoPtr == NULL)
    2408         return 0;
     2409        return 0;
    24092410    infoPtr->hwndToolTip = (HWND)wParam;
    24102411    return 0;
    … …  
    24182419    BOOL bTemp;
    24192420
    2420 //    TRACE (toolbar, "%s hwnd=0x%04x stub!\n", 
    2421 //         ((BOOL)wParam) ? "TRUE" : "FALSE", hwnd);
     2421//    TRACE (toolbar, "%s hwnd=0x%04x stub!\n",
     2422//         ((BOOL)wParam) ? "TRUE" : "FALSE", hwnd);
    24222423
    24232424    bTemp = infoPtr->bUnicode;
    … …  
    24602461
    24612462    if (dwStyle & TBSTYLE_TOOLTIPS) {
    2462         /* Create tooltip control */
    2463         infoPtr->hwndToolTip =
    2464             CreateWindowExA (0, TOOLTIPS_CLASSA, NULL, 0,
    2465                                CW_USEDEFAULT, CW_USEDEFAULT,
    2466                                CW_USEDEFAULT, CW_USEDEFAULT,
    2467                                hwnd, 0, 0, 0);
    2468 
    2469         /* Send NM_TOOLTIPSCREATED notification */
    2470         if (infoPtr->hwndToolTip) {
    2471             NMTOOLTIPSCREATED nmttc;
    2472 
    2473             nmttc.hdr.hwndFrom = hwnd;
    2474             nmttc.hdr.idFrom   = GetWindowLongA (hwnd, GWL_ID);
    2475             nmttc.hdr.code = NM_TOOLTIPSCREATED;
    2476             nmttc.hwndToolTips = infoPtr->hwndToolTip;
    2477 
    2478             SendMessageA (infoPtr->hwndNotify, WM_NOTIFY,
    2479                           (WPARAM)nmttc.hdr.idFrom, (LPARAM)&nmttc);
    2480         }
     2463        /* Create tooltip control */
     2464        infoPtr->hwndToolTip =
     2465            CreateWindowExA (0, TOOLTIPS_CLASSA, NULL, 0,
     2466                               CW_USEDEFAULT, CW_USEDEFAULT,
     2467                               CW_USEDEFAULT, CW_USEDEFAULT,
     2468                               hwnd, 0, 0, 0);
     2469
     2470        /* Send NM_TOOLTIPSCREATED notification */
     2471        if (infoPtr->hwndToolTip) {
     2472            NMTOOLTIPSCREATED nmttc;
     2473
     2474            nmttc.hdr.hwndFrom = hwnd;
     2475            nmttc.hdr.idFrom   = GetWindowLongA (hwnd, GWL_ID);
     2476            nmttc.hdr.code = NM_TOOLTIPSCREATED;
     2477            nmttc.hwndToolTips = infoPtr->hwndToolTip;
     2478
     2479            SendMessageA (infoPtr->hwndNotify, WM_NOTIFY,
     2480                          (WPARAM)nmttc.hdr.idFrom, (LPARAM)&nmttc);
     2481        }
    24812482    }
    24822483
    … …  
    24922493    /* delete tooltip control */
    24932494    if (infoPtr->hwndToolTip)
    2494         DestroyWindow (infoPtr->hwndToolTip);
     2495        DestroyWindow (infoPtr->hwndToolTip);
    24952496
    24962497    /* delete button data */
    24972498    if (infoPtr->buttons)
    2498         COMCTL32_Free (infoPtr->buttons);
     2499        COMCTL32_Free (infoPtr->buttons);
    24992500
    25002501    /* delete strings */
    25012502    if (infoPtr->strings) {
    2502         INT i;
    2503         for (i = 0; i < infoPtr->nNumStrings; i++)
    2504             if (infoPtr->strings[i])
    2505                 COMCTL32_Free (infoPtr->strings[i]);
    2506 
    2507         COMCTL32_Free (infoPtr->strings);
     2503        INT i;
     2504        for (i = 0; i < infoPtr->nNumStrings; i++)
     2505            if (infoPtr->strings[i])
     2506                COMCTL32_Free (infoPtr->strings[i]);
     2507
     2508        COMCTL32_Free (infoPtr->strings);
    25082509    }
    25092510
    25102511    /* destroy default image list */
    25112512    if (infoPtr->himlDef)
    2512         ImageList_Destroy (infoPtr->himlDef);
     2513        ImageList_Destroy (infoPtr->himlDef);
    25132514
    25142515    /* destroy disabled image list */
    25152516    if (infoPtr->himlDis)
    2516         ImageList_Destroy (infoPtr->himlDis);
     2517        ImageList_Destroy (infoPtr->himlDis);
    25172518
    25182519    /* destroy hot image list */
    25192520    if (infoPtr->himlHot)
    2520         ImageList_Destroy (infoPtr->himlHot);
     2521        ImageList_Destroy (infoPtr->himlHot);
    25212522
    25222523    /* delete default font */
    25232524    if (infoPtr->hFont)
    2524         DeleteObject (infoPtr->hFont);
     2525        DeleteObject (infoPtr->hFont);
    25252526
    25262527    /* free toolbar info data */
    … …  
    25372538
    25382539    if (infoPtr->bTransparent)
    2539         return SendMessageA (GetParent (hwnd), WM_ERASEBKGND, wParam, lParam);
     2540        return SendMessageA (GetParent (hwnd), WM_ERASEBKGND, wParam, lParam);
    25402541
    25412542    return DefWindowProcA (hwnd, WM_ERASEBKGND, wParam, lParam);
    … …  
    25572558
    25582559    if (nHit >= 0) {
    2559         btnPtr = &infoPtr->buttons[nHit];
    2560         if (!(btnPtr->fsState & TBSTATE_ENABLED))
    2561             return 0;
    2562         SetCapture (hwnd);
    2563         infoPtr->bCaptured = TRUE;
    2564         infoPtr->nButtonDown = nHit;
    2565 
    2566         btnPtr->fsState |= TBSTATE_PRESSED;
    2567 
    2568         hdc = GetDC (hwnd);
    2569         TOOLBAR_DrawButton (hwnd, btnPtr, hdc);
    2570         ReleaseDC (hwnd, hdc);
     2560        btnPtr = &infoPtr->buttons[nHit];
     2561        if (!(btnPtr->fsState & TBSTATE_ENABLED))
     2562            return 0;
     2563        SetCapture (hwnd);
     2564        infoPtr->bCaptured = TRUE;
     2565        infoPtr->nButtonDown = nHit;
     2566
     2567        btnPtr->fsState |= TBSTATE_PRESSED;
     2568
     2569        hdc = GetDC (hwnd);
     2570        TOOLBAR_DrawButton (hwnd, btnPtr, hdc);
     2571        ReleaseDC (hwnd, hdc);
    25712572    }
    25722573    else if (GetWindowLongA (hwnd, GWL_STYLE) & CCS_ADJUSTABLE)
    2573         TOOLBAR_Customize (hwnd);
     2574        TOOLBAR_Customize (hwnd);
    25742575
    25752576    return 0;
    … …  
    25872588
    25882589    if (infoPtr->hwndToolTip)
    2589         TOOLBAR_RelayEvent (infoPtr->hwndToolTip, hwnd,
    2590                             WM_LBUTTONDOWN, wParam, lParam);
     2590        TOOLBAR_RelayEvent (infoPtr->hwndToolTip, hwnd,
     2591                            WM_LBUTTONDOWN, wParam, lParam);
    25912592
    25922593    pt.x = (INT)LOWORD(lParam);
    … …  
    25952596
    25962597    if (nHit >= 0) {
    2597         btnPtr = &infoPtr->buttons[nHit];
    2598         if (!(btnPtr->fsState & TBSTATE_ENABLED))
    2599             return 0;
    2600 
    2601         SetCapture (hwnd);
    2602         infoPtr->bCaptured = TRUE;
    2603         infoPtr->nButtonDown = nHit;
    2604         infoPtr->nOldHit = nHit;
    2605 
    2606         btnPtr->fsState |= TBSTATE_PRESSED;
    2607 
    2608         hdc = GetDC (hwnd);
    2609         TOOLBAR_DrawButton (hwnd, btnPtr, hdc);
    2610         ReleaseDC (hwnd, hdc);
     2598        btnPtr = &infoPtr->buttons[nHit];
     2599        if (!(btnPtr->fsState & TBSTATE_ENABLED))
     2600            return 0;
     2601
     2602        SetCapture (hwnd);
     2603        infoPtr->bCaptured = TRUE;
     2604        infoPtr->nButtonDown = nHit;
     2605        infoPtr->nOldHit = nHit;
     2606
     2607        btnPtr->fsState |= TBSTATE_PRESSED;
     2608
     2609        hdc = GetDC (hwnd);
     2610        TOOLBAR_DrawButton (hwnd, btnPtr, hdc);
     2611        ReleaseDC (hwnd, hdc);
    26112612    }
    26122613
    … …  
    26272628
    26282629    if (infoPtr->hwndToolTip)
    2629         TOOLBAR_RelayEvent (infoPtr->hwndToolTip, hwnd,
    2630                             WM_LBUTTONUP, wParam, lParam);
     2630        TOOLBAR_RelayEvent (infoPtr->hwndToolTip, hwnd,
     2631                            WM_LBUTTONUP, wParam, lParam);
    26312632
    26322633    pt.x = (INT)LOWORD(lParam);
    … …  
    26352636
    26362637    if ((infoPtr->bCaptured) && (infoPtr->nButtonDown >= 0)) {
    2637         infoPtr->bCaptured = FALSE;
    2638         ReleaseCapture ();
    2639         btnPtr = &infoPtr->buttons[infoPtr->nButtonDown];
    2640         btnPtr->fsState &= ~TBSTATE_PRESSED;
    2641 
    2642         if (nHit == infoPtr->nButtonDown) {
    2643             if (btnPtr->fsStyle & TBSTYLE_CHECK) {
    2644                 if (btnPtr->fsStyle & TBSTYLE_GROUP) {
    2645                     nOldIndex = TOOLBAR_GetCheckedGroupButtonIndex (infoPtr,
    2646                         infoPtr->nButtonDown);
    2647                     if (nOldIndex == infoPtr->nButtonDown)
    2648                         bSendMessage = FALSE;
    2649                     if ((nOldIndex != infoPtr->nButtonDown) &&
    2650                         (nOldIndex != -1))
    2651                         infoPtr->buttons[nOldIndex].fsState &= ~TBSTATE_CHECKED;
    2652                     btnPtr->fsState |= TBSTATE_CHECKED;
    2653                 }
    2654                 else {
    2655                     if (btnPtr->fsState & TBSTATE_CHECKED)
    2656                         btnPtr->fsState &= ~TBSTATE_CHECKED;
    2657                     else
    2658                         btnPtr->fsState |= TBSTATE_CHECKED;
    2659                 }
    2660             }
    2661         }
    2662         else
    2663             bSendMessage = FALSE;
    2664 
    2665         hdc = GetDC (hwnd);
    2666         if (nOldIndex != -1)
    2667             TOOLBAR_DrawButton (hwnd, &infoPtr->buttons[nOldIndex], hdc);
    2668         TOOLBAR_DrawButton (hwnd, btnPtr, hdc);
    2669         ReleaseDC (hwnd, hdc);
    2670 
    2671         if (bSendMessage)
    2672             SendMessageA (infoPtr->hwndNotify, WM_COMMAND,
    2673                           MAKEWPARAM(btnPtr->idCommand, 0), (LPARAM)hwnd);
    2674 
    2675         infoPtr->nButtonDown = -1;
    2676         infoPtr->nOldHit = -1;
     2638        infoPtr->bCaptured = FALSE;
     2639        ReleaseCapture ();
     2640        btnPtr = &infoPtr->buttons[infoPtr->nButtonDown];
     2641        btnPtr->fsState &= ~TBSTATE_PRESSED;
     2642
     2643        if (nHit == infoPtr->nButtonDown) {
     2644            if (btnPtr->fsStyle & TBSTYLE_CHECK) {
     2645                if (btnPtr->fsStyle & TBSTYLE_GROUP) {
     2646                    nOldIndex = TOOLBAR_GetCheckedGroupButtonIndex (infoPtr,
     2647                        infoPtr->nButtonDown);
     2648                    if (nOldIndex == infoPtr->nButtonDown)
     2649                        bSendMessage = FALSE;
     2650                    if ((nOldIndex != infoPtr->nButtonDown) &&
     2651                        (nOldIndex != -1))
     2652                        infoPtr->buttons[nOldIndex].fsState &= ~TBSTATE_CHECKED;
     2653                    btnPtr->fsState |= TBSTATE_CHECKED;
     2654                }
     2655                else {
     2656                    if (btnPtr->fsState & TBSTATE_CHECKED)
     2657                        btnPtr->fsState &= ~TBSTATE_CHECKED;
     2658                    else
     2659                        btnPtr->fsState |= TBSTATE_CHECKED;
     2660                }
     2661            }
     2662        }
     2663        else
     2664            bSendMessage = FALSE;
     2665
     2666        hdc = GetDC (hwnd);
     2667        if (nOldIndex != -1)
     2668            TOOLBAR_DrawButton (hwnd, &infoPtr->buttons[nOldIndex], hdc);
     2669        TOOLBAR_DrawButton (hwnd, btnPtr, hdc);
     2670        ReleaseDC (hwnd, hdc);
     2671
     2672        if (bSendMessage)
     2673            SendMessageA (infoPtr->hwndNotify, WM_COMMAND,
     2674                          MAKEWPARAM(btnPtr->idCommand, 0), (LPARAM)hwnd);
     2675
     2676        infoPtr->nButtonDown = -1;
     2677        infoPtr->nOldHit = -1;
    26772678    }
    26782679
    … …  
    26912692
    26922693    if (infoPtr->hwndToolTip)
    2693         TOOLBAR_RelayEvent (infoPtr->hwndToolTip, hwnd,
    2694                             WM_MOUSEMOVE, wParam, lParam);
     2694        TOOLBAR_RelayEvent (infoPtr->hwndToolTip, hwnd,
     2695                            WM_MOUSEMOVE, wParam, lParam);
    26952696
    26962697    pt.x = (INT)LOWORD(lParam);
    … …  
    27022703    {
    27032704        /* Remove the effect of an old hot button */
    2704         if(infoPtr->nOldHit == infoPtr->nHotItem)
    2705         {
    2706             oldBtnPtr = &infoPtr->buttons[infoPtr->nOldHit];
    2707             oldBtnPtr->bHot = FALSE;
    2708                    
    2709             InvalidateRect (hwnd, &oldBtnPtr->rect, TRUE);
    2710         }
    2711 
    2712         /* It's not a separator or in nowhere. It's a hot button. */
    2713         if (nHit >= 0)
    2714         {
    2715             btnPtr = &infoPtr->buttons[nHit];
    2716             btnPtr->bHot = TRUE;
    2717 
    2718             hdc = GetDC (hwnd);
    2719             TOOLBAR_DrawButton (hwnd, btnPtr, hdc);
    2720             ReleaseDC (hwnd, hdc);
    2721 
    2722             infoPtr->nHotItem = nHit;
    2723         }
     2705        if(infoPtr->nOldHit == infoPtr->nHotItem)
     2706        {
     2707            oldBtnPtr = &infoPtr->buttons[infoPtr->nOldHit];
     2708            oldBtnPtr->bHot = FALSE;
     2709
     2710            InvalidateRect (hwnd, &oldBtnPtr->rect, TRUE);
     2711        }
     2712
     2713        /* It's not a separator or in nowhere. It's a hot button. */
     2714        if (nHit >= 0)
     2715        {
     2716            btnPtr = &infoPtr->buttons[nHit];
     2717            btnPtr->bHot = TRUE;
     2718
     2719            hdc = GetDC (hwnd);
     2720            TOOLBAR_DrawButton (hwnd, btnPtr, hdc);
     2721            ReleaseDC (hwnd, hdc);
     2722
     2723            infoPtr->nHotItem = nHit;
     2724        }
    27242725
    27252726    if (infoPtr->bCaptured) {
    2726             btnPtr = &infoPtr->buttons[infoPtr->nButtonDown];
    2727             if (infoPtr->nOldHit == infoPtr->nButtonDown) {
    2728                 btnPtr->fsState &= ~TBSTATE_PRESSED;
    2729                 hdc = GetDC (hwnd);
    2730                 TOOLBAR_DrawButton (hwnd, btnPtr, hdc);
    2731                 ReleaseDC (hwnd, hdc);
    2732             }
    2733             else if (nHit == infoPtr->nButtonDown) {
    2734                 btnPtr->fsState |= TBSTATE_PRESSED;
    2735                 hdc = GetDC (hwnd);
    2736                 TOOLBAR_DrawButton (hwnd, btnPtr, hdc);
    2737                 ReleaseDC (hwnd, hdc);
    2738             }
    2739         }
    2740         infoPtr->nOldHit = nHit;
     2727            btnPtr = &infoPtr->buttons[infoPtr->nButtonDown];
     2728            if (infoPtr->nOldHit == infoPtr->nButtonDown) {
     2729                btnPtr->fsState &= ~TBSTATE_PRESSED;
     2730                hdc = GetDC (hwnd);
     2731                TOOLBAR_DrawButton (hwnd, btnPtr, hdc);
     2732                ReleaseDC (hwnd, hdc);
     2733            }
     2734            else if (nHit == infoPtr->nButtonDown) {
     2735                btnPtr->fsState |= TBSTATE_PRESSED;
     2736                hdc = GetDC (hwnd);
     2737                TOOLBAR_DrawButton (hwnd, btnPtr, hdc);
     2738                ReleaseDC (hwnd, hdc);
     2739            }
     2740        }
     2741        infoPtr->nOldHit = nHit;
    27412742    }
    27422743    return 0;
    … …  
    27482749{
    27492750/*    if (wndPtr->dwStyle & CCS_NODIVIDER) */
    2750         return DefWindowProcA (hwnd, WM_NCACTIVATE, wParam, lParam);
     2751        return DefWindowProcA (hwnd, WM_NCACTIVATE, wParam, lParam);
    27512752/*    else */
    2752 /*      return TOOLBAR_NCPaint (wndPtr, wParam, lParam); */
     2753/*      return TOOLBAR_NCPaint (wndPtr, wParam, lParam); */
    27532754}
    27542755
    … …  
    27582759{
    27592760    if (!(GetWindowLongA (hwnd, GWL_STYLE) & CCS_NODIVIDER))
    2760         ((LPRECT)lParam)->top += GetSystemMetrics(SM_CYEDGE);
     2761        ((LPRECT)lParam)->top += GetSystemMetrics(SM_CYEDGE);
    27612762
    27622763    return DefWindowProcA (hwnd, WM_NCCALCSIZE, wParam, lParam);
    … …  
    27792780    if (!GetWindowLongA (hwnd, GWL_HINSTANCE)) {
    27802781        HINSTANCE hInst = (HINSTANCE)GetWindowLongA (GetParent (hwnd), GWL_HINSTANCE);
    2781         SetWindowLongA (hwnd, GWL_HINSTANCE, (DWORD)hInst);
     2782        SetWindowLongA (hwnd, GWL_HINSTANCE, (DWORD)hInst);
    27822783    }
    27832784
    … …  
    27942795
    27952796    if (dwStyle & WS_MINIMIZE)
    2796         return 0; /* Nothing to do */
     2797        return 0; /* Nothing to do */
    27972798
    27982799    DefWindowProcA (hwnd, WM_NCPAINT, wParam, lParam);
    27992800
    28002801    if (!(hdc = GetDCEx (hwnd, 0, DCX_USESTYLE | DCX_WINDOW)))
    2801         return 0;
     2802        return 0;
    28022803
    28032804    if (!(dwStyle & CCS_NODIVIDER))
    28042805    {
    2805         GetWindowRect (hwnd, &rcWindow);
    2806         OffsetRect (&rcWindow, -rcWindow.left, -rcWindow.top);
    2807         DrawEdge (hdc, &rcWindow, EDGE_ETCHED, BF_TOP);
     2806        GetWindowRect (hwnd, &rcWindow);
     2807        OffsetRect (&rcWindow, -rcWindow.left, -rcWindow.top);
     2808        DrawEdge (hdc, &rcWindow, EDGE_ETCHED, BF_TOP);
    28082809    }
    28092810
    … …  
    28232824
    28242825    if ((infoPtr->hwndToolTip) && (lpnmh->hwndFrom == infoPtr->hwndToolTip)) {
    2825         SendMessageA (infoPtr->hwndNotify, WM_NOTIFY,   wParam, lParam);
     2826        SendMessageA (infoPtr->hwndNotify, WM_NOTIFY,   wParam, lParam);
    28262827
    28272828#if 0
    2828         if (lpnmh->code == TTN_GETDISPINFOA) {
    2829             LPNMTTDISPINFOA lpdi = (LPNMTTDISPINFOA)lParam;
    2830 
    2831 //          FIXME (toolbar, "retrieving ASCII string\n");
    2832 
    2833         }
    2834         else if (lpnmh->code == TTN_GETDISPINFOW) {
    2835             LPNMTTDISPINFOW lpdi = (LPNMTTDISPINFOW)lParam;
    2836 
    2837 //          FIXME (toolbar, "retrieving UNICODE string\n");
    2838 
    2839         }
     2829        if (lpnmh->code == TTN_GETDISPINFOA) {
     2830            LPNMTTDISPINFOA lpdi = (LPNMTTDISPINFOA)lParam;
     2831
     2832//          FIXME (toolbar, "retrieving ASCII string\n");
     2833
     2834        }
     2835        else if (lpnmh->code == TTN_GETDISPINFOW) {
     2836            LPNMTTDISPINFOW lpdi = (LPNMTTDISPINFOW)lParam;
     2837
     2838//          FIXME (toolbar, "retrieving UNICODE string\n");
     2839
     2840        }
    28402841#endif
    28412842    }
    … …  
    28552856    TOOLBAR_Refresh (hwnd, hdc);
    28562857    if (!wParam)
    2857         EndPaint (hwnd, &ps);
     2858        EndPaint (hwnd, &ps);
    28582859    return 0;
    28592860}
    … …  
    28742875    /* Resize deadlock check */
    28752876    if (infoPtr->bAutoSize) {
    2876         infoPtr->bAutoSize = FALSE;
    2877         return 0;
     2877        infoPtr->bAutoSize = FALSE;
     2878        return 0;
    28782879    }
    28792880
    … …  
    28872888
    28882889    if (flags == SIZE_RESTORED) {
    2889         /* width and height don't apply */
    2890         parent = GetParent (hwnd);
    2891         GetClientRect(parent, &parent_rect);
    2892 
    2893         if (dwStyle & CCS_NORESIZE) {
    2894             uPosFlags |= (SWP_NOSIZE | SWP_NOMOVE);
    2895 
    2896             /* FIXME */
    2897 /*          infoPtr->nWidth = parent_rect.right - parent_rect.left; */
    2898             cy = infoPtr->nHeight;
    2899             cx = infoPtr->nWidth;
    2900             TOOLBAR_CalcToolbar (hwnd);
    2901             infoPtr->nWidth = cx;
    2902             infoPtr->nHeight = cy;
    2903         }
    2904         else {
    2905             infoPtr->nWidth = parent_rect.right - parent_rect.left;
    2906             TOOLBAR_CalcToolbar (hwnd);
    2907             cy = infoPtr->nHeight;
    2908             cx = infoPtr->nWidth;
    2909         }
    2910 
    2911         if (dwStyle & CCS_NOPARENTALIGN) {
    2912             uPosFlags |= SWP_NOMOVE;
    2913             cy = infoPtr->nHeight;
    2914             cx = infoPtr->nWidth;
    2915         }
    2916 
    2917         if (!(dwStyle & CCS_NODIVIDER))
    2918             cy += GetSystemMetrics(SM_CYEDGE);
    2919 
    2920         SetWindowPos (hwnd, 0, parent_rect.left, parent_rect.top,
    2921                         cx, cy, uPosFlags | SWP_NOZORDER);
     2890        /* width and height don't apply */
     2891        parent = GetParent (hwnd);
     2892        GetClientRect(parent, &parent_rect);
     2893
     2894        if (dwStyle & CCS_NORESIZE) {
     2895            uPosFlags |= (SWP_NOSIZE | SWP_NOMOVE);
     2896
     2897            /* FIXME */
     2898/*          infoPtr->nWidth = parent_rect.right - parent_rect.left; */
     2899            cy = infoPtr->nHeight;
     2900            cx = infoPtr->nWidth;
     2901            TOOLBAR_CalcToolbar (hwnd);
     2902            infoPtr->nWidth = cx;
     2903            infoPtr->nHeight = cy;
     2904        }
     2905        else {
     2906            infoPtr->nWidth = parent_rect.right - parent_rect.left;
     2907            TOOLBAR_CalcToolbar (hwnd);
     2908            cy = infoPtr->nHeight;
     2909            cx = infoPtr->nWidth;
     2910        }
     2911
     2912        if (dwStyle & CCS_NOPARENTALIGN) {
     2913            uPosFlags |= SWP_NOMOVE;
     2914            cy = infoPtr->nHeight;
     2915            cx = infoPtr->nWidth;
     2916        }
     2917
     2918        if (!(dwStyle & CCS_NODIVIDER))
     2919            cy += GetSystemMetrics(SM_CYEDGE);
     2920
     2921        SetWindowPos (hwnd, 0, parent_rect.left, parent_rect.top,
     2922                        cx, cy, uPosFlags | SWP_NOZORDER);
    29222923    }
    29232924    return 0;
    … …  
    29422943    switch (uMsg)
    29432944    {
    2944         case TB_ADDBITMAP:
    2945             return TOOLBAR_AddBitmap (hwnd, wParam, lParam);
    2946 
    2947         case TB_ADDBUTTONSA:
    2948             return TOOLBAR_AddButtonsA (hwnd, wParam, lParam);
    2949 
    2950 /*      case TB_ADDBUTTONSW: */
    2951 
    2952         case TB_ADDSTRINGA:
    2953             return TOOLBAR_AddStringA (hwnd, wParam, lParam);
    2954 
    2955         case TB_ADDSTRINGW:
    2956             return TOOLBAR_AddStringW (hwnd, wParam, lParam);
    2957 
    2958         case TB_AUTOSIZE:
    2959             return TOOLBAR_AutoSize (hwnd, wParam, lParam);
    2960 
    2961         case TB_BUTTONCOUNT:
    2962             return TOOLBAR_ButtonCount (hwnd, wParam, lParam);
    2963 
    2964         case TB_BUTTONSTRUCTSIZE:
    2965             return TOOLBAR_ButtonStructSize (hwnd, wParam, lParam);
    2966 
    2967         case TB_CHANGEBITMAP:
    2968             return TOOLBAR_ChangeBitmap (hwnd, wParam, lParam);
    2969 
    2970         case TB_CHECKBUTTON:
    2971             return TOOLBAR_CheckButton (hwnd, wParam, lParam);
    2972 
    2973         case TB_COMMANDTOINDEX:
    2974             return TOOLBAR_CommandToIndex (hwnd, wParam, lParam);
    2975 
    2976         case TB_CUSTOMIZE:
    2977             return TOOLBAR_Customize (hwnd);
    2978 
    2979         case TB_DELETEBUTTON:
    2980             return TOOLBAR_DeleteButton (hwnd, wParam, lParam);
    2981 
    2982         case TB_ENABLEBUTTON:
    2983             return TOOLBAR_EnableButton (hwnd, wParam, lParam);
    2984 
    2985 /*      case TB_GETANCHORHIGHLIGHT:             */ /* 4.71 */
    2986 
    2987         case TB_GETBITMAP:
    2988             return TOOLBAR_GetBitmap (hwnd, wParam, lParam);
    2989 
    2990         case TB_GETBITMAPFLAGS:
    2991             return TOOLBAR_GetBitmapFlags (hwnd, wParam, lParam);
    2992 
    2993         case TB_GETBUTTON:
    2994             return TOOLBAR_GetButton (hwnd, wParam, lParam);
    2995 
    2996         case TB_GETBUTTONINFOA:
    2997             return TOOLBAR_GetButtonInfoA (hwnd, wParam, lParam);
    2998 
    2999 /*      case TB_GETBUTTONINFOW:         */ /* 4.71 */
    3000 
    3001         case TB_GETBUTTONSIZE:
    3002             return TOOLBAR_GetButtonSize (hwnd);
    3003 
    3004         case TB_GETBUTTONTEXTA:
    3005             return TOOLBAR_GetButtonTextA (hwnd, wParam, lParam);
    3006 
    3007 /*      case TB_GETBUTTONTEXTW: */
    3008 /*      case TB_GETCOLORSCHEME:                 */ /* 4.71 */
    3009 
    3010         case TB_GETDISABLEDIMAGELIST:
    3011             return TOOLBAR_GetDisabledImageList (hwnd, wParam, lParam);
    3012 
    3013         case TB_GETEXTENDEDSTYLE:
    3014             return TOOLBAR_GetExtendedStyle (hwnd);
    3015 
    3016         case TB_GETHOTIMAGELIST:
    3017             return TOOLBAR_GetHotImageList (hwnd, wParam, lParam);
    3018 
    3019 /*      case TB_GETHOTITEM:                     */ /* 4.71 */
    3020 
    3021         case TB_GETIMAGELIST:
    3022             return TOOLBAR_GetImageList (hwnd, wParam, lParam);
    3023 
    3024 /*      case TB_GETINSERTMARK:                  */ /* 4.71 */
    3025 /*      case TB_GETINSERTMARKCOLOR:             */ /* 4.71 */
    3026 
    3027         case TB_GETITEMRECT:
    3028             return TOOLBAR_GetItemRect (hwnd, wParam, lParam);
    3029 
    3030         case TB_GETMAXSIZE:
    3031             return TOOLBAR_GetMaxSize (hwnd, wParam, lParam);
    3032 
    3033 /*      case TB_GETOBJECT:                      */ /* 4.71 */
    3034 /*      case TB_GETPADDING:                     */ /* 4.71 */
    3035 
    3036         case TB_GETRECT:
    3037             return TOOLBAR_GetRect (hwnd, wParam, lParam);
    3038 
    3039         case TB_GETROWS:
    3040             return TOOLBAR_GetRows (hwnd, wParam, lParam);
    3041 
    3042         case TB_GETSTATE:
    3043             return TOOLBAR_GetState (hwnd, wParam, lParam);
    3044 
    3045         case TB_GETSTYLE:
    3046             return TOOLBAR_GetStyle (hwnd, wParam, lParam);
    3047 
    3048         case TB_GETTEXTROWS:
    3049             return TOOLBAR_GetTextRows (hwnd, wParam, lParam);
    3050 
    3051         case TB_GETTOOLTIPS:
    3052             return TOOLBAR_GetToolTips (hwnd, wParam, lParam);
    3053 
    3054         case TB_GETUNICODEFORMAT:
    3055             return TOOLBAR_GetUnicodeFormat (hwnd, wParam, lParam);
    3056 
    3057         case TB_HIDEBUTTON:
    3058             return TOOLBAR_HideButton (hwnd, wParam, lParam);
    3059 
    3060         case TB_HITTEST:
    3061             return TOOLBAR_HitTest (hwnd, wParam, lParam);
    3062 
    3063         case TB_INDETERMINATE:
    3064             return TOOLBAR_Indeterminate (hwnd, wParam, lParam);
    3065 
    3066         case TB_INSERTBUTTONA:
    3067             return TOOLBAR_InsertButtonA (hwnd, wParam, lParam);
    3068 
    3069 /*      case TB_INSERTBUTTONW: */
    3070 /*      case TB_INSERTMARKHITTEST:              */ /* 4.71 */
    3071 
    3072         case TB_ISBUTTONCHECKED:
    3073             return TOOLBAR_IsButtonChecked (hwnd, wParam, lParam);
    3074 
    3075         case TB_ISBUTTONENABLED:
    3076             return TOOLBAR_IsButtonEnabled (hwnd, wParam, lParam);
    3077 
    3078         case TB_ISBUTTONHIDDEN:
    3079             return TOOLBAR_IsButtonHidden (hwnd, wParam, lParam);
    3080 
    3081         case TB_ISBUTTONHIGHLIGHTED:
    3082             return TOOLBAR_IsButtonHighlighted (hwnd, wParam, lParam);
    3083 
    3084         case TB_ISBUTTONINDETERMINATE:
    3085             return TOOLBAR_IsButtonIndeterminate (hwnd, wParam, lParam);
    3086 
    3087         case TB_ISBUTTONPRESSED:
    3088             return TOOLBAR_IsButtonPressed (hwnd, wParam, lParam);
    3089 
    3090 /*      case TB_LOADIMAGES:                     */ /* 4.70 */
    3091 /*      case TB_MAPACCELERATORA:                */ /* 4.71 */
    3092 /*      case TB_MAPACCELERATORW:                */ /* 4.71 */
    3093 /*      case TB_MARKBUTTON:                     */ /* 4.71 */
    3094 /*      case TB_MOVEBUTTON:                     */ /* 4.71 */
    3095 
    3096         case TB_PRESSBUTTON:
    3097             return TOOLBAR_PressButton (hwnd, wParam, lParam);
    3098 
    3099 /*      case TB_REPLACEBITMAP: */
    3100 
    3101         case TB_SAVERESTOREA:
    3102             return TOOLBAR_SaveRestoreA (hwnd, wParam, lParam);
    3103 
    3104 /*      case TB_SAVERESTOREW: */
    3105 /*      case TB_SETANCHORHIGHLIGHT:             */ /* 4.71 */
    3106 
    3107         case TB_SETBITMAPSIZE:
    3108             return TOOLBAR_SetBitmapSize (hwnd, wParam, lParam);
    3109 
    3110         case TB_SETBUTTONINFOA:
    3111             return TOOLBAR_SetButtonInfoA (hwnd, wParam, lParam);
    3112 
    3113 /*      case TB_SETBUTTONINFOW:                 */ /* 4.71 */
    3114 
    3115         case TB_SETBUTTONSIZE:
    3116             return TOOLBAR_SetButtonSize (hwnd, wParam, lParam);
    3117 
    3118         case TB_SETBUTTONWIDTH:
    3119             return TOOLBAR_SetButtonWidth (hwnd, wParam, lParam);
    3120 
    3121         case TB_SETCMDID:
    3122             return TOOLBAR_SetCmdId (hwnd, wParam, lParam);
    3123 
    3124 /*      case TB_SETCOLORSCHEME:                 */ /* 4.71 */
    3125 
    3126         case TB_SETDISABLEDIMAGELIST:
    3127             return TOOLBAR_SetDisabledImageList (hwnd, wParam, lParam);
    3128 
    3129         case TB_SETDRAWTEXTFLAGS:
    3130             return TOOLBAR_SetDrawTextFlags (hwnd, wParam, lParam);
    3131 
    3132         case TB_SETEXTENDEDSTYLE:
    3133             return TOOLBAR_SetExtendedStyle (hwnd, wParam, lParam);
    3134 
    3135         case TB_SETHOTIMAGELIST:
    3136             return TOOLBAR_SetHotImageList (hwnd, wParam, lParam);
    3137 
    3138 /*      case TB_SETHOTITEM:                     */ /* 4.71 */
    3139 
    3140         case TB_SETIMAGELIST:
    3141             return TOOLBAR_SetImageList (hwnd, wParam, lParam);
    3142 
    3143         case TB_SETINDENT:
    3144             return TOOLBAR_SetIndent (hwnd, wParam, lParam);
    3145 
    3146 /*      case TB_SETINSERTMARK:                  */ /* 4.71 */
    3147 
    3148         case TB_SETINSERTMARKCOLOR:
    3149             return TOOLBAR_SetInsertMarkColor (hwnd, wParam, lParam);
    3150 
    3151         case TB_SETMAXTEXTROWS:
    3152             return TOOLBAR_SetMaxTextRows (hwnd, wParam, lParam);
    3153 
    3154 /*      case TB_SETPADDING:                     */ /* 4.71 */
    3155 
    3156         case TB_SETPARENT:
    3157             return TOOLBAR_SetParent (hwnd, wParam, lParam);
    3158 
    3159         case TB_SETROWS:
    3160             return TOOLBAR_SetRows (hwnd, wParam, lParam);
    3161 
    3162         case TB_SETSTATE:
    3163             return TOOLBAR_SetState (hwnd, wParam, lParam);
    3164 
    3165         case TB_SETSTYLE:
    3166             return TOOLBAR_SetStyle (hwnd, wParam, lParam);
    3167 
    3168         case TB_SETTOOLTIPS:
    3169             return TOOLBAR_SetToolTips (hwnd, wParam, lParam);
    3170 
    3171         case TB_SETUNICODEFORMAT:
    3172             return TOOLBAR_SetUnicodeFormat (hwnd, wParam, lParam);
    3173 
    3174 
    3175 /*      case WM_CHAR: */
    3176 
    3177         case WM_CREATE:
    3178             return TOOLBAR_Create (hwnd, wParam, lParam);
    3179 
    3180         case WM_DESTROY:
    3181             return TOOLBAR_Destroy (hwnd, wParam, lParam);
    3182 
    3183         case WM_ERASEBKGND:
    3184             return TOOLBAR_EraseBackground (hwnd, wParam, lParam);
    3185 
    3186 /*      case WM_GETFONT: */
    3187 /*      case WM_KEYDOWN: */
    3188 /*      case WM_KILLFOCUS: */
    3189 
    3190         case WM_LBUTTONDBLCLK:
    3191             return TOOLBAR_LButtonDblClk (hwnd, wParam, lParam);
    3192 
    3193         case WM_LBUTTONDOWN:
    3194             return TOOLBAR_LButtonDown (hwnd, wParam, lParam);
    3195 
    3196         case WM_LBUTTONUP:
    3197             return TOOLBAR_LButtonUp (hwnd, wParam, lParam);
    3198 
    3199         case WM_MOUSEMOVE:
    3200             return TOOLBAR_MouseMove (hwnd, wParam, lParam);
    3201 
    3202         case WM_NCACTIVATE:
    3203             return TOOLBAR_NCActivate (hwnd, wParam, lParam);
    3204 
    3205         case WM_NCCALCSIZE:
    3206             return TOOLBAR_NCCalcSize (hwnd, wParam, lParam);
    3207 
    3208         case WM_NCCREATE:
    3209             return TOOLBAR_NCCreate (hwnd, wParam, lParam);
    3210 
    3211         case WM_NCPAINT:
    3212             return TOOLBAR_NCPaint (hwnd, wParam, lParam);
    3213 
    3214         case WM_NOTIFY:
    3215             return TOOLBAR_Notify (hwnd, wParam, lParam);
    3216 
    3217 /*      case WM_NOTIFYFORMAT: */
    3218 
    3219         case WM_PAINT:
    3220             return TOOLBAR_Paint (hwnd, wParam);
    3221 
    3222         case WM_SIZE:
    3223             return TOOLBAR_Size (hwnd, wParam, lParam);
    3224 
    3225         case WM_STYLECHANGED:
    3226             return TOOLBAR_StyleChanged (hwnd, wParam, lParam);
    3227 
    3228 /*      case WM_SYSCOLORCHANGE: */
    3229 
    3230 /*      case WM_WININICHANGE: */
    3231 
    3232         case WM_CHARTOITEM:
    3233         case WM_COMMAND:
    3234         case WM_DRAWITEM:
    3235         case WM_MEASUREITEM:
    3236         case WM_VKEYTOITEM:
    3237             return SendMessageA (GetParent (hwnd), uMsg, wParam, lParam);
    3238 
    3239         default:
    3240             if (uMsg >= WM_USER)
    3241 //              ERR (toolbar, "unknown msg %04x wp=%08x lp=%08lx\n",
    3242 //                   uMsg, wParam, lParam);
    3243             return DefWindowProcA (hwnd, uMsg, wParam, lParam);
     2945        case TB_ADDBITMAP:
     2946            return TOOLBAR_AddBitmap (hwnd, wParam, lParam);
     2947
     2948        case TB_ADDBUTTONSA:
     2949            return TOOLBAR_AddButtonsA (hwnd, wParam, lParam);
     2950
     2951/*      case TB_ADDBUTTONSW: */
     2952
     2953        case TB_ADDSTRINGA:
     2954            return TOOLBAR_AddStringA (hwnd, wParam, lParam);
     2955
     2956        case TB_ADDSTRINGW:
     2957            return TOOLBAR_AddStringW (hwnd, wParam, lParam);
     2958
     2959        case TB_AUTOSIZE:
     2960            return TOOLBAR_AutoSize (hwnd, wParam, lParam);
     2961
     2962        case TB_BUTTONCOUNT:
     2963            return TOOLBAR_ButtonCount (hwnd, wParam, lParam);
     2964
     2965        case TB_BUTTONSTRUCTSIZE:
     2966            return TOOLBAR_ButtonStructSize (hwnd, wParam, lParam);
     2967
     2968        case TB_CHANGEBITMAP:
     2969            return TOOLBAR_ChangeBitmap (hwnd, wParam, lParam);
     2970
     2971        case TB_CHECKBUTTON:
     2972            return TOOLBAR_CheckButton (hwnd, wParam, lParam);
     2973
     2974        case TB_COMMANDTOINDEX:
     2975            return TOOLBAR_CommandToIndex (hwnd, wParam, lParam);
     2976
     2977        case TB_CUSTOMIZE:
     2978            return TOOLBAR_Customize (hwnd);
     2979
     2980        case TB_DELETEBUTTON:
     2981            return TOOLBAR_DeleteButton (hwnd, wParam, lParam);
     2982
     2983        case TB_ENABLEBUTTON:
     2984            return TOOLBAR_EnableButton (hwnd, wParam, lParam);
     2985
     2986/*      case TB_GETANCHORHIGHLIGHT:             */ /* 4.71 */
     2987
     2988        case TB_GETBITMAP:
     2989            return TOOLBAR_GetBitmap (hwnd, wParam, lParam);
     2990
     2991        case TB_GETBITMAPFLAGS:
     2992            return TOOLBAR_GetBitmapFlags (hwnd, wParam, lParam);
     2993
     2994        case TB_GETBUTTON:
     2995            return TOOLBAR_GetButton (hwnd, wParam, lParam);
     2996
     2997        case TB_GETBUTTONINFOA:
     2998            return TOOLBAR_GetButtonInfoA (hwnd, wParam, lParam);
     2999
     3000/*      case TB_GETBUTTONINFOW:         */ /* 4.71 */
     3001
     3002        case TB_GETBUTTONSIZE:
     3003            return TOOLBAR_GetButtonSize (hwnd);
     3004
     3005        case TB_GETBUTTONTEXTA:
     3006            return TOOLBAR_GetButtonTextA (hwnd, wParam, lParam);
     3007
     3008/*      case TB_GETBUTTONTEXTW: */
     3009/*      case TB_GETCOLORSCHEME:                 */ /* 4.71 */
     3010
     3011        case TB_GETDISABLEDIMAGELIST:
     3012            return TOOLBAR_GetDisabledImageList (hwnd, wParam, lParam);
     3013
     3014        case TB_GETEXTENDEDSTYLE:
     3015            return TOOLBAR_GetExtendedStyle (hwnd);
     3016
     3017        case TB_GETHOTIMAGELIST:
     3018            return TOOLBAR_GetHotImageList (hwnd, wParam, lParam);
     3019
     3020/*      case TB_GETHOTITEM:                     */ /* 4.71 */
     3021
     3022        case TB_GETIMAGELIST:
     3023            return TOOLBAR_GetImageList (hwnd, wParam, lParam);
     3024
     3025/*      case TB_GETINSERTMARK:                  */ /* 4.71 */
     3026/*      case TB_GETINSERTMARKCOLOR:             */ /* 4.71 */
     3027
     3028        case TB_GETITEMRECT:
     3029            return TOOLBAR_GetItemRect (hwnd, wParam, lParam);
     3030
     3031        case TB_GETMAXSIZE:
     3032            return TOOLBAR_GetMaxSize (hwnd, wParam, lParam);
     3033
     3034/*      case TB_GETOBJECT:                      */ /* 4.71 */
     3035/*      case TB_GETPADDING:                     */ /* 4.71 */
     3036
     3037        case TB_GETRECT:
     3038            return TOOLBAR_GetRect (hwnd, wParam, lParam);
     3039
     3040        case TB_GETROWS:
     3041            return TOOLBAR_GetRows (hwnd, wParam, lParam);
     3042
     3043        case TB_GETSTATE:
     3044            return TOOLBAR_GetState (hwnd, wParam, lParam);
     3045
     3046        case TB_GETSTYLE:
     3047            return TOOLBAR_GetStyle (hwnd, wParam, lParam);
     3048
     3049        case TB_GETTEXTROWS:
     3050            return TOOLBAR_GetTextRows (hwnd, wParam, lParam);
     3051
     3052        case TB_GETTOOLTIPS:
     3053            return TOOLBAR_GetToolTips (hwnd, wParam, lParam);
     3054
     3055        case TB_GETUNICODEFORMAT:
     3056            return TOOLBAR_GetUnicodeFormat (hwnd, wParam, lParam);
     3057
     3058        case TB_HIDEBUTTON:
     3059            return TOOLBAR_HideButton (hwnd, wParam, lParam);
     3060
     3061        case TB_HITTEST:
     3062            return TOOLBAR_HitTest (hwnd, wParam, lParam);
     3063
     3064        case TB_INDETERMINATE:
     3065            return TOOLBAR_Indeterminate (hwnd, wParam, lParam);
     3066
     3067        case TB_INSERTBUTTONA:
     3068            return TOOLBAR_InsertButtonA (hwnd, wParam, lParam);
     3069
     3070/*      case TB_INSERTBUTTONW: */
     3071/*      case TB_INSERTMARKHITTEST:              */ /* 4.71 */
     3072
     3073        case TB_ISBUTTONCHECKED:
     3074            return TOOLBAR_IsButtonChecked (hwnd, wParam, lParam);
     3075
     3076        case TB_ISBUTTONENABLED:
     3077            return TOOLBAR_IsButtonEnabled (hwnd, wParam, lParam);
     3078
     3079        case TB_ISBUTTONHIDDEN:
     3080            return TOOLBAR_IsButtonHidden (hwnd, wParam, lParam);
     3081
     3082        case TB_ISBUTTONHIGHLIGHTED:
     3083            return TOOLBAR_IsButtonHighlighted (hwnd, wParam, lParam);
     3084
     3085        case TB_ISBUTTONINDETERMINATE:
     3086            return TOOLBAR_IsButtonIndeterminate (hwnd, wParam, lParam);
     3087
     3088        case TB_ISBUTTONPRESSED:
     3089            return TOOLBAR_IsButtonPressed (hwnd, wParam, lParam);
     3090
     3091/*      case TB_LOADIMAGES:                     */ /* 4.70 */
     3092/*      case TB_MAPACCELERATORA:                */ /* 4.71 */
     3093/*      case TB_MAPACCELERATORW:                */ /* 4.71 */
     3094/*      case TB_MARKBUTTON:                     */ /* 4.71 */
     3095/*      case TB_MOVEBUTTON:                     */ /* 4.71 */
     3096
     3097        case TB_PRESSBUTTON:
     3098            return TOOLBAR_PressButton (hwnd, wParam, lParam);
     3099
     3100/*      case TB_REPLACEBITMAP: */
     3101
     3102        case TB_SAVERESTOREA:
     3103            return TOOLBAR_SaveRestoreA (hwnd, wParam, lParam);
     3104
     3105/*      case TB_SAVERESTOREW: */
     3106/*      case TB_SETANCHORHIGHLIGHT:             */ /* 4.71 */
     3107
     3108        case TB_SETBITMAPSIZE:
     3109            return TOOLBAR_SetBitmapSize (hwnd, wParam, lParam);
     3110
     3111        case TB_SETBUTTONINFOA:
     3112            return TOOLBAR_SetButtonInfoA (hwnd, wParam, lParam);
     3113
     3114/*      case TB_SETBUTTONINFOW:                 */ /* 4.71 */
     3115
     3116        case TB_SETBUTTONSIZE:
     3117            return TOOLBAR_SetButtonSize (hwnd, wParam, lParam);
     3118
     3119        case TB_SETBUTTONWIDTH:
     3120            return TOOLBAR_SetButtonWidth (hwnd, wParam, lParam);
     3121
     3122        case TB_SETCMDID:
     3123            return TOOLBAR_SetCmdId (hwnd, wParam, lParam);
     3124
     3125/*      case TB_SETCOLORSCHEME:                 */ /* 4.71 */
     3126
     3127        case TB_SETDISABLEDIMAGELIST:
     3128            return TOOLBAR_SetDisabledImageList (hwnd, wParam, lParam);
     3129
     3130        case TB_SETDRAWTEXTFLAGS:
     3131            return TOOLBAR_SetDrawTextFlags (hwnd, wParam, lParam);
     3132
     3133        case TB_SETEXTENDEDSTYLE:
     3134            return TOOLBAR_SetExtendedStyle (hwnd, wParam, lParam);
     3135
     3136        case TB_SETHOTIMAGELIST:
     3137            return TOOLBAR_SetHotImageList (hwnd, wParam, lParam);
     3138
     3139/*      case TB_SETHOTITEM:                     */ /* 4.71 */
     3140
     3141        case TB_SETIMAGELIST:
     3142            return TOOLBAR_SetImageList (hwnd, wParam, lParam);
     3143
     3144        case TB_SETINDENT:
     3145            return TOOLBAR_SetIndent (hwnd, wParam, lParam);
     3146
     3147/*      case TB_SETINSERTMARK:                  */ /* 4.71 */
     3148
     3149        case TB_SETINSERTMARKCOLOR:
     3150            return TOOLBAR_SetInsertMarkColor (hwnd, wParam, lParam);
     3151
     3152        case TB_SETMAXTEXTROWS:
     3153            return TOOLBAR_SetMaxTextRows (hwnd, wParam, lParam);
     3154
     3155/*      case TB_SETPADDING:                     */ /* 4.71 */
     3156
     3157        case TB_SETPARENT:
     3158            return TOOLBAR_SetParent (hwnd, wParam, lParam);
     3159
     3160        case TB_SETROWS:
     3161            return TOOLBAR_SetRows (hwnd, wParam, lParam);
     3162
     3163        case TB_SETSTATE:
     3164            return TOOLBAR_SetState (hwnd, wParam, lParam);
     3165
     3166        case TB_SETSTYLE:
     3167            return TOOLBAR_SetStyle (hwnd, wParam, lParam);
     3168
     3169        case TB_SETTOOLTIPS:
     3170            return TOOLBAR_SetToolTips (hwnd, wParam, lParam);
     3171
     3172        case TB_SETUNICODEFORMAT:
     3173            return TOOLBAR_SetUnicodeFormat (hwnd, wParam, lParam);
     3174
     3175
     3176/*      case WM_CHAR: */
     3177
     3178        case WM_CREATE:
     3179            return TOOLBAR_Create (hwnd, wParam, lParam);
     3180
     3181        case WM_DESTROY:
     3182            return TOOLBAR_Destroy (hwnd, wParam, lParam);
     3183
     3184        case WM_ERASEBKGND:
     3185            return TOOLBAR_EraseBackground (hwnd, wParam, lParam);
     3186
     3187/*      case WM_GETFONT: */
     3188/*      case WM_KEYDOWN: */
     3189/*      case WM_KILLFOCUS: */
     3190
     3191        case WM_LBUTTONDBLCLK:
     3192            return TOOLBAR_LButtonDblClk (hwnd, wParam, lParam);
     3193
     3194        case WM_LBUTTONDOWN:
     3195            return TOOLBAR_LButtonDown (hwnd, wParam, lParam);
     3196
     3197        case WM_LBUTTONUP:
     3198            return TOOLBAR_LButtonUp (hwnd, wParam, lParam);
     3199
     3200        case WM_MOUSEMOVE:
     3201            return TOOLBAR_MouseMove (hwnd, wParam, lParam);
     3202
     3203        case WM_NCACTIVATE:
     3204            return TOOLBAR_NCActivate (hwnd, wParam, lParam);
     3205
     3206        case WM_NCCALCSIZE:
     3207            return TOOLBAR_NCCalcSize (hwnd, wParam, lParam);
     3208
     3209        case WM_NCCREATE:
     3210            return TOOLBAR_NCCreate (hwnd, wParam, lParam);
     3211
     3212        case WM_NCPAINT:
     3213            return TOOLBAR_NCPaint (hwnd, wParam, lParam);
     3214
     3215        case WM_NOTIFY:
     3216            return TOOLBAR_Notify (hwnd, wParam, lParam);
     3217
     3218/*      case WM_NOTIFYFORMAT: */
     3219
     3220        case WM_PAINT:
     3221            return TOOLBAR_Paint (hwnd, wParam);
     3222
     3223        case WM_SIZE:
     3224            return TOOLBAR_Size (hwnd, wParam, lParam);
     3225
     3226        case WM_STYLECHANGED:
     3227            return TOOLBAR_StyleChanged (hwnd, wParam, lParam);
     3228
     3229/*      case WM_SYSCOLORCHANGE: */
     3230
     3231/*      case WM_WININICHANGE: */
     3232
     3233        case WM_CHARTOITEM:
     3234        case WM_COMMAND:
     3235        case WM_DRAWITEM:
     3236        case WM_MEASUREITEM:
     3237        case WM_VKEYTOITEM:
     3238            return SendMessageA (GetParent (hwnd), uMsg, wParam, lParam);
     3239
     3240        default:
     3241//            if (uMsg >= WM_USER)
     3242//              ERR (toolbar, "unknown msg %04x wp=%08x lp=%08lx\n",
     3243//                   uMsg, wParam, lParam);
     3244            return DefWindowProcA (hwnd, uMsg, wParam, lParam);
    32443245    }
    32453246    return 0;
    … …  
    32623263    wndClass.hbrBackground = (HBRUSH)(COLOR_3DFACE + 1);
    32633264    wndClass.lpszClassName = TOOLBARCLASSNAMEA;
    3264  
     3265
    32653266    RegisterClassA (&wndClass);
    32663267}
    … …  
    32713272{
    32723273    if (GlobalFindAtomA (TOOLBARCLASSNAMEA))
    3273         UnregisterClassA (TOOLBARCLASSNAMEA, (HINSTANCE)NULL);
    3274 }
    3275 
     3274        UnregisterClassA (TOOLBARCLASSNAMEA, (HINSTANCE)NULL);
     3275}
     3276
Note: See TracChangeset for help on using the changeset viewer.