#include "Changes.h"
#include "Dimension.h"
#include "Font.h"
+#include "RowFlags.h"
#include "support/docstring.h"
#include "support/types.h"
// An inset
INSET,
// Some spacing described by its width, not a string
- SPACE
+ SPACE,
+ // Something that should not happen (for error handling)
+ INVALID
};
/**
* by other methods that need to parse the Row contents.
*/
struct Element {
+ //
+ Element() = default;
+ //
Element(Type const t, pos_type p, Font const & f, Change const & ch)
- : type(t), pos(p), endpos(p + 1), inset(0),
- extra(0), font(f), change(ch), final(false) {}
+ : type(t), pos(p), endpos(p + 1), font(f), change(ch) {}
+
// Return the number of separator in the element (only STRING type)
int countSeparators() const;
* adjusted to the actual pixel position.
*/
pos_type x2pos(int &x) const;
+ /** Break the element in two if possible, so that its width is less
+ * than \param w.
+ * \return an element containing the remainder of the text, or
+ * an invalid element if nothing happened.
+ * \param w: the desired maximum width
+ * \param force: if true, the string is cut at any place, otherwise it
+ * respects the row breaking rules of characters.
+ */
+ Element splitAt(int w, bool force);
/** Break the element if possible, so that its width is less
* than \param w. Returns true on success. When \param force
- * is true, the string is cut at any place, other wise it
+ * is true, the string is cut at any place, otherwise it
* respects the row breaking rules of characters.
*/
bool breakAt(int w, bool force);
- // Returns the position on left side of the element.
- pos_type left_pos() const;
- // Returns the position on right side of the element.
- pos_type right_pos() const;
-
//
bool isRTL() const { return font.isVisibleRightToLeft(); }
// This is true for virtual elements.
- // Note that we do not use the type here. The two definitions
- // should be equivalent
- bool isVirtual() const { return pos == endpos; }
+ bool isVirtual() const { return type == VIRTUAL; }
+ // Invalid element, for error handling
+ bool isValid() const { return type !=INVALID; }
+
+ // Returns the position on left side of the element.
+ pos_type left_pos() const { return isRTL() ? endpos : pos; };
+ // Returns the position on right side of the element.
+ pos_type right_pos() const { return isRTL() ? pos : endpos; };
// The kind of row element
- Type type;
+ Type type = INVALID;
// position of the element in the paragraph
- pos_type pos;
+ pos_type pos = 0;
// first position after the element in the paragraph
- pos_type endpos;
+ pos_type endpos = 0;
// The dimension of the chunk (does not contains the
// separator correction)
Dimension dim;
// Non-zero only if element is an inset
- Inset const * inset;
+ Inset const * inset = nullptr;
// Only non-null for justified rows
- double extra;
+ double extra = 0;
// Non-empty if element is a string or is virtual
docstring str;
//
Change change;
// is it possible to add contents to this element?
- bool final;
+ bool final = false;
+ // properties with respect to row breaking (made of RowFlag enums)
+ int row_flags = Inline;
friend std::ostream & operator<<(std::ostream & os, Element const & row);
};
///
- Row();
+ Row() {}
+
/**
* Helper function: set variable \c var to value \c val, and mark
* row as changed is the values were different. This is intended
///
int descent() const { return dim_.des; }
+ ///
+ Dimension const & contents_dim() const { return contents_dim_; }
+ ///
+ Dimension & contents_dim() { return contents_dim_; }
+
/// The offset of the left-most cursor position on the row
int left_x() const;
/// The offset of the right-most cursor position on the row
Font const & f, Change const & ch);
///
void add(pos_type pos, char_type const c,
- Font const & f, Change const & ch);
+ Font const & f, Change const & ch, bool can_break);
///
void addVirtual(pos_type pos, docstring const & s,
Font const & f, Change const & ch);
Element & back() { return elements_.back(); }
///
Element const & back() const { return elements_.back(); }
- /// remove last element
+ /// add element at the end and update width
+ void push_back(Element const &);
+ /// remove last element and update width
void pop_back();
- /// remove all row elements
- void clear() { elements_.clear(); }
/**
* if row width is too large, remove all elements after last
* separator and update endpos if necessary. If all that
* remains is a large word, cut it to \param width.
- * \param body_pos minimum amount of text to keep.
* \param width maximum width of the row.
* \param available width on next row.
* \return true if the row has been shortened.
*/
- bool shortenIfNeeded(pos_type const body_pos, int const width, int const next_width);
+ bool shortenIfNeeded(int const width, int const next_width);
/**
* If last element of the row is a string, compute its width
friend std::ostream & operator<<(std::ostream & os, Row const & row);
/// additional width for separators in justified rows (i.e. space)
- double separator;
+ double separator = 0;
/// width of hfills in the label
- double label_hfill;
+ double label_hfill = 0;
/// the left margin position of the row
- int left_margin;
+ int left_margin = 0;
/// the right margin of the row
- int right_margin;
+ int right_margin = 0;
///
- mutable pos_type sel_beg;
+ mutable pos_type sel_beg = -1;
///
- mutable pos_type sel_end;
+ mutable pos_type sel_end = -1;
///
- mutable bool begin_margin_sel;
+ mutable bool begin_margin_sel = false;
///
- mutable bool end_margin_sel;
+ mutable bool end_margin_sel = false;
private:
/// Decides whether the margin is selected.
Elements elements_;
/// has the Row appearance changed since last drawing?
- mutable bool changed_;
+ mutable bool changed_ = true;
/// Index of the paragraph that contains this row
- pit_type pit_;
+ pit_type pit_ = 0;
/// first pos covered by this row
- pos_type pos_;
+ pos_type pos_ = 0;
/// one behind last pos covered by this row
- pos_type end_;
+ pos_type end_ = 0;
// Is there a boundary at the end of the row (display inset...)
- bool right_boundary_;
+ bool right_boundary_ = false;
// Shall the row be flushed when it is supposed to be justified?
- bool flushed_;
+ bool flushed_ = false;
/// Row dimension.
Dimension dim_;
+ /// Row contents dimension. Does not contain the space above/below row.
+ Dimension contents_dim_;
/// true when this row lives in a right-to-left paragraph
- bool rtl_;
+ bool rtl_ = false;
/// true when a changebar should be drawn in the margin
- bool changebar_;
+ bool changebar_ = false;
};
+/**
+ * Each paragraph is broken up into a number of rows on the screen.
+ * This is a list of such on-screen rows, ordered from the top row
+ * downwards.
+ */
+typedef std::vector<Row> RowList;
+
} // namespace lyx
#endif