using std::endl;
using std::swap;
using std::max;
+using std::auto_ptr;
namespace {
}
-InsetBase * InsetTabular::clone() const
+auto_ptr<InsetBase> InsetTabular::clone() const
{
- return new InsetTabular(*this);
+ return auto_ptr<InsetBase>(new InsetTabular(*this));
}
void InsetTabular::write(Buffer const * buf, ostream & os) const
{
- os << " Tabular" << endl;
+ os << "Tabular" << endl;
tabular.write(buf, os);
}
lyxerr << "InsetTabular::metrics: need bv\n";
Assert(0);
}
-
+
calculate_dimensions_of_cells(mi);
-
+
dim.asc = tabular.getAscentOfRow(0);
dim.des = tabular.getHeightOfTabular() - tabular.getAscentOfRow(0) + 1;
dim.wid = tabular.getWidthOfTabular() + 2 * ADD_TO_TABULAR_WIDTH;
{
//lyxerr << "InsetTabular::draw: " << x << " " << y << "\n";
if (nodraw()) {
+ lyxerr << "InsetTabular::nodraw: " << x << " " << y << "\n";
need_update = FULL;
return;
}
BufferView * bv = pi.base.bv;
- int i;
- int j;
- int nx;
#if 0
UpdatableInset::draw(pi, x, y);
x += ADD_TO_TABULAR_WIDTH;
int cell = 0;
- int cx;
first_visible_cell = -1;
- for (i = 0; i < tabular.rows(); ++i) {
- nx = x;
+ for (int i = 0; i < tabular.rows(); ++i) {
+ int nx = x;
cell = tabular.getCellNumber(i, 0);
- if (!((y + tabular.getDescentOfRow(i)) > 0) &&
- (y - tabular.getAscentOfRow(i)) < pi.pain.paperHeight())
+ if (y + tabular.getDescentOfRow(i) <= 0 &&
+ y - tabular.getAscentOfRow(i) < pi.pain.paperHeight())
{
- y += tabular.getDescentOfRow(i) +
- tabular.getAscentOfRow(i + 1) +
- tabular.getAdditionalHeight(i + 1);
+ y += tabular.getDescentOfRow(i) +
+ tabular.getAscentOfRow(i + 1) +
+ tabular.getAdditionalHeight(i + 1);
continue;
}
- for (j = 0; j < tabular.columns(); ++j) {
+ for (int j = 0; j < tabular.columns(); ++j) {
if (nx > bv->workWidth())
break;
if (tabular.isPartOfMultiColumn(i, j))
continue;
- cx = nx + tabular.getBeginningOfTextInCell(cell);
+ int cx = nx + tabular.getBeginningOfTextInCell(cell);
if (first_visible_cell < 0)
first_visible_cell = cell;
if (hasSelection()) {
}
-bool InsetTabular::updateInsetInInset(BufferView * bv, Inset * inset)
+bool InsetTabular::updateInsetInInset(BufferView * bv, InsetOld * inset)
{
- Inset * tl_inset = inset;
+ InsetOld * tl_inset = inset;
// look if this inset is really inside myself!
while(tl_inset->owner() && tl_inset->owner() != this)
tl_inset = tl_inset->owner();
}
-UpdatableInset * InsetTabular::getFirstLockingInsetOfType(Inset::Code c)
+UpdatableInset * InsetTabular::getFirstLockingInsetOfType(InsetOld::Code c)
{
if (c == lyxCode())
return this;
}
-bool InsetTabular::insertInset(BufferView * bv, Inset * inset)
+bool InsetTabular::insertInset(BufferView * bv, InsetOld * inset)
{
if (the_locking_inset)
return the_locking_inset->insertInset(bv, inset);
}
-Inset::RESULT InsetTabular::localDispatch(FuncRequest const & cmd)
+InsetOld::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.
result = DISPATCHED;
// this one have priority over the locked InsetText, if we're not already
// inside another tabular then that one get's priority!
- if (getFirstLockingInsetOfType(Inset::TABULAR_CODE) == this) {
+ if (getFirstLockingInsetOfType(InsetOld::TABULAR_CODE) == this) {
switch (cmd.action) {
case LFUN_MOUSE_PRESS:
lfunMousePress(cmd);
break;
// no break here!
case LFUN_DELETE:
- setUndo(bv, Undo::DELETE);
+ recordUndo(bv, Undo::DELETE);
cutSelection(bv->buffer()->params);
updateLocal(bv, INIT);
break;
}
case LFUN_PASTE:
if (hasPasteBuffer()) {
- setUndo(bv, Undo::INSERT);
+ recordUndo(bv, Undo::INSERT);
pasteSelection(bv);
updateLocal(bv, INIT);
break;
int InsetTabular::linuxdoc(Buffer const * buf, ostream & os) const
{
- os << "<![CDATA[";
- int const ret = tabular.ascii(buf,os,
- (int)parOwner()->params().depth(),
- false, 0);
- os << "]]>";
- return ret;
+ return tabular.linuxdoc(buf,os);
}
int InsetTabular::docbook(Buffer const * buf, ostream & os, bool mixcont) const
{
int ret = 0;
- Inset * master;
+ InsetOld * master;
// if the table is inside a float it doesn't need the informaltable
// wrapper. Search for it.
for(master = owner();
- master && master->lyxCode() != Inset::FLOAT_CODE;
+ master && master->lyxCode() != InsetOld::FLOAT_CODE;
master = master->owner());
if (!master) {
}
-Inset::RESULT InsetTabular::moveRight(BufferView * bv, bool lock)
+InsetOld::RESULT InsetTabular::moveRight(BufferView * bv, bool lock)
{
if (lock && !old_locking_inset) {
if (activateCellInset(bv))
}
-Inset::RESULT InsetTabular::moveLeft(BufferView * bv, bool lock)
+InsetOld::RESULT InsetTabular::moveLeft(BufferView * bv, bool lock)
{
bool moved = isRightToLeft(bv) ? moveNextCell(bv) : movePrevCell(bv);
if (!moved)
}
-Inset::RESULT InsetTabular::moveUp(BufferView * bv, bool lock)
+InsetOld::RESULT InsetTabular::moveUp(BufferView * bv, bool lock)
{
int const ocell = actcell;
actcell = tabular.getCellAbove(actcell);
}
-Inset::RESULT InsetTabular::moveDown(BufferView * bv, bool lock)
+InsetOld::RESULT InsetTabular::moveDown(BufferView * bv, bool lock)
{
int const ocell = actcell;
actcell = tabular.getCellBelow(actcell);
setSelection(0, tabular.getNumberOfCells() - 1);
}
if (hasSelection()) {
- setUndo(bv, Undo::EDIT);
+ recordUndo(bv, Undo::ATOMIC);
bool const frozen = undo_frozen;
if (!frozen)
freezeUndo();
sel_col_start = sel_col_end = tabular.column_of_cell(actcell);
sel_row_start = sel_row_end = tabular.row_of_cell(actcell);
}
- setUndo(bv, Undo::FINISH);
+ recordUndo(bv, Undo::ATOMIC);
int row = tabular.row_of_cell(actcell);
int column = tabular.column_of_cell(actcell);
{
if (the_locking_inset)
return the_locking_inset->getLyXText(bv, recursive);
- return Inset::getLyXText(bv, recursive);
+ return InsetOld::getLyXText(bv, recursive);
}
{
if (the_locking_inset)
return the_locking_inset->cursor(bv);
- return Inset::cursor(bv);
+ return InsetOld::cursor(bv);
}
-Inset * InsetTabular::getInsetFromID(int id_arg) const
+InsetOld * InsetTabular::getInsetFromID(int id_arg) const
{
if (id_arg == id())
return const_cast<InsetTabular *>(this);
for (int i = 0; i < tabular.rows(); ++i) {
for (int j = 0; j < tabular.columns(); ++j) {
- Inset * inset = tabular.getCellInset(i, j).getInsetFromID(id_arg);
+ InsetOld * inset = tabular.getCellInset(i, j).getInsetFromID(id_arg);
if (inset)
return inset;
}
}
-bool InsetTabular::insetAllowed(Inset::Code code) const
+bool InsetTabular::insetAllowed(InsetOld::Code code) const
{
if (the_locking_inset)
return the_locking_inset->insetAllowed(code);
}
-bool InsetTabular::forceDefaultParagraphs(Inset const * in) const
+bool InsetTabular::forceDefaultParagraphs(InsetOld const * in) const
{
const int cell = tabular.getCellFromInset(in, actcell);
// well we didn't obviously find it so maybe our owner knows more
if (owner())
return owner()->forceDefaultParagraphs(in);
+
// if we're here there is really something strange going on!!!
+ lyxerr << "if we're here there is really something strange going on!\n";
return false;
}
if (cols < columns) {
InsetText & inset = loctab->getCellInset(cell);
LyXFont const font = inset.getLyXText(bv)->
- getFont(bv->buffer(), 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.getLyXText(bv)->
- getFont(bv->buffer(), inset.paragraphs.begin(), 0);
+ getFont(inset.paragraphs.begin(), 0);
inset.setText(buf.substr(op, p - op), font);
}
cols = ocol;
if (cell < cells && op < len) {
InsetText & inset = loctab->getCellInset(cell);
LyXFont const font = inset.getLyXText(bv)->
- getFont(bv->buffer(), inset.paragraphs.begin(), 0);
+ getFont(inset.paragraphs.begin(), 0);
inset.setText(buf.substr(op, len - op), font);
}
{}
-string const InsetTabularMailer::inset2string() const
+string const InsetTabularMailer::inset2string(Buffer const &) const
{
return params2string(inset_);
}