/////////////////////////////////////////////////////////////////////////////
-// Name: msw/wince/tbarwce.cpp
+// Name: src/msw/wince/tbarwce.cpp
// Purpose: wxToolBar for Windows CE
// Author: Julian Smart
// Modified by:
// headers
// ----------------------------------------------------------------------------
-#ifdef __GNUG__
- #pragma implementation "tbarwce.h"
-#endif
-
// For compilers that support precompilation, includes "wx.h".
#include "wx/wxprec.h"
#pragma hdrstop
#endif
+// Use the WinCE-specific toolbar only if we're either compiling
+// with a WinCE earlier than 4, or we wish to emulate a PocketPC-style UI
+#if wxUSE_TOOLBAR && wxUSE_TOOLBAR_NATIVE && (_WIN32_WCE < 400 || defined(__POCKETPC__) || defined(__SMARTPHONE__))
+
+#include "wx/toolbar.h"
+
#ifndef WX_PRECOMP
+ #include "wx/msw/wrapcctl.h" // include <commctrl.h> "properly"
+ #include "wx/dynarray.h"
#include "wx/frame.h"
#include "wx/log.h"
#include "wx/intl.h"
- #include "wx/dynarray.h"
#include "wx/settings.h"
#include "wx/bitmap.h"
#include "wx/dcmemory.h"
#include "wx/control.h"
#endif
-#if wxUSE_TOOLBAR && wxUSE_TOOLBAR_NATIVE
-
-#include "wx/toolbar.h"
-
#if !defined(__GNUWIN32__) && !defined(__SALFORDC__)
#include "malloc.h"
#endif
#include <windowsx.h>
#include <tchar.h>
#include <ole2.h>
-#include <commctrl.h>
-#include <aygshell.h>
-
-#include "wx/msw/winundef.h"
-
-#if defined(__MWERKS__) && defined(__WXMSW__)
-// including <windef.h> for max definition doesn't seem
-// to work using CodeWarrior 6 Windows. So we define it
-// here. (Otherwise we get a undefined identifier 'max'
-// later on in this file.) (Added by dimitri@shortcut.nl)
-# ifndef max
-# define max(a,b) (((a) > (b)) ? (a) : (b))
-# endif
-
+#include <shellapi.h>
+#if defined(WINCE_WITHOUT_COMMANDBAR)
+ #include <aygshell.h>
+ #include "wx/msw/wince/resources.h"
#endif
+#include "wx/msw/wince/missing.h"
-// ----------------------------------------------------------------------------
-// conditional compilation
-// ----------------------------------------------------------------------------
-
-// wxWindows previously always considered that toolbar buttons have light grey
-// (0xc0c0c0) background and so ignored any bitmap masks - however, this
-// doesn't work with XPMs which then appear to have black background. To make
-// this work, we must respect the bitmap masks - which we do now. This should
-// be ok in any case, but to restore 100% compatible with the old version
-// behaviour, you can set this to 0.
-#define USE_BITMAP_MASKS 1
-
-// ----------------------------------------------------------------------------
-// constants
-// ----------------------------------------------------------------------------
-
-// these standard constants are not always defined in compilers headers
-
-// Styles
-#ifndef TBSTYLE_FLAT
- #define TBSTYLE_LIST 0x1000
- #define TBSTYLE_FLAT 0x0800
-#endif
-
-#ifndef TBSTYLE_TRANSPARENT
- #define TBSTYLE_TRANSPARENT 0x8000
-#endif
-
-#ifndef TBSTYLE_TOOLTIPS
- #define TBSTYLE_TOOLTIPS 0x0100
-#endif
-
-// Messages
-#ifndef TB_GETSTYLE
- #define TB_SETSTYLE (WM_USER + 56)
- #define TB_GETSTYLE (WM_USER + 57)
-#endif
+#include "wx/msw/winundef.h"
-#ifndef TB_HITTEST
- #define TB_HITTEST (WM_USER + 69)
-#endif
+#if !defined(__SMARTPHONE__)
-// these values correspond to those used by comctl32.dll
-#define DEFAULTBITMAPX 16
-#define DEFAULTBITMAPY 15
-#define DEFAULTBUTTONX 24
-#define DEFAULTBUTTONY 24
-#define DEFAULTBARHEIGHT 27
+///////////// This implementation is for PocketPC.
+///////////// See later for the Smartphone dummy toolbar class.
// ----------------------------------------------------------------------------
-// wxWin macros
+// Event table
// ----------------------------------------------------------------------------
-IMPLEMENT_DYNAMIC_CLASS(wxToolBar, wxToolBarBase)
+IMPLEMENT_DYNAMIC_CLASS(wxToolMenuBar, wxToolBar)
-BEGIN_EVENT_TABLE(wxToolBar, wxToolBarBase)
- EVT_MOUSE_EVENTS(wxToolBar::OnMouseEvent)
- EVT_SYS_COLOUR_CHANGED(wxToolBar::OnSysColourChanged)
+BEGIN_EVENT_TABLE(wxToolMenuBar, wxToolBar)
END_EVENT_TABLE()
// ----------------------------------------------------------------------------
// private classes
// ----------------------------------------------------------------------------
-class wxToolBarTool : public wxToolBarToolBase
+class wxToolMenuBarTool : public wxToolBarToolBase
{
public:
- wxToolBarTool(wxToolBar *tbar,
+ wxToolMenuBarTool(wxToolBar *tbar,
int id,
const wxString& label,
const wxBitmap& bmpNormal,
clientData, shortHelp, longHelp)
{
m_nSepCount = 0;
+ m_bitmapIndex = -1;
}
- wxToolBarTool(wxToolBar *tbar, wxControl *control)
- : wxToolBarToolBase(tbar, control)
+ wxToolMenuBarTool(wxToolBar *tbar, wxControl *control, const wxString& label)
+ : wxToolBarToolBase(tbar, control, label)
{
m_nSepCount = 1;
+ m_bitmapIndex = -1;
}
virtual void SetLabel(const wxString& label)
void SetSeparatorsCount(size_t count) { m_nSepCount = count; }
size_t GetSeparatorsCount() const { return m_nSepCount; }
+ void SetBitmapIndex(int idx) { m_bitmapIndex = idx; }
+ int GetBitmapIndex() const { return m_bitmapIndex; }
+
private:
size_t m_nSepCount;
+ int m_bitmapIndex;
};
// wxToolBarTool
// ----------------------------------------------------------------------------
-wxToolBarToolBase *wxToolBar::CreateTool(int id,
+wxToolBarToolBase *wxToolMenuBar::CreateTool(int id,
const wxString& label,
const wxBitmap& bmpNormal,
const wxBitmap& bmpDisabled,
const wxString& shortHelp,
const wxString& longHelp)
{
- return new wxToolBarTool(this, id, label, bmpNormal, bmpDisabled, kind,
+ return new wxToolMenuBarTool(this, id, label, bmpNormal, bmpDisabled, kind,
clientData, shortHelp, longHelp);
}
-wxToolBarToolBase *wxToolBar::CreateTool(wxControl *control)
+wxToolBarToolBase *
+wxToolMenuBar::CreateTool(wxControl *control, const wxString& label)
{
- return new wxToolBarTool(this, control);
+ return new wxToolMenuBarTool(this, control, label);
}
// ----------------------------------------------------------------------------
// wxToolBar construction
// ----------------------------------------------------------------------------
-void wxToolBar::Init()
+void wxToolMenuBar::Init()
{
- m_hBitmap = 0;
+ wxToolBar::Init();
m_nButtons = 0;
-
- m_defaultWidth = DEFAULTBITMAPX;
- m_defaultHeight = DEFAULTBITMAPY;
-
- m_pInTool = 0;
m_menuBar = NULL;
}
-bool wxToolBar::Create(wxWindow *parent,
+bool wxToolMenuBar::Create(wxWindow *parent,
wxWindowID id,
const wxPoint& pos,
const wxSize& size,
{
// common initialisation
if ( !CreateControl(parent, id, pos, size, style, wxDefaultValidator, name) )
- return FALSE;
+ return false;
// MSW-specific initialisation
if ( !MSWCreateToolbar(pos, size, menuBar) )
- return FALSE;
+ return false;
// set up the colors and fonts
SetBackgroundColour(wxSystemSettings::GetColour(wxSYS_COLOUR_MENUBAR));
SetFont(wxSystemSettings::GetFont(wxSYS_DEFAULT_GUI_FONT));
- return TRUE;
+ return true;
}
-#ifndef TBSTYLE_NO_DROPDOWN_ARROW
-#define TBSTYLE_NO_DROPDOWN_ARROW 0x0080
-#endif
-
-bool wxToolBar::MSWCreateToolbar(const wxPoint& pos, const wxSize& size, wxMenuBar* menuBar)
+bool wxToolMenuBar::MSWCreateToolbar(const wxPoint& WXUNUSED(pos),
+ const wxSize& WXUNUSED(size),
+ wxMenuBar *menuBar)
{
SetMenuBar(menuBar);
if (m_menuBar)
m_menuBar->SetToolBar(this);
- // Create the menubar.
- SHMENUBARINFO mbi;
-
- memset (&mbi, 0, sizeof (SHMENUBARINFO));
- mbi.cbSize = sizeof (SHMENUBARINFO);
- mbi.hwndParent = (HWND) GetParent()->GetHWND();
-#if wxUSE_SMARTPHONE
- mbi.nToolBarId = 5002;
-#else
- mbi.nToolBarId = 5000;
-#endif
- mbi.nBmpId = 0;
- mbi.cBmpImages = 0;
- mbi.dwFlags = 0 ; // SHCMBF_EMPTYBAR;
+ HWND hwndParent = GetHwndOf(GetParent());
+ wxCHECK_MSG( hwndParent, false, _T("should have valid parent HWND") );
+
+#if defined(WINCE_WITHOUT_COMMANDBAR)
+ // create the menubar.
+ WinStruct<SHMENUBARINFO> mbi;
+
+ mbi.hwndParent = hwndParent;
+ mbi.nToolBarId = wxIDM_SHMENU;
mbi.hInstRes = wxGetInstance();
-
- if (!SHCreateMenuBar(&mbi))
+
+ if ( !SHCreateMenuBar(&mbi) )
{
wxFAIL_MSG( _T("SHCreateMenuBar failed") );
- return FALSE;
+ return false;
}
-
+
SetHWND((WXHWND) mbi.hwndMB);
-/*
- if (!::SendMessage((HWND) GetHWND(), TB_DELETEBUTTON, 0, (LPARAM) 0))
- {
- wxLogLastError(wxT("TB_DELETEBUTTON"));
- }
-*/
- // install wxWindows window proc for this window
+#else
+ HWND hWnd = CommandBar_Create(wxGetInstance(), hwndParent, GetId());
+ SetHWND((WXHWND) hWnd);
+#endif
+
+ // install wxWidgets window proc for this window
SubclassWin(m_hWnd);
if (menuBar)
menuBar->Create();
-
- return TRUE;
+
+ return true;
}
-void wxToolBar::Recreate()
+void wxToolMenuBar::Recreate()
{
-#if 0
- const HWND hwndOld = GetHwnd();
- if ( !hwndOld )
- {
- // we haven't been created yet, no need to recreate
- return;
- }
-
- // get the position and size before unsubclassing the old toolbar
- const wxPoint pos = GetPosition();
- const wxSize size = GetSize();
-
- UnsubclassWin();
-
- if ( !MSWCreateToolbar(pos, size) )
- {
- // what can we do?
- wxFAIL_MSG( _T("recreating the toolbar failed") );
-
- return;
- }
-
- // reparent all our children under the new toolbar
- for ( wxWindowList::compatibility_iterator node = m_children.GetFirst();
- node;
- node = node->GetNext() )
- {
- wxWindow *win = node->GetData();
- if ( !win->IsTopLevel() )
- ::SetParent(GetHwndOf(win), GetHwnd());
- }
-
- // only destroy the old toolbar now -- after all the children had been
- // reparented
- ::DestroyWindow(hwndOld);
-
- // it is for the old bitmap control and can't be used with the new one
- if ( m_hBitmap )
- {
- ::DeleteObject((HBITMAP) m_hBitmap);
- m_hBitmap = 0;
- }
-
- Realize();
- UpdateSize();
-#endif
+ // TODO
}
-wxToolBar::~wxToolBar()
+wxToolMenuBar::~wxToolMenuBar()
{
if (GetMenuBar())
GetMenuBar()->SetToolBar(NULL);
-
- // we must refresh the frame size when the toolbar is deleted but the frame
- // is not - otherwise toolbar leaves a hole in the place it used to occupy
- wxFrame *frame = wxDynamicCast(GetParent(), wxFrame);
- if ( frame && !frame->IsBeingDeleted() )
- {
- frame->SendSizeEvent();
- }
-
- if ( m_hBitmap )
- {
- ::DeleteObject((HBITMAP) m_hBitmap);
- }
-}
-
-wxSize wxToolBar::DoGetBestSize() const
-{
- wxSize sizeBest = GetToolSize();
- sizeBest.x *= GetToolsCount();
-
- // reverse horz and vertical components if necessary
- return HasFlag(wxTB_VERTICAL) ? wxSize(sizeBest.y, sizeBest.x) : sizeBest;
}
// Return HMENU for the menu associated with the commandbar
-WXHMENU wxToolBar::GetHMenu()
+WXHMENU wxToolMenuBar::GetHMenu()
{
+#if !defined(__HANDHELDPC__)
if (GetHWND())
{
- return (WXHMENU) (HMENU)::SendMessage((HWND) GetHWND(), SHCMBM_GETMENU, (WPARAM)0, (LPARAM)0);
- }
- else
- return 0;
-}
-
-
-WXDWORD wxToolBar::MSWGetStyle(long style, WXDWORD *exstyle) const
-{
- // toolbars never have border, giving one to them results in broken
- // appearance
- WXDWORD msStyle = wxControl::MSWGetStyle
- (
- (style & ~wxBORDER_MASK) | wxBORDER_NONE, exstyle
- );
-
- // always include this one, it never hurts and setting it later only if we
- // do have tooltips wouldn't work
- msStyle |= TBSTYLE_TOOLTIPS;
-
- if ( style & (wxTB_FLAT | wxTB_HORZ_LAYOUT) )
- {
- // static as it doesn't change during the program lifetime
- static int s_verComCtl = wxTheApp->GetComCtl32Version();
-
- // comctl32.dll 4.00 doesn't support the flat toolbars and using this
- // style with 6.00 (part of Windows XP) leads to the toolbar with
- // incorrect background colour - and not using it still results in the
- // correct (flat) toolbar, so don't use it there
- if ( s_verComCtl > 400 && s_verComCtl < 600 )
- {
- msStyle |= TBSTYLE_FLAT | TBSTYLE_TRANSPARENT;
- }
-
- if ( s_verComCtl >= 470 && style & wxTB_HORZ_LAYOUT )
- {
- msStyle |= TBSTYLE_LIST;
- }
+ return (WXHMENU)::SendMessage(GetHwnd(), SHCMBM_GETMENU, 0, 0);
}
+#endif
- if ( style & wxTB_NODIVIDER )
- msStyle |= CCS_NODIVIDER;
-
- if ( style & wxTB_NOALIGN )
- msStyle |= CCS_NOPARENTALIGN;
-
- if ( style & wxTB_VERTICAL )
- msStyle |= CCS_VERT;
-
- return msStyle;
+ return NULL;
}
// ----------------------------------------------------------------------------
// adding/removing tools
// ----------------------------------------------------------------------------
-bool wxToolBar::DoInsertTool(size_t WXUNUSED(pos), wxToolBarToolBase *tool)
+bool wxToolMenuBar::DoInsertTool(size_t WXUNUSED(pos), wxToolBarToolBase *tool)
{
// nothing special to do here - we really create the toolbar buttons in
// Realize() later
tool->Attach(this);
- return TRUE;
+ return true;
}
-bool wxToolBar::DoDeleteTool(size_t pos, wxToolBarToolBase *tool)
+bool wxToolMenuBar::DoDeleteTool(size_t pos, wxToolBarToolBase *tool)
{
// the main difficulty we have here is with the controls in the toolbars:
// as we (sometimes) use several separators to cover up the space used by
if ( tool2->IsControl() )
{
- pos += ((wxToolBarTool *)tool2)->GetSeparatorsCount() - 1;
+ pos += ((wxToolMenuBarTool *)tool2)->GetSeparatorsCount() - 1;
}
}
if ( tool->IsControl() )
{
- nButtonsToDelete = ((wxToolBarTool *)tool)->GetSeparatorsCount();
+ nButtonsToDelete = ((wxToolMenuBarTool *)tool)->GetSeparatorsCount();
width *= nButtonsToDelete;
}
{
wxLogLastError(wxT("TB_DELETEBUTTON"));
- return FALSE;
+ return false;
}
}
int x;
wxControl *control = tool2->GetControl();
control->GetPosition(&x, NULL);
- control->Move(x - width, -1);
+ control->Move(x - width, wxDefaultCoord);
}
}
- return TRUE;
+ return true;
}
-struct wxToolBarIdMapping
-{
- int m_wxwinId;
- int m_winceId;
-};
-
-static wxToolBarIdMapping sm_ToolBarIdMappingArray[] =
-{
- { wxID_COPY, STD_COPY },
- { wxID_CUT, STD_CUT },
- { wxID_FIND, STD_FIND },
- { wxID_PASTE, STD_PASTE },
- { wxID_NEW, STD_FILENEW },
- { wxID_OPEN, STD_FILEOPEN },
- { wxID_SAVE, STD_FILESAVE },
- { wxID_PRINT, STD_PRINT },
- { wxID_PREVIEW, STD_PRINTPRE },
- { wxID_UNDO, STD_UNDO },
- { wxID_REDO, STD_REDOW },
- { wxID_HELP, STD_HELP },
- { wxID_DELETE, STD_DELETE },
- { wxID_REPLACE, STD_REPLACE },
- { wxID_PROPERTIES, STD_PROPERTIES },
- { wxID_VIEW_DETAILS, VIEW_DETAILS },
- { wxID_VIEW_SORTDATE, VIEW_SORTDATE },
- { wxID_VIEW_LARGEICONS, VIEW_LARGEICONS },
- { wxID_VIEW_SORTNAME, VIEW_SORTNAME },
- { wxID_VIEW_LIST, VIEW_LIST },
- { wxID_VIEW_SORTSIZE, VIEW_SORTSIZE },
- { wxID_VIEW_SMALLICONS, VIEW_SMALLICONS },
- { wxID_VIEW_SORTTYPE, VIEW_SORTTYPE },
- { 0, 0},
-};
-
-static int wxFindIdForWinceId(int id)
-{
- int i = 0;
- while (TRUE)
- {
- if (sm_ToolBarIdMappingArray[i].m_winceId == 0)
- return -1;
- else if (sm_ToolBarIdMappingArray[i].m_winceId == id)
- return sm_ToolBarIdMappingArray[i].m_wxwinId;
- i ++;
- }
- return -1;
-}
-
-static int wxFindIdForwxWinId(int id)
-{
- int i = 0;
- while (TRUE)
- {
- if (sm_ToolBarIdMappingArray[i].m_wxwinId == 0)
- return -1;
- else if (sm_ToolBarIdMappingArray[i].m_wxwinId == id)
- return sm_ToolBarIdMappingArray[i].m_winceId;
- i ++;
- }
- return -1;
-}
-
-
-bool wxToolBar::Realize()
+bool wxToolMenuBar::Realize()
{
const size_t nTools = GetToolsCount();
if ( nTools == 0 )
{
// nothing to do
- return TRUE;
+ return true;
}
- const bool isVertical = HasFlag(wxTB_VERTICAL);
-
#if 0
// delete all old buttons, if any
for ( size_t pos = 0; pos < m_nButtons; pos++ )
wxLogDebug(wxT("TB_DELETEBUTTON failed"));
}
}
-#endif
-
- // add the buttons and separators
- // ------------------------------
-
- // Use standard buttons
- CommandBar_AddBitmap((HWND) GetHWND(), HINST_COMMCTRL,
- IDB_STD_SMALL_COLOR, 0, 16, 16);
-
- TBBUTTON *buttons = new TBBUTTON[nTools];
-
- // this array will hold the indices of all controls in the toolbar
- wxArrayInt controlIds;
+#endif // 0
- bool lastWasRadio = FALSE;
- int i = 0;
+ bool lastWasRadio = false;
wxToolBarToolsList::Node* node;
for ( node = m_tools.GetFirst(); node; node = node->GetNext() )
{
- wxToolBarToolBase *tool = node->GetData();
+ wxToolMenuBarTool *tool = (wxToolMenuBarTool*) node->GetData();
- bool processedThis = TRUE;
+ TBBUTTON buttons[1] ;
- TBBUTTON& button = buttons[i];
+ TBBUTTON& button = buttons[0];
wxZeroMemory(button);
- bool isRadio = FALSE;
+ bool isRadio = false;
switch ( tool->GetStyle() )
{
case wxTOOL_STYLE_CONTROL:
button.idCommand = tool->GetId();
// fall through: create just a separator too
+ // TODO: controls are not yet supported on wxToolMenuBar.
case wxTOOL_STYLE_SEPARATOR:
button.fsState = TBSTATE_ENABLED;
break;
case wxTOOL_STYLE_BUTTON:
-// if ( !HasFlag(wxTB_NOICONS) )
-// button.iBitmap = bitmapId;
if ( HasFlag(wxTB_TEXT) )
{
const wxString& label = tool->GetLabel();
if ( !label.empty() )
{
- button.iString = (int)label.c_str();
+ button.iString = (int)label.wx_str();
}
}
- int winceId = wxFindIdForwxWinId(tool->GetId());
- if (winceId > -1)
+ const wxBitmap& bmp = tool->GetNormalBitmap();
+
+ wxBitmap bmpToUse = bmp;
+
+ if (bmp.GetWidth() < 16 || bmp.GetHeight() < 16 || bmp.GetMask() != NULL)
+ {
+ wxMemoryDC memDC;
+ wxBitmap b(16,16);
+ memDC.SelectObject(b);
+ wxColour col = wxColour(192,192,192);
+ memDC.SetBackground(wxBrush(col));
+ memDC.Clear();
+ int x = (16 - bmp.GetWidth())/2;
+ int y = (16 - bmp.GetHeight())/2;
+ memDC.DrawBitmap(bmp, x, y, true);
+ memDC.SelectObject(wxNullBitmap);
+
+ bmpToUse = b;
+ tool->SetNormalBitmap(b);
+ }
+
+ int n = 0;
+ if ( bmpToUse.Ok() )
{
- button.idCommand = tool->GetId();
-// if ( !HasFlag(wxTB_NOICONS) )
- button.iBitmap = winceId;
+ n = ::CommandBar_AddBitmap( (HWND) GetHWND(), NULL, (int) (HBITMAP) bmpToUse.GetHBITMAP(),
+ 1, 16, 16 );
}
- else
- processedThis = FALSE;
+
+ button.idCommand = tool->GetId();
+ button.iBitmap = n;
if ( tool->IsEnabled() )
button.fsState |= TBSTATE_ENABLED;
// radio items
button.fsState |= TBSTATE_CHECKED;
- tool->Toggle(TRUE);
+ tool->Toggle(true);
}
- isRadio = TRUE;
+ isRadio = true;
break;
case wxITEM_CHECK:
case wxITEM_NORMAL:
button.fsStyle = TBSTYLE_BUTTON;
}
-
-// bitmapId++;
break;
}
- lastWasRadio = isRadio;
-
- if (processedThis)
- i++;
- }
-
- // Add buttons to Commandbar
- if (!CommandBar_AddButtons(GetHwnd(), i, buttons))
- {
- wxLogLastError(wxT("CommandBar_AddButtons"));
- }
-
- delete [] buttons;
-
-#if 0
- // Deal with the controls finally
- // ------------------------------
-
- // adjust the controls size to fit nicely in the toolbar
- int y = 0;
- size_t index = 0;
- for ( node = m_tools.GetFirst(); node; node = node->GetNext(), index++ )
- {
- wxToolBarToolBase *tool = node->GetData();
-
- // we calculate the running y coord for vertical toolbars so we need to
- // get the items size for all items but for the horizontal ones we
- // don't need to deal with the non controls
- bool isControl = tool->IsControl();
- if ( !isControl && !isVertical )
- continue;
-
- // note that we use TB_GETITEMRECT and not TB_GETRECT because the
- // latter only appeared in v4.70 of comctl32.dll
- RECT r;
- if ( !SendMessage(GetHwnd(), TB_GETITEMRECT,
- index, (LPARAM)(LPRECT)&r) )
- {
- wxLogLastError(wxT("TB_GETITEMRECT"));
- }
-
- if ( !isControl )
+ if ( !::CommandBar_AddButtons( (HWND) GetHWND(), 1, buttons ) )
{
- // can only be control if isVertical
- y += r.bottom - r.top;
-
- continue;
+ wxFAIL_MSG( wxT("Could not add toolbar button."));
}
- wxControl *control = tool->GetControl();
+ lastWasRadio = isRadio;
+ }
- wxSize size = control->GetSize();
+ return true;
+}
- // the position of the leftmost controls corner
- int left = -1;
+bool wxToolMenuBar::MSWCommand(WXUINT WXUNUSED(cmd), WXWORD id_)
+{
+ const int id = (signed short)id_;
- // TB_SETBUTTONINFO message is only supported by comctl32.dll 4.71+
-#if defined(_WIN32_IE) && (_WIN32_IE >= 0x400 )
- // available in headers, now check whether it is available now
- // (during run-time)
- if ( wxTheApp->GetComCtl32Version() >= 471 )
+ wxToolBarToolBase *tool = FindById(id);
+ if ( !tool )
+ {
+ bool checked = false;
+ if ( m_menuBar )
{
- // set the (underlying) separators width to be that of the
- // control
- TBBUTTONINFO tbbi;
- tbbi.cbSize = sizeof(tbbi);
- tbbi.dwMask = TBIF_SIZE;
- tbbi.cx = size.x;
- if ( !SendMessage(GetHwnd(), TB_SETBUTTONINFO,
- tool->GetId(), (LPARAM)&tbbi) )
+ wxMenuItem *item = m_menuBar->FindItem(id);
+ if ( item && item->IsCheckable() )
{
- // the id is probably invalid?
- wxLogLastError(wxT("TB_SETBUTTONINFO"));
+ item->Toggle();
+ checked = item->IsChecked();
}
}
- else
-#endif // comctl32.dll 4.71
- // TB_SETBUTTONINFO unavailable
- {
- // try adding several separators to fit the controls width
- int widthSep = r.right - r.left;
- left = r.left;
-
- TBBUTTON tbb;
- wxZeroMemory(tbb);
- tbb.idCommand = 0;
- tbb.fsState = TBSTATE_ENABLED;
- tbb.fsStyle = TBSTYLE_SEP;
-
- size_t nSeparators = size.x / widthSep;
- for ( size_t nSep = 0; nSep < nSeparators; nSep++ )
- {
- if ( !SendMessage(GetHwnd(), TB_INSERTBUTTON,
- index, (LPARAM)&tbb) )
- {
- wxLogLastError(wxT("TB_INSERTBUTTON"));
- }
-
- index++;
- }
-
- // remember the number of separators we used - we'd have to
- // delete all of them later
- ((wxToolBarTool *)tool)->SetSeparatorsCount(nSeparators);
- // adjust the controls width to exactly cover the separators
- control->SetSize((nSeparators + 1)*widthSep, -1);
- }
-
- // position the control itself correctly vertically
- int height = r.bottom - r.top;
- int diff = height - size.y;
- if ( diff < 0 )
- {
- // the control is too high, resize to fit
- control->SetSize(-1, height - 2);
-
- diff = 2;
- }
-
- int top;
- if ( isVertical )
- {
- left = 0;
- top = y;
-
- y += height + 2*GetMargins().y;
- }
- else // horizontal toolbar
- {
- if ( left == -1 )
- left = r.left;
-
- top = r.top;
- }
-
- control->Move(left, top + (diff + 1) / 2);
- }
-
- // the max index is the "real" number of buttons - i.e. counting even the
- // separators which we added just for aligning the controls
- m_nButtons = index;
-
- if ( !isVertical )
- {
- if ( m_maxRows == 0 )
- {
- // if not set yet, only one row
- SetRows(1);
- }
- }
- else if ( m_nButtons > 0 ) // vertical non empty toolbar
- {
- if ( m_maxRows == 0 )
- {
- // if not set yet, have one column
- SetRows(m_nButtons);
- }
- }
-#endif
-
- return TRUE;
-}
-
-// ----------------------------------------------------------------------------
-// message handlers
-// ----------------------------------------------------------------------------
-
-bool wxToolBar::MSWCommand(WXUINT WXUNUSED(cmd), WXWORD id)
-{
- wxToolBarToolBase *tool = FindById((int)id);
- if ( !tool )
- {
wxCommandEvent event(wxEVT_COMMAND_MENU_SELECTED);
event.SetEventObject(this);
event.SetId(id);
- event.SetInt(id);
+ event.SetInt(checked);
return GetEventHandler()->ProcessEvent(event);
}
}
}
- return TRUE;
+ return true;
}
-bool wxToolBar::MSWOnNotify(int WXUNUSED(idCtrl),
- WXLPARAM lParam,
- WXLPARAM *WXUNUSED(result))
+WXLRESULT wxToolMenuBar::MSWWindowProc(WXUINT nMsg, WXWPARAM wParam, WXLPARAM lParam)
{
-#if wxUSE_TOOLTIPS
- // First check if this applies to us
- NMHDR *hdr = (NMHDR *)lParam;
-
- // the tooltips control created by the toolbar is sometimes Unicode, even
- // in an ANSI application - this seems to be a bug in comctl32.dll v5
- UINT code = hdr->code;
- if ( (code != (UINT) TTN_NEEDTEXTA) && (code != (UINT) TTN_NEEDTEXTW) )
- return FALSE;
-
- HWND toolTipWnd = (HWND)::SendMessage((HWND)GetHWND(), TB_GETTOOLTIPS, 0, 0);
- if ( toolTipWnd != hdr->hwndFrom )
- return FALSE;
-
- LPTOOLTIPTEXT ttText = (LPTOOLTIPTEXT)lParam;
- int id = (int)ttText->hdr.idFrom;
-
- wxToolBarToolBase *tool = FindById(id);
- if ( !tool )
- return FALSE;
-
- return HandleTooltipNotify(code, lParam, tool->GetShortHelp());
-#else
- return FALSE;
-#endif
-}
-
-// ----------------------------------------------------------------------------
-// toolbar geometry
-// ----------------------------------------------------------------------------
-
-void wxToolBar::SetToolBitmapSize(const wxSize& size)
-{
- wxToolBarBase::SetToolBitmapSize(size);
-
- ::SendMessage(GetHwnd(), TB_SETBITMAPSIZE, 0, MAKELONG(size.x, size.y));
-}
-
-void wxToolBar::SetRows(int nRows)
-{
- if ( nRows == m_maxRows )
+ switch ( nMsg )
{
- // avoid resizing the frame uselessly
- return;
- }
+ case WM_SIZE:
+ break;
- // TRUE in wParam means to create at least as many rows, FALSE -
- // at most as many
- RECT rect;
- ::SendMessage(GetHwnd(), TB_SETROWS,
- MAKEWPARAM(nRows, !(GetWindowStyle() & wxTB_VERTICAL)),
- (LPARAM) &rect);
+ case WM_MOUSEMOVE:
+ // we don't handle mouse moves, so always pass the message to
+ // wxControl::MSWWindowProc
+ HandleMouseMove(wParam, lParam);
+ break;
- m_maxRows = nRows;
+ case WM_PAINT:
+ break;
+ }
- UpdateSize();
+ return MSWDefWindowProc(nMsg, wParam, lParam);
}
-// The button size is bigger than the bitmap size
-wxSize wxToolBar::GetToolSize() const
-{
- // TB_GETBUTTONSIZE is supported from version 4.70
-#if defined(_WIN32_IE) && (_WIN32_IE >= 0x300 ) \
- && !( defined(__GNUWIN32__) && !wxCHECK_W32API_VERSION( 1, 0 ) )
- if ( wxTheApp->GetComCtl32Version() >= 470 )
- {
- DWORD dw = ::SendMessage(GetHwnd(), TB_GETBUTTONSIZE, 0, 0);
-
- return wxSize(LOWORD(dw), HIWORD(dw));
- }
- else
-#endif // comctl32.dll 4.70+
- {
- // defaults
- return wxSize(m_defaultWidth + 8, m_defaultHeight + 7);
- }
-}
-static
-wxToolBarToolBase *GetItemSkippingDummySpacers(const wxToolBarToolsList& tools,
- size_t index )
-{
- wxToolBarToolsList::compatibility_iterator current = tools.GetFirst();
+#else
- for ( ; current != 0; current = current->GetNext() )
- {
- if ( index == 0 )
- return current->GetData();
+////////////// For Smartphone
- wxToolBarTool *tool = (wxToolBarTool *)current->GetData();
- size_t separators = tool->GetSeparatorsCount();
+// ----------------------------------------------------------------------------
+// Event table
+// ----------------------------------------------------------------------------
- // if it is a normal button, sepcount == 0, so skip 1 item (the button)
- // otherwise, skip as many items as the separator count, plus the
- // control itself
- index -= separators ? separators + 1 : 1;
- }
+IMPLEMENT_DYNAMIC_CLASS(wxToolBar, wxToolBarBase)
- return 0;
-}
+BEGIN_EVENT_TABLE(wxToolBar, wxToolBarBase)
+END_EVENT_TABLE()
-wxToolBarToolBase *wxToolBar::FindToolForPosition(wxCoord x, wxCoord y) const
+wxToolBarToolBase *wxToolBar::CreateTool(int id,
+ const wxString& label,
+ const wxBitmap& bmpNormal,
+ const wxBitmap& bmpDisabled,
+ wxItemKind kind,
+ wxObject *clientData,
+ const wxString& shortHelp,
+ const wxString& longHelp)
{
- POINT pt;
- pt.x = x;
- pt.y = y;
- int index = (int)::SendMessage(GetHwnd(), TB_HITTEST, 0, (LPARAM)&pt);
- // MBN: when the point ( x, y ) is close to the toolbar border
- // TB_HITTEST returns m_nButtons ( not -1 )
- if ( index < 0 || (size_t)index >= m_nButtons )
- {
- // it's a separator or there is no tool at all there
- return (wxToolBarToolBase *)NULL;
- }
-
- // if comctl32 version < 4.71 wxToolBar95 adds dummy spacers
-#if defined(_WIN32_IE) && (_WIN32_IE >= 0x400 )
- if ( wxTheApp->GetComCtl32Version() >= 471 )
- {
- return m_tools.Item((size_t)index)->GetData();
- }
- else
-#endif
- {
- return GetItemSkippingDummySpacers( m_tools, (size_t) index );
- }
+ return new wxToolBarToolBase(this, id, label, bmpNormal, bmpDisabled, kind,
+ clientData, shortHelp, longHelp);
}
-void wxToolBar::UpdateSize()
+wxToolBarToolBase *wxToolBar::CreateTool(wxControl *control)
{
- // the toolbar size changed
- SendMessage(GetHwnd(), TB_AUTOSIZE, 0, 0);
-
- // we must also refresh the frame after the toolbar size (possibly) changed
- wxFrame *frame = wxDynamicCast(GetParent(), wxFrame);
- if ( frame )
- {
- frame->SendSizeEvent();
- }
+ return new wxToolBarToolBase(this, control);
}
-// ----------------------------------------------------------------------------
-// toolbar styles
-// ---------------------------------------------------------------------------
-
-void wxToolBar::SetWindowStyleFlag(long style)
+bool wxToolBar::Create(wxWindow *parent,
+ wxWindowID WXUNUSED(id),
+ const wxPoint& WXUNUSED(pos),
+ const wxSize& WXUNUSED(size),
+ long style,
+ const wxString& name)
{
- // the style bits whose changes force us to recreate the toolbar
- static const long MASK_NEEDS_RECREATE = wxTB_TEXT | wxTB_NOICONS;
+ // TODO: we may need to make this a dummy hidden window to
+ // satisfy other parts of wxWidgets.
- const long styleOld = GetWindowStyle();
+ parent->AddChild(this);
- wxToolBarBase::SetWindowStyleFlag(style);
+ SetWindowStyle(style);
+ SetName(name);
- // don't recreate an empty toolbar: not only this is unnecessary, but it is
- // also fatal as we'd then try to recreate the toolbar when it's just being
- // created
- if ( GetToolsCount() &&
- (style & MASK_NEEDS_RECREATE) != (styleOld & MASK_NEEDS_RECREATE) )
- {
- // to remove the text labels, simply re-realizing the toolbar is enough
- // but I don't know of any way to add the text to an existing toolbar
- // other than by recreating it entirely
- Recreate();
- }
+ return true;
}
// ----------------------------------------------------------------------------
-// tool state
+// adding/removing tools
// ----------------------------------------------------------------------------
-void wxToolBar::DoEnableTool(wxToolBarToolBase *tool, bool enable)
+bool wxToolBar::DoInsertTool(size_t WXUNUSED(pos), wxToolBarToolBase *tool)
{
- ::SendMessage(GetHwnd(), TB_ENABLEBUTTON,
- (WPARAM)tool->GetId(), (LPARAM)MAKELONG(enable, 0));
+ tool->Attach(this);
+ return true;
}
-void wxToolBar::DoToggleTool(wxToolBarToolBase *tool, bool toggle)
+bool wxToolBar::DoDeleteTool(size_t WXUNUSED(pos), wxToolBarToolBase *tool)
{
- ::SendMessage(GetHwnd(), TB_CHECKBUTTON,
- (WPARAM)tool->GetId(), (LPARAM)MAKELONG(toggle, 0));
+ tool->Detach();
+ return true;
}
-void wxToolBar::DoSetToggle(wxToolBarToolBase *WXUNUSED(tool), bool WXUNUSED(toggle))
+wxToolBarToolBase *wxToolBar::FindToolForPosition(wxCoord WXUNUSED(x), wxCoord WXUNUSED(y)) const
{
- // VZ: AFAIK, the button has to be created either with TBSTYLE_CHECK or
- // without, so we really need to delete the button and recreate it here
- wxFAIL_MSG( _T("not implemented") );
+ return NULL;
}
// ----------------------------------------------------------------------------
-// event handlers
+// tool state
// ----------------------------------------------------------------------------
-// Responds to colour changes, and passes event on to children.
-void wxToolBar::OnSysColourChanged(wxSysColourChangedEvent& event)
+void wxToolBar::DoEnableTool(wxToolBarToolBase *WXUNUSED(tool), bool WXUNUSED(enable))
{
- wxRGBToColour(m_backgroundColour, ::GetSysColor(COLOR_BTNFACE));
-
- // Remap the buttons
- Realize();
-
- // Relayout the toolbar
- int nrows = m_maxRows;
- m_maxRows = 0; // otherwise SetRows() wouldn't do anything
- SetRows(nrows);
-
- Refresh();
-
- // let the event propagate further
- event.Skip();
}
-void wxToolBar::OnMouseEvent(wxMouseEvent& event)
+void wxToolBar::DoToggleTool(wxToolBarToolBase *WXUNUSED(tool), bool WXUNUSED(toggle))
{
- if (event.Leaving() && m_pInTool)
- {
- OnMouseEnter( -1 );
- event.Skip();
- return;
- }
-
- if (event.RightDown())
- {
- // For now, we don't have an id. Later we could
- // try finding the tool.
- OnRightClick((int)-1, event.GetX(), event.GetY());
- }
- else
- {
- event.Skip();
- }
}
-void wxToolBar::HandleMouseMove(WXWPARAM wParam, WXLPARAM lParam)
+void wxToolBar::DoSetToggle(wxToolBarToolBase *WXUNUSED(tool), bool WXUNUSED(toggle))
{
- wxCoord x = GET_X_LPARAM(lParam),
- y = GET_Y_LPARAM(lParam);
- wxToolBarToolBase* tool = FindToolForPosition( x, y );
-
- // cursor left current tool
- if( tool != m_pInTool && !tool )
- {
- m_pInTool = 0;
- OnMouseEnter( -1 );
- }
-
- // cursor entered a tool
- if( tool != m_pInTool && tool )
- {
- m_pInTool = tool;
- OnMouseEnter( tool->GetId() );
- }
+ wxFAIL_MSG( _T("not implemented") );
}
-long wxToolBar::MSWWindowProc(WXUINT nMsg, WXWPARAM wParam, WXLPARAM lParam)
-{
-#if 0
- switch ( nMsg )
- {
- case WM_SIZE:
- if ( HandleSize(wParam, lParam) )
- return 0;
- break;
-
- case WM_MOUSEMOVE:
- // we don't handle mouse moves, so always pass the message to
- // wxControl::MSWWindowProc
- HandleMouseMove(wParam, lParam);
- break;
- }
#endif
- return wxControl::MSWWindowProc(nMsg, wParam, lParam);
-}
-
-// ----------------------------------------------------------------------------
-// private functions
-// ----------------------------------------------------------------------------
-
-WXHBITMAP wxToolBar::MapBitmap(WXHBITMAP bitmap, int width, int height)
-{
- MemoryHDC hdcMem;
-
- if ( !hdcMem )
- {
- wxLogLastError(_T("CreateCompatibleDC"));
-
- return bitmap;
- }
-
- SelectInHDC bmpInHDC(hdcMem, (HBITMAP)bitmap);
-
- if ( !bmpInHDC )
- {
- wxLogLastError(_T("SelectObject"));
-
- return bitmap;
- }
-
- wxCOLORMAP *cmap = wxGetStdColourMap();
-
- for ( int i = 0; i < width; i++ )
- {
- for ( int j = 0; j < height; j++ )
- {
- COLORREF pixel = ::GetPixel(hdcMem, i, j);
-
- for ( size_t k = 0; k < wxSTD_COL_MAX; k++ )
- {
- COLORREF col = cmap[k].from;
- if ( abs(GetRValue(pixel) - GetRValue(col)) < 10 &&
- abs(GetGValue(pixel) - GetGValue(col)) < 10 &&
- abs(GetBValue(pixel) - GetBValue(col)) < 10 )
- {
- ::SetPixel(hdcMem, i, j, cmap[k].to);
- break;
- }
- }
- }
- }
-
- return bitmap;
-
- // VZ: I leave here my attempts to map the bitmap to the system colours
- // faster by using BitBlt() even though it's broken currently - but
- // maybe someone else can finish it? It should be faster than iterating
- // over all pixels...
-#if 0
- MemoryHDC hdcMask, hdcDst;
- if ( !hdcMask || !hdcDst )
- {
- wxLogLastError(_T("CreateCompatibleDC"));
-
- return bitmap;
- }
-
- // create the target bitmap
- HBITMAP hbmpDst = ::CreateCompatibleBitmap(hdcDst, width, height);
- if ( !hbmpDst )
- {
- wxLogLastError(_T("CreateCompatibleBitmap"));
-
- return bitmap;
- }
-
- // create the monochrome mask bitmap
- HBITMAP hbmpMask = ::CreateBitmap(width, height, 1, 1, 0);
- if ( !hbmpMask )
- {
- wxLogLastError(_T("CreateBitmap(mono)"));
-
- ::DeleteObject(hbmpDst);
-
- return bitmap;
- }
-
- SelectInHDC bmpInDst(hdcDst, hbmpDst),
- bmpInMask(hdcMask, hbmpMask);
-
- // for each colour:
- for ( n = 0; n < NUM_OF_MAPPED_COLOURS; n++ )
- {
- // create the mask for this colour
- ::SetBkColor(hdcMem, ColorMap[n].from);
- ::BitBlt(hdcMask, 0, 0, width, height, hdcMem, 0, 0, SRCCOPY);
-
- // replace this colour with the target one in the dst bitmap
- HBRUSH hbr = ::CreateSolidBrush(ColorMap[n].to);
- HGDIOBJ hbrOld = ::SelectObject(hdcDst, hbr);
-
- ::MaskBlt(hdcDst, 0, 0, width, height,
- hdcMem, 0, 0,
- hbmpMask, 0, 0,
- MAKEROP4(PATCOPY, SRCCOPY));
-
- (void)::SelectObject(hdcDst, hbrOld);
- ::DeleteObject(hbr);
- }
-
- ::DeleteObject((HBITMAP)bitmap);
-
- return (WXHBITMAP)hbmpDst;
-#endif // 0
-}
-
-#endif // wxUSE_TOOLBAR && Win95
+ // !__SMARTPHONE__
+#endif // wxUSE_TOOLBAR
projects / wxWidgets.git / blobdiff