-/* This file is part of
- * ======================================================
+/**
+ * \file paragraph.C
+ * This file is part of LyX, the document processor.
+ * Licence details can be found in the file COPYING.
*
- * LyX, The Document Processor
+ * \author Asger Alstrup
+ * \author Lars Gullik Bjønnes
+ * \author Jean-Marc Lasgouttes
+ * \author Angus Leeming
+ * \author John Levon
+ * \author André Pönitz
+ * \author Dekel Tsur
+ * \author Jürgen Vigna
*
- * Copyright 1995 Matthias Ettrich
- * Copyright 1995-2001 The LyX Team.
- *
- * ====================================================== */
+ * Full author contact details are available in file CREDITS.
+ */
#include <config.h>
#include "buffer.h"
#include "bufferparams.h"
-#include "BufferView.h"
-#include "changes.h"
#include "encoding.h"
#include "debug.h"
#include "gettext.h"
#include "language.h"
#include "latexrunparams.h"
-#include "layout.h"
+#include "lyxfont.h"
#include "lyxrc.h"
-#include "paragraph_funcs.h"
-#include "ParameterStruct.h"
+#include "lyxrow.h"
#include "texrow.h"
-
-#include "Lsstream.h"
+#include "vspace.h"
#include "insets/insetbibitem.h"
#include "insets/insetoptarg.h"
-#include "insets/insetenv.h"
-#include "support/filetools.h"
#include "support/lstrings.h"
-#include "support/lyxmanip.h"
-#include "support/FileInfo.h"
-#include "support/LAssert.h"
#include "support/textutils.h"
-
-#include <algorithm>
-#include <fstream>
-#include <csignal>
-#include <ctime>
-
-using namespace lyx::support;
-
-using std::ostream;
-using std::endl;
-using std::fstream;
-using std::ios;
-using std::lower_bound;
-using std::upper_bound;
+#include "support/std_sstream.h"
using lyx::pos_type;
+using lyx::support::contains;
+using lyx::support::subst;
-// this is a minibuffer
-
-namespace {
-
-char minibuffer_char;
-LyXFont minibuffer_font;
-InsetOld * minibuffer_inset;
-
-} // namespace anon
+using std::endl;
+using std::string;
+using std::ostream;
+using std::ostringstream;
Paragraph::Paragraph()
- : pimpl_(new Paragraph::Pimpl(this))
+ : y(0), pimpl_(new Paragraph::Pimpl(this))
{
- enumdepth = 0;
itemdepth = 0;
params().clear();
}
Paragraph::Paragraph(Paragraph const & lp)
- : pimpl_(new Paragraph::Pimpl(*lp.pimpl_, this))
+ : y(0), text_(lp.text_), pimpl_(new Paragraph::Pimpl(*lp.pimpl_, this))
{
- enumdepth = 0;
itemdepth = 0;
// this is because of the dummy layout of the paragraphs that
// follow footnotes
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);
}
}
// needed as we will destroy the pimpl_ before copying it
if (&lp != this)
return;
- lyxerr << "Paragraph::operator=()\n";
+
+ lyxerr << "Paragraph::operator=()" << endl;
+
+ text_ = lp.text_;
+
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
InsetList::iterator end = insetlist.end();
for (; it != end; ++it) {
it->inset = static_cast<InsetOld*>(it->inset->clone().release());
- // tell the new inset who is the boss now
- it->inset->parOwner(this);
}
}
}
-void Paragraph::write(Buffer const * buf, ostream & os,
+void Paragraph::write(Buffer const & buf, ostream & os,
BufferParams const & bparams,
depth_type & dth) const
{
}
// First write the layout
- os << "\n\\layout " << layout()->name() << '\n';
+ os << "\n\\begin_layout " << layout()->name() << '\n';
params().write(os);
}
Changes::lyxMarkChange(os, column, curtime,
running_change, Change(Change::UNCHANGED));
+
+ os << "\n\\end_layout\n";
}
}
-// First few functions needed for cut and paste and paragraph breaking.
-void Paragraph::copyIntoMinibuffer(Buffer const & buffer, pos_type pos) const
-{
- BufferParams bparams = buffer.params;
-
- minibuffer_char = getChar(pos);
- minibuffer_font = getFontSettings(bparams, pos);
- minibuffer_inset = 0;
- if (minibuffer_char == Paragraph::META_INSET) {
- if (getInset(pos)) {
- minibuffer_inset = static_cast<InsetOld *>(getInset(pos)->clone().release());
- } else {
- minibuffer_inset = 0;
- minibuffer_char = ' ';
- // This reflects what GetInset() does (ARRae)
- }
- }
-}
-
-
-void Paragraph::cutIntoMinibuffer(BufferParams const & bparams, pos_type pos)
-{
- minibuffer_char = getChar(pos);
- minibuffer_font = getFontSettings(bparams, pos);
- minibuffer_inset = 0;
- if (minibuffer_char == Paragraph::META_INSET) {
- if (getInset(pos)) {
- // the inset is not in a paragraph anymore
- minibuffer_inset = insetlist.release(pos);
- minibuffer_inset->parOwner(0);
- } else {
- minibuffer_inset = 0;
- minibuffer_char = ' ';
- // This reflects what GetInset() does (ARRae)
- }
-
- }
-
- // Erase(pos); now the caller is responsible for that.
-}
-
-
-bool Paragraph::insertFromMinibuffer(pos_type pos)
-{
- if (minibuffer_char == Paragraph::META_INSET) {
- if (!insetAllowed(minibuffer_inset->lyxCode())) {
- return false;
- }
- insertInset(pos, minibuffer_inset, minibuffer_font);
- } else {
- LyXFont f = minibuffer_font;
- if (!checkInsertChar(f)) {
- return false;
- }
- insertChar(pos, minibuffer_char, f);
- }
- return true;
-}
-
-// end of minibuffer
-
-
void Paragraph::eraseIntern(lyx::pos_type pos)
{
pimpl_->eraseIntern(pos);
void Paragraph::insertChar(pos_type pos, Paragraph::value_type c)
{
- LyXFont const f(LyXFont::ALL_INHERIT);
- insertChar(pos, c, f);
+ insertChar(pos, c, LyXFont(LyXFont::ALL_INHERIT));
}
void Paragraph::insertInset(pos_type pos, InsetOld * inset)
{
- LyXFont const f(LyXFont::ALL_INHERIT);
- insertInset(pos, inset, f);
+ insertInset(pos, inset, LyXFont(LyXFont::ALL_INHERIT));
}
-void Paragraph::insertInset(pos_type pos, InsetOld * 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(InsetOld::Code code)
+bool Paragraph::insetAllowed(InsetOld_code code)
{
//lyxerr << "Paragraph::InsertInsetAllowed" << endl;
if (pimpl_->inset_owner)
InsetOld * Paragraph::getInset(pos_type pos)
{
- Assert(pos < size());
+ BOOST_ASSERT(pos < size());
return insetlist.get(pos);
}
InsetOld const * Paragraph::getInset(pos_type pos) const
{
- Assert(pos < size());
+ BOOST_ASSERT(pos < size());
return insetlist.get(pos);
}
LyXFont const Paragraph::getFontSettings(BufferParams const & bparams,
pos_type pos) const
{
- Assert(pos <= size());
+ BOOST_ASSERT(pos <= size());
Pimpl::FontList::const_iterator cit = pimpl_->fontlist.begin();
Pimpl::FontList::const_iterator end = pimpl_->fontlist.end();
- for (; cit != end; ++cit) {
+ for (; cit != end; ++cit)
if (cit->pos() >= pos)
break;
- }
- LyXFont retfont;
if (cit != end)
- retfont = cit->font();
- else if (pos == size() && !empty())
- retfont = getFontSettings(bparams, pos - 1);
- else
- retfont = LyXFont(LyXFont::ALL_INHERIT, getParLanguage(bparams));
+ return cit->font();
+
+ if (pos == size() && !empty())
+ return getFontSettings(bparams, pos - 1);
- return retfont;
+ return LyXFont(LyXFont::ALL_INHERIT, getParLanguage(bparams));
}
-lyx::pos_type
-Paragraph::getEndPosOfFontSpan(lyx::pos_type pos) const
+
+lyx::pos_type Paragraph::getEndPosOfFontSpan(lyx::pos_type pos) const
{
- Assert(pos <= size());
+ BOOST_ASSERT(pos <= size());
Pimpl::FontList::const_iterator cit = pimpl_->fontlist.begin();
Pimpl::FontList::const_iterator end = pimpl_->fontlist.end();
- for (; cit != end; ++cit) {
+ for (; cit != end; ++cit)
if (cit->pos() >= pos)
return cit->pos();
- }
+
// This should not happen, but if so, we take no chances.
+ //lyxerr << "Paragraph::getEndPosOfFontSpan: This should not happen!"
+ // << endl;
return pos;
}
LyXFont const Paragraph::getFont(BufferParams const & bparams, pos_type pos,
LyXFont const & outerfont) const
{
- Assert(pos >= 0);
+ BOOST_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 realizeFont(tmpfont, bparams);
+ return tmpfont;
}
LyXFont const Paragraph::getLabelFont(BufferParams const & bparams,
LyXFont const & outerfont) const
{
- LyXLayout_ptr const & lout = layout();
-
- LyXFont tmpfont = lout->labelfont;
+ LyXFont tmpfont = layout()->labelfont;
tmpfont.setLanguage(getParLanguage(bparams));
tmpfont.realize(outerfont);
-
- return realizeFont(tmpfont, bparams);
+ tmpfont.realize(bparams.getLyXTextClass().defaultfont());
+ return tmpfont;
}
LyXFont const Paragraph::getLayoutFont(BufferParams const & bparams,
LyXFont const & outerfont) const
{
- LyXLayout_ptr const & lout = layout();
-
- LyXFont tmpfont = lout->font;
+ LyXFont tmpfont = layout()->font;
tmpfont.setLanguage(getParLanguage(bparams));
tmpfont.realize(outerfont);
-
- return realizeFont(tmpfont, bparams);
+ tmpfont.realize(bparams.getLyXTextClass().defaultfont());
+ return tmpfont;
}
/// Returns the height of the highest font in range
-LyXFont::FONT_SIZE
+LyXFont_size
Paragraph::highestFontInRange(pos_type startpos, pos_type endpos,
- LyXFont::FONT_SIZE const def_size) const
+ LyXFont_size def_size) const
{
if (pimpl_->fontlist.empty())
return def_size;
void Paragraph::setFont(pos_type pos, LyXFont const & font)
{
- Assert(pos <= size());
+ BOOST_ASSERT(pos <= size());
// First, reduce font against layout/label font
// Update: The SetCharFont() routine in text2.C already
}
+namespace {
+
+/* paragraphs inside floats need different alignment tags to avoid
+unwanted space */
+
+bool noTrivlistCentering(UpdatableInset const * inset)
+{
+ if (inset && inset->owner()) {
+ InsetOld::Code const code = inset->owner()->lyxCode();
+ return code == InsetOld::FLOAT_CODE ||
+ code == InsetOld::WRAP_CODE;
+ }
+ return false;
+}
+
+
+string correction(string const & orig)
+{
+ if (orig == "flushleft")
+ return "raggedright";
+ if (orig == "flushright")
+ return "raggedleft";
+ if (orig == "center")
+ return "centering";
+ return orig;
+}
+
+
+string const corrected_env(string const & suffix, string const & env,
+ UpdatableInset const * inset)
+{
+ string output = suffix + "{";
+ if (noTrivlistCentering(inset))
+ output += correction(env);
+ else
+ output += env;
+ return output + "}";
+}
+
+} // namespace anon
+
// This could go to ParagraphParameters if we want to
int Paragraph::startTeXParParams(BufferParams const & bparams,
case LYX_ALIGN_LAYOUT:
case LYX_ALIGN_SPECIAL:
break;
- case LYX_ALIGN_LEFT:
- if (getParLanguage(bparams)->babel() != "hebrew") {
- os << "\\begin{flushleft}";
- column += 17;
- } else {
- os << "\\begin{flushright}";
- column += 18;
- }
+ case LYX_ALIGN_LEFT: {
+ string output;
+ UpdatableInset const * const inset = pimpl_->inset_owner;
+ if (getParLanguage(bparams)->babel() != "hebrew")
+ output = corrected_env("\\begin", "flushleft", inset);
+ else
+ output = corrected_env("\\begin", "flushright", inset);
+ os << output;
+ column += output.size();
break;
- case LYX_ALIGN_RIGHT:
- if (getParLanguage(bparams)->babel() != "hebrew") {
- os << "\\begin{flushright}";
- column += 18;
- } else {
- os << "\\begin{flushleft}";
- column += 17;
- }
+ } case LYX_ALIGN_RIGHT: {
+ string output;
+ UpdatableInset const * const inset = pimpl_->inset_owner;
+ if (getParLanguage(bparams)->babel() != "hebrew")
+ output = corrected_env("\\begin", "flushright", inset);
+ else
+ output = corrected_env("\\begin", "flushleft", inset);
+ os << output;
+ column += output.size();
break;
- case LYX_ALIGN_CENTER:
- os << "\\begin{center}";
- column += 14;
+ } case LYX_ALIGN_CENTER: {
+ string output;
+ output = corrected_env("\\begin", "center", pimpl_->inset_owner);
+ os << output;
+ column += output.size();
break;
}
+ }
return column;
}
case LYX_ALIGN_LAYOUT:
case LYX_ALIGN_SPECIAL:
break;
- case LYX_ALIGN_LEFT:
- if (getParLanguage(bparams)->babel() != "hebrew") {
- os << "\\end{flushleft}";
- column = 15;
- } else {
- os << "\\end{flushright}";
- column = 16;
- }
+ case LYX_ALIGN_LEFT: {
+ string output;
+ UpdatableInset const * const inset = pimpl_->inset_owner;
+ if (getParLanguage(bparams)->babel() != "hebrew")
+ output = corrected_env("\\par\\end", "flushleft", inset);
+ else
+ output = corrected_env("\\par\\end", "flushright", inset);
+ os << output;
+ column += output.size();
break;
- case LYX_ALIGN_RIGHT:
- if (getParLanguage(bparams)->babel() != "hebrew") {
- os << "\\end{flushright}";
- column+= 16;
- } else {
- os << "\\end{flushleft}";
- column = 15;
- }
+ } case LYX_ALIGN_RIGHT: {
+ string output;
+ UpdatableInset const * const inset = pimpl_->inset_owner;
+ if (getParLanguage(bparams)->babel() != "hebrew")
+ output = corrected_env("\\par\\end", "flushright", inset);
+ else
+ output = corrected_env("\\par\\end", "flushleft", inset);
+ os << output;
+ column += output.size();
break;
- case LYX_ALIGN_CENTER:
- os << "\\end{center}";
- column = 12;
+ } case LYX_ALIGN_CENTER: {
+ string output;
+ output = corrected_env("\\par\\end", "center", pimpl_->inset_owner);
+ os << output;
+ column += output.size();
break;
}
+ }
+
return column;
}
// This one spits out the text of the paragraph
-bool Paragraph::simpleTeXOnePar(Buffer const * buf,
+bool Paragraph::simpleTeXOnePar(Buffer const & buf,
BufferParams const & bparams,
LyXFont const & outerfont,
ostream & os, TexRow & texrow,
LyXLayout_ptr style;
// well we have to check if we are in an inset with unlimited
- // lenght (all in one row) if that is true then we don't allow
+ // 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!
bool asdefault =
}
+namespace {
+
+/// return true if the char is a meta-character for an inset
+inline
+bool IsInsetChar(char c)
+{
+ return (c == Paragraph::META_INSET);
+}
+
+} // namespace anon
+
bool Paragraph::isHfill(pos_type pos) const
bool Paragraph::isWord(pos_type pos) const
{
- return IsWordChar(getChar(pos)) ;
+ unsigned char const c = getChar(pos);
+ return !(IsSeparatorChar(c)
+ || IsKommaChar(c)
+ || IsInsetChar(c));
}
Language const *
Paragraph::getParLanguage(BufferParams const & bparams) const
{
- if (!empty()) {
+ if (!empty())
return getFirstFontSettings().language();
#warning FIXME we should check the prev par as well (Lgb)
-#if 0
- } else if (previous_) {
- return previous_->getParLanguage(bparams);
-#endif
- }else
- return bparams.language;
+ return bparams.language;
}
for (; cit != end; ++cit)
if (cit->font().language() != ignore_language &&
cit->font().language() != latex_language &&
- cit->font().language() != doc_language)
+ cit->font().language() != doc_language)
return true;
return false;
}
// Convert the paragraph to a string.
// Used for building the table of contents
-string const Paragraph::asString(Buffer const * buffer, bool label) const
+string const Paragraph::asString(Buffer const & buffer, bool label) const
{
#if 0
string s;
}
-string const Paragraph::asString(Buffer const * buffer,
+string const Paragraph::asString(Buffer const & buffer,
pos_type beg, pos_type end, bool label) const
{
ostringstream os;
os << params().labelString() << ' ';
for (pos_type i = beg; i < end; ++i) {
- value_type const c = getUChar(buffer->params, i);
+ value_type const c = getUChar(buffer.params(), i);
if (IsPrintable(c))
os << c;
else if (c == META_INSET)
getInset(i)->ascii(buffer, os);
}
- return STRCONV(os.str());
+ return os.str();
}
}
-void Paragraph::resizeInsetsLyXText(BufferView * bv)
-{
- insetlist.resizeInsetsLyXText(bv);
-}
-
-
void Paragraph::setContentsFromPar(Paragraph const & par)
{
pimpl_->setContentsFromPar(par);
Change::Type Paragraph::lookupChange(lyx::pos_type pos) const
{
- Assert(!size() || pos < size());
+ BOOST_ASSERT(!size() || pos < size());
return pimpl_->lookupChange(pos);
}
Change const Paragraph::lookupChangeFull(lyx::pos_type pos) const
{
- Assert(!size() || pos < size());
+ BOOST_ASSERT(!size() || pos < size());
return pimpl_->lookupChangeFull(pos);
}
}
-lyx::pos_type Paragraph::size() const
+Paragraph::value_type Paragraph::getChar(pos_type pos) const
{
- return pimpl_->size();
-}
+ // This is in the critical path!
+ pos_type const siz = text_.size();
+ BOOST_ASSERT(pos <= siz);
-bool Paragraph::empty() const
-{
- return pimpl_->empty();
-}
-
+ if (pos == siz) {
+ lyxerr << "getChar() on pos " << pos << " in par id "
+ << id() << " of size " << siz
+ << " is a bit silly !" << endl;
+ return '\0';
+ }
-Paragraph::value_type Paragraph::getChar(pos_type pos) const
-{
- return pimpl_->getChar(pos);
+ return text_[pos];
}
void Paragraph::clearContents()
{
- pimpl_->clear();
+ text_.clear();
}
+
void Paragraph::setChar(pos_type pos, value_type c)
{
- pimpl_->setChar(pos, c);
+ text_[pos] = c;
}
return true;
// for now we just need this, later should we need this in some
- // other way we can always add a function to InsetOld::() 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() == InsetOld::ERT_CODE);
+ return pimpl_->inset_owner->owner()->lyxCode() == InsetOld::ERT_CODE;
return false;
}
if (layout()->keepempty)
return true;
if (pimpl_->inset_owner && pimpl_->inset_owner->owner())
- return (pimpl_->inset_owner->owner()->lyxCode() == InsetOld::ERT_CODE);
+ 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;
-}
projects / lyx.git / blobdiff