#include "FuncStatus.h"
#include "gettext.h"
#include "language.h"
+#include "LColor.h"
#include "lyx_cb.h"
#include "lyxlex.h"
#include "metricsinfo.h"
#include "frontends/Painter.h"
#include "support/std_sstream.h"
+#include <iostream>
using lyx::graphics::PreviewLoader;
using std::endl;
using std::max;
using std::swap;
-
+using std::string;
using std::auto_ptr;
using std::istringstream;
using std::ostream;
InsetTabular::InsetTabular(Buffer const & buf, int rows, int columns)
- : tabular(buf.params(), this, max(rows, 1), max(columns, 1)),
+ : tabular(buf.params(), max(rows, 1), max(columns, 1)),
buffer_(&buf), cursorx_(0), cursory_(0)
{
+ tabular.setOwner(this);
// for now make it always display as display() inset
// just for test!!!
the_locking_inset = 0;
InsetTabular::InsetTabular(InsetTabular const & tab)
- : UpdatableInset(tab),
- tabular(tab.buffer_->params(), this, tab.tabular),
+ : UpdatableInset(tab), tabular(tab.tabular),
buffer_(tab.buffer_), cursorx_(0), cursory_(0)
{
+ tabular.setOwner(this);
the_locking_inset = 0;
old_locking_inset = 0;
locked = false;
}
-InsetOld::RESULT InsetTabular::localDispatch(FuncRequest const & cmd)
+dispatch_result InsetTabular::localDispatch(FuncRequest const & cmd)
{
// We need to save the value of the_locking_inset as the call to
// the_locking_inset->localDispatch might unlock it.
old_locking_inset = the_locking_inset;
- RESULT result = UpdatableInset::localDispatch(cmd);
+ dispatch_result result = UpdatableInset::localDispatch(cmd);
BufferView * bv = cmd.view();
if (cmd.action == LFUN_INSET_EDIT) {
}
// we need this only from here on!!!
++in_reset_pos;
- static int const offset = ADD_TO_TABULAR_WIDTH + 2;
+ int const offset = ADD_TO_TABULAR_WIDTH + 2;
int new_x = getCellXPos(actcell);
int old_x = cursorx_;
new_x += offset;
}
-InsetOld::RESULT InsetTabular::moveRight(BufferView * bv, bool lock)
+dispatch_result InsetTabular::moveRight(BufferView * bv, bool lock)
{
if (lock && !old_locking_inset) {
if (activateCellInset(bv))
}
-InsetOld::RESULT InsetTabular::moveLeft(BufferView * bv, bool lock)
+dispatch_result InsetTabular::moveLeft(BufferView * bv, bool lock)
{
bool moved = isRightToLeft(bv) ? moveNextCell(bv) : movePrevCell(bv);
if (!moved)
}
-InsetOld::RESULT InsetTabular::moveUp(BufferView * bv, bool lock)
+dispatch_result InsetTabular::moveUp(BufferView * bv, bool lock)
{
int const ocell = actcell;
actcell = tabular.getCellAbove(actcell);
}
-InsetOld::RESULT InsetTabular::moveDown(BufferView * bv, bool lock)
+dispatch_result InsetTabular::moveDown(BufferView * bv, bool lock)
{
int const ocell = actcell;
actcell = tabular.getCellBelow(actcell);
case LyXTabular::SET_PWIDTH:
{
- LyXLength const vallen(value);
- LyXLength const & tmplen = tabular.getColumnPWidth(actcell);
+ LyXLength const len(value);
+ LyXLength const & oldlen = tabular.getColumnPWidth(actcell);
- bool const update = (tmplen != vallen);
- tabular.setColumnPWidth(actcell, vallen);
- if (update) {
+ tabular.setColumnPWidth(actcell, len);
+ if (oldlen != len) {
// We need this otherwise we won't resize
// the insettext of the active cell (if any)
// until later (see InsetText::do_resize)
bv->update();
}
- if (vallen.zero()
+ if (len.zero()
&& tabular.getAlignment(actcell, true) == LYX_ALIGN_BLOCK)
tabularFeatures(bv, LyXTabular::ALIGN_CENTER, string());
- else if (!vallen.zero()
+ else if (!len.zero()
&& tabular.getAlignment(actcell, true) != LYX_ALIGN_BLOCK)
tabularFeatures(bv, LyXTabular::ALIGN_BLOCK, string());
break;
case LyXTabular::SET_MPWIDTH:
{
- LyXLength const vallen(value);
- LyXLength const & tmplen = tabular.getPWidth(actcell);
-
- bool const update = (tmplen != vallen);
- tabular.setMColumnPWidth(actcell, vallen);
- if (update) {
+ LyXLength const len(value);
+ LyXLength const & oldlen = tabular.getPWidth(actcell);
+ tabular.setMColumnPWidth(actcell, len);
+ if (oldlen != len) {
// We need this otherwise we won't resize
// the insettext of the active cell (if any)
// until later (see InsetText::do_resize)
// append the row into the tabular
unlockInsetInInset(bv, the_locking_inset);
tabular.appendRow(bv->buffer()->params(), actcell);
+ tabular.setOwner(this);
updateLocal(bv);
break;
case LyXTabular::APPEND_COLUMN:
// append the column into the tabular
unlockInsetInInset(bv, the_locking_inset);
tabular.appendColumn(bv->buffer()->params(), actcell);
+ tabular.setOwner(this);
actcell = tabular.getCellNumber(row, column);
updateLocal(bv);
break;
}
-void InsetTabular::getLabelList(std::vector<string> & list) const
+void InsetTabular::getLabelList(Buffer const & buffer,
+ std::vector<string> & list) const
{
- tabular.getLabelList(list);
+ tabular.getLabelList(buffer, list);
}
swap(sel_row_start, sel_row_end);
delete paste_tabular;
- paste_tabular = new LyXTabular(bv->buffer()->params(), this, tabular);
+ paste_tabular = new LyXTabular(tabular);
+ paste_tabular->setOwner(this);
for (int i = 0; i < sel_row_start; ++i)
paste_tabular->deleteRow(0);
for (int i = sel_row_start; i <= sel_row_end; ++i)
for (int j = sel_col_start; j <= sel_col_end; ++j)
- tabular.getCellInset(tabular.getCellNumber(i, j)).clear(bp.tracking_changes);
+ tabular.getCellInset(tabular.getCellNumber(i, j))
+ .clear(bp.tracking_changes);
return true;
}
bool InsetTabular::forceDefaultParagraphs(InsetOld const * in) const
{
- const int cell = tabular.getCellFromInset(in, actcell);
+ const int cell = tabular.getCellFromInset(in);
if (cell != -1)
return tabular.getPWidth(cell).zero();
// well we didn't obviously find it so maybe our owner knows more
- if (owner())
- return owner()->forceDefaultParagraphs(in);
-
- lyxerr << "If we're here there is really something strange going on!"
- << endl;
- return false;
+ BOOST_ASSERT(owner());
+ return owner()->forceDefaultParagraphs(in);
}
if (usePaste) {
delete paste_tabular;
paste_tabular = new LyXTabular(bv->buffer()->params(),
- this, rows, maxCols);
+ rows, maxCols);
+ paste_tabular->setOwner(this);
loctab = paste_tabular;
cols = 0;
} else {