168492376
/
qskinny
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

QskSkinHintTableEditor introduced

This commit is contained in:
Uwe Rathmann 2020-12-26 12:57:08 +01:00
parent 9f2cb6920d
commit 5ecec7892e
15 changed files with 1130 additions and 956 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

71
examples/automotive/SkinFactory.cpp
View File

@ -18,6 +18,7 @@
#include <QskAnimationHint.h> #include <QskAnimationHint.h>
#include <QskSetup.h> #include <QskSetup.h>
#include <QskSkinTransition.h> #include <QskSkinTransition.h>
#include <QskSkinHintTableEditor.h>
#include <QskSkin.h> #include <QskSkin.h>
#include <QEasingCurve> #include <QEasingCurve>
@ -56,31 +57,33 @@ namespace
const QColor color4( "#E5E5E5" ); // Platinum const QColor color4( "#E5E5E5" ); // Platinum
const QColor color5( "#FFFFFF" ); // white const QColor color5( "#FFFFFF" ); // white
setColor( QskTextLabel::Text, color3 ); QskSkinHintTableEditor ed( &hintTable() );
ed.setColor( QskTextLabel::Text, color3 );
{ {
using Q = Speedometer; using Q = Speedometer;
setBoxBorderMetrics( Q::Panel, 5 ); ed.setBoxBorderMetrics( Q::Panel, 5 );
setBoxShape( Q::Panel, 30, Qt::RelativeSize ); ed.setBoxShape( Q::Panel, 30, Qt::RelativeSize );
setGradient( Q::Panel, ed.setGradient( Q::Panel,
QskGradient( QskGradient::Vertical, color2, color4 ) ); QskGradient( QskGradient::Vertical, color2, color4 ) );
setBoxBorderColors( Q::Panel, color3 ); ed.setBoxBorderColors( Q::Panel, color3 );
setBoxBorderMetrics( Q::Knob, 5 ); ed.setBoxBorderMetrics( Q::Knob, 5 );
setStrutSize( Q::Knob, 20, 20 ); ed.setStrutSize( Q::Knob, 20, 20 );
setBoxShape( Q::Knob, 100, Qt::RelativeSize ); ed.setBoxShape( Q::Knob, 100, Qt::RelativeSize );
setGradient( Q::Knob, color2 ); ed.setGradient( Q::Knob, color2 );
setBoxBorderColors( Q::Knob, color4 ); ed.setBoxBorderColors( Q::Knob, color4 );
setMetric( Q::Needle | QskAspect::Size, 4 ); ed.setMetric( Q::Needle | QskAspect::Size, 4 );
setMetric( Q::Needle | QskAspect::Margin, 15 ); ed.setMetric( Q::Needle | QskAspect::Margin, 15 );
setColor( Q::Needle, color4 ); ed.setColor( Q::Needle, color4 );
setSpacing( Q::TickLabels, 3 ); ed.setSpacing( Q::TickLabels, 3 );
setStrutSize( Q::TickLabels, 3, 25 ); ed.setStrutSize( Q::TickLabels, 3, 25 );
setColor( Q::TickLabels, color4 ); ed.setColor( Q::TickLabels, color4 );
setFontRole( Q::TickLabels, QskSkin::SmallFont ); ed.setFontRole( Q::TickLabels, QskSkin::SmallFont );
} }
{ {
@ -105,30 +108,32 @@ namespace
const QColor color4( "#FDFFFC" ); // baby powder const QColor color4( "#FDFFFC" ); // baby powder
const QColor color5( "#B91372" ); // red violet const QColor color5( "#B91372" ); // red violet
setColor( QskTextLabel::Text, color4 ); QskSkinHintTableEditor ed( &hintTable() );
ed.setColor( QskTextLabel::Text, color4 );
{ {
using Q = Speedometer; using Q = Speedometer;
setBoxBorderMetrics( Q::Panel, 2 ); ed.setBoxBorderMetrics( Q::Panel, 2 );
setBoxShape( Q::Panel, 100, Qt::RelativeSize ); ed.setBoxShape( Q::Panel, 100, Qt::RelativeSize );
setGradient( Q::Panel, color1 ); ed.setGradient( Q::Panel, color1 );
setBoxBorderColors( Q::Panel, color3 ); ed.setBoxBorderColors( Q::Panel, color3 );
setBoxBorderMetrics( Q::Knob, 2 ); ed.setBoxBorderMetrics( Q::Knob, 2 );
setStrutSize( Q::Knob, 30, 30 ); ed.setStrutSize( Q::Knob, 30, 30 );
setBoxShape( Q::Knob, 100, Qt::RelativeSize ); ed.setBoxShape( Q::Knob, 100, Qt::RelativeSize );
setGradient( Q::Knob, ed.setGradient( Q::Knob,
QskGradient( QskGradient::Diagonal, color2, color1 ) ); QskGradient( QskGradient::Diagonal, color2, color1 ) );
setMetric( Q::Needle | QskAspect::Size, 2 ); ed.setMetric( Q::Needle | QskAspect::Size, 2 );
setMetric( Q::Needle | QskAspect::Margin, 10 ); ed.setMetric( Q::Needle | QskAspect::Margin, 10 );
setColor( Q::Needle, color2 ); ed.setColor( Q::Needle, color2 );
setSpacing( Q::TickLabels, 4 ); ed.setSpacing( Q::TickLabels, 4 );
setStrutSize( Q::TickLabels, 2, 15 ); ed.setStrutSize( Q::TickLabels, 2, 15 );
setColor( Q::TickLabels, color4 ); ed.setColor( Q::TickLabels, color4 );
setFontRole( Q::TickLabels, QskSkin::SmallFont ); ed.setFontRole( Q::TickLabels, QskSkin::SmallFont );
} }
} }
}; };

30
examples/colorswitch/Theme.cpp
View File

@ -12,19 +12,8 @@
#include <QskSetup.h> #include <QskSetup.h>
#include <QskSkin.h> #include <QskSkin.h>
#include <QskSkinTransition.h> #include <QskSkinTransition.h>
#include <QskSkinHintTable.h>
static void qskResetColors( QskSkin* skin, const QColor& accent ) #include <QskSkinHintTableEditor.h>
{
skin->resetColors( accent );
/*
The current implementation of the skins is not that good
and we don't have support for customizing them by a minimal set
of attributes. So we do some manual extra work here
*/
skin->setColor( QskListView::CellSelected, accent.darker( 130 ) );
skin->setBoxBorderColors( QskFocusIndicator::Panel, accent.darker( 150 ) );
}
namespace namespace
{ {
@ -39,7 +28,18 @@ namespace
protected: protected:
void updateSkin( QskSkin*, QskSkin* newSkin ) override void updateSkin( QskSkin*, QskSkin* newSkin ) override
{ {
qskResetColors( newSkin, m_accent ); newSkin->resetColors( m_accent );
/*
The current implementation of the skins is not that good
and we don't have support for customizing them by a minimal set
of attributes. So we do some manual extra work here
*/
QskSkinHintTableEditor ed( &newSkin->hintTable() );
ed.setColor( QskListView::CellSelected, m_accent.darker( 130 ) );
ed.setBoxBorderColors( QskFocusIndicator::Panel, m_accent.darker( 150 ) );
} }
private: private:
@ -49,7 +49,7 @@ namespace
Theme::Theme( QObject* parent ) Theme::Theme( QObject* parent )
: QObject( parent ) : QObject( parent )
, m_accent( qskSetup->skin()->color( QskAspect::Color ) ) , m_accent( Qt::blue )
{ {
connect( qskSetup, &QskSetup::skinChanged, connect( qskSetup, &QskSetup::skinChanged,
this, [ this ]( QskSkin* ) { updateColors(); } ); this, [ this ]( QskSkin* ) { updateColors(); } );

74
examples/mycontrols/MySkin.cpp
View File

@ -9,6 +9,7 @@
#include "MyToggleButtonSkinlet.h" #include "MyToggleButtonSkinlet.h"
#include <QskSkin.h> #include <QskSkin.h>
#include <QskSkinHintTableEditor.h>
#include <QskAnimationHint.h> #include <QskAnimationHint.h>
#include <QskSetup.h> #include <QskSetup.h>
@ -40,13 +41,22 @@ class MySkin : public QskSkin
declareSkinlet< QskBox, QskBoxSkinlet >(); declareSkinlet< QskBox, QskBoxSkinlet >();
declareSkinlet< QskFocusIndicator, QskFocusIndicatorSkinlet >(); declareSkinlet< QskFocusIndicator, QskFocusIndicatorSkinlet >();
declareSkinlet< MyToggleButton, MyToggleButtonSkinlet >(); declareSkinlet< MyToggleButton, MyToggleButtonSkinlet >();
#if 1
setGradient( QskAspect::Control, Qt::gray );
#endif
} }
void initFocusIndicatorHints( protected:
void setGraphicFilter( int role, QRgb rgb )
{
QskColorFilter filter;
filter.addColorSubstitution( QskRgb::Khaki, rgb );
QskSkin::setGraphicFilter( role, filter );
}
};
class MySkinEditor : public QskSkinHintTableEditor
{
public:
void setupFocusIndicator(
qreal border, qreal radius, qreal padding, QRgb rgb ) qreal border, qreal radius, qreal padding, QRgb rgb )
{ {
const auto subControl = QskFocusIndicator::Panel; const auto subControl = QskFocusIndicator::Panel;
@ -59,7 +69,7 @@ class MySkin : public QskSkin
setBoxBorderColors( subControl, rgb ); setBoxBorderColors( subControl, rgb );
} }
void initBoxHints( void setupBox(
qreal border, qreal radius, qreal border, qreal radius,
const QskBoxBorderColors& borderColors, const QskBoxBorderColors& borderColors,
const QskGradient& fillColor ) const QskGradient& fillColor )
@ -73,7 +83,7 @@ class MySkin : public QskSkin
setPadding( subControl, 0.5 * radius ); setPadding( subControl, 0.5 * radius );
} }
void initToggleButtonHints( void setupToggleButton(
bool raised, qreal width, qreal height, qreal radius, bool raised, qreal width, qreal height, qreal radius,
QRgb baseColor, QRgb baseTextColor, QRgb baseColor, QRgb baseTextColor,
QRgb foregroundColor, QRgb foregroundTextColor ) QRgb foregroundColor, QRgb foregroundTextColor )
@ -154,17 +164,19 @@ class MySkin : public QskSkin
setAnimation( Q::Cursor | A::Metric, animator() ); setAnimation( Q::Cursor | A::Metric, animator() );
} }
void setGraphicFilter( int role, QRgb rgb ) void setAnimator( uint duration, QEasingCurve::Type type )
{ {
QskColorFilter filter; m_animationHint.duration = duration;
filter.addColorSubstitution( QskRgb::Khaki, rgb ); m_animationHint.type = type;
}
QskSkin::setGraphicFilter( role, filter ); QskAnimationHint animator() const
{
return m_animationHint;
} }
private: private:
QskAnimationHint m_animationHint;
virtual QskAnimationHint animator() const = 0;
}; };
class MySkin1 : public MySkin class MySkin1 : public MySkin
@ -177,15 +189,17 @@ class MySkin1 : public MySkin
setGraphicFilter( GraphicRoleNormal, Crimson ); setGraphicFilter( GraphicRoleNormal, Crimson );
setGraphicFilter( GraphicRoleInverted, Gold ); setGraphicFilter( GraphicRoleInverted, Gold );
initFocusIndicatorHints( 2, 3, 6, DarkBlue ); MySkinEditor editor;
initBoxHints( 2, 8, DarkCyan, LightCyan ); editor.setTable( &hintTable() );
initToggleButtonHints( false, 150, 120, 6, editor.setAnimator( 200, QEasingCurve::Linear );
AliceBlue, Black, CornflowerBlue, White );
}
QskAnimationHint animator() const override editor.setGradient( QskAspect::Control, Qt::gray );
{
return QskAnimationHint( 200, QEasingCurve::Linear ); editor.setupFocusIndicator( 2, 3, 6, DarkBlue );
editor.setupBox( 2, 8, DarkCyan, LightCyan );
editor.setupToggleButton( false, 150, 120, 6,
AliceBlue, Black, CornflowerBlue, White );
} }
}; };
@ -199,15 +213,17 @@ class MySkin2 : public MySkin
setGraphicFilter( GraphicRoleNormal, HotPink ); setGraphicFilter( GraphicRoleNormal, HotPink );
setGraphicFilter( GraphicRoleInverted, White ); setGraphicFilter( GraphicRoleInverted, White );
initFocusIndicatorHints( 2, 6, 6, Crimson ); MySkinEditor editor;
initBoxHints( 4, 30, LightPink, MistyRose ); editor.setTable( &hintTable() );
initToggleButtonHints( true, 130, 100, 40, editor.setAnimator( 100, QEasingCurve::InQuad );
LightPink, Black, HotPink, White );
}
QskAnimationHint animator() const override editor.setGradient( QskAspect::Control, Qt::gray );
{
return QskAnimationHint( 100, QEasingCurve::InQuad ); editor.setupFocusIndicator( 2, 6, 6, Crimson );
editor.setupBox( 4, 30, LightPink, MistyRose );
editor.setupToggleButton( true, 130, 100, 40,
LightPink, Black, HotPink, White );
} }
}; };

346
skins/material/QskMaterialSkin.cpp
View File

@ -5,6 +5,8 @@
#include "QskMaterialSkin.h" #include "QskMaterialSkin.h"
#include <QskSkinHintTableEditor.h>
#include <QskBox.h> #include <QskBox.h>
#include <QskDialogButton.h> #include <QskDialogButton.h>
#include <QskDialogButtonBox.h> #include <QskDialogButtonBox.h>
@ -25,8 +27,6 @@
#include <QskTextLabel.h> #include <QskTextLabel.h>
#include <QskVirtualKeyboard.h> #include <QskVirtualKeyboard.h>
#include <QskSkinlet.h>
#include <QskAnimationHint.h> #include <QskAnimationHint.h>
#include <QskAspect.h> #include <QskAspect.h>
#include <QskBoxBorderColors.h> #include <QskBoxBorderColors.h>
@ -93,153 +93,144 @@ namespace
QColor textColor; QColor textColor;
}; };
}
class QskMaterialSkin::PrivateData class Editor : private QskSkinHintTableEditor
{ {
public: public:
ColorPalette palette; Editor( QskSkinHintTable* table, const ColorPalette& palette )
: QskSkinHintTableEditor( table )
, m_pal( palette )
{
}
void setup();
private:
void setupControl();
void setupBox();
void setupDialogButtonBox();
void setupDialogButton();
void setupFocusIndicator();
void setupInputPanel();
void setupVirtualKeyboard();
void setupListView();
void setupPageIndicator();
void setupPopup();
void setupProgressBar();
void setupPushButton();
void setupScrollView();
void setupSeparator();
void setupSubWindow();
void setupSlider();
void setupTabButton();
void setupTabBar();
void setupTabView();
void setupTextInput();
void setupTextLabel();
const ColorPalette& m_pal;
}; };
QskMaterialSkin::QskMaterialSkin( QObject* parent )
: Inherited( parent )
, m_data( new PrivateData() )
{
m_data->palette = ColorPalette( QskRgb::Grey100,
QskRgb::Blue500, QskRgb::White );
// Default theme colors
setupFonts( "Roboto" );
auto buttonFont = font( QskSkin::DefaultFont );
buttonFont.setCapitalization( QFont::AllUppercase );
setFont( ButtonFontRole, buttonFont );
initHints();
} }
QskMaterialSkin::~QskMaterialSkin() void Editor::setup()
{ {
setupControl();
setupBox();
setupDialogButtonBox();
setupDialogButton();
setupFocusIndicator();
setupInputPanel();
setupVirtualKeyboard();
setupListView();
setupPageIndicator();
setupPopup();
setupProgressBar();
setupPushButton();
setupScrollView();
setupSeparator();
setupSlider();
setupSubWindow();
setupTabButton();
setupTabBar();
setupTabView();
setupTextLabel();
setupTextInput();
} }
void QskMaterialSkin::initHints() void Editor::setupControl()
{
initCommonHints();
initBoxHints();
initDialogButtonBoxHints();
initDialogButtonHints();
initFocusIndicatorHints();
initInputPanelHints();
initVirtualKeyboardHints();
initListViewHints();
initPageIndicatorHints();
initPopupHints();
initProgressBarHints();
initPushButtonHints();
initScrollViewHints();
initSeparatorHints();
initSliderHints();
initSubWindowHints();
initTabButtonHints();
initTabBarHints();
initTabViewHints();
initTextLabelHints();
initTextInputHints();
}
void QskMaterialSkin::resetColors( const QColor& accent )
{
m_data->palette = ColorPalette( m_data->palette.baseColor,
accent, m_data->palette.contrastColor );
initHints();
}
void QskMaterialSkin::initCommonHints()
{ {
using A = QskAspect; using A = QskAspect;
using Q = QskControl; using Q = QskControl;
const auto& pal = m_data->palette;
setPadding( A::Control, 4 ); setPadding( A::Control, 4 );
setGradient( A::Control, pal.baseColor ); setGradient( A::Control, m_pal.baseColor );
setColor( A::Control | A::StyleColor, pal.textColor ); setColor( A::Control | A::StyleColor, m_pal.textColor );
setColor( A::Control | A::StyleColor | Q::Disabled, setColor( A::Control | A::StyleColor | Q::Disabled,
qskShadedColor( m_data->palette.textColor, 0.6 ) ); qskShadedColor( m_pal.textColor, 0.6 ) );
} }
void QskMaterialSkin::initBoxHints() void Editor::setupBox()
{ {
using Q = QskBox; using Q = QskBox;
const auto& pal = m_data->palette; setGradient( Q::Panel, m_pal.baseColor );
setGradient( Q::Panel, pal.baseColor );
setBoxShape( Q::Panel, 4 ); setBoxShape( Q::Panel, 4 );
setBoxBorderMetrics( Q::Panel, 0 ); setBoxBorderMetrics( Q::Panel, 0 );
} }
void QskMaterialSkin::initPopupHints() void Editor::setupPopup()
{ {
using A = QskAspect; using A = QskAspect;
using Q = QskPopup; using Q = QskPopup;
const auto& pal = m_data->palette; setFlagHint( Q::Overlay | A::Style, true );
setSkinHint( Q::Overlay | A::Style, true );
const QskGradient gradient( QskGradient::Vertical, const QskGradient gradient( QskGradient::Vertical,
qskShadedColor( pal.accentColor, 0.45 ), qskShadedColor( pal.accentColor, 0.7 ) ); qskShadedColor( m_pal.accentColor, 0.45 ), qskShadedColor( m_pal.accentColor, 0.7 ) );
setGradient( Q::Overlay, gradient ); setGradient( Q::Overlay, gradient );
} }
void QskMaterialSkin::initTextLabelHints() void Editor::setupTextLabel()
{ {
using Q = QskTextLabel; using Q = QskTextLabel;
const auto& pal = m_data->palette;
setAlignment( Q::Text, Qt::AlignCenter ); setAlignment( Q::Text, Qt::AlignCenter );
setColor( Q::Text, pal.textColor ); setColor( Q::Text, m_pal.textColor );
setPadding( Q::Panel, 5 ); setPadding( Q::Panel, 5 );
setBoxShape( Q::Panel, 4 ); setBoxShape( Q::Panel, 4 );
setBoxBorderMetrics( Q::Panel, 2 ); setBoxBorderMetrics( Q::Panel, 2 );
setBoxBorderColors( Q::Panel, pal.darker125 ); setBoxBorderColors( Q::Panel, m_pal.darker125 );
setGradient( Q::Panel, pal.baseColor ); setGradient( Q::Panel, m_pal.baseColor );
} }
void QskMaterialSkin::initTextInputHints() void Editor::setupTextInput()
{ {
using Q = QskTextInput; using Q = QskTextInput;
setAlignment( Q::Text, Qt::AlignLeft | Qt::AlignTop ); setAlignment( Q::Text, Qt::AlignLeft | Qt::AlignTop );
const auto& pal = m_data->palette; setColor( Q::Text, m_pal.textColor );
setColor( Q::PanelSelected, m_pal.accentColor );
setColor( Q::Text, pal.textColor ); setColor( Q::TextSelected, m_pal.contrastColor );
setColor( Q::PanelSelected, pal.accentColor );
setColor( Q::TextSelected, pal.contrastColor );
setPadding( Q::Panel, 5 ); setPadding( Q::Panel, 5 );
setBoxShape( Q::Panel, 4 ); setBoxShape( Q::Panel, 4 );
setBoxBorderMetrics( Q::Panel, 2 ); setBoxBorderMetrics( Q::Panel, 2 );
setBoxBorderColors( Q::Panel, pal.darker125 ); setBoxBorderColors( Q::Panel, m_pal.darker125 );
setGradient( Q::Panel, pal.baseColor ); setGradient( Q::Panel, m_pal.baseColor );
} }
void QskMaterialSkin::initProgressBarHints() void Editor::setupProgressBar()
{ {
using A = QskAspect; using A = QskAspect;
using namespace QskRgb; using namespace QskRgb;
using Q = QskProgressBar; using Q = QskProgressBar;
const auto& pal = m_data->palette;
for ( auto subControl : { Q::Groove, Q::Bar } ) for ( auto subControl : { Q::Groove, Q::Bar } )
{ {
setMetric( subControl | A::Size, 5 ); setMetric( subControl | A::Size, 5 );
@ -251,29 +242,25 @@ void QskMaterialSkin::initProgressBarHints()
setGradient( Q::Groove, Grey ); setGradient( Q::Groove, Grey );
setMetric( Q::Groove | A::Size, 5 ); setMetric( Q::Groove | A::Size, 5 );
setGradient( Q::Bar, pal.accentColor ); setGradient( Q::Bar, m_pal.accentColor );
} }
void QskMaterialSkin::initFocusIndicatorHints() void Editor::setupFocusIndicator()
{ {
using Q = QskFocusIndicator; using Q = QskFocusIndicator;
const auto& pal = m_data->palette;
setPadding( Q::Panel, 5 ); setPadding( Q::Panel, 5 );
setBoxShape( Q::Panel, 4 ); setBoxShape( Q::Panel, 4 );
setBoxBorderMetrics( Q::Panel, 2 ); setBoxBorderMetrics( Q::Panel, 2 );
setBoxBorderColors( Q::Panel, pal.accentColor ); setBoxBorderColors( Q::Panel, m_pal.accentColor );
setGradient( Q::Panel, QskGradient() ); setGradient( Q::Panel, QskGradient() );
} }
void QskMaterialSkin::initSeparatorHints() void Editor::setupSeparator()
{ {
using A = QskAspect; using A = QskAspect;
using Q = QskSeparator; using Q = QskSeparator;
const auto& pal = m_data->palette;
for ( auto placement : { A::Horizontal, A::Vertical } ) for ( auto placement : { A::Horizontal, A::Vertical } )
{ {
const auto aspect = Q::Panel | placement; const auto aspect = Q::Panel | placement;
@ -281,16 +268,14 @@ void QskMaterialSkin::initSeparatorHints()
setMetric( aspect | A::Size, 4 ); setMetric( aspect | A::Size, 4 );
setBoxShape( Q::Panel, 0 ); setBoxShape( Q::Panel, 0 );
setBoxBorderMetrics( Q::Panel, 0 ); setBoxBorderMetrics( Q::Panel, 0 );
setGradient( aspect, pal.baseColor ); setGradient( aspect, m_pal.baseColor );
} }
} }
void QskMaterialSkin::initPageIndicatorHints() void Editor::setupPageIndicator()
{ {
using Q = QskPageIndicator; using Q = QskPageIndicator;
const auto& pal = m_data->palette;
for ( auto subControl : { Q::Bullet, Q::Highlighted } ) for ( auto subControl : { Q::Bullet, Q::Highlighted } )
{ {
const auto extent = qskDpiScaled( 10 ); const auto extent = qskDpiScaled( 10 );
@ -301,7 +286,7 @@ void QskMaterialSkin::initPageIndicatorHints()
setBoxBorderMetrics( subControl, 0 ); setBoxBorderMetrics( subControl, 0 );
const QColor color = ( subControl == Q::Bullet ) const QColor color = ( subControl == Q::Bullet )
? pal.lighter150 : pal.accentColor; ? m_pal.lighter150 : m_pal.accentColor;
setGradient( subControl, color ); setGradient( subControl, color );
setBoxBorderColors( subControl, color ); setBoxBorderColors( subControl, color );
@ -314,14 +299,12 @@ void QskMaterialSkin::initPageIndicatorHints()
setSpacing( Q::Panel, 3 ); setSpacing( Q::Panel, 3 );
} }
void QskMaterialSkin::initPushButtonHints() void Editor::setupPushButton()
{ {
using A = QskAspect; using A = QskAspect;
using namespace QskRgb; using namespace QskRgb;
using Q = QskPushButton; using Q = QskPushButton;
const auto& pal = m_data->palette;
setStrutSize( Q::Panel, qskDpiScaled( 75.0 ), qskDpiScaled( 23.0 ) ); setStrutSize( Q::Panel, qskDpiScaled( 75.0 ), qskDpiScaled( 23.0 ) );
setSpacing( Q::Panel, 4 ); setSpacing( Q::Panel, 4 );
@ -343,8 +326,8 @@ void QskMaterialSkin::initPushButtonHints()
setGradient( Q::Panel, White ); setGradient( Q::Panel, White );
setGradient( Q::Panel | Q::Flat, White & ColorMask ); setGradient( Q::Panel | Q::Flat, White & ColorMask );
setColor( Q::Text, pal.textColor ); setColor( Q::Text, m_pal.textColor );
setColor( Q::Text | Q::Disabled, qskShadedColor( pal.textColor, 0.6 ) ); setColor( Q::Text | Q::Disabled, qskShadedColor( m_pal.textColor, 0.6 ) );
setFontRole( Q::Text, ButtonFontRole ); setFontRole( Q::Text, ButtonFontRole );
setAlignment( Q::Text, Qt::AlignCenter ); setAlignment( Q::Text, Qt::AlignCenter );
@ -359,10 +342,10 @@ void QskMaterialSkin::initPushButtonHints()
{ {
const auto states = state1 | state2 | state3; const auto states = state1 | state2 | state3;
setGradient( Q::Panel | states, pal.accentColor ); setGradient( Q::Panel | states, m_pal.accentColor );
setColor( Q::Text | states, White ); setColor( Q::Text | states, White );
setGradient( Q::Panel | Q::Flat | states, pal.accentColor ); setGradient( Q::Panel | Q::Flat | states, m_pal.accentColor );
setColor( Q::Text | Q::Flat | states, White ); setColor( Q::Text | Q::Flat | states, White );
} }
} }
@ -373,14 +356,12 @@ void QskMaterialSkin::initPushButtonHints()
setAnimation( Q::Text | A::Color, qskDuration ); setAnimation( Q::Text | A::Color, qskDuration );
} }
void QskMaterialSkin::initDialogButtonHints() void Editor::setupDialogButton()
{ {
using A = QskAspect; using A = QskAspect;
using namespace QskRgb; using namespace QskRgb;
using Q = QskDialogButton; using Q = QskDialogButton;
const auto& pal = m_data->palette;
setStrutSize( Q::Panel, 30, 16 ); setStrutSize( Q::Panel, 30, 16 );
setSpacing( Q::Panel, 4 ); setSpacing( Q::Panel, 4 );
@ -397,8 +378,8 @@ void QskMaterialSkin::initDialogButtonHints()
setBoxBorderColors( Q::Panel, noBorderColors ); setBoxBorderColors( Q::Panel, noBorderColors );
setGradient( Q::Panel, White ); setGradient( Q::Panel, White );
setColor( Q::Text, pal.textColor ); setColor( Q::Text, m_pal.textColor );
setColor( Q::Text | Q::Disabled, qskShadedColor( pal.textColor, 0.6 ) ); setColor( Q::Text | Q::Disabled, qskShadedColor( m_pal.textColor, 0.6 ) );
setFontRole( Q::Text, ButtonFontRole ); setFontRole( Q::Text, ButtonFontRole );
setAlignment( Q::Text, Qt::AlignCenter ); setAlignment( Q::Text, Qt::AlignCenter );
@ -412,7 +393,7 @@ void QskMaterialSkin::initDialogButtonHints()
{ {
const auto states = state1 | state2 | state3; const auto states = state1 | state2 | state3;
setGradient( Q::Panel | states, pal.accentColor ); setGradient( Q::Panel | states, m_pal.accentColor );
setColor( Q::Text | states, White ); setColor( Q::Text | states, White );
} }
} }
@ -423,25 +404,21 @@ void QskMaterialSkin::initDialogButtonHints()
setAnimation( Q::Text | A::Color, qskDuration ); setAnimation( Q::Text | A::Color, qskDuration );
} }
void QskMaterialSkin::initDialogButtonBoxHints() void Editor::setupDialogButtonBox()
{ {
using Q = QskDialogButtonBox; using Q = QskDialogButtonBox;
const auto& pal = m_data->palette; setGradient( Q::Panel, m_pal.baseColor );
setGradient( Q::Panel, pal.baseColor );
setBoxShape( Q::Panel, 0 ); setBoxShape( Q::Panel, 0 );
setBoxBorderMetrics( Q::Panel, 0 ); setBoxBorderMetrics( Q::Panel, 0 );
} }
void QskMaterialSkin::initSliderHints() void Editor::setupSlider()
{ {
using A = QskAspect; using A = QskAspect;
using namespace QskRgb; using namespace QskRgb;
using Q = QskSlider; using Q = QskSlider;
const auto& pal = m_data->palette;
const qreal extent = 30; const qreal extent = 30;
// Panel // Panel
@ -467,8 +444,8 @@ void QskMaterialSkin::initSliderHints()
setGradient( Q::Groove, Grey ); setGradient( Q::Groove, Grey );
setGradient( Q::Fill, pal.accentColor ); setGradient( Q::Fill, m_pal.accentColor );
setBoxBorderColors( Q::Fill, pal.accentColor ); setBoxBorderColors( Q::Fill, m_pal.accentColor );
// handle // handle
@ -483,12 +460,12 @@ void QskMaterialSkin::initSliderHints()
setGradient( Q::Handle | Q::Disabled, Grey ); setGradient( Q::Handle | Q::Disabled, Grey );
setBoxBorderColors( Q::Handle | Q::Disabled, Grey ); setBoxBorderColors( Q::Handle | Q::Disabled, Grey );
setGradient( Q::Handle, pal.accentColor ); setGradient( Q::Handle, m_pal.accentColor );
setGradient( Q::Handle | Q::Pressed, pal.accentColor ); setGradient( Q::Handle | Q::Pressed, m_pal.accentColor );
for ( auto state : { A::NoState, Q::Pressed, Q::Pressed | Q::Hovered } ) for ( auto state : { A::NoState, Q::Pressed, Q::Pressed | Q::Hovered } )
{ {
setBoxBorderColors( Q::Handle | state, pal.accentColor ); setBoxBorderColors( Q::Handle | state, m_pal.accentColor );
} }
for ( auto state : { A::NoState, Q::Pressed, Q::Pressed | Q::Hovered } ) for ( auto state : { A::NoState, Q::Pressed, Q::Pressed | Q::Hovered } )
@ -506,13 +483,11 @@ void QskMaterialSkin::initSliderHints()
setAnimation( Q::Handle | A::Metric | A::Position | Q::Pressed, 0 ); setAnimation( Q::Handle | A::Metric | A::Position | Q::Pressed, 0 );
} }
void QskMaterialSkin::initTabButtonHints() void Editor::setupTabButton()
{ {
using A = QskAspect; using A = QskAspect;
using Q = QskTabButton; using Q = QskTabButton;
const auto& pal = m_data->palette;
setStrutSize( Q::Panel, 30, 16 ); setStrutSize( Q::Panel, 30, 16 );
for ( const auto placement : { A::Left, A::Right, A::Top, A::Bottom } ) for ( const auto placement : { A::Left, A::Right, A::Top, A::Bottom } )
@ -555,7 +530,7 @@ void QskMaterialSkin::initTabButtonHints()
QskBoxBorderColors borderColors( QskRgb::White ); QskBoxBorderColors borderColors( QskRgb::White );
setBoxBorderColors( aspect, borderColors ); setBoxBorderColors( aspect, borderColors );
borderColors.setColorsAt( edge, pal.accentColor ); borderColors.setColorsAt( edge, m_pal.accentColor );
for ( auto state : { Q::Checked, Q::Pressed, Q::Checkable | Q::Hovered } ) for ( auto state : { Q::Checked, Q::Pressed, Q::Checkable | Q::Hovered } )
setBoxBorderColors( aspect | state, borderColors ); setBoxBorderColors( aspect | state, borderColors );
} }
@ -566,12 +541,12 @@ void QskMaterialSkin::initTabButtonHints()
setFontRole( Q::Text, ButtonFontRole ); setFontRole( Q::Text, ButtonFontRole );
setAlignment( Q::Text, Qt::AlignCenter ); setAlignment( Q::Text, Qt::AlignCenter );
setColor( Q::Text, pal.textColor ); setColor( Q::Text, m_pal.textColor );
setColor( Q::Text | Q::Checkable | Q::Disabled, qskShadedColor( pal.textColor, 0.6 ) ); setColor( Q::Text | Q::Checkable | Q::Disabled, qskShadedColor( m_pal.textColor, 0.6 ) );
setColor( Q::Text | Q::Disabled, QskRgb::Grey600 ); setColor( Q::Text | Q::Disabled, QskRgb::Grey600 );
} }
void QskMaterialSkin::initTabBarHints() void Editor::setupTabBar()
{ {
using A = QskAspect; using A = QskAspect;
using Q = QskTabBar; using Q = QskTabBar;
@ -584,50 +559,44 @@ void QskMaterialSkin::initTabBarHints()
setAnimation( Q::Panel | A::Metric, QskAnimationHint( 200, QEasingCurve::InCubic ) ); setAnimation( Q::Panel | A::Metric, QskAnimationHint( 200, QEasingCurve::InCubic ) );
} }
void QskMaterialSkin::initTabViewHints() void Editor::setupTabView()
{ {
using Q = QskTabView; using Q = QskTabView;
const auto& pal = m_data->palette;
setBoxShape( Q::Page, 0 ); setBoxShape( Q::Page, 0 );
setBoxBorderMetrics( Q::Page, 0 ); setBoxBorderMetrics( Q::Page, 0 );
setGradient( Q::Page, pal.darker150 ); setGradient( Q::Page, m_pal.darker150 );
setBoxBorderColors( Q::Page, pal.baseColor ); setBoxBorderColors( Q::Page, m_pal.baseColor );
setAnimation( Q::Page, qskDuration ); setAnimation( Q::Page, qskDuration );
} }
void QskMaterialSkin::initInputPanelHints() void Editor::setupInputPanel()
{ {
using Q = QskInputPanelBox; using Q = QskInputPanelBox;
const auto& pal = m_data->palette;
setBoxShape( Q::Panel, 0 ); setBoxShape( Q::Panel, 0 );
setBoxBorderMetrics( Q::Panel, 0 ); setBoxBorderMetrics( Q::Panel, 0 );
setGradient( Q::Panel, pal.darker150 ); setGradient( Q::Panel, m_pal.darker150 );
setBoxBorderColors( Q::Panel, pal.baseColor ); setBoxBorderColors( Q::Panel, m_pal.baseColor );
} }
void QskMaterialSkin::initVirtualKeyboardHints() void Editor::setupVirtualKeyboard()
{ {
using A = QskAspect; using A = QskAspect;
using Q = QskVirtualKeyboard; using Q = QskVirtualKeyboard;
const auto& pal = m_data->palette;
// key panel // key panel
setMargin( Q::ButtonPanel, 2 ); setMargin( Q::ButtonPanel, 2 );
setBoxShape( Q::ButtonPanel, 20.0, Qt::RelativeSize ); setBoxShape( Q::ButtonPanel, 20.0, Qt::RelativeSize );
setBoxBorderMetrics( Q::ButtonPanel, 2 ); setBoxBorderMetrics( Q::ButtonPanel, 2 );
setGradient( Q::ButtonPanel, pal.darker125 ); setGradient( Q::ButtonPanel, m_pal.darker125 );
setBoxBorderColors( Q::ButtonPanel, pal.baseColor ); setBoxBorderColors( Q::ButtonPanel, m_pal.baseColor );
for ( auto state : { A::NoState, Q::Focused } ) for ( auto state : { A::NoState, Q::Focused } )
setBoxBorderColors( Q::ButtonPanel | QskPushButton::Pressed | state, pal.accentColor ); setBoxBorderColors( Q::ButtonPanel | QskPushButton::Pressed | state, m_pal.accentColor );
setAnimation( Q::ButtonPanel | A::Color, qskDuration ); setAnimation( Q::ButtonPanel | A::Color, qskDuration );
setAnimation( Q::ButtonPanel | A::Metric, qskDuration ); setAnimation( Q::ButtonPanel | A::Metric, qskDuration );
@ -635,17 +604,15 @@ void QskMaterialSkin::initVirtualKeyboardHints()
// panel // panel
setBoxShape( Q::Panel, 0 ); setBoxShape( Q::Panel, 0 );
setBoxBorderMetrics( Q::Panel, 0 ); setBoxBorderMetrics( Q::Panel, 0 );
setGradient( Q::Panel, pal.darker150 ); setGradient( Q::Panel, m_pal.darker150 );
setBoxBorderColors( Q::Panel, pal.baseColor ); setBoxBorderColors( Q::Panel, m_pal.baseColor );
} }
void QskMaterialSkin::initScrollViewHints() void Editor::setupScrollView()
{ {
using A = QskAspect; using A = QskAspect;
using Q = QskScrollView; using Q = QskScrollView;
const auto& pal = m_data->palette;
setSpacing( Q::Panel, 2 ); setSpacing( Q::Panel, 2 );
setBoxShape( Q::Viewport, 5 ); setBoxShape( Q::Viewport, 5 );
@ -667,7 +634,7 @@ void QskMaterialSkin::initScrollViewHints()
{ {
setBoxShape( subControl, 3 ); setBoxShape( subControl, 3 );
setBoxBorderMetrics( subControl, 1 ); setBoxBorderMetrics( subControl, 1 );
setGradient( subControl, pal.accentColor ); setGradient( subControl, m_pal.accentColor );
setBoxBorderColors( subControl, QskRgb::White ); setBoxBorderColors( subControl, QskRgb::White );
setAnimation( subControl | A::Color, qskDuration ); setAnimation( subControl | A::Color, qskDuration );
@ -677,54 +644,50 @@ void QskMaterialSkin::initScrollViewHints()
Q::HorizontalScrollHandle | Q::HorizontalHandlePressed, Q::HorizontalScrollHandle | Q::HorizontalHandlePressed,
Q::VerticalScrollHandle | Q::VerticalHandlePressed } ) Q::VerticalScrollHandle | Q::VerticalHandlePressed } )
{ {
setGradient( subControl, pal.accentColor ); setGradient( subControl, m_pal.accentColor );
setBoxBorderColors( subControl, pal.accentColor ); setBoxBorderColors( subControl, m_pal.accentColor );
} }
// when changing the position by QskScrollView::scrollTo // when changing the position by QskScrollView::scrollTo
setAnimation( Q::Viewport | A::Metric, QskAnimationHint( 200, QEasingCurve::InCubic ) ); setAnimation( Q::Viewport | A::Metric, QskAnimationHint( 200, QEasingCurve::InCubic ) );
} }
void QskMaterialSkin::initListViewHints() void Editor::setupListView()
{ {
using Q = QskListView; using Q = QskListView;
const auto& pal = m_data->palette;
// padding for each cell // padding for each cell
setPadding( Q::Cell, QskMargins( 4, 8 ) ); setPadding( Q::Cell, QskMargins( 4, 8 ) );
setColor( Q::Cell, pal.baseColor ); setColor( Q::Cell, m_pal.baseColor );
setColor( Q::Text, pal.textColor ); setColor( Q::Text, m_pal.textColor );
setColor( Q::CellSelected, pal.accentColor ); setColor( Q::CellSelected, m_pal.accentColor );
setColor( Q::TextSelected, pal.contrastColor ); setColor( Q::TextSelected, m_pal.contrastColor );
} }
void QskMaterialSkin::initSubWindowHints() void Editor::setupSubWindow()
{ {
using A = QskAspect; using A = QskAspect;
using Q = QskSubWindow; using Q = QskSubWindow;
const auto& pal = m_data->palette;
// Panel // Panel
setSkinHint( Q::Panel | A::Decoration, true ); setFlagHint( Q::Panel | A::Decoration, true );
setPadding( Q::Panel, 10 ); setPadding( Q::Panel, 10 );
setBoxShape( Q::Panel, 0 ); setBoxShape( Q::Panel, 0 );
setBoxBorderMetrics( Q::Panel, 2 ); setBoxBorderMetrics( Q::Panel, 2 );
setGradient( Q::Panel, pal.baseColor ); setGradient( Q::Panel, m_pal.baseColor );
QskBoxBorderColors colors; QskBoxBorderColors colors;
colors.setColorsAt( Qt::TopEdge | Qt::LeftEdge, pal.lighter125 ); colors.setColorsAt( Qt::TopEdge | Qt::LeftEdge, m_pal.lighter125 );
colors.setColorsAt( Qt::RightEdge | Qt::BottomEdge, pal.darker200 ); colors.setColorsAt( Qt::RightEdge | Qt::BottomEdge, m_pal.darker200 );
setBoxBorderColors( Q::Panel, colors ); setBoxBorderColors( Q::Panel, colors );
// TitleBar // TitleBar
setGradient( Q::TitleBar, pal.darker200 ); setGradient( Q::TitleBar, m_pal.darker200 );
setGradient( Q::TitleBar | Q::Focused, pal.accentColor ); setGradient( Q::TitleBar | Q::Focused, m_pal.accentColor );
// TitleBarText // TitleBarText
setFontRole( Q::TitleBarText, QskSkin::SmallFont ); setFontRole( Q::TitleBarText, QskSkin::SmallFont );
@ -735,4 +698,41 @@ void QskMaterialSkin::initSubWindowHints()
} }
class QskMaterialSkin::PrivateData
{
public:
ColorPalette palette;
};
QskMaterialSkin::QskMaterialSkin( QObject* parent )
: Inherited( parent )
, m_data( new PrivateData() )
{
m_data->palette = ColorPalette( QskRgb::Grey100,
QskRgb::Blue500, QskRgb::White );
// Default theme colors
setupFonts( "Roboto" );
auto buttonFont = font( QskSkin::DefaultFont );
buttonFont.setCapitalization( QFont::AllUppercase );
setFont( ButtonFontRole, buttonFont );
Editor editor( &hintTable(), m_data->palette );
editor.setup();
}
QskMaterialSkin::~QskMaterialSkin()
{
}
void QskMaterialSkin::resetColors( const QColor& accent )
{
m_data->palette = ColorPalette( m_data->palette.baseColor,
accent, m_data->palette.contrastColor );
Editor editor( &hintTable(), m_data->palette );
editor.setup();
}
#include "moc_QskMaterialSkin.cpp" #include "moc_QskMaterialSkin.cpp"

25
skins/material/QskMaterialSkin.h
View File

@ -23,31 +23,6 @@ class QSK_MATERIAL_EXPORT QskMaterialSkin : public QskSkin
private: private:
void resetColors( const QColor& accent ) override; void resetColors( const QColor& accent ) override;
void initHints();
void initCommonHints();
void initBoxHints();
void initDialogButtonBoxHints();
void initDialogButtonHints();
void initFocusIndicatorHints();
void initInputPanelHints();
void initVirtualKeyboardHints();
void initListViewHints();
void initPageIndicatorHints();
void initPopupHints();
void initProgressBarHints();
void initPushButtonHints();
void initScrollViewHints();
void initSeparatorHints();
void initSubWindowHints();
void initSliderHints();
void initTabButtonHints();
void initTabBarHints();
void initTabViewHints();
void initTextInputHints();
void initTextLabelHints();
class PrivateData; class PrivateData;
std::unique_ptr< PrivateData > m_data; std::unique_ptr< PrivateData > m_data;
}; };

354
skins/squiek/QskSquiekSkin.cpp
View File

@ -5,6 +5,8 @@
#include "QskSquiekSkin.h" #include "QskSquiekSkin.h"
#include <QskSkinHintTableEditor.h>
#include <QskBox.h> #include <QskBox.h>
#include <QskDialogButton.h> #include <QskDialogButton.h>
#include <QskDialogButtonBox.h> #include <QskDialogButtonBox.h>
@ -26,8 +28,6 @@
#include <QskTextLabel.h> #include <QskTextLabel.h>
#include <QskVirtualKeyboard.h> #include <QskVirtualKeyboard.h>
#include <QskSkinlet.h>
#include <QskAnimationHint.h> #include <QskAnimationHint.h>
#include <QskAspect.h> #include <QskAspect.h>
#include <QskBoxBorderColors.h> #include <QskBoxBorderColors.h>
@ -112,31 +112,63 @@ namespace
QColor highlighted; QColor highlighted;
QColor highlightedText; QColor highlightedText;
}; };
}
class QskSquiekSkin::PrivateData class Editor : private QskSkinHintTableEditor
{ {
public: public:
ColorPalette palette; Editor( QskSkinHintTable* table, const ColorPalette& palette )
: QskSkinHintTableEditor( table )
, m_pal( palette )
{
}
void setup();
private:
void setupControl();
void setupBox();
void setupDialogButton();
void setupDialogButtonBox();
void setupFocusIndicator();
void setupInputPanel();
void setupInputPredictionBar();
void setupVirtualKeyboard();
void setupListView();
void setupPageIndicator();
void setupPopup();
void setupProgressBar();
void setupPushButton();
void setupScrollView();
void setupSeparator();
void setupSlider();
void setupSubWindow();
void setupTabButton();
void setupTabBar();
void setupTabView();
void setupTextLabel();
void setupTextInput();
enum PanelStyle
{
NoPanel,
Raised,
Sunken,
Plain,
Flat
}; };
QskSquiekSkin::QskSquiekSkin( QObject* parent ) void setSeparator( QskAspect );
: Inherited( parent ) void setButton( QskAspect, PanelStyle, qreal border = 2.0 );
, m_data( new PrivateData() ) void setPanel( QskAspect, PanelStyle );
{
initHints(); const ColorPalette& m_pal;
setupFonts( "DejaVuSans" ); };
} }
QskSquiekSkin::~QskSquiekSkin() void Editor::setSeparator( QskAspect aspect )
{ {
} QskGradient gradient( QskGradient::Vertical, m_pal.lighter110, m_pal.darker125 );
void QskSquiekSkin::setSeparator( QskAspect aspect )
{
const auto& pal = m_data->palette;
QskGradient gradient( QskGradient::Vertical, pal.lighter110, pal.darker125 );
if ( aspect.placement() == QskAspect::Vertical ) if ( aspect.placement() == QskAspect::Vertical )
gradient.setOrientation( QskGradient::Horizontal ); gradient.setOrientation( QskGradient::Horizontal );
@ -146,14 +178,11 @@ void QskSquiekSkin::setSeparator( QskAspect aspect )
setBoxBorderMetrics( aspect, 0 ); setBoxBorderMetrics( aspect, 0 );
} }
void QskSquiekSkin::setButton( void Editor::setButton( QskAspect aspect, PanelStyle style, qreal border )
QskAspect aspect, PanelStyle style, qreal border )
{ {
#if 1 #if 1
// Buttons shift ??? // Buttons shift ???
#endif #endif
const auto& pal = m_data->palette;
QskBoxBorderColors borderColors; QskBoxBorderColors borderColors;
QskGradient gradient; QskGradient gradient;
@ -163,31 +192,31 @@ void QskSquiekSkin::setButton(
{ {
case Raised: case Raised:
{ {
borderColors.setColorsAt( Qt::TopEdge | Qt::LeftEdge, pal.lighter135 ); borderColors.setColorsAt( Qt::TopEdge | Qt::LeftEdge, m_pal.lighter135 );
borderColors.setColorsAt( Qt::RightEdge | Qt::BottomEdge, pal.darker200 ); borderColors.setColorsAt( Qt::RightEdge | Qt::BottomEdge, m_pal.darker200 );
gradient.setColors( pal.lighter125, pal.lighter110 ); gradient.setColors( m_pal.lighter125, m_pal.lighter110 );
break; break;
} }
case Sunken: case Sunken:
{ {
borderColors.setColorsAt( Qt::TopEdge | Qt::LeftEdge, pal.darker200 ); borderColors.setColorsAt( Qt::TopEdge | Qt::LeftEdge, m_pal.darker200 );
borderColors.setColorsAt( Qt::RightEdge | Qt::BottomEdge, pal.lighter135 ); borderColors.setColorsAt( Qt::RightEdge | Qt::BottomEdge, m_pal.lighter135 );
gradient.setColors( pal.lighter110, pal.lighter125 ); gradient.setColors( m_pal.lighter110, m_pal.lighter125 );
break; break;
} }
case Plain: case Plain:
{ {
borderColors.setColors( pal.darker125 ); borderColors.setColors( m_pal.darker125 );
gradient.setColor( pal.lighter125 ); gradient.setColor( m_pal.lighter125 );
break; break;
} }
case Flat: case Flat:
case NoPanel: case NoPanel:
{ {
QColor noColor( pal.theme ); QColor noColor( m_pal.theme );
noColor.setAlpha( 0 ); noColor.setAlpha( 0 );
borderColors.setColors( noColor ); borderColors.setColors( noColor );
@ -206,86 +235,76 @@ void QskSquiekSkin::setButton(
setBoxBorderMetrics( aspect, border ); setBoxBorderMetrics( aspect, border );
} }
void QskSquiekSkin::setPanel( QskAspect aspect, PanelStyle style ) void Editor::setPanel( QskAspect aspect, PanelStyle style )
{ {
setButton( aspect, style, 1 ); setButton( aspect, style, 1 );
} }
void QskSquiekSkin::initHints() void Editor::setup()
{ {
initCommonHints(); setupControl();
initBoxHints(); setupBox();
initDialogButtonBoxHints(); setupDialogButtonBox();
initDialogButtonHints(); setupDialogButton();
initFocusIndicatorHints(); setupFocusIndicator();
initInputPanelHints(); setupInputPanel();
initInputPredictionBar(); setupInputPredictionBar();
initVirtualKeyboardHints(); setupVirtualKeyboard();
initListViewHints(); setupListView();
initPageIndicatorHints(); setupPageIndicator();
initPopupHints(); setupPopup();
initProgressBarHints(); setupProgressBar();
initPushButtonHints(); setupPushButton();
initScrollViewHints(); setupScrollView();
initSeparatorHints(); setupSeparator();
initSliderHints(); setupSlider();
initSubWindowHints(); setupSubWindow();
initTabButtonHints(); setupTabButton();
initTabBarHints(); setupTabBar();
initTabViewHints(); setupTabView();
initTextLabelHints(); setupTextLabel();
initTextInputHints(); setupTextInput();
} }
void QskSquiekSkin::resetColors( const QColor& accent ) void Editor::setupControl()
{
m_data->palette = ColorPalette( accent );
initHints();
}
void QskSquiekSkin::initCommonHints()
{ {
using A = QskAspect; using A = QskAspect;
using Q = QskControl; using Q = QskControl;
const auto& pal = m_data->palette;
setPadding( A::Control, 4 ); setPadding( A::Control, 4 );
setGradient( A::Control, pal.lighter135 ); setGradient( A::Control, m_pal.lighter135 );
setColor( A::Control | A::StyleColor, pal.themeForeground ); setColor( A::Control | A::StyleColor, m_pal.themeForeground );
setColor( A::Control | A::StyleColor | Q::Disabled, pal.theme ); setColor( A::Control | A::StyleColor | Q::Disabled, m_pal.theme );
} }
void QskSquiekSkin::initBoxHints() void Editor::setupBox()
{ {
setPanel( QskBox::Panel, Plain ); setPanel( QskBox::Panel, Plain );
} }
void QskSquiekSkin::initPopupHints() void Editor::setupPopup()
{ {
using A = QskAspect; using A = QskAspect;
using Q = QskPopup; using Q = QskPopup;
setSkinHint( Q::Overlay | A::Style, true ); setFlagHint( Q::Overlay | A::Style, true );
setGradient( Q::Overlay, QColor( 220, 220, 220, 150 ) ); setGradient( Q::Overlay, QColor( 220, 220, 220, 150 ) );
} }
void QskSquiekSkin::initTextLabelHints() void Editor::setupTextLabel()
{ {
using Q = QskTextLabel; using Q = QskTextLabel;
const auto& pal = m_data->palette;
setAlignment( Q::Text, Qt::AlignCenter ); setAlignment( Q::Text, Qt::AlignCenter );
setColor( Q::Text, pal.themeForeground ); setColor( Q::Text, m_pal.themeForeground );
setPadding( Q::Panel, 5 ); setPadding( Q::Panel, 5 );
setBoxBorderMetrics( Q::Panel, 2 ); setBoxBorderMetrics( Q::Panel, 2 );
setBoxShape( Q::Panel, 4 ); setBoxShape( Q::Panel, 4 );
const QColor c = pal.base; const QColor c = m_pal.base;
const QskBoxBorderColors borderColors( const QskBoxBorderColors borderColors(
c.darker( 170 ), c.darker( 170 ), c.darker( 170 ), c.darker( 170 ),
@ -295,18 +314,16 @@ void QskSquiekSkin::initTextLabelHints()
setGradient( Q::Panel, c ); setGradient( Q::Panel, c );
} }
void QskSquiekSkin::initTextInputHints() void Editor::setupTextInput()
{ {
using A = QskAspect; using A = QskAspect;
using Q = QskTextInput; using Q = QskTextInput;
const auto& pal = m_data->palette;
setAlignment( Q::Text, Qt::AlignLeft | Qt::AlignTop ); setAlignment( Q::Text, Qt::AlignLeft | Qt::AlignTop );
setColor( Q::Text, pal.themeForeground ); setColor( Q::Text, m_pal.themeForeground );
setColor( Q::PanelSelected, pal.highlighted ); setColor( Q::PanelSelected, m_pal.highlighted );
setColor( Q::TextSelected, pal.highlightedText ); setColor( Q::TextSelected, m_pal.highlightedText );
setPadding( Q::Panel, 5 ); setPadding( Q::Panel, 5 );
setBoxBorderMetrics( Q::Panel, 2 ); setBoxBorderMetrics( Q::Panel, 2 );
@ -318,15 +335,15 @@ void QskSquiekSkin::initTextInputHints()
if ( state == Q::ReadOnly ) if ( state == Q::ReadOnly )
{ {
c = pal.theme.lighter( 120 ); c = m_pal.theme.lighter( 120 );
} }
else if ( state == Q::Editing ) else if ( state == Q::Editing )
{ {
c = pal.baseActive; c = m_pal.baseActive;
} }
else else
{ {
c = pal.base; c = m_pal.base;
} }
const auto aspect = Q::Panel | state; const auto aspect = Q::Panel | state;
@ -342,36 +359,32 @@ void QskSquiekSkin::initTextInputHints()
setAnimation( Q::Panel | A::Color, qskDuration ); setAnimation( Q::Panel | A::Color, qskDuration );
} }
void QskSquiekSkin::initProgressBarHints() void Editor::setupProgressBar()
{ {
using A = QskAspect; using A = QskAspect;
using Q = QskProgressBar; using Q = QskProgressBar;
const auto& pal = m_data->palette;
setMetric( Q::Groove | A::Size, 8 ); setMetric( Q::Groove | A::Size, 8 );
setPadding( Q::Groove, 0 ); setPadding( Q::Groove, 0 );
setGradient( Q::Groove, pal.darker200 ); setGradient( Q::Groove, m_pal.darker200 );
setBoxShape( Q::Groove, 4 ); setBoxShape( Q::Groove, 4 );
setGradient( Q::Bar, pal.highlighted ); setGradient( Q::Bar, m_pal.highlighted );
setBoxShape( Q::Bar, 4 ); setBoxShape( Q::Bar, 4 );
} }
void QskSquiekSkin::initFocusIndicatorHints() void Editor::setupFocusIndicator()
{ {
using Q = QskFocusIndicator; using Q = QskFocusIndicator;
const auto& pal = m_data->palette;
setPadding( Q::Panel, 5 ); setPadding( Q::Panel, 5 );
setBoxBorderMetrics( Q::Panel, 2 ); setBoxBorderMetrics( Q::Panel, 2 );
setBoxShape( Q::Panel, 4 ); setBoxShape( Q::Panel, 4 );
setGradient( Q::Panel, Qt::transparent ); setGradient( Q::Panel, Qt::transparent );
setBoxBorderColors( Q::Panel, pal.highlighted ); setBoxBorderColors( Q::Panel, m_pal.highlighted );
} }
void QskSquiekSkin::initSeparatorHints() void Editor::setupSeparator()
{ {
using A = QskAspect; using A = QskAspect;
using Q = QskSeparator; using Q = QskSeparator;
@ -382,13 +395,11 @@ void QskSquiekSkin::initSeparatorHints()
setSeparator( Q::Panel | A::Vertical ); setSeparator( Q::Panel | A::Vertical );
} }
void QskSquiekSkin::initPageIndicatorHints() void Editor::setupPageIndicator()
{ {
using A = QskAspect; using A = QskAspect;
using Q = QskPageIndicator; using Q = QskPageIndicator;
const auto& pal = m_data->palette;
for ( auto subControl : { Q::Bullet, Q::Highlighted } ) for ( auto subControl : { Q::Bullet, Q::Highlighted } )
{ {
const auto extent = qskDpiScaled( 12 ); const auto extent = qskDpiScaled( 12 );
@ -398,8 +409,8 @@ void QskSquiekSkin::initPageIndicatorHints()
setBoxShape( subControl, 100, Qt::RelativeSize ); setBoxShape( subControl, 100, Qt::RelativeSize );
} }
setGradient( Q::Bullet, pal.darker150 ); setGradient( Q::Bullet, m_pal.darker150 );
setGradient( Q::Highlighted, pal.lighter150 ); setGradient( Q::Highlighted, m_pal.lighter150 );
// no visible background panel // no visible background panel
setBoxBorderMetrics( Q::Panel, 0 ); setBoxBorderMetrics( Q::Panel, 0 );
@ -409,13 +420,11 @@ void QskSquiekSkin::initPageIndicatorHints()
setMetric( Q::Panel | A::Spacing, 3 ); setMetric( Q::Panel | A::Spacing, 3 );
} }
void QskSquiekSkin::initPushButtonHints() void Editor::setupPushButton()
{ {
using A = QskAspect; using A = QskAspect;
using Q = QskPushButton; using Q = QskPushButton;
const auto& pal = m_data->palette;
// Panel // Panel
setStrutSize( Q::Panel, qskDpiScaled( 75.0 ), qskDpiScaled( 23.0 ) ); setStrutSize( Q::Panel, qskDpiScaled( 75.0 ), qskDpiScaled( 23.0 ) );
@ -443,20 +452,18 @@ void QskSquiekSkin::initPushButtonHints()
setAnimation( Q::Panel | A::Metric, qskDuration ); setAnimation( Q::Panel | A::Metric, qskDuration );
// Text // Text
setSkinHint( Q::Text | Q::Disabled | A::Style, Qsk::Sunken ); setFlagHint( Q::Text | Q::Disabled | A::Style, Qsk::Sunken );
setAlignment( Q::Text, Qt::AlignCenter ); setAlignment( Q::Text, Qt::AlignCenter );
setColor( Q::Text, pal.themeForeground ); setColor( Q::Text, m_pal.themeForeground );
setColor( Q::Text | Q::Disabled, pal.darker200 ); setColor( Q::Text | Q::Disabled, m_pal.darker200 );
} }
void QskSquiekSkin::initDialogButtonHints() void Editor::setupDialogButton()
{ {
using A = QskAspect; using A = QskAspect;
using Q = QskDialogButton; using Q = QskDialogButton;
const auto& pal = m_data->palette;
// panel // panel
setStrutSize( Q::Panel, qskDpiScaled( 75.0 ), qskDpiScaled( 23.0 ) ); setStrutSize( Q::Panel, qskDpiScaled( 75.0 ), qskDpiScaled( 23.0 ) );
@ -470,58 +477,54 @@ void QskSquiekSkin::initDialogButtonHints()
setAnimation( Q::Panel | A::Metric, qskDuration ); setAnimation( Q::Panel | A::Metric, qskDuration );
// text // text
setSkinHint( Q::Text | Q::Disabled | A::Style, Qsk::Sunken ); setFlagHint( Q::Text | Q::Disabled | A::Style, Qsk::Sunken );
setAlignment( Q::Text, Qt::AlignCenter ); setAlignment( Q::Text, Qt::AlignCenter );
setColor( Q::Text, pal.themeForeground ); setColor( Q::Text, m_pal.themeForeground );
setColor( Q::Text | Q::Disabled, pal.darker200 ); setColor( Q::Text | Q::Disabled, m_pal.darker200 );
} }
void QskSquiekSkin::initDialogButtonBoxHints() void Editor::setupDialogButtonBox()
{ {
using Q = QskDialogButtonBox; using Q = QskDialogButtonBox;
const auto& pal = m_data->palette; setBoxBorderColors( Q::Panel, m_pal.theme );
setGradient( Q::Panel, m_pal.lighter135 );
setBoxBorderColors( Q::Panel, pal.theme );
setGradient( Q::Panel, pal.lighter135 );
setBoxBorderMetrics( Q::Panel, 0 ); setBoxBorderMetrics( Q::Panel, 0 );
setBoxShape( Q::Panel, 2 ); setBoxShape( Q::Panel, 2 );
} }
void QskSquiekSkin::initTabButtonHints() void Editor::setupTabButton()
{ {
using A = QskAspect; using A = QskAspect;
using Q = QskTabButton; using Q = QskTabButton;
const auto& pal = m_data->palette;
setStrutSize( Q::Panel, 30, 16 ); setStrutSize( Q::Panel, 30, 16 );
for ( auto placement : { A::Top, A::Bottom } ) for ( auto placement : { A::Top, A::Bottom } )
{ {
setGradient( Q::Panel | placement, setGradient( Q::Panel | placement,
QskGradient( Qt::Vertical, pal.lighter125, pal.lighter110 ) ); QskGradient( Qt::Vertical, m_pal.lighter125, m_pal.lighter110 ) );
for ( const auto state : { Q::Checked, Q::Checked | Q::Pressed } ) for ( const auto state : { Q::Checked, Q::Checked | Q::Pressed } )
{ {
setGradient( Q::Panel | placement | state, pal.lighter125 ); setGradient( Q::Panel | placement | state, m_pal.lighter125 );
setColor( Q::Text | placement | state, pal.themeForeground ); setColor( Q::Text | placement | state, m_pal.themeForeground );
} }
} }
for ( auto placement : { A::Left, A::Right } ) for ( auto placement : { A::Left, A::Right } )
{ {
setGradient( Q::Panel | placement, pal.lighter125 ); setGradient( Q::Panel | placement, m_pal.lighter125 );
for ( const auto state : { Q::Checked, Q::Checked | Q::Pressed } ) for ( const auto state : { Q::Checked, Q::Checked | Q::Pressed } )
{ {
setGradient( Q::Panel | placement | state, pal.highlighted ); setGradient( Q::Panel | placement | state, m_pal.highlighted );
setColor( Q::Text | placement | state, pal.highlightedText ); setColor( Q::Text | placement | state, m_pal.highlightedText );
} }
} }
setBoxBorderColors( Q::Panel, pal.darker200 ); setBoxBorderColors( Q::Panel, m_pal.darker200 );
for ( auto placement : { A::Left, A::Right, A::Top, A::Bottom } ) for ( auto placement : { A::Left, A::Right, A::Top, A::Bottom } )
{ {
@ -593,17 +596,15 @@ void QskSquiekSkin::initTabButtonHints()
// text // text
setAlignment( Q::Text, Qt::AlignCenter ); setAlignment( Q::Text, Qt::AlignCenter );
setColor( Q::Text, pal.themeForeground ); setColor( Q::Text, m_pal.themeForeground );
setColor( Q::Text | Q::Checkable | Q::Disabled, pal.darker200 ); setColor( Q::Text | Q::Checkable | Q::Disabled, m_pal.darker200 );
} }
void QskSquiekSkin::initSliderHints() void Editor::setupSlider()
{ {
using A = QskAspect; using A = QskAspect;
using Q = QskSlider; using Q = QskSlider;
const auto& pal = m_data->palette;
const qreal extent = 40; const qreal extent = 40;
// Panel // Panel
@ -636,7 +637,7 @@ void QskSquiekSkin::initSliderHints()
setBoxShape( aspect, 0.1 * extent ); setBoxShape( aspect, 0.1 * extent );
} }
setGradient( Q::Groove | placement, pal.darker200 ); setGradient( Q::Groove | placement, m_pal.darker200 );
setGradient( Q::Fill | placement, QskGradient() ); // no filling setGradient( Q::Fill | placement, QskGradient() ); // no filling
} }
@ -657,7 +658,7 @@ void QskSquiekSkin::initSliderHints()
setAnimation( Q::Handle | A::Color, qskDuration ); setAnimation( Q::Handle | A::Color, qskDuration );
} }
void QskSquiekSkin::initTabBarHints() void Editor::setupTabBar()
{ {
using A = QskAspect; using A = QskAspect;
using Q = QskTabBar; using Q = QskTabBar;
@ -678,7 +679,7 @@ void QskSquiekSkin::initTabBarHints()
setAnimation( Q::Panel | A::Metric, QskAnimationHint( 200, QEasingCurve::OutCubic ) ); setAnimation( Q::Panel | A::Metric, QskAnimationHint( 200, QEasingCurve::OutCubic ) );
} }
void QskSquiekSkin::initTabViewHints() void Editor::setupTabView()
{ {
using A = QskAspect; using A = QskAspect;
using Q = QskTabView; using Q = QskTabView;
@ -696,7 +697,7 @@ void QskSquiekSkin::initTabViewHints()
setAnimation( Q::Page, qskDuration ); setAnimation( Q::Page, qskDuration );
} }
void QskSquiekSkin::initInputPanelHints() void Editor::setupInputPanel()
{ {
using Q = QskInputPanelBox; using Q = QskInputPanelBox;
@ -704,31 +705,27 @@ void QskSquiekSkin::initInputPanelHints()
setPanel( Q::Panel, Raised ); setPanel( Q::Panel, Raised );
} }
void QskSquiekSkin::initInputPredictionBar() void Editor::setupInputPredictionBar()
{ {
using Q = QskInputPredictionBar; using Q = QskInputPredictionBar;
const auto& pal = m_data->palette;
setPadding( Q::Panel, 5 ); setPadding( Q::Panel, 5 );
setPanel( Q::Panel, Flat ); setPanel( Q::Panel, Flat );
setButton( Q::ButtonPanel, Flat ); setButton( Q::ButtonPanel, Flat );
setButton( Q::ButtonPanel | QskPushButton::Pressed, Sunken ); setButton( Q::ButtonPanel | QskPushButton::Pressed, Sunken );
setStrutSize( Q::ButtonPanel, qskDpiScaled( 30.0 ), qskDpiScaled( 10.0 ) ); setStrutSize( Q::ButtonPanel, qskDpiScaled( 30.0 ), qskDpiScaled( 23.0 ) );
setColor( Q::ButtonText, pal.themeForeground ); setColor( Q::ButtonText, m_pal.themeForeground );
setColor( Q::ButtonText | QskPushButton::Disabled, pal.darker200 ); setColor( Q::ButtonText | QskPushButton::Disabled, m_pal.darker200 );
} }
void QskSquiekSkin::initVirtualKeyboardHints() void Editor::setupVirtualKeyboard()
{ {
using A = QskAspect; using A = QskAspect;
using Q = QskVirtualKeyboard; using Q = QskVirtualKeyboard;
const auto& pal = m_data->palette;
setPadding( Q::Panel, 5 ); setPadding( Q::Panel, 5 );
setMetric( Q::Panel | A::Spacing, 5 ); setMetric( Q::Panel | A::Spacing, 5 );
setPanel( Q::Panel, Raised ); setPanel( Q::Panel, Raised );
@ -738,11 +735,11 @@ void QskSquiekSkin::initVirtualKeyboardHints()
setAnimation( Q::ButtonPanel | A::Color, qskDuration ); setAnimation( Q::ButtonPanel | A::Color, qskDuration );
setColor( Q::ButtonText, pal.themeForeground ); setColor( Q::ButtonText, m_pal.themeForeground );
setColor( Q::ButtonText | QskPushButton::Disabled, pal.darker200 ); setColor( Q::ButtonText | QskPushButton::Disabled, m_pal.darker200 );
} }
void QskSquiekSkin::initScrollViewHints() void Editor::setupScrollView()
{ {
using A = QskAspect; using A = QskAspect;
using Q = QskScrollView; using Q = QskScrollView;
@ -796,57 +793,53 @@ void QskSquiekSkin::initScrollViewHints()
setAnimation( Q::Viewport | A::Metric, QskAnimationHint( 200, QEasingCurve::OutCubic ) ); setAnimation( Q::Viewport | A::Metric, QskAnimationHint( 200, QEasingCurve::OutCubic ) );
} }
void QskSquiekSkin::initListViewHints() void Editor::setupListView()
{ {
using Q = QskListView; using Q = QskListView;
const auto& pal = m_data->palette;
// padding for each cell // padding for each cell
setPadding( Q::Cell, QskMargins( 4, 8 ) ); setPadding( Q::Cell, QskMargins( 4, 8 ) );
setColor( Q::Text, pal.themeForeground ); setColor( Q::Text, m_pal.themeForeground );
setColor( Q::Cell, pal.contrasted ); setColor( Q::Cell, m_pal.contrasted );
setColor( Q::CellSelected, pal.highlighted ); setColor( Q::CellSelected, m_pal.highlighted );
setColor( Q::TextSelected, pal.highlightedText ); setColor( Q::TextSelected, m_pal.highlightedText );
} }
void QskSquiekSkin::initSubWindowHints() void Editor::setupSubWindow()
{ {
using A = QskAspect; using A = QskAspect;
using Q = QskSubWindow; using Q = QskSubWindow;
const auto& pal = m_data->palette;
const qreal radius = 5.0; const qreal radius = 5.0;
// Panel // Panel
setSkinHint( Q::Panel | A::Decoration, true ); setFlagHint( Q::Panel | A::Decoration, true );
setPadding( Q::Panel, 10 ); setPadding( Q::Panel, 10 );
setBoxBorderMetrics( Q::Panel, 2 ); setBoxBorderMetrics( Q::Panel, 2 );
setBoxShape( Q::Panel, radius, radius, 0, 0, Qt::AbsoluteSize ); setBoxShape( Q::Panel, radius, radius, 0, 0, Qt::AbsoluteSize );
QskBoxBorderColors borderColors; QskBoxBorderColors borderColors;
borderColors.setColorsAt( Qt::TopEdge | Qt::LeftEdge, pal.lighter125 ); borderColors.setColorsAt( Qt::TopEdge | Qt::LeftEdge, m_pal.lighter125 );
borderColors.setColorsAt( Qt::RightEdge | Qt::BottomEdge, pal.darker200 ); borderColors.setColorsAt( Qt::RightEdge | Qt::BottomEdge, m_pal.darker200 );
setBoxBorderColors( Q::Panel, borderColors ); setBoxBorderColors( Q::Panel, borderColors );
setGradient( Q::Panel, pal.lighter135 ); setGradient( Q::Panel, m_pal.lighter135 );
// TitleBar // TitleBar
setGradient( Q::TitleBar | Q::Focused, pal.highlighted ); setGradient( Q::TitleBar | Q::Focused, m_pal.highlighted );
setGradient( Q::TitleBar, pal.contrasted ); setGradient( Q::TitleBar, m_pal.contrasted );
setSpacing( Q::TitleBar, 5 ); setSpacing( Q::TitleBar, 5 );
setStrutSize( Q::TitleBar, 0, 20 ); setStrutSize( Q::TitleBar, 0, 20 );
setBoxShape( Q::TitleBar, radius, radius, 0, 0, Qt::AbsoluteSize ); setBoxShape( Q::TitleBar, radius, radius, 0, 0, Qt::AbsoluteSize );
// TitleBarText // TitleBarText
setFontRole( Q::TitleBarText, QskSkin::SmallFont ); setFontRole( Q::TitleBarText, QskSkin::SmallFont );
setColor( Q::TitleBarText | Q::Focused, pal.highlightedText ); setColor( Q::TitleBarText | Q::Focused, m_pal.highlightedText );
setColor( Q::TitleBarText, pal.themeForeground ); setColor( Q::TitleBarText, m_pal.themeForeground );
setAlignment( Q::TitleBarText, Qt::AlignLeft | Qt::AlignVCenter ); setAlignment( Q::TitleBarText, Qt::AlignLeft | Qt::AlignVCenter );
@ -854,4 +847,33 @@ void QskSquiekSkin::initSubWindowHints()
setAnimation( subControl | A::Color, qskDuration ); setAnimation( subControl | A::Color, qskDuration );
} }
class QskSquiekSkin::PrivateData
{
public:
ColorPalette palette;
};
QskSquiekSkin::QskSquiekSkin( QObject* parent )
: Inherited( parent )
, m_data( new PrivateData() )
{
setupFonts( "DejaVuSans" );
Editor editor( &hintTable(), m_data->palette );
editor.setup();
}
QskSquiekSkin::~QskSquiekSkin()
{
}
void QskSquiekSkin::resetColors( const QColor& accent )
{
m_data->palette = ColorPalette( accent );
Editor editor( &hintTable(), m_data->palette );
editor.setup();
}
#include "moc_QskSquiekSkin.cpp" #include "moc_QskSquiekSkin.cpp"

39
skins/squiek/QskSquiekSkin.h
View File

@ -23,45 +23,6 @@ class QSK_SQUIEK_EXPORT QskSquiekSkin : public QskSkin
private: private:
void resetColors( const QColor& accent ) override; void resetColors( const QColor& accent ) override;
void initHints();
void initCommonHints();
void initBoxHints();
void initDialogButtonHints();
void initDialogButtonBoxHints();
void initFocusIndicatorHints();
void initInputPanelHints();
void initInputPredictionBar();
void initVirtualKeyboardHints();
void initListViewHints();
void initPageIndicatorHints();
void initPopupHints();
void initProgressBarHints();
void initPushButtonHints();
void initScrollViewHints();
void initSeparatorHints();
void initSliderHints();
void initSubWindowHints();
void initTabButtonHints();
void initTabBarHints();
void initTabViewHints();
void initTextLabelHints();
void initTextInputHints();
enum PanelStyle
{
NoPanel,
Raised,
Sunken,
Plain,
Flat
};
void setSeparator( QskAspect );
void setButton( QskAspect, PanelStyle, qreal border = 2.0 );
void setPanel( QskAspect, PanelStyle );
class PrivateData; class PrivateData;
std::unique_ptr< PrivateData > m_data; std::unique_ptr< PrivateData > m_data;
}; };

15
src/common/QskAspect.h
View File

@ -131,6 +131,9 @@ class QSK_EXPORT QskAspect
constexpr QskAspect operator|( Placement ) const noexcept; constexpr QskAspect operator|( Placement ) const noexcept;
constexpr QskAspect operator|( State ) const noexcept; constexpr QskAspect operator|( State ) const noexcept;
constexpr QskAspect stateless() const noexcept;
constexpr QskAspect trunk() const noexcept;
constexpr quint64 value() const noexcept; constexpr quint64 value() const noexcept;
constexpr bool isAnimator() const noexcept; constexpr bool isAnimator() const noexcept;
@ -295,6 +298,18 @@ inline constexpr QskAspect QskAspect::operator|( State state ) const noexcept
m_bits.primitive, m_bits.placement, m_bits.states | state ); m_bits.primitive, m_bits.placement, m_bits.states | state );
} }
inline constexpr QskAspect QskAspect::stateless() const noexcept
{
return QskAspect( m_bits.subControl, m_bits.type, m_bits.isAnimator,
m_bits.primitive, m_bits.placement, 0 );
}
inline constexpr QskAspect QskAspect::trunk() const noexcept
{
return QskAspect( m_bits.subControl, m_bits.type, m_bits.isAnimator,
m_bits.primitive, 0, 0 );
}
inline constexpr quint64 QskAspect::value() const noexcept inline constexpr quint64 QskAspect::value() const noexcept
{ {
return m_value; return m_value;

204
src/controls/QskSkin.cpp
View File

@ -13,6 +13,8 @@
#include "QskSkinHintTable.h" #include "QskSkinHintTable.h"
#include "QskStandardSymbol.h" #include "QskStandardSymbol.h"
#include "QskMargins.h"
QSK_QT_PRIVATE_BEGIN QSK_QT_PRIVATE_BEGIN
#include <private/qguiapplication_p.h> #include <private/qguiapplication_p.h>
QSK_QT_PRIVATE_END QSK_QT_PRIVATE_END
@ -156,203 +158,21 @@ QskSkin::QskSkin( QObject* parent )
const QFont font = QGuiApplication::font(); const QFont font = QGuiApplication::font();
setupFonts( font.family(), font.weight(), font.italic() ); setupFonts( font.family(), font.weight(), font.italic() );
setMargin( QskAspect::Control, 0 ); {
setPadding( QskAspect::Control, 0 ); // some defaults
setSpacing( QskAspect::Control, 0 ); const auto noMargins = QVariant::fromValue( QskMargins( 0 ) );
const auto aspect = QskAspect::Control | QskAspect::Metric;
setSkinHint( aspect | QskAspect::Margin, noMargins );
setSkinHint( aspect | QskAspect::Padding, noMargins );
setSkinHint( aspect | QskAspect::Spacing, 0 );
}
} }
QskSkin::~QskSkin() QskSkin::~QskSkin()
{ {
} }
void QskSkin::setColor( QskAspect aspect, QRgb rgb )
{
setSkinHint( aspect | QskAspect::Color, QColor::fromRgba( rgb ) );
}
void QskSkin::setColor( QskAspect aspect, Qt::GlobalColor color )
{
setSkinHint( aspect | QskAspect::Color, QColor( color ) );
}
void QskSkin::setColor( QskAspect aspect, const QColor& color )
{
setSkinHint( aspect | QskAspect::Color, color );
}
QColor QskSkin::color( QskAspect aspect ) const
{
return m_data->hintTable.color( aspect );
}
void QskSkin::setMetric( QskAspect aspect, qreal metric )
{
m_data->hintTable.setMetric( aspect, metric );
}
qreal QskSkin::metric( QskAspect aspect ) const
{
return m_data->hintTable.metric( aspect );
}
void QskSkin::setStrutSize( QskAspect aspect, qreal width, qreal height )
{
setStrutSize( aspect, QSizeF( width, height ) );
}
void QskSkin::setStrutSize( QskAspect aspect, const QSizeF& strut )
{
m_data->hintTable.setStrutSize( aspect, strut );
}
QSizeF QskSkin::strutSize( QskAspect aspect ) const
{
return m_data->hintTable.strutSize( aspect );
}
void QskSkin::setMargin( QskAspect aspect, const QskMargins& margins )
{
m_data->hintTable.setMargin( aspect, margins );
}
void QskSkin::setMargin( QskAspect aspect,
qreal left, qreal top, qreal right, qreal bottom )
{
const QskMargins margins( left, top, right, bottom );
m_data->hintTable.setMargin( aspect, margins );
}
QskMargins QskSkin::margin( QskAspect aspect ) const
{
return m_data->hintTable.margin( aspect );
}
void QskSkin::setPadding( QskAspect aspect, const QskMargins& padding )
{
m_data->hintTable.setPadding( aspect, padding );
}
void QskSkin::setPadding( QskAspect aspect,
qreal left, qreal top, qreal right, qreal bottom )
{
const QskMargins padding( left, top, right, bottom );
m_data->hintTable.setPadding( aspect, padding );
}
QskMargins QskSkin::padding( QskAspect aspect ) const
{
return m_data->hintTable.padding( aspect );
}
void QskSkin::setSpacing( QskAspect aspect, qreal spacing )
{
m_data->hintTable.setSpacing( aspect, spacing );
}
qreal QskSkin::spacing( QskAspect aspect ) const
{
return m_data->hintTable.spacing( aspect );
}
void QskSkin::setGradient( QskAspect aspect, const QskGradient& gradient )
{
m_data->hintTable.setGradient( aspect, gradient );
}
QskGradient QskSkin::gradient( QskAspect aspect ) const
{
return m_data->hintTable.gradient( aspect );
}
void QskSkin::setBoxShape( QskAspect aspect,
qreal radius, Qt::SizeMode sizeMode )
{
m_data->hintTable.setBoxShape( aspect,
QskBoxShapeMetrics( radius, radius, radius, radius, sizeMode ) );
}
void QskSkin::setBoxShape( QskAspect aspect, qreal topLeft, qreal topRight,
qreal bottomLeft, qreal bottomRight, Qt::SizeMode sizeMode )
{
m_data->hintTable.setBoxShape( aspect,
QskBoxShapeMetrics( topLeft, topRight, bottomLeft, bottomRight, sizeMode ) );
}
void QskSkin::setBoxShape( QskAspect aspect, const QskBoxShapeMetrics& shape )
{
m_data->hintTable.setBoxShape( aspect, shape );
}
QskBoxShapeMetrics QskSkin::boxShape( QskAspect aspect ) const
{
return m_data->hintTable.boxShape( aspect );
}
void QskSkin::setBoxBorderMetrics( QskAspect aspect,
qreal left, qreal top, qreal right, qreal bottom, Qt::SizeMode sizeMode )
{
m_data->hintTable.setBoxBorder( aspect,
QskBoxBorderMetrics( left, top, right, bottom, sizeMode ) );
}
void QskSkin::setBoxBorderMetrics( QskAspect aspect,
qreal borderWidth, Qt::SizeMode sizeMode )
{
m_data->hintTable.setBoxBorder(
aspect, QskBoxBorderMetrics( borderWidth, sizeMode ) );
}
void QskSkin::setBoxBorderMetrics(
QskAspect aspect, const QskBoxBorderMetrics& border )
{
m_data->hintTable.setBoxBorder( aspect, border );
}
QskBoxBorderMetrics QskSkin::boxBorderMetrics( QskAspect aspect ) const
{
return m_data->hintTable.boxBorder( aspect );
}
void QskSkin::setBoxBorderColors( QskAspect aspect, const QskBoxBorderColors& colors )
{
m_data->hintTable.setBoxBorderColors( aspect, colors );
}
QskBoxBorderColors QskSkin::boxBorderColors( QskAspect aspect ) const
{
return m_data->hintTable.boxBorderColors( aspect );
}
void QskSkin::setFontRole( QskAspect aspect, int fontRole )
{
m_data->hintTable.setFontRole( aspect, fontRole );
}
void QskSkin::setGraphicRole( QskAspect aspect, int graphicRole )
{
m_data->hintTable.setGraphicRole( aspect, graphicRole );
}
void QskSkin::setAnimation( QskAspect aspect, QskAnimationHint animation )
{
m_data->hintTable.setAnimation( aspect, animation );
}
QskAnimationHint QskSkin::animation( QskAspect aspect ) const
{
return m_data->hintTable.animation( aspect );
}
void QskSkin::setAlignment( QskAspect aspect, Qt::Alignment alignment )
{
m_data->hintTable.setAlignment( aspect, alignment );
}
Qt::Alignment QskSkin::alignment( QskAspect aspect ) const
{
return m_data->hintTable.alignment( aspect );
}
void QskSkin::setSkinHint( QskAspect aspect, const QVariant& skinHint ) void QskSkin::setSkinHint( QskAspect aspect, const QVariant& skinHint )
{ {
m_data->hintTable.setHint( aspect, skinHint ); m_data->hintTable.setHint( aspect, skinHint );
@ -457,7 +277,7 @@ const QskSkinHintTable& QskSkin::hintTable() const
return m_data->hintTable; return m_data->hintTable;
} }
QskSkinHintTable& QskSkin::skinHintTable() QskSkinHintTable& QskSkin::hintTable()
{ {
return m_data->hintTable; return m_data->hintTable;
} }

65
src/controls/QskSkin.h
View File

@ -22,15 +22,9 @@ class QskColorFilter;
class QskGraphic; class QskGraphic;
class QskGraphicProvider; class QskGraphicProvider;
class QskAnimationHint;
class QskSkinHintTable; class QskSkinHintTable;
class QVariant; class QVariant;
class QskMargins;
class QskGradient;
class QskBoxShapeMetrics;
class QskBoxBorderMetrics;
class QskBoxBorderColors;
class QSK_EXPORT QskSkin : public QObject class QSK_EXPORT QskSkin : public QObject
{ {
@ -60,60 +54,6 @@ class QSK_EXPORT QskSkin : public QObject
virtual void resetColors( const QColor& accent ); virtual void resetColors( const QColor& accent );
void setColor( QskAspect, Qt::GlobalColor );
void setColor( QskAspect, QRgb );
void setColor( QskAspect, const QColor& );
QColor color( QskAspect ) const;
void setMetric( QskAspect, qreal metric );
qreal metric( QskAspect ) const;
void setStrutSize( QskAspect, const QSizeF& );
void setStrutSize( QskAspect, qreal width, qreal height );
QSizeF strutSize( QskAspect ) const;
void setMargin( QskAspect, const QskMargins& );
void setMargin( QskAspect,
qreal left, qreal top, qreal right, qreal bottom );
QskMargins margin( QskAspect ) const;
void setPadding( QskAspect, const QskMargins& );
void setPadding( QskAspect,
qreal left, qreal top, qreal right, qreal bottom );
QskMargins padding( QskAspect ) const;
void setSpacing( QskAspect, qreal );
qreal spacing( QskAspect ) const;
void setGradient( QskAspect, const QskGradient& );
QskGradient gradient( QskAspect ) const;
void setBoxShape( QskAspect, qreal radius, Qt::SizeMode = Qt::AbsoluteSize );
void setBoxShape( QskAspect, qreal topLeft, qreal topRight,
qreal bottomLeft, qreal bottomRight, Qt::SizeMode = Qt::AbsoluteSize );
void setBoxShape( QskAspect, const QskBoxShapeMetrics& );
QskBoxShapeMetrics boxShape( QskAspect ) const;
void setBoxBorderMetrics( QskAspect,
qreal borderWidth, Qt::SizeMode = Qt::AbsoluteSize );
void setBoxBorderMetrics( QskAspect, qreal left, qreal top,
qreal right, qreal bottom, Qt::SizeMode = Qt::AbsoluteSize );
void setBoxBorderMetrics( QskAspect, const QskBoxBorderMetrics& );
QskBoxBorderMetrics boxBorderMetrics( QskAspect ) const;
void setBoxBorderColors( QskAspect, const QskBoxBorderColors& );
QskBoxBorderColors boxBorderColors( QskAspect ) const;
void setAnimation( QskAspect, QskAnimationHint );
QskAnimationHint animation( QskAspect ) const;
void setAlignment( QskAspect, Qt::Alignment );
Qt::Alignment alignment( QskAspect ) const;
void setSkinHint( QskAspect, const QVariant& hint ); void setSkinHint( QskAspect, const QVariant& hint );
const QVariant& skinHint( QskAspect ) const; const QVariant& skinHint( QskAspect ) const;
@ -121,9 +61,6 @@ class QSK_EXPORT QskSkin : public QObject
void resetGraphicFilter( int graphicRole ); void resetGraphicFilter( int graphicRole );
QskColorFilter graphicFilter( int graphicRole ) const; QskColorFilter graphicFilter( int graphicRole ) const;
void setFontRole( QskAspect, int fontRole );
void setGraphicRole( QskAspect, int graphicRole );
void setFont( int fontRole, const QFont& ); void setFont( int fontRole, const QFont& );
void resetFont( int fontRole ); void resetFont( int fontRole );
QFont font( int fontRole ) const; QFont font( int fontRole ) const;
@ -145,12 +82,12 @@ class QSK_EXPORT QskSkin : public QObject
QskSkinlet* skinlet( const QMetaObject* ); QskSkinlet* skinlet( const QMetaObject* );
const QskSkinHintTable& hintTable() const; const QskSkinHintTable& hintTable() const;
QskSkinHintTable& hintTable();
const std::unordered_map< int, QFont >& fonts() const; const std::unordered_map< int, QFont >& fonts() const;
const std::unordered_map< int, QskColorFilter >& graphicFilters() const; const std::unordered_map< int, QskColorFilter >& graphicFilters() const;
protected: protected:
QskSkinHintTable& skinHintTable();
private: private:
void declareSkinlet( const QMetaObject* controlMetaObject, void declareSkinlet( const QMetaObject* controlMetaObject,

18
src/controls/QskSkinHintTable.cpp
View File

@ -4,8 +4,9 @@
*****************************************************************************/ *****************************************************************************/
#include "QskSkinHintTable.h" #include "QskSkinHintTable.h"
#include "QskAnimationHint.h"
QVariant QskSkinHintTable::invalidHint; const QVariant QskSkinHintTable::invalidHint;
inline const QVariant* qskResolvedHint( QskAspect aspect, inline const QVariant* qskResolvedHint( QskAspect aspect,
const std::unordered_map< QskAspect, QVariant >& hints, const std::unordered_map< QskAspect, QVariant >& hints,
@ -111,7 +112,7 @@ void QskSkinHintTable::setHint( QskAspect aspect, const QVariant& skinHint )
it->second = skinHint; it->second = skinHint;
} }
if ( aspect.state() ) if ( aspect.hasState() )
m_hasStates = true; m_hasStates = true;
} }
@ -213,3 +214,16 @@ QskAspect QskSkinHintTable::resolvedAnimator(
return QskAspect(); return QskAspect();
} }
QskAnimationHint QskSkinHintTable::animation( QskAspect aspect ) const
{
aspect.setAnimator( true );
return hint< QskAnimationHint >( aspect );
}
void QskSkinHintTable::setAnimation(
QskAspect aspect, QskAnimationHint animation )
{
aspect.setAnimator( true );
setHint( aspect, animation );
}

222
src/controls/QskSkinHintTable.h
View File

@ -6,19 +6,13 @@
#ifndef QSK_SKIN_HINT_TABLE_H #ifndef QSK_SKIN_HINT_TABLE_H
#define QSK_SKIN_HINT_TABLE_H #define QSK_SKIN_HINT_TABLE_H
#include "QskAnimationHint.h"
#include "QskAspect.h" #include "QskAspect.h"
#include "QskBoxBorderColors.h"
#include "QskBoxBorderMetrics.h"
#include "QskBoxShapeMetrics.h"
#include "QskGradient.h"
#include "QskMargins.h"
#include <qcolor.h>
#include <qvariant.h> #include <qvariant.h>
#include <unordered_map> #include <unordered_map>
class QskAnimationHint;
class QSK_EXPORT QskSkinHintTable class QSK_EXPORT QskSkinHintTable
{ {
public: public:
@ -29,52 +23,15 @@ class QSK_EXPORT QskSkinHintTable
QskSkinHintTable& operator=( const QskSkinHintTable& ); QskSkinHintTable& operator=( const QskSkinHintTable& );
void setColor( QskAspect, Qt::GlobalColor );
void setColor( QskAspect, QRgb );
void setColor( QskAspect, const QColor& );
QColor color( QskAspect ) const;
void setMetric( QskAspect, qreal );
qreal metric( QskAspect ) const;
void setStrutSize( QskAspect, const QSizeF& );
QSizeF strutSize( QskAspect ) const;
void setMargin( QskAspect, const QskMargins& );
QskMargins margin( QskAspect ) const;
void setPadding( QskAspect, const QskMargins& );
QskMargins padding( QskAspect ) const;
void setGradient( QskAspect, const QskGradient& );
QskGradient gradient( QskAspect ) const;
void setBoxShape( QskAspect, const QskBoxShapeMetrics& );
QskBoxShapeMetrics boxShape( QskAspect ) const;
void setBoxBorder( QskAspect, const QskBoxBorderMetrics& );
QskBoxBorderMetrics boxBorder( QskAspect ) const;
void setBoxBorderColors( QskAspect, const QskBoxBorderColors& );
QskBoxBorderColors boxBorderColors( QskAspect ) const;
void setSpacing( QskAspect, qreal );
qreal spacing( QskAspect ) const;
void setAlignment( QskAspect, Qt::Alignment );
Qt::Alignment alignment( QskAspect ) const;
void setAnimation( QskAspect, QskAnimationHint ); void setAnimation( QskAspect, QskAnimationHint );
QskAnimationHint animation( QskAspect ) const; QskAnimationHint animation( QskAspect ) const;
void setGraphicRole( QskAspect, int role );
void setFontRole( QskAspect, int role );
void setFlagHint( QskAspect, int flag );
void setHint( QskAspect, const QVariant& ); void setHint( QskAspect, const QVariant& );
const QVariant& hint( QskAspect ) const; const QVariant& hint( QskAspect ) const;
template< typename T > void setHint( QskAspect, const T& );
template< typename T > T hint( QskAspect ) const;
bool removeHint( QskAspect ); bool removeHint( QskAspect );
QVariant takeHint( QskAspect ); QVariant takeHint( QskAspect );
@ -97,7 +54,7 @@ class QSK_EXPORT QskSkinHintTable
QskAspect, QskAnimationHint& ) const; QskAspect, QskAnimationHint& ) const;
private: private:
static QVariant invalidHint; static const QVariant invalidHint;
typedef std::unordered_map< QskAspect, QVariant > HintMap; typedef std::unordered_map< QskAspect, QVariant > HintMap;
HintMap* m_hints; HintMap* m_hints;
@ -141,171 +98,16 @@ inline const QVariant& QskSkinHintTable::hint( QskAspect aspect ) const
return invalidHint; return invalidHint;
} }
inline void QskSkinHintTable::setColor( QskAspect aspect, const QColor& color ) template< typename T >
inline void QskSkinHintTable::setHint( QskAspect aspect, const T& hint )
{ {
setHint( aspect | QskAspect::Color, color ); setHint( aspect, QVariant::fromValue( hint ) );
} }
inline void QskSkinHintTable::setColor( QskAspect aspect, Qt::GlobalColor color ) template< typename T >
inline T QskSkinHintTable::hint( QskAspect aspect ) const
{ {
setHint( aspect | QskAspect::Color, QColor( color ) ); return hint( aspect ).value< T >();
}
inline void QskSkinHintTable::setColor( QskAspect aspect, QRgb rgb )
{
setHint( aspect | QskAspect::Color, QColor::fromRgba( rgb ) );
}
inline QColor QskSkinHintTable::color( QskAspect aspect ) const
{
return hint( aspect | QskAspect::Color ).value< QColor >();
}
inline void QskSkinHintTable::setMetric( QskAspect aspect, qreal metric )
{
setHint( aspect | QskAspect::Metric, metric );
}
inline qreal QskSkinHintTable::metric( QskAspect aspect ) const
{
return hint( aspect | QskAspect::Metric ).toReal();
}
inline void QskSkinHintTable::setStrutSize( QskAspect aspect, const QSizeF& size )
{
const auto aspectStrut = aspect | QskAspect::Metric | QskAspect::StrutSize;
setHint( aspectStrut, QVariant::fromValue( size ) );
}
inline QSizeF QskSkinHintTable::strutSize( QskAspect aspect ) const
{
const auto aspectStrut = aspect | QskAspect::Metric | QskAspect::StrutSize;
return hint( aspectStrut ).value< QSizeF >();
}
inline void QskSkinHintTable::setMargin(
QskAspect aspect, const QskMargins& margins )
{
const auto aspectMargin = aspect | QskAspect::Metric | QskAspect::Margin;
setHint( aspectMargin, QVariant::fromValue( margins ) );
}
inline QskMargins QskSkinHintTable::margin( QskAspect aspect ) const
{
const auto aspectMargin = aspect | QskAspect::Metric | QskAspect::Margin;
return hint( aspectMargin ).value< QskMargins >();
}
inline void QskSkinHintTable::setPadding(
QskAspect aspect, const QskMargins& padding )
{
const auto aspectPadding = aspect | QskAspect::Metric | QskAspect::Padding;
setHint( aspectPadding, QVariant::fromValue( padding ) );
}
inline QskMargins QskSkinHintTable::padding( QskAspect aspect ) const
{
const auto aspectPadding = aspect | QskAspect::Metric | QskAspect::Padding;
return hint( aspectPadding ).value< QskMargins >();
}
inline void QskSkinHintTable::setGradient(
QskAspect aspect, const QskGradient& gradient )
{
setHint( aspect | QskAspect::Color, QVariant::fromValue( gradient ) );
}
inline QskGradient QskSkinHintTable::gradient( QskAspect aspect ) const
{
return hint( aspect | QskAspect::Color ).value< QskGradient >();
}
inline void QskSkinHintTable::setBoxShape(
QskAspect aspect, const QskBoxShapeMetrics& shape )
{
using A = QskAspect;
setHint( aspect | A::Shape | A::Metric, QVariant::fromValue( shape ) );
}
inline QskBoxShapeMetrics QskSkinHintTable::boxShape( QskAspect aspect ) const
{
using A = QskAspect;
return hint( aspect | A::Shape | A::Metric ).value< QskBoxShapeMetrics >();
}
inline void QskSkinHintTable::setBoxBorder(
QskAspect aspect, const QskBoxBorderMetrics& border )
{
using A = QskAspect;
setHint( aspect | A::Border | A::Metric, QVariant::fromValue( border ) );
}
inline QskBoxBorderMetrics QskSkinHintTable::boxBorder( QskAspect aspect ) const
{
using A = QskAspect;
return hint( aspect | A::Border | A::Metric ).value< QskBoxBorderMetrics >();
}
inline void QskSkinHintTable::setBoxBorderColors(
QskAspect aspect, const QskBoxBorderColors& colors )
{
using A = QskAspect;
setHint( aspect | A::Border | A::Color, QVariant::fromValue( colors ) );
}
inline QskBoxBorderColors QskSkinHintTable::boxBorderColors( QskAspect aspect ) const
{
using A = QskAspect;
return hint( aspect | A::Border | A::Color ).value< QskBoxBorderColors >();
}
inline void QskSkinHintTable::setSpacing( QskAspect aspect, qreal spacing )
{
setMetric( aspect | QskAspect::Spacing, spacing );
}
inline qreal QskSkinHintTable::spacing( QskAspect aspect ) const
{
return metric( aspect | QskAspect::Spacing );
}
inline QskAnimationHint QskSkinHintTable::animation( QskAspect aspect ) const
{
aspect.setAnimator( true );
return hint( aspect ).value< QskAnimationHint >();
}
inline void QskSkinHintTable::setGraphicRole( QskAspect aspect, int role )
{
setHint( aspect | QskAspect::GraphicRole, role );
}
inline void QskSkinHintTable::setFontRole( QskAspect aspect, int role )
{
setHint( aspect | QskAspect::FontRole, role );
}
inline void QskSkinHintTable::setAlignment(
QskAspect aspect, Qt::Alignment alignment )
{
setFlagHint( aspect | QskAspect::Alignment, alignment );
}
inline Qt::Alignment QskSkinHintTable::alignment( QskAspect aspect ) const
{
return hint( aspect | QskAspect::Alignment ).value< Qt::Alignment >();
}
inline void QskSkinHintTable::setFlagHint( QskAspect aspect, int flag )
{
setHint( aspect, QVariant( flag ) );
}
inline void QskSkinHintTable::setAnimation(
QskAspect aspect, QskAnimationHint animation )
{
aspect.setAnimator( true );
setHint( aspect, QVariant::fromValue( animation ) );
} }
#endif #endif

324
src/controls/QskSkinHintTableEditor.cpp Normal file
View File

@ -0,0 +1,324 @@
/******************************************************************************
* QSkinny - Copyright (C) 2016 Uwe Rathmann
* This file may be used under the terms of the QSkinny License, Version 1.0
*****************************************************************************/
#include "QskSkinHintTableEditor.h"
#include "QskSkinHintTable.h"
#include "QskMargins.h"
#include "QskBoxShapeMetrics.h"
#include "QskBoxBorderMetrics.h"
#include "QskBoxBorderColors.h"
#include "QskGradient.h"
namespace
{
inline QskAspect aspectStrutSize( QskAspect aspect )
{
return aspect | QskAspect::StrutSize;
}
inline QskAspect aspectMargin( QskAspect aspect )
{
return aspect | QskAspect::Margin;
}
inline QskAspect aspectPadding( QskAspect aspect )
{
return aspect | QskAspect::Padding;
}
inline QskAspect aspectSpacing( QskAspect aspect )
{
return aspect | QskAspect::Spacing;
}
inline QskAspect aspectAlignment( QskAspect aspect )
{
return aspect | QskAspect::Alignment;
}
inline QskAspect aspectFontRole( QskAspect aspect )
{
return aspect | QskAspect::FontRole;
}
inline QskAspect aspectGraphicRole( QskAspect aspect )
{
return aspect | QskAspect::GraphicRole;
}
inline QskAspect aspectShape( QskAspect aspect )
{
return aspect | QskAspect::Shape;
}
inline QskAspect aspectBorder( QskAspect aspect )
{
return aspect | QskAspect::Border;
}
}
QskSkinHintTableEditor::QskSkinHintTableEditor( QskSkinHintTable* table )
: m_table( table )
{
}
void QskSkinHintTableEditor::setTable( QskSkinHintTable* table )
{
m_table = table;
}
QskSkinHintTable* QskSkinHintTableEditor::table() const
{
return m_table;
}
void QskSkinHintTableEditor::setFlag( QskAspect aspect, int flag )
{
setFlagHint( aspect, flag );
}
int QskSkinHintTableEditor::flag( QskAspect aspect ) const
{
return flagHint<int>( aspect );
}
void QskSkinHintTableEditor::setMetric( QskAspect aspect, qreal metric )
{
setMetricHint( aspect, metric );
}
qreal QskSkinHintTableEditor::metric( QskAspect aspect ) const
{
return metricHint<qreal>( aspect );
}
void QskSkinHintTableEditor::setColor( QskAspect aspect, Qt::GlobalColor color )
{
setColorHint( aspect, QColor( color ) );
}
void QskSkinHintTableEditor::setColor( QskAspect aspect, QRgb rgb )
{
setColorHint( aspect, QColor::fromRgba( rgb ) );
}
void QskSkinHintTableEditor::setColor( QskAspect aspect, const QColor& color )
{
setColorHint( aspect, color );
}
QColor QskSkinHintTableEditor::color( QskAspect aspect ) const
{
return colorHint<QColor>( aspect );
}
void QskSkinHintTableEditor::setGradient( QskAspect aspect, const QskGradient& gradient )
{
setColorHint( aspect, gradient );
}
QskGradient QskSkinHintTableEditor::gradient( QskAspect aspect ) const
{
return colorHint<QskGradient>( aspect );
}
void QskSkinHintTableEditor::setStrutSize( QskAspect aspect, const QSizeF& size )
{
setMetricHint( aspect | QskAspect::StrutSize, size );
}
void QskSkinHintTableEditor::setStrutSize( QskAspect aspect, qreal width, qreal height )
{
setMetricHint( aspectStrutSize( aspect ), QSizeF( width, height ) );
}
void QskSkinHintTableEditor::removeStrutSize( QskAspect aspect )
{
removeMetricHint( aspectStrutSize( aspect ) );
}
QSizeF QskSkinHintTableEditor::strutSize( QskAspect aspect ) const
{
return metricHint< QSizeF >( aspectStrutSize( aspect ) );
}
void QskSkinHintTableEditor::setMargin( QskAspect aspect, const QskMargins& margins )
{
setMetricHint( aspectMargin( aspect ), margins );
}
void QskSkinHintTableEditor::setMargin( QskAspect aspect,
qreal left, qreal top, qreal right, qreal bottom )
{
setMetricHint( aspectMargin( aspect ), QskMargins( left, top, right, bottom ) );
}
void QskSkinHintTableEditor::removeMargin( QskAspect aspect )
{
removeMetricHint( aspectMargin( aspect ) );
}
QskMargins QskSkinHintTableEditor::margin( QskAspect aspect ) const
{
return metricHint< QskMargins >( aspectMargin( aspect ) );
}
void QskSkinHintTableEditor::setPadding( QskAspect aspect, const QskMargins& padding )
{
setMetricHint( aspectPadding( aspect ), padding );
}
void QskSkinHintTableEditor::setPadding( QskAspect aspect,
qreal left, qreal top, qreal right, qreal bottom )
{
setMetricHint( aspectPadding( aspect ), QskMargins( left, top, right, bottom ) );
}
void QskSkinHintTableEditor::removePadding( QskAspect aspect )
{
removeMetricHint( aspectPadding( aspect ) );
}
QskMargins QskSkinHintTableEditor::padding( QskAspect aspect ) const
{
return metricHint< QskMargins >( aspectPadding( aspect ) );
}
void QskSkinHintTableEditor::setSpacing( QskAspect aspect, qreal spacing )
{
setMetricHint( aspectSpacing( aspect ), spacing );
}
void QskSkinHintTableEditor::removeSpacing( QskAspect aspect )
{
removeMetricHint( aspectSpacing( aspect ) );
}
qreal QskSkinHintTableEditor::spacing( QskAspect aspect ) const
{
return metricHint< qreal >( aspectSpacing( aspect ) );
}
void QskSkinHintTableEditor::setAlignment( QskAspect aspect, Qt::Alignment alignment )
{
setFlagHint( aspectAlignment( aspect ), static_cast< int >( alignment ) );
}
void QskSkinHintTableEditor::removeAlignment( QskAspect aspect )
{
return removeFlagHint( aspectAlignment( aspect ) );
}
Qt::Alignment QskSkinHintTableEditor::alignment( QskAspect aspect ) const
{
return flagHint< Qt::Alignment >( aspectAlignment( aspect ) );
}
void QskSkinHintTableEditor::setFontRole( QskAspect aspect, int fontRole )
{
setFlagHint( aspectFontRole( aspect ), fontRole );
}
void QskSkinHintTableEditor::removeFontRole( QskAspect aspect )
{
return removeFlagHint( aspectFontRole( aspect ) );
}
int QskSkinHintTableEditor::fontRole( QskAspect aspect ) const
{
return flagHint< int >( aspectFontRole( aspect ) );
}
void QskSkinHintTableEditor::setGraphicRole( QskAspect aspect, int graphicRole )
{
setFlagHint( aspectGraphicRole( aspect ), graphicRole );
}
void QskSkinHintTableEditor::removeGraphicRole( QskAspect aspect )
{
return removeFlagHint( aspectGraphicRole( aspect ) );
}
int QskSkinHintTableEditor::graphicRole( QskAspect aspect ) const
{
return flagHint< int >( aspectGraphicRole( aspect ) );
}
void QskSkinHintTableEditor::setBoxShape(
QskAspect aspect, qreal radius, Qt::SizeMode sizeMode )
{
setMetricHint( aspectShape( aspect ),
QskBoxShapeMetrics( radius, sizeMode ) );
}
void QskSkinHintTableEditor::setBoxShape( QskAspect aspect, qreal topLeft, qreal topRight,
qreal bottomLeft, qreal bottomRight, Qt::SizeMode sizeMode )
{
setMetricHint( aspectShape( aspect ),
QskBoxShapeMetrics( topLeft, topRight, bottomLeft, bottomRight, sizeMode ) );
}
void QskSkinHintTableEditor::setBoxShape(
QskAspect aspect, const QskBoxShapeMetrics& shape )
{
setMetricHint( aspectShape( aspect ), shape );
}
void QskSkinHintTableEditor::removeBoxShape( QskAspect aspect )
{
return removeMetricHint( aspectShape( aspect ) );
}
QskBoxShapeMetrics QskSkinHintTableEditor::boxShape( QskAspect aspect ) const
{
return metricHint< QskBoxShapeMetrics >( aspectShape( aspect ) );
}
void QskSkinHintTableEditor::setBoxBorderMetrics( QskAspect aspect,
qreal borderWidth, Qt::SizeMode sizeMode )
{
setMetricHint( aspectBorder( aspect ),
QskBoxBorderMetrics( borderWidth, sizeMode ) );
}
void QskSkinHintTableEditor::setBoxBorderMetrics( QskAspect aspect,
qreal left, qreal top, qreal right, qreal bottom, Qt::SizeMode sizeMode )
{
setMetricHint( aspectBorder( aspect ),
QskBoxBorderMetrics( left, top, right, bottom, sizeMode ) );
}
void QskSkinHintTableEditor::setBoxBorderMetrics(
QskAspect aspect, const QskBoxBorderMetrics& borderMetrics )
{
setMetricHint( aspectBorder( aspect ), borderMetrics );
}
void QskSkinHintTableEditor::removeBoxBorderMetric( QskAspect aspect )
{
return removeMetricHint( aspectBorder( aspect ) );
}
QskBoxBorderMetrics QskSkinHintTableEditor::boxBorderMetrics( QskAspect aspect ) const
{
return metricHint< QskBoxBorderMetrics >( aspectBorder( aspect ) );
}
void QskSkinHintTableEditor::setBoxBorderColors(
QskAspect aspect, const QskBoxBorderColors& borderColors )
{
setColorHint( aspectBorder( aspect ), borderColors );
}
void QskSkinHintTableEditor::removeBoxBorderColors( QskAspect aspect )
{
return removeColorHint( aspectBorder( aspect ) );
}
QskBoxBorderColors QskSkinHintTableEditor::boxBorderColors( QskAspect aspect ) const
{
return colorHint< QskBoxBorderColors >( aspectBorder( aspect ) );
}

281
src/controls/QskSkinHintTableEditor.h Normal file
View File

@ -0,0 +1,281 @@
/******************************************************************************
* QSkinny - Copyright (C) 2016 Uwe Rathmann
* This file may be used under the terms of the QSkinny License, Version 1.0
*****************************************************************************/
#ifndef QSK_SKIN_HINT_TABLE_EDITOR_H
#define QSK_SKIN_HINT_TABLE_EDITOR_H
#include "QskAspect.h"
#include "QskSkinHintTable.h"
#include "QskAnimationHint.h"
#include <qcolor.h>
#include <qvariant.h>
class QskMargins;
class QskGradient;
class QskBoxShapeMetrics;
class QskBoxBorderMetrics;
class QskBoxBorderColors;
class QSK_EXPORT QskSkinHintTableEditor
{
public:
QskSkinHintTableEditor( QskSkinHintTable* = nullptr );
void setTable( QskSkinHintTable* );
QskSkinHintTable* table() const;
// generic access
void setHint( QskAspect, const QVariant& );
const QVariant& hint( QskAspect ) const;
bool removeHint( QskAspect );
QVariant takeHint( QskAspect );
bool hasHint( QskAspect ) const;
template< typename T > void setHint( QskAspect, const T& );
template< typename T > T hint( QskAspect ) const;
// animation hints
void setAnimation( QskAspect, QskAnimationHint );
QskAnimationHint animation( QskAspect ) const;
// flag/metric/color
void setFlagHint( QskAspect, const QVariant& );
void removeFlagHint( QskAspect );
QVariant flagHint( QskAspect ) const;
template< typename T > void setFlagHint( QskAspect, const T& );
template< typename T > T flagHint( QskAspect ) const;
void setMetricHint( QskAspect, const QVariant& );
void removeMetricHint( QskAspect );
QVariant metricHint( QskAspect ) const;
template< typename T > void setMetricHint( QskAspect, const T& );
template< typename T > T metricHint( QskAspect ) const;
void setColorHint( QskAspect, const QVariant& );
void removeColorHint( QskAspect );
QVariant colorHint( QskAspect ) const;
template< typename T > void setColorHint( QskAspect, const T& );
template< typename T > T colorHint( QskAspect ) const;
// type specific
void setFlag( QskAspect, int );
int flag( QskAspect ) const;
void setMetric( QskAspect, qreal metric );
qreal metric( QskAspect ) const;
void setColor( QskAspect, Qt::GlobalColor );
void setColor( QskAspect, QRgb );
void setColor( QskAspect, const QColor& );
QColor color( QskAspect ) const;
void setGradient( QskAspect, const QskGradient& );
QskGradient gradient( QskAspect ) const;
void setStrutSize( QskAspect, const QSizeF& );
void setStrutSize( QskAspect, qreal width, qreal height );
void removeStrutSize( QskAspect );
QSizeF strutSize( QskAspect ) const;
void setMargin( QskAspect, const QskMargins& );
void setMargin( QskAspect,
qreal left, qreal top, qreal right, qreal bottom );
void removeMargin( QskAspect );
QskMargins margin( QskAspect ) const;
void setPadding( QskAspect, const QskMargins& );
void setPadding( QskAspect,
qreal left, qreal top, qreal right, qreal bottom );
void removePadding( QskAspect );
QskMargins padding( QskAspect ) const;
void setSpacing( QskAspect, qreal );
void removeSpacing( QskAspect );
qreal spacing( QskAspect ) const;
void setAlignment( QskAspect, Qt::Alignment );
void removeAlignment( QskAspect );
Qt::Alignment alignment( QskAspect ) const;
void setFontRole( QskAspect, int );
void removeFontRole( QskAspect );
int fontRole( QskAspect ) const;
void setGraphicRole( QskAspect, int );
void removeGraphicRole( QskAspect );
int graphicRole( QskAspect ) const;
void setBoxShape( QskAspect, qreal radius, Qt::SizeMode = Qt::AbsoluteSize );
void setBoxShape( QskAspect, qreal topLeft, qreal topRight,
qreal bottomLeft, qreal bottomRight, Qt::SizeMode = Qt::AbsoluteSize );
void setBoxShape( QskAspect, const QskBoxShapeMetrics& );
void removeBoxShape( QskAspect );
QskBoxShapeMetrics boxShape( QskAspect ) const;
void setBoxBorderMetrics( QskAspect,
qreal borderWidth, Qt::SizeMode = Qt::AbsoluteSize );
void setBoxBorderMetrics( QskAspect, qreal left, qreal top,
qreal right, qreal bottom, Qt::SizeMode = Qt::AbsoluteSize );
void setBoxBorderMetrics( QskAspect, const QskBoxBorderMetrics& );
void removeBoxBorderMetric( QskAspect );
QskBoxBorderMetrics boxBorderMetrics( QskAspect ) const;
void setBoxBorderColors( QskAspect, const QskBoxBorderColors& );
void removeBoxBorderColors( QskAspect );
QskBoxBorderColors boxBorderColors( QskAspect ) const;
private:
QskSkinHintTable* m_table = nullptr;
};
// --- generic access ---
inline void QskSkinHintTableEditor::setHint( QskAspect aspect, const QVariant& hint )
{
return m_table->setHint( aspect, hint );
}
template< typename T >
inline void QskSkinHintTableEditor::setHint( QskAspect aspect, const T& hint )
{
setHint( aspect, QVariant::fromValue( hint ) );
}
template< typename T >
inline T QskSkinHintTableEditor::hint( QskAspect aspect ) const
{
return hint( aspect ).value< T >();
}
inline const QVariant& QskSkinHintTableEditor::hint( QskAspect aspect ) const
{
return m_table->hint( aspect );
}
inline bool QskSkinHintTableEditor::removeHint( QskAspect aspect )
{
return m_table->removeHint( aspect );
}
inline QVariant QskSkinHintTableEditor::takeHint( QskAspect aspect )
{
return m_table->takeHint( aspect );
}
inline bool QskSkinHintTableEditor::hasHint( QskAspect aspect ) const
{
return m_table->hasHint( aspect );
}
// --- flag ---
inline void QskSkinHintTableEditor::setFlagHint( QskAspect aspect, const QVariant& hint )
{
setHint( aspect | QskAspect::Flag, hint );
}
template< typename T >
inline void QskSkinHintTableEditor::setFlagHint( QskAspect aspect, const T& hint )
{
setHint( aspect | QskAspect::Flag, hint );
}
inline void QskSkinHintTableEditor::removeFlagHint( QskAspect aspect )
{
removeHint( aspect | QskAspect::Flag );
}
inline QVariant QskSkinHintTableEditor::flagHint( QskAspect aspect ) const
{
return hint( aspect | QskAspect::Flag );
}
template< typename T >
inline T QskSkinHintTableEditor::flagHint( QskAspect aspect ) const
{
return hint< T >( aspect | QskAspect::Flag );
}
// --- metric ---
inline void QskSkinHintTableEditor::setMetricHint( QskAspect aspect, const QVariant& hint )
{
setHint( aspect | QskAspect::Metric, hint );
}
template< typename T >
inline void QskSkinHintTableEditor::setMetricHint( QskAspect aspect, const T& hint )
{
setHint( aspect | QskAspect::Metric, hint );
}
inline void QskSkinHintTableEditor::removeMetricHint( QskAspect aspect )
{
removeHint( aspect | QskAspect::Metric );
}
inline QVariant QskSkinHintTableEditor::metricHint( QskAspect aspect ) const
{
return hint( aspect | QskAspect::Metric );
}
template< typename T >
inline T QskSkinHintTableEditor::metricHint( QskAspect aspect ) const
{
return hint< T >( aspect | QskAspect::Metric );
}
// --- color ---
inline void QskSkinHintTableEditor::setColorHint( QskAspect aspect, const QVariant& hint )
{
setHint( aspect | QskAspect::Metric, hint );
}
template< typename T >
inline void QskSkinHintTableEditor::setColorHint( QskAspect aspect, const T& hint )
{
setHint( aspect | QskAspect::Color, hint );
}
inline void QskSkinHintTableEditor::removeColorHint( QskAspect aspect )
{
removeHint( aspect | QskAspect::Color );
}
inline QVariant QskSkinHintTableEditor::colorHint( QskAspect aspect ) const
{
return hint( aspect | QskAspect::Color );
}
template< typename T >
inline T QskSkinHintTableEditor::colorHint( QskAspect aspect ) const
{
return hint< T >( aspect | QskAspect::Color );
}
// --- animation ---
inline QskAnimationHint QskSkinHintTableEditor::animation( QskAspect aspect ) const
{
return m_table->animation( aspect );
}
inline void QskSkinHintTableEditor::setAnimation( QskAspect aspect, QskAnimationHint hint )
{
m_table->setAnimation( aspect, hint );
}
#endif

2
src/src.pro
View File

@ -170,6 +170,7 @@ HEADERS += \
controls/QskSkin.h \ controls/QskSkin.h \
controls/QskSkinFactory.h \ controls/QskSkinFactory.h \
controls/QskSkinHintTable.h \ controls/QskSkinHintTable.h \
controls/QskSkinHintTableEditor.h \
controls/QskSkinManager.h \ controls/QskSkinManager.h \
controls/QskSkinTransition.h \ controls/QskSkinTransition.h \
controls/QskSkinlet.h \ controls/QskSkinlet.h \
@ -242,6 +243,7 @@ SOURCES += \
controls/QskSimpleListBox.cpp \ controls/QskSimpleListBox.cpp \
controls/QskSkin.cpp \ controls/QskSkin.cpp \
controls/QskSkinHintTable.cpp \ controls/QskSkinHintTable.cpp \
controls/QskSkinHintTableEditor.cpp \
controls/QskSkinFactory.cpp \ controls/QskSkinFactory.cpp \
controls/QskSkinManager.cpp \ controls/QskSkinManager.cpp \
controls/QskSkinTransition.cpp \ controls/QskSkinTransition.cpp \