mirror of
https://github.com/Nheko-Reborn/nheko.git
synced 2024-10-31 10:00:46 +03:00
719 lines
20 KiB
C++
719 lines
20 KiB
C++
#include <QEventTransition>
|
|
#include <QFontDatabase>
|
|
#include <QIcon>
|
|
#include <QMouseEvent>
|
|
#include <QPainterPath>
|
|
#include <QResizeEvent>
|
|
#include <QSignalTransition>
|
|
|
|
#include "FlatButton.h"
|
|
#include "Ripple.h"
|
|
#include "RippleOverlay.h"
|
|
#include "ThemeManager.h"
|
|
|
|
// The ampersand is automatically set in QPushButton or QCheckbx
|
|
// by KDEPlatformTheme plugin in Qt5.
|
|
// [https://bugs.kde.org/show_bug.cgi?id=337491]
|
|
//
|
|
// A workaroud is to add
|
|
//
|
|
// [Development]
|
|
// AutoCheckAccelerators=false
|
|
//
|
|
// to ~/.config/kdeglobals
|
|
static QString
|
|
removeKDEAccelerators(QString text)
|
|
{
|
|
return text.remove(QChar('&'));
|
|
}
|
|
|
|
void
|
|
FlatButton::init()
|
|
{
|
|
ripple_overlay_ = new RippleOverlay(this);
|
|
state_machine_ = new FlatButtonStateMachine(this);
|
|
role_ = ui::Role::Default;
|
|
ripple_style_ = ui::RippleStyle::PositionedRipple;
|
|
icon_placement_ = ui::ButtonIconPlacement::LeftIcon;
|
|
overlay_style_ = ui::OverlayStyle::GrayOverlay;
|
|
bg_mode_ = Qt::TransparentMode;
|
|
fixed_ripple_radius_ = 64;
|
|
corner_radius_ = 3;
|
|
base_opacity_ = 0.13;
|
|
font_size_ = 10; // 10.5;
|
|
use_fixed_ripple_radius_ = false;
|
|
|
|
setStyle(&ThemeManager::instance());
|
|
setAttribute(Qt::WA_Hover);
|
|
setMouseTracking(true);
|
|
setCursor(QCursor(Qt::PointingHandCursor));
|
|
|
|
QPainterPath path;
|
|
path.addRoundedRect(rect(), corner_radius_, corner_radius_);
|
|
|
|
ripple_overlay_->setClipPath(path);
|
|
ripple_overlay_->setClipping(true);
|
|
|
|
state_machine_->setupProperties();
|
|
state_machine_->startAnimations();
|
|
}
|
|
|
|
FlatButton::FlatButton(QWidget *parent, ui::ButtonPreset preset)
|
|
: QPushButton(parent)
|
|
{
|
|
init();
|
|
applyPreset(preset);
|
|
}
|
|
|
|
FlatButton::FlatButton(const QString &text, QWidget *parent, ui::ButtonPreset preset)
|
|
: QPushButton(text, parent)
|
|
{
|
|
init();
|
|
applyPreset(preset);
|
|
}
|
|
|
|
FlatButton::FlatButton(const QString &text, ui::Role role, QWidget *parent, ui::ButtonPreset preset)
|
|
: QPushButton(text, parent)
|
|
{
|
|
init();
|
|
applyPreset(preset);
|
|
setRole(role);
|
|
}
|
|
|
|
FlatButton::~FlatButton() {}
|
|
|
|
void
|
|
FlatButton::applyPreset(ui::ButtonPreset preset)
|
|
{
|
|
switch (preset) {
|
|
case ui::ButtonPreset::FlatPreset:
|
|
setOverlayStyle(ui::OverlayStyle::NoOverlay);
|
|
break;
|
|
case ui::ButtonPreset::CheckablePreset:
|
|
setOverlayStyle(ui::OverlayStyle::NoOverlay);
|
|
setCheckable(true);
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
|
|
void
|
|
FlatButton::setRole(ui::Role role)
|
|
{
|
|
role_ = role;
|
|
state_machine_->setupProperties();
|
|
}
|
|
|
|
ui::Role
|
|
FlatButton::role() const
|
|
{
|
|
return role_;
|
|
}
|
|
|
|
void
|
|
FlatButton::setForegroundColor(const QColor &color)
|
|
{
|
|
foreground_color_ = color;
|
|
}
|
|
|
|
QColor
|
|
FlatButton::foregroundColor() const
|
|
{
|
|
if (!foreground_color_.isValid()) {
|
|
if (bg_mode_ == Qt::OpaqueMode) {
|
|
return ThemeManager::instance().themeColor("BrightWhite");
|
|
}
|
|
|
|
switch (role_) {
|
|
case ui::Role::Primary:
|
|
return ThemeManager::instance().themeColor("Blue");
|
|
case ui::Role::Secondary:
|
|
return ThemeManager::instance().themeColor("Gray");
|
|
case ui::Role::Default:
|
|
default:
|
|
return ThemeManager::instance().themeColor("Black");
|
|
}
|
|
}
|
|
|
|
return foreground_color_;
|
|
}
|
|
|
|
void
|
|
FlatButton::setBackgroundColor(const QColor &color)
|
|
{
|
|
background_color_ = color;
|
|
}
|
|
|
|
QColor
|
|
FlatButton::backgroundColor() const
|
|
{
|
|
if (!background_color_.isValid()) {
|
|
switch (role_) {
|
|
case ui::Role::Primary:
|
|
return ThemeManager::instance().themeColor("Blue");
|
|
case ui::Role::Secondary:
|
|
return ThemeManager::instance().themeColor("Gray");
|
|
case ui::Role::Default:
|
|
default:
|
|
return ThemeManager::instance().themeColor("Black");
|
|
}
|
|
}
|
|
|
|
return background_color_;
|
|
}
|
|
|
|
void
|
|
FlatButton::setOverlayColor(const QColor &color)
|
|
{
|
|
overlay_color_ = color;
|
|
setOverlayStyle(ui::OverlayStyle::TintedOverlay);
|
|
}
|
|
|
|
QColor
|
|
FlatButton::overlayColor() const
|
|
{
|
|
if (!overlay_color_.isValid()) {
|
|
return foregroundColor();
|
|
}
|
|
|
|
return overlay_color_;
|
|
}
|
|
|
|
void
|
|
FlatButton::setDisabledForegroundColor(const QColor &color)
|
|
{
|
|
disabled_color_ = color;
|
|
}
|
|
|
|
QColor
|
|
FlatButton::disabledForegroundColor() const
|
|
{
|
|
if (!disabled_color_.isValid()) {
|
|
return ThemeManager::instance().themeColor("FadedWhite");
|
|
}
|
|
|
|
return disabled_color_;
|
|
}
|
|
|
|
void
|
|
FlatButton::setDisabledBackgroundColor(const QColor &color)
|
|
{
|
|
disabled_background_color_ = color;
|
|
}
|
|
|
|
QColor
|
|
FlatButton::disabledBackgroundColor() const
|
|
{
|
|
if (!disabled_background_color_.isValid()) {
|
|
return ThemeManager::instance().themeColor("FadedWhite");
|
|
}
|
|
|
|
return disabled_background_color_;
|
|
}
|
|
|
|
void
|
|
FlatButton::setFontSize(qreal size)
|
|
{
|
|
font_size_ = size;
|
|
|
|
QFont f(font());
|
|
f.setPixelSize(size);
|
|
setFont(f);
|
|
|
|
update();
|
|
}
|
|
|
|
qreal
|
|
FlatButton::fontSize() const
|
|
{
|
|
return font_size_;
|
|
}
|
|
|
|
void
|
|
FlatButton::setOverlayStyle(ui::OverlayStyle style)
|
|
{
|
|
overlay_style_ = style;
|
|
update();
|
|
}
|
|
|
|
ui::OverlayStyle
|
|
FlatButton::overlayStyle() const
|
|
{
|
|
return overlay_style_;
|
|
}
|
|
|
|
void
|
|
FlatButton::setRippleStyle(ui::RippleStyle style)
|
|
{
|
|
ripple_style_ = style;
|
|
}
|
|
|
|
ui::RippleStyle
|
|
FlatButton::rippleStyle() const
|
|
{
|
|
return ripple_style_;
|
|
}
|
|
|
|
void
|
|
FlatButton::setIconPlacement(ui::ButtonIconPlacement placement)
|
|
{
|
|
icon_placement_ = placement;
|
|
update();
|
|
}
|
|
|
|
ui::ButtonIconPlacement
|
|
FlatButton::iconPlacement() const
|
|
{
|
|
return icon_placement_;
|
|
}
|
|
|
|
void
|
|
FlatButton::setCornerRadius(qreal radius)
|
|
{
|
|
corner_radius_ = radius;
|
|
updateClipPath();
|
|
update();
|
|
}
|
|
|
|
qreal
|
|
FlatButton::cornerRadius() const
|
|
{
|
|
return corner_radius_;
|
|
}
|
|
|
|
void
|
|
FlatButton::setBackgroundMode(Qt::BGMode mode)
|
|
{
|
|
bg_mode_ = mode;
|
|
state_machine_->setupProperties();
|
|
}
|
|
|
|
Qt::BGMode
|
|
FlatButton::backgroundMode() const
|
|
{
|
|
return bg_mode_;
|
|
}
|
|
|
|
void
|
|
FlatButton::setBaseOpacity(qreal opacity)
|
|
{
|
|
base_opacity_ = opacity;
|
|
state_machine_->setupProperties();
|
|
}
|
|
|
|
qreal
|
|
FlatButton::baseOpacity() const
|
|
{
|
|
return base_opacity_;
|
|
}
|
|
|
|
void
|
|
FlatButton::setCheckable(bool value)
|
|
{
|
|
state_machine_->updateCheckedStatus();
|
|
state_machine_->setCheckedOverlayProgress(0);
|
|
|
|
QPushButton::setCheckable(value);
|
|
}
|
|
|
|
void
|
|
FlatButton::setHasFixedRippleRadius(bool value)
|
|
{
|
|
use_fixed_ripple_radius_ = value;
|
|
}
|
|
|
|
bool
|
|
FlatButton::hasFixedRippleRadius() const
|
|
{
|
|
return use_fixed_ripple_radius_;
|
|
}
|
|
|
|
void
|
|
FlatButton::setFixedRippleRadius(qreal radius)
|
|
{
|
|
fixed_ripple_radius_ = radius;
|
|
setHasFixedRippleRadius(true);
|
|
}
|
|
|
|
QSize
|
|
FlatButton::sizeHint() const
|
|
{
|
|
ensurePolished();
|
|
|
|
QSize label(fontMetrics().size(Qt::TextSingleLine, removeKDEAccelerators(text())));
|
|
|
|
int w = 20 + label.width();
|
|
int h = label.height();
|
|
|
|
if (!icon().isNull()) {
|
|
w += iconSize().width() + FlatButton::IconPadding;
|
|
h = qMax(h, iconSize().height());
|
|
}
|
|
|
|
return QSize(w, 20 + h);
|
|
}
|
|
|
|
void
|
|
FlatButton::checkStateSet()
|
|
{
|
|
state_machine_->updateCheckedStatus();
|
|
QPushButton::checkStateSet();
|
|
}
|
|
|
|
void
|
|
FlatButton::mousePressEvent(QMouseEvent *event)
|
|
{
|
|
if (ui::RippleStyle::NoRipple != ripple_style_) {
|
|
QPoint pos;
|
|
qreal radiusEndValue;
|
|
|
|
if (ui::RippleStyle::CenteredRipple == ripple_style_) {
|
|
pos = rect().center();
|
|
} else {
|
|
pos = event->pos();
|
|
}
|
|
|
|
if (use_fixed_ripple_radius_) {
|
|
radiusEndValue = fixed_ripple_radius_;
|
|
} else {
|
|
radiusEndValue = static_cast<qreal>(width()) / 2;
|
|
}
|
|
|
|
Ripple *ripple = new Ripple(pos);
|
|
|
|
ripple->setRadiusEndValue(radiusEndValue);
|
|
ripple->setOpacityStartValue(0.35);
|
|
ripple->setColor(foregroundColor());
|
|
ripple->radiusAnimation()->setDuration(250);
|
|
ripple->opacityAnimation()->setDuration(250);
|
|
|
|
ripple_overlay_->addRipple(ripple);
|
|
}
|
|
|
|
QPushButton::mousePressEvent(event);
|
|
}
|
|
|
|
void
|
|
FlatButton::mouseReleaseEvent(QMouseEvent *event)
|
|
{
|
|
QPushButton::mouseReleaseEvent(event);
|
|
state_machine_->updateCheckedStatus();
|
|
}
|
|
|
|
void
|
|
FlatButton::resizeEvent(QResizeEvent *event)
|
|
{
|
|
QPushButton::resizeEvent(event);
|
|
updateClipPath();
|
|
}
|
|
|
|
void
|
|
FlatButton::paintEvent(QPaintEvent *event)
|
|
{
|
|
Q_UNUSED(event)
|
|
|
|
QPainter painter(this);
|
|
painter.setRenderHint(QPainter::Antialiasing);
|
|
|
|
const qreal cr = corner_radius_;
|
|
|
|
if (cr > 0) {
|
|
QPainterPath path;
|
|
path.addRoundedRect(rect(), cr, cr);
|
|
|
|
painter.setClipPath(path);
|
|
painter.setClipping(true);
|
|
}
|
|
|
|
paintBackground(&painter);
|
|
|
|
painter.setOpacity(1);
|
|
painter.setClipping(false);
|
|
|
|
paintForeground(&painter);
|
|
}
|
|
|
|
void
|
|
FlatButton::paintBackground(QPainter *painter)
|
|
{
|
|
const qreal overlayOpacity = state_machine_->overlayOpacity();
|
|
const qreal checkedProgress = state_machine_->checkedOverlayProgress();
|
|
|
|
if (Qt::OpaqueMode == bg_mode_) {
|
|
QBrush brush;
|
|
brush.setStyle(Qt::SolidPattern);
|
|
|
|
if (isEnabled()) {
|
|
brush.setColor(backgroundColor());
|
|
} else {
|
|
brush.setColor(disabledBackgroundColor());
|
|
}
|
|
|
|
painter->setOpacity(1);
|
|
painter->setBrush(brush);
|
|
painter->setPen(Qt::NoPen);
|
|
painter->drawRect(rect());
|
|
}
|
|
|
|
QBrush brush;
|
|
brush.setStyle(Qt::SolidPattern);
|
|
painter->setPen(Qt::NoPen);
|
|
|
|
if (!isEnabled()) {
|
|
return;
|
|
}
|
|
|
|
if ((ui::OverlayStyle::NoOverlay != overlay_style_) && (overlayOpacity > 0)) {
|
|
if (ui::OverlayStyle::TintedOverlay == overlay_style_) {
|
|
brush.setColor(overlayColor());
|
|
} else {
|
|
brush.setColor(Qt::gray);
|
|
}
|
|
|
|
painter->setOpacity(overlayOpacity);
|
|
painter->setBrush(brush);
|
|
painter->drawRect(rect());
|
|
}
|
|
|
|
if (isCheckable() && checkedProgress > 0) {
|
|
const qreal q = Qt::TransparentMode == bg_mode_ ? 0.45 : 0.7;
|
|
brush.setColor(foregroundColor());
|
|
painter->setOpacity(q * checkedProgress);
|
|
painter->setBrush(brush);
|
|
QRect r(rect());
|
|
r.setHeight(static_cast<qreal>(r.height()) * checkedProgress);
|
|
painter->drawRect(r);
|
|
}
|
|
}
|
|
|
|
#define COLOR_INTERPOLATE(CH) (1 - progress) * source.CH() + progress *dest.CH()
|
|
|
|
void
|
|
FlatButton::paintForeground(QPainter *painter)
|
|
{
|
|
if (isEnabled()) {
|
|
painter->setPen(foregroundColor());
|
|
const qreal progress = state_machine_->checkedOverlayProgress();
|
|
|
|
if (isCheckable() && progress > 0) {
|
|
QColor source = foregroundColor();
|
|
QColor dest =
|
|
Qt::TransparentMode == bg_mode_ ? Qt::white : backgroundColor();
|
|
if (qFuzzyCompare(1, progress)) {
|
|
painter->setPen(dest);
|
|
} else {
|
|
painter->setPen(QColor(COLOR_INTERPOLATE(red),
|
|
COLOR_INTERPOLATE(green),
|
|
COLOR_INTERPOLATE(blue),
|
|
COLOR_INTERPOLATE(alpha)));
|
|
}
|
|
}
|
|
} else {
|
|
painter->setPen(disabledForegroundColor());
|
|
}
|
|
|
|
if (icon().isNull()) {
|
|
painter->drawText(rect(), Qt::AlignCenter, removeKDEAccelerators(text()));
|
|
return;
|
|
}
|
|
|
|
QSize textSize(fontMetrics().size(Qt::TextSingleLine, removeKDEAccelerators(text())));
|
|
QSize base(size() - textSize);
|
|
|
|
const int iw = iconSize().width() + IconPadding;
|
|
QPoint pos((base.width() - iw) / 2, 0);
|
|
|
|
QRect textGeometry(pos + QPoint(0, base.height() / 2), textSize);
|
|
QRect iconGeometry(pos + QPoint(0, (height() - iconSize().height()) / 2), iconSize());
|
|
|
|
/* if (ui::LeftIcon == icon_placement_) { */
|
|
/* textGeometry.translate(iw, 0); */
|
|
/* } else { */
|
|
/* iconGeometry.translate(textSize.width() + IconPadding, 0); */
|
|
/* } */
|
|
|
|
painter->drawText(textGeometry, Qt::AlignCenter, removeKDEAccelerators(text()));
|
|
|
|
QPixmap pixmap = icon().pixmap(iconSize());
|
|
QPainter icon(&pixmap);
|
|
icon.setCompositionMode(QPainter::CompositionMode_SourceIn);
|
|
icon.fillRect(pixmap.rect(), painter->pen().color());
|
|
painter->drawPixmap(iconGeometry, pixmap);
|
|
}
|
|
|
|
void
|
|
FlatButton::updateClipPath()
|
|
{
|
|
const qreal radius = corner_radius_;
|
|
|
|
QPainterPath path;
|
|
path.addRoundedRect(rect(), radius, radius);
|
|
ripple_overlay_->setClipPath(path);
|
|
}
|
|
|
|
FlatButtonStateMachine::FlatButtonStateMachine(FlatButton *parent)
|
|
: QStateMachine(parent)
|
|
, button_(parent)
|
|
, top_level_state_(new QState(QState::ParallelStates))
|
|
, config_state_(new QState(top_level_state_))
|
|
, checkable_state_(new QState(top_level_state_))
|
|
, checked_state_(new QState(checkable_state_))
|
|
, unchecked_state_(new QState(checkable_state_))
|
|
, neutral_state_(new QState(config_state_))
|
|
, neutral_focused_state_(new QState(config_state_))
|
|
, hovered_state_(new QState(config_state_))
|
|
, hovered_focused_state_(new QState(config_state_))
|
|
, pressed_state_(new QState(config_state_))
|
|
, overlay_opacity_(0)
|
|
, checked_overlay_progress_(parent->isChecked() ? 1 : 0)
|
|
, was_checked_(false)
|
|
{
|
|
Q_ASSERT(parent);
|
|
|
|
parent->installEventFilter(this);
|
|
|
|
config_state_->setInitialState(neutral_state_);
|
|
addState(top_level_state_);
|
|
setInitialState(top_level_state_);
|
|
|
|
checkable_state_->setInitialState(parent->isChecked() ? checked_state_ : unchecked_state_);
|
|
QSignalTransition *transition;
|
|
QPropertyAnimation *animation;
|
|
|
|
transition = new QSignalTransition(this, SIGNAL(buttonChecked()));
|
|
transition->setTargetState(checked_state_);
|
|
unchecked_state_->addTransition(transition);
|
|
|
|
animation = new QPropertyAnimation(this, "checkedOverlayProgress", this);
|
|
animation->setDuration(200);
|
|
transition->addAnimation(animation);
|
|
|
|
transition = new QSignalTransition(this, SIGNAL(buttonUnchecked()));
|
|
transition->setTargetState(unchecked_state_);
|
|
checked_state_->addTransition(transition);
|
|
|
|
animation = new QPropertyAnimation(this, "checkedOverlayProgress", this);
|
|
animation->setDuration(200);
|
|
transition->addAnimation(animation);
|
|
|
|
addTransition(button_, QEvent::FocusIn, neutral_state_, neutral_focused_state_);
|
|
addTransition(button_, QEvent::FocusOut, neutral_focused_state_, neutral_state_);
|
|
addTransition(button_, QEvent::Enter, neutral_state_, hovered_state_);
|
|
addTransition(button_, QEvent::Leave, hovered_state_, neutral_state_);
|
|
addTransition(button_, QEvent::Enter, neutral_focused_state_, hovered_focused_state_);
|
|
addTransition(button_, QEvent::Leave, hovered_focused_state_, neutral_focused_state_);
|
|
addTransition(button_, QEvent::FocusIn, hovered_state_, hovered_focused_state_);
|
|
addTransition(button_, QEvent::FocusOut, hovered_focused_state_, hovered_state_);
|
|
addTransition(this, SIGNAL(buttonPressed()), hovered_state_, pressed_state_);
|
|
addTransition(button_, QEvent::Leave, pressed_state_, neutral_focused_state_);
|
|
addTransition(button_, QEvent::FocusOut, pressed_state_, hovered_state_);
|
|
}
|
|
|
|
FlatButtonStateMachine::~FlatButtonStateMachine() {}
|
|
|
|
void
|
|
FlatButtonStateMachine::setOverlayOpacity(qreal opacity)
|
|
{
|
|
overlay_opacity_ = opacity;
|
|
button_->update();
|
|
}
|
|
|
|
void
|
|
FlatButtonStateMachine::setCheckedOverlayProgress(qreal opacity)
|
|
{
|
|
checked_overlay_progress_ = opacity;
|
|
button_->update();
|
|
}
|
|
|
|
void
|
|
FlatButtonStateMachine::startAnimations()
|
|
{
|
|
start();
|
|
}
|
|
|
|
void
|
|
FlatButtonStateMachine::setupProperties()
|
|
{
|
|
QColor overlayColor;
|
|
|
|
if (Qt::TransparentMode == button_->backgroundMode()) {
|
|
overlayColor = button_->backgroundColor();
|
|
} else {
|
|
overlayColor = button_->foregroundColor();
|
|
}
|
|
|
|
const qreal baseOpacity = button_->baseOpacity();
|
|
|
|
neutral_state_->assignProperty(this, "overlayOpacity", 0);
|
|
neutral_focused_state_->assignProperty(this, "overlayOpacity", 0);
|
|
hovered_state_->assignProperty(this, "overlayOpacity", baseOpacity);
|
|
hovered_focused_state_->assignProperty(this, "overlayOpacity", baseOpacity);
|
|
pressed_state_->assignProperty(this, "overlayOpacity", baseOpacity);
|
|
checked_state_->assignProperty(this, "checkedOverlayProgress", 1);
|
|
unchecked_state_->assignProperty(this, "checkedOverlayProgress", 0);
|
|
|
|
button_->update();
|
|
}
|
|
|
|
void
|
|
FlatButtonStateMachine::updateCheckedStatus()
|
|
{
|
|
const bool checked = button_->isChecked();
|
|
if (was_checked_ != checked) {
|
|
was_checked_ = checked;
|
|
if (checked) {
|
|
emit buttonChecked();
|
|
} else {
|
|
emit buttonUnchecked();
|
|
}
|
|
}
|
|
}
|
|
|
|
bool
|
|
FlatButtonStateMachine::eventFilter(QObject *watched, QEvent *event)
|
|
{
|
|
if (QEvent::FocusIn == event->type()) {
|
|
QFocusEvent *focusEvent = static_cast<QFocusEvent *>(event);
|
|
if (focusEvent && Qt::MouseFocusReason == focusEvent->reason()) {
|
|
emit buttonPressed();
|
|
return true;
|
|
}
|
|
}
|
|
|
|
return QStateMachine::eventFilter(watched, event);
|
|
}
|
|
|
|
void
|
|
FlatButtonStateMachine::addTransition(QObject *object,
|
|
const char *signal,
|
|
QState *fromState,
|
|
QState *toState)
|
|
{
|
|
addTransition(new QSignalTransition(object, signal), fromState, toState);
|
|
}
|
|
|
|
void
|
|
FlatButtonStateMachine::addTransition(QObject *object,
|
|
QEvent::Type eventType,
|
|
QState *fromState,
|
|
QState *toState)
|
|
{
|
|
addTransition(new QEventTransition(object, eventType), fromState, toState);
|
|
}
|
|
|
|
void
|
|
FlatButtonStateMachine::addTransition(QAbstractTransition *transition,
|
|
QState *fromState,
|
|
QState *toState)
|
|
{
|
|
transition->setTargetState(toState);
|
|
|
|
QPropertyAnimation *animation;
|
|
|
|
animation = new QPropertyAnimation(this, "overlayOpacity", this);
|
|
animation->setDuration(150);
|
|
transition->addAnimation(animation);
|
|
|
|
fromState->addTransition(transition);
|
|
}
|