X-Git-Url: https://git.lyx.org/gitweb/?a=blobdiff_plain;f=src%2Finsets%2FInsetTabular.cpp;h=f7f0d2419b8ff20070f7f3bfcf2940ab0b17f144;hb=2c39859575babfc503b1feb3bd64b3c9886f5930;hp=f8d868608a94d29638e54d3fea67323050abef3f;hpb=1954458817f80ac15d670a9732469066994ef08a;p=lyx.git diff --git a/src/insets/InsetTabular.cpp b/src/insets/InsetTabular.cpp index f8d868608a..f7f0d2419b 100644 --- a/src/insets/InsetTabular.cpp +++ b/src/insets/InsetTabular.cpp @@ -13,6 +13,7 @@ * \author Jürgen Vigna * \author Uwe Stöhr * \author Edwin Leuven + * \author Scott Kostyshak * * Full author contact details are available in file CREDITS. */ @@ -32,6 +33,7 @@ #include "DispatchResult.h" #include "FuncRequest.h" #include "FuncStatus.h" +#include "InsetList.h" #include "Language.h" #include "LaTeXFeatures.h" #include "Lexer.h" @@ -62,10 +64,10 @@ #include -#include +#include #include #include -#include +#include using namespace std; using namespace lyx::support; @@ -114,6 +116,10 @@ TabularFeature tabularFeature[] = { Tabular::DELETE_COLUMN, "delete-column", false }, { Tabular::COPY_ROW, "copy-row", false }, { Tabular::COPY_COLUMN, "copy-column", false }, + { Tabular::MOVE_COLUMN_RIGHT, "move-column-right", false }, + { Tabular::MOVE_COLUMN_LEFT, "move-column-left", false }, + { Tabular::MOVE_ROW_DOWN, "move-row-down", false }, + { Tabular::MOVE_ROW_UP, "move-row-up", false }, { Tabular::SET_LINE_TOP, "set-line-top", true }, { Tabular::SET_LINE_BOTTOM, "set-line-bottom", true }, { Tabular::SET_LINE_LEFT, "set-line-left", true }, @@ -256,7 +262,7 @@ string const tostr(Tabular::BoxType const & num) // I would have liked a fromstr template a lot better. (Lgb) -bool string2type(string const str, LyXAlignment & num) +bool string2type(string const & str, LyXAlignment & num) { if (str == "none") num = LYX_ALIGN_NONE; @@ -276,7 +282,7 @@ bool string2type(string const str, LyXAlignment & num) } -bool string2type(string const str, Tabular::HAlignment & num) +bool string2type(string const & str, Tabular::HAlignment & num) { if (str == "left") num = Tabular::LYX_LONGTABULAR_ALIGN_LEFT; @@ -290,7 +296,7 @@ bool string2type(string const str, Tabular::HAlignment & num) } -bool string2type(string const str, Tabular::VAlignment & num) +bool string2type(string const & str, Tabular::VAlignment & num) { if (str == "top") num = Tabular::LYX_VALIGN_TOP; @@ -304,7 +310,7 @@ bool string2type(string const str, Tabular::VAlignment & num) } -bool string2type(string const str, Tabular::BoxType & num) +bool string2type(string const & str, Tabular::BoxType & num) { if (str == "none") num = Tabular::BOX_NONE; @@ -318,7 +324,7 @@ bool string2type(string const str, Tabular::BoxType & num) } -bool string2type(string const str, bool & num) +bool string2type(string const & str, bool & num) { if (str == "true") num = true; @@ -528,7 +534,7 @@ DocIterator separatorPos(InsetTableCell * cell, docstring const & align_d) } -InsetTableCell splitCell(InsetTableCell & head, docstring const align_d, bool & hassep) +InsetTableCell splitCell(InsetTableCell & head, docstring const & align_d, bool & hassep) { InsetTableCell tail = InsetTableCell(head); DocIterator const dit = separatorPos(&head, align_d); @@ -596,36 +602,32 @@ Tabular::CellData::CellData(CellData const & cs) { } -Tabular::CellData & Tabular::CellData::operator=(CellData cs) -{ - swap(cs); +Tabular::CellData & Tabular::CellData::operator=(CellData const & cs) +{ + if (&cs == this) + return *this; + cellno = cs.cellno; + width = cs.width; + multicolumn = cs.multicolumn; + multirow = cs.multirow; + mroffset = cs.mroffset; + alignment = cs.alignment; + valignment = cs.valignment; + decimal_hoffset = cs.decimal_hoffset; + decimal_width = cs.decimal_width; + voffset = cs.voffset; + top_line = cs.top_line; + bottom_line = cs.bottom_line; + left_line = cs.left_line; + right_line = cs.right_line; + usebox = cs.usebox; + rotate = cs.rotate; + align_special = cs.align_special; + p_width = cs.p_width; + inset.reset(static_cast(cs.inset->clone())); return *this; } -void Tabular::CellData::swap(CellData & rhs) -{ - std::swap(cellno, rhs.cellno); - std::swap(width, rhs.width); - std::swap(multicolumn, rhs.multicolumn); - std::swap(multirow, rhs.multirow); - std::swap(mroffset, rhs.mroffset); - std::swap(alignment, rhs.alignment); - std::swap(valignment, rhs.valignment); - std::swap(decimal_hoffset, rhs.decimal_hoffset); - std::swap(decimal_width, rhs.decimal_width); - std::swap(voffset, rhs.voffset); - std::swap(top_line, rhs.top_line); - std::swap(bottom_line, rhs.bottom_line); - std::swap(left_line, rhs.left_line); - std::swap(right_line, rhs.right_line); - std::swap(usebox, rhs.usebox); - std::swap(rotate, rhs.rotate); - std::swap(align_special, rhs.align_special); - p_width.swap(rhs.p_width); - inset.swap(rhs.inset); -} - - Tabular::RowData::RowData() : ascent(0), descent(0), @@ -742,7 +744,7 @@ void Tabular::insertRow(row_type const row, bool copy) for (col_type c = 0; c < ncols(); ++c) { cell_info[row + 1].insert(cell_info[row + 1].begin() + c, copy ? CellData(cell_info[row][c]) : CellData(buffer_)); - if (buffer().params().trackChanges) + if (buffer().params().track_changes) cell_info[row + 1][c].inset->setChange(Change(Change::INSERTED)); if (cell_info[row][c].multirow == CELL_BEGIN_OF_MULTIROW) cell_info[row + 1][c].multirow = CELL_PART_OF_MULTIROW; @@ -763,9 +765,57 @@ void Tabular::insertRow(row_type const row, bool copy) setBottomLine(j, false); } // mark track changes - if (buffer().params().trackChanges) + if (buffer().params().track_changes) + cellInfo(i).inset->setChange(Change(Change::INSERTED)); + } +} + + +void Tabular::moveColumn(col_type col, ColDirection direction) +{ + if (direction == Tabular::LEFT) + col = col - 1; + + std::swap(column_info[col], column_info[col + 1]); + + for (row_type r = 0; r < nrows(); ++r) { + std::swap(cell_info[r][col], cell_info[r][col + 1]); + std::swap(cell_info[r][col].left_line, cell_info[r][col + 1].left_line); + std::swap(cell_info[r][col].right_line, cell_info[r][col + 1].right_line); + + // FIXME track changes is broken for tabular features (#8469) + idx_type const i = cellIndex(r, col); + idx_type const j = cellIndex(r, col + 1); + if (buffer().params().track_changes) { cellInfo(i).inset->setChange(Change(Change::INSERTED)); + cellInfo(j).inset->setChange(Change(Change::INSERTED)); + } + } + updateIndexes(); +} + + +void Tabular::moveRow(row_type row, RowDirection direction) +{ + if (direction == Tabular::UP) + row = row - 1; + + std::swap(row_info[row], row_info[row + 1]); + + for (col_type c = 0; c < ncols(); ++c) { + std::swap(cell_info[row][c], cell_info[row + 1][c]); + std::swap(cell_info[row][c].top_line, cell_info[row + 1][c].top_line); + std::swap(cell_info[row][c].bottom_line, cell_info[row + 1][c].bottom_line); + + // FIXME track changes is broken for tabular features (#8469) + idx_type const i = cellIndex(row, c); + idx_type const j = cellIndex(row + 1, c); + if (buffer().params().track_changes) { + cellInfo(i).inset->setChange(Change(Change::INSERTED)); + cellInfo(j).inset->setChange(Change(Change::INSERTED)); + } } + updateIndexes(); } @@ -809,7 +859,7 @@ void Tabular::insertColumn(col_type const col, bool copy) for (row_type r = 0; r < nrows(); ++r) { cell_info[r].insert(cell_info[r].begin() + col + 1, copy ? CellData(cell_info[r][col]) : CellData(buffer_)); - if (bp.trackChanges) + if (bp.track_changes) cell_info[r][col + 1].inset->setChange(Change(Change::INSERTED)); if (cell_info[r][col].multicolumn == CELL_BEGIN_OF_MULTICOLUMN) cell_info[r][col + 1].multicolumn = CELL_PART_OF_MULTICOLUMN; @@ -822,11 +872,11 @@ void Tabular::insertColumn(col_type const col, bool copy) setBottomLine(i, bottomLine(j)); setTopLine(i, topLine(j)); setLeftLine(i, leftLine(j)); - if (rightLine(j) && rightLine(j)) { + if (rightLine(i) && rightLine(j)) { setRightLine(i, true); setRightLine(j, false); } - if (buffer().params().trackChanges) + if (buffer().params().track_changes) cellInfo(i).inset->setChange(Change(Change::INSERTED)); } } @@ -1100,7 +1150,7 @@ void Tabular::setColumnPWidth(Cursor & cur, idx_type cell, col_type const c = cellColumn(cell); column_info[c].p_width = width; - // reset the vertical alignment to top if the fixed with + // reset the vertical alignment to top if the fixed width // is removed or zero because only fixed width columns can // have a vertical alignment if (column_info[c].p_width.zero()) @@ -1110,6 +1160,8 @@ void Tabular::setColumnPWidth(Cursor & cur, idx_type cell, // because of multicolumns toggleFixedWidth(cur, cellInset(cell).get(), !getPWidth(cell).zero()); + if (isMultiRow(cell)) + setAlignment(cell, LYX_ALIGN_LEFT, false); } // cur paragraph can become invalid after paragraphs were merged if (cur.pit() > cur.lastpit()) @@ -1389,7 +1441,7 @@ void Tabular::write(ostream & os) const << ">\n"; // global longtable options os << "(rotate)) + << write_attribute("rotate", rotate) << write_attribute("booktabs", use_booktabs) << write_attribute("islongtable", is_long_tabular) << write_attribute("firstHeadTopDL", endfirsthead.topDL) @@ -1404,12 +1456,11 @@ void Tabular::write(ostream & os) const << write_attribute("lastFootEmpty", endlastfoot.empty); // longtables cannot be aligned vertically if (!is_long_tabular) { - os << write_attribute("tabularvalignment", tabular_valignment); - os << write_attribute("tabularwidth", tabular_width); + os << write_attribute("tabularvalignment", tabular_valignment); + os << write_attribute("tabularwidth", tabular_width); } if (is_long_tabular) - os << write_attribute("longtabularalignment", - longtabular_alignment); + os << write_attribute("longtabularalignment", longtabular_alignment); os << ">\n"; for (col_type c = 0; c < ncols(); ++c) { os << "write(os); os << "\n\\end_inset\n" << "\n"; + // FIXME This can be removed again once the mystery + // crash has been resolved. + os << flush; } os << "\n"; } @@ -1477,14 +1531,13 @@ void Tabular::read(Lexer & lex) l_getline(is, line); if (!prefixIs(line, "= 2, /**/); + LATTEST(version >= 2); int rows_arg; if (!getTokenValue(line, "rows", rows_arg)) @@ -1603,6 +1656,16 @@ bool Tabular::isMultiColumn(idx_type cell) const } +bool Tabular::hasMultiColumn(col_type c) const +{ + for (row_type r = 0; r < nrows(); ++r) { + if (isMultiColumn(cellIndex(r, c))) + return true; + } + return false; +} + + Tabular::CellData & Tabular::cellInfo(idx_type cell) const { return cell_info[cellRow(cell)][cellColumn(cell)]; @@ -1623,8 +1686,7 @@ Tabular::idx_type Tabular::setMultiColumn(idx_type cell, idx_type number, cs.multicolumn = CELL_BEGIN_OF_MULTICOLUMN; if (column_info[col].alignment != LYX_ALIGN_DECIMAL) cs.alignment = column_info[col].alignment; - if (col > 0) - setRightLine(cell, right_border); + setRightLine(cell, right_border); for (idx_type i = 1; i < number; ++i) { CellData & cs1 = cellInfo(cell + i); @@ -1643,9 +1705,18 @@ bool Tabular::isMultiRow(idx_type cell) const || cellInfo(cell).multirow == CELL_PART_OF_MULTIROW); } +bool Tabular::hasMultiRow(row_type r) const +{ + for (col_type c = 0; c < ncols(); ++c) { + if (isMultiRow(cellIndex(r, c))) + return true; + } + return false; +} Tabular::idx_type Tabular::setMultiRow(idx_type cell, idx_type number, - bool const bottom_border) + bool const bottom_border, + LyXAlignment const halign) { idx_type const col = cellColumn(cell); idx_type const row = cellRow(cell); @@ -1661,10 +1732,10 @@ Tabular::idx_type Tabular::setMultiRow(idx_type cell, idx_type number, // be changed for the whole table row, // support changing this only for the multirow cell can be done via // \multirowsetup - // this feature would be a fileformat change - // until LyX supports this, use the deault alignment of multirow - // cells: left - cs.alignment = LYX_ALIGN_LEFT; + if (getPWidth(cell).zero()) + cs.alignment = halign; + else + cs.alignment = LYX_ALIGN_LEFT; // set the bottom line of the last selected cell setBottomLine(cell, bottom_border); @@ -1799,8 +1870,8 @@ Tabular::idx_type Tabular::cellBelow(idx_type cell) const Tabular::idx_type Tabular::cellIndex(row_type row, col_type column) const { - LASSERT(column != npos && column < ncols() - && row != npos && row < nrows(), /**/); + LASSERT(column != npos && column < ncols(), column = 0); + LASSERT(row != npos && row < nrows(), row = 0); return cell_info[row][column].cellno; } @@ -2031,14 +2102,14 @@ void Tabular::setRowDescent(row_type row, int height) int Tabular::rowAscent(row_type row) const { - LASSERT(row < nrows(), /**/); + LASSERT(row < nrows(), row = 0); return row_info[row].ascent; } int Tabular::rowDescent(row_type row) const { - LASSERT(row < nrows(), /**/); + LASSERT(row < nrows(), row = 0); return row_info[row].descent; } @@ -2055,21 +2126,21 @@ int Tabular::height() const bool Tabular::isPartOfMultiColumn(row_type row, col_type column) const { - LASSERT(row < nrows(), /**/); - LASSERT(column < ncols(), /**/); + LASSERT(row < nrows(), return false); + LASSERT(column < ncols(), return false); return cell_info[row][column].multicolumn == CELL_PART_OF_MULTICOLUMN; } bool Tabular::isPartOfMultiRow(row_type row, col_type column) const { - LASSERT(row < nrows(), /**/); - LASSERT(column < ncols(), /**/); + LASSERT(row < nrows(), return false); + LASSERT(column < ncols(), return false); return cell_info[row][column].multirow == CELL_PART_OF_MULTIROW; } -void Tabular::TeXTopHLine(otexstream & os, row_type row, string const lang) const +void Tabular::TeXTopHLine(otexstream & os, row_type row, string const & lang) const { // we only output complete row lines and the 1st row here, the rest // is done in Tabular::TeXBottomHLine(...) @@ -2131,7 +2202,7 @@ void Tabular::TeXTopHLine(otexstream & os, row_type row, string const lang) cons } -void Tabular::TeXBottomHLine(otexstream & os, row_type row, string const lang) const +void Tabular::TeXBottomHLine(otexstream & os, row_type row, string const & lang) const { // we output bottomlines of row r and the toplines of row r+1 // if the latter do not span the whole tabular @@ -2380,6 +2451,16 @@ void Tabular::TeXLongtableHeaderFooter(otexstream & os, if (!is_long_tabular) return; + // caption handling + // output caption which is in no header or footer + if (haveLTCaption()) { + for (row_type r = 0; r < nrows(); ++r) { + if (row_info[r].caption && + !row_info[r].endfirsthead && !row_info[r].endhead && + !row_info[r].endfoot && !row_info[r].endlastfoot) + TeXRow(os, r, runparams); + } + } // output first header info if (haveLTFirstHead()) { if (endfirsthead.topDL) @@ -3018,7 +3099,7 @@ docstring Tabular::xhtml(XHTMLStream & xs, OutputParams const & runparams) const } -bool Tabular::plaintextTopHLine(odocstream & os, row_type row, +bool Tabular::plaintextTopHLine(odocstringstream & os, row_type row, vector const & clen) const { idx_type const fcell = getFirstCellInRow(row); @@ -3066,7 +3147,7 @@ bool Tabular::plaintextTopHLine(odocstream & os, row_type row, } -bool Tabular::plaintextBottomHLine(odocstream & os, row_type row, +bool Tabular::plaintextBottomHLine(odocstringstream & os, row_type row, vector const & clen) const { idx_type const fcell = getFirstCellInRow(row); @@ -3113,14 +3194,14 @@ bool Tabular::plaintextBottomHLine(odocstream & os, row_type row, } -void Tabular::plaintextPrintCell(odocstream & os, +void Tabular::plaintextPrintCell(odocstringstream & os, OutputParams const & runparams, idx_type cell, row_type row, col_type column, vector const & clen, - bool onlydata) const + bool onlydata, size_t max_length) const { odocstringstream sstr; - cellInset(cell)->plaintext(sstr, runparams); + cellInset(cell)->plaintext(sstr, runparams, max_length); if (onlydata) { os << sstr.str(); @@ -3163,9 +3244,9 @@ void Tabular::plaintextPrintCell(odocstream & os, } -void Tabular::plaintext(odocstream & os, +void Tabular::plaintext(odocstringstream & os, OutputParams const & runparams, int const depth, - bool onlydata, char_type delim) const + bool onlydata, char_type delim, size_t max_length) const { // first calculate the width of the single columns vector clen(ncols()); @@ -3179,7 +3260,7 @@ void Tabular::plaintext(odocstream & os, if (isMultiColumn(cell)) continue; odocstringstream sstr; - cellInset(cell)->plaintext(sstr, runparams); + cellInset(cell)->plaintext(sstr, runparams, max_length); if (clen[c] < sstr.str().length()) clen[c] = sstr.str().length(); } @@ -3191,7 +3272,7 @@ void Tabular::plaintext(odocstream & os, if (cell_info[r][c].multicolumn != CELL_BEGIN_OF_MULTICOLUMN) continue; odocstringstream sstr; - cellInset(cell)->plaintext(sstr, runparams); + cellInset(cell)->plaintext(sstr, runparams, max_length); int len = int(sstr.str().length()); idx_type const n = columnSpan(cell); for (col_type k = c; len > 0 && k < c + n - 1; ++k) @@ -3212,8 +3293,10 @@ void Tabular::plaintext(odocstream & os, // we don't use operator<< for single UCS4 character. // see explanation in docstream.h os.put(delim); - plaintextPrintCell(os, runparams, cell, r, c, clen, onlydata); + plaintextPrintCell(os, runparams, cell, r, c, clen, onlydata, max_length); ++cell; + if (os.str().size() > max_length) + break; } os << endl; if (!onlydata) { @@ -3221,6 +3304,8 @@ void Tabular::plaintext(odocstream & os, if (plaintextBottomHLine(os, r, clen)) os << docstring(depth * 2, ' '); } + if (os.str().size() > max_length) + break; } } @@ -3348,6 +3433,12 @@ docstring InsetTableCell::asString(bool intoInsets) } +void InsetTableCell::addToToc(DocIterator const & di, bool output_active) const +{ + InsetText::iterateForToc(di, output_active); +} + + docstring InsetTableCell::xhtml(XHTMLStream & xs, OutputParams const & rp) const { if (!isFixedWidth) @@ -3408,6 +3499,13 @@ bool InsetTabular::insetAllowed(InsetCode code) const } +bool InsetTabular::allowsCaptionVariation(std::string const & newtype) const +{ + return tabular.is_long_tabular && + (newtype == "Standard" || newtype == "LongTableNoNumber"); +} + + void InsetTabular::write(ostream & os) const { os << "Tabular" << endl; @@ -3477,10 +3575,7 @@ void InsetTabular::metrics(MetricsInfo & mi, Dimension & dim) const { //lyxerr << "InsetTabular::metrics: " << mi.base.bv << " width: " << // mi.base.textwidth << "\n"; - if (!mi.base.bv) { - LYXERR0("need bv"); - LASSERT(false, /**/); - } + LBUFERR(mi.base.bv); for (row_type r = 0; r < tabular.nrows(); ++r) { int maxasc = 0; @@ -3763,9 +3858,13 @@ void InsetTabular::drawCellLines(PainterInfo & pi, int x, int y, // Right x -= tabular.interColumnSpace(cell); + col_type next_cell_col = col + 1; + while (next_cell_col < tabular.ncols() + && tabular.isMultiColumn(tabular.cellIndex(row, next_cell_col))) + next_cell_col++; drawline = tabular.rightLine(cell) - || (col + 1 < tabular.ncols() - && tabular.leftLine(tabular.cellIndex(row, col + 1))); + || (next_cell_col < tabular.ncols() + && tabular.leftLine(tabular.cellIndex(row, next_cell_col))); pi.pain.line(x + w, y, x + w, y + h, drawline ? linecolor : gridcolor, drawline ? Painter::line_solid : Painter::line_onoffdash); @@ -3805,8 +3904,12 @@ void InsetTabular::updateBuffer(ParIterator const & it, UpdateType utype) // In a longtable, tell captions what the current float is Counters & cnts = buffer().masterBuffer()->params().documentClass().counters(); string const saveflt = cnts.current_float(); - if (tabular.is_long_tabular) + if (tabular.is_long_tabular) { cnts.current_float("table"); + // in longtables, we only step the counter once + cnts.step(from_ascii("table"), utype); + cnts.isLongtable(true); + } ParIterator it2 = it; it2.forwardPos(); @@ -3815,18 +3918,20 @@ void InsetTabular::updateBuffer(ParIterator const & it, UpdateType utype) buffer().updateBuffer(it2, utype); //reset afterwards - if (tabular.is_long_tabular) + if (tabular.is_long_tabular) { cnts.current_float(saveflt); + cnts.isLongtable(false); + } } -void InsetTabular::addToToc(DocIterator const & cpit) const +void InsetTabular::addToToc(DocIterator const & cpit, bool output_active) const { DocIterator dit = cpit; dit.forwardPos(); size_t const end = dit.nargs(); for ( ; dit.idx() < end; dit.top().forwardIdx()) - cell(dit.idx())->addToToc(dit); + cell(dit.idx())->addToToc(dit, output_active); } @@ -4224,8 +4329,16 @@ void InsetTabular::doDispatch(Cursor & cur, FuncRequest & cmd) if (cur.selIsMultiCell()) { cur.recordUndoInset(DELETE_UNDO); cutSelection(cur); - } - cell(cur.idx())->dispatch(cur, cmd); + BufferView * bv = &cur.bv(); + docstring::const_iterator cit = cmd.argument().begin(); + docstring::const_iterator const end = cmd.argument().end(); + for (; cit != end; ++cit) + bv->translateAndInsert(*cit, getText(cur.idx()), cur); + + cur.resetAnchor(); + bv->bookmarkEditPosition(); + } else + cell(cur.idx())->dispatch(cur, cmd); break; case LFUN_CHAR_DELETE_BACKWARD: @@ -4250,7 +4363,7 @@ void InsetTabular::doDispatch(Cursor & cur, FuncRequest & cmd) case LFUN_CLIPBOARD_PASTE: case LFUN_PRIMARY_SELECTION_PASTE: { docstring const clip = (act == LFUN_CLIPBOARD_PASTE) ? - theClipboard().getAsText() : + theClipboard().getAsText(Clipboard::PlainTextType) : theSelection().get(); if (clip.empty()) break; @@ -4298,9 +4411,11 @@ void InsetTabular::doDispatch(Cursor & cur, FuncRequest & cmd) case LFUN_FONT_SIZE: case LFUN_FONT_UNDERLINE: case LFUN_FONT_STRIKEOUT: - case LFUN_FONT_UULINE: - case LFUN_FONT_UWAVE: + case LFUN_FONT_UNDERUNDERLINE: + case LFUN_FONT_UNDERWAVE: case LFUN_LANGUAGE: + case LFUN_PARAGRAPH_PARAMS_APPLY: + case LFUN_PARAGRAPH_PARAMS: case LFUN_WORD_CAPITALIZE: case LFUN_WORD_UPCASE: case LFUN_WORD_LOWCASE: @@ -4411,6 +4526,56 @@ bool InsetTabular::getStatus(Cursor & cur, FuncRequest const & cmd, && tabular.tabular_valignment == Tabular::LYX_VALIGN_MIDDLE); break; + case Tabular::MOVE_COLUMN_RIGHT: + case Tabular::MOVE_COLUMN_LEFT: + case Tabular::MOVE_ROW_DOWN: + case Tabular::MOVE_ROW_UP: { + if (cur.selection()) { + status.message(_("Selections not supported.")); + status.setEnabled(false); + break; + } + + if ((action == Tabular::MOVE_COLUMN_RIGHT && + tabular.ncols() == tabular.cellColumn(cur.idx()) + 1) || + (action == Tabular::MOVE_COLUMN_LEFT && + tabular.cellColumn(cur.idx()) == 0) || + (action == Tabular::MOVE_ROW_DOWN && + tabular.nrows() == tabular.cellRow(cur.idx()) + 1) || + (action == Tabular::MOVE_ROW_UP && + tabular.cellRow(cur.idx()) == 0)) { + status.setEnabled(false); + break; + } + + if (action == Tabular::MOVE_COLUMN_RIGHT || + action == Tabular::MOVE_COLUMN_LEFT) { + if (tabular.hasMultiColumn(tabular.cellColumn(cur.idx())) || + tabular.hasMultiColumn(tabular.cellColumn(cur.idx()) + + (action == Tabular::MOVE_COLUMN_RIGHT ? 1 : -1))) { + status.message(_("Multi-column in current or" + " destination column.")); + status.setEnabled(false); + break; + } + } + + if (action == Tabular::MOVE_ROW_DOWN || + action == Tabular::MOVE_ROW_UP) { + if (tabular.hasMultiRow(tabular.cellRow(cur.idx())) || + tabular.hasMultiRow(tabular.cellRow(cur.idx()) + + (action == Tabular::MOVE_ROW_DOWN ? 1 : -1))) { + status.message(_("Multi-row in current or" + " destination row.")); + status.setEnabled(false); + break; + } + } + + status.setEnabled(true); + break; + } + case Tabular::SET_DECIMAL_POINT: status.setEnabled( tabular.getAlignment(cur.idx()) == LYX_ALIGN_DECIMAL); @@ -4608,7 +4773,7 @@ bool InsetTabular::getStatus(Cursor & cur, FuncRequest const & cmd, break; case Tabular::UNSET_LTFIRSTHEAD: - status.setEnabled(sel_row_start == sel_row_end && !tabular.ltCaption(sel_row_start)); + status.setEnabled(sel_row_start == sel_row_end); status.setOnOff(!tabular.getRowOfLTFirstHead(sel_row_start, dummyltt)); break; @@ -4618,7 +4783,7 @@ bool InsetTabular::getStatus(Cursor & cur, FuncRequest const & cmd, break; case Tabular::UNSET_LTHEAD: - status.setEnabled(sel_row_start == sel_row_end && !tabular.ltCaption(sel_row_start)); + status.setEnabled(sel_row_start == sel_row_end); status.setOnOff(!tabular.getRowOfLTHead(sel_row_start, dummyltt)); break; @@ -4628,7 +4793,7 @@ bool InsetTabular::getStatus(Cursor & cur, FuncRequest const & cmd, break; case Tabular::UNSET_LTFOOT: - status.setEnabled(sel_row_start == sel_row_end && !tabular.ltCaption(sel_row_start)); + status.setEnabled(sel_row_start == sel_row_end); status.setOnOff(!tabular.getRowOfLTFoot(sel_row_start, dummyltt)); break; @@ -4638,7 +4803,7 @@ bool InsetTabular::getStatus(Cursor & cur, FuncRequest const & cmd, break; case Tabular::UNSET_LTLASTFOOT: - status.setEnabled(sel_row_start == sel_row_end && !tabular.ltCaption(sel_row_start)); + status.setEnabled(sel_row_start == sel_row_end); status.setOnOff(!tabular.getRowOfLTLastFoot(sel_row_start, dummyltt)); break; @@ -4698,6 +4863,37 @@ bool InsetTabular::getStatus(Cursor & cur, FuncRequest const & cmd, return true; } + case LFUN_CAPTION_INSERT: { + // caption is only allowed in caption cell of longtable + if (!tabular.ltCaption(tabular.cellRow(cur.idx()))) { + status.setEnabled(false); + return true; + } + // only standard caption is allowed + string arg = cmd.getArg(0); + if (!arg.empty() && arg != "Standard") { + status.setEnabled(false); + return true; + } + // check if there is already a caption + bool have_caption = false; + InsetTableCell itc = InsetTableCell(*tabular.cellInset(cur.idx()).get()); + ParagraphList::const_iterator pit = itc.paragraphs().begin(); + ParagraphList::const_iterator pend = itc.paragraphs().end(); + for (; pit != pend; ++pit) { + InsetList::const_iterator it = pit->insetList().begin(); + InsetList::const_iterator end = pit->insetList().end(); + for (; it != end; ++it) { + if (it->inset->lyxCode() == CAPTION_CODE) { + have_caption = true; + break; + } + } + } + status.setEnabled(!have_caption); + return true; + } + // These are only enabled inside tabular case LFUN_CELL_BACKWARD: case LFUN_CELL_FORWARD: @@ -4805,11 +5001,12 @@ void InsetTabular::latex(otexstream & os, OutputParams const & runparams) const } -int InsetTabular::plaintext(odocstream & os, OutputParams const & runparams) const +int InsetTabular::plaintext(odocstringstream & os, + OutputParams const & runparams, size_t max_length) const { os << '\n'; // output table on a new line int const dp = runparams.linelen > 0 ? runparams.depth : 0; - tabular.plaintext(os, runparams, dp, false, 0); + tabular.plaintext(os, runparams, dp, false, 0, max_length); return PLAINTEXT_NEWLINE; } @@ -5361,6 +5558,26 @@ void InsetTabular::tabularFeatures(Cursor & cur, cur.idx() = tabular.cellIndex(row, column); break; + case Tabular::MOVE_COLUMN_RIGHT: + tabular.moveColumn(column, Tabular::RIGHT); + cur.idx() = tabular.cellIndex(row, column + 1); + break; + + case Tabular::MOVE_COLUMN_LEFT: + tabular.moveColumn(column, Tabular::LEFT); + cur.idx() = tabular.cellIndex(row, column - 1); + break; + + case Tabular::MOVE_ROW_DOWN: + tabular.moveRow(row, Tabular::DOWN); + cur.idx() = tabular.cellIndex(row + 1, column); + break; + + case Tabular::MOVE_ROW_UP: + tabular.moveRow(row, Tabular::UP); + cur.idx() = tabular.cellIndex(row - 1, column); + break; + case Tabular::SET_LINE_TOP: case Tabular::TOGGLE_LINE_TOP: { bool lineSet = (feature == Tabular::SET_LINE_TOP) @@ -5436,7 +5653,7 @@ void InsetTabular::tabularFeatures(Cursor & cur, tabular.rightLine(cur.idx())); break; } - // we have a selection so this means we just add all this + // we have a selection so this means we just add all these // cells to form a multicolumn cell idx_type const s_start = cur.selBegin().idx(); row_type const col_start = tabular.cellColumn(s_start); @@ -5488,7 +5705,8 @@ void InsetTabular::tabularFeatures(Cursor & cur, // check whether we are completely in a multirow if (!tabular.isMultiRow(cur.idx())) tabular.setMultiRow(cur.idx(), 1, - tabular.bottomLine(cur.idx())); + tabular.bottomLine(cur.idx()), + tabular.getAlignment(cur.idx())); break; } // we have a selection so this means we just add all this @@ -5497,7 +5715,8 @@ void InsetTabular::tabularFeatures(Cursor & cur, row_type const row_start = tabular.cellRow(s_start); row_type const row_end = tabular.cellRow(cur.selEnd().idx()); cur.idx() = tabular.setMultiRow(s_start, row_end - row_start + 1, - tabular.bottomLine(cur.selEnd().idx())); + tabular.bottomLine(cur.selEnd().idx()), + tabular.getAlignment(cur.selEnd().idx())); cur.pit() = 0; cur.pos() = 0; cur.setSelection(false); @@ -5830,7 +6049,7 @@ bool InsetTabular::copySelection(Cursor & cur) odocstringstream os; OutputParams const runparams(0); - paste_tabular->plaintext(os, runparams, 0, true, '\t'); + paste_tabular->plaintext(os, runparams, 0, true, '\t', INT_MAX); // Needed for the "Edit->Paste recent" menu and the system clipboard. cap::copySelection(cur, os.str()); @@ -5881,7 +6100,7 @@ bool InsetTabular::pasteClipboard(Cursor & cur) tabular.cellInset(r2, c2)->setBuffer(tabular.buffer()); // FIXME: change tracking (MG) - inset->setChange(Change(buffer().params().trackChanges ? + inset->setChange(Change(buffer().params().track_changes ? Change::INSERTED : Change::UNCHANGED)); cur.pos() = 0; } @@ -5902,7 +6121,7 @@ void InsetTabular::cutSelection(Cursor & cur) for (col_type c = cs; c <= ce; ++c) { shared_ptr t = cell(tabular.cellIndex(r, c)); - if (buffer().params().trackChanges) + if (buffer().params().track_changes) // FIXME: Change tracking (MG) t->setChange(Change(Change::DELETED)); else @@ -5921,7 +6140,8 @@ void InsetTabular::cutSelection(Cursor & cur) bool InsetTabular::isRightToLeft(Cursor & cur) const { - LASSERT(cur.depth() > 1, /**/); + // LASSERT: It might be better to abandon this Buffer. + LASSERT(cur.depth() > 1, return false); Paragraph const & parentpar = cur[cur.depth() - 2].paragraph(); pos_type const parentpos = cur[cur.depth() - 2].pos(); return parentpar.getFontSettings(buffer().params(), @@ -6071,7 +6291,7 @@ bool InsetTabular::insertPlaintextString(BufferView & bv, docstring const & buf, Font const font = bv.textMetrics(&inset->text()). displayFont(0, 0); inset->setText(buf.substr(op, p - op), font, - buffer().params().trackChanges); + buffer().params().track_changes); ++cols; ++cell; } @@ -6083,7 +6303,7 @@ bool InsetTabular::insertPlaintextString(BufferView & bv, docstring const & buf, Font const font = bv.textMetrics(&inset->text()). displayFont(0, 0); inset->setText(buf.substr(op, p - op), font, - buffer().params().trackChanges); + buffer().params().track_changes); } cols = ocol; ++row; @@ -6099,7 +6319,7 @@ bool InsetTabular::insertPlaintextString(BufferView & bv, docstring const & buf, shared_ptr inset = loctab->cellInset(cell); Font const font = bv.textMetrics(&inset->text()).displayFont(0, 0); inset->setText(buf.substr(op, len - op), font, - buffer().params().trackChanges); + buffer().params().track_changes); } return true; }