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), main_text_(false), 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 maxWidth() const { return max_width_; }
 111
 112         ///
 113         int rightMargin(ParagraphMetrics const & pm) const;
 114         int rightMargin(pit_type const pit) const;
 115
 116         ///
 117         void draw(PainterInfo & pi, int x, int y) const;
 118
 119         void drawParagraph(PainterInfo & pi, pit_type pit, int x, int y) const;
 120
 121         /// Returns the height of the row (width member is set to 0).
 122         /// If \c topBottomSpace is true, extra space is added for the
 123         /// top and bottom row.
 124         void setRowHeight(Row & row, pit_type const pit,
 125                           bool topBottomSpace = true) const;
 126
 127 private:
 128         ///
 129         ParagraphMetrics & parMetrics(pit_type, bool redo_paragraph);
 130
 131         /// the minimum space a manual label needs on the screen in pixels
 132         int labelFill(pit_type const pit, 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         void breakRow(Row & row, int right_margin, pit_type const pit) const;
 140
 141         // Expand the alignment of row \param row in paragraph \param par
 142         LyXAlignment getAlign(Paragraph const & par, Row const & row) const;
 143         /** this calculates the specified parameters. needed when setting
 144          * the cursor and when creating a visible row */
 145         void computeRowMetrics(pit_type pit, Row & row, int width) const;
 146
 147         // Helper function for the other checkInsetHit method.
 148         InsetList::InsetTable * checkInsetHit(pit_type pit, int x, int y);
 149
 150
 151 // Temporary public:
 152 public:
 153         /// returns the position near the specified x-coordinate of the row.
 154         /// x is an absolute screen coord, it is set to the real beginning
 155         /// of this column. This takes in account horizontal cursor row scrolling.
 156         pos_type getPosNearX(Row const & row, int & x, bool & boundary) const;
 157
 158         /// returns pos in given par at given x coord.
 159         pos_type x2pos(pit_type pit, int row, int x) const;
 160
 161         // FIXME: is there a need for this?
 162         //int pos2x(pit_type pit, pos_type pos) const;
 163
 164         /// returns the row near the specified y-coordinate in a given paragraph
 165         /// (relative to the screen). If assert_in_view is true, it is made sure
 166         /// that the row is on screen completely; this might change the given pit.
 167         Row const & getPitAndRowNearY(int & y, pit_type & pit,
 168                 bool assert_in_view, bool up);
 169
 170         /// returns the paragraph number closest to screen y-coordinate.
 171         /// This method uses the BufferView CoordCache to locate the
 172         /// paragraph. The y-coodinate is allowed to be off-screen and
 173         /// the CoordCache will be automatically updated if needed. This is
 174         /// the reason why we need a non const BufferView.
 175         pit_type getPitNearY(int y);
 176
 177         /// sets cursor recursively descending into nested editable insets
 178         /**
 179         \return the inset pointer if x,y is covering that inset
 180         \param x,y are absolute screen coordinates.
 181         \param assert_in_view if true the cursor will be set on a row
 182            that is completely visible
 183         \param up whether we are going up or down (only used when
 184            assert_in_view is true
 185         \retval inset is null if the cursor is positioned over normal
 186                text in the current Text object. Otherwise it is the inset
 187                that the cursor points to, like for Inset::editXY.
 188         */
 189         /// FIXME: cleanup to use BufferView::getCoveringInset() and
 190         /// setCursorFromCoordinates() instead of checkInsetHit().
 191         Inset * editXY(Cursor & cur, int x, int y,
 192                 bool assert_in_view = false, bool up = true);
 193
 194         /// sets cursor only within this Text.
 195         /// x,y are screen coordinates
 196         void setCursorFromCoordinates(Cursor & cur, int x, int y);
 197
 198         /// Helper function: find row element that contains pos, and
 199         /// compute x offset.
 200         Row::const_iterator const
 201         findRowElement(Row const & row, pos_type const pos,
 202                    bool const boundary, double & x) const;
 203
 204         ///
 205         int cursorX(CursorSlice const & cursor, bool boundary) const;
 206         ///
 207         int cursorY(CursorSlice const & cursor, bool boundary) const;
 208
 209         ///
 210         bool cursorHome(Cursor & cur);
 211         ///
 212         bool cursorEnd(Cursor & cur);
 213         ///
 214         void deleteLineForward(Cursor & cur);
 215
 216         /// is this row the last in the text?
 217         bool isLastRow(pit_type pit, Row const & row) const;
 218         /// is this row the first in the text?
 219         bool isFirstRow(pit_type pit, Row const & row) const;
 220
 221         /// Returns an inset if inset was hit, or 0 if not.
 222         /// \warning This method is not recursive! It will return the
 223         /// outermost inset within this Text.
 224         /// \sa BufferView::getCoveringInset() to get the innermost inset.
 225         Inset * checkInsetHit(int x, int y);
 226
 227         /**
 228          * Returns the left beginning of the text.
 229          * This information cannot be taken from the layout object, because
 230          * in LaTeX the beginning of the text fits in some cases
 231          * (for example sections) exactly the label-width.
 232          */
 233         int leftMargin(int max_width, pit_type pit, pos_type pos) const;
 234         int leftMargin(int max_width, pit_type pit) const;
 235
 236         /// calculates the position of a completion popup
 237         void completionPosAndDim(Cursor const & cur, int & x, int & y,
 238                 Dimension & dim) const;
 239
 240 private:
 241         friend class BufferView;
 242
 243         /// The BufferView owner.
 244         BufferView * bv_;
 245
 246         /// The text contents (the model).
 247         /// \todo FIXME: this should be const.
 248         Text * text_;
 249
 250         bool main_text_;
 251         /// A map from paragraph index number to paragraph metrics
 252         typedef std::map<pit_type, ParagraphMetrics> ParMetricsCache;
 253         ///
 254         mutable ParMetricsCache par_metrics_;
 255         Dimension dim_;
 256         int max_width_;
 257         mutable Point origin_;
 258
 259 // temporary public:
 260 public:
 261         /// our 'outermost' font.
 262         /// This is handed down from the surrounding
 263         /// inset through the pi/mi parameter (pi.base.font)
 264         /// It is used in applyOuterFont() and setCharFont() for reasons
 265         /// that are not clear... to hand hand the outermost language and
 266         /// also for char style apparently.
 267         Font font_;
 268 };
 269
 270 /// return the default height of a row in pixels, considering font zoom
 271 int defaultRowHeight();
 272
 273 } // namespace lyx
 274
 275 #endif // TEXT_METRICS_H