/*! With this function you can set the skin that will be displayed in the widget. \code QtScrollDial * scroll = new QtScrollDial(this); scroll->setSkin("Beryl"); \endcode This function has to be called before using the QtScrollDial. \sa skin() */ void QtScrollDial::setSkin(const QString& skin) { m_skin = skin; const QString base = ":/scrolldial/" + skin + '/'; if(m_popup != NULL) m_popup->setSkin(skin); m_label->setStyleSheet("color: white; border-width: 2px;" "border-image: url(" + base + "label.svg);"); // set to null pictures m_background = QPicture(); m_hoverBackground = QPicture(); QSvgRenderer renderer; QPainter painter; if (renderer.load(base + "background.svg")) { painter.begin(&m_background); renderer.render(&painter, QRectF(0.0, 0.0, 1.0, 1.0)); painter.end(); } if (renderer.load(base + "background_hover.svg")) { painter.begin(&m_hoverBackground); renderer.render(&painter, QRectF(0.0, 0.0, 1.0, 1.0)); painter.end(); } // update geometry for new sizeHint and repaint updateGeometry(); update(); }
inline static QImage colorBlot(const QColor &color, int blotVariation, QSize *size, const QSize &requestedSize) { QSvgRenderer *renderer = designRenderer(); const static QString elementIdBase = QStringLiteral("colorblot"); const static int variationsCnt = variationsCount(renderer, elementIdBase); const int actualVariation = (blotVariation % variationsCnt) + 1; const QString elementId = elementIdBase + QLatin1Char('_') + QString::number(actualVariation); const QString maskElementId = elementId + QStringLiteral("_mask"); const QString highlightElementId = elementId + QStringLiteral("_highlight"); const QRectF backgroundRect = renderer->boundsOnElement(idPrefix + elementId); QSize resultSize = backgroundRect.size().toSize(); if (size) *size = resultSize; resultSize.scale(requestedSize, Qt::KeepAspectRatio); const qreal scaleFactor = resultSize.width() / backgroundRect.width(); QTransform transform = QTransform::fromScale(scaleFactor, scaleFactor); transform.translate(-backgroundRect.topLeft().x(), -backgroundRect.topLeft().y()); QImage result(resultSize, QImage::Format_ARGB32); if (result.isNull()) qDebug() << Q_FUNC_INFO << "clock image is NULL! Variation:" << blotVariation; result.fill(0); QPainter p(&result); p.setTransform(transform); renderer->render(&p, idPrefix + maskElementId, renderer->boundsOnElement(idPrefix + maskElementId)); p.save(); p.setCompositionMode(QPainter::CompositionMode_SourceIn); p.fillRect(backgroundRect, color); p.restore(); renderer->render(&p, idPrefix + highlightElementId, renderer->boundsOnElement(idPrefix + highlightElementId)); return result; }
bool GoTableWidget::buildPixmaps(int diameter) { QSvgRenderer svgR; delete blackStonePixmap; blackStonePixmap = new QPixmap(diameter, diameter); blackStonePixmap->fill(Qt::transparent); svgR.load(QString(":/resources/cursorBlack.svg")); QPainter bPainter(blackStonePixmap); svgR.render(&bPainter); delete blackCursor; blackCursor = new QCursor(*blackStonePixmap); delete whiteStonePixmap; whiteStonePixmap = new QPixmap(diameter, diameter); whiteStonePixmap->fill(QColor(0, 0, 0, 0)); svgR.load(QString(":/resources/cursorWhite.svg")); QPainter wPainter(whiteStonePixmap); svgR.render(&wPainter); delete whiteCursor; whiteCursor = new QCursor(*whiteStonePixmap); delete redStonePixmap; redStonePixmap = new QPixmap(diameter, diameter); redStonePixmap->fill(QColor(0, 0, 0, 0)); svgR.load(QString(":/resources/cursorRed.svg")); QPainter rPainter(redStonePixmap); svgR.render(&rPainter); delete redCursor; redCursor = new QCursor(*redStonePixmap); return true; }
inline static QImage notes(const QStringList ¬es, QSize *size, const QSize &requestedSize) { QSvgRenderer *renderer = notesRenderer(); static const QString clefId = QStringLiteral("clef"); static const QRectF clefRect = renderer->boundsOnElement(idPrefix + clefId); static const QString staffLinesId = QStringLiteral("stafflines"); static const QRectF staffLinesOriginalRect = renderer->boundsOnElement(idPrefix + staffLinesId); static const qreal clefRightY = clefRect.right() - staffLinesOriginalRect.left(); static const qreal linesSpacePerNote = clefRect.width() * 1.75; const qreal linesSpaceForNotes = notes.count() * linesSpacePerNote; QRectF imageRect = staffLinesOriginalRect; imageRect.setWidth(clefRightY + linesSpaceForNotes); QSize resultSize = imageRect.size().toSize(); if (size) *size = resultSize; resultSize.scale(requestedSize, Qt::KeepAspectRatio); QImage result(resultSize, QImage::Format_ARGB32); if (result.isNull()) qDebug() << Q_FUNC_INFO << "notes image is NULL! Notes:" << notes; result.fill(Qt::transparent); QPainter p(&result); const qreal scaleFactor = resultSize.width() / imageRect.width(); p.scale(scaleFactor, scaleFactor); p.translate(-imageRect.topLeft()); renderer->render(&p, idPrefix + staffLinesId, imageRect); renderer->render(&p, idPrefix + clefId, clefRect); int currentNoteIndex = 0; foreach(const QString ¤tNote, notes) { const QString trimmedNote = currentNote.trimmed(); const QString note = trimmedNote.at(0).toLower(); const QString noteID = QStringLiteral("note_") + note; QRectF noteRect = renderer->boundsOnElement(idPrefix + noteID); const qreal noteCenterX = clefRightY + (currentNoteIndex + 0.125) * linesSpacePerNote + noteRect.width(); currentNoteIndex++; const qreal noteXTranslate = noteCenterX - noteRect.center().x(); noteRect.translate(noteXTranslate, 0); renderer->render(&p, idPrefix + noteID, noteRect); if (trimmedNote.length() > 1) { static const QString sharpId = QStringLiteral("sharp"); static const QString flatId = QStringLiteral("flat"); static const QRectF noteCHeadRect = renderer->boundsOnElement(idPrefix + QStringLiteral("note_c_head")); const bool sharp = trimmedNote.endsWith(QStringLiteral("sharp")); const QString ¬eSign = sharp ? sharpId : flatId; const QRectF noteHeadRect = renderer->boundsOnElement(idPrefix + QStringLiteral("note_") + note + QStringLiteral("_head")); const QRectF signRect = renderer->boundsOnElement(idPrefix + noteSign) .translated(noteXTranslate, 0) .translated(noteHeadRect.topLeft() - noteCHeadRect.topLeft()); renderer->render(&p, idPrefix + noteSign, signRect); } } return result; }
QImage SvgElementProvider::requestImage(const QString& id, QSize* size, const QSize& requestedSize) { // Resolve URL QUrl url = QUrl(id); if (url.isRelative() && !mBaseUrl.isEmpty()) url = mBaseUrl.resolved(url); if (!url.isValid()) return placeholder(QString("Invalid URL\nBase: %1\nInput: %2").arg(mBaseUrl.toString()).arg(id), requestedSize); // Make a filename from the given URL QString imagepath = QQmlFile::urlToLocalFileOrQrc(url); // Fragment is used to specify SVG element QString elementId = url.fragment(); // Load image QSvgRenderer renderer; if (!renderer.load(imagepath)) { qWarning() << "Unable to load image:" << imagepath; return placeholder(QStringLiteral("Unable to load image:\n") + imagepath, requestedSize); } // Check whether requested element exists if (!elementId.isEmpty() && !renderer.elementExists(elementId)) return placeholder(QStringLiteral("Unable to find element:\n") + elementId + "\nin image:\n" + imagepath, requestedSize); // Get image or element size QSize itemSize = elementId.isEmpty() ? renderer.defaultSize() : renderer.boundsOnElement(elementId).size().toSize(); if (size) *size = itemSize; // Create image QImage image(requestedSize.width() > 0 ? requestedSize.width() : itemSize.width(), requestedSize.height() > 0 ? requestedSize.height() : itemSize.height(), QImage::Format_ARGB32_Premultiplied); image.fill(Qt::transparent); // Paint svg or element QPainter p(&image); if (elementId.isEmpty()) renderer.render(&p); else renderer.render(&p, elementId); return image; }
void TouchUI::draw( QPainter & painter ) { _screen_width = painter.window().width(); _screen_height = painter.window().height(); limitScroll(); // draw background QRect rect(0,0,painter.window().width(),_height); painter.drawTiledPixmap( rect, _background ); // draw icons for ( int i = 0; i < _items.count(); i++ ) { UIItem * t = _items[i]; int posx = t->x1; int posy = t->y1; if ( posx < 0 ) posx = _screen_width+posx; QSvgRenderer * image = t->image; if ( t->highlighted ) painter.setCompositionMode( QPainter::CompositionMode_HardLight ); else painter.setCompositionMode( QPainter::CompositionMode_SourceOver ); if ( image == NULL ) continue; int h = image->defaultSize().height(); int w = image->defaultSize().width(); int img_width = g_config.ui_size; int img_height = g_config.ui_size; ImageLoadThread::fitImage( w,h, img_width, img_height, false ); QRectF r( posx+_xoffset, posy+_yoffset, w, h ); image->render( &painter, r ); } }
void DistroMesas::paintEvent ( QPaintEvent * event ) { QPainter painter; painter.begin ( this ); // paint in picture QSvgRenderer *arender; if (m_background.isEmpty()) { arender = new QSvgRenderer(mui_widget); } else { arender = new QSvgRenderer(m_background, mui_widget); } // end if arender->render(&painter); painter.end(); QList<Mesa *> mesas = findChildren<Mesa *>(); for (int i = 0; i < mesas.size(); ++i) { if ( mesas.at(i)->m_pantalla == m_pantallaactual) { mesas.at(i)->setVisible(TRUE); } else { mesas.at(i)->setVisible(FALSE); } // end if } // end for delete arender; }
void QgsLayoutItemPolyline::drawSvgMarker( QPainter *p, QPointF point, double angle, const QString &markerPath, double height ) const { // translate angle from ccw from axis to cw from north angle = 90 - angle; if ( mArrowHeadWidth <= 0 || height <= 0 ) { //bad image size return; } if ( markerPath.isEmpty() ) return; QSvgRenderer r; const QByteArray &svgContent = QgsApplication::svgCache()->svgContent( markerPath, mArrowHeadWidth, mArrowHeadFillColor, mArrowHeadStrokeColor, mArrowHeadStrokeWidth, 1.0 ); r.load( svgContent ); p->save(); p->translate( point.x(), point.y() ); p->rotate( angle ); p->translate( -mArrowHeadWidth / 2.0, -height / 2.0 ); r.render( p, QRectF( 0, 0, mArrowHeadWidth, height ) ); p->restore(); }
QPixmap MIconEngine::pixmap(const QSize &size, QIcon::Mode mode, QIcon::State state) { QPixmap pm; QString pmckey(d->pmcKey(size, mode, state)); if (QPixmapCache::find(pmckey, pm)) return pm; if (d->addedPixmaps) { pm = d->addedPixmaps->value(d->hashKey(mode, state)); if (!pm.isNull() && pm.size() == size) return pm; } QSvgRenderer renderer; d->loadDataForModeAndState(&renderer, mode, state); if (!renderer.isValid()) return pm; QSize actualSize = renderer.defaultSize(); if (!actualSize.isNull()) actualSize.scale(size, Qt::KeepAspectRatio); QImage img(actualSize, QImage::Format_ARGB32); img.fill(0x00000000); QPainter p(&img); renderer.render(&p); p.end(); pm = QPixmap::fromImage(img); if (!pm.isNull()) QPixmapCache::insert(pmckey, pm); return pm; }
inline static QImage quantity(int quantity, const QString &item, QSize *size, const QSize &requestedSize) { QSvgRenderer *renderer = countablesRenderer(); const int columns = ceil(sqrt(qreal(quantity))); const int rows = ceil(quantity / qreal(columns)); const int columnsInLastRow = quantity % columns == 0 ? columns : quantity % columns; const int itemSize = qMin((requestedSize.width() / qMax(3, columns)), (requestedSize.height() / qMax(3, rows))); const QSize resultSize(itemSize * columns, itemSize * rows); QImage result(resultSize, QImage::Format_ARGB32); result.fill(Qt::transparent); QPainter p(&result); for (int row = 0; row < rows; row++) { for (int column = 0; column < columns; column++) { if (columns * row + column >= quantity) break; const QString itemId = item + QLatin1Char('_') + QString::number((qrand() % 8 + 1)); const QRect itemRect(column * itemSize + (row == rows-1 ? (columns - columnsInLastRow) * itemSize / 2 : 0), row * itemSize, itemSize, itemSize); renderer->render(&p, idPrefix + itemId, itemRect); } } if (size) *size = resultSize; return result; }
QPixmap SCPageLayout::thumbnail() const { static KIconLoader * loader = KIconLoader::global(); QSvgRenderer renderer; QSize size(80, 60); QPixmap pic(size); pic.fill(); QPainter p(&pic); QString file = loader->iconPath("layout-elements", KIconLoader::User); if (renderer.load(file)) { QList<SCPlaceholder *>::const_iterator it(m_placeholders.begin()); for (; it != m_placeholders.end(); ++it) { kDebug(33001) << "-----------------" <<(*it)->presentationObject() << (*it)->rect(size); renderer.render(&p, (*it)->presentationObject(), (*it)->rect(size)); } } else { kWarning(33001) << "could not load" << file; } return pic; }
void KWaitedPlayerSetupDialog::fillWaitedPlayersCombo() { kDebug() << "Filling nations combo" << endl; QList<PlayerMatrix>::iterator it, it_end; it = m_automaton->game()->waitedPlayers().begin(); it_end = m_automaton->game()->waitedPlayers().end(); for (; it != it_end; it++) { kDebug() << "Adding waited player " << (*it).name << endl; QString imgName = m_automaton->game()->theWorld()->nationNamed((*it).nation)->flagFileName(); // load image QPixmap flag; QSize size(flag.width()/Sprites::SkinSpritesData::single().intData("flag-frames"),flag.height()); QImage image(size, QImage::Format_ARGB32_Premultiplied); image.fill(0); QPainter p(&image); QSvgRenderer renderer; renderer.load(imgName); renderer.render(&p/*, svgid*/); QPixmap allpm = QPixmap::fromImage(image); flag = allpm.copy(0, 0, size.width(), size.height()); // get name QString name = (*it).name; name += QString(" ("); name += (i18n((*it).nation.toUtf8().data())); name += QString(")"); // fill a combo entry waitedPlayersCombo->addItem(QIcon(flag),name); } }
void ClassicStyle::drawPrimitive( PrimitiveElement pe, const QStyleOption *opt, QPainter *p, const QWidget *w ) const { static QSvgRenderer onRenderer(QString(":/vpiano/led_green.svg")); static QSvgRenderer offRenderer(QString(":/vpiano/led_grey.svg")); if (pe == PE_IndicatorCheckBox) { QRect r = opt->rect; if (opt->state & State_On) onRenderer.render(p, r); else if (opt->state & State_Off) offRenderer.render(p, r); return; } else if (pe == PE_FrameFocusRect) return; QCommonStyle::drawPrimitive(pe, opt, p, w); }
QPixmap SIconPool::loadIcon( const QString &fileName, const QSize &size, Qt::AspectRatioMode mode, const QColor &color) { QPixmap pm; // SVG? Use QSvgRenderer if (fileName.endsWith(".svg")) { QSvgRenderer *renderer = getSvgRenderer(fileName); if (renderer->isValid()) { QSize renderSize = renderer->defaultSize(); // If given size is valid, scale default size to it using the given aspect ratio mode if (size.isValid()) { renderSize.scale(size, mode); // If only one dimension is valid, scale other dimension keeping the aspect ratio } else if (size.height() > 0) { Qt::AspectRatioMode scaleMode = size.height() > renderSize.height() ? Qt::KeepAspectRatioByExpanding : Qt::KeepAspectRatio; renderSize.scale(renderSize.width(), size.height(), scaleMode); } else if (size.width() > 0) { Qt::AspectRatioMode scaleMode = size.width() > renderSize.width() ? Qt::KeepAspectRatioByExpanding : Qt::KeepAspectRatio; renderSize.scale(size.width(), renderSize.height(), scaleMode); } // Otherwise (-1,-1) was given as size, leave renderSize as icon's default size pm = QPixmap(renderSize); pm.fill(QColor(0, 0, 0, 0)); QPainter painter(&pm); renderer->render(&painter, QRectF(QPointF(), renderSize)); } } else { // Otherwise load with QPixmap pm.load(fileName); if (!pm.isNull()) { pm = pm.scaled(size, mode, Qt::SmoothTransformation); } } if (!pm.isNull() && color.isValid()) { // Colorize the icon QPixmap mask = pm.alphaChannel(); pm.fill(color); pm.setAlphaChannel(mask); } #ifdef Q_DEBUG_ICON if (pm.isNull()) { qDebug() << "Fail to load icon: " << filename; } #endif return pm; }
// QtPluginIconPalletTool Interface void dmz::QtPluginIconPalletTool::_add_type (const ObjectType &Type) { const String IconResource = config_to_string ( get_plugin_name () + ".resource", Type.get_config()); const String IconName = _rc.find_file (IconResource); if (IconName) { const String Name = Type.get_name (); if (Name) { QImage back ( (int)_iconExtent, (int)_iconExtent, QImage::Format_ARGB32_Premultiplied); QPainter painter (&back); painter.setCompositionMode (QPainter::CompositionMode_Source); painter.fillRect (back.rect (), Qt::transparent); painter.setCompositionMode (QPainter::CompositionMode_SourceOver); QSvgRenderer qsr (QString (IconName.get_buffer ())); QRectF size = qsr.viewBoxF (); qreal width = size.width (); qreal height = size.height (); qreal scale = (width > height) ? width : height; if (scale <= 0.0f) { scale = 1.0f; } scale = _iconExtent / scale; width *= scale; height *= scale; size.setWidth (width); size.setHeight (height); if (height < _iconExtent) { size.moveTop ((_iconExtent - height) * 0.5f); } if (width < _iconExtent) { size.moveLeft ((_iconExtent - width) * 0.5f); } qsr.render (&painter, size); painter.end (); QIcon icon; icon.addPixmap (QPixmap::fromImage (back)); QStandardItem *item = new QStandardItem (icon, Name.get_buffer ()); item->setEditable (false); _model.appendRow (item); } } else if (IconResource) { _log.error << "Unable to find icon resource: " << IconResource << " for object type: " << Type.get_name () << endl; } RuntimeIterator it; ObjectType next; while (Type.get_next_child (it, next)) { _add_type (next); } }
qreal PdfElementImage::paint(QPainter *painter) { qreal x = toQReal(_attributes.value("x", "0")); qreal y = toQReal(_attributes.value("y", "0")) + _offsetY; qreal w = toQReal(_attributes.value("width", "0")); qreal h = toQReal(_attributes.value("height", "0")); if (w > 0 && h > 0) { painter->setPen(Qt::NoPen); painter->setBrush(Qt::NoBrush); QRectF box(QPointF(x, y), QSizeF(w, h)); QImage picture; // Get the variable defined in the attribute "file" QString var = _attributes.value("file", ""); bool drawn = FALSE; // No variable found, the attribute "file" might point to an imagefile if (_variables->value(var, "").isEmpty()) { // Load the image (or default image) and print it QList<QString> images = replaceVariables(var); QString img; for (int i = 0; i < images.size(); i++) { img = QString("/").prepend(_templatePath).append(images.at(i)); if (picture.load(img)) { painter->drawImage( box, picture, QRectF(picture.rect()) ); drawn = TRUE; break; } } } else { // if an attribute exists with the addition "_file" the string in the attribute should be iinterpreted as a file, otherwise as SVG-Content bool imageIsFile = _variables->contains(var) && !_variables->value(var.append("_file"), "").isEmpty(); // Try to render a normal pixel image or as an SVG Image / Content QSvgRenderer svg; if (imageIsFile && picture.load(_variables->value(var))) { painter->drawImage( box, picture, QRectF(picture.rect()) ); drawn = TRUE; } else if ( (imageIsFile && svg.load( _variables->value(var) )) || (!imageIsFile && svg.load( _variables->value(var).toUtf8() )) ) { svg.render(painter, box); drawn = TRUE; } } // If the Image isn't drawn, show the default one if (!drawn) { showDefaultImage(painter, box); } } return bottom(); }
void draw(QPainter * painter, const QRect & frameRect, bool opaqueContents) const { // left column int l = frameRect.left(); int t = frameRect.top(); int w = frameRect.width(); int h = frameRect.height(); int wx = w - w1 - w3; int hx = h - h1 - h3; svg->render(painter, "topleft", QRect(l, t, w1, h1)); svg->render(painter, "top", QRect(l+w1, t, wx, h1)); svg->render(painter, "topright", QRect(l+w1+wx, t, w3, h1)); svg->render(painter, "left", QRect(l, t+h1, w1, hx)); if (padL > w1 || padT > h1 || padR > w3 || padB > h3 || !opaqueContents) svg->render(painter, "center", QRect(l+w1, t+h1, wx, hx)); svg->render(painter, "right", QRect(l+w1+wx, t+h1, w3, hx)); svg->render(painter, "bottomleft", QRect(l, t+h1+hx,w1, h3)); svg->render(painter, "bottom", QRect(l+w1, t+h1+hx,wx, h3)); svg->render(painter, "bottomright", QRect(l+w1+wx, t+h1+hx,w3, h3)); }
inline static QImage clock(int hour, int minute, int variation, QSize *size, const QSize &requestedSize) { QSvgRenderer *renderer = clocksRenderer(); const static QString clockBackgroundString = QStringLiteral("background"); const static int variationsCnt = variationsCount(renderer, clockBackgroundString); const int actualVariation = (variation % variationsCnt) + 1; const QString variationNumber = QLatin1Char('_') + QString::number(actualVariation); const QString backgroundElementId = clockBackgroundString + variationNumber; const QRectF backgroundRect = renderer->boundsOnElement(idPrefix + backgroundElementId); QSize resultSize = backgroundRect.size().toSize(); if (size) *size = resultSize; resultSize.scale(requestedSize, Qt::KeepAspectRatio); QImage result(resultSize, QImage::Format_ARGB32); if (result.isNull()) qDebug() << Q_FUNC_INFO << "clock image is NULL! Variation:" << variation; result.fill(Qt::transparent); QPainter p(&result); const qreal scaleFactor = resultSize.width() / backgroundRect.width(); QTransform mainTransform; mainTransform .scale(scaleFactor, scaleFactor) .translate(-backgroundRect.left(), -backgroundRect.top()); p.setTransform(mainTransform); renderer->render(&p, idPrefix + backgroundElementId, backgroundRect); const int minuteRotation = (minute * 6) % 360; renderIndicator(QStringLiteral("minute") + variationNumber, minuteRotation, backgroundRect, scaleFactor, renderer, &p); const int hoursSkew = 6; // Initial position of hour in the SVG is 6 renderIndicator(QStringLiteral("hour") + variationNumber, (((hour + hoursSkew) * 360 + minuteRotation) / 12) % 360, backgroundRect, scaleFactor, renderer, &p); const QString foregroundElementId = QStringLiteral("foreground") + variationNumber; if (renderer->elementExists(idPrefix + foregroundElementId)) { p.setTransform(mainTransform); renderer->render(&p, idPrefix + foregroundElementId, renderer->boundsOnElement(idPrefix + foregroundElementId)); } return result; }
void StartGameDialog::loadChipImages() { QSvgRenderer svgRenderer; svgRenderer.load(m_provider->currentTheme()->graphicsPath()); QPixmap blackChip(QSize(46, 46)); blackChip.fill(Qt::transparent); QPixmap whiteChip(QSize(46, 46)); whiteChip.fill(Qt::transparent); QPainter *painter = new QPainter(&blackChip); QString prefix = Utils::chipPrefixToString(m_chipsPrefix); svgRenderer.render(painter, prefix + "_1"); delete painter; painter = new QPainter(&whiteChip); // TODO: get 12 from some global constant that is shared with QML svgRenderer.render(painter, prefix + "_12"); delete painter; ui->blackLabel->setPixmap(blackChip); ui->whiteLabel->setPixmap(whiteChip); QGraphicsDropShadowEffect *blackShadow = new QGraphicsDropShadowEffect(this); blackShadow->setBlurRadius(10.0); blackShadow->setColor(Qt::black); blackShadow->setOffset(0.0); QGraphicsDropShadowEffect *whiteShadow = new QGraphicsDropShadowEffect(this); whiteShadow->setBlurRadius(10.0); whiteShadow->setColor(Qt::black); whiteShadow->setOffset(0.0); ui->blackLabel->setGraphicsEffect(blackShadow); ui->whiteLabel->setGraphicsEffect(whiteShadow); }
int main(int argc, char *argv[]) { QApplication app(argc, argv); //! [0] QSvgWidget window(":/files/spheres.svg"); window.show(); //! [0] QSvgRenderer *renderer = window.renderer(); QImage image(150, 150, QImage::Format_RGB32); QPainter painter; painter.begin(&image); renderer->render(&painter); painter.end(); image.save("spheres.png", "PNG", 9); return app.exec(); }
const QImage gradientImage(DesignElementType type) { QSvgRenderer *renderer = designRenderer(); const QString gradientId = idPrefix + (type == DesignElementTypeButton ? buttonString : frameString) + QStringLiteral("gradient"); Q_ASSERT(renderer->boundsOnElement(gradientId).size().toSize() == QSize(256, 1)); QImage result(256, 1, QImage::Format_ARGB32); result.fill(0); QPainter p(&result); renderer->render(&p, gradientId, result.rect()); #if 0 // for debugging p.fillRect(0, 0, 16, 1, Qt::red); p.fillRect(120, 0, 16, 1, Qt::green); p.fillRect(240, 0, 16, 1, Qt::blue); #endif return result; }
void TrafficGraph::drawBackground(QPainter *p, int w, int h) { p->fillRect(0,0,w, h, mBackgroundColor); if(mSvgFilename.isEmpty()) return; //nothing to draw, return QSvgRenderer *svgRenderer; if(!sSvgRenderer.contains(mSvgFilename)) { KStandardDirs* kstd = KGlobal::dirs(); QString file = kstd->findResource( "data", "ksysguard/" + mSvgFilename); svgRenderer = new QSvgRenderer(file, this); sSvgRenderer.insert(mSvgFilename, svgRenderer); } else svgRenderer = sSvgRenderer[mSvgFilename]; svgRenderer->render(p); }
void WidgetEngineWidget::paintEvent(QPaintEvent*) { if (m_svgr) { QPainter p(this); p.fillRect(0, 0, m_size.width(), m_size.height(), m_fillColor); m_svgr->render(&p); p.end(); } else { QPainter p(this); PaintCommands pcmd(m_qpsScript, 800, 800); pcmd.setPainter(&p); pcmd.setFilePath(m_absFilePath); pcmd.runCommands(); p.end(); } }
QPixmap QSvgIconEngine::pixmap(const QSize &size, QIcon::Mode mode, QIcon::State state) { QPixmap pm; QString pmckey(d->pmcKey(size, mode, state)); if (QPixmapCache::find(pmckey, pm)) return pm; if (d->addedPixmaps) { pm = d->addedPixmaps->value(d->hashKey(mode, state)); if (!pm.isNull() && pm.size() == size) return pm; } QSvgRenderer renderer; d->loadDataForModeAndState(&renderer, mode, state); if (!renderer.isValid()) return pm; QSize actualSize = renderer.defaultSize(); if (!actualSize.isNull()) actualSize.scale(size, Qt::KeepAspectRatio); if (actualSize.isEmpty()) return QPixmap(); QImage img(actualSize, QImage::Format_ARGB32_Premultiplied); img.fill(0x00000000); QPainter p(&img); renderer.render(&p); p.end(); pm = QPixmap::fromImage(img); if (qobject_cast<QGuiApplication *>(QCoreApplication::instance())) { const QPixmap generated = QGuiApplicationPrivate::instance()->applyQIconStyleHelper(mode, pm); if (!generated.isNull()) pm = generated; } if (!pm.isNull()) QPixmapCache::insert(pmckey, pm); return pm; }
inline static QImage renderedLessonIcon(const QString &iconId, int buttonVariation, QSize *size, const QSize &requestedSize) { QImage result(requestedSize, QImage::Format_ARGB32); result.fill(Qt::transparent); QPainter p(&result); QSvgRenderer *renderer = lessonIconsRenderer(); const QRectF iconRectOriginal = renderer->boundsOnElement(idPrefix + iconId); QSizeF iconSize = iconRectOriginal.size(); iconSize.scale(requestedSize, Qt::KeepAspectRatio); QRectF iconRect(QPointF(), iconSize); if (requestedSize.height() > requestedSize.width()) iconRect.moveBottom(requestedSize.height()); else iconRect.moveTop((requestedSize.height() - iconSize.height()) / 2); renderer->render(&p, idPrefix + iconId, iconRect); const QImage button = renderedDesignElement(DesignElementTypeButton, buttonVariation, size, requestedSize); p.drawImage(QPointF(), button); return result; }
void PdfElementImage::showDefaultImage(QPainter *painter, QRectF box) { QSvgRenderer svg; QImage picture; QString img; QList<QString> images = replaceVariables(_attributes.value("default", "")); // Try to load the image as SVG and after as a pixel graphic for (int i = 0; i < images.size(); i++) { img = QString("/").prepend(_templatePath).append( images.at(i) ); if (svg.load(img)) { painter->setPen(Qt::NoPen); svg.render(painter, box); break; } else if (picture.load( img )) { painter->drawImage( box, picture, QRectF(picture.rect()) ); break; } } }
static bool writeImage(QSvgRenderer &svg, int size, const QString &outFile1, const QString &outFile2 = QString()) { QImage out(size, size, QImage::Format_ARGB32); out.fill(Qt::transparent); QPainter painter(&out); svg.render(&painter); painter.end(); if (!out.save(outFile1)) { fprintf(stderr, "Unable to write %s\n", qPrintable(outFile1)); return false; } if (!outFile2.isEmpty() && !out.save(outFile2)) { fprintf(stderr, "Unable to write %s\n", qPrintable(outFile2)); return false; } return true; }
QPixmap QSvgIconEngine::pixmap(const QSize &size, QIcon::Mode mode, QIcon::State state) { QPixmap pm; QString pmckey(d->pmcKey(size, mode, state)); if (QPixmapCache::find(pmckey, pm)) return pm; if (d->addedPixmaps) { pm = d->addedPixmaps->value(d->hashKey(mode, state)); if (!pm.isNull() && pm.size() == size) return pm; } QSvgRenderer renderer; d->loadDataForModeAndState(&renderer, mode, state); if (!renderer.isValid()) return pm; QSize actualSize = renderer.defaultSize(); if (!actualSize.isNull()) actualSize.scale(size, Qt::KeepAspectRatio); QImage img(actualSize, QImage::Format_ARGB32_Premultiplied); img.fill(0x00000000); QPainter p(&img); renderer.render(&p); p.end(); pm = QPixmap::fromImage(img); QStyleOption opt(0); opt.palette = QApplication::palette(); QPixmap generated = QApplication::style()->generatedIconPixmap(mode, pm, &opt); if (!generated.isNull()) pm = generated; if (!pm.isNull()) QPixmapCache::insert(pmckey, pm); return pm; }
QPixmap MIconEngine::pixmap(const QSize &size, QIcon::Mode mode, QIcon::State state) { QPixmap pm; QString pmckey(d->pmcKey(size, mode, state)); pmckey.prepend("Ms"); if (QPixmapCache::find(pmckey, pm)) return pm; if (d->addedPixmaps) { pm = d->addedPixmaps->value(d->hashKey(mode, state)); if (!pm.isNull() && pm.size() == size) return pm; } QSvgRenderer renderer; d->loadDataForModeAndState(&renderer, mode, state); if (!renderer.isValid()) return pm; QSize actualSize = renderer.defaultSize(); if (!actualSize.isNull()) actualSize.scale(size, Qt::KeepAspectRatio); // Generate an image of the requested size, but render the // the SVG with the correct aspect ratio centered in the image // to prevent scaling issues when setting non square icon size. QImage img(size, QImage::Format_ARGB32); img.fill(0x00000000); QPainter p(&img); renderer.render(&p, getBounds(size, actualSize)); p.end(); pm = QPixmap::fromImage(img); if (!pm.isNull()) QPixmapCache::insert(pmckey, pm); return pm; }
void QStarPawn::paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget) { QGraphicsEllipseItem::paint(painter, option, widget); if (_isStarOn) { QSvgRenderer *renderer = new QSvgRenderer(QString(":/resources/star.svg")); QGraphicsSvgItem *star = new QGraphicsSvgItem(); star->setSharedRenderer(renderer); renderer->render(painter, boundingRect()); } }