Rework the wxCusor ctor taking wx stock number to provide as many cursors as

[wxWidgets.git] / src / msw / wince / tbarwce.cpp

diff --git a/src/msw/wince/tbarwce.cpp b/src/msw/wince/tbarwce.cpp
index 90f4f1fc51bb023cd95d21404c88ced6f965f97b..0ff004bae357bb403193dacf4617b8dc8530c5a3 100644 (file)
--- a/src/msw/wince/tbarwce.cpp
+++ b/src/msw/wince/tbarwce.cpp
@@ -1,5 +1,5 @@
 /////////////////////////////////////////////////////////////////////////////
 /////////////////////////////////////////////////////////////////////////////

-// Name:        msw/wince/tbarwce.cpp
+// Name:        src/msw/wince/tbarwce.cpp

 // Purpose:     wxToolBar for Windows CE
 // Author:      Julian Smart
 // Modified by:
 // Purpose:     wxToolBar for Windows CE
 // Author:      Julian Smart
 // Modified by:


@@ -17,10 +17,6 @@
 // headers
 // ----------------------------------------------------------------------------
 
 // headers
 // ----------------------------------------------------------------------------
 

-#if defined(__GNUG__) && !defined(NO_GCC_PRAGMA)
-    #pragma implementation "tbarwce.h"
-#endif
-

 // For compilers that support precompilation, includes "wx.h".
 #include "wx/wxprec.h"
 
 // For compilers that support precompilation, includes "wx.h".
 #include "wx/wxprec.h"
 


@@ -28,23 +24,24 @@
     #pragma hdrstop
 #endif
 
     #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
 #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/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
 
     #include "wx/settings.h"
     #include "wx/bitmap.h"
     #include "wx/dcmemory.h"
     #include "wx/control.h"
 #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"
-

 #if !defined(__GNUWIN32__) && !defined(__SALFORDC__)
     #include "malloc.h"
 #endif
 #if !defined(__GNUWIN32__) && !defined(__SALFORDC__)
     #include "malloc.h"
 #endif


@@ -55,7 +52,6 @@
 #include <tchar.h>
 #include <ole2.h>
 #include <shellapi.h>
 #include <tchar.h>
 #include <ole2.h>
 #include <shellapi.h>

-#include <commctrl.h>

 #if defined(WINCE_WITHOUT_COMMANDBAR)
   #include <aygshell.h>
 #endif
 #if defined(WINCE_WITHOUT_COMMANDBAR)
   #include <aygshell.h>
 #endif


@@ -63,73 +59,28 @@
 
 #include "wx/msw/winundef.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
-
-#endif
-
-// ----------------------------------------------------------------------------
-// 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
-
-#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, wxControl)
+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
 // ----------------------------------------------------------------------------
 
 END_EVENT_TABLE()
 
 // ----------------------------------------------------------------------------
 // private classes
 // ----------------------------------------------------------------------------
 

-class wxToolBarTool : public wxToolBarToolBase
+class wxToolMenuBarTool : public wxToolBarToolBase

 {
 public:
 {
 public:

-    wxToolBarTool(wxToolBar *tbar,
+    wxToolMenuBarTool(wxToolBar *tbar,

                   int id,
                   const wxString& label,
                   const wxBitmap& bmpNormal,
                   int id,
                   const wxString& label,
                   const wxBitmap& bmpNormal,


@@ -145,8 +96,8 @@ public:
         m_bitmapIndex = -1;
     }
 
         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;
     {
         m_nSepCount = 1;
         m_bitmapIndex = -1;


@@ -169,7 +120,7 @@ public:
     // a control in the toolbar
     void SetSeparatorsCount(size_t count) { m_nSepCount = count; }
     size_t GetSeparatorsCount() const { return m_nSepCount; }
     // a control in the toolbar
     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; }
 
     void SetBitmapIndex(int idx) { m_bitmapIndex = idx; }
     int GetBitmapIndex() const { return m_bitmapIndex; }
 


@@ -187,7 +138,7 @@ private:
 // wxToolBarTool
 // ----------------------------------------------------------------------------
 
 // wxToolBarTool
 // ----------------------------------------------------------------------------
 

-wxToolBarToolBase *wxToolBar::CreateTool(int id,
+wxToolBarToolBase *wxToolMenuBar::CreateTool(int id,

                                          const wxString& label,
                                          const wxBitmap& bmpNormal,
                                          const wxBitmap& bmpDisabled,
                                          const wxString& label,
                                          const wxBitmap& bmpNormal,
                                          const wxBitmap& bmpDisabled,


@@ -196,31 +147,29 @@ wxToolBarToolBase *wxToolBar::CreateTool(int id,
                                          const wxString& shortHelp,
                                          const wxString& longHelp)
 {
                                          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);
 }
 
                              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
 // ----------------------------------------------------------------------------
 
 }
 
 // ----------------------------------------------------------------------------
 // wxToolBar construction
 // ----------------------------------------------------------------------------
 

-void wxToolBar::Init()
+void wxToolMenuBar::Init()

 {
 {

-    m_nButtons = 0;
-
-    m_defaultWidth = DEFAULTBITMAPX;
-    m_defaultHeight = DEFAULTBITMAPY;
+    wxToolBar::Init();

 
 

-    m_pInTool = 0;
+    m_nButtons = 0;

     m_menuBar = NULL;
 }
 
     m_menuBar = NULL;
 }
 

-bool wxToolBar::Create(wxWindow *parent,
+bool wxToolMenuBar::Create(wxWindow *parent,

                        wxWindowID id,
                        const wxPoint& pos,
                        const wxSize& size,
                        wxWindowID id,
                        const wxPoint& pos,
                        const wxSize& size,


@@ -243,20 +192,12 @@ bool wxToolBar::Create(wxWindow *parent,
     return true;
 }
 
     return true;
 }
 

-#ifndef TBSTYLE_NO_DROPDOWN_ARROW
-#define TBSTYLE_NO_DROPDOWN_ARROW 0x0080
-#endif
-
-bool wxToolBar::MSWCreateToolbar(const wxPoint& WXUNUSED(pos), const wxSize& WXUNUSED(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);
 
 {
     SetMenuBar(menuBar);
     if (m_menuBar)
         m_menuBar->SetToolBar(this);
 

-    // Smartphone doesn't show a toolbar, it uses menu buttons.
-
-#if !defined(__SMARTPHONE__)
-

 #if defined(WINCE_WITHOUT_COMMANDBAR)
     // Create the menubar.
     SHMENUBARINFO mbi;
 #if defined(WINCE_WITHOUT_COMMANDBAR)
     // Create the menubar.
     SHMENUBARINFO mbi;


@@ -291,83 +232,25 @@ bool wxToolBar::MSWCreateToolbar(const wxPoint& WXUNUSED(pos), const wxSize& WXU
 
     if (menuBar)
         menuBar->Create();
 
     if (menuBar)
         menuBar->Create();

-#endif
-    // __SMARTPHONE__

 
     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);
-
-    Realize();
-    UpdateSize();
-#endif
+    // TODO

 }
 
 }
 

-wxToolBar::~wxToolBar()
+wxToolMenuBar::~wxToolMenuBar()

 {
     if (GetMenuBar())
         GetMenuBar()->SetToolBar(NULL);
 {
     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();
-    }
-}
-
-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
 }
 
 // Return HMENU for the menu associated with the commandbar

-WXHMENU wxToolBar::GetHMenu()
+WXHMENU wxToolMenuBar::GetHMenu()

 {
 #if defined(__HANDHELDPC__)
 {
 #if defined(__HANDHELDPC__)

-    // TODO ???

     return 0;
 #else
     if (GetHWND())
     return 0;
 #else
     if (GetHWND())


@@ -379,57 +262,11 @@ WXHMENU wxToolBar::GetHMenu()
 #endif
 }
 
 #endif
 }
 

-
-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;
-        }
-    }
-
-    if ( style & wxTB_NODIVIDER )
-        msStyle |= CCS_NODIVIDER;
-
-    if ( style & wxTB_NOALIGN )
-        msStyle |= CCS_NOPARENTALIGN;
-
-    if ( style & wxTB_VERTICAL )
-        msStyle |= CCS_VERT;
-
-    return msStyle;
-}
-

 // ----------------------------------------------------------------------------
 // adding/removing tools
 // ----------------------------------------------------------------------------
 
 // ----------------------------------------------------------------------------
 // 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
 {
     // nothing special to do here - we really create the toolbar buttons in
     // Realize() later


@@ -438,7 +275,7 @@ bool wxToolBar::DoInsertTool(size_t WXUNUSED(pos), wxToolBarToolBase *tool)
     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
 {
     // 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


@@ -461,7 +298,7 @@ bool wxToolBar::DoDeleteTool(size_t pos, wxToolBarToolBase *tool)
 
         if ( tool2->IsControl() )
         {
 
         if ( tool2->IsControl() )
         {

-            pos += ((wxToolBarTool *)tool2)->GetSeparatorsCount() - 1;
+            pos += ((wxToolMenuBarTool *)tool2)->GetSeparatorsCount() - 1;

         }
     }
 
         }
     }
 


@@ -479,7 +316,7 @@ bool wxToolBar::DoDeleteTool(size_t pos, wxToolBarToolBase *tool)
 
     if ( tool->IsControl() )
     {
 
     if ( tool->IsControl() )
     {

-        nButtonsToDelete = ((wxToolBarTool *)tool)->GetSeparatorsCount();
+        nButtonsToDelete = ((wxToolMenuBarTool *)tool)->GetSeparatorsCount();

 
         width *= nButtonsToDelete;
     }
 
         width *= nButtonsToDelete;
     }


@@ -515,11 +352,8 @@ bool wxToolBar::DoDeleteTool(size_t pos, wxToolBarToolBase *tool)
     return true;
 }
 
     return true;
 }
 

-bool wxToolBar::Realize()
+bool wxToolMenuBar::Realize()

 {
 {

-#if defined(__SMARTPHONE__)
-    return true;
-#else

     const size_t nTools = GetToolsCount();
     if ( nTools == 0 )
     {
     const size_t nTools = GetToolsCount();
     if ( nTools == 0 )
     {


@@ -542,7 +376,7 @@ bool wxToolBar::Realize()
     wxToolBarToolsList::Node* node;
     for ( node = m_tools.GetFirst(); node; node = node->GetNext() )
     {
     wxToolBarToolsList::Node* node;
     for ( node = m_tools.GetFirst(); node; node = node->GetNext() )
     {

-        wxToolBarTool *tool = (wxToolBarTool*) node->GetData();
+        wxToolMenuBarTool *tool = (wxToolMenuBarTool*) node->GetData();

 
         TBBUTTON buttons[1] ;
 
 
         TBBUTTON buttons[1] ;
 


@@ -556,6 +390,7 @@ bool wxToolBar::Realize()
             case wxTOOL_STYLE_CONTROL:
                 button.idCommand = tool->GetId();
                 // fall through: create just a separator too
             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;
 
             case wxTOOL_STYLE_SEPARATOR:
                 button.fsState = TBSTATE_ENABLED;


@@ -563,7 +398,7 @@ bool wxToolBar::Realize()
                 break;
 
             case wxTOOL_STYLE_BUTTON:
                 break;
 
             case wxTOOL_STYLE_BUTTON:

-            
+

                 if ( HasFlag(wxTB_TEXT) )
                 {
                     const wxString& label = tool->GetLabel();
                 if ( HasFlag(wxTB_TEXT) )
                 {
                     const wxString& label = tool->GetLabel();


@@ -577,12 +412,13 @@ bool wxToolBar::Realize()
 
                 wxBitmap bmpToUse = bmp;
 
 
                 wxBitmap bmpToUse = bmp;
 

-                if (bmp.GetWidth() < 16 || bmp.GetHeight() < 16)
+                if (bmp.GetWidth() < 16 || bmp.GetHeight() < 16 || bmp.GetMask() != NULL)

                 {
                     wxMemoryDC memDC;
                     wxBitmap b(16,16);
                     memDC.SelectObject(b);
                 {
                     wxMemoryDC memDC;
                     wxBitmap b(16,16);
                     memDC.SelectObject(b);

-                    memDC.SetBackground(wxBrush(wxSystemSettings::GetColour(wxSYS_COLOUR_BTNFACE)));
+                    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.Clear();
                     int x = (16 - bmp.GetWidth())/2;
                     int y = (16 - bmp.GetHeight())/2;


@@ -640,31 +476,37 @@ bool wxToolBar::Realize()
                 break;
         }
 
                 break;
         }
 

-        BOOL bRc = ::CommandBar_AddButtons( (HWND) GetHWND(), 1, buttons );
-        
-        wxASSERT_MSG( bRc, wxT("Could not add toolbar button."));
+        if ( !::CommandBar_AddButtons( (HWND) GetHWND(), 1, buttons ) )
+        {
+            wxFAIL_MSG( wxT("Could not add toolbar button."));
+        }

 
         lastWasRadio = isRadio;
     }
 
     return true;
 
         lastWasRadio = isRadio;
     }
 
     return true;

-#endif
-    // __SMARTPHONE__

 }
 
 }
 

-// ----------------------------------------------------------------------------
-// message handlers
-// ----------------------------------------------------------------------------
-
-bool wxToolBar::MSWCommand(WXUINT WXUNUSED(cmd), WXWORD id)
+bool wxToolMenuBar::MSWCommand(WXUINT WXUNUSED(cmd), WXWORD id)

 {
     wxToolBarToolBase *tool = FindById((int)id);
     if ( !tool )
     {
 {
     wxToolBarToolBase *tool = FindById((int)id);
     if ( !tool )
     {

+        bool checked = false;
+        if ( m_menuBar )
+        {
+            wxMenuItem *item = m_menuBar->FindItem(id);
+            if ( item && item->IsCheckable() )
+            {
+                item->Toggle();
+                checked = item->IsChecked();
+            }
+        }
+

         wxCommandEvent event(wxEVT_COMMAND_MENU_SELECTED);
         event.SetEventObject(this);
         event.SetId(id);
         wxCommandEvent event(wxEVT_COMMAND_MENU_SELECTED);
         event.SetEventObject(this);
         event.SetId(id);

-        event.SetInt(id);
+        event.SetInt(checked);

 
         return GetEventHandler()->ProcessEvent(event);
     }
 
         return GetEventHandler()->ProcessEvent(event);
     }


@@ -696,285 +538,115 @@ bool wxToolBar::MSWCommand(WXUINT WXUNUSED(cmd), WXWORD id)
     return true;
 }
 
     return true;
 }
 

-bool wxToolBar::MSWOnNotify(int WXUNUSED(idCtrl),
-                            WXLPARAM lParam,
-                            WXLPARAM *WXUNUSED(result))
-{
-#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
-    wxUnusedVar(lParam);
-    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)
+WXLRESULT wxToolMenuBar::MSWWindowProc(WXUINT nMsg, WXWPARAM wParam, WXLPARAM lParam)

 {
 {

-    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);
-    }
-}
+#else

 
 

-static
-wxToolBarToolBase *GetItemSkippingDummySpacers(const wxToolBarToolsList& tools,
-                                               size_t index )
-{
-    wxToolBarToolsList::compatibility_iterator current = tools.GetFirst();
+////////////// For Smartphone

 
 

-    for ( ; current != 0; current = current->GetNext() )
-    {
-        if ( index == 0 )
-            return current->GetData();
-
-        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 WXUNUSED(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") );

 }
 
 }
 

-WXLRESULT 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
 #endif

-    return wxControl::MSWWindowProc(nMsg, wParam, lParam);
-}
-
-#endif // wxUSE_TOOLBAR && Win95
+    // !__SMARTPHONE__

 
 

+#endif // wxUSE_TOOLBAR