anne/lyx_mirror
1
0
Fork 0
mirror of https://git.lyx.org/repos/lyx.git synced 2024-12-22 05:16:21 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

Remove old cruft

Browse Source 
There are many things that are not necessary anymore:

* remove methods paintText2, paintFromPos, leftMargin, paintInlineCompletion

* Remove use of Bidi class.

* add a Font and a Change parameter to paintInset.

Also remove a comment that describes what we have just done.
This commit is contained in:
Jean-Marc Lasgouttes 2015-07-16 23:34:33 +02:00
parent 83afe2e547
commit f750d9b5cf
2 changed files with 16 additions and 331 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

319
src/RowPainter.cpp
View File

@ -64,8 +64,6 @@ RowPainter::RowPainter(PainterInfo & pi,
solid_line_thickness_(1), solid_line_offset_(1),
dotted_line_thickness_(1), dotted_line_offset_(2)
{
bidi_.computeTables(par_, pi_.base.bv->buffer(), row_);
if (lyxrc.zoom >= 200) {
// derive the line thickness from zoom factor
// the zoom is given in percent
@ -103,18 +101,14 @@ FontInfo RowPainter::labelFont() const
}
int RowPainter::leftMargin() const
{
return text_metrics_.leftMargin(text_metrics_.width(), pit_,
row_.pos());
}
// If you want to debug inset metrics uncomment the following line:
//#define DEBUG_METRICS
// This draws green lines around each inset.
void RowPainter::paintInset(Inset const * inset, pos_type const pos)
void RowPainter::paintInset(Inset const * inset, Font const & font,
Change const & change,
pos_type const pos)
{
// Handle selection
bool const pi_selected = pi_.selected;
@ -123,19 +117,17 @@ void RowPainter::paintInset(Inset const * inset, pos_type const pos)
&& cur.normalAnchor().text() == &text_)
pi_.selected = row_.sel_beg <= pos && row_.sel_end > pos;
Font const font = text_metrics_.displayFont(pit_, pos);
LASSERT(inset, return);
// Backup full_repaint status because some insets (InsetTabular)
// requires a full repaint
bool const pi_full_repaint = pi_.full_repaint;
bool const pi_do_spellcheck = pi_.do_spellcheck;
Change const pi_change = pi_.change_;
pi_.base.font = inset->inheritFont() ? font.fontInfo() :
pi_.base.bv->buffer().params().getFont().fontInfo();
pi_.ltr_pos = (bidi_.level(pos) % 2 == 0);
Change prev_change = change_;
pi_.change_ = change_.changed() ? change_ : par_.lookupChange(pos);
pi_.ltr_pos = !font.isVisibleRightToLeft();
pi_.change_ = change_.changed() ? change_ : change;
pi_.do_spellcheck &= inset->allowSpellCheck();
int const x1 = int(x_);
@ -155,7 +147,7 @@ void RowPainter::paintInset(Inset const * inset, pos_type const pos)
// Restore full_repaint status.
pi_.full_repaint = pi_full_repaint;
pi_.change_ = prev_change;
pi_.change_ = pi_change;
pi_.do_spellcheck = pi_do_spellcheck;
pi_.selected = pi_selected;
@ -294,94 +286,6 @@ void RowPainter::paintChange(double orig_x, Font const & font,
}
void RowPainter::paintFromPos(pos_type & vpos, bool changed)
{
pos_type pos = bidi_.vis2log(vpos);
pos_type start_pos = pos;
// first character
docstring str;
str.reserve(100);
char_type const c = par_.getChar(pos);
str.push_back(c);
double const orig_x = x_;
Font const font = text_metrics_.displayFont(pit_, pos);
FontSpan const font_span = par_.fontSpan(pos);
// Track-change status.
Change const & change_running = par_.lookupChange(pos);
// collect as much similar chars as we can
pos_type const end = row_.endpos();
for (++vpos ; vpos < end ; ++vpos) {
pos = bidi_.vis2log(vpos);
if (!font_span.contains(pos))
break;
Change const & change = par_.lookupChange(pos);
if (!change_running.isSimilarTo(change))
// Track change type or author has changed.
break;
char_type const c = par_.getChar(pos);
if (c == '\t')
break;
if (!isPrintableNonspace(c))
break;
str.push_back(c);
}
// Make pos point to the last character in the string.
// Using "pos = bidi_.vis2log(vpos)" does not work for some reason.
if (vpos < end)
pos = bidi_.vis2log(vpos - 1);
// Now make pos point to the position _after_ the string.
// Using vis2log for that is not a good idea in general, we
// want logical ordering.
if (font.isVisibleRightToLeft())
--pos;
else
++pos;
if (str[0] == '\t')
str.replace(0,1,from_ascii(" "));
/* Because we do our own bidi, at this point the strings are
* already in visual order. However, Qt also applies its own
* bidi algorithm to strings that it paints to the screen.
* Therefore, if we were to paint Hebrew/Arabic words as a
* single string, the letters in the words would get reversed
* again. In order to avoid that, we reverse our string.
* See also http://thread.gmane.org/gmane.editors.lyx.devel/79740
* for an earlier thread on the subject
*/
if (font.isVisibleRightToLeft()) {
reverse(str.begin(), str.end());
// If the string is reversed, the positions need to be adjusted
++pos;
++start_pos;
swap(start_pos, pos);
}
// Actually paint the text, taking care about the selection
paintStringAndSel(str, font, change_running, start_pos, pos);
// The line that indicates word in a different language
paintForeignMark(orig_x, font.language());
// Paint the spelling mark if needed.
if (lyxrc.spellcheck_continuously && pi_.do_spellcheck
&& par_.isMisspelled(start_pos)) {
paintMisspelledMark(orig_x, str, font, start_pos, changed);
}
}
void RowPainter::paintChangeBar() const
{
pos_type const start = row_.pos();
@ -557,7 +461,7 @@ void RowPainter::paintLabel() const
double x = x_;
if (is_rtl) {
x = width_ - leftMargin()
x = width_ - row_.left_margin
+ fm.width(layout.labelsep);
} else {
x = x_ - fm.width(layout.labelsep)
@ -597,11 +501,11 @@ void RowPainter::paintTopLevelLabel() const
double x = x_;
if (layout.labeltype == LABEL_CENTERED) {
if (is_rtl)
x = leftMargin();
x += (width_ - text_metrics_.rightMargin(pm_) - leftMargin()) / 2;
x = row_.left_margin;
x += (width_ - text_metrics_.rightMargin(pm_) - row_.left_margin) / 2;
x -= fm.width(str) / 2;
} else if (is_rtl) {
x = width_ - leftMargin() - fm.width(str);
x = width_ - row_.left_margin - fm.width(str);
}
pi_.pain.text(int(x), yo_ - maxdesc - labeladdon, str, font);
}
@ -723,7 +627,8 @@ void RowPainter::paintOnlyInsets()
|| !cache.getInsets().has(inset))
continue;
x_ = cache.getInsets().x(inset);
paintInset(inset, pos);
Font const font = text_metrics_.displayFont(pit_, pos);
paintInset(inset, font, par_.lookupChange(pos), pos);
}
}
@ -750,7 +655,7 @@ void RowPainter::paintText()
case Row::INSET: {
// If outer row has changed, nested insets are repaint completely.
pi_.base.bv->coordCache().insets().add(e.inset, int(x_), yo_);
paintInset(e.inset, e.pos);
paintInset(e.inset, e.font, e.change, e.pos);
foreign_descent = e.dim.descent();
}
break;
@ -766,168 +671,6 @@ void RowPainter::paintText()
if (e.type != Row::INSET || ! e.inset->canTrackChanges())
paintChange(orig_x, e.font, e.change);
}
#if 0
x_ = row_.left_margin + xo_;
paintText2();
#endif
}
void RowPainter::paintText2()
{
//LYXERR0("-------------------------------------------------------");
pos_type const end = row_.endpos();
// Spaces at logical line breaks in bidi text must be skipped during
// painting. However, they may appear visually in the middle
// of a row; they must be skipped, wherever they are...
// * logically "abc_[HEBREW_\nHEBREW]"
// * visually "abc_[_WERBEH\nWERBEH]"
pos_type skipped_sep_vpos = -1;
pos_type body_pos = par_.beginOfBody();
if (body_pos > 0 &&
(body_pos > end || !par_.isLineSeparator(body_pos - 1))) {
body_pos = 0;
}
Layout const & layout = par_.layout();
Change change_running;
int change_last_x = 0;
// check for possible inline completion
DocIterator const & inlineCompletionPos = pi_.base.bv->inlineCompletionPos();
pos_type inlineCompletionVPos = -1;
if (inlineCompletionPos.inTexted()
&& inlineCompletionPos.text() == &text_
&& inlineCompletionPos.pit() == pit_
&& inlineCompletionPos.pos() - 1 >= row_.pos()
&& inlineCompletionPos.pos() - 1 < row_.endpos()) {
// draw logically behind the previous character
inlineCompletionVPos = bidi_.log2vis(inlineCompletionPos.pos() - 1);
}
// Use font span to speed things up, see below
FontSpan font_span;
Font font;
// If the last logical character is a separator, don't paint it, unless
// it's in the last row of a paragraph; see skipped_sep_vpos declaration
if (end > 0 && end < par_.size() && par_.isSeparator(end - 1))
skipped_sep_vpos = bidi_.log2vis(end - 1);
for (pos_type vpos = row_.pos(); vpos < end; ) {
if (x_ > pi_.base.bv->workWidth())
break;
// Skip the separator at the logical end of the row
if (vpos == skipped_sep_vpos) {
++vpos;
continue;
}
pos_type const pos = bidi_.vis2log(vpos);
if (pos >= par_.size()) {
++vpos;
continue;
}
// Use font span to speed things up, see above
if (!font_span.contains(pos)) {
font_span = par_.fontSpan(pos);
font = text_metrics_.displayFont(pit_, pos);
// split font span if inline completion is inside
if (inlineCompletionVPos != -1
&& font_span.contains(inlineCompletionPos.pos()))
font_span.last = inlineCompletionPos.pos();
}
// Note that this value will only be used in
// situations where no ligature of composition of
// characters is needed. (see comments in uses of width_pos).
const int width_pos = pm_.singleWidth(pos, font);
Change const & change = par_.lookupChange(pos);
if (change.changed() && !change_running.changed()) {
change_running = change;
change_last_x = int(x_);
}
Inset const * inset = par_.getInset(pos);
bool const highly_editable_inset = inset
&& inset->editable();
// If we reach the end of a change or if the author changes, paint it.
// We also don't paint across things like tables
if (change_running.changed() && (highly_editable_inset
|| !change.changed() || !change_running.isSimilarTo(change))) {
// Calculate 1/3 height of the buffer's default font
FontMetrics const & fm
= theFontMetrics(pi_.base.bv->buffer().params().getFont());
int const y_bar = change_running.deleted() ?
yo_ - fm.maxAscent() / 3 : yo_ + 2 * solid_line_offset_ + solid_line_thickness_;
pi_.pain.line(change_last_x, y_bar, int(x_), y_bar,
change_running.color(), Painter::line_solid, solid_line_thickness_);
// Change might continue with a different author or type
if (change.changed() && !highly_editable_inset) {
change_running = change;
change_last_x = int(x_);
} else
change_running.setUnchanged();
}
if (body_pos > 0 && pos == body_pos - 1) {
int const lwidth = theFontMetrics(labelFont())
.width(layout.labelsep);
// width_pos is either the width of a space or an inset
x_ += row_.label_hfill + lwidth - width_pos;
}
// Is the inline completion in front of character?
if (font.isRightToLeft() && vpos == inlineCompletionVPos)
paintInlineCompletion(font);
if (par_.isSeparator(pos)) {
Font const orig_font = text_metrics_.displayFont(pit_, pos);
double const orig_x = x_;
// width_pos is the width of a space
double separator_width = width_pos;
if (pos >= body_pos)
separator_width += row_.separator;
paintSeparator(separator_width, orig_font);
paintForeignMark(orig_x, orig_font.language());
++vpos;
} else if (inset) {
// If outer row has changed, nested insets are repaint completely.
pi_.base.bv->coordCache().insets().add(inset, int(x_), yo_);
paintInset(inset, pos);
++vpos;
} else {
// paint as many characters as possible.
paintFromPos(vpos, change_running.changed());
}
// Is the inline completion after character?
if (!font.isRightToLeft() && vpos - 1 == inlineCompletionVPos)
paintInlineCompletion(font);
}
// if we reach the end of a struck out range, paint it
if (change_running.changed()) {
FontMetrics const & fm
= theFontMetrics(pi_.base.bv->buffer().params().getFont());
int const y_bar = change_running.deleted() ?
yo_ - fm.maxAscent() / 3 : yo_ + 2 * solid_line_offset_ + solid_line_thickness_;
pi_.pain.line(change_last_x, y_bar, int(x_), y_bar,
change_running.color(), Painter::line_solid, solid_line_thickness_);
change_running.setUnchanged();
}
}
@ -1029,38 +772,4 @@ void RowPainter::paintSelection() const
}
void RowPainter::paintInlineCompletion(Font const & font)
{
docstring completion = pi_.base.bv->inlineCompletion();
FontInfo f = font.fontInfo();
bool rtl = font.isRightToLeft();
// draw the unique and the non-unique completion part
// Note: this is not time-critical as it is
// only done once per screen.
size_t uniqueTo = pi_.base.bv->inlineCompletionUniqueChars();
docstring s1 = completion.substr(0, uniqueTo);
docstring s2 = completion.substr(uniqueTo);
ColorCode c1 = Color_inlinecompletion;
ColorCode c2 = Color_nonunique_inlinecompletion;
// right to left?
if (rtl) {
swap(s1, s2);
swap(c1, c2);
}
if (!s1.empty()) {
f.setColor(c1);
pi_.pain.text(int(x_), yo_, s1, f);
x_ += theFontMetrics(font).width(s1);
}
if (!s2.empty()) {
f.setColor(c2);
pi_.pain.text(int(x_), yo_, s2, f);
x_ += theFontMetrics(font).width(s2);
}
}
} // namespace lyx

28
src/RowPainter.h
View File

@ -14,7 +14,6 @@
#ifndef ROWPAINTER_H
#define ROWPAINTER_H
#include "Bidi.h"
#include "Changes.h"
#include "support/types.h"
@ -36,21 +35,6 @@ class TextMetrics;
namespace frontend { class Painter; }
/**
* FIXME: Re-implement row painting using row elements.
*
* This is not difficult in principle, but the code is intricate and
* needs some careful analysis. The first thing that needs to be done
* is to break row elements with the same criteria. Currently breakRow
* does not consider on-the-fly spell-checking, but it is not clear to
* me that it is required. Moreover, this thing would only work if we
* are sure that the Row object is up-to-date when drawing happens.
* This depends on the update machinery.
*
* This would allow to get rid of the Bidi class.
*/
/**
* A class used for painting an individual row of text.
* FIXME: get rid of that class.
@ -70,7 +54,6 @@ public:
void paintFirst() const;
void paintLast();
void paintText();
void paintText2();
void paintOnlyInsets();
void paintSelection() const;
@ -85,12 +68,8 @@ private:
pos_type pos, bool changed) const;
void paintChange(double orig_x , Font const & font, Change const & change) const;
int paintAppendixStart(int y) const;
void paintFromPos(pos_type & vpos, bool changed);
void paintInset(Inset const * inset, pos_type const pos);
void paintInlineCompletion(Font const & font);
/// return left margin
int leftMargin() const;
void paintInset(Inset const * inset, Font const & font,
Change const & change, pos_type const pos);
/// return the label font for this row
FontInfo labelFont() const;
@ -117,9 +96,6 @@ private:
Paragraph const & par_;
ParagraphMetrics const & pm_;
/// bidi cache
Bidi bidi_;
/// row changed? (change tracking)
Change const change_;