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

« back to all changes in this revision

Viewing changes to src/gldit/cairo-dock-load.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:
 
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 <math.h>
 
21
#include <string.h>
 
22
#include <stdlib.h>
 
23
 
 
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 <gtk/gtkgl.h>
 
33
 
 
34
#include "cairo-dock-draw.h"
 
35
#include "cairo-dock-icons.h"
 
36
#include "cairo-dock-surface-factory.h"
 
37
#include "cairo-dock-launcher-manager.h"
 
38
#include "cairo-dock-separator-manager.h"
 
39
#include "cairo-dock-applet-manager.h"
 
40
#include "cairo-dock-dock-factory.h"
 
41
#include "cairo-dock-modules.h"
 
42
#include "cairo-dock-log.h"
 
43
#include "cairo-dock-dock-manager.h"
 
44
#include "cairo-dock-class-manager.h"
 
45
#include "cairo-dock-X-utilities.h"
 
46
#include "cairo-dock-draw-opengl.h"
 
47
#include "cairo-dock-internal-taskbar.h"
 
48
#include "cairo-dock-internal-indicators.h"
 
49
#include "cairo-dock-internal-labels.h"
 
50
#include "cairo-dock-internal-background.h"
 
51
#include "cairo-dock-internal-icons.h"
 
52
#include "cairo-dock-container.h"
 
53
#include "cairo-dock-desklet-factory.h"
 
54
#include "cairo-dock-dialog-manager.h"
 
55
#include "cairo-dock-data-renderer.h"
 
56
#include "cairo-dock-flying-container.h"
 
57
#include "cairo-dock-emblem.h"
 
58
#include "cairo-dock-X-manager.h"
 
59
#include "cairo-dock-applications-manager.h"
 
60
#include "cairo-dock-icon-loader.h"
 
61
#include "cairo-dock-indicator-manager.h"
 
62
#include "cairo-dock-load.h"
 
63
 
 
64
#define CAIRO_DOCK_DEFAULT_APPLI_ICON_NAME "default-icon-appli.svg"
 
65
 
 
66
GLuint g_pGradationTexture[2]={0, 0};
 
67
 
 
68
extern CairoDockDesktopGeometry g_desktopGeometry;
 
69
extern CairoDockDesktopBackground *g_pFakeTransparencyDesktopBg;
 
70
 
 
71
extern gchar *g_cCurrentThemePath;
 
72
 
 
73
extern GLuint g_pGradationTexture[2];
 
74
 
 
75
extern gboolean g_bUseOpenGL;
 
76
 
 
77
static CairoDockDesktopBackground *s_pDesktopBg = NULL;  // une fois alloue, le pointeur restera le meme tout le temps.
 
78
 
 
79
void cairo_dock_free_label_description (CairoDockLabelDescription *pTextDescription)
 
80
{
 
81
        if (pTextDescription == NULL)
 
82
                return ;
 
83
        g_free (pTextDescription->cFont);
 
84
        g_free (pTextDescription);
 
85
}
 
86
 
 
87
void cairo_dock_copy_label_description (CairoDockLabelDescription *pDestTextDescription, CairoDockLabelDescription *pOrigTextDescription)
 
88
{
 
89
        g_return_if_fail (pOrigTextDescription != NULL && pDestTextDescription != NULL);
 
90
        memcpy (pDestTextDescription, pOrigTextDescription, sizeof (CairoDockLabelDescription));
 
91
        pDestTextDescription->cFont = g_strdup (pOrigTextDescription->cFont);
 
92
}
 
93
 
 
94
CairoDockLabelDescription *cairo_dock_duplicate_label_description (CairoDockLabelDescription *pOrigTextDescription)
 
95
{
 
96
        g_return_val_if_fail (pOrigTextDescription != NULL, NULL);
 
97
        CairoDockLabelDescription *pTextDescription = g_memdup (pOrigTextDescription, sizeof (CairoDockLabelDescription));
 
98
        pTextDescription->cFont = g_strdup (pOrigTextDescription->cFont);
 
99
        return pTextDescription;
 
100
}
 
101
 
 
102
gchar *cairo_dock_generate_file_path (const gchar *cImageFile)
 
103
{
 
104
        g_return_val_if_fail (cImageFile != NULL, NULL);
 
105
        gchar *cImagePath;
 
106
        if (*cImageFile == '~')
 
107
        {
 
108
                cImagePath = g_strdup_printf ("%s%s", getenv("HOME"), cImageFile + 1);
 
109
        }
 
110
        else if (*cImageFile == '/')
 
111
        {
 
112
                cImagePath = g_strdup (cImageFile);
 
113
        }
 
114
        else
 
115
        {
 
116
                cImagePath = g_strdup_printf ("%s/%s", g_cCurrentThemePath, cImageFile);
 
117
        }
 
118
        return cImagePath;
 
119
}
 
120
 
 
121
 
 
122
void cairo_dock_load_image_buffer_full (CairoDockImageBuffer *pImage, const gchar *cImageFile, int iWidth, int iHeight, CairoDockLoadImageModifier iLoadModifier, double fAlpha)
 
123
{
 
124
        if (cImageFile == NULL)
 
125
                return;
 
126
        gchar *cImagePath = cairo_dock_generate_file_path (cImageFile);
 
127
        double w, h;
 
128
        pImage->pSurface = cairo_dock_create_surface_from_image (
 
129
                cImagePath,
 
130
                1.,
 
131
                iWidth,
 
132
                iHeight,
 
133
                iLoadModifier,
 
134
                &w,
 
135
                &h,
 
136
                &pImage->fZoomX,
 
137
                &pImage->fZoomY);
 
138
        pImage->iWidth = w;
 
139
        pImage->iHeight = h;
 
140
        
 
141
        if (fAlpha < 1)
 
142
        {
 
143
                cairo_surface_t *pNewSurfaceAlpha = cairo_dock_create_blank_surface (
 
144
                        w,
 
145
                        h);
 
146
                cairo_t *pCairoContext = cairo_create (pNewSurfaceAlpha);
 
147
 
 
148
                cairo_set_source_surface (pCairoContext, pImage->pSurface, 0, 0);
 
149
                cairo_paint_with_alpha (pCairoContext, fAlpha);
 
150
                cairo_destroy (pCairoContext);
 
151
 
 
152
                cairo_surface_destroy (pImage->pSurface);
 
153
                pImage->pSurface = pNewSurfaceAlpha;
 
154
        }
 
155
        
 
156
        if (g_bUseOpenGL)
 
157
                pImage->iTexture = cairo_dock_create_texture_from_surface (pImage->pSurface);
 
158
        
 
159
        g_free (cImagePath);
 
160
}
 
161
 
 
162
void cairo_dock_load_image_buffer_from_surface (CairoDockImageBuffer *pImage, cairo_surface_t *pSurface, int iWidth, int iHeight)
 
163
{
 
164
        pImage->pSurface = pSurface;
 
165
        pImage->iWidth = iWidth;
 
166
        pImage->iHeight = iHeight;
 
167
        pImage->fZoomX = 1.;
 
168
        pImage->fZoomY = 1.;
 
169
        if (g_bUseOpenGL)
 
170
                pImage->iTexture = cairo_dock_create_texture_from_surface (pImage->pSurface);
 
171
}
 
172
 
 
173
CairoDockImageBuffer *cairo_dock_create_image_buffer (const gchar *cImageFile, int iWidth, int iHeight, CairoDockLoadImageModifier iLoadModifier)
 
174
{
 
175
        CairoDockImageBuffer *pImage = g_new0 (CairoDockImageBuffer, 1);
 
176
        
 
177
        cairo_dock_load_image_buffer (pImage, cImageFile, iWidth, iHeight, iLoadModifier);
 
178
        
 
179
        return pImage;
 
180
}
 
181
 
 
182
void cairo_dock_unload_image_buffer (CairoDockImageBuffer *pImage)
 
183
{
 
184
        if (pImage->pSurface != NULL)
 
185
        {
 
186
                cairo_surface_destroy (pImage->pSurface);
 
187
        }
 
188
        if (pImage->iTexture != 0)
 
189
        {
 
190
                _cairo_dock_delete_texture (pImage->iTexture);
 
191
        }
 
192
        memset (pImage, 0, sizeof (CairoDockImageBuffer));
 
193
}
 
194
 
 
195
void cairo_dock_free_image_buffer (CairoDockImageBuffer *pImage)
 
196
{
 
197
        if (pImage == NULL)
 
198
                return;
 
199
        cairo_dock_unload_image_buffer (pImage);
 
200
        g_free (pImage);
 
201
}
 
202
 
 
203
 
 
204
  ///////////////////////
 
205
 /// DOCK BACKGROUND ///
 
206
///////////////////////
 
207
 
 
208
static cairo_surface_t *_cairo_dock_make_stripes_background (int iWidth, int iHeight, double *fStripesColorBright, double *fStripesColorDark, int iNbStripes, double fStripesWidth, double fStripesAngle)
 
209
{
 
210
        cairo_pattern_t *pStripesPattern;
 
211
        double fWidth = iWidth;
 
212
        if (fabs (fStripesAngle) != 90)
 
213
                pStripesPattern = cairo_pattern_create_linear (0.0f,
 
214
                        0.0f,
 
215
                        iWidth,
 
216
                        iWidth * tan (fStripesAngle * G_PI/180.));
 
217
        else
 
218
                pStripesPattern = cairo_pattern_create_linear (0.0f,
 
219
                        0.0f,
 
220
                        0.,
 
221
                        (fStripesAngle == 90) ? iHeight : - iHeight);
 
222
        g_return_val_if_fail (cairo_pattern_status (pStripesPattern) == CAIRO_STATUS_SUCCESS, NULL);
 
223
 
 
224
        cairo_pattern_set_extend (pStripesPattern, CAIRO_EXTEND_REPEAT);
 
225
 
 
226
        if (iNbStripes > 0)
 
227
        {
 
228
                gdouble fStep;
 
229
                int i;
 
230
                for (i = 0; i < iNbStripes+1; i ++)
 
231
                {
 
232
                        fStep = (double)i / iNbStripes;
 
233
                        cairo_pattern_add_color_stop_rgba (pStripesPattern,
 
234
                                fStep - fStripesWidth / 2.,
 
235
                                fStripesColorBright[0],
 
236
                                fStripesColorBright[1],
 
237
                                fStripesColorBright[2],
 
238
                                fStripesColorBright[3]);
 
239
                        cairo_pattern_add_color_stop_rgba (pStripesPattern,
 
240
                                fStep,
 
241
                                fStripesColorDark[0],
 
242
                                fStripesColorDark[1],
 
243
                                fStripesColorDark[2],
 
244
                                fStripesColorDark[3]);
 
245
                        cairo_pattern_add_color_stop_rgba (pStripesPattern,
 
246
                                fStep + fStripesWidth / 2.,
 
247
                                fStripesColorBright[0],
 
248
                                fStripesColorBright[1],
 
249
                                fStripesColorBright[2],
 
250
                                fStripesColorBright[3]);
 
251
                }
 
252
        }
 
253
        else
 
254
        {
 
255
                cairo_pattern_add_color_stop_rgba (pStripesPattern,
 
256
                        0.,
 
257
                        fStripesColorDark[0],
 
258
                        fStripesColorDark[1],
 
259
                        fStripesColorDark[2],
 
260
                        fStripesColorDark[3]);
 
261
                cairo_pattern_add_color_stop_rgba (pStripesPattern,
 
262
                        1.,
 
263
                        fStripesColorBright[0],
 
264
                        fStripesColorBright[1],
 
265
                        fStripesColorBright[2],
 
266
                        fStripesColorBright[3]);
 
267
        }
 
268
 
 
269
        cairo_surface_t *pNewSurface = cairo_dock_create_blank_surface (
 
270
                        iWidth,
 
271
                        iHeight);
 
272
        cairo_t *pImageContext = cairo_create (pNewSurface);
 
273
        cairo_set_source (pImageContext, pStripesPattern);
 
274
        cairo_paint (pImageContext);
 
275
 
 
276
        cairo_pattern_destroy (pStripesPattern);
 
277
        cairo_destroy (pImageContext);
 
278
        
 
279
        return pNewSurface;
 
280
}
 
281
static void _cairo_dock_load_default_background (CairoDockImageBuffer *pImage, int iWidth, int iHeight)
 
282
{
 
283
        //g_print ("%s (%s, %d)\n", __func__, myBackground.cBackgroundImageFile, myBackground.bBackgroundImageRepeat);
 
284
        if (myBackground.cBackgroundImageFile != NULL)
 
285
        {
 
286
                if (myBackground.bBackgroundImageRepeat)
 
287
                {
 
288
                        cairo_surface_t *pBgSurface = cairo_dock_create_surface_from_pattern (myBackground.cBackgroundImageFile,
 
289
                                iWidth,
 
290
                                iHeight,
 
291
                                myBackground.fBackgroundImageAlpha);
 
292
                        cairo_dock_load_image_buffer_from_surface (pImage,
 
293
                                pBgSurface,
 
294
                                iWidth,
 
295
                                iHeight);
 
296
                }
 
297
                else
 
298
                {
 
299
                        cairo_dock_load_image_buffer_full (pImage,
 
300
                                myBackground.cBackgroundImageFile,
 
301
                                iWidth,
 
302
                                iHeight,
 
303
                                CAIRO_DOCK_FILL_SPACE,
 
304
                                myBackground.fBackgroundImageAlpha);
 
305
                }
 
306
        }
 
307
        if (pImage->pSurface == NULL)
 
308
        {
 
309
                cairo_surface_t *pBgSurface = _cairo_dock_make_stripes_background (
 
310
                        iWidth,
 
311
                        iHeight,
 
312
                        myBackground.fStripesColorBright,
 
313
                        myBackground.fStripesColorDark,
 
314
                        myBackground.iNbStripes,
 
315
                        myBackground.fStripesWidth,
 
316
                        myBackground.fStripesAngle);
 
317
                cairo_dock_load_image_buffer_from_surface (pImage,
 
318
                        pBgSurface,
 
319
                        iWidth,
 
320
                        iHeight);
 
321
        }
 
322
}
 
323
 
 
324
void cairo_dock_load_dock_background (CairoDock *pDock)
 
325
{
 
326
        cairo_dock_unload_image_buffer (&pDock->backgroundBuffer);
 
327
        
 
328
        int iWidth = pDock->iDecorationsWidth;
 
329
        int iHeight = pDock->iDecorationsHeight;
 
330
        
 
331
        if (pDock->bGlobalBg || pDock->iRefCount > 0)
 
332
        {
 
333
                _cairo_dock_load_default_background (&pDock->backgroundBuffer, iWidth, iHeight);
 
334
        }
 
335
        else if (pDock->cBgImagePath != NULL)
 
336
        {
 
337
                cairo_dock_load_image_buffer (&pDock->backgroundBuffer, pDock->cBgImagePath, iWidth, iHeight, CAIRO_DOCK_FILL_SPACE);
 
338
        }
 
339
        if (pDock->backgroundBuffer.pSurface == NULL)
 
340
        {
 
341
                cairo_surface_t *pSurface = _cairo_dock_make_stripes_background (iWidth, iHeight, pDock->fBgColorBright, pDock->fBgColorDark, 0, 0., 90);
 
342
                cairo_dock_load_image_buffer_from_surface (&pDock->backgroundBuffer, pSurface, iWidth, iHeight);
 
343
        }
 
344
}
 
345
 
 
346
static gboolean _load_background_idle (CairoDock *pDock)
 
347
{
 
348
        cairo_dock_load_dock_background (pDock);
 
349
        
 
350
        pDock->iSidLoadBg = 0;
 
351
        return FALSE;
 
352
}
 
353
void cairo_dock_trigger_load_dock_background (CairoDock *pDock)
 
354
{
 
355
        if (pDock->iDecorationsWidth == pDock->backgroundBuffer.iWidth && pDock->iDecorationsHeight == pDock->backgroundBuffer.iHeight)  // mise a jour inutile.
 
356
                return;
 
357
        if (pDock->iSidLoadBg == 0)
 
358
                pDock->iSidLoadBg = g_idle_add ((GSourceFunc)_load_background_idle, pDock);
 
359
}
 
360
 
 
361
 
 
362
  //////////////////
 
363
 /// DESKTOP BG ///
 
364
//////////////////
 
365
 
 
366
static cairo_surface_t *_cairo_dock_create_surface_from_desktop_bg (void)  // attention : fonction lourde.
 
367
{
 
368
        cd_debug ("%s ()", __func__);
 
369
        Pixmap iRootPixmapID = cairo_dock_get_window_background_pixmap (cairo_dock_get_root_id ());
 
370
        g_return_val_if_fail (iRootPixmapID != 0, NULL);
 
371
        
 
372
        cairo_surface_t *pDesktopBgSurface = NULL;
 
373
        GdkPixbuf *pBgPixbuf = cairo_dock_get_pixbuf_from_pixmap (iRootPixmapID, FALSE);  // FALSE <=> on n'y ajoute pas de transparence.
 
374
        if (pBgPixbuf != NULL)
 
375
        {
 
376
                if (gdk_pixbuf_get_height (pBgPixbuf) == 1 && gdk_pixbuf_get_width (pBgPixbuf) == 1)  // couleur unie.
 
377
                {
 
378
                        guchar *pixels = gdk_pixbuf_get_pixels (pBgPixbuf);
 
379
                        cd_debug ("c'est une couleur unie (%.2f, %.2f, %.2f)", (double) pixels[0] / 255, (double) pixels[1] / 255, (double) pixels[2] / 255);
 
380
                        
 
381
                        pDesktopBgSurface = cairo_dock_create_blank_surface (
 
382
                                g_desktopGeometry.iXScreenWidth[CAIRO_DOCK_HORIZONTAL],
 
383
                                g_desktopGeometry.iXScreenHeight[CAIRO_DOCK_HORIZONTAL]);
 
384
                        
 
385
                        cairo_t *pCairoContext = cairo_create (pDesktopBgSurface);
 
386
                        cairo_set_source_rgb (pCairoContext,
 
387
                                (double) pixels[0] / 255,
 
388
                                (double) pixels[1] / 255,
 
389
                                (double) pixels[2] / 255);
 
390
                        cairo_set_operator (pCairoContext, CAIRO_OPERATOR_SOURCE);
 
391
                        cairo_paint (pCairoContext);
 
392
                        cairo_destroy (pCairoContext);
 
393
                }
 
394
                else
 
395
                {
 
396
                        double fWidth, fHeight;
 
397
                        cairo_surface_t *pBgSurface = cairo_dock_create_surface_from_pixbuf (pBgPixbuf,
 
398
                                1,
 
399
                                0,
 
400
                                0,
 
401
                                FALSE,
 
402
                                &fWidth,
 
403
                                &fHeight,
 
404
                                NULL, NULL);
 
405
                        
 
406
                        if (fWidth < g_desktopGeometry.iXScreenWidth[CAIRO_DOCK_HORIZONTAL] || fHeight < g_desktopGeometry.iXScreenHeight[CAIRO_DOCK_HORIZONTAL])
 
407
                        {
 
408
                                cd_debug ("c'est un degrade ou un motif (%dx%d)", (int) fWidth, (int) fHeight);
 
409
                                pDesktopBgSurface = cairo_dock_create_blank_surface (
 
410
                                        g_desktopGeometry.iXScreenWidth[CAIRO_DOCK_HORIZONTAL],
 
411
                                        g_desktopGeometry.iXScreenHeight[CAIRO_DOCK_HORIZONTAL]);
 
412
                                cairo_t *pCairoContext = cairo_create (pDesktopBgSurface);
 
413
                                
 
414
                                cairo_pattern_t *pPattern = cairo_pattern_create_for_surface (pBgSurface);
 
415
                                g_return_val_if_fail (cairo_pattern_status (pPattern) == CAIRO_STATUS_SUCCESS, NULL);
 
416
                                cairo_pattern_set_extend (pPattern, CAIRO_EXTEND_REPEAT);
 
417
                                
 
418
                                cairo_set_source (pCairoContext, pPattern);
 
419
                                cairo_paint (pCairoContext);
 
420
                                
 
421
                                cairo_destroy (pCairoContext);
 
422
                                cairo_pattern_destroy (pPattern);
 
423
                                cairo_surface_destroy (pBgSurface);
 
424
                        }
 
425
                        else
 
426
                        {
 
427
                                cd_debug ("c'est un fond d'ecran de taille %dx%d", (int) fWidth, (int) fHeight);
 
428
                                pDesktopBgSurface = pBgSurface;
 
429
                        }
 
430
                }
 
431
                
 
432
                g_object_unref (pBgPixbuf);
 
433
        }
 
434
        return pDesktopBgSurface;
 
435
}
 
436
 
 
437
CairoDockDesktopBackground *cairo_dock_get_desktop_background (gboolean bWithTextureToo)
 
438
{
 
439
        cd_message ("%s (%d, %d)", __func__, bWithTextureToo, s_pDesktopBg?s_pDesktopBg->iRefCount:-1);
 
440
        if (s_pDesktopBg == NULL)
 
441
        {
 
442
                s_pDesktopBg = g_new0 (CairoDockDesktopBackground, 1);
 
443
        }
 
444
        if (s_pDesktopBg->iRefCount == 0)
 
445
        {
 
446
                s_pDesktopBg->pSurface = _cairo_dock_create_surface_from_desktop_bg ();
 
447
        }
 
448
        if (s_pDesktopBg->iTexture == 0 && bWithTextureToo)
 
449
        {
 
450
                s_pDesktopBg->iTexture = cairo_dock_create_texture_from_surface (s_pDesktopBg->pSurface);
 
451
        }
 
452
        
 
453
        s_pDesktopBg->iRefCount ++;
 
454
        if (s_pDesktopBg->iSidDestroyBg != 0)
 
455
        {
 
456
                g_source_remove (s_pDesktopBg->iSidDestroyBg);
 
457
                s_pDesktopBg->iSidDestroyBg = 0;
 
458
        }
 
459
        return s_pDesktopBg;
 
460
}
 
461
 
 
462
static gboolean _destroy_bg (CairoDockDesktopBackground *pDesktopBg)
 
463
{
 
464
        cd_message ("%s ()", __func__);
 
465
        g_return_val_if_fail (pDesktopBg != NULL, 0);
 
466
        if (pDesktopBg->pSurface != NULL)
 
467
        {
 
468
                cairo_surface_destroy (pDesktopBg->pSurface);
 
469
                pDesktopBg->pSurface = NULL;
 
470
        }
 
471
        if (pDesktopBg->iTexture != 0)
 
472
        {
 
473
                _cairo_dock_delete_texture (pDesktopBg->iTexture);
 
474
                pDesktopBg->iTexture = 0;
 
475
        }
 
476
        pDesktopBg->iSidDestroyBg = 0;
 
477
        return FALSE;
 
478
}
 
479
void cairo_dock_destroy_desktop_background (CairoDockDesktopBackground *pDesktopBg)
 
480
{
 
481
        g_return_if_fail (pDesktopBg != NULL);
 
482
        if (pDesktopBg->iRefCount > 0)
 
483
                pDesktopBg->iRefCount --;
 
484
        if (pDesktopBg->iRefCount == 0 && pDesktopBg->iSidDestroyBg == 0)
 
485
        {
 
486
                pDesktopBg->iSidDestroyBg = g_timeout_add_seconds (3, (GSourceFunc)_destroy_bg, pDesktopBg);
 
487
        }
 
488
}
 
489
 
 
490
cairo_surface_t *cairo_dock_get_desktop_bg_surface (CairoDockDesktopBackground *pDesktopBg)
 
491
{
 
492
        g_return_val_if_fail (pDesktopBg != NULL, NULL);
 
493
        return pDesktopBg->pSurface;
 
494
}
 
495
 
 
496
GLuint cairo_dock_get_desktop_bg_texture (CairoDockDesktopBackground *pDesktopBg)
 
497
{
 
498
        g_return_val_if_fail (pDesktopBg != NULL, 0);
 
499
        return pDesktopBg->iTexture;
 
500
}
 
501
 
 
502
void cairo_dock_reload_desktop_background (void)
 
503
{
 
504
        cd_message ("%s ()", __func__);
 
505
        if (s_pDesktopBg == NULL)  // rien a recharger.
 
506
                return ;
 
507
        if (s_pDesktopBg->pSurface == NULL && s_pDesktopBg->iTexture == 0)  // rien a recharger.
 
508
                return ;
 
509
        
 
510
        if (s_pDesktopBg->pSurface != NULL)
 
511
                cairo_surface_destroy (s_pDesktopBg->pSurface);
 
512
        s_pDesktopBg->pSurface = _cairo_dock_create_surface_from_desktop_bg ();
 
513
        
 
514
        if (s_pDesktopBg->iTexture != 0)
 
515
        {
 
516
                _cairo_dock_delete_texture (s_pDesktopBg->iTexture);
 
517
                s_pDesktopBg->iTexture = cairo_dock_create_texture_from_surface (s_pDesktopBg->pSurface);
 
518
        }
 
519
}
 
520
 
 
521
 
 
522
void cairo_dock_unload_additionnal_textures (void)
 
523
{
 
524
        cd_debug ("");
 
525
        if (s_pDesktopBg)  // on decharge le desktop-bg de force.
 
526
        {
 
527
                _destroy_bg (s_pDesktopBg);  // detruit ses ressources immediatement, mais pas le pointeur.
 
528
                if (s_pDesktopBg->iSidDestroyBg != 0)
 
529
                {
 
530
                        g_source_remove (s_pDesktopBg->iSidDestroyBg);
 
531
                        s_pDesktopBg->iSidDestroyBg = 0;
 
532
                }
 
533
                s_pDesktopBg->iRefCount = 0;
 
534
        }
 
535
        g_pFakeTransparencyDesktopBg = NULL;
 
536
        cairo_dock_unload_desklet_buttons ();
 
537
        cairo_dock_unload_dialog_buttons ();
 
538
        cairo_dock_unload_icon_textures ();
 
539
        cairo_dock_unload_indicator_textures ();
 
540
        if (g_pGradationTexture[0] != 0)
 
541
        {
 
542
                _cairo_dock_delete_texture (g_pGradationTexture[0]);
 
543
                g_pGradationTexture[0] = 0;
 
544
        }
 
545
        if (g_pGradationTexture[1] != 0)
 
546
        {
 
547
                _cairo_dock_delete_texture (g_pGradationTexture[1]);
 
548
                g_pGradationTexture[1] = 0;
 
549
        }
 
550
        if (s_pDesktopBg != NULL && s_pDesktopBg->iTexture != 0)
 
551
        {
 
552
                _cairo_dock_delete_texture (s_pDesktopBg->iTexture);
 
553
                s_pDesktopBg->iTexture = 0;
 
554
        }
 
555
        ///cairo_dock_destroy_icon_pbuffer ();
 
556
        cairo_dock_destroy_icon_fbo ();
 
557
        cairo_dock_unload_default_data_renderer_font ();
 
558
        cairo_dock_unload_flying_container_textures ();
 
559
        cairo_dock_reset_source_context ();
 
560
}