anne/lyx_mirror
1
0
Fork 0
mirror of https://git.lyx.org/repos/lyx.git synced 2024-11-25 19:07:45 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

This is just a giant renaming of member variables in FuncRequest,

Browse Source 
preparatory to making them private.


git-svn-id: svn://svn.lyx.org/lyx/lyx-devel/trunk@34105 a592a061-630c-0410-9148-cb99ea01b6c8
This commit is contained in:
Richard Heck 2010-04-09 18:15:17 +00:00
parent 09c2d0e85d
commit 4c7a5d0024
57 changed files with 292 additions and 293 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
src/Buffer.cpp
View File

@ -1815,7 +1815,7 @@ bool Buffer::getStatus(FuncRequest const & cmd, FuncStatus & flag)
bool enable = true;
switch (cmd.action) {
switch (cmd.action_) {
case LFUN_BUFFER_TOGGLE_READ_ONLY:
flag.setOnOff(isReadonly());
@ -1887,7 +1887,7 @@ void Buffer::dispatch(FuncRequest const & func, DispatchResult & dr)
{
if (isInternal()) {
// FIXME? if there is an Buffer LFUN that can be dispatched even
// if internal, put a switch '(cmd.action)' here.
// if internal, put a switch '(cmd.action_)' here.
dr.dispatched(false);
return;
}
@ -1896,7 +1896,7 @@ void Buffer::dispatch(FuncRequest const & func, DispatchResult & dr)
bool dispatched = true;
undo().beginUndoGroup();
switch (func.action) {
switch (func.action_) {
case LFUN_BUFFER_TOGGLE_READ_ONLY:
if (lyxvc().inUse())
lyxvc().toggleReadOnly();
@ -2014,7 +2014,7 @@ void Buffer::dispatch(FuncRequest const & func, DispatchResult & dr)
bformat(_("Branch \"%1$s\" does not exist."), branchName);
dr.setMessage(msg);
} else {
branch->setSelected(func.action == LFUN_BRANCH_ACTIVATE);
branch->setSelected(func.action_ == LFUN_BRANCH_ACTIVATE);
dr.setError(false);
dr.update(Update::Force);
}

40
src/BufferView.cpp
View File

@ -948,16 +948,16 @@ bool BufferView::getStatus(FuncRequest const & cmd, FuncStatus & flag)
{
// Can we use a readonly buffer?
if (buffer_.isReadonly()
&& !lyxaction.funcHasFlag(cmd.action, LyXAction::ReadOnly)
&& !lyxaction.funcHasFlag(cmd.action, LyXAction::NoBuffer)) {
&& !lyxaction.funcHasFlag(cmd.action_, LyXAction::ReadOnly)
&& !lyxaction.funcHasFlag(cmd.action_, LyXAction::NoBuffer)) {
flag.message(from_utf8(N_("Document is read-only")));
flag.setEnabled(false);
return true;
}
// Are we in a DELETED change-tracking region?
if (lookupChangeType(d->cursor_, true) == Change::DELETED
&& !lyxaction.funcHasFlag(cmd.action, LyXAction::ReadOnly)
&& !lyxaction.funcHasFlag(cmd.action, LyXAction::NoBuffer)) {
&& !lyxaction.funcHasFlag(cmd.action_, LyXAction::ReadOnly)
&& !lyxaction.funcHasFlag(cmd.action_, LyXAction::NoBuffer)) {
flag.message(from_utf8(N_("This portion of the document is deleted.")));
flag.setEnabled(false);
return true;
@ -968,7 +968,7 @@ bool BufferView::getStatus(FuncRequest const & cmd, FuncStatus & flag)
if (cur.getStatus(cmd, flag))
return true;
switch (cmd.action) {
switch (cmd.action_) {
// FIXME: This is a bit problematic because we don't check if this is
// a document BufferView or not for these LFUNs. We probably have to
@ -1153,10 +1153,10 @@ void BufferView::dispatch(FuncRequest const & cmd, DispatchResult & dr)
//lyxerr << [ cmd = " << cmd << "]" << endl;
// Make sure that the cached BufferView is correct.
LYXERR(Debug::ACTION, " action[" << cmd.action << ']'
LYXERR(Debug::ACTION, " action[" << cmd.action_ << ']'
<< " arg[" << to_utf8(cmd.argument()) << ']'
<< " x[" << cmd.x << ']'
<< " y[" << cmd.y << ']'
<< " x[" << cmd.x_ << ']'
<< " y[" << cmd.y_ << ']'
<< " button[" << cmd.button() << ']');
string const argument = to_utf8(cmd.argument());
@ -1164,14 +1164,14 @@ void BufferView::dispatch(FuncRequest const & cmd, DispatchResult & dr)
// Don't dispatch function that does not apply to internal buffers.
if (buffer_.isInternal()
&& lyxaction.funcHasFlag(cmd.action, LyXAction::NoInternal))
&& lyxaction.funcHasFlag(cmd.action_, LyXAction::NoInternal))
return;
// We'll set this back to false if need be.
bool dispatched = true;
buffer_.undo().beginUndoGroup();
switch (cmd.action) {
switch (cmd.action_) {
case LFUN_BUFFER_PARAMS_APPLY: {
DocumentClass const * const oldClass = buffer_.params().documentClassPtr();
@ -1451,7 +1451,7 @@ void BufferView::dispatch(FuncRequest const & cmd, DispatchResult & dr)
if (searched_string.empty())
break;
bool const fw = cmd.action == LFUN_WORD_FIND_FORWARD;
bool const fw = cmd.action_ == LFUN_WORD_FIND_FORWARD;
docstring const data =
find2string(searched_string, true, false, fw);
find(this, FuncRequest(LFUN_WORD_FIND, data));
@ -1628,11 +1628,11 @@ void BufferView::dispatch(FuncRequest const & cmd, DispatchResult & dr)
showCursor();
p = getPos(cur, cur.boundary());
}*/
int const scrolled = scroll(cmd.action == LFUN_SCREEN_UP
int const scrolled = scroll(cmd.action_ == LFUN_SCREEN_UP
? -height_ : height_);
if (cmd.action == LFUN_SCREEN_UP && scrolled > -height_)
if (cmd.action_ == LFUN_SCREEN_UP && scrolled > -height_)
p = Point(0, 0);
if (cmd.action == LFUN_SCREEN_DOWN && scrolled < height_)
if (cmd.action_ == LFUN_SCREEN_DOWN && scrolled < height_)
p = Point(width_, height_);
Cursor old = cur;
bool const in_texted = cur.inTexted();
@ -1641,7 +1641,7 @@ void BufferView::dispatch(FuncRequest const & cmd, DispatchResult & dr)
updateHoveredInset();
d->text_metrics_[&buffer_.text()].editXY(cur, p.x_, p.y_,
true, cmd.action == LFUN_SCREEN_UP);
true, cmd.action_ == LFUN_SCREEN_UP);
//FIXME: what to do with cur.x_target()?
bool update = in_texted && cur.bv().checkDepm(cur, old);
cur.finishUndo();
@ -1971,18 +1971,18 @@ void BufferView::mouseEventDispatch(FuncRequest const & cmd0)
// surrounding Text will handle this event.
// make sure we stay within the screen...
cmd.y = min(max(cmd.y, -1), height_);
cmd.y_ = min(max(cmd.y_, -1), height_);
d->mouse_position_cache_.x_ = cmd.x;
d->mouse_position_cache_.y_ = cmd.y;
d->mouse_position_cache_.x_ = cmd.x_;
d->mouse_position_cache_.y_ = cmd.y_;
if (cmd.action == LFUN_MOUSE_MOTION && cmd.button() == mouse_button::none) {
if (cmd.action_ == LFUN_MOUSE_MOTION && cmd.button() == mouse_button::none) {
updateHoveredInset();
return;
}
// Build temporary cursor.
Inset * inset = d->text_metrics_[&buffer_.text()].editXY(cur, cmd.x, cmd.y);
Inset * inset = d->text_metrics_[&buffer_.text()].editXY(cur, cmd.x_, cmd.y_);
// Put anchor at the same position.
cur.resetAnchor();

4
src/CmdDef.cpp
View File

@ -163,8 +163,8 @@ CmdDef::newCmdDefResult CmdDef::newCmdDef(string const & name,
return CmdDefExists;
FuncRequest func = lyxaction.lookupFunc(def);
if (func.action == LFUN_NOACTION
|| func.action == LFUN_UNKNOWN_ACTION) {
if (func.action_ == LFUN_NOACTION
|| func.action_ == LFUN_UNKNOWN_ACTION) {
return CmdDefInvalid;
}

4
src/Cursor.cpp
View File

@ -286,7 +286,7 @@ bool Cursor::getStatus(FuncRequest const & cmd, FuncStatus & status) const
// Is this a function that acts on inset at point?
Inset * inset = cur.nextInset();
if (lyxaction.funcHasFlag(cmd.action, LyXAction::AtPoint)
if (lyxaction.funcHasFlag(cmd.action_, LyXAction::AtPoint)
&& inset && inset->getStatus(cur, cmd, status))
return true;
@ -333,7 +333,7 @@ void Cursor::dispatch(FuncRequest const & cmd0)
buffer()->undo().beginUndoGroup();
// Is this a function that acts on inset at point?
if (lyxaction.funcHasFlag(cmd.action, LyXAction::AtPoint)
if (lyxaction.funcHasFlag(cmd.action_, LyXAction::AtPoint)
&& nextInset()) {
result().dispatched(true);
result().update(Update::FitCursor | Update::Force);

28
src/FuncRequest.cpp
View File

@ -29,43 +29,43 @@ FuncRequest const FuncRequest::unknown(LFUN_UNKNOWN_ACTION);
FuncRequest const FuncRequest::noaction(LFUN_NOACTION);
FuncRequest::FuncRequest(Origin o)
: action(LFUN_NOACTION), origin(o), x(0), y(0),
: action_(LFUN_NOACTION), origin_(o), x_(0), y_(0),
button_(mouse_button::none)
{}
FuncRequest::FuncRequest(FuncCode act, Origin o)
: action(act), origin(o), x(0), y(0), button_(mouse_button::none)
: action_(act), origin_(o), x_(0), y_(0), button_(mouse_button::none)
{}
FuncRequest::FuncRequest(FuncCode act, docstring const & arg, Origin o)
: action(act), argument_(arg), origin(o), x(0), y(0),
: argument_(arg), action_(act), origin_(o), x_(0), y_(0),
button_(mouse_button::none)
{}
FuncRequest::FuncRequest(FuncCode act, string const & arg, Origin o)
: action(act), argument_(from_utf8(arg)), origin(o), x(0), y(0),
: argument_(from_utf8(arg)), action_(act), origin_(o), x_(0), y_(0),
button_(mouse_button::none)
{}
FuncRequest::FuncRequest(FuncCode act, int ax, int ay,
mouse_button::state but, Origin o)
: action(act), origin(o), x(ax), y(ay), button_(but)
: action_(act), origin_(o), x_(ax), y_(ay), button_(but)
{}
FuncRequest::FuncRequest(FuncRequest const & cmd, docstring const & arg, Origin o)
: action(cmd.action), argument_(arg), origin(o),
x(cmd.x), y(cmd.y), button_(cmd.button_)
: argument_(arg), action_(cmd.action_), origin_(o),
x_(cmd.x_), y_(cmd.y_), button_(cmd.button_)
{}
FuncRequest::FuncRequest(FuncRequest const & cmd, string const & arg, Origin o)
: action(cmd.action), argument_(from_utf8(arg)), origin(o),
x(cmd.x), y(cmd.y), button_(cmd.button_)
: argument_(from_utf8(arg)), action_(cmd.action_), origin_(o),
x_(cmd.x_), y_(cmd.y_), button_(cmd.button_)
{}
@ -130,18 +130,18 @@ string FuncRequest::getLongArg(unsigned int i) const
bool operator==(FuncRequest const & lhs, FuncRequest const & rhs)
{
return lhs.action == rhs.action && lhs.argument() == rhs.argument();
return lhs.action_ == rhs.action_ && lhs.argument() == rhs.argument();
}
ostream & operator<<(ostream & os, FuncRequest const & cmd)
{
return os
<< " action: " << cmd.action
<< " [" << lyxaction.getActionName(cmd.action) << "] "
<< " action: " << cmd.action_
<< " [" << lyxaction.getActionName(cmd.action_) << "] "
<< " arg: '" << to_utf8(cmd.argument()) << "'"
<< " x: " << cmd.x
<< " y: " << cmd.y;
<< " x: " << cmd.x_
<< " y: " << cmd.y_;
}

13
src/FuncRequest.h
View File

@ -75,19 +75,18 @@ public:
static FuncRequest const unknown;
///
static FuncRequest const noaction;
public: // should be private
/// the action
FuncCode action;
private:
/// the action's string argument
docstring argument_;
public: // should be private
public:
/// the action
FuncCode action_;
/// who initiated the action
Origin origin;
Origin origin_;
/// the x coordinate of a mouse press
int x;
int x_;
/// the y coordinate of a mouse press
int y;
int y_;
/// some extra information (like button number)
mouse_button::state button_;
};

14
src/KeyMap.cpp
View File

@ -59,7 +59,7 @@ string const KeyMap::printKeySym(KeySymbol const & key, KeyModifier mod)
size_t KeyMap::bind(string const & seq, FuncRequest const & func)
{
LYXERR(Debug::KBMAP, "BIND: Sequence `" << seq << "' Action `"
<< func.action << '\'');
<< func.action_ << '\'');
KeySequence k(0, 0);
@ -113,7 +113,7 @@ void KeyMap::bind(KeySequence * seq, FuncRequest const & func, unsigned int r)
it->prefixes.reset();
}
it->func = func;
it->func.origin = FuncRequest::KEYBOARD;
it->func.origin_ = FuncRequest::KEYBOARD;
return;
} else if (!it->prefixes.get()) {
lyxerr << "Error: New binding for '"
@ -133,7 +133,7 @@ void KeyMap::bind(KeySequence * seq, FuncRequest const & func, unsigned int r)
newone->mod = seq->modifiers[r];
if (r + 1 == seq->length()) {
newone->func = func;
newone->func.origin = FuncRequest::KEYBOARD;
newone->func.origin_ = FuncRequest::KEYBOARD;
newone->prefixes.reset();
} else {
newone->prefixes.reset(new KeyMap);
@ -296,7 +296,7 @@ bool KeyMap::read(FileName const & bind_file, KeyMap * unbind_map)
string cmd = lexrc.getString();
FuncRequest func = lyxaction.lookupFunc(cmd);
if (func.action == LFUN_UNKNOWN_ACTION) {
if (func.action_ == LFUN_UNKNOWN_ACTION) {
lexrc.printError("BN_BIND: Unknown LyX function `$$Token'");
error = true;
break;
@ -322,7 +322,7 @@ bool KeyMap::read(FileName const & bind_file, KeyMap * unbind_map)
string cmd = lexrc.getString();
FuncRequest func = lyxaction.lookupFunc(cmd);
if (func.action == LFUN_UNKNOWN_ACTION) {
if (func.action_ == LFUN_UNKNOWN_ACTION) {
lexrc.printError("BN_UNBIND: Unknown LyX"
" function `$$Token'");
error = true;
@ -368,7 +368,7 @@ void KeyMap::write(string const & bind_file, bool append, bool unbind) const
BindingList::const_iterator it = list.begin();
BindingList::const_iterator it_end = list.end();
for (; it != it_end; ++it) {
FuncCode action = it->request.action;
FuncCode action = it->request.action_;
string arg = to_utf8(it->request.argument());
os << tag << " \""
@ -493,7 +493,7 @@ KeyMap::BindingList KeyMap::listBindings(bool unbound, KeyMap::ItemType tag) con
BindingList::const_iterator bit = list.begin();
BindingList::const_iterator const ben = list.end();
for (; bit != ben; ++bit)
if (bit->request.action == action) {
if (bit->request.action_ == action) {
has_action = true;
break;
}

82
src/Text3.cpp
View File

@ -198,7 +198,7 @@ static void mathDispatch(Cursor & cur, FuncRequest const & cmd, bool display)
void regexpDispatch(Cursor & cur, FuncRequest const & cmd)
{
LASSERT(cmd.action == LFUN_REGEXP_MODE, return);
LASSERT(cmd.action_ == LFUN_REGEXP_MODE, return);
if (cur.inRegexped()) {
cur.message(_("Already in regular expression mode"));
return;
@ -239,7 +239,7 @@ static bool doInsertInset(Cursor & cur, Text * text,
ci->setButtonLabel();
cur.recordUndo();
if (cmd.action == LFUN_INDEX_INSERT) {
if (cmd.action_ == LFUN_INDEX_INSERT) {
docstring ds = subst(text->getStringToIndex(cur), '\n', ' ');
text->insertInset(cur, inset);
if (edit)
@ -472,13 +472,13 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd)
bool sel = cur.selection();
// Signals that, even if needsUpdate == false, an update of the
// cursor paragraph is required
bool singleParUpdate = lyxaction.funcHasFlag(cmd.action,
bool singleParUpdate = lyxaction.funcHasFlag(cmd.action_,
LyXAction::SingleParUpdate);
// Signals that a full-screen update is required
bool needsUpdate = !(lyxaction.funcHasFlag(cmd.action,
bool needsUpdate = !(lyxaction.funcHasFlag(cmd.action_,
LyXAction::NoUpdate) || singleParUpdate);
switch (cmd.action) {
switch (cmd.action_) {
case LFUN_PARAGRAPH_MOVE_DOWN: {
pit_type const pit = cur.pit();
@ -552,7 +552,7 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd)
case LFUN_BUFFER_BEGIN:
case LFUN_BUFFER_BEGIN_SELECT:
needsUpdate |= cur.selHandle(cmd.action == LFUN_BUFFER_BEGIN_SELECT);
needsUpdate |= cur.selHandle(cmd.action_ == LFUN_BUFFER_BEGIN_SELECT);
if (cur.depth() == 1)
needsUpdate |= cursorTop(cur);
else
@ -562,7 +562,7 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd)
case LFUN_BUFFER_END:
case LFUN_BUFFER_END_SELECT:
needsUpdate |= cur.selHandle(cmd.action == LFUN_BUFFER_END_SELECT);
needsUpdate |= cur.selHandle(cmd.action_ == LFUN_BUFFER_END_SELECT);
if (cur.depth() == 1)
needsUpdate |= cursorBottom(cur);
else
@ -572,7 +572,7 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd)
case LFUN_INSET_BEGIN:
case LFUN_INSET_BEGIN_SELECT:
needsUpdate |= cur.selHandle(cmd.action == LFUN_INSET_BEGIN_SELECT);
needsUpdate |= cur.selHandle(cmd.action_ == LFUN_INSET_BEGIN_SELECT);
if (cur.depth() == 1 || !cur.top().at_begin())
needsUpdate |= cursorTop(cur);
else
@ -582,7 +582,7 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd)
case LFUN_INSET_END:
case LFUN_INSET_END_SELECT:
needsUpdate |= cur.selHandle(cmd.action == LFUN_INSET_END_SELECT);
needsUpdate |= cur.selHandle(cmd.action_ == LFUN_INSET_END_SELECT);
if (cur.depth() == 1 || !cur.top().at_end())
needsUpdate |= cursorBottom(cur);
else
@ -605,7 +605,7 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd)
case LFUN_CHAR_FORWARD:
case LFUN_CHAR_FORWARD_SELECT:
//LYXERR0(" LFUN_CHAR_FORWARD[SEL]:\n" << cur);
needsUpdate |= cur.selHandle(cmd.action == LFUN_CHAR_FORWARD_SELECT);
needsUpdate |= cur.selHandle(cmd.action_ == LFUN_CHAR_FORWARD_SELECT);
needsUpdate |= cursorForward(cur);
if (!needsUpdate && oldTopSlice == cur.top()
@ -631,7 +631,7 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd)
case LFUN_CHAR_BACKWARD:
case LFUN_CHAR_BACKWARD_SELECT:
//lyxerr << "handle LFUN_CHAR_BACKWARD[_SELECT]:\n" << cur << endl;
needsUpdate |= cur.selHandle(cmd.action == LFUN_CHAR_BACKWARD_SELECT);
needsUpdate |= cur.selHandle(cmd.action_ == LFUN_CHAR_BACKWARD_SELECT);
needsUpdate |= cursorBackward(cur);
if (!needsUpdate && oldTopSlice == cur.top()
@ -657,7 +657,7 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd)
case LFUN_CHAR_LEFT:
case LFUN_CHAR_LEFT_SELECT:
if (lyxrc.visual_cursor) {
needsUpdate |= cur.selHandle(cmd.action == LFUN_CHAR_LEFT_SELECT);
needsUpdate |= cur.selHandle(cmd.action_ == LFUN_CHAR_LEFT_SELECT);
needsUpdate |= cursorVisLeft(cur);
if (!needsUpdate && oldTopSlice == cur.top()
&& cur.boundary() == oldBoundary) {
@ -666,10 +666,10 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd)
}
} else {
if (reverseDirectionNeeded(cur)) {
cmd.action = cmd.action == LFUN_CHAR_LEFT_SELECT ?
cmd.action_ = cmd.action_ == LFUN_CHAR_LEFT_SELECT ?
LFUN_CHAR_FORWARD_SELECT : LFUN_CHAR_FORWARD;
} else {
cmd.action = cmd.action == LFUN_CHAR_LEFT_SELECT ?
cmd.action_ = cmd.action_ == LFUN_CHAR_LEFT_SELECT ?
LFUN_CHAR_BACKWARD_SELECT : LFUN_CHAR_BACKWARD;
}
dispatch(cur, cmd);
@ -680,7 +680,7 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd)
case LFUN_CHAR_RIGHT:
case LFUN_CHAR_RIGHT_SELECT:
if (lyxrc.visual_cursor) {
needsUpdate |= cur.selHandle(cmd.action == LFUN_CHAR_RIGHT_SELECT);
needsUpdate |= cur.selHandle(cmd.action_ == LFUN_CHAR_RIGHT_SELECT);
needsUpdate |= cursorVisRight(cur);
if (!needsUpdate && oldTopSlice == cur.top()
&& cur.boundary() == oldBoundary) {
@ -689,10 +689,10 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd)
}
} else {
if (reverseDirectionNeeded(cur)) {
cmd.action = cmd.action == LFUN_CHAR_RIGHT_SELECT ?
cmd.action_ = cmd.action_ == LFUN_CHAR_RIGHT_SELECT ?
LFUN_CHAR_BACKWARD_SELECT : LFUN_CHAR_BACKWARD;
} else {
cmd.action = cmd.action == LFUN_CHAR_RIGHT_SELECT ?
cmd.action_ = cmd.action_ == LFUN_CHAR_RIGHT_SELECT ?
LFUN_CHAR_FORWARD_SELECT : LFUN_CHAR_FORWARD;
}
dispatch(cur, cmd);
@ -706,11 +706,11 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd)
case LFUN_UP:
case LFUN_DOWN: {
// stop/start the selection
bool select = cmd.action == LFUN_DOWN_SELECT ||
cmd.action == LFUN_UP_SELECT;
bool select = cmd.action_ == LFUN_DOWN_SELECT ||
cmd.action_ == LFUN_UP_SELECT;
// move cursor up/down
bool up = cmd.action == LFUN_UP_SELECT || cmd.action == LFUN_UP;
bool up = cmd.action_ == LFUN_UP_SELECT || cmd.action_ == LFUN_UP;
bool const atFirstOrLastRow = cur.atFirstOrLastRow(up);
if (!atFirstOrLastRow) {
@ -732,25 +732,25 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd)
case LFUN_PARAGRAPH_UP:
case LFUN_PARAGRAPH_UP_SELECT:
needsUpdate |= cur.selHandle(cmd.action == LFUN_PARAGRAPH_UP_SELECT);
needsUpdate |= cur.selHandle(cmd.action_ == LFUN_PARAGRAPH_UP_SELECT);
needsUpdate |= cursorUpParagraph(cur);
break;
case LFUN_PARAGRAPH_DOWN:
case LFUN_PARAGRAPH_DOWN_SELECT:
needsUpdate |= cur.selHandle(cmd.action == LFUN_PARAGRAPH_DOWN_SELECT);
needsUpdate |= cur.selHandle(cmd.action_ == LFUN_PARAGRAPH_DOWN_SELECT);
needsUpdate |= cursorDownParagraph(cur);
break;
case LFUN_LINE_BEGIN:
case LFUN_LINE_BEGIN_SELECT:
needsUpdate |= cur.selHandle(cmd.action == LFUN_LINE_BEGIN_SELECT);
needsUpdate |= cur.selHandle(cmd.action_ == LFUN_LINE_BEGIN_SELECT);
needsUpdate |= tm->cursorHome(cur);
break;
case LFUN_LINE_END:
case LFUN_LINE_END_SELECT:
needsUpdate |= cur.selHandle(cmd.action == LFUN_LINE_END_SELECT);
needsUpdate |= cur.selHandle(cmd.action_ == LFUN_LINE_END_SELECT);
needsUpdate |= tm->cursorEnd(cur);
break;
@ -792,7 +792,7 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd)
case LFUN_WORD_RIGHT:
case LFUN_WORD_RIGHT_SELECT:
if (lyxrc.visual_cursor) {
needsUpdate |= cur.selHandle(cmd.action == LFUN_WORD_RIGHT_SELECT);
needsUpdate |= cur.selHandle(cmd.action_ == LFUN_WORD_RIGHT_SELECT);
needsUpdate |= cursorVisRightOneWord(cur);
if (!needsUpdate && oldTopSlice == cur.top()
&& cur.boundary() == oldBoundary) {
@ -801,10 +801,10 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd)
}
} else {
if (reverseDirectionNeeded(cur)) {
cmd.action = cmd.action == LFUN_WORD_RIGHT_SELECT ?
cmd.action_ = cmd.action_ == LFUN_WORD_RIGHT_SELECT ?
LFUN_WORD_BACKWARD_SELECT : LFUN_WORD_BACKWARD;
} else {
cmd.action = cmd.action == LFUN_WORD_RIGHT_SELECT ?
cmd.action_ = cmd.action_ == LFUN_WORD_RIGHT_SELECT ?
LFUN_WORD_FORWARD_SELECT : LFUN_WORD_FORWARD;
}
dispatch(cur, cmd);
@ -814,14 +814,14 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd)
case LFUN_WORD_FORWARD:
case LFUN_WORD_FORWARD_SELECT:
needsUpdate |= cur.selHandle(cmd.action == LFUN_WORD_FORWARD_SELECT);
needsUpdate |= cur.selHandle(cmd.action_ == LFUN_WORD_FORWARD_SELECT);
needsUpdate |= cursorForwardOneWord(cur);
break;
case LFUN_WORD_LEFT:
case LFUN_WORD_LEFT_SELECT:
if (lyxrc.visual_cursor) {
needsUpdate |= cur.selHandle(cmd.action == LFUN_WORD_LEFT_SELECT);
needsUpdate |= cur.selHandle(cmd.action_ == LFUN_WORD_LEFT_SELECT);
needsUpdate |= cursorVisLeftOneWord(cur);
if (!needsUpdate && oldTopSlice == cur.top()
&& cur.boundary() == oldBoundary) {
@ -830,10 +830,10 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd)
}
} else {
if (reverseDirectionNeeded(cur)) {
cmd.action = cmd.action == LFUN_WORD_LEFT_SELECT ?
cmd.action_ = cmd.action_ == LFUN_WORD_LEFT_SELECT ?
LFUN_WORD_FORWARD_SELECT : LFUN_WORD_FORWARD;
} else {
cmd.action = cmd.action == LFUN_WORD_LEFT_SELECT ?
cmd.action_ = cmd.action_ == LFUN_WORD_LEFT_SELECT ?
LFUN_WORD_BACKWARD_SELECT : LFUN_WORD_BACKWARD;
}
dispatch(cur, cmd);
@ -843,7 +843,7 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd)
case LFUN_WORD_BACKWARD:
case LFUN_WORD_BACKWARD_SELECT:
needsUpdate |= cur.selHandle(cmd.action == LFUN_WORD_BACKWARD_SELECT);
needsUpdate |= cur.selHandle(cmd.action_ == LFUN_WORD_BACKWARD_SELECT);
needsUpdate |= cursorBackwardOneWord(cur);
break;
@ -1409,19 +1409,19 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd)
CursorSlice old = bvcur.top();
int const wh = bv->workHeight();
int const y = max(0, min(wh - 1, cmd.y));
int const y = max(0, min(wh - 1, cmd.y_));
tm->setCursorFromCoordinates(cur, cmd.x, y);
cur.setTargetX(cmd.x);
if (cmd.y >= wh)
tm->setCursorFromCoordinates(cur, cmd.x_, y);
cur.setTargetX(cmd.x_);
if (cmd.y_ >= wh)
lyx::dispatch(FuncRequest(LFUN_DOWN_SELECT));
else if (cmd.y < 0)
else if (cmd.y_ < 0)
lyx::dispatch(FuncRequest(LFUN_UP_SELECT));
// This is to allow jumping over large insets
if (cur.top() == old) {
if (cmd.y >= wh)
if (cmd.y_ >= wh)
lyx::dispatch(FuncRequest(LFUN_DOWN_SELECT));
else if (cmd.y < 0)
else if (cmd.y_ < 0)
lyx::dispatch(FuncRequest(LFUN_UP_SELECT));
}
// We continue with our existing selection or start a new one, so don't
@ -1933,7 +1933,7 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd)
case LFUN_ACCENT_HUNGARIAN_UMLAUT:
case LFUN_ACCENT_CIRCLE:
case LFUN_ACCENT_OGONEK:
theApp()->handleKeyFunc(cmd.action);
theApp()->handleKeyFunc(cmd.action_);
if (!cmd.argument().empty())
// FIXME: Are all these characters encoded in one byte in utf8?
bv->translateAndInsert(cmd.argument()[0], this, cur);
@ -2153,7 +2153,7 @@ bool Text::getStatus(Cursor & cur, FuncRequest const & cmd,
bool enable = true;
InsetCode code = NO_CODE;
switch (cmd.action) {
switch (cmd.action_) {
case LFUN_DEPTH_DECREMENT:
enable = changeDepthAllowed(cur, DEC_DEPTH);

2
src/factory.cpp
View File

@ -80,7 +80,7 @@ Inset * createInsetHelper(Buffer * buf, FuncRequest const & cmd)
{
try {
switch (cmd.action) {
switch (cmd.action_) {
case LFUN_LINE_INSERT:
return new InsetLine;

70
src/frontends/qt4/GuiApplication.cpp
View File

@ -313,7 +313,7 @@ QString iconName(FuncRequest const & f, bool unknown)
QString name1;
QString name2;
QString path;
switch (f.action) {
switch (f.action_) {
case LFUN_MATH_INSERT:
if (!f.argument().empty()) {
path = "math/";
@ -353,7 +353,7 @@ QString iconName(FuncRequest const & f, bool unknown)
}
}
default:
name2 = toqstr(lyxaction.getActionName(f.action));
name2 = toqstr(lyxaction.getActionName(f.action_));
name1 = name2;
if (!f.argument().empty()) {
@ -390,7 +390,7 @@ QString iconName(FuncRequest const & f, bool unknown)
<< " or filename "
<< "\"" << name2 << "\""
<< " for command \""
<< lyxaction.getActionName(f.action)
<< lyxaction.getActionName(f.action_)
<< '(' << to_utf8(f.argument()) << ")\"");
if (unknown) {
@ -856,13 +856,13 @@ FuncStatus GuiApplication::getStatus(FuncRequest const & cmd) const
{
FuncStatus flag;
if (cmd.action == LFUN_NOACTION) {
if (cmd.action_ == LFUN_NOACTION) {
flag.message(from_utf8(N_("Nothing to do")));
flag.setEnabled(false);
return flag;
}
if (cmd.action == LFUN_UNKNOWN_ACTION) {
if (cmd.action_ == LFUN_UNKNOWN_ACTION) {
flag.unknown(true);
flag.setEnabled(false);
flag.message(from_utf8(N_("Unknown action")));
@ -874,7 +874,7 @@ FuncStatus GuiApplication::getStatus(FuncRequest const & cmd) const
// -- And I'd rather let an inset decide which LFUNs it is willing
// to handle (Andre')
bool enable = true;
switch (cmd.action) {
switch (cmd.action_) {
// This could be used for the no-GUI version. The GUI version is handled in
// GuiView::getStatus(). See above.
@ -903,7 +903,7 @@ FuncStatus GuiApplication::getStatus(FuncRequest const & cmd) const
// argument contains ';'-terminated commands
string const firstcmd = token(to_utf8(cmd.argument()), ';', 0);
FuncRequest func(lyxaction.lookupFunc(firstcmd));
func.origin = cmd.origin;
func.origin_ = cmd.origin_;
flag = getStatus(func);
break;
}
@ -916,7 +916,7 @@ FuncStatus GuiApplication::getStatus(FuncRequest const & cmd) const
string first;
arg = split(arg, first, ';');
FuncRequest func(lyxaction.lookupFunc(first));
func.origin = cmd.origin;
func.origin_ = cmd.origin_;
flag = getStatus(func);
// if this one is enabled, the whole thing is
if (flag.enabled())
@ -929,7 +929,7 @@ FuncStatus GuiApplication::getStatus(FuncRequest const & cmd) const
FuncRequest func;
string name = to_utf8(cmd.argument());
if (theTopLevelCmdDef().lock(name, func)) {
func.origin = cmd.origin;
func.origin_ = cmd.origin_;
flag = getStatus(func);
theTopLevelCmdDef().release(name);
} else {
@ -989,7 +989,7 @@ FuncStatus GuiApplication::getStatus(FuncRequest const & cmd) const
// entries that are buffer or view-related.
//FIXME: Abdel (09/02/10) This has very bad effect on Linux, don't know why...
/*
if (cmd.origin == FuncRequest::MENU && !current_view_->hasFocus()) {
if (cmd.origin_ == FuncRequest::MENU && !current_view_->hasFocus()) {
enable = false;
break;
}
@ -1026,11 +1026,11 @@ FuncStatus GuiApplication::getStatus(FuncRequest const & cmd) const
static docstring makeDispatchMessage(docstring const & msg,
FuncRequest const & cmd)
{
const bool verbose = (cmd.origin == FuncRequest::MENU
|| cmd.origin == FuncRequest::TOOLBAR
|| cmd.origin == FuncRequest::COMMANDBUFFER);
const bool verbose = (cmd.origin_ == FuncRequest::MENU
|| cmd.origin_ == FuncRequest::TOOLBAR
|| cmd.origin_ == FuncRequest::COMMANDBUFFER);
if (cmd.action == LFUN_SELF_INSERT || !verbose) {
if (cmd.action_ == LFUN_SELF_INSERT || !verbose) {
LYXERR(Debug::ACTION, "dispatch msg is " << msg);
return msg;
}
@ -1039,12 +1039,12 @@ static docstring makeDispatchMessage(docstring const & msg,
if (!dispatch_msg.empty())
dispatch_msg += ' ';
docstring comname = from_utf8(lyxaction.getActionName(cmd.action));
docstring comname = from_utf8(lyxaction.getActionName(cmd.action_));
bool argsadded = false;
if (!cmd.argument().empty()) {
if (cmd.action != LFUN_UNKNOWN_ACTION) {
if (cmd.action_ != LFUN_UNKNOWN_ACTION) {
comname += ' ' + cmd.argument();
argsadded = true;
}
@ -1197,7 +1197,7 @@ void GuiApplication::reconfigure(string const & option)
void GuiApplication::dispatch(FuncRequest const & cmd, DispatchResult & dr)
{
string const argument = to_utf8(cmd.argument());
FuncCode const action = cmd.action;
FuncCode const action = cmd.action_;
LYXERR(Debug::ACTION, "cmd: " << cmd);
@ -1222,7 +1222,7 @@ void GuiApplication::dispatch(FuncRequest const & cmd, DispatchResult & dr)
// Assumes that the action will be dispatched.
dr.dispatched(true);
switch (cmd.action) {
switch (cmd.action_) {
case LFUN_WINDOW_NEW:
createView(toqstr(cmd.argument()));
@ -1459,7 +1459,7 @@ void GuiApplication::dispatch(FuncRequest const & cmd, DispatchResult & dr)
string first;
arg = split(arg, first, ';');
FuncRequest func(lyxaction.lookupFunc(first));
func.origin = cmd.origin;
func.origin_ = cmd.origin_;
dispatch(func);
}
// the buffer may have been closed by one action
@ -1475,7 +1475,7 @@ void GuiApplication::dispatch(FuncRequest const & cmd, DispatchResult & dr)
string first;
arg = split(arg, first, ';');
FuncRequest func(lyxaction.lookupFunc(first));
func.origin = cmd.origin;
func.origin_ = cmd.origin_;
FuncStatus stat = getStatus(func);
if (stat.enabled()) {
dispatch(func);
@ -1488,11 +1488,11 @@ void GuiApplication::dispatch(FuncRequest const & cmd, DispatchResult & dr)
case LFUN_CALL: {
FuncRequest func;
if (theTopLevelCmdDef().lock(argument, func)) {
func.origin = cmd.origin;
func.origin_ = cmd.origin_;
dispatch(func);
theTopLevelCmdDef().release(argument);
} else {
if (func.action == LFUN_UNKNOWN_ACTION) {
if (func.action_ == LFUN_UNKNOWN_ACTION) {
// unknown command definition
lyxerr << "Warning: unknown command definition `"
<< argument << "'"
@ -1606,11 +1606,11 @@ void GuiApplication::dispatch(FuncRequest const & cmd, DispatchResult & dr)
// update completion. We do it here and not in
// processKeySym to avoid another redraw just for a
// changed inline completion
if (cmd.origin == FuncRequest::KEYBOARD) {
if (cmd.action == LFUN_SELF_INSERT
|| (cmd.action == LFUN_ERT_INSERT && bv->cursor().inMathed()))
if (cmd.origin_ == FuncRequest::KEYBOARD) {
if (cmd.action_ == LFUN_SELF_INSERT
|| (cmd.action_ == LFUN_ERT_INSERT && bv->cursor().inMathed()))
current_view_->updateCompletion(bv->cursor(), true, true);
else if (cmd.action == LFUN_CHAR_DELETE_BACKWARD)
else if (cmd.action_ == LFUN_CHAR_DELETE_BACKWARD)
current_view_->updateCompletion(bv->cursor(), false, true);
else
current_view_->updateCompletion(bv->cursor(), false, false);
@ -1691,25 +1691,25 @@ void GuiApplication::processKeySym(KeySymbol const & keysym, KeyModifier state)
d->cancel_meta_seq.reset();
FuncRequest func = d->cancel_meta_seq.addkey(keysym, state);
LYXERR(Debug::KEY, "action first set to [" << func.action << ']');
LYXERR(Debug::KEY, "action first set to [" << func.action_ << ']');
// 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 = NoModifier. RVDK_PATCH_5.
if ((func.action != LFUN_CANCEL) && (func.action != LFUN_META_PREFIX)) {
if ((func.action_ != LFUN_CANCEL) && (func.action_ != LFUN_META_PREFIX)) {
// remove Caps Lock and Mod2 as a modifiers
func = d->keyseq.addkey(keysym, (state | d->meta_fake_bit));
LYXERR(Debug::KEY, "action now set to [" << func.action << ']');
LYXERR(Debug::KEY, "action now set to [" << func.action_ << ']');
}
// Dont remove this unless you know what you are doing.
d->meta_fake_bit = NoModifier;
// Can this happen now ?
if (func.action == LFUN_NOACTION)
if (func.action_ == LFUN_NOACTION)
func = FuncRequest(LFUN_COMMAND_PREFIX);
LYXERR(Debug::KEY, " Key [action=" << func.action << "]["
LYXERR(Debug::KEY, " Key [action=" << func.action_ << "]["
<< d->keyseq.print(KeySequence::Portable) << ']');
// already here we know if it any point in going further
@ -1722,13 +1722,13 @@ void GuiApplication::processKeySym(KeySymbol const & keysym, KeyModifier state)
// Maybe user can only reach the key via holding down shift.
// Let's see. But only if shift is the only modifier
if (func.action == LFUN_UNKNOWN_ACTION && state == ShiftModifier) {
if (func.action_ == LFUN_UNKNOWN_ACTION && state == ShiftModifier) {
LYXERR(Debug::KEY, "Trying without shift");
func = d->keyseq.addkey(keysym, NoModifier);
LYXERR(Debug::KEY, "Action now " << func.action);
LYXERR(Debug::KEY, "Action now " << func.action_);
}
if (func.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
@ -1744,7 +1744,7 @@ void GuiApplication::processKeySym(KeySymbol const & keysym, KeyModifier state)
}
}
if (func.action == LFUN_SELF_INSERT) {
if (func.action_ == LFUN_SELF_INSERT) {
if (encoded_last_key != 0) {
docstring const arg(1, encoded_last_key);
lyx::dispatch(FuncRequest(LFUN_SELF_INSERT, arg,

2
src/frontends/qt4/GuiCommandBuffer.cpp
View File

@ -357,7 +357,7 @@ void GuiCommandBuffer::dispatch(string const & str)
upPB->setEnabled(history_pos_ != history_.begin());
downPB->setEnabled(history_pos_ != history_.end());
FuncRequest func = lyxaction.lookupFunc(str);
func.origin = FuncRequest::COMMANDBUFFER;
func.origin_ = FuncRequest::COMMANDBUFFER;
lyx::dispatch(func);
}

12
src/frontends/qt4/GuiPrefs.cpp
View File

@ -2562,7 +2562,7 @@ void PrefShortcuts::setItemType(QTreeWidgetItem * item, KeyMap::ItemType tag)
QTreeWidgetItem * PrefShortcuts::insertShortcutItem(FuncRequest const & lfun,
KeySequence const & seq, KeyMap::ItemType tag)
{
FuncCode action = lfun.action;
FuncCode action = lfun.action_;
string const action_name = lyxaction.getActionName(action);
QString const lfun_name = toqstr(from_utf8(action_name)
+ ' ' + lfun.argument());
@ -2776,7 +2776,7 @@ void PrefShortcuts::on_searchLE_textEdited()
docstring makeCmdString(FuncRequest const & f)
{
docstring actionStr = from_ascii(lyxaction.getActionName(f.action));
docstring actionStr = from_ascii(lyxaction.getActionName(f.action_));
if (!f.argument().empty())
actionStr += " " + f.argument();
return actionStr;
@ -2788,7 +2788,7 @@ void PrefShortcuts::shortcutOkPressed()
QString const new_lfun = shortcut_->lfunLE->text();
FuncRequest func = lyxaction.lookupFunc(fromqstr(new_lfun));
if (func.action == LFUN_UNKNOWN_ACTION) {
if (func.action_ == LFUN_UNKNOWN_ACTION) {
Alert::error(_("Failed to create shortcut"),
_("Unknown or invalid LyX function"));
return;
@ -2803,16 +2803,16 @@ void PrefShortcuts::shortcutOkPressed()
// check to see if there's been any change
FuncRequest oldBinding = system_bind_.getBinding(k);
if (oldBinding.action == LFUN_UNKNOWN_ACTION)
if (oldBinding.action_ == LFUN_UNKNOWN_ACTION)
oldBinding = user_bind_.getBinding(k);
if (oldBinding == func)
// nothing has changed
return;
// make sure this key isn't already bound---and, if so, not unbound
FuncCode const unbind = user_unbind_.getBinding(k).action;
FuncCode const unbind = user_unbind_.getBinding(k).action_;
docstring const action_string = makeCmdString(oldBinding);
if (oldBinding.action > LFUN_NOACTION && unbind == LFUN_UNKNOWN_ACTION
if (oldBinding.action_ > LFUN_NOACTION && unbind == LFUN_UNKNOWN_ACTION
&& save_lfun_ != toqstr(action_string)) {
// FIXME Perhaps we should offer to over-write the old shortcut?
// If so, we'll need to remove it from our list, etc.

14
src/frontends/qt4/GuiView.cpp
View File

@ -1388,7 +1388,7 @@ bool GuiView::getStatus(FuncRequest const & cmd, FuncStatus & flag)
? &(documentBufferView()->buffer()) : 0;
// Check whether we need a buffer
if (!lyxaction.funcHasFlag(cmd.action, LyXAction::NoBuffer) && !buf) {
if (!lyxaction.funcHasFlag(cmd.action_, LyXAction::NoBuffer) && !buf) {
// no, exit directly
flag.message(from_utf8(N_("Command not allowed with"
"out any document open")));
@ -1396,7 +1396,7 @@ bool GuiView::getStatus(FuncRequest const & cmd, FuncStatus & flag)
return true;
}
if (cmd.origin == FuncRequest::TOC) {
if (cmd.origin_ == FuncRequest::TOC) {
GuiToc * toc = static_cast<GuiToc*>(findOrBuild("toc", false));
FuncStatus fs;
if (toc->getStatus(documentBufferView()->cursor(), cmd, fs))
@ -1406,7 +1406,7 @@ bool GuiView::getStatus(FuncRequest const & cmd, FuncStatus & flag)
return true;
}
switch(cmd.action) {
switch(cmd.action_) {
case LFUN_BUFFER_IMPORT:
break;
@ -2533,7 +2533,7 @@ void GuiView::dispatchVC(FuncRequest const & cmd)
Buffer * buffer = documentBufferView()
? &(documentBufferView()->buffer()) : 0;
switch (cmd.action) {
switch (cmd.action_) {
case LFUN_VC_REGISTER:
if (!buffer || !ensureBufferClean(buffer))
break;
@ -2812,7 +2812,7 @@ void GuiView::dispatch(FuncRequest const & cmd, DispatchResult & dr)
Buffer * doc_buffer = documentBufferView()
? &(documentBufferView()->buffer()) : 0;
if (cmd.origin == FuncRequest::TOC) {
if (cmd.origin_ == FuncRequest::TOC) {
GuiToc * toc = static_cast<GuiToc*>(findOrBuild("toc", false));
// FIXME: do we need to pass a DispatchResult object here?
toc->doDispatch(bv->cursor(), cmd);
@ -2821,7 +2821,7 @@ void GuiView::dispatch(FuncRequest const & cmd, DispatchResult & dr)
string const argument = to_utf8(cmd.argument());
switch(cmd.action) {
switch(cmd.action_) {
case LFUN_BUFFER_CHILD_OPEN:
openChildDocument(to_utf8(cmd.argument()));
break;
@ -3186,7 +3186,7 @@ void GuiView::dispatch(FuncRequest const & cmd, DispatchResult & dr)
case LFUN_BUFFER_ZOOM_IN:
case LFUN_BUFFER_ZOOM_OUT:
if (cmd.argument().empty()) {
if (cmd.action == LFUN_BUFFER_ZOOM_IN)
if (cmd.action_ == LFUN_BUFFER_ZOOM_IN)
lyxrc.zoom += 20;
else
lyxrc.zoom -= 20;

12
src/frontends/qt4/GuiWorkArea.cpp
View File

@ -472,7 +472,7 @@ void GuiWorkArea::processKeySym(KeySymbol const & key, KeyModifier mod)
void GuiWorkArea::dispatch(FuncRequest const & cmd0, KeyModifier mod)
{
// Handle drag&drop
if (cmd0.action == LFUN_FILE_OPEN) {
if (cmd0.action_ == LFUN_FILE_OPEN) {
DispatchResult dr;
lyx_view_->dispatch(cmd0, dr);
return;
@ -480,7 +480,7 @@ void GuiWorkArea::dispatch(FuncRequest const & cmd0, KeyModifier mod)
FuncRequest cmd;
if (cmd0.action == LFUN_MOUSE_PRESS) {
if (cmd0.action_ == LFUN_MOUSE_PRESS) {
if (mod == ShiftModifier)
cmd = FuncRequest(cmd0, "region-select");
else if (mod == ControlModifier)
@ -492,7 +492,7 @@ void GuiWorkArea::dispatch(FuncRequest const & cmd0, KeyModifier mod)
cmd = cmd0;
bool const notJustMovingTheMouse =
cmd.action != LFUN_MOUSE_MOTION || cmd.button() != mouse_button::none;
cmd.action_ != LFUN_MOUSE_MOTION || cmd.button() != mouse_button::none;
// In order to avoid bad surprise in the middle of an operation, we better stop
// the blinking cursor.
@ -502,7 +502,7 @@ void GuiWorkArea::dispatch(FuncRequest const & cmd0, KeyModifier mod)
buffer_view_->mouseEventDispatch(cmd);
// Skip these when selecting
if (cmd.action != LFUN_MOUSE_MOTION) {
if (cmd.action_ != LFUN_MOUSE_MOTION) {
completer_->updateVisibility(false, false);
lyx_view_->updateDialogs();
lyx_view_->updateStatusBar();
@ -776,9 +776,9 @@ void GuiWorkArea::mouseMoveEvent(QMouseEvent * e)
// so they come at a steady rate:
if (e->y() <= 20)
// _Force_ a scroll up:
cmd.y = -40;
cmd.y_ = -40;
else
cmd.y = viewport()->height();
cmd.y_ = viewport()->height();
// Store the event, to be handled when the timeout expires.
synthetic_mouse_event_.cmd = cmd;

4
src/frontends/qt4/Menus.cpp
View File

@ -187,7 +187,7 @@ public:
FuncRequest::Origin origin = FuncRequest::MENU)
: kind_(kind), label_(label), func_(func), optional_(optional)
{
func_.origin = origin;
func_.origin_ = origin;
}
// boost::shared_ptr<MenuDefinition> needs this apprently...
@ -233,7 +233,7 @@ public:
return toqstr(bindings.begin()->print(KeySequence::ForGui));
LYXERR(Debug::KBMAP, "No binding for "
<< lyxaction.getActionName(func_.action)
<< lyxaction.getActionName(func_.action_)
<< '(' << func_.argument() << ')');
return QString();
}

6
src/frontends/qt4/TocWidget.cpp
View File

@ -139,7 +139,7 @@ bool TocWidget::getStatus(Cursor & cur, FuncRequest const & cmd,
TocItem const & item =
gui_view_.tocModels().currentItem(current_type_, index);
switch (cmd.action)
switch (cmd.action_)
{
case LFUN_CHANGE_ACCEPT:
case LFUN_CHANGE_REJECT:
@ -179,7 +179,7 @@ void TocWidget::doDispatch(Cursor & cur, FuncRequest const & cmd)
// Start an undo group.
cur.beginUndoGroup();
switch (cmd.action)
switch (cmd.action_)
{
case LFUN_CHANGE_ACCEPT:
case LFUN_CHANGE_REJECT:
@ -200,7 +200,7 @@ void TocWidget::doDispatch(Cursor & cur, FuncRequest const & cmd)
case LFUN_OUTLINE_DOWN:
case LFUN_OUTLINE_IN:
case LFUN_OUTLINE_OUT:
outline(cmd.action);
outline(cmd.action_);
break;
default:

2
src/frontends/qt4/Toolbars.cpp
View File

@ -55,7 +55,7 @@ ToolbarItem::ToolbarItem(Type type, string const & name, docstring const & label
void ToolbarInfo::add(ToolbarItem const & item)
{
items.push_back(item);
items.back().func_.origin = FuncRequest::TOOLBAR;
items.back().func_.origin_ = FuncRequest::TOOLBAR;
}

4
src/insets/Inset.cpp
View File

@ -322,7 +322,7 @@ bool Inset::showInsetDialog(BufferView * bv) const
void Inset::doDispatch(Cursor & cur, FuncRequest &cmd)
{
switch (cmd.action) {
switch (cmd.action_) {
case LFUN_MOUSE_RELEASE:
// if the derived inset did not explicitly handle mouse_release,
// we assume we request the settings dialog
@ -360,7 +360,7 @@ bool Inset::getStatus(Cursor &, FuncRequest const & cmd,
// Dialogs::checkStatus() ensures that the dialog is deactivated if
// LFUN_INSET_APPLY is disabled.
switch (cmd.action) {
switch (cmd.action_) {
case LFUN_INSET_MODIFY:
// Allow modification of our data.
// This needs to be handled in the doDispatch method of our

2
src/insets/InsetBibitem.cpp
View File

@ -113,7 +113,7 @@ ParamInfo const & InsetBibitem::findInfo(string const & /* cmdName */)
void InsetBibitem::doDispatch(Cursor & cur, FuncRequest & cmd)
{
switch (cmd.action) {
switch (cmd.action_) {
case LFUN_INSET_MODIFY: {
InsetCommandParams p(BIBITEM_CODE);

4
src/insets/InsetBibtex.cpp
View File

@ -77,7 +77,7 @@ ParamInfo const & InsetBibtex::findInfo(string const & /* cmdName */)
void InsetBibtex::doDispatch(Cursor & cur, FuncRequest & cmd)
{
switch (cmd.action) {
switch (cmd.action_) {
case LFUN_INSET_EDIT:
editDatabases();
@ -115,7 +115,7 @@ void InsetBibtex::doDispatch(Cursor & cur, FuncRequest & cmd)
bool InsetBibtex::getStatus(Cursor & cur, FuncRequest const & cmd,
FuncStatus & flag) const
{
switch (cmd.action) {
switch (cmd.action_) {
case LFUN_INSET_EDIT:
flag.setEnabled(true);
return true;

4
src/insets/InsetBox.cpp
View File

@ -186,7 +186,7 @@ bool InsetBox::forcePlainLayout(idx_type) const
void InsetBox::doDispatch(Cursor & cur, FuncRequest & cmd)
{
switch (cmd.action) {
switch (cmd.action_) {
case LFUN_INSET_MODIFY: {
//lyxerr << "InsetBox::dispatch MODIFY" << endl;
@ -208,7 +208,7 @@ void InsetBox::doDispatch(Cursor & cur, FuncRequest & cmd)
bool InsetBox::getStatus(Cursor & cur, FuncRequest const & cmd,
FuncStatus & flag) const
{
switch (cmd.action) {
switch (cmd.action_) {
case LFUN_INSET_MODIFY:
if (cmd.getArg(0) == "changetype")

6
src/insets/InsetBranch.cpp
View File

@ -114,7 +114,7 @@ ColorCode InsetBranch::backgroundColor(PainterInfo const & pi) const
void InsetBranch::doDispatch(Cursor & cur, FuncRequest & cmd)
{
switch (cmd.action) {
switch (cmd.action_) {
case LFUN_INSET_MODIFY: {
InsetBranchParams params;
InsetBranch::string2params(to_utf8(cmd.argument()), params);
@ -133,7 +133,7 @@ void InsetBranch::doDispatch(Cursor & cur, FuncRequest & cmd)
if (!our_branch)
break;
}
our_branch->setSelected(cmd.action == LFUN_BRANCH_ACTIVATE);
our_branch->setSelected(cmd.action_ == LFUN_BRANCH_ACTIVATE);
break;
}
case LFUN_INSET_TOGGLE:
@ -153,7 +153,7 @@ void InsetBranch::doDispatch(Cursor & cur, FuncRequest & cmd)
bool InsetBranch::getStatus(Cursor & cur, FuncRequest const & cmd,
FuncStatus & flag) const
{
switch (cmd.action) {
switch (cmd.action_) {
case LFUN_INSET_MODIFY:
flag.setEnabled(true);
break;

2
src/insets/InsetCaption.cpp
View File

@ -192,7 +192,7 @@ bool InsetCaption::insetAllowed(InsetCode code) const
bool InsetCaption::getStatus(Cursor & cur, FuncRequest const & cmd,
FuncStatus & status) const
{
switch (cmd.action) {
switch (cmd.action_) {
case LFUN_BREAK_PARAGRAPH:
status.setEnabled(false);

6
src/insets/InsetCollapsable.cpp
View File

@ -405,7 +405,7 @@ bool InsetCollapsable::descendable(BufferView const & bv) const
bool InsetCollapsable::hitButton(FuncRequest const & cmd) const
{
return button_dim.contains(cmd.x, cmd.y);
return button_dim.contains(cmd.x_, cmd.y_);
}
@ -455,7 +455,7 @@ void InsetCollapsable::doDispatch(Cursor & cur, FuncRequest & cmd)
//lyxerr << "InsetCollapsable::doDispatch (begin): cmd: " << cmd
// << " cur: " << cur << " bvcur: " << cur.bv().cursor() << endl;
switch (cmd.action) {
switch (cmd.action_) {
case LFUN_MOUSE_PRESS:
if (hitButton(cmd)) {
switch (cmd.button()) {
@ -548,7 +548,7 @@ void InsetCollapsable::doDispatch(Cursor & cur, FuncRequest & cmd)
bool InsetCollapsable::getStatus(Cursor & cur, FuncRequest const & cmd,
FuncStatus & flag) const
{
switch (cmd.action) {
switch (cmd.action_) {
case LFUN_INSET_TOGGLE:
if (cmd.argument() == "open")
flag.setEnabled(status_ != Open);

4
src/insets/InsetCommand.cpp
View File

@ -131,7 +131,7 @@ int InsetCommand::docbook(odocstream &, OutputParams const &) const
void InsetCommand::doDispatch(Cursor & cur, FuncRequest & cmd)
{
switch (cmd.action) {
switch (cmd.action_) {
case LFUN_INSET_MODIFY: {
if (cmd.getArg(0) == "changetype") {
p_.setCmdName(cmd.getArg(1));
@ -164,7 +164,7 @@ void InsetCommand::doDispatch(Cursor & cur, FuncRequest & cmd)
bool InsetCommand::getStatus(Cursor & cur, FuncRequest const & cmd,
FuncStatus & status) const
{
switch (cmd.action) {
switch (cmd.action_) {
// suppress these
case LFUN_ERT_INSERT:
status.setEnabled(false);

4
src/insets/InsetERT.cpp
View File

@ -111,7 +111,7 @@ int InsetERT::docbook(odocstream & os, OutputParams const &) const
void InsetERT::doDispatch(Cursor & cur, FuncRequest & cmd)
{
switch (cmd.action) {
switch (cmd.action_) {
case LFUN_INSET_MODIFY: {
setStatus(cur, string2params(to_utf8(cmd.argument())));
break;
@ -126,7 +126,7 @@ void InsetERT::doDispatch(Cursor & cur, FuncRequest & cmd)
bool InsetERT::getStatus(Cursor & cur, FuncRequest const & cmd,
FuncStatus & status) const
{
switch (cmd.action) {
switch (cmd.action_) {
case LFUN_INSET_MODIFY:
status.setEnabled(true);
return true;

4
src/insets/InsetExternal.cpp
View File

@ -393,7 +393,7 @@ void InsetExternal::statusChanged() const
void InsetExternal::doDispatch(Cursor & cur, FuncRequest & cmd)
{
switch (cmd.action) {
switch (cmd.action_) {
case LFUN_INSET_EDIT: {
InsetExternalParams p = params();
@ -424,7 +424,7 @@ void InsetExternal::doDispatch(Cursor & cur, FuncRequest & cmd)
bool InsetExternal::getStatus(Cursor & cur, FuncRequest const & cmd,
FuncStatus & flag) const
{
switch (cmd.action) {
switch (cmd.action_) {
case LFUN_INSET_EDIT:
case LFUN_INSET_MODIFY:

4
src/insets/InsetFlex.cpp
View File

@ -60,7 +60,7 @@ void InsetFlex::write(ostream & os) const
bool InsetFlex::getStatus(Cursor & cur, FuncRequest const & cmd,
FuncStatus & flag) const
{
switch (cmd.action) {
switch (cmd.action_) {
case LFUN_INSET_DISSOLVE:
if (!cmd.argument().empty()) {
InsetLayout const & il = getLayout();
@ -81,7 +81,7 @@ bool InsetFlex::getStatus(Cursor & cur, FuncRequest const & cmd,
void InsetFlex::doDispatch(Cursor & cur, FuncRequest & cmd)
{
switch (cmd.action) {
switch (cmd.action_) {
case LFUN_INSET_DISSOLVE:
if (!cmd.argument().empty()) {
InsetLayout const & il = getLayout();

4
src/insets/InsetFloat.cpp
View File

@ -137,7 +137,7 @@ docstring InsetFloat::toolTip(BufferView const & bv, int x, int y) const
void InsetFloat::doDispatch(Cursor & cur, FuncRequest & cmd)
{
switch (cmd.action) {
switch (cmd.action_) {
case LFUN_INSET_MODIFY: {
InsetFloatParams params;
@ -172,7 +172,7 @@ void InsetFloat::doDispatch(Cursor & cur, FuncRequest & cmd)
bool InsetFloat::getStatus(Cursor & cur, FuncRequest const & cmd,
FuncStatus & flag) const
{
switch (cmd.action) {
switch (cmd.action_) {
case LFUN_INSET_MODIFY:
case LFUN_INSET_DIALOG_UPDATE:

4
src/insets/InsetGraphics.cpp
View File

@ -192,7 +192,7 @@ InsetGraphics::~InsetGraphics()
void InsetGraphics::doDispatch(Cursor & cur, FuncRequest & cmd)
{
switch (cmd.action) {
switch (cmd.action_) {
case LFUN_INSET_EDIT: {
InsetGraphicsParams p = params();
if (!cmd.argument().empty())
@ -237,7 +237,7 @@ void InsetGraphics::doDispatch(Cursor & cur, FuncRequest & cmd)
bool InsetGraphics::getStatus(Cursor & cur, FuncRequest const & cmd,
FuncStatus & flag) const
{
switch (cmd.action) {
switch (cmd.action_) {
case LFUN_INSET_EDIT:
case LFUN_INSET_MODIFY:
case LFUN_INSET_DIALOG_UPDATE:

4
src/insets/InsetInclude.cpp
View File

@ -227,7 +227,7 @@ bool InsetInclude::isCompatibleCommand(string const & s)
void InsetInclude::doDispatch(Cursor & cur, FuncRequest & cmd)
{
switch (cmd.action) {
switch (cmd.action_) {
case LFUN_INSET_EDIT: {
editIncluded(to_utf8(params()["filename"]));
@ -304,7 +304,7 @@ void InsetInclude::editIncluded(string const & file)
bool InsetInclude::getStatus(Cursor & cur, FuncRequest const & cmd,
FuncStatus & flag) const
{
switch (cmd.action) {
switch (cmd.action_) {
case LFUN_INSET_EDIT:
flag.setEnabled(true);

8
src/insets/InsetIndex.cpp
View File

@ -196,7 +196,7 @@ bool InsetIndex::showInsetDialog(BufferView * bv) const
void InsetIndex::doDispatch(Cursor & cur, FuncRequest & cmd)
{
switch (cmd.action) {
switch (cmd.action_) {
case LFUN_INSET_MODIFY: {
if (cmd.getArg(0) == "changetype") {
@ -223,7 +223,7 @@ void InsetIndex::doDispatch(Cursor & cur, FuncRequest & cmd)
bool InsetIndex::getStatus(Cursor & cur, FuncRequest const & cmd,
FuncStatus & flag) const
{
switch (cmd.action) {
switch (cmd.action_) {
case LFUN_INSET_MODIFY:
if (cmd.getArg(0) == "changetype") {
@ -462,7 +462,7 @@ bool InsetPrintIndex::isCompatibleCommand(string const & s)
void InsetPrintIndex::doDispatch(Cursor & cur, FuncRequest & cmd)
{
switch (cmd.action) {
switch (cmd.action_) {
case LFUN_INSET_MODIFY: {
if (cmd.argument() == from_ascii("toggle-subindex")) {
@ -504,7 +504,7 @@ void InsetPrintIndex::doDispatch(Cursor & cur, FuncRequest & cmd)
bool InsetPrintIndex::getStatus(Cursor & cur, FuncRequest const & cmd,
FuncStatus & status) const
{
switch (cmd.action) {
switch (cmd.action_) {
case LFUN_INSET_MODIFY: {
if (cmd.argument() == from_ascii("toggle-subindex")) {

10
src/insets/InsetInfo.cpp
View File

@ -162,7 +162,7 @@ bool InsetInfo::validateModifyArgument(docstring const & arg) const
case MENU_INFO:
case ICON_INFO: {
FuncRequest func = lyxaction.lookupFunc(name);
return func.action != LFUN_UNKNOWN_ACTION;
return func.action_ != LFUN_UNKNOWN_ACTION;
}
case LYXRC_INFO: {
ostringstream oss;
@ -191,7 +191,7 @@ bool InsetInfo::showInsetDialog(BufferView * bv) const
bool InsetInfo::getStatus(Cursor & cur, FuncRequest const & cmd,
FuncStatus & flag) const
{
switch (cmd.action) {
switch (cmd.action_) {
case LFUN_INSET_SETTINGS:
return InsetCollapsable::getStatus(cur, cmd, flag);
@ -215,7 +215,7 @@ bool InsetInfo::getStatus(Cursor & cur, FuncRequest const & cmd,
void InsetInfo::doDispatch(Cursor & cur, FuncRequest & cmd)
{
// allow selection, copy but not cut, delete etc
switch (cmd.action) {
switch (cmd.action_) {
case LFUN_INSET_SETTINGS:
InsetCollapsable::doDispatch(cur, cmd);
break;
@ -266,7 +266,7 @@ void InsetInfo::updateInfo()
case SHORTCUT_INFO:
case SHORTCUTS_INFO: {
FuncRequest func = lyxaction.lookupFunc(name_);
if (func.action == LFUN_UNKNOWN_ACTION) {
if (func.action_ == LFUN_UNKNOWN_ACTION) {
error("Unknown action %1$s");
break;
}
@ -306,7 +306,7 @@ void InsetInfo::updateInfo()
case MENU_INFO: {
docstring_list names;
FuncRequest func = lyxaction.lookupFunc(name_);
if (func.action == LFUN_UNKNOWN_ACTION) {
if (func.action_ == LFUN_UNKNOWN_ACTION) {
error("Unknown action %1$s");
break;
}

4
src/insets/InsetLabel.cpp
View File

@ -177,7 +177,7 @@ bool InsetLabel::getStatus(Cursor & cur, FuncRequest const & cmd,
FuncStatus & status) const
{
bool enabled;
switch (cmd.action) {
switch (cmd.action_) {
case LFUN_LABEL_INSERT_AS_REF:
case LFUN_LABEL_COPY_AS_REF:
enabled = true;
@ -193,7 +193,7 @@ bool InsetLabel::getStatus(Cursor & cur, FuncRequest const & cmd,
void InsetLabel::doDispatch(Cursor & cur, FuncRequest & cmd)
{
switch (cmd.action) {
switch (cmd.action_) {
case LFUN_INSET_MODIFY: {
InsetCommandParams p(LABEL_CODE);

4
src/insets/InsetListings.cpp
View File

@ -312,7 +312,7 @@ docstring InsetListings::contextMenu(BufferView const &, int, int) const
void InsetListings::doDispatch(Cursor & cur, FuncRequest & cmd)
{
switch (cmd.action) {
switch (cmd.action_) {
case LFUN_INSET_MODIFY: {
InsetListings::string2params(to_utf8(cmd.argument()), params());
@ -333,7 +333,7 @@ void InsetListings::doDispatch(Cursor & cur, FuncRequest & cmd)
bool InsetListings::getStatus(Cursor & cur, FuncRequest const & cmd,
FuncStatus & status) const
{
switch (cmd.action) {
switch (cmd.action_) {
case LFUN_INSET_MODIFY:
case LFUN_INSET_DIALOG_UPDATE:
status.setEnabled(true);

4
src/insets/InsetNewline.cpp
View File

@ -90,7 +90,7 @@ void InsetNewline::metrics(MetricsInfo & mi, Dimension & dim) const
void InsetNewline::doDispatch(Cursor & cur, FuncRequest & cmd)
{
switch (cmd.action) {
switch (cmd.action_) {
case LFUN_INSET_MODIFY: {
InsetNewlineParams params;
@ -109,7 +109,7 @@ void InsetNewline::doDispatch(Cursor & cur, FuncRequest & cmd)
bool InsetNewline::getStatus(Cursor & cur, FuncRequest const & cmd,
FuncStatus & status) const
{
switch (cmd.action) {
switch (cmd.action_) {
// we handle these
case LFUN_INSET_MODIFY:
if (cmd.getArg(0) == "newline") {

4
src/insets/InsetNewpage.cpp
View File

@ -137,7 +137,7 @@ void InsetNewpage::draw(PainterInfo & pi, int x, int y) const
void InsetNewpage::doDispatch(Cursor & cur, FuncRequest & cmd)
{
switch (cmd.action) {
switch (cmd.action_) {
case LFUN_INSET_MODIFY: {
InsetNewpageParams params;
@ -156,7 +156,7 @@ void InsetNewpage::doDispatch(Cursor & cur, FuncRequest & cmd)
bool InsetNewpage::getStatus(Cursor & cur, FuncRequest const & cmd,
FuncStatus & status) const
{
switch (cmd.action) {
switch (cmd.action_) {
// we handle these
case LFUN_INSET_MODIFY:
if (cmd.getArg(0) == "newpage") {

4
src/insets/InsetNomencl.cpp
View File

@ -164,7 +164,7 @@ docstring InsetPrintNomencl::screenLabel() const
void InsetPrintNomencl::doDispatch(Cursor & cur, FuncRequest & cmd)
{
switch (cmd.action) {
switch (cmd.action_) {
case LFUN_INSET_MODIFY: {
InsetCommandParams p(NOMENCL_PRINT_CODE);
@ -189,7 +189,7 @@ void InsetPrintNomencl::doDispatch(Cursor & cur, FuncRequest & cmd)
bool InsetPrintNomencl::getStatus(Cursor & cur, FuncRequest const & cmd,
FuncStatus & status) const
{
switch (cmd.action) {
switch (cmd.action_) {
case LFUN_INSET_DIALOG_UPDATE:
case LFUN_INSET_MODIFY:

4
src/insets/InsetNote.cpp
View File

@ -171,7 +171,7 @@ bool InsetNote::showInsetDialog(BufferView * bv) const
void InsetNote::doDispatch(Cursor & cur, FuncRequest & cmd)
{
switch (cmd.action) {
switch (cmd.action_) {
case LFUN_INSET_MODIFY:
string2params(to_utf8(cmd.argument()), params_);
@ -192,7 +192,7 @@ void InsetNote::doDispatch(Cursor & cur, FuncRequest & cmd)
bool InsetNote::getStatus(Cursor & cur, FuncRequest const & cmd,
FuncStatus & flag) const
{
switch (cmd.action) {
switch (cmd.action_) {
case LFUN_INSET_MODIFY:
// disallow comment and greyed out in commands

4
src/insets/InsetPhantom.cpp
View File

@ -256,7 +256,7 @@ bool InsetPhantom::showInsetDialog(BufferView * bv) const
void InsetPhantom::doDispatch(Cursor & cur, FuncRequest & cmd)
{
switch (cmd.action) {
switch (cmd.action_) {
case LFUN_INSET_MODIFY:
string2params(to_utf8(cmd.argument()), params_);
@ -276,7 +276,7 @@ void InsetPhantom::doDispatch(Cursor & cur, FuncRequest & cmd)
bool InsetPhantom::getStatus(Cursor & cur, FuncRequest const & cmd,
FuncStatus & flag) const
{
switch (cmd.action) {
switch (cmd.action_) {
case LFUN_INSET_MODIFY:
if (cmd.getArg(0) == "phantom") {

4
src/insets/InsetSpace.cpp
View File

@ -141,7 +141,7 @@ docstring InsetSpace::toolTip(BufferView const &, int, int) const
void InsetSpace::doDispatch(Cursor & cur, FuncRequest & cmd)
{
switch (cmd.action) {
switch (cmd.action_) {
case LFUN_INSET_MODIFY:
string2params(to_utf8(cmd.argument()), params_);
@ -161,7 +161,7 @@ void InsetSpace::doDispatch(Cursor & cur, FuncRequest & cmd)
bool InsetSpace::getStatus(Cursor & cur, FuncRequest const & cmd,
FuncStatus & status) const
{
switch (cmd.action) {
switch (cmd.action_) {
// we handle these
case LFUN_INSET_MODIFY:
if (cmd.getArg(0) == "space") {

50
src/insets/InsetTabular.cpp
View File

@ -3050,7 +3050,7 @@ bool InsetTableCell::getStatus(Cursor & cur, FuncRequest const & cmd,
FuncStatus & status) const
{
bool enabled;
switch (cmd.action) {
switch (cmd.action_) {
case LFUN_LAYOUT:
enabled = !forcePlainLayout();
break;
@ -3505,14 +3505,14 @@ void InsetTabular::doDispatch(Cursor & cur, FuncRequest & cmd)
CursorSlice sl = cur.top();
Cursor & bvcur = cur.bv().cursor();
switch (cmd.action) {
switch (cmd.action_) {
case LFUN_MOUSE_PRESS: {
//lyxerr << "# InsetTabular::MousePress\n" << cur.bv().cursor() << endl;
// select row
if (cmd.x < xo(cur.bv()) + ADD_TO_TABULAR_WIDTH
|| cmd.x > xo(cur.bv()) + tabular.width()) {
row_type r = rowFromY(cur, cmd.y);
if (cmd.x_ < xo(cur.bv()) + ADD_TO_TABULAR_WIDTH
|| cmd.x_ > xo(cur.bv()) + tabular.width()) {
row_type r = rowFromY(cur, cmd.y_);
cur.idx() = tabular.getFirstCellInRow(r);
cur.pos() = 0;
cur.resetAnchor();
@ -3525,9 +3525,9 @@ void InsetTabular::doDispatch(Cursor & cur, FuncRequest & cmd)
}
// select column
int const y0 = yo(cur.bv()) - tabular.rowAscent(0);
if (cmd.y < y0 + ADD_TO_TABULAR_WIDTH
|| cmd.y > y0 + tabular.height()) {
col_type c = columnFromX(cur, cmd.x);
if (cmd.y_ < y0 + ADD_TO_TABULAR_WIDTH
|| cmd.y_ > y0 + tabular.height()) {
col_type c = columnFromX(cur, cmd.x_);
cur.idx() = tabular.cellIndex(0, c);
cur.pos() = 0;
cur.resetAnchor();
@ -3559,7 +3559,7 @@ void InsetTabular::doDispatch(Cursor & cur, FuncRequest & cmd)
}
// select (additional) row
if (rowselect_) {
row_type r = rowFromY(cur, cmd.y);
row_type r = rowFromY(cur, cmd.y_);
cur.idx() = tabular.getLastCellInRow(r);
// we need to reset the cursor's pit and pos now, as the old ones
// may no longer be valid.
@ -3571,7 +3571,7 @@ void InsetTabular::doDispatch(Cursor & cur, FuncRequest & cmd)
}
// select (additional) column
if (colselect_) {
col_type c = columnFromX(cur, cmd.x);
col_type c = columnFromX(cur, cmd.x_);
cur.idx() = tabular.cellIndex(tabular.nrows() - 1, c);
// we need to reset the cursor's pit and pos now, as the old ones
// may no longer be valid.
@ -3585,7 +3585,7 @@ void InsetTabular::doDispatch(Cursor & cur, FuncRequest & cmd)
if (bvcur.idx() == cur.idx() &&
!(bvcur.anchor_.idx() == cur.idx() && bvcur.pos() != cur.pos()))
cur.noUpdate();
setCursorFromCoordinates(cur, cmd.x, cmd.y);
setCursorFromCoordinates(cur, cmd.x_, cmd.y_);
bvcur.setCursor(cur);
bvcur.setSelection(true);
// if this is a multicell selection, we just set the cursor to
@ -3627,21 +3627,21 @@ void InsetTabular::doDispatch(Cursor & cur, FuncRequest & cmd)
EntryDirection entry_from = ENTRY_DIRECTION_IGNORE;
FuncCode finish_lfun;
if (cmd.action == LFUN_CHAR_FORWARD
|| cmd.action == LFUN_CHAR_FORWARD_SELECT) {
if (cmd.action_ == LFUN_CHAR_FORWARD
|| cmd.action_ == LFUN_CHAR_FORWARD_SELECT) {
next_cell = true;
finish_lfun = LFUN_FINISHED_FORWARD;
}
else if (cmd.action == LFUN_CHAR_BACKWARD
|| cmd.action == LFUN_CHAR_BACKWARD_SELECT) {
else if (cmd.action_ == LFUN_CHAR_BACKWARD
|| cmd.action_ == LFUN_CHAR_BACKWARD_SELECT) {
next_cell = false;
finish_lfun = LFUN_FINISHED_BACKWARD;
}
// LEFT or RIGHT commands --- the interpretation will depend on the
// table's direction.
else {
bool const right = cmd.action == LFUN_CHAR_RIGHT
|| cmd.action == LFUN_CHAR_RIGHT_SELECT;
bool const right = cmd.action_ == LFUN_CHAR_RIGHT
|| cmd.action_ == LFUN_CHAR_RIGHT_SELECT;
next_cell = isRightToLeft(cur) != right;
if (lyxrc.visual_cursor)
@ -3650,10 +3650,10 @@ void InsetTabular::doDispatch(Cursor & cur, FuncRequest & cmd)
finish_lfun = right ? LFUN_FINISHED_RIGHT : LFUN_FINISHED_LEFT;
}
bool const select = cmd.action == LFUN_CHAR_FORWARD_SELECT ||
cmd.action == LFUN_CHAR_BACKWARD_SELECT ||
cmd.action == LFUN_CHAR_RIGHT_SELECT ||
cmd.action == LFUN_CHAR_LEFT_SELECT;
bool const select = cmd.action_ == LFUN_CHAR_FORWARD_SELECT ||
cmd.action_ == LFUN_CHAR_BACKWARD_SELECT ||
cmd.action_ == LFUN_CHAR_RIGHT_SELECT ||
cmd.action_ == LFUN_CHAR_LEFT_SELECT;
// If we have a multicell selection or we're
// not doing some LFUN_*_SELECT thing anyway...
@ -3715,7 +3715,7 @@ void InsetTabular::doDispatch(Cursor & cur, FuncRequest & cmd)
// if our Text didn't do anything to the cursor
// then we try to put the cursor into the cell below
// setting also the right targetX.
cur.selHandle(cmd.action == LFUN_DOWN_SELECT);
cur.selHandle(cmd.action_ == LFUN_DOWN_SELECT);
if (tabular.cellRow(cur.idx()) != tabular.nrows() - 1) {
cur.idx() = tabular.cellBelow(cur.idx());
cur.pit() = 0;
@ -3748,7 +3748,7 @@ void InsetTabular::doDispatch(Cursor & cur, FuncRequest & cmd)
// if our Text didn't do anything to the cursor
// then we try to put the cursor into the cell above
// setting also the right targetX.
cur.selHandle(cmd.action == LFUN_UP_SELECT);
cur.selHandle(cmd.action_ == LFUN_UP_SELECT);
if (tabular.cellRow(cur.idx()) != 0) {
cur.idx() = tabular.cellAbove(cur.idx());
cur.pit() = cur.lastpit();
@ -3876,7 +3876,7 @@ void InsetTabular::doDispatch(Cursor & cur, FuncRequest & cmd)
case LFUN_CLIPBOARD_PASTE:
case LFUN_PRIMARY_SELECTION_PASTE: {
docstring const clip = (cmd.action == LFUN_CLIPBOARD_PASTE) ?
docstring const clip = (cmd.action_ == LFUN_CLIPBOARD_PASTE) ?
theClipboard().getAsText() :
theSelection().get();
if (clip.empty())
@ -3977,7 +3977,7 @@ void InsetTabular::doDispatch(Cursor & cur, FuncRequest & cmd)
bool InsetTabular::getStatus(Cursor & cur, FuncRequest const & cmd,
FuncStatus & status) const
{
switch (cmd.action) {
switch (cmd.action_) {
case LFUN_INSET_MODIFY: {
if (&cur.inset() != this || cmd.getArg(0) != "tabular")
break;

6
src/insets/InsetText.cpp
View File

@ -241,7 +241,7 @@ Inset * InsetText::editXY(Cursor & cur, int x, int y)
void InsetText::doDispatch(Cursor & cur, FuncRequest & cmd)
{
LYXERR(Debug::ACTION, "InsetText::doDispatch()"
<< " [ cmd.action = " << cmd.action << ']');
<< " [ cmd.action_ = " << cmd.action_ << ']');
if (getLayout().isPassThru()) {
// Force any new text to latex_language FIXME: This
@ -254,7 +254,7 @@ void InsetText::doDispatch(Cursor & cur, FuncRequest & cmd)
cur.real_current_font.setLanguage(latex_language);
}
switch (cmd.action) {
switch (cmd.action_) {
case LFUN_PASTE:
case LFUN_CLIPBOARD_PASTE:
case LFUN_SELECTION_PASTE:
@ -297,7 +297,7 @@ void InsetText::doDispatch(Cursor & cur, FuncRequest & cmd)
bool InsetText::getStatus(Cursor & cur, FuncRequest const & cmd,
FuncStatus & status) const
{
switch (cmd.action) {
switch (cmd.action_) {
case LFUN_INSET_DISSOLVE: {
bool const main_inset = &buffer().inset() == this;
bool const target_inset = cmd.argument().empty()

4
src/insets/InsetVSpace.cpp
View File

@ -55,7 +55,7 @@ InsetVSpace::InsetVSpace(VSpace const & space)
void InsetVSpace::doDispatch(Cursor & cur, FuncRequest & cmd)
{
switch (cmd.action) {
switch (cmd.action_) {
case LFUN_INSET_MODIFY: {
InsetVSpace::string2params(to_utf8(cmd.argument()), space_);
@ -72,7 +72,7 @@ void InsetVSpace::doDispatch(Cursor & cur, FuncRequest & cmd)
bool InsetVSpace::getStatus(Cursor & cur, FuncRequest const & cmd,
FuncStatus & status) const
{
switch (cmd.action) {
switch (cmd.action_) {
// we handle these
case LFUN_INSET_MODIFY:
if (cmd.getArg(0) == "vspace") {

4
src/insets/InsetWrap.cpp
View File

@ -77,7 +77,7 @@ docstring InsetWrap::toolTip(BufferView const & bv, int x, int y) const
void InsetWrap::doDispatch(Cursor & cur, FuncRequest & cmd)
{
switch (cmd.action) {
switch (cmd.action_) {
case LFUN_INSET_MODIFY: {
InsetWrapParams params;
InsetWrap::string2params(to_utf8(cmd.argument()), params);
@ -102,7 +102,7 @@ void InsetWrap::doDispatch(Cursor & cur, FuncRequest & cmd)
bool InsetWrap::getStatus(Cursor & cur, FuncRequest const & cmd,
FuncStatus & flag) const
{
switch (cmd.action) {
switch (cmd.action_) {
case LFUN_INSET_MODIFY:
case LFUN_INSET_DIALOG_UPDATE:
flag.setEnabled(true);

4
src/lyxfind.cpp
View File

@ -285,7 +285,7 @@ docstring const replace2string(docstring const & replace,
bool find(BufferView * bv, FuncRequest const & ev)
{
if (!bv || ev.action != LFUN_WORD_FIND)
if (!bv || ev.action_ != LFUN_WORD_FIND)
return false;
//lyxerr << "find called, cmd: " << ev << endl;
@ -306,7 +306,7 @@ bool find(BufferView * bv, FuncRequest const & ev)
void replace(BufferView * bv, FuncRequest const & ev, bool has_deleted)
{
if (!bv || ev.action != LFUN_WORD_REPLACE)
if (!bv || ev.action_ != LFUN_WORD_REPLACE)
return;
// data is of the form

2
src/mathed/InsetMathAMSArray.cpp
View File

@ -106,7 +106,7 @@ void InsetMathAMSArray::draw(PainterInfo & pi, int x, int y) const
bool InsetMathAMSArray::getStatus(Cursor & cur, FuncRequest const & cmd,
FuncStatus & flag) const
{
switch (cmd.action) {
switch (cmd.action_) {
case LFUN_INSET_MODIFY: {
istringstream is(to_utf8(cmd.argument()));
string s;

4
src/mathed/InsetMathCases.cpp
View File

@ -70,7 +70,7 @@ void InsetMathCases::draw(PainterInfo & pi, int x, int y) const
void InsetMathCases::doDispatch(Cursor & cur, FuncRequest & cmd)
{
//lyxerr << "*** InsetMathCases: request: " << cmd << endl;
switch (cmd.action) {
switch (cmd.action_) {
case LFUN_INSET_MODIFY: {
istringstream is(to_utf8(cmd.argument()));
string s;
@ -96,7 +96,7 @@ void InsetMathCases::doDispatch(Cursor & cur, FuncRequest & cmd)
bool InsetMathCases::getStatus(Cursor & cur, FuncRequest const & cmd,
FuncStatus & flag) const
{
switch (cmd.action) {
switch (cmd.action_) {
case LFUN_INSET_MODIFY: {
istringstream is(to_utf8(cmd.argument()));
string s;

16
src/mathed/InsetMathGrid.cpp
View File

@ -1126,7 +1126,7 @@ void InsetMathGrid::doDispatch(Cursor & cur, FuncRequest & cmd)
Parse::flags parseflg = Parse::QUIET | Parse::USETEXT;
switch (cmd.action) {
switch (cmd.action_) {
// insert file functions
case LFUN_LINE_DELETE:
@ -1379,9 +1379,9 @@ void InsetMathGrid::doDispatch(Cursor & cur, FuncRequest & cmd)
case LFUN_WORD_BACKWARD:
case LFUN_WORD_LEFT_SELECT:
case LFUN_WORD_LEFT:
cur.selHandle(cmd.action == LFUN_WORD_BACKWARD_SELECT ||
cmd.action == LFUN_WORD_LEFT_SELECT ||
cmd.action == LFUN_LINE_BEGIN_SELECT);
cur.selHandle(cmd.action_ == LFUN_WORD_BACKWARD_SELECT ||
cmd.action_ == LFUN_WORD_LEFT_SELECT ||
cmd.action_ == LFUN_LINE_BEGIN_SELECT);
cur.macroModeClose();
if (cur.pos() != 0) {
cur.pos() = 0;
@ -1403,9 +1403,9 @@ void InsetMathGrid::doDispatch(Cursor & cur, FuncRequest & cmd)
case LFUN_WORD_RIGHT:
case LFUN_LINE_END_SELECT:
case LFUN_LINE_END:
cur.selHandle(cmd.action == LFUN_WORD_FORWARD_SELECT ||
cmd.action == LFUN_WORD_RIGHT_SELECT ||
cmd.action == LFUN_LINE_END_SELECT);
cur.selHandle(cmd.action_ == LFUN_WORD_FORWARD_SELECT ||
cmd.action_ == LFUN_WORD_RIGHT_SELECT ||
cmd.action_ == LFUN_LINE_END_SELECT);
cur.macroModeClose();
cur.clearTargetX();
if (cur.pos() != cur.lastpos()) {
@ -1431,7 +1431,7 @@ void InsetMathGrid::doDispatch(Cursor & cur, FuncRequest & cmd)
bool InsetMathGrid::getStatus(Cursor & cur, FuncRequest const & cmd,
FuncStatus & status) const
{
switch (cmd.action) {
switch (cmd.action_) {
case LFUN_INSET_MODIFY: {
istringstream is(to_utf8(cmd.argument()));
string s;

8
src/mathed/InsetMathHull.cpp
View File

@ -1230,14 +1230,14 @@ void InsetMathHull::doExtern(Cursor & cur, FuncRequest & func)
void InsetMathHull::doDispatch(Cursor & cur, FuncRequest & cmd)
{
//lyxerr << "action: " << cmd.action << endl;
switch (cmd.action) {
//lyxerr << "action: " << cmd.action_ << endl;
switch (cmd.action_) {
case LFUN_FINISHED_BACKWARD:
case LFUN_FINISHED_FORWARD:
case LFUN_FINISHED_RIGHT:
case LFUN_FINISHED_LEFT:
//lyxerr << "action: " << cmd.action << endl;
//lyxerr << "action: " << cmd.action_ << endl;
InsetMathGrid::doDispatch(cur, cmd);
cur.undispatched();
break;
@ -1425,7 +1425,7 @@ void InsetMathHull::doDispatch(Cursor & cur, FuncRequest & cmd)
bool InsetMathHull::getStatus(Cursor & cur, FuncRequest const & cmd,
FuncStatus & status) const
{
switch (cmd.action) {
switch (cmd.action_) {
case LFUN_FINISHED_BACKWARD:
case LFUN_FINISHED_FORWARD:
case LFUN_FINISHED_RIGHT:

46
src/mathed/InsetMathNest.cpp
View File

@ -542,7 +542,7 @@ void InsetMathNest::doDispatch(Cursor & cur, FuncRequest & cmd)
Parse::flags parseflg = Parse::QUIET | Parse::USETEXT;
switch (cmd.action) {
switch (cmd.action_) {
case LFUN_CLIPBOARD_PASTE:
parseflg |= Parse::VERBATIM;
@ -619,10 +619,10 @@ void InsetMathNest::doDispatch(Cursor & cur, FuncRequest & cmd)
case LFUN_CHAR_BACKWARD_SELECT:
case LFUN_CHAR_FORWARD_SELECT: {
// are we in a selection?
bool select = (cmd.action == LFUN_CHAR_RIGHT_SELECT
|| cmd.action == LFUN_CHAR_LEFT_SELECT
|| cmd.action == LFUN_CHAR_BACKWARD_SELECT
|| cmd.action == LFUN_CHAR_FORWARD_SELECT);
bool select = (cmd.action_ == LFUN_CHAR_RIGHT_SELECT
|| cmd.action_ == LFUN_CHAR_LEFT_SELECT
|| cmd.action_ == LFUN_CHAR_BACKWARD_SELECT
|| cmd.action_ == LFUN_CHAR_FORWARD_SELECT);
// are we moving forward or backwards?
// If the command was RIGHT or LEFT, then whether we're moving forward
// or backwards depends on the cursor movement mode (logical or visual):
@ -634,19 +634,19 @@ void InsetMathNest::doDispatch(Cursor & cur, FuncRequest & cmd)
bool forward;
FuncCode finish_lfun;
if (cmd.action == LFUN_CHAR_FORWARD
|| cmd.action == LFUN_CHAR_FORWARD_SELECT) {
if (cmd.action_ == LFUN_CHAR_FORWARD
|| cmd.action_ == LFUN_CHAR_FORWARD_SELECT) {
forward = true;
finish_lfun = LFUN_FINISHED_FORWARD;
}
else if (cmd.action == LFUN_CHAR_BACKWARD
|| cmd.action == LFUN_CHAR_BACKWARD_SELECT) {
else if (cmd.action_ == LFUN_CHAR_BACKWARD
|| cmd.action_ == LFUN_CHAR_BACKWARD_SELECT) {
forward = false;
finish_lfun = LFUN_FINISHED_BACKWARD;
}
else {
bool right = (cmd.action == LFUN_CHAR_RIGHT_SELECT
|| cmd.action == LFUN_CHAR_RIGHT);
bool right = (cmd.action_ == LFUN_CHAR_RIGHT_SELECT
|| cmd.action_ == LFUN_CHAR_RIGHT);
if (lyxrc.visual_cursor || !reverseDirectionNeeded(cur))
forward = right;
else
@ -683,12 +683,12 @@ void InsetMathNest::doDispatch(Cursor & cur, FuncRequest & cmd)
}
// stop/start the selection
bool select = cmd.action == LFUN_DOWN_SELECT ||
cmd.action == LFUN_UP_SELECT;
bool select = cmd.action_ == LFUN_DOWN_SELECT ||
cmd.action_ == LFUN_UP_SELECT;
cur.selHandle(select);
// go up/down
bool up = cmd.action == LFUN_UP || cmd.action == LFUN_UP_SELECT;
bool up = cmd.action_ == LFUN_UP || cmd.action_ == LFUN_UP_SELECT;
bool successful = cur.upDownInMath(up);
if (successful)
break;
@ -728,9 +728,9 @@ void InsetMathNest::doDispatch(Cursor & cur, FuncRequest & cmd)
case LFUN_LINE_BEGIN_SELECT:
case LFUN_WORD_BACKWARD_SELECT:
case LFUN_WORD_LEFT_SELECT:
cur.selHandle(cmd.action == LFUN_WORD_BACKWARD_SELECT ||
cmd.action == LFUN_WORD_LEFT_SELECT ||
cmd.action == LFUN_LINE_BEGIN_SELECT);
cur.selHandle(cmd.action_ == LFUN_WORD_BACKWARD_SELECT ||
cmd.action_ == LFUN_WORD_LEFT_SELECT ||
cmd.action_ == LFUN_LINE_BEGIN_SELECT);
cur.macroModeClose();
if (cur.pos() != 0) {
cur.pos() = 0;
@ -753,9 +753,9 @@ void InsetMathNest::doDispatch(Cursor & cur, FuncRequest & cmd)
case LFUN_WORD_FORWARD_SELECT:
case LFUN_WORD_RIGHT_SELECT:
case LFUN_LINE_END_SELECT:
cur.selHandle(cmd.action == LFUN_WORD_FORWARD_SELECT ||
cmd.action == LFUN_WORD_RIGHT_SELECT ||
cmd.action == LFUN_LINE_END_SELECT);
cur.selHandle(cmd.action_ == LFUN_WORD_FORWARD_SELECT ||
cmd.action_ == LFUN_WORD_RIGHT_SELECT ||
cmd.action_ == LFUN_LINE_END_SELECT);
cur.macroModeClose();
cur.clearTargetX();
if (cur.pos() != cur.lastpos()) {
@ -1146,7 +1146,7 @@ void InsetMathNest::doDispatch(Cursor & cur, FuncRequest & cmd)
case LFUN_MATH_MACRO_FOLD:
case LFUN_MATH_MACRO_UNFOLD: {
Cursor it = cur;
bool fold = cmd.action == LFUN_MATH_MACRO_FOLD;
bool fold = cmd.action_ == LFUN_MATH_MACRO_FOLD;
bool found = findMacroToFoldUnfold(it, fold);
if (found) {
MathMacro * macro = it.nextInset()->asInsetMath()->asMacro();
@ -1264,7 +1264,7 @@ bool InsetMathNest::getStatus(Cursor & cur, FuncRequest const & cmd,
//string tc = "mathnormal";
bool ret = true;
string const arg = to_utf8(cmd.argument());
switch (cmd.action) {
switch (cmd.action_) {
case LFUN_INSET_MODIFY:
flag.setEnabled(false);
break;
@ -1353,7 +1353,7 @@ bool InsetMathNest::getStatus(Cursor & cur, FuncRequest const & cmd,
case LFUN_MATH_MACRO_FOLD:
case LFUN_MATH_MACRO_UNFOLD: {
Cursor it = cur;
bool found = findMacroToFoldUnfold(it, cmd.action == LFUN_MATH_MACRO_FOLD);
bool found = findMacroToFoldUnfold(it, cmd.action_ == LFUN_MATH_MACRO_FOLD);
flag.setEnabled(found);
break;
}

4
src/mathed/InsetMathRef.cpp
View File

@ -61,7 +61,7 @@ void InsetMathRef::infoize(odocstream & os) const
void InsetMathRef::doDispatch(Cursor & cur, FuncRequest & cmd)
{
switch (cmd.action) {
switch (cmd.action_) {
case LFUN_INSET_MODIFY:
if (cmd.getArg(0) == "ref") {
MathData ar;
@ -110,7 +110,7 @@ void InsetMathRef::doDispatch(Cursor & cur, FuncRequest & cmd)
bool InsetMathRef::getStatus(Cursor & cur, FuncRequest const & cmd,
FuncStatus & status) const
{
switch (cmd.action) {
switch (cmd.action_) {
// we handle these
case LFUN_INSET_MODIFY:
case LFUN_INSET_DIALOG_UPDATE:

2
src/mathed/InsetMathScript.cpp
View File

@ -753,7 +753,7 @@ void InsetMathScript::doDispatch(Cursor & cur, FuncRequest & cmd)
{
//LYXERR("InsetMathScript: request: " << cmd);
if (cmd.action == LFUN_MATH_LIMITS) {
if (cmd.action_ == LFUN_MATH_LIMITS) {
if (!cmd.argument().empty()) {
if (cmd.argument() == "limits")
limits_ = 1;

4
src/mathed/InsetMathSpace.cpp
View File

@ -277,7 +277,7 @@ docstring InsetMathSpace::contextMenu(BufferView const &, int, int) const
bool InsetMathSpace::getStatus(Cursor & cur, FuncRequest const & cmd,
FuncStatus & status) const
{
switch (cmd.action) {
switch (cmd.action_) {
// we handle these
case LFUN_INSET_MODIFY:
case LFUN_INSET_DIALOG_UPDATE:
@ -295,7 +295,7 @@ bool InsetMathSpace::getStatus(Cursor & cur, FuncRequest const & cmd,
void InsetMathSpace::doDispatch(Cursor & cur, FuncRequest & cmd)
{
switch (cmd.action) {
switch (cmd.action_) {
case LFUN_INSET_MODIFY:
if (cmd.getArg(0) == "mathspace") {
MathData ar;

2
src/mathed/InsetMathSplit.cpp
View File

@ -69,7 +69,7 @@ void InsetMathSplit::draw(PainterInfo & pi, int x, int y) const
bool InsetMathSplit::getStatus(Cursor & cur, FuncRequest const & cmd,
FuncStatus & flag) const
{
switch (cmd.action) {
switch (cmd.action_) {
case LFUN_INSET_MODIFY: {
istringstream is(to_utf8(cmd.argument()));
string s;

2
src/mathed/InsetMathSubstack.cpp
View File

@ -62,7 +62,7 @@ void InsetMathSubstack::draw(PainterInfo & pi, int x, int y) const
bool InsetMathSubstack::getStatus(Cursor & cur, FuncRequest const & cmd,
FuncStatus & flag) const
{
switch (cmd.action) {
switch (cmd.action_) {
case LFUN_INSET_MODIFY: {
istringstream is(to_utf8(cmd.argument()));
string s;

4
src/mathed/MathMacroTemplate.cpp
View File

@ -974,7 +974,7 @@ void MathMacroTemplate::makeNonOptional(Cursor & cur,
void MathMacroTemplate::doDispatch(Cursor & cur, FuncRequest & cmd)
{
string const arg = to_utf8(cmd.argument());
switch (cmd.action) {
switch (cmd.action_) {
case LFUN_MATH_MACRO_ADD_PARAM:
if (numargs_ < 9) {
@ -1064,7 +1064,7 @@ bool MathMacroTemplate::getStatus(Cursor & /*cur*/, FuncRequest const & cmd,
{
bool ret = true;
string const arg = to_utf8(cmd.argument());
switch (cmd.action) {
switch (cmd.action_) {
case LFUN_MATH_MACRO_ADD_PARAM: {
int num = numargs_ + 1;
if (arg.size() != 0)