anne/lyx_mirror
1
0
Fork 0
mirror of https://git.lyx.org/repos/lyx.git synced 2025-01-09 10:47:57 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

IU stuff + shuffling things from BV::dispatch to LyXText::dispatch

Browse Source 
git-svn-id: svn://svn.lyx.org/lyx/lyx-devel/trunk@8427 a592a061-630c-0410-9148-cb99ea01b6c8
This commit is contained in:
André Pönitz 2004-02-13 07:30:59 +00:00
parent df974a3904
commit 4bcfc43c29
25 changed files with 566 additions and 602 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

22
src/BufferView.C
View File

@ -324,26 +324,6 @@ void BufferView::gotoLabel(string const & label)
}
void BufferView::replaceWord(string const & replacestring)
{
if (!available())
return;
LyXText * t = getLyXText();
t->replaceSelectionWithString(replacestring);
t->setSelectionRange(replacestring.length());
// Go back so that replacement string is also spellchecked
for (string::size_type i = 0; i < replacestring.length() + 1; ++i)
t->cursorLeft(cursor(), this);
// FIXME: should be done through LFUN
buffer()->markDirty();
update();
}
void BufferView::hideCursor()
{
screen().hideCursor();
@ -455,7 +435,7 @@ void BufferView::putSelectionAt(PosIterator const & cur,
cursor().updatePos();
if (length) {
text->setSelectionRange(length);
text->setSelectionRange(cursor(), length);
cursor().setSelection();
if (backwards)
swap(cursor().cursor_, cursor().anchor_);

2
src/BufferView.h
View File

@ -117,8 +117,6 @@ public:
/// return the parent language of the given inset
Language const * getParentLanguage(InsetOld * inset) const;
/// replace the currently selected word
void replaceWord(std::string const & replacestring);
/// simple replacing. Use the font of the first selected character
void replaceSelectionWithString(std::string const & str);

45
src/BufferView_pimpl.C
View File

@ -65,8 +65,6 @@
#include <boost/bind.hpp>
using bv_funcs::currentState;
using lyx::pos_type;
using lyx::support::AddPath;
@ -975,7 +973,6 @@ bool BufferView::Pimpl::dispatch(FuncRequest const & cmd)
<< " button[" << cmd.button() << ']'
<< endl;
LyXTextClass const & tclass = buffer_->params().getLyXTextClass();
LCursor & cur = bv_->cursor();
switch (cmd.action) {
@ -1015,7 +1012,7 @@ bool BufferView::Pimpl::dispatch(FuncRequest const & cmd)
break;
case LFUN_FONT_STATE:
owner_->getLyXFunc().setMessage(currentState(bv_));
cur.message(cur.currentState());
break;
case LFUN_INSERT_LABEL: {
@ -1049,31 +1046,13 @@ bool BufferView::Pimpl::dispatch(FuncRequest const & cmd)
if (!label.empty())
bv_->gotoLabel(label);
}
break;
}
case LFUN_PARAGRAPH_APPLY:
setParagraphParams(*bv_, cmd.argument);
break;
case LFUN_THESAURUS_ENTRY: {
string arg = cmd.argument;
if (arg.empty()) {
arg = cur.selectionAsString(false);
// FIXME
if (arg.size() > 100 || arg.empty()) {
// Get word or selection
bv_->getLyXText()->selectWordWhenUnderCursor(lyx::WHOLE_WORD);
arg = cur.selectionAsString(false);
// FIXME: where is getLyXText()->unselect(bv_) ?
}
}
bv_->owner()->getDialogs().show("thesaurus", arg);
break;
}
case LFUN_TRACK_CHANGES:
trackChanges();
break;
@ -1083,31 +1062,19 @@ bool BufferView::Pimpl::dispatch(FuncRequest const & cmd)
break;
case LFUN_ACCEPT_ALL_CHANGES: {
bv_->text()->setCursor(0, 0);
bv_->cursor().reset();
#warning FIXME changes
while (lyx::find::findNextChange(bv_))
bv_->getLyXText()->acceptChange();
bv_->getLyXText()->acceptChange(bv_->cursor());
update();
break;
}
case LFUN_REJECT_ALL_CHANGES: {
bv_->text()->setCursor(0, 0);
bv_->cursor().reset();
#warning FIXME changes
while (lyx::find::findNextChange(bv_))
bv_->getLyXText()->rejectChange();
update();
break;
}
case LFUN_ACCEPT_CHANGE: {
bv_->getLyXText()->acceptChange();
update();
break;
}
case LFUN_REJECT_CHANGE: {
bv_->getLyXText()->rejectChange();
bv_->getLyXText()->rejectChange(bv_->cursor());
update();
break;
}

1
src/ChangeLog
View File

@ -5,6 +5,7 @@
* text.C:
* text2.C:
* text3.C: add LCursor & parameter to most cursor movement functions
remove usage of LyXText::cursorRow() and cursorPar()
* cursor.[Ch]: add textRow() needed members

3
src/Spacing.C
View File

@ -11,9 +11,10 @@
#include <config.h>
#include "support/std_sstream.h"
#include "Spacing.h"
#include "support/std_sstream.h"
using std::ios;
using std::istringstream;
using std::ostream;

112
src/bufferview_funcs.C
View File

@ -145,118 +145,10 @@ bool string2font(string const & data, LyXFont & font, bool & toggle)
}
bool changeDepthAllowed(BufferView * bv, LyXText * text, DEPTH_CHANGE type)
bool changeDepthAllowed(LCursor & cur, LyXText * text, DEPTH_CHANGE type)
{
return bv->available() && text && text->changeDepthAllowed(type);
return cur.bv().available() && text && text->changeDepthAllowed(cur, type);
}
void changeDepth(BufferView * bv, LyXText * text, DEPTH_CHANGE type)
{
if (bv->available() && text)
text->changeDepth(type);
}
// Returns the current font and depth as a message.
string const currentState(BufferView * bv)
{
ostringstream state;
if (!bv->available())
return string();
if (bv->cursor().inMathed()) {
bv->cursor().info(state);
return state.str();
}
LyXText * text = bv->getLyXText();
Buffer * buffer = bv->buffer();
CursorSlice const & c = text->cursor();
bool const show_change = buffer->params().tracking_changes
&& text->cursor().pos() != text->cursorPar()->size()
&& text->cursorPar()->lookupChange(c.pos()) != Change::UNCHANGED;
if (show_change) {
Change change = text->cursorPar()->lookupChangeFull(c.pos());
Author const & a = bv->buffer()->params().authors().get(change.author);
state << _("Change: ") << a.name();
if (!a.email().empty())
state << " (" << a.email() << ")";
if (change.changetime)
state << _(" at ") << ctime(&change.changetime);
state << " : ";
}
// I think we should only show changes from the default
// font. (Asger)
LyXFont font = text->real_current_font;
font.reduce(buffer->params().getLyXTextClass().defaultfont());
// avoid _(...) re-entrance problem
string const s = font.stateText(&buffer->params());
state << bformat(_("Font: %1$s"), s);
// state << bformat(_("Font: %1$s"), font.stateText(&buffer->params));
// The paragraph depth
int depth = text->getDepth();
if (depth > 0)
state << bformat(_(", Depth: %1$s"), tostr(depth));
// The paragraph spacing, but only if different from
// buffer spacing.
if (!text->cursorPar()->params().spacing().isDefault()) {
Spacing::Space cur_space =
text->cursorPar()->params().spacing().getSpace();
state << _(", Spacing: ");
switch (cur_space) {
case Spacing::Single:
state << _("Single");
break;
case Spacing::Onehalf:
state << _("OneHalf");
break;
case Spacing::Double:
state << _("Double");
break;
case Spacing::Other:
state << _("Other (")
<< text->cursorPar()->params().spacing().getValue()
<< ')';
break;
case Spacing::Default:
// should never happen, do nothing
break;
}
}
#ifdef DEVEL_VERSION
ParagraphList::iterator pit = text->cursorPar();
state << _(", Paragraph: ") << pit->id();
state << _(", Position: ") << text->cursor().pos();
RowList::iterator rit = pit->getRow(text->cursor().pos());
state << bformat(_(", Row b:%1$d e:%2$d"), rit->pos(), rit->endpos());
state << _(", Inset: ");
InsetOld * inset = pit->inInset();
if (inset)
state << inset << " owner: " << inset->owner();
else
state << -1;
#endif
return state.str();
}
// deletes a selection during an insertion
void replaceSelection(LyXText * text)
{
if (text->bv()->cursor().selection()) {
text->cutSelection(true, false);
text->bv()->update();
}
}
} // namespace bv_funcs

12
src/bufferview_funcs.h
View File

@ -18,6 +18,7 @@
class BufferView;
class LCursor;
class LyXFont;
class LyXText;
class PosIterator;
@ -45,17 +46,8 @@ enum DEPTH_CHANGE {
DEC_DEPTH
};
/// Increase or decrease the nesting depth of the selected paragraph(s)
void changeDepth(BufferView *, LyXText *, DEPTH_CHANGE);
/// Returns whether something would be changed by changeDepth
bool changeDepthAllowed(BufferView *, LyXText *, DEPTH_CHANGE);
/// Returns the current font and depth as a message.
std::string const currentState(BufferView *);
/// replace selection with insertion
void replaceSelection(LyXText * lt);
bool changeDepthAllowed(LCursor & cur, LyXText * text, DEPTH_CHANGE);
}; // namespace bv_funcs

50
src/cursor.C
View File

@ -35,6 +35,8 @@
#include "mathed/math_support.h"
#include "support/limited_stack.h"
#include "support/std_sstream.h"
#include "frontends/LyXView.h"
#include <boost/assert.hpp>
@ -255,7 +257,7 @@ void LCursor::getDim(int & asc, int & des) const
asc = 10;
des = 10;
} else {
Row const & row = *text()->cursorRow();
Row const & row = textRow();
asc = row.baseline();
des = row.height() - asc;
}
@ -568,7 +570,7 @@ MathArray & LCursor::cell()
}
void LCursor::info(std::ostream & os)
void LCursor::info(std::ostream & os) const
{
for (int i = 1, n = depth(); i < n; ++i) {
cursor_[i].inset()->infoize(os);
@ -1031,7 +1033,7 @@ void LCursor::insert(InsetBase * inset)
if (inMathed())
insert(MathAtom(inset));
else
text()->insertInset(inset);
text()->insertInset(*this, inset);
}
@ -1829,8 +1831,7 @@ InsetBase * LCursor::nextInset()
return 0;
if (inMathed())
return nextAtom().nucleus();
Paragraph & par = paragraph();
return par.isInset(pos()) ? par.getInset(pos()) : 0;
return paragraph().isInset(pos()) ? paragraph().getInset(pos()) : 0;
}
@ -1840,8 +1841,17 @@ InsetBase * LCursor::prevInset()
return 0;
if (inMathed())
return prevAtom().nucleus();
Paragraph & par = paragraph();
return par.isInset(pos() - 1) ? par.getInset(pos() - 1) : 0;
return paragraph().isInset(pos() - 1) ? paragraph().getInset(pos() - 1) : 0;
}
InsetBase const * LCursor::prevInset() const
{
if (pos() == 0)
return 0;
if (inMathed())
return prevAtom().nucleus();
return paragraph().isInset(pos() - 1) ? paragraph().getInset(pos() - 1) : 0;
}
@ -1892,3 +1902,29 @@ string LCursor::selectionAsString(bool label) const
#warning an mathed?
return string();
}
string LCursor::currentState()
{
if (inMathed()) {
std::ostringstream os;
info(os);
return os.str();
}
return text()->currentState(*this);
}
// only used by the spellchecker
void LCursor::replaceWord(string const & replacestring)
{
LyXText * t = text();
t->replaceSelectionWithString(*this, replacestring);
t->setSelectionRange(*this, replacestring.length());
// Go back so that replacement string is also spellchecked
for (string::size_type i = 0; i < replacestring.length() + 1; ++i)
t->cursorLeft(*this, true);
}

8
src/cursor.h
View File

@ -146,6 +146,8 @@ public:
std::string selectionAsString(bool label) const;
///
void paste(std::string const & data);
///
std::string currentState();
//
// access to the 'current' cursor slice
@ -189,6 +191,8 @@ public:
InsetBase * nextInset();
/// the inset just in front of the cursor
InsetBase * prevInset();
/// the inset just in front of the cursor
InsetBase const * prevInset() const;
//
// math-specific part
@ -276,11 +280,13 @@ public:
/// access to owning BufferView
BufferView & bv() const;
/// get some interesting description of current position
void info(std::ostream & os);
void info(std::ostream & os) const;
/// are we in math mode (2), text mode (1) or unsure (0)?
int currentMode();
/// reset cursor
void reset();
/// for spellchecking
void replaceWord(std::string const & replacestring);
/// output
friend std::ostream & operator<<(std::ostream & os, LCursor const & cur);

2
src/factory.C
View File

@ -154,7 +154,7 @@ InsetBase * createInset(BufferView * bv, FuncRequest const & cmd)
// Try and generate a valid index entry.
InsetCommandParams icp("index");
string const contents = cmd.argument.empty() ?
bv->getLyXText()->getStringToIndex() :
bv->getLyXText()->getStringToIndex(bv->cursor()) :
cmd.argument;
icp.setContents(contents);

17
src/frontends/controllers/ControlCommandBuffer.C
View File

@ -13,17 +13,18 @@
#include <config.h>
#include "ControlCommandBuffer.h"
#include "bufferview_funcs.h"
#include "BufferView.h"
#include "cursor.h"
#include "lyxfunc.h"
#include "LyXAction.h"
#include "funcrequest.h"
#include "frontends/LyXView.h"
#include "support/lyxalgo.h"
#include "support/lstrings.h"
using bv_funcs::currentState;
using lyx::support::prefixIs;
using std::back_inserter;
@ -66,9 +67,9 @@ string const ControlCommandBuffer::historyUp()
string const ControlCommandBuffer::historyDown()
{
if (history_pos_ == history_.end())
return "";
return string();
if (history_pos_ + 1 == history_.end())
return "";
return string();
return *(++history_pos_);
}
@ -76,7 +77,7 @@ string const ControlCommandBuffer::historyDown()
string const ControlCommandBuffer::getCurrentState() const
{
return currentState(lv_.view().get());
return lv_.view()->cursor().currentState();
}
@ -98,9 +99,9 @@ ControlCommandBuffer::completions(string const & prefix, string & new_prefix)
return vector<string>();
}
// find maximal avaliable prefix
// find maximal available prefix
string const tmp = comp[0];
string test(prefix);
string test = prefix;
if (tmp.length() > test.length())
test += tmp[test.length()];
while (test.length() < tmp.length()) {

19
src/frontends/controllers/ControlSpellchecker.C
View File

@ -16,12 +16,11 @@
#include "buffer.h"
#include "bufferparams.h"
#include "BufferView.h"
#include "bufferview_funcs.h"
#include "cursor.h"
#include "debug.h"
#include "gettext.h"
#include "language.h"
#include "lyxrc.h"
#include "PosIterator.h"
#include "paragraph.h"
@ -235,17 +234,17 @@ void ControlSpellchecker::check()
lyxerr[Debug::GUI] << "Found word \"" << word_.word() << "\"" << endl;
if (!word_.word().empty()) {
int const size = word_.word().size();
advance(cur, -size);
bufferview()->putSelectionAt(cur, size, false);
advance(cur, size);
} else {
if (word_.word().empty()) {
showSummary();
endSession();
return;
}
int const size = word_.word().size();
advance(cur, -size);
bufferview()->putSelectionAt(cur, size, false);
advance(cur, size);
// set suggestions
if (res != SpellBase::OK && res != SpellBase::IGNORE) {
lyxerr[Debug::GUI] << "Found a word needing checking." << endl;
@ -292,7 +291,9 @@ void ControlSpellchecker::showSummary()
void ControlSpellchecker::replace(string const & replacement)
{
bufferview()->replaceWord(replacement);
bufferview()->cursor().replaceWord(replacement);
bufferview()->buffer()->markDirty();
bufferview()->update();
// fix up the count
--count_;
check();

5
src/insets/insetcollapsable.C
View File

@ -348,15 +348,14 @@ InsetCollapsable::priv_dispatch(LCursor & cur, FuncRequest const & cmd)
return lfunMouseRelease(cur, cmd);
case LFUN_INSET_TOGGLE:
if (inset.text_.toggleInset())
if (inset.text_.toggleInset(cur))
return DispatchResult(true, true);
if (status_ == Open) {
setStatus(Inlined);
return DispatchResult(true, true);
} else {
}
setStatus(Collapsed);
return DispatchResult(false, FINISHED_RIGHT);
}
default:
return inset.dispatch(cur, cmd);

6
src/insets/insettext.C
View File

@ -52,8 +52,6 @@
#include <boost/bind.hpp>
using bv_funcs::replaceSelection;
using lyx::pos_type;
using lyx::graphics::PreviewLoader;
@ -279,7 +277,7 @@ void InsetText::sanitizeEmptyText(BufferView & bv)
&& bv.getParentLanguage(this) != text_.current_font.language()) {
LyXFont font(LyXFont::ALL_IGNORE);
font.setLanguage(bv.getParentLanguage(this));
text_.setFont(font, false);
text_.setFont(bv.cursor(), font, false);
}
}
@ -329,7 +327,7 @@ DispatchResult InsetText::priv_dispatch(LCursor & cur, FuncRequest const & cmd)
paragraphs().size() == 1) {
LyXFont font(LyXFont::ALL_IGNORE);
font.setLanguage(cur.bv().getParentLanguage(this));
text_.setFont(font, false);
text_.setFont(cur, font, false);
}
//lyxerr << "InsetText::priv_dispatch (end)" << endl;

4
src/lyx_cb.C
View File

@ -361,9 +361,9 @@ void InsertAsciiFile(BufferView * bv, string const & f, bool asParagraph)
if (bv->text() == bv->getLyXText())
bv->cursor().clearSelection();
if (asParagraph)
bv->getLyXText()->insertStringAsParagraphs(tmpstr);
bv->getLyXText()->insertStringAsParagraphs(bv->cursor(), tmpstr);
else
bv->getLyXText()->insertStringAsLines(tmpstr);
bv->getLyXText()->insertStringAsLines(bv->cursor(), tmpstr);
bv->update();
}

4
src/lyxfind.C
View File

@ -388,8 +388,8 @@ int replace(BufferView * bv, string const & searchstr,
LyXText * text = bv->getLyXText();
text->replaceSelectionWithString(replacestr);
text->setSelectionRange(replacestr.length());
text->replaceSelectionWithString(bv->cursor(), replacestr);
text->setSelectionRange(bv->cursor(), replacestr.length());
bv->cursor().current() = fw ? bv->cursor().selEnd() : bv->cursor().selBegin();
bv->buffer()->markDirty();
find(bv, searchstr, cs, mw, fw);

113
src/lyxfunc.C
View File

@ -82,8 +82,6 @@
#include "support/std_sstream.h"
#include "support/os.h"
using bv_funcs::changeDepth;
using bv_funcs::currentState;
using bv_funcs::DEC_DEPTH;
using bv_funcs::freefont2string;
using bv_funcs::INC_DEPTH;
@ -257,19 +255,19 @@ void LyXFunc::processKeySym(LyXKeySymPtr keysym, key_modifier::state state)
}
FuncStatus LyXFunc::getStatus(FuncRequest const & ev) const
FuncStatus LyXFunc::getStatus(FuncRequest const & cmd) const
{
FuncStatus flag;
Buffer * buf = owner->buffer();
LCursor & cur = view()->cursor();
if (ev.action == LFUN_NOACTION) {
if (cmd.action == LFUN_NOACTION) {
setStatusMessage(N_("Nothing to do"));
flag.disabled(true);
return flag;
}
switch (ev.action) {
switch (cmd.action) {
case LFUN_UNKNOWN_ACTION:
#ifndef HAVE_LIBAIKSAURUS
case LFUN_THESAURUS_ENTRY:
@ -278,7 +276,7 @@ FuncStatus LyXFunc::getStatus(FuncRequest const & ev) const
flag.disabled(true);
break;
default:
flag |= lyx_gui::getStatus(ev);
flag |= lyx_gui::getStatus(cmd);
}
if (flag.unknown()) {
@ -290,13 +288,13 @@ FuncStatus LyXFunc::getStatus(FuncRequest const & ev) const
setStatusMessage(N_("Command disabled"));
// Check whether we need a buffer
if (!lyxaction.funcHasFlag(ev.action, LyXAction::NoBuffer)) {
if (!lyxaction.funcHasFlag(cmd.action, LyXAction::NoBuffer)) {
// Yes we need a buffer, do we have one?
if (buf) {
// yes
// Can we use a readonly buffer?
if (buf->isReadonly() &&
!lyxaction.funcHasFlag(ev.action,
!lyxaction.funcHasFlag(cmd.action,
LyXAction::ReadOnly)) {
// no
setStatusMessage(N_("Document is read-only"));
@ -317,10 +315,10 @@ FuncStatus LyXFunc::getStatus(FuncRequest const & ev) const
// I would really like to avoid having this switch and rather try to
// encode this in the function itself.
bool disable = false;
switch (ev.action) {
switch (cmd.action) {
case LFUN_EXPORT:
disable = ev.argument != "custom"
&& !Exporter::IsExportable(*buf, ev.argument);
disable = cmd.argument != "custom"
&& !Exporter::IsExportable(*buf, cmd.argument);
break;
case LFUN_UNDO:
disable = buf->undostack().empty();
@ -349,11 +347,11 @@ FuncStatus LyXFunc::getStatus(FuncRequest const & ev) const
break;
case LFUN_DEPTH_MIN:
disable = !changeDepthAllowed(view(), view()->getLyXText(), DEC_DEPTH);
disable = !changeDepthAllowed(cur, view()->getLyXText(), DEC_DEPTH);
break;
case LFUN_DEPTH_PLUS:
disable = !changeDepthAllowed(view(), view()->getLyXText(), INC_DEPTH);
disable = !changeDepthAllowed(cur, view()->getLyXText(), INC_DEPTH);
break;
case LFUN_LAYOUT:
@ -377,15 +375,15 @@ FuncStatus LyXFunc::getStatus(FuncRequest const & ev) const
disable = true;
break;
}
if (ev.argument.empty()) {
if (cmd.argument.empty()) {
flag.clear();
break;
}
if (!contains("tcb", ev.argument[0])) {
if (!contains("tcb", cmd.argument[0])) {
disable = true;
break;
}
flag.setOnOff(ev.argument[0] == align);
flag.setOnOff(cmd.argument[0] == align);
} else {
disable = true;
@ -394,15 +392,15 @@ FuncStatus LyXFunc::getStatus(FuncRequest const & ev) const
disable = true;
break;
}
if (ev.argument.empty()) {
if (cmd.argument.empty()) {
flag.clear();
break;
}
if (!contains("lcr", ev.argument[0])) {
if (!contains("lcr", cmd.argument[0])) {
disable = true;
break;
}
flag.setOnOff(ev.argument[0] == align);
flag.setOnOff(cmd.argument[0] == align);
disable = !mathcursor::halign();
break;
@ -413,7 +411,7 @@ FuncStatus LyXFunc::getStatus(FuncRequest const & ev) const
//ret.disabled(true);
InsetTabular * tab = cur.innerInsetTabular();
if (tab) {
ret = tab->getStatus(ev.argument);
ret = tab->getStatus(cmd.argument);
flag |= ret;
disable = false;
} else {
@ -422,7 +420,7 @@ FuncStatus LyXFunc::getStatus(FuncRequest const & ev) const
} else {
static InsetTabular inset(*buf, 1, 1);
disable = true;
FuncStatus ret = inset.getStatus(ev.argument);
FuncStatus ret = inset.getStatus(cmd.argument);
if (ret.onoff(true) || ret.onoff(false))
flag.setOnOff(false);
}
@ -447,7 +445,7 @@ FuncStatus LyXFunc::getStatus(FuncRequest const & ev) const
break;
case LFUN_BOOKMARK_GOTO:
disable = !view()->
isSavedPosition(strToUnsignedInt(ev.argument));
isSavedPosition(strToUnsignedInt(cmd.argument));
break;
case LFUN_MERGE_CHANGES:
@ -474,25 +472,25 @@ FuncStatus LyXFunc::getStatus(FuncRequest const & ev) const
InsetOld::Code code = inset->lyxCode();
switch (code) {
case InsetOld::TABULAR_CODE:
disable = ev.argument != "tabular";
disable = cmd.argument != "tabular";
break;
case InsetOld::ERT_CODE:
disable = ev.argument != "ert";
disable = cmd.argument != "ert";
break;
case InsetOld::FLOAT_CODE:
disable = ev.argument != "float";
disable = cmd.argument != "float";
break;
case InsetOld::WRAP_CODE:
disable = ev.argument != "wrap";
disable = cmd.argument != "wrap";
break;
case InsetOld::NOTE_CODE:
disable = ev.argument != "note";
disable = cmd.argument != "note";
break;
case InsetOld::BRANCH_CODE:
disable = ev.argument != "branch";
disable = cmd.argument != "branch";
break;
case InsetOld::BOX_CODE:
disable = ev.argument != "box";
disable = cmd.argument != "box";
break;
default:
break;
@ -502,7 +500,7 @@ FuncStatus LyXFunc::getStatus(FuncRequest const & ev) const
case LFUN_MATH_MUTATE:
if (cur.inMathed())
//flag.setOnOff(mathcursor::formula()->hullType() == ev.argument);
//flag.setOnOff(mathcursor::formula()->hullType() == cmd.argument);
flag.setOnOff(false);
else
disable = true;
@ -519,7 +517,7 @@ FuncStatus LyXFunc::getStatus(FuncRequest const & ev) const
break;
case LFUN_DIALOG_SHOW: {
string const name = ev.getArg(0);
string const name = cmd.getArg(0);
if (!buf) {
disable = !(name == "aboutlyx" ||
name == "file" ||
@ -549,43 +547,43 @@ FuncStatus LyXFunc::getStatus(FuncRequest const & ev) const
// the functions which insert insets
InsetOld::Code code = InsetOld::NO_CODE;
switch (ev.action) {
switch (cmd.action) {
case LFUN_DIALOG_SHOW_NEW_INSET:
if (ev.argument == "bibitem")
if (cmd.argument == "bibitem")
code = InsetOld::BIBITEM_CODE;
else if (ev.argument == "bibtex")
else if (cmd.argument == "bibtex")
code = InsetOld::BIBTEX_CODE;
else if (ev.argument == "box")
else if (cmd.argument == "box")
code = InsetOld::BOX_CODE;
else if (ev.argument == "branch")
else if (cmd.argument == "branch")
code = InsetOld::BRANCH_CODE;
else if (ev.argument == "citation")
else if (cmd.argument == "citation")
code = InsetOld::CITE_CODE;
else if (ev.argument == "ert")
else if (cmd.argument == "ert")
code = InsetOld::ERT_CODE;
else if (ev.argument == "external")
else if (cmd.argument == "external")
code = InsetOld::EXTERNAL_CODE;
else if (ev.argument == "float")
else if (cmd.argument == "float")
code = InsetOld::FLOAT_CODE;
else if (ev.argument == "graphics")
else if (cmd.argument == "graphics")
code = InsetOld::GRAPHICS_CODE;
else if (ev.argument == "include")
else if (cmd.argument == "include")
code = InsetOld::INCLUDE_CODE;
else if (ev.argument == "index")
else if (cmd.argument == "index")
code = InsetOld::INDEX_CODE;
else if (ev.argument == "label")
else if (cmd.argument == "label")
code = InsetOld::LABEL_CODE;
else if (ev.argument == "note")
else if (cmd.argument == "note")
code = InsetOld::NOTE_CODE;
else if (ev.argument == "ref")
else if (cmd.argument == "ref")
code = InsetOld::REF_CODE;
else if (ev.argument == "toc")
else if (cmd.argument == "toc")
code = InsetOld::TOC_CODE;
else if (ev.argument == "url")
else if (cmd.argument == "url")
code = InsetOld::URL_CODE;
else if (ev.argument == "vspace")
else if (cmd.argument == "vspace")
code = InsetOld::VSPACE_CODE;
else if (ev.argument == "wrap")
else if (cmd.argument == "wrap")
code = InsetOld::WRAP_CODE;
break;
@ -700,7 +698,7 @@ FuncStatus LyXFunc::getStatus(FuncRequest const & ev) const
flag.disabled(true);
// A few general toggles
switch (ev.action) {
switch (cmd.action) {
case LFUN_TOOLTIPS_TOGGLE:
flag.setOnOff(owner->getDialogs().tooltipsEnabled());
break;
@ -715,7 +713,7 @@ FuncStatus LyXFunc::getStatus(FuncRequest const & ev) const
case LFUN_SWITCHBUFFER:
// toggle on the current buffer, but do not toggle off
// the other ones (is that a good idea?)
if (ev.argument == buf->fileName())
if (cmd.argument == buf->fileName())
flag.setOnOff(true);
break;
case LFUN_TRACK_CHANGES:
@ -729,7 +727,7 @@ FuncStatus LyXFunc::getStatus(FuncRequest const & ev) const
// the font related toggles
if (cur.inTexted()) {
LyXFont const & font = cur.text()->real_current_font;
switch (ev.action) {
switch (cmd.action) {
case LFUN_EMPH:
flag.setOnOff(font.emph() == LyXFont::ON);
break;
@ -753,7 +751,7 @@ FuncStatus LyXFunc::getStatus(FuncRequest const & ev) const
}
} else {
string tc = mathcursor::getLastCode();
switch (ev.action) {
switch (cmd.action) {
case LFUN_BOLD:
flag.setOnOff(tc == "mathbf");
break;
@ -783,10 +781,11 @@ FuncStatus LyXFunc::getStatus(FuncRequest const & ev) const
// this one is difficult to get right. As a half-baked
// solution, we consider only the first action of the sequence
if (ev.action == LFUN_SEQUENCE) {
if (cmd.action == LFUN_SEQUENCE) {
// argument contains ';'-terminated commands
#warning LyXAction arguments not handled here.
flag = getStatus(FuncRequest(lyxaction.lookupFunc(token(ev.argument, ';', 0))));
flag = getStatus(FuncRequest(
lyxaction.lookupFunc(token(cmd.argument, ';', 0))));
}
return flag;
@ -1750,7 +1749,7 @@ string const LyXFunc::view_status_message()
if (!view()->available())
return _("Welcome to LyX!");
return currentState(view());
return view()->cursor().currentState();
}

57
src/lyxtext.h
View File

@ -79,22 +79,19 @@ public:
ParagraphList::iterator end,
std::string const & layout);
///
void setLayout(std::string const & layout);
void setLayout(LCursor & cur, std::string const & layout);
/// Increase or decrease the nesting depth of the selected paragraph(s)
void changeDepth(bv_funcs::DEPTH_CHANGE type);
void changeDepth(LCursor & cur, bv_funcs::DEPTH_CHANGE type);
/// Returns whether something would be changed by changeDepth
bool changeDepthAllowed(bv_funcs::DEPTH_CHANGE type);
bool changeDepthAllowed(LCursor & cur, bv_funcs::DEPTH_CHANGE type);
/// get the depth at current cursor position
int getDepth() const;
/** set font over selection and make a total rebreak of those
paragraphs.
toggleall defaults to false.
*/
void setFont(LyXFont const &, bool toggleall = false);
/// Set font over selection paragraphs and rebreak.
void setFont(LCursor & cur, LyXFont const &, bool toggleall = false);
/// rebreaks all paragaphs between the given pars.
void redoParagraphs(ParagraphList::iterator begin,
@ -102,18 +99,18 @@ public:
/// rebreaks the given par
void redoParagraph(ParagraphList::iterator pit);
/// rebreaks the cursor par
void redoParagraph();
void redoParagraph(LCursor & cur);
///
void toggleFree(LyXFont const &, bool toggleall = false);
void toggleFree(LCursor & cur, LyXFont const &, bool toggleall = false);
///
std::string getStringToIndex();
std::string getStringToIndex(LCursor & cur);
/// insert a character at cursor position
void insertChar(char c);
void insertChar(LCursor & cur, char c);
/// insert an inset at cursor position
void insertInset(InsetBase * inset);
void insertInset(LCursor & cur, InsetBase * inset);
/// a full rebreak of the whole text
void fullRebreak();
@ -137,10 +134,10 @@ public:
ParagraphList::iterator getPar(lyx::paroffset_type par) const;
///
int parOffset(ParagraphList::iterator pit) const;
/// convenience
/// # FIXME: should not be used
ParagraphList::iterator cursorPar() const;
///
RowList::iterator cursorRow() const;
// Returns the current font and depth as a message.
std::string LyXText::currentState(LCursor & cur);
/** returns an iterator pointing to the row near the specified
* y-coordinate (relative to the whole text). y is set to the
@ -162,12 +159,12 @@ public:
*/
void getWord(CursorSlice & from, CursorSlice & to, lyx::word_location const);
/// just selects the word the cursor is in
void selectWord(lyx::word_location loc);
void selectWord(LCursor & cur, lyx::word_location loc);
/// accept selected change
void acceptChange();
void acceptChange(LCursor & cur);
/// reject selected change
void rejectChange();
void rejectChange(LCursor & cur);
/// returns true if par was empty and was removed
bool setCursor(lyx::paroffset_type par, lyx::pos_type pos,
@ -224,7 +221,7 @@ public:
///
void backspace(LCursor & cur);
///
bool selectWordWhenUnderCursor(lyx::word_location);
bool selectWordWhenUnderCursor(LCursor & cur, lyx::word_location);
///
enum TextCase {
///
@ -235,16 +232,16 @@ public:
text_uppercase = 2
};
/// Change the case of the word at cursor position.
void changeCase(TextCase action);
void changeCase(LCursor & cur, TextCase action);
/// returns success
bool toggleInset();
bool toggleInset(LCursor & cur);
///
void cutSelection(bool doclear = true, bool realcut = true);
///
void copySelection();
///
void pasteSelection(size_t sel_index = 0);
void pasteSelection(LCursor & cur, size_t sel_index = 0);
/** the DTP switches for paragraphs. LyX will store the top settings
always in the first physical paragraph, the bottom settings in the
@ -263,16 +260,16 @@ public:
* Sets the selection from the current cursor position to length
* characters to the right. No safety checks.
*/
void setSelectionRange(lyx::pos_type length);
/** simple replacing. The font of the first selected character
is used
*/
void replaceSelectionWithString(std::string const & str);
void setSelectionRange(LCursor & cur, lyx::pos_type length);
/// simply replace using the font of the first selected character
void replaceSelectionWithString(LCursor & cur, std::string const & str);
/// replace selection helper
void replaceSelection(LCursor & cur);
/// needed to insert the selection
void insertStringAsLines(std::string const & str);
void insertStringAsLines(LCursor & cur, std::string const & str);
/// needed to insert the selection
void insertStringAsParagraphs(std::string const & str);
void insertStringAsParagraphs(LCursor & cur, std::string const & str);
/// Find next inset of some specified type.
bool gotoNextInset(std::vector<InsetOld_code> const & codes,

6
src/paper.h
View File

@ -15,8 +15,8 @@
#ifndef PAPER_H
#define PAPER_H
///
enum PAPER_SIZE {
///
enum PAPER_SIZE {
///
PAPER_DEFAULT,
///
@ -33,7 +33,7 @@
PAPER_A5PAPER,
///
PAPER_B5PAPER
};
};
///
enum PAPER_PACKAGES {

249
src/text.C
View File

@ -18,6 +18,7 @@
#include "lyxtext.h"
#include "author.h"
#include "buffer.h"
#include "bufferparams.h"
#include "BufferView.h"
@ -50,10 +51,13 @@
#include "support/lstrings.h"
#include "support/textutils.h"
#include "support/tostr.h"
#include "support/std_sstream.h"
using lyx::pos_type;
using lyx::word_location;
using lyx::support::bformat;
using lyx::support::contains;
using lyx::support::lowercase;
using lyx::support::uppercase;
@ -834,25 +838,26 @@ void LyXText::breakParagraph(LCursor & cur, char keep_layout)
// convenience function
void LyXText::redoParagraph()
void LyXText::redoParagraph(LCursor & cur)
{
bv()->cursor().clearSelection();
redoParagraph(cursorPar());
setCursorIntern(cursor().par(), cursor().pos());
cur.clearSelection();
redoParagraph(getPar(cur.par()));
setCursorIntern(cur.par(), cur.pos());
}
// insert a character, moves all the following breaks in the
// same Paragraph one to the right and make a rebreak
void LyXText::insertChar(char c)
void LyXText::insertChar(LCursor & cur, char c)
{
recordUndo(bv()->cursor(), Undo::INSERT);
recordUndo(cur, Undo::INSERT);
// When the free-spacing option is set for the current layout,
// disable the double-space checking
Paragraph & par = cur.paragraph();
// try to remove this
ParagraphList::iterator pit = getPar(cur.par());
bool const freeSpacing = cursorPar()->layout()->free_spacing ||
cursorPar()->isFreeSpacing();
bool const freeSpacing = par.layout()->free_spacing ||
par.isFreeSpacing();
if (lyxrc.auto_number) {
static string const number_operators = "+-/*";
@ -862,36 +867,28 @@ void LyXText::insertChar(char c)
if (current_font.number() == LyXFont::ON) {
if (!IsDigit(c) && !contains(number_operators, c) &&
!(contains(number_seperators, c) &&
cursor().pos() >= 1 &&
cursor().pos() < cursorPar()->size() &&
getFont(cursorPar(), cursor().pos()).number() == LyXFont::ON &&
getFont(cursorPar(), cursor().pos() - 1).number() == LyXFont::ON)
cur.pos() != 0 &&
cur.pos() != cur.lastpos() &&
getFont(pit, cur.pos()).number() == LyXFont::ON &&
getFont(pit, cur.pos() - 1).number() == LyXFont::ON)
)
number(); // Set current_font.number to OFF
} else if (IsDigit(c) &&
real_current_font.isVisibleRightToLeft()) {
number(); // Set current_font.number to ON
if (cursor().pos() > 0) {
char const c = cursorPar()->getChar(cursor().pos() - 1);
if (cur.pos() != 0) {
char const c = par.getChar(cur.pos() - 1);
if (contains(number_unary_operators, c) &&
(cursor().pos() == 1 ||
cursorPar()->isSeparator(cursor().pos() - 2) ||
cursorPar()->isNewline(cursor().pos() - 2))
(cur.pos() == 1
|| par.isSeparator(cur.pos() - 2)
|| par.isNewline(cur.pos() - 2))
) {
setCharFont(
cursorPar(),
cursor().pos() - 1,
current_font);
} else if (contains(number_seperators, c) &&
cursor().pos() >= 2 &&
getFont(
cursorPar(),
cursor().pos() - 2).number() == LyXFont::ON) {
setCharFont(
cursorPar(),
cursor().pos() - 1,
current_font);
setCharFont(pit, cur.pos() - 1, current_font);
} else if (contains(number_seperators, c)
&& cur.pos() >= 2
&& getFont(pit, cur.pos() - 2).number() == LyXFont::ON) {
setCharFont(pit, cur.pos() - 1, current_font);
}
}
}
@ -913,36 +910,41 @@ void LyXText::insertChar(char c)
LyXFont realtmpfont = real_current_font;
LyXFont rawtmpfont = current_font;
// When the free-spacing option is set for the current layout,
// disable the double-space checking
if (!freeSpacing && IsLineSeparatorChar(c)) {
if ((cursor().pos() > 0
&& cursorPar()->isLineSeparator(cursor().pos() - 1))
|| (cursor().pos() > 0
&& cursorPar()->isNewline(cursor().pos() - 1))
|| (cursor().pos() == 0)) {
if (cur.pos() == 0) {
static bool sent_space_message = false;
if (!sent_space_message) {
if (cursor().pos() == 0)
bv()->owner()->message(_("You cannot insert a space at the beginning of a paragraph. Please read the Tutorial."));
else
bv()->owner()->message(_("You cannot type two spaces this way. Please read the Tutorial."));
cur.message(_("You cannot insert a space at the "
"beginning of a paragraph. Please read the Tutorial."));
sent_space_message = true;
return;
}
}
BOOST_ASSERT(cur.pos() > 0);
if (par.isLineSeparator(cur.pos() - 1)
|| par.isNewline(cur.pos() - 1)) {
static bool sent_space_message = false;
if (!sent_space_message) {
cur.message(_("You cannot type two spaces this way. "
"Please read the Tutorial."));
sent_space_message = true;
}
charInserted();
return;
}
}
// Here case LyXText::InsertInset already inserted the character
if (c != Paragraph::META_INSET)
cursorPar()->insertChar(cursor().pos(), c);
par.insertChar(cur.pos(), c);
setCharFont(cursorPar(), cursor().pos(), rawtmpfont);
setCharFont(pit, cur.pos(), rawtmpfont);
current_font = rawtmpfont;
real_current_font = realtmpfont;
redoParagraph(cursorPar());
setCursor(cursor().par(), cursor().pos() + 1, false, cursor().boundary());
redoParagraph(cur);
setCursor(cur.par(), cur.pos() + 1, false, cur.boundary());
charInserted();
}
@ -1117,42 +1119,41 @@ void LyXText::cursorLeftOneWord(LCursor & cur)
}
void LyXText::selectWord(word_location loc)
void LyXText::selectWord(LCursor & cur, word_location loc)
{
CursorSlice from = cursor();
CursorSlice to = cursor();
CursorSlice from = cur.current();
CursorSlice to = cur.current();
getWord(from, to, loc);
if (cursor() != from)
if (cur.current() != from)
setCursor(from.par(), from.pos());
if (to == from)
return;
bv()->cursor().resetAnchor();
cur.resetAnchor();
setCursor(to.par(), to.pos());
bv()->cursor().setSelection();
cur.setSelection();
}
// Select the word currently under the cursor when no
// selection is currently set
bool LyXText::selectWordWhenUnderCursor(word_location loc)
bool LyXText::selectWordWhenUnderCursor(LCursor & cur, word_location loc)
{
if (bv()->cursor().selection())
if (cur.selection())
return false;
selectWord(loc);
return bv()->cursor().selection();
selectWord(cur, loc);
return cur.selection();
}
void LyXText::acceptChange()
void LyXText::acceptChange(LCursor & cur)
{
LCursor & cur = bv()->cursor();
if (!cur.selection() && cursorPar()->size())
if (!cur.selection() && cur.lastpos() != 0)
return;
if (cur.selBegin().par() == cur.par()) {
CursorSlice const & startc = cur.selBegin();
CursorSlice const & endc = cur.selEnd();
recordUndo(cur, Undo::INSERT, cur.anchor().par());
if (startc.par() == endc.par()) {
recordUndoSelection(cur, Undo::INSERT);
getPar(startc)->acceptChange(startc.pos(), endc.pos());
finishUndo();
cur.clearSelection();
@ -1163,16 +1164,15 @@ void LyXText::acceptChange()
}
void LyXText::rejectChange()
void LyXText::rejectChange(LCursor & cur)
{
LCursor & cur = bv()->cursor();
if (!cur.selection() && cursorPar()->size())
if (!cur.selection() && cur.lastpos() != 0)
return;
if (cur.selBegin().par() == cur.selEnd().par()) {
CursorSlice const & startc = cur.selBegin();
CursorSlice const & endc = cur.selEnd();
recordUndo(cur, Undo::INSERT, cur.anchor().par());
if (startc.par() == endc.par()) {
recordUndoSelection(cur, Undo::INSERT);
getPar(startc)->rejectChange(startc.pos(), endc.pos());
finishUndo();
cur.clearSelection();
@ -1233,9 +1233,8 @@ void LyXText::deleteLineForward(LCursor & cur)
}
void LyXText::changeCase(LyXText::TextCase action)
void LyXText::changeCase(LCursor & cur, LyXText::TextCase action)
{
LCursor & cur = bv()->cursor();
CursorSlice from;
CursorSlice to;
@ -1248,7 +1247,7 @@ void LyXText::changeCase(LyXText::TextCase action)
setCursor(to.par(), to.pos() + 1);
}
recordUndo(cur, Undo::ATOMIC, cur.anchor().par());
recordUndoSelection(cur);
pos_type pos = from.pos();
int par = from.par();
@ -1298,23 +1297,21 @@ void LyXText::Delete(LCursor & cur)
void LyXText::backspace(LCursor & cur)
{
// Get the font that is used to calculate the baselineskip
ParagraphList::iterator pit = cursorPar();
pos_type lastpos = pit->size();
if (cur.pos() == 0) {
// The cursor is at the beginning of a paragraph, so
// the the backspace will collapse two paragraphs into
// one.
// but it's not allowed unless it's new
if (pit->isChangeEdited(0, pit->size()))
Paragraph & par = cur.paragraph();
if (par.isChangeEdited(0, par.size()))
return;
// we may paste some paragraphs
// is it an empty paragraph?
if (lastpos == 0 || (lastpos == 1 && pit->isSeparator(0))) {
pos_type lastpos = cur.lastpos();
if (lastpos == 0 || (lastpos == 1 && par.isSeparator(0))) {
// This is an empty paragraph and we delete it just
// by moving the cursor one step
// left and let the DeleteEmptyParagraphMechanism
@ -1323,7 +1320,7 @@ void LyXText::backspace(LCursor & cur)
if (cur.par() != 0) {
cursorLeft(cur, true);
// the layout things can change the height of a row !
redoParagraph();
redoParagraph(cur);
return;
}
}
@ -1331,7 +1328,7 @@ void LyXText::backspace(LCursor & cur)
if (cur.par() != 0)
recordUndo(cur, Undo::DELETE, cur.par() - 1);
ParagraphList::iterator tmppit = cursorPar();
ParagraphList::iterator tmppit = getPar(cur.par());
// We used to do cursorLeftIntern() here, but it is
// not a good idea since it triggers the auto-delete
// mechanism. So we do a cursorLeftIntern()-lite,
@ -1350,7 +1347,7 @@ void LyXText::backspace(LCursor & cur)
Buffer & buf = *bv()->buffer();
BufferParams const & bufparams = buf.params();
LyXTextClass const & tclass = bufparams.getLyXTextClass();
ParagraphList::iterator const cpit = cursorPar();
ParagraphList::iterator const cpit = getPar(cur.par());
if (cpit != tmppit
&& (cpit->layout() == tmppit->layout()
@ -1381,7 +1378,7 @@ void LyXText::backspace(LCursor & cur)
if (cur.pos() == cur.lastpos())
setCurrentFont();
redoParagraph();
redoParagraph(cur);
setCursor(cur.par(), cur.pos(), false, cur.boundary());
}
@ -1394,12 +1391,6 @@ ParagraphList::iterator LyXText::cursorPar() const
}
RowList::iterator LyXText::cursorRow() const
{
return cursorPar()->getRow(cursor().pos());
}
ParagraphList::iterator LyXText::getPar(CursorSlice const & cur) const
{
return getPar(cur.par());
@ -1861,3 +1852,89 @@ CursorSlice const & LyXText::cursor() const
}
return bv()->cursor().current();
}
void LyXText::replaceSelection(LCursor & cur)
{
if (cur.selection()) {
cutSelection(true, false);
bv()->update();
}
}
// Returns the current font and depth as a message.
string LyXText::currentState(LCursor & cur)
{
Buffer * buffer = bv()->buffer();
Paragraph const & par = cur.paragraph();
std::ostringstream os;
bool const show_change = buffer->params().tracking_changes
&& cur.pos() != cur.lastpos()
&& par.lookupChange(cur.pos()) != Change::UNCHANGED;
if (show_change) {
Change change = par.lookupChangeFull(cur.pos());
Author const & a = buffer->params().authors().get(change.author);
os << _("Change: ") << a.name();
if (!a.email().empty())
os << " (" << a.email() << ")";
if (change.changetime)
os << _(" at ") << ctime(&change.changetime);
os << " : ";
}
// I think we should only show changes from the default
// font. (Asger)
LyXFont font = real_current_font;
font.reduce(buffer->params().getLyXTextClass().defaultfont());
// avoid _(...) re-entrance problem
string const s = font.stateText(&buffer->params());
os << bformat(_("Font: %1$s"), s);
// os << bformat(_("Font: %1$s"), font.stateText(&buffer->params));
// The paragraph depth
int depth = getDepth();
if (depth > 0)
os << bformat(_(", Depth: %1$s"), tostr(depth));
// The paragraph spacing, but only if different from
// buffer spacing.
Spacing const & spacing = par.params().spacing();
if (!spacing.isDefault()) {
os << _(", Spacing: ");
switch (spacing.getSpace()) {
case Spacing::Single:
os << _("Single");
break;
case Spacing::Onehalf:
os << _("OneHalf");
break;
case Spacing::Double:
os << _("Double");
break;
case Spacing::Other:
os << _("Other (") << spacing.getValue() << ')';
break;
case Spacing::Default:
// should never happen, do nothing
break;
}
}
#ifdef DEVEL_VERSION
os << _(", Paragraph: ") << par.id();
os << _(", Position: ") << cur.pos();
Row & row = cur.textRow();
os << bformat(_(", Row b:%1$d e:%2$d"), row.pos(), row.endpos());
os << _(", Inset: ");
InsetOld * inset = par.inInset();
if (inset)
os << inset << " owner: " << inset->owner();
else
os << -1;
#endif
return os.str();
}

144
src/text2.C
View File

@ -279,7 +279,7 @@ LyXText::setLayout(ParagraphList::iterator start,
// set layout over selection and make a total rebreak of those paragraphs
void LyXText::setLayout(string const & layout)
void LyXText::setLayout(LCursor & cur, string const & layout)
{
// special handling of new environment insets
BufferParams const & params = bv()->buffer()->params();
@ -291,18 +291,15 @@ void LyXText::setLayout(string const & layout)
bv()->owner()->dispatch(FuncRequest(LFUN_ENDSEL));
bv()->owner()->dispatch(FuncRequest(LFUN_CUT));
InsetBase * inset = new InsetEnvironment(params, layout);
insertInset(inset);
insertInset(cur, inset);
//inset->edit(bv());
//bv()->owner()->dispatch(FuncRequest(LFUN_PASTE));
return;
}
ParagraphList::iterator start =
getPar(bv()->cursor().selBegin().par());
ParagraphList::iterator end =
boost::next(getPar(bv()->cursor().selEnd().par()));
ParagraphList::iterator start = getPar(cur.selBegin().par());
ParagraphList::iterator end = boost::next(getPar(cur.selEnd().par()));
ParagraphList::iterator endpit = setLayout(start, end, layout);
redoParagraphs(start, endpit);
updateCounters();
}
@ -311,16 +308,16 @@ void LyXText::setLayout(string const & layout)
namespace {
void getSelectionSpan(LyXText & text,
void getSelectionSpan(LCursor & cur, LyXText & text,
ParagraphList::iterator & beg,
ParagraphList::iterator & end)
{
if (!text.bv()->cursor().selection()) {
beg = text.cursorPar();
if (!cur.selection()) {
beg = text.getPar(cur.par());
end = boost::next(beg);
} else {
beg = text.getPar(text.bv()->cursor().selBegin());
end = boost::next(text.getPar(text.bv()->cursor().selEnd()));
beg = text.getPar(cur.selBegin());
end = boost::next(text.getPar(cur.selEnd()));
}
}
@ -343,10 +340,10 @@ bool changeDepthAllowed(bv_funcs::DEPTH_CHANGE type,
}
bool LyXText::changeDepthAllowed(bv_funcs::DEPTH_CHANGE type)
bool LyXText::changeDepthAllowed(LCursor & cur, bv_funcs::DEPTH_CHANGE type)
{
ParagraphList::iterator beg, end;
getSelectionSpan(*this, beg, end);
getSelectionSpan(cur, *this, beg, end);
int max_depth = 0;
if (beg != paragraphs().begin())
max_depth = boost::prior(beg)->getMaxDepthAfter();
@ -360,12 +357,11 @@ bool LyXText::changeDepthAllowed(bv_funcs::DEPTH_CHANGE type)
}
void LyXText::changeDepth(bv_funcs::DEPTH_CHANGE type)
void LyXText::changeDepth(LCursor & cur, bv_funcs::DEPTH_CHANGE type)
{
ParagraphList::iterator beg, end;
getSelectionSpan(*this, beg, end);
recUndo(parOffset(beg), parOffset(end) - 1);
getSelectionSpan(cur, *this, beg, end);
recordUndoSelection(cur);
int max_depth = 0;
if (beg != paragraphs().begin())
@ -388,17 +384,17 @@ void LyXText::changeDepth(bv_funcs::DEPTH_CHANGE type)
// set font over selection and make a total rebreak of those paragraphs
void LyXText::setFont(LyXFont const & font, bool toggleall)
void LyXText::setFont(LCursor & cur, LyXFont const & font, bool toggleall)
{
LCursor & cur = bv()->cursor();
// if there is no selection just set the current_font
if (!cur.selection()) {
// Determine basis font
LyXFont layoutfont;
if (cursor().pos() < cursorPar()->beginOfBody())
layoutfont = getLabelFont(cursorPar());
ParagraphList::iterator pit = getPar(cur.par());
if (cur.pos() < pit->beginOfBody())
layoutfont = getLabelFont(pit);
else
layoutfont = getLayoutFont(cursorPar());
layoutfont = getLayoutFont(pit);
// Update current font
real_current_font.update(font,
@ -415,7 +411,7 @@ void LyXText::setFont(LyXFont const & font, bool toggleall)
}
// ok we have a selection.
recUndo(cur.selBegin().par(), cur.selEnd().par());
recordUndoSelection(cur);
freezeUndo();
ParagraphList::iterator beg = getPar(cur.selBegin().par());
@ -468,12 +464,12 @@ void LyXText::cursorBottom(LCursor & cur)
}
void LyXText::toggleFree(LyXFont const & font, bool toggleall)
void LyXText::toggleFree(LCursor & cur, LyXFont const & font, bool toggleall)
{
// If the mask is completely neutral, tell user
if (font == LyXFont(LyXFont::ALL_IGNORE)) {
// Could only happen with user style
bv()->owner()->message(_("No font change defined. "
cur.message(_("No font change defined. "
"Use Character under the Layout menu to define font change."));
return;
}
@ -481,45 +477,44 @@ void LyXText::toggleFree(LyXFont const & font, bool toggleall)
// Try implicit word selection
// If there is a change in the language the implicit word selection
// is disabled.
CursorSlice resetCursor = cursor();
CursorSlice resetCursor = cur.current();
bool implicitSelection =
font.language() == ignore_language
&& font.number() == LyXFont::IGNORE
&& selectWordWhenUnderCursor(lyx::WHOLE_WORD_STRICT);
&& selectWordWhenUnderCursor(cur, lyx::WHOLE_WORD_STRICT);
// Set font
setFont(font, toggleall);
setFont(cur, font, toggleall);
// Implicit selections are cleared afterwards
//and cursor is set to the original position.
// and cursor is set to the original position.
if (implicitSelection) {
bv()->cursor().clearSelection();
cursor() = resetCursor;
bv()->cursor().resetAnchor();
cur.clearSelection();
cur.current() = resetCursor;
cur.resetAnchor();
}
}
string LyXText::getStringToIndex()
string LyXText::getStringToIndex(LCursor & cur)
{
LCursor & cur = bv()->cursor();
// Try implicit word selection
// If there is a change in the language the implicit word selection
// is disabled.
CursorSlice const reset_cursor = cursor();
CursorSlice const reset_cursor = cur.current();
bool const implicitSelection =
selectWordWhenUnderCursor(lyx::PREVIOUS_WORD);
selectWordWhenUnderCursor(cur, lyx::PREVIOUS_WORD);
string idxstring;
if (!cur.selection())
bv()->owner()->message(_("Nothing to index!"));
cur.message(_("Nothing to index!"));
else if (cur.selBegin().par() != cur.selEnd().par())
bv()->owner()->message(_("Cannot index more than one paragraph!"));
cur.message(_("Cannot index more than one paragraph!"));
else
idxstring = cur.selectionAsString(false);
// Reset cursors to their original position.
cursor() = reset_cursor;
cur.current() = reset_cursor;
cur.resetAnchor();
// Clear the implicit selection.
@ -859,24 +854,20 @@ void LyXText::updateCounters()
}
void LyXText::insertInset(InsetBase * inset)
void LyXText::insertInset(LCursor & cur, InsetBase * inset)
{
if (!cursorPar()->insetAllowed(inset->lyxCode()))
return;
recUndo(cursor().par());
recordUndo(cur);
freezeUndo();
cursorPar()->insertInset(cursor().pos(), inset);
cur.paragraph().insertInset(cur.pos(), inset);
// Just to rebreak and refresh correctly.
// The character will not be inserted a second time
insertChar(Paragraph::META_INSET);
insertChar(cur, Paragraph::META_INSET);
// If we enter a highly editable inset the cursor should be before
// the inset. After an undo LyX tries to call inset->edit(...)
// and fails if the cursor is behind the inset and getInset
// does not return the inset!
if (isHighlyEditableInset(inset))
cursorLeft(bv()->cursor(), true);
cursorLeft(cur, true);
unFreezeUndo();
}
@ -902,10 +893,10 @@ void LyXText::cutSelection(bool doclear, bool realcut)
// and cur.selEnd()
// make sure that the depth behind the selection are restored, too
recordUndoSelection(cur);
ParagraphList::iterator begpit = getPar(cur.selBegin().par());
ParagraphList::iterator endpit = getPar(cur.selEnd().par());
ParagraphList::iterator undopit = undoSpan(endpit);
recUndo(cur.selBegin().par(), parOffset(undopit) - 1);
int endpos = cur.selEnd().pos();
@ -913,7 +904,7 @@ void LyXText::cutSelection(bool doclear, bool realcut)
boost::tie(endpit, endpos) = realcut ?
CutAndPaste::cutSelection(bufparams,
paragraphs(),
begpit , endpit,
begpit, endpit,
cur.selBegin().pos(), endpos,
bufparams.textclass,
doclear)
@ -930,8 +921,8 @@ void LyXText::cutSelection(bool doclear, bool realcut)
// cutSelection can invalidate the cursor so we need to set
// it anew. (Lgb)
// we prefer the end for when tracking changes
cursor().pos(endpos);
cursor().par(parOffset(endpit));
cur.pos() = endpos;
cur.par() = parOffset(endpit);
// need a valid cursor. (Lgb)
cur.clearSelection();
@ -967,14 +958,13 @@ void LyXText::copySelection()
}
void LyXText::pasteSelection(size_t sel_index)
void LyXText::pasteSelection(LCursor & cur, size_t sel_index)
{
LCursor & cur = bv()->cursor();
// this does not make sense, if there is nothing to paste
if (!CutAndPaste::checkPastePossible())
return;
recUndo(cursor().par());
recordUndo(cur);
ParagraphList::iterator endpit;
PitPosPair ppp;
@ -1000,12 +990,10 @@ void LyXText::pasteSelection(size_t sel_index)
}
void LyXText::setSelectionRange(lyx::pos_type length)
void LyXText::setSelectionRange(LCursor & cur, lyx::pos_type length)
{
if (!length)
return;
LCursor & cur = bv()->cursor();
cur.resetAnchor();
while (length--)
cursorRight(cur, true);
@ -1014,10 +1002,9 @@ void LyXText::setSelectionRange(lyx::pos_type length)
// simple replacing. The font of the first selected character is used
void LyXText::replaceSelectionWithString(string const & str)
void LyXText::replaceSelectionWithString(LCursor & cur, string const & str)
{
LCursor & cur = bv()->cursor();
recUndo(cur.par());
recordUndo(cur);
freezeUndo();
// Get font setting before we cut
@ -1042,34 +1029,32 @@ void LyXText::replaceSelectionWithString(string const & str)
// needed to insert the selection
void LyXText::insertStringAsLines(string const & str)
void LyXText::insertStringAsLines(LCursor & cur, string const & str)
{
LCursor & cur = bv()->cursor();
ParagraphList::iterator pit = cursorPar();
ParagraphList::iterator pit = getPar(cur.par());
ParagraphList::iterator endpit = boost::next(pit);
pos_type pos = cursor().pos();
ParagraphList::iterator endpit = boost::next(cursorPar());
recordUndo(cur, Undo::ATOMIC);
recordUndo(cur);
// only to be sure, should not be neccessary
cur.clearSelection();
bv()->buffer()->insertStringAsLines(pit, pos, current_font, str);
redoParagraphs(cursorPar(), endpit);
redoParagraphs(getPar(cur.par()), endpit);
cur.resetAnchor();
setCursor(parOffset(pit), pos);
setCursor(cur.par(), pos);
cur.setSelection();
}
// turn double CR to single CR, others are converted into one
// blank. Then insertStringAsLines is called
void LyXText::insertStringAsParagraphs(string const & str)
void LyXText::insertStringAsParagraphs(LCursor & cur, string const & str)
{
string linestr(str);
string linestr = str;
bool newline_inserted = false;
string::size_type const siz = linestr.length();
for (string::size_type i = 0; i < siz; ++i) {
for (string::size_type i = 0, siz = linestr.size(); i < siz; ++i) {
if (linestr[i] == '\n') {
if (newline_inserted) {
// we know that \r will be ignored by
@ -1085,7 +1070,7 @@ void LyXText::insertStringAsParagraphs(string const & str)
newline_inserted = false;
}
}
insertStringAsLines(linestr);
insertStringAsLines(cur, linestr);
}
@ -1197,6 +1182,7 @@ void LyXText::setCurrentFont()
}
}
// x is an absolute screen coord
// returns the column near the specified x-coordinate of the row
// x is set to the real beginning of this column
@ -1479,7 +1465,7 @@ bool LyXText::cursorRight(LCursor & cur, bool internal)
void LyXText::cursorUp(LCursor & cur, bool selecting)
{
Row const & row = *cursorRow();
Row const & row = cur.textRow();
int x = cur.x_target();
int y = cursorY(cur.current()) - row.baseline() - 1;
setCursorFromCoordinates(x, y);
@ -1702,17 +1688,17 @@ bool LyXText::isInInset() const
}
bool LyXText::toggleInset()
bool LyXText::toggleInset(LCursor & cur)
{
InsetBase * inset = bv()->cursor().nextInset();
InsetBase * inset = cur.nextInset();
// is there an editable inset at cursor position?
if (!isEditableInset(inset))
return false;
//bv()->owner()->message(inset->editMessage());
cur.message(inset->editMessage());
// do we want to keep this?? (JMarc)
if (!isHighlyEditableInset(inset))
recUndo(cursor().par());
recordUndo(cur);
if (inset->isOpen())
inset->close();

209
src/text3.C
View File

@ -57,9 +57,6 @@
#include <clocale>
using bv_funcs::replaceSelection;
using lyx::pos_type;
using lyx::support::isStrUnsignedInt;
@ -88,28 +85,26 @@ namespace {
bool toggleall = false;
void toggleAndShow(BufferView * bv, LyXText * text,
void toggleAndShow(LCursor & cur, LyXText * text,
LyXFont const & font, bool toggleall = true)
{
if (!bv->available())
if (!cur.bv().available())
return;
text->toggleFree(font, toggleall);
bv->update();
text->toggleFree(cur, font, toggleall);
if (font.language() != ignore_language ||
font.number() != LyXFont::IGNORE) {
CursorSlice & cur = text->cursor();
Paragraph & par = *text->cursorPar();
text->bidi.computeTables(par, *bv->buffer(),
*par.getRow(cur.pos()));
Paragraph & par = cur.paragraph();
text->bidi.computeTables(par, *cur.bv().buffer(), cur.textRow());
if (cur.boundary() !=
text->bidi.isBoundary(*bv->buffer(), par,
text->bidi.isBoundary(*cur.bv().buffer(), par,
cur.pos(),
text->real_current_font))
text->setCursor(cur.par(), cur.pos(),
false, !cur.boundary());
}
cur.bv().update();
}
@ -271,10 +266,10 @@ void LyXText::gotoInset(vector<InsetOld_code> const & codes, bool same_content)
cur.pos() = 0;
if (!gotoNextInset(codes, contents)) {
cursor() = tmp;
cur.bv().owner()->message(_("No more insets"));
cur.message(_("No more insets"));
}
} else {
cur.bv().owner()->message(_("No more insets"));
cur.message(_("No more insets"));
}
}
cur.bv().update();
@ -330,30 +325,31 @@ void LyXText::cursorNext(LCursor & cur)
namespace {
void specialChar(LyXText * text, BufferView * bv, InsetSpecialChar::Kind kind)
void specialChar(LCursor & cur, LyXText * text, BufferView * bv,
InsetSpecialChar::Kind kind)
{
bv->update();
replaceSelection(text);
text->insertInset(new InsetSpecialChar(kind));
text->replaceSelection(cur);
cur.insert(new InsetSpecialChar(kind));
bv->update();
}
void doInsertInset(LyXText * text, BufferView * bv, FuncRequest const & cmd,
bool edit, bool pastesel)
void doInsertInset(LCursor & cur, LyXText * text, BufferView * bv,
FuncRequest const & cmd, bool edit, bool pastesel)
{
InsetBase * inset = createInset(bv, cmd);
if (!inset)
return;
bool gotsel = false;
if (bv->cursor().selection()) {
if (cur.selection()) {
bv->owner()->dispatch(FuncRequest(LFUN_CUT));
gotsel = true;
}
text->insertInset(inset);
text->insertInset(cur, inset);
if (edit)
inset->edit(bv->cursor(), true);
inset->edit(cur, true);
if (gotsel && pastesel)
bv->owner()->dispatch(FuncRequest(LFUN_PASTE));
}
@ -365,7 +361,7 @@ void LyXText::number()
{
LyXFont font(LyXFont::ALL_IGNORE);
font.setNumber(LyXFont::TOGGLE);
toggleAndShow(bv(), this, font);
toggleAndShow(bv()->cursor(), this, font);
}
@ -385,8 +381,8 @@ DispatchResult LyXText::dispatch(LCursor & cur, FuncRequest const & cmd)
switch (cmd.action) {
case LFUN_APPENDIX: {
ParagraphList::iterator pit = cursorPar();
bool start = !pit->params().startOfAppendix();
Paragraph & par = cur.paragraph();
bool start = !par.params().startOfAppendix();
// ensure that we have only one start_of_appendix in this document
ParagraphList::iterator tmp = paragraphs().begin();
@ -401,12 +397,12 @@ DispatchResult LyXText::dispatch(LCursor & cur, FuncRequest const & cmd)
}
}
recUndo(parOffset(pit));
pit->params().startOfAppendix(start);
recordUndo(cur);
par.params().startOfAppendix(start);
// we can set the refreshing parameters now
updateCounters();
redoParagraph(cursorPar());
redoParagraph(cur);
bv->update();
break;
}
@ -560,7 +556,7 @@ DispatchResult LyXText::dispatch(LCursor & cur, FuncRequest const & cmd)
break;
case LFUN_WORDSEL: {
selectWord(lyx::WHOLE_WORD);
selectWord(cur, lyx::WHOLE_WORD);
finishChange(cur, true);
break;
}
@ -630,9 +626,9 @@ DispatchResult LyXText::dispatch(LCursor & cur, FuncRequest const & cmd)
case LFUN_BREAKLINE: {
// Not allowed by LaTeX (labels or empty par)
if (cursor().pos() > cursorPar()->beginOfBody()) {
replaceSelection(this);
insertInset(new InsetNewline);
if (cur.pos() > cur.paragraph().beginOfBody()) {
replaceSelection(cur);
cur.insert(new InsetNewline);
moveCursor(cur, false);
}
break;
@ -697,7 +693,7 @@ DispatchResult LyXText::dispatch(LCursor & cur, FuncRequest const & cmd)
break;
case LFUN_BREAKPARAGRAPH:
replaceSelection(this);
replaceSelection(cur);
breakParagraph(cur, 0);
bv->update();
cur.resetAnchor();
@ -706,7 +702,7 @@ DispatchResult LyXText::dispatch(LCursor & cur, FuncRequest const & cmd)
break;
case LFUN_BREAKPARAGRAPHKEEPLAYOUT:
replaceSelection(this);
replaceSelection(cur);
breakParagraph(cur, 1);
bv->update();
cur.resetAnchor();
@ -719,7 +715,7 @@ DispatchResult LyXText::dispatch(LCursor & cur, FuncRequest const & cmd)
// indentation and add a "defskip" at the top.
// Otherwise, do the same as LFUN_BREAKPARAGRAPH.
#warning look here
replaceSelection(this);
replaceSelection(cur);
if (cur.pos() == 0) {
ParagraphParameters & params = cur.paragraph().params();
setParagraph(
@ -772,7 +768,7 @@ DispatchResult LyXText::dispatch(LCursor & cur, FuncRequest const & cmd)
}
if (cur_spacing != new_spacing || cur_value != new_value) {
par.params().spacing(Spacing(new_spacing, new_value));
redoParagraph();
redoParagraph(cur);
bv->update();
}
break;
@ -791,7 +787,7 @@ DispatchResult LyXText::dispatch(LCursor & cur, FuncRequest const & cmd)
case LFUN_INSET_INSERT: {
InsetBase * inset = createInset(bv, cmd);
if (inset)
insertInset(inset);
insertInset(cur, inset);
break;
}
@ -802,69 +798,69 @@ DispatchResult LyXText::dispatch(LCursor & cur, FuncRequest const & cmd)
case LFUN_INSET_TOGGLE:
cur.clearSelection();
if (!toggleInset())
if (!toggleInset(cur))
return DispatchResult(false);
bv->update();
bv->switchKeyMap();
break;
case LFUN_SPACE_INSERT:
if (cursorPar()->layout()->free_spacing)
insertChar(' ');
if (cur.paragraph().layout()->free_spacing)
insertChar(cur, ' ');
else
doInsertInset(this, bv, cmd, false, false);
doInsertInset(cur, this, bv, cmd, false, false);
moveCursor(cur, false);
break;
case LFUN_HYPHENATION:
specialChar(this, bv, InsetSpecialChar::HYPHENATION);
specialChar(cur, this, bv, InsetSpecialChar::HYPHENATION);
break;
case LFUN_LIGATURE_BREAK:
specialChar(this, bv, InsetSpecialChar::LIGATURE_BREAK);
specialChar(cur, this, bv, InsetSpecialChar::LIGATURE_BREAK);
break;
case LFUN_LDOTS:
specialChar(this, bv, InsetSpecialChar::LDOTS);
specialChar(cur, this, bv, InsetSpecialChar::LDOTS);
break;
case LFUN_END_OF_SENTENCE:
specialChar(this, bv, InsetSpecialChar::END_OF_SENTENCE);
specialChar(cur, this, bv, InsetSpecialChar::END_OF_SENTENCE);
break;
case LFUN_MENU_SEPARATOR:
specialChar(this, bv, InsetSpecialChar::MENU_SEPARATOR);
specialChar(cur, this, bv, InsetSpecialChar::MENU_SEPARATOR);
break;
case LFUN_UPCASE_WORD:
changeCase(LyXText::text_uppercase);
changeCase(cur, LyXText::text_uppercase);
bv->update();
break;
case LFUN_LOWCASE_WORD:
changeCase(LyXText::text_lowercase);
changeCase(cur, LyXText::text_lowercase);
bv->update();
break;
case LFUN_CAPITALIZE_WORD:
changeCase(LyXText::text_capitalization);
changeCase(cur, LyXText::text_capitalization);
bv->update();
break;
case LFUN_TRANSPOSE_CHARS:
recUndo(cursor().par());
redoParagraph();
recordUndo(cur);
redoParagraph(cur);
bv->update();
break;
case LFUN_PASTE:
cur.message(_("Paste"));
replaceSelection(this);
replaceSelection(cur);
#warning FIXME Check if the arg is in the domain of available selections.
if (isStrUnsignedInt(cmd.argument))
pasteSelection(strToUnsignedInt(cmd.argument));
pasteSelection(cur, strToUnsignedInt(cmd.argument));
else
pasteSelection(0);
pasteSelection(cur, 0);
cur.clearSelection(); // bug 393
bv->update();
bv->switchKeyMap();
@ -928,7 +924,7 @@ DispatchResult LyXText::dispatch(LCursor & cur, FuncRequest const & cmd)
break;
case LFUN_GETLAYOUT:
cur.message(cursorPar()->layout()->name());
cur.message(cur.paragraph().layout()->name());
break;
case LFUN_LAYOUT: {
@ -982,7 +978,7 @@ DispatchResult LyXText::dispatch(LCursor & cur, FuncRequest const & cmd)
if (change_layout) {
current_layout = layout;
setLayout(layout);
setLayout(cur, layout);
bv->owner()->setLayout(layout);
bv->update();
bv->switchKeyMap();
@ -995,9 +991,9 @@ DispatchResult LyXText::dispatch(LCursor & cur, FuncRequest const & cmd)
string const clip = bv->getClipboard();
if (!clip.empty()) {
if (cmd.argument == "paragraph")
insertStringAsParagraphs(clip);
insertStringAsParagraphs(cur, clip);
else
insertStringAsLines(clip);
insertStringAsLines(cur, clip);
bv->update();
}
break;
@ -1020,30 +1016,30 @@ DispatchResult LyXText::dispatch(LCursor & cur, FuncRequest const & cmd)
}
case LFUN_QUOTE: {
replaceSelection(this);
ParagraphList::iterator pit = cursorPar();
lyx::pos_type pos = cursor().pos();
replaceSelection(cur);
Paragraph & par = cur.paragraph();
lyx::pos_type pos = cur.pos();
char c;
if (!pos)
if (pos == 0)
c = ' ';
else if (pit->isInset(pos - 1) && pit->getInset(pos - 1)->isSpace())
else if (cur.prevInset() && cur.prevInset()->isSpace())
c = ' ';
else
c = pit->getChar(pos - 1);
c = par.getChar(pos - 1);
LyXLayout_ptr const & style = pit->layout();
LyXLayout_ptr const & style = par.layout();
BufferParams const & bufparams = bv->buffer()->params();
if (style->pass_thru ||
pit->getFontSettings(bufparams,pos).language()->lang() == "hebrew")
insertInset(new InsetQuotes(c, bufparams));
par.getFontSettings(bufparams, pos).language()->lang() == "hebrew")
cur.insert(new InsetQuotes(c, bufparams));
else
bv->owner()->dispatch(FuncRequest(LFUN_SELFINSERT, "\""));
break;
}
case LFUN_DATE_INSERT: {
replaceSelection(this);
replaceSelection(cur);
time_t now_time_t = time(NULL);
struct tm * now_tm = localtime(&now_time_t);
setlocale(LC_TIME, "");
@ -1057,7 +1053,7 @@ DispatchResult LyXText::dispatch(LCursor & cur, FuncRequest const & cmd)
::strftime(datetmp, 32, arg.c_str(), now_tm);
for (int i = 0; i < datetmp_len; i++)
insertChar(datetmp[i]);
insertChar(cur, datetmp[i]);
cur.resetAnchor();
moveCursor(cur, false);
@ -1078,7 +1074,7 @@ DispatchResult LyXText::dispatch(LCursor & cur, FuncRequest const & cmd)
case LFUN_MOUSE_DOUBLE:
if (cmd.button() == mouse_button::button1) {
selection_possible = true;
selectWord(lyx::WHOLE_WORD_STRICT);
selectWord(cur, lyx::WHOLE_WORD_STRICT);
bv->haveSelection(cur.selection());
}
break;
@ -1095,14 +1091,14 @@ DispatchResult LyXText::dispatch(LCursor & cur, FuncRequest const & cmd)
"Dispatch: no selection possible\n";
break;
}
RowList::iterator cursorrow = cursorRow();
CursorSlice old = cur.current();
#warning
setCursorFromCoordinates(cmd.x, cmd.y);
// This is to allow jumping over large insets
// FIXME: shouldn't be top-text-specific
if (cursorrow == cursorRow() && !in_inset_) {
if (!in_inset_ && cur.current() == old) {
if (cmd.y - bv->top_y() >= bv->workHeight())
cursorDown(cur, true);
else if (cmd.y - bv->top_y() < 0)
@ -1280,12 +1276,12 @@ DispatchResult LyXText::dispatch(LCursor & cur, FuncRequest const & cmd)
case LFUN_ENVIRONMENT_INSERT:
// Open the inset, and move the current selection
// inside it.
doInsertInset(this, bv, cmd, true, true);
doInsertInset(cur, this, bv, cmd, true, true);
break;
case LFUN_INDEX_INSERT:
// Just open the inset
doInsertInset(this, bv, cmd, true, false);
doInsertInset(cur, this, bv, cmd, true, false);
break;
case LFUN_INDEX_PRINT:
@ -1294,16 +1290,16 @@ DispatchResult LyXText::dispatch(LCursor & cur, FuncRequest const & cmd)
case LFUN_INSERT_LINE:
case LFUN_INSERT_PAGEBREAK:
// do nothing fancy
doInsertInset(this, bv, cmd, false, false);
doInsertInset(cur, this, bv, cmd, false, false);
break;
case LFUN_DEPTH_MIN:
bv_funcs::changeDepth(bv, this, bv_funcs::DEC_DEPTH);
changeDepth(cur, bv_funcs::DEC_DEPTH);
bv->update();
break;
case LFUN_DEPTH_PLUS:
bv_funcs::changeDepth(bv, this, bv_funcs::INC_DEPTH);
changeDepth(cur, bv_funcs::INC_DEPTH);
bv->update();
break;
@ -1343,7 +1339,7 @@ DispatchResult LyXText::dispatch(LCursor & cur, FuncRequest const & cmd)
case LFUN_EMPH: {
LyXFont font(LyXFont::ALL_IGNORE);
font.setEmph(LyXFont::TOGGLE);
toggleAndShow(bv, this, font);
toggleAndShow(cur, this, font);
bv->owner()->view_state_changed();
break;
}
@ -1351,7 +1347,7 @@ DispatchResult LyXText::dispatch(LCursor & cur, FuncRequest const & cmd)
case LFUN_BOLD: {
LyXFont font(LyXFont::ALL_IGNORE);
font.setSeries(LyXFont::BOLD_SERIES);
toggleAndShow(bv, this, font);
toggleAndShow(cur, this, font);
bv->owner()->view_state_changed();
break;
}
@ -1359,7 +1355,7 @@ DispatchResult LyXText::dispatch(LCursor & cur, FuncRequest const & cmd)
case LFUN_NOUN: {
LyXFont font(LyXFont::ALL_IGNORE);
font.setNoun(LyXFont::TOGGLE);
toggleAndShow(bv, this, font);
toggleAndShow(cur, this, font);
bv->owner()->view_state_changed();
break;
}
@ -1367,7 +1363,7 @@ DispatchResult LyXText::dispatch(LCursor & cur, FuncRequest const & cmd)
case LFUN_CODE: {
LyXFont font(LyXFont::ALL_IGNORE);
font.setFamily(LyXFont::TYPEWRITER_FAMILY); // no good
toggleAndShow(bv, this, font);
toggleAndShow(cur, this, font);
bv->owner()->view_state_changed();
break;
}
@ -1375,7 +1371,7 @@ DispatchResult LyXText::dispatch(LCursor & cur, FuncRequest const & cmd)
case LFUN_SANS: {
LyXFont font(LyXFont::ALL_IGNORE);
font.setFamily(LyXFont::SANS_FAMILY);
toggleAndShow(bv, this, font);
toggleAndShow(cur, this, font);
bv->owner()->view_state_changed();
break;
}
@ -1383,14 +1379,14 @@ DispatchResult LyXText::dispatch(LCursor & cur, FuncRequest const & cmd)
case LFUN_ROMAN: {
LyXFont font(LyXFont::ALL_IGNORE);
font.setFamily(LyXFont::ROMAN_FAMILY);
toggleAndShow(bv, this, font);
toggleAndShow(cur, this, font);
bv->owner()->view_state_changed();
break;
}
case LFUN_DEFAULT: {
LyXFont font(LyXFont::ALL_INHERIT, ignore_language);
toggleAndShow(bv, this, font);
toggleAndShow(cur, this, font);
bv->owner()->view_state_changed();
break;
}
@ -1398,7 +1394,7 @@ DispatchResult LyXText::dispatch(LCursor & cur, FuncRequest const & cmd)
case LFUN_UNDERLINE: {
LyXFont font(LyXFont::ALL_IGNORE);
font.setUnderbar(LyXFont::TOGGLE);
toggleAndShow(bv, this, font);
toggleAndShow(cur, this, font);
bv->owner()->view_state_changed();
break;
}
@ -1406,7 +1402,7 @@ DispatchResult LyXText::dispatch(LCursor & cur, FuncRequest const & cmd)
case LFUN_FONT_SIZE: {
LyXFont font(LyXFont::ALL_IGNORE);
font.setLyXSize(cmd.argument);
toggleAndShow(bv, this, font);
toggleAndShow(cur, this, font);
bv->owner()->view_state_changed();
break;
}
@ -1417,16 +1413,16 @@ DispatchResult LyXText::dispatch(LCursor & cur, FuncRequest const & cmd)
break;
LyXFont font(LyXFont::ALL_IGNORE);
font.setLanguage(lang);
toggleAndShow(bv, this, font);
toggleAndShow(cur, this, font);
bv->switchKeyMap();
bv->owner()->view_state_changed();
break;
}
case LFUN_FREEFONT_APPLY:
toggleAndShow(bv, this, freefont, toggleall);
toggleAndShow(cur, this, freefont, toggleall);
bv->owner()->view_state_changed();
bv->owner()->message(_("Character set"));
cur.message(_("Character set"));
break;
// Set the freefont using the contents of \param data dispatched from
@ -1437,9 +1433,9 @@ DispatchResult LyXText::dispatch(LCursor & cur, FuncRequest const & cmd)
if (bv_funcs::string2font(cmd.argument, font, toggle)) {
freefont = font;
toggleall = toggle;
toggleAndShow(bv, this, freefont, toggleall);
toggleAndShow(cur, this, freefont, toggleall);
bv->owner()->view_state_changed();
bv->owner()->message(_("Character set"));
cur.message(_("Character set"));
}
break;
}
@ -1535,9 +1531,9 @@ DispatchResult LyXText::dispatch(LCursor & cur, FuncRequest const & cmd)
breakParagraph(cur);
}
setLayout(tclass.defaultLayoutName());
setLayout(cur, tclass.defaultLayoutName());
setParagraph(Spacing(), LYX_ALIGN_LAYOUT, string(), 0);
insertInset(new InsetFloatList(cmd.argument));
cur.insert(new InsetFloatList(cmd.argument));
unFreezeUndo();
} else {
lyxerr << "Non-existent float type: "
@ -1546,6 +1542,33 @@ DispatchResult LyXText::dispatch(LCursor & cur, FuncRequest const & cmd)
break;
}
case LFUN_ACCEPT_CHANGE: {
acceptChange(cur);
bv->update();
break;
}
case LFUN_REJECT_CHANGE: {
rejectChange(cur);
bv->update();
break;
}
case LFUN_THESAURUS_ENTRY: {
string arg = cmd.argument;
if (arg.empty()) {
arg = cur.selectionAsString(false);
// FIXME
if (arg.size() > 100 || arg.empty()) {
// Get word or selection
selectWordWhenUnderCursor(cur, lyx::WHOLE_WORD);
arg = cur.selectionAsString(false);
}
}
bv->owner()->getDialogs().show("thesaurus", arg);
break;
}
default:
return DispatchResult(false);
}

24
src/trans_mgr.C
View File

@ -12,11 +12,16 @@
#include <config.h>
#include "trans_mgr.h"
#include "trans.h"
#include "lyxtext.h"
#include "BufferView.h"
#include "cursor.h"
#include "debug.h"
#include "insets/insetlatexaccent.h"
#include "lyxrc.h"
#include "lyxtext.h"
#include "trans.h"
#include "insets/insetlatexaccent.h"
#include "support/lstrings.h"
using lyx::support::split;
@ -260,11 +265,8 @@ void TransManager::TranslateAndInsert(char c, LyXText * text)
void TransManager::insertVerbatim(string const & str, LyXText * text)
{
string::size_type const l = str.length();
for (string::size_type i = 0; i < l; ++i) {
text->insertChar(str[i]);
}
for (string::size_type i = 0, n = str.size(); i < n; ++i)
text->insertChar(text->bv()->cursor(), str[i]);
}
@ -282,15 +284,13 @@ void TransManager::insert(string const & str, LyXText * text)
// Could not find an encoding
InsetLatexAccent ins(str);
if (ins.canDisplay()) {
text->insertInset(
new InsetLatexAccent(ins));
text->bv()->cursor().insert(new InsetLatexAccent(ins));
} else {
insertVerbatim(str, text);
}
return;
}
string tmp;
tmp += static_cast<char>(enc.second);
string const tmp(1, static_cast<char>(enc.second));
insertVerbatim(tmp, text);
}

10
src/undo.C
View File

@ -186,7 +186,9 @@ bool performUndoOrRedo(BufferView & bv, Undo const & undo)
text->updateCounters();
// rebreak the entire lyxtext
buf.text().fullRebreak();
#warning needed?
text->redoParagraphs(buf.paragraphs().begin(), buf.paragraphs().end());
bv.cursor().resetAnchor();
ParIterator pit2 = num2pit(buf, undo.text);
advance(pit2, undo.cursor_par);
@ -290,6 +292,12 @@ void recordUndo(LCursor & cur, Undo::undo_kind kind)
}
void recordUndoSelection(LCursor & cur, Undo::undo_kind kind)
{
recordUndo(kind, cur, cur.selBegin().par(), cur.selEnd().par());
}
void recordUndo(LCursor & cur, Undo::undo_kind kind, paroffset_type from)
{
recordUndo(kind, cur, cur.par(), from);

2
src/undo.h
View File

@ -102,6 +102,8 @@ void recordUndo(LCursor & cur, Undo::undo_kind kind, lyx::paroffset_type from);
/// convienience: prepare undo for the single paragraph containing the cursor
void recordUndo(LCursor & cur, Undo::undo_kind kind = Undo::ATOMIC);
/// convienience: prepare undo for the selected paragraphs
void recordUndoSelection(LCursor & cur, Undo::undo_kind kind = Undo::ATOMIC);
/// convienience: prepare undo for the single paragraph containing the cursor
void recordUndoFullDocument(LCursor & cur);