X-Git-Url: https://git.lyx.org/gitweb/?a=blobdiff_plain;f=src%2Flyxtext.h;h=5bf93d8278def4cd6aa4c2fee3d53d6eeb340f40;hb=c66d2f1ee555358a0a378bcdc9783a1306bd8990;hp=ee0f9e116bc644d42d89accdbd320cb1a8860e22;hpb=ccc5d5576437a7615f54bf1ed6e83e05bfbaaf78;p=lyx.git

diff --git a/src/lyxtext.h b/src/lyxtext.h
index ee0f9e116b..5bf93d8278 100644
--- a/src/lyxtext.h
+++ b/src/lyxtext.h
@@ -16,142 +16,137 @@
 
 #include "bufferview_funcs.h"
 #include "Bidi.h"
-#include "layout.h"
+#include "dispatchresult.h"
+#include "dimension.h"
 #include "lyxfont.h"
-#include "lyxtextclass.h"
-#include "ParagraphList_fwd.h"
-#include "RowList_fwd.h"
-
-#include "insets/inset.h"
+#include "layout.h"
+#include "lyxlayout_ptr_fwd.h"
+#include "ParagraphList.h"
 
 #include <iosfwd>
 
+
+namespace lyx {
+
 class Buffer;
 class BufferParams;
 class BufferView;
+class CursorSlice;
 class Dimension;
+class ErrorList;
+class InsetBase;
+class InsetBase_code;
+class FuncRequest;
+class FuncStatus;
 class LColor_color;
-class CursorSlice;
+class LCursor;
+class LyXTextClass;
 class MetricsInfo;
-class Paragraph;
+class PainterInfo;
 class Row;
+class RowMetrics;
 class Spacing;
-class UpdatableInset;
-class VSpace;
 
 
 /// This class encapsulates the main text data and operations in LyX
 class LyXText {
 public:
-	/// Constructor
-	LyXText(BufferView *, bool ininset);
+	/// constructor
+	explicit LyXText(BufferView * bv = 0);
 	///
 	void init(BufferView *);
 
-
-	/// update y coordinate cache of all paragraphs
-	void updateParPositions();
 	///
-	LyXFont getFont(ParagraphList::iterator pit, lyx::pos_type pos) const;
+	LyXFont getFont(Buffer const & buffer, Paragraph const & par,
+		pos_type pos) const;
+	///
+	void applyOuterFont(Buffer const & buffer, LyXFont &) const;
 	///
-	LyXFont getLayoutFont(ParagraphList::iterator pit) const;
+	LyXFont getLayoutFont(Buffer const & buffer, pit_type pit) const;
 	///
-	LyXFont getLabelFont(ParagraphList::iterator pit) const;
+	LyXFont getLabelFont(Buffer const & buffer,
+		Paragraph const & par) const;
 	///
-	void setCharFont(ParagraphList::iterator pit,
-			 lyx::pos_type pos, LyXFont const & font);
-	void setCharFont(ParagraphList::iterator pit,
-			 lyx::pos_type pos,
-			 LyXFont const & font, bool toggleall);
+	void setCharFont(Buffer const & buffer, pit_type pit, pos_type pos,
+		LyXFont const & font);
+	///
+	void setCharFont(Buffer const & buffer, pit_type pit, pos_type pos,
+		LyXFont const & font, bool toggleall);
 
 	/// what you expect when pressing <enter> at cursor position
-	void breakParagraph(ParagraphList & paragraphs, char keep_layout = 0);
+	void breakParagraph(LCursor & cur, bool keep_layout = false);
 
-	/** set layout over selection and make a total rebreak of
-	  those paragraphs
-	  */
-	ParagraphList::iterator
-	setLayout(ParagraphList::iterator start,
-		  ParagraphList::iterator end,
-		  std::string const & layout);
+	/// set layout over selection
+	void setLayout(Buffer const & buffer, pit_type start, pit_type end,
+		std::string const & layout);
 	///
-	void setLayout(std::string const & layout);
+	void setLayout(LCursor & cur, std::string const & layout);
 
+	/// what type of depth change to make
+	enum DEPTH_CHANGE {
+		INC_DEPTH,
+		DEC_DEPTH
+	};
 	/// Increase or decrease the nesting depth of the selected paragraph(s)
-	void changeDepth(bv_funcs::DEPTH_CHANGE type);
+	void changeDepth(LCursor & cur, DEPTH_CHANGE type);
 
 	/// Returns whether something would be changed by changeDepth
-	bool changeDepthAllowed(bv_funcs::DEPTH_CHANGE type);
+	bool changeDepthAllowed(LCursor & cur, DEPTH_CHANGE type) const;
 
-	/// get the depth at current cursor position
-	int getDepth() const;
+	/// Set font over selection paragraphs and rebreak.
+	void setFont(LCursor & cur, LyXFont const &, bool toggleall = false);
 
-	/** set font over selection and make a total rebreak of those
-	  paragraphs.
-	  toggleall defaults to false.
-	  */
-	void setFont(LyXFont const &, bool toggleall = false);
-
-	/// rebreaks all paragaphs between the given pars.
-	void redoParagraphs(ParagraphList::iterator begin,
-			    ParagraphList::iterator end);
-	/// rebreaks the given par
-	void redoParagraph(ParagraphList::iterator pit);
+	/// Rebreaks the given paragraph.
+	/// \retval true if a full screen redraw is needed.
+	/// \retval false if a single paragraph redraw is enough.
+	bool redoParagraph(BufferView &, pit_type pit);
 
-	/// rebreaks the cursor par
-	void redoParagraph();
+	/// returns pos in given par at given x coord
+	pos_type x2pos(BufferView const &, pit_type pit, int row, int x) const;
+	int pos2x(pit_type pit, pos_type pos) const;
 
 	///
-	void toggleFree(LyXFont const &, bool toggleall = false);
+	void toggleFree(LCursor & cur, LyXFont const &, bool toggleall = false);
 
 	///
-	std::string getStringToIndex();
+	docstring getStringToIndex(LCursor const & cur);
 
-	/** insert a character, moves all the following breaks in the
-	  same Paragraph one to the right and make a little rebreak
-	  */
-	void insertChar(char c);
-	///
-	void insertInset(InsetOld * inset);
+	/// insert a character at cursor position
+	void insertChar(LCursor & cur, char_type c);
+	/// insert an inset at cursor position
+	void insertInset(LCursor & cur, InsetBase * inset);
 
-	/// a full rebreak of the whole text
-	void fullRebreak();
 	/// compute text metrics
 	void metrics(MetricsInfo & mi, Dimension & dim);
 	/// draw text (only used for insets)
 	void draw(PainterInfo & pi, int x, int y) const;
+	/// draw textselection
+	void drawSelection(PainterInfo & pi, int x, int y) const;
 
 	/// try to handle that request
-	DispatchResult dispatch(LCursor & cur, FuncRequest const & cmd);
-
-	BufferView * bv();
-
-	BufferView * bv() const;
-
-	friend class LyXScreen;
-
-	/// returns an iterator pointing to a cursor paragraph
-	ParagraphList::iterator getPar(CursorSlice const & cursor) const;
-	///
-	ParagraphList::iterator getPar(lyx::paroffset_type par) const;
-	///
-	int parOffset(ParagraphList::iterator pit) const;
-	/// convenience
-	ParagraphList::iterator cursorPar() const;
-	///
-	RowList::iterator cursorRow() const;
-
-	/** returns an iterator pointing to the row near the specified
-	  * y-coordinate (relative to the whole text). y is set to the
-	  * real beginning of this row
+	void dispatch(LCursor & cur, FuncRequest & cmd);
+	/// do we want to handle this event?
+	bool getStatus(LCursor & cur, FuncRequest const & cmd,
+		FuncStatus & status) const;
+
+	/// read-only access to individual paragraph
+	Paragraph const & getPar(pit_type pit) const { return pars_[pit]; }
+	/// read-write access to individual paragraph
+	Paragraph & getPar(pit_type pit) { return pars_[pit]; }
+	// Returns the current font and depth as a message.
+	std::string currentState(LCursor & cur);
+
+	/** returns row near the specified
+	  * y-coordinate in given paragraph (relative to the screen).
 	  */
-	RowList::iterator getRowNearY(int y,
-		ParagraphList::iterator & pit) const;
+	Row const & getRowNearY(BufferView const & bv, int y,
+		pit_type pit) const;
+	pit_type getPitNearY(BufferView const & bv, int y) const;
 
 	/** returns the column near the specified x-coordinate of the row
 	 x is set to the real beginning of this column
 	 */
-	lyx::pos_type getColumnNearX(ParagraphList::iterator pit,
+	pos_type getColumnNearX(BufferView const & bv, pit_type pit,
 		Row const & row, int & x, bool & boundary) const;
 
 	/** Find the word under \c from in the relative location
@@ -159,74 +154,94 @@ public:
 	 *  @param from return here the start of the word
 	 *  @param to return here the end of the word
 	 */
-	void getWord(CursorSlice & from, CursorSlice & to, lyx::word_location const);
+	void getWord(CursorSlice & from, CursorSlice & to, word_location const);
 	/// just selects the word the cursor is in
-	void selectWord(lyx::word_location loc);
-	/// returns the inset at cursor (if it exists), 0 otherwise
-	InsetOld * getInset() const;
+	void selectWord(LCursor & cur, word_location loc);
 
 	/// accept selected change
-	void acceptChange();
-
+	void acceptChange(LCursor & cur);
 	/// reject selected change
-	void rejectChange();
+	void rejectChange(LCursor & cur);
 
-	///
-	void setCursor(ParagraphList::iterator pit, lyx::pos_type pos);
 	/// returns true if par was empty and was removed
-	bool setCursor(lyx::paroffset_type par, lyx::pos_type pos,
+	bool setCursor(LCursor & cur, pit_type par, pos_type pos,
 		       bool setfont = true, bool boundary = false);
 	///
-	void setCursor(CursorSlice &, lyx::paroffset_type par,
-		       lyx::pos_type pos, bool boundary = false);
+	void setCursor(CursorSlice &, pit_type par, pos_type pos);
 	///
-	void setCursorIntern(lyx::paroffset_type par, lyx::pos_type pos,
-			     bool setfont = true, bool boundary = false);
+	void setCursorIntern(LCursor & cur, pit_type par,
+		 pos_type pos, bool setfont = true, bool boundary = false);
 	///
-	void setCurrentFont();
+	void setCurrentFont(LCursor & cur);
 
 	///
-	void recUndo(lyx::paroffset_type first, lyx::paroffset_type last) const;
-	///
-	void recUndo(lyx::paroffset_type first) const;
-	///
-	void setCursorFromCoordinates(int x, int y);
-	///
-	void setCursorFromCoordinates(CursorSlice &, int x, int y);
+	void recUndo(LCursor & cur, pit_type first, pit_type last) const;
 	///
-	void cursorUp(bool selecting = false);
-	///
-	void cursorDown(bool selecting = false);
-	///
-	bool cursorLeft(bool internal = true);
-	///
-	bool cursorRight(bool internal = true);
-	///
-	void cursorLeftOneWord();
-	///
-	void cursorRightOneWord();
+	void recUndo(LCursor & cur, pit_type first) const;
+	/// returns true if par was empty and was removed
+	bool setCursorFromCoordinates(LCursor & cur, int x, int y);
+
+	/// sets cursor recursively descending into nested editable insets
+	/**
+	\return the inset pointer if x,y is covering that inset
+	\param x,y are absolute screen coordinates.
+	\retval inset is non-null if the cursor is positionned inside
+	*/
+	InsetBase * editXY(LCursor & cur, int x, int y);
+	
+	/// Move cursor one line up.
+	/**
+	 * Returns true if an update is needed after the move.
+	 */
+	bool cursorUp(LCursor & cur);
+	/// Move cursor one line down.
+	/**
+	 * Returns true if an update is needed after the move.
+	 */
+	bool cursorDown(LCursor & cur);
+	/// Move cursor one position left
+	/**
+	 * Returns true if an update is needed after the move.
+	 */
+	bool cursorLeft(LCursor & cur);
+	/// Move cursor one position right
+	/**
+	 * Returns true if an update is needed after the move.
+	 */
+	bool cursorRight(LCursor & cur);
 	///
-	void cursorUpParagraph();
+	bool cursorLeftOneWord(LCursor & cur);
 	///
-	void cursorDownParagraph();
+	bool cursorRightOneWord(LCursor & cur);
 	///
-	void cursorHome();
+	bool cursorUpParagraph(LCursor & cur);
 	///
-	void cursorEnd();
+	bool cursorDownParagraph(LCursor & cur);
 	///
-	void cursorPrevious();
+	bool cursorHome(LCursor & cur);
 	///
-	void cursorNext();
+	bool cursorEnd(LCursor & cur);
 	///
-	void cursorTop();
+	bool cursorPrevious(LCursor & cur);
 	///
-	void cursorBottom();
+	bool cursorNext(LCursor & cur);
 	///
-	void Delete();
+	bool cursorTop(LCursor & cur);
 	///
-	void backspace();
+	bool cursorBottom(LCursor & cur);
+	/// Erase character at cursor. Honour change tracking
+	bool erase(LCursor & cur);
+	/** At cursor position 0, merge paragraph with the one before it.
+	 * Ignore CT (this is used in \c acceptChange, \c rejectChange for
+	 * physical deletion of paragraph break)
+	 */
+	bool backspacePos0(LCursor & cur);
+	/// Delete character before cursor. Honour CT
+	bool backspace(LCursor & cur);
+	// Dissolve the inset under cursor
+	bool dissolveInset(LCursor & cur);
 	///
-	bool selectWordWhenUnderCursor(lyx::word_location);
+	bool selectWordWhenUnderCursor(LCursor & cur, word_location);
 	///
 	enum TextCase {
 		///
@@ -237,68 +252,43 @@ public:
 		text_uppercase = 2
 	};
 	/// Change the case of the word at cursor position.
-	void changeCase(TextCase action);
-
-	/// returns success
-	bool toggleInset();
-	///
-	void cutSelection(bool doclear = true, bool realcut = true);
-	///
-	void copySelection();
-	///
-	void pasteSelection(size_t sel_index = 0);
+	void changeCase(LCursor & cur, TextCase action);
+	/// Transposes the character at the cursor with the one before it
+	void charsTranspose(LCursor & cur);
 
 	/** the DTP switches for paragraphs. LyX will store the top settings
 	 always in the first physical paragraph, the bottom settings in the
 	 last. When a paragraph is broken, the top settings rest, the bottom
 	 settings are given to the new one.
 	 */
-	void setParagraph(
+	void setParagraph(LCursor & cur,
 			  Spacing const & spacing,
 			  LyXAlignment align,
-			  std::string const & labelwidthstring,
+			  docstring const & labelwidthstring,
 			  bool noindent);
 
 	/* these things are for search and replace */
 
-	/**
-	 * Sets the selection from the current cursor position to length
-	 * characters to the right. No safety checks.
-	 */
-	void setSelectionRange(lyx::pos_type length);
-
-	/** simple replacing. The font of the first selected character
-	  is used
-	  */
-	void replaceSelectionWithString(std::string const & str);
-
 	/// needed to insert the selection
-	void insertStringAsLines(std::string const & str);
+	void insertStringAsLines(LCursor & cur, docstring const & str);
 	/// needed to insert the selection
-	void insertStringAsParagraphs(std::string const & str);
+	void insertStringAsParagraphs(LCursor & cur, docstring const & str);
 
-	/// Find next inset of some specified type.
-	bool gotoNextInset(std::vector<InsetOld::Code> const & codes,
-			   std::string const & contents = std::string());
-	///
-	void gotoInset(std::vector<InsetOld::Code> const & codes,
-		       bool same_content);
-	///
-	void gotoInset(InsetOld::Code code, bool same_content);
+	/// current text width
+	int width() const;
 
-	/// current max text width
-	int textWidth() const;
+	/// current text heigth
+	int height() const;
 
-	/// updates all counters
-	void updateCounters();
 	/// Returns an inset if inset was hit, or 0 if not.
-	InsetOld * checkInsetHit(int x, int y);
+	InsetBase * checkInsetHit(BufferView const &, int x, int y) const;
 
 	///
-	int singleWidth(ParagraphList::iterator pit, lyx::pos_type pos) const;
+	int singleWidth(Buffer const &, Paragraph const & par,
+		pos_type pos) const;
 	///
-	int singleWidth(ParagraphList::iterator pit,
-		lyx::pos_type pos, char c, LyXFont const & Font) const;
+	int singleWidth(Paragraph const & par, pos_type pos, char_type c,
+		LyXFont const & Font) const;
 
 	/// return the color of the canvas
 	LColor_color backgroundColor() const;
@@ -309,193 +299,120 @@ public:
 	 * in LaTeX the beginning of the text fits in some cases
 	 * (for example sections) exactly the label-width.
 	 */
-	int leftMargin(ParagraphList::iterator pit, lyx::pos_type pos) const;
-	int leftMargin(ParagraphList::iterator pit) const;
+	int leftMargin(Buffer const &, pit_type pit, pos_type pos) const;
+	int leftMargin(Buffer const &, pit_type pit) const;
 	///
-	int rightMargin(Paragraph const & par) const;
+	int rightMargin(Buffer const &, Paragraph const & par) const;
 
 	/** this calculates the specified parameters. needed when setting
 	 * the cursor and when creating a visible row */
-	void prepareToPrint(ParagraphList::iterator pit, Row & row) const;
+	RowMetrics computeRowMetrics(Buffer const &, pit_type pit,
+		Row const & row) const;
 
-	//
-	// special owner functions
-	///
-	ParagraphList & paragraphs() const;
-
-	/// return true if this is owned by an inset.
-	bool isInInset() const;
+	/// access to our paragraphs
+	ParagraphList const & paragraphs() const { return pars_; }
+	ParagraphList & paragraphs() { return pars_; }
+	/// return true if this is the main text
+	bool isMainText(Buffer const &) const;
 
-	///
-	ParagraphList::iterator firstPar() const;
-	///
-	ParagraphList::iterator lastPar() const;
-	///
-	ParagraphList::iterator endPar() const;
-	
 	/// return first row of text
-	RowList::iterator firstRow() const;
-	/// return last row of text
-	RowList::iterator lastRow() const;
-	/// return row "behind" last row of text
-	RowList::iterator endRow() const;
-	/// return next row crossing paragraph boundaries
-	void nextRow(ParagraphList::iterator & pit,
-		RowList::iterator & rit) const;
-	/// return previous row crossing paragraph boundaries
-	void previousRow(ParagraphList::iterator & pit,
-		RowList::iterator & rit) const;
+	Row const & firstRow() const;
 
 	/// is this row the last in the text?
-	bool isLastRow(ParagraphList::iterator pit, Row const & row) const;
+	bool isLastRow(pit_type pit, Row const & row) const;
 	/// is this row the first in the text?
-	bool isFirstRow(ParagraphList::iterator pit, Row const & row) const;
+	bool isFirstRow(pit_type pit, Row const & row) const;
 
 	///
-	std::string selectionAsString(Buffer const & buffer, bool label) const;
+	double spacing(Buffer const & buffer, Paragraph const & par) const;
+	/// make a suggestion for a label
+	docstring getPossibleLabel(LCursor & cur) const;
+	/// is this paragraph right-to-left?
+	bool isRTL(Buffer const &, Paragraph const & par) const;
 	///
-	double spacing(Paragraph const &) const;
-	///
-	void cursorLeftOneWord(CursorSlice &);
-	///
-	void cursorRightOneWord(CursorSlice &);
-
-	///
-	DispatchResult moveRight();
-	///
-	DispatchResult moveLeft();
-	///
-	DispatchResult moveRightIntern(bool front,
-		bool activate_inset, bool selecting);
-	///
-	DispatchResult moveLeftIntern(bool front,
-		bool activate_inset, bool selecting);
-	///
-	DispatchResult moveUp();
-	///
-	DispatchResult moveDown();
-	///
-	bool checkAndActivateInset(bool front);
+	bool checkAndActivateInset(LCursor & cur, bool front);
 
 	///
 	void write(Buffer const & buf, std::ostream & os) const;
 	/// returns whether we've seen our usual 'end' marker
-	bool read(Buffer const & buf, LyXLex & lex);
+	bool read(Buffer const & buf, LyXLex & lex, ErrorList & errorList);
 
 	///
 	int ascent() const;
 	///
 	int descent() const;
 	///
-	int cursorX() const;
-	///
-	int cursorY() const;
+	int cursorX(Buffer const &, CursorSlice const & cursor,
+		bool boundary) const;
 	///
-	int cursorX(CursorSlice const & cursor) const;
-	///
-	int cursorY(CursorSlice const & cursor) const;
+	int cursorY(CursorSlice const & cursor, bool boundary) const;
 
-	/// the topmost cursor slice
-	CursorSlice & cursor();
-	/// the topmost cursor slice
-	CursorSlice const & cursor() const;
-	/// access to the selection anchor
-	CursorSlice & anchor();
-	/// access to the selection anchor
-	CursorSlice const & anchor() const;
+	/// delete double space or empty paragraphs around old cursor
+	bool deleteEmptyParagraphMechanism(LCursor & cur, LCursor & old);
 
 public:
 	///
-	int height;
-	///
-	unsigned int width;
+	Dimension dim_;
 	///
-	int textwidth_;
+	int maxwidth_;
 	/// the current font settings
 	LyXFont current_font;
 	/// the current font
 	LyXFont real_current_font;
-	/// our buffer's default layout font
-	LyXFont defaultfont_;
 	///
 	int background_color_;
 
-	/// only the top-level LyXText has this non-zero
-	BufferView * bv_owner;
-
 	///
 	mutable Bidi bidi;
 	///
-	bool in_inset_;
-	///
-	ParagraphList paragraphs_;
-
-	/// absolute document pixel coordinates of this LyXText
-	mutable int xo_;
-	mutable int yo_;
+	ParagraphList pars_;
 
-	/// our 'outermost' Font
+	/// our 'outermost' font. This is handed down from the surrounding
+	// inset through the pi/mi parameter (pi.base.font)
 	LyXFont font_;
 
-
+	///
+	bool autoBreakRows_;
 private:
 	/// return past-the-last paragraph influenced by a layout
 	/// change on pit
-	ParagraphList::iterator undoSpan(ParagraphList::iterator pit);
-	
-	/// rebreaks the given par
-	void redoParagraphInternal(ParagraphList::iterator pit);
-	/// used in setlayout
-	void makeFontEntriesLayoutSpecific(BufferParams const &, Paragraph & par);
+	pit_type undoSpan(pit_type pit);
 
 	/// Calculate and set the height of the row
-	void setHeightOfRow(ParagraphList::iterator, Row & row);
+	void setHeightOfRow(BufferView const &, pit_type, Row & row);
 
 	// fix the cursor `cur' after a characters has been deleted at `where'
 	// position. Called by deleteEmptyParagraphMechanism
 	void fixCursorAfterDelete(CursorSlice & cur, CursorSlice const & where);
 
-	/// delete double space (false) or empty paragraphs (true) around old_cursor
-	bool deleteEmptyParagraphMechanism(CursorSlice const & old_cursor);
-
-	///
-	void setCounter(Buffer const &, ParagraphList::iterator pit);
 	///
-	void deleteWordForward();
+	void deleteWordForward(LCursor & cur);
 	///
-	void deleteWordBackward();
+	void deleteWordBackward(LCursor & cur);
 	///
-	void deleteLineForward();
+	void deleteLineForward(LCursor & cur);
 
 	/// sets row.end to the pos value *after* which a row should break.
 	/// for example, the pos after which isNewLine(pos) == true
-	void rowBreakPoint(ParagraphList::iterator pit, Row & row) const;
-
-	/// sets row.witdh to the minimum space a row needs on the screen in pixel
-	void fill(ParagraphList::iterator pit, Row & row, int workwidth) const;
-
-	/**
-	 * returns the minimum space a manual label needs on the
-	 * screen in pixels
-	 */
-	int labelFill(ParagraphList::iterator pit, Row const & row) const;
-
+	void rowBreakPoint(Buffer const &, int right_margin, pit_type pit,
+		Row & row) const;
+	/// sets row.width to the minimum space a row needs on the screen in pixel
+	void setRowWidth(Buffer const &, pit_type pit, Row & row) const;
+	/// the minimum space a manual label needs on the screen in pixels
+	int labelFill(Buffer const &, Paragraph const & par, Row const & row) const;
 	/// FIXME
-	int labelEnd(ParagraphList::iterator pit) const;
+	int labelEnd(Buffer const &, pit_type pit) const;
 
 	///
 	void charInserted();
 	/// set 'number' font property
-	void number();
-	/// is the cursor paragraph right-to-left?
-	bool rtl() const;
+	void number(LCursor & cur);
 };
 
 /// return the default height of a row in pixels, considering font zoom
-extern int defaultRowHeight();
+int defaultRowHeight();
+
 
-///
-std::string expandLabel(LyXTextClass const & textclass,
-		LyXLayout_ptr const & layout, bool appendix);
+} // namespace lyx
 
 #endif // LYXTEXT_H