///
InsetCode lyxCode() const { return CELL_CODE; }
///
- Inset * clone() { return new InsetTableCell(*this); }
+ Inset * clone() const { return new InsetTableCell(*this); }
///
bool getStatus(Cursor & cur, FuncRequest const & cmd,
FuncStatus & status) const;
docstring asString(bool intoInsets = true);
///
docstring xhtml(XHTMLStream &, OutputParams const &) const;
+ ///
+ void addToToc(DocIterator const & di, bool output_active,
+ UpdateType utype) const;
private:
/// unimplemented
InsetTableCell();
// This boolean is supposed to track whether the cell has had its
// width explicitly set. 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
// 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!
LyXAlignment contentAlignment() const { return contentAlign; }
///
virtual bool usePlainLayout() const { return true; }
- ///
+ ///
virtual bool forcePlainLayout(idx_type = 0) const;
- ///
+ ///
virtual bool allowParagraphCustomization(idx_type = 0) const;
+ ///
+ virtual bool forceLocalFontSwitch() const;
/// Is the width forced to some value?
bool hasFixedWidth() const { return isFixedWidth; }
+ /// Can the cell contain several paragraphs?
+ /** FIXME this is wrong for multirows, that are limited to one
+ * paragraph. However, we cannot test for this (see the big
+ * comment above).
+ */
+ bool allowMultiPar() const { return isFixedWidth; }
};
///
UNSET_ALL_LINES,
///
+ TOGGLE_LONGTABULAR,
+ ///
SET_LONGTABULAR,
///
UNSET_LONGTABULAR,
///
SET_SPECIAL_MULTICOLUMN,
///
+ TOGGLE_BOOKTABS,
+ ///
SET_BOOKTABS,
///
UNSET_BOOKTABS,
LYX_VALIGN_MIDDLE = 1,
///
LYX_VALIGN_BOTTOM = 2
-
+
};
///
enum HAlignment {
void deleteRow(row_type row);
///
void copyRow(row_type row);
- ///
+ ///
void insertRow(row_type row, bool copy);
///
void moveColumn(col_type col, ColDirection direction);
bool hasMultiRow(row_type r) const;
///
idx_type setMultiRow(idx_type cell, idx_type number,
- bool const bottom_border);
+ bool const bottom_border,
+ LyXAlignment const halign);
///
void unsetMultiRow(idx_type cell);
///
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);
bool haveLTCaption(CaptionType captiontype = CAPTION_ANY) const;
///
// end longtable support
- ///
+
+ //@{
+ /// 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 multicell.
shared_ptr<InsetTableCell> cellInset(idx_type cell) const;
- ///
shared_ptr<InsetTableCell> cellInset(row_type row,
col_type column) const;
+ //@}
///
void setCellInset(row_type row, col_type column,
shared_ptr<InsetTableCell>) const;
/// 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<InsetTableCell> rather than a
- // vector<CellData>, 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<InsetTableCell> rather than a
+ // vector<CellData>, and an InsetTableCell had a CellData as a member,
+ // or perhaps just had its members as members.
///
class CellData {
public:
///
CellData(CellData const &);
///
- CellData & operator=(CellData);
- ///
- void swap(CellData & rhs);
+ CellData & operator=(CellData const &);
///
idx_type cellno;
///
///
// helper function for Latex
///
- void TeXTopHLine(otexstream &, row_type row, std::string const lang) const;
+ void TeXTopHLine(otexstream &, row_type row, std::string const & lang) const;
///
- void TeXBottomHLine(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;
///
/// 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);
- ///
+ /// 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
/// Update the counters of this inset and of its contents
void updateBuffer(ParIterator const &, UpdateType);
///
- void addToToc(DocIterator const & di, bool output_active) const;
+ void addToToc(DocIterator const & di, bool output_active,
+ UpdateType utype) const;
///
bool completionSupported(Cursor const &) const;
/// 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
///
///
void doDispatch(Cursor & cur, FuncRequest & cmd);
///
+ bool getFeatureStatus(Cursor & cur, std::string const & s,
+ std::string const & argument, FuncStatus & status) const;
+ ///
bool getStatus(Cursor & cur, FuncRequest const & cmd, FuncStatus &) const;
///
Inset * clone() const { return new InsetTabular(*this); }
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,
///
int cellYPos(idx_type cell) const;
///
- void resetPos(Cursor & cur) const;
- ///
bool copySelection(Cursor & cur);
///
bool pasteClipboard(Cursor & cur);
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_;
+ mutable idx_type first_visible_cell_;
/// The vertical offset of the table due to the vertical
/// alignment with respect to the baseline.
mutable int offset_valign_;
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