#include <algorithm>
#include <cstdlib>
#include <map>
-//#include <signal.h>
using namespace lyx::support;
+using namespace lyx::graphics;
using std::vector;
using std::ostream;
using std::endl;
using std::swap;
using std::max;
+using std::auto_ptr;
-namespace grfx = lyx::graphics;
namespace {
InsetTabular::InsetTabular(Buffer const & buf, int rows, int columns)
: tabular(buf.params, this, max(rows, 1), max(columns, 1)),
- buffer_(&buf)
+ buffer_(&buf), cursorx_(0), cursory_(0)
{
// for now make it always display as display() inset
// just for test!!!
InsetTabular::InsetTabular(InsetTabular const & tab)
: UpdatableInset(tab),
tabular(tab.buffer_->params, this, tab.tabular),
- buffer_(tab.buffer_)
+ buffer_(tab.buffer_), cursorx_(0), cursory_(0)
{
the_locking_inset = 0;
old_locking_inset = 0;
InsetTabular::~InsetTabular()
{
- InsetTabularMailer mailer(*this);
- mailer.hideDialog();
+ InsetTabularMailer(*this).hideDialog();
}
-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);
}
void InsetTabular::metrics(MetricsInfo & mi, Dimension & dim) const
{
- if (mi.base.bv) {
- calculate_dimensions_of_cells(mi.base.bv);
- //lyxerr << "InsetTabular::metrics, bv: " << mi.base.bv << endl;
- for (int i = 0; i < tabular.getNumberOfCells(); ++i) {
- tabular.cellinfo_of_cell(i)->inset.text_.bv_owner = mi.base.bv;
- tabular.cellinfo_of_cell(i)->inset.reinitLyXText();
- }
+ //lyxerr << "InsetTabular::metrics: " << mi.base.bv << " width: " <<
+ // mi.base.textwidth << "\n";
+ if (!mi.base.bv) {
+ 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;
+ dim_ = dim;
}
void InsetTabular::draw(PainterInfo & pi, int x, int y) const
{
+ //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;
void InsetTabular::updateLocal(BufferView * bv, UpdateCodes what) const
{
- if (what == INIT) {
- calculate_dimensions_of_cells(bv);
- }
+ lyxerr << "InsetTabular::updateLocal: " << what << "\n";
if (!locked && what == CELL)
what = FULL;
if (need_update < what) // only set this if it has greater update
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;
if (the_locking_inset->unlockInsetInInset(bv, inset, lr)) {
if (inset->lyxCode() == TABULAR_CODE &&
!the_locking_inset->getFirstLockingInsetOfType(TABULAR_CODE)) {
- InsetTabularMailer mailer(*this);
- mailer.updateDialog(bv);
+ InsetTabularMailer(*this).updateDialog(bv);
oldcell = actcell;
}
return true;
}
-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);
case LFUN_ENDBUFSEL:
break;
case LFUN_LAYOUT_TABULAR: {
- InsetTabularMailer mailer(*this);
- mailer.showDialog(bv);
+ InsetTabularMailer(*this).showDialog(bv);
break;
}
case LFUN_INSET_DIALOG_UPDATE: {
- InsetTabularMailer mailer(*this);
- mailer.updateDialog(bv);
+ InsetTabularMailer(*this).updateDialog(bv);
break;
}
case LFUN_TABULAR_FEATURE:
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) {
}
-void InsetTabular::calculate_dimensions_of_cells(BufferView * bv) const
+void InsetTabular::calculate_dimensions_of_cells(MetricsInfo & mi) const
{
- // FIXME: since InsetText ignores this anyway, it doesn't
- // matter what we pass it. Ugly
- LyXFont font;
-
+#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 ;)
+ // 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 i = 0; i < tabular.columns(); ++i) {
+ for (int j = 0; j < tabular.columns(); ++j) {
Dimension dim;
- MetricsInfo mi(bv, font);
- tabular.getCellInset(actrow, i)->metrics(mi, dim);
- maxAsc = max(dim.asc, maxAsc);
+ 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(bv, font));
+ 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;
bool changed = false;
for (int i = 0; i < tabular.rows(); ++i) {
- maxAsc = 0;
- maxDesc = 0;
+ int maxAsc = 0;
+ int maxDesc = 0;
for (int j = 0; j < tabular.columns(); ++j) {
- if (tabular.isPartOfMultiColumn(i,j))
+ if (tabular.isPartOfMultiColumn(i, j))
continue;
++cell;
Dimension dim;
- MetricsInfo mi(bv, font);
- tabular.getCellInset(cell)->metrics(mi, dim);
- maxAsc = max(maxAsc, dim.asc);
+ MetricsInfo m = mi;
+ m.base.textwidth =
+ tabular.column_info[j].p_width.inPixels(mi.base.textwidth);
+ tabular.getCellInset(cell).metrics(m, dim);
+ maxAsc = max(maxAsc, dim.asc);
maxDesc = max(maxDesc, dim.des);
changed = tabular.setWidthOfCell(cell, dim.wid) || changed;
}
changed = tabular.setAscentOfRow(i, maxAsc + ADD_TO_HEIGHT) || changed;
changed = tabular.setDescentOfRow(i, maxDesc + ADD_TO_HEIGHT) || changed;
}
- if (changed)
- tabular.reinit();
+ //if (changed)
+ // tabular.reinit();
}
return;
}
- x = cursor_.x();
- y = cursor_.y() + InsetTabular::y();
+ x = cursorx_;
+ y = cursory_ + InsetTabular::y();
// Fun stuff
int desc = tabular.getDescentOfRow(actrow);
the_locking_inset->getCursorPos(bv, x, y);
return;
}
- x = cursor_.x() - top_x;
- y = cursor_.y();
+ x = cursorx_ - top_x;
+ y = cursory_;
}
int const desc = font_metrics::maxDescent(font);
resetPos(bv);
- if (bv->fitLockedInsetCursor(cursor_.x(), cursor_.y(), asc, desc))
+ if (bv->fitLockedInsetCursor(cursorx_, cursory_, asc, desc))
need_update = FULL;
}
void InsetTabular::setPos(BufferView * bv, int x, int y) const
{
- cursor_.y(0);
-
+ cursory_ = 0;
actcell = actrow = actcol = 0;
int ly = tabular.getDescentOfRow(actrow);
// first search the right row
- while ((ly < y) && ((actrow+1) < tabular.rows())) {
- cursor_.y(cursor_.y() + tabular.getDescentOfRow(actrow) +
+ while (ly < y && actrow + 1 < tabular.rows()) {
+ cursory_ += tabular.getDescentOfRow(actrow) +
tabular.getAscentOfRow(actrow + 1) +
- tabular.getAdditionalHeight(actrow + 1));
+ tabular.getAdditionalHeight(actrow + 1);
++actrow;
- ly = cursor_.y() + tabular.getDescentOfRow(actrow);
+ ly = cursory_ + tabular.getDescentOfRow(actrow);
}
actcell = tabular.getCellNumber(actrow, actcol);
lx += tabular.getWidthOfColumn(actcell + 1)
+ tabular.getAdditionalWidth(actcell);
}
- cursor_.x(lx - tabular.getWidthOfColumn(actcell) + top_x + 2);
+ cursorx_ = lx - tabular.getWidthOfColumn(actcell) + top_x + 2;
resetPos(bv);
}
int cell = 0;
actcol = tabular.column_of_cell(actcell);
actrow = 0;
- cursor_.y(0);
- for (; (cell < actcell) && !tabular.isLastRow(cell); ++cell) {
+ cursory_ = 0;
+ for (; cell < actcell && !tabular.isLastRow(cell); ++cell) {
if (tabular.isLastCellInRow(cell)) {
- cursor_.y(cursor_.y() + tabular.getDescentOfRow(actrow) +
+ cursory_ += tabular.getDescentOfRow(actrow) +
tabular.getAscentOfRow(actrow + 1) +
- tabular.getAdditionalHeight(actrow + 1));
+ tabular.getAdditionalHeight(actrow + 1);
++actrow;
}
}
if (!locked || nodraw()) {
if (the_locking_inset)
- inset_y = cursor_.y();
+ inset_y = cursory_;
return;
}
// we need this only from here on!!!
++in_reset_pos;
static int const offset = ADD_TO_TABULAR_WIDTH + 2;
int new_x = getCellXPos(actcell);
- int old_x = cursor_.x();
+ int old_x = cursorx_;
new_x += offset;
- cursor_.x(new_x);
+ cursorx_ = new_x;
// cursor.x(getCellXPos(actcell) + offset);
if ((actcol < tabular.columns() - 1) && scroll(false) &&
(tabular.getWidthOfTabular() < bv->workWidth()-20))
scroll(bv, 0.0F);
updateLocal(bv, FULL);
} else if (the_locking_inset &&
- (tabular.getWidthOfColumn(actcell) > bv->workWidth()-20))
+ tabular.getWidthOfColumn(actcell) > bv->workWidth() - 20)
{
- int xx = cursor_.x() - offset + bv->text->getRealCursorX();
+ int xx = cursorx_ - offset + bv->text->getRealCursorX();
if (xx > (bv->workWidth()-20)) {
scroll(bv, -(xx - bv->workWidth() + 60));
updateLocal(bv, FULL);
scroll(bv, xx);
updateLocal(bv, FULL);
}
- } else if ((cursor_.x() - offset) > 20 &&
- (cursor_.x() - offset + tabular.getWidthOfColumn(actcell))
+ } else if ((cursorx_ - offset) > 20 &&
+ (cursorx_ - offset + tabular.getWidthOfColumn(actcell))
> (bv->workWidth() - 20)) {
scroll(bv, -tabular.getWidthOfColumn(actcell) - 20);
updateLocal(bv, FULL);
- } else if ((cursor_.x() - offset) < 20) {
- scroll(bv, 20 - cursor_.x() + offset);
+ } else if ((cursorx_ - offset) < 20) {
+ scroll(bv, 20 - cursorx_ + offset);
updateLocal(bv, FULL);
} else if (scroll() && top_x > 20 &&
(top_x + tabular.getWidthOfTabular()) > (bv->workWidth() - 20)) {
- scroll(bv, old_x - cursor_.x());
+ scroll(bv, old_x - cursorx_);
updateLocal(bv, FULL);
}
if (the_locking_inset) {
- inset_x = cursor_.x() - top_x + tabular.getBeginningOfTextInCell(actcell);
- inset_y = cursor_.y();
+ inset_x = cursorx_ - top_x + tabular.getBeginningOfTextInCell(actcell);
+ inset_y = cursory_;
}
if ((!the_locking_inset ||
!the_locking_inset->getFirstLockingInsetOfType(TABULAR_CODE)) &&
actcell != oldcell) {
- InsetTabular * inset = const_cast<InsetTabular *>(this);
- InsetTabularMailer mailer(*inset);
- mailer.updateDialog(bv);
+ InsetTabularMailer(*this).updateDialog(bv);
oldcell = actcell;
}
in_reset_pos = 0;
}
-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);
int y = 0;
if (old_locking_inset) {
old_locking_inset->getCursorPos(bv, x, y);
- x -= cursor_.x() + tabular.getBeginningOfTextInCell(actcell);
+ x -= cursorx_ + tabular.getBeginningOfTextInCell(actcell);
}
if (activateCellInset(bv, x, 0))
return DISPATCHED;
}
-Inset::RESULT InsetTabular::moveDown(BufferView * bv, bool lock)
+InsetOld::RESULT InsetTabular::moveDown(BufferView * bv, bool lock)
{
int const ocell = actcell;
actcell = tabular.getCellBelow(actcell);
int y = 0;
if (old_locking_inset) {
old_locking_inset->getCursorPos(bv, x, y);
- x -= cursor_.x() + tabular.getBeginningOfTextInCell(actcell);
+ x -= cursorx_ + tabular.getBeginningOfTextInCell(actcell);
}
if (activateCellInset(bv, x, 0))
return DISPATCHED;
++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);
}
}
case LyXTabular::UNSET_LTFIRSTHEAD:
flag = false;
case LyXTabular::SET_LTFIRSTHEAD:
- (void)tabular.getRowOfLTFirstHead(row, ltt);
+ tabular.getRowOfLTFirstHead(row, ltt);
checkLongtableSpecial(ltt, value, flag);
tabular.setLTHead(row, flag, ltt, true);
break;
case LyXTabular::UNSET_LTHEAD:
flag = false;
case LyXTabular::SET_LTHEAD:
- (void)tabular.getRowOfLTHead(row, ltt);
+ tabular.getRowOfLTHead(row, ltt);
checkLongtableSpecial(ltt, value, flag);
tabular.setLTHead(row, flag, ltt, false);
break;
case LyXTabular::UNSET_LTFOOT:
flag = false;
case LyXTabular::SET_LTFOOT:
- (void)tabular.getRowOfLTFoot(row, ltt);
+ tabular.getRowOfLTFoot(row, ltt);
checkLongtableSpecial(ltt, value, flag);
tabular.setLTFoot(row, flag, ltt, false);
break;
case LyXTabular::UNSET_LTLASTFOOT:
flag = false;
case LyXTabular::SET_LTLASTFOOT:
- (void)tabular.getRowOfLTLastFoot(row, ltt);
+ tabular.getRowOfLTLastFoot(row, ltt);
checkLongtableSpecial(ltt, value, flag);
tabular.setLTFoot(row, flag, ltt, true);
break;
break;
}
- InsetTabularMailer mailer(*this);
- mailer.updateDialog(bv);
+ InsetTabularMailer(*this).updateDialog(bv);
}
-bool InsetTabular::activateCellInset(BufferView * bv, int x, int y, mouse_button::state button,
- bool behind)
+bool InsetTabular::activateCellInset(BufferView * bv, int x, int y,
+ mouse_button::state button, bool behind)
{
- UpdatableInset * inset =
- static_cast<UpdatableInset*>(tabular.getCellInset(actcell));
- LyXFont font(LyXFont::ALL_SANE);
+ UpdatableInset & inset = tabular.getCellInset(actcell);
if (behind) {
- x = inset->x() + inset->width(bv, font);
- y = inset->descent(bv, font);
+#warning metrics?
+ x = inset.x() + inset.width();
+ y = inset.descent();
}
- //inset_x = cursor.x() - top_x + tabular.getBeginningOfTextInCell(actcell);
- //inset_y = cursor.y();
- inset->localDispatch(FuncRequest(bv, LFUN_INSET_EDIT, x, y, button));
+ //inset_x = cursorx_ - top_x + tabular.getBeginningOfTextInCell(actcell);
+ //inset_y = cursory_;
+ inset.localDispatch(FuncRequest(bv, LFUN_INSET_EDIT, x, y, button));
if (!the_locking_inset)
return false;
updateLocal(bv, CELL);
bool InsetTabular::activateCellInsetAbs(BufferView * bv, int x, int y,
mouse_button::state button)
{
- inset_x = cursor_.x()
- - top_x + tabular.getBeginningOfTextInCell(actcell);
- inset_y = cursor_.y();
+ inset_x = cursorx_ - top_x + tabular.getBeginningOfTextInCell(actcell);
+ inset_y = cursory_;
return activateCellInset(bv, x - inset_x, y - inset_y, button);
}
bool InsetTabular::insetHit(BufferView *, int x, int) const
{
- return (x + top_x)
- > (cursor_.x() + tabular.getBeginningOfTextInCell(actcell));
-}
-
-
-// This returns paperWidth() if the cell-width is unlimited or the width
-// in pixels if we have a pwidth for this cell.
-int InsetTabular::getMaxWidthOfCell(BufferView * bv, int cell) const
-{
- LyXLength const len = tabular.getPWidth(cell);
-
- if (len.zero())
- return -1;
- return len.inPixels(latexTextWidth(bv));
-}
-
-
-int InsetTabular::getMaxWidth(BufferView * bv,
- UpdatableInset const * inset) const
-{
- int cell = tabular.getCellFromInset(inset, actcell);
-
- if (cell == -1) {
- lyxerr << "Own inset not found, shouldn't really happen!"
- << endl;
- return -1;
- }
-
- int w = getMaxWidthOfCell(bv, cell);
- if (w > 0) {
- // because the inset then subtracts it's top_x and owner->x()
- w += (inset->x() - top_x);
- }
-
- return w;
+ return x + top_x
+ > cursorx_ + tabular.getBeginningOfTextInCell(actcell);
}
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);
-#if 0
- // if we're locked lock the actual insettext and return it's LyXText!!!
- if (locked) {
- UpdatableInset * inset =
- static_cast<UpdatableInset*>(tabular.getCellInset(actcell));
- inset->edit(const_cast<BufferView *>(bv), 0, 0, 0);
- return the_locking_inset->getLyXText(bv, recursive);
- }
-#endif
- return Inset::getLyXText(bv, recursive);
+ return InsetOld::getLyXText(bv, recursive);
}
bool InsetTabular::showInsetDialog(BufferView * bv) const
{
- if (!the_locking_inset || !the_locking_inset->showInsetDialog(bv)) {
- InsetTabular * tmp = const_cast<InsetTabular *>(this);
- InsetTabularMailer mailer(*tmp);
- mailer.showDialog(bv);
- }
+ if (!the_locking_inset || !the_locking_inset->showInsetDialog(bv))
+ InsetTabularMailer(*this).showDialog(bv);
return true;
}
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;
}
}
- InsetTabular * tmp = const_cast<InsetTabular *>(this);
- InsetTabularMailer mailer(*tmp);
- mailer.showDialog(bv);
+ InsetTabularMailer(*this).showDialog(bv);
}
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);
- Inset * result;
- for(int i = 0; i < tabular.rows(); ++i) {
- for(int j = 0; j < tabular.columns(); ++j) {
- if ((result = tabular.getCellInset(i, j)->getInsetFromID(id_arg)))
- return result;
+ for (int i = 0; i < tabular.rows(); ++i) {
+ for (int j = 0; j < tabular.columns(); ++j) {
+ InsetOld * inset = tabular.getCellInset(i, j).getInsetFromID(id_arg);
+ if (inset)
+ return inset;
}
}
return 0;
++actcell;
}
// otherwise we have to lock the next inset and ask for it's selecttion
- UpdatableInset * inset =
- static_cast<UpdatableInset*>(tabular.getCellInset(actcell));
- inset->localDispatch(FuncRequest(bv, LFUN_INSET_EDIT));
+ tabular.getCellInset(actcell)
+ .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
- UpdatableInset * inset =
- static_cast<UpdatableInset*>(tabular.getCellInset(++actcell));
- inset->localDispatch(FuncRequest(bv, LFUN_INSET_EDIT));
+ ++actcell;
+ tabular.getCellInset(actcell)
+ .localDispatch(FuncRequest(bv, LFUN_INSET_EDIT));
return selectNextWordInt(bv, value);
}
void InsetTabular::selectSelectedWord(BufferView * bv)
{
- if (the_locking_inset) {
+ if (the_locking_inset)
the_locking_inset->selectSelectedWord(bv);
- return;
- }
- return;
}
void InsetTabular::toggleSelection(BufferView * bv, bool kill_selection)
{
- if (the_locking_inset) {
+ if (the_locking_inset)
the_locking_inset->toggleSelection(bv, kill_selection);
- }
}
void InsetTabular::markErased()
{
- int cell = 0;
-
- while (cell < tabular.getNumberOfCells()) {
- InsetText * inset = tabular.getCellInset(cell);
- inset->markErased();
- ++cell;
- }
+ for (int cell = 0; cell < tabular.getNumberOfCells(); ++cell)
+ 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;
}
+
bool InsetTabular::insertAsciiString(BufferView * bv, string const & buf,
bool usePaste)
{
rows = loctab->rows();
int const columns = loctab->columns();
- while ((cell < cells) && (p < len) && (row < rows) &&
+ while (cell < cells && p < len && row < rows &&
(p = buf.find_first_of("\t\n", p)) != string::npos)
{
if (p >= len)
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;
op = p;
}
// 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);
+ if (cell < cells && op < len) {
+ 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;
}
-void InsetTabular::addPreview(grfx::PreviewLoader & loader) const
+void InsetTabular::addPreview(PreviewLoader & loader) const
{
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:: name_("tabular");
+string const InsetTabularMailer::name_("tabular");
-InsetTabularMailer::InsetTabularMailer(InsetTabular & inset)
- : inset_(inset)
+InsetTabularMailer::InsetTabularMailer(InsetTabular const & inset)
+ : inset_(const_cast<InsetTabular &>(inset))
{}
-string const InsetTabularMailer::inset2string() const
+string const InsetTabularMailer::inset2string(Buffer const &) const
{
return params2string(inset_);
}
projects / lyx.git / blobdiff