X-Git-Url: https://git.lyx.org/gitweb/?a=blobdiff_plain;f=src%2Finsets%2FInsetTabular.h;h=5602984b3339be79d73199034f71ebdb36436489;hb=8124e6c02ea1fd6779bb6c47ffe2bca2c8bd2d97;hp=2f0ff3b760874bc30a339746a29c5d12f029cde0;hpb=ecef54500d4d77baf4fa47eac2253679875ac08c;p=lyx.git diff --git a/src/insets/InsetTabular.h b/src/insets/InsetTabular.h index 2f0ff3b760..5602984b33 100644 --- a/src/insets/InsetTabular.h +++ b/src/insets/InsetTabular.h @@ -24,16 +24,19 @@ #ifndef INSET_TABULAR_H #define INSET_TABULAR_H -#include "Inset.h" +#include "BufferParams.h" +#include "Changes.h" #include "InsetText.h" -#include "Length.h" -#include "support/shared_ptr.h" +#include "support/Length.h" +#include "support/types.h" #include #include +#include #include + namespace lyx { class Buffer; @@ -44,8 +47,7 @@ class CursorSlice; class FuncStatus; class Lexer; class OutputParams; -class Paragraph; -class XHTMLStream; +class XMLStream; /// @@ -53,34 +55,59 @@ class InsetTableCell : public InsetText { public: /// - InsetTableCell(Buffer * buf); + explicit InsetTableCell(Buffer * buf); + /// We need this since generation of the default is deprecated + /// (since we declare the assignment constuctor below). + InsetTableCell(InsetTableCell const & in) = default; /// - InsetCode lyxCode() const { return CELL_CODE; } + InsetCode lyxCode() const override { return CELL_CODE; } /// - Inset * clone() { return new InsetTableCell(*this); } + Inset * clone() const override { return new InsetTableCell(*this); } /// bool getStatus(Cursor & cur, FuncRequest const & cmd, - FuncStatus & status) const; + FuncStatus & status) const override; /// void toggleFixedWidth(bool fw) { isFixedWidth = fw; } /// - void setContentAlignment(LyXAlignment al) {contentAlign = al; } + void toggleVarWidth(bool vw) { isVarwidth = vw; } + /// + void toggleMultiCol(bool m) { isMultiColumn = m; } + /// + void toggleMultiRow(bool m) { isMultiRow = m; } + /// + void setContentAlignment(LyXAlignment al) { contentAlign = al; } /// writes the contents of the cell as a string, optionally /// descending into insets docstring asString(bool intoInsets = true); /// - docstring xhtml(XHTMLStream &, OutputParams const &) const; + docstring xhtml(XMLStream &, OutputParams const &) const override; + /// + void docbook(XMLStream &, OutputParams const &) const override; + /// + void addToToc(DocIterator const & di, bool output_active, + UpdateType utype, TocBackend & backend) const override; + /// + void metrics(MetricsInfo &, Dimension &) const override; + /// Needs to be same as InsetTabular + bool inheritFont() const override { return false; } + /// Can the cell contain several paragraphs? + bool allowMultiPar() const override { return !isMultiRow && (!isMultiColumn || isFixedWidth); } + /// + bool canPaintChange(BufferView const &) const override { return false; } + /// This assures we never output \maketitle in table cells + bool isInTitle() const override { return true; } private: - /// unimplemented - InsetTableCell(); - /// unimplemented - void operator=(InsetTableCell const &); + /// + InsetTableCell() = delete; + /// + void operator=(InsetTableCell const &) = delete; // FIXME - // This boolean is supposed to track whether the cell has had its - // width explicitly set. We need to know this to determine whether + // These booleans are supposed to track whether the cell has had its + // width explicitly set and whether it is part of a multicolumn, respectively. + // We need to know this to determine whether // layout changes and paragraph customization are allowed---that is, - // we need it in forcePlainLayout() and allowParagraphCustomization(). - // Unfortunately, that information is not readily available in + // we need it in forcePlainLayout() and allowParagraphCustomization(). + // Unfortunately, that information is not readily available in // InsetTableCell. In the case of multicolumn cells, it is present // in CellData, and so would be available here if CellData were to // become a member of InsetTableCell. But in the other case, it isn't @@ -90,31 +117,37 @@ private: // but the other solutions are no better. These are: // (i) Keep a pointer in InsetTableCell to the table; // (ii) Find the table by iterating over the Buffer's insets. - // Solution (i) raises the problem of updating the pointer when an + // Solution (i) raises the problem of updating the pointer when an // InsetTableCell is copied, and we'd therefore need a copy constructor - // in InsetTabular and then in Tabular, which seems messy, given how - // complicated those classes are. Solution (ii) involves a lot of + // in InsetTabular and then in Tabular, which seems messy, given how + // complicated those classes are. Solution (ii) involves a lot of // iterating, since this information is needed quite often, and so may // be quite slow. // So, well, if someone can do better, please do! - // --rgh + // --rkh /// bool isFixedWidth; + /// + bool isVarwidth; + /// + bool isMultiColumn; + /// + bool isMultiRow; // FIXME: Here the thoughts from the comment above also apply. /// LyXAlignment contentAlign; - /// should paragraph indendation be omitted in any case? - bool neverIndent() const { return true; } + /// should paragraph indentation be omitted in any case? + bool neverIndent() const override { return true; } /// - LyXAlignment contentAlignment() const { return contentAlign; } + LyXAlignment contentAlignment() const override { return contentAlign; } /// - virtual bool usePlainLayout() const { return true; } - /// - virtual bool forcePlainLayout(idx_type = 0) const; - /// - virtual bool allowParagraphCustomization(idx_type = 0) const; + bool usePlainLayout() const override { return true; } + /// + bool allowParagraphCustomization(idx_type = 0) const override; + /// + bool forceLocalFontSwitch() const override; /// Is the width forced to some value? - bool hasFixedWidth() const { return isFixedWidth; } + bool hasFixedWidth() const override { return isFixedWidth; } }; @@ -162,6 +195,22 @@ public: ///FIXME: remove TOGGLE_LINE_RIGHT, /// + SET_LTRIM_TOP, + /// + SET_RTRIM_TOP, + /// + SET_LTRIM_BOTTOM, + /// + SET_RTRIM_BOTTOM, + /// + TOGGLE_LTRIM_TOP, + /// + TOGGLE_RTRIM_TOP, + /// + TOGGLE_LTRIM_BOTTOM, + /// + TOGGLE_RTRIM_BOTTOM, + /// ALIGN_LEFT, /// ALIGN_RIGHT, @@ -206,8 +255,12 @@ public: /// SET_ALL_LINES, /// + RESET_FORMAL_DEFAULT, + /// UNSET_ALL_LINES, /// + TOGGLE_LONGTABULAR, + /// SET_LONGTABULAR, /// UNSET_LONGTABULAR, @@ -216,6 +269,8 @@ public: /// SET_MPWIDTH, /// + TOGGLE_VARWIDTH_COLUMN, + /// SET_ROTATE_TABULAR, /// UNSET_ROTATE_TABULAR, @@ -255,6 +310,8 @@ public: /// SET_SPECIAL_MULTICOLUMN, /// + TOGGLE_BOOKTABS, + /// SET_BOOKTABS, /// UNSET_BOOKTABS, @@ -283,6 +340,14 @@ public: /// SET_TABULAR_WIDTH, /// + SET_INNER_LINES, + /// + TOGGLE_INNER_LINES, + /// + TOGGLE_BORDER_LINES, + /// + TOGGLE_ALL_LINES, + /// LAST_ACTION }; /// @@ -307,7 +372,7 @@ public: LYX_VALIGN_MIDDLE = 1, /// LYX_VALIGN_BOTTOM = 2 - + }; /// enum HAlignment { @@ -325,7 +390,9 @@ public: /// BOX_PARBOX = 1, /// - BOX_MINIPAGE = 2 + BOX_MINIPAGE = 2, + /// + BOX_VARWIDTH = 3 }; enum CaptionType { @@ -367,12 +434,6 @@ public: bool empty; }; - /// type for row numbers - typedef size_t row_type; - /// type for column numbers - typedef size_t col_type; - /// type for cell indices - typedef size_t idx_type; /// index indicating an invalid position static const idx_type npos = static_cast(-1); @@ -384,9 +445,29 @@ public: /// Returns true if there is a topline, returns false if not bool bottomLine(idx_type cell) const; /// Returns true if there is a topline, returns false if not - bool leftLine(idx_type cell) const; + /// If \p ignore_bt is true, we return the state as if booktabs was + /// not used + bool leftLine(idx_type cell, bool const ignore_bt = false) const; /// Returns true if there is a topline, returns false if not - bool rightLine(idx_type cell) const; + /// If \p ignore_bt is true, we return the state as if booktabs was + /// not used + bool rightLine(idx_type cell, bool const ignore_bt = false) const; + /// Returns true if there is an outside border around the selection + bool outsideBorders(row_type sel_row_start, row_type sel_row_end, + col_type sel_col_start, col_type sel_col_end) const; + /// Returns true if there are inside lines in the selection + bool innerBorders(row_type sel_row_start, row_type sel_row_end, + col_type sel_col_start, col_type sel_col_end) const; + /// Sets the grid lines in the selection + /// if \p setLinesInnerOnly is true, outside borders are excluded + /// if \p setLines is true the lines are set otherwise they are unset + void setLines(row_type const sel_row_start, row_type const sel_row_end, + col_type const sel_col_start, col_type const sel_col_end, + bool setLinesInnerOnly, bool setLines); + /// Returns whether the top line is trimmed left and/or right + std::pair topLineTrim(idx_type const cell) const; + /// Returns whether the bottom line is trimmed left and/or right + std::pair bottomLineTrim(idx_type const cell) const; /// return space occupied by the second horizontal line and /// interline space above row \p row in pixels @@ -420,6 +501,18 @@ public: /// void setBottomLine(idx_type cell, bool line); /// + void setTopLineLTrim(idx_type cell, bool val); + /// + void setBottomLineLTrim(idx_type cell, bool val); + /// + void setTopLineRTrim(idx_type cell, bool val); + /// + void setBottomLineRTrim(idx_type cell, bool val); + /// + void setTopLineTrim(idx_type cell, std::pair); + /// + void setBottomLineTrim(idx_type cell, std::pair); + /// void setLeftLine(idx_type cell, bool line); /// void setRightLine(idx_type cell, bool line); @@ -446,6 +539,8 @@ public: /// bool setMColumnPWidth(Cursor &, idx_type, Length const &); /// + bool toggleVarwidth(idx_type, bool const); + /// bool setMROffset(Cursor &, idx_type, Length const &); /// void setAlignSpecial(idx_type cell, docstring const & special, @@ -456,6 +551,9 @@ public: /// VAlignment getVAlignment(idx_type cell, bool onlycolumn = false) const; + /// The vertical offset of the table due to the vertical + /// alignment with respect to the baseline. + int offsetVAlignment() const; /// Length const getPWidth(idx_type cell) const; /// @@ -467,27 +565,33 @@ public: /// void appendRow(row_type row); /// - void deleteRow(row_type row); + void deleteRow(row_type row, bool const force = false); /// void copyRow(row_type row); - /// + /// void insertRow(row_type row, bool copy); /// - void moveColumn(col_type col, ColDirection direction); + void moveColumn(col_type col_start, col_type col_end, + ColDirection direction); /// - void moveRow(row_type row, RowDirection direction); + void moveRow(row_type row_start, row_type row_end, + RowDirection direction); /// void appendColumn(col_type column); /// - void deleteColumn(col_type column); + void deleteColumn(col_type column, bool const force = false); /// void copyColumn(col_type column); /// void insertColumn(col_type column, bool copy); /// - idx_type getFirstCellInRow(row_type row) const; + idx_type getFirstCellInRow(row_type row, bool const ct = false) const; + /// + idx_type getLastCellInRow(row_type row, bool const ct = false) const; /// - idx_type getLastCellInRow(row_type row) const; + idx_type getFirstRow(bool const ct = false) const; + /// + idx_type getLastRow(bool const ct = false) const; /// idx_type numberOfCellsInRow(row_type row) const; /// @@ -496,10 +600,10 @@ public: void read(Lexer &); /// void latex(otexstream &, OutputParams const &) const; + /// serialise the table in DocBook, according to buffer parameters + void docbook(XMLStream &, OutputParams const &) const; /// - int docbook(odocstream & os, OutputParams const &) const; - /// - docstring xhtml(XHTMLStream & os, OutputParams const &) const; + docstring xhtml(XMLStream &, OutputParams const &) const; /// void plaintext(odocstringstream &, OutputParams const & runparams, int const depth, @@ -509,7 +613,11 @@ public: /// bool hasMultiColumn(col_type cell) const; /// - idx_type setMultiColumn(idx_type cell, idx_type number, + bool hasVarwidthColumn() const; + /// + bool isVTypeColumn(col_type cell) const; + /// + idx_type setMultiColumn(Cursor & cur, idx_type cell, idx_type number, bool const right_border); /// void unsetMultiColumn(idx_type cell); @@ -522,8 +630,9 @@ public: /// bool hasMultiRow(row_type r) const; /// - idx_type setMultiRow(idx_type cell, idx_type number, - bool const bottom_border); + idx_type setMultiRow(Cursor & cur, idx_type cell, idx_type number, + bool const bottom_border, + LyXAlignment const halign); /// void unsetMultiRow(idx_type cell); /// @@ -542,7 +651,9 @@ public: idx_type cellAbove(idx_type cell) const; /// idx_type cellBelow(idx_type cell) const; - /// + /// \return the index of the VISIBLE cell at row, column + /// this will be the same as the cell in the previous row, + /// e.g., if the cell is part of a multirow idx_type cellIndex(row_type row, col_type column) const; /// void setUsebox(idx_type cell, BoxType); @@ -567,7 +678,7 @@ public: /// bool getLTNewPage(row_type row) const; /// - idx_type setLTCaption(row_type row, bool what); + idx_type setLTCaption(Cursor & cur, row_type row, bool what); /// bool ltCaption(row_type row) const; /// @@ -582,34 +693,42 @@ public: bool haveLTCaption(CaptionType captiontype = CAPTION_ANY) const; /// // end longtable support - /// - shared_ptr cellInset(idx_type cell) const; - /// - shared_ptr cellInset(row_type row, - col_type column) const; + + //@{ + /// there is a subtle difference between these two methods. + /// cellInset(r,c); + /// and + /// cellInset(cellIndex(r,c)); + /// can return different things. this is because cellIndex(r,c) + /// returns the VISIBLE cell at r,c, which may be the same as the + /// cell at the previous row or column, if we're dealing with some + /// multirow or multicolumn. + std::shared_ptr cellInset(idx_type cell); + std::shared_ptr cellInset(row_type row, col_type column); + InsetTableCell const * cellInset(idx_type cell) const; + //@} /// void setCellInset(row_type row, col_type column, - shared_ptr) const; + std::shared_ptr); /// Search for \param inset in the tabular, with the /// void validate(LaTeXFeatures &) const; -//private: - // FIXME Now that cells have an InsetTableCell as their insets, rather - // than an InsetText, it'd be possible to reverse the relationship here, - // so that cell_vector was a vector rather than a - // vector, and an InsetTableCell had a CellData as a member, - // or perhaps just had its members as members. + + //private: + // FIXME Now that cells have an InsetTableCell as their insets, rather + // than an InsetText, it'd be possible to reverse the relationship here, + // so that cell_vector was a vector rather than a + // vector, and an InsetTableCell had a CellData as a member, + // or perhaps just had its members as members. /// class CellData { public: /// - CellData(Buffer *); + explicit CellData(Buffer *); /// CellData(CellData const &); /// - CellData & operator=(CellData); - /// - void swap(CellData & rhs); + CellData & operator=(CellData const &); /// idx_type cellno; /// @@ -639,6 +758,14 @@ public: /// bool right_line; /// + bool top_line_rtrimmed; + /// + bool top_line_ltrimmed; + /// + bool bottom_line_rtrimmed; + /// + bool bottom_line_ltrimmed; + /// BoxType usebox; /// int rotate; @@ -647,9 +774,12 @@ public: /// Length p_width; // this is only set for multicolumn!!! /// - shared_ptr inset; + std::shared_ptr inset; }; - CellData & cellInfo(idx_type cell) const; + /// + CellData const & cellInfo(idx_type cell) const; + /// + CellData & cellInfo(idx_type cell); /// typedef std::vector cell_vector; /// @@ -689,6 +819,8 @@ public: bool newpage; /// caption bool caption; + /// + Change change; }; /// typedef std::vector row_vector; @@ -710,10 +842,32 @@ public: docstring align_special; /// docstring decimal_point; + /// + bool varwidth; + /// + Change change; }; /// typedef std::vector column_vector; +private: + // Determines the style of borders, per row. + class XmlRowWiseBorders { + public: + // Whether to draw double bottom line. + bool completeBorder = true; + + // Whether to draw booktabs' thicker lines. + bool completeBorderAbove = true; + bool completeBorderBelow = true; + + // Size of the borders. + double borderBottomWidth = 1.0; + double borderBottomWidthComplete = 3.0; + double borderTopWidth = 1.0; + }; + +public: /// idx_type numberofcells; /// @@ -725,7 +879,7 @@ public: /// column_vector column_info; /// - mutable cell_vvector cell_info; + cell_vvector cell_info; /// Length tabular_width; /// @@ -757,57 +911,90 @@ public: /// bool setFixedWidth(row_type r, col_type c); /// return true of update is needed - bool updateColumnWidths(); + bool updateColumnWidths(MetricsInfo & mi); /// idx_type columnSpan(idx_type cell) const; /// idx_type rowSpan(idx_type cell) const; /// - BoxType useParbox(idx_type cell) const; - /// - // helper function for Latex + BoxType useBox(idx_type cell) const; /// - void TeXTopHLine(otexstream &, row_type row, std::string const lang) const; - /// - void TeXBottomHLine(otexstream &, row_type row, std::string const lang) const; - /// - void TeXCellPreamble(otexstream &, idx_type cell, bool & ismulticol, bool & ismultirow) const; - /// - void TeXCellPostamble(otexstream &, idx_type cell, bool ismulticol, bool ismultirow) const; - /// - void TeXLongtableHeaderFooter(otexstream &, OutputParams const &) const; + bool hasNewlines(idx_type cell) const; /// bool isValidRow(row_type const row) const; /// void TeXRow(otexstream &, row_type const row, - OutputParams const &) const; + OutputParams const &, std::list, std::list) const; + + /// change associated Buffer + void setBuffer(Buffer & buffer); + /// retrieve associated Buffer + Buffer const & buffer() const { return *buffer_; } + /// retrieve associated Buffer + Buffer & buffer() { return *buffer_; } + +private: + Buffer * buffer_; + + /// + // helper function for DocBook + /// + /// Determines whether the tabular item should be generated as DocBook or XHTML. + enum class XmlOutputFormat : bool { + XHTML = true, + DOCBOOK = false + }; + + /// Transforms the vertical alignment of the given cell as prebaked CSS (for HTML tables in HTML output). + std::string getHAlignAsXmlAttribute(idx_type cell) const; + /// Transforms the vertical alignment of the given cell as a prebaked XML attribute (for CALS or HTML tables in DocBook). + std::string getHAlignAsCssAttribute(idx_type cell) const; + /// Transforms the vertical alignment of the given cell as prebaked CSS (for HTML tables in HTML output). + std::string getVAlignAsCssAttribute(idx_type cell) const; + /// Transforms the vertical alignment of the given cell as a prebaked XML attribute (for CALS or HTML tables in DocBook). + std::string getVAlignAsXmlAttribute(idx_type cell) const; + + /// Helpers for XML tables (XHTML or DocBook). + docstring xmlRow(XMLStream & xs, row_type row, OutputParams const &, + bool header, XmlOutputFormat output_format, + BufferParams::TableOutput docbook_table_output = BufferParams::TableOutput::HTMLTable) const; + void xmlHeader(XMLStream & xs, OutputParams const &, XmlOutputFormat output_format) const; + void xmlFooter(XMLStream & xs, OutputParams const &, XmlOutputFormat output_format) const; + void xmlBody(XMLStream & xs, OutputParams const &, XmlOutputFormat output_format) const; + XmlRowWiseBorders computeXmlBorders(row_type row) const; + std::vector computeCssStylePerCell(row_type row, col_type col, idx_type cell) const; + /// // helper functions for plain text /// bool plaintextTopHLine(odocstringstream &, row_type row, - std::vector const &) const; + std::vector const &) const; /// bool plaintextBottomHLine(odocstringstream &, row_type row, - std::vector const &) const; + std::vector const &) const; /// void plaintextPrintCell(odocstringstream &, - OutputParams const &, - idx_type cell, row_type row, col_type column, - std::vector const &, - bool onlydata, size_t max_length) const; - /// auxiliary function for docbook - int docbookRow(odocstream & os, row_type, OutputParams const &) const; - /// - docstring xhtmlRow(XHTMLStream & xs, row_type, OutputParams const &, - bool header = false) const; + OutputParams const &, + idx_type cell, row_type row, col_type column, + std::vector const &, + bool onlydata, size_t max_length) const; - /// change associated Buffer - void setBuffer(Buffer & buffer); - /// retrieve associated Buffer - Buffer & buffer() const { return *buffer_; } - -private: - Buffer * buffer_; + /// + // helper function for LaTeX + /// + void TeXTopHLine(otexstream &, row_type row, std::list, + std::list) const; + /// + void TeXBottomHLine(otexstream &, row_type row, std::list, + std::list) const; + /// + void TeXCellPreamble(otexstream &, idx_type cell, bool & ismulticol, bool & ismultirow, + bool const bidi) const; + /// + void TeXCellPostamble(otexstream &, idx_type cell, bool ismulticol, bool ismultirow) const; + /// + void TeXLongtableHeaderFooter(otexstream &, OutputParams const &, std::list, + std::list) const; }; // Tabular @@ -821,139 +1008,154 @@ public: /// ~InsetTabular(); /// - void setBuffer(Buffer & buffer); + void setBuffer(Buffer & buffer) override; /// static void string2params(std::string const &, InsetTabular &); /// static std::string params2string(InsetTabular const &); /// - void read(Lexer &); + void read(Lexer &) override; /// - void write(std::ostream &) const; + void write(std::ostream &) const override; /// - void metrics(MetricsInfo &, Dimension &) const; + void metrics(MetricsInfo &, Dimension &) const override; /// - void draw(PainterInfo & pi, int x, int y) const; + void draw(PainterInfo & pi, int x, int y) const override; /// - void drawSelection(PainterInfo & pi, int x, int y) const; + void drawSelection(PainterInfo & pi, int x, int y) const override; /// - void drawBackground(PainterInfo & pi, int x, int y) const; + void drawBackground(PainterInfo & pi, int x, int y) const override; /// - bool editable() const { return true; } + bool editable() const override { return true; } /// - bool hasSettings() const { return true; } + bool hasSettings() const override { return true; } /// - bool insetAllowed(InsetCode code) const; + bool insetAllowed(InsetCode code) const override; /// - bool allowSpellCheck() const { return true; } + bool allowSpellCheck() const override { return true; } /// - bool canTrackChanges() const { return true; } - /** returns false if, when outputing LaTeX, font changes should - be closed before generating this inset. This is needed for - insets that may contain several paragraphs */ - bool inheritFont() const { return false; } + bool canTrackChanges() const override { return true; } /// - DisplayType display() const; + bool canPaintChange(BufferView const &) const override { return true; } /// - void latex(otexstream &, OutputParams const &) const; + bool inheritFont() const override { return false; } + /// + bool allowMultiPar() const override; + /// + bool allowsCaptionVariation(std::string const &) const override; + // + bool isTable() const override { return true; } + /// + int rowFlags() const override; + /// + void latex(otexstream &, OutputParams const &) const override; /// int plaintext(odocstringstream & ods, OutputParams const & op, - size_t max_length = INT_MAX) const; + size_t max_length = INT_MAX) const override; /// - int docbook(odocstream &, OutputParams const &) const; + void docbook(XMLStream &, OutputParams const &) const override; /// - docstring xhtml(XHTMLStream &, OutputParams const &) const; + docstring xhtml(XMLStream &, OutputParams const &) const override; /// - void validate(LaTeXFeatures & features) const; + void validate(LaTeXFeatures & features) const override; /// - InsetCode lyxCode() const { return TABULAR_CODE; } + InsetCode lyxCode() const override { return TABULAR_CODE; } /// - std::string contextMenu(BufferView const &, int, int) const; + std::string contextMenu(BufferView const &, int, int) const override; /// - std::string contextMenuName() const; + std::string contextMenuName() const override; /// get offset of this cursor slice relative to our upper left corner void cursorPos(BufferView const & bv, CursorSlice const & sl, - bool boundary, int & x, int & y) const; - /// - bool tabularFeatures(Cursor & cur, std::string const & what); - /// + bool boundary, int & x, int & y) const override; + /// Executes a space-separated sequence of tabular-features requests + void tabularFeatures(Cursor & cur, std::string const & what); + /// Change a single tabular feature; does not handle undo. void tabularFeatures(Cursor & cur, Tabular::Feature feature, std::string const & val = std::string()); /// number of cells - size_t nargs() const { return tabular.numberofcells; } + size_t nargs() const override { return tabular.numberofcells; } /// - shared_ptr cell(idx_type) const; + std::shared_ptr cell(idx_type) const; /// - shared_ptr cell(idx_type); + std::shared_ptr cell(idx_type); /// - Text * getText(int) const; + Text * getText(int) const override; + /// does the inset contain changes ? + bool isChanged() const override; /// set the change for the entire inset - void setChange(Change const & change); + void setChange(Change const & change) override; /// accept the changes within the inset - void acceptChanges(); + void acceptChanges() override; /// reject the changes within the inset - void rejectChanges(); + void rejectChanges() override; // this should return true if we have a "normal" cell, otherwise false. // "normal" means without width set! /// should all paragraphs be output with "Standard" layout? - virtual bool allowParagraphCustomization(idx_type cell = 0) const; - /// - virtual bool forcePlainLayout(idx_type cell = 0) const; + bool allowParagraphCustomization(idx_type cell = 0) const override; /// void addPreview(DocIterator const & inset_pos, - graphics::PreviewLoader &) const; + graphics::PreviewLoader &) const override; /// lock cell with given index - void edit(Cursor & cur, bool front, EntryDirection entry_from); + void edit(Cursor & cur, bool front, EntryDirection entry_from) override; /// get table row from x coordinate int rowFromY(Cursor & cur, int y) const; /// get table column from y coordinate int columnFromX(Cursor & cur, int x) const; /// - Inset * editXY(Cursor & cur, int x, int y); + Inset * editXY(Cursor & cur, int x, int y) override; /// can we go further down on mouse click? - bool descendable(BufferView const &) const { return true; } + bool descendable(BufferView const &) const override { return true; } /// Update the counters of this inset and of its contents - void updateBuffer(ParIterator const &, UpdateType); + void updateBuffer(ParIterator const &, UpdateType, bool const deleted = false) override; /// - void addToToc(DocIterator const &) const; + void addToToc(DocIterator const & di, bool output_active, + UpdateType utype, TocBackend & backend) const override; /// - bool completionSupported(Cursor const &) const; + bool completionSupported(Cursor const &) const override; /// - bool inlineCompletionSupported(Cursor const & cur) const; + bool inlineCompletionSupported(Cursor const & cur) const override; /// - bool automaticInlineCompletion() const; + bool automaticInlineCompletion() const override; /// - bool automaticPopupCompletion() const; + bool automaticPopupCompletion() const override; /// - bool showCompletionCursor() const; + bool showCompletionCursor() const override; /// - CompletionList const * createCompletionList(Cursor const & cur) const; + CompletionList const * createCompletionList(Cursor const & cur) const override; /// - docstring completionPrefix(Cursor const & cur) const; + docstring completionPrefix(Cursor const & cur) const override; /// - bool insertCompletion(Cursor & cur, docstring const & s, bool finished); + bool insertCompletion(Cursor & cur, docstring const & s, bool /*finished*/) override; /// - void completionPosAndDim(Cursor const &, int & x, int & y, Dimension & dim) const; + void completionPosAndDim(Cursor const &, int & x, int & y, Dimension & dim) const override; /// - virtual bool usePlainLayout() const { return true; } + bool usePlainLayout() const override { return true; } + /// + docstring layoutName() const override { return from_ascii("Tabular"); } + /// - InsetTabular * asInsetTabular() { return this; } + InsetTabular * asInsetTabular() override { return this; } /// - InsetTabular const * asInsetTabular() const { return this; } + InsetTabular const * asInsetTabular() const override { return this; } /// bool isRightToLeft(Cursor & cur) const; /// writes the cells between stidx and enidx as a string, optionally /// descending into the insets docstring asString(idx_type stidx, idx_type enidx, bool intoInsets = true); - + /// + ParagraphList asParList(idx_type stidx, idx_type enidx); + /// + bool confirmDeletion() const override { return true; } /// Returns whether the cell in the specified row and column is selected. bool isCellSelected(Cursor & cur, row_type row, col_type col) const; + /// + void setLayoutForHiddenCells(DocumentClass const & dc); // // Public structures and variables /// @@ -963,11 +1165,21 @@ private: /// InsetTabular(InsetTabular const &); /// - void doDispatch(Cursor & cur, FuncRequest & cmd); + void doDispatch(Cursor & cur, FuncRequest & cmd) override; + /// + bool getFeatureStatus(Cursor & cur, std::string const & s, + std::string const & argument, FuncStatus & status) const; + /// + bool getStatus(Cursor & cur, FuncRequest const & cmd, FuncStatus &) const override; /// - bool getStatus(Cursor & cur, FuncRequest const & cmd, FuncStatus &) const; + Inset * clone() const override { return new InsetTabular(*this); } + + /// + bool hitSelectRow(BufferView const & bv, int x) const; /// - Inset * clone() const { return new InsetTabular(*this); } + bool hitSelectColumn(BufferView const & bv, int y) const; + /// Returns true if coordinates are on row/column selection zones + bool clickable(BufferView const &, int x, int y) const override; /// void drawCellLines(PainterInfo &, int x, int y, row_type row, @@ -976,7 +1188,7 @@ private: void setCursorFromCoordinates(Cursor & cur, int x, int y) const; /// - void moveNextCell(Cursor & cur, + void moveNextCell(Cursor & cur, EntryDirection entry_from = ENTRY_DIRECTION_IGNORE); /// void movePrevCell(Cursor & cur, @@ -986,8 +1198,6 @@ private: /// int cellYPos(idx_type cell) const; /// - void resetPos(Cursor & cur) const; - /// bool copySelection(Cursor & cur); /// bool pasteClipboard(Cursor & cur); @@ -1004,17 +1214,11 @@ private: /// return the cell nearest to x, y idx_type getNearestCell(BufferView &, int x, int y) const; - /// test the rotation state of the give cell range. + /// test the rotation state of the given cell range. bool oneCellHasRotationState(bool rotated, row_type row_start, row_type row_end, col_type col_start, col_type col_end) const; - /// - mutable idx_type first_visible_cell; - /// - mutable int scx_; - /// The vertical offset of the table due to the vertical - /// alignment with respect to the baseline. - mutable int offset_valign_; + /// true when selecting rows with the mouse bool rowselect_; /// true when selecting columns with the mouse @@ -1024,7 +1228,7 @@ private: std::string const featureAsString(Tabular::Feature feature); /// Split cell on decimal symbol -InsetTableCell splitCell(InsetTableCell & head, docstring const decimal_sym, bool & hassep); +InsetTableCell splitCell(InsetTableCell & head, docstring const & decimal_sym, bool & hassep); } // namespace lyx