// Create turn animation, i.e. card combined out of backside and frontside
QPixmap CardSprite::createCard(const QPixmap &front, const QPixmap &back, int curNo, int count)
{
int halfCount = count/2;
// Turn the frontside of the card 0..90 degree
if (curNo < halfCount)
{
QMatrix m;
// Get an angle eps..90 deg for the values i is running
double angle = (double)curNo/(double)halfCount*90.0;
// Conversion to rad
angle = angle/180.0*M_PI;
// Scale pixmap to simulate rotating card
m.scale(cos(angle), 1.0);
QPixmap pm = front.transformed(m, Qt::SmoothTransformation);
return pm;
}
// Turn the backside of the card 90..eps degree
else
{
QMatrix m;
// Get an angle 0..90 deg for the values i is running
double angle = 90.0-((double)(curNo-halfCount+1)/(double)halfCount*90.0);
// Conversion to rad
angle = angle/180.0*M_PI;
// Scale pixmap to simulate rotating card
m.scale(cos(angle), 1.0);
QPixmap pm = back.transformed(m, Qt::SmoothTransformation);
return pm;
}
}
void TsEnv::createThumbnail(const QPixmap& source,
int angle,
const void* userData)
{
try {
QPixmap thumbnailSource;
const Qt::Axis rotationAxis(Qt::ZAxis);
if ( 270 <= angle ) {
thumbnailSource = source.transformed(QTransform().rotate(270.0f,
rotationAxis),
Qt::SmoothTransformation);
} else if( 180 <= angle ) {
thumbnailSource = source.transformed(QTransform().rotate(180.0f,
rotationAxis),
Qt::SmoothTransformation);
} else if( 90 <= angle ) {
thumbnailSource = source.transformed(QTransform().rotate(90.0f,
rotationAxis),
Qt::SmoothTransformation);
} else {
thumbnailSource = source;
}
const QRect expectedRect(0, 0, thumbnailWidth, thumbnailHeight);
const QPixmap thumbanail(thumbnailSource.scaled(expectedRect.size(),
Qt::KeepAspectRatioByExpanding,
Qt::SmoothTransformation));
emit thumbnailCreated(thumbanail.copy(expectedRect), userData);
} catch (...) {
}
}
QPixmap Icon::applyEffects() const
{
QPixmap gfx = pixmap;
if (isColor && !qFuzzyIsNull(depth)) {
QLabel w;
QGraphicsColorizeEffect *effect = new QGraphicsColorizeEffect();
effect->setColor(color);
effect->setStrength(depth);
w.setPixmap(gfx);
w.setGraphicsEffect(effect);
gfx = w.grab();
}
if (!qFuzzyIsNull(radius)) {
QImage canvas(gfx.size(), QImage::Format_ARGB32_Premultiplied);
QPainter painter(&canvas);
painter.setCompositionMode(QPainter::CompositionMode_Source);
painter.fillRect(gfx.rect(), Qt::transparent);
painter.setPen(Qt::NoPen);
painter.setBrush(QBrush(gfx));
painter.setRenderHint(QPainter::Antialiasing);
painter.drawRoundedRect(gfx.rect(), radius, radius);
painter.end();
gfx = QPixmap::fromImage(canvas);
}
if (blur > 1.0) {
QLabel w;
QGraphicsBlurEffect *effect = new QGraphicsBlurEffect();
effect->setBlurRadius(blur);
effect->setBlurHints(QGraphicsBlurEffect::QualityHint);
w.setPixmap(gfx);
w.setGraphicsEffect(effect);
gfx = w.grab();
}
if (flipX) {
gfx = gfx.transformed(QTransform().scale(-1, 1));
}
if (flipY) {
gfx = gfx.transformed(QTransform().scale(1, -1));
}
if (angle != 0) {
gfx = gfx.transformed(QTransform().rotate(angle));
}
return gfx;
}
GameWidget::GameWidget(QWidget *parent)
:QLabel(parent), m_gunX(32), m_shipXHeading(1), m_soser(250, 65)
{
srand(QDateTime::currentDateTime().toTime_t());
m_shipTimeInt = 200.0;
m_shottimer = new QTimer(this);
connect(m_shottimer, SIGNAL(timeout()), this, SLOT(shotTimeout()));
m_shottimer->start(30);
m_shiptimer = new QTimer(this);
connect(m_shiptimer, SIGNAL(timeout()), this, SLOT(shipTimeout()));
m_shiptimer->start((int)m_shipTimeInt);
m_soserShowTimer = new QTimer(this);
connect(m_soserShowTimer, SIGNAL(timeout()), this, SLOT(soserShowTimeout()));
m_soserShowTimer->setSingleShot(false);
int tm = (((rand() % 6) + 5) * 1000);
m_soserShowTimer->start(tm);
m_soserMoveTimer = new QTimer(this);
connect(m_soserMoveTimer, SIGNAL(timeout()), this, SLOT(soserMoveTimeout()));
m_levelFinTimer = new QTimer(this);
connect(m_levelFinTimer, SIGNAL(timeout()), this, SLOT(levelFinTimeout()));
setMouseTracking(true);
// draw soser pixmap
m_soser.fill(Qt::transparent);
QPainter p(&m_soser);
QPixmap a = PicBucket::instance().getPic(4, 0).pixmap;
QPixmap b = PicBucket::instance().getPic(4, 3).pixmap;
p.drawPixmap(0, 0, a);
p.drawPixmap(51, 0, b.transformed(QMatrix().rotate(270), Qt::SmoothTransformation).transformed(
QMatrix(QMatrix(1, 0, 0, -1, 0, 0)), Qt::SmoothTransformation)); // flip it, looks better
p.drawPixmap(102, 0, b);
p.drawPixmap(153, 0, a.transformed(QMatrix(-1, 0, 0, 1, 0, 0), Qt::SmoothTransformation));
p.end();
m_soser = m_soser.scaled(QSize(170, 43), Qt::KeepAspectRatio, Qt::SmoothTransformation);
m_soserMask = QRegion(m_soser.mask());
m_score = 0;
m_level = 1;
m_lives = 3;
m_soserX = 0;
sizeY = 9999;
loadScores();
initLevel(m_level);
}
//Rotate the left/right image function
void HelloGUIWorld::on_pushButton_clicked() {
QPixmap pixmapLeft = *ui.leftImage->pixmap();
QPixmap pixmapRight = *ui.rightImage->pixmap();
QMatrix imageRotationMatrix;
imageRotationMatrix.rotate(90);
pixmapLeft = pixmapLeft.transformed(imageRotationMatrix);
pixmapRight = pixmapRight.transformed(imageRotationMatrix);
ui.leftImage->setPixmap(pixmapLeft);
ui.rightImage->setPixmap(pixmapRight);
}
void pDockWidgetTitleBar::updateStandardIcons()
{
const QSize size( 16, 16 );
QPixmap pixmap;
QRect rect( QPoint(), iconSize() );
QTransform transform;
transform.rotate( 90 );
pixmap = style()->standardIcon( QStyle::SP_ToolBarHorizontalExtensionButton, 0, widgetForAction( aOrientation ) ).pixmap( size );
rect.moveCenter( pixmap.rect().center() );
pixmap = pixmap.copy( rect );
pixmap = pixmap.transformed( transform, Qt::SmoothTransformation );
aOrientation->setIcon( pixmap );
pixmap = style()->standardIcon( QStyle::SP_TitleBarNormalButton, 0, widgetForAction( aFloat ) ).pixmap( size );
rect.moveCenter( pixmap.rect().center() );
pixmap = pixmap.copy( rect );
aFloat->setIcon( pixmap );
pixmap = style()->standardIcon( QStyle::SP_TitleBarCloseButton, 0, widgetForAction( aClose ) ).pixmap( size );
rect.moveCenter( pixmap.rect().center() );
pixmap = pixmap.copy( rect );
aClose->setIcon( pixmap );
}
void tst_qsganimatedimage::mirror_notRunning()
{
QFETCH(QUrl, fileUrl);
QSGView *canvas = new QSGView;
canvas->show();
canvas->setSource(fileUrl);
QSGAnimatedImage *anim = qobject_cast<QSGAnimatedImage *>(canvas->rootObject());
QVERIFY(anim);
int width = anim->property("width").toInt();
QPixmap screenshot = canvas->renderPixmap();
QTransform transform;
transform.translate(width, 0).scale(-1, 1.0);
QPixmap expected = screenshot.transformed(transform);
int frame = anim->currentFrame();
bool playing = anim->isPlaying();
bool paused = anim->isPlaying();
anim->setProperty("mirror", true);
screenshot = canvas->renderPixmap();
QSKIP("Skip while QTBUG-19351 and QTBUG-19252 are not resolved", SkipSingle);
QCOMPARE(screenshot, expected);
// mirroring should not change the current frame or playing status
QCOMPARE(anim->currentFrame(), frame);
QCOMPARE(anim->isPlaying(), playing);
QCOMPARE(anim->isPaused(), paused);
delete canvas;
}
void QTextDocumentExporter::writePicture(cf::CEDPicture& pic) {
if(!pic.image()) {
qDebug() << Q_FUNC_INFO << "empty image given";
return;
}
if(!page_) {
qDebug() << Q_FUNC_INFO << "NULL page pointer";
return;
}
QPixmap pixmap;
QTransform t = QTransform().rotate(page_->angle());
ImageCache::load(page_->imageURL(), &pixmap);
cf::Rect r = pic.boundingRect();
pixmap = pixmap.transformed(t);
pixmap = pixmap.copy(r.x(), r.y(), r.width(), r.height());
static int image_counter = 0;
cursor_.insertImage(pixmap.toImage(), QString("image %1").arg(++image_counter));
// QTextFrameFormat format;
// cursor_.currentFrame()->setFrameFormat(format);
}
CategorieButton::CategorieButton(QPixmap icon, QString name, QWidget *parent) : QWidget(parent) // This widget shows the icon and name of a menu's categorie
{
resize(100, 100);
isHovered = false;
m_iconLabel = new QLabel(this);
m_iconLabel->resize(size());
m_iconLabel->setAlignment(Qt::AlignCenter);
QPixmap modifiedIcon(48, 100);
modifiedIcon.fill(Qt::transparent);
QPainter p(&modifiedIcon);
p.drawPixmap(0, 2, 48, 48, icon);
QTransform t;
p.drawPixmap(0, 50, 48, 48, icon.transformed(t.rotate(180, Qt::XAxis), Qt::SmoothTransformation));
QLinearGradient alphaGradient(0, 0, 0, height());
alphaGradient.setColorAt(0.0, Qt::black);
alphaGradient.setColorAt(0.5, Qt::black);
alphaGradient.setColorAt(0.8, Qt::transparent);
QGraphicsOpacityEffect *iconEffect = new QGraphicsOpacityEffect(this);
iconEffect->setOpacity(1);
iconEffect->setOpacityMask(alphaGradient);
m_iconLabel->setPixmap(modifiedIcon);
m_iconLabel->setGraphicsEffect(iconEffect);
m_nameLabel = new QLabel(name, this);
m_nameLabel->setStyleSheet("color: white;");
QGraphicsDropShadowEffect *nameEffect = new QGraphicsDropShadowEffect();
nameEffect->setOffset(1);
nameEffect->setColor(Qt::black);
m_nameLabel->setGraphicsEffect(nameEffect);
m_nameLabel->setAlignment(Qt::AlignCenter);
m_nameLabel->setGeometry(0, 60, width(), m_nameLabel->height());
}
QPixmap
View::getPixmapForTile( std::string const & inTileId, View::Rotation inRotation )
{
QPixmap const pixmap = getPixmap( inTileId );
QTransform rotation = QTransform();
rotation.rotate( getAngle( inRotation ) );
return pixmap.transformed( rotation );
}
void StylePainterMobile::drawProgress(const QRect& rect, double progress, bool leftToRight, bool animated, bool vertical) const
{
const int horizontalBorder = (vertical ? rect.width() / 4 : 0);
const int verticalBorder = (vertical ? 0 : rect.height() / 4);
const QRect targetRect = rect.adjusted(horizontalBorder, verticalBorder, -horizontalBorder, -verticalBorder);
QPixmap result;
QSize imageSize = sizeForPainterScale(targetRect);
if (vertical)
qSwap(imageSize.rheight(), imageSize.rwidth());
KeyIdentifier id;
id.type = KeyIdentifier::Progress;
id.width = imageSize.width();
id.height = imageSize.height();
id.trait1 = animated;
id.trait2 = (!animated && !leftToRight);
id.trait3 = progress * 100;
if (!findCachedControl(id, &result)) {
if (imageSize.isNull())
return;
result = QPixmap(imageSize);
result.fill(Qt::transparent);
QPainter painter(&result);
painter.setRenderHint(QPainter::Antialiasing);
QRect progressRect(QPoint(0, 0), imageSize);
qreal radius = radiusFactor * progressRect.height();
painter.setBrush(Qt::NoBrush);
painter.setPen(borderPen());
progressRect.adjust(1, 1, -1, -1);
painter.drawRoundedRect(progressRect, radius, radius);
progressRect.adjust(1, 1, -1, -1);
if (animated) {
const int right = progressRect.right();
const int startPos = right * (1 - progressBarChunkPercentage) * 2 * fabs(progress - 0.5);
progressRect.setWidth(progressBarChunkPercentage * right);
progressRect.moveLeft(startPos);
} else {
progressRect.setWidth(progress * progressRect.width());
if (!leftToRight)
progressRect.moveRight(imageSize.width() - 2);
}
if (progressRect.width() > 0) {
QLinearGradient gradient;
gradient.setStart(progressRect.bottomLeft());
gradient.setFinalStop(progressRect.topLeft());
gradient.setColorAt(0.0, highlightColor);
gradient.setColorAt(1.0, highlightColor.lighter());
painter.setBrush(gradient);
painter.setPen(Qt::NoPen);
radius = radiusFactor * progressRect.height();
painter.drawRoundedRect(progressRect, radius, radius);
}
insertIntoCache(id, result);
}
QTransform transform;
transform.rotate(-90);
painter->drawPixmap(targetRect, vertical ? result.transformed(transform) : result);
}
void tst_QPixmap::transformed()
{
QFETCH(QSize, size);
QFETCH(QTransform, transform);
QFETCH(Qt::TransformationMode, transformMode);
QPixmap opaque = rasterPixmap(size);
QPixmap transparent = rasterPixmap(size);
opaque.fill(QColor(255, 0, 0));
transparent.fill(QColor(255, 0, 0, 200));
QPixmap transformed1;
QPixmap transformed2;
QBENCHMARK {
transformed1 = opaque.transformed(transform, transformMode);
transformed2 = transparent.transformed(transform, transformMode);
}
}
QIcon UserWidget::rotateIcon(QIcon ico){
//Rotate the given icon to appear vertical in the tab widget
QPixmap pix = ico.pixmap(32,32);
QTransform tran;
tran.rotate(+90); //For tabs on the left/West
pix = pix.transformed(tran);
ico = QIcon(pix);
return ico;
}
void Player::render(QPainter *p)
{
QPixmap* tx = texIndex > 8 ? texture1 : texture2;
QPixmap tex = tx->transformed(QTransform()
.translate(-width/2, -height/2)
.rotate(dir*90)
.translate(width/2, height/2));
p->drawPixmap(getX() + getMap()->offsetX, getY() + getMap()->offsetY, tex);
}
QBrush DBrushAdjuster::adjustBrush(const QBrush &brush, const QRect &rect )
{
QBrush brush1(brush);
if(brush.gradient())
{
QGradient grad = DGradientAdjuster::adjustGradient( brush.gradient(), rect );
brush1 = QBrush(grad);
}
else if(!brush.texture().isNull())
{
QPixmap p = (brush.texture()/*.toImage ()*/);
int offset= 0;
QRect br = p.rect();
QMatrix matrix;
float sx = 1, sy = 1;
if ( rect.width() < br.width() )
{
sx = static_cast<float>(rect.width()-offset) / static_cast<float>(br.width());
}
if ( rect.height() < br.height() )
{
sy = static_cast<float>(rect.height()-offset) / static_cast<float>(br.height());
}
float factor = qMin(sx, sy);
matrix.scale(sx, sy);
p = p.transformed(matrix ,Qt::SmoothTransformation );
matrix.reset();
QPointF pos = br.topLeft();
float tx = offset/2-pos.x(), ty = offset/2-pos.y();
matrix.translate(tx, ty);
p = p.transformed(matrix ,Qt::SmoothTransformation );
// brush1 = QBrush(p);
brush1.setTexture ( p );
}
return brush1;
}
QGraphicsScene *Road::paintCar(QGraphicsScene *scene)
{
qDebug() << QDir::currentPath()+"/assets/car.png";
QPixmap pMap = QPixmap(QDir::currentPath()+"/assets/car.png");
QTransform transform;
//transform.rotate(-45);
transform.scale(0.25,0.25);
QGraphicsPixmapItem *pm = scene->addPixmap( QPixmap(pMap.transformed(transform)));
pm->setPos(roadPattern->at(0),-15);
return scene;
}
QIcon IndigoTabbar::rotateIcon(const QIcon &icon, TabPosition tabPos){
QSize sz;
for (int var = 0; var < icon.availableSizes().count(); ++var) {
if (icon.availableSizes().at(var).width() > sz.width())
sz = icon.availableSizes().at(var);
}
QPixmap pix = icon.pixmap(sz);
QTransform trans;
switch(this->tabPosition()){
case QTabWidget::East:{
switch(tabPos){
case QTabWidget::West:{
trans.rotate(180);
break;
}
case QTabWidget::North:{
trans.rotate(-90);
break;
}
default:
break;
}
break;
}
case QTabWidget::West:{
switch(tabPos){
case QTabWidget::East:{
trans.rotate(180);
break;
}
case QTabWidget::North:{
trans.rotate(+90);
break;
}
default:
break;
}
break;
}
default:
break;
}
pix = pix.transformed(trans);
pix = pix.scaledToWidth( iconScale );
pix = pix.scaledToHeight( iconScale );
return QIcon(pix);
}
void MainWindow::ajouterExplosion(Bombe *bombe,int x, int y, int dx, int dy,bool end){
QPixmap sprite = QPixmap("../Game1/ressource/sprites_bomberman.png");
QTransform transform;
if(end)
sprite = sprite.copy(48,591,20,20);
else
sprite = sprite.copy(18,591,20,20);
if (dx == -1)
sprite = sprite.transformed(transform.rotate( -180,Qt::YAxis ), Qt::FastTransformation);
else if (dy != 0){
sprite = sprite.transformed(transform.rotate( dy *90 ), Qt::FastTransformation);
}
QGraphicsPixmapItem *picture = new QGraphicsPixmapItem(sprite);
bombe->addExplosions(picture);
picture->setPos(x,y);
scene->addItem(picture);
}
void Theme::cache(const QString& element, QPixmap& pixmap, const QRect& bounds, int angle) const
{
pixmap = QPixmap(bounds.size() * m_ratio);
pixmap.setDevicePixelRatio(m_ratio);
pixmap.fill(QColor(255, 255, 255, 0));
QPainter painter(&pixmap);
m_renderer->render(&painter, element, bounds);
// Handle rotated images
if (angle) {
Q_ASSERT(angle == 90 || angle == 180 || angle == 270);
painter.end();
pixmap = pixmap.transformed(QTransform().rotate(angle));
pixmap.setDevicePixelRatio(m_ratio);
}
}
void MonthWidget::gotThumbnail( const KUrl &url, const QPixmap &pix )
{
if ( url != imagePath_ )
return;
QPixmap image = pix;
int angle = interface_->info( url ).angle();
if ( angle != 0 )
{
QMatrix matrix;
matrix.rotate( angle );
image = image.transformed( matrix );
}
setThumb(image);
}
void
GraphicsScene::handleInputData(void)
{
while (m_sock->hasPendingDatagrams())
{
m_dgram.resize(m_sock->pendingDatagramSize());
m_sock->readDatagram(m_dgram.data(), m_dgram.size());
IMC::Message* msg = IMC::Packet::deserialize((uint8_t*)m_dgram.data(), m_dgram.size());
if (msg == 0)
continue;
if (msg->getId() == DUNE_IMC_COMPRESSEDIMAGE)
{
++m_fps;
IMC::CompressedImage* img = static_cast<IMC::CompressedImage*>(msg);
QPixmap pix;
pix.loadFromData((uchar*)img->data.data(), img->data.size(), "JPEG");
QTransform t;
pix = pix.transformed(t.rotate(m_rotate));
m_item.setPixmap(pix);
setMinimumSize(pix.width() + c_pad, pix.height() + c_pad);
if (m_grid)
{
m_vline->setLine(0, pix.height() / 2, pix.width(), pix.height() / 2);
m_hline->setLine(pix.width() / 2, 0, pix.width() / 2, pix.height());
}
}
else if (msg->getId() == DUNE_IMC_EULERANGLES)
{
IMC::EulerAngles* ang = static_cast<IMC::EulerAngles*>(msg);
// QString str("Roll: %0.2f | Pitch: %0.2f");
// m_text.setText(str.arg(Angles::degrees(ang->roll), Angles::degrees(ang->pitch)));
}
}
}
void SkinStyle::drawScaledPixmap(const QString & pixmapFilename, const QRect & rect, QPainter * painter, bool rotate) const {
QPixmap pix(_info.getSkinPath() + pixmapFilename);
QPixmap scaledPix;
if (pix.isNull()) {
return;
}
if (rotate) {
//pix.scaledToWidth(rect.height());
//pix.scaled(rect.height(), rect.width());
scaledPix = pix.scaled(rect.height(), rect.width());
QMatrix m;
m.rotate(90.0);
scaledPix = scaledPix.transformed(m);
} else {
scaledPix = pix.scaled(rect.width(), rect.height());
}
painter->drawPixmap(rect.x(), rect.y(), scaledPix);
}
void ReflectionEffect::paintEvent(QPaintEvent *)
{
if (m_source) {
QPixmap pixmap = m_source->grab();
// flip the pixmap
pixmap = pixmap.transformed(QTransform().scale(1, -1));
if (!pixmap.isNull()) {
QPainter painter;
painter.begin(this);
painter.setClipRect(rect());
painter.setOpacity(m_opacity);
painter.drawPixmap(0, 0, pixmap);
painter.end();
}
}
}
void HbInputVkbWidgetPrivate::captureScreenshot()
{
Q_Q(HbInputVkbWidget);
if (!mScreenshotWidget) {
mScreenshotWidget = new HbInputScreenshotWidget();
mScreenshotWidget->setZValue(q->zValue());
mScreenshotWidget->setGeometry(q->geometry());
q->mainWindow()->scene()->addItem(mScreenshotWidget);
}
QPointF position = q->pos();
QRectF rect = QRectF(position.x(), position.y() + mCloseHandleHeight, q->boundingRect().width(), q->boundingRect().height() - mCloseHandleHeight);
QTransform rotateTrans;
rotateTrans = q->mainWindow()->viewportTransform();
QRectF transRect = rotateTrans.mapRect(rect);
QPixmap pixmap;
pixmap = QPixmap::grabWidget(q->mainWindow(), (int)transRect.x(), (int)transRect.y(), (int)transRect.width(), (int)transRect.height());
pixmap = pixmap.transformed(rotateTrans.inverted());
mScreenshotWidget->setScreenshot(pixmap);
}
// experimental
void PrintLayout::printSixDives() const
{
ProfileGraphicsView *profile = mainWindow()->graphics();
QPainter painter;
painter.begin(printer);
painter.setRenderHint(QPainter::Antialiasing);
// painter.setRenderHint(QPainter::HighQualityAntialiasing);
painter.setRenderHint(QPainter::SmoothPixmapTransform);
painter.scale(scaleX, scaleY);
profile->clear();
profile->setPrintMode(true, !printOptions->color_selected);
QSize originalSize = profile->size();
profile->resize(scaledPageW, scaledPageH);
int i;
struct dive *dive;
bool firstPage = true;
for_each_dive(i, dive) {
if (!dive->selected && printOptions->print_selected)
continue;
// don't create a new page if still on first page
if (!firstPage)
printer->newPage();
else
firstPage = false;
profile->plot(dive, true);
QPixmap pm = QPixmap::grabWidget(profile);
QTransform transform;
transform.rotate(270);
pm = QPixmap(pm.transformed(transform));
painter.drawPixmap(0, 0, pm);
}
painter.end();
profile->setPrintMode(false);
profile->resize(originalSize);
profile->clear();
profile->plot(current_dive, true);
}
QPixmap MediaBrowser::iconForImage(const QString & file, const QSize & size)
{
QPixmap cache;
QDir path(QString("%1/%2").arg(AppSettings::cachePath()).arg(CACHE_DIR));
if(!path.exists())
QDir(AppSettings::cachePath()).mkdir(CACHE_DIR);
QString cacheFile = QString("%1/%2/%3-%4x%5")
.arg(AppSettings::cachePath())
.arg(CACHE_DIR)
.arg(MD5::md5sum(file))
.arg(size.width())
.arg(size.height());
//QPixmap orig(file);
//orig = orig.scaled(size,Qt::IgnoreAspectRatio,Qt::SmoothTransformation);
//orig.detach();
//return orig;
bool cacheFileModified = !QFile(cacheFile).exists() || QFileInfo(file).lastModified() >= QFileInfo(cacheFile).lastModified();
//qDebug() << "MediaBrowser::iconForImage: file:"<<file<<", size:"<<size<<", cacheFile: "<<cacheFile<<", cacheModified:"<<cacheFileModified;
if(!QPixmapCache::find(cacheFile,cache) || cacheFileModified)
{
if(QFile(cacheFile).exists() && !cacheFileModified)
{
cache.load(cacheFile);
QPixmapCache::insert(cacheFile,cache);
// qDebug() << "MediaBrowser::iconForImage: file:"<<file<<", size:"<<size<<": hit DISK (loaded scaled from disk cache)";
}
else
{
bool gotThumb = false;
try
{
Exiv2::Image::AutoPtr exiv = Exiv2::ImageFactory::open(file.toStdString());
if(exiv.get() != 0)
{
exiv->readMetadata();
Exiv2::ExifData& exifData = exiv->exifData();
if (exifData.empty())
{
// qDebug() << file << ": No Exif data found in the file";
}
Exiv2::ExifThumb exifThumb(exifData);
std::string thumbExt = exifThumb.extension();
if (thumbExt.empty())
{
// qDebug() << file << ": Image does not contain an Exif thumbnail";
}
else
{
Exiv2::DataBuf buf = exifThumb.copy();
if (buf.size_ != 0)
{
qDebug() << file << ": Attempting to load thumnail (" << exifThumb.mimeType() << ", "
<< buf.size_ << " Bytes)";
QPixmap thumb;
if(!thumb.loadFromData(buf.pData_, buf.size_))
{
qDebug() << file << "QPixmap::fromData() failed";
}
else
{
QString rotateSensor = exifData["Exif.Image.Orientation"].toString().c_str();
int rotationFlag = rotateSensor.toInt();
int rotateDegrees = rotationFlag == 1 ||
rotationFlag == 2 ? 0 :
rotationFlag == 7 ||
rotationFlag == 8 ? -90 :
rotationFlag == 3 ||
rotationFlag == 4 ? -180 :
rotationFlag == 5 ||
rotationFlag == 6 ? -270 :
0;
QTransform t = QTransform().rotate(rotateDegrees);
thumb = thumb.transformed(t);
cache = thumb.scaled(size,Qt::KeepAspectRatio,Qt::SmoothTransformation);
if(abs(rotateDegrees) == 90 || abs(rotateDegrees) == 270)
{
QPixmap centeredCache(size);
centeredCache.fill(Qt::transparent);
int pos = size.width() /2 - cache.width() / 2;
QPainter painter(¢eredCache);
painter.drawPixmap(pos,0,cache);
cache = centeredCache;
qDebug() << file << " * Centered rotated pixmap in frame";
}
cache.save(cacheFile,"PNG");
//qDebug() << "MediaBrowser::iconForImage: file:"<<file<<", image file: caching to:"<<cacheFile<<" for "<<file;
QPixmapCache::insert(cacheFile,cache);
gotThumb = true;
// qDebug() << file << ": Succesfully loaded Exiv thumnail and scaled to size, wrote to: "<<cacheFile;
}
}
}
}
}
catch (Exiv2::AnyError& e)
{
//std::cout << "Caught Exiv2 exception '" << e << "'\n";
//return -1;
gotThumb = false;
}
if(!gotThumb)
{
QPixmap orig(file);
if(orig.isNull())
{
cache = QPixmap();
QPixmapCache::insert(cacheFile,cache);
qDebug() << "MediaBrowser::iconForImage: file:"<<file<<", size:"<<size<<": load INVALID (Can't load original)";
}
else
{
cache = orig.scaled(size,Qt::KeepAspectRatio,Qt::SmoothTransformation);
cache.save(cacheFile,"PNG");
////qDebug() << "MyQFileIconProvider::icon(): image file: caching to:"<<cacheFile<<" for "<<file;
QPixmapCache::insert(cacheFile,cache);
// qDebug() << "MediaBrowser::iconForImage: file:"<<file<<", size:"<<size<<": load GOOD (loaded original and scaled)";
//QApplication::processEvents();
}
}
}
}
else
{
//qDebug() << "MediaBrowser::iconForImage: file:"<<file<<", size:"<<size<<": hit RAM (scaled image already in ram)";
}
//qDebug() << "MediaBrowser::data: iconForImage: file:"<<file<<", cacheKey:"<<cache.cacheKey();
return cache;
}
void PDF::slotPrintButton()
{
QDir monRepertoire;
bool firstpage = true;
SeriesInfos.SetChapter(ui->StartChap->value());
monRepertoire.setPath(SeriesInfos.GetChapterFolder());
if (monRepertoire.exists())
{
QPdfWriter pdfWriter(SeriesInfos.GetSeriesFolder() + "/" + SeriesInfos.GetSeriesName() + " Tome " + SeriesInfos.GetVolume() + ".pdf");
pdfWriter.setPageSize(QPagedPaintDevice::A4);
const qreal horizontalMarginMM = 10.0; // 10 mm margin on each side
const qreal verticalMarginMM = 10.0;
QPagedPaintDevice::Margins margins;
margins.left = margins.right = horizontalMarginMM;
margins.top = margins.bottom = verticalMarginMM;
pdfWriter.setMargins(margins);
QPixmap pixmap;
QPainter painter;
while ((monRepertoire.exists()) && (ui->EndChap->value() >= SeriesInfos.GetChapter().toInt()))
{
QStringList listOfFiles = monRepertoire.entryList();
for (int i = 2; i < listOfFiles.size(); i++)
{
QString imagePath = monRepertoire.absolutePath() + "/" + listOfFiles.at(i);
if ((imagePath.contains("jpg")) || (imagePath.contains("png")))
{
pixmap.load(imagePath);
if (pixmap.width() > pixmap.height())
{
if (ui->Vertical->isChecked())
{
if (firstpage == false)
{
pdfWriter.newPage();
}
else
{
painter.begin(&pdfWriter);
}
QTransform t;
pixmap = pixmap.transformed(t.rotate(90),Qt::SmoothTransformation);
painter.drawPixmap(QRectF(0, 0, pdfWriter.width(), pdfWriter.height()), pixmap, QRectF(0, 0, pixmap.width(), pixmap.height()));
}
else
{
pdfWriter.setPageOrientation(QPageLayout::Landscape);
if (firstpage == false)
{
pdfWriter.newPage();
}
else
{
painter.begin(&pdfWriter);
}
painter.drawPixmap(QRectF(0, 0, pdfWriter.width(), pdfWriter.height()), pixmap, QRectF(0, 0, pixmap.width(), pixmap.height()));
pdfWriter.setPageOrientation(QPageLayout::Portrait);
}
}
else
{
if (firstpage == false)
{
pdfWriter.newPage();
}
else
{
painter.begin(&pdfWriter);
}
painter.drawPixmap(QRectF(0, 0, pdfWriter.width(), pdfWriter.height()), pixmap, QRectF(0, 0, pixmap.width(), pixmap.height()));
}
firstpage = false;
}
}
SeriesInfos.UpdateChapterVal();
monRepertoire.setPath(SeriesInfos.GetChapterFolder());
}
emit UpdateVolume(CurrentIdx);
painter.end();
}
this->close();
}
