{
// the SET/UNSET actions are used by the table dialog,
// the TOGGLE actions by the table toolbar buttons
+ // FIXME: these values have been hardcoded in InsetMathGrid and other
+ // math insets.
{ Tabular::APPEND_ROW, "append-row", false },
{ Tabular::APPEND_COLUMN, "append-column", false },
{ Tabular::DELETE_ROW, "delete-row", false },
{ Tabular::SET_MROFFSET, "set-mroffset", true },
{ Tabular::SET_ALL_LINES, "set-all-lines", false },
{ Tabular::UNSET_ALL_LINES, "unset-all-lines", false },
+ { Tabular::TOGGLE_LONGTABULAR, "toggle-longtabular", false },
{ Tabular::SET_LONGTABULAR, "set-longtabular", false },
{ Tabular::UNSET_LONGTABULAR, "unset-longtabular", false },
{ Tabular::SET_PWIDTH, "set-pwidth", true },
{ Tabular::UNSET_LTCAPTION, "unset-ltcaption", false },
{ Tabular::SET_SPECIAL_COLUMN, "set-special-column", true },
{ Tabular::SET_SPECIAL_MULTICOLUMN, "set-special-multicolumn", true },
+ { Tabular::TOGGLE_BOOKTABS, "toggle-booktabs", false },
{ Tabular::SET_BOOKTABS, "set-booktabs", false },
{ Tabular::UNSET_BOOKTABS, "unset-booktabs", false },
{ Tabular::SET_TOP_SPACE, "set-top-space", true },
Tabular::ltType::ltType()
- : topDL(false),
+ : set(false), topDL(false),
bottomDL(false),
empty(false)
{}
*/
void toggleFixedWidth(Cursor & cur, InsetTableCell * inset, bool fixedWidth)
{
- inset->setAutoBreakRows(fixedWidth);
inset->toggleFixedWidth(fixedWidth);
if (fixedWidth)
return;
shared_ptr<InsetTableCell> inset = cellInset(cell);
Paragraph const & par = inset->paragraphs().front();
+
+ os.texrow().forceStart(par.id(), 0);
+
bool rtl = par.isRTL(buffer().params())
&& !par.empty()
&& getPWidth(cell).zero()
void Tabular::latex(otexstream & os, OutputParams const & runparams) const
{
bool const is_tabular_star = !tabular_width.zero();
+ TexRow::RowEntry pos = TexRow::textEntry(runparams.lastid,
+ runparams.lastpos);
//+---------------------------------------------------------------------
//+ first the opening preamble +
//+---------------------------------------------------------------------
os << safebreakln;
- if (runparams.lastid != -1)
- os.texrow().start(runparams.lastid, runparams.lastpos);
+ if (!TexRow::isNone(pos))
+ os.texrow().start(pos);
if (rotate != 0)
os << "\\begin{turn}{" << convert<string>(rotate) << "}\n";
if (rotate != 0)
os << breakln << "\\end{turn}";
+
+ if (!TexRow::isNone(pos))
+ os.texrow().start(pos);
}
}
+bool InsetTableCell::forceLocalFontSwitch() const
+{
+ return isFixedWidth;
+}
+
+
bool InsetTableCell::getStatus(Cursor & cur, FuncRequest const & cmd,
FuncStatus & status) const
{
}
-void InsetTableCell::addToToc(DocIterator const & di, bool output_active) const
+void InsetTableCell::addToToc(DocIterator const & di, bool output_active,
+ UpdateType utype) const
{
- InsetText::iterateForToc(di, output_active);
+ InsetText::iterateForToc(di, output_active, utype);
}
InsetTabular::InsetTabular(Buffer * buf, row_type rows,
col_type columns)
: Inset(buf), tabular(buf, max(rows, row_type(1)), max(columns, col_type(1))),
- rowselect_(false), colselect_(false)
+ first_visible_cell_(0), offset_valign_(0), rowselect_(false), colselect_(false)
{
}
bool const original_selection_state = pi.selected;
idx_type idx = 0;
- first_visible_cell = Tabular::npos;
+ first_visible_cell_ = Tabular::npos;
int yy = y + offset_valign_;
for (row_type r = 0; r < tabular.nrows(); ++r) {
continue;
}
- if (first_visible_cell == Tabular::npos)
- first_visible_cell = idx;
+ if (first_visible_cell_ == Tabular::npos)
+ first_visible_cell_ = idx;
pi.selected |= isCellSelected(cur, r, c);
int const cx = nx + tabular.textHOffset(idx);
}
-void InsetTabular::addToToc(DocIterator const & cpit, bool output_active) const
+void InsetTabular::addToToc(DocIterator const & cpit, bool output_active,
+ UpdateType utype) const
{
DocIterator dit = cpit;
dit.forwardPos();
size_t const end = dit.nargs();
for ( ; dit.idx() < end; dit.top().forwardIdx())
- cell(dit.idx())->addToToc(dit, output_active);
+ cell(dit.idx())->addToToc(dit, output_active, utype);
}
|| cmd.x() > xo(cur.bv()) + tabular.width()) {
row_type r = rowFromY(cur, cmd.y());
cur.idx() = tabular.getFirstCellInRow(r);
+ cur.pit() = 0;
cur.pos() = 0;
cur.resetAnchor();
cur.idx() = tabular.getLastCellInRow(r);
+ cur.pit() = cur.lastpit();
cur.pos() = cur.lastpos();
cur.setSelection(true);
bvcur = cur;
|| cmd.y() > y0 + tabular.height()) {
col_type c = columnFromX(cur, cmd.x());
cur.idx() = tabular.cellIndex(0, c);
+ cur.pit() = 0;
cur.pos() = 0;
cur.resetAnchor();
cur.idx() = tabular.cellIndex(tabular.nrows() - 1, c);
+ cur.pit() = cur.lastpit();
cur.pos() = cur.lastpos();
cur.setSelection(true);
bvcur = cur;
// int const t = cur.bv().top_y() + cur.bv().height();
// if (t < yo() + tabular.getHeightOfTabular()) {
// cur.bv().scrollDocView(t, true);
-// cur.idx() = tabular.cellBelow(first_visible_cell) + col;
+// cur.idx() = tabular.cellBelow(first_visible_cell_) + col;
// } else {
// cur.idx() = tabular.getFirstCellInRow(tabular.rows() - 1) + col;
// }
// if (yo() > 0)
// cur.idx() = col;
// else
-// cur.idx() = tabular.cellBelow(first_visible_cell) + col;
+// cur.idx() = tabular.cellBelow(first_visible_cell_) + col;
// } else {
// cur.idx() = col;
// }
cur.bv().showDialog("tabular");
break;
- case LFUN_INSET_MODIFY: {
- string arg;
- if (cmd.getArg(1) == "from-dialog")
- arg = cmd.getArg(0) + to_utf8(cmd.argument().substr(19));
+ case LFUN_INSET_MODIFY:
+ // we come from the dialog
+ if (cmd.getArg(0) == "tabular")
+ tabularFeatures(cur, cmd.getLongArg(1));
else
- arg = to_utf8(cmd.argument());
- if (!tabularFeatures(cur, arg))
cur.undispatched();
break;
- }
+
+ case LFUN_TABULAR_FEATURE:
+ tabularFeatures(cur, to_utf8(cmd.argument()));
+ break;
// insert file functions
case LFUN_FILE_INSERT_PLAINTEXT_PARA:
}
-// function sets an object as defined in func_status.h:
-// states OK, Unknown, Disabled, On, Off.
-bool InsetTabular::getStatus(Cursor & cur, FuncRequest const & cmd,
- FuncStatus & status) const
+bool InsetTabular::getFeatureStatus(Cursor & cur, string const & s,
+ string const & argument, FuncStatus & status) const
{
- switch (cmd.action()) {
- case LFUN_INSET_MODIFY: {
- if (&cur.inset() != this || cmd.getArg(0) != "tabular")
- break;
-
- // FIXME: We only check for the very first argument...
- string const s = cmd.getArg(1);
- // We always enable the lfun if it is coming from the dialog
- // because the dialog makes sure all the settings are valid,
- // even though the first argument might not be valid now.
- if (s == "from-dialog") {
- status.setEnabled(true);
- return true;
- }
int action = Tabular::LAST_ACTION;
int i = 0;
return true;
}
- string const argument = cmd.getLongArg(2);
-
row_type sel_row_start = 0;
row_type sel_row_end = 0;
col_type sel_col_start = 0;
case Tabular::SET_LINE_TOP:
case Tabular::SET_LINE_BOTTOM:
+ status.setEnabled(!tabular.ltCaption(tabular.cellRow(cur.idx())));
+ break;
+
case Tabular::SET_LINE_LEFT:
case Tabular::SET_LINE_RIGHT:
- status.setEnabled(!tabular.ltCaption(tabular.cellRow(cur.idx())));
+ status.setEnabled(!tabular.use_booktabs
+ && !tabular.ltCaption(tabular.cellRow(cur.idx())));
break;
case Tabular::TOGGLE_LINE_TOP:
break;
case Tabular::TOGGLE_LINE_LEFT:
- status.setEnabled(!tabular.ltCaption(tabular.cellRow(cur.idx())));
+ status.setEnabled(!tabular.use_booktabs
+ && !tabular.ltCaption(tabular.cellRow(cur.idx())));
status.setOnOff(tabular.leftLine(cur.idx()));
break;
case Tabular::TOGGLE_LINE_RIGHT:
- status.setEnabled(!tabular.ltCaption(tabular.cellRow(cur.idx())));
+ status.setEnabled(!tabular.use_booktabs
+ && !tabular.ltCaption(tabular.cellRow(cur.idx())));
status.setOnOff(tabular.rightLine(cur.idx()));
break;
break;
case Tabular::SET_LONGTABULAR:
+ case Tabular::TOGGLE_LONGTABULAR:
// setting as longtable is not allowed when table is inside a float
if (cur.innerInsetOfType(FLOAT_CODE) != 0
|| cur.innerInsetOfType(WRAP_CODE) != 0)
status.setOnOff(tabular.ltCaption(sel_row_start));
break;
+ case Tabular::TOGGLE_BOOKTABS:
case Tabular::SET_BOOKTABS:
status.setOnOff(tabular.use_booktabs);
break;
break;
}
return true;
+}
+
+
+// function sets an object as defined in FuncStatus.h:
+// states OK, Unknown, Disabled, On, Off.
+bool InsetTabular::getStatus(Cursor & cur, FuncRequest const & cmd,
+ FuncStatus & status) const
+{
+ switch (cmd.action()) {
+ case LFUN_INSET_MODIFY:
+ if (cmd.getArg(0) != "tabular")
+ break;
+ if (cmd.getArg(1) == "for-dialog") {
+ // The dialog is asking the status of a command
+ if (&cur.inset() != this)
+ break;
+ string action = cmd.getArg(2);
+ string arg = cmd.getLongArg(3);
+ return getFeatureStatus(cur, action, arg, status);
+ } else {
+ // We always enable the lfun if it is coming from the dialog
+ // because the dialog makes sure all the settings are valid,
+ // even though the first argument might not be valid now.
+ status.setEnabled(true);
+ return true;
+ }
+
+ case LFUN_TABULAR_FEATURE: {
+ if (&cur.inset() != this)
+ break;
+ string action = cmd.getArg(0);
+ string arg = cmd.getLongArg(1);
+ return getFeatureStatus(cur, action, arg, status);
}
case LFUN_CAPTION_INSERT: {
}
-bool InsetTabular::tabularFeatures(Cursor & cur, string const & argument)
+void InsetTabular::tabularFeatures(Cursor & cur, string const & argument)
{
+ cur.recordUndoInset(this);
+
istringstream is(argument);
string s;
- is >> s;
- if (insetCode(s) != TABULAR_CODE)
- return false;
-
// Safe guard.
size_t safe_guard = 0;
for (;;) {
if (is.eof())
- break;
+ return;
safe_guard++;
if (safe_guard > 1000) {
LYXERR0("parameter max count reached!");
- break;
+ return;
}
is >> s;
Tabular::Feature action = Tabular::LAST_ACTION;
LYXERR(Debug::DEBUG, "Feature: " << s << "\t\tvalue: " << val);
tabularFeatures(cur, action, val);
}
- return true;
}
break;
case Tabular::ALIGN_DECIMAL:
- if (tabular.column_info[tabular.cellColumn(cur.idx())].alignment == LYX_ALIGN_DECIMAL)
- setAlign = LYX_ALIGN_CENTER;
- else
- setAlign = LYX_ALIGN_DECIMAL;
+ setAlign = LYX_ALIGN_DECIMAL;
break;
case Tabular::M_VALIGN_TOP:
break;
}
- cur.recordUndoInset(ATOMIC_UNDO, this);
-
getSelection(cur, sel_row_start, sel_row_end, sel_col_start, sel_col_end);
row_type const row = tabular.cellRow(cur.idx());
col_type const column = tabular.cellColumn(cur.idx());
}
break;
+ case Tabular::TOGGLE_LONGTABULAR:
+ if (tabular.is_long_tabular)
+ tabularFeatures(cur, Tabular::UNSET_LONGTABULAR);
+ else
+ tabular.is_long_tabular = true;
+ break;
+
case Tabular::SET_LONGTABULAR:
tabular.is_long_tabular = true;
break;
cur.setSelection(false);
// If a row is set as caption, then also insert
// a caption. Otherwise the LaTeX output is broken.
- lyx::dispatch(FuncRequest(LFUN_INSET_SELECT_ALL));
+ // Select cell if it is non-empty
+ if (cur.lastpos() > 0 || cur.lastpit() > 0)
+ lyx::dispatch(FuncRequest(LFUN_INSET_SELECT_ALL));
lyx::dispatch(FuncRequest(LFUN_CAPTION_INSERT));
break;
}
break;
}
+ case Tabular::TOGGLE_BOOKTABS:
+ tabular.use_booktabs = !tabular.use_booktabs;
+ break;
+
case Tabular::SET_BOOKTABS:
tabular.use_booktabs = true;
break;
if (usePaste) {
paste_tabular.reset(new Tabular(buffer_, rows, maxCols));
loctab = paste_tabular.get();
- cols = 0;
dirtyTabularStack(true);
} else {
loctab = &tabular;
projects / lyx.git / blobdiff