src/TextMetrics.h

   1 // -*- C++ -*-
   2 /**
   3  * \file TextMetrics.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 John Levon
   9  * \author Abdelrazak Younes
  10  *
  11  * Full author contact details are available in file CREDITS.
  12  */
  13
  14 #ifndef TEXT_METRICS_H
  15 #define TEXT_METRICS_H
  16
  17 #include "Font.h"
  18 #include "InsetList.h"
  19 #include "LayoutEnums.h"
  20 #include "ParagraphMetrics.h"
  21
  22 #include "support/types.h"
  23
  24 namespace lyx {
  25
  26 class BufferView;
  27 class Cursor;
  28 class CursorSlice;
  29 class DocIterator;
  30 class MetricsInfo;
  31 class Text;
  32
  33 /// A map from a Text to the map of paragraphs metrics
  34 class TextMetrics
  35 {
  36 public:
  37         /// Default constructor (only here for STL containers).
  38         TextMetrics() : bv_(0), text_(0), max_width_(0) {}
  39         /// The only useful constructor.
  40         TextMetrics(BufferView *, Text *);
  41
  42         ///
  43         bool contains(pit_type pit) const;
  44         ///
  45         ParagraphMetrics const & parMetrics(pit_type) const;
  46         ///
  47         std::pair<pit_type, ParagraphMetrics const *> first() const;
  48         ///
  49         std::pair<pit_type, ParagraphMetrics const *> last() const;
  50
  51         ///
  52         Dimension const & dimension() const { return dim_; }
  53         ///
  54         Point const & origin() const { return origin_; }
  55
  56
  57         /// compute text metrics.
  58         bool metrics(MetricsInfo & mi, Dimension & dim, int min_width = 0);
  59
  60         ///
  61         void newParMetricsDown();
  62         ///
  63         void newParMetricsUp();
  64
  65         /// Gets the fully instantiated font at a given position in a paragraph
  66         /// Basically the same routine as Paragraph::getFont() in Paragraph.cpp.
  67         /// The difference is that this one is used for displaying, and thus we
  68         /// are allowed to make cosmetic improvements. For instance make footnotes
  69         /// smaller. (Asger)
  70         Font displayFont(pit_type pit, pos_type pos) const;
  71
  72         /// There are currently two font mechanisms in LyX:
  73         /// 1. The font attributes in a lyxtext, and
  74         /// 2. The inset-specific font properties, defined in an inset's
  75         /// metrics() and draw() methods and handed down the inset chain through
  76         /// the pi/mi parameters, and stored locally in a lyxtext in font_.
  77         /// This is where the two are integrated in the final fully realized
  78         /// font.
  79         void applyOuterFont(Font &) const;
  80
  81         /// is this position in the paragraph right-to-left?
  82         bool isRTL(CursorSlice const & sl, bool boundary) const;
  83         /// is between pos-1 and pos an RTL<->LTR boundary?
  84         bool isRTLBoundary(pit_type pit,
  85           pos_type pos) const;
  86         /// would be a RTL<->LTR boundary between pos and the given font?
  87         bool isRTLBoundary(pit_type pit,
  88           pos_type pos, Font const & font) const;
  89
  90
  91         /// Rebreaks the given paragraph.
  92         /// \retval true if a full screen redraw is needed.
  93         /// \retval false if a single paragraph redraw is enough.
  94         bool redoParagraph(pit_type const pit);
  95         /// Clear cache of paragraph metrics
  96         void clear() { par_metrics_.clear(); }
  97         /// Is cache of paragraph metrics empty ?
  98         bool empty() const { return par_metrics_.empty(); }
  99
 100         ///
 101         int ascent() const { return dim_.asc; }
 102         ///
 103         int descent() const { return dim_.des; }
 104         /// current text width.
 105         int width() const { return dim_.wid; }
 106         /// current text height.
 107         int height() const { return dim_.height(); }
 108
 109         ///
 110         int rightMargin(ParagraphMetrics const & pm) const;
 111         int rightMargin(pit_type const pit) const;
 112
 113         ///
 114         void draw(PainterInfo & pi, int x, int y) const;
 115
 116         void drawParagraph(PainterInfo & pi, pit_type pit, int x, int y) const;
 117
 118 private:
 119         ///
 120         ParagraphMetrics & parMetrics(pit_type, bool redo_paragraph);
 121
 122         /**
 123          * Returns the left beginning of the text.
 124          * This information cannot be taken from the layout object, because
 125          * in LaTeX the beginning of the text fits in some cases
 126          * (for example sections) exactly the label-width.
 127          */
 128         int leftMargin(pit_type pit, pos_type pos) const;
 129         int leftMargin(pit_type pit) const;
 130
 131         /// the minimum space a manual label needs on the screen in pixels
 132         int labelFill(Row const & row) const;
 133
 134         /// FIXME??
 135         int labelEnd(pit_type const pit) const;
 136
 137         /// sets row.end to the pos value *after* which a row should break.
 138         /// for example, the pos after which isNewLine(pos) == true
 139         /// \return true when another row is required (after a newline)
 140         bool breakRow(Row & row, int right_margin) const;
 141
 142         // Expand the alignment of row \param row in paragraph \param par
 143         LyXAlignment getAlign(Paragraph const & par, Row const & row) const;
 144         /** this calculates the specified parameters. needed when setting
 145          * the cursor and when creating a visible row */
 146         void computeRowMetrics(Row & row, int width) const;
 147
 148         /// Set the height of the row (without space above/below paragraph)
 149         void setRowHeight(Row & row) const;
 150         // Compute the space on top of a paragraph
 151         int parTopSpacing(pit_type pit) const;
 152         // Compute the space below a a paragraph
 153         int parBottomSpacing(pit_type pit) const;
 154
 155         // Helper function for the other checkInsetHit method.
 156         InsetList::InsetTable * checkInsetHit(pit_type pit, int x, int y);
 157
 158
 159 // Temporary public:
 160 public:
 161         /// returns the position near the specified x-coordinate of the row.
 162         /// x is an absolute screen coord, it is set to the real beginning
 163         /// of this column. This takes in account horizontal cursor row scrolling.
 164         pos_type getPosNearX(Row const & row, int & x, bool & boundary) const;
 165
 166         /// returns pos in given par at given x coord.
 167         pos_type x2pos(pit_type pit, int row, int x) const;
 168
 169         // FIXME: is there a need for this?
 170         //int pos2x(pit_type pit, pos_type pos) const;
 171
 172         /// returns the row near the specified y-coordinate in a given paragraph
 173         /// (relative to the screen). If assert_in_view is true, it is made sure
 174         /// that the row is on screen completely; this might change the given pit.
 175         Row const & getPitAndRowNearY(int & y, pit_type & pit,
 176                 bool assert_in_view, bool up);
 177
 178         /// returns the paragraph number closest to screen y-coordinate.
 179         /// This method uses the BufferView CoordCache to locate the
 180         /// paragraph. The y-coodinate is allowed to be off-screen and
 181         /// the CoordCache will be automatically updated if needed. This is
 182         /// the reason why we need a non const BufferView.
 183         pit_type getPitNearY(int y);
 184
 185         /// sets cursor recursively descending into nested editable insets
 186         /**
 187         \return the inset pointer if x,y is covering that inset
 188         \param x,y are absolute screen coordinates.
 189         \param assert_in_view if true the cursor will be set on a row
 190            that is completely visible
 191         \param up whether we are going up or down (only used when
 192            assert_in_view is true
 193         \retval inset is null if the cursor is positioned over normal
 194                text in the current Text object. Otherwise it is the inset
 195                that the cursor points to, like for Inset::editXY.
 196         */
 197         /// FIXME: cleanup to use BufferView::getCoveringInset() and
 198         /// setCursorFromCoordinates() instead of checkInsetHit().
 199         Inset * editXY(Cursor & cur, int x, int y,
 200                 bool assert_in_view = false, bool up = true);
 201
 202         /// sets cursor only within this Text.
 203         /// x,y are screen coordinates
 204         void setCursorFromCoordinates(Cursor & cur, int x, int y);
 205
 206         ///
 207         int cursorX(CursorSlice const & cursor, bool boundary) const;
 208         ///
 209         int cursorY(CursorSlice const & cursor, bool boundary) const;
 210
 211         ///
 212         bool cursorHome(Cursor & cur);
 213         ///
 214         bool cursorEnd(Cursor & cur);
 215         ///
 216         void deleteLineForward(Cursor & cur);
 217
 218         /// is this row the last in the text?
 219         bool isLastRow(Row const & row) const;
 220         /// is this row the first in the text?
 221         bool isFirstRow(Row const & row) const;
 222
 223         /// Returns an inset if inset was hit, or 0 if not.
 224         /// \warning This method is not recursive! It will return the
 225         /// outermost inset within this Text.
 226         /// \sa BufferView::getCoveringInset() to get the innermost inset.
 227         Inset * checkInsetHit(int x, int y);
 228
 229         /// calculates the position of a completion popup
 230         void completionPosAndDim(Cursor const & cur, int & x, int & y,
 231                 Dimension & dim) const;
 232
 233 private:
 234         friend class BufferView;
 235
 236         /// The BufferView owner.
 237         BufferView * bv_;
 238
 239         /// The text contents (the model).
 240         /// \todo FIXME: this should be const.
 241         Text * text_;
 242
 243         /// A map from paragraph index number to paragraph metrics
 244         typedef std::map<pit_type, ParagraphMetrics> ParMetricsCache;
 245         ///
 246         mutable ParMetricsCache par_metrics_;
 247         Dimension dim_;
 248         int max_width_;
 249         mutable Point origin_;
 250
 251 // temporary public:
 252 public:
 253         /// our 'outermost' font.
 254         /// This is handed down from the surrounding
 255         /// inset through the pi/mi parameter (pi.base.font)
 256         /// It is used in applyOuterFont() and setCharFont() for reasons
 257         /// that are not clear... to hand hand the outermost language and
 258         /// also for char style apparently.
 259         Font font_;
 260 };
 261
 262 /// return the default height of a row in pixels, considering font zoom
 263 int defaultRowHeight();
 264
 265 } // namespace lyx
 266
 267 #endif // TEXT_METRICS_H