Fix wxEncodingConverter::Convert(wchar_t) documentation.

[wxWidgets.git] / src / aui / auibook.cpp

diff --git a/src/aui/auibook.cpp b/src/aui/auibook.cpp
index b9f44578903890e04c96a2edd5f6618dad17201d..36640c3fcccbb025f0cced46a34eebd54dc96557 100644 (file)
--- a/src/aui/auibook.cpp
+++ b/src/aui/auibook.cpp
@@ -119,14 +119,14 @@ class wxAuiCommandCapture : public wxEvtHandler
 {
 public:
 
 {
 public:
 

-    wxAuiCommandCapture() { m_last_id = 0; }
-    int GetCommandId() const { return m_last_id; }
+    wxAuiCommandCapture() { m_lastId = 0; }
+    int GetCommandId() const { return m_lastId; }

 
     bool ProcessEvent(wxEvent& evt)
     {
         if (evt.GetEventType() == wxEVT_COMMAND_MENU_SELECTED)
         {
 
     bool ProcessEvent(wxEvent& evt)
     {
         if (evt.GetEventType() == wxEVT_COMMAND_MENU_SELECTED)
         {

-            m_last_id = evt.GetId();
+            m_lastId = evt.GetId();

             return true;
         }
 
             return true;
         }
 


@@ -137,7 +137,7 @@ public:
     }
 
 private:
     }
 
 private:

-    int m_last_id;
+    int m_lastId;

 };
 
 
 };
 
 


@@ -184,48 +184,48 @@ static const unsigned char list_bits[] = {
 
 wxAuiDefaultTabArt::wxAuiDefaultTabArt()
 {
 
 wxAuiDefaultTabArt::wxAuiDefaultTabArt()
 {

-    m_normal_font = *wxNORMAL_FONT;
-    m_selected_font = *wxNORMAL_FONT;
-    m_selected_font.SetWeight(wxBOLD);
-    m_measuring_font = m_selected_font;
+    m_normalFont = *wxNORMAL_FONT;
+    m_selectedFont = *wxNORMAL_FONT;
+    m_selectedFont.SetWeight(wxBOLD);
+    m_measuringFont = m_selectedFont;

 
 

-    m_fixed_tab_width = 100;
-    m_tab_ctrl_height = 0;
+    m_fixedTabWidth = 100;
+    m_tabCtrlHeight = 0;

 
 #if defined( __WXMAC__ ) && wxOSX_USE_COCOA_OR_CARBON
 
 #if defined( __WXMAC__ ) && wxOSX_USE_COCOA_OR_CARBON

-    wxColor base_colour = wxColour( wxMacCreateCGColorFromHITheme(kThemeBrushToolbarBackground));
+    wxColor baseColour = wxColour( wxMacCreateCGColorFromHITheme(kThemeBrushToolbarBackground));

 #else
 #else

-    wxColor base_colour = wxSystemSettings::GetColour(wxSYS_COLOUR_3DFACE);
+    wxColor baseColour = wxSystemSettings::GetColour(wxSYS_COLOUR_3DFACE);

 #endif
 
 #endif
 

-    // the base_colour is too pale to use as our base colour,
+    // the baseColour is too pale to use as our base colour,

     // so darken it a bit --
     // so darken it a bit --

-    if ((255-base_colour.Red()) +
-        (255-base_colour.Green()) +
-        (255-base_colour.Blue()) < 60)
+    if ((255-baseColour.Red()) +
+        (255-baseColour.Green()) +
+        (255-baseColour.Blue()) < 60)

     {
     {

-        base_colour = base_colour.ChangeLightness(92);
+        baseColour = baseColour.ChangeLightness(92);

     }
 
     }
 

-    m_active_colour = base_colour;
-    m_base_colour = base_colour;
-    wxColor border_colour = base_colour.ChangeLightness(75);
+    m_activeColour = baseColour;
+    m_baseColour = baseColour;
+    wxColor borderColour = baseColour.ChangeLightness(75);

 
 

-    m_border_pen = wxPen(border_colour);
-    m_base_colour_pen = wxPen(m_base_colour);
-    m_base_colour_brush = wxBrush(m_base_colour);
+    m_borderPen = wxPen(borderColour);
+    m_baseColourPen = wxPen(m_baseColour);
+    m_baseColourBrush = wxBrush(m_baseColour);

 
 

-    m_active_close_bmp = wxAuiBitmapFromBits(close_bits, 16, 16, *wxBLACK);
-    m_disabled_close_bmp = wxAuiBitmapFromBits(close_bits, 16, 16, wxColour(128,128,128));
+    m_activeCloseBmp = wxAuiBitmapFromBits(close_bits, 16, 16, *wxBLACK);
+    m_disabledCloseBmp = wxAuiBitmapFromBits(close_bits, 16, 16, wxColour(128,128,128));

 
 

-    m_active_left_bmp = wxAuiBitmapFromBits(left_bits, 16, 16, *wxBLACK);
-    m_disabled_left_bmp = wxAuiBitmapFromBits(left_bits, 16, 16, wxColour(128,128,128));
+    m_activeLeftBmp = wxAuiBitmapFromBits(left_bits, 16, 16, *wxBLACK);
+    m_disabledLeftBmp = wxAuiBitmapFromBits(left_bits, 16, 16, wxColour(128,128,128));

 
 

-    m_active_right_bmp = wxAuiBitmapFromBits(right_bits, 16, 16, *wxBLACK);
-    m_disabled_right_bmp = wxAuiBitmapFromBits(right_bits, 16, 16, wxColour(128,128,128));
+    m_activeRightBmp = wxAuiBitmapFromBits(right_bits, 16, 16, *wxBLACK);
+    m_disabledRightBmp = wxAuiBitmapFromBits(right_bits, 16, 16, wxColour(128,128,128));

 
 

-    m_active_windowlist_bmp = wxAuiBitmapFromBits(list_bits, 16, 16, *wxBLACK);
-    m_disabled_windowlist_bmp = wxAuiBitmapFromBits(list_bits, 16, 16, wxColour(128,128,128));
+    m_activeWindowListBmp = wxAuiBitmapFromBits(list_bits, 16, 16, *wxBLACK);
+    m_disabledWindowListBmp = wxAuiBitmapFromBits(list_bits, 16, 16, wxColour(128,128,128));

 
     m_flags = 0;
 }
 
     m_flags = 0;
 }


@@ -247,31 +247,31 @@ void wxAuiDefaultTabArt::SetFlags(unsigned int flags)
 void wxAuiDefaultTabArt::SetSizingInfo(const wxSize& tab_ctrl_size,
                                        size_t tab_count)
 {
 void wxAuiDefaultTabArt::SetSizingInfo(const wxSize& tab_ctrl_size,
                                        size_t tab_count)
 {

-    m_fixed_tab_width = 100;
+    m_fixedTabWidth = 100;

 
     int tot_width = (int)tab_ctrl_size.x - GetIndentSize() - 4;
 
     if (m_flags & wxAUI_NB_CLOSE_BUTTON)
 
     int tot_width = (int)tab_ctrl_size.x - GetIndentSize() - 4;
 
     if (m_flags & wxAUI_NB_CLOSE_BUTTON)

-        tot_width -= m_active_close_bmp.GetWidth();
+        tot_width -= m_activeCloseBmp.GetWidth();

     if (m_flags & wxAUI_NB_WINDOWLIST_BUTTON)
     if (m_flags & wxAUI_NB_WINDOWLIST_BUTTON)

-        tot_width -= m_active_windowlist_bmp.GetWidth();
+        tot_width -= m_activeWindowListBmp.GetWidth();

 
     if (tab_count > 0)
     {
 
     if (tab_count > 0)
     {

-        m_fixed_tab_width = tot_width/(int)tab_count;
+        m_fixedTabWidth = tot_width/(int)tab_count;

     }
 
 
     }
 
 

-    if (m_fixed_tab_width < 100)
-        m_fixed_tab_width = 100;
+    if (m_fixedTabWidth < 100)
+        m_fixedTabWidth = 100;

 
 

-    if (m_fixed_tab_width > tot_width/2)
-        m_fixed_tab_width = tot_width/2;
+    if (m_fixedTabWidth > tot_width/2)
+        m_fixedTabWidth = tot_width/2;

 
 

-    if (m_fixed_tab_width > 220)
-        m_fixed_tab_width = 220;
+    if (m_fixedTabWidth > 220)
+        m_fixedTabWidth = 220;

 
 

-    m_tab_ctrl_height = tab_ctrl_size.y;
+    m_tabCtrlHeight = tab_ctrl_size.y;

 }
 
 
 }
 
 


@@ -281,8 +281,8 @@ void wxAuiDefaultTabArt::DrawBackground(wxDC& dc,
 {
     // draw background
 
 {
     // draw background
 

-    wxColor top_color       = m_base_colour.ChangeLightness(90);
-    wxColor bottom_color   = m_base_colour.ChangeLightness(170);
+    wxColor top_color       = m_baseColour.ChangeLightness(90);
+    wxColor bottom_color   = m_baseColour.ChangeLightness(170);

     wxRect r;
 
    if (m_flags &wxAUI_NB_BOTTOM)
     wxRect r;
 
    if (m_flags &wxAUI_NB_BOTTOM)


@@ -297,7 +297,7 @@ void wxAuiDefaultTabArt::DrawBackground(wxDC& dc,
 
    // draw base lines
 
 
    // draw base lines
 

-   dc.SetPen(m_border_pen);
+   dc.SetPen(m_borderPen);

    int y = rect.GetHeight();
    int w = rect.GetWidth();
 
    int y = rect.GetHeight();
    int w = rect.GetWidth();
 


@@ -310,7 +310,7 @@ void wxAuiDefaultTabArt::DrawBackground(wxDC& dc,
    // TODO: else if (m_flags &wxAUI_NB_RIGHT) {}
    else //for wxAUI_NB_TOP
    {
    // TODO: else if (m_flags &wxAUI_NB_RIGHT) {}
    else //for wxAUI_NB_TOP
    {

-       dc.SetBrush(m_base_colour_brush);
+       dc.SetBrush(m_baseColourBrush);

        dc.DrawRectangle(-1, y-4, w+2, 4);
    }
 }
        dc.DrawRectangle(-1, y-4, w+2, 4);
    }
 }


@@ -343,10 +343,10 @@ void wxAuiDefaultTabArt::DrawTab(wxDC& dc,
     if (caption.empty())
         caption = wxT("Xj");
 
     if (caption.empty())
         caption = wxT("Xj");
 

-    dc.SetFont(m_selected_font);
+    dc.SetFont(m_selectedFont);

     dc.GetTextExtent(caption, &selected_textx, &selected_texty);
 
     dc.GetTextExtent(caption, &selected_textx, &selected_texty);
 

-    dc.SetFont(m_normal_font);
+    dc.SetFont(m_normalFont);

     dc.GetTextExtent(caption, &normal_textx, &normal_texty);
 
     // figure out the size of the tab
     dc.GetTextExtent(caption, &normal_textx, &normal_texty);
 
     // figure out the size of the tab


@@ -358,7 +358,7 @@ void wxAuiDefaultTabArt::DrawTab(wxDC& dc,
                                  close_button_state,
                                  x_extent);
 
                                  close_button_state,
                                  x_extent);
 

-    wxCoord tab_height = m_tab_ctrl_height - 3;
+    wxCoord tab_height = m_tabCtrlHeight - 3;

     wxCoord tab_width = tab_size.x;
     wxCoord tab_x = in_rect.x;
     wxCoord tab_y = in_rect.y + in_rect.height - tab_height;
     wxCoord tab_width = tab_size.x;
     wxCoord tab_x = in_rect.x;
     wxCoord tab_y = in_rect.y + in_rect.height - tab_height;


@@ -371,12 +371,12 @@ void wxAuiDefaultTabArt::DrawTab(wxDC& dc,
 
     if (page.active)
     {
 
     if (page.active)
     {

-        dc.SetFont(m_selected_font);
+        dc.SetFont(m_selectedFont);

         texty = selected_texty;
     }
     else
     {
         texty = selected_texty;
     }
     else
     {

-        dc.SetFont(m_normal_font);
+        dc.SetFont(m_normalFont);

         texty = normal_texty;
     }
 
         texty = normal_texty;
     }
 


@@ -440,8 +440,8 @@ void wxAuiDefaultTabArt::DrawTab(wxDC& dc,
 
         // draw base background color
         wxRect r(tab_x, tab_y, tab_width, tab_height);
 
         // draw base background color
         wxRect r(tab_x, tab_y, tab_width, tab_height);

-        dc.SetPen(wxPen(m_active_colour));
-        dc.SetBrush(wxBrush(m_active_colour));
+        dc.SetPen(wxPen(m_activeColour));
+        dc.SetBrush(wxBrush(m_activeColour));

         dc.DrawRectangle(r.x+1, r.y+1, r.width-1, r.height-4);
 
         // this white helps fill out the gradient at the top of the tab
         dc.DrawRectangle(r.x+1, r.y+1, r.width-1, r.height-4);
 
         // this white helps fill out the gradient at the top of the tab


@@ -450,7 +450,7 @@ void wxAuiDefaultTabArt::DrawTab(wxDC& dc,
         dc.DrawRectangle(r.x+2, r.y+1, r.width-3, r.height-4);
 
         // these two points help the rounded corners appear more antialiased
         dc.DrawRectangle(r.x+2, r.y+1, r.width-3, r.height-4);
 
         // these two points help the rounded corners appear more antialiased

-        dc.SetPen(wxPen(m_active_colour));
+        dc.SetPen(wxPen(m_activeColour));

         dc.DrawPoint(r.x+2, r.y+1);
         dc.DrawPoint(r.x+r.width-2, r.y+1);
 
         dc.DrawPoint(r.x+2, r.y+1);
         dc.DrawPoint(r.x+r.width-2, r.y+1);
 


@@ -463,7 +463,7 @@ void wxAuiDefaultTabArt::DrawTab(wxDC& dc,
 
         // draw gradient background
         wxColor top_color = *wxWHITE;
 
         // draw gradient background
         wxColor top_color = *wxWHITE;

-        wxColor bottom_color = m_active_colour;
+        wxColor bottom_color = m_activeColour;

         dc.GradientFillLinear(r, bottom_color, top_color, wxNORTH);
     }
     else
         dc.GradientFillLinear(r, bottom_color, top_color, wxNORTH);
     }
     else


@@ -482,7 +482,7 @@ void wxAuiDefaultTabArt::DrawTab(wxDC& dc,
         r.height--;
 
         // -- draw top gradient fill for glossy look
         r.height--;
 
         // -- draw top gradient fill for glossy look

-        wxColor top_color = m_base_colour;
+        wxColor top_color = m_baseColour;

         wxColor bottom_color = top_color.ChangeLightness(160);
         dc.GradientFillLinear(r, bottom_color, top_color, wxNORTH);
 
         wxColor bottom_color = top_color.ChangeLightness(160);
         dc.GradientFillLinear(r, bottom_color, top_color, wxNORTH);
 


@@ -490,13 +490,13 @@ void wxAuiDefaultTabArt::DrawTab(wxDC& dc,
         r.y--;
 
         // -- draw bottom fill for glossy look
         r.y--;
 
         // -- draw bottom fill for glossy look

-        top_color = m_base_colour;
-        bottom_color = m_base_colour;
+        top_color = m_baseColour;
+        bottom_color = m_baseColour;

         dc.GradientFillLinear(r, top_color, bottom_color, wxSOUTH);
     }
 
     // draw tab outline
         dc.GradientFillLinear(r, top_color, bottom_color, wxSOUTH);
     }
 
     // draw tab outline

-    dc.SetPen(m_border_pen);
+    dc.SetPen(m_borderPen);

     dc.SetBrush(*wxTRANSPARENT_BRUSH);
     dc.DrawPolygon(WXSIZEOF(border_points), border_points);
 
     dc.SetBrush(*wxTRANSPARENT_BRUSH);
     dc.DrawPolygon(WXSIZEOF(border_points), border_points);
 


@@ -505,11 +505,11 @@ void wxAuiDefaultTabArt::DrawTab(wxDC& dc,
     if (page.active)
     {
         if (m_flags &wxAUI_NB_BOTTOM)
     if (page.active)
     {
         if (m_flags &wxAUI_NB_BOTTOM)

-            dc.SetPen(wxPen(m_base_colour.ChangeLightness(170)));
+            dc.SetPen(wxPen(m_baseColour.ChangeLightness(170)));

         // TODO: else if (m_flags &wxAUI_NB_LEFT) {}
         // TODO: else if (m_flags &wxAUI_NB_RIGHT) {}
         else //for wxAUI_NB_TOP
         // TODO: else if (m_flags &wxAUI_NB_LEFT) {}
         // TODO: else if (m_flags &wxAUI_NB_RIGHT) {}
         else //for wxAUI_NB_TOP

-            dc.SetPen(m_base_colour_pen);
+            dc.SetPen(m_baseColourPen);

         dc.DrawLine(border_points[0].x+1,
                     border_points[0].y,
                     border_points[5].x,
         dc.DrawLine(border_points[0].x+1,
                     border_points[0].y,
                     border_points[5].x,


@@ -521,7 +521,7 @@ void wxAuiDefaultTabArt::DrawTab(wxDC& dc,
     int close_button_width = 0;
     if (close_button_state != wxAUI_BUTTON_STATE_HIDDEN)
     {
     int close_button_width = 0;
     if (close_button_state != wxAUI_BUTTON_STATE_HIDDEN)
     {

-        close_button_width = m_active_close_bmp.GetWidth();
+        close_button_width = m_activeCloseBmp.GetWidth();

     }
 
     int bitmap_offset = 0;
     }
 
     int bitmap_offset = 0;


@@ -582,12 +582,12 @@ void wxAuiDefaultTabArt::DrawTab(wxDC& dc,
     // draw close button if necessary
     if (close_button_state != wxAUI_BUTTON_STATE_HIDDEN)
     {
     // draw close button if necessary
     if (close_button_state != wxAUI_BUTTON_STATE_HIDDEN)
     {

-        wxBitmap bmp = m_disabled_close_bmp;
+        wxBitmap bmp = m_disabledCloseBmp;

 
         if (close_button_state == wxAUI_BUTTON_STATE_HOVER ||
             close_button_state == wxAUI_BUTTON_STATE_PRESSED)
         {
 
         if (close_button_state == wxAUI_BUTTON_STATE_HOVER ||
             close_button_state == wxAUI_BUTTON_STATE_PRESSED)
         {

-            bmp = m_active_close_bmp;
+            bmp = m_activeCloseBmp;

         }
 
         int offsetY = tab_y-1;
         }
 
         int offsetY = tab_y-1;


@@ -625,7 +625,7 @@ wxSize wxAuiDefaultTabArt::GetTabSize(wxDC& dc,
 {
     wxCoord measured_textx, measured_texty, tmp;
 
 {
     wxCoord measured_textx, measured_texty, tmp;
 

-    dc.SetFont(m_measuring_font);
+    dc.SetFont(m_measuringFont);

     dc.GetTextExtent(caption, &measured_textx, &measured_texty);
 
     dc.GetTextExtent(wxT("ABCDEFXj"), &tmp, &measured_texty);
     dc.GetTextExtent(caption, &measured_textx, &measured_texty);
 
     dc.GetTextExtent(wxT("ABCDEFXj"), &tmp, &measured_texty);


@@ -636,7 +636,7 @@ wxSize wxAuiDefaultTabArt::GetTabSize(wxDC& dc,
 
     // if the close button is showing, add space for it
     if (close_button_state != wxAUI_BUTTON_STATE_HIDDEN)
 
     // if the close button is showing, add space for it
     if (close_button_state != wxAUI_BUTTON_STATE_HIDDEN)

-        tab_width += m_active_close_bmp.GetWidth() + 3;
+        tab_width += m_activeCloseBmp.GetWidth() + 3;

 
     // if there's a bitmap, add space for it
     if (bitmap.IsOk())
 
     // if there's a bitmap, add space for it
     if (bitmap.IsOk())


@@ -652,7 +652,7 @@ wxSize wxAuiDefaultTabArt::GetTabSize(wxDC& dc,
 
     if (m_flags & wxAUI_NB_TAB_FIXED_WIDTH)
     {
 
     if (m_flags & wxAUI_NB_TAB_FIXED_WIDTH)
     {

-        tab_width = m_fixed_tab_width;
+        tab_width = m_fixedTabWidth;

     }
 
     *x_extent = tab_width;
     }
 
     *x_extent = tab_width;


@@ -676,27 +676,27 @@ void wxAuiDefaultTabArt::DrawButton(wxDC& dc,
     {
         case wxAUI_BUTTON_CLOSE:
             if (button_state & wxAUI_BUTTON_STATE_DISABLED)
     {
         case wxAUI_BUTTON_CLOSE:
             if (button_state & wxAUI_BUTTON_STATE_DISABLED)

-                bmp = m_disabled_close_bmp;
+                bmp = m_disabledCloseBmp;

             else
             else

-                bmp = m_active_close_bmp;
+                bmp = m_activeCloseBmp;

             break;
         case wxAUI_BUTTON_LEFT:
             if (button_state & wxAUI_BUTTON_STATE_DISABLED)
             break;
         case wxAUI_BUTTON_LEFT:
             if (button_state & wxAUI_BUTTON_STATE_DISABLED)

-                bmp = m_disabled_left_bmp;
+                bmp = m_disabledLeftBmp;

             else
             else

-                bmp = m_active_left_bmp;
+                bmp = m_activeLeftBmp;

             break;
         case wxAUI_BUTTON_RIGHT:
             if (button_state & wxAUI_BUTTON_STATE_DISABLED)
             break;
         case wxAUI_BUTTON_RIGHT:
             if (button_state & wxAUI_BUTTON_STATE_DISABLED)

-                bmp = m_disabled_right_bmp;
+                bmp = m_disabledRightBmp;

             else
             else

-                bmp = m_active_right_bmp;
+                bmp = m_activeRightBmp;

             break;
         case wxAUI_BUTTON_WINDOWLIST:
             if (button_state & wxAUI_BUTTON_STATE_DISABLED)
             break;
         case wxAUI_BUTTON_WINDOWLIST:
             if (button_state & wxAUI_BUTTON_STATE_DISABLED)

-                bmp = m_disabled_windowlist_bmp;
+                bmp = m_disabledWindowListBmp;

             else
             else

-                bmp = m_active_windowlist_bmp;
+                bmp = m_activeWindowListBmp;

             break;
     }
 
             break;
     }
 


@@ -771,19 +771,19 @@ int wxAuiDefaultTabArt::ShowDropDown(wxWindow* wnd,
 
 int wxAuiDefaultTabArt::GetBestTabCtrlSize(wxWindow* wnd,
                                            const wxAuiNotebookPageArray& pages,
 
 int wxAuiDefaultTabArt::GetBestTabCtrlSize(wxWindow* wnd,
                                            const wxAuiNotebookPageArray& pages,

-                                           const wxSize& required_bmp_size)
+                                           const wxSize& requiredBmp_size)

 {
     wxClientDC dc(wnd);
 {
     wxClientDC dc(wnd);

-    dc.SetFont(m_measuring_font);
+    dc.SetFont(m_measuringFont);

 
     // sometimes a standard bitmap size needs to be enforced, especially
     // if some tabs have bitmaps and others don't.  This is important because
     // it prevents the tab control from resizing when tabs are added.
 
     // sometimes a standard bitmap size needs to be enforced, especially
     // if some tabs have bitmaps and others don't.  This is important because
     // it prevents the tab control from resizing when tabs are added.

-    wxBitmap measure_bmp;
-    if (required_bmp_size.IsFullySpecified())
+    wxBitmap measureBmp;
+    if (requiredBmp_size.IsFullySpecified())

     {
     {

-        measure_bmp.Create(required_bmp_size.x,
-                           required_bmp_size.y);
+        measureBmp.Create(requiredBmp_size.x,
+                           requiredBmp_size.y);

     }
 
 
     }
 
 


@@ -794,8 +794,8 @@ int wxAuiDefaultTabArt::GetBestTabCtrlSize(wxWindow* wnd,
         wxAuiNotebookPage& page = pages.Item(i);
 
         wxBitmap bmp;
         wxAuiNotebookPage& page = pages.Item(i);
 
         wxBitmap bmp;

-        if (measure_bmp.IsOk())
-            bmp = measure_bmp;
+        if (measureBmp.IsOk())
+            bmp = measureBmp;

         else
             bmp = page.bitmap;
 
         else
             bmp = page.bitmap;
 


@@ -820,67 +820,67 @@ int wxAuiDefaultTabArt::GetBestTabCtrlSize(wxWindow* wnd,
 
 void wxAuiDefaultTabArt::SetNormalFont(const wxFont& font)
 {
 
 void wxAuiDefaultTabArt::SetNormalFont(const wxFont& font)
 {

-    m_normal_font = font;
+    m_normalFont = font;

 }
 
 void wxAuiDefaultTabArt::SetSelectedFont(const wxFont& font)
 {
 }
 
 void wxAuiDefaultTabArt::SetSelectedFont(const wxFont& font)
 {

-    m_selected_font = font;
+    m_selectedFont = font;

 }
 
 void wxAuiDefaultTabArt::SetMeasuringFont(const wxFont& font)
 {
 }
 
 void wxAuiDefaultTabArt::SetMeasuringFont(const wxFont& font)
 {

-    m_measuring_font = font;
+    m_measuringFont = font;

 }
 
 void wxAuiDefaultTabArt::SetColour(const wxColour& colour)
 {
 }
 
 void wxAuiDefaultTabArt::SetColour(const wxColour& colour)
 {

-    m_base_colour = colour;
-    m_border_pen = wxPen(m_base_colour.ChangeLightness(75));
-    m_base_colour_pen = wxPen(m_base_colour);
-    m_base_colour_brush = wxBrush(m_base_colour);
+    m_baseColour = colour;
+    m_borderPen = wxPen(m_baseColour.ChangeLightness(75));
+    m_baseColourPen = wxPen(m_baseColour);
+    m_baseColourBrush = wxBrush(m_baseColour);

 }
 
 void wxAuiDefaultTabArt::SetActiveColour(const wxColour& colour)
 {
 }
 
 void wxAuiDefaultTabArt::SetActiveColour(const wxColour& colour)
 {

-    m_active_colour = colour;
+    m_activeColour = colour;

 }
 
 // -- wxAuiSimpleTabArt class implementation --
 
 wxAuiSimpleTabArt::wxAuiSimpleTabArt()
 {
 }
 
 // -- wxAuiSimpleTabArt class implementation --
 
 wxAuiSimpleTabArt::wxAuiSimpleTabArt()
 {

-    m_normal_font = *wxNORMAL_FONT;
-    m_selected_font = *wxNORMAL_FONT;
-    m_selected_font.SetWeight(wxBOLD);
-    m_measuring_font = m_selected_font;
+    m_normalFont = *wxNORMAL_FONT;
+    m_selectedFont = *wxNORMAL_FONT;
+    m_selectedFont.SetWeight(wxBOLD);
+    m_measuringFont = m_selectedFont;

 
     m_flags = 0;
 
     m_flags = 0;

-    m_fixed_tab_width = 100;
+    m_fixedTabWidth = 100;

 
 

-    wxColour base_colour = wxSystemSettings::GetColour(wxSYS_COLOUR_3DFACE);
+    wxColour baseColour = wxSystemSettings::GetColour(wxSYS_COLOUR_3DFACE);

 
 

-    wxColour background_colour = base_colour;
-    wxColour normaltab_colour = base_colour;
-    wxColour selectedtab_colour = *wxWHITE;
+    wxColour backgroundColour = baseColour;
+    wxColour normaltabColour = baseColour;
+    wxColour selectedtabColour = *wxWHITE;

 
 

-    m_bkbrush = wxBrush(background_colour);
-    m_normal_bkbrush = wxBrush(normaltab_colour);
-    m_normal_bkpen = wxPen(normaltab_colour);
-    m_selected_bkbrush = wxBrush(selectedtab_colour);
-    m_selected_bkpen = wxPen(selectedtab_colour);
+    m_bkBrush = wxBrush(backgroundColour);
+    m_normalBkBrush = wxBrush(normaltabColour);
+    m_normalBkPen = wxPen(normaltabColour);
+    m_selectedBkBrush = wxBrush(selectedtabColour);
+    m_selectedBkPen = wxPen(selectedtabColour);

 
 

-    m_active_close_bmp = wxAuiBitmapFromBits(close_bits, 16, 16, *wxBLACK);
-    m_disabled_close_bmp = wxAuiBitmapFromBits(close_bits, 16, 16, wxColour(128,128,128));
+    m_activeCloseBmp = wxAuiBitmapFromBits(close_bits, 16, 16, *wxBLACK);
+    m_disabledCloseBmp = wxAuiBitmapFromBits(close_bits, 16, 16, wxColour(128,128,128));

 
 

-    m_active_left_bmp = wxAuiBitmapFromBits(left_bits, 16, 16, *wxBLACK);
-    m_disabled_left_bmp = wxAuiBitmapFromBits(left_bits, 16, 16, wxColour(128,128,128));
+    m_activeLeftBmp = wxAuiBitmapFromBits(left_bits, 16, 16, *wxBLACK);
+    m_disabledLeftBmp = wxAuiBitmapFromBits(left_bits, 16, 16, wxColour(128,128,128));

 
 

-    m_active_right_bmp = wxAuiBitmapFromBits(right_bits, 16, 16, *wxBLACK);
-    m_disabled_right_bmp = wxAuiBitmapFromBits(right_bits, 16, 16, wxColour(128,128,128));
+    m_activeRightBmp = wxAuiBitmapFromBits(right_bits, 16, 16, *wxBLACK);
+    m_disabledRightBmp = wxAuiBitmapFromBits(right_bits, 16, 16, wxColour(128,128,128));

 
 

-    m_active_windowlist_bmp = wxAuiBitmapFromBits(list_bits, 16, 16, *wxBLACK);
-    m_disabled_windowlist_bmp = wxAuiBitmapFromBits(list_bits, 16, 16, wxColour(128,128,128));
+    m_activeWindowListBmp = wxAuiBitmapFromBits(list_bits, 16, 16, *wxBLACK);
+    m_disabledWindowListBmp = wxAuiBitmapFromBits(list_bits, 16, 16, wxColour(128,128,128));

 
 }
 
 
 }
 


@@ -901,42 +901,42 @@ void wxAuiSimpleTabArt::SetFlags(unsigned int flags)
 void wxAuiSimpleTabArt::SetSizingInfo(const wxSize& tab_ctrl_size,
                                       size_t tab_count)
 {
 void wxAuiSimpleTabArt::SetSizingInfo(const wxSize& tab_ctrl_size,
                                       size_t tab_count)
 {

-    m_fixed_tab_width = 100;
+    m_fixedTabWidth = 100;

 
     int tot_width = (int)tab_ctrl_size.x - GetIndentSize() - 4;
 
     if (m_flags & wxAUI_NB_CLOSE_BUTTON)
 
     int tot_width = (int)tab_ctrl_size.x - GetIndentSize() - 4;
 
     if (m_flags & wxAUI_NB_CLOSE_BUTTON)

-        tot_width -= m_active_close_bmp.GetWidth();
+        tot_width -= m_activeCloseBmp.GetWidth();

     if (m_flags & wxAUI_NB_WINDOWLIST_BUTTON)
     if (m_flags & wxAUI_NB_WINDOWLIST_BUTTON)

-        tot_width -= m_active_windowlist_bmp.GetWidth();
+        tot_width -= m_activeWindowListBmp.GetWidth();

 
     if (tab_count > 0)
     {
 
     if (tab_count > 0)
     {

-        m_fixed_tab_width = tot_width/(int)tab_count;
+        m_fixedTabWidth = tot_width/(int)tab_count;

     }
 
 
     }
 
 

-    if (m_fixed_tab_width < 100)
-        m_fixed_tab_width = 100;
+    if (m_fixedTabWidth < 100)
+        m_fixedTabWidth = 100;

 
 

-    if (m_fixed_tab_width > tot_width/2)
-        m_fixed_tab_width = tot_width/2;
+    if (m_fixedTabWidth > tot_width/2)
+        m_fixedTabWidth = tot_width/2;

 
 

-    if (m_fixed_tab_width > 220)
-        m_fixed_tab_width = 220;
+    if (m_fixedTabWidth > 220)
+        m_fixedTabWidth = 220;

 }
 
 void wxAuiSimpleTabArt::SetColour(const wxColour& colour)
 {
 }
 
 void wxAuiSimpleTabArt::SetColour(const wxColour& colour)
 {

-    m_bkbrush = wxBrush(colour);
-    m_normal_bkbrush = wxBrush(colour);
-    m_normal_bkpen = wxPen(colour);
+    m_bkBrush = wxBrush(colour);
+    m_normalBkBrush = wxBrush(colour);
+    m_normalBkPen = wxPen(colour);

 }
 
 void wxAuiSimpleTabArt::SetActiveColour(const wxColour& colour)
 {
 }
 
 void wxAuiSimpleTabArt::SetActiveColour(const wxColour& colour)
 {

-    m_selected_bkbrush = wxBrush(colour);
-    m_selected_bkpen = wxPen(colour);
+    m_selectedBkBrush = wxBrush(colour);
+    m_selectedBkPen = wxPen(colour);

 }
 
 void wxAuiSimpleTabArt::DrawBackground(wxDC& dc,
 }
 
 void wxAuiSimpleTabArt::DrawBackground(wxDC& dc,


@@ -944,7 +944,7 @@ void wxAuiSimpleTabArt::DrawBackground(wxDC& dc,
                                        const wxRect& rect)
 {
     // draw background
                                        const wxRect& rect)
 {
     // draw background

-    dc.SetBrush(m_bkbrush);
+    dc.SetBrush(m_bkBrush);

     dc.SetPen(*wxTRANSPARENT_PEN);
     dc.DrawRectangle(-1, -1, rect.GetWidth()+2, rect.GetHeight()+2);
 
     dc.SetPen(*wxTRANSPARENT_PEN);
     dc.DrawRectangle(-1, -1, rect.GetWidth()+2, rect.GetHeight()+2);
 


@@ -981,10 +981,10 @@ void wxAuiSimpleTabArt::DrawTab(wxDC& dc,
     if (caption.empty())
         caption = wxT("Xj");
 
     if (caption.empty())
         caption = wxT("Xj");
 

-    dc.SetFont(m_selected_font);
+    dc.SetFont(m_selectedFont);

     dc.GetTextExtent(caption, &selected_textx, &selected_texty);
 
     dc.GetTextExtent(caption, &selected_textx, &selected_texty);
 

-    dc.SetFont(m_normal_font);
+    dc.SetFont(m_normalFont);

     dc.GetTextExtent(caption, &normal_textx, &normal_texty);
 
     // figure out the size of the tab
     dc.GetTextExtent(caption, &normal_textx, &normal_texty);
 
     // figure out the size of the tab


@@ -1007,17 +1007,17 @@ void wxAuiSimpleTabArt::DrawTab(wxDC& dc,
 
     if (page.active)
     {
 
     if (page.active)
     {

-        dc.SetPen(m_selected_bkpen);
-        dc.SetBrush(m_selected_bkbrush);
-        dc.SetFont(m_selected_font);
+        dc.SetPen(m_selectedBkPen);
+        dc.SetBrush(m_selectedBkBrush);
+        dc.SetFont(m_selectedFont);

         textx = selected_textx;
         texty = selected_texty;
     }
     else
     {
         textx = selected_textx;
         texty = selected_texty;
     }
     else
     {

-        dc.SetPen(m_normal_bkpen);
-        dc.SetBrush(m_normal_bkbrush);
-        dc.SetFont(m_normal_font);
+        dc.SetPen(m_normalBkPen);
+        dc.SetBrush(m_normalBkBrush);
+        dc.SetFont(m_normalFont);

         textx = normal_textx;
         texty = normal_texty;
     }
         textx = normal_textx;
         texty = normal_texty;
     }


@@ -1055,7 +1055,7 @@ void wxAuiSimpleTabArt::DrawTab(wxDC& dc,
     int close_button_width = 0;
     if (close_button_state != wxAUI_BUTTON_STATE_HIDDEN)
     {
     int close_button_width = 0;
     if (close_button_state != wxAUI_BUTTON_STATE_HIDDEN)
     {

-        close_button_width = m_active_close_bmp.GetWidth();
+        close_button_width = m_activeCloseBmp.GetWidth();

         text_offset = tab_x + (tab_height/2) + ((tab_width-close_button_width)/2) - (textx/2);
     }
     else
         text_offset = tab_x + (tab_height/2) + ((tab_width-close_button_width)/2) - (textx/2);
     }
     else


@@ -1094,9 +1094,9 @@ void wxAuiSimpleTabArt::DrawTab(wxDC& dc,
     {
         wxBitmap bmp;
         if (page.active)
     {
         wxBitmap bmp;
         if (page.active)

-            bmp = m_active_close_bmp;
+            bmp = m_activeCloseBmp;

         else
         else

-            bmp = m_disabled_close_bmp;
+            bmp = m_disabledCloseBmp;

 
         wxRect rect(tab_x + tab_width - close_button_width - 1,
                     tab_y + (tab_height/2) - (bmp.GetHeight()/2) + 1,
 
         wxRect rect(tab_x + tab_width - close_button_width - 1,
                     tab_y + (tab_height/2) - (bmp.GetHeight()/2) + 1,


@@ -1128,18 +1128,18 @@ wxSize wxAuiSimpleTabArt::GetTabSize(wxDC& dc,
 {
     wxCoord measured_textx, measured_texty;
 
 {
     wxCoord measured_textx, measured_texty;
 

-    dc.SetFont(m_measuring_font);
+    dc.SetFont(m_measuringFont);

     dc.GetTextExtent(caption, &measured_textx, &measured_texty);
 
     wxCoord tab_height = measured_texty + 4;
     wxCoord tab_width = measured_textx + tab_height + 5;
 
     if (close_button_state != wxAUI_BUTTON_STATE_HIDDEN)
     dc.GetTextExtent(caption, &measured_textx, &measured_texty);
 
     wxCoord tab_height = measured_texty + 4;
     wxCoord tab_width = measured_textx + tab_height + 5;
 
     if (close_button_state != wxAUI_BUTTON_STATE_HIDDEN)

-        tab_width += m_active_close_bmp.GetWidth();
+        tab_width += m_activeCloseBmp.GetWidth();

 
     if (m_flags & wxAUI_NB_TAB_FIXED_WIDTH)
     {
 
     if (m_flags & wxAUI_NB_TAB_FIXED_WIDTH)
     {

-        tab_width = m_fixed_tab_width;
+        tab_width = m_fixedTabWidth;

     }
 
     *x_extent = tab_width - (tab_height/2) - 1;
     }
 
     *x_extent = tab_width - (tab_height/2) - 1;


@@ -1163,27 +1163,27 @@ void wxAuiSimpleTabArt::DrawButton(wxDC& dc,
     {
         case wxAUI_BUTTON_CLOSE:
             if (button_state & wxAUI_BUTTON_STATE_DISABLED)
     {
         case wxAUI_BUTTON_CLOSE:
             if (button_state & wxAUI_BUTTON_STATE_DISABLED)

-                bmp = m_disabled_close_bmp;
+                bmp = m_disabledCloseBmp;

             else
             else

-                bmp = m_active_close_bmp;
+                bmp = m_activeCloseBmp;

             break;
         case wxAUI_BUTTON_LEFT:
             if (button_state & wxAUI_BUTTON_STATE_DISABLED)
             break;
         case wxAUI_BUTTON_LEFT:
             if (button_state & wxAUI_BUTTON_STATE_DISABLED)

-                bmp = m_disabled_left_bmp;
+                bmp = m_disabledLeftBmp;

             else
             else

-                bmp = m_active_left_bmp;
+                bmp = m_activeLeftBmp;

             break;
         case wxAUI_BUTTON_RIGHT:
             if (button_state & wxAUI_BUTTON_STATE_DISABLED)
             break;
         case wxAUI_BUTTON_RIGHT:
             if (button_state & wxAUI_BUTTON_STATE_DISABLED)

-                bmp = m_disabled_right_bmp;
+                bmp = m_disabledRightBmp;

             else
             else

-                bmp = m_active_right_bmp;
+                bmp = m_activeRightBmp;

             break;
         case wxAUI_BUTTON_WINDOWLIST:
             if (button_state & wxAUI_BUTTON_STATE_DISABLED)
             break;
         case wxAUI_BUTTON_WINDOWLIST:
             if (button_state & wxAUI_BUTTON_STATE_DISABLED)

-                bmp = m_disabled_windowlist_bmp;
+                bmp = m_disabledWindowListBmp;

             else
             else

-                bmp = m_active_windowlist_bmp;
+                bmp = m_activeWindowListBmp;

             break;
     }
 
             break;
     }
 


@@ -1258,10 +1258,10 @@ int wxAuiSimpleTabArt::ShowDropDown(wxWindow* wnd,
 
 int wxAuiSimpleTabArt::GetBestTabCtrlSize(wxWindow* wnd,
                                           const wxAuiNotebookPageArray& WXUNUSED(pages),
 
 int wxAuiSimpleTabArt::GetBestTabCtrlSize(wxWindow* wnd,
                                           const wxAuiNotebookPageArray& WXUNUSED(pages),

-                                          const wxSize& WXUNUSED(required_bmp_size))
+                                          const wxSize& WXUNUSED(requiredBmp_size))

 {
     wxClientDC dc(wnd);
 {
     wxClientDC dc(wnd);

-    dc.SetFont(m_measuring_font);
+    dc.SetFont(m_measuringFont);

     int x_ext = 0;
     wxSize s = GetTabSize(dc,
                           wnd,
     int x_ext = 0;
     wxSize s = GetTabSize(dc,
                           wnd,


@@ -1275,17 +1275,17 @@ int wxAuiSimpleTabArt::GetBestTabCtrlSize(wxWindow* wnd,
 
 void wxAuiSimpleTabArt::SetNormalFont(const wxFont& font)
 {
 
 void wxAuiSimpleTabArt::SetNormalFont(const wxFont& font)
 {

-    m_normal_font = font;
+    m_normalFont = font;

 }
 
 void wxAuiSimpleTabArt::SetSelectedFont(const wxFont& font)
 {
 }
 
 void wxAuiSimpleTabArt::SetSelectedFont(const wxFont& font)
 {

-    m_selected_font = font;
+    m_selectedFont = font;

 }
 
 void wxAuiSimpleTabArt::SetMeasuringFont(const wxFont& font)
 {
 }
 
 void wxAuiSimpleTabArt::SetMeasuringFont(const wxFont& font)
 {

-    m_measuring_font = font;
+    m_measuringFont = font;

 }
 
 
 }
 
 


@@ -1306,7 +1306,7 @@ void wxAuiSimpleTabArt::SetMeasuringFont(const wxFont& font)
 
 wxAuiTabContainer::wxAuiTabContainer()
 {
 
 wxAuiTabContainer::wxAuiTabContainer()
 {

-    m_tab_offset = 0;
+    m_tabOffset = 0;

     m_flags = 0;
     m_art = new wxAuiDefaultTabArt;
 
     m_flags = 0;
     m_art = new wxAuiDefaultTabArt;
 


@@ -1592,15 +1592,15 @@ size_t wxAuiTabContainer::GetPageCount() const
 
 void wxAuiTabContainer::AddButton(int id,
                                   int location,
 
 void wxAuiTabContainer::AddButton(int id,
                                   int location,

-                                  const wxBitmap& normal_bitmap,
-                                  const wxBitmap& disabled_bitmap)
+                                  const wxBitmap& normalBitmap,
+                                  const wxBitmap& disabledBitmap)

 {
     wxAuiTabContainerButton button;
     button.id = id;
 {
     wxAuiTabContainerButton button;
     button.id = id;

-    button.bitmap = normal_bitmap;
-    button.dis_bitmap = disabled_bitmap;
+    button.bitmap = normalBitmap;
+    button.disBitmap = disabledBitmap;

     button.location = location;
     button.location = location;

-    button.cur_state = wxAUI_BUTTON_STATE_NORMAL;
+    button.curState = wxAUI_BUTTON_STATE_NORMAL;

 
     m_buttons.Add(button);
 }
 
     m_buttons.Add(button);
 }


@@ -1623,12 +1623,12 @@ void wxAuiTabContainer::RemoveButton(int id)
 
 size_t wxAuiTabContainer::GetTabOffset() const
 {
 
 size_t wxAuiTabContainer::GetTabOffset() const
 {

-    return m_tab_offset;
+    return m_tabOffset;

 }
 
 void wxAuiTabContainer::SetTabOffset(size_t offset)
 {
 }
 
 void wxAuiTabContainer::SetTabOffset(size_t offset)
 {

-    m_tab_offset = offset;
+    m_tabOffset = offset;

 }
 
 
 }
 
 


@@ -1693,7 +1693,7 @@ void wxAuiTabContainer::Render(wxDC* raw_dc, wxWindow* wnd)
         else
             total_width += size.x;
 
         else
             total_width += size.x;
 

-        if (i >= m_tab_offset)
+        if (i >= m_tabOffset)

         {
             if (i+1 < page_count)
                 visible_width += x_extent;
         {
             if (i+1 < page_count)
                 visible_width += x_extent;


@@ -1702,7 +1702,7 @@ void wxAuiTabContainer::Render(wxDC* raw_dc, wxWindow* wnd)
         }
     }
 
         }
     }
 

-    if (total_width > m_rect.GetWidth() || m_tab_offset != 0)
+    if (total_width > m_rect.GetWidth() || m_tabOffset != 0)

     {
         // show left/right buttons
         for (i = 0; i < button_count; ++i)
     {
         // show left/right buttons
         for (i = 0; i < button_count; ++i)


@@ -1711,7 +1711,7 @@ void wxAuiTabContainer::Render(wxDC* raw_dc, wxWindow* wnd)
             if (button.id == wxAUI_BUTTON_LEFT ||
                 button.id == wxAUI_BUTTON_RIGHT)
             {
             if (button.id == wxAUI_BUTTON_LEFT ||
                 button.id == wxAUI_BUTTON_RIGHT)
             {

-                button.cur_state &= ~wxAUI_BUTTON_STATE_HIDDEN;
+                button.curState &= ~wxAUI_BUTTON_STATE_HIDDEN;

             }
         }
     }
             }
         }
     }


@@ -1724,7 +1724,7 @@ void wxAuiTabContainer::Render(wxDC* raw_dc, wxWindow* wnd)
             if (button.id == wxAUI_BUTTON_LEFT ||
                 button.id == wxAUI_BUTTON_RIGHT)
             {
             if (button.id == wxAUI_BUTTON_LEFT ||
                 button.id == wxAUI_BUTTON_RIGHT)
             {

-                button.cur_state |= wxAUI_BUTTON_STATE_HIDDEN;
+                button.curState |= wxAUI_BUTTON_STATE_HIDDEN;

             }
         }
     }
             }
         }
     }


@@ -1735,17 +1735,17 @@ void wxAuiTabContainer::Render(wxDC* raw_dc, wxWindow* wnd)
         wxAuiTabContainerButton& button = m_buttons.Item(i);
         if (button.id == wxAUI_BUTTON_LEFT)
         {
         wxAuiTabContainerButton& button = m_buttons.Item(i);
         if (button.id == wxAUI_BUTTON_LEFT)
         {

-            if (m_tab_offset == 0)
-                button.cur_state |= wxAUI_BUTTON_STATE_DISABLED;
+            if (m_tabOffset == 0)
+                button.curState |= wxAUI_BUTTON_STATE_DISABLED;

             else
             else

-                button.cur_state &= ~wxAUI_BUTTON_STATE_DISABLED;
+                button.curState &= ~wxAUI_BUTTON_STATE_DISABLED;

         }
         if (button.id == wxAUI_BUTTON_RIGHT)
         {
             if (visible_width < m_rect.GetWidth() - ((int)button_count*16))
         }
         if (button.id == wxAUI_BUTTON_RIGHT)
         {
             if (visible_width < m_rect.GetWidth() - ((int)button_count*16))

-                button.cur_state |= wxAUI_BUTTON_STATE_DISABLED;
+                button.curState |= wxAUI_BUTTON_STATE_DISABLED;

             else
             else

-                button.cur_state &= ~wxAUI_BUTTON_STATE_DISABLED;
+                button.curState &= ~wxAUI_BUTTON_STATE_DISABLED;

         }
     }
 
         }
     }
 


@@ -1768,7 +1768,7 @@ void wxAuiTabContainer::Render(wxDC* raw_dc, wxWindow* wnd)
 
         if (button.location != wxRIGHT)
             continue;
 
         if (button.location != wxRIGHT)
             continue;

-        if (button.cur_state & wxAUI_BUTTON_STATE_HIDDEN)
+        if (button.curState & wxAUI_BUTTON_STATE_HIDDEN)

             continue;
 
         wxRect button_rect = m_rect;
             continue;
 
         wxRect button_rect = m_rect;


@@ -1779,7 +1779,7 @@ void wxAuiTabContainer::Render(wxDC* raw_dc, wxWindow* wnd)
                           wnd,
                           button_rect,
                           button.id,
                           wnd,
                           button_rect,
                           button.id,

-                          button.cur_state,
+                          button.curState,

                           wxRIGHT,
                           &button.rect);
 
                           wxRIGHT,
                           &button.rect);
 


@@ -1799,7 +1799,7 @@ void wxAuiTabContainer::Render(wxDC* raw_dc, wxWindow* wnd)
 
         if (button.location != wxLEFT)
             continue;
 
         if (button.location != wxLEFT)
             continue;

-        if (button.cur_state & wxAUI_BUTTON_STATE_HIDDEN)
+        if (button.curState & wxAUI_BUTTON_STATE_HIDDEN)

             continue;
 
         wxRect button_rect(offset, 1, 1000, m_rect.height);
             continue;
 
         wxRect button_rect(offset, 1, 1000, m_rect.height);


@@ -1808,7 +1808,7 @@ void wxAuiTabContainer::Render(wxDC* raw_dc, wxWindow* wnd)
                           wnd,
                           button_rect,
                           button.id,
                           wnd,
                           button_rect,
                           button.id,

-                          button.cur_state,
+                          button.curState,

                           wxLEFT,
                           &button.rect);
 
                           wxLEFT,
                           &button.rect);
 


@@ -1824,24 +1824,24 @@ void wxAuiTabContainer::Render(wxDC* raw_dc, wxWindow* wnd)
 
     // prepare the tab-close-button array
     // make sure tab button entries which aren't used are marked as hidden
 
     // prepare the tab-close-button array
     // make sure tab button entries which aren't used are marked as hidden

-    for (i = page_count; i < m_tab_close_buttons.GetCount(); ++i)
-        m_tab_close_buttons.Item(i).cur_state = wxAUI_BUTTON_STATE_HIDDEN;
+    for (i = page_count; i < m_tabCloseButtons.GetCount(); ++i)
+        m_tabCloseButtons.Item(i).curState = wxAUI_BUTTON_STATE_HIDDEN;

 
     // make sure there are enough tab button entries to accommodate all tabs
 
     // make sure there are enough tab button entries to accommodate all tabs

-    while (m_tab_close_buttons.GetCount() < page_count)
+    while (m_tabCloseButtons.GetCount() < page_count)

     {
         wxAuiTabContainerButton tempbtn;
         tempbtn.id = wxAUI_BUTTON_CLOSE;
         tempbtn.location = wxCENTER;
     {
         wxAuiTabContainerButton tempbtn;
         tempbtn.id = wxAUI_BUTTON_CLOSE;
         tempbtn.location = wxCENTER;

-        tempbtn.cur_state = wxAUI_BUTTON_STATE_HIDDEN;
-        m_tab_close_buttons.Add(tempbtn);
+        tempbtn.curState = wxAUI_BUTTON_STATE_HIDDEN;
+        m_tabCloseButtons.Add(tempbtn);

     }
 
 
     // buttons before the tab offset must be set to hidden
     }
 
 
     // buttons before the tab offset must be set to hidden

-    for (i = 0; i < m_tab_offset; ++i)
+    for (i = 0; i < m_tabOffset; ++i)

     {
     {

-        m_tab_close_buttons.Item(i).cur_state = wxAUI_BUTTON_STATE_HIDDEN;
+        m_tabCloseButtons.Item(i).curState = wxAUI_BUTTON_STATE_HIDDEN;

     }
 
 
     }
 
 


@@ -1856,25 +1856,25 @@ void wxAuiTabContainer::Render(wxDC* raw_dc, wxWindow* wnd)
     rect.y = 0;
     rect.height = m_rect.height;
 
     rect.y = 0;
     rect.height = m_rect.height;
 

-    for (i = m_tab_offset; i < page_count; ++i)
+    for (i = m_tabOffset; i < page_count; ++i)

     {
         wxAuiNotebookPage& page = m_pages.Item(i);
     {
         wxAuiNotebookPage& page = m_pages.Item(i);

-        wxAuiTabContainerButton& tab_button = m_tab_close_buttons.Item(i);
+        wxAuiTabContainerButton& tab_button = m_tabCloseButtons.Item(i);

 
         // determine if a close button is on this tab
         if ((m_flags & wxAUI_NB_CLOSE_ON_ALL_TABS) != 0 ||
             ((m_flags & wxAUI_NB_CLOSE_ON_ACTIVE_TAB) != 0 && page.active))
         {
 
         // determine if a close button is on this tab
         if ((m_flags & wxAUI_NB_CLOSE_ON_ALL_TABS) != 0 ||
             ((m_flags & wxAUI_NB_CLOSE_ON_ACTIVE_TAB) != 0 && page.active))
         {

-            if (tab_button.cur_state == wxAUI_BUTTON_STATE_HIDDEN)
+            if (tab_button.curState == wxAUI_BUTTON_STATE_HIDDEN)

             {
                 tab_button.id = wxAUI_BUTTON_CLOSE;
             {
                 tab_button.id = wxAUI_BUTTON_CLOSE;

-                tab_button.cur_state = wxAUI_BUTTON_STATE_NORMAL;
+                tab_button.curState = wxAUI_BUTTON_STATE_NORMAL;

                 tab_button.location = wxCENTER;
             }
         }
         else
         {
                 tab_button.location = wxCENTER;
             }
         }
         else
         {

-            tab_button.cur_state = wxAUI_BUTTON_STATE_HIDDEN;
+            tab_button.curState = wxAUI_BUTTON_STATE_HIDDEN;

         }
 
         rect.x = offset;
         }
 
         rect.x = offset;


@@ -1887,7 +1887,7 @@ void wxAuiTabContainer::Render(wxDC* raw_dc, wxWindow* wnd)
                        wnd,
                        page,
                        rect,
                        wnd,
                        page,
                        rect,

-                       tab_button.cur_state,
+                       tab_button.curState,

                        &page.rect,
                        &tab_button.rect,
                        &x_extent);
                        &page.rect,
                        &tab_button.rect,
                        &x_extent);


@@ -1904,25 +1904,25 @@ void wxAuiTabContainer::Render(wxDC* raw_dc, wxWindow* wnd)
 
 
     // make sure to deactivate buttons which are off the screen to the right
 
 
     // make sure to deactivate buttons which are off the screen to the right

-    for (++i; i < m_tab_close_buttons.GetCount(); ++i)
+    for (++i; i < m_tabCloseButtons.GetCount(); ++i)

     {
     {

-        m_tab_close_buttons.Item(i).cur_state = wxAUI_BUTTON_STATE_HIDDEN;
+        m_tabCloseButtons.Item(i).curState = wxAUI_BUTTON_STATE_HIDDEN;

     }
 
 
     // draw the active tab again so it stands in the foreground
     }
 
 
     // draw the active tab again so it stands in the foreground

-    if (active >= m_tab_offset && active < m_pages.GetCount())
+    if (active >= m_tabOffset && active < m_pages.GetCount())

     {
         wxAuiNotebookPage& page = m_pages.Item(active);
 
     {
         wxAuiNotebookPage& page = m_pages.Item(active);
 

-        wxAuiTabContainerButton& tab_button = m_tab_close_buttons.Item(active);
+        wxAuiTabContainerButton& tab_button = m_tabCloseButtons.Item(active);

 
         rect.x = active_offset;
         m_art->DrawTab(dc,
                        wnd,
                        page,
                        active_rect,
 
         rect.x = active_offset;
         m_art->DrawTab(dc,
                        wnd,
                        page,
                        active_rect,

-                       tab_button.cur_state,
+                       tab_button.curState,

                        &page.rect,
                        &tab_button.rect,
                        &x_extent);
                        &page.rect,
                        &tab_button.rect,
                        &x_extent);


@@ -1945,7 +1945,7 @@ bool wxAuiTabContainer::IsTabVisible(int tabPage, int tabOffset, wxDC* dc, wxWin
     size_t button_count = m_buttons.GetCount();
 
     // Hasn't been rendered yet; assume it's visible
     size_t button_count = m_buttons.GetCount();
 
     // Hasn't been rendered yet; assume it's visible

-    if (m_tab_close_buttons.GetCount() < page_count)
+    if (m_tabCloseButtons.GetCount() < page_count)

         return true;
 
     // First check if both buttons are disabled - if so, there's no need to
         return true;
 
     // First check if both buttons are disabled - if so, there's no need to


@@ -1957,7 +1957,7 @@ bool wxAuiTabContainer::IsTabVisible(int tabPage, int tabOffset, wxDC* dc, wxWin
         if (button.id == wxAUI_BUTTON_LEFT ||
             button.id == wxAUI_BUTTON_RIGHT)
         {
         if (button.id == wxAUI_BUTTON_LEFT ||
             button.id == wxAUI_BUTTON_RIGHT)
         {

-            if ((button.cur_state & wxAUI_BUTTON_STATE_HIDDEN) == 0)
+            if ((button.curState & wxAUI_BUTTON_STATE_HIDDEN) == 0)

                 arrowButtonVisibleCount ++;
         }
     }
                 arrowButtonVisibleCount ++;
         }
     }


@@ -1984,7 +1984,7 @@ bool wxAuiTabContainer::IsTabVisible(int tabPage, int tabOffset, wxDC* dc, wxWin
 
         if (button.location != wxRIGHT)
             continue;
 
         if (button.location != wxRIGHT)
             continue;

-        if (button.cur_state & wxAUI_BUTTON_STATE_HIDDEN)
+        if (button.curState & wxAUI_BUTTON_STATE_HIDDEN)

             continue;
 
         offset -= button.rect.GetWidth();
             continue;
 
         offset -= button.rect.GetWidth();


@@ -2000,7 +2000,7 @@ bool wxAuiTabContainer::IsTabVisible(int tabPage, int tabOffset, wxDC* dc, wxWin
 
         if (button.location != wxLEFT)
             continue;
 
         if (button.location != wxLEFT)
             continue;

-        if (button.cur_state & wxAUI_BUTTON_STATE_HIDDEN)
+        if (button.curState & wxAUI_BUTTON_STATE_HIDDEN)

             continue;
 
         offset += button.rect.GetWidth();
             continue;
 
         offset += button.rect.GetWidth();


@@ -2022,7 +2022,7 @@ bool wxAuiTabContainer::IsTabVisible(int tabPage, int tabOffset, wxDC* dc, wxWin
     for (i = tabOffset; i < page_count; ++i)
     {
         wxAuiNotebookPage& page = m_pages.Item(i);
     for (i = tabOffset; i < page_count; ++i)
     {
         wxAuiNotebookPage& page = m_pages.Item(i);

-        wxAuiTabContainerButton& tab_button = m_tab_close_buttons.Item(i);
+        wxAuiTabContainerButton& tab_button = m_tabCloseButtons.Item(i);

 
         rect.x = offset;
         rect.width = m_rect.width - right_buttons_width - offset - 2;
 
         rect.x = offset;
         rect.width = m_rect.width - right_buttons_width - offset - 2;


@@ -2031,12 +2031,12 @@ bool wxAuiTabContainer::IsTabVisible(int tabPage, int tabOffset, wxDC* dc, wxWin
             return false; // haven't found the tab, and we've run out of space, so return false
 
         int x_extent = 0;
             return false; // haven't found the tab, and we've run out of space, so return false
 
         int x_extent = 0;

-        wxSize size = m_art->GetTabSize(*dc,
+        m_art->GetTabSize(*dc,

                             wnd,
                             page.caption,
                             page.bitmap,
                             page.active,
                             wnd,
                             page.caption,
                             page.bitmap,
                             page.active,

-                            tab_button.cur_state,
+                            tab_button.curState,

                             &x_extent);
 
         offset += x_extent;
                             &x_extent);
 
         offset += x_extent;


@@ -2085,7 +2085,7 @@ bool wxAuiTabContainer::TabHitTest(int x, int y, wxWindow** hit) const
         return false;
 
     wxAuiTabContainerButton* btn = NULL;
         return false;
 
     wxAuiTabContainerButton* btn = NULL;

-    if (ButtonHitTest(x, y, &btn) && !(btn->cur_state & wxAUI_BUTTON_STATE_DISABLED))
+    if (ButtonHitTest(x, y, &btn) && !(btn->curState & wxAUI_BUTTON_STATE_DISABLED))

     {
         if (m_buttons.Index(*btn) != wxNOT_FOUND)
             return false;
     {
         if (m_buttons.Index(*btn) != wxNOT_FOUND)
             return false;


@@ -2093,7 +2093,7 @@ bool wxAuiTabContainer::TabHitTest(int x, int y, wxWindow** hit) const
 
     size_t i, page_count = m_pages.GetCount();
 
 
     size_t i, page_count = m_pages.GetCount();
 

-    for (i = m_tab_offset; i < page_count; ++i)
+    for (i = m_tabOffset; i < page_count; ++i)

     {
         wxAuiNotebookPage& page = m_pages.Item(i);
         if (page.rect.Contains(x,y))
     {
         wxAuiNotebookPage& page = m_pages.Item(i);
         if (page.rect.Contains(x,y))


@@ -2123,7 +2123,7 @@ bool wxAuiTabContainer::ButtonHitTest(int x, int y,
     {
         wxAuiTabContainerButton& button = m_buttons.Item(i);
         if (button.rect.Contains(x,y) &&
     {
         wxAuiTabContainerButton& button = m_buttons.Item(i);
         if (button.rect.Contains(x,y) &&

-            !(button.cur_state & wxAUI_BUTTON_STATE_HIDDEN ))
+            !(button.curState & wxAUI_BUTTON_STATE_HIDDEN ))

         {
             if (hit)
                 *hit = &button;
         {
             if (hit)
                 *hit = &button;


@@ -2131,12 +2131,12 @@ bool wxAuiTabContainer::ButtonHitTest(int x, int y,
         }
     }
 
         }
     }
 

-    button_count = m_tab_close_buttons.GetCount();
+    button_count = m_tabCloseButtons.GetCount();

     for (i = 0; i < button_count; ++i)
     {
     for (i = 0; i < button_count; ++i)
     {

-        wxAuiTabContainerButton& button = m_tab_close_buttons.Item(i);
+        wxAuiTabContainerButton& button = m_tabCloseButtons.Item(i);

         if (button.rect.Contains(x,y) &&
         if (button.rect.Contains(x,y) &&

-            !(button.cur_state & (wxAUI_BUTTON_STATE_HIDDEN |
+            !(button.curState & (wxAUI_BUTTON_STATE_HIDDEN |

                                    wxAUI_BUTTON_STATE_DISABLED)))
         {
             if (hit)
                                    wxAUI_BUTTON_STATE_DISABLED)))
         {
             if (hit)


@@ -2233,10 +2233,10 @@ wxAuiTabCtrl::wxAuiTabCtrl(wxWindow* parent,
                            long style) : wxControl(parent, id, pos, size, style)
 {
     SetName(wxT("wxAuiTabCtrl"));
                            long style) : wxControl(parent, id, pos, size, style)
 {
     SetName(wxT("wxAuiTabCtrl"));

-    m_click_pt = wxDefaultPosition;
-    m_is_dragging = false;
-    m_hover_button = NULL;
-    m_pressed_button = NULL;
+    m_clickPt = wxDefaultPosition;
+    m_isDragging = false;
+    m_hoverButton = NULL;
+    m_pressedButton = NULL;

 }
 
 wxAuiTabCtrl::~wxAuiTabCtrl()
 }
 
 wxAuiTabCtrl::~wxAuiTabCtrl()


@@ -2267,10 +2267,10 @@ void wxAuiTabCtrl::OnSize(wxSizeEvent& evt)
 void wxAuiTabCtrl::OnLeftDown(wxMouseEvent& evt)
 {
     CaptureMouse();
 void wxAuiTabCtrl::OnLeftDown(wxMouseEvent& evt)
 {
     CaptureMouse();

-    m_click_pt = wxDefaultPosition;
-    m_is_dragging = false;
-    m_click_tab = NULL;
-    m_pressed_button = NULL;
+    m_clickPt = wxDefaultPosition;
+    m_isDragging = false;
+    m_clickTab = NULL;
+    m_pressedButton = NULL;

 
 
     wxWindow* wnd;
 
 
     wxWindow* wnd;


@@ -2291,15 +2291,15 @@ void wxAuiTabCtrl::OnLeftDown(wxMouseEvent& evt)
             GetEventHandler()->ProcessEvent(e);
         }
 
             GetEventHandler()->ProcessEvent(e);
         }
 

-        m_click_pt.x = evt.m_x;
-        m_click_pt.y = evt.m_y;
-        m_click_tab = wnd;
+        m_clickPt.x = evt.m_x;
+        m_clickPt.y = evt.m_y;
+        m_clickTab = wnd;

     }
 
     }
 

-    if (m_hover_button)
+    if (m_hoverButton)

     {
     {

-        m_pressed_button = m_hover_button;
-        m_pressed_button->cur_state = wxAUI_BUTTON_STATE_PRESSED;
+        m_pressedButton = m_hoverButton;
+        m_pressedButton->curState = wxAUI_BUTTON_STATE_PRESSED;

         Refresh();
         Update();
     }
         Refresh();
         Update();
     }


@@ -2307,12 +2307,12 @@ void wxAuiTabCtrl::OnLeftDown(wxMouseEvent& evt)
 
 void wxAuiTabCtrl::OnCaptureLost(wxMouseCaptureLostEvent& WXUNUSED(event))
 {
 
 void wxAuiTabCtrl::OnCaptureLost(wxMouseCaptureLostEvent& WXUNUSED(event))
 {

-    if (m_is_dragging)
+    if (m_isDragging)

     {
     {

-        m_is_dragging = false;
+        m_isDragging = false;

 
         wxAuiNotebookEvent evt(wxEVT_COMMAND_AUINOTEBOOK_CANCEL_DRAG, m_windowId);
 
         wxAuiNotebookEvent evt(wxEVT_COMMAND_AUINOTEBOOK_CANCEL_DRAG, m_windowId);

-        evt.SetSelection(GetIdxFromWindow(m_click_tab));
+        evt.SetSelection(GetIdxFromWindow(m_clickTab));

         evt.SetOldSelection(evt.GetSelection());
         evt.SetEventObject(this);
         GetEventHandler()->ProcessEvent(evt);
         evt.SetOldSelection(evt.GetSelection());
         evt.SetEventObject(this);
         GetEventHandler()->ProcessEvent(evt);


@@ -2324,12 +2324,12 @@ void wxAuiTabCtrl::OnLeftUp(wxMouseEvent& evt)
     if (GetCapture() == this)
         ReleaseMouse();
 
     if (GetCapture() == this)
         ReleaseMouse();
 

-    if (m_is_dragging)
+    if (m_isDragging)

     {
     {

-        m_is_dragging = false;
+        m_isDragging = false;

 
         wxAuiNotebookEvent evt(wxEVT_COMMAND_AUINOTEBOOK_END_DRAG, m_windowId);
 
         wxAuiNotebookEvent evt(wxEVT_COMMAND_AUINOTEBOOK_END_DRAG, m_windowId);

-        evt.SetSelection(GetIdxFromWindow(m_click_tab));
+        evt.SetSelection(GetIdxFromWindow(m_clickTab));

         evt.SetOldSelection(evt.GetSelection());
         evt.SetEventObject(this);
         GetEventHandler()->ProcessEvent(evt);
         evt.SetOldSelection(evt.GetSelection());
         evt.SetEventObject(this);
         GetEventHandler()->ProcessEvent(evt);


@@ -2337,38 +2337,38 @@ void wxAuiTabCtrl::OnLeftUp(wxMouseEvent& evt)
         return;
     }
 
         return;
     }
 

-    if (m_pressed_button)
+    if (m_pressedButton)

     {
         // make sure we're still clicking the button
         wxAuiTabContainerButton* button = NULL;
         if (!ButtonHitTest(evt.m_x, evt.m_y, &button) ||
     {
         // make sure we're still clicking the button
         wxAuiTabContainerButton* button = NULL;
         if (!ButtonHitTest(evt.m_x, evt.m_y, &button) ||

-            button->cur_state & wxAUI_BUTTON_STATE_DISABLED)
+            button->curState & wxAUI_BUTTON_STATE_DISABLED)

             return;
 
             return;
 

-        if (button != m_pressed_button)
+        if (button != m_pressedButton)

         {
         {

-            m_pressed_button = NULL;
+            m_pressedButton = NULL;

             return;
         }
 
         Refresh();
         Update();
 
             return;
         }
 
         Refresh();
         Update();
 

-        if (!(m_pressed_button->cur_state & wxAUI_BUTTON_STATE_DISABLED))
+        if (!(m_pressedButton->curState & wxAUI_BUTTON_STATE_DISABLED))

         {
             wxAuiNotebookEvent evt(wxEVT_COMMAND_AUINOTEBOOK_BUTTON, m_windowId);
         {
             wxAuiNotebookEvent evt(wxEVT_COMMAND_AUINOTEBOOK_BUTTON, m_windowId);

-            evt.SetSelection(GetIdxFromWindow(m_click_tab));
-            evt.SetInt(m_pressed_button->id);
+            evt.SetSelection(GetIdxFromWindow(m_clickTab));
+            evt.SetInt(m_pressedButton->id);

             evt.SetEventObject(this);
             GetEventHandler()->ProcessEvent(evt);
         }
 
             evt.SetEventObject(this);
             GetEventHandler()->ProcessEvent(evt);
         }
 

-        m_pressed_button = NULL;
+        m_pressedButton = NULL;

     }
 
     }
 

-    m_click_pt = wxDefaultPosition;
-    m_is_dragging = false;
-    m_click_tab = NULL;
+    m_clickPt = wxDefaultPosition;
+    m_isDragging = false;
+    m_clickTab = NULL;

 }
 
 void wxAuiTabCtrl::OnMiddleUp(wxMouseEvent& evt)
 }
 
 void wxAuiTabCtrl::OnMiddleUp(wxMouseEvent& evt)


@@ -2437,44 +2437,44 @@ void wxAuiTabCtrl::OnMotion(wxMouseEvent& evt)
 
     // check if the mouse is hovering above a button
     wxAuiTabContainerButton* button;
 
     // check if the mouse is hovering above a button
     wxAuiTabContainerButton* button;

-    if (ButtonHitTest(pos.x, pos.y, &button) && !(button->cur_state & wxAUI_BUTTON_STATE_DISABLED))
+    if (ButtonHitTest(pos.x, pos.y, &button) && !(button->curState & wxAUI_BUTTON_STATE_DISABLED))

     {
     {

-        if (m_hover_button && button != m_hover_button)
+        if (m_hoverButton && button != m_hoverButton)

         {
         {

-            m_hover_button->cur_state = wxAUI_BUTTON_STATE_NORMAL;
-            m_hover_button = NULL;
+            m_hoverButton->curState = wxAUI_BUTTON_STATE_NORMAL;
+            m_hoverButton = NULL;

             Refresh();
             Update();
         }
 
             Refresh();
             Update();
         }
 

-        if (button->cur_state != wxAUI_BUTTON_STATE_HOVER)
+        if (button->curState != wxAUI_BUTTON_STATE_HOVER)

         {
         {

-            button->cur_state = wxAUI_BUTTON_STATE_HOVER;
+            button->curState = wxAUI_BUTTON_STATE_HOVER;

             Refresh();
             Update();
             Refresh();
             Update();

-            m_hover_button = button;
+            m_hoverButton = button;

             return;
         }
     }
     else
     {
             return;
         }
     }
     else
     {

-        if (m_hover_button)
+        if (m_hoverButton)

         {
         {

-            m_hover_button->cur_state = wxAUI_BUTTON_STATE_NORMAL;
-            m_hover_button = NULL;
+            m_hoverButton->curState = wxAUI_BUTTON_STATE_NORMAL;
+            m_hoverButton = NULL;

             Refresh();
             Update();
         }
     }
 
 
             Refresh();
             Update();
         }
     }
 
 

-    if (!evt.LeftIsDown() || m_click_pt == wxDefaultPosition)
+    if (!evt.LeftIsDown() || m_clickPt == wxDefaultPosition)

         return;
 
         return;
 

-    if (m_is_dragging)
+    if (m_isDragging)

     {
         wxAuiNotebookEvent evt(wxEVT_COMMAND_AUINOTEBOOK_DRAG_MOTION, m_windowId);
     {
         wxAuiNotebookEvent evt(wxEVT_COMMAND_AUINOTEBOOK_DRAG_MOTION, m_windowId);

-        evt.SetSelection(GetIdxFromWindow(m_click_tab));
+        evt.SetSelection(GetIdxFromWindow(m_clickTab));

         evt.SetOldSelection(evt.GetSelection());
         evt.SetEventObject(this);
         GetEventHandler()->ProcessEvent(evt);
         evt.SetOldSelection(evt.GetSelection());
         evt.SetEventObject(this);
         GetEventHandler()->ProcessEvent(evt);


@@ -2485,25 +2485,25 @@ void wxAuiTabCtrl::OnMotion(wxMouseEvent& evt)
     int drag_x_threshold = wxSystemSettings::GetMetric(wxSYS_DRAG_X);
     int drag_y_threshold = wxSystemSettings::GetMetric(wxSYS_DRAG_Y);
 
     int drag_x_threshold = wxSystemSettings::GetMetric(wxSYS_DRAG_X);
     int drag_y_threshold = wxSystemSettings::GetMetric(wxSYS_DRAG_Y);
 

-    if (abs(pos.x - m_click_pt.x) > drag_x_threshold ||
-        abs(pos.y - m_click_pt.y) > drag_y_threshold)
+    if (abs(pos.x - m_clickPt.x) > drag_x_threshold ||
+        abs(pos.y - m_clickPt.y) > drag_y_threshold)

     {
         wxAuiNotebookEvent evt(wxEVT_COMMAND_AUINOTEBOOK_BEGIN_DRAG, m_windowId);
     {
         wxAuiNotebookEvent evt(wxEVT_COMMAND_AUINOTEBOOK_BEGIN_DRAG, m_windowId);

-        evt.SetSelection(GetIdxFromWindow(m_click_tab));
+        evt.SetSelection(GetIdxFromWindow(m_clickTab));

         evt.SetOldSelection(evt.GetSelection());
         evt.SetEventObject(this);
         GetEventHandler()->ProcessEvent(evt);
 
         evt.SetOldSelection(evt.GetSelection());
         evt.SetEventObject(this);
         GetEventHandler()->ProcessEvent(evt);
 

-        m_is_dragging = true;
+        m_isDragging = true;

     }
 }
 
 void wxAuiTabCtrl::OnLeaveWindow(wxMouseEvent& WXUNUSED(event))
 {
     }
 }
 
 void wxAuiTabCtrl::OnLeaveWindow(wxMouseEvent& WXUNUSED(event))
 {

-    if (m_hover_button)
+    if (m_hoverButton)

     {
     {

-        m_hover_button->cur_state = wxAUI_BUTTON_STATE_NORMAL;
-        m_hover_button = NULL;
+        m_hoverButton->curState = wxAUI_BUTTON_STATE_NORMAL;
+        m_hoverButton = NULL;

         Refresh();
         Update();
     }
         Refresh();
         Update();
     }


@@ -2699,7 +2699,7 @@ public:
     {
         m_tabs = NULL;
         m_rect = wxRect(0,0,200,200);
     {
         m_tabs = NULL;
         m_rect = wxRect(0,0,200,200);

-        m_tab_ctrl_height = 20;
+        m_tabCtrlHeight = 20;

     }
 
     ~wxTabFrame()
     }
 
     ~wxTabFrame()


@@ -2709,7 +2709,7 @@ public:
 
     void SetTabCtrlHeight(int h)
     {
 
     void SetTabCtrlHeight(int h)
     {

-        m_tab_ctrl_height = h;
+        m_tabCtrlHeight = h;

     }
 
 protected:
     }
 
 protected:


@@ -2738,18 +2738,18 @@ public:
         if (m_tabs->IsFrozen() || m_tabs->GetParent()->IsFrozen())
             return;
 
         if (m_tabs->IsFrozen() || m_tabs->GetParent()->IsFrozen())
             return;
 

-        m_tab_rect = wxRect(m_rect.x, m_rect.y, m_rect.width, m_tab_ctrl_height);
+        m_tab_rect = wxRect(m_rect.x, m_rect.y, m_rect.width, m_tabCtrlHeight);

         if (m_tabs->GetFlags() & wxAUI_NB_BOTTOM)
         {
         if (m_tabs->GetFlags() & wxAUI_NB_BOTTOM)
         {

-            m_tab_rect = wxRect (m_rect.x, m_rect.y + m_rect.height - m_tab_ctrl_height, m_rect.width, m_tab_ctrl_height);
-            m_tabs->SetSize     (m_rect.x, m_rect.y + m_rect.height - m_tab_ctrl_height, m_rect.width, m_tab_ctrl_height);
-            m_tabs->SetRect     (wxRect(0, 0, m_rect.width, m_tab_ctrl_height));
+            m_tab_rect = wxRect (m_rect.x, m_rect.y + m_rect.height - m_tabCtrlHeight, m_rect.width, m_tabCtrlHeight);
+            m_tabs->SetSize     (m_rect.x, m_rect.y + m_rect.height - m_tabCtrlHeight, m_rect.width, m_tabCtrlHeight);
+            m_tabs->SetRect     (wxRect(0, 0, m_rect.width, m_tabCtrlHeight));

         }
         else //TODO: if (GetFlags() & wxAUI_NB_TOP)
         {
         }
         else //TODO: if (GetFlags() & wxAUI_NB_TOP)
         {

-            m_tab_rect = wxRect (m_rect.x, m_rect.y, m_rect.width, m_tab_ctrl_height);
-            m_tabs->SetSize     (m_rect.x, m_rect.y, m_rect.width, m_tab_ctrl_height);
-            m_tabs->SetRect     (wxRect(0, 0,        m_rect.width, m_tab_ctrl_height));
+            m_tab_rect = wxRect (m_rect.x, m_rect.y, m_rect.width, m_tabCtrlHeight);
+            m_tabs->SetSize     (m_rect.x, m_rect.y, m_rect.width, m_tabCtrlHeight);
+            m_tabs->SetRect     (wxRect(0, 0,        m_rect.width, m_tabCtrlHeight));

         }
         // TODO: else if (GetFlags() & wxAUI_NB_LEFT){}
         // TODO: else if (GetFlags() & wxAUI_NB_RIGHT){}
         }
         // TODO: else if (GetFlags() & wxAUI_NB_LEFT){}
         // TODO: else if (GetFlags() & wxAUI_NB_RIGHT){}


@@ -2762,7 +2762,7 @@ public:
 
         for (i = 0; i < page_count; ++i)
         {
 
         for (i = 0; i < page_count; ++i)
         {

-            int height = m_rect.height - m_tab_ctrl_height;
+            int height = m_rect.height - m_tabCtrlHeight;

             if ( height < 0 )
             {
                 // avoid passing negative height to wxWindow::SetSize(), this
             if ( height < 0 )
             {
                 // avoid passing negative height to wxWindow::SetSize(), this


@@ -2777,7 +2777,7 @@ public:
             }
             else //TODO: if (GetFlags() & wxAUI_NB_TOP)
             {
             }
             else //TODO: if (GetFlags() & wxAUI_NB_TOP)
             {

-                page.window->SetSize(m_rect.x, m_rect.y + m_tab_ctrl_height,
+                page.window->SetSize(m_rect.x, m_rect.y + m_tabCtrlHeight,

                                      m_rect.width, height);
             }
             // TODO: else if (GetFlags() & wxAUI_NB_LEFT){}
                                      m_rect.width, height);
             }
             // TODO: else if (GetFlags() & wxAUI_NB_LEFT){}


@@ -2811,7 +2811,7 @@ public:
     wxRect m_rect;
     wxRect m_tab_rect;
     wxAuiTabCtrl* m_tabs;
     wxRect m_rect;
     wxRect m_tab_rect;
     wxAuiTabCtrl* m_tabs;

-    int m_tab_ctrl_height;
+    int m_tabCtrlHeight;

 };
 
 
 };
 
 


@@ -2864,12 +2864,12 @@ END_EVENT_TABLE()
 
 void wxAuiNotebook::Init()
 {
 
 void wxAuiNotebook::Init()
 {

-    m_curpage = -1;
-    m_tab_id_counter = wxAuiBaseTabCtrlId;
-    m_dummy_wnd = NULL;
-    m_tab_ctrl_height = 20;
-    m_requested_bmp_size = wxDefaultSize;
-    m_requested_tabctrl_height = -1;
+    m_curPage = -1;
+    m_tabIdCounter = wxAuiBaseTabCtrlId;
+    m_dummyWnd = NULL;
+    m_tabCtrlHeight = 20;
+    m_requestedBmpSize = wxDefaultSize;
+    m_requestedTabCtrlHeight = -1;

 }
 
 bool wxAuiNotebook::Create(wxWindow* parent,
 }
 
 bool wxAuiNotebook::Create(wxWindow* parent,


@@ -2891,27 +2891,27 @@ bool wxAuiNotebook::Create(wxWindow* parent,
 void wxAuiNotebook::InitNotebook(long style)
 {
     SetName(wxT("wxAuiNotebook"));
 void wxAuiNotebook::InitNotebook(long style)
 {
     SetName(wxT("wxAuiNotebook"));

-    m_curpage = -1;
-    m_tab_id_counter = wxAuiBaseTabCtrlId;
-    m_dummy_wnd = NULL;
+    m_curPage = -1;
+    m_tabIdCounter = wxAuiBaseTabCtrlId;
+    m_dummyWnd = NULL;

     m_flags = (unsigned int)style;
     m_flags = (unsigned int)style;

-    m_tab_ctrl_height = 20;
+    m_tabCtrlHeight = 20;

 
 

-    m_normal_font = *wxNORMAL_FONT;
-    m_selected_font = *wxNORMAL_FONT;
-    m_selected_font.SetWeight(wxBOLD);
+    m_normalFont = *wxNORMAL_FONT;
+    m_selectedFont = *wxNORMAL_FONT;
+    m_selectedFont.SetWeight(wxBOLD);

 
     SetArtProvider(new wxAuiDefaultTabArt);
 
 
     SetArtProvider(new wxAuiDefaultTabArt);
 

-    m_dummy_wnd = new wxWindow(this, wxID_ANY, wxPoint(0,0), wxSize(0,0));
-    m_dummy_wnd->SetSize(200, 200);
-    m_dummy_wnd->Show(false);
+    m_dummyWnd = new wxWindow(this, wxID_ANY, wxPoint(0,0), wxSize(0,0));
+    m_dummyWnd->SetSize(200, 200);
+    m_dummyWnd->Show(false);

 
     m_mgr.SetManagedWindow(this);
     m_mgr.SetFlags(wxAUI_MGR_DEFAULT);
     m_mgr.SetDockSizeConstraint(1.0, 1.0); // no dock size constraint
 
 
     m_mgr.SetManagedWindow(this);
     m_mgr.SetFlags(wxAUI_MGR_DEFAULT);
     m_mgr.SetDockSizeConstraint(1.0, 1.0); // no dock size constraint
 

-    m_mgr.AddPane(m_dummy_wnd,
+    m_mgr.AddPane(m_dummyWnd,

               wxAuiPaneInfo().Name(wxT("dummy")).Bottom().CaptionVisible(false).Show(false));
 
     m_mgr.Update();
               wxAuiPaneInfo().Name(wxT("dummy")).Bottom().CaptionVisible(false).Show(false));
 
     m_mgr.Update();


@@ -2960,10 +2960,10 @@ void wxAuiNotebook::SetArtProvider(wxAuiTabArt* art)
 
 void wxAuiNotebook::SetTabCtrlHeight(int height)
 {
 
 void wxAuiNotebook::SetTabCtrlHeight(int height)
 {

-    m_requested_tabctrl_height = height;
+    m_requestedTabCtrlHeight = height;

 
     // if window is already initialized, recalculate the tab height
 
     // if window is already initialized, recalculate the tab height

-    if (m_dummy_wnd)
+    if (m_dummyWnd)

     {
         UpdateTabCtrlHeight();
     }
     {
         UpdateTabCtrlHeight();
     }


@@ -2979,10 +2979,10 @@ void wxAuiNotebook::SetTabCtrlHeight(int height)
 
 void wxAuiNotebook::SetUniformBitmapSize(const wxSize& size)
 {
 
 void wxAuiNotebook::SetUniformBitmapSize(const wxSize& size)
 {

-    m_requested_bmp_size = size;
+    m_requestedBmpSize = size;

 
     // if window is already initialized, recalculate the tab height
 
     // if window is already initialized, recalculate the tab height

-    if (m_dummy_wnd)
+    if (m_dummyWnd)

     {
         UpdateTabCtrlHeight();
     }
     {
         UpdateTabCtrlHeight();
     }


@@ -2997,12 +2997,12 @@ bool wxAuiNotebook::UpdateTabCtrlHeight()
 
     // if the tab control height needs to change, update
     // all of our tab controls with the new height
 
     // if the tab control height needs to change, update
     // all of our tab controls with the new height

-    if (m_tab_ctrl_height == height)
+    if (m_tabCtrlHeight == height)

         return false;
 
     wxAuiTabArt* art = m_tabs.GetArtProvider();
 
         return false;
 
     wxAuiTabArt* art = m_tabs.GetArtProvider();
 

-    m_tab_ctrl_height = height;
+    m_tabCtrlHeight = height;

 
     wxAuiPaneInfoArray& all_panes = m_mgr.GetAllPanes();
     size_t i, pane_count = all_panes.GetCount();
 
     wxAuiPaneInfoArray& all_panes = m_mgr.GetAllPanes();
     size_t i, pane_count = all_panes.GetCount();


@@ -3013,7 +3013,7 @@ bool wxAuiNotebook::UpdateTabCtrlHeight()
             continue;
         wxTabFrame* tab_frame = (wxTabFrame*)pane.window;
         wxAuiTabCtrl* tabctrl = tab_frame->m_tabs;
             continue;
         wxTabFrame* tab_frame = (wxTabFrame*)pane.window;
         wxAuiTabCtrl* tabctrl = tab_frame->m_tabs;

-        tab_frame->SetTabCtrlHeight(m_tab_ctrl_height);
+        tab_frame->SetTabCtrlHeight(m_tabCtrlHeight);

         tabctrl->SetArtProvider(art->Clone());
         tab_frame->DoSizing();
     }
         tabctrl->SetArtProvider(art->Clone());
         tab_frame->DoSizing();
     }


@@ -3031,7 +3031,7 @@ void wxAuiNotebook::UpdateHintWindowSize()
     {
         info.MinSize(size);
         info.BestSize(size);
     {
         info.MinSize(size);
         info.BestSize(size);

-        m_dummy_wnd->SetSize(size);
+        m_dummyWnd->SetSize(size);

     }
 }
 
     }
 }
 


@@ -3076,15 +3076,15 @@ int wxAuiNotebook::CalculateTabCtrlHeight()
     // if a fixed tab ctrl height is specified,
     // just return that instead of calculating a
     // tab height
     // if a fixed tab ctrl height is specified,
     // just return that instead of calculating a
     // tab height

-    if (m_requested_tabctrl_height != -1)
-        return m_requested_tabctrl_height;
+    if (m_requestedTabCtrlHeight != -1)
+        return m_requestedTabCtrlHeight;

 
     // find out new best tab height
     wxAuiTabArt* art = m_tabs.GetArtProvider();
 
     return art->GetBestTabCtrlSize(this,
                                    m_tabs.GetPages(),
 
     // find out new best tab height
     wxAuiTabArt* art = m_tabs.GetArtProvider();
 
     return art->GetBestTabCtrlSize(this,
                                    m_tabs.GetPages(),

-                                   m_requested_bmp_size);
+                                   m_requestedBmpSize);

 }
 
 
 }
 
 


@@ -3160,7 +3160,7 @@ bool wxAuiNotebook::InsertPage(size_t page_idx,
     // (though no select events will be fired)
     if (!select && m_tabs.GetPageCount() == 1)
         select = true;
     // (though no select events will be fired)
     if (!select && m_tabs.GetPageCount() == 1)
         select = true;

-        //m_curpage = GetPageIndex(page);
+        //m_curPage = GetPageIndex(page);

 
     wxAuiTabCtrl* active_tabctrl = GetActiveTabCtrl();
     if (page_idx >= active_tabctrl->GetPageCount())
 
     wxAuiTabCtrl* active_tabctrl = GetActiveTabCtrl();
     if (page_idx >= active_tabctrl->GetPageCount())


@@ -3173,8 +3173,8 @@ bool wxAuiNotebook::InsertPage(size_t page_idx,
     active_tabctrl->DoShowHide();
 
     // adjust selected index
     active_tabctrl->DoShowHide();
 
     // adjust selected index

-    if(m_curpage >= (int) page_idx)
-        m_curpage++;
+    if(m_curPage >= (int) page_idx)
+        m_curPage++;

 
     if (select)
     {
 
     if (select)
     {


@@ -3227,8 +3227,8 @@ bool wxAuiNotebook::RemovePage(size_t page_idx)
 {
     // save active window pointer
     wxWindow* active_wnd = NULL;
 {
     // save active window pointer
     wxWindow* active_wnd = NULL;

-    if (m_curpage >= 0)
-        active_wnd = m_tabs.GetWindowFromIdx(m_curpage);
+    if (m_curPage >= 0)
+        active_wnd = m_tabs.GetWindowFromIdx(m_curPage);

 
     // save pointer of window being deleted
     wxWindow* wnd = m_tabs.GetWindowFromIdx(page_idx);
 
     // save pointer of window being deleted
     wxWindow* wnd = m_tabs.GetWindowFromIdx(page_idx);


@@ -3244,7 +3244,7 @@ bool wxAuiNotebook::RemovePage(size_t page_idx)
     if (!FindTab(wnd, &ctrl, &ctrl_idx))
         return false;
 
     if (!FindTab(wnd, &ctrl, &ctrl_idx))
         return false;
 

-    bool is_curpage = (m_curpage == (int)page_idx);
+    bool is_curpage = (m_curPage == (int)page_idx);

     bool is_active_in_split = ctrl->GetPage(ctrl_idx).active;
 
 
     bool is_active_in_split = ctrl->GetPage(ctrl_idx).active;
 
 


@@ -3303,7 +3303,7 @@ bool wxAuiNotebook::RemovePage(size_t page_idx)
 
     RemoveEmptyTabFrames();
 
 
     RemoveEmptyTabFrames();
 

-    m_curpage = wxNOT_FOUND;
+    m_curPage = wxNOT_FOUND;

 
     // set new active pane unless we're being destroyed anyhow
     if (new_active && !m_isBeingDeleted)
 
     // set new active pane unless we're being destroyed anyhow
     if (new_active && !m_isBeingDeleted)


@@ -3396,7 +3396,7 @@ wxBitmap wxAuiNotebook::GetPageBitmap(size_t page_idx) const
 // GetSelection() returns the index of the currently active page
 int wxAuiNotebook::GetSelection() const
 {
 // GetSelection() returns the index of the currently active page
 int wxAuiNotebook::GetSelection() const
 {

-    return m_curpage;
+    return m_curPage;

 }
 
 // SetSelection() sets the currently active page
 }
 
 // SetSelection() sets the currently active page


@@ -3463,13 +3463,13 @@ void wxAuiNotebook::DoSizing()
 // called to determine which control gets new windows being added
 wxAuiTabCtrl* wxAuiNotebook::GetActiveTabCtrl()
 {
 // called to determine which control gets new windows being added
 wxAuiTabCtrl* wxAuiNotebook::GetActiveTabCtrl()
 {

-    if (m_curpage >= 0 && m_curpage < (int)m_tabs.GetPageCount())
+    if (m_curPage >= 0 && m_curPage < (int)m_tabs.GetPageCount())

     {
         wxAuiTabCtrl* ctrl;
         int idx;
 
         // find the tab ctrl with the current page
     {
         wxAuiTabCtrl* ctrl;
         int idx;
 
         // find the tab ctrl with the current page

-        if (FindTab(m_tabs.GetPage(m_curpage).window,
+        if (FindTab(m_tabs.GetPage(m_curPage).window,

                     &ctrl, &idx))
         {
             return ctrl;
                     &ctrl, &idx))
         {
             return ctrl;


@@ -3490,9 +3490,9 @@ wxAuiTabCtrl* wxAuiNotebook::GetActiveTabCtrl()
 
     // If there is no tabframe at all, create one
     wxTabFrame* tabframe = new wxTabFrame;
 
     // If there is no tabframe at all, create one
     wxTabFrame* tabframe = new wxTabFrame;

-    tabframe->SetTabCtrlHeight(m_tab_ctrl_height);
+    tabframe->SetTabCtrlHeight(m_tabCtrlHeight);

     tabframe->m_tabs = new wxAuiTabCtrl(this,
     tabframe->m_tabs = new wxAuiTabCtrl(this,

-                                        m_tab_id_counter++,
+                                        m_tabIdCounter++,

                                         wxDefaultPosition,
                                         wxDefaultSize,
                                         wxNO_BORDER|wxWANTS_CHARS);
                                         wxDefaultPosition,
                                         wxDefaultSize,
                                         wxNO_BORDER|wxWANTS_CHARS);


@@ -3573,9 +3573,9 @@ void wxAuiNotebook::Split(size_t page, int direction)
     // create a new tab frame
     wxTabFrame* new_tabs = new wxTabFrame;
     new_tabs->m_rect = wxRect(wxPoint(0,0), split_size);
     // create a new tab frame
     wxTabFrame* new_tabs = new wxTabFrame;
     new_tabs->m_rect = wxRect(wxPoint(0,0), split_size);

-    new_tabs->SetTabCtrlHeight(m_tab_ctrl_height);
+    new_tabs->SetTabCtrlHeight(m_tabCtrlHeight);

     new_tabs->m_tabs = new wxAuiTabCtrl(this,
     new_tabs->m_tabs = new wxAuiTabCtrl(this,

-                                        m_tab_id_counter++,
+                                        m_tabIdCounter++,

                                         wxDefaultPosition,
                                         wxDefaultSize,
                                         wxNO_BORDER|wxWANTS_CHARS);
                                         wxDefaultPosition,
                                         wxDefaultSize,
                                         wxNO_BORDER|wxWANTS_CHARS);


@@ -3585,31 +3585,31 @@ void wxAuiNotebook::Split(size_t page, int direction)
 
     // create a pane info structure with the information
     // about where the pane should be added
 
     // create a pane info structure with the information
     // about where the pane should be added

-    wxAuiPaneInfo pane_info = wxAuiPaneInfo().Bottom().CaptionVisible(false);
+    wxAuiPaneInfo paneInfo = wxAuiPaneInfo().Bottom().CaptionVisible(false);

     wxPoint mouse_pt;
 
     if (direction == wxLEFT)
     {
     wxPoint mouse_pt;
 
     if (direction == wxLEFT)
     {

-        pane_info.Left();
+        paneInfo.Left();

         mouse_pt = wxPoint(0, cli_size.y/2);
     }
     else if (direction == wxRIGHT)
     {
         mouse_pt = wxPoint(0, cli_size.y/2);
     }
     else if (direction == wxRIGHT)
     {

-        pane_info.Right();
+        paneInfo.Right();

         mouse_pt = wxPoint(cli_size.x, cli_size.y/2);
     }
     else if (direction == wxTOP)
     {
         mouse_pt = wxPoint(cli_size.x, cli_size.y/2);
     }
     else if (direction == wxTOP)
     {

-        pane_info.Top();
+        paneInfo.Top();

         mouse_pt = wxPoint(cli_size.x/2, 0);
     }
     else if (direction == wxBOTTOM)
     {
         mouse_pt = wxPoint(cli_size.x/2, 0);
     }
     else if (direction == wxBOTTOM)
     {

-        pane_info.Bottom();
+        paneInfo.Bottom();

         mouse_pt = wxPoint(cli_size.x/2, cli_size.y);
     }
 
         mouse_pt = wxPoint(cli_size.x/2, cli_size.y);
     }
 

-    m_mgr.AddPane(new_tabs, pane_info, mouse_pt);
+    m_mgr.AddPane(new_tabs, paneInfo, mouse_pt);

     m_mgr.Update();
 
     // remove the page from the source tabs
     m_mgr.Update();
 
     // remove the page from the source tabs


@@ -3637,7 +3637,7 @@ void wxAuiNotebook::Split(size_t page, int direction)
     dest_tabs->Refresh();
 
     // force the set selection function reset the selection
     dest_tabs->Refresh();
 
     // force the set selection function reset the selection

-    m_curpage = -1;
+    m_curPage = -1;

 
     // set the active page to the one we just split off
     SetSelectionToPage(page_info);
 
     // set the active page to the one we just split off
     SetSelectionToPage(page_info);


@@ -3674,7 +3674,7 @@ void wxAuiNotebook::OnTabBgDClick(wxAuiNotebookEvent& WXUNUSED(evt))
 
 void wxAuiNotebook::OnTabBeginDrag(wxAuiNotebookEvent&)
 {
 
 void wxAuiNotebook::OnTabBeginDrag(wxAuiNotebookEvent&)
 {

-    m_last_drag_x = 0;
+    m_lastDragX = 0;

 }
 
 void wxAuiNotebook::OnTabDragMotion(wxAuiNotebookEvent& evt)
 }
 
 void wxAuiNotebook::OnTabDragMotion(wxAuiNotebookEvent& evt)


@@ -3713,10 +3713,10 @@ void wxAuiNotebook::OnTabDragMotion(wxAuiNotebookEvent& evt)
 
             // prevent jumpy drag
             if ((src_idx == dest_idx) || dest_idx == -1 ||
 
             // prevent jumpy drag
             if ((src_idx == dest_idx) || dest_idx == -1 ||

-                (src_idx > dest_idx && m_last_drag_x <= pt.x) ||
-                (src_idx < dest_idx && m_last_drag_x >= pt.x))
+                (src_idx > dest_idx && m_lastDragX <= pt.x) ||
+                (src_idx < dest_idx && m_lastDragX >= pt.x))

             {
             {

-                m_last_drag_x = pt.x;
+                m_lastDragX = pt.x;

                 return;
             }
 
                 return;
             }
 


@@ -3726,7 +3726,7 @@ void wxAuiNotebook::OnTabDragMotion(wxAuiNotebookEvent& evt)
             dest_tabs->SetActivePage((size_t)dest_idx);
             dest_tabs->DoShowHide();
             dest_tabs->Refresh();
             dest_tabs->SetActivePage((size_t)dest_idx);
             dest_tabs->DoShowHide();
             dest_tabs->Refresh();

-            m_last_drag_x = pt.x;
+            m_lastDragX = pt.x;

 
         }
 
 
         }
 


@@ -3802,7 +3802,7 @@ void wxAuiNotebook::OnTabDragMotion(wxAuiNotebookEvent& evt)
     }
     else
     {
     }
     else
     {

-        m_mgr.DrawHintRect(m_dummy_wnd, client_pt, zero);
+        m_mgr.DrawHintRect(m_dummyWnd, client_pt, zero);

     }
 }
 
     }
 }
 


@@ -3959,7 +3959,7 @@ void wxAuiNotebook::OnTabEndDrag(wxAuiNotebookEvent& evt)
         else
         {
             wxPoint zero(0,0);
         else
         {
             wxPoint zero(0,0);

-            wxRect rect = m_mgr.CalculateHintRect(m_dummy_wnd,
+            wxRect rect = m_mgr.CalculateHintRect(m_dummyWnd,

                                                   mouse_client_pt,
                                                   zero);
             if (rect.IsEmpty())
                                                   mouse_client_pt,
                                                   zero);
             if (rect.IsEmpty())


@@ -3971,9 +3971,9 @@ void wxAuiNotebook::OnTabEndDrag(wxAuiNotebookEvent& evt)
             // If there is no tabframe at all, create one
             wxTabFrame* new_tabs = new wxTabFrame;
             new_tabs->m_rect = wxRect(wxPoint(0,0), CalculateNewSplitSize());
             // If there is no tabframe at all, create one
             wxTabFrame* new_tabs = new wxTabFrame;
             new_tabs->m_rect = wxRect(wxPoint(0,0), CalculateNewSplitSize());

-            new_tabs->SetTabCtrlHeight(m_tab_ctrl_height);
+            new_tabs->SetTabCtrlHeight(m_tabCtrlHeight);

             new_tabs->m_tabs = new wxAuiTabCtrl(this,
             new_tabs->m_tabs = new wxAuiTabCtrl(this,

-                                                m_tab_id_counter++,
+                                                m_tabIdCounter++,

                                                 wxDefaultPosition,
                                                 wxDefaultSize,
                                                 wxNO_BORDER|wxWANTS_CHARS);
                                                 wxDefaultPosition,
                                                 wxDefaultSize,
                                                 wxNO_BORDER|wxWANTS_CHARS);


@@ -4017,7 +4017,7 @@ void wxAuiNotebook::OnTabEndDrag(wxAuiNotebookEvent& evt)
         dest_tabs->Refresh();
 
         // force the set selection function reset the selection
         dest_tabs->Refresh();
 
         // force the set selection function reset the selection

-        m_curpage = -1;
+        m_curPage = -1;

 
         // set the active page to the one we just split off
         SetSelectionToPage(page_info);
 
         // set the active page to the one we just split off
         SetSelectionToPage(page_info);


@@ -4166,7 +4166,7 @@ void wxAuiNotebook::OnChildFocusNotebook(wxChildFocusEvent& evt)
     // change the tab selection to the child
     // which was focused
     int idx = m_tabs.GetIdxFromWindow(evt.GetWindow());
     // change the tab selection to the child
     // which was focused
     int idx = m_tabs.GetIdxFromWindow(evt.GetWindow());

-    if (idx != -1 && idx != m_curpage)
+    if (idx != -1 && idx != m_curPage)

     {
         SetSelection(idx);
     }
     {
         SetSelection(idx);
     }


@@ -4370,14 +4370,14 @@ void wxAuiNotebook::OnTabRightUp(wxAuiNotebookEvent& evt)
 // Sets the normal font
 void wxAuiNotebook::SetNormalFont(const wxFont& font)
 {
 // Sets the normal font
 void wxAuiNotebook::SetNormalFont(const wxFont& font)
 {

-    m_normal_font = font;
+    m_normalFont = font;

     GetArtProvider()->SetNormalFont(font);
 }
 
 // Sets the selected tab font
 void wxAuiNotebook::SetSelectedFont(const wxFont& font)
 {
     GetArtProvider()->SetNormalFont(font);
 }
 
 // Sets the selected tab font
 void wxAuiNotebook::SetSelectedFont(const wxFont& font)
 {

-    m_selected_font = font;
+    m_selectedFont = font;

     GetArtProvider()->SetSelectedFont(font);
 }
 
     GetArtProvider()->SetSelectedFont(font);
 }
 


@@ -4406,7 +4406,7 @@ bool wxAuiNotebook::SetFont(const wxFont& font)
 // Gets the tab control height
 int wxAuiNotebook::GetTabCtrlHeight() const
 {
 // Gets the tab control height
 int wxAuiNotebook::GetTabCtrlHeight() const
 {

-    return m_tab_ctrl_height;
+    return m_tabCtrlHeight;

 }
 
 // Gets the height of the notebook for a given page height
 }
 
 // Gets the height of the notebook for a given page height


@@ -4547,13 +4547,13 @@ bool wxAuiNotebook::InsertPage(size_t index, wxWindow *page,
 
 int wxAuiNotebook::DoModifySelection(size_t n, bool events)
 {
 
 int wxAuiNotebook::DoModifySelection(size_t n, bool events)
 {

-   wxWindow* wnd = m_tabs.GetWindowFromIdx(n);
+    wxWindow* wnd = m_tabs.GetWindowFromIdx(n);

     if (!wnd)
     if (!wnd)

-        return m_curpage;
+        return m_curPage;

 
     // don't change the page unless necessary;
     // however, clicking again on a tab should give it the focus.
 
     // don't change the page unless necessary;
     // however, clicking again on a tab should give it the focus.

-    if ((int)n == m_curpage)
+    if ((int)n == m_curPage)

     {
         wxAuiTabCtrl* ctrl;
         int ctrl_idx;
     {
         wxAuiTabCtrl* ctrl;
         int ctrl_idx;


@@ -4562,7 +4562,7 @@ int wxAuiNotebook::DoModifySelection(size_t n, bool events)
             if (FindFocus() != ctrl)
                 ctrl->SetFocus();
         }
             if (FindFocus() != ctrl)
                 ctrl->SetFocus();
         }

-        return m_curpage;
+        return m_curPage;

     }
 
     bool vetoed = false;
     }
 
     bool vetoed = false;


@@ -4572,7 +4572,7 @@ int wxAuiNotebook::DoModifySelection(size_t n, bool events)
     if(events)
     {
         evt.SetSelection(n);
     if(events)
     {
         evt.SetSelection(n);

-        evt.SetOldSelection(m_curpage);
+        evt.SetOldSelection(m_curPage);

         evt.SetEventObject(this);
         GetEventHandler()->ProcessEvent(evt);
         vetoed = !evt.IsAllowed();
         evt.SetEventObject(this);
         GetEventHandler()->ProcessEvent(evt);
         vetoed = !evt.IsAllowed();


@@ -4580,8 +4580,8 @@ int wxAuiNotebook::DoModifySelection(size_t n, bool events)
 
     if (!vetoed)
     {
 
     if (!vetoed)
     {

-        int old_curpage = m_curpage;
-        m_curpage = n;
+        int old_curpage = m_curPage;
+        m_curPage = n;

 
         // program allows the page change
         if(events)
 
         // program allows the page change
         if(events)


@@ -4613,9 +4613,9 @@ int wxAuiNotebook::DoModifySelection(size_t n, bool events)
                     continue;
                 wxAuiTabCtrl* tabctrl = ((wxTabFrame*)pane.window)->m_tabs;
                 if (tabctrl != ctrl)
                     continue;
                 wxAuiTabCtrl* tabctrl = ((wxTabFrame*)pane.window)->m_tabs;
                 if (tabctrl != ctrl)

-                    tabctrl->SetSelectedFont(m_normal_font);
+                    tabctrl->SetSelectedFont(m_normalFont);

                 else
                 else

-                    tabctrl->SetSelectedFont(m_selected_font);
+                    tabctrl->SetSelectedFont(m_selectedFont);

                 tabctrl->Refresh();
             }
 
                 tabctrl->Refresh();
             }
 


@@ -4628,7 +4628,7 @@ int wxAuiNotebook::DoModifySelection(size_t n, bool events)
         }
     }
 
         }
     }
 

-    return m_curpage;
+    return m_curPage;

 }
 
 
 }