/**
- * \file src/text.cpp
+ * \file src/Text.cpp
* This file is part of LyX, the document processor.
* Licence details can be found in the file COPYING.
*
#include "Cursor.h"
#include "ParIterator.h"
#include "CutAndPaste.h"
-#include "debug.h"
#include "DispatchResult.h"
#include "Encoding.h"
#include "ErrorList.h"
#include "FuncRequest.h"
#include "factory.h"
#include "FontIterator.h"
-#include "gettext.h"
#include "Language.h"
#include "Length.h"
#include "Lexer.h"
#include "VSpace.h"
#include "WordLangTuple.h"
-#include "frontends/FontMetrics.h"
-#include "frontends/Painter.h"
-
#include "insets/InsetText.h"
#include "insets/InsetBibitem.h"
#include "insets/InsetCaption.h"
#include "insets/InsetSpecialChar.h"
#include "insets/InsetTabular.h"
+#include "support/convert.h"
+#include "support/debug.h"
#include "support/docstream.h"
+#include "support/gettext.h"
#include "support/lstrings.h"
#include "support/textutils.h"
-#include "support/convert.h"
-#include <boost/current_function.hpp>
#include <boost/next_prior.hpp>
#include <sstream>
-using std::auto_ptr;
-using std::advance;
-using std::distance;
-using std::max;
-using std::min;
-using std::endl;
-using std::string;
+using namespace std;
+using namespace lyx::support;
namespace lyx {
-using support::bformat;
-using support::contains;
-using support::split;
-using support::subst;
-
using cap::cutSelection;
using cap::pasteParagraphList;
-using frontend::FontMetrics;
-
namespace {
void readParToken(Buffer const & buf, Paragraph & par, Lexer & lex,
font = Font(inherit_font, bp.language);
change = Change(Change::UNCHANGED);
- TextClass const & tclass = bp.getTextClass();
+ DocumentClass const & tclass = bp.documentClass();
- if (layoutname.empty()) {
+ if (layoutname.empty())
layoutname = tclass.defaultLayoutName();
+
+ if (par.forceEmptyLayout()) {
+ // in this case only the empty layout is allowed
+ layoutname = tclass.emptyLayoutName();
+ } else if (par.useEmptyLayout()) {
+ // in this case, default layout maps to empty layout
+ if (layoutname == tclass.defaultLayoutName())
+ layoutname = tclass.emptyLayoutName();
+ } else {
+ // otherwise, the empty layout maps to the default
+ if (layoutname == tclass.emptyLayoutName())
+ layoutname = tclass.defaultLayoutName();
}
bool hasLayout = tclass.hasLayout(layoutname);
errorList.push_back(ErrorItem(_("Unknown layout"),
bformat(_("Layout '%1$s' does not exist in textclass '%2$s'\nTrying to use the default instead.\n"),
layoutname, from_utf8(tclass.name())), par.id(), 0, par.size()));
- layoutname = tclass.defaultLayoutName();
+ layoutname = par.useEmptyLayout() ?
+ tclass.emptyLayoutName() :
+ tclass.defaultLayoutName();
}
- par.layout(bp.getTextClass()[layoutname]);
+ par.setLayout(bp.documentClass()[layoutname]);
// Test whether the layout is obsolete.
- LayoutPtr const & layout = par.layout();
- if (!layout->obsoleted_by().empty())
- par.layout(bp.getTextClass()[layout->obsoleted_by()]);
+ Layout const & layout = par.layout();
+ if (!layout.obsoleted_by().empty())
+ par.setLayout(bp.documentClass()[layout.obsoleted_by()]);
par.params().read(lex);
} else if (token == "\\end_layout") {
- lyxerr << BOOST_CURRENT_FUNCTION
- << ": Solitary \\end_layout in line "
- << lex.getLineNo() << "\n"
- << "Missing \\begin_layout?.\n";
+ LYXERR0("Solitary \\end_layout in line " << lex.getLineNo() << "\n"
+ << "Missing \\begin_layout ?");
} else if (token == "\\end_inset") {
- lyxerr << BOOST_CURRENT_FUNCTION
- << ": Solitary \\end_inset in line "
- << lex.getLineNo() << "\n"
- << "Missing \\begin_inset?.\n";
+ LYXERR0("Solitary \\end_inset in line " << lex.getLineNo() << "\n"
+ << "Missing \\begin_inset ?");
} else if (token == "\\begin_inset") {
Inset * inset = readInset(lex, buf);
if (inset)
inset.reset(new InsetSpecialChar);
else
inset.reset(new InsetSpace);
- inset->read(buf, lex);
+ inset->read(lex);
par.insertInset(par.size(), inset.release(),
font, change);
}
} else if (token == "\\backslash") {
par.appendChar('\\', font, change);
+ } else if (token == "\\linebreak") {
+ auto_ptr<Inset> inset(new InsetLinebreak);
+ inset->read(lex);
+ par.insertInset(par.size(), inset.release(), font, change);
} else if (token == "\\newline") {
auto_ptr<Inset> inset(new InsetNewline);
- inset->read(buf, lex);
+ inset->read(lex);
par.insertInset(par.size(), inset.release(), font, change);
} else if (token == "\\LyXTable") {
auto_ptr<Inset> inset(new InsetTabular(buf));
- inset->read(buf, lex);
+ inset->read(lex);
par.insertInset(par.size(), inset.release(), font, change);
} else if (token == "\\hfill") {
par.insertInset(par.size(), new InsetHFill, font, change);
change = Change(Change::UNCHANGED);
} else if (token == "\\change_inserted") {
lex.eatLine();
- std::istringstream is(lex.getString());
+ istringstream is(lex.getString());
unsigned int aid;
- time_type ct;
+ time_t ct;
is >> aid >> ct;
if (aid >= bp.author_map.size()) {
errorList.push_back(ErrorItem(_("Change tracking error"),
change = Change(Change::INSERTED, bp.author_map[aid], ct);
} else if (token == "\\change_deleted") {
lex.eatLine();
- std::istringstream is(lex.getString());
+ istringstream is(lex.getString());
unsigned int aid;
- time_type ct;
+ time_t ct;
is >> aid >> ct;
if (aid >= bp.author_map.size()) {
errorList.push_back(ErrorItem(_("Change tracking error"),
{
return pars_.empty() || (pars_.size() == 1 && pars_[0].empty()
// FIXME: Should we consider the labeled type as empty too?
- && pars_[0].layout()->labeltype == LABEL_NO_LABEL);
+ && pars_[0].layout().labeltype == LABEL_NO_LABEL);
}
-double Text::spacing(Buffer const & buffer,
- Paragraph const & par) const
+double Text::spacing(Buffer const & buffer, Paragraph const & par) const
{
if (par.params().spacing().isDefault())
return buffer.params().spacing().getValue();
Paragraph & cpar = cur.paragraph();
pit_type cpit = cur.pit();
- TextClass const & tclass = cur.buffer().params().getTextClass();
- LayoutPtr const & layout = cpar.layout();
+ DocumentClass const & tclass = cur.buffer().params().documentClass();
+ Layout const & layout = cpar.layout();
// this is only allowed, if the current paragraph is not empty
// or caption and if it has not the keepempty flag active
if (cur.lastpos() == 0 && !cpar.allowEmpty() &&
- layout->labeltype != LABEL_SENSITIVE)
+ layout.labeltype != LABEL_SENSITIVE)
return;
// a layout change may affect also the following paragraph
// What should the layout for the new paragraph be?
bool keep_layout = inverse_logic ?
- !layout->isEnvironment()
- : layout->isEnvironment();
+ !layout.isEnvironment()
+ : layout.isEnvironment();
// We need to remember this before we break the paragraph, because
// that invalidates the layout variable
- bool sensitive = layout->labeltype == LABEL_SENSITIVE;
+ bool sensitive = layout.labeltype == LABEL_SENSITIVE;
// we need to set this before we insert the paragraph.
bool const isempty = cpar.allowEmpty() && cpar.empty();
if (sensitive) {
if (cur.pos() == 0)
// set to standard-layout
+ //FIXME Check if this should be emptyLayout() in some cases
pars_[cpit].applyLayout(tclass.defaultLayout());
else
// set to standard-layout
+ //FIXME Check if this should be emptyLayout() in some cases
pars_[next_par].applyLayout(tclass.defaultLayout());
}
// try to remove this
pit_type const pit = cur.pit();
- bool const freeSpacing = par.layout()->free_spacing ||
+ bool const freeSpacing = par.layout().free_spacing ||
par.isFreeSpacing();
if (lyxrc.auto_number) {
!(contains(number_seperators, c) &&
cur.pos() != 0 &&
cur.pos() != cur.lastpos() &&
- tm.getDisplayFont(pit, cur.pos()).fontInfo().number() == FONT_ON &&
- tm.getDisplayFont(pit, cur.pos() - 1).fontInfo().number() == FONT_ON)
+ tm.displayFont(pit, cur.pos()).fontInfo().number() == FONT_ON &&
+ tm.displayFont(pit, cur.pos() - 1).fontInfo().number() == FONT_ON)
)
number(cur); // Set current_font.number to OFF
} else if (isDigit(c) &&
tm.font_);
} else if (contains(number_seperators, c)
&& cur.pos() >= 2
- && tm.getDisplayFont(pit, cur.pos() - 2).fontInfo().number() == FONT_ON) {
+ && tm.displayFont(pit, cur.pos() - 2).fontInfo().number() == FONT_ON) {
setCharFont(buffer, pit, cur.pos() - 1, cur.current_font,
tm.font_);
}
if ((cur.pos() >= 2) && (par.isLineSeparator(cur.pos() - 1))) {
// get font in front and behind the space in question. But do NOT
// use getFont(cur.pos()) because the character c is not inserted yet
- Font const pre_space_font = tm.getDisplayFont(cur.pit(), cur.pos() - 2);
+ Font const pre_space_font = tm.displayFont(cur.pit(), cur.pos() - 2);
Font const & post_space_font = cur.real_current_font;
bool pre_space_rtl = pre_space_font.isVisibleRightToLeft();
bool post_space_rtl = post_space_font.isVisibleRightToLeft();
(pre_space_rtl == par.isRTL(buffer.params())) ?
pre_space_font.language() : post_space_font.language();
- Font space_font = tm.getDisplayFont(cur.pit(), cur.pos() - 1);
+ Font space_font = tm.displayFont(cur.pit(), cur.pos() - 1);
space_font.setLanguage(lang);
par.setFont(cur.pos() - 1, space_font);
}
}
par.insertChar(cur.pos(), c, cur.current_font, cur.buffer().params().trackChanges);
- checkBufferStructure(cur.buffer(), cur);
+ cur.checkBufferStructure();
// cur.updateFlags(Update::Force);
setCursor(cur.top(), cur.pit(), cur.pos() + 1);
void Text::charInserted(Cursor & cur)
{
+ Paragraph & par = cur.paragraph();
+
// Here we call finishUndo for every 20 characters inserted.
// This is from my experience how emacs does it. (Lgb)
static unsigned int counter;
cur.finishUndo();
counter = 0;
}
+
+ // register word if a non-letter was entered
+ if (cur.pos() > 1
+ && par.isLetter(cur.pos() - 2)
+ && !par.isLetter(cur.pos() - 1)) {
+ // get the word in front of cursor
+ BOOST_ASSERT(this == cur.text());
+ cur.paragraph().updateWords(cur.top());
+ }
}
cursorForwardOneWord(cur);
cur.setSelection();
cutSelection(cur, true, false);
- checkBufferStructure(cur.buffer(), cur);
+ cur.checkBufferStructure();
}
}
cursorBackwardOneWord(cur);
cur.setSelection();
cutSelection(cur, true, false);
- checkBufferStructure(cur.buffer(), cur);
+ cur.checkBufferStructure();
}
}
CursorSlice from;
CursorSlice to;
+ bool gotsel = false;
if (cur.selection()) {
from = cur.selBegin();
to = cur.selEnd();
+ gotsel = true;
} else {
from = cur.top();
getWord(from, to, PARTIAL_WORD);
}
// the selection may have changed due to logically-only deleted chars
- setCursor(cur, begPit, begPos);
- cur.resetAnchor();
- setCursor(cur, endPit, right);
- cur.setSelection();
+ if (gotsel) {
+ setCursor(cur, begPit, begPos);
+ cur.resetAnchor();
+ setCursor(cur, endPit, right);
+ cur.setSelection();
+ } else
+ setCursor(cur, endPit, right);
- checkBufferStructure(cur.buffer(), cur);
+ cur.checkBufferStructure();
}
bool Text::handleBibitems(Cursor & cur)
{
- if (cur.paragraph().layout()->labeltype != LABEL_BIBLIO)
+ if (cur.paragraph().layout().labeltype != LABEL_BIBLIO)
return false;
+
+ if (cur.pos() != 0)
+ return false;
+
+ BufferParams const & bufparams = cur.buffer().params();
+ Paragraph const & par = cur.paragraph();
+ Cursor prevcur = cur;
+ if (cur.pit() > 0) {
+ --prevcur.pit();
+ prevcur.pos() = prevcur.lastpos();
+ }
+ Paragraph const & prevpar = prevcur.paragraph();
+
// if a bibitem is deleted, merge with previous paragraph
// if this is a bibliography item as well
- if (cur.pos() == 0) {
- BufferParams const & bufparams = cur.buffer().params();
- Paragraph const & par = cur.paragraph();
- Cursor prevcur = cur;
- if (cur.pit() > 0) {
- --prevcur.pit();
- prevcur.pos() = prevcur.lastpos();
- }
- Paragraph const & prevpar = prevcur.paragraph();
- if (cur.pit() > 0 && par.layout() == prevpar.layout()) {
- cur.recordUndo(ATOMIC_UNDO, prevcur.pit());
- mergeParagraph(bufparams, cur.text()->paragraphs(),
- prevcur.pit());
- updateLabels(cur.buffer());
- setCursorIntern(cur, prevcur.pit(), prevcur.pos());
- cur.updateFlags(Update::Force);
- // if not, reset the paragraph to default
- } else
- cur.paragraph().layout(
- bufparams.getTextClass().defaultLayout());
+ if (cur.pit() > 0 && par.layout() == prevpar.layout()) {
+ cur.recordUndo(ATOMIC_UNDO, prevcur.pit());
+ mergeParagraph(bufparams, cur.text()->paragraphs(),
+ prevcur.pit());
+ updateLabels(cur.buffer());
+ setCursorIntern(cur, prevcur.pit(), prevcur.pos());
+ cur.updateFlags(Update::Force);
return true;
- }
- return false;
+ }
+
+ // otherwise reset to default
+ cur.paragraph().setEmptyOrDefaultLayout(bufparams.documentClass());
+ return true;
}
// this is the code for a normal delete, not pasting
// any paragraphs
cur.recordUndo(DELETE_UNDO);
- if(!par.eraseChar(cur.pos(), cur.buffer().params().trackChanges)) {
+ bool const was_inset = cur.paragraph().isInset(cur.pos());
+ if(!par.eraseChar(cur.pos(), cur.buffer().params().trackChanges))
// the character has been logically deleted only => skip it
cur.top().forwardPos();
- }
- checkBufferStructure(cur.buffer(), cur);
+
+ if (was_inset)
+ updateLabels(cur.buffer());
+ else
+ cur.checkBufferStructure();
needsUpdate = true;
} else {
if (cur.pit() == cur.lastpit())
// Make sure the cursor is correct. Is this really needed?
// No, not really... at least not here!
cur.text()->setCursor(cur.top(), cur.pit(), cur.pos());
- checkBufferStructure(cur.buffer(), cur);
+ cur.checkBufferStructure();
}
return needsUpdate;
bool needsUpdate = false;
BufferParams const & bufparams = cur.buffer().params();
- TextClass const & tclass = bufparams.getTextClass();
+ DocumentClass const & tclass = bufparams.documentClass();
ParagraphList & plist = cur.text()->paragraphs();
Paragraph const & par = cur.paragraph();
Cursor prevcur = cur;
// layouts. I think it is a real bug of all other
// word processors to allow it. It confuses the user.
// Correction: Pasting is always allowed with standard-layout
+ // or the empty layout.
else if (par.layout() == prevpar.layout()
- || par.layout() == tclass.defaultLayout()) {
+ || tclass.isDefaultLayout(par.layout())
+ || tclass.isEmptyLayout(par.layout())) {
cur.recordUndo(ATOMIC_UNDO, prevcur.pit());
mergeParagraph(bufparams, plist, prevcur.pit());
needsUpdate = true;
// without the dreaded mechanism. (JMarc)
setCursorIntern(cur, cur.pit(), cur.pos() - 1,
false, cur.boundary());
+ bool const was_inset = cur.paragraph().isInset(cur.pos());
cur.paragraph().eraseChar(cur.pos(), cur.buffer().params().trackChanges);
- checkBufferStructure(cur.buffer(), cur);
+ if (was_inset)
+ updateLabels(cur.buffer());
+ else
+ cur.checkBufferStructure();
}
if (cur.pos() == cur.lastpos())
return false;
cur.recordUndoInset();
+ cur.mark() = false;
cur.selHandle(false);
// save position
pos_type spos = cur.pos();
for (; it != it_end; it++)
it->changeLanguage(b.params(), latex_language, b.language());
- pasteParagraphList(cur, plist, b.params().getTextClassPtr(),
+ pasteParagraphList(cur, plist, b.params().documentClassPtr(),
b.errorList("Paste"));
// restore position
- cur.pit() = std::min(cur.lastpit(), spit);
- cur.pos() = std::min(cur.lastpos(), spos);
+ cur.pit() = min(cur.lastpit(), spit);
+ cur.pos() = min(cur.lastpos(), spos);
}
cur.clearSelection();
cur.resetAnchor();
void Text::getWord(CursorSlice & from, CursorSlice & to,
- word_location const loc)
+ word_location const loc) const
{
Paragraph const & from_par = pars_[from.pit()];
switch (loc) {
--from.pos();
break;
case NEXT_WORD:
- lyxerr << "Text::getWord: NEXT_WORD not implemented yet"
- << endl;
+ LYXERR0("Text::getWord: NEXT_WORD not implemented yet");
break;
case PARTIAL_WORD:
// no need to move the 'from' cursor
break;
}
to = from;
- Paragraph & to_par = pars_[to.pit()];
+ Paragraph const & to_par = pars_[to.pit()];
while (to.pos() < to_par.size() && to_par.isLetter(to.pos()))
++to.pos();
}
-void Text::write(Buffer const & buf, std::ostream & os) const
+void Text::write(Buffer const & buf, ostream & os) const
{
ParagraphList::const_iterator pit = paragraphs().begin();
ParagraphList::const_iterator end = paragraphs().end();
depth_type dth = 0;
for (; pit != end; ++pit)
- pit->write(buf, os, buf.params(), dth);
+ pit->write(os, buf.params(), dth);
// Close begin_deeper
for(; dth > 0; --dth)
}
-bool Text::read(Buffer const & buf, Lexer & lex, ErrorList & errorList)
+bool Text::read(Buffer const & buf, Lexer & lex,
+ ErrorList & errorList, InsetText * insetPtr)
{
depth_type depth = 0;
Paragraph par;
par.params().depth(depth);
par.setFont(0, Font(inherit_font, buf.params().language));
+ par.setInsetOwner(insetPtr);
pars_.push_back(par);
// FIXME: goddamn InsetTabular makes us pass a Buffer
// not BufferParams
lyx::readParagraph(buf, pars_.back(), lex, errorList);
+ // register the words in the global word list
+ CursorSlice sl = CursorSlice(*insetPtr);
+ sl.pit() = pars_.size() - 1;
+ pars_.back().updateWords(sl);
} else if (token == "\\begin_deeper") {
++depth;
} else if (token == "\\end_deeper") {
- if (!depth) {
+ if (!depth)
lex.printError("\\end_deeper: " "depth is already null");
- } else {
+ else
--depth;
- }
} else {
- lyxerr << "Handling unknown body token: `"
- << token << '\'' << endl;
+ LYXERR0("Handling unknown body token: `" << token << '\'');
}
}
return true;
if (!par.empty() && cur.pos() < par.size()) {
// Force output of code point, not character
size_t const c = par.getChar(cur.pos());
- os << _(", Char: 0x") << std::hex << c;
+ os << _(", Char: 0x") << hex << c;
}
os << _(", Boundary: ") << cur.boundary();
// Row & row = cur.textRow();
{
pit_type pit = cur.pit();
- LayoutPtr layout = pars_[pit].layout();
+ Layout const * layout = &(pars_[pit].layout());
docstring text;
- docstring par_text = pars_[pit].asString(cur.buffer(), false);
+ docstring par_text = pars_[pit].asString(false);
string piece;
// the return string of math matrices might contain linebreaks
par_text = subst(par_text, '\n', '-');
// For section, subsection, etc...
if (layout->latextype == LATEX_PARAGRAPH && pit != 0) {
- LayoutPtr const & layout2 = pars_[pit - 1].layout();
+ Layout const * layout2 = &(pars_[pit - 1].layout());
if (layout2->latextype != LATEX_PARAGRAPH) {
--pit;
layout = layout2;
par.insertChar(pos1, char2, font2, trackChanges);
par.insertChar(pos2, char1, font1, trackChanges);
- checkBufferStructure(cur.buffer(), cur);
+ cur.checkBufferStructure();
// After the transposition, move cursor to after the transposition.
setCursor(cur, cur.pit(), pos2);
}
+DocIterator Text::macrocontextPosition() const
+{
+ return macrocontext_position_;
+}
+
+
+void Text::setMacrocontextPosition(DocIterator const & pos)
+{
+ macrocontext_position_ = pos;
+}
+
+
} // namespace lyx