mirror of
https://github.com/reactos/wine.git
synced 2024-11-25 04:39:45 +00:00
2951 lines
72 KiB
C
2951 lines
72 KiB
C
/*
|
|
* Toolbar control
|
|
*
|
|
* Copyright 1998 Eric Kohl
|
|
*
|
|
* TODO:
|
|
* - A little bug in TOOLBAR_DrawMasked()
|
|
* - Button wrapping (under construction).
|
|
* - Messages.
|
|
* - Notifications.
|
|
* - Fix TB_SETROWS.
|
|
* - Tooltip support (almost complete).
|
|
* - Unicode suppport.
|
|
* - Internal COMMCTL32 bitmaps.
|
|
* - Fix TOOLBAR_SetButtonInfo32A.
|
|
* - Fix TOOLBAR_Customize. (Customize dialog.)
|
|
*
|
|
* Testing:
|
|
* - Run tests using Waite Group Windows95 API Bible Volume 2.
|
|
* The second cdrom contains executables addstr.exe, btncount.exe,
|
|
* btnstate.exe, butstrsz.exe, chkbtn.exe, chngbmp.exe, customiz.exe,
|
|
* enablebtn.exe, getbmp.exe, getbtn.exe, getflags.exe, hidebtn.exe,
|
|
* indetbtn.exe, insbtn.exe, pressbtn.exe, setbtnsz.exe, setcmdid.exe,
|
|
* setparnt.exe, setrows.exe, toolwnd.exe.
|
|
* - Microsofts controlspy examples.
|
|
*/
|
|
|
|
#include "windows.h"
|
|
#include "commctrl.h"
|
|
#include "sysmetrics.h"
|
|
#include "cache.h"
|
|
#include "toolbar.h"
|
|
#include "win.h"
|
|
#include "debug.h"
|
|
|
|
/* #define __NEW_WRAP_CODE__ */
|
|
|
|
#define SEPARATOR_WIDTH 8
|
|
#define SEPARATOR_HEIGHT 5
|
|
#define TOP_BORDER 2
|
|
#define BOTTOM_BORDER 2
|
|
|
|
|
|
|
|
#define TOOLBAR_GetInfoPtr(wndPtr) ((TOOLBAR_INFO *)wndPtr->wExtra[0])
|
|
|
|
|
|
static void
|
|
TOOLBAR_DrawFlatSeparator (LPRECT32 lpRect, HDC32 hdc)
|
|
{
|
|
INT32 x = (lpRect->left + lpRect->right) / 2 - 1;
|
|
INT32 yBottom = lpRect->bottom - 3;
|
|
INT32 yTop = lpRect->top + 1;
|
|
|
|
SelectObject32 ( hdc, GetSysColorPen32 (COLOR_3DSHADOW));
|
|
MoveToEx32 (hdc, x, yBottom, NULL);
|
|
LineTo32 (hdc, x, yTop);
|
|
x++;
|
|
SelectObject32 ( hdc, GetSysColorPen32 (COLOR_3DHILIGHT));
|
|
MoveToEx32 (hdc, x, yBottom, NULL);
|
|
LineTo32 (hdc, x, yTop);
|
|
}
|
|
|
|
|
|
static void
|
|
TOOLBAR_DrawString (TOOLBAR_INFO *infoPtr, TBUTTON_INFO *btnPtr,
|
|
HDC32 hdc, INT32 nState)
|
|
{
|
|
RECT32 rcText = btnPtr->rect;
|
|
HFONT32 hOldFont;
|
|
INT32 nOldBkMode;
|
|
COLORREF clrOld;
|
|
|
|
/* draw text */
|
|
if ((btnPtr->iString > -1) && (btnPtr->iString < infoPtr->nNumStrings)) {
|
|
InflateRect32 (&rcText, -3, -3);
|
|
rcText.top += infoPtr->nBitmapHeight;
|
|
if (nState & (TBSTATE_PRESSED | TBSTATE_CHECKED))
|
|
OffsetRect32 (&rcText, 1, 1);
|
|
|
|
hOldFont = SelectObject32 (hdc, infoPtr->hFont);
|
|
nOldBkMode = SetBkMode32 (hdc, TRANSPARENT);
|
|
if (!(nState & TBSTATE_ENABLED)) {
|
|
clrOld = SetTextColor32 (hdc, GetSysColor32 (COLOR_3DHILIGHT));
|
|
OffsetRect32 (&rcText, 1, 1);
|
|
DrawText32W (hdc, infoPtr->strings[btnPtr->iString], -1,
|
|
&rcText, infoPtr->dwDTFlags);
|
|
SetTextColor32 (hdc, GetSysColor32 (COLOR_3DSHADOW));
|
|
OffsetRect32 (&rcText, -1, -1);
|
|
DrawText32W (hdc, infoPtr->strings[btnPtr->iString], -1,
|
|
&rcText, infoPtr->dwDTFlags);
|
|
}
|
|
else if (nState & TBSTATE_INDETERMINATE) {
|
|
clrOld = SetTextColor32 (hdc, GetSysColor32 (COLOR_3DSHADOW));
|
|
DrawText32W (hdc, infoPtr->strings[btnPtr->iString], -1,
|
|
&rcText, infoPtr->dwDTFlags);
|
|
}
|
|
else {
|
|
clrOld = SetTextColor32 (hdc, GetSysColor32 (COLOR_BTNTEXT));
|
|
DrawText32W (hdc, infoPtr->strings[btnPtr->iString], -1,
|
|
&rcText, infoPtr->dwDTFlags);
|
|
}
|
|
|
|
SetTextColor32 (hdc, clrOld);
|
|
SelectObject32 (hdc, hOldFont);
|
|
if (nOldBkMode != TRANSPARENT)
|
|
SetBkMode32 (hdc, nOldBkMode);
|
|
}
|
|
}
|
|
|
|
|
|
static void
|
|
TOOLBAR_DrawPattern (HDC32 hdc, LPRECT32 lpRect)
|
|
{
|
|
HBRUSH32 hbr = SelectObject32 (hdc, CACHE_GetPattern55AABrush ());
|
|
INT32 cx = lpRect->right - lpRect->left;
|
|
INT32 cy = lpRect->bottom - lpRect->top;
|
|
PatBlt32 (hdc, lpRect->left, lpRect->top, cx, cy, 0x00FA0089);
|
|
SelectObject32 (hdc, hbr);
|
|
}
|
|
|
|
|
|
static void
|
|
TOOLBAR_DrawMasked (TOOLBAR_INFO *infoPtr, TBUTTON_INFO *btnPtr,
|
|
HDC32 hdc, INT32 x, INT32 y)
|
|
{
|
|
/* FIXME: this function is a hack since it uses image list
|
|
internals directly */
|
|
|
|
HDC32 hdcImageList = CreateCompatibleDC32 (0);
|
|
HDC32 hdcMask = CreateCompatibleDC32 (0);
|
|
HIMAGELIST himl = infoPtr->himlStd;
|
|
HBITMAP32 hbmMask;
|
|
|
|
/* create new bitmap */
|
|
hbmMask = CreateBitmap32 (himl->cx, himl->cy, 1, 1, NULL);
|
|
SelectObject32 (hdcMask, hbmMask);
|
|
|
|
/* copy the mask bitmap */
|
|
SelectObject32 (hdcImageList, himl->hbmMask);
|
|
SetBkColor32 (hdcImageList, RGB(255, 255, 255));
|
|
SetTextColor32 (hdcImageList, RGB(0, 0, 0));
|
|
BitBlt32 (hdcMask, 0, 0, himl->cx, himl->cy,
|
|
hdcImageList, himl->cx * btnPtr->iBitmap, 0, SRCCOPY);
|
|
|
|
#if 0
|
|
/* add white mask from image */
|
|
SelectObject32 (hdcImageList, himl->hbmImage);
|
|
SetBkColor32 (hdcImageList, RGB(0, 0, 0));
|
|
BitBlt32 (hdcMask, 0, 0, himl->cx, himl->cy,
|
|
hdcImageList, himl->cx * btnPtr->iBitmap, 0, MERGEPAINT);
|
|
#endif
|
|
|
|
/* draw the new mask */
|
|
SelectObject32 (hdc, GetSysColorBrush32 (COLOR_3DHILIGHT));
|
|
BitBlt32 (hdc, x+1, y+1, himl->cx, himl->cy,
|
|
hdcMask, 0, 0, 0xB8074A);
|
|
|
|
SelectObject32 (hdc, GetSysColorBrush32 (COLOR_3DSHADOW));
|
|
BitBlt32 (hdc, x, y, himl->cx, himl->cy,
|
|
hdcMask, 0, 0, 0xB8074A);
|
|
|
|
DeleteObject32 (hbmMask);
|
|
DeleteDC32 (hdcMask);
|
|
DeleteDC32 (hdcImageList);
|
|
}
|
|
|
|
|
|
static void
|
|
TOOLBAR_DrawButton (WND *wndPtr, TBUTTON_INFO *btnPtr, HDC32 hdc)
|
|
{
|
|
TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr(wndPtr);
|
|
BOOL32 bFlat = (wndPtr->dwStyle & TBSTYLE_FLAT);
|
|
RECT32 rc;
|
|
|
|
if (btnPtr->fsState & TBSTATE_HIDDEN) return;
|
|
|
|
rc = btnPtr->rect;
|
|
if (btnPtr->fsStyle & TBSTYLE_SEP) {
|
|
if ((bFlat) && (btnPtr->idCommand == 0))
|
|
TOOLBAR_DrawFlatSeparator (&btnPtr->rect, hdc);
|
|
return;
|
|
}
|
|
|
|
/* disabled */
|
|
if (!(btnPtr->fsState & TBSTATE_ENABLED)) {
|
|
DrawEdge32 (hdc, &rc, EDGE_RAISED,
|
|
BF_SOFT | BF_RECT | BF_MIDDLE | BF_ADJUST);
|
|
|
|
if (bFlat) {
|
|
/* if (infoPtr->himlDis) */
|
|
ImageList_Draw (infoPtr->himlDis, btnPtr->iBitmap, hdc,
|
|
rc.left+1, rc.top+1, ILD_NORMAL);
|
|
/* else */
|
|
/* TOOLBAR_DrawMasked (infoPtr, btnPtr, hdc, rc.left+1, rc.top+1); */
|
|
}
|
|
else
|
|
TOOLBAR_DrawMasked (infoPtr, btnPtr, hdc, rc.left+1, rc.top+1);
|
|
|
|
TOOLBAR_DrawString (infoPtr, btnPtr, hdc, btnPtr->fsState);
|
|
return;
|
|
}
|
|
|
|
/* pressed TBSTYLE_BUTTON */
|
|
if (btnPtr->fsState & TBSTATE_PRESSED) {
|
|
DrawEdge32 (hdc, &rc, EDGE_SUNKEN,
|
|
BF_RECT | BF_MIDDLE | BF_ADJUST);
|
|
ImageList_Draw (infoPtr->himlStd, btnPtr->iBitmap, hdc,
|
|
rc.left+2, rc.top+2, ILD_NORMAL);
|
|
TOOLBAR_DrawString (infoPtr, btnPtr, hdc, btnPtr->fsState);
|
|
return;
|
|
}
|
|
|
|
/* checked TBSTYLE_CHECK*/
|
|
if ((btnPtr->fsStyle & TBSTYLE_CHECK) &&
|
|
(btnPtr->fsState & TBSTATE_CHECKED)) {
|
|
if (bFlat)
|
|
DrawEdge32 (hdc, &rc, BDR_SUNKENOUTER,
|
|
BF_RECT | BF_MIDDLE | BF_ADJUST);
|
|
else
|
|
DrawEdge32 (hdc, &rc, EDGE_SUNKEN,
|
|
BF_RECT | BF_MIDDLE | BF_ADJUST);
|
|
|
|
TOOLBAR_DrawPattern (hdc, &rc);
|
|
if (bFlat)
|
|
ImageList_Draw (infoPtr->himlDef, btnPtr->iBitmap, hdc,
|
|
rc.left+2, rc.top+2, ILD_NORMAL);
|
|
else
|
|
ImageList_Draw (infoPtr->himlStd, btnPtr->iBitmap, hdc,
|
|
rc.left+2, rc.top+2, ILD_NORMAL);
|
|
TOOLBAR_DrawString (infoPtr, btnPtr, hdc, btnPtr->fsState);
|
|
return;
|
|
}
|
|
|
|
/* indeterminate */
|
|
if (btnPtr->fsState & TBSTATE_INDETERMINATE) {
|
|
DrawEdge32 (hdc, &rc, EDGE_RAISED,
|
|
BF_SOFT | BF_RECT | BF_MIDDLE | BF_ADJUST);
|
|
|
|
TOOLBAR_DrawPattern (hdc, &rc);
|
|
TOOLBAR_DrawMasked (infoPtr, btnPtr, hdc, rc.left+1, rc.top+1);
|
|
TOOLBAR_DrawString (infoPtr, btnPtr, hdc, btnPtr->fsState);
|
|
return;
|
|
}
|
|
|
|
/* normal state */
|
|
DrawEdge32 (hdc, &rc, EDGE_RAISED,
|
|
BF_SOFT | BF_RECT | BF_MIDDLE | BF_ADJUST);
|
|
|
|
if (bFlat)
|
|
ImageList_Draw (infoPtr->himlDef, btnPtr->iBitmap, hdc,
|
|
rc.left+1, rc.top+1, ILD_NORMAL);
|
|
else
|
|
ImageList_Draw (infoPtr->himlStd, btnPtr->iBitmap, hdc,
|
|
rc.left+1, rc.top+1, ILD_NORMAL);
|
|
|
|
TOOLBAR_DrawString (infoPtr, btnPtr, hdc, btnPtr->fsState);
|
|
}
|
|
|
|
|
|
static void
|
|
TOOLBAR_Refresh (WND *wndPtr, HDC32 hdc)
|
|
{
|
|
TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr(wndPtr);
|
|
TBUTTON_INFO *btnPtr;
|
|
INT32 i;
|
|
|
|
/* draw buttons */
|
|
btnPtr = infoPtr->buttons;
|
|
for (i = 0; i < infoPtr->nNumButtons; i++, btnPtr++)
|
|
TOOLBAR_DrawButton (wndPtr, btnPtr, hdc);
|
|
}
|
|
|
|
|
|
static void
|
|
TOOLBAR_CalcStrings (WND *wndPtr, LPSIZE32 lpSize)
|
|
{
|
|
TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr(wndPtr);
|
|
TBUTTON_INFO *btnPtr;
|
|
INT32 i;
|
|
HDC32 hdc;
|
|
HFONT32 hOldFont;
|
|
SIZE32 sz;
|
|
|
|
lpSize->cx = 0;
|
|
lpSize->cy = 0;
|
|
hdc = GetDC32 (0);
|
|
hOldFont = SelectObject32 (hdc, infoPtr->hFont);
|
|
|
|
btnPtr = infoPtr->buttons;
|
|
for (i = 0; i < infoPtr->nNumButtons; i++, btnPtr++) {
|
|
if (!(btnPtr->fsState & TBSTATE_HIDDEN) &&
|
|
(btnPtr->iString > -1) &&
|
|
(btnPtr->iString < infoPtr->nNumStrings)) {
|
|
LPWSTR lpText = infoPtr->strings[btnPtr->iString];
|
|
GetTextExtentPoint32W (hdc, lpText, lstrlen32W (lpText), &sz);
|
|
if (sz.cx > lpSize->cx)
|
|
lpSize->cx = sz.cx;
|
|
if (sz.cy > lpSize->cy)
|
|
lpSize->cy = sz.cy;
|
|
}
|
|
}
|
|
|
|
SelectObject32 (hdc, hOldFont);
|
|
ReleaseDC32 (0, hdc);
|
|
|
|
TRACE (toolbar, "string size %d x %d!\n", lpSize->cx, lpSize->cy);
|
|
}
|
|
|
|
|
|
static void
|
|
TOOLBAR_CalcToolbar (WND *wndPtr)
|
|
{
|
|
TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr(wndPtr);
|
|
TBUTTON_INFO *btnPtr, *grpPtr;
|
|
INT32 i, j, nRows;
|
|
INT32 x, y, cx, cy;
|
|
BOOL32 bWrap;
|
|
SIZE32 sizeString;
|
|
/* --- new --- */
|
|
INT32 nGrpCount = 0;
|
|
INT32 grpX;
|
|
/* --- end new --- */
|
|
|
|
TOOLBAR_CalcStrings (wndPtr, &sizeString);
|
|
|
|
if (sizeString.cy > 0)
|
|
infoPtr->nButtonHeight = sizeString.cy + infoPtr->nBitmapHeight + 6;
|
|
else if (infoPtr->nButtonHeight < infoPtr->nBitmapHeight + 6)
|
|
infoPtr->nButtonHeight = infoPtr->nBitmapHeight + 6;
|
|
|
|
if (sizeString.cx > infoPtr->nBitmapWidth)
|
|
infoPtr->nButtonWidth = sizeString.cx + 6;
|
|
else if (infoPtr->nButtonWidth < infoPtr->nBitmapWidth + 6)
|
|
infoPtr->nButtonWidth = infoPtr->nBitmapWidth + 6;
|
|
|
|
x = infoPtr->nIndent;
|
|
y = TOP_BORDER;
|
|
cx = infoPtr->nButtonWidth;
|
|
cy = infoPtr->nButtonHeight;
|
|
nRows = 0;
|
|
|
|
/* calculate the size of each button according to it's style */
|
|
/* TOOLBAR_CalcButtons (wndPtr); */
|
|
|
|
infoPtr->rcBound.top = y;
|
|
infoPtr->rcBound.left = x;
|
|
infoPtr->rcBound.bottom = y + cy;
|
|
infoPtr->rcBound.right = x;
|
|
|
|
btnPtr = infoPtr->buttons;
|
|
for (i = 0; i < infoPtr->nNumButtons; i++, btnPtr++) {
|
|
bWrap = FALSE;
|
|
|
|
if (btnPtr->fsState & TBSTATE_HIDDEN) {
|
|
SetRectEmpty32 (&btnPtr->rect);
|
|
continue;
|
|
}
|
|
|
|
#ifdef __NEW_WRAP_CODE__
|
|
/*#if 0 */
|
|
if (btnPtr->fsStyle & TBSTYLE_SEP) {
|
|
/* UNDOCUMENTED: If a separator has a non zero bitmap index, */
|
|
/* it is the actual width of the separator. This is used for */
|
|
/* custom controls in toolbars. */
|
|
if ((wndPtr->dwStyle & TBSTYLE_WRAPABLE) &&
|
|
(btnPtr->fsState & TBSTATE_WRAP)) {
|
|
x = 0;
|
|
y += cy;
|
|
cx = infoPtr->nWidth;
|
|
cy = ((btnPtr->iBitmap > 0) ?
|
|
btnPtr->iBitmap : SEPARATOR_WIDTH) * 2 / 3;
|
|
/* nRows++; */
|
|
/* bWrap = TRUE; */
|
|
}
|
|
else
|
|
cx = (btnPtr->iBitmap > 0) ?
|
|
btnPtr->iBitmap : SEPARATOR_WIDTH;
|
|
}
|
|
else {
|
|
/* this must be a button */
|
|
cx = infoPtr->nButtonWidth;
|
|
}
|
|
/*#endif */
|
|
|
|
/* --- begin test --- */
|
|
if ((i >= nGrpCount) && (btnPtr->fsStyle & TBSTYLE_GROUP)) {
|
|
for (j = i, grpX = x, nGrpCount = 0; j < infoPtr->nNumButtons; j++) {
|
|
grpPtr = &infoPtr->buttons[j];
|
|
if (grpPtr->fsState & TBSTATE_HIDDEN)
|
|
continue;
|
|
|
|
grpX += cx;
|
|
|
|
if ((grpPtr->fsStyle & TBSTYLE_SEP) ||
|
|
!(grpPtr->fsStyle & TBSTYLE_GROUP) ||
|
|
(grpX > infoPtr->nWidth)) {
|
|
nGrpCount = j;
|
|
break;
|
|
}
|
|
else if (grpX + x > infoPtr->nWidth) {
|
|
bWrap = TRUE;
|
|
nGrpCount = j;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
bWrap = ((bWrap || (x + cx > infoPtr->nWidth)) &&
|
|
(wndPtr->dwStyle & TBSTYLE_WRAPABLE));
|
|
if (bWrap) {
|
|
nRows++;
|
|
y += cy;
|
|
x = infoPtr->nIndent;
|
|
bWrap = FALSE;
|
|
}
|
|
|
|
SetRect32 (&btnPtr->rect, x, y, x + cx, y + cy);
|
|
|
|
btnPtr->nRow = nRows;
|
|
x += cx;
|
|
|
|
if (btnPtr->fsState & TBSTATE_WRAP) {
|
|
nRows++;
|
|
y += (cy + SEPARATOR_HEIGHT);
|
|
x = infoPtr->nIndent;
|
|
}
|
|
|
|
infoPtr->nRows = nRows + 1;
|
|
|
|
/* --- end test --- */
|
|
#else
|
|
if (btnPtr->fsStyle & TBSTYLE_SEP) {
|
|
/* UNDOCUMENTED: If a separator has a non zero bitmap index, */
|
|
/* it is the actual width of the separator. This is used for */
|
|
/* custom controls in toolbars. */
|
|
if ((wndPtr->dwStyle & TBSTYLE_WRAPABLE) &&
|
|
(btnPtr->fsState & TBSTATE_WRAP)) {
|
|
x = 0;
|
|
y += cy;
|
|
cx = infoPtr->nWidth;
|
|
cy = ((btnPtr->iBitmap > 0) ?
|
|
btnPtr->iBitmap : SEPARATOR_WIDTH) * 2 / 3;
|
|
nRows++;
|
|
bWrap = TRUE;
|
|
}
|
|
else
|
|
cx = (btnPtr->iBitmap > 0) ?
|
|
btnPtr->iBitmap : SEPARATOR_WIDTH;
|
|
}
|
|
else {
|
|
/* this must be a button */
|
|
cx = infoPtr->nButtonWidth;
|
|
}
|
|
|
|
btnPtr->rect.left = x;
|
|
btnPtr->rect.top = y;
|
|
btnPtr->rect.right = x + cx;
|
|
btnPtr->rect.bottom = y + cy;
|
|
|
|
if (infoPtr->rcBound.left > x)
|
|
infoPtr->rcBound.left = x;
|
|
if (infoPtr->rcBound.right < x + cx)
|
|
infoPtr->rcBound.right = x + cx;
|
|
if (infoPtr->rcBound.bottom < y + cy)
|
|
infoPtr->rcBound.bottom = y + cy;
|
|
|
|
if (infoPtr->hwndToolTip) {
|
|
TTTOOLINFO32A ti;
|
|
|
|
ZeroMemory (&ti, sizeof(TTTOOLINFO32A));
|
|
ti.cbSize = sizeof(TTTOOLINFO32A);
|
|
ti.hwnd = wndPtr->hwndSelf;
|
|
ti.uId = btnPtr->idCommand;
|
|
ti.rect = btnPtr->rect;
|
|
SendMessage32A (infoPtr->hwndToolTip, TTM_NEWTOOLRECT32A,
|
|
0, (LPARAM)&ti);
|
|
}
|
|
|
|
if (bWrap) {
|
|
x = 0;
|
|
y += cy;
|
|
if (i < infoPtr->nNumButtons)
|
|
nRows++;
|
|
}
|
|
else
|
|
x += cx;
|
|
#endif
|
|
}
|
|
|
|
infoPtr->nHeight = y + cy + BOTTOM_BORDER;
|
|
TRACE (toolbar, "toolbar height %d\n", infoPtr->nHeight);
|
|
}
|
|
|
|
|
|
static INT32
|
|
TOOLBAR_InternalHitTest (WND *wndPtr, LPPOINT32 lpPt)
|
|
{
|
|
TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr(wndPtr);
|
|
TBUTTON_INFO *btnPtr;
|
|
INT32 i;
|
|
|
|
btnPtr = infoPtr->buttons;
|
|
for (i = 0; i < infoPtr->nNumButtons; i++, btnPtr++) {
|
|
if (btnPtr->fsState & TBSTATE_HIDDEN)
|
|
continue;
|
|
|
|
if (btnPtr->fsStyle & TBSTYLE_SEP) {
|
|
if (PtInRect32 (&btnPtr->rect, *lpPt)) {
|
|
TRACE (toolbar, " ON SEPARATOR %d!\n", i);
|
|
return -i;
|
|
}
|
|
}
|
|
else {
|
|
if (PtInRect32 (&btnPtr->rect, *lpPt)) {
|
|
TRACE (toolbar, " ON BUTTON %d!\n", i);
|
|
return i;
|
|
}
|
|
}
|
|
}
|
|
|
|
TRACE (toolbar, " NOWHERE!\n");
|
|
return -1;
|
|
}
|
|
|
|
|
|
static INT32
|
|
TOOLBAR_GetButtonIndex (TOOLBAR_INFO *infoPtr, INT32 idCommand)
|
|
{
|
|
TBUTTON_INFO *btnPtr;
|
|
INT32 i;
|
|
|
|
btnPtr = infoPtr->buttons;
|
|
for (i = 0; i < infoPtr->nNumButtons; i++, btnPtr++) {
|
|
if (btnPtr->idCommand == idCommand) {
|
|
TRACE (toolbar, "command=%d index=%d\n", idCommand, i);
|
|
return i;
|
|
}
|
|
}
|
|
TRACE (toolbar, "no index found for command=%d\n", idCommand);
|
|
return -1;
|
|
}
|
|
|
|
|
|
static INT32
|
|
TOOLBAR_GetCheckedGroupButtonIndex (TOOLBAR_INFO *infoPtr, INT32 nIndex)
|
|
{
|
|
TBUTTON_INFO *btnPtr;
|
|
INT32 nRunIndex;
|
|
|
|
if ((nIndex < 0) || (nIndex > infoPtr->nNumButtons))
|
|
return -1;
|
|
|
|
/* check index button */
|
|
btnPtr = &infoPtr->buttons[nIndex];
|
|
if ((btnPtr->fsStyle & TBSTYLE_CHECKGROUP) == TBSTYLE_CHECKGROUP) {
|
|
if (btnPtr->fsState & TBSTATE_CHECKED)
|
|
return nIndex;
|
|
}
|
|
|
|
/* check previous buttons */
|
|
nRunIndex = nIndex - 1;
|
|
while (nRunIndex >= 0) {
|
|
btnPtr = &infoPtr->buttons[nRunIndex];
|
|
if ((btnPtr->fsStyle & TBSTYLE_CHECKGROUP) == TBSTYLE_CHECKGROUP) {
|
|
if (btnPtr->fsState & TBSTATE_CHECKED)
|
|
return nRunIndex;
|
|
}
|
|
else
|
|
break;
|
|
nRunIndex--;
|
|
}
|
|
|
|
/* check next buttons */
|
|
nRunIndex = nIndex + 1;
|
|
while (nRunIndex < infoPtr->nNumButtons) {
|
|
btnPtr = &infoPtr->buttons[nRunIndex];
|
|
if ((btnPtr->fsStyle & TBSTYLE_CHECKGROUP) == TBSTYLE_CHECKGROUP) {
|
|
if (btnPtr->fsState & TBSTATE_CHECKED)
|
|
return nRunIndex;
|
|
}
|
|
else
|
|
break;
|
|
nRunIndex++;
|
|
}
|
|
|
|
return -1;
|
|
}
|
|
|
|
|
|
static VOID
|
|
TOOLBAR_RelayEvent (HWND32 hwndTip, HWND32 hwndMsg, UINT32 uMsg,
|
|
WPARAM32 wParam, LPARAM lParam)
|
|
{
|
|
MSG32 msg;
|
|
|
|
msg.hwnd = hwndMsg;
|
|
msg.message = uMsg;
|
|
msg.wParam = wParam;
|
|
msg.lParam = lParam;
|
|
msg.time = GetMessageTime ();
|
|
msg.pt.x = LOWORD(GetMessagePos ());
|
|
msg.pt.y = HIWORD(GetMessagePos ());
|
|
|
|
SendMessage32A (hwndTip, TTM_RELAYEVENT, 0, (LPARAM)&msg);
|
|
}
|
|
|
|
|
|
static LRESULT
|
|
TOOLBAR_AddBitmap (WND *wndPtr, WPARAM32 wParam, LPARAM lParam)
|
|
{
|
|
TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr(wndPtr);
|
|
LPTBADDBITMAP lpAddBmp = (LPTBADDBITMAP)lParam;
|
|
INT32 nIndex = 0;
|
|
|
|
if ((!lpAddBmp) || ((INT32)wParam <= 0))
|
|
return -1;
|
|
|
|
TRACE (toolbar, "adding %d bitmaps!\n", wParam);
|
|
|
|
if (!(infoPtr->himlDef)) {
|
|
/* create new default image list */
|
|
TRACE (toolbar, "creating default image list!\n");
|
|
infoPtr->himlStd =
|
|
ImageList_Create (infoPtr->nBitmapWidth, infoPtr->nBitmapHeight,
|
|
ILC_COLOR | ILC_MASK, (INT32)wParam, 2);
|
|
}
|
|
|
|
#if 0
|
|
if (!(infoPtr->himlDis)) {
|
|
/* create new disabled image list */
|
|
TRACE (toolbar, "creating disabled image list!\n");
|
|
infoPtr->himlDis =
|
|
ImageList_Create (infoPtr->nBitmapWidth,
|
|
infoPtr->nBitmapHeight, ILC_COLOR | ILC_MASK,
|
|
(INT32)wParam, 2);
|
|
}
|
|
#endif
|
|
|
|
/* Add bitmaps to the default image list */
|
|
if (lpAddBmp->hInst == (HINSTANCE32)0) {
|
|
nIndex =
|
|
ImageList_AddMasked (infoPtr->himlStd, (HBITMAP32)lpAddBmp->nID,
|
|
CLR_DEFAULT);
|
|
}
|
|
else if (lpAddBmp->hInst == HINST_COMMCTRL) {
|
|
/* add internal bitmaps */
|
|
FIXME (toolbar, "internal bitmaps not supported!\n");
|
|
|
|
/* Hack to "add" some reserved images within the image list
|
|
to get the right image indices */
|
|
nIndex = ImageList_GetImageCount (infoPtr->himlStd);
|
|
ImageList_SetImageCount (infoPtr->himlStd, nIndex + (INT32)wParam);
|
|
}
|
|
else {
|
|
HBITMAP32 hBmp =
|
|
LoadBitmap32A (lpAddBmp->hInst, (LPSTR)lpAddBmp->nID);
|
|
|
|
nIndex = ImageList_AddMasked (infoPtr->himlStd, hBmp, CLR_DEFAULT);
|
|
|
|
DeleteObject32 (hBmp);
|
|
}
|
|
|
|
|
|
infoPtr->nNumBitmaps += (INT32)wParam;
|
|
|
|
return nIndex;
|
|
}
|
|
|
|
|
|
static LRESULT
|
|
TOOLBAR_AddButtons32A (WND *wndPtr, WPARAM32 wParam, LPARAM lParam)
|
|
{
|
|
TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr(wndPtr);
|
|
LPTBBUTTON lpTbb = (LPTBBUTTON)lParam;
|
|
INT32 nOldButtons, nNewButtons, nAddButtons, nCount;
|
|
HDC32 hdc;
|
|
|
|
TRACE (toolbar, "adding %d buttons!\n", wParam);
|
|
|
|
nAddButtons = (UINT32)wParam;
|
|
nOldButtons = infoPtr->nNumButtons;
|
|
nNewButtons = nOldButtons + nAddButtons;
|
|
|
|
if (infoPtr->nNumButtons == 0) {
|
|
infoPtr->buttons =
|
|
COMCTL32_Alloc (sizeof(TBUTTON_INFO) * nNewButtons);
|
|
}
|
|
else {
|
|
TBUTTON_INFO *oldButtons = infoPtr->buttons;
|
|
infoPtr->buttons =
|
|
COMCTL32_Alloc (sizeof(TBUTTON_INFO) * nNewButtons);
|
|
memcpy (&infoPtr->buttons[0], &oldButtons[0],
|
|
nOldButtons * sizeof(TBUTTON_INFO));
|
|
COMCTL32_Free (oldButtons);
|
|
}
|
|
|
|
infoPtr->nNumButtons = nNewButtons;
|
|
|
|
/* insert new button data */
|
|
for (nCount = 0; nCount < nAddButtons; nCount++) {
|
|
TBUTTON_INFO *btnPtr = &infoPtr->buttons[nOldButtons+nCount];
|
|
btnPtr->iBitmap = lpTbb[nCount].iBitmap;
|
|
btnPtr->idCommand = lpTbb[nCount].idCommand;
|
|
btnPtr->fsState = lpTbb[nCount].fsState;
|
|
btnPtr->fsStyle = lpTbb[nCount].fsStyle;
|
|
btnPtr->dwData = lpTbb[nCount].dwData;
|
|
btnPtr->iString = lpTbb[nCount].iString;
|
|
|
|
if ((infoPtr->hwndToolTip) && !(btnPtr->fsStyle & TBSTYLE_SEP)) {
|
|
TTTOOLINFO32A ti;
|
|
|
|
ZeroMemory (&ti, sizeof(TTTOOLINFO32A));
|
|
ti.cbSize = sizeof (TTTOOLINFO32A);
|
|
ti.hwnd = wndPtr->hwndSelf;
|
|
ti.uId = btnPtr->idCommand;
|
|
ti.hinst = 0;
|
|
ti.lpszText = LPSTR_TEXTCALLBACK32A;
|
|
|
|
SendMessage32A (infoPtr->hwndToolTip, TTM_ADDTOOL32A,
|
|
0, (LPARAM)&ti);
|
|
}
|
|
}
|
|
|
|
TOOLBAR_CalcToolbar (wndPtr);
|
|
|
|
hdc = GetDC32 (wndPtr->hwndSelf);
|
|
TOOLBAR_Refresh (wndPtr, hdc);
|
|
ReleaseDC32 (wndPtr->hwndSelf, hdc);
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
|
|
/* << TOOLBAR_AddButtons32W >> */
|
|
|
|
|
|
static LRESULT
|
|
TOOLBAR_AddString32A (WND *wndPtr, WPARAM32 wParam, LPARAM lParam)
|
|
{
|
|
TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr(wndPtr);
|
|
INT32 nIndex;
|
|
|
|
if ((wParam) && (HIWORD(lParam) == 0)) {
|
|
char szString[256];
|
|
INT32 len;
|
|
TRACE (toolbar, "adding string from resource!\n");
|
|
|
|
len = LoadString32A ((HINSTANCE32)wParam, (UINT32)lParam,
|
|
szString, 256);
|
|
|
|
TRACE (toolbar, "len=%d \"%s\"\n", len, szString);
|
|
nIndex = infoPtr->nNumStrings;
|
|
if (infoPtr->nNumStrings == 0) {
|
|
infoPtr->strings =
|
|
COMCTL32_Alloc (sizeof(LPWSTR));
|
|
}
|
|
else {
|
|
LPWSTR *oldStrings = infoPtr->strings;
|
|
infoPtr->strings =
|
|
COMCTL32_Alloc (sizeof(LPWSTR) * (infoPtr->nNumStrings + 1));
|
|
memcpy (&infoPtr->strings[0], &oldStrings[0],
|
|
sizeof(LPWSTR) * infoPtr->nNumStrings);
|
|
COMCTL32_Free (oldStrings);
|
|
}
|
|
|
|
infoPtr->strings[infoPtr->nNumStrings] =
|
|
COMCTL32_Alloc (sizeof(WCHAR)*(len+1));
|
|
lstrcpyAtoW (infoPtr->strings[infoPtr->nNumStrings], szString);
|
|
infoPtr->nNumStrings++;
|
|
}
|
|
else {
|
|
LPSTR p = (LPSTR)lParam;
|
|
INT32 len;
|
|
|
|
if (p == NULL)
|
|
return -1;
|
|
TRACE (toolbar, "adding string(s) from array!\n");
|
|
nIndex = infoPtr->nNumStrings;
|
|
while (*p) {
|
|
len = lstrlen32A (p);
|
|
TRACE (toolbar, "len=%d \"%s\"\n", len, p);
|
|
|
|
if (infoPtr->nNumStrings == 0) {
|
|
infoPtr->strings =
|
|
COMCTL32_Alloc (sizeof(LPWSTR));
|
|
}
|
|
else {
|
|
LPWSTR *oldStrings = infoPtr->strings;
|
|
infoPtr->strings =
|
|
COMCTL32_Alloc (sizeof(LPWSTR) * (infoPtr->nNumStrings + 1));
|
|
memcpy (&infoPtr->strings[0], &oldStrings[0],
|
|
sizeof(LPWSTR) * infoPtr->nNumStrings);
|
|
COMCTL32_Free (oldStrings);
|
|
}
|
|
|
|
infoPtr->strings[infoPtr->nNumStrings] =
|
|
COMCTL32_Alloc (sizeof(WCHAR)*(len+1));
|
|
lstrcpyAtoW (infoPtr->strings[infoPtr->nNumStrings], p);
|
|
infoPtr->nNumStrings++;
|
|
|
|
p += (len+1);
|
|
}
|
|
}
|
|
|
|
return nIndex;
|
|
}
|
|
|
|
|
|
static LRESULT
|
|
TOOLBAR_AddString32W (WND *wndPtr, WPARAM32 wParam, LPARAM lParam)
|
|
{
|
|
TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr(wndPtr);
|
|
INT32 nIndex;
|
|
|
|
if ((wParam) && (HIWORD(lParam) == 0)) {
|
|
WCHAR szString[256];
|
|
INT32 len;
|
|
TRACE (toolbar, "adding string from resource!\n");
|
|
|
|
len = LoadString32W ((HINSTANCE32)wParam, (UINT32)lParam,
|
|
szString, 256);
|
|
|
|
TRACE (toolbar, "len=%d \"%s\"\n", len, debugstr_w(szString));
|
|
nIndex = infoPtr->nNumStrings;
|
|
if (infoPtr->nNumStrings == 0) {
|
|
infoPtr->strings =
|
|
COMCTL32_Alloc (sizeof(LPWSTR));
|
|
}
|
|
else {
|
|
LPWSTR *oldStrings = infoPtr->strings;
|
|
infoPtr->strings =
|
|
COMCTL32_Alloc (sizeof(LPWSTR) * (infoPtr->nNumStrings + 1));
|
|
memcpy (&infoPtr->strings[0], &oldStrings[0],
|
|
sizeof(LPWSTR) * infoPtr->nNumStrings);
|
|
COMCTL32_Free (oldStrings);
|
|
}
|
|
|
|
infoPtr->strings[infoPtr->nNumStrings] =
|
|
COMCTL32_Alloc (sizeof(WCHAR)*(len+1));
|
|
lstrcpy32W (infoPtr->strings[infoPtr->nNumStrings], szString);
|
|
infoPtr->nNumStrings++;
|
|
}
|
|
else {
|
|
LPWSTR p = (LPWSTR)lParam;
|
|
INT32 len;
|
|
|
|
if (p == NULL)
|
|
return -1;
|
|
TRACE (toolbar, "adding string(s) from array!\n");
|
|
nIndex = infoPtr->nNumStrings;
|
|
while (*p) {
|
|
len = lstrlen32W (p);
|
|
TRACE (toolbar, "len=%d \"%s\"\n", len, debugstr_w(p));
|
|
|
|
if (infoPtr->nNumStrings == 0) {
|
|
infoPtr->strings =
|
|
COMCTL32_Alloc (sizeof(LPWSTR));
|
|
}
|
|
else {
|
|
LPWSTR *oldStrings = infoPtr->strings;
|
|
infoPtr->strings =
|
|
COMCTL32_Alloc (sizeof(LPWSTR) * (infoPtr->nNumStrings + 1));
|
|
memcpy (&infoPtr->strings[0], &oldStrings[0],
|
|
sizeof(LPWSTR) * infoPtr->nNumStrings);
|
|
COMCTL32_Free (oldStrings);
|
|
}
|
|
|
|
infoPtr->strings[infoPtr->nNumStrings] =
|
|
COMCTL32_Alloc (sizeof(WCHAR)*(len+1));
|
|
lstrcpy32W (infoPtr->strings[infoPtr->nNumStrings], p);
|
|
infoPtr->nNumStrings++;
|
|
|
|
p += (len+1);
|
|
}
|
|
}
|
|
|
|
return nIndex;
|
|
}
|
|
|
|
|
|
static LRESULT
|
|
TOOLBAR_AutoSize (WND *wndPtr, WPARAM32 wParam, LPARAM lParam)
|
|
{
|
|
TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr(wndPtr);
|
|
RECT32 parent_rect;
|
|
HWND32 parent;
|
|
/* INT32 x, y; */
|
|
INT32 cx, cy;
|
|
UINT32 uPosFlags = 0;
|
|
|
|
TRACE (toolbar, "resize forced!\n");
|
|
|
|
parent = GetParent32 (wndPtr->hwndSelf);
|
|
GetClientRect32(parent, &parent_rect);
|
|
|
|
if (wndPtr->dwStyle & CCS_NORESIZE) {
|
|
uPosFlags |= (SWP_NOSIZE | SWP_NOMOVE);
|
|
cx = 0;
|
|
cy = 0;
|
|
}
|
|
else {
|
|
infoPtr->nWidth = parent_rect.right - parent_rect.left;
|
|
TOOLBAR_CalcToolbar (wndPtr);
|
|
cy = infoPtr->nHeight;
|
|
cx = infoPtr->nWidth;
|
|
}
|
|
|
|
if (wndPtr->dwStyle & CCS_NOPARENTALIGN)
|
|
uPosFlags |= SWP_NOMOVE;
|
|
|
|
if (!(wndPtr->dwStyle & CCS_NODIVIDER))
|
|
cy += sysMetrics[SM_CYEDGE];
|
|
|
|
infoPtr->bAutoSize = TRUE;
|
|
SetWindowPos32 (wndPtr->hwndSelf, HWND_TOP, parent_rect.left, parent_rect.top,
|
|
cx, cy, uPosFlags);
|
|
|
|
return 0;
|
|
}
|
|
|
|
|
|
static LRESULT
|
|
TOOLBAR_ButtonCount (WND *wndPtr, WPARAM32 wParam, LPARAM lParam)
|
|
{
|
|
TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr(wndPtr);
|
|
|
|
return infoPtr->nNumButtons;
|
|
}
|
|
|
|
|
|
static LRESULT
|
|
TOOLBAR_ButtonStructSize (WND *wndPtr, WPARAM32 wParam, LPARAM lParam)
|
|
{
|
|
TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr(wndPtr);
|
|
|
|
if (infoPtr == NULL) {
|
|
ERR (toolbar, "(0x%08lx, 0x%08x, 0x%08lx)\n", (DWORD)wndPtr, wParam, lParam);
|
|
ERR (toolbar, "infoPtr == NULL!\n");
|
|
return 0;
|
|
}
|
|
|
|
infoPtr->dwStructSize = (DWORD)wParam;
|
|
|
|
return 0;
|
|
}
|
|
|
|
|
|
static LRESULT
|
|
TOOLBAR_ChangeBitmap (WND *wndPtr, WPARAM32 wParam, LPARAM lParam)
|
|
{
|
|
TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr(wndPtr);
|
|
TBUTTON_INFO *btnPtr;
|
|
HDC32 hdc;
|
|
INT32 nIndex;
|
|
|
|
nIndex = TOOLBAR_GetButtonIndex (infoPtr, (INT32)wParam);
|
|
if (nIndex == -1)
|
|
return FALSE;
|
|
|
|
btnPtr = &infoPtr->buttons[nIndex];
|
|
btnPtr->iBitmap = LOWORD(lParam);
|
|
|
|
hdc = GetDC32 (wndPtr->hwndSelf);
|
|
TOOLBAR_DrawButton (wndPtr, btnPtr, hdc);
|
|
ReleaseDC32 (wndPtr->hwndSelf, hdc);
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
|
|
static LRESULT
|
|
TOOLBAR_CheckButton (WND *wndPtr, WPARAM32 wParam, LPARAM lParam)
|
|
{
|
|
TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr(wndPtr);
|
|
TBUTTON_INFO *btnPtr;
|
|
HDC32 hdc;
|
|
INT32 nIndex;
|
|
INT32 nOldIndex = -1;
|
|
|
|
nIndex = TOOLBAR_GetButtonIndex (infoPtr, (INT32)wParam);
|
|
if (nIndex == -1)
|
|
return FALSE;
|
|
|
|
btnPtr = &infoPtr->buttons[nIndex];
|
|
|
|
if (!(btnPtr->fsStyle & TBSTYLE_CHECK))
|
|
return FALSE;
|
|
|
|
if (LOWORD(lParam) == FALSE)
|
|
btnPtr->fsState &= ~TBSTATE_CHECKED;
|
|
else {
|
|
if (btnPtr->fsStyle & TBSTYLE_GROUP) {
|
|
nOldIndex =
|
|
TOOLBAR_GetCheckedGroupButtonIndex (infoPtr, nIndex);
|
|
if (nOldIndex == nIndex)
|
|
return 0;
|
|
if (nOldIndex != -1)
|
|
infoPtr->buttons[nOldIndex].fsState &= ~TBSTATE_CHECKED;
|
|
}
|
|
btnPtr->fsState |= TBSTATE_CHECKED;
|
|
}
|
|
|
|
hdc = GetDC32 (wndPtr->hwndSelf);
|
|
if (nOldIndex != -1)
|
|
TOOLBAR_DrawButton (wndPtr, &infoPtr->buttons[nOldIndex], hdc);
|
|
TOOLBAR_DrawButton (wndPtr, btnPtr, hdc);
|
|
ReleaseDC32 (wndPtr->hwndSelf, hdc);
|
|
|
|
/* FIXME: Send a WM_NOTIFY?? */
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
|
|
static LRESULT
|
|
TOOLBAR_CommandToIndex (WND *wndPtr, WPARAM32 wParam, LPARAM lParam)
|
|
{
|
|
TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr(wndPtr);
|
|
|
|
return TOOLBAR_GetButtonIndex (infoPtr, (INT32)wParam);
|
|
}
|
|
|
|
|
|
static LRESULT
|
|
TOOLBAR_Customize (WND *wndPtr)
|
|
{
|
|
FIXME (toolbar, "customization not implemented!\n");
|
|
|
|
return 0;
|
|
}
|
|
|
|
|
|
static LRESULT
|
|
TOOLBAR_DeleteButton (WND *wndPtr, WPARAM32 wParam, LPARAM lParam)
|
|
{
|
|
TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr(wndPtr);
|
|
INT32 nIndex = (INT32)wParam;
|
|
|
|
if ((nIndex < 0) || (nIndex >= infoPtr->nNumButtons))
|
|
return FALSE;
|
|
|
|
if ((infoPtr->hwndToolTip) &&
|
|
!(infoPtr->buttons[nIndex].fsStyle & TBSTYLE_SEP)) {
|
|
TTTOOLINFO32A ti;
|
|
|
|
ZeroMemory (&ti, sizeof(TTTOOLINFO32A));
|
|
ti.cbSize = sizeof (TTTOOLINFO32A);
|
|
ti.hwnd = wndPtr->hwndSelf;
|
|
ti.uId = infoPtr->buttons[nIndex].idCommand;
|
|
|
|
SendMessage32A (infoPtr->hwndToolTip, TTM_DELTOOL32A, 0, (LPARAM)&ti);
|
|
}
|
|
|
|
if (infoPtr->nNumButtons == 1) {
|
|
TRACE (toolbar, " simple delete!\n");
|
|
COMCTL32_Free (infoPtr->buttons);
|
|
infoPtr->buttons = NULL;
|
|
infoPtr->nNumButtons = 0;
|
|
}
|
|
else {
|
|
TBUTTON_INFO *oldButtons = infoPtr->buttons;
|
|
TRACE(toolbar, "complex delete! [nIndex=%d]\n", nIndex);
|
|
|
|
infoPtr->nNumButtons--;
|
|
infoPtr->buttons = COMCTL32_Alloc (sizeof (TBUTTON_INFO) * infoPtr->nNumButtons);
|
|
if (nIndex > 0) {
|
|
memcpy (&infoPtr->buttons[0], &oldButtons[0],
|
|
nIndex * sizeof(TBUTTON_INFO));
|
|
}
|
|
|
|
if (nIndex < infoPtr->nNumButtons) {
|
|
memcpy (&infoPtr->buttons[nIndex], &oldButtons[nIndex+1],
|
|
(infoPtr->nNumButtons - nIndex) * sizeof(TBUTTON_INFO));
|
|
}
|
|
|
|
COMCTL32_Free (oldButtons);
|
|
}
|
|
|
|
TOOLBAR_CalcToolbar (wndPtr);
|
|
|
|
InvalidateRect32 (wndPtr->hwndSelf, NULL, TRUE);
|
|
UpdateWindow32 (wndPtr->hwndSelf);
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
|
|
static LRESULT
|
|
TOOLBAR_EnableButton (WND *wndPtr, WPARAM32 wParam, LPARAM lParam)
|
|
{
|
|
TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr(wndPtr);
|
|
TBUTTON_INFO *btnPtr;
|
|
HDC32 hdc;
|
|
INT32 nIndex;
|
|
|
|
nIndex = TOOLBAR_GetButtonIndex (infoPtr, (INT32)wParam);
|
|
if (nIndex == -1)
|
|
return FALSE;
|
|
|
|
btnPtr = &infoPtr->buttons[nIndex];
|
|
if (LOWORD(lParam) == FALSE)
|
|
btnPtr->fsState &= ~(TBSTATE_ENABLED | TBSTATE_PRESSED);
|
|
else
|
|
btnPtr->fsState |= TBSTATE_ENABLED;
|
|
|
|
hdc = GetDC32 (wndPtr->hwndSelf);
|
|
TOOLBAR_DrawButton (wndPtr, btnPtr, hdc);
|
|
ReleaseDC32 (wndPtr->hwndSelf, hdc);
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
|
|
/* << TOOLBAR_GetAnchorHighlight >> */
|
|
|
|
|
|
static LRESULT
|
|
TOOLBAR_GetBitmap (WND *wndPtr, WPARAM32 wParam, LPARAM lParam)
|
|
{
|
|
TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr(wndPtr);
|
|
INT32 nIndex;
|
|
|
|
nIndex = TOOLBAR_GetButtonIndex (infoPtr, (INT32)wParam);
|
|
if (nIndex == -1)
|
|
return -1;
|
|
|
|
return infoPtr->buttons[nIndex].iBitmap;
|
|
}
|
|
|
|
|
|
static __inline__ LRESULT
|
|
TOOLBAR_GetBitmapFlags (WND *wndPtr, WPARAM32 wParam, LPARAM lParam)
|
|
{
|
|
return (GetDeviceCaps32 (0, LOGPIXELSX) >= 120) ? TBBF_LARGE : 0;
|
|
}
|
|
|
|
|
|
static LRESULT
|
|
TOOLBAR_GetButton (WND *wndPtr, WPARAM32 wParam, LPARAM lParam)
|
|
{
|
|
TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr(wndPtr);
|
|
LPTBBUTTON lpTbb = (LPTBBUTTON)lParam;
|
|
INT32 nIndex = (INT32)wParam;
|
|
TBUTTON_INFO *btnPtr;
|
|
|
|
if (infoPtr == NULL) return FALSE;
|
|
if (lpTbb == NULL) return FALSE;
|
|
|
|
if ((nIndex < 0) || (nIndex >= infoPtr->nNumButtons))
|
|
return FALSE;
|
|
|
|
btnPtr = &infoPtr->buttons[nIndex];
|
|
lpTbb->iBitmap = btnPtr->iBitmap;
|
|
lpTbb->idCommand = btnPtr->idCommand;
|
|
lpTbb->fsState = btnPtr->fsState;
|
|
lpTbb->fsStyle = btnPtr->fsStyle;
|
|
lpTbb->dwData = btnPtr->dwData;
|
|
lpTbb->iString = btnPtr->iString;
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
|
|
static LRESULT
|
|
TOOLBAR_GetButtonInfo32A (WND *wndPtr, WPARAM32 wParam, LPARAM lParam)
|
|
{
|
|
TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr(wndPtr);
|
|
LPTBBUTTONINFO32A lpTbInfo = (LPTBBUTTONINFO32A)lParam;
|
|
TBUTTON_INFO *btnPtr;
|
|
INT32 nIndex;
|
|
|
|
if (infoPtr == NULL) return -1;
|
|
if (lpTbInfo == NULL) return -1;
|
|
if (lpTbInfo->cbSize < sizeof(LPTBBUTTONINFO32A)) return -1;
|
|
|
|
nIndex = TOOLBAR_GetButtonIndex (infoPtr, (INT32)wParam);
|
|
if (nIndex == -1)
|
|
return -1;
|
|
|
|
btnPtr = &infoPtr->buttons[nIndex];
|
|
|
|
if (lpTbInfo->dwMask & TBIF_COMMAND)
|
|
lpTbInfo->idCommand = btnPtr->idCommand;
|
|
if (lpTbInfo->dwMask & TBIF_IMAGE)
|
|
lpTbInfo->iImage = btnPtr->iBitmap;
|
|
if (lpTbInfo->dwMask & TBIF_LPARAM)
|
|
lpTbInfo->lParam = btnPtr->dwData;
|
|
if (lpTbInfo->dwMask & TBIF_SIZE)
|
|
lpTbInfo->cx = (WORD)(btnPtr->rect.right - btnPtr->rect.left);
|
|
if (lpTbInfo->dwMask & TBIF_STATE)
|
|
lpTbInfo->fsState = btnPtr->fsState;
|
|
if (lpTbInfo->dwMask & TBIF_STYLE)
|
|
lpTbInfo->fsStyle = btnPtr->fsStyle;
|
|
if (lpTbInfo->dwMask & TBIF_TEXT) {
|
|
if ((btnPtr->iString >= 0) || (btnPtr->iString < infoPtr->nNumStrings))
|
|
lstrcpyn32A (lpTbInfo->pszText,
|
|
(LPSTR)infoPtr->strings[btnPtr->iString],
|
|
lpTbInfo->cchText);
|
|
}
|
|
|
|
return nIndex;
|
|
}
|
|
|
|
|
|
/* << TOOLBAR_GetButtonInfo32W >> */
|
|
|
|
|
|
static LRESULT
|
|
TOOLBAR_GetButtonSize (WND *wndPtr)
|
|
{
|
|
TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr(wndPtr);
|
|
|
|
return MAKELONG((WORD)infoPtr->nButtonWidth,
|
|
(WORD)infoPtr->nButtonHeight);
|
|
}
|
|
|
|
|
|
static LRESULT
|
|
TOOLBAR_GetButtonText32A (WND *wndPtr, WPARAM32 wParam, LPARAM lParam)
|
|
{
|
|
TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr(wndPtr);
|
|
INT32 nIndex, nStringIndex;
|
|
|
|
nIndex = TOOLBAR_GetButtonIndex (infoPtr, (INT32)wParam);
|
|
if (nIndex == -1)
|
|
return -1;
|
|
|
|
nStringIndex = infoPtr->buttons[nIndex].iString;
|
|
|
|
TRACE (toolbar, "index=%d stringIndex=%d\n", nIndex, nStringIndex);
|
|
|
|
if ((nStringIndex < 0) || (nStringIndex >= infoPtr->nNumStrings))
|
|
return -1;
|
|
|
|
if (lParam == 0) return -1;
|
|
|
|
lstrcpy32A ((LPSTR)lParam, (LPSTR)infoPtr->strings[nStringIndex]);
|
|
|
|
return lstrlen32A ((LPSTR)infoPtr->strings[nStringIndex]);
|
|
}
|
|
|
|
|
|
/* << TOOLBAR_GetButtonText32W >> */
|
|
/* << TOOLBAR_GetColorScheme >> */
|
|
|
|
|
|
static LRESULT
|
|
TOOLBAR_GetDisabledImageList (WND *wndPtr, WPARAM32 wParam, LPARAM lParam)
|
|
{
|
|
TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr(wndPtr);
|
|
|
|
if (wndPtr->dwStyle & TBSTYLE_FLAT)
|
|
return (LRESULT)infoPtr->himlDis;
|
|
else
|
|
return 0;
|
|
}
|
|
|
|
|
|
__inline__ static LRESULT
|
|
TOOLBAR_GetExtendedStyle (WND *wndPtr)
|
|
{
|
|
TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr(wndPtr);
|
|
|
|
return infoPtr->dwExStyle;
|
|
}
|
|
|
|
|
|
static LRESULT
|
|
TOOLBAR_GetHotImageList (WND *wndPtr, WPARAM32 wParam, LPARAM lParam)
|
|
{
|
|
TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr(wndPtr);
|
|
|
|
if (wndPtr->dwStyle & TBSTYLE_FLAT)
|
|
return (LRESULT)infoPtr->himlHot;
|
|
else
|
|
return 0;
|
|
}
|
|
|
|
|
|
/* << TOOLBAR_GetHotItem >> */
|
|
|
|
|
|
static LRESULT
|
|
TOOLBAR_GetImageList (WND *wndPtr, WPARAM32 wParam, LPARAM lParam)
|
|
{
|
|
TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr(wndPtr);
|
|
|
|
if (wndPtr->dwStyle & TBSTYLE_FLAT)
|
|
return (LRESULT)infoPtr->himlDef;
|
|
else
|
|
return 0;
|
|
}
|
|
|
|
|
|
/* << TOOLBAR_GetInsertMark >> */
|
|
/* << TOOLBAR_GetInsertMarkColor >> */
|
|
|
|
|
|
static LRESULT
|
|
TOOLBAR_GetItemRect (WND *wndPtr, WPARAM32 wParam, LPARAM lParam)
|
|
{
|
|
TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr(wndPtr);
|
|
TBUTTON_INFO *btnPtr;
|
|
LPRECT32 lpRect;
|
|
INT32 nIndex;
|
|
|
|
if (infoPtr == NULL) return FALSE;
|
|
nIndex = (INT32)wParam;
|
|
btnPtr = &infoPtr->buttons[nIndex];
|
|
if ((nIndex < 0) || (nIndex >= infoPtr->nNumButtons))
|
|
return FALSE;
|
|
lpRect = (LPRECT32)lParam;
|
|
if (lpRect == NULL) return FALSE;
|
|
if (btnPtr->fsState & TBSTATE_HIDDEN) return FALSE;
|
|
|
|
lpRect->left = btnPtr->rect.left;
|
|
lpRect->right = btnPtr->rect.right;
|
|
lpRect->bottom = btnPtr->rect.bottom;
|
|
lpRect->top = btnPtr->rect.top;
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
|
|
static LRESULT
|
|
TOOLBAR_GetMaxSize (WND *wndPtr, WPARAM32 wParam, LPARAM lParam)
|
|
{
|
|
TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr(wndPtr);
|
|
LPSIZE32 lpSize = (LPSIZE32)lParam;
|
|
|
|
if (lpSize == NULL)
|
|
return FALSE;
|
|
|
|
lpSize->cx = infoPtr->rcBound.right - infoPtr->rcBound.left;
|
|
lpSize->cy = infoPtr->rcBound.bottom - infoPtr->rcBound.top;
|
|
|
|
TRACE (toolbar, "maximum size %d x %d\n",
|
|
infoPtr->rcBound.right - infoPtr->rcBound.left,
|
|
infoPtr->rcBound.bottom - infoPtr->rcBound.top);
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
|
|
/* << TOOLBAR_GetObject >> */
|
|
/* << TOOLBAR_GetPadding >> */
|
|
|
|
|
|
static LRESULT
|
|
TOOLBAR_GetRect (WND *wndPtr, WPARAM32 wParam, LPARAM lParam)
|
|
{
|
|
TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr(wndPtr);
|
|
TBUTTON_INFO *btnPtr;
|
|
LPRECT32 lpRect;
|
|
INT32 nIndex;
|
|
|
|
if (infoPtr == NULL) return FALSE;
|
|
nIndex = (INT32)wParam;
|
|
btnPtr = &infoPtr->buttons[nIndex];
|
|
if ((nIndex < 0) || (nIndex >= infoPtr->nNumButtons))
|
|
return FALSE;
|
|
lpRect = (LPRECT32)lParam;
|
|
if (lpRect == NULL) return FALSE;
|
|
|
|
lpRect->left = btnPtr->rect.left;
|
|
lpRect->right = btnPtr->rect.right;
|
|
lpRect->bottom = btnPtr->rect.bottom;
|
|
lpRect->top = btnPtr->rect.top;
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
|
|
static LRESULT
|
|
TOOLBAR_GetRows (WND *wndPtr, WPARAM32 wParam, LPARAM lParam)
|
|
{
|
|
TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr(wndPtr);
|
|
|
|
if (wndPtr->dwStyle & TBSTYLE_WRAPABLE)
|
|
return infoPtr->nRows;
|
|
else
|
|
return 1;
|
|
}
|
|
|
|
|
|
static LRESULT
|
|
TOOLBAR_GetState (WND *wndPtr, WPARAM32 wParam, LPARAM lParam)
|
|
{
|
|
TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr(wndPtr);
|
|
INT32 nIndex;
|
|
|
|
nIndex = TOOLBAR_GetButtonIndex (infoPtr, (INT32)wParam);
|
|
if (nIndex == -1) return -1;
|
|
|
|
return infoPtr->buttons[nIndex].fsState;
|
|
}
|
|
|
|
|
|
static LRESULT
|
|
TOOLBAR_GetStyle (WND *wndPtr, WPARAM32 wParam, LPARAM lParam)
|
|
{
|
|
TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr(wndPtr);
|
|
INT32 nIndex;
|
|
|
|
nIndex = TOOLBAR_GetButtonIndex (infoPtr, (INT32)wParam);
|
|
if (nIndex == -1) return -1;
|
|
|
|
return infoPtr->buttons[nIndex].fsStyle;
|
|
}
|
|
|
|
|
|
static LRESULT
|
|
TOOLBAR_GetTextRows (WND *wndPtr, WPARAM32 wParam, LPARAM lParam)
|
|
{
|
|
TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr(wndPtr);
|
|
|
|
if (infoPtr == NULL)
|
|
return 0;
|
|
|
|
return infoPtr->nMaxTextRows;
|
|
}
|
|
|
|
|
|
static LRESULT
|
|
TOOLBAR_GetToolTips (WND *wndPtr, WPARAM32 wParam, LPARAM lParam)
|
|
{
|
|
TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr(wndPtr);
|
|
|
|
if (infoPtr == NULL) return 0;
|
|
return infoPtr->hwndToolTip;
|
|
}
|
|
|
|
|
|
static LRESULT
|
|
TOOLBAR_GetUnicodeFormat (WND *wndPtr, WPARAM32 wParam, LPARAM lParam)
|
|
{
|
|
TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr(wndPtr);
|
|
|
|
TRACE (toolbar, "%s hwnd=0x%04x stub!\n",
|
|
infoPtr->bUnicode ? "TRUE" : "FALSE", wndPtr->hwndSelf);
|
|
|
|
return infoPtr->bUnicode;
|
|
}
|
|
|
|
|
|
static LRESULT
|
|
TOOLBAR_HideButton (WND *wndPtr, WPARAM32 wParam, LPARAM lParam)
|
|
{
|
|
TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr(wndPtr);
|
|
TBUTTON_INFO *btnPtr;
|
|
INT32 nIndex;
|
|
|
|
nIndex = TOOLBAR_GetButtonIndex (infoPtr, (INT32)wParam);
|
|
if (nIndex == -1)
|
|
return FALSE;
|
|
|
|
btnPtr = &infoPtr->buttons[nIndex];
|
|
if (LOWORD(lParam) == FALSE)
|
|
btnPtr->fsState &= ~TBSTATE_HIDDEN;
|
|
else
|
|
btnPtr->fsState |= TBSTATE_HIDDEN;
|
|
|
|
TOOLBAR_CalcToolbar (wndPtr);
|
|
|
|
InvalidateRect32 (wndPtr->hwndSelf, NULL, TRUE);
|
|
UpdateWindow32 (wndPtr->hwndSelf);
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
|
|
__inline__ static LRESULT
|
|
TOOLBAR_HitTest (WND *wndPtr, WPARAM32 wParam, LPARAM lParam)
|
|
{
|
|
return TOOLBAR_InternalHitTest (wndPtr, (LPPOINT32)lParam);
|
|
}
|
|
|
|
|
|
static LRESULT
|
|
TOOLBAR_Indeterminate (WND *wndPtr, WPARAM32 wParam, LPARAM lParam)
|
|
{
|
|
TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr(wndPtr);
|
|
TBUTTON_INFO *btnPtr;
|
|
HDC32 hdc;
|
|
INT32 nIndex;
|
|
|
|
nIndex = TOOLBAR_GetButtonIndex (infoPtr, (INT32)wParam);
|
|
if (nIndex == -1)
|
|
return FALSE;
|
|
|
|
btnPtr = &infoPtr->buttons[nIndex];
|
|
if (LOWORD(lParam) == FALSE)
|
|
btnPtr->fsState &= ~TBSTATE_INDETERMINATE;
|
|
else
|
|
btnPtr->fsState |= TBSTATE_INDETERMINATE;
|
|
|
|
hdc = GetDC32 (wndPtr->hwndSelf);
|
|
TOOLBAR_DrawButton (wndPtr, btnPtr, hdc);
|
|
ReleaseDC32 (wndPtr->hwndSelf, hdc);
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
|
|
static LRESULT
|
|
TOOLBAR_InsertButton32A (WND *wndPtr, WPARAM32 wParam, LPARAM lParam)
|
|
{
|
|
TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr(wndPtr);
|
|
LPTBBUTTON lpTbb = (LPTBBUTTON)lParam;
|
|
INT32 nIndex = (INT32)wParam;
|
|
TBUTTON_INFO *oldButtons;
|
|
HDC32 hdc;
|
|
|
|
if (lpTbb == NULL) return FALSE;
|
|
if (nIndex < 0) return FALSE;
|
|
|
|
TRACE (toolbar, "inserting button index=%d\n", nIndex);
|
|
if (nIndex > infoPtr->nNumButtons) {
|
|
nIndex = infoPtr->nNumButtons;
|
|
TRACE (toolbar, "adjust index=%d\n", nIndex);
|
|
}
|
|
|
|
oldButtons = infoPtr->buttons;
|
|
infoPtr->nNumButtons++;
|
|
infoPtr->buttons = COMCTL32_Alloc (sizeof (TBUTTON_INFO) * infoPtr->nNumButtons);
|
|
/* pre insert copy */
|
|
if (nIndex > 0) {
|
|
memcpy (&infoPtr->buttons[0], &oldButtons[0],
|
|
nIndex * sizeof(TBUTTON_INFO));
|
|
}
|
|
|
|
/* insert new button */
|
|
infoPtr->buttons[nIndex].iBitmap = lpTbb->iBitmap;
|
|
infoPtr->buttons[nIndex].idCommand = lpTbb->idCommand;
|
|
infoPtr->buttons[nIndex].fsState = lpTbb->fsState;
|
|
infoPtr->buttons[nIndex].fsStyle = lpTbb->fsStyle;
|
|
infoPtr->buttons[nIndex].dwData = lpTbb->dwData;
|
|
infoPtr->buttons[nIndex].iString = lpTbb->iString;
|
|
|
|
if ((infoPtr->hwndToolTip) && !(lpTbb->fsStyle & TBSTYLE_SEP)) {
|
|
TTTOOLINFO32A ti;
|
|
|
|
ZeroMemory (&ti, sizeof(TTTOOLINFO32A));
|
|
ti.cbSize = sizeof (TTTOOLINFO32A);
|
|
ti.hwnd = wndPtr->hwndSelf;
|
|
ti.uId = lpTbb->idCommand;
|
|
ti.hinst = 0;
|
|
ti.lpszText = LPSTR_TEXTCALLBACK32A;
|
|
|
|
SendMessage32A (infoPtr->hwndToolTip, TTM_ADDTOOL32A,
|
|
0, (LPARAM)&ti);
|
|
}
|
|
|
|
/* post insert copy */
|
|
if (nIndex < infoPtr->nNumButtons - 1) {
|
|
memcpy (&infoPtr->buttons[nIndex+1], &oldButtons[nIndex],
|
|
(infoPtr->nNumButtons - nIndex - 1) * sizeof(TBUTTON_INFO));
|
|
}
|
|
|
|
COMCTL32_Free (oldButtons);
|
|
|
|
TOOLBAR_CalcToolbar (wndPtr);
|
|
|
|
hdc = GetDC32 (wndPtr->hwndSelf);
|
|
TOOLBAR_Refresh (wndPtr, hdc);
|
|
ReleaseDC32 (wndPtr->hwndSelf, hdc);
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
|
|
/* << TOOLBAR_InsertButton32W >> */
|
|
/* << TOOLBAR_InsertMarkHitTest >> */
|
|
|
|
|
|
static LRESULT
|
|
TOOLBAR_IsButtonChecked (WND *wndPtr, WPARAM32 wParam, LPARAM lParam)
|
|
{
|
|
TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr(wndPtr);
|
|
INT32 nIndex;
|
|
|
|
nIndex = TOOLBAR_GetButtonIndex (infoPtr, (INT32)wParam);
|
|
if (nIndex == -1)
|
|
return FALSE;
|
|
|
|
return (infoPtr->buttons[nIndex].fsState & TBSTATE_CHECKED);
|
|
}
|
|
|
|
|
|
static LRESULT
|
|
TOOLBAR_IsButtonEnabled (WND *wndPtr, WPARAM32 wParam, LPARAM lParam)
|
|
{
|
|
TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr(wndPtr);
|
|
INT32 nIndex;
|
|
|
|
nIndex = TOOLBAR_GetButtonIndex (infoPtr, (INT32)wParam);
|
|
if (nIndex == -1)
|
|
return FALSE;
|
|
|
|
return (infoPtr->buttons[nIndex].fsState & TBSTATE_ENABLED);
|
|
}
|
|
|
|
|
|
static LRESULT
|
|
TOOLBAR_IsButtonHidden (WND *wndPtr, WPARAM32 wParam, LPARAM lParam)
|
|
{
|
|
TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr(wndPtr);
|
|
INT32 nIndex;
|
|
|
|
nIndex = TOOLBAR_GetButtonIndex (infoPtr, (INT32)wParam);
|
|
if (nIndex == -1)
|
|
return FALSE;
|
|
|
|
return (infoPtr->buttons[nIndex].fsState & TBSTATE_HIDDEN);
|
|
}
|
|
|
|
|
|
static LRESULT
|
|
TOOLBAR_IsButtonHighlighted (WND *wndPtr, WPARAM32 wParam, LPARAM lParam)
|
|
{
|
|
TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr(wndPtr);
|
|
INT32 nIndex;
|
|
|
|
nIndex = TOOLBAR_GetButtonIndex (infoPtr, (INT32)wParam);
|
|
if (nIndex == -1)
|
|
return FALSE;
|
|
|
|
return (infoPtr->buttons[nIndex].fsState & TBSTATE_MARKED);
|
|
}
|
|
|
|
|
|
static LRESULT
|
|
TOOLBAR_IsButtonIndeterminate (WND *wndPtr, WPARAM32 wParam, LPARAM lParam)
|
|
{
|
|
TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr(wndPtr);
|
|
INT32 nIndex;
|
|
|
|
nIndex = TOOLBAR_GetButtonIndex (infoPtr, (INT32)wParam);
|
|
if (nIndex == -1)
|
|
return FALSE;
|
|
|
|
return (infoPtr->buttons[nIndex].fsState & TBSTATE_INDETERMINATE);
|
|
}
|
|
|
|
|
|
static LRESULT
|
|
TOOLBAR_IsButtonPressed (WND *wndPtr, WPARAM32 wParam, LPARAM lParam)
|
|
{
|
|
TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr(wndPtr);
|
|
INT32 nIndex;
|
|
|
|
nIndex = TOOLBAR_GetButtonIndex (infoPtr, (INT32)wParam);
|
|
if (nIndex == -1)
|
|
return FALSE;
|
|
|
|
return (infoPtr->buttons[nIndex].fsState & TBSTATE_PRESSED);
|
|
}
|
|
|
|
|
|
/* << TOOLBAR_LoadImages >> */
|
|
/* << TOOLBAR_MapAccelerator >> */
|
|
/* << TOOLBAR_MarkButton >> */
|
|
/* << TOOLBAR_MoveButton >> */
|
|
|
|
|
|
static LRESULT
|
|
TOOLBAR_PressButton (WND *wndPtr, WPARAM32 wParam, LPARAM lParam)
|
|
{
|
|
TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr(wndPtr);
|
|
TBUTTON_INFO *btnPtr;
|
|
HDC32 hdc;
|
|
INT32 nIndex;
|
|
|
|
nIndex = TOOLBAR_GetButtonIndex (infoPtr, (INT32)wParam);
|
|
if (nIndex == -1)
|
|
return FALSE;
|
|
|
|
btnPtr = &infoPtr->buttons[nIndex];
|
|
if (LOWORD(lParam) == FALSE)
|
|
btnPtr->fsState &= ~TBSTATE_PRESSED;
|
|
else
|
|
btnPtr->fsState |= TBSTATE_PRESSED;
|
|
|
|
hdc = GetDC32 (wndPtr->hwndSelf);
|
|
TOOLBAR_DrawButton (wndPtr, btnPtr, hdc);
|
|
ReleaseDC32 (wndPtr->hwndSelf, hdc);
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
|
|
/* << TOOLBAR_ReplaceBitmap >> */
|
|
|
|
|
|
static LRESULT
|
|
TOOLBAR_SaveRestore32A (WND *wndPtr, WPARAM32 wParam, LPARAM lParam)
|
|
{
|
|
#if 0
|
|
TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr(wndPtr);
|
|
LPTBSAVEPARAMS32A lpSave = (LPTBSAVEPARAMS32A)lParam;
|
|
|
|
if (lpSave == NULL) return 0;
|
|
|
|
if ((BOOL32)wParam) {
|
|
/* save toolbar information */
|
|
FIXME (toolbar, "save to \"%s\" \"%s\"\n",
|
|
lpSave->pszSubKey, lpSave->pszValueName);
|
|
|
|
|
|
}
|
|
else {
|
|
/* restore toolbar information */
|
|
|
|
FIXME (toolbar, "restore from \"%s\" \"%s\"\n",
|
|
lpSave->pszSubKey, lpSave->pszValueName);
|
|
|
|
|
|
}
|
|
#endif
|
|
|
|
return 0;
|
|
}
|
|
|
|
|
|
/* << TOOLBAR_SaveRestore32W >> */
|
|
/* << TOOLBAR_SetAnchorHighlight >> */
|
|
|
|
|
|
static LRESULT
|
|
TOOLBAR_SetBitmapSize (WND *wndPtr, WPARAM32 wParam, LPARAM lParam)
|
|
{
|
|
TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr(wndPtr);
|
|
|
|
if ((LOWORD(lParam) <= 0) || (HIWORD(lParam)<=0))
|
|
return FALSE;
|
|
|
|
infoPtr->nBitmapWidth = (INT32)LOWORD(lParam);
|
|
infoPtr->nBitmapHeight = (INT32)HIWORD(lParam);
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
|
|
static LRESULT
|
|
TOOLBAR_SetButtonInfo32A (WND *wndPtr, WPARAM32 wParam, LPARAM lParam)
|
|
{
|
|
TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr(wndPtr);
|
|
LPTBBUTTONINFO32A lptbbi = (LPTBBUTTONINFO32A)lParam;
|
|
TBUTTON_INFO *btnPtr;
|
|
INT32 nIndex;
|
|
|
|
if (lptbbi == NULL)
|
|
return FALSE;
|
|
if (lptbbi->cbSize < sizeof(LPTBBUTTONINFO32A))
|
|
return FALSE;
|
|
|
|
nIndex = TOOLBAR_GetButtonIndex (infoPtr, (INT32)wParam);
|
|
if (nIndex == -1)
|
|
return FALSE;
|
|
|
|
btnPtr = &infoPtr->buttons[nIndex];
|
|
if (lptbbi->dwMask & TBIF_COMMAND)
|
|
btnPtr->idCommand = lptbbi->idCommand;
|
|
if (lptbbi->dwMask & TBIF_IMAGE)
|
|
btnPtr->iBitmap = lptbbi->iImage;
|
|
if (lptbbi->dwMask & TBIF_LPARAM)
|
|
btnPtr->dwData = lptbbi->lParam;
|
|
/* if (lptbbi->dwMask & TBIF_SIZE) */
|
|
/* btnPtr->cx = lptbbi->cx; */
|
|
if (lptbbi->dwMask & TBIF_STATE)
|
|
btnPtr->fsState = lptbbi->fsState;
|
|
if (lptbbi->dwMask & TBIF_STYLE)
|
|
btnPtr->fsStyle = lptbbi->fsStyle;
|
|
|
|
if (lptbbi->dwMask & TBIF_TEXT) {
|
|
if ((btnPtr->iString >= 0) ||
|
|
(btnPtr->iString < infoPtr->nNumStrings)) {
|
|
#if 0
|
|
CHAR **lpString = &infoPtr->strings[btnPtr->iString];
|
|
INT32 len = lstrlen32A (lptbbi->pszText);
|
|
*lpString = COMCTL32_ReAlloc (lpString, sizeof(char)*(len+1));
|
|
#endif
|
|
|
|
/* this is the ultimate sollution */
|
|
/* Str_SetPtrA (&infoPtr->strings[btnPtr->iString], lptbbi->pszText); */
|
|
}
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
|
|
/* << TOOLBAR_SetButtonInfo32W >> */
|
|
|
|
|
|
static LRESULT
|
|
TOOLBAR_SetButtonSize (WND *wndPtr, WPARAM32 wParam, LPARAM lParam)
|
|
{
|
|
TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr(wndPtr);
|
|
|
|
if ((LOWORD(lParam) <= 0) || (HIWORD(lParam)<=0))
|
|
return FALSE;
|
|
|
|
infoPtr->nButtonWidth = (INT32)LOWORD(lParam);
|
|
infoPtr->nButtonHeight = (INT32)HIWORD(lParam);
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
|
|
static LRESULT
|
|
TOOLBAR_SetButtonWidth (WND *wndPtr, WPARAM32 wParam, LPARAM lParam)
|
|
{
|
|
TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr(wndPtr);
|
|
|
|
if (infoPtr == NULL)
|
|
return FALSE;
|
|
|
|
infoPtr->cxMin = (INT32)LOWORD(lParam);
|
|
infoPtr->cxMax = (INT32)HIWORD(lParam);
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
|
|
static LRESULT
|
|
TOOLBAR_SetCmdId (WND *wndPtr, WPARAM32 wParam, LPARAM lParam)
|
|
{
|
|
TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr(wndPtr);
|
|
INT32 nIndex = (INT32)wParam;
|
|
|
|
if ((nIndex < 0) || (nIndex >= infoPtr->nNumButtons))
|
|
return FALSE;
|
|
|
|
infoPtr->buttons[nIndex].idCommand = (INT32)lParam;
|
|
|
|
if (infoPtr->hwndToolTip) {
|
|
|
|
FIXME (toolbar, "change tool tip!\n");
|
|
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
|
|
/* << TOOLBAR_SetColorScheme >> */
|
|
|
|
|
|
static LRESULT
|
|
TOOLBAR_SetDisabledImageList (WND *wndPtr, WPARAM32 wParam, LPARAM lParam)
|
|
{
|
|
TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr(wndPtr);
|
|
HIMAGELIST himlTemp;
|
|
|
|
if (!(wndPtr->dwStyle & TBSTYLE_FLAT))
|
|
return 0;
|
|
|
|
himlTemp = infoPtr->himlDis;
|
|
infoPtr->himlDis = (HIMAGELIST)lParam;
|
|
|
|
/* FIXME: redraw ? */
|
|
|
|
return (LRESULT)himlTemp;
|
|
}
|
|
|
|
|
|
static LRESULT
|
|
TOOLBAR_SetDrawTextFlags (WND *wndPtr, WPARAM32 wParam, LPARAM lParam)
|
|
{
|
|
TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr(wndPtr);
|
|
DWORD dwTemp;
|
|
|
|
dwTemp = infoPtr->dwDTFlags;
|
|
infoPtr->dwDTFlags =
|
|
(infoPtr->dwDTFlags & (DWORD)wParam) | (DWORD)lParam;
|
|
|
|
return (LRESULT)dwTemp;
|
|
}
|
|
|
|
|
|
static LRESULT
|
|
TOOLBAR_SetExtendedStyle (WND *wndPtr, WPARAM32 wParam, LPARAM lParam)
|
|
{
|
|
TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr(wndPtr);
|
|
DWORD dwTemp;
|
|
|
|
dwTemp = infoPtr->dwExStyle;
|
|
infoPtr->dwExStyle = (DWORD)lParam;
|
|
|
|
return (LRESULT)dwTemp;
|
|
}
|
|
|
|
|
|
static LRESULT
|
|
TOOLBAR_SetHotImageList (WND *wndPtr, WPARAM32 wParam, LPARAM lParam)
|
|
{
|
|
TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr(wndPtr);
|
|
HIMAGELIST himlTemp;
|
|
|
|
if (!(wndPtr->dwStyle & TBSTYLE_FLAT))
|
|
return 0;
|
|
|
|
himlTemp = infoPtr->himlHot;
|
|
infoPtr->himlHot = (HIMAGELIST)lParam;
|
|
|
|
/* FIXME: redraw ? */
|
|
|
|
return (LRESULT)himlTemp;
|
|
}
|
|
|
|
|
|
/* << TOOLBAR_SetHotItem >> */
|
|
|
|
|
|
static LRESULT
|
|
TOOLBAR_SetImageList (WND *wndPtr, WPARAM32 wParam, LPARAM lParam)
|
|
{
|
|
TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr(wndPtr);
|
|
HIMAGELIST himlTemp;
|
|
|
|
if (!(wndPtr->dwStyle & TBSTYLE_FLAT))
|
|
return 0;
|
|
|
|
himlTemp = infoPtr->himlDef;
|
|
infoPtr->himlDef = (HIMAGELIST)lParam;
|
|
|
|
/* FIXME: redraw ? */
|
|
|
|
return (LRESULT)himlTemp;
|
|
}
|
|
|
|
|
|
static LRESULT
|
|
TOOLBAR_SetIndent (WND *wndPtr, WPARAM32 wParam, LPARAM lParam)
|
|
{
|
|
TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr(wndPtr);
|
|
HDC32 hdc;
|
|
|
|
infoPtr->nIndent = (INT32)wParam;
|
|
TOOLBAR_CalcToolbar (wndPtr);
|
|
hdc = GetDC32 (wndPtr->hwndSelf);
|
|
TOOLBAR_Refresh (wndPtr, hdc);
|
|
ReleaseDC32 (wndPtr->hwndSelf, hdc);
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
|
|
/* << TOOLBAR_SetInsertMark >> */
|
|
|
|
|
|
static LRESULT
|
|
TOOLBAR_SetInsertMarkColor (WND *wndPtr, WPARAM32 wParam, LPARAM lParam)
|
|
{
|
|
TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr(wndPtr);
|
|
|
|
infoPtr->clrInsertMark = (COLORREF)lParam;
|
|
|
|
/* FIXME : redraw ??*/
|
|
|
|
return 0;
|
|
}
|
|
|
|
|
|
static LRESULT
|
|
TOOLBAR_SetMaxTextRows (WND *wndPtr, WPARAM32 wParam, LPARAM lParam)
|
|
{
|
|
TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr(wndPtr);
|
|
|
|
if (infoPtr == NULL)
|
|
return FALSE;
|
|
|
|
infoPtr->nMaxTextRows = (INT32)wParam;
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
|
|
/* << TOOLBAR_SetPadding >> */
|
|
|
|
|
|
static LRESULT
|
|
TOOLBAR_SetParent (WND *wndPtr, WPARAM32 wParam, LPARAM lParam)
|
|
{
|
|
TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr(wndPtr);
|
|
HWND32 hwndOldNotify;
|
|
|
|
if (infoPtr == NULL) return 0;
|
|
hwndOldNotify = infoPtr->hwndNotify;
|
|
infoPtr->hwndNotify = (HWND32)wParam;
|
|
|
|
return hwndOldNotify;
|
|
}
|
|
|
|
|
|
static LRESULT
|
|
TOOLBAR_SetRows (WND *wndPtr, WPARAM32 wParam, LPARAM lParam)
|
|
{
|
|
TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr(wndPtr);
|
|
LPRECT32 lprc = (LPRECT32)lParam;
|
|
HDC32 hdc;
|
|
|
|
if (LOWORD(wParam) > 1) {
|
|
|
|
FIXME (toolbar, "multiple rows not supported!\n");
|
|
|
|
}
|
|
|
|
/* recalculate toolbar */
|
|
TOOLBAR_CalcToolbar (wndPtr);
|
|
|
|
/* return bounding rectangle */
|
|
if (lprc) {
|
|
lprc->left = infoPtr->rcBound.left;
|
|
lprc->right = infoPtr->rcBound.right;
|
|
lprc->top = infoPtr->rcBound.top;
|
|
lprc->bottom = infoPtr->rcBound.bottom;
|
|
}
|
|
|
|
/* repaint toolbar */
|
|
hdc = GetDC32 (wndPtr->hwndSelf);
|
|
TOOLBAR_Refresh (wndPtr, hdc);
|
|
ReleaseDC32 (wndPtr->hwndSelf, hdc);
|
|
|
|
return 0;
|
|
}
|
|
|
|
|
|
static LRESULT
|
|
TOOLBAR_SetState (WND *wndPtr, WPARAM32 wParam, LPARAM lParam)
|
|
{
|
|
TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr(wndPtr);
|
|
TBUTTON_INFO *btnPtr;
|
|
HDC32 hdc;
|
|
INT32 nIndex;
|
|
|
|
nIndex = TOOLBAR_GetButtonIndex (infoPtr, (INT32)wParam);
|
|
if (nIndex == -1)
|
|
return FALSE;
|
|
|
|
btnPtr = &infoPtr->buttons[nIndex];
|
|
btnPtr->fsState = LOWORD(lParam);
|
|
|
|
hdc = GetDC32 (wndPtr->hwndSelf);
|
|
TOOLBAR_DrawButton (wndPtr, btnPtr, hdc);
|
|
ReleaseDC32 (wndPtr->hwndSelf, hdc);
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
|
|
static LRESULT
|
|
TOOLBAR_SetStyle (WND *wndPtr, WPARAM32 wParam, LPARAM lParam)
|
|
{
|
|
TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr(wndPtr);
|
|
TBUTTON_INFO *btnPtr;
|
|
HDC32 hdc;
|
|
INT32 nIndex;
|
|
|
|
nIndex = TOOLBAR_GetButtonIndex (infoPtr, (INT32)wParam);
|
|
if (nIndex == -1)
|
|
return FALSE;
|
|
|
|
btnPtr = &infoPtr->buttons[nIndex];
|
|
btnPtr->fsStyle = LOWORD(lParam);
|
|
|
|
hdc = GetDC32 (wndPtr->hwndSelf);
|
|
TOOLBAR_DrawButton (wndPtr, btnPtr, hdc);
|
|
ReleaseDC32 (wndPtr->hwndSelf, hdc);
|
|
|
|
if (infoPtr->hwndToolTip) {
|
|
|
|
FIXME (toolbar, "change tool tip!\n");
|
|
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
|
|
__inline__ static LRESULT
|
|
TOOLBAR_SetToolTips (WND *wndPtr, WPARAM32 wParam, LPARAM lParam)
|
|
{
|
|
TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr(wndPtr);
|
|
|
|
if (infoPtr == NULL) return 0;
|
|
infoPtr->hwndToolTip = (HWND32)wParam;
|
|
return 0;
|
|
}
|
|
|
|
|
|
static LRESULT
|
|
TOOLBAR_SetUnicodeFormat (WND *wndPtr, WPARAM32 wParam, LPARAM lParam)
|
|
{
|
|
TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr(wndPtr);
|
|
BOOL32 bTemp;
|
|
|
|
TRACE (toolbar, "%s hwnd=0x%04x stub!\n",
|
|
((BOOL32)wParam) ? "TRUE" : "FALSE", wndPtr->hwndSelf);
|
|
|
|
bTemp = infoPtr->bUnicode;
|
|
infoPtr->bUnicode = (BOOL32)wParam;
|
|
|
|
return bTemp;
|
|
}
|
|
|
|
|
|
static LRESULT
|
|
TOOLBAR_Create (WND *wndPtr, WPARAM32 wParam, LPARAM lParam)
|
|
{
|
|
TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr(wndPtr);
|
|
LOGFONT32A logFont;
|
|
|
|
/* initialize info structure */
|
|
infoPtr->nButtonHeight = 22;
|
|
infoPtr->nButtonWidth = 23;
|
|
infoPtr->nBitmapHeight = 15;
|
|
infoPtr->nBitmapWidth = 16;
|
|
|
|
infoPtr->nHeight = infoPtr->nButtonHeight + TOP_BORDER + BOTTOM_BORDER;
|
|
infoPtr->nRows = 1;
|
|
infoPtr->nMaxTextRows = 1;
|
|
infoPtr->cxMin = -1;
|
|
infoPtr->cxMax = -1;
|
|
|
|
infoPtr->bCaptured = FALSE;
|
|
infoPtr->bUnicode = IsWindowUnicode (wndPtr->hwndSelf);
|
|
infoPtr->nButtonDown = -1;
|
|
infoPtr->nOldHit = -1;
|
|
|
|
infoPtr->hwndNotify = GetParent32 (wndPtr->hwndSelf);
|
|
infoPtr->bTransparent = (wndPtr->dwStyle & TBSTYLE_FLAT);
|
|
infoPtr->nHotItem = -1;
|
|
infoPtr->dwDTFlags = DT_CENTER;
|
|
|
|
SystemParametersInfo32A (SPI_GETICONTITLELOGFONT, 0, &logFont, 0);
|
|
infoPtr->hFont = CreateFontIndirect32A (&logFont);
|
|
|
|
if (wndPtr->dwStyle & TBSTYLE_TOOLTIPS) {
|
|
/* Create tooltip control */
|
|
infoPtr->hwndToolTip =
|
|
CreateWindowEx32A (0, TOOLTIPS_CLASS32A, NULL, 0,
|
|
CW_USEDEFAULT32, CW_USEDEFAULT32,
|
|
CW_USEDEFAULT32, CW_USEDEFAULT32,
|
|
wndPtr->hwndSelf, 0, 0, 0);
|
|
|
|
/* Send NM_TOOLTIPSCREATED notification */
|
|
if (infoPtr->hwndToolTip) {
|
|
NMTOOLTIPSCREATED nmttc;
|
|
|
|
nmttc.hdr.hwndFrom = wndPtr->hwndSelf;
|
|
nmttc.hdr.idFrom = wndPtr->wIDmenu;
|
|
nmttc.hdr.code = NM_TOOLTIPSCREATED;
|
|
nmttc.hwndToolTips = infoPtr->hwndToolTip;
|
|
|
|
SendMessage32A (infoPtr->hwndNotify, WM_NOTIFY,
|
|
(WPARAM32)wndPtr->wIDmenu, (LPARAM)&nmttc);
|
|
}
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
|
|
static LRESULT
|
|
TOOLBAR_Destroy (WND *wndPtr, WPARAM32 wParam, LPARAM lParam)
|
|
{
|
|
TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr(wndPtr);
|
|
|
|
/* delete tooltip control */
|
|
if (infoPtr->hwndToolTip)
|
|
DestroyWindow32 (infoPtr->hwndToolTip);
|
|
|
|
/* delete button data */
|
|
if (infoPtr->buttons)
|
|
COMCTL32_Free (infoPtr->buttons);
|
|
|
|
/* delete strings */
|
|
if (infoPtr->strings) {
|
|
INT32 i;
|
|
for (i = 0; i < infoPtr->nNumStrings; i++)
|
|
if (infoPtr->strings[i])
|
|
COMCTL32_Free (infoPtr->strings[i]);
|
|
|
|
COMCTL32_Free (infoPtr->strings);
|
|
}
|
|
|
|
/* destroy default image list */
|
|
if (infoPtr->himlDef)
|
|
ImageList_Destroy (infoPtr->himlDef);
|
|
|
|
/* destroy disabled image list */
|
|
if (infoPtr->himlDis)
|
|
ImageList_Destroy (infoPtr->himlDis);
|
|
|
|
/* destroy hot image list */
|
|
if (infoPtr->himlHot)
|
|
ImageList_Destroy (infoPtr->himlHot);
|
|
|
|
/* delete default font */
|
|
if (infoPtr->hFont)
|
|
DeleteObject32 (infoPtr->hFont);
|
|
|
|
/* free toolbar info data */
|
|
COMCTL32_Free (infoPtr);
|
|
|
|
return 0;
|
|
}
|
|
|
|
|
|
static LRESULT
|
|
TOOLBAR_EraseBackground (WND *wndPtr, WPARAM32 wParam, LPARAM lParam)
|
|
{
|
|
TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr(wndPtr);
|
|
|
|
if (infoPtr->bTransparent)
|
|
return SendMessage32A (GetParent32 (wndPtr->hwndSelf), WM_ERASEBKGND,
|
|
wParam, lParam);
|
|
|
|
return DefWindowProc32A (wndPtr->hwndSelf, WM_ERASEBKGND, wParam, lParam);
|
|
}
|
|
|
|
|
|
static LRESULT
|
|
TOOLBAR_LButtonDblClk (WND *wndPtr, WPARAM32 wParam, LPARAM lParam)
|
|
{
|
|
TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr(wndPtr);
|
|
TBUTTON_INFO *btnPtr;
|
|
POINT32 pt;
|
|
INT32 nHit;
|
|
HDC32 hdc;
|
|
|
|
pt.x = (INT32)LOWORD(lParam);
|
|
pt.y = (INT32)HIWORD(lParam);
|
|
nHit = TOOLBAR_InternalHitTest (wndPtr, &pt);
|
|
|
|
if (nHit >= 0) {
|
|
btnPtr = &infoPtr->buttons[nHit];
|
|
if (!(btnPtr->fsState & TBSTATE_ENABLED))
|
|
return 0;
|
|
SetCapture32 (wndPtr->hwndSelf);
|
|
infoPtr->bCaptured = TRUE;
|
|
infoPtr->nButtonDown = nHit;
|
|
|
|
btnPtr->fsState |= TBSTATE_PRESSED;
|
|
|
|
hdc = GetDC32 (wndPtr->hwndSelf);
|
|
TOOLBAR_DrawButton (wndPtr, btnPtr, hdc);
|
|
ReleaseDC32 (wndPtr->hwndSelf, hdc);
|
|
}
|
|
else if (wndPtr->dwStyle & CCS_ADJUSTABLE)
|
|
TOOLBAR_Customize (wndPtr);
|
|
|
|
return 0;
|
|
}
|
|
|
|
|
|
static LRESULT
|
|
TOOLBAR_LButtonDown (WND *wndPtr, WPARAM32 wParam, LPARAM lParam)
|
|
{
|
|
TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr(wndPtr);
|
|
TBUTTON_INFO *btnPtr;
|
|
POINT32 pt;
|
|
INT32 nHit;
|
|
HDC32 hdc;
|
|
|
|
if (infoPtr->hwndToolTip)
|
|
TOOLBAR_RelayEvent (infoPtr->hwndToolTip, wndPtr->hwndSelf,
|
|
WM_LBUTTONDOWN, wParam, lParam);
|
|
|
|
pt.x = (INT32)LOWORD(lParam);
|
|
pt.y = (INT32)HIWORD(lParam);
|
|
nHit = TOOLBAR_InternalHitTest (wndPtr, &pt);
|
|
|
|
if (nHit >= 0) {
|
|
btnPtr = &infoPtr->buttons[nHit];
|
|
if (!(btnPtr->fsState & TBSTATE_ENABLED))
|
|
return 0;
|
|
|
|
SetCapture32 (wndPtr->hwndSelf);
|
|
infoPtr->bCaptured = TRUE;
|
|
infoPtr->nButtonDown = nHit;
|
|
infoPtr->nOldHit = nHit;
|
|
|
|
btnPtr->fsState |= TBSTATE_PRESSED;
|
|
|
|
hdc = GetDC32 (wndPtr->hwndSelf);
|
|
TOOLBAR_DrawButton (wndPtr, btnPtr, hdc);
|
|
ReleaseDC32 (wndPtr->hwndSelf, hdc);
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
|
|
static LRESULT
|
|
TOOLBAR_LButtonUp (WND *wndPtr, WPARAM32 wParam, LPARAM lParam)
|
|
{
|
|
TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr(wndPtr);
|
|
TBUTTON_INFO *btnPtr;
|
|
POINT32 pt;
|
|
INT32 nHit;
|
|
INT32 nOldIndex = -1;
|
|
HDC32 hdc;
|
|
BOOL32 bSendMessage = TRUE;
|
|
|
|
if (infoPtr->hwndToolTip)
|
|
TOOLBAR_RelayEvent (infoPtr->hwndToolTip, wndPtr->hwndSelf,
|
|
WM_LBUTTONUP, wParam, lParam);
|
|
|
|
pt.x = (INT32)LOWORD(lParam);
|
|
pt.y = (INT32)HIWORD(lParam);
|
|
nHit = TOOLBAR_InternalHitTest (wndPtr, &pt);
|
|
|
|
if ((infoPtr->bCaptured) && (infoPtr->nButtonDown >= 0)) {
|
|
infoPtr->bCaptured = FALSE;
|
|
ReleaseCapture ();
|
|
btnPtr = &infoPtr->buttons[infoPtr->nButtonDown];
|
|
btnPtr->fsState &= ~TBSTATE_PRESSED;
|
|
|
|
if (nHit == infoPtr->nButtonDown) {
|
|
if (btnPtr->fsStyle & TBSTYLE_CHECK) {
|
|
if (btnPtr->fsStyle & TBSTYLE_GROUP) {
|
|
nOldIndex = TOOLBAR_GetCheckedGroupButtonIndex (infoPtr,
|
|
infoPtr->nButtonDown);
|
|
if (nOldIndex == infoPtr->nButtonDown)
|
|
bSendMessage = FALSE;
|
|
if ((nOldIndex != infoPtr->nButtonDown) &&
|
|
(nOldIndex != -1))
|
|
infoPtr->buttons[nOldIndex].fsState &= ~TBSTATE_CHECKED;
|
|
btnPtr->fsState |= TBSTATE_CHECKED;
|
|
}
|
|
else {
|
|
if (btnPtr->fsState & TBSTATE_CHECKED)
|
|
btnPtr->fsState &= ~TBSTATE_CHECKED;
|
|
else
|
|
btnPtr->fsState |= TBSTATE_CHECKED;
|
|
}
|
|
}
|
|
}
|
|
else
|
|
bSendMessage = FALSE;
|
|
|
|
hdc = GetDC32 (wndPtr->hwndSelf);
|
|
if (nOldIndex != -1)
|
|
TOOLBAR_DrawButton (wndPtr, &infoPtr->buttons[nOldIndex], hdc);
|
|
TOOLBAR_DrawButton (wndPtr, btnPtr, hdc);
|
|
ReleaseDC32 (wndPtr->hwndSelf, hdc);
|
|
|
|
if (bSendMessage)
|
|
SendMessage32A (infoPtr->hwndNotify, WM_COMMAND,
|
|
MAKEWPARAM(btnPtr->idCommand, 0),
|
|
(LPARAM)wndPtr->hwndSelf);
|
|
|
|
infoPtr->nButtonDown = -1;
|
|
infoPtr->nOldHit = -1;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
|
|
static LRESULT
|
|
TOOLBAR_MouseMove (WND *wndPtr, WPARAM32 wParam, LPARAM lParam)
|
|
{
|
|
TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr(wndPtr);
|
|
TBUTTON_INFO *btnPtr;
|
|
POINT32 pt;
|
|
INT32 nHit;
|
|
HDC32 hdc;
|
|
|
|
if (infoPtr->hwndToolTip)
|
|
TOOLBAR_RelayEvent (infoPtr->hwndToolTip, wndPtr->hwndSelf,
|
|
WM_MOUSEMOVE, wParam, lParam);
|
|
|
|
pt.x = (INT32)LOWORD(lParam);
|
|
pt.y = (INT32)HIWORD(lParam);
|
|
nHit = TOOLBAR_InternalHitTest (wndPtr, &pt);
|
|
|
|
if (infoPtr->bCaptured) {
|
|
if (infoPtr->nOldHit != nHit) {
|
|
btnPtr = &infoPtr->buttons[infoPtr->nButtonDown];
|
|
if (infoPtr->nOldHit == infoPtr->nButtonDown) {
|
|
btnPtr->fsState &= ~TBSTATE_PRESSED;
|
|
hdc = GetDC32 (wndPtr->hwndSelf);
|
|
TOOLBAR_DrawButton (wndPtr, btnPtr, hdc);
|
|
ReleaseDC32 (wndPtr->hwndSelf, hdc);
|
|
}
|
|
else if (nHit == infoPtr->nButtonDown) {
|
|
btnPtr->fsState |= TBSTATE_PRESSED;
|
|
hdc = GetDC32 (wndPtr->hwndSelf);
|
|
TOOLBAR_DrawButton (wndPtr, btnPtr, hdc);
|
|
ReleaseDC32 (wndPtr->hwndSelf, hdc);
|
|
}
|
|
}
|
|
infoPtr->nOldHit = nHit;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
|
|
__inline__ static LRESULT
|
|
TOOLBAR_NCActivate (WND *wndPtr, WPARAM32 wParam, LPARAM lParam)
|
|
{
|
|
/* if (wndPtr->dwStyle & CCS_NODIVIDER) */
|
|
return DefWindowProc32A (wndPtr->hwndSelf, WM_NCACTIVATE,
|
|
wParam, lParam);
|
|
/* else */
|
|
/* return TOOLBAR_NCPaint (wndPtr, wParam, lParam); */
|
|
}
|
|
|
|
|
|
__inline__ static LRESULT
|
|
TOOLBAR_NCCalcSize (WND *wndPtr, WPARAM32 wParam, LPARAM lParam)
|
|
{
|
|
if (!(wndPtr->dwStyle & CCS_NODIVIDER))
|
|
((LPRECT32)lParam)->top += sysMetrics[SM_CYEDGE];
|
|
|
|
return DefWindowProc32A (wndPtr->hwndSelf, WM_NCCALCSIZE, wParam, lParam);
|
|
}
|
|
|
|
|
|
static LRESULT
|
|
TOOLBAR_NCCreate (WND *wndPtr, WPARAM32 wParam, LPARAM lParam)
|
|
{
|
|
TOOLBAR_INFO *infoPtr;
|
|
|
|
/* allocate memory for info structure */
|
|
infoPtr = (TOOLBAR_INFO *)COMCTL32_Alloc (sizeof(TOOLBAR_INFO));
|
|
wndPtr->wExtra[0] = (DWORD)infoPtr;
|
|
|
|
if (infoPtr == NULL) {
|
|
ERR (toolbar, "could not allocate info memory!\n");
|
|
return 0;
|
|
}
|
|
|
|
if ((TOOLBAR_INFO*)wndPtr->wExtra[0] != infoPtr) {
|
|
ERR (toolbar, "pointer assignment error!\n");
|
|
return 0;
|
|
}
|
|
|
|
/* paranoid!! */
|
|
infoPtr->dwStructSize = sizeof(TBBUTTON);
|
|
|
|
/* fix instance handle, if the toolbar was created by CreateToolbarEx() */
|
|
if (!wndPtr->hInstance)
|
|
wndPtr->hInstance = wndPtr->parent->hInstance;
|
|
|
|
return DefWindowProc32A (wndPtr->hwndSelf, WM_NCCREATE, wParam, lParam);
|
|
}
|
|
|
|
|
|
static LRESULT
|
|
TOOLBAR_NCPaint (WND *wndPtr, WPARAM32 wParam, LPARAM lParam)
|
|
{
|
|
HWND32 hwnd = wndPtr->hwndSelf;
|
|
HDC32 hdc;
|
|
|
|
if ( wndPtr->dwStyle & WS_MINIMIZE ||
|
|
!WIN_IsWindowDrawable( wndPtr, 0 )) return 0; /* Nothing to do */
|
|
|
|
DefWindowProc32A (hwnd, WM_NCPAINT, wParam, lParam);
|
|
|
|
if (!(hdc = GetDCEx32( hwnd, 0, DCX_USESTYLE | DCX_WINDOW ))) return 0;
|
|
|
|
if (ExcludeVisRect( hdc, wndPtr->rectClient.left-wndPtr->rectWindow.left,
|
|
wndPtr->rectClient.top-wndPtr->rectWindow.top,
|
|
wndPtr->rectClient.right-wndPtr->rectWindow.left,
|
|
wndPtr->rectClient.bottom-wndPtr->rectWindow.top )
|
|
== NULLREGION){
|
|
ReleaseDC32( hwnd, hdc );
|
|
return 0;
|
|
}
|
|
|
|
if (!(wndPtr->flags & WIN_MANAGED) && !(wndPtr->dwStyle & CCS_NODIVIDER))
|
|
DrawEdge32 (hdc, &wndPtr->rectWindow, EDGE_ETCHED, BF_TOP);
|
|
|
|
ReleaseDC32( hwnd, hdc );
|
|
|
|
return 0;
|
|
}
|
|
|
|
|
|
__inline__ static LRESULT
|
|
TOOLBAR_Notify (WND *wndPtr, WPARAM32 wParam, LPARAM lParam)
|
|
{
|
|
TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr(wndPtr);
|
|
LPNMHDR lpnmh = (LPNMHDR)lParam;
|
|
|
|
TRACE (toolbar, "passing WM_NOTIFY!\n");
|
|
|
|
if ((infoPtr->hwndToolTip) && (lpnmh->hwndFrom == infoPtr->hwndToolTip)) {
|
|
SendMessage32A (infoPtr->hwndNotify, WM_NOTIFY, wParam, lParam);
|
|
|
|
#if 0
|
|
if (lpnmh->code == TTN_GETDISPINFO32A) {
|
|
LPNMTTDISPINFO32A lpdi = (LPNMTTDISPINFO32A)lParam;
|
|
|
|
FIXME (toolbar, "retrieving ASCII string\n");
|
|
|
|
}
|
|
else if (lpnmh->code == TTN_GETDISPINFO32W) {
|
|
LPNMTTDISPINFO32W lpdi = (LPNMTTDISPINFO32W)lParam;
|
|
|
|
FIXME (toolbar, "retrieving UNICODE string\n");
|
|
|
|
}
|
|
#endif
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
|
|
static LRESULT
|
|
TOOLBAR_Paint (WND *wndPtr, WPARAM32 wParam)
|
|
{
|
|
HDC32 hdc;
|
|
PAINTSTRUCT32 ps;
|
|
|
|
hdc = wParam==0 ? BeginPaint32 (wndPtr->hwndSelf, &ps) : (HDC32)wParam;
|
|
TOOLBAR_Refresh (wndPtr, hdc);
|
|
if (!wParam)
|
|
EndPaint32 (wndPtr->hwndSelf, &ps);
|
|
return 0;
|
|
}
|
|
|
|
|
|
static LRESULT
|
|
TOOLBAR_Size (WND *wndPtr, WPARAM32 wParam, LPARAM lParam)
|
|
{
|
|
TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr(wndPtr);
|
|
RECT32 parent_rect;
|
|
HWND32 parent;
|
|
/* INT32 x, y; */
|
|
INT32 cx, cy;
|
|
INT32 flags;
|
|
UINT32 uPosFlags = 0;
|
|
|
|
/* Resize deadlock check */
|
|
if (infoPtr->bAutoSize) {
|
|
infoPtr->bAutoSize = FALSE;
|
|
return 0;
|
|
}
|
|
|
|
flags = (INT32) wParam;
|
|
|
|
/* FIXME for flags =
|
|
* SIZE_MAXIMIZED, SIZE_MAXSHOW, SIZE_MINIMIZED
|
|
*/
|
|
|
|
TRACE (toolbar, "sizing toolbar!\n");
|
|
|
|
if (flags == SIZE_RESTORED) {
|
|
/* width and height don't apply */
|
|
parent = GetParent32 (wndPtr->hwndSelf);
|
|
GetClientRect32(parent, &parent_rect);
|
|
|
|
if (wndPtr->dwStyle & CCS_NORESIZE) {
|
|
uPosFlags |= (SWP_NOSIZE | SWP_NOMOVE);
|
|
|
|
/* FIXME */
|
|
/* infoPtr->nWidth = parent_rect.right - parent_rect.left; */
|
|
cy = infoPtr->nHeight;
|
|
cx = infoPtr->nWidth;
|
|
TOOLBAR_CalcToolbar (wndPtr);
|
|
infoPtr->nWidth = cx;
|
|
infoPtr->nHeight = cy;
|
|
}
|
|
else {
|
|
infoPtr->nWidth = parent_rect.right - parent_rect.left;
|
|
TOOLBAR_CalcToolbar (wndPtr);
|
|
cy = infoPtr->nHeight;
|
|
cx = infoPtr->nWidth;
|
|
}
|
|
|
|
if (wndPtr->dwStyle & CCS_NOPARENTALIGN) {
|
|
uPosFlags |= SWP_NOMOVE;
|
|
cy = infoPtr->nHeight;
|
|
cx = infoPtr->nWidth;
|
|
}
|
|
|
|
if (!(wndPtr->dwStyle & CCS_NODIVIDER))
|
|
cy += sysMetrics[SM_CYEDGE];
|
|
|
|
SetWindowPos32 (wndPtr->hwndSelf, 0, parent_rect.left, parent_rect.top,
|
|
cx, cy, uPosFlags | SWP_NOZORDER);
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
|
|
static LRESULT
|
|
TOOLBAR_StyleChanged (WND *wndPtr, WPARAM32 wParam, LPARAM lParam)
|
|
{
|
|
HDC32 hdc;
|
|
|
|
TOOLBAR_AutoSize (wndPtr, wParam, lParam);
|
|
|
|
hdc = GetDC32 (wndPtr->hwndSelf);
|
|
TOOLBAR_Refresh (wndPtr, hdc);
|
|
ReleaseDC32 (wndPtr->hwndSelf, hdc);
|
|
|
|
return 0;
|
|
}
|
|
|
|
|
|
|
|
LRESULT WINAPI
|
|
ToolbarWindowProc (HWND32 hwnd, UINT32 uMsg, WPARAM32 wParam, LPARAM lParam)
|
|
{
|
|
WND *wndPtr = WIN_FindWndPtr(hwnd);
|
|
|
|
switch (uMsg)
|
|
{
|
|
case TB_ADDBITMAP:
|
|
return TOOLBAR_AddBitmap (wndPtr, wParam, lParam);
|
|
|
|
case TB_ADDBUTTONS32A:
|
|
return TOOLBAR_AddButtons32A (wndPtr, wParam, lParam);
|
|
|
|
/* case TB_ADDBUTTONS32W: */
|
|
|
|
case TB_ADDSTRING32A:
|
|
return TOOLBAR_AddString32A (wndPtr, wParam, lParam);
|
|
|
|
case TB_ADDSTRING32W:
|
|
return TOOLBAR_AddString32W (wndPtr, wParam, lParam);
|
|
|
|
case TB_AUTOSIZE:
|
|
return TOOLBAR_AutoSize (wndPtr, wParam, lParam);
|
|
|
|
case TB_BUTTONCOUNT:
|
|
return TOOLBAR_ButtonCount (wndPtr, wParam, lParam);
|
|
|
|
case TB_BUTTONSTRUCTSIZE:
|
|
return TOOLBAR_ButtonStructSize (wndPtr, wParam, lParam);
|
|
|
|
case TB_CHANGEBITMAP:
|
|
return TOOLBAR_ChangeBitmap (wndPtr, wParam, lParam);
|
|
|
|
case TB_CHECKBUTTON:
|
|
return TOOLBAR_CheckButton (wndPtr, wParam, lParam);
|
|
|
|
case TB_COMMANDTOINDEX:
|
|
return TOOLBAR_CommandToIndex (wndPtr, wParam, lParam);
|
|
|
|
case TB_CUSTOMIZE:
|
|
return TOOLBAR_Customize (wndPtr);
|
|
|
|
case TB_DELETEBUTTON:
|
|
return TOOLBAR_DeleteButton (wndPtr, wParam, lParam);
|
|
|
|
case TB_ENABLEBUTTON:
|
|
return TOOLBAR_EnableButton (wndPtr, wParam, lParam);
|
|
|
|
/* case TB_GETANCHORHIGHLIGHT: */ /* 4.71 */
|
|
|
|
case TB_GETBITMAP:
|
|
return TOOLBAR_GetBitmap (wndPtr, wParam, lParam);
|
|
|
|
case TB_GETBITMAPFLAGS:
|
|
return TOOLBAR_GetBitmapFlags (wndPtr, wParam, lParam);
|
|
|
|
case TB_GETBUTTON:
|
|
return TOOLBAR_GetButton (wndPtr, wParam, lParam);
|
|
|
|
case TB_GETBUTTONINFO32A:
|
|
return TOOLBAR_GetButtonInfo32A (wndPtr, wParam, lParam);
|
|
|
|
/* case TB_GETBUTTONINFO32W: */ /* 4.71 */
|
|
|
|
case TB_GETBUTTONSIZE:
|
|
return TOOLBAR_GetButtonSize (wndPtr);
|
|
|
|
case TB_GETBUTTONTEXT32A:
|
|
return TOOLBAR_GetButtonText32A (wndPtr, wParam, lParam);
|
|
|
|
/* case TB_GETBUTTONTEXT32W: */
|
|
/* case TB_GETCOLORSCHEME: */ /* 4.71 */
|
|
|
|
case TB_GETDISABLEDIMAGELIST:
|
|
return TOOLBAR_GetDisabledImageList (wndPtr, wParam, lParam);
|
|
|
|
case TB_GETEXTENDEDSTYLE:
|
|
return TOOLBAR_GetExtendedStyle (wndPtr);
|
|
|
|
case TB_GETHOTIMAGELIST:
|
|
return TOOLBAR_GetHotImageList (wndPtr, wParam, lParam);
|
|
|
|
/* case TB_GETHOTITEM: */ /* 4.71 */
|
|
|
|
case TB_GETIMAGELIST:
|
|
return TOOLBAR_GetImageList (wndPtr, wParam, lParam);
|
|
|
|
/* case TB_GETINSERTMARK: */ /* 4.71 */
|
|
/* case TB_GETINSERTMARKCOLOR: */ /* 4.71 */
|
|
|
|
case TB_GETITEMRECT:
|
|
return TOOLBAR_GetItemRect (wndPtr, wParam, lParam);
|
|
|
|
case TB_GETMAXSIZE:
|
|
return TOOLBAR_GetMaxSize (wndPtr, wParam, lParam);
|
|
|
|
/* case TB_GETOBJECT: */ /* 4.71 */
|
|
/* case TB_GETPADDING: */ /* 4.71 */
|
|
|
|
case TB_GETRECT:
|
|
return TOOLBAR_GetRect (wndPtr, wParam, lParam);
|
|
|
|
case TB_GETROWS:
|
|
return TOOLBAR_GetRows (wndPtr, wParam, lParam);
|
|
|
|
case TB_GETSTATE:
|
|
return TOOLBAR_GetState (wndPtr, wParam, lParam);
|
|
|
|
case TB_GETSTYLE:
|
|
return TOOLBAR_GetStyle (wndPtr, wParam, lParam);
|
|
|
|
case TB_GETTEXTROWS:
|
|
return TOOLBAR_GetTextRows (wndPtr, wParam, lParam);
|
|
|
|
case TB_GETTOOLTIPS:
|
|
return TOOLBAR_GetToolTips (wndPtr, wParam, lParam);
|
|
|
|
case TB_GETUNICODEFORMAT:
|
|
return TOOLBAR_GetUnicodeFormat (wndPtr, wParam, lParam);
|
|
|
|
case TB_HIDEBUTTON:
|
|
return TOOLBAR_HideButton (wndPtr, wParam, lParam);
|
|
|
|
case TB_HITTEST:
|
|
return TOOLBAR_HitTest (wndPtr, wParam, lParam);
|
|
|
|
case TB_INDETERMINATE:
|
|
return TOOLBAR_Indeterminate (wndPtr, wParam, lParam);
|
|
|
|
case TB_INSERTBUTTON32A:
|
|
return TOOLBAR_InsertButton32A (wndPtr, wParam, lParam);
|
|
|
|
/* case TB_INSERTBUTTON32W: */
|
|
/* case TB_INSERTMARKHITTEST: */ /* 4.71 */
|
|
|
|
case TB_ISBUTTONCHECKED:
|
|
return TOOLBAR_IsButtonChecked (wndPtr, wParam, lParam);
|
|
|
|
case TB_ISBUTTONENABLED:
|
|
return TOOLBAR_IsButtonEnabled (wndPtr, wParam, lParam);
|
|
|
|
case TB_ISBUTTONHIDDEN:
|
|
return TOOLBAR_IsButtonHidden (wndPtr, wParam, lParam);
|
|
|
|
case TB_ISBUTTONHIGHLIGHTED:
|
|
return TOOLBAR_IsButtonHighlighted (wndPtr, wParam, lParam);
|
|
|
|
case TB_ISBUTTONINDETERMINATE:
|
|
return TOOLBAR_IsButtonIndeterminate (wndPtr, wParam, lParam);
|
|
|
|
case TB_ISBUTTONPRESSED:
|
|
return TOOLBAR_IsButtonPressed (wndPtr, wParam, lParam);
|
|
|
|
/* case TB_LOADIMAGES: */ /* 4.70 */
|
|
/* case TB_MAPACCELERATOR32A: */ /* 4.71 */
|
|
/* case TB_MAPACCELERATOR32W: */ /* 4.71 */
|
|
/* case TB_MARKBUTTON: */ /* 4.71 */
|
|
/* case TB_MOVEBUTTON: */ /* 4.71 */
|
|
|
|
case TB_PRESSBUTTON:
|
|
return TOOLBAR_PressButton (wndPtr, wParam, lParam);
|
|
|
|
/* case TB_REPLACEBITMAP: */
|
|
|
|
case TB_SAVERESTORE32A:
|
|
return TOOLBAR_SaveRestore32A (wndPtr, wParam, lParam);
|
|
|
|
/* case TB_SAVERESTORE32W: */
|
|
/* case TB_SETANCHORHIGHLIGHT: */ /* 4.71 */
|
|
|
|
case TB_SETBITMAPSIZE:
|
|
return TOOLBAR_SetBitmapSize (wndPtr, wParam, lParam);
|
|
|
|
case TB_SETBUTTONINFO32A:
|
|
return TOOLBAR_SetButtonInfo32A (wndPtr, wParam, lParam);
|
|
|
|
/* case TB_SETBUTTONINFO32W: */ /* 4.71 */
|
|
|
|
case TB_SETBUTTONSIZE:
|
|
return TOOLBAR_SetButtonSize (wndPtr, wParam, lParam);
|
|
|
|
case TB_SETBUTTONWIDTH:
|
|
return TOOLBAR_SetButtonWidth (wndPtr, wParam, lParam);
|
|
|
|
case TB_SETCMDID:
|
|
return TOOLBAR_SetCmdId (wndPtr, wParam, lParam);
|
|
|
|
/* case TB_SETCOLORSCHEME: */ /* 4.71 */
|
|
|
|
case TB_SETDISABLEDIMAGELIST:
|
|
return TOOLBAR_SetDisabledImageList (wndPtr, wParam, lParam);
|
|
|
|
case TB_SETDRAWTEXTFLAGS:
|
|
return TOOLBAR_SetDrawTextFlags (wndPtr, wParam, lParam);
|
|
|
|
case TB_SETEXTENDEDSTYLE:
|
|
return TOOLBAR_SetExtendedStyle (wndPtr, wParam, lParam);
|
|
|
|
case TB_SETHOTIMAGELIST:
|
|
return TOOLBAR_SetHotImageList (wndPtr, wParam, lParam);
|
|
|
|
/* case TB_SETHOTITEM: */ /* 4.71 */
|
|
|
|
case TB_SETIMAGELIST:
|
|
return TOOLBAR_SetImageList (wndPtr, wParam, lParam);
|
|
|
|
case TB_SETINDENT:
|
|
return TOOLBAR_SetIndent (wndPtr, wParam, lParam);
|
|
|
|
/* case TB_SETINSERTMARK: */ /* 4.71 */
|
|
|
|
case TB_SETINSERTMARKCOLOR:
|
|
return TOOLBAR_SetInsertMarkColor (wndPtr, wParam, lParam);
|
|
|
|
case TB_SETMAXTEXTROWS:
|
|
return TOOLBAR_SetMaxTextRows (wndPtr, wParam, lParam);
|
|
|
|
/* case TB_SETPADDING: */ /* 4.71 */
|
|
|
|
case TB_SETPARENT:
|
|
return TOOLBAR_SetParent (wndPtr, wParam, lParam);
|
|
|
|
case TB_SETROWS:
|
|
return TOOLBAR_SetRows (wndPtr, wParam, lParam);
|
|
|
|
case TB_SETSTATE:
|
|
return TOOLBAR_SetState (wndPtr, wParam, lParam);
|
|
|
|
case TB_SETSTYLE:
|
|
return TOOLBAR_SetStyle (wndPtr, wParam, lParam);
|
|
|
|
case TB_SETTOOLTIPS:
|
|
return TOOLBAR_SetToolTips (wndPtr, wParam, lParam);
|
|
|
|
case TB_SETUNICODEFORMAT:
|
|
return TOOLBAR_SetUnicodeFormat (wndPtr, wParam, lParam);
|
|
|
|
|
|
/* case WM_CHAR: */
|
|
|
|
case WM_CREATE:
|
|
return TOOLBAR_Create (wndPtr, wParam, lParam);
|
|
|
|
case WM_DESTROY:
|
|
return TOOLBAR_Destroy (wndPtr, wParam, lParam);
|
|
|
|
case WM_ERASEBKGND:
|
|
return TOOLBAR_EraseBackground (wndPtr, wParam, lParam);
|
|
|
|
/* case WM_GETFONT: */
|
|
/* case WM_KEYDOWN: */
|
|
/* case WM_KILLFOCUS: */
|
|
|
|
case WM_LBUTTONDBLCLK:
|
|
return TOOLBAR_LButtonDblClk (wndPtr, wParam, lParam);
|
|
|
|
case WM_LBUTTONDOWN:
|
|
return TOOLBAR_LButtonDown (wndPtr, wParam, lParam);
|
|
|
|
case WM_LBUTTONUP:
|
|
return TOOLBAR_LButtonUp (wndPtr, wParam, lParam);
|
|
|
|
case WM_MOUSEMOVE:
|
|
return TOOLBAR_MouseMove (wndPtr, wParam, lParam);
|
|
|
|
case WM_NCACTIVATE:
|
|
return TOOLBAR_NCActivate (wndPtr, wParam, lParam);
|
|
|
|
case WM_NCCALCSIZE:
|
|
return TOOLBAR_NCCalcSize (wndPtr, wParam, lParam);
|
|
|
|
case WM_NCCREATE:
|
|
return TOOLBAR_NCCreate (wndPtr, wParam, lParam);
|
|
|
|
case WM_NCPAINT:
|
|
return TOOLBAR_NCPaint (wndPtr, wParam, lParam);
|
|
|
|
case WM_NOTIFY:
|
|
return TOOLBAR_Notify (wndPtr, wParam, lParam);
|
|
|
|
/* case WM_NOTIFYFORMAT: */
|
|
|
|
case WM_PAINT:
|
|
return TOOLBAR_Paint (wndPtr, wParam);
|
|
|
|
case WM_SIZE:
|
|
return TOOLBAR_Size (wndPtr, wParam, lParam);
|
|
|
|
case WM_STYLECHANGED:
|
|
return TOOLBAR_StyleChanged (wndPtr, wParam, lParam);
|
|
|
|
/* case WM_SYSCOLORCHANGE: */
|
|
|
|
/* case WM_WININICHANGE: */
|
|
|
|
case WM_CHARTOITEM:
|
|
case WM_COMMAND:
|
|
case WM_DRAWITEM:
|
|
case WM_MEASUREITEM:
|
|
case WM_VKEYTOITEM:
|
|
return SendMessage32A (GetParent32 (hwnd), uMsg, wParam, lParam);
|
|
|
|
default:
|
|
if (uMsg >= WM_USER)
|
|
ERR (toolbar, "unknown msg %04x wp=%08x lp=%08lx\n",
|
|
uMsg, wParam, lParam);
|
|
return DefWindowProc32A (hwnd, uMsg, wParam, lParam);
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
|
|
VOID
|
|
TOOLBAR_Register (VOID)
|
|
{
|
|
WNDCLASS32A wndClass;
|
|
|
|
if (GlobalFindAtom32A (TOOLBARCLASSNAME32A)) return;
|
|
|
|
ZeroMemory (&wndClass, sizeof(WNDCLASS32A));
|
|
wndClass.style = CS_GLOBALCLASS | CS_DBLCLKS;
|
|
wndClass.lpfnWndProc = (WNDPROC32)ToolbarWindowProc;
|
|
wndClass.cbClsExtra = 0;
|
|
wndClass.cbWndExtra = sizeof(TOOLBAR_INFO *);
|
|
wndClass.hCursor = LoadCursor32A (0, IDC_ARROW32A);
|
|
wndClass.hbrBackground = (HBRUSH32)(COLOR_3DFACE + 1);
|
|
wndClass.lpszClassName = TOOLBARCLASSNAME32A;
|
|
|
|
RegisterClass32A (&wndClass);
|
|
}
|
|
|
|
|
|
VOID
|
|
TOOLBAR_Unregister (VOID)
|
|
{
|
|
if (GlobalFindAtom32A (TOOLBARCLASSNAME32A))
|
|
UnregisterClass32A (TOOLBARCLASSNAME32A, (HINSTANCE32)NULL);
|
|
}
|
|
|