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         /// the minimum space a manual label needs on the screen in pixels
 123         int labelFill(Row const & row) const;
 124
 125         /// FIXME??
 126         int labelEnd(pit_type const pit) const;
 127
 128         /// sets row.end to the pos value *after* which a row should break.
 129         /// for example, the pos after which isNewLine(pos) == true
 130         /// \return true when another row is required (after a newline)
 131         bool breakRow(Row & row, int right_margin) const;
 132
 133         // Expand the alignment of row \param row in paragraph \param par
 134         LyXAlignment getAlign(Paragraph const & par, Row const & row) const;
 135         /** this calculates the specified parameters. needed when setting
 136          * the cursor and when creating a visible row */
 137         void computeRowMetrics(Row & row, int width) const;
 138
 139         /// Set the height of the row (without space above/below paragraph)
 140         void setRowHeight(Row & row) const;
 141         // Compute the space on top of a paragraph
 142         int parTopSpacing(pit_type pit) const;
 143         // Compute the space below a a paragraph
 144         int parBottomSpacing(pit_type pit) const;
 145
 146         // Helper function for the other checkInsetHit method.
 147         InsetList::InsetTable * checkInsetHit(pit_type pit, int x, int y);
 148
 149
 150 // Temporary public:
 151 public:
 152         /// returns the position near the specified x-coordinate of the row.
 153         /// x is an absolute screen coord, it is set to the real beginning
 154         /// of this column. This takes in account horizontal cursor row scrolling.
 155         pos_type getPosNearX(Row const & row, int & x, bool & boundary) const;
 156
 157         /// returns pos in given par at given x coord.
 158         pos_type x2pos(pit_type pit, int row, int x) const;
 159
 160         // FIXME: is there a need for this?
 161         //int pos2x(pit_type pit, pos_type pos) const;
 162
 163         /// returns the row near the specified y-coordinate in a given paragraph
 164         /// (relative to the screen). If assert_in_view is true, it is made sure
 165         /// that the row is on screen completely; this might change the given pit.
 166         Row const & getPitAndRowNearY(int & y, pit_type & pit,
 167                 bool assert_in_view, bool up);
 168
 169         /// returns the paragraph number closest to screen y-coordinate.
 170         /// This method uses the BufferView CoordCache to locate the
 171         /// paragraph. The y-coodinate is allowed to be off-screen and
 172         /// the CoordCache will be automatically updated if needed. This is
 173         /// the reason why we need a non const BufferView.
 174         pit_type getPitNearY(int y);
 175
 176         /// sets cursor recursively descending into nested editable insets
 177         /**
 178         \return the inset pointer if x,y is covering that inset
 179         \param x,y are absolute screen coordinates.
 180         \param assert_in_view if true the cursor will be set on a row
 181            that is completely visible
 182         \param up whether we are going up or down (only used when
 183            assert_in_view is true
 184         \retval inset is null if the cursor is positioned over normal
 185                text in the current Text object. Otherwise it is the inset
 186                that the cursor points to, like for Inset::editXY.
 187         */
 188         /// FIXME: cleanup to use BufferView::getCoveringInset() and
 189         /// setCursorFromCoordinates() instead of checkInsetHit().
 190         Inset * editXY(Cursor & cur, int x, int y,
 191                 bool assert_in_view = false, bool up = true);
 192
 193         /// sets cursor only within this Text.
 194         /// x,y are screen coordinates
 195         void setCursorFromCoordinates(Cursor & cur, int x, int y);
 196
 197         ///
 198         int cursorX(CursorSlice const & cursor, bool boundary) const;
 199         ///
 200         int cursorY(CursorSlice const & cursor, bool boundary) const;
 201
 202         ///
 203         bool cursorHome(Cursor & cur);
 204         ///
 205         bool cursorEnd(Cursor & cur);
 206         ///
 207         void deleteLineForward(Cursor & cur);
 208
 209         /// is this row the last in the text?
 210         bool isLastRow(Row const & row) const;
 211         /// is this row the first in the text?
 212         bool isFirstRow(Row const & row) const;
 213
 214         /// Returns an inset if inset was hit, or 0 if not.
 215         /// \warning This method is not recursive! It will return the
 216         /// outermost inset within this Text.
 217         /// \sa BufferView::getCoveringInset() to get the innermost inset.
 218         Inset * checkInsetHit(int x, int y);
 219
 220         /**
 221          * Returns the left beginning of the text.
 222          * This information cannot be taken from the layout object, because
 223          * in LaTeX the beginning of the text fits in some cases
 224          * (for example sections) exactly the label-width.
 225          */
 226         int leftMargin(int max_width, pit_type pit, pos_type pos) const;
 227         int leftMargin(int max_width, pit_type pit) const;
 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