Question

I want a few menu entries that show accelerators that are normal keys, like the space-bar or comma key, but I don’t want wxWidgets to make those accelerators itself (because then they can’t be used anywhere in the program, including in things like edit boxes).

Unfortunately, wxWidgets insists on always making anything it recognizes in that column into an accelerator under its control, and simply erases anything it doesn’t recognize.

I’m looking for some way to either put arbitrary text into the accelerator column (which I don’t think exists, I’ve looked at the source code), or get ‘hold of the accelerator table used for the menus so I can modify it myself (haven’t found it yet). Can anyone point me in the right direction?

Answer 1

I couldn’t find a way to access the menu’s accelerator keys directly, but modifying the accelerator menu text works just as well. Here’s the code I came up with:

In a header file:

class accel_t {
    public:
    // If idcount == -1, idlist must be null or terminated with a -1 entry.
    accel_t(): mMenu(0) { }
    accel_t(wxMenuBar *m, int *idlist = 0, int idcount = -1);
    void reset(wxMenuBar *m, int *idlist = 0, int idcount = -1);
    void restore() const;
    void remove() const;

    private: //
    struct accelitem_t {
        accelitem_t(int _id, wxAcceleratorEntry _key): id(_id), hotkey(_key) { }
        int id;
        wxAcceleratorEntry hotkey;
    };
    typedef std::vector<accelitem_t> data_t;

    void noteProblemMenuItems(wxMenu *m);
    static bool isProblemAccelerator(wxAcceleratorEntry *a);

    wxMenuBar *mMenu;
    data_t mData;
};

In a cpp file:

accel_t::accel_t(wxMenuBar *m, int *idlist, int idcount) {
    reset(m, idlist, idcount);
}

void accel_t::reset(wxMenuBar *m, int *idlist, int idcount) {
    mMenu = m;
    mData.clear();
    if (idlist == 0) {
        for (int i = 0, ie = m->GetMenuCount(); i != ie; ++i)
            noteProblemMenuItems(m->GetMenu(i));
    } else {
        if (idcount < 0) {
            int *i = idlist;
            while (*i != -1) ++i;
            idcount = (i - idlist);
        }

        for (int *i = idlist, *ie = i + idcount; i != ie; ++i) {
            wxMenuItem *item = mMenu->FindItem(*i);
            if (item) {
                wxAcceleratorEntry *a = item->GetAccel();
                if (a != 0) mData.push_back(accelitem_t(*i, *a));
            }
        }
    }
}

bool accel_t::isProblemAccelerator(wxAcceleratorEntry *a) {
    if (a == 0) return false;
    int flags = a->GetFlags(), keycode = a->GetKeyCode();

    // Normal ASCII characters, when used with no modifier or Shift-only, would
    // interfere with editing.
    if ((flags == wxACCEL_NORMAL || flags == wxACCEL_SHIFT) &&
        (keycode >= 32 && keycode < 127)) return true;

    // Certain other values, when used as normal accelerators, could cause
    // problems too.
    if (flags == wxACCEL_NORMAL) {
        if (keycode == WXK_RETURN ||
            keycode == WXK_DELETE ||
            keycode == WXK_BACK) return true;
    }

    return false;
}

void accel_t::noteProblemMenuItems(wxMenu *m) {
    // Problem menu items have hotkeys that are ASCII characters with normal or
    // shift-only modifiers.
    for (size_t i = 0, ie = m->GetMenuItemCount(); i != ie; ++i) {
        wxMenuItem *item = m->FindItemByPosition(i);
        if (item->IsSubMenu())
            noteProblemMenuItems(item->GetSubMenu());
        else {
            wxAcceleratorEntry *a = item->GetAccel();
            if (isProblemAccelerator(a))
                mData.push_back(accelitem_t(item->GetId(), *a));
        }
    }
}

void accel_t::restore() const {
    if (mMenu == 0) return;
    for (data_t::const_iterator i = mData.begin(), ie = mData.end(); i != ie;
        ++i)
    {
        wxMenuItem *item = mMenu->FindItem(i->id);
        if (item) {
            wxString text = item->GetItemLabel().BeforeFirst(wxT('\t'));
            wxString hotkey = i->hotkey.ToString();
            if (hotkey.empty()) {
                // The wxWidgets authors apparently don't expect ASCII
                // characters to be used for accelerators, because
                // wxAcceleratorEntry::ToString just returns an empty string for
                // them. This code deals with that.
                int flags = i->hotkey.GetFlags(), key = i->hotkey.GetKeyCode();
                if (flags == wxACCEL_SHIFT) hotkey = wx("Shift-") + wxChar(key);
                else hotkey = wxChar(key);
            }
            item->SetItemLabel(text + '\t' + hotkey);
        }
    }
}

void accel_t::remove() const {
    if (mMenu == 0) return;
    for (data_t::const_iterator i = mData.begin(), ie = mData.end(); i != ie;
        ++i)
    {
        wxMenuItem *item = mMenu->FindItem(i->id);
        if (item) {
            wxString text = item->GetItemLabel().BeforeFirst(wxT('\t'));
            item->SetItemLabel(text);
        }
    }
}

The easiest way to use it is to create your menu-bar as normal, with all accelerator keys (including the problematic ones) in place, then create an accel_t item from it something like this:

// mProblemAccelerators is an accel_t item in the private part of my frame class.
// This code is in the frame class's constructor.
wxMenuBar *menubar = _createMenuBar();
SetMenuBar(menubar);
mProblemAccelerators.reset(menubar);

It will identify and record the accelerator keys that pose problems. Finally, call the remove and restore functions as needed, to remove or restore the problematic accelerator keys. I’m calling them via messages passed to the frame whenever I open a window that needs to do standard editing.