void SearchButton::paintEvent(QPaintEvent *e) { Q_UNUSED(e); QPainter painter(this); const int h = height(); int iconSize = 16; if (h > 32) iconSize = 22; QPixmap p = IconUtils::icon("edit-find").pixmap(iconSize, iconSize); int x = (width() - p.width() / p.devicePixelRatio()) / 2; int y = (h - p.height() / p.devicePixelRatio()) / 2; painter.drawPixmap(x, y, p); }
QSize DConfigDlgListViewDelegate::sizeHint(const QStyleOptionViewItem& option, const QModelIndex& index) const { if (!index.isValid()) { return QSize(0, 0); } QStyleOptionViewItemV4 opt(option); opt.showDecorationSelected = true; QStyle* const style = opt.widget ? opt.widget->style() : QApplication::style(); int iconSize = style->pixelMetric(QStyle::PM_IconViewIconSize); const QString text = index.model()->data(index, Qt::DisplayRole).toString(); const QIcon icon = index.model()->data(index, Qt::DecorationRole).value<QIcon>(); const QPixmap pixmap = icon.pixmap(iconSize, iconSize); QFontMetrics fm = option.fontMetrics; int gap = fm.height(); int wp = pixmap.width() / pixmap.devicePixelRatio(); int hp = pixmap.height() / pixmap.devicePixelRatio(); if (hp == 0) { /** * No pixmap loaded yet, we'll use the default icon size in this case. */ hp = iconSize; wp = iconSize; } QTextLayout iconTextLayout(text, option.font); int wt = layoutText(&iconTextLayout, qMax(3 * wp, 8 * fm.height())); int ht = iconTextLayout.boundingRect().height(); int width, height; if (text.isEmpty()) { height = hp; } else { height = hp + ht + 10; } width = qMax(wt, wp) + gap; return QSize(width, height); }
void RefineSearchButton::paintEvent(QPaintEvent *) { QColor backgroundColor = palette().windowText().color(); backgroundColor.setAlpha(hovered ? 192 : 170); QPainter painter(this); painter.setRenderHints(QPainter::Antialiasing, true); painter.setPen(Qt::NoPen); painter.setBrush(backgroundColor); painter.drawEllipse(QPoint(width(), height()), width() - 2, height() - 2); QPixmap pixmap = IconUtils::iconPixmap("refine-search", 24, backgroundColor, devicePixelRatioF()); int pw = pixmap.width() / pixmap.devicePixelRatio(); int ph = pixmap.height() / pixmap.devicePixelRatio(); painter.drawPixmap(width() - pw - 6, height() - ph - 6, pw, ph, pixmap); }
void SurfaceImpl::Copy(PRectangle rc, Point from, Surface &surfaceSource) { Q_ASSERT(painter); SurfaceImpl &si = static_cast<SurfaceImpl &>(surfaceSource); if (si.pd) { QPixmap *pm = static_cast<QPixmap *>(si.pd); qreal x = from.x; qreal y = from.y; qreal width = rc.right - rc.left; qreal height = rc.bottom - rc.top; #if QT_VERSION >= 0x050000 qreal dpr = pm->devicePixelRatio(); x *= dpr; y *= dpr; width *= dpr; height *= dpr; #endif painter->drawPixmap(QPointF(rc.left, rc.top), *pm, QRectF(x, y, width, height)); } }
void MainWindow::setPixmap(const QPixmap &pixmap) { pixmapLabel->setPixmap(pixmap); QSize size = pixmap.size() / pixmap.devicePixelRatio(); if (size - QSize(1, 0) == pixmapLabelArea->maximumViewportSize()) size -= QSize(1, 0); pixmapLabel->resize(size); }
QPixmap scalePixmapKeepingAspectRatio(QPixmap pixmap, QSize size, QColor color) { if (pixmap.isNull()) return pixmap; if (pixmap.devicePixelRatio() > 1.0) size *= pixmap.devicePixelRatio(); if (pixmap.size() == size) return pixmap; QPixmap scaledPixmap = pixmap.scaled(size.width(), size.height(), Qt::KeepAspectRatio, Qt::SmoothTransformation); QPixmap newPixmap(size); newPixmap.fill(color); QPainter painter(&newPixmap); painter.drawPixmap(double(size.width() - scaledPixmap.width()) * 0.5, double(size.height() - scaledPixmap.height()) * 0.5, scaledPixmap); newPixmap.setDevicePixelRatio(pixmap.devicePixelRatio()); return newPixmap; }
static qreal pixmapDevicePixelRatio(const QPixmap &pixmap) { #if QT_VERSION > 0x050000 return pixmap.devicePixelRatio(); #else Q_UNUSED(pixmap); return 1.0; #endif }
void DConfigDlgListViewDelegate::paint(QPainter* painter, const QStyleOptionViewItem& option, const QModelIndex& index) const { if (!index.isValid()) { return; } QStyleOptionViewItemV4 opt(option); opt.showDecorationSelected = true; QStyle* const style = opt.widget ? opt.widget->style() : QApplication::style(); int iconSize = style->pixelMetric(QStyle::PM_IconViewIconSize); const QString text = index.model()->data(index, Qt::DisplayRole).toString(); const QIcon icon = index.model()->data(index, Qt::DecorationRole).value<QIcon>(); const QPixmap pixmap = icon.pixmap(iconSize, iconSize); QFontMetrics fm = painter->fontMetrics(); int wp = pixmap.width() / pixmap.devicePixelRatio(); int hp = pixmap.height() / pixmap.devicePixelRatio(); QTextLayout iconTextLayout(text, option.font); QTextOption textOption(Qt::AlignHCenter); iconTextLayout.setTextOption(textOption); int maxWidth = qMax(3 * wp, 8 * fm.height()); layoutText(&iconTextLayout, maxWidth); QPen pen = painter->pen(); QPalette::ColorGroup cg = (option.state & QStyle::State_Enabled) ? QPalette::Normal : QPalette::Disabled; if (cg == QPalette::Normal && !(option.state & QStyle::State_Active)) { cg = QPalette::Inactive; } style->drawPrimitive(QStyle::PE_PanelItemViewItem, &opt, painter, opt.widget); if (option.state & QStyle::State_Selected) { painter->setPen(option.palette.color(cg, QPalette::HighlightedText)); } else { painter->setPen(option.palette.color(cg, QPalette::Text)); } painter->drawPixmap(option.rect.x() + (option.rect.width() / 2) - (wp / 2), option.rect.y() + 5, pixmap); if (!text.isEmpty()) { iconTextLayout.draw(painter, QPoint(option.rect.x() + (option.rect.width() / 2) - (maxWidth / 2), option.rect.y() + hp + 7)); } painter->setPen(pen); drawFocus(painter, option, option.rect); }
//______________________________________________________________________________________ inline qreal devicePixelRatio( const QPixmap& pixmap ) { #if QT_VERSION >= 0x050300 return pixmap.devicePixelRatio(); #else Q_UNUSED( pixmap ); return 1; #endif }
RippleAnimation::Ripple::Ripple(const style::RippleAnimation &st, const QPixmap &mask, Fn<void()> update) : _st(st) , _update(update) , _origin(mask.width() / (2 * cIntRetinaFactor()), mask.height() / (2 * cIntRetinaFactor())) , _radiusFrom(mask.width() + mask.height()) , _frame(mask.size(), QImage::Format_ARGB32_Premultiplied) { _frame.setDevicePixelRatio(mask.devicePixelRatio()); _radiusTo = _radiusFrom; _hide.start(_update, 0., 1., _st.hideDuration); }
static void drawIcon(const QIcon &icon, const QRect &r, QPainter *p, const QSize &iconSize, bool selected) { QPixmap px = icon.pixmap(iconSize, selected ? QIcon::Selected : QIcon::Normal); #if QT_VERSION >= 0x050100 QSize layoutSize = px.size() / px.devicePixelRatio(); #else QSize layoutSize = px.size(); #endif p->drawPixmap(r.x()+(r.width()-layoutSize.width())/2.0, r.y()+(r.height()-layoutSize.height())/2.0, layoutSize.width(), layoutSize.height(), px); }
static QSize getPixmapSize(QTextDocument *doc, const QTextImageFormat &format) { QPixmap pm; const bool hasWidth = format.hasProperty(QTextFormat::ImageWidth); const int width = qRound(format.width()); const bool hasHeight = format.hasProperty(QTextFormat::ImageHeight); const int height = qRound(format.height()); QSize size(width, height); if (!hasWidth || !hasHeight) { pm = getPixmap(doc, format); const int pmWidth = pm.width() / pm.devicePixelRatio(); const int pmHeight = pm.height() / pm.devicePixelRatio(); if (!hasWidth) { if (!hasHeight) size.setWidth(pmWidth); else size.setWidth(qRound(height * (pmWidth / (qreal) pmHeight))); } if (!hasHeight) { if (!hasWidth) size.setHeight(pmHeight); else size.setHeight(qRound(width * (pmHeight / (qreal) pmWidth))); } } qreal scale = 1.0; QPaintDevice *pdev = doc->documentLayout()->paintDevice(); if (pdev) { if (pm.isNull()) pm = getPixmap(doc, format); if (!pm.isNull()) scale = qreal(pdev->logicalDpiY()) / qreal(qt_defaultDpi()); } size *= scale; return size; }
void QWindowsDragCursorWindow::setPixmap(const QPixmap &p) { if (p.cacheKey() == m_pixmap.cacheKey()) return; const QSize oldSize = m_pixmap.size(); QSize newSize = p.size(); qCDebug(lcQpaMime) << __FUNCTION__ << p.cacheKey() << newSize; m_pixmap = p; if (oldSize != newSize) { const qreal pixDevicePixelRatio = p.devicePixelRatio(); if (pixDevicePixelRatio > 1.0 && qFuzzyCompare(pixDevicePixelRatio, devicePixelRatio())) newSize /= qRound(pixDevicePixelRatio); resize(newSize); } if (isVisible()) update(); }
QSize sizeHint(const QStyleOptionViewItem &option, const QModelIndex &index) const { if (standard) { return QStyledItemDelegate::sizeHint(option, index); } if (!index.isValid()) { return QSize(0, 0); } const QString text = index.model()->data(index, Qt::DisplayRole).toString(); const QIcon icon = index.model()->data(index, Qt::DecorationRole).value<QIcon>(); const QPixmap pixmap = icon.pixmap(iconSize, iconSize); QFontMetrics fm = option.fontMetrics; int gap = fm.height(); #if QT_VERSION >= 0x050100 QSize layoutSize = pixmap.size() / pixmap.devicePixelRatio(); #else QSize layoutSize = pixmap.size(); #endif if (layoutSize.height() == 0) { /** * No pixmap loaded yet, we'll use the default icon size in this case. */ layoutSize=QSize(iconSize, iconSize); } QTextLayout iconTextLayout(text, option.font); int wt = layoutText(&iconTextLayout, qMax(3 * layoutSize.width(), 8 * fm.height())); int ht = iconTextLayout.boundingRect().height(); int width, height; if (text.isEmpty()) { height = layoutSize.height(); } else { height = layoutSize.height() + ht + 10; } width = qMax(wt, layoutSize.width()) + gap; return QSize(width, height); }
void QGraphicsGlowEffect::draw(QPainter* painter) { QPoint offset; QPixmap source = sourcePixmap(Qt::LogicalCoordinates, &offset); source = source.scaled(source.size().width()/source.devicePixelRatio(), source.size().height()/source.devicePixelRatio()); QPixmap glow; QGraphicsColorizeEffect *colorize = new QGraphicsColorizeEffect; colorize->setColor(_color); colorize->setStrength(1); glow = applyEffectToPixmap(source, colorize, 0); QGraphicsBlurEffect *blur = new QGraphicsBlurEffect; blur->setBlurRadius(_blurRadius); glow = applyEffectToPixmap(glow, blur, _extent); for (int i = 0; i < _strength; i++) painter->drawPixmap(offset - QPoint(_extent, _extent), glow); drawSource(painter); }
RippleAnimation::Ripple::Ripple(const style::RippleAnimation &st, QPoint origin, int startRadius, const QPixmap &mask, Fn<void()> update) : _st(st) , _update(update) , _origin(origin) , _radiusFrom(startRadius) , _frame(mask.size(), QImage::Format_ARGB32_Premultiplied) { _frame.setDevicePixelRatio(mask.devicePixelRatio()); QPoint points[] = { { 0, 0 }, { _frame.width() / cIntRetinaFactor(), 0 }, { _frame.width() / cIntRetinaFactor(), _frame.height() / cIntRetinaFactor() }, { 0, _frame.height() / cIntRetinaFactor() }, }; for (auto point : points) { accumulate_max(_radiusTo, style::point::dotProduct(_origin - point, _origin - point)); } _radiusTo = qRound(sqrt(_radiusTo)); _show.start(_update, 0., 1., _st.showDuration, anim::easeOutQuint); }
static QPixmap masksToIcon(const MasksAndColors &masks, const QPixmap &combinedMask, Icon::IconStyleOptions style) { QPixmap result(combinedMask.size()); result.setDevicePixelRatio(combinedMask.devicePixelRatio()); result.fill(Qt::transparent); QPainter p(&result); for (MasksAndColors::const_iterator maskImage = masks.constBegin(); maskImage != masks.constEnd(); ++maskImage) { if (style & Icon::PunchEdges && maskImage != masks.constBegin()) { // Punch a transparent outline around an overlay. p.save(); p.setOpacity(0.4); p.setCompositionMode(QPainter::CompositionMode_DestinationOut); smearPixmap(&p, maskToColorAndAlpha((*maskImage).first, Qt::white), 0.5); p.restore(); } p.drawPixmap(0, 0, maskToColorAndAlpha((*maskImage).first, (*maskImage).second)); } if (style & Icon::DropShadow) { const QPixmap shadowMask = maskToColorAndAlpha(combinedMask, Qt::black); p.setCompositionMode(QPainter::CompositionMode_DestinationOver); p.setOpacity(0.05); p.drawPixmap(QPointF(0, -0.501), shadowMask); p.drawPixmap(QPointF(-0.501, 0), shadowMask); p.drawPixmap(QPointF(0.5, 0), shadowMask); p.drawPixmap(QPointF(0.5, 0.5), shadowMask); p.drawPixmap(QPointF(-0.501, 0.5), shadowMask); p.setOpacity(0.2); p.drawPixmap(0, 1, shadowMask); } p.end(); return result; }
void paint(QPainter *painter, const QStyleOptionViewItem &option, const QModelIndex &index) const { if (!index.isValid()) { return; } bool mouseOver=option.state&QStyle::State_MouseOver; bool selected=option.state&QStyle::State_Selected; if (standard) { if (GtkStyle::isActive()) { bool mouseOver=option.state&QStyle::State_MouseOver; QStyleOptionViewItemV4 opt = option; initStyleOption(&opt, index); if (!underMouse) { mouseOver=false; } if (mouseOver) { opt.showDecorationSelected=true; GtkStyle::drawSelection(option, painter, selected ? 0.75 : 0.25); opt.showDecorationSelected=false; opt.state&=~(QStyle::State_MouseOver|QStyle::State_Selected); opt.backgroundBrush=QBrush(Qt::transparent); if (selected) { opt.palette.setBrush(QPalette::Text, opt.palette.highlightedText()); } } QApplication::style()->drawControl(QStyle::CE_ItemViewItem, &opt, painter, opt.widget); } else { QStyledItemDelegate::paint(painter, option, index); } return; } bool gtk=mouseOver && GtkStyle::isActive(); bool drawBgnd=true; if (!underMouse) { if (mouseOver && !selected) { drawBgnd=false; } mouseOver=false; } const QString text = index.model()->data(index, Qt::DisplayRole).toString(); const QIcon icon = index.model()->data(index, Qt::DecorationRole).value<QIcon>(); const QPixmap pixmap = icon.pixmap(iconSize, iconSize); QFontMetrics fm = painter->fontMetrics(); #if QT_VERSION >= 0x050100 QSize layoutSize = pixmap.size() / pixmap.devicePixelRatio(); #else QSize layoutSize = pixmap.size(); #endif QTextLayout iconTextLayout(text, option.font); QTextOption textOption(Qt::AlignHCenter); iconTextLayout.setTextOption(textOption); int maxWidth = qMax(3 * layoutSize.width(), 8 * fm.height()); layoutText(&iconTextLayout, maxWidth); QPen pen = painter->pen(); QPalette::ColorGroup cg = option.state & QStyle::State_Enabled ? QPalette::Normal : QPalette::Disabled; if (cg == QPalette::Normal && !(option.state & QStyle::State_Active)) { cg = QPalette::Inactive; } QStyleOptionViewItemV4 opt(option); opt.showDecorationSelected = true; QStyle *style = opt.widget ? opt.widget->style() : QApplication::style(); if (drawBgnd) { if (mouseOver && gtk) { GtkStyle::drawSelection(opt, painter, selected ? 0.75 : 0.25); } else { style->drawPrimitive(QStyle::PE_PanelItemViewItem, &opt, painter, opt.widget); } } #ifndef Q_OS_WIN if (selected) { painter->setPen(option.palette.color(cg, QPalette::HighlightedText)); } else #endif { painter->setPen(option.palette.color(cg, QPalette::Text)); } painter->drawPixmap(option.rect.x() + (option.rect.width()/2)-(layoutSize.width()/2), option.rect.y() + 5, pixmap); if (!text.isEmpty()) { iconTextLayout.draw(painter, QPoint(option.rect.x() + (option.rect.width()/2)-(maxWidth/2), option.rect.y() + layoutSize.height()+7)); } painter->setPen(pen); drawFocus(painter, option, option.rect); }
void QWindowsOleDropSource::createCursors() { const QDrag *drag = m_drag->currentDrag(); const QPixmap pixmap = drag->pixmap(); const bool hasPixmap = !pixmap.isNull(); // Find screen for drag. Could be obtained from QDrag::source(), but that might be a QWidget. const QPlatformScreen *platformScreen = QWindowsContext::instance()->screenManager().screenAtDp(QWindowsCursor::mousePosition()); if (!platformScreen) { if (const QScreen *primaryScreen = QGuiApplication::primaryScreen()) platformScreen = primaryScreen->handle(); } Q_ASSERT(platformScreen); QPlatformCursor *platformCursor = platformScreen->cursor(); qreal pixmapScaleFactor = 1; qreal hotSpotScaleFactor = 1; if (m_mode != TouchDrag) { // Touch drag: pixmap is shown in a separate QWindow, which will be scaled.) hotSpotScaleFactor = QHighDpiScaling::factor(platformScreen); pixmapScaleFactor = hotSpotScaleFactor / pixmap.devicePixelRatio(); } QPixmap scaledPixmap = qFuzzyCompare(pixmapScaleFactor, 1.0) ? pixmap : pixmap.scaled((QSizeF(pixmap.size()) * pixmapScaleFactor).toSize(), Qt::KeepAspectRatio, Qt::SmoothTransformation); scaledPixmap.setDevicePixelRatio(1); Qt::DropAction actions[] = { Qt::MoveAction, Qt::CopyAction, Qt::LinkAction, Qt::IgnoreAction }; int actionCount = int(sizeof(actions) / sizeof(actions[0])); if (!hasPixmap) --actionCount; // No Qt::IgnoreAction unless pixmap const QPoint hotSpot = qFuzzyCompare(hotSpotScaleFactor, 1.0) ? drag->hotSpot() : (QPointF(drag->hotSpot()) * hotSpotScaleFactor).toPoint(); for (int cnum = 0; cnum < actionCount; ++cnum) { const Qt::DropAction action = actions[cnum]; QPixmap cursorPixmap = drag->dragCursor(action); if (cursorPixmap.isNull() && platformCursor) cursorPixmap = static_cast<QWindowsCursor *>(platformCursor)->dragDefaultCursor(action); const qint64 cacheKey = cursorPixmap.cacheKey(); const auto it = m_cursors.find(action); if (it != m_cursors.end() && it.value().cacheKey == cacheKey) continue; if (cursorPixmap.isNull()) { qWarning("%s: Unable to obtain drag cursor for %d.", __FUNCTION__, action); continue; } QPoint newHotSpot(0, 0); QPixmap newPixmap = cursorPixmap; if (hasPixmap) { const int x1 = qMin(-hotSpot.x(), 0); const int x2 = qMax(scaledPixmap.width() - hotSpot.x(), cursorPixmap.width()); const int y1 = qMin(-hotSpot.y(), 0); const int y2 = qMax(scaledPixmap.height() - hotSpot.y(), cursorPixmap.height()); QPixmap newCursor(x2 - x1 + 1, y2 - y1 + 1); newCursor.fill(Qt::transparent); QPainter p(&newCursor); const QPoint pmDest = QPoint(qMax(0, -hotSpot.x()), qMax(0, -hotSpot.y())); p.drawPixmap(pmDest, scaledPixmap); p.drawPixmap(qMax(0, hotSpot.x()),qMax(0, hotSpot.y()), cursorPixmap); newPixmap = newCursor; newHotSpot = QPoint(qMax(0, hotSpot.x()), qMax(0, hotSpot.y())); } if (const HCURSOR sysCursor = QWindowsCursor::createPixmapCursor(newPixmap, newHotSpot)) { const CursorEntry entry(newPixmap, cacheKey, CursorHandlePtr(new CursorHandle(sysCursor)), newHotSpot); if (it == m_cursors.end()) m_cursors.insert(action, entry); else it.value() = entry; } } #ifndef QT_NO_DEBUG_OUTPUT if (lcQpaMime().isDebugEnabled()) qCDebug(lcQpaMime) << __FUNCTION__ << "pixmap" << pixmap.size() << m_cursors.size() << "cursors:\n" << m_cursors; #endif // !QT_NO_DEBUG_OUTPUT }
const QPixmap *VehicleIcons::pixmapFromCache(const PixmapKey& key, int rotate) { if(aircraftPixmaps.contains(key)) return aircraftPixmaps.object(key); else { int size = key.size; QString name = ":/littlenavmap/resources/icons/aircraft"; switch(key.type) { case AC_ONLINE: name += "_online"; break; case AC_SMALL: name += "_small"; break; case AC_JET: name += "_jet"; break; case AC_HELICOPTER: name += "_helicopter"; // Make helicopter a bit bigger due to image size = atools::roundToInt(size * 1.2f); break; case AC_SHIP: name += "_boat"; break; } if(key.ground) name += "_ground"; if(key.type != AC_ONLINE && key.user) // No user key for online name += "_user"; name = atools::settings::Settings::instance().getOverloadedPath(name + ".svg"); QPixmap *newPx = nullptr; QPixmap pixmap = QIcon(name).pixmap(QSize(size, size)); if(rotate == 0) newPx = new QPixmap(pixmap); else { QPixmap painterPixmap(size, size); painterPixmap.fill(QColor(Qt::transparent)); QPainter painter(&painterPixmap); painter.setRenderHint(QPainter::Antialiasing, true); painter.setRenderHint(QPainter::TextAntialiasing, true); painter.setRenderHint(QPainter::SmoothPixmapTransform, true); painter.translate(size / 2.f, size / 2.f); painter.rotate(rotate); painter.drawPixmap(QPointF(-size / 2.f, -size / 2.f), pixmap, QRectF(0, 0, size * pixmap.devicePixelRatio(), size * pixmap.devicePixelRatio())); painter.resetTransform(); newPx = new QPixmap(painterPixmap); } aircraftPixmaps.insert(key, newPx); return newPx; } }
void ManhattanStyle::drawControl(ControlElement element, const QStyleOption *option, QPainter *painter, const QWidget *widget) const { if (!panelWidget(widget)) return QProxyStyle::drawControl(element, option, painter, widget); switch (element) { case CE_Splitter: painter->fillRect(option->rect, StyleHelper::borderColor()); break; case CE_TabBarTabShape: // Most styles draw a single dark outline. This looks rather ugly when combined with our // single pixel dark separator so we adjust the first tab to compensate for this if (const QStyleOptionTabV3 *tab = qstyleoption_cast<const QStyleOptionTabV3 *>(option)) { QStyleOptionTabV3 adjustedTab = *tab; if (tab->cornerWidgets == QStyleOptionTab::NoCornerWidgets && ( tab->position == QStyleOptionTab::Beginning || tab->position == QStyleOptionTab::OnlyOneTab)) { if (option->direction == Qt::LeftToRight) adjustedTab.rect = adjustedTab.rect.adjusted(-1, 0, 0, 0); else adjustedTab.rect = adjustedTab.rect.adjusted(0, 0, 1 ,0); } QProxyStyle::drawControl(element, &adjustedTab, painter, widget); return; } break; case CE_MenuBarItem: painter->save(); if (const QStyleOptionMenuItem *mbi = qstyleoption_cast<const QStyleOptionMenuItem *>(option)) { QColor highlightOutline = StyleHelper::borderColor().lighter(120); bool act = mbi->state & State_Sunken; bool dis = !(mbi->state & State_Enabled); StyleHelper::menuGradient(painter, option->rect, option->rect); QStyleOptionMenuItem item = *mbi; item.rect = mbi->rect; QPalette pal = mbi->palette; pal.setBrush(QPalette::ButtonText, dis ? Qt::gray : Qt::black); item.palette = pal; QCommonStyle::drawControl(element, &item, painter, widget); QRect r = option->rect; if (act) { // Fill| QColor baseColor = StyleHelper::baseColor(); QLinearGradient grad(option->rect.topLeft(), option->rect.bottomLeft()); grad.setColorAt(0, baseColor.lighter(120)); grad.setColorAt(1, baseColor.lighter(130)); painter->fillRect(option->rect.adjusted(1, 1, -1, 0), grad); // Outline painter->setPen(QPen(highlightOutline, 0)); painter->drawLine(QPoint(r.left(), r.top() + 1), QPoint(r.left(), r.bottom())); painter->drawLine(QPoint(r.right(), r.top() + 1), QPoint(r.right(), r.bottom())); painter->drawLine(QPoint(r.left() + 1, r.top()), QPoint(r.right() - 1, r.top())); highlightOutline.setAlpha(60); painter->setPen(QPen(highlightOutline, 0)); painter->drawPoint(r.topLeft()); painter->drawPoint(r.topRight()); QPalette pal = mbi->palette; uint alignment = Qt::AlignCenter | Qt::TextShowMnemonic | Qt::TextDontClip | Qt::TextSingleLine; if (!styleHint(SH_UnderlineShortcut, mbi, widget)) alignment |= Qt::TextHideMnemonic; pal.setBrush(QPalette::Text, dis ? Qt::gray : QColor(0, 0, 0, 60)); drawItemText(painter, item.rect.translated(0, 1), alignment, pal, mbi->state & State_Enabled, mbi->text, QPalette::Text); pal.setBrush(QPalette::Text, dis ? Qt::gray : Qt::white); drawItemText(painter, item.rect, alignment, pal, mbi->state & State_Enabled, mbi->text, QPalette::Text); } } painter->restore(); break; case CE_ComboBoxLabel: if (const QStyleOptionComboBox *cb = qstyleoption_cast<const QStyleOptionComboBox *>(option)) { if (panelWidget(widget)) { painter->save(); QRect editRect = subControlRect(CC_ComboBox, cb, SC_ComboBoxEditField, widget); QPalette customPal = cb->palette; bool drawIcon = !(widget && widget->property("hideicon").toBool()); if (!cb->currentIcon.isNull() && drawIcon) { QIcon::Mode mode = cb->state & State_Enabled ? QIcon::Normal : QIcon::Disabled; QPixmap pixmap = cb->currentIcon.pixmap(cb->iconSize, mode); QRect iconRect(editRect); iconRect.setWidth(cb->iconSize.width() + 4); iconRect = alignedRect(cb->direction, Qt::AlignLeft | Qt::AlignVCenter, iconRect.size(), editRect); if (cb->editable) painter->fillRect(iconRect, customPal.brush(QPalette::Base)); drawItemPixmap(painter, iconRect, Qt::AlignCenter, pixmap); if (cb->direction == Qt::RightToLeft) editRect.translate(-4 - cb->iconSize.width(), 0); else editRect.translate(cb->iconSize.width() + 4, 0); // Reserve some space for the down-arrow editRect.adjust(0, 0, -13, 0); } QLatin1Char asterisk('*'); int elideWidth = editRect.width(); bool notElideAsterisk = widget && widget->property("notelideasterisk").toBool() && cb->currentText.endsWith(asterisk) && option->fontMetrics.width(cb->currentText) > elideWidth; QString text; if (notElideAsterisk) { elideWidth -= option->fontMetrics.width(asterisk); text = asterisk; } text.prepend(option->fontMetrics.elidedText(cb->currentText, Qt::ElideRight, elideWidth)); if ((option->state & State_Enabled)) { painter->setPen(QColor(0, 0, 0, 70)); painter->drawText(editRect.adjusted(1, 0, -1, 0), Qt::AlignLeft | Qt::AlignVCenter, text); } else { painter->setOpacity(0.8); } painter->setPen(StyleHelper::panelTextColor()); painter->drawText(editRect.adjusted(1, 0, -1, 0), Qt::AlignLeft | Qt::AlignVCenter, text); painter->restore(); } else { QProxyStyle::drawControl(element, option, painter, widget); } } break; case CE_SizeGrip: { painter->save(); QColor dark = Qt::white; dark.setAlphaF(0.1); int x, y, w, h; option->rect.getRect(&x, &y, &w, &h); int sw = qMin(h, w); if (h > w) painter->translate(0, h - w); else painter->translate(w - h, 0); int sx = x; int sy = y; int s = 4; painter->setPen(dark); if (option->direction == Qt::RightToLeft) { sx = x + sw; for (int i = 0; i < 4; ++i) { painter->drawLine(x, sy, sx, sw); sx -= s; sy += s; } } else { for (int i = 0; i < 4; ++i) { painter->drawLine(sx, sw, sw, sy); sx += s; sy += s; } } painter->restore(); } break; case CE_MenuBarEmptyArea: { StyleHelper::menuGradient(painter, option->rect, option->rect); painter->save(); painter->setPen(StyleHelper::borderColor()); painter->drawLine(option->rect.bottomLeft(), option->rect.bottomRight()); painter->restore(); } break; case CE_ToolBar: { QRect rect = option->rect; bool horizontal = option->state & State_Horizontal; rect = option->rect; // Map offset for global window gradient QPoint offset = widget->window()->mapToGlobal(option->rect.topLeft()) - widget->mapToGlobal(option->rect.topLeft()); QRect gradientSpan; if (widget) gradientSpan = QRect(offset, widget->window()->size()); bool drawLightColored = lightColored(widget); if (horizontal) StyleHelper::horizontalGradient(painter, gradientSpan, rect, drawLightColored); else StyleHelper::verticalGradient(painter, gradientSpan, rect, drawLightColored); if (!drawLightColored) painter->setPen(StyleHelper::borderColor()); else painter->setPen(QColor(0x888888)); if (horizontal) { // Note: This is a hack to determine if the // toolbar should draw the top or bottom outline // (needed for the find toolbar for instance) QColor lighter(StyleHelper::sidebarHighlight()); if (drawLightColored) lighter = QColor(255, 255, 255, 180); if (widget && widget->property("topBorder").toBool()) { painter->drawLine(rect.topLeft(), rect.topRight()); painter->setPen(lighter); painter->drawLine(rect.topLeft() + QPoint(0, 1), rect.topRight() + QPoint(0, 1)); } else { painter->drawLine(rect.bottomLeft(), rect.bottomRight()); painter->setPen(lighter); painter->drawLine(rect.topLeft(), rect.topRight()); } } else { painter->drawLine(rect.topLeft(), rect.bottomLeft()); painter->drawLine(rect.topRight(), rect.bottomRight()); } } break; #if defined(Q_OS_MAC) case CE_ToolButtonLabel: if (const QStyleOptionToolButton *tb = qstyleoption_cast<const QStyleOptionToolButton *>(option)) { QStyleOptionToolButton myTb = *tb; myTb.state &= ~State_AutoRaise; QRect cr = tb->rect; bool needText = false; int alignment = 0; bool down = tb->state & (State_Sunken | State_On); // The down state is special for QToolButtons in a toolbar on the Mac // The text is a bit bolder and gets a drop shadow and the icons are also darkened. // This doesn't really fit into any particular case in QIcon, so we // do the majority of the work ourselves. if (!(tb->features & QStyleOptionToolButton::Arrow)) { Qt::ToolButtonStyle tbstyle = tb->toolButtonStyle; if (tb->icon.isNull() && !tb->text.isEmpty()) tbstyle = Qt::ToolButtonTextOnly; switch (tbstyle) { case Qt::ToolButtonTextOnly: { needText = true; alignment = Qt::AlignCenter; break; } case Qt::ToolButtonIconOnly: case Qt::ToolButtonTextBesideIcon: case Qt::ToolButtonTextUnderIcon: { QRect pr = cr; QIcon::Mode iconMode = (tb->state & State_Enabled) ? QIcon::Normal : QIcon::Disabled; QIcon::State iconState = (tb->state & State_On) ? QIcon::On : QIcon::Off; QPixmap pixmap = tb->icon.pixmap(tb->rect.size().boundedTo(tb->iconSize), iconMode, iconState); // Draw the text if it's needed. if (tb->toolButtonStyle != Qt::ToolButtonIconOnly) { needText = true; if (tb->toolButtonStyle == Qt::ToolButtonTextUnderIcon) { QMainWindow *mw = widget ? qobject_cast<QMainWindow *>(widget->window()) : 0; if (mw && mw->unifiedTitleAndToolBarOnMac()) { pr.setHeight(pixmap.size().height() / pixmap.devicePixelRatio()); cr.adjust(0, pr.bottom() + 1, 0, 1); } else { pr.setHeight(pixmap.size().height() / pixmap.devicePixelRatio() + 6); cr.adjust(0, pr.bottom(), 0, -3); } alignment |= Qt::AlignCenter; } else { pr.setWidth(pixmap.width() / pixmap.devicePixelRatio() + 8); cr.adjust(pr.right(), 0, 0, 0); alignment |= Qt::AlignLeft | Qt::AlignVCenter; } } proxy()->drawItemPixmap(painter, pr, Qt::AlignCenter, pixmap); break; } default: Q_ASSERT(false); break; } if (needText) { QPalette pal = tb->palette; QPalette::ColorRole role = QPalette::WindowText; if (!proxy()->styleHint(SH_UnderlineShortcut, tb, widget)) alignment |= Qt::TextHideMnemonic; if (tbstyle == Qt::ToolButtonTextOnly || (tbstyle != Qt::ToolButtonTextOnly && !down)) { painter->drawText(cr, alignment, tb->text); if (down && tbstyle == Qt::ToolButtonTextOnly) { pal = QApplication::palette("QMenu"); pal.setCurrentColorGroup(tb->palette.currentColorGroup()); role = QPalette::HighlightedText; } } proxy()->drawItemText(painter, cr, alignment, pal, tb->state & State_Enabled, tb->text, role); } } else { QProxyStyle::drawControl(element, option, painter, widget); } } break; #endif default: QProxyStyle::drawControl(element, option, painter, widget); break; } }
void QPaintEngineEx::drawPixmap(const QPointF &pos, const QPixmap &pm) { drawPixmap(QRectF(pos, pm.size() / pm.devicePixelRatio()), pm, pm.rect()); }
/*! Initialize \a option with the values using the index \a index. This method is useful for subclasses when they need a QStyleOptionViewItem, but don't want to fill in all the information themselves. \sa QStyleOption::initFrom() */ void QStyledItemDelegate::initStyleOption(QStyleOptionViewItem *option, const QModelIndex &index) const { QVariant value = index.data(Qt::FontRole); if (value.isValid() && !value.isNull()) { option->font = qvariant_cast<QFont>(value).resolve(option->font); option->fontMetrics = QFontMetrics(option->font); } value = index.data(Qt::TextAlignmentRole); if (value.isValid() && !value.isNull()) option->displayAlignment = Qt::Alignment(value.toInt()); value = index.data(Qt::ForegroundRole); if (value.canConvert<QBrush>()) option->palette.setBrush(QPalette::Text, qvariant_cast<QBrush>(value)); option->index = index; value = index.data(Qt::CheckStateRole); if (value.isValid() && !value.isNull()) { option->features |= QStyleOptionViewItem::HasCheckIndicator; option->checkState = static_cast<Qt::CheckState>(value.toInt()); } value = index.data(Qt::DecorationRole); if (value.isValid() && !value.isNull()) { option->features |= QStyleOptionViewItem::HasDecoration; switch (value.type()) { case QVariant::Icon: { option->icon = qvariant_cast<QIcon>(value); QIcon::Mode mode; if (!(option->state & QStyle::State_Enabled)) mode = QIcon::Disabled; else if (option->state & QStyle::State_Selected) mode = QIcon::Selected; else mode = QIcon::Normal; QIcon::State state = option->state & QStyle::State_Open ? QIcon::On : QIcon::Off; QSize actualSize = option->icon.actualSize(option->decorationSize, mode, state); // For highdpi icons actualSize might be larger than decorationSize, which we don't want. Clamp it to decorationSize. option->decorationSize = QSize(qMin(option->decorationSize.width(), actualSize.width()), qMin(option->decorationSize.height(), actualSize.height())); break; } case QVariant::Color: { QPixmap pixmap(option->decorationSize); pixmap.fill(qvariant_cast<QColor>(value)); option->icon = QIcon(pixmap); break; } case QVariant::Image: { QImage image = qvariant_cast<QImage>(value); option->icon = QIcon(QPixmap::fromImage(image)); option->decorationSize = image.size() / image.devicePixelRatio(); break; } case QVariant::Pixmap: { QPixmap pixmap = qvariant_cast<QPixmap>(value); option->icon = QIcon(pixmap); option->decorationSize = pixmap.size() / pixmap.devicePixelRatio(); break; } default: break; } } value = index.data(Qt::DisplayRole); if (value.isValid() && !value.isNull()) { option->features |= QStyleOptionViewItem::HasDisplay; option->text = displayText(value, option->locale); } option->backgroundBrush = qvariant_cast<QBrush>(index.data(Qt::BackgroundRole)); // disable style animations for checkboxes etc. within itemviews (QTBUG-30146) option->styleObject = 0; }
void MiamStyle::drawControl(ControlElement element, const QStyleOption *option, QPainter *painter, const QWidget *widget) const { switch (element) { #if !defined(Q_OS_OSX) case CE_Splitter: break; #endif case CE_MenuBarItem:{ const QStyleOptionMenuItem *somi = static_cast<const QStyleOptionMenuItem*>(option); const bool act = somi->state & (State_Sunken | State_Selected); QPalette palette = QApplication::palette(); QBrush brush; if (act) { painter->setPen(palette.highlight().color()); brush = palette.highlight().color().lighter(); painter->setBrush(brush); painter->drawRect(option->rect.adjusted(0, 0, -1, -1)); } else { brush = palette.window(); painter->fillRect(option->rect, palette.window()); } uint alignment = Qt::AlignCenter | Qt::TextShowMnemonic | Qt::TextDontClip | Qt::TextSingleLine; if (!styleHint(SH_UnderlineShortcut, somi, widget)) { alignment |= Qt::TextHideMnemonic; } if (somi->state.testFlag(QStyle::State_Enabled)) { if (SettingsPrivate::instance()->isCustomTextColorOverriden()) { if (act) { painter->setPen(palette.highlightedText().color()); } else { painter->setPen(palette.text().color()); } } else { if (qAbs(palette.text().color().value() - brush.color().value()) < 128) { painter->setPen(palette.highlightedText().color()); } else { painter->setPen(palette.text().color()); } } } /*else if (act) { painter->setPen(palette.mid().color()); }*/ painter->drawText(option->rect, alignment, somi->text); break; } case CE_MenuItem: if (const QStyleOptionMenuItem *menuitem = qstyleoption_cast<const QStyleOptionMenuItem *>(option)) { QGuiApplication *app = static_cast<QGuiApplication*>(QGuiApplication::instance()); qreal checkcol = 25 / app->devicePixelRatio(); qreal gutterWidth = 3 / app->devicePixelRatio(); QRect rect = option->rect; //draw vertical menu line if (option->direction == Qt::LeftToRight) checkcol += rect.x(); int x, y, w, h; menuitem->rect.getRect(&x, &y, &w, &h); int tab = menuitem->tabWidth; bool dis = !(menuitem->state & State_Enabled); bool checked = menuitem->checkType != QStyleOptionMenuItem::NotCheckable ? menuitem->checked : false; bool act = menuitem->state & State_Selected; QPalette palette = QApplication::palette(); if (menuitem->menuItemType == QStyleOptionMenuItem::Separator) { int yoff = y - 1 + h / 2; qreal separatorSize = 6 / app->devicePixelRatio(); QPoint p1 = QPoint(x + checkcol, yoff); QPoint p2 = QPoint(x + w + separatorSize, yoff); painter->save(); painter->fillRect(menuitem->rect, palette.window()); painter->setPen(palette.mid().color()); painter->drawLine(p1, p2); painter->restore(); return; } QString s = menuitem->text; QBrush fill; if (act) { fill = palette.highlight().color().lighter(); } else { fill = palette.window(); } painter->fillRect(menuitem->rect, fill); QRect vCheckRect = visualRect(option->direction, menuitem->rect, QRect(menuitem->rect.x(), menuitem->rect.y(), checkcol - (gutterWidth + menuitem->rect.x()), menuitem->rect.height())); if (checked) { QStyleOptionMenuItem newMi = *menuitem; int windowsItemFrame = 2; newMi.rect = visualRect(option->direction, menuitem->rect, QRect(menuitem->rect.x() + windowsItemFrame, menuitem->rect.y() + windowsItemFrame, checkcol - 2 * windowsItemFrame, menuitem->rect.height() - 2 * windowsItemFrame) ); painter->setRenderHint(QPainter::Antialiasing, true); proxy()->drawPrimitive(PE_IndicatorMenuCheckMark, &newMi, painter, widget); painter->setRenderHint(QPainter::Antialiasing, false); } if (!menuitem->icon.isNull()) { QIcon::Mode mode = dis ? QIcon::Disabled : QIcon::Normal; if (act && !dis) { mode = QIcon::Active; } QPixmap pixmap; if (checked) { pixmap = menuitem->icon.pixmap(proxy()->pixelMetric(PM_SmallIconSize, option, widget), mode, QIcon::On); } else { pixmap = menuitem->icon.pixmap(proxy()->pixelMetric(PM_SmallIconSize, option, widget), mode); } const int pixw = pixmap.width() / pixmap.devicePixelRatio(); const int pixh = pixmap.height() / pixmap.devicePixelRatio(); QRect pmr(0, 0, pixw, pixh); pmr.moveCenter(vCheckRect.center()); painter->setPen(palette.text().color()); painter->drawPixmap(pmr.topLeft(), pixmap); } //painter->setPen(palette.buttonText().color()); QColor textColor = palette.text().color(); if (dis) { textColor = palette.mid().color(); painter->setPen(textColor); } else if (act && SettingsPrivate::instance()->isCustomTextColorOverriden()) { textColor = palette.highlightedText().color(); painter->setPen(textColor); } int xm = checkcol + 2 + (gutterWidth - menuitem->rect.x()) - 1; int xpos = menuitem->rect.x() + xm; /// int windowsItemVMargin = 3, windowsRightBorder = 3; QRect textRect(xpos, y + windowsItemVMargin, w - xm - windowsRightBorder - tab + 1, h - 2 * windowsItemVMargin); QRect vTextRect = visualRect(option->direction, menuitem->rect, textRect); if (!s.isEmpty()) { // draw text painter->save(); int t = s.indexOf(QLatin1Char('\t')); int text_flags = Qt::AlignVCenter | Qt::TextShowMnemonic | Qt::TextDontClip | Qt::TextSingleLine; if (!proxy()->styleHint(SH_UnderlineShortcut, menuitem, widget)) { text_flags |= Qt::TextHideMnemonic; } text_flags |= Qt::AlignLeft; if (t >= 0) { QRect vShortcutRect = visualRect(option->direction, menuitem->rect, QRect(textRect.topRight(), QPoint(menuitem->rect.right(), textRect.bottom()))); painter->drawText(vShortcutRect, text_flags, s.mid(t + 1)); s = s.left(t); } QFont font = menuitem->font; if (menuitem->menuItemType == QStyleOptionMenuItem::DefaultItem) { font.setBold(true); } painter->setFont(font); painter->setPen(textColor); painter->drawText(vTextRect, text_flags, s.left(t)); painter->restore(); } if (menuitem->menuItemType == QStyleOptionMenuItem::SubMenu) {// draw sub menu arrow int dim = (h - 2 * 5) / 2; PrimitiveElement arrow; arrow = (option->direction == Qt::RightToLeft) ? PE_IndicatorArrowLeft : PE_IndicatorArrowRight; xpos = x + w - 2 - 2 - dim; QRect vSubMenuRect = visualRect(option->direction, menuitem->rect, QRect(xpos, y + h / 2 - dim / 2, dim, dim)); QStyleOptionMenuItem newMI = *menuitem; newMI.rect = vSubMenuRect; newMI.state = dis ? State_None : State_Enabled; proxy()->drawPrimitive(arrow, &newMI, painter, widget); } } break; case CE_MenuBarEmptyArea:{ painter->fillRect(option->rect, QApplication::palette().window()); break; } default: QProxyStyle::drawControl(element, option, painter, widget); } }