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