DesktopBackgroundDialog::DesktopBackgroundDialog(RazorSettings * cfg, int screen, QSize desktopSize, const QBrush & brush, QWidget * parent)
: QDialog(parent),
m_desktopSize(desktopSize),
m_type(RazorWorkSpaceManager::BackgroundColor),
m_config(cfg),
m_screen(screen)
{
setupUi(this);
// center it to current desktop
move(parent->geometry().center() - geometry().center());
// read current wallpaper brush
if (brush.texture().isNull())
{
m_color = brush.color();
preview();
}
else
{
QPixmap p = brush.texture().scaled(previewLabel->size(), Qt::IgnoreAspectRatio, Qt::FastTransformation);
previewLabel->setPixmap(p);
}
connect(colorButton, SIGNAL(clicked()),
this, SLOT(colorButton_clicked()));
connect(wallpaperButton, SIGNAL(clicked()),
this, SLOT(wallpaperButton_clicked()));
connect(systemButton, SIGNAL(clicked()),
this, SLOT(systemButton_clicked()));
connect(keepAspectCheckBox, SIGNAL(toggled(bool)),
this, SLOT(preview()));
buttonBox->button(QDialogButtonBox::Ok)->setEnabled(false);
keepAspectCheckBox->setEnabled(false);
}
void createBrushNode( QDomDocument& doc, QDomNode& parent,
const QString& elementName, const QBrush& brush )
{
QDomElement brushElement = doc.createElement( elementName );
parent.appendChild( brushElement );
createColorNode( doc, brushElement, "Color", brush.color() );
createStringNode( doc, brushElement, "Style",
KDGanttXML::brushStyleToString( brush.style() ) );
if( brush.style() == Qt::TexturePattern && !brush.texture().isNull() )
createPixmapNode( doc, brushElement, "Pixmap", brush.texture() );
}
static inline void qwtFillRect( const QWidget *widget, QPainter *painter,
const QRect &rect, const QBrush &brush)
{
if ( brush.style() == Qt::TexturePattern )
{
painter->save();
painter->setClipRect( rect );
painter->drawTiledPixmap(rect, brush.texture(), rect.topLeft());
painter->restore();
}
else if ( brush.gradient() )
{
painter->save();
painter->setClipRect( rect );
painter->fillRect(0, 0, widget->width(),
widget->height(), brush);
painter->restore();
}
else
{
painter->fillRect(rect, brush);
}
}
bool QBrushPropertyItem::hasChildren()
{
if (!m_childrenSet)
{
m_childrenSet = true;
QBrush brush = qvariant_cast<QBrush>(m_metaProperty.read(m_parent->qObject()));
QPropertyItem* width = new QPropertyItem(brush.color(), "Color", this);
m_children.append(width);
connect(width, SIGNAL(valueChanged(const QString&, const QVariant&)), this,
SLOT(onChildItemValueChanged(const QString&, const QVariant&)));
int index = staticQtMetaObject.indexOfEnumerator("BrushStyle");
QMetaEnum enumeration = staticQtMetaObject.enumerator(index);
QChildEnumPropertyItem* brushStyle = new QChildEnumPropertyItem((int)brush.style(), "Brush Style",enumeration , this);
m_children.append(brushStyle);
connect(brushStyle, SIGNAL(valueChanged(const QString&, const QVariant&)), this,
SLOT(onChildItemValueChanged(const QString&, const QVariant&)));
QChildImagePropertyItem* textureImage = new QChildImagePropertyItem(brush.texture(), "Texture", this);
m_children.append(textureImage);
connect(textureImage, SIGNAL(valueChanged(const QString&, const QVariant&)), this,
SLOT(onChildItemValueChanged(const QString&, const QVariant&)));
return true;
}
void QBrushPropertyItem::setChildValues()
{
if (!m_isSettingChildren)
{
m_isSettingChildren = true;
QBrush brush = qvariant_cast<QBrush>(m_metaProperty.read(m_parent->qObject()));
for (int i = 0; i < m_children.count(); i++)
{
QPropertyItem* child = m_children[i];
QString propertyName = child->name();
QVariant tval;
if (propertyName == "Color")
{
tval = brush.color();
}
else if (propertyName == "Brush Style")
{
tval = (int)brush.style();
}
else if (propertyName == "Texture")
{
tval = brush.texture();
}
m_model->setData(child->index(), tval);
}
m_isSettingChildren = false;
}
}
QBrush DBrushAdjuster::mapBrush(const QBrush &brush, const QMatrix &matrix )
{
QBrush brush1(brush);
if(brush.gradient())
{
QGradient grad = DGradientAdjuster::mapGradient( brush.gradient(), matrix );
brush1 = QBrush(grad);
}
else if(!brush.texture().isNull())
{
QPixmap p(brush.texture());
p = p.transformed(matrix , Qt::SmoothTransformation );
brush1.setTexture( p );
}
return brush1;
}
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;
}
void ContactListView::paintEmptyArea( QPainter * p, const QRect & rect )
{
QBrush b = palette().brush(QPalette::Active, QPalette::Base);
// Get the brush, which will have the background pixmap if there is one.
if (!b.texture().isNull())
{
p->drawTiledPixmap( rect.left(), rect.top(), rect.width(), rect.height(),
b.texture(),
rect.left() + contentsX(),
rect.top() + contentsY() );
}
else
{
// Do a normal paint
K3ListView::paintEmptyArea(p, rect);
}
}
QBrush DBrushAdjuster::flipBrush(const QBrush &brush, Qt::Orientation o)
{
QBrush brush1(brush);
if(brush.gradient())
{
QGradient grad = DGradientAdjuster::flipGradient( brush.gradient(), o );
brush1 = QBrush(grad);
}
else if(!brush.texture().isNull())
{
}
return brush1;
}
/**
* Saves the brush info as xmi into the DOM element \a qElement.
*
* @param qDoc The QDomDocument object pointing to the xmi document.
*
* @param qElement The element into which the pen, brush and font
* info should be saved.
*
* @param brush The QBrush whose details should be saved.
*/
void saveBrushToXMI(QDomDocument &qDoc, QDomElement &qElement,
const QBrush& brush)
{
QDomElement brushElement = qDoc.createElement(QLatin1String("brush"));
brushElement.setAttribute(QLatin1String("style"), (quint8)brush.style());
brushElement.setAttribute(QLatin1String("color"), brush.color().name());
if(brush.style() == Qt::TexturePattern) {
savePixmapToXMI(qDoc, brushElement, brush.texture());
}
else if(brush.style() == Qt::LinearGradientPattern
|| brush.style() == Qt::RadialGradientPattern
|| brush.style() == Qt::ConicalGradientPattern) {
saveGradientToXMI(qDoc, brushElement, brush.gradient());
}
//TODO: Check if transform of this brush needs to be saved.
qElement.appendChild(brushElement);
}
void SheetDelegate::paint(QPainter *painter, const QStyleOptionViewItem &option, const QModelIndex &index) const
{
const QAbstractItemModel *model = index.model();
Q_ASSERT(model);
if (!model->parent(index).isValid()) {
// this is a top-level item.
QStyleOptionButton buttonOption;
buttonOption.state = option.state;
#ifdef Q_OS_MAC
buttonOption.state |= QStyle::State_Raised;
#endif
buttonOption.state &= ~QStyle::State_HasFocus;
buttonOption.rect = option.rect;
buttonOption.palette = option.palette;
buttonOption.features = QStyleOptionButton::None;
painter->save();
QColor buttonColor(230, 230, 230);
QBrush buttonBrush = option.palette.button();
if (!buttonBrush.gradient() && buttonBrush.texture().isNull())
buttonColor = buttonBrush.color();
QColor outlineColor = buttonColor.darker(150);
QColor highlightColor = buttonColor.lighter(130);
// Only draw topline if the previous item is expanded
QModelIndex previousIndex = model->index(index.row() - 1, index.column());
bool drawTopline = (index.row() > 0 && m_view->isExpanded(previousIndex));
int highlightOffset = drawTopline ? 1 : 0;
QLinearGradient gradient(option.rect.topLeft(), option.rect.bottomLeft());
gradient.setColorAt(0, buttonColor.lighter(102));
gradient.setColorAt(1, buttonColor.darker(106));
painter->setPen(Qt::NoPen);
painter->setBrush(gradient);
painter->drawRect(option.rect);
painter->setPen(highlightColor);
painter->drawLine(option.rect.topLeft() + QPoint(0, highlightOffset),
option.rect.topRight() + QPoint(0, highlightOffset));
painter->setPen(outlineColor);
if (drawTopline)
painter->drawLine(option.rect.topLeft(), option.rect.topRight());
painter->drawLine(option.rect.bottomLeft(), option.rect.bottomRight());
painter->restore();
QStyleOption branchOption;
static const int i = 9; // ### hardcoded in qcommonstyle.cpp
QRect r = option.rect;
branchOption.rect = QRect(r.left() + i/2, r.top() + (r.height() - i)/2, i, i);
branchOption.palette = option.palette;
branchOption.state = QStyle::State_Children;
if (m_view->isExpanded(index))
branchOption.state |= QStyle::State_Open;
m_view->style()->drawPrimitive(QStyle::PE_IndicatorBranch, &branchOption, painter, m_view);
// draw text
QRect textrect = QRect(r.left() + i*2, r.top(), r.width() - ((5*i)/2), r.height());
QString text = elidedText(option.fontMetrics, textrect.width(), Qt::ElideMiddle,
model->data(index, Qt::DisplayRole).toString());
m_view->style()->drawItemText(painter, textrect, Qt::AlignCenter,
option.palette, m_view->isEnabled(), text);
} else {
QItemDelegate::paint(painter, option, index);
}
}
//________________________________________________
void TransitionWidget::grabBackground( QPixmap& pixmap, QWidget* widget, QRect& rect ) const
{
if( !widget ) return;
QWidgetList widgets;
if( widget->autoFillBackground() )
{ widgets.append( widget ); }
QWidget *parent(0);
// get highest level parent
for( parent = widget->parentWidget(); parent; parent = parent->parentWidget() )
{
if( !( parent->isVisible() && parent->rect().isValid() ) ) continue;
// store in list
widgets.append( parent );
// stop at topLevel
if( parent->isTopLevel() || parent->autoFillBackground() ) break;
}
if( !parent ) parent = widget;
// painting
QPainter p(&pixmap);
p.setClipRect( rect );
const QBrush backgroundBrush = parent->palette().brush( parent->backgroundRole());
if( backgroundBrush.style() == Qt::TexturePattern)
{
p.drawTiledPixmap( rect, backgroundBrush.texture(), widget->mapTo( parent, rect.topLeft() ) );
} else {
p.fillRect( pixmap.rect(), backgroundBrush );
}
if( parent->isTopLevel() && parent->testAttribute(Qt::WA_StyledBackground))
{
QStyleOption option;
option.initFrom(parent);
option.rect = rect;
option.rect.translate( widget->mapTo( parent, rect.topLeft() ) );
p.translate(-option.rect.topLeft());
parent->style()->drawPrimitive ( QStyle::PE_Widget, &option, &p, parent );
p.translate(option.rect.topLeft());
}
// draw all widgets in parent list
// backward
QPaintEvent event(rect);
for( int i = widgets.size() - 1; i>=0; i-- )
{
QWidget* w = widgets.at(i);
w->render( &p, -widget->mapTo( w, rect.topLeft() ), rect, 0 );
}
// end
p.end();
}
void QBlitterPaintEngine::fillRect(const QRectF &rect, const QBrush &brush)
{
if (rect.size().isEmpty())
return;
Q_D(QBlitterPaintEngine);
if (qbrush_style(brush) == Qt::SolidPattern
&& d->caps.canBlitterAlphaFillRect()) {
d->fillRect(rect, qbrush_color(brush), true);
} else if (qbrush_style(brush) == Qt::SolidPattern
&& qbrush_color(brush).alpha() == 0xff
&& d->caps.canBlitterFillRect()) {
d->fillRect(rect, qbrush_color(brush), false);
} else if ((brush.style() == Qt::TexturePattern) &&
(brush.transform().type() <= QTransform::TxTranslate) &&
((d->caps.canBlitterDrawPixmapOpacity(brush.texture())) ||
(d->caps.canBlitterDrawPixmap(rect, brush.texture(), rect)))) {
bool rectIsFilled = false;
QRectF transformedRect = state()->matrix.mapRect(rect);
qreal x = transformedRect.x();
qreal y = transformedRect.y();
QPixmap pm = brush.texture();
d->unlock();
int srcX = int(rect.x() - state()->brushOrigin.x() - brush.transform().dx()) % pm.width();
if (srcX < 0)
srcX = pm.width() + srcX;
const int startX = srcX;
int srcY = int(rect.y() - state()->brushOrigin.y() - brush.transform().dy()) % pm.height();
if (srcY < 0)
srcY = pm.height() + srcY;
while (!rectIsFilled) {
qreal blitWidth = (pm.width() ) - srcX;
qreal blitHeight = (pm.height() ) - srcY;
if (x + blitWidth > transformedRect.right())
blitWidth = transformedRect.right() -x;
if (y + blitHeight > transformedRect.bottom())
blitHeight = transformedRect.bottom() - y;
const QClipData *clipData = d->clip();
if (clipData->hasRectClip) {
QRect targetRect = QRect(x, y, blitWidth, blitHeight).intersected(clipData->clipRect);
if (targetRect.isValid()) {
int tmpSrcX = srcX + (targetRect.x() - x);
int tmpSrcY = srcY + (targetRect.y() - y);
QRect srcRect(tmpSrcX, tmpSrcY, targetRect.width(), targetRect.height());
d->pmData->blittable()->drawPixmap(targetRect, pm, srcRect);
}
} else if (clipData->hasRegionClip) {
QVector<QRect> clipRects = clipData->clipRegion.rects();
QRect unclippedTargetRect(x, y, blitWidth, blitHeight);
QRegion intersectedRects = clipData->clipRegion.intersected(unclippedTargetRect);
for (int i = 0; i < intersectedRects.rects().size(); ++i) {
QRect targetRect = intersectedRects.rects().at(i);
if (!targetRect.isValid() || targetRect.isEmpty())
continue;
int tmpSrcX = srcX + (targetRect.x() - x);
int tmpSrcY = srcY + (targetRect.y() - y);
QRect srcRect(tmpSrcX, tmpSrcY, targetRect.width(), targetRect.height());
d->pmData->blittable()->drawPixmap(targetRect, pm, srcRect);
}
}
x+=blitWidth;
if (qFuzzyCompare(x, transformedRect.right())) {
x = transformedRect.x();
srcX = startX;
srcY = 0;
y += blitHeight;
if (qFuzzyCompare(y, transformedRect.bottom()))
rectIsFilled = true;
} else
srcX = 0;
}
} else {
d->lock();
d->pmData->markRasterOverlay(rect);
QRasterPaintEngine::fillRect(rect, brush);
}
}
ComPtr<ID2D1Brush> to_d2d_brush(const QBrush &newBrush, bool *needsEmulation)
{
HRESULT hr;
ComPtr<ID2D1Brush> result;
Q_ASSERT(needsEmulation);
*needsEmulation = false;
switch (newBrush.style()) {
case Qt::NoBrush:
break;
case Qt::SolidPattern:
{
ComPtr<ID2D1SolidColorBrush> solid;
hr = dc()->CreateSolidColorBrush(to_d2d_color_f(newBrush.color()), &solid);
if (FAILED(hr)) {
qWarning("%s: Could not create solid color brush: %#x", __FUNCTION__, hr);
break;
}
hr = solid.As(&result);
if (FAILED(hr))
qWarning("%s: Could not convert solid color brush: %#x", __FUNCTION__, hr);
}
break;
case Qt::Dense1Pattern:
case Qt::Dense2Pattern:
case Qt::Dense3Pattern:
case Qt::Dense4Pattern:
case Qt::Dense5Pattern:
case Qt::Dense6Pattern:
case Qt::Dense7Pattern:
case Qt::HorPattern:
case Qt::VerPattern:
case Qt::CrossPattern:
case Qt::BDiagPattern:
case Qt::FDiagPattern:
case Qt::DiagCrossPattern:
{
ComPtr<ID2D1BitmapBrush1> bitmapBrush;
D2D1_BITMAP_BRUSH_PROPERTIES1 bitmapBrushProperties = {
D2D1_EXTEND_MODE_WRAP,
D2D1_EXTEND_MODE_WRAP,
interpolationMode()
};
QImage brushImg = qt_imageForBrush(newBrush.style(), false);
brushImg.setColor(0, newBrush.color().rgba());
brushImg.setColor(1, qRgba(0, 0, 0, 0));
QWindowsDirect2DBitmap bitmap;
bool success = bitmap.fromImage(brushImg, Qt::AutoColor);
if (!success) {
qWarning("%s: Could not create Direct2D bitmap from Qt pattern brush image", __FUNCTION__);
break;
}
hr = dc()->CreateBitmapBrush(bitmap.bitmap(),
bitmapBrushProperties,
&bitmapBrush);
if (FAILED(hr)) {
qWarning("%s: Could not create Direct2D bitmap brush for Qt pattern brush: %#x", __FUNCTION__, hr);
break;
}
hr = bitmapBrush.As(&result);
if (FAILED(hr))
qWarning("%s: Could not convert Direct2D bitmap brush for Qt pattern brush: %#x", __FUNCTION__, hr);
}
break;
case Qt::LinearGradientPattern:
case Qt::RadialGradientPattern:
case Qt::ConicalGradientPattern:
*needsEmulation = true;
break;
case Qt::TexturePattern:
{
ComPtr<ID2D1BitmapBrush1> bitmapBrush;
D2D1_BITMAP_BRUSH_PROPERTIES1 bitmapBrushProperties = {
D2D1_EXTEND_MODE_WRAP,
D2D1_EXTEND_MODE_WRAP,
interpolationMode()
};
QWindowsDirect2DPlatformPixmap *pp = static_cast<QWindowsDirect2DPlatformPixmap *>(newBrush.texture().handle());
QWindowsDirect2DBitmap *bitmap = pp->bitmap();
hr = dc()->CreateBitmapBrush(bitmap->bitmap(),
bitmapBrushProperties,
&bitmapBrush);
if (FAILED(hr)) {
qWarning("%s: Could not create texture brush: %#x", __FUNCTION__, hr);
break;
}
hr = bitmapBrush.As(&result);
if (FAILED(hr))
qWarning("%s: Could not convert texture brush: %#x", __FUNCTION__, hr);
}
break;
}
if (result && !newBrush.transform().isIdentity())
result->SetTransform(to_d2d_matrix_3x2_f(newBrush.transform()));
return result;
}
HBRUSH EmfPaintEngine::convertBrush(const QBrush& brush)
{
LOGBRUSH lbrush = {BS_NULL, 0, 0};
if (!brush.color().alpha())
return CreateBrushIndirect( &lbrush );
if (brush.color().alpha() < 255){//semi-transparent brush color
qWarning ("Semi-transparent brushes are not supported by EmfEngine.");
#ifdef Q_WS_WIN
QPixmap pix(4, 4);
pix.fill(Qt::white);
QPainter p;
p.begin(&pix);
p.setPen(QPen(Qt::NoPen));
p.setBrush(brush);
p.drawRect(QRect(0, 0, 4, 4));
p.end();
HBITMAP hBmp = pix.toWinHBITMAP();
HBRUSH wbrush = CreatePatternBrush(hBmp);
DeleteObject(hBmp);
return wbrush;
#endif
}
LONG lbHatch = HS_HORIZONTAL;
UINT lbStyle = BS_HATCHED;
switch(brush.style()){
case Qt::NoBrush:
lbStyle = BS_NULL;
break;
case Qt::SolidPattern:
lbStyle = BS_SOLID;
break;
case Qt::Dense1Pattern:
case Qt::Dense2Pattern:
case Qt::Dense3Pattern:
case Qt::Dense4Pattern:
case Qt::Dense5Pattern:
case Qt::Dense6Pattern:
case Qt::Dense7Pattern:
{
#ifdef Q_WS_WIN
QPixmap pix(4, 4);
pix.fill(Qt::white);
QPainter p;
p.begin(&pix);
p.setPen(QPen(Qt::NoPen));
p.setBrush(brush);
p.drawRect(QRect(0, 0, 4, 4));
p.end();
HBITMAP hbm = pix.toWinHBITMAP();
HBRUSH wbrush = CreatePatternBrush(hbm);
DeleteObject(hbm);
return wbrush;
#endif
}
break;
case Qt::HorPattern:
break;
case Qt::VerPattern:
lbHatch = HS_VERTICAL;
break;
case Qt::CrossPattern:
lbHatch = HS_CROSS;
break;
case Qt::BDiagPattern:
lbHatch = HS_BDIAGONAL;
break;
case Qt::FDiagPattern:
lbHatch = HS_FDIAGONAL;
break;
case Qt::DiagCrossPattern:
lbHatch = HS_DIAGCROSS;
break;
case Qt::LinearGradientPattern:
{
qWarning("EmfEngine: Qt::LinearGradientPattern is not supported.");
return CreateBrushIndirect( &lbrush );
}
break;
case Qt::ConicalGradientPattern:
{
qWarning("EmfEngine: Qt::ConicalGradientPattern is not supported.");
return CreateBrushIndirect( &lbrush );
}
break;
case Qt::RadialGradientPattern:
{
qWarning("EmfEngine: Qt::RadialGradientPattern is not supported.");
return CreateBrushIndirect( &lbrush );
}
case Qt::TexturePattern:
#ifdef Q_WS_WIN
{
HBITMAP hbm = brush.texture().toWinHBITMAP();
HBRUSH wbrush = CreatePatternBrush(hbm);
DeleteObject(hbm);
return wbrush;
}
#endif
break;
default:
lbStyle = BS_SOLID;
break;
}
LOGBRUSH logbrush = {lbStyle, RGB(brush.color().red(), brush.color().green(), brush.color().blue()), lbHatch};
return CreateBrushIndirect( &logbrush );
}
