#include "Painter.h"
#include "font.h"
#include "lyxtext.h"
-#include "lyx_gui_misc.h"
#include "LyXView.h"
#include "insets/insettext.h"
#include "debug.h"
#include <map>
//#include <signal.h>
+
+using std::vector;
using std::ostream;
using std::ifstream;
using std::max;
// for now make it always display as display() inset
// just for test!!!
the_locking_inset = 0;
+ old_locking_inset = 0;
locked = false;
oldcell = -1;
actrow = actcell = 0;
need_update = INIT;
in_update = false;
in_reset_pos = false;
+ inset_x = 0;
+ inset_y = 0;
}
{
tabular.reset(new LyXTabular(this, *(tab.tabular), same_id));
the_locking_inset = 0;
+ old_locking_inset = 0;
locked = false;
oldcell = -1;
actrow = actcell = 0;
need_update = INIT;
in_update = false;
in_reset_pos = false;
+ inset_x = 0;
+ inset_y = 0;
}
float dx = nx + tabular->GetBeginningOfTextInCell(cell);
float cx = dx;
tabular->GetCellInset(cell)->draw(bv, font, baseline, dx, false);
+ //
+ // Here we use rectangular backgroundColor patches to clean up
+ // within a cell around the cell's red inset box. As follows:
+ //
+ // +--------------------+
+ // | C | The rectangles are A, B and C
+ // | A |------------| B | below, origin top left (tx, ty),
+ // | | inset box | | dimensions w(idth), h(eight).
+ // +---+------------+---+ x grows rightward, y downward
+ // | D |
+ // +--------------------+
+ //
+#if 0
// clear only if we didn't have a change
if (bv->text->status() != LyXText::CHANGED_IN_DRAW) {
+#endif
// clear before the inset
- pain.fillRectangle(
- nx + 1,
- baseline - tabular->GetAscentOfRow(i) + 1,
- int(cx - nx - 1),
- tabular->GetAscentOfRow(i) +
- tabular->GetDescentOfRow(i) - 1,
- backgroundColor());
+ int tx, ty, w, h;
+ tx = nx + 1;
+ ty = baseline - tabular->GetAscentOfRow(i) + 1;
+ w = int(cx - nx - 1);
+ h = tabular->GetAscentOfRow(i) +
+ tabular->GetDescentOfRow(i) - 1;
+ pain.fillRectangle(tx, ty, w, h, backgroundColor());
// clear behind the inset
- pain.fillRectangle(
- int(cx + the_locking_inset->width(bv,font) + 1),
- baseline - tabular->GetAscentOfRow(i) + 1,
- tabular->GetWidthOfColumn(cell) -
+ tx = int(cx + the_locking_inset->width(bv,font) + 1);
+ ty = baseline - tabular->GetAscentOfRow(i) + 1;
+ w = tabular->GetWidthOfColumn(cell) -
tabular->GetBeginningOfTextInCell(cell) -
the_locking_inset->width(bv,font) -
- tabular->GetAdditionalWidth(cell) - 1,
- tabular->GetAscentOfRow(i) +
- tabular->GetDescentOfRow(i) - 1,
- backgroundColor());
+ tabular->GetAdditionalWidth(cell) - 1;
+ h = tabular->GetAscentOfRow(i) + tabular->GetDescentOfRow(i) - 1;
+ pain.fillRectangle(tx, ty, w, h, backgroundColor());
// clear below the inset
- pain.fillRectangle(
- nx + 1,
- baseline + the_locking_inset->descent(bv, font) + 1,
- tabular->GetWidthOfColumn(cell) -
- tabular->GetAdditionalWidth(cell) - 1,
- tabular->GetAscentOfRow(i) +
- tabular->GetDescentOfRow(i) -
- the_locking_inset->ascent(bv, font) -
- the_locking_inset->descent(bv, font) -
- TEXT_TO_INSET_OFFSET - 1,
- backgroundColor());
+ tx = nx + 1;
+ ty = baseline + the_locking_inset->descent(bv, font) + 1;
+ w = tabular->GetWidthOfColumn(cell) -
+ tabular->GetAdditionalWidth(cell) - 1;
+ h = tabular->GetDescentOfRow(i) -
+ the_locking_inset->descent(bv, font) - 1;
+ pain.fillRectangle(tx, ty, w, h, backgroundColor());
+ // clear above the inset
+ tx = nx + 1;
+ ty = baseline - tabular->GetAscentOfRow(i) + 1;
+ w = tabular->GetWidthOfColumn(cell) -
+ tabular->GetAdditionalWidth(cell) - 1;
+ h = tabular->GetAscentOfRow(i) - the_locking_inset->ascent(bv, font);
+ pain.fillRectangle(tx, ty, w, h, backgroundColor());
+#if 0
}
+#endif
}
x -= ADD_TO_TABULAR_WIDTH;
x += width(bv, font);
need_update = INIT;
break;
case SELECTION:
- need_update = INIT;
+ need_update = FULL;
break;
default:
break;
void InsetTabular::updateLocal(BufferView * bv, UpdateCodes what,
- bool mark_dirty) const
+ bool mark_dirty) const
{
if (what == INIT) {
LyXFont font;
}
if (need_update < what) // only set this if it has greater update
need_update = what;
+#if 0 // maybe this should not be done!
if ((what == INIT) && hasSelection()) {
clearSelection();
}
+#endif
// Dirty Cast! (Lgb)
if (need_update != NONE) {
bv->updateInset(const_cast<InsetTabular *>(this), mark_dirty);
}
if (in->getInsetFromID(id)) {
actcell = i;
- the_locking_inset = in;
- locked = true;
- resetPos(bv);
+ in->edit(bv);
return the_locking_inset->lockInsetInInset(bv, inset);
}
}
{
bool ret = false;
if (the_locking_inset)
- ret = the_locking_inset->insetButtonRelease(bv, x, y, button);
+ ret = the_locking_inset->insetButtonRelease(bv, x - inset_x,
+ y - inset_y, button);
if (button == 3 && !ret) {
bv->owner()->getDialogs()->showTabular(this);
return true;
updateLocal(bv, SELECTION, false);
break;
case LFUN_NEXT: {
+ UpdateCodes code = CURSOR;
+ if (hs) {
+ clearSelection();
+ code = SELECTION;
+ }
int column = actcol;
unlockInsetInInset(bv, the_locking_inset);
if (bv->text->first + bv->painter().paperHeight() <
(top_baseline + tabular->GetHeightOfTabular()))
{
bv->scrollCB(bv->text->first + bv->painter().paperHeight());
- updateLocal(bv, FULL, false);
+ code = FULL;
actcell = tabular->GetCellBelow(first_visible_cell) + column;
} else {
actcell = tabular->GetFirstCellInRow(tabular->rows() - 1) + column;
}
resetPos(bv);
- updateLocal(bv, CURSOR, false);
+ updateLocal(bv, code, false);
break;
}
case LFUN_PRIOR: {
+ UpdateCodes code = CURSOR;
+ if (hs) {
+ clearSelection();
+ code = SELECTION;
+ }
int column = actcol;
unlockInsetInInset(bv, the_locking_inset);
if (top_baseline < 0) {
bv->scrollCB(bv->text->first - bv->painter().paperHeight());
- updateLocal(bv, FULL, false);
+ code = FULL;
if (top_baseline > 0)
actcell = column;
else
actcell = column;
}
resetPos(bv);
- updateLocal(bv, CURSOR, false);
+ updateLocal(bv, code, false);
break;
}
// none of these make sense for insettabular,
case LFUN_HOMESEL:
case LFUN_END:
case LFUN_ENDSEL:
+ case LFUN_BEGINNINGBUF:
+ case LFUN_BEGINNINGBUFSEL:
+ case LFUN_ENDBUF:
+ case LFUN_ENDBUFSEL:
break;
case LFUN_LAYOUT_TABULAR:
bv->owner()->getDialogs()->showTabular(this);
while (p < len &&
((p = clip.find_first_of("\t\n", p)) != string::npos)) {
- switch(clip[p]) {
+ switch (clip[p]) {
case '\t':
++cols;
break;
(p = clip.find_first_of("\t\n", p)) != string::npos) {
if (p >= len)
break;
- switch(clip[p]) {
+ switch (clip[p]) {
case '\t':
paste_tabular->GetCellInset(cell)->setText(clip.substr(op, p-op));
++cols;
}
// ATTENTION: the function above has to be PASTE and PASTESELECTION!!!
default:
+ // handle font changing stuff on selection before we lock the inset
+ // in the default part!
+ result = UNDISPATCHED;
+ if (hs) {
+ switch(action) {
+ case LFUN_LANGUAGE:
+ case LFUN_EMPH:
+ case LFUN_BOLD:
+ case LFUN_NOUN:
+ case LFUN_CODE:
+ case LFUN_SANS:
+ case LFUN_ROMAN:
+ case LFUN_DEFAULT:
+ case LFUN_UNDERLINE:
+ case LFUN_FONT_SIZE:
+ if (bv->Dispatch(action, arg))
+ result = DISPATCHED;
+ break;
+ default:
+ break;
+ }
+ }
// we try to activate the actual inset and put this event down to
// the insets dispatch function.
- result = UNDISPATCHED;
- if (the_locking_inset)
+ if ((result == DISPATCHED) || the_locking_inset)
break;
nodraw(true);
if (activateCellInset(bv)) {
return UNDISPATCHED;
} else if (hs) {
clearSelection();
+ // so the below CELL is not set because this is higher
+ // priority and we get a full redraw
+ need_update = SELECTION;
}
nodraw(false);
updateLocal(bv, CELL, false);
int InsetTabular::linuxdoc(Buffer const * buf, ostream & os) const
{
- return tabular->ascii(buf,os, (int)parOwner()->params().depth(), false, 0);
+ os << "<![CDATA[";
+ int const ret = tabular->ascii(buf,os,
+ (int)parOwner()->params().depth(),
+ false, 0);
+ os << "]]>";
+ return ret;
}
if (len.zero())
return -1;
-#ifdef WITH_WARNINGS
-#warning Remove use of VSpace as soon as LyXLength::inPixels exists (JMarc)
-#endif
- return VSpace(len).inPixels(bv);
+ return len.inPixels(latexTextWidth(bv), bv->text->defaultHeight());
}
int InsetTabular::getMaxWidth(BufferView * bv,
UpdatableInset const * inset) const
{
- int cell = tabular->cur_cell;
- if (tabular->GetCellInset(cell) != inset) {
- cell = actcell;
- if (tabular->GetCellInset(cell) != inset) {
-
- lyxerr[Debug::INSETTEXT] << "Actcell not equal to actual cell!\n";
- cell = -1;
- }
- }
-
- int const n = tabular->GetNumberOfCells();
+ int cell = tabular->GetCellFromInset(inset, actcell);
if (cell == -1) {
- for (cell = 0; cell < n; ++cell) {
- if (tabular->GetCellInset(cell) == inset)
- break;
- }
- }
-
- if (cell >= n) {
- lyxerr << "Own inset not found, shouldn't really happen!\n";
+ lyxerr << "Own inset not found, shouldn't really happen!"
+ << endl;
return -1;
}
//
-// functions returns:
-// 0 ... disabled
-// 1 ... enabled
-// 2 ... toggled on
-// 3 ... toggled off
+// function returns an object as defined in func_status.h:
+// states OK, Unknown, Disabled, On, Off.
//
-func_status::value_type InsetTabular::getStatus(string const & what) const
+FuncStatus InsetTabular::getStatus(string const & what) const
{
int action = LyXTabular::LAST_ACTION;
- func_status::value_type status = func_status::OK;
+ FuncStatus status;
int i = 0;
for (; tabularFeature[i].action != LyXTabular::LAST_ACTION; ++i) {
break;
}
}
- if (action == LyXTabular::LAST_ACTION)
- return func_status::Unknown;
-
+ if (action == LyXTabular::LAST_ACTION) {
+ status.clear();
+ return status.unknown(true);
+ }
+
string const argument = frontStrip(what.substr(tabularFeature[i].feature.length()));
int sel_row_start;
case LyXTabular::SET_MPWIDTH:
case LyXTabular::SET_SPECIAL_COLUMN:
case LyXTabular::SET_SPECIAL_MULTI:
- status |= func_status::Disabled;
- return status;
+ return status.disabled(true);
case LyXTabular::APPEND_ROW:
case LyXTabular::APPEND_COLUMN:
case LyXTabular::DELETE_COLUMN:
case LyXTabular::SET_ALL_LINES:
case LyXTabular::UNSET_ALL_LINES:
- status |= func_status::OK;
- return status;
+ return status.clear();
case LyXTabular::MULTICOLUMN:
- if (tabular->IsMultiColumn(actcell))
- status |= func_status::ToggleOn;
- else
- status |= func_status::ToggleOff;
+ status.setOnOff(tabular->IsMultiColumn(actcell));
break;
case LyXTabular::M_TOGGLE_LINE_TOP:
flag = false;
case LyXTabular::TOGGLE_LINE_TOP:
- if (tabular->TopLine(actcell, flag))
- status |= func_status::ToggleOn;
- else
- status |= func_status::ToggleOff;
+ status.setOnOff(tabular->TopLine(actcell, flag));
break;
case LyXTabular::M_TOGGLE_LINE_BOTTOM:
flag = false;
case LyXTabular::TOGGLE_LINE_BOTTOM:
- if (tabular->BottomLine(actcell, flag))
- status |= func_status::ToggleOn;
- else
- status |= func_status::ToggleOff;
+ status.setOnOff(tabular->BottomLine(actcell, flag));
break;
case LyXTabular::M_TOGGLE_LINE_LEFT:
flag = false;
case LyXTabular::TOGGLE_LINE_LEFT:
- if (tabular->LeftLine(actcell, flag))
- status |= func_status::ToggleOn;
- else
- status |= func_status::ToggleOff;
+ status.setOnOff(tabular->LeftLine(actcell, flag));
break;
case LyXTabular::M_TOGGLE_LINE_RIGHT:
flag = false;
case LyXTabular::TOGGLE_LINE_RIGHT:
- if (tabular->RightLine(actcell, flag))
- status |= func_status::ToggleOn;
- else
- status |= func_status::ToggleOff;
+ status.setOnOff(tabular->RightLine(actcell, flag));
break;
case LyXTabular::M_ALIGN_LEFT:
flag = false;
case LyXTabular::ALIGN_LEFT:
- if (tabular->GetAlignment(actcell, flag) == LYX_ALIGN_LEFT)
- status |= func_status::ToggleOn;
- else
- status |= func_status::ToggleOff;
+ status.setOnOff(tabular->GetAlignment(actcell, flag) == LYX_ALIGN_LEFT);
break;
case LyXTabular::M_ALIGN_RIGHT:
flag = false;
case LyXTabular::ALIGN_RIGHT:
- if (tabular->GetAlignment(actcell, flag) == LYX_ALIGN_RIGHT)
- status |= func_status::ToggleOn;
- else
- status |= func_status::ToggleOff;
+ status.setOnOff(tabular->GetAlignment(actcell, flag) == LYX_ALIGN_RIGHT);
break;
case LyXTabular::M_ALIGN_CENTER:
flag = false;
case LyXTabular::ALIGN_CENTER:
- if (tabular->GetAlignment(actcell, flag) == LYX_ALIGN_CENTER)
- status |= func_status::ToggleOn;
- else
- status |= func_status::ToggleOff;
+ status.setOnOff(tabular->GetAlignment(actcell, flag) == LYX_ALIGN_CENTER);
break;
case LyXTabular::M_VALIGN_TOP:
flag = false;
case LyXTabular::VALIGN_TOP:
- if (tabular->GetVAlignment(actcell, flag) == LyXTabular::LYX_VALIGN_TOP)
- status |= func_status::ToggleOn;
- else
- status |= func_status::ToggleOff;
+ status.setOnOff(tabular->GetVAlignment(actcell, flag) == LyXTabular::LYX_VALIGN_TOP);
break;
case LyXTabular::M_VALIGN_BOTTOM:
flag = false;
case LyXTabular::VALIGN_BOTTOM:
- if (tabular->GetVAlignment(actcell, flag) == LyXTabular::LYX_VALIGN_BOTTOM)
- status |= func_status::ToggleOn;
- else
- status |= func_status::ToggleOff;
+ status.setOnOff(tabular->GetVAlignment(actcell, flag) == LyXTabular::LYX_VALIGN_BOTTOM);
break;
case LyXTabular::M_VALIGN_CENTER:
flag = false;
case LyXTabular::VALIGN_CENTER:
- if (tabular->GetVAlignment(actcell, flag) == LyXTabular::LYX_VALIGN_CENTER)
- status |= func_status::ToggleOn;
- else
- status |= func_status::ToggleOff;
+ status.setOnOff(tabular->GetVAlignment(actcell, flag) == LyXTabular::LYX_VALIGN_CENTER);
break;
case LyXTabular::SET_LONGTABULAR:
- if (tabular->IsLongTabular())
- status |= func_status::ToggleOn;
- else
- status |= func_status::ToggleOff;
+ status.setOnOff(tabular->IsLongTabular());
break;
case LyXTabular::UNSET_LONGTABULAR:
- if (!tabular->IsLongTabular())
- status |= func_status::ToggleOn;
- else
- status |= func_status::ToggleOff;
+ status.setOnOff(!tabular->IsLongTabular());
break;
case LyXTabular::SET_ROTATE_TABULAR:
- if (tabular->GetRotateTabular())
- status |= func_status::ToggleOn;
- else
- status |= func_status::ToggleOff;
+ status.setOnOff(tabular->GetRotateTabular());
break;
case LyXTabular::UNSET_ROTATE_TABULAR:
- if (!tabular->GetRotateTabular())
- status |= func_status::ToggleOn;
- else
- status |= func_status::ToggleOff;
+ status.setOnOff(!tabular->GetRotateTabular());
break;
case LyXTabular::SET_ROTATE_CELL:
- if (tabular->GetRotateCell(actcell))
- status |= func_status::ToggleOn;
- else
- status |= func_status::ToggleOff;
+ status.setOnOff(tabular->GetRotateCell(actcell));
break;
case LyXTabular::UNSET_ROTATE_CELL:
- if (!tabular->GetRotateCell(actcell))
- status |= func_status::ToggleOn;
- else
- status |= func_status::ToggleOff;
+ status.setOnOff(!tabular->GetRotateCell(actcell));
break;
case LyXTabular::SET_USEBOX:
- if (strToInt(argument) == tabular->GetUsebox(actcell))
- status |= func_status::ToggleOn;
- else
- status |= func_status::ToggleOff;
+ status.setOnOff(strToInt(argument) == tabular->GetUsebox(actcell));
break;
case LyXTabular::SET_LTFIRSTHEAD:
- if (tabular->GetRowOfLTHead(sel_row_start, dummyltt))
- status |= func_status::ToggleOn;
- else
- status |= func_status::ToggleOff;
+ status.setOnOff(tabular->GetRowOfLTHead(sel_row_start, dummyltt));
break;
case LyXTabular::SET_LTHEAD:
- if (tabular->GetRowOfLTHead(sel_row_start, dummyltt))
- status |= func_status::ToggleOn;
- else
- status |= func_status::ToggleOff;
+ status.setOnOff(tabular->GetRowOfLTHead(sel_row_start, dummyltt));
break;
case LyXTabular::SET_LTFOOT:
- if (tabular->GetRowOfLTFoot(sel_row_start, dummyltt))
- status |= func_status::ToggleOn;
- else
- status |= func_status::ToggleOff;
+ status.setOnOff(tabular->GetRowOfLTFoot(sel_row_start, dummyltt));
break;
case LyXTabular::SET_LTLASTFOOT:
- if (tabular->GetRowOfLTFoot(sel_row_start, dummyltt))
- status |= func_status::ToggleOn;
- else
- status |= func_status::ToggleOff;
+ status.setOnOff(tabular->GetRowOfLTFoot(sel_row_start, dummyltt));
break;
case LyXTabular::SET_LTNEWPAGE:
- if (tabular->GetLTNewPage(sel_row_start))
- status |= func_status::ToggleOn;
- else
- status |= func_status::ToggleOff;
+ status.setOnOff(tabular->GetLTNewPage(sel_row_start));
break;
default:
- status = func_status::Disabled;
+ status.clear();
+ status.disabled(true);
break;
}
return status;
}
-std::vector<string> const InsetTabular::getLabelList() const
+vector<string> const InsetTabular::getLabelList() const
{
return tabular->getLabelList();
}
}
-bool InsetTabular::isRightToLeft(BufferView *bv )
+bool InsetTabular::isRightToLeft(BufferView * bv)
{
return bv->getParentLanguage(this)->RightToLeft();
}
bool InsetTabular::searchForward(BufferView * bv, string const & str,
- bool const & cs, bool const & mw)
+ bool cs, bool mw)
{
nodraw(true);
if (the_locking_inset) {
bool InsetTabular::searchBackward(BufferView * bv, string const & str,
- bool const & cs, bool const & mw)
+ bool cs, bool mw)
{
nodraw(true);
if (the_locking_inset) {
return the_locking_inset->insetAllowed(code);
return false;
}
+
+
+bool InsetTabular::forceDefaultParagraphs(Inset const * in) const
+{
+ const int cell = tabular->GetCellFromInset(in, actcell);
+
+ 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);
+ // if we're here there is really something strange going on!!!
+ return false;
+}
projects / lyx.git / blobdiff