anne/lyx_mirror
1
0
Fork 0
mirror of https://git.lyx.org/repos/lyx.git synced 2024-12-22 13:18:28 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

Remove the BufferView* arg from almost all LyXText class functions.

Browse Source 
git-svn-id: svn://svn.lyx.org/lyx/lyx-devel/trunk@6519 a592a061-630c-0410-9148-cb99ea01b6c8
This commit is contained in:
Lars Gullik Bjønnes 2003-03-17 16:25:00 +00:00
parent e5d401f632
commit 064714a102
32 changed files with 1155 additions and 1152 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
po/POTFILES.in
View File

@ -13,12 +13,10 @@ src/frontends/controllers/biblio.C
src/frontends/controllers/character.C src/frontends/controllers/character.C
src/frontends/controllers/ControlAboutlyx.C src/frontends/controllers/ControlAboutlyx.C
src/frontends/controllers/ControlBibtex.C src/frontends/controllers/ControlBibtex.C
src/frontends/controllers/ControlCharacter.C
src/frontends/controllers/ControlDocument.C src/frontends/controllers/ControlDocument.C
src/frontends/controllers/ControlExternal.C src/frontends/controllers/ControlExternal.C
src/frontends/controllers/ControlGraphics.C src/frontends/controllers/ControlGraphics.C
src/frontends/controllers/ControlInclude.C src/frontends/controllers/ControlInclude.C
src/frontends/controllers/ControlParagraph.C
src/frontends/controllers/ControlPreamble.C src/frontends/controllers/ControlPreamble.C
src/frontends/controllers/ControlPrefs.C src/frontends/controllers/ControlPrefs.C
src/frontends/controllers/ControlPrint.C src/frontends/controllers/ControlPrint.C
@ -135,6 +133,7 @@ src/importer.C
src/insets/insetbibtex.C src/insets/insetbibtex.C
src/insets/inset.C src/insets/inset.C
src/insets/insetcaption.C src/insets/insetcaption.C
src/insets/insetenv.C
src/insets/inseterror.C src/insets/inseterror.C
src/insets/insetert.C src/insets/insetert.C
src/insets/insetexternal.C src/insets/insetexternal.C
@ -180,6 +179,7 @@ src/mathed/ref_inset.C
src/MenuBackend.C src/MenuBackend.C
src/paragraph.C src/paragraph.C
src/paragraph_funcs.C src/paragraph_funcs.C
src/ParagraphParameters.C
src/rowpainter.C src/rowpainter.C
src/support/filetools.C src/support/filetools.C
src/tabular.C src/tabular.C

48
src/BufferView.C
View File

@ -349,7 +349,7 @@ bool BufferView::removeAutoInsets()
// loop once at most. However for safety we iterate rather than just // loop once at most. However for safety we iterate rather than just
// make this an if () conditional. // make this an if () conditional.
while ((cursor_par_prev || cursor_par_next) while ((cursor_par_prev || cursor_par_next)
&& text->setCursor(this, && text->setCursor(
cursor_par_prev ? cursor_par_prev : cursor_par_next, cursor_par_prev ? cursor_par_prev : cursor_par_next,
0)) { 0)) {
// We just removed cursor_par so have to fix the "cursor" // We just removed cursor_par so have to fix the "cursor"
@ -379,7 +379,7 @@ bool BufferView::removeAutoInsets()
Paragraph * par_prev = par ? par->previous() : 0; Paragraph * par_prev = par ? par->previous() : 0;
bool removed = false; bool removed = false;
if (text->setCursor(this, par, 0) if (text->setCursor(par, 0)
&& cursor_par == par_prev) { && cursor_par == par_prev) {
// The previous setCursor line was deleted and that // The previous setCursor line was deleted and that
// was the cursor_par line. This can only happen if an // was the cursor_par line. This can only happen if an
@ -443,14 +443,14 @@ bool BufferView::removeAutoInsets()
} }
if (removed) { if (removed) {
found = true; found = true;
text->redoParagraph(this); text->redoParagraph();
} }
} }
// It is possible that the last line is empty if it was cursor_par // It is possible that the last line is empty if it was cursor_par
// and/or only had an error inset on it. So we set the cursor to the // and/or only had an error inset on it. So we set the cursor to the
// start of the doc to force its removal and ensure a valid saved cursor // start of the doc to force its removal and ensure a valid saved cursor
if (text->setCursor(this, text->ownerParagraph(), 0) if (text->setCursor(text->ownerParagraph(), 0)
&& 0 == cursor_par_next) { && 0 == cursor_par_next) {
cursor_par = cursor_par_prev; cursor_par = cursor_par_prev;
cursor_pos = cursor_par->size(); cursor_pos = cursor_par->size();
@ -463,7 +463,7 @@ bool BufferView::removeAutoInsets()
} }
// restore the original cursor in its corrected location. // restore the original cursor in its corrected location.
text->setCursorIntern(this, cursor_par, cursor_pos); text->setCursorIntern(cursor_par, cursor_pos);
return found; return found;
} }
@ -504,13 +504,13 @@ void BufferView::insertErrors(TeXErrors & terr)
freezeUndo(); freezeUndo();
InsetError * new_inset = new InsetError(msgtxt); InsetError * new_inset = new InsetError(msgtxt);
text->setCursorIntern(this, texrowpar, tmppos); text->setCursorIntern(texrowpar, tmppos);
text->insertInset(this, new_inset); text->insertInset(new_inset);
text->fullRebreak(this); text->fullRebreak();
unFreezeUndo(); unFreezeUndo();
} }
// Restore the cursor position // Restore the cursor position
text->setCursorIntern(this, cursor.par(), cursor.pos()); text->setCursorIntern(cursor.par(), cursor.pos());
} }
@ -529,7 +529,7 @@ void BufferView::setCursorFromRow(int row)
} else { } else {
texrowpar = buffer()->getParFromID(tmpid); texrowpar = buffer()->getParFromID(tmpid);
} }
text->setCursor(this, texrowpar, tmppos); text->setCursor(texrowpar, tmppos);
} }
@ -552,7 +552,7 @@ bool BufferView::gotoLabel(string const & label)
if (find(labels.begin(),labels.end(),label) if (find(labels.begin(),labels.end(),label)
!= labels.end()) { != labels.end()) {
beforeChange(text); beforeChange(text);
text->setCursor(this, it.getPar(), it.getPos()); text->setCursor(it.getPar(), it.getPos());
text->selection.cursor = text->cursor; text->selection.cursor = text->cursor;
update(text, BufferView::SELECT|BufferView::FITCUR); update(text, BufferView::SELECT|BufferView::FITCUR);
return true; return true;
@ -608,7 +608,7 @@ void BufferView::copyEnvironment()
void BufferView::pasteEnvironment() void BufferView::pasteEnvironment()
{ {
if (available()) { if (available()) {
text->pasteEnvironmentType(this); text->pasteEnvironmentType();
owner()->message(_("Paragraph environment type set")); owner()->message(_("Paragraph environment type set"));
update(text, BufferView::SELECT|BufferView::FITCUR|BufferView::CHANGE); update(text, BufferView::SELECT|BufferView::FITCUR|BufferView::CHANGE);
} }
@ -623,7 +623,7 @@ WordLangTuple const BufferView::nextWord(float & value)
return WordLangTuple(); return WordLangTuple();
} }
return text->selectNextWordToSpellcheck(this, value); return text->selectNextWordToSpellcheck(value);
} }
@ -636,7 +636,7 @@ void BufferView::selectLastWord()
hideCursor(); hideCursor();
beforeChange(text); beforeChange(text);
text->selection.cursor = cur; text->selection.cursor = cur;
text->selectSelectedWord(this); text->selectSelectedWord();
toggleSelection(false); toggleSelection(false);
update(text, BufferView::SELECT|BufferView::FITCUR); update(text, BufferView::SELECT|BufferView::FITCUR);
} }
@ -648,7 +648,7 @@ void BufferView::endOfSpellCheck()
hideCursor(); hideCursor();
beforeChange(text); beforeChange(text);
text->selectSelectedWord(this); text->selectSelectedWord();
text->clearSelection(); text->clearSelection();
update(text, BufferView::SELECT|BufferView::FITCUR); update(text, BufferView::SELECT|BufferView::FITCUR);
} }
@ -669,9 +669,9 @@ void BufferView::replaceWord(string const & replacestring)
// clear the selection (if there is any) // clear the selection (if there is any)
toggleSelection(false); toggleSelection(false);
tt->replaceSelectionWithString(this, replacestring); tt->replaceSelectionWithString(replacestring);
tt->setSelectionRange(this, replacestring.length()); tt->setSelectionRange(replacestring.length());
// Go back so that replacement string is also spellchecked // Go back so that replacement string is also spellchecked
for (string::size_type i = 0; i < replacestring.length() + 1; ++i) { for (string::size_type i = 0; i < replacestring.length() + 1; ++i) {
@ -709,12 +709,12 @@ bool BufferView::lockInset(UpdatableInset * inset)
InsetList::iterator end = pit->insetlist.end(); InsetList::iterator end = pit->insetlist.end();
for (; it != end; ++it) { for (; it != end; ++it) {
if (it.getInset() == inset) { if (it.getInset() == inset) {
text->setCursorIntern(this, &*pit, it.getPos()); text->setCursorIntern(&*pit, it.getPos());
theLockingInset(inset); theLockingInset(inset);
return true; return true;
} }
if (it.getInset()->getInsetFromID(id)) { if (it.getInset()->getInsetFromID(id)) {
text->setCursorIntern(this, &*pit, it.getPos()); text->setCursorIntern(&*pit, it.getPos());
it.getInset()->edit(this); it.getInset()->edit(this);
return theLockingInset()->lockInsetInInset(this, inset); return theLockingInset()->lockInsetInInset(this, inset);
} }
@ -736,7 +736,7 @@ void BufferView::showLockedInsetCursor(int x, int y, int asc, int desc)
cursor.par()->isInset(cursor.pos() - 1) && cursor.par()->isInset(cursor.pos() - 1) &&
(cursor.par()->getInset(cursor.pos() - 1) == (cursor.par()->getInset(cursor.pos() - 1) ==
locking_inset)) locking_inset))
text->setCursor(this, cursor, text->setCursor(cursor,
cursor.par(), cursor.pos() - 1); cursor.par(), cursor.pos() - 1);
LyXScreen::Cursor_Shape shape = LyXScreen::BAR_SHAPE; LyXScreen::Cursor_Shape shape = LyXScreen::BAR_SHAPE;
LyXText * txt = getLyXText(); LyXText * txt = getLyXText();
@ -852,14 +852,14 @@ bool BufferView::ChangeInsets(Inset::Code code,
// The test it.size()==1 was needed to prevent crashes. // The test it.size()==1 was needed to prevent crashes.
// How to set the cursor corretly when it.size()>1 ?? // How to set the cursor corretly when it.size()>1 ??
if (it.size() == 1) { if (it.size() == 1) {
text->setCursorIntern(this, par, 0); text->setCursorIntern(par, 0);
text->redoParagraphs(this, text->cursor, text->redoParagraphs(text->cursor,
text->cursor.par()->next()); text->cursor.par()->next());
text->fullRebreak(this); text->fullRebreak();
} }
} }
} }
text->setCursorIntern(this, cursor.par(), cursor.pos()); text->setCursorIntern(cursor.par(), cursor.pos());
return need_update; return need_update;
} }

64
src/BufferView_pimpl.C
View File

@ -308,13 +308,13 @@ int BufferView::Pimpl::resizeCurrentBuffer()
// Mechanism when setting the cursor. // Mechanism when setting the cursor.
bv_->text->selection.mark(mark_set); bv_->text->selection.mark(mark_set);
if (selection) { if (selection) {
bv_->text->setCursor(bv_, selstartpar, selstartpos); bv_->text->setCursor(selstartpar, selstartpos);
bv_->text->selection.cursor = bv_->text->cursor; bv_->text->selection.cursor = bv_->text->cursor;
bv_->text->setCursor(bv_, selendpar, selendpos); bv_->text->setCursor(selendpar, selendpos);
bv_->text->setSelection(bv_); bv_->text->setSelection();
bv_->text->setCursor(bv_, par, pos); bv_->text->setCursor(par, pos);
} else { } else {
bv_->text->setCursor(bv_, par, pos); bv_->text->setCursor(par, pos);
bv_->text->selection.cursor = bv_->text->cursor; bv_->text->selection.cursor = bv_->text->cursor;
bv_->text->selection.set(false); bv_->text->selection.set(false);
} }
@ -376,9 +376,9 @@ void BufferView::Pimpl::scrollDocView(int value)
int const last = static_cast<int>((bv_->text->top_y() + workarea().workHeight() - height)); int const last = static_cast<int>((bv_->text->top_y() + workarea().workHeight() - height));
if (vbt->cursor.y() < first) if (vbt->cursor.y() < first)
vbt->setCursorFromCoordinates(bv_, 0, first); vbt->setCursorFromCoordinates(0, first);
else if (vbt->cursor.y() > last) else if (vbt->cursor.y() > last)
vbt->setCursorFromCoordinates(bv_, 0, last); vbt->setCursorFromCoordinates(0, last);
} }
@ -503,19 +503,19 @@ void BufferView::Pimpl::update()
screen().update(*bv_); screen().update(*bv_);
bool fitc = false; bool fitc = false;
while (bv_->text->status() == LyXText::CHANGED_IN_DRAW) { while (bv_->text->status() == LyXText::CHANGED_IN_DRAW) {
bv_->text->fullRebreak(bv_); bv_->text->fullRebreak();
bv_->text->setCursor(bv_, bv_->text->cursor.par(), bv_->text->setCursor(bv_->text->cursor.par(),
bv_->text->cursor.pos()); bv_->text->cursor.pos());
if (bv_->text->selection.set()) { if (bv_->text->selection.set()) {
bv_->text->setCursor(bv_, bv_->text->selection.start, bv_->text->setCursor(bv_->text->selection.start,
bv_->text->selection.start.par(), bv_->text->selection.start.par(),
bv_->text->selection.start.pos()); bv_->text->selection.start.pos());
bv_->text->setCursor(bv_, bv_->text->selection.end, bv_->text->setCursor(bv_->text->selection.end,
bv_->text->selection.end.par(), bv_->text->selection.end.par(),
bv_->text->selection.end.pos()); bv_->text->selection.end.pos());
} }
fitc = true; fitc = true;
bv_->text->postPaint(*bv_, 0); bv_->text->postPaint(0);
screen().update(*bv_); screen().update(*bv_);
} }
@ -574,7 +574,7 @@ void BufferView::Pimpl::update(LyXText * text, BufferView::UpdateCodes f)
text->selection.cursor = text->cursor; text->selection.cursor = text->cursor;
} }
text->fullRebreak(bv_); text->fullRebreak();
if (text->inset_owner) { if (text->inset_owner) {
text->inset_owner->setUpdateStatus(bv_, InsetText::NONE); text->inset_owner->setUpdateStatus(bv_, InsetText::NONE);
@ -680,7 +680,7 @@ void BufferView::Pimpl::restorePosition(unsigned int i)
if (!par) if (!par)
return; return;
bv_->text->setCursor(bv_, par, bv_->text->setCursor(par,
min(par->size(), saved_positions[i].par_pos)); min(par->size(), saved_positions[i].par_pos));
update(bv_->text, BufferView::SELECT | BufferView::FITCUR); update(bv_->text, BufferView::SELECT | BufferView::FITCUR);
@ -940,7 +940,7 @@ void BufferView::Pimpl::trackChanges()
buf->undostack.clear(); buf->undostack.clear();
} else { } else {
bv_->update(bv_->text, BufferView::SELECT | BufferView::FITCUR); bv_->update(bv_->text, BufferView::SELECT | BufferView::FITCUR);
bv_->text->setCursor(bv_, &(*buf->paragraphs.begin()), 0); bv_->text->setCursor(&(*buf->paragraphs.begin()), 0);
#warning changes FIXME #warning changes FIXME
//moveCursorUpdate(false); //moveCursorUpdate(false);
@ -1224,7 +1224,7 @@ bool BufferView::Pimpl::dispatch(FuncRequest const & ev_in)
case LFUN_PARAGRAPH_APPLY: case LFUN_PARAGRAPH_APPLY:
setParagraphParams(*bv_, ev.argument); setParagraphParams(*bv_, ev.argument);
break; break;
case LFUN_THESAURUS_ENTRY: case LFUN_THESAURUS_ENTRY:
{ {
string arg = ev.argument; string arg = ev.argument;
@ -1236,7 +1236,7 @@ bool BufferView::Pimpl::dispatch(FuncRequest const & ev_in)
// FIXME // FIXME
if (arg.size() > 100 || arg.empty()) { if (arg.size() > 100 || arg.empty()) {
// Get word or selection // Get word or selection
bv_->getLyXText()->selectWordWhenUnderCursor(bv_, LyXText::WHOLE_WORD); bv_->getLyXText()->selectWordWhenUnderCursor(LyXText::WHOLE_WORD);
arg = bv_->getLyXText()->selectionAsString(buffer_, false); arg = bv_->getLyXText()->selectionAsString(buffer_, false);
// FIXME: where is getLyXText()->unselect(bv_) ? // FIXME: where is getLyXText()->unselect(bv_) ?
} }
@ -1256,12 +1256,12 @@ bool BufferView::Pimpl::dispatch(FuncRequest const & ev_in)
case LFUN_ACCEPT_ALL_CHANGES: { case LFUN_ACCEPT_ALL_CHANGES: {
bv_->update(bv_->text, BufferView::SELECT | BufferView::FITCUR); bv_->update(bv_->text, BufferView::SELECT | BufferView::FITCUR);
bv_->text->setCursor(bv_, &(*bv_->buffer()->paragraphs.begin()), 0); bv_->text->setCursor(&(*bv_->buffer()->paragraphs.begin()), 0);
#warning FIXME changes #warning FIXME changes
//moveCursorUpdate(false); //moveCursorUpdate(false);
while (lyxfind::findNextChange(bv_)) { while (lyxfind::findNextChange(bv_)) {
bv_->getLyXText()->acceptChange(bv_); bv_->getLyXText()->acceptChange();
} }
update(bv_->text, update(bv_->text,
BufferView::SELECT | BufferView::FITCUR | BufferView::CHANGE); BufferView::SELECT | BufferView::FITCUR | BufferView::CHANGE);
@ -1270,12 +1270,12 @@ bool BufferView::Pimpl::dispatch(FuncRequest const & ev_in)
case LFUN_REJECT_ALL_CHANGES: { case LFUN_REJECT_ALL_CHANGES: {
bv_->update(bv_->text, BufferView::SELECT | BufferView::FITCUR); bv_->update(bv_->text, BufferView::SELECT | BufferView::FITCUR);
bv_->text->setCursor(bv_, &(*bv_->buffer()->paragraphs.begin()), 0); bv_->text->setCursor(&(*bv_->buffer()->paragraphs.begin()), 0);
#warning FIXME changes #warning FIXME changes
//moveCursorUpdate(false); //moveCursorUpdate(false);
while (lyxfind::findNextChange(bv_)) { while (lyxfind::findNextChange(bv_)) {
bv_->getLyXText()->rejectChange(bv_); bv_->getLyXText()->rejectChange();
} }
update(bv_->text, update(bv_->text,
BufferView::SELECT | BufferView::FITCUR | BufferView::CHANGE); BufferView::SELECT | BufferView::FITCUR | BufferView::CHANGE);
@ -1283,14 +1283,14 @@ bool BufferView::Pimpl::dispatch(FuncRequest const & ev_in)
} }
case LFUN_ACCEPT_CHANGE: { case LFUN_ACCEPT_CHANGE: {
bv_->getLyXText()->acceptChange(bv_); bv_->getLyXText()->acceptChange();
update(bv_->text, update(bv_->text,
BufferView::SELECT | BufferView::FITCUR | BufferView::CHANGE); BufferView::SELECT | BufferView::FITCUR | BufferView::CHANGE);
break; break;
} }
case LFUN_REJECT_CHANGE: { case LFUN_REJECT_CHANGE: {
bv_->getLyXText()->rejectChange(bv_); bv_->getLyXText()->rejectChange();
update(bv_->text, update(bv_->text,
BufferView::SELECT | BufferView::FITCUR | BufferView::CHANGE); BufferView::SELECT | BufferView::FITCUR | BufferView::CHANGE);
break; break;
@ -1325,13 +1325,13 @@ bool BufferView::Pimpl::insertInset(Inset * inset, string const & lout)
beforeChange(bv_->text); beforeChange(bv_->text);
if (!lout.empty()) { if (!lout.empty()) {
update(bv_->text, BufferView::SELECT|BufferView::FITCUR); update(bv_->text, BufferView::SELECT|BufferView::FITCUR);
bv_->text->breakParagraph(bv_, bv_->buffer()->paragraphs); bv_->text->breakParagraph(bv_->buffer()->paragraphs);
update(bv_->text, BufferView::SELECT|BufferView::FITCUR|BufferView::CHANGE); update(bv_->text, BufferView::SELECT|BufferView::FITCUR|BufferView::CHANGE);
if (!bv_->text->cursor.par()->empty()) { if (!bv_->text->cursor.par()->empty()) {
bv_->text->cursorLeft(bv_); bv_->text->cursorLeft(bv_);
bv_->text->breakParagraph(bv_, bv_->buffer()->paragraphs); bv_->text->breakParagraph(bv_->buffer()->paragraphs);
update(bv_->text, BufferView::SELECT|BufferView::FITCUR|BufferView::CHANGE); update(bv_->text, BufferView::SELECT|BufferView::FITCUR|BufferView::CHANGE);
} }
@ -1349,9 +1349,9 @@ bool BufferView::Pimpl::insertInset(Inset * inset, string const & lout)
lay = tclass.defaultLayoutName(); lay = tclass.defaultLayoutName();
} }
bv_->text->setLayout(bv_, lay); bv_->text->setLayout(lay);
bv_->text->setParagraph(bv_, 0, 0, bv_->text->setParagraph(0, 0,
0, 0, 0, 0,
VSpace(VSpace::NONE), VSpace(VSpace::NONE), VSpace(VSpace::NONE), VSpace(VSpace::NONE),
Spacing(), Spacing(),
@ -1361,7 +1361,7 @@ bool BufferView::Pimpl::insertInset(Inset * inset, string const & lout)
update(bv_->text, BufferView::SELECT|BufferView::FITCUR|BufferView::CHANGE); update(bv_->text, BufferView::SELECT|BufferView::FITCUR|BufferView::CHANGE);
} }
bv_->text->insertInset(bv_, inset); bv_->text->insertInset(inset);
update(bv_->text, BufferView::SELECT|BufferView::FITCUR|BufferView::CHANGE); update(bv_->text, BufferView::SELECT|BufferView::FITCUR|BufferView::CHANGE);
unFreezeUndo(); unFreezeUndo();
@ -1377,7 +1377,7 @@ void BufferView::Pimpl::updateInset(Inset * inset, bool mark_dirty)
// first check for locking insets // first check for locking insets
if (bv_->theLockingInset()) { if (bv_->theLockingInset()) {
if (bv_->theLockingInset() == inset) { if (bv_->theLockingInset() == inset) {
if (bv_->text->updateInset(bv_, inset)) { if (bv_->text->updateInset(inset)) {
update(); update();
if (mark_dirty) { if (mark_dirty) {
buffer_->markDirty(); buffer_->markDirty();
@ -1386,7 +1386,7 @@ void BufferView::Pimpl::updateInset(Inset * inset, bool mark_dirty)
return; return;
} }
} else if (bv_->theLockingInset()->updateInsetInInset(bv_, inset)) { } else if (bv_->theLockingInset()->updateInsetInInset(bv_, inset)) {
if (bv_->text->updateInset(bv_, bv_->theLockingInset())) { if (bv_->text->updateInset(bv_->theLockingInset())) {
update(); update();
if (mark_dirty) { if (mark_dirty) {
buffer_->markDirty(); buffer_->markDirty();
@ -1406,7 +1406,7 @@ void BufferView::Pimpl::updateInset(Inset * inset, bool mark_dirty)
hideCursor(); hideCursor();
if (tl_inset == inset) { if (tl_inset == inset) {
update(bv_->text, BufferView::UPDATE); update(bv_->text, BufferView::UPDATE);
if (bv_->text->updateInset(bv_, inset)) { if (bv_->text->updateInset(inset)) {
if (mark_dirty) { if (mark_dirty) {
update(bv_->text, update(bv_->text,
BufferView::SELECT BufferView::SELECT
@ -1420,7 +1420,7 @@ void BufferView::Pimpl::updateInset(Inset * inset, bool mark_dirty)
} else if (static_cast<UpdatableInset *>(tl_inset) } else if (static_cast<UpdatableInset *>(tl_inset)
->updateInsetInInset(bv_, inset)) ->updateInsetInInset(bv_, inset))
{ {
if (bv_->text->updateInset(bv_, tl_inset)) { if (bv_->text->updateInset(tl_inset)) {
update(); update();
updateScrollbar(); updateScrollbar();
} }

22
src/ChangeLog
View File

@ -1,3 +1,9 @@
2003-03-17 Lars Gullik Bjønnes <larsbj@gullik.net>
* lyxtext.h: remove BufferView* as first arg from almost all class
functions.
* other files: adjust.
2003-03-17 John Levon <levon@movementarian.org> 2003-03-17 John Levon <levon@movementarian.org>
* lyxtext.h: * lyxtext.h:
@ -17,11 +23,11 @@
* text3.C: add helper functions for setting refresh_row/y * text3.C: add helper functions for setting refresh_row/y
2003-03-14 Kayvan Sylvan <kayvan@sylvan.com> 2003-03-14 Kayvan Sylvan <kayvan@sylvan.com>
* paragraph_pimpl.C (simpleTeXSpecialChars): Added fix for the * paragraph_pimpl.C (simpleTeXSpecialChars): Added fix for the
newline inset which *can* get inserted in the pass_thru layouts. newline inset which *can* get inserted in the pass_thru layouts.
This is primarily for literate documents. This is primarily for literate documents.
2003-03-14 Dekel Tsur <dekelts@tau.ac.il> 2003-03-14 Dekel Tsur <dekelts@tau.ac.il>
* buffer.C: increment LYX_FORMAT to 223 * buffer.C: increment LYX_FORMAT to 223
@ -73,7 +79,7 @@
Probably only temporary. Let's see how things pan out. Probably only temporary. Let's see how things pan out.
* BufferView.C (unlockInset): * BufferView.C (unlockInset):
* BufferView_pimpl.C (fitCursor): * BufferView_pimpl.C (fitCursor):
replace Dialogs::updateParagraph with dispatch(LFUN_PARAGRAPH_UPDATE). replace Dialogs::updateParagraph with dispatch(LFUN_PARAGRAPH_UPDATE).
* BufferView_pimpl.C (dispatch): code for LFUNs LAYOUT_PARAGRAPH, * BufferView_pimpl.C (dispatch): code for LFUNs LAYOUT_PARAGRAPH,
@ -90,8 +96,8 @@
* lyxfunc.C: * lyxfunc.C:
* text3.C: * text3.C:
* factory.C: make it aware of InsetEnv * factory.C: make it aware of InsetEnv
2003-03-13 Lars Gullik Bjønnes <larsbj@gullik.net> 2003-03-13 Lars Gullik Bjønnes <larsbj@gullik.net>
* text2.C (setCursor): never ask for one past last * text2.C (setCursor): never ask for one past last

34
src/CutAndPaste.C
View File

@ -224,11 +224,11 @@ bool CutAndPaste::pasteSelection(Paragraph ** par, Paragraph ** endpar,
pos = (*par)->size(); pos = (*par)->size();
// many paragraphs // many paragraphs
// make a copy of the simple cut_buffer // make a copy of the simple cut_buffer
#if 1 #if 1
ParagraphList::iterator it = paragraphs.begin(); ParagraphList::iterator it = paragraphs.begin();
ParagraphList simple_cut_clone; ParagraphList simple_cut_clone;
simple_cut_clone.insert(simple_cut_clone.begin(), simple_cut_clone.insert(simple_cut_clone.begin(),
new Paragraph(*it, false)); new Paragraph(*it, false));
@ -251,13 +251,13 @@ bool CutAndPaste::pasteSelection(Paragraph ** par, Paragraph ** endpar,
// Temporary set *par as previous of tmpbuf as we might have // Temporary set *par as previous of tmpbuf as we might have
// to realize the font. // to realize the font.
tmpbuf->previous(*par); tmpbuf->previous(*par);
// make sure there is no class difference // make sure there is no class difference
SwitchLayoutsBetweenClasses(textclass, tc, &*tmpbuf, SwitchLayoutsBetweenClasses(textclass, tc, &*tmpbuf,
current_view->buffer()->params); current_view->buffer()->params);
Paragraph::depth_type max_depth = (*par)->getMaxDepthAfter(); Paragraph::depth_type max_depth = (*par)->getMaxDepthAfter();
while (tmpbuf != paragraphs.end()) { while (tmpbuf != paragraphs.end()) {
// If we have a negative jump so that the depth would // If we have a negative jump so that the depth would
// go below 0 depth then we have to redo the delta to // go below 0 depth then we have to redo the delta to
@ -300,14 +300,14 @@ bool CutAndPaste::pasteSelection(Paragraph ** par, Paragraph ** endpar,
// make the buf exactly the same layout than // make the buf exactly the same layout than
// the cursor paragraph // the cursor paragraph
paragraphs.begin()->makeSameLayout(*par); paragraphs.begin()->makeSameLayout(*par);
// find the end of the buffer // find the end of the buffer
ParagraphList::iterator lastbuffer = paragraphs.begin(); ParagraphList::iterator lastbuffer = paragraphs.begin();
while (boost::next(lastbuffer) != paragraphs.end()) while (boost::next(lastbuffer) != paragraphs.end())
++lastbuffer; ++lastbuffer;
bool paste_the_end = false; bool paste_the_end = false;
// open the paragraph for inserting the buf // open the paragraph for inserting the buf
// if necessary // if necessary
if (((*par)->size() > pos) || !(*par)->next()) { if (((*par)->size() > pos) || !(*par)->next()) {
@ -317,17 +317,17 @@ bool CutAndPaste::pasteSelection(Paragraph ** par, Paragraph ** endpar,
} }
// set the end for redoing later // set the end for redoing later
*endpar = (*par)->next()->next(); *endpar = (*par)->next()->next();
// paste it! // paste it!
lastbuffer->next((*par)->next()); lastbuffer->next((*par)->next());
(*par)->next()->previous(&*lastbuffer); (*par)->next()->previous(&*lastbuffer);
(*par)->next(&*paragraphs.begin()); (*par)->next(&*paragraphs.begin());
paragraphs.begin()->previous(*par); paragraphs.begin()->previous(*par);
if ((*par)->next() == lastbuffer) if ((*par)->next() == lastbuffer)
lastbuffer = *par; lastbuffer = *par;
mergeParagraph(current_view->buffer()->params, mergeParagraph(current_view->buffer()->params,
current_view->buffer()->paragraphs, *par); current_view->buffer()->paragraphs, *par);
// store the new cursor position // store the new cursor position
@ -350,7 +350,7 @@ bool CutAndPaste::pasteSelection(Paragraph ** par, Paragraph ** endpar,
} }
// restore the simple cut buffer // restore the simple cut buffer
paragraphs = simple_cut_clone; paragraphs = simple_cut_clone;
return true; return true;
} }
@ -408,10 +408,10 @@ int CutAndPaste::SwitchLayoutsBetweenClasses(textclass_type c1,
InsetError * new_inset = new InsetError(s); InsetError * new_inset = new InsetError(s);
LyXText * txt = current_view->getLyXText(); LyXText * txt = current_view->getLyXText();
LyXCursor cur = txt->cursor; LyXCursor cur = txt->cursor;
txt->setCursorIntern(current_view, par, 0); txt->setCursorIntern(par, 0);
txt->insertInset(current_view, new_inset); txt->insertInset(new_inset);
txt->fullRebreak(current_view); txt->fullRebreak();
txt->setCursorIntern(current_view, cur.par(), cur.pos()); txt->setCursorIntern(cur.par(), cur.pos());
unFreezeUndo(); unFreezeUndo();
} }
} }

3
src/ParagraphParameters.C
View File

@ -426,8 +426,7 @@ void setParagraphParams(BufferView & bv, string const & data)
params.read(lex); params.read(lex);
LyXText * text = bv.getLyXText(); LyXText * text = bv.getLyXText();
text->setParagraph(&bv, text->setParagraph(params.lineTop(),
params.lineTop(),
params.lineBottom(), params.lineBottom(),
params.pagebreakTop(), params.pagebreakTop(),
params.pagebreakBottom(), params.pagebreakBottom(),

6
src/buffer.C
View File

@ -337,7 +337,7 @@ bool Buffer::readBody(LyXLex & lex, ParagraphList::iterator pit)
} }
} else { } else {
// We are inserting into an existing document // We are inserting into an existing document
users->text->breakParagraph(users, paragraphs); users->text->breakParagraph(paragraphs);
markDirty(); markDirty();
// We don't want to adopt the parameters from the // We don't want to adopt the parameters from the
@ -406,8 +406,8 @@ bool Buffer::readBody(LyXLex & lex, ParagraphList::iterator pit)
int int
Buffer::readParagraph(LyXLex & lex, string const & token, Buffer::readParagraph(LyXLex & lex, string const & token,
ParagraphList & pars, ParagraphList::iterator & pit, ParagraphList & pars, ParagraphList::iterator & pit,
Paragraph::depth_type & depth) Paragraph::depth_type & depth)
{ {
static Change current_change; static Change current_change;
int unknown = 0; int unknown = 0;

8
src/bufferview_funcs.C
View File

@ -236,9 +236,9 @@ void changeDepth(BufferView * bv, LyXText * text, int decInc)
bv->hideCursor(); bv->hideCursor();
bv->update(bv->text, BufferView::SELECT|BufferView::FITCUR); bv->update(bv->text, BufferView::SELECT|BufferView::FITCUR);
if (decInc >= 0) if (decInc >= 0)
text->incDepth(bv); text->incDepth();
else else
text->decDepth(bv); text->decDepth();
if (text->inset_owner) if (text->inset_owner)
bv->updateInset((Inset *)text->inset_owner, true); bv->updateInset((Inset *)text->inset_owner, true);
bv->update(bv->text, BufferView::SELECT|BufferView::FITCUR|BufferView::CHANGE); bv->update(bv->text, BufferView::SELECT|BufferView::FITCUR|BufferView::CHANGE);
@ -398,7 +398,7 @@ void toggleAndShow(BufferView * bv, LyXFont const & font, bool toggleall)
bv->hideCursor(); bv->hideCursor();
bv->update(text, BufferView::SELECT | BufferView::FITCUR); bv->update(text, BufferView::SELECT | BufferView::FITCUR);
text->toggleFree(bv, font, toggleall); text->toggleFree(font, toggleall);
bv->update(text, BufferView::SELECT | BufferView::FITCUR | BufferView::CHANGE); bv->update(text, BufferView::SELECT | BufferView::FITCUR | BufferView::CHANGE);
if (font.language() != ignore_language || if (font.language() != ignore_language ||
@ -408,7 +408,7 @@ void toggleAndShow(BufferView * bv, LyXFont const & font, bool toggleall)
if (cursor.boundary() != if (cursor.boundary() !=
text->isBoundary(bv->buffer(), cursor.par(), cursor.pos(), text->isBoundary(bv->buffer(), cursor.par(), cursor.pos(),
text->real_current_font)) text->real_current_font))
text->setCursor(bv, cursor.par(), cursor.pos(), text->setCursor(cursor.par(), cursor.pos(),
false, !cursor.boundary()); false, !cursor.boundary());
} }
} }

6
src/factory.C
View File

@ -112,7 +112,7 @@ Inset * createInset(FuncRequest const & cmd)
// Try and generate a valid index entry. // Try and generate a valid index entry.
InsetCommandParams icp("index"); InsetCommandParams icp("index");
string const contents = cmd.argument.empty() ? string const contents = cmd.argument.empty() ?
bv->getLyXText()->getStringToIndex(bv) : bv->getLyXText()->getStringToIndex() :
cmd.argument; cmd.argument;
icp.setContents(contents); icp.setContents(contents);
@ -200,14 +200,14 @@ Inset * createInset(FuncRequest const & cmd)
return inset; return inset;
} else if (name == "external") { } else if (name == "external") {
InsetExternal::Params iep; InsetExternal::Params iep;
InsetExternalMailer::string2params(cmd.argument, iep); InsetExternalMailer::string2params(cmd.argument, iep);
InsetExternal * inset = new InsetExternal; InsetExternal * inset = new InsetExternal;
inset->setFromParams(iep); inset->setFromParams(iep);
return inset; return inset;
} else if (name == "graphics") { } else if (name == "graphics") {
InsetGraphicsParams igp; InsetGraphicsParams igp;
InsetGraphicsMailer::string2params(cmd.argument, igp); InsetGraphicsMailer::string2params(cmd.argument, igp);
InsetGraphics * inset = new InsetGraphics; InsetGraphics * inset = new InsetGraphics;
string const fpath = cmd.view()->buffer()->filePath(); string const fpath = cmd.view()->buffer()->filePath();

8
src/frontends/ChangeLog
View File

@ -1,3 +1,7 @@
2003-03-17 Lars Gullik Bjønnes <larsbj@gullik.net>
* adjust for BufferView* arg removal from lyxtext.
2003-03-17 John Levon <levon@movementarian.org> 2003-03-17 John Levon <levon@movementarian.org>
* screen.h: * screen.h:
@ -8,7 +12,7 @@
* Dialogs.h: remove showParagraph and updateParagraph. * Dialogs.h: remove showParagraph and updateParagraph.
* guiapi.[Ch]: remove gui_ShowParagraph and gui_UpdateParagraph. * guiapi.[Ch]: remove gui_ShowParagraph and gui_UpdateParagraph.
2003-03-12 Angus Leeming <leeming@lyx.org> 2003-03-12 Angus Leeming <leeming@lyx.org>
* Dialogs.[Ch] (hide): rejig as a static method. Hide the signal * Dialogs.[Ch] (hide): rejig as a static method. Hide the signal
@ -101,7 +105,7 @@
* guiapi.[Ch]: provide a C-interface to the new Dialogs::show * guiapi.[Ch]: provide a C-interface to the new Dialogs::show
method. Retire the old functions that called dead Dialogs methods. method. Retire the old functions that called dead Dialogs methods.
2003-02-21 Angus Leeming <leeming@lyx.org> 2003-02-21 Angus Leeming <leeming@lyx.org>
* Timeout.[Ch]: define a Timeout::Impl abstract base class from * Timeout.[Ch]: define a Timeout::Impl abstract base class from

1
src/frontends/controllers/ControlError.C
View File

@ -28,4 +28,3 @@ void ControlError::clearParams()
{ {
params_.erase(); params_.erase();
} }

17
src/frontends/screen.C
View File

@ -357,7 +357,7 @@ void LyXScreen::redraw(LyXText * text, BufferView * bv)
return; return;
} }
workarea().getPainter().start(); workarea().getPainter().start();
@ -434,24 +434,25 @@ void LyXScreen::drawFromTo(LyXText * text, BufferView * bv,
RowPainter rp(*bv, *text, *row); RowPainter rp(*bv, *text, *row);
if (rp.paint(y + yo, xo, y + text->top_y())) if (rp.paint(y + yo, xo, y + text->top_y()))
text->markChangeInDraw(bv, row, prev); text->markChangeInDraw(row, prev);
internal = internal && (st != LyXText::CHANGED_IN_DRAW); internal = internal && (st != LyXText::CHANGED_IN_DRAW);
while (internal && text->status() == LyXText::CHANGED_IN_DRAW) { while (internal && text->status() == LyXText::CHANGED_IN_DRAW) {
text->fullRebreak(bv); text->fullRebreak();
text->setCursor(bv, text->cursor.par(), text->cursor.pos()); text->setCursor(text->cursor.par(),
text->postPaint(*bv, 0); text->cursor.pos());
text->postPaint(0);
Row * prev = row->previous(); Row * prev = row->previous();
RowPainter rp(*bv, *text, *row); RowPainter rp(*bv, *text, *row);
if (rp.paint(y + yo, xo, y + text->top_y())) if (rp.paint(y + yo, xo, y + text->top_y()))
text->markChangeInDraw(bv, row, prev); text->markChangeInDraw(row, prev);
} }
y += row->height(); y += row->height();
row = row->next(); row = row->next();
} }
// maybe we have to clear the screen at the bottom // maybe we have to clear the screen at the bottom
if ((y < y2) && text->isTopLevel()) { if ((y < y2) && !text->isInInset()) {
workarea().getPainter().fillRectangle(0, y, workarea().getPainter().fillRectangle(0, y,
workarea().workWidth(), y2 - y, workarea().workWidth(), y2 - y,
LColor::bottomarea); LColor::bottomarea);
@ -469,6 +470,6 @@ void LyXScreen::drawOneRow(LyXText * text, BufferView * bv, Row * row,
Row * prev = row->previous(); Row * prev = row->previous();
RowPainter rp(*bv, *text, *row); RowPainter rp(*bv, *text, *row);
if (rp.paint(y, xo, y + text->top_y())) if (rp.paint(y, xo, y + text->top_y()))
text->markChangeInDraw(bv, row, prev); text->markChangeInDraw(row, prev);
} }
} }

6
src/insets/ChangeLog
View File

@ -1,6 +1,10 @@
2003-03-17 Lars Gullik Bjønnes <larsbj@gullik.net>
* adjust for BufferView* arg removal from lyxtext.
2003-03-17 John Levon <levon@movementarian.org> 2003-03-17 John Levon <levon@movementarian.org>
* most files: remove the "cleared" parameter * most files: remove the "cleared" parameter
to draw in favour of always clearing. Associated to draw in favour of always clearing. Associated
code removal. code removal.

2
src/insets/inset.h
View File

@ -323,7 +323,7 @@ public:
/// mark the inset contents as erased (for change tracking) /// mark the inset contents as erased (for change tracking)
virtual void markErased() {} virtual void markErased() {}
/** Adds a LaTeX snippet to the Preview Loader for transformation /** Adds a LaTeX snippet to the Preview Loader for transformation
* into a bitmap image. Does not start the laoding process. * into a bitmap image. Does not start the laoding process.
* *

4
src/insets/insetert.C
View File

@ -355,7 +355,7 @@ int InsetERT::latex(Buffer const *, ostream & os, bool /*fragile*/,
// ignore all struck out text // ignore all struck out text
if (isDeletedText(*par, i)) if (isDeletedText(*par, i))
continue; continue;
if (par->isNewline(i)) { if (par->isNewline(i)) {
os << '\n'; os << '\n';
++lines; ++lines;
@ -449,7 +449,7 @@ Inset::RESULT InsetERT::localDispatch(FuncRequest const & cmd)
result = DISPATCHED; result = DISPATCHED;
} }
break; break;
case LFUN_MOUSE_PRESS: case LFUN_MOUSE_PRESS:
lfunMousePress(cmd); lfunMousePress(cmd);
result = DISPATCHED; result = DISPATCHED;

2
src/insets/insettabular.C
View File

@ -1505,7 +1505,7 @@ void InsetTabular::resetPos(BufferView * bv) const
} else if (the_locking_inset && } else if (the_locking_inset &&
(tabular->GetWidthOfColumn(actcell) > bv->workWidth()-20)) (tabular->GetWidthOfColumn(actcell) > bv->workWidth()-20))
{ {
int xx = cursor_.x() - offset + bv->text->getRealCursorX(bv); int xx = cursor_.x() - offset + bv->text->getRealCursorX();
if (xx > (bv->workWidth()-20)) { if (xx > (bv->workWidth()-20)) {
scroll(bv, -(xx - bv->workWidth() + 60)); scroll(bv, -(xx - bv->workWidth() + 60));
updateLocal(bv, FULL, false); updateLocal(bv, FULL, false);

142
src/insets/insettext.C
View File

@ -106,7 +106,7 @@ void InsetText::saveLyXTextState(LyXText * t) const
} }
void InsetText::restoreLyXTextState(BufferView * bv, LyXText * t) const void InsetText::restoreLyXTextState(LyXText * t) const
{ {
if (!sstate.lpar) if (!sstate.lpar)
return; return;
@ -115,15 +115,15 @@ void InsetText::restoreLyXTextState(BufferView * bv, LyXText * t) const
/* at this point just to avoid the DEPM when setting the cursor */ /* at this point just to avoid the DEPM when setting the cursor */
t->selection.mark(sstate.mark_set); t->selection.mark(sstate.mark_set);
if (sstate.selection) { if (sstate.selection) {
t->setCursor(bv, sstate.selstartpar, sstate.selstartpos, t->setCursor(sstate.selstartpar, sstate.selstartpos,
true, sstate.selstartboundary); true, sstate.selstartboundary);
t->selection.cursor = t->cursor; t->selection.cursor = t->cursor;
t->setCursor(bv, sstate.selendpar, sstate.selendpos, t->setCursor(sstate.selendpar, sstate.selendpos,
true, sstate.selendboundary); true, sstate.selendboundary);
t->setSelection(bv); t->setSelection();
t->setCursor(bv, sstate.lpar, sstate.pos); t->setCursor(sstate.lpar, sstate.pos);
} else { } else {
t->setCursor(bv, sstate.lpar, sstate.pos, true, sstate.boundary); t->setCursor(sstate.lpar, sstate.pos, true, sstate.boundary);
t->selection.cursor = t->cursor; t->selection.cursor = t->cursor;
t->selection.set(false); t->selection.set(false);
} }
@ -434,17 +434,17 @@ void InsetText::draw(BufferView * bv, LyXFont const & f,
Row * prev = row->previous(); Row * prev = row->previous();
RowPainter rp(*bv, *lt, *row); RowPainter rp(*bv, *lt, *row);
if (rp.paint(y + y_offset + first, int(x), y + lt->top_y())) if (rp.paint(y + y_offset + first, int(x), y + lt->top_y()))
lt->markChangeInDraw(bv, row, prev); lt->markChangeInDraw(row, prev);
if (bv->text->status() == LyXText::CHANGED_IN_DRAW) { if (bv->text->status() == LyXText::CHANGED_IN_DRAW) {
lt->need_break_row = row; lt->need_break_row = row;
lt->fullRebreak(bv); lt->fullRebreak();
lt->setCursor(bv, lt->cursor.par(), lt->setCursor(lt->cursor.par(),
lt->cursor.pos()); lt->cursor.pos());
if (lt->selection.set()) { if (lt->selection.set()) {
lt->setCursor(bv, lt->selection.start, lt->setCursor(lt->selection.start,
lt->selection.start.par(), lt->selection.start.par(),
lt->selection.start.pos()); lt->selection.start.pos());
lt->setCursor(bv, lt->selection.end, lt->setCursor(lt->selection.end,
lt->selection.end.par(), lt->selection.end.par(),
lt->selection.end.pos()); lt->selection.end.pos());
} }
@ -522,7 +522,7 @@ void InsetText::update(BufferView * bv, LyXFont const & font, bool reinit)
if ((need_update & CURSOR_PAR) && (lt->status() == LyXText::UNCHANGED) && if ((need_update & CURSOR_PAR) && (lt->status() == LyXText::UNCHANGED) &&
the_locking_inset) the_locking_inset)
{ {
lt->updateInset(bv, the_locking_inset); lt->updateInset(the_locking_inset);
} }
if (lt->status() == LyXText::NEED_MORE_REFRESH) if (lt->status() == LyXText::NEED_MORE_REFRESH)
need_update |= FULL; need_update |= FULL;
@ -567,7 +567,7 @@ void InsetText::updateLocal(BufferView * bv, int what, bool mark_dirty)
lt = getLyXText(bv); lt = getLyXText(bv);
clear = true; clear = true;
} }
lt->fullRebreak(bv); lt->fullRebreak();
setUpdateStatus(bv, what); setUpdateStatus(bv, what);
bool flag = mark_dirty || bool flag = mark_dirty ||
(((need_update != CURSOR) && (need_update != NONE)) || (((need_update != CURSOR) && (need_update != NONE)) ||
@ -631,7 +631,7 @@ void InsetText::edit(BufferView * bv, int x, int y, mouse_button::state button)
// cycle hopefully (Jug 20020509) // cycle hopefully (Jug 20020509)
// FIXME: GUII I've changed this to none: probably WRONG // FIXME: GUII I've changed this to none: probably WRONG
if (!checkAndActivateInset(bv, x, tmp_y, mouse_button::none)) { if (!checkAndActivateInset(bv, x, tmp_y, mouse_button::none)) {
lt->setCursorFromCoordinates(bv, x - drawTextXOffset, lt->setCursorFromCoordinates(x - drawTextXOffset,
y + insetAscent); y + insetAscent);
lt->cursor.x_fix(lt->cursor.x()); lt->cursor.x_fix(lt->cursor.x());
} }
@ -680,14 +680,14 @@ void InsetText::edit(BufferView * bv, bool front)
clear = true; clear = true;
} }
if (front) if (front)
lt->setCursor(bv, &*(paragraphs.begin()), 0); lt->setCursor(&*(paragraphs.begin()), 0);
else { else {
ParagraphList::iterator it = paragraphs.begin(); ParagraphList::iterator it = paragraphs.begin();
ParagraphList::iterator end = paragraphs.end(); ParagraphList::iterator end = paragraphs.end();
while (boost::next(it) != end) while (boost::next(it) != end)
++it; ++it;
// int const pos = (p->size() ? p->size()-1 : p->size()); // int const pos = (p->size() ? p->size()-1 : p->size());
lt->setCursor(bv, &*it, it->size()); lt->setCursor(&*it, it->size());
} }
lt->clearSelection(); lt->clearSelection();
finishUndo(); finishUndo();
@ -736,9 +736,9 @@ void InsetText::insetUnlock(BufferView * bv)
bv->owner()->setLayout(bv->text->cursor.par()->layout()->name()); bv->owner()->setLayout(bv->text->cursor.par()->layout()->name());
// hack for deleteEmptyParMech // hack for deleteEmptyParMech
if (!paragraphs.begin()->empty()) { if (!paragraphs.begin()->empty()) {
lt->setCursor(bv, &*(paragraphs.begin()), 0); lt->setCursor(&*(paragraphs.begin()), 0);
} else if (paragraphs.begin()->next()) { } else if (paragraphs.begin()->next()) {
lt->setCursor(bv, paragraphs.begin()->next(), 0); lt->setCursor(paragraphs.begin()->next(), 0);
} }
if (clear) if (clear)
lt = 0; lt = 0;
@ -764,7 +764,7 @@ void InsetText::lockInset(BufferView * bv)
lt = getLyXText(bv); lt = getLyXText(bv);
clear = true; clear = true;
} }
lt->setCursor(bv, &*(paragraphs.begin()), 0); lt->setCursor(&*(paragraphs.begin()), 0);
lt->clearSelection(); lt->clearSelection();
finishUndo(); finishUndo();
// If the inset is empty set the language of the current font to the // If the inset is empty set the language of the current font to the
@ -812,12 +812,12 @@ bool InsetText::lockInsetInInset(BufferView * bv, UpdatableInset * inset)
p->insetlist.end(); p->insetlist.end();
for (; it != end; ++it) { for (; it != end; ++it) {
if (it.getInset() == inset) { if (it.getInset() == inset) {
getLyXText(bv)->setCursorIntern(bv, p, it.getPos()); getLyXText(bv)->setCursorIntern(p, it.getPos());
lockInset(bv, inset); lockInset(bv, inset);
return true; return true;
} }
if (it.getInset()->getInsetFromID(id)) { if (it.getInset()->getInsetFromID(id)) {
getLyXText(bv)->setCursorIntern(bv, p, it.getPos()); getLyXText(bv)->setCursorIntern(p, it.getPos());
it.getInset()->edit(bv); it.getInset()->edit(bv);
return the_locking_inset->lockInsetInInset(bv, inset); return the_locking_inset->lockInsetInInset(bv, inset);
} }
@ -854,7 +854,7 @@ bool InsetText::unlockInsetInInset(BufferView * bv, UpdatableInset * inset,
return false; return false;
if (the_locking_inset == inset) { if (the_locking_inset == inset) {
the_locking_inset->insetUnlock(bv); the_locking_inset->insetUnlock(bv);
getLyXText(bv)->updateInset(bv, inset); getLyXText(bv)->updateInset(inset);
the_locking_inset = 0; the_locking_inset = 0;
if (lr) if (lr)
moveRightIntern(bv, true, false); moveRightIntern(bv, true, false);
@ -896,14 +896,14 @@ bool InsetText::updateInsetInInset(BufferView * bv, Inset * inset)
ustat = FULL; ustat = FULL;
} }
if (found) if (found)
lt->updateInset(bv, tl_inset); lt->updateInset(tl_inset);
if (clear) if (clear)
lt = 0; lt = 0;
if (found) if (found)
setUpdateStatus(bv, ustat); setUpdateStatus(bv, ustat);
return found; return found;
} }
bool found = lt->updateInset(bv, inset); bool found = lt->updateInset(inset);
if (clear) if (clear)
lt = 0; lt = 0;
if (found) { if (found) {
@ -936,7 +936,7 @@ void InsetText::lfunMousePress(FuncRequest const & cmd)
int tmp_x = cmd.x - drawTextXOffset; int tmp_x = cmd.x - drawTextXOffset;
int tmp_y = cmd.y + insetAscent - getLyXText(bv)->top_y(); int tmp_y = cmd.y + insetAscent - getLyXText(bv)->top_y();
Inset * inset = getLyXText(bv)->checkInsetHit(bv, tmp_x, tmp_y); Inset * inset = getLyXText(bv)->checkInsetHit(tmp_x, tmp_y);
hideInsetCursor(bv); hideInsetCursor(bv);
if (the_locking_inset) { if (the_locking_inset) {
@ -992,7 +992,7 @@ void InsetText::lfunMousePress(FuncRequest const & cmd)
} }
int old_top_y = lt->top_y(); int old_top_y = lt->top_y();
lt->setCursorFromCoordinates(bv, cmd.x - drawTextXOffset, lt->setCursorFromCoordinates(cmd.x - drawTextXOffset,
cmd.y + insetAscent); cmd.y + insetAscent);
// set the selection cursor! // set the selection cursor!
lt->selection.cursor = lt->cursor; lt->selection.cursor = lt->cursor;
@ -1045,7 +1045,7 @@ bool InsetText::lfunMouseRelease(FuncRequest const & cmd)
int tmp_x = cmd.x - drawTextXOffset; int tmp_x = cmd.x - drawTextXOffset;
int tmp_y = cmd.y + insetAscent - getLyXText(bv)->top_y(); int tmp_y = cmd.y + insetAscent - getLyXText(bv)->top_y();
Inset * inset = getLyXText(bv)->checkInsetHit(bv, tmp_x, tmp_y); Inset * inset = getLyXText(bv)->checkInsetHit(tmp_x, tmp_y);
bool ret = false; bool ret = false;
if (inset) { if (inset) {
if (isHighlyEditableInset(inset)) if (isHighlyEditableInset(inset))
@ -1089,14 +1089,14 @@ void InsetText::lfunMouseMotion(FuncRequest const & cmd)
hideInsetCursor(bv); hideInsetCursor(bv);
LyXCursor cur = lt->cursor; LyXCursor cur = lt->cursor;
lt->setCursorFromCoordinates lt->setCursorFromCoordinates
(bv, cmd.x - drawTextXOffset, cmd.y + insetAscent); (cmd.x - drawTextXOffset, cmd.y + insetAscent);
lt->cursor.x_fix(lt->cursor.x()); lt->cursor.x_fix(lt->cursor.x());
if (cur == lt->cursor) { if (cur == lt->cursor) {
if (clear) if (clear)
lt = 0; lt = 0;
return; return;
} }
lt->setSelection(bv); lt->setSelection();
bool flag = (lt->toggle_cursor.par() != lt->toggle_end_cursor.par() || bool flag = (lt->toggle_cursor.par() != lt->toggle_end_cursor.par() ||
lt->toggle_cursor.pos() != lt->toggle_end_cursor.pos()); lt->toggle_cursor.pos() != lt->toggle_end_cursor.pos());
if (clear) if (clear)
@ -1198,7 +1198,7 @@ Inset::RESULT InsetText::localDispatch(FuncRequest const & ev)
bv->switchKeyMap(); bv->switchKeyMap();
if (lyxrc.auto_region_delete) { if (lyxrc.auto_region_delete) {
if (lt->selection.set()) { if (lt->selection.set()) {
lt->cutSelection(bv, false, false); lt->cutSelection(false, false);
} }
} }
lt->clearSelection(); lt->clearSelection();
@ -1216,7 +1216,7 @@ Inset::RESULT InsetText::localDispatch(FuncRequest const & ev)
case LFUN_RIGHTSEL: case LFUN_RIGHTSEL:
finishUndo(); finishUndo();
moveRight(bv, false, true); moveRight(bv, false, true);
lt->setSelection(bv); lt->setSelection();
updwhat = SELECTION; updwhat = SELECTION;
break; break;
case LFUN_RIGHT: case LFUN_RIGHT:
@ -1227,7 +1227,7 @@ Inset::RESULT InsetText::localDispatch(FuncRequest const & ev)
case LFUN_LEFTSEL: case LFUN_LEFTSEL:
finishUndo(); finishUndo();
moveLeft(bv, false, true); moveLeft(bv, false, true);
lt->setSelection(bv); lt->setSelection();
updwhat = SELECTION; updwhat = SELECTION;
break; break;
case LFUN_LEFT: case LFUN_LEFT:
@ -1238,7 +1238,7 @@ Inset::RESULT InsetText::localDispatch(FuncRequest const & ev)
case LFUN_DOWNSEL: case LFUN_DOWNSEL:
finishUndo(); finishUndo();
moveDown(bv); moveDown(bv);
lt->setSelection(bv); lt->setSelection();
updwhat = SELECTION; updwhat = SELECTION;
break; break;
case LFUN_DOWN: case LFUN_DOWN:
@ -1249,7 +1249,7 @@ Inset::RESULT InsetText::localDispatch(FuncRequest const & ev)
case LFUN_UPSEL: case LFUN_UPSEL:
finishUndo(); finishUndo();
moveUp(bv); moveUp(bv);
lt->setSelection(bv); lt->setSelection();
updwhat = SELECTION; updwhat = SELECTION;
break; break;
case LFUN_UP: case LFUN_UP:
@ -1259,18 +1259,18 @@ Inset::RESULT InsetText::localDispatch(FuncRequest const & ev)
break; break;
case LFUN_HOME: case LFUN_HOME:
finishUndo(); finishUndo();
lt->cursorHome(bv); lt->cursorHome();
updwhat = CURSOR; updwhat = CURSOR;
break; break;
case LFUN_END: case LFUN_END:
lt->cursorEnd(bv); lt->cursorEnd();
updwhat = CURSOR; updwhat = CURSOR;
break; break;
case LFUN_PRIOR: case LFUN_PRIOR:
if (!crow(bv)->previous()) if (!crow(bv)->previous())
result = FINISHED_UP; result = FINISHED_UP;
else { else {
lt->cursorPrevious(bv); lt->cursorPrevious();
result = DISPATCHED_NOUPDATE; result = DISPATCHED_NOUPDATE;
} }
updwhat = CURSOR; updwhat = CURSOR;
@ -1279,16 +1279,16 @@ Inset::RESULT InsetText::localDispatch(FuncRequest const & ev)
if (!crow(bv)->next()) if (!crow(bv)->next())
result = FINISHED_DOWN; result = FINISHED_DOWN;
else { else {
lt->cursorNext(bv); lt->cursorNext();
result = DISPATCHED_NOUPDATE; result = DISPATCHED_NOUPDATE;
} }
updwhat = CURSOR; updwhat = CURSOR;
break; break;
case LFUN_BACKSPACE: { case LFUN_BACKSPACE: {
if (lt->selection.set()) if (lt->selection.set())
lt->cutSelection(bv, true, false); lt->cutSelection(true, false);
else else
lt->backspace(bv); lt->backspace();
updwhat = CURSOR_PAR; updwhat = CURSOR_PAR;
updflag = true; updflag = true;
} }
@ -1296,9 +1296,9 @@ Inset::RESULT InsetText::localDispatch(FuncRequest const & ev)
case LFUN_DELETE: { case LFUN_DELETE: {
if (lt->selection.set()) { if (lt->selection.set()) {
lt->cutSelection(bv, true, false); lt->cutSelection(true, false);
} else { } else {
lt->Delete(bv); lt->Delete();
} }
updwhat = CURSOR_PAR; updwhat = CURSOR_PAR;
updflag = true; updflag = true;
@ -1314,7 +1314,7 @@ Inset::RESULT InsetText::localDispatch(FuncRequest const & ev)
case LFUN_COPY: case LFUN_COPY:
finishUndo(); finishUndo();
lt->copySelection(bv); lt->copySelection();
updwhat = CURSOR_PAR; updwhat = CURSOR_PAR;
break; break;
case LFUN_PASTESELECTION: case LFUN_PASTESELECTION:
@ -1324,9 +1324,9 @@ Inset::RESULT InsetText::localDispatch(FuncRequest const & ev)
if (clip.empty()) if (clip.empty())
break; break;
if (ev.argument == "paragraph") { if (ev.argument == "paragraph") {
lt->insertStringAsParagraphs(bv, clip); lt->insertStringAsParagraphs(clip);
} else { } else {
lt->insertStringAsLines(bv, clip); lt->insertStringAsLines(clip);
} }
// bug 393 // bug 393
lt->clearSelection(); lt->clearSelection();
@ -1350,7 +1350,7 @@ Inset::RESULT InsetText::localDispatch(FuncRequest const & ev)
setUndo(bv, Undo::INSERT, setUndo(bv, Undo::INSERT,
lt->cursor.par(), lt->cursor.par()->next()); lt->cursor.par(), lt->cursor.par()->next());
#endif #endif
lt->pasteSelection(bv); lt->pasteSelection();
// bug 393 // bug 393
lt->clearSelection(); lt->clearSelection();
updwhat = CURSOR_PAR; updwhat = CURSOR_PAR;
@ -1363,7 +1363,7 @@ Inset::RESULT InsetText::localDispatch(FuncRequest const & ev)
result = DISPATCHED; result = DISPATCHED;
break; break;
} }
lt->breakParagraph(bv, paragraphs, 0); lt->breakParagraph(paragraphs, 0);
updwhat = CURSOR | FULL; updwhat = CURSOR | FULL;
updflag = true; updflag = true;
break; break;
@ -1372,7 +1372,7 @@ Inset::RESULT InsetText::localDispatch(FuncRequest const & ev)
result = DISPATCHED; result = DISPATCHED;
break; break;
} }
lt->breakParagraph(bv, paragraphs, 1); lt->breakParagraph(paragraphs, 1);
updwhat = CURSOR | FULL; updwhat = CURSOR | FULL;
updflag = true; updflag = true;
break; break;
@ -1387,7 +1387,7 @@ Inset::RESULT InsetText::localDispatch(FuncRequest const & ev)
setUndo(bv, Undo::INSERT, setUndo(bv, Undo::INSERT,
lt->cursor.par(), lt->cursor.par()->next()); lt->cursor.par(), lt->cursor.par()->next());
#endif #endif
lt->insertInset(bv, new InsetNewline); lt->insertInset(new InsetNewline);
updwhat = CURSOR | CURSOR_PAR; updwhat = CURSOR | CURSOR_PAR;
updflag = true; updflag = true;
} }
@ -1422,7 +1422,7 @@ Inset::RESULT InsetText::localDispatch(FuncRequest const & ev)
if (cur_layout != layout) { if (cur_layout != layout) {
cur_layout = layout; cur_layout = layout;
lt->setLayout(bv, layout); lt->setLayout(layout);
bv->owner()->setLayout(cpar(bv)->layout()->name()); bv->owner()->setLayout(cpar(bv)->layout()->name());
updwhat = CURSOR_PAR; updwhat = CURSOR_PAR;
updflag = true; updflag = true;
@ -1859,7 +1859,7 @@ bool InsetText::insertInset(BufferView * bv, Inset * inset)
} }
inset->setOwner(this); inset->setOwner(this);
hideInsetCursor(bv); hideInsetCursor(bv);
getLyXText(bv)->insertInset(bv, inset); getLyXText(bv)->insertInset(inset);
bv->fitCursor(); bv->fitCursor();
updateLocal(bv, CURSOR_PAR|CURSOR, true); updateLocal(bv, CURSOR_PAR|CURSOR, true);
return true; return true;
@ -1936,7 +1936,7 @@ void InsetText::setFont(BufferView * bv, LyXFont const & font, bool toggleall,
return; return;
} }
if ((!paragraphs.begin()->next() && paragraphs.begin()->empty()) || cpar(bv)->empty()) { if ((!paragraphs.begin()->next() && paragraphs.begin()->empty()) || cpar(bv)->empty()) {
getLyXText(bv)->setFont(bv, font, toggleall); getLyXText(bv)->setFont(font, toggleall);
return; return;
} }
bool clear = false; bool clear = false;
@ -1949,7 +1949,7 @@ void InsetText::setFont(BufferView * bv, LyXFont const & font, bool toggleall,
} }
if (selectall) if (selectall)
selectAll(bv); selectAll(bv);
lt->toggleFree(bv, font, toggleall); lt->toggleFree(font, toggleall);
if (selectall) if (selectall)
lt->clearSelection(); lt->clearSelection();
bv->fitCursor(); bv->fitCursor();
@ -1986,7 +1986,7 @@ bool InsetText::checkAndActivateInset(BufferView * bv, int x, int y,
x -= drawTextXOffset; x -= drawTextXOffset;
int dummyx = x; int dummyx = x;
int dummyy = y + insetAscent; int dummyy = y + insetAscent;
Inset * inset = getLyXText(bv)->checkInsetHit(bv, dummyx, dummyy); Inset * inset = getLyXText(bv)->checkInsetHit(dummyx, dummyy);
// we only do the edit() call if the inset was hit by the mouse // we only do the edit() call if the inset was hit by the mouse
// or if it is a highly editable inset. So we should call this // or if it is a highly editable inset. So we should call this
// function from our own edit with button < 0. // function from our own edit with button < 0.
@ -2215,7 +2215,7 @@ LyXText * InsetText::getLyXText(BufferView const * lbv,
// when we have to reinit the existing LyXText! // when we have to reinit the existing LyXText!
// //
it->second.text->init(bv); it->second.text->init(bv);
restoreLyXTextState(bv, it->second.text.get()); restoreLyXTextState(it->second.text.get());
it->second.remove = false; it->second.remove = false;
} }
cached_text = it->second.text; cached_text = it->second.text;
@ -2227,9 +2227,9 @@ LyXText * InsetText::getLyXText(BufferView const * lbv,
/// ///
// we are here only if we don't have a BufferView * in the cache!!! // we are here only if we don't have a BufferView * in the cache!!!
/// ///
cached_text.reset(new LyXText(const_cast<InsetText *>(this))); cached_text.reset(new LyXText(bv, const_cast<InsetText *>(this)));
cached_text->init(bv); cached_text->init(bv);
restoreLyXTextState(bv, cached_text.get()); restoreLyXTextState(cached_text.get());
cache.insert(make_pair(bv, cached_text)); cache.insert(make_pair(bv, cached_text));
@ -2276,7 +2276,7 @@ void InsetText::resizeLyXText(BufferView * bv, bool force) const
LyXText * t = getLyXText(bv); LyXText * t = getLyXText(bv);
saveLyXTextState(t); saveLyXTextState(t);
t->init(bv, true); t->init(bv, true);
restoreLyXTextState(bv, t); restoreLyXTextState(t);
return; return;
} }
// one endless line, resize normally not necessary // one endless line, resize normally not necessary
@ -2296,7 +2296,7 @@ void InsetText::resizeLyXText(BufferView * bv, bool force) const
boost::bind(&Paragraph::resizeInsetsLyXText, _1, bv)); boost::bind(&Paragraph::resizeInsetsLyXText, _1, bv));
t->init(bv, true); t->init(bv, true);
restoreLyXTextState(bv, t); restoreLyXTextState(t);
if (the_locking_inset) { if (the_locking_inset) {
inset_x = cix(bv) - top_x + drawTextXOffset; inset_x = cix(bv) - top_x + drawTextXOffset;
inset_y = ciy(bv) + drawTextYOffset; inset_y = ciy(bv) + drawTextYOffset;
@ -2336,7 +2336,7 @@ void InsetText::reinitLyXText() const
boost::bind(&Paragraph::resizeInsetsLyXText, _1, bv)); boost::bind(&Paragraph::resizeInsetsLyXText, _1, bv));
t->init(bv, true); t->init(bv, true);
restoreLyXTextState(bv, t); restoreLyXTextState(t);
if (the_locking_inset) { if (the_locking_inset) {
inset_x = cix(bv) - top_x + drawTextXOffset; inset_x = cix(bv) - top_x + drawTextXOffset;
inset_y = ciy(bv) + drawTextYOffset; inset_y = ciy(bv) + drawTextYOffset;
@ -2393,10 +2393,10 @@ int InsetText::scroll(bool recursive) const
void InsetText::selectAll(BufferView * bv) void InsetText::selectAll(BufferView * bv)
{ {
getLyXText(bv)->cursorTop(bv); getLyXText(bv)->cursorTop();
getLyXText(bv)->selection.cursor = getLyXText(bv)->cursor; getLyXText(bv)->selection.cursor = getLyXText(bv)->cursor;
getLyXText(bv)->cursorBottom(bv); getLyXText(bv)->cursorBottom();
getLyXText(bv)->setSelection(bv); getLyXText(bv)->setSelection();
} }
@ -2519,7 +2519,7 @@ InsetText::selectNextWordToSpellcheck(BufferView * bv,
// we have to go on checking so move cursor to the next char // we have to go on checking so move cursor to the next char
lt->cursor.pos(lt->cursor.pos() + 1); lt->cursor.pos(lt->cursor.pos() + 1);
} }
word = lt->selectNextWordToSpellcheck(bv, value); word = lt->selectNextWordToSpellcheck(value);
if (word.word().empty()) if (word.word().empty())
bv->unlockInset(const_cast<InsetText *>(this)); bv->unlockInset(const_cast<InsetText *>(this));
else else
@ -2536,7 +2536,7 @@ void InsetText::selectSelectedWord(BufferView * bv)
the_locking_inset->selectSelectedWord(bv); the_locking_inset->selectSelectedWord(bv);
return; return;
} }
getLyXText(bv)->selectSelectedWord(bv); getLyXText(bv)->selectSelectedWord();
updateLocal(bv, SELECTION, false); updateLocal(bv, SELECTION, false);
} }
@ -2582,7 +2582,7 @@ bool InsetText::nextChange(BufferView * bv, lyx::pos_type & length)
if (the_locking_inset) { if (the_locking_inset) {
if (the_locking_inset->nextChange(bv, length)) if (the_locking_inset->nextChange(bv, length))
return true; return true;
lt->cursorRight(bv, true); lt->cursorRight(true);
} }
lyxfind::SearchResult result = lyxfind::SearchResult result =
lyxfind::findNextChange(bv, lt, length); lyxfind::findNextChange(bv, lt, length);
@ -2593,7 +2593,7 @@ bool InsetText::nextChange(BufferView * bv, lyx::pos_type & length)
if (bv->lockInset(this)) if (bv->lockInset(this))
locked = true; locked = true;
lt->cursor = cur; lt->cursor = cur;
lt->setSelectionRange(bv, length); lt->setSelectionRange(length);
updateLocal(bv, SELECTION, false); updateLocal(bv, SELECTION, false);
} }
if (clear) if (clear)
@ -2613,7 +2613,7 @@ bool InsetText::searchForward(BufferView * bv, string const & str,
if (the_locking_inset) { if (the_locking_inset) {
if (the_locking_inset->searchForward(bv, str, cs, mw)) if (the_locking_inset->searchForward(bv, str, cs, mw))
return true; return true;
lt->cursorRight(bv, true); lt->cursorRight(true);
} }
lyxfind::SearchResult result = lyxfind::SearchResult result =
lyxfind::LyXFind(bv, lt, str, true, cs, mw); lyxfind::LyXFind(bv, lt, str, true, cs, mw);
@ -2624,7 +2624,7 @@ bool InsetText::searchForward(BufferView * bv, string const & str,
if (bv->lockInset(this)) if (bv->lockInset(this))
locked = true; locked = true;
lt->cursor = cur; lt->cursor = cur;
lt->setSelectionRange(bv, str.length()); lt->setSelectionRange(str.length());
updateLocal(bv, SELECTION, false); updateLocal(bv, SELECTION, false);
} }
if (clear) if (clear)
@ -2648,7 +2648,7 @@ bool InsetText::searchBackward(BufferView * bv, string const & str,
Paragraph * p = &*(paragraphs.begin()); Paragraph * p = &*(paragraphs.begin());
while (p->next()) while (p->next())
p = p->next(); p = p->next();
lt->setCursor(bv, p, p->size()); lt->setCursor(p, p->size());
} }
lyxfind::SearchResult result = lyxfind::SearchResult result =
lyxfind::LyXFind(bv, lt, str, false, cs, mw); lyxfind::LyXFind(bv, lt, str, false, cs, mw);
@ -2659,7 +2659,7 @@ bool InsetText::searchBackward(BufferView * bv, string const & str,
if (bv->lockInset(this)) if (bv->lockInset(this))
locked = true; locked = true;
lt->cursor = cur; lt->cursor = cur;
lt->setSelectionRange(bv, str.length()); lt->setSelectionRange(str.length());
updateLocal(bv, SELECTION, false); updateLocal(bv, SELECTION, false);
} }
if (clear) if (clear)

2
src/insets/insettext.h
View File

@ -348,7 +348,7 @@ private:
/// ///
void saveLyXTextState(LyXText *) const; void saveLyXTextState(LyXText *) const;
/// ///
void restoreLyXTextState(BufferView *, LyXText *) const; void restoreLyXTextState(LyXText *) const;
/// ///
void reinitLyXText() const; void reinitLyXText() const;
/// ///

4
src/insets/updatableinset.C
View File

@ -167,7 +167,7 @@ int UpdatableInset::getMaxWidth(BufferView * bv, UpdatableInset const *) const
w = static_cast<UpdatableInset*> w = static_cast<UpdatableInset*>
(owner())->getMaxWidth(bv, this); (owner())->getMaxWidth(bv, this);
} else { } else {
w = bv->text->workWidth(*bv, const_cast<UpdatableInset *>(this)); w = bv->text->workWidth(const_cast<UpdatableInset *>(this));
} }
if (w < 0) { if (w < 0) {
return -1; return -1;
@ -216,7 +216,7 @@ bool UpdatableInset::nextChange(BufferView * bv, lyx::pos_type &)
return false; return false;
} }
bool UpdatableInset::searchForward(BufferView * bv, string const &, bool UpdatableInset::searchForward(BufferView * bv, string const &,
bool, bool) bool, bool)
{ {

4
src/lyx_cb.C
View File

@ -404,9 +404,9 @@ void InsertAsciiFile(BufferView * bv, string const & f, bool asParagraph)
if (flag) if (flag)
bv->beforeChange(bv->text); bv->beforeChange(bv->text);
if (!asParagraph) if (!asParagraph)
bv->getLyXText()->insertStringAsLines(bv, tmpstr); bv->getLyXText()->insertStringAsLines(tmpstr);
else else
bv->getLyXText()->insertStringAsParagraphs(bv, tmpstr); bv->getLyXText()->insertStringAsParagraphs(tmpstr);
if (flag) if (flag)
bv->update(bv->text, bv->update(bv->text,
BufferView::SELECT|BufferView::FITCUR|BufferView::CHANGE); BufferView::SELECT|BufferView::FITCUR|BufferView::CHANGE);

26
src/lyxfind.C
View File

@ -57,7 +57,7 @@ int LyXReplace(BufferView * bv,
text->clearSelection(); text->clearSelection();
bv->unlockInset(bv->theLockingInset()); bv->unlockInset(bv->theLockingInset());
text = bv->text; text = bv->text;
text->cursorTop(bv); text->cursorTop();
// override search direction because we search top to bottom // override search direction because we search top to bottom
fw = true; fw = true;
} }
@ -94,8 +94,8 @@ int LyXReplace(BufferView * bv,
bv->hideCursor(); bv->hideCursor();
bv->update(text, BufferView::SELECT|BufferView::FITCUR); bv->update(text, BufferView::SELECT|BufferView::FITCUR);
bv->toggleSelection(false); bv->toggleSelection(false);
text->replaceSelectionWithString(bv, replacestr); text->replaceSelectionWithString(replacestr);
text->setSelectionRange(bv, replacestr.length()); text->setSelectionRange(replacestr.length());
bv->update(text, BufferView::SELECT|BufferView::FITCUR|BufferView::CHANGE); bv->update(text, BufferView::SELECT|BufferView::FITCUR|BufferView::CHANGE);
++replace_count; ++replace_count;
} }
@ -128,7 +128,7 @@ bool LyXFind(BufferView * bv,
// We now are in the main text but if we did a forward // We now are in the main text but if we did a forward
// search we have to put the cursor behind the inset. // search we have to put the cursor behind the inset.
if (forward) { if (forward) {
bv->text->cursorRight(bv, true); bv->text->cursorRight(true);
} }
} }
// If we arrive here we are in the main text again so we // If we arrive here we are in the main text again so we
@ -154,7 +154,7 @@ bool LyXFind(BufferView * bv,
if (result == SR_FOUND) { if (result == SR_FOUND) {
bv->unlockInset(bv->theLockingInset()); bv->unlockInset(bv->theLockingInset());
bv->update(text, BufferView::SELECT|BufferView::FITCUR); bv->update(text, BufferView::SELECT|BufferView::FITCUR);
text->setSelectionRange(bv, searchstr.length()); text->setSelectionRange(searchstr.length());
bv->toggleSelection(false); bv->toggleSelection(false);
bv->update(text, BufferView::SELECT|BufferView::FITCUR); bv->update(text, BufferView::SELECT|BufferView::FITCUR);
} else if (result == SR_NOT_FOUND) { } else if (result == SR_NOT_FOUND) {
@ -251,12 +251,12 @@ SearchResult SearchForward(BufferView * bv, LyXText * text, string const & str,
} }
if (par) { if (par) {
text->setCursor(bv, par, pos); text->setCursor(par, pos);
return SR_FOUND; return SR_FOUND;
} else { } else {
// make sure we end up at the end of the text, // make sure we end up at the end of the text,
// not the start point of the last search // not the start point of the last search
text->setCursor(bv, prev_par, prev_par->size()); text->setCursor(prev_par, prev_par->size());
return SR_NOT_FOUND; return SR_NOT_FOUND;
} }
} }
@ -301,11 +301,11 @@ SearchResult SearchBackward(BufferView * bv, LyXText * text,
} while (par && !IsStringInText(par, pos, str, cs, mw)); } while (par && !IsStringInText(par, pos, str, cs, mw));
if (par) { if (par) {
text->setCursor(bv, par, pos); text->setCursor(par, pos);
return SR_FOUND; return SR_FOUND;
} else { } else {
// go to the last part of the unsuccessful search // go to the last part of the unsuccessful search
text->setCursor(bv, prev_par, 0); text->setCursor(prev_par, 0);
return SR_NOT_FOUND; return SR_NOT_FOUND;
} }
} }
@ -340,7 +340,7 @@ SearchResult nextChange(BufferView * bv, LyXText * text, pos_type & length)
} }
if (par) { if (par) {
text->setCursor(bv, par, pos); text->setCursor(par, pos);
Change orig_change = par->lookupChangeFull(pos); Change orig_change = par->lookupChangeFull(pos);
pos_type end = pos; pos_type end = pos;
@ -359,7 +359,7 @@ SearchResult nextChange(BufferView * bv, LyXText * text, pos_type & length)
} else { } else {
// make sure we end up at the end of the text, // make sure we end up at the end of the text,
// not the start point of the last search // not the start point of the last search
text->setCursor(bv, prev_par, prev_par->size()); text->setCursor(prev_par, prev_par->size());
return SR_NOT_FOUND; return SR_NOT_FOUND;
} }
} }
@ -397,7 +397,7 @@ bool findNextChange(BufferView * bv)
// We now are in the main text but if we did a forward // We now are in the main text but if we did a forward
// search we have to put the cursor behind the inset. // search we have to put the cursor behind the inset.
bv->text->cursorRight(bv, true); bv->text->cursorRight(true);
} }
// If we arrive here we are in the main text again so we // If we arrive here we are in the main text again so we
// just start searching from the root LyXText at the position // just start searching from the root LyXText at the position
@ -422,7 +422,7 @@ bool findNextChange(BufferView * bv)
if (result == SR_FOUND) { if (result == SR_FOUND) {
bv->unlockInset(bv->theLockingInset()); bv->unlockInset(bv->theLockingInset());
bv->update(text, BufferView::SELECT|BufferView::FITCUR); bv->update(text, BufferView::SELECT|BufferView::FITCUR);
text->setSelectionRange(bv, length); text->setSelectionRange(length);
bv->toggleSelection(false); bv->toggleSelection(false);
bv->update(text, BufferView::SELECT|BufferView::FITCUR); bv->update(text, BufferView::SELECT|BufferView::FITCUR);
} else if (result == SR_NOT_FOUND) { } else if (result == SR_NOT_FOUND) {

32
src/lyxfunc.C
View File

@ -121,8 +121,8 @@ inline
void LyXFunc::moveCursorUpdate(bool flag, bool selecting) void LyXFunc::moveCursorUpdate(bool flag, bool selecting)
{ {
if (selecting || TEXT(flag)->selection.mark()) { if (selecting || TEXT(flag)->selection.mark()) {
TEXT(flag)->setSelection(view()); TEXT(flag)->setSelection();
if (TEXT(flag)->isTopLevel()) if (!TEXT(flag)->isInInset())
view()->toggleToggle(); view()->toggleToggle();
} }
view()->update(TEXT(flag), BufferView::SELECT|BufferView::FITCUR); view()->update(TEXT(flag), BufferView::SELECT|BufferView::FITCUR);
@ -825,7 +825,7 @@ void LyXFunc::dispatch(FuncRequest const & ev, bool verbose)
if (TEXT()->cursor.irow()->previous()) { if (TEXT()->cursor.irow()->previous()) {
#if 1 #if 1
TEXT()->setCursorFromCoordinates( TEXT()->setCursorFromCoordinates(
view(), TEXT()->cursor.ix() + inset_x, TEXT()->cursor.ix() + inset_x,
TEXT()->cursor.iy() - TEXT()->cursor.iy() -
TEXT()->cursor.irow()->baseline() - 1); TEXT()->cursor.irow()->baseline() - 1);
TEXT()->cursor.x_fix(TEXT()->cursor.x()); TEXT()->cursor.x_fix(TEXT()->cursor.x());
@ -842,7 +842,7 @@ void LyXFunc::dispatch(FuncRequest const & ev, bool verbose)
if (TEXT()->cursor.irow()->next()) { if (TEXT()->cursor.irow()->next()) {
#if 1 #if 1
TEXT()->setCursorFromCoordinates( TEXT()->setCursorFromCoordinates(
view(), TEXT()->cursor.ix() + inset_x, TEXT()->cursor.ix() + inset_x,
TEXT()->cursor.iy() - TEXT()->cursor.iy() -
TEXT()->cursor.irow()->baseline() + TEXT()->cursor.irow()->baseline() +
TEXT()->cursor.irow()->height() + 1); TEXT()->cursor.irow()->height() + 1);
@ -1105,12 +1105,12 @@ void LyXFunc::dispatch(FuncRequest const & ev, bool verbose)
break; break;
case LFUN_FREEFONT_APPLY: case LFUN_FREEFONT_APPLY:
apply_freefont(view()); apply_freefont(view());
break; break;
case LFUN_FREEFONT_UPDATE: case LFUN_FREEFONT_UPDATE:
update_and_apply_freefont(view(), argument); update_and_apply_freefont(view(), argument);
break; break;
case LFUN_RECONFIGURE: case LFUN_RECONFIGURE:
Reconfigure(view()); Reconfigure(view());
@ -1235,12 +1235,12 @@ void LyXFunc::dispatch(FuncRequest const & ev, bool verbose)
owner->getDialogs().showDocument(); owner->getDialogs().showDocument();
break; break;
case LFUN_LAYOUT_CHARACTER: { case LFUN_LAYOUT_CHARACTER: {
string data = freefont2string(); string data = freefont2string();
if (!data.empty()) if (!data.empty())
owner->getDialogs().show("character", data); owner->getDialogs().show("character", data);
break; break;
} }
case LFUN_LAYOUT_TABULAR: case LFUN_LAYOUT_TABULAR:
if (view()->theLockingInset()) { if (view()->theLockingInset()) {
@ -1336,7 +1336,7 @@ void LyXFunc::dispatch(FuncRequest const & ev, bool verbose)
par->inInset()->edit(view()); par->inInset()->edit(view());
} }
// Set the cursor // Set the cursor
view()->getLyXText()->setCursor(view(), par, 0); view()->getLyXText()->setCursor(par, 0);
view()->switchKeyMap(); view()->switchKeyMap();
owner->view_state_changed(); owner->view_state_changed();

210
src/lyxtext.h
View File

@ -69,7 +69,7 @@ public:
/// Constructor /// Constructor
LyXText(BufferView *); LyXText(BufferView *);
/// sets inset as owner /// sets inset as owner
LyXText(InsetText *); LyXText(BufferView *, InsetText *);
/// Destructor /// Destructor
~LyXText(); ~LyXText();
@ -88,7 +88,7 @@ private:
* declared mutable because removeRow is const * declared mutable because removeRow is const
*/ */
mutable Row * top_row_; mutable Row * top_row_;
/** the pixel offset with respect to this row of top_y /** the pixel offset with respect to this row of top_y
* declared mutable because removeRow is const * declared mutable because removeRow is const
*/ */
mutable int top_row_offset_; mutable int top_row_offset_;
@ -103,7 +103,7 @@ public:
UpdatableInset * the_locking_inset; UpdatableInset * the_locking_inset;
/// ///
int getRealCursorX(BufferView *) const; int getRealCursorX() const;
/// ///
LyXFont const getFont(Buffer const *, Paragraph * par, LyXFont const getFont(Buffer const *, Paragraph * par,
lyx::pos_type pos) const; lyx::pos_type pos) const;
@ -114,35 +114,34 @@ public:
/// ///
void setCharFont(Buffer const *, Paragraph * par, void setCharFont(Buffer const *, Paragraph * par,
lyx::pos_type pos, LyXFont const & font); lyx::pos_type pos, LyXFont const & font);
void setCharFont(BufferView *, Paragraph * par, void setCharFont(Paragraph * par,
lyx::pos_type pos, LyXFont const & font, bool toggleall); lyx::pos_type pos, LyXFont const & font, bool toggleall);
/// return true if the row changed /// return true if the row changed
void markChangeInDraw(BufferView * bv, Row * row, Row * next); void markChangeInDraw(Row * row, Row * next);
/// ///
void breakAgainOneRow(BufferView *, Row * row); void breakAgainOneRow(Row * row);
/// what you expect when pressing <enter> at cursor position /// what you expect when pressing <enter> at cursor position
void breakParagraph(BufferView *, void breakParagraph(ParagraphList & paragraphs, char keep_layout = 0);
ParagraphList & paragraphs, char keep_layout = 0);
/** set layout over selection and make a total rebreak of /** set layout over selection and make a total rebreak of
those paragraphs those paragraphs
*/ */
Paragraph * setLayout(BufferView *, LyXCursor & actual_cursor, Paragraph * setLayout(LyXCursor & actual_cursor,
LyXCursor & selection_start, LyXCursor & selection_start,
LyXCursor & selection_end, LyXCursor & selection_end,
string const & layout); string const & layout);
/// ///
void setLayout(BufferView *, string const & layout); void setLayout(string const & layout);
/** increment depth over selection and make a total rebreak of those /** increment depth over selection and make a total rebreak of those
paragraphs paragraphs
*/ */
void incDepth(BufferView *); void incDepth();
/** decrement depth over selection and make a total rebreak of those /** decrement depth over selection and make a total rebreak of those
paragraphs */ paragraphs */
void decDepth(BufferView *); void decDepth();
/// get the depth at current cursor position /// get the depth at current cursor position
int getDepth() const; int getDepth() const;
@ -151,39 +150,39 @@ public:
paragraphs. paragraphs.
toggleall defaults to false. toggleall defaults to false.
*/ */
void setFont(BufferView *, LyXFont const &, bool toggleall = false); void setFont(LyXFont const &, bool toggleall = false);
/** deletes and inserts again all paragaphs between the cursor /** deletes and inserts again all paragaphs between the cursor
and the specified par. The Cursor is needed to set the refreshing and the specified par. The Cursor is needed to set the refreshing
parameters. parameters.
This function is needed after SetLayout and SetFont etc. This function is needed after SetLayout and SetFont etc.
*/ */
void redoParagraphs(BufferView *, LyXCursor const & cursor, void redoParagraphs(LyXCursor const & cursor,
Paragraph const * end_par) const; Paragraph const * end_par) const;
/// ///
void redoParagraph(BufferView *) const; void redoParagraph() const;
/// ///
void toggleFree(BufferView *, LyXFont const &, bool toggleall = false); void toggleFree(LyXFont const &, bool toggleall = false);
/// ///
string getStringToIndex(BufferView *); string getStringToIndex();
/** recalculates the heights of all previous rows of the /** recalculates the heights of all previous rows of the
specified paragraph. needed, if the last characters font specified paragraph. needed, if the last characters font
has changed. has changed.
*/ */
void redoHeightOfParagraph(BufferView *); void redoHeightOfParagraph();
/** insert a character, moves all the following breaks in the /** insert a character, moves all the following breaks in the
same Paragraph one to the right and make a little rebreak same Paragraph one to the right and make a little rebreak
*/ */
void insertChar(BufferView *, char c); void insertChar(char c);
/// ///
void insertInset(BufferView *, Inset * inset); void insertInset(Inset * inset);
/// Completes the insertion with a full rebreak /// Completes the insertion with a full rebreak
void fullRebreak(BufferView *); void fullRebreak();
/// ///
mutable Row * need_break_row; mutable Row * need_break_row;
@ -197,16 +196,20 @@ public:
/** /**
* Mark position y as the starting point for a repaint * Mark position y as the starting point for a repaint
*/ */
void postPaint(BufferView & bv, int start_y); void postPaint(int start_y);
/** /**
* Mark the given row at position y as needing a repaint. * Mark the given row at position y as needing a repaint.
*/ */
void postRowPaint(BufferView & bv, Row * row, int start_y); void postRowPaint(Row * row, int start_y);
/// ///
Inset::RESULT dispatch(FuncRequest const & cmd); Inset::RESULT dispatch(FuncRequest const & cmd);
BufferView * bv();
BufferView * bv() const;
friend class LyXScreen; friend class LyXScreen;
/** /**
@ -247,7 +250,7 @@ public:
/** returns the column near the specified x-coordinate of the row /** returns the column near the specified x-coordinate of the row
x is set to the real beginning of this column x is set to the real beginning of this column
*/ */
lyx::pos_type getColumnNearX(BufferView *, Row * row, lyx::pos_type getColumnNearX(Row * row,
int & x, bool & boundary) const; int & x, bool & boundary) const;
/** returns a pointer to a specified row. y is set to the beginning /** returns a pointer to a specified row. y is set to the beginning
@ -309,7 +312,7 @@ public:
mutable LyXCursor toggle_end_cursor; mutable LyXCursor toggle_end_cursor;
/// need the selection cursor: /// need the selection cursor:
void setSelection(BufferView *); void setSelection();
/// ///
void clearSelection() const; void clearSelection() const;
/// ///
@ -319,40 +322,40 @@ public:
void getWord(LyXCursor & from, LyXCursor & to, void getWord(LyXCursor & from, LyXCursor & to,
word_location const) const; word_location const) const;
/// just selects the word the cursor is in /// just selects the word the cursor is in
void selectWord(BufferView *, word_location const); void selectWord(word_location const);
/// returns the inset at cursor (if it exists), 0 otherwise /// returns the inset at cursor (if it exists), 0 otherwise
Inset * getInset() const; Inset * getInset() const;
/// accept selected change /// accept selected change
void acceptChange(BufferView * bv); void acceptChange();
/// reject selected change /// reject selected change
void rejectChange(BufferView * bv); void rejectChange();
/** 'selects" the next word, where the cursor is not in /** 'selects" the next word, where the cursor is not in
and returns this word as string. THe cursor will be moved and returns this word as string. THe cursor will be moved
to the beginning of this word. to the beginning of this word.
With SelectSelectedWord can this be highlighted really With SelectSelectedWord can this be highlighted really
*/ */
WordLangTuple const selectNextWordToSpellcheck(BufferView *, float & value) const; WordLangTuple const selectNextWordToSpellcheck(float & value) const;
/// ///
void selectSelectedWord(BufferView *); void selectSelectedWord();
/// returns true if par was empty and was removed /// returns true if par was empty and was removed
bool setCursor(BufferView *, Paragraph * par, bool setCursor(Paragraph * par,
lyx::pos_type pos, lyx::pos_type pos,
bool setfont = true, bool setfont = true,
bool boundary = false) const; bool boundary = false) const;
/// ///
void setCursor(BufferView *, LyXCursor &, Paragraph * par, void setCursor(LyXCursor &, Paragraph * par,
lyx::pos_type pos, lyx::pos_type pos,
bool boundary = false) const; bool boundary = false) const;
/// ///
void setCursorIntern(BufferView *, Paragraph * par, void setCursorIntern(Paragraph * par,
lyx::pos_type pos, lyx::pos_type pos,
bool setfont = true, bool setfont = true,
bool boundary = false) const; bool boundary = false) const;
/// ///
void setCurrentFont(BufferView *) const; void setCurrentFont() const;
/// ///
bool isBoundary(Buffer const *, Paragraph * par, bool isBoundary(Buffer const *, Paragraph * par,
@ -363,47 +366,46 @@ public:
LyXFont const & font) const; LyXFont const & font) const;
/// ///
void setCursorFromCoordinates(BufferView *, int x, int y) const; void setCursorFromCoordinates(int x, int y) const;
/// ///
void setCursorFromCoordinates(BufferView *, LyXCursor &, void setCursorFromCoordinates(LyXCursor &,
int x, int y) const; int x, int y) const;
/// ///
void cursorUp(BufferView *, bool selecting = false) const; void cursorUp(bool selecting = false) const;
/// ///
void cursorDown(BufferView *, bool selecting = false) const; void cursorDown(bool selecting = false) const;
/// ///
void cursorLeft(BufferView *, bool internal = true) const; void cursorLeft(bool internal = true) const;
/// ///
void cursorRight(BufferView *, bool internal = true) const; void cursorRight(bool internal = true) const;
/// ///
void cursorLeftOneWord(BufferView *) const; void cursorLeftOneWord() const;
/// ///
void cursorRightOneWord(BufferView *) const; void cursorRightOneWord() const;
/// ///
void cursorUpParagraph(BufferView *) const; void cursorUpParagraph() const;
/// ///
void cursorDownParagraph(BufferView *) const; void cursorDownParagraph() const;
/// ///
void cursorHome(BufferView *) const; void cursorHome() const;
/// ///
void cursorEnd(BufferView *) const; void cursorEnd() const;
/// ///
void cursorPrevious(BufferView * bv); void cursorPrevious();
/// ///
void cursorNext(BufferView * bv); void cursorNext();
/// ///
void cursorTab(BufferView *) const; void cursorTab() const;
/// ///
void cursorTop(BufferView *) const; void cursorTop() const;
/// ///
void cursorBottom(BufferView *) const; void cursorBottom() const;
/// ///
void Delete(BufferView *); void Delete();
/// ///
void backspace(BufferView *); void backspace();
/// ///
bool selectWordWhenUnderCursor(BufferView *, bool selectWordWhenUnderCursor(word_location);
word_location const);
/// ///
enum TextCase { enum TextCase {
/// ///
@ -414,22 +416,22 @@ public:
text_uppercase = 2 text_uppercase = 2
}; };
/// Change the case of the word at cursor position. /// Change the case of the word at cursor position.
void changeCase(BufferView &, TextCase action); void changeCase(TextCase action);
/// ///
void transposeChars(BufferView &); void transposeChars();
/// ///
void toggleInset(BufferView *); void toggleInset();
/// ///
void cutSelection(BufferView *, bool doclear = true, bool realcut = true); void cutSelection(bool doclear = true, bool realcut = true);
/// ///
void copySelection(BufferView *); void copySelection();
/// ///
void pasteSelection(BufferView *); void pasteSelection();
/// ///
void copyEnvironmentType(); void copyEnvironmentType();
/// ///
void pasteEnvironmentType(BufferView *); void pasteEnvironmentType();
/** the DTP switches for paragraphs. LyX will store the top settings /** the DTP switches for paragraphs. LyX will store the top settings
always in the first physical paragraph, the bottom settings in the always in the first physical paragraph, the bottom settings in the
@ -437,14 +439,13 @@ public:
settings are given to the new one. So I can make shure, they do not settings are given to the new one. So I can make shure, they do not
duplicate themself (and you cannnot make dirty things with them! ) duplicate themself (and you cannnot make dirty things with them! )
*/ */
void setParagraph(BufferView *, void setParagraph(bool line_top, bool line_bottom,
bool line_top, bool line_bottom,
bool pagebreak_top, bool pagebreak_bottom, bool pagebreak_top, bool pagebreak_bottom,
VSpace const & space_top, VSpace const & space_top,
VSpace const & space_bottom, VSpace const & space_bottom,
Spacing const & spacing, Spacing const & spacing,
LyXAlignment align, LyXAlignment align,
string labelwidthstring, string const & labelwidthstring,
bool noindent); bool noindent);
/* these things are for search and replace */ /* these things are for search and replace */
@ -453,38 +454,38 @@ public:
* Sets the selection from the current cursor position to length * Sets the selection from the current cursor position to length
* characters to the right. No safety checks. * characters to the right. No safety checks.
*/ */
void setSelectionRange(BufferView *, lyx::pos_type length); void setSelectionRange(lyx::pos_type length);
/** simple replacing. The font of the first selected character /** simple replacing. The font of the first selected character
is used is used
*/ */
void replaceSelectionWithString(BufferView *, string const & str); void replaceSelectionWithString(string const & str);
/// needed to insert the selection /// needed to insert the selection
void insertStringAsLines(BufferView *, string const & str); void insertStringAsLines(string const & str);
/// needed to insert the selection /// needed to insert the selection
void insertStringAsParagraphs(BufferView *, string const & str); void insertStringAsParagraphs(string const & str);
/// Find next inset of some specified type. /// Find next inset of some specified type.
bool gotoNextInset(BufferView *, std::vector<Inset::Code> const & codes, bool gotoNextInset(std::vector<Inset::Code> const & codes,
string const & contents = string()) const; string const & contents = string()) const;
/// ///
void gotoInset(BufferView * bv, std::vector<Inset::Code> const & codes, void gotoInset(std::vector<Inset::Code> const & codes,
bool same_content); bool same_content);
/// ///
void gotoInset(BufferView * bv, Inset::Code code, bool same_content); void gotoInset(Inset::Code code, bool same_content);
/// ///
/* for the greater insets */ /* for the greater insets */
/// returns false if inset wasn't found /// returns false if inset wasn't found
bool updateInset(BufferView *, Inset *); bool updateInset(Inset *);
/// ///
void checkParagraph(BufferView *, Paragraph * par, lyx::pos_type pos); void checkParagraph(Paragraph * par, lyx::pos_type pos);
/// ///
int workWidth(BufferView &) const; int workWidth() const;
/// ///
int workWidth(BufferView &, Inset * inset) const; int workWidth(Inset * inset) const;
/// ///
void computeBidiTables(Buffer const *, Row * row) const; void computeBidiTables(Buffer const *, Row * row) const;
@ -529,15 +530,15 @@ private:
void cursorLeftOneWord(LyXCursor &) const; void cursorLeftOneWord(LyXCursor &) const;
/// ///
float getCursorX(BufferView *, Row *, lyx::pos_type pos, float getCursorX(Row *, lyx::pos_type pos,
lyx::pos_type last, bool boundary) const; lyx::pos_type last, bool boundary) const;
/// used in setlayout /// used in setlayout
void makeFontEntriesLayoutSpecific(Buffer const &, Paragraph & par); void makeFontEntriesLayoutSpecific(Buffer const &, Paragraph & par);
/** forces the redrawing of a paragraph. Needed when manipulating a /** forces the redrawing of a paragraph. Needed when manipulating a
right address box right address box
*/ */
void redoDrawingOfParagraph(BufferView *, LyXCursor const & cursor); void redoDrawingOfParagraph(LyXCursor const & cursor);
/** Copybuffer for copy environment type. /** Copybuffer for copy environment type.
Asger has learned that this should be a buffer-property instead Asger has learned that this should be a buffer-property instead
@ -555,45 +556,42 @@ private:
void removeParagraph(Row * row) const; void removeParagraph(Row * row) const;
/// insert the specified paragraph behind the specified row /// insert the specified paragraph behind the specified row
void insertParagraph(BufferView *, void insertParagraph(Paragraph * par, Row * row) const;
Paragraph * par, Row * row) const;
/** appends the implizit specified paragraph behind the specified row, /** appends the implizit specified paragraph behind the specified row,
* start at the implizit given position */ * start at the implizit given position */
void appendParagraph(BufferView *, Row * row) const; void appendParagraph(Row * row) const;
/// ///
void breakAgain(BufferView *, Row * row) const; void breakAgain(Row * row) const;
/// Calculate and set the height of the row /// Calculate and set the height of the row
void setHeightOfRow(BufferView *, Row * row_ptr) const; void setHeightOfRow(Row * row_ptr) const;
// fix the cursor `cur' after a characters has been deleted at `where' // fix the cursor `cur' after a characters has been deleted at `where'
// position. Called by deleteEmptyParagraphMechanism // position. Called by deleteEmptyParagraphMechanism
void fixCursorAfterDelete(BufferView * bv, void fixCursorAfterDelete(LyXCursor & cur,
LyXCursor & cur,
LyXCursor const & where) const; LyXCursor const & where) const;
/// delete double space (false) or empty paragraphs (true) around old_cursor /// delete double space (false) or empty paragraphs (true) around old_cursor
bool deleteEmptyParagraphMechanism(BufferView *, bool deleteEmptyParagraphMechanism(LyXCursor const & old_cursor) const;
LyXCursor const & old_cursor) const;
public: public:
/** Updates all counters starting BEHIND the row. Changed paragraphs /** Updates all counters starting BEHIND the row. Changed paragraphs
* with a dynamic left margin will be rebroken. */ * with a dynamic left margin will be rebroken. */
void updateCounters(BufferView *) const; void updateCounters() const;
/// ///
void update(BufferView * bv, bool changed = true); void update(bool changed = true);
/** /**
* Returns an inset if inset was hit, or 0 if not. * Returns an inset if inset was hit, or 0 if not.
* If hit, the coordinates are changed relative to the inset. * If hit, the coordinates are changed relative to the inset.
*/ */
Inset * checkInsetHit(BufferView * bv, int & x, int & y) const; Inset * checkInsetHit(int & x, int & y) const;
/// ///
int singleWidth(BufferView *, Paragraph * par, int singleWidth(Paragraph * par,
lyx::pos_type pos) const; lyx::pos_type pos) const;
/// ///
int singleWidth(BufferView *, Paragraph * par, int singleWidth(Paragraph * par,
lyx::pos_type pos, char c) const; lyx::pos_type pos, char c) const;
/// return the color of the canvas /// return the color of the canvas
@ -611,13 +609,13 @@ public:
* in LaTeX the beginning of the text fits in some cases * in LaTeX the beginning of the text fits in some cases
* (for example sections) exactly the label-width. * (for example sections) exactly the label-width.
*/ */
int leftMargin(BufferView *, Row const * row) const; int leftMargin(Row const * row) const;
/// ///
int rightMargin(Buffer const &, Row const & row) const; int rightMargin(Buffer const &, Row const & row) const;
/** this calculates the specified parameters. needed when setting /** this calculates the specified parameters. needed when setting
* the cursor and when creating a visible row */ * the cursor and when creating a visible row */
void prepareToPrint(BufferView *, Row * row, float & x, void prepareToPrint(Row * row, float & x,
float & fill_separator, float & fill_separator,
float & fill_hfill, float & fill_hfill,
float & fill_label_hfill, float & fill_label_hfill,
@ -627,11 +625,11 @@ private:
/// ///
void setCounter(Buffer const *, Paragraph * par) const; void setCounter(Buffer const *, Paragraph * par) const;
/// ///
void deleteWordForward(BufferView *); void deleteWordForward();
/// ///
void deleteWordBackward(BufferView *); void deleteWordBackward();
/// ///
void deleteLineForward(BufferView *); void deleteLineForward();
/* /*
* some low level functions * some low level functions
@ -640,19 +638,19 @@ private:
/// return the pos value *before* which a row should break. /// return the pos value *before* which a row should break.
/// for example, the pos at which IsNewLine(pos) == true /// for example, the pos at which IsNewLine(pos) == true
lyx::pos_type rowBreakPoint(BufferView &, Row const & row) const; lyx::pos_type rowBreakPoint(Row const & row) const;
/// returns the minimum space a row needs on the screen in pixel /// returns the minimum space a row needs on the screen in pixel
int fill(BufferView &, Row & row, int workwidth) const; int fill(Row & row, int workwidth) const;
/** /**
* returns the minimum space a manual label needs on the * returns the minimum space a manual label needs on the
* screen in pixels * screen in pixels
*/ */
int labelFill(BufferView &, Row const & row) const; int labelFill(Row const & row) const;
/// FIXME /// FIXME
int labelEnd(BufferView &, Row const & row) const; int labelEnd(Row const & row) const;
/// ///
mutable std::vector<lyx::pos_type> log2vis_list; mutable std::vector<lyx::pos_type> log2vis_list;
@ -681,11 +679,7 @@ public:
// set it searching first for the right owner using the paragraph id // set it searching first for the right owner using the paragraph id
void ownerParagraph(int id, Paragraph *) const; void ownerParagraph(int id, Paragraph *) const;
/// return true if this is the outer-most lyxtext /// return true if this is owned by an inset.
bool isTopLevel() const;
/// return true if this is owned by an inset. FIXME: why the difference
/// with isTopLevel() ??
bool isInInset() const; bool isInInset() const;
}; };

2
src/mathed/math_hullinset.C
View File

@ -391,7 +391,7 @@ void MathHullInset::footer_write(WriteStream & os) const
else if (type_ == "eqnarray" || type_ == "align" || type_ == "flalign" else if (type_ == "eqnarray" || type_ == "align" || type_ == "flalign"
|| type_ == "alignat" || type_ == "xalignat" || type_ == "alignat" || type_ == "xalignat"
|| type_ == "gather" || type_ == "multline") || type_ == "gather" || type_ == "multline")
os << "\\end{" << type_ << star(n) << "}\n"; os << "\\end{" << type_ << star(n) << "}\n";
else if (type_ == "xxalignat") else if (type_ == "xxalignat")
os << "\\end{" << type_ << "}\n"; os << "\\end{" << type_ << "}\n";

2
src/mathed/math_parser.C
View File

@ -967,7 +967,7 @@ void Parser::parse1(MathGridInset & grid, unsigned flags,
parse(cell->back().nucleus()->cell(0), FLAG_ITEM, mode); parse(cell->back().nucleus()->cell(0), FLAG_ITEM, mode);
} }
else if (t.cs() == "ref" || t.cs() == "prettyref" || else if (t.cs() == "ref" || t.cs() == "prettyref" ||
t.cs() == "pageref" || t.cs() == "vpageref" || t.cs() == "vref") { t.cs() == "pageref" || t.cs() == "vpageref" || t.cs() == "vref") {
cell->push_back(MathAtom(new RefInset(t.cs()))); cell->push_back(MathAtom(new RefInset(t.cs())));
parse(cell->back().nucleus()->cell(1), FLAG_OPTION, mode); parse(cell->back().nucleus()->cell(1), FLAG_OPTION, mode);

16
src/rowpainter.C
View File

@ -69,17 +69,15 @@ LyXFont const RowPainter::getFont(pos_type pos) const
int RowPainter::singleWidth(lyx::pos_type pos) const int RowPainter::singleWidth(lyx::pos_type pos) const
{ {
BufferView * bv(perv(bv_));
Paragraph * par(const_cast<Paragraph*>(&par_)); Paragraph * par(const_cast<Paragraph*>(&par_));
return text_.singleWidth(bv, par, pos); return text_.singleWidth(par, pos);
} }
int RowPainter::singleWidth(lyx::pos_type pos, char c) const int RowPainter::singleWidth(lyx::pos_type pos, char c) const
{ {
BufferView * bv(perv(bv_));
Paragraph * par(const_cast<Paragraph*>(&par_)); Paragraph * par(const_cast<Paragraph*>(&par_));
return text_.singleWidth(bv, par, pos, c); return text_.singleWidth(par, pos, c);
} }
@ -99,9 +97,8 @@ char const RowPainter::transformChar(char c, lyx::pos_type pos) const
int RowPainter::leftMargin() const int RowPainter::leftMargin() const
{ {
BufferView * bv(perv(bv_));
Row * row(const_cast<Row *>(&row_)); Row * row(const_cast<Row *>(&row_));
return text_.leftMargin(bv, row); return text_.leftMargin(row);
} }
@ -631,7 +628,7 @@ void RowPainter::paintFirst()
} }
// the top margin // the top margin
if (!row_.previous() && text_.isTopLevel()) if (!row_.previous() && !text_.isInInset())
y_top += PAPER_MARGIN; y_top += PAPER_MARGIN;
// draw a top pagebreak // draw a top pagebreak
@ -778,7 +775,7 @@ void RowPainter::paintLast()
int y_bottom = row_.height() - 1; int y_bottom = row_.height() - 1;
// the bottom margin // the bottom margin
if (!row_.next() && text_.isTopLevel()) if (!row_.next() && !text_.isInInset())
y_bottom -= PAPER_MARGIN; y_bottom -= PAPER_MARGIN;
int const ww = bv_.workWidth(); int const ww = bv_.workWidth();
@ -980,9 +977,8 @@ bool RowPainter::paint(int y_offset, int x_offset, int y)
// FIXME: must be a cleaner way here. Aren't these calculations // FIXME: must be a cleaner way here. Aren't these calculations
// belonging to row metrics ? // belonging to row metrics ?
BufferView * bv(const_cast<BufferView *>(&bv_));
Row * row(const_cast<Row *>(&row_)); Row * row(const_cast<Row *>(&row_));
text_.prepareToPrint(bv, row, x_, separator_, hfill_, label_hfill_); text_.prepareToPrint(row, x_, separator_, hfill_, label_hfill_);
// FIXME: what is this fixing ? // FIXME: what is this fixing ?
if (text_.isInInset() && (x_ < 0)) if (text_.isInInset() && (x_ < 0))

109
src/tex2lyx/tex2lyx.C
View File

@ -46,19 +46,20 @@ void parse(Parser & p, ostream & os, unsigned flags, const mode_type mode);
char const OPEN = '<'; char const OPEN = '<';
char const CLOSE = '>'; char const CLOSE = '>';
// rather brutish way to code table structure in a string: /* rather brutish way to code table structure in a string:
//
// \begin{tabular}{ccc} \begin{tabular}{ccc}
// 1 & 2 & 3\\ \hline 1 & 2 & 3\\ \hline
// \multicolumn{2}{c}{4} & 5\\ \multicolumn{2}{c}{4} & 5 //
// 6 & 7 \\ 6 & 7 \\
// \end{tabular} \end{tabular}
//
// gets "translated" to: gets "translated" to:
//
// 1 TAB 2 TAB 3 LINE 1 TAB 2 TAB 3 LINE
// HLINE 2 MULT c MULT 4 TAB 5 LINE HLINE 2 MULT c MULT 4 TAB 5 LINE
// 5 TAB 7 LINE 5 TAB 7 LINE
*/
char const TAB = '\001'; char const TAB = '\001';
char const LINE = '\002'; char const LINE = '\002';
@ -158,7 +159,7 @@ string const trim(string const & a, char const * p = " \t\n\r")
void split(string const & s, vector<string> & result, char delim = ',') void split(string const & s, vector<string> & result, char delim = ',')
{ {
istringstream is(s); istringstream is(s);
string t; string t;
while (getline(is, t, delim)) while (getline(is, t, delim))
result.push_back(t); result.push_back(t);
@ -174,7 +175,7 @@ map<string, string> split_map(string const & s)
for (size_t i = 0; i < v.size(); ++i) { for (size_t i = 0; i < v.size(); ++i) {
size_t const pos = v[i].find('='); size_t const pos = v[i].find('=');
string const index = v[i].substr(0, pos); string const index = v[i].substr(0, pos);
string const value = v[i].substr(pos + 1, string::npos); string const value = v[i].substr(pos + 1, string::npos);
res[trim(index)] = trim(value); res[trim(index)] = trim(value);
} }
return res; return res;
@ -186,8 +187,8 @@ string join(vector<string> const & input, char const * delim)
ostringstream os; ostringstream os;
for (size_t i = 0; i != input.size(); ++i) { for (size_t i = 0; i != input.size(); ++i) {
if (i) if (i)
os << delim; os << delim;
os << input[i]; os << input[i];
} }
return os.str(); return os.str();
} }
@ -266,7 +267,7 @@ void handle_par(ostream & os)
return; return;
os << "\n\\layout "; os << "\n\\layout ";
string s = curr_env(); string s = curr_env();
if (s == "document" || s == "table") if (s == "document" || s == "table")
os << "Standard\n\n"; os << "Standard\n\n";
else if (s == "lyxcode") else if (s == "lyxcode")
os << "LyX-Code\n\n"; os << "LyX-Code\n\n";
@ -285,23 +286,23 @@ void handle_package(string const & name, string const & options)
if (name == "a4wide") { if (name == "a4wide") {
h_papersize = "a4paper"; h_papersize = "a4paper";
h_paperpackage = "widemarginsa4"; h_paperpackage = "widemarginsa4";
} else if (name == "ae") } else if (name == "ae")
h_fontscheme = "ae"; h_fontscheme = "ae";
else if (name == "aecompl") else if (name == "aecompl")
h_fontscheme = "ae"; h_fontscheme = "ae";
else if (name == "amsmath") else if (name == "amsmath")
h_use_amsmath = "1"; h_use_amsmath = "1";
else if (name == "amssymb") else if (name == "amssymb")
h_use_amsmath = "1"; h_use_amsmath = "1";
else if (name == "babel") else if (name == "babel")
; // ignore this ; // ignore this
else if (name == "fontenc") else if (name == "fontenc")
; // ignore this ; // ignore this
else if (name == "inputenc") else if (name == "inputenc")
h_inputencoding = options; h_inputencoding = options;
else if (name == "makeidx") else if (name == "makeidx")
; // ignore this ; // ignore this
else if (name == "verbatim") else if (name == "verbatim")
; // ignore this ; // ignore this
else if (is_known(name, known_languages)) { else if (is_known(name, known_languages)) {
h_language = name; h_language = name;
@ -373,7 +374,7 @@ void handle_tabular(Parser & p, ostream & os, mode_type mode)
cells.push_back(string()); cells.push_back(string());
os << "<row"; os << "<row";
if (hlines) if (hlines)
os << " topline=\"true\""; os << " topline=\"true\"";
os << ">\n"; os << ">\n";
for (size_t c = 0; c < cols; ++c) { for (size_t c = 0; c < cols; ++c) {
os << "<cell"; os << "<cell";
@ -400,7 +401,7 @@ void handle_tabular(Parser & p, ostream & os, mode_type mode)
os << "</row>\n"; os << "</row>\n";
} }
os << "</lyxtabular>\n"; os << "</lyxtabular>\n";
end_inset(os); end_inset(os);
} }
@ -457,7 +458,7 @@ void parse_preamble(Parser & p, ostream & os)
// cat codes // cat codes
// //
if (t.cat() == catLetter || if (t.cat() == catLetter ||
t.cat() == catSpace || t.cat() == catSpace ||
t.cat() == catSuper || t.cat() == catSuper ||
t.cat() == catSub || t.cat() == catSub ||
t.cat() == catOther || t.cat() == catOther ||
@ -489,7 +490,7 @@ void parse_preamble(Parser & p, ostream & os)
p.setCatCode('@', catLetter); p.setCatCode('@', catLetter);
h_preamble << "\\makeatletter\n"; h_preamble << "\\makeatletter\n";
} }
else if (t.cs() == "makeatother") { else if (t.cs() == "makeatother") {
p.setCatCode('@', catOther); p.setCatCode('@', catOther);
h_preamble << "\\makeatother\n"; h_preamble << "\\makeatother\n";
@ -526,8 +527,8 @@ void parse_preamble(Parser & p, ostream & os)
else if (t.cs() == "documentclass") { else if (t.cs() == "documentclass") {
vector<string> opts; vector<string> opts;
split(p.getArg('[', ']'), opts, ','); split(p.getArg('[', ']'), opts, ',');
handle_opt(opts, known_languages, h_language); handle_opt(opts, known_languages, h_language);
handle_opt(opts, known_fontsizes, h_paperfontsize); handle_opt(opts, known_fontsizes, h_paperfontsize);
h_quotes_language = h_language; h_quotes_language = h_language;
h_options = join(opts, ","); h_options = join(opts, ",");
h_textclass = p.getArg('{', '}'); h_textclass = p.getArg('{', '}');
@ -572,9 +573,9 @@ void parse_preamble(Parser & p, ostream & os)
else if (t.cs() == "setcounter") { else if (t.cs() == "setcounter") {
string const name = p.getArg('{', '}'); string const name = p.getArg('{', '}');
string const content = p.getArg('{', '}'); string const content = p.getArg('{', '}');
if (name == "secnumdepth") if (name == "secnumdepth")
h_secnumdepth = content; h_secnumdepth = content;
else if (name == "tocdepth") else if (name == "tocdepth")
h_tocdepth = content; h_tocdepth = content;
else else
h_preamble << "\\setcounter{" << name << "}{" << content << "}\n"; h_preamble << "\\setcounter{" << name << "}{" << content << "}\n";
@ -587,10 +588,10 @@ void parse_preamble(Parser & p, ostream & os)
h_paragraph_separation = "skip"; h_paragraph_separation = "skip";
else if (name == "parindent") else if (name == "parindent")
h_paragraph_separation = "skip"; h_paragraph_separation = "skip";
else else
h_preamble << "\\setlength{" + name + "}{" + content + "}\n"; h_preamble << "\\setlength{" + name + "}{" + content + "}\n";
} }
else if (t.cs() == "par") else if (t.cs() == "par")
h_preamble << '\n'; h_preamble << '\n';
@ -701,8 +702,8 @@ void parse(Parser & p, ostream & os, unsigned flags, const mode_type mode)
} }
else if (t.cat() == catLetter || else if (t.cat() == catLetter ||
t.cat() == catSpace || t.cat() == catSpace ||
t.cat() == catSuper || t.cat() == catSuper ||
t.cat() == catSub || t.cat() == catSub ||
t.cat() == catOther || t.cat() == catOther ||
t.cat() == catParameter) t.cat() == catParameter)
@ -717,7 +718,7 @@ void parse(Parser & p, ostream & os, unsigned flags, const mode_type mode)
os << ' '; os << ' ';
else if (mode == TEXT_MODE) else if (mode == TEXT_MODE)
os << "\\SpecialChar ~\n"; os << "\\SpecialChar ~\n";
else else
os << '~'; os << '~';
} else } else
os << t.character(); os << t.character();
@ -793,7 +794,7 @@ void parse(Parser & p, ostream & os, unsigned flags, const mode_type mode)
p.setCatCode('@', catLetter); p.setCatCode('@', catLetter);
handle_ert(os, "\\makeatletter\n"); handle_ert(os, "\\makeatletter\n");
} }
else if (t.cs() == "makeatother") { else if (t.cs() == "makeatother") {
p.setCatCode('@', catOther); p.setCatCode('@', catOther);
handle_ert(os, "\\makeatother\n"); handle_ert(os, "\\makeatother\n");
@ -860,13 +861,13 @@ void parse(Parser & p, ostream & os, unsigned flags, const mode_type mode)
handle_par(os); handle_par(os);
parse(p, os, FLAG_END, mode); parse(p, os, FLAG_END, mode);
} else if (is_math_env(name)) { } else if (is_math_env(name)) {
begin_inset(os, "Formula "); begin_inset(os, "Formula ");
os << "\\begin{" << name << "}"; os << "\\begin{" << name << "}";
parse(p, os, FLAG_END, MATH_MODE); parse(p, os, FLAG_END, MATH_MODE);
os << "\\end{" << name << "}"; os << "\\end{" << name << "}";
end_inset(os); end_inset(os);
} else if (name == "tabular") { } else if (name == "tabular") {
if (mode == TEXT_MODE) if (mode == TEXT_MODE)
handle_tabular(p, os, mode); handle_tabular(p, os, mode);
else { else {
os << "\\begin{" << name << "}"; os << "\\begin{" << name << "}";
@ -883,7 +884,7 @@ void parse(Parser & p, ostream & os, unsigned flags, const mode_type mode)
<< "\n" << "\n"
<< "\\layout Standard\n"; << "\\layout Standard\n";
parse(p, os, FLAG_END, mode); parse(p, os, FLAG_END, mode);
end_inset(os); end_inset(os);
} else if (name == "thebibliography") { } else if (name == "thebibliography") {
p.verbatimItem(); // swallow next arg p.verbatimItem(); // swallow next arg
parse(p, os, FLAG_END, mode); parse(p, os, FLAG_END, mode);
@ -928,8 +929,8 @@ void parse(Parser & p, ostream & os, unsigned flags, const mode_type mode)
else if (t.cs() == "documentclass") { else if (t.cs() == "documentclass") {
vector<string> opts; vector<string> opts;
split(p.getArg('[', ']'), opts, ','); split(p.getArg('[', ']'), opts, ',');
handle_opt(opts, known_languages, h_language); handle_opt(opts, known_languages, h_language);
handle_opt(opts, known_fontsizes, h_paperfontsize); handle_opt(opts, known_fontsizes, h_paperfontsize);
h_quotes_language = h_language; h_quotes_language = h_language;
h_options = join(opts, ","); h_options = join(opts, ",");
h_textclass = p.getArg('{', '}'); h_textclass = p.getArg('{', '}');
@ -1001,14 +1002,14 @@ void parse(Parser & p, ostream & os, unsigned flags, const mode_type mode)
else if (t.cs() == "multicolumn" && mode == TEXT_MODE) { else if (t.cs() == "multicolumn" && mode == TEXT_MODE) {
// brutish... // brutish...
parse(p, os, FLAG_ITEM, mode); parse(p, os, FLAG_ITEM, mode);
os << MULT; os << MULT;
parse(p, os, FLAG_ITEM, mode); parse(p, os, FLAG_ITEM, mode);
os << MULT; os << MULT;
parse(p, os, FLAG_ITEM, mode); parse(p, os, FLAG_ITEM, mode);
} }
else if (t.cs() == "hline" && mode == TEXT_MODE) else if (t.cs() == "hline" && mode == TEXT_MODE)
os << HLINE; os << HLINE;
else if (t.cs() == "textrm") { else if (t.cs() == "textrm") {
@ -1151,7 +1152,7 @@ void parse(Parser & p, ostream & os, unsigned flags, const mode_type mode)
else handle_ert(os, "\"{" + name + "}"); else handle_ert(os, "\"{" + name + "}");
} }
else if (t.cs() == "ss") else if (t.cs() == "ss")
os << "ß"; os << "ß";
else if (t.cs() == "input") else if (t.cs() == "input")
@ -1213,7 +1214,7 @@ int main(int argc, char * argv[])
parse(p, cout, FLAG_END, TEXT_MODE); parse(p, cout, FLAG_END, TEXT_MODE);
cout << "\n\\the_end"; cout << "\n\\the_end";
return 0; return 0;
} }
// }]) // }])

523
src/text.C
View File

File diff suppressed because it is too large Load Diff

570
src/text2.C
View File

File diff suppressed because it is too large Load Diff

402
src/text3.C
View File

File diff suppressed because it is too large Load Diff

4
src/trans_mgr.C
View File

@ -255,7 +255,7 @@ void TransManager::insertVerbatim(string const & str, LyXText * text)
string::size_type const l = str.length(); string::size_type const l = str.length();
for (string::size_type i = 0; i < l; ++i) { for (string::size_type i = 0; i < l; ++i) {
text->insertChar(current_view, str[i]); text->insertChar(str[i]);
} }
} }
@ -274,7 +274,7 @@ void TransManager::insert(string const & str, LyXText * text)
// Could not find an encoding // Could not find an encoding
InsetLatexAccent ins(str); InsetLatexAccent ins(str);
if (ins.canDisplay()) { if (ins.canDisplay()) {
text->insertInset(current_view, text->insertInset(
new InsetLatexAccent(ins)); new InsetLatexAccent(ins));
} else { } else {
insertVerbatim(str, text); insertVerbatim(str, text);

24
src/undo_funcs.C
View File

@ -66,7 +66,7 @@ void finishNoUndo(BufferView * bv)
freezeUndo(); freezeUndo();
bv->unlockInset(bv->theLockingInset()); bv->unlockInset(bv->theLockingInset());
finishUndo(); finishUndo();
bv->text->postPaint(*bv, 0); bv->text->postPaint(0);
unFreezeUndo(); unFreezeUndo();
} }
@ -96,7 +96,7 @@ bool textHandleUndo(BufferView * bv, Undo & undo)
num = -1; num = -1;
} }
} }
t->setCursorIntern(bv, firstUndoParagraph(bv, num), 0); t->setCursorIntern(firstUndoParagraph(bv, num), 0);
} }
// replace the paragraphs with the undo informations // replace the paragraphs with the undo informations
@ -186,9 +186,9 @@ bool textHandleUndo(BufferView * bv, Undo & undo)
if (before) { // if we have a par before the undopar if (before) { // if we have a par before the undopar
Inset * it = before->inInset(); Inset * it = before->inInset();
if (it) if (it)
it->getLyXText(bv)->setCursorIntern(bv, before, 0); it->getLyXText(bv)->setCursorIntern(before, 0);
else else
bv->text->setCursorIntern(bv, before, 0); bv->text->setCursorIntern(before, 0);
} }
// we are not ready for this we cannot set the cursor for a paragraph // we are not ready for this we cannot set the cursor for a paragraph
// which is not already in a row of LyXText!!! // which is not already in a row of LyXText!!!
@ -212,7 +212,7 @@ bool textHandleUndo(BufferView * bv, Undo & undo)
if (undopar) if (undopar)
it = static_cast<UpdatableInset*>(undopar->inInset()); it = static_cast<UpdatableInset*>(undopar->inInset());
if (it) { if (it) {
it->getLyXText(bv)->redoParagraphs(bv, it->getLyXText(bv)->redoParagraphs(
it->getLyXText(bv)->cursor, it->getLyXText(bv)->cursor,
endpar); endpar);
if (tmppar) { if (tmppar) {
@ -224,19 +224,19 @@ bool textHandleUndo(BufferView * bv, Undo & undo)
} else { } else {
t = bv->text; t = bv->text;
} }
t->setCursorIntern(bv, tmppar, undo.cursor_pos); t->setCursorIntern(tmppar, undo.cursor_pos);
// clear any selection and set the selection cursor // clear any selection and set the selection cursor
// for an evt. new selection. // for an evt. new selection.
t->clearSelection(); t->clearSelection();
t->selection.cursor = t->cursor; t->selection.cursor = t->cursor;
t->updateCounters(bv); t->updateCounters();
bv->fitCursor(); bv->fitCursor();
} }
bv->updateInset(it, false); bv->updateInset(it, false);
bv->text->setCursorIntern(bv, bv->text->cursor.par(), bv->text->setCursorIntern(bv->text->cursor.par(),
bv->text->cursor.pos()); bv->text->cursor.pos());
} else { } else {
bv->text->redoParagraphs(bv, bv->text->cursor, endpar); bv->text->redoParagraphs(bv->text->cursor, endpar);
if (tmppar) { if (tmppar) {
LyXText * t; LyXText * t;
Inset * it = tmppar->inInset(); Inset * it = tmppar->inInset();
@ -246,12 +246,12 @@ bool textHandleUndo(BufferView * bv, Undo & undo)
} else { } else {
t = bv->text; t = bv->text;
} }
t->setCursorIntern(bv, tmppar, undo.cursor_pos); t->setCursorIntern(tmppar, undo.cursor_pos);
// clear any selection and set the selection cursor // clear any selection and set the selection cursor
// for an evt. new selection. // for an evt. new selection.
t->clearSelection(); t->clearSelection();
t->selection.cursor = t->cursor; t->selection.cursor = t->cursor;
t->updateCounters(bv); t->updateCounters();
} }
} }
@ -266,7 +266,7 @@ bool textHandleUndo(BufferView * bv, Undo & undo)
} }
finishUndo(); finishUndo();
bv->text->postPaint(*bv, 0); bv->text->postPaint(0);
return true; return true;
} }