* This file is part of LyX, the document processor.
* Licence details can be found in the file COPYING.
*
- * \author Lars Gullik Bjønnes
+ * \author Lars Gullik Bjønnes
* \author Matthias Ettrich
- * \author José Matos
+ * \author José Matos
* \author Jean-Marc Lasgouttes
* \author Angus Leeming
* \author John Levon
- * \author André Pönitz
- * \author Jürgen Vigna
+ * \author André Pönitz
+ * \author Jürgen Vigna
*
* Full author contact details are available in file CREDITS.
*/
{ Tabular::SET_BOTTOM_SPACE, "set-bottom-space" },
{ Tabular::SET_INTERLINE_SPACE, "set-interline-space" },
{ Tabular::SET_BORDER_LINES, "set-border-lines" },
+ { Tabular::TABULAR_VALIGN_TOP, "tabular-valign-top"},
+ { Tabular::TABULAR_VALIGN_MIDDLE, "tabular-valign-middle"},
+ { Tabular::TABULAR_VALIGN_BOTTOM, "tabular-valign-bottom"},
{ Tabular::LAST_ACTION, "" }
};
cell_info.reserve(100);
updateIndexes();
is_long_tabular = false;
+ tabular_valignment = LYX_VALIGN_MIDDLE;
rotate = false;
use_booktabs = false;
size_t row_count = row_info.size();
for (row_type r = 0; r < nrows; ++r) {
cell_info[r].insert(cell_info[r].begin() + c + 1,
CellData(buffer()));
+#if 0
+// FIXME: This code does not work. It deletes the cell's content and
+// it triggers an assertion if the cursor is at pos > 0.
if (cell_info[r][c].multicolumn == CELL_BEGIN_OF_MULTICOLUMN)
cell_info[r][c + 1].multicolumn = CELL_PART_OF_MULTICOLUMN;
else
cell_info[r][c + 1].multicolumn = cell_info[r][c].multicolumn;
+#endif
}
updateIndexes();
for (row_type r = 0; r < nrows; ++r) {
if (column_info.size() == 1)
return;
- column_info.erase(column_info.begin() + column);
- size_t row_count = row_info.size();
+ size_t const row_count = row_info.size();
for (row_type i = 0; i < row_count; ++i) {
// Care about multicolumn cells
if (column + 1 < column_info.size() &&
}
cell_info[i].erase(cell_info[i].begin() + column);
}
+ column_info.erase(column_info.begin() + column);
updateIndexes();
}
rowofcell[i] = row;
columnofcell[i] = column;
setFixedWidth(row, column);
+ updateContentAlignment(row, column);
++i;
}
}
column_info[cellColumn(cell)].alignment = align;
if (!onlycolumn)
cellInfo(cell).alignment = align;
+ cellInset(cell).get()->setContentAlignment(align);
}
bool Tabular::setFixedWidth(row_type r, col_type c)
{
- if (!column_info[c].p_width.zero() ||
- (cell_info[r][c].multicolumn != CELL_NORMAL &&
- !cell_info[r][c].p_width.zero())) {
- cell_info[r][c].inset->toggleFixedWidth(true);
- return true;
- }
- return false;
+ bool const multicol = cell_info[r][c].multicolumn != CELL_NORMAL;
+ bool const fixed_width = (!column_info[c].p_width.zero() && !multicol)
+ || (multicol && !cell_info[r][c].p_width.zero());
+ cell_info[r][c].inset->toggleFixedWidth(fixed_width);
+ return fixed_width;
+}
+
+
+void Tabular::updateContentAlignment(row_type r, col_type c)
+{
+ cell_info[r][c].inset->setContentAlignment(
+ getAlignment(cellIndex(r, c)));
}
idx_type i = cellIndex(r, c);
if (c == cellColumn(i) + columnSpan(i) - 1) {
++total;
- bool left = c + 1 < column_info.size()
- && cellInfo(cellIndex(r, c + 1)).left_line
+ bool left = (c + 1 < column_info.size()
+ && cellInfo(cellIndex(r, c + 1)).left_line)
|| c + 1 == column_info.size();
if (cellInfo(i).right_line && left)
++nrows_right;
<< write_attribute("rotate", rotate)
<< write_attribute("booktabs", use_booktabs)
<< write_attribute("islongtable", is_long_tabular)
+ << write_attribute("tabularvalignment", tabular_valignment)
<< write_attribute("firstHeadTopDL", endfirsthead.topDL)
<< write_attribute("firstHeadBottomDL", endfirsthead.bottomDL)
<< write_attribute("firstHeadEmpty", endfirsthead.empty)
getTokenValue(line, "rotate", rotate);
getTokenValue(line, "booktabs", use_booktabs);
getTokenValue(line, "islongtable", is_long_tabular);
+ getTokenValue(line, "tabularvalignment", tabular_valignment);
getTokenValue(line, "firstHeadTopDL", endfirsthead.topDL);
getTokenValue(line, "firstHeadBottomDL", endfirsthead.bottomDL);
getTokenValue(line, "firstHeadEmpty", endfirsthead.empty);
{
idx_type i = getFirstCellInRow(row);
if (what) {
- setMultiColumn(i, column_info.size());
+ setMultiColumn(i, numberOfCellsInRow(i));
setTopLine(i, false);
setBottomLine(i, false);
setLeftLine(i, false);
setRightLine(i, false);
- } else
+ // When a row is set as caption, then also insert a caption. Otherwise
+ // the LaTeX output is broken, when the user don't add a caption.
+ dispatch(FuncRequest(LFUN_CAPTION_INSERT));
+ } else {
unsetMultiColumn(i);
+ // FIXME: when unsetting a caption row, also all existing captions
+ // in this row must be dissolved, see (bug 5754)
+ // dispatch(FuncRequest(LFUN_INSET_DISSOLVE, "caption-insert"));
+ }
row_info[row].caption = what;
return i;
}
}
+bool Tabular::haveLTCaption() const
+{
+ for (row_type i = 0; i < row_info.size(); ++i)
+ if (row_info[i].caption)
+ return true;
+ return false;
+}
+
+
// end longtable support functions
void Tabular::setRowAscent(row_type row, int height)
}
-int Tabular::TeXTopHLine(odocstream & os, row_type row) const
+int Tabular::TeXTopHLine(odocstream & os, row_type row, string const lang) const
{
- // FIXME: assert or return 0 as in TeXBottomHLine()?
- LASSERT(row != npos, /**/);
- LASSERT(row < row_info.size(), /**/);
+ // we only output complete row lines and the 1st row here, the rest
+ // is done in Tabular::TeXBottomHLine(...)
- idx_type const fcell = getFirstCellInRow(row);
- idx_type const n = numberOfCellsInRow(fcell) + fcell;
- idx_type tmp = 0;
-
- for (idx_type i = fcell; i < n; ++i) {
- if (topLine(i))
- ++tmp;
+ // get for each column the topline (if any)
+ col_type const ncols = column_info.size();
+ vector<bool> topline;
+ col_type nset = 0;
+ for (col_type c = 0; c < ncols; ++c) {
+ topline.push_back(topLine(cellIndex(row, c)));
+ if (topline[c])
+ ++nset;
}
- if (use_booktabs && row == 0) {
- if (topLine(fcell))
- os << "\\toprule ";
- } else if (tmp == n - fcell) {
- os << (use_booktabs ? "\\midrule " : "\\hline ");
- } else if (tmp) {
- for (idx_type i = fcell; i < n; ++i) {
- if (topLine(i)) {
- os << (use_booktabs ? "\\cmidrule{" : "\\cline{")
- << cellColumn(i) + 1
- << '-'
- << cellRightColumn(i) + 1
- << "} ";
+
+ // do nothing if empty first row, or incomplete row line after
+ if ((row == 0 && nset == 0) || (row > 0 && nset != ncols))
+ return 0;
+
+ // only output complete row lines and the 1st row's clines
+ if (nset == ncols) {
+ if (use_booktabs) {
+ os << (row == 0 ? "\\toprule " : "\\midrule ");
+ } else {
+ os << "\\hline ";
+ }
+ } else if (row == 0) {
+ for (col_type c = 0; c < ncols; ++c) {
+ if (topline[c]) {
+ //babel makes the "-" character an active one, so we have to suppress this here
+ //see http://groups.google.com/group/comp.text.tex/browse_thread/thread/af769424a4a0f289#
+ if (lang == "slovak" || lang == "czech")
+ os << (use_booktabs ? "\\expandafter\\cmidrule\\expandafter{\\expandafter" :
+ "\\expandafter\\cline\\expandafter{\\expandafter")
+ << c + 1 << "\\string-";
+ else
+ os << (use_booktabs ? "\\cmidrule{" : "\\cline{") << c + 1 << '-';
+ // get to last column of line span
+ while (c < ncols && topline[c])
+ ++c;
+ os << c << "} ";
}
}
- } else {
- return 0;
}
os << "\n";
return 1;
}
-int Tabular::TeXBottomHLine(odocstream & os, row_type row) const
+int Tabular::TeXBottomHLine(odocstream & os, row_type row, string const lang) const
{
- // FIXME: return 0 or assert as in TeXTopHLine()?
- if (row == npos || row >= row_info.size())
- return 0;
+ // we output bottomlines of row r and the toplines of row r+1
+ // if the latter do not span the whole tabular
- idx_type const fcell = getFirstCellInRow(row);
- idx_type const n = numberOfCellsInRow(fcell) + fcell;
- idx_type tmp = 0;
+ // get the bottomlines of row r, and toplines in next row
+ bool lastrow = row == row_info.size() - 1;
+ col_type const ncols = column_info.size();
+ vector<bool> bottomline, topline;
+ bool nextrowset = true;
+ for (col_type c = 0; c < ncols; ++c) {
+ bottomline.push_back(bottomLine(cellIndex(row, c)));
+ topline.push_back(!lastrow && topLine(cellIndex(row + 1, c)));
+ nextrowset &= topline[c];
+ }
- for (idx_type i = fcell; i < n; ++i) {
- if (bottomLine(i))
- ++tmp;
+ // combine this row's bottom lines and next row's toplines if necessary
+ col_type nset = 0;
+ for (col_type c = 0; c < ncols; ++c) {
+ if (!nextrowset)
+ bottomline[c] = bottomline[c] || topline[c];
+ if (bottomline[c])
+ ++nset;
}
- if (use_booktabs && row == row_info.size() - 1) {
- if (bottomLine(fcell))
- os << "\\bottomrule";
- } else if (tmp == n - fcell) {
- os << (use_booktabs ? "\\midrule" : "\\hline");
- } else if (tmp) {
- for (idx_type i = fcell; i < n; ++i) {
- if (bottomLine(i)) {
- os << (use_booktabs ? "\\cmidrule{" : "\\cline{")
- << cellColumn(i) + 1
- << '-'
- << cellRightColumn(i) + 1
- << "} ";
+
+ // do nothing if empty, OR incomplete row line with a topline in next row
+ if (nset == 0 || (nextrowset && nset != ncols))
+ return 0;
+
+ if (nset == ncols) {
+ if (use_booktabs)
+ os << (lastrow ? "\\bottomrule" : "\\midrule");
+ else
+ os << "\\hline";
+ } else {
+ for (col_type c = 0; c < ncols; ++c) {
+ if (bottomline[c]) {
+ //babel makes the "-" character an active one, so we have to suppress this here
+ //see http://groups.google.com/group/comp.text.tex/browse_thread/thread/af769424a4a0f289#
+ if (lang == "slovak" || lang == "czech")
+ os << (use_booktabs ? "\\expandafter\\cmidrule\\expandafter{\\expandafter" :
+ "\\expandafter\\cline\\expandafter{\\expandafter")
+ << c + 1 << "\\string-";
+ else
+ os << (use_booktabs ? "\\cmidrule{" : "\\cline{") << c + 1 << '-';
+ // get to last column of line span
+ while (c < ncols && bottomline[c])
+ ++c;
+ os << c << "} ";
}
}
- } else {
- return 0;
}
os << "\n";
return 1;
os << cellInfo(cell).align_special;
} else {
if (!getPWidth(cell).zero()) {
+ switch (align) {
+ case LYX_ALIGN_LEFT:
+ os << ">{\\raggedright}";
+ break;
+ case LYX_ALIGN_RIGHT:
+ os << ">{\\raggedleft}";
+ break;
+ case LYX_ALIGN_CENTER:
+ os << ">{\\centering}";
+ break;
+ default:
+ break;
+ }
switch (valign) {
case LYX_VALIGN_TOP:
os << 'p';
return 0;
int ret = 0;
- // output header info
- if (haveLTHead()) {
- if (endhead.topDL) {
+ // caption handling
+ // the caption must be output befrore the headers
+ if (haveLTCaption()) {
+ for (row_type i = 0; i < row_info.size(); ++i) {
+ if (row_info[i].caption) {
+ ret += TeXRow(os, i, runparams);
+ }
+ }
+ }
+ // output first header info
+ // first header must be output before the header, otherwise the
+ // correct caption placement becomes really wierd
+ if (haveLTFirstHead()) {
+ if (endfirsthead.topDL) {
os << "\\hline\n";
++ret;
}
for (row_type i = 0; i < row_info.size(); ++i) {
- if (row_info[i].endhead) {
+ if (row_info[i].endfirsthead) {
ret += TeXRow(os, i, runparams);
}
}
- if (endhead.bottomDL) {
+ if (endfirsthead.bottomDL) {
os << "\\hline\n";
++ret;
}
- os << "\\endhead\n";
+ os << "\\endfirsthead\n";
++ret;
- if (endfirsthead.empty) {
+ }
+ // output header info
+ if (haveLTHead()) {
+ if (!haveLTFirstHead()) {
os << "\\endfirsthead\n";
++ret;
}
- }
- // output firstheader info
- if (haveLTFirstHead()) {
- if (endfirsthead.topDL) {
+ if (endhead.topDL) {
os << "\\hline\n";
++ret;
}
for (row_type i = 0; i < row_info.size(); ++i) {
- if (row_info[i].endfirsthead) {
+ if (row_info[i].endhead) {
ret += TeXRow(os, i, runparams);
}
}
- if (endfirsthead.bottomDL) {
+ if (endhead.bottomDL) {
os << "\\hline\n";
++ret;
}
- os << "\\endfirsthead\n";
+ os << "\\endhead\n";
++ret;
}
// output footer info
}
os << "\\endfoot\n";
++ret;
- if (endlastfoot.empty) {
+ if (!haveLTLastFoot()) {
os << "\\endlastfoot\n";
++ret;
}
{
if (!is_long_tabular)
return true;
- return !row_info[row].endhead && !row_info[row].endfirsthead &&
- !row_info[row].endfoot && !row_info[row].endlastfoot;
+ return !row_info[row].endhead && !row_info[row].endfirsthead
+ && !row_info[row].endfoot && !row_info[row].endlastfoot
+ && !row_info[row].caption;
}
OutputParams const & runparams) const
{
idx_type cell = cellIndex(i, 0);
- int ret = TeXTopHLine(os, i);
+ shared_ptr<InsetTableCell> inset = cellInset(cell);
+ Paragraph const & par = inset->paragraphs().front();
+ string const lang = par.getParLanguage(buffer().params())->lang();
+
+ //output the top line
+ int ret = TeXTopHLine(os, i, lang);
+
if (row_info[i].top_space_default) {
if (use_booktabs)
os << "\\addlinespace\n";
&& getPWidth(cell).zero();
if (rtl) {
- if (par.getParLanguage(buffer().params())->lang() ==
- "farsi")
+ string const lang =
+ par.getParLanguage(buffer().params())->lang();
+ if (lang == "farsi")
os << "\\textFR{";
- else if (par.getParLanguage(buffer().params())->lang() == "arabic_arabi")
+ else if (lang == "arabic_arabi")
os << "\\textAR{";
- // currently, remaning RTL languages are arabic_arabtex and hebrew
+ // currently, remaning RTL languages are
+ // arabic_arabtex and hebrew
else
os << "\\R{";
}
- ret += inset->latex(os, runparams);
+ // pass to the OutputParams that we are in a cell and
+ // which alignment we have set.
+ // InsetNewline needs this context information.
+ OutputParams newrp(runparams);
+ newrp.inTableCell = (getAlignment(cell) == LYX_ALIGN_BLOCK)
+ ? OutputParams::PLAIN
+ : OutputParams::ALIGNED;
+ ret += inset->latex(os, newrp);
+ runparams.encoding = newrp.encoding;
if (rtl)
os << '}';
}
os << '\n';
++ret;
- ret += TeXBottomHLine(os, i);
+
+ //output the bottom line
+ ret += TeXBottomHLine(os, i, lang);
+
if (row_info[i].interline_space_default) {
if (use_booktabs)
os << "\\addlinespace\n";
++ret;
}
if (is_long_tabular)
- os << "\\begin{longtable}{";
+ os << "\\begin{longtable}";
else
- os << "\\begin{tabular}{";
+ os << "\\begin{tabular}";
+
+ switch (tabular_valignment) {
+ case LYX_VALIGN_TOP:
+ os << "[t]";
+ break;
+ case LYX_VALIGN_BOTTOM:
+ os << "[b]";
+ break;
+ case LYX_VALIGN_MIDDLE:
+ break;
+ }
+
+ os << "{";
for (col_type i = 0; i < column_info.size(); ++i) {
if (columnLeftLine(i))
//+---------------------------------------------------------------------
// output header info
- if (haveLTHead() || haveLTFirstHead()) {
+ if (haveLTHead() || haveLTFirstHead()|| haveLTCaption()) {
os << "<thead>\n";
++ret;
for (row_type i = 0; i < row_info.size(); ++i) {
- if (row_info[i].endhead || row_info[i].endfirsthead) {
+ if (row_info[i].endhead || row_info[i].endfirsthead
+ || row_info[i].caption) {
ret += docbookRow(os, i, runparams);
}
}
if (needRotating())
features.require("rotating");
for (idx_type cell = 0; cell < numberofcells; ++cell) {
- if (getVAlignment(cell) != LYX_VALIGN_TOP ||
- (!getPWidth(cell).zero() && !isMultiColumn(cell)))
+ if (getVAlignment(cell) != LYX_VALIGN_TOP
+ || !getPWidth(cell).zero())
features.require("array");
cellInset(cell)->validate(features);
}
/////////////////////////////////////////////////////////////////////
InsetTableCell::InsetTableCell(Buffer & buf)
- : InsetText(buf), isFixedWidth(false)
+ : InsetText(buf), isFixedWidth(false),
+ contentAlign(LYX_ALIGN_CENTER)
{}
return !isFixedWidth;
}
+
bool InsetTableCell::allowParagraphCustomization(idx_type) const
{
return isFixedWidth;
}
-int InsetTableCell::latex(odocstream & od, OutputParams const & rp) const
-{
- OutputParams newrp = rp;
- newrp.inTableCell = true;
- return InsetText::latex(od, newrp);
-}
bool InsetTableCell::getStatus(Cursor & cur, FuncRequest const & cmd,
FuncStatus & status) const
dim.wid = tabular.width() + 2 * ADD_TO_TABULAR_WIDTH;
}
+bool InsetTabular::isCellSelected(Cursor & cur, row_type row, col_type col)
+ const
+{
+ if (&cur.inset() == this && cur.selection()) {
+ if (cur.selIsMultiCell()) {
+ row_type rs, re;
+ col_type cs, ce;
+ getSelection(cur, rs, re, cs, ce);
+
+ if (col >= cs && col <= ce && row >= rs && row <= re)
+ return true;
+ } else
+ if (col == tabular.cellColumn(cur.idx())
+ && row == tabular.cellRow(cur.idx())) {
+ CursorSlice const & beg = cur.selBegin();
+ CursorSlice const & end = cur.selEnd();
+
+ if ((end.lastpos() > 0 || end.lastpit() > 0)
+ && end.pos() == end.lastpos() && beg.pos() == 0
+ && end.pit() == end.lastpit() && beg.pit() == 0)
+ return true;
+ }
+ }
+ return false;
+}
+
void InsetTabular::draw(PainterInfo & pi, int x, int y) const
{
//lyxerr << "InsetTabular::draw: " << x << " " << y << endl;
BufferView * bv = pi.base.bv;
+ Cursor & cur = pi.base.bv->cursor();
// FIXME: As the full backrgound is painted in drawSelection(),
// we have no choice but to do a full repaint for the Text cells.
x += ADD_TO_TABULAR_WIDTH;
bool const original_drawing_state = pi.pain.isDrawingEnabled();
+ bool const original_selection_state = pi.selected;
idx_type idx = 0;
first_visible_cell = Tabular::npos;
if (first_visible_cell == Tabular::npos)
first_visible_cell = idx;
+ pi.selected |= isCellSelected(cur, i, j);
int const cx = nx + tabular.getBeginningOfTextInCell(idx);
// Cache the Inset position.
bv->coordCache().insets().add(cell(idx).get(), cx, y);
|| y - a > bv->workHeight()) {
pi.pain.setDrawingEnabled(false);
cell(idx)->draw(pi, cx, y);
- drawCellLines(pi.pain, nx, y, i, idx, pi.erased_);
+ drawCellLines(pi.pain, nx, y, i, idx, pi.change_);
pi.pain.setDrawingEnabled(original_drawing_state);
} else {
cell(idx)->draw(pi, cx, y);
- drawCellLines(pi.pain, nx, y, i, idx, pi.erased_);
+ drawCellLines(pi.pain, nx, y, i, idx, pi.change_);
}
nx += tabular.columnWidth(idx);
++idx;
+ pi.selected = original_selection_state;
}
if (i + 1 < tabular.row_info.size())
void InsetTabular::drawSelection(PainterInfo & pi, int x, int y) const
{
Cursor & cur = pi.base.bv->cursor();
+ resetPos(cur);
x += scx_ + ADD_TO_TABULAR_WIDTH;
int const w = tabular.width();
int const h = tabular.height();
int yy = y - tabular.rowAscent(0);
- pi.pain.fillRectangle(x, yy, w, h, backgroundColor());
+ pi.pain.fillRectangle(x, yy, w, h, pi.backgroundColor(this));
if (!cur.selection())
return;
//resetPos(cur);
+ bool const full_cell_selected = isCellSelected(cur,
+ tabular.cellRow(cur.idx()), tabular.cellColumn(cur.idx()));
- if (cur.selIsMultiCell()) {
- row_type rs, re;
- col_type cs, ce;
- getSelection(cur, rs, re, cs, ce);
+ if (cur.selIsMultiCell() || full_cell_selected) {
y -= tabular.rowAscent(0);
for (row_type j = 0; j < tabular.row_info.size(); ++j) {
int const a = tabular.rowAscent(j);
idx_type const cell =
tabular.cellIndex(j, i);
int const w = tabular.columnWidth(cell);
- if (i >= cs && i <= ce && j >= rs && j <= re)
- pi.pain.fillRectangle(xx, y, w, h,
- Color_selection);
+ if (isCellSelected(cur, j, i))
+ pi.pain.fillRectangle(xx, y, w, h, Color_selection);
xx += w;
}
y += h;
void InsetTabular::drawCellLines(Painter & pain, int x, int y,
- row_type row, idx_type cell, bool erased) const
+ row_type row, idx_type cell, Change const & change) const
{
int x2 = x + tabular.columnWidth(cell);
bool on_off = false;
- ColorCode col = Color_tabularline;
- ColorCode onoffcol = Color_tabularonoffline;
+ Color col = Color_tabularline;
+ Color onoffcol = Color_tabularonoffline;
- if (erased) {
- col = Color_deletedtext;
- onoffcol = Color_deletedtext;
+ if (change.changed()) {
+ col = change.color();
+ onoffcol = change.color();
}
if (!tabular.topAlreadyDrawn(cell)) {
{
//lyxerr << "InsetTabular::edit: " << this << endl;
cur.finishUndo();
- cur.selection() = false;
+ cur.setSelection(false);
cur.push(*this);
if (front) {
if (isRightToLeft(cur))
void InsetTabular::updateLabels(ParIterator const & it)
{
// In a longtable, tell captions what the current float is
- Counters & cnts = buffer().params().documentClass().counters();
+ Counters & cnts = buffer().masterBuffer()->params().documentClass().counters();
string const saveflt = cnts.current_float();
if (tabular.is_long_tabular)
cnts.current_float("table");
it2.forwardPos();
size_t const end = it2.nargs();
for ( ; it2.idx() < end; it2.top().forwardIdx())
- lyx::updateLabels(buffer(), it2);
+ buffer().updateLabels(it2);
//reset afterwards
if (tabular.is_long_tabular)
cur.resetAnchor();
cur.idx() = tabular.getLastCellInRow(r);
cur.pos() = cur.lastpos();
- cur.selection() = true;
+ cur.setSelection(true);
bvcur = cur;
rowselect_ = true;
break;
cur.resetAnchor();
cur.idx() = tabular.cellIndex(tabular.row_info.size() - 1, c);
cur.pos() = cur.lastpos();
- cur.selection() = true;
+ cur.setSelection(true);
bvcur = cur;
colselect_ = true;
break;
cur.pit() = 0;
cur.pos() = 0;
bvcur.setCursor(cur);
- bvcur.selection() = true;
+ bvcur.setSelection(true);
break;
}
// select (additional) column
cur.pit() = 0;
cur.pos() = 0;
bvcur.setCursor(cur);
- bvcur.selection() = true;
+ bvcur.setSelection(true);
break;
}
// only update if selection changes
cur.noUpdate();
setCursorFromCoordinates(cur, cmd.x, cmd.y);
bvcur.setCursor(cur);
- bvcur.selection() = true;
+ bvcur.setSelection(true);
// if this is a multicell selection, we just set the cursor to
// the beginning of the cell's text.
if (bvcur.selIsMultiCell()) {
- bvcur.pit() = 0;
- bvcur.pos() = 0;
+ bvcur.pit() = bvcur.lastpit();
+ bvcur.pos() = bvcur.lastpos();
}
}
break;
case LFUN_CELL_BACKWARD:
movePrevCell(cur);
- cur.selection() = false;
+ cur.setSelection(false);
break;
case LFUN_CELL_FORWARD:
moveNextCell(cur);
- cur.selection() = false;
+ cur.setSelection(false);
break;
case LFUN_CHAR_FORWARD_SELECT:
// LEFT or RIGHT commands --- the interpretation will depend on the
// table's direction.
else {
- bool right = (cmd.action == LFUN_CHAR_RIGHT
- || cmd.action == LFUN_CHAR_RIGHT_SELECT);
- next_cell = (isRightToLeft(cur) != right);
+ bool const right = cmd.action == LFUN_CHAR_RIGHT
+ || cmd.action == LFUN_CHAR_RIGHT_SELECT;
+ next_cell = isRightToLeft(cur) != right;
- if (lyxrc.visual_cursor) {
+ if (lyxrc.visual_cursor)
entry_from = right ? ENTRY_DIRECTION_LEFT:ENTRY_DIRECTION_RIGHT;
- }
- if (right)
- finish_lfun = LFUN_FINISHED_RIGHT;
- else
- finish_lfun = LFUN_FINISHED_LEFT;
+ finish_lfun = right ? LFUN_FINISHED_RIGHT : LFUN_FINISHED_LEFT;
}
- // if we don't have a multicell selection...
- if (!cur.selIsMultiCell() ||
- // ...or we're not doing some LFUN_*_SELECT thing, anyway...
- (cmd.action != LFUN_CHAR_FORWARD_SELECT &&
- cmd.action != LFUN_CHAR_BACKWARD_SELECT &&
- cmd.action != LFUN_CHAR_RIGHT_SELECT &&
- cmd.action != LFUN_CHAR_LEFT_SELECT)) {
+ bool const select = cmd.action == LFUN_CHAR_FORWARD_SELECT ||
+ cmd.action == LFUN_CHAR_BACKWARD_SELECT ||
+ cmd.action == LFUN_CHAR_RIGHT_SELECT ||
+ cmd.action == LFUN_CHAR_LEFT_SELECT;
+
+ // If we have a multicell selection or we're
+ // not doing some LFUN_*_SELECT thing anyway...
+ if (!cur.selIsMultiCell() || !select) {
+ col_type const c = tabular.cellColumn(cur.idx());
+ row_type const r = tabular.cellRow(cur.idx());
+ // Are we trying to select the whole cell and is the whole cell
+ // not yet selected?
+ bool const select_whole = select && !isCellSelected(cur, r, c) &&
+ ((next_cell && cur.pit() == cur.lastpit()
+ && cur.pos() == cur.lastpos())
+ || (!next_cell && cur.pit() == 0 && cur.pos() == 0));
+
// ...try to dispatch to the cell's inset.
cell(cur.idx())->dispatch(cur, cmd);
- if (cur.result().dispatched())
+
+ bool const empty_cell = cur.lastpos() == 0 && cur.lastpit() == 0;
+
+ // When we already have a selection we want to select the whole cell
+ // before going to the next cell.
+ if (select_whole && !empty_cell){
+ getText(cur.idx())->selectAll(cur);
+ cur.dispatched();
+ break;
+ }
+
+ // FIXME: When we support the selection of an empty cell, remove
+ // the !empty_cell from this condition. For now we jump to the next
+ // cell if the current cell is empty.
+ if (cur.result().dispatched() && !empty_cell)
break;
}
+
// move to next/prev cell, as appropriate
// note that we will always do this if we're selecting and we have
// a multicell selection
case LFUN_DOWN_SELECT:
case LFUN_DOWN:
- cell(cur.idx())->dispatch(cur, cmd);
+ if (!(cur.selection() && cur.selIsMultiCell()))
+ cell(cur.idx())->dispatch(cur, cmd);
+
cur.dispatched(); // override the cell's decision
- if (sl == cur.top())
+ if (sl == cur.top()) {
// if our Text didn't do anything to the cursor
// then we try to put the cursor into the cell below
// setting also the right targetX.
+ cur.selHandle(cmd.action == LFUN_DOWN_SELECT);
if (tabular.cellRow(cur.idx()) != tabular.row_info.size() - 1) {
cur.idx() = tabular.cellBelow(cur.idx());
cur.pit() = 0;
cur.bv().textMetrics(cell(cur.idx())->getText(0));
cur.pos() = tm.x2pos(cur.pit(), 0, cur.targetX());
}
+ }
if (sl == cur.top()) {
// we trick it to go to forward after leaving the
// tabular.
cmd = FuncRequest(LFUN_FINISHED_FORWARD);
cur.undispatched();
}
+ if (cur.selIsMultiCell()) {
+ cur.pit() = cur.lastpit();
+ cur.pos() = cur.lastpos();
+ return;
+ }
break;
case LFUN_UP_SELECT:
case LFUN_UP:
- cell(cur.idx())->dispatch(cur, cmd);
+ if (!(cur.selection() && cur.selIsMultiCell()))
+ cell(cur.idx())->dispatch(cur, cmd);
cur.dispatched(); // override the cell's decision
- if (sl == cur.top())
+ if (sl == cur.top()) {
// if our Text didn't do anything to the cursor
// then we try to put the cursor into the cell above
// setting also the right targetX.
+ cur.selHandle(cmd.action == LFUN_UP_SELECT);
if (tabular.cellRow(cur.idx()) != 0) {
cur.idx() = tabular.cellAbove(cur.idx());
cur.pit() = cur.lastpit();
tm.parMetrics(cur.lastpit());
cur.pos() = tm.x2pos(cur.pit(), pm.rows().size()-1, cur.targetX());
}
+ }
if (sl == cur.top()) {
cmd = FuncRequest(LFUN_UP);
cur.undispatched();
}
+ if (cur.selIsMultiCell()) {
+ cur.pit() = 0;
+ cur.pos() = cur.lastpos();
+ return;
+ }
break;
// case LFUN_SCREEN_DOWN: {
cell(cur.idx())->dispatch(cur, cmd);
break;
+ case LFUN_SELF_INSERT:
+ if (cur.selIsMultiCell()) {
+ cur.recordUndoInset(DELETE_UNDO);
+ cutSelection(cur);
+ }
+ cell(cur.idx())->dispatch(cur, cmd);
+ break;
+
case LFUN_CHAR_DELETE_BACKWARD:
case LFUN_CHAR_DELETE_FORWARD:
if (cur.selIsMultiCell()) {
break;
}
if (theClipboard().isInternal() ||
- !theClipboard().hasInternal() && theClipboard().hasLyXContents()) {
+ (!theClipboard().hasInternal() && theClipboard().hasLyXContents())) {
cur.recordUndoInset(INSERT_UNDO);
pasteClipboard(cur);
}
case LFUN_FONT_EMPH:
case LFUN_FONT_BOLD:
+ case LFUN_FONT_BOLDSYMBOL:
case LFUN_FONT_ROMAN:
case LFUN_FONT_NOUN:
case LFUN_FONT_ITAL:
status.setOnOff(tabular.rotate);
break;
+ case Tabular::TABULAR_VALIGN_TOP:
+ status.setOnOff(tabular.tabular_valignment
+ == Tabular::LYX_VALIGN_TOP);
+ break;
+ case Tabular::TABULAR_VALIGN_MIDDLE:
+ status.setOnOff(tabular.tabular_valignment
+ == Tabular::LYX_VALIGN_MIDDLE);
+ break;
+ case Tabular::TABULAR_VALIGN_BOTTOM:
+ status.setOnOff(tabular.tabular_valignment
+ == Tabular::LYX_VALIGN_BOTTOM);
+ break;
+
case Tabular::UNSET_ROTATE_TABULAR:
status.setOnOff(!tabular.rotate);
break;
status.setOnOff(convert<int>(argument) == tabular.getUsebox(cur.idx()));
break;
- case Tabular::SET_LTFIRSTHEAD:
- status.setOnOff(tabular.getRowOfLTHead(sel_row_start, dummyltt));
+ // every row can only be one thing:
+ // either a footer or header or caption
+ case Tabular::SET_LTFIRSTHEAD:
+ status.setEnabled(sel_row_start == sel_row_end
+ && !tabular.getRowOfLTHead(sel_row_start, dummyltt)
+ && !tabular.getRowOfLTFoot(sel_row_start, dummyltt)
+ && !tabular.getRowOfLTLastFoot(sel_row_start, dummyltt)
+ && !tabular.ltCaption(sel_row_start));
+ status.setOnOff(tabular.getRowOfLTFirstHead(sel_row_start, dummyltt));
break;
case Tabular::UNSET_LTFIRSTHEAD:
- status.setOnOff(!tabular.getRowOfLTHead(sel_row_start, dummyltt));
+ status.setOnOff(!tabular.getRowOfLTFirstHead(sel_row_start, dummyltt));
break;
case Tabular::SET_LTHEAD:
+ status.setEnabled(sel_row_start == sel_row_end
+ && !tabular.getRowOfLTFirstHead(sel_row_start, dummyltt)
+ && !tabular.getRowOfLTFoot(sel_row_start, dummyltt)
+ && !tabular.getRowOfLTLastFoot(sel_row_start, dummyltt)
+ && !tabular.ltCaption(sel_row_start));
status.setOnOff(tabular.getRowOfLTHead(sel_row_start, dummyltt));
break;
break;
case Tabular::SET_LTFOOT:
+ status.setEnabled(sel_row_start == sel_row_end
+ && !tabular.getRowOfLTFirstHead(sel_row_start, dummyltt)
+ && !tabular.getRowOfLTHead(sel_row_start, dummyltt)
+ && !tabular.getRowOfLTLastFoot(sel_row_start, dummyltt)
+ && !tabular.ltCaption(sel_row_start));
status.setOnOff(tabular.getRowOfLTFoot(sel_row_start, dummyltt));
break;
break;
case Tabular::SET_LTLASTFOOT:
- status.setOnOff(tabular.getRowOfLTFoot(sel_row_start, dummyltt));
+ status.setEnabled(sel_row_start == sel_row_end
+ && !tabular.getRowOfLTFirstHead(sel_row_start, dummyltt)
+ && !tabular.getRowOfLTHead(sel_row_start, dummyltt)
+ && !tabular.getRowOfLTFoot(sel_row_start, dummyltt)
+ && !tabular.ltCaption(sel_row_start));
+ status.setOnOff(tabular.getRowOfLTLastFoot(sel_row_start, dummyltt));
break;
case Tabular::UNSET_LTLASTFOOT:
- status.setOnOff(!tabular.getRowOfLTFoot(sel_row_start, dummyltt));
+ status.setOnOff(!tabular.getRowOfLTLastFoot(sel_row_start, dummyltt));
break;
case Tabular::SET_LTNEWPAGE:
break;
case Tabular::TOGGLE_LTCAPTION:
- status.setEnabled(sel_row_start == sel_row_end);
+ status.setEnabled(sel_row_start == sel_row_end
+ && !tabular.getRowOfLTFirstHead(sel_row_start, dummyltt)
+ && !tabular.getRowOfLTHead(sel_row_start, dummyltt)
+ && !tabular.getRowOfLTFoot(sel_row_start, dummyltt)
+ && !tabular.getRowOfLTLastFoot(sel_row_start, dummyltt));
status.setOnOff(tabular.ltCaption(sel_row_start));
break;
case LFUN_OPTIONAL_INSERT:
case LFUN_BOX_INSERT:
case LFUN_BRANCH_INSERT:
+ case LFUN_PHANTOM_INSERT:
case LFUN_WRAP_INSERT:
case LFUN_ERT_INSERT: {
if (cur.selIsMultiCell()) {
Inset * InsetTabular::editXY(Cursor & cur, int x, int y)
{
//lyxerr << "InsetTabular::editXY: " << this << endl;
- cur.selection() = false;
+ cur.setSelection(false);
cur.push(*this);
cur.idx() = getNearestCell(cur.bv(), x, y);
resetPos(cur);
return;
++cur.idx();
}
+
+ cur.boundary(false);
+
+ if (cur.selIsMultiCell()) {
+ cur.pit() = cur.lastpit();
+ cur.pos() = cur.lastpos();
+ resetPos(cur);
+ return;
+ }
+
cur.pit() = 0;
cur.pos() = 0;
- cur.boundary(false);
// in visual mode, place cursor at extreme left or right
return;
--cur.idx();
}
+
+ if (cur.selIsMultiCell()) {
+ cur.pit() = cur.lastpit();
+ cur.pos() = cur.lastpos();
+ resetPos(cur);
+ return;
+ }
+
cur.pit() = cur.lastpit();
cur.pos() = cur.lastpos();
cur.idx() = tabular.cellIndex(sel_row_start, column);
cur.pit() = 0;
cur.pos() = 0;
- cur.selection() = false;
+ cur.setSelection(false);
break;
case Tabular::DELETE_COLUMN:
cur.idx() = tabular.cellIndex(row, sel_col_start);
cur.pit() = 0;
cur.pos() = 0;
- cur.selection() = false;
+ cur.setSelection(false);
break;
case Tabular::COPY_ROW:
cur.idx() = s_start;
cur.pit() = 0;
cur.pos() = 0;
- cur.selection() = false;
+ cur.setSelection(false);
break;
}
tabular.rotate = !tabular.rotate;
break;
+ case Tabular::TABULAR_VALIGN_TOP:
+ tabular.tabular_valignment = Tabular::LYX_VALIGN_TOP;
+ break;
+
+ case Tabular::TABULAR_VALIGN_MIDDLE:
+ tabular.tabular_valignment = Tabular::LYX_VALIGN_MIDDLE;
+ break;
+
+ case Tabular::TABULAR_VALIGN_BOTTOM:
+ tabular.tabular_valignment = Tabular::LYX_VALIGN_BOTTOM;
+ break;
+
case Tabular::SET_ROTATE_CELL:
for (row_type i = sel_row_start; i <= sel_row_end; ++i)
for (col_type j = sel_col_start; j <= sel_col_end; ++j)
cur.idx() = tabular.setLTCaption(row, !tabular.ltCaption(row));
cur.pit() = 0;
cur.pos() = 0;
- cur.selection() = false;
+ cur.setSelection(false);
break;
case Tabular::SET_BOOKTABS:
new InsetTableCell(*paste_tabular->cellInset(r1, c1)));
tabular.setCellInset(r2, c2, inset);
// FIXME: change tracking (MG)
- inset->setChange(Change(cur.buffer().params().trackChanges ?
+ inset->setChange(Change(buffer().params().trackChanges ?
Change::INSERTED : Change::UNCHANGED));
cur.pos() = 0;
}
for (col_type j = cs; j <= ce; ++j) {
shared_ptr<InsetTableCell> t
= cell(tabular.cellIndex(i, j));
- if (cur.buffer().params().trackChanges)
+ if (buffer().params().trackChanges)
// FIXME: Change tracking (MG)
t->setChange(Change(Change::DELETED));
else
LASSERT(cur.depth() > 1, /**/);
Paragraph const & parentpar = cur[cur.depth() - 2].paragraph();
pos_type const parentpos = cur[cur.depth() - 2].pos();
- return parentpar.getFontSettings(cur.bv().buffer().params(),
+ return parentpar.getFontSettings(buffer().params(),
parentpos).language()->rightToLeft();
}
projects / lyx.git / blobdiff