An alternative to ToolBarFrame which can contain an ExpandingToolBar. ToolBarArea is used for a 'docked' ToolBar, ToolBarFrame for a floating one. More...

#include <ExpandingToolBar.h>

Inheritance diagram for ToolBarArea:

[legend]

Collaboration diagram for ToolBarArea:

[legend]

Public Member Functions
	ToolBarArea (wxWindow *parent, wxWindowID id, const wxPoint &pos=wxDefaultPosition, const wxSize &size=wxDefaultSize)

	~ToolBarArea ()

bool	Layout () override

void	Fit () override

void	OnSize (wxSizeEvent &evt)

void	OnMouse (wxMouseEvent &evt)

void	CollapseAll (bool now=false)

void	AddChild (ExpandingToolBar *child)

void	RemoveChild (ExpandingToolBar *child)

std::unique_ptr< ToolBarArrangement >	SaveArrangement ()

void	RestoreArrangement (std::unique_ptr< ToolBarArrangement > &&arrangement)

std::vector< wxRect >	GetDropTargets ()

void	MoveChild (ExpandingToolBar *child, wxRect dropTarget)

void	SetCapturedChild (ExpandingToolBar *child)

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	ContractRow (int rowIndex)

bool	ExpandRow (int rowIndex)

void	LayoutOne (int childIndex)

void	AdjustLayout ()

void	Fit (bool horizontal, bool vertical)

Protected Attributes
std::vector< ExpandingToolBar * >	mChildArray

std::vector< int >	mRowArray

wxSize	mLastLayoutSize

bool	mInOnSize

ExpandingToolBar *	mCapturedChild

wxSize	mMinSize

wxSize	mMaxSize

wxSize	mActualSize

std::vector< wxRect >	mDropTargets

std::vector< int >	mDropTargetIndices

std::vector< int >	mDropTargetRows

Detailed Description

An alternative to ToolBarFrame which can contain an ExpandingToolBar. ToolBarArea is used for a 'docked' ToolBar, ToolBarFrame for a floating one.

Definition at line 196 of file ExpandingToolBar.h.

Constructor & Destructor Documentation

◆ ToolBarArea()

ToolBarArea::ToolBarArea	(	wxWindow *	parent,
		wxWindowID	id,
		const wxPoint &	pos = `wxDefaultPosition`,
		const wxSize &	size = `wxDefaultSize`
	)

Definition at line 843 of file ExpandingToolBar.cpp.

                                            :
   wxPanelWrapper(parent, id, pos, size),
   mInOnSize(false),
   mCapturedChild(NULL)
{
 
}

◆ ~ToolBarArea()

ToolBarArea::~ToolBarArea ( )

Definition at line 854 of file ExpandingToolBar.cpp.

855{

856}

Member Function Documentation

◆ AddChild()

void ToolBarArea::AddChild ( ExpandingToolBar * child )

Definition at line 1154 of file ExpandingToolBar.cpp.

{
   mChildArray.push_back(child);
   mRowArray.push_back(-1); // unknown row
   LayoutOne(mChildArray.size() - 1);
   Fit(false, true);
}

References Fit(), LayoutOne(), mChildArray, and mRowArray.

Referenced by ExpandingToolBar::OnSize().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ AdjustLayout()

void ToolBarArea::AdjustLayout ( )

protected

Definition at line 1030 of file ExpandingToolBar.cpp.

{
   // Try to modify the layout as little as possible - but if that's
   // impossible, redo the layout as necessary.
 
   int row = -1;
   int i, j;
 
   for(i = 0; i < (int)mChildArray.size(); i++) {
      if (mRowArray[i] > row) {
         row = mRowArray[i];
         bool success = ExpandRow(row);
         if (!success) {
            // Re-layout all toolbars from this row on
            for(j = i; j < (int)mChildArray.size(); j++)
               LayoutOne(j);
            return;
         }
      }
   }
}

References ExpandRow(), LayoutOne(), mChildArray, and mRowArray.

Referenced by OnSize().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ CollapseAll()

void ToolBarArea::CollapseAll ( bool now = false )

Definition at line 1146 of file ExpandingToolBar.cpp.

{
   int i;
 
   for(i = 0; i < (int)mChildArray.size(); i++)
      mChildArray[i]->Collapse(now);
}

References mChildArray.

Referenced by ExpandingToolBar::FinishMoving(), and ExpandingToolBar::StartMoving().

Here is the caller graph for this function:

◆ ContractRow()

void ToolBarArea::ContractRow ( int rowIndex )

protected

Definition at line 858 of file ExpandingToolBar.cpp.

{
   // Contract all of the toolbars in a given row to their
   // minimum size.  This is an intermediate step in layout.
 
   int i;
   int x = 0;
 
   for(i = 0; i < (int)mChildArray.size(); i++)
      if (mRowArray[i] == rowIndex) {
         wxPoint childPos = mChildArray[i]->GetPosition();
         wxSize childMin = mChildArray[i]->GetMinSize();
 
         mChildArray[i]->SetSize(x, childPos.y,
                                 childMin.x, childMin.y);
         x += childMin.x;
      }
}

References mChildArray, and mRowArray.

Referenced by LayoutOne(), and MoveChild().

Here is the caller graph for this function:

◆ ExpandRow()

bool ToolBarArea::ExpandRow ( int rowIndex )

protected

Definition at line 877 of file ExpandingToolBar.cpp.

{
   // Expand all of the toolbars in a given row so that the
   // whole width is filled, if possible.  This is the last
   // step after laying out as many toolbars as possible in
   // that row.  Returns false if it's not possible to fit
   // all of these toolbars in one row anymore.
 
   wxSize area = GetClientSize();
   int i, j, x;
   int minWidth = 0;
   int leftoverSpace = 0;
   int expandableCount = 0;
   int toolbarCount = 0;
 
   for(i = 0; i < (int)mChildArray.size(); i++)
      if (mRowArray[i] == rowIndex) {
         ExpandingToolBar *child = mChildArray[i];
         wxSize childMin = child->GetMinSize();
         wxSize childMax = child->GetMaxSize();
 
         minWidth += childMin.x;
 
         toolbarCount++;
         if (childMax.x > childMin.x)
            expandableCount++;
      }
 
   leftoverSpace = area.x - minWidth;
 
   if (leftoverSpace <= 0) {
      if (toolbarCount > 1)
         return false; // not possible to fit all in one row
      else
         return true; // there's only one, so it doesn't matter
   }
 
   j = 0;
   x = 0;
   for(i = 0; i < (int)mChildArray.size(); i++)
      if (mRowArray[i] == rowIndex) {
         ExpandingToolBar *child = mChildArray[i];
         wxPoint childPos = child->GetPosition();
         wxSize childMin = child->GetMinSize();
         wxSize childMax = child->GetMaxSize();
 
         int width = childMin.x;
 
         if (childMax.x > childMin.x)
            width +=
               (leftoverSpace * (j+1) / expandableCount) -
               (leftoverSpace * (j) / expandableCount);
 
         mChildArray[i]->SetSize(x, childPos.y,
                                 width, childMin.y);
         x += width;
         j++;
      }
 
   return true; // success
}

References mChildArray, and mRowArray.

Referenced by AdjustLayout(), and LayoutOne().

Here is the caller graph for this function:

◆ Fit() [1/2]

void ToolBarArea::Fit ( )

override

Definition at line 1052 of file ExpandingToolBar.cpp.

{
   Fit(true, true);
}

References Fit().

Referenced by AddChild(), Fit(), MoveChild(), OnSize(), RemoveChild(), and RestoreArrangement().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Fit() [2/2]

void ToolBarArea::Fit	(	bool	horizontal,
		bool	vertical
	)

protected

Definition at line 1057 of file ExpandingToolBar.cpp.

{
   wxSize clientSize = GetClientSize();
   wxSize minSize;
   wxSize maxSize;
   wxSize actualSize;
   int i;
 
   minSize.x = 0;
   minSize.y = 0;
   maxSize.x = 9999;
   maxSize.y = 0;
   for(i = 0; i < (int)mChildArray.size(); i++) {
      wxPoint childPos = mChildArray[i]->GetPosition();
      wxSize childSize = mChildArray[i]->GetSize();
 
      if (childPos.x + childSize.x > actualSize.x) {
         actualSize.x = childPos.x + childSize.x;
      }
 
      if (childSize.x > minSize.x) {
         minSize.x = childSize.x;
      }
 
      if (childPos.y + childSize.y > maxSize.y) {
         maxSize.y = childPos.y + childSize.y;
         minSize.y = maxSize.y;
         actualSize.y = maxSize.y;
      }
   }
 
   if (!horizontal && actualSize.x < clientSize.x)
      actualSize.x = clientSize.x;
   if (!vertical && actualSize.y < clientSize.y)
      actualSize.y = clientSize.y;
 
   if (minSize != mMinSize ||
       maxSize != mMaxSize) {
      mMinSize = minSize;
      mMaxSize = maxSize;
      SetMinSize(mMinSize);
      SetMaxSize(mMaxSize);
   }
   if (actualSize != mActualSize) {
      mActualSize = actualSize;
      SetSize(mActualSize);
   }
}

References mActualSize, mChildArray, mMaxSize, and mMinSize.

◆ GetDropTargets()

std::vector< wxRect > ToolBarArea::GetDropTargets ( )

Definition at line 1215 of file ExpandingToolBar.cpp.

{
   mDropTargets.clear();
   mDropTargetIndices.clear();
   mDropTargetRows.clear();
 
   int numChildren = (int)mChildArray.size();
   int i;
   int row = -1;
 
   if (numChildren == 0)
      return mDropTargets;
 
   for(i=0; i<numChildren; i++) {
      int childRow = mRowArray[i];
      wxRect childRect = mChildArray[i]->GetRect();
 
      if (childRow != row) {
         // Add a target before this child (at beginning of row only)
         row = childRow;
         mDropTargetIndices.push_back(i);
         mDropTargetRows.push_back(row);
         mDropTargets.push_back(wxRect(childRect.x, childRect.y,
                                 0, childRect.height));
      }
 
      // Add a target after this child (always)
      mDropTargetIndices.push_back(i+1);
      mDropTargetRows.push_back(row);
      mDropTargets.push_back(wxRect(childRect.x+childRect.width, childRect.y,
                              0, childRect.height));
   }
 
   return mDropTargets;
}

References mChildArray, mDropTargetIndices, mDropTargetRows, mDropTargets, and mRowArray.

Referenced by ExpandingToolBar::StartMoving().

Here is the caller graph for this function:

◆ Layout()

bool ToolBarArea::Layout ( )

override

Definition at line 1012 of file ExpandingToolBar.cpp.

{
   // Redo the layout from scratch, preserving only the order of
   // the children
 
   int i;
 
   for(i = 0; i < (int)mChildArray.size(); i++)
      mRowArray[i] = -1;
 
   for(i = 0; i < (int)mChildArray.size(); i++)
      LayoutOne(i);
 
   Refresh(true);
 
   return true;
}

References LayoutOne(), mChildArray, and mRowArray.

Referenced by OnSize().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ LayoutOne()

void ToolBarArea::LayoutOne ( int childIndex )

protected

Definition at line 939 of file ExpandingToolBar.cpp.

{
   wxSize area = GetClientSize();
   ExpandingToolBar *child = mChildArray[childIndex];
   wxSize childMin = child->GetMinSize();
 
   if (childIndex == 0) {
      mRowArray[childIndex] = 0;
      mChildArray[childIndex]->SetSize(0, 0, childMin.x, childMin.y);
      ExpandRow(0);
 
      #if 0
      wxPoint p = mChildArray[childIndex]->GetPosition();
      wxSize s = mChildArray[childIndex]->GetSize();
 
      wxPrintf("ToolBar %d moved to row %d at (%d, %d), size (%d x %d)\n",
             childIndex, mRowArray[childIndex],
             p.x, p.y, s.x, s.y);
      #endif
 
      mLastLayoutSize = area;
 
      return;
   }
 
   int prevRow = mRowArray[childIndex-1];
   ContractRow(prevRow);
   wxPoint prevPos = mChildArray[childIndex-1]->GetPosition();
   wxSize prevSize = mChildArray[childIndex-1]->GetSize();
 
   int prevX = prevPos.x + prevSize.x;
   int availableWidth = area.x - prevX;
 
   if (childMin.x <= availableWidth) {
      // It fits into the same row
      mRowArray[childIndex] = prevRow;
      mChildArray[childIndex]->SetSize(prevX, prevPos.y,
                                       childMin.x, childMin.y);
      ExpandRow(prevRow);
   }
   else {
      // Go to the next row
      ExpandRow(prevRow);
      mRowArray[childIndex] = prevRow + 1;
 
      int i;
      int maxRowHeight = 0;
      for(i=0; i<childIndex; i++)
         if (mRowArray[i] == prevRow &&
             mChildArray[i]->GetSize().y > maxRowHeight)
            maxRowHeight = mChildArray[i]->GetSize().y;
 
      mChildArray[childIndex]->SetSize(0, prevPos.y + maxRowHeight,
                                       childMin.x, childMin.y);
      ExpandRow(prevRow+1);
   }
 
   // Save the size of the window the last time we moved one of the
   // toolbars around.  If the user does a minor resize, we try to
   // preserve the layout.  If the user does a major resize, we're
   // allowed to redo the layout.
   mLastLayoutSize = area;
 
   #if 0
   wxPoint p = mChildArray[childIndex]->GetPosition();
   wxSize s = mChildArray[childIndex]->GetSize();
 
   wxPrintf("ToolBar %d moved to row %d at (%d, %d), size (%d x %d)\n",
          childIndex, mRowArray[childIndex],
          p.x, p.y, s.x, s.y);
   #endif
}

References ContractRow(), ExpandRow(), mChildArray, mLastLayoutSize, and mRowArray.

Referenced by AddChild(), AdjustLayout(), Layout(), MoveChild(), and RemoveChild().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ MoveChild()

void ToolBarArea::MoveChild	(	ExpandingToolBar *	child,
		wxRect	dropTarget
	)

Definition at line 1251 of file ExpandingToolBar.cpp.

{
   int i, j;
 
   for(i = 0; i < (int)mDropTargets.size(); i++) {
      if (dropTarget == mDropTargets[i]) {
         int newIndex = mDropTargetIndices[i];
         int newRow = mDropTargetRows[i];
 
         mChildArray.insert(mChildArray.begin() + newIndex, toolBar);
         mRowArray.insert(mRowArray.begin() + newIndex, newRow);
 
         for(j = newIndex+1; j < (int)mChildArray.size(); j++)
            mRowArray[j] = -1;
 
         ContractRow(newRow);
 
         mChildArray[newIndex]->Show();
 
         for(j = newIndex; j < (int)mChildArray.size(); j++)
            LayoutOne(j);
 
         Fit(false, true);
 
         return;
      }
   }
}

References ContractRow(), Fit(), LayoutOne(), mChildArray, mDropTargetIndices, mDropTargetRows, mDropTargets, and mRowArray.

Referenced by ExpandingToolBar::FinishMoving().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ OnMouse()

void ToolBarArea::OnMouse ( wxMouseEvent & evt )

Definition at line 1133 of file ExpandingToolBar.cpp.

{
   if (mCapturedChild) {
      if (evt.ButtonUp())
         mCapturedChild->FinishMoving();
      else if (evt.Moving() || evt.Dragging())
         mCapturedChild->UpdateMoving();
   }
   else {
      evt.Skip();
   }
}

References ExpandingToolBar::FinishMoving(), mCapturedChild, and ExpandingToolBar::UpdateMoving().

Here is the call graph for this function:

◆ OnSize()

void ToolBarArea::OnSize ( wxSizeEvent & evt )

Definition at line 1106 of file ExpandingToolBar.cpp.

{
   if (mInOnSize)
      return;
 
   mInOnSize = true;
 
   wxSize currentSize = GetClientSize();
 
   if (abs(currentSize.x - mLastLayoutSize.x) >= 100) {
      // If they resize by more than 100 pixels (horizontally),
      // we totally redo the layout, preserving the order of the
      // toolbars but not the exact position.
      Layout();
   }
   else {
      // If it was a minor resize, we try to preserve the positions of
      // the toolbars.  If this is impossible, we still redo the layout,
      // of course.
      AdjustLayout();
   }
 
   Fit(false, true);
 
   mInOnSize = false;
}

References AdjustLayout(), Fit(), Layout(), mInOnSize, and mLastLayoutSize.

Here is the call graph for this function:

◆ RemoveChild()

void ToolBarArea::RemoveChild ( ExpandingToolBar * child )

Definition at line 1162 of file ExpandingToolBar.cpp.

{
   int i, j;
 
   for(i = 0; i < (int)mChildArray.size(); i++) {
      if (mChildArray[i] == child) {
         child->Hide();
 
         mChildArray.erase(mChildArray.begin() + i);
         mRowArray.erase(mRowArray.begin() + i);
 
         for(j = i; j < (int)mChildArray.size(); j++)
            mRowArray[j] = -1;
 
         for(j = i; j < (int)mChildArray.size(); j++)
            LayoutOne(j);
 
         Fit(false, true);
      }
   }
}

References Fit(), LayoutOne(), mChildArray, and mRowArray.

Referenced by ExpandingToolBar::StartMoving().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ RestoreArrangement()

void ToolBarArea::RestoreArrangement ( std::unique_ptr< ToolBarArrangement > && arrangement )

Definition at line 1198 of file ExpandingToolBar.cpp.

{
   int i;
 
   mChildArray = arrangement->childArray;
   mRowArray = arrangement->rowArray;
 
   for(i = 0; i < (int)mChildArray.size(); i++) {
      mChildArray[i]->SetSize(arrangement->rectArray[i]);
      mChildArray[i]->Show();
   }
 
   Fit(false, true);
 
   arrangement.reset();
}

References Fit(), mChildArray, and mRowArray.

Referenced by ExpandingToolBar::FinishMoving().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ SaveArrangement()

std::unique_ptr< ToolBarArrangement > ToolBarArea::SaveArrangement ( )

Definition at line 1184 of file ExpandingToolBar.cpp.

{
   auto arrangement = std::make_unique<ToolBarArrangement>();
   int i;
 
   arrangement->childArray = mChildArray;
   arrangement->rowArray = mRowArray;
 
   for(i = 0; i < (int)mChildArray.size(); i++)
      arrangement->rectArray.push_back(mChildArray[i]->GetRect());
 
   return arrangement;
}

References mChildArray, and mRowArray.

Referenced by ExpandingToolBar::StartMoving().

Here is the caller graph for this function:

◆ SetCapturedChild()

void ToolBarArea::SetCapturedChild ( ExpandingToolBar * child )

Definition at line 1280 of file ExpandingToolBar.cpp.

{
   mCapturedChild = child;
}

References mCapturedChild.

Referenced by ExpandingToolBar::FinishMoving(), and ExpandingToolBar::StartMoving().

Here is the caller graph for this function:

Member Data Documentation

◆ mActualSize

wxSize ToolBarArea::mActualSize

protected

Definition at line 243 of file ExpandingToolBar.h.

Referenced by Fit().

◆ mCapturedChild

ExpandingToolBar* ToolBarArea::mCapturedChild

protected

Definition at line 239 of file ExpandingToolBar.h.

Referenced by OnMouse(), and SetCapturedChild().

◆ mChildArray

std::vector<ExpandingToolBar*> ToolBarArea::mChildArray

protected

Definition at line 234 of file ExpandingToolBar.h.

Referenced by AddChild(), AdjustLayout(), CollapseAll(), ContractRow(), ExpandRow(), Fit(), GetDropTargets(), Layout(), LayoutOne(), MoveChild(), RemoveChild(), RestoreArrangement(), and SaveArrangement().

◆ mDropTargetIndices

std::vector<int> ToolBarArea::mDropTargetIndices

protected

Definition at line 246 of file ExpandingToolBar.h.

Referenced by GetDropTargets(), and MoveChild().

◆ mDropTargetRows

std::vector<int> ToolBarArea::mDropTargetRows

protected

Definition at line 247 of file ExpandingToolBar.h.

Referenced by GetDropTargets(), and MoveChild().

◆ mDropTargets

std::vector<wxRect> ToolBarArea::mDropTargets

protected

Definition at line 245 of file ExpandingToolBar.h.

Referenced by GetDropTargets(), and MoveChild().

◆ mInOnSize

bool ToolBarArea::mInOnSize

protected

Definition at line 237 of file ExpandingToolBar.h.

Referenced by OnSize().

◆ mLastLayoutSize

wxSize ToolBarArea::mLastLayoutSize

protected

Definition at line 236 of file ExpandingToolBar.h.

Referenced by LayoutOne(), and OnSize().

◆ mMaxSize

wxSize ToolBarArea::mMaxSize

protected

Definition at line 242 of file ExpandingToolBar.h.

Referenced by Fit().

◆ mMinSize

wxSize ToolBarArea::mMinSize

protected

Definition at line 241 of file ExpandingToolBar.h.

Referenced by Fit().

◆ mRowArray

std::vector<int> ToolBarArea::mRowArray

protected

Definition at line 235 of file ExpandingToolBar.h.

Referenced by AddChild(), AdjustLayout(), ContractRow(), ExpandRow(), GetDropTargets(), Layout(), LayoutOne(), MoveChild(), RemoveChild(), RestoreArrangement(), and SaveArrangement().

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

Public Member Functions

Protected Member Functions

Protected Attributes

Detailed Description

Constructor & Destructor Documentation

◆ ToolBarArea()

◆ ~ToolBarArea()

Member Function Documentation

◆ AddChild()

◆ AdjustLayout()

◆ CollapseAll()

◆ ContractRow()

◆ ExpandRow()

◆ Fit() [1/2]

◆ Fit() [2/2]

◆ GetDropTargets()

◆ Layout()

◆ LayoutOne()

◆ MoveChild()

◆ OnMouse()

◆ OnSize()

◆ RemoveChild()

◆ RestoreArrangement()

◆ SaveArrangement()

◆ SetCapturedChild()

Member Data Documentation

◆ mActualSize

◆ mCapturedChild

◆ mChildArray

◆ mDropTargetIndices

◆ mDropTargetRows

◆ mDropTargets

◆ mInOnSize

◆ mLastLayoutSize

◆ mMaxSize

◆ mMinSize

◆ mRowArray