#include <config.h>
-#include <fstream>
-#include <algorithm>
-
-#include <cstdlib>
-#include <map>
-//#include <signal.h>
#ifdef __GNUG__
#pragma implementation
#endif
#include "lyx_gui_misc.h"
#include "LyXView.h"
#include "insets/insettext.h"
-#include "frontends/Dialogs.h"
-#include "frontends/Alert.h"
#include "debug.h"
#include "WorkArea.h"
#include "gettext.h"
#include "language.h"
#include "BufferView.h"
#include "undo_funcs.h"
+#include "lyxlength.h"
+#include "ParagraphParameters.h"
+
+#include "frontends/Dialogs.h"
+#include "frontends/Alert.h"
+
#include "support/LAssert.h"
#include "support/lstrings.h"
+#include <fstream>
+#include <algorithm>
+#include <cstdlib>
+#include <map>
+//#include <signal.h>
+
using std::ostream;
using std::ifstream;
using std::max;
namespace {
-const int ADD_TO_HEIGHT = 2;
-const int ADD_TO_TABULAR_WIDTH = 2;
+int const ADD_TO_HEIGHT = 2;
+int const ADD_TO_TABULAR_WIDTH = 2;
+
///
LyXTabular * paste_tabular = 0;
string feature;
};
-//tabular_features * tabularFeatures = 0;
TabularFeature tabularFeature[] =
{
// for now make it always display as display() inset
// just for test!!!
the_locking_inset = 0;
- locked = no_selection = false;
+ locked = false;
oldcell = -1;
actrow = actcell = 0;
clearSelection();
{
tabular.reset(new LyXTabular(this, *(tab.tabular), same_id));
the_locking_inset = 0;
- locked = no_selection = false;
+ locked = false;
oldcell = -1;
actrow = actcell = 0;
- sel_cell_start = sel_cell_end = 0;
+ clearSelection();
need_update = INIT;
in_update = false;
in_reset_pos = false;
{
bool const old_format = (lex.getString() == "\\LyXTable");
- //if (tabular)
- //delete tabular;
- //tabular = new LyXTabular(buf, this, lex);
tabular.reset(new LyXTabular(buf, this, lex));
need_update = INIT;
cx = nx + tabular->GetBeginningOfTextInCell(cell);
if (first_visible_cell < 0)
first_visible_cell = cell;
- if (hasSelection())
+ if (hasSelection()) {
drawCellSelection(pain, nx, baseline, i, j, cell);
+ }
- tabular->GetCellInset(cell)->draw(bv, font, baseline, cx,
- cleared);
+ tabular->GetCellInset(cell)->draw(bv, font, baseline, cx, cleared);
drawCellLines(pain, nx, baseline, i, cell);
nx += tabular->GetWidthOfColumn(cell);
++cell;
x += width(bv, font);
if (bv->text->status() == LyXText::CHANGED_IN_DRAW) {
int i = 0;
- for(Inset * inset=owner(); inset; ++i)
+ for(Inset * inset = owner(); inset; ++i)
inset = inset->owner();
if (calculate_dimensions_of_cells(bv, font, false))
need_update = INIT;
void InsetTabular::drawCellLines(Painter & pain, int x, int baseline,
- int row, int cell) const
+ int row, int cell) const
{
int x2 = x + tabular->GetWidthOfColumn(cell);
bool on_off;
void InsetTabular::drawCellSelection(Painter & pain, int x, int baseline,
int row, int column, int cell) const
{
+ lyx::Assert(hasSelection());
int cs = tabular->column_of_cell(sel_cell_start);
int ce = tabular->column_of_cell(sel_cell_end);
if (cs > ce) {
int rs = tabular->row_of_cell(sel_cell_start);
int re = tabular->row_of_cell(sel_cell_end);
- if (rs > re) swap(rs, re);
+ if (rs > re)
+ swap(rs, re);
if ((column >= cs) && (column <= ce) && (row >= rs) && (row <= re)) {
int w = tabular->GetWidthOfColumn(cell);
inset_x = 0;
inset_y = 0;
setPos(bv, x, y);
- sel_cell_start = sel_cell_end = actcell;
+ clearSelection();
finishUndo();
if (insetHit(bv, x, y) && (button != 3)) {
activateCellInsetAbs(bv, x, y, button);
actcell = 0;
else
actcell = tabular->GetNumberOfCells() - 1;
- sel_cell_start = sel_cell_end = actcell;
+ clearSelection();
resetPos(bv);
finishUndo();
}
the_locking_inset = 0;
}
hideInsetCursor(bv);
- no_selection = false;
oldcell = -1;
locked = false;
if (scroll(false) || hasSelection()) {
- sel_cell_start = sel_cell_end = 0;
+ clearSelection();
if (scroll(false)) {
scroll(bv, 0.0F);
}
}
if (need_update < what) // only set this if it has greater update
need_update = what;
- if ((what == INIT) && hasSelection())
+ if ((what == INIT) && hasSelection()) {
clearSelection();
+ }
// Dirty Cast! (Lgb)
if (need_update != NONE) {
bv->updateInset(const_cast<InsetTabular *>(this), mark_dirty);
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);
+ if (inset == in) {
+ actcell = i;
+ the_locking_inset = in;
+ locked = true;
+ resetPos(bv);
+ return true;
+ }
+ if (in->getInsetFromID(id)) {
+ actcell = i;
+ the_locking_inset = in;
+ locked = true;
+ resetPos(bv);
+ return the_locking_inset->lockInsetInInset(bv, inset);
+ }
+ }
} else if (the_locking_inset && (the_locking_inset == inset)) {
lyxerr[Debug::INSETTEXT] << "OK" << endl;
resetPos(bv);
updateLocal(bv, SELECTION, false);
}
- no_selection = false;
-
int const ocell = actcell;
int const orow = actrow;
setPos(bv, x, y);
if (actrow != orow)
updateLocal(bv, NONE, false);
- sel_cell_start = sel_cell_end = actcell;
+ clearSelection();
+#if 0
if (button == 3) {
if ((ocell != actcell) && the_locking_inset) {
the_locking_inset->insetUnlock(bv);
showInsetCursor(bv);
return;
}
+#endif
bool const inset_hit = insetHit(bv, x, y);
}
-void InsetTabular::insetButtonRelease(BufferView * bv,
- int x, int y, int button)
+bool InsetTabular::insetButtonRelease(BufferView * bv,
+ int x, int y, int button)
{
- if (button == 3) {
- if (the_locking_inset) {
- UpdatableInset * i;
- if ((i = the_locking_inset->getFirstLockingInsetOfType(TABULAR_CODE))) {
- i->insetButtonRelease(bv, x, y, button);
- return;
- }
- }
+ bool ret = false;
+ if (the_locking_inset)
+ ret = the_locking_inset->insetButtonRelease(bv, x, y, button);
+ if (button == 3 && !ret) {
bv->owner()->getDialogs()->showTabular(this);
- return;
- }
- if (the_locking_inset) {
- the_locking_inset->insetButtonRelease(bv,
- x - inset_x, y - inset_y,
- button);
- return;
+ return true;
}
- no_selection = false;
+ return ret;
}
button);
return;
}
- if (!no_selection) {
- hideInsetCursor(bv);
- int const old_cell = actcell;
-
- setPos(bv, x, y);
- sel_cell_end = actcell;
- if (sel_cell_end != old_cell)
- updateLocal(bv, SELECTION, false);
- showInsetCursor(bv);
+
+ hideInsetCursor(bv);
+// int const old_cell = actcell;
+
+ setPos(bv, x, y);
+ if (!hasSelection()) {
+ setSelection(actcell, actcell);
+ } else {
+ setSelection(sel_cell_start, actcell);
}
- no_selection = false;
+ updateLocal(bv, SELECTION, false);
+ showInsetCursor(bv);
}
// 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;
- no_selection = false;
UpdatableInset::RESULT result =
UpdatableInset::localDispatch(bv, action, arg);
if (result == DISPATCHED || result == DISPATCHED_NOUPDATE) {
moveNextCell(bv, old_locking_inset != 0);
else
movePrevCell(bv, old_locking_inset != 0);
- sel_cell_start = sel_cell_end = actcell;
+ clearSelection();
if (hs)
updateLocal(bv, SELECTION, false);
if (!the_locking_inset) {
}
hideInsetCursor(bv);
- result=DISPATCHED;
+ result = DISPATCHED;
switch (action) {
// --- Cursor Movements ----------------------------------
- case LFUN_RIGHTSEL:
- if (tabular->IsLastCellInRow(actcell))
+ case LFUN_RIGHTSEL: {
+ int const start = hasSelection() ? sel_cell_start : actcell;
+ if (tabular->IsLastCellInRow(actcell)) {
+ setSelection(start, actcell);
break;
- moveRight(bv, false);
- sel_cell_end = actcell;
+ }
+
+ int end = actcell;
+ // if we are starting a selection, only select
+ // the current cell at the beginning
+ if (hasSelection()) {
+ moveRight(bv, false);
+ end = actcell;
+ }
+ setSelection(start, end);
updateLocal(bv, SELECTION, false);
break;
+ }
case LFUN_RIGHT:
result = moveRight(bv);
- sel_cell_start = sel_cell_end = actcell;
+ clearSelection();
if (hs)
updateLocal(bv, SELECTION, false);
break;
- case LFUN_LEFTSEL:
- if (tabular->IsFirstCellInRow(actcell))
+ case LFUN_LEFTSEL: {
+ int const start = hasSelection() ? sel_cell_start : actcell;
+ if (tabular->IsFirstCellInRow(actcell)) {
+ setSelection(start, actcell);
break;
- moveLeft(bv, false);
- sel_cell_end = actcell;
+ }
+
+ int end = actcell;
+ // if we are starting a selection, only select
+ // the current cell at the beginning
+ if (hasSelection()) {
+ moveLeft(bv, false);
+ end = actcell;
+ }
+ setSelection(start, end);
updateLocal(bv, SELECTION, false);
break;
+ }
case LFUN_LEFT:
result = moveLeft(bv);
- sel_cell_start = sel_cell_end = actcell;
+ clearSelection();
if (hs)
updateLocal(bv, SELECTION, false);
break;
- case LFUN_DOWNSEL:
- {
+ case LFUN_DOWNSEL: {
+ int const start = hasSelection() ? sel_cell_start : actcell;
int const ocell = actcell;
- moveDown(bv, false);
+ // if we are starting a selection, only select
+ // the current cell at the beginning
+ if (hasSelection()) {
+ moveDown(bv, false);
+ }
if ((ocell == sel_cell_end) ||
(tabular->column_of_cell(ocell)>tabular->column_of_cell(actcell)))
- sel_cell_end = tabular->GetCellBelow(sel_cell_end);
+ setSelection(start, tabular->GetCellBelow(sel_cell_end));
else
- sel_cell_end = tabular->GetLastCellBelow(sel_cell_end);
+ setSelection(start, tabular->GetLastCellBelow(sel_cell_end));
updateLocal(bv, SELECTION, false);
}
break;
case LFUN_DOWN:
result = moveDown(bv, old_locking_inset != 0);
- sel_cell_start = sel_cell_end = actcell;
- if (hs)
+ clearSelection();
+ if (hs) {
updateLocal(bv, SELECTION, false);
+ }
break;
- case LFUN_UPSEL:
- {
+ case LFUN_UPSEL: {
+ int const start = hasSelection() ? sel_cell_start : actcell;
int const ocell = actcell;
- moveUp(bv, false);
+ // if we are starting a selection, only select
+ // the current cell at the beginning
+ if (hasSelection()) {
+ moveUp(bv, false);
+ }
if ((ocell == sel_cell_end) ||
(tabular->column_of_cell(ocell)>tabular->column_of_cell(actcell)))
- sel_cell_end = tabular->GetCellAbove(sel_cell_end);
+ setSelection(start, tabular->GetCellAbove(sel_cell_end));
else
- sel_cell_end = tabular->GetLastCellAbove(sel_cell_end);
+ setSelection(start, tabular->GetLastCellAbove(sel_cell_end));
updateLocal(bv, SELECTION, false);
}
break;
case LFUN_UP:
result = moveUp(bv, old_locking_inset != 0);
- sel_cell_start = sel_cell_end = actcell;
+ clearSelection();
if (hs)
updateLocal(bv, SELECTION, false);
break;
case LFUN_ENDSEL:
break;
case LFUN_LAYOUT_TABULAR:
- {
bv->owner()->getDialogs()->showTabular(this);
- }
- break;
+ break;
case LFUN_TABULAR_FEATURE:
if (!tabularFeatures(bv, arg))
result = UNDISPATCHED;
int InsetTabular::latex(Buffer const * buf, ostream & os,
- bool fragile, bool fp) const
+ bool fragile, bool fp) const
{
- return tabular->Latex(buf, os, fragile, fp);
+ return tabular->latex(buf, os, fragile, fp);
}
-int InsetTabular::ascii(Buffer const * buf, ostream & os, int) const
+int InsetTabular::ascii(Buffer const * buf, ostream & os, int ll) const
{
- // This should be changed to a real ascii export
- return tabular->Ascii(buf, os);
+ if (ll > 0)
+ return tabular->ascii(buf, os, (int)parOwner()->params().depth(),
+ false,0);
+ return tabular->ascii(buf, os, 0, false,0);
}
int InsetTabular::linuxdoc(Buffer const * buf, ostream & os) const
{
- return tabular->Ascii(buf,os);
+ return tabular->ascii(buf,os, (int)parOwner()->params().depth(), false, 0);
}
os << "<informaltable>\n";
ret++;
}
- ret+= tabular->DocBook(buf,os);
+ ret+= tabular->docBook(buf,os);
if (!master) {
os << "</informaltable>\n";
ret++;
bool selectall)
{
if (selectall) {
- sel_cell_start = 0;
- sel_cell_end = tabular->GetNumberOfCells() - 1;
+ setSelection(0, tabular->GetNumberOfCells() - 1);
}
if (hasSelection()) {
setUndo(bv, Undo::EDIT,
return true;
}
+static void checkLongtableSpecial(LyXTabular::ltType & ltt,
+ string const & special, bool & flag)
+{
+ if (special == "dl_above") {
+ ltt.topDL = flag;
+ ltt.set = false;
+ } else if (special == "dl_below") {
+ ltt.bottomDL = flag;
+ ltt.set = false;
+ } else if (special == "empty") {
+ ltt.empty = flag;
+ ltt.set = false;
+ } else if (flag) {
+ ltt.empty = false;
+ ltt.set = true;
+ }
+}
+
void InsetTabular::tabularFeatures(BufferView * bv,
LyXTabular::Feature feature,
bv->text->cursor.par(),
bv->text->cursor.par()->next());
- LyXTabular::ltType ltt;
- int row = ltt.row = tabular->row_of_cell(actcell);
+ int row = tabular->row_of_cell(actcell);
int column = tabular->column_of_cell(actcell);
bool flag = true;
-
+ LyXTabular::ltType ltt;
+
switch (feature) {
case LyXTabular::SET_PWIDTH:
{
- LyXLength const vallen = LyXLength(value);
- bool const update = (tabular->GetColumnPWidth(actcell) != vallen);
- tabular->SetColumnPWidth(actcell,vallen);
+ LyXLength const vallen(value);
+ LyXLength const & tmplen = tabular->GetColumnPWidth(actcell);
+
+ bool const update = (tmplen != vallen);
+ tabular->SetColumnPWidth(actcell, vallen);
if (update) {
+ int cell;
for (int i = 0; i < tabular->rows(); ++i) {
- tabular->GetCellInset(tabular->GetCellNumber(i, column))->
- resizeLyXText(bv);
+ cell = tabular->GetCellNumber(i,column);
+ tabular->GetCellInset(cell)->resizeLyXText(bv);
}
updateLocal(bv, INIT, true);
}
break;
case LyXTabular::SET_MPWIDTH:
{
- LyXLength const vallen = LyXLength(value);
- bool const update = (tabular->GetPWidth(actcell) != vallen);
- tabular->SetMColumnPWidth(actcell,vallen);
+ LyXLength const vallen(value);
+ LyXLength const & tmplen = tabular->GetPWidth(actcell);
+
+ bool const update = (tmplen != vallen);
+ tabular->SetMColumnPWidth(actcell, vallen);
if (update) {
for (int i = 0; i < tabular->rows(); ++i) {
tabular->GetCellInset(tabular->GetCellNumber(i, column))->
}
tabular->SetMultiColumn(s_start, s_end - s_start + 1);
actcell = s_start;
- sel_cell_end = sel_cell_start;
+ clearSelection();
updateLocal(bv, INIT, true);
break;
}
break;
}
case LyXTabular::UNSET_LTFIRSTHEAD:
- ltt.row = 0;
+ flag = false;
case LyXTabular::SET_LTFIRSTHEAD:
- tabular->SetLTHead(ltt, true);
+ (void)tabular->GetRowOfLTFirstHead(row, ltt);
+ checkLongtableSpecial(ltt, value, flag);
+ tabular->SetLTHead(row, flag, ltt, true);
break;
case LyXTabular::UNSET_LTHEAD:
- ltt.row = 0;
+ flag = false;
case LyXTabular::SET_LTHEAD:
- tabular->SetLTHead(ltt, false);
+ (void)tabular->GetRowOfLTHead(row, ltt);
+ checkLongtableSpecial(ltt, value, flag);
+ tabular->SetLTHead(row, flag, ltt, false);
break;
case LyXTabular::UNSET_LTFOOT:
- ltt.row = 0;
+ flag = false;
case LyXTabular::SET_LTFOOT:
- tabular->SetLTFoot(ltt, false);
+ (void)tabular->GetRowOfLTFoot(row, ltt);
+ checkLongtableSpecial(ltt, value, flag);
+ tabular->SetLTFoot(row, flag, ltt, false);
break;
case LyXTabular::UNSET_LTLASTFOOT:
- ltt.row = 0;
+ flag = false;
case LyXTabular::SET_LTLASTFOOT:
- tabular->SetLTFoot(ltt, true);
+ (void)tabular->GetRowOfLTLastFoot(row, ltt);
+ checkLongtableSpecial(ltt, value, flag);
+ tabular->SetLTFoot(row, flag, ltt, true);
break;
case LyXTabular::SET_LTNEWPAGE:
{
- bool what = !tabular->GetLTNewPage(actcell);
- tabular->SetLTNewPage(actcell, what);
+ bool what = !tabular->GetLTNewPage(row);
+ tabular->SetLTNewPage(row, what);
break;
}
// dummy stuff just to avoid warnings
status |= func_status::ToggleOff;
break;
case LyXTabular::SET_LTFIRSTHEAD:
- if (tabular->GetRowOfLTHead(actcell, dummyltt))
+ if (tabular->GetRowOfLTHead(sel_row_start, dummyltt))
status |= func_status::ToggleOn;
else
status |= func_status::ToggleOff;
break;
case LyXTabular::SET_LTHEAD:
- if (tabular->GetRowOfLTHead(actcell, dummyltt))
+ if (tabular->GetRowOfLTHead(sel_row_start, dummyltt))
status |= func_status::ToggleOn;
else
status |= func_status::ToggleOff;
break;
case LyXTabular::SET_LTFOOT:
- if (tabular->GetRowOfLTFoot(actcell, dummyltt))
+ if (tabular->GetRowOfLTFoot(sel_row_start, dummyltt))
status |= func_status::ToggleOn;
else
status |= func_status::ToggleOff;
break;
case LyXTabular::SET_LTLASTFOOT:
- if (tabular->GetRowOfLTFoot(actcell, dummyltt))
+ if (tabular->GetRowOfLTFoot(sel_row_start, dummyltt))
status |= func_status::ToggleOn;
else
status |= func_status::ToggleOff;
break;
case LyXTabular::SET_LTNEWPAGE:
- if (tabular->GetLTNewPage(actcell))
+ if (tabular->GetLTNewPage(sel_row_start))
status |= func_status::ToggleOn;
else
status |= func_status::ToggleOff;
while (paste_tabular->rows() > rows)
paste_tabular->DeleteRow(rows);
paste_tabular->SetTopLine(0, true, true);
- paste_tabular->SetBottomLine(paste_tabular->GetFirstCellInRow(rows-1),
+ paste_tabular->SetBottomLine(paste_tabular->GetFirstCellInRow(rows - 1),
true, true);
for (int i = 0; i < sel_col_start; ++i)
paste_tabular->DeleteColumn(0);
true, true);
ostringstream sstr;
- paste_tabular->Ascii(bv->buffer(), sstr);
+ paste_tabular->ascii(bv->buffer(), sstr,
+ (int)parOwner()->params().depth(), true, '\t');
bv->stuffClipboard(sstr.str().c_str());
return true;
}
}
-void InsetTabular::getSelection(int & srow, int & erow, int & scol, int & ecol) const
+void InsetTabular::getSelection(int & srow, int & erow,
+ int & scol, int & ecol) const
{
- srow = tabular->row_of_cell(sel_cell_start);
- erow = tabular->row_of_cell(sel_cell_end);
- if (srow > erow)
- swap(srow, erow);
+ int const start = hasSelection() ? sel_cell_start : actcell;
+ int const end = hasSelection() ? sel_cell_end : actcell;
+
+ srow = tabular->row_of_cell(start);
+ erow = tabular->row_of_cell(end);
+ if (srow > erow) {
+ swap(srow, erow);
+ }
- scol = tabular->column_of_cell(sel_cell_start);
- ecol = tabular->column_of_cell(sel_cell_end);
- if (scol > ecol)
- swap(scol, ecol);
- else
- ecol = tabular->right_column_of_cell(sel_cell_end);
+ scol = tabular->column_of_cell(start);
+ ecol = tabular->column_of_cell(end);
+ if (scol > ecol) {
+ swap(scol, ecol);
+ } else {
+ ecol = tabular->right_column_of_cell(end);
+ }
}
return const_cast<InsetTabular *>(this);
Inset * result;
- for(int i=0; i < tabular->rows(); ++i) {
- for(int j=0; j < tabular->columns(); ++j) {
+ 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;
}
}
-string const InsetTabular::selectNextWordToSpellcheck(BufferView * bv, float & value) const
+string const
+InsetTabular::selectNextWordToSpellcheck(BufferView * bv, float & value) const
{
if (the_locking_inset) {
string const str(the_locking_inset->selectNextWordToSpellcheck(bv, value));