windows-nt/Source/XPSP1/NT/printscan/ui/uicommon/createtb.cpp

515 lines
19 KiB
C++
Raw Normal View History

2020-09-26 03:20:57 -05:00
/*******************************************************************************
*
* (C) COPYRIGHT MICROSOFT CORPORATION, 2000
*
* TITLE: CREATETB.CPP
*
* VERSION: 1.0
*
* AUTHOR: ShaunIv
*
* DATE: 12/22/2000
*
* DESCRIPTION: Toolbar helpers
*
*******************************************************************************/
#include "precomp.h"
#pragma hdrstop
#include "createtb.h"
#include <windowsx.h>
#include <simstr.h>
#include <psutil.h>
#include <simrect.h>
namespace ToolbarHelper
{
//
// This is a replacement for CreateToolbarEx (in comctl32.dll) that uses CreateMappedBitmap
// so we can get the benefit of having buttons that work ok in high contrast mode.
//
HWND CreateToolbar(
HWND hwndParent,
DWORD dwStyle,
UINT_PTR nID,
CToolbarBitmapInfo &ToolbarBitmapInfo,
LPCTBBUTTON pButtons,
int nButtonCount,
int nButtonWidth,
int nButtonHeight,
int nBitmapWidth,
int nBitmapHeight,
UINT nButtonStructSize )
{
HWND hwndToolbar = CreateWindow( TOOLBARCLASSNAME, NULL, WS_CHILD | dwStyle, 0, 0, 100, 30, hwndParent, reinterpret_cast<HMENU>(nID), NULL, NULL );
if (hwndToolbar)
{
ToolbarBitmapInfo.Toolbar(hwndToolbar);
SendMessage( hwndToolbar, TB_BUTTONSTRUCTSIZE, nButtonStructSize, 0 );
if (nBitmapWidth && nBitmapHeight)
{
SendMessage( hwndToolbar, TB_SETBITMAPSIZE, 0, MAKELONG(nBitmapWidth,nBitmapHeight) );
}
if (nButtonWidth && nButtonHeight)
{
SendMessage( hwndToolbar, TB_SETBUTTONSIZE, 0, MAKELONG(nButtonWidth,nButtonHeight) );
}
HBITMAP hBitmap = CreateMappedBitmap( ToolbarBitmapInfo.ToolbarInstance(), ToolbarBitmapInfo.BitmapResId(), 0, NULL, 0 );
if (hBitmap)
{
TBADDBITMAP TbAddBitmap = {0};
TbAddBitmap.hInst = NULL;
TbAddBitmap.nID = reinterpret_cast<UINT_PTR>(hBitmap);
if (-1 != SendMessage( hwndToolbar, TB_ADDBITMAP, ToolbarBitmapInfo.ButtonCount(), reinterpret_cast<LPARAM>(&TbAddBitmap) ) )
{
ToolbarBitmapInfo.Bitmap(hBitmap);
}
}
SendMessage( hwndToolbar, TB_ADDBUTTONS, nButtonCount, reinterpret_cast<LPARAM>(pButtons) );
}
return hwndToolbar;
}
HWND CreateToolbar(
HWND hWndParent,
HWND hWndPrevious,
HWND hWndAlign,
int Alignment,
UINT nToolbarId,
CToolbarBitmapInfo &ToolbarBitmapInfo,
CButtonDescriptor *pButtonDescriptors,
UINT nDescriptorCount )
{
HWND hWndToolbar = NULL;
//
// Make sure we have valid data
//
if (!hWndParent || !ToolbarBitmapInfo.ToolbarInstance() || !ToolbarBitmapInfo.BitmapResId() || !pButtonDescriptors || !nDescriptorCount)
{
return NULL;
}
//
// Load the bitmap, so we can figure out how many buttons are in the supplied bitmap,
// and their size. We assume that the buttons are the same height and width.
//
HBITMAP hBitmap = reinterpret_cast<HBITMAP>(LoadImage( ToolbarBitmapInfo.ToolbarInstance(), MAKEINTRESOURCE(ToolbarBitmapInfo.BitmapResId()), IMAGE_BITMAP, 0, 0, LR_DEFAULTCOLOR|LR_CREATEDIBSECTION ));
if (hBitmap)
{
//
// Get the size of the bitmap
//
SIZE sizeBitmap = {0};
PrintScanUtil::GetBitmapSize(hBitmap,sizeBitmap);
//
// If the sizes are valid, continue
//
if (sizeBitmap.cx && sizeBitmap.cy)
{
//
// Figure out the count and dimensions of the buttons
// Note the ridiculous size supplied for nButtonSizeX. This is a
// workaround for a BTNS_AUTOSIZE bug
//
int nToolbarButtonCount = sizeBitmap.cx / sizeBitmap.cy;
int nButtonBitmapSizeX = sizeBitmap.cy;
int nButtonBitmapSizeY = sizeBitmap.cy;
int nButtonSizeX = 1000;
int nButtonSizeY = sizeBitmap.cy;
//
// Figure out which buttons to actually add
//
CSimpleDynamicArray<TBBUTTON> aActualButtons;
for (UINT i=0;i<nDescriptorCount;i++)
{
//
// If there is no controlling variable, or if it is true, add the button
//
if (!pButtonDescriptors[i].pbControllingVariable || *(pButtonDescriptors[i].pbControllingVariable))
{
TBBUTTON ToolbarButton = {0};
ToolbarButton.iBitmap = pButtonDescriptors[i].iBitmap >= 0 ? pButtonDescriptors[i].iBitmap : I_IMAGENONE;
ToolbarButton.idCommand = pButtonDescriptors[i].idCommand;
ToolbarButton.fsState = pButtonDescriptors[i].fsState;
ToolbarButton.fsStyle = pButtonDescriptors[i].fsStyle | BTNS_AUTOSIZE;
aActualButtons.Append(ToolbarButton);
//
// Add the separator, if requested
//
if (pButtonDescriptors[i].bFollowingSeparator)
{
TBBUTTON ToolbarButtonSeparator = {0};
ToolbarButton.fsStyle = BTNS_SEP;
aActualButtons.Append(ToolbarButton);
}
}
}
//
// Make sure we have at least one button
//
ToolbarBitmapInfo.ButtonCount(nToolbarButtonCount);
if (aActualButtons.Size())
{
//
// Create the toolbar
//
hWndToolbar = CreateToolbar(
hWndParent,
WS_CHILD|WS_GROUP|WS_VISIBLE|TBSTYLE_FLAT|WS_TABSTOP|CCS_NODIVIDER|TBSTYLE_LIST|CCS_NORESIZE|TBSTYLE_TOOLTIPS,
nToolbarId,
ToolbarBitmapInfo,
aActualButtons.Array(),
aActualButtons.Size(),
nButtonSizeX,
nButtonSizeY,
nButtonBitmapSizeX,
nButtonBitmapSizeY,
sizeof(TBBUTTON) );
if (hWndToolbar)
{
//
// Set the font for the toolbar to be the same as the font for its parent
//
LRESULT lFontResult = SendMessage( hWndParent, WM_GETFONT, 0, 0 );
if (lFontResult)
{
SendMessage( hWndToolbar, WM_SETFONT, lFontResult, 0 );
}
//
// Loop through all of the actual buttons, to find their string resource ID
//
for (int i=0;i<aActualButtons.Size();i++)
{
//
// Look for the matching record, to find the string resource ID
//
for (UINT j=0;j<nDescriptorCount;j++)
{
//
// If this is the original record
//
if (aActualButtons[i].idCommand == pButtonDescriptors[j].idCommand)
{
//
// If this button has a resource ID
//
if (pButtonDescriptors[j].nStringResId)
{
//
// Load the string resource and check to make sure it has a length
//
CSimpleString strText( pButtonDescriptors[j].nStringResId, ToolbarBitmapInfo.ToolbarInstance() );
if (strText.Length())
{
//
// Add the text
//
TBBUTTONINFO ToolBarButtonInfo = {0};
ToolBarButtonInfo.cbSize = sizeof(ToolBarButtonInfo);
ToolBarButtonInfo.dwMask = TBIF_TEXT;
ToolBarButtonInfo.pszText = const_cast<LPTSTR>(strText.String());
SendMessage( hWndToolbar, TB_SETBUTTONINFO, pButtonDescriptors[j].idCommand, reinterpret_cast<LPARAM>(&ToolBarButtonInfo) );
}
}
//
// Exit the inner loop, since we've found a match
//
break;
}
}
}
//
// Tell the toolbar to resize itself
//
SendMessage( hWndToolbar, TB_AUTOSIZE, 0, 0 );
}
}
}
//
// Free the bitmap
//
DeleteBitmap(hBitmap);
}
//
// Resize and place the toolbar as needed
//
if (hWndToolbar && hWndAlign)
{
//
// Get the size of the toolbar
//
SIZE sizeToolbar = {0};
if (SendMessage( hWndToolbar, TB_GETMAXSIZE, 0, reinterpret_cast<LPARAM>(&sizeToolbar)))
{
//
// Get the size of the placement window
//
CSimpleRect rcFrameWnd = CSimpleRect( hWndAlign, CSimpleRect::WindowRect ).ScreenToClient(hWndParent);
//
// Determine how to align horizontally
//
int nOriginX = rcFrameWnd.left;
if (Alignment & AlignHCenter)
{
nOriginX = rcFrameWnd.left + (rcFrameWnd.Width() - sizeToolbar.cx) / 2;
}
else if (Alignment & AlignRight)
{
nOriginX = rcFrameWnd.right - sizeToolbar.cx;
}
int nOriginY = rcFrameWnd.top;
if (Alignment & AlignVCenter)
{
nOriginY = rcFrameWnd.top + (rcFrameWnd.Height() - sizeToolbar.cy) / 2;
}
else if (Alignment & AlignBottom)
{
nOriginY = rcFrameWnd.bottom - sizeToolbar.cy;
}
//
// Move and size the toolbar
//
SetWindowPos( hWndToolbar, NULL, nOriginX, nOriginY, sizeToolbar.cx, sizeToolbar.cy, SWP_NOZORDER|SWP_NOACTIVATE );
}
}
if (hWndToolbar && hWndPrevious)
{
SetWindowPos( hWndToolbar, hWndPrevious, 0, 0, 0, 0, SWP_NOSIZE|SWP_NOMOVE|SWP_NOACTIVATE );
}
return hWndToolbar;
}
void SetToolbarButtonState( HWND hWndToolbar, int nButtonId, int nState )
{
int nCurrentState = static_cast<int>(SendMessage(hWndToolbar,TB_GETSTATE,nButtonId,0));
if (nCurrentState != -1)
{
if (nCurrentState ^ nState)
{
SendMessage(hWndToolbar,TB_SETSTATE,nButtonId,MAKELONG(nState,0));
}
}
}
void EnableToolbarButton( HWND hWndToolbar, int nButtonId, bool bEnable )
{
WIA_PUSH_FUNCTION((TEXT("EnableToolbarButton")));
int nCurrentState = static_cast<int>(SendMessage(hWndToolbar,TB_GETSTATE,nButtonId,0));
if (nCurrentState != -1)
{
if (bEnable)
{
nCurrentState |= TBSTATE_ENABLED;
}
else
{
nCurrentState &= ~TBSTATE_ENABLED;
}
SetToolbarButtonState( hWndToolbar, nButtonId, nCurrentState );
}
//
// If there are no enabled buttons, remove the WS_TABSTOP bit. If there are,
// make sure we add it back in.
//
//
// Assume we don't need the WS_TABSTOP style
//
bool bTabStop = false;
//
// Loop through all of the buttons in the control
//
for (int i=0;i<SendMessage(hWndToolbar,TB_BUTTONCOUNT,0,0);++i)
{
//
// Get the button info for each button
//
TBBUTTON TbButton = {0};
if (SendMessage(hWndToolbar,TB_GETBUTTON,i,reinterpret_cast<LPARAM>(&TbButton)))
{
WIA_TRACE((TEXT("TbButton: %d, %d, %04X, %04X, %08X, %p"), TbButton.iBitmap, TbButton.idCommand, TbButton.fsState, TbButton.fsStyle, TbButton.dwData, TbButton.iString ));
//
// If this button is enabled, set bTabStop to true and pop out of the loop
if (!(TbButton.fsStyle & BTNS_SEP) && TbButton.fsState & TBSTATE_ENABLED)
{
bTabStop = true;
break;
}
}
}
//
// Get the current window style and save a copy, so we don't
// call SetWindowLong for no reason.
//
LONG nStyle = GetWindowLong( hWndToolbar, GWL_STYLE );
LONG nCurrent = nStyle;
//
// Calculate the new style
//
if (bTabStop)
{
nStyle |= WS_TABSTOP;
}
else
{
nStyle &= ~WS_TABSTOP;
}
//
// If the new style doesn't match the old one, set the style
//
if (nStyle != nCurrent)
{
SetWindowLong( hWndToolbar, GWL_STYLE, nStyle );
}
}
bool GetAccelerator( LPCTSTR pszString, TCHAR &chAccel )
{
//
// & marks an accelerator
//
const TCHAR c_chAccelFlag = TEXT('&');
//
// Assume we won't find an accelerator
//
chAccel = 0;
//
// Loop through the string
//
LPCTSTR pszCurr = pszString;
while (pszString && *pszString)
{
//
// If this is the marker character
//
if (c_chAccelFlag == *pszCurr)
{
//
// Get the next character.
//
pszCurr = CharNext(pszCurr);
//
// Make sure this isn't a && situation. If it isn't, save the accelerator and break out.
//
if (c_chAccelFlag != *pszCurr)
{
chAccel = reinterpret_cast<TCHAR>(CharUpper(reinterpret_cast<LPTSTR>(*pszCurr)));
break;
}
}
//
// It is OK to call this even if we are on the end of the string already
//
pszCurr = CharNext(pszCurr);
}
return (0 != chAccel);
}
UINT GetButtonBarAccelerators( HWND hWndToolbar, ACCEL *pAccelerators, UINT nMaxCount )
{
WIA_PUSH_FUNCTION((TEXT("GetButtonBarAccelerators")));
//
// We can't exceed the maximum number of buttons
//
UINT nCurrAccel=0;
//
// Loop through all of the buttons in the control
//
for (LRESULT i=0;i<SendMessage(hWndToolbar,TB_BUTTONCOUNT,0,0) && nCurrAccel < nMaxCount;++i)
{
//
// Get the button info for each button, so we can get the ID
//
TBBUTTON TbButton = {0};
if (SendMessage(hWndToolbar,TB_GETBUTTON,i,reinterpret_cast<LPARAM>(&TbButton)))
{
WIA_TRACE((TEXT("TbButton: %d, %d, %04X, %04X, %08X, %p"), TbButton.iBitmap, TbButton.idCommand, TbButton.fsState, TbButton.fsStyle, TbButton.dwData, TbButton.iString ));
//
// Ignore separators
//
if (!(TbButton.fsStyle & BTNS_SEP))
{
//
// Get the button text.
//
TCHAR szButtonText[MAX_PATH]={0};
if (-1 != SendMessage(hWndToolbar,TB_GETBUTTONTEXT,TbButton.idCommand,reinterpret_cast<LPARAM>(szButtonText)))
{
//
// Get the accelerator (if any)
//
TCHAR chAccel = 0;
if (GetAccelerator( szButtonText, chAccel ))
{
//
// Create an ACCEL record
//
pAccelerators[nCurrAccel].cmd = static_cast<WORD>(TbButton.idCommand);
pAccelerators[nCurrAccel].fVirt = FALT|FVIRTKEY;
pAccelerators[nCurrAccel].key = chAccel;
//
// One more accelerator
//
nCurrAccel++;
}
}
}
}
}
#if defined(DBG)
for (UINT i=0;i<nCurrAccel;i++)
{
WIA_TRACE((TEXT("pAccelerators[%d].fVirt = 0x%02X, 0x%04X (%c), 0x%04X"), i, pAccelerators[i].fVirt, pAccelerators[i].key, pAccelerators[i].key, pAccelerators[i].cmd ));
}
#endif
return nCurrAccel;
}
void CheckToolbarButton( HWND hWndToolbar, int nButtonId, bool bChecked )
{
int nCurrentState = static_cast<int>(SendMessage(hWndToolbar,TB_GETSTATE,nButtonId,0));
if (nCurrentState != -1)
{
if (bChecked)
{
nCurrentState |= TBSTATE_CHECKED;
}
else
{
nCurrentState &= ~TBSTATE_CHECKED;
}
SetToolbarButtonState( hWndToolbar, nButtonId, nCurrentState );
}
}
}