#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"
} // 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<Inset*>(it->inset->clone());
+ // 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<Inset*>(it->inset->clone());
// 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 = "
minibuffer_inset = 0;
if (minibuffer_char == Paragraph::META_INSET) {
if (getInset(pos)) {
- minibuffer_inset = getInset(pos)->clone(buffer);
+ minibuffer_inset = static_cast<Inset *>(getInset(pos)->clone());
} 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);
}
}
-#ifndef NO_NEXT
-void Paragraph::next(Paragraph * p)
-{
- next_ = p;
-}
-
-
-// This function is able to hide closed footnotes.
-Paragraph * Paragraph::next()
+void Paragraph::makeSameLayout(Paragraph const & par)
{
- 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
-{
- 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());
+ par.layout() == layout() &&
+ params().sameLayout(par.params());
}
int Paragraph::getPositionOfInset(Inset 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() == Inset::BIBTEX_CODE)
+ return static_cast<InsetBibitem *>(it->inset);
return 0;
}
BufferParams const & bparams,
LyXFont const & outerfont,
ostream & os, TexRow & texrow,
- bool moving_arg)
+ LatexRunParams const & runparams)
{
lyxerr[Debug::LATEX] << "SimpleTeXOnePar... " << this << endl;
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 += 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, outerfont, open_font,
running_change,
// 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() + ' ';
}
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
}
}
-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);
+ if (it->inset)
+ it->inset->setOwner(inset);
}
}
-void Paragraph::setContentsFromPar(Paragraph * par)
+void Paragraph::setContentsFromPar(Paragraph const & par)
{
pimpl_->setContentsFromPar(par);
}
}
+void Paragraph::id(int i)
+{
+ pimpl_->id_ = i;
+}
+
+
LyXLayout_ptr const & Paragraph::layout() const
{
+/*
+ Inset * inset = inInset();
+ if (inset && inset->lyxCode() == Inset::ENVIRONMENT_CODE)
+ return static_cast<InsetEnvironment*>(inset)->layout();
+*/
return 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.
if (pimpl_->inset_owner && pimpl_->inset_owner->owner())
return (pimpl_->inset_owner->owner()->lyxCode() == Inset::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() == Inset::ERT_CODE);
+ return false;
+}
+
+
+bool operator==(Paragraph const & lhs, Paragraph const & rhs)
+{
+#warning FIXME this implementatoin must be completely wrong...
+ return &lhs == &rhs;
+}