KeyView Class Reference

Provides multiple views of keyboard shortcuts. More...

#include <KeyView.h>

Inheritance diagram for KeyView:

Collaboration diagram for KeyView:

Public Member Functions
	KeyView (wxWindow *parent, wxWindowID id=wxID_ANY, const wxPoint &pos=wxDefaultPosition, const wxSize &size=wxDefaultSize)
virtual	~KeyView ()
wxString	GetName () const override
void	RefreshBindings (const CommandIDs &names, const TranslatableStrings &categories, const TranslatableStrings &prefixes, const TranslatableStrings &labels, const std::vector< NormalizedKeyString > &keys, bool bSort)
int	GetSelected () const
wxString	GetLabel (int index) const
wxString	GetFullLabel (int index) const
int	GetIndexByName (const CommandID &name) const
CommandID	GetName (int index) const
CommandID	GetNameByKey (const NormalizedKeyString &key) const
int	GetIndexByKey (const NormalizedKeyString &key) const
NormalizedKeyString	GetKey (int index) const
bool	CanSetKey (int index) const
bool	SetKey (int index, const NormalizedKeyString &key)
bool	SetKeyByName (const CommandID &name, const NormalizedKeyString &key)
void	SetView (ViewByType type)
void	SetFilter (const wxString &filter)
void	ExpandAll ()
void	CollapseAll ()
void	SelectNode (int index)

Private Member Functions
void	RecalcExtents ()
void	UpdateHScroll ()
void	RefreshLines (bool bSort=true)
int	LineToIndex (int line) const
int	IndexToLine (int index) const
void	OnDrawBackground (wxDC &dc, const wxRect &rect, size_t line) const override
void	OnDrawItem (wxDC &dc, const wxRect &rect, size_t line) const override
wxCoord	OnMeasureItem (size_t line) const override
void	OnSelected (wxCommandEvent &event)
void	OnSetFocus (wxFocusEvent &event)
void	OnKillFocus (wxFocusEvent &event)
void	OnSize (wxSizeEvent &event)
void	OnScroll (wxScrollWinEvent &event)
void	OnKeyDown (wxKeyEvent &event)
void	OnLeftDown (wxMouseEvent &event)

Static Private Member Functions
static bool	CmpKeyNodeByTree (KeyNode *n1, KeyNode *n2)
static bool	CmpKeyNodeByName (KeyNode *n1, KeyNode *n2)
static bool	CmpKeyNodeByKey (KeyNode *n1, KeyNode *n2)

Private Attributes
std::vector< KeyNode >	mNodes
std::vector< KeyNode * >	mLines
ViewByType	mViewType
wxString	mFilter
wxCoord	mScrollX
wxCoord	mWidth
size_t	mLineCount
wxCoord	mLineHeight
wxCoord	mKeyX
int	mCommandWidth
wxCoord	mKeyWidth

Detailed Description

Provides multiple views of keyboard shortcuts.

Definition at line 72 of file KeyView.h.

Constructor & Destructor Documentation

KeyView()

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

Definition at line 155 of file KeyView.cpp.

: wxVListBox(parent, id, pos, size, wxBORDER_THEME | wxHSCROLL | wxVSCROLL),
  mScrollX(0),
  mWidth(0)
{
#if wxUSE_ACCESSIBILITY
   // Create and set accessibility object
   SetAccessible(mAx = safenew KeyViewAx(this));
#endif
 
   SetMinSize({-1, 150});
 
   // The default view
   mViewType = ViewByTree;
 
   // Calculate measurements used for columns and scrolling
   RecalcExtents();
}

References safenew, and ViewByTree.

~KeyView()

KeyView::~KeyView ( )

virtual

Definition at line 177 of file KeyView.cpp.

{
}

Member Function Documentation

CanSetKey()

bool KeyView::CanSetKey

(

int

index

)

const

Definition at line 338 of file KeyView.cpp.

{
   // Make sure index is valid
   if (index < 0 || index >= (int) mNodes.size())
   {
      wxASSERT(false);
      return false;
   }
 
   // Parents can't be assigned keys
   return !mNodes[index].isparent;
}

References mNodes.

Referenced by KeyConfigPrefs::OnSelected(), and KeyConfigPrefs::SetKeyForSelected().

Here is the caller graph for this function:

CmpKeyNodeByKey()

bool KeyView::CmpKeyNodeByKey ( KeyNode *  n1, KeyNode *  n2  )

staticprivate

Definition at line 1756 of file KeyView.cpp.

{
   wxString k1 = t1->key.Display();
   wxString k2 = t2->key.Display();
 
   // Left node is unassigned, so prefix it
   if(k1.empty())
   {
      k1 = wxT("\xff");
   }
 
   // Right node is unassigned, so prefix it
   if(k2.empty())
   {
      k2 = wxT("\xff");
   }
 
   // Add prefix if available
   if (!t1->prefix.empty())
   {
      k1 += t1->prefix + wxT(" - ");
   }
 
   // Add prefix if available
   if (!t2->prefix.empty())
   {
      k2 += t2->prefix + wxT(" - ");
   }
 
   // Add labels
   k1 += t1->label;
   k2 += t2->label;
 
   return (k1 < k2);
}

References NormalizedKeyString::Display(), KeyNode::key, KeyNode::label, KeyNode::prefix, and wxT().

Referenced by RefreshLines().

Here is the call graph for this function:

Here is the caller graph for this function:

CmpKeyNodeByName()

bool KeyView::CmpKeyNodeByName ( KeyNode *  n1, KeyNode *  n2  )

staticprivate

Definition at line 1722 of file KeyView.cpp.

{
   wxString k1 = t1->label;
   wxString k2 = t2->label;
 
   // Prepend prefix if available
   if (!t1->prefix.empty())
   {
      k1 = t1->prefix + wxT(" - ") + k1;
   }
 
   // Prepend prefix if available
   if (!t2->prefix.empty())
   {
      k2 = t2->prefix + wxT(" - ") + k2;
   }
 
   return (k1 < k2);
}

References KeyNode::label, KeyNode::prefix, and wxT().

Referenced by RefreshLines().

Here is the call graph for this function:

Here is the caller graph for this function:

CmpKeyNodeByTree()

bool KeyView::CmpKeyNodeByTree ( KeyNode *  n1, KeyNode *  n2  )

staticprivate

Definition at line 1692 of file KeyView.cpp.

{
   unsigned int k1UInt= 0xffffffff;
   unsigned int k2UInt= 0xffffffff;
 
   // This is a "command" node if its category is "Command"
   // and it is a child of the "Command" category.  This latter
   // test ensures that the "Command" parent will be handled
   // as a "menu" node and remain at the bottom of the list.
   if (t1->category != CommandTranslated || t1->isparent)
      k1UInt = (unsigned int) t1->line;
 
   // See above for explanation
   if (t2->category != CommandTranslated || t2->isparent)
      k2UInt = (unsigned int) t2->line;
 
   if( k1UInt < k2UInt ) 
      return true;
   if( k1UInt > k2UInt )
      return false;
 
   return ( t1->label < t2->label );
}

References KeyNode::category, CommandTranslated, KeyNode::isparent, KeyNode::label, and KeyNode::line.

Referenced by RefreshLines().

Here is the caller graph for this function:

CollapseAll()

void KeyView::CollapseAll

(

)

Definition at line 525 of file KeyView.cpp.

{
   int cnt = (int) mNodes.size();
 
   // Set all parent nodes to closed
   for (int i = 0; i < cnt; i++)
   {
      KeyNode & node = mNodes[i];
 
      if (node.isparent)
      {
         node.isopen = false;
      }
   }
 
   RefreshLines();
}

References KeyNode::isopen, KeyNode::isparent, mNodes, and RefreshLines().

Here is the call graph for this function:

ExpandAll()

void KeyView::ExpandAll

(

)

Definition at line 503 of file KeyView.cpp.

{
   int cnt = (int) mNodes.size();
 
   // Set all parent nodes to open
   for (int i = 0; i < cnt; i++)
   {
      KeyNode & node = mNodes[i];
 
      if (node.isparent)
      {
         node.isopen = true;
      }
   }
 
   RefreshLines();
}

References KeyNode::isopen, KeyNode::isparent, mNodes, and RefreshLines().

Here is the call graph for this function:

GetFullLabel()

wxString KeyView::GetFullLabel

(

int

index

)

const

Definition at line 220 of file KeyView.cpp.

{
   // Make sure index is valid
   if (index < 0 || index >= (int) mNodes.size())
   {
      wxASSERT(false);
      return wxEmptyString;
   }
 
   // Cache the node and label
   const KeyNode & node = mNodes[index];
   wxString label = node.label;
 
   // Prepend the prefix if available
   if (!node.prefix.empty())
   {
      label = node.prefix + wxT(" - ") + label;
   }
 
   return label;
}

References label, KeyNode::label, mNodes, KeyNode::prefix, and wxT().

Referenced by OnKeyDown().

Here is the call graph for this function:

Here is the caller graph for this function:

GetIndexByKey()

int KeyView::GetIndexByKey

(

const NormalizedKeyString &

key

)

const

Definition at line 302 of file KeyView.cpp.

{
   int cnt = (int) mNodes.size();
 
   // Search the nodes for the key
   for (int i = 0; i < cnt; i++)
   {
      if ( key == mNodes[i].key )
      {
         return mNodes[i].index;
      }
   }
 
   return wxNOT_FOUND;
}

References key, and mNodes.

GetIndexByName()

int KeyView::GetIndexByName

(

const CommandID &

name

)

const

Definition at line 246 of file KeyView.cpp.

{
   int cnt = (int) mNodes.size();
 
   // Search the nodes for the key
   for (int i = 0; i < cnt; i++)
   {
      if (name == mNodes[i].name)
      {
         return mNodes[i].index;
      }
   }
 
   return wxNOT_FOUND;
}

References mNodes, and name.

Referenced by SetKeyByName().

Here is the caller graph for this function:

GetKey()

NormalizedKeyString KeyView::GetKey

(

int

index

)

const

Definition at line 322 of file KeyView.cpp.

{
   // Make sure index is valid
   if (index < 0 || index >= (int) mNodes.size())
   {
      wxASSERT(false);
      return {};
   }
 
   return mNodes[index].key;
}

References mNodes.

Referenced by KeyConfigPrefs::OnHotkeyKillFocus(), OnKeyDown(), and KeyConfigPrefs::OnSelected().

Here is the caller graph for this function:

GetLabel()

wxString KeyView::GetLabel

(

int

index

)

const

Definition at line 204 of file KeyView.cpp.

{
   // Make sure index is valid
   if (index < 0 || index >= (int) mNodes.size())
   {
      wxASSERT(false);
      return wxEmptyString;
   }
 
   return mNodes[index].label;
}

References mNodes.

Referenced by OnKeyDown().

Here is the caller graph for this function:

GetName() [1/2]

wxString KeyView::GetName ( ) const

override

Definition at line 194 of file KeyView.cpp.

{
   // Just forward request
   return wxVListBox::GetName();
}

Referenced by KeyConfigPrefs::OnSet(), and KeyConfigPrefs::SetKeyForSelected().

Here is the caller graph for this function:

GetName() [2/2]

CommandID KeyView::GetName

(

int

index

)

const

Definition at line 266 of file KeyView.cpp.

{
   // Make sure index is valid
   if (index < 0 || index >= (int) mNodes.size())
   {
      wxASSERT(false);
      return {};
   }
 
   return mNodes[index].name;
}

References mNodes.

GetNameByKey()

CommandID KeyView::GetNameByKey

(

const NormalizedKeyString &

key

)

const

Definition at line 282 of file KeyView.cpp.

{
   int cnt = (int) mNodes.size();
 
   // Search the nodes for the key
   for (int i = 0; i < cnt; i++)
   {
      if ( key == mNodes[i].key )
      {
         return mNodes[i].name;
      }
   }
 
   return {};
}

References key, and mNodes.

Referenced by KeyConfigPrefs::NameFromKey().

Here is the caller graph for this function:

GetSelected()

int KeyView::GetSelected

(

)

const

Definition at line 185 of file KeyView.cpp.

{
   return LineToIndex(GetSelection());
}

References LineToIndex().

Referenced by KeyConfigPrefs::OnSelected().

Here is the call graph for this function:

Here is the caller graph for this function:

IndexToLine()

int KeyView::IndexToLine ( int  index ) const

private

Definition at line 1146 of file KeyView.cpp.

{
   if (index < 0 || index >= (int) mNodes.size())
   {
      return wxNOT_FOUND;
   }
 
   return mNodes[index].line;
}

References mNodes.

Referenced by SelectNode().

Here is the caller graph for this function:

LineToIndex()

int KeyView::LineToIndex ( int  line ) const

private

Definition at line 1132 of file KeyView.cpp.

{
   if (line < 0 || line >= (int) mLines.size())
   {
      return wxNOT_FOUND;
   }
 
   return mLines[line]->index;
}

References mLines.

Referenced by GetSelected(), OnKeyDown(), OnLeftDown(), RefreshBindings(), SetFilter(), and SetView().

Here is the caller graph for this function:

OnDrawBackground()

void KeyView::OnDrawBackground ( wxDC &  dc, const wxRect &  rect, size_t  line  ) const

overrideprivate

Definition at line 1162 of file KeyView.cpp.

{
   const KeyNode *node = mLines[line];
   wxRect r = rect;
   wxRect r2 = rect; // for just the key shortcut.
   wxCoord indent = 0;
 
   // When in tree view mode, each younger branch gets indented by the
   // width of the open/close bitmaps
   if (mViewType == ViewByTree)
   {
      indent += mKeyWidth + KV_COLUMN_SPACER + node->depth * KV_BITMAP_SIZE;
   }
 
   // Offset left side by the indentation (if any) and scroll amounts
   r.x = indent - mScrollX;
   r2.x = -mScrollX;
 
   // If the line width is less than the client width, then we want to
   // extend the background to the right edge of the client view.  Otherwise,
   // go all the way to the end of the line width...this will draw past the
   // right edge, but that's what we want.
   r.width = wxMax(mWidth, r.width);
   r2.width = mKeyWidth;
 
   // Selected lines get a solid background
   if (IsSelected(line))
   {
      if (FindFocus() == this)
      {
         // Focused lines get highlighted background
         dc.SetPen(*wxTRANSPARENT_PEN);
         dc.SetBrush(wxBrush(wxSystemSettings::GetColour(wxSYS_COLOUR_HIGHLIGHT)));
         dc.DrawRectangle(r);
         
         // and they also get a dotted focus rect.  This could just be left out.
         // The focus rect does very little for us, as it is the same size as the 
         // rectangle itself.  Consequently for themes that have black text it
         // disappears.  But on HiContrast you do get a dotted green border which
         // may have some utility.
         AColor::DrawFocus(dc, r);
 
         if (mViewType == ViewByTree){
            dc.DrawRectangle(r2);
            AColor::DrawFocus(dc, r2);
         }
      }
      else
      {
         // Non focused lines get a light background
         dc.SetPen(*wxTRANSPARENT_PEN);
         dc.SetBrush(wxBrush(wxSystemSettings::GetColour(wxSYS_COLOUR_BTNFACE)));
         dc.DrawRectangle(r);
         if (mViewType == ViewByTree)
            dc.DrawRectangle(r2);
      }
   }
   else
   {
      // Non-selected lines get a thin bottom border
      dc.SetPen(wxColour(240, 240, 240));
      AColor::Line(dc, r.GetLeft(), r.GetBottom(), r.GetRight(), r.GetBottom());
      if (mViewType == ViewByTree )
         AColor::Line(dc, r2.GetLeft(), r2.GetBottom(), r2.GetRight(), r2.GetBottom());
   }
}

References KeyNode::depth, AColor::DrawFocus(), BasicUI::FindFocus(), KV_BITMAP_SIZE, KV_COLUMN_SPACER, AColor::Line(), mKeyWidth, mLines, mScrollX, mViewType, mWidth, and ViewByTree.

Here is the call graph for this function:

OnDrawItem()

void KeyView::OnDrawItem ( wxDC &  dc, const wxRect &  rect, size_t  line  ) const

overrideprivate

Definition at line 1235 of file KeyView.cpp.

{
   const KeyNode *node = mLines[line];
   wxString label = node->label;
 
   // Make sure the DC has a valid font
   dc.SetFont(GetFont());
 
   // Set the text color based on selection and focus
   if (IsSelected(line) && FindFocus() == this)
   {
      dc.SetTextForeground(wxSystemSettings::GetColour(wxSYS_COLOUR_LISTBOXHIGHLIGHTTEXT));
   }
   else
   {
      dc.SetTextForeground(wxSystemSettings::GetColour(wxSYS_COLOUR_LISTBOXTEXT));
   }
 
   // Tree views get bitmaps
   if (mViewType == ViewByTree)
   {
      // Adjust left edge to account for scrolling
      wxCoord x = rect.x - mScrollX;
 
      if (node->iscat || node->ispfx)
      {
         wxCoord bx = x + mKeyWidth  + KV_COLUMN_SPACER;
         wxCoord by = rect.y;
 
         if (node->ispfx)
         {
            bx += KV_BITMAP_SIZE;
         }
 
         dc.SetBrush(*wxTRANSPARENT_BRUSH);
         dc.SetPen(*wxBLACK_PEN);
         dc.DrawRectangle(bx + 3, by + 4, 9, 9);
         if (node->isopen)
         {
            AColor::Line(dc, bx + 5, by + 8, bx + 9, by + 8);
         }
         else
         {
            AColor::Line(dc, bx + 7, by + 6, bx + 7, by + 10);
            AColor::Line(dc, bx + 5, by + 8, bx + 9, by + 8);
         }
      }
 
      // Indent text
      x += KV_LEFT_MARGIN;
 
      // Draw the key and command columns
      dc.DrawText(node->key.Display(), x , rect.y);
      dc.DrawText(label, x + mKeyWidth  + KV_COLUMN_SPACER + node->depth * KV_BITMAP_SIZE, rect.y);
   }
   else
   {
      // Adjust left edge by margin and account for scrolling
      wxCoord x = rect.x + KV_LEFT_MARGIN - mScrollX;
 
      // Prepend prefix if available
      if (!node->prefix.empty())
      {
         label = node->prefix + wxT(" - ") + label;
      }
 
      // don't swap the columns based on view type
      if((mViewType == ViewByName) || (mViewType == ViewByKey))
      {
         // Draw key columnd and then command column
         dc.DrawText(node->key.Display(), x, rect.y);
         dc.DrawText(label, x + mKeyWidth + KV_COLUMN_SPACER, rect.y);
      }
   }
 
   return;
}

References KeyNode::depth, NormalizedKeyString::Display(), BasicUI::FindFocus(), KeyNode::iscat, KeyNode::isopen, KeyNode::ispfx, KeyNode::key, KV_BITMAP_SIZE, KV_COLUMN_SPACER, KV_LEFT_MARGIN, label, KeyNode::label, AColor::Line(), mKeyWidth, mLines, mScrollX, mViewType, KeyNode::prefix, ViewByKey, ViewByName, ViewByTree, and wxT().

Here is the call graph for this function:

OnKeyDown()

void KeyView::OnKeyDown ( wxKeyEvent &  event )

private

Definition at line 1417 of file KeyView.cpp.

{
   int line = GetSelection();
 
   int keycode = event.GetKeyCode();
   switch (keycode)
   {
      // The LEFT key moves selection to parent or collapses selected
      // node if it is expanded.
      case WXK_LEFT:
      {
         // Nothing selected...nothing to do
         if (line == wxNOT_FOUND)
         {
            // Allow further processing
            event.Skip();
            break;
         }
 
         KeyNode *node = mLines[line];
 
         // Collapse the node if it is open
         if (node->isopen)
         {
            // No longer open
            node->isopen = false;
 
            // Don't want the view to scroll vertically, so remember the current
            // top line.
            size_t topline = GetVisibleBegin();
 
            // Refresh the view now that the number of lines have changed
            RefreshLines();
 
            // Reset the original top line
            ScrollToRow(topline);
 
            // And make sure current line is still selected
            SelectNode(LineToIndex(line));
         }
         else
         {
            // Move selection to the parent of this node
            for (int i = line - 1; i >= 0; i--)
            {
               // Found the parent
               if (mLines[i]->depth < node->depth)
               {
                  // So select it
                  SelectNode(LineToIndex(i));
                  break;
               }
            }
         }
 
         // Further processing of the event is not wanted
         // (we didn't call event.Skip()
      }
      break;
 
      // The RIGHT key moves the selection to the first child or expands
      // the node if it is a parent.
      case WXK_RIGHT:
      {
         // Nothing selected...nothing to do
         if (line == wxNOT_FOUND)
         {
            // Allow further processing
            event.Skip();
            break;
         }
 
         KeyNode *node = mLines[line];
 
         // Only want parent nodes
         if (node->isparent)
         {
            // It is open so move select to first child
            if (node->isopen)
            {
               // But only if there is one
               if (line < (int) mLines.size() - 1)
               {
                  SelectNode(LineToIndex(line + 1));
               }
            }
            else
            {
               // Node is now open
               node->isopen = true;
 
               // Don't want the view to scroll vertically, so remember the current
               // top line.
               size_t topline = GetVisibleBegin();
 
               // Refresh the view now that the number of lines have changed
               RefreshLines();
 
               // Reset the original top line
               ScrollToRow(topline);
 
               // And make sure current line is still selected
               SelectNode(LineToIndex(line));
            }
         }
 
         // Further processing of the event is not wanted
         // (we didn't call event.Skip()
      }
      break;
 
      // Move selection to next node whose 1st character matches
      // the keycode
      default:
      {
         int cnt = (int) mLines.size();
         bool found = false;
 
         // Search the entire list if none is currently selected
         if (line == wxNOT_FOUND)
         {
            line = cnt;
         }
         else
         {
            // Search from the node following the current one
            for (int i = line + 1; i < cnt; i++)
            {
               wxString label;
 
               // Get the string to search based on view type
               if (mViewType == ViewByTree)
               {
                  label = GetLabel(LineToIndex(i));
               }
               else if (mViewType == ViewByName)
               {
                  label = GetFullLabel(LineToIndex(i));
               }
               else if (mViewType == ViewByKey)
               {
                  label = GetKey(LineToIndex(i)).Display();
               }
 
               // Move selection if they match
               if (label.Left(1).IsSameAs(keycode, false))
               {
                  SelectNode(LineToIndex(i));
 
                  found = true;
 
                  break;
               }
            }
         }
 
         // A match wasn't found
         if (!found)
         {
            // So scan from the start of the list to the current node
            for (int i = 0; i < line; i++)
            {
               wxString label;
 
               // Get the string to search based on view type
               if (mViewType == ViewByTree)
               {
                  label = GetLabel(LineToIndex(i));
               }
               else if (mViewType == ViewByName)
               {
                  label = GetFullLabel(LineToIndex(i));
               }
               else if (mViewType == ViewByKey)
               {
                  label = GetKey(LineToIndex(i)).Display();
               }
 
               // Move selection if they match
               if (label.Left(1).IsSameAs(keycode, false))
               {
                  SelectNode(LineToIndex(i));
 
                  found = true;
 
                  break;
               }
            }
         }
 
         // A node wasn't found so allow further processing
         if (!found) {
            event.Skip();
         }
 
         // Otherwise, further processing of the event is not wanted
         // (we didn't call event.Skip()
      }
   }
}

References NormalizedKeyString::Display(), GetFullLabel(), GetKey(), GetLabel(), KeyNode::isopen, KeyNode::isparent, label, LineToIndex(), mLines, mViewType, RefreshLines(), SelectNode(), ViewByKey, ViewByName, and ViewByTree.

Here is the call graph for this function:

OnKillFocus()

void KeyView::OnKillFocus ( wxFocusEvent &  event )

private

Definition at line 1369 of file KeyView.cpp.

{
   // Allow further processing
   event.Skip();
 
   // Refresh the selected line to adjust visual highlighting.
   if (GetSelection() != wxNOT_FOUND)
   {
      RefreshRow(GetSelection());
   }
}

OnLeftDown()

void KeyView::OnLeftDown ( wxMouseEvent &  event )

private

Definition at line 1622 of file KeyView.cpp.

{
   // Only check if for tree view
   if (mViewType != ViewByTree)
   {
      // Allow further processing (important for focus handling)
      event.Skip();
 
      return;
   }
 
   // Get the mouse position when the button was pressed
   wxPoint pos = event.GetPosition();
 
   // And see if it was on a line within the view
   int line = VirtualHitTest(pos.y);
 
   // It was on a line
   if (line != wxNOT_FOUND)
   {
      KeyNode *node = mLines[line];
 
      // Toggle the open state if this is a parent node
      if (node->isparent)
      {
         // Toggle state
         node->isopen = !node->isopen;
 
         // Don't want the view to scroll vertically, so remember the current
         // top line.
         size_t topline = GetVisibleBegin();
 
         // Refresh the view now that the number of lines have changed
         RefreshLines();
 
         // Reset the original top line
         ScrollToRow(topline);
 
         // And make sure current line is still selected
         SelectNode(LineToIndex(line));
 
         // If a node is closed near the bottom of the tree,
         // the node may move down, and no longer be at the
         // mouse pointer position. So don't allow further processing as this
         // selects the line at the mouse position. Bug 1723.
         // So we need to set the focus.
         SetFocus();
         return;
      }
   }
 
   // Allow further processing (important for focus handling)
   event.Skip();
}

References KeyNode::isopen, KeyNode::isparent, LineToIndex(), mLines, mViewType, RefreshLines(), SelectNode(), BasicUI::SetFocus(), and ViewByTree.

Here is the call graph for this function:

OnMeasureItem()

wxCoord KeyView::OnMeasureItem ( size_t  line ) const

overrideprivate

Definition at line 1319 of file KeyView.cpp.

{
   // All lines are of equal height
   //
   // (add a magic 1 for decenders...looks better...not required)
   return mLineHeight + 1;
}

References mLineHeight.

OnScroll()

void KeyView::OnScroll ( wxScrollWinEvent &  event )

private

Definition at line 1395 of file KeyView.cpp.

{
   // We only care bout the horizontal scrollbar.
   if (event.GetOrientation() != wxHORIZONTAL)
   {
      // Allow further processing
      event.Skip();
      return;
   }
 
   // Get NEW scroll position and scroll the view
   mScrollX = event.GetPosition();
   SetScrollPos(wxHORIZONTAL, mScrollX);
 
   // Refresh the entire view
   RefreshAll();
}

References mScrollX, and RefreshCode::RefreshAll.

OnSelected()

void KeyView::OnSelected ( wxCommandEvent &  event )

private

Definition at line 1331 of file KeyView.cpp.

{
   // Allow further processing
   event.Skip();
 
#if wxUSE_ACCESSIBILITY
   // Tell accessibility of the change
   mAx->SetCurrentLine(event.GetInt());
#endif
}

OnSetFocus()

void KeyView::OnSetFocus ( wxFocusEvent &  event )

private

Definition at line 1346 of file KeyView.cpp.

{
   // Allow further processing
   event.Skip();
 
   // Refresh the selected line to pull in any changes while
   // focus was away...like when setting a NEW key value.  This
   // will also refresh the visual (highlighted) state.
   if (GetSelection() != wxNOT_FOUND)
   {
      RefreshRow(GetSelection());
   }
 
#if wxUSE_ACCESSIBILITY
   // Tell accessibility of the change
   mAx->SetCurrentLine(GetSelection());
#endif
}

OnSize()

void KeyView::OnSize ( wxSizeEvent &  event )

private

Definition at line 1385 of file KeyView.cpp.

{
   // Update horizontal scrollbar
   UpdateHScroll();
}

References UpdateHScroll().

Here is the call graph for this function:

RecalcExtents()

void KeyView::RecalcExtents ( )

private

Definition at line 547 of file KeyView.cpp.

{
   // Reset
   mLineHeight = 0;
   mCommandWidth = 0;
   mKeyWidth = 0;
 
   // Examine all nodes
   int cnt = (int) mNodes.size();
   for (int i = 0; i < cnt; i++)
   {
      KeyNode & node = mNodes[i];
      int x, y;
 
      if (node.iscat)
      {
         // Measure the category
         GetTextExtent(node.category, &x, &y);
      }
      else if (node.ispfx)
      {
         // Measure the prefix
         GetTextExtent(node.prefix, &x, &y);
      }
      else
      {
         // Measure the key
         GetTextExtent(node.key.Display(), &x, &y);
         mLineHeight = wxMax(mLineHeight, y);
         mKeyWidth = wxMax(mKeyWidth, x);
 
         // Prepend prefix for view types other than tree
         wxString label = node.label;
         if (mViewType != ViewByTree && !node.prefix.empty())
         {
            label = node.prefix + wxT(" - ") + label;
         }
 
         // Measure the label
         GetTextExtent(label, &x, &y);
      }
 
      // Finish calc for command column
      mLineHeight = wxMax(mLineHeight, y);
      mCommandWidth = wxMax(mCommandWidth, x);
   }
 
   // Update horizontal scrollbar
   UpdateHScroll();
}

References KeyNode::category, NormalizedKeyString::Display(), KeyNode::iscat, KeyNode::ispfx, KeyNode::key, label, KeyNode::label, mCommandWidth, mKeyWidth, mLineHeight, mNodes, mViewType, KeyNode::prefix, UpdateHScroll(), ViewByTree, and wxT().

Referenced by SetKey().

Here is the call graph for this function:

Here is the caller graph for this function:

RefreshBindings()

void KeyView::RefreshBindings	(	const CommandIDs &	names,
		const TranslatableStrings &	categories,
		const TranslatableStrings &	prefixes,
		const TranslatableStrings &	labels,
		const std::vector< NormalizedKeyString > &	keys,
		bool	bSort
	)

Definition at line 636 of file KeyView.cpp.

{
   // Start clean
   mNodes.clear();
 
   // Same as in RecalcExtents() but do it inline
   mLineHeight = 0;
   mKeyWidth = 0;
   mCommandWidth = 0;
 
   wxString lastcat;
   wxString lastpfx;
   int nodecnt = 0;
   int depth = 1;
   bool incat = false;
   bool inpfx = false;
 
   // lookup translation once only
   CommandTranslated = _("Command");
 
   // Examine all names...all arrays passed have the same indexes
   int cnt = (int) names.size();
   for (int i = 0; i < cnt; i++)
   {
      auto name = names[i];
      int x, y;
 
      // Remove any menu code from the category and prefix
      wxString cat = categories[i].Translation();
      wxString pfx = prefixes[i].Translation();
 
      // Append "Menu" this node is for a menu title
      if (cat != CommandTranslated)
      {
         cat.Append(wxT(" "));
         cat += _("Menu");
      }
 
      // Process a NEW category
      if (cat != lastcat)
      {
         // A NEW category always finishes any current subtree
         if (inpfx)
         {
            // Back to category level
            depth--;
            inpfx = false;
         }
 
         // Only time this is not true is during the first iteration
         if (incat)
         {
            // Back to root level
            depth--;
            incat = false;
         }
 
         // Remember for next iteration
         lastcat = cat;
 
         // Add a NEW category node
         if (!cat.empty())
         {
            KeyNode node;
 
            // Fill in the node info
            node.name = CommandID{};    // don't associate branches with a command
            node.category = cat;
            node.prefix = pfx;
            node.label = cat;
            node.index = nodecnt++;
            node.iscat = true;
            node.isparent = true;
            node.depth = depth++;
            node.isopen = true;
 
            // Add it to the tree
            mNodes.push_back(node);
            incat = true;
 
            // Measure category
            GetTextExtent(cat, &x, &y);
            mLineHeight = wxMax(mLineHeight, y);
            mCommandWidth = wxMax(mCommandWidth, x);
         }
      }
 
      // Process a NEW prefix
      if (pfx != lastpfx)
      {
         // Done with prefix branch
         if (inpfx)
         {
            depth--;
            inpfx = false;
         }
 
         // Remember for next iteration
         lastpfx = pfx;
 
         // Add a NEW prefix node
         if (!pfx.empty())
         {
            KeyNode node;
 
            // Fill in the node info
            node.name = CommandID{};    // don't associate branches with a command
            node.category = cat;
            node.prefix = pfx;
            node.label = pfx;
            node.index = nodecnt++;
            node.ispfx = true;
            node.isparent = true;
            node.depth = depth++;
            node.isopen = true;
 
            // Add it to the tree
            mNodes.push_back(node);
            inpfx = true;
         }
      }
 
      // Add the key entry
      KeyNode node;
      node.category = cat;
      node.prefix = pfx;
 
      // Labels for undo and redo change according to the last command
      // which can be undone/redone, so give them a special check in order
      // not to confuse users
      if (name == wxT("Undo"))
      {
         node.label = _("Undo");
      }
      else if (name == wxT("Redo"))
      {
         node.label = _("Redo");
      }
      else
      {
         auto label = labels[i];
         node.label = label.Strip().Translation();
      }
 
      // Fill in remaining info
      node.name = name;
      node.key = keys[i];
      node.index = nodecnt++;
      node.depth = depth;
 
      // Add it to the tree
      mNodes.push_back(node);
 
      // Measure key
      GetTextExtent(node.key.Display(), &x, &y);
      mLineHeight = wxMax(mLineHeight, y);
      mKeyWidth = wxMax(mKeyWidth, x);
 
      // Prepend prefix for all view types to determine maximum
      // column widths
      wxString label = node.label;
      if (!node.prefix.empty())
      {
         label = node.prefix + wxT(" - ") + label;
      }
 
      // Measure label
      GetTextExtent(label, &x, &y);
      mLineHeight = wxMax(mLineHeight, y);
      mCommandWidth = wxMax(mCommandWidth, x);
   }
 
#if 0
   // For debugging
   for (int j = 0; j < mNodes.size(); j++)
   {
      KeyNode & node = mNodes[j];
      wxLogDebug(wxT("NODE line %4d index %4d depth %1d open %1d parent %1d cat %1d pfx %1d name %s STR %s | %s | %s"),
         node.line,
         node.index,
         node.depth,
         node.isopen,
         node.isparent,
         node.iscat,
         node.ispfx,
         node.name,
         node.category,
         node.prefix,
         node.label);
   }
#endif
 
   // Update horizontal scrollbar
   UpdateHScroll();
 
   // Refresh the view lines
   RefreshLines(bSort);
 
   // Set the selected node if we've just reprepared the list and nothing was selected.
   if ((GetSelection()==wxNOT_FOUND) && bSort )
   {
      SelectNode(LineToIndex(0));
   }
}

References _, KeyNode::category, CommandTranslated, KeyNode::depth, NormalizedKeyString::Display(), KeyNode::index, KeyNode::iscat, KeyNode::isopen, KeyNode::isparent, KeyNode::ispfx, KeyNode::key, label, KeyNode::label, KeyNode::line, LineToIndex(), mCommandWidth, mKeyWidth, mLineHeight, mNodes, name, KeyNode::name, names, KeyNode::prefix, RefreshLines(), SelectNode(), TranslatableString::Strip(), TranslatableString::Translation(), UpdateHScroll(), and wxT().

Referenced by KeyConfigPrefs::RefreshBindings().

Here is the call graph for this function:

Here is the caller graph for this function:

RefreshLines()

void KeyView::RefreshLines ( bool  bSort = true )

private

Definition at line 851 of file KeyView.cpp.

{
   int cnt = (int) mNodes.size();
   int linecnt = 0;
   mLines.clear();
 
   // Process a filter if one is set
   if (!mFilter.empty())
   {
      // Examine all nodes
      for (int i = 0; i < cnt; i++)
      {
         KeyNode & node = mNodes[i];
 
         // Reset line number
         node.line = wxNOT_FOUND;
 
         // Search columns based on view type
         wxString searchit;
         switch (mViewType)
         {
            // The x"01" separator is used to prevent finding a
            // match comprising the end of the label and beginning
            // of the key.  It was chosen since it's not very likely
            // to appear in the filter itself.
            case ViewByTree:
               searchit = node.label.Lower() +
                          wxT("\01x") +
                          node.key.Display().Lower();
            break;
 
            case ViewByName:
               searchit = node.label.Lower();
            break;
 
            case ViewByKey:
               searchit = node.key.Display().Lower();
            break;
         }
         if (searchit.Find(mFilter) == wxNOT_FOUND)
         {
            // Not found so continue to next node
            continue;
         }
 
         // For the Key View, if the filter is a single character,
         // then it has to be the last character in the searchit string,
         // and be preceded by nothing or +.
         if ((mViewType == ViewByKey) &&
               (mFilter.length() == 1) &&
               (mFilter != searchit.Last() ||
                  ((searchit.length() > 1) &&
                     ((wxString)(searchit.GetChar(searchit.length() - 2)) != wxT("+")))))
         {
            // Not suitable so continue to next node
            continue;
         }
 
         // For tree view, we must make sure all parent nodes are included
         // whether they match the filter or not.
         if (mViewType == ViewByTree)
         {
            std::vector<KeyNode*> queue;
            int depth = node.depth;
 
            // This node is a category or prefix node, so always mark them
            // as open.
            //
            // What this is really doing is resolving a situation where the
            // the filter matches a parent node and nothing underneath.  In
            // this case, the node would never be marked as open.
            if (node.isparent)
            {
               node.isopen = true;
            }
 
            // Examine siblings until a parent is found.
            for (int j = node.index - 1; j >= 0 && depth > 0; j--)
            {
               // Found a parent
               if (mNodes[j].depth < depth)
               {
                  // Examine all previously added nodes to see if this nodes
                  // ancestors need to be added prior to adding this node.
                  bool found = false;
                  for (int k = (int) mLines.size() - 1; k >= 0; k--)
                  {
                     // The node indexes match, so we've found the parent of the
                     // child node.
                     if (mLines[k]->index == mNodes[j].index)
                     {
                        found = true;
                        break;
                     }
                  }
 
                  // The parent wasn't found so remember it for later
                  // addition.  Can't add directory to mLines here since
                  // they will wind up in reverse order.
                  if (!found)
                  {
                     queue.push_back(&mNodes[j]);
                  }
 
                  // Traverse up the tree
                  depth = mNodes[j].depth;
               }
            }
 
            // Add any queues nodes to list.  This will all be
            // parent nodes, so mark them as open.
            for (int j = (int) queue.size() - 1; j >= 0; j--)
            {
               queue[j]->isopen = true;
               queue[j]->line = linecnt++;
               mLines.push_back(queue[j]);
            }
         }
 
         // Finally add the child node
         node.line = linecnt++;
         mLines.push_back(&node);
      }
   }
   else
   {
      // Examine all nodes - non-filtered
      for (int i = 0; i < cnt; i++)
      {
         KeyNode & node = mNodes[i];
 
         // Reset line number
         node.line = wxNOT_FOUND;
 
         // Node is either a category or prefix
         if (node.isparent)
         {
            // Only need to do this for tree views
            if (mViewType != ViewByTree)
            {
               continue;
            }
 
            // Add the node
            node.line = linecnt++;
            mLines.push_back(&node);
 
            // If this node is not open, then skip all of its descendants
            if (!node.isopen)
            {
               bool iscat = node.iscat;
               bool ispfx = node.ispfx;
 
               // Skip nodes until we find a node that has a different
               // category or prefix
               while (i < cnt)
               {
                  KeyNode & skip = mNodes[i];
 
                  if ((iscat && skip.category != node.category) ||
                      (ispfx && skip.prefix != node.prefix))
                  {
                     break;
                  }
 
                  // Bump to next node
                  i++;
               }
 
               // Index is pointing to the node that was different or
               // past the end, so back off to last node of this branch.
               i--;
            }
            continue;
         }
 
         // Add child node to list
         node.line = linecnt++;
         mLines.push_back(&node);
      }
   }
 
   // Sorting is costly.  If bSort is false, we do not have to sort.
   // bSort false means we know that the list will be updated again before
   // the user needs to see it.
   if( bSort )
   {
      //To see how many lines are being sorted (and how often).
      //wxLogDebug("Sorting %i lines for type %i", mLines.size(), mViewType);
 
      // Speed up the comparison function used in sorting
      // by only translating this string once.
      CommandTranslated = _("Command");
 
      // Sort list based on type
      switch (mViewType)
      {
         case ViewByTree:
            std::sort(mLines.begin(), mLines.end(), CmpKeyNodeByTree);
         break;
 
         case ViewByName:
            std::sort(mLines.begin(), mLines.end(), CmpKeyNodeByName);
         break;
 
         case ViewByKey:
            std::sort(mLines.begin(), mLines.end(), CmpKeyNodeByKey);
         break;
      }
   }
 
   // Now, reassign the line numbers
   for (int i = 0; i < (int) mLines.size(); i++)
   {
      mLines[i]->line = i;
   }
 
#if 0
   // For debugging
   for (int j = 0; j < mLines.size(); j++)
   {
      KeyNode & node = *mLines[j];
      wxLogDebug(wxT("LINE line %4d index %4d depth %1d open %1d parent %1d cat %1d pfx %1d name %s STR %s | %s | %s"),
         node.line,
         node.index,
         node.depth,
         node.isopen,
         node.isparent,
         node.iscat,
         node.ispfx,
         node.name,
         node.category,
         node.prefix,
         node.label);
   }
#endif
 
   // Tell listbox the NEW count and refresh the entire view
   SetItemCount(mLines.size());
   RefreshAll();
 
#if wxUSE_ACCESSIBILITY
   // Let accessibility know that the list has changed
   if( bSort )
      mAx->ListUpdated();
#endif
}

References _, KeyNode::category, CmpKeyNodeByKey(), CmpKeyNodeByName(), CmpKeyNodeByTree(), CommandTranslated, KeyNode::depth, NormalizedKeyString::Display(), KeyNode::index, KeyNode::iscat, KeyNode::isopen, KeyNode::isparent, KeyNode::ispfx, KeyNode::key, KeyNode::label, KeyNode::line, mFilter, mLines, mNodes, mViewType, KeyNode::name, KeyNode::prefix, RefreshCode::RefreshAll, ViewByKey, ViewByName, ViewByTree, and wxT().

Referenced by CollapseAll(), ExpandAll(), OnKeyDown(), OnLeftDown(), RefreshBindings(), SetFilter(), and SetView().

Here is the call graph for this function:

Here is the caller graph for this function:

SelectNode()

void KeyView::SelectNode

(

int

index

)

Definition at line 1105 of file KeyView.cpp.

{
   int line = IndexToLine(index);
 
   // Tell the listbox to select the line
   SetSelection(line);
 
#if wxUSE_ACCESSIBILITY
   // And accessibility
   mAx->SetCurrentLine(line);
#endif
 
   // Always send an event to let parent know of selection change
   //
   // Must do this ourselves because we want to send notifications
   // even if there isn't an item selected and SendSelectedEvent()
   // doesn't allow sending an event for indexes not in the listbox.
   wxCommandEvent event(wxEVT_COMMAND_LISTBOX_SELECTED, GetId());
   event.SetEventObject(this);
   event.SetInt(line);
   (void)GetEventHandler()->ProcessEvent(event);
}

References IndexToLine().

Referenced by OnKeyDown(), OnLeftDown(), RefreshBindings(), SetFilter(), and SetView().

Here is the call graph for this function:

Here is the caller graph for this function:

SetFilter()

void KeyView::SetFilter

(

const wxString &

filter

)

Definition at line 472 of file KeyView.cpp.

{
   int index = LineToIndex(GetSelection());
 
   // Unselect any currently selected line...do even if none selected
   SelectNode(-1);
 
   // Save the filter
   mFilter = filter.Lower();
 
   // Refresh the view lines
   RefreshLines();
 
   // Reselect old node (if possible)
   if (index != wxNOT_FOUND)
   {
      SelectNode(index);
   }
 
   // ensure that a node is selected so that when the keyview is the focus,
   // this is indicated visually, and the Narrator screen reader reads it.
   if ((GetSelection() == wxNOT_FOUND))
   {
      SelectNode(LineToIndex(0));
   }
}

References LineToIndex(), mFilter, RefreshLines(), and SelectNode().

Referenced by KeyConfigPrefs::OnFilterKeyDown(), and KeyConfigPrefs::OnFilterTimer().

Here is the call graph for this function:

Here is the caller graph for this function:

SetKey()

bool KeyView::SetKey	(	int	index,
		const NormalizedKeyString &	key
	)

Definition at line 355 of file KeyView.cpp.

{
   // Make sure index is valid
   if (index < 0 || index >= (int) mNodes.size())
   {
      wxASSERT(false);
      return false;
   }
 
   // Cache the node
   KeyNode & node = mNodes[index];
 
   // Do not allow setting keys on branches
   if (node.isparent)
   {
      return false;
   }
 
   // Set the NEW key
   node.key = key;
 
   // Check to see if the key column needs to be expanded
   int x, y;
   GetTextExtent(node.key.Display(), &x, &y);
   if (x > mKeyWidth || y > mLineHeight)
   {
      // New key is wider than column so recalc extents (will refresh view)
      RecalcExtents();
      return true;
   }
 
   // Refresh the view lines
   RefreshAll();
 
   return true;
}

References NormalizedKeyString::Display(), KeyNode::isparent, key, KeyNode::key, mKeyWidth, mLineHeight, mNodes, RecalcExtents(), and RefreshCode::RefreshAll.

Referenced by SetKeyByName(), and KeyConfigPrefs::SetKeyForSelected().

Here is the call graph for this function:

Here is the caller graph for this function:

SetKeyByName()

bool KeyView::SetKeyByName	(	const CommandID &	name,
		const NormalizedKeyString &	key
	)

Definition at line 396 of file KeyView.cpp.

{
   int index = GetIndexByName(name);
 
   // Bail is the name wasn't found
   if (index == wxNOT_FOUND)
   {
      return false;
   }
 
   // Go set the key
   return SetKey(index, key);
}

References GetIndexByName(), key, name, and SetKey().

Referenced by KeyConfigPrefs::OnSet().

Here is the call graph for this function:

Here is the caller graph for this function:

SetView()

void KeyView::SetView

(

ViewByType

type

)

Definition at line 414 of file KeyView.cpp.

{
   int index = LineToIndex(GetSelection());
 
   // Handle an existing selection
   if (index != wxNOT_FOUND)
   {
      // Cache the currently selected node
      KeyNode & node = mNodes[index];
 
      // Expand branches if switching to Tree view and a line
      // is currently selected
      if (type == ViewByTree)
      {
         // Cache the node's depth
         int depth = node.depth;
 
         // Search for its parents, setting each one as open
         for (int i = node.index - 1; i >= 0 && depth > 1; i--)
         {
            if (mNodes[i].depth < depth)
            {
               mNodes[i].isopen = true;
               depth = mNodes[i].depth;
            }
         }
      }
   }
 
   // Unselect any currently selected line...do even if none selected
   SelectNode(-1);
 
   // Save NEW type
   mViewType = type;
 
   // Refresh the view lines
   RefreshLines();
 
   // Reselect old node (if possible)
   if (index != wxNOT_FOUND)
   {
      SelectNode(index);
   }
 
   // ensure that a node is selected so that when the keyview is the focus,
   // this is indicated visually, and the Narrator screen reader reads it.
   if ((GetSelection() == wxNOT_FOUND))
   {
      SelectNode(LineToIndex(0));
   }
 
   return;
}

References KeyNode::depth, KeyNode::index, LineToIndex(), mNodes, mViewType, RefreshLines(), SelectNode(), and ViewByTree.

Referenced by KeyConfigPrefs::OnViewBy(), and KeyConfigPrefs::Populate().

Here is the call graph for this function:

Here is the caller graph for this function:

UpdateHScroll()

void KeyView::UpdateHScroll ( )

private

Definition at line 602 of file KeyView.cpp.

{
   // Get the internal dimensions of the view
   wxRect r = GetClientRect();
 
   // Calculate the full line width
   mWidth = KV_LEFT_MARGIN +
            mKeyWidth +
            KV_COLUMN_SPACER +
            mCommandWidth +
            KV_VSCROLL_WIDTH;
 
   // Retrieve the current horizontal scroll amount
   mScrollX = GetScrollPos(wxHORIZONTAL);
 
   if (mWidth <= r.GetWidth())
   {
      // Remove the scrollbar if it will fit within client width
      SetScrollbar(wxHORIZONTAL, 0, 0, 0);
   }
   else
   {
      // Set scrollbar metrics
      SetScrollbar(wxHORIZONTAL, mScrollX, r.GetWidth(), mWidth);
   }
 
   // Refresh the entire view
   RefreshAll();
}

References KV_COLUMN_SPACER, KV_LEFT_MARGIN, KV_VSCROLL_WIDTH, mCommandWidth, mKeyWidth, mScrollX, mWidth, and RefreshCode::RefreshAll.

Referenced by OnSize(), RecalcExtents(), and RefreshBindings().

Here is the caller graph for this function:

Member Data Documentation

mCommandWidth

int KeyView::mCommandWidth

private

Definition at line 161 of file KeyView.h.

Referenced by RecalcExtents(), RefreshBindings(), and UpdateHScroll().

mFilter

wxString KeyView::mFilter

private

Definition at line 153 of file KeyView.h.

Referenced by RefreshLines(), and SetFilter().

mKeyWidth

wxCoord KeyView::mKeyWidth

private

Definition at line 162 of file KeyView.h.

Referenced by OnDrawBackground(), OnDrawItem(), RecalcExtents(), RefreshBindings(), SetKey(), and UpdateHScroll().

mKeyX

wxCoord KeyView::mKeyX

private

Definition at line 160 of file KeyView.h.

mLineCount

size_t KeyView::mLineCount

private

Definition at line 158 of file KeyView.h.

mLineHeight

wxCoord KeyView::mLineHeight

private

Definition at line 159 of file KeyView.h.

Referenced by OnMeasureItem(), RecalcExtents(), RefreshBindings(), and SetKey().

mLines

std::vector<KeyNode*> KeyView::mLines

private

Definition at line 150 of file KeyView.h.

Referenced by LineToIndex(), OnDrawBackground(), OnDrawItem(), OnKeyDown(), OnLeftDown(), and RefreshLines().

mNodes

std::vector<KeyNode> KeyView::mNodes

private

Definition at line 149 of file KeyView.h.

Referenced by CanSetKey(), CollapseAll(), ExpandAll(), GetFullLabel(), GetIndexByKey(), GetIndexByName(), GetKey(), GetLabel(), GetName(), GetNameByKey(), IndexToLine(), RecalcExtents(), RefreshBindings(), RefreshLines(), SetKey(), and SetView().

mScrollX

wxCoord KeyView::mScrollX

private

Definition at line 155 of file KeyView.h.

Referenced by OnDrawBackground(), OnDrawItem(), OnScroll(), and UpdateHScroll().

mViewType

ViewByType KeyView::mViewType

private

Definition at line 152 of file KeyView.h.

Referenced by OnDrawBackground(), OnDrawItem(), OnKeyDown(), OnLeftDown(), RecalcExtents(), RefreshLines(), and SetView().

mWidth

wxCoord KeyView::mWidth

private

Definition at line 156 of file KeyView.h.

Referenced by OnDrawBackground(), and UpdateHScroll().

---

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

• KeyView.h
• KeyView.cpp