/*!
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());
}
}
