[ 1216436 ] cleanup 'shadow variable' warnings from gcc in headers.

[wxWidgets.git] / src / univ / themes / win32.cpp

diff --git a/src/univ/themes/win32.cpp b/src/univ/themes/win32.cpp
index ef654c4ad56609a8600bb0e1b758f42e0c2ef06d..ed3e0f8d58c6c6a47dcb56068c930f418026999d 100644 (file)
--- a/src/univ/themes/win32.cpp
+++ b/src/univ/themes/win32.cpp
@@ -1,3 +1,4 @@
+///////////////////////////////////////////////////////////////////////////////

 // Name:        univ/themes/win32.cpp
 // Purpose:     wxUniversal theme implementing Win32-like LNF
 // Author:      Vadim Zeitlin
 // Name:        univ/themes/win32.cpp
 // Purpose:     wxUniversal theme implementing Win32-like LNF
 // Author:      Vadim Zeitlin


@@ -32,13 +33,16 @@
     #include "wx/dcmemory.h"
 
     #include "wx/button.h"
     #include "wx/dcmemory.h"
 
     #include "wx/button.h"

+    #include "wx/bmpbuttn.h"

     #include "wx/listbox.h"
     #include "wx/checklst.h"
     #include "wx/combobox.h"
     #include "wx/scrolbar.h"
     #include "wx/slider.h"
     #include "wx/textctrl.h"
     #include "wx/listbox.h"
     #include "wx/checklst.h"
     #include "wx/combobox.h"
     #include "wx/scrolbar.h"
     #include "wx/slider.h"
     #include "wx/textctrl.h"

+    #include "wx/listbox.h"

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

+    #include "wx/statusbr.h"

 
     #ifdef __WXMSW__
         // for COLOR_* constants
 
     #ifdef __WXMSW__
         // for COLOR_* constants


@@ -52,6 +56,7 @@
 #include "wx/menu.h"
 #include "wx/artprov.h"
 #include "wx/toplevel.h"
 #include "wx/menu.h"
 #include "wx/artprov.h"
 #include "wx/toplevel.h"

+#include "wx/image.h"

 
 #include "wx/univ/scrtimer.h"
 #include "wx/univ/renderer.h"
 
 #include "wx/univ/scrtimer.h"
 #include "wx/univ/renderer.h"


@@ -106,6 +111,7 @@ enum IndicatorStatus
 {
     IndicatorStatus_Checked,
     IndicatorStatus_Unchecked,
 {
     IndicatorStatus_Checked,
     IndicatorStatus_Unchecked,

+    IndicatorStatus_Undeterminated,

     IndicatorStatus_Max
 };
 
     IndicatorStatus_Max
 };
 


@@ -130,8 +136,8 @@ public:
         Arrow_Normal,
         Arrow_Disabled,
         Arrow_Pressed,
         Arrow_Normal,
         Arrow_Disabled,
         Arrow_Pressed,

-        Arrow_Inversed,
-        Arrow_InversedDisabled,
+        Arrow_Inverted,
+        Arrow_InvertedDisabled,

         Arrow_StateMax
     };
 
         Arrow_StateMax
     };
 


@@ -298,7 +304,7 @@ public:
     virtual void DrawStatusField(wxDC& dc,
                                  const wxRect& rect,
                                  const wxString& label,
     virtual void DrawStatusField(wxDC& dc,
                                  const wxRect& rect,
                                  const wxString& label,

-                                 int flags = 0);
+                                 int flags = 0, int style = 0);

 
     // titlebars
     virtual void DrawFrameTitleBar(wxDC& dc,
 
     // titlebars
     virtual void DrawFrameTitleBar(wxDC& dc,


@@ -441,7 +447,7 @@ protected:
     void DrawSunkenBorder(wxDC& dc, wxRect *rect);
 
     // draw the border used for scrollbar arrows
     void DrawSunkenBorder(wxDC& dc, wxRect *rect);
 
     // draw the border used for scrollbar arrows

-    void DrawArrowBorder(wxDC& dc, wxRect *rect, bool isPressed = FALSE);
+    void DrawArrowBorder(wxDC& dc, wxRect *rect, bool isPressed = false);

 
     // public DrawArrow()s helper
     void DrawArrow(wxDC& dc, const wxRect& rect,
 
     // public DrawArrow()s helper
     void DrawArrow(wxDC& dc, const wxRect& rect,


@@ -467,7 +473,7 @@ protected:
     void DrawLine(wxDC& dc,
                   wxCoord x1, wxCoord y1,
                   wxCoord x2, wxCoord y2,
     void DrawLine(wxDC& dc,
                   wxCoord x1, wxCoord y1,
                   wxCoord x2, wxCoord y2,

-                  bool transpose = FALSE)
+                  bool transpose = false)

     {
         if ( transpose )
             dc.DrawLine(y1, x1, y2, x2);
     {
         if ( transpose )
             dc.DrawLine(y1, x1, y2, x2);


@@ -549,7 +555,8 @@ public:
 protected:
     virtual bool IsAllowedButton(int button) { return button == 1; }
 
 protected:
     virtual bool IsAllowedButton(int button) { return button == 1; }
 

-    virtual void Highlight(wxScrollBar *scrollbar, bool doIt)
+    virtual void Highlight(wxScrollBar * WXUNUSED(scrollbar),
+                           bool WXUNUSED(doIt))

     {
         // we don't highlight anything
     }
     {
         // we don't highlight anything
     }


@@ -622,7 +629,7 @@ public:
                              const wxMouseEvent& event);
 
     virtual bool HandleActivation(wxInputConsumer *consumer, bool activated);
                              const wxMouseEvent& event);
 
     virtual bool HandleActivation(wxInputConsumer *consumer, bool activated);

-                             
+

     void PopupSystemMenu(wxTopLevelWindow *window, const wxPoint& pos) const;
 
 private:
     void PopupSystemMenu(wxTopLevelWindow *window, const wxPoint& pos) const;
 
 private:


@@ -657,7 +664,7 @@ protected:
 // wxWin32Theme
 // ----------------------------------------------------------------------------
 
 // wxWin32Theme
 // ----------------------------------------------------------------------------
 

-WX_DEFINE_ARRAY(wxInputHandler *, wxArrayHandlers);
+WX_DEFINE_ARRAY_PTR(wxInputHandler *, wxArrayHandlers);

 
 class wxWin32Theme : public wxTheme
 {
 
 class wxWin32Theme : public wxTheme
 {


@@ -675,7 +682,7 @@ private:
     wxInputHandler *GetDefaultInputHandler();
 
     wxWin32Renderer *m_renderer;
     wxInputHandler *GetDefaultInputHandler();
 
     wxWin32Renderer *m_renderer;

-    
+

     wxWin32ArtProvider *m_artProvider;
 
     // the names of the already created handlers and the handlers themselves
     wxWin32ArtProvider *m_artProvider;
 
     // the names of the already created handlers and the handlers themselves


@@ -1004,6 +1011,54 @@ static const char *unchecked_item_xpm[] = {
 "wwwwwwwwwwwww"
 };
 
 "wwwwwwwwwwwww"
 };
 

+static const char *undetermined_xpm[] = {
+/* columns rows colors chars-per-pixel */
+"13 13 5 1",
+"A c #030303",
+"B c #838383",
+"C c #C3C3C3",
+"D c #FBFBFB",
+"E c #DBDBDB",
+/* pixels */
+"BBBBBBBBBBBBD",
+"BAAAAAAAAAAED",
+"BACDCDCDCDCED",
+"BADCDCDCDBDED",
+"BACDCDCDBBCED",
+"BADBDCEBBBDED",
+"BACBBDBBBDCED",
+"BADBBBBBDCDED",
+"BACDBBBDCDCED",
+"BADCDBDCDCDED",
+"BACDCDCDCDCED",
+"BEEEEEEEEEEED",
+"DDDDDDDDDDDDD"
+};
+
+static const char *pressed_undetermined_xpm[] = {
+/* columns rows colors chars-per-pixel */
+"13 13 5 1",
+"A c #040404",
+"B c #848484",
+"C c #C4C4C4",
+"D c #FCFCFC",
+"E c #DCDCDC",
+/* pixels */
+"BBBBBBBBBBBBD",
+"BAAAAAAAAAAED",
+"BACCCCCCCCCCD",
+"BACCCCCCCACED",
+"BACCCCCCAACED",
+"BACACCCAAACED",
+"BACAACAAACCED",
+"BACAAAAACCCED",
+"BACCAAACCCCCD",
+"BACCCACCCCCED",
+"BACCCCCCCCCED",
+"BEEEEEEEEEEED",
+"DDDDDDDDDDDDD"
+};
+

 static const char *checked_radio_xpm[] = {
 /* columns rows colors chars-per-pixel */
 "12 12 6 1",
 static const char *checked_radio_xpm[] = {
 /* columns rows colors chars-per-pixel */
 "12 12 6 1",


@@ -1130,40 +1185,40 @@ static const char **
     // checkboxes first
     {
         // normal state
     // checkboxes first
     {
         // normal state

-        { checked_xpm, unchecked_xpm },
+        { checked_xpm, unchecked_xpm, undetermined_xpm },

 
         // pressed state
 
         // pressed state

-        { pressed_checked_xpm, pressed_unchecked_xpm },
+        { pressed_checked_xpm, pressed_unchecked_xpm, pressed_undetermined_xpm },

 
         // disabled state
 
         // disabled state

-        { pressed_disabled_checked_xpm, pressed_unchecked_xpm },
+        { pressed_disabled_checked_xpm, pressed_unchecked_xpm, pressed_disabled_checked_xpm },

     },
 
     // radio
     {
         // normal state
     },
 
     // radio
     {
         // normal state

-        { checked_radio_xpm, unchecked_radio_xpm },
+        { checked_radio_xpm, unchecked_radio_xpm, NULL },

 
         // pressed state
 
         // pressed state

-        { pressed_checked_radio_xpm, pressed_unchecked_radio_xpm },
+        { pressed_checked_radio_xpm, pressed_unchecked_radio_xpm, NULL },

 
         // disabled state
 
         // disabled state

-        { pressed_disabled_checked_radio_xpm, pressed_unchecked_radio_xpm },
+        { pressed_disabled_checked_radio_xpm, pressed_unchecked_radio_xpm, NULL },

     },
 
     // menu
     {
         // normal state
     },
 
     // menu
     {
         // normal state

-        { checked_menu_xpm, NULL },
+        { checked_menu_xpm, NULL, NULL },

 
         // selected state
 
         // selected state

-        { selected_checked_menu_xpm, NULL },
+        { selected_checked_menu_xpm, NULL, NULL },

 
         // disabled state
 
         // disabled state

-        { disabled_checked_menu_xpm, NULL },
+        { disabled_checked_menu_xpm, NULL, NULL },

 
         // disabled selected state
 
         // disabled selected state

-        { selected_disabled_checked_menu_xpm, NULL },
+        { selected_disabled_checked_menu_xpm, NULL, NULL },

     }
 };
 
     }
 };
 


@@ -1329,21 +1384,32 @@ wxColour wxWin32ColourScheme::GetBackground(wxWindow *win) const
         col = win->GetBackgroundColour();
     }
 
         col = win->GetBackgroundColour();
     }
 

-    if ( win->IsContainerWindow() )
+    if ( !win->ShouldInheritColours() )

     {
         wxTextCtrl *text = wxDynamicCast(win, wxTextCtrl);
     {
         wxTextCtrl *text = wxDynamicCast(win, wxTextCtrl);

-        if ( text )
+#if wxUSE_LISTBOX
+        wxListBox* listBox = wxDynamicCast(win, wxListBox);
+#endif
+        if ( text
+#if wxUSE_LISTBOX
+         || listBox
+#endif
+          )

         {
         {

-            if ( !text->IsEnabled() ) // not IsEditable()
+            if ( !win->IsEnabled() ) // not IsEditable()

                 col = Get(CONTROL);
                 col = Get(CONTROL);

-            //else: execute code below
+            else
+            {
+                if ( !col.Ok() )
+                {
+                    // doesn't depend on the state
+                    col = Get(WINDOW);
+                }
+            }

         }
 
         }
 

-        if ( !col.Ok() )
-        {
-            // doesn't depend on the state
-            col = Get(WINDOW);
-        }
+        if (!col.Ok())
+            col = Get(CONTROL); // Most controls should be this colour, not WINDOW

     }
     else
     {
     }
     else
     {


@@ -1611,31 +1677,31 @@ wxWin32Renderer::wxWin32Renderer(const wxColourScheme *scheme)
 
         }
 
 
         }
 

-        // create the inversed bitmap but only for the right arrow as we only
+        // create the inverted bitmap but only for the right arrow as we only

         // use it for the menus
         if ( n == Arrow_Right )
         {
         // use it for the menus
         if ( n == Arrow_Right )
         {

-            m_bmpArrows[Arrow_Inversed][n].Create(w, h);
-            dcInverse.SelectObject(m_bmpArrows[Arrow_Inversed][n]);
+            m_bmpArrows[Arrow_Inverted][n].Create(w, h);
+            dcInverse.SelectObject(m_bmpArrows[Arrow_Inverted][n]);

             dcInverse.Clear();
             dcInverse.Blit(0, 0, w, h,
                           &dcNormal, 0, 0,
                           wxXOR);
             dcInverse.SelectObject(wxNullBitmap);
 
             dcInverse.Clear();
             dcInverse.Blit(0, 0, w, h,
                           &dcNormal, 0, 0,
                           wxXOR);
             dcInverse.SelectObject(wxNullBitmap);
 

-            mask = new wxMask(m_bmpArrows[Arrow_Inversed][n], *wxBLACK);
-            m_bmpArrows[Arrow_Inversed][n].SetMask(mask);
+            mask = new wxMask(m_bmpArrows[Arrow_Inverted][n], *wxBLACK);
+            m_bmpArrows[Arrow_Inverted][n].SetMask(mask);

 
 

-            m_bmpArrows[Arrow_InversedDisabled][n].Create(w, h);
-            dcInverse.SelectObject(m_bmpArrows[Arrow_InversedDisabled][n]);
+            m_bmpArrows[Arrow_InvertedDisabled][n].Create(w, h);
+            dcInverse.SelectObject(m_bmpArrows[Arrow_InvertedDisabled][n]);

             dcInverse.Clear();
             dcInverse.Blit(0, 0, w, h,
                           &dcDisabled, 0, 0,
                           wxXOR);
             dcInverse.SelectObject(wxNullBitmap);
 
             dcInverse.Clear();
             dcInverse.Blit(0, 0, w, h,
                           &dcDisabled, 0, 0,
                           wxXOR);
             dcInverse.SelectObject(wxNullBitmap);
 

-            mask = new wxMask(m_bmpArrows[Arrow_InversedDisabled][n], *wxBLACK);
-            m_bmpArrows[Arrow_InversedDisabled][n].SetMask(mask);
+            mask = new wxMask(m_bmpArrows[Arrow_InvertedDisabled][n], *wxBLACK);
+            m_bmpArrows[Arrow_InvertedDisabled][n].SetMask(mask);

         }
 
         dcNormal.SelectObject(wxNullBitmap);
         }
 
         dcNormal.SelectObject(wxNullBitmap);


@@ -1879,7 +1945,7 @@ wxRect wxWin32Renderer::GetBorderDimensions(wxBorder border) const
             break;
 
         default:
             break;
 
         default:

-        { 
+        {

             // char *crash = NULL;
             // *crash = 0;
             wxFAIL_MSG(_T("unknown border type"));
             // char *crash = NULL;
             // *crash = 0;
             wxFAIL_MSG(_T("unknown border type"));


@@ -1903,7 +1969,7 @@ wxRect wxWin32Renderer::GetBorderDimensions(wxBorder border) const
 
 bool wxWin32Renderer::AreScrollbarsInsideBorder() const
 {
 
 bool wxWin32Renderer::AreScrollbarsInsideBorder() const
 {

-    return TRUE;
+    return true;

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


@@ -2270,7 +2336,7 @@ void wxWin32Renderer::DrawCheckItem(wxDC& dc,
     }
 
     dc.DrawBitmap(bmp, rect.x, rect.y + (rect.height - bmp.GetHeight()) / 2 - 1,
     }
 
     dc.DrawBitmap(bmp, rect.x, rect.y + (rect.height - bmp.GetHeight()) / 2 - 1,

-                  TRUE /* use mask */);
+                  true /* use mask */);

 
     wxRect rectLabel = rect;
     int bmpWidth = bmp.GetWidth();
 
     wxRect rectLabel = rect;
     int bmpWidth = bmp.GetWidth();


@@ -2299,7 +2365,9 @@ wxBitmap wxWin32Renderer::GetIndicator(IndicatorType indType, int flags)
 
     IndicatorStatus indStatus = flags & wxCONTROL_CHECKED
                                     ? IndicatorStatus_Checked
 
     IndicatorStatus indStatus = flags & wxCONTROL_CHECKED
                                     ? IndicatorStatus_Checked

-                                    : IndicatorStatus_Unchecked;
+                                    : ( flags & wxCONTROL_UNDETERMINED
+                                          ? IndicatorStatus_Undeterminated
+                                          : IndicatorStatus_Unchecked );

 
     wxBitmap bmp = m_bmpIndicators[indType][indState][indStatus];
     if ( !bmp.Ok() )
 
     wxBitmap bmp = m_bmpIndicators[indType][indState][indStatus];
     if ( !bmp.Ok() )


@@ -2351,7 +2419,7 @@ void wxWin32Renderer::DrawCheckOrRadioButton(wxDC& dc,
         rectLabel.SetRight(rect.GetRight());
     }
 
         rectLabel.SetRight(rect.GetRight());
     }
 

-    dc.DrawBitmap(bitmap, xBmp, yBmp, TRUE /* use mask */);
+    dc.DrawBitmap(bitmap, xBmp, yBmp, true /* use mask */);

 
     DoDrawLabel(
                 dc, label, rectLabel,
 
     DoDrawLabel(
                 dc, label, rectLabel,


@@ -2453,7 +2521,9 @@ void wxWin32Renderer::DrawTextLine(wxDC& dc,
     StandardDrawTextLine(dc, text, rect, selStart, selEnd, flags);
 }
 
     StandardDrawTextLine(dc, text, rect, selStart, selEnd, flags);
 }
 

-void wxWin32Renderer::DrawLineWrapMark(wxDC& dc, const wxRect& rect)
+void
+wxWin32Renderer::DrawLineWrapMark(wxDC& WXUNUSED(dc),
+                                  const wxRect& WXUNUSED(rect))

 {
     // we don't draw them
 }
 {
     // we don't draw them
 }


@@ -2470,13 +2540,23 @@ void wxWin32Renderer::DrawTab(wxDC& dc,
                               int flags,
                               int indexAccel)
 {
                               int flags,
                               int indexAccel)
 {

+    #define SELECT_FOR_VERTICAL(X,Y) ( isVertical ? Y : X )
+    #define REVERSE_FOR_VERTICAL(X,Y) \
+        SELECT_FOR_VERTICAL(X,Y)      \
+        ,                             \
+        SELECT_FOR_VERTICAL(Y,X)
+

     wxRect rect = rectOrig;
 
     wxRect rect = rectOrig;
 

+    bool isVertical = ( dir == wxLEFT ) || ( dir == wxRIGHT );
+

     // the current tab is drawn indented (to the top for default case) and
     // bigger than the other ones
     const wxSize indent = GetTabIndent();
     if ( flags & wxCONTROL_SELECTED )
     {
     // the current tab is drawn indented (to the top for default case) and
     // bigger than the other ones
     const wxSize indent = GetTabIndent();
     if ( flags & wxCONTROL_SELECTED )
     {

+        rect.Inflate( SELECT_FOR_VERTICAL( indent.x , 0),
+                      SELECT_FOR_VERTICAL( 0, indent.y ));

         switch ( dir )
         {
             default:
         switch ( dir )
         {
             default:


@@ -2484,115 +2564,162 @@ void wxWin32Renderer::DrawTab(wxDC& dc,
                 // fall through
 
             case wxTOP:
                 // fall through
 
             case wxTOP:

-                rect.Inflate(indent.x, 0);

                 rect.y -= indent.y;
                 rect.y -= indent.y;

-                rect.height += indent.y;
-                break;
-
+                // fall through

             case wxBOTTOM:
             case wxBOTTOM:

-                rect.Inflate(indent.x, 0);

                 rect.height += indent.y;
                 break;
 
             case wxLEFT:
                 rect.height += indent.y;
                 break;
 
             case wxLEFT:

+                rect.x -= indent.x;
+                // fall through

             case wxRIGHT:
             case wxRIGHT:

-                wxFAIL_MSG(_T("TODO"));
+                rect.width += indent.x;

                 break;
         }
     }
 
     // draw the text, image and the focus around them (if necessary)
                 break;
         }
     }
 
     // draw the text, image and the focus around them (if necessary)

-    wxRect rectLabel = rect;
+    wxRect rectLabel( REVERSE_FOR_VERTICAL(rect.x,rect.y),
+                      REVERSE_FOR_VERTICAL(rect.width,rect.height)
+                    );

     rectLabel.Deflate(1, 1);
     rectLabel.Deflate(1, 1);

-    DrawButtonLabel(dc, label, bitmap, rectLabel,
-                    flags, wxALIGN_CENTRE, indexAccel);
+    if ( isVertical )
+    {
+        // draw it horizontally into memory and rotate for screen
+        wxMemoryDC dcMem;
+        wxBitmap bitmapRotated,
+                 bitmapMem( rectLabel.x + rectLabel.width,
+                            rectLabel.y + rectLabel.height );
+        dcMem.SelectObject(bitmapMem);
+        dcMem.SetBackground(dc.GetBackground());
+        dcMem.SetFont(dc.GetFont());
+        dcMem.SetTextForeground(dc.GetTextForeground());
+        dcMem.Clear();
+        bitmapRotated = wxBitmap( wxImage( bitmap.ConvertToImage() ).Rotate90(dir==wxLEFT) );
+        DrawButtonLabel(dcMem, label, bitmapRotated, rectLabel,
+                        flags, wxALIGN_CENTRE, indexAccel);
+        dcMem.SelectObject(wxNullBitmap);
+        bitmapMem = bitmapMem.GetSubBitmap(rectLabel);
+        bitmapMem = wxBitmap(wxImage(bitmapMem.ConvertToImage()).Rotate90(dir==wxRIGHT));
+        dc.DrawBitmap(bitmapMem, rectLabel.y, rectLabel.x, false);
+    }
+    else
+    {
+        DrawButtonLabel(dc, label, bitmap, rectLabel,
+                        flags, wxALIGN_CENTRE, indexAccel);
+    }

 
     // now draw the tab border itself (maybe use DrawRoundedRectangle()?)
     static const wxCoord CUTOFF = 2; // radius of the rounded corner
 
     // now draw the tab border itself (maybe use DrawRoundedRectangle()?)
     static const wxCoord CUTOFF = 2; // radius of the rounded corner

-    wxCoord x = rect.x,
-            y = rect.y,
-            x2 = rect.GetRight(),
-            y2 = rect.GetBottom();
+    wxCoord x = SELECT_FOR_VERTICAL(rect.x,rect.y),
+            y = SELECT_FOR_VERTICAL(rect.y,rect.x),
+            x2 = SELECT_FOR_VERTICAL(rect.GetRight(),rect.GetBottom()),
+            y2 = SELECT_FOR_VERTICAL(rect.GetBottom(),rect.GetRight());

 
     // FIXME: all this code will break if the tab indent or the border width,
     //        it is tied to the fact that both of them are equal to 2
     switch ( dir )
     {
         default:
 
     // FIXME: all this code will break if the tab indent or the border width,
     //        it is tied to the fact that both of them are equal to 2
     switch ( dir )
     {
         default:

+            // default is top
+        case wxLEFT:
+            // left orientation looks like top but IsVertical makes x and y reversed

         case wxTOP:
         case wxTOP:

+            // top is not vertical so use coordinates in written order

             dc.SetPen(m_penHighlight);
             dc.SetPen(m_penHighlight);

-            dc.DrawLine(x, y2, x, y + CUTOFF);
-            dc.DrawLine(x, y + CUTOFF, x + CUTOFF, y);
-            dc.DrawLine(x + CUTOFF, y, x2 - CUTOFF + 1, y);
+            dc.DrawLine(REVERSE_FOR_VERTICAL(x, y2),
+                        REVERSE_FOR_VERTICAL(x, y + CUTOFF));
+            dc.DrawLine(REVERSE_FOR_VERTICAL(x, y + CUTOFF),
+                        REVERSE_FOR_VERTICAL(x + CUTOFF, y));
+            dc.DrawLine(REVERSE_FOR_VERTICAL(x + CUTOFF, y),
+                        REVERSE_FOR_VERTICAL(x2 - CUTOFF + 1, y));

 
             dc.SetPen(m_penBlack);
 
             dc.SetPen(m_penBlack);

-            dc.DrawLine(x2, y2, x2, y + CUTOFF);
-            dc.DrawLine(x2, y + CUTOFF, x2 - CUTOFF, y);
+            dc.DrawLine(REVERSE_FOR_VERTICAL(x2, y2),
+                        REVERSE_FOR_VERTICAL(x2, y + CUTOFF));
+            dc.DrawLine(REVERSE_FOR_VERTICAL(x2, y + CUTOFF),
+                        REVERSE_FOR_VERTICAL(x2 - CUTOFF, y));

 
             dc.SetPen(m_penDarkGrey);
 
             dc.SetPen(m_penDarkGrey);

-            dc.DrawLine(x2 - 1, y2, x2 - 1, y + CUTOFF - 1);
+            dc.DrawLine(REVERSE_FOR_VERTICAL(x2 - 1, y2),
+                        REVERSE_FOR_VERTICAL(x2 - 1, y + CUTOFF - 1));

 
             if ( flags & wxCONTROL_SELECTED )
             {
                 dc.SetPen(m_penLightGrey);
 
                 // overwrite the part of the border below this tab
 
             if ( flags & wxCONTROL_SELECTED )
             {
                 dc.SetPen(m_penLightGrey);
 
                 // overwrite the part of the border below this tab

-                dc.DrawLine(x + 1, y2 + 1, x2 - 1, y2 + 1);
+                dc.DrawLine(REVERSE_FOR_VERTICAL(x + 1, y2 + 1),
+                            REVERSE_FOR_VERTICAL(x2 - 1, y2 + 1));

 
                 // and the shadow of the tab to the left of us
 
                 // and the shadow of the tab to the left of us

-                dc.DrawLine(x + 1, y + CUTOFF + 1, x + 1, y2 + 1);
+                dc.DrawLine(REVERSE_FOR_VERTICAL(x + 1, y + CUTOFF + 1),
+                            REVERSE_FOR_VERTICAL(x + 1, y2 + 1));

             }
             break;
 
             }
             break;
 

+        case wxRIGHT:
+            // right orientation looks like bottom but IsVertical makes x and y reversed

         case wxBOTTOM:
         case wxBOTTOM:

+            // bottom is not vertical so use coordinates in written order

             dc.SetPen(m_penHighlight);
             // we need to continue one pixel further to overwrite the corner of
             // the border for the selected tab
             dc.SetPen(m_penHighlight);
             // we need to continue one pixel further to overwrite the corner of
             // the border for the selected tab

-            dc.DrawLine(x, y - (flags & wxCONTROL_SELECTED ? 1 : 0),
-                        x, y2 - CUTOFF);
-            dc.DrawLine(x, y2 - CUTOFF, x + CUTOFF, y2);
+            dc.DrawLine(REVERSE_FOR_VERTICAL(x, y - (flags & wxCONTROL_SELECTED ? 1 : 0)),
+                        REVERSE_FOR_VERTICAL(x, y2 - CUTOFF));
+            dc.DrawLine(REVERSE_FOR_VERTICAL(x, y2 - CUTOFF),
+                        REVERSE_FOR_VERTICAL(x + CUTOFF, y2));

 
             dc.SetPen(m_penBlack);
 
             dc.SetPen(m_penBlack);

-            dc.DrawLine(x + CUTOFF, y2, x2 - CUTOFF + 1, y2);
-            dc.DrawLine(x2, y, x2, y2 - CUTOFF);
-            dc.DrawLine(x2, y2 - CUTOFF, x2 - CUTOFF, y2);
+            dc.DrawLine(REVERSE_FOR_VERTICAL(x + CUTOFF, y2),
+                        REVERSE_FOR_VERTICAL(x2 - CUTOFF + 1, y2));
+            dc.DrawLine(REVERSE_FOR_VERTICAL(x2, y),
+                        REVERSE_FOR_VERTICAL(x2, y2 - CUTOFF));
+            dc.DrawLine(REVERSE_FOR_VERTICAL(x2, y2 - CUTOFF),
+                        REVERSE_FOR_VERTICAL(x2 - CUTOFF, y2));

 
             dc.SetPen(m_penDarkGrey);
 
             dc.SetPen(m_penDarkGrey);

-            dc.DrawLine(x + CUTOFF, y2 - 1, x2 - CUTOFF + 1, y2 - 1);
-            dc.DrawLine(x2 - 1, y, x2 - 1, y2 - CUTOFF + 1);
+            dc.DrawLine(REVERSE_FOR_VERTICAL(x + CUTOFF, y2 - 1),
+                        REVERSE_FOR_VERTICAL(x2 - CUTOFF + 1, y2 - 1));
+            dc.DrawLine(REVERSE_FOR_VERTICAL(x2 - 1, y),
+                        REVERSE_FOR_VERTICAL(x2 - 1, y2 - CUTOFF + 1));

 
             if ( flags & wxCONTROL_SELECTED )
             {
                 dc.SetPen(m_penLightGrey);
 
                 // overwrite the part of the (double!) border above this tab
 
             if ( flags & wxCONTROL_SELECTED )
             {
                 dc.SetPen(m_penLightGrey);
 
                 // overwrite the part of the (double!) border above this tab

-                dc.DrawLine(x + 1, y - 1, x2 - 1, y - 1);
-                dc.DrawLine(x + 1, y - 2, x2 - 1, y - 2);
+                dc.DrawLine(REVERSE_FOR_VERTICAL(x + 1, y - 1),
+                            REVERSE_FOR_VERTICAL(x2 - 1, y - 1));
+                dc.DrawLine(REVERSE_FOR_VERTICAL(x + 1, y - 2),
+                            REVERSE_FOR_VERTICAL(x2 - 1, y - 2));

 
                 // and the shadow of the tab to the left of us
 
                 // and the shadow of the tab to the left of us

-                dc.DrawLine(x + 1, y2 - CUTOFF, x + 1, y - 1);
+                dc.DrawLine(REVERSE_FOR_VERTICAL(x + 1, y2 - CUTOFF),
+                            REVERSE_FOR_VERTICAL(x + 1, y - 1));

             }
             break;
             }
             break;

-
-        case wxLEFT:
-        case wxRIGHT:
-            wxFAIL_MSG(_T("TODO"));

     }
     }

+
+    #undef SELECT_FOR_VERTICAL
+    #undef REVERSE_FOR_VERTICAL

 }
 
 // ----------------------------------------------------------------------------
 // slider
 // ----------------------------------------------------------------------------
 
 }
 
 // ----------------------------------------------------------------------------
 // slider
 // ----------------------------------------------------------------------------
 

-wxSize wxWin32Renderer::GetSliderThumbSize(const wxRect& rect,
-                                           int lenThumb,
-                                           wxOrientation orient) const
+wxSize
+wxWin32Renderer::GetSliderThumbSize(const wxRect& WXUNUSED(rect),
+                                    int lenThumb,
+                                    wxOrientation orient) const

 {
     wxSize size;
     wxCoord width  = wxMax (lenThumb, SLIDER_THUMB_LENGTH) / 2;
     wxCoord height = wxMax (lenThumb, SLIDER_THUMB_LENGTH);
 
 {
     wxSize size;
     wxCoord width  = wxMax (lenThumb, SLIDER_THUMB_LENGTH) / 2;
     wxCoord height = wxMax (lenThumb, SLIDER_THUMB_LENGTH);
 

-    if (orient == wxHORIZONTAL) 
+    if (orient == wxHORIZONTAL)

     {
         size.x = width;
         size.y = height;
     {
         size.x = width;
         size.y = height;


@@ -2627,11 +2754,11 @@ wxRect wxWin32Renderer::GetSliderShaftRect(const wxRect& rectOrig,
 
     if (orient == wxHORIZONTAL) {
         rect.x += SLIDER_MARGIN;
 
     if (orient == wxHORIZONTAL) {
         rect.x += SLIDER_MARGIN;

-        if (left & right) 
+        if (left & right)

         {
             rect.y += wxMax ((rect.height - 2*BORDER_THICKNESS) / 2, sizeThumb.y/2);
         }
         {
             rect.y += wxMax ((rect.height - 2*BORDER_THICKNESS) / 2, sizeThumb.y/2);
         }

-        else if (left) 
+        else if (left)

         {
             rect.y += wxMax ((rect.height - 2*BORDER_THICKNESS - sizeThumb.y/2), sizeThumb.y/2);
         }
         {
             rect.y += wxMax ((rect.height - 2*BORDER_THICKNESS - sizeThumb.y/2), sizeThumb.y/2);
         }


@@ -2645,11 +2772,11 @@ wxRect wxWin32Renderer::GetSliderShaftRect(const wxRect& rectOrig,
     else
     { // == wxVERTICAL
         rect.y += SLIDER_MARGIN;
     else
     { // == wxVERTICAL
         rect.y += SLIDER_MARGIN;

-        if (left & right) 
+        if (left & right)

         {
             rect.x += wxMax ((rect.width - 2*BORDER_THICKNESS) / 2, sizeThumb.x/2);
         }
         {
             rect.x += wxMax ((rect.width - 2*BORDER_THICKNESS) / 2, sizeThumb.x/2);
         }

-        else if (left) 
+        else if (left)

         {
             rect.x += wxMax ((rect.width - 2*BORDER_THICKNESS - sizeThumb.x/2), sizeThumb.x/2);
         }
         {
             rect.x += wxMax ((rect.width - 2*BORDER_THICKNESS - sizeThumb.x/2), sizeThumb.x/2);
         }


@@ -2716,7 +2843,7 @@ void wxWin32Renderer::DrawSliderThumb(wxDC& dc,
        H         D B
        H         D B
        H         D B
        H         D B
        H         D B
        H         D B

-       H         D B   where H is hightlight colour
+       H         D B   where H is highlight colour

        H         D B         D    dark grey
        H         D B         B    black
        H         D B
        H         D B         D    dark grey
        H         D B         B    black
        H         D B


@@ -2763,7 +2890,7 @@ void wxWin32Renderer::DrawSliderThumb(wxDC& dc,
         DrawLine(dc, x3+1-c, y1, x2, y3, transpose);
     }
     DrawLine(dc, x2, y3, x2, y4, transpose);
         DrawLine(dc, x3+1-c, y1, x2, y3, transpose);
     }
     DrawLine(dc, x2, y3, x2, y4, transpose);

-    if (right) 
+    if (right)

     {
         DrawLine(dc, x3+1-c, y2, x2, y4, transpose);
     }
     {
         DrawLine(dc, x3+1-c, y2, x2, y4, transpose);
     }


@@ -2783,7 +2910,7 @@ void wxWin32Renderer::DrawSliderThumb(wxDC& dc,
     }
 
     dc.SetPen(m_penHighlight);
     }
 
     dc.SetPen(m_penHighlight);

-    if (left) 
+    if (left)

     {
         DrawLine(dc, x1, y3, x3, y1, transpose);
         DrawLine(dc, x3+1-c, y1+1, x2-1, y3, transpose);
     {
         DrawLine(dc, x1, y3, x3, y1, transpose);
         DrawLine(dc, x3+1-c, y1+1, x2-1, y3, transpose);


@@ -2793,7 +2920,7 @@ void wxWin32Renderer::DrawSliderThumb(wxDC& dc,
         DrawLine(dc, x1, y1, x2, y1, transpose);
     }
     DrawLine(dc, x1, y3, x1, y4, transpose);
         DrawLine(dc, x1, y1, x2, y1, transpose);
     }
     DrawLine(dc, x1, y3, x1, y4, transpose);

-    if (right) 
+    if (right)

     {
         DrawLine(dc, x1, y4, x3+c, y2+c, transpose);
     }
     {
         DrawLine(dc, x1, y4, x3+c, y2+c, transpose);
     }


@@ -2801,7 +2928,7 @@ void wxWin32Renderer::DrawSliderThumb(wxDC& dc,
     if (flags & wxCONTROL_PRESSED) {
         // TODO: MSW fills the entire area inside, not just the rect
         wxRect rectInt = rect;
     if (flags & wxCONTROL_PRESSED) {
         // TODO: MSW fills the entire area inside, not just the rect
         wxRect rectInt = rect;

-        if ( transpose ) 
+        if ( transpose )

         {
             rectInt.SetLeft(y3);
             rectInt.SetRight(y4);
         {
             rectInt.SetLeft(y3);
             rectInt.SetRight(y4);


@@ -2857,7 +2984,7 @@ void wxWin32Renderer::DrawSliderTicks(wxDC& dc,
                                       int start,
                                       int end,
                                       int step,
                                       int start,
                                       int end,
                                       int step,

-                                      int flags,
+                                      int WXUNUSED(flags),

                                       long style)
 {
     /*    show ticks geometry
                                       long style)
 {
     /*    show ticks geometry


@@ -3070,10 +3197,10 @@ void wxWin32Renderer::DrawMenuItem(wxDC& dc,
 
         wxArrowStyle arrowStyle;
         if ( flags & wxCONTROL_DISABLED )
 
         wxArrowStyle arrowStyle;
         if ( flags & wxCONTROL_DISABLED )

-            arrowStyle = flags & wxCONTROL_SELECTED ? Arrow_InversedDisabled
+            arrowStyle = flags & wxCONTROL_SELECTED ? Arrow_InvertedDisabled

                                                     : Arrow_Disabled;
         else if ( flags & wxCONTROL_SELECTED )
                                                     : Arrow_Disabled;
         else if ( flags & wxCONTROL_SELECTED )

-            arrowStyle = Arrow_Inversed;
+            arrowStyle = Arrow_Inverted;

         else
             arrowStyle = Arrow_Normal;
 
         else
             arrowStyle = Arrow_Normal;
 


@@ -3208,7 +3335,7 @@ wxSize wxWin32Renderer::GetStatusBarBorders(wxCoord *borderBetweenFields) const
 void wxWin32Renderer::DrawStatusField(wxDC& dc,
                                       const wxRect& rect,
                                       const wxString& label,
 void wxWin32Renderer::DrawStatusField(wxDC& dc,
                                       const wxRect& rect,
                                       const wxString& label,

-                                      int flags)
+                                      int flags, int style /*=0*/)

 {
     wxRect rectIn;
 
 {
     wxRect rectIn;
 


@@ -3224,9 +3351,15 @@ void wxWin32Renderer::DrawStatusField(wxDC& dc,
                 y2 = rect.GetBottom();
 
         // draw the upper left part of the rect normally
                 y2 = rect.GetBottom();
 
         // draw the upper left part of the rect normally

-        dc.SetPen(m_penDarkGrey);
-        dc.DrawLine(rect.GetLeft(), rect.GetTop(), rect.GetLeft(), y2);
-        dc.DrawLine(rect.GetLeft() + 1, rect.GetTop(), x2, rect.GetTop());
+        if (style != wxSB_FLAT)
+        {
+            if (style == wxSB_RAISED)
+                dc.SetPen(m_penHighlight);
+            else
+                dc.SetPen(m_penDarkGrey);
+            dc.DrawLine(rect.GetLeft(), rect.GetTop(), rect.GetLeft(), y2);
+            dc.DrawLine(rect.GetLeft() + 1, rect.GetTop(), x2, rect.GetTop());
+        }

 
         // draw the grey stripes of the grip
         size_t n;
 
         // draw the grey stripes of the grip
         size_t n;


@@ -3246,9 +3379,16 @@ void wxWin32Renderer::DrawStatusField(wxDC& dc,
         }
 
         // draw the remaining rect boundaries
         }
 
         // draw the remaining rect boundaries

-        ofs -= WIDTH_STATUSBAR_GRIP_BAND;
-        dc.DrawLine(x2, rect.GetTop(), x2, y2 - ofs + 1);
-        dc.DrawLine(rect.GetLeft(), y2, x2 - ofs + 1, y2);
+        if (style != wxSB_FLAT)
+        {
+            if (style == wxSB_RAISED)
+                dc.SetPen(m_penDarkGrey);
+            else
+                dc.SetPen(m_penHighlight);
+            ofs -= WIDTH_STATUSBAR_GRIP_BAND;
+            dc.DrawLine(x2, rect.GetTop(), x2, y2 - ofs + 1);
+            dc.DrawLine(rect.GetLeft(), y2, x2 - ofs + 1, y2);
+        }

 
         rectIn = rect;
         rectIn.Deflate(1);
 
         rectIn = rect;
         rectIn.Deflate(1);


@@ -3257,7 +3397,10 @@ void wxWin32Renderer::DrawStatusField(wxDC& dc,
     }
     else // normal pane
     {
     }
     else // normal pane
     {

-        DrawBorder(dc, wxBORDER_STATIC, rect, flags, &rectIn);
+        if (style == wxSB_RAISED)
+            DrawBorder(dc, wxBORDER_RAISED, rect, flags, &rectIn);
+        else if (style != wxSB_FLAT)
+            DrawBorder(dc, wxBORDER_STATIC, rect, flags, &rectIn);

     }
 
     rectIn.Deflate(STATBAR_BORDER_X, STATBAR_BORDER_Y);
     }
 
     rectIn.Deflate(STATBAR_BORDER_X, STATBAR_BORDER_Y);


@@ -3271,7 +3414,7 @@ void wxWin32Renderer::DrawStatusField(wxDC& dc,
 // ----------------------------------------------------------------------------
 
 void wxWin32Renderer::GetComboBitmaps(wxBitmap *bmpNormal,
 // ----------------------------------------------------------------------------
 
 void wxWin32Renderer::GetComboBitmaps(wxBitmap *bmpNormal,

-                                      wxBitmap *bmpFocus,
+                                      wxBitmap * WXUNUSED(bmpFocus),

                                       wxBitmap *bmpPressed,
                                       wxBitmap *bmpDisabled)
 {
                                       wxBitmap *bmpPressed,
                                       wxBitmap *bmpDisabled)
 {


@@ -3312,7 +3455,7 @@ void wxWin32Renderer::GetComboBitmaps(wxBitmap *bmpNormal,
 void wxWin32Renderer::DoDrawBackground(wxDC& dc,
                                        const wxColour& col,
                                        const wxRect& rect,
 void wxWin32Renderer::DoDrawBackground(wxDC& dc,
                                        const wxColour& col,
                                        const wxRect& rect,

-                                       wxWindow *window )
+                                       wxWindow * WXUNUSED(window))

 {
     wxBrush brush(col, wxSOLID);
     dc.SetBrush(brush);
 {
     wxBrush brush(col, wxSOLID);
     dc.SetBrush(brush);


@@ -3323,8 +3466,8 @@ void wxWin32Renderer::DoDrawBackground(wxDC& dc,
 void wxWin32Renderer::DrawBackground(wxDC& dc,
                                      const wxColour& col,
                                      const wxRect& rect,
 void wxWin32Renderer::DrawBackground(wxDC& dc,
                                      const wxColour& col,
                                      const wxRect& rect,

-                                     int flags,
-                                     wxWindow *window )
+                                     int WXUNUSED(flags),
+                                     wxWindow *window)

 {
     // just fill it with the given or default bg colour
     wxColour colBg = col.Ok() ? col : wxSCHEME_COLOUR(m_scheme, CONTROL);
 {
     // just fill it with the given or default bg colour
     wxColour colBg = col.Ok() ? col : wxSCHEME_COLOUR(m_scheme, CONTROL);


@@ -3385,7 +3528,7 @@ void wxWin32Renderer::DrawArrow(wxDC& dc,
         x--;
 
     // draw it
         x--;
 
     // draw it

-    dc.DrawBitmap(bmp, x, y, TRUE /* use mask */);
+    dc.DrawBitmap(bmp, x, y, true /* use mask */);

 }
 
 void wxWin32Renderer::DrawArrowButton(wxDC& dc,
 }
 
 void wxWin32Renderer::DrawArrowButton(wxDC& dc,


@@ -3400,9 +3543,9 @@ void wxWin32Renderer::DrawArrowButton(wxDC& dc,
 }
 
 void wxWin32Renderer::DrawScrollbarThumb(wxDC& dc,
 }
 
 void wxWin32Renderer::DrawScrollbarThumb(wxDC& dc,

-                                         wxOrientation orient,
+                                         wxOrientation WXUNUSED(orient),

                                          const wxRect& rect,
                                          const wxRect& rect,

-                                         int flags)
+                                         int WXUNUSED(flags))

 {
     // we don't use the flags, the thumb never changes appearance
     wxRect rectThumb = rect;
 {
     // we don't use the flags, the thumb never changes appearance
     wxRect rectThumb = rect;


@@ -3411,7 +3554,7 @@ void wxWin32Renderer::DrawScrollbarThumb(wxDC& dc,
 }
 
 void wxWin32Renderer::DrawScrollbarShaft(wxDC& dc,
 }
 
 void wxWin32Renderer::DrawScrollbarShaft(wxDC& dc,

-                                         wxOrientation orient,
+                                         wxOrientation WXUNUSED(orient),

                                          const wxRect& rectBar,
                                          int flags)
 {
                                          const wxRect& rectBar,
                                          int flags)
 {


@@ -3594,7 +3737,6 @@ void wxWin32Renderer::DrawFrameTitleBar(wxDC& dc,
             DrawFrameButton(dc, x, y, wxTOPLEVEL_BUTTON_HELP,
                             (specialButton == wxTOPLEVEL_BUTTON_HELP) ?
                             specialButtonFlags : 0);
             DrawFrameButton(dc, x, y, wxTOPLEVEL_BUTTON_HELP,
                             (specialButton == wxTOPLEVEL_BUTTON_HELP) ?
                             specialButtonFlags : 0);

-            x -= FRAME_BUTTON_WIDTH;

         }
     }
 }
         }
     }
 }


@@ -3736,14 +3878,14 @@ void wxWin32Renderer::DrawFrameButton(wxDC& dc,
         DrawShadedRect(dc, &r, m_penBlack, m_penHighlight);
         DrawShadedRect(dc, &r, m_penDarkGrey, m_penLightGrey);
         DrawBackground(dc, wxSCHEME_COLOUR(m_scheme, CONTROL), r);
         DrawShadedRect(dc, &r, m_penBlack, m_penHighlight);
         DrawShadedRect(dc, &r, m_penDarkGrey, m_penLightGrey);
         DrawBackground(dc, wxSCHEME_COLOUR(m_scheme, CONTROL), r);

-        dc.DrawBitmap(m_bmpFrameButtons[idx], r.x+1, r.y+1, TRUE);
+        dc.DrawBitmap(m_bmpFrameButtons[idx], r.x+1, r.y+1, true);

     }
     else
     {
         DrawShadedRect(dc, &r, m_penHighlight, m_penBlack);
         DrawShadedRect(dc, &r, m_penLightGrey, m_penDarkGrey);
         DrawBackground(dc, wxSCHEME_COLOUR(m_scheme, CONTROL), r);
     }
     else
     {
         DrawShadedRect(dc, &r, m_penHighlight, m_penBlack);
         DrawShadedRect(dc, &r, m_penLightGrey, m_penDarkGrey);
         DrawBackground(dc, wxSCHEME_COLOUR(m_scheme, CONTROL), r);

-        dc.DrawBitmap(m_bmpFrameButtons[idx], r.x, r.y, TRUE);
+        dc.DrawBitmap(m_bmpFrameButtons[idx], r.x, r.y, true);

     }
 }
 
     }
 }
 


@@ -3790,7 +3932,7 @@ wxSize wxWin32Renderer::GetFrameTotalSize(const wxSize& clientSize,
 
 wxSize wxWin32Renderer::GetFrameMinSize(int flags) const
 {
 
 wxSize wxWin32Renderer::GetFrameMinSize(int flags) const
 {

-    wxSize s(0, 0);
+    wxSize s;

 
     if ( (flags & wxTOPLEVEL_BORDER) && !(flags & wxTOPLEVEL_MAXIMIZED) )
     {
 
     if ( (flags & wxTOPLEVEL_BORDER) && !(flags & wxTOPLEVEL_MAXIMIZED) )
     {


@@ -3832,168 +3974,274 @@ wxSize wxWin32Renderer::GetFrameIconSize() const
 // standard icons
 // ----------------------------------------------------------------------------
 
 // standard icons
 // ----------------------------------------------------------------------------
 

+/* Copyright (c) Julian Smart */

 static char *error_xpm[]={
 static char *error_xpm[]={

-"32 32 5 1",
-". c None",
-"# c #800000",
-"b c #808080",
-"a c #ff0000",
-"c c #ffffff",
-"...........########.............",
-"........###aaaaaaaa###..........",
-".......#aaaaaaaaaaaaaa#.........",
-".....##aaaaaaaaaaaaaaaa##.......",
-"....#aaaaaaaaaaaaaaaaaaaa#......",
-"...#aaaaaaaaaaaaaaaaaaaaaa#.....",
-"...#aaaaaaaaaaaaaaaaaaaaaa#b....",
-"..#aaaaaacaaaaaaaaaacaaaaaa#b...",
-".#aaaaaacccaaaaaaaacccaaaaaa#...",
-".#aaaaacccccaaaaaacccccaaaaa#b..",
-".#aaaaaacccccaaaacccccaaaaaa#bb.",
-"#aaaaaaaacccccaacccccaaaaaaaa#b.",
-"#aaaaaaaaaccccccccccaaaaaaaaa#b.",
-"#aaaaaaaaaaccccccccaaaaaaaaaa#bb",
-"#aaaaaaaaaaaccccccaaaaaaaaaaa#bb",
-"#aaaaaaaaaaaccccccaaaaaaaaaaa#bb",
-"#aaaaaaaaaaccccccccaaaaaaaaaa#bb",
-"#aaaaaaaaaccccccccccaaaaaaaaa#bb",
-"#aaaaaaaacccccaacccccaaaaaaaa#bb",
-".#aaaaaacccccaaaacccccaaaaaa#bbb",
-".#aaaaacccccaaaaaacccccaaaaa#bbb",
-".#aaaaaacccaaaaaaaacccaaaaaa#bb.",
-"..#aaaaaacaaaaaaaaaacaaaaaa#bbb.",
-"...#aaaaaaaaaaaaaaaaaaaaaa#bbbb.",
-"...#aaaaaaaaaaaaaaaaaaaaaa#bbb..",
-"....#aaaaaaaaaaaaaaaaaaaa#bbb...",
-".....##aaaaaaaaaaaaaaaa##bbbb...",
-"......b#aaaaaaaaaaaaaa#bbbbb....",
-".......b###aaaaaaaa###bbbbb.....",
-".........bb########bbbbbb.......",
-"..........bbbbbbbbbbbbbb........",
-".............bbbbbbbb..........."};
+/* columns rows colors chars-per-pixel */
+"32 32 70 1",
+"- c #BF0101",
+"b c #361F1F",
+"& c #C08484",
+"X c #BF3333",
+"# c #C08181",
+"% c #C01111",
+"d c #C51515",
+"s c #551818",
+"O c #C07E7E",
+": c #C00E0E",
+"u c #E28A8A",
+"2 c #C81F1F",
+"8 c #FFFFFF",
+"p c #E59494",
+"< c #BB0101",
+"y c #DA6A6A",
+"A c #4C4C4C",
+"9 c #F7DFDF",
+"@ c #BF5353",
+"w c #FAE9E9",
+"F c #272727",
+"5 c #D24A4A",
+". c #C06363",
+"n c #BF8282",
+"7 c #F2C9C9",
+"t c #C09292",
+"M c #3E3E3E",
+"x c #4D4D4D",
+"4 c #CA2A2A",
+"h c #E79F9F",
+"* c #C05454",
+"D c #711212",
+"V c #737373",
+"$ c #BF3232",
+"N c #900B0B",
+"6 c #BD0303",
+"3 c #DF7F7F",
+"K c #6F1212",
+"C c #BD0000",
+"m c #950909",
+"P c #8A8A8A",
+"j c #D75F5F",
+"  c None",
+"e c #F4D4D4",
+"S c #BF2020",
+"L c #747474",
+"G c #842C2C",
+"c c #ECB4B4",
+"l c #2E2121",
+"g c #BF7E7E",
+"k c #9B0808",
+"= c #BF0505",
+"a c #B10303",
+"q c #7E2020",
+"1 c #642222",
+"J c #676767",
+"B c #322020",
+"; c #C00303",
+"i c #242424",
+"o c #C00000",
+"> c #BF1F1F",
+", c #842B2B",
+"f c #701212",
+"0 c #BE0000",
+"r c #960909",
+"H c #686868",
+"v c #BC0000",
+"Z c #671414",
+"+ c #C02020",
+"z c #CD3535",
+/* pixels */
+"                                ",
+"                                ",
+"            .XoooOO             ",
+"         .+ooooooooo@#          ",
+"        $oooooooooooo%&         ",
+"      *=-ooooooooooooo;:        ",
+"     *oooooooooooooooooo>       ",
+"     =ooooooooooooooooooo,      ",
+"    $-ooooooooooooooooooo<1     ",
+"   .oooooo2334ooo533oooooo6     ",
+"   +ooooooo789oo2883oooooo0q    ",
+"   oooooooo2w83o78eoooooooor    ",
+"  toooooooooy88u884oooooooori   ",
+"  Xooooooooooe888poooooooooas   ",
+"  ooooooooooo4889doooooooooof   ",
+"  ooooooooooo588w2oooooooooofi  ",
+"  oooooooooodw8887oooooooooofi  ",
+"  goooooooooh8w588jooooooookli  ",
+"  tooooooooz885op8wdooooooorix  ",
+"   oooooood98cood98cooooooori   ",
+"   @oooooop8w2ooo5885ooooovbi   ",
+"   n%ooooooooooooooooooooomiM   ",
+"    &;oooooooooooooooooooNBiV   ",
+"     :ooooooooooooooooooCZiA    ",
+"     nSooooooooooooooooCDiF     ",
+"      nG<oooooooooooooNZiiH     ",
+"        160ooooooooovmBiFH      ",
+"         nqrraoookrrbiiA        ",
+"          nJisKKKliiiML         ",
+"             nPiiix             ",
+"                                ",
+"                                "
+};

 
 

+/* Copyright (c) Julian Smart */

 static char *info_xpm[]={
 static char *info_xpm[]={

-"32 32 6 1",
-". c None",
-"d c #000000",
-"c c #0000ff",
-"# c #808080",
-"a c #c0c0c0",
-"b c #ffffff",
-"...........########.............",
-"........###abbbbbba###..........",
-"......##abbbbbbbbbbbba##........",
-".....#abbbbbbbbbbbbbbbba#.......",
-"....#bbbbbbbaccccabbbbbbbd......",
-"...#bbbbbbbbccccccbbbbbbbbd.....",
-"..#bbbbbbbbbccccccbbbbbbbbbd....",
-".#abbbbbbbbbaccccabbbbbbbbbad...",
-".#bbbbbbbbbbbbbbbbbbbbbbbbbbd#..",
-"#abbbbbbbbbbbbbbbbbbbbbbbbbbad#.",
-"#bbbbbbbbbbcccccccbbbbbbbbbbbd#.",
-"#bbbbbbbbbbbbcccccbbbbbbbbbbbd##",
-"#bbbbbbbbbbbbcccccbbbbbbbbbbbd##",
-"#bbbbbbbbbbbbcccccbbbbbbbbbbbd##",
-"#bbbbbbbbbbbbcccccbbbbbbbbbbbd##",
-"#abbbbbbbbbbbcccccbbbbbbbbbbad##",
-".#bbbbbbbbbbbcccccbbbbbbbbbbd###",
-".#abbbbbbbbbbcccccbbbbbbbbbad###",
-"..#bbbbbbbbcccccccccbbbbbbbd###.",
-"...dbbbbbbbbbbbbbbbbbbbbbbd####.",
-"....dbbbbbbbbbbbbbbbbbbbbd####..",
-".....dabbbbbbbbbbbbbbbbad####...",
-"......ddabbbbbbbbbbbbadd####....",
-".......#dddabbbbbbaddd#####.....",
-"........###dddabbbd#######......",
-"..........####dbbbd#####........",
-".............#dbbbd##...........",
-"...............dbbd##...........",
-"................dbd##...........",
-".................dd##...........",
-"..................###...........",
-"...................##..........."};
+/* columns rows colors chars-per-pixel */
+"32 32 17 1",
+"* c #A1A3FB",
+"X c #FFFFFF",
+"O c #191EF4",
+"= c #777AF9",
+": c #4D51F7",
+"  c None",
+"- c #2328F5",
+"+ c #4247F6",
+"; c #C1C2FC",
+". c #C0C0C0",
+"& c #E0E1FE",
+"% c #242424",
+"> c #2D32F5",
+"o c #CBCCFD",
+"# c #0309F3",
+"@ c #8C8FFA",
+"$ c #EAEBFE",
+/* pixels */
+"          .......               ",
+"       ...XXXXXXX...            ",
+"     ..XXXXXXXXXXXXX..          ",
+"    .XXXXXXXXXXXXXXXXX.         ",
+"   .XXXXXXXXoO+XXXXXXXX.        ",
+"  .XXXXXXXXX@#OXXXXXXXXX.       ",
+" .XXXXXXXXXX$@oXXXXXXXXXX.      ",
+" .XXXXXXXXXXXXXXXXXXXXXXX.%     ",
+" .XXXXXXXXX&*=-XXXXXXXXXX.%%    ",
+".XXXXXXXXXX;:#>XXXXXXXXXXX.%    ",
+".XXXXXXXXXXX;#+XXXXXXXXXXX.%    ",
+".XXXXXXXXXXX;#+XXXXXXXXXXX.%%   ",
+" .XXXXXXXXXX;#+XXXXXXXXXX.%%%   ",
+" .XXXXXXXXXX;#+XXXXXXXXXX.%%%   ",
+" .XXXXXXXXXX;#+XXXXXXXXXX.%%    ",
+"  .XXXXXXXX*-##+XXXXXXXX.%%%    ",
+"   .XXXXXXXXXXXXXXXXXXX.%%%%    ",
+"    .XXXXXXXXXXXXXXXXX.%%%%     ",
+"     ..XXXXXXXXXXXXX..%%%%      ",
+"      %...XXXXXXXX..%%%%%       ",
+"       %%%..XXXXXX.%%%%%        ",
+"         %%%.XXXXX.%%%          ",
+"            %.XXXX.%%           ",
+"              .XXX.%%           ",
+"               .XX.%%           ",
+"                .X.%%           ",
+"                 ..%%           ",
+"                  .%%           ",
+"                   %%           ",
+"                    %           ",
+"                                ",
+"                                "
+};

 
 

+/* Copyright (c) Julian Smart */

 static char *question_xpm[]={
 static char *question_xpm[]={

-"32 32 6 1",
-". c None",
-"c c #000000",
-"d c #0000ff",
-"# c #808080",
-"a c #c0c0c0",
-"b c #ffffff",
-"...........########.............",
-"........###abbbbbba###..........",
-"......##abbbbbbbbbbbba##........",
-".....#abbbbbbbbbbbbbbbba#.......",
-"....#bbbbbbbbbbbbbbbbbbbbc......",
-"...#bbbbbbbaddddddabbbbbbbc.....",
-"..#bbbbbbbadabbddddabbbbbbbc....",
-".#abbbbbbbddbbbbddddbbbbbbbac...",
-".#bbbbbbbbddddbbddddbbbbbbbbc#..",
-"#abbbbbbbbddddbaddddbbbbbbbbac#.",
-"#bbbbbbbbbaddabddddbbbbbbbbbbc#.",
-"#bbbbbbbbbbbbbadddbbbbbbbbbbbc##",
-"#bbbbbbbbbbbbbdddbbbbbbbbbbbbc##",
-"#bbbbbbbbbbbbbddabbbbbbbbbbbbc##",
-"#bbbbbbbbbbbbbddbbbbbbbbbbbbbc##",
-"#abbbbbbbbbbbbbbbbbbbbbbbbbbac##",
-".#bbbbbbbbbbbaddabbbbbbbbbbbc###",
-".#abbbbbbbbbbddddbbbbbbbbbbac###",
-"..#bbbbbbbbbbddddbbbbbbbbbbc###.",
-"...cbbbbbbbbbaddabbbbbbbbbc####.",
-"....cbbbbbbbbbbbbbbbbbbbbc####..",
-".....cabbbbbbbbbbbbbbbbac####...",
-"......ccabbbbbbbbbbbbacc####....",
-".......#cccabbbbbbaccc#####.....",
-"........###cccabbbc#######......",
-"..........####cbbbc#####........",
-".............#cbbbc##...........",
-"...............cbbc##...........",
-"................cbc##...........",
-".................cc##...........",
-"..................###...........",
-"...................##..........."};
+/* columns rows colors chars-per-pixel */
+"32 32 16 1",
+"O c #A3A3FF",
+"X c #FFFFFF",
+"% c #CACAFF",
+"- c #4141FF",
+"= c #6060FF",
+"* c #2B2BFF",
+"@ c #B5B5FF",
+"  c None",
+"# c #1616FF",
+"+ c #8181FF",
+"$ c #0000FF",
+". c #C0C0C0",
+"; c #5555FF",
+": c #242424",
+"o c #E7E7FF",
+"& c #7575FF",
+/* pixels */
+"          .......               ",
+"       ...XXXXXXX...            ",
+"     ..XXXXXXXXXXXXX..          ",
+"    .XXXXXXoO++@XXXXXX.         ",
+"   .XXXXXXO#$$$$#%XXXXX.        ",
+"  .XXXXXX@$$#&&#$#oXXXXX.       ",
+" .XXXXXXX*$$%XX%$$=XXXXXX.      ",
+" .XXXXXXX+-;XXXX$$-XXXXXX.:     ",
+" .XXXXXXXXXXXXX+$$&XXXXXX.::    ",
+".XXXXXXXXXXXXo;$$*oXXXXXXX.:    ",
+".XXXXXXXXXXXo*$$*oXXXXXXXX.:    ",
+".XXXXXXXXXXX+$$*oXXXXXXXXX.::   ",
+" .XXXXXXXXXX-$$oXXXXXXXXX.:::   ",
+" .XXXXXXXXXXX--XXXXXXXXXX.:::   ",
+" .XXXXXXXXXXXXXXXXXXXXXXX.::    ",
+"  .XXXXXXXXX-$$XXXXXXXXX.:::    ",
+"   .XXXXXXXX-$$XXXXXXXX.::::    ",
+"    .XXXXXXXO++XXXXXXX.::::     ",
+"     ..XXXXXXXXXXXXX..::::      ",
+"      :...XXXXXXXX..:::::       ",
+"       :::..XXXXXX.:::::        ",
+"         :::.XXXXX.:::          ",
+"            :.XXXX.::           ",
+"              .XXX.::           ",
+"               .XX.::           ",
+"                .X.::           ",
+"                 ..::           ",
+"                  .::           ",
+"                   ::           ",
+"                    :           ",
+"                                ",
+"                                "
+};

 
 

+/* Copyright (c) Julian Smart */

 static char *warning_xpm[]={
 static char *warning_xpm[]={

-"32 32 6 1",
-". c None",
-"c c #000000",
-"# c #808000",
-"d c #808080",
-"b c #c0c0c0",
-"a c #ffff00",
-".............###................",
-"............#aabc...............",
-"...........#aaaabcd.............",
-"...........#aaaaacdd............",
-"..........#aaaaaabcdd...........",
-"..........#aaaaaaacdd...........",
-".........#aaaaaaaabcdd..........",
-".........#aaaaaaaaacdd..........",
-"........#aaaaaaaaaabcdd.........",
-"........#aaabcccbaaacdd.........",
-".......#aaaacccccaaabcdd........",
-".......#aaaacccccaaaacdd........",
-"......#aaaaacccccaaaabcdd.......",
-"......#aaaaacccccaaaaacdd.......",
-".....#aaaaaacccccaaaaabcdd......",
-".....#aaaaaa#ccc#aaaaaacdd......",
-"....#aaaaaaabcccbaaaaaabcdd.....",
-"....#aaaaaaaacccaaaaaaaacdd.....",
-"...#aaaaaaaaa#c#aaaaaaaabcdd....",
-"...#aaaaaaaaabcbaaaaaaaaacdd....",
-"..#aaaaaaaaaaacaaaaaaaaaabcdd...",
-"..#aaaaaaaaaaaaaaaaaaaaaaacdd...",
-".#aaaaaaaaaaabccbaaaaaaaaabcdd..",
-".#aaaaaaaaaaaccccaaaaaaaaaacdd..",
-"#aaaaaaaaaaaaccccaaaaaaaaaabcdd.",
-"#aaaaaaaaaaaabccbaaaaaaaaaaacdd.",
-"#aaaaaaaaaaaaaaaaaaaaaaaaaaacddd",
-"#aaaaaaaaaaaaaaaaaaaaaaaaaabcddd",
-".#aaaaaaaaaaaaaaaaaaaaaaaabcdddd",
-"..#ccccccccccccccccccccccccddddd",
-"....ddddddddddddddddddddddddddd.",
-".....ddddddddddddddddddddddddd.."};
+/* columns rows colors chars-per-pixel */
+"32 32 9 1",
+"@ c Black",
+"o c #A6A800",
+"+ c #8A8C00",
+"$ c #B8BA00",
+"  c None",
+"O c #6E7000",
+"X c #DCDF00",
+". c #C00000",
+"# c #373800",
+/* pixels */
+"                                ",
+"                                ",
+"                                ",
+"                .               ",
+"               ...              ",
+"               ...              ",
+"              .....             ",
+"             ...X..             ",
+"             ..XXX..            ",
+"            ...XXX...           ",
+"            ..XXXXX..           ",
+"           ..XXXXXX...          ",
+"          ...XXoO+XX..          ",
+"          ..XXXO@#XXX..         ",
+"         ..XXXXO@#XXX...        ",
+"        ...XXXXO@#XXXX..        ",
+"        ..XXXXXO@#XXXX...       ",
+"       ...XXXXXo@OXXXXX..       ",
+"      ...XXXXXXo@OXXXXXX..      ",
+"      ..XXXXXXX$@OXXXXXX...     ",
+"     ...XXXXXXXX@XXXXXXXX..     ",
+"    ...XXXXXXXXXXXXXXXXXX...    ",
+"    ..XXXXXXXXXXOXXXXXXXXX..    ",
+"   ...XXXXXXXXXO@#XXXXXXXXX..   ",
+"   ..XXXXXXXXXXX#XXXXXXXXXX...  ",
+"  ...XXXXXXXXXXXXXXXXXXXXXXX..  ",
+" ...XXXXXXXXXXXXXXXXXXXXXXXX... ",
+" .............................. ",
+" .............................. ",
+"                                ",
+"                                ",
+"                                "
+};
+

 
 wxBitmap wxWin32ArtProvider::CreateBitmap(const wxArtID& id,
                                           const wxArtClient& WXUNUSED(client),
 
 wxBitmap wxWin32ArtProvider::CreateBitmap(const wxArtID& id,
                                           const wxArtClient& WXUNUSED(client),


@@ -4020,8 +4268,9 @@ static inline int GetTextBorderWidth()
     return 1;
 }
 
     return 1;
 }
 

-wxRect wxWin32Renderer::GetTextTotalArea(const wxTextCtrl *text,
-                                         const wxRect& rect) const
+wxRect
+wxWin32Renderer::GetTextTotalArea(const wxTextCtrl * WXUNUSED(text),
+                                  const wxRect& rect) const

 {
     wxRect rectTotal = rect;
 
 {
     wxRect rectTotal = rect;
 


@@ -4034,9 +4283,10 @@ wxRect wxWin32Renderer::GetTextTotalArea(const wxTextCtrl *text,
     return rectTotal;
 }
 
     return rectTotal;
 }
 

-wxRect wxWin32Renderer::GetTextClientArea(const wxTextCtrl *text,
-                                          const wxRect& rect,
-                                          wxCoord *extraSpaceBeyond) const
+wxRect
+wxWin32Renderer::GetTextClientArea(const wxTextCtrl * WXUNUSED(text),
+                                   const wxRect& rect,
+                                   wxCoord *extraSpaceBeyond) const

 {
     wxRect rectText = rect;
 
 {
     wxRect rectText = rect;
 


@@ -4074,6 +4324,12 @@ void wxWin32Renderer::AdjustSize(wxSize *size, const wxWindow *window)
     }
 #endif // wxUSE_SCROLLBAR/!wxUSE_SCROLLBAR
 
     }
 #endif // wxUSE_SCROLLBAR/!wxUSE_SCROLLBAR
 

+#if wxUSE_BMPBUTTON
+    if ( wxDynamicCast(window, wxBitmapButton) )
+    {
+        // do nothing
+    } else
+#endif // wxUSE_BMPBUTTON

 #if wxUSE_BUTTON
     if ( wxDynamicCast(window, wxButton) )
     {
 #if wxUSE_BUTTON
     if ( wxDynamicCast(window, wxButton) )
     {


@@ -4093,9 +4349,9 @@ void wxWin32Renderer::AdjustSize(wxSize *size, const wxWindow *window)
         // less than the standard one, but not when display not PDAs.
         if (wxSystemSettings::GetScreenType() > wxSYS_SCREEN_PDA)
         {
         // less than the standard one, but not when display not PDAs.
         if (wxSystemSettings::GetScreenType() > wxSYS_SCREEN_PDA)
         {

-        if ( !(window->GetWindowStyle() & wxBU_EXACTFIT) )
+            if ( !(window->GetWindowStyle() & wxBU_EXACTFIT) )

             {
             {

-                       wxSize szDef = wxButton::GetDefaultSize();
+                wxSize szDef = wxButton::GetDefaultSize();

                 if ( size->x < szDef.x )
                     size->x = szDef.x;
             }
                 if ( size->x < szDef.x )
                     size->x = szDef.x;
             }


@@ -4125,11 +4381,11 @@ wxWin32InputHandler::wxWin32InputHandler(wxWin32Renderer *renderer)
     m_renderer = renderer;
 }
 
     m_renderer = renderer;
 }
 

-bool wxWin32InputHandler::HandleKey(wxInputConsumer *control,
-                                    const wxKeyEvent& event,
-                                    bool pressed)
+bool wxWin32InputHandler::HandleKey(wxInputConsumer * WXUNUSED(control),
+                                    const wxKeyEvent& WXUNUSED(event),
+                                    bool WXUNUSED(pressed))

 {
 {

-    return FALSE;
+    return false;

 }
 
 bool wxWin32InputHandler::HandleMouse(wxInputConsumer *control,
 }
 
 bool wxWin32InputHandler::HandleMouse(wxInputConsumer *control,


@@ -4145,11 +4401,11 @@ bool wxWin32InputHandler::HandleMouse(wxInputConsumer *control,
         {
             win->SetFocus();
 
         {
             win->SetFocus();
 

-            return TRUE;
+            return true;

         }
     }
 
         }
     }
 

-    return FALSE;
+    return false;

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


@@ -4161,7 +4417,7 @@ wxWin32ScrollBarInputHandler(wxWin32Renderer *renderer,
                              wxInputHandler *handler)
         : wxStdScrollBarInputHandler(renderer, handler)
 {
                              wxInputHandler *handler)
         : wxStdScrollBarInputHandler(renderer, handler)
 {

-    m_scrollPaused = FALSE;
+    m_scrollPaused = false;

     m_interval = 0;
 }
 
     m_interval = 0;
 }
 


@@ -4170,7 +4426,7 @@ bool wxWin32ScrollBarInputHandler::OnScrollTimer(wxScrollBar *scrollbar,
 {
     // stop if went beyond the position of the original click (this can only
     // happen when we scroll by pages)
 {
     // stop if went beyond the position of the original click (this can only
     // happen when we scroll by pages)

-    bool stop = FALSE;
+    bool stop = false;

     if ( action == wxACTION_SCROLL_PAGE_DOWN )
     {
         stop = m_renderer->HitTestScrollbar(scrollbar, m_ptStartScrolling)
     if ( action == wxACTION_SCROLL_PAGE_DOWN )
     {
         stop = m_renderer->HitTestScrollbar(scrollbar, m_ptStartScrolling)


@@ -4188,7 +4444,7 @@ bool wxWin32ScrollBarInputHandler::OnScrollTimer(wxScrollBar *scrollbar,
 
         scrollbar->Refresh();
 
 
         scrollbar->Refresh();
 

-        return FALSE;
+        return false;

     }
 
     return wxStdScrollBarInputHandler::OnScrollTimer(scrollbar, action);
     }
 
     return wxStdScrollBarInputHandler::OnScrollTimer(scrollbar, action);


@@ -4221,12 +4477,12 @@ bool wxWin32ScrollBarInputHandler::HandleMouseMove(wxInputConsumer *control,
     // mouse move events normally - only do it while mouse is captured (i.e.
     // when we're dragging the thumb or pressing on something)
     if ( !m_winCapture )
     // mouse move events normally - only do it while mouse is captured (i.e.
     // when we're dragging the thumb or pressing on something)
     if ( !m_winCapture )

-        return FALSE;
+        return false;

 
     if ( event.Entering() )
     {
         // we're not interested in this at all
 
     if ( event.Entering() )
     {
         // we're not interested in this at all

-        return FALSE;
+        return false;

     }
 
     wxScrollBar *scrollbar = wxStaticCast(control->GetInputWindow(), wxScrollBar);
     }
 
     wxScrollBar *scrollbar = wxStaticCast(control->GetInputWindow(), wxScrollBar);


@@ -4238,20 +4494,20 @@ bool wxWin32ScrollBarInputHandler::HandleMouseMove(wxInputConsumer *control,
         if ( event.Leaving() )
         {
             // it surely didn't
         if ( event.Leaving() )
         {
             // it surely didn't

-            return FALSE;
+            return false;

         }
 
         ht = m_renderer->HitTestScrollbar(scrollbar, event.GetPosition());
         if ( ht == m_htLast )
         {
             // yes it did, resume scrolling
         }
 
         ht = m_renderer->HitTestScrollbar(scrollbar, event.GetPosition());
         if ( ht == m_htLast )
         {
             // yes it did, resume scrolling

-            m_scrollPaused = FALSE;
+            m_scrollPaused = false;

             if ( m_timerScroll )
             {
                 // we were scrolling by line/page, restart timer
                 m_timerScroll->Start(m_interval);
 
             if ( m_timerScroll )
             {
                 // we were scrolling by line/page, restart timer
                 m_timerScroll->Start(m_interval);
 

-                Press(scrollbar, TRUE);
+                Press(scrollbar, true);

             }
             else // we were dragging the thumb
             {
             }
             else // we were dragging the thumb
             {


@@ -4259,7 +4515,7 @@ bool wxWin32ScrollBarInputHandler::HandleMouseMove(wxInputConsumer *control,
                 HandleThumbMove(scrollbar, m_eventLastDrag);
             }
 
                 HandleThumbMove(scrollbar, m_eventLastDrag);
             }
 

-            return TRUE;
+            return true;

         }
     }
     else // normal case, scrolling hasn't been paused
         }
     }
     else // normal case, scrolling hasn't been paused


@@ -4311,10 +4567,10 @@ bool wxWin32ScrollBarInputHandler::HandleMouseMove(wxInputConsumer *control,
                 // pause scrolling
                 m_interval = m_timerScroll->GetInterval();
                 m_timerScroll->Stop();
                 // pause scrolling
                 m_interval = m_timerScroll->GetInterval();
                 m_timerScroll->Stop();

-                m_scrollPaused = TRUE;
+                m_scrollPaused = true;

 
                 // unpress the arrow
 
                 // unpress the arrow

-                Press(scrollbar, FALSE);
+                Press(scrollbar, false);

             }
             else // we were dragging the thumb
             {
             }
             else // we were dragging the thumb
             {


@@ -4327,7 +4583,7 @@ bool wxWin32ScrollBarInputHandler::HandleMouseMove(wxInputConsumer *control,
                 HandleThumbMove(scrollbar, m_eventStartDrag);
             }
 
                 HandleThumbMove(scrollbar, m_eventStartDrag);
             }
 

-            return TRUE;
+            return true;

         }
     }
 
         }
     }
 


@@ -4364,15 +4620,15 @@ bool wxWin32CheckboxInputHandler::HandleKey(wxInputConsumer *control,
                 break;
         }
 
                 break;
         }
 

-        if ( !!action )
+        if ( !action.IsEmpty() )

         {
             control->PerformAction(action);
 
         {
             control->PerformAction(action);
 

-            return TRUE;
+            return true;

         }
     }
 
         }
     }
 

-    return FALSE;
+    return false;

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


@@ -4406,7 +4662,7 @@ bool wxWin32TextCtrlInputHandler::HandleKey(wxInputConsumer *control,
         {
             control->PerformAction(action);
 
         {
             control->PerformAction(action);
 

-            return TRUE;
+            return true;

         }
     }
 
         }
     }
 


@@ -4421,7 +4677,7 @@ wxWin32StatusBarInputHandler::
 wxWin32StatusBarInputHandler(wxInputHandler *handler)
     : wxStdInputHandler(handler)
 {
 wxWin32StatusBarInputHandler(wxInputHandler *handler)
     : wxStdInputHandler(handler)
 {

-    m_isOnGrip = FALSE;
+    m_isOnGrip = false;

 }
 
 bool wxWin32StatusBarInputHandler::IsOnGrip(wxWindow *statbar,
 }
 
 bool wxWin32StatusBarInputHandler::IsOnGrip(wxWindow *statbar,


@@ -4433,7 +4689,7 @@ bool wxWin32StatusBarInputHandler::IsOnGrip(wxWindow *statbar,
         wxTopLevelWindow *
             parentTLW = wxDynamicCast(statbar->GetParent(), wxTopLevelWindow);
 
         wxTopLevelWindow *
             parentTLW = wxDynamicCast(statbar->GetParent(), wxTopLevelWindow);
 

-        wxCHECK_MSG( parentTLW, FALSE,
+        wxCHECK_MSG( parentTLW, false,

                      _T("the status bar should be a child of a TLW") );
 
         // a maximized window can't be resized anyhow
                      _T("the status bar should be a child of a TLW") );
 
         // a maximized window can't be resized anyhow


@@ -4451,7 +4707,7 @@ bool wxWin32StatusBarInputHandler::IsOnGrip(wxWindow *statbar,
         }
     }
 
         }
     }
 

-    return FALSE;
+    return false;

 }
 
 bool wxWin32StatusBarInputHandler::HandleMouse(wxInputConsumer *consumer,
 }
 
 bool wxWin32StatusBarInputHandler::HandleMouse(wxInputConsumer *consumer,


@@ -4474,7 +4730,7 @@ bool wxWin32StatusBarInputHandler::HandleMouse(wxInputConsumer *consumer,
 
                     statbar->SetCursor(m_cursorOld);
 
 
                     statbar->SetCursor(m_cursorOld);
 

-                    return TRUE;
+                    return true;

                 }
             }
         }
                 }
             }
         }


@@ -4514,19 +4770,21 @@ class wxWin32SystemMenuEvtHandler : public wxEvtHandler
 {
 public:
     wxWin32SystemMenuEvtHandler(wxWin32FrameInputHandler *handler);
 {
 public:
     wxWin32SystemMenuEvtHandler(wxWin32FrameInputHandler *handler);

-    
+

     void Attach(wxInputConsumer *consumer);
     void Detach();
     void Attach(wxInputConsumer *consumer);
     void Detach();

-    
+

 private:
     DECLARE_EVENT_TABLE()
     void OnSystemMenu(wxCommandEvent &event);
     void OnCloseFrame(wxCommandEvent &event);
     void OnClose(wxCloseEvent &event);
 private:
     DECLARE_EVENT_TABLE()
     void OnSystemMenu(wxCommandEvent &event);
     void OnCloseFrame(wxCommandEvent &event);
     void OnClose(wxCloseEvent &event);

-   
+

     wxWin32FrameInputHandler *m_inputHnd;
     wxTopLevelWindow         *m_wnd;
     wxWin32FrameInputHandler *m_inputHnd;
     wxTopLevelWindow         *m_wnd;

+#if wxUSE_ACCEL

     wxAcceleratorTable        m_oldAccelTable;
     wxAcceleratorTable        m_oldAccelTable;

+#endif

 };
 
 wxWin32SystemMenuEvtHandler::wxWin32SystemMenuEvtHandler(
 };
 
 wxWin32SystemMenuEvtHandler::wxWin32SystemMenuEvtHandler(


@@ -4542,22 +4800,26 @@ void wxWin32SystemMenuEvtHandler::Attach(wxInputConsumer *consumer)
 
     m_wnd = wxStaticCast(consumer->GetInputWindow(), wxTopLevelWindow);
     m_wnd->PushEventHandler(this);
 
     m_wnd = wxStaticCast(consumer->GetInputWindow(), wxTopLevelWindow);
     m_wnd->PushEventHandler(this);

-    
-    // VS: This code relies on using generic implementation of 
+
+#if wxUSE_ACCEL
+    // VS: This code relies on using generic implementation of

     //     wxAcceleratorTable in wxUniv!
     wxAcceleratorTable table = *m_wnd->GetAcceleratorTable();
     m_oldAccelTable = table;
     table.Add(wxAcceleratorEntry(wxACCEL_ALT, WXK_SPACE, wxID_SYSTEM_MENU));
     table.Add(wxAcceleratorEntry(wxACCEL_ALT, WXK_F4, wxID_CLOSE_FRAME));
     m_wnd->SetAcceleratorTable(table);
     //     wxAcceleratorTable in wxUniv!
     wxAcceleratorTable table = *m_wnd->GetAcceleratorTable();
     m_oldAccelTable = table;
     table.Add(wxAcceleratorEntry(wxACCEL_ALT, WXK_SPACE, wxID_SYSTEM_MENU));
     table.Add(wxAcceleratorEntry(wxACCEL_ALT, WXK_F4, wxID_CLOSE_FRAME));
     m_wnd->SetAcceleratorTable(table);

+#endif

 }
 
 void wxWin32SystemMenuEvtHandler::Detach()
 {
     if ( m_wnd )
     {
 }
 
 void wxWin32SystemMenuEvtHandler::Detach()
 {
     if ( m_wnd )
     {

+#if wxUSE_ACCEL

         m_wnd->SetAcceleratorTable(m_oldAccelTable);
         m_wnd->SetAcceleratorTable(m_oldAccelTable);

-        m_wnd->RemoveEventHandler(this); 
+#endif
+        m_wnd->RemoveEventHandler(this);

         m_wnd = NULL;
     }
 }
         m_wnd = NULL;
     }
 }


@@ -4578,10 +4840,16 @@ void wxWin32SystemMenuEvtHandler::OnSystemMenu(wxCommandEvent &WXUNUSED(event))
     pt.x = -pt.x + border;
     pt.y = -pt.y + border + FRAME_TITLEBAR_HEIGHT;
 
     pt.x = -pt.x + border;
     pt.y = -pt.y + border + FRAME_TITLEBAR_HEIGHT;
 

+#if wxUSE_ACCEL

     wxAcceleratorTable table = *m_wnd->GetAcceleratorTable();
     m_wnd->SetAcceleratorTable(wxNullAcceleratorTable);
     wxAcceleratorTable table = *m_wnd->GetAcceleratorTable();
     m_wnd->SetAcceleratorTable(wxNullAcceleratorTable);

+#endif
+

     m_inputHnd->PopupSystemMenu(m_wnd, pt);
     m_inputHnd->PopupSystemMenu(m_wnd, pt);

+
+#if wxUSE_ACCEL

     m_wnd->SetAcceleratorTable(table);
     m_wnd->SetAcceleratorTable(table);

+#endif

 }
 
 void wxWin32SystemMenuEvtHandler::OnCloseFrame(wxCommandEvent &WXUNUSED(event))
 }
 
 void wxWin32SystemMenuEvtHandler::OnCloseFrame(wxCommandEvent &WXUNUSED(event))


@@ -4627,17 +4895,17 @@ bool wxWin32FrameInputHandler::HandleMouse(wxInputConsumer *consumer,
             tlw->PerformAction(wxACTION_TOPLEVEL_BUTTON_CLICK,
                                tlw->IsMaximized() ? wxTOPLEVEL_BUTTON_RESTORE
                                                   : wxTOPLEVEL_BUTTON_MAXIMIZE);
             tlw->PerformAction(wxACTION_TOPLEVEL_BUTTON_CLICK,
                                tlw->IsMaximized() ? wxTOPLEVEL_BUTTON_RESTORE
                                                   : wxTOPLEVEL_BUTTON_MAXIMIZE);

-            return TRUE;
+            return true;

         }
         else if ( tlw->GetWindowStyle() & wxSYSTEM_MENU )
         {
             if ( (event.LeftDown() && hit == wxHT_TOPLEVEL_ICON) ||
         }
         else if ( tlw->GetWindowStyle() & wxSYSTEM_MENU )
         {
             if ( (event.LeftDown() && hit == wxHT_TOPLEVEL_ICON) ||

-                 (event.RightDown() && 
-                      (hit == wxHT_TOPLEVEL_TITLEBAR || 
+                 (event.RightDown() &&
+                      (hit == wxHT_TOPLEVEL_TITLEBAR ||

                        hit == wxHT_TOPLEVEL_ICON)) )
             {
                 PopupSystemMenu(tlw, event.GetPosition());
                        hit == wxHT_TOPLEVEL_ICON)) )
             {
                 PopupSystemMenu(tlw, event.GetPosition());

-                return TRUE;
+                return true;

             }
         }
     }
             }
         }
     }


@@ -4645,7 +4913,7 @@ bool wxWin32FrameInputHandler::HandleMouse(wxInputConsumer *consumer,
     return wxStdFrameInputHandler::HandleMouse(consumer, event);
 }
 
     return wxStdFrameInputHandler::HandleMouse(consumer, event);
 }
 

-void wxWin32FrameInputHandler::PopupSystemMenu(wxTopLevelWindow *window, 
+void wxWin32FrameInputHandler::PopupSystemMenu(wxTopLevelWindow *window,

                                                const wxPoint& pos) const
 {
     wxMenu *menu = new wxMenu;
                                                const wxPoint& pos) const
 {
     wxMenu *menu = new wxMenu;


@@ -4661,25 +4929,25 @@ void wxWin32FrameInputHandler::PopupSystemMenu(wxTopLevelWindow *window,
         menu->Append(wxID_MAXIMIZE_FRAME , _("Ma&ximize"));
     menu->AppendSeparator();
     menu->Append(wxID_CLOSE_FRAME, _("Close\tAlt-F4"));
         menu->Append(wxID_MAXIMIZE_FRAME , _("Ma&ximize"));
     menu->AppendSeparator();
     menu->Append(wxID_CLOSE_FRAME, _("Close\tAlt-F4"));

-    
+

     if ( window->GetWindowStyle() & wxMAXIMIZE_BOX )
     {
         if ( window->IsMaximized() )
         {
     if ( window->GetWindowStyle() & wxMAXIMIZE_BOX )
     {
         if ( window->IsMaximized() )
         {

-            menu->Enable(wxID_MAXIMIZE_FRAME, FALSE);
-            menu->Enable(wxID_MOVE_FRAME, FALSE);
+            menu->Enable(wxID_MAXIMIZE_FRAME, false);
+            menu->Enable(wxID_MOVE_FRAME, false);

             if ( window->GetWindowStyle() & wxRESIZE_BORDER )
             if ( window->GetWindowStyle() & wxRESIZE_BORDER )

-                menu->Enable(wxID_RESIZE_FRAME, FALSE);
+                menu->Enable(wxID_RESIZE_FRAME, false);

         }
         else
         }
         else

-            menu->Enable(wxID_RESTORE_FRAME, FALSE);
+            menu->Enable(wxID_RESTORE_FRAME, false);

     }
 
     window->PopupMenu(menu, pos);
     delete menu;
 }
 
     }
 
     window->PopupMenu(menu, pos);
     delete menu;
 }
 

-bool wxWin32FrameInputHandler::HandleActivation(wxInputConsumer *consumer, 
+bool wxWin32FrameInputHandler::HandleActivation(wxInputConsumer *consumer,

                                                 bool activated)
 {
     if ( consumer->GetInputWindow()->GetWindowStyle() & wxSYSTEM_MENU )
                                                 bool activated)
 {
     if ( consumer->GetInputWindow()->GetWindowStyle() & wxSYSTEM_MENU )