BasicMenu::anonymous_namespace{BasicMenu.cpp} Namespace Reference

Classes
struct	Watcher
	Singleton object listens to global wxEvent stream. More...

Typedefs
using	Menus = std::vector< wxWeakRef< wxMenu > >

Functions
Menus	FindDescendants (wxMenu &menu)
bool	ContainsMenu (const Menus &menus, void *pObj)
std::optional< wxArrayStringEx >	FindPathName (wxMenu &theMenu, int id)
void	Watch ()
void	ReplayPopup (wxMenu *theMenu)

Variables
const auto	JournalCode = L"PopupMenu"
std::vector< Menus >	sMenuStack
bool	sHandledEvent = false
Journal::RegisteredInitializer	initializer

Typedef Documentation

Menus

using BasicMenu::anonymous_namespace{BasicMenu.cpp}::Menus = typedef std::vector< wxWeakRef< wxMenu > >

Definition at line 31 of file BasicMenu.cpp.

Function Documentation

ContainsMenu()

bool BasicMenu::anonymous_namespace{BasicMenu.cpp}::ContainsMenu ( const Menus &  menus, void *  pObj  )

inline

Definition at line 52 of file BasicMenu.cpp.

{
   return std::count( menus.begin(), menus.end(), pObj );
}

Referenced by BasicMenu::anonymous_namespace{BasicMenu.cpp}::Watcher::FilterEvent().

Here is the caller graph for this function:

FindDescendants()

Menus BasicMenu::anonymous_namespace{BasicMenu.cpp}::FindDescendants

(

wxMenu &

menu

)

Definition at line 37 of file BasicMenu.cpp.

{
   Menus result{ &menu };
   // We can discover them breadth-first
   for ( size_t ii = 0; ii < result.size(); ++ii ) {
      if ( auto pMenu = result[ii] ) {
         for ( const auto &pItem : pMenu->GetMenuItems() ) {
            if ( const auto pSubMenu = pItem->GetSubMenu() )
               result.push_back( pSubMenu );
         }
      }
   }
   return result;
}

Referenced by BasicMenu::Handle::Popup().

Here is the caller graph for this function:

FindPathName()

std::optional< wxArrayStringEx > BasicMenu::anonymous_namespace{BasicMenu.cpp}::FindPathName	(	wxMenu &	theMenu,
		int	id
	)

Definition at line 59 of file BasicMenu.cpp.

{
   wxMenuItem *pItem = nullptr;
   wxMenu *pSubMenu = nullptr;
   if ( !( pItem = theMenu.FindItem( id, &pSubMenu ) ) )
      return std::nullopt;
 
   // Gather path components, checking uniqueness at each level
   wxArrayStringEx names;
   for ( ; pSubMenu; pSubMenu = pSubMenu->GetParent() ) {
      const auto &items = pSubMenu->GetMenuItems();
      const auto begin = items.begin(), end = items.end();
      if ( !names.empty() ) {
         // Update pItem on second and later passes
         if ( const auto iter = std::find_if( begin, end,
               [&]( auto pNewItem ){
                  return pNewItem->GetSubMenu() == pItem->GetMenu(); } );
             iter == end )
            return std::nullopt;
         else
            pItem = *iter;
      }
      auto name = pItem->GetItemLabelText();
      if ( 1 != std::count_if( begin, end, [&](auto item){
            return item->GetItemLabelText() == name; } ) )
         // nonuniqueness
         return std::nullopt;
      names.push_back( name );
   }
   std::reverse( names.begin(), names.end() );
   return { names };
}

References details::begin(), details::end(), name, names, and anonymous_namespace{RegisterBuiltinEffects.cpp}::reverse.

Referenced by BasicMenu::anonymous_namespace{BasicMenu.cpp}::Watcher::FilterEvent().

Here is the call graph for this function:

Here is the caller graph for this function:

ReplayPopup()

void BasicMenu::anonymous_namespace{BasicMenu.cpp}::ReplayPopup

(

wxMenu *

theMenu

)

Definition at line 153 of file BasicMenu.cpp.

{
   // Expect JournalCode and maybe a path.
   const auto fields = Journal::GetTokens();
   if ( fields[0] == JournalCode ) {
      if ( fields.size() == 1)
         // No command, so just eat the journal line
         return;
 
      // Locate the menu item by name in the current popup menu or descendant.
      auto found = [&]() -> std::pair<wxMenuItem *, wxMenu*> {
         wxMenuItem *pItem = nullptr;
         auto pMenu = theMenu;
         for ( auto pField = fields.begin() + 1, endFields = fields.end();
              pMenu && pField != endFields; ++pField ) {
            auto &name = *pField;
            const auto &list = pMenu->GetMenuItems();
            const auto pred = [&name](auto &pItem){
               return pItem->GetItemLabelText() == name; };
            const auto begin = list.begin(), end = list.end(),
               iter = std::find_if(begin, end, pred);
 
            // Check existence and uniqueness
            if ( auto next = iter;
                end == next || end != std::find_if(++next, end, pred) )
               return { nullptr, nullptr };
 
            pItem = *iter;
            if ( pField + 1 != endFields )
               pMenu = pItem->GetSubMenu();
         }
         return { pItem, pMenu };
      }();
 
      if ( auto [pItem, pMenu] = found; pItem && pMenu ) {
         // Don't really pop up the menu, which uses native event handling
         // that we can't filter.  Simulate an event instead.
         // Require that some event is bound to the item, so it is
         // handled, or else the journal fails replay.
         wxCommandEvent event{ wxEVT_MENU, pItem->GetId() };
         event.SetEventObject( pMenu );
         if ( pMenu->ProcessEvent( event ) ) {
            sHandledEvent = true;
            return;
         }
      }
   }
 
   // Replay did not find all as expected
   throw Journal::SyncException(wxString::Format(
      "PopupMenu has failed to invoke %s",
      wxJoin(fields, ',').ToStdString().c_str()));
}

References details::begin(), details::end(), Journal::GetTokens(), JournalCode, name, and sHandledEvent.

Referenced by BasicMenu::Handle::Popup().

Here is the call graph for this function:

Here is the caller graph for this function:

Watch()

void BasicMenu::anonymous_namespace{BasicMenu.cpp}::Watch

(

)

Definition at line 137 of file BasicMenu.cpp.

{
   static Watcher instance;
}

Variable Documentation

initializer

Journal::RegisteredInitializer BasicMenu::anonymous_namespace{BasicMenu.cpp}::initializer

Initial value:

{ []{
   using namespace Journal;
 
   if ( !GetError() && IsRecording() )
      
      Watch();
 
   return true;
} }

Definition at line 143 of file BasicMenu.cpp.

JournalCode

const auto BasicMenu::anonymous_namespace{BasicMenu.cpp}::JournalCode = L"PopupMenu"

Definition at line 29 of file BasicMenu.cpp.

sHandledEvent

bool BasicMenu::anonymous_namespace{BasicMenu.cpp}::sHandledEvent = false

Definition at line 35 of file BasicMenu.cpp.

Referenced by BasicMenu::anonymous_namespace{BasicMenu.cpp}::Watcher::FilterEvent(), BasicMenu::Handle::Popup(), and ReplayPopup().

sMenuStack

std::vector< Menus > BasicMenu::anonymous_namespace{BasicMenu.cpp}::sMenuStack

Definition at line 34 of file BasicMenu.cpp.

Referenced by BasicMenu::anonymous_namespace{BasicMenu.cpp}::Watcher::FilterEvent(), and BasicMenu::Handle::Popup().