/**
- * \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 "Color.h"
#include "Length.h"
#include "Lexer.h"
#include "LyXRC.h"
#include "Paragraph.h"
#include "paragraph_funcs.h"
#include "ParagraphParameters.h"
+#include "TextClass.h"
#include "TextMetrics.h"
#include "VSpace.h"
#include "WordLangTuple.h"
#include "insets/InsetHFill.h"
#include "insets/InsetLine.h"
#include "insets/InsetNewline.h"
-#include "insets/InsetPagebreak.h"
+#include "insets/InsetNewpage.h"
#include "insets/InsetOptArg.h"
#include "insets/InsetSpace.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;
namespace lyx {
using support::bformat;
using support::contains;
-using support::lowercase;
using support::split;
-using support::uppercase;
+using support::subst;
using cap::cutSelection;
using cap::pasteParagraphList;
lex.eatLine();
docstring layoutname = lex.getDocString();
- font = Font(Font::ALL_INHERIT, bp.language);
+ font = Font(inherit_font, bp.language);
change = Change(Change::UNCHANGED);
TextClass const & tclass = bp.getTextClass();
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)
}
} else if (token == "\\family") {
lex.next();
- font.setLyXFamily(lex.getString());
+ setLyXFamily(lex.getString(), font.fontInfo());
} else if (token == "\\series") {
lex.next();
- font.setLyXSeries(lex.getString());
+ setLyXSeries(lex.getString(), font.fontInfo());
} else if (token == "\\shape") {
lex.next();
- font.setLyXShape(lex.getString());
+ setLyXShape(lex.getString(), font.fontInfo());
} else if (token == "\\size") {
lex.next();
- font.setLyXSize(lex.getString());
+ setLyXSize(lex.getString(), font.fontInfo());
} else if (token == "\\lang") {
lex.next();
string const tok = lex.getString();
}
} else if (token == "\\numeric") {
lex.next();
- font.setNumber(font.setLyXMisc(lex.getString()));
+ font.fontInfo().setNumber(font.setLyXMisc(lex.getString()));
} else if (token == "\\emph") {
lex.next();
- font.setEmph(font.setLyXMisc(lex.getString()));
+ font.fontInfo().setEmph(font.setLyXMisc(lex.getString()));
} else if (token == "\\bar") {
lex.next();
string const tok = lex.getString();
if (tok == "under")
- font.setUnderbar(Font::ON);
+ font.fontInfo().setUnderbar(FONT_ON);
else if (tok == "no")
- font.setUnderbar(Font::OFF);
+ font.fontInfo().setUnderbar(FONT_OFF);
else if (tok == "default")
- font.setUnderbar(Font::INHERIT);
+ font.fontInfo().setUnderbar(FONT_INHERIT);
else
lex.printError("Unknown bar font flag "
"`$$Token'");
} else if (token == "\\noun") {
lex.next();
- font.setNoun(font.setLyXMisc(lex.getString()));
+ font.fontInfo().setNoun(font.setLyXMisc(lex.getString()));
} else if (token == "\\color") {
lex.next();
- font.setLyXColor(lex.getString());
+ setLyXColor(lex.getString(), font.fontInfo());
} else if (token == "\\InsetSpace" || token == "\\SpecialChar") {
// Insets don't make sense in a free-spacing context! ---Kayvan
}
} else if (token == "\\backslash") {
par.appendChar('\\', font, change);
+ } else if (token == "\\linebreak") {
+ auto_ptr<Inset> inset(new InsetLinebreak);
+ inset->read(buf, lex);
+ par.insertInset(par.size(), inset.release(), font, change);
} else if (token == "\\newline") {
auto_ptr<Inset> inset(new InsetNewline);
inset->read(buf, lex);
} else if (token == "\\lyxline") {
par.insertInset(par.size(), new InsetLine, font, change);
} else if (token == "\\newpage") {
+ par.insertInset(par.size(), new InsetNewpage, font, change);
+ } else if (token == "\\pagebreak") {
par.insertInset(par.size(), new InsetPagebreak, font, change);
} else if (token == "\\clearpage") {
par.insertInset(par.size(), new InsetClearPage, font, change);
lex.eatLine();
std::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"),
lex.eatLine();
std::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"),
break;
}
- LYXERR(Debug::PARSER) << "Handling paragraph token: `"
- << token << '\'' << endl;
+ LYXERR(Debug::PARSER, "Handling paragraph token: `" << token << '\'');
if (token == "\\begin_layout" || token == "\\end_document"
|| token == "\\end_inset" || token == "\\begin_deeper"
|| token == "\\end_deeper") {
static docstring const number_unary_operators = from_ascii("+-");
static docstring const number_seperators = from_ascii(".,:");
- if (cur.current_font.number() == Font::ON) {
+ if (cur.current_font.fontInfo().number() == FONT_ON) {
if (!isDigit(c) && !contains(number_operators, c) &&
!(contains(number_seperators, c) &&
cur.pos() != 0 &&
cur.pos() != cur.lastpos() &&
- tm.getDisplayFont(pit, cur.pos()).number() == Font::ON &&
- tm.getDisplayFont(pit, cur.pos() - 1).number() == Font::ON)
+ tm.getDisplayFont(pit, cur.pos()).fontInfo().number() == FONT_ON &&
+ tm.getDisplayFont(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).number() == Font::ON) {
+ && tm.getDisplayFont(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.getDisplayFont(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();
// the cursor set functions have a special mechanism. When they
// realize, that you left an empty paragraph, they will delete it.
-bool Text::cursorRightOneWord(Cursor & cur)
+bool Text::cursorForwardOneWord(Cursor & cur)
{
BOOST_ASSERT(this == cur.text());
}
-bool Text::cursorLeftOneWord(Cursor & cur)
+bool Text::cursorBackwardOneWord(Cursor & cur)
{
BOOST_ASSERT(this == cur.text());
else {
cur.resetAnchor();
cur.selection() = true;
- cursorRightOneWord(cur);
+ cursorForwardOneWord(cur);
cur.setSelection();
cutSelection(cur, true, false);
checkBufferStructure(cur.buffer(), cur);
else {
cur.resetAnchor();
cur.selection() = true;
- cursorLeftOneWord(cur);
+ cursorBackwardOneWord(cur);
cur.setSelection();
cutSelection(cur, true, false);
checkBufferStructure(cur.buffer(), cur);
// Kill to end of line.
-void Text::changeCase(Cursor & cur, Text::TextCase action)
+void Text::changeCase(Cursor & cur, TextCase action)
{
BOOST_ASSERT(this == cur.text());
CursorSlice from;
} else {
from = cur.top();
getWord(from, to, PARTIAL_WORD);
- cursorRightOneWord(cur);
+ cursorForwardOneWord(cur);
}
cur.recordUndoSelection();
pos_type begPos = from.pos();
pos_type endPos = to.pos();
- bool const trackChanges = cur.buffer().params().trackChanges;
-
pos_type right = 0; // needed after the for loop
for (pit_type pit = begPit; pit <= endPit; ++pit) {
Paragraph & par = pars_[pit];
- pos_type parSize = par.size();
-
- pos_type pos = (pit == begPit ? begPos : 0);
- right = (pit == endPit ? endPos : parSize);
-
- // process sequences of modified characters; in change
- // tracking mode, this approach results in much better
- // usability than changing case on a char-by-char basis
- docstring changes;
-
- bool capitalize = true;
-
- for (; pos < right; ++pos) {
- char_type oldChar = par.getChar(pos);
- char_type newChar = oldChar;
-
- // ignore insets and don't play with deleted text!
- if (par.isInset(pos) && !par.isDeleted(pos)) {
- switch (action) {
- case text_lowercase:
- newChar = lowercase(oldChar);
- break;
- case text_capitalization:
- if (capitalize) {
- newChar = uppercase(oldChar);
- capitalize = false;
- }
- break;
- case text_uppercase:
- newChar = uppercase(oldChar);
- break;
- }
- }
-
- if (!par.isLetter(pos) || par.isDeleted(pos)) {
- capitalize = true; // permit capitalization again
- }
-
- if (oldChar != newChar) {
- changes += newChar;
- }
-
- if (oldChar == newChar || pos == right - 1) {
- if (oldChar != newChar) {
- pos++; // step behind the changing area
- }
- int erasePos = pos - changes.size();
- for (size_t i = 0; i < changes.size(); i++) {
- par.insertChar(pos, changes[i],
- par.getFontSettings(cur.buffer().params(),
- erasePos),
- trackChanges);
- if (!par.eraseChar(erasePos, trackChanges)) {
- ++erasePos;
- ++pos; // advance
- ++right; // expand selection
- }
- }
- changes.clear();
- }
- }
+ pos_type const pos = (pit == begPit ? begPos : 0);
+ right = (pit == endPit ? endPos : par.size());
+ par.changeCase(cur.buffer().params(), pos, right, action);
}
// the selection may have changed due to logically-only deleted chars
ParagraphList plist;
if (cur.lastpit() != 0 || cur.lastpos() != 0)
plist = paragraphs();
- cur.popLeft();
+ cur.popBackward();
// store cursor offset
if (spit == 0)
spos += cur.pos();
--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
Paragraph par;
par.params().depth(depth);
- par.setFont(0, Font(Font::ALL_INHERIT, buf.params().language));
+ par.setFont(0, Font(inherit_font, buf.params().language));
pars_.push_back(par);
// FIXME: goddamn InsetTabular makes us pass a Buffer
} 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;
// font. (Asger)
// No, from the document font (MV)
Font font = cur.real_current_font;
- font.reduce(buf.params().getFont());
+ font.fontInfo().reduce(buf.params().getFont().fontInfo());
os << bformat(_("Font: %1$s"), font.stateText(&buf.params()));
docstring text;
docstring par_text = pars_[pit].asString(cur.buffer(), false);
+ string piece;
+ // the return string of math matrices might contain linebreaks
+ par_text = subst(par_text, '\n', '-');
for (int i = 0; i < lyxrc.label_init_length; ++i) {
if (par_text.empty())
break;
projects / lyx.git / blobdiff