src/paragraph_pimpl.h

   1 // -*- C++ -*-
   2 /**
   3  * \file paragraph_pimpl.h
   4  * This file is part of LyX, the document processor.
   5  * Licence details can be found in the file COPYING.
   6  *
   7  * \author Lars Gullik Bjønnes
   8  * \author Jean-Marc Lasgouttes
   9  * \author John Levon
  10  * \author André Pönitz
  11  *
  12  * Full author contact details are available in file CREDITS.
  13  */
  14
  15 #ifndef PARAGRAPH_PIMPL_H
  16 #define PARAGRAPH_PIMPL_H
  17
  18 #include "paragraph.h"
  19
  20 #include "changes.h"
  21 #include "lyxfont.h"
  22 #include "ParagraphParameters.h"
  23
  24 #include <boost/scoped_ptr.hpp>
  25
  26
  27 namespace lyx {
  28
  29 class LyXLayout;
  30
  31
  32 class Paragraph::Pimpl {
  33 public:
  34         ///
  35         Pimpl(Paragraph * owner);
  36         /// "Copy constructor"
  37         Pimpl(Pimpl const &, Paragraph * owner);
  38
  39         //
  40         // Change tracking
  41         //
  42         /// look up change at given pos
  43         Change const lookupChange(pos_type pos) const;
  44         /// is there a change within the given range ?
  45         bool isChanged(pos_type start, pos_type end) const;
  46         /// set change for the entire par
  47         void setChange(Change const & change);
  48         /// set change at given pos
  49         void setChange(pos_type pos, Change const & change);
  50         /// accept changes within the given range
  51         void acceptChanges(pos_type start, pos_type end);
  52         /// reject changes within the given range
  53         void rejectChanges(pos_type start, pos_type end);
  54
  55         ///
  56         value_type getChar(pos_type pos) const;
  57         ///
  58         void insertChar(pos_type pos, value_type c, Change const & change);
  59         ///
  60         void insertInset(pos_type pos, InsetBase * inset, Change const & change);
  61         /// (logically) erase the char at pos; return true if it was actually erased
  62         bool eraseChar(pos_type pos, bool trackChanges);
  63         /// (logically) erase the given range; return the number of chars actually erased
  64         int eraseChars(pos_type start, pos_type end, bool trackChanges);
  65         ///
  66         InsetBase * inset_owner;
  67
  68         /** A font entry covers a range of positions. Notice that the
  69             entries in the list are inserted in random order.
  70             I don't think it's worth the effort to implement a more effective
  71             datastructure, because the number of different fonts in a paragraph
  72             is limited. (Asger)
  73             Nevertheless, I decided to store fontlist using a sorted vector:
  74             fontlist = { {pos_1,font_1} , {pos_2,font_2} , ... } where
  75             pos_1 < pos_2 < ..., font_{i-1} != font_i for all i,
  76             and font_i covers the chars in positions pos_{i-1}+1,...,pos_i
  77             (font_1 covers the chars 0,...,pos_1) (Dekel)
  78         */
  79         class FontTable  {
  80         public:
  81                 ///
  82                 FontTable(pos_type p, LyXFont const & f)
  83                         : pos_(p), font_(f)
  84                 {}
  85                 ///
  86                 pos_type pos() const { return pos_; }
  87                 ///
  88                 void pos(pos_type p) { pos_ = p; }
  89                 ///
  90                 LyXFont const & font() const { return font_; }
  91                 ///
  92                 void font(LyXFont const & f) { font_ = f;}
  93         private:
  94                 /// End position of paragraph this font attribute covers
  95                 pos_type pos_;
  96                 /** Font. Interpretation of the font values:
  97                     If a value is LyXFont::INHERIT_*, it means that the font
  98                     attribute is inherited from either the layout of this
  99                     paragraph or, in the case of nested paragraphs, from the
 100                     layout in the environment one level up until completely
 101                     resolved.
 102                     The values LyXFont::IGNORE_* and LyXFont::TOGGLE are NOT
 103                     allowed in these font tables.
 104                 */
 105                 LyXFont font_;
 106         };
 107         ///
 108         friend class matchFT;
 109         ///
 110         class matchFT {
 111         public:
 112                 /// used by lower_bound and upper_bound
 113                 int operator()(FontTable const & a, FontTable const & b) const {
 114                         return a.pos() < b.pos();
 115                 }
 116         };
 117
 118         ///
 119         typedef std::vector<FontTable> FontList;
 120         ///
 121         FontList fontlist;
 122
 123         ///
 124         void simpleTeXBlanks(odocstream &, TexRow & texrow,
 125                              pos_type const i,
 126                              unsigned int & column,
 127                              LyXFont const & font,
 128                              LyXLayout const & style);
 129         ///
 130         void simpleTeXSpecialChars(Buffer const &, BufferParams const &,
 131                                    odocstream &, TexRow & texrow,
 132                                    OutputParams const &,
 133                                    LyXFont & font, LyXFont & running_font,
 134                                    LyXFont & basefont,
 135                                    LyXFont const & outerfont,
 136                                    bool & open_font,
 137                                    Change::Type & running_change,
 138                                    LyXLayout const & style,
 139                                    pos_type & i,
 140                                    unsigned int & column, value_type const c);
 141
 142         ///
 143         void validate(LaTeXFeatures & features,
 144                       LyXLayout const & layout) const;
 145
 146         ///
 147         unsigned int id_;
 148         ///
 149         static unsigned int paragraph_id;
 150         ///
 151         ParagraphParameters params;
 152
 153 private:
 154         ///
 155         pos_type size() const { return owner_->size(); }
 156         /// match a string against a particular point in the paragraph
 157         bool isTextAt(std::string const & str, pos_type pos) const;
 158
 159         /// for recording and looking up changes
 160         Changes changes_;
 161
 162         /// Who owns us?
 163         Paragraph * owner_;
 164 };
 165
 166
 167 } // namespace lyx
 168
 169 #endif