← Back to branch summary

~ubuntu-branches/ubuntu/utopic/kde-workspace/utopic-proposed

« back to all changes in this revision

Viewing changes to kstyles/oxygen/animations/oxygenanimations.cpp

  • Committer: Bazaar Package Importer
  • Author(s): Michał Zając
  • Date: 2011-07-09 08:31:15 UTC
  • Revision ID: james.westby@ubuntu.com-20110709083115-ohyxn6z93mily9fc
Tags: upstream-4.6.90
Import upstream version 4.6.90

Show diffs side-by-side

added added

removed removed

Lines of Context:
kstyles/oxygen/animations/oxygenanimations.cpp
 
1
//////////////////////////////////////////////////////////////////////////////
 
2
// oxygenanimations.cpp
 
3
// container for all animation engines
 
4
// -------------------
 
5
//
 
6
// Copyright (c) 2006, 2007 Riccardo Iaconelli <riccardo@kde.org>
 
7
// Copyright (c) 2006, 2007 Casper Boemann <cbr@boemann.dk>
 
8
// Copyright (c) 2009 Hugo Pereira Da Costa <hugo.pereira@free.fr>
 
9
//
 
10
// Permission is hereby granted, free of charge, to any person obtaining a copy
 
11
// of this software and associated documentation files (the "Software"), to
 
12
// deal in the Software without restriction, including without limitation the
 
13
// rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
 
14
// sell copies of the Software, and to permit persons to whom the Software is
 
15
// furnished to do so, subject to the following conditions:
 
16
//
 
17
// The above copyright notice and this permission notice shall be included in
 
18
// all copies or substantial portions of the Software.
 
19
//
 
20
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 
21
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 
22
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 
23
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 
24
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
 
25
// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
 
26
// IN THE SOFTWARE.
 
27
//////////////////////////////////////////////////////////////////////////////
 
28
 
 
29
#include "oxygenanimations.h"
 
30
#include "oxygenanimations.moc"
 
31
#include "oxygenpropertynames.h"
 
32
#include "oxygenstyleconfigdata.h"
 
33
 
 
34
#include <QtGui/QAbstractItemView>
 
35
#include <QtGui/QComboBox>
 
36
#include <QtGui/QDial>
 
37
#include <QtGui/QHeaderView>
 
38
#include <QtGui/QLineEdit>
 
39
#include <QtGui/QMainWindow>
 
40
#include <QtGui/QMdiSubWindow>
 
41
#include <QtGui/QScrollBar>
 
42
#include <QtGui/QSpinBox>
 
43
#include <QtGui/QSplitterHandle>
 
44
#include <QtGui/QTextEdit>
 
45
#include <QtGui/QToolBar>
 
46
#include <QtGui/QToolBox>
 
47
#include <QtGui/QToolButton>
 
48
#include <QtGui/QGroupBox>
 
49
 
 
50
#include <KDebug>
 
51
 
 
52
namespace Oxygen
 
53
{
 
54
 
 
55
    //____________________________________________________________
 
56
    Animations::Animations( QObject* parent ):
 
57
        QObject( parent )
 
58
    {
 
59
 
 
60
        _widgetEnabilityEngine = new WidgetStateEngine( this );
 
61
        _spinBoxEngine = new SpinBoxEngine( this );
 
62
        _comboBoxEngine = new WidgetStateEngine( this );
 
63
        _toolButtonEngine = new WidgetStateEngine( this );
 
64
        _toolBoxEngine = new ToolBoxEngine( this );
 
65
 
 
66
        registerEngine( _splitterEngine = new SplitterEngine( this ) );
 
67
        registerEngine( _dockSeparatorEngine = new DockSeparatorEngine( this ) );
 
68
        registerEngine( _headerViewEngine = new HeaderViewEngine( this ) );
 
69
        registerEngine( _widgetStateEngine = new WidgetStateEngine( this ) );
 
70
        registerEngine( _lineEditEngine = new WidgetStateEngine( this ) );
 
71
        registerEngine( _progressBarEngine = new ProgressBarEngine( this ) );
 
72
        registerEngine( _menuBarEngine = new MenuBarEngineV1( this ) );
 
73
        registerEngine( _menuEngine = new MenuEngineV1( this ) );
 
74
        registerEngine( _scrollBarEngine = new ScrollBarEngine( this ) );
 
75
        registerEngine( _sliderEngine = new SliderEngine( this ) );
 
76
        registerEngine( _tabBarEngine = new TabBarEngine( this ) );
 
77
        registerEngine( _toolBarEngine = new ToolBarEngine( this ) );
 
78
        registerEngine( _mdiWindowEngine = new MdiWindowEngine( this ) );
 
79
    }
 
80
 
 
81
    //____________________________________________________________
 
82
    void Animations::setupEngines( void )
 
83
    {
 
84
 
 
85
        // animation steps
 
86
        AnimationData::setSteps( StyleConfigData::animationSteps() );
 
87
 
 
88
        {
 
89
            // default enability, duration and maxFrame
 
90
            bool animationsEnabled( StyleConfigData::animationsEnabled() );
 
91
 
 
92
            // enability
 
93
            _widgetEnabilityEngine->setEnabled( animationsEnabled &&  StyleConfigData::genericAnimationsEnabled() );
 
94
            _widgetStateEngine->setEnabled( animationsEnabled &&  StyleConfigData::genericAnimationsEnabled() );
 
95
            _comboBoxEngine->setEnabled( animationsEnabled &&  StyleConfigData::genericAnimationsEnabled() );
 
96
            _toolButtonEngine->setEnabled( animationsEnabled &&  StyleConfigData::genericAnimationsEnabled() );
 
97
            _toolBoxEngine->setEnabled( animationsEnabled &&  StyleConfigData::genericAnimationsEnabled() );
 
98
            _lineEditEngine->setEnabled( animationsEnabled &&  StyleConfigData::genericAnimationsEnabled() );
 
99
            _splitterEngine->setEnabled( animationsEnabled &&  StyleConfigData::genericAnimationsEnabled() );
 
100
            _scrollBarEngine->setEnabled( animationsEnabled &&  StyleConfigData::genericAnimationsEnabled() );
 
101
            _sliderEngine->setEnabled( animationsEnabled &&  StyleConfigData::genericAnimationsEnabled() );
 
102
            _spinBoxEngine->setEnabled( animationsEnabled &&  StyleConfigData::genericAnimationsEnabled() );
 
103
            _tabBarEngine->setEnabled( animationsEnabled &&  StyleConfigData::genericAnimationsEnabled() );
 
104
            _dockSeparatorEngine->setEnabled( animationsEnabled &&  StyleConfigData::genericAnimationsEnabled() );
 
105
            _headerViewEngine->setEnabled( animationsEnabled &&  StyleConfigData::genericAnimationsEnabled() );
 
106
            _mdiWindowEngine->setEnabled( animationsEnabled &&  StyleConfigData::genericAnimationsEnabled() );
 
107
 
 
108
            _progressBarEngine->setEnabled( animationsEnabled &&  StyleConfigData::progressBarAnimationsEnabled() );
 
109
            _progressBarEngine->setBusyIndicatorEnabled( StyleConfigData::progressBarAnimated() );
 
110
 
 
111
            // menubar engine
 
112
            int menuBarAnimationType( StyleConfigData::menuBarAnimationType() );
 
113
            if( menuBarAnimationType == StyleConfigData::MB_FADE && !qobject_cast<MenuBarEngineV1*>( _menuBarEngine ) )
 
114
            {
 
115
                if( _menuBarEngine )
 
116
                {
 
117
 
 
118
                    MenuBarEngineV1* newEngine = new MenuBarEngineV1( this, _menuBarEngine );
 
119
                    registerEngine( newEngine );
 
120
                    _menuBarEngine->deleteLater();
 
121
                    _menuBarEngine = newEngine;
 
122
 
 
123
                } else registerEngine( _menuBarEngine = new MenuBarEngineV1( this ) );
 
124
 
 
125
            } else if( menuBarAnimationType == StyleConfigData::MB_FOLLOW_MOUSE && !qobject_cast<MenuBarEngineV2*>( _menuBarEngine ) ) {
 
126
 
 
127
                if( _menuBarEngine )
 
128
                {
 
129
 
 
130
                    MenuBarEngineV2* newEngine = new MenuBarEngineV2( this, _menuBarEngine );
 
131
                    registerEngine( newEngine );
 
132
                    _menuBarEngine->deleteLater();
 
133
                    _menuBarEngine = newEngine;
 
134
 
 
135
                } else registerEngine( _menuBarEngine = new MenuBarEngineV1( this ) );
 
136
 
 
137
            }
 
138
 
 
139
            // menu engine
 
140
            int menuAnimationType( StyleConfigData::menuAnimationType() );
 
141
            if( menuAnimationType == StyleConfigData::ME_FADE && !qobject_cast<MenuEngineV1*>( _menuEngine ) )
 
142
            {
 
143
 
 
144
                if( _menuEngine )
 
145
                {
 
146
 
 
147
                    MenuEngineV1* newEngine = new MenuEngineV1( this, _menuEngine );
 
148
                    registerEngine( newEngine );
 
149
                    _menuEngine->deleteLater();
 
150
                    _menuEngine = newEngine;
 
151
 
 
152
                } else registerEngine( _menuEngine = new MenuEngineV1( this ) );
 
153
 
 
154
            } else if( menuAnimationType == StyleConfigData::ME_FOLLOW_MOUSE && !qobject_cast<MenuEngineV2*>( _menuEngine ) ) {
 
155
 
 
156
                if( _menuEngine )
 
157
                {
 
158
 
 
159
                    MenuEngineV2* newEngine = new MenuEngineV2( this, _menuEngine );
 
160
                    registerEngine( newEngine );
 
161
                    _menuEngine->deleteLater();
 
162
                    _menuEngine = newEngine;
 
163
 
 
164
                } else registerEngine( _menuEngine = new MenuEngineV1( this ) );
 
165
 
 
166
            }
 
167
 
 
168
            _menuBarEngine->setEnabled( animationsEnabled && menuBarAnimationType != StyleConfigData::MB_NONE );
 
169
            _menuEngine->setEnabled( animationsEnabled && menuAnimationType != StyleConfigData::ME_NONE );
 
170
 
 
171
            // toolbar engine
 
172
            int toolBarAnimationType( StyleConfigData::toolBarAnimationType() );
 
173
            if( toolBarAnimationType == StyleConfigData::TB_NONE || toolBarAnimationType == StyleConfigData::TB_FOLLOW_MOUSE )
 
174
            {
 
175
 
 
176
                // disable toolbar engine
 
177
                _toolBarEngine->setEnabled( animationsEnabled && toolBarAnimationType == StyleConfigData::TB_FOLLOW_MOUSE );
 
178
 
 
179
                // unregister all toolbuttons that belong to a toolbar
 
180
                foreach( QWidget* widget, _widgetStateEngine->registeredWidgets( AnimationHover|AnimationFocus ) )
 
181
                {
 
182
                    if( qobject_cast<QToolButton*>( widget ) && qobject_cast<QToolBar*>( widget->parentWidget() ) )
 
183
                    { _widgetStateEngine->unregisterWidget( widget ); }
 
184
                }
 
185
 
 
186
            } else if( toolBarAnimationType == StyleConfigData::TB_FADE ) {
 
187
 
 
188
                // disable toolbar engine
 
189
                _toolBarEngine->setEnabled( false );
 
190
 
 
191
                // retrieve all registered toolbars
 
192
                BaseEngine::WidgetList widgets( _toolBarEngine->registeredWidgets() );
 
193
                foreach( QWidget* widget, widgets )
 
194
                {
 
195
                    // get all toolbuttons
 
196
                    foreach( QObject* child, widget->children() )
 
197
                    {
 
198
                        if( QToolButton* toolButton = qobject_cast<QToolButton*>( child ) )
 
199
                        { _widgetStateEngine->registerWidget( toolButton, AnimationHover ); }
 
200
                    }
 
201
                }
 
202
 
 
203
            }
 
204
 
 
205
        }
 
206
 
 
207
 
 
208
        {
 
209
 
 
210
            // durations
 
211
            _widgetEnabilityEngine->setDuration( StyleConfigData::genericAnimationsDuration() );
 
212
            _widgetStateEngine->setDuration( StyleConfigData::genericAnimationsDuration() );
 
213
            _comboBoxEngine->setDuration( StyleConfigData::genericAnimationsDuration() );
 
214
            _toolButtonEngine->setDuration( StyleConfigData::genericAnimationsDuration() );
 
215
            _toolBoxEngine->setDuration( StyleConfigData::genericAnimationsDuration() );
 
216
            _lineEditEngine->setDuration( StyleConfigData::genericAnimationsDuration() );
 
217
            _splitterEngine->setDuration( StyleConfigData::genericAnimationsDuration() );
 
218
            _scrollBarEngine->setDuration( StyleConfigData::genericAnimationsDuration() );
 
219
            _sliderEngine->setDuration( StyleConfigData::genericAnimationsDuration() );
 
220
            _spinBoxEngine->setDuration( StyleConfigData::genericAnimationsDuration() );
 
221
            _tabBarEngine->setDuration( StyleConfigData::genericAnimationsDuration() );
 
222
            _dockSeparatorEngine->setDuration( StyleConfigData::genericAnimationsDuration() );
 
223
            _headerViewEngine->setDuration( StyleConfigData::genericAnimationsDuration() );
 
224
            _mdiWindowEngine->setDuration( StyleConfigData::genericAnimationsDuration() );
 
225
 
 
226
            _progressBarEngine->setDuration( StyleConfigData::progressBarAnimationsDuration() );
 
227
            _progressBarEngine->setBusyStepDuration( StyleConfigData::progressBarBusyStepDuration() );
 
228
 
 
229
            _toolBarEngine->setDuration( StyleConfigData::genericAnimationsDuration() );
 
230
            _toolBarEngine->setFollowMouseDuration( StyleConfigData::toolBarAnimationsDuration() );
 
231
 
 
232
            _menuBarEngine->setDuration( StyleConfigData::menuBarAnimationsDuration() );
 
233
            _menuBarEngine->setFollowMouseDuration( StyleConfigData::menuBarFollowMouseAnimationsDuration() );
 
234
 
 
235
            _menuEngine->setDuration( StyleConfigData::menuAnimationsDuration() );
 
236
            _menuEngine->setFollowMouseDuration( StyleConfigData::menuFollowMouseAnimationsDuration() );
 
237
 
 
238
        }
 
239
 
 
240
    }
 
241
 
 
242
    //____________________________________________________________
 
243
    void Animations::registerWidget( QWidget* widget ) const
 
244
    {
 
245
 
 
246
        if( !widget ) return;
 
247
 
 
248
        // check against noAnimations propery
 
249
        QVariant propertyValue( widget->property( PropertyNames::noAnimations ) );
 
250
        if( propertyValue.isValid() && propertyValue.toBool() ) return;
 
251
 
 
252
        // these are needed to not register animations for kwin widgets
 
253
        if( widget->objectName() == "decoration widget" ) return;
 
254
        if( widget->inherits( "KCommonDecorationButton" ) ) return;
 
255
        if( widget->inherits( "QShapedPixmapWidget" ) ) return;
 
256
 
 
257
        // all widgets are registered to the enability engine.
 
258
        widgetEnabilityEngine().registerWidget( widget, AnimationEnable );
 
259
 
 
260
        // install animation timers
 
261
        // for optimization, one should put with most used widgets here first
 
262
        if( qobject_cast<QToolButton*>(widget) )
 
263
        {
 
264
 
 
265
            toolButtonEngine().registerWidget( widget, AnimationHover );
 
266
            bool isInToolBar( qobject_cast<QToolBar*>(widget->parent()) );
 
267
            if( isInToolBar )
 
268
            {
 
269
 
 
270
                if( StyleConfigData::toolBarAnimationType() == StyleConfigData::TB_FADE )
 
271
                { widgetStateEngine().registerWidget( widget, AnimationHover ); }
 
272
 
 
273
            } else widgetStateEngine().registerWidget( widget, AnimationHover|AnimationFocus );
 
274
 
 
275
        } else if( qobject_cast<QAbstractButton*>(widget) ) {
 
276
 
 
277
            if( qobject_cast<QToolBox*>( widget->parent() ) )
 
278
            { toolBoxEngine().registerWidget( widget ); }
 
279
 
 
280
            widgetStateEngine().registerWidget( widget, AnimationHover|AnimationFocus );
 
281
 
 
282
        } else if( qobject_cast<QDial*>(widget) ) {
 
283
 
 
284
            widgetStateEngine().registerWidget( widget, AnimationHover|AnimationFocus );
 
285
 
 
286
        }
 
287
 
 
288
        // groupboxes
 
289
        else if( QGroupBox* groupBox = qobject_cast<QGroupBox*>( widget ) )
 
290
        {
 
291
            if( groupBox->isCheckable() )
 
292
            { widgetStateEngine().registerWidget( widget, AnimationHover|AnimationFocus ); }
 
293
        }
 
294
 
 
295
        // scrollbar
 
296
        else if( qobject_cast<QScrollBar*>( widget ) ) { scrollBarEngine().registerWidget( widget ); }
 
297
        else if( qobject_cast<QSlider*>( widget ) ) { sliderEngine().registerWidget( widget ); }
 
298
        else if( qobject_cast<QProgressBar*>( widget ) ) { progressBarEngine().registerWidget( widget ); }
 
299
        else if( qobject_cast<QSplitterHandle*>( widget ) ) { splitterEngine().registerWidget( widget ); }
 
300
        else if( qobject_cast<QMainWindow*>( widget ) ) { dockSeparatorEngine().registerWidget( widget ); }
 
301
        else if( qobject_cast<QHeaderView*>( widget ) ) { headerViewEngine().registerWidget( widget ); }
 
302
        // menu
 
303
        else if( qobject_cast<QMenu*>( widget ) ) { menuEngine().registerWidget( widget ); }
 
304
        else if( qobject_cast<QMenuBar*>( widget ) ) { menuBarEngine().registerWidget( widget ); }
 
305
        else if( qobject_cast<QTabBar*>( widget ) ) { tabBarEngine().registerWidget( widget ); }
 
306
        else if( qobject_cast<QToolBar*>( widget ) ) { toolBarEngine().registerWidget( widget ); }
 
307
 
 
308
        // editors
 
309
        else if( qobject_cast<QComboBox*>( widget ) ) {
 
310
            comboBoxEngine().registerWidget( widget, AnimationHover );
 
311
            lineEditEngine().registerWidget( widget, AnimationHover|AnimationFocus );
 
312
        } else if( qobject_cast<QSpinBox*>( widget ) ) {
 
313
            spinBoxEngine().registerWidget( widget );
 
314
            lineEditEngine().registerWidget( widget, AnimationHover|AnimationFocus );
 
315
        }
 
316
        else if( qobject_cast<QLineEdit*>( widget ) ) { lineEditEngine().registerWidget( widget, AnimationHover|AnimationFocus ); }
 
317
        else if( qobject_cast<QTextEdit*>( widget ) ) { lineEditEngine().registerWidget( widget, AnimationHover|AnimationFocus ); }
 
318
 
 
319
        // lists
 
320
        else if( qobject_cast<QAbstractItemView*>( widget ) || widget->inherits("Q3ListView") )
 
321
        { lineEditEngine().registerWidget( widget, AnimationHover|AnimationFocus ); }
 
322
 
 
323
        // mdi subwindows
 
324
        else if( qobject_cast<QMdiSubWindow*>( widget ) )
 
325
        { mdiWindowEngine().registerWidget( widget ); }
 
326
 
 
327
        return;
 
328
 
 
329
    }
 
330
 
 
331
    //____________________________________________________________
 
332
    void Animations::unregisterWidget( QWidget* widget ) const
 
333
    {
 
334
 
 
335
        if( !widget ) return;
 
336
 
 
337
        /*
 
338
        these are the engines that have not been stored
 
339
        inside the list, because they can be register widgets in combination
 
340
        with other engines
 
341
        */
 
342
        widgetEnabilityEngine().unregisterWidget( widget );
 
343
        spinBoxEngine().unregisterWidget( widget );
 
344
        comboBoxEngine().unregisterWidget( widget );
 
345
        toolButtonEngine().unregisterWidget( widget );
 
346
        toolBoxEngine().unregisterWidget( widget );
 
347
 
 
348
        // the following allows some optimization of widget unregistration
 
349
        // it assumes that a widget can be registered atmost in one of the
 
350
        // engines stored in the list.
 
351
        foreach( const BaseEngine::Pointer& engine, _engines )
 
352
        { if( engine && engine.data()->unregisterWidget( widget ) ) break; }
 
353
 
 
354
    }
 
355
 
 
356
    //_______________________________________________________________
 
357
    void Animations::unregisterEngine( QObject* object )
 
358
    {
 
359
        int index( _engines.indexOf( qobject_cast<BaseEngine*>(object) ) );
 
360
        if( index >= 0 ) _engines.removeAt( index );
 
361
    }
 
362
 
 
363
    //_______________________________________________________________
 
364
    void Animations::registerEngine( BaseEngine* engine )
 
365
    {
 
366
        _engines.push_back( engine );
 
367
        connect( engine, SIGNAL( destroyed( QObject* ) ), this, SLOT( unregisterEngine( QObject* ) ) );
 
368
    }
 
369
 
 
370
}