* LyX, The Document Processor
*
* Copyright 1995 Matthias Ettrich
- * Copyright 1995-2000 The LyX Team.
+ * Copyright 1995-2001 The LyX Team.
*
* ====================================================== */
#pragma interface
#endif
+#include "LString.h"
+
#include <vector>
#include <list>
+#include <boost/array.hpp>
#include "insets/lyxinset.h"
-#include "table.h"
-#include "vspace.h"
-#include "layout.h"
-#include "support/block.h"
-#include "language.h"
+#include "ParagraphParameters.h"
+#include "support/LAssert.h"
class BufferParams;
class LyXBuffer;
struct LaTeXFeatures;
class InsetBibKey;
class BufferView;
+class Language;
+
+// After 1.2.0 is released, during 1.3.0cvs, we enable this. And after
+// a while we verify that reading of 1.2.x files work perfectly we remove
+// this code completely. (Lgb)
+//#define NO_PEXTRA_REALLY 1
+
+// Define this if you want to try out the new storage container for
+// paragraphs. std::container instead of obfuscated homegrown
+// linked list. (Lgb)
+// This is non working and far from finished.
+// #define NO_NEXT 1
/// A LyXParagraph holds all text, attributes and insets in a text paragraph
class LyXParagraph {
public:
+#ifndef NO_PEXTRA_REALLY
///
enum PEXTRA_TYPE {
///
///
MINIPAGE_ALIGN_BOTTOM
};
+#endif
///
enum META_KIND {
///
- META_FOOTNOTE = 1,
- ///
- META_MARGIN,
- ///
- META_FIG,
- ///
- META_TAB,
- ///
- META_ALGORITHM,
- ///
- META_WIDE_FIG,
- ///
- META_WIDE_TAB,
- ///
- META_HFILL,
+ META_HFILL = 1,
///
META_NEWLINE,
///
- //META_PROTECTED_SEPARATOR,
- ///
META_INSET
};
-
- /// The footnoteflag
- enum footnote_flag {
- ///
- NO_FOOTNOTE,
- ///
- OPEN_FOOTNOTE,
- ///
- CLOSED_FOOTNOTE
- };
-
- /// The footnotekinds
- enum footnote_kind {
- ///
- FOOTNOTE,
- ///
- MARGIN,
- ///
- FIG,
- ///
- TAB,
- ///
- ALGORITHM, // Bernhard, 970807
- ///
- WIDE_FIG, // CFO-G, 971106
- ///
- WIDE_TAB // CFO-G, 971106
- };
-
///
typedef char value_type;
///
typedef std::vector<value_type> TextContainer;
///
- typedef int size_type;
+ /* This should be TextContainer::size_type, but we need
+ signed values for now.
+ */
+ typedef TextContainer::difference_type size_type;
///
LyXParagraph();
- /// this konstruktor inserts the new paragraph in a list
+ /// this constructor inserts the new paragraph in a list
explicit
LyXParagraph(LyXParagraph * par);
- /// the destruktors removes the new paragraph from the list
+ ///
+ LyXParagraph(LyXParagraph const &);
+ /// the destructor removes the new paragraph from the list
~LyXParagraph();
///
bool isMultiLingual(BufferParams const &);
///
- string String(Buffer const *, bool label);
+ string const String(Buffer const *, bool label);
///
- string String(Buffer const *, size_type beg, size_type end);
+ string const String(Buffer const *, size_type beg, size_type end);
///
void writeFile(Buffer const *, std::ostream &, BufferParams const &,
- char, char) const;
+ char) const;
///
void validate(LaTeXFeatures &) const;
///
- int id() const {
- return id_;
- }
+ int id() const;
///
- void id(int id_arg) {
- id_ = id_arg;
- }
-
+ void id(int id_arg);
///
void read();
///
LyXParagraph * TeXOnePar(Buffer const *, BufferParams const &,
std::ostream &, TexRow & texrow,
- bool moving_arg,
- std::ostream & foot, TexRow & foot_texrow,
- int & foot_count);
+ bool moving_arg);
///
bool SimpleTeXOnePar(Buffer const *, BufferParams const &,
std::ostream &, TexRow & texrow, bool moving_arg);
///
LyXParagraph * TeXEnvironment(Buffer const *, BufferParams const &,
- std::ostream &, TexRow & texrow,
- std::ostream & foot, TexRow & foot_texrow,
- int & foot_count);
- ///
- LyXParagraph * Clone() const;
-
+ std::ostream &, TexRow & texrow);
///
bool HasSameLayout(LyXParagraph const * par) const;
void MakeSameLayout(LyXParagraph const * par);
/// Is it the first par with same depth and layout?
- bool IsFirstInSequence() const {
- LyXParagraph const * dhook = DepthHook(GetDepth());
- return (dhook == this
- || dhook->GetLayout() != GetLayout()
- || dhook->GetDepth() != GetDepth());
- }
+ bool IsFirstInSequence() const;
/** Check if the current paragraph is the last paragraph in a
proof environment */
int GetEndLabel(BufferParams const &) const;
///
- Inset * InInset() { return inset_owner; }
+ Inset * InInset();
///
void SetInsetOwner(Inset * i);
///
void deleteInsetsLyXText(BufferView *);
+ ///
+ void resizeInsetsLyXText(BufferView *);
private:
///
TextContainer text;
public:
///
- size_type size() const { return text.size(); }
- ///
- void fitToSize() {
- text.resize(text.size());
- }
- void setContentsFromPar(LyXParagraph * par) {
- text = par->text;
- }
- void clearContents() {
- text.clear();
- }
-
- ///
- VSpace added_space_top;
-
- ///
- VSpace added_space_bottom;
-
+ inline
+ size_type size() const;
///
- Spacing spacing;
-
- ///
- LyXTextClass::LayoutList::size_type layout;
-
- /**
- \begin{itemize}
- \item no footnote, closed footnote,
- \item open footnote, where footnote
- \item means footnote-environment
- \end{itemize}
- */
- footnote_flag footnoteflag;
-
- /// footnote, margin, fig, tab
- footnote_kind footnotekind;
-
- //@Man: the LyX- DTP-switches
- //@{
- ///
- bool line_top;
-
+ void fitToSize();
///
- bool line_bottom;
-
- ///
- bool pagebreak_top;
-
+ void setContentsFromPar(LyXParagraph * par);
///
- bool pagebreak_bottom;
-
- ///
- LyXAlignment align;
-
- ///
- char depth;
+ void clearContents();
+
+ ParagraphParameters params;
///
- bool noindent;
-
+ LyXTextClass::LayoutList::size_type layout;
private:
- block<int, 10> counter_;
+ ///
+ boost::array<int, 10> counter_;
public:
///
- void setCounter(int i, int v) { counter_[i] = v; }
- int getCounter(int i) const { return counter_[i]; }
- void incCounter(int i) { counter_[i]++; }
+ void setCounter(int i, int v);
///
- bool start_of_appendix;
-
+ int getCounter(int i) const;
///
- bool appendix;
+ void incCounter(int i);
///
char enumdepth;
///
char itemdepth;
-
- /* This is for the paragraph extra stuff */
- ///
- int pextra_type;
- ///
- string pextra_width;
- ///
- string pextra_widthp;
- ///
- int pextra_alignment;
- ///
- bool pextra_hfill;
- ///
- bool pextra_start_minipage;
-
- ///
- string labelstring;
-
- ///
- string labelwidthstring;
- //@}
-
- ///
- LyXParagraph * next;
+private:
///
- LyXParagraph * previous;
-
- /* table stuff -- begin*/
+ LyXParagraph * next_;
///
- LyXTable * table;
- /* table stuff -- end*/
-
+ LyXParagraph * previous_;
+public:
///
InsetBibKey * bibkey; // ale970302
+ ///
+ void next(LyXParagraph *);
/** these function are able to hide closed footnotes
*/
- LyXParagraph * Next();
-
- ///
- LyXParagraph * Previous();
+ LyXParagraph * next();
///
- LyXParagraph const * Previous() const;
+ LyXParagraph const * next() const;
- /** these function are able to hide open and closed footnotes
- */
- LyXParagraph * NextAfterFootnote();
///
- LyXParagraph const * NextAfterFootnote() const;
-
- ///
- LyXParagraph * PreviousBeforeFootnote();
- ///
- LyXParagraph * LastPhysicalPar();
- ///
- LyXParagraph const * LastPhysicalPar() const;
-
+ void previous(LyXParagraph *);
///
- LyXParagraph * FirstPhysicalPar();
+ LyXParagraph * previous();
///
- LyXParagraph const * FirstPhysicalPar() const;
-
- /// returns the physical paragraph
- LyXParagraph * ParFromPos(size_type pos);
- /// returns the position in the physical par
- int PositionInParFromPos(size_type pos) const;
+ LyXParagraph const * previous() const;
/// for the environments
LyXParagraph * DepthHook(int depth);
///
int BeginningOfMainBody() const;
///
- string GetLabelstring() const;
+ string const & GetLabelstring() const;
/// the next two functions are for the manual labels
- string GetLabelWidthString() const;
+ string const GetLabelWidthString() const;
///
void SetLabelWidthString(string const & s);
///
+ inline
LyXTextClass::LayoutList::size_type GetLayout() const;
///
char GetAlign() const;
///
char GetDepth() const;
///
- void SetLayout(BufferParams const &,
- LyXTextClass::LayoutList::size_type new_layout);
+ void SetLayout(LyXTextClass::LayoutList::size_type new_layout);
///
- void SetOnlyLayout(BufferParams const &,
- LyXTextClass::LayoutList::size_type new_layout);
+ void SetOnlyLayout(LyXTextClass::LayoutList::size_type new_layout);
///
int GetFirstCounter(int i) const;
///
- size_type Last() const;
- ///
void Erase(size_type pos);
/** the flag determines wether the layout should be copied
*/
///
void BreakParagraphConservative(BufferParams const &, size_type pos);
/** Get unistantiated font setting. Returns the difference
- between the characters font and the layoutfont.
- This is what is stored in the fonttable
- */
- LyXFont GetFontSettings(BufferParams const &, size_type pos) const;
+ between the characters font and the layoutfont.
+ This is what is stored in the fonttable
+ */
+ LyXFont const
+ GetFontSettings(BufferParams const &, size_type pos) const;
///
- LyXFont GetFirstFontSettings() const;
+ LyXFont const GetFirstFontSettings() const;
/** Get fully instantiated font. If pos == -1, use the layout
- font attached to this paragraph.
- If pos == -2, use the label font of the layout attached here.
- In all cases, the font is instantiated, i.e. does not have any
- attributes with values LyXFont::INHERIT, LyXFont::IGNORE or
- LyXFont::TOGGLE.
- */
- LyXFont getFont(BufferParams const &, size_type pos) const;
+ font attached to this paragraph.
+ If pos == -2, use the label font of the layout attached here.
+ In all cases, the font is instantiated, i.e. does not have any
+ attributes with values LyXFont::INHERIT, LyXFont::IGNORE or
+ LyXFont::TOGGLE.
+ */
+ LyXFont const getFont(BufferParams const &, size_type pos) const;
///
- char GetChar(size_type pos);
+ value_type GetChar(size_type pos) const;
///
- char GetChar(size_type pos) const;
+ value_type GetUChar(BufferParams const &, size_type pos) const;
/// The position must already exist.
- void SetChar(size_type pos, char c) {
- text[pos] = c;
- }
-
+ void SetChar(size_type pos, value_type c);
///
void SetFont(size_type pos, LyXFont const & font);
///
- string GetWord(size_type &) const;
+ string const GetWord(size_type &) const;
/// Returns the height of the highest font in range
LyXFont::FONT_SIZE HighestFontInRange(size_type startpos,
size_type endpos) const;
///
- void InsertChar(size_type pos, char c);
+ void InsertChar(size_type pos, value_type c);
+ ///
+ void InsertChar(size_type pos, value_type c, LyXFont const &);
///
void InsertInset(size_type pos, Inset * inset);
///
+ void InsertInset(size_type pos, Inset * inset, LyXFont const &);
+ ///
bool InsertInsetAllowed(Inset * inset);
///
Inset * GetInset(size_type pos);
///
Inset const * GetInset(size_type pos) const;
- ///
- void OpenFootnote(size_type pos);
- ///
- void CloseFootnote(size_type pos);
- /// important for cut and paste
- void CopyIntoMinibuffer(BufferParams const &, size_type pos) const;
+ /** important for cut and paste
+ Temporary change from BufferParams to Buffer. Will revert when we
+ get rid of the argument to Inset::Clone(Buffer const &) */
+ void CopyIntoMinibuffer(Buffer const &, size_type pos) const;
///
void CutIntoMinibuffer(BufferParams const &, size_type pos);
///
///
bool IsInset(size_type pos) const;
///
- bool IsFloat(size_type pos) const;
- ///
bool IsNewline(size_type pos) const;
///
bool IsSeparator(size_type pos) const;
bool IsWord(size_type pos) const;
/** This one resets all layout and dtp switches but not the font
- of the single characters
- */
+ of the single characters
+ */
void Clear();
/** paste this paragraph with the next one
- be carefull, this doesent make any check at all
- */
+ be carefull, this doesent make any check at all
+ */
void PasteParagraph(BufferParams const &);
/// used to remove the error messages
/// returns -1 if inset not found
int GetPositionOfInset(Inset * inset) const;
-
- /// ok and now some footnote functions
- void OpenFootnotes();
-
- ///
- void CloseFootnotes();
-
- ///
- LyXParagraph * FirstSelfrowPar();
///
int StripLeadingSpaces(LyXTextClassList::size_type tclass);
-
- /** A paragraph following a footnote is a "dummy". A paragraph
- with a footnote in it is stored as three paragraphs:
- First a paragraph with the text up to the footnote, then
- one (or more) paragraphs with the footnote, and finally
- the a paragraph with the text after the footnote. Only the
- first paragraph keeps information about layoutparameters, */
- bool IsDummy() const;
+#ifndef NO_PEXTRA_REALLY
/* If I set a PExtra Indent on one paragraph of a ENV_LIST-TYPE
I have to set it on each of it's elements */
///
- void SetPExtraType(BufferParams const &,
- int type, char const * width, char const * widthp);
+ void SetPExtraType(BufferParams const &, int type,
+ string const & width, string const & widthp);
///
void UnsetPExtraType(BufferParams const &);
-#if 0
- ///
- bool RoffContTableRows(std::ostream &, size_type i, int actcell);
#endif
///
bool linuxDocConvertChar(char c, string & sgml_string);
- ///
- void DocBookContTableRows(Buffer const *,
- std::ostream &, string & extra,
- int & desc_on, size_type i,
- int current_cell_number, int & column);
- ///
- void SimpleDocBookOneTablePar(Buffer const *,
- std::ostream &, string & extra,
- int & desc_on, int depth);
private:
///
struct InsetTable {
///
Inset * inset;
///
- InsetTable(size_type p, Inset * i) { pos = p; inset = i;}
+ InsetTable(size_type p, Inset * i) : pos(p), inset(i) {}
};
///
friend struct matchIT;
///
struct matchIT {
- /// used by lower_bound
+ /// used by lower_bound and upper_bound
inline
int operator()(LyXParagraph::InsetTable const & a,
- LyXParagraph::size_type pos) const {
- return a.pos < pos;
- }
- /// used by upper_bound
- inline
- int operator()(LyXParagraph::size_type pos,
- LyXParagraph::InsetTable const & a) const {
- return pos < a.pos;
+ LyXParagraph::InsetTable const & b) const {
+ return a.pos < b.pos;
}
};
/** A font entry covers a range of positions. Notice that the
- entries in the list are inserted in random order.
- I don't think it's worth the effort to implement a more effective
- datastructure, because the number of different fonts in a paragraph
- is limited. (Asger)
- Nevertheless, I decided to store fontlist using a sorted vector:
- fontlist = { {pos_1,font_1} , {pos_2,font_2} , ... } where
- pos_1 < pos_2 < ..., font_{i-1} != font_i for all i,
- and font_i covers the chars in positions pos_{i-1}+1,...,pos_i
- (font_1 covers the chars 0,...,pos_1) (Dekel)
+ entries in the list are inserted in random order.
+ I don't think it's worth the effort to implement a more effective
+ datastructure, because the number of different fonts in a paragraph
+ is limited. (Asger)
+ Nevertheless, I decided to store fontlist using a sorted vector:
+ fontlist = { {pos_1,font_1} , {pos_2,font_2} , ... } where
+ pos_1 < pos_2 < ..., font_{i-1} != font_i for all i,
+ and font_i covers the chars in positions pos_{i-1}+1,...,pos_i
+ (font_1 covers the chars 0,...,pos_1) (Dekel)
*/
struct FontTable {
+ ///
+ FontTable(size_type p, LyXFont const & f)
+ : pos_(p)
+ {
+ font_ = container.get(f);
+ }
+ ///
+ size_type pos() const { return pos_; }
+ ///
+ void pos(size_type p) { pos_ = p; }
+ ///
+ LyXFont const & font() const { return *font_; }
+ ///
+ void font(LyXFont const & f) { font_ = container.get(f);}
+ private:
/// End position of paragraph this font attribute covers
- size_type pos;
+ size_type pos_;
/** Font. Interpretation of the font values:
- If a value is LyXFont::INHERIT_*, it means that the font
- attribute is inherited from either the layout of this
- paragraph or, in the case of nested paragraphs, from the
- layout in the environment one level up until completely
- resolved.
- The values LyXFont::IGNORE_* and LyXFont::TOGGLE are NOT
- allowed in these font tables.
+ If a value is LyXFont::INHERIT_*, it means that the font
+ attribute is inherited from either the layout of this
+ paragraph or, in the case of nested paragraphs, from the
+ layout in the environment one level up until completely
+ resolved.
+ The values LyXFont::IGNORE_* and LyXFont::TOGGLE are NOT
+ allowed in these font tables.
*/
- LyXFont font;
+ boost::shared_ptr<LyXFont> font_;
///
- FontTable(size_type p, LyXFont const & f) {pos = p; font = f;}
+ static ShareContainer<LyXFont> container;
};
+ ///
friend struct matchFT;
///
struct matchFT {
- /// used by lower_bound
+ /// used by lower_bound and upper_bound
inline
int operator()(LyXParagraph::FontTable const & a,
- LyXParagraph::size_type pos) const {
- return a.pos < pos;
- }
- /// used by upper_bound
- inline
- int operator()(LyXParagraph::size_type pos,
- LyXParagraph::FontTable const & a) const {
- return pos < a.pos;
+ LyXParagraph::FontTable const & b) const {
+ return a.pos() < b.pos();
}
};
InsetList insetlist;
///
LyXParagraph * TeXDeeper(Buffer const *, BufferParams const &,
- std::ostream &, TexRow & texrow,
- std::ostream & foot, TexRow & foot_texrow,
- int & foot_count);
- ///
- LyXParagraph * TeXFootnote(Buffer const *, BufferParams const &,
- std::ostream &, TexRow & texrow,
- std::ostream & foot, TexRow & foot_texrow,
- int & foot_count,
- bool parent_is_rtl);
- ///
- bool SimpleTeXOneTablePar(Buffer const *, BufferParams const &,
- std::ostream &, TexRow & texrow);
- ///
- bool TeXContTableRows(Buffer const *, BufferParams const &,
- std::ostream &, size_type i,
- int current_cell_number,
- int & column, TexRow & texrow);
+ std::ostream &, TexRow & texrow);
///
void SimpleTeXBlanks(std::ostream &, TexRow & texrow,
size_type const i,
LyXFont & basefont, bool & open_font,
LyXLayout const & style,
size_type & i,
- int & column, char const c);
+ int & column, value_type const c);
///
unsigned int id_;
///
static unsigned int paragraph_id;
public:
+ ///
class inset_iterator {
public:
+ ///
inset_iterator() {}
+ //
inset_iterator(InsetList::iterator const & iter) : it(iter) {};
+ ///
inset_iterator & operator++() {
++it;
return *this;
}
+ ///
Inset * operator*() { return (*it).inset; }
- size_type getPos() {return (*it).pos; }
+ ///
+ size_type getPos() const {return (*it).pos; }
+ ///
bool operator==(inset_iterator const & iter) const {
return it == iter.it;
}
+ ///
bool operator!=(inset_iterator const & iter) const {
return it != iter.it;
}
private:
+ ///
InsetList::iterator it;
};
///
- inset_iterator inset_iterator_begin() {
- return inset_iterator(insetlist.begin());
- }
+ inset_iterator inset_iterator_begin();
///
- inset_iterator inset_iterator_end() {
- return inset_iterator(insetlist.end());
- }
+ inset_iterator inset_iterator_end();
///
inset_iterator InsetIterator(size_type pos);
-
};
+
+inline
+LyXParagraph::size_type LyXParagraph::size() const
+{
+ return text.size();
+}
+
+
+inline
+LyXParagraph::value_type
+LyXParagraph::GetChar(LyXParagraph::size_type pos) const
+{
+ lyx::Assert(pos <= size());
+ // This is stronger, and I belive that this is the assertion
+ // that we should really use. (Lgb)
+ //Assert(pos < size());
+
+ // Then this has no meaning. (Lgb)
+ if (!size() || pos == size()) return '\0';
+
+ return text[pos];
+}
+
+
+inline
+int LyXParagraph::id() const
+{
+ return id_;
+}
+
+
+inline
+void LyXParagraph::id(int id_arg)
+{
+ id_ = id_arg;
+}
+
+
+inline
+LyXTextClass::size_type LyXParagraph::GetLayout() const
+{
+ return layout;
+}
+
+
+inline
+bool LyXParagraph::IsFirstInSequence() const
+{
+ LyXParagraph const * dhook = DepthHook(GetDepth());
+ return (dhook == this
+ || dhook->GetLayout() != GetLayout()
+ || dhook->GetDepth() != GetDepth());
+}
+
+
+inline
+Inset * LyXParagraph::InInset()
+{
+ return inset_owner;
+}
+
+
+inline
+void LyXParagraph::clearContents()
+{
+ text.clear();
+}
+
+
+inline
+void LyXParagraph::setCounter(int i, int v)
+{
+ counter_[i] = v;
+}
+
+
+inline
+int LyXParagraph::getCounter(int i) const
+{
+ return counter_[i];
+}
+
+
+inline
+void LyXParagraph::incCounter(int i)
+{
+ counter_[i]++;
+}
+
+
+inline
+void LyXParagraph::SetChar(size_type pos, value_type c)
+{
+ text[pos] = c;
+}
+
+
+inline
+LyXParagraph::inset_iterator LyXParagraph::inset_iterator_begin()
+{
+ return inset_iterator(insetlist.begin());
+}
+
+
+inline
+LyXParagraph::inset_iterator LyXParagraph::inset_iterator_end()
+{
+ return inset_iterator(insetlist.end());
+}
#endif
projects / lyx.git / blobdiff