504 lines
17 KiB
C++
504 lines
17 KiB
C++
//////////////////////////////////////////////////////////////////////////////
|
|
// oxygenframeshadow.h
|
|
// handle sunken frames' shadows
|
|
// -------------------
|
|
//
|
|
// Copyright (c) 2010 Hugo Pereira Da Costa <hugo@oxygen-icons.org>
|
|
//
|
|
// Largely inspired from skulpture widget style
|
|
// Copyright (c) 2007-2009 Christoph Feck <christoph@maxiom.de>
|
|
//
|
|
// Permission is hereby granted, free of charge, to any person obtaining a copy
|
|
// of this software and associated documentation files (the "Software"), to
|
|
// deal in the Software without restriction, including without limitation the
|
|
// rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
|
|
// sell copies of the Software, and to permit persons to whom the Software is
|
|
// furnished to do so, subject to the following conditions:
|
|
//
|
|
// The above copyright notice and this permission notice shall be included in
|
|
// all copies or substantial portions of the Software.
|
|
//
|
|
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
|
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
|
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
|
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
|
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
|
|
// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
|
|
// IN THE SOFTWARE.
|
|
//////////////////////////////////////////////////////////////////////////////
|
|
|
|
#include "frameshadow.h"
|
|
#include "colorutils.h"
|
|
|
|
//---------------------------------------------------------
|
|
// registerWidget
|
|
//---------------------------------------------------------
|
|
|
|
bool FrameShadowFactory::registerWidget( QWidget* widget, StyleHelper& helper ) {
|
|
if (!widget)
|
|
return false;
|
|
if (isRegistered(widget))
|
|
return false;
|
|
|
|
// check whether widget is a frame, and has the proper shape
|
|
bool accepted = false;
|
|
bool flat = false;
|
|
|
|
// cast to frame and check
|
|
QFrame* frame(qobject_cast<QFrame*>(widget));
|
|
if (!frame)
|
|
return false;
|
|
|
|
// also do not install on QSplitter
|
|
/*
|
|
due to Qt, splitters are set with a frame style that matches the condition below,
|
|
though no shadow should be installed, obviously
|
|
*/
|
|
if (qobject_cast<QSplitter*>(widget))
|
|
return false;
|
|
|
|
// further checks on frame shape, and parent
|
|
if ( frame->frameStyle() == (QFrame::StyledPanel | QFrame::Sunken) )
|
|
accepted = true;
|
|
else if (widget->parent() && widget->parent()->inherits("QComboBoxPrivateContainer")) {
|
|
accepted = true;
|
|
flat = true;
|
|
}
|
|
|
|
if (!accepted)
|
|
return false;
|
|
|
|
// store in set
|
|
_registeredWidgets.insert( widget );
|
|
|
|
// catch object destruction
|
|
connect(widget, SIGNAL(destroyed(QObject*)), SLOT(widgetDestroyed(QObject*)));
|
|
|
|
// install shadow
|
|
installShadows(widget, helper, flat);
|
|
|
|
return true;
|
|
}
|
|
|
|
//---------------------------------------------------------
|
|
// unregisterWidget
|
|
//---------------------------------------------------------
|
|
|
|
void FrameShadowFactory::unregisterWidget( QWidget* widget ) {
|
|
if (!isRegistered(widget))
|
|
return;
|
|
_registeredWidgets.remove(widget);
|
|
removeShadows(widget);
|
|
}
|
|
|
|
//---------------------------------------------------------
|
|
// widgetDestroyed
|
|
//---------------------------------------------------------
|
|
|
|
void FrameShadowFactory::widgetDestroyed( QObject* o ) {
|
|
_registeredWidgets.remove( o );
|
|
}
|
|
|
|
//---------------------------------------------------------
|
|
// installShadows
|
|
//---------------------------------------------------------
|
|
|
|
void FrameShadowFactory::installShadows(QWidget* widget, StyleHelper& helper, bool flat) {
|
|
removeShadows(widget);
|
|
|
|
widget->installEventFilter(this);
|
|
if (!flat) {
|
|
installShadow( widget, helper, Left );
|
|
installShadow( widget, helper, Right );
|
|
}
|
|
|
|
installShadow( widget, helper, Top, flat );
|
|
installShadow( widget, helper, Bottom, flat );
|
|
}
|
|
|
|
//---------------------------------------------------------
|
|
// removeShadows
|
|
//---------------------------------------------------------
|
|
|
|
void FrameShadowFactory::removeShadows( QWidget* widget ) {
|
|
widget->removeEventFilter(this);
|
|
|
|
const QList<QObject* > children = widget->children();
|
|
foreach(QObject * child, children) {
|
|
if (FrameShadowBase* shadow = qobject_cast<FrameShadowBase*>(child)) {
|
|
shadow->hide();
|
|
shadow->setParent(0);
|
|
shadow->deleteLater();
|
|
}
|
|
}
|
|
}
|
|
|
|
//---------------------------------------------------------
|
|
// eventFilter
|
|
//---------------------------------------------------------
|
|
|
|
bool FrameShadowFactory::eventFilter( QObject* object, QEvent* event ) {
|
|
switch ( event->type() ) {
|
|
// TODO: possibly implement ZOrderChange event, to make sure that
|
|
// the shadow is always painted on top
|
|
case QEvent::ZOrderChange: {
|
|
raiseShadows( object );
|
|
break;
|
|
}
|
|
case QEvent::Show:
|
|
updateShadowsGeometry( object );
|
|
update( object );
|
|
break;
|
|
case QEvent::Resize:
|
|
updateShadowsGeometry( object );
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
return QObject::eventFilter( object, event );
|
|
}
|
|
|
|
//---------------------------------------------------------
|
|
// updateShadowsGeometry
|
|
//---------------------------------------------------------
|
|
|
|
void FrameShadowFactory::updateShadowsGeometry(QObject* object) const {
|
|
const QList<QObject*> children = object->children();
|
|
foreach(QObject * child, children) {
|
|
if (FrameShadowBase* shadow = qobject_cast<FrameShadowBase*>(child)) {
|
|
shadow->updateGeometry();
|
|
}
|
|
}
|
|
}
|
|
|
|
//---------------------------------------------------------
|
|
// raiseShadows
|
|
//---------------------------------------------------------
|
|
|
|
void FrameShadowFactory::raiseShadows(QObject* object) const {
|
|
const QList<QObject*> children = object->children();
|
|
foreach(QObject * child, children) {
|
|
if (FrameShadowBase* shadow = qobject_cast<FrameShadowBase*>(child)) {
|
|
shadow->raise();
|
|
}
|
|
}
|
|
}
|
|
|
|
//---------------------------------------------------------
|
|
// update
|
|
//---------------------------------------------------------
|
|
|
|
void FrameShadowFactory::update( QObject* object ) const {
|
|
const QList<QObject* > children = object->children();
|
|
foreach( QObject * child, children ) {
|
|
if (FrameShadowBase* shadow = qobject_cast<FrameShadowBase*>(child)) {
|
|
shadow->update();
|
|
}
|
|
}
|
|
}
|
|
|
|
//---------------------------------------------------------
|
|
// updateState
|
|
//---------------------------------------------------------
|
|
|
|
void FrameShadowFactory::updateState(const QWidget* widget, bool focus, bool hover, qreal opacity, AnimationMode mode) const {
|
|
const QList<QObject*> children = widget->children();
|
|
foreach (QObject * child, children) {
|
|
if (FrameShadowBase* shadow = qobject_cast<FrameShadowBase*>(child)) {
|
|
shadow->updateState( focus, hover, opacity, mode );
|
|
}
|
|
}
|
|
}
|
|
|
|
//---------------------------------------------------------
|
|
// installShadow
|
|
//---------------------------------------------------------
|
|
|
|
void FrameShadowFactory::installShadow( QWidget* widget, StyleHelper& helper, ShadowArea area, bool flat ) const {
|
|
FrameShadowBase* shadow(0);
|
|
if (flat)
|
|
shadow = new FlatFrameShadow(area, helper);
|
|
else
|
|
shadow = new SunkenFrameShadow(area, helper);
|
|
shadow->setParent(widget);
|
|
shadow->updateGeometry();
|
|
shadow->show();
|
|
}
|
|
|
|
//---------------------------------------------------------
|
|
// init
|
|
//---------------------------------------------------------
|
|
|
|
void FrameShadowBase::init() {
|
|
setAttribute(Qt::WA_OpaquePaintEvent, false);
|
|
|
|
setFocusPolicy(Qt::NoFocus);
|
|
setAttribute(Qt::WA_TransparentForMouseEvents, true);
|
|
setContextMenuPolicy(Qt::NoContextMenu);
|
|
|
|
// grab viewport widget
|
|
QWidget* viewport( FrameShadowBase::viewport() );
|
|
// set cursor from viewport
|
|
if (viewport)
|
|
setCursor(viewport->cursor());
|
|
}
|
|
|
|
//---------------------------------------------------------
|
|
// viewport
|
|
//---------------------------------------------------------
|
|
|
|
QWidget* FrameShadowBase::viewport() const {
|
|
if (!parentWidget())
|
|
return 0;
|
|
|
|
if (QAbstractScrollArea* widget = qobject_cast<QAbstractScrollArea*>(parentWidget()))
|
|
return widget->viewport();
|
|
else
|
|
return 0;
|
|
}
|
|
|
|
//---------------------------------------------------------
|
|
// event
|
|
//---------------------------------------------------------
|
|
|
|
bool FrameShadowBase::event(QEvent* e) {
|
|
// paintEvents are handled separately
|
|
if (e->type() == QEvent::Paint)
|
|
return QWidget::event(e);
|
|
|
|
QWidget* viewport(FrameShadowBase::viewport());
|
|
|
|
switch (e->type()) {
|
|
case QEvent::DragEnter:
|
|
case QEvent::DragMove:
|
|
case QEvent::DragLeave:
|
|
case QEvent::Drop:
|
|
if ( viewport ) {
|
|
setAcceptDrops(viewport->acceptDrops());
|
|
return viewport->QObject::event(e);
|
|
}
|
|
break;
|
|
|
|
case QEvent::Enter:
|
|
if ( viewport ) {
|
|
setCursor(viewport->cursor());
|
|
setAcceptDrops(viewport->acceptDrops());
|
|
}
|
|
break;
|
|
|
|
case QEvent::ContextMenu:
|
|
if ( viewport ) {
|
|
QContextMenuEvent* me = static_cast<QContextMenuEvent*>(e);
|
|
QContextMenuEvent* ne = new QContextMenuEvent(me->reason(), parentWidget()->mapFromGlobal(me->globalPos()), me->globalPos());
|
|
QApplication::sendEvent(viewport, ne);
|
|
e->accept();
|
|
return true;
|
|
}
|
|
break;
|
|
|
|
case QEvent::MouseButtonPress:
|
|
releaseMouse();
|
|
case QEvent::MouseMove:
|
|
case QEvent::MouseButtonRelease:
|
|
if ( viewport ) {
|
|
QMouseEvent* me = static_cast<QMouseEvent*>(e);
|
|
QMouseEvent* ne = new QMouseEvent(e->type(), parentWidget()->mapFromGlobal(me->globalPos()), me->globalPos(), me->button(), me->buttons(), me->modifiers());
|
|
QApplication::sendEvent(viewport, ne);
|
|
e->accept();
|
|
return true;
|
|
}
|
|
break;
|
|
|
|
default:
|
|
break;
|
|
}
|
|
e->ignore();
|
|
return false;
|
|
}
|
|
|
|
//---------------------------------------------------------
|
|
// updateGeometry
|
|
//---------------------------------------------------------
|
|
|
|
void SunkenFrameShadow::updateGeometry() {
|
|
QWidget* widget = parentWidget();
|
|
if (!widget)
|
|
return;
|
|
|
|
QRect cr = widget->contentsRect();
|
|
switch (shadowArea()) {
|
|
case Top:
|
|
cr.setHeight( SHADOW_SIZE_TOP );
|
|
cr.adjust( -1, -1, 1, 0 );
|
|
break;
|
|
case Left:
|
|
cr.setWidth(SHADOW_SIZE_LEFT);
|
|
cr.adjust(-1, SHADOW_SIZE_TOP, 0, -SHADOW_SIZE_BOTTOM);
|
|
break;
|
|
case Bottom:
|
|
cr.setTop(cr.bottom() - SHADOW_SIZE_BOTTOM + 1);
|
|
cr.adjust( -1, 0, 1, 1 );
|
|
break;
|
|
case Right:
|
|
cr.setLeft(cr.right() - SHADOW_SIZE_RIGHT + 1);
|
|
cr.adjust(0, SHADOW_SIZE_TOP, 1, -SHADOW_SIZE_BOTTOM);
|
|
break;
|
|
case UnknownArea:
|
|
default:
|
|
return;
|
|
}
|
|
setGeometry(cr);
|
|
}
|
|
|
|
//---------------------------------------------------------
|
|
// updateState
|
|
//---------------------------------------------------------
|
|
|
|
void SunkenFrameShadow::updateState( bool focus, bool hover, qreal opacity, AnimationMode mode ) {
|
|
bool changed = false;
|
|
if (_focus != focus) {
|
|
_focus = focus;
|
|
changed |= true;
|
|
}
|
|
if (_hover != hover) {
|
|
_hover = hover;
|
|
changed |= !_focus;
|
|
}
|
|
if (_mode != mode) {
|
|
_mode = mode;
|
|
changed |=
|
|
(_mode == AnimationNone) ||
|
|
(_mode == AnimationFocus) ||
|
|
(_mode == AnimationHover && !_focus );
|
|
}
|
|
|
|
if (_opacity != opacity) {
|
|
_opacity = opacity;
|
|
changed |= (_mode != AnimationNone );
|
|
}
|
|
if (changed) {
|
|
if (QWidget* viewport = this->viewport()) {
|
|
// need to disable viewport updates to avoid some redundant painting
|
|
// besides it fixes one visual glitch (from Qt) in QTableViews
|
|
viewport->setUpdatesEnabled( false );
|
|
update() ;
|
|
viewport->setUpdatesEnabled( true );
|
|
}
|
|
else
|
|
update();
|
|
}
|
|
}
|
|
|
|
//---------------------------------------------------------
|
|
// paintEvent
|
|
//---------------------------------------------------------
|
|
|
|
void SunkenFrameShadow::paintEvent(QPaintEvent* event ) {
|
|
// this fixes shadows in frames that change frameStyle() after polish()
|
|
if (QFrame* frame = qobject_cast<QFrame*>(parentWidget())) {
|
|
if (frame->frameStyle() != (QFrame::StyledPanel | QFrame::Sunken))
|
|
return;
|
|
}
|
|
|
|
QWidget* parent = parentWidget();
|
|
QRect r = parent->contentsRect();
|
|
r.translate(mapFromParent(QPoint(0, 0)));
|
|
|
|
QColor base( palette().color(QPalette::Window) );
|
|
TileSet::Tiles tiles;
|
|
switch ( shadowArea() ) {
|
|
case Top: {
|
|
tiles = TileSet::Left | TileSet::Top | TileSet::Right;
|
|
r.adjust( -2, -2, 2, -1 );
|
|
break;
|
|
}
|
|
|
|
case Bottom: {
|
|
tiles = TileSet::Left | TileSet::Bottom | TileSet::Right;
|
|
r.adjust( -2, 1, 2, 2 );
|
|
break;
|
|
}
|
|
|
|
case Left: {
|
|
tiles = TileSet::Left;
|
|
r.adjust( -2, -3, -1, 3 );
|
|
break;
|
|
}
|
|
|
|
case Right: {
|
|
tiles = TileSet::Right;
|
|
r.adjust( -1, -3, 2, 3 );
|
|
break;
|
|
}
|
|
|
|
default:
|
|
return;
|
|
}
|
|
|
|
QPainter painter(this);
|
|
painter.setClipRegion( event->region() );
|
|
_helper.renderHole( &painter, palette().color( QPalette::Window ), r, _focus, _hover, _opacity, _mode, tiles, true );
|
|
}
|
|
|
|
//---------------------------------------------------------
|
|
// updateGeometry
|
|
//---------------------------------------------------------
|
|
|
|
void FlatFrameShadow::updateGeometry() {
|
|
QWidget* widget = parentWidget();
|
|
if (!widget)
|
|
return;
|
|
|
|
QRect cr = widget->contentsRect();
|
|
switch (shadowArea()) {
|
|
case Top:
|
|
cr.setHeight( SHADOW_SIZE_TOP - 3 );
|
|
break;
|
|
|
|
case Bottom:
|
|
cr.setTop(cr.bottom() - SHADOW_SIZE_BOTTOM + 4);
|
|
break;
|
|
|
|
case UnknownArea:
|
|
default:
|
|
return;
|
|
}
|
|
setGeometry(cr);
|
|
}
|
|
|
|
//---------------------------------------------------------
|
|
// paintEvent
|
|
//---------------------------------------------------------
|
|
|
|
void FlatFrameShadow::paintEvent(QPaintEvent* event ) {
|
|
// this fixes shadows in frames that change frameStyle() after polish()
|
|
if (QFrame* frame = qobject_cast<QFrame*>(parentWidget())) {
|
|
if (frame->frameStyle() != (QFrame::NoFrame))
|
|
return;
|
|
}
|
|
QWidget* parent = parentWidget();
|
|
QImage pm(size(), QImage::Format_ARGB32_Premultiplied);
|
|
|
|
{
|
|
pm.fill(Qt::transparent);
|
|
QPainter p(&pm);
|
|
p.setClipRegion(event->region());
|
|
p.setRenderHints(QPainter::Antialiasing);
|
|
p.translate(-geometry().topLeft());
|
|
p.setCompositionMode(QPainter::CompositionMode_DestinationOver);
|
|
p.setPen(Qt::NoPen);
|
|
_helper.renderMenuBackground(&p, geometry(), parent, parent->palette());
|
|
|
|
// mask
|
|
p.setCompositionMode(QPainter::CompositionMode_DestinationOut);
|
|
p.setBrush(Qt::black);
|
|
p.drawRoundedRect(QRectF(parent->contentsRect()), 2.5, 2.5);
|
|
}
|
|
|
|
QPainter p(this);
|
|
p.setClipRegion(event->region());
|
|
p.fillRect(rect(), Qt::transparent);
|
|
p.drawPixmap(QPoint(0, 0), QPixmap::fromImage(pm));
|
|
return;
|
|
}
|
|
|