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);
}
}
