ev.errorMessage(N_("Unknown function!"));
break;
- default:
+ default:
return bv_->getLyXText()->dispatch(FuncRequest(ev, bv_));
} // end of switch
+2003-09-22 Lars Gullik Bjønnes <larsbj@gullik.net>
+
+ * lyxfunc.C (processKeySym): adjust
+ (dispatch): adjust
+ (dispatch): change arg name from ev to func, adjust
+ (sendDispatchMessage): ditto
+
+ * lyx_main.C (defaultKeyBindings): adjust keybindings
+ (deadKeyBindings): ditto
+
+ * kbsequence.C (addkey): return a FuncRequest
+
+ * kbmap.h (kb_key): struct var FuncRequest instead of int action.
+
+ * kbmap.C (bind): take a FuncRequest as arg, adjust
+ (read): adjust
+ (lookup): adjust
+ (defkey): change to take a FuncRequest as arg, adjust
+ (findbinding): take a FuncRequest as arg, adjust.
+
+ * funcrequest.h (operator=): added
+
+ * funcrequest.C (FuncRequest): default kb_action changed from
+ LFUN_UNKNOWN_ACTION to LFUN_NO_ACTION
+
+ * buffer.C (dispatch): simplify
+ (dispatch): adjust to take a FuncRequest as arg, adjust
+
+ * boost.C (assertion_failed): change assertion message slightly
+
+ * ToolbarBackend.C (read): simplify
+
+ * MenuBackend.C (binding): adjust call to findbinding, add a
+ message if no binding is found.
+ (read): simplify
+ (expandToc): correct by adding a empty FuncRequest
+
+ * LyXAction.C: include <boost/assert.hpp>
+ (isPseudoAction): delete function
+ (LookupFunc): change name to...
+ (lookupFunc): this. change return type to FuncRequest.
+ (getActionName): take kb_action as arg, simplify
+ (funcHasFlag): add an assert, simplify.
+
2003-09-21 Lars Gullik Bjønnes <larsbj@gullik.net>
* toc.C (action): return a FuncRequest, simplify
#include "support/lstrings.h"
+#include <boost/assert.hpp>
+
using lyx::support::split;
using lyx::support::trim;
LyXAction lyxaction;
-namespace {
-
-/// return true if the given action is a pseudo-action
-inline bool isPseudoAction(int a)
-{
- return a > int(LFUN_LASTACTION);
-}
-
-}
-
void LyXAction::newFunc(kb_action action, string const & name,
unsigned int attrib)
// Returns an action tag from a string.
-kb_action LyXAction::LookupFunc(string const & func)
+FuncRequest LyXAction::lookupFunc(string const & func) const
{
string const func2 = trim(func);
- if (func2.empty()) return LFUN_NOACTION;
- // split action and arg
- string actstr;
- string const argstr = split(func2, actstr, ' ');
- lyxerr[Debug::ACTION] << "Action: " << actstr << '\n'
- << "Arg : " << argstr << endl;
+ if (func2.empty()) {
+ return FuncRequest(LFUN_NOACTION);
+ }
+
+ string cmd;
+ string const arg = split(func2, cmd, ' ');
- func_map::const_iterator fit = lyx_func_map.find(actstr);
+ func_map::const_iterator fit = lyx_func_map.find(cmd);
- return fit != lyx_func_map.end() ? fit->second : LFUN_UNKNOWN_ACTION;
+ return fit != lyx_func_map.end() ? FuncRequest(fit->second, arg) : FuncRequest(LFUN_UNKNOWN_ACTION);
}
-string const LyXAction::getActionName(int action) const
+string const LyXAction::getActionName(kb_action action) const
{
- info_map::const_iterator const it = lyx_info_map.find(kb_action(action));
- if (it != lyx_info_map.end())
- return it->second.name;
- return string();
+ info_map::const_iterator const it = lyx_info_map.find(action);
+ return it != lyx_info_map.end() ? it->second.name : string();
}
{
info_map::const_iterator ici = lyx_info_map.find(action);
- if (ici != lyx_info_map.end()) {
- return ici->second.attrib & flag;
- } else {
- // it really should exist, but...
- lyxerr << "LyXAction::funcHasFlag: "
- "No info about kb_action: " << action << '\n';
- return false;
- }
+ BOOST_ASSERT(ici != lyx_info_map.end());
+
+ return ici->second.attrib & flag;
}
* If you include arguments in func_name, a new pseudoaction
* will be created if needed.
*/
- kb_action LookupFunc(string const & func_name);
+ FuncRequest lookupFunc(string const & func_name) const;
/// Return the name (and argument) associated with the given (pseudo) action
- string const getActionName(int action) const;
+ string const getActionName(kb_action action) const;
/// True if the command has `flag' set
bool funcHasFlag(kb_action action, func_attrib flag) const;
// Get the keys bound to this action, but keep only the
// first one later
- string bindings = toplevel_keymap->findbinding(func_.action);
+ string bindings = toplevel_keymap->findbinding(func_);
if (!bindings.empty()) {
return bindings.substr(1, bindings.find(']') - 1);
- } else
+ } else {
+ lyxerr << "No bindings for "
+ << lyxaction.getActionName(func_.action)
+ << '(' << func_.argument << ')' << endl;
return string();
+ }
+
}
string const name = _(lex.getString());
lex.next(true);
string const command = lex.getString();
- string::size_type sp = command.find(' ');
- if (sp != string::npos) {
- string const cmd = command.substr(0, sp);
- string const arg =command.substr(sp + 1,
- string::npos);
- kb_action act = lyxaction.LookupFunc(cmd);
- add(MenuItem(MenuItem::Command, name,
- FuncRequest(act, arg), optional));
- } else {
- kb_action act = lyxaction.LookupFunc(command);
- add(MenuItem(MenuItem::Command, name,
- FuncRequest(act), optional));
- }
-
+ FuncRequest func = lyxaction.lookupFunc(command);
+ add(MenuItem(MenuItem::Command, name, func, optional));
optional = false;
break;
}
cit = toc_list.find("TOC");
if (cit == end) {
tomenu.add(MenuItem(MenuItem::Command,
- _("No Table of contents")),
+ _("No Table of contents"),
+ FuncRequest()),
view);
} else {
expandToc2(tomenu, cit->second, 0, cit->second.size(), 0);
lyxerr[Debug::PARSER]
<< "ToolbarBackend::read TO_ADD func: `"
<< func_arg << '\'' << endl;
- // Split func_arg in function and arg.
- string::size_type sp = func_arg.find(' ');
- if (sp != string::npos) {
-
- string const func =
- func_arg.substr(0, sp);
- string const arg =
- func_arg.substr(sp + 1,
- string::npos);
-
- kb_action const tf =
- lyxaction.LookupFunc(func);
-
- add(tb, FuncRequest(tf, arg), tooltip);
- } else {
- kb_action const tf = lyxaction.LookupFunc(func_arg);
- add(tb, FuncRequest(tf), tooltip);
-
- }
+ FuncRequest func =
+ lyxaction.lookupFunc(func_arg);
+ add(tb, func, tooltip);
}
break;
void assertion_failed(char const * expr, char const * function,
char const * file, long line)
{
- lyxerr << "Assertion triggered in " << function << " by \"" <<
- expr << " in file " << file << ":" << line << endl;
+ lyxerr << "Assertion triggered in " << function
+ << " by failing check \"" << expr << "\""
+ << " in file " << file << ":" << line << endl;
emergencyCleanup();
lyx::support::abort();
}
#include "errorlist.h"
#include "exporter.h"
#include "format.h"
+#include "funcrequest.h"
#include "gettext.h"
#include "iterators.h"
#include "language.h"
bool Buffer::dispatch(string const & command, bool * result)
{
- // Split command string into command and argument
- string cmd;
- string line = ltrim(command);
- string const arg = trim(split(line, cmd, ' '));
-
- return dispatch(lyxaction.LookupFunc(cmd), arg, result);
+ return dispatch(lyxaction.lookupFunc(command), result);
}
-bool Buffer::dispatch(int action, string const & argument, bool * result)
+bool Buffer::dispatch(FuncRequest const & func, bool * result)
{
bool dispatched = true;
- switch (action) {
+ switch (func.action) {
case LFUN_EXPORT: {
- bool const tmp = Exporter::Export(this, argument, false);
+ bool const tmp = Exporter::Export(this, func.argument, false);
if (result)
*result = tmp;
break;
class BufferParams;
class ErrorItem;
+class FuncRequest;
class LyXFont;
class LyXLex;
class LyXRC;
bool dispatch(string const & command, bool * result = 0);
/// Maybe we know the function already by number...
- bool dispatch(int ac, string const & argument, bool * result = 0);
+ bool dispatch(FuncRequest const & func, bool * result = 0);
/// Load the autosaved file.
void loadAutoSaveFile();
lyxerr << "\nbuildCursor: " << inset << std::endl;
if (!inset)
return;
-
+
inset = inset->getLockingInset();
bool ok = false;
for ( ; pit != end && !ok; ++pit) {
InsetList::iterator it = pit->insetlist.begin();
InsetList::iterator iend = pit->insetlist.end();
- for ( ; it != iend && !ok; ++it)
+ for ( ; it != iend && !ok; ++it)
if (it->inset == inset || it->inset == inset->owner())
ok = true;
}
return;
}
- vector<ParagraphList::iterator> pits;
+ vector<ParagraphList::iterator> pits;
vector<ParagraphList const *> plists;
vector<LyXText *> texts;
/*
break;
case MenuItem::Command:
{
+ #warning Bindings are not inserted into the menu labels here. (Lgb)
FuncStatus const flag =
view_->getLyXFunc().getStatus(i->func());
- bool on, off;
- on = flag.onoff(true);
- off = flag.onoff(false);
+ bool on = flag.onoff(true);
+ bool off = flag.onoff(false);
if (on || off) {
gmenu->items().push_back(
+2003-09-22 Lars Gullik Bjønnes <larsbj@gullik.net>
+
+ * QLPopupMenu.C (getLabel): fix so that bindings are added even if
+ shortcut is missing.
+
2003-09-21 Lars Gullik Bjønnes <larsbj@gullik.net>
* QtView.C (activated): change to take a FuncRequest, not a slot
- anymore.
+ anymore.
* QLToolbar.C (update): adjust
(add): change to take a FuncRequest
string const shortcut = mi.shortcut();
string label = subst(mi.label(), "&", "&&");
- if (shortcut.empty())
- return label;
-
- string::size_type pos = label.find(shortcut);
- if (pos == string::npos)
- return label;
- label.insert(pos, 1, '&');
+ if (!shortcut.empty()) {
+ string::size_type pos = label.find(shortcut);
+ if (pos != string::npos)
+ label.insert(pos, 1, '&');
+ }
if (mi.kind() == MenuItem::Command) {
string const binding(mi.binding());
FuncRequest::FuncRequest()
- : view_(0), action(LFUN_UNKNOWN_ACTION), x(0), y(0), button_(mouse_button::none)
+ : view_(0), action(LFUN_NOACTION), x(0), y(0), button_(mouse_button::none)
{}
mouse_button::state button_;
};
+
+inline
+bool operator==(FuncRequest const & lhs, FuncRequest const & rhs)
+{
+ return lhs.action == rhs.action && lhs.argument == rhs.argument;
+}
+
#endif // FUNCREQUEST_H
using std::endl;
using lyx::support::i18nLibFileSearch;
+
string const kb_keymap::printKeysym(LyXKeySymPtr key,
key_modifier::state mod)
{
}
-string::size_type kb_keymap::bind(string const & seq, int action)
+string::size_type kb_keymap::bind(string const & seq, FuncRequest const & func)
{
if (lyxerr.debugging(Debug::KBMAP)) {
lyxerr << "BIND: Sequence `"
<< seq << "' Action `"
- << action << '\'' << endl;
+ << func.action << '\'' << endl;
}
kb_sequence k(0, 0);
string::size_type const res = k.parse(seq);
if (res == string::npos) {
- defkey(&k, action);
+ defkey(&k, func);
} else {
lyxerr[Debug::KBMAP] << "Parse error at position " << res
<< " in key sequence '" << seq << "'."
break;
}
- int action = lyxaction.LookupFunc(cmd);
- if (!action == LFUN_UNKNOWN_ACTION) {
+ FuncRequest func = lyxaction.lookupFunc(cmd);
+ if (func. action == LFUN_UNKNOWN_ACTION) {
lexrc.printError("BN_BIND: Unknown LyX"
" function `$$Token'");
error = true;
break;
}
- bind(seq, kb_action(action));
+ bind(seq, func);
break;
}
case BN_BINDFILE:
}
-int kb_keymap::lookup(LyXKeySymPtr key,
- key_modifier::state mod, kb_sequence * seq) const
+FuncRequest const &
+kb_keymap::lookup(LyXKeySymPtr key,
+ key_modifier::state mod, kb_sequence * seq) const
{
+ static FuncRequest const unknown(LFUN_UNKNOWN_ACTION);
+
if (table.empty()) {
seq->curmap = seq->stdmap;
seq->mark_deleted();
- return LFUN_UNKNOWN_ACTION;
+ return unknown;
}
Table::const_iterator end = table.end();
if (cit->table.get()) {
// this is a prefix key - set new map
seq->curmap = cit->table.get();
- return LFUN_PREFIX;
+ static FuncRequest prefix(LFUN_PREFIX);
+ return prefix;
} else {
// final key - reset map
seq->curmap = seq->stdmap;
seq->mark_deleted();
- return cit->action;
+ return cit->func;
}
}
}
// error - key not found:
seq->curmap = seq->stdmap;
seq->mark_deleted();
- return LFUN_UNKNOWN_ACTION;
+
+ return unknown;
}
}
-void kb_keymap::defkey(kb_sequence * seq, int action, unsigned int r)
+void kb_keymap::defkey(kb_sequence * seq,
+ FuncRequest const & func, unsigned int r)
{
LyXKeySymPtr code = seq->sequence[r];
if (!code->isOK())
if (it->table.get()) {
it->table.reset();
}
- it->action = action;
+ it->func = func;
return;
} else if (!it->table.get()) {
lyxerr << "Error: New binding for '" << seq->print()
<< endl;
return;
} else {
- it->table->defkey(seq, action, r + 1);
+ it->table->defkey(seq, func, r + 1);
return;
}
}
newone->code = code;
newone->mod = seq->modifiers[r];
if (r + 1 == seq->length()) {
- newone->action = action;
+ newone->func = func;
newone->table.reset();
return;
} else {
newone->table.reset(new kb_keymap);
- newone->table->defkey(seq, action, r + 1);
+ newone->table->defkey(seq, func, r + 1);
return;
}
}
-string const kb_keymap::findbinding(int act, string const & prefix) const
+string const kb_keymap::findbinding(FuncRequest const & func,
+ string const & prefix) const
{
string res;
if (table.empty()) return res;
for (Table::const_iterator cit = table.begin();
cit != end; ++cit) {
if (cit->table.get()) {
- res += cit->table->findbinding(act,
+ res += cit->table->findbinding(func,
prefix
+ printKey((*cit))
+ ' ');
- } else if (cit->action == act) {
+ } else if (cit->func == func) {
res += '[';
res += prefix + printKey((*cit));
res += "] ";
}
}
+
return res;
}
#ifndef KBMAP_H
#define KBMAP_H
+#include "funcrequest.h"
+
#include "frontends/key_state.h"
#include <boost/shared_ptr.hpp>
* occurs.
* See kb_sequence::parse for the syntax of the seq string
*/
- string::size_type bind(string const & seq, int action);
+ string::size_type bind(string const & seq, FuncRequest const & func);
// Parse a bind file
- bool kb_keymap::read(string const & bind_file);
+ bool read(string const & bind_file);
/// print all available keysyms
string const print() const;
* @param seq the current key sequence so far
* @return the action / LFUN_PREFIX / LFUN_UNKNOWN_ACTION
*/
- int lookup(LyXKeySymPtr key,
- key_modifier::state mod, kb_sequence * seq) const;
+ FuncRequest const &
+ lookup(LyXKeySymPtr key,
+ key_modifier::state mod, kb_sequence * seq) const;
/// Given an action, find all keybindings.
- string const findbinding(int action,
+ string const findbinding(FuncRequest const & func,
string const & prefix = string()) const;
/**
boost::shared_ptr<kb_keymap> table;
/// Action for !prefix keys
- int action;
+ FuncRequest func;
};
/**
* Define an action for a key sequence.
* @param r internal recursion level
*/
- void defkey(kb_sequence * seq, int action, unsigned int r = 0);
+ void defkey(kb_sequence * seq, FuncRequest const & func,
+ unsigned int r = 0);
/// Returns a string of the given key
string const printKey(kb_key const & key) const;
using std::make_pair;
-int kb_sequence::addkey(LyXKeySymPtr key,
- key_modifier::state mod, key_modifier::state nmod)
+FuncRequest const &
+kb_sequence::addkey(LyXKeySymPtr key,
+ key_modifier::state mod, key_modifier::state nmod)
{
// adding a key to a deleted sequence
// starts a new sequence
return curmap->lookup(key, mod, this);
}
- return LFUN_UNKNOWN_ACTION;
+ static FuncRequest unknown(LFUN_UNKNOWN_ACTION);
+ return unknown;
}
class kb_keymap;
class LyXKeySym;
+class FuncRequest;
/// Holds a key sequence and the current and standard keymaps
class kb_sequence {
* @param nmod which modifiers to mask out for equality test
* @return the action matching this key sequence or LFUN_UNKNOWN_ACTION
*/
- int addkey(LyXKeySymPtr keysym, key_modifier::state mod,
- key_modifier::state nmod = key_modifier::none);
+ FuncRequest const &
+ addkey(LyXKeySymPtr keysym, key_modifier::state mod,
+ key_modifier::state nmod = key_modifier::none);
/**
* Add a sequence of keys from a string to the sequence
void LyX::defaultKeyBindings(kb_keymap * kbmap)
{
- kbmap->bind("Right", LFUN_RIGHT);
- kbmap->bind("Left", LFUN_LEFT);
- kbmap->bind("Up", LFUN_UP);
- kbmap->bind("Down", LFUN_DOWN);
+ kbmap->bind("Right", FuncRequest(LFUN_RIGHT));
+ kbmap->bind("Left", FuncRequest(LFUN_LEFT));
+ kbmap->bind("Up", FuncRequest(LFUN_UP));
+ kbmap->bind("Down", FuncRequest(LFUN_DOWN));
- kbmap->bind("Tab", LFUN_CELL_FORWARD);
- kbmap->bind("ISO_Left_Tab", LFUN_CELL_FORWARD); // jbl 2001-23-02
+ kbmap->bind("Tab", FuncRequest(LFUN_CELL_FORWARD));
+ kbmap->bind("ISO_Left_Tab", FuncRequest(LFUN_CELL_FORWARD));
- kbmap->bind("Home", LFUN_HOME);
- kbmap->bind("End", LFUN_END);
- kbmap->bind("Prior", LFUN_PRIOR);
- kbmap->bind("Next", LFUN_NEXT);
+ kbmap->bind("Home", FuncRequest(LFUN_HOME));
+ kbmap->bind("End", FuncRequest(LFUN_END));
+ kbmap->bind("Prior", FuncRequest(LFUN_PRIOR));
+ kbmap->bind("Next", FuncRequest(LFUN_NEXT));
- kbmap->bind("Return", LFUN_BREAKPARAGRAPH);
- //kbmap->bind("~C-~S-~M-nobreakspace", LFUN_PROTECTEDSPACE);
+ kbmap->bind("Return", FuncRequest(LFUN_BREAKPARAGRAPH));
+ //kbmap->bind("~C-~S-~M-nobreakspace", FuncRequest(LFUN_PROTECTEDSPACE));
- kbmap->bind("Delete", LFUN_DELETE);
- kbmap->bind("BackSpace", LFUN_BACKSPACE);
+ kbmap->bind("Delete", FuncRequest(LFUN_DELETE));
+ kbmap->bind("BackSpace", FuncRequest(LFUN_BACKSPACE));
// sub- and superscript -MV
- kbmap->bind("~S-underscore", LFUN_SUBSCRIPT);
- kbmap->bind("~S-asciicircum", LFUN_SUPERSCRIPT);
+ kbmap->bind("~S-underscore", FuncRequest(LFUN_SUBSCRIPT));
+ kbmap->bind("~S-asciicircum", FuncRequest(LFUN_SUPERSCRIPT));
// kbmap->bindings to enable the use of the numeric keypad
// e.g. Num Lock set
- //kbmap->bind("KP_0", LFUN_SELFINSERT);
- //kbmap->bind("KP_Decimal", LFUN_SELFINSERT);
- kbmap->bind("KP_Enter", LFUN_BREAKPARAGRAPH);
- //kbmap->bind("KP_1", LFUN_SELFINSERT);
- //kbmap->bind("KP_2", LFUN_SELFINSERT);
- //kbmap->bind("KP_3", LFUN_SELFINSERT);
- //kbmap->bind("KP_4", LFUN_SELFINSERT);
- //kbmap->bind("KP_5", LFUN_SELFINSERT);
- //kbmap->bind("KP_6", LFUN_SELFINSERT);
- //kbmap->bind("KP_Add", LFUN_SELFINSERT);
- //kbmap->bind("KP_7", LFUN_SELFINSERT);
- //kbmap->bind("KP_8", LFUN_SELFINSERT);
- //kbmap->bind("KP_9", LFUN_SELFINSERT);
- //kbmap->bind("KP_Divide", LFUN_SELFINSERT);
- //kbmap->bind("KP_Multiply", LFUN_SELFINSERT);
- //kbmap->bind("KP_Subtract", LFUN_SELFINSERT);
- kbmap->bind("KP_Right", LFUN_RIGHT);
- kbmap->bind("KP_Left", LFUN_LEFT);
- kbmap->bind("KP_Up", LFUN_UP);
- kbmap->bind("KP_Down", LFUN_DOWN);
- kbmap->bind("KP_Home", LFUN_HOME);
- kbmap->bind("KP_End", LFUN_END);
- kbmap->bind("KP_Prior", LFUN_PRIOR);
- kbmap->bind("KP_Next", LFUN_NEXT);
-
- kbmap->bind("C-Tab", LFUN_CELL_SPLIT); // ale970515
- kbmap->bind("S-Tab", LFUN_CELL_BACKWARD); // jug20000522
- kbmap->bind("S-ISO_Left_Tab", LFUN_CELL_BACKWARD); // jbl 2001-23-02
+ //kbmap->bind("KP_0", FuncRequest(LFUN_SELFINSERT));
+ //kbmap->bind("KP_Decimal", FuncRequest(LFUN_SELFINSERT));
+ kbmap->bind("KP_Enter", FuncRequest(LFUN_BREAKPARAGRAPH));
+ //kbmap->bind("KP_1", FuncRequest(LFUN_SELFINSERT));
+ //kbmap->bind("KP_2", FuncRequest(LFUN_SELFINSERT));
+ //kbmap->bind("KP_3", FuncRequest(LFUN_SELFINSERT));
+ //kbmap->bind("KP_4", FuncRequest(LFUN_SELFINSERT));
+ //kbmap->bind("KP_5", FuncRequest(LFUN_SELFINSERT));
+ //kbmap->bind("KP_6", FuncRequest(LFUN_SELFINSERT));
+ //kbmap->bind("KP_Add", FuncRequest(LFUN_SELFINSERT));
+ //kbmap->bind("KP_7", FuncRequest(LFUN_SELFINSERT));
+ //kbmap->bind("KP_8", FuncRequest(LFUN_SELFINSERT));
+ //kbmap->bind("KP_9", FuncRequest(LFUN_SELFINSERT));
+ //kbmap->bind("KP_Divide", FuncRequest(LFUN_SELFINSERT));
+ //kbmap->bind("KP_Multiply", FuncRequest(LFUN_SELFINSERT));
+ //kbmap->bind("KP_Subtract", FuncRequest(LFUN_SELFINSERT));
+ kbmap->bind("KP_Right", FuncRequest(LFUN_RIGHT));
+ kbmap->bind("KP_Left", FuncRequest(LFUN_LEFT));
+ kbmap->bind("KP_Up", FuncRequest(LFUN_UP));
+ kbmap->bind("KP_Down", FuncRequest(LFUN_DOWN));
+ kbmap->bind("KP_Home", FuncRequest(LFUN_HOME));
+ kbmap->bind("KP_End", FuncRequest(LFUN_END));
+ kbmap->bind("KP_Prior", FuncRequest(LFUN_PRIOR));
+ kbmap->bind("KP_Next", FuncRequest(LFUN_NEXT));
+
+ kbmap->bind("C-Tab", FuncRequest(LFUN_CELL_SPLIT));
+ kbmap->bind("S-Tab", FuncRequest(LFUN_CELL_BACKWARD));
+ kbmap->bind("S-ISO_Left_Tab", FuncRequest(LFUN_CELL_BACKWARD));
}
{
// bindKeyings for transparent handling of deadkeys
// The keysyms are gotten from XFree86 X11R6
- kbmap->bind("~C-~S-~M-dead_acute", LFUN_ACUTE);
- kbmap->bind("~C-~S-~M-dead_breve", LFUN_BREVE);
- kbmap->bind("~C-~S-~M-dead_caron", LFUN_CARON);
- kbmap->bind("~C-~S-~M-dead_cedilla", LFUN_CEDILLA);
- kbmap->bind("~C-~S-~M-dead_abovering", LFUN_CIRCLE);
- kbmap->bind("~C-~S-~M-dead_circumflex", LFUN_CIRCUMFLEX);
- kbmap->bind("~C-~S-~M-dead_abovedot", LFUN_DOT);
- kbmap->bind("~C-~S-~M-dead_grave", LFUN_GRAVE);
- kbmap->bind("~C-~S-~M-dead_doubleacute", LFUN_HUNG_UMLAUT);
- kbmap->bind("~C-~S-~M-dead_macron", LFUN_MACRON);
+ kbmap->bind("~C-~S-~M-dead_acute", FuncRequest(LFUN_ACUTE));
+ kbmap->bind("~C-~S-~M-dead_breve", FuncRequest(LFUN_BREVE));
+ kbmap->bind("~C-~S-~M-dead_caron", FuncRequest(LFUN_CARON));
+ kbmap->bind("~C-~S-~M-dead_cedilla", FuncRequest(LFUN_CEDILLA));
+ kbmap->bind("~C-~S-~M-dead_abovering", FuncRequest(LFUN_CIRCLE));
+ kbmap->bind("~C-~S-~M-dead_circumflex", FuncRequest(LFUN_CIRCUMFLEX));
+ kbmap->bind("~C-~S-~M-dead_abovedot", FuncRequest(LFUN_DOT));
+ kbmap->bind("~C-~S-~M-dead_grave", FuncRequest(LFUN_GRAVE));
+ kbmap->bind("~C-~S-~M-dead_doubleacute", FuncRequest(LFUN_HUNG_UMLAUT));
+ kbmap->bind("~C-~S-~M-dead_macron", FuncRequest(LFUN_MACRON));
// nothing with this name
// kbmap->bind("~C-~S-~M-dead_special_caron", LFUN_SPECIAL_CARON);
- kbmap->bind("~C-~S-~M-dead_tilde", LFUN_TILDE);
- kbmap->bind("~C-~S-~M-dead_diaeresis", LFUN_UMLAUT);
+ kbmap->bind("~C-~S-~M-dead_tilde", FuncRequest(LFUN_TILDE));
+ kbmap->bind("~C-~S-~M-dead_diaeresis", FuncRequest(LFUN_UMLAUT));
// nothing with this name either...
- //kbmap->bind("~C-~S-~M-dead_underbar", LFUN_UNDERBAR);
- kbmap->bind("~C-~S-~M-dead_belowdot", LFUN_UNDERDOT);
- kbmap->bind("~C-~S-~M-dead_tie", LFUN_TIE);
- kbmap->bind("~C-~S-~M-dead_ogonek", LFUN_OGONEK);
+ //kbmap->bind("~C-~S-~M-dead_underbar", FuncRequest(LFUN_UNDERBAR));
+ kbmap->bind("~C-~S-~M-dead_belowdot", FuncRequest(LFUN_UNDERDOT));
+ kbmap->bind("~C-~S-~M-dead_tie", FuncRequest(LFUN_TIE));
+ kbmap->bind("~C-~S-~M-dead_ogonek",FuncRequest(LFUN_OGONEK));
}
// cancel and meta-fake keys. RVDK_PATCH_5
cancel_meta_seq.reset();
- int action = cancel_meta_seq.addkey(keysym, state);
- lyxerr[Debug::KEY] << "action first set to [" << action << ']' << endl;
+ FuncRequest func = cancel_meta_seq.addkey(keysym, state);
+ lyxerr[Debug::KEY] << "action first set to [" << func.action << ']' << endl;
// When not cancel or meta-fake, do the normal lookup.
// Note how the meta_fake Mod1 bit is OR-ed in and reset afterwards.
// Mostly, meta_fake_bit = key_modifier::none. RVDK_PATCH_5.
- if ((action != LFUN_CANCEL) && (action != LFUN_META_FAKE)) {
+ if ((func.action != LFUN_CANCEL) && (func.action != LFUN_META_FAKE)) {
// remove Caps Lock and Mod2 as a modifiers
- action = keyseq.addkey(keysym, (state | meta_fake_bit));
+ func = keyseq.addkey(keysym, (state | meta_fake_bit));
lyxerr[Debug::KEY] << "action now set to ["
- << action << ']' << endl;
+ << func.action << ']' << endl;
}
// Dont remove this unless you know what you are doing.
meta_fake_bit = key_modifier::none;
// can this happen now ?
- if (action == LFUN_NOACTION) {
- action = LFUN_PREFIX;
+ if (func.action == LFUN_NOACTION) {
+ func = FuncRequest(LFUN_PREFIX);
}
if (lyxerr.debugging(Debug::KEY)) {
lyxerr << "Key [action="
- << action << "]["
+ << func.action << "]["
<< keyseq.print() << ']'
<< endl;
}
// Maybe user can only reach the key via holding down shift.
// Let's see. But only if shift is the only modifier
- if (action == LFUN_UNKNOWN_ACTION && state == key_modifier::shift) {
+ if (func.action == LFUN_UNKNOWN_ACTION &&
+ state == key_modifier::shift) {
lyxerr[Debug::KEY] << "Trying without shift" << endl;
- action = keyseq.addkey(keysym, key_modifier::none);
- lyxerr[Debug::KEY] << "Action now " << action << endl;
+ func = keyseq.addkey(keysym, key_modifier::none);
+ lyxerr[Debug::KEY] << "Action now " << func.action << endl;
}
- if (action == LFUN_UNKNOWN_ACTION) {
+ if (func.action == LFUN_UNKNOWN_ACTION) {
// Hmm, we didn't match any of the keysequences. See
// if it's normal insertable text not already covered
// by a binding
if (keysym->isText() && keyseq.length() == 1) {
lyxerr[Debug::KEY] << "isText() is true, inserting." << endl;
- action = LFUN_SELFINSERT;
+ func = FuncRequest(LFUN_SELFINSERT);
} else {
lyxerr[Debug::KEY] << "Unknown, !isText() - giving up" << endl;
owner->message(_("Unknown function."));
}
}
- if (action == LFUN_SELFINSERT) {
+ if (func.action == LFUN_SELFINSERT) {
if (encoded_last_key != 0) {
string arg;
arg += encoded_last_key;
<< argument << "']" << endl;
}
} else {
- dispatch(FuncRequest(kb_action(action)));
+ dispatch(func);
}
}
// solution, we consider only the first action of the sequence
if (ev.action == LFUN_SEQUENCE) {
// argument contains ';'-terminated commands
- flag = getStatus(FuncRequest(lyxaction.LookupFunc(token(ev.argument, ';', 0))));
+#warning LyXAction arguements not handled here.
+ flag = getStatus(FuncRequest(lyxaction.lookupFunc(token(ev.argument, ';', 0))));
}
return flag;
void LyXFunc::dispatch(string const & s, bool verbose)
{
- int const action = lyxaction.LookupFunc(s);
+ FuncRequest func = lyxaction.lookupFunc(s);
- if (action == LFUN_UNKNOWN_ACTION) {
+ if (func.action == LFUN_UNKNOWN_ACTION) {
owner->message(bformat(_("Unknown function (%1$s)"), s));
return;
}
- dispatch(FuncRequest(kb_action(action)), verbose);
+ dispatch(func, verbose);
}
} //namespace anon
-void LyXFunc::dispatch(FuncRequest const & ev, bool verbose)
+void LyXFunc::dispatch(FuncRequest const & func, bool verbose)
{
- lyxerr[Debug::ACTION] << "LyXFunc::dispatch: action[" << ev.action
- <<"] arg[" << ev.argument << ']' << endl;
+ string argument = func.argument;
+ kb_action action = func.action;
+
+ lyxerr[Debug::ACTION] << "LyXFunc::dispatch: action[" << action
+ <<"] arg[" << argument << ']' << endl;
// we have not done anything wrong yet.
errorstat = false;
selection_possible = false;
- string argument = ev.argument;
- kb_action action = ev.action;
-
// We cannot use this function here
- if (getStatus(ev).disabled()) {
+ if (getStatus(func).disabled()) {
lyxerr[Debug::ACTION] << "LyXFunc::dispatch: "
<< lyxaction.getActionName(action)
<< " [" << action << "] is disabled at this location"
{
Cursor cursor;
buildCursor(cursor, *view());
- if (cursor.dispatch(FuncRequest(ev, view())) == DISPATCHED) {
+ if (cursor.dispatch(FuncRequest(func, view())) == DISPATCHED) {
lyxerr << "dispatched by Cursor::dispatch()\n";
goto exit_with_message;
}
// if we've just done LFUN_ESCAPE (which
// injects an LFUN_PARAGRAPH_UPDATE)
if (action == LFUN_PARAGRAPH_UPDATE) {
- view()->dispatch(ev);
+ view()->dispatch(func);
goto exit_with_message;
}
break;
case LFUN_DIALOG_SHOW: {
- string const name = ev.getArg(0);
- string data = trim(ev.argument.substr(name.size()));
+ string const name = func.getArg(0);
+ string data = trim(func.argument.substr(name.size()));
if (name == "character") {
data = freefont2string();
InsetBase * inset = owner->getDialogs().getOpenInset(name);
if (inset) {
FuncRequest fr(view(), LFUN_INSET_DIALOG_UPDATE,
- ev.argument);
+ func.argument);
inset->localDispatch(fr);
} else if (name == "paragraph") {
dispatch(FuncRequest(LFUN_PARAGRAPH_UPDATE));
default:
// Then if it was none of the above
// Trying the BufferView::pimpl dispatch:
- if (!view()->dispatch(ev))
+ if (!view()->dispatch(func))
lyxerr << "A truly unknown func ["
- << lyxaction.getActionName(ev.action) << "]!"
+ << lyxaction.getActionName(func.action) << "]!"
<< endl;
break;
} // end of switch
}
// If we executed a mutating lfun, mark the buffer as dirty
- if (!getStatus(ev).disabled()
- && !lyxaction.funcHasFlag(ev.action, LyXAction::NoBuffer)
- && !lyxaction.funcHasFlag(ev.action, LyXAction::ReadOnly))
+ if (!getStatus(func).disabled()
+ && !lyxaction.funcHasFlag(func.action, LyXAction::NoBuffer)
+ && !lyxaction.funcHasFlag(func.action, LyXAction::ReadOnly))
view()->buffer()->markDirty();
}
- sendDispatchMessage(getMessage(), ev, verbose);
+ sendDispatchMessage(getMessage(), func, verbose);
}
-void LyXFunc::sendDispatchMessage(string const & msg, FuncRequest const & ev, bool verbose)
+void LyXFunc::sendDispatchMessage(string const & msg,
+ FuncRequest const & func, bool verbose)
{
owner->updateMenubar();
owner->updateToolbar();
- if (ev.action == LFUN_SELFINSERT || !verbose) {
+ if (func.action == LFUN_SELFINSERT || !verbose) {
lyxerr[Debug::ACTION] << "dispatch msg is " << msg << endl;
if (!msg.empty())
owner->message(msg);
if (!dispatch_msg.empty())
dispatch_msg += ' ';
- string comname = lyxaction.getActionName(ev.action);
+ string comname = lyxaction.getActionName(func.action);
bool argsadded = false;
- if (!ev.argument.empty()) {
- if (ev.action != LFUN_UNKNOWN_ACTION) {
- comname += ' ' + ev.argument;
+ if (!func.argument.empty()) {
+ if (func.action != LFUN_UNKNOWN_ACTION) {
+ comname += ' ' + func.argument;
argsadded = true;
}
}
- string const shortcuts = toplevel_keymap->findbinding(ev.action);
+ string const shortcuts = toplevel_keymap->findbinding(func);
if (!shortcuts.empty()) {
comname += ": " + shortcuts;
- } else if (!argsadded && !ev.argument.empty()) {
- comname += ' ' + ev.argument;
+ } else if (!argsadded && !func.argument.empty()) {
+ comname += ' ' + func.argument;
}
if (!comname.empty()) {
output += env;
return output + "}";
}
-
+
} // namespace anon
projects / features.git / commitdiff