#include "frontends/font_metrics.h"
#include "frontends/nullpainter.h"
+#include "frontends/LyXView.h"
+#include "frontends/WorkArea.h"
#include "frontends/Painter.h"
#include "insets/insettext.h"
#include <boost/crc.hpp>
+using lyx::docstring;
+using lyx::frontend::Painter;
+using lyx::frontend::NullPainter;
+using lyx::char_type;
using lyx::pos_type;
using lyx::pit_type;
namespace {
+/// Flag: do a full redraw of inside text of inset
+/// Working variable indicating a full screen refresh
+bool refreshInside;
+
/**
* A class used for painting an individual row of text.
*/
void paintForeignMark(double orig_x, LyXFont const & font, int desc = 0);
void paintHebrewComposeChar(lyx::pos_type & vpos, LyXFont const & font);
void paintArabicComposeChar(lyx::pos_type & vpos, LyXFont const & font);
- void paintChars(lyx::pos_type & vpos, LyXFont font,
- bool hebrew, bool arabic);
+ void paintChars(lyx::pos_type & vpos, LyXFont font,
+ bool hebrew, bool arabic);
int paintAppendixStart(int y);
void paintFromPos(lyx::pos_type & vpos);
void paintInset(lyx::pos_type const pos, LyXFont const & font);
pi.ltr_pos = (text_.bidi.level(pos) % 2 == 0);
pi.erased_ = erased_ || isDeletedText(par_, pos);
theCoords.insets().add(inset, int(x_), yo_);
- inset->drawSelection(pi, int(x_), yo_);
+ InsetText const * const in = inset->asTextInset();
+ // non-wide insets are painted completely. Recursive
+ bool tmp = refreshInside;
+ if (!in || !in->Wide()) {
+ refreshInside = true;
+ lyxerr[Debug::PAINTING] << endl << "Paint inset fully" << endl;
+ }
+ if (refreshInside)
+ inset->drawSelection(pi, int(x_), yo_);
inset->draw(pi, int(x_), yo_);
+ refreshInside = tmp;
x_ += inset->width();
}
string str;
// first char
- char c = par_.getChar(pos);
+ char_type c = par_.getChar(pos);
str += c;
++vpos;
for (pos_type i = pos - 1; i >= 0; --i) {
c = par_.getChar(i);
- if (!Encodings::IsComposeChar_hebrew(c)) {
- if (IsPrintableNonspace(c)) {
+ if (!Encodings::isComposeChar_hebrew(c)) {
+ if (isPrintableNonspace(c)) {
int const width2 =
text_.singleWidth(par_, i, c, text_.getFont(par_, i));
// dalet / resh
}
// Draw nikud
- pain_.text(int(x_) + dx, yo_, str, font);
+ docstring dstr(str.begin(), str.end());
+ pain_.text(int(x_) + dx, yo_, dstr, font);
}
string str;
// first char
- char c = par_.getChar(pos);
+ char_type c = par_.getChar(pos);
c = par_.transformChar(c, pos);
str += c;
++vpos;
for (pos_type i = pos - 1; i >= 0; --i) {
c = par_.getChar(i);
- if (!Encodings::IsComposeChar_arabic(c)) {
- if (IsPrintableNonspace(c)) {
- int const width2 =
+ if (!Encodings::isComposeChar_arabic(c)) {
+ if (isPrintableNonspace(c)) {
+ int const width2 =
text_.singleWidth(par_, i, c, text_.getFont(par_, i));
dx = (width2 - width) / 2;
}
}
}
// Draw nikud
- pain_.text(int(x_) + dx, yo_, str, font);
+ docstring dstr(str.begin(), str.end());
+ pain_.text(int(x_) + dx, yo_, dstr, font);
}
-void RowPainter::paintChars(pos_type & vpos, LyXFont font,
+void RowPainter::paintChars(pos_type & vpos, LyXFont font,
bool hebrew, bool arabic)
{
pos_type pos = text_.bidi.vis2log(vpos);
pos_type const end = row_.endpos();
FontSpan const font_span = par_.fontSpan(pos);
- Change::Type const prev_change = par_.lookupChange(pos);
+ Change::Type const prev_change = par_.lookupChange(pos).type;
// first character
+#if 0
string str;
str += par_.getChar(pos);
+#else
+ std::vector<char_type> str;
+ str.push_back(par_.getChar(pos));
+#endif
if (arabic) {
- unsigned char c = str[0];
+ char_type c = str[0];
str[0] = par_.transformChar(c, pos);
}
if (prev_change != par_.lookupChange(pos))
break;
- char c = par_.getChar(pos);
+ char_type c = par_.getChar(pos);
- if (!IsPrintableNonspace(c))
+ if (!isPrintableNonspace(c))
break;
- if (arabic && Encodings::IsComposeChar_arabic(c))
+ if (arabic && Encodings::isComposeChar_arabic(c))
break;
- if (hebrew && Encodings::IsComposeChar_hebrew(c))
+ if (hebrew && Encodings::isComposeChar_hebrew(c))
break;
if (arabic)
c = par_.transformChar(c, pos);
+#if 0
str += c;
+#else
+ str.push_back(c);
+#endif
}
if (prev_change == Change::DELETED)
// Draw text and set the new x position
//lyxerr << "paint row: yo_ " << yo_ << "\n";
+#if 0
pain_.text(int(x_), yo_, str, font);
x_ += font_metrics::width(str, font);
+#else
+ pain_.text(int(x_), yo_, &str[0], str.size(), font);
+ x_ += font_metrics::width(&str[0], str.size(), font);
+#endif
}
}
// usual characters, no insets
- char const c = par_.getChar(pos);
+ char_type const c = par_.getChar(pos);
// special case languages
std::string const & lang = orig_font.language()->lang();
// draw as many chars as we can
if ((!hebrew && !arabic)
- || (hebrew && !Encodings::IsComposeChar_hebrew(c))
- || (arabic && !Encodings::IsComposeChar_arabic(c))) {
+ || (hebrew && !Encodings::isComposeChar_hebrew(c))
+ || (arabic && !Encodings::isComposeChar_arabic(c))) {
paintChars(vpos, orig_font, hebrew, arabic);
} else if (hebrew) {
paintHebrewComposeChar(vpos, orig_font);
pos_type const start = row_.pos();
pos_type const end = row_.endpos();
- if (start == end || !par_.isChanged(start, end - 1))
+ if (start == end || !par_.isChanged(start, end))
return;
int const height = text_.isLastRow(pit_, row_)
pb_font.setColor(LColor::appendix);
pb_font.decSize();
- string const label = _("Appendix");
+ string const label = lyx::to_utf8(_("Appendix"));
int w = 0;
int a = 0;
int d = 0;
- font_metrics::rectText(label, pb_font, w, a, d);
+ docstring dlab(label.begin(), label.end());
+ font_metrics::rectText(dlab, pb_font, w, a, d);
int const text_start = int(xo_ + (width_ - w) / 2);
int const text_end = text_start + w;
- pain_.rectText(text_start, y + d, label, pb_font, LColor::none, LColor::none);
+ pain_.rectText(text_start, y + d, dlab, pb_font, LColor::none, LColor::none);
pain_.line(int(xo_ + 1), y, text_start, y, LColor::appendix);
pain_.line(text_end, y, int(xo_ + width_ - 2), y, LColor::appendix);
string const str = par_.getLabelstring();
if (!str.empty()) {
double x = x_;
+ docstring dstr(str.begin(), str.end());
// this is special code for the chapter layout. This is
// printed in an extra row and has a pagebreak at
if (is_rtl) {
x = width_ - leftMargin() -
- font_metrics::width(str, font);
+ font_metrics::width(dstr, font);
}
- pain_.text(int(x), yo_ - maxdesc - labeladdon, str, font);
+ pain_.text(int(x), yo_ - maxdesc - labeladdon, dstr, font);
} else {
+ string lab = layout->labelsep;
+ docstring dlab(lab.begin(), lab.end());
if (is_rtl) {
x = width_ - leftMargin()
- + font_metrics::width(layout->labelsep, font);
+ + font_metrics::width(dlab, font);
} else {
- x = x_ - font_metrics::width(layout->labelsep, font)
- - font_metrics::width(str, font);
+ x = x_ - font_metrics::width(dlab, font)
+ - font_metrics::width(dstr, font);
}
- pain_.text(int(x), yo_, str, font);
+ pain_.text(int(x), yo_, dstr, font);
}
}
LyXFont font = getLabelFont();
if (!par_.getLabelstring().empty()) {
string const str = par_.getLabelstring();
+ docstring dstr(str.begin(), str.end());
double spacing_val = 1.0;
if (!parparams.spacing().isDefault())
spacing_val = parparams.spacing().getValue();
if (is_rtl)
x = leftMargin();
x += (width_ - text_.rightMargin(par_) - leftMargin()) / 2;
- x -= font_metrics::width(str, font) / 2;
+ x -= font_metrics::width(dstr, font) / 2;
} else if (is_rtl) {
x = width_ - leftMargin() -
- font_metrics::width(str, font);
+ font_metrics::width(dstr, font);
}
- pain_.text(int(x), yo_ - maxdesc - labeladdon, str, font);
+ pain_.text(int(x), yo_ - maxdesc - labeladdon, dstr, font);
}
}
}
case END_LABEL_STATIC: {
LyXFont font = getLabelFont();
string const & str = par_.layout()->endlabelstring();
+ docstring dstr(str.begin(), str.end());
double const x = is_rtl ?
- x_ - font_metrics::width(str, font)
+ x_ - font_metrics::width(dstr, font)
: - text_.rightMargin(par_) - row_.width();
- pain_.text(int(x), yo_, str, font);
+ pain_.text(int(x), yo_, dstr, font);
break;
}
bool is_struckout = false;
int last_strikeout_x = 0;
- // Use font span to speed things up, see below
+ // Use font span to speed things up, see below
FontSpan font_span;
LyXFont font;
}
if (body_pos > 0 && pos == body_pos - 1) {
- int const lwidth = font_metrics::width(layout->labelsep,
+ string lab = layout->labelsep;
+ docstring dlab(lab.begin(), lab.end());
+ int const lwidth = font_metrics::width(dlab,
getLabelFont());
x_ += label_hfill_ + lwidth - width_pos;
}
-lyx::size_type calculateRowSignature(Row const & row, Paragraph const & par)
+lyx::size_type calculateRowSignature(Row const & row, Paragraph const & par,
+ int x, int y)
{
boost::crc_32_type crc;
for (lyx::pos_type i = row.pos(); i < row.endpos(); ++i) {
const unsigned char b[] = { par.getChar(i) };
crc.process_bytes(b, 1);
}
+ const unsigned char b[] = { x, y, row.width() };
+ crc.process_bytes(b, 3);
return crc.checksum();
}
-bool isCursorOnRow(PainterInfo & pi, pit_type pit, RowList::const_iterator rit)
+bool CursorOnRow(PainterInfo & pi, pit_type const pit,
+ RowList::const_iterator rit, LyXText const & text)
{
+ // Is there a cursor on this row (or inside inset on row)
LCursor & cur = pi.base.bv->cursor();
- for (lyx::size_type d = 0; d < cur.depth(); d++)
- if (cur[d].pit() == pit
- && cur[d].pos() >= rit->pos()
- && cur[d].pos() <= rit->endpos())
+ for (lyx::size_type d = 0; d < cur.depth(); d++) {
+ CursorSlice const & sl = cur[d];
+ if (sl.text() == &text
+ && sl.pit() == pit
+ && sl.pos() >= rit->pos()
+ && sl.pos() <= rit->endpos())
return true;
+ }
+ return false;
+}
+
+
+bool innerCursorOnRow(PainterInfo & pi, pit_type pit,
+ RowList::const_iterator rit, LyXText const & text)
+{
+ // Is there a cursor inside an inset on this row, and is this inset
+ // the only "character" on this row
+ LCursor & cur = pi.base.bv->cursor();
+ if (rit->pos() + 1 != rit->endpos())
+ return false;
+ for (lyx::size_type d = 0; d < cur.depth(); d++) {
+ CursorSlice const & sl = cur[d];
+ if (sl.text() == &text
+ && sl.pit() == pit
+ && sl.pos() == rit->pos())
+ return d < cur.depth() - 1;
+ }
return false;
}
static PainterInfo nullpi(pi.base.bv, nop);
int const ww = pi.base.bv->workHeight();
+ theCoords.parPos()[&text][pit] = Point(x, y);
+
Paragraph const & par = text.paragraphs()[pit];
+ if (par.rows().empty())
+ return;
RowList::const_iterator const rb = par.rows().begin();
RowList::const_iterator const re = par.rows().end();
- theCoords.parPos()[&text][pit] = Point(x, y);
y -= rb->ascent();
lyx::size_type rowno(0);
for (RowList::const_iterator rit = rb; rit != re; ++rit, ++rowno) {
y += rit->ascent();
+ // Allow setting of refreshInside for nested insets in
+ // this row only
+ bool tmp = refreshInside;
// Row signature; has row changed since last paint?
- lyx::size_type const row_sig = calculateRowSignature(*rit, par);
+ lyx::size_type const row_sig = calculateRowSignature(*rit, par, x, y);
+ bool row_has_changed = par.rowSignature()[rowno] != row_sig;
+
+ bool cursor_on_row = CursorOnRow(pi, pit, rit, text);
+ bool in_inset_alone_on_row = innerCursorOnRow(pi, pit, rit,
+ text);
+
+ // If this is the only object on the row, we can make it wide
+ for (pos_type i = rit->pos() ; i != rit->endpos(); ++i) {
+ InsetBase const * const in = par.getInset(i);
+ if (in) {
+ InsetText const * const t = in->asTextInset();
+ if (t)
+ t->Wide() = in_inset_alone_on_row;
+ }
+ }
- bool cursor_on_row = isCursorOnRow(pi, pit, rit);
-
- // If selection is on, the current row signature differs from
- // from cache, or cursor is inside an inset _on this row_,
+ // If selection is on, the current row signature differs
+ // from cache, or cursor is inside an inset _on this row_,
// then paint the row
- if (repaintAll || par.rowSignature()[rowno] != row_sig
- || cursor_on_row) {
+ if (repaintAll || row_has_changed || cursor_on_row) {
// Add to row signature cache
par.rowSignature()[rowno] = row_sig;
bool const inside = (y + rit->descent() >= 0
&& y - rit->ascent() < ww);
RowPainter rp(inside ? pi : nullpi, text, pit, *rit, x, y);
- // Clear background of this row
+ // Clear background of this row
// (if paragraph background was not cleared)
- if (!repaintAll) {
- pi.pain.fillRectangle(x, y - rit->ascent(),
- pi.base.bv->workWidth(), rit->height(),
+ if (!repaintAll &&
+ (!in_inset_alone_on_row || row_has_changed)) {
+ pi.pain.fillRectangle(x, y - rit->ascent(),
+ text.maxwidth_, rit->height(),
text.backgroundColor());
+ // If outer row has changed, force nested
+ // insets to repaint completely
+ if (row_has_changed)
+ refreshInside = true;
}
-
+
// Instrumentation for testing row cache (see also
// 12 lines lower):
- //lyxerr << "#";
+ if (text.isMainText())
+ lyxerr[Debug::PAINTING] << "#";
+ else
+ lyxerr[Debug::PAINTING] << "[" <<
+ repaintAll << row_has_changed <<
+ cursor_on_row << "]";
rp.paintAppendix();
rp.paintDepthBar();
rp.paintChangeBar();
rp.paintText();
}
y += rit->descent();
+ // Restore, see above
+ refreshInside = tmp;
}
- //lyxerr << "." << endl;
+ lyxerr[Debug::PAINTING] << "." << endl;
}
} // namespace anon
-void paintText(BufferView const & bv, ViewMetricsInfo const & vi)
+void paintText(BufferView const & bv, ViewMetricsInfo const & vi,
+ Painter & pain)
{
- Painter & pain = bv.painter();
- LyXText * const text = bv.text();
+ LyXText & text = bv.buffer()->text();
bool const select = bv.cursor().selection();
PainterInfo pi(const_cast<BufferView *>(&bv), pain);
- if (select || !vi.singlepar) {
- // Clear background (Delegated to rows if no selection)
+ // Should the whole screen, including insets, be refreshed?
+ bool repaintAll = select || !vi.singlepar;
+
+ if (repaintAll) {
+ // Clear background (if not delegated to rows)
pain.fillRectangle(0, vi.y1, bv.workWidth(), vi.y2 - vi.y1,
- text->backgroundColor());
+ text.backgroundColor());
}
if (select) {
- text->drawSelection(pi, 0, 0);
+ text.drawSelection(pi, 0, 0);
}
int yy = vi.y1;
// draw contents
for (pit_type pit = vi.p1; pit <= vi.p2; ++pit) {
- Paragraph const & par = text->getPar(pit);
+ refreshInside = repaintAll;
+ Paragraph const & par = text.getPar(pit);
yy += par.ascent();
- paintPar(pi, *bv.text(), pit, 0, yy, select || !vi.singlepar);
+ paintPar(pi, text, pit, 0, yy, repaintAll);
yy += par.descent();
}
// Try viewing the User Guide Mobius figure
if (vi.p1 > 0) {
- text->redoParagraph(vi.p1 - 1);
- theCoords.parPos()[bv.text()][vi.p1 - 1] =
- Point(0, vi.y1 - text->getPar(vi.p1 - 1).descent());
+ text.redoParagraph(vi.p1 - 1);
+ theCoords.parPos()[&text][vi.p1 - 1] =
+ Point(0, vi.y1 - text.getPar(vi.p1 - 1).descent());
}
- if (vi.p2 < lyx::pit_type(text->paragraphs().size()) - 1) {
- text->redoParagraph(vi.p2 + 1);
- theCoords.parPos()[bv.text()][vi.p2 + 1] =
- Point(0, vi.y2 + text->getPar(vi.p2 + 1).ascent());
+ if (vi.p2 < lyx::pit_type(text.paragraphs().size()) - 1) {
+ text.redoParagraph(vi.p2 + 1);
+ theCoords.parPos()[&text][vi.p2 + 1] =
+ Point(0, vi.y2 + text.getPar(vi.p2 + 1).ascent());
}
// and grey out above (should not happen later)
-// lyxerr << "par ascent: " << text->getPar(vi.p1).ascent() << endl;
+// lyxerr << "par ascent: " << text.getPar(vi.p1).ascent() << endl;
if (vi.y1 > 0 && !vi.singlepar)
pain.fillRectangle(0, 0, bv.workWidth(), vi.y1, LColor::bottomarea);
// and possibly grey out below
-// lyxerr << "par descent: " << text->getPar(vi.p1).ascent() << endl;
+// lyxerr << "par descent: " << text.getPar(vi.p1).ascent() << endl;
if (vi.y2 < bv.workHeight() && !vi.singlepar)
pain.fillRectangle(0, vi.y2, bv.workWidth(), bv.workHeight() - vi.y2, LColor::bottomarea);
}
// lyxerr << " paintTextInset: y: " << y << endl;
y -= text.getPar(0).ascent();
+ // This flag can not be set from within same inset:
+ bool repaintAll = refreshInside;
for (int pit = 0; pit < int(text.paragraphs().size()); ++pit) {
y += text.getPar(pit).ascent();
- paintPar(pi, text, pit, x, y, true);
+ paintPar(pi, text, pit, x, y, repaintAll);
y += text.getPar(pit).descent();
}
}
projects / lyx.git / blobdiff