#include "Buffer.h"
#include "BufferParams.h"
#include "BufferView.h"
+#include "CoordCache.h"
#include "Cursor.h"
#include "CutAndPaste.h"
#include "FuncRequest.h"
int InsetMathGrid::RowInfo::skipPixels(MetricsInfo const & mi) const
{
- return crskip_.inPixels(mi.base);
+ return mi.base.inPixels(crskip_);
}
for (idx_type i = 0; i < nargs(); ++i) {
if (cellinfo_[i].multi_ != CELL_PART_OF_MULTICOLUMN) {
Dimension dimc;
- cell(i).metrics(mi, dimc);
+ // the 'false' is to make sure that the cell is tall enough
+ cell(i).metrics(mi, dimc, false);
}
}
rowinfo_[row].ascent_ = asc;
rowinfo_[row].descent_ = desc;
}
- rowinfo_[0].ascent_ += hlinesep() * rowinfo_[0].lines_;
rowinfo_[nrows()].ascent_ = 0;
rowinfo_[nrows()].descent_ = 0;
colinfo_[ncols()].width_ = 0;
// compute horizontal offsets
- colinfo_[0].offset_ = border();
+ colinfo_[0].offset_ = border() + colinfo_[0].lines_ * vlinesep();;
for (col_type col = 1; col <= ncols(); ++col) {
colinfo_[col].offset_ =
colinfo_[col - 1].offset_ +
dim.des = rowinfo_[nrows() - 1].offset_
+ rowinfo_[nrows() - 1].descent_
+ hlinesep() * rowinfo_[nrows()].lines_
- + border();
+ + border() + 1;
/*
cxrow->setBaseline(cxrow->getBaseline() - ascent);
}
*/
- metricsMarkers2(dim);
- // Cache the inset dimension.
- setDimCache(mi, dim);
+ dim.wid += leftMargin() + rightMargin();
}
-void InsetMathGrid::draw(PainterInfo & pi, int x, int y) const
+int InsetMathGrid::vLineHOffset(col_type col, unsigned int line) const
{
- drawWithMargin(pi, x, y, 1, 1);
+ if (col < ncols())
+ return leftMargin() + colinfo_[col].offset_
+ - (colinfo_[col].lines_ - line - 1) * vlinesep()
+ - vlinesep()/2 - colsep()/2;
+ else {
+ LASSERT(col == ncols(), return 0);
+ return leftMargin() + colinfo_[col-1].offset_ + colinfo_[col-1].width_
+ + line * vlinesep()
+ + vlinesep()/2 + colsep()/2;
+ }
}
-void InsetMathGrid::drawWithMargin(PainterInfo & pi, int x, int y,
- int lmargin, int rmargin) const
+int InsetMathGrid::hLineVOffset(row_type row, unsigned int line) const
+{
+ return rowinfo_[row].offset_
+ - rowinfo_[row].ascent_
+ - line * hlinesep()
+ - hlinesep()/2 - rowsep()/2;
+}
+
+
+void InsetMathGrid::draw(PainterInfo & pi, int x, int y) const
{
- Dimension const dim = dimension(*pi.base.bv);
BufferView const & bv = *pi.base.bv;
for (idx_type idx = 0; idx < nargs(); ++idx) {
if (cellinfo_[idx].multi_ != CELL_PART_OF_MULTICOLUMN) {
cell(idx).draw(pi,
- x + lmargin + cellXOffset(bv, idx),
- y + cellYOffset(idx));
-
- // draw inner lines cell by cell because of possible multicolumns
- // FIXME: multicolumn lines are not yet considered
- row_type const r = row(idx);
- col_type const c = col(idx);
- if (r > 0 && r < nrows()) {
- for (unsigned int i = 0; i < rowinfo_[r].lines_; ++i) {
- int const yy = y + rowinfo_[r].offset_
- - rowinfo_[r].ascent_
- - i * hlinesep()
- - hlinesep()/2 - rowsep()/2;
- pi.pain.line(
- x + lmargin + colinfo_[c].offset_,
- yy,
- x + lmargin + colinfo_[c+1].offset_,
- yy, Color_foreground);
- }
- }
- if (c > 0 && c < ncols()) {
+ x + leftMargin() + cellXOffset(bv, idx),
+ y + cellYOffset(idx));
+
+ row_type r = row(idx);
+ int const yy1 = y + hLineVOffset(r, 0);
+ int const yy2 = y + hLineVOffset(r + 1, rowinfo_[r + 1].lines_ - 1);
+ auto draw_left_borders = [&](col_type c) {
for (unsigned int i = 0; i < colinfo_[c].lines_; ++i) {
- int const xx = x + lmargin
- + colinfo_[c].offset_
- - i * vlinesep()
- - vlinesep()/2 - colsep()/2;
- int top_offset;
- if (r > 0)
- top_offset = rowinfo_[r - 1].offset_ + rowinfo_[r - 1].descent_;
- else
- top_offset = rowinfo_[0].offset_- rowinfo_[0].ascent_;
- pi.pain.line(xx, y + top_offset,
- xx, y + rowinfo_[r].offset_ + rowinfo_[r].descent_,
- Color_foreground);
+ int const xx = x + vLineHOffset(c, i);
+ pi.pain.line(xx, yy1, xx, yy2, Color_foreground);
}
- }
+ };
+ col_type c = col(idx);
+ // Draw inner left borders cell-by-cell because of multicolumns
+ draw_left_borders(c);
+ // Draw the right border (only once)
+ if (c == 0)
+ draw_left_borders(ncols());
}
}
- // draw outer lines in one go
- for (row_type row = 0; row <= nrows(); row += nrows())
- for (unsigned int i = 0; i < rowinfo_[row].lines_; ++i) {
- int yy = y + rowinfo_[row].offset_ - rowinfo_[row].ascent_
- - i * hlinesep() - hlinesep()/2 - rowsep()/2;
- pi.pain.line(x + lmargin + 1, yy,
- x + dim.width() - rmargin - 1, yy,
- Color_foreground);
- }
-
- for (col_type col = 0; col <= ncols(); col += ncols())
- for (unsigned int i = 0; i < colinfo_[col].lines_; ++i) {
- int xx = x + lmargin + colinfo_[col].offset_
- - i * vlinesep() - vlinesep()/2 - colsep()/2;
- pi.pain.line(xx, y - dim.ascent() + 1,
- xx, y + dim.descent() - 1,
- Color_foreground);
+ // Draw horizontal borders
+ for (row_type r = 0; r <= nrows(); ++r) {
+ int const xx1 = x + vLineHOffset(0, 0);
+ int const xx2 = x + vLineHOffset(ncols(), colinfo_[ncols()].lines_ - 1);
+ for (unsigned int i = 0; i < rowinfo_[r].lines_; ++i) {
+ int const yy = y + hLineVOffset(r, i);
+ pi.pain.line(xx1, yy, xx2, yy, Color_foreground);
}
- drawMarkers2(pi, x, y);
+ }
}
rowinfo_[row].ascent_ = asc;
rowinfo_[row].descent_ = desc;
}
- //rowinfo_[0].ascent_ += hlinesep() * rowinfo_[0].lines_;
rowinfo_[nrows()].ascent_ = 0;
rowinfo_[nrows()].descent_ = 0;
{
rowinfo_.insert(rowinfo_.begin() + row + 1, RowInfo());
cells_.insert
- (cells_.begin() + (row + 1) * ncols(), ncols(), MathData());
+ (cells_.begin() + (row + 1) * ncols(), ncols(), MathData(buffer_));
cellinfo_.insert
(cellinfo_.begin() + (row + 1) * ncols(), ncols(), CellInfo());
}
void InsetMathGrid::copyRow(row_type row)
{
addRow(row);
- for (col_type col = 0; col < ncols(); ++col)
+ for (col_type col = 0; col < ncols(); ++col) {
cells_[(row + 1) * ncols() + col] = cells_[row * ncols() + col];
+ // copying the cell does not set the buffer
+ cells_[(row + 1) * ncols() + col].setBuffer(*buffer_);
+ }
}
= cellinfo_[row * nc + col];
}
swap(cells_, new_cells);
+ // copying cells loses the buffer reference
+ setBuffer(*buffer_);
swap(cellinfo_, new_cellinfo);
ColInfo inf;
void InsetMathGrid::copyCol(col_type col)
{
addCol(col+1);
- for (row_type row = 0; row < nrows(); ++row)
+ for (row_type row = 0; row < nrows(); ++row) {
cells_[row * ncols() + col + 1] = cells_[row * ncols() + col];
+ // copying the cell does not set the buffer
+ cells_[row * ncols() + col + 1].setBuffer(*buffer_);
+ }
}
LASSERT(cur.idx() > 0, return false);
--cur.idx();
}
- cur.pos() = cur.cell().x2pos(&cur.bv(), cur.x_target() - cur.cell().xo(cur.bv()));
+ // FIXME: this is only a workaround to avoid a crash if the inset
+ // in not in coord cache. The best would be to force a FitCursor
+ // operation.
+ CoordCache::Arrays const & arraysCache = cur.bv().coordCache().arrays();
+ if (arraysCache.has(&cur.cell()))
+ cur.pos() = cur.cell().x2pos(&cur.bv(), cur.x_target() - cur.cell().xo(cur.bv()));
+ else
+ cur.pos() = 0;
return true;
}
}
-bool InsetMathGrid::idxFirst(Cursor & cur) const
+idx_type InsetMathGrid::firstIdx() const
{
+ size_type idx = 0;
switch (v_align_) {
case 't':
- cur.idx() = 0;
+ //idx = 0;
break;
case 'b':
- cur.idx() = (nrows() - 1) * ncols();
+ idx = (nrows() - 1) * ncols();
break;
default:
- cur.idx() = ((nrows() - 1) / 2) * ncols();
+ idx = ((nrows() - 1) / 2) * ncols();
}
// If we are in a multicolumn cell, move to the "real" cell
- while (cellinfo_[cur.idx()].multi_ == CELL_PART_OF_MULTICOLUMN) {
- LASSERT(cur.idx() > 0, return false);
- --cur.idx();
+ while (cellinfo_[idx].multi_ == CELL_PART_OF_MULTICOLUMN) {
+ LASSERT(idx > 0, return 0);
+ --idx;
}
- cur.pos() = 0;
- return true;
+ return idx;
}
-bool InsetMathGrid::idxLast(Cursor & cur) const
+idx_type InsetMathGrid::lastIdx() const
{
+ size_type idx = 0;
switch (v_align_) {
case 't':
- cur.idx() = ncols() - 1;
+ idx = ncols() - 1;
break;
case 'b':
- cur.idx() = nargs() - 1;
+ idx = nargs() - 1;
break;
default:
- cur.idx() = ((nrows() - 1) / 2 + 1) * ncols() - 1;
+ idx = ((nrows() - 1) / 2 + 1) * ncols() - 1;
}
// If we are in a multicolumn cell, move to the "real" cell
- while (cellinfo_[cur.idx()].multi_ == CELL_PART_OF_MULTICOLUMN) {
- LASSERT(cur.idx() > 0, return false);
- --cur.idx();
+ while (cellinfo_[idx].multi_ == CELL_PART_OF_MULTICOLUMN) {
+ LASSERT(idx > 0, return false);
+ --idx;
}
- cur.pos() = cur.lastpos();
- return true;
+ return idx;
}
for (col_type col = beg_col; col < end_col;) {
int nccols = 1;
idx_type const idx = index(row, col);
- RowEntry entry = TexRow::mathEntry(id(),idx);
+ TexRow::RowEntry entry = TexRow::mathEntry(id(),idx);
os.texrow().start(entry);
if (col >= lastcol) {
++col;
splitCell(cur);
break;
- case LFUN_CELL_BACKWARD:
- // See below.
- cur.selection(false);
- if (!idxPrev(cur)) {
- cmd = FuncRequest(LFUN_FINISHED_BACKWARD);
- cur.undispatched();
- }
- break;
-
- case LFUN_CELL_FORWARD:
- // Can't handle selection by additional 'shift' as this is
- // hard bound to LFUN_CELL_BACKWARD
- cur.selection(false);
- if (!idxNext(cur)) {
- cmd = FuncRequest(LFUN_FINISHED_FORWARD);
- cur.undispatched();
- }
- break;
-
case LFUN_NEWLINE_INSERT: {
cur.recordUndoInset();
row_type const r = cur.row();
parseflg |= Parse::VERBATIM;
// fall through
case LFUN_PASTE: {
- if (cur.currentMode() <= TEXT_MODE)
+ if (cur.currentMode() != MATH_MODE)
parseflg |= Parse::TEXTMODE;
cur.message(_("Paste"));
cap::replaceSelection(cur);
}
case LFUN_LINE_BEGIN:
- case LFUN_WORD_BACKWARD:
- case LFUN_WORD_LEFT:
cur.screenUpdateFlags(Update::Decoration | Update::FitCursor);
// fall through
case LFUN_LINE_BEGIN_SELECT:
- case LFUN_WORD_BACKWARD_SELECT:
- case LFUN_WORD_LEFT_SELECT:
cur.selHandle(act == LFUN_WORD_BACKWARD_SELECT ||
act == LFUN_WORD_LEFT_SELECT ||
act == LFUN_LINE_BEGIN_SELECT);
}
break;
- case LFUN_WORD_FORWARD:
- case LFUN_WORD_RIGHT:
case LFUN_LINE_END:
cur.screenUpdateFlags(Update::Decoration | Update::FitCursor);
// fall through
- case LFUN_WORD_FORWARD_SELECT:
- case LFUN_WORD_RIGHT_SELECT:
case LFUN_LINE_END_SELECT:
cur.selHandle(act == LFUN_WORD_FORWARD_SELECT ||
act == LFUN_WORD_RIGHT_SELECT ||
// static
-char InsetMathGrid::colAlign(HullType type, col_type col)
+char InsetMathGrid::colAlign(HullType type, col_type col, BufferParams const & bp)
{
switch (type) {
case hullEqnArray:
return "rcl"[col % 3];
case hullMultline:
- case hullGather:
return 'c';
+ case hullGather:
+ if (!bp.is_math_indent)
+ return 'c';
+ else
+ return 'l';
case hullAlign:
case hullAlignAt: