// -*- 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
#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;
+class BufferView;
/// 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
+ };
+#ifndef NEW_INSETS
+ ///
+ 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 {
///
WIDE_TAB // CFO-G, 971106
};
-
+#endif
+ ///
+ 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(BufferParams const &) const;
+ ///
+ bool isRightToLeftPar(BufferParams const &) const;
+ ///
+ void ChangeLanguage(BufferParams const & bparams,
+ Language const * from, Language const * to);
+ ///
+ bool isMultiLingual(BufferParams const &);
+ ///
+ string String(Buffer const *, bool label);
///
- void validate(LaTeXFeatures&);
+ string 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,
+ std::ostream & foot, TexRow & foot_texrow,
+ int & foot_count);
+ ///
+ 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,
+ 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(BufferParams const &) const;
///
- int size;
-
+ Inset * InInset() { return inset_owner; }
+ ///
+ void SetInsetOwner(Inset * i);
+ ///
+ void deleteInsetsLyXText(BufferView *);
+private:
+ ///
+ TextContainer text;
///
- char *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;
-
+
///
- signed char layout;
+ Spacing spacing;
+ ///
+ LyXTextClass::LayoutList::size_type layout;
+#ifndef NEW_INSETS
/**
\begin{itemize}
\item no footnote, closed footnote,
/// footnote, margin, fig, tab
footnote_kind footnotekind;
-
+#endif
//@Man: the LyX- DTP-switches
//@{
///
bool pagebreak_bottom;
///
- char align;
+ LyXAlignment align;
///
char depth;
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;
//@}
///
- 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 *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;
/// 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(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 GetFontSettings(BufferParams const &, 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.
attributes with values LyXFont::INHERIT, LyXFont::IGNORE or
LyXFont::TOGGLE.
*/
- LyXFont getFont(int pos);
-
+ LyXFont getFont(BufferParams const &, 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 InsertChar(size_type pos, char 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;
///
- void CutIntoMinibuffer(int pos);
+ void OpenFootnote(size_type pos);
///
- void InsertFromMinibuffer(int pos);
-
+ void CloseFootnote(size_type pos);
+ /// 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;
///
- bool IsNewline(int pos) {
- bool tmp=false;
- if (pos>=0)
- tmp= IsNewlineChar(GetChar(pos));
- return tmp;
- }
-
+ bool IsFloat(size_type pos) const;
///
- 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;
+
+ /// 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;
- }
+ void CloseFootnotes();
+
+ ///
+ LyXParagraph * FirstSelfrowPar();
+
+ ///
+ int StripLeadingSpaces(LyXTextClassList::size_type tclass);
/** A paragraph following a footnote is a "dummy". A paragraph
with a footnote in it is stored as three paragraphs:
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(BufferParams const &,
+ int type, char const * width, char const * widthp);
///
- void UnsetPExtraType();
+ void UnsetPExtraType(BufferParams const &);
///
- bool RoffContTableRows(FILE *file, int i, int actcell);
+ bool linuxDocConvertChar(char c, string & sgml_string);
///
- bool linuxDocConvertChar(char c, string &sgml_string);
+ void DocBookContTableRows(Buffer const *,
+ std::ostream &, string & extra,
+ int & desc_on, size_type i,
+ int current_cell_number, int & column);
///
- void SimpleDocBookOneTablePar(string &file, string &extra,
- int &desc_on, int depth);
- ///
- void DocBookContTableRows(string &file, string &extra, int &desc_on,
- int i, int current_cell_number, int &column);
+ void SimpleDocBookOneTablePar(Buffer const *,
+ 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;}
+ };
+ ///
+ friend struct matchIT;
+ ///
+ 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
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
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;}
+ };
+ friend struct matchFT;
+ ///
+ struct matchFT {
+ /// used by lower_bound
+ inline
+ int operator()(LyXParagraph::FontTable const & a,
+ LyXParagraph::size_type pos) const {
+ return a.pos < pos;
+ }
+ /// used by upper_bound
+ inline
+ int operator()(LyXParagraph::size_type pos,
+ LyXParagraph::FontTable const & a) const {
+ return pos < a.pos;
+ }
};
+
+ ///
+ typedef std::vector<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(Buffer const *, BufferParams const &,
+ std::ostream &, TexRow & texrow,
+ std::ostream & foot, TexRow & foot_texrow,
+ int & foot_count);
///
- bool SimpleTeXOnePar(string &file, TexRow &texrow);
+ LyXParagraph * TeXFootnote(Buffer const *, BufferParams const &,
+ 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(Buffer const *, BufferParams const &,
+ std::ostream &, TexRow & texrow);
///
- bool TeXContTableRows(string &file, int i, int current_cell_number,
- int &column, TexRow &texrow);
+ bool TeXContTableRows(Buffer const *, BufferParams const &,
+ 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(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);
///
- 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() {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