X-Git-Url: https://git.lyx.org/gitweb/?a=blobdiff_plain;f=src%2Flyxparagraph.h;h=6d8d6129109aa9241555ef4440b7b4c563d3ef41;hb=f448e22d483e1370bcbfbb7be8cb47ad7251ed77;hp=1e8185ecfca7cbee19b0b986d9694126b090fcd9;hpb=0eccdd1c3613e5170deb77b22174dd0afde833e9;p=lyx.git diff --git a/src/lyxparagraph.h b/src/lyxparagraph.h index 1e8185ecfc..6d8d612910 100644 --- a/src/lyxparagraph.h +++ b/src/lyxparagraph.h @@ -1,13 +1,13 @@ // -*- C++ -*- /* This file is part of - * ====================================================== + * ====================================================== * * LyX, The Document Processor * - * Copyright (C) 1995 Matthias Ettrich - * Copyright (C) 1995-1999 The LyX Team. + * Copyright 1995 Matthias Ettrich + * Copyright 1995-2000 The LyX Team. * - *======================================================*/ + * ====================================================== */ #ifndef LYXPARAGRAPH_H #define LYXPARAGRAPH_H @@ -16,22 +16,86 @@ #pragma interface #endif -#include "definitions.h" +//#define HAVE_ROPE 1 + +#ifdef HAVE_ROPE +#include +#endif + +#include +#include + #include "insets/lyxinset.h" -#include "table.h" -#include "support/textutils.h" #include "vspace.h" -#include "insets/insetbib.h" +#include "layout.h" +#include +#include "language.h" class BufferParams; class LyXBuffer; -class LyXLayout; class TexRow; struct LaTeXFeatures; +class InsetBibKey; +class BufferView; + +// I dare you to enable this and help me find all the bugs that then show +// up. (Lgb) +//#define NEW_INSETS 1 /// A LyXParagraph holds all text, attributes and insets in a text paragraph class LyXParagraph { public: + /// + enum PEXTRA_TYPE { + /// + PEXTRA_NONE, + /// + PEXTRA_INDENT, + /// + PEXTRA_MINIPAGE, + /// + PEXTRA_FLOATFLT + }; + /// + enum MINIPAGE_ALIGNMENT { + /// + MINIPAGE_ALIGN_TOP, + /// + MINIPAGE_ALIGN_MIDDLE, + /// + MINIPAGE_ALIGN_BOTTOM + }; + /// + enum META_KIND { +#ifndef NEW_INSETS + /// + META_FOOTNOTE = 1, + /// + META_MARGIN, + /// + META_FIG, + /// + META_TAB, + /// + META_ALGORITHM, + /// + META_WIDE_FIG, + /// + META_WIDE_TAB, + /// + META_HFILL, +#else + /// + META_HFILL = 1, +#endif + /// + META_NEWLINE, + // + //META_PROTECTED_SEPARATOR, + /// + META_INSET + }; +#ifndef NEW_INSETS /// The footnoteflag enum footnote_flag { @@ -60,91 +124,152 @@ public: /// WIDE_TAB // CFO-G, 971106 }; - +#endif + /// + typedef char value_type; + /// +#ifndef HAVE_ROPE + typedef std::vector TextContainer; +#else + typedef std::rope TextContainer; +#endif + /// + /* 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 - LyXParagraph(LyXParagraph *par); - /// the destruktors removes the new paragraph from the list + /// this constructor inserts the new paragraph in a list + explicit + LyXParagraph(LyXParagraph * par); + /// the destructor removes the new paragraph from the list ~LyXParagraph(); /// - void writeFile(FILE*, BufferParams &, char, char); - - // /// - //void writeLaTeX(FILE*, BufferParams &); + 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 writeFile(Buffer const *, std::ostream &, BufferParams const &, + char, char) const; + /// + void validate(LaTeXFeatures &) const; + + /// + int id() const { + return id_; } /// - void SetID(int id_arg){ - id = id_arg; + void id(int id_arg) { + id_ = id_arg; } - - /** 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(); - + /// void read(); - - /// - void readSimpleWholeFile(FILE *); /// - LyXParagraph* TeXOnePar(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 +#ifndef NEW_INSETS + , + std::ostream & foot, TexRow & foot_texrow, + int & foot_count +#endif + ); + /// + bool SimpleTeXOnePar(Buffer const *, BufferParams const &, + std::ostream &, TexRow & texrow, bool moving_arg); /// - LyXParagraph* TeXEnvironment(string &file, TexRow &texrow, - string &foot, TexRow &foot_texrow, - int &foot_count); - + LyXParagraph * TeXEnvironment(Buffer const *, BufferParams const &, + std::ostream &, TexRow & texrow +#ifndef NEW_INSETS + ,std::ostream & foot, TexRow & foot_texrow, + int & foot_count +#endif + ); /// - LyXParagraph* Clone(); + LyXParagraph * Clone() const; /// - bool HasSameLayout(LyXParagraph *par); + 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()); + bool IsFirstInSequence() const { + LyXParagraph const * dhook = DepthHook(GetDepth()); return (dhook == this || dhook->GetLayout() != GetLayout() || dhook->GetDepth() != GetDepth()); } + /** Check if the current paragraph is the last paragraph in a + proof environment */ + int GetEndLabel(BufferParams const &) const; /// - int size; - + Inset * InInset() { return inset_owner; } + /// + void SetInsetOwner(Inset * i); + /// + void deleteInsetsLyXText(BufferView *); + /// + void resizeInsetsLyXText(BufferView *); +private: /// - char *text; + TextContainer text; + /// + Inset * inset_owner; +public: + /// + size_type size() const { return text.size(); } + /// + void fitToSize() { +#ifndef HAVE_ROPE + text.resize(text.size()); +#endif + } + /// + void setContentsFromPar(LyXParagraph * par) { + text = par->text; + } + /// + void clearContents() { +#ifndef HAVE_ROPE + text.clear(); +#else + text.erase(text.mutable_begin(), text.mutable_end()); +#endif + } + /// VSpace added_space_top; /// VSpace added_space_bottom; - + /// - signed char layout; + Spacing spacing; + /// + LyXTextClass::LayoutList::size_type layout; +#ifndef NEW_INSETS /** \begin{itemize} \item no footnote, closed footnote, @@ -156,9 +281,7 @@ public: /// footnote, margin, fig, tab footnote_kind footnotekind; - - //@Man: the LyX- DTP-switches - //@{ +#endif /// bool line_top; @@ -172,7 +295,7 @@ public: bool pagebreak_bottom; /// - char align; + LyXAlignment align; /// char depth; @@ -182,12 +305,14 @@ public: private: /// - int counter[10]; + 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) { counter_[i] = v; } + /// + int getCounter(int i) const { return counter_[i]; } + /// + void incCounter(int i) { counter_[i]++; } /// bool start_of_appendix; @@ -219,247 +344,249 @@ public: /// string labelwidthstring; - //@} /// - int last; - /// - LyXParagraph *next; + LyXParagraph * next; /// - LyXParagraph *previous; - - /* table stuff -- begin*/ - /// - LyXTable *table; - /* table stuff -- end*/ + LyXParagraph * previous; /// - InsetBibKey* bibkey; // ale970302 + InsetBibKey * bibkey; // ale970302 /** these function are able to hide closed footnotes */ - LyXParagraph *Next(); + LyXParagraph * Next(); /// - LyXParagraph *Previous(); + LyXParagraph * Previous(); + /// + LyXParagraph const * Previous() const; +#ifndef NEW_INSETS /** these function are able to hide open and closed footnotes */ - LyXParagraph *NextAfterFootnote(); + LyXParagraph * NextAfterFootnote(); /// - LyXParagraph *PreviousBeforeFootnote(); + LyXParagraph const * NextAfterFootnote() const; + /// - LyXParagraph *LastPhysicalPar(); + LyXParagraph * PreviousBeforeFootnote(); /// - LyXParagraph *FirstPhysicalPar(); + LyXParagraph * LastPhysicalPar(); + /// + LyXParagraph const * LastPhysicalPar() const; + /// + LyXParagraph * FirstPhysicalPar(); + /// + LyXParagraph const * FirstPhysicalPar() const; /// returns the physical paragraph - LyXParagraph *ParFromPos(int pos); + LyXParagraph * ParFromPos(size_type pos); /// returns the position in the physical par - int PositionInParFromPos(int pos); + int PositionInParFromPos(size_type pos) const; +#endif /// for the environments - LyXParagraph* DepthHook(int depth); + 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(const string &s); + void SetLabelWidthString(string const & s); /// - int GetLayout(); + LyXTextClass::LayoutList::size_type GetLayout() const; /// - char GetAlign(); + char GetAlign() const; /// - char GetDepth(); + char GetDepth() const; /// - void SetLayout(char new_layout); + void SetLayout(BufferParams const &, + LyXTextClass::LayoutList::size_type new_layout); /// - void SetOnlyLayout(char new_layout); + void SetOnlyLayout(BufferParams const &, + LyXTextClass::LayoutList::size_type new_layout); /// - int GetFirstCounter(int i); + int GetFirstCounter(int i) const; /// - int Last(); - - /** This one resets all layout and dtp switches but not the font - of the single characters - */ - void Clear(); + size_type Last() const; /// - void Erase(int pos); - + void Erase(size_type pos); /** the flag determines wether the layout should be copied */ - void BreakParagraph(int pos, int flag); + void BreakParagraph(BufferParams const &, size_type pos, int flag); /// - void BreakParagraphConservative(int pos); - - /** paste this paragraph with the next one - be carefull, this doesent make any check at all - */ - void PasteParagraph(); - + 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(int pos); - + */ + LyXFont const + GetFontSettings(BufferParams const &, size_type pos) 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(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; + /// + value_type GetChar(size_type pos) const; + /// The position must already exist. + void SetChar(size_type pos, value_type c) { +#ifndef HAVE_ROPE + text[pos] = c; +#else + text.replace(pos, c); +#endif + } /// - char GetChar(int pos); + void SetFont(size_type pos, LyXFont const & font); /// - string GetWord(int &); - /// - void SetFont(int 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); - - /// used to remove the error messages - int AutoDeleteInsets(); - + void InsertInset(size_type pos, Inset * inset); /// - Inset* ReturnNextInsetPointer(int &pos); - - /// returns -1 if inset not found - int GetPositionOfInset(Inset* inset); - - /// ok and now some footnote functions - void OpenFootnotes(); + void InsertInset(size_type pos, Inset * inset, LyXFont const &); /// - void OpenFootnote(int pos); + bool InsertInsetAllowed(Inset * inset); /// - void CloseFootnotes(); + Inset * GetInset(size_type pos); /// - void CloseFootnote(int pos); - - /// important for cut and paste - void CopyIntoMinibuffer(int pos); + Inset const * GetInset(size_type pos) const; +#ifndef NEW_INSETS /// - void CutIntoMinibuffer(int pos); + void OpenFootnote(size_type pos); /// - void InsertFromMinibuffer(int pos); - + void CloseFootnote(size_type pos); +#endif + /// important for cut and paste + void CopyIntoMinibuffer(BufferParams const &, size_type pos) const; /// - LyXParagraph *FirstSelfrowPar(); - + 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; +#ifndef NEW_INSETS /// - bool IsNewline(int pos) { - bool tmp=false; - if (pos>=0) - tmp= IsNewlineChar(GetChar(pos)); - return tmp; - } - + bool IsFloat(size_type pos) const; +#endif /// - bool IsSeparator(int pos) { - return IsSeparatorChar(GetChar(pos)); - } - + bool IsNewline(size_type pos) const; /// - bool IsLineSeparator(int pos) { - return IsLineSeparatorChar(GetChar(pos)); - } - + bool IsSeparator(size_type pos) const; /// - bool IsKomma(int pos){ - return IsKommaChar(GetChar(pos)); - } - + bool IsLineSeparator(size_type pos) const; + /// + 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) ) ; - } + bool IsWord(size_type pos) const; + + /** This one resets all layout and dtp switches but not the font + of the single characters + */ + void Clear(); + + /** paste this paragraph with the next one + 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) const; + +#ifndef NEW_INSETS + /// ok and now some footnote functions + void OpenFootnotes(); /// - 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); - } + void CloseFootnotes(); + /// + LyXParagraph * FirstSelfrowPar(); +#endif + /// + int StripLeadingSpaces(LyXTextClassList::size_type tclass); + +#ifndef NEW_INSETS + /** 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; +#endif /* 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, const char *width, const char *widthp); + void SetPExtraType(BufferParams const &, int type, + string const & width, string const & widthp); /// - void UnsetPExtraType(); + void UnsetPExtraType(BufferParams const &); /// - bool RoffContTableRows(FILE *file, int i, int actcell); + bool linuxDocConvertChar(char c, string & sgml_string); +private: /// - bool linuxDocConvertChar(char c, string &sgml_string); + struct InsetTable { + /// + size_type pos; + /// + Inset * inset; + /// + InsetTable(size_type p, Inset * i) { pos = p; inset = i;} + }; /// - void SimpleDocBookOneTablePar(string &file, string &extra, - int &desc_on, int depth); + friend struct matchIT; /// - void DocBookContTableRows(string &file, string &extra, int &desc_on, - int i, int current_cell_number, int &column); -private: + 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 { - /// Start position of paragraph this font attribute covers - int pos; - /// Ending position of paragraph this font attribute covers - int pos_end; - + /// 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 @@ -470,51 +597,102 @@ private: allowed in these font tables. */ LyXFont font; - /// Pointer to next font entry - FontTable *next; - }; - /// - struct InsetTable { - /// - int pos; /// - Inset *inset; - /// - InsetTable *next; + FontTable(size_type p, LyXFont const & f) {pos = p; font = f;} }; /// - FontTable *fonttable; + friend struct matchFT; /// - InsetTable *insettable; + 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); + InsetList insetlist; /// - bool TeXContTableRows(string &file, int i, int current_cell_number, - int &column, TexRow &texrow); + LyXParagraph * TeXDeeper(Buffer const *, BufferParams const &, + std::ostream &, TexRow & texrow +#ifndef NEW_INSETS + ,std::ostream & foot, TexRow & foot_texrow, + int & foot_count +#endif + ); +#ifndef NEW_INSETS + /// + LyXParagraph * TeXFootnote(Buffer const *, BufferParams const &, + std::ostream &, TexRow & texrow, + std::ostream & foot, TexRow & foot_texrow, + int & foot_count, + bool parent_is_rtl); +#endif /// - void SimpleTeXBlanks(string &file, TexRow &texrow, - int const i, int &column, LyXFont const &font, - LyXLayout const * const style); + void SimpleTeXBlanks(std::ostream &, TexRow & texrow, + size_type const i, + int & column, LyXFont const & font, + LyXLayout const & style); /// - void SimpleTeXSpecialChars(string &file, TexRow &texrow, - LyXFont &font, LyXFont &running_font, - LyXFont &basefont, bool &open_font, - LyXLayout const * const style, - int &i, int &column, char const c); + 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, value_type const c); /// - int id; + 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() 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_end() { + return inset_iterator(insetlist.end()); + } + /// + inset_iterator InsetIterator(size_type pos); }; #endif