From deca5e502114683f1b1574cd931853a353a91821 Mon Sep 17 00:00:00 2001 From: Jonas Kvinge Date: Wed, 24 Apr 2019 23:43:09 +0200 Subject: [PATCH] Update stylehelper --- src/CMakeLists.txt | 2 +- src/core/stylehelper.cpp | 550 +++++++++++++++++++++++++++++++++++++++ src/core/stylehelper.h | 109 ++++++++ 3 files changed, 660 insertions(+), 1 deletion(-) create mode 100644 src/core/stylehelper.cpp create mode 100644 src/core/stylehelper.h diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt index 352b28468..6dc95d9b7 100644 --- a/src/CMakeLists.txt +++ b/src/CMakeLists.txt @@ -98,6 +98,7 @@ set(SOURCES core/signalchecker.cpp core/song.cpp core/songloader.cpp + core/stylehelper.cpp core/stylesheetloader.cpp core/tagreaderclient.cpp core/taskmanager.cpp @@ -245,7 +246,6 @@ set(SOURCES widgets/volumeslider.cpp widgets/stickyslider.cpp widgets/stretchheaderview.cpp - widgets/stylehelper.cpp widgets/trackslider.cpp widgets/tracksliderpopup.cpp widgets/tracksliderslider.cpp diff --git a/src/core/stylehelper.cpp b/src/core/stylehelper.cpp new file mode 100644 index 000000000..002a8265a --- /dev/null +++ b/src/core/stylehelper.cpp @@ -0,0 +1,550 @@ +/**************************************************************************** +** +** Copyright (C) 2016 The Qt Company Ltd. +** Contact: https://www.qt.io/licensing/ +** +** This file is part of Qt Creator. +** +** Commercial License Usage +** Licensees holding valid commercial Qt licenses may use this file in +** accordance with the commercial license agreement provided with the +** Software or, alternatively, in accordance with the terms contained in +** a written agreement between you and The Qt Company. For licensing terms +** and conditions see https://www.qt.io/terms-conditions. For further +** information use the contact form at https://www.qt.io/contact-us. +** +** GNU General Public License Usage +** Alternatively, this file may be used under the terms of the GNU +** General Public License version 3 as published by the Free Software +** Foundation with exceptions as appearing in the file LICENSE.GPL3-EXCEPT +** included in the packaging of this file. Please review the following +** information to ensure the GNU General Public License requirements will +** be met: https://www.gnu.org/licenses/gpl-3.0.html. +** +****************************************************************************/ + +#include "stylehelper.h" + +#include +#include +#include +#include +#include +#include +#include +#include + +// Clamps float color values within (0, 255) +static int clamp(float x) { + const int val = x > 255 ? 255 : static_cast(x); + return val < 0 ? 0 : val; +} + +// Clamps float color values within (0, 255) +/* +static int range(float x, int min, int max) { + int val = x > max ? max : x; + return val < min ? min : val; +} +*/ + +namespace Utils { + +QColor StyleHelper::m_baseColor; +QColor StyleHelper::m_requestedBaseColor; +QColor StyleHelper::m_IconsBaseColor=0xffdcdcdc; +QColor StyleHelper::m_IconsDisabledColor=0x88a0a0a0; +QColor StyleHelper::m_ProgressBarTitleColor = 0xffffffff; + +QColor StyleHelper::mergedColors(const QColor &colorA, const QColor &colorB, int factor) { + + const int maxFactor = 100; + QColor tmp = colorA; + tmp.setRed((tmp.red() * factor) / maxFactor + (colorB.red() * (maxFactor - factor)) / maxFactor); + tmp.setGreen((tmp.green() * factor) / maxFactor + (colorB.green() * (maxFactor - factor)) / maxFactor); + tmp.setBlue((tmp.blue() * factor) / maxFactor + (colorB.blue() * (maxFactor - factor)) / maxFactor); + return tmp; + +} + +QColor StyleHelper::alphaBlendedColors(const QColor &colorA, const QColor &colorB) { + + const int alpha = colorB.alpha(); + const int antiAlpha = 255 - alpha; + + return QColor( + (colorA.red() * antiAlpha + colorB.red() * alpha) / 255, + (colorA.green() * antiAlpha + colorB.green() * alpha) / 255, + (colorA.blue() * antiAlpha + colorB.blue() * alpha) / 255 + ); +} + +qreal StyleHelper::sidebarFontSize() { +#ifdef Q_OS_MACOS + return 10; +#else + return 7.5; +#endif +} + +QColor StyleHelper::notTooBrightHighlightColor() { + + QColor highlightColor = QApplication::palette().highlight().color(); + if (0.5 * highlightColor.saturationF() + 0.75 - highlightColor.valueF() < 0) + highlightColor.setHsvF(highlightColor.hsvHueF(), 0.1 + highlightColor.saturationF() * 2.0, highlightColor.valueF()); + return highlightColor; + +} + +QPalette StyleHelper::sidebarFontPalette(const QPalette &original) { + + QPalette palette = original; + const QColor textColor = m_ProgressBarTitleColor; + palette.setColor(QPalette::WindowText, textColor); + palette.setColor(QPalette::Text, textColor); + return palette; + +} + +QColor StyleHelper::panelTextColor(bool lightColored) { + + if (!lightColored) + return Qt::white; + else + return Qt::black; + +} + +QColor StyleHelper::baseColor(bool lightColored) { + + if (!lightColored) + return m_baseColor; + else + return m_baseColor.lighter(230); + +} + +QColor StyleHelper::highlightColor(bool lightColored) { + + QColor result = baseColor(lightColored); + if (!lightColored) + result.setHsv(result.hue(), clamp(result.saturation()), clamp(result.value() * 1.16)); + else + result.setHsv(result.hue(), clamp(result.saturation()), clamp(result.value() * 1.06)); + return result; + +} + +QColor StyleHelper::shadowColor(bool lightColored) { + + QColor result = baseColor(lightColored); + result.setHsv(result.hue(), clamp(result.saturation() * 1.1), clamp(result.value() * 0.70)); + return result; + +} + +QColor StyleHelper::borderColor(bool lightColored) { + + QColor result = baseColor(lightColored); + result.setHsv(result.hue(), result.saturation(), result.value() / 2); + return result; + +} + +QColor StyleHelper::toolBarBorderColor() { + + const QColor base = baseColor(); + return QColor::fromHsv(base.hue(), base.saturation(), clamp(base.value() * 0.80f)); + +} + +// We try to ensure that the actual color used are within reasonalbe bounds while generating the actual baseColor from the users request. +void StyleHelper::setBaseColor(const QColor &newcolor) { + + m_requestedBaseColor = newcolor; + + QColor color; + color.setHsv(newcolor.hue(), newcolor.saturation() * 0.7, 64 + newcolor.value() / 3); + + if (color.isValid() && color != m_baseColor) { + m_baseColor = color; + for (QWidget* w : QApplication::topLevelWidgets()) { + w->update(); + } + } + +} + +static void verticalGradientHelper(QPainter *p, const QRect &spanRect, const QRect &rect, bool lightColored) { + + QColor highlight = StyleHelper::highlightColor(lightColored); + QColor shadow = StyleHelper::shadowColor(lightColored); + QLinearGradient grad(spanRect.topRight(), spanRect.topLeft()); + grad.setColorAt(0, highlight.lighter(117)); + grad.setColorAt(1, shadow.darker(109)); + p->fillRect(rect, grad); + + QColor light(255, 255, 255, 80); + p->setPen(light); + p->drawLine(rect.topRight() - QPoint(1, 0), rect.bottomRight() - QPoint(1, 0)); + QColor dark(0, 0, 0, 90); + p->setPen(dark); + p->drawLine(rect.topLeft(), rect.bottomLeft()); + +} + +void StyleHelper::verticalGradient(QPainter *painter, const QRect &spanRect, const QRect &clipRect, bool lightColored) { + + if (StyleHelper::usePixmapCache()) { + QString key; + QColor keyColor = baseColor(lightColored); + key.sprintf("mh_vertical %d %d %d %d %d", spanRect.width(), spanRect.height(), clipRect.width(), clipRect.height(), keyColor.rgb()); + + QPixmap pixmap; + if (!QPixmapCache::find(key, &pixmap)) { + pixmap = QPixmap(clipRect.size()); + QPainter p(&pixmap); + QRect rect(0, 0, clipRect.width(), clipRect.height()); + verticalGradientHelper(&p, spanRect, rect, lightColored); + p.end(); + QPixmapCache::insert(key, pixmap); + } + painter->drawPixmap(clipRect.topLeft(), pixmap); + } + else { + verticalGradientHelper(painter, spanRect, clipRect, lightColored); + } + +} + +static void horizontalGradientHelper(QPainter *p, const QRect &spanRect, const QRect &rect, bool lightColored) { + + if (lightColored) { + QLinearGradient shadowGradient(rect.topLeft(), rect.bottomLeft()); + shadowGradient.setColorAt(0, 0xf0f0f0); + shadowGradient.setColorAt(1, 0xcfcfcf); + p->fillRect(rect, shadowGradient); + return; + } + + QColor base = StyleHelper::baseColor(lightColored); + QColor highlight = StyleHelper::highlightColor(lightColored); + QColor shadow = StyleHelper::shadowColor(lightColored); + QLinearGradient grad(rect.topLeft(), rect.bottomLeft()); + grad.setColorAt(0, highlight.lighter(120)); + if (rect.height() == StyleHelper::navigationWidgetHeight()) { + grad.setColorAt(0.4, highlight); + grad.setColorAt(0.401, base); + } + grad.setColorAt(1, shadow); + p->fillRect(rect, grad); + + QLinearGradient shadowGradient(spanRect.topLeft(), spanRect.topRight()); + shadowGradient.setColorAt(0, QColor(0, 0, 0, 30)); + QColor lighterHighlight; + lighterHighlight = highlight.lighter(130); + lighterHighlight.setAlpha(100); + shadowGradient.setColorAt(0.7, lighterHighlight); + shadowGradient.setColorAt(1, QColor(0, 0, 0, 40)); + p->fillRect(rect, shadowGradient); + +} + +void StyleHelper::horizontalGradient(QPainter *painter, const QRect &spanRect, const QRect &clipRect, bool lightColored) { + + if (StyleHelper::usePixmapCache()) { + QString key; + QColor keyColor = baseColor(lightColored); + key.sprintf("mh_horizontal %d %d %d %d %d %d", spanRect.width(), spanRect.height(), clipRect.width(), clipRect.height(), keyColor.rgb(), spanRect.x()); + + QPixmap pixmap; + if (!QPixmapCache::find(key, &pixmap)) { + pixmap = QPixmap(clipRect.size()); + QPainter p(&pixmap); + QRect rect = QRect(0, 0, clipRect.width(), clipRect.height()); + horizontalGradientHelper(&p, spanRect, rect, lightColored); + p.end(); + QPixmapCache::insert(key, pixmap); + } + painter->drawPixmap(clipRect.topLeft(), pixmap); + } + else { + horizontalGradientHelper(painter, spanRect, clipRect, lightColored); + } + +} + +static void menuGradientHelper(QPainter *p, const QRect &spanRect, const QRect &rect) { + + QLinearGradient grad(spanRect.topLeft(), spanRect.bottomLeft()); + QColor menuColor = StyleHelper::mergedColors(StyleHelper::baseColor(), QColor(244, 244, 244), 25); + grad.setColorAt(0, menuColor.lighter(112)); + grad.setColorAt(1, menuColor); + p->fillRect(rect, grad); + +} + +void StyleHelper::drawArrow(QStyle::PrimitiveElement element, QPainter *painter, const QStyleOption *option) { + + if (option->rect.width() <= 1 || option->rect.height() <= 1) + return; + + const qreal devicePixelRatio = painter->device()->devicePixelRatio(); + const bool enabled = option->state & QStyle::State_Enabled; + QRect r = option->rect; + int size = qMin(r.height(), r.width()); + QPixmap pixmap; + QString pixmapName; + pixmapName.sprintf("StyleHelper::drawArrow-%d-%d-%d-%f", element, size, enabled, devicePixelRatio); + if (!QPixmapCache::find(pixmapName, &pixmap)) { + QImage image(size * devicePixelRatio, size * devicePixelRatio, QImage::Format_ARGB32_Premultiplied); + image.fill(Qt::transparent); + QPainter painter(&image); + + QStyleOption tweakedOption(*option); + tweakedOption.state = QStyle::State_Enabled; + + auto drawCommonStyleArrow = [&tweakedOption, element, &painter](const QRect &rect, const QColor &color) -> void + { + static const QCommonStyle* const style = qobject_cast(QApplication::style()); + if (!style) + return; + tweakedOption.palette.setColor(QPalette::ButtonText, color.rgb()); + tweakedOption.rect = rect; + painter.setOpacity(color.alphaF()); + style->QCommonStyle::drawPrimitive(element, &tweakedOption, &painter); + }; + + if (!enabled) { + drawCommonStyleArrow(image.rect(), m_IconsDisabledColor); + } + else { + drawCommonStyleArrow(image.rect().translated(0, devicePixelRatio), toolBarDropShadowColor()); + drawCommonStyleArrow(image.rect(), m_IconsBaseColor); + } + painter.end(); + pixmap = QPixmap::fromImage(image); + pixmap.setDevicePixelRatio(devicePixelRatio); + QPixmapCache::insert(pixmapName, pixmap); + } + int xOffset = r.x() + (r.width() - size)/2; + int yOffset = r.y() + (r.height() - size)/2; + painter->drawPixmap(xOffset, yOffset, pixmap); + +} + +void StyleHelper::menuGradient(QPainter *painter, const QRect &spanRect, const QRect &clipRect) { + + if (StyleHelper::usePixmapCache()) { + QString key; + key.sprintf("mh_menu %d %d %d %d %d", spanRect.width(), spanRect.height(), clipRect.width(), clipRect.height(), StyleHelper::baseColor().rgb()); + + QPixmap pixmap; + if (!QPixmapCache::find(key, &pixmap)) { + pixmap = QPixmap(clipRect.size()); + QPainter p(&pixmap); + QRect rect = QRect(0, 0, clipRect.width(), clipRect.height()); + menuGradientHelper(&p, spanRect, rect); + p.end(); + QPixmapCache::insert(key, pixmap); + } + painter->drawPixmap(clipRect.topLeft(), pixmap); + } + else { + menuGradientHelper(painter, spanRect, clipRect); + } + +} + +QPixmap StyleHelper::disabledSideBarIcon(const QPixmap &enabledicon) { + + QImage im = enabledicon.toImage().convertToFormat(QImage::Format_ARGB32); + + for (int y=0; y(im.scanLine(y)); + for (int x=0; xdevice()->devicePixelRatio(); + QString pixmapName = QString::fromLatin1("icon %0 %1 %2 %3").arg(icon.cacheKey()).arg(iconMode).arg(rect.height()).arg(devicePixelRatio); + + if (!QPixmapCache::find(pixmapName, &cache)) { + // High-dpi support: The in parameters (rect, radius, offset) are in + // device-independent pixels. The call to QIcon::pixmap() below might + // return a high-dpi pixmap, which will in that case have a devicePixelRatio + // different than 1. The shadow drawing caluculations are done in device + // pixels. + QWindow *window = dynamic_cast(p->device())->window()->windowHandle(); + QPixmap px = icon.pixmap(window, rect.size(), iconMode); + int radius = dipRadius * devicePixelRatio; + QPoint offset = dipOffset * devicePixelRatio; + cache = QPixmap(px.size() + QSize(radius * 2, radius * 2)); + cache.fill(Qt::transparent); + + QPainter cachePainter(&cache); + if (iconMode == QIcon::Disabled) { + const bool hasDisabledState = icon.availableSizes().count() == icon.availableSizes(QIcon::Disabled).count(); + if (!hasDisabledState) + px = disabledSideBarIcon(icon.pixmap(window, rect.size())); + } + + // Draw shadow + QImage tmp(px.size() + QSize(radius * 2, radius * 2 + 1), QImage::Format_ARGB32_Premultiplied); + tmp.fill(Qt::transparent); + + QPainter tmpPainter(&tmp); + tmpPainter.setCompositionMode(QPainter::CompositionMode_Source); + tmpPainter.drawPixmap(QRect(radius, radius, px.width(), px.height()), px); + tmpPainter.end(); + + // blur the alpha channel + QImage blurred(tmp.size(), QImage::Format_ARGB32_Premultiplied); + blurred.fill(Qt::transparent); + QPainter blurPainter(&blurred); + qt_blurImage(&blurPainter, tmp, radius, false, true); + blurPainter.end(); + + tmp = blurred; + + // blacken the image... + tmpPainter.begin(&tmp); + tmpPainter.setCompositionMode(QPainter::CompositionMode_SourceIn); + tmpPainter.fillRect(tmp.rect(), color); + tmpPainter.end(); + + tmpPainter.begin(&tmp); + tmpPainter.setCompositionMode(QPainter::CompositionMode_SourceIn); + tmpPainter.fillRect(tmp.rect(), color); + tmpPainter.end(); + + // draw the blurred drop shadow... + cachePainter.drawImage(QRect(0, 0, cache.rect().width(), cache.rect().height()), tmp); + + // Draw the actual pixmap... + cachePainter.drawPixmap(QRect(QPoint(radius, radius) + offset, QSize(px.width(), px.height())), px); + cachePainter.end(); + cache.setDevicePixelRatio(devicePixelRatio); + QPixmapCache::insert(pixmapName, cache); + } + + QRect targetRect = cache.rect(); + targetRect.setSize(targetRect.size() / cache.devicePixelRatio()); + targetRect.moveCenter(rect.center() - dipOffset); + p->drawPixmap(targetRect, cache); + +} + +// Draws a CSS-like border image where the defined borders are not stretched +// Unit for rect, left, top, right and bottom is user pixels +void StyleHelper::drawCornerImage(const QImage &img, QPainter *painter, const QRect &rect, int left, int top, int right, int bottom) { + + // source rect for drawImage() calls needs to be specified in DIP unit of the image + const qreal imagePixelRatio = img.devicePixelRatio(); + const qreal leftDIP = left * imagePixelRatio; + const qreal topDIP = top * imagePixelRatio; + const qreal rightDIP = right * imagePixelRatio; + const qreal bottomDIP = bottom * imagePixelRatio; + + const QSize size = img.size(); + if (top > 0) { //top + painter->drawImage(QRectF(rect.left() + left, rect.top(), rect.width() -right - left, top), img, QRectF(leftDIP, 0, size.width() - rightDIP - leftDIP, topDIP)); + if (left > 0) //top-left + painter->drawImage(QRectF(rect.left(), rect.top(), left, top), img, QRectF(0, 0, leftDIP, topDIP)); + if (right > 0) //top-right + painter->drawImage(QRectF(rect.left() + rect.width() - right, rect.top(), right, top), img, QRectF(size.width() - rightDIP, 0, rightDIP, topDIP)); + } + //left + if (left > 0) + painter->drawImage(QRectF(rect.left(), rect.top()+top, left, rect.height() - top - bottom), img, QRectF(0, topDIP, leftDIP, size.height() - bottomDIP - topDIP)); + //center + painter->drawImage(QRectF(rect.left() + left, rect.top()+top, rect.width() -right - left, rect.height() - bottom - top), img, QRectF(leftDIP, topDIP, size.width() - rightDIP - leftDIP, size.height() - bottomDIP - topDIP)); + if (right > 0) //right + painter->drawImage(QRectF(rect.left() +rect.width() - right, rect.top()+top, right, rect.height() - top - bottom), img, QRectF(size.width() - rightDIP, topDIP, rightDIP, size.height() - bottomDIP - topDIP)); + if (bottom > 0) { //bottom + painter->drawImage(QRectF(rect.left() +left, rect.top() + rect.height() - bottom, rect.width() - right - left, bottom), img, QRectF(leftDIP, size.height() - bottomDIP, size.width() - rightDIP - leftDIP, bottomDIP)); + if (left > 0) //bottom-left + painter->drawImage(QRectF(rect.left(), rect.top() + rect.height() - bottom, left, bottom), img, QRectF(0, size.height() - bottomDIP, leftDIP, bottomDIP)); + if (right > 0) //bottom-right + painter->drawImage(QRectF(rect.left() + rect.width() - right, rect.top() + rect.height() - bottom, right, bottom), img, QRectF(size.width() - rightDIP, size.height() - bottomDIP, rightDIP, bottomDIP)); + } + +} + +// Tints an image with tintColor, while preserving alpha and lightness +void StyleHelper::tintImage(QImage &img, const QColor &tintColor) { + + QPainter p(&img); + p.setCompositionMode(QPainter::CompositionMode_Screen); + + for (int x = 0; x < img.width(); ++x) { + for (int y = 0; y < img.height(); ++y) { + QRgb rgbColor = img.pixel(x, y); + int alpha = qAlpha(rgbColor); + QColor c = QColor(rgbColor); + + if (alpha > 0) { + c.toHsl(); + qreal l = c.lightnessF(); + QColor newColor = QColor::fromHslF(tintColor.hslHueF(), tintColor.hslSaturationF(), l); + newColor.setAlpha(alpha); + img.setPixel(x, y, newColor.rgba()); + } + } + } + +} + +QLinearGradient StyleHelper::statusBarGradient(const QRect &statusBarRect) { + + QLinearGradient grad(statusBarRect.topLeft(), QPoint(statusBarRect.center().x(), statusBarRect.bottom())); + QColor startColor = shadowColor().darker(164); + QColor endColor = baseColor().darker(130); + grad.setColorAt(0, startColor); + grad.setColorAt(1, endColor); + return grad; + +} + +QString StyleHelper::dpiSpecificImageFile(const QString &fileName) { + + // See QIcon::addFile() + if (qApp->devicePixelRatio() > 1.0) { + const QString atDprfileName = imageFileWithResolution(fileName, qRound(qApp->devicePixelRatio())); + if (QFile::exists(atDprfileName)) + return atDprfileName; + } + return fileName; + +} + +QString StyleHelper::imageFileWithResolution(const QString &fileName, int dpr) { + + const QFileInfo fi(fileName); + return dpr == 1 ? fileName : fi.path() + QLatin1Char('/') + fi.completeBaseName() + QLatin1Char('@') + QString::number(dpr) + QLatin1String("x.") + fi.suffix(); + +} + +QList StyleHelper::availableImageResolutions(const QString &fileName) { + + QList result; + const int maxResolutions = qApp->devicePixelRatio(); + for (int i = 1; i <= maxResolutions; ++i) + if (QFile::exists(imageFileWithResolution(fileName, i))) + result.append(i); + return result; + +} + +} // namespace Utils diff --git a/src/core/stylehelper.h b/src/core/stylehelper.h new file mode 100644 index 000000000..282cc1c38 --- /dev/null +++ b/src/core/stylehelper.h @@ -0,0 +1,109 @@ +/**************************************************************************** +** +** Copyright (C) 2016 The Qt Company Ltd. +** Contact: https://www.qt.io/licensing/ +** +** This file is part of Qt Creator. +** +** Commercial License Usage +** Licensees holding valid commercial Qt licenses may use this file in +** accordance with the commercial license agreement provided with the +** Software or, alternatively, in accordance with the terms contained in +** a written agreement between you and The Qt Company. For licensing terms +** and conditions see https://www.qt.io/terms-conditions. For further +** information use the contact form at https://www.qt.io/contact-us. +** +** GNU General Public License Usage +** Alternatively, this file may be used under the terms of the GNU +** General Public License version 3 as published by the Free Software +** Foundation with exceptions as appearing in the file LICENSE.GPL3-EXCEPT +** included in the packaging of this file. Please review the following +** information to ensure the GNU General Public License requirements will +** be met: https://www.gnu.org/licenses/gpl-3.0.html. +** +****************************************************************************/ + +//#pragma once +#ifndef STYLEHELPER_H +#define STYLEHELPER_H + +#include + +QT_BEGIN_NAMESPACE +class QPalette; +class QPainter; +class QRect; +// Note, this is exported but in a private header as qtopengl depends on it. +// We should consider adding this as a public helper function. +void qt_blurImage(QPainter *p, QImage &blurImage, qreal radius, bool quality, bool alphaOnly, int transposed = 0); +QT_END_NAMESPACE + +// Helper class holding all custom color values + +namespace Utils { +class StyleHelper +{ +public: + static const unsigned int DEFAULT_BASE_COLOR = 0x666666; + static const int progressFadeAnimationDuration = 600; + + // Height of the project explorer navigation bar + static int navigationWidgetHeight() { return 24; } + static qreal sidebarFontSize(); + static QPalette sidebarFontPalette(const QPalette &original); + + // This is our color table, all colors derive from baseColor + static QColor requestedBaseColor() { return m_requestedBaseColor; } + static QColor baseColor(bool lightColored = false); + static QColor panelTextColor(bool lightColored = false); + static QColor highlightColor(bool lightColored = false); + static QColor shadowColor(bool lightColored = false); + static QColor borderColor(bool lightColored = false); + static QColor toolBarBorderColor(); + static QColor buttonTextColor() { return QColor(0x4c4c4c); } + static QColor mergedColors(const QColor &colorA, const QColor &colorB, int factor = 50); + static QColor alphaBlendedColors(const QColor &colorA, const QColor &colorB); + + static QColor sidebarHighlight() { return QColor(255, 255, 255, 40); } + static QColor sidebarShadow() { return QColor(0, 0, 0, 40); } + + static QColor toolBarDropShadowColor() { return QColor(0, 0, 0, 70); } + + static QColor notTooBrightHighlightColor(); + + // Sets the base color and makes sure all top level widgets are updated + static void setBaseColor(const QColor &color); + + // Draws a shaded anti-aliased arrow + static void drawArrow(QStyle::PrimitiveElement element, QPainter *painter, const QStyleOption *option); + + // Gradients used for panels + static void horizontalGradient(QPainter *painter, const QRect &spanRect, const QRect &clipRect, bool lightColored = false); + static void verticalGradient(QPainter *painter, const QRect &spanRect, const QRect &clipRect, bool lightColored = false); + static void menuGradient(QPainter *painter, const QRect &spanRect, const QRect &clipRect); + static bool usePixmapCache() { return true; } + + static QPixmap disabledSideBarIcon(const QPixmap &enabledicon); + static void drawIconWithShadow(const QIcon &icon, const QRect &rect, QPainter *p, QIcon::Mode iconMode, int dipRadius = 3, const QColor &color = QColor(0, 0, 0, 130), const QPoint &dipOffset = QPoint(1, -2)); + static void drawCornerImage(const QImage &img, QPainter *painter, const QRect &rect, int left = 0, int top = 0, int right = 0, int bottom = 0); + + static void tintImage(QImage &img, const QColor &tintColor); + static QLinearGradient statusBarGradient(const QRect &statusBarRect); + + static QString dpiSpecificImageFile(const QString &fileName); + static QString imageFileWithResolution(const QString &fileName, int dpr); + static QList availableImageResolutions(const QString &fileName); + +private: + static QColor m_baseColor; + static QColor m_requestedBaseColor; + static QColor m_IconsBaseColor; + static QColor m_IconsDisabledColor; + static QColor m_ProgressBarTitleColor; +}; + +} // namespace Utils + +using Utils::StyleHelper; +#endif // STYLEHELPER_H +