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()) {
drawCellSelection(pi.pain, nx, y, i, j, cell);
}
- tabular.getCellInset(cell)->draw(pi, cx, y);
+ tabular.getCellInset(cell).draw(pi, cx, y);
drawCellLines(pi.pain, nx, y, i, cell);
nx += tabular.getWidthOfColumn(cell);
++cell;
if (!inset)
return false;
oldcell = -1;
- if (inset == tabular.getCellInset(actcell)) {
+ if (inset == &tabular.getCellInset(actcell)) {
lyxerr[Debug::INSETTEXT] << "OK" << endl;
- the_locking_inset = tabular.getCellInset(actcell);
+ the_locking_inset = &tabular.getCellInset(actcell);
resetPos(bv);
return true;
} else if (!the_locking_inset) {
int const n = tabular.getNumberOfCells();
int const id = inset->id();
for (int i = 0; i < n; ++i) {
- InsetText * in = tabular.getCellInset(i);
+ InsetText * in = &tabular.getCellInset(i);
if (inset == in) {
actcell = i;
the_locking_inset = in;
}
-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);
}
if (inset_hit && bv->theLockingInset()) {
- if (!bv->lockInset(static_cast<UpdatableInset*>
- (tabular.getCellInset(actcell))))
- {
+ if (!bv->lockInset(&tabular.getCellInset(actcell))) {
lyxerr[Debug::INSETS] << "Cannot lock inset" << endl;
return;
}
}
-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) {
// change so I'll try this to have a boost, but who knows ;) (Jug?)
// This is _really_ important (André)
if (need_update != INIT &&
- the_locking_inset == tabular.getCellInset(actcell)) {
+ the_locking_inset == &tabular.getCellInset(actcell)) {
int maxAsc = 0;
int maxDesc = 0;
for (int j = 0; j < tabular.columns(); ++j) {
MetricsInfo m = mi;
m.base.textwidth =
tabular.column_info[j].p_width.inPixels(mi.base.textwidth);
- tabular.getCellInset(actrow, j)->metrics(m, dim);
+ tabular.getCellInset(actrow, j).metrics(m, dim);
maxAsc = max(dim.asc, maxAsc);
maxDesc = max(dim.des, maxDesc);
}
MetricsInfo m = mi;
m.base.textwidth =
tabular.column_info[j].p_width.inPixels(mi.base.textwidth);
- tabular.getCellInset(cell)->metrics(m, dim);
+ tabular.getCellInset(cell).metrics(m, dim);
maxAsc = max(maxAsc, dim.asc);
maxDesc = max(maxDesc, dim.des);
changed = tabular.setWidthOfCell(cell, dim.wid) || changed;
}
-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);
++actcell;
}
if (lock) {
- bool rtl = tabular.getCellInset(actcell)->paragraphs.begin()->
+ bool rtl = tabular.getCellInset(actcell).paragraphs.begin()->
isRightToLeftPar(bv->buffer()->params);
activateCellInset(bv, 0, 0, mouse_button::none, !rtl);
}
--actcell;
}
if (lock) {
- bool rtl = tabular.getCellInset(actcell)->paragraphs.begin()->
+ bool rtl = tabular.getCellInset(actcell).paragraphs.begin()->
isRightToLeftPar(bv->buffer()->params);
activateCellInset(bv, 0, 0, mouse_button::none, !rtl);
}
setSelection(0, tabular.getNumberOfCells() - 1);
}
if (hasSelection()) {
- setUndo(bv, Undo::EDIT);
+ recordUndo(bv, Undo::ATOMIC);
bool const frozen = undo_frozen;
if (!frozen)
freezeUndo();
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);
- }
- }
+ 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)
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);
// until later (see InsetText::do_resize)
unlockInsetInInset(bv, the_locking_inset);
- int cell;
- for (int i = 0; i < tabular.rows(); ++i) {
- cell = tabular.getCellNumber(i,column);
- tabular.getCellInset(cell)->resizeLyXText(bv);
- }
+ for (int i = 0; i < tabular.rows(); ++i)
+ tabular.getCellInset(i, column).resizeLyXText(bv);
updateLocal(bv, INIT);
}
// until later (see InsetText::do_resize)
unlockInsetInInset(bv, the_locking_inset);
- for (int i = 0; i < tabular.rows(); ++i) {
- tabular.getCellInset(tabular.getCellNumber(i, column))->
- resizeLyXText(bv);
- }
+ for (int i = 0; i < tabular.rows(); ++i)
+ tabular.getCellInset(i, column).resizeLyXText(bv);
+
updateLocal(bv, INIT);
}
}
bool InsetTabular::activateCellInset(BufferView * bv, int x, int y,
mouse_button::state button, bool behind)
{
- UpdatableInset * inset =
- static_cast<UpdatableInset*>(tabular.getCellInset(actcell));
+ UpdatableInset & inset = tabular.getCellInset(actcell);
if (behind) {
#warning metrics?
- x = inset->x() + inset->width();
- y = inset->descent();
+ x = inset.x() + inset.width();
+ y = inset.descent();
}
//inset_x = cursorx_ - top_x + tabular.getBeginningOfTextInCell(actcell);
//inset_y = cursory_;
- inset->localDispatch(FuncRequest(bv, LFUN_INSET_EDIT, x, y, button));
+ inset.localDispatch(FuncRequest(bv, LFUN_INSET_EDIT, x, y, button));
if (!the_locking_inset)
return false;
updateLocal(bv, CELL);
void InsetTabular::resizeLyXText(BufferView * bv, bool force) const
{
- if (force) {
- for(int i = 0; i < tabular.rows(); ++i) {
- for(int j = 0; j < tabular.columns(); ++j) {
- tabular.getCellInset(i, j)->resizeLyXText(bv, true);
- }
- }
- }
+ if (force)
+ for(int i = 0; i < tabular.rows(); ++i)
+ for(int j = 0; j < tabular.columns(); ++j)
+ tabular.getCellInset(i, j).resizeLyXText(bv, true);
need_update = FULL;
}
{
if (the_locking_inset)
return the_locking_inset->getLyXText(bv, recursive);
- return Inset::getLyXText(bv, recursive);
+ return InsetOld::getLyXText(bv, recursive);
}
void InsetTabular::openLayoutDialog(BufferView * bv) const
{
if (the_locking_inset) {
- InsetTabular * i = static_cast<InsetTabular *>
+ InsetTabular * inset = static_cast<InsetTabular *>
(the_locking_inset->getFirstLockingInsetOfType(TABULAR_CODE));
- if (i) {
- i->openLayoutDialog(bv);
+ if (inset) {
+ inset->openLayoutDialog(bv);
return;
}
}
return false;
for (int r1 = 0, r2 = actrow;
- (r1 < paste_tabular->rows()) && (r2 < tabular.rows());
+ r1 < paste_tabular->rows() && r2 < tabular.rows();
++r1, ++r2) {
- for(int c1 = 0, c2 = actcol;
- (c1 < paste_tabular->columns()) && (c2 < tabular.columns());
+ for (int c1 = 0, c2 = actcol;
+ c1 < paste_tabular->columns() && c2 < tabular.columns();
++c1, ++c2) {
- if (paste_tabular->isPartOfMultiColumn(r1,c1) &&
- tabular.isPartOfMultiColumn(r2,c2))
+ if (paste_tabular->isPartOfMultiColumn(r1, c1) &&
+ tabular.isPartOfMultiColumn(r2, c2))
continue;
- if (paste_tabular->isPartOfMultiColumn(r1,c1)) {
+ if (paste_tabular->isPartOfMultiColumn(r1, c1)) {
--c2;
continue;
}
- if (tabular.isPartOfMultiColumn(r2,c2)) {
+ if (tabular.isPartOfMultiColumn(r2, c2)) {
--c1;
continue;
}
- int const n1 = paste_tabular->getCellNumber(r1, c1);
- int const n2 = tabular.getCellNumber(r2, c2);
- *(tabular.getCellInset(n2)) = *(paste_tabular->getCellInset(n1));
- tabular.getCellInset(n2)->setOwner(this);
- tabular.getCellInset(n2)->deleteLyXText(bv);
- tabular.getCellInset(n2)->markNew();
+ InsetText & inset = tabular.getCellInset(r2, c2);
+ inset = paste_tabular->getCellInset(r1, c1);
+ inset.setOwner(this);
+ inset.deleteLyXText(bv);
+ inset.markNew();
}
}
return true;
if (sel_cell_start > sel_cell_end) {
swap(sel_cell_start, sel_cell_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(tabular.getCellNumber(i, j))->clear(bp.tracking_changes);
- }
- }
+ 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);
return true;
}
ParagraphList * InsetTabular::getParagraphs(int i) const
{
return (i < tabular.getNumberOfCells())
- ? tabular.getCellInset(i)->getParagraphs(0)
+ ? tabular.getCellInset(i).getParagraphs(0)
: 0;
}
{
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;
}
}
// otherwise we have to lock the next inset and ask for it's selecttion
tabular.getCellInset(actcell)
- ->localDispatch(FuncRequest(bv, LFUN_INSET_EDIT));
+ .localDispatch(FuncRequest(bv, LFUN_INSET_EDIT));
WordLangTuple word(selectNextWordInt(bv, value));
nodraw(false);
if (!word.word().empty())
// otherwise we have to lock the next inset and ask for it's selecttion
++actcell;
tabular.getCellInset(actcell)
- ->localDispatch(FuncRequest(bv, LFUN_INSET_EDIT));
+ .localDispatch(FuncRequest(bv, LFUN_INSET_EDIT));
return selectNextWordInt(bv, value);
}
void InsetTabular::markErased()
{
for (int cell = 0; cell < tabular.getNumberOfCells(); ++cell)
- tabular.getCellInset(cell)->markErased();
+ tabular.getCellInset(cell).markErased();
}
return false;
++actcell;
}
- InsetText * inset = tabular.getCellInset(actcell);
- if (inset->nextChange(bv, length)) {
+ InsetText & inset = tabular.getCellInset(actcell);
+ if (inset.nextChange(bv, length)) {
updateLocal(bv, FULL);
return true;
}
while (!tabular.isLastCell(actcell)) {
++actcell;
- inset = tabular.getCellInset(actcell);
- if (inset->nextChange(bv, length)) {
+ InsetText & inset = tabular.getCellInset(actcell);
+ if (inset.nextChange(bv, length)) {
updateLocal(bv, FULL);
return true;
}
return false;
cell = actcell + 1;
}
- InsetText * inset = tabular.getCellInset(cell);
- if (inset->searchForward(bv, str, cs, mw)) {
+ InsetText & inset = tabular.getCellInset(cell);
+ if (inset.searchForward(bv, str, cs, mw)) {
updateLocal(bv, FULL);
return true;
}
while (!tabular.isLastCell(cell)) {
++cell;
- inset = tabular.getCellInset(cell);
- if (inset->searchForward(bv, str, cs, mw)) {
+ InsetText & inset = tabular.getCellInset(cell);
+ if (inset.searchForward(bv, str, cs, mw)) {
updateLocal(bv, FULL);
return true;
}
while (cell) {
--cell;
- InsetText * inset = tabular.getCellInset(cell);
- if (inset->searchBackward(bv, str, cs, mw)) {
+ InsetText & inset = tabular.getCellInset(cell);
+ if (inset.searchBackward(bv, str, cs, mw)) {
updateLocal(bv, CELL);
return true;
}
}
-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;
}
case '\t':
// we can only set this if we are not too far right
if (cols < columns) {
- InsetText * ti = loctab->getCellInset(cell);
- LyXFont const font = ti->getLyXText(bv)->
- getFont(bv->buffer(), ti->paragraphs.begin(), 0);
- ti->setText(buf.substr(op, p - op), font);
+ InsetText & inset = loctab->getCellInset(cell);
+ LyXFont const font = inset.getLyXText(bv)->
+ getFont(inset.paragraphs.begin(), 0);
+ inset.setText(buf.substr(op, p - op), font);
++cols;
++cell;
}
case '\n':
// we can only set this if we are not too far right
if (cols < columns) {
- InsetText * ti = loctab->getCellInset(cell);
- LyXFont const font = ti->getLyXText(bv)->
- getFont(bv->buffer(), ti->paragraphs.begin(), 0);
- ti->setText(buf.substr(op, p - op), font);
+ InsetText & inset = tabular.getCellInset(cell);
+ LyXFont const font = inset.getLyXText(bv)->
+ getFont(inset.paragraphs.begin(), 0);
+ inset.setText(buf.substr(op, p - op), font);
}
cols = ocol;
++row;
}
// check for the last cell if there is no trailing '\n'
if (cell < cells && op < len) {
- InsetText * ti = loctab->getCellInset(cell);
- LyXFont const font = ti->getLyXText(bv)->
- getFont(bv->buffer(), ti->paragraphs.begin(), 0);
- ti->setText(buf.substr(op, len - op), font);
+ InsetText & inset = loctab->getCellInset(cell);
+ LyXFont const font = inset.getLyXText(bv)->
+ getFont(inset.paragraphs.begin(), 0);
+ inset.setText(buf.substr(op, len - op), font);
}
return true;
{
int const rows = tabular.rows();
int const columns = tabular.columns();
- for (int i = 0; i < rows; ++i) {
- for (int j = 0; j < columns; ++j) {
- tabular.getCellInset(i,j)->addPreview(loader);
- }
- }
+ for (int i = 0; i < rows; ++i)
+ for (int j = 0; j < columns; ++j)
+ tabular.getCellInset(i, j).addPreview(loader);
}
{}
-string const InsetTabularMailer::inset2string() const
+string const InsetTabularMailer::inset2string(Buffer const &) const
{
return params2string(inset_);
}
projects / lyx.git / blobdiff