* Licence details can be found in the file COPYING.
*
* \author Asger Alstrup
- * \author Lars Gullik Bjønnes
+ * \author Lars Gullik Bjønnes
* \author Alfredo Braunstein
* \author Jean-Marc Lasgouttes
* \author Angus Leeming
* \author John Levon
- * \author André Pönitz
+ * \author André Pönitz
* \author Allan Rae
* \author Stefan Schimanski
* \author Dekel Tsur
- * \author Jürgen Vigna
+ * \author Jürgen Vigna
*
* Full author contact details are available in file CREDITS.
*/
#include "Text.h"
+#include "Bidi.h"
#include "Buffer.h"
#include "buffer_funcs.h"
#include "BufferList.h"
#include "BufferParams.h"
#include "BufferView.h"
-#include "bufferview_funcs.h"
-#include "Bullet.h"
-#include "Color.h"
-#include "CoordCache.h"
+#include "Changes.h"
#include "Cursor.h"
#include "CutAndPaste.h"
-#include "debug.h"
#include "DispatchResult.h"
#include "ErrorList.h"
-#include "FuncRequest.h"
-#include "gettext.h"
#include "Language.h"
+#include "Layout.h"
#include "Lexer.h"
-#include "LyXFunc.h"
+#include "LyX.h"
#include "LyXRC.h"
-#include "Row.h"
#include "Paragraph.h"
-#include "TextMetrics.h"
-#include "paragraph_funcs.h"
#include "ParagraphParameters.h"
-#include "ParIterator.h"
-#include "Server.h"
-#include "ServerSocket.h"
-#include "Undo.h"
-#include "VSpace.h"
-
-#include "frontends/FontMetrics.h"
+#include "TextClass.h"
+#include "TextMetrics.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"
-#include <boost/current_function.hpp>
+#include <boost/next_prior.hpp>
#include <sstream>
+using namespace std;
namespace lyx {
-using std::endl;
-using std::ostringstream;
-using std::string;
-using std::max;
-using std::min;
-using std::istringstream;
-
-Text::Text()
- : current_font(Font::ALL_INHERIT),
- background_color_(Color::background),
- autoBreakRows_(false)
-{}
-
-
-bool Text::isMainText(Buffer const & buffer) const
+bool Text::isMainText() const
{
- return &buffer.text() == this;
+ return &owner_->buffer().text() == this;
}
-//takes screen x,y coordinates
-Inset * Text::checkInsetHit(BufferView & bv, int x, int y)
+// Note that this is supposed to return a fully realized font.
+FontInfo Text::layoutFont(pit_type const pit) const
{
- pit_type pit = getPitNearY(bv, y);
- BOOST_ASSERT(pit != -1);
-
- Paragraph const & par = pars_[pit];
-
- LYXERR(Debug::DEBUG)
- << BOOST_CURRENT_FUNCTION
- << ": x: " << x
- << " y: " << y
- << " pit: " << pit
- << endl;
- InsetList::const_iterator iit = par.insetlist.begin();
- InsetList::const_iterator iend = par.insetlist.end();
- for (; iit != iend; ++iit) {
- Inset * inset = iit->inset;
-#if 1
- LYXERR(Debug::DEBUG)
- << BOOST_CURRENT_FUNCTION
- << ": examining inset " << inset << endl;
-
- if (bv.coordCache().getInsets().has(inset))
- LYXERR(Debug::DEBUG)
- << BOOST_CURRENT_FUNCTION
- << ": xo: " << inset->xo(bv) << "..."
- << inset->xo(bv) + inset->width()
- << " yo: " << inset->yo(bv) - inset->ascent()
- << "..."
- << inset->yo(bv) + inset->descent()
- << endl;
- else
- LYXERR(Debug::DEBUG)
- << BOOST_CURRENT_FUNCTION
- << ": inset has no cached position" << endl;
-#endif
- if (inset->covers(bv, x, y)) {
- LYXERR(Debug::DEBUG)
- << BOOST_CURRENT_FUNCTION
- << ": Hit inset: " << inset << endl;
- return inset;
- }
- }
- LYXERR(Debug::DEBUG)
- << BOOST_CURRENT_FUNCTION
- << ": No inset hit. " << endl;
- return 0;
-}
-
-
-
-// Gets the fully instantiated font at a given position in a paragraph
-// Basically the same routine as Paragraph::getFont() in Paragraph.cpp.
-// The difference is that this one is used for displaying, and thus we
-// are allowed to make cosmetic improvements. For instance make footnotes
-// smaller. (Asger)
-Font Text::getFont(Buffer const & buffer, Paragraph const & par,
- pos_type const pos) const
-{
- BOOST_ASSERT(pos >= 0);
-
- Layout_ptr const & layout = par.layout();
- // FIXME: broken?
- BufferParams const & params = buffer.params();
- pos_type const body_pos = par.beginOfBody();
-
- // We specialize the 95% common case:
- if (!par.getDepth()) {
- Font f = par.getFontSettings(params, pos);
- if (!isMainText(buffer))
- applyOuterFont(buffer, f);
- Font lf;
- Font rlf;
- if (layout->labeltype == LABEL_MANUAL && pos < body_pos) {
- lf = layout->labelfont;
- rlf = layout->reslabelfont;
- } else {
- lf = layout->font;
- rlf = layout->resfont;
- }
- // In case the default family has been customized
- if (lf.family() == Font::INHERIT_FAMILY)
- rlf.setFamily(params.getFont().family());
- return f.realize(rlf);
- }
-
- // The uncommon case need not be optimized as much
- Font layoutfont;
- if (pos < body_pos)
- layoutfont = layout->labelfont;
- else
- layoutfont = layout->font;
-
- Font font = par.getFontSettings(params, pos);
- font.realize(layoutfont);
-
- if (!isMainText(buffer))
- applyOuterFont(buffer, font);
-
- // Find the pit value belonging to paragraph. This will not break
- // even if pars_ would not be a vector anymore.
- // Performance appears acceptable.
-
- pit_type pit = pars_.size();
- for (pit_type it = 0; it < pit; ++it)
- if (&pars_[it] == &par) {
- pit = it;
- break;
- }
- // Realize against environment font information
- // NOTE: the cast to pit_type should be removed when pit_type
- // changes to a unsigned integer.
- if (pit < pit_type(pars_.size()))
- font.realize(outerFont(pit, pars_));
-
- // Realize with the fonts of lesser depth.
- font.realize(params.getFont());
-
- return font;
-}
-
-// There are currently two font mechanisms in LyX:
-// 1. The font attributes in a lyxtext, and
-// 2. The inset-specific font properties, defined in an inset's
-// metrics() and draw() methods and handed down the inset chain through
-// the pi/mi parameters, and stored locally in a lyxtext in font_.
-// This is where the two are integrated in the final fully realized
-// font.
-void Text::applyOuterFont(Buffer const & buffer, Font & font) const {
- Font lf(font_);
- lf.reduce(buffer.params().getFont());
- lf.realize(font);
- lf.setLanguage(font.language());
- font = lf;
-}
-
-
-Font Text::getLayoutFont(Buffer const & buffer, pit_type const pit) const
-{
- Layout_ptr const & layout = pars_[pit].layout();
+ Layout const & layout = pars_[pit].layout();
if (!pars_[pit].getDepth()) {
- Font lf = layout->resfont;
+ FontInfo lf = layout.resfont;
// In case the default family has been customized
- if (layout->font.family() == Font::INHERIT_FAMILY)
- lf.setFamily(buffer.params().getFont().family());
- return lf;
+ if (layout.font.family() == INHERIT_FAMILY)
+ lf.setFamily(owner_->buffer().params().getFont().fontInfo().family());
+ FontInfo icf = owner_->getLayout().font();
+ icf.realize(lf);
+ return icf;
}
- Font font = layout->font;
+ FontInfo font = layout.font;
// Realize with the fonts of lesser depth.
- //font.realize(outerFont(pit, paragraphs()));
- font.realize(buffer.params().getFont());
+ //font.realize(outerFont(pit));
+ font.realize(owner_->buffer().params().getFont().fontInfo());
return font;
}
-Font Text::getLabelFont(Buffer const & buffer, Paragraph const & par) const
+// Note that this is supposed to return a fully realized font.
+FontInfo Text::labelFont(Paragraph const & par) const
{
- Layout_ptr const & layout = par.layout();
+ Buffer const & buffer = owner_->buffer();
+ Layout const & layout = par.layout();
if (!par.getDepth()) {
- Font lf = layout->reslabelfont;
+ FontInfo lf = layout.reslabelfont;
// In case the default family has been customized
- if (layout->labelfont.family() == Font::INHERIT_FAMILY)
- lf.setFamily(buffer.params().getFont().family());
+ if (layout.labelfont.family() == INHERIT_FAMILY)
+ lf.setFamily(buffer.params().getFont().fontInfo().family());
return lf;
}
- Font font = layout->labelfont;
+ FontInfo font = layout.labelfont;
// Realize with the fonts of lesser depth.
- font.realize(buffer.params().getFont());
+ font.realize(buffer.params().getFont().fontInfo());
return font;
}
-void Text::setCharFont(Buffer const & buffer, pit_type pit,
- pos_type pos, Font const & fnt)
+void Text::setCharFont(pit_type pit,
+ pos_type pos, Font const & fnt, Font const & display_font)
{
+ Buffer const & buffer = owner_->buffer();
Font font = fnt;
- Layout_ptr const & layout = pars_[pit].layout();
+ Layout const & layout = pars_[pit].layout();
// Get concrete layout font to reduce against
- Font layoutfont;
+ 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()) {
while (!layoutfont.resolved() &&
tp != pit_type(paragraphs().size()) &&
pars_[tp].getDepth()) {
- tp = outerHook(tp, paragraphs());
+ tp = outerHook(tp);
if (tp != pit_type(paragraphs().size()))
- layoutfont.realize(pars_[tp].layout()->font);
+ layoutfont.realize(pars_[tp].layout().font);
}
}
// Inside inset, apply the inset's font attributes if any
// (charstyle!)
- if (!isMainText(buffer))
- layoutfont.realize(font_);
+ if (!isMainText())
+ layoutfont.realize(display_font.fontInfo());
- layoutfont.realize(buffer.params().getFont());
+ layoutfont.realize(buffer.params().getFont().fontInfo());
// Now, reduce font against full layout font
- font.reduce(layoutfont);
+ font.fontInfo().reduce(layoutfont);
pars_[pit].setFont(pos, font);
}
-void Text::setInsetFont(Buffer const & buffer, pit_type pit,
- pos_type pos, Font const & font, bool toggleall)
+void Text::setInsetFont(BufferView const & bv, pit_type pit,
+ pos_type pos, Font const & font)
{
- BOOST_ASSERT(pars_[pit].isInset(pos) &&
- pars_[pit].getInset(pos)->noFontChange());
-
Inset * const inset = pars_[pit].getInset(pos);
+ LASSERT(inset && inset->resetFontEdit(), /**/);
+
CursorSlice::idx_type endidx = inset->nargs();
for (CursorSlice cs(*inset); cs.idx() != endidx; ++cs.idx()) {
Text * text = cs.text();
CursorSlice cellend = cs;
cellend.pit() = cellend.lastpit();
cellend.pos() = cellend.lastpos();
- text->setFont(buffer, 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 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)
+void Text::setLayout(pit_type start, pit_type end,
+ docstring const & layout)
{
- BOOST_ASSERT(start != end);
+ LASSERT(start != end, /**/);
- BufferParams const & bufparams = buffer.params();
- Layout_ptr const & lyxlayout = bufparams.getTextClass()[layout];
+ Buffer const & buffer = owner_->buffer();
+ BufferParams const & bp = buffer.params();
+ Layout const & lyxlayout = bp.documentClass()[layout];
for (pit_type pit = start; pit != end; ++pit) {
Paragraph & par = pars_[pit];
par.applyLayout(lyxlayout);
- if (lyxlayout->margintype == MARGIN_MANUAL)
- par.setLabelWidthString(par.translateIfPossible(
- lyxlayout->labelstring(), buffer.params()));
+ if (lyxlayout.margintype == MARGIN_MANUAL)
+ par.setLabelWidthString(par.expandLabel(lyxlayout, bp));
}
}
// 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();
- Layout_ptr const & lyxlayout = params.getTextClass()[layout];
- if (lyxlayout->is_environment) {
- // move everything in a new environment inset
- LYXERR(Debug::DEBUG) << "setting layout " << to_utf8(layout) << endl;
- 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;
pit_type undopit = undoSpan(end - 1);
recUndo(cur, start, undopit - 1);
- setLayout(cur.buffer(), start, end, layout);
- updateLabels(cur.buffer());
+ setLayout(start, end, layout);
+ cur.forceBufferUpdate();
}
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;
- recordUndoSelection(cur);
+ cur.recordUndoSelection();
int max_depth = (beg != 0 ? pars_[beg - 1].getMaxDepthAfter() : 0);
for (pit_type pit = beg; pit != end; ++pit) {
}
// this handles the counter labels, and also fixes up
// depth values for follow-on (child) paragraphs
- updateLabels(cur.buffer());
+ cur.forceBufferUpdate();
}
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
- Font layoutfont;
+ FontInfo layoutfont;
pit_type pit = cur.pit();
if (cur.pos() < pars_[pit].beginOfBody())
- layoutfont = getLabelFont(cur.buffer(), pars_[pit]);
+ layoutfont = labelFont(pars_[pit]);
else
- layoutfont = getLayoutFont(cur.buffer(), pit);
+ layoutfont = layoutFont(pit);
// Update current font
- real_current_font.update(font,
- cur.buffer().params().language,
+ cur.real_current_font.update(font,
+ cur.buffer()->params().language,
toggleall);
// Reduce to implicit settings
- current_font = real_current_font;
- current_font.reduce(layoutfont);
+ cur.current_font = cur.real_current_font;
+ cur.current_font.fontInfo().reduce(layoutfont);
// And resolve it completely
- real_current_font.realize(layoutfont);
+ cur.real_current_font.fontInfo().realize(layoutfont);
// if there is no selection that's all we need to do
if (!cur.selection())
return;
// Ok, we have a selection.
- recordUndoSelection(cur);
-
- setFont(cur.buffer(), cur.selectionBegin().top(),
- cur.selectionEnd().top(), font, toggleall);
-}
-
+ 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(), newfont);
+}
+
+
+void Text::setFont(BufferView const & bv, CursorSlice const & begin,
+ CursorSlice const & end, Font const & font)
+{
+ Buffer const & buffer = bv.buffer();
-void Text::setFont(Buffer const & buffer, CursorSlice const & begin,
- CursorSlice const & end, Font const & font,
- bool toggleall)
-{
// Don't use forwardChar here as ditend might have
// pos() == lastpos() and forwardChar would miss it.
// Can't use forwardPos either as this descends into
// 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();
- if (pars_[pit].isInset(pos) &&
- pars_[pit].getInset(pos)->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(buffer, pit, pos, font, toggleall);
- Font f = getFont(buffer, dit.paragraph(), pos);
- f.update(font, language, toggleall);
- setCharFont(buffer, pit, pos, f);
+ 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->resetFontEdit()) {
+ // We need to propagate the font change to all
+ // 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);
+ setCharFont(pit, pos, f, tm.font_);
+ // font change may change language...
+ // spell checker has to know that
+ pars_[pit].requestSpellCheck(pos);
}
}
-// the cursor set functions have a special mechanism. When they
-// realize you left an empty paragraph, they will delete it.
-
-bool Text::cursorHome(Cursor & cur)
-{
- BOOST_ASSERT(this == cur.text());
- ParagraphMetrics const & pm = cur.bv().parMetrics(this, cur.pit());
- Row const & row = pm.getRow(cur.pos(),cur.boundary());
- return setCursor(cur, cur.pit(), row.pos());
-}
-
-
-bool Text::cursorEnd(Cursor & cur)
-{
- BOOST_ASSERT(this == cur.text());
- // if not on the last row of the par, put the cursor before
- // the final space exept if I have a spanning inset or one string
- // is so long that we force a break.
- pos_type end = cur.textRow().endpos();
- if (end == 0)
- // empty text, end-1 is no valid position
- return false;
- bool boundary = false;
- if (end != cur.lastpos()) {
- if (!cur.paragraph().isLineSeparator(end-1)
- && !cur.paragraph().isNewline(end-1))
- boundary = true;
- else
- --end;
- }
- return setCursor(cur, cur.pit(), end, true, boundary);
-}
-
-
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 == Font(Font::ALL_IGNORE)) {
+ if (font.fontInfo() == ignore_font && font.language() == ignore_language) {
// Could only happen with user style
cur.message(_("No font change defined."));
return;
// Try implicit word selection
// If there is a change in the language the implicit word selection
// is disabled.
- CursorSlice resetCursor = cur.top();
- bool implicitSelection =
+ CursorSlice const resetCursor = cur.top();
+ bool const implicitSelection =
font.language() == ignore_language
- && font.number() == Font::IGNORE
+ && font.fontInfo().number() == FONT_IGNORE
&& selectWordWhenUnderCursor(cur, WHOLE_WORD_STRICT);
// Set font
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 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::setLabelWidthStringToSequence(pit_type const par_offset,
+ docstring const & s)
+{
+ pit_type offset = par_offset;
+ // Find first of same layout in sequence
+ while (!isFirstInSequence(offset)) {
+ offset = depthHook(offset, pars_[offset].getDepth());
}
- return idxstring;
+ // 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 (pit == end)
+ return;
+ }
+ if (pars_[pit].getDepth() < depth)
+ return;
+ if (pars_[pit].layout() != layout)
+ return;
+ pars_[pit].setLabelWidthString(s);
+ }
}
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);
+ depth_type priordepth = -1;
+ Layout priorlayout;
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);
+ // 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());
+ par.params().apply(params, par.layout());
+ priordepth = par.getDepth();
+ priorlayout = 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);
+ depth_type priordepth = -1;
+ Layout priorlayout;
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);
- }
+ // 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,
+ 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)
{
- BOOST_ASSERT(this == cur.text());
- BOOST_ASSERT(inset);
- cur.paragraph().insertInset(cur.pos(), inset, current_font,
- Change(cur.buffer().params().trackChanges ?
- Change::INSERTED : Change::UNCHANGED));
-}
-
-
-// needed to insert the selection
-void Text::insertStringAsLines(Cursor & cur, docstring const & str)
-{
- cur.buffer().insertStringAsLines(pars_, cur.pit(), cur.pos(),
- current_font, str, autoBreakRows_);
-}
-
-
-// turn double CR to single CR, others are converted into one
-// blank. Then insertStringAsLines is called
-void Text::insertStringAsParagraphs(Cursor & cur, docstring const & str)
-{
- docstring linestr = str;
- bool newline_inserted = false;
-
- for (string::size_type i = 0, siz = linestr.size(); i < siz; ++i) {
- if (linestr[i] == '\n') {
- if (newline_inserted) {
- // we know that \r will be ignored by
- // insertStringAsLines. Of course, it is a dirty
- // trick, but it works...
- linestr[i - 1] = '\r';
- linestr[i] = '\n';
- } else {
- linestr[i] = ' ';
- newline_inserted = true;
- }
- } else if (isPrintable(linestr[i])) {
- newline_inserted = false;
- }
- }
- insertStringAsLines(cur, linestr);
+ LASSERT(this == cur.text(), /**/);
+ LASSERT(inset, /**/);
+ cur.paragraph().insertInset(cur.pos(), inset, cur.current_font,
+ Change(cur.buffer()->params().trackChanges
+ ? Change::INSERTED : Change::UNCHANGED));
}
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);
+ // FIXME There is a chance that we'll miss a screen update here.
+ // If so, then do DEPM and then check if cur wants an update and
+ // go ahead and do it, if so.
+ 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);
+ lyxerr << "don't like -1" << endl;
+ LASSERT(false, /**/);
}
if (pos > para.size()) {
- lyxerr << "dont like 1, pos: " << pos
+ lyxerr << "don't 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)
- setCurrentFont(cur);
-}
-
-
-void Text::setCurrentFont(Cursor & cur)
-{
- BOOST_ASSERT(this == cur.text());
- pos_type pos = cur.pos();
- Paragraph & par = cur.paragraph();
-
- // are we behind previous char in fact? -> go to that char
- if (pos > 0 && cur.boundary())
- --pos;
-
- // find position to take the font from
- if (pos != 0) {
- // paragraph end? -> font of last char
- if (pos == cur.lastpos())
- --pos;
- // on space? -> look at the words in front of space
- else if (pos > 0 && par.isSeparator(pos)) {
- // abc| def -> font of c
- // abc |[WERBEH], i.e. boundary==true -> font of c
- // abc [WERBEH]| def, font of the space
- if (!isRTLBoundary(cur.buffer(), par, pos))
- --pos;
- }
- }
-
- // get font
- BufferParams const & bufparams = cur.buffer().params();
- current_font = par.getFontSettings(bufparams, pos);
- real_current_font = getFont(cur.buffer(), par, pos);
-
- // special case for paragraph end
- if (cur.pos() == cur.lastpos()
- && isRTLBoundary(cur.buffer(), par, cur.pos())
- && !cur.boundary()) {
- Language const * lang = par.getParLanguage(bufparams);
- current_font.setLanguage(lang);
- current_font.setNumber(Font::OFF);
- real_current_font.setLanguage(lang);
- real_current_font.setNumber(Font::OFF);
- }
-}
-
-// y is screen coordinate
-pit_type Text::getPitNearY(BufferView & bv, int y) const
-{
- BOOST_ASSERT(!paragraphs().empty());
- BOOST_ASSERT(bv.coordCache().getParPos().find(this) != bv.coordCache().getParPos().end());
- CoordCache::InnerParPosCache const & cc = bv.coordCache().getParPos().find(this)->second;
- LYXERR(Debug::DEBUG)
- << BOOST_CURRENT_FUNCTION
- << ": y: " << y << " cache size: " << cc.size()
- << endl;
-
- // look for highest numbered paragraph with y coordinate less than given y
- pit_type pit = 0;
- int yy = -1;
- CoordCache::InnerParPosCache::const_iterator it = cc.begin();
- CoordCache::InnerParPosCache::const_iterator et = cc.end();
- CoordCache::InnerParPosCache::const_iterator last = et; last--;
-
- TextMetrics & tm = bv.textMetrics(this);
- ParagraphMetrics const & pm = tm.parMetrics(it->first);
-
- // If we are off-screen (before the visible part)
- if (y < 0
- // and even before the first paragraph in the cache.
- && y < it->second.y_ - int(pm.ascent())) {
- // and we are not at the first paragraph in the inset.
- if (it->first == 0)
- return 0;
- // then this is the paragraph we are looking for.
- pit = it->first - 1;
- // rebreak it and update the CoordCache.
- tm.redoParagraph(pit);
- bv.coordCache().parPos()[this][pit] =
- Point(0, it->second.y_ - pm.descent());
- return pit;
- }
-
- ParagraphMetrics const & pm_last = bv.parMetrics(this, last->first);
-
- // If we are off-screen (after the visible part)
- if (y > bv.workHeight()
- // and even after the first paragraph in the cache.
- && y >= last->second.y_ + int(pm_last.descent())) {
- pit = last->first + 1;
- // and we are not at the last paragraph in the inset.
- if (pit == int(pars_.size()))
- return last->first;
- // then this is the paragraph we are looking for.
- // rebreak it and update the CoordCache.
- tm.redoParagraph(pit);
- bv.coordCache().parPos()[this][pit] =
- Point(0, last->second.y_ + pm_last.ascent());
- return pit;
- }
-
- for (; it != et; ++it) {
- LYXERR(Debug::DEBUG)
- << BOOST_CURRENT_FUNCTION
- << " examining: pit: " << it->first
- << " y: " << it->second.y_
- << endl;
-
- ParagraphMetrics const & pm = bv.parMetrics(this, it->first);
-
- if (it->first >= pit && int(it->second.y_) - int(pm.ascent()) <= y) {
- pit = it->first;
- yy = it->second.y_;
- }
- }
-
- LYXERR(Debug::DEBUG)
- << BOOST_CURRENT_FUNCTION
- << ": found best y: " << yy << " for pit: " << pit
- << endl;
-
- return pit;
-}
-
-
-Row const & Text::getRowNearY(BufferView const & bv, int y, pit_type pit) const
-{
- ParagraphMetrics const & pm = bv.parMetrics(this, pit);
-
- int yy = bv.coordCache().get(this, pit).y_ - pm.ascent();
- BOOST_ASSERT(!pm.rows().empty());
- RowList::const_iterator rit = pm.rows().begin();
- RowList::const_iterator const rlast = boost::prior(pm.rows().end());
- for (; rit != rlast; yy += rit->height(), ++rit)
- if (yy + rit->height() > y)
- break;
- return *rit;
-}
-
-
-// x,y are absolute screen coordinates
-// sets cursor recursively descending into nested editable insets
-Inset * Text::editXY(Cursor & cur, int x, int y)
-{
- if (lyxerr.debugging(Debug::WORKAREA)) {
- lyxerr << "Text::editXY(cur, " << x << ", " << y << ")" << std::endl;
- cur.bv().coordCache().dump();
- }
- pit_type pit = getPitNearY(cur.bv(), y);
- BOOST_ASSERT(pit != -1);
-
- Row const & row = getRowNearY(cur.bv(), y, pit);
- bool bound = false;
-
- TextMetrics const & tm = cur.bv().textMetrics(this);
- int xx = x; // is modified by getColumnNearX
- pos_type const pos = row.pos()
- + tm.getColumnNearX(pit, row, xx, bound);
- cur.pit() = pit;
- cur.pos() = pos;
- cur.boundary(bound);
- cur.setTargetX(x);
-
- // try to descend into nested insets
- Inset * inset = checkInsetHit(cur.bv(), x, y);
- //lyxerr << "inset " << inset << " hit at x: " << x << " y: " << y << endl;
- if (!inset) {
- // Either we deconst editXY or better we move current_font
- // and real_current_font to Cursor
- setCurrentFont(cur);
- return 0;
- }
-
- Inset * insetBefore = pos? pars_[pit].getInset(pos - 1): 0;
- //Inset * insetBehind = pars_[pit].getInset(pos);
-
- // This should be just before or just behind the
- // cursor position set above.
- BOOST_ASSERT((pos != 0 && inset == insetBefore)
- || inset == pars_[pit].getInset(pos));
-
- // Make sure the cursor points to the position before
- // this inset.
- if (inset == insetBefore) {
- --cur.pos();
- cur.boundary(false);
- }
-
- // Try to descend recursively inside the inset.
- inset = inset->editXY(cur, x, y);
-
- if (cur.top().text() == this)
- setCurrentFont(cur);
- return inset;
+ cur.setCurrentFont();
}
if (!front && cur.pos() == 0)
return false;
Inset * inset = front ? cur.nextInset() : cur.prevInset();
- if (!isHighlyEditableInset(inset))
+ if (!inset || !inset->editable())
return false;
/*
* Apparently, when entering an inset we are expected to be positioned
}
-bool Text::cursorLeft(Cursor & cur)
+bool Text::checkAndActivateInsetVisual(Cursor & cur, bool movingForward, bool movingLeft)
+{
+ if (cur.selection())
+ return false;
+ if (cur.pos() == -1)
+ return false;
+ if (cur.pos() == cur.lastpos())
+ return false;
+ Paragraph & par = cur.paragraph();
+ Inset * inset = par.isInset(cur.pos()) ? par.getInset(cur.pos()) : 0;
+ if (!inset || !inset->editable())
+ return false;
+ inset->edit(cur, movingForward,
+ movingLeft ? Inset::ENTRY_DIRECTION_RIGHT : Inset::ENTRY_DIRECTION_LEFT);
+ return true;
+}
+
+
+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) {
// move to the previous paragraph or do nothing
if (cur.pit() > 0)
- return setCursor(cur, cur.pit() - 1, getPar(cur.pit() - 1).size());
+ return setCursor(cur, cur.pit() - 1, getPar(cur.pit() - 1).size(), true, false);
return false;
}
-bool Text::cursorRight(Cursor & cur)
+bool Text::cursorVisLeft(Cursor & cur, bool skip_inset)
+{
+ Cursor temp_cur = cur;
+ temp_cur.posVisLeft(skip_inset);
+ if (temp_cur.depth() > cur.depth()) {
+ cur = temp_cur;
+ return false;
+ }
+ return setCursor(cur, temp_cur.pit(), temp_cur.pos(),
+ true, temp_cur.boundary());
+}
+
+
+bool Text::cursorVisRight(Cursor & cur, bool skip_inset)
+{
+ Cursor temp_cur = cur;
+ temp_cur.posVisRight(skip_inset);
+ if (temp_cur.depth() > cur.depth()) {
+ cur = temp_cur;
+ return false;
+ }
+ return setCursor(cur, temp_cur.pit(), temp_cur.pos(),
+ true, temp_cur.boundary());
+}
+
+
+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()) {
if (checkAndActivateInset(cur, true))
return false;
+ TextMetrics const & tm = cur.bv().textMetrics(this);
// if left of boundary -> just jump to right side
- // but for RTL boundaries don't, because: abc|DDEEFFghi -> abcDDEEF|Fghi
- if (cur.boundary() &&
- !isRTLBoundary(cur.buffer(), cur.paragraph(), cur.pos()))
+ // but for RTL boundaries don't, because: abc|DDEEFFghi -> abcDDEEF|Fghi
+ if (cur.boundary() && !tm.isRTLBoundary(cur.pit(), cur.pos()))
return setCursor(cur, cur.pit(), cur.pos(), true, false);
// next position is left of boundary,
// in front of RTL boundary? Stay on this side of the boundary because:
// ab|cDDEEFFghi -> abc|DDEEFFghi
- if (isRTLBoundary(cur.buffer(), cur.paragraph(), cur.pos() + 1))
+ if (tm.isRTLBoundary(cur.pit(), cur.pos() + 1))
return setCursor(cur, cur.pit(), cur.pos() + 1, true, true);
// move right
// move to next paragraph
if (cur.pit() != cur.lastpit())
- return setCursor(cur, cur.pit() + 1, 0);
+ return setCursor(cur, cur.pit() + 1, 0, true, false);
return false;
}
bool Text::deleteEmptyParagraphMechanism(Cursor & cur,
Cursor & old, bool & need_anchor_change)
{
- //LYXERR(Debug::DEBUG) << "DEPM: cur:\n" << cur << "old:\n" << old << endl;
+ //LYXERR(Debug::DEBUG, "DEPM: cur:\n" << cur << "old:\n" << old);
Paragraph & oldpar = old.paragraph();
// delete the LineSeparator.
// MISSING
- bool const same_inset = &old.inset() == &cur.inset();
- bool const same_par = same_inset && old.pit() == cur.pit();
- bool const same_par_pos = same_par && old.pos() == cur.pos();
+ // Find a common inset and the corresponding depth.
+ size_t depth = 0;
+ for (; depth < cur.depth(); ++depth)
+ if (&old.inset() == &cur[depth].inset())
+ break;
+ // Whether a common inset is found and whether the cursor is still in
+ // the same paragraph (possibly nested).
+ bool const same_par = depth < cur.depth() && old.pit() == cur[depth].pit();
+ bool const same_par_pos = depth == cur.depth() - 1 && same_par
+ && old.pos() == cur[depth].pos();
+
// If the chars around the old cursor were spaces, delete one of them.
if (!same_par_pos) {
// Only if the cursor has really moved.
&& old.pos() < oldpar.size()
&& oldpar.isLineSeparator(old.pos())
&& oldpar.isLineSeparator(old.pos() - 1)
- && !oldpar.isDeleted(old.pos() - 1)) {
- oldpar.eraseChar(old.pos() - 1, cur.buffer().params().trackChanges);
+ && !oldpar.isDeleted(old.pos() - 1)
+ && !oldpar.isDeleted(old.pos())) {
+ oldpar.eraseChar(old.pos() - 1, cur.buffer()->params().trackChanges);
// 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
// automated way in CursorSlice code. (JMarc 26/09/2001)
// correct all cursor parts
if (same_par) {
- fixCursorAfterDelete(cur.top(), old.top());
+ fixCursorAfterDelete(cur[depth], old.top());
need_anchor_change = true;
}
return true;
if (oldpar.empty() || (oldpar.size() == 1 && oldpar.isLineSeparator(0))) {
// Delete old par.
- recordUndo(old, Undo::ATOMIC,
+ old.recordUndo(ATOMIC_UNDO,
max(old.pit() - 1, pit_type(0)),
min(old.pit() + 1, old.lastpit()));
ParagraphList & plist = old.text()->paragraphs();
+ bool const soa = oldpar.params().startOfAppendix();
plist.erase(boost::next(plist.begin(), old.pit()));
+ // do not lose start of appendix marker (bug 4212)
+ if (soa && old.pit() < pit_type(plist.size()))
+ plist[old.pit()].params().startOfAppendix(true);
// see #warning (FIXME?) above
if (cur.depth() >= old.depth()) {
return true;
}
- if (oldpar.stripLeadingSpaces(cur.buffer().params().trackChanges)) {
+ if (oldpar.stripLeadingSpaces(cur.buffer()->params().trackChanges)) {
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)
{
- 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];
}
}
- // 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;
void Text::recUndo(Cursor & cur, pit_type first, pit_type last) const
{
- recordUndo(cur, Undo::ATOMIC, first, last);
+ cur.recordUndo(ATOMIC_UNDO, first, last);
}
void Text::recUndo(Cursor & cur, pit_type par) const
{
- recordUndo(cur, Undo::ATOMIC, par, par);
+ cur.recordUndo(ATOMIC_UNDO, par, par);
}
} // namespace lyx