src/svg/qsvggraphics.cpp

   1 /****************************************************************************
   2 **
   3 ** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
   4 ** All rights reserved.
   5 ** Contact: Nokia Corporation (qt-info@nokia.com)
   6 **
   7 ** This file is part of the QtSvg module of the Qt Toolkit.
   8 **
   9 ** $QT_BEGIN_LICENSE:LGPL$
  10 ** Commercial Usage
  11 ** Licensees holding valid Qt Commercial licenses may use this file in
  12 ** accordance with the Qt Commercial License Agreement provided with the
  13 ** Software or, alternatively, in accordance with the terms contained in
  14 ** a written agreement between you and Nokia.
  15 **
  16 ** GNU Lesser General Public License Usage
  17 ** Alternatively, this file may be used under the terms of the GNU Lesser
  18 ** General Public License version 2.1 as published by the Free Software
  19 ** Foundation and appearing in the file LICENSE.LGPL included in the
  20 ** packaging of this file.  Please review the following information to
  21 ** ensure the GNU Lesser General Public License version 2.1 requirements
  22 ** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
  23 **
  24 ** In addition, as a special exception, Nokia gives you certain additional
  25 ** rights.  These rights are described in the Nokia Qt LGPL Exception
  26 ** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
  27 **
  28 ** GNU General Public License Usage
  29 ** Alternatively, this file may be used under the terms of the GNU
  30 ** General Public License version 3.0 as published by the Free Software
  31 ** Foundation and appearing in the file LICENSE.GPL included in the
  32 ** packaging of this file.  Please review the following information to
  33 ** ensure the GNU General Public License version 3.0 requirements will be
  34 ** met: http://www.gnu.org/copyleft/gpl.html.
  35 **
  36 ** If you have questions regarding the use of this file, please contact
  37 ** Nokia at qt-info@nokia.com.
  38 ** $QT_END_LICENSE$
  39 **
  40 ****************************************************************************/
  41
  42 #include "qsvggraphics_p.h"
  43
  44 #ifndef QT_NO_SVG
  45
  46 #include "qsvgfont_p.h"
  47
  48 #include "qpainter.h"
  49 #include "qtextdocument.h"
  50 #include "qabstracttextdocumentlayout.h"
  51 #include "qtextcursor.h"
  52 #include "qdebug.h"
  53
  54 #include <math.h>
  55 #include <limits.h>
  56
  57 QT_BEGIN_NAMESPACE
  58
  59 #define QT_SVG_DRAW_SHAPE(command)                  \
  60     applyStyle(p, states);                          \
  61     qreal oldOpacity = p->opacity();                \
  62     QBrush oldBrush = p->brush();                   \
  63     QPen oldPen = p->pen();                         \
  64     p->setPen(Qt::NoPen);                           \
  65     p->setOpacity(oldOpacity * states.fillOpacity); \
  66     command;                                        \
  67     p->setOpacity(oldOpacity);                      \
  68     p->setPen(oldPen);                              \
  69     p->setBrush(Qt::NoBrush);                       \
  70     command;                                        \
  71     p->setBrush(oldBrush);                          \
  72     revertStyle(p, states);
  73
  74
  75 void QSvgAnimation::draw(QPainter *, QSvgExtraStates &)
  76 {
  77     qWarning("<animation> no implemented");
  78 }
  79
  80 static inline QRectF boundsOnStroke(const QPainterPath &path, qreal width)
  81 {
  82     QPainterPathStroker stroker;
  83     stroker.setWidth(width);
  84     QPainterPath stroke = stroker.createStroke(path);
  85     return stroke.boundingRect();
  86 }
  87
  88 QSvgCircle::QSvgCircle(QSvgNode *parent, const QRectF &rect)
  89     : QSvgNode(parent), m_bounds(rect)
  90 {
  91 }
  92
  93
  94 QRectF QSvgCircle::bounds() const
  95 {
  96     qreal sw = strokeWidth();
  97     if (qFuzzyCompare(sw + 1, 1))
  98         return m_bounds;
  99     else {
 100         QPainterPath path;
 101         path.addRect(m_bounds);
 102         return boundsOnStroke(path, sw);
 103     }
 104 }
 105
 106 void QSvgCircle::draw(QPainter *p, QSvgExtraStates &states)
 107 {
 108     QT_SVG_DRAW_SHAPE(p->drawEllipse(m_bounds));
 109 }
 110
 111 QSvgArc::QSvgArc(QSvgNode *parent, const QPainterPath &path)
 112     : QSvgNode(parent), cubic(path)
 113 {
 114     m_cachedBounds = path.boundingRect();
 115 }
 116
 117 void QSvgArc::draw(QPainter *p, QSvgExtraStates &states)
 118 {
 119     applyStyle(p, states);
 120     p->drawPath(cubic);
 121     revertStyle(p, states);
 122 }
 123
 124 QSvgEllipse::QSvgEllipse(QSvgNode *parent, const QRectF &rect)
 125     : QSvgNode(parent), m_bounds(rect)
 126 {
 127 }
 128
 129 QRectF QSvgEllipse::bounds() const
 130 {
 131     qreal sw = strokeWidth();
 132     if (qFuzzyCompare(sw + 1, 1))
 133         return m_bounds;
 134     else {
 135         QPainterPath path;
 136         path.addEllipse(m_bounds);
 137         return boundsOnStroke(path, sw);
 138     }
 139 }
 140
 141 void QSvgEllipse::draw(QPainter *p, QSvgExtraStates &states)
 142 {
 143     QT_SVG_DRAW_SHAPE(p->drawEllipse(m_bounds));
 144 }
 145
 146 QSvgImage::QSvgImage(QSvgNode *parent, const QImage &image,
 147                      const QRect &bounds)
 148     : QSvgNode(parent), m_image(image),
 149       m_bounds(bounds)
 150 {
 151     if (m_bounds.width() == 0)
 152         m_bounds.setWidth(m_image.width());
 153     if (m_bounds.height() == 0)
 154         m_bounds.setHeight(m_image.height());
 155 }
 156
 157 void QSvgImage::draw(QPainter *p, QSvgExtraStates &states)
 158 {
 159     applyStyle(p, states);
 160     p->drawImage(m_bounds, m_image);
 161     revertStyle(p, states);
 162 }
 163
 164
 165 QSvgLine::QSvgLine(QSvgNode *parent, const QLineF &line)
 166     : QSvgNode(parent), m_bounds(line)
 167 {
 168 }
 169
 170
 171 void QSvgLine::draw(QPainter *p, QSvgExtraStates &states)
 172 {
 173     applyStyle(p, states);
 174     p->drawLine(m_bounds);
 175     revertStyle(p, states);
 176 }
 177
 178 QSvgPath::QSvgPath(QSvgNode *parent, const QPainterPath &qpath)
 179     : QSvgNode(parent), m_path(qpath)
 180 {
 181     //m_cachedBounds = m_path.controlPointRect();
 182     m_cachedBounds = m_path.boundingRect();
 183 }
 184
 185 void QSvgPath::draw(QPainter *p, QSvgExtraStates &states)
 186 {
 187     QT_SVG_DRAW_SHAPE(p->drawPath(m_path));
 188 }
 189
 190 QRectF QSvgPath::bounds() const
 191 {
 192     qreal sw = strokeWidth();
 193     if (qFuzzyCompare(sw + 1, 1))
 194         return m_cachedBounds;
 195     else {
 196         return boundsOnStroke(m_path, sw);
 197     }
 198 }
 199
 200 QSvgPolygon::QSvgPolygon(QSvgNode *parent, const QPolygonF &poly)
 201     : QSvgNode(parent), m_poly(poly)
 202 {
 203
 204 }
 205
 206 QRectF QSvgPolygon::bounds() const
 207 {
 208     qreal sw = strokeWidth();
 209     if (qFuzzyCompare(sw + 1, 1))
 210         return m_poly.boundingRect();
 211     else {
 212         QPainterPath path;
 213         path.addPolygon(m_poly);
 214         return boundsOnStroke(path, sw);
 215     }
 216 }
 217
 218 void QSvgPolygon::draw(QPainter *p, QSvgExtraStates &states)
 219 {
 220     QT_SVG_DRAW_SHAPE(p->drawPolygon(m_poly));
 221 }
 222
 223
 224 QSvgPolyline::QSvgPolyline(QSvgNode *parent, const QPolygonF &poly)
 225     : QSvgNode(parent), m_poly(poly)
 226 {
 227
 228 }
 229
 230 void QSvgPolyline::draw(QPainter *p, QSvgExtraStates &states)
 231 {
 232     applyStyle(p, states);
 233     if (p->brush().style() != Qt::NoBrush) {
 234         QPen save = p->pen();
 235         p->setPen(QPen(Qt::NoPen));
 236         p->drawPolygon(m_poly);
 237         p->setPen(save);
 238     }
 239     p->drawPolyline(m_poly);
 240     revertStyle(p, states);
 241 }
 242
 243 QSvgRect::QSvgRect(QSvgNode *node, const QRectF &rect, int rx, int ry)
 244     : QSvgNode(node),
 245       m_rect(rect), m_rx(rx), m_ry(ry)
 246 {
 247 }
 248
 249 QRectF QSvgRect::bounds() const
 250 {
 251     qreal sw = strokeWidth();
 252     if (qFuzzyCompare(sw + 1, 1))
 253         return m_rect;
 254     else {
 255         QPainterPath path;
 256         path.addRect(m_rect);
 257         return boundsOnStroke(path, sw);
 258     }
 259 }
 260
 261 void QSvgRect::draw(QPainter *p, QSvgExtraStates &states)
 262 {
 263     if (m_rx || m_ry) {
 264         QT_SVG_DRAW_SHAPE(p->drawRoundedRect(m_rect, m_rx, m_ry, Qt::RelativeSize));
 265     } else {
 266         QT_SVG_DRAW_SHAPE(p->drawRect(m_rect));
 267     }
 268 }
 269
 270 QSvgText::QSvgText(QSvgNode *parent, const QPointF &coord)
 271     : QSvgNode(parent)
 272     , m_coord(coord)
 273     , m_textAlignment(Qt::AlignLeft)
 274     , m_scale(1)
 275     , m_appendSpace(false)
 276     , m_type(TEXT)
 277     , m_size(0, 0)
 278 {
 279     m_paragraphs.push_back(QString());
 280     m_formatRanges.push_back(QList<QTextLayout::FormatRange>());
 281 }
 282
 283 QSvgText::~QSvgText()
 284 {
 285 }
 286
 287 void QSvgText::setTextArea(const QSizeF &size)
 288 {
 289     m_size = size;
 290     m_type = TEXTAREA;
 291 }
 292
 293 //QRectF QSvgText::bounds() const {}
 294
 295 void QSvgText::draw(QPainter *p, QSvgExtraStates &states)
 296 {
 297     applyStyle(p, states);
 298
 299     QSvgFontStyle *fontStyle = static_cast<QSvgFontStyle*>(
 300         styleProperty(QSvgStyleProperty::FONT));
 301     if (fontStyle && fontStyle->svgFont()) {
 302         // SVG fonts not fully supported...
 303         QString text = m_paragraphs.front();
 304         for (int i = 1; i < m_paragraphs.size(); ++i) {
 305             text.append(QLatin1Char('\n'));
 306             text.append(m_paragraphs[i]);
 307         }
 308         fontStyle->svgFont()->draw(p, m_coord, text, fontStyle->pointSize(), m_textAlignment);
 309         revertStyle(p, states);
 310         return;
 311     }
 312
 313     // Scale the font to its correct size.
 314     QTransform oldTransform = p->worldTransform();
 315     p->scale(1 / m_scale, 1 / m_scale);
 316
 317     qreal y = 0;
 318     bool initial = true;
 319     qreal px = m_coord.x() * m_scale;
 320     qreal py = m_coord.y() * m_scale;
 321     QSizeF scaledSize = m_size * m_scale;
 322
 323     if (m_type == TEXTAREA) {
 324         if (m_textAlignment == Qt::AlignHCenter)
 325             px += scaledSize.width() / 2;
 326         else if (m_textAlignment == Qt::AlignRight)
 327             px += scaledSize.width();
 328     }
 329
 330     QRectF bounds;
 331     if (m_size.height() != 0)
 332         bounds = QRectF(0, 0, 1, scaledSize.height());
 333
 334     for (int i = 0; i < m_paragraphs.size(); ++i) {
 335         QTextLayout tl(m_paragraphs[i]);
 336         QTextOption op = tl.textOption();
 337         op.setWrapMode(QTextOption::WrapAtWordBoundaryOrAnywhere);
 338         tl.setTextOption(op);
 339         tl.setAdditionalFormats(m_formatRanges[i]);
 340         tl.beginLayout();
 341         forever {
 342             QTextLine line = tl.createLine();
 343             if (!line.isValid())
 344                 break;
 345
 346             if (m_size.width() != 0)
 347                 line.setLineWidth(scaledSize.width());
 348         }
 349         tl.endLayout();
 350
 351         bool endOfBoundsReached = false;
 352         for (int i = 0; i < tl.lineCount(); ++i) {
 353             QTextLine line = tl.lineAt(i);
 354
 355             qreal x = 0;
 356             if (m_textAlignment == Qt::AlignHCenter)
 357                 x -= line.naturalTextWidth() / 2;
 358             else if (m_textAlignment == Qt::AlignRight)
 359                 x -= line.naturalTextWidth();
 360
 361             if (initial && m_type == TEXT)
 362                 y -= line.ascent();
 363             initial = false;
 364
 365             line.setPosition(QPointF(x, y));
 366             if ((m_size.width() != 0 && line.naturalTextWidth() > scaledSize.width())
 367                 || (m_size.height() != 0 && y + line.height() > scaledSize.height())) {
 368                 bounds.setHeight(y);
 369                 endOfBoundsReached = true;
 370                 break;
 371             }
 372
 373             y += 1.1 * line.height();
 374         }
 375         tl.draw(p, QPointF(px, py), QVector<QTextLayout::FormatRange>(), bounds);
 376
 377         if (endOfBoundsReached)
 378             break;
 379     }
 380
 381     p->setWorldTransform(oldTransform, false);
 382     revertStyle(p, states);
 383 }
 384
 385 void QSvgText::insertText(const QString &text, WhitespaceMode mode)
 386 {
 387     bool isTSpan = (m_formats.count() == 2);
 388     QString newText(text);
 389     newText.replace(QLatin1Char('\t'), QLatin1Char(' '));
 390     newText.replace(QLatin1Char('\n'), QLatin1Char(' '));
 391
 392     bool prependSpace = !m_appendSpace && !isTSpan && (mode == Default) && !m_paragraphs.back().isEmpty() && newText.startsWith(QLatin1Char(' '));
 393     if (m_appendSpace || prependSpace)
 394         m_paragraphs.back().append(QLatin1Char(' '));
 395
 396     bool appendSpaceNext = (!isTSpan && (mode == Default) && newText.endsWith(QLatin1Char(' ')));
 397
 398     if (mode == Default) {
 399         newText = newText.simplified();
 400         if (newText.isEmpty())
 401             appendSpaceNext = false;
 402     }
 403
 404     if (!m_formats.isEmpty()) {
 405         QTextLayout::FormatRange range;
 406         range.start = m_paragraphs.back().length();
 407         range.length = newText.length();
 408         range.format = m_formats.top();
 409         if (m_appendSpace) {
 410             Q_ASSERT(!m_formatRanges.back().isEmpty());
 411             ++m_formatRanges.back().back().length;
 412         } else if (prependSpace) {
 413             --range.start;
 414             ++range.length;
 415         }
 416         m_formatRanges.back().append(range);
 417     }
 418
 419     m_appendSpace = appendSpaceNext;
 420     m_paragraphs.back() += newText;
 421 }
 422
 423 void QSvgText::insertFormat(const QTextCharFormat &format)
 424 {
 425     QTextCharFormat mergedFormat = format;
 426     if (!m_formats.isEmpty()) {
 427         mergedFormat = m_formats.top();
 428         mergedFormat.merge(format);
 429     }
 430     m_formats.push(mergedFormat);
 431 }
 432
 433 void QSvgText::insertLineBreak()
 434 {
 435     if (m_type == TEXTAREA) {
 436         if (m_paragraphs.back().isEmpty())
 437             insertText(QLatin1String(" "), Preserve);
 438         m_appendSpace = false;
 439         m_paragraphs.push_back(QString());
 440         m_formatRanges.push_back(QList<QTextLayout::FormatRange>());
 441     }
 442 }
 443
 444 void QSvgText::popFormat()
 445 {
 446     if (m_formats.count() > 1)
 447         m_formats.pop();
 448 }
 449
 450 qreal QSvgText::scale() const
 451 {
 452     return m_scale;
 453 }
 454
 455 void QSvgText::setScale(qreal scale)
 456 {
 457     m_scale = scale;
 458 }
 459
 460 const QTextCharFormat &QSvgText::topFormat() const
 461 {
 462     return m_formats.top();
 463 }
 464
 465 void QSvgText::setTextAlignment(const Qt::Alignment &alignment)
 466 {
 467     m_textAlignment = alignment;
 468 }
 469
 470 QSvgUse::QSvgUse(const QPointF &start, QSvgNode *parent, QSvgNode *node)
 471     : QSvgNode(parent), m_link(node), m_start(start)
 472 {
 473
 474 }
 475
 476 void QSvgUse::draw(QPainter *p, QSvgExtraStates &states)
 477 {
 478     applyStyle(p, states);
 479
 480     if (!m_start.isNull()) {
 481         p->translate(m_start);
 482     }
 483     m_link->draw(p, states);
 484     if (!m_start.isNull()) {
 485         p->translate(-m_start);
 486     }
 487
 488     revertStyle(p, states);
 489 }
 490
 491 void QSvgVideo::draw(QPainter *p, QSvgExtraStates &states)
 492 {
 493     applyStyle(p, states);
 494
 495     revertStyle(p, states);
 496 }
 497
 498 QSvgNode::Type QSvgAnimation::type() const
 499 {
 500     return ANIMATION;
 501 }
 502
 503 QSvgNode::Type QSvgArc::type() const
 504 {
 505     return ARC;
 506 }
 507
 508 QSvgNode::Type QSvgCircle::type() const
 509 {
 510     return CIRCLE;
 511 }
 512
 513 QSvgNode::Type QSvgEllipse::type() const
 514 {
 515     return ELLIPSE;
 516 }
 517
 518 QSvgNode::Type QSvgImage::type() const
 519 {
 520     return IMAGE;
 521 }
 522
 523 QSvgNode::Type QSvgLine::type() const
 524 {
 525     return LINE;
 526 }
 527
 528 QSvgNode::Type QSvgPath::type() const
 529 {
 530     return PATH;
 531 }
 532
 533 QSvgNode::Type QSvgPolygon::type() const
 534 {
 535     return POLYGON;
 536 }
 537
 538 QSvgNode::Type QSvgPolyline::type() const
 539 {
 540     return POLYLINE;
 541 }
 542
 543 QSvgNode::Type QSvgRect::type() const
 544 {
 545     return RECT;
 546 }
 547
 548 QSvgNode::Type QSvgText::type() const
 549 {
 550     return m_type;
 551 }
 552
 553 QSvgNode::Type QSvgUse::type() const
 554 {
 555     return USE;
 556 }
 557
 558 QSvgNode::Type QSvgVideo::type() const
 559 {
 560     return VIDEO;
 561 }
 562
 563 QRectF QSvgUse::bounds() const
 564 {
 565     if (m_link && m_bounds.isEmpty())  {
 566         m_bounds = m_link->bounds();
 567         m_bounds = QRectF(m_bounds.x()+m_start.x(),
 568                           m_bounds.y()+m_start.y(),
 569                           m_bounds.width(),
 570                           m_bounds.height());
 571
 572         return m_bounds;
 573     }
 574     return m_bounds;
 575 }
 576
 577 QRectF QSvgUse::transformedBounds(const QTransform &transform) const
 578 {
 579     QRectF bounds;
 580     QTransform t = transform;
 581
 582     if (m_link)  {
 583         QSvgTransformStyle *transStyle = m_style.transform;
 584         if (transStyle) {
 585             t = transStyle->qtransform() * t;
 586         }
 587         t.translate(m_start.x(), m_start.y());
 588
 589         bounds = m_link->transformedBounds(t);
 590
 591         return bounds;
 592     }
 593     return bounds;
 594 }
 595
 596 QRectF QSvgPolyline::bounds() const
 597 {
 598     qreal sw = strokeWidth();
 599     if (qFuzzyCompare(sw + 1, 1))
 600         return m_poly.boundingRect();
 601     else {
 602         QPainterPath path;
 603         path.addPolygon(m_poly);
 604         return boundsOnStroke(path, sw);
 605     }
 606 }
 607
 608 QRectF QSvgArc::bounds() const
 609 {
 610     qreal sw = strokeWidth();
 611     if (qFuzzyCompare(sw + 1, 1))
 612         return m_cachedBounds;
 613     else {
 614         return boundsOnStroke(cubic, sw);
 615     }
 616 }
 617
 618 QRectF QSvgImage::bounds() const
 619 {
 620     return m_bounds;
 621 }
 622
 623 QRectF QSvgLine::bounds() const
 624 {
 625     qreal sw = strokeWidth();
 626     if (qFuzzyCompare(sw + 1, 1)) {
 627         qreal minX = qMin(m_bounds.x1(), m_bounds.x2());
 628         qreal minY = qMin(m_bounds.y1(), m_bounds.y2());
 629         qreal maxX = qMax(m_bounds.x1(), m_bounds.x2());
 630         qreal maxY = qMax(m_bounds.y1(), m_bounds.y2());
 631         return QRectF(minX, minY, maxX-minX, maxY-minY);
 632     } else {
 633         QPainterPath path;
 634         path.moveTo(m_bounds.x1(), m_bounds.y1());
 635         path.lineTo(m_bounds.x2(), m_bounds.y2());
 636         return boundsOnStroke(path, sw);
 637     }
 638 }
 639
 640 QT_END_NAMESPACE
 641
 642 #endif // QT_NO_SVG