/*! Redraw the liquid in thermometer pipe. \param painter Painter \param pipeRect Bounding rectangle of the pipe without borders */ void QwtThermo::drawLiquid( QPainter *painter, const QRect &pipeRect ) const { painter->save(); painter->setClipRect( pipeRect, Qt::IntersectClip ); const bool inverted = ( maxValue() < minValue() ); if ( d_data->colorMap != NULL ) { QwtInterval interval( d_data->minValue, d_data->maxValue ); interval = interval.normalized(); // Because the positions of the ticks are rounded // we calculate the colors for the rounded tick values QVector<double> values = qwtTickList( scaleDraw()->scaleDiv(), d_data->value ); if ( d_data->map.isInverting() ) qSort( values.begin(), values.end(), qGreater<double>() ); else qSort( values.begin(), values.end(), qLess<double>() ); int from; if ( !values.isEmpty() ) { from = qRound( d_data->map.transform( values[0] ) ); qwtDrawLine( painter, from, d_data->colorMap->color( interval, values[0] ), pipeRect, d_data->orientation ); } for ( int i = 1; i < values.size(); i++ ) { const int to = qRound( d_data->map.transform( values[i] ) ); for ( int pos = from + 1; pos < to; pos++ ) { const double v = d_data->map.invTransform( pos ); qwtDrawLine( painter, pos, d_data->colorMap->color( interval, v ), pipeRect, d_data->orientation ); } qwtDrawLine( painter, to, d_data->colorMap->color( interval, values[i] ), pipeRect, d_data->orientation ); from = to; } } else { const int tval = qRound( d_data->map.transform( d_data->value ) ); QRect fillRect = pipeRect; if ( d_data->orientation == Qt::Horizontal ) { if ( inverted ) fillRect.setLeft( tval ); else fillRect.setRight( tval ); } else // Qt::Vertical { if ( inverted ) fillRect.setBottom( tval ); else fillRect.setTop( tval ); } if ( d_data->alarmEnabled && d_data->value >= d_data->alarmLevel ) { QRect alarmRect = fillRect; const int taval = qRound( d_data->map.transform( d_data->alarmLevel ) ); if ( d_data->orientation == Qt::Horizontal ) { if ( inverted ) alarmRect.setRight( taval ); else alarmRect.setLeft( taval ); } else { if ( inverted ) alarmRect.setTop( taval ); else alarmRect.setBottom( taval ); } fillRect = QRegion( fillRect ).subtracted( alarmRect ).boundingRect(); painter->fillRect( alarmRect, palette().brush( QPalette::Highlight ) ); } painter->fillRect( fillRect, palette().brush( QPalette::ButtonText ) ); } painter->restore(); }
/*! \brief Change the brush of the liquid. Changes the QPalette::ButtonText brush of the palette. \param brush New brush. \sa fillBrush(), QWidget::setPalette() */ void QwtThermo::setFillBrush( const QBrush& brush ) { QPalette pal = palette(); pal.setBrush( QPalette::ButtonText, brush ); setPalette( pal ); }
/*! \brief Specify the liquid brush above the alarm threshold Changes the QPalette::Highlight brush of the palette. \param brush New brush. \sa alarmBrush(), QWidget::setPalette() \warning The alarm threshold has no effect, when a color map has been assigned */ void QwtThermo::setAlarmBrush( const QBrush& brush ) { QPalette pal = palette(); pal.setBrush( QPalette::Highlight, brush ); setPalette( pal ); }
const QColor &TextShow::foreground() const { return palette().color(QPalette::Active, QColorGroup::Text); }
PaletteDockerDock::PaletteDockerDock( ) : QDockWidget(i18n("Palette")) , m_wdgPaletteDock(new Ui_WdgPaletteDock()) , m_currentColorSet(0) , m_resourceProvider(0) , m_canvas(0) { QWidget* mainWidget = new QWidget(this); setWidget(mainWidget); m_wdgPaletteDock->setupUi(mainWidget); m_wdgPaletteDock->bnAdd->setIcon(KisIconUtils::loadIcon("list-add")); m_wdgPaletteDock->bnAdd->setIconSize(QSize(16, 16)); m_wdgPaletteDock->bnAddDialog->setIcon(KisIconUtils::loadIcon("document-new")); m_wdgPaletteDock->bnAddDialog->setIconSize(QSize(16, 16)); m_wdgPaletteDock->bnRemove->setIcon(KisIconUtils::loadIcon("edit-delete")); m_wdgPaletteDock->bnRemove->setIconSize(QSize(16, 16)); m_wdgPaletteDock->bnAdd->setEnabled(false); m_wdgPaletteDock->bnRemove->setEnabled(false); connect(m_wdgPaletteDock->bnAdd, SIGNAL(clicked(bool)), this, SLOT(addColorForeground())); connect(m_wdgPaletteDock->bnAddDialog, SIGNAL(clicked(bool)), this, SLOT(addColor())); connect(m_wdgPaletteDock->bnRemove, SIGNAL(clicked(bool)), this, SLOT(removeColor())); m_model = new PaletteModel(this); m_wdgPaletteDock->paletteView->setModel(m_model); m_wdgPaletteDock->paletteView->setShowGrid(false); m_wdgPaletteDock->paletteView->horizontalHeader()->setVisible(false); m_wdgPaletteDock->paletteView->verticalHeader()->setVisible(false); m_wdgPaletteDock->paletteView->setItemDelegate(new PaletteDelegate()); KisConfig cfg; QPalette pal(palette()); pal.setColor(QPalette::Base, cfg.getMDIBackgroundColor()); m_wdgPaletteDock->paletteView->setAutoFillBackground(true); m_wdgPaletteDock->paletteView->setPalette(pal); connect(m_wdgPaletteDock->paletteView, SIGNAL(clicked(QModelIndex)), this, SLOT(entrySelected(QModelIndex))); m_wdgPaletteDock->paletteView->viewport()->installEventFilter(this); KoResourceServer<KoColorSet>* rServer = KoResourceServerProvider::instance()->paletteServer(false); m_serverAdapter = QSharedPointer<KoAbstractResourceServerAdapter>(new KoResourceServerAdapter<KoColorSet>(rServer)); m_serverAdapter->connectToResourceServer(); rServer->addObserver(this); m_colorSetChooser = new ColorSetChooser(this); connect(m_colorSetChooser, SIGNAL(paletteSelected(KoColorSet*)), this, SLOT(setColorSet(KoColorSet*))); m_wdgPaletteDock->bnColorSets->setIcon(KisIconUtils::loadIcon("hi16-palette_library")); m_wdgPaletteDock->bnColorSets->setToolTip(i18n("Choose palette")); m_wdgPaletteDock->bnColorSets->setPopupWidget(m_colorSetChooser); int defaultSectionSize = cfg.paletteDockerPaletteViewSectionSize(); m_wdgPaletteDock->paletteView->horizontalHeader()->setDefaultSectionSize(defaultSectionSize); m_wdgPaletteDock->paletteView->verticalHeader()->setDefaultSectionSize(defaultSectionSize); QString defaultPalette = cfg.defaultPalette(); KoColorSet* defaultColorSet = rServer->resourceByName(defaultPalette); if (defaultColorSet) { setColorSet(defaultColorSet); } }
// paint a ROUND SUNKEN led lamp void KLed::paintSunken() { if ( paintCachedPixmap() ) return; QPainter paint; QColor color; QBrush brush; QPen pen; // First of all we want to know what area should be updated // Initialize coordinates, width, and height of the LED int width = ledWidth(); int scale = 3; QPixmap *tmpMap = 0; width *= scale; tmpMap = new QPixmap( width, width ); tmpMap->fill( palette().color( backgroundRole() ) ); paint.begin( tmpMap ); paint.setRenderHint(QPainter::Antialiasing); // Set the color of the LED according to given parameters color = ( d->state == On ) ? d->color : d->offColor; // Set the brush to SolidPattern, this fills the entire area // of the ellipse which is drawn first brush.setStyle( Qt::SolidPattern ); brush.setColor( color ); paint.setBrush( brush ); // Assign the brush to the painter // Draws a "flat" LED with the given color: paint.drawEllipse( scale, scale, width - scale * 2, width - scale * 2 ); // Draw the bright light spot of the LED now, using modified "old" // painter routine taken from KDEUI's KLed widget: // Setting the new width of the pen is essential to avoid "pixelized" // shadow like it can be observed with the old LED code pen.setWidth( 2 * scale ); // shrink the light on the LED to a size about 2/3 of the complete LED int pos = width / 5 + 1; int light_width = width; light_width *= 2; light_width /= 3; // Calculate the LED's "light factor": int light_quote = ( 130 * 2 / ( light_width ? light_width : 1 ) ) + 100; // Now draw the bright spot on the LED: while ( light_width ) { color = color.light( light_quote ); // make color lighter pen.setColor( color ); // set color as pen color paint.setPen( pen ); // select the pen for drawing paint.drawEllipse( pos, pos, light_width, light_width ); // draw the ellipse (circle) light_width--; if ( !light_width ) break; paint.drawEllipse( pos, pos, light_width, light_width ); light_width--; if ( !light_width ) break; paint.drawEllipse( pos, pos, light_width, light_width ); pos++; light_width--; } // Drawing of bright spot finished, now draw a thin border // around the LED which resembles a shadow with light coming // from the upper left. pen.setWidth( 2 * scale + 1 ); // ### shouldn't this value be smaller for smaller LEDs? brush.setStyle( Qt::NoBrush ); // Switch off the brush paint.setBrush( brush ); // This avoids filling of the ellipse // Set the initial color value to QColorGroup(palette()).light() (bright) and start // drawing the shadow border at 45° (45*16 = 720). int angle = -720; color = palette().color( QPalette::Light ); for ( int arc = 120; arc < 2880; arc += 240 ) { pen.setColor( color ); paint.setPen( pen ); int w = width - pen.width() / 2 - scale + 1; paint.drawArc( pen.width() / 2, pen.width() / 2, w, w, angle + arc, 240 ); paint.drawArc( pen.width() / 2, pen.width() / 2, w, w, angle - arc, 240 ); color = color.dark( 110 ); //FIXME: this should somehow use the contrast value } // end for ( angle = 720; angle < 6480; angle += 160 ) paint.end(); // painting done QPixmap *&dest = ( d->state == On ? d->onMap : d->offMap ); QImage i = tmpMap->toImage(); width /= 3; i = i.scaled( width, width, Qt::IgnoreAspectRatio, Qt::SmoothTransformation ); delete tmpMap; dest = new QPixmap( QPixmap::fromImage( i ) ); paint.begin( this ); paint.setCompositionMode(QPainter::CompositionMode_Source); paint.drawPixmap( 0, 0, *dest ); paint.end(); }
void TextShow::setForeground(const QColor& c) { QPalette pal = palette(); pal.setColor(QPalette::Active, QColorGroup::Text, c); setPalette(pal); }
void KMenuBar::drawContents(QPainter *p) { // Closes the BR77113 // We need to overload this method to paint only the menu items // This way when the KMenuBar is embedded in the menu applet it // integrates correctly. // // Background mode and origin are set so late because of styles // using the polish() method to modify these settings. // // Of course this hack can safely be removed when real transparency // will be available if(!d->topLevel) { QMenuBar::drawContents(p); } else { bool up_enabled = isUpdatesEnabled(); BackgroundMode bg_mode = backgroundMode(); BackgroundOrigin bg_origin = backgroundOrigin(); setUpdatesEnabled(false); setBackgroundMode(X11ParentRelative); setBackgroundOrigin(WindowOrigin); p->eraseRect(rect()); erase(); QColorGroup g = colorGroup(); bool e; for(int i = 0; i < (int)count(); i++) { QMenuItem *mi = findItem(idAt(i)); if(!mi->text().isNull() || mi->pixmap()) { QRect r = itemRect(i); if(r.isEmpty() || !mi->isVisible()) continue; e = mi->isEnabledAndVisible(); if(e) g = isEnabled() ? (isActiveWindow() ? palette().active() : palette().inactive()) : palette().disabled(); else g = palette().disabled(); bool item_active = (actItem == i); p->setClipRect(r); if(item_active) { QStyle::SFlags flags = QStyle::Style_Default; if(isEnabled() && e) flags |= QStyle::Style_Enabled; if(item_active) flags |= QStyle::Style_Active; if(item_active && actItemDown) flags |= QStyle::Style_Down; flags |= QStyle::Style_HasFocus; style().drawControl(QStyle::CE_MenuBarItem, p, this, r, g, flags, QStyleOption(mi)); } else { style().drawItem(p, r, AlignCenter | AlignVCenter | ShowPrefix, g, e, mi->pixmap(), mi->text()); } } } setBackgroundOrigin(bg_origin); setBackgroundMode(bg_mode); setUpdatesEnabled(up_enabled); } }
//! [0] DragWidget::DragWidget(QWidget *parent) : QWidget(parent) { QFile dictionaryFile(":/dictionary/words.txt"); dictionaryFile.open(QFile::ReadOnly); QTextStream inputStream(&dictionaryFile); //! [0] //! [1] int x = 5; int y = 5; while (!inputStream.atEnd()) { QString word; inputStream >> word; if (!word.isEmpty()) { DragLabel *wordLabel = new DragLabel(word, this); wordLabel->move(x, y); wordLabel->show(); wordLabel->setAttribute(Qt::WA_DeleteOnClose); x += wordLabel->width() + 2; #if defined(Q_WS_MAEMO_5) || defined(Q_WS_SIMULATOR) if (x >= 345) { #else if (x >= 245) { #endif x = 5; y += wordLabel->height() + 2; } } } //! [1] //! [2] #ifndef Q_WS_S60 //Fridge magnets is used for demoing Qt on S60 and themed backgrounds look better than white QPalette newPalette = palette(); newPalette.setColor(QPalette::Window, Qt::white); setPalette(newPalette); #endif setMinimumSize(400, qMax(200, y)); setWindowTitle(tr("Fridge Magnets")); //! [2] //! [3] setAcceptDrops(true); } //! [3] //! [4] void DragWidget::dragEnterEvent(QDragEnterEvent *event) { //! [4] //! [5] if (event->mimeData()->hasFormat("application/x-fridgemagnet")) { if (children().contains(event->source())) { event->setDropAction(Qt::MoveAction); event->accept(); } else { event->acceptProposedAction(); //! [5] //! [6] } //! [6] //! [7] } else if (event->mimeData()->hasText()) { event->acceptProposedAction(); } else { event->ignore(); } } //! [7] //! [8] void DragWidget::dragMoveEvent(QDragMoveEvent *event) { if (event->mimeData()->hasFormat("application/x-fridgemagnet")) { if (children().contains(event->source())) { event->setDropAction(Qt::MoveAction); event->accept(); } else { event->acceptProposedAction(); } } else if (event->mimeData()->hasText()) { event->acceptProposedAction(); } else { event->ignore(); } } //! [8] //! [9] void DragWidget::dropEvent(QDropEvent *event) { if (event->mimeData()->hasFormat("application/x-fridgemagnet")) { const QMimeData *mime = event->mimeData(); //! [9] //! [10] QByteArray itemData = mime->data("application/x-fridgemagnet"); QDataStream dataStream(&itemData, QIODevice::ReadOnly); QString text; QPoint offset; dataStream >> text >> offset; //! [10] //! [11] DragLabel *newLabel = new DragLabel(text, this); newLabel->move(event->pos() - offset); newLabel->show(); newLabel->setAttribute(Qt::WA_DeleteOnClose); if (event->source() == this) { event->setDropAction(Qt::MoveAction); event->accept(); } else { event->acceptProposedAction(); } //! [11] //! [12] } else if (event->mimeData()->hasText()) { QStringList pieces = event->mimeData()->text().split(QRegExp("\\s+"), QString::SkipEmptyParts); QPoint position = event->pos(); foreach (QString piece, pieces) { DragLabel *newLabel = new DragLabel(piece, this); newLabel->move(position); newLabel->show(); newLabel->setAttribute(Qt::WA_DeleteOnClose); position += QPoint(newLabel->width(), 0); }
void QwtPlotCanvas::drawCanvas( QPainter *painter, bool withBackground ) { bool hackStyledBackground = false; if ( withBackground && testAttribute( Qt::WA_StyledBackground ) && testPaintAttribute( HackStyledBackground ) ) { // Antialiasing rounded borders is done by // inserting pixels with colors between the // border color and the color on the canvas, // When the border is painted before the plot items // these colors are interpolated for the canvas // and the plot items need to be clipped excluding // the anialiased pixels. In situations, where // the plot items fill the area at the rounded // borders this is noticeable. // The only way to avoid these annoying "artefacts" // is to paint the border on top of the plot items. if ( d_data->styleSheet.hasBorder && !d_data->styleSheet.borderPath.isEmpty() ) { // We have a border with at least one rounded corner hackStyledBackground = true; } } if ( withBackground ) { painter->save(); if ( testAttribute( Qt::WA_StyledBackground ) ) { if ( hackStyledBackground ) { // paint background without border painter->setPen( Qt::NoPen ); painter->setBrush( d_data->styleSheet.background.brush ); painter->setBrushOrigin( d_data->styleSheet.background.origin ); painter->setClipPath( d_data->styleSheet.borderPath ); painter->drawRect( contentsRect() ); } else { qwtDrawStyledBackground( this, painter ); } } else if ( autoFillBackground() ) { painter->setPen( Qt::NoPen ); painter->setBrush( palette().brush( backgroundRole() ) ); if ( d_data->borderRadius > 0.0 && ( rect() == frameRect() ) ) { if ( frameWidth() > 0 ) { painter->setClipPath( borderPath( rect() ) ); painter->drawRect( rect() ); } else { painter->setRenderHint( QPainter::Antialiasing, true ); painter->drawPath( borderPath( rect() ) ); } } else { painter->drawRect( rect() ); } } painter->restore(); } painter->save(); if ( !d_data->styleSheet.borderPath.isEmpty() ) { painter->setClipPath( d_data->styleSheet.borderPath, Qt::IntersectClip ); } else { if ( d_data->borderRadius > 0.0 ) painter->setClipPath( borderPath( frameRect() ), Qt::IntersectClip ); else painter->setClipRect( contentsRect(), Qt::IntersectClip ); } plot()->drawCanvas( painter ); painter->restore(); if ( withBackground && hackStyledBackground ) { // Now paint the border on top QStyleOptionFrame opt; opt.initFrom(this); style()->drawPrimitive( QStyle::PE_Frame, &opt, painter, this); } }
/*! Draw the border of the plot canvas \param painter Painter \sa setBorderRadius() */ void QwtPlotCanvas::drawBorder( QPainter *painter ) { if ( d_data->borderRadius > 0 ) { if ( frameWidth() > 0 ) { QwtPainter::drawRoundedFrame( painter, QRectF( frameRect() ), d_data->borderRadius, d_data->borderRadius, palette(), frameWidth(), frameStyle() ); } } else { #if QT_VERSION >= 0x040500 #if !defined(_MSC_VER) #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wdeprecated-declarations" #endif QStyleOptionFrameV3 opt; #if !defined(_MSC_VER) #pragma GCC diagnostic pop #endif opt.init(this); int frameShape = frameStyle() & QFrame::Shape_Mask; int frameShadow = frameStyle() & QFrame::Shadow_Mask; opt.frameShape = QFrame::Shape( int( opt.frameShape ) | frameShape ); #if 0 opt.rect = frameRect(); #endif switch (frameShape) { case QFrame::Box: case QFrame::HLine: case QFrame::VLine: case QFrame::StyledPanel: case QFrame::Panel: { opt.lineWidth = lineWidth(); opt.midLineWidth = midLineWidth(); break; } default: { opt.lineWidth = frameWidth(); break; } } if ( frameShadow == Sunken ) opt.state |= QStyle::State_Sunken; else if ( frameShadow == Raised ) opt.state |= QStyle::State_Raised; style()->drawControl(QStyle::CE_ShapedFrame, &opt, painter, this); #else drawFrame( painter ); #endif } }
void ClassName::setFrameColor(const QColor& color) { d->frameColor = color; //update light and dark colors setPalette(palette()); }
QwtCompass *CompassGrid::createCompass( int pos ) { int c; QPalette palette0; for ( c = 0; c < QPalette::NColorRoles; c++ ) { const QPalette::ColorRole colorRole = static_cast<QPalette::ColorRole>( c ); palette0.setColor( colorRole, QColor() ); } palette0.setColor( QPalette::Base, palette().color( backgroundRole() ).light( 120 ) ); palette0.setColor( QPalette::WindowText, palette0.color( QPalette::Base ) ); QwtCompass *compass = new QwtCompass( this ); compass->setLineWidth( 4 ); compass->setFrameShadow( pos <= 2 ? QwtCompass::Sunken : QwtCompass::Raised ); switch( pos ) { case 0: { /* A compass with a rose and no needle. Scale and rose are rotating. */ compass->setMode( QwtCompass::RotateScale ); QwtSimpleCompassRose *rose = new QwtSimpleCompassRose( 16, 2 ); rose->setWidth( 0.15 ); compass->setRose( rose ); break; } case 1: { /* A windrose, with a scale indicating the main directions only */ QMap<double, QString> map; map.insert( 0.0, "N" ); map.insert( 90.0, "E" ); map.insert( 180.0, "S" ); map.insert( 270.0, "W" ); compass->setScaleDraw( new QwtCompassScaleDraw( map ) ); QwtSimpleCompassRose *rose = new QwtSimpleCompassRose( 4, 1 ); compass->setRose( rose ); compass->setNeedle( new QwtCompassWindArrow( QwtCompassWindArrow::Style2 ) ); compass->setValue( 60.0 ); break; } case 2: { /* A compass with a rotating needle in darkBlue. Shows a ticks for each degree. */ palette0.setColor( QPalette::Base, Qt::darkBlue ); palette0.setColor( QPalette::WindowText, QColor( Qt::darkBlue ).dark( 120 ) ); palette0.setColor( QPalette::Text, Qt::white ); QwtCompassScaleDraw *scaleDraw = new QwtCompassScaleDraw(); scaleDraw->enableComponent( QwtAbstractScaleDraw::Ticks, true ); scaleDraw->enableComponent( QwtAbstractScaleDraw::Labels, true ); scaleDraw->enableComponent( QwtAbstractScaleDraw::Backbone, false ); scaleDraw->setTickLength( QwtScaleDiv::MinorTick, 1 ); scaleDraw->setTickLength( QwtScaleDiv::MediumTick, 1 ); scaleDraw->setTickLength( QwtScaleDiv::MajorTick, 3 ); compass->setScaleDraw( scaleDraw ); compass->setScaleMaxMajor( 36 ); compass->setScaleMaxMinor( 5 ); compass->setNeedle( new QwtCompassMagnetNeedle( QwtCompassMagnetNeedle::ThinStyle ) ); compass->setValue( 220.0 ); break; } case 3: { /* A compass without a frame, showing numbers as tick labels. The origin is at 220.0 */ palette0.setColor( QPalette::Base, palette().color( backgroundRole() ) ); palette0.setColor( QPalette::WindowText, Qt::blue ); compass->setLineWidth( 0 ); QMap<double, QString> map; for ( double d = 0.0; d < 360.0; d += 60.0 ) { QString label; label.sprintf( "%.0f", d ); map.insert( d, label ); } QwtCompassScaleDraw *scaleDraw = new QwtCompassScaleDraw( map ); scaleDraw->enableComponent( QwtAbstractScaleDraw::Ticks, true ); scaleDraw->enableComponent( QwtAbstractScaleDraw::Labels, true ); scaleDraw->enableComponent( QwtAbstractScaleDraw::Backbone, true ); scaleDraw->setTickLength( QwtScaleDiv::MinorTick, 0 ); scaleDraw->setTickLength( QwtScaleDiv::MediumTick, 0 ); scaleDraw->setTickLength( QwtScaleDiv::MajorTick, 3 ); compass->setScaleDraw( scaleDraw ); compass->setScaleMaxMajor( 36 ); compass->setScaleMaxMinor( 5 ); compass->setNeedle( new QwtDialSimpleNeedle( QwtDialSimpleNeedle::Ray, true, Qt::white ) ); compass->setOrigin( 220.0 ); compass->setValue( 20.0 ); break; } case 4: { /* A compass showing another needle */ QwtCompassScaleDraw *scaleDraw = new QwtCompassScaleDraw(); scaleDraw->enableComponent( QwtAbstractScaleDraw::Ticks, true ); scaleDraw->enableComponent( QwtAbstractScaleDraw::Labels, true ); scaleDraw->enableComponent( QwtAbstractScaleDraw::Backbone, false ); scaleDraw->setTickLength( QwtScaleDiv::MinorTick, 0 ); scaleDraw->setTickLength( QwtScaleDiv::MediumTick, 0 ); scaleDraw->setTickLength( QwtScaleDiv::MajorTick, 3 ); compass->setScaleDraw( scaleDraw ); compass->setNeedle( new QwtCompassMagnetNeedle( QwtCompassMagnetNeedle::TriangleStyle, Qt::white, Qt::red ) ); compass->setValue( 220.0 ); break; } case 5: { /* A compass with a yellow on black ray */ palette0.setColor( QPalette::WindowText, Qt::black ); compass->setNeedle( new QwtDialSimpleNeedle( QwtDialSimpleNeedle::Ray, false, Qt::yellow ) ); compass->setValue( 315.0 ); break; } } QPalette newPalette = compass->palette(); for ( c = 0; c < QPalette::NColorRoles; c++ ) { const QPalette::ColorRole colorRole = static_cast<QPalette::ColorRole>( c ); if ( palette0.color( colorRole ).isValid() ) newPalette.setColor( colorRole, palette0.color( colorRole ) ); } for ( int i = 0; i < QPalette::NColorGroups; i++ ) { const QPalette::ColorGroup colorGroup = static_cast<QPalette::ColorGroup>( i ); const QColor light = newPalette.color( colorGroup, QPalette::Base ).light( 170 ); const QColor dark = newPalette.color( colorGroup, QPalette::Base ).dark( 170 ); const QColor mid = compass->frameShadow() == QwtDial::Raised ? newPalette.color( colorGroup, QPalette::Base ).dark( 110 ) : newPalette.color( colorGroup, QPalette::Base ).light( 110 ); newPalette.setColor( colorGroup, QPalette::Dark, dark ); newPalette.setColor( colorGroup, QPalette::Mid, mid ); newPalette.setColor( colorGroup, QPalette::Light, light ); } compass->setPalette( newPalette ); return compass; }
/** * @brief Builds stylesheet for this WorkAreaTabBar widget. */ QString WorkAreaTabBar::buildStyleSheet() { QColor background = palette().window().color(); QColor gradientZero = QColor("#ffffff");//Qt::white;//.lighter(103); QColor gradientOne = background.lighter(104);//Qt::white;//.lighter(103); QColor gradientTwo = background.lighter(108);//.lighter(103); QColor selectedBorder = background.darker(103); QString aga1 = gradientOne.name(); QString aga2 = gradientTwo.name(); QString aga3 = background.name(); QString styles = QString( "QTabBar::tab:first {" "margin-left: 4px;" "} " "QTabBar::tab:last {" "margin-right: 1px;" "} " "QTabBar::close-button { " "image: url(:/robomongo/icons/close_2_16x16.png);" "width: 10px;" "height: 10px;" "}" "QTabBar::close-button:hover { " "image: url(:/robomongo/icons/close_hover_16x16.png);" "width: 15px;" "height: 15px;" "}" "QTabBar::tab {" "background: qlineargradient(x1: 0, y1: 0, x2: 0, y2: 1," "stop: 0 #F0F0F0, stop: 0.4 #DEDEDE," "stop: 0.5 #E6E6E6, stop: 1.0 #E1E1E1);" "border: 1px solid #C4C4C3;" "border-bottom-color: #B8B7B6;" // #C2C7CB same as the pane color "border-top-left-radius: 6px;" "border-top-right-radius: 6px;" // "min-width: 8ex;" "max-width: 200px;" "padding: 4px 0px 5px 0px;" "margin: 0px;" "margin-left: 1px;" "margin-right: -3px;" // it should be -(tab:first:margin-left + tab:last:margin-left) to fix incorrect text elidement "}" "QTabBar::tab:selected, QTabBar::tab:hover {" "background: qlineargradient(x1: 0, y1: 1, x2: 0, y2: 0," "stop: 0 %1, stop: 0.3 %2," //#fafafa, #f4f4f4 "stop: 0.6 %3, stop: 1.0 %4);" //#e7e7e7, #fafafa "}" "QTabBar::tab:selected {" "border-color: #9B9B9B;" // "border-bottom-color: %4;" //#fafafa "}" "QTabBar::tab:!selected {" "margin-top: 2px;" // make non-selected tabs look smaller "} " "QTabBar::tab:only-one { margin-top: 2px; margin-left:4px; }" ).arg(gradientZero.name(), gradientOne.name(), gradientTwo.name(), "#ffffff"); QString aga = palette().window().color().name(); return styles; }
PopupView::PopupView(const QModelIndex &index, const QPoint &pos, const bool &showPreview, const QStringList &previewPlugins, const IconView *parentView) : QWidget(0, Qt::X11BypassWindowManagerHint), m_view(0), m_parentView(parentView), m_busyWidget(0), m_iconView(0), m_parentViewModel(0), m_dirModel(0), m_model(0), m_actionCollection(this), m_newMenu(0), m_itemActions(0), m_showingMenu(false), m_showPreview(showPreview), m_delayedClose(false), m_previewPlugins(previewPlugins) { setAttribute(Qt::WA_TranslucentBackground); #ifdef Q_WS_X11 if (KWindowSystem::compositingActive()) { setAttribute(Qt::WA_NoSystemBackground, false); } #endif #ifdef Q_WS_WIN setWindowFlags(Qt::FramelessWindowHint | Qt::WindowStaysOnTopHint | Qt::Tool); #endif KWindowSystem::setState(effectiveWinId(), NET::SkipTaskbar | NET::SkipPager); setAcceptDrops(true); QPalette pal = palette(); pal.setColor(backgroundRole(), Qt::transparent); pal.setColor(QPalette::Text, Plasma::Theme::defaultTheme()->color(Plasma::Theme::TextColor)); setPalette(pal); m_parentViewModel = static_cast<const ProxyModel*>(index.model()); KFileItem item = m_parentViewModel->itemForIndex(index); if (item.isDesktopFile()) { KDesktopFile file(item.localPath()); m_url = file.readUrl(); } else { m_url = item.targetUrl(); } m_background = new Plasma::FrameSvg(this); m_background->setImagePath("dialogs/background"); int left = m_background->marginSize(Plasma::LeftMargin); int top = m_background->marginSize(Plasma::TopMargin); int right = m_background->marginSize(Plasma::RightMargin); int bottom = m_background->marginSize(Plasma::BottomMargin); setContentsMargins(left, top, right, bottom); resize(parentView->sizeForRowsColumns(2, 3) + QSize(left + right, top + bottom)); const QRect available = QApplication::desktop()->availableGeometry(pos); QPoint pt = pos; if (pt.x() + width() > available.right()) { pt.rx() -= width(); } if (pt.x() < available.left()) { pt.rx() = available.left(); } if (pt.y() + height() > available.bottom()) { pt.ry() -= height(); } if (pt.y() < available.top()) { pt.ry() = available.top(); } Plasma::WindowEffects::overrideShadow(winId(), true); move(pt); show(); QTimer::singleShot(10, this, SLOT(init())); s_lastOpenClose.restart(); }
void OSDWidget::paintEvent( QPaintEvent *e ) { const int& M = m_m; const QSize& size = m_size; QPoint point; QRect rect( point, size ); rect.adjust( 0, 0, -1, -1 ); QColor shadowColor; { int h, s, v; palette().color( QPalette::Normal, QPalette::Foreground ).getHsv( &h, &s, &v ); shadowColor = v > 128 ? Qt::black : Qt::white; } int align = Qt::AlignCenter | Qt::TextWordWrap; QPainter p( this ); p.setRenderHints( QPainter::Antialiasing | QPainter::TextAntialiasing | QPainter::SmoothPixmapTransform | QPainter::HighQualityAntialiasing ); p.setClipRect( e->rect() ); QPixmap background = The::svgHandler()->renderSvgWithDividers( "service_list_item", width(), height(), "service_list_item" ); p.drawPixmap( 0, 0, background ); p.setPen( Qt::white ); // Revert this when the background can be colorized again. rect.adjust( M, M, -M, -M ); if( !m_cover.isNull() ) { QRect r( rect ); r.setTop( ( size.height() - m_scaledCover.height() ) / 2 ); r.setSize( m_scaledCover.size() ); p.drawPixmap( r.topLeft(), m_scaledCover ); rect.setLeft( rect.left() + m_scaledCover.width() + M ); } int graphicsHeight = 0; if( !m_showVolume && m_rating > 0 && !m_paused ) { // TODO: Check if we couldn't use a KRatingPainter instead QPixmap* star = StarManager::instance()->getStar( m_rating/2 ); QRect r( rect ); //Align to center... r.setLeft( ( rect.left() + rect.width() / 2 ) - star->width() * m_rating / 4 ); r.setTop( rect.bottom() - star->height() ); graphicsHeight += star->height() + M; bool half = m_rating % 2; if( half ) { QPixmap* halfStar = StarManager::instance()->getHalfStar( m_rating / 2 + 1 ); p.drawPixmap( r.left() + star->width() * ( m_rating / 2 ), r.top(), *halfStar ); star = StarManager::instance()->getStar( m_rating / 2 + 1 ); } for( int i = 0; i < m_rating / 2; i++ ) { p.drawPixmap( r.left() + i * star->width(), r.top(), *star ); } } rect.setBottom( rect.bottom() - graphicsHeight ); // Draw "shadow" text effect (black outline) if( m_drawShadow ) { QPixmap pixmap( rect.size() + QSize( 10, 10 ) ); pixmap.fill( Qt::black ); QPainter p2( &pixmap ); p2.setFont( font() ); p2.setPen( Qt::white ); p2.setBrush( Qt::white ); p2.drawText( QRect( QPoint( 5, 5 ), rect.size() ), align, m_text ); p2.end(); p.drawImage( rect.topLeft() - QPoint( 5, 5 ), ShadowEngine::makeShadow( pixmap, shadowColor ) ); } p.setPen( palette().color( QPalette::Active, QPalette::WindowText ) ); //p.setPen( Qt::white ); // This too. p.drawText( rect, align, m_text ); }
// paint a ROUND RAISED led lamp void KLed::paintRaised() { if ( paintCachedPixmap() ) return; QPainter paint; QColor color; QBrush brush; QPen pen; // Initialize coordinates, width, and height of the LED int width = ledWidth(); int scale = 3; QPixmap *tmpMap = 0; width *= scale; tmpMap = new QPixmap( width + 6, width + 6 ); tmpMap->fill( palette().color( backgroundRole() ) ); paint.begin( tmpMap ); paint.setRenderHint(QPainter::Antialiasing); // Set the color of the LED according to given parameters color = ( d->state == On ? d->color : d->offColor ); // Set the brush to SolidPattern, this fills the entire area // of the ellipse which is drawn first brush.setStyle( Qt::SolidPattern ); brush.setColor( color ); paint.setBrush( brush ); // Assign the brush to the painter // Draws a "flat" LED with the given color: paint.drawEllipse( scale, scale, width - scale * 2, width - scale * 2 ); // Draw the bright light spot of the LED now, using modified "old" // painter routine taken from KDEUI's KLed widget: // Setting the new width of the pen is essential to avoid "pixelized" // shadow like it can be observed with the old LED code pen.setWidth( 2 * scale ); // shrink the light on the LED to a size about 2/3 of the complete LED int pos = width / 5 + 1; int light_width = width; light_width *= 2; light_width /= 3; // Calculate the LED's "light factor": int light_quote = ( 130 * 2 / ( light_width ? light_width : 1 ) ) + 100; // Now draw the bright spot on the LED: while ( light_width ) { color = color.light( light_quote ); // make color lighter pen.setColor( color ); // set color as pen color paint.setPen( pen ); // select the pen for drawing paint.drawEllipse( pos, pos, light_width, light_width ); // draw the ellipse (circle) light_width--; if ( !light_width ) break; paint.drawEllipse( pos, pos, light_width, light_width ); light_width--; if ( !light_width ) break; paint.drawEllipse( pos, pos, light_width, light_width ); pos++; light_width--; } // Drawing of bright spot finished, now draw a thin gray border // around the LED; it looks nicer that way. We do this here to // avoid that the border can be erased by the bright spot of the LED pen.setWidth( 2 * scale + 1 ); color = palette().color( QPalette::Dark ); pen.setColor( color ); // Set the pen accordingly paint.setPen( pen ); // Select pen for drawing brush.setStyle( Qt::NoBrush ); // Switch off the brush paint.setBrush( brush ); // This avoids filling of the ellipse paint.drawEllipse( 2, 2, width, width ); paint.end(); // painting done QPixmap *&dest = ( d->state == On ? d->onMap : d->offMap ); QImage i = tmpMap->toImage(); width /= 3; i = i.scaled( width, width, Qt::IgnoreAspectRatio, Qt::SmoothTransformation ); delete tmpMap; dest = new QPixmap( QPixmap::fromImage( i ) ); paint.begin( this ); paint.drawPixmap( 0, 0, *dest ); paint.end(); }
void ByteViewText::paintEvent(QPaintEvent *) { QPainter painter(viewport()); painter.translate(-horizontalScrollBar()->value() * font_width_, 0); // Pixel offset of this row int row_y = 0; // Starting byte offset int offset = verticalScrollBar()->value() * row_width_; // Clear the area painter.fillRect(viewport()->rect(), palette().base()); // Offset background. We want the entire height to be filled. if (show_offset_) { QRect offset_rect = QRect(viewport()->rect()); offset_rect.setWidth(offsetPixels()); painter.fillRect(offset_rect, palette().window()); } if ( data_.isEmpty() ) { return; } // Data rows int widget_height = height(); int leading = fontMetrics().leading(); painter.save(); x_pos_to_column_.clear(); while( (int) (row_y + line_height_) < widget_height && offset < (int) data_.count()) { drawLine(&painter, offset, row_y); offset += row_width_; row_y += line_height_ + leading; } painter.restore(); // We can't do this in drawLine since the next line might draw over our rect. if (!hover_outlines_.isEmpty()) { qreal pen_width = 1.0; qreal hover_alpha = 0.6; QPen ho_pen; QColor ho_color = palette().text().color(); if (marked_byte_offset_ < 0) { hover_alpha = 0.3; if (devicePixelRatio() > 1) { pen_width = 0.5; } } ho_pen.setWidthF(pen_width); ho_color.setAlphaF(hover_alpha); ho_pen.setColor(ho_color); painter.save(); painter.setPen(ho_pen); painter.setBrush(Qt::NoBrush); foreach (QRect ho_rect, hover_outlines_) { // These look good on retina and non-retina displays on macOS. // We might want to use fontMetrics numbers instead. ho_rect.adjust(-1, 0, -1, -1); painter.drawRect(ho_rect); }
BalloonMsg::BalloonMsg(void *param, const QString &_text, QStringList &btn, QWidget *parent, const QRect *rcParent, bool bModal, bool bAutoHide, unsigned bwidth, const QString &box_msg, bool *bChecked) : QDialog(parent, "ballon", bModal, (bAutoHide ? WType_Popup : WType_TopLevel | WStyle_StaysOnTop) | WStyle_Customize | WStyle_NoBorderEx | WStyle_Tool | WDestructiveClose | WX11BypassWM) { m_param = param; m_parent = parent; m_width = bwidth; m_bAutoHide = bAutoHide; m_bYes = false; m_bChecked = bChecked; bool bTailDown = true; setPalette(QToolTip::palette()); text = _text; QFrame *frm = new QFrame(this); frm->setPalette(palette()); QVBoxLayout *vlay = new QVBoxLayout(frm); vlay->setMargin(0); m_check = NULL; if (!box_msg.isEmpty()){ m_check = new QCheckBox(box_msg, frm); vlay->addWidget(m_check); if (m_bChecked) m_check->setChecked(*m_bChecked); } QHBoxLayout *lay = new QHBoxLayout(vlay); lay->setSpacing(5); lay->addStretch(); unsigned id = 0; bool bFirst = true; for (QStringList::Iterator it = btn.begin(); it != btn.end(); ++it, id++){ BalloonButton *b = new BalloonButton(*it, frm, id); connect(b, SIGNAL(action(int)), this, SLOT(action(int))); lay->addWidget(b); if (bFirst){ b->setDefault(true); bFirst = false; } } setButtonsPict(this); lay->addStretch(); int wndWidth = frm->minimumSizeHint().width(); int hButton = frm->minimumSizeHint().height(); int txtWidth = bwidth; QRect rc; if (rcParent){ rc = *rcParent; }else{ QPoint p = parent->mapToGlobal(parent->rect().topLeft()); rc = QRect(p.x(), p.y(), parent->width(), parent->height()); } if (rc.width() > txtWidth) txtWidth = rc.width(); QSimpleRichText richText(_text, font(), "", QStyleSheet::defaultSheet(), QMimeSourceFactory::defaultFactory(), -1, Qt::blue, false); richText.setWidth(wndWidth); richText.adjustSize(); QSize s(richText.widthUsed(), richText.height()); QSize sMin = frm->minimumSizeHint(); if (s.width() < sMin.width()) s.setWidth(sMin.width()); int BALLOON_SHADOW = BALLOON_SHADOW_DEF; #ifdef WIN32 /* FIXME */ /* if ((GetClassLong(winId(), GCL_STYLE) & CS_DROPSHADOW) && style().inherits("QWindowsXPStyle")) BALLOON_SHADOW = 0; */ #endif resize(s.width() + BALLOON_R * 2 + BALLOON_SHADOW, s.height() + BALLOON_R * 2 + BALLOON_TAIL + BALLOON_SHADOW + hButton + BALLOON_MARGIN); mask = QBitmap(width(), height()); int w = width() - BALLOON_SHADOW; int tailX = w / 2; int posX = rc.left() + rc.width() / 2 + BALLOON_TAIL_WIDTH - tailX; if (posX <= 0) posX = 1; QRect rcScreen = screenGeometry(); if (posX + width() >= rcScreen.width()) posX = rcScreen.width() - 1 - width(); int tx = posX + tailX - BALLOON_TAIL_WIDTH; if (tx < rc.left()) tx = rc.left(); if (tx > rc.left() + rc.width()) tx = rc.left() + rc.width(); tailX = tx + BALLOON_TAIL_WIDTH - posX; if (tailX < BALLOON_R) tailX = BALLOON_R; if (tailX > width() - BALLOON_R - BALLOON_TAIL_WIDTH) tailX = width() - BALLOON_R - BALLOON_TAIL_WIDTH; if (rc.top() <= height() + 2){ bTailDown = false; move(posX, rc.top() + rc.height() + 1); }else{ move(posX, rc.top() - height() - 1); } int pos = 0; int h = height() - BALLOON_SHADOW - BALLOON_TAIL; if (!bTailDown) pos += BALLOON_TAIL; textRect.setRect(BALLOON_R, pos + BALLOON_R, w - BALLOON_R * 2, h); frm->resize(s.width(), hButton); frm->move(BALLOON_R, pos + h - BALLOON_R - hButton); QPainter p; p.begin(&mask); #ifdef WIN32 QColor bg(255, 255, 255); QColor fg(0, 0, 0); #else QColor bg(0, 0, 0); QColor fg(255, 255, 255); #endif p.fillRect(0, 0, width(), height(), bg); p.fillRect(0, pos + BALLOON_R, w, h - BALLOON_R * 2, fg); p.fillRect(BALLOON_R, pos, w - BALLOON_R * 2, h, fg); p.fillRect(BALLOON_SHADOW, pos + BALLOON_R + BALLOON_SHADOW, w, h - BALLOON_R * 2, fg); p.fillRect(BALLOON_R + BALLOON_SHADOW, pos + BALLOON_SHADOW, w - BALLOON_R * 2, h, fg); p.setBrush(fg); p.drawEllipse(0, pos, BALLOON_R * 2, BALLOON_R * 2); p.drawEllipse(w - BALLOON_R * 2, pos, BALLOON_R * 2, BALLOON_R * 2); p.drawEllipse(w - BALLOON_R * 2, pos + h - BALLOON_R * 2, BALLOON_R * 2, BALLOON_R * 2); p.drawEllipse(0, pos + h - BALLOON_R * 2, BALLOON_R * 2, BALLOON_R * 2); p.drawEllipse(BALLOON_SHADOW, pos + BALLOON_SHADOW, BALLOON_R * 2, BALLOON_R * 2); p.drawEllipse(w - BALLOON_R * 2 + BALLOON_SHADOW, pos + BALLOON_SHADOW, BALLOON_R * 2, BALLOON_R * 2); p.drawEllipse(w - BALLOON_R * 2 + BALLOON_SHADOW, pos + h - BALLOON_R * 2 + BALLOON_SHADOW, BALLOON_R * 2, BALLOON_R * 2); p.drawEllipse(BALLOON_SHADOW, pos + h - BALLOON_R * 2 + BALLOON_SHADOW, BALLOON_R * 2, BALLOON_R * 2); QPointArray arr(3); arr.setPoint(0, tailX, bTailDown ? h : pos); arr.setPoint(1, tailX + BALLOON_TAIL_WIDTH, bTailDown ? h : pos); arr.setPoint(2, tailX - BALLOON_TAIL_WIDTH, bTailDown ? height() - BALLOON_SHADOW : 0); p.drawPolygon(arr); arr.setPoint(0, tailX + BALLOON_SHADOW, (bTailDown ? h : pos) + BALLOON_SHADOW); arr.setPoint(1, tailX + BALLOON_TAIL_WIDTH + BALLOON_SHADOW, (bTailDown ? h : pos) + BALLOON_SHADOW); arr.setPoint(2, tailX - BALLOON_TAIL_WIDTH + BALLOON_SHADOW, bTailDown ? height() : BALLOON_SHADOW); p.drawPolygon(arr); p.end(); setMask(mask); qApp->syncX(); QPixmap pict = QPixmap::grabWindow(QApplication::desktop()->winId(), x(), y(), width(), height()); intensity(pict, -0.50f); p.begin(&pict); p.setBrush(colorGroup().background()); p.drawEllipse(0, pos, BALLOON_R * 2, BALLOON_R * 2); p.drawEllipse(w - BALLOON_R * 2, pos, BALLOON_R * 2, BALLOON_R * 2); p.drawEllipse(w - BALLOON_R * 2, pos + h - BALLOON_R * 2, BALLOON_R * 2, BALLOON_R * 2); p.drawEllipse(0, pos + h - BALLOON_R * 2, BALLOON_R * 2, BALLOON_R * 2); arr.setPoint(0, tailX, bTailDown ? h - 1 : pos + 1); arr.setPoint(1, tailX + BALLOON_TAIL_WIDTH, bTailDown ? h - 1 : pos + 1); arr.setPoint(2, tailX - BALLOON_TAIL_WIDTH, bTailDown ? height() - BALLOON_SHADOW : 0); p.drawPolygon(arr); p.fillRect(0, pos + BALLOON_R, w, h - BALLOON_R * 2, colorGroup().background()); p.fillRect(BALLOON_R, pos, w - BALLOON_R * 2, h, colorGroup().background()); p.drawLine(0, pos + BALLOON_R, 0, pos + h - BALLOON_R); p.drawLine(w - 1, pos + BALLOON_R, w - 1, pos + h - BALLOON_R); if (bTailDown){ p.drawLine(BALLOON_R, 0, w - BALLOON_R, 0); p.drawLine(BALLOON_R, h - 1, tailX, h - 1); p.drawLine(tailX + BALLOON_TAIL_WIDTH, h - 1, w - BALLOON_R, h - 1); }else{ p.drawLine(BALLOON_R, pos + h - 1, w - BALLOON_R, pos + h - 1); p.drawLine(BALLOON_R, pos, tailX, pos); p.drawLine(tailX + BALLOON_TAIL_WIDTH, pos, w - BALLOON_R, pos); } p.end(); setBackgroundPixmap(pict); setAutoMask(true); if (!bAutoHide) setFocusPolicy(NoFocus); QWidget *top = NULL; if (parent) top = parent->topLevelWidget(); if (top){ raiseWindow(top); top->installEventFilter(this); } }
CVolumeProperties::CVolumeProperties(CVolume *volume) { setWindowTitle(tr("Volume Properties")); tmpVolume = volume; QVBoxLayout *vLayout = new QVBoxLayout(this); nameLabel = new QLabel(tr("Name of volume")); name = new QLineEdit(); name->setText(volume->getName()); vLayout->addWidget(nameLabel); vLayout->addWidget(name); QHBoxLayout *dLayout = new QHBoxLayout(); dimensionsBox = new QGroupBox(tr("Dimension of volume")); dimensionsLabel = new QLabel(tr("%1 x %2 x %3").arg(volume->getWidth()).arg(volume->getHeight()).arg(volume->getDepth())); dLayout->addWidget(dimensionsLabel); dimensionsBox->setLayout(dLayout); vLayout->addWidget(dimensionsBox); QHBoxLayout *pLayout = new QHBoxLayout(); positionBox = new QGroupBox(tr("Position")); x = new QLabel(tr("X:")); y = new QLabel(tr("Y:")); z = new QLabel(tr("Z:")); xv = new QDoubleSpinBox(); xv->setMinimum(-1000); xv->setMaximum(1000); yv = new QDoubleSpinBox(); yv->setMinimum(-1000); yv->setMaximum(1000); zv = new QDoubleSpinBox(); zv->setMinimum(-1000); zv->setMaximum(1000); xv->setValue(volume->getPosition().getX()); yv->setValue(volume->getPosition().getY()); zv->setValue(volume->getPosition().getZ()); pLayout->addWidget(x); pLayout->addWidget(xv); pLayout->addWidget(y); pLayout->addWidget(yv); pLayout->addWidget(z); pLayout->addWidget(zv); positionBox->setLayout(pLayout); vLayout->addWidget(positionBox); QHBoxLayout *arLayout = new QHBoxLayout(); aspectRatioBox = new QGroupBox(tr("Aspect Ratio")); xr = new QLabel(tr("X:")); yr = new QLabel(tr("Y:")); zr = new QLabel(tr("Z:")); xvr = new QDoubleSpinBox(); xvr->setMinimum(-10); xvr->setMaximum(10); yvr = new QDoubleSpinBox(); yvr->setMinimum(-10); yvr->setMaximum(10); zvr = new QDoubleSpinBox(); zvr->setMinimum(-10); zvr->setMaximum(10); xvr->setValue(volume->getAspectRatio(VISc::dX)); yvr->setValue(volume->getAspectRatio(VISc::dY)); zvr->setValue(volume->getAspectRatio(VISc::dZ)); arLayout->addWidget(xr); arLayout->addWidget(xvr); arLayout->addWidget(yr); arLayout->addWidget(yvr); arLayout->addWidget(zr); arLayout->addWidget(zvr); aspectRatioBox->setLayout(arLayout); vLayout->addWidget(aspectRatioBox); QHBoxLayout *cLayout = new QHBoxLayout(); colorLabel = new QLabel(tr("Color:")); colorShower = new QLineEdit(); colorShower->setEnabled(false); QPalette palette( colorShower->palette() ); palette.setColor( QPalette::Base, volume->getColor() ); colorShower->setPalette(palette); tmpColor = volume->getColor(); colorPicker = new QPushButton(tr("Color")); connect(colorPicker, SIGNAL(clicked()), this, SLOT(colorPickerAction())); cLayout->addWidget(colorLabel); cLayout->addWidget(colorShower); cLayout->addWidget(colorPicker); vLayout->addLayout(cLayout); //QHBoxLayout *iLayout = new QHBoxLayout(); //intensityLabel = new QLabel(tr("Intensity")); //intensity = new QDoubleSpinBox(); //intensity->setMinimum(0.0); //intensity->setMaximum(1.0); //intensity->setValue(light->getIntensity()); //iLayout->addWidget(intensityLabel); //iLayout->addWidget(intensity); //intensity->setValue(light->getIntensity()); //vLayout->addLayout(iLayout); QHBoxLayout *buttons = new QHBoxLayout(); ok = new QPushButton(tr("OK")); ok->setDefault(true); connect(ok, SIGNAL(clicked()), this, SLOT(okAction())); cancel = new QPushButton(tr("Cancel")); connect(cancel, SIGNAL(clicked()), this, SLOT(cancelAction())); buttons->addWidget(ok); buttons->addWidget(cancel); vLayout->addLayout(buttons); }
const QColor &TextShow::background() const { return palette().color(QPalette::Active, QColorGroup::Base); }
static int run(int index) { int i, prev = 0; struct iodef *id, *lastidread = 0; unsigned long u, t; if (index >= niodefs) return index; /* state machine! */ for(i = index, id = &iodefs[i]; id->op; i++, id++){ switch(id->op){ case M: if (verbose & vmsg) printk(BIOS_SPEW, "%ld: %s\n", globalmicroseconds(), id->msg); break; case P: palette(); break; case R: u = READ32(id->addr); if (verbose & vio) printk(BIOS_SPEW, "\texpect %08lx\n", id->data); /* we're looking for something. */ if (lastidread->addr == id->addr){ /* they're going to be polling. * just do it 1000 times */ for (t = 0; t < 1000 && id->data != u; t++){ u = READ32(id->addr); } if (verbose & vspin) printk(BIOS_SPEW, "%s: # loops %ld got %08lx want %08lx\n", regname(id->addr), t, u, id->data); } lastidread = id; break; case W: WRITE32(id->data, id->addr); if (id->addr == PCH_PP_CONTROL){ if (verbose & vio) printk(BIOS_SPEW, "PCH_PP_CONTROL\n"); switch(id->data & 0xf){ case 8: break; case 7: break; default: udelay(100000); if (verbose & vio) printk(BIOS_SPEW, "U %d\n", 100000); } } break; case V: if (id->count < 8){ prev = verbose; verbose = id->count; } else { verbose = prev; } printk(BIOS_SPEW, "Change verbosity to %d\n", verbose); break; case I: printk(BIOS_SPEW, "run: return %d\n", i+1); return i+1; break; default: printk(BIOS_SPEW, "BAD TABLE, opcode %d @ %d\n", id->op, i); return -1; } if (id->udelay) udelay(id->udelay); if (i < ARRAY_SIZE(times)) times[i] = globalmicroseconds(); } printk(BIOS_SPEW, "run: return %d\n", i); return i+1; }
QPixmap FoundCountIcon::circledTextPixmap(const QString &text, int height, const QFont &font, const QColor &color) const { QString key = QString("BLI-%1.%2.%3.%4") .arg(text).arg(height).arg(font.toString()).arg(color.rgb()); if (QPixmap* cached = QPixmapCache::find(key)) { return *cached; } // Compute the sizes of the image components: QRectF textRect = QFontMetrics(font).boundingRect(0, 0, /*width=*/1, height, Qt::AlignLeft | Qt::AlignTop, text); qreal xMargin = height / 6; qreal width = xMargin + textRect.width() + xMargin; // Create the gradient image: QPixmap gradient(3 * width, 3 * height); // We double the size to be able to smooth scale down it (== antialiased curves) QPainter gradientPainter(&gradient); #if 1 // Enable the new look of the gradient: const QPalette& palette = m_basketTree->palette(); QColor topColor = palette.color(QPalette::Highlight).lighter(130); //120 QColor topMidColor = palette.color(QPalette::Highlight).lighter(105); //105 QColor bottomMidColor = palette.color(QPalette::Highlight).darker(130); //120 QColor bottomColor = palette.color(QPalette::Highlight); drawGradient(&gradientPainter, topColor, topMidColor, 0, 0, gradient.width(), gradient.height() / 2, /*sunken=*/false, /*horz=*/true, /*flat=*/false); drawGradient(&gradientPainter, bottomMidColor, bottomColor, 0, gradient.height() / 2, gradient.width(), gradient.height() - gradient.height() / 2, /*sunken=*/false, /*horz=*/true, /*flat=*/false); gradientPainter.fillRect(0, 0, gradient.width(), 3, palette.color(QPalette::Highlight)); #else drawGradient(&gradientPainter, palette().color(QPalette::Highlight), palette().color(QPalette::Highlight).darker(), 0, 0, gradient.width(), gradient.height(), /*sunken=*/false, /*horz=*/true, /*flat=*/false); #endif gradientPainter.end(); // Draw the curved rectangle: QBitmap curvedRectangle(3 * width, 3 * height); curvedRectangle.fill(Qt::color0); QPainter curvePainter(&curvedRectangle); curvePainter.setPen(Qt::color1); curvePainter.setBrush(Qt::color1); curvePainter.setClipRect(0, 0, 3*(height / 5), 3*(height)); // If the width is small, don't fill the right part of the pixmap curvePainter.drawEllipse(0, 3*(-height / 4), 3*(height), 3*(height * 3 / 2)); // Don't forget we double the sizes curvePainter.setClipRect(3*(width - height / 5), 0, 3*(height / 5), 3*(height)); curvePainter.drawEllipse(3*(width - height), 3*(-height / 4), 3*(height), 3*(height * 3 / 2)); curvePainter.setClipping(false); curvePainter.fillRect(3*(height / 6), 0, 3*(width - 2 * height / 6), 3*(height), curvePainter.brush()); curvePainter.end(); // Apply the curved rectangle as the mask of the gradient: gradient.setMask(curvedRectangle); QImage resultImage = gradient.toImage(); //resultImage.setAlphaBuffer(true); resultImage.convertToFormat(QImage::Format_ARGB32); // Scale down the image smoothly to get anti-aliasing: QPixmap pmScaled = QPixmap::fromImage(resultImage.scaled(width, height, Qt::IgnoreAspectRatio, Qt::SmoothTransformation)); // Draw the text, and return the result: QPainter painter(&pmScaled); painter.setPen(color); painter.setFont(font); painter.drawText(0 + 1, 0, width, height, Qt::AlignHCenter | Qt::AlignVCenter, text); painter.end(); QPixmapCache::insert(key, pmScaled); return pmScaled; }
void TermWidget::term_termGetFocus() { m_border = palette().color(QPalette::Highlight); emit termGetFocus(this); update(); }
/*! Redraw the liquid in thermometer pipe. \param painter Painter \param pipeRect Bounding rectangle of the pipe without borders */ void QwtThermo::drawLiquid( QPainter *painter, const QRect &pipeRect ) const { painter->save(); painter->setClipRect( pipeRect, Qt::IntersectClip ); painter->setPen( Qt::NoPen ); const QwtScaleMap scaleMap = scaleDraw()->scaleMap(); QRect liquidRect = fillRect( pipeRect ); if ( d_data->colorMap != NULL ) { const QwtInterval interval = scaleDiv().interval().normalized(); // Because the positions of the ticks are rounded // we calculate the colors for the rounded tick values QVector<double> values = qwtTickList( scaleDraw()->scaleDiv() ); if ( scaleMap.isInverting() ) qSort( values.begin(), values.end(), qGreater<double>() ); else qSort( values.begin(), values.end(), qLess<double>() ); int from; if ( !values.isEmpty() ) { from = qRound( scaleMap.transform( values[0] ) ); qwtDrawLine( painter, from, d_data->colorMap->color( interval, values[0] ), pipeRect, liquidRect, d_data->orientation ); } for ( int i = 1; i < values.size(); i++ ) { const int to = qRound( scaleMap.transform( values[i] ) ); for ( int pos = from + 1; pos < to; pos++ ) { const double v = scaleMap.invTransform( pos ); qwtDrawLine( painter, pos, d_data->colorMap->color( interval, v ), pipeRect, liquidRect, d_data->orientation ); } qwtDrawLine( painter, to, d_data->colorMap->color( interval, values[i] ), pipeRect, liquidRect, d_data->orientation ); from = to; } } else { if ( !liquidRect.isEmpty() && d_data->alarmEnabled ) { const QRect r = alarmRect( liquidRect ); if ( !r.isEmpty() ) { painter->fillRect( r, palette().brush( QPalette::Highlight ) ); liquidRect = QRegion( liquidRect ).subtracted( r ).boundingRect(); } } painter->fillRect( liquidRect, palette().brush( QPalette::ButtonText ) ); } painter->restore(); }
void TermWidget::term_termLostFocus() { m_border = palette().color(QPalette::Window); update(); }
/*! \return Liquid ( QPalette::ButtonText ) brush. \sa setFillBrush(), QWidget::palette() */ QBrush QwtThermo::fillBrush() const { return palette().brush( QPalette::ButtonText ); }
void PopupView::init() { if (m_model) { return; } m_scene = new QGraphicsScene(this); m_view = new QGraphicsView(m_scene, this); m_view->setFrameShape(QFrame::NoFrame); m_view->setHorizontalScrollBarPolicy(Qt::ScrollBarAlwaysOff); m_view->setVerticalScrollBarPolicy(Qt::ScrollBarAlwaysOff); m_view->viewport()->setAutoFillBackground(false); m_view->setGeometry(contentsRect()); m_view->show(); DirLister *lister = new DirLister(this); lister->setDelayedMimeTypes(true); lister->setAutoErrorHandlingEnabled(false, 0); lister->openUrl(m_url); m_dirModel = new KDirModel(this); m_dirModel->setDropsAllowed(KDirModel::DropOnDirectory | KDirModel::DropOnLocalExecutable); m_dirModel->setDirLister(lister); m_model = new ProxyModel(this); m_model->setSourceModel(m_dirModel); m_model->setSortLocaleAware(m_parentViewModel->isSortLocaleAware()); m_model->setParseDesktopFiles(m_parentViewModel->parseDesktopFiles()); m_model->setFilterMode(m_parentViewModel->ProxyModel::NoFilter); m_model->setDynamicSortFilter(true); if (!m_parentViewModel->dynamicSortFilter()) { m_model->setSortDirectoriesFirst(true); m_model->sort(int(KDirModel::Name), Qt::AscendingOrder); } else { m_model->setSortDirectoriesFirst(m_parentViewModel->sortDirectoriesFirst()); m_model->sort(m_parentViewModel->sortColumn(), m_parentViewModel->sortOrder()); } m_delegate = new KFileItemDelegate(this); m_selectionModel = new QItemSelectionModel(m_model, this); m_iconView = new IconView(0); m_iconView->setModel(m_model); m_iconView->setItemDelegate(m_delegate); m_iconView->setSelectionModel(m_selectionModel); m_iconView->setFont(m_parentView->font()); m_iconView->setPalette(palette()); m_iconView->setDrawShadows(m_parentView->drawShadows()); m_iconView->setIconSize(m_parentView->iconSize()); m_iconView->setGridSize(m_parentView->gridSize()); m_iconView->setTextLineCount(m_parentView->textLineCount()); m_iconView->setWordWrap(m_parentView->wordWrap()); m_iconView->setIconsMoveable(false); m_iconView->setClickToViewFolders(false); m_iconView->setShowSelectionMarker(m_parentView->showSelectionMarker()); connect(m_iconView, SIGNAL(activated(QModelIndex)), SLOT(activated(QModelIndex))); connect(m_iconView, SIGNAL(contextMenuRequest(QWidget*,QPoint)), SLOT(contextMenuRequest(QWidget*,QPoint))); connect(m_iconView, SIGNAL(busy(bool)), SLOT(setBusy(bool))); connect(m_iconView, SIGNAL(popupViewClosed()), SLOT(maybeClose())); FolderViewAdapter *adapter = new FolderViewAdapter(m_iconView); m_previewGenerator = new KFilePreviewGenerator(adapter, m_model); m_previewGenerator->setPreviewShown(m_showPreview); m_previewGenerator->setEnabledPlugins(m_previewPlugins); m_iconView->setGeometry(contentsRect()); m_iconView->show(); m_scene->addItem(m_iconView); setBusy(true); }
/*! \return Liquid brush ( QPalette::Highlight ) above the alarm threshold. \sa setAlarmBrush(), QWidget::palette() \warning The alarm threshold has no effect, when a color map has been assigned */ QBrush QwtThermo::alarmBrush() const { return palette().brush( QPalette::Highlight ); }
void ZoneViewWidget::paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget) { painter->fillRect(boundingRect(), palette().color(QPalette::Window)); QGraphicsWidget::paint(painter, option, widget); }