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

QskGradientDirection introduced - no more classes derived from 

QskGradient
This commit is contained in:
Uwe Rathmann 2022-11-13 17:22:09 +01:00
parent a658a2a4e4
commit b140d1b30a
28 changed files with 691 additions and 905 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

16
examples/boxes/Box.cpp
View File

@ -10,9 +10,8 @@
#include <QskBoxShapeMetrics.h> #include <QskBoxShapeMetrics.h>
#include <QskHctColor.h> #include <QskHctColor.h>
#include <QskRgbValue.h> #include <QskRgbValue.h>
#include <QskLinearGradient.h>
static inline void setStartStop( Box::FillType type, QskLinearGradient& gradient ) static inline void setStartStop( Box::FillType type, QskGradient& gradient )
{ {
qreal x1 = 0.0, y1 = 0.0, x2 = 0.0, y2 = 0.0; qreal x1 = 0.0, y1 = 0.0, x2 = 0.0, y2 = 0.0;
@ -22,8 +21,7 @@ static inline void setStartStop( Box::FillType type, QskLinearGradient& gradient
if ( type != Box::Vertical ) if ( type != Box::Vertical )
x2 = 1.0; x2 = 1.0;
gradient.setStart( x1, y1 ); gradient.setLinearDirection( x1, y1, x2, y2 );
gradient.setStop( x2, y2 );
} }
Box::Box( QQuickItem* parentItem ) Box::Box( QQuickItem* parentItem )
@ -46,7 +44,7 @@ void Box::setWebGradient( FillType type, QGradient::Preset preset, bool inverted
return; return;
} }
QskLinearGradient gradient( preset ); QskGradient gradient( preset );
if ( type == Solid ) if ( type == Solid )
{ {
@ -72,7 +70,7 @@ void Box::setTonalGradient( FillType type, const QRgb base, bool inverted )
return; return;
} }
QskLinearGradient gradient; QskGradient gradient;
const QskHctColor htcColor( base ); const QskHctColor htcColor( base );
if ( type == Solid ) if ( type == Solid )
@ -101,7 +99,7 @@ void Box::setTonalPalette( FillType type, const QRgb base )
return; return;
} }
QskLinearGradient gradient; QskGradient gradient;
setStartStop( type, gradient ); setStartStop( type, gradient );
{ {
@ -211,7 +209,7 @@ void Box::setGradient( Qt::GlobalColor color )
void Box::setGradient( const QColor& color ) void Box::setGradient( const QColor& color )
{ {
setPanelGradient( QskLinearGradient( color ) ); setPanelGradient( QskGradient( color ) );
} }
void Box::setGradient( FillType fillType, void Box::setGradient( FillType fillType,
@ -237,7 +235,7 @@ void Box::setGradient( FillType fillType,
void Box::setGradient( FillType fillType, const QskGradientStops& stops ) void Box::setGradient( FillType fillType, const QskGradientStops& stops )
{ {
QskLinearGradient gradient( stops ); QskGradient gradient( stops );
setStartStop( fillType, gradient ); setStartStop( fillType, gradient );
setPanelGradient( gradient ); setPanelGradient( gradient );

7
examples/desktop/main.cpp
View File

@ -7,7 +7,6 @@
#include <SkinnyShortcut.h> #include <SkinnyShortcut.h>
#include <QskAspect.h> #include <QskAspect.h>
#include <QskLinearGradient.h>
#include <QskGraphicLabel.h> #include <QskGraphicLabel.h>
#include <QskObjectCounter.h> #include <QskObjectCounter.h>
#include <QskShortcutMap.h> #include <QskShortcutMap.h>
@ -58,9 +57,11 @@ int main( int argc, char* argv[] )
SkinnyShortcut::enable( SkinnyShortcut::AllShortcuts ); SkinnyShortcut::enable( SkinnyShortcut::AllShortcuts );
QskGradient gradient( QskRgb::DarkSlateGray, QskRgb::LightSlateGray );
gradient.setLinearDirection( 0.0, 0.0, 1.0, 1.0 );
QskSubWindowArea* area = new QskSubWindowArea(); QskSubWindowArea* area = new QskSubWindowArea();
area->setGradientHint( QskSubWindowArea::Panel, area->setGradientHint( QskSubWindowArea::Panel, gradient );
QskLinearGradient( 0.0, 0.0, 1.0, 1.0, QskRgb::DarkSlateGray, QskRgb::LightSlateGray ) );
QRectF windowRect( 0, 0, 250, 250 ); QRectF windowRect( 0, 0, 250, 250 );

8
examples/iotdashboard/Skin.cpp
View File

@ -26,7 +26,6 @@
#include <QskBoxShapeMetrics.h> #include <QskBoxShapeMetrics.h>
#include <QskBoxBorderMetrics.h> #include <QskBoxBorderMetrics.h>
#include <QskBoxBorderColors.h> #include <QskBoxBorderColors.h>
#include <QskLinearGradient.h>
#include <QskFunctions.h> #include <QskFunctions.h>
#include <QskShadowMetrics.h> #include <QskShadowMetrics.h>
#include <QskSkinHintTableEditor.h> #include <QskSkinHintTableEditor.h>
@ -142,8 +141,11 @@ void Skin::initHints( const Palette& palette )
{ {
ed.setBoxShape( subControl, 6 ); ed.setBoxShape( subControl, 6 );
QskLinearGradient normal( Qt::Vertical, 0xff6776ff, 0xff6100ff ); QskGradient normal( 0xff6776ff, 0xff6100ff );
QskLinearGradient bright( Qt::Vertical, 0xffff7d34, 0xffff3122 ); normal.setLinearDirection( Qt::Vertical );
QskGradient bright( 0xffff7d34, 0xffff3122 );
bright.setLinearDirection( Qt::Vertical );
if ( subControl == RoundedIcon::PalePanel ) if ( subControl == RoundedIcon::PalePanel )
{ {

7
playground/dials/SkinFactory.cpp
View File

@ -14,7 +14,6 @@
#include <QskSkin.h> #include <QskSkin.h>
#include <QskPlatform.h> #include <QskPlatform.h>
#include <QskRgbValue.h> #include <QskRgbValue.h>
#include <QskLinearGradient.h>
namespace namespace
{ {
@ -57,8 +56,10 @@ namespace
ed.setBoxBorderMetrics( Q::Knob, 2 ); ed.setBoxBorderMetrics( Q::Knob, 2 );
ed.setStrutSize( Q::Knob, 30, 30 ); ed.setStrutSize( Q::Knob, 30, 30 );
ed.setBoxShape( Q::Knob, 100, Qt::RelativeSize ); ed.setBoxShape( Q::Knob, 100, Qt::RelativeSize );
ed.setGradient( Q::Knob,
QskLinearGradient( 0.0, 0.0, 1.0, 1.0, rgb2, rgb1 ) ); QskGradient gradient( rgb2, rgb1 );
gradient.setLinearDirection( 0.0, 0.0, 1.0, 1.0 );
ed.setGradient( Q::Knob, gradient );
ed.setMetric( Q::Needle | QskAspect::Size, 2 ); ed.setMetric( Q::Needle | QskAspect::Size, 2 );
ed.setMetric( Q::Needle | QskAspect::Margin, 10 ); ed.setMetric( Q::Needle | QskAspect::Margin, 10 );

42
playground/shapes/main.cpp
View File

@ -10,9 +10,7 @@
#include <QskRgbValue.h> #include <QskRgbValue.h>
#include <QskLinearBox.h> #include <QskLinearBox.h>
#include <QskTabView.h> #include <QskTabView.h>
#include <QskLinearGradient.h> #include <QskGradientDirection.h>
#include <QskRadialGradient.h>
#include <QskConicGradient.h>
#include <SkinnyShortcut.h> #include <SkinnyShortcut.h>
#include <SkinnyShapeFactory.h> #include <SkinnyShapeFactory.h>
@ -65,7 +63,8 @@ namespace
shapeItem->setPath( path( SkinnyShapeFactory::Hexagon ) ); shapeItem->setPath( path( SkinnyShapeFactory::Hexagon ) );
shapeItem->setPen( pen( QColorConstants::Svg::indigo ) ); shapeItem->setPen( pen( QColorConstants::Svg::indigo ) );
QskLinearGradient gradient( 0.0, 0.0, 0.2, 0.5, QGradient::PhoenixStart ); QskGradient gradient( QGradient::PhoenixStart );
gradient.setLinearDirection( 0.0, 0.0, 0.2, 0.5 );
gradient.setSpread( QGradient::ReflectSpread ); gradient.setSpread( QGradient::ReflectSpread );
shapeItem->setGradient( gradient ); shapeItem->setGradient( gradient );
@ -78,7 +77,8 @@ namespace
const QVector< QskGradientStop > stops = const QVector< QskGradientStop > stops =
{ { 0.5, QskRgb::RoyalBlue }, { 0.5, QskRgb::LemonChiffon } }; { { 0.5, QskRgb::RoyalBlue }, { 0.5, QskRgb::LemonChiffon } };
QskLinearGradient gradient( 0.0, 0.0, 0.05, 0.1, stops ); QskGradient gradient( stops );
gradient.setLinearDirection( 0.0, 0.0, 0.05, 0.1 );
gradient.setSpread( QGradient::RepeatSpread ); gradient.setSpread( QGradient::RepeatSpread );
shapeItem->setGradient( gradient ); shapeItem->setGradient( gradient );
@ -90,7 +90,8 @@ namespace
const QVector< QskGradientStop > stops = const QVector< QskGradientStop > stops =
{ { 0.5, QskRgb::MediumVioletRed }, { 0.5, QskRgb::Navy } }; { { 0.5, QskRgb::MediumVioletRed }, { 0.5, QskRgb::Navy } };
QskLinearGradient gradient( 0.5, 0.0, 0.5, 0.5, stops ); QskGradient gradient( stops );
gradient.setLinearDirection( 0.5, 0.0, 0.5, 0.5 );
shapeItem->setGradient( gradient ); shapeItem->setGradient( gradient );
} }
@ -109,8 +110,8 @@ namespace
shapeItem->setPath( path( SkinnyShapeFactory::Rectangle ) ); shapeItem->setPath( path( SkinnyShapeFactory::Rectangle ) );
shapeItem->setPen( pen( QColorConstants::Svg::indigo ) ); shapeItem->setPen( pen( QColorConstants::Svg::indigo ) );
QskRadialGradient gradient; QskGradient gradient( QskRgb::LightYellow, QskRgb::MidnightBlue );
gradient.setStops( QskRgb::LightYellow, QskRgb::MidnightBlue ); gradient.setRadialDirection( QskRadialDirection() );
gradient.setSpread( QGradient::PadSpread ); gradient.setSpread( QGradient::PadSpread );
shapeItem->setGradient( gradient ); shapeItem->setGradient( gradient );
@ -134,7 +135,8 @@ namespace
stops += QskGradientStop( 0.8, Qt::darkCyan ); stops += QskGradientStop( 0.8, Qt::darkCyan );
stops += QskGradientStop( 1.0, Qt::darkCyan ); stops += QskGradientStop( 1.0, Qt::darkCyan );
QskRadialGradient gradient( stops ); QskGradient gradient( stops );
gradient.setRadialDirection();
gradient.setSpread( QGradient::PadSpread ); gradient.setSpread( QGradient::PadSpread );
shapeItem->setGradient( gradient ); shapeItem->setGradient( gradient );
@ -145,7 +147,8 @@ namespace
shapeItem->setPath( path( SkinnyShapeFactory::Rectangle ) ); shapeItem->setPath( path( SkinnyShapeFactory::Rectangle ) );
shapeItem->setPen( pen( QskRgb::Indigo ) ); shapeItem->setPen( pen( QskRgb::Indigo ) );
QskRadialGradient gradient( 0.5, 0.7, 0.25, QGradient::LilyMeadow ); QskGradient gradient( QGradient::LilyMeadow );
gradient.setRadialDirection( QskRadialDirection( 0.5, 0.7, 0.25 ) );
gradient.setSpread( QGradient::RepeatSpread ); gradient.setSpread( QGradient::RepeatSpread );
shapeItem->setGradient( gradient ); shapeItem->setGradient( gradient );
@ -156,7 +159,8 @@ namespace
shapeItem->setPath( path( SkinnyShapeFactory::Rectangle ) ); shapeItem->setPath( path( SkinnyShapeFactory::Rectangle ) );
shapeItem->setPen( pen( QskRgb::Indigo ) ); shapeItem->setPen( pen( QskRgb::Indigo ) );
QskRadialGradient gradient( 0.6, 0.4, 0.1, Qt::red, Qt::blue ); QskGradient gradient( Qt::red, Qt::blue );
gradient.setRadialDirection( 0.6, 0.4, 0.1 );
gradient.setSpread( QGradient::ReflectSpread ); gradient.setSpread( QGradient::ReflectSpread );
shapeItem->setGradient( gradient ); shapeItem->setGradient( gradient );
@ -175,9 +179,9 @@ namespace
shapeItem->setPath( path( SkinnyShapeFactory::Ellipse ) ); shapeItem->setPath( path( SkinnyShapeFactory::Ellipse ) );
QskConicGradient gradient( 0.5, 0.5, 30.0, 60.0 ); QskGradient gradient( QGradient::JuicyPeach );
gradient.setConicDirection( 0.5, 0.5, 30.0, 60.0 );
gradient.setSpread( QGradient::ReflectSpread ); gradient.setSpread( QGradient::ReflectSpread );
gradient.setStops( QGradient::JuicyPeach );
shapeItem->setGradient( gradient ); shapeItem->setGradient( gradient );
} }
@ -186,9 +190,9 @@ namespace
shapeItem->setPath( path( SkinnyShapeFactory::TriangleUp ) ); shapeItem->setPath( path( SkinnyShapeFactory::TriangleUp ) );
QskConicGradient gradient( 0.5, 0.5, 30.0, 60.0 ); QskGradient gradient( QGradient::WinterNeva );
gradient.setConicDirection( 0.5, 0.5, 30.0, 60.0 );
gradient.setSpread( QGradient::RepeatSpread ); gradient.setSpread( QGradient::RepeatSpread );
gradient.setStops( QGradient::WinterNeva );
shapeItem->setGradient( gradient ); shapeItem->setGradient( gradient );
} }
@ -197,8 +201,8 @@ namespace
shapeItem->setPath( path( SkinnyShapeFactory::Arc ) ); shapeItem->setPath( path( SkinnyShapeFactory::Arc ) );
QskConicGradient gradient( 0.5, 0.5, 300.0, -240.0 ); QskGradient gradient( QGradient::SpikyNaga );
gradient.setStops( QGradient::SpikyNaga ); gradient.setConicDirection( 0.5, 0.5, 300.0, -240.0 );
shapeItem->setGradient( gradient ); shapeItem->setGradient( gradient );
} }
@ -207,8 +211,8 @@ namespace
shapeItem->setPath( path( SkinnyShapeFactory::Diamond ) ); shapeItem->setPath( path( SkinnyShapeFactory::Diamond ) );
QskConicGradient gradient( 0.5, 0.5, 45.0, 180.0 ); QskGradient gradient( QGradient::FabledSunset );
gradient.setStops( QGradient::FabledSunset ); gradient.setConicDirection( 0.5, 0.5, 45.0, 180.0 );
gradient.setSpread( QGradient::ReflectSpread ); gradient.setSpread( QGradient::ReflectSpread );
shapeItem->setGradient( gradient ); shapeItem->setGradient( gradient );

4
skins/squiek/QskSquiekSkin.cpp
View File

@ -39,7 +39,6 @@
#include <QskBoxBorderMetrics.h> #include <QskBoxBorderMetrics.h>
#include <QskBoxShapeMetrics.h> #include <QskBoxShapeMetrics.h>
#include <QskPlatform.h> #include <QskPlatform.h>
#include <QskLinearGradient.h>
#include <QskMargins.h> #include <QskMargins.h>
#include <QskNamespace.h> #include <QskNamespace.h>
#include <QskRgbValue.h> #include <QskRgbValue.h>
@ -188,7 +187,8 @@ void Editor::setButton( QskAspect aspect, PanelStyle style, qreal border )
#endif #endif
QskBoxBorderColors borderColors; QskBoxBorderColors borderColors;
QskLinearGradient gradient( Qt::Vertical ); QskGradient gradient;
gradient.setLinearDirection( Qt::Vertical );
switch ( style ) switch ( style )
{ {

52
src/common/QskConicGradient.cpp
View File

@ -1,52 +0,0 @@
/******************************************************************************
* QSkinny - Copyright (C) 2016 Uwe Rathmann
* This file may be used under the terms of the QSkinny License, Version 1.0
*****************************************************************************/
#include "QskConicGradient.h"
QskConicGradient::QskConicGradient( qreal cx, qreal cy, qreal startAngle,
const QColor& color1, const QColor& color2 )
: QskConicGradient( cx, cy, startAngle )
{
setStops( color1, color2 );
}
QskConicGradient::QskConicGradient( qreal cx, qreal cy,
qreal startAngle, QGradient::Preset preset )
: QskConicGradient( cx, cy, startAngle )
{
setStops( preset );
}
QskConicGradient::QskConicGradient( qreal cx, qreal cy,
qreal startAngle, const QVector< QskGradientStop >& stops )
: QskConicGradient( cx, cy, startAngle )
{
setStops( stops );
}
inline void QskConicGradient::setCenter( const QPointF& center ) noexcept
{
m_values[0] = center.x();
m_values[1] = center.y();
}
inline void QskConicGradient::setCenter( qreal x, qreal y ) noexcept
{
m_values[0] = x;
m_values[1] = y;
}
inline void QskConicGradient::setStartAngle( qreal degrees ) noexcept
{
m_values[2] = degrees;
}
inline void QskConicGradient::setSpanAngle( qreal degrees ) noexcept
{
m_values[3] = qBound( -360.0, degrees, 360.0 );
}
#include "moc_QskConicGradient.cpp"

110
src/common/QskConicGradient.h
View File

@ -1,110 +0,0 @@
/******************************************************************************
* QSkinny - Copyright (C) 2016 Uwe Rathmann
* This file may be used under the terms of the QSkinny License, Version 1.0
*****************************************************************************/
#ifndef QSK_CONIC_GRADIENT_H
#define QSK_CONIC_GRADIENT_H
#include "QskGradient.h"
class QSK_EXPORT QskConicGradient : public QskGradient
{
Q_GADGET
Q_PROPERTY( QPointF center READ center WRITE setCenter )
Q_PROPERTY( qreal startAngle READ startAngle WRITE setStartAngle )
Q_PROPERTY( qreal spanAngle READ spanAngle WRITE setSpanAngle )
public:
// counter-clockwise
QskConicGradient() noexcept;
QskConicGradient( const QColor&, const QColor& );
QskConicGradient( QGradient::Preset );
QskConicGradient( const QVector< QskGradientStop >& );
QskConicGradient( const QPointF&,
qreal startAngle = 0.0, qreal spanAngle = 360.0 ) noexcept;
QskConicGradient( qreal cx, qreal cy,
qreal startAngle = 0.0, qreal spanAngle = 360.0 ) noexcept;
QskConicGradient( qreal cx, qreal cy, qreal startAngle,
const QColor&, const QColor& );
QskConicGradient( const QPointF&, qreal startAngle,
const QColor&, const QColor& );
QskConicGradient( qreal cx, qreal cy, qreal startAngle, QGradient::Preset );
QskConicGradient( const QPointF&, qreal startAngle, QGradient::Preset );
QskConicGradient( qreal cx, qreal cy, qreal startAngle,
const QVector< QskGradientStop >& );
QskConicGradient( const QPointF&, qreal startAngle,
const QVector< QskGradientStop >& );
QPointF center() const noexcept;
void setCenter(const QPointF& center) noexcept;
void setCenter(qreal x, qreal y) noexcept;
qreal startAngle() const noexcept;
void setStartAngle( qreal ) noexcept;
qreal spanAngle() const noexcept;
void setSpanAngle( qreal ) noexcept;
};
inline QskConicGradient::QskConicGradient() noexcept
: QskConicGradient( Conic, 0.5, 0.5, 0.0, 360.0 )
{
}
inline QskConicGradient::QskConicGradient(
const QPointF& center, qreal startAngle, qreal spanAngle ) noexcept
: QskConicGradient( center.x(), center.y(), startAngle, spanAngle )
{
}
inline QskConicGradient::QskConicGradient(
qreal cx, qreal cy, qreal startAngle, qreal spanAngle ) noexcept
: QskGradient( Conic, cx, cy, startAngle, spanAngle )
{
}
inline QskConicGradient::QskConicGradient( const QPointF& center,
qreal startAngle, const QColor& color1, const QColor& color2 )
: QskConicGradient( center.x(), center.y(), startAngle, color1, color2 )
{
}
inline QskConicGradient::QskConicGradient( const QPointF& center,
qreal startAngle, const QVector< QskGradientStop >& stops )
: QskConicGradient( center.x(), center.y(), startAngle, stops )
{
}
inline QskConicGradient::QskConicGradient( const QPointF& center,
qreal startAngle, QGradient::Preset preset )
: QskConicGradient( center.x(), center.y(), startAngle, preset )
{
}
inline QPointF QskConicGradient::center() const noexcept
{
return QPointF( m_values[0], m_values[1] );
}
inline qreal QskConicGradient::startAngle() const noexcept
{
return m_values[2];
}
inline qreal QskConicGradient::spanAngle() const noexcept
{
return m_values[3];
}
#endif

170
src/common/QskGradient.cpp
View File

@ -5,6 +5,7 @@
#include "QskGradient.h" #include "QskGradient.h"
#include "QskRgbValue.h" #include "QskRgbValue.h"
#include "QskGradientDirection.h"
#include <qvariant.h> #include <qvariant.h>
@ -386,7 +387,104 @@ QskHashValue QskGradient::hash( QskHashValue seed ) const
return hash; return hash;
} }
void QskGradient::setLinear( const QVector< qreal >& params ) void QskGradient::setLinearDirection( Qt::Orientation orientation )
{
setLinearDirection( QskLinearDirection( orientation ) );
}
void QskGradient::setLinearDirection( qreal x1, qreal y1, qreal x2, qreal y2 )
{
setLinearDirection( QskLinearDirection( x1, y1, x2, y2 ) );
}
void QskGradient::setLinearDirection( const QskLinearDirection& direction )
{
m_type = Linear;
m_values[0] = direction.x1();
m_values[1] = direction.y1();
m_values[2] = direction.x2();
m_values[3] = direction.y2();
}
QskLinearDirection QskGradient::linearDirection() const
{
Q_ASSERT( m_type == Linear );
if ( m_type != Linear )
return QskLinearDirection();
return QskLinearDirection( m_values[0], m_values[1], m_values[2], m_values[3] );
}
void QskGradient::setRadialDirection()
{
setRadialDirection( QskRadialDirection() );
}
void QskGradient::setRadialDirection( const qreal x, qreal y, qreal radius )
{
setRadialDirection( QskRadialDirection( x, y, radius ) );
}
void QskGradient::setRadialDirection( const QskRadialDirection& direction )
{
m_type = Radial;
m_values[0] = direction.center().x();
m_values[1] = direction.center().y();
m_values[2] = direction.radius();
m_values[3] = 0.0;
}
QskRadialDirection QskGradient::radialDirection() const
{
Q_ASSERT( m_type == Radial );
if ( m_type != Radial )
return QskRadialDirection();
return QskRadialDirection( m_values[0], m_values[1], m_values[2] );
}
void QskGradient::setConicDirection( qreal x, qreal y )
{
setConicDirection( QskConicDirection( x, y ) );
}
void QskGradient::setConicDirection( qreal x, qreal y,
qreal startAngle, qreal spanAngle )
{
setConicDirection( QskConicDirection( x, y, startAngle, spanAngle ) );
}
void QskGradient::setConicDirection( const QskConicDirection& direction )
{
m_type = Conic;
m_values[0] = direction.center().x();
m_values[1] = direction.center().y();
m_values[2] = direction.startAngle();
m_values[3] = direction.spanAngle();
}
QskConicDirection QskGradient::conicDirection() const
{
Q_ASSERT( m_type == Conic );
if ( m_type != Conic )
return QskConicDirection();
return QskConicDirection( m_values[0], m_values[1], m_values[2], m_values[3] );
}
void QskGradient::resetDirection()
{
m_type = Stops;
m_values[0] = m_values[1] = m_values[2] = m_values[3] = 0.0;
}
void QskGradient::setLinearAsList( const QVector< qreal >& params )
{ {
Q_ASSERT( params.size() == 4 ); Q_ASSERT( params.size() == 4 );
@ -398,13 +496,13 @@ void QskGradient::setLinear( const QVector< qreal >& params )
m_values[3] = params[3]; m_values[3] = params[3];
} }
QVector< qreal > QskGradient::linear() const QVector< qreal > QskGradient::linearAsList() const
{ {
Q_ASSERT( m_type == Linear ); Q_ASSERT( m_type == Linear );
return { m_values[0], m_values[1], m_values[2], m_values[3] }; return { m_values[0], m_values[1], m_values[2], m_values[3] };
} }
void QskGradient::setRadial( const QVector< qreal >& params ) void QskGradient::setRadialAsList( const QVector< qreal >& params )
{ {
Q_ASSERT( params.size() == 3 ); Q_ASSERT( params.size() == 3 );
@ -416,17 +514,17 @@ void QskGradient::setRadial( const QVector< qreal >& params )
m_values[3] = 0.0; m_values[3] = 0.0;
} }
QVector< qreal > QskGradient::radial() const QVector< qreal > QskGradient::radialAsList() const
{ {
Q_ASSERT( m_type == Radial ); Q_ASSERT( m_type == Radial );
return { m_values[0], m_values[1], m_values[2] }; return { m_values[0], m_values[1], m_values[2] };
} }
void QskGradient::setConic( const QVector< qreal >& params ) void QskGradient::setConicAsList( const QVector< qreal >& params )
{ {
Q_ASSERT( params.size() >= 2 && params.size() <= 4 ); Q_ASSERT( params.size() >= 2 && params.size() <= 4 );
m_type = Linear; m_type = Conic;
m_values[0] = params[0]; m_values[0] = params[0];
m_values[1] = params[1]; m_values[1] = params[1];
@ -442,52 +540,12 @@ void QskGradient::setConic( const QVector< qreal >& params )
m_values[2] = 360.0; m_values[2] = 360.0;
} }
QVector< qreal > QskGradient::conic() const QVector< qreal > QskGradient::conicAsList() const
{ {
Q_ASSERT( m_type == Conic ); Q_ASSERT( m_type == Conic );
return { m_values[0], m_values[1], m_values[2], m_values[3] }; return { m_values[0], m_values[1], m_values[2], m_values[3] };
} }
#include "QskLinearGradient.h"
#include "QskRadialGradient.h"
#include "QskConicGradient.h"
QskLinearGradient& QskGradient::asLinearGradient()
{
assert( m_type == QskGradient::Linear );
return *reinterpret_cast< QskLinearGradient* >( this );
}
const QskLinearGradient& QskGradient::asLinearGradient() const
{
assert( m_type == QskGradient::Linear );
return *reinterpret_cast< const QskLinearGradient* >( this );
}
QskRadialGradient& QskGradient::asRadialGradient()
{
assert( m_type == QskGradient::Radial );
return *reinterpret_cast< QskRadialGradient* >( this );
}
const QskRadialGradient& QskGradient::asRadialGradient() const
{
assert( m_type == QskGradient::Radial );
return *reinterpret_cast< const QskRadialGradient* >( this );
}
QskConicGradient& QskGradient::asConicGradient()
{
assert( m_type == QskGradient::Conic );
return *reinterpret_cast< QskConicGradient* >( this );
}
const QskConicGradient& QskGradient::asConicGradient() const
{
assert( m_type == QskGradient::Conic );
return *reinterpret_cast< const QskConicGradient* >( this );
}
#ifndef QT_NO_DEBUG_STREAM #ifndef QT_NO_DEBUG_STREAM
#include <qdebug.h> #include <qdebug.h>
@ -505,9 +563,9 @@ QDebug operator<<( QDebug debug, const QskGradient& gradient )
{ {
debug << "L("; debug << "L(";
const auto& g = gradient.asLinearGradient(); const auto dir = gradient.linearDirection();
debug << g.start().x() << "," << g.start().y() debug << dir.start().x() << "," << dir.start().y()
<< "," << g.stop().x() << "," << g.stop().y() << ")"; << "," << dir.stop().x() << "," << dir.stop().y() << ")";
break; break;
} }
@ -516,10 +574,10 @@ QDebug operator<<( QDebug debug, const QskGradient& gradient )
{ {
debug << "R("; debug << "R(";
const auto& g = gradient.asRadialGradient(); const auto dir = gradient.radialDirection();
debug << g.center().x() << "," << g.center().y() debug << dir.center().x() << "," << dir.center().y()
<< "," << g.radius() << ")"; << "," << dir.radius() << ")";
break; break;
} }
@ -528,10 +586,10 @@ QDebug operator<<( QDebug debug, const QskGradient& gradient )
{ {
debug << "C("; debug << "C(";
const auto& g = gradient.asConicGradient(); const auto dir = gradient.conicDirection();
debug << g.center().x() << "," << g.center().y() debug << dir.center().x() << "," << dir.center().y()
<< ",[" << g.startAngle() << "," << g.spanAngle() << "])"; << ",[" << dir.startAngle() << "," << dir.spanAngle() << "])";
break; break;
} }

83
src/common/QskGradient.h
View File

@ -11,9 +11,9 @@
#include <qbrush.h> #include <qbrush.h>
#include <qmetatype.h> #include <qmetatype.h>
class QskLinearGradient; class QskLinearDirection;
class QskRadialGradient; class QskRadialDirection;
class QskConicGradient; class QskConicDirection;
class QVariant; class QVariant;
@ -28,10 +28,6 @@ class QSK_EXPORT QskGradient
Q_PROPERTY( Type type READ type ) Q_PROPERTY( Type type READ type )
Q_PROPERTY( QVector< qreal > linear READ linear WRITE setLinear )
Q_PROPERTY( QVector< qreal > conic READ linear WRITE setConic )
Q_PROPERTY( QVector< qreal > radial READ radial WRITE setRadial )
Q_PROPERTY( QVector< QskGradientStop > stops READ stops WRITE setStops ) Q_PROPERTY( QVector< QskGradientStop > stops READ stops WRITE setStops )
Q_PROPERTY( bool valid READ isValid ) Q_PROPERTY( bool valid READ isValid )
@ -71,6 +67,24 @@ class QSK_EXPORT QskGradient
QskGradient::Type type() const noexcept; QskGradient::Type type() const noexcept;
void setLinearDirection( const QskLinearDirection& );
void setLinearDirection( qreal, qreal, qreal, qreal );
void setLinearDirection( Qt::Orientation );
QskLinearDirection linearDirection() const;
void setRadialDirection( const QskRadialDirection& );
void setRadialDirection( const qreal x, qreal y, qreal radius );
void setRadialDirection();
QskRadialDirection radialDirection() const;
void setConicDirection( qreal, qreal );
void setConicDirection( qreal, qreal, qreal, qreal = 360.0 );
void setConicDirection( const QskConicDirection& );
QskConicDirection conicDirection() const;
void resetDirection();
bool isValid() const noexcept; bool isValid() const noexcept;
bool isMonochrome() const noexcept; bool isMonochrome() const noexcept;
bool isVisible() const noexcept; bool isVisible() const noexcept;
@ -112,35 +126,32 @@ class QSK_EXPORT QskGradient
int stepCount() const noexcept; int stepCount() const noexcept;
QskLinearGradient& asLinearGradient();
const QskLinearGradient& asLinearGradient() const;
QskRadialGradient& asRadialGradient();
const QskRadialGradient& asRadialGradient() const;
QskConicGradient& asConicGradient();
const QskConicGradient& asConicGradient() const;
private: private:
friend class QskLinearGradient;
friend class QskRadialGradient;
friend class QskConicGradient;
QskGradient( Type ) noexcept;
QskGradient( Type, qreal, qreal, qreal, qreal ) noexcept;
void updateStatusBits() const; void updateStatusBits() const;
private: private:
// for QML
QVector< qreal > linear() const;
void setLinear( const QVector< qreal >& );
QVector< qreal > radial() const; #if 1
void setRadial( const QVector< qreal >& ); /*
Couldn't find a way how to assign a struct to another struct
that is used as proprty from QML without creating extra QObjects.
So for the moment we are using lists, that are more
error prone and less intuitive. Let's see if some day we will have
the QML system being capable of this. TODO ...
*/
Q_PROPERTY( QVector< qreal > linear READ linearAsList WRITE setLinearAsList )
Q_PROPERTY( QVector< qreal > conic READ conicAsList WRITE setConicAsList )
Q_PROPERTY( QVector< qreal > radial READ radialAsList WRITE setRadialAsList )
QVector< qreal > conic() const; QVector< qreal > linearAsList() const;
void setConic( const QVector< qreal >& ); void setLinearAsList( const QVector< qreal >& );
QVector< qreal > radialAsList() const;
void setRadialAsList( const QVector< qreal >& );
QVector< qreal > conicAsList() const;
void setConicAsList( const QVector< qreal >& );
#endif
private: private:
QVector< QskGradientStop > m_stops; QVector< QskGradientStop > m_stops;
@ -163,18 +174,6 @@ class QSK_EXPORT QskGradient
Q_DECLARE_METATYPE( QskGradient ) Q_DECLARE_METATYPE( QskGradient )
inline QskGradient::QskGradient( QskGradient::Type type ) noexcept
: m_type( type )
{
}
inline QskGradient::QskGradient( QskGradient::Type type,
qreal v1, qreal v2, qreal v3, qreal v4 ) noexcept
: m_values{ v1, v2, v3, v4 }
, m_type( type )
{
}
inline QskGradient::QskGradient( Qt::GlobalColor color ) inline QskGradient::QskGradient( Qt::GlobalColor color )
: QskGradient( QColor( color ) ) : QskGradient( QColor( color ) )
{ {

121
src/common/QskGradientDirection.cpp Normal file
View File

@ -0,0 +1,121 @@
/******************************************************************************
* QSkinny - Copyright (C) 2016 Uwe Rathmann
* This file may be used under the terms of the QSkinny License, Version 1.0
*****************************************************************************/
#include "QskGradientDirection.h"
// -- QskLinearDirection
void QskLinearDirection::setOrientation( Qt::Orientation orientation ) noexcept
{
setStart( 0.0, 0.0 );
if ( orientation == Qt::Vertical )
setStop( 0.0, 1.0 );
else
setStop( 1.0, 0.0 );
}
void QskLinearDirection::setStart( const QPointF& pos ) noexcept
{
m_x1 = pos.x();
m_y1 = pos.y();
}
void QskLinearDirection::setStart( qreal x, qreal y ) noexcept
{
m_x1 = x;
m_y1 = y;
}
void QskLinearDirection::setStop( const QPointF& pos ) noexcept
{
m_x2 = pos.x();
m_y2 = pos.y();
}
void QskLinearDirection::setStop( qreal x, qreal y ) noexcept
{
m_x2 = x;
m_y2 = y;
}
void QskLinearDirection::setX1( qreal x ) noexcept
{
m_x1 = x;
}
void QskLinearDirection::setY1( qreal y ) noexcept
{
m_y1 = y;
}
void QskLinearDirection::setX2( qreal x ) noexcept
{
m_x2 = x;
}
void QskLinearDirection::setY2( qreal y ) noexcept
{
m_y2 = y;
}
void QskLinearDirection::setInterval( Qt::Orientation orientation, qreal from, qreal to )
{
if ( orientation == Qt::Vertical )
{
m_y1 = from;
m_y2 = to;
}
else
{
m_x1 = from;
m_x2 = to;
}
}
// -- QskConicDirection
void QskConicDirection::setCenter( const QPointF& center ) noexcept
{
m_x = center.x();
m_y = center.y();
}
void QskConicDirection::setCenter( qreal x, qreal y ) noexcept
{
m_x = x;
m_y = y;
}
void QskConicDirection::setStartAngle( qreal degrees ) noexcept
{
m_startAngle = degrees;
}
void QskConicDirection::setSpanAngle( qreal degrees ) noexcept
{
m_spanAngle = qBound( -360.0, degrees, 360.0 );
}
// -- QskRadialDirection
void QskRadialDirection::setCenter( const QPointF& center ) noexcept
{
m_x = center.x();
m_y = center.y();
}
void QskRadialDirection::setCenter( qreal x, qreal y ) noexcept
{
m_x = x;
m_y = y;
}
void QskRadialDirection::setRadius( qreal radius ) noexcept
{
m_radius = radius;
}
#include "moc_QskGradientDirection.cpp"

269
src/common/QskGradientDirection.h Normal file
View File

@ -0,0 +1,269 @@
/******************************************************************************
* QSkinny - Copyright (C) 2016 Uwe Rathmann
* This file may be used under the terms of the QSkinny License, Version 1.0
*****************************************************************************/
#ifndef QSK_GRDIENT_DIRECTION_H
#define QSK_GRDIENT_DIRECTION_H
#include "QskGlobal.h"
#include <qmetatype.h>
#include <qpoint.h>
class QSK_EXPORT QskLinearDirection
{
Q_GADGET
Q_PROPERTY( qreal x1 READ x1 WRITE setX1 )
Q_PROPERTY( qreal y1 READ y1 WRITE setY1 )
Q_PROPERTY( qreal x2 READ x2 WRITE setX2 )
Q_PROPERTY( qreal y2 READ y2 WRITE setY2 )
public:
constexpr QskLinearDirection() noexcept = default;
constexpr QskLinearDirection( Qt::Orientation ) noexcept;
constexpr QskLinearDirection( const QPointF&, const QPointF& ) noexcept;
constexpr QskLinearDirection( qreal x1, qreal y1, qreal x2, qreal y2 ) noexcept;
void setStart( const QPointF& ) noexcept;
void setStart( qreal x, qreal y ) noexcept;
void setStop(const QPointF& ) noexcept;
void setStop( qreal x, qreal y ) noexcept;
void setInterval( Qt::Orientation, qreal, qreal );
void setOrientation( Qt::Orientation ) noexcept;
constexpr bool isOriented( Qt::Orientation ) const noexcept;
constexpr bool isHorizontal() const noexcept;
constexpr bool isVertical() const noexcept;
constexpr bool isTilted() const noexcept;
constexpr QPointF start() const noexcept;
constexpr QPointF stop() const noexcept;
constexpr qreal x1() const noexcept;
void setX1( qreal ) noexcept;
constexpr qreal y1() const noexcept;
void setY1( qreal ) noexcept;
constexpr qreal x2() const noexcept;
void setX2( qreal ) noexcept;
constexpr qreal y2() const noexcept;
void setY2( qreal ) noexcept;
private:
qreal m_x1 = 0.0;
qreal m_y1 = 0.0;
qreal m_x2 = 0.0;
qreal m_y2 = 1.0;
};
class QSK_EXPORT QskConicDirection
{
Q_GADGET
Q_PROPERTY( QPointF center READ center WRITE setCenter )
Q_PROPERTY( qreal startAngle READ startAngle WRITE setStartAngle )
Q_PROPERTY( qreal spanAngle READ spanAngle WRITE setSpanAngle )
public:
// counter-clockwise
constexpr QskConicDirection() noexcept = default;
constexpr QskConicDirection( qreal x, qreal y, qreal startAngle = 0.0 ) noexcept;
constexpr QskConicDirection( qreal x, qreal y, qreal startAngle, qreal spanAngle ) noexcept;
constexpr QskConicDirection( const QPointF&, qreal startAngle = 0.0 ) noexcept;
constexpr QskConicDirection( const QPointF&, qreal startAngle, qreal spanAngle ) noexcept;
constexpr QPointF center() const noexcept;
void setCenter(const QPointF& center) noexcept;
void setCenter(qreal x, qreal y) noexcept;
constexpr qreal startAngle() const noexcept;
void setStartAngle( qreal ) noexcept;
constexpr qreal spanAngle() const noexcept;
void setSpanAngle( qreal ) noexcept;
private:
qreal m_x = 0.5;
qreal m_y = 0.5;
qreal m_startAngle = 0.0;
qreal m_spanAngle = 360.0;
};
class QSK_EXPORT QskRadialDirection
{
Q_GADGET
Q_PROPERTY( QPointF center READ center WRITE setCenter )
Q_PROPERTY( qreal radius READ radius WRITE setRadius )
public:
constexpr QskRadialDirection() noexcept = default;
constexpr QskRadialDirection( const QPointF& center, qreal radius ) noexcept;
constexpr QskRadialDirection( qreal cx, qreal cy, qreal radius ) noexcept;
constexpr QPointF center() const noexcept;
void setCenter(const QPointF& center) noexcept;
void setCenter(qreal x, qreal y) noexcept;
constexpr qreal radius() const noexcept;
void setRadius( qreal radius ) noexcept;
private:
qreal m_x = 0.5;
qreal m_y = 0.5;
qreal m_radius = 0.5;
};
inline constexpr QskLinearDirection::QskLinearDirection(
Qt::Orientation orientation ) noexcept
: m_x2( ( orientation == Qt::Vertical ) ? 0.0 : 1.0 )
, m_y2( ( orientation == Qt::Vertical ) ? 1.0 : 0.0 )
{
}
inline constexpr QskLinearDirection::QskLinearDirection(
const QPointF& start, const QPointF& stop ) noexcept
: QskLinearDirection( start.x(), start.y(), stop.x(), stop.y() )
{
}
inline constexpr QskLinearDirection::QskLinearDirection(
qreal x1, qreal y1, qreal x2, qreal y2 ) noexcept
: m_x1( x1 )
, m_y1( y1 )
, m_x2( x2 )
, m_y2( y2 )
{
}
inline constexpr qreal QskLinearDirection::x1() const noexcept
{
return m_x1;
}
inline constexpr qreal QskLinearDirection::y1() const noexcept
{
return m_y1;
}
inline constexpr qreal QskLinearDirection::x2() const noexcept
{
return m_x2;
}
inline constexpr qreal QskLinearDirection::y2() const noexcept
{
return m_y2;
}
inline constexpr QPointF QskLinearDirection::start() const noexcept
{
return QPointF( m_x1, m_y1 );
}
inline constexpr QPointF QskLinearDirection::stop() const noexcept
{
return QPointF( m_x2, m_y2 );
}
inline constexpr bool QskLinearDirection::isOriented(
Qt::Orientation orientation ) const noexcept
{
return ( orientation == Qt::Horizontal )
? isHorizontal() : isVertical();
}
inline constexpr bool QskLinearDirection::isHorizontal() const noexcept
{
return !isVertical() && ( m_y1 == m_y2 );
}
inline constexpr bool QskLinearDirection::isVertical() const noexcept
{
return m_x1 == m_x2;
}
inline constexpr bool QskLinearDirection::isTilted() const noexcept
{
return ( m_x1 != m_x2 ) && ( m_y1 != m_y2 );
}
inline constexpr QskConicDirection::QskConicDirection(
qreal x, qreal y, qreal startAngle ) noexcept
: QskConicDirection( x, y, startAngle, 360.0 )
{
}
inline constexpr QskConicDirection::QskConicDirection(
qreal x, qreal y, qreal startAngle, qreal spanAngle ) noexcept
: m_x( x )
, m_y( y )
, m_startAngle( startAngle )
, m_spanAngle( spanAngle )
{
}
inline constexpr QskConicDirection::QskConicDirection(
const QPointF& pos, qreal startAngle ) noexcept
: QskConicDirection( pos.x(), pos.y(), startAngle )
{
}
inline constexpr QskConicDirection::QskConicDirection(
const QPointF& pos, qreal startAngle, qreal spanAngle ) noexcept
: QskConicDirection( pos.x(), pos.y(), startAngle, spanAngle )
{
}
inline constexpr QPointF QskConicDirection::center() const noexcept
{
return QPointF( m_x, m_y );
}
inline constexpr qreal QskConicDirection::startAngle() const noexcept
{
return m_startAngle;
}
inline constexpr qreal QskConicDirection::spanAngle() const noexcept
{
return m_spanAngle;
}
inline constexpr QskRadialDirection::QskRadialDirection(
qreal x, qreal y, qreal radius ) noexcept
: m_x( x )
, m_y( y )
, m_radius( radius )
{
}
inline constexpr QskRadialDirection::QskRadialDirection(
const QPointF& center, qreal radius ) noexcept
: QskRadialDirection( center.x(), center.y(), radius )
{
}
inline constexpr QPointF QskRadialDirection::center() const noexcept
{
return QPointF( m_x, m_y );
}
inline constexpr qreal QskRadialDirection::radius() const noexcept
{
return m_radius;
}
#endif

155
src/common/QskLinearGradient.cpp
View File

@ -1,155 +0,0 @@
/******************************************************************************
* QSkinny - Copyright (C) 2016 Uwe Rathmann
* This file may be used under the terms of the QSkinny License, Version 1.0
*****************************************************************************/
#include "QskLinearGradient.h"
QskLinearGradient::QskLinearGradient( Qt::Orientation orientation ) noexcept
: QskGradient( QskGradient::Linear )
{
setOrientation( orientation );
}
QskLinearGradient::QskLinearGradient( const QColor& color )
: QskLinearGradient( Qt::Vertical )
{
setStops( color );
}
QskLinearGradient::QskLinearGradient(
const QColor& startColor, const QColor& stopColor )
: QskLinearGradient( Qt::Vertical )
{
setStops( startColor, stopColor );
}
QskLinearGradient::QskLinearGradient( QGradient::Preset preset )
: QskLinearGradient( Qt::Vertical )
{
setStops( preset );
}
QskLinearGradient::QskLinearGradient( const QVector< QskGradientStop >& stops )
: QskLinearGradient( Qt::Vertical )
{
setStops( stops );
}
QskLinearGradient::QskLinearGradient( Qt::Orientation orientation, const QColor& color )
: QskLinearGradient( orientation )
{
setStops( color );
}
QskLinearGradient::QskLinearGradient( Qt::Orientation orientation,
const QColor& startColor, const QColor& stopColor )
: QskLinearGradient( orientation )
{
setStops( startColor, stopColor );
}
QskLinearGradient::QskLinearGradient(
Qt::Orientation orientation, QGradient::Preset preset )
: QskLinearGradient( orientation )
{
setStops( preset );
}
QskLinearGradient::QskLinearGradient(
Qt::Orientation orientation, const QVector< QskGradientStop >& stops )
: QskLinearGradient( orientation )
{
setStops( stops );
}
void QskLinearGradient::setOrientation( Qt::Orientation orientation ) noexcept
{
setStart( 0.0, 0.0 );
if ( orientation == Qt::Vertical )
setStop( 0.0, 1.0 );
else
setStop( 1.0, 0.0 );
}
QskLinearGradient::QskLinearGradient( qreal x1, qreal y1,
qreal x2, qreal y2, const QColor& color1, const QColor& color2 )
: QskLinearGradient( x1, y1, x2, y2 )
{
setStops( color1, color2 );
}
QskLinearGradient::QskLinearGradient( qreal x1, qreal y1,
qreal x2, qreal y2, QGradient::Preset preset )
: QskLinearGradient( x1, y1, x2, y2 )
{
setStops( preset );
}
QskLinearGradient::QskLinearGradient( qreal x1, qreal y1,
qreal x2, qreal y2, const QVector< QskGradientStop >& stops )
: QskLinearGradient( x1, y1, x2, y2 )
{
setStops( stops );
}
void QskLinearGradient::setStart( const QPointF& pos ) noexcept
{
m_values[0] = pos.x();
m_values[1] = pos.y();
}
void QskLinearGradient::setStart( qreal x, qreal y ) noexcept
{
m_values[0] = x;
m_values[1] = y;
}
void QskLinearGradient::setStop( const QPointF& pos ) noexcept
{
m_values[2] = pos.x();
m_values[3] = pos.y();
}
void QskLinearGradient::setStop( qreal x, qreal y ) noexcept
{
m_values[2] = x;
m_values[3] = y;
}
void QskLinearGradient::setX1( qreal x ) noexcept
{
m_values[0] = x;
}
void QskLinearGradient::setY1( qreal y ) noexcept
{
m_values[1] = y;
}
void QskLinearGradient::setX2( qreal x ) noexcept
{
m_values[2] = x;
}
void QskLinearGradient::setY2( qreal y ) noexcept
{
m_values[3] = y;
}
void QskLinearGradient::setInterval( Qt::Orientation orientation, qreal from, qreal to )
{
if ( orientation == Qt::Vertical )
{
m_values[1] = from;
m_values[3] = to;
}
else
{
m_values[0] = from;
m_values[2] = to;
}
}
#include "moc_QskLinearGradient.cpp"

200
src/common/QskLinearGradient.h
View File

@ -1,200 +0,0 @@
/******************************************************************************
* QSkinny - Copyright (C) 2016 Uwe Rathmann
* This file may be used under the terms of the QSkinny License, Version 1.0
*****************************************************************************/
#ifndef QSK_LINEAR_GRADIENT_H
#define QSK_LINEAR_GRADIENT_H
#include "QskGradient.h"
class QSK_EXPORT QskLinearGradient : public QskGradient
{
Q_GADGET
Q_PROPERTY( qreal x1 READ x1 WRITE setX1 )
Q_PROPERTY( qreal y1 READ y1 WRITE setY1 )
Q_PROPERTY( qreal x2 READ x2 WRITE setX2 )
Q_PROPERTY( qreal y2 READ y2 WRITE setY2 )
public:
QskLinearGradient() noexcept;
QskLinearGradient( Qt::GlobalColor );
QskLinearGradient( QRgb );
QskLinearGradient( const QColor& );
QskLinearGradient( const QColor&, const QColor& );
QskLinearGradient( QGradient::Preset );
QskLinearGradient( const QVector< QskGradientStop >& );
QskLinearGradient( Qt::Orientation ) noexcept;
QskLinearGradient( Qt::Orientation, Qt::GlobalColor );
QskLinearGradient( Qt::Orientation, QRgb );
QskLinearGradient( Qt::Orientation, const QColor& );
QskLinearGradient( Qt::Orientation, const QColor&, const QColor& );
QskLinearGradient( Qt::Orientation, QGradient::Preset );
QskLinearGradient( Qt::Orientation, const QVector< QskGradientStop >& );
QskLinearGradient( const QPointF&, const QPointF& ) noexcept;
QskLinearGradient( qreal x1, qreal y1, qreal x2, qreal y2 ) noexcept;
QskLinearGradient( const QPointF&, const QPointF&,
const QColor&, const QColor& );
QskLinearGradient( qreal x1, qreal y1,
qreal x2, qreal y2, const QColor&, const QColor& );
QskLinearGradient( const QPointF&, const QPointF&, QGradient::Preset );
QskLinearGradient( qreal x1, qreal y1,
qreal x2, qreal y2, QGradient::Preset );
QskLinearGradient( const QPointF&, const QPointF&,
const QVector< QskGradientStop >& );
QskLinearGradient( qreal x1, qreal y1,
qreal x2, qreal y2, const QVector< QskGradientStop >& );
void setStart(const QPointF& start) noexcept;
void setStart( qreal x, qreal y ) noexcept;
void setStop(const QPointF& start) noexcept;
void setStop( qreal x, qreal y ) noexcept;
void setInterval( Qt::Orientation, qreal, qreal );
void setOrientation( Qt::Orientation ) noexcept;
bool isOriented( Qt::Orientation ) const noexcept;
bool isHorizontal() const noexcept;
bool isVertical() const noexcept;
bool isTilted() const noexcept;
QPointF start() const noexcept;
QPointF stop() const noexcept;
qreal x1() const noexcept;
void setX1( qreal ) noexcept;
qreal y1() const noexcept;
void setY1( qreal ) noexcept;
qreal x2() const noexcept;
void setX2( qreal ) noexcept;
qreal y2() const noexcept;
void setY2( qreal ) noexcept;
};
inline QskLinearGradient::QskLinearGradient() noexcept
: QskGradient( QskGradient::Linear, 0.0, 0.0, 0.0, 1.0 )
{
}
inline QskLinearGradient::QskLinearGradient( Qt::GlobalColor color )
: QskLinearGradient( QColor( color ) )
{
}
inline QskLinearGradient::QskLinearGradient( QRgb rgb )
: QskLinearGradient( QColor::fromRgba( rgb ) )
{
}
inline QskLinearGradient::QskLinearGradient(
Qt::Orientation orientation, Qt::GlobalColor color )
: QskLinearGradient( orientation, QColor( color ) )
{
}
inline QskLinearGradient::QskLinearGradient(
Qt::Orientation orientation, QRgb rgb )
: QskLinearGradient( orientation, QColor::fromRgba( rgb ) )
{
}
inline QskLinearGradient::QskLinearGradient(
const QPointF& start, const QPointF& stop,
const QColor& color1, const QColor& color2 )
: QskLinearGradient( start.x(), start.y(), stop.x(), stop.y(), color1, color2 )
{
}
inline QskLinearGradient::QskLinearGradient(
const QPointF& start, const QPointF& stop, QGradient::Preset preset )
: QskLinearGradient( start.x(), start.y(), stop.x(), stop.y(), preset )
{
}
inline QskLinearGradient::QskLinearGradient(
const QPointF& start, const QPointF& stop,
const QVector< QskGradientStop >& stops )
: QskLinearGradient( start.x(), start.y(), stop.x(), stop.y(), stops )
{
}
inline QskLinearGradient::QskLinearGradient(
const QPointF& start, const QPointF& stop ) noexcept
: QskLinearGradient( start.x(), start.y(), stop.x(), stop.y() )
{
}
inline QskLinearGradient::QskLinearGradient(
qreal x1, qreal y1, qreal x2, qreal y2 ) noexcept
: QskGradient( QskGradient::Linear, x1, y1, x2, y2 )
{
}
inline qreal QskLinearGradient::x1() const noexcept
{
return m_values[0];
}
inline qreal QskLinearGradient::y1() const noexcept
{
return m_values[1];
}
inline qreal QskLinearGradient::x2() const noexcept
{
return m_values[2];
}
inline qreal QskLinearGradient::y2() const noexcept
{
return m_values[3];
}
inline QPointF QskLinearGradient::start() const noexcept
{
return QPointF( x1(), y1() );
}
inline QPointF QskLinearGradient::stop() const noexcept
{
return QPointF( x2(), y2() );
}
inline bool QskLinearGradient::isOriented(
Qt::Orientation orientation ) const noexcept
{
return ( orientation == Qt::Horizontal )
? isHorizontal() : isVertical();
}
inline bool QskLinearGradient::isHorizontal() const noexcept
{
return !isVertical() && ( y1() == y2() );
}
inline bool QskLinearGradient::isVertical() const noexcept
{
return x1() == x2();
}
inline bool QskLinearGradient::isTilted() const noexcept
{
return ( x1() != x2() ) && ( y1() != y2() );
}
#endif

69
src/common/QskRadialGradient.cpp
View File

@ -1,69 +0,0 @@
/******************************************************************************
* QSkinny - Copyright (C) 2016 Uwe Rathmann
* This file may be used under the terms of the QSkinny License, Version 1.0
*****************************************************************************/
#include "QskRadialGradient.h"
QskRadialGradient::QskRadialGradient( qreal cx, qreal cy, qreal radius ) noexcept
: QskGradient( Radial, cx, cy, radius, 0.0 )
{
}
QskRadialGradient::QskRadialGradient( const QColor& color1, const QColor& color2 )
: QskRadialGradient()
{
setStops( color1, color2 );
}
QskRadialGradient::QskRadialGradient( QGradient::Preset preset )
: QskRadialGradient()
{
setStops( preset );
}
QskRadialGradient::QskRadialGradient( const QVector< QskGradientStop >& stops )
: QskRadialGradient()
{
setStops( stops );
}
QskRadialGradient::QskRadialGradient( qreal cx, qreal cy, qreal radius,
const QColor& color1, const QColor& color2 )
: QskRadialGradient( cx, cy, radius )
{
setStops( color1, color2 );
}
QskRadialGradient::QskRadialGradient( qreal cx, qreal cy,
qreal radius, QGradient::Preset preset )
: QskRadialGradient( cx, cy, radius )
{
setStops( preset );
}
QskRadialGradient::QskRadialGradient( qreal cx, qreal cy,
qreal radius, const QVector< QskGradientStop >& stops )
: QskRadialGradient( cx, cy, radius )
{
setStops( stops );
}
void QskRadialGradient::setCenter( const QPointF& center ) noexcept
{
m_values[0] = center.x();
m_values[1] = center.y();
}
void QskRadialGradient::setCenter( qreal x, qreal y ) noexcept
{
m_values[0] = x;
m_values[1] = y;
}
void QskRadialGradient::setRadius( qreal radius ) noexcept
{
m_values[2] = radius;
}
#include "moc_QskRadialGradient.cpp"

90
src/common/QskRadialGradient.h
View File

@ -1,90 +0,0 @@
/******************************************************************************
* QSkinny - Copyright (C) 2016 Uwe Rathmann
* This file may be used under the terms of the QSkinny License, Version 1.0
*****************************************************************************/
#ifndef QSK_RADIAL_GRADIENT_H
#define QSK_RADIAL_GRADIENT_H
#include "QskGradient.h"
class QSK_EXPORT QskRadialGradient : public QskGradient
{
Q_GADGET
Q_PROPERTY( QPointF center READ center WRITE setCenter )
Q_PROPERTY( qreal radius READ radius WRITE setRadius )
public:
QskRadialGradient() noexcept;
QskRadialGradient( const QColor&, const QColor& );
QskRadialGradient( QGradient::Preset );
QskRadialGradient( const QVector< QskGradientStop >& );
QskRadialGradient( const QPointF& center, qreal radius ) noexcept;
QskRadialGradient( qreal cx, qreal cy, qreal radius ) noexcept;
QskRadialGradient( const QPointF& center, qreal radius,
const QColor&, const QColor& );
QskRadialGradient( qreal cx, qreal cy, qreal radius,
const QColor&, const QColor& );
QskRadialGradient( const QPointF& center, qreal radius, QGradient::Preset );
QskRadialGradient( qreal cx, qreal cy, qreal radius, QGradient::Preset );
QskRadialGradient( const QPointF& center, qreal radius,
const QVector< QskGradientStop >& );
QskRadialGradient( qreal cx, qreal cy, qreal radius,
const QVector< QskGradientStop >& );
QPointF center() const noexcept;
void setCenter(const QPointF& center) noexcept;
void setCenter(qreal x, qreal y) noexcept;
qreal radius() const noexcept;
void setRadius( qreal radius ) noexcept;
};
inline QskRadialGradient::QskRadialGradient() noexcept
: QskGradient( Radial, 0.5, 0.5, 0.5, 0.0 )
{
}
inline QskRadialGradient::QskRadialGradient(
const QPointF& center, qreal radius ) noexcept
: QskRadialGradient( center.x(), center.y(), radius )
{
}
inline QskRadialGradient::QskRadialGradient(
const QPointF& center, qreal radius, const QColor& start, const QColor& stop )
: QskRadialGradient( center.x(), center.y(), radius, start, stop )
{
}
inline QskRadialGradient::QskRadialGradient(
const QPointF& center, qreal radius, QGradient::Preset preset )
: QskRadialGradient( center.x(), center.y(), radius, preset )
{
}
inline QskRadialGradient::QskRadialGradient(
const QPointF& center, qreal radius, const QVector< QskGradientStop >& stops )
: QskRadialGradient( center.x(), center.y(), radius, stops )
{
}
inline QPointF QskRadialGradient::center() const noexcept
{
return QPointF( m_values[0], m_values[1] );
}
inline qreal QskRadialGradient::radius() const noexcept
{
return m_values[2];
}
#endif

3
src/controls/QskMenuSkinlet.cpp
View File

@ -14,7 +14,6 @@
#include "QskFunctions.h" #include "QskFunctions.h"
#include "QskMargins.h" #include "QskMargins.h"
#include "QskFunctions.h" #include "QskFunctions.h"
#include "QskLinearGradient.h"
#include <qfontmetrics.h> #include <qfontmetrics.h>
#include <qmath.h> #include <qmath.h>
@ -534,7 +533,7 @@ QSGNode* QskMenuSkinlet::updateSampleNode( const QskSkinnable* skinnable,
{ {
auto gradient = menu->gradientHint( subControl ); auto gradient = menu->gradientHint( subControl );
if ( ( gradient.type() == QskGradient::Stops ) && !gradient.isMonochrome() ) if ( ( gradient.type() == QskGradient::Stops ) && !gradient.isMonochrome() )
gradient = QskLinearGradient( Qt::Vertical, gradient.stops() ); gradient.setLinearDirection( Qt::Vertical );
return updateBoxNode( menu, node, rect, gradient, subControl ); return updateBoxNode( menu, node, rect, gradient, subControl );
} }

7
src/controls/QskProgressBarSkinlet.cpp
View File

@ -7,7 +7,7 @@
#include "QskProgressBar.h" #include "QskProgressBar.h"
#include "QskIntervalF.h" #include "QskIntervalF.h"
#include "QskBoxBorderMetrics.h" #include "QskBoxBorderMetrics.h"
#include "QskLinearGradient.h" #include "QskGradientDirection.h"
#include <qeasingcurve.h> #include <qeasingcurve.h>
#include <cmath> #include <cmath>
@ -141,10 +141,11 @@ QSGNode* QskProgressBarSkinlet::updateBarNode(
const auto intv = qskBarInterval( bar ); const auto intv = qskBarInterval( bar );
auto stops = qskExtractedGradientStops( gradient.stops(), const auto stops = qskExtractedGradientStops( gradient.stops(),
intv.lowerBound(), intv.upperBound() ); intv.lowerBound(), intv.upperBound() );
gradient = QskLinearGradient( bar->orientation(), stops ); gradient.setStops( stops );
gradient.setLinearDirection( bar->orientation() );
if ( bar->orientation() == Qt::Vertical || bar->layoutMirroring() ) if ( bar->orientation() == Qt::Vertical || bar->layoutMirroring() )
gradient.reverse(); gradient.reverse();
} }

4
src/controls/QskSeparatorSkinlet.cpp
View File

@ -6,7 +6,7 @@
#include "QskSeparatorSkinlet.h" #include "QskSeparatorSkinlet.h"
#include "QskSeparator.h" #include "QskSeparator.h"
#include "QskLinearGradient.h" #include "QskGradientDirection.h"
#include "QskAspect.h" #include "QskAspect.h"
QskSeparatorSkinlet::QskSeparatorSkinlet( QskSkin* skin ) QskSeparatorSkinlet::QskSeparatorSkinlet( QskSkin* skin )
@ -50,7 +50,7 @@ QSGNode* QskSeparatorSkinlet::updateSubNode(
const auto orientation = ( separator->orientation() == Qt::Vertical ) const auto orientation = ( separator->orientation() == Qt::Vertical )
? Qt::Horizontal : Qt::Vertical; ? Qt::Horizontal : Qt::Vertical;
gradient = QskLinearGradient( orientation, gradient.stops() ); gradient.setLinearDirection( orientation );
} }
return updateBoxNode( separator, node, rect, gradient, Q::Panel ); return updateBoxNode( separator, node, rect, gradient, Q::Panel );

9
src/controls/QskSkinHintTableEditor.cpp
View File

@ -12,7 +12,6 @@
#include "QskBoxBorderMetrics.h" #include "QskBoxBorderMetrics.h"
#include "QskBoxBorderColors.h" #include "QskBoxBorderColors.h"
#include "QskShadowMetrics.h" #include "QskShadowMetrics.h"
#include "QskLinearGradient.h"
namespace namespace
{ {
@ -225,7 +224,9 @@ void QskSkinHintTableEditor::setHGradient(
QskAspect aspect, const QColor& color1, const QColor& color2, QskAspect aspect, const QColor& color1, const QColor& color2,
QskStateCombination combination ) QskStateCombination combination )
{ {
const QskLinearGradient gradient( Qt::Horizontal, color1, color2 ); QskGradient gradient( color1, color2 );
gradient.setLinearDirection( Qt::Horizontal );
setGradient( aspect, gradient, combination ); setGradient( aspect, gradient, combination );
} }
@ -233,7 +234,9 @@ void QskSkinHintTableEditor::setVGradient(
QskAspect aspect, const QColor& color1, const QColor& color2, QskAspect aspect, const QColor& color1, const QColor& color2,
QskStateCombination combination ) QskStateCombination combination )
{ {
const QskLinearGradient gradient( Qt::Vertical, color1, color2 ); QskGradient gradient( color1, color2 );
gradient.setLinearDirection( Qt::Vertical );
setGradient( aspect, gradient, combination ); setGradient( aspect, gradient, combination );
} }

5
src/nodes/QskArcRenderer.cpp
View File

@ -5,7 +5,8 @@
#include "QskArcRenderer.h" #include "QskArcRenderer.h"
#include "QskArcMetrics.h" #include "QskArcMetrics.h"
#include "QskLinearGradient.h" #include "QskGradient.h"
#include "QskGradientDirection.h"
#include <qpainter.h> #include <qpainter.h>
#include <qrect.h> #include <qrect.h>
@ -21,7 +22,7 @@ void QskArcRenderer::renderArc(const QRectF& rect,
Horizontal is interpreted as conic ( in direction of the arc ), Horizontal is interpreted as conic ( in direction of the arc ),
while Vertical means radial ( inner to outer border ) while Vertical means radial ( inner to outer border )
*/ */
isRadial = gradient.asLinearGradient().isVertical(); isRadial = gradient.linearDirection().isVertical();
} }
QBrush brush; QBrush brush;

34
src/nodes/QskBoxNode.cpp
View File

@ -9,6 +9,7 @@
#include "QskBoxRenderer.h" #include "QskBoxRenderer.h"
#include "QskBoxShapeMetrics.h" #include "QskBoxShapeMetrics.h"
#include "QskGradient.h" #include "QskGradient.h"
#include "QskGradientDirection.h"
#include <qglobalstatic.h> #include <qglobalstatic.h>
#include <qsgflatcolormaterial.h> #include <qsgflatcolormaterial.h>
@ -39,56 +40,53 @@ static inline QskHashValue qskColorsHash(
#if 1 #if 1
#include "QskLinearGradient.h"
static inline QskLinearGradient qskEffectiveGradient( const QskGradient& gradient ) static inline QskGradient qskEffectiveGradient( const QskGradient& gradient )
{ {
QskLinearGradient g; QskGradient g;
if ( gradient.isVisible() ) if ( gradient.isVisible() )
{ {
if ( gradient.isMonochrome() ) if ( gradient.isMonochrome() )
{ {
g.setLinearDirection( Qt::Vertical );
g.setStops( gradient.startColor() ); g.setStops( gradient.startColor() );
} }
else else
{ {
switch( gradient.type() ) switch( gradient.type() )
{ {
case QskGradient::Linear: case QskGradient::Linear:
{ {
const auto& linearGradient = gradient.asLinearGradient(); auto dir = gradient.linearDirection();
if ( linearGradient.isVertical() ) if ( dir.isTilted() )
{ {
g.setOrientation( Qt::Vertical ); dir.setStart( 0.0, 0.0 );
} dir.setStop( 1.0, 1.0 );
else if ( linearGradient.isHorizontal() )
{
g.setOrientation( Qt::Horizontal );
}
else
{
g.setStart( 0.0, 0.0 );
g.setStop( 1.0, 1.0 );
} }
g.setStops( gradient.stops() ); g.setLinearDirection( dir );
break; break;
} }
case QskGradient::Radial: case QskGradient::Radial:
case QskGradient::Conic: case QskGradient::Conic:
{ {
qWarning() << "QskBoxNode does not support radial/conic gradients"; qWarning() << "QskBoxNode does not support radial/conic gradients";
g.setStops( Qt::black ); g.setLinearDirection( Qt::Vertical );
break; break;
} }
case QskGradient::Stops: case QskGradient::Stops:
{ {
g.setStops( gradient.stops() ); g.setLinearDirection( Qt::Vertical );
break; break;
} }
} }
g.setStops( gradient.stops() );
} }
} }

11
src/nodes/QskBoxRenderer.h
View File

@ -12,7 +12,6 @@
class QskBoxBorderMetrics; class QskBoxBorderMetrics;
class QskBoxBorderColors; class QskBoxBorderColors;
class QskLinearGradient;
class QskGradient; class QskGradient;
class QSGGeometry; class QSGGeometry;
@ -33,7 +32,7 @@ class QSK_EXPORT QskBoxRenderer
void renderBox( const QRectF&, void renderBox( const QRectF&,
const QskBoxShapeMetrics&, const QskBoxBorderMetrics&, const QskBoxShapeMetrics&, const QskBoxBorderMetrics&,
const QskBoxBorderColors&, const QskLinearGradient&, QSGGeometry& ); const QskBoxBorderColors&, const QskGradient&, QSGGeometry& );
class Quad class Quad
{ {
@ -116,7 +115,7 @@ class QSK_EXPORT QskBoxRenderer
void renderRect( const QRectF&, void renderRect( const QRectF&,
const QskBoxShapeMetrics&, const QskBoxBorderMetrics&, const QskBoxShapeMetrics&, const QskBoxBorderMetrics&,
const QskBoxBorderColors&, const QskLinearGradient&, QSGGeometry& ); const QskBoxBorderColors&, const QskGradient&, QSGGeometry& );
void renderRectellipseFill( const QRectF&, void renderRectellipseFill( const QRectF&,
const QskBoxShapeMetrics&, const QskBoxBorderMetrics&, QSGGeometry& ); const QskBoxShapeMetrics&, const QskBoxBorderMetrics&, QSGGeometry& );
@ -126,12 +125,12 @@ class QSK_EXPORT QskBoxRenderer
void renderRectellipse( const QRectF&, void renderRectellipse( const QRectF&,
const QskBoxShapeMetrics&, const QskBoxBorderMetrics&, const QskBoxShapeMetrics&, const QskBoxBorderMetrics&,
const QskBoxBorderColors&, const QskLinearGradient&, QSGGeometry& ); const QskBoxBorderColors&, const QskGradient&, QSGGeometry& );
void renderDiagonalFill( const Metrics&, const QskGradient&, void renderDiagonalFill( const Metrics&, const QskGradient&,
int lineCount, QskVertex::ColoredLine* ); int lineCount, QskVertex::ColoredLine* );
void renderRectFill( const Quad&, const QskLinearGradient&, QskVertex::ColoredLine* ); void renderRectFill( const Quad&, const QskGradient&, QskVertex::ColoredLine* );
}; };
inline void QskBoxRenderer::renderBorder( inline void QskBoxRenderer::renderBorder(
@ -156,7 +155,7 @@ inline void QskBoxRenderer::renderFill(
inline void QskBoxRenderer::renderBox( const QRectF& rect, inline void QskBoxRenderer::renderBox( const QRectF& rect,
const QskBoxShapeMetrics& shape, const QskBoxBorderMetrics& border, const QskBoxShapeMetrics& shape, const QskBoxBorderMetrics& border,
const QskBoxBorderColors& borderColors, const QskLinearGradient& gradient, const QskBoxBorderColors& borderColors, const QskGradient& gradient,
QSGGeometry& geometry ) QSGGeometry& geometry )
{ {
if ( shape.isRectangle() ) if ( shape.isRectangle() )

34
src/nodes/QskBoxRendererEllipse.cpp
View File

@ -4,12 +4,12 @@
*****************************************************************************/ *****************************************************************************/
#include "QskBoxRenderer.h" #include "QskBoxRenderer.h"
#include "QskLinearGradient.h"
#include "QskBoxBorderColors.h" #include "QskBoxBorderColors.h"
#include "QskBoxBorderMetrics.h" #include "QskBoxBorderMetrics.h"
#include "QskBoxRendererColorMap.h" #include "QskBoxRendererColorMap.h"
#include "QskBoxShapeMetrics.h" #include "QskBoxShapeMetrics.h"
#include "QskGradientDirection.h"
#include <qmath.h> #include <qmath.h>
#include <qsggeometry.h> #include <qsggeometry.h>
@ -868,13 +868,13 @@ namespace
}; };
} }
static inline Qt::Orientation qskQtOrientation( const QskLinearGradient& gradient ) static inline Qt::Orientation qskQtOrientation( const QskGradient& gradient )
{ {
return gradient.isVertical() ? Qt::Vertical : Qt::Horizontal; return gradient.linearDirection().isVertical() ? Qt::Vertical : Qt::Horizontal;
} }
static inline int qskFillLineCount( static inline int qskFillLineCount(
const QskBoxRenderer::Metrics& metrics, const QskLinearGradient& gradient ) const QskBoxRenderer::Metrics& metrics, const QskGradient& gradient )
{ {
const int stepCount = metrics.corner[ 0 ].stepCount; const int stepCount = metrics.corner[ 0 ].stepCount;
@ -883,7 +883,9 @@ static inline int qskFillLineCount(
int lineCount = 0; int lineCount = 0;
if ( gradient.isVertical() ) const auto dir = gradient.linearDirection();
if ( dir.isVertical() )
{ {
lineCount += qMax( metrics.corner[ TopLeft ].stepCount, lineCount += qMax( metrics.corner[ TopLeft ].stepCount,
metrics.corner[ TopRight ].stepCount ) + 1; metrics.corner[ TopRight ].stepCount ) + 1;
@ -894,7 +896,7 @@ static inline int qskFillLineCount(
if ( metrics.centerQuad.top >= metrics.centerQuad.bottom ) if ( metrics.centerQuad.top >= metrics.centerQuad.bottom )
lineCount--; lineCount--;
} }
else if ( gradient.isHorizontal() ) else if ( dir.isHorizontal() )
{ {
lineCount += qMax( metrics.corner[ TopLeft ].stepCount, lineCount += qMax( metrics.corner[ TopLeft ].stepCount,
metrics.corner[ BottomLeft ].stepCount ) + 1; metrics.corner[ BottomLeft ].stepCount ) + 1;
@ -1029,7 +1031,7 @@ static inline void qskRenderBorder( const QskBoxRenderer::Metrics& metrics,
static inline void qskRenderFillRandom( static inline void qskRenderFillRandom(
const QskBoxRenderer::Metrics& metrics, const QskBoxRenderer::Metrics& metrics,
const QskLinearGradient& gradient, ColoredLine* line ) const QskGradient& gradient, ColoredLine* line )
{ {
const auto orientation = qskQtOrientation( gradient ); const auto orientation = qskQtOrientation( gradient );
@ -1047,7 +1049,7 @@ static inline void qskRenderFillRandom(
static inline void qskRenderBoxRandom( static inline void qskRenderBoxRandom(
const QskBoxRenderer::Metrics& metrics, const QskBoxBorderColors& borderColors, const QskBoxRenderer::Metrics& metrics, const QskBoxBorderColors& borderColors,
const QskLinearGradient& gradient, ColoredLine* fillLine, ColoredLine* borderLine ) const QskGradient& gradient, ColoredLine* fillLine, ColoredLine* borderLine )
{ {
const auto& bc = borderColors; const auto& bc = borderColors;
@ -1099,7 +1101,7 @@ static inline void qskRenderBoxRandom(
static inline void qskRenderFillOrdered( static inline void qskRenderFillOrdered(
const QskBoxRenderer::Metrics& metrics, const QskBoxRenderer::Metrics& metrics,
const QskLinearGradient& gradient, ColoredLine* lines ) const QskGradient& gradient, ColoredLine* lines )
{ {
const auto& r = metrics.innerQuad; const auto& r = metrics.innerQuad;
@ -1108,7 +1110,7 @@ static inline void qskRenderFillOrdered(
implemented TODO ... implemented TODO ...
*/ */
if ( gradient.isHorizontal() ) if ( gradient.linearDirection().isHorizontal() )
{ {
HRectEllipseIterator it( metrics ); HRectEllipseIterator it( metrics );
QskVertex::fillOrdered( it, r.left, r.right, gradient, lines ); QskVertex::fillOrdered( it, r.left, r.right, gradient, lines );
@ -1333,7 +1335,7 @@ void QskBoxRenderer::renderRectellipseFill(
void QskBoxRenderer::renderRectellipse( const QRectF& rect, void QskBoxRenderer::renderRectellipse( const QRectF& rect,
const QskBoxShapeMetrics& shape, const QskBoxBorderMetrics& border, const QskBoxShapeMetrics& shape, const QskBoxBorderMetrics& border,
const QskBoxBorderColors& borderColors, const QskLinearGradient& gradient, const QskBoxBorderColors& borderColors, const QskGradient& gradient,
QSGGeometry& geometry ) QSGGeometry& geometry )
{ {
const Metrics metrics( rect, shape, border ); const Metrics metrics( rect, shape, border );
@ -1351,7 +1353,7 @@ void QskBoxRenderer::renderRectellipse( const QRectF& rect,
#if 1 #if 1
// code copied from QskBoxRendererRect.cpp TODO ... // code copied from QskBoxRendererRect.cpp TODO ...
if ( gradient.isTilted() ) if ( gradient.linearDirection().isTilted() )
{ {
if ( metrics.centerQuad.width == metrics.centerQuad.height ) if ( metrics.centerQuad.width == metrics.centerQuad.height )
{ {
@ -1394,7 +1396,7 @@ void QskBoxRenderer::renderRectellipse( const QRectF& rect,
bool extraLine = false; bool extraLine = false;
if ( borderLineCount > 0 && fillLineCount > 0 ) if ( borderLineCount > 0 && fillLineCount > 0 )
{ {
if ( !gradient.isMonochrome() && gradient.isTilted() ) if ( !gradient.isMonochrome() && gradient.linearDirection().isTilted() )
{ {
/* /*
The filling ends at 45° and we have no implementation The filling ends at 45° and we have no implementation
@ -1417,7 +1419,7 @@ void QskBoxRenderer::renderRectellipse( const QRectF& rect,
} }
else if ( !gradient.isMonochrome() ) else if ( !gradient.isMonochrome() )
{ {
if ( gradient.stepCount() > 1 || gradient.isTilted() ) if ( gradient.stepCount() > 1 || gradient.linearDirection().isTilted() )
fillRandom = false; fillRandom = false;
} }
@ -1447,7 +1449,7 @@ void QskBoxRenderer::renderRectellipse( const QRectF& rect,
{ {
renderRectFill( metrics.innerQuad, gradient, line ); renderRectFill( metrics.innerQuad, gradient, line );
} }
else if ( gradient.isTilted() ) else if ( gradient.linearDirection().isTilted() )
{ {
renderDiagonalFill( metrics, gradient, fillLineCount, line ); renderDiagonalFill( metrics, gradient, fillLineCount, line );
} }
@ -1483,7 +1485,7 @@ void QskBoxRenderer::renderRectellipse( const QRectF& rect,
{ {
renderRectFill( metrics.innerQuad, gradient, line ); renderRectFill( metrics.innerQuad, gradient, line );
} }
else if ( gradient.isTilted() ) else if ( gradient.linearDirection().isTilted() )
{ {
renderDiagonalFill( metrics, gradient, fillLineCount, line ); renderDiagonalFill( metrics, gradient, fillLineCount, line );
} }

21
src/nodes/QskBoxRendererRect.cpp
View File

@ -8,7 +8,7 @@
#include "QskBoxRenderer.h" #include "QskBoxRenderer.h"
#include "QskBoxRendererColorMap.h" #include "QskBoxRendererColorMap.h"
#include "QskFunctions.h" #include "QskFunctions.h"
#include "QskLinearGradient.h" #include "QskGradientDirection.h"
#include "QskVertex.h" #include "QskVertex.h"
using namespace QskVertex; using namespace QskVertex;
@ -343,14 +343,16 @@ namespace
} }
static inline void qskCreateFillOrdered( const QskBoxRenderer::Quad& rect, static inline void qskCreateFillOrdered( const QskBoxRenderer::Quad& rect,
const QskLinearGradient& gradient, ColoredLine* line ) const QskGradient& gradient, ColoredLine* line )
{ {
if ( gradient.isHorizontal() ) const auto dir = gradient.linearDirection();
if ( dir.isHorizontal() )
{ {
HRectIterator it( rect ); HRectIterator it( rect );
line = QskVertex::fillOrdered( it, rect.left, rect.right, gradient, line ); line = QskVertex::fillOrdered( it, rect.left, rect.right, gradient, line );
} }
else if ( gradient.isVertical() ) else if ( dir.isVertical() )
{ {
VRectIterator it( rect ); VRectIterator it( rect );
line = QskVertex::fillOrdered( it, rect.top, rect.bottom, gradient, line ); line = QskVertex::fillOrdered( it, rect.top, rect.bottom, gradient, line );
@ -554,7 +556,7 @@ void QskBoxRenderer::renderRectFill(
void QskBoxRenderer::renderRect( void QskBoxRenderer::renderRect(
const QRectF& rect, const QskBoxShapeMetrics& shape, const QRectF& rect, const QskBoxShapeMetrics& shape,
const QskBoxBorderMetrics& border, const QskBoxBorderColors& borderColors, const QskBoxBorderMetrics& border, const QskBoxBorderColors& borderColors,
const QskLinearGradient& gradient, QSGGeometry& geometry ) const QskGradient& gradient, QSGGeometry& geometry )
{ {
Q_UNUSED( shape ) Q_UNUSED( shape )
@ -566,7 +568,7 @@ void QskBoxRenderer::renderRect(
{ {
fillLineCount = gradient.stepCount() + 1; fillLineCount = gradient.stepCount() + 1;
if ( gradient.isTilted() ) if ( gradient.linearDirection().isTilted() )
{ {
if ( in.width == in.height ) if ( in.width == in.height )
{ {
@ -633,12 +635,13 @@ void QskBoxRenderer::renderRect(
but we didn't implement a random fill algo for but we didn't implement a random fill algo for
diagonal gradients yet. diagonal gradients yet.
*/ */
fillRandom = !gd.isTilted(); fillRandom = !gd.linearDirection().isTilted();
} }
if ( fillRandom ) if ( fillRandom )
{ {
const auto orientation = gd.isVertical() ? Qt::Vertical : Qt::Horizontal; const auto orientation = gd.linearDirection().isVertical()
? Qt::Vertical : Qt::Horizontal;
const ColorMapGradient colorMap( gd.startColor(), gd.endColor() ); const ColorMapGradient colorMap( gd.startColor(), gd.endColor() );
qskCreateFillRandom( orientation, in, colorMap, line ); qskCreateFillRandom( orientation, in, colorMap, line );
@ -668,7 +671,7 @@ void QskBoxRenderer::renderRect(
} }
void QskBoxRenderer::renderRectFill( const QskBoxRenderer::Quad& rect, void QskBoxRenderer::renderRectFill( const QskBoxRenderer::Quad& rect,
const QskLinearGradient& gradient, QskVertex::ColoredLine* line ) const QskGradient& gradient, QskVertex::ColoredLine* line )
{ {
qskCreateFillOrdered( rect, gradient, line ); qskCreateFillOrdered( rect, gradient, line );
} }

47
src/nodes/QskGradientMaterial.cpp
View File

@ -6,10 +6,7 @@
#include "QskGradientMaterial.h" #include "QskGradientMaterial.h"
#include "QskFunctions.h" #include "QskFunctions.h"
#include "QskRgbValue.h" #include "QskRgbValue.h"
#include "QskGradientDirection.h"
#include "QskLinearGradient.h"
#include "QskRadialGradient.h"
#include "QskConicGradient.h"
QSK_QT_PRIVATE_BEGIN QSK_QT_PRIVATE_BEGIN
#include <private/qrhi_p.h> #include <private/qrhi_p.h>
@ -317,7 +314,7 @@ namespace
{ {
} }
bool setGradient( const QRectF& rect, const QskLinearGradient& gradient ) bool setGradient( const QRectF& rect, const QskGradient& gradient )
{ {
bool changed = false; bool changed = false;
@ -337,11 +334,13 @@ namespace
QTransform transform( rect.width(), 0, 0, rect.height(), rect.x(), rect.y()); QTransform transform( rect.width(), 0, 0, rect.height(), rect.x(), rect.y());
#endif #endif
const auto dir = gradient.linearDirection();
const QVector4D vector( const QVector4D vector(
rect.left() + gradient.start().x() * rect.width(), rect.left() + dir.start().x() * rect.width(),
rect.top() + gradient.start().y() * rect.height(), rect.top() + dir.start().y() * rect.height(),
gradient.stop().x() * rect.width(), dir.stop().x() * rect.width(),
gradient.stop().y() * rect.height() ); dir.stop().y() * rect.height() );
if ( m_gradientVector != vector ) if ( m_gradientVector != vector )
{ {
@ -476,7 +475,7 @@ namespace
return &type; return &type;
} }
bool setGradient( const QRectF& rect, const QskRadialGradient& gradient ) bool setGradient( const QRectF& rect, const QskGradient& gradient )
{ {
bool changed = false; bool changed = false;
@ -492,14 +491,14 @@ namespace
changed = true; changed = true;
} }
const auto& center = gradient.center(); const auto dir = gradient.radialDirection();
const auto r = gradient.radius();
const QVector2D pos( const QVector2D pos(
rect.left() + center.x() * rect.width(), rect.left() + dir.center().x() * rect.width(),
rect.top() + center.y() * rect.height() ); rect.top() + dir.center().y() * rect.height() );
const QVector2D radius( r * rect.width(), r * rect.height() ); const QVector2D radius( dir.radius() * rect.width(),
dir.radius() * rect.height() );
if ( ( pos != m_center ) || ( m_radius != radius ) ) if ( ( pos != m_center ) || ( m_radius != radius ) )
{ {
@ -647,7 +646,7 @@ namespace
return &type; return &type;
} }
bool setGradient( const QRectF& rect, const QskConicGradient& gradient ) bool setGradient( const QRectF& rect, const QskGradient& gradient )
{ {
bool changed = false; bool changed = false;
@ -663,17 +662,19 @@ namespace
changed = true; changed = true;
} }
const auto dir = gradient.conicDirection();
const QVector2D center( const QVector2D center(
rect.left() + gradient.center().x() * rect.width(), rect.left() + dir.center().x() * rect.width(),
rect.top() + gradient.center().y() * rect.height() ); rect.top() + dir.center().y() * rect.height() );
// Angles as ratio of a rotation // Angles as ratio of a rotation
float start = fmod( gradient.startAngle(), 360.0 ) / 360.0; float start = fmod( dir.startAngle(), 360.0 ) / 360.0;
if ( start < 0.0) if ( start < 0.0)
start += 1.0; start += 1.0;
const float span = fmod( gradient.spanAngle(), 360.0 ) / 360.0; const float span = fmod( dir.spanAngle(), 360.0 ) / 360.0;
if ( center != m_center ) if ( center != m_center )
{ {
@ -842,19 +843,19 @@ bool QskGradientMaterial::updateGradient( const QRectF& rect, const QskGradient&
case QskGradient::Linear: case QskGradient::Linear:
{ {
auto material = static_cast< LinearMaterial* >( this ); auto material = static_cast< LinearMaterial* >( this );
return material->setGradient( rect, gradient.asLinearGradient() ); return material->setGradient( rect, gradient );
} }
case QskGradient::Radial: case QskGradient::Radial:
{ {
auto material = static_cast< RadialMaterial* >( this ); auto material = static_cast< RadialMaterial* >( this );
return material->setGradient( rect, gradient.asRadialGradient() ); return material->setGradient( rect, gradient );
} }
case QskGradient::Conic: case QskGradient::Conic:
{ {
auto material = static_cast< ConicMaterial* >( this ); auto material = static_cast< ConicMaterial* >( this );
return material->setGradient( rect, gradient.asConicGradient() ); return material->setGradient( rect, gradient );
} }
default: default:

10
src/nodes/QskShapeNode.cpp
View File

@ -6,7 +6,7 @@
#include "QskShapeNode.h" #include "QskShapeNode.h"
#include "QskGradientMaterial.h" #include "QskGradientMaterial.h"
#include "QskGradient.h" #include "QskGradient.h"
#include "QskLinearGradient.h" #include "QskGradientDirection.h"
#include <qsgflatcolormaterial.h> #include <qsgflatcolormaterial.h>
@ -19,7 +19,13 @@ QSK_QT_PRIVATE_END
static inline QskGradient qskEffectiveGradient( const QskGradient& gradient ) static inline QskGradient qskEffectiveGradient( const QskGradient& gradient )
{ {
if ( gradient.type() == QskGradient::Stops ) if ( gradient.type() == QskGradient::Stops )
return QskLinearGradient( Qt::Vertical, gradient.stops() ); {
QskGradient g;
g.setLinearDirection( Qt::Vertical );
g.setStops( gradient.stops() );
return g;
}
return gradient; return gradient;
} }

8
src/src.pro
View File

@ -26,10 +26,8 @@ HEADERS += \
common/QskFunctions.h \ common/QskFunctions.h \
common/QskGlobal.h \ common/QskGlobal.h \
common/QskGradient.h \ common/QskGradient.h \
common/QskGradientDirection.h \
common/QskGradientStop.h \ common/QskGradientStop.h \
common/QskConicGradient.h \
common/QskLinearGradient.h \
common/QskRadialGradient.h \
common/QskHctColor.h \ common/QskHctColor.h \
common/QskIntervalF.h \ common/QskIntervalF.h \
common/QskMargins.h \ common/QskMargins.h \
@ -58,9 +56,7 @@ SOURCES += \
common/QskBoxHints.cpp \ common/QskBoxHints.cpp \
common/QskFunctions.cpp \ common/QskFunctions.cpp \
common/QskGradient.cpp \ common/QskGradient.cpp \
common/QskConicGradient.cpp \ common/QskGradientDirection.cpp \
common/QskLinearGradient.cpp \
common/QskRadialGradient.cpp \
common/QskGradientStop.cpp \ common/QskGradientStop.cpp \
common/QskHctColor.cpp \ common/QskHctColor.cpp \
common/QskIntervalF.cpp \ common/QskIntervalF.cpp \