981 lines
35 KiB
C++
981 lines
35 KiB
C++
/****************************************************************************
|
|
**
|
|
** Copyright (C) 2016 The Qt Company Ltd.
|
|
** Contact: https://www.qt.io/licensing/
|
|
**
|
|
** This file is part of the plugins of the Qt Toolkit.
|
|
**
|
|
** $QT_BEGIN_LICENSE:LGPL$
|
|
** 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 Lesser General Public License Usage
|
|
** Alternatively, this file may be used under the terms of the GNU Lesser
|
|
** General Public License version 3 as published by the Free Software
|
|
** Foundation and appearing in the file LICENSE.LGPL3 included in the
|
|
** packaging of this file. Please review the following information to
|
|
** ensure the GNU Lesser General Public License version 3 requirements
|
|
** will be met: https://www.gnu.org/licenses/lgpl-3.0.html.
|
|
**
|
|
** GNU General Public License Usage
|
|
** Alternatively, this file may be used under the terms of the GNU
|
|
** General Public License version 2.0 or (at your option) the GNU General
|
|
** Public license version 3 or any later version approved by the KDE Free
|
|
** Qt Foundation. The licenses are as published by the Free Software
|
|
** Foundation and appearing in the file LICENSE.GPL2 and LICENSE.GPL3
|
|
** 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-2.0.html and
|
|
** https://www.gnu.org/licenses/gpl-3.0.html.
|
|
**
|
|
** $QT_END_LICENSE$
|
|
**
|
|
****************************************************************************/
|
|
|
|
// SHSTOCKICONINFO is only available since Vista
|
|
#if _WIN32_WINNT < 0x0601
|
|
# undef _WIN32_WINNT
|
|
# define _WIN32_WINNT 0x0601
|
|
#endif
|
|
|
|
#include "qwindowstheme.h"
|
|
#include "qwindowsmenu.h"
|
|
#include "qwindowsdialoghelpers.h"
|
|
#include "qwindowscontext.h"
|
|
#include "qwindowsintegration.h"
|
|
#if QT_CONFIG(systemtrayicon)
|
|
# include "qwindowssystemtrayicon.h"
|
|
#endif
|
|
#include "qt_windows.h"
|
|
#include <commctrl.h>
|
|
#include <objbase.h>
|
|
#ifndef Q_CC_MINGW
|
|
# include <commoncontrols.h>
|
|
#endif
|
|
#include <shellapi.h>
|
|
|
|
#include <QtCore/qvariant.h>
|
|
#include <QtCore/qcoreapplication.h>
|
|
#include <QtCore/qdebug.h>
|
|
#include <QtCore/qtextstream.h>
|
|
#include <QtCore/qsysinfo.h>
|
|
#include <QtCore/qcache.h>
|
|
#include <QtCore/qthread.h>
|
|
#include <QtCore/qmutex.h>
|
|
#include <QtCore/qwaitcondition.h>
|
|
#include <QtGui/qcolor.h>
|
|
#include <QtGui/qpalette.h>
|
|
#include <QtGui/qguiapplication.h>
|
|
#include <QtGui/qpainter.h>
|
|
#include <QtGui/qpixmapcache.h>
|
|
#include <qpa/qwindowsysteminterface.h>
|
|
#include <QtThemeSupport/private/qabstractfileiconengine_p.h>
|
|
#include <QtFontDatabaseSupport/private/qwindowsfontdatabase_p.h>
|
|
#include <private/qhighdpiscaling_p.h>
|
|
#include <private/qsystemlibrary_p.h>
|
|
|
|
#include <algorithm>
|
|
|
|
#if defined(__IImageList_INTERFACE_DEFINED__) && defined(__IID_DEFINED__)
|
|
# define USE_IIMAGELIST
|
|
#endif
|
|
|
|
QT_BEGIN_NAMESPACE
|
|
|
|
static inline QColor COLORREFToQColor(COLORREF cr)
|
|
{
|
|
return QColor(GetRValue(cr), GetGValue(cr), GetBValue(cr));
|
|
}
|
|
|
|
static inline QTextStream& operator<<(QTextStream &str, const QColor &c)
|
|
{
|
|
str.setIntegerBase(16);
|
|
str.setFieldWidth(2);
|
|
str.setPadChar(QLatin1Char('0'));
|
|
str << " rgb: #" << c.red() << c.green() << c.blue();
|
|
str.setIntegerBase(10);
|
|
str.setFieldWidth(0);
|
|
return str;
|
|
}
|
|
|
|
static inline bool booleanSystemParametersInfo(UINT what, bool defaultValue)
|
|
{
|
|
BOOL result;
|
|
if (SystemParametersInfo(what, 0, &result, 0))
|
|
return result != FALSE;
|
|
return defaultValue;
|
|
}
|
|
|
|
static inline DWORD dWordSystemParametersInfo(UINT what, DWORD defaultValue)
|
|
{
|
|
DWORD result;
|
|
if (SystemParametersInfo(what, 0, &result, 0))
|
|
return result;
|
|
return defaultValue;
|
|
}
|
|
|
|
static inline QColor mixColors(const QColor &c1, const QColor &c2)
|
|
{
|
|
return {(c1.red() + c2.red()) / 2,
|
|
(c1.green() + c2.green()) / 2,
|
|
(c1.blue() + c2.blue()) / 2};
|
|
}
|
|
|
|
static inline QColor getSysColor(int index)
|
|
{
|
|
return COLORREFToQColor(GetSysColor(index));
|
|
}
|
|
|
|
// QTBUG-48823/Windows 10: SHGetFileInfo() (as called by item views on file system
|
|
// models has been observed to trigger a WM_PAINT on the mainwindow. Suppress the
|
|
// behavior by running it in a thread.
|
|
|
|
struct QShGetFileInfoParams
|
|
{
|
|
QShGetFileInfoParams(const QString &fn, DWORD a, SHFILEINFO *i, UINT f, bool *r)
|
|
: fileName(fn), attributes(a), flags(f), info(i), result(r)
|
|
{ }
|
|
|
|
const QString &fileName;
|
|
const DWORD attributes;
|
|
const UINT flags;
|
|
SHFILEINFO *const info;
|
|
bool *const result;
|
|
};
|
|
|
|
class QShGetFileInfoThread : public QThread
|
|
{
|
|
public:
|
|
explicit QShGetFileInfoThread()
|
|
: QThread(), m_params(nullptr)
|
|
{
|
|
connect(this, &QThread::finished, this, &QObject::deleteLater);
|
|
}
|
|
|
|
void run() override
|
|
{
|
|
m_init = CoInitializeEx(nullptr, COINIT_MULTITHREADED);
|
|
|
|
QMutexLocker readyLocker(&m_readyMutex);
|
|
while (!m_cancelled.load()) {
|
|
if (!m_params && !m_cancelled.load()
|
|
&& !m_readyCondition.wait(&m_readyMutex, 1000))
|
|
continue;
|
|
|
|
if (m_params) {
|
|
const QString fileName = m_params->fileName;
|
|
SHFILEINFO info;
|
|
#ifndef Q_OS_WINCE
|
|
const UINT oldErrorMode = SetErrorMode(SEM_FAILCRITICALERRORS | SEM_NOOPENFILEERRORBOX);
|
|
#endif
|
|
const bool result = SHGetFileInfo(reinterpret_cast<const wchar_t *>(fileName.utf16()),
|
|
m_params->attributes, &info, sizeof(SHFILEINFO),
|
|
m_params->flags);
|
|
#ifndef Q_OS_WINCE
|
|
SetErrorMode(oldErrorMode);
|
|
#endif
|
|
m_doneMutex.lock();
|
|
if (!m_cancelled.load()) {
|
|
*m_params->result = result;
|
|
memcpy(m_params->info, &info, sizeof(SHFILEINFO));
|
|
}
|
|
m_params = nullptr;
|
|
|
|
m_doneCondition.wakeAll();
|
|
m_doneMutex.unlock();
|
|
}
|
|
}
|
|
|
|
if (m_init != S_FALSE)
|
|
CoUninitialize();
|
|
}
|
|
|
|
bool runWithParams(QShGetFileInfoParams *params, unsigned long timeOutMSecs)
|
|
{
|
|
QMutexLocker doneLocker(&m_doneMutex);
|
|
|
|
m_readyMutex.lock();
|
|
m_params = params;
|
|
m_readyCondition.wakeAll();
|
|
m_readyMutex.unlock();
|
|
|
|
return m_doneCondition.wait(&m_doneMutex, timeOutMSecs);
|
|
}
|
|
|
|
void cancel()
|
|
{
|
|
QMutexLocker doneLocker(&m_doneMutex);
|
|
m_cancelled.store(1);
|
|
m_readyCondition.wakeAll();
|
|
}
|
|
|
|
private:
|
|
HRESULT m_init;
|
|
QShGetFileInfoParams *m_params;
|
|
QAtomicInt m_cancelled;
|
|
QWaitCondition m_readyCondition;
|
|
QWaitCondition m_doneCondition;
|
|
QMutex m_readyMutex;
|
|
QMutex m_doneMutex;
|
|
};
|
|
|
|
static bool shGetFileInfoBackground(const QString &fileName, DWORD attributes,
|
|
SHFILEINFO *info, UINT flags,
|
|
unsigned long timeOutMSecs = 5000)
|
|
{
|
|
static QShGetFileInfoThread *getFileInfoThread = nullptr;
|
|
if (!getFileInfoThread) {
|
|
getFileInfoThread = new QShGetFileInfoThread;
|
|
getFileInfoThread->start();
|
|
}
|
|
|
|
bool result = false;
|
|
QShGetFileInfoParams params(fileName, attributes, info, flags, &result);
|
|
if (!getFileInfoThread->runWithParams(¶ms, timeOutMSecs)) {
|
|
// Cancel and reset getFileInfoThread. It'll
|
|
// be reinitialized the next time we get called.
|
|
getFileInfoThread->cancel();
|
|
getFileInfoThread = nullptr;
|
|
qWarning().noquote() << "SHGetFileInfo() timed out for " << fileName;
|
|
return false;
|
|
}
|
|
return result;
|
|
}
|
|
|
|
// from QStyle::standardPalette
|
|
static inline QPalette standardPalette()
|
|
{
|
|
QColor backgroundColor(0xd4, 0xd0, 0xc8); // win 2000 grey
|
|
QColor lightColor(backgroundColor.lighter());
|
|
QColor darkColor(backgroundColor.darker());
|
|
const QBrush darkBrush(darkColor);
|
|
QColor midColor(Qt::gray);
|
|
QPalette palette(Qt::black, backgroundColor, lightColor, darkColor,
|
|
midColor, Qt::black, Qt::white);
|
|
palette.setBrush(QPalette::Disabled, QPalette::WindowText, darkBrush);
|
|
palette.setBrush(QPalette::Disabled, QPalette::Text, darkBrush);
|
|
palette.setBrush(QPalette::Disabled, QPalette::ButtonText, darkBrush);
|
|
palette.setBrush(QPalette::Disabled, QPalette::Base, QBrush(backgroundColor));
|
|
return palette;
|
|
}
|
|
|
|
static inline QPalette systemPalette()
|
|
{
|
|
QPalette result = standardPalette();
|
|
result.setColor(QPalette::WindowText, getSysColor(COLOR_WINDOWTEXT));
|
|
result.setColor(QPalette::Button, getSysColor(COLOR_BTNFACE));
|
|
result.setColor(QPalette::Light, getSysColor(COLOR_BTNHIGHLIGHT));
|
|
result.setColor(QPalette::Dark, getSysColor(COLOR_BTNSHADOW));
|
|
result.setColor(QPalette::Mid, result.button().color().darker(150));
|
|
result.setColor(QPalette::Text, getSysColor(COLOR_WINDOWTEXT));
|
|
result.setColor(QPalette::BrightText, getSysColor(COLOR_BTNHIGHLIGHT));
|
|
result.setColor(QPalette::Base, getSysColor(COLOR_WINDOW));
|
|
result.setColor(QPalette::Window, getSysColor(COLOR_BTNFACE));
|
|
result.setColor(QPalette::ButtonText, getSysColor(COLOR_BTNTEXT));
|
|
result.setColor(QPalette::Midlight, getSysColor(COLOR_3DLIGHT));
|
|
result.setColor(QPalette::Shadow, getSysColor(COLOR_3DDKSHADOW));
|
|
result.setColor(QPalette::Highlight, getSysColor(COLOR_HIGHLIGHT));
|
|
result.setColor(QPalette::HighlightedText, getSysColor(COLOR_HIGHLIGHTTEXT));
|
|
result.setColor(QPalette::Link, Qt::blue);
|
|
result.setColor(QPalette::LinkVisited, Qt::magenta);
|
|
result.setColor(QPalette::Inactive, QPalette::Button, result.button().color());
|
|
result.setColor(QPalette::Inactive, QPalette::Window, result.window().color());
|
|
result.setColor(QPalette::Inactive, QPalette::Light, result.light().color());
|
|
result.setColor(QPalette::Inactive, QPalette::Dark, result.dark().color());
|
|
|
|
if (result.midlight() == result.button())
|
|
result.setColor(QPalette::Midlight, result.button().color().lighter(110));
|
|
if (result.window() != result.base()) {
|
|
result.setColor(QPalette::Inactive, QPalette::Highlight, result.color(QPalette::Inactive, QPalette::Window));
|
|
result.setColor(QPalette::Inactive, QPalette::HighlightedText, result.color(QPalette::Inactive, QPalette::Text));
|
|
}
|
|
|
|
const QColor disabled =
|
|
mixColors(result.windowText().color(), result.button().color());
|
|
|
|
result.setColorGroup(QPalette::Disabled, result.windowText(), result.button(),
|
|
result.light(), result.dark(), result.mid(),
|
|
result.text(), result.brightText(), result.base(),
|
|
result.window());
|
|
result.setColor(QPalette::Disabled, QPalette::WindowText, disabled);
|
|
result.setColor(QPalette::Disabled, QPalette::Text, disabled);
|
|
result.setColor(QPalette::Disabled, QPalette::ButtonText, disabled);
|
|
result.setColor(QPalette::Disabled, QPalette::Highlight,
|
|
getSysColor(COLOR_HIGHLIGHT));
|
|
result.setColor(QPalette::Disabled, QPalette::HighlightedText,
|
|
getSysColor(COLOR_HIGHLIGHTTEXT));
|
|
result.setColor(QPalette::Disabled, QPalette::Base,
|
|
result.window().color());
|
|
return result;
|
|
}
|
|
|
|
static inline QPalette toolTipPalette(const QPalette &systemPalette)
|
|
{
|
|
QPalette result(systemPalette);
|
|
const QColor tipBgColor(getSysColor(COLOR_INFOBK));
|
|
const QColor tipTextColor(getSysColor(COLOR_INFOTEXT));
|
|
|
|
result.setColor(QPalette::All, QPalette::Button, tipBgColor);
|
|
result.setColor(QPalette::All, QPalette::Window, tipBgColor);
|
|
result.setColor(QPalette::All, QPalette::Text, tipTextColor);
|
|
result.setColor(QPalette::All, QPalette::WindowText, tipTextColor);
|
|
result.setColor(QPalette::All, QPalette::ButtonText, tipTextColor);
|
|
result.setColor(QPalette::All, QPalette::Button, tipBgColor);
|
|
result.setColor(QPalette::All, QPalette::Window, tipBgColor);
|
|
result.setColor(QPalette::All, QPalette::Text, tipTextColor);
|
|
result.setColor(QPalette::All, QPalette::WindowText, tipTextColor);
|
|
result.setColor(QPalette::All, QPalette::ButtonText, tipTextColor);
|
|
result.setColor(QPalette::All, QPalette::ToolTipBase, tipBgColor);
|
|
result.setColor(QPalette::All, QPalette::ToolTipText, tipTextColor);
|
|
const QColor disabled =
|
|
mixColors(result.windowText().color(), result.button().color());
|
|
result.setColor(QPalette::Disabled, QPalette::WindowText, disabled);
|
|
result.setColor(QPalette::Disabled, QPalette::Text, disabled);
|
|
result.setColor(QPalette::Disabled, QPalette::ToolTipText, disabled);
|
|
result.setColor(QPalette::Disabled, QPalette::Base, Qt::white);
|
|
result.setColor(QPalette::Disabled, QPalette::BrightText, Qt::white);
|
|
result.setColor(QPalette::Disabled, QPalette::ToolTipBase, Qt::white);
|
|
return result;
|
|
}
|
|
|
|
static inline QPalette menuPalette(const QPalette &systemPalette)
|
|
{
|
|
QPalette result(systemPalette);
|
|
const QColor menuColor(getSysColor(COLOR_MENU));
|
|
const QColor menuTextColor(getSysColor(COLOR_MENUTEXT));
|
|
const QColor disabled(getSysColor(COLOR_GRAYTEXT));
|
|
// we might need a special color group for the result.
|
|
result.setColor(QPalette::Active, QPalette::Button, menuColor);
|
|
result.setColor(QPalette::Active, QPalette::Text, menuTextColor);
|
|
result.setColor(QPalette::Active, QPalette::WindowText, menuTextColor);
|
|
result.setColor(QPalette::Active, QPalette::ButtonText, menuTextColor);
|
|
result.setColor(QPalette::Disabled, QPalette::WindowText, disabled);
|
|
result.setColor(QPalette::Disabled, QPalette::Text, disabled);
|
|
const bool isFlat = booleanSystemParametersInfo(SPI_GETFLATMENU, false);
|
|
result.setColor(QPalette::Disabled, QPalette::Highlight,
|
|
getSysColor(isFlat ? COLOR_MENUHILIGHT : COLOR_HIGHLIGHT));
|
|
result.setColor(QPalette::Disabled, QPalette::HighlightedText, disabled);
|
|
result.setColor(QPalette::Disabled, QPalette::Button,
|
|
result.color(QPalette::Active, QPalette::Button));
|
|
result.setColor(QPalette::Inactive, QPalette::Button,
|
|
result.color(QPalette::Active, QPalette::Button));
|
|
result.setColor(QPalette::Inactive, QPalette::Text,
|
|
result.color(QPalette::Active, QPalette::Text));
|
|
result.setColor(QPalette::Inactive, QPalette::WindowText,
|
|
result.color(QPalette::Active, QPalette::WindowText));
|
|
result.setColor(QPalette::Inactive, QPalette::ButtonText,
|
|
result.color(QPalette::Active, QPalette::ButtonText));
|
|
result.setColor(QPalette::Inactive, QPalette::Highlight,
|
|
result.color(QPalette::Active, QPalette::Highlight));
|
|
result.setColor(QPalette::Inactive, QPalette::HighlightedText,
|
|
result.color(QPalette::Active, QPalette::HighlightedText));
|
|
result.setColor(QPalette::Inactive, QPalette::ButtonText,
|
|
systemPalette.color(QPalette::Inactive, QPalette::Dark));
|
|
return result;
|
|
}
|
|
|
|
static inline QPalette *menuBarPalette(const QPalette &menuPalette)
|
|
{
|
|
QPalette *result = nullptr;
|
|
if (booleanSystemParametersInfo(SPI_GETFLATMENU, false)) {
|
|
result = new QPalette(menuPalette);
|
|
const QColor menubar(getSysColor(COLOR_MENUBAR));
|
|
result->setColor(QPalette::Active, QPalette::Button, menubar);
|
|
result->setColor(QPalette::Disabled, QPalette::Button, menubar);
|
|
result->setColor(QPalette::Inactive, QPalette::Button, menubar);
|
|
}
|
|
return result;
|
|
}
|
|
|
|
const char *QWindowsTheme::name = "windows";
|
|
QWindowsTheme *QWindowsTheme::m_instance = nullptr;
|
|
|
|
QWindowsTheme::QWindowsTheme()
|
|
{
|
|
m_instance = this;
|
|
std::fill(m_fonts, m_fonts + NFonts, nullptr);
|
|
std::fill(m_palettes, m_palettes + NPalettes, nullptr);
|
|
refresh();
|
|
refreshIconPixmapSizes();
|
|
}
|
|
|
|
QWindowsTheme::~QWindowsTheme()
|
|
{
|
|
clearPalettes();
|
|
clearFonts();
|
|
m_instance = nullptr;
|
|
}
|
|
|
|
static inline QStringList iconThemeSearchPaths()
|
|
{
|
|
const QFileInfo appDir(QCoreApplication::applicationDirPath() + QLatin1String("/icons"));
|
|
return appDir.isDir() ? QStringList(appDir.absoluteFilePath()) : QStringList();
|
|
}
|
|
|
|
static inline QStringList styleNames()
|
|
{
|
|
return { QStringLiteral("WindowsVista"), QStringLiteral("Windows") };
|
|
}
|
|
|
|
static inline int uiEffects()
|
|
{
|
|
int result = QPlatformTheme::HoverEffect;
|
|
if (booleanSystemParametersInfo(SPI_GETUIEFFECTS, false))
|
|
result |= QPlatformTheme::GeneralUiEffect;
|
|
if (booleanSystemParametersInfo(SPI_GETMENUANIMATION, false))
|
|
result |= QPlatformTheme::AnimateMenuUiEffect;
|
|
if (booleanSystemParametersInfo(SPI_GETMENUFADE, false))
|
|
result |= QPlatformTheme::FadeMenuUiEffect;
|
|
if (booleanSystemParametersInfo(SPI_GETCOMBOBOXANIMATION, false))
|
|
result |= QPlatformTheme::AnimateComboUiEffect;
|
|
if (booleanSystemParametersInfo(SPI_GETTOOLTIPANIMATION, false))
|
|
result |= QPlatformTheme::AnimateTooltipUiEffect;
|
|
return result;
|
|
}
|
|
|
|
QVariant QWindowsTheme::themeHint(ThemeHint hint) const
|
|
{
|
|
switch (hint) {
|
|
case UseFullScreenForPopupMenu:
|
|
return QVariant(true);
|
|
case DialogButtonBoxLayout:
|
|
return QVariant(QPlatformDialogHelper::WinLayout);
|
|
case IconThemeSearchPaths:
|
|
return QVariant(iconThemeSearchPaths());
|
|
case StyleNames:
|
|
return QVariant(styleNames());
|
|
case TextCursorWidth:
|
|
return QVariant(int(dWordSystemParametersInfo(SPI_GETCARETWIDTH, 1u)));
|
|
case DropShadow:
|
|
return QVariant(booleanSystemParametersInfo(SPI_GETDROPSHADOW, false));
|
|
case MaximumScrollBarDragDistance:
|
|
return QVariant(qRound(qreal(QWindowsContext::instance()->defaultDPI()) * 1.375));
|
|
case KeyboardScheme:
|
|
return QVariant(int(WindowsKeyboardScheme));
|
|
case UiEffects:
|
|
return QVariant(uiEffects());
|
|
case IconPixmapSizes:
|
|
return QVariant::fromValue(m_fileIconSizes);
|
|
case DialogSnapToDefaultButton:
|
|
return QVariant(booleanSystemParametersInfo(SPI_GETSNAPTODEFBUTTON, false));
|
|
case ContextMenuOnMouseRelease:
|
|
return QVariant(true);
|
|
case WheelScrollLines: {
|
|
int result = 3;
|
|
const DWORD scrollLines = dWordSystemParametersInfo(SPI_GETWHEELSCROLLLINES, DWORD(result));
|
|
if (scrollLines != DWORD(-1)) // Special value meaning "scroll one screen", unimplemented in Qt.
|
|
result = int(scrollLines);
|
|
return QVariant(result);
|
|
}
|
|
default:
|
|
break;
|
|
}
|
|
return QPlatformTheme::themeHint(hint);
|
|
}
|
|
|
|
void QWindowsTheme::clearPalettes()
|
|
{
|
|
qDeleteAll(m_palettes, m_palettes + NPalettes);
|
|
std::fill(m_palettes, m_palettes + NPalettes, nullptr);
|
|
}
|
|
|
|
void QWindowsTheme::refreshPalettes()
|
|
{
|
|
|
|
if (!QGuiApplication::desktopSettingsAware())
|
|
return;
|
|
m_palettes[SystemPalette] = new QPalette(systemPalette());
|
|
m_palettes[ToolTipPalette] = new QPalette(toolTipPalette(*m_palettes[SystemPalette]));
|
|
m_palettes[MenuPalette] = new QPalette(menuPalette(*m_palettes[SystemPalette]));
|
|
m_palettes[MenuBarPalette] = menuBarPalette(*m_palettes[MenuPalette]);
|
|
}
|
|
|
|
void QWindowsTheme::clearFonts()
|
|
{
|
|
qDeleteAll(m_fonts, m_fonts + NFonts);
|
|
std::fill(m_fonts, m_fonts + NFonts, nullptr);
|
|
}
|
|
|
|
void QWindowsTheme::refreshFonts()
|
|
{
|
|
clearFonts();
|
|
if (!QGuiApplication::desktopSettingsAware())
|
|
return;
|
|
NONCLIENTMETRICS ncm;
|
|
QWindowsContext::nonClientMetrics(&ncm);
|
|
const QFont menuFont = QWindowsFontDatabase::LOGFONT_to_QFont(ncm.lfMenuFont);
|
|
const QFont messageBoxFont = QWindowsFontDatabase::LOGFONT_to_QFont(ncm.lfMessageFont);
|
|
const QFont statusFont = QWindowsFontDatabase::LOGFONT_to_QFont(ncm.lfStatusFont);
|
|
const QFont titleFont = QWindowsFontDatabase::LOGFONT_to_QFont(ncm.lfCaptionFont);
|
|
QFont fixedFont(QStringLiteral("Courier New"), messageBoxFont.pointSize());
|
|
fixedFont.setStyleHint(QFont::TypeWriter);
|
|
|
|
LOGFONT lfIconTitleFont;
|
|
SystemParametersInfo(SPI_GETICONTITLELOGFONT, sizeof(lfIconTitleFont), &lfIconTitleFont, 0);
|
|
const QFont iconTitleFont = QWindowsFontDatabase::LOGFONT_to_QFont(lfIconTitleFont);
|
|
|
|
m_fonts[SystemFont] = new QFont(QWindowsFontDatabase::systemDefaultFont());
|
|
m_fonts[MenuFont] = new QFont(menuFont);
|
|
m_fonts[MenuBarFont] = new QFont(menuFont);
|
|
m_fonts[MessageBoxFont] = new QFont(messageBoxFont);
|
|
m_fonts[TipLabelFont] = new QFont(statusFont);
|
|
m_fonts[StatusBarFont] = new QFont(statusFont);
|
|
m_fonts[MdiSubWindowTitleFont] = new QFont(titleFont);
|
|
m_fonts[DockWidgetTitleFont] = new QFont(titleFont);
|
|
m_fonts[ItemViewFont] = new QFont(iconTitleFont);
|
|
m_fonts[FixedFont] = new QFont(fixedFont);
|
|
}
|
|
|
|
enum FileIconSize {
|
|
// Standard icons obtainable via shGetFileInfo(), SHGFI_SMALLICON, SHGFI_LARGEICON
|
|
SmallFileIcon, LargeFileIcon,
|
|
// Larger icons obtainable via SHGetImageList()
|
|
ExtraLargeFileIcon,
|
|
JumboFileIcon, // Vista onwards
|
|
FileIconSizeCount
|
|
};
|
|
|
|
bool QWindowsTheme::usePlatformNativeDialog(DialogType type) const
|
|
{
|
|
return QWindowsDialogs::useHelper(type);
|
|
}
|
|
|
|
QPlatformDialogHelper *QWindowsTheme::createPlatformDialogHelper(DialogType type) const
|
|
{
|
|
return QWindowsDialogs::createHelper(type);
|
|
}
|
|
|
|
#if QT_CONFIG(systemtrayicon)
|
|
QPlatformSystemTrayIcon *QWindowsTheme::createPlatformSystemTrayIcon() const
|
|
{
|
|
return new QWindowsSystemTrayIcon;
|
|
}
|
|
#endif
|
|
|
|
void QWindowsTheme::windowsThemeChanged(QWindow * window)
|
|
{
|
|
refresh();
|
|
QWindowSystemInterface::handleThemeChange(window);
|
|
}
|
|
|
|
static int fileIconSizes[FileIconSizeCount];
|
|
|
|
void QWindowsTheme::refreshIconPixmapSizes()
|
|
{
|
|
// Standard sizes: 16, 32, 48, 256
|
|
fileIconSizes[SmallFileIcon] = GetSystemMetrics(SM_CXSMICON); // corresponds to SHGFI_SMALLICON);
|
|
fileIconSizes[LargeFileIcon] = GetSystemMetrics(SM_CXICON); // corresponds to SHGFI_LARGEICON
|
|
fileIconSizes[ExtraLargeFileIcon] =
|
|
fileIconSizes[LargeFileIcon] + fileIconSizes[LargeFileIcon] / 2;
|
|
fileIconSizes[JumboFileIcon] = 8 * fileIconSizes[LargeFileIcon]; // empirical, has not been observed to work
|
|
|
|
#ifdef USE_IIMAGELIST
|
|
int *availEnd = fileIconSizes + JumboFileIcon + 1;
|
|
#else
|
|
int *availEnd = fileIconSizes + LargeFileIcon + 1;
|
|
#endif // USE_IIMAGELIST
|
|
m_fileIconSizes = QAbstractFileIconEngine::toSizeList(fileIconSizes, availEnd);
|
|
qCDebug(lcQpaWindows) << __FUNCTION__ << m_fileIconSizes;
|
|
}
|
|
|
|
// Defined in qpixmap_win.cpp
|
|
Q_GUI_EXPORT QPixmap qt_pixmapFromWinHICON(HICON icon);
|
|
|
|
static QPixmap loadIconFromShell32(int resourceId, QSizeF size)
|
|
{
|
|
if (const HMODULE hmod = QSystemLibrary::load(L"shell32")) {
|
|
HICON iconHandle =
|
|
static_cast<HICON>(LoadImage(hmod, MAKEINTRESOURCE(resourceId),
|
|
IMAGE_ICON, int(size.width()), int(size.height()), 0));
|
|
if (iconHandle) {
|
|
QPixmap iconpixmap = qt_pixmapFromWinHICON(iconHandle);
|
|
DestroyIcon(iconHandle);
|
|
return iconpixmap;
|
|
}
|
|
}
|
|
return QPixmap();
|
|
}
|
|
|
|
QPixmap QWindowsTheme::standardPixmap(StandardPixmap sp, const QSizeF &pixmapSize) const
|
|
{
|
|
int resourceId = -1;
|
|
SHSTOCKICONID stockId = SIID_INVALID;
|
|
UINT stockFlags = 0;
|
|
LPCTSTR iconName = nullptr;
|
|
switch (sp) {
|
|
case DriveCDIcon:
|
|
stockId = SIID_DRIVECD;
|
|
resourceId = 12;
|
|
break;
|
|
case DriveDVDIcon:
|
|
stockId = SIID_DRIVEDVD;
|
|
resourceId = 12;
|
|
break;
|
|
case DriveNetIcon:
|
|
stockId = SIID_DRIVENET;
|
|
resourceId = 10;
|
|
break;
|
|
case DriveHDIcon:
|
|
stockId = SIID_DRIVEFIXED;
|
|
resourceId = 9;
|
|
break;
|
|
case DriveFDIcon:
|
|
stockId = SIID_DRIVE35;
|
|
resourceId = 7;
|
|
break;
|
|
case FileLinkIcon:
|
|
stockFlags = SHGSI_LINKOVERLAY;
|
|
Q_FALLTHROUGH();
|
|
case FileIcon:
|
|
stockId = SIID_DOCNOASSOC;
|
|
resourceId = 1;
|
|
break;
|
|
case DirLinkIcon:
|
|
stockFlags = SHGSI_LINKOVERLAY;
|
|
Q_FALLTHROUGH();
|
|
case DirClosedIcon:
|
|
case DirIcon:
|
|
stockId = SIID_FOLDER;
|
|
resourceId = 4;
|
|
break;
|
|
case DesktopIcon:
|
|
resourceId = 35;
|
|
break;
|
|
case ComputerIcon:
|
|
resourceId = 16;
|
|
break;
|
|
case DirLinkOpenIcon:
|
|
stockFlags = SHGSI_LINKOVERLAY;
|
|
Q_FALLTHROUGH();
|
|
case DirOpenIcon:
|
|
stockId = SIID_FOLDEROPEN;
|
|
resourceId = 5;
|
|
break;
|
|
case FileDialogNewFolder:
|
|
stockId = SIID_FOLDER;
|
|
resourceId = 319;
|
|
break;
|
|
case DirHomeIcon:
|
|
resourceId = 235;
|
|
break;
|
|
case TrashIcon:
|
|
stockId = SIID_RECYCLER;
|
|
resourceId = 191;
|
|
break;
|
|
case MessageBoxInformation:
|
|
stockId = SIID_INFO;
|
|
iconName = IDI_INFORMATION;
|
|
break;
|
|
case MessageBoxWarning:
|
|
stockId = SIID_WARNING;
|
|
iconName = IDI_WARNING;
|
|
break;
|
|
case MessageBoxCritical:
|
|
stockId = SIID_ERROR;
|
|
iconName = IDI_ERROR;
|
|
break;
|
|
case MessageBoxQuestion:
|
|
stockId = SIID_HELP;
|
|
iconName = IDI_QUESTION;
|
|
break;
|
|
case VistaShield:
|
|
stockId = SIID_SHIELD;
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
|
|
if (stockId != SIID_INVALID) {
|
|
QPixmap pixmap;
|
|
SHSTOCKICONINFO iconInfo;
|
|
memset(&iconInfo, 0, sizeof(iconInfo));
|
|
iconInfo.cbSize = sizeof(iconInfo);
|
|
stockFlags |= (pixmapSize.width() > 16 ? SHGFI_LARGEICON : SHGFI_SMALLICON);
|
|
if (SHGetStockIconInfo(stockId, SHGFI_ICON | stockFlags, &iconInfo) == S_OK) {
|
|
pixmap = qt_pixmapFromWinHICON(iconInfo.hIcon);
|
|
DestroyIcon(iconInfo.hIcon);
|
|
return pixmap;
|
|
}
|
|
}
|
|
|
|
if (resourceId != -1) {
|
|
QPixmap pixmap = loadIconFromShell32(resourceId, pixmapSize);
|
|
if (!pixmap.isNull()) {
|
|
if (sp == FileLinkIcon || sp == DirLinkIcon || sp == DirLinkOpenIcon) {
|
|
QPainter painter(&pixmap);
|
|
QPixmap link = loadIconFromShell32(30, pixmapSize);
|
|
painter.drawPixmap(0, 0, int(pixmapSize.width()), int(pixmapSize.height()), link);
|
|
}
|
|
return pixmap;
|
|
}
|
|
}
|
|
|
|
if (iconName) {
|
|
HICON iconHandle = LoadIcon(nullptr, iconName);
|
|
QPixmap pixmap = qt_pixmapFromWinHICON(iconHandle);
|
|
DestroyIcon(iconHandle);
|
|
if (!pixmap.isNull())
|
|
return pixmap;
|
|
}
|
|
|
|
return QPlatformTheme::standardPixmap(sp, pixmapSize);
|
|
}
|
|
|
|
enum { // Shell image list ids
|
|
sHIL_EXTRALARGE = 0x2, // 48x48 or user-defined
|
|
sHIL_JUMBO = 0x4 // 256x256 (Vista or later)
|
|
};
|
|
|
|
static QString dirIconPixmapCacheKey(int iIcon, int iconSize, int imageListSize)
|
|
{
|
|
QString key = QLatin1String("qt_dir_") + QString::number(iIcon);
|
|
if (iconSize == SHGFI_LARGEICON)
|
|
key += QLatin1Char('l');
|
|
switch (imageListSize) {
|
|
case sHIL_EXTRALARGE:
|
|
key += QLatin1Char('e');
|
|
break;
|
|
case sHIL_JUMBO:
|
|
key += QLatin1Char('j');
|
|
break;
|
|
}
|
|
return key;
|
|
}
|
|
|
|
template <typename T>
|
|
class FakePointer
|
|
{
|
|
public:
|
|
|
|
Q_STATIC_ASSERT_X(sizeof(T) <= sizeof(void *), "FakePointers can only go that far.");
|
|
|
|
static FakePointer *create(T thing)
|
|
{
|
|
return reinterpret_cast<FakePointer *>(qintptr(thing));
|
|
}
|
|
|
|
T operator * () const
|
|
{
|
|
return T(qintptr(this));
|
|
}
|
|
|
|
void operator delete (void *) {}
|
|
};
|
|
|
|
// Shell image list helper functions.
|
|
|
|
static QPixmap pixmapFromShellImageList(int iImageList, const SHFILEINFO &info)
|
|
{
|
|
QPixmap result;
|
|
#ifdef USE_IIMAGELIST
|
|
// For MinGW:
|
|
static const IID iID_IImageList = {0x46eb5926, 0x582e, 0x4017, {0x9f, 0xdf, 0xe8, 0x99, 0x8d, 0xaa, 0x9, 0x50}};
|
|
|
|
IImageList *imageList = nullptr;
|
|
HRESULT hr = SHGetImageList(iImageList, iID_IImageList, reinterpret_cast<void **>(&imageList));
|
|
if (hr != S_OK)
|
|
return result;
|
|
HICON hIcon;
|
|
hr = imageList->GetIcon(info.iIcon, ILD_TRANSPARENT, &hIcon);
|
|
if (hr == S_OK) {
|
|
result = qt_pixmapFromWinHICON(hIcon);
|
|
DestroyIcon(hIcon);
|
|
}
|
|
imageList->Release();
|
|
#else
|
|
Q_UNUSED(iImageList)
|
|
Q_UNUSED(info)
|
|
#endif // USE_IIMAGELIST
|
|
return result;
|
|
}
|
|
|
|
class QWindowsFileIconEngine : public QAbstractFileIconEngine
|
|
{
|
|
public:
|
|
explicit QWindowsFileIconEngine(const QFileInfo &info, QPlatformTheme::IconOptions opts) :
|
|
QAbstractFileIconEngine(info, opts) {}
|
|
|
|
QList<QSize> availableSizes(QIcon::Mode = QIcon::Normal, QIcon::State = QIcon::Off) const override
|
|
{ return QWindowsTheme::instance()->availableFileIconSizes(); }
|
|
|
|
protected:
|
|
QString cacheKey() const override;
|
|
QPixmap filePixmap(const QSize &size, QIcon::Mode mode, QIcon::State) override;
|
|
};
|
|
|
|
QString QWindowsFileIconEngine::cacheKey() const
|
|
{
|
|
// Cache directories unless custom or drives, which have custom icons depending on type
|
|
if ((options() & QPlatformTheme::DontUseCustomDirectoryIcons) && fileInfo().isDir() && !fileInfo().isRoot())
|
|
return QStringLiteral("qt_/directory/");
|
|
if (!fileInfo().isFile())
|
|
return QString();
|
|
// Return "" for .exe, .lnk and .ico extensions.
|
|
// It is faster to just look at the file extensions;
|
|
// avoiding slow QFileInfo::isExecutable() (QTBUG-13182)
|
|
QString suffix = fileInfo().suffix();
|
|
if (!suffix.compare(QLatin1String("exe"), Qt::CaseInsensitive)
|
|
|| !suffix.compare(QLatin1String("lnk"), Qt::CaseInsensitive)
|
|
|| !suffix.compare(QLatin1String("ico"), Qt::CaseInsensitive)) {
|
|
return QString();
|
|
}
|
|
return QLatin1String("qt_.")
|
|
+ (suffix.isEmpty() ? fileInfo().fileName() : std::move(suffix).toUpper()); // handle "Makefile" ;)
|
|
}
|
|
|
|
QPixmap QWindowsFileIconEngine::filePixmap(const QSize &size, QIcon::Mode, QIcon::State)
|
|
{
|
|
/* We don't use the variable, but by storing it statically, we
|
|
* ensure CoInitialize is only called once. */
|
|
static HRESULT comInit = CoInitialize(nullptr);
|
|
Q_UNUSED(comInit);
|
|
|
|
static QCache<QString, FakePointer<int> > dirIconEntryCache(1000);
|
|
static QMutex mx;
|
|
static int defaultFolderIIcon = -1;
|
|
const bool useDefaultFolderIcon = options() & QPlatformTheme::DontUseCustomDirectoryIcons;
|
|
|
|
QPixmap pixmap;
|
|
const QString filePath = QDir::toNativeSeparators(fileInfo().filePath());
|
|
const int width = int(size.width());
|
|
const int iconSize = width > fileIconSizes[SmallFileIcon] ? SHGFI_LARGEICON : SHGFI_SMALLICON;
|
|
const int requestedImageListSize =
|
|
#ifdef USE_IIMAGELIST
|
|
width > fileIconSizes[ExtraLargeFileIcon]
|
|
? sHIL_JUMBO
|
|
: (width > fileIconSizes[LargeFileIcon] ? sHIL_EXTRALARGE : 0);
|
|
#else
|
|
0;
|
|
#endif // !USE_IIMAGELIST
|
|
bool cacheableDirIcon = fileInfo().isDir() && !fileInfo().isRoot();
|
|
if (cacheableDirIcon) {
|
|
QMutexLocker locker(&mx);
|
|
int iIcon = (useDefaultFolderIcon && defaultFolderIIcon >= 0) ? defaultFolderIIcon
|
|
: **dirIconEntryCache.object(filePath);
|
|
if (iIcon) {
|
|
QPixmapCache::find(dirIconPixmapCacheKey(iIcon, iconSize, requestedImageListSize),
|
|
&pixmap);
|
|
if (pixmap.isNull()) // Let's keep both caches in sync
|
|
dirIconEntryCache.remove(filePath);
|
|
else
|
|
return pixmap;
|
|
}
|
|
}
|
|
|
|
SHFILEINFO info;
|
|
unsigned int flags = SHGFI_ICON | iconSize | SHGFI_SYSICONINDEX | SHGFI_ADDOVERLAYS | SHGFI_OVERLAYINDEX;
|
|
DWORD attributes = 0;
|
|
QString path = filePath;
|
|
if (cacheableDirIcon && useDefaultFolderIcon) {
|
|
flags |= SHGFI_USEFILEATTRIBUTES;
|
|
attributes |= FILE_ATTRIBUTE_DIRECTORY;
|
|
path = QStringLiteral("dummy");
|
|
} else if (!fileInfo().exists()) {
|
|
flags |= SHGFI_USEFILEATTRIBUTES;
|
|
attributes |= FILE_ATTRIBUTE_NORMAL;
|
|
}
|
|
const bool val = shGetFileInfoBackground(path, attributes, &info, flags);
|
|
|
|
// Even if GetFileInfo returns a valid result, hIcon can be empty in some cases
|
|
if (val && info.hIcon) {
|
|
QString key;
|
|
if (cacheableDirIcon) {
|
|
if (useDefaultFolderIcon && defaultFolderIIcon < 0)
|
|
defaultFolderIIcon = info.iIcon;
|
|
|
|
//using the unique icon index provided by windows save us from duplicate keys
|
|
key = dirIconPixmapCacheKey(info.iIcon, iconSize, requestedImageListSize);
|
|
QPixmapCache::find(key, &pixmap);
|
|
if (!pixmap.isNull()) {
|
|
QMutexLocker locker(&mx);
|
|
dirIconEntryCache.insert(filePath, FakePointer<int>::create(info.iIcon));
|
|
}
|
|
}
|
|
|
|
if (pixmap.isNull()) {
|
|
if (requestedImageListSize) {
|
|
pixmap = pixmapFromShellImageList(requestedImageListSize, info);
|
|
if (pixmap.isNull() && requestedImageListSize == sHIL_JUMBO)
|
|
pixmap = pixmapFromShellImageList(sHIL_EXTRALARGE, info);
|
|
}
|
|
if (pixmap.isNull())
|
|
pixmap = qt_pixmapFromWinHICON(info.hIcon);
|
|
if (!pixmap.isNull()) {
|
|
if (cacheableDirIcon) {
|
|
QMutexLocker locker(&mx);
|
|
QPixmapCache::insert(key, pixmap);
|
|
dirIconEntryCache.insert(filePath, FakePointer<int>::create(info.iIcon));
|
|
}
|
|
} else {
|
|
qWarning("QWindowsTheme::fileIconPixmap() no icon found");
|
|
}
|
|
}
|
|
DestroyIcon(info.hIcon);
|
|
}
|
|
|
|
return pixmap;
|
|
}
|
|
|
|
QIcon QWindowsTheme::fileIcon(const QFileInfo &fileInfo, QPlatformTheme::IconOptions iconOptions) const
|
|
{
|
|
return QIcon(new QWindowsFileIconEngine(fileInfo, iconOptions));
|
|
}
|
|
|
|
static inline bool doUseNativeMenus()
|
|
{
|
|
const unsigned options = QWindowsIntegration::instance()->options();
|
|
if ((options & QWindowsIntegration::NoNativeMenus) != 0)
|
|
return false;
|
|
if ((options & QWindowsIntegration::AlwaysUseNativeMenus) != 0)
|
|
return true;
|
|
// "Auto" mode: For non-widget or Quick Controls 2 applications
|
|
if (!QCoreApplication::instance()->inherits("QApplication"))
|
|
return true;
|
|
const QWindowList &topLevels = QGuiApplication::topLevelWindows();
|
|
for (const QWindow *t : topLevels) {
|
|
if (t->inherits("QQuickApplicationWindow"))
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
bool QWindowsTheme::useNativeMenus()
|
|
{
|
|
static const bool result = doUseNativeMenus();
|
|
return result;
|
|
}
|
|
|
|
QPlatformMenuItem *QWindowsTheme::createPlatformMenuItem() const
|
|
{
|
|
qCDebug(lcQpaMenus) << __FUNCTION__;
|
|
return QWindowsTheme::useNativeMenus() ? new QWindowsMenuItem : nullptr;
|
|
}
|
|
|
|
QPlatformMenu *QWindowsTheme::createPlatformMenu() const
|
|
{
|
|
qCDebug(lcQpaMenus) << __FUNCTION__;
|
|
// We create a popup menu here, since it will likely be used as context
|
|
// menu. Submenus should be created the factory functions of
|
|
// QPlatformMenu/Bar. Note though that Quick Controls 1 will use this
|
|
// function for submenus as well, but this has been found to work.
|
|
return QWindowsTheme::useNativeMenus() ? new QWindowsPopupMenu : nullptr;
|
|
}
|
|
|
|
QPlatformMenuBar *QWindowsTheme::createPlatformMenuBar() const
|
|
{
|
|
qCDebug(lcQpaMenus) << __FUNCTION__;
|
|
return QWindowsTheme::useNativeMenus() ? new QWindowsMenuBar : nullptr;
|
|
}
|
|
|
|
void QWindowsTheme::showPlatformMenuBar()
|
|
{
|
|
qCDebug(lcQpaMenus) << __FUNCTION__;
|
|
}
|
|
|
|
QT_END_NAMESPACE
|