← Back to branch summary

~cairo-dock-team/ubuntu/oneiric/cairo-dock/2.3.0-3

« back to all changes in this revision

Viewing changes to src/cairo-dock-flying-container.c

  • Committer: Bazaar Package Importer
  • Author(s): Matthieu Baerts (matttbe)
  • Date: 2010-08-09 23:26:12 UTC
  • mto: This revision was merged to the branch mainline in revision 13.
  • Revision ID: james.westby@ubuntu.com-20100809232612-pocdxliaxjdetm37
Tags: upstream-2.2.0~0beta4
Import upstream version 2.2.0~0beta4

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/cairo-dock-flying-container.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
 
#include <stdlib.h>
21
 
#include <sys/time.h>
22
 
#include <cairo.h>
23
 
#include <glib/gstdio.h>
24
 
#include <gtk/gtk.h>
25
 
 
26
 
#ifdef HAVE_GLITZ
27
 
#include <gdk/gdkx.h>
28
 
#include <glitz-glx.h>
29
 
#include <cairo-glitz.h>
30
 
#endif
31
 
 
32
 
#include "cairo-dock-draw.h"
33
 
#include "cairo-dock-draw-opengl.h"
34
 
#include "cairo-dock-icons.h"
35
 
#include "cairo-dock-file-manager.h"
36
 
#include "cairo-dock-modules.h"
37
 
#include "cairo-dock-config.h"
38
 
#include "cairo-dock-log.h"
39
 
#include "cairo-dock-desklet.h"
40
 
#include "cairo-dock-container.h"
41
 
#include "cairo-dock-surface-factory.h"
42
 
#include "cairo-dock-callbacks.h"
43
 
#include "cairo-dock-animations.h"
44
 
#include "cairo-dock-notifications.h"
45
 
#include "cairo-dock-internal-system.h"
46
 
#include "cairo-dock-keyfile-utilities.h"
47
 
#include "cairo-dock-dock-factory.h"
48
 
#include "cairo-dock-gui-manager.h"
49
 
#include "cairo-dock-flying-container.h"
50
 
 
51
 
#define HAND_WIDTH 80
52
 
#define HAND_HEIGHT 50
53
 
#define EXPLOSION_NB_FRAMES 10
54
 
 
55
 
extern CairoDock *g_pMainDock;
56
 
extern gchar *g_cCurrentLaunchersPath;
57
 
extern gchar *g_cCurrentThemePath;
58
 
extern gboolean g_bUseOpenGL;
59
 
extern int g_iXScreenWidth[2], g_iXScreenHeight[2];
60
 
 
61
 
static cairo_surface_t *s_pHandSurface = NULL;
62
 
static GLuint s_iHandTexture = 0;
63
 
static double s_fHandWidth, s_fHandHeight;
64
 
static cairo_surface_t *s_pExplosionSurface = NULL;
65
 
static GLuint s_iExplosionTexture = 0;
66
 
static double s_fExplosionWidth, s_fExplosionHeight;
67
 
 
68
 
static void _cairo_dock_load_hand_image (cairo_t *pCairoContext, int iWidth)
69
 
{
70
 
        if (s_pHandSurface != NULL || s_iHandTexture != 0)
71
 
                return ;
72
 
        
73
 
        s_pHandSurface = cairo_dock_create_surface_from_image (CAIRO_DOCK_SHARE_DATA_DIR"/hand.svg",
74
 
                pCairoContext,
75
 
                1.,
76
 
                iWidth, 0.,
77
 
                CAIRO_DOCK_KEEP_RATIO,
78
 
                &s_fHandWidth, &s_fHandHeight,
79
 
                NULL, NULL);
80
 
        if (s_pHandSurface != NULL && g_bUseOpenGL)
81
 
        {
82
 
                s_iHandTexture = cairo_dock_create_texture_from_surface (s_pHandSurface);
83
 
                cairo_surface_destroy (s_pHandSurface);
84
 
                s_pHandSurface = NULL;
85
 
        }
86
 
}
87
 
static void _cairo_dock_load_explosion_image (cairo_t *pCairoContext, int iWidth)
88
 
{
89
 
        if (s_pExplosionSurface != NULL || s_iExplosionTexture != 0)
90
 
                return ;
91
 
        
92
 
        gchar *cExplosionFile = g_strdup_printf ("%s/%s", g_cCurrentThemePath, "explosion.png");
93
 
        if (g_file_test (cExplosionFile, G_FILE_TEST_EXISTS))
94
 
        {
95
 
                s_pExplosionSurface = cairo_dock_create_surface_for_icon (cExplosionFile,
96
 
                        pCairoContext,
97
 
                        iWidth * EXPLOSION_NB_FRAMES,
98
 
                        iWidth);
99
 
        }
100
 
        else
101
 
        {
102
 
                s_pExplosionSurface = cairo_dock_create_surface_for_icon (CAIRO_DOCK_SHARE_DATA_DIR"/explosion/explosion.png",
103
 
                        pCairoContext,
104
 
                        iWidth * EXPLOSION_NB_FRAMES,
105
 
                        iWidth);
106
 
        }
107
 
        g_free (cExplosionFile);
108
 
        s_fExplosionWidth = iWidth;
109
 
        s_fExplosionHeight = iWidth;
110
 
        if (s_pExplosionSurface != NULL && g_bUseOpenGL)
111
 
        {
112
 
                s_iExplosionTexture = cairo_dock_create_texture_from_surface (s_pExplosionSurface);
113
 
                cairo_surface_destroy (s_pExplosionSurface);
114
 
                s_pExplosionSurface = NULL;
115
 
        }
116
 
}
117
 
 
118
 
 
119
 
void cairo_dock_unload_flying_container_textures (void)
120
 
{
121
 
        if (s_iHandTexture != 0)
122
 
        {
123
 
                _cairo_dock_delete_texture (s_iHandTexture);
124
 
                s_iHandTexture = 0;
125
 
        }
126
 
        if (s_iExplosionTexture != 0)
127
 
        {
128
 
                _cairo_dock_delete_texture (s_iExplosionTexture);
129
 
                s_iExplosionTexture = 0;
130
 
        }
131
 
}
132
 
 
133
 
gboolean cairo_dock_update_flying_container_notification (gpointer pUserData, CairoFlyingContainer *pFlyingContainer, gboolean *bContinueAnimation)
134
 
{
135
 
        if (pFlyingContainer->container.iAnimationStep > 0)
136
 
        {
137
 
                pFlyingContainer->container.iAnimationStep --;
138
 
                if (pFlyingContainer->container.iAnimationStep == 0)
139
 
                {
140
 
                        *bContinueAnimation = FALSE;
141
 
                        return CAIRO_DOCK_INTERCEPT_NOTIFICATION;
142
 
                }
143
 
        }
144
 
        gtk_widget_queue_draw (pFlyingContainer->container.pWidget);
145
 
        
146
 
        *bContinueAnimation = TRUE;
147
 
        return CAIRO_DOCK_LET_PASS_NOTIFICATION;
148
 
}
149
 
 
150
 
gboolean cairo_dock_render_flying_container_notification (gpointer pUserData, CairoFlyingContainer *pFlyingContainer, cairo_t *pCairoContext)
151
 
{
152
 
        Icon *pIcon = pFlyingContainer->pIcon;
153
 
        if (pCairoContext != NULL)
154
 
        {
155
 
                if (pIcon != NULL)
156
 
                {
157
 
                        cairo_save (pCairoContext);
158
 
                        cairo_dock_render_one_icon (pIcon, CAIRO_CONTAINER (pFlyingContainer), pCairoContext, 1., TRUE);
159
 
                        cairo_restore (pCairoContext);
160
 
                        
161
 
                        cairo_set_source_surface (pCairoContext, s_pHandSurface, 0., 0.);
162
 
                        cairo_paint (pCairoContext);
163
 
                }
164
 
                else if (pFlyingContainer->container.iAnimationStep > 0)
165
 
                {
166
 
                        int x = 0;
167
 
                        int y = (pFlyingContainer->container.iHeight - pFlyingContainer->container.iWidth) / 2;
168
 
                        int iCurrentFrame = EXPLOSION_NB_FRAMES - pFlyingContainer->container.iAnimationStep;
169
 
                        
170
 
                        cairo_rectangle (pCairoContext,
171
 
                                x,
172
 
                                y,
173
 
                                s_fExplosionWidth,
174
 
                                s_fExplosionHeight);
175
 
                        cairo_clip (pCairoContext);
176
 
                        
177
 
                        cairo_set_source_surface (pCairoContext,
178
 
                                s_pExplosionSurface,
179
 
                                x - (iCurrentFrame * s_fExplosionWidth),
180
 
                                y);
181
 
                        cairo_paint (pCairoContext);
182
 
                }
183
 
        }
184
 
        else
185
 
        {
186
 
                if (pIcon != NULL)
187
 
                {
188
 
                        glPushMatrix ();
189
 
                        /*glTranslatef (pFlyingContainer->container.iWidth / 2,
190
 
                                pIcon->fHeight * pIcon->fScale/2,
191
 
                                - pFlyingContainer->container.iHeight);*/
192
 
                        cairo_dock_render_one_icon_opengl (pIcon, CAIRO_CONTAINER (pFlyingContainer), 1., TRUE);
193
 
                        glPopMatrix ();
194
 
                        
195
 
                        glTranslatef (pFlyingContainer->container.iWidth / 2,
196
 
                                pFlyingContainer->container.iHeight - s_fHandHeight/2,
197
 
                                - 3.);
198
 
                        cairo_dock_draw_texture (s_iHandTexture, s_fHandWidth, s_fHandHeight);
199
 
                }
200
 
                else if (pFlyingContainer->container.iAnimationStep > 0)
201
 
                {
202
 
                        int iCurrentFrame = EXPLOSION_NB_FRAMES - pFlyingContainer->container.iAnimationStep;
203
 
                        
204
 
                        glTranslatef (pFlyingContainer->container.iWidth/2,
205
 
                                pFlyingContainer->container.iHeight/2,
206
 
                                -3.);
207
 
                        glBindTexture (GL_TEXTURE_2D, s_iExplosionTexture);
208
 
                        _cairo_dock_enable_texture ();
209
 
                        _cairo_dock_set_blend_source ();
210
 
                        _cairo_dock_set_alpha (1.);
211
 
                        _cairo_dock_apply_current_texture_portion_at_size_with_offset ((double) iCurrentFrame / EXPLOSION_NB_FRAMES, 1.,
212
 
                                1. / EXPLOSION_NB_FRAMES, 1.,
213
 
                                s_fExplosionWidth, s_fExplosionHeight,
214
 
                                0., 0.);
215
 
                        
216
 
                        _cairo_dock_disable_texture ();
217
 
                }
218
 
        }
219
 
        return CAIRO_DOCK_LET_PASS_NOTIFICATION;
220
 
}
221
 
 
222
 
 
223
 
static gboolean on_expose_flying_icon (GtkWidget *pWidget,
224
 
        GdkEventExpose *pExpose,
225
 
        CairoFlyingContainer *pFlyingContainer)
226
 
{
227
 
        if (g_bUseOpenGL)
228
 
        {
229
 
                GdkGLContext *pGlContext = gtk_widget_get_gl_context (pWidget);
230
 
                GdkGLDrawable *pGlDrawable = gtk_widget_get_gl_drawable (pWidget);
231
 
                if (!gdk_gl_drawable_gl_begin (pGlDrawable, pGlContext))
232
 
                        return FALSE;
233
 
                
234
 
                glClear (GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
235
 
                glLoadIdentity ();
236
 
                
237
 
                cairo_dock_apply_desktop_background_opengl (CAIRO_CONTAINER (pFlyingContainer));
238
 
                
239
 
                cairo_dock_notify (CAIRO_DOCK_RENDER_FLYING_CONTAINER, pFlyingContainer, NULL);
240
 
                
241
 
                if (gdk_gl_drawable_is_double_buffered (pGlDrawable))
242
 
                        gdk_gl_drawable_swap_buffers (pGlDrawable);
243
 
                else
244
 
                        glFlush ();
245
 
                gdk_gl_drawable_gl_end (pGlDrawable);
246
 
                if (! pFlyingContainer->pIcon)  // plus d'icone, le container va se faire detruire sous peu, on repasse donc sur un contexte qui a plus d'avenir, sinon cela peut invalider les fonctions qui font appel a OpenGL sans definir de contexte (genre cairo_dock_create_texture_from_surface).
247
 
                {
248
 
                        GdkGLContext *pGlContext = gtk_widget_get_gl_context (g_pMainDock->container.pWidget);
249
 
                        GdkGLDrawable *pGlDrawable = gtk_widget_get_gl_drawable (g_pMainDock->container.pWidget);
250
 
                        if (gdk_gl_drawable_gl_begin (pGlDrawable, pGlContext))
251
 
                                gdk_gl_drawable_gl_end (pGlDrawable);
252
 
                }
253
 
        }
254
 
        else
255
 
        {
256
 
                cairo_t *pCairoContext = cairo_dock_create_drawing_context_on_container (CAIRO_CONTAINER (pFlyingContainer));
257
 
                
258
 
                cairo_dock_notify (CAIRO_DOCK_RENDER_FLYING_CONTAINER, pFlyingContainer, pCairoContext);
259
 
                
260
 
                cairo_destroy (pCairoContext);
261
 
        }
262
 
        
263
 
        return FALSE;
264
 
}
265
 
 
266
 
static gboolean on_configure_flying_icon (GtkWidget* pWidget,
267
 
        GdkEventConfigure* pEvent,
268
 
        CairoFlyingContainer *pFlyingContainer)
269
 
{
270
 
        if (pFlyingContainer->container.iWidth != pEvent->width || pFlyingContainer->container.iHeight != pEvent->height)
271
 
        {
272
 
                pFlyingContainer->container.iWidth = pEvent->width;
273
 
                pFlyingContainer->container.iHeight = pEvent->height;
274
 
                
275
 
                if (g_bUseOpenGL)
276
 
                {
277
 
                        GdkGLContext* pGlContext = gtk_widget_get_gl_context (pWidget);
278
 
                        GdkGLDrawable* pGlDrawable = gtk_widget_get_gl_drawable (pWidget);
279
 
                        GLsizei w = pEvent->width;
280
 
                        GLsizei h = pEvent->height;
281
 
                        if (!gdk_gl_drawable_gl_begin (pGlDrawable, pGlContext))
282
 
                                return FALSE;
283
 
                        
284
 
                        glViewport(0, 0, w, h);
285
 
                        
286
 
                        cairo_dock_set_ortho_view (w, h);
287
 
                        
288
 
                        gdk_gl_drawable_gl_end (pGlDrawable);
289
 
                }
290
 
        }
291
 
        return FALSE;
292
 
}
293
 
 
294
 
CairoFlyingContainer *cairo_dock_create_flying_container (Icon *pFlyingIcon, CairoDock *pOriginDock, gboolean bDrawHand)
295
 
{
296
 
        g_return_val_if_fail (pFlyingIcon != NULL, NULL);
297
 
        CairoFlyingContainer * pFlyingContainer = g_new0 (CairoFlyingContainer, 1);
298
 
        pFlyingContainer->container.iType = CAIRO_DOCK_TYPE_FLYING_CONTAINER;
299
 
        GtkWidget* pWindow = cairo_dock_create_container_window ();
300
 
        gtk_window_set_keep_above (GTK_WINDOW (pWindow), TRUE);
301
 
        gtk_window_set_title (GTK_WINDOW(pWindow), "cairo-dock-flying-icon");
302
 
        pFlyingContainer->container.pWidget = pWindow;
303
 
        pFlyingContainer->pIcon = pFlyingIcon;
304
 
        pFlyingContainer->container.bIsHorizontal = TRUE;
305
 
        pFlyingContainer->container.bDirectionUp = TRUE;
306
 
        pFlyingContainer->container.fRatio = 1.;
307
 
        pFlyingContainer->container.bUseReflect = FALSE;
308
 
        cairo_dock_set_default_animation_delta_t (pFlyingContainer);
309
 
        
310
 
        g_signal_connect (G_OBJECT (pWindow),
311
 
                "expose-event",
312
 
                G_CALLBACK (on_expose_flying_icon),
313
 
                pFlyingContainer);
314
 
        g_signal_connect (G_OBJECT (pWindow),
315
 
                "configure-event",
316
 
                G_CALLBACK (on_configure_flying_icon),
317
 
                pFlyingContainer);
318
 
        
319
 
        pFlyingContainer->container.bInside = TRUE;
320
 
        pFlyingIcon->bPointed = TRUE;
321
 
        pFlyingIcon->fScale = 1.;
322
 
        pFlyingContainer->container.iWidth = pFlyingIcon->fWidth * pFlyingIcon->fScale * 3.7;
323
 
        pFlyingContainer->container.iHeight = pFlyingIcon->fHeight * pFlyingIcon->fScale + 1.*pFlyingContainer->container.iWidth / HAND_WIDTH * HAND_HEIGHT * .6;
324
 
        pFlyingIcon->fDrawX = (pFlyingContainer->container.iWidth - pFlyingIcon->fWidth * pFlyingIcon->fScale) / 2 * 1.2;
325
 
        pFlyingIcon->fDrawY = pFlyingContainer->container.iHeight - pFlyingIcon->fHeight * pFlyingIcon->fScale;
326
 
        
327
 
        if (pOriginDock->container.bIsHorizontal)
328
 
        {
329
 
                pFlyingContainer->container.iWindowPositionX = pOriginDock->container.iWindowPositionX + pOriginDock->container.iMouseX - pFlyingContainer->container.iWidth/2;
330
 
                pFlyingContainer->container.iWindowPositionY = pOriginDock->container.iWindowPositionY + pOriginDock->container.iMouseY - pFlyingContainer->container.iHeight/2;
331
 
        }
332
 
        else
333
 
        {
334
 
                pFlyingContainer->container.iWindowPositionY = pOriginDock->container.iWindowPositionX + pOriginDock->container.iMouseX - pFlyingContainer->container.iWidth/2;
335
 
                pFlyingContainer->container.iWindowPositionX = pOriginDock->container.iWindowPositionY + pOriginDock->container.iMouseY - pFlyingContainer->container.iHeight/2;
336
 
        }
337
 
        /*g_print ("%s (%d;%d %dx%d)\n", __func__ pFlyingContainer->container.iWindowPositionX,
338
 
                pFlyingContainer->container.iWindowPositionY,
339
 
                pFlyingContainer->container.iWidth,
340
 
                pFlyingContainer->container.iHeight);*/
341
 
        gdk_window_move_resize (pWindow->window,
342
 
                pFlyingContainer->container.iWindowPositionX,
343
 
                pFlyingContainer->container.iWindowPositionY,
344
 
                pFlyingContainer->container.iWidth,
345
 
                pFlyingContainer->container.iHeight);
346
 
        /*gtk_window_resize (GTK_WINDOW (pWindow),
347
 
                pFlyingContainer->container.iWidth,
348
 
                pFlyingContainer->container.iHeight);
349
 
        gtk_window_move (GTK_WINDOW (pWindow),
350
 
                pFlyingContainer->container.iWindowPositionX,
351
 
                pFlyingContainer->container.iWindowPositionY);*/
352
 
        gtk_window_present (GTK_WINDOW (pWindow));
353
 
        
354
 
        cairo_t *pSourceContext = cairo_dock_create_drawing_context_generic (CAIRO_CONTAINER (pFlyingContainer));
355
 
        _cairo_dock_load_hand_image (pSourceContext, pFlyingContainer->container.iWidth);
356
 
        _cairo_dock_load_explosion_image (pSourceContext, pFlyingContainer->container.iWidth);
357
 
        cairo_destroy (pSourceContext);
358
 
        
359
 
        pFlyingContainer->bDrawHand = bDrawHand;
360
 
        if (bDrawHand)
361
 
                cairo_dock_request_icon_animation (pFlyingIcon, CAIRO_CONTAINER (pFlyingContainer), bDrawHand ? "pulse" : "bounce", 1e6);
362
 
        cairo_dock_launch_animation (CAIRO_CONTAINER (pFlyingContainer));  // au cas ou pas d'animation.
363
 
        
364
 
        struct timeval tv;
365
 
        int r = gettimeofday (&tv, NULL);
366
 
        pFlyingContainer->fCreationTime = tv.tv_sec + tv.tv_usec * 1e-6;
367
 
        
368
 
        return pFlyingContainer;
369
 
}
370
 
 
371
 
void cairo_dock_drag_flying_container (CairoFlyingContainer *pFlyingContainer, CairoDock *pOriginDock)
372
 
{
373
 
        if (pOriginDock->container.bIsHorizontal)
374
 
        {
375
 
                pFlyingContainer->container.iWindowPositionX = pOriginDock->container.iWindowPositionX + pOriginDock->container.iMouseX - pFlyingContainer->container.iWidth/2;
376
 
                pFlyingContainer->container.iWindowPositionY = pOriginDock->container.iWindowPositionY + pOriginDock->container.iMouseY - pFlyingContainer->container.iHeight/2;
377
 
        }
378
 
        else
379
 
        {
380
 
                pFlyingContainer->container.iWindowPositionY = pOriginDock->container.iWindowPositionX + pOriginDock->container.iMouseX - pFlyingContainer->container.iWidth/2;
381
 
                pFlyingContainer->container.iWindowPositionX = pOriginDock->container.iWindowPositionY + pOriginDock->container.iMouseY - pFlyingContainer->container.iHeight/2;
382
 
        }
383
 
        //g_print ("  on tire l'icone volante en (%d;%d)\n", pFlyingContainer->container.iWindowPositionX, pFlyingContainer->container.iWindowPositionY);
384
 
        gtk_window_move (GTK_WINDOW (pFlyingContainer->container.pWidget),
385
 
                pFlyingContainer->container.iWindowPositionX,
386
 
                pFlyingContainer->container.iWindowPositionY);
387
 
}
388
 
 
389
 
void cairo_dock_free_flying_container (CairoFlyingContainer *pFlyingContainer)
390
 
{
391
 
        cd_debug ("%s ()", __func__);
392
 
        gtk_widget_destroy (pFlyingContainer->container.pWidget);  // enleve les signaux.
393
 
        if (pFlyingContainer->container.iSidGLAnimation != 0)
394
 
                g_source_remove (pFlyingContainer->container.iSidGLAnimation);
395
 
        g_free (pFlyingContainer);
396
 
}
397
 
 
398
 
void cairo_dock_terminate_flying_container (CairoFlyingContainer *pFlyingContainer)
399
 
{
400
 
        Icon *pIcon = pFlyingContainer->pIcon;
401
 
        pFlyingContainer->pIcon = NULL;
402
 
        pFlyingContainer->container.iAnimationStep = EXPLOSION_NB_FRAMES+1;
403
 
        
404
 
        if (pIcon->cDesktopFileName != NULL)  // c'est un lanceur, ou un separateur manuel, ou un sous-dock.
405
 
        {
406
 
                cairo_dock_remove_one_icon_from_dock (NULL, pIcon);
407
 
                cairo_dock_free_icon (pIcon);
408
 
        }
409
 
        else if (CAIRO_DOCK_IS_APPLET(pIcon))
410
 
        {
411
 
                cd_debug ("le module %s devient un desklet", pIcon->pModuleInstance->cConfFilePath);
412
 
                
413
 
                cairo_dock_stop_icon_animation (pIcon);
414
 
                GError *erreur = NULL;
415
 
                GKeyFile *pKeyFile = cairo_dock_open_key_file (pIcon->pModuleInstance->cConfFilePath);
416
 
                if (pKeyFile != NULL)
417
 
                {
418
 
                        //\______________ On centre le desklet sur l'icone volante.
419
 
                        int iDeskletWidth = cairo_dock_get_integer_key_value (pKeyFile, "Desklet", "width", NULL, 92, NULL, NULL);
420
 
                        int iDeskletHeight = cairo_dock_get_integer_key_value (pKeyFile, "Desklet", "height", NULL, 92, NULL, NULL);
421
 
                        
422
 
                        int iDeskletPositionX = pFlyingContainer->container.iWindowPositionX + (pFlyingContainer->container.iWidth - iDeskletWidth)/2;
423
 
                        int iDeskletPositionY = pFlyingContainer->container.iWindowPositionY + (pFlyingContainer->container.iHeight - iDeskletHeight)/2;
424
 
                        
425
 
                        int iRelativePositionX = (iDeskletPositionX + iDeskletWidth/2 <= g_iXScreenWidth[CAIRO_DOCK_HORIZONTAL]/2 ? iDeskletPositionX : iDeskletPositionX - g_iXScreenWidth[CAIRO_DOCK_HORIZONTAL]);
426
 
                        int iRelativePositionY = (iDeskletPositionY + iDeskletHeight/2 <= g_iXScreenHeight[CAIRO_DOCK_HORIZONTAL]/2 ? iDeskletPositionY : iDeskletPositionY - g_iXScreenHeight[CAIRO_DOCK_HORIZONTAL]);
427
 
                        
428
 
                        g_key_file_set_boolean (pKeyFile, "Desklet", "initially detached", TRUE);
429
 
                        g_key_file_set_double (pKeyFile, "Desklet", "x position", iDeskletPositionX);
430
 
                        g_key_file_set_double (pKeyFile, "Desklet", "y position", iDeskletPositionY);
431
 
                        
432
 
                        cairo_dock_update_desklet_detached_state_in_gui (pIcon->pModuleInstance, TRUE);
433
 
                        cairo_dock_update_desklet_position_in_gui (pIcon->pModuleInstance, iDeskletPositionX, iDeskletPositionY);
434
 
                        
435
 
                        cairo_dock_write_keys_to_file (pKeyFile, pIcon->pModuleInstance->cConfFilePath);
436
 
                        g_key_file_free (pKeyFile);
437
 
                        
438
 
                        //\______________ On detache le module.
439
 
                        cairo_dock_reload_module_instance (pIcon->pModuleInstance, TRUE);
440
 
                        
441
 
                        //\______________ On fait apparaitre le desklet avec un effet de zoom.
442
 
                        if (pIcon->pModuleInstance->pDesklet)  // normalement toujours vrai.
443
 
                        {
444
 
                                while (pIcon->pModuleInstance->pDesklet->iDesiredWidth != 0 && pIcon->pModuleInstance->pDesklet->iDesiredHeight != 0 && (pIcon->pModuleInstance->pDesklet->iKnownWidth != pIcon->pModuleInstance->pDesklet->iDesiredWidth || pIcon->pModuleInstance->pDesklet->iKnownHeight != pIcon->pModuleInstance->pDesklet->iDesiredHeight))
445
 
                                {
446
 
                                        gtk_main_iteration ();  // on le laisse se charger en plein.
447
 
                                        if (! pIcon->pModuleInstance->pDesklet)  // ne devrait pas arriver.
448
 
                                                break ;
449
 
                                }
450
 
                                cairo_dock_zoom_out_desklet (pIcon->pModuleInstance->pDesklet);
451
 
                        }
452
 
                }
453
 
        }
454
 
}