#include "insettabular.h"
#include "buffer.h"
+#include "bufferparams.h"
#include "BufferView.h"
#include "debug.h"
#include "funcrequest.h"
#include "FuncStatus.h"
#include "gettext.h"
#include "language.h"
+#include "LColor.h"
#include "lyx_cb.h"
#include "lyxlex.h"
#include "metricsinfo.h"
+#include "paragraph.h"
#include "paragraph_funcs.h"
#include "ParagraphParameters.h"
#include "undo_funcs.h"
#include "frontends/LyXView.h"
#include "frontends/Painter.h"
-#include "support/LAssert.h"
+#include "support/std_sstream.h"
+#include <iostream>
-#include "Lsstream.h"
+using lyx::graphics::PreviewLoader;
-using namespace lyx::support;
-using namespace lyx::graphics;
+using lyx::support::ltrim;
+using lyx::support::strToInt;
using std::endl;
using std::max;
using std::swap;
+using std::string;
using std::auto_ptr;
-using std::ifstream;
+using std::istringstream;
using std::ostream;
-using std::vector;
+using std::ostringstream;
namespace {
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;
BufferView * InsetTabular::view() const
{
- Assert(false);
+ BOOST_ASSERT(false);
return 0;
}
// mi.base.textwidth << "\n";
if (!mi.base.bv) {
lyxerr << "InsetTabular::metrics: need bv" << endl;
- Assert(0);
+ BOOST_ASSERT(false);
}
calculate_dimensions_of_cells(mi);
void InsetTabular::drawCellSelection(Painter & pain, int x, int y,
int row, int column, int cell) const
{
- Assert(hasSelection());
+ BOOST_ASSERT(hasSelection());
int cs = tabular.column_of_cell(sel_cell_start);
int ce = tabular.column_of_cell(sel_cell_end);
if (cs > ce) {
}
-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) {
// no break here!
case LFUN_DELETE:
recordUndo(bv, Undo::DELETE);
- cutSelection(bv->buffer()->params);
+ cutSelection(bv->buffer()->params());
updateLocal(bv);
break;
case LFUN_COPY:
}
maxCols = max(cols, maxCols);
delete paste_tabular;
- paste_tabular = new LyXTabular(bv->buffer()->params,
+ paste_tabular = new LyXTabular(bv->buffer()->params(),
this, rows, maxCols);
string::size_type op = 0;
int cell = 0;
}
// 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);
}
if (lock) {
bool rtl = tabular.getCellInset(actcell).paragraphs.begin()->
- isRightToLeftPar(bv->buffer()->params);
+ isRightToLeftPar(bv->buffer()->params());
activateCellInset(bv, 0, 0, mouse_button::none, !rtl);
}
resetPos(bv);
}
if (lock) {
bool rtl = tabular.getCellInset(actcell).paragraphs.begin()->
- isRightToLeftPar(bv->buffer()->params);
+ isRightToLeftPar(bv->buffer()->params());
activateCellInset(bv, 0, 0, mouse_button::none, !rtl);
}
resetPos(bv);
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)
case LyXTabular::APPEND_ROW:
// append the row into the tabular
unlockInsetInInset(bv, the_locking_inset);
- tabular.appendRow(bv->buffer()->params, actcell);
+ 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.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);
ostringstream os;
paste_tabular->ascii(*bv->buffer(), os,
ownerPar(*bv->buffer(), this).params().depth(), true, '\t');
- bv->stuffClipboard(STRCONV(os.str()));
+ bv->stuffClipboard(os.str());
return 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(tabular.getCellNumber(i, j)).clear(bp.tracking_changes);
+ tabular.getCellInset(tabular.getCellNumber(i, j))
+ .clear(bp.tracking_changes);
return true;
}
WordLangTuple InsetTabular::selectNextWordInt(BufferView * bv, float & value) const
{
// when entering this function the inset should be ALWAYS locked!
- Assert(the_locking_inset);
+ BOOST_ASSERT(the_locking_inset);
WordLangTuple word(the_locking_inset->selectNextWordToSpellcheck(bv, value));
if (!word.word().empty())
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);
}
int row = 0;
if (usePaste) {
delete paste_tabular;
- paste_tabular = new LyXTabular(bv->buffer()->params,
- this, rows, maxCols);
+ paste_tabular = new LyXTabular(bv->buffer()->params(),
+ rows, maxCols);
+ paste_tabular->setOwner(this);
loctab = paste_tabular;
cols = 0;
} else {
int InsetTabularMailer::string2params(string const & in, InsetTabular & inset)
{
- istringstream data(STRCONV(in));
+ istringstream data(in);
LyXLex lex(0,0);
lex.setStream(data);
data << name_ << " \\active_cell " << inset.getActCell() << '\n';
inset.write(buffer, data);
data << "\\end_inset\n";
- return STRCONV(data.str());
+ return data.str();
}
projects / lyx.git / blobdiff