X-Git-Url: https://git.lyx.org/gitweb/?a=blobdiff_plain;f=src%2Flyxparagraph.h;h=8311f79e04bda0e4239d77f4d6fd5ddfb66cbe8e;hb=4590c8cfab02a3bc56813cfb1f2e80bd1119af9e;hp=caa3540fdb8e344a31176937c23725a31eb15ad0;hpb=65e9b99a59e4e3ebc1fc6b688239faac5007b88e;p=lyx.git diff --git a/src/lyxparagraph.h b/src/lyxparagraph.h index caa3540fdb..8311f79e04 100644 --- a/src/lyxparagraph.h +++ b/src/lyxparagraph.h @@ -1,11 +1,11 @@ // -*- C++ -*- /* This file is part of - * ====================================================== + * ====================================================== * * LyX, The Document Processor * * Copyright 1995 Matthias Ettrich - * Copyright 1995-1999 The LyX Team. + * Copyright 1995-2001 The LyX Team. * * ====================================================== */ @@ -16,680 +16,590 @@ #pragma interface #endif -#define NEW_TEXT 1 -//#define NEW_TABLE 1 +#include "LString.h" -#ifdef NEW_TABLE -#include -#endif - -#ifdef NEW_TEXT #include -//#include -//#define __STD_STUFF 1 -//#include -#endif +#include +#include -#include "definitions.h" #include "insets/lyxinset.h" -#include "table.h" -#include "support/textutils.h" -#include "vspace.h" -#include "insets/insetbib.h" -#include "layout.h" +#include "ParagraphParameters.h" +#include "support/LAssert.h" class BufferParams; class LyXBuffer; class TexRow; 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: - /// The footnoteflag - enum footnote_flag { +#ifndef NO_PEXTRA_REALLY + /// + enum PEXTRA_TYPE { /// - NO_FOOTNOTE, + PEXTRA_NONE, /// - OPEN_FOOTNOTE, + PEXTRA_INDENT, /// - CLOSED_FOOTNOTE - }; - - /// The footnotekinds - enum footnote_kind { + PEXTRA_MINIPAGE, /// - FOOTNOTE, + PEXTRA_FLOATFLT + }; + /// + enum MINIPAGE_ALIGNMENT { /// - MARGIN, + MINIPAGE_ALIGN_TOP, /// - FIG, + MINIPAGE_ALIGN_MIDDLE, /// - TAB, + MINIPAGE_ALIGN_BOTTOM + }; +#endif + /// + enum META_KIND { /// - ALGORITHM, // Bernhard, 970807 + META_HFILL = 1, /// - WIDE_FIG, // CFO-G, 971106 + META_NEWLINE, /// - WIDE_TAB // CFO-G, 971106 + META_INSET }; - + /// + typedef char value_type; + /// + typedef std::vector TextContainer; + /// + /* 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(); /// - void writeFile(FILE *, BufferParams &, char, char); + Language const * getParLanguage(BufferParams const &) const; + /// + bool isRightToLeftPar(BufferParams const &) const; + /// + void ChangeLanguage(BufferParams const & bparams, + Language const * from, Language const * to); + /// + bool isMultiLingual(BufferParams const &); + /// + string const String(Buffer const *, bool label); /// - void validate(LaTeXFeatures &); + string const String(Buffer const *, size_type beg, size_type end); /// - int GetID(){ - return id; - } - /// - void SetID(int id_arg){ - id = id_arg; - } - -#ifndef NEW_TEXT - /** allocates more memory for the specified paragraph - pos is needed to specify the paragraph correctly. Remember the - closed footnotes - */ - void Enlarge(int pos, int number); - /** make the allocated memory fit to the needed size - used to make a paragraph smaller - */ - void FitSize(); -#endif - + void writeFile(Buffer const *, std::ostream &, BufferParams const &, + char) const; /// - void read(); + void validate(LaTeXFeatures &) const; /// - void readSimpleWholeFile(FILE *); - + int id() const; + /// + void id(int id_arg); /// - LyXParagraph * TeXOnePar(string & file, TexRow & texrow, - string & foot, TexRow & foot_texrow, - int & foot_count); + void read(); /// - LyXParagraph * TeXEnvironment(string & file, TexRow & texrow, - string & foot, TexRow & foot_texrow, - int & foot_count); - + LyXParagraph * TeXOnePar(Buffer const *, BufferParams const &, + std::ostream &, TexRow & texrow, + bool moving_arg); /// - LyXParagraph * Clone(); - + bool SimpleTeXOnePar(Buffer const *, BufferParams const &, + std::ostream &, TexRow & texrow, bool moving_arg); + /// - bool HasSameLayout(LyXParagraph * par); + LyXParagraph * TeXEnvironment(Buffer const *, BufferParams const &, + std::ostream &, TexRow & texrow); + /// + bool HasSameLayout(LyXParagraph const * par) const; /// - void MakeSameLayout(LyXParagraph * par); + void MakeSameLayout(LyXParagraph const * par); /// Is it the first par with same depth and layout? - bool IsFirstInSequence() { - LyXParagraph * dhook = DepthHook(GetDepth()); - return (dhook == this - || dhook->GetLayout() != GetLayout() - || dhook->GetDepth() != GetDepth()); - } - + bool IsFirstInSequence() const; -#ifdef NEW_TEXT + /** Check if the current paragraph is the last paragraph in a + proof environment */ + int GetEndLabel(BufferParams const &) const; /// - typedef char value_type; - /// - typedef vector TextContainer; - //typedef deque TextContainer; - //typedef rope TextContainer; - typedef int size_type; - /// - TextContainer text; + Inset * InInset(); /// - size_type size() const { return text.size(); } -#else + void SetInsetOwner(Inset * i); /// - int last; + void deleteInsetsLyXText(BufferView *); /// - int size; + void resizeInsetsLyXText(BufferView *); +private: /// - char * text; -#endif - /// - VSpace added_space_top; - - /// - VSpace added_space_bottom; - + TextContainer text; /// - 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; + Inset * inset_owner; - /// footnote, margin, fig, tab - footnote_kind footnotekind; - - //@Man: the LyX- DTP-switches - //@{ +public: /// - bool line_top; - + inline + size_type size() const; /// - bool line_bottom; - - /// - bool pagebreak_top; - + void fitToSize(); /// - bool pagebreak_bottom; - - /// - LyXAlignment align; - + void setContentsFromPar(LyXParagraph * par); /// - char depth; + void clearContents(); + + ParagraphParameters params; /// - bool noindent; - + LyXTextClass::LayoutList::size_type layout; private: /// - int counter[10]; + boost::array counter_; public: /// - void setCounter(int i, int v) { counter[i] = v; } - int getCounter(int i) { 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 * next(); /// - LyXParagraph * Previous(); + LyXParagraph const * next() const; - /** these function are able to hide open and closed footnotes - */ - LyXParagraph * NextAfterFootnote(); /// - LyXParagraph * PreviousBeforeFootnote(); + void previous(LyXParagraph *); /// - LyXParagraph * LastPhysicalPar(); + LyXParagraph * previous(); /// - LyXParagraph * FirstPhysicalPar(); - -#ifdef NEW_TEXT - /// returns the physical paragraph - LyXParagraph * ParFromPos(size_type pos); - /// returns the position in the physical par - int PositionInParFromPos(size_type pos); -#else - /// returns the physical paragraph - LyXParagraph * ParFromPos(int pos); - /// returns the position in the physical par - int PositionInParFromPos(int pos); -#endif + LyXParagraph const * previous() const; /// for the environments LyXParagraph * DepthHook(int depth); + /// for the environments + LyXParagraph const * DepthHook(int depth) const; /// - int BeginningOfMainBody(); + int BeginningOfMainBody() const; /// - string GetLabestring(); + string const & GetLabelstring() const; /// the next two functions are for the manual labels - string GetLabelWidthString(); + string const GetLabelWidthString() const; /// void SetLabelWidthString(string const & s); /// - LyXTextClass::LayoutList::size_type GetLayout(); + inline + LyXTextClass::LayoutList::size_type GetLayout() const; /// - char GetAlign(); + char GetAlign() const; /// - char GetDepth(); + char GetDepth() const; /// void SetLayout(LyXTextClass::LayoutList::size_type new_layout); /// void SetOnlyLayout(LyXTextClass::LayoutList::size_type new_layout); /// - int GetFirstCounter(int i); -#ifdef NEW_TEXT - /// - size_type Last(); + int GetFirstCounter(int i) const; /// void Erase(size_type pos); /** the flag determines wether the layout should be copied */ - void BreakParagraph(size_type pos, int flag); + void BreakParagraph(BufferParams const &, size_type pos, int flag); /// - void BreakParagraphConservative(size_type pos); + 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(size_type pos); - /** 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(size_type pos); - /// - char GetChar(size_type pos); - /// - void SetFont(size_type pos, LyXFont const & font); - /// - string GetWord(size_type &); - /// 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 InsertInset(size_type pos, Inset * inset); - /// - Inset * GetInset(size_type pos); - /// - Inset * ReturnNextInsetPointer(size_type & pos); - /// - void OpenFootnote(size_type pos); - /// - void CloseFootnote(size_type pos); - /// important for cut and paste - void CopyIntoMinibuffer(size_type pos); - /// - void CutIntoMinibuffer(size_type pos); - /// - void InsertFromMinibuffer(size_type pos); - /// - bool IsHfill(size_type pos) { - return IsHfillChar(GetChar(pos)); - } - - /// - bool IsInset(size_type pos) { - return IsInsetChar(GetChar(pos)); - } - - /// - bool IsFloat(size_type pos) { - return IsFloatChar(GetChar(pos)); - } - - /// - bool IsNewline(size_type pos) { - bool tmp = false; - if (pos >= 0) - tmp= IsNewlineChar(GetChar(pos)); - return tmp; - } - - /// - bool IsSeparator(size_type pos) { - return IsSeparatorChar(GetChar(pos)); - } - - /// - bool IsLineSeparator(size_type pos) { - return IsLineSeparatorChar(GetChar(pos)); - } - - /// - bool IsKomma(size_type pos){ - return IsKommaChar(GetChar(pos)); - } - - /// Used by the spellchecker - bool IsLetter(size_type pos); - - /// - bool IsWord(size_type pos ) { - return IsWordChar( GetChar(pos) ) ; - } -#else - /// - int Last(); - /// - void Erase(int pos); - /** the flag determines wether the layout should be copied - */ - void BreakParagraph(int pos, int flag); + between the characters font and the layoutfont. + This is what is stored in the fonttable + */ + LyXFont const + GetFontSettings(BufferParams const &, size_type pos) const; /// - void BreakParagraphConservative(int 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(int pos); + 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(int pos); + 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(int pos); + value_type GetChar(size_type pos) const; /// - void SetFont(int pos, LyXFont const & font); + value_type GetUChar(BufferParams const &, size_type pos) const; + /// The position must already exist. + void SetChar(size_type pos, value_type c); /// - string GetWord(int &); + void SetFont(size_type pos, LyXFont const & font); + /// + string const GetWord(size_type &) const; /// Returns the height of the highest font in range - LyXFont::FONT_SIZE HighestFontInRange(int startpos, int endpos) const; + LyXFont::FONT_SIZE HighestFontInRange(size_type startpos, + size_type endpos) const; /// - void InsertChar(int pos, char c); + void InsertChar(size_type pos, value_type c); /// - void InsertInset(int pos, Inset * inset); + void InsertChar(size_type pos, value_type c, LyXFont const &); /// - Inset * GetInset(int pos); + void InsertInset(size_type pos, Inset * inset); /// - Inset * ReturnNextInsetPointer(int & pos); + void InsertInset(size_type pos, Inset * inset, LyXFont const &); /// - void OpenFootnote(int pos); + bool InsertInsetAllowed(Inset * inset); /// - void CloseFootnote(int pos); - /// important for cut and paste - void CopyIntoMinibuffer(int pos); + Inset * GetInset(size_type pos); /// - void CutIntoMinibuffer(int pos); + Inset const * GetInset(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 InsertFromMinibuffer(int pos); + void CutIntoMinibuffer(BufferParams const &, size_type pos); /// - bool IsHfill(int pos) { - return IsHfillChar(GetChar(pos)); - } - + bool InsertFromMinibuffer(size_type pos); + /// - bool IsInset(int pos) { - return IsInsetChar(GetChar(pos)); - } - + bool IsHfill(size_type pos) const; /// - bool IsFloat(int pos) { - return IsFloatChar(GetChar(pos)); - } - + bool IsInset(size_type pos) const; /// - bool IsNewline(int pos) { - bool tmp = false; - if (pos >= 0) - tmp= IsNewlineChar(GetChar(pos)); - return tmp; - } - + bool IsNewline(size_type pos) const; /// - bool IsSeparator(int pos) { - return IsSeparatorChar(GetChar(pos)); - } - + bool IsSeparator(size_type pos) const; /// - bool IsLineSeparator(int pos) { - return IsLineSeparatorChar(GetChar(pos)); - } - + bool IsLineSeparator(size_type pos) const; /// - bool IsKomma(int pos){ - return IsKommaChar(GetChar(pos)); - } - + bool IsKomma(size_type pos) const; /// Used by the spellchecker - bool IsLetter(int pos); - + bool IsLetter(size_type pos) const; /// - bool IsWord( int pos ) { - return IsWordChar( GetChar(pos) ) ; - } -#endif + 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 - */ - void PasteParagraph(); + be carefull, this doesent make any check at all + */ + void PasteParagraph(BufferParams const &); /// used to remove the error messages int AutoDeleteInsets(); /// returns -1 if inset not found - int GetPositionOfInset(Inset * inset); - - /// ok and now some footnote functions - void OpenFootnotes(); + int GetPositionOfInset(Inset * inset) const; /// - void CloseFootnotes(); - - /// - LyXParagraph * FirstSelfrowPar(); - - /// - int ClearParagraph(){ - int i = 0; - if (!IsDummy() && !table){ - while (Last() - && (IsNewline(0) - || IsLineSeparator(0))){ - Erase(0); - i++; - } - } - return i; - } - - /** 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(){ - return (footnoteflag == LyXParagraph::NO_FOOTNOTE && previous - && previous->footnoteflag != LyXParagraph::NO_FOOTNOTE); - } + int StripLeadingSpaces(LyXTextClassList::size_type tclass); +#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(int type, char const * width, char const * widthp); - /// - void UnsetPExtraType(); -#ifdef NEW_TEXT - /// - bool RoffContTableRows(FILE * file, size_type i, - int actcell); - /// - void DocBookContTableRows(string & file, string & extra, int & desc_on, - size_type i, - int current_cell_number, int & column); -#else + void SetPExtraType(BufferParams const &, int type, + string const & width, string const & widthp); /// - bool RoffContTableRows(FILE * file, int i, int actcell); - /// - void DocBookContTableRows(string & file, string & extra, int & desc_on, - int i, int current_cell_number, int & column); + void UnsetPExtraType(BufferParams const &); #endif /// bool linuxDocConvertChar(char c, string & sgml_string); - /// - void SimpleDocBookOneTablePar(string & file, string & extra, - int & desc_on, int depth); private: - /** 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) - */ - struct FontTable { -#ifdef NEW_TEXT - /// Start position of paragraph this font attribute covers - size_type pos; - /// Ending position of paragraph this font attribute covers - size_type pos_end; -#else - /// Start position of paragraph this font attribute covers - int pos; - /// Ending position of paragraph this font attribute covers - int pos_end; -#endif - /** 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. - */ - LyXFont font; -#ifndef NEW_TABLE - /// Pointer to next font entry - FontTable * next; -#endif - }; /// struct InsetTable { -#ifdef NEW_TEXT /// size_type pos; -#else - /// - int pos; -#endif /// Inset * inset; -#ifndef NEW_TABLE /// - InsetTable * next; -#endif + InsetTable(size_type p, Inset * i) : pos(p), inset(i) {} }; -#ifdef NEW_TABLE - /// - typedef list FontList; /// - typedef list InsetList; + friend struct matchIT; /// - FontList fontlist; - /// - InsetList insetlist; -#else + struct matchIT { + /// used by lower_bound and upper_bound + inline + int operator()(LyXParagraph::InsetTable const & a, + 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) + */ + 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_; + /** 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. + */ + boost::shared_ptr font_; + /// + static ShareContainer container; + }; /// - FontTable * fonttable; + friend struct matchFT; /// - InsetTable * insettable; -#endif + struct matchFT { + /// used by lower_bound and upper_bound + inline + int operator()(LyXParagraph::FontTable const & a, + LyXParagraph::FontTable const & b) const { + return a.pos() < b.pos(); + } + }; + /// - LyXParagraph * TeXDeeper(string & file, TexRow & texrow, - string & foot, TexRow & foot_texrow, - int & foot_count); + typedef std::vector FontList; /// - LyXParagraph * TeXFootnote(string & file, TexRow & texrow, - string & foot, TexRow & foot_texrow, - int & foot_count); + FontList fontlist; /// - bool SimpleTeXOnePar(string & file, TexRow & texrow); + typedef std::vector InsetList; /// - bool SimpleTeXOneTablePar(string & file, TexRow & texrow); -#ifdef NEW_TEXT + InsetList insetlist; /// - bool TeXContTableRows(string & file, size_type i, - int current_cell_number, - int & column, TexRow & texrow); + LyXParagraph * TeXDeeper(Buffer const *, BufferParams const &, + std::ostream &, TexRow & texrow); /// - void SimpleTeXBlanks(string & file, TexRow & texrow, + void SimpleTeXBlanks(std::ostream &, TexRow & texrow, size_type const i, int & column, LyXFont const & font, LyXLayout const & style); /// - void SimpleTeXSpecialChars(string & file, TexRow & texrow, + void SimpleTeXSpecialChars(Buffer const *, BufferParams const &, + std::ostream &, TexRow & texrow, + bool moving_arg, LyXFont & font, LyXFont & running_font, LyXFont & basefont, bool & open_font, LyXLayout const & style, size_type & i, - int & column, char const c); -#else + int & column, value_type const c); /// - bool TeXContTableRows(string & file, int i, int current_cell_number, - int & column, TexRow & texrow); + unsigned int id_; /// - void SimpleTeXBlanks(string & file, TexRow & texrow, - int const i, int & column, LyXFont const & font, - LyXLayout const & style); + static unsigned int paragraph_id; +public: /// - void SimpleTeXSpecialChars(string & file, TexRow & texrow, - LyXFont & font, LyXFont & running_font, - LyXFont & basefont, bool & open_font, - LyXLayout const & style, - int & i, int & column, char const c); -#endif + 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() 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; + }; /// - int id; + inset_iterator inset_iterator_begin(); /// - static unsigned int paragraph_id; + 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