X-Git-Url: https://git.lyx.org/gitweb/?a=blobdiff_plain;f=src%2Fparagraph.h;h=f3c3700025dbd9abfca3ba99f5ace62cedcc1cfe;hb=8c93f63b48a1b15d4f3e163b7305213f2f73879e;hp=e06f6ff9339eee37a653779aef2dd6540685e109;hpb=263b9fc043acb50b768cec3dbaa7210c2793978e;p=lyx.git

diff --git a/src/paragraph.h b/src/paragraph.h
index e06f6ff933..f3c3700025 100644
--- a/src/paragraph.h
+++ b/src/paragraph.h
@@ -1,49 +1,69 @@
 // -*- C++ -*-
 /**
- *  \file paragraph.h
- *  Copyright 1995 Matthias Ettrich
- *  Copyright 2002 the LyX Team
- *  Read the file COPYING
+ * \file paragraph.h
+ * This file is part of LyX, the document processor.
+ * Licence details can be found in the file COPYING.
+ *
+ * \author Asger Alstrup
+ * \author Lars Gullik Bjønnes
+ * \author John Levon
+ * \author André Pönitz
+ * \author Jürgen Vigna
+ *
+ * Full author contact details are available in file CREDITS.
  */
 
 #ifndef PARAGRAPH_H
 #define PARAGRAPH_H
 
-#include "lyxlayout_ptr_fwd.h"
-#include "lyxfont.h" // Just for LyXFont::FONT_SIZE
+#include "changes.h"
+#include "dimension.h"
 #include "InsetList.h"
+#include "lyxlayout_ptr_fwd.h"
+#include "RowList_fwd.h"
 
-#include "insets/inset.h" // Just for Inset::Code
+#include "insets/insetbase.h" // only for InsetBase::Code
 
 #include "support/types.h"
-#include "changes.h"
 
-#include "ParagraphList.h"
-#include "LString.h"
+#include <string>
 
+class Buffer;
 class BufferParams;
 class BufferView;
 class Counters;
+class InsetBase;
 class InsetBibitem;
-class Language;
 class LaTeXFeatures;
+class InsetBase_code;
+class Language;
+class LyXFont;
+class LyXFont_size;
+class MetricsInfo;
+class OutputParams;
+class PainterInfo;
 class ParagraphParameters;
 class TexRow;
 
-// Define this if you want to try out the new storage container for
-// paragraphs. (Lgb)
-// This is non working and far from finished.
-// #define NO_NEXT 1
+
+class FontSpan {
+public:
+	/// Invalid font span containing no character
+	FontSpan() : first(0), last(-1) {}
+	/// Span including first and last
+	FontSpan(lyx::pos_type f, lyx::pos_type l) : first(f), last(l) {}
+
+public:
+	/// Range including first and last.
+	lyx::pos_type first, last;
+};
+
 
 /// A Paragraph holds all text, attributes and insets in a text paragraph
 class Paragraph  {
 public:
-	// Remove this whan ParagraphList transition is over. (Lgb)
-	friend class ParagraphList;
-	friend class ParagraphList::iterator;
-
 	///
-	enum META_KIND {
+	enum {
 		/// Note that this is 1 right now to avoid
 		/// crashes where getChar() is called wrongly
 		/// (returning 0) - if this was 0, then we'd
@@ -53,20 +73,22 @@ public:
 	};
 	///
 	typedef char value_type;
-	/// The same as ParameterStruct::depth_type
-	typedef unsigned int depth_type;
+	///
+	typedef lyx::depth_type depth_type;
+	///
+	typedef std::vector<value_type> TextContainer;
 
 	///
 	Paragraph();
-#ifndef NO_NEXT
-	/// this constructor inserts the new paragraph in a list
-	explicit
-	Paragraph(Paragraph * par);
-#endif
-	///
-	Paragraph(Paragraph const &, bool same_ids);
-	/// the destructor removes the new paragraph from the list
+	///
+	Paragraph(Paragraph const &);
+	///
+	Paragraph & operator=(Paragraph const &);
+	///
 	~Paragraph();
+	///
+	int id() const;
+
 
 	///
 	Language const * getParLanguage(BufferParams const &) const;
@@ -76,23 +98,32 @@ public:
 	void changeLanguage(BufferParams const & bparams,
 			    Language const * from, Language const * to);
 	///
-	bool isMultiLingual(BufferParams const &);
+	bool isMultiLingual(BufferParams const &) const;
 
 	///
-	string const asString(Buffer const *, bool label) const;
+	std::string const asString(Buffer const &,
+				   OutputParams const & runparams,
+				   bool label) const;
+	///
+	std::string const asString(Buffer const &, bool label) const;
+	///
+	std::string const asString(Buffer const & buffer,
+				   lyx::pos_type beg,
+				   lyx::pos_type end,
+				   bool label) const;
 	///
-	string const asString(Buffer const *, lyx::pos_type beg, lyx::pos_type end,
-			      bool label) const;
+	std::string const asString(Buffer const &,
+				   OutputParams const & runparams,
+				   lyx::pos_type beg,
+				   lyx::pos_type end,
+				   bool label) const;
 
 	///
-	void write(Buffer const *, std::ostream &, BufferParams const &,
-		       depth_type & depth) const;
+	void write(Buffer const &, std::ostream &, BufferParams const &,
+		   depth_type & depth) const;
 	///
 	void validate(LaTeXFeatures &) const;
 
-	/// return the unique ID of this paragraph
-	int id() const;
-
 	///
 	int startTeXParParams(BufferParams const &, std::ostream &, bool) const;
 
@@ -101,29 +132,59 @@ public:
 
 
 	///
-	bool simpleTeXOnePar(Buffer const *, BufferParams const &,
+	bool simpleTeXOnePar(Buffer const &, BufferParams const &,
 			     LyXFont const & outerfont, std::ostream &,
-			     TexRow & texrow, bool moving_arg);
+			     TexRow & texrow, OutputParams const &) const;
+
+	/// Writes to stream the content of the paragraph for linuxdoc
+	void simpleLinuxDocOnePar(Buffer const & buf,
+				  std::ostream & os,
+				  LyXFont const & outerfont,
+				  OutputParams const & runparams,
+				  lyx::depth_type depth) const;
+
+	/// Can we drop the standard paragraph wrapper?
+	bool emptyTag() const;
+
+	/// Get the id of the paragraph, usefull for docbook and linuxdoc
+	std::string getID(Buffer const & buf,
+			  OutputParams const & runparams) const;
+
+	// Get the first word of a paragraph, return the position where it left
+	lyx::pos_type getFirstWord(Buffer const & buf,
+				   std::ostream & os,
+				   OutputParams const & runparams) const;
+
+	/// Checks if the paragraph contains only text and no inset or font change.
+	bool onlyText(Buffer const & buf, LyXFont const & outerfont,
+		      lyx::pos_type initial) const;
+
+	/// Writes to stream the docbook representation
+	void simpleDocBookOnePar(Buffer const & buf,
+				 std::ostream &,
+				 OutputParams const & runparams,
+				 LyXFont const & outerfont,
+				 lyx::pos_type initial = 0) const;
 
 	///
-	bool hasSameLayout(Paragraph const * par) const;
+	bool hasSameLayout(Paragraph const & par) const;
 
 	///
-	void makeSameLayout(Paragraph const * par);
+	void makeSameLayout(Paragraph const & par);
 
 	///
-	Inset * inInset() const;
+	void setInsetOwner(InsetBase * inset);
 	///
-	void setInsetOwner(Inset * i);
+	InsetBase * inInset() const;
 	///
-	void deleteInsetsLyXText(BufferView *);
+	InsetBase::Code ownerCode() const;
 	///
-	void resizeInsetsLyXText(BufferView *);
+	bool forceDefaultParagraphs() const;
 
 	///
-	lyx::pos_type size() const;
+	lyx::pos_type size() const { return text_.size(); }
 	///
-	bool empty() const;
+	bool empty() const { return text_.empty(); }
 	///
 	void setContentsFromPar(Paragraph const & par);
 	///
@@ -134,31 +195,11 @@ public:
 	///
 	void layout(LyXLayout_ptr const & new_layout);
 
-	///
-	char enumdepth;
-
-	///
-	char itemdepth;
-
-	///
-	InsetBibitem * bibitem();  // ale970302
-
-#ifndef NO_NEXT
-	///
-	void next(Paragraph *);
-	/** these function are able to hide closed footnotes
-	 */
-	Paragraph * next();
-	///
-	Paragraph const * next() const;
+	/// This is the item depth, only used by enumerate and itemize
+	signed char itemdepth;
 
 	///
-	void previous(Paragraph *);
-	///
-	Paragraph * previous();
-	///
-	Paragraph const * previous() const;
-#endif
+	InsetBibitem * bibitem() const;  // ale970302
 
 	/// initialise tracking for this par
 	void trackChanges(Change::Type = Change::UNCHANGED);
@@ -184,28 +225,34 @@ public:
 	/// set change at pos
 	void setChange(lyx::pos_type pos, Change::Type type);
 
+	/// set full change at pos
+	void setChangeFull(lyx::pos_type pos, Change change);
+
 	/// accept change
 	void acceptChange(lyx::pos_type start, lyx::pos_type end);
 
 	/// reject change
 	void rejectChange(lyx::pos_type start, lyx::pos_type end);
 
-	/// mark whole par as erased
-	void markErased();
+	/// mark whole par as erased or not
+	void markErased(bool erased);
 
-	/// Paragraphs can contain "manual labels", for example, Description environment.
-	/// The text for this user-editable label is stored in the paragraph alongside
-	/// the text of the rest of the paragraph (the body). This function returns
-	/// the starting position of the body of the text in the paragraph.
-	int beginningOfBody() const;
+	/// Paragraphs can contain "manual labels", for example, Description
+	/// environment. The text for this user-editable label is stored in
+	/// the paragraph alongside the text of the rest of the paragraph
+	/// (the body). This function returns the starting position of the
+	/// body of the text in the paragraph.
+	lyx::pos_type beginOfBody() const;
+	/// recompute this value
+	void setBeginOfBody();
 
 	///
-	string const & getLabelstring() const;
+	std::string const & getLabelstring() const;
 
 	/// the next two functions are for the manual labels
-	string const getLabelWidthString() const;
+	std::string const getLabelWidthString() const;
 	///
-	void setLabelWidthString(string const & s);
+	void setLabelWidthString(std::string const & s);
 	///
 	char getAlign() const;
 	/// The nesting depth of a paragraph
@@ -218,7 +265,7 @@ public:
 	/// definite erase
 	void eraseIntern(lyx::pos_type pos);
 	/// erase the char at the given position
-	void erase(lyx::pos_type pos);
+	bool erase(lyx::pos_type pos);
 	/// erase the given range. Returns the number of chars actually erased
 	int erase(lyx::pos_type start, lyx::pos_type end);
 
@@ -229,7 +276,7 @@ public:
 	LyXFont const
 	getFontSettings(BufferParams const &, lyx::pos_type pos) const;
 	///
-	LyXFont const getFirstFontSettings() const;
+	LyXFont const getFirstFontSettings(BufferParams const &) const;
 
 	/** Get fully instantiated font. If pos == -1, use the layout
 	    font attached to this paragraph.
@@ -244,95 +291,145 @@ public:
 				    LyXFont const & outerfont) const;
 	LyXFont const getLabelFont(BufferParams const &,
 				   LyXFont const & outerfont) const;
+	/**
+	 * The font returned by the above functions is the same in a
+	 * span of characters. This method will return the first and
+	 * the last positions in the paragraph for which that font is
+	 * the same. This can be used to avoid unnecessary calls to
+   * getFont.
+	 */
+	FontSpan fontSpan(lyx::pos_type pos) const;
 	///
-	value_type getChar(lyx::pos_type pos) const;
-	///
+	/// this is a bottleneck.
+	value_type getChar(lyx::pos_type pos) const { return text_[pos]; }
+	/// Get the char, but mirror all bracket characters if it is right-to-left
 	value_type getUChar(BufferParams const &, lyx::pos_type pos) const;
 	/// The position must already exist.
 	void setChar(lyx::pos_type pos, value_type c);
 	/// pos <= size() (there is a dummy font change at the end of each par)
 	void setFont(lyx::pos_type pos, LyXFont const & font);
 	/// Returns the height of the highest font in range
-	LyXFont::FONT_SIZE
-	highestFontInRange(lyx::pos_type startpos,
-			   lyx::pos_type endpos,
-			   LyXFont::FONT_SIZE const def_size) const;
-	///
-	void insertChar(lyx::pos_type pos, value_type c);
+	LyXFont_size highestFontInRange(lyx::pos_type startpos,
+					lyx::pos_type endpos,
+					LyXFont_size def_size) const;
 	///
-	void insertChar(lyx::pos_type pos, value_type c, LyXFont const &, Change change = Change(Change::INSERTED));
+	void insert(lyx::pos_type pos, std::string const & str,
+		    LyXFont const & font);
 	///
-	bool checkInsertChar(LyXFont &);
+	void insertChar(lyx::pos_type pos, value_type c,
+			Change change = Change::INSERTED);
 	///
-	void insertInset(lyx::pos_type pos, Inset * inset);
+	void insertChar(lyx::pos_type pos, value_type c,
+		LyXFont const &, Change change = Change::INSERTED);
 	///
-	void insertInset(lyx::pos_type pos, Inset * inset, LyXFont const &, Change change = Change(Change::INSERTED));
+	void insertInset(lyx::pos_type pos, InsetBase * inset,
+			 Change change = Change::INSERTED);
 	///
-	bool insetAllowed(Inset::Code code);
+	void insertInset(lyx::pos_type pos, InsetBase * inset,
+		LyXFont const &, Change change = Change::INSERTED);
 	///
-	Inset * getInset(lyx::pos_type pos);
+	bool insetAllowed(InsetBase_code code);
 	///
-	Inset const * getInset(lyx::pos_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 &, lyx::pos_type pos) const;
+	InsetBase * getInset(lyx::pos_type pos) {
+		return insetlist.get(pos);
+	}
 	///
-	void cutIntoMinibuffer(BufferParams const &, lyx::pos_type pos);
-	///
-	bool insertFromMinibuffer(lyx::pos_type pos);
+	InsetBase const * getInset(lyx::pos_type pos) const {
+		return insetlist.get(pos);
+	}
 
 	///
-	bool isHfill(lyx::pos_type pos) const;
-	///
-	bool isInset(lyx::pos_type pos) const;
+	bool isHfill(lyx::pos_type pos) const {
+	return isInset(pos)
+		&& getInset(pos)->lyxCode() == InsetBase::HFILL_CODE;
+	}
+	/// hinted by profiler
+	bool isInset(lyx::pos_type pos) const {
+		return getChar(pos) == static_cast<value_type>(META_INSET);
+	}
 	///
 	bool isNewline(lyx::pos_type pos) const;
-	///
-	bool isSeparator(lyx::pos_type pos) const;
+	/// return true if the char is a word separator
+	bool isSeparator(lyx::pos_type pos) const { return getChar(pos) == ' '; }
 	///
 	bool isLineSeparator(lyx::pos_type pos) const;
-	///
-	bool isKomma(lyx::pos_type pos) const;
-	/// Used by the spellchecker
+	/// True if the character/inset at this point can be part of a word
+	// Note that digits in particular are considered as letters
 	bool isLetter(lyx::pos_type pos) const;
-	///
-	bool isWord(lyx::pos_type pos) const;
 
 	/// returns -1 if inset not found
-	int getPositionOfInset(Inset const * inset) const;
+	int getPositionOfInset(InsetBase const * inset) const;
 
-	///
+	/// Returns the number of line breaks and white-space stripped at the start
 	int stripLeadingSpaces();
 
-	///
+	/// return true if we allow multiple spaces
 	bool isFreeSpacing() const;
 
+	/// return true if we allow this par to stay empty
+	bool allowEmpty() const;
+	///
+	unsigned char transformChar(unsigned char c, lyx::pos_type pos) const;
 	///
 	ParagraphParameters & params();
 	///
 	ParagraphParameters const & params() const;
+
 	///
-	InsetList insetlist;
+	Row & getRow(lyx::pos_type pos, bool boundary);
+	///
+	Row const & getRow(lyx::pos_type pos, bool boundary) const;
+	///
+	size_t pos2row(lyx::pos_type pos) const;
+
+	/// total height of paragraph
+	unsigned int height() const { return dim_.height(); }
+	/// total width of paragraph, may differ from workwidth
+	unsigned int width() const { return dim_.width(); }
+	/// ascend of paragraph above baseline
+	unsigned int ascent() const { return dim_.ascent(); }
+	/// descend of paragraph below baseline
+	unsigned int descent() const { return dim_.descent(); }
+	/// LyXText updates the rows using this access point
+	RowList & rows() { return rows_; }
+	/// The painter and others use this
+	RowList const & rows() const { return rows_; }
+	///
+	RowSignature & rowSignature() const { return rowSignature_; }
+
+	/// LyXText::redoParagraph updates this
+	Dimension & dim() { return dim_; }
+
+	/// dump some information to lyxerr
+	void dump() const;
+
+public:
 	///
-	//Counters & counters();
+	InsetList insetlist;
+
 private:
+	/// cached dimensions of paragraph
+	Dimension dim_;
+
 	///
-	LyXLayout_ptr layout_;
-	/// if anything uses this we don't want it to.
-	Paragraph(Paragraph const &);
-#ifndef NO_NEXT
+	mutable RowList rows_;
 	///
-	Paragraph * next_;
+	mutable RowSignature rowSignature_;
+
 	///
-	Paragraph * previous_;
-#else
-	Paragraph * next_par_;
-	Paragraph * prev_par_;
-#endif
-	struct Pimpl;
+	LyXLayout_ptr layout_;
+	/**
+	 * Keeping this here instead of in the pimpl makes LyX >10% faster
+	 * for average tasks as buffer loading/switching etc.
+	 */
+	TextContainer text_;
+	/// end of label
+	lyx::pos_type begin_of_body_;
+
+	/// Pimpl away stuff
+	class Pimpl;
 	///
-	friend struct Paragraph::Pimpl;
+	friend class Paragraph::Pimpl;
 	///
 	Pimpl * pimpl_;
 };