#include "frontends/Painter.h"
#include "support/std_sstream.h"
+
#include <iostream>
using lyx::graphics::PreviewLoader;
using lyx::support::strToInt;
using lyx::support::strToDbl;
+using std::auto_ptr;
using std::endl;
using std::max;
-using std::swap;
using std::string;
-using std::auto_ptr;
using std::istringstream;
using std::ostream;
using std::ostringstream;
+using std::swap;
+using std::vector;
namespace {
{ LyXTabular::LAST_ACTION, "" }
};
-struct FindFeature {
- ///
- FindFeature(LyXTabular::Feature feature)
- : feature_(feature)
- {}
- ///
- bool operator()(TabularFeature & tf)
- {
+
+class FeatureEqual : public std::unary_function<TabularFeature, bool> {
+public:
+ FeatureEqual(LyXTabular::Feature feature)
+ : feature_(feature) {}
+ bool operator()(TabularFeature const & tf) const {
return tf.action == feature_;
}
private:
- ///
LyXTabular::Feature feature_;
};
string const featureAsString(LyXTabular::Feature feature)
{
- TabularFeature * it = tabularFeature;
- TabularFeature * end = it +
+ TabularFeature * end = tabularFeature +
sizeof(tabularFeature) / sizeof(TabularFeature);
- it = std::find_if(it, end, FindFeature(feature));
+ TabularFeature * it = std::find_if(tabularFeature, end,
+ FeatureEqual(feature));
return (it == end) ? string() : it->feature;
}
InsetTabular::InsetTabular(Buffer const & buf, int rows, int columns)
: tabular(buf.params(), max(rows, 1), max(columns, 1)),
- buffer_(&buf), cursorx_(0), cursory_(0)
+ buffer_(&buf), cursorx_(0), cursory_(0), tablemode(false)
{
tabular.setOwner(this);
- the_locking_inset = 0;
- actrow = 0;
- actcell = 0;
clearSelection();
in_reset_pos = 0;
}
InsetTabular::InsetTabular(InsetTabular const & tab)
: UpdatableInset(tab), tabular(tab.tabular),
- buffer_(tab.buffer_), cursorx_(0), cursory_(0)
+ buffer_(tab.buffer_), cursorx_(0), cursory_(0), tablemode(false)
{
tabular.setOwner(this);
- the_locking_inset = 0;
- actrow = 0;
- actcell = 0;
clearSelection();
in_reset_pos = 0;
}
break;
if (tabular.isPartOfMultiColumn(i, j))
continue;
- int cx = nx + tabular.getBeginningOfTextInCell(cell);
if (first_visible_cell < 0)
first_visible_cell = cell;
- if (hasSelection()) {
+ if (hasSelection())
drawCellSelection(pi.pain, nx, y, i, j, cell);
- }
+ int const cx = nx + tabular.getBeginningOfTextInCell(cell);
tabular.getCellInset(cell).draw(pi, cx, y);
drawCellLines(pi.pain, nx, y, i, cell);
nx += tabular.getWidthOfColumn(cell);
void InsetTabular::drawCellSelection(Painter & pain, int x, int y,
int row, int column, int cell) const
{
+ if (!tablemode)
+ return;
+
BOOST_ASSERT(hasSelection());
int cs = tabular.column_of_cell(sel_cell_start);
int ce = tabular.column_of_cell(sel_cell_end);
}
-void InsetTabular::updateLocal(BufferView * bv) const
+void InsetTabular::updateLocal(LCursor & cur) const
{
- bv->update();
- resetPos(bv);
+ cur.bv().update();
+ resetPos(cur);
}
-int InsetTabular::insetInInsetY() const
-{
- if (the_locking_inset)
- return cursory_ + the_locking_inset->insetInInsetY();
- return 0;
-}
+extern CursorBase theTempCursor;
-bool InsetTabular::insertInset(BufferView * bv, InsetOld * inset)
-{
- return the_locking_inset && the_locking_inset->insertInset(bv, inset);
-}
-
-
-void InsetTabular::lfunMousePress(FuncRequest const & cmd)
+void InsetTabular::lfunMousePress(LCursor & cur, FuncRequest const & cmd)
{
if (hasSelection() && cmd.button() == mouse_button::button3)
return;
- if (hasSelection())
- clearSelection();
-
- BufferView * bv = cmd.view();
-
- the_locking_inset = 0;
- setPos(bv, cmd.x, cmd.y);
+ int cell = getCell(cmd.x + xo_, cmd.y + yo_);
clearSelection();
- the_locking_inset = 0;
-
- if (cmd.button() == mouse_button::button2)
- dispatch(FuncRequest(bv, LFUN_PASTESELECTION, "paragraph"));
-}
+ lyxerr << "# InsetTabular::lfunMousePress cell: " << cell << endl;
+ if (cell == -1) {
+ tablemode = true;
+ cur.cursor_ = theTempCursor;
+ cur.push(this);
+ cur.idx() = cell;
+ } else {
+ tablemode = false;
+ setPos(cur.bv(), cmd.x, cmd.y);
+ cur.cursor_ = theTempCursor;
+ cur.idx() = cell;
+ }
+ cur.resetAnchor();
+ lyxerr << cur << endl;
-void InsetTabular::lfunMouseRelease(FuncRequest const & cmd)
-{
- if (cmd.button() == mouse_button::button3)
- InsetTabularMailer(*this).showDialog(cmd.view());
+ if (cmd.button() == mouse_button::button2)
+ dispatch(cur, FuncRequest(LFUN_PASTESELECTION, "paragraph"));
}
-void InsetTabular::lfunMouseMotion(FuncRequest const & cmd)
+void InsetTabular::lfunMouseMotion(LCursor & cur, FuncRequest const & cmd)
{
- BufferView * bv = cmd.view();
- int const old_cell = actcell;
+ int const actcell = getCell(cmd.x + xo_, cmd.y + yo_);
+ lyxerr << "# InsetTabular::lfunMouseMotion cell: " << actcell << endl;
- setPos(bv, cmd.x, cmd.y);
- if (!hasSelection())
+ setPos(cur.bv(), cmd.x, cmd.y);
+ if (!hasSelection()) {
setSelection(actcell, actcell);
- else if (old_cell != actcell)
+ cur.setSelection();
+ } else {
+ cur.idx() = actcell;
setSelection(sel_cell_start, actcell);
+ tablemode = (sel_cell_start != actcell);
+ }
}
-void InsetTabular::edit(BufferView * bv, bool left)
+void InsetTabular::lfunMouseRelease(LCursor & cur, FuncRequest const & cmd)
{
- lyxerr << "InsetTabular::edit: " << this
- << " first text: " << tabular.cell_info[0][0].inset.getText(0)
- << " first cell: " << &tabular.cell_info[0][0].inset << endl;
+ int const actcell = getCell(cmd.x + xo_, cmd.y + yo_);
+ lyxerr << "# InsetTabular::lfunMouseRelease cell: " << actcell << endl;
+ if (cmd.button() == mouse_button::button3)
+ InsetTabularMailer(*this).showDialog(&cur.bv());
+}
- finishUndo();
- the_locking_inset = 0;
+void InsetTabular::edit(LCursor & cur, bool left)
+{
+ lyxerr << "InsetTabular::edit: " << this << endl;
+ finishUndo();
+ //tablemode = false;
+ int cell;
if (left) {
- if (isRightToLeft(bv))
- actcell = tabular.getLastCellInRow(0);
+ if (isRightToLeft(cur))
+ cell = tabular.getLastCellInRow(0);
else
- actcell = 0;
+ cell = 0;
} else {
- if (isRightToLeft(bv))
- actcell = tabular.getFirstCellInRow(tabular.rows()-1);
+ if (isRightToLeft(cur))
+ cell = tabular.getFirstCellInRow(tabular.rows()-1);
else
- actcell = tabular.getNumberOfCells() - 1;
+ cell = tabular.getNumberOfCells() - 1;
}
clearSelection();
- resetPos(bv);
- bv->fitCursor();
- bv->cursor().push(this);
+ resetPos(cur);
+ cur.bv().fitCursor();
+ cur.push(this);
+ cur.idx() = cell;
}
-void InsetTabular::edit(BufferView * bv, int x, int y)
+void InsetTabular::edit(LCursor & cur, int x, int y)
{
lyxerr << "InsetTabular::edit: " << this << " first cell "
<< &tabular.cell_info[0][0].inset << endl;
finishUndo();
- the_locking_inset = 0;
- setPos(bv, x, y);
+ setPos(cur.bv(), x, y);
clearSelection();
finishUndo();
- int xx = cursorx_ - xo_ + tabular.getBeginningOfTextInCell(actcell);
- bv->cursor().push(this);
- if (x > xx)
- activateCellInset(bv, x - xx, y - cursory_);
+ //int xx = cursorx_ - xo_ + tabular.getBeginningOfTextInCell(actcell);
+ cur.push(this);
+ //if (x > xx)
+ // activateCellInset(bv, cell, x - xx, y - cursory_);
}
DispatchResult
-InsetTabular::priv_dispatch(FuncRequest const & cmd, idx_type &, pos_type &)
+InsetTabular::priv_dispatch(LCursor & cur, FuncRequest const & cmd)
{
- lyxerr << "InsetTabular::dispatch: " << cmd << endl;
- // We need to save the value of the_locking_inset as the call to
- // the_locking_inset->localDispatch might unlock it.
- DispatchResult result(true, true);
- BufferView * bv = cmd.view();
- bool hs = hasSelection();
+ lyxerr << "# InsetTabular::dispatch: " << cmd
+ << " tablemode: " << tablemode << endl;
+ DispatchResult result(true, true);
switch (cmd.action) {
case LFUN_MOUSE_PRESS:
- lfunMousePress(cmd);
+ lfunMousePress(cur, cmd);
return DispatchResult(true, true);
case LFUN_MOUSE_MOTION:
- lfunMouseMotion(cmd);
+ lfunMouseMotion(cur, cmd);
return DispatchResult(true, true);
case LFUN_MOUSE_RELEASE:
- lfunMouseRelease(cmd);
+ lfunMouseRelease(cur, cmd);
return DispatchResult(true, true);
- case LFUN_CELL_BACKWARD:
- case LFUN_CELL_FORWARD:
- if (cmd.action == LFUN_CELL_FORWARD)
- moveNextCell(bv, the_locking_inset != 0);
- else
- movePrevCell(bv, the_locking_inset != 0);
- clearSelection();
- if (!the_locking_inset)
- return DispatchResult(true);
- return result;
-
- case LFUN_SCROLL_INSET:
- if (!cmd.argument.empty()) {
- if (cmd.argument.find('.') != cmd.argument.npos)
- scroll(cmd.view(), static_cast<float>(strToDbl(cmd.argument)));
+ default:
+ break;
+ }
+
+ if (!tablemode) {
+
+ int cell = cur.idx();
+ lyxerr << "# InsetTabular::dispatch: A " << cur << endl;
+ result = tabular.getCellInset(cell).dispatch(cur, cmd);
+
+ switch (result.val()) {
+ case FINISHED:
+ if (movePrevCell(cur))
+ result = DispatchResult(true, true);
else
- scroll(cmd.view(), strToInt(cmd.argument));
- cmd.view()->update();
- return DispatchResult(true, true);
- }
+ result = DispatchResult(false, FINISHED);
+ break;
- case LFUN_RIGHTSEL: {
- int const start = hasSelection() ? sel_cell_start : actcell;
- if (tabular.isLastCellInRow(actcell)) {
- setSelection(start, actcell);
+ case FINISHED_RIGHT:
+ if (moveNextCell(cur))
+ result = DispatchResult(true, true);
+ else
+ result = DispatchResult(false, FINISHED_RIGHT);
break;
- }
- int end = actcell;
- // if we are starting a selection, only select
- // the current cell at the beginning
- if (hasSelection()) {
- moveRight(bv, false);
- end = actcell;
- }
- setSelection(start, end);
- break;
- }
+ case FINISHED_UP:
+ if (moveUpLock(cur))
+ result = DispatchResult(true, true);
+ else
+ result = DispatchResult(false, FINISHED_UP);
+ break;
- case LFUN_RIGHT:
- result = moveRight(bv, true);
- clearSelection();
- break;
+ case FINISHED_DOWN:
+ if (moveDownLock(cur))
+ result = DispatchResult(true, true);
+ else
+ result = DispatchResult(false, FINISHED_UP);
+ break;
- case LFUN_LEFTSEL: {
- int const start = hasSelection() ? sel_cell_start : actcell;
- if (tabular.isFirstCellInRow(actcell)) {
- setSelection(start, actcell);
+ default:
+ lyxerr << "# don't handle dispatch" << endl;
break;
}
- int end = actcell;
- // if we are starting a selection, only select
- // the current cell at the beginning
- if (hasSelection()) {
- moveLeft(bv, false);
- end = actcell;
- }
- setSelection(start, end);
- break;
- }
+ lyxerr << "# InsetTabular::dispatch: B " << cur << endl;
+ } else {
- case LFUN_LEFT:
- result = moveLeft(bv, true);
- clearSelection();
- break;
+ lyxerr << "# InsetTabular::dispatch 3: " << cmd << endl;
+ switch (cmd.action) {
- case LFUN_DOWNSEL: {
- int const start = hasSelection() ? sel_cell_start : actcell;
- int const ocell = actcell;
- // if we are starting a selection, only select
- // the current cell at the beginning
- if (hasSelection()) {
- moveDown(bv, false);
- if (ocell == sel_cell_end ||
- tabular.column_of_cell(ocell) > tabular.column_of_cell(actcell))
- setSelection(start, tabular.getCellBelow(sel_cell_end));
+ case LFUN_CELL_BACKWARD:
+ case LFUN_CELL_FORWARD:
+ if (cmd.action == LFUN_CELL_FORWARD)
+ moveNextCell(cur);
else
- setSelection(start, tabular.getLastCellBelow(sel_cell_end));
- } else {
- setSelection(start, start);
- }
- break;
- }
+ movePrevCell(cur);
+ clearSelection();
+ return result;
+
+ case LFUN_SCROLL_INSET:
+ if (!cmd.argument.empty()) {
+ if (cmd.argument.find('.') != cmd.argument.npos)
+ scroll(cur.bv(), static_cast<float>(strToDbl(cmd.argument)));
+ else
+ scroll(cur.bv(), strToInt(cmd.argument));
+ cur.bv().update();
+ return DispatchResult(true, true);
+ }
- case LFUN_DOWN:
- result = moveDown(bv, the_locking_inset != 0);
- clearSelection();
- break;
+ case LFUN_RIGHTSEL: {
+ int const start = hasSelection() ? sel_cell_start : cur.idx();
+ if (tabular.isLastCellInRow(cur.idx())) {
+ setSelection(start, cur.idx());
+ break;
+ }
- case LFUN_UPSEL: {
- int const start = hasSelection() ? sel_cell_start : actcell;
- int const ocell = actcell;
- // if we are starting a selection, only select
- // the current cell at the beginning
- if (hasSelection()) {
- moveUp(bv, false);
- if (ocell == sel_cell_end ||
- tabular.column_of_cell(ocell) > tabular.column_of_cell(actcell))
- setSelection(start, tabular.getCellAbove(sel_cell_end));
- else
- setSelection(start, tabular.getLastCellAbove(sel_cell_end));
- } else {
- setSelection(start, start);
+ int end = cur.idx();
+ // if we are starting a selection, only select
+ // the current cell at the beginning
+ if (hasSelection()) {
+ moveRight(cur);
+ end = cur.idx();
+ }
+ setSelection(start, end);
+ break;
}
- break;
- }
- case LFUN_UP:
- result = moveUp(bv, the_locking_inset != 0);
- clearSelection();
- break;
-
- case LFUN_NEXT: {
- if (hs)
+ case LFUN_RIGHT:
+ if (!moveRightLock(cur))
+ result = DispatchResult(false, FINISHED_RIGHT);
clearSelection();
- int column = actcol;
- if (bv->top_y() + bv->painter().paperHeight()
- < yo_ + tabular.getHeightOfTabular())
- {
- bv->scrollDocView(bv->top_y() + bv->painter().paperHeight());
- actcell = tabular.getCellBelow(first_visible_cell) + column;
- } else {
- actcell = tabular.getFirstCellInRow(tabular.rows() - 1) + column;
+ break;
+
+ case LFUN_LEFTSEL: {
+ int const start = hasSelection() ? sel_cell_start : cur.idx();
+ if (tabular.isFirstCellInRow(cur.idx())) {
+ setSelection(start, cur.idx());
+ break;
+ }
+
+ int end = cur.idx();
+ // if we are starting a selection, only select
+ // the current cell at the beginning
+ if (hasSelection()) {
+ moveLeft(cur);
+ end = cur.idx();
+ }
+ setSelection(start, end);
+ break;
}
- resetPos(bv);
- break;
- }
- case LFUN_PRIOR: {
- if (hs)
+ case LFUN_LEFT:
+ if (!moveLeftLock(cur))
+ result = DispatchResult(false, FINISHED);
clearSelection();
- int column = actcol;
- if (yo_ < 0) {
- bv->scrollDocView(bv->top_y() - bv->painter().paperHeight());
- if (yo_ > 0)
- actcell = column;
- else
- actcell = tabular.getCellBelow(first_visible_cell) + column;
- } else {
- actcell = column;
- }
- resetPos(bv);
- break;
- }
+ break;
- // none of these make sense for insettabular,
- // but we must catch them to prevent any
- // selection from being confused
- case LFUN_PRIORSEL:
- case LFUN_NEXTSEL:
- case LFUN_WORDLEFT:
- case LFUN_WORDLEFTSEL:
- case LFUN_WORDRIGHT:
- case LFUN_WORDRIGHTSEL:
- case LFUN_WORDSEL:
- case LFUN_DOWN_PARAGRAPH:
- case LFUN_DOWN_PARAGRAPHSEL:
- case LFUN_UP_PARAGRAPH:
- case LFUN_UP_PARAGRAPHSEL:
- case LFUN_BACKSPACE:
- case LFUN_HOME:
- case LFUN_HOMESEL:
- case LFUN_END:
- case LFUN_ENDSEL:
- case LFUN_BEGINNINGBUF:
- case LFUN_BEGINNINGBUFSEL:
- case LFUN_ENDBUF:
- case LFUN_ENDBUFSEL:
- break;
+ case LFUN_DOWNSEL: {
+ int const start = hasSelection() ? sel_cell_start : cur.idx();
+ int const ocell = cur.idx();
+ // if we are starting a selection, only select
+ // the current cell at the beginning
+ if (hasSelection()) {
+ moveDown(cur);
+ if (ocell == sel_cell_end ||
+ tabular.column_of_cell(ocell) >
+tabular.column_of_cell(cur.idx()))
+ setSelection(start, tabular.getCellBelow(sel_cell_end));
+ else
+ setSelection(start, tabular.getLastCellBelow(sel_cell_end));
+ } else {
+ setSelection(start, start);
+ }
+ break;
+ }
- case LFUN_LAYOUT_TABULAR:
- InsetTabularMailer(*this).showDialog(bv);
- break;
+ case LFUN_DOWN:
+ if (!moveDown(cur))
+ result = DispatchResult(false, FINISHED_DOWN);
+ clearSelection();
+ break;
- case LFUN_INSET_DIALOG_UPDATE:
- InsetTabularMailer(*this).updateDialog(bv);
- break;
+ case LFUN_UPSEL: {
+ int const start = hasSelection() ? sel_cell_start : cur.idx();
+ int const ocell = cur.idx();
+ // if we are starting a selection, only select
+ // the current cell at the beginning
+ if (hasSelection()) {
+ moveUp(cur);
+ if (ocell == sel_cell_end ||
+ tabular.column_of_cell(ocell) >
+tabular.column_of_cell(cur.idx()))
+ setSelection(start, tabular.getCellAbove(sel_cell_end));
+ else
+ setSelection(start, tabular.getLastCellAbove(sel_cell_end));
+ } else {
+ setSelection(start, start);
+ }
+ break;
+ }
- case LFUN_TABULAR_FEATURE:
- if (!tabularFeatures(bv, cmd.argument))
- result = DispatchResult(false);
- break;
+ case LFUN_UP:
+ if (!moveUp(cur))
+ result = DispatchResult(false, FINISHED_DOWN);
+ clearSelection();
+ break;
- // insert file functions
- case LFUN_FILE_INSERT_ASCII_PARA:
- case LFUN_FILE_INSERT_ASCII: {
- string tmpstr = getContentsOfAsciiFile(bv, cmd.argument, false);
- if (!tmpstr.empty() && !insertAsciiString(bv, tmpstr, false))
- result = DispatchResult(false);
- break;
- }
+ case LFUN_NEXT: {
+ if (hasSelection())
+ clearSelection();
+ int actcell = cur.idx();
+ int actcol = tabular.column_of_cell(actcell);
+ int column = actcol;
+ if (cur.bv().top_y() + cur.bv().painter().paperHeight()
+ < yo_ + tabular.getHeightOfTabular())
+ {
+ cur.bv().scrollDocView(
+ cur.bv().top_y() + cur.bv().painter().paperHeight());
+ cur.idx() = tabular.getCellBelow(first_visible_cell) + column;
+ } else {
+ cur.idx() = tabular.getFirstCellInRow(tabular.rows() - 1) + column;
+ }
+ resetPos(cur);
+ break;
+ }
- case LFUN_LANGUAGE:
- case LFUN_EMPH:
- case LFUN_BOLD:
- case LFUN_NOUN:
- case LFUN_CODE:
- case LFUN_SANS:
- case LFUN_ROMAN:
- case LFUN_DEFAULT:
- case LFUN_UNDERLINE:
- case LFUN_FONT_SIZE:
- lyxerr << "font changes not re-implemented for tables after LOCK" << endl;
- break;
+ case LFUN_PRIOR: {
+ if (hasSelection())
+ clearSelection();
+ int column = tabular.column_of_cell(cur.idx());
+ if (yo_ < 0) {
+ cur.bv().scrollDocView(
+ cur.bv().top_y() - cur.bv().painter().paperHeight());
+ if (yo_ > 0)
+ cur.idx() = column;
+ else
+ cur.idx() = tabular.getCellBelow(first_visible_cell) + column;
+ } else {
+ cur.idx() = column;
+ }
+ resetPos(cur);
+ break;
+ }
- case LFUN_FINISHED_LEFT:
- lyxerr << "swallow LFUN_FINISHED_LEFT, act: " << actcell << endl;
- if (!movePrevCell(bv, false))
- result = DispatchResult(FINISHED);
- break;
+ // none of these make sense for insettabular,
+ // but we must catch them to prevent any
+ // selection from being confused
+ case LFUN_PRIORSEL:
+ case LFUN_NEXTSEL:
+ case LFUN_WORDLEFT:
+ case LFUN_WORDLEFTSEL:
+ case LFUN_WORDRIGHT:
+ case LFUN_WORDRIGHTSEL:
+ case LFUN_WORDSEL:
+ case LFUN_DOWN_PARAGRAPH:
+ case LFUN_DOWN_PARAGRAPHSEL:
+ case LFUN_UP_PARAGRAPH:
+ case LFUN_UP_PARAGRAPHSEL:
+ case LFUN_BACKSPACE:
+ case LFUN_HOME:
+ case LFUN_HOMESEL:
+ case LFUN_END:
+ case LFUN_ENDSEL:
+ case LFUN_BEGINNINGBUF:
+ case LFUN_BEGINNINGBUFSEL:
+ case LFUN_ENDBUF:
+ case LFUN_ENDBUFSEL:
+ break;
- case LFUN_FINISHED_RIGHT:
- lyxerr << "swallow LFUN_FINISHED_RIGHT, act: " << actcell << endl;
- if (!moveNextCell(bv, false))
- result = DispatchResult(FINISHED_RIGHT);
- break;
+ case LFUN_LAYOUT_TABULAR:
+ InsetTabularMailer(*this).showDialog(&cur.bv());
+ break;
- case LFUN_FINISHED_UP:
- lyxerr << "swallow LFUN_FINISHED_UP, act: " << actcell << endl;
- result = moveUp(bv, true);
- break;
+ case LFUN_INSET_DIALOG_UPDATE:
+ InsetTabularMailer(*this).updateDialog(&cur.bv());
+ break;
- case LFUN_FINISHED_DOWN:
- lyxerr << "swallow LFUN_FINISHED_DOWN, act: " << actcell << endl;
- result = moveDown(bv, true);
- break;
+ case LFUN_TABULAR_FEATURE:
+ if (!tabularFeatures(cur, cmd.argument))
+ result = DispatchResult(false);
+ break;
- case LFUN_CUT:
- if (copySelection(bv)) {
- recordUndo(bv, Undo::DELETE);
- cutSelection(bv->buffer()->params());
+ // insert file functions
+ case LFUN_FILE_INSERT_ASCII_PARA:
+ case LFUN_FILE_INSERT_ASCII: {
+ string tmpstr = getContentsOfAsciiFile(&cur.bv(), cmd.argument, false);
+ if (!tmpstr.empty() && !insertAsciiString(cur.bv(), tmpstr, false))
+ result = DispatchResult(false);
+ break;
}
- break;
- case LFUN_DELETE:
- recordUndo(bv, Undo::DELETE);
- cutSelection(bv->buffer()->params());
- break;
+ case LFUN_LANGUAGE:
+ case LFUN_EMPH:
+ case LFUN_BOLD:
+ case LFUN_NOUN:
+ case LFUN_CODE:
+ case LFUN_SANS:
+ case LFUN_ROMAN:
+ case LFUN_DEFAULT:
+ case LFUN_UNDERLINE:
+ case LFUN_FONT_SIZE:
+ lyxerr << "font changes not re-implemented for tables after LOCK" << endl;
+ break;
- case LFUN_COPY:
- if (!hasSelection())
+ case LFUN_CUT:
+ if (copySelection(cur.bv())) {
+ recordUndo(cur, Undo::DELETE);
+ cutSelection(cur.bv().buffer()->params());
+ }
break;
- finishUndo();
- copySelection(bv);
- break;
- case LFUN_PASTESELECTION: {
- string const clip = bv->getClipboard();
- if (clip.empty())
+ case LFUN_DELETE:
+ recordUndo(cur, Undo::DELETE);
+ cutSelection(cur.bv().buffer()->params());
break;
- if (clip.find('\t') != string::npos) {
- int cols = 1;
- int rows = 1;
- int maxCols = 1;
- string::size_type len = clip.length();
- string::size_type p = 0;
-
- while (p < len &&
- ((p = clip.find_first_of("\t\n", p)) != string::npos)) {
- switch (clip[p]) {
- case '\t':
- ++cols;
- break;
- case '\n':
- if ((p+1) < len)
- ++rows;
- maxCols = max(cols, maxCols);
- cols = 1;
- break;
- }
- ++p;
- }
- maxCols = max(cols, maxCols);
- paste_tabular.reset(
- new LyXTabular(bv->buffer()->params(), rows, maxCols));
-
- string::size_type op = 0;
- int cell = 0;
- int cells = paste_tabular->getNumberOfCells();
- p = 0;
- cols = 0;
- LyXFont font;
- while (cell < cells && p < len &&
- (p = clip.find_first_of("\t\n", p)) != string::npos) {
- if (p >= len)
- break;
- switch (clip[p]) {
- case '\t':
- paste_tabular->getCellInset(cell).
- setText(clip.substr(op, p-op), font);
- ++cols;
- ++cell;
- break;
- case '\n':
- paste_tabular->getCellInset(cell).
- setText(clip.substr(op, p-op), font);
- while (cols++ < maxCols)
+ case LFUN_COPY:
+ if (!hasSelection())
+ break;
+ finishUndo();
+ copySelection(cur.bv());
+ break;
+
+ case LFUN_PASTESELECTION: {
+ string const clip = cur.bv().getClipboard();
+ if (clip.empty())
+ break;
+ if (clip.find('\t') != string::npos) {
+ int cols = 1;
+ int rows = 1;
+ int maxCols = 1;
+ string::size_type len = clip.length();
+ string::size_type p = 0;
+
+ while (p < len &&
+ (p = clip.find_first_of("\t\n", p)) != string::npos) {
+ switch (clip[p]) {
+ case '\t':
+ ++cols;
+ break;
+ case '\n':
+ if (p + 1 < len)
+ ++rows;
+ maxCols = max(cols, maxCols);
+ cols = 1;
+ break;
+ }
+ ++p;
+ }
+ maxCols = max(cols, maxCols);
+
+ paste_tabular.reset(
+ new LyXTabular(cur.bv().buffer()->params(), rows, maxCols));
+
+ string::size_type op = 0;
+ int cell = 0;
+ int cells = paste_tabular->getNumberOfCells();
+ p = 0;
+ cols = 0;
+ LyXFont font;
+ while (cell < cells && p < len &&
+ (p = clip.find_first_of("\t\n", p)) != string::npos) {
+ if (p >= len)
+ break;
+ switch (clip[p]) {
+ case '\t':
+ paste_tabular->getCellInset(cell).
+ setText(clip.substr(op, p-op), font);
+ ++cols;
++cell;
- cols = 0;
- break;
+ break;
+ case '\n':
+ paste_tabular->getCellInset(cell).
+ setText(clip.substr(op, p-op), font);
+ while (cols++ < maxCols)
+ ++cell;
+ cols = 0;
+ break;
+ }
+ ++p;
+ op = p;
}
- ++p;
- op = p;
+ // check for the last cell if there is no trailing '\n'
+ if (cell < cells && op < len)
+ paste_tabular->getCellInset(cell).
+ setText(clip.substr(op, len-op), font);
+ } else if (!insertAsciiString(cur.bv(), clip, true))
+ {
+ // so that the clipboard is used and it goes on
+ // to default
+ // and executes LFUN_PASTESELECTION in insettext!
+ paste_tabular.reset();
}
- // check for the last cell if there is no trailing '\n'
- if (cell < cells && op < len)
- paste_tabular->getCellInset(cell).
- setText(clip.substr(op, len-op), font);
- } else if (!insertAsciiString(bv, clip, true))
- {
- // so that the clipboard is used and it goes on
- // to default
- // and executes LFUN_PASTESELECTION in insettext!
- paste_tabular.reset();
+ // fall through
}
- // fall through
- }
- case LFUN_PASTE:
- if (hasPasteBuffer()) {
- recordUndo(bv, Undo::INSERT);
- pasteSelection(bv);
+ case LFUN_PASTE:
+ if (hasPasteBuffer()) {
+ recordUndo(cur, Undo::INSERT);
+ pasteSelection(cur.bv());
+ break;
+ }
+ // fall through
+
+ // ATTENTION: the function above has to be PASTE and PASTESELECTION!!!
+
+ default:
+ // handle font changing stuff on selection before we lock the inset
+ // in the default part!
+ result = DispatchResult(false);
+ // we try to activate the actual inset and put this event down to
+ // the insets dispatch function.
break;
}
- // fall through
- // ATTENTION: the function above has to be PASTE and PASTESELECTION!!!
+ updateLocal(cur);
+ InsetTabularMailer(*this).updateDialog(&cur.bv());
+ }
- default:
- // handle font changing stuff on selection before we lock the inset
- // in the default part!
- result = DispatchResult(false);
- // we try to activate the actual inset and put this event down to
- // the insets dispatch function.
- if (!the_locking_inset && activateCellInset(bv)) {
- result = the_locking_inset->dispatch(cmd);
- if (!result.dispatched()) {
- // we need to update if this was requested before
- result = DispatchResult(false);
- break;
- }
- if (hs)
- clearSelection();
- }
- break;
+ if (cmd.action == LFUN_INSET_TOGGLE) {
+ tablemode = !tablemode;
+ result = DispatchResult(true, true);
}
- updateLocal(bv);
- InsetTabularMailer(*this).updateDialog(bv);
return result;
}
// if the table is inside a float it doesn't need the informaltable
// wrapper. Search for it.
- for (master = owner();
- master && master->lyxCode() != InsetOld::FLOAT_CODE;
- master = master->owner());
+ for (master = owner(); master; master = master->owner())
+ if (master->lyxCode() == InsetOld::FLOAT_CODE)
+ break;
if (!master) {
os << "<informaltable>";
void InsetTabular::calculate_dimensions_of_cells(MetricsInfo & mi) const
{
-#if 1
- // if we have a locking_inset we should have to check only this cell for
- // change so I'll try this to have a boost, but who knows ;) (Jug?)
- // This is _really_ important (André)
- if (the_locking_inset == &tabular.getCellInset(actcell)) {
- int maxAsc = 0;
- int maxDesc = 0;
- for (int j = 0; j < tabular.columns(); ++j) {
- Dimension dim;
- MetricsInfo m = mi;
- m.base.textwidth =
- tabular.column_info[j].p_width.inPixels(mi.base.textwidth);
- tabular.getCellInset(actrow, j).metrics(m, dim);
- maxAsc = max(dim.asc, maxAsc);
- maxDesc = max(dim.des, maxDesc);
- }
- tabular.setWidthOfCell(actcell, the_locking_inset->width());
- tabular.setAscentOfRow(actrow, maxAsc + ADD_TO_HEIGHT);
- tabular.setDescentOfRow(actrow, maxDesc + ADD_TO_HEIGHT);
- return;
- }
-#endif
-
- int cell = -1;
- for (int i = 0; i < tabular.rows(); ++i) {
+ for (int i = 0, cell = -1; i < tabular.rows(); ++i) {
int maxAsc = 0;
int maxDesc = 0;
for (int j = 0; j < tabular.columns(); ++j) {
}
-void InsetTabular::getCursorPos(BufferView *, int & x, int & y) const
+void InsetTabular::getCursorPos(int cell, int & x, int & y) const
{
- x = TEXT_TO_INSET_OFFSET + cursorx_ - xo_;
- y = TEXT_TO_INSET_OFFSET + cursory_;
+ InsetText const & inset = tabular.getCellInset(cell);
+ inset.getCursorPos(cell, x, y);
+ x += inset.x() - xo_;
+ y += inset.y() - yo_;
}
-void InsetTabular::setPos(BufferView * bv, int x, int y) const
+void InsetTabular::setPos(BufferView & bv, int x, int y) const
{
+ int const cell = getCell(x + xo_, y + yo_);
+ lyxerr << "# InsetTabular::setPos() cell: " << cell << endl;
+ InsetText const & inset = tabular.getCellInset(cell);
+ inset.text_.setCursorFromCoordinates(x, y);
+#if 0
cursory_ = 0;
- actcell = 0;
- actrow = 0;
- actcol = 0;
+ int actcell = 0;
+ int actrow = 0;
+ int actcol = 0;
int ly = tabular.getDescentOfRow(actrow);
// first search the right row
+ tabular.getAdditionalWidth(actcell);
cursorx_ = lx - tabular.getWidthOfColumn(actcell) + xo_ + 2;
- resetPos(bv);
+#endif
+ resetPos(bv.cursor());
}
}
-void InsetTabular::resetPos(BufferView * bv) const
+void InsetTabular::resetPos(LCursor &) const
{
+#if 0
#ifdef WITH_WARNINGS
#warning This should be fixed in the right manner (20011128 Jug)
#endif
if (in_reset_pos > 0)
return;
+ BufferView & bv = cur.bv();
int cell = 0;
- actcol = tabular.column_of_cell(actcell);
- actrow = 0;
+ int actcell = cur.cell();
+ int actcol = tabular.column_of_cell(actcell);
+ int actrow = 0;
cursory_ = 0;
for (; cell < actcell && !tabular.isLastRow(cell); ++cell) {
if (tabular.isLastCellInRow(cell)) {
tabular.getWidthOfTabular() < bv->workWidth()-20)
{
scroll(bv, 0.0F);
- updateLocal(bv);
- } else if (the_locking_inset &&
- tabular.getWidthOfColumn(actcell) > bv->workWidth() - 20)
- {
- int xx = cursorx_ - offset;
- if (xx > bv->workWidth()-20) {
- scroll(bv, - xx + bv->workWidth() - 60);
- updateLocal(bv);
- } else if (xx < 20) {
- if (xx < 0)
- xx = -xx + 60;
- else
- xx = 60;
- scroll(bv, xx);
- updateLocal(bv);
- }
+ updateLocal(cur);
} else if (cursorx_ - offset > 20 &&
cursorx_ - offset + tabular.getWidthOfColumn(actcell)
- > bv->workWidth() - 20) {
- scroll(bv, - tabular.getWidthOfColumn(actcell) - 20);
- updateLocal(bv);
+ > bv.workWidth() - 20) {
+ scroll(&bv, - tabular.getWidthOfColumn(actcell) - 20);
+ updateLocal(cur);
} else if (cursorx_ - offset < 20) {
- scroll(bv, 20 - cursorx_ + offset);
- updateLocal(bv);
+ scroll(&bv, 20 - cursorx_ + offset);
+ updateLocal(cur);
} else if (scroll() && xo_ > 20 &&
xo_ + tabular.getWidthOfTabular() > bv->workWidth() - 20) {
- scroll(bv, old_x - cursorx_);
- updateLocal(bv);
+ scroll(&bv, old_x - cursorx_);
+ updateLocal(cur);
}
InsetTabularMailer(*this).updateDialog(bv);
in_reset_pos = 0;
+#endif
}
-DispatchResult InsetTabular::moveRight(BufferView * bv, bool lock)
+bool InsetTabular::moveRight(LCursor & cur)
{
- if (lock) {
- if (activateCellInset(bv))
- return DispatchResult(true, true);
- } else {
- bool moved = isRightToLeft(bv)
- ? movePrevCell(bv) : moveNextCell(bv);
- if (!moved)
- return DispatchResult(false, FINISHED_RIGHT);
- if (lock && activateCellInset(bv))
- return DispatchResult(true, true);
- }
- resetPos(bv);
- return DispatchResult(true);
+ bool moved = isRightToLeft(cur) ? movePrevCell(cur) : moveNextCell(cur);
+ if (!moved)
+ return false;
+ resetPos(cur);
+ return true;
}
-DispatchResult InsetTabular::moveLeft(BufferView * bv, bool lock)
+bool InsetTabular::moveRightLock(LCursor & cur)
{
- bool moved = isRightToLeft(bv) ? moveNextCell(bv) : movePrevCell(bv);
+ bool moved = isRightToLeft(cur) ? movePrevCell(cur) : moveNextCell(cur);
if (!moved)
- return DispatchResult(false, FINISHED);
- // behind the inset
- if (lock && activateCellInset(bv, 0, 0, true))
- return DispatchResult(true, true);
- resetPos(bv);
- return DispatchResult(true);
+ return false;
+ activateCellInset(cur, cur.idx(), false);
+ return true;
}
-DispatchResult InsetTabular::moveUp(BufferView * bv, bool lock)
+bool InsetTabular::moveLeft(LCursor & cur)
{
- int const ocell = actcell;
- actcell = tabular.getCellAbove(actcell);
- if (actcell == ocell) { // we moved out of the inset
- return DispatchResult(false, FINISHED_UP);
- }
- resetPos(bv);
- if (lock)
- activateCellInset(bv, bv->x_target(), 0);
- return DispatchResult(true, true);
+ bool moved = isRightToLeft(cur) ? moveNextCell(cur) : movePrevCell(cur);
+ if (!moved)
+ return false;
+ resetPos(cur);
+ return true;
}
-DispatchResult InsetTabular::moveDown(BufferView * bv, bool lock)
+bool InsetTabular::moveLeftLock(LCursor & cur)
{
- int const ocell = actcell;
- actcell = tabular.getCellBelow(actcell);
- if (actcell == ocell) { // we moved out of the inset
- return DispatchResult(false, FINISHED_DOWN);
- }
- resetPos(bv);
- if (lock)
- activateCellInset(bv, bv->x_target(), 0);
- return DispatchResult(true, true);
+ bool moved = isRightToLeft(cur) ? moveNextCell(cur) : movePrevCell(cur);
+ if (!moved)
+ return false;
+ activateCellInset(cur, cur.idx(), true);
+ return true;
}
-bool InsetTabular::moveNextCell(BufferView * bv, bool lock)
+bool InsetTabular::moveUp(LCursor & cur)
{
- if (isRightToLeft(bv)) {
- if (tabular.isFirstCellInRow(actcell)) {
- int row = tabular.row_of_cell(actcell);
+ if (tabular.row_of_cell(cur.idx()) == 0)
+ return false;
+ cur.idx() = tabular.getCellAbove(cur.idx());
+ resetPos(cur);
+ return true;
+}
+
+
+bool InsetTabular::moveUpLock(LCursor & cur)
+{
+ if (tabular.row_of_cell(cur.idx()) == 0)
+ return false;
+ cur.idx() = tabular.getCellAbove(cur.idx());
+ resetPos(cur);
+ activateCellInset(cur, cur.idx(), cur.x_target(), 0);
+ return true;
+}
+
+
+bool InsetTabular::moveDown(LCursor & cur)
+{
+ if (tabular.row_of_cell(cur.idx()) == tabular.rows() - 1)
+ return false;
+ cur.idx() = tabular.getCellBelow(cur.idx());
+ resetPos(cur);
+ return true;
+}
+
+
+bool InsetTabular::moveDownLock(LCursor & cur)
+{
+ if (tabular.row_of_cell(cur.idx()) == tabular.rows() - 1)
+ return false;
+ cur.idx() = tabular.getCellBelow(cur.idx());
+ resetPos(cur);
+ activateCellInset(cur, cur.idx(), cur.x_target());
+ return true;
+}
+
+
+bool InsetTabular::moveNextCell(LCursor & cur)
+{
+ lyxerr << "InsetTabular::moveNextCell 1 cur: " << cur << endl;
+ if (isRightToLeft(cur)) {
+ if (tabular.isFirstCellInRow(cur.idx())) {
+ int row = tabular.row_of_cell(cur.idx());
if (row == tabular.rows() - 1)
return false;
- actcell = tabular.getLastCellInRow(row);
- actcell = tabular.getCellBelow(actcell);
+ cur.idx() = tabular.getLastCellInRow(row);
+ cur.idx() = tabular.getCellBelow(cur.idx());
} else {
- if (!actcell)
+ if (cur.idx() == 0)
return false;
- --actcell;
+ --cur.idx();
}
} else {
- if (tabular.isLastCell(actcell))
+ if (tabular.isLastCell(cur.idx()))
return false;
- ++actcell;
+ ++cur.idx();
}
- if (lock) {
- bool rtl = tabular.getCellInset(actcell).paragraphs.begin()->
- isRightToLeftPar(bv->buffer()->params());
- activateCellInset(bv, 0, 0, !rtl);
- }
- resetPos(bv);
+ cur.par() = 0;
+ cur.pos() = 0;
+ lyxerr << "InsetTabular::moveNextCell 2 cur: " << cur << endl;
+ resetPos(cur);
return true;
}
-bool InsetTabular::movePrevCell(BufferView * bv, bool lock)
+bool InsetTabular::movePrevCell(LCursor & cur)
{
- lyxerr << "move prevcell 1" << endl;
- if (isRightToLeft(bv)) {
- lyxerr << "move prevcell a" << endl;
- if (tabular.isLastCellInRow(actcell)) {
- int row = tabular.row_of_cell(actcell);
+ if (isRightToLeft(cur)) {
+ if (tabular.isLastCellInRow(cur.idx())) {
+ int row = tabular.row_of_cell(cur.idx());
if (row == 0)
return false;
- actcell = tabular.getFirstCellInRow(row);
- actcell = tabular.getCellAbove(actcell);
+ cur.idx() = tabular.getFirstCellInRow(row);
+ cur.idx() = tabular.getCellAbove(cur.idx());
} else {
- if (tabular.isLastCell(actcell))
+ if (tabular.isLastCell(cur.idx()))
return false;
- ++actcell;
+ ++cur.idx();
}
} else {
- lyxerr << "move prevcell b" << endl;
- if (actcell == 0) // first cell
+ if (cur.idx() == 0) // first cell
return false;
- --actcell;
- }
- lyxerr << "move prevcell 2" << endl;
- if (lock) {
- bool rtl = tabular.getCellInset(actcell).paragraphs.begin()->
- isRightToLeftPar(bv->buffer()->params());
- activateCellInset(bv, 0, 0, !rtl);
+ --cur.idx();
}
- lyxerr << "move prevcell 3" << endl;
- resetPos(bv);
- lyxerr << "move prevcell 4" << endl;
+ cur.par() = 0;
+ cur.pos() = 0;
+ resetPos(cur);
return true;
}
-void InsetTabular::setFont(BufferView * bv, LyXFont const & font, bool tall,
- bool selectall)
-{
- if (selectall) {
- setSelection(0, tabular.getNumberOfCells() - 1);
- }
- if (hasSelection()) {
- recordUndo(bv, Undo::ATOMIC);
- bool const frozen = undo_frozen;
- if (!frozen)
- freezeUndo();
- // apply the fontchange on the whole selection
- int sel_row_start;
- int sel_row_end;
- int sel_col_start;
- int sel_col_end;
- getSelection(sel_row_start, sel_row_end, sel_col_start, sel_col_end);
- for (int i = sel_row_start; i <= sel_row_end; ++i)
- for (int j = sel_col_start; j <= sel_col_end; ++j)
- tabular.getCellInset(i, j).setFont(bv, font, tall, true);
-
- if (!frozen)
- unFreezeUndo();
- if (selectall)
- clearSelection();
- updateLocal(bv);
- }
- if (the_locking_inset)
- the_locking_inset->setFont(bv, font, tall);
-}
-
-
-bool InsetTabular::tabularFeatures(BufferView * bv, string const & what)
+bool InsetTabular::tabularFeatures(LCursor & cur, string const & what)
{
LyXTabular::Feature action = LyXTabular::LAST_ACTION;
string const val =
ltrim(what.substr(tabularFeature[i].feature.length()));
- tabularFeatures(bv, action, val);
+ tabularFeatures(cur, action, val);
return true;
}
+
namespace {
void checkLongtableSpecial(LyXTabular::ltType & ltt,
} // anon namespace
-void InsetTabular::tabularFeatures(BufferView * bv,
+void InsetTabular::tabularFeatures(LCursor & cur,
LyXTabular::Feature feature, string const & value)
{
+ BufferView & bv = cur.bv();
+ int actcell = cur.idx();
int sel_col_start;
int sel_col_end;
int sel_row_start;
}
if (hasSelection()) {
- getSelection(sel_row_start, sel_row_end, sel_col_start, sel_col_end);
+ getSelection(actcell, sel_row_start, sel_row_end, sel_col_start, sel_col_end);
} else {
sel_col_start = sel_col_end = tabular.column_of_cell(actcell);
sel_row_start = sel_row_end = tabular.row_of_cell(actcell);
}
- recordUndo(bv, Undo::ATOMIC);
+ recordUndo(cur, Undo::ATOMIC);
int row = tabular.row_of_cell(actcell);
int column = tabular.column_of_cell(actcell);
tabular.setColumnPWidth(actcell, len);
if (len.zero()
&& tabular.getAlignment(actcell, true) == LYX_ALIGN_BLOCK)
- tabularFeatures(bv, LyXTabular::ALIGN_CENTER, string());
+ tabularFeatures(cur, LyXTabular::ALIGN_CENTER, string());
else if (!len.zero()
&& tabular.getAlignment(actcell, true) != LYX_ALIGN_BLOCK)
- tabularFeatures(bv, LyXTabular::ALIGN_BLOCK, string());
+ tabularFeatures(cur, LyXTabular::ALIGN_BLOCK, string());
break;
}
case LyXTabular::APPEND_ROW:
// append the row into the tabular
- tabular.appendRow(bv->buffer()->params(), actcell);
+ tabular.appendRow(bv.buffer()->params(), actcell);
tabular.setOwner(this);
break;
case LyXTabular::APPEND_COLUMN:
// append the column into the tabular
- tabular.appendColumn(bv->buffer()->params(), actcell);
+ tabular.appendColumn(bv.buffer()->params(), actcell);
tabular.setOwner(this);
actcell = tabular.getCellNumber(row, column);
break;
if (tabular.isMultiColumn(actcell))
tabular.unsetMultiColumn(actcell);
else
- tabular.setMultiColumn(bv->buffer(), actcell, 1);
+ tabular.setMultiColumn(bv.buffer(), actcell, 1);
break;
}
// we have a selection so this means we just add all this
s_start = sel_cell_start;
s_end = sel_cell_end;
}
- tabular.setMultiColumn(bv->buffer(), s_start, s_end - s_start + 1);
+ tabular.setMultiColumn(bv.buffer(), s_start, s_end - s_start + 1);
actcell = s_start;
clearSelection();
break;
break;
}
- updateLocal(bv);
- InsetTabularMailer(*this).updateDialog(bv);
+ updateLocal(cur);
+ InsetTabularMailer(*this).updateDialog(&bv);
}
-bool InsetTabular::activateCellInset(BufferView * bv, int x, int y, bool behind)
+void InsetTabular::activateCellInset(LCursor & cur, int cell, int x, int y)
{
- UpdatableInset & inset = tabular.getCellInset(actcell);
- if (behind) {
-#warning metrics?
- x = inset.x() + inset.width();
- y = inset.descent();
- }
- inset.edit(bv, x, y);
- bv->cursor().push(&inset);
- if (!the_locking_inset)
- return false;
- updateLocal(bv);
- return the_locking_inset;
+ tabular.getCellInset(cell).edit(cur, x, y);
+ cur.idx() = cell;
+ updateLocal(cur);
+}
+
+
+void InsetTabular::activateCellInset(LCursor & cur, int cell, bool behind)
+{
+ tabular.getCellInset(cell).edit(cur, behind);
+ cur.idx() = cell;
+ updateLocal(cur);
}
bool InsetTabular::showInsetDialog(BufferView * bv) const
{
- if (!the_locking_inset || !the_locking_inset->showInsetDialog(bv))
- InsetTabularMailer(*this).showDialog(bv);
+ InsetTabularMailer(*this).showDialog(bv);
return true;
}
void InsetTabular::openLayoutDialog(BufferView * bv) const
{
-#warning Look here
-/*
- if (the_locking_inset) {
- InsetTabular * inset = static_cast<InsetTabular *>
- (the_locking_inset->getFirstLockingInsetOfType(TABULAR_CODE));
- if (inset) {
- inset->openLayoutDialog(bv);
- return;
- }
- }
-*/
InsetTabularMailer(*this).showDialog(bv);
}
// function returns an object as defined in func_status.h:
// states OK, Unknown, Disabled, On, Off.
//
-FuncStatus InsetTabular::getStatus(string const & what) const
+FuncStatus InsetTabular::getStatus(string const & what, int actcell) const
{
- int action = LyXTabular::LAST_ACTION;
FuncStatus status;
+ int action = LyXTabular::LAST_ACTION;
int i = 0;
for (; tabularFeature[i].action != LyXTabular::LAST_ACTION; ++i) {
string const tmp = tabularFeature[i].feature;
if (tmp == what.substr(0, tmp.length())) {
//if (!compare(tabularFeatures[i].feature.c_str(), what.c_str(),
- // tabularFeatures[i].feature.length())) {
+ // tabularFeatures[i].feature.length()))
action = tabularFeature[i].action;
break;
}
bool flag = true;
if (hasSelection())
- getSelection(sel_row_start, sel_row_end, dummy, dummy);
+ getSelection(actcell, sel_row_start, sel_row_end, dummy, dummy);
else
sel_row_start = sel_row_end = tabular.row_of_cell(actcell);
void InsetTabular::getLabelList(Buffer const & buffer,
- std::vector<string> & list) const
+ vector<string> & list) const
{
tabular.getLabelList(buffer, list);
}
-bool InsetTabular::copySelection(BufferView * bv)
+bool InsetTabular::copySelection(BufferView & bv)
{
if (!hasSelection())
return false;
true, true);
ostringstream os;
- OutputParams const runparams;
- paste_tabular->plaintext(*bv->buffer(), os, runparams,
- ownerPar(*bv->buffer(), this).params().depth(), true, '\t');
- bv->stuffClipboard(os.str());
+ OutputParams const runparams;
+ paste_tabular->plaintext(*bv.buffer(), os, runparams,
+ ownerPar(*bv.buffer(), this).params().depth(), true, '\t');
+ bv.stuffClipboard(os.str());
return true;
}
-bool InsetTabular::pasteSelection(BufferView *)
+bool InsetTabular::pasteSelection(BufferView & bv)
{
if (!paste_tabular)
return false;
-
+ int actcell = bv.cursor().idx();
+ int actcol = tabular.column_of_cell(actcell);
+ int actrow = tabular.row_of_cell(actcell);
for (int r1 = 0, r2 = actrow;
r1 < paste_tabular->rows() && r2 < tabular.rows();
++r1, ++r2) {
}
-bool InsetTabular::isRightToLeft(BufferView * bv)
-{
- return bv->getParentLanguage(this)->RightToLeft();
-}
-
-
-int InsetTabular::scroll(bool recursive) const
+bool InsetTabular::isRightToLeft(LCursor & cur)
{
- int sx = UpdatableInset::scroll(false);
-
- if (recursive && the_locking_inset)
- sx += the_locking_inset->scroll(recursive);
-
- return sx;
+ return cur.bv().getParentLanguage(this)->RightToLeft();
}
-void InsetTabular::getSelection(int & srow, int & erow,
- int & scol, int & ecol) const
+void InsetTabular::getSelection(int actcell,
+ int & srow, int & erow, int & scol, int & ecol) const
{
int const start = hasSelection() ? sel_cell_start : actcell;
int const end = hasSelection() ? sel_cell_end : actcell;
}
-ParagraphList * InsetTabular::getParagraphs(int i) const
-{
- return i < tabular.getNumberOfCells()
- ? tabular.getCellInset(i).getParagraphs(0)
- : 0;
-}
-
-
int InsetTabular::numParagraphs() const
{
return tabular.getNumberOfCells();
}
-bool InsetTabular::insetAllowed(InsetOld::Code) const
-{
- return false;
-}
-
-
-bool InsetTabular::forceDefaultParagraphs(InsetOld const * in) const
+bool InsetTabular::forceDefaultParagraphs(InsetBase const * in) const
{
const int cell = tabular.getCellFromInset(in);
}
-bool InsetTabular::insertAsciiString(BufferView * bv, string const & buf,
+bool InsetTabular::insertAsciiString(BufferView & bv, string const & buf,
bool usePaste)
{
if (buf.length() <= 0)
string::size_type len = buf.length();
string::size_type p = 0;
+ int actcell = bv.cursor().idx();
+ int actcol = tabular.column_of_cell(actcell);
+ int actrow = tabular.row_of_cell(actcell);
+
while (p < len && (p = buf.find_first_of("\t\n", p)) != string::npos) {
switch (buf[p]) {
case '\t':
int row = 0;
if (usePaste) {
paste_tabular.reset(
- new LyXTabular(bv->buffer()->params(), rows, maxCols)
- );
-
+ new LyXTabular(bv.buffer()->params(), rows, maxCols));
paste_tabular->setOwner(this);
loctab = paste_tabular.get();
cols = 0;
if (cols < columns) {
InsetText & inset = loctab->getCellInset(cell);
LyXFont const font = inset.text_.
- getFont(inset.paragraphs.begin(), 0);
+ getFont(inset.paragraphs().begin(), 0);
inset.setText(buf.substr(op, p - op), font);
++cols;
++cell;
if (cols < columns) {
InsetText & inset = tabular.getCellInset(cell);
LyXFont const font = inset.text_.
- getFont(inset.paragraphs.begin(), 0);
+ getFont(inset.paragraphs().begin(), 0);
inset.setText(buf.substr(op, p - op), font);
}
cols = ocol;
// check for the last cell if there is no trailing '\n'
if (cell < cells && op < len) {
InsetText & inset = loctab->getCellInset(cell);
- LyXFont const font = inset.text_.getFont(inset.paragraphs.begin(), 0);
+ LyXFont const font = inset.text_.getFont(inset.paragraphs().begin(), 0);
inset.setText(buf.substr(op, len - op), font);
}
-
return true;
}
}
+
+void InsetTabular::clearSelection() const
+{
+ sel_cell_start = 0;
+ sel_cell_end = 0;
+ has_selection = false;
+}
+
+
+void InsetTabular::setSelection(int start, int end) const
+{
+ sel_cell_start = start;
+ sel_cell_end = end;
+ has_selection = true;
+}
+
+
string const InsetTabularMailer::name_("tabular");
InsetTabularMailer::InsetTabularMailer(InsetTabular const & inset)
string const InsetTabularMailer::params2string(InsetTabular const & inset)
{
ostringstream data;
- data << name_ << " \\active_cell " << inset.getActCell() << '\n';
+#warning wrong!
+ //data << name_ << " \\active_cell " << inset.getActCell() << '\n';
+ data << name_ << " \\active_cell " << 0 << '\n';
inset.write(inset.buffer(), data);
data << "\\end_inset\n";
return data.str();
projects / lyx.git / blobdiff