check default library directories in WX_PATH_FIND_LIBRARIES; do *not* add default...

[wxWidgets.git] / src / motif / toolbar.cpp

diff --git a/src/motif/toolbar.cpp b/src/motif/toolbar.cpp
index b38f1c392981d3fa859a3da2cc5b1a2519ec16e7..4c685aada7802729bd7cc2700f647ff5173f44ab 100644 (file)
--- a/src/motif/toolbar.cpp
+++ b/src/motif/toolbar.cpp
@@ -17,18 +17,22 @@
 // headers
 // ----------------------------------------------------------------------------
 
 // headers
 // ----------------------------------------------------------------------------
 

-#ifdef __GNUG__
+#if defined(__GNUG__) && !defined(NO_GCC_PRAGMA)

     #pragma implementation "toolbar.h"
 #endif
 
     #pragma implementation "toolbar.h"
 #endif
 

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

 #ifdef __VMS
 #define XtDisplay XTDISPLAY
 #endif
 
 #ifdef __VMS
 #define XtDisplay XTDISPLAY
 #endif
 

-#include "wx/wx.h"
+#include "wx/settings.h"

 #include "wx/app.h"
 #include "wx/timer.h"
 #include "wx/toolbar.h"
 #include "wx/app.h"
 #include "wx/timer.h"
 #include "wx/toolbar.h"

+#include "wx/frame.h"

 
 #ifdef __VMS__
 #pragma message disable nosimpint
 
 #ifdef __VMS__
 #pragma message disable nosimpint


@@ -45,14 +49,13 @@
 #endif
 
 #include "wx/motif/private.h"
 #endif
 
 #include "wx/motif/private.h"

+#include "wx/motif/bmpmotif.h"

 
 // ----------------------------------------------------------------------------
 // wxWin macros
 // ----------------------------------------------------------------------------
 
 
 // ----------------------------------------------------------------------------
 // wxWin macros
 // ----------------------------------------------------------------------------
 

-#if !USE_SHARED_LIBRARY
-IMPLEMENT_DYNAMIC_CLASS(wxToolBar, wxToolBarBase)
-#endif
+IMPLEMENT_DYNAMIC_CLASS(wxToolBar, wxControl)

 
 // ----------------------------------------------------------------------------
 // private functions
 
 // ----------------------------------------------------------------------------
 // private functions


@@ -82,14 +85,15 @@ class wxToolBarTool : public wxToolBarToolBase
 public:
     wxToolBarTool(wxToolBar *tbar,
                   int id,
 public:
     wxToolBarTool(wxToolBar *tbar,
                   int id,

-                  const wxBitmap& bitmap1,
-                  const wxBitmap& bitmap2,
-                  bool toggle,
+                  const wxString& label,
+                  const wxBitmap& bmpNormal,
+                  const wxBitmap& bmpToggled,
+                  wxItemKind kind,

                   wxObject *clientData,
                   wxObject *clientData,

-                  const wxString& shortHelpString,
-                  const wxString& longHelpString)
-        : wxToolBarToolBase(tbar, id, bitmap1, bitmap2, toggle,
-                            clientData, shortHelpString, longHelpString)
+                  const wxString& shortHelp,
+                  const wxString& longHelp)
+        : wxToolBarToolBase(tbar, id, label, bmpNormal, bmpToggled, kind,
+                            clientData, shortHelp, longHelp)

     {
         Init();
     }
     {
         Init();
     }


@@ -106,14 +110,22 @@ public:
     void SetWidget(Widget widget) { m_widget = widget; }
     Widget GetButtonWidget() const { return m_widget; }
 
     void SetWidget(Widget widget) { m_widget = widget; }
     Widget GetButtonWidget() const { return m_widget; }
 

-    void SetPixmap(Pixmap pixmap) { m_pixmap = pixmap; }
-    Pixmap GetPixmap() const { return m_pixmap; }
+    Pixmap GetArmPixmap()
+    {
+        m_bitmapCache.SetBitmap( GetNormalBitmap() );
+        return (Pixmap)m_bitmapCache.GetArmPixmap( (WXWidget)m_widget );
+    }

 
 

+    Pixmap GetInsensPixmap()
+    {
+        m_bitmapCache.SetBitmap( GetNormalBitmap() );
+        return (Pixmap)m_bitmapCache.GetInsensPixmap( (WXWidget)m_widget );
+    }

 protected:
     void Init();
 
     Widget m_widget;
 protected:
     void Init();
 
     Widget m_widget;

-    Pixmap m_pixmap;
+    wxBitmapCache m_bitmapCache;

 };
 
 // ----------------------------------------------------------------------------
 };
 
 // ----------------------------------------------------------------------------


@@ -135,17 +147,19 @@ wxString wxToolBarTimer::helpString;
 // ----------------------------------------------------------------------------
 
 wxToolBarToolBase *wxToolBar::CreateTool(int id,
 // ----------------------------------------------------------------------------
 
 wxToolBarToolBase *wxToolBar::CreateTool(int id,

-                                         const wxBitmap& bitmap1,
-                                         const wxBitmap& bitmap2,
-                                         bool toggle,
+                                         const wxString& label,
+                                         const wxBitmap& bmpNormal,
+                                         const wxBitmap& bmpToggled,
+                                         wxItemKind kind,

                                          wxObject *clientData,
                                          wxObject *clientData,

-                                         const wxString& shortHelpString,
-                                         const wxString& longHelpString)
+                                         const wxString& shortHelp,
+                                         const wxString& longHelp)

 {
 {

-    return new wxToolBarTool(this, id, bitmap1, bitmap2, toggle,
-                             clientData, shortHelpString, longHelpString);
+    return new wxToolBarTool(this, id, label, bmpNormal, bmpToggled, kind,
+                             clientData, shortHelp, longHelp);

 }
 
 }
 

+

 wxToolBarToolBase *wxToolBar::CreateTool(wxControl *control)
 {
     return new wxToolBarTool(this, control);
 wxToolBarToolBase *wxToolBar::CreateTool(wxControl *control)
 {
     return new wxToolBarTool(this, control);


@@ -154,16 +168,12 @@ wxToolBarToolBase *wxToolBar::CreateTool(wxControl *control)
 void wxToolBarTool::Init()
 {
     m_widget = (Widget)0;
 void wxToolBarTool::Init()
 {
     m_widget = (Widget)0;

-    m_pixmap = (Pixmap)0;

 }
 
 wxToolBarTool::~wxToolBarTool()
 {
     if ( m_widget )
         XtDestroyWidget(m_widget);
 }
 
 wxToolBarTool::~wxToolBarTool()
 {
     if ( m_widget )
         XtDestroyWidget(m_widget);

-    if ( m_pixmap )
-        XmDestroyPixmap(DefaultScreenOfDisplay((Display*)wxGetDisplay()),
-                        m_pixmap);

 }
 
 // ----------------------------------------------------------------------------
 }
 
 // ----------------------------------------------------------------------------


@@ -191,18 +201,11 @@ bool wxToolBar::Create(wxWindow *parent,
                        long style,
                        const wxString& name)
 {
                        long style,
                        const wxString& name)
 {

-    Init();
-
-    m_windowId = id;
+    if( !wxControl::CreateControl( parent, id, pos, size, style,
+                                   wxDefaultValidator, name ) )
+        return false;

 
 

-    SetName(name);
-    m_backgroundColour = wxSystemSettings::GetSystemColour(wxSYS_COLOUR_3DFACE);
-    m_foregroundColour = parent->GetForegroundColour();
-    m_windowStyle = style;
-
-    SetParent(parent);
-
-    if (parent) parent->AddChild(this);
+    m_backgroundColour = wxSystemSettings::GetColour(wxSYS_COLOUR_3DFACE);

 
     Widget parentWidget = (Widget) parent->GetClientWidget();
 
 
     Widget parentWidget = (Widget) parent->GetClientWidget();
 


@@ -227,15 +230,22 @@ bool wxToolBar::Create(wxWindow *parent,
 
     m_mainWidget = (WXWidget) toolbar;
 
 
     m_mainWidget = (WXWidget) toolbar;
 

-    m_font = parent->GetFont();
-    ChangeFont(FALSE);
+    ChangeFont(false);
+
+    wxPoint rPos = pos;
+    wxSize  rSize = size;
+
+    if( rPos.x == -1 ) rPos.x = 0;
+    if( rPos.y == -1 ) rPos.y = 0;
+    if( rSize.x == -1 && GetParent() )
+        rSize.x = GetParent()->GetSize().x;

 
 

-    SetCanAddEventHandler(TRUE);
-    AttachWidget (parent, m_mainWidget, (WXWidget) NULL, pos.x, pos.y, size.x, size.y);
+    AttachWidget (parent, m_mainWidget, (WXWidget) NULL,
+                  rPos.x, rPos.y, rSize.x, rSize.y);

 
     ChangeBackgroundColour();
 
 
     ChangeBackgroundColour();
 

-    return TRUE;
+    return true;

 }
 
 wxToolBar::~wxToolBar()
 }
 
 wxToolBar::~wxToolBar()


@@ -249,9 +259,11 @@ bool wxToolBar::Realize()
     if ( m_tools.GetCount() == 0 )
     {
         // nothing to do
     if ( m_tools.GetCount() == 0 )
     {
         // nothing to do

-        return TRUE;
+        return true;

     }
 
     }
 

+    bool isVertical = GetWindowStyle() & wxTB_VERTICAL;
+

     // Separator spacing
     const int separatorSize = GetToolSeparation(); // 8;
     wxSize margins = GetToolMargins();
     // Separator spacing
     const int separatorSize = GetToolSeparation(); // 8;
     wxSize margins = GetToolMargins();


@@ -262,15 +274,13 @@ bool wxToolBar::Realize()
     int currentX = marginX;
     int currentY = marginY;
 
     int currentX = marginX;
     int currentY = marginY;
 

-    int buttonHeight = 0;
-
-    int currentSpacing = 0;
+    int buttonHeight = 0, buttonWidth = 0;

 
     Widget button;
     Pixmap pixmap, insensPixmap;
 
     Widget button;
     Pixmap pixmap, insensPixmap;

-    wxBitmap bmp;
+    wxBitmap bmp, insensBmp;

 
 

-    wxToolBarToolsList::Node *node = m_tools.GetFirst();
+    wxToolBarToolsList::compatibility_iterator node = m_tools.GetFirst();

     while ( node )
     {
         wxToolBarTool *tool = (wxToolBarTool *)node->GetData();
     while ( node )
     {
         wxToolBarTool *tool = (wxToolBarTool *)node->GetData();


@@ -282,19 +292,32 @@ bool wxToolBar::Realize()
                 wxControl* control = tool->GetControl();
                 wxSize sz = control->GetSize();
                 wxPoint pos = control->GetPosition();
                 wxControl* control = tool->GetControl();
                 wxSize sz = control->GetSize();
                 wxPoint pos = control->GetPosition();

-                control->Move(currentX, pos.y);
-                currentX += sz.x + packing;
+                // Allow a control to specify a y[x]-offset by setting
+                // its initial position, but still don't allow it to
+                // position itself above the top[left] margin.
+                int controlY = (pos.y > 0) ? pos.y : currentY;
+                int controlX = (pos.x > 0) ? pos.x : currentX;
+                control->Move( isVertical ? controlX : currentX,
+                               isVertical ? currentY : controlY );
+                if ( isVertical )
+                    currentY += sz.y + packing;
+                else
+                    currentX += sz.x + packing;

 
                 break;
             }
             case wxTOOL_STYLE_SEPARATOR:
 
                 break;
             }
             case wxTOOL_STYLE_SEPARATOR:

-                currentX += separatorSize;
+                // skip separators for vertical toolbars
+                if( !isVertical )
+                {
+                    currentX += separatorSize;
+                }

                 break;
 
             case wxTOOL_STYLE_BUTTON:
                 button = (Widget) 0;
 
                 break;
 
             case wxTOOL_STYLE_BUTTON:
                 button = (Widget) 0;
 

-                if ( tool->CanBeToggled() )
+                if ( tool->CanBeToggled() && !tool->GetButtonWidget() )

                 {
                     button = XtVaCreateWidget("toggleButton",
                             xmToggleButtonWidgetClass, (Widget) m_mainWidget,
                 {
                     button = XtVaCreateWidget("toggleButton",
                             xmToggleButtonWidgetClass, (Widget) m_mainWidget,


@@ -308,14 +331,18 @@ bool wxToolBar::Realize()
                             XmNmultiClick, XmMULTICLICK_KEEP,
                             XmNlabelType, XmPIXMAP,
                             NULL);
                             XmNmultiClick, XmMULTICLICK_KEEP,
                             XmNlabelType, XmPIXMAP,
                             NULL);

-                    XtAddCallback ((Widget) button, XmNvalueChangedCallback, (XtCallbackProc) wxToolButtonCallback,
-                            (XtPointer) this);
+                    XtAddCallback ((Widget) button,
+                                   XmNvalueChangedCallback,
+                                   (XtCallbackProc) wxToolButtonCallback,
+                                   (XtPointer) this);

 
                     XtVaSetValues ((Widget) button,
 
                     XtVaSetValues ((Widget) button,

-                            XmNselectColor, m_backgroundColour.AllocColour(XtDisplay((Widget) button)),
-                            NULL);
+                                   XmNselectColor,
+                                   m_backgroundColour.AllocColour
+                                       (XtDisplay((Widget) button)),
+                                   NULL);

                 }
                 }

-                else
+                else if( !tool->GetButtonWidget() )

                 {
                     button = XtVaCreateWidget("button",
                             xmPushButtonWidgetClass, (Widget) m_mainWidget,
                 {
                     button = XtVaCreateWidget("button",
                             xmPushButtonWidgetClass, (Widget) m_mainWidget,


@@ -325,31 +352,52 @@ bool wxToolBar::Realize()
                             XmNlabelType, XmPIXMAP,
                             NULL);
                     XtAddCallback (button,
                             XmNlabelType, XmPIXMAP,
                             NULL);
                     XtAddCallback (button,

-                            XmNactivateCallback, (XtCallbackProc) wxToolButtonCallback,
-                            (XtPointer) this);
+                                   XmNactivateCallback,
+                                   (XtCallbackProc) wxToolButtonCallback,
+                                   (XtPointer) this);

                 }
 
                 }
 

-                DoChangeBackgroundColour((WXWidget) button, m_backgroundColour, TRUE);
+                if( !tool->GetButtonWidget() )
+                {
+                    wxDoChangeBackgroundColour((WXWidget) button,
+                                               m_backgroundColour, true);

 
 

-                tool->SetWidget(button);
+                    tool->SetWidget(button);
+                }
+                else
+                {
+                    button = (Widget)tool->GetButtonWidget();
+                    XtVaSetValues( button,
+                                   XmNx, currentX, XmNy, currentY,
+                                   NULL );
+                }

 
                 // For each button, if there is a mask, we must create
                 // a new wxBitmap that has the correct background colour
                 // for the button. Otherwise the background will just be
                 // e.g. black if a transparent XPM has been loaded.
 
                 // For each button, if there is a mask, we must create
                 // a new wxBitmap that has the correct background colour
                 // for the button. Otherwise the background will just be
                 // e.g. black if a transparent XPM has been loaded.

-                bmp = tool->GetBitmap1();
-                if ( bmp.GetMask() )
+                bmp = tool->GetNormalBitmap();
+                insensBmp = tool->GetDisabledBitmap();
+                if ( bmp.GetMask() || insensBmp.GetMask() )

                 {
                     int backgroundPixel;
                     XtVaGetValues(button, XmNbackground, &backgroundPixel,
                 {
                     int backgroundPixel;
                     XtVaGetValues(button, XmNbackground, &backgroundPixel,

-                            NULL);
+                                  NULL);

 
                     wxColour col;
                     col.SetPixel(backgroundPixel);
 
 
                     wxColour col;
                     col.SetPixel(backgroundPixel);
 

-                    bmp = wxCreateMaskedBitmap(bmp, col);
+                    if( bmp.Ok() && bmp.GetMask() )
+                    {
+                        bmp = wxCreateMaskedBitmap(bmp, col);
+                        tool->SetNormalBitmap(bmp);
+                    }

 
 

-                    tool->SetBitmap1(bmp);
+                    if( insensBmp.Ok() && insensBmp.GetMask() )
+                    {
+                        insensBmp = wxCreateMaskedBitmap(insensBmp, col);
+                        tool->SetDisabledBitmap(insensBmp);
+                    }

                 }
 
                 // Create a selected/toggled bitmap. If there isn't a 2nd
                 }
 
                 // Create a selected/toggled bitmap. If there isn't a 2nd


@@ -358,56 +406,27 @@ bool wxToolBar::Realize()
                 int backgroundPixel;
                 if ( tool->CanBeToggled() )
                     XtVaGetValues(button, XmNselectColor, &backgroundPixel,
                 int backgroundPixel;
                 if ( tool->CanBeToggled() )
                     XtVaGetValues(button, XmNselectColor, &backgroundPixel,

-                            NULL);
+                                  NULL);

                 else
                     XtVaGetValues(button, XmNarmColor, &backgroundPixel,
                 else
                     XtVaGetValues(button, XmNarmColor, &backgroundPixel,

-                            NULL);
-
+                                  NULL);

                 wxColour col;
                 col.SetPixel(backgroundPixel);
 
                 wxColour col;
                 col.SetPixel(backgroundPixel);
 

-                if (tool->GetBitmap2().Ok() && tool->GetBitmap2().GetMask())
+                pixmap = (Pixmap) bmp.GetDrawable();

                 {
                 {

-                    // Use what's there
-                    wxBitmap newBitmap = wxCreateMaskedBitmap(tool->GetBitmap2(), col);
-                    tool->SetBitmap2(newBitmap);
-                }
-                else
-                {
-                    // Use unselected bitmap
-                    if ( bmp.GetMask() )
-                    {
-                        wxBitmap newBitmap = wxCreateMaskedBitmap(bmp, col);
-                        tool->SetBitmap2(newBitmap);
-                    }
-                    else
-                        tool->SetBitmap2(bmp);
-                }
-
-                pixmap = (Pixmap) bmp.GetPixmap();
-                insensPixmap = (Pixmap) bmp.GetInsensPixmap();
+                    wxBitmap tmp = tool->GetDisabledBitmap();

 
 

+                    insensPixmap = tmp.Ok() ?
+                            (Pixmap)tmp.GetDrawable() :
+                            tool->GetInsensPixmap();
+                }
+                

                 if (tool->CanBeToggled())
                 {
                     // Toggle button
                 if (tool->CanBeToggled())
                 {
                     // Toggle button

-                    Pixmap pixmap2 = (Pixmap) 0;
-                    Pixmap insensPixmap2 = (Pixmap) 0;
-
-                    // If there's a bitmap for the toggled state, use it,
-                    // otherwise generate one.
-                    if (tool->GetBitmap2().Ok())
-                    {
-                        wxBitmap bmp2 = tool->GetBitmap2();
-                        pixmap2 = (Pixmap) bmp2.GetPixmap();
-                        insensPixmap2 = (Pixmap) bmp2.GetInsensPixmap();
-                    }
-                    else
-                    {
-                        pixmap2 = (Pixmap) bmp.GetArmPixmap(button);
-                        insensPixmap2 = XCreateInsensitivePixmap((Display*) wxGetDisplay(), pixmap2);
-                    }
-
-                    tool->SetPixmap(pixmap2);
+                    Pixmap pixmap2 = tool->GetArmPixmap();
+                    Pixmap insensPixmap2 = tool->GetInsensPixmap();

 
                     XtVaSetValues (button,
                             XmNfillOnSelect, True,
 
                     XtVaSetValues (button,
                             XmNfillOnSelect, True,


@@ -420,21 +439,7 @@ bool wxToolBar::Realize()
                 }
                 else
                 {
                 }
                 else
                 {

-                    Pixmap pixmap2 = (Pixmap) 0;
-
-                    // If there's a bitmap for the armed state, use it,
-                    // otherwise generate one.
-                    if (tool->GetBitmap2().Ok())
-                    {
-                        pixmap2 = (Pixmap) tool->GetBitmap2().GetPixmap();
-                    }
-                    else
-                    {
-                        pixmap2 = (Pixmap) bmp.GetArmPixmap(button);
-
-                    }
-
-                    tool->SetPixmap(pixmap2);
+                    Pixmap pixmap2 = tool->GetArmPixmap();

 
                     // Normal button
                     XtVaSetValues(button,
 
                     // Normal button
                     XtVaSetValues(button,


@@ -452,23 +457,28 @@ bool wxToolBar::Realize()
                                   XmNwidth, &width,
                                   XmNheight, & height,
                                   NULL);
                                   XmNwidth, &width,
                                   XmNheight, & height,
                                   NULL);

-                    currentX += width + packing;
+                    if ( isVertical )
+                        currentY += height + packing;
+                    else
+                        currentX += width + packing;

                     buttonHeight = wxMax(buttonHeight, height);
                     buttonHeight = wxMax(buttonHeight, height);

+                    buttonWidth = wxMax(buttonWidth, width);

                 }
 
                 XtAddEventHandler (button, EnterWindowMask | LeaveWindowMask,
                         False, wxToolButtonPopupCallback, (XtPointer) this);
 
                 }
 
                 XtAddEventHandler (button, EnterWindowMask | LeaveWindowMask,
                         False, wxToolButtonPopupCallback, (XtPointer) this);
 

-                currentSpacing = 0;

                 break;
         }
 
         node = node->GetNext();
     }
 
                 break;
         }
 
         node = node->GetNext();
     }
 

-    SetSize(-1, -1, currentX, buttonHeight + 2*marginY);
+    SetSize( -1, -1,
+             isVertical ? buttonWidth + 2 * marginX : -1,
+             isVertical ? -1 : buttonHeight +  2*marginY );

 
 

-    return TRUE;
+    return true;

 }
 
 wxToolBarToolBase *wxToolBar::FindToolForPosition(wxCoord WXUNUSED(x),
 }
 
 wxToolBarToolBase *wxToolBar::FindToolForPosition(wxCoord WXUNUSED(x),


@@ -483,21 +493,106 @@ bool wxToolBar::DoInsertTool(size_t WXUNUSED(pos), wxToolBarToolBase *tool)
 {
     tool->Attach(this);
 
 {
     tool->Attach(this);
 

-    return TRUE;
+    return true;

 }
 
 }
 

-bool wxToolBar::DoDeleteTool(size_t WXUNUSED(pos), wxToolBarToolBase *tool)
+bool wxToolBar::DoDeleteTool(size_t pos, wxToolBarToolBase *tool)

 {
     tool->Detach();
 
 {
     tool->Detach();
 

-    return TRUE;
+    bool isVertical = GetWindowStyle() & wxTB_VERTICAL;
+    const int separatorSize = GetToolSeparation(); // 8;
+    int packing = GetToolPacking();
+    int offset = 0;
+
+    for( wxToolBarToolsList::compatibility_iterator node = m_tools.GetFirst();
+         node; node = node->GetNext() )
+    {
+        wxToolBarTool *t = (wxToolBarTool*)node->GetData();
+
+        if( t == tool )
+        {
+            switch ( t->GetStyle() )
+            {
+            case wxTOOL_STYLE_CONTROL:
+            {
+                wxSize size = t->GetControl()->GetSize();
+                offset = isVertical ? size.y : size.x;
+                offset += packing;
+                break;
+            }       
+            case wxTOOL_STYLE_SEPARATOR:
+                offset = isVertical ? 0 : separatorSize;
+                break;
+            case wxTOOL_STYLE_BUTTON:
+            {
+                Widget w = t->GetButtonWidget();
+                Dimension width, height;
+
+                XtVaGetValues( w,
+                               XmNwidth, &width,
+                               XmNheight, &height,
+                               NULL );
+
+                offset = isVertical ? height : width;
+                offset += packing;
+                break;
+            }
+            }
+        }
+        else if( offset )
+        {
+            switch ( t->GetStyle() )
+            {
+            case wxTOOL_STYLE_CONTROL:
+            {
+                wxPoint pos = t->GetControl()->GetPosition();
+
+                if( isVertical )
+                    pos.y -= offset;
+                else
+                    pos.x -= offset;
+
+                t->GetControl()->Move( pos );
+                break;
+            }
+            case wxTOOL_STYLE_SEPARATOR:
+                break;
+            case wxTOOL_STYLE_BUTTON:
+            {
+                Dimension x, y;
+                XtVaGetValues( t->GetButtonWidget(),
+                               XmNx, &x,
+                               XmNy, &y,
+                               NULL );
+
+                if( isVertical )
+                    y -= offset;
+                else
+                    x -= offset;
+
+                XtVaSetValues( t->GetButtonWidget(),
+                               XmNx, x,
+                               XmNy, y,
+                               NULL );
+                break;
+            }
+            }
+        }
+    }
+
+    return true;

 }
 
 void wxToolBar::DoEnableTool(wxToolBarToolBase *toolBase, bool enable)
 {
     wxToolBarTool *tool = (wxToolBarTool *)toolBase;
 }
 
 void wxToolBar::DoEnableTool(wxToolBarToolBase *toolBase, bool enable)
 {
     wxToolBarTool *tool = (wxToolBarTool *)toolBase;

-
-    XtSetSensitive(tool->GetButtonWidget(), (Boolean) enable);
+    if (tool->GetButtonWidget()){
+        XtSetSensitive(tool->GetButtonWidget(), (Boolean) enable);
+    } else if (wxTOOL_STYLE_CONTROL == tool->GetStyle()){
+        // Controls (such as wxChoice) do not have button widgets
+        tool->GetControl()->Enable(enable);
+    }

 }
 
 void wxToolBar::DoToggleTool(wxToolBarToolBase *toolBase, bool toggle)
 }
 
 void wxToolBar::DoToggleTool(wxToolBarToolBase *toolBase, bool toggle)


@@ -513,13 +608,45 @@ void wxToolBar::DoSetToggle(wxToolBarToolBase * WXUNUSED(tool),
     // nothing to do
 }
 
     // nothing to do
 }
 

+void wxToolBar::DoSetSize(int x, int y, int width, int height, int sizeFlags)
+{
+    int old_width, old_height;
+    GetSize(&old_width, &old_height);
+
+    // Correct width and height if needed.
+    if ( width == -1 || height == -1 )
+    {
+        wxSize defaultSize = GetSize();
+
+        if ( width == -1 )
+            width = defaultSize.x;
+        if ( height == -1 )
+            height = defaultSize.y;
+    }
+
+    wxToolBarBase::DoSetSize(x, y, width, height, sizeFlags);
+  
+    // We must refresh the frame size when the toolbar changes size
+    // otherwise the toolbar can be shown incorrectly
+    if ( old_width != width || old_height != height )
+    {
+        // But before we send the size event check it 
+        // we have a frame that is not being deleted.
+        wxFrame *frame = wxDynamicCast(GetParent(), wxFrame);
+        if ( frame && !frame->IsBeingDeleted() )
+        {
+            frame->SendSizeEvent();
+        }
+    }
+}
+

 // ----------------------------------------------------------------------------
 // Motif callbacks
 // ----------------------------------------------------------------------------
 
 wxToolBarToolBase *wxToolBar::FindToolByWidget(WXWidget w) const
 {
 // ----------------------------------------------------------------------------
 // Motif callbacks
 // ----------------------------------------------------------------------------
 
 wxToolBarToolBase *wxToolBar::FindToolByWidget(WXWidget w) const
 {

-    wxToolBarToolsList::Node* node = m_tools.GetFirst();
+    wxToolBarToolsList::compatibility_iterator node = m_tools.GetFirst();

     while ( node )
     {
         wxToolBarTool *tool = (wxToolBarTool *)node->GetData();
     while ( node )
     {
         wxToolBarTool *tool = (wxToolBarTool *)node->GetData();


@@ -591,7 +718,7 @@ static void wxToolButtonPopupCallback(Widget w,
         wxToolBarTimer::help_popup = (Widget) 0;
 
         // One shot
         wxToolBarTimer::help_popup = (Widget) 0;
 
         // One shot

-        wxTheToolBarTimer->Start(delayMilli, TRUE);
+        wxTheToolBarTimer->Start(delayMilli, true);

 
     }
     /************************************************************/
 
     }
     /************************************************************/