#include "lyxrc.h"
#include "layout.h"
#include "language.h"
-#include "tex-strings.h"
#include "buffer.h"
#include "bufferparams.h"
#include "debug.h"
#include "ParameterStruct.h"
#include "gettext.h"
#include "changes.h"
+#include "paragraph_funcs.h"
#include "insets/insetbibitem.h"
#include "insets/insetoptarg.h"
#ifndef NO_NEXT
// This constructor inserts the new paragraph in a list.
+// It is placed after par.
Paragraph::Paragraph(Paragraph * par)
: pimpl_(new Paragraph::Pimpl(this))
{
// First write the layout
os << "\n\\layout " << layout()->name() << '\n';
- // Maybe some vertical spaces.
- if (params().spaceTop().kind() != VSpace::NONE)
- os << "\\added_space_top "
- << params().spaceTop().asLyXCommand() << ' ';
- if (params().spaceBottom().kind() != VSpace::NONE)
- os << "\\added_space_bottom "
- << params().spaceBottom().asLyXCommand() << ' ';
-
- // Maybe the paragraph has special spacing
- params().spacing().writeFile(os, true);
-
- // The labelwidth string used in lists.
- if (!params().labelWidthString().empty())
- os << "\\labelwidthstring "
- << params().labelWidthString() << '\n';
-
- // Lines above or below?
- if (params().lineTop())
- os << "\\line_top ";
- if (params().lineBottom())
- os << "\\line_bottom ";
-
- // Pagebreaks above or below?
- if (params().pagebreakTop())
- os << "\\pagebreak_top ";
- if (params().pagebreakBottom())
- os << "\\pagebreak_bottom ";
-
- // Start of appendix?
- if (params().startOfAppendix())
- os << "\\start_of_appendix ";
-
- // Noindent?
- if (params().noindent())
- os << "\\noindent ";
-
- // Do we have a manual left indent?
- if (!params().leftIndent().zero())
- os << "\\leftindent " << params().leftIndent().asString()
- << ' ';
-
- // Alignment?
- if (params().align() != LYX_ALIGN_LAYOUT) {
- int h = 0;
- switch (params().align()) {
- case LYX_ALIGN_LEFT: h = 1; break;
- case LYX_ALIGN_RIGHT: h = 2; break;
- case LYX_ALIGN_CENTER: h = 3; break;
- default: h = 0; break;
- }
- os << "\\align " << string_align[h] << ' ';
- }
+ params().write(os);
LyXFont font1(LyXFont::ALL_INHERIT, bparams.language);
}
}
break;
- case META_NEWLINE:
- os << "\n\\newline \n";
- column = 0;
- break;
- case META_HFILL:
- os << "\n\\hfill \n";
- column = 0;
- break;
case '\\':
os << "\n\\backslash \n";
column = 0;
// end of minibuffer
+void Paragraph::eraseIntern(lyx::pos_type pos)
+{
+ pimpl_->eraseIntern(pos);
+}
+
+
void Paragraph::erase(pos_type pos)
{
pimpl_->erase(pos);
}
-bool Paragraph::erase(pos_type start, pos_type end)
+int Paragraph::erase(pos_type start, pos_type end)
{
return pimpl_->erase(start, end);
}
bool Paragraph::insetAllowed(Inset::Code code)
{
//lyxerr << "Paragraph::InsertInsetAllowed" << endl;
-
if (pimpl_->inset_owner)
return pimpl_->inset_owner->insetAllowed(code);
return true;
Inset * Paragraph::getInset(pos_type pos)
{
lyx::Assert(pos < size());
-
return insetlist.get(pos);
}
Inset const * Paragraph::getInset(pos_type pos) const
{
lyx::Assert(pos < size());
-
return insetlist.get(pos);
}
}
LyXFont retfont;
- if (cit != end) {
+ if (cit != end)
retfont = cit->font();
- } else if (pos == size() && !empty()) {
+ else if (pos == size() && !empty())
retfont = getFontSettings(bparams, pos - 1);
- } else
+ else
retfont = LyXFont(LyXFont::ALL_INHERIT, getParLanguage(bparams));
return retfont;
// The difference is that this one is used for generating the LaTeX file,
// and thus cosmetic "improvements" are disallowed: This has to deliver
// the true picture of the buffer. (Asger)
-// If position is -1, we get the layout font of the paragraph.
-// If position is -2, we get the font of the manual label of the paragraph.
-LyXFont const Paragraph::getFont(BufferParams const & bparams,
- pos_type pos) const
+LyXFont const Paragraph::getFont(BufferParams const & bparams, pos_type pos,
+ LyXFont const & outerfont) const
{
lyx::Assert(pos >= 0);
LyXLayout_ptr const & lout = layout();
- pos_type const main_body = beginningOfMainBody();
+ pos_type const body_pos = beginningOfBody();
LyXFont layoutfont;
- if (pos < main_body)
+ if (pos < body_pos)
layoutfont = lout->labelfont;
else
layoutfont = lout->font;
LyXFont tmpfont = getFontSettings(bparams, pos);
tmpfont.realize(layoutfont);
+ tmpfont.realize(outerfont);
- return pimpl_->realizeFont(tmpfont, bparams);
+ return realizeFont(tmpfont, bparams);
}
-LyXFont const Paragraph::getLabelFont(BufferParams const & bparams) const
+LyXFont const Paragraph::getLabelFont(BufferParams const & bparams,
+ LyXFont const & outerfont) const
{
LyXLayout_ptr const & lout = layout();
LyXFont tmpfont = lout->labelfont;
tmpfont.setLanguage(getParLanguage(bparams));
+ tmpfont.realize(outerfont);
- return pimpl_->realizeFont(tmpfont, bparams);
+ return realizeFont(tmpfont, bparams);
}
-LyXFont const Paragraph::getLayoutFont(BufferParams const & bparams) const
+LyXFont const Paragraph::getLayoutFont(BufferParams const & bparams,
+ LyXFont const & outerfont) const
{
LyXLayout_ptr const & lout = layout();
LyXFont tmpfont = lout->font;
tmpfont.setLanguage(getParLanguage(bparams));
+ tmpfont.realize(outerfont);
- return pimpl_->realizeFont(tmpfont, bparams);
+ return realizeFont(tmpfont, bparams);
}
#endif
-void Paragraph::makeSameLayout(Paragraph const * par)
+void Paragraph::makeSameLayout(Paragraph const & par)
{
- layout(par->layout());
+ layout(par.layout());
// move to pimpl?
- params() = par->params();
+ params() = par.params();
}
int Paragraph::stripLeadingSpaces()
{
- if (layout()->free_spacing ||
- isFreeSpacing()) {
+ if (layout()->free_spacing || isFreeSpacing())
return 0;
- }
int i = 0;
while (!empty() && (isNewline(0) || isLineSeparator(0))) {
}
-bool Paragraph::hasSameLayout(Paragraph const * par) const
+bool Paragraph::hasSameLayout(Paragraph const & par) const
{
return
- par->layout() == layout() &&
- params().sameLayout(par->params());
-}
-
-
-int Paragraph::getEndLabel() const
-{
- Paragraph const * par = this;
- depth_type par_depth = getDepth();
- while (par) {
- LyXLayout_ptr const & layout = par->layout();
- int const endlabeltype = layout->endlabeltype;
-
- if (endlabeltype != END_LABEL_NO_LABEL) {
- if (!next_)
- return endlabeltype;
-
- depth_type const next_depth = next_->getDepth();
- if (par_depth > next_depth ||
- (par_depth == next_depth
- && layout != next_->layout()))
- return endlabeltype;
- break;
- }
- if (par_depth == 0)
- break;
- par = par->outerHook();
- if (par)
- par_depth = par->getDepth();
- }
- return END_LABEL_NO_LABEL;
+ par.layout() == layout() &&
+ params().sameLayout(par.params());
}
Paragraph::depth_type Paragraph::getMaxDepthAfter() const
{
- bool const isenv = layout()->isEnvironment();
-
- if (isenv)
+ if (layout()->isEnvironment())
return params().depth() + 1;
else
return params().depth();
-
}
+
char Paragraph::getAlign() const
{
return params().align();
}
-// if the layout of a paragraph contains a manual label, the beginning of the
-// main body is the beginning of the second word. This is what the par-
-// function returns. If the layout does not contain a label, the main
-// body always starts with position 0. This differentiation is necessary,
-// because there cannot be a newline or a blank <= the beginning of the
-// main body in TeX.
-
-int Paragraph::beginningOfMainBody() const
+int Paragraph::beginningOfBody() const
{
if (layout()->labeltype != LABEL_MANUAL)
return 0;
// and remember the previous character to
// remove unnecessary GetChar() calls
pos_type i = 0;
- if (i < size() && getChar(i) != Paragraph::META_NEWLINE) {
+ if (i < size() && !isNewline(i)) {
++i;
char previous_char = 0;
char temp = 0;
- if (i < size()
- && (previous_char = getChar(i)) != Paragraph::META_NEWLINE) {
- // Yes, this ^ is supposed to be "= " not "=="
- ++i;
- while (i < size()
- && previous_char != ' '
- && (temp = getChar(i)) != Paragraph::META_NEWLINE) {
+ if (i < size()) {
+ previous_char = getChar(i);
+ if (!isNewline(i)) {
++i;
- previous_char = temp;
+ while (i < size() && previous_char != ' ') {
+ temp = getChar(i);
+ if (isNewline(i))
+ break;
+
+ ++i;
+ previous_char = temp;
+ }
}
}
}
}
-Paragraph * Paragraph::depthHook(depth_type depth)
-{
- Paragraph * newpar = this;
-
- do {
- newpar = newpar->previous();
- } while (newpar && newpar->getDepth() > depth);
-
- if (!newpar) {
- if (previous() || getDepth())
- lyxerr << "ERROR (Paragraph::DepthHook): "
- "no hook." << endl;
- newpar = this;
- }
-
- return newpar;
-}
-
-
-Paragraph const * Paragraph::depthHook(depth_type depth) const
-{
- Paragraph const * newpar = this;
-
- do {
- newpar = newpar->previous();
- } while (newpar && newpar->getDepth() > depth);
-
- if (!newpar) {
- if (previous() || getDepth())
- lyxerr << "ERROR (Paragraph::DepthHook): "
- "no hook." << endl;
- newpar = this;
- }
-
- return newpar;
-}
-
-
-Paragraph * Paragraph::outerHook()
-{
- if (!getDepth())
- return 0;
- return depthHook(depth_type(getDepth() - 1));
-}
-
-
-Paragraph const * Paragraph::outerHook() const
-{
- if (!getDepth())
- return 0;
- return depthHook(depth_type(getDepth() - 1));
-}
-
-
// returns -1 if inset not found
int Paragraph::getPositionOfInset(Inset const * inset) const
{
// This one spits out the text of the paragraph
bool Paragraph::simpleTeXOnePar(Buffer const * buf,
BufferParams const & bparams,
+ LyXFont const & outerfont,
ostream & os, TexRow & texrow,
bool moving_arg)
{
LyXFont basefont;
// Maybe we have to create a optional argument.
- pos_type main_body;
+ pos_type body_pos;
// FIXME: can we actually skip this check and just call
- // beginningOfMainBody() ??
+ // beginningOfBody() ??
if (style->labeltype != LABEL_MANUAL) {
- main_body = 0;
+ body_pos = 0;
} else {
- main_body = beginningOfMainBody();
+ body_pos = beginningOfBody();
}
unsigned int column = 0;
- if (main_body > 0) {
+ if (body_pos > 0) {
os << '[';
++column;
- basefont = getLabelFont(bparams);
+ basefont = getLabelFont(bparams, outerfont);
} else {
- basefont = getLayoutFont(bparams);
+ basefont = getLayoutFont(bparams, outerfont);
}
moving_arg |= style->needprotect;
for (pos_type i = 0; i < size(); ++i) {
++column;
// First char in paragraph or after label?
- if (i == main_body) {
- if (main_body > 0) {
+ if (i == body_pos) {
+ if (body_pos > 0) {
if (open_font) {
column += running_font.latexWriteEndChanges(os, basefont, basefont);
open_font = false;
}
- basefont = getLayoutFont(bparams);
+ basefont = getLayoutFont(bparams, outerfont);
running_font = basefont;
os << ']';
++column;
value_type c = getChar(i);
// Fully instantiated font
- LyXFont font = getFont(bparams, i);
+ LyXFont font = getFont(bparams, i, outerfont);
LyXFont const last_font = running_font;
// 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);
+ LyXFont const & next_font = getFont(bparams, i + 1, outerfont);
if (next_font != running_font
&& next_font != font) {
font = next_font;
{
column += running_font.latexWriteEndChanges(os,
basefont,
- (i == main_body-1) ? basefont : font);
+ (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 != main_body - 1) {
+ if (i != body_pos - 1) {
pimpl_->simpleTeXBlanks(os, texrow, i,
column, font, *style);
}
// Do we need to change font?
if ((font != running_font ||
font.language() != running_font.language()) &&
- i != main_body - 1)
+ i != body_pos - 1)
{
column += font.latexWriteStartChanges(os, basefont,
last_font);
column += Changes::latexMarkChange(os, running_change, change);
running_change = change;
- if (c == Paragraph::META_NEWLINE) {
- // newlines are handled differently here than
- // the default in SimpleTeXSpecialChars().
- if (!style->newline_allowed) {
- os << '\n';
- } else {
- if (open_font) {
- column += running_font.latexWriteEndChanges(os, basefont, basefont);
- open_font = false;
- }
- basefont = getLayoutFont(bparams);
- running_font = basefont;
- if (font.family() ==
- LyXFont::TYPEWRITER_FAMILY) {
- os << '~';
- }
- if (moving_arg)
- os << "\\protect ";
-
- os << "\\\\\n";
- }
- texrow.newline();
- texrow.start(this, i + 1);
- column = 0;
- } else {
- pimpl_->simpleTeXSpecialChars(buf, bparams,
- os, texrow, moving_arg,
- font, running_font,
- basefont, open_font,
- running_change,
- *style, i, column, c);
- }
+ pimpl_->simpleTeXSpecialChars(buf, bparams,
+ os, texrow, moving_arg,
+ font, running_font,
+ basefont, outerfont, open_font,
+ running_change,
+ *style, i, column, c);
}
column += Changes::latexMarkChange(os,
running_font
.latexWriteEndChanges(os, basefont,
next_->getFont(bparams,
- 0));
+ 0, outerfont));
} else {
running_font.latexWriteEndChanges(os, basefont,
basefont);
}
// Needed if there is an optional argument but no contents.
- if (main_body > 0 && main_body == size()) {
+ if (body_pos > 0 && body_pos == size()) {
os << "]~";
return_value = false;
}
bool Paragraph::isHfill(pos_type pos) const
{
- return IsHfillChar(getChar(pos));
+ return IsInsetChar(getChar(pos))
+ && getInset(pos)->lyxCode() == Inset::HFILL_CODE;
}
bool Paragraph::isNewline(pos_type pos) const
{
- return pos >= 0 && IsNewlineChar(getChar(pos));
+ return IsInsetChar(getChar(pos))
+ && getInset(pos)->lyxCode() == Inset::NEWLINE_CODE;
}
{
if (!empty()) {
return getFirstFontSettings().language();
- } else if (previous_)
+#warning FIXME we should check the prev par as well (Lgb)
+#if 0
+ } else if (previous_) {
return previous_->getParLanguage(bparams);
- else
+#endif
+ }else
return bparams.language;
}
void Paragraph::changeLanguage(BufferParams const & bparams,
- Language const * from, Language const * to)
+ Language const * from, Language const * to)
{
for (pos_type i = 0; i < size(); ++i) {
LyXFont font = getFontSettings(bparams, i);
string const Paragraph::asString(Buffer const * buffer,
pos_type beg, pos_type end, bool label) const
{
- ostringstream ost;
+ ostringstream os;
if (beg == 0 && label && !params().labelString().empty())
- ost << params().labelString() << ' ';
+ os << params().labelString() << ' ';
for (pos_type i = beg; i < end; ++i) {
value_type const c = getUChar(buffer->params, i);
if (IsPrintable(c))
- ost << c;
- else if (c == META_NEWLINE)
- ost << '\n';
- else if (c == META_HFILL)
- ost << '\t';
- else if (c == META_INSET) {
- getInset(i)->ascii(buffer, ost);
- }
+ os << c;
+ else if (c == META_INSET)
+ getInset(i)->ascii(buffer, os);
}
- return STRCONV(ost.str());
+ return STRCONV(os.str());
}
pimpl_->inset_owner = i;
InsetList::iterator it = insetlist.begin();
InsetList::iterator end = insetlist.end();
- for (; it != end; ++it) {
+ for (; it != end; ++it)
if (it.getInset())
it.getInset()->setOwner(i);
- }
}
}
-void Paragraph::setContentsFromPar(Paragraph * par)
+void Paragraph::setContentsFromPar(Paragraph const & par)
{
pimpl_->setContentsFromPar(par);
}
}
+void Paragraph::setChange(lyx::pos_type pos, Change::Type type)
+{
+ pimpl_->setChange(pos, type);
+
+}
+
+
void Paragraph::markErased()
{
pimpl_->markErased();
}
-bool Paragraph::isFirstInSequence() const
-{
- Paragraph const * dhook = depthHook(getDepth());
- return (dhook == this
- || dhook->layout() != layout()
- || dhook->getDepth() != getDepth());
-}
-
-
Inset * Paragraph::inInset() const
{
return pimpl_->inset_owner;
projects / lyx.git / blobdiff