use wxCopyRectToRECT instead of duplicating it

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

diff --git a/src/msw/wince/tbarwce.cpp b/src/msw/wince/tbarwce.cpp
index a1be85a8c6ee174c7b5c412fc72c5624a13f9ffd..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,21 +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
 

-#if wxUSE_TOOLBAR && wxUSE_TOOLBAR_NATIVE
-
-#include "wx/toolbar.h"
-

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


@@ -53,90 +52,35 @@
 #include <tchar.h>
 #include <ole2.h>
 #include <shellapi.h>
 #include <tchar.h>
 #include <ole2.h>
 #include <shellapi.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
-
+#if defined(WINCE_WITHOUT_COMMANDBAR)
+  #include <aygshell.h>

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


@@ -149,12 +93,14 @@ public:
                             clientData, shortHelp, longHelp)
     {
         m_nSepCount = 0;
                             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_nSepCount = 1;

+        m_bitmapIndex = -1;

     }
 
     virtual void SetLabel(const wxString& label)
     }
 
     virtual void SetLabel(const wxString& label)


@@ -175,8 +121,12 @@ public:
     void SetSeparatorsCount(size_t count) { m_nSepCount = count; }
     size_t GetSeparatorsCount() const { return m_nSepCount; }
 
     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;
 private:
     size_t m_nSepCount;

+    int m_bitmapIndex;

 };
 
 
 };
 
 


@@ -188,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,


@@ -197,33 +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_hBitmap = 0;
+    wxToolBar::Init();

 
     m_nButtons = 0;
 
     m_nButtons = 0;

-
-    m_defaultWidth = DEFAULTBITMAPX;
-    m_defaultHeight = DEFAULTBITMAPY;
-
-    m_pInTool = 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,


@@ -233,36 +179,33 @@ bool wxToolBar::Create(wxWindow *parent,
 {
     // common initialisation
     if ( !CreateControl(parent, id, pos, size, style, wxDefaultValidator, name) )
 {
     // common initialisation
     if ( !CreateControl(parent, id, pos, size, style, wxDefaultValidator, name) )

-        return FALSE;
+        return false;

 
     // MSW-specific initialisation
     if ( !MSWCreateToolbar(pos, size, menuBar) )
 
     // 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));
 
 
     // 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);
 
 {
     SetMenuBar(menuBar);
     if (m_menuBar)
         m_menuBar->SetToolBar(this);
 

+#if defined(WINCE_WITHOUT_COMMANDBAR)

     // Create the menubar.
     SHMENUBARINFO mbi;
     // Create the menubar.
     SHMENUBARINFO mbi;

-    
+

     memset (&mbi, 0, sizeof (SHMENUBARINFO));
     mbi.cbSize     = sizeof (SHMENUBARINFO);
     mbi.hwndParent = (HWND) GetParent()->GetHWND();
     memset (&mbi, 0, sizeof (SHMENUBARINFO));
     mbi.cbSize     = sizeof (SHMENUBARINFO);
     mbi.hwndParent = (HWND) GetParent()->GetHWND();

-#if wxUSE_SMARTPHONE
+#ifdef __SMARTPHONE__

     mbi.nToolBarId = 5002;
 #else
     mbi.nToolBarId = 5000;
     mbi.nToolBarId = 5002;
 #else
     mbi.nToolBarId = 5000;


@@ -271,178 +214,68 @@ bool wxToolBar::MSWCreateToolbar(const wxPoint& pos, const wxSize& size, wxMenuB
     mbi.cBmpImages = 0;
     mbi.dwFlags = 0 ; // SHCMBF_EMPTYBAR;
     mbi.hInstRes = wxGetInstance();
     mbi.cBmpImages = 0;
     mbi.dwFlags = 0 ; // SHCMBF_EMPTYBAR;
     mbi.hInstRes = wxGetInstance();

-    
+

     if (!SHCreateMenuBar(&mbi))
     {
         wxFAIL_MSG( _T("SHCreateMenuBar failed") );
     if (!SHCreateMenuBar(&mbi))
     {
         wxFAIL_MSG( _T("SHCreateMenuBar failed") );

-        return FALSE;
+        return false;

     }
     }

-    
+

     SetHWND((WXHWND) mbi.hwndMB);
     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(), (HWND) GetParent()->GetHWND(), GetId());
+    SetHWND((WXHWND) hWnd);
+#endif
+
+    // install wxWidgets window proc for this window

     SubclassWin(m_hWnd);
 
     if (menuBar)
         menuBar->Create();
     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);
 {
     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
 }
 
 // Return HMENU for the menu associated with the commandbar

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

 {
 {

+#if defined(__HANDHELDPC__)
+    return 0;
+#else

     if (GetHWND())
     {
         return (WXHMENU) (HMENU)::SendMessage((HWND) GetHWND(), SHCMBM_GETMENU, (WPARAM)0, (LPARAM)0);
     }
     else
         return 0;
     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;
-        }
-    }
-
-    if ( style & wxTB_NODIVIDER )
-        msStyle |= CCS_NODIVIDER;
-
-    if ( style & wxTB_NOALIGN )
-        msStyle |= CCS_NOPARENTALIGN;
-
-    if ( style & wxTB_VERTICAL )
-        msStyle |= CCS_VERT;
-
-    return msStyle;
+#endif

 }
 
 // ----------------------------------------------------------------------------
 // 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
     tool->Attach(this);
 
 {
     // 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
 {
     // 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


@@ -465,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;

         }
     }
 
         }
     }
 


@@ -483,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;
     }


@@ -496,7 +329,7 @@ bool wxToolBar::DoDeleteTool(size_t pos, wxToolBarToolBase *tool)
         {
             wxLogLastError(wxT("TB_DELETEBUTTON"));
 
         {
             wxLogLastError(wxT("TB_DELETEBUTTON"));
 

-            return FALSE;
+            return false;

         }
     }
 
         }
     }
 


@@ -512,87 +345,22 @@ bool wxToolBar::DoDeleteTool(size_t pos, wxToolBarToolBase *tool)
             int x;
             wxControl *control = tool2->GetControl();
             control->GetPosition(&x, NULL);
             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
 {
     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++ )
 #if 0
     // delete all old buttons, if any
     for ( size_t pos = 0; pos < m_nButtons; pos++ )


@@ -602,39 +370,27 @@ bool wxToolBar::Realize()
             wxLogDebug(wxT("TB_DELETEBUTTON failed"));
         }
     }
             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() )
     {
     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);
 
 
         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
         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;
 
             case wxTOOL_STYLE_SEPARATOR:
                 button.fsState = TBSTATE_ENABLED;


@@ -642,8 +398,6 @@ bool wxToolBar::Realize()
                 break;
 
             case wxTOOL_STYLE_BUTTON:
                 break;
 
             case wxTOOL_STYLE_BUTTON:

-//                if ( !HasFlag(wxTB_NOICONS) )
-//                    button.iBitmap = bitmapId;

 
                 if ( HasFlag(wxTB_TEXT) )
                 {
 
                 if ( HasFlag(wxTB_TEXT) )
                 {


@@ -654,15 +408,36 @@ bool wxToolBar::Realize()
                     }
                 }
 
                     }
                 }
 

-                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;
 
                 if ( tool->IsEnabled() )
                     button.fsState |= TBSTATE_ENABLED;


@@ -681,10 +456,10 @@ bool wxToolBar::Realize()
                             // radio items
                             button.fsState |= TBSTATE_CHECKED;
 
                             // radio items
                             button.fsState |= TBSTATE_CHECKED;
 

-                            tool->Toggle(TRUE);
+                            tool->Toggle(true);

                         }
 
                         }
 

-                        isRadio = TRUE;
+                        isRadio = true;

                         break;
 
                     case wxITEM_CHECK:
                         break;
 
                     case wxITEM_CHECK:


@@ -698,188 +473,40 @@ bool wxToolBar::Realize()
                     case wxITEM_NORMAL:
                         button.fsStyle = TBSTYLE_BUTTON;
                 }
                     case wxITEM_NORMAL:
                         button.fsStyle = TBSTYLE_BUTTON;
                 }

-
-//                bitmapId++;

                 break;
         }
 
                 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();
-
-        wxSize size = control->GetSize();
-
-        // the position of the leftmost controls corner
-        int left = -1;
-
-        // 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 )
-        {
-            // 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) )
-            {
-                // the id is probably invalid?
-                wxLogLastError(wxT("TB_SETBUTTONINFO"));
-            }
-        }
-        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);
-        }
+        lastWasRadio = isRadio;

     }
     }

-#endif

 
 

-    return TRUE;
+    return true;

 }
 
 }
 

-// ----------------------------------------------------------------------------
-// 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);
     }


@@ -908,397 +535,118 @@ bool wxToolBar::MSWCommand(WXUINT WXUNUSED(cmd), WXWORD id)
         }
     }
 
         }
     }
 

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