{

KeyViewAx(KeyView *view);

void SetCurrentLine(int row);

void ListUpdated();

bool LineToId(int line, int & childId);

bool IdToLine(int childId, int & line);

// Can return either a child object, or an integer

// representing the child element, starting from 1.

wxAccStatus HitTest(const wxPoint & pt, int *childId, wxAccessible **childObject) override;

// Retrieves the address of an IDispatch interface for the specified child.

// All objects must support this property.

wxAccStatus GetChild(int childId, wxAccessible **child) override;

// Gets the number of children.

wxAccStatus GetChildCount(int *childCount) override;

// Gets the default action for this object (0) or > 0 (the action for a child).

// Return wxACC_OK even if there is no action. actionName is the action, or the empty

// string if there is no action.

// The retrieved string describes the action that is performed on an object,

// not what the object does as a result. For example, a toolbar button that prints

// a document has a default action of "Press" rather than "Prints the current document."

wxAccStatus GetDefaultAction(int childId, wxString *actionName) override;

// Returns the description for this object or a child.

wxAccStatus GetDescription(int childId, wxString *description) override;

// Gets the window with the keyboard focus.

// If childId is 0 and child is NULL, no object in

// this subhierarchy has the focus.

// If this object has the focus, child should be 'this'.

wxAccStatus GetFocus(int *childId, wxAccessible **child) override;

// Returns help text for this object or a child, similar to tooltip text.

wxAccStatus GetHelpText(int childId, wxString *helpText) override;

// Returns the keyboard shortcut for this object or child.

// Return e.g. ALT+K

wxAccStatus GetKeyboardShortcut(int childId, wxString *shortcut) override;

// Returns the rectangle for this object (id = 0) or a child element (id > 0).

// rect is in screen coordinates.

wxAccStatus GetLocation(wxRect & rect, int elementId) override;

// Navigates from fromId to toId/toObject.

wxAccStatus Navigate(wxNavDir navDir, int fromId,

int *toId, wxAccessible **toObject) override;

// Gets the name of the specified object.

wxAccStatus GetName(int childId, wxString *name) override;

// Gets the parent, or NULL.

wxAccStatus GetParent(wxAccessible **parent) override;

// Returns a role constant.

wxAccStatus GetRole(int childId, wxAccRole *role) override;

// Gets a variant representing the selected children

// of this object.

// Acceptable values:

// - a null variant (IsNull() returns TRUE)

// - a list variant (GetType() == wxT("list"))

// - an integer representing the selected child element,

// or 0 if this object is selected (GetType() == wxT("long"))

// - a "void*" pointer to a wxAccessible child object

wxAccStatus GetSelections(wxVariant *selections) override;

// Returns a state constant.

wxAccStatus GetState(int childId, long *state) override;

// Returns a localized string representing the value for the object

// or child.

wxAccStatus GetValue(int childId, wxString *strValue) override;

#if defined(__WXMAC__)

// Selects the object or child.

wxAccStatus Select(int childId, wxAccSelectionFlags selectFlags) override;

#endif

KeyView *mView;

int mLastId;

wxWindowID id,

const wxPoint & pos,

const wxSize & size)

: 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();

{

// Just forward request

return wxVListBox::GetName();

{

// Make sure index is valid

if (index < 0 || index >= (int) mNodes.size())

{

wxASSERT(false);

return wxEmptyString;

}

return mNodes[index].label;

{

// 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;

{

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;

{

// Make sure index is valid

if (index < 0 || index >= (int) mNodes.size())

{

wxASSERT(false);

return {};

}

return mNodes[index].name;

{

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 {};

{

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;

{

// Make sure index is valid

if (index < 0 || index >= (int) mNodes.size())

{

wxASSERT(false);

return {};

}

return mNodes[index].key;

{

// 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;

{

// 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;

{

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);

{

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;

{

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));

}

{

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();

{

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();

{

// 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();

{

// 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();

const TranslatableStrings & categories,

const TranslatableStrings & prefixes,

const TranslatableStrings & labels,

const std::vector<NormalizedKeyString> & keys,

bool bSort

)

{

// 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));

}

{

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)

{