#include "GuiImage.h"
#include "qt_helpers.h"
-#include "FontInfo.h"
+#include "Font.h"
#include "Language.h"
#include "LyXRC.h"
// Set USE_PIXMAP_CACHE to 1 for enabling the use of a Pixmap cache when
// drawing text. This is especially useful for older PPC/Mac systems.
-#if defined(Q_WS_X11)
+#if defined(Q_WS_X11) || defined(QPA_XCB)
#define USE_PIXMAP_CACHE 0
#else
#define USE_PIXMAP_CACHE 1
#endif
using namespace std;
+using namespace lyx::support;
namespace lyx {
namespace frontend {
-GuiPainter::GuiPainter(QPaintDevice * device)
- : QPainter(device), Painter(),
+const int Painter::thin_line = 0;
+
+GuiPainter::GuiPainter(QPaintDevice * device, double pixel_ratio)
+ : QPainter(device), Painter(pixel_ratio),
use_pixmap_cache_(lyxrc.use_pixmap_cache && USE_PIXMAP_CACHE)
{
// new QPainter has default QPen:
current_color_ = guiApp->colorCache().get(Color_black);
current_ls_ = line_solid;
- current_lw_ = line_thin;
+ current_lw_ = thin_line;
}
void GuiPainter::setQPainterPen(QColor const & col,
- Painter::line_style ls, Painter::line_width lw)
+ Painter::line_style ls, int lw)
{
if (col == current_color_ && ls == current_ls_ && lw == current_lw_)
return;
case line_onoffdash: pen.setStyle(Qt::DotLine); break;
}
- switch (lw) {
- case line_thin: pen.setWidth(0); break;
- case line_thick: pen.setWidth(3); break;
- }
+ pen.setWidth(lw);
setPen(pen);
}
sig.append(QChar(static_cast<short>(f.series())));
sig.append(QChar(static_cast<short>(f.realShape())));
sig.append(QChar(static_cast<short>(f.size())));
- sig.append(QChar(static_cast<short>(f.color())));
+ Color const & color = f.realColor();
+ sig.append(QChar(static_cast<short>(color.baseColor)));
+ sig.append(QChar(static_cast<short>(color.mergeColor)));
if (!monochrome_min_.empty()) {
QColor const & min = monochrome_min_.top();
QColor const & max = monochrome_max_.top();
void GuiPainter::leaveMonochromeMode()
{
- LASSERT(!monochrome_min_.empty(), /**/);
+ LASSERT(!monochrome_min_.empty(), return);
monochrome_min_.pop();
monochrome_max_.pop();
}
void GuiPainter::line(int x1, int y1, int x2, int y2,
Color col,
line_style ls,
- line_width lw)
+ int lw)
{
if (!isDrawingEnabled())
return;
void GuiPainter::lines(int const * xp, int const * yp, int np,
Color col,
+ fill_style fs,
line_style ls,
- line_width lw)
+ int lw)
{
if (!isDrawingEnabled())
return;
// double the size if needed
+ // FIXME THREAD
static QVector<QPoint> points(32);
if (np > points.size())
points.resize(2 * np);
if (i != 0)
antialias |= xp[i-1] != xp[i] && yp[i-1] != yp[i];
}
- setQPainterPen(computeColor(col), ls, lw);
+ QColor const color = computeColor(col);
+ setQPainterPen(color, ls, lw);
bool const text_is_antialiased = renderHints() & TextAntialiasing;
setRenderHint(Antialiasing, antialias && text_is_antialiased);
- drawPolyline(points.data(), np);
+ if (fs == fill_none) {
+ drawPolyline(points.data(), np);
+ } else {
+ QBrush const oldbrush = brush();
+ setBrush(QBrush(color));
+ drawPolygon(points.data(), np, fs == fill_oddeven ?
+ Qt::OddEvenFill : Qt::WindingFill);
+ setBrush(oldbrush);
+ }
setRenderHint(Antialiasing, false);
}
void GuiPainter::rectangle(int x, int y, int w, int h,
Color col,
line_style ls,
- line_width lw)
+ int lw)
{
if (!isDrawingEnabled())
return;
if (!isDrawingEnabled())
return;
- drawImage(x, y, qlimage.image(), 0, 0, w, h);
+ QImage const image = qlimage.image();
+ QRectF const drect = QRectF(x, y, w, h);
+ QRectF const srect = QRectF(0, 0, image.width(), image.height());
+ drawImage(drect, image, srect);
}
int GuiPainter::text(int x, int y, char_type c, FontInfo const & f)
{
- docstring s(1, c);
- return text(x, y, s, f);
-}
-
-
-int GuiPainter::smallCapsText(int x, int y,
- QString const & s, FontInfo const & f)
-{
- FontInfo smallfont(f);
- smallfont.decSize().decSize().setShape(UP_SHAPE);
-
- QFont const & qfont = getFont(f);
- QFont const & qsmallfont = getFont(smallfont);
-
- setQPainterPen(computeColor(f.realColor()));
- int textwidth = 0;
- size_t const ls = s.length();
- for (unsigned int i = 0; i < ls; ++i) {
- QChar const c = s[i].toUpper();
- if (c != s.at(i)) {
- setFont(qsmallfont);
- } else {
- setFont(qfont);
- }
- if (isDrawingEnabled())
- drawText(x + textwidth, y, c);
- textwidth += fontMetrics().width(c);
- }
- return textwidth;
+ return text(x, y, docstring(1, c), f);
}
int GuiPainter::text(int x, int y, docstring const & s,
- FontInfo const & f)
+ FontInfo const & f, bool const rtl,
+ double const wordspacing)
{
+ //LYXERR0("text: x=" << x << ", s=" << s);
if (s.empty())
return 0;
str = ' ' + str;
#endif
- QFont const & ff = getFont(f);
- GuiFontMetrics const & fm = getFontMetrics(f);
-
- int textwidth;
-
- if (f.realShape() == SMALLCAPS_SHAPE) {
- textwidth = smallCapsText(x, y, str, f);
- if (f.underbar() == FONT_ON)
- underline(f, x, y, textwidth);
- return textwidth;
- }
+ QFont ff = getFont(f);
+ ff.setWordSpacing(wordspacing);
+ GuiFontMetrics const & fm = getFontMetrics(f);
// Here we use the font width cache instead of
// textwidth = fontMetrics().width(str);
// because the above is awfully expensive on MacOSX
- textwidth = fm.width(s);
- if (f.underbar() == FONT_ON)
- underline(f, x, y, textwidth);
+ int const textwidth = fm.width(s);
if (!isDrawingEnabled())
return textwidth;
- // Qt4 does not display a glyph whose codepoint is the
- // same as that of a soft-hyphen (0x00ad), unless it
- // occurs at a line-break. As a kludge, we force Qt to
- // render this glyph using a one-column line.
- if (s.size() == 1 && str[0].unicode() == 0x00ad) {
- setQPainterPen(computeColor(f.realColor()));
- QTextLayout adsymbol(str);
- adsymbol.setFont(ff);
- adsymbol.beginLayout();
- QTextLine line = adsymbol.createLine();
- line.setNumColumns(1);
- line.setPosition(QPointF(0, -line.ascent()));
- adsymbol.endLayout();
- line.draw(this, QPointF(x, y));
- return textwidth;
- }
+ textDecoration(f, x, y, textwidth);
if (use_pixmap_cache_) {
QPixmap pm;
int const mD = fm.maxDescent();
int const h = mA + mD;
if (w > 0 && h > 0) {
- pm = QPixmap(w, h);
+ pm = QPixmap(static_cast<int>(pixelRatio() * w),
+ static_cast<int>(pixelRatio() * h));
+#if QT_VERSION >= 0x050000
+ pm.setDevicePixelRatio(pixelRatio());
+#endif
pm.fill(Qt::transparent);
- GuiPainter p(&pm);
+ GuiPainter p(&pm, pixelRatio());
p.setQPainterPen(computeColor(f.realColor()));
if (p.font() != ff)
p.setFont(ff);
// Draw the new cached pixmap.
drawPixmap(x + lb, y - mA, pm);
-
- return textwidth;
}
+ return textwidth;
}
// don't use the pixmap cache,
setQPainterPen(computeColor(f.realColor()));
if (font() != ff)
setFont(ff);
- // We need to draw the text as LTR as we use our own bidi code.
- QPainter::setLayoutDirection(Qt::LeftToRight);
+
+ /* In LyX, the character direction is forced by the language.
+ * Therefore, we have to signal that fact to Qt.
+ */
+#if 1
+ /* Use unicode override characters to enforce drawing direction
+ * Source: http://www.iamcal.com/understanding-bidirectional-text/
+ */
+ if (rtl)
+ // Right-to-left override: forces to draw text right-to-left
+ str = QChar(0x202E) + str;
+ else
+ // Left-to-right override: forces to draw text left-to-right
+ str = QChar(0x202D) + str;
drawText(x, y, str);
+#else
+ /* This looks like a cleaner solution, but it has drawbacks
+ * - does not work reliably (Mac OS X, ...)
+ * - it is not really documented
+ * Keep it here for now, in case it can be helpful
+ */
+ //This is much stronger than setLayoutDirection.
+ int flag = rtl ? Qt::TextForceRightToLeft : Qt::TextForceLeftToRight;
+ drawText(x + (rtl ? textwidth : 0), y - fm.maxAscent(), 0, 0,
+ flag | Qt::TextDontClip,
+ str);
+#endif
//LYXERR(Debug::PAINTING, "draw " << string(str.toUtf8())
// << " at " << x << "," << y);
return textwidth;
}
+int GuiPainter::text(int x, int y, docstring const & str, Font const & f,
+ double const wordspacing)
+{
+ return text(x, y, str, f.fontInfo(), f.isVisibleRightToLeft(), wordspacing);
+}
+
+
+int GuiPainter::text(int x, int y, docstring const & str, Font const & f,
+ Color other, size_type const from, size_type const to,
+ double const wordspacing)
+{
+ GuiFontMetrics const & fm = getFontMetrics(f.fontInfo());
+ FontInfo fi = f.fontInfo();
+ bool const rtl = f.isVisibleRightToLeft();
+
+ // dimensions
+ int const ascent = fm.maxAscent();
+ int const height = fm.maxAscent() + fm.maxDescent();
+ int xmin = fm.pos2x(str, from, rtl, wordspacing);
+ int xmax = fm.pos2x(str, to, rtl, wordspacing);
+ if (xmin > xmax)
+ swap(xmin, xmax);
+
+ // First the part in other color
+ Color const orig = fi.realColor();
+ fi.setPaintColor(other);
+ QRegion const clip(x + xmin, y - ascent, xmax - xmin, height);
+ setClipRegion(clip);
+ int const textwidth = text(x, y, str, fi, rtl, wordspacing);
+
+ // Then the part in normal color
+ // Note that in Qt5, it is not possible to use Qt::UniteClip,
+ // therefore QRegion is used.
+ fi.setPaintColor(orig);
+ QRegion region(viewport());
+ setClipRegion(region - clip);
+ text(x, y, str, fi, rtl, wordspacing);
+ setClipping(false);
+
+ return textwidth;
+}
+
+
+void GuiPainter::textDecoration(FontInfo const & f, int x, int y, int width)
+{
+ if (f.underbar() == FONT_ON)
+ underline(f, x, y, width);
+ if (f.strikeout() == FONT_ON)
+ strikeoutLine(f, x, y, width);
+ if (f.uuline() == FONT_ON)
+ doubleUnderline(f, x, y, width);
+ if (f.uwave() == FONT_ON)
+ // f.color() doesn't work on some circumstances
+ wavyHorizontalLine(x, y, width, f.realColor().baseColor);
+}
+
+
static int max(int a, int b) { return a > b ? a : b; }
}
-void GuiPainter::underline(FontInfo const & f, int x, int y, int width)
+void GuiPainter::underline(FontInfo const & f, int x, int y, int width,
+ line_style ls)
{
FontMetrics const & fm = theFontMetrics(f);
+ int const pos = fm.underlinePos();
- int const below = max(fm.maxDescent() / 2, 2);
- int const height = max((fm.maxDescent() / 4) - 1, 1);
+ line(x, y + pos, x + width, y + pos,
+ f.realColor(), ls, fm.lineWidth());
+}
- if (height < 2)
- line(x, y + below, x + width, y + below, f.realColor());
- else
- fillRectangle(x, y + below, width, below + height, f.realColor());
+
+void GuiPainter::strikeoutLine(FontInfo const & f, int x, int y, int width)
+{
+ FontMetrics const & fm = theFontMetrics(f);
+ int const pos = fm.strikeoutPos();
+
+ line(x, y - pos, x + width, y - pos,
+ f.realColor(), line_solid, fm.lineWidth());
+}
+
+
+void GuiPainter::doubleUnderline(FontInfo const & f, int x, int y, int width)
+{
+ FontMetrics const & fm = theFontMetrics(f);
+ int const pos1 = fm.underlinePos() + fm.lineWidth();
+ int const pos2 = fm.underlinePos() - fm.lineWidth() + 1;
+
+ line(x, y + pos1, x + width, y + pos1,
+ f.realColor(), line_solid, fm.lineWidth());
+ line(x, y + pos2, x + width, y + pos2,
+ f.realColor(), line_solid, fm.lineWidth());
}
void GuiPainter::wavyHorizontalLine(int x, int y, int width, ColorCode col)
{
setQPainterPen(computeColor(col));
- int const step = 4;
+ int const step = 2;
int const xend = x + width;
int height = 1;
//FIXME: I am not sure if Antialiasing gives the best effect.
height = - height;
drawLine(x, y - height, x + step, y + height);
x += step;
- drawLine(x, y + height, x + 2, y + height);
- x += 2;
+ drawLine(x, y + height, x + step/2, y + height);
+ x += step/2;
}
//setRenderHint(Antialiasing, false);
}
projects / lyx.git / blobdiff