void Tab::paintEvent(QPaintEvent *event) { Q_UNUSED(event) QPainter painter(this); painter.setRenderHint(QPainter::Antialiasing); QBrush brush; brush.setStyle(Qt::SolidPattern); brush.setColor(backgroundColor()); painter.setOpacity(1); painter.setBrush(brush); painter.setPen(Qt::NoPen); painter.drawRect(rect()); paintHalo(&painter); QStylePainter style(this); if (!icon().isNull()) { style.translate(0, 12); } QStyleOptionButton option; initStyleOption(&option); option.features |= QStyleOptionButton::Flat; option.iconSize = QSize(-1, -1); // Prevent icon from being drawn twice style.drawControl(QStyle::CE_PushButtonLabel, option); if (!icon().isNull()) { const QSize &size = iconSize(); QRect iconRect(QPoint((width()-size.width())/2, 0), size); icon().paint(&painter, iconRect, Qt::AlignCenter, QIcon::Normal); } if (!_active) { QColor overlayColor = backgroundColor(); overlayColor.setAlphaF(0.36); QBrush overlay; overlay.setStyle(Qt::SolidPattern); overlay.setColor(overlayColor); painter.fillRect(rect(), overlay); } #ifdef DEBUG_LAYOUT QPainter debug(this); QPen pen; pen.setColor(Qt::red); pen.setWidth(2); debug.setPen(pen); debug.setBrush(Qt::NoBrush); debug.drawRect(rect()); #endif }
static void drawSelectionSquare( QPainter* painter, const QRect& rect, const QBrush& brush ) { painter->save(); painter->setPen( QPen( brush.color().darker(), 1 ) ); QColor highlightColor = QPalette().highlight().color(); highlightColor = highlightColor.lighter( 500 ); highlightColor.setAlpha( 120 ); painter->setBrush( highlightColor ); painter->translate( .5, .5 ); painter->drawRoundedRect( rect.adjusted( 0, 0, -1, -1 ), CORNER_RADIUS, CORNER_RADIUS ); painter->translate( -.5, -.5 ); painter->restore(); }
void FrameLoaderClientQt::transitionToCommittedForNewPage() { ASSERT(m_frame); ASSERT(m_webFrame); QBrush brush = m_webFrame->page()->palette().brush(QPalette::Base); QColor backgroundColor = brush.style() == Qt::SolidPattern ? brush.color() : QColor(); QWebPage* page = m_webFrame->page(); const QSize preferredLayoutSize = page->preferredContentsSize(); ScrollbarMode hScrollbar = (ScrollbarMode) m_webFrame->scrollBarPolicy(Qt::Horizontal); ScrollbarMode vScrollbar = (ScrollbarMode) m_webFrame->scrollBarPolicy(Qt::Vertical); bool hLock = hScrollbar != ScrollbarAuto; bool vLock = vScrollbar != ScrollbarAuto; m_frame->createView(m_webFrame->page()->viewportSize(), backgroundColor, !backgroundColor.alpha(), preferredLayoutSize.isValid() ? IntSize(preferredLayoutSize) : IntSize(), preferredLayoutSize.isValid(), hScrollbar, hLock, vScrollbar, vLock); }
// --------------------------------------------------------------------- bool SymbolWidget::getBrush(const QString& s, QBrush& Brush, int i) { bool ok; QString n; n = s.section(' ',i,i); // fill color QColor co; co.setNamedColor(n); Brush.setColor(co); if(!Brush.color().isValid()) return false; i++; n = s.section(' ',i,i); // fill style Brush.setStyle((Qt::BrushStyle)n.toInt(&ok)); if(!ok) return false; i++; n = s.section(' ',i,i); // filled if(n.toInt(&ok) == 0) Brush.setStyle(Qt::NoBrush); if(!ok) return false; return true; }
void koregui::ShaderInputItem::paint(QPainter* painter, const QStyleOptionGraphicsItem* option, QWidget* widget) { QPen p; p.setColor(QColor(44,44,44)); p.setWidth(2); QBrush b; switch(_input->type) { case GL_FLOAT_MAT4: b.setColor(Qt::GlobalColor::green); break; default : b.setColor(Qt::GlobalColor::red); } b.setStyle(Qt::BrushStyle::SolidPattern); painter->setBrush(b); painter->setPen(p); if(_mouseover) { painter->drawRect(-2, -2, 16, 16); } else { painter->drawRect(0, 0, 12, 12); } }
void BitmapImage::drawEllipse(QRectF rectangle, QPen pen, QBrush brush, QPainter::CompositionMode cm, bool antialiasing) { int width = pen.width(); setCompositionModeBounds(rectangle.adjusted(-width, -width, width, width).toRect(), true, cm); if (brush.style() == Qt::RadialGradientPattern) { QRadialGradient* gradient = (QRadialGradient*)brush.gradient(); gradient->setCenter(gradient->center() - mBounds.topLeft()); gradient->setFocalPoint(gradient->focalPoint() - mBounds.topLeft()); } if (!image()->isNull()) { QPainter painter(image()); painter.setRenderHint(QPainter::Antialiasing, antialiasing); painter.setPen(pen); painter.setBrush(brush); painter.setCompositionMode(cm); painter.drawEllipse(rectangle.translated(-mBounds.topLeft())); painter.end(); } modification(); }
void fillOpaqueRect(QPainter *painter, const QRect &rect, const QBrush &brush) { if (!brush.isOpaque()) { QPixmap chessboardPattern(16, 16); QPainter patternPainter(&chessboardPattern); patternPainter.fillRect(0, 0, 8, 8, Qt::black); patternPainter.fillRect(8, 8, 8, 8, Qt::black); patternPainter.fillRect(0, 8, 8, 8, Qt::white); patternPainter.fillRect(8, 0, 8, 8, Qt::white); patternPainter.end(); painter->fillRect(rect, QBrush(chessboardPattern)); } painter->fillRect(rect, brush); }
void TargetList::editRow(int row, QString fileName, QString name, QString coordinates, QString description) { // Creates image preview item QBrush brush; QImage brushImage; if (fileName == "") brushImage.load(defaultImagePath); else brushImage.load(fileName); // Resize image int width = 100; int height = 100; QImage scaledBrushImage = brushImage.scaled(width, height, Qt::IgnoreAspectRatio); // Apply resized image brush.setTextureImage(scaledBrushImage); rows->at(row)->image->setBackground(brush); rows->at(row)->name->setText(name); rows->at(row)->coord->setText(coordinates); rows->at(row)->desc->setText(description); refreshTable(); }
void QQuickTextNodeEngine::addBorder(const QRectF &rect, qreal border, QTextFrameFormat::BorderStyle borderStyle, const QBrush &borderBrush) { QColor color = borderBrush.color(); // Currently we don't support other styles than solid Q_UNUSED(borderStyle); m_backgrounds.append(qMakePair(QRectF(rect.left(), rect.top(), border, rect.height() + border), color)); m_backgrounds.append(qMakePair(QRectF(rect.left() + border, rect.top(), rect.width(), border), color)); m_backgrounds.append(qMakePair(QRectF(rect.right(), rect.top() + border, border, rect.height() - border), color)); m_backgrounds.append(qMakePair(QRectF(rect.left() + border, rect.bottom(), rect.width(), border), color)); }
void MythRenderOpenGL1::DrawRectPriv(const QRect &area, const QBrush &fillBrush, const QPen &linePen, int alpha) { SetBlend(true); DisableTextures(); EnableShaderObject(0); glEnableClientState(GL_VERTEX_ARRAY); int lineWidth = linePen.width(); QRect r(area.left() + lineWidth, area.top() + lineWidth, area.width() - (lineWidth * 2), area.height() - (lineWidth * 2)); if (fillBrush.style() != Qt::NoBrush) { int a = 255 * (((float)alpha / 255.0f) * ((float)fillBrush.color().alpha() / 255.0f)); SetColor(fillBrush.color().red(), fillBrush.color().green(), fillBrush.color().blue(), a); GLfloat *vertices = GetCachedVertices(GL_TRIANGLE_STRIP, r); glVertexPointer(2, GL_FLOAT, 0, vertices); glDrawArrays(GL_TRIANGLE_STRIP, 0, 4); } if (linePen.style() != Qt::NoPen) { int a = 255 * (((float)alpha / 255.0f) * ((float)linePen.color().alpha() / 255.0f)); SetColor(linePen.color().red(), linePen.color().green(), linePen.color().blue(), a); glLineWidth(linePen.width()); GLfloat *vertices = GetCachedVertices(GL_LINE_LOOP, r); glVertexPointer(2, GL_FLOAT, 0, vertices); glDrawArrays(GL_LINE_LOOP, 0, 4); } glDisableClientState(GL_VERTEX_ARRAY); }
void QgsComposerUtils::drawArrowHead( QPainter *p, const double x, const double y, const double angle, const double arrowHeadWidth ) { if ( !p ) { return; } double angleRad = angle / 180.0 * M_PI; QPointF middlePoint( x, y ); //rotate both arrow points QPointF p1 = QPointF( -arrowHeadWidth / 2.0, arrowHeadWidth ); QPointF p2 = QPointF( arrowHeadWidth / 2.0, arrowHeadWidth ); QPointF p1Rotated, p2Rotated; p1Rotated.setX( p1.x() * cos( angleRad ) + p1.y() * -sin( angleRad ) ); p1Rotated.setY( p1.x() * sin( angleRad ) + p1.y() * cos( angleRad ) ); p2Rotated.setX( p2.x() * cos( angleRad ) + p2.y() * -sin( angleRad ) ); p2Rotated.setY( p2.x() * sin( angleRad ) + p2.y() * cos( angleRad ) ); QPolygonF arrowHeadPoly; arrowHeadPoly << middlePoint; arrowHeadPoly << QPointF( middlePoint.x() + p1Rotated.x(), middlePoint.y() + p1Rotated.y() ); arrowHeadPoly << QPointF( middlePoint.x() + p2Rotated.x(), middlePoint.y() + p2Rotated.y() ); p->save(); QPen arrowPen = p->pen(); arrowPen.setJoinStyle( Qt::RoundJoin ); QBrush arrowBrush = p->brush(); arrowBrush.setStyle( Qt::SolidPattern ); p->setPen( arrowPen ); p->setBrush( arrowBrush ); arrowBrush.setStyle( Qt::SolidPattern ); p->drawPolygon( arrowHeadPoly ); p->restore(); }
void CanvasStyle::applyFillColor(GraphicsContext* context) const { if (!context) return; switch (m_type) { case RGBA: context->setFillColor(m_rgba, ColorSpaceDeviceRGB); break; case CMYKA: { // FIXME: Do this through platform-independent GraphicsContext API. // We'll need a fancier Color abstraction to support CMYKA correctly #if USE(CG) CGContextSetCMYKFillColor(context->platformContext(), m_cmyka->c, m_cmyka->m, m_cmyka->y, m_cmyka->k, m_cmyka->a); #elif PLATFORM(QT) QBrush currentBrush = context->platformContext()->brush(); QColor clr; clr.setCmykF(m_cmyka->c, m_cmyka->m, m_cmyka->y, m_cmyka->k, m_cmyka->a); currentBrush.setColor(clr); context->platformContext()->setBrush(currentBrush); #else context->setFillColor(m_cmyka->rgba, ColorSpaceDeviceRGB); #endif break; } case Gradient: context->setFillGradient(canvasGradient()->gradient()); break; case ImagePattern: context->setFillPattern(canvasPattern()->pattern()); break; case CurrentColor: case CurrentColorWithOverrideAlpha: case Invalid: ASSERT_NOT_REACHED(); break; } }
void WaveDisplay::paintEvent( QPaintEvent *ev ) { UNUSED(ev); QPainter painter( this ); painter.setRenderHint( QPainter::Antialiasing ); QBrush brush = QBrush(Qt::red, m_Background); brush.setStyle(Qt::TexturePattern); painter.setBrush(brush); painter.drawRect(0, 0, width(), height()); if( m_pLayer ){ painter.setPen( QColor( 102, 150, 205 ) ); int VCenter = height() / 2; for ( int x = 0; x < width(); x++ ) { painter.drawLine( x, VCenter, x, m_pPeakData[x] + VCenter ); painter.drawLine( x, VCenter, x, -m_pPeakData[x] + VCenter ); } } QFont font; font.setWeight( 63 ); painter.setFont( font ); painter.setPen( QColor( 255 , 255, 255, 200 ) ); if( m_SampleNameAlignment == Qt::AlignCenter ){ painter.drawText( 0, 0, width(), 20, m_SampleNameAlignment, m_sSampleName ); } else if( m_SampleNameAlignment == Qt::AlignLeft ) { // Use a small offnset iso. starting directly at the left border painter.drawText( 20, 0, width(), 20, m_SampleNameAlignment, m_sSampleName ); } }
MainWindow::MainWindow() { /* Create a pen object for the line item. */ QPen pen; pen.setStyle(Qt::DashDotLine); // use dash-do-line style : "-.--" pen.setWidth(3); pen.setBrush(Qt::green); // use Green color pen.setCapStyle(Qt::RoundCap); // set round style of end points of line. m_view = new QGraphicsView(this); this->setCentralWidget(m_view); // Add the view object into main window. QObject::connect(&m_timeLine, SIGNAL(frameChanged(int)), this, SLOT(animate(int))); m_timeLine.setDuration(5000); // 5 seconds m_timeLine.setFrameRange(0, 100); m_timeLine.setCurveShape(QTimeLine::LinearCurve); // set the velocity change mode of animation m_scene.addText("Hello, world!")->setPos(5.0, 5.0); // Create a Text item. QGraphicsLineItem *line = m_scene.addLine(10, 90, 250, 250, pen); // Create a Line item. m_rect_x = START_X; m_rect_y = START_Y; m_rect = m_scene.addRect(QRectF(m_rect_x, m_rect_y, 50, 50)); // Create a Rectangle item. /* Create a brush object to paint the Rectangle item. */ QBrush brush; brush.setColor(Qt::darkGray); brush.setStyle(Qt::SolidPattern); m_rect->setBrush(brush); /* Set the Rectangle's opacity */ m_opacity = 1; m_rect->setOpacity(m_opacity); m_view->setScene(&m_scene); // Add scene into the view object m_timeLine.start(); }
//! [0] void NorwegianWoodStyle::polish(QPalette &palette) { QColor brown(212, 140, 95); QColor beige(236, 182, 120); QColor slightlyOpaqueBlack(0, 0, 0, 63); QPixmap backgroundImage(":/images/woodbackground.png"); QPixmap buttonImage(":/images/woodbutton.png"); QPixmap midImage = buttonImage; QPainter painter; painter.begin(&midImage); painter.setPen(Qt::NoPen); painter.fillRect(midImage.rect(), slightlyOpaqueBlack); painter.end(); //! [0] //! [1] palette = QPalette(brown); palette.setBrush(QPalette::BrightText, Qt::white); palette.setBrush(QPalette::Base, beige); palette.setBrush(QPalette::Highlight, Qt::darkGreen); setTexture(palette, QPalette::Button, buttonImage); setTexture(palette, QPalette::Mid, midImage); setTexture(palette, QPalette::Window, backgroundImage); QBrush brush = palette.background(); brush.setColor(brush.color().dark()); palette.setBrush(QPalette::Disabled, QPalette::WindowText, brush); palette.setBrush(QPalette::Disabled, QPalette::Text, brush); palette.setBrush(QPalette::Disabled, QPalette::ButtonText, brush); palette.setBrush(QPalette::Disabled, QPalette::Base, brush); palette.setBrush(QPalette::Disabled, QPalette::Button, brush); palette.setBrush(QPalette::Disabled, QPalette::Mid, brush); }
void DiagramSettings::Private::changeBackgroundColor() { if ( m_chart && m_chart->coordinatePlane() && m_chart->coordinatePlane()->diagram() ) { BackgroundAttributes bat = m_chart->coordinatePlane()->backgroundAttributes(); bat.setVisible( true ); ui->visibleBtn->setChecked( true ); if ( ui->color->isChecked() ) { QBrush setBrush = bat.brush(); const QColor color = QColorDialog::getColor( setBrush.color(), qq, tr( "Choose new color" ) ); if ( !color.isValid() ) return; bat.setBrush( color ); QPalette palette = ui->diagramBackground->palette(); palette.setBrush( QPalette::Button, color ); ui->diagramBackground->setPalette( palette ); } else if ( ui->textureBtn->isChecked() ) { //QBrush setBrush = m_chart->coordinatePlane()->diagram()->brush( index ); QImage texture; const QString filename = QFileDialog::getOpenFileName( qq, tr( "Choose Texture" ), QString(), tr( "Images (*.png *.xpm *.jpg)" ) ); if ( filename.isEmpty() ) return; texture = QImage( filename ); bat.setBrush( texture ); QPalette palette = ui->diagramBackground->palette(); palette.setBrush( QPalette::Button, QBrush( texture ) ); ui->diagramBackground->setPalette( palette ); } else { QBrush setBrush = bat.brush(); QGradient grad; QLinearGradient lGrad; lGrad.setColorAt( 0, Qt::black ); lGrad.setColorAt( 1, setBrush.color() ); grad = lGrad; if ( setBrush.gradient() ) grad = *setBrush.gradient(); const QGradient &color = GradientDialog::getGradient( grad, qq, tr( "Choose new color" ) ); bat.setBrush( color ); QPalette palette = ui->diagramBackground->palette(); palette.setBrush( QPalette::Button, QBrush( color ) ); ui->diagramBackground->setPalette( palette ); } bat.setVisible( true ); m_chart->coordinatePlane()->setBackgroundAttributes( bat ); qq->update(); } }
DesktopBackgroundDialog::DesktopBackgroundDialog(RazorSettings * cfg, int screen, int desktop, QSize desktopSize, const QBrush & brush, QWidget * parent) : QDialog(parent), m_desktopSize(desktopSize), m_type(RazorWorkSpaceManager::BackgroundColor), m_config(cfg), m_screen(screen), m_desktop(desktop) { 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 mainWidget::paintEvent(QPaintEvent *) { QBitmap bitmap(this->size()); bitmap.fill(); QPainter painter(&bitmap); painter.setBrush(QBrush(Qt::black)); painter.drawRoundedRect(bitmap.rect(),5,5); setMask(bitmap); QPixmap pixmap(this->size()); pixmap.fill(); painter.end(); painter.begin(&pixmap); painter.setRenderHints(QPainter::Antialiasing,true); QBrush brush; brush.setStyle(Qt::TexturePattern); brush.setTextureImage(QImage(bkPicName)); painter.setBrush(brush); painter.setPen(Qt::black); painter.drawRoundedRect(rect(),5,5); painter.end(); painter.begin(this); painter.drawPixmap(this->rect(),pixmap); }
QString KoOdfGraphicStyles::saveOdfHatchStyle(KoGenStyles& mainStyles, const QBrush &brush) { KoGenStyle hatchStyle(KoGenStyle::HatchStyle /*no family name*/); hatchStyle.addAttribute("draw:color", brush.color().name()); //hatchStyle.addAttribute( "draw:distance", m_distance ); not implemented into kpresenter switch (brush.style()) { case Qt::HorPattern: hatchStyle.addAttribute("draw:style", "single"); hatchStyle.addAttribute("draw:rotation", 0); break; case Qt::BDiagPattern: hatchStyle.addAttribute("draw:style", "single"); hatchStyle.addAttribute("draw:rotation", 450); break; case Qt::VerPattern: hatchStyle.addAttribute("draw:style", "single"); hatchStyle.addAttribute("draw:rotation", 900); break; case Qt::FDiagPattern: hatchStyle.addAttribute("draw:style", "single"); hatchStyle.addAttribute("draw:rotation", 1350); break; case Qt::CrossPattern: hatchStyle.addAttribute("draw:style", "double"); hatchStyle.addAttribute("draw:rotation", 0); break; case Qt::DiagCrossPattern: hatchStyle.addAttribute("draw:style", "double"); hatchStyle.addAttribute("draw:rotation", 450); break; default: break; } return mainStyles.insert(hatchStyle, "hatch"); }
/* * Configures display properties of the List view attached to this model */ QVariant ActivityModel::data(const QModelIndex &index, int role) const { switch (role) { case Qt::DisplayRole: if (!index.isValid()) { return QVariant(); } if (index.row() >= string_list_.size()) { return QVariant(); } return string_list_.at(index.row()); break; case Qt::TextAlignmentRole: if (index.row() == tag_row_ && index.column() == 0) { return Qt::AlignCenter; } break; case Qt::FontRole: if (index.row() == tag_row_ && index.column() == 0) { QFont font; font.setItalic(true); return font; } break; case Qt::ForegroundRole: QBrush text; if (index.row() == 0) { text.setColor(Qt::gray); return text; } break; } return QVariant(); }
QVariant AttributesModel::defaultHeaderData( int section, Qt::Orientation orientation, int role ) const { // Default values if nothing else matches const int dataset = section / d->dataDimension; switch ( role ) { case Qt::DisplayRole: //TODO for KChart 3.0: return QString::number( dataset + 1 ); return QVariant( (orientation == Qt::Vertical ? QStringLiteral("Series ") : QStringLiteral("Item ")) + QString::number( dataset )) ; case KChart::DatasetBrushRole: return d->palette.getBrush( dataset ); case KChart::DatasetPenRole: // if no per model override was set, use the (possibly default) color set for the brush if ( !modelData( role ).isValid() ) { QBrush brush = headerData( section, orientation, DatasetBrushRole ).value< QBrush >(); return QPen( brush.color() ); } default: break; } return QVariant(); }
/*! Fill the area between the curve and the baseline with the curve brush \param painter Painter \param xMap x map \param yMap y map \param pa Polygon \sa setBrush(), setBaseline(), setCurveType() */ void QwtPlotCurve::fillCurve(QPainter *painter, const QwtScaleMap &xMap, const QwtScaleMap &yMap, QwtPolygon &pa) const { if ( d_data->brush.style() == Qt::NoBrush ) return; closePolyline(xMap, yMap, pa); if ( pa.count() <= 2 ) // a line can't be filled return; QBrush b = d_data->brush; if ( !b.color().isValid() ) b.setColor(d_data->pen.color()); painter->save(); painter->setPen(QPen(Qt::NoPen)); painter->setBrush(b); QwtPainter::drawPolygon(painter, pa); painter->restore(); }
void QEmulationPaintEngine::stroke(const QVectorPath &path, const QPen &pen) { QPainterState *s = state(); if (s->bgMode == Qt::OpaqueMode && pen.style() > Qt::SolidLine) { QPen bgPen = pen; bgPen.setBrush(s->bgBrush); bgPen.setStyle(Qt::SolidLine); real_engine->stroke(path, bgPen); } QBrush brush = pen.brush(); Qt::BrushStyle style = qbrush_style(brush); if (style >= Qt::LinearGradientPattern && style <= Qt::ConicalGradientPattern) { const QGradient *g = brush.gradient(); if (g->coordinateMode() > QGradient::LogicalMode) { QPaintEngineEx::stroke(path, pen); return; } } real_engine->stroke(path, pen); }
QPixmap KisLightSource::createBackground() { QPen pen; QBrush brush; QPixmap harhar(m_icondiameter, m_icondiameter); harhar.fill(QColor(0,0,0,0)); QPainter painter(&harhar); painter.setBackgroundMode(Qt::TransparentMode); painter.setRenderHint(QPainter::Antialiasing, 0x08); pen.setWidth(1); pen.setColor(QColor(0, 0, 0, 150)); brush.setStyle(Qt::SolidPattern); brush.setColor(m_color); painter.setBrush(brush); painter.setPen(pen); painter.drawEllipse(1, 1, m_icondiameter-2, m_icondiameter-2); return harhar; }
subObservationVisualiserBase::subObservationVisualiserBase(const context& contextObj, float pointSize) :pointSize(pointSize), contextObj(contextObj),standardPointsItem(NULL), standardLinesItem(NULL), backgroundItem(NULL) { //We don't run this if there are no vertex positions if(contextObj.getVertexPositions().size() == 0) { std::cout << "Specified graph did not have vertex positions, exiting..." << std::endl; QTimer::singleShot(0, this, SLOT(close())); return; } initialiseControls(); QPen pen(Qt::NoPen); QColor grey("grey"); grey.setAlphaF(0.5); QBrush brush; brush.setColor(grey); brush.setStyle(Qt::SolidPattern); backgroundItem = new QGraphicsRectItem(minX, minY, maxX - minX, maxY - minY, NULL); backgroundItem->setPen(pen); backgroundItem->setBrush(brush); backgroundItem->setZValue(-1); graphicsScene->addItem(backgroundItem); }
ColorSchemePrivate::ColorSchemePrivate(QPalette::ColorGroup state, const char* group, SetDefaultColors defaults, const QBrush& tint) { _contrast = 1.0; // KGlobalSettings::contrastF( config ); // loaded-from-config colors _brushes.bg[0] = SET_DEFAULT(NormalBackground); _brushes.bg[1] = SET_DEFAULT(AlternateBackground); // adjustment _brushes.bg[0] = ColorUtils::tint(_brushes.bg[0].color(), tint.color(), 0.4); _brushes.bg[1] = ColorUtils::tint(_brushes.bg[1].color(), tint.color(), 0.4); // the rest init(state, group, defaults); }
// >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> void OriginSymbol::drawOriginSymbol(const Map::Canvas*, QPainter& painter) { painter.save(); QPen pen; pen.setColor(_color); pen.setWidth(4); pen.setJoinStyle(Qt::MiterJoin); painter.setPen(pen); QBrush brush; brush.setColor(_color); brush.setStyle(Qt::NoBrush); if ( isFilled() ) brush.setStyle(Qt::SolidPattern); /* QBrush brush; brush.setStyle(Qt::SolidPattern); if ( isFilled() ) brush.setColor(_color); else brush.setColor(QColor(_color.red(), _color.green(), _color.blue(), 64)); */ painter.setBrush(brush); const QSize& size = Seiscomp::Gui::Map::Symbol::size(); int height = size.height(), width = size.width(), r = int(width / 2); QRect rect(_mapPosition.x() - r, _mapPosition.y() - r, width, height); _poly = rect; painter.drawEllipse(rect); painter.restore(); }
void KisVisualEllipticalSelectorShape::drawCursor() { //qDebug() << this << "KisVisualEllipticalSelectorShape::drawCursor: image needs update" << imagesNeedUpdate(); QPointF cursorPoint = convertShapeCoordinateToWidgetCoordinate(getCursorPosition()); QImage fullSelector = getImageMap(); QColor col = getColorFromConverter(getCurrentColor()); QPainter painter; painter.begin(&fullSelector); painter.setRenderHint(QPainter::Antialiasing); QRect innerRect(m_barWidth, m_barWidth, width()-(m_barWidth*2), height()-(m_barWidth*2)); painter.save(); painter.setCompositionMode(QPainter::CompositionMode_Clear); QPen pen; pen.setWidth(5); painter.setPen(pen); painter.drawEllipse(QRect(0,0,width(),height())); if (getDimensions()==KisVisualColorSelectorShape::onedimensional) { painter.setBrush(Qt::SolidPattern); painter.drawEllipse(innerRect); } painter.restore(); QBrush fill; fill.setStyle(Qt::SolidPattern); int cursorwidth = 5; if (m_type==KisVisualEllipticalSelectorShape::borderMirrored) { painter.setPen(Qt::white); fill.setColor(Qt::white); painter.setBrush(fill); painter.drawEllipse(cursorPoint, cursorwidth, cursorwidth); QPoint mirror(innerRect.center().x()+(innerRect.center().x()-cursorPoint.x()),cursorPoint.y()); painter.drawEllipse(mirror, cursorwidth, cursorwidth); fill.setColor(col); painter.setPen(Qt::black); painter.setBrush(fill); painter.drawEllipse(cursorPoint, cursorwidth-1, cursorwidth-1); painter.drawEllipse(mirror, cursorwidth-1, cursorwidth-1); } else { painter.setPen(Qt::white); fill.setColor(Qt::white); painter.setBrush(fill); painter.drawEllipse(cursorPoint, cursorwidth, cursorwidth); fill.setColor(col); painter.setPen(Qt::black); painter.setBrush(fill); painter.drawEllipse(cursorPoint, cursorwidth-1.0, cursorwidth-1.0); } painter.end(); setFullImage(fullSelector); }
void MythOpenGLPainter::DrawRoundRect(const QRect &area, int cornerRadius, const QBrush &fillBrush, const QPen &linePen, int alpha) { if (realRender && realRender->RectanglesAreAccelerated()) { if (fillBrush.style() == Qt::SolidPattern || fillBrush.style() == Qt::NoBrush) { realRender->DrawRoundRect(area, cornerRadius, fillBrush, linePen, alpha); return; } } MythPainter::DrawRoundRect(area, cornerRadius, fillBrush, linePen, alpha); }
void QPicturePaintEngine::updateBrush(const QBrush &brush) { Q_D(QPicturePaintEngine); #ifdef QT_PICTURE_DEBUG qDebug() << " -> updateBrush(): style:" << brush.style(); #endif int pos; SERIALIZE_CMD(QPicturePrivate::PdcSetBrush); if (d->pic_d->in_memory_only) { int index = d->pic_d->brush_list.size(); d->pic_d->brush_list.append(brush); d->s << index; } else { d->s << brush; } writeCmdLength(pos, QRect(), false); }