270     if (painter && !painter->isActive())

   272     processCommands(painter, frameStartIndex(frame), frameEndIndex(frame));

   271         return;

   273 

   274 #ifdef QPAINTBUFFER_DEBUG_DRAW

   275     qDebug() << "QPaintBuffer::draw() -------------------------------- DONE!";

   276 #endif

   277 }

   278 

   279 int QPaintBuffer::frameStartIndex(int frame) const

   280 {

   281     return (frame == 0) ? 0 : d_ptr->frames.at(frame - 1);

   282 }

   283 

   284 int QPaintBuffer::frameEndIndex(int frame) const

   285 {

   286     return (frame == d_ptr->frames.size()) ? d_ptr->commands.size() : d_ptr->frames.at(frame);

   287 }

   288 

   289 int QPaintBuffer::processCommands(QPainter *painter, int begin, int end) const

   290 {

   291     if (!painter || !painter->isActive())

   292         return 0;

   277         player.draw(*this, painter, frame);

   298         player.processCommands(*this, painter, begin, end);

   280         player.draw(*this, painter, frame);

   301         player.processCommands(*this, painter, begin, end);

   281     }

   302     }

   282 

   303 

   283 #ifdef QPAINTBUFFER_DEBUG_DRAW

   304     int depth = 0;

   284     qDebug() << "QPaintBuffer::draw() -------------------------------- DONE!";

   305     for (int i = begin; i < end; ++i) {

   285 #endif

   306         const QPaintBufferCommand &cmd = d_ptr->commands.at(i);

   286 }

   307         if (cmd.id == QPaintBufferPrivate::Cmd_Save)

   287 

   308             ++depth;

   309         else if (cmd.id == QPaintBufferPrivate::Cmd_Restore)

   310             --depth;

   311     }

   312     return depth;

   313 }

   314 

   315 #ifndef QT_NO_DEBUG_STREAM

   316 QString QPaintBuffer::commandDescription(int command) const

   317 {

   318     QString desc;

   319     QDebug debug(&desc);

   320 

   321     const QPaintBufferCommand &cmd = d_ptr->commands.at(command);

   322 

   323     switch (cmd.id) {

   324     case QPaintBufferPrivate::Cmd_Save: {

   325         debug << "Cmd_Save";

   326         break; }

   327 

   328     case QPaintBufferPrivate::Cmd_Restore: {

   329         debug << "Cmd_Restore";

   330         break; }

   331 

   332     case QPaintBufferPrivate::Cmd_SetBrush: {

   333         QBrush brush = qVariantValue<QBrush>(d_ptr->variants.at(cmd.offset));

   334         debug << "Cmd_SetBrush: " << brush;

   335         break; }

   336 

   337     case QPaintBufferPrivate::Cmd_SetBrushOrigin: {

   338         debug << "Cmd_SetBrushOrigin: " << d_ptr->variants.at(cmd.offset).toPointF();

   339         break; }

   340 

   341     case QPaintBufferPrivate::Cmd_SetCompositionMode: {

   342         QPainter::CompositionMode mode = (QPainter::CompositionMode) cmd.extra;

   343         debug << "ExCmd_SetCompositionMode, mode: " << mode;

   344         break; }

   345 

   346     case QPaintBufferPrivate::Cmd_SetOpacity: {

   347         debug << "ExCmd_SetOpacity: " << d_ptr->variants.at(cmd.offset).toDouble();

   348         break; }

   349 

   350     case QPaintBufferPrivate::Cmd_DrawVectorPath: {

   351         debug << "ExCmd_DrawVectorPath: size: " << cmd.size

   352 //                 << ", hints:" << d->ints[cmd.offset2+cmd.size]

   353                  << "pts/elms:" << cmd.offset << cmd.offset2;

   354         break; }

   355 

   356     case QPaintBufferPrivate::Cmd_StrokeVectorPath: {

   357         QPen pen = qVariantValue<QPen>(d_ptr->variants.at(cmd.extra));

   358         debug << "ExCmd_StrokeVectorPath: size: " << cmd.size

   359 //                 << ", hints:" << d->ints[cmd.offset2+cmd.size]

   360                  << "pts/elms:" << cmd.offset << cmd.offset2 << pen;

   361         break; }

   362 

   363     case QPaintBufferPrivate::Cmd_FillVectorPath: {

   364         QBrush brush = qVariantValue<QBrush>(d_ptr->variants.at(cmd.extra));

   365         debug << "ExCmd_FillVectorPath: size: " << cmd.size

   366 //                 << ", hints:" << d->ints[cmd.offset2+cmd.size]

   367                  << "pts/elms:" << cmd.offset << cmd.offset2 << brush;

   368         break; }

   369 

   370     case QPaintBufferPrivate::Cmd_FillRectBrush: {

   371         QBrush brush = qVariantValue<QBrush>(d_ptr->variants.at(cmd.extra));

   372         QRectF *rect = (QRectF *)(d_ptr->floats.constData() + cmd.offset);

   373         debug << "ExCmd_FillRectBrush, offset: " << cmd.offset << " rect: " << *rect << " brush: " << brush;

   374         break; }

   375 

   376     case QPaintBufferPrivate::Cmd_FillRectColor: {

   377         QColor color = qVariantValue<QColor>(d_ptr->variants.at(cmd.extra));

   378         QRectF *rect = (QRectF *)(d_ptr->floats.constData() + cmd.offset);

   379         debug << "ExCmd_FillRectBrush, offset: " << cmd.offset << " rect: " << *rect << " color: " << color;

   380         break; }

   381 

   382     case QPaintBufferPrivate::Cmd_DrawPolygonF: {

   383         debug << "ExCmd_DrawPolygonF, offset: " << cmd.offset << " size: " << cmd.size

   384                  << " mode: " << cmd.extra

   385                  << d_ptr->floats.at(cmd.offset)

   386                  << d_ptr->floats.at(cmd.offset+1);

   387         break; }

   388 

   389     case QPaintBufferPrivate::Cmd_DrawPolygonI: {

   390         debug << "ExCmd_DrawPolygonI, offset: " << cmd.offset << " size: " << cmd.size

   391                  << " mode: " << cmd.extra

   392                  << d_ptr->ints.at(cmd.offset)

   393                  << d_ptr->ints.at(cmd.offset+1);

   394         break; }

   395 

   396     case QPaintBufferPrivate::Cmd_DrawEllipseF: {

   397         debug << "ExCmd_DrawEllipseF, offset: " << cmd.offset;

   398         break; }

   399 

   400     case QPaintBufferPrivate::Cmd_DrawLineF: {

   401         debug << "ExCmd_DrawLineF, offset: " << cmd.offset << " size: " << cmd.size;

   402         break; }

   403 

   404     case QPaintBufferPrivate::Cmd_DrawLineI: {

   405         debug << "ExCmd_DrawLineI, offset: " << cmd.offset << " size: " << cmd.size;

   406         break; }

   407 

   408     case QPaintBufferPrivate::Cmd_DrawPointsF: {

   409         debug << "ExCmd_DrawPointsF, offset: " << cmd.offset << " size: " << cmd.size;

   410         break; }

   411 

   412     case QPaintBufferPrivate::Cmd_DrawPointsI: {

   413         debug << "ExCmd_DrawPointsI, offset: " << cmd.offset << " size: " << cmd.size;

   414         break; }

   415 

   416     case QPaintBufferPrivate::Cmd_DrawPolylineF: {

   417         debug << "ExCmd_DrawPolylineF, offset: " << cmd.offset << " size: " << cmd.size;

   418         break; }

   419 

   420     case QPaintBufferPrivate::Cmd_DrawPolylineI: {

   421         debug << "ExCmd_DrawPolylineI, offset: " << cmd.offset << " size: " << cmd.size;

   422         break; }

   423 

   424     case QPaintBufferPrivate::Cmd_DrawRectF: {

   425         debug << "ExCmd_DrawRectF, offset: " << cmd.offset << " size: " << cmd.size;

   426         break; }

   427 

   428     case QPaintBufferPrivate::Cmd_DrawRectI: {

   429         debug << "ExCmd_DrawRectI, offset: " << cmd.offset << " size: " << cmd.size;

   430         break; }

   431 

   432     case QPaintBufferPrivate::Cmd_SetClipEnabled: {

   433         bool clipEnabled = d_ptr->variants.at(cmd.offset).toBool();

   434         debug << "ExCmd_SetClipEnabled:" << clipEnabled;

   435         break; }

   436 

   437     case QPaintBufferPrivate::Cmd_ClipVectorPath: {

   438         QVectorPathCmd path(d_ptr, cmd);

   439         debug << "ExCmd_ClipVectorPath:" << path().elementCount();

   440         break; }

   441 

   442     case QPaintBufferPrivate::Cmd_ClipRect: {

   443         QRect rect(QPoint(d_ptr->ints.at(cmd.offset), d_ptr->ints.at(cmd.offset + 1)),

   444                    QPoint(d_ptr->ints.at(cmd.offset + 2), d_ptr->ints.at(cmd.offset + 3)));

   445         debug << "ExCmd_ClipRect:" << rect << cmd.extra;

   446         break; }

   447 

   448     case QPaintBufferPrivate::Cmd_ClipRegion: {

   449         QRegion region(d_ptr->variants.at(cmd.offset).value<QRegion>());

   450         debug << "ExCmd_ClipRegion:" << region.boundingRect() << cmd.extra;

   451         break; }

   452 

   453     case QPaintBufferPrivate::Cmd_SetPen: {

   454         QPen pen = qVariantValue<QPen>(d_ptr->variants.at(cmd.offset));

   455         debug << "Cmd_SetPen: " << pen;

   456         break; }

   457 

   458     case QPaintBufferPrivate::Cmd_SetTransform: {

   459         QTransform xform = qVariantValue<QTransform>(d_ptr->variants.at(cmd.offset));

   460         debug << "Cmd_SetTransform, offset: " << cmd.offset << xform;

   461         break; }

   462 

   463     case QPaintBufferPrivate::Cmd_SetRenderHints: {

   464         debug << "Cmd_SetRenderHints, hints: " << cmd.extra;

   465         break; }

   466 

   467     case QPaintBufferPrivate::Cmd_SetBackgroundMode: {

   468         debug << "Cmd_SetBackgroundMode: " << cmd.extra;

   469         break; }

   470 

   471     case QPaintBufferPrivate::Cmd_DrawConvexPolygonF: {

   472         debug << "Cmd_DrawConvexPolygonF, offset: " << cmd.offset << " size: " << cmd.size;

   473         break; }

   474 

   475     case QPaintBufferPrivate::Cmd_DrawConvexPolygonI: {

   476         debug << "Cmd_DrawConvexPolygonI, offset: " << cmd.offset << " size: " << cmd.size;

   477         break; }

   478 

   479     case QPaintBufferPrivate::Cmd_DrawEllipseI: {

   480         debug << "Cmd_DrawEllipseI, offset: " << cmd.offset;

   481         break; }

   482 

   483     case QPaintBufferPrivate::Cmd_DrawPixmapRect: {

   484         QPixmap pm(d_ptr->variants.at(cmd.offset).value<QPixmap>());

   485         QRectF r(d_ptr->floats.at(cmd.extra), d_ptr->floats.at(cmd.extra+1),

   486                  d_ptr->floats.at(cmd.extra+2), d_ptr->floats.at(cmd.extra+3));

   487 

   488         QRectF sr(d_ptr->floats.at(cmd.extra+4), d_ptr->floats.at(cmd.extra+5),

   489                   d_ptr->floats.at(cmd.extra+6), d_ptr->floats.at(cmd.extra+7));

   490         debug << "Cmd_DrawPixmapRect:" << r << sr << pm.size();

   491         break; }

   492 

   493     case QPaintBufferPrivate::Cmd_DrawPixmapPos: {

   494         QPixmap pm(d_ptr->variants.at(cmd.offset).value<QPixmap>());

   495         QPointF pos(d_ptr->floats.at(cmd.extra), d_ptr->floats.at(cmd.extra+1));

   496         debug << "Cmd_DrawPixmapPos:" << pos << pm.size();

   497         break; }

   498 

   499     case QPaintBufferPrivate::Cmd_DrawTiledPixmap: {

   500         QPixmap pm(d_ptr->variants.at(cmd.offset).value<QPixmap>());

   501         QRectF r(d_ptr->floats.at(cmd.extra), d_ptr->floats.at(cmd.extra+1),

   502                  d_ptr->floats.at(cmd.extra+2), d_ptr->floats.at(cmd.extra+3));

   503 

   504         QPointF offset(d_ptr->floats.at(cmd.extra+4), d_ptr->floats.at(cmd.extra+5));

   505         debug << "Cmd_DrawTiledPixmap:" << r << offset << pm.size();

   506         break; }

   507 

   508     case QPaintBufferPrivate::Cmd_DrawImageRect: {

   509         QImage image(d_ptr->variants.at(cmd.offset).value<QImage>());

   510         QRectF r(d_ptr->floats.at(cmd.extra), d_ptr->floats.at(cmd.extra+1),

   511                  d_ptr->floats.at(cmd.extra+2), d_ptr->floats.at(cmd.extra+3));

   512         QRectF sr(d_ptr->floats.at(cmd.extra+4), d_ptr->floats.at(cmd.extra+5),

   513                   d_ptr->floats.at(cmd.extra+6), d_ptr->floats.at(cmd.extra+7));

   514         debug << "Cmd_DrawImageRect:" << r << sr << image.size();

   515         break; }

   516 

   517     case QPaintBufferPrivate::Cmd_DrawImagePos: {

   518         QImage image(d_ptr->variants.at(cmd.offset).value<QImage>());

   519         QPointF pos(d_ptr->floats.at(cmd.extra), d_ptr->floats.at(cmd.extra+1));

   520         debug << "Cmd_DrawImagePos:" << pos << image.size();

   521         break; }

   522 

   523     case QPaintBufferPrivate::Cmd_DrawText: {

   524         QPointF pos(d_ptr->floats.at(cmd.extra), d_ptr->floats.at(cmd.extra+1));

   525         QList<QVariant> variants(d_ptr->variants.at(cmd.offset).value<QList<QVariant> >());

   526 

   527         QFont font(variants.at(0).value<QFont>());

   528         QString text(variants.at(1).value<QString>());

   529 

   530         debug << "Cmd_DrawText:" << pos << text << font.family();

   531         break; }

   532 

   533     case QPaintBufferPrivate::Cmd_DrawTextItem: {

   534         QPointF pos(d_ptr->floats.at(cmd.extra), d_ptr->floats.at(cmd.extra+1));

   535         QTextItemIntCopy *tiCopy = reinterpret_cast<QTextItemIntCopy *>(qVariantValue<void *>(d_ptr->variants.at(cmd.offset)));

   536         QTextItemInt &ti = (*tiCopy)();

   537         QString text(ti.text());

   538 

   539         QFont font(ti.font());

   540         font.setUnderline(false);

   541         font.setStrikeOut(false);

   542         font.setOverline(false);

   543 

   544         const QTextItemInt &si = static_cast<const QTextItemInt &>(ti);

   545         qreal justificationWidth = 0;

   546         if (si.justified)

   547             justificationWidth = si.width.toReal();

   548 

   549         debug << "Cmd_DrawTextItem:" << pos << " " << text;

   550         break; }

   551     case QPaintBufferPrivate::Cmd_SystemStateChanged: {

   552         QRegion systemClip(d_ptr->variants.at(cmd.offset).value<QRegion>());

   553 

   554         debug << "Cmd_SystemStateChanged:" << systemClip;

   555         break; }

   556     case QPaintBufferPrivate::Cmd_Translate: {

   557         QPointF delta(d_ptr->floats.at(cmd.extra), d_ptr->floats.at(cmd.extra+1));

   558         debug << "Cmd_Translate:" << delta;

   559         break; }

   560     case QPaintBufferPrivate::Cmd_DrawStaticText: {

   561         debug << "Cmd_DrawStaticText";

   562         break; }

   563     }

   564 

   565     return desc;

   566 }

   567 #endif

  1068 void QPainterReplayer::draw(const QPaintBuffer &buffer, QPainter *_painter, int frame)

  1392 void QPainterReplayer::processCommands(const QPaintBuffer &buffer, QPainter *p, int begin, int end)

  1071     setupTransform(_painter);

  1395     painter = p;

  1072 

  1396 

  1073     int frameStart = (frame == 0) ? 0 : d->frames.at(frame-1);

  1397     for (int cmdIndex = begin; cmdIndex < end; ++cmdIndex) {

  1074     int frameEnd = (frame == d->frames.size()) ? d->commands.size() : d->frames.at(frame);

  1075 

  1076     for (int cmdIndex=frameStart; cmdIndex<frameEnd; ++cmdIndex) {

  1807             images[image.cacheKey()] = image;

  2193 

  1808 

  2194             QPaintBufferCacheEntryV2 entry;

  1809             QPaintBufferCacheEntry entry;

  2195             entry.flags.type = QPaintBufferCacheEntryV2::ImageKey;

  1810             entry.type = QVariant::Image;

  2196 

  1811             entry.cacheKey = image.cacheKey();

  2197             QHash<qint64, uint>::iterator it = imageKeys.find(image.cacheKey());

  2198             if (it != imageKeys.end()) {

  2199                 entry.flags.key = *it;

  2200             } else {

  2201                 imageKeys[image.cacheKey()] = entry.flags.key = images.size();

  2202                 images[images.size()] = image;

  2203             }

  2204 

  1815             pixmaps[pixmap.cacheKey()] = pixmap;

  2208 

  1816 

  2209             QPaintBufferCacheEntryV2 entry;

  1817             QPaintBufferCacheEntry entry;

  2210             entry.flags.type = QPaintBufferCacheEntryV2::PixmapKey;

  1818             entry.type = QVariant::Pixmap;

  2211 

  1819             entry.cacheKey = pixmap.cacheKey();

  2212             QHash<qint64, uint>::iterator it = pixmapKeys.find(pixmap.cacheKey());

  2213             if (it != pixmapKeys.end()) {

  2214                 entry.flags.key = *it;

  2215             } else {

  2216                 pixmapKeys[pixmap.cacheKey()] = entry.flags.key = pixmaps.size();

  2217                 pixmaps[pixmaps.size()] = pixmap;

  2218             }

  2219