ToolDock Class Reference

A dynamic panel where a ToolBar can be docked. More...

#include <ToolDock.h>

Inheritance diagram for ToolDock:

Collaboration diagram for ToolDock:

Classes
class	LayoutVisitor

Public Member Functions
	ToolDock (wxEvtHandler *manager, wxWindow *parent, int dockid)
	Methods for ToolDock. More...
	~ToolDock ()
bool	AcceptsFocus () const override
void	LoadConfig ()
void	LayoutToolBars ()
void	Expose (Identifier type, bool show)
int	GetOrder (ToolBar *bar)
void	Dock (ToolBar *bar, bool deflate, ToolBarConfiguration::Position ndx=ToolBarConfiguration::UnspecifiedPosition)
void	Undock (ToolBar *bar)
ToolBarConfiguration::Position	PositionBar (ToolBar *t, const wxPoint &pos, wxRect &rect)
ToolBarConfiguration &	GetConfiguration ()
void	WrapConfiguration (ToolBarConfiguration &backup)
void	RestoreConfiguration (ToolBarConfiguration &backup)
void	Updated ()
Public Member Functions inherited from wxPanelWrapper
	wxPanelWrapper ()
	wxPanelWrapper (wxWindow *parent, wxWindowID winid=wxID_ANY, const wxPoint &pos=wxDefaultPosition, const wxSize &size=wxDefaultSize, long style=wxTAB_TRAVERSAL|wxNO_BORDER, const TranslatableString &name=XO("Panel"))
bool	Create (wxWindow *parent, wxWindowID winid=wxID_ANY, const wxPoint &pos=wxDefaultPosition, const wxSize &size=wxDefaultSize, long style=wxTAB_TRAVERSAL|wxNO_BORDER, const TranslatableString &name=XO("Panel"))
void	SetLabel (const TranslatableString &label)
void	SetName (const TranslatableString &name)
void	SetToolTip (const TranslatableString &toolTip)
void	SetName ()
Public Member Functions inherited from wxTabTraversalWrapper< wxPanel >
	wxTabTraversalWrapper (Args &&... args)
	wxTabTraversalWrapper (const wxTabTraversalWrapper &)=delete
	wxTabTraversalWrapper (wxTabTraversalWrapper &&)=delete
wxTabTraversalWrapper &	operator= (const wxTabTraversalWrapper &)=delete
wxTabTraversalWrapper &	operator= (wxTabTraversalWrapper &&)=delete

Protected Member Functions
void	OnErase (wxEraseEvent &event)
void	OnSize (wxSizeEvent &event)
void	OnPaint (wxPaintEvent &event)
void	OnGrabber (GrabberEvent &event)
void	OnMouseEvents (wxMouseEvent &event)

Private Member Functions
void	VisitLayout (LayoutVisitor &visitor, ToolBarConfiguration *pWrappedConfiguration=nullptr)

Private Attributes
wxEvtHandler *	mManager
ToolBarConfiguration	mConfiguration
ToolBarConfiguration	mWrappedConfiguration
std::map< Identifier, ToolBar * >	mBars

Detailed Description

A dynamic panel where a ToolBar can be docked.

Definition at line 291 of file ToolDock.h.

Constructor & Destructor Documentation

ToolDock()

ToolDock::ToolDock	(	wxEvtHandler *	manager,
		wxWindow *	parent,
		int	dockid
	)

Methods for ToolDock.

Definition at line 402 of file ToolDock.cpp.

                                                                       :
   wxPanelWrapper( parent, dockid, wxDefaultPosition, parent->GetSize() )
{
   SetLabel( XO( "ToolDock" ) );
   SetName( XO( "ToolDock" ) );
 
   // Init
   mManager = manager;
   SetBackgroundColour(theTheme.Colour( clrMedium ));
   SetLayoutDirection(wxLayout_LeftToRight);
   // Use for testing gaps
   // SetOwnBackgroundColour( wxColour( 255, 0, 0 ) );
}

References ThemeBase::Colour(), manager, theTheme, and XO().

Here is the call graph for this function:

~ToolDock()

ToolDock::~ToolDock

(

)

Definition at line 419 of file ToolDock.cpp.

{
}

Member Function Documentation

AcceptsFocus()

bool ToolDock::AcceptsFocus ( ) const

inlineoverride

Definition at line 298 of file ToolDock.h.

{ return false; };

Dock()

void ToolDock::Dock	(	ToolBar *	bar,
		bool	deflate,
		ToolBarConfiguration::Position	ndx = ToolBarConfiguration::UnspecifiedPosition
	)

Definition at line 438 of file ToolDock.cpp.

{
#ifndef __WXMAC__
   // Apply the deflate fix only on Mac, else you introduce the opposite bug on others
   deflate = false;
#endif
 
   // Adopt the toolbar into our family
   bar->Reparent( this );
   mBars[ bar->GetSection() ] = bar;
 
   // Reset size
   bar->SetSize(
      // Undo the expansion that was applied when un-docking
      bar->GetSize().x - (deflate ? 2 * ToolBarFloatMargin : 0),
      // Don't need to adjust y the same way.
      bar->GetDockedSize().y
   );
 
   // Park the NEW bar in the correct berth
   if (!mConfiguration.Contains(bar) && bar->IsVisible())
      mConfiguration.Insert( bar, position );
 
   // Inform toolbar of change
   bar->SetDocked( this, false );
}

References ToolBarConfiguration::Contains(), ToolBar::GetDockedSize(), ToolBar::GetSection(), ToolBarConfiguration::Insert(), ToolBar::IsVisible(), mBars, mConfiguration, ToolBar::SetDocked(), and ToolBarFloatMargin.

Referenced by ToolManager::HandleEscapeKey(), LoadConfig(), ToolManager::OnMouse(), ToolManager::ReadConfig(), and ToolManager::Reset().

Here is the call graph for this function:

Here is the caller graph for this function:

Expose()

void ToolDock::Expose	(	Identifier	type,
		bool	show
	)

Definition at line 858 of file ToolDock.cpp.

{
   ToolBar *t = mBars[ type ];
 
   // Maintain the docked array
   const auto shown = mConfiguration.Shows( t );
   if( show && !shown )
      mConfiguration.Show( t );
   else if( !show && shown )
      mConfiguration.Hide( t );
 
   // Make it (dis)appear
   t->Expose( show );
}

References ToolBar::Expose(), ToolBarConfiguration::Hide(), mBars, mConfiguration, ToolBarConfiguration::Show(), and ToolBarConfiguration::Shows().

Referenced by ToolManager::Expose(), and LoadConfig().

Here is the call graph for this function:

Here is the caller graph for this function:

GetConfiguration()

ToolBarConfiguration & ToolDock::GetConfiguration ( )

inline

Definition at line 311 of file ToolDock.h.

   { return mConfiguration; }

References mConfiguration.

Referenced by ToolManager::Destroy(), LayoutToolBars(), LoadConfig(), ToolManager::OnGrabber(), ToolManager::OnMouse(), OnPaint(), ToolManager::ReadConfig(), VisitLayout(), and ToolManager::WriteConfig().

Here is the caller graph for this function:

GetOrder()

int ToolDock::GetOrder

(

ToolBar *

bar

)

LayoutToolBars()

void ToolDock::LayoutToolBars

(

)

Definition at line 687 of file ToolDock.cpp.

{
   struct SizeSetter final : public LayoutVisitor
   {
      SizeSetter (ToolDock *d) : dock{ d } {}
 
      void Visit
         (ToolBar *bar, wxPoint point)
         override
      {
         // Place the toolbar
         if(bar)
            bar->SetPosition( point );
      }
 
      bool ShouldVisitSpaces() override
      {
         return false;
      }
 
      virtual void FinalRect
         (const wxRect &rect, ToolBarConfiguration::Position)
         override
      {
         // Set the final size of the dock window
         dock->SetMinSize( rect.GetSize() );
      }
 
      ToolDock *dock;
   } sizeSetter {
      this
   };
   VisitLayout(sizeSetter, &mWrappedConfiguration);
 
   // Set tab order and layout internal controls.
   {
      ToolBar *lt{};
      for ( const auto &place : GetConfiguration() ) {
         auto ct = place.pTree->pBar;
         if( lt ){
            ct->MoveAfterInTabOrder( lt );
         }
         lt = ct;
         // Bug 1371.
         // After a dock size change, the toolbars may need relaying inside.
         lt->Layout();
      }
   }
 
   // Clean things up
   Refresh( false );
}

References GetConfiguration(), mWrappedConfiguration, MenuRegistry::Visit(), and VisitLayout().

Referenced by ToolManager::LayoutToolBars().

Here is the call graph for this function:

Here is the caller graph for this function:

LoadConfig()

void ToolDock::LoadConfig

(

)

Definition at line 466 of file ToolDock.cpp.

{
   // Add all ordered toolbars
   for(const auto &place : GetConfiguration()) {
      auto bar = place.pTree->pBar;
      this->Dock(bar, false);
      // Show it -- hidden bars are not (yet) ever saved as part of a
      // configuration
      Expose( bar->GetSection(), true );
   }
   Updated();
}

References Dock(), Expose(), GetConfiguration(), and Updated().

Referenced by ToolManager::ReadConfig().

Here is the call graph for this function:

Here is the caller graph for this function:

OnErase()

void ToolDock::OnErase ( wxEraseEvent &  event )

protected

Definition at line 907 of file ToolDock.cpp.

{
   // Ignore it to prevent flashing
}

OnGrabber()

void ToolDock::OnGrabber ( GrabberEvent &  event )

protected

Definition at line 887 of file ToolDock.cpp.

{
   // auto pos = event.GetPosition();
   if (!event.IsEscaping()) {
      // Pass it on to the manager since it isn't in the handling hierarchy
      mManager->ProcessEvent( event );
   }
}

References GrabberEvent::IsEscaping(), and mManager.

Here is the call graph for this function:

OnMouseEvents()

void ToolDock::OnMouseEvents ( wxMouseEvent &  event )

protected

Definition at line 968 of file ToolDock.cpp.

{
   // Do this hack so scrubber can detect mouse drags anywhere
   event.ResumePropagation(wxEVENT_PROPAGATE_MAX);
   event.Skip();
}

OnPaint()

void ToolDock::OnPaint ( wxPaintEvent &  event )

protected

Definition at line 915 of file ToolDock.cpp.

{
   // Don't use a wxBufferedPaintDC() here.  It produces a bogus
   // background on Windows and GTK.
   wxPaintDC dc( this );
 
   // Start with a clean background
   //
   // Under GTK, we don't set the toolbar background to the background
   // colour in the system theme.  Instead we use our own colour.
 
   dc.SetBackground( wxBrush( theTheme.Colour( clrMedium )));
   dc.Clear();
 
   // Set the gap color
   AColor::Dark( &dc, false );
 
   // Draw the initial horizontal and vertical gaps
   wxSize sz = GetClientSize();
 
   AColor::Line(dc, 0, 0, sz.GetWidth(), 0 );
   AColor::Line(dc, 0, 0, 0, sz.GetHeight() );
 
   // Draw the gap between each bar
   for (const auto &place : GetConfiguration())
   {
      auto toolbar = place.pTree->pBar;
      if (!toolbar)
         continue;
 
      wxRect r = toolbar->GetRect();
 
      // Draw a horizontal line under the bar extending to the right edge of
      // the dock
      AColor::Line( dc,
                   r.GetLeft(),
                   r.GetBottom() + 1,
                   sz.GetWidth(),
                   r.GetBottom() + 1 );
 
      // For all bars but the last...
      // ...and for bars that aren't the last in a row, draw a
      // vertical gap line
      if (!mConfiguration.IsRightmost(toolbar)) {
         AColor::Line(dc,
            r.GetRight() + 1,
            r.GetTop(),
            r.GetRight() + 1,
            r.GetBottom() + 1 );
      }
   }
}

References ThemeBase::Colour(), AColor::Dark(), GetConfiguration(), ToolBarConfiguration::IsRightmost(), AColor::Line(), mConfiguration, and theTheme.

Here is the call graph for this function:

OnSize()

void ToolDock::OnSize ( wxSizeEvent &  event )

protected

Definition at line 899 of file ToolDock.cpp.

{
//   event.Skip();
}

PositionBar()

ToolBarConfiguration::Position ToolDock::PositionBar	(	ToolBar *	t,
		const wxPoint &	pos,
		wxRect &	rect
	)

Definition at line 744 of file ToolDock.cpp.

{
   // Set width and size, but we must still find x and y.
   rect = t->GetRect();
 
   using Position = ToolBarConfiguration::Position;
   Position result { ToolBarConfiguration::UnspecifiedPosition };
   struct Inserter : public LayoutVisitor
   {
      struct Stop {};
 
      Inserter(Position &p, wxRect &r, const wxPoint &pt, ToolBar *t)
         : result(p), rect(r), point(pt), tb(t)
      {}
 
      void ModifySize
         (ToolBar *ct,
          const wxRect &rectIn,
          ToolBarConfiguration::Position prevPosition,
          ToolBarConfiguration::Position position,
          wxSize &sz)
         override
      {
         // Maybe insert the NEW bar if it hasn't already been done
         // and is in the right place.
 
         // Does the location fall within this bar?
         if (rectIn.Contains(point))
         {
            sz = tb->GetDockedSize();
            // Choose a position always, if there is a bar to displace.
            // Else, only if the fit is possible.
            if (ct || (sz.x <= rectIn.width && sz.y <= rectIn.height)) {
               // May choose current or previous.
               if (ct &&
                   (sz.y < rectIn.height ||
                    point.y < (rectIn.GetTop() + rectIn.GetBottom()) / 2))
                  // "Wedge" the bar into a crack alone, not adopting others,
                  // if either a short bar displaces a tall one, or else
                  // the displacing bar is at least at tall, but the pointer is
                  // in the upper half of the box.
                  usedPrev = true, result = prevPosition, result.adopt = false;
               else
                  result = position;
            }
            // Now wait until the other callback below to discover x and y
         }
      }
 
      void Visit
         (ToolBar *, wxPoint pointIn)
         override
      {
         if (result != ToolBarConfiguration::UnspecifiedPosition) {
            // If we've placed it, we're done.
            rect.x = pointIn.x;
            rect.y = pointIn.y;
            if (usedPrev)
               rect.y -= tb->GetDockedSize().GetHeight() / 2;
 
            throw Stop {};
         }
      }
 
      bool ShouldVisitSpaces() override
      {
         return true;
      }
 
      void FinalRect
         (const wxRect &finalRect, ToolBarConfiguration::Position finalPosition)
         override
      {
         if (result == ToolBarConfiguration::UnspecifiedPosition) {
            // Default of all other placements.
            result = finalPosition;
            wxPoint point1 { finalRect.GetLeft(), finalRect.GetBottom() };
            rect.SetPosition(point1);
         }
      }
 
 
      Position &result;
      wxRect &rect;
      const wxPoint point;
      ToolBar *const tb;
      bool usedPrev { false };
   } inserter {
      result, rect, pos, t
   };
 
   try { this->VisitLayout(inserter); } catch (const Inserter::Stop&) {}
 
   // rect is decided
   return result;
}

References ToolBarConfiguration::Position::adopt, ToolBarConfiguration::UnspecifiedPosition, MenuRegistry::Visit(), and VisitLayout().

Referenced by ToolManager::OnMouse().

Here is the call graph for this function:

Here is the caller graph for this function:

RestoreConfiguration()

void ToolDock::RestoreConfiguration

(

ToolBarConfiguration &

backup

)

Definition at line 848 of file ToolDock.cpp.

{
   mWrappedConfiguration.Clear();
   mWrappedConfiguration.Swap(mConfiguration);
   mConfiguration.Swap(backup);
}

References ToolBarConfiguration::Clear(), mConfiguration, mWrappedConfiguration, and ToolBarConfiguration::Swap().

Referenced by ToolManager::HandleEscapeKey(), and ToolManager::OnMouse().

Here is the call graph for this function:

Here is the caller graph for this function:

Undock()

void ToolDock::Undock

(

ToolBar *

bar

)

Definition at line 426 of file ToolDock.cpp.

{
   if( mConfiguration.Contains( bar ) )
   {
      mConfiguration.Remove( bar );
   }
   mBars[ bar->GetSection() ] = nullptr;
}

References ToolBarConfiguration::Contains(), ToolBar::GetSection(), mBars, mConfiguration, and ToolBarConfiguration::Remove().

Referenced by ToolManager::Reset().

Here is the call graph for this function:

Here is the caller graph for this function:

Updated()

void ToolDock::Updated

(

)

Definition at line 877 of file ToolDock.cpp.

{
   // Queue an update event
   wxCommandEvent e( EVT_TOOLBAR_UPDATED, GetId() );
   GetParent()->GetEventHandler()->AddPendingEvent( e );
}

Referenced by LoadConfig(), and ToolBar::Updated().

Here is the caller graph for this function:

VisitLayout()

void ToolDock::VisitLayout ( LayoutVisitor &  visitor, ToolBarConfiguration *  pWrappedConfiguration = nullptr  )

private

Definition at line 505 of file ToolDock.cpp.

{
   if (pWrappedConfiguration)
      pWrappedConfiguration->Clear();
 
   // Get size of our parent since we haven't been sized yet
   int width, height;
   GetParent()->GetClientSize( &width, &height );
   width -= toolbarGap;
   height -= toolbarGap;
 
   // Rectangle of space to allocate
   wxRect main{ toolbarGap, toolbarGap,
      // Allow limited width, but arbitrary height, for the root rectangle
      width, std::numeric_limits<int>::max() };
 
   // For recording the nested subdivisions of the rectangle
   struct Item {
      Identifier section;
      Item *parent{};
      ToolBar *lastSib {};
      ToolBar *lastWrappedChild {};
      wxRect rect;
   };
   std::vector<Item> items(mBars.size());
   Item *layout = items.data();
   Item *next = layout;
 
   ToolBar *lastRoot {};
   ToolBar *lastWrappedRoot {};
 
   // Process all docked and visible toolbars
   for ( const auto &place : this->GetConfiguration() )
   {
      // Cache toolbar pointer
      const auto ct = place.pTree->pBar;
 
      // set up the chain of ancestors.
      const auto parent = place.position.rightOf;
      const auto section = ct->GetSection();
      auto &newItem = *next++;
      if (parent)
         newItem.parent = std::find_if(layout, next - 1, [&](Item &item){
            return parent->GetSection() == item.section;
         });
      // Mark the slots that really were visited, for final pass through
      // the spaces.
      newItem.section = section;
 
      ToolBar *prevSib;
      if (!parent) {
         prevSib = lastRoot;
         lastRoot = ct;
      }
      else {
         auto &sib = newItem.parent->lastSib;
         prevSib = sib;
         sib = ct;
      }
      auto prevPosition = ToolBarConfiguration::Position{ parent, prevSib };
 
      // Determine the size of the toolbar to fit, with advice from
      // the visitor object
      wxSize sz = ct->GetSize();
      {
         wxRect temp;
         temp.SetPosition(ct->GetParent()->ClientToScreen(ct->GetPosition()));
         temp.SetSize(sz);
         visitor.ModifySize(ct, temp, prevPosition, place.position, sz);
      }
 
      // Inflate the size to leave margins
      int tw = sz.GetWidth() + toolbarGap;
      int th = sz.GetHeight() + toolbarGap;
 
      // Choose the rectangle to subdivide
      // Find a box that we fit in by going up the tree as needed --
      // thus when parent space is exhausted, fall back on ancestors --
      // so if the tree has too much depth for the width of the
      // window, the toolbars may "wrap."
      // Can always fall back to the main rectangle even if the bar is too
      // wide.
      auto pItem = newItem.parent;
      auto pRect = pItem ? &pItem->rect : &main;
      while (pRect != &main)
      {
         // Get out if it will fit
         bool bTooWide = tw > pRect->GetWidth();
         // We'd like to be able to add a tall toolbar in at the start of a row,
         // even if there isn't enough height for it.
         // If so, we'd have to at least change how we calculate 'bTooHigh'.
         bool bTooHigh = th > pRect->GetHeight();
         //bTooHigh &= stack[stkcnt].GetWidth() < (width - toolbarGap);
         //bTooHigh = false;
 
         if (!bTooWide && !bTooHigh)
            break;
 
         auto parentItem = pItem->parent;
         if (!parentItem) {
            pItem = nullptr;
            pRect = &main;
         }
         else {
            pItem = parentItem;
            pRect = &pItem->rect;
         }
      }
 
      // Record where the toolbar wrapped
      ToolBar *& sib = pItem ? pItem->lastWrappedChild : lastWrappedRoot;
      ToolBarConfiguration::Position newPosition {
         pItem ? this->mBars[ pItem->section ] : nullptr,
         sib
      };
      sib = ct;
      if (pWrappedConfiguration)
         pWrappedConfiguration->Insert(ct, newPosition);
 
      // Place the toolbar at the upper left part of the rectangle.
      const auto cpos = pRect->GetPosition();
      visitor.Visit(ct, cpos);
 
      // Allocate an upper portion of the rectangle to this bar.
      pRect->y += th;
      pRect->height -= th;
 
      // A right portion of that upper portion remains available for
      // descendant bars and is remembered in the layout array.
      int x = cpos.x + tw;
      newItem.rect = wxRect{ x, cpos.y, width - x, th };
   }
 
   if (visitor.ShouldVisitSpaces()) {
      // Visit the fringe where NEW leaves of the tree could go
 
      // Sort top to bottom for definiteness, though perhaps not really needed
      // Do not use the parent pointers after this sort!
      std::sort(layout, next,
         [](const Item &lhs, const Item &rhs){
            return lhs.rect.y < rhs.rect.y;
         }
      );
      for (auto iter = layout; iter != next; ++iter) {
         const auto &item = *iter;
         const auto &rect = item.rect;
 
         auto globalRect = rect;
         globalRect.SetPosition( this->ClientToScreen(rect.GetPosition()) );
 
         // Let the visitor determine size
         wxSize sz {};
         ToolBarConfiguration::Position
            position { this->mBars[ item.section ], item.lastWrappedChild },
            prevPosition {};
         visitor.ModifySize(nullptr, globalRect, prevPosition, position, sz);
         int tw = sz.GetWidth() + toolbarGap;
         int th = sz.GetHeight() + toolbarGap;
 
         // Test fit
         bool bTooWide = tw > rect.GetWidth();
         bool bTooHigh = th > rect.GetHeight();
         if (!bTooWide && !bTooHigh) {
            // Call visitor again to confirm the placement
            const auto cpos = rect.GetPosition();
            visitor.Visit(nullptr, cpos);
         }
      }
   }
 
   // Report the final bounding box of all the bars, and a position where
   // you can insert a NEW bar at bottom left.
   ToolBarConfiguration::Position finalPosition { nullptr, lastRoot };
   visitor.FinalRect(
      wxRect { toolbarGap, toolbarGap, main.width, main.y }, finalPosition
   );
}

References ToolBarConfiguration::Clear(), ToolDock::LayoutVisitor::FinalRect(), GetConfiguration(), ToolBar::GetSection(), ToolBarConfiguration::Insert(), main(), mBars, ToolDock::LayoutVisitor::ModifySize(), ToolDock::LayoutVisitor::ShouldVisitSpaces(), toolbarGap, and ToolDock::LayoutVisitor::Visit().

Referenced by LayoutToolBars(), and PositionBar().

Here is the call graph for this function:

Here is the caller graph for this function:

WrapConfiguration()

void ToolDock::WrapConfiguration

(

ToolBarConfiguration &

backup

)

Definition at line 841 of file ToolDock.cpp.

{
   backup.Clear();
   backup.Swap(mConfiguration);
   mConfiguration.Swap(mWrappedConfiguration);
}

References ToolBarConfiguration::Clear(), mConfiguration, mWrappedConfiguration, and ToolBarConfiguration::Swap().

Referenced by ToolManager::OnGrabber().

Here is the call graph for this function:

Here is the caller graph for this function:

Member Data Documentation

mBars

std::map<Identifier, ToolBar*> ToolDock::mBars

private

Definition at line 345 of file ToolDock.h.

Referenced by Dock(), Expose(), Undock(), and VisitLayout().

mConfiguration

ToolBarConfiguration ToolDock::mConfiguration

private

Definition at line 340 of file ToolDock.h.

Referenced by Dock(), Expose(), GetConfiguration(), OnPaint(), RestoreConfiguration(), Undock(), and WrapConfiguration().

mManager

wxEvtHandler* ToolDock::mManager

private

Definition at line 337 of file ToolDock.h.

Referenced by OnGrabber().

mWrappedConfiguration

ToolBarConfiguration ToolDock::mWrappedConfiguration

private

Definition at line 343 of file ToolDock.h.

Referenced by LayoutToolBars(), RestoreConfiguration(), and WrapConfiguration().

---

The documentation for this class was generated from the following files:

• ToolDock.h
• ToolDock.cpp