wxaui flags reworked a bit; allows any hinting type to be explicity invoked; turning off hinting completely is not possible; sample updated accordingly

git-svn-id: https://svn.wxwidgets.org/svn/wx/wxWidgets/trunk@42451 c3d73ce0-8a6f-49c7-b76d-6d57e0e08775

include/wx/aui/framemanager.h

@@ -39,23 +39,22 @@ enum wxFrameManagerDock
 
 enum wxFrameManagerOption
 {
-    wxAUI_MGR_ALLOW_FLOATING        = 1 << 0,
+    wxAUI_MGR_ALLOW_FLOATING           = 1 << 0,
-    wxAUI_MGR_ALLOW_ACTIVE_PANE     = 1 << 1,
+    wxAUI_MGR_ALLOW_ACTIVE_PANE        = 1 << 1,
-    wxAUI_MGR_TRANSPARENT_DRAG      = 1 << 2,
+    wxAUI_MGR_TRANSPARENT_DRAG         = 1 << 2,
-    wxAUI_MGR_TRANSPARENT_HINT      = 1 << 3,
+    wxAUI_MGR_TRANSPARENT_HINT         = 1 << 3,
-    wxAUI_MGR_TRANSPARENT_HINT_FADE = 1 << 4,
+    wxAUI_MGR_VENETIAN_BLINDS_HINT     = 1 << 4,
-    // The venetian blind effect is ONLY used when the wxAUI_MGR_TRANSPARENT_HINT has been used, but
+    wxAUI_MGR_RECTANGLE_HINT           = 1 << 5,
-    // at runtime we determine we cannot use transparency (because, for instance, the OS does not support it).
+    wxAUI_MGR_HINT_FADE                = 1 << 6,
-    // setting this flag drops back in such circumstances (only) to the behaviour without wxAUI_MGR_TRANSPARENT_HINT
+    wxAUI_MGR_NO_VENETIAN_BLINDS_FADE  = 1 << 7,
-    wxAUI_MGR_DISABLE_VENETIAN_BLINDS = 1 << 5,
-    wxAUI_MGR_DISABLE_VENETIAN_BLINDS_FADE = 1 << 6,
 
     wxAUI_MGR_DEFAULT = wxAUI_MGR_ALLOW_FLOATING |
                         wxAUI_MGR_TRANSPARENT_HINT |
-                        wxAUI_MGR_TRANSPARENT_HINT_FADE |
+                        wxAUI_MGR_HINT_FADE |
-                        wxAUI_MGR_DISABLE_VENETIAN_BLINDS_FADE
+                        wxAUI_MGR_NO_VENETIAN_BLINDS_FADE
 };
 
+
 enum wxPaneDockArtSetting
 {
     wxAUI_ART_SASH_SIZE = 0,
@@ -443,11 +442,11 @@ public:
 
 
 public:
-    virtual wxFloatingPane * CreateFloatingFrame(wxWindow* parent, const wxPaneInfo& p);
+    virtual wxFloatingPane* CreateFloatingFrame(wxWindow* parent, const wxPaneInfo& p);
 
     void DrawHintRect(wxWindow* pane_window,
-                       const wxPoint& pt,
+                      const wxPoint& pt,
-                       const wxPoint& offset);
+                      const wxPoint& offset);
     virtual void ShowHint(const wxRect& rect);
     virtual void HideHint();
 
@@ -461,7 +460,7 @@ public:
     
 protected:
 
-
+    void UpdateHintWindowConfig();
     
     void DoFrameLayout();
 

samples/aui/auidemo.cpp

@@ -74,9 +74,11 @@ class MyFrame : public wxFrame
         ID_AllowFloating,
         ID_AllowActivePane,
         ID_TransparentHint,
-        ID_TransparentHintFade,
+        ID_VenetianBlindsHint,
-        ID_DisableVenetian,
+        ID_RectangleHint,
-        ID_DisableVenetianFade,
+        ID_NoHint,
+        ID_HintFade,
+        ID_NoVenetianFade,
         ID_TransparentDrag,
         ID_NoGradient,
         ID_VerticalGradient,
@@ -551,9 +553,11 @@ BEGIN_EVENT_TABLE(MyFrame, wxFrame)
     EVT_MENU(MyFrame::ID_CopyPerspectiveCode, MyFrame::OnCopyPerspectiveCode)
     EVT_MENU(ID_AllowFloating, MyFrame::OnManagerFlag)
     EVT_MENU(ID_TransparentHint, MyFrame::OnManagerFlag)
-    EVT_MENU(ID_TransparentHintFade, MyFrame::OnManagerFlag)
+    EVT_MENU(ID_VenetianBlindsHint, MyFrame::OnManagerFlag)
-    EVT_MENU(ID_DisableVenetian, MyFrame::OnManagerFlag)
+    EVT_MENU(ID_RectangleHint, MyFrame::OnManagerFlag)
-    EVT_MENU(ID_DisableVenetianFade, MyFrame::OnManagerFlag)
+    EVT_MENU(ID_NoHint, MyFrame::OnManagerFlag)
+    EVT_MENU(ID_HintFade, MyFrame::OnManagerFlag)
+    EVT_MENU(ID_NoVenetianFade, MyFrame::OnManagerFlag)
     EVT_MENU(ID_TransparentDrag, MyFrame::OnManagerFlag)
     EVT_MENU(ID_AllowActivePane, MyFrame::OnManagerFlag)
     EVT_MENU(ID_NoGradient, MyFrame::OnGradient)
@@ -570,9 +574,11 @@ BEGIN_EVENT_TABLE(MyFrame, wxFrame)
     EVT_MENU(wxID_ABOUT, MyFrame::OnAbout)
     EVT_UPDATE_UI(ID_AllowFloating, MyFrame::OnUpdateUI)
     EVT_UPDATE_UI(ID_TransparentHint, MyFrame::OnUpdateUI)
-    EVT_UPDATE_UI(ID_TransparentHintFade, MyFrame::OnUpdateUI)
+    EVT_UPDATE_UI(ID_VenetianBlindsHint, MyFrame::OnUpdateUI)
-    EVT_UPDATE_UI(ID_DisableVenetian, MyFrame::OnUpdateUI)
+    EVT_UPDATE_UI(ID_RectangleHint, MyFrame::OnUpdateUI)
-    EVT_UPDATE_UI(ID_DisableVenetianFade, MyFrame::OnUpdateUI)
+    EVT_UPDATE_UI(ID_NoHint, MyFrame::OnUpdateUI)
+    EVT_UPDATE_UI(ID_HintFade, MyFrame::OnUpdateUI)
+    EVT_UPDATE_UI(ID_NoVenetianFade, MyFrame::OnUpdateUI)
     EVT_UPDATE_UI(ID_TransparentDrag, MyFrame::OnUpdateUI)
     EVT_UPDATE_UI(ID_NoGradient, MyFrame::OnUpdateUI)
     EVT_UPDATE_UI(ID_VerticalGradient, MyFrame::OnUpdateUI)
@@ -618,11 +624,14 @@ MyFrame::MyFrame(wxWindow* parent,
     view_menu->Append(ID_SizeReportContent, _("Use a Size Reporter for the Content Pane"));
 
     wxMenu* options_menu = new wxMenu;
+    options_menu->AppendRadioItem(ID_TransparentHint, _("Transparent Hint"));
+    options_menu->AppendRadioItem(ID_VenetianBlindsHint, _("Venetian Blinds Hint"));
+    options_menu->AppendRadioItem(ID_RectangleHint, _("Rectangle Hint"));
+    options_menu->AppendRadioItem(ID_NoHint, _("No Hint"));
+    options_menu->AppendSeparator();
+    options_menu->AppendCheckItem(ID_HintFade, _("Hint Fade-in"));
     options_menu->AppendCheckItem(ID_AllowFloating, _("Allow Floating"));
-    options_menu->AppendCheckItem(ID_TransparentHint, _("Transparent Hint"));
+    options_menu->AppendCheckItem(ID_NoVenetianFade, _("Disable Venetian Blinds Hint Fade-in"));
-    options_menu->AppendCheckItem(ID_TransparentHintFade, _("Transparent Hint Fade-in"));
-    options_menu->AppendCheckItem(ID_DisableVenetian, _("Disable Venetian Blinds Hint"));
-    options_menu->AppendCheckItem(ID_DisableVenetianFade, _("Disable Venetian Blinds Hint Fade-in"));
     options_menu->AppendCheckItem(ID_TransparentDrag, _("Transparent Drag"));
     options_menu->AppendCheckItem(ID_AllowActivePane, _("Allow Active Pane"));
     options_menu->AppendSeparator();
@@ -921,24 +930,44 @@ void MyFrame::OnManagerFlag(wxCommandEvent& event)
 #if !defined(__WXMSW__) && !defined(__WXMAC__) && !defined(__WXGTK__)
     if (event.GetId() == ID_TransparentDrag ||
         event.GetId() == ID_TransparentHint ||
-        event.GetId() == ID_TransparentHintFade)
+        event.GetId() == ID_HintFade)
     {
         wxMessageBox(wxT("This option is presently only available on wxGTK, wxMSW and wxMac"));
         return;
     }
 #endif
 
-    switch (event.GetId())
+    int id = event.GetId();
+
+    if (id == ID_TransparentHint ||
+        id == ID_VenetianBlindsHint ||
+        id == ID_RectangleHint ||
+        id == ID_NoHint)
+    {
+        unsigned int flags = m_mgr.GetFlags();
+        flags &= ~wxAUI_MGR_TRANSPARENT_HINT;
+        flags &= ~wxAUI_MGR_VENETIAN_BLINDS_HINT;
+        flags &= ~wxAUI_MGR_RECTANGLE_HINT;
+        m_mgr.SetFlags(flags);
+    }
+
+    switch (id)
     {
         case ID_AllowFloating: flag = wxAUI_MGR_ALLOW_FLOATING; break;
         case ID_TransparentDrag: flag = wxAUI_MGR_TRANSPARENT_DRAG; break;
-        case ID_TransparentHint: flag = wxAUI_MGR_TRANSPARENT_HINT; break;
+        case ID_HintFade: flag = wxAUI_MGR_HINT_FADE; break;
-        case ID_TransparentHintFade: flag = wxAUI_MGR_TRANSPARENT_HINT_FADE; break;
+        case ID_NoVenetianFade: flag = wxAUI_MGR_NO_VENETIAN_BLINDS_FADE; break;
-        case ID_DisableVenetian: flag = wxAUI_MGR_DISABLE_VENETIAN_BLINDS; break;
-        case ID_DisableVenetianFade: flag = wxAUI_MGR_DISABLE_VENETIAN_BLINDS_FADE; break;
         case ID_AllowActivePane: flag = wxAUI_MGR_ALLOW_ACTIVE_PANE; break;
+        case ID_TransparentHint: flag = wxAUI_MGR_TRANSPARENT_HINT; break;
+        case ID_VenetianBlindsHint: flag = wxAUI_MGR_VENETIAN_BLINDS_HINT; break;
+        case ID_RectangleHint: flag = wxAUI_MGR_RECTANGLE_HINT; break;
     }
-    m_mgr.SetFlags(m_mgr.GetFlags() ^ flag);
+    
+    if (flag)
+    {
+        m_mgr.SetFlags(m_mgr.GetFlags() ^ flag);
+    }
+    
     m_mgr.Update();
 }
 
@@ -966,14 +995,22 @@ void MyFrame::OnUpdateUI(wxUpdateUIEvent& event)
         case ID_TransparentHint:
             event.Check((flags & wxAUI_MGR_TRANSPARENT_HINT) != 0);
             break;
-        case ID_TransparentHintFade:
+        case ID_VenetianBlindsHint:
-            event.Check((flags & wxAUI_MGR_TRANSPARENT_HINT_FADE) != 0);
+            event.Check((flags & wxAUI_MGR_VENETIAN_BLINDS_HINT) != 0);
             break;
-        case ID_DisableVenetian:
+        case ID_RectangleHint:
-            event.Check((flags & wxAUI_MGR_DISABLE_VENETIAN_BLINDS) != 0);
+            event.Check((flags & wxAUI_MGR_RECTANGLE_HINT) != 0);
             break;
-        case ID_DisableVenetianFade:
+        case ID_NoHint:
-            event.Check((flags & wxAUI_MGR_DISABLE_VENETIAN_BLINDS_FADE) != 0);
+            event.Check(((wxAUI_MGR_TRANSPARENT_HINT |
+                          wxAUI_MGR_VENETIAN_BLINDS_HINT |
+                          wxAUI_MGR_RECTANGLE_HINT) & flags) == 0);
+            break;        
+        case ID_HintFade:
+            event.Check((flags & wxAUI_MGR_HINT_FADE) != 0);
+            break;
+        case ID_NoVenetianFade:
+            event.Check((flags & wxAUI_MGR_NO_VENETIAN_BLINDS_FADE) != 0);
             break;
     }
 }

src/aui/framemanager.cpp

@@ -147,7 +147,11 @@ public:
     }
 
 #ifdef __WXGTK__
-    void OnWindowCreate(wxWindowCreateEvent& WXUNUSED(event)) {m_CanSetShape=true; SetTransparent(0);}
+    void OnWindowCreate(wxWindowCreateEvent& WXUNUSED(event))
+    {
+        m_CanSetShape=true;
+        SetTransparent(0);
+    }
 #endif
 
     void OnSize(wxSizeEvent& event)
@@ -184,7 +188,7 @@ private:
 };
 
 
-IMPLEMENT_DYNAMIC_CLASS( wxPseudoTransparentFrame, wxFrame )
+IMPLEMENT_DYNAMIC_CLASS(wxPseudoTransparentFrame, wxFrame)
 
 BEGIN_EVENT_TABLE(wxPseudoTransparentFrame, wxFrame)
     EVT_PAINT(wxPseudoTransparentFrame::OnPaint)
@@ -580,7 +584,22 @@ wxDockUIPart* wxFrameManager::HitTest(int x, int y)
 // options which are global to wxFrameManager
 void wxFrameManager::SetFlags(unsigned int flags)
 {
+    // find out if we have to call UpdateHintWindowConfig()
+    bool update_hint_wnd = false;
+    unsigned int hint_mask = wxAUI_MGR_TRANSPARENT_HINT |
+                             wxAUI_MGR_VENETIAN_BLINDS_HINT |
+                             wxAUI_MGR_RECTANGLE_HINT;
+    if ((flags & hint_mask) != (m_flags & hint_mask))
+        update_hint_wnd = true;
+
+
+    // set the new flags
     m_flags = flags;
+    
+    if (update_hint_wnd)
+    {
+        UpdateHintWindowConfig();
+    }
 }
 
 unsigned int wxFrameManager::GetFlags() const
@@ -602,16 +621,97 @@ wxFrame* wxFrameManager::GetFrame() const
 }
 
 
+void wxFrameManager::UpdateHintWindowConfig()
+{
+    // find out if the the system can do transparent frames
+    bool can_do_transparent = false;
+    
+    wxWindow* w = m_frame;
+    while (w)
+    {
+        if (w->IsKindOf(CLASSINFO(wxFrame)))
+        {
+            wxFrame* f = static_cast<wxFrame*>(w);
+            #if wxCHECK_VERSION(2,7,0)
+            can_do_transparent = f->CanSetTransparent();
+            #endif
+            break;
+        }
+        
+        w = w->GetParent();
+    }
+    
+    // if there is an existing hint window, delete it
+    if (m_hint_wnd)
+    {
+        m_hint_wnd->Destroy();
+        m_hint_wnd = NULL;
+    }
+
+    m_hint_fademax = 50;
+    m_hint_wnd = NULL;
+    
+    if ((m_flags & wxAUI_MGR_TRANSPARENT_HINT) && can_do_transparent)
+    { 
+        // Make a window to use for a transparent hint
+        #if defined(__WXMSW__) || defined(__WXGTK__)
+            m_hint_wnd = new wxFrame(m_frame, wxID_ANY, wxEmptyString,
+                                     wxDefaultPosition, wxSize(1,1),
+                                         wxFRAME_TOOL_WINDOW |
+                                         wxFRAME_FLOAT_ON_PARENT |
+                                         wxFRAME_NO_TASKBAR |
+                                         wxNO_BORDER);
+
+            m_hint_wnd->SetBackgroundColour(wxSystemSettings::GetColour(wxSYS_COLOUR_ACTIVECAPTION));
+        #elif defined(__WXMAC__)
+            // Using a miniframe with float and tool styles keeps the parent
+            // frame activated and highlighted as such...
+            m_hint_wnd = new wxMiniFrame(m_frame, wxID_ANY, wxEmptyString,
+                                         wxDefaultPosition, wxSize(1,1),
+                                         wxFRAME_FLOAT_ON_PARENT
+                                         | wxFRAME_TOOL_WINDOW );
+
+            // Can't set the bg colour of a Frame in wxMac
+            wxPanel* p = new wxPanel(m_hint_wnd);
+
+            // The default wxSYS_COLOUR_ACTIVECAPTION colour is a light silver
+            // color that is really hard to see, especially transparent.
+            // Until a better system color is decided upon we'll just use
+            // blue.
+            p->SetBackgroundColour(*wxBLUE);
+        #endif
+        
+    }
+     else
+    {
+        if ((m_flags & wxAUI_MGR_TRANSPARENT_HINT) != 0 ||
+            (m_flags & wxAUI_MGR_VENETIAN_BLINDS_HINT) != 0)
+        {
+            // system can't support transparent fade, or the venetian
+            // blinds effect was explicitly requested
+            m_hint_wnd = new wxPseudoTransparentFrame(m_frame,
+                                                      wxID_ANY,
+                                                      wxEmptyString,
+                                                      wxDefaultPosition,
+                                                      wxSize(1,1),
+                                                            wxFRAME_TOOL_WINDOW |
+                                                            wxFRAME_FLOAT_ON_PARENT |
+                                                            wxFRAME_NO_TASKBAR |
+                                                            wxNO_BORDER);
+            m_hint_fademax = 128;
+        }
+    }
+}
 
 
 // SetManagedWindow() is usually called once when the frame
 // manager class is being initialized.  "frame" specifies
 // the frame which should be managed by the frame mananger
-void wxFrameManager::SetManagedWindow(wxWindow* frame)
+void wxFrameManager::SetManagedWindow(wxWindow* wnd)
 {
-    wxASSERT_MSG(frame, wxT("specified frame must be non-NULL"));
+    wxASSERT_MSG(wnd, wxT("specified window must be non-NULL"));
 
-    m_frame = frame;
+    m_frame = wnd;
     m_frame->PushEventHandler(this);
 
 #if wxUSE_MDI
@@ -619,9 +719,9 @@ void wxFrameManager::SetManagedWindow(wxWindow* frame)
     // we need to add the MDI client window as the default
     // center pane
 
-    if (frame->IsKindOf(CLASSINFO(wxMDIParentFrame)))
+    if (m_frame->IsKindOf(CLASSINFO(wxMDIParentFrame)))
     {
-        wxMDIParentFrame* mdi_frame = (wxMDIParentFrame*)frame;
+        wxMDIParentFrame* mdi_frame = (wxMDIParentFrame*)m_frame;
         wxWindow* client_window = mdi_frame->GetClientWindow();
 
         wxASSERT_MSG(client_window, wxT("Client window is NULL!"));
@@ -632,57 +732,7 @@ void wxFrameManager::SetManagedWindow(wxWindow* frame)
     }
 #endif
 
-    // Make a window to use for a transparent hint
+    UpdateHintWindowConfig();
-#if defined(__WXMSW__) || defined(__WXGTK__)
-    m_hint_wnd = new wxFrame(m_frame, wxID_ANY, wxEmptyString, wxDefaultPosition, wxSize(1,1),
-                             wxFRAME_TOOL_WINDOW |
-                             wxFRAME_FLOAT_ON_PARENT |
-                             wxFRAME_NO_TASKBAR |
-                             wxNO_BORDER);
-
-    m_hint_wnd->SetBackgroundColour(wxSystemSettings::GetColour(wxSYS_COLOUR_ACTIVECAPTION));
-
-#elif defined(__WXMAC__)
-    // Using a miniframe with float and tool styles keeps the parent
-    // frame activated and highlighted as such...
-    m_hint_wnd = new wxMiniFrame(m_frame, wxID_ANY, wxEmptyString, wxDefaultPosition, wxSize(1,1),
-                                 wxFRAME_FLOAT_ON_PARENT
-                                 | wxFRAME_TOOL_WINDOW );
-
-    // Can't set the bg colour of a Frame in wxMac
-    wxPanel* p = new wxPanel(m_hint_wnd);
-
-    // The default wxSYS_COLOUR_ACTIVECAPTION colour is a light silver
-    // color that is really hard to see, especially transparent.
-    // Until a better system color is decided upon we'll just use
-    // blue.
-    p->SetBackgroundColour(*wxBLUE);
-#endif
-
-    m_hint_fademax=50;
-
-    if (m_hint_wnd
-        // CanSetTransparent is only present in the 2.7.0 ABI. To allow this file to be easily used
-        // in a backported environment, conditionally compile this in.
-#if wxCHECK_VERSION(2,7,0)
-       && !m_hint_wnd->CanSetTransparent()
-#endif
-        )
-    {
-
-        m_hint_wnd->Close();
-        m_hint_wnd->Destroy();
-        m_hint_wnd = NULL;
-
-        // If we can convert it to a PseudoTransparent window, do so
-        m_hint_wnd = new wxPseudoTransparentFrame (m_frame, wxID_ANY, wxEmptyString, wxDefaultPosition, wxSize(1,1),
-                                                wxFRAME_TOOL_WINDOW |
-                                                wxFRAME_FLOAT_ON_PARENT |
-                                                wxFRAME_NO_TASKBAR |
-                                                wxNO_BORDER);
-
-        m_hint_fademax = 128;
-    }
 }
 
 
@@ -871,7 +921,7 @@ bool wxFrameManager::InsertPane(wxWindow* window, const wxPaneInfo& pane_info,
     {
         return AddPane(window, pane_info);
     }
-    else
+     else
     {
         if (pane_info.IsFloating())
         {
@@ -2724,27 +2774,24 @@ void wxFrameManager::OnHintFadeTimer(wxTimerEvent& WXUNUSED(event))
 
 void wxFrameManager::ShowHint(const wxRect& rect)
 {
-    if ((m_flags & wxAUI_MGR_TRANSPARENT_HINT) != 0
+    if (m_hint_wnd)
-        && m_hint_wnd
-        // Finally, don't use a venetian blind effect if it's been specifically disabled
-        && !((m_hint_wnd->IsKindOf(CLASSINFO(wxPseudoTransparentFrame))) &&
-             (m_flags & wxAUI_MGR_DISABLE_VENETIAN_BLINDS))
-       )
     {
+        // if the hint rect is the same as last time, don't do anything
         if (m_last_hint == rect)
             return;
         m_last_hint = rect;
 
         m_hint_fadeamt = m_hint_fademax;
-        if ((m_flags & wxAUI_MGR_TRANSPARENT_HINT_FADE)
+        
+        if ((m_flags & wxAUI_MGR_HINT_FADE)
             && !((m_hint_wnd->IsKindOf(CLASSINFO(wxPseudoTransparentFrame))) &&
-                 (m_flags & wxAUI_MGR_DISABLE_VENETIAN_BLINDS_FADE))
+                 (m_flags & wxAUI_MGR_NO_VENETIAN_BLINDS_FADE))
             )
             m_hint_fadeamt = 0;
 
         m_hint_wnd->SetSize(rect);
 
-        if (! m_hint_wnd->IsShown())
+        if (!m_hint_wnd->IsShown())
             m_hint_wnd->Show();
 
         // if we are dragging a floating pane, set the focus
@@ -2756,7 +2803,7 @@ void wxFrameManager::ShowHint(const wxRect& rect)
         m_hint_wnd->SetTransparent(m_hint_fadeamt);
 #else
         if (m_hint_wnd->IsKindOf(CLASSINFO(wxPseudoTransparentFrame)))
-            ((wxPseudoTransparentFrame *)m_hint_wnd)->SetTransparent(m_hint_fadeamt);
+            ((wxPseudoTransparentFrame*)m_hint_wnd)->SetTransparent(m_hint_fadeamt);
 #endif
         m_hint_wnd->Raise();
 
@@ -2768,10 +2815,11 @@ void wxFrameManager::ShowHint(const wxRect& rect)
             m_hint_fadetimer.Start(5);
         }
     }
-
+     else  // Not using a transparent hint window...
-    else  // Not using a transparent hint window...
     {
-
+        if (!(m_flags & wxAUI_MGR_RECTANGLE_HINT))
+            return;
+            
         if (m_last_hint != rect)
         {
             // remove the last hint rectangle