X-Git-Url: https://git.lyx.org/gitweb/?a=blobdiff_plain;f=src%2Flyxparagraph.h;h=d329740e423e0e2d143d6b4768ebdc365183df7a;hb=fe4e2a84c664ab13a2cfbfcbdb953d72c77eb268;hp=1e8185ecfca7cbee19b0b986d9694126b090fcd9;hpb=0eccdd1c3613e5170deb77b22174dd0afde833e9;p=lyx.git

diff --git a/src/lyxparagraph.h b/src/lyxparagraph.h
index 1e8185ecfc..d329740e42 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,70 @@
 #pragma interface
 #endif
 
-#include "definitions.h"
+#include <vector>
+#include <list>
+
 #include "insets/lyxinset.h"
 #include "table.h"
-#include "support/textutils.h"
 #include "vspace.h"
-#include "insets/insetbib.h"
+#include "layout.h"
+#include "support/block.h"
+#include "language.h"
 
 class BufferParams;
 class LyXBuffer;
-class LyXLayout;
 class TexRow;
 struct LaTeXFeatures;
+class InsetBibKey;
 
 /// 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 {
+		///
+		META_FOOTNOTE = 1,
+		///
+		META_MARGIN,
+		///
+		META_FIG,
+		///
+		META_TAB,
+		///
+		META_ALGORITHM,
+		///
+		META_WIDE_FIG,
+		///
+		META_WIDE_TAB,
+		///
+		META_HFILL,
+		///
+		META_NEWLINE,
+		///
+		//META_PROTECTED_SEPARATOR,
+		///
+		META_INSET
+	};
 
 	/// The footnoteflag
 	enum footnote_flag {
@@ -61,89 +109,113 @@ public:
 		WIDE_TAB    // CFO-G, 971106
 	};
 	
+	///
+	typedef char value_type;
+	///
+	typedef std::vector<value_type> TextContainer;
+	///
+	typedef int size_type;
+
 	///
 	LyXParagraph();
 	/// this konstruktor inserts the new paragraph in a list
-	LyXParagraph(LyXParagraph *par);
+	explicit
+	LyXParagraph(LyXParagraph * par);
 	/// the destruktors removes the new paragraph from the list
 	~LyXParagraph();
 
 	///
-	void writeFile(FILE*, BufferParams &, char, char);
-
-	// ///
-	//void writeLaTeX(FILE*, BufferParams &);
-
+	Language const * getParLanguage() const;
+	///
+	bool isRightToLeftPar() const;
+	///
+	void ChangeLanguage(Language const * from, Language const * to);
+	///
+	bool isMultiLingual();
+	
 	///
-	void validate(LaTeXFeatures&);
+	void writeFile(std::ostream &, BufferParams const &, char, char) const;
+	///
+	void validate(LaTeXFeatures &) const;
 	
 	///
-	int GetID(){
-		return id;
+	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(std::ostream &, TexRow & texrow,
+				 std::ostream & foot, TexRow & foot_texrow,
+				 int & foot_count);
+	///
+	bool SimpleTeXOnePar(std::ostream &, TexRow & texrow);
 
 	///
-	LyXParagraph* TeXEnvironment(string &file, TexRow &texrow,
-				     string &foot, TexRow &foot_texrow,
-				     int &foot_count);
-	
+	LyXParagraph * TeXEnvironment(std::ostream &, TexRow & texrow,
+				      std::ostream & foot, TexRow & foot_texrow,
+				      int & foot_count);
 	///
-	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() const;
 	///
-	int size;
-	
+	Inset * InInset() { return inset_owner; }
 	///
-	char *text;
+	void SetInsetOwner(Inset * i) { inset_owner = i; }
+private:
+	///
+	TextContainer text;
+	///
+	Inset * inset_owner;
 
+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;
+
+	///
+	Spacing spacing;
 	
 	///
-	signed char layout;
+	LyXTextClass::LayoutList::size_type layout;
 	
 	/**
 	  \begin{itemize}
@@ -172,7 +244,7 @@ public:
 	bool pagebreak_bottom;
 	
 	///
-	char align;
+	LyXAlignment align;
 	
 	///
 	char depth;
@@ -181,13 +253,12 @@ public:
         bool noindent;
 	
 private:
-	///
-	int counter[10];
+	block<int, 10> 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;
 
@@ -222,92 +293,92 @@ public:
 	//@}
 	
 	///
-	int last;
+	LyXParagraph * next;
 	///
-	LyXParagraph *next;
-	///
-	LyXParagraph *previous;
+	LyXParagraph * previous;
 
 	/* table stuff -- begin*/
 	///
-	LyXTable *table;
+	LyXTable * table;
 	/* table stuff -- end*/
 
         /// 
-        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;
 
 	/** these function are able to hide open and closed footnotes
 	 */ 
-	LyXParagraph *NextAfterFootnote();
+	LyXParagraph * NextAfterFootnote();
 	///
-	LyXParagraph *PreviousBeforeFootnote();
+	LyXParagraph const * NextAfterFootnote() const;
+	
+	///
+	LyXParagraph * PreviousBeforeFootnote();
 	///
-	LyXParagraph *LastPhysicalPar();
+	LyXParagraph * LastPhysicalPar();
 	///
-	LyXParagraph *FirstPhysicalPar();
+	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;
 
 	/// 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 GetLabelstring() const;
 	
 	/// the next two functions are for the manual labels
-	string GetLabelWidthString();
+	string 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(LyXTextClass::LayoutList::size_type new_layout);
 	///
-	void SetOnlyLayout(char new_layout);
+	void SetOnlyLayout(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(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(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 GetFontSettings(size_type pos) const;
+	///
+	LyXFont 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.
@@ -315,106 +386,99 @@ public:
 	  attributes with values LyXFont::INHERIT, LyXFont::IGNORE or 
 	  LyXFont::TOGGLE.
 	  */
-	LyXFont getFont(int pos);
-	
+	LyXFont getFont(size_type pos) const;
+	///
+	char GetChar(size_type pos);
 	///
-	char GetChar(int pos);
+	char GetChar(size_type pos) const;
+	/// The position must already exist.
+	void SetChar(size_type pos, char c) {
+		text[pos] = c;
+	}
+	
 	///
-        string GetWord(int &);
+	void SetFont(size_type pos, LyXFont const & font);
 	///
-	void SetFont(int pos, LyXFont const & font);
+        string 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, char c);
 	///
-	void InsertInset(int pos, Inset *inset);
+	void InsertInset(size_type pos, Inset * inset);
 	///
-	Inset* GetInset(int pos);
-	
-	/// used to remove the error messages
-	int AutoDeleteInsets();
-
+	bool InsertInsetAllowed(Inset * inset);
 	///
-	Inset* ReturnNextInsetPointer(int &pos);
-	
-	/// returns -1 if inset not found
-	int GetPositionOfInset(Inset* inset);
-	
-	/// ok and now some footnote functions
-	void OpenFootnotes();
+	Inset * GetInset(size_type pos);
 	///
-	void OpenFootnote(int pos);
+	Inset const * GetInset(size_type pos) const;
 	///
-	void CloseFootnotes();
+	Inset * ReturnNextInsetPointer(size_type & pos);
 	///
-	void CloseFootnote(int pos);
-   
-	/// important for cut and paste
-	void CopyIntoMinibuffer(int pos);
+	void OpenFootnote(size_type pos);
 	///
-	void CutIntoMinibuffer(int pos);
+	void CloseFootnote(size_type pos);
+	/// important for cut and paste
+	void CopyIntoMinibuffer(size_type pos) const;
 	///
-	void InsertFromMinibuffer(int pos);
-	
+	void CutIntoMinibuffer(size_type pos);
 	///
-	LyXParagraph *FirstSelfrowPar();
-	
+	bool InsertFromMinibuffer(size_type pos);
+
 	///
-	bool IsHfill(int pos) {
-		return IsHfillChar(GetChar(pos));
-	}
-	
+	bool IsHfill(size_type pos) const;
 	///
-	bool IsInset(int pos) {
-		return IsInsetChar(GetChar(pos));
-	}
-	
+	bool IsInset(size_type pos) const;
 	///
-	bool IsFloat(int pos) {
-		return IsFloatChar(GetChar(pos));
-	}
-	
+	bool IsFloat(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) ) ;
-	}
+	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();
+
+	/// used to remove the error messages
+	int AutoDeleteInsets();
+
+	/// returns -1 if inset not found
+	int GetPositionOfInset(Inset * inset) const;
+	
+	/// ok and now some footnote functions
+	void OpenFootnotes();
+
+	///
+	void CloseFootnotes();
+   
+	///
+	LyXParagraph * FirstSelfrowPar();
 
 	///
-	int ClearParagraph(){
-		int i=0;
+	int ClearParagraph() {
+		int i = 0;
 		if (!IsDummy() && !table){
 			while (Last()
 			       && (IsNewline(0) 
 				   || IsLineSeparator(0))){
 				Erase(0);
-				i++;
+				++i;
 			}
 		}
 		return i;
@@ -426,28 +490,52 @@ public:
 	  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);
-	}
+	bool IsDummy() const;
 
         /* 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(int type, char const * width, char const * widthp);
 	///
         void UnsetPExtraType();
+#if 0
 	///
-	bool RoffContTableRows(FILE *file, int i, int actcell);
+	bool RoffContTableRows(std::ostream &, size_type i, int actcell);
+#endif
 	///
-	bool linuxDocConvertChar(char c, string &sgml_string);
+	bool linuxDocConvertChar(char c, string & sgml_string);
 	///
-	void SimpleDocBookOneTablePar(string &file, string &extra,
-				      int &desc_on, int depth);
+	void DocBookContTableRows(std::ostream &, string & extra,
+				  int & desc_on, size_type i,
+				  int current_cell_number, int & column);
 	///
-	void DocBookContTableRows(string &file, string &extra, int &desc_on,
-				  int i, int current_cell_number, int &column);
+	void SimpleDocBookOneTablePar(std::ostream &, string & extra,
+				      int & desc_on, int depth);
 private:
+	///
+	struct InsetTable {
+		///
+		size_type pos;
+		///
+		Inset * inset;
+		///
+		InsetTable(size_type p, Inset * i) { pos = p; inset = i;}
+	};
+	///
+	struct matchIT {
+		/// used by lower_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;
+		}
+	};
 	/** 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
@@ -456,10 +544,9 @@ private:
 	*/
 	struct FontTable  {
 		/// Start position of paragraph this font attribute covers
-		int pos;
+		size_type pos;
 		/// Ending position of paragraph this font attribute covers
-		int pos_end;
-
+		size_type pos_end;
 		/** 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,49 +557,44 @@ private:
 		allowed in these font tables.
 		*/
 		LyXFont font;
-		/// Pointer to next font entry
-		FontTable *next;
 	};
 	///
-	struct InsetTable {
-		///
-		int pos;
-		///
-		Inset *inset;
-		///
-		InsetTable *next;
-	};
+	typedef std::list<FontTable> FontList;
 	///
-	FontTable *fonttable;
+	FontList fontlist;
 	///
-	InsetTable *insettable;
+	typedef std::vector<InsetTable> InsetList;
 	///
-	LyXParagraph * TeXDeeper(string &file, TexRow &texrow,
-				   string &foot, TexRow &foot_texrow,
-				   int &foot_count);
+	InsetList insetlist;
 	///
-	LyXParagraph * TeXFootnote(string &file, TexRow &texrow,
-				   string &foot, TexRow &foot_texrow,
-				   int &foot_count);
+	LyXParagraph * TeXDeeper(std::ostream &, TexRow & texrow,
+				 std::ostream & foot, TexRow & foot_texrow,
+				 int & foot_count);
 	///
-	bool SimpleTeXOnePar(string &file, TexRow &texrow);
+	LyXParagraph * TeXFootnote(std::ostream &, TexRow & texrow,
+				   std::ostream & foot, TexRow & foot_texrow,
+				   int & foot_count,
+				   bool parent_is_rtl);
 	///
-	bool SimpleTeXOneTablePar(string &file, TexRow &texrow);
+	bool SimpleTeXOneTablePar(std::ostream &, TexRow & texrow);
 	///
-	bool TeXContTableRows(string &file, int i, int current_cell_number,
-                              int &column, TexRow &texrow);
+	bool TeXContTableRows(std::ostream &, size_type i,
+			      int current_cell_number,
+                              int & column, TexRow & texrow);
 	///
-	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(std::ostream &, TexRow & texrow,
+				   LyXFont & font, LyXFont & running_font,
+				   LyXFont & basefont, bool & open_font,
+				   LyXLayout const & style,
+				   size_type & i,
+				   int & column, char const c);
 	///
-	int id;
+	unsigned int id_;
 	///
 	static unsigned int paragraph_id;
 };