#include "CutAndPaste.h"
#include "DispatchResult.h"
#include "ErrorList.h"
-#include "FuncRequest.h"
#include "Language.h"
#include "Layout.h"
#include "Lexer.h"
-#include "LyXFunc.h"
+#include "LyX.h"
#include "LyXRC.h"
#include "Paragraph.h"
#include "ParagraphParameters.h"
#include "TextClass.h"
#include "TextMetrics.h"
-#include "VSpace.h"
#include "insets/InsetCollapsable.h"
// In case the default family has been customized
if (layout.font.family() == INHERIT_FAMILY)
lf.setFamily(owner_->buffer().params().getFont().fontInfo().family());
- // FIXME
- // It ought to be possible here just to use Inset::getLayout() and skip
- // the asInsetCollapsable() bit. Unfortunatley, that doesn't work right
- // now, because Inset::getLayout() will return a default-constructed
- // InsetLayout, and that e.g. sets the foreground color to red. So we
- // need to do some work to make that possible.
- InsetCollapsable const * icp = owner_->asInsetCollapsable();
- if (!icp)
- return lf;
- FontInfo icf = icp->getLayout().font();
+ FontInfo icf = owner_->getLayout().font();
icf.realize(lf);
return icf;
}
void Text::setInsetFont(BufferView const & bv, pit_type pit,
- pos_type pos, Font const & font, bool toggleall)
+ pos_type pos, Font const & font)
{
Inset * const inset = pars_[pit].getInset(pos);
- LASSERT(inset && inset->noFontChange(), /**/);
+ LASSERT(inset && inset->resetFontEdit(), return);
CursorSlice::idx_type endidx = inset->nargs();
for (CursorSlice cs(*inset); cs.idx() != endidx; ++cs.idx()) {
CursorSlice cellend = cs;
cellend.pit() = cellend.lastpit();
cellend.pos() = cellend.lastpos();
- text->setFont(bv, cs, cellend, font, toggleall);
+ text->setFont(bv, cs, cellend, font);
}
}
}
-// return past-the-last paragraph influenced by a layout change on pit
-pit_type Text::undoSpan(pit_type pit)
-{
- pit_type const end = paragraphs().size();
- pit_type nextpit = pit + 1;
- if (nextpit == end)
- return nextpit;
- //because of parindents
- if (!pars_[pit].getDepth())
- return boost::next(nextpit);
- //because of depth constrains
- for (; nextpit != end; ++pit, ++nextpit) {
- if (!pars_[pit].getDepth())
- break;
- }
- return nextpit;
-}
-
-
void Text::setLayout(pit_type start, pit_type end,
docstring const & layout)
{
- LASSERT(start != end, /**/);
+ LASSERT(start != end, return);
Buffer const & buffer = owner_->buffer();
BufferParams const & bp = buffer.params();
// set layout over selection and make a total rebreak of those paragraphs
void Text::setLayout(Cursor & cur, docstring const & layout)
{
- LASSERT(this == cur.text(), /**/);
+ LBUFERR(this == cur.text());
pit_type start = cur.selBegin().pit();
pit_type end = cur.selEnd().pit() + 1;
- pit_type undopit = undoSpan(end - 1);
- recUndo(cur, start, undopit - 1);
+ cur.recordUndoSelection();
setLayout(start, end, layout);
- cur.buffer()->updateLabels();
+ cur.forceBufferUpdate();
}
static bool changeDepthAllowed(Text::DEPTH_CHANGE type,
Paragraph const & par, int max_depth)
{
- if (par.layout().labeltype == LABEL_BIBLIO)
- return false;
int const depth = par.params().depth();
if (type == Text::INC_DEPTH && depth < max_depth)
return true;
bool Text::changeDepthAllowed(Cursor & cur, DEPTH_CHANGE type) const
{
- LASSERT(this == cur.text(), /**/);
+ LBUFERR(this == cur.text());
// this happens when selecting several cells in tabular (bug 2630)
if (cur.selBegin().idx() != cur.selEnd().idx())
return false;
void Text::changeDepth(Cursor & cur, DEPTH_CHANGE type)
{
- LASSERT(this == cur.text(), /**/);
+ LBUFERR(this == cur.text());
pit_type const beg = cur.selBegin().pit();
pit_type const end = cur.selEnd().pit() + 1;
cur.recordUndoSelection();
}
// this handles the counter labels, and also fixes up
// depth values for follow-on (child) paragraphs
- cur.buffer()->updateLabels();
+ cur.forceBufferUpdate();
}
void Text::setFont(Cursor & cur, Font const & font, bool toggleall)
{
- LASSERT(this == cur.text(), /**/);
+ LASSERT(this == cur.text(), return);
// Set the current_font
// Determine basis font
FontInfo layoutfont;
// Ok, we have a selection.
cur.recordUndoSelection();
+ Font newfont = font;
+
+ if (toggleall) {
+ // Toggling behaves as follows: We check the first character of the
+ // selection. If it's (say) got EMPH on, then we set to off; if off,
+ // then to on. With families and the like, we set it to INHERIT, if
+ // we already have it.
+ CursorSlice const & sl = cur.selBegin();
+ Text const & text = *sl.text();
+ Paragraph const & par = text.getPar(sl.pit());
+
+ // get font at the position
+ Font oldfont = par.getFont(cur.bv().buffer().params(), sl.pos(),
+ text.outerFont(sl.pit()));
+ FontInfo const & oldfi = oldfont.fontInfo();
+
+ FontInfo & newfi = newfont.fontInfo();
+
+ FontFamily newfam = newfi.family();
+ if (newfam != INHERIT_FAMILY && newfam != IGNORE_FAMILY &&
+ newfam == oldfi.family())
+ newfi.setFamily(INHERIT_FAMILY);
+
+ FontSeries newser = newfi.series();
+ if (newser == BOLD_SERIES && oldfi.series() == BOLD_SERIES)
+ newfi.setSeries(INHERIT_SERIES);
+
+ FontShape newshp = newfi.shape();
+ if (newshp != INHERIT_SHAPE && newshp != IGNORE_SHAPE &&
+ newshp == oldfi.shape())
+ newfi.setShape(INHERIT_SHAPE);
+
+ ColorCode newcol = newfi.color();
+ if (newcol != Color_none && newcol != Color_inherit
+ && newcol != Color_ignore && newcol == oldfi.color())
+ newfi.setColor(Color_none);
+
+ // ON/OFF ones
+ if (newfi.emph() == FONT_TOGGLE)
+ newfi.setEmph(oldfi.emph() == FONT_OFF ? FONT_ON : FONT_OFF);
+ if (newfi.underbar() == FONT_TOGGLE)
+ newfi.setUnderbar(oldfi.underbar() == FONT_OFF ? FONT_ON : FONT_OFF);
+ if (newfi.strikeout() == FONT_TOGGLE)
+ newfi.setStrikeout(oldfi.strikeout() == FONT_OFF ? FONT_ON : FONT_OFF);
+ if (newfi.uuline() == FONT_TOGGLE)
+ newfi.setUuline(oldfi.uuline() == FONT_OFF ? FONT_ON : FONT_OFF);
+ if (newfi.uwave() == FONT_TOGGLE)
+ newfi.setUwave(oldfi.uwave() == FONT_OFF ? FONT_ON : FONT_OFF);
+ if (newfi.noun() == FONT_TOGGLE)
+ newfi.setNoun(oldfi.noun() == FONT_OFF ? FONT_ON : FONT_OFF);
+ if (newfi.number() == FONT_TOGGLE)
+ newfi.setNumber(oldfi.number() == FONT_OFF ? FONT_ON : FONT_OFF);
+ }
setFont(cur.bv(), cur.selectionBegin().top(),
- cur.selectionEnd().top(), font, toggleall);
+ cur.selectionEnd().top(), newfont);
}
void Text::setFont(BufferView const & bv, CursorSlice const & begin,
- CursorSlice const & end, Font const & font,
- bool toggleall)
+ CursorSlice const & end, Font const & font)
{
Buffer const & buffer = bv.buffer();
pit_type const pit = dit.pit();
pos_type const pos = dit.pos();
Inset * inset = pars_[pit].getInset(pos);
- if (inset && inset->noFontChange()) {
+ if (inset && inset->resetFontEdit()) {
// We need to propagate the font change to all
- // text cells of the inset (bug 1973).
- // FIXME: This should change, see documentation
- // of noFontChange in Inset.h
- setInsetFont(bv, pit, pos, font, toggleall);
+ // text cells of the inset (bugs 1973, 6919).
+ setInsetFont(bv, pit, pos, font);
}
TextMetrics const & tm = bv.textMetrics(this);
Font f = tm.displayFont(pit, pos);
- f.update(font, language, toggleall);
+ f.update(font, language);
setCharFont(pit, pos, f, tm.font_);
+ // font change may change language...
+ // spell checker has to know that
+ pars_[pit].requestSpellCheck(pos);
}
}
bool Text::cursorTop(Cursor & cur)
{
- LASSERT(this == cur.text(), /**/);
+ LBUFERR(this == cur.text());
return setCursor(cur, 0, 0);
}
bool Text::cursorBottom(Cursor & cur)
{
- LASSERT(this == cur.text(), /**/);
+ LBUFERR(this == cur.text());
return setCursor(cur, cur.lastpit(), boost::prior(paragraphs().end())->size());
}
void Text::toggleFree(Cursor & cur, Font const & font, bool toggleall)
{
- LASSERT(this == cur.text(), /**/);
+ LBUFERR(this == cur.text());
// If the mask is completely neutral, tell user
if (font.fontInfo() == ignore_font && font.language() == ignore_language) {
// Could only happen with user style
docstring Text::getStringToIndex(Cursor const & cur)
{
- LASSERT(this == cur.text(), /**/);
+ LBUFERR(this == cur.text());
if (cur.selection())
return cur.selectionAsString(false);
}
-void Text::setLabelWidthStringToSequence(pit_type const par_offset,
+void Text::setLabelWidthStringToSequence(Cursor const & cur,
docstring const & s)
{
- pit_type offset = par_offset;
+ Cursor c = cur;
// Find first of same layout in sequence
- while (!isFirstInSequence(offset)) {
- offset = depthHook(offset, pars_[offset].getDepth());
+ while (!isFirstInSequence(c.pit())) {
+ c.pit() = depthHook(c.pit(), c.paragraph().getDepth());
}
// now apply label width string to every par
// in sequence
- pit_type const end = pars_.size();
- depth_type const depth = pars_[offset].getDepth();
- Layout const & layout = pars_[offset].layout();
- for (pit_type pit = offset; pit != end; ++pit) {
- while (pars_[pit].getDepth() > depth)
- ++pit;
- if (pars_[pit].getDepth() < depth)
+ depth_type const depth = c.paragraph().getDepth();
+ Layout const & layout = c.paragraph().layout();
+ for ( ; c.pit() <= c.lastpit() ; ++c.pit()) {
+ while (c.paragraph().getDepth() > depth) {
+ ++c.pit();
+ if (c.pit() > c.lastpit())
+ return;
+ }
+ if (c.paragraph().getDepth() < depth)
return;
- if (pars_[pit].layout() != layout)
+ if (c.paragraph().layout() != layout)
return;
- pars_[pit].setLabelWidthString(s);
+ c.recordUndo();
+ c.paragraph().setLabelWidthString(s);
}
}
void Text::setParagraphs(Cursor & cur, docstring arg, bool merge)
{
- LASSERT(cur.text(), /**/);
- // make sure that the depth behind the selection are restored, too
- pit_type undopit = undoSpan(cur.selEnd().pit());
- recUndo(cur, cur.selBegin().pit(), undopit - 1);
+ LBUFERR(cur.text());
//FIXME UNICODE
string const argument = to_utf8(arg);
depth_type priordepth = -1;
Layout priorlayout;
- for (pit_type pit = cur.selBegin().pit(), end = cur.selEnd().pit();
- pit <= end; ++pit) {
- Paragraph & par = pars_[pit];
+ Cursor c(cur.bv());
+ c.setCursor(cur.selectionBegin());
+ for ( ; c <= cur.selectionEnd() ; ++c.pit()) {
+ Paragraph & par = c.paragraph();
ParagraphParameters params = par.params();
params.read(argument, merge);
// Changes to label width string apply to all paragraphs
// with same layout in a sequence.
// Do this only once for a selected range of paragraphs
// of the same layout and depth.
- if (par.getDepth() != priordepth || par.layout() != priorlayout)
- setLabelWidthStringToSequence(pit, params.labelWidthString());
+ cur.recordUndo();
par.params().apply(params, par.layout());
+ if (par.getDepth() != priordepth || par.layout() != priorlayout)
+ setLabelWidthStringToSequence(c, params.labelWidthString());
priordepth = par.getDepth();
priorlayout = par.layout();
}
}
-//FIXME This is a little redundant now, but it's probably worth keeping,
-//especially if we're going to go away from using serialization internally
-//quite so much.
void Text::setParagraphs(Cursor & cur, ParagraphParameters const & p)
{
- LASSERT(cur.text(), /**/);
- // make sure that the depth behind the selection are restored, too
- pit_type undopit = undoSpan(cur.selEnd().pit());
- recUndo(cur, cur.selBegin().pit(), undopit - 1);
+ LBUFERR(cur.text());
depth_type priordepth = -1;
Layout priorlayout;
- for (pit_type pit = cur.selBegin().pit(), end = cur.selEnd().pit();
- pit <= end; ++pit) {
- Paragraph & par = pars_[pit];
+ Cursor c(cur.bv());
+ c.setCursor(cur.selectionBegin());
+ for ( ; c < cur.selectionEnd() ; ++c.pit()) {
+ Paragraph & par = c.paragraph();
// Changes to label width string apply to all paragraphs
// with same layout in a sequence.
// Do this only once for a selected range of paragraphs
// of the same layout and depth.
+ cur.recordUndo();
+ par.params().apply(p, par.layout());
if (par.getDepth() != priordepth || par.layout() != priorlayout)
- setLabelWidthStringToSequence(pit,
+ setLabelWidthStringToSequence(c,
par.params().labelWidthString());
- par.params().apply(p, par.layout());
priordepth = par.getDepth();
priorlayout = par.layout();
}
// this really should just insert the inset and not move the cursor.
void Text::insertInset(Cursor & cur, Inset * inset)
{
- LASSERT(this == cur.text(), /**/);
- LASSERT(inset, /**/);
+ LBUFERR(this == cur.text());
+ LBUFERR(inset);
cur.paragraph().insertInset(cur.pos(), inset, cur.current_font,
- Change(cur.buffer()->params().trackChanges
+ Change(cur.buffer()->params().track_changes
? Change::INSERTED : Change::UNCHANGED));
}
void Text::setCursor(CursorSlice & cur, pit_type par, pos_type pos)
{
- LASSERT(par != int(paragraphs().size()), /**/);
+ LASSERT(par != int(paragraphs().size()), return);
cur.pit() = par;
cur.pos() = pos;
// None of these should happen, but we're scaredy-cats
if (pos < 0) {
- lyxerr << "don't like -1" << endl;
- LASSERT(false, /**/);
+ LYXERR0("Don't like -1!");
+ LATTEST(false);
}
if (pos > para.size()) {
- lyxerr << "don't like 1, pos: " << pos
+ LYXERR0("Don't like 1, pos: " << pos
<< " size: " << para.size()
- << " par: " << par << endl;
- LASSERT(false, /**/);
+ << " par: " << par);
+ LATTEST(false);
}
}
void Text::setCursorIntern(Cursor & cur,
pit_type par, pos_type pos, bool setfont, bool boundary)
{
- LASSERT(this == cur.text(), /**/);
+ LBUFERR(this == cur.text());
cur.boundary(boundary);
setCursor(cur.top(), par, pos);
if (setfont)
bool Text::cursorBackward(Cursor & cur)
{
// Tell BufferView to test for FitCursor in any case!
- cur.updateFlags(Update::FitCursor);
+ cur.screenUpdateFlags(Update::FitCursor);
// not at paragraph start?
if (cur.pos() > 0) {
bool Text::cursorForward(Cursor & cur)
{
// Tell BufferView to test for FitCursor in any case!
- cur.updateFlags(Update::FitCursor);
+ cur.screenUpdateFlags(Update::FitCursor);
// not at paragraph end?
if (cur.pos() != cur.lastpos()) {
{
bool updated = false;
if (cur.pit() != cur.lastpit())
- updated = setCursor(cur, cur.pit() + 1, 0);
+ if (lyxrc.mac_like_cursor_movement)
+ if (cur.pos() == cur.lastpos())
+ updated = setCursor(cur, cur.pit() + 1, getPar(cur.pit() + 1).size());
+ else
+ updated = setCursor(cur, cur.pit(), cur.lastpos());
+ else
+ updated = setCursor(cur, cur.pit() + 1, 0);
else
updated = setCursor(cur, cur.pit(), cur.lastpos());
return updated;
&& oldpar.isLineSeparator(old.pos() - 1)
&& !oldpar.isDeleted(old.pos() - 1)
&& !oldpar.isDeleted(old.pos())) {
- oldpar.eraseChar(old.pos() - 1, cur.buffer()->params().trackChanges);
+ oldpar.eraseChar(old.pos() - 1, cur.buffer()->params().track_changes);
// FIXME: This will not work anymore when we have multiple views of the same buffer
// In this case, we will have to correct also the cursors held by
// other bufferviews. It will probably be easier to do that in a more
return true;
}
- if (oldpar.stripLeadingSpaces(cur.buffer()->params().trackChanges)) {
+ if (oldpar.stripLeadingSpaces(cur.buffer()->params().track_changes)) {
need_anchor_change = true;
// We return true here because the Paragraph contents changed and
// we need a redraw before further action is processed.
void Text::deleteEmptyParagraphMechanism(pit_type first, pit_type last, bool trackChanges)
{
- LASSERT(first >= 0 && first <= last && last < (int) pars_.size(), /**/);
+ LASSERT(first >= 0 && first <= last && last < (int) pars_.size(), return);
for (pit_type pit = first; pit <= last; ++pit) {
Paragraph & par = pars_[pit];
}
}
- // don't delete anything if this is the only remaining paragraph within the given range
- // note: Text::acceptOrRejectChanges() sets the cursor to 'first' after calling DEPM
+ // don't delete anything if this is the only remaining paragraph
+ // within the given range. Note: Text::acceptOrRejectChanges()
+ // sets the cursor to 'first' after calling DEPM
if (first == last)
continue;