#include "lyxfont.h"
#include "lyxrc.h"
#include "lyxrow.h"
+#include "messages.h"
#include "outputparams.h"
+#include "output_latex.h"
#include "paragraph_funcs.h"
-#include "ParagraphList_fwd.h"
#include "rowpainter.h"
}
-int Paragraph::stripLeadingSpaces()
+bool Paragraph::stripLeadingSpaces(bool trackChanges)
{
if (isFreeSpacing())
- return 0;
+ return false;
- int i = 0;
- while (!empty() && (isNewline(0) || isLineSeparator(0))
- && !isDeleted(0)) {
- eraseChar(0, false); // no change tracking here
- ++i;
+ int pos = 0;
+ int count = 0;
+
+ while (pos < size() && (isNewline(pos) || isLineSeparator(pos))) {
+ if (eraseChar(pos, trackChanges))
+ ++count;
+ else
+ ++pos;
}
- return i;
+ return count > 0 || pos > 0;
}
}
+docstring const Paragraph::translateIfPossible(docstring const & s,
+ BufferParams const & bparams) const
+{
+ if (!support::isAscii(s) || s.empty()) {
+ // This must be a user defined layout. We cannot translate
+ // this, since gettext accepts only ascii keys.
+ return s;
+ }
+ // Probably standard layout, try to translate
+ Messages & m = getMessages(getParLanguage(bparams)->code());
+ return m.get(to_ascii(s));
+}
+
+
+docstring Paragraph::expandLabel(LyXLayout_ptr const & layout,
+ BufferParams const & bparams, bool process_appendix) const
+{
+ LyXTextClass const & tclass = bparams.getLyXTextClass();
+
+ docstring fmt;
+ if (process_appendix && params().appendix())
+ fmt = translateIfPossible(layout->labelstring_appendix(),
+ bparams);
+ else
+ fmt = translateIfPossible(layout->labelstring(), bparams);
+
+ // handle 'inherited level parts' in 'fmt',
+ // i.e. the stuff between '@' in '@Section@.\arabic{subsection}'
+ size_t const i = fmt.find('@', 0);
+ if (i != docstring::npos) {
+ size_t const j = fmt.find('@', i + 1);
+ if (j != docstring::npos) {
+ docstring parent(fmt, i + 1, j - i - 1);
+ // FIXME UNICODE
+ docstring label = expandLabel(tclass[to_utf8(parent)], bparams);
+ fmt = docstring(fmt, 0, i) + label + docstring(fmt, j + 1, docstring::npos);
+ }
+ }
+
+ return tclass.counters().counterLabel(fmt);
+}
+
+
void Paragraph::applyLayout(LyXLayout_ptr const & new_layout)
{
layout(new_layout);
}
-int adjust_column_count(string const & str, int oldcol)
+void adjust_row_column(string const & str, TexRow & texrow, int & column)
{
if (!contains(str, "\n"))
- return oldcol + str.size();
+ column += str.size();
else {
string tmp;
- return rsplit(str, tmp, '\n').size();
+ texrow.newline();
+ column = rsplit(str, tmp, '\n').size();
}
}
// This could go to ParagraphParameters if we want to
int Paragraph::startTeXParParams(BufferParams const & bparams,
- odocstream & os, bool moving_arg) const
+ odocstream & os, TexRow & texrow,
+ bool moving_arg) const
{
int column = 0;
else
output = corrected_env("\\begin", "flushright", ownerCode());
os << from_ascii(output);
- column = adjust_column_count(output, column);
+ adjust_row_column(output, texrow, column);
break;
} case LYX_ALIGN_RIGHT: {
string output;
else
output = corrected_env("\\begin", "flushleft", ownerCode());
os << from_ascii(output);
- column = adjust_column_count(output, column);
+ adjust_row_column(output, texrow, column);
break;
} case LYX_ALIGN_CENTER: {
string output;
output = corrected_env("\\begin", "center", ownerCode());
os << from_ascii(output);
- column = adjust_column_count(output, column);
+ adjust_row_column(output, texrow, column);
break;
}
}
// This could go to ParagraphParameters if we want to
-int Paragraph::endTeXParParams(BufferParams const & bparams,
- odocstream & os, bool moving_arg) const
+int Paragraph::endTeXParParams(BufferParams const & bparams,
+ odocstream & os, TexRow & texrow,
+ bool moving_arg) const
{
int column = 0;
else
output = corrected_env("\n\\par\\end", "flushright", ownerCode());
os << from_ascii(output);
- column = adjust_column_count(output, column);
+ adjust_row_column(output, texrow, column);
break;
} case LYX_ALIGN_RIGHT: {
string output;
else
output = corrected_env("\n\\par\\end", "flushleft", ownerCode());
os << from_ascii(output);
- column = adjust_column_count(output, column);
+ adjust_row_column(output, texrow, column);
break;
} case LYX_ALIGN_CENTER: {
string output;
output = corrected_env("\n\\par\\end", "center", ownerCode());
os << from_ascii(output);
- column = adjust_column_count(output, column);
+ adjust_row_column(output, texrow, column);
break;
}
}
// well we have to check if we are in an inset with unlimited
// length (all in one row) if that is true then we don't allow
// any special options in the paragraph and also we don't allow
- // any environment other then "Standard" to be valid!
+ // any environment other than the default layout of the text class
+ // to be valid!
bool asdefault = forceDefaultParagraphs();
if (asdefault) {
style = layout();
}
+ // Current base font for all inherited font changes, without any
+ // change caused by an individual character, except for the language:
+ // It is set to the language of the first character.
+ // As long as we are in the label, this font is the base font of the
+ // label. Before the first body character it is set to the base font
+ // of the body.
LyXFont basefont;
- LaTeXFeatures features(buf, bparams, runparams);
-
// output change tracking marks only if desired,
// if dvipost is installed,
// and with dvi/ps (other formats don't work)
bool const output = bparams.outputChanges
&& runparams.flavor == OutputParams::LATEX
- && features.isAvailable("dvipost");
+ && LaTeXFeatures::isAvailable("dvipost");
// Maybe we have to create a optional argument.
pos_type body_pos = beginOfBody();
++column;
}
if (!asdefault)
- column += startTeXParParams(bparams, os,
+ column += startTeXParParams(bparams, os, texrow,
runparams.moving_arg);
}
+ // Computed only once per paragraph since bparams.encoding() is expensive
+ Encoding const & doc_encoding = bparams.encoding();
+
for (pos_type i = 0; i < size(); ++i) {
- ++column;
// First char in paragraph or after label?
if (i == body_pos) {
if (body_pos > 0) {
if (open_font) {
- column += running_font.latexWriteEndChanges(os, basefont, basefont);
+ column += running_font.latexWriteEndChanges(
+ os, basefont, basefont);
open_font = false;
}
basefont = getLayoutFont(bparams, outerfont);
running_font = basefont;
+
+ column += Changes::latexMarkChange(os,
+ runningChangeType, Change::UNCHANGED, output);
+ runningChangeType = Change::UNCHANGED;
+
os << "}] ";
column +=3;
}
}
if (!asdefault)
- column += startTeXParParams(bparams, os,
+ column += startTeXParParams(bparams, os,
+ texrow,
runparams.moving_arg);
}
- value_type c = getChar(i);
+ Change::Type changeType = pimpl_->lookupChange(i).type;
+
+ // do not output text which is marked deleted
+ // if change tracking output is disabled
+ if (!output && changeType == Change::DELETED) {
+ runningChangeType = changeType;
+ continue;
+ }
+
+ ++column;
+
+ column += Changes::latexMarkChange(os, runningChangeType,
+ changeType, output);
+ runningChangeType = changeType;
+
+ value_type const c = getChar(i);
// Fully instantiated font
- LyXFont font = getFont(bparams, i, outerfont);
+ LyXFont const font = getFont(bparams, i, outerfont);
LyXFont const last_font = running_font;
- // Spaces at end of font change are simulated to be
- // outside font change, i.e. we write "\textXX{text} "
- // rather than "\textXX{text }". (Asger)
- if (open_font && c == ' ' && i <= size() - 2) {
- LyXFont const & next_font = getFont(bparams, i + 1, outerfont);
- if (next_font != running_font && next_font != font) {
- font = next_font;
- }
- }
-
- // We end font definition before blanks
+ // Do we need to close the previous font?
if (open_font &&
(font != running_font ||
font.language() != running_font.language()))
{
- column += running_font.latexWriteEndChanges(os,
- basefont,
- (i == body_pos-1) ? basefont : font);
+ column += running_font.latexWriteEndChanges(
+ os, basefont,
+ (i == body_pos-1) ? basefont : font);
running_font = basefont;
open_font = false;
}
- // Blanks are printed before start of fontswitch
- if (c == ' ') {
- // Do not print the separation of the optional argument
- if (i != body_pos - 1) {
- pimpl_->simpleTeXBlanks(os, texrow, i,
- column, font, *style);
- }
+ // Switch file encoding if necessary
+ int const count = switchEncoding(os, bparams,
+ *(runparams.encoding),
+ *(font.language()->encoding()));
+ if (count > 0) {
+ column += count;
+ runparams.encoding = font.language()->encoding();
}
// Do we need to change font?
i != body_pos - 1)
{
column += font.latexWriteStartChanges(os, basefont,
- last_font);
+ last_font);
running_font = font;
open_font = true;
}
- Change::Type changeType = pimpl_->lookupChange(i).type;
-
- column += Changes::latexMarkChange(os, runningChangeType,
- changeType, output);
- runningChangeType = changeType;
-
- // do not output text which is marked deleted
- // if change tracking output is not desired
- if (output || runningChangeType != Change::DELETED) {
- OutputParams rp = runparams;
- rp.free_spacing = style->free_spacing;
- rp.local_font = &font;
- rp.intitle = style->intitle;
- pimpl_->simpleTeXSpecialChars(buf, bparams,
- os, texrow, rp,
- font, running_font,
- basefont, outerfont, open_font,
- runningChangeType,
- *style, i, column, c);
+ if (c == ' ') {
+ // Do not print the separation of the optional argument
+ // if style->pass_thru is false. This works because
+ // simpleTeXSpecialChars ignores spaces if
+ // style->pass_thru is false.
+ if (i != body_pos - 1) {
+ if (pimpl_->simpleTeXBlanks(bparams,
+ doc_encoding, os, texrow,
+ i, column, font, *style))
+ // A surrogate pair was output. We
+ // must not call simpleTeXSpecialChars
+ // in this iteration, since
+ // simpleTeXBlanks incremented i, and
+ // simpleTeXSpecialChars would output
+ // the combining character again.
+ continue;
+ }
}
- }
- column += Changes::latexMarkChange(os,
- runningChangeType, Change::UNCHANGED, output);
+ OutputParams rp = runparams;
+ rp.free_spacing = style->free_spacing;
+ rp.local_font = &font;
+ rp.intitle = style->intitle;
+ pimpl_->simpleTeXSpecialChars(buf, bparams, doc_encoding, os,
+ texrow, rp, running_font,
+ basefont, outerfont, open_font,
+ runningChangeType, *style, i, column, c);
+ }
// If we have an open font definition, we have to close it
if (open_font) {
if (next_) {
running_font
.latexWriteEndChanges(os, basefont,
- next_->getFont(bparams,
- 0, outerfont));
+ next_->getFont(bparams, 0, outerfont));
} else {
running_font.latexWriteEndChanges(os, basefont,
basefont);
//#warning there as we start another \selectlanguage with the next paragraph if
//#warning we are in need of this. This should be fixed sometime (Jug)
#endif
- running_font.latexWriteEndChanges(os, basefont, basefont);
+ running_font.latexWriteEndChanges(os, basefont, basefont);
#endif
}
+ column += Changes::latexMarkChange(os,
+ runningChangeType, Change::UNCHANGED, output);
+
// Needed if there is an optional argument but no contents.
if (body_pos > 0 && body_pos == size()) {
os << "}]~";
}
if (!asdefault) {
- column += endTeXParParams(bparams, os, runparams.moving_arg);
+ column += endTeXParParams(bparams, os, texrow,
+ runparams.moving_arg);
}
lyxerr[Debug::LATEX] << "SimpleTeXOnePar...done " << this << endl;
namespace {
-// checks, if newcol chars should be put into this line
-// writes newline, if necessary.
-void sgmlLineBreak(ostream & os, string::size_type & colcount,
- string::size_type newcol)
-{
- colcount += newcol;
- if (colcount > lyxrc.ascii_linelen) {
- os << "\n";
- colcount = newcol; // assume write after this call
- }
-}
-
enum PAR_TAG {
PAR_NONE=0,
TT = 1,
// Used for building the table of contents
docstring const Paragraph::asString(Buffer const & buffer, bool label) const
{
- OutputParams runparams;
- return asString(buffer, runparams, label);
-}
-
-
-docstring const Paragraph::asString(Buffer const & buffer,
- OutputParams const & runparams,
- bool label) const
-{
-#if 0
- string s;
- if (label && !params().labelString().empty())
- s += params().labelString() + ' ';
-
- for (pos_type i = 0; i < size(); ++i) {
- value_type c = getChar(i);
- if (isPrintable(c))
- s += c;
- else if (c == META_INSET &&
- getInset(i)->lyxCode() == InsetBase::MATH_CODE) {
- ostringstream os;
- getInset(i)->plaintext(buffer, os, runparams);
- s += subst(STRCONV(os.str()),'\n',' ');
- }
- }
-
- return s;
-#else
- // This should really be done by the caller and not here.
- docstring ret = asString(buffer, runparams, 0, size(), label);
- return subst(ret, '\n', ' ');
-#endif
+ return asString(buffer, 0, size(), label);
}
pos_type beg, pos_type end, bool label) const
{
- OutputParams const runparams;
- return asString(buffer, runparams, beg, end, label);
-}
-
-
-docstring const Paragraph::asString(Buffer const & buffer,
- OutputParams const & runparams,
- pos_type beg, pos_type end, bool label) const
-{
- lyx::odocstringstream os;
+ odocstringstream os;
if (beg == 0 && label && !params().labelString().empty())
os << params().labelString() << ' ';
if (isPrintable(c))
os.put(c);
else if (c == META_INSET)
- getInset(i)->textString(buffer, os, runparams);
+ getInset(i)->textString(buffer, os);
}
return os.str();
}
-Change const Paragraph::lookupChange(pos_type pos) const
+Change const & Paragraph::lookupChange(pos_type pos) const
{
BOOST_ASSERT(pos <= size());
return pimpl_->lookupChange(pos);
}
-void Paragraph::acceptChanges(pos_type start, pos_type end)
+void Paragraph::acceptChanges(BufferParams const & bparams, pos_type start, pos_type end)
{
- return pimpl_->acceptChanges(start, end);
+ return pimpl_->acceptChanges(bparams, start, end);
}
-void Paragraph::rejectChanges(pos_type start, pos_type end)
+void Paragraph::rejectChanges(BufferParams const & bparams, pos_type start, pos_type end)
{
- return pimpl_->rejectChanges(start, end);
+ return pimpl_->rejectChanges(bparams, start, end);
}
}
-void Paragraph::clearContents()
-{
- text_.clear();
-}
-
-
ParagraphParameters & Paragraph::params()
{
return pimpl_->params;
return false;
}
- // expand at the beginning of a row only if it is the first row of a paragaph
+ // expand at the beginning of a row only if it is the first row of a paragraph
if (pos == row.pos()) {
- return row.pos() == 0;
+ return pos == 0;
}
// do not expand in some labels
// if there is anything between the first char of the row and
// the specified position that is neither a newline nor an hfill,
// the hfill will be expanded, otherwise it won't
- pos_type i = row.pos();
- while (i < pos && (isNewline(i) || isHfill(i))) {
- ++i;
+ for (pos_type i = row.pos(); i < pos; i++) {
+ if (!isNewline(i) && !isHfill(i))
+ return true;
}
- return i != pos;
+ return false;
}
projects / lyx.git / blobdiff