No real changes, just minor cleanup in wxGTK wxDVC.

[wxWidgets.git] / src / propgrid / propgrid.cpp

diff --git a/src/propgrid/propgrid.cpp b/src/propgrid/propgrid.cpp
index fa85a9ae7ee2ebdaa5ea84c9a917aaa3d8cd6770..a87ebc07cc9bcd6f709303dfa5940e45f91ab228 100644 (file)
--- a/src/propgrid/propgrid.cpp
+++ b/src/propgrid/propgrid.cpp
@@ -64,10 +64,6 @@
 #include "wx/timer.h"
 #include "wx/dcbuffer.h"
 
 #include "wx/timer.h"
 #include "wx/dcbuffer.h"
 

-#ifdef __WXMSW__
-    #include "wx/msw/private.h"
-#endif
-

 // Two pics for the expand / collapse buttons.
 // Files are not supplied with this project (since it is
 // recommended to use either custom or native rendering).
 // Two pics for the expand / collapse buttons.
 // Files are not supplied with this project (since it is
 // recommended to use either custom or native rendering).


@@ -237,113 +233,6 @@ void wxPropertyGridInitGlobalsIfNeeded()
 {
 }
 
 {
 }
 

-// -----------------------------------------------------------------------
-// wxPGCanvas
-// -----------------------------------------------------------------------
-
-//
-// wxPGCanvas acts as a graphics sub-window of the
-// wxScrolledWindow that wxPropertyGrid is.
-//
-class wxPGCanvas : public wxPanel
-{
-public:
-    wxPGCanvas() : wxPanel()
-    {
-    }
-    virtual ~wxPGCanvas() { }
-
-protected:
-    void OnMouseMove( wxMouseEvent &event )
-    {
-        wxPropertyGrid* pg = wxStaticCast(GetParent(), wxPropertyGrid);
-        pg->OnMouseMove( event );
-    }
-
-    void OnMouseClick( wxMouseEvent &event )
-    {
-        wxPropertyGrid* pg = wxStaticCast(GetParent(), wxPropertyGrid);
-        pg->OnMouseClick( event );
-    }
-
-    void OnMouseUp( wxMouseEvent &event )
-    {
-        wxPropertyGrid* pg = wxStaticCast(GetParent(), wxPropertyGrid);
-        pg->OnMouseUp( event );
-    }
-
-    void OnMouseRightClick( wxMouseEvent &event )
-    {
-        wxPropertyGrid* pg = wxStaticCast(GetParent(), wxPropertyGrid);
-        pg->OnMouseRightClick( event );
-    }
-
-    void OnMouseDoubleClick( wxMouseEvent &event )
-    {
-        wxPropertyGrid* pg = wxStaticCast(GetParent(), wxPropertyGrid);
-        pg->OnMouseDoubleClick( event );
-    }
-
-    void OnKey( wxKeyEvent& event )
-    {
-        wxPropertyGrid* pg = wxStaticCast(GetParent(), wxPropertyGrid);
-        pg->OnKey( event );
-    }
-
-    void OnPaint( wxPaintEvent& event );
-
-    // Always be focussable, even with child windows
-    virtual void SetCanFocus(bool WXUNUSED(canFocus))
-    {  wxPanel::SetCanFocus(true); }
-
-
-private:
-    DECLARE_EVENT_TABLE()
-    DECLARE_ABSTRACT_CLASS(wxPGCanvas)
-};
-
-
-IMPLEMENT_ABSTRACT_CLASS(wxPGCanvas,wxPanel)
-
-BEGIN_EVENT_TABLE(wxPGCanvas, wxPanel)
-    EVT_MOTION(wxPGCanvas::OnMouseMove)
-    EVT_PAINT(wxPGCanvas::OnPaint)
-    EVT_LEFT_DOWN(wxPGCanvas::OnMouseClick)
-    EVT_LEFT_UP(wxPGCanvas::OnMouseUp)
-    EVT_RIGHT_UP(wxPGCanvas::OnMouseRightClick)
-    EVT_LEFT_DCLICK(wxPGCanvas::OnMouseDoubleClick)
-    EVT_KEY_DOWN(wxPGCanvas::OnKey)
-END_EVENT_TABLE()
-
-
-void wxPGCanvas::OnPaint( wxPaintEvent& WXUNUSED(event) )
-{
-    wxPropertyGrid* pg = wxStaticCast(GetParent(), wxPropertyGrid);
-    wxASSERT( pg->IsKindOf(CLASSINFO(wxPropertyGrid)) );
-
-    wxPaintDC dc(this);
-
-    // Don't paint after destruction has begun
-    if ( !(pg->GetInternalFlags() & wxPG_FL_INITIALIZED) )
-        return;
-
-    // Update everything inside the box
-    wxRect r = GetUpdateRegion().GetBox();
-
-    // FIXME: This is just a workaround for a bug that causes splitters not
-    //        to paint when other windows are being dragged over the grid.
-    wxRect fullRect = GetRect();
-    r.x = fullRect.x;
-    r.width = fullRect.width;
-
-    // Repaint this rectangle
-    pg->DrawItems( dc, r.y, r.y + r.height, &r );
-
-    // We assume that the size set when grid is shown
-    // is what is desired.
-    pg->SetInternalFlag(wxPG_FL_GOOD_SIZE_SET);
-}
-

 // -----------------------------------------------------------------------
 // wxPropertyGrid
 // -----------------------------------------------------------------------
 // -----------------------------------------------------------------------
 // wxPropertyGrid
 // -----------------------------------------------------------------------


@@ -352,7 +241,6 @@ IMPLEMENT_DYNAMIC_CLASS(wxPropertyGrid, wxScrolledWindow)
 
 BEGIN_EVENT_TABLE(wxPropertyGrid, wxScrolledWindow)
   EVT_IDLE(wxPropertyGrid::OnIdle)
 
 BEGIN_EVENT_TABLE(wxPropertyGrid, wxScrolledWindow)
   EVT_IDLE(wxPropertyGrid::OnIdle)

-  EVT_MOTION(wxPropertyGrid::OnMouseMoveBottom)

   EVT_PAINT(wxPropertyGrid::OnPaint)
   EVT_SIZE(wxPropertyGrid::OnResize)
   EVT_ENTER_WINDOW(wxPropertyGrid::OnMouseEntry)
   EVT_PAINT(wxPropertyGrid::OnPaint)
   EVT_SIZE(wxPropertyGrid::OnResize)
   EVT_ENTER_WINDOW(wxPropertyGrid::OnMouseEntry)


@@ -363,9 +251,14 @@ BEGIN_EVENT_TABLE(wxPropertyGrid, wxScrolledWindow)
   EVT_SET_FOCUS(wxPropertyGrid::OnFocusEvent)
   EVT_KILL_FOCUS(wxPropertyGrid::OnFocusEvent)
   EVT_SYS_COLOUR_CHANGED(wxPropertyGrid::OnSysColourChanged)
   EVT_SET_FOCUS(wxPropertyGrid::OnFocusEvent)
   EVT_KILL_FOCUS(wxPropertyGrid::OnFocusEvent)
   EVT_SYS_COLOUR_CHANGED(wxPropertyGrid::OnSysColourChanged)

+  EVT_MOTION(wxPropertyGrid::OnMouseMove)
+  EVT_LEFT_DOWN(wxPropertyGrid::OnMouseClick)
+  EVT_LEFT_UP(wxPropertyGrid::OnMouseUp)
+  EVT_RIGHT_UP(wxPropertyGrid::OnMouseRightClick)
+  EVT_LEFT_DCLICK(wxPropertyGrid::OnMouseDoubleClick)
+  EVT_KEY_DOWN(wxPropertyGrid::OnKey)

 END_EVENT_TABLE()
 
 END_EVENT_TABLE()
 

-

 // -----------------------------------------------------------------------
 
 wxPropertyGrid::wxPropertyGrid()
 // -----------------------------------------------------------------------
 
 wxPropertyGrid::wxPropertyGrid()


@@ -398,8 +291,10 @@ bool wxPropertyGrid::Create( wxWindow *parent,
                              const wxString& name )
 {
 
                              const wxString& name )
 {
 

-    if ( !(style&wxBORDER_MASK) )
-        style |= wxSIMPLE_BORDER;
+    if (!(style&wxBORDER_MASK))
+    {
+        style |= wxBORDER_THEME;
+    }

 
     style |= wxVSCROLL;
 
 
     style |= wxVSCROLL;
 


@@ -435,6 +330,7 @@ void wxPropertyGrid::Init1()
     m_labelEditorProperty = NULL;
     m_eventObject = this;
     m_curFocused = NULL;
     m_labelEditorProperty = NULL;
     m_eventObject = this;
     m_curFocused = NULL;

+    m_processedEvent = NULL;

     m_sortFunction = NULL;
     m_inDoPropertyChanged = 0;
     m_inCommitChangesFromEditor = 0;
     m_sortFunction = NULL;
     m_inDoPropertyChanged = 0;
     m_inCommitChangesFromEditor = 0;


@@ -458,8 +354,6 @@ void wxPropertyGrid::Init1()
     m_coloursCustomized = 0;
     m_frozen = 0;
 
     m_coloursCustomized = 0;
     m_frozen = 0;
 

-    m_canvas = NULL;
-

 #if wxPG_DOUBLE_BUFFER
     m_doubleBuffer = NULL;
 #endif
 #if wxPG_DOUBLE_BUFFER
     m_doubleBuffer = NULL;
 #endif


@@ -512,7 +406,7 @@ void wxPropertyGrid::Init2()
     }
 
     if ( !(m_windowStyle & wxPG_SPLITTER_AUTO_CENTER) )
     }
 
     if ( !(m_windowStyle & wxPG_SPLITTER_AUTO_CENTER) )

-        m_iFlags |= wxPG_FL_DONT_CENTER_SPLITTER;
+        m_pState->m_dontCenterSplitter = true;

 
     if ( m_windowStyle & wxPG_HIDE_CATEGORIES )
     {
 
     if ( m_windowStyle & wxPG_HIDE_CATEGORIES )
     {


@@ -555,7 +449,6 @@ void wxPropertyGrid::Init2()
     m_tlp = NULL;
     m_tlpClosed = NULL;
     m_tlpClosedTime = 0;
     m_tlp = NULL;
     m_tlpClosed = NULL;
     m_tlpClosedTime = 0;

-    OnTLPChanging(::wxGetTopLevelParent(this));

 
     // set virtual size to this window size
     wxSize wndsize = GetSize();
 
     // set virtual size to this window size
     wxSize wndsize = GetSize();


@@ -563,10 +456,9 @@ void wxPropertyGrid::Init2()
 
     m_timeCreated = ::wxGetLocalTimeMillis();
 
 
     m_timeCreated = ::wxGetLocalTimeMillis();
 

-    m_canvas = new wxPGCanvas();
-    m_canvas->Create(this, 1, wxPoint(0, 0), GetClientSize(),
-                     wxWANTS_CHARS | wxCLIP_CHILDREN);
-    m_canvas->SetBackgroundStyle( wxBG_STYLE_CUSTOM );
+    //m_canvas->Create(this, wxID_ANY, wxPoint(0, 0), GetClientSize(),
+    //                 wxWANTS_CHARS | wxCLIP_CHILDREN);
+    SetBackgroundStyle( wxBG_STYLE_CUSTOM );

 
     m_iFlags |= wxPG_FL_INITIALIZED;
 
 
     m_iFlags |= wxPG_FL_INITIALIZED;
 


@@ -584,21 +476,56 @@ wxPropertyGrid::~wxPropertyGrid()
 {
     size_t i;
 
 {
     size_t i;
 

+#if wxUSE_THREADS
+    wxCriticalSectionLocker(wxPGGlobalVars->m_critSect);
+#endif
+
+    //
+    // Remove grid and property pointers from live wxPropertyGridEvents.
+    for ( i=0; i<m_liveEvents.size(); i++ )
+    {
+        wxPropertyGridEvent* evt = m_liveEvents[i];
+        evt->SetPropertyGrid(NULL);
+        evt->SetProperty(NULL);
+    }
+    m_liveEvents.clear();
+
+    if ( m_processedEvent )
+    {
+        // All right... we are being deleted while wxPropertyGrid event
+        // is being sent. Make sure that event propagates as little
+        // as possible (although usually this is not enough to prevent
+        // a crash).
+        m_processedEvent->Skip(false);
+        m_processedEvent->StopPropagation();
+
+        // Let's use wxMessageBox to make the message appear more
+        // reliably (and *before* the crash can happen).
+        ::wxMessageBox("wxPropertyGrid was being destroyed in an event "
+                       "generated by it. This usually leads to a crash "
+                       "so it is recommended to destroy the control "
+                       "at idle time instead.");
+    }
+

     DoSelectProperty(NULL, wxPG_SEL_NOVALIDATE|wxPG_SEL_DONT_SEND_EVENT);
 
     // This should do prevent things from going too badly wrong
     m_iFlags &= ~(wxPG_FL_INITIALIZED);
 
     if ( m_iFlags & wxPG_FL_MOUSE_CAPTURED )
     DoSelectProperty(NULL, wxPG_SEL_NOVALIDATE|wxPG_SEL_DONT_SEND_EVENT);
 
     // This should do prevent things from going too badly wrong
     m_iFlags &= ~(wxPG_FL_INITIALIZED);
 
     if ( m_iFlags & wxPG_FL_MOUSE_CAPTURED )

-        m_canvas->ReleaseMouse();
+        ReleaseMouse();

 
     // Call with NULL to disconnect event handling
 
     // Call with NULL to disconnect event handling

-    OnTLPChanging(NULL);
+    if ( GetExtraStyle() & wxPG_EX_ENABLE_TLP_TRACKING )
+    {
+        OnTLPChanging(NULL);

 
 

-    wxASSERT_MSG( !IsEditorsValueModified(),
-                  wxS("Most recent change in property editor was lost!!! ")
-                  wxS("(if you don't want this to happen, close your frames ")
-                  wxS("and dialogs using Close(false).)") );
+        wxASSERT_MSG( !IsEditorsValueModified(),
+                      wxS("Most recent change in property editor was ")
+                      wxS("lost!!! (if you don't want this to happen, ")
+                      wxS("close your frames and dialogs using ")
+                      wxS("Close(false).)") );
+    }

 
 #if wxPG_DOUBLE_BUFFER
     if ( m_doubleBuffer )
 
 #if wxPG_DOUBLE_BUFFER
     if ( m_doubleBuffer )


@@ -618,7 +545,9 @@ wxPropertyGrid::~wxPropertyGrid()
     // Delete common value records
     for ( i=0; i<m_commonValues.size(); i++ )
     {
     // Delete common value records
     for ( i=0; i<m_commonValues.size(); i++ )
     {

-        delete GetCommonValue(i);
+        // Use temporary variable to work around possible strange VC6 (asserts because m_size is zero)
+        wxPGCommonValue* value = m_commonValues[i];
+        delete value;

     }
 }
 
     }
 }
 


@@ -627,7 +556,7 @@ wxPropertyGrid::~wxPropertyGrid()
 bool wxPropertyGrid::Destroy()
 {
     if ( m_iFlags & wxPG_FL_MOUSE_CAPTURED )
 bool wxPropertyGrid::Destroy()
 {
     if ( m_iFlags & wxPG_FL_MOUSE_CAPTURED )

-        m_canvas->ReleaseMouse();
+        ReleaseMouse();

 
     return wxScrolledWindow::Destroy();
 }
 
     return wxScrolledWindow::Destroy();
 }


@@ -688,7 +617,7 @@ void wxPropertyGrid::SetWindowStyleFlag( long style )
             //
             // Tooltips disabled
             //
             //
             // Tooltips disabled
             //

-            m_canvas->SetToolTip( NULL );
+            wxScrolledWindow::SetToolTip( NULL );

         }
     #endif
     }
         }
     #endif
     }


@@ -727,7 +656,7 @@ void wxPropertyGrid::Thaw()
         wxScrolledWindow::Thaw();
         RecalculateVirtualSize();
     #if wxPG_REFRESH_CONTROLS_AFTER_REPAINT
         wxScrolledWindow::Thaw();
         RecalculateVirtualSize();
     #if wxPG_REFRESH_CONTROLS_AFTER_REPAINT

-        m_canvas->Refresh();
+        Refresh();

     #endif
 
         // Force property re-selection
     #endif
 
         // Force property re-selection


@@ -922,6 +851,29 @@ void wxPropertyGrid::DoSetSelection( const wxArrayPGProperty& newSelection,
 
 // -----------------------------------------------------------------------
 
 
 // -----------------------------------------------------------------------
 

+void wxPropertyGrid::MakeColumnEditable( unsigned int column,
+                                         bool editable )
+{
+    wxASSERT( column != 1 );
+
+    wxArrayInt& cols = m_pState->m_editableColumns;
+
+    if ( editable )
+    {
+        cols.push_back(column);
+    }
+    else
+    {
+        for ( int i = cols.size() - 1; i > 0; i-- )
+        {
+            if ( cols[i] == (int)column )
+                cols.erase( cols.begin() + i );
+        }
+    }
+}
+
+// -----------------------------------------------------------------------
+

 void wxPropertyGrid::DoBeginLabelEdit( unsigned int colIndex,
                                        int selFlags )
 {
 void wxPropertyGrid::DoBeginLabelEdit( unsigned int colIndex,
                                        int selFlags )
 {


@@ -1061,6 +1013,11 @@ void wxPropertyGrid::DoEndLabelEdit( bool commit, int selFlags )
 
 void wxPropertyGrid::SetExtraStyle( long exStyle )
 {
 
 void wxPropertyGrid::SetExtraStyle( long exStyle )
 {

+    if ( exStyle & wxPG_EX_ENABLE_TLP_TRACKING )
+        OnTLPChanging(::wxGetTopLevelParent(this));
+    else
+        OnTLPChanging(NULL);
+

     if ( exStyle & wxPG_EX_NATIVE_DOUBLE_BUFFERING )
     {
 #if defined(__WXMSW__)
     if ( exStyle & wxPG_EX_NATIVE_DOUBLE_BUFFERING )
     {
 #if defined(__WXMSW__)


@@ -1122,7 +1079,15 @@ wxSize wxPropertyGrid::DoGetBestSize() const
                     10
                    );
 
                     10
                    );
 

-    const wxSize sz = wxSize(60, lineHeight*numLines + 40);
+    wxClientDC dc(const_cast<wxPropertyGrid *>(this));
+    int width = m_marginWidth;
+    for ( unsigned int i = 0; i < m_pState->m_colWidths.size(); i++ )
+    {
+        width += m_pState->GetColumnFitWidth(dc, m_pState->DoGetRoot(), i, true);
+    }
+
+    const wxSize sz = wxSize(width, lineHeight*numLines + 40);
+

     CacheBestSize(sz);
     return sz;
 }
     CacheBestSize(sz);
     return sz;
 }


@@ -1131,6 +1096,9 @@ wxSize wxPropertyGrid::DoGetBestSize() const
 
 void wxPropertyGrid::OnTLPChanging( wxWindow* newTLP )
 {
 
 void wxPropertyGrid::OnTLPChanging( wxWindow* newTLP )
 {

+    if ( newTLP == m_tlp )
+        return;
+

     wxLongLong currentTime = ::wxGetLocalTimeMillis();
 
     //
     wxLongLong currentTime = ::wxGetLocalTimeMillis();
 
     //


@@ -1395,7 +1363,7 @@ bool wxPropertyGrid::SetFont( const wxFont& font )
     DoClearSelection();
 
     bool res = wxScrolledWindow::SetFont( font );
     DoClearSelection();
 
     bool res = wxScrolledWindow::SetFont( font );

-    if ( res && GetParent()) // may not have been Create()ed yet
+    if ( res && GetParent()) // may not have been Create()ed yet if SetFont called from SetWindowVariant

     {
         CalculateFontAndBitmapStuff( m_vspacing );
         Refresh();
     {
         CalculateFontAndBitmapStuff( m_vspacing );
         Refresh();


@@ -1754,13 +1722,34 @@ wxPGProperty* wxPropertyGrid::DoGetItemAtY( int y ) const
 void wxPropertyGrid::OnPaint( wxPaintEvent& WXUNUSED(event) )
 {
     wxPaintDC dc(this);
 void wxPropertyGrid::OnPaint( wxPaintEvent& WXUNUSED(event) )
 {
     wxPaintDC dc(this);

+    PrepareDC(dc);
+
+    // Don't paint after destruction has begun
+    if ( !HasInternalFlag(wxPG_FL_INITIALIZED) )
+        return;
+
+    // Find out where the window is scrolled to
+    int vx,vy;                     // Top left corner of client
+    GetViewStart(&vx,&vy);
+    vy *= wxPG_PIXELS_PER_UNIT;

 
     // Update everything inside the box
     wxRect r = GetUpdateRegion().GetBox();
 
 
     // Update everything inside the box
     wxRect r = GetUpdateRegion().GetBox();
 

-    dc.SetPen(m_colEmptySpace);
-    dc.SetBrush(m_colEmptySpace);
-    dc.DrawRectangle(r);
+    r.y += vy;
+
+    // FIXME: This is just a workaround for a bug that causes splitters not
+    //        to paint when other windows are being dragged over the grid.
+    wxRect fullRect = GetRect();
+    r.x = fullRect.x;
+    r.width = fullRect.width;
+
+    // Repaint this rectangle
+    DrawItems( dc, r.y, r.y + r.height, &r );
+
+    // We assume that the size set when grid is shown
+    // is what is desired.
+    SetInternalFlag(wxPG_FL_GOOD_SIZE_SET);

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


@@ -1842,19 +1831,25 @@ void wxPropertyGrid::DrawExpanderButton( wxDC& dc, const wxRect& rect,
 // topy and bottomy are already unscrolled (ie. physical)
 //
 void wxPropertyGrid::DrawItems( wxDC& dc,
 // topy and bottomy are already unscrolled (ie. physical)
 //
 void wxPropertyGrid::DrawItems( wxDC& dc,

-                                unsigned int topy,
-                                unsigned int bottomy,
-                                const wxRect* clipRect )
-{
-    if ( m_frozen || m_height < 1 || bottomy < topy || !m_pState ) return;
+                                unsigned int topItemY,
+                                unsigned int bottomItemY,
+                                const wxRect* drawRect )
+{
+    if ( m_frozen ||
+         m_height < 1 ||
+         bottomItemY < topItemY ||
+         !m_pState )
+        return;

 
     m_pState->EnsureVirtualHeight();
 
 
     m_pState->EnsureVirtualHeight();
 

-    wxRect tempClipRect;
-    if ( !clipRect )
+    wxRect tempDrawRect;
+    if ( !drawRect )

     {
     {

-        tempClipRect = wxRect(0,topy,m_pState->m_width,bottomy);
-        clipRect = &tempClipRect;
+        tempDrawRect = wxRect(0, topItemY,
+                              m_pState->m_width,
+                              bottomItemY);
+        drawRect = &tempDrawRect;

     }
 
     // items added check
     }
 
     // items added check


@@ -1874,7 +1869,7 @@ void wxPropertyGrid::DrawItems( wxDC& dc,
         {
             if ( !m_doubleBuffer )
             {
         {
             if ( !m_doubleBuffer )
             {

-                paintFinishY = clipRect->y;
+                paintFinishY = drawRect->y;

                 dcPtr = NULL;
             }
             else
                 dcPtr = NULL;
             }
             else


@@ -1892,49 +1887,62 @@ void wxPropertyGrid::DrawItems( wxDC& dc,
 
         if ( dcPtr )
         {
 
         if ( dcPtr )
         {

-            dc.SetClippingRegion( *clipRect );
-            paintFinishY = DoDrawItems( *dcPtr, clipRect, isBuffered );
+            dc.SetClippingRegion( *drawRect );
+            paintFinishY = DoDrawItems( *dcPtr, drawRect, isBuffered );
+            int drawBottomY = drawRect->y + drawRect->height;
+
+            // Clear area beyond last painted property
+            if ( paintFinishY < drawBottomY )
+            {
+                dcPtr->SetPen(m_colEmptySpace);
+                dcPtr->SetBrush(m_colEmptySpace);
+                dcPtr->DrawRectangle(0, paintFinishY,
+                                     m_width,
+                                     drawBottomY );
+            }
+
+            dc.DestroyClippingRegion();

         }
 
     #if wxPG_DOUBLE_BUFFER
         if ( bufferDC )
         {
         }
 
     #if wxPG_DOUBLE_BUFFER
         if ( bufferDC )
         {

-            dc.Blit( clipRect->x, clipRect->y, clipRect->width, clipRect->height,
-                bufferDC, 0, 0, wxCOPY );
-            dc.DestroyClippingRegion(); // Is this really necessary?
+            dc.Blit( drawRect->x, drawRect->y, drawRect->width,
+                     drawRect->height,
+                     bufferDC, 0, 0, wxCOPY );

             delete bufferDC;
         }
     #endif
     }
             delete bufferDC;
         }
     #endif
     }

-
-    // Clear area beyond bottomY?
-    if ( paintFinishY < (clipRect->y+clipRect->height) )
+    else

     {
     {

+        // Just clear the area

         dc.SetPen(m_colEmptySpace);
         dc.SetBrush(m_colEmptySpace);
         dc.SetPen(m_colEmptySpace);
         dc.SetBrush(m_colEmptySpace);

-        dc.DrawRectangle( 0, paintFinishY, m_width, (clipRect->y+clipRect->height) );
+        dc.DrawRectangle(*drawRect);

     }
 }
 
 // -----------------------------------------------------------------------
 
 int wxPropertyGrid::DoDrawItems( wxDC& dc,
     }
 }
 
 // -----------------------------------------------------------------------
 
 int wxPropertyGrid::DoDrawItems( wxDC& dc,

-                                 const wxRect* clipRect,
+                                 const wxRect* drawRect,

                                  bool isBuffered ) const
 {
     const wxPGProperty* firstItem;
     const wxPGProperty* lastItem;
 
                                  bool isBuffered ) const
 {
     const wxPGProperty* firstItem;
     const wxPGProperty* lastItem;
 

-    firstItem = DoGetItemAtY(clipRect->y);
-    lastItem = DoGetItemAtY(clipRect->y+clipRect->height-1);
+    firstItem = DoGetItemAtY(drawRect->y);
+    lastItem = DoGetItemAtY(drawRect->y+drawRect->height-1);

 
     if ( !lastItem )
         lastItem = GetLastItem( wxPG_ITERATE_VISIBLE );
 
     if ( m_frozen || m_height < 1 || firstItem == NULL )
 
     if ( !lastItem )
         lastItem = GetLastItem( wxPG_ITERATE_VISIBLE );
 
     if ( m_frozen || m_height < 1 || firstItem == NULL )

-        return clipRect->y;
+        return drawRect->y;

 
 

-    wxCHECK_MSG( !m_pState->m_itemsAdded, clipRect->y, wxT("no items added") );
+    wxCHECK_MSG( !m_pState->m_itemsAdded, drawRect->y,
+                 "no items added" );

     wxASSERT( m_pState->m_properties->GetChildCount() );
 
     int lh = m_lineHeight;
     wxASSERT( m_pState->m_properties->GetChildCount() );
 
     int lh = m_lineHeight;


@@ -1942,8 +1950,8 @@ int wxPropertyGrid::DoDrawItems( wxDC& dc,
     int firstItemTopY;
     int lastItemBottomY;
 
     int firstItemTopY;
     int lastItemBottomY;
 

-    firstItemTopY = clipRect->y;
-    lastItemBottomY = clipRect->y + clipRect->height;
+    firstItemTopY = drawRect->y;
+    lastItemBottomY = drawRect->y + drawRect->height;

 
     // Align y coordinates to item boundaries
     firstItemTopY -= firstItemTopY % lh;
 
     // Align y coordinates to item boundaries
     firstItemTopY -= firstItemTopY % lh;


@@ -1951,19 +1959,22 @@ int wxPropertyGrid::DoDrawItems( wxDC& dc,
     lastItemBottomY -= 1;
 
     // Entire range outside scrolled, visible area?
     lastItemBottomY -= 1;
 
     // Entire range outside scrolled, visible area?

-    if ( firstItemTopY >= (int)m_pState->GetVirtualHeight() || lastItemBottomY <= 0 )
-        return clipRect->y;
-
-    wxCHECK_MSG( firstItemTopY < lastItemBottomY, clipRect->y, wxT("invalid y values") );
+    if ( firstItemTopY >= (int)m_pState->GetVirtualHeight() ||
+         lastItemBottomY <= 0 )
+        return drawRect->y;

 
 

+    wxCHECK_MSG( firstItemTopY < lastItemBottomY,
+                 drawRect->y,
+                 "invalid y values" );

 
     /*
 
     /*

-    wxLogDebug(wxT("  -> DoDrawItems ( \"%s\" -> \"%s\", height=%i (ch=%i), clipRect = 0x%lX )"),
+    wxLogDebug("  -> DoDrawItems ( \"%s\" -> \"%s\"
+               "height=%i (ch=%i), drawRect = 0x%lX )",

         firstItem->GetLabel().c_str(),
         lastItem->GetLabel().c_str(),
         (int)(lastItemBottomY - firstItemTopY),
         (int)m_height,
         firstItem->GetLabel().c_str(),
         lastItem->GetLabel().c_str(),
         (int)(lastItemBottomY - firstItemTopY),
         (int)m_height,

-        (unsigned long)clipRect );
+        (unsigned long)drawRect );

     */
 
     wxRect r;
     */
 
     wxRect r;


@@ -1975,7 +1986,7 @@ int wxPropertyGrid::DoDrawItems( wxDC& dc,
 
     //
     // With wxPG_DOUBLE_BUFFER, do double buffering
 
     //
     // With wxPG_DOUBLE_BUFFER, do double buffering

-    // - buffer's y = 0, so align cliprect and coordinates to that
+    // - buffer's y = 0, so align drawRect and coordinates to that

     //
 #if wxPG_DOUBLE_BUFFER
 
     //
 #if wxPG_DOUBLE_BUFFER
 


@@ -1983,15 +1994,15 @@ int wxPropertyGrid::DoDrawItems( wxDC& dc,
 
     if ( isBuffered )
     {
 
     if ( isBuffered )
     {

-        xRelMod = clipRect->x;
-        yRelMod = clipRect->y;
+        xRelMod = drawRect->x;
+        yRelMod = drawRect->y;

 
         //
 
         //

-        // clipRect conversion
-        cr2 = *clipRect;
+        // drawRect conversion
+        cr2 = *drawRect;

         cr2.x -= xRelMod;
         cr2.y -= yRelMod;
         cr2.x -= xRelMod;
         cr2.y -= yRelMod;

-        clipRect = &cr2;
+        drawRect = &cr2;

         firstItemTopY -= yRelMod;
         lastItemBottomY -= yRelMod;
     }
         firstItemTopY -= yRelMod;
         lastItemBottomY -= yRelMod;
     }


@@ -2109,8 +2120,28 @@ int wxPropertyGrid::DoDrawItems( wxDC& dc,
 
         int y2 = y + lh;
 
 
         int y2 = y + lh;
 

+#ifdef __WXMSW__

         // Margin Edge
         // Margin Edge

-        dc.DrawLine( greyDepthX, y, greyDepthX, y2 );
+        // Modified by JACS to not draw a margin if wxPG_HIDE_MARGIN is specified, since it
+        // looks better, at least under Windows when we have a themed border (the themed-window-specific
+        // whitespace between the real border and the propgrid margin exacerbates the double-border look).
+
+        // Is this or its parent themed?
+        bool suppressMarginEdge = (GetWindowStyle() & wxPG_HIDE_MARGIN) &&
+            (((GetWindowStyle() & wxBORDER_MASK) == wxBORDER_THEME) ||
+            (((GetWindowStyle() & wxBORDER_MASK) == wxBORDER_NONE) && ((GetParent()->GetWindowStyle() & wxBORDER_MASK) == wxBORDER_THEME)));
+#else
+        bool suppressMarginEdge = false;
+#endif
+        if (!suppressMarginEdge)
+            dc.DrawLine( greyDepthX, y, greyDepthX, y2 );
+        else
+        {
+            // Blank out the margin edge
+            dc.SetPen(wxPen(GetBackgroundColour()));
+            dc.DrawLine( greyDepthX, y, greyDepthX, y2 );
+            dc.SetPen( linepen );
+        }

 
         // Splitters
         unsigned int si;
 
         // Splitters
         unsigned int si;


@@ -2365,7 +2396,7 @@ int wxPropertyGrid::DoDrawItems( wxDC& dc,
     }
 #endif
 
     }
 #endif
 

-    return y + yRelMod;
+    return y;

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


@@ -2425,7 +2456,7 @@ void wxPropertyGrid::DrawItems( const wxPGProperty* p1, const wxPGProperty* p2 )
     wxRect r = GetPropertyRect(p1, p2);
     if ( r.width > 0 )
     {
     wxRect r = GetPropertyRect(p1, p2);
     if ( r.width > 0 )
     {

-        m_canvas->RefreshRect(r);
+        RefreshRect(r);

     }
 }
 
     }
 }
 


@@ -2493,10 +2524,7 @@ void wxPropertyGrid::Refresh( bool WXUNUSED(eraseBackground),
 {
     PrepareAfterItemsAdded();
 
 {
     PrepareAfterItemsAdded();
 

-    wxWindow::Refresh(false);
-    if ( m_canvas )
-        // TODO: Coordinate translation
-        m_canvas->Refresh(false, rect);
+    wxWindow::Refresh(false, rect);

 
 #if wxPG_REFRESH_CONTROLS_AFTER_REPAINT
     // I think this really helps only GTK+1.2
 
 #if wxPG_REFRESH_CONTROLS_AFTER_REPAINT
     // I think this really helps only GTK+1.2


@@ -2606,10 +2634,11 @@ void wxPropertyGrid::SwitchState( wxPropertyGridPageState* pNewState )
     {
         //
         // Just in case, fully re-center splitter
     {
         //
         // Just in case, fully re-center splitter

-        if ( HasFlag( wxPG_SPLITTER_AUTO_CENTER ) )
-            pNewState->m_fSplitterX = -1.0;
+        //if ( HasFlag( wxPG_SPLITTER_AUTO_CENTER ) )
+        //    pNewState->m_fSplitterX = -1.0;

 
 

-        pNewState->OnClientWidthChange( pgWidth, pgWidth - pNewState->m_width );
+        pNewState->OnClientWidthChange(pgWidth,
+                                       pgWidth - pNewState->m_width);

     }
 
     m_propHover = NULL;
     }
 
     m_propHover = NULL;


@@ -2640,7 +2669,9 @@ void wxPropertyGrid::SwitchState( wxPropertyGridPageState* pNewState )
 
 // Call to SetSplitterPosition will always disable splitter auto-centering
 // if parent window is shown.
 
 // Call to SetSplitterPosition will always disable splitter auto-centering
 // if parent window is shown.

-void wxPropertyGrid::DoSetSplitterPosition_( int newxpos, bool refresh, int splitterIndex, bool allPages )
+void wxPropertyGrid::DoSetSplitterPosition_( int newxpos, bool refresh,
+                                             int splitterIndex,
+                                             bool allPages )

 {
     if ( ( newxpos < wxPG_DRAG_MARGIN ) )
         return;
 {
     if ( ( newxpos < wxPG_DRAG_MARGIN ) )
         return;


@@ -2662,9 +2693,9 @@ void wxPropertyGrid::DoSetSplitterPosition_( int newxpos, bool refresh, int spli
 
 void wxPropertyGrid::CenterSplitter( bool enableAutoCentering )
 {
 
 void wxPropertyGrid::CenterSplitter( bool enableAutoCentering )
 {

-    SetSplitterPosition( m_width/2, true );
-    if ( enableAutoCentering && ( m_windowStyle & wxPG_SPLITTER_AUTO_CENTER ) )
-        m_iFlags &= ~(wxPG_FL_DONT_CENTER_SPLITTER);
+    SetSplitterPosition( m_width/2 );
+    if ( enableAutoCentering && HasFlag(wxPG_SPLITTER_AUTO_CENTER) )
+        m_pState->m_dontCenterSplitter = false;

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


@@ -2809,7 +2840,10 @@ bool wxPropertyGrid::PerformValidation( wxPGProperty* p, wxVariant& pendingValue
 
     m_validationInfo.m_failureBehavior = m_permanentValidationFailureBehavior;
 
 
     m_validationInfo.m_failureBehavior = m_permanentValidationFailureBehavior;
 

-    if ( pendingValue.GetType() == wxPG_VARIANT_TYPE_LIST )
+    //
+    // Variant list a special value that cannot be validated
+    // by normal means.
+    if ( pendingValue.GetType() != wxPG_VARIANT_TYPE_LIST )

     {
         if ( !p->ValidateValue(pendingValue, m_validationInfo) )
             return false;
     {
         if ( !p->ValidateValue(pendingValue, m_validationInfo) )
             return false;


@@ -3240,7 +3274,12 @@ void wxPropertyGrid::HandleCustomEditorEvent( wxEvent &event )
 
     // Somehow, event is handled after property has been deselected.
     // Possibly, but very rare.
 
     // Somehow, event is handled after property has been deselected.
     // Possibly, but very rare.

-    if ( !selected || selected->HasFlag(wxPG_PROP_BEING_DELETED) )
+    if ( !selected ||
+          selected->HasFlag(wxPG_PROP_BEING_DELETED) ||
+          // Also don't handle editor event if wxEVT_PG_CHANGED or
+          // similar is currently doing something (showing a
+          // message box, for instance).
+          m_processedEvent )

         return;
 
     if ( m_iFlags & wxPG_FL_IN_HANDLECUSTOMEDITOREVENT )
         return;
 
     if ( m_iFlags & wxPG_FL_IN_HANDLECUSTOMEDITOREVENT )


@@ -3385,11 +3424,14 @@ void wxPropertyGrid::HandleCustomEditorEvent( wxEvent &event )
 wxRect wxPropertyGrid::GetEditorWidgetRect( wxPGProperty* p, int column ) const
 {
     int itemy = p->GetY2(m_lineHeight);
 wxRect wxPropertyGrid::GetEditorWidgetRect( wxPGProperty* p, int column ) const
 {
     int itemy = p->GetY2(m_lineHeight);

-    int vy = 0;

     int splitterX = m_pState->DoGetSplitterPosition(column-1);
     int colEnd = splitterX + m_pState->m_colWidths[column];
     int imageOffset = 0;
 
     int splitterX = m_pState->DoGetSplitterPosition(column-1);
     int colEnd = splitterX + m_pState->m_colWidths[column];
     int imageOffset = 0;
 

+    int vx, vy;  // Top left corner of client
+    GetViewStart(&vx, &vy);
+    vy *= wxPG_PIXELS_PER_UNIT;
+

     // TODO: If custom image detection changes from current, change this.
     if ( m_iFlags & wxPG_FL_CUR_USES_CUSTOM_IMAGE )
     {
     // TODO: If custom image detection changes from current, change this.
     if ( m_iFlags & wxPG_FL_CUR_USES_CUSTOM_IMAGE )
     {


@@ -3495,7 +3537,7 @@ void wxPropertyGrid::CustomSetCursor( int type, bool override )
     if ( type == wxCURSOR_SIZEWE )
         cursor = m_cursorSizeWE;
 
     if ( type == wxCURSOR_SIZEWE )
         cursor = m_cursorSizeWE;
 

-    m_canvas->SetCursor( *cursor );
+    SetCursor( *cursor );

 
     m_curcursor = type;
 }
 
     m_curcursor = type;
 }


@@ -3591,7 +3633,7 @@ void wxPropertyGrid::FreeEditors()
         wxWindow* parent = focus->GetParent();
         while ( parent )
         {
         wxWindow* parent = focus->GetParent();
         while ( parent )
         {

-            if ( parent == m_canvas )
+            if ( parent == this )

             {
                 SetFocusOnCanvas();
                 break;
             {
                 SetFocusOnCanvas();
                 break;


@@ -3787,10 +3829,11 @@ bool wxPropertyGrid::DoSelectProperty( wxPGProperty* p, unsigned int flags )
 
                 m_iFlags &= ~wxPG_FL_FIXED_WIDTH_EDITOR;
 
 
                 m_iFlags &= ~wxPG_FL_FIXED_WIDTH_EDITOR;
 

-                wxPGWindowList wndList = editor->CreateControls(this,
-                                                                p,
-                                                                goodPos,
-                                                                grect.GetSize());
+                wxPGWindowList wndList =
+                    editor->CreateControls(this,
+                                           p,
+                                           goodPos,
+                                           grect.GetSize());

 
                 m_wndEditor = wndList.m_primary;
                 m_wndEditor2 = wndList.m_secondary;
 
                 m_wndEditor = wndList.m_primary;
                 m_wndEditor2 = wndList.m_secondary;


@@ -3800,15 +3843,17 @@ bool wxPropertyGrid::DoSelectProperty( wxPGProperty* p, unsigned int flags )
                 // Essentially, primaryCtrl == m_wndEditor
                 //
 
                 // Essentially, primaryCtrl == m_wndEditor
                 //
 

-                // NOTE: It is allowed for m_wndEditor to be NULL - in this case
-                //       value is drawn as normal, and m_wndEditor2 is assumed
-                //       to be a right-aligned button that triggers a separate editorCtrl
-                //       window.
+                // NOTE: It is allowed for m_wndEditor to be NULL - in this
+                //       case value is drawn as normal, and m_wndEditor2 is
+                //       assumed to be a right-aligned button that triggers
+                //       a separate editorCtrl window.

 
                 if ( m_wndEditor )
                 {
                     wxASSERT_MSG( m_wndEditor->GetParent() == GetPanel(),
 
                 if ( m_wndEditor )
                 {
                     wxASSERT_MSG( m_wndEditor->GetParent() == GetPanel(),

-                                  wxT("CreateControls must use result of wxPropertyGrid::GetPanel() as parent of controls.") );
+                                  "CreateControls must use result of "
+                                  "wxPropertyGrid::GetPanel() as parent "
+                                  "of controls." );

 
                     // Set validator, if any
                 #if wxUSE_VALIDATORS
 
                     // Set validator, if any
                 #if wxUSE_VALIDATORS


@@ -3822,21 +3867,10 @@ bool wxPropertyGrid::DoSelectProperty( wxPGProperty* p, unsigned int flags )
 
                     // If it has modified status, use bold font
                     // (must be done before capturing m_ctrlXAdjust)
 
                     // If it has modified status, use bold font
                     // (must be done before capturing m_ctrlXAdjust)

-                    if ( (p->m_flags & wxPG_PROP_MODIFIED) && (m_windowStyle & wxPG_BOLD_MODIFIED) )
+                    if ( (p->m_flags & wxPG_PROP_MODIFIED) &&
+                         (m_windowStyle & wxPG_BOLD_MODIFIED) )

                         SetCurControlBoldFont();
 
                         SetCurControlBoldFont();
 

-                    //
-                    // Fix TextCtrl indentation
-                #if defined(__WXMSW__) && !defined(__WXWINCE__)
-                    wxTextCtrl* tc = NULL;
-                    if ( primaryCtrl->IsKindOf(CLASSINFO(wxOwnerDrawnComboBox)) )
-                        tc = ((wxOwnerDrawnComboBox*)primaryCtrl)->GetTextCtrl();
-                    else
-                        tc = wxDynamicCast(primaryCtrl, wxTextCtrl);
-                    if ( tc )
-                        ::SendMessage(GetHwndOf(tc), EM_SETMARGINS, EC_LEFTMARGIN | EC_RIGHTMARGIN, MAKELONG(0, 0));
-                #endif
-

                     // Store x relative to splitter (we'll need it).
                     m_ctrlXAdjust = m_wndEditor->GetPosition().x - splitterX;
 
                     // Store x relative to splitter (we'll need it).
                     m_ctrlXAdjust = m_wndEditor->GetPosition().x - splitterX;
 


@@ -3863,7 +3897,9 @@ bool wxPropertyGrid::DoSelectProperty( wxPGProperty* p, unsigned int flags )
                 if ( m_wndEditor2 )
                 {
                     wxASSERT_MSG( m_wndEditor2->GetParent() == GetPanel(),
                 if ( m_wndEditor2 )
                 {
                     wxASSERT_MSG( m_wndEditor2->GetParent() == GetPanel(),

-                                  wxT("CreateControls must use result of wxPropertyGrid::GetPanel() as parent of controls.") );
+                                  "CreateControls must use result of "
+                                  "wxPropertyGrid::GetPanel() as parent "
+                                  "of controls." );

 
                     // Get proper id for wndSecondary
                     m_wndSecId = m_wndEditor2->GetId();
 
                     // Get proper id for wndSecondary
                     m_wndSecId = m_wndEditor2->GetId();


@@ -3894,7 +3930,8 @@ bool wxPropertyGrid::DoSelectProperty( wxPGProperty* p, unsigned int flags )
             }
             else
             {
             }
             else
             {

-                // Make sure focus is in grid canvas (important for wxGTK, at least)
+                // Make sure focus is in grid canvas (important for wxGTK,
+                // at least)

                 SetFocusOnCanvas();
             }
 
                 SetFocusOnCanvas();
             }
 


@@ -4053,8 +4090,8 @@ bool wxPropertyGrid::DoCollapse( wxPGProperty* p, bool sendEvents )
     }
 
     // Store dont-center-splitter flag 'cause we need to temporarily set it
     }
 
     // Store dont-center-splitter flag 'cause we need to temporarily set it

-    wxUint32 old_flag = m_iFlags & wxPG_FL_DONT_CENTER_SPLITTER;
-    m_iFlags |= wxPG_FL_DONT_CENTER_SPLITTER;
+    bool prevDontCenterSplitter = m_pState->m_dontCenterSplitter;
+    m_pState->m_dontCenterSplitter = true;

 
     bool res = m_pState->DoCollapse(pwc);
 
 
     bool res = m_pState->DoCollapse(pwc);
 


@@ -4064,20 +4101,10 @@ bool wxPropertyGrid::DoCollapse( wxPGProperty* p, bool sendEvents )
             SendEvent( wxEVT_PG_ITEM_COLLAPSED, p );
 
         RecalculateVirtualSize();
             SendEvent( wxEVT_PG_ITEM_COLLAPSED, p );
 
         RecalculateVirtualSize();

-
-        // Redraw etc. only if collapsed was visible.
-        if (pwc->IsVisible() &&
-            !m_frozen &&
-            ( !pwc->IsCategory() || !(m_windowStyle & wxPG_HIDE_CATEGORIES) ) )
-        {
-            // When item is collapsed so that scrollbar would move,
-            // graphics mess is about (unless we redraw everything).
-            Refresh();
-        }
+        Refresh();

     }
 
     }
 

-    // Clear dont-center-splitter flag if it wasn't set
-    m_iFlags = (m_iFlags & ~wxPG_FL_DONT_CENTER_SPLITTER) | old_flag;
+    m_pState->m_dontCenterSplitter = prevDontCenterSplitter;

 
     return res;
 }
 
     return res;
 }


@@ -4091,8 +4118,8 @@ bool wxPropertyGrid::DoExpand( wxPGProperty* p, bool sendEvents )
     wxPGProperty* pwc = (wxPGProperty*)p;
 
     // Store dont-center-splitter flag 'cause we need to temporarily set it
     wxPGProperty* pwc = (wxPGProperty*)p;
 
     // Store dont-center-splitter flag 'cause we need to temporarily set it

-    wxUint32 old_flag = m_iFlags & wxPG_FL_DONT_CENTER_SPLITTER;
-    m_iFlags |= wxPG_FL_DONT_CENTER_SPLITTER;
+    bool prevDontCenterSplitter = m_pState->m_dontCenterSplitter;
+    m_pState->m_dontCenterSplitter = true;

 
     bool res = m_pState->DoExpand(pwc);
 
 
     bool res = m_pState->DoExpand(pwc);
 


@@ -4102,23 +4129,10 @@ bool wxPropertyGrid::DoExpand( wxPGProperty* p, bool sendEvents )
             SendEvent( wxEVT_PG_ITEM_EXPANDED, p );
 
         RecalculateVirtualSize();
             SendEvent( wxEVT_PG_ITEM_EXPANDED, p );
 
         RecalculateVirtualSize();

-
-        // Redraw etc. only if expanded was visible.
-        if ( pwc->IsVisible() && !m_frozen &&
-             ( !pwc->IsCategory() || !(m_windowStyle & wxPG_HIDE_CATEGORIES) )
-           )
-        {
-            // Redraw
-        #if wxPG_REFRESH_CONTROLS_AFTER_REPAINT
-            Refresh();
-        #else
-            DrawItems(pwc, NULL);
-        #endif
-        }
+        Refresh();

     }
 
     }
 

-    // Clear dont-center-splitter flag if it wasn't set
-    m_iFlags = (m_iFlags & ~wxPG_FL_DONT_CENTER_SPLITTER) | old_flag;
+    m_pState->m_dontCenterSplitter = prevDontCenterSplitter;

 
     return res;
 }
 
     return res;
 }


@@ -4219,8 +4233,6 @@ void wxPropertyGrid::RecalculateVirtualSize( int forceXPos )
     m_width = width;
     m_height = height;
 
     m_width = width;
     m_height = height;
 

-    m_canvas->SetSize( x, y );
-

     m_pState->CheckColumnWidths();
 
     if ( GetSelection() )
     m_pState->CheckColumnWidths();
 
     if ( GetSelection() )


@@ -4237,7 +4249,7 @@ void wxPropertyGrid::OnResize( wxSizeEvent& event )
         return;
 
     int width, height;
         return;
 
     int width, height;

-    GetClientSize(&width,&height);
+    GetClientSize(&width, &height);

 
     m_width = width;
     m_height = height;
 
     m_width = width;
     m_height = height;


@@ -4307,7 +4319,7 @@ void wxPropertyGrid::SetVirtualWidth( int width )
 
 void wxPropertyGrid::SetFocusOnCanvas()
 {
 
 void wxPropertyGrid::SetFocusOnCanvas()
 {

-    m_canvas->SetFocusIgnoringChildren();
+    SetFocusIgnoringChildren();

     m_editorFocused = 0;
 }
 
     m_editorFocused = 0;
 }
 


@@ -4328,20 +4340,25 @@ bool wxPropertyGrid::SendEvent( int eventType, wxPGProperty* p,
     evt.SetEventObject(m_eventObject);
     evt.SetProperty(p);
     evt.SetColumn(column);
     evt.SetEventObject(m_eventObject);
     evt.SetProperty(p);
     evt.SetColumn(column);

-    if ( pValue )
+    if ( eventType == wxEVT_PG_CHANGING )

     {
     {

+        wxASSERT( pValue );

         evt.SetCanVeto(true);
         evt.SetCanVeto(true);

-        evt.SetupValidationInfo();

         m_validationInfo.m_pValue = pValue;
         m_validationInfo.m_pValue = pValue;

+        evt.SetupValidationInfo();

     }
     }

-    else if ( !(selFlags & wxPG_SEL_NOVALIDATE) )
+    else

     {
     {

-        evt.SetCanVeto(true);
-    }
+        if ( p )
+            evt.SetPropertyValue(p->GetValue());

 
 

-    wxEvtHandler* evtHandler = m_eventObject->GetEventHandler();
+        if ( !(selFlags & wxPG_SEL_NOVALIDATE) )
+            evt.SetCanVeto(true);
+    }

 
 

-    evtHandler->ProcessEvent(evt);
+    m_processedEvent = &evt;
+    m_eventObject->HandleWindowEvent(evt);
+    m_processedEvent = NULL;

 
     return evt.WasVetoed();
 }
 
     return evt.WasVetoed();
 }


@@ -4463,7 +4480,7 @@ bool wxPropertyGrid::HandleMouseClick( int x, unsigned int y, wxMouseEvent &even
 
                         if ( !(m_iFlags & wxPG_FL_MOUSE_CAPTURED) )
                         {
 
                         if ( !(m_iFlags & wxPG_FL_MOUSE_CAPTURED) )
                         {

-                            m_canvas->CaptureMouse();
+                            CaptureMouse();

                             m_iFlags |= wxPG_FL_MOUSE_CAPTURED;
                         }
 
                             m_iFlags |= wxPG_FL_MOUSE_CAPTURED;
                         }
 


@@ -4471,8 +4488,6 @@ bool wxPropertyGrid::HandleMouseClick( int x, unsigned int y, wxMouseEvent &even
                         m_draggedSplitter = splitterHit;
                         m_dragOffset = splitterHitOffset;
 
                         m_draggedSplitter = splitterHit;
                         m_dragOffset = splitterHitOffset;
 

-                        wxClientDC dc(m_canvas);
-

                     #if wxPG_REFRESH_CONTROLS_AFTER_REPAINT
                         // Fixes button disappearance bug
                         if ( m_wndEditor2 )
                     #if wxPG_REFRESH_CONTROLS_AFTER_REPAINT
                         // Fixes button disappearance bug
                         if ( m_wndEditor2 )


@@ -4558,14 +4573,14 @@ void wxPropertyGrid::SetToolTip( const wxString& tipString )
 {
     if ( tipString.length() )
     {
 {
     if ( tipString.length() )
     {

-        m_canvas->SetToolTip(tipString);
+        wxScrolledWindow::SetToolTip(tipString);

     }
     else
     {
     #if wxPG_ALLOW_EMPTY_TOOLTIPS
     }
     else
     {
     #if wxPG_ALLOW_EMPTY_TOOLTIPS

-        m_canvas->SetToolTip( m_emptyString );
+        wxScrolledWindow::SetToolTip( m_emptyString );

     #else
     #else

-        m_canvas->SetToolTip( NULL );
+        wxScrolledWindow::SetToolTip( NULL );

     #endif
     }
 }
     #endif
     }
 }


@@ -4575,13 +4590,14 @@ void wxPropertyGrid::SetToolTip( const wxString& tipString )
 // -----------------------------------------------------------------------
 
 // Return false if should be skipped
 // -----------------------------------------------------------------------
 
 // Return false if should be skipped

-bool wxPropertyGrid::HandleMouseMove( int x, unsigned int y, wxMouseEvent &event )
+bool wxPropertyGrid::HandleMouseMove( int x, unsigned int y,
+                                      wxMouseEvent &event )

 {
     // Safety check (needed because mouse capturing may
     // otherwise freeze the control)
     if ( m_dragStatus > 0 && !event.Dragging() )
     {
 {
     // Safety check (needed because mouse capturing may
     // otherwise freeze the control)
     if ( m_dragStatus > 0 && !event.Dragging() )
     {

-        HandleMouseUp(x,y,event);
+        HandleMouseUp(x, y, event);

     }
 
     wxPropertyGridPageState* state = m_pState;
     }
 
     wxPropertyGridPageState* state = m_pState;


@@ -4605,8 +4621,10 @@ bool wxPropertyGrid::HandleMouseMove( int x, unsigned int y, wxMouseEvent &event
             if ( newSplitterX != splitterX )
             {
                 // Move everything
             if ( newSplitterX != splitterX )
             {
                 // Move everything

-                SetInternalFlag(wxPG_FL_DONT_CENTER_SPLITTER);
-                state->DoSetSplitterPosition( newSplitterX, m_draggedSplitter, false );
+                state->m_dontCenterSplitter = true;
+                state->DoSetSplitterPosition(newSplitterX,
+                                             m_draggedSplitter,
+                                             false);

                 state->m_fSplitterX = (float) newSplitterX;
 
                 if ( GetSelection() )
                 state->m_fSplitterX = (float) newSplitterX;
 
                 if ( GetSelection() )


@@ -4662,7 +4680,7 @@ bool wxPropertyGrid::HandleMouseMove( int x, unsigned int y, wxMouseEvent &event
         //
         if ( m_windowStyle & wxPG_TOOLTIPS )
         {
         //
         if ( m_windowStyle & wxPG_TOOLTIPS )
         {

-            wxToolTip* tooltip = m_canvas->GetToolTip();
+            wxToolTip* tooltip = GetToolTip();

 
             if ( m_propHover != prevHover || prevSide != m_mouseSide )
             {
 
             if ( m_propHover != prevHover || prevSide != m_mouseSide )
             {


@@ -4693,7 +4711,9 @@ bool wxPropertyGrid::HandleMouseMove( int x, unsigned int y, wxMouseEvent &event
 
                             space = m_width - splitterX;
                             if ( m_propHover->m_flags & wxPG_PROP_CUSTOMIMAGE )
 
                             space = m_width - splitterX;
                             if ( m_propHover->m_flags & wxPG_PROP_CUSTOMIMAGE )

-                                space -= wxPG_CUSTOM_IMAGE_WIDTH + wxCC_CUSTOM_IMAGE_MARGIN1 + wxCC_CUSTOM_IMAGE_MARGIN2;
+                                space -= wxPG_CUSTOM_IMAGE_WIDTH +
+                                         wxCC_CUSTOM_IMAGE_MARGIN1 +
+                                         wxCC_CUSTOM_IMAGE_MARGIN2;

                         }
 
                         if ( space )
                         }
 
                         if ( space )


@@ -4710,9 +4730,9 @@ bool wxPropertyGrid::HandleMouseMove( int x, unsigned int y, wxMouseEvent &event
                             if ( tooltip )
                             {
                             #if wxPG_ALLOW_EMPTY_TOOLTIPS
                             if ( tooltip )
                             {
                             #if wxPG_ALLOW_EMPTY_TOOLTIPS

-                                m_canvas->SetToolTip( m_emptyString );
+                                SetToolTip( m_emptyString );

                             #else
                             #else

-                                m_canvas->SetToolTip( NULL );
+                                wxScrolledWindow::SetToolTip( NULL );

                             #endif
                             }
                         }
                             #endif
                             }
                         }


@@ -4724,9 +4744,9 @@ bool wxPropertyGrid::HandleMouseMove( int x, unsigned int y, wxMouseEvent &event
                     if ( tooltip )
                     {
                     #if wxPG_ALLOW_EMPTY_TOOLTIPS
                     if ( tooltip )
                     {
                     #if wxPG_ALLOW_EMPTY_TOOLTIPS

-                        m_canvas->SetToolTip( m_emptyString );
+                        SetToolTip( m_emptyString );

                     #else
                     #else

-                        m_canvas->SetToolTip( NULL );
+                        wxScrolledWindow::SetToolTip( NULL );

                     #endif
                     }
                 }
                     #endif
                     }
                 }


@@ -4754,8 +4774,8 @@ bool wxPropertyGrid::HandleMouseMove( int x, unsigned int y, wxMouseEvent &event
 
                 // hovering on splitter
 
 
                 // hovering on splitter
 

-                // NB: Condition disabled since MouseLeave event (from the editor control) cannot be
-                //     reliably detected.
+                // NB: Condition disabled since MouseLeave event (from the
+                //     editor control) cannot be reliably detected.

                 //if ( m_curcursor != wxCURSOR_SIZEWE )
                 CustomSetCursor( wxCURSOR_SIZEWE, true );
 
                 //if ( m_curcursor != wxCURSOR_SIZEWE )
                 CustomSetCursor( wxCURSOR_SIZEWE, true );
 


@@ -4772,13 +4792,33 @@ bool wxPropertyGrid::HandleMouseMove( int x, unsigned int y, wxMouseEvent &event
         //
         // Multi select by dragging
         //
         //
         // Multi select by dragging
         //

-        if ( GetExtraStyle() & wxPG_EX_MULTIPLE_SELECTION &&
+        if ( (GetExtraStyle() & wxPG_EX_MULTIPLE_SELECTION) &&

              event.LeftIsDown() &&
              m_propHover &&
              GetSelection() &&
              event.LeftIsDown() &&
              m_propHover &&
              GetSelection() &&

+             columnHit != 1 &&

              !state->DoIsPropertySelected(m_propHover) )
         {
              !state->DoIsPropertySelected(m_propHover) )
         {

-            DoAddToSelection(m_propHover);
+            // Additional requirement is that the hovered property
+            // is adjacent to edges of selection.
+            const wxArrayPGProperty& selection = GetSelectedProperties();
+
+            // Since categories cannot be selected along with 'other'
+            // properties, exclude them from iterator flags.
+            int iterFlags = wxPG_ITERATE_VISIBLE & (~wxPG_PROP_CATEGORY);
+
+            for ( int i=(selection.size()-1); i>=0; i-- )
+            {
+                // TODO: This could be optimized by keeping track of
+                //       which properties are at the edges of selection.
+                wxPGProperty* selProp = selection[i];
+                if ( state->ArePropertiesAdjacent(m_propHover, selProp,
+                                                  iterFlags) )
+                {
+                    DoAddToSelection(m_propHover);
+                    break;
+                }
+            }

         }
     }
     return true;
         }
     }
     return true;


@@ -4810,12 +4850,12 @@ bool wxPropertyGrid::HandleMouseUp( int x, unsigned int WXUNUSED(y),
         //splitterX = x;
 
         // Disable splitter auto-centering
         //splitterX = x;
 
         // Disable splitter auto-centering

-        m_iFlags |= wxPG_FL_DONT_CENTER_SPLITTER;
+        state->m_dontCenterSplitter = true;

 
         // This is necessary to return cursor
         if ( m_iFlags & wxPG_FL_MOUSE_CAPTURED )
         {
 
         // This is necessary to return cursor
         if ( m_iFlags & wxPG_FL_MOUSE_CAPTURED )
         {

-            m_canvas->ReleaseMouse();
+            ReleaseMouse();

             m_iFlags &= ~(wxPG_FL_MOUSE_CAPTURED);
         }
 
             m_iFlags &= ~(wxPG_FL_MOUSE_CAPTURED);
         }
 


@@ -4857,10 +4897,8 @@ bool wxPropertyGrid::OnMouseCommon( wxMouseEvent& event, int* px, int* py )
 {
     int splitterX = GetSplitterPosition();
 
 {
     int splitterX = GetSplitterPosition();
 

-    //int ux, uy;
-    //CalcUnscrolledPosition( event.m_x, event.m_y, &ux, &uy );
-    int ux = event.m_x;
-    int uy = event.m_y;
+    int ux, uy;
+    CalcUnscrolledPosition( event.m_x, event.m_y, &ux, &uy );

 
     wxWindow* wnd = GetEditorControl();
 
 
     wxWindow* wnd = GetEditorControl();
 


@@ -4943,14 +4981,6 @@ void wxPropertyGrid::OnMouseMove( wxMouseEvent &event )
 
 // -----------------------------------------------------------------------
 
 
 // -----------------------------------------------------------------------
 

-void wxPropertyGrid::OnMouseMoveBottom( wxMouseEvent& WXUNUSED(event) )
-{
-    // Called when mouse moves in the empty space below the properties.
-    CustomSetCursor( wxCURSOR_ARROW );
-}
-
-// -----------------------------------------------------------------------
-

 void wxPropertyGrid::OnMouseUp( wxMouseEvent &event )
 {
     int x, y;
 void wxPropertyGrid::OnMouseUp( wxMouseEvent &event )
 {
     int x, y;


@@ -4985,7 +5015,7 @@ void wxPropertyGrid::OnMouseEntry( wxMouseEvent &event )
     else if ( event.Leaving() )
     {
         // Without this, wxSpinCtrl editor will sometimes have wrong cursor
     else if ( event.Leaving() )
     {
         // Without this, wxSpinCtrl editor will sometimes have wrong cursor

-        m_canvas->SetCursor( wxNullCursor );
+        SetCursor( wxNullCursor );

 
         // Get real cursor position
         wxPoint pt = ScreenToClient(::wxGetMousePosition());
 
         // Get real cursor position
         wxPoint pt = ScreenToClient(::wxGetMousePosition());


@@ -5137,14 +5167,25 @@ void wxPropertyGrid::AddActionTrigger( int action, int keycode, int modifiers )
 void wxPropertyGrid::ClearActionTriggers( int action )
 {
     wxPGHashMapI2I::iterator it;
 void wxPropertyGrid::ClearActionTriggers( int action )
 {
     wxPGHashMapI2I::iterator it;

+    bool didSomething;

 
 

-    for ( it = m_actionTriggers.begin(); it != m_actionTriggers.end(); ++it )
+    do

     {
     {

-        if ( it->second == action )
+        didSomething = false;
+
+        for ( it = m_actionTriggers.begin();
+              it != m_actionTriggers.end();
+              it++ )

         {
         {

-            m_actionTriggers.erase(it);
+            if ( it->second == action )
+            {
+                m_actionTriggers.erase(it);
+                didSomething = true;
+                break;
+            }

         }
     }
         }
     }

+    while ( didSomething );

 }
 
 void wxPropertyGrid::HandleKeyEvent( wxKeyEvent &event, bool fromChild )
 }
 
 void wxPropertyGrid::HandleKeyEvent( wxKeyEvent &event, bool fromChild )


@@ -5383,10 +5424,11 @@ void wxPropertyGrid::OnIdle( wxIdleEvent& WXUNUSED(event) )
 
     //
     // Check if top-level parent has changed
 
     //
     // Check if top-level parent has changed

-    wxWindow* tlp = ::wxGetTopLevelParent(this);
-    if ( tlp != m_tlp )
+    if ( GetExtraStyle() & wxPG_EX_ENABLE_TLP_TRACKING )

     {
     {

-        OnTLPChanging(tlp);
+        wxWindow* tlp = ::wxGetTopLevelParent(this);
+        if ( tlp != m_tlp )
+            OnTLPChanging(tlp);

     }
 }
 
     }
 }
 


@@ -5753,6 +5795,7 @@ wxPropertyGridEvent::wxPropertyGridEvent(const wxPropertyGridEvent& event)
     m_eventType = event.GetEventType();
     m_eventObject = event.m_eventObject;
     m_pg = event.m_pg;
     m_eventType = event.GetEventType();
     m_eventObject = event.m_eventObject;
     m_pg = event.m_pg;

+    OnPropertyGridSet();

     m_property = event.m_property;
     m_validationInfo = event.m_validationInfo;
     m_canVeto = event.m_canVeto;
     m_property = event.m_property;
     m_validationInfo = event.m_validationInfo;
     m_canVeto = event.m_canVeto;


@@ -5761,8 +5804,40 @@ wxPropertyGridEvent::wxPropertyGridEvent(const wxPropertyGridEvent& event)
 
 // -----------------------------------------------------------------------
 
 
 // -----------------------------------------------------------------------
 

+void wxPropertyGridEvent::OnPropertyGridSet()
+{
+    if ( !m_pg )
+        return;
+
+#if wxUSE_THREADS
+    wxCriticalSectionLocker(wxPGGlobalVars->m_critSect);
+#endif
+    m_pg->m_liveEvents.push_back(this);
+}
+
+// -----------------------------------------------------------------------
+

 wxPropertyGridEvent::~wxPropertyGridEvent()
 {
 wxPropertyGridEvent::~wxPropertyGridEvent()
 {

+    if ( m_pg )
+    {
+    #if wxUSE_THREADS
+        wxCriticalSectionLocker(wxPGGlobalVars->m_critSect);
+    #endif
+
+        // Use iterate from the back since it is more likely that the event
+        // being desroyed is at the end of the array.
+        wxVector<wxPropertyGridEvent*>& liveEvents = m_pg->m_liveEvents;
+
+        for ( int i = liveEvents.size()-1; i >= 0; i-- )
+        {
+            if ( liveEvents[i] == this )
+            {
+                liveEvents.erase(liveEvents.begin() + i);
+                break;
+            }
+        }
+    }

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