qpicture.cpp

qt-x11-opensource-src-4.1.4.tar.gz源码

{
    Q_D(QPicture);
#if defined(QT_DEBUG)
    int                strm_pos;
#endif
    quint8     c;                      // command id
    quint8     tiny_len;               // 8-bit length descriptor
    qint32     len;                    // 32-bit length descriptor
    qint16     i_16, i1_16, i2_16;     // parameters...
    qint8      i_8;
    quint32    ul;
    QByteArray  str1;
    QString     str;
    QPointF     p, p1, p2;
    QRectF      r;
    QPolygonF   a;
    QPolygon    pa;
    QColor      color;
    QFont       font;
    QPen        pen;
    QBrush      brush;
    QRegion     rgn;
    QMatrix     matrix;

    QMatrix worldMatrix = painter->matrix();
    QMatrix oldWorldMatrix = worldMatrix;
    worldMatrix.scale(qreal(painter->device()->logicalDpiX()) / qreal(qt_defaultDpi()),
                      qreal(painter->device()->logicalDpiY()) / qreal(qt_defaultDpi()));
    painter->setMatrix(worldMatrix);

    while (nrecords-- && !s.atEnd()) {
        s >> c;                 // read cmd
        s >> tiny_len;          // read param length
        if (tiny_len == 255)    // longer than 254 bytes
            s >> len;
        else
            len = tiny_len;
#if defined(QT_DEBUG)
        strm_pos = s.device()->pos();
#endif
        switch (c) {            // exec cmd
        case QPicturePrivate::PdcNOP:
            break;
        case QPicturePrivate::PdcDrawPoint:
            s >> p;
            painter->drawPoint(p);
            break;
        case QPicturePrivate::PdcDrawPoints:
// ## implement me in the picture paint engine
//                 s >> a >> i1_32 >> i2_32;
//                 painter->drawPoints(a.mid(i1_32, i2_32));
            break;
        case QPicturePrivate::PdcDrawPath: {
            QPainterPath path;
            s >> path;
            painter->drawPath(path);
            break;
        }
        case QPicturePrivate::PdcDrawLine:
            s >> p1 >> p2;
            painter->drawLine(p1, p2);
            break;
        case QPicturePrivate::PdcDrawRect:
            s >> r;
            painter->drawRect(r);
            break;
        case QPicturePrivate::PdcDrawRoundRect:
            s >> r >> i1_16 >> i2_16;
            painter->drawRoundRect(r, i1_16, i2_16);
            break;
        case QPicturePrivate::PdcDrawEllipse:
            s >> r;
            painter->drawEllipse(r);
            break;
        case QPicturePrivate::PdcDrawArc:
            s >> r >> i1_16 >> i2_16;
            painter->drawArc(r, i1_16, i2_16);
            break;
        case QPicturePrivate::PdcDrawPie:
            s >> r >> i1_16 >> i2_16;
            painter->drawPie(r, i1_16, i2_16);
            break;
        case QPicturePrivate::PdcDrawChord:
            s >> r >> i1_16 >> i2_16;
            painter->drawChord(r, i1_16, i2_16);
            break;
        case QPicturePrivate::PdcDrawLineSegments:
            s >> pa;
            painter->drawLines(pa);
            pa.clear();
            break;
        case QPicturePrivate::PdcDrawPolyline:
            s >> a;
            painter->drawPolyline(a);
            a.clear();
            break;
        case QPicturePrivate::PdcDrawPolygon:
            s >> a >> i_8;
            painter->drawPolygon(a, i_8 ? Qt::WindingFill : Qt::OddEvenFill);
            a.clear();
            break;
        case QPicturePrivate::PdcDrawCubicBezier: {
            s >> a;
            QPainterPath path;
            Q_ASSERT(a.size() == 4);
            path.moveTo(a.at(0));
            path.cubicTo(a.at(1), a.at(2), a.at(3));
            painter->strokePath(path, painter->pen());
            a.clear();
        }
            break;
        case QPicturePrivate::PdcDrawText:
            s >> p >> str1;
            painter->drawText(p, str1);
            break;
        case QPicturePrivate::PdcDrawTextFormatted:
            s >> r >> i_16 >> str1;
            painter->drawText(r, i_16, str1);
            break;
        case QPicturePrivate::PdcDrawText2:
            s >> p >> str;
            painter->drawText(p, str);
            break;
        case QPicturePrivate::PdcDrawText2Formatted:
            s >> r >> i_16 >> str;
            painter->drawText(r, i_16, str);
            break;
        case QPicturePrivate::PdcDrawTextItem: {
            Qt::LayoutDirection oldDir = painter->layoutDirection();

            s >> p >> str >> font >> ul;

            if (ul & QTextItem::RightToLeft)
                painter->setLayoutDirection(Qt::RightToLeft);
            else
                painter->setLayoutDirection(Qt::LeftToRight);

            font = QFont(font, painter->device());

            QMatrix matrix = painter->matrix();
            painter->setMatrix(oldWorldMatrix);

            p.rx() *= painter->device()->logicalDpiX() / double(qt_defaultDpi());
            p.ry() *= painter->device()->logicalDpiY() / double(qt_defaultDpi());

            qt_format_text(font, QRectF(p, QSizeF(1, 1)), Qt::TextSingleLine | Qt::TextDontClip, str, /*brect=*/0, /*tabstops=*/0, /*...*/0, /*tabarraylen=*/0, painter);

            painter->setLayoutDirection(oldDir);
            painter->setMatrix(matrix);
            break;
        }
        case QPicturePrivate::PdcDrawPixmap: {
            QPixmap pixmap;
            if (d->formatMajor < 4) {
                s >> p >> pixmap;
                painter->drawPixmap(p, pixmap);
            } else {
                QRectF sr;
                s >> r >> pixmap >> sr;
                painter->drawPixmap(r, pixmap, sr);
            }
        }
            break;
        case QPicturePrivate::PdcDrawTiledPixmap: {
            QPixmap pixmap;
            s >> r >> pixmap >> p;
            painter->drawTiledPixmap(r, pixmap, p);
        }
            break;
        case QPicturePrivate::PdcDrawImage: {
            QImage image;
            if (d->formatMajor < 4) {
                s >> p >> image;
                painter->drawPixmap(p, QPixmap::fromImage(image));
            } else {
                s >> r >> image;
                painter->drawPixmap(r, QPixmap::fromImage(image), QRectF(0, 0, r.width(), r.height()));
            }
        }
            break;
        case QPicturePrivate::PdcBegin:
            s >> ul;                        // number of records
            if (!exec(painter, s, ul))
                return false;
            break;
        case QPicturePrivate::PdcEnd:
            if (nrecords == 0)
                return true;
            break;
        case QPicturePrivate::PdcSave:
            painter->save();
            break;
        case QPicturePrivate::PdcRestore:
            painter->restore();
            break;
        case QPicturePrivate::PdcSetBkColor:
            s >> color;
            painter->setBackground(color);
            break;
        case QPicturePrivate::PdcSetBkMode:
            s >> i_8;
            painter->setBackgroundMode((Qt::BGMode)i_8);
            break;
        case QPicturePrivate::PdcSetROP: // NOP
            break;
        case QPicturePrivate::PdcSetBrushOrigin:
            s >> p;
            painter->setBrushOrigin(p);
            break;
        case QPicturePrivate::PdcSetFont:
            s >> font;
            painter->setFont(font);
            break;
        case QPicturePrivate::PdcSetPen:
            s >> pen;
            painter->setPen(pen);
            break;
        case QPicturePrivate::PdcSetBrush:
            s >> brush;
            painter->setBrush(brush);
            break;
// #ifdef Q_Q3PAINTER
//         case QPicturePrivate::PdcSetTabStops:
//                 s >> i_16;
//                 painter->setTabStops(i_16);
//                 break;
//             case QPicturePrivate::PdcSetTabArray:
//                 s >> i_16;
//                 if (i_16 == 0) {
//                     painter->setTabArray(0);
//                 } else {
//                     int *ta = new int[i_16];
//                     for (int i=0; i<i_16; i++) {
//                         s >> i1_16;
//                         ta[i] = i1_16;
//                     }
//                     painter->setTabArray(ta);
//                     delete [] ta;
//                 }
//                 break;
// #endif
        case QPicturePrivate::PdcSetVXform:
            s >> i_8;
            painter->setViewTransformEnabled(i_8);
            break;
        case QPicturePrivate::PdcSetWindow:
            s >> r;
            painter->setWindow(r.toRect());
            break;
        case QPicturePrivate::PdcSetViewport:
            s >> r;
            painter->setViewport(r.toRect());
            break;
        case QPicturePrivate::PdcSetWXform:
            s >> i_8;
            painter->setMatrixEnabled(i_8);
            break;
        case QPicturePrivate::PdcSetWMatrix:
            s >> matrix >> i_8;
            matrix.setMatrix(matrix.m11(), matrix.m12(), matrix.m21(), matrix.m22(),
                             matrix.dx() * painter->device()->logicalDpiX() / double(qt_defaultDpi()),
                             matrix.dy() * painter->device()->logicalDpiY() / double(qt_defaultDpi()));
            // i_8 is always false due to updateXForm() in qpaintengine_pic.cpp
            painter->setMatrix(worldMatrix * matrix, false);
            oldWorldMatrix *= matrix;
            break;
// #ifdef Q_Q3PAINTER
//             case QPicturePrivate::PdcSaveWMatrix:
//                 painter->saveWorldMatrix();
//                 break;
//             case QPicturePrivate::PdcRestoreWMatrix:
//                 painter->restoreWorldMatrix();
//                 break;
// #endif
        case QPicturePrivate::PdcSetClip:
            s >> i_8;
            painter->setClipping(i_8);
            break;
        case QPicturePrivate::PdcSetClipRegion:
            s >> rgn >> i_8;
            painter->setClipRegion(rgn);
            break;
        case QPicturePrivate::PdcSetClipPath:
            {
                QPainterPath path;
                s >> path >> i_8;
                painter->setClipPath(path, Qt::ClipOperation(i_8));
                break;
            }
        case QPicturePrivate::PdcSetRenderHint:
            s >> ul;
            painter->setRenderHint(QPainter::Antialiasing,
                                   bool(ul & QPainter::Antialiasing));
            painter->setRenderHint(QPainter::SmoothPixmapTransform,
                                   bool(ul & QPainter::SmoothPixmapTransform));
            break;
        default:
            qWarning("QPicture::play: Invalid command %d", c);
            if (len)                        // skip unknown command
                s.device()->seek(s.device()->pos()+len);
        }
#if defined(QT_DEBUG)
        //qDebug("device->at(): %i, strm_pos: %i len: %i", s.device()->at(), strm_pos, len);
        Q_ASSERT(qint32(s.device()->pos() - strm_pos) == len);
#endif
    }
    return false;
}

/*!
    Internal implementation of the virtual QPaintDevice::metric()
    function.

    A picture has the following hard-coded values: numcolors=16777216
    and depth=24.

    \a m is the metric to get.
*/

int QPicture::metric(PaintDeviceMetric m) const
{
    int val;
    QRect brect = boundingRect();
    switch (m) {
        case PdmWidth:
            val = brect.width();
            break;
        case PdmHeight:
            val = brect.height();
            break;
        case PdmWidthMM:
            val = int(25.4/qt_defaultDpi()*brect.width());
            break;
        case PdmHeightMM:
            val = int(25.4/qt_defaultDpi()*brect.height());
            break;
        case PdmDpiX:
        case PdmPhysicalDpiX:
            val = qt_defaultDpi();
            break;
        case PdmDpiY:
        case PdmPhysicalDpiY:
            val = qt_defaultDpi();
            break;
        case PdmNumColors:
            val = 16777216;
            break;
        case PdmDepth:
            val = 24;
            break;
        default:
            val = 0;
            qWarning("QPicture::metric: Invalid metric command");
    }
    return val;
}

/*!
    \fn void QPicture::detach()
    \internal
    Detaches from shared picture data and makes sure that this picture
    is the only one referring to the data.

    If multiple pictures share common data, this picture makes a copy
    of the data and detaches itself from the sharing mechanism.
    Nothing is done if there is just a single reference.
*/

/*! \fn bool QPicture::isDetached() const
\internal
*/
void QPicture::detach_helper()
{
    Q_D(QPicture);
    QPicturePrivate *x = new QPicturePrivate;
    int pictsize = size();
    x->pictb.setData(data(), pictsize);
    if (d->pictb.isOpen()) {
        x->pictb.open(d->pictb.openMode());
        x->pictb.seek(d->pictb.pos());
    }
    x->trecs = d->trecs;
    x->formatOk = d->formatOk;
    x->formatMinor = d->formatMinor;
    x->brect = d->brect;
    x->override_rect = d->override_rect;
    x = qAtomicSetPtr(&d_ptr, x);
    if (!x->ref.deref())
        delete x;
}

/*!
    Assigns picture \a p to this picture and returns a reference to
    this picture.
*/
QPicture& QPicture::operator=(const QPicture &p)
{
    qAtomicAssign<QPicturePrivate>(d_ptr, p.d_ptr);
    return *this;
}

/*!
  \internal

  Sets formatOk to false and resets the format version numbers to default
*/

void QPicturePrivate::resetFormat()
{
    formatOk = false;
    formatMajor = mfhdr_maj;
    formatMinor = mfhdr_min;
}


/*!
  \internal

  Checks data integrity and format version number. Set formatOk to
  true on success, to false otherwise. Returns the resulting formatOk
  value.
*/
bool QPicturePrivate::checkFormat()
{
    resetFormat();

    // can't check anything in an empty buffer
    if (pictb.size() == 0 || pictb.isOpen())
        return false;

    pictb.open(QIODevice::ReadOnly);                        // open buffer device
    QDataStream s;
    s.setDevice(&pictb);                        // attach data stream to buffer

    char mf_id[4];                                // picture header tag
    s.readRawData(mf_id, 4);                        // read actual tag
    if (memcmp(mf_id, qt_mfhdr_tag, 4) != 0) {         // wrong header id
        qWarning("QPicturePaintEngine::checkFormat: Incorrect header");
        pictb.close();