#include "BufferList.h"
#include "BufferParams.h"
#include "BufferView.h"
-#include "Bullet.h"
#include "Changes.h"
#include "Cursor.h"
#include "CutAndPaste.h"
#include "TextMetrics.h"
#include "VSpace.h"
-#include "frontends/FontMetrics.h"
-
-#include "insets/InsetEnvironment.h"
+#include "insets/InsetCollapsable.h"
#include "mathed/InsetMathHull.h"
+#include "support/lassert.h"
#include "support/debug.h"
#include "support/gettext.h"
#include "support/textutils.h"
}
-FontInfo Text::getLayoutFont(Buffer const & buffer, pit_type const pit) const
+// Note that this is supposed to return a fully realized font.
+FontInfo Text::layoutFont(Buffer const & buffer, pit_type const pit) const
{
- LayoutPtr const & layout = pars_[pit].layout();
+ Layout const & layout = pars_[pit].layout();
if (!pars_[pit].getDepth()) {
- FontInfo lf = layout->resfont;
+ FontInfo lf = layout.resfont;
// In case the default family has been customized
- if (layout->font.family() == INHERIT_FAMILY)
+ if (layout.font.family() == INHERIT_FAMILY)
lf.setFamily(buffer.params().getFont().fontInfo().family());
- return lf;
+ // 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 = pars_[pit].inInset().asInsetCollapsable();
+ if (!icp)
+ return lf;
+ FontInfo icf = icp->getLayout().font();
+ icf.realize(lf);
+ return icf;
}
- FontInfo font = layout->font;
+ FontInfo font = layout.font;
// Realize with the fonts of lesser depth.
//font.realize(outerFont(pit, paragraphs()));
font.realize(buffer.params().getFont().fontInfo());
}
-FontInfo Text::getLabelFont(Buffer const & buffer, Paragraph const & par) const
+// Note that this is supposed to return a fully realized font.
+FontInfo Text::labelFont(Buffer const & buffer, Paragraph const & par) const
{
- LayoutPtr const & layout = par.layout();
+ Layout const & layout = par.layout();
if (!par.getDepth()) {
- FontInfo lf = layout->reslabelfont;
+ FontInfo lf = layout.reslabelfont;
// In case the default family has been customized
- if (layout->labelfont.family() == INHERIT_FAMILY)
+ if (layout.labelfont.family() == INHERIT_FAMILY)
lf.setFamily(buffer.params().getFont().fontInfo().family());
- return lf;
+ // FIXME As above....
+ InsetCollapsable const * icp = par.inInset().asInsetCollapsable();
+ if (!icp)
+ return lf;
+ FontInfo icf = icp->getLayout().labelfont();
+ icf.realize(lf);
+ return icf;
}
- FontInfo font = layout->labelfont;
+ FontInfo font = layout.labelfont;
// Realize with the fonts of lesser depth.
font.realize(buffer.params().getFont().fontInfo());
pos_type pos, Font const & fnt, Font const & display_font)
{
Font font = fnt;
- LayoutPtr const & layout = pars_[pit].layout();
+ Layout const & layout = pars_[pit].layout();
// Get concrete layout font to reduce against
FontInfo layoutfont;
if (pos < pars_[pit].beginOfBody())
- layoutfont = layout->labelfont;
+ layoutfont = layout.labelfont;
else
- layoutfont = layout->font;
+ layoutfont = layout.font;
// Realize against environment font information
if (pars_[pit].getDepth()) {
pars_[tp].getDepth()) {
tp = outerHook(tp, paragraphs());
if (tp != pit_type(paragraphs().size()))
- layoutfont.realize(pars_[tp].layout()->font);
+ layoutfont.realize(pars_[tp].layout().font);
}
}
pos_type pos, Font const & font, bool toggleall)
{
Inset * const inset = pars_[pit].getInset(pos);
- BOOST_ASSERT(inset && inset->noFontChange());
+ LASSERT(inset && inset->noFontChange(), /**/);
CursorSlice::idx_type endidx = inset->nargs();
for (CursorSlice cs(*inset); cs.idx() != endidx; ++cs.idx()) {
// return past-the-last paragraph influenced by a layout change on pit
pit_type Text::undoSpan(pit_type pit)
{
- pit_type end = paragraphs().size();
+ pit_type const end = paragraphs().size();
pit_type nextpit = pit + 1;
if (nextpit == end)
return nextpit;
void Text::setLayout(Buffer const & buffer, pit_type start, pit_type end,
docstring const & layout)
{
- BOOST_ASSERT(start != end);
+ LASSERT(start != end, /**/);
BufferParams const & bufparams = buffer.params();
- LayoutPtr const & lyxlayout = bufparams.getTextClass()[layout];
+ Layout const & lyxlayout = bufparams.documentClass()[layout];
for (pit_type pit = start; pit != end; ++pit) {
Paragraph & par = pars_[pit];
par.applyLayout(lyxlayout);
- if (lyxlayout->margintype == MARGIN_MANUAL)
+ if (lyxlayout.margintype == MARGIN_MANUAL)
par.setLabelWidthString(par.translateIfPossible(
- lyxlayout->labelstring(), buffer.params()));
+ lyxlayout.labelstring(), buffer.params()));
}
}
// set layout over selection and make a total rebreak of those paragraphs
void Text::setLayout(Cursor & cur, docstring const & layout)
{
- BOOST_ASSERT(this == cur.text());
- // special handling of new environment insets
- BufferView & bv = cur.bv();
- BufferParams const & params = bv.buffer().params();
- LayoutPtr const & lyxlayout = params.getTextClass()[layout];
- if (lyxlayout->is_environment) {
- // move everything in a new environment inset
- LYXERR(Debug::DEBUG, "setting layout " << to_utf8(layout));
- lyx::dispatch(FuncRequest(LFUN_LINE_BEGIN));
- lyx::dispatch(FuncRequest(LFUN_LINE_END_SELECT));
- lyx::dispatch(FuncRequest(LFUN_CUT));
- Inset * inset = new InsetEnvironment(params, layout);
- insertInset(cur, inset);
- //inset->edit(cur, true);
- //lyx::dispatch(FuncRequest(LFUN_PASTE));
- return;
- }
+ LASSERT(this == cur.text(), /**/);
pit_type start = cur.selBegin().pit();
pit_type end = cur.selEnd().pit() + 1;
static bool changeDepthAllowed(Text::DEPTH_CHANGE type,
Paragraph const & par, int max_depth)
{
- if (par.layout()->labeltype == LABEL_BIBLIO)
+ if (par.layout().labeltype == LABEL_BIBLIO)
return false;
int const depth = par.params().depth();
if (type == Text::INC_DEPTH && depth < max_depth)
bool Text::changeDepthAllowed(Cursor & cur, DEPTH_CHANGE type) const
{
- BOOST_ASSERT(this == cur.text());
+ LASSERT(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)
{
- BOOST_ASSERT(this == cur.text());
+ LASSERT(this == cur.text(), /**/);
pit_type const beg = cur.selBegin().pit();
pit_type const end = cur.selEnd().pit() + 1;
cur.recordUndoSelection();
void Text::setFont(Cursor & cur, Font const & font, bool toggleall)
{
- BOOST_ASSERT(this == cur.text());
+ LASSERT(this == cur.text(), /**/);
// Set the current_font
// Determine basis font
FontInfo layoutfont;
pit_type pit = cur.pit();
if (cur.pos() < pars_[pit].beginOfBody())
- layoutfont = getLabelFont(cur.buffer(), pars_[pit]);
+ layoutfont = labelFont(cur.buffer(), pars_[pit]);
else
- layoutfont = getLayoutFont(cur.buffer(), pit);
+ layoutfont = layoutFont(cur.buffer(), pit);
// Update current font
cur.real_current_font.update(font,
// nested insets.
Language const * language = buffer.params().language;
for (CursorSlice dit = begin; dit != end; dit.forwardPos()) {
- if (dit.pos() != dit.lastpos()) {
- pit_type const pit = dit.pit();
- pos_type const pos = dit.pos();
- Inset * inset = pars_[pit].getInset(pos);
- if (inset && inset->noFontChange()) {
- // 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);
- }
- TextMetrics const & tm = bv.textMetrics(this);
- Font f = tm.getDisplayFont(pit, pos);
- f.update(font, language, toggleall);
- setCharFont(buffer, pit, pos, f, tm.font_);
+ if (dit.pos() == dit.lastpos())
+ continue;
+ pit_type const pit = dit.pit();
+ pos_type const pos = dit.pos();
+ Inset * inset = pars_[pit].getInset(pos);
+ if (inset && inset->noFontChange()) {
+ // 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);
}
+ TextMetrics const & tm = bv.textMetrics(this);
+ Font f = tm.displayFont(pit, pos);
+ f.update(font, language, toggleall);
+ setCharFont(buffer, pit, pos, f, tm.font_);
}
}
bool Text::cursorTop(Cursor & cur)
{
- BOOST_ASSERT(this == cur.text());
+ LASSERT(this == cur.text(), /**/);
return setCursor(cur, 0, 0);
}
bool Text::cursorBottom(Cursor & cur)
{
- BOOST_ASSERT(this == cur.text());
+ LASSERT(this == cur.text(), /**/);
return setCursor(cur, cur.lastpit(), boost::prior(paragraphs().end())->size());
}
void Text::toggleFree(Cursor & cur, Font const & font, bool toggleall)
{
- BOOST_ASSERT(this == cur.text());
+ LASSERT(this == cur.text(), /**/);
// If the mask is completely neutral, tell user
- if (font.fontInfo() == ignore_font &&
- (font.language() == 0 || font.language() == ignore_language)) {
+ if (font.fontInfo() == ignore_font && font.language() == ignore_language) {
// Could only happen with user style
cur.message(_("No font change defined."));
return;
docstring Text::getStringToIndex(Cursor const & cur)
{
- BOOST_ASSERT(this == cur.text());
+ LASSERT(this == cur.text(), /**/);
- docstring idxstring;
if (cur.selection())
- idxstring = cur.selectionAsString(false);
- else {
- // Try implicit word selection. If there is a change
- // in the language the implicit word selection is
- // disabled.
- Cursor tmpcur = cur;
- selectWord(tmpcur, PREVIOUS_WORD);
-
- if (!tmpcur.selection())
- cur.message(_("Nothing to index!"));
- else if (tmpcur.selBegin().pit() != tmpcur.selEnd().pit())
- cur.message(_("Cannot index more than one paragraph!"));
- else
- idxstring = tmpcur.selectionAsString(false);
- }
-
- return idxstring;
+ return cur.selectionAsString(false);
+
+ // Try implicit word selection. If there is a change
+ // in the language the implicit word selection is
+ // disabled.
+ Cursor tmpcur = cur;
+ selectWord(tmpcur, PREVIOUS_WORD);
+
+ if (!tmpcur.selection())
+ cur.message(_("Nothing to index!"));
+ else if (tmpcur.selBegin().pit() != tmpcur.selEnd().pit())
+ cur.message(_("Cannot index more than one paragraph!"));
+ else
+ return tmpcur.selectionAsString(false);
+
+ return docstring();
}
void Text::setParagraphs(Cursor & cur, docstring arg, bool merge)
{
- BOOST_ASSERT(cur.text());
+ 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);
+ //FIXME UNICODE
+ string const argument = to_utf8(arg);
for (pit_type pit = cur.selBegin().pit(), end = cur.selEnd().pit();
pit <= end; ++pit) {
Paragraph & par = pars_[pit];
ParagraphParameters params = par.params();
- params.read(to_utf8(arg), merge);
- Layout const & layout = *(par.layout());
- par.params().apply(params, layout);
+ params.read(argument, merge);
+ par.params().apply(params, par.layout());
}
}
//quite so much.
void Text::setParagraphs(Cursor & cur, ParagraphParameters const & p)
{
- BOOST_ASSERT(cur.text());
+ 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);
for (pit_type pit = cur.selBegin().pit(), end = cur.selEnd().pit();
pit <= end; ++pit) {
Paragraph & par = pars_[pit];
- Layout const & layout = *(par.layout());
- par.params().apply(p, layout);
+ par.params().apply(p, par.layout());
}
}
// this really should just insert the inset and not move the cursor.
void Text::insertInset(Cursor & cur, Inset * inset)
{
- BOOST_ASSERT(this == cur.text());
- BOOST_ASSERT(inset);
+ LASSERT(this == cur.text(), /**/);
+ LASSERT(inset, /**/);
cur.paragraph().insertInset(cur.pos(), inset, cur.current_font,
- Change(cur.buffer().params().trackChanges ?
- Change::INSERTED : Change::UNCHANGED));
+ Change(cur.buffer().params().trackChanges
+ ? Change::INSERTED : Change::UNCHANGED));
}
void Text::insertStringAsLines(Cursor & cur, docstring const & str)
{
cur.buffer().insertStringAsLines(pars_, cur.pit(), cur.pos(),
- cur.current_font, str, autoBreakRows_);
+ cur.current_font, str, autoBreakRows_);
}
bool Text::setCursor(Cursor & cur, pit_type par, pos_type pos,
bool setfont, bool boundary)
{
+ TextMetrics const & tm = cur.bv().textMetrics(this);
+ bool const update_needed = !tm.contains(par);
Cursor old = cur;
setCursorIntern(cur, par, pos, setfont, boundary);
- return cur.bv().checkDepm(cur, old);
+ return cur.bv().checkDepm(cur, old) || update_needed;
}
void Text::setCursor(CursorSlice & cur, pit_type par, pos_type pos)
{
- BOOST_ASSERT(par != int(paragraphs().size()));
+ LASSERT(par != int(paragraphs().size()), /**/);
cur.pit() = par;
cur.pos() = pos;
// None of these should happen, but we're scaredy-cats
if (pos < 0) {
lyxerr << "dont like -1" << endl;
- BOOST_ASSERT(false);
+ LASSERT(false, /**/);
}
if (pos > para.size()) {
lyxerr << "dont like 1, pos: " << pos
<< " size: " << para.size()
<< " par: " << par << endl;
- BOOST_ASSERT(false);
+ LASSERT(false, /**/);
}
}
void Text::setCursorIntern(Cursor & cur,
pit_type par, pos_type pos, bool setfont, bool boundary)
{
- BOOST_ASSERT(this == cur.text());
+ LASSERT(this == cur.text(), /**/);
cur.boundary(boundary);
setCursor(cur.top(), par, pos);
if (setfont)
if (!inset || inset->editable() != Inset::HIGHLY_EDITABLE)
return false;
inset->edit(cur, movingForward,
- movingLeft ? Inset::ENTER_FROM_RIGHT : Inset::ENTER_FROM_LEFT);
+ movingLeft ? Inset::ENTRY_DIRECTION_RIGHT : Inset::ENTRY_DIRECTION_LEFT);
return true;
}
bool Text::cursorVisLeft(Cursor & cur, bool skip_inset)
{
- pit_type new_pit = cur.pit(); // the paragraph to which we will move
- pos_type new_pos; // the position we will move to
- bool new_boundary; // will we move to a boundary position?
- pos_type left_pos; // position visually left of current cursor
- pos_type right_pos; // position visually right of current cursor
- bool new_pos_is_RTL; // is new position we're moving to RTL?
-
- cur.getSurroundingPos(left_pos, right_pos);
-
- LYXERR(Debug::RTL, left_pos <<"|"<< right_pos << " (pos: "<<cur.pos()<<")");
-
- // Are we at an inset?
Cursor temp_cur = cur;
- temp_cur.pos() = left_pos;
- temp_cur.boundary(false);
- if (!skip_inset &&
- checkAndActivateInsetVisual(temp_cur, left_pos >= cur.pos(), true)) {
- LYXERR(Debug::RTL, "entering inset at: " << temp_cur.pos());
- cur = temp_cur; // set the real cursor to new position inside inset!
+ temp_cur.posVisLeft(skip_inset);
+ if (temp_cur.depth() > cur.depth()) {
+ cur = temp_cur;
return false;
}
-
- // Are we already at leftmost pos in row?
- if (left_pos == -1) {
-
- Cursor new_cur = cur;
- if (!new_cur.posVisToNewRow(true)) {
- LYXERR(Debug::RTL, "not moving!");
- return false;
- }
-
- // we actually move the cursor at the end of this function, for now
- // just keep track of the new position...
- new_pit = new_cur.pit();
- new_pos = new_cur.pos();
- new_boundary = new_cur.boundary();
-
- LYXERR(Debug::RTL, "left edge, moving: " << int(new_pit) << ","
- << int(new_pos) << "," << (new_boundary ? 1 : 0));
-
- }
- // normal movement to the left
- else {
- // Recall, if the cursor is at position 'x', that means *before*
- // the character at position 'x'. In RTL, "before" means "to the
- // right of", in LTR, "to the left of". So currently our situation
- // is this: the position to our left is 'left_pos' (i.e., we're
- // currently to the right of 'left_pos'). In order to move to the
- // left, it depends whether or not the character at 'left_pos' is RTL.
- new_pos_is_RTL = cur.paragraph().getFontSettings(
- cur.bv().buffer().params(), left_pos).isVisibleRightToLeft();
- // If the character at 'left_pos' *is* RTL, then in order to move to
- // the left of it, we need to be *after* 'left_pos', i.e., move to
- // position 'left_pos' + 1.
- if (new_pos_is_RTL) {
- new_pos = left_pos + 1;
- // if the position *after* left_pos is not RTL, set boundary to
- // true (we want to be *after* left_pos, not before left_pos + 1!)
- new_boundary = !cur.paragraph().getFontSettings(
- cur.bv().buffer().params(), new_pos).isVisibleRightToLeft();
- }
- // Otherwise (if the character at position 'left_pos' is LTR), then
- // moving to the left of it is as easy as setting the new position
- // to 'left_pos'.
- else {
- new_pos = left_pos;
- new_boundary = false;
- }
-
- }
-
- LYXERR(Debug::RTL, "moving to: " << new_pos
- << (new_boundary ? " (boundary)" : ""));
-
- return setCursor(cur, new_pit, new_pos, true, new_boundary);
+ return setCursor(cur, temp_cur.pit(), temp_cur.pos(),
+ true, temp_cur.boundary());
}
bool Text::cursorVisRight(Cursor & cur, bool skip_inset)
{
- pit_type new_pit = cur.pit(); // the paragraph to which we will move
- pos_type new_pos; // the position we will move to
- bool new_boundary; // will we move to a boundary position?
- pos_type left_pos; // position visually left of current cursor
- pos_type right_pos; // position visually right of current cursor
- bool new_pos_is_RTL; // is new position we're moving to RTL?
-
- cur.getSurroundingPos(left_pos, right_pos);
-
- LYXERR(Debug::RTL, left_pos <<"|"<< right_pos << " (pos: "<<cur.pos()<<")");
-
- // Are we at an inset?
Cursor temp_cur = cur;
- temp_cur.pos() = right_pos;
- temp_cur.boundary(false);
- if (!skip_inset &&
- checkAndActivateInsetVisual(temp_cur, right_pos >= cur.pos(), false)) {
- LYXERR(Debug::RTL, "entering inset at: " << temp_cur.pos());
- cur = temp_cur; // set the real cursor to new position inside inset!
+ temp_cur.posVisRight(skip_inset);
+ if (temp_cur.depth() > cur.depth()) {
+ cur = temp_cur;
return false;
}
-
- // Are we already at rightmost pos in row?
- if (right_pos == -1) {
-
- Cursor new_cur = cur;
- if (!new_cur.posVisToNewRow(false)) {
- LYXERR(Debug::RTL, "not moving!");
- return false;
- }
-
- // we actually move the cursor at the end of this function, for now
- // just keep track of the new position...
- new_pit = new_cur.pit();
- new_pos = new_cur.pos();
- new_boundary = new_cur.boundary();
-
- LYXERR(Debug::RTL, "right edge, moving: " << int(new_pit) << ","
- << int(new_pos) << "," << (new_boundary ? 1 : 0));
-
- }
- // normal movement to the right
- else {
- // Recall, if the cursor is at position 'x', that means *before*
- // the character at position 'x'. In RTL, "before" means "to the
- // right of", in LTR, "to the left of". So currently our situation
- // is this: the position to our right is 'right_pos' (i.e., we're
- // currently to the left of 'right_pos'). In order to move to the
- // right, it depends whether or not the character at 'right_pos' is RTL.
- new_pos_is_RTL = cur.paragraph().getFontSettings(
- cur.bv().buffer().params(), right_pos).isVisibleRightToLeft();
- // If the character at 'right_pos' *is* LTR, then in order to move to
- // the right of it, we need to be *after* 'right_pos', i.e., move to
- // position 'right_pos' + 1.
- if (!new_pos_is_RTL) {
- new_pos = right_pos + 1;
- // if the position *after* right_pos is RTL, set boundary to
- // true (we want to be *after* right_pos, not before right_pos + 1!)
- new_boundary = cur.paragraph().getFontSettings(
- cur.bv().buffer().params(), new_pos).isVisibleRightToLeft();
- }
- // Otherwise (if the character at position 'right_pos' is RTL), then
- // moving to the right of it is as easy as setting the new position
- // to 'right_pos'.
- else {
- new_pos = right_pos;
- new_boundary = false;
- }
-
- }
-
- LYXERR(Debug::RTL, "moving to: " << new_pos
- << (new_boundary ? " (boundary)" : ""));
-
- return setCursor(cur, new_pit, new_pos, true, new_boundary);
+ return setCursor(cur, temp_cur.pit(), temp_cur.pos(),
+ true, temp_cur.boundary());
}
void Text::deleteEmptyParagraphMechanism(pit_type first, pit_type last, bool trackChanges)
{
- BOOST_ASSERT(first >= 0 && first <= last && last < (int) pars_.size());
+ LASSERT(first >= 0 && first <= last && last < (int) pars_.size(), /**/);
for (pit_type pit = first; pit <= last; ++pit) {
Paragraph & par = pars_[pit];