forked from openkylin/qt5-ukui-platformtheme
1207 lines
62 KiB
C++
1207 lines
62 KiB
C++
/*
|
|
* Qt5-UKUI's Library
|
|
*
|
|
* Copyright (C) 2023, KylinSoft Co., Ltd.
|
|
*
|
|
* This library is free software; you can redistribute it and/or
|
|
* modify it under the terms of the GNU Lesser General Public
|
|
* License as published by the Free Software Foundation; either
|
|
* version 3 of the License, or (at your option) any later version.
|
|
*
|
|
* This library is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
|
* Lesser General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU General Public License
|
|
* along with this library. If not, see <https://www.gnu.org/licenses/>.
|
|
*
|
|
* Authors: Jing Tan <tanjing@kylinos.cn>
|
|
*
|
|
*/
|
|
|
|
#include "readconfig.h"
|
|
#include <QDebug>
|
|
#include <QFile>
|
|
#include <QString>
|
|
#include <QStringList>
|
|
#include <QStandardPaths>
|
|
#include <QMetaEnum>
|
|
|
|
ReadConfig::ReadConfig(const QString &cfg)
|
|
{
|
|
|
|
}
|
|
|
|
ReadConfig::~ReadConfig()
|
|
{
|
|
|
|
}
|
|
|
|
bool ReadConfig::load(const QString &cfg)
|
|
{
|
|
if (!QFile::exists(cfg)) {
|
|
qWarning() << "ReadConfig load file not exists!" << cfg;
|
|
return false;
|
|
}
|
|
|
|
QFile file(cfg);
|
|
if(!file.open(QIODevice::ReadOnly)) {
|
|
qWarning() << "ReadConfig load file Error!" << cfg;
|
|
return false;
|
|
}
|
|
|
|
QByteArray jsonData = file.readAll();
|
|
file.close();
|
|
QJsonParseError error;
|
|
QJsonDocument jdoc = QJsonDocument::fromJson(jsonData, &error);
|
|
if (error.error != QJsonParseError::NoError) {
|
|
qWarning("QJsonDocument fromJson error!");
|
|
return false;
|
|
}
|
|
m_cfgPath = cfg;
|
|
qDebug() << "m_cfgPath..." << m_cfgPath;
|
|
m_cfgJsonObj = jdoc.object();
|
|
return true;
|
|
}
|
|
|
|
QVariant ReadConfig::getValue(const QString key_1, const QString key_2, const QString key_3, const QString key_4, const QString key_5) const
|
|
{
|
|
QJsonObject obj;
|
|
if (!key_1.isEmpty() && key_2.isEmpty()) {
|
|
return getValue(key_1, m_cfgJsonObj);
|
|
}
|
|
|
|
if (!key_1.isEmpty() && !key_2.isEmpty()) {
|
|
obj = getJsonObjectValue(key_1, m_cfgJsonObj);
|
|
}
|
|
|
|
if(!key_2.isEmpty()) {
|
|
if(key_3.isEmpty())
|
|
return getValue(key_2, obj);
|
|
else
|
|
obj = getJsonObjectValue(key_2, obj);
|
|
}
|
|
|
|
if (!key_3.isEmpty()) {
|
|
if (key_4.isEmpty())
|
|
return getValue(key_3, obj);
|
|
else
|
|
obj = getJsonObjectValue(key_3, obj);
|
|
}
|
|
|
|
if (!key_4.isEmpty()) {
|
|
if(key_5.isEmpty())
|
|
return getValue(key_4, obj);
|
|
else
|
|
obj = getJsonObjectValue(key_4, obj);
|
|
}
|
|
|
|
if(!key_5.isEmpty())
|
|
return getValue(key_5, obj);
|
|
return QVariant();
|
|
}
|
|
|
|
QVariant ReadConfig::getValue(const QString key, QJsonObject obj) const
|
|
{
|
|
QVariant r;
|
|
|
|
if (key.isEmpty() || obj.isEmpty() || !obj.contains(key)) {
|
|
cWarning << "key or QJsonObject unvalue!" << key << obj.isEmpty() << obj.contains(key);
|
|
return QVariant();
|
|
}
|
|
|
|
r = obj.value(key);
|
|
if (!r.isValid()) {
|
|
cWarning << "getValue key:" << key << "error!";
|
|
return QVariant();
|
|
}
|
|
return r;
|
|
}
|
|
|
|
QJsonObject ReadConfig::getJsonObjectValue(const QString key, QJsonObject obj) const
|
|
{
|
|
QJsonObject o;
|
|
if (key.isEmpty() || obj.isEmpty() || !obj.contains(key)) {
|
|
cWarning << "key or QJsonObject unvalue!";
|
|
return o;
|
|
}
|
|
|
|
QJsonValue v = obj.value(key);
|
|
// cDebug << "getJsonObjectValue:" << key << v;
|
|
if (!v.isObject()) {
|
|
cWarning << "getValue QJsonValue to QJsonObject error!";
|
|
return o;
|
|
}
|
|
o = v.toObject();
|
|
|
|
return o;
|
|
}
|
|
|
|
bool ReadConfig::getColorValue(QColor &c, const QString key_1, const QString key_2, const QString key_3, const QString key_4, const QString key_5) const
|
|
{
|
|
QJsonObject obj = getValue(key_1, key_2, key_3, key_4, key_5).toJsonObject();
|
|
if (obj.isEmpty()) {
|
|
cDebug << "getvalue isempty!" << key_1 << key_2 << key_3 << key_4 << key_5;
|
|
return false;
|
|
}
|
|
if (obj.value(Obj_Type) != Obj_Color_Type && obj.value(Obj_Type) != Obj_PaletteRole_Type) {
|
|
cDebug << "get color value type error!" << obj.value(Obj_Type).toString() << key_1 << key_2 << key_3 << key_4 << key_5 << obj.value(Obj_Type);
|
|
return false;
|
|
}
|
|
if(obj.value(Obj_Value).toString().isEmpty()){
|
|
cDebug << "obj" << Obj_Value << "key isempty!";
|
|
return false;
|
|
}
|
|
if(obj.value(Obj_Type) == Obj_PaletteRole_Type)
|
|
c = stringToPaletteColor(obj.value(Obj_Value).toString());
|
|
else
|
|
c = stringToColor(obj.value(Obj_Value).toString());
|
|
return true;
|
|
}
|
|
|
|
bool ReadConfig::getColorValue(QBrush &brush, const QString key_1, const QString key_2, const QString key_3, const QString key_4, const QString key_5) const
|
|
{
|
|
QJsonObject obj = getValue(key_1, key_2, key_3, key_4, key_5).toJsonObject();
|
|
if (obj.isEmpty()) {
|
|
cDebug << "getvalue isempty!" << key_1 << key_2 << key_3 << key_4 << key_5;
|
|
return false;
|
|
}
|
|
if (obj.value(Obj_Type) != Obj_Color_Type && obj.value(Obj_Type) != Obj_PaletteRole_Type) {
|
|
cDebug << "get color value type error!" << obj.value(Obj_Type).toString() << key_1 << key_2 << key_3 << key_4 << key_5 << obj.value(Obj_Type);
|
|
return false;
|
|
}
|
|
if(obj.value(Obj_Value).toString().isEmpty()){
|
|
cDebug << "obj" << Obj_Value << "key isempty!";
|
|
return false;
|
|
}
|
|
if(obj.value(Obj_Type) == Obj_PaletteRole_Type)
|
|
brush = stringToPaletteColor(obj.value(Obj_Value).toString());
|
|
else
|
|
brush = stringToColor(obj.value(Obj_Value).toString());
|
|
return true;
|
|
}
|
|
|
|
bool ReadConfig::getGradientValue(QList<QColor> &cl, const QString key_1, const QString key_2, const QString key_3, const QString key_4, const QString key_5) const
|
|
{
|
|
QJsonObject obj = getValue(key_1, key_2, key_3, key_4, key_5).toJsonObject();
|
|
if (obj.isEmpty()) {
|
|
cDebug << "getvalue isempty!" << key_1 << key_2 << key_3 << key_4 << key_5;
|
|
return false;
|
|
}
|
|
if(obj.value(Obj_Value).toString().isEmpty()){
|
|
cDebug << "obj" << Obj_Value << "key isempty!";
|
|
return false;
|
|
}
|
|
if (obj.value(Obj_Type) != Obj_Gradient_Type) {
|
|
cDebug << "get color value type error!" << obj.value(Obj_Type).toString() << key_1 << key_2 << key_3 << key_4 << key_5 << obj.value(Obj_Type);
|
|
return false;
|
|
}
|
|
stringToGradient(cl, obj.value(Obj_Value).toString());
|
|
return true;
|
|
|
|
}
|
|
|
|
QString ReadConfig::getType(const QString key_1, const QString key_2, const QString key_3, const QString key_4, const QString key_5) const
|
|
{
|
|
QJsonObject obj = getValue(key_1, key_2, key_3, key_4, key_5).toJsonObject();
|
|
if (obj.isEmpty()) {
|
|
cDebug << "getvalue isempty!" << key_1 << key_2 << key_3 << key_4 << key_5;
|
|
return "";
|
|
}
|
|
return obj.value(Obj_Type).toString();
|
|
}
|
|
|
|
QColor ReadConfig::stringToColor(QString s) const
|
|
{
|
|
QColor c = Qt::NoBrush;
|
|
|
|
QStringList list = s.split(",");
|
|
if (list.length() >= 3) {
|
|
c.setRed(list[0].toInt());
|
|
c.setGreen(list[1].toInt());
|
|
c.setBlue(list[2].toInt());
|
|
if (list.length() == 4) {
|
|
QStringList alphaList = QString(list[3]).split("*");
|
|
if (alphaList.length() == 2) {
|
|
if (alphaList[0].toFloat() == 255.0)
|
|
c.setAlphaF(alphaList[1].toFloat());
|
|
else if (alphaList[1].toFloat() == 255.0)
|
|
c.setAlphaF(alphaList[0].toFloat());
|
|
else
|
|
c.setAlphaF(alphaList[0].toFloat() * alphaList[1].toFloat() / 255.0);
|
|
|
|
} else if (alphaList.length() == 1) {
|
|
if(alphaList[0].toFloat() <= 1.0)
|
|
c.setAlphaF(alphaList[0].toFloat());
|
|
else
|
|
c.setAlphaF(alphaList[0].toFloat()/255.0);
|
|
} else
|
|
c.setAlphaF(1.0);
|
|
}
|
|
} else if (list.length() == 1 && list[0].startsWith("#")) {
|
|
c = list[0];
|
|
}
|
|
|
|
return c;
|
|
}
|
|
|
|
QColor ReadConfig::stringToPaletteColor(QString s) const
|
|
{
|
|
QColor c = Qt::NoBrush;
|
|
QMetaEnum metaEnum = QMetaEnum::fromType<UKUIPaletteRole::PaletteRole>();
|
|
QByteArray ba=s.toLatin1();
|
|
const char * c_scence=ba.data();
|
|
//qDebug()<<c_scence;
|
|
|
|
switch (metaEnum.keyToValue(c_scence)) {
|
|
case UKUIPaletteRole::WindowText_at:
|
|
c = m_platte.color(QPalette::Active, QPalette::WindowText);
|
|
break;
|
|
case UKUIPaletteRole::WindowText_iat:
|
|
c = m_platte.color(QPalette::Inactive, QPalette::WindowText);
|
|
break;
|
|
case UKUIPaletteRole::WindowText_dis:
|
|
c = m_platte.color(QPalette::Disabled, QPalette::WindowText);
|
|
break;
|
|
case UKUIPaletteRole::Button_at:
|
|
c = m_platte.color(QPalette::Active, QPalette::Button);
|
|
break;
|
|
case UKUIPaletteRole::Button_iat:
|
|
c = m_platte.color(QPalette::Inactive, QPalette::Button);
|
|
break;
|
|
case UKUIPaletteRole::Button_dis:
|
|
c = m_platte.color(QPalette::Disabled, QPalette::Button);
|
|
break;
|
|
case UKUIPaletteRole::Light_at:
|
|
c = m_platte.color(QPalette::Active, QPalette::Light);
|
|
break;
|
|
case UKUIPaletteRole::Light_iat:
|
|
c = m_platte.color(QPalette::Inactive, QPalette::Light);
|
|
break;
|
|
case UKUIPaletteRole::Light_dis:
|
|
c = m_platte.color(QPalette::Disabled, QPalette::Light);
|
|
break;
|
|
case UKUIPaletteRole::Midlight_at:
|
|
c = m_platte.color(QPalette::Active, QPalette::Midlight);
|
|
break;
|
|
case UKUIPaletteRole::Midlight_iat:
|
|
c = m_platte.color(QPalette::Inactive, QPalette::Midlight);
|
|
break;
|
|
case UKUIPaletteRole::Midlight_dis:
|
|
c = m_platte.color(QPalette::Disabled, QPalette::Midlight);
|
|
break;
|
|
case UKUIPaletteRole::Dark_at:
|
|
c = m_platte.color(QPalette::Active, QPalette::Dark);
|
|
break;
|
|
case UKUIPaletteRole::Dark_iat:
|
|
c = m_platte.color(QPalette::Inactive, QPalette::Dark);
|
|
break;
|
|
case UKUIPaletteRole::Dark_dis:
|
|
c = m_platte.color(QPalette::Disabled, QPalette::Dark);
|
|
break;
|
|
case UKUIPaletteRole::Mid_at:
|
|
c = m_platte.color(QPalette::Active, QPalette::Mid);
|
|
break;
|
|
case UKUIPaletteRole::Mid_iat:
|
|
c = m_platte.color(QPalette::Inactive, QPalette::Mid);
|
|
break;
|
|
case UKUIPaletteRole::Mid_dis:
|
|
c = m_platte.color(QPalette::Disabled, QPalette::Mid);
|
|
break;
|
|
case UKUIPaletteRole::Text_at:
|
|
c = m_platte.color(QPalette::Active, QPalette::Text);
|
|
break;
|
|
case UKUIPaletteRole::Text_iat:
|
|
c = m_platte.color(QPalette::Inactive, QPalette::Text);
|
|
break;
|
|
case UKUIPaletteRole::Text_dis:
|
|
c = m_platte.color(QPalette::Disabled, QPalette::Text);
|
|
break;
|
|
case UKUIPaletteRole::BrightText_at:
|
|
c = m_platte.color(QPalette::Active, QPalette::BrightText);
|
|
break;
|
|
case UKUIPaletteRole::BrightText_iat:
|
|
c = m_platte.color(QPalette::Inactive, QPalette::BrightText);
|
|
break;
|
|
case UKUIPaletteRole::BrightText_dis:
|
|
c = m_platte.color(QPalette::Disabled, QPalette::BrightText);
|
|
break;
|
|
case UKUIPaletteRole::ButtonText_at:
|
|
c = m_platte.color(QPalette::Active, QPalette::ButtonText);
|
|
break;
|
|
case UKUIPaletteRole::ButtonText_iat:
|
|
c = m_platte.color(QPalette::Inactive, QPalette::ButtonText);
|
|
break;
|
|
case UKUIPaletteRole::ButtonText_dis:
|
|
c = m_platte.color(QPalette::Disabled, QPalette::ButtonText);
|
|
break;
|
|
case UKUIPaletteRole::Base_at:
|
|
c = m_platte.color(QPalette::Active, QPalette::Base);
|
|
break;
|
|
case UKUIPaletteRole::Base_iat:
|
|
c = m_platte.color(QPalette::Inactive, QPalette::Base);
|
|
break;
|
|
case UKUIPaletteRole::Base_dis:
|
|
c = m_platte.color(QPalette::Disabled, QPalette::Base);
|
|
break;
|
|
case UKUIPaletteRole::Window_at:
|
|
c = m_platte.color(QPalette::Active, QPalette::Window);
|
|
break;
|
|
case UKUIPaletteRole::Window_iat:
|
|
c = m_platte.color(QPalette::Inactive, QPalette::Window);
|
|
break;
|
|
case UKUIPaletteRole::Window_dis:
|
|
c = m_platte.color(QPalette::Disabled, QPalette::Window);
|
|
break;
|
|
case UKUIPaletteRole::Shadow_at:
|
|
c = m_platte.color(QPalette::Active, QPalette::Shadow);
|
|
break;
|
|
case UKUIPaletteRole::Shadow_iat:
|
|
c = m_platte.color(QPalette::Inactive, QPalette::Shadow);
|
|
break;
|
|
case UKUIPaletteRole::Shadow_dis:
|
|
c = m_platte.color(QPalette::Disabled, QPalette::Shadow);
|
|
break;
|
|
case UKUIPaletteRole::HighLight_at:
|
|
c = m_platte.color(QPalette::Active, QPalette::Highlight);
|
|
break;
|
|
case UKUIPaletteRole::HighLight_iat:
|
|
c = m_platte.color(QPalette::Inactive, QPalette::Highlight);
|
|
break;
|
|
case UKUIPaletteRole::HighLight_dis:
|
|
c = m_platte.color(QPalette::Disabled, QPalette::Highlight);
|
|
break;
|
|
case UKUIPaletteRole::HighLightText_at:
|
|
c = m_platte.color(QPalette::Active, QPalette::HighlightedText);
|
|
break;
|
|
case UKUIPaletteRole::HighLightText_iat:
|
|
c = m_platte.color(QPalette::Inactive, QPalette::HighlightedText);
|
|
break;
|
|
case UKUIPaletteRole::HighLightText_dis:
|
|
c = m_platte.color(QPalette::Disabled, QPalette::HighlightedText);
|
|
break;
|
|
case UKUIPaletteRole::Link_at:
|
|
c = m_platte.color(QPalette::Active, QPalette::Link);
|
|
break;
|
|
case UKUIPaletteRole::Link_iat:
|
|
c = m_platte.color(QPalette::Inactive, QPalette::Link);
|
|
break;
|
|
case UKUIPaletteRole::Link_dis:
|
|
c = m_platte.color(QPalette::Disabled, QPalette::Link);
|
|
break;
|
|
case UKUIPaletteRole::LinkVisited_at:
|
|
c = m_platte.color(QPalette::Active, QPalette::LinkVisited);
|
|
break;
|
|
case UKUIPaletteRole::LinkVisited_iat:
|
|
c = m_platte.color(QPalette::Inactive, QPalette::LinkVisited);
|
|
break;
|
|
case UKUIPaletteRole::LinkVisited_dis:
|
|
c = m_platte.color(QPalette::Disabled, QPalette::LinkVisited);
|
|
break;
|
|
case UKUIPaletteRole::AlternateBase_at:
|
|
c = m_platte.color(QPalette::Active, QPalette::AlternateBase);
|
|
break;
|
|
case UKUIPaletteRole::AlternateBase_iat:
|
|
c = m_platte.color(QPalette::Inactive, QPalette::AlternateBase);
|
|
break;
|
|
case UKUIPaletteRole::AlternateBase_dis:
|
|
c = m_platte.color(QPalette::Disabled, QPalette::AlternateBase);
|
|
break;
|
|
case UKUIPaletteRole::NoRole_at:
|
|
c = m_platte.color(QPalette::Active, QPalette::NoRole);
|
|
break;
|
|
case UKUIPaletteRole::NoRole_iat:
|
|
c = m_platte.color(QPalette::Inactive, QPalette::NoRole);
|
|
break;
|
|
case UKUIPaletteRole::NoRole_dis:
|
|
c = m_platte.color(QPalette::Disabled, QPalette::NoRole);
|
|
break;
|
|
case UKUIPaletteRole::ToolTipBase_at:
|
|
c = m_platte.color(QPalette::Active, QPalette::ToolTipBase);
|
|
break;
|
|
case UKUIPaletteRole::ToolTipBase_iat:
|
|
c = m_platte.color(QPalette::Inactive, QPalette::ToolTipBase);
|
|
break;
|
|
case UKUIPaletteRole::ToolTipBase_dis:
|
|
c = m_platte.color(QPalette::Disabled, QPalette::ToolTipBase);
|
|
break;
|
|
case UKUIPaletteRole::ToolTipText_at:
|
|
c = m_platte.color(QPalette::Active, QPalette::ToolTipText);
|
|
break;
|
|
case UKUIPaletteRole::ToolTipText_iat:
|
|
c = m_platte.color(QPalette::Inactive, QPalette::ToolTipText);
|
|
break;
|
|
case UKUIPaletteRole::ToolTipText_dis:
|
|
c = m_platte.color(QPalette::Disabled, QPalette::ToolTipText);
|
|
break;
|
|
case UKUIPaletteRole::PlaceholderText_at:
|
|
c = m_platte.color(QPalette::Active, QPalette::PlaceholderText);
|
|
break;
|
|
case UKUIPaletteRole::PlaceholderText_iat:
|
|
c = m_platte.color(QPalette::Inactive, QPalette::PlaceholderText);
|
|
break;
|
|
case UKUIPaletteRole::PlaceholderText_dis:
|
|
c = m_platte.color(QPalette::Disabled, QPalette::PlaceholderText);
|
|
break;
|
|
|
|
default:
|
|
break;
|
|
}
|
|
|
|
return c;
|
|
}
|
|
|
|
void ReadConfig::stringToGradient(QList<QColor> &cl, QString s) const
|
|
{
|
|
QStringList list = s.split("~");
|
|
|
|
if(list.length() == 2)
|
|
foreach (QString s, list) {
|
|
cl.append(stringToColor(s));
|
|
}
|
|
}
|
|
|
|
bool ReadConfig::setValue(QString key, QVariant value)
|
|
{
|
|
QString cfg = m_cfgPath;
|
|
if (!QFile::exists(cfg)) {
|
|
cWarning << "ReadConfig setValue file not exists!";
|
|
return false;
|
|
}
|
|
|
|
QFile file(cfg);
|
|
if(!file.open(QIODevice::ReadWrite)) {
|
|
cWarning << "ReadConfig setValue file Error!";
|
|
return false;
|
|
}
|
|
|
|
QByteArray jsonData = file.readAll();
|
|
QJsonParseError error;
|
|
QJsonDocument jdoc = QJsonDocument::fromJson(jsonData, &error);
|
|
if (error.error != QJsonParseError::NoError) {
|
|
cWarning << "QJsonDocument fromJson error!";
|
|
return false;
|
|
}
|
|
QJsonObject obj = jdoc.object();
|
|
if(obj.contains(key)){
|
|
obj[key] = value.toString();
|
|
}
|
|
QJsonDocument jdc;
|
|
jdc.setObject(obj);
|
|
file.write(jdc.toJson());
|
|
file.close();
|
|
}
|
|
|
|
void ReadConfig::widgetPalette(const QPalette platte)
|
|
{
|
|
m_platte = platte;
|
|
}
|
|
|
|
|
|
ReadThemeConfig::ReadThemeConfig(QString colorCfgPath, bool isDark):
|
|
m_colorCfgPath(colorCfgPath),
|
|
m_themeIsDark(isDark)
|
|
{
|
|
if (m_colorCfgPath.isEmpty()) {
|
|
QString path = ColorPath;
|
|
m_colorCfgPath = path + DefaultConfigName;
|
|
}
|
|
m_readConfig = new ReadConfig(m_colorCfgPath);
|
|
m_loadConfig = m_readConfig->load(m_colorCfgPath);
|
|
if(!m_loadConfig){
|
|
m_readConfig->deleteLater();
|
|
m_readConfig = nullptr;
|
|
}
|
|
m_theme = m_themeIsDark ? UKUIDarkTheme : UKUILightTheme;
|
|
|
|
}
|
|
|
|
ReadThemeConfig::~ReadThemeConfig()
|
|
{
|
|
if (m_readConfig) {
|
|
m_readConfig->deleteLater();
|
|
m_readConfig = nullptr;
|
|
}
|
|
}
|
|
|
|
UKUIColorTheme::PaletteColorCfg ReadThemeConfig::paletteColorCfg()
|
|
{
|
|
if(!m_loadConfig)
|
|
return m_paletteColorCfg;
|
|
|
|
m_readConfig->getColorValue(m_paletteColorCfg.windowText_at , m_theme, UKUIPalette, c_windowText_at);
|
|
m_readConfig->getColorValue(m_paletteColorCfg.windowText_iat , m_theme, UKUIPalette, c_windowText_iat);
|
|
m_readConfig->getColorValue(m_paletteColorCfg.windowText_dis , m_theme, UKUIPalette, c_windowText_dis);
|
|
m_readConfig->getColorValue(m_paletteColorCfg.button_at , m_theme, UKUIPalette, c_button_at);
|
|
m_readConfig->getColorValue(m_paletteColorCfg.button_iat , m_theme, UKUIPalette, c_button_iat);
|
|
m_readConfig->getColorValue(m_paletteColorCfg.button_dis , m_theme, UKUIPalette, c_button_dis);
|
|
m_readConfig->getColorValue(m_paletteColorCfg.light_at , m_theme, UKUIPalette, c_light_at);
|
|
m_readConfig->getColorValue(m_paletteColorCfg.light_iat , m_theme, UKUIPalette, c_light_iat);
|
|
m_readConfig->getColorValue(m_paletteColorCfg.light_dis , m_theme, UKUIPalette, c_light_dis);
|
|
m_readConfig->getColorValue(m_paletteColorCfg.midlight_at , m_theme, UKUIPalette, c_midlight_at);
|
|
m_readConfig->getColorValue(m_paletteColorCfg.midlight_iat , m_theme, UKUIPalette, c_midlight_iat);
|
|
m_readConfig->getColorValue(m_paletteColorCfg.midlight_dis , m_theme, UKUIPalette, c_midlight_dis);
|
|
m_readConfig->getColorValue(m_paletteColorCfg.dark_at , m_theme, UKUIPalette, c_dark_at);
|
|
m_readConfig->getColorValue(m_paletteColorCfg.dark_iat , m_theme, UKUIPalette, c_dark_iat);
|
|
m_readConfig->getColorValue(m_paletteColorCfg.dark_dis , m_theme, UKUIPalette, c_dark_dis);
|
|
m_readConfig->getColorValue(m_paletteColorCfg.mid_at , m_theme, UKUIPalette, c_mid_at);
|
|
m_readConfig->getColorValue(m_paletteColorCfg.mid_iat , m_theme, UKUIPalette, c_mid_iat);
|
|
m_readConfig->getColorValue(m_paletteColorCfg.mid_dis , m_theme, UKUIPalette, c_mid_dis);
|
|
m_readConfig->getColorValue(m_paletteColorCfg.text_at , m_theme, UKUIPalette, c_text_at);
|
|
m_readConfig->getColorValue(m_paletteColorCfg.text_iat , m_theme, UKUIPalette, c_text_iat);
|
|
m_readConfig->getColorValue(m_paletteColorCfg.text_dis , m_theme, UKUIPalette, c_text_dis);
|
|
m_readConfig->getColorValue(m_paletteColorCfg.brightText_at , m_theme, UKUIPalette, c_brightText_at);
|
|
m_readConfig->getColorValue(m_paletteColorCfg.brightText_iat , m_theme, UKUIPalette, c_brightText_iat);
|
|
m_readConfig->getColorValue(m_paletteColorCfg.brightText_dis , m_theme, UKUIPalette, c_brightText_dis);
|
|
m_readConfig->getColorValue(m_paletteColorCfg.buttonText_at , m_theme, UKUIPalette, c_buttonText_at);
|
|
m_readConfig->getColorValue(m_paletteColorCfg.buttonText_iat , m_theme, UKUIPalette, c_buttonText_iat);
|
|
m_readConfig->getColorValue(m_paletteColorCfg.buttonText_dis , m_theme, UKUIPalette, c_buttonText_dis);
|
|
m_readConfig->getColorValue(m_paletteColorCfg.base_at , m_theme, UKUIPalette, c_base_at);
|
|
m_readConfig->getColorValue(m_paletteColorCfg.base_iat , m_theme, UKUIPalette, c_base_iat);
|
|
m_readConfig->getColorValue(m_paletteColorCfg.base_dis , m_theme, UKUIPalette, c_base_dis);
|
|
m_readConfig->getColorValue(m_paletteColorCfg.window_at , m_theme, UKUIPalette, c_window_at);
|
|
m_readConfig->getColorValue(m_paletteColorCfg.window_iat , m_theme, UKUIPalette, c_window_iat);
|
|
m_readConfig->getColorValue(m_paletteColorCfg.window_dis , m_theme, UKUIPalette, c_window_dis);
|
|
m_readConfig->getColorValue(m_paletteColorCfg.shadow_at , m_theme, UKUIPalette, c_shadow_at);
|
|
m_readConfig->getColorValue(m_paletteColorCfg.shadow_iat , m_theme, UKUIPalette, c_shadow_iat);
|
|
m_readConfig->getColorValue(m_paletteColorCfg.shadow_dis , m_theme, UKUIPalette, c_shadow_dis);
|
|
m_readConfig->getColorValue(m_paletteColorCfg.highLight_at , m_theme, UKUIPalette, c_highLight_at);
|
|
m_readConfig->getColorValue(m_paletteColorCfg.highLight_iat , m_theme, UKUIPalette, c_highLight_iat);
|
|
m_readConfig->getColorValue(m_paletteColorCfg.highLight_dis , m_theme, UKUIPalette, c_highLight_dis);
|
|
m_readConfig->getColorValue(m_paletteColorCfg.highLightText_at , m_theme, UKUIPalette, c_highLightText_at);
|
|
m_readConfig->getColorValue(m_paletteColorCfg.highLightText_iat , m_theme, UKUIPalette, c_highLightText_iat);
|
|
m_readConfig->getColorValue(m_paletteColorCfg.highLightText_dis , m_theme, UKUIPalette, c_highLightText_dis);
|
|
m_readConfig->getColorValue(m_paletteColorCfg.link_at , m_theme, UKUIPalette, c_link_at);
|
|
m_readConfig->getColorValue(m_paletteColorCfg.link_iat , m_theme, UKUIPalette, c_link_iat);
|
|
m_readConfig->getColorValue(m_paletteColorCfg.link_dis , m_theme, UKUIPalette, c_link_dis);
|
|
m_readConfig->getColorValue(m_paletteColorCfg.linkVisited_at , m_theme, UKUIPalette, c_linkVisited_at);
|
|
m_readConfig->getColorValue(m_paletteColorCfg.linkVisited_iat , m_theme, UKUIPalette, c_linkVisited_iat);
|
|
m_readConfig->getColorValue(m_paletteColorCfg.linkVisited_dis , m_theme, UKUIPalette, c_linkVisited_dis);
|
|
m_readConfig->getColorValue(m_paletteColorCfg.alternateBase_at , m_theme, UKUIPalette, c_alternateBase_at);
|
|
m_readConfig->getColorValue(m_paletteColorCfg.alternateBase_iat , m_theme, UKUIPalette, c_alternateBase_iat);
|
|
m_readConfig->getColorValue(m_paletteColorCfg.alternateBase_dis , m_theme, UKUIPalette, c_alternateBase_dis);
|
|
m_readConfig->getColorValue(m_paletteColorCfg.noRole_at , m_theme, UKUIPalette, c_noRole_at);
|
|
m_readConfig->getColorValue(m_paletteColorCfg.noRole_iat , m_theme, UKUIPalette, c_noRole_iat);
|
|
m_readConfig->getColorValue(m_paletteColorCfg.noRole_dis , m_theme, UKUIPalette, c_noRole_dis);
|
|
m_readConfig->getColorValue(m_paletteColorCfg.toolTipBase_at , m_theme, UKUIPalette, c_toolTipBase_at);
|
|
m_readConfig->getColorValue(m_paletteColorCfg.toolTipBase_iat , m_theme, UKUIPalette, c_toolTipBase_iat);
|
|
m_readConfig->getColorValue(m_paletteColorCfg.toolTipBase_dis , m_theme, UKUIPalette, c_toolTipBase_dis);
|
|
m_readConfig->getColorValue(m_paletteColorCfg.toolTipText_at , m_theme, UKUIPalette, c_toolTipText_at);
|
|
m_readConfig->getColorValue(m_paletteColorCfg.toolTipText_iat , m_theme, UKUIPalette, c_toolTipText_iat);
|
|
m_readConfig->getColorValue(m_paletteColorCfg.toolTipText_dis , m_theme, UKUIPalette, c_toolTipText_dis);
|
|
m_readConfig->getColorValue(m_paletteColorCfg.placeholderText_at , m_theme, UKUIPalette, c_placeholderText_at);
|
|
m_readConfig->getColorValue(m_paletteColorCfg.placeholderText_iat, m_theme, UKUIPalette, c_placeholderText_iat);
|
|
m_readConfig->getColorValue(m_paletteColorCfg.placeholderText_dis, m_theme, UKUIPalette, c_placeholderText_dis);
|
|
return m_paletteColorCfg;
|
|
}
|
|
|
|
UKUIColorTheme::ButtonColorCfg ReadThemeConfig::buttonColorCfg(const QPalette palette, QString property)
|
|
{
|
|
if(!m_loadConfig)
|
|
return m_buttonColorCfg;
|
|
|
|
m_readConfig->widgetPalette(palette);
|
|
UKUIColorTheme::ButtonColorCfg buttonCfg;
|
|
m_readConfig->getColorValue(buttonCfg.defaultBrush, m_theme, UKUIPushButton, property, C_Button_DefaultBrush);
|
|
m_readConfig->getColorValue(buttonCfg.clickBrush , m_theme, UKUIPushButton, property, C_Button_ClickBrush);
|
|
m_readConfig->getColorValue(buttonCfg.disableBrush, m_theme, UKUIPushButton, property, C_Button_DisableBrush);
|
|
|
|
buttonCfg.hoverType = m_readConfig->getType(m_theme, UKUIPushButton, property, C_Button_HoverBrush);
|
|
if(buttonCfg.hoverType == Obj_Gradient_Type){
|
|
buttonCfg.hoverGradientList.clear();
|
|
m_readConfig->getGradientValue(buttonCfg.hoverGradientList , m_theme, UKUIPushButton, property, C_Button_HoverBrush);
|
|
}
|
|
else{
|
|
m_readConfig->getColorValue(buttonCfg.hoverBrush , m_theme, UKUIPushButton, property, C_Button_HoverBrush);
|
|
}
|
|
|
|
m_readConfig->getColorValue(buttonCfg.defaultPen , m_theme, UKUIPushButton, property, C_Button_DefaultPen );
|
|
m_readConfig->getColorValue(buttonCfg.hoverPen , m_theme, UKUIPushButton, property, C_Button_HoverPen );
|
|
m_readConfig->getColorValue(buttonCfg.clickPen , m_theme, UKUIPushButton, property, C_Button_ClickPen );
|
|
m_readConfig->getColorValue(buttonCfg.disablePen , m_theme, UKUIPushButton, property, C_Button_DisablePen );
|
|
m_readConfig->getColorValue(buttonCfg.focusPen , m_theme, UKUIPushButton, property, C_Button_FocusPen );
|
|
m_readConfig->getColorValue(buttonCfg.textColor , m_theme, UKUIPushButton, property, C_Button_TextColor );
|
|
m_readConfig->getColorValue(buttonCfg.textHoverColor , m_theme, UKUIPushButton, property, C_Button_TextHoverColor );
|
|
|
|
m_buttonColorCfg = buttonCfg;
|
|
return m_buttonColorCfg;
|
|
}
|
|
|
|
UKUIColorTheme::ToolButtonColorCfg ReadThemeConfig::toolButtonColorCfg(const QPalette palette, QString property)
|
|
{
|
|
if(!m_loadConfig)
|
|
return m_toolButtonColorCfg;
|
|
|
|
m_readConfig->widgetPalette(palette);
|
|
UKUIColorTheme::ToolButtonColorCfg tbcfg;
|
|
m_readConfig->getColorValue(tbcfg.defaultBrush, m_theme, UKUIToolButton, property, C_Button_DefaultBrush);
|
|
m_readConfig->getColorValue(tbcfg.clickBrush , m_theme, UKUIToolButton, property, C_Button_ClickBrush);
|
|
m_readConfig->getColorValue(tbcfg.disableBrush, m_theme, UKUIToolButton, property, C_Button_DisableBrush);
|
|
|
|
tbcfg.hoverType = m_readConfig->getType(m_theme, UKUIToolButton, property, C_Button_HoverBrush);
|
|
if(tbcfg.hoverType == Obj_Gradient_Type){
|
|
tbcfg.hoverGradientList.clear();
|
|
m_readConfig->getGradientValue(tbcfg.hoverGradientList , m_theme, UKUIToolButton, property, C_Button_HoverBrush);
|
|
}
|
|
else{
|
|
m_readConfig->getColorValue(tbcfg.hoverBrush , m_theme, UKUIToolButton, property, C_Button_HoverBrush);
|
|
}
|
|
|
|
m_readConfig->getColorValue(tbcfg.defaultPen , m_theme, UKUIToolButton, property, C_Button_DefaultPen );
|
|
m_readConfig->getColorValue(tbcfg.hoverPen , m_theme, UKUIToolButton, property, C_Button_HoverPen );
|
|
m_readConfig->getColorValue(tbcfg.clickPen , m_theme, UKUIToolButton, property, C_Button_ClickPen );
|
|
m_readConfig->getColorValue(tbcfg.disablePen , m_theme, UKUIToolButton, property, C_Button_DisablePen );
|
|
m_readConfig->getColorValue(tbcfg.focusPen , m_theme, UKUIToolButton, property, C_Button_FocusPen );
|
|
m_readConfig->getColorValue(tbcfg.textColor , m_theme, UKUIToolButton, property, C_Button_TextColor );
|
|
m_readConfig->getColorValue(tbcfg.textHoverColor , m_theme, UKUIToolButton, property, C_Button_TextHoverColor );
|
|
|
|
m_toolButtonColorCfg = tbcfg;
|
|
return m_toolButtonColorCfg;
|
|
}
|
|
|
|
UKUIColorTheme::CheckBoxColorCfg ReadThemeConfig::checkBoxColorCfg(const QPalette palette, QString property)
|
|
{
|
|
if(!m_loadConfig)
|
|
return m_checkBoxColorCfg;
|
|
|
|
m_readConfig->widgetPalette(palette);
|
|
m_readConfig->getColorValue(m_checkBoxColorCfg.defaultPen , m_theme, UKUICheckBox, property, C_CheckBox_DefaultPen);
|
|
m_readConfig->getColorValue(m_checkBoxColorCfg.hoverPen , m_theme, UKUICheckBox, property, C_CheckBox_HoverPen);
|
|
m_readConfig->getColorValue(m_checkBoxColorCfg.clickPen , m_theme, UKUICheckBox, property, C_CheckBox_ClickPen);
|
|
m_readConfig->getColorValue(m_checkBoxColorCfg.disablePen , m_theme, UKUICheckBox, property, C_CheckBox_DisablePen);
|
|
m_readConfig->getColorValue(m_checkBoxColorCfg.onDefaultPen , m_theme, UKUICheckBox, property, C_CheckBox_OnDefaultPen);
|
|
m_readConfig->getColorValue(m_checkBoxColorCfg.onHoverPen , m_theme, UKUICheckBox, property, C_CheckBox_OnHoverPen);
|
|
m_readConfig->getColorValue(m_checkBoxColorCfg.onClickPen , m_theme, UKUICheckBox, property, C_CheckBox_OnClickPen);
|
|
m_readConfig->getColorValue(m_checkBoxColorCfg.contentPen , m_theme, UKUICheckBox, property, C_CheckBox_ContentPen);
|
|
|
|
m_readConfig->getColorValue(m_checkBoxColorCfg.defaultBrush , m_theme, UKUICheckBox, property, C_CheckBox_DefaultBrush);
|
|
m_readConfig->getColorValue(m_checkBoxColorCfg.clickBrush , m_theme, UKUICheckBox, property, C_CheckBox_ClickBrush);
|
|
m_readConfig->getColorValue(m_checkBoxColorCfg.disableBrush , m_theme, UKUICheckBox, property, C_CheckBox_DisableBrush);
|
|
m_readConfig->getColorValue(m_checkBoxColorCfg.onDefaultBrush , m_theme, UKUICheckBox, property, C_CheckBox_OnDefaultBrush);
|
|
m_readConfig->getColorValue(m_checkBoxColorCfg.pathBrush , m_theme, UKUICheckBox, property, C_CheckBox_PathBrush);
|
|
m_readConfig->getColorValue(m_checkBoxColorCfg.pathDisableBrush, m_theme, UKUICheckBox, property, C_CheckBox_PathDisableBrush);
|
|
|
|
m_checkBoxColorCfg.hoverType = m_readConfig->getType(m_theme, UKUICheckBox, property, C_CheckBox_HoverBrush);
|
|
m_checkBoxColorCfg.onHoverType = m_readConfig->getType(m_theme, UKUICheckBox, property, C_CheckBox_OnHoverBrush);
|
|
m_checkBoxColorCfg.onClickType = m_readConfig->getType(m_theme, UKUICheckBox, property, C_CheckBox_OnClickBrush);
|
|
|
|
if(m_checkBoxColorCfg.hoverType == Obj_Gradient_Type){
|
|
m_checkBoxColorCfg.hoverGradientList.clear();
|
|
m_readConfig->getGradientValue(m_checkBoxColorCfg.hoverGradientList , m_theme, UKUICheckBox, property, C_CheckBox_HoverBrush);
|
|
}
|
|
else{
|
|
m_readConfig->getColorValue(m_checkBoxColorCfg.hoverBrush, m_theme, UKUICheckBox, property, C_CheckBox_HoverBrush);
|
|
}
|
|
if(m_checkBoxColorCfg.onHoverType == Obj_Gradient_Type){
|
|
m_checkBoxColorCfg.onHoverGradientList.clear();
|
|
m_readConfig->getGradientValue(m_checkBoxColorCfg.onHoverGradientList , m_theme, UKUICheckBox, property, C_CheckBox_OnHoverBrush);
|
|
}
|
|
else{
|
|
m_readConfig->getColorValue(m_checkBoxColorCfg.onHoverBrush, m_theme, UKUICheckBox, property, C_CheckBox_OnHoverBrush);
|
|
}
|
|
if(m_checkBoxColorCfg.onClickType == Obj_Gradient_Type){
|
|
m_checkBoxColorCfg.onClickGradientList.clear();
|
|
m_readConfig->getGradientValue(m_checkBoxColorCfg.onClickGradientList , m_theme, UKUICheckBox, property, C_CheckBox_OnClickBrush);
|
|
}
|
|
else{
|
|
m_readConfig->getColorValue(m_checkBoxColorCfg.onClickBrush, m_theme, UKUICheckBox, property, C_CheckBox_OnClickBrush);
|
|
}
|
|
|
|
return m_checkBoxColorCfg;
|
|
}
|
|
|
|
UKUIColorTheme::RadioButtonColorCfg ReadThemeConfig::radioButtonColorCfg(const QPalette palette, QString property)
|
|
{
|
|
if(!m_loadConfig)
|
|
return m_radioButtonColorCfg;
|
|
|
|
m_readConfig->widgetPalette(palette);
|
|
m_readConfig->getColorValue(m_radioButtonColorCfg.defaultPen , m_theme, UKUIRadioButton, property, C_RadioButton_DefaultPen);
|
|
m_readConfig->getColorValue(m_radioButtonColorCfg.hoverPen , m_theme, UKUIRadioButton, property, C_RadioButton_HoverPen);
|
|
m_readConfig->getColorValue(m_radioButtonColorCfg.clickPen , m_theme, UKUIRadioButton, property, C_RadioButton_ClickPen);
|
|
m_readConfig->getColorValue(m_radioButtonColorCfg.disablePen , m_theme, UKUIRadioButton, property, C_RadioButton_DisablePen);
|
|
m_readConfig->getColorValue(m_radioButtonColorCfg.onDefaultPen , m_theme, UKUIRadioButton, property, C_RadioButton_OnDefaultPen);
|
|
m_readConfig->getColorValue(m_radioButtonColorCfg.onHoverPen , m_theme, UKUIRadioButton, property, C_RadioButton_OnHoverPen);
|
|
m_readConfig->getColorValue(m_radioButtonColorCfg.onClickPen , m_theme, UKUIRadioButton, property, C_RadioButton_OnClickPen);
|
|
|
|
m_readConfig->getColorValue(m_radioButtonColorCfg.defaultBrush , m_theme, UKUIRadioButton, property, C_RadioButton_DefaultBrush);
|
|
m_readConfig->getColorValue(m_radioButtonColorCfg.hoverBrush , m_theme, UKUIRadioButton, property, C_RadioButton_HoverBrush);
|
|
m_readConfig->getColorValue(m_radioButtonColorCfg.clickBrush , m_theme, UKUIRadioButton, property, C_RadioButton_ClickBrush);
|
|
m_readConfig->getColorValue(m_radioButtonColorCfg.disableBrush , m_theme, UKUIRadioButton, property, C_RadioButton_DisableBrush);
|
|
m_readConfig->getColorValue(m_radioButtonColorCfg.onDefaultBrush , m_theme, UKUIRadioButton, property, C_RadioButton_OnDefaultBrush);
|
|
m_readConfig->getColorValue(m_radioButtonColorCfg.onClickBrush , m_theme, UKUIRadioButton, property, C_RadioButton_OnClickBrush);
|
|
m_readConfig->getColorValue(m_radioButtonColorCfg.childrenOnDefaultBrush, m_theme, UKUIRadioButton, property, C_RadioButton_ChildrenOnDefaultBrush);
|
|
m_readConfig->getColorValue(m_radioButtonColorCfg.childrenOnHoverBrush , m_theme, UKUIRadioButton, property, C_RadioButton_ChildrenOnHoverBrush);
|
|
m_readConfig->getColorValue(m_radioButtonColorCfg.childrenOnClickBrush , m_theme, UKUIRadioButton, property, C_RadioButton_ChildrenOnClickBrush);
|
|
m_readConfig->getColorValue(m_radioButtonColorCfg.childrenOnDisableBrush, m_theme, UKUIRadioButton, property, C_RadioButton_ChildrenOnDisableBrush);
|
|
|
|
m_radioButtonColorCfg.onHoverType = m_readConfig->getType(m_theme, UKUIRadioButton, property, C_RadioButton_OnHoverBrush);
|
|
if(m_radioButtonColorCfg.onHoverType == Obj_Gradient_Type){
|
|
m_radioButtonColorCfg.onHoverGradientList.clear();
|
|
m_readConfig->getGradientValue(m_radioButtonColorCfg.onHoverGradientList , m_theme, UKUIRadioButton, property, C_RadioButton_OnHoverBrush);
|
|
}
|
|
else{
|
|
m_readConfig->getColorValue(m_radioButtonColorCfg.onHoverBrush, m_theme, UKUIRadioButton, property, C_RadioButton_OnHoverBrush);
|
|
}
|
|
|
|
return m_radioButtonColorCfg;
|
|
}
|
|
|
|
UKUIColorTheme::LineEditColorCfg ReadThemeConfig::lineEditColorCfg(const QPalette palette, QString property)
|
|
{
|
|
if(!m_loadConfig)
|
|
return m_lineEditColorCfg;
|
|
|
|
m_readConfig->widgetPalette(palette);
|
|
m_readConfig->getColorValue(m_lineEditColorCfg.defaultPen , m_theme, UKUILineEdit, property, C_LineEdit_DefaultPen);
|
|
m_readConfig->getColorValue(m_lineEditColorCfg.hoverPen , m_theme, UKUILineEdit, property, C_LineEdit_HoverPen);
|
|
m_readConfig->getColorValue(m_lineEditColorCfg.focusPen , m_theme, UKUILineEdit, property, C_LineEdit_FocusPen);
|
|
m_readConfig->getColorValue(m_lineEditColorCfg.disablePen , m_theme, UKUILineEdit, property, C_LineEdit_DisablePen);
|
|
|
|
m_readConfig->getColorValue(m_lineEditColorCfg.defaultBrush, m_theme, UKUILineEdit, property, C_LineEdit_DefaultBrush);
|
|
m_readConfig->getColorValue(m_lineEditColorCfg.focusBrush , m_theme, UKUILineEdit, property, C_LineEdit_FocusBrush);
|
|
m_readConfig->getColorValue(m_lineEditColorCfg.disableBrush, m_theme, UKUILineEdit, property, C_LineEdit_DisableBrush);
|
|
|
|
m_lineEditColorCfg.hoverType = m_readConfig->getType(m_theme, UKUILineEdit, property, C_LineEdit_HoverBrush);
|
|
if(m_lineEditColorCfg.hoverType == Obj_Gradient_Type){
|
|
m_lineEditColorCfg.hoverGradientList.clear();
|
|
m_readConfig->getGradientValue(m_lineEditColorCfg.hoverGradientList , m_theme, UKUILineEdit, property, C_LineEdit_HoverBrush);
|
|
}
|
|
else{
|
|
m_readConfig->getColorValue(m_lineEditColorCfg.hoverBrush, m_theme, UKUILineEdit, property, C_LineEdit_HoverBrush);
|
|
}
|
|
|
|
return m_lineEditColorCfg;
|
|
}
|
|
|
|
UKUIColorTheme::ComboBoxColorCfg ReadThemeConfig::comboBoxColorCfg(const QPalette palette, QString property)
|
|
{
|
|
if(!m_loadConfig)
|
|
return m_comboBoxColorCfg;
|
|
|
|
m_readConfig->widgetPalette(palette);
|
|
m_readConfig->getColorValue(m_comboBoxColorCfg.defaultPen , m_theme, UKUIComboBox, property, C_ComboBox_DefaultPen);
|
|
m_readConfig->getColorValue(m_comboBoxColorCfg.hoverPen , m_theme, UKUIComboBox, property, C_ComboBox_HoverPen);
|
|
m_readConfig->getColorValue(m_comboBoxColorCfg.onPen , m_theme, UKUIComboBox, property, C_ComboBox_OnPen);
|
|
m_readConfig->getColorValue(m_comboBoxColorCfg.editPen , m_theme, UKUIComboBox, property, C_ComboBox_EditPen);
|
|
m_readConfig->getColorValue(m_comboBoxColorCfg.disablePen , m_theme, UKUIComboBox, property, C_ComboBox_DisablePen);
|
|
m_readConfig->getColorValue(m_comboBoxColorCfg.focusPen , m_theme, UKUIComboBox, property, C_ComboBox_FocusPen);
|
|
|
|
m_readConfig->getColorValue(m_comboBoxColorCfg.defaultBrush, m_theme, UKUIComboBox, property, C_ComboBox_DefaultBrush);
|
|
m_readConfig->getColorValue(m_comboBoxColorCfg.hoverBrush , m_theme, UKUIComboBox, property, C_ComboBox_HoverBrush);
|
|
m_readConfig->getColorValue(m_comboBoxColorCfg.onBrush , m_theme, UKUIComboBox, property, C_ComboBox_OnBrush);
|
|
m_readConfig->getColorValue(m_comboBoxColorCfg.editBrush , m_theme, UKUIComboBox, property, C_ComboBox_EditBrush);
|
|
m_readConfig->getColorValue(m_comboBoxColorCfg.disableBrush, m_theme, UKUIComboBox, property, C_ComboBox_DisableBrush);
|
|
return m_comboBoxColorCfg;
|
|
}
|
|
|
|
UKUIColorTheme::SpinBoxColorCfg ReadThemeConfig::spinBoxColorCfg(const QPalette palette, QString property, QString layout)
|
|
{
|
|
if(!m_loadConfig)
|
|
return m_spinBoxColorCfg;
|
|
|
|
m_readConfig->widgetPalette(palette);
|
|
m_readConfig->getColorValue(m_spinBoxColorCfg.defaultPen , m_theme, UKUISpinBox, property, layout, C_SpinBox_DefaultPen);
|
|
m_readConfig->getColorValue(m_spinBoxColorCfg.hoverPen , m_theme, UKUISpinBox, property, layout, C_SpinBox_HoverPen);
|
|
m_readConfig->getColorValue(m_spinBoxColorCfg.focusPen , m_theme, UKUISpinBox, property, layout, C_SpinBox_FocusPen);
|
|
m_readConfig->getColorValue(m_spinBoxColorCfg.disablePen , m_theme, UKUISpinBox, property, layout, C_SpinBox_DisablePen);
|
|
|
|
m_readConfig->getColorValue(m_spinBoxColorCfg.defaultBrush , m_theme, UKUISpinBox, property, layout, C_SpinBox_DefaultBrush);
|
|
m_readConfig->getColorValue(m_spinBoxColorCfg.focusBrush , m_theme, UKUISpinBox, property, layout, C_SpinBox_FocusBrush);
|
|
m_readConfig->getColorValue(m_spinBoxColorCfg.disableBrush , m_theme, UKUISpinBox, property, layout, C_SpinBox_DisableBrush);
|
|
m_readConfig->getColorValue(m_spinBoxColorCfg.upClickBrush , m_theme, UKUISpinBox, property, layout, C_SpinBox_UpClickBrush );
|
|
m_readConfig->getColorValue(m_spinBoxColorCfg.upDefaultBrush , m_theme, UKUISpinBox, property, layout, C_SpinBox_UpDefaultBrush );
|
|
m_readConfig->getColorValue(m_spinBoxColorCfg.downClickBrush , m_theme, UKUISpinBox, property, layout, C_SpinBox_DownClickBrush );
|
|
m_readConfig->getColorValue(m_spinBoxColorCfg.downDefaultBrush , m_theme, UKUISpinBox, property, layout, C_SpinBox_DownDefaultBrush );
|
|
|
|
m_spinBoxColorCfg.hoverType = m_readConfig->getType(m_theme, UKUISpinBox, property, layout, C_SpinBox_HoverBrush);
|
|
m_spinBoxColorCfg.upHoverBrushType = m_readConfig->getType(m_theme, UKUISpinBox, property, layout, C_SpinBox_UpHoverBrush);
|
|
m_spinBoxColorCfg.upFocusHoverBrushType = m_readConfig->getType(m_theme, UKUISpinBox, property, layout, C_SpinBox_UpFocusHoverBrush);
|
|
m_spinBoxColorCfg.downHoverBrushType = m_readConfig->getType(m_theme, UKUISpinBox, property, layout, C_SpinBox_DownHoverBrush);
|
|
m_spinBoxColorCfg.downFocusHoverBrushType = m_readConfig->getType(m_theme, UKUISpinBox, property, layout, C_SpinBox_DownFocusHoverBrush);
|
|
|
|
if(m_spinBoxColorCfg.hoverType == Obj_Gradient_Type){
|
|
m_spinBoxColorCfg.hoverGradientList.clear();
|
|
m_readConfig->getGradientValue(m_spinBoxColorCfg.hoverGradientList , m_theme, UKUISpinBox, property, layout, C_SpinBox_HoverBrush);
|
|
}
|
|
else {
|
|
m_readConfig->getColorValue(m_spinBoxColorCfg.hoverBrush, m_theme, UKUISpinBox, property, layout, C_SpinBox_HoverBrush);
|
|
}
|
|
|
|
if(m_spinBoxColorCfg.upHoverBrushType == Obj_Gradient_Type){
|
|
m_spinBoxColorCfg.upHoverBrushGradientList.clear();
|
|
m_readConfig->getGradientValue(m_spinBoxColorCfg.upHoverBrushGradientList , m_theme, UKUISpinBox, property, layout, C_SpinBox_UpHoverBrush);
|
|
}
|
|
else{
|
|
m_readConfig->getColorValue(m_spinBoxColorCfg.upHoverBrush, m_theme, UKUISpinBox, property, layout, C_SpinBox_UpHoverBrush);
|
|
}
|
|
|
|
if(m_spinBoxColorCfg.upFocusHoverBrushType == Obj_Gradient_Type){
|
|
m_spinBoxColorCfg.upFocusHoverBrushGradientList.clear();
|
|
m_readConfig->getGradientValue(m_spinBoxColorCfg.upFocusHoverBrushGradientList , m_theme, UKUISpinBox, property, layout, C_SpinBox_UpFocusHoverBrush);
|
|
}
|
|
else{
|
|
m_readConfig->getColorValue(m_spinBoxColorCfg.upFocusHoverBrush, m_theme, UKUISpinBox, property, layout, C_SpinBox_UpFocusHoverBrush);
|
|
}
|
|
|
|
if(m_spinBoxColorCfg.downHoverBrushType == Obj_Gradient_Type){
|
|
m_spinBoxColorCfg.downHoverBrushGradientList.clear();
|
|
m_readConfig->getGradientValue(m_spinBoxColorCfg.downHoverBrushGradientList , m_theme, UKUISpinBox, property, layout, C_SpinBox_DownHoverBrush);
|
|
}
|
|
else{
|
|
m_readConfig->getColorValue(m_spinBoxColorCfg.downHoverBrush, m_theme, UKUISpinBox, property, layout, C_SpinBox_DownHoverBrush);
|
|
}
|
|
|
|
if(m_spinBoxColorCfg.downFocusHoverBrushType == Obj_Gradient_Type){
|
|
m_spinBoxColorCfg.downFocusHoverBrushGradientList.clear();
|
|
m_readConfig->getGradientValue(m_spinBoxColorCfg.downFocusHoverBrushGradientList , m_theme, UKUISpinBox, property, layout, C_SpinBox_DownFocusHoverBrush);
|
|
}
|
|
else{
|
|
m_readConfig->getColorValue(m_spinBoxColorCfg.downFocusHoverBrush, m_theme, UKUISpinBox, property, layout, C_SpinBox_DownFocusHoverBrush);
|
|
}
|
|
|
|
m_readConfig->getColorValue(m_spinBoxColorCfg.upDefaultPen , m_theme, UKUISpinBox, property, layout, C_SpinBox_UpDefaultPen );
|
|
m_readConfig->getColorValue(m_spinBoxColorCfg.upHoverPen , m_theme, UKUISpinBox, property, layout, C_SpinBox_UpHoverPen );
|
|
m_readConfig->getColorValue(m_spinBoxColorCfg.upDisablePen , m_theme, UKUISpinBox, property, layout, C_SpinBox_UpDisablePen );
|
|
m_readConfig->getColorValue(m_spinBoxColorCfg.upClickPen , m_theme, UKUISpinBox, property, layout, C_SpinBox_UpClickPen );
|
|
m_readConfig->getColorValue(m_spinBoxColorCfg.upFocusPen , m_theme, UKUISpinBox, property, layout, C_SpinBox_UpFocusPen );
|
|
|
|
m_readConfig->getColorValue(m_spinBoxColorCfg.downDefaultPen , m_theme, UKUISpinBox, property, layout, C_SpinBox_DownDefaultPen );
|
|
m_readConfig->getColorValue(m_spinBoxColorCfg.downHoverPen , m_theme, UKUISpinBox, property, layout, C_SpinBox_DownHoverPen );
|
|
m_readConfig->getColorValue(m_spinBoxColorCfg.downDisablePen , m_theme, UKUISpinBox, property, layout, C_SpinBox_DownDisablePen );
|
|
m_readConfig->getColorValue(m_spinBoxColorCfg.downClickPen , m_theme, UKUISpinBox, property, layout, C_SpinBox_DownClickPen );
|
|
m_readConfig->getColorValue(m_spinBoxColorCfg.downFocusPen , m_theme, UKUISpinBox, property, layout, C_SpinBox_DownFocusPen );
|
|
|
|
return m_spinBoxColorCfg;
|
|
}
|
|
|
|
UKUIColorTheme::TableColorCfg ReadThemeConfig::tableColorCfg(const QPalette palette, QString property)
|
|
{
|
|
if(!m_loadConfig)
|
|
return m_tableColorCfg;
|
|
|
|
m_readConfig->widgetPalette(palette);
|
|
m_readConfig->getColorValue(m_tableColorCfg.defaultBrush ,m_theme, UKUITable, property, C_Table_DefaultBrush);
|
|
m_readConfig->getColorValue(m_tableColorCfg.selectBrush ,m_theme, UKUITable, property, C_Table_SelectBrush);
|
|
m_readConfig->getColorValue(m_tableColorCfg.disableBrush ,m_theme, UKUITable, property, C_Table_DisableBrush);
|
|
|
|
m_readConfig->getColorValue(m_tableColorCfg.hoverPen ,m_theme, UKUITable, property, C_Table_HoverPen);
|
|
m_readConfig->getColorValue(m_tableColorCfg.selectPen ,m_theme, UKUITable, property, C_Table_SelectPen);
|
|
m_readConfig->getColorValue(m_tableColorCfg.textHoverPen ,m_theme, UKUITable, property, C_Table_TextHoverPen);
|
|
m_readConfig->getColorValue(m_tableColorCfg.textSelectPen ,m_theme, UKUITable, property, C_Table_TextSelectPen);
|
|
|
|
m_tableColorCfg.hoverType = m_readConfig->getType(m_theme, UKUITable, property, C_Table_HoverBrush);
|
|
if(m_tableColorCfg.hoverType == Obj_Gradient_Type){
|
|
m_tableColorCfg.hoverGradientList.clear();
|
|
m_readConfig->getGradientValue(m_tableColorCfg.hoverGradientList , m_theme, UKUITable, property, C_Table_HoverBrush);
|
|
}
|
|
else{
|
|
m_readConfig->getColorValue(m_tableColorCfg.hoverBrush, m_theme, UKUITable, property, C_Table_HoverBrush);
|
|
}
|
|
return m_tableColorCfg;
|
|
}
|
|
|
|
UKUIColorTheme::ListViewColorCfg ReadThemeConfig::listViewColorCfg(const QPalette palette, QString property)
|
|
{
|
|
if(!m_loadConfig)
|
|
return m_listViewColorCfg;
|
|
|
|
m_readConfig->widgetPalette(palette);
|
|
m_readConfig->getColorValue(m_listViewColorCfg.defaultBrush , m_theme, UKUIListView, property, C_ListView_DefaultBrush);
|
|
m_readConfig->getColorValue(m_listViewColorCfg.selectBrush , m_theme, UKUIListView, property, C_ListView_SelectBrush);
|
|
m_readConfig->getColorValue(m_listViewColorCfg.disableBrush , m_theme, UKUIListView, property, C_ListView_DisableBrush);
|
|
|
|
m_readConfig->getColorValue(m_listViewColorCfg.textHoverPen , m_theme, UKUIListView, property, C_ListView_TextHoverPen);
|
|
m_readConfig->getColorValue(m_listViewColorCfg.textSelectPen, m_theme, UKUIListView, property, C_ListView_TextSelectPen);
|
|
m_readConfig->getColorValue(m_listViewColorCfg.focusPen , m_theme, UKUITreeView, property, C_TreeView_FocusPen);
|
|
|
|
m_listViewColorCfg.hoverType = m_readConfig->getType(m_theme, UKUIListView, property, C_ListView_HoverBrush);
|
|
if(m_listViewColorCfg.hoverType == Obj_Gradient_Type){
|
|
m_listViewColorCfg.hoverGradientList.clear();
|
|
m_readConfig->getGradientValue(m_listViewColorCfg.hoverGradientList , m_theme, UKUIListView, property, C_ListView_HoverBrush);
|
|
}
|
|
else{
|
|
m_readConfig->getColorValue(m_listViewColorCfg.hoverBrush, m_theme, UKUIListView, property, C_ListView_HoverBrush);
|
|
}
|
|
|
|
m_readConfig->getColorValue(m_listViewColorCfg.hoverPen , m_theme, UKUIListView, property, C_ListView_HoverPen);
|
|
m_readConfig->getColorValue(m_listViewColorCfg.selectPen, m_theme, UKUIListView, property, C_ListView_SelectPen);
|
|
|
|
return m_listViewColorCfg;
|
|
}
|
|
|
|
UKUIColorTheme::TreeViewColorCfg ReadThemeConfig::treeViewColorCfg(const QPalette palette, QString property)
|
|
{
|
|
if(!m_loadConfig)
|
|
return m_treeViewColorCfg;
|
|
|
|
m_readConfig->widgetPalette(palette);
|
|
m_readConfig->getColorValue(m_treeViewColorCfg.defaultBrush , m_theme, UKUITreeView, property, C_TreeView_DefaultBrush);
|
|
m_readConfig->getColorValue(m_treeViewColorCfg.selectBrush , m_theme, UKUITreeView, property, C_TreeView_SelectBrush);
|
|
m_readConfig->getColorValue(m_treeViewColorCfg.disableBrush , m_theme, UKUITreeView, property, C_TreeView_DisableBrush);
|
|
m_readConfig->getColorValue(m_treeViewColorCfg.branchDefaultBrush, m_theme, UKUITreeView, property, C_TreeView_BranchDefaultBrush);
|
|
m_readConfig->getColorValue(m_treeViewColorCfg.branchSelectBrush , m_theme, UKUITreeView, property, C_TreeView_BranchSelectBrush);
|
|
m_readConfig->getColorValue(m_treeViewColorCfg.branchDisableBrush, m_theme, UKUITreeView, property, C_TreeView_BranchDisableBrush);
|
|
m_readConfig->getColorValue(m_treeViewColorCfg.focusPen , m_theme, UKUITreeView, property, C_TreeView_FocusPen);
|
|
|
|
m_readConfig->getColorValue(m_treeViewColorCfg.textHoverPen , m_theme, UKUITreeView, property, C_TreeView_TextHoverPen);
|
|
m_readConfig->getColorValue(m_treeViewColorCfg.textSelectPen , m_theme, UKUITreeView, property, C_TreeView_TextSelectPen);
|
|
|
|
|
|
m_treeViewColorCfg.hoverType = m_readConfig->getType(m_theme, UKUITreeView, property, C_TreeView_HoverBrush);
|
|
if(m_treeViewColorCfg.hoverType == Obj_Gradient_Type){
|
|
m_treeViewColorCfg.hoverGradientList.clear();
|
|
m_readConfig->getGradientValue(m_treeViewColorCfg.hoverGradientList , m_theme, UKUITreeView, property, C_TreeView_HoverBrush);
|
|
}
|
|
else{
|
|
m_readConfig->getColorValue(m_treeViewColorCfg.hoverBrush, m_theme, UKUITreeView, property, C_TreeView_HoverBrush);
|
|
}
|
|
m_treeViewColorCfg.branchHoverType = m_readConfig->getType(m_theme, UKUITreeView, property, C_TreeView_BranchHoverBrush);
|
|
if(m_treeViewColorCfg.branchHoverType == Obj_Gradient_Type){
|
|
m_treeViewColorCfg.branchHoverGradientList.clear();
|
|
m_readConfig->getGradientValue(m_treeViewColorCfg.branchHoverGradientList , m_theme, UKUITreeView, property, C_TreeView_BranchHoverBrush);
|
|
}
|
|
else{
|
|
m_readConfig->getColorValue(m_treeViewColorCfg.branchHoverBrush, m_theme, UKUITreeView, property, C_TreeView_BranchHoverBrush);
|
|
}
|
|
m_readConfig->getColorValue(m_treeViewColorCfg.hoverPen , m_theme, UKUITreeView, property, C_TreeView_HoverPen);
|
|
m_readConfig->getColorValue(m_treeViewColorCfg.selectPen, m_theme, UKUITreeView, property, C_TreeView_SelectPen);
|
|
m_readConfig->getColorValue(m_treeViewColorCfg.branchhoverPen , m_theme, UKUITreeView, property, C_TreeView_BranchHoverPen);
|
|
m_readConfig->getColorValue(m_treeViewColorCfg.branchselectPen, m_theme, UKUITreeView, property, C_TreeView_BranchSelectPen);
|
|
|
|
return m_treeViewColorCfg;
|
|
}
|
|
|
|
UKUIColorTheme::SliderBarColorCfg ReadThemeConfig::sliderBarColorCfg(const QPalette palette, QString property)
|
|
{
|
|
if(!m_loadConfig)
|
|
return m_sliderBarColorCfg;
|
|
|
|
m_readConfig->widgetPalette(palette);
|
|
m_readConfig->getColorValue(m_sliderBarColorCfg.handleDefaultBrush , m_theme, UKUISliderBar, property, C_SliderBar_HandleDefaultBrush );
|
|
m_readConfig->getColorValue(m_sliderBarColorCfg.handleClickBrush , m_theme, UKUISliderBar, property, C_SliderBar_HandleClickBrush );
|
|
m_readConfig->getColorValue(m_sliderBarColorCfg.handleDisableBrush , m_theme, UKUISliderBar, property, C_SliderBar_HandleDisableBrush );
|
|
m_readConfig->getColorValue(m_sliderBarColorCfg.grooveValueDefaultBrush , m_theme, UKUISliderBar, property, C_SliderBar_GrooveValueDefaultBrush );
|
|
m_readConfig->getColorValue(m_sliderBarColorCfg.grooveValueHoverBrush , m_theme, UKUISliderBar, property, C_SliderBar_GrooveValueHoverBrush );
|
|
m_readConfig->getColorValue(m_sliderBarColorCfg.grooveValueDisableBrush , m_theme, UKUISliderBar, property, C_SliderBar_GrooveValueDisableBrush );
|
|
m_readConfig->getColorValue(m_sliderBarColorCfg.grooveUnvalueDefaultBrush, m_theme, UKUISliderBar, property, C_SliderBar_GrooveUnvalueDefaultBrush);
|
|
m_readConfig->getColorValue(m_sliderBarColorCfg.grooveUnvalueHoverBrush , m_theme, UKUISliderBar, property, C_SliderBar_GrooveUnvalueHoverBrush );
|
|
m_readConfig->getColorValue(m_sliderBarColorCfg.grooveUnvalueDisableBrush, m_theme, UKUISliderBar, property, C_SliderBar_GrooveUnvalueDisableBrush);
|
|
m_readConfig->getColorValue(m_sliderBarColorCfg.handleDefaultPen, m_theme, UKUISliderBar, property, C_SliderBar_HandleDefaultPen);
|
|
m_readConfig->getColorValue(m_sliderBarColorCfg.handleHoverPen , m_theme, UKUISliderBar, property, C_SliderBar_HandleHoverPen );
|
|
m_readConfig->getColorValue(m_sliderBarColorCfg.handleClickPen , m_theme, UKUISliderBar, property, C_SliderBar_HandleClickPen );
|
|
m_readConfig->getColorValue(m_sliderBarColorCfg.handleDisablePen, m_theme, UKUISliderBar, property, C_SliderBar_HandleDisablePen);
|
|
m_readConfig->getColorValue(m_sliderBarColorCfg.sliderGroovePen , m_theme, UKUISliderBar, property, C_SliderBar_SliderGroovePen );
|
|
m_readConfig->getColorValue(m_sliderBarColorCfg.focusPen , m_theme, UKUISliderBar, property, C_SliderBar_FocusPen);
|
|
|
|
|
|
m_sliderBarColorCfg.handleHoverType = m_readConfig->getType(m_theme, UKUISliderBar, property, C_SliderBar_HandleHoverBrush);
|
|
if(m_sliderBarColorCfg.handleHoverType == Obj_Gradient_Type){
|
|
m_sliderBarColorCfg.handleHoverGradientList.clear();
|
|
m_readConfig->getGradientValue(m_sliderBarColorCfg.handleHoverGradientList , m_theme, UKUISliderBar, property, C_SliderBar_HandleHoverBrush);
|
|
}
|
|
else {
|
|
m_readConfig->getColorValue(m_sliderBarColorCfg.handleHoverBrush, m_theme, UKUISliderBar, property, C_SliderBar_HandleHoverBrush);
|
|
}
|
|
|
|
return m_sliderBarColorCfg;
|
|
}
|
|
|
|
UKUIColorTheme::ProgressBarColorCfg ReadThemeConfig::progressBarColorCfg(const QPalette palette, QString property)
|
|
{
|
|
if(!m_loadConfig)
|
|
return m_progressBarColorCfg;
|
|
|
|
m_readConfig->widgetPalette(palette);
|
|
m_readConfig->getColorValue(m_progressBarColorCfg.contentStartColor , m_theme, UKUIProgressBar, property, C_ProgressBar_ContentStartColor );
|
|
m_readConfig->getColorValue(m_progressBarColorCfg.contentEndColor , m_theme, UKUIProgressBar, property, C_ProgressBar_ContentEndColor );
|
|
m_readConfig->getColorValue(m_progressBarColorCfg.contentBrush , m_theme, UKUIProgressBar, property, C_ProgressBar_ContentBrush );
|
|
m_readConfig->getColorValue(m_progressBarColorCfg.grooveDefaultBrush, m_theme, UKUIProgressBar, property, C_ProgressBar_GrooveDefaultBrush);
|
|
m_readConfig->getColorValue(m_progressBarColorCfg.grooveDisableBrush, m_theme, UKUIProgressBar, property, C_ProgressBar_GrooveDisableBrush);
|
|
|
|
m_readConfig->getColorValue(m_progressBarColorCfg.contentPen , m_theme, UKUIProgressBar, property, C_ProgressBar_ContentPen );
|
|
m_readConfig->getColorValue(m_progressBarColorCfg.grooveDefaultPen, m_theme, UKUIProgressBar, property, C_ProgressBar_GrooveDefaultPen);
|
|
m_readConfig->getColorValue(m_progressBarColorCfg.grooveDisablePen, m_theme, UKUIProgressBar, property, C_ProgressBar_GrooveDisablePen);
|
|
|
|
return m_progressBarColorCfg;
|
|
}
|
|
|
|
UKUIColorTheme::ToolTipColorCfg ReadThemeConfig::toolTipColorCfg(const QPalette palette, QString property)
|
|
{
|
|
if(!m_loadConfig)
|
|
return m_toolTipColorCfg;
|
|
|
|
m_readConfig->widgetPalette(palette);
|
|
m_readConfig->getColorValue(m_toolTipColorCfg.backgroundBrush, m_theme, UKUIToolTip, property, C_ToolTip_BackgroundBrush);
|
|
m_readConfig->getColorValue(m_toolTipColorCfg.backgroundPen, m_theme, UKUIToolTip, property, C_ToolTip_BackgroundPen);
|
|
return m_toolTipColorCfg;
|
|
}
|
|
|
|
UKUIColorTheme::ScrollBarColorCfg ReadThemeConfig::scrollBarColorCfg(const QPalette palette, QString property)
|
|
{
|
|
if(!m_loadConfig)
|
|
return m_scrollBarColorCfg;
|
|
|
|
m_readConfig->widgetPalette(palette);
|
|
m_readConfig->getColorValue(m_scrollBarColorCfg.grooveDefaultBrush , m_theme, UKUIScrollBar, property, C_ScrollBar_GrooveDefaultBrush );
|
|
m_readConfig->getColorValue(m_scrollBarColorCfg.grooveInactiveBrush, m_theme, UKUIScrollBar, property, C_ScrollBar_GrooveInactiveBrush );
|
|
m_readConfig->getColorValue(m_scrollBarColorCfg.sliderDefaultBrush , m_theme, UKUIScrollBar, property, C_ScrollBar_SliderDefaultBrush );
|
|
m_readConfig->getColorValue(m_scrollBarColorCfg.sliderClickBrush , m_theme, UKUIScrollBar, property, C_ScrollBar_SliderClickBrush );
|
|
m_readConfig->getColorValue(m_scrollBarColorCfg.sliderDisableBrush , m_theme, UKUIScrollBar, property, C_ScrollBar_SliderDisableBrush );
|
|
|
|
m_scrollBarColorCfg.sliderHoverType = m_readConfig->getType(m_theme, UKUIScrollBar, property, C_ScrollBar_SliderHoverBrush);
|
|
if(m_scrollBarColorCfg.sliderHoverType == Obj_Gradient_Type){
|
|
m_scrollBarColorCfg.sliderHoverGradientList.clear();
|
|
m_readConfig->getGradientValue(m_scrollBarColorCfg.sliderHoverGradientList , m_theme, UKUIScrollBar, property, C_ScrollBar_SliderHoverBrush);
|
|
}
|
|
else{
|
|
m_readConfig->getColorValue(m_scrollBarColorCfg.sliderHoverBrush, m_theme, UKUIScrollBar, property, C_ScrollBar_SliderHoverBrush);
|
|
}
|
|
return m_scrollBarColorCfg;
|
|
}
|
|
|
|
UKUIColorTheme::TabWidgetColorCfg ReadThemeConfig::tabWidgetColorCfg(const QPalette palette, QString property)
|
|
{
|
|
if(!m_loadConfig)
|
|
return m_tabWidgetColorCfg;
|
|
|
|
m_readConfig->widgetPalette(palette);
|
|
m_readConfig->getColorValue(m_tabWidgetColorCfg.widgetBackgroundBrush, m_theme, UKUITabWidget, property, C_TabWidget_WidgetBackgroundBrush);
|
|
m_readConfig->getColorValue(m_tabWidgetColorCfg.tabBarBackgroundBrush, m_theme, UKUITabWidget, property, C_TabWidget_TabBarBackgroundBrush);
|
|
m_readConfig->getColorValue(m_tabWidgetColorCfg.tabBarDefaultBrush , m_theme, UKUITabWidget, property, C_TabWidget_TabBarDefaultBrush );
|
|
m_readConfig->getColorValue(m_tabWidgetColorCfg.tabBarSelectBrush , m_theme, UKUITabWidget, property, C_TabWidget_TabBarSelectBrush );
|
|
m_readConfig->getColorValue(m_tabWidgetColorCfg.tabBarClickBrush , m_theme, UKUITabWidget, property, C_TabWidget_TabBarClickBrush );
|
|
m_readConfig->getColorValue(m_tabWidgetColorCfg.tabBarHoverPen , m_theme, UKUITabWidget, property, C_TabWidget_TabBarHoverPen );
|
|
m_readConfig->getColorValue(m_tabWidgetColorCfg.tabBarClickPen , m_theme, UKUITabWidget, property, C_TabWidget_TabBarClickPen );
|
|
m_readConfig->getColorValue(m_tabWidgetColorCfg.tabBarFocusPen , m_theme, UKUITabWidget, property, C_TabWidget_TabBarFocusPen );
|
|
|
|
m_tabWidgetColorCfg.tabBarHoverType = m_readConfig->getType(m_theme, UKUITabWidget, property, C_TabWidget_TabBarHoverBrush);
|
|
if(m_tabWidgetColorCfg.tabBarHoverType == Obj_Gradient_Type){
|
|
m_tabWidgetColorCfg.tabBarHoverGradientList.clear();
|
|
m_readConfig->getGradientValue(m_tabWidgetColorCfg.tabBarHoverGradientList , m_theme, UKUITabWidget, property, C_TabWidget_TabBarHoverBrush);
|
|
}
|
|
else{
|
|
m_readConfig->getColorValue(m_tabWidgetColorCfg.tabBarHoverBrush, m_theme, UKUITabWidget, property, C_TabWidget_TabBarHoverBrush);
|
|
}
|
|
|
|
return m_tabWidgetColorCfg;
|
|
}
|
|
|
|
UKUIColorTheme::MenuColorCfg ReadThemeConfig::menuColorCfg(const QPalette palette, QString property)
|
|
{
|
|
if(!m_loadConfig)
|
|
return m_menuColorCfg;
|
|
|
|
m_readConfig->widgetPalette(palette);
|
|
m_readConfig->getColorValue(m_menuColorCfg.menuBackgroundBrush, m_theme, UKUIMenu, property, C_Menu_MenuBackgroundBrush);
|
|
m_readConfig->getColorValue(m_menuColorCfg.menuBackgroundPen, m_theme, UKUIMenu, property, C_Menu_MenuBackgroundPen);
|
|
m_readConfig->getColorValue(m_menuColorCfg.menuItemSelectBrush, m_theme, UKUIMenu, property, C_Menu_MenuItemSelectBrush);
|
|
m_readConfig->getColorValue(m_menuColorCfg.menuItemFocusPen , m_theme, UKUIMenu, property, C_Menu_MenuItemFocusPen );
|
|
m_readConfig->getColorValue(m_menuColorCfg.menuTextHoverPen , m_theme, UKUIMenu, property, C_Menu_MenuTextHoverPen );
|
|
|
|
return m_menuColorCfg;
|
|
}
|
|
|
|
|
|
bool ReadThemeConfig::setRadius(QString key, int r)
|
|
{
|
|
if(!m_loadConfig)
|
|
return false;
|
|
m_readConfig->setValue(key, r);
|
|
}
|
|
|
|
void ReadThemeConfig::getRadius(QString key, int &r)
|
|
{
|
|
if(!m_loadConfig)
|
|
return;
|
|
QJsonObject obj = m_readConfig->getValue(UKUI_Radius, key).toJsonObject();
|
|
if (obj.isEmpty()) {
|
|
cWarning << "getRadius isempty!" << key;
|
|
return;
|
|
}
|
|
if (obj.value(Obj_Type) != Obj_Int_Type) {
|
|
cWarning << "get radius value type error!" << obj.value(Obj_Type).toString() << key;
|
|
return;
|
|
}
|
|
if(obj.value(Obj_Value).toString().isEmpty()){
|
|
cWarning << "obj" << Obj_Value << "key isempty!";
|
|
return;
|
|
}
|
|
r = QString(obj.value(Obj_Value).toString()).toInt();
|
|
return;
|
|
}
|
|
|
|
UKUIRadiusInformation::UKUIRadiusStruct ReadThemeConfig::getRadiusStruct(QString key)
|
|
{
|
|
if(!m_loadConfig)
|
|
return m_radiusStruct;
|
|
|
|
getRadius(Max_Radius, m_radiusStruct.maxRadius);
|
|
getRadius(Normal_Radius, m_radiusStruct.normalRadius);
|
|
getRadius(Min_Radius, m_radiusStruct.minRadius);
|
|
return m_radiusStruct;
|
|
}
|
|
|
|
QString ReadThemeConfig::getColorValueAdjustRules()
|
|
{
|
|
if(!m_loadConfig)
|
|
return "";
|
|
if(m_readConfig->getValue(ColorAdjustRules).toString().isEmpty())
|
|
return "";
|
|
return m_readConfig->getValue(ColorAdjustRules).toString();
|
|
}
|
|
|
|
|
|
/*
|
|
RadiusConfig::RadiusConfig(QString cfgPath):
|
|
m_cfgPath(cfgPath)
|
|
{
|
|
if (m_cfgPath.isEmpty()) {
|
|
QString path = UsrRadiusPath;
|
|
m_cfgPath = path + DefaultConfigName;
|
|
}
|
|
m_readConfig = new ReadConfig(m_cfgPath);
|
|
m_loadConfig = m_readConfig->load(m_cfgPath);
|
|
cDebug << "m_cfgPath:" << m_cfgPath << "m_loadConfig:" << m_loadConfig;
|
|
|
|
if(!m_loadConfig){
|
|
m_readConfig->deleteLater();
|
|
m_readConfig = nullptr;
|
|
}
|
|
}
|
|
|
|
RadiusConfig::~RadiusConfig()
|
|
{
|
|
|
|
}
|
|
|
|
bool RadiusConfig::setRadius(QString key, int r)
|
|
{
|
|
if(!m_loadConfig)
|
|
return false;
|
|
m_readConfig->setValue(key, r);
|
|
}
|
|
|
|
void RadiusConfig::getRadius(QString key, int &r)
|
|
{
|
|
if(!m_loadConfig)
|
|
return;
|
|
QJsonObject obj = m_readConfig->getValue(UKUI_Radius, key).toJsonObject();
|
|
if (obj.isEmpty()) {
|
|
cDebug << "getRadius isempty!" << key;
|
|
return;
|
|
}
|
|
if (obj.value(Obj_Type) != Obj_Int_Type) {
|
|
cDebug << "get radius value type error!" << obj.value(Obj_Type).toString() << key;
|
|
return;
|
|
}
|
|
if(obj.value(Obj_Value).toString().isEmpty()){
|
|
cDebug << "obj" << Obj_Value << "key isempty!";
|
|
return;
|
|
}
|
|
r = QString(obj.value(Obj_Value).toString()).toInt();
|
|
return;
|
|
}
|
|
*/
|