ToolBarConfiguration Class Reference

#include <ToolDock.h>

Collaboration diagram for ToolBarConfiguration:

Classes
class	Iterator
struct	Legacy
struct	Place
struct	Position
struct	Tree

Public Member Functions
void	Swap (ToolBarConfiguration &that)
void	Clear ()
Iterator	begin ()
Iterator	end () const
Position	Find (const ToolBar *bar) const
ToolBar *	FindToolBar (Identifier id) const
bool	Contains (const ToolBar *bar) const
void	Insert (ToolBar *bar, Position position=UnspecifiedPosition)
void	InsertAtPath (ToolBar *bar, const std::vector< int > &path)
void	Remove (const ToolBar *bar)
bool	Shows (const ToolBar *bar) const
void	Show (ToolBar *bar)
void	Hide (ToolBar *bar)
bool	IsRightmost (const ToolBar *bar) const
void	PostRead (Legacy &legacy)

Static Public Member Functions
static bool	Read (ToolBarConfiguration *pConfiguration, Legacy *pLegacy, ToolBar *bar, bool &visible, bool defaultVisible)
static void	Write (const ToolBarConfiguration *pConfiguration, const ToolBar *bar)

Static Public Attributes
static const Position	UnspecifiedPosition { false }

Private Types
using	Forest = std::vector< Tree >

Private Member Functions
void	Remove (Forest &forest, Forest::iterator iter)
void	RemoveNulls (Forest &forest)
Iterator	FindPlace (const ToolBar *bar) const
std::pair< Forest *, Forest::iterator >	FindPeers (const ToolBar *bar)

Private Attributes
Forest	mForest

Detailed Description

Definition at line 50 of file ToolDock.h.

Member Typedef Documentation

Forest

using ToolBarConfiguration::Forest = std::vector<Tree>

private

Definition at line 53 of file ToolDock.h.

Member Function Documentation

begin()

Iterator ToolBarConfiguration::begin ( )

inline

Definition at line 229 of file ToolDock.h.

{ return Iterator { *this }; }

Referenced by Insert().

Here is the caller graph for this function:

Clear()

void ToolBarConfiguration::Clear ( )

inline

Definition at line 62 of file ToolDock.h.

   {
      mForest.clear();
   }

References mForest.

Referenced by ToolManager::Destroy(), ToolManager::DoneDragging(), ToolDock::RestoreConfiguration(), ToolDock::VisitLayout(), and ToolDock::WrapConfiguration().

Here is the caller graph for this function:

Contains()

bool ToolBarConfiguration::Contains ( const ToolBar *  bar ) const

inline

Definition at line 235 of file ToolDock.h.

   {
      return Find(bar) != UnspecifiedPosition;
   }

References Find(), and UnspecifiedPosition.

Referenced by ToolDock::Dock(), Show(), Shows(), ToolDock::Undock(), and ToolManager::WriteConfig().

Here is the call graph for this function:

Here is the caller graph for this function:

end()

Iterator ToolBarConfiguration::end ( ) const

inline

Definition at line 230 of file ToolDock.h.

{ return Iterator {}; }

Referenced by FindToolBar(), Insert(), IsRightmost(), and Write().

Here is the caller graph for this function:

Find()

auto ToolBarConfiguration::Find

(

const ToolBar *

bar

)

const

Definition at line 87 of file ToolDock.cpp.

{
   auto iter = FindPlace(bar);
   if (iter == end())
      return UnspecifiedPosition;
   else
      return iter->position;
}

References details::end().

Referenced by Contains(), and ToolManager::OnGrabber().

Here is the call graph for this function:

Here is the caller graph for this function:

FindPeers()

auto ToolBarConfiguration::FindPeers ( const ToolBar *  bar )

private

Definition at line 62 of file ToolDock.cpp.

{
   auto findTree = [=](Forest &forest){
      return std::find_if(forest.begin(), forest.end(),
         [=](const Tree &tree){ return tree.pBar == bar; });
   };
 
   auto iter1 = findTree(mForest);
   if (iter1 != mForest.end())
      return { &mForest, iter1 };
 
   Forest::iterator result;
   auto iter = std::find_if(begin(), end(),
      [&](const Place &place){
         auto &children = place.pTree->children;
         return (result = findTree(children)) != children.end();
      }
   );
   if (iter != end())
      return { &iter->pTree->children, result };
 
   return { nullptr, Forest::iterator{} };
}

References details::begin(), ToolBarConfiguration::Tree::children, details::end(), and ToolBarConfiguration::Place::pTree.

Referenced by Remove().

Here is the call graph for this function:

Here is the caller graph for this function:

FindPlace()

auto ToolBarConfiguration::FindPlace ( const ToolBar *  bar ) const

private

Definition at line 52 of file ToolDock.cpp.

{
   auto This = const_cast<ToolBarConfiguration*>(this);
   return std::find_if(This->begin(), This->end(),
      [=](const Place &place){
         return place.pTree->pBar == bar;
      });
}

Referenced by Insert(), IsRightmost(), and Write().

Here is the caller graph for this function:

FindToolBar()

ToolBar * ToolBarConfiguration::FindToolBar

(

Identifier

id

)

const

Definition at line 96 of file ToolDock.cpp.

{
   if (toolBarID.empty())
      return nullptr;
   
   auto This = const_cast<ToolBarConfiguration*>(this);
   auto it = std::find_if(
      This->begin(), This->end(),
      [=](const Place& place)
      { return place.pTree->pBar->GetSection() == toolBarID; });
 
   return it != end() ? it->pTree->pBar : nullptr;
}

References Identifier::empty(), end(), ToolBarConfiguration::Tree::pBar, and ToolBarConfiguration::Place::pTree.

Referenced by Show().

Here is the call graph for this function:

Here is the caller graph for this function:

Hide()

void ToolBarConfiguration::Hide

(

ToolBar *

bar

)

Definition at line 257 of file ToolDock.cpp.

{
   // Future:  might hide a bar without eliminating it from the configuration
   Remove(bar);
}

References Remove().

Referenced by ToolDock::Expose().

Here is the call graph for this function:

Here is the caller graph for this function:

Insert()

void ToolBarConfiguration::Insert	(	ToolBar *	bar,
		Position	position = UnspecifiedPosition
	)

Definition at line 110 of file ToolDock.cpp.

{
   if (position == UnspecifiedPosition) {
      // Add at the "end" of the layout
      // bottommost and rightmost
      Forest *pForest = &mForest;
      while (!pForest->empty())
         pForest = &pForest->back().children;
      pForest->push_back( Tree {} );
      pForest->back().pBar = bar;
   }
   else {
      // Insert at what depth?
      auto pForest = &mForest;
      if (position.rightOf) {
         const auto parent = FindPlace(position.rightOf);
         if (parent != end())
            // Insert among children of some node
            pForest = &parent->pTree->children;
      }
      else {
         // Insert a new root in the top forest
      }
 
      // Insert at what breadth?
      const auto begin = pForest->begin();
      auto iter = begin;
      const auto end = pForest->end();
      bool adopt = false;
 
      if (position.below) {
         iter = std::find_if(begin, end,
            [=](const Tree &tree){ return tree.pBar == position.below; }
         );
         if (iter != end) {
            ++iter;
            if (iter != end)
               adopt = true;
         }
         else
            // Not found, default to topmost
            iter = begin;
      }
      else
         // No previous sibling specified, so insert as first
         adopt = (iter != end);
 
      // Insert as a leaf, or as an internal node?
      if (adopt && position.adopt) {
         // Existing children of parent become grandchildren
 
         // Make NEW node
         Tree tree;
         tree.pBar = bar;
 
         // Do adoption
         const auto barHeight = bar->GetSize().GetY() + toolbarGap;
         auto totalHeight = 0;
         while (iter != pForest->end() &&
            barHeight >=
               (totalHeight += (iter->pBar->GetSize().GetY() + toolbarGap))) {
            tree.children.push_back(Tree{});
            auto &child = tree.children.back();
            child.pBar = iter->pBar;
            child.children.swap(iter->children);
            iter = pForest->erase(iter);
         }
 
         // Put the node in the tree
         iter = pForest->insert(iter, Tree{});
         (*iter).swap(tree);
      }
      else
         // Insert as a leaf
         pForest->insert(iter, Tree {})->pBar = bar;
   }
}

References ToolBarConfiguration::Position::adopt, begin(), ToolBarConfiguration::Position::below, ToolBarConfiguration::Tree::children, end(), FindPlace(), mForest, ToolBarConfiguration::Tree::pBar, ToolBarConfiguration::Position::rightOf, toolbarGap, and UnspecifiedPosition.

Referenced by ToolDock::Dock(), PostRead(), Show(), and ToolDock::VisitLayout().

Here is the call graph for this function:

Here is the caller graph for this function:

InsertAtPath()

void ToolBarConfiguration::InsertAtPath	(	ToolBar *	bar,
		const std::vector< int > &	path
	)

Definition at line 188 of file ToolDock.cpp.

{
   auto pForest = &mForest;
   Tree *pTree {};
 
   // Guarantee the existence of nodes
   for (auto ii : path) {
      Forest::size_type uu = std::max(0, ii);
      // This may make more than one default-constructed tree, which we
      // will fill in with some other call to InsertAtPath, or else cleanup
      // with RemoveNulls
      pForest->resize(std::max(uu + 1, pForest->size()));
      pTree = &(*pForest)[uu];
      pForest = &pTree->children;
   }
 
   if (pTree)
      pTree->pBar = bar;
}

References mForest.

Referenced by Read().

Here is the caller graph for this function:

IsRightmost()

bool ToolBarConfiguration::IsRightmost

(

const ToolBar *

bar

)

const

Definition at line 263 of file ToolDock.cpp.

{
   auto iter = FindPlace(bar);
   auto endit = end();
   if (iter == endit)
      // not present
      return true;
   if (++iter == endit)
      // Last of all
      return true;
   if (bar->GetRect().y != iter->pTree->pBar->GetRect().y)
      // Next step in preorder traversal is not rightward to a child drawn at
      // the same height
      return true;
   return false;
}

References end(), and FindPlace().

Here is the call graph for this function:

PostRead()

void ToolBarConfiguration::PostRead

(

Legacy &

legacy

)

Definition at line 334 of file ToolDock.cpp.

{
   // Be sure no nodes contain NULL,
   // against the case of obsolete preferences, perhaps
   RemoveNulls(mForest);
 
   // Interpret what was saved in old .cfg files under "order"
   // which specified toolbar configuration simply as a sequence, not a tree
   ToolBar *prev {};
   for (auto pBar : legacy.bars) {
      if (!pBar)
         continue;
 
      Position position{ prev };
      Insert(pBar, position);
 
      prev = pBar;
   }
}

References ToolBarConfiguration::Legacy::bars, Insert(), mForest, and RemoveNulls().

Referenced by ToolManager::ReadConfig().

Here is the call graph for this function:

Here is the caller graph for this function:

Read()

bool ToolBarConfiguration::Read ( ToolBarConfiguration *  pConfiguration, Legacy *  pLegacy, ToolBar *  bar, bool &  visible, bool  defaultVisible  )

static

Definition at line 280 of file ToolDock.cpp.

{
   bool result = true;
 
   // Future: might remember visibility in the configuration, not forgetting
   // positions of hidden bars.
   gPrefs->Read( wxT("Show"), &visible, defaultVisible);
 
   if (pConfiguration && visible) {
      int ord;
      gPrefs->Read( wxT("Order"), &ord, -1 );
      // Index was written 1-based
      --ord;
      if (ord >= 0)
      {
         // Legacy preferences
         while (pLegacy->bars.size() <= size_t(ord))
            pLegacy->bars.push_back(nullptr);
         pLegacy->bars[ord] = bar;
      }
      else {
         wxString strPath;
         gPrefs->Read( wxT("Path"), &strPath );
         if (!strPath.empty()) {
            wxStringTokenizer toker { strPath, wxT(",") };
            std::vector<int> path;
            while(toker.HasMoreTokens()) {
               auto token = toker.GetNextToken();
               auto ii = wxAtoi(token);
               path.push_back(ii);
            }
            pConfiguration->InsertAtPath(bar, path);
         }
      }
   }
 
   return result;
}

References ToolBarConfiguration::Legacy::bars, gPrefs, InsertAtPath(), audacity::BasicSettings::Read(), and wxT().

Referenced by ToolManager::ReadConfig().

Here is the call graph for this function:

Here is the caller graph for this function:

Remove() [1/2]

void ToolBarConfiguration::Remove

(

const ToolBar *

bar

)

Definition at line 224 of file ToolDock.cpp.

{
   auto results = FindPeers(bar);
   auto pForest = results.first;
   if (pForest) {
      // Reparent all of the children of the deleted node
      auto iter = results.second;
      wxASSERT(iter->pBar == bar);
      Remove(*pForest, iter);
   }
}

References FindPeers(), and Remove().

Referenced by Hide(), ToolManager::OnMouse(), Remove(), RemoveNulls(), and ToolDock::Undock().

Here is the call graph for this function:

Here is the caller graph for this function:

Remove() [2/2]

void ToolBarConfiguration::Remove ( Forest &  forest, Forest::iterator  iter  )

private

Definition at line 209 of file ToolDock.cpp.

{
   // Reparent all of the children of the deleted node
   Tree tree;
   tree.swap(*iter);
   iter = forest.erase(iter);
   auto &children = tree.children;
   auto cIter = children.rbegin(), cEnd = children.rend();
   while (cIter != cEnd) {
      iter = forest.insert(iter, Tree{});
      (*iter).swap(*cIter);
      ++cIter;
   }
}

References ToolBarConfiguration::Tree::children, and ToolBarConfiguration::Tree::swap().

Here is the call graph for this function:

RemoveNulls()

void ToolBarConfiguration::RemoveNulls ( Forest &  forest )

private

Definition at line 322 of file ToolDock.cpp.

{
   for (size_t ii = 0; ii < forest.size(); ++ii) {
      if(forest[ii].pBar == nullptr)
         Remove(forest, forest.begin() + ii--);
   }
 
   // Now do the same recursively
   for (auto &tree : forest)
      RemoveNulls(tree.children);
}

References Remove(), and RemoveNulls().

Referenced by PostRead(), and RemoveNulls().

Here is the call graph for this function:

Here is the caller graph for this function:

Show()

void ToolBarConfiguration::Show

(

ToolBar *

bar

)

Definition at line 236 of file ToolDock.cpp.

{
   // Do not assume the bar is absent, though in practice that is always so
   if (!Contains(bar)) {
      auto position = UnspecifiedPosition;
      const auto preferredNeighbors = bar->PreferredNeighbors();
      if (!preferredNeighbors.first.empty() ||
          !preferredNeighbors.second.empty())
      {
         auto leftNeighbor = FindToolBar(preferredNeighbors.first);
         auto topNeighbor = FindToolBar(preferredNeighbors.second);
 
         // Perform a sanity check to verify that neighbors are
         // really inside this configuration
         if (leftNeighbor != nullptr || topNeighbor != nullptr)
            position = Position { leftNeighbor, topNeighbor };
      }
      Insert(bar, position);
   }
}

References Contains(), FindToolBar(), Insert(), ToolBar::PreferredNeighbors(), and UnspecifiedPosition.

Referenced by ToolDock::Expose().

Here is the call graph for this function:

Here is the caller graph for this function:

Shows()

bool ToolBarConfiguration::Shows ( const ToolBar *  bar ) const

inline

Definition at line 248 of file ToolDock.h.

{ return Contains(bar); }

References Contains().

Referenced by ToolDock::Expose().

Here is the call graph for this function:

Here is the caller graph for this function:

Swap()

void ToolBarConfiguration::Swap ( ToolBarConfiguration &  that )

inline

Definition at line 57 of file ToolDock.h.

   {
      mForest.swap(that.mForest);
   }

References mForest.

Referenced by ToolDock::RestoreConfiguration(), and ToolDock::WrapConfiguration().

Here is the caller graph for this function:

Write()

void ToolBarConfiguration::Write ( const ToolBarConfiguration *  pConfiguration, const ToolBar *  bar  )

static

Definition at line 354 of file ToolDock.cpp.

{
   // Assume a path has been set in gPrefs suitable for bar
   if (pConfiguration) {
      // Write comma-separated list of numbers specifying position in the tree
      wxString strPath;
      const auto cIter = pConfiguration->FindPlace(bar);
      const auto path = cIter.GetPath();
      if (!path.empty()) {
         auto iter = path.begin(), end = path.end();
         strPath += wxString::Format(wxT("%d"), *iter++);
         while (iter != end)
            strPath += wxString::Format(wxT(",%d"), *iter++);
      }
      gPrefs->Write(wxT("Path"), strPath);
 
      // Remove any legacy configuration info.
      // Note:  this causes Audacity 2.1.2 and earlier to create toolbars
      // always in default position when reading a .cfg saved by Audacity
      // 2.1.3 or later
      gPrefs->DeleteEntry(wxT("Order"));
   }
   gPrefs->Write( wxT("Show"), bar->IsVisible() );
}

References audacity::BasicSettings::DeleteEntry(), end(), FindPlace(), ToolBarConfiguration::Iterator::GetPath(), gPrefs, ToolBar::IsVisible(), audacity::BasicSettings::Write(), and wxT().

Referenced by ToolManager::WriteConfig().

Here is the call graph for this function:

Here is the caller graph for this function:

Member Data Documentation

mForest

Forest ToolBarConfiguration::mForest

private

Definition at line 288 of file ToolDock.h.

Referenced by Clear(), Insert(), InsertAtPath(), ToolBarConfiguration::Iterator::Iterator(), PostRead(), and Swap().

UnspecifiedPosition

const ToolBarConfiguration::Position ToolBarConfiguration::UnspecifiedPosition { false }

static

Definition at line 106 of file ToolDock.h.

Referenced by Contains(), ToolManager::DoneDragging(), Insert(), ToolDock::PositionBar(), and Show().

---

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

• ToolDock.h
• ToolDock.cpp