← Back to branch summary

~ubuntu-branches/ubuntu/saucy/cairo-dock-plug-ins/saucy

« back to all changes in this revision

Viewing changes to icon-effect/src/applet-notifications.c

  • Committer: Bazaar Package Importer
  • Author(s): Didier Roche
  • Date: 2009-08-26 21:07:39 UTC
  • Revision ID: james.westby@ubuntu.com-20090826210739-gyjuuqezrzuluao4
Tags: upstream-2.0.8.1
Import upstream version 2.0.8.1

Show diffs side-by-side

added added

removed removed

Lines of Context:
icon-effect/src/applet-notifications.c
 
1
/**
 
2
* This file is a part of the Cairo-Dock project
 
3
*
 
4
* Copyright : (C) see the 'copyright' file.
 
5
* E-mail    : see the 'copyright' file.
 
6
*
 
7
* This program is free software; you can redistribute it and/or
 
8
* modify it under the terms of the GNU General Public License
 
9
* as published by the Free Software Foundation; either version 3
 
10
* of the License, or (at your option) any later version.
 
11
*
 
12
* This program is distributed in the hope that it will be useful,
 
13
* but WITHOUT ANY WARRANTY; without even the implied warranty of
 
14
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 
15
* GNU General Public License for more details.
 
16
* You should have received a copy of the GNU General Public License
 
17
* along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
18
*/
 
19
 
 
20
/******************************************************************************
 
21
 
 
22
This file is a part of the cairo-dock program, 
 
23
released under the terms of the GNU General Public License.
 
24
 
 
25
Written by Fabrice Rey (for any bug report, please mail me to fabounet@users.berlios.de)
 
26
 
 
27
******************************************************************************/
 
28
 
 
29
#include <stdlib.h>
 
30
#include <string.h>
 
31
 
 
32
#include "applet-fire.h"
 
33
#include "applet-rain.h"
 
34
#include "applet-snow.h"
 
35
#include "applet-star.h"
 
36
#include "applet-storm.h"
 
37
#include "applet-struct.h"
 
38
#include "applet-notifications.h"
 
39
 
 
40
 
 
41
static void _cd_icon_effect_start (gpointer pUserData, Icon *pIcon, CairoDock *pDock, CDIconEffects *pAnimations, gboolean *bStartAnimation)
 
42
{
 
43
        if (! CAIRO_DOCK_CONTAINER_IS_OPENGL (CAIRO_CONTAINER (pDock)))
 
44
                return ;
 
45
        
 
46
        CDIconEffectData *pData = CD_APPLET_GET_MY_ICON_DATA (pIcon);
 
47
        if (pData == NULL)
 
48
        {
 
49
                pData = g_new0 (CDIconEffectData, 1);
 
50
                CD_APPLET_SET_MY_ICON_DATA (pIcon, pData);
 
51
        }
 
52
        double dt = mySystem.iGLAnimationDeltaT;
 
53
        
 
54
        int i;
 
55
        for (i = 0; i < CD_ICON_EFFECT_NB_EFFECTS; i ++)
 
56
        {
 
57
                switch (pAnimations[i])
 
58
                {
 
59
                        case CD_ICON_EFFECT_FIRE :
 
60
                                if (pData->pFireSystem == NULL)
 
61
                                        pData->pFireSystem = cd_icon_effect_init_fire (pIcon, pDock, dt);
 
62
                                *bStartAnimation = TRUE;
 
63
                        break;
 
64
                        
 
65
                        case CD_ICON_EFFECT_STARS :
 
66
                                if (pData->pStarSystem == NULL)
 
67
                                        pData->pStarSystem = cd_icon_effect_init_stars (pIcon, pDock, dt);
 
68
                                *bStartAnimation = TRUE;
 
69
                        break;
 
70
                        
 
71
                        case CD_ICON_EFFECT_RAIN :
 
72
                                if (pData->pRainSystem == NULL)
 
73
                                        pData->pRainSystem = cd_icon_effect_init_rain (pIcon, pDock, dt);
 
74
                                *bStartAnimation = TRUE;
 
75
                        break;
 
76
                        
 
77
                        case CD_ICON_EFFECT_SNOW :
 
78
                                if (pData->pSnowSystem == NULL)
 
79
                                        pData->pSnowSystem = cd_icon_effect_init_snow (pIcon, pDock, dt);
 
80
                                *bStartAnimation = TRUE;
 
81
                        break;
 
82
                        
 
83
                        case CD_ICON_EFFECT_SAND :
 
84
                                if (pData->pStormSystem == NULL)
 
85
                                        pData->pStormSystem = cd_icon_effect_init_storm (pIcon, pDock, dt);
 
86
                                *bStartAnimation = TRUE;
 
87
                        break;
 
88
                        
 
89
                        default :
 
90
                                i = CD_ICON_EFFECT_NB_EFFECTS - 1;
 
91
                        break;
 
92
                }
 
93
        }
 
94
}
 
95
 
 
96
gboolean cd_icon_effect_on_enter (gpointer pUserData, Icon *pIcon, CairoDock *pDock, gboolean *bStartAnimation)
 
97
{
 
98
        if (pIcon->iAnimationState > CAIRO_DOCK_STATE_MOUSE_HOVERED)
 
99
                return CAIRO_DOCK_LET_PASS_NOTIFICATION;
 
100
        _cd_icon_effect_start (pUserData, pIcon, pDock, myConfig.iEffectsUsed, bStartAnimation);
 
101
        if (bStartAnimation)
 
102
        {
 
103
                CDIconEffectData *pData = CD_APPLET_GET_MY_ICON_DATA (pIcon);
 
104
                pData->iRequestTime = 0;
 
105
                cairo_dock_mark_icon_as_hovered_by_mouse (pIcon);
 
106
        }
 
107
        return CAIRO_DOCK_LET_PASS_NOTIFICATION;
 
108
}
 
109
 
 
110
gboolean cd_icon_effect_on_click (gpointer pUserData, Icon *pIcon, CairoDock *pDock, gint iButtonState)
 
111
{
 
112
        if (! CAIRO_DOCK_IS_DOCK (pDock) || pIcon == NULL || pIcon->iAnimationState > CAIRO_DOCK_STATE_CLICKED)
 
113
                return CAIRO_DOCK_LET_PASS_NOTIFICATION;
 
114
        
 
115
        CairoDockIconType iType = cairo_dock_get_icon_type (pIcon);
 
116
        if (iType == CAIRO_DOCK_APPLI && CAIRO_DOCK_IS_LAUNCHER (pIcon) && iButtonState & GDK_SHIFT_MASK)
 
117
                iType = CAIRO_DOCK_LAUNCHER;
 
118
        
 
119
        gboolean bStartAnimation = FALSE;
 
120
        _cd_icon_effect_start (pUserData, pIcon, pDock, myConfig.iEffectsOnClick[iType], &bStartAnimation);
 
121
        if (bStartAnimation)
 
122
        {
 
123
                CDIconEffectData *pData = CD_APPLET_GET_MY_ICON_DATA (pIcon);
 
124
                pData->iRequestTime = 0;
 
125
                cairo_dock_mark_icon_as_clicked (pIcon);
 
126
        }
 
127
        
 
128
        return CAIRO_DOCK_LET_PASS_NOTIFICATION;
 
129
}
 
130
 
 
131
gboolean cd_icon_effect_on_request (gpointer pUserData, Icon *pIcon, CairoDock *pDock, const gchar *cAnimation, gint iNbRounds)
 
132
{
 
133
        if (pIcon == NULL || pIcon->iAnimationState > CAIRO_DOCK_STATE_CLICKED)
 
134
                return CAIRO_DOCK_LET_PASS_NOTIFICATION;
 
135
        
 
136
        CDIconEffects anim[2] = {0, -1};
 
137
        int iRoundDuration=0;
 
138
        
 
139
        if (strcmp (cAnimation, "default") == 0)
 
140
        {
 
141
                CairoDockIconType iType = cairo_dock_get_icon_type (pIcon);
 
142
                anim[0] = myConfig.iEffectsOnClick[iType][0];
 
143
                switch (anim[0])
 
144
                {
 
145
                        case CD_ICON_EFFECT_FIRE  : iRoundDuration = myConfig.iFireDuration; break;
 
146
                        case CD_ICON_EFFECT_STARS : iRoundDuration = myConfig.iStarDuration; break;
 
147
                        case CD_ICON_EFFECT_RAIN  : iRoundDuration = myConfig.iRainDuration; break;
 
148
                        case CD_ICON_EFFECT_SNOW  : iRoundDuration = myConfig.iSnowDuration; break;
 
149
                        case CD_ICON_EFFECT_SAND  : iRoundDuration = myConfig.iStormDuration; break;
 
150
                        
 
151
                }
 
152
        }
 
153
        else
 
154
        {
 
155
                int iAnimationID = cairo_dock_get_animation_id (cAnimation);
 
156
                if (iAnimationID == myData.iAnimationID[CD_ICON_EFFECT_FIRE])
 
157
                {
 
158
                        anim[0] = CD_ICON_EFFECT_FIRE;
 
159
                        iRoundDuration = myConfig.iFireDuration;
 
160
                }
 
161
                else if (iAnimationID == myData.iAnimationID[CD_ICON_EFFECT_STARS])
 
162
                {
 
163
                        anim[0] = CD_ICON_EFFECT_STARS;
 
164
                        iRoundDuration = myConfig.iStarDuration;
 
165
                }
 
166
                else if (iAnimationID == myData.iAnimationID[CD_ICON_EFFECT_RAIN])
 
167
                {
 
168
                        anim[0] = CD_ICON_EFFECT_RAIN;
 
169
                        iRoundDuration = myConfig.iRainDuration;
 
170
                }
 
171
                else if (iAnimationID == myData.iAnimationID[CD_ICON_EFFECT_SNOW])
 
172
                {
 
173
                        anim[0] = CD_ICON_EFFECT_SNOW;
 
174
                        iRoundDuration = myConfig.iSnowDuration;
 
175
                }
 
176
                else if (iAnimationID == myData.iAnimationID[CD_ICON_EFFECT_SAND])
 
177
                {
 
178
                        anim[0] = CD_ICON_EFFECT_SAND;
 
179
                        iRoundDuration = myConfig.iStormDuration;
 
180
                }
 
181
                else
 
182
                        return CAIRO_DOCK_LET_PASS_NOTIFICATION;
 
183
        }
 
184
        
 
185
        gboolean bStartAnimation = FALSE;
 
186
        _cd_icon_effect_start (pUserData, pIcon, pDock, anim, &bStartAnimation);
 
187
        if (bStartAnimation)
 
188
        {
 
189
                CDIconEffectData *pData = CD_APPLET_GET_MY_ICON_DATA (pIcon);
 
190
                //pData->iNumRound = iNbRounds - 1;
 
191
                pData->iRequestTime = iNbRounds * iRoundDuration;
 
192
                cairo_dock_mark_icon_as_hovered_by_mouse (pIcon);
 
193
        }
 
194
        return CAIRO_DOCK_LET_PASS_NOTIFICATION;
 
195
}
 
196
 
 
197
 
 
198
static void _cd_icon_effect_render_effects (Icon *pIcon, CairoDock *pDock, CDIconEffectData *pData)
 
199
{
 
200
        glPushMatrix ();
 
201
        if (!pDock->bHorizontalDock && myConfig.bRotateEffects)
 
202
                glRotatef (pDock->bDirectionUp ? 90:-90, 0., 0., 1.);
 
203
        glTranslatef (0., - pIcon->fHeight * pIcon->fScale/2, 0.);
 
204
        
 
205
        if (pData->pFireSystem != NULL)
 
206
        {
 
207
                cairo_dock_render_particles (pData->pFireSystem);
 
208
        }
 
209
        
 
210
        if (pData->pStarSystem != NULL)
 
211
        {
 
212
                cairo_dock_render_particles (pData->pStarSystem);
 
213
        }
 
214
        
 
215
        if (pData->pSnowSystem != NULL)
 
216
        {
 
217
                cairo_dock_render_particles (pData->pSnowSystem);
 
218
        }
 
219
        
 
220
        if (pData->pRainSystem != NULL)
 
221
        {
 
222
                cairo_dock_render_particles (pData->pRainSystem);
 
223
        }
 
224
        
 
225
        glPopMatrix ();
 
226
}
 
227
 
 
228
static void _cd_icon_effect_render_effects_with_depth (Icon *pIcon, CairoDock *pDock, CDIconEffectData *pData, int iDepth)
 
229
{
 
230
        glPushMatrix ();
 
231
        if (!pDock->bHorizontalDock && myConfig.bRotateEffects)
 
232
                glRotatef (pDock->bDirectionUp ? 90:-90, 0., 0., 1.);
 
233
        glTranslatef (0., - pIcon->fHeight * pIcon->fScale/2, 0.);
 
234
        
 
235
        if (pData->pStormSystem != NULL)
 
236
        {
 
237
                cairo_dock_render_particles_full (pData->pStormSystem, iDepth);
 
238
        }
 
239
        
 
240
        glPopMatrix ();
 
241
}
 
242
 
 
243
gboolean cd_icon_effect_pre_render_icon (gpointer pUserData, Icon *pIcon, CairoDock *pDock)
 
244
{
 
245
        CDIconEffectData *pData = CD_APPLET_GET_MY_ICON_DATA (pIcon);
 
246
        if (pData == NULL)
 
247
                return CAIRO_DOCK_LET_PASS_NOTIFICATION;
 
248
        
 
249
        if (myConfig.bBackGround)
 
250
                _cd_icon_effect_render_effects (pIcon, pDock, pData);
 
251
        
 
252
        if (pData->pStormSystem != NULL)
 
253
                _cd_icon_effect_render_effects_with_depth (pIcon, pDock, pData, -1);
 
254
        return CAIRO_DOCK_LET_PASS_NOTIFICATION;
 
255
}
 
256
 
 
257
gboolean cd_icon_effect_render_icon (gpointer pUserData, Icon *pIcon, CairoDock *pDock, gboolean *bHasBeenRendered, cairo_t *pCairoContext)
 
258
{
 
259
        if (pCairoContext != NULL)
 
260
                return CAIRO_DOCK_LET_PASS_NOTIFICATION;
 
261
        CDIconEffectData *pData = CD_APPLET_GET_MY_ICON_DATA (pIcon);
 
262
        if (pData == NULL)
 
263
                return CAIRO_DOCK_LET_PASS_NOTIFICATION;
 
264
        
 
265
        if (! myConfig.bBackGround)
 
266
                _cd_icon_effect_render_effects (pIcon, pDock, pData);
 
267
        
 
268
        if (pData->pStormSystem != NULL)
 
269
                _cd_icon_effect_render_effects_with_depth (pIcon, pDock, pData, 1);
 
270
        return CAIRO_DOCK_LET_PASS_NOTIFICATION;
 
271
}
 
272
 
 
273
 
 
274
#define _will_continue(bRepeat) ((pData->iRequestTime > 0) || (pIcon->iAnimationState == CAIRO_DOCK_STATE_MOUSE_HOVERED && bRepeat && pIcon->bPointed && pDock->bInside))
 
275
 
 
276
gboolean cd_icon_effect_update_icon (gpointer pUserData, Icon *pIcon, CairoDock *pDock, gboolean *bContinueAnimation)
 
277
{
 
278
        CDIconEffectData *pData = CD_APPLET_GET_MY_ICON_DATA (pIcon);
 
279
        if (pData == NULL)
 
280
                return CAIRO_DOCK_LET_PASS_NOTIFICATION;
 
281
        
 
282
        if (pData->iRequestTime > 0)
 
283
        {
 
284
                int dt = mySystem.iGLAnimationDeltaT;
 
285
                pData->iRequestTime -= dt;
 
286
                if (pData->iRequestTime < 0)
 
287
                        pData->iRequestTime = 0;
 
288
        }
 
289
        
 
290
        if (pData->pFireSystem != NULL)
 
291
        {
 
292
                gboolean bContinueFire = cd_icon_effect_update_fire_system (pData->pFireSystem,
 
293
                        (_will_continue (myConfig.bContinueFire) ? cd_icon_effect_rewind_fire_particle : NULL));
 
294
                pData->pFireSystem->fWidth = pIcon->fWidth * pIcon->fScale;
 
295
                if (pDock->bAtBottom)
 
296
                        pData->pFireSystem->fHeight = pIcon->fHeight;
 
297
                if (bContinueFire)
 
298
                        *bContinueAnimation = TRUE;
 
299
                else
 
300
                {
 
301
                        cairo_dock_free_particle_system (pData->pFireSystem);
 
302
                        pData->pFireSystem = NULL;
 
303
                }
 
304
        }
 
305
        
 
306
        if (pData->pStarSystem != NULL)
 
307
        {
 
308
                gboolean bContinueStar = cd_icon_effect_update_star_system (pData->pStarSystem,
 
309
                        (_will_continue (myConfig.bContinueStar) ? cd_icon_effect_rewind_star_particle : NULL));
 
310
                pData->pStarSystem->fWidth = pIcon->fWidth * pIcon->fScale;
 
311
                if (bContinueStar)
 
312
                        *bContinueAnimation = TRUE;
 
313
                else
 
314
                {
 
315
                        cairo_dock_free_particle_system (pData->pStarSystem);
 
316
                        pData->pStarSystem = NULL;
 
317
                }
 
318
        }
 
319
        
 
320
        if (pData->pSnowSystem != NULL)
 
321
        {
 
322
                gboolean bContinueSnow = cd_icon_effect_update_snow_system (pData->pSnowSystem,
 
323
                        (_will_continue (myConfig.bContinueSnow) ? cd_icon_effect_rewind_snow_particle : NULL));
 
324
                pData->pSnowSystem->fWidth = pIcon->fWidth * pIcon->fScale;
 
325
                if (bContinueSnow)
 
326
                        *bContinueAnimation = TRUE;
 
327
                else
 
328
                {
 
329
                        cairo_dock_free_particle_system (pData->pSnowSystem);
 
330
                        pData->pSnowSystem = NULL;
 
331
                }
 
332
        }
 
333
        
 
334
        if (pData->pRainSystem != NULL)
 
335
        {
 
336
                gboolean bContinueRain = cd_icon_effect_update_rain_system (pData->pRainSystem,
 
337
                        (_will_continue (myConfig.bContinueRain) ? cd_icon_effect_rewind_rain_particle : NULL));
 
338
                pData->pRainSystem->fWidth = pIcon->fWidth * pIcon->fScale;
 
339
                if (bContinueRain)
 
340
                        *bContinueAnimation = TRUE;
 
341
                else
 
342
                {
 
343
                        cairo_dock_free_particle_system (pData->pRainSystem);
 
344
                        pData->pRainSystem = NULL;
 
345
                }
 
346
        }
 
347
        
 
348
        if (pData->pStormSystem != NULL)
 
349
        {
 
350
                gboolean bContinueStorm = cd_icon_effect_update_storm_system (pData->pStormSystem,
 
351
                        (_will_continue (myConfig.bContinueStorm) ? cd_icon_effect_rewind_storm_particle : NULL));
 
352
                pData->pStormSystem->fWidth = pIcon->fWidth * pIcon->fScale;
 
353
                if (bContinueStorm)
 
354
                        *bContinueAnimation = TRUE;
 
355
                else
 
356
                {
 
357
                        cairo_dock_free_particle_system (pData->pStormSystem);
 
358
                        pData->pStormSystem = NULL;
 
359
                }
 
360
        }
 
361
        
 
362
        double fMaxScale = cairo_dock_get_max_scale (pDock);
 
363
        GdkRectangle area;
 
364
        if (pDock->bHorizontalDock)
 
365
        {
 
366
                area.x = pIcon->fDrawX - .2 * pIcon->fWidth * pIcon->fScale;
 
367
                area.y = pIcon->fDrawY;
 
368
                if (pDock->bDirectionUp)
 
369
                        area.y -= (pIcon->fScale - fMaxScale) * pIcon->fHeight + myLabels.iconTextDescription.iSize;
 
370
                area.width = pIcon->fWidth * pIcon->fScale * 1.4;
 
371
                area.height = pIcon->fHeight * fMaxScale + myLabels.iconTextDescription.iSize;
 
372
        }
 
373
        else
 
374
        {
 
375
                area.y = pIcon->fDrawX - .2 * pIcon->fWidth * pIcon->fScale;
 
376
                area.x = pIcon->fDrawY;
 
377
                if (pDock->bDirectionUp)
 
378
                        area.x -= (pIcon->fScale - fMaxScale) * pIcon->fHeight + myLabels.iconTextDescription.iSize;
 
379
                area.height = pIcon->fWidth * pIcon->fScale * 1.4;
 
380
                area.width = pIcon->fHeight * fMaxScale + myLabels.iconTextDescription.iSize;
 
381
        }
 
382
        cairo_dock_redraw_container_area (pDock, &area);
 
383
        
 
384
        if (! *bContinueAnimation)
 
385
                cd_icon_effect_free_data (pUserData, pIcon);
 
386
        
 
387
        return CAIRO_DOCK_LET_PASS_NOTIFICATION;
 
388
}
 
389
 
 
390
 
 
391
gboolean cd_icon_effect_free_data (gpointer pUserData, Icon *pIcon)
 
392
{
 
393
        cd_message ("");
 
394
        CDIconEffectData *pData = CD_APPLET_GET_MY_ICON_DATA (pIcon);
 
395
        if (pData == NULL)
 
396
                return CAIRO_DOCK_LET_PASS_NOTIFICATION;
 
397
        
 
398
        if (pData->pFireSystem != NULL)
 
399
                cairo_dock_free_particle_system (pData->pFireSystem);
 
400
        
 
401
        if (pData->pStarSystem != NULL)
 
402
                cairo_dock_free_particle_system (pData->pStarSystem);
 
403
        
 
404
        if (pData->pRainSystem != NULL)
 
405
                cairo_dock_free_particle_system (pData->pRainSystem);
 
406
        
 
407
        if (pData->pSnowSystem != NULL)
 
408
                cairo_dock_free_particle_system (pData->pSnowSystem);
 
409
        
 
410
        if (pData->pStormSystem != NULL)
 
411
                cairo_dock_free_particle_system (pData->pStormSystem);
 
412
        
 
413
        g_free (pData);
 
414
        CD_APPLET_SET_MY_ICON_DATA (pIcon, NULL);
 
415
        return CAIRO_DOCK_LET_PASS_NOTIFICATION;
 
416
}