#include "paragraph.h"
#include "paragraph_pimpl.h"
-#include "lyxrc.h"
-#include "layout.h"
-#include "language.h"
+
#include "buffer.h"
#include "bufferparams.h"
-#include "debug.h"
-#include "texrow.h"
#include "BufferView.h"
+#include "changes.h"
#include "encoding.h"
-#include "ParameterStruct.h"
+#include "debug.h"
#include "gettext.h"
-#include "changes.h"
+#include "language.h"
+#include "latexrunparams.h"
+#include "layout.h"
+#include "lyxrc.h"
+#include "paragraph_funcs.h"
+#include "ParameterStruct.h"
+#include "texrow.h"
+
+#include "Lsstream.h"
#include "insets/insetbibitem.h"
#include "insets/insetoptarg.h"
+#include "insets/insetenv.h"
#include "support/filetools.h"
#include "support/lstrings.h"
#include <csignal>
#include <ctime>
+using namespace lyx::support;
+
using std::ostream;
using std::endl;
using std::fstream;
char minibuffer_char;
LyXFont minibuffer_font;
-Inset * minibuffer_inset;
+InsetOld * minibuffer_inset;
} // namespace anon
-extern BufferView * current_view;
-
-
Paragraph::Paragraph()
: pimpl_(new Paragraph::Pimpl(this))
{
-#ifndef NO_NEXT
- next_ = 0;
- previous_ = 0;
-#endif
enumdepth = 0;
itemdepth = 0;
params().clear();
}
-#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))
+Paragraph::Paragraph(Paragraph const & lp)
+ : pimpl_(new Paragraph::Pimpl(*lp.pimpl_, this))
{
enumdepth = 0;
itemdepth = 0;
+ // this is because of the dummy layout of the paragraphs that
+ // follow footnotes
+ layout_ = lp.layout();
- // double linked list begin
- next_ = par->next_;
- if (next_)
- next_->previous_ = this;
- previous_ = par;
- previous_->next_ = this;
- // end
-
- params().clear();
+ // copy everything behind the break-position to the new paragraph
+ insetlist = lp.insetlist;
+ InsetList::iterator it = insetlist.begin();
+ InsetList::iterator end = insetlist.end();
+ for (; it != end; ++it) {
+ // currently we hold Inset*, not InsetBase*
+ it->inset = static_cast<InsetOld*>(it->inset->clone().release());
+ // tell the new inset who is the boss now
+ it->inset->parOwner(this);
+ }
}
-#endif
-Paragraph::Paragraph(Paragraph const & lp, bool same_ids)
- : pimpl_(new Paragraph::Pimpl(*lp.pimpl_, this, same_ids))
+void Paragraph::operator=(Paragraph const & lp)
{
- enumdepth = 0;
- itemdepth = 0;
-#ifndef NO_NEXT
- next_ = 0;
- previous_ = 0;
-#endif
+ // needed as we will destroy the pimpl_ before copying it
+ if (&lp != this)
+ return;
+ lyxerr << "Paragraph::operator=()\n";
+ delete pimpl_;
+ pimpl_ = new Pimpl(*lp.pimpl_, this);
+
+ enumdepth = lp.enumdepth;
+ itemdepth = lp.itemdepth;
// this is because of the dummy layout of the paragraphs that
// follow footnotes
layout_ = lp.layout();
InsetList::iterator it = insetlist.begin();
InsetList::iterator end = insetlist.end();
for (; it != end; ++it) {
- it.setInset(it.getInset()->clone(*current_view->buffer(),
- same_ids));
+ it->inset = static_cast<InsetOld*>(it->inset->clone().release());
// tell the new inset who is the boss now
- it.getInset()->parOwner(this);
+ it->inset->parOwner(this);
}
}
-
// the destructor removes the new paragraph from the list
Paragraph::~Paragraph()
{
-#ifndef NO_NEXT
- if (previous_)
- previous_->next_ = next_;
- if (next_)
- next_->previous_ = previous_;
-#endif
-
delete pimpl_;
//
//lyxerr << "Paragraph::paragraph_id = "
switch (c) {
case META_INSET:
{
- Inset const * inset = getInset(i);
+ InsetOld const * inset = getInset(i);
if (inset)
if (inset->directWrite()) {
// international char, let it write
}
Changes::lyxMarkChange(os, column, curtime,
running_change, Change(Change::UNCHANGED));
+
+ os << "\n\\end_layout\n";
}
minibuffer_inset = 0;
if (minibuffer_char == Paragraph::META_INSET) {
if (getInset(pos)) {
- minibuffer_inset = getInset(pos)->clone(buffer);
+ minibuffer_inset = static_cast<InsetOld *>(getInset(pos)->clone().release());
} else {
minibuffer_inset = 0;
minibuffer_char = ' ';
}
-void Paragraph::erase(pos_type pos)
+bool Paragraph::erase(pos_type pos)
{
- pimpl_->erase(pos);
+ return 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);
}
}
-void Paragraph::insertInset(pos_type pos, Inset * inset)
+void Paragraph::insertInset(pos_type pos, InsetOld * inset)
{
LyXFont const f(LyXFont::ALL_INHERIT);
insertInset(pos, inset, f);
}
-void Paragraph::insertInset(pos_type pos, Inset * inset, LyXFont const & font, Change change)
+void Paragraph::insertInset(pos_type pos, InsetOld * inset, LyXFont const & font, Change change)
{
pimpl_->insertInset(pos, inset, font, change);
}
-bool Paragraph::insetAllowed(Inset::Code code)
+bool Paragraph::insetAllowed(InsetOld::Code code)
{
//lyxerr << "Paragraph::InsertInsetAllowed" << endl;
if (pimpl_->inset_owner)
}
-Inset * Paragraph::getInset(pos_type pos)
+InsetOld * Paragraph::getInset(pos_type pos)
{
- lyx::Assert(pos < size());
+ Assert(pos < size());
return insetlist.get(pos);
}
-Inset const * Paragraph::getInset(pos_type pos) const
+InsetOld const * Paragraph::getInset(pos_type pos) const
{
- lyx::Assert(pos < size());
+ Assert(pos < size());
return insetlist.get(pos);
}
LyXFont const Paragraph::getFontSettings(BufferParams const & bparams,
pos_type pos) const
{
- lyx::Assert(pos <= size());
+ Assert(pos <= size());
Pimpl::FontList::const_iterator cit = pimpl_->fontlist.begin();
Pimpl::FontList::const_iterator end = pimpl_->fontlist.end();
return retfont;
}
+lyx::pos_type
+Paragraph::getEndPosOfFontSpan(lyx::pos_type pos) const
+{
+ Assert(pos <= size());
+
+ Pimpl::FontList::const_iterator cit = pimpl_->fontlist.begin();
+ Pimpl::FontList::const_iterator end = pimpl_->fontlist.end();
+ for (; cit != end; ++cit) {
+ if (cit->pos() >= pos)
+ return cit->pos();
+ }
+ // This should not happen, but if so, we take no chances.
+ return pos;
+}
+
// Gets uninstantiated font setting at position 0
LyXFont const Paragraph::getFirstFontSettings() const
// 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);
+ Assert(pos >= 0);
LyXLayout_ptr const & lout = layout();
LyXFont tmpfont = getFontSettings(bparams, pos);
tmpfont.realize(layoutfont);
+ tmpfont.realize(outerfont);
+ tmpfont.realize(bparams.getLyXTextClass().defaultfont());
- return pimpl_->realizeFont(tmpfont, bparams);
+ return tmpfont;
}
-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);
+ tmpfont.realize(bparams.getLyXTextClass().defaultfont());
- return pimpl_->realizeFont(tmpfont, bparams);
+ return tmpfont;
}
-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);
+ tmpfont.realize(bparams.getLyXTextClass().defaultfont());
- return pimpl_->realizeFont(tmpfont, bparams);
+ return tmpfont;
}
void Paragraph::setFont(pos_type pos, LyXFont const & font)
{
- lyx::Assert(pos <= size());
+ Assert(pos <= size());
// First, reduce font against layout/label font
// Update: The SetCharFont() routine in text2.C already
}
-#ifndef NO_NEXT
-void Paragraph::next(Paragraph * p)
-{
- next_ = p;
-}
-
-
-// This function is able to hide closed footnotes.
-Paragraph * Paragraph::next()
-{
- return next_;
-}
-
-
-Paragraph const * Paragraph::next() const
-{
- return next_;
-}
-
-
-void Paragraph::previous(Paragraph * p)
-{
- previous_ = p;
-}
-
-
-// This function is able to hide closed footnotes.
-Paragraph * Paragraph::previous()
-{
- return previous_;
-}
-
-
-// This function is able to hide closed footnotes.
-Paragraph const * Paragraph::previous() const
+void Paragraph::makeSameLayout(Paragraph const & par)
{
- return previous_;
-}
-#endif
-
-
-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 (isFreeSpacing())
return 0;
int i = 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());
}
char previous_char = 0;
char temp = 0;
if (i < size()) {
- previous_char = getChar(i);
+ previous_char = getChar(i);
if (!isNewline(i)) {
++i;
while (i < size() && previous_char != ' ') {
}
-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
+int Paragraph::getPositionOfInset(InsetOld const * inset) const
{
// Find the entry.
- InsetList::iterator it = insetlist.begin();
- InsetList::iterator end = insetlist.end();
+ InsetList::const_iterator it = insetlist.begin();
+ InsetList::const_iterator end = insetlist.end();
for (; it != end; ++it)
- if (it.getInset() == inset)
- return it.getPos();
+ if (it->inset == inset)
+ return it->pos;
return -1;
}
-InsetBibitem * Paragraph::bibitem()
+InsetBibitem * Paragraph::bibitem() const
{
- InsetList::iterator it = insetlist.begin();
- if (it != insetlist.end() && it.getInset()->lyxCode() == Inset::BIBTEX_CODE)
- return static_cast<InsetBibitem *>(it.getInset());
+ InsetList::const_iterator it = insetlist.begin();
+ if (it != insetlist.end() && it->inset->lyxCode() == InsetOld::BIBTEX_CODE)
+ return static_cast<InsetBibitem *>(it->inset);
return 0;
}
// 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)
+ LatexRunParams const & runparams)
{
lyxerr[Debug::LATEX] << "SimpleTeXOnePar... " << this << endl;
if (body_pos > 0) {
os << '[';
++column;
- basefont = getLabelFont(bparams);
+ basefont = getLabelFont(bparams, outerfont);
} else {
- basefont = getLayoutFont(bparams);
+ basefont = getLayoutFont(bparams, outerfont);
}
+ bool moving_arg = runparams.moving_arg;
moving_arg |= style->needprotect;
// Which font is currently active?
Change::Type running_change = Change::UNCHANGED;
- texrow.start(this, 0);
+ texrow.start(id(), 0);
// if the paragraph is empty, the loop will not be entered at all
if (empty()) {
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 += Changes::latexMarkChange(os, running_change, change);
running_change = change;
+ LatexRunParams rp = runparams;
+ rp.moving_arg = moving_arg;
+ rp.free_spacing = style->free_spacing;
pimpl_->simpleTeXSpecialChars(buf, bparams,
- os, texrow, moving_arg,
+ os, texrow, runparams,
font, running_font,
- basefont, open_font,
+ basefont, outerfont, open_font,
running_change,
*style, i, column, c);
}
running_font
.latexWriteEndChanges(os, basefont,
next_->getFont(bparams,
- 0));
+ 0, outerfont));
} else {
running_font.latexWriteEndChanges(os, basefont,
basefont);
bool Paragraph::isHfill(pos_type pos) const
{
return IsInsetChar(getChar(pos))
- && getInset(pos)->lyxCode() == Inset::HFILL_CODE;
+ && getInset(pos)->lyxCode() == InsetOld::HFILL_CODE;
}
bool Paragraph::isNewline(pos_type pos) const
{
return IsInsetChar(getChar(pos))
- && getInset(pos)->lyxCode() == Inset::NEWLINE_CODE;
+ && getInset(pos)->lyxCode() == InsetOld::NEWLINE_CODE;
}
Language const *
Paragraph::getParLanguage(BufferParams const & bparams) const
{
- if (!empty()) {
+ if (!empty())
return getFirstFontSettings().language();
- } else if (previous_)
- return previous_->getParLanguage(bparams);
- else
- return bparams.language;
+#warning FIXME we should check the prev par as well (Lgb)
+ return bparams.language;
}
return lyxrc.rtl_support
&& getParLanguage(bparams)->RightToLeft()
&& !(inInset() && inInset()->owner() &&
- inInset()->owner()->lyxCode() == Inset::ERT_CODE);
+ inInset()->owner()->lyxCode() == InsetOld::ERT_CODE);
}
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);
// Used for building the table of contents
string const Paragraph::asString(Buffer const * buffer, bool label) const
{
+#if 0
string s;
if (label && !params().labelString().empty())
s += params().labelString() + ' ';
if (IsPrintable(c))
s += c;
else if (c == META_INSET &&
- getInset(i)->lyxCode() == Inset::MATH_CODE) {
+ getInset(i)->lyxCode() == InsetOld::MATH_CODE) {
ostringstream ost;
getInset(i)->ascii(buffer, ost);
s += subst(STRCONV(ost.str()),'\n',' ');
}
return s;
+#else
+ // This should really be done by the caller and not here.
+ string ret(asString(buffer, 0, size(), label));
+ return subst(ret, '\n', ' ');
+#endif
}
value_type const c = getUChar(buffer->params, i);
if (IsPrintable(c))
os << c;
- else if (c == META_INSET)
+ else if (c == META_INSET)
getInset(i)->ascii(buffer, os);
}
}
-void Paragraph::setInsetOwner(Inset * i)
+void Paragraph::setInsetOwner(UpdatableInset * inset)
{
- pimpl_->inset_owner = i;
+ pimpl_->inset_owner = inset;
InsetList::iterator it = insetlist.begin();
InsetList::iterator end = insetlist.end();
- for (; it != end; ++it)
- if (it.getInset())
- it.getInset()->setOwner(i);
+ for (; it != end; ++it)
+ if (it->inset)
+ it->inset->setOwner(inset);
}
void Paragraph::deleteInsetsLyXText(BufferView * bv)
{
- // then the insets
insetlist.deleteInsetsLyXText(bv);
}
void Paragraph::resizeInsetsLyXText(BufferView * bv)
{
- // then the insets
insetlist.resizeInsetsLyXText(bv);
}
-void Paragraph::setContentsFromPar(Paragraph * par)
+void Paragraph::setContentsFromPar(Paragraph const & par)
{
pimpl_->setContentsFromPar(par);
}
Change::Type Paragraph::lookupChange(lyx::pos_type pos) const
{
- lyx::Assert(!size() || pos < size());
+ Assert(!size() || pos < size());
return pimpl_->lookupChange(pos);
}
Change const Paragraph::lookupChangeFull(lyx::pos_type pos) const
{
- lyx::Assert(!size() || pos < size());
+ Assert(!size() || pos < size());
return pimpl_->lookupChangeFull(pos);
}
}
-LyXLayout_ptr const & Paragraph::layout() const
+void Paragraph::id(int i)
{
- return layout_;
+ pimpl_->id_ = i;
}
-void Paragraph::layout(LyXLayout_ptr const & new_layout)
+LyXLayout_ptr const & Paragraph::layout() const
{
- layout_ = new_layout;
+/*
+ InsetOld * inset = inInset();
+ if (inset && inset->lyxCode() == InsetOld::ENVIRONMENT_CODE)
+ return static_cast<InsetEnvironment*>(inset)->layout();
+*/
+ return layout_;
}
-bool Paragraph::isFirstInSequence() const
+void Paragraph::layout(LyXLayout_ptr const & new_layout)
{
- Paragraph const * dhook = depthHook(getDepth());
- return (dhook == this
- || dhook->layout() != layout()
- || dhook->getDepth() != getDepth());
+ layout_ = new_layout;
}
-Inset * Paragraph::inInset() const
+UpdatableInset * Paragraph::inInset() const
{
return pimpl_->inset_owner;
}
bool Paragraph::isFreeSpacing() const
{
+ if (layout()->free_spacing)
+ return true;
+
// for now we just need this, later should we need this in some
- // other way we can always add a function to Inset::() too.
+ // other way we can always add a function to InsetOld::() too.
if (pimpl_->inset_owner && pimpl_->inset_owner->owner())
- return (pimpl_->inset_owner->owner()->lyxCode() == Inset::ERT_CODE);
+ return (pimpl_->inset_owner->owner()->lyxCode() == InsetOld::ERT_CODE);
return false;
}
+
+
+bool Paragraph::allowEmpty() const
+{
+ if (layout()->keepempty)
+ return true;
+ if (pimpl_->inset_owner && pimpl_->inset_owner->owner())
+ return (pimpl_->inset_owner->owner()->lyxCode() == InsetOld::ERT_CODE);
+ return false;
+}
+
+
+bool operator==(Paragraph const & lhs, Paragraph const & rhs)
+{
+#warning FIXME this implementatoin must be completely wrong...
+ return &lhs == &rhs;
+}