#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[] =
{
{
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;
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;
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);
if (actrow != orow)
updateLocal(bv, NONE, false);
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;
}
+ return ret;
}
}
hideInsetCursor(bv);
- result=DISPATCHED;
+ result = DISPATCHED;
switch (action) {
// --- Cursor Movements ----------------------------------
case LFUN_RIGHTSEL: {
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++;
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))->
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
{
int const start = hasSelection() ? sel_cell_start : actcell;
int const end = hasSelection() ? sel_cell_end : actcell;
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));
projects / lyx.git / blobdiff