← 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-renderer-manager.c

  • Committer: Bazaar Package Importer
  • Author(s): Matthieu Baerts (matttbe)
  • Date: 2010-08-09 23:26:12 UTC
  • mfrom: (1.1.10 upstream)
  • Revision ID: james.westby@ubuntu.com-20100809232612-yp4c6ig3jt1bzpdv
Tags: 2.2.0~0beta4-0ubuntu1
https://launchpad.net/bugs/614624
https://launchpad.net/bugs/518453
https://launchpad.net/bugs/521369
https://launchpad.net/bugs/521762
https://launchpad.net/bugs/526466
https://launchpad.net/bugs/535083
* New Upstream Version (LP: #614624)
* Fixed a few bugs on LP:
 - LP: #518453: Dock appears under all windows
                 (Compiz - fullscreen window)
 - LP: #521369: Separator are not removed when closing
                 grouped windows
 - LP: #521762: Some sentences are not correct
 - LP: #526466: Icons of apps with same class shouldn't
                 be stacked by default
 - LP: #535083: Dialogues looks ugly when a lot of them
                 appears at the same time
 - More details on the 'ChangeLog' file
* debian/rules:
 - Autotools has been replaced by CMake
 - Man pages are now included in the source code
* debian/copyright:
 - Updated with the new pathes and new files
* debian/control:
 - Autotools has been replaced by CMake
 - Added libcurl4-gnutls-dev as Build-deps
 - Bump Standard-Version to 3.9.1
* debian/cairo-dock-core.install:
 - Man pages are now included in the source code
 - All sonames are now installed into lib32 or lib64
* debian/cairo-dock-dev.install:
 - pkgconfig is now installed into lib32 or lib64

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/cairo-dock-renderer-manager.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 <string.h>
22
 
 
23
 
#include "cairo-dock-draw.h"
24
 
#include "cairo-dock-icons.h"
25
 
#include "cairo-dock-callbacks.h"
26
 
#include "cairo-dock-keyfile-utilities.h"
27
 
#include "cairo-dock-dock-factory.h"
28
 
#include "cairo-dock-log.h"
29
 
#include "cairo-dock-gui-factory.h"
30
 
#include "cairo-dock-internal-views.h"
31
 
#include "cairo-dock-internal-desklets.h"
32
 
#include "cairo-dock-internal-system.h"
33
 
#include "cairo-dock-animations.h"
34
 
#include "cairo-dock-dialogs.h"
35
 
#include "cairo-dock-container.h"
36
 
#include "cairo-dock-renderer-manager.h"
37
 
 
38
 
extern gboolean g_bUseOpenGL;
39
 
 
40
 
static GHashTable *s_hRendererTable = NULL;  // table des rendus de dock.
41
 
static GHashTable *s_hDeskletRendererTable = NULL;  // table des rendus des desklets.
42
 
static GHashTable *s_hDialogRendererTable = NULL;  // table des rendus des dialogues.
43
 
static GHashTable *s_hDeskletDecorationsTable = NULL;  // table des decorations des desklets.
44
 
static GHashTable *s_hAnimationsTable = NULL;  // table des animations disponibles.
45
 
static GHashTable *s_hDialogDecoratorTable = NULL;  // table des decorateurs de dialogues disponibles.
46
 
static GHashTable *s_hDataRendererTable = NULL;  // table des rendus de donnees disponibles.
47
 
 
48
 
 
49
 
CairoDockRenderer *cairo_dock_get_renderer (const gchar *cRendererName, gboolean bForMainDock)
50
 
{
51
 
        //g_print ("%s (%s, %d)\n", __func__, cRendererName, bForMainDock);
52
 
        CairoDockRenderer *pRenderer = NULL;
53
 
        if (cRendererName != NULL)
54
 
                pRenderer = g_hash_table_lookup (s_hRendererTable, cRendererName);
55
 
        
56
 
        if (pRenderer == NULL)
57
 
        {
58
 
                const gchar *cDefaultRendererName = (bForMainDock ? myViews.cMainDockDefaultRendererName : myViews.cSubDockDefaultRendererName);
59
 
                //g_print ("  cDefaultRendererName : %s\n", cDefaultRendererName);
60
 
                if (cDefaultRendererName != NULL)
61
 
                        pRenderer = g_hash_table_lookup (s_hRendererTable, cDefaultRendererName);
62
 
        }
63
 
        
64
 
        if (pRenderer == NULL)
65
 
                pRenderer = g_hash_table_lookup (s_hRendererTable, CAIRO_DOCK_DEFAULT_RENDERER_NAME);
66
 
        
67
 
        return pRenderer;
68
 
}
69
 
 
70
 
void cairo_dock_register_renderer (const gchar *cRendererName, CairoDockRenderer *pRenderer)
71
 
{
72
 
        cd_message ("%s (%s)", __func__, cRendererName);
73
 
        g_hash_table_insert (s_hRendererTable, g_strdup (cRendererName), pRenderer);
74
 
}
75
 
 
76
 
void cairo_dock_remove_renderer (const gchar *cRendererName)
77
 
{
78
 
        g_hash_table_remove (s_hRendererTable, cRendererName);
79
 
}
80
 
 
81
 
 
82
 
CairoDeskletRenderer *cairo_dock_get_desklet_renderer (const gchar *cRendererName)
83
 
{
84
 
        if (cRendererName != NULL)
85
 
                return g_hash_table_lookup (s_hDeskletRendererTable, cRendererName);
86
 
        else
87
 
                return NULL;
88
 
}
89
 
 
90
 
void cairo_dock_register_desklet_renderer (const gchar *cRendererName, CairoDeskletRenderer *pRenderer)
91
 
{
92
 
        cd_message ("%s (%s)", __func__, cRendererName);
93
 
        g_hash_table_insert (s_hDeskletRendererTable, g_strdup (cRendererName), pRenderer);
94
 
}
95
 
 
96
 
void cairo_dock_remove_desklet_renderer (const gchar *cRendererName)
97
 
{
98
 
        g_hash_table_remove (s_hDeskletRendererTable, cRendererName);
99
 
}
100
 
 
101
 
void cairo_dock_predefine_desklet_renderer_config (CairoDeskletRenderer *pRenderer, const gchar *cConfigName, CairoDeskletRendererConfigPtr pConfig)
102
 
{
103
 
        g_return_if_fail (cConfigName != NULL && pConfig != NULL);
104
 
        CairoDeskletRendererPreDefinedConfig *pPreDefinedConfig = g_new (CairoDeskletRendererPreDefinedConfig, 1);
105
 
        pPreDefinedConfig->cName = g_strdup (cConfigName);
106
 
        pPreDefinedConfig->pConfig = pConfig;
107
 
        pRenderer->pPreDefinedConfigList = g_list_prepend (pRenderer->pPreDefinedConfigList, pPreDefinedConfig);
108
 
}
109
 
 
110
 
CairoDeskletRendererConfigPtr cairo_dock_get_desklet_renderer_predefined_config (const gchar *cRendererName, const gchar *cConfigName)
111
 
{
112
 
        CairoDeskletRenderer *pRenderer = cairo_dock_get_desklet_renderer (cRendererName);
113
 
        g_return_val_if_fail (pRenderer != NULL && cConfigName != NULL, NULL);
114
 
        
115
 
        GList *c;
116
 
        CairoDeskletRendererPreDefinedConfig *pPreDefinedConfig;
117
 
        for (c = pRenderer->pPreDefinedConfigList; c != NULL; c = c->next)
118
 
        {
119
 
                pPreDefinedConfig = c->data;
120
 
                if (strcmp (pPreDefinedConfig->cName, cConfigName) == 0)
121
 
                        return pPreDefinedConfig->pConfig;
122
 
        }
123
 
        return NULL;
124
 
}
125
 
 
126
 
 
127
 
CairoDialogRenderer *cairo_dock_get_dialog_renderer (const gchar *cRendererName)
128
 
{
129
 
        if (cRendererName != NULL)
130
 
                return g_hash_table_lookup (s_hDialogRendererTable, cRendererName);
131
 
        else
132
 
                return NULL;
133
 
}
134
 
 
135
 
void cairo_dock_register_dialog_renderer (const gchar *cRendererName, CairoDialogRenderer *pRenderer)
136
 
{
137
 
        cd_message ("%s (%s)", __func__, cRendererName);
138
 
        g_hash_table_insert (s_hDialogRendererTable, g_strdup (cRendererName), pRenderer);
139
 
}
140
 
 
141
 
void cairo_dock_remove_dialog_renderer (const gchar *cRendererName)
142
 
{
143
 
        g_hash_table_remove (s_hDialogRendererTable, cRendererName);
144
 
}
145
 
 
146
 
 
147
 
CairoDeskletDecoration *cairo_dock_get_desklet_decoration (const gchar *cDecorationName)
148
 
{
149
 
        if (cDecorationName != NULL)
150
 
                return g_hash_table_lookup (s_hDeskletDecorationsTable, cDecorationName);
151
 
        else if (myDesklets.cDeskletDecorationsName != NULL)
152
 
                return g_hash_table_lookup (s_hDeskletDecorationsTable, myDesklets.cDeskletDecorationsName);
153
 
        else
154
 
                return NULL;
155
 
}
156
 
 
157
 
void cairo_dock_register_desklet_decoration (const gchar *cDecorationName, CairoDeskletDecoration *pDecoration)
158
 
{
159
 
        cd_message ("%s (%s)", __func__, cDecorationName);
160
 
        g_hash_table_insert (s_hDeskletDecorationsTable, g_strdup (cDecorationName), pDecoration);
161
 
}
162
 
 
163
 
void cairo_dock_remove_desklet_decoration (const gchar *cDecorationName)
164
 
{
165
 
        g_hash_table_remove (s_hDeskletDecorationsTable, cDecorationName);
166
 
}
167
 
 
168
 
 
169
 
CairoDataRendererNewFunc cairo_dock_get_data_renderer_entry_point (const gchar *cRendererName)
170
 
{
171
 
        if (cRendererName != NULL)
172
 
                return g_hash_table_lookup (s_hDataRendererTable, cRendererName);
173
 
        else
174
 
                return NULL;
175
 
}
176
 
 
177
 
void cairo_dock_register_data_renderer_entry_point (const gchar *cRendererName, CairoDataRendererNewFunc pFunc)
178
 
{
179
 
        cd_message ("%s (%s)", __func__, cRendererName);
180
 
        g_hash_table_insert (s_hDataRendererTable, g_strdup (cRendererName), pFunc);
181
 
}
182
 
 
183
 
void cairo_dock_remove_data_renderer_entry_point (const gchar *cRendererName)
184
 
{
185
 
        g_hash_table_remove (s_hDataRendererTable, cRendererName);
186
 
}
187
 
 
188
 
void cairo_dock_initialize_renderer_manager (void)
189
 
{
190
 
        g_return_if_fail (s_hRendererTable == NULL);
191
 
        cd_message ("");
192
 
        
193
 
        s_hRendererTable = g_hash_table_new_full (g_str_hash,
194
 
                g_str_equal,
195
 
                g_free,
196
 
                g_free);
197
 
        
198
 
        s_hDeskletRendererTable = g_hash_table_new_full (g_str_hash,
199
 
                g_str_equal,
200
 
                g_free,
201
 
                g_free);
202
 
        
203
 
        s_hDialogRendererTable = g_hash_table_new_full (g_str_hash,
204
 
                g_str_equal,
205
 
                g_free,
206
 
                g_free);
207
 
        
208
 
        s_hDeskletDecorationsTable = g_hash_table_new_full (g_str_hash,
209
 
                g_str_equal,
210
 
                g_free,
211
 
                (GFreeFunc) cairo_dock_free_desklet_decoration);
212
 
        
213
 
        s_hAnimationsTable = g_hash_table_new_full (g_str_hash,
214
 
                g_str_equal,
215
 
                g_free,
216
 
                (GFreeFunc) cairo_dock_free_animation_record);
217
 
        
218
 
        s_hDialogDecoratorTable = g_hash_table_new_full (g_str_hash,
219
 
                g_str_equal,
220
 
                g_free,
221
 
                g_free);
222
 
        
223
 
        s_hDataRendererTable = g_hash_table_new_full (g_str_hash,
224
 
                g_str_equal,
225
 
                g_free,
226
 
                NULL);
227
 
}
228
 
 
229
 
 
230
 
void cairo_dock_set_renderer (CairoDock *pDock, const gchar *cRendererName)
231
 
{
232
 
        g_return_if_fail (pDock != NULL);
233
 
        cd_message ("%s (%x:%s)", __func__, pDock, cRendererName);
234
 
        
235
 
        if (pDock->pRenderer && pDock->pRenderer->free_data)
236
 
        {
237
 
                pDock->pRenderer->free_data (pDock);
238
 
                pDock->pRendererData = NULL;
239
 
        }
240
 
        pDock->pRenderer = cairo_dock_get_renderer (cRendererName, (pDock->iRefCount == 0));
241
 
        
242
 
        pDock->fMagnitudeMax = 1.;
243
 
        pDock->container.bUseReflect = pDock->pRenderer->bUseReflect;
244
 
        gtk_widget_set_double_buffered (pDock->container.pWidget, ! (g_bUseOpenGL && pDock->pRenderer->render_opengl != NULL));
245
 
        
246
 
        int iAnimationDeltaT = pDock->container.iAnimationDeltaT;
247
 
        pDock->container.iAnimationDeltaT = (g_bUseOpenGL && pDock->pRenderer->render_opengl != NULL ? mySystem.iGLAnimationDeltaT : mySystem.iCairoAnimationDeltaT);
248
 
        if (pDock->container.iAnimationDeltaT == 0)
249
 
                pDock->container.iAnimationDeltaT = 30;  // le main dock est cree avant meme qu'on ait recuperer la valeur en conf. Lorsqu'une vue lui sera attribuee, la bonne valeur sera renseignee, en attendant on met un truc non nul.
250
 
        if (iAnimationDeltaT != pDock->container.iAnimationDeltaT && pDock->container.iSidGLAnimation != 0)
251
 
        {
252
 
                g_source_remove (pDock->container.iSidGLAnimation);
253
 
                pDock->container.iSidGLAnimation = 0;
254
 
                cairo_dock_launch_animation (CAIRO_CONTAINER (pDock));
255
 
        }
256
 
        if (/**cRendererName != NULL && */pDock->cRendererName != cRendererName)  // NULL ecrase le nom de l'ancienne vue depuis le 12/11/2009
257
 
        {
258
 
                g_free (pDock->cRendererName);
259
 
                pDock->cRendererName = g_strdup (cRendererName);
260
 
        }
261
 
}
262
 
 
263
 
void cairo_dock_set_default_renderer (CairoDock *pDock)
264
 
{
265
 
        g_return_if_fail (pDock != NULL);
266
 
        cairo_dock_set_renderer (pDock, (pDock->cRendererName != NULL ? pDock->cRendererName : NULL));  // NULL => laissera le champ cRendererName nul plutot que de mettre le nom de la vue par defaut.
267
 
}
268
 
 
269
 
 
270
 
void cairo_dock_set_desklet_renderer (CairoDesklet *pDesklet, CairoDeskletRenderer *pRenderer, cairo_t *pSourceContext, gboolean bLoadIcons, CairoDeskletRendererConfigPtr pConfig)
271
 
{
272
 
        g_return_if_fail (pDesklet != NULL);
273
 
        
274
 
        if (pDesklet->pRenderer != NULL && pDesklet->pRenderer->free_data != NULL)  // meme si pDesklet->pRendererData == NULL.
275
 
        {
276
 
                pDesklet->pRenderer->free_data (pDesklet);
277
 
                pDesklet->pRendererData = NULL;
278
 
        }
279
 
        
280
 
        pDesklet->pRenderer = pRenderer;
281
 
        gtk_widget_set_double_buffered (pDesklet->container.pWidget, ! (g_bUseOpenGL && pRenderer != NULL && pRenderer->render_opengl != NULL));
282
 
        pDesklet->container.iAnimationDeltaT = (g_bUseOpenGL && pRenderer != NULL && pRenderer->render_opengl != NULL ? mySystem.iGLAnimationDeltaT : mySystem.iCairoAnimationDeltaT);
283
 
        
284
 
        if (pRenderer != NULL)
285
 
        {
286
 
                cairo_t *pCairoContext = (pSourceContext != NULL ? pSourceContext : cairo_dock_create_drawing_context_generic (CAIRO_CONTAINER (pDesklet)));
287
 
                
288
 
                if (pRenderer->configure != NULL)
289
 
                        pDesklet->pRendererData = pRenderer->configure (pDesklet, pCairoContext, pConfig);
290
 
                
291
 
                if (bLoadIcons && pRenderer->load_icons != NULL)
292
 
                        pRenderer->load_icons (pDesklet, pCairoContext);
293
 
                
294
 
                if (pRenderer->load_data != NULL)
295
 
                        pRenderer->load_data (pDesklet, pCairoContext);
296
 
                
297
 
                if (pSourceContext == NULL)
298
 
                        cairo_destroy (pCairoContext);
299
 
        }
300
 
}
301
 
 
302
 
void cairo_dock_set_desklet_renderer_by_name (CairoDesklet *pDesklet, const gchar *cRendererName, cairo_t *pSourceContext, gboolean bLoadIcons, CairoDeskletRendererConfigPtr pConfig)
303
 
{
304
 
        cd_message ("%s (%s, %d)", __func__, cRendererName, bLoadIcons);
305
 
        CairoDeskletRenderer *pRenderer = (cRendererName != NULL ? cairo_dock_get_desklet_renderer (cRendererName) : NULL);
306
 
        
307
 
        cairo_dock_set_desklet_renderer (pDesklet, pRenderer, pSourceContext, bLoadIcons, pConfig);
308
 
}
309
 
 
310
 
 
311
 
void cairo_dock_set_dialog_renderer (CairoDialog *pDialog, CairoDialogRenderer *pRenderer, cairo_t *pSourceContext, CairoDialogRendererConfigPtr pConfig)
312
 
{
313
 
        g_return_if_fail (pDialog != NULL);
314
 
        
315
 
        if (pDialog->pRenderer != NULL && pDialog->pRenderer->free_data != NULL)
316
 
        {
317
 
                pDialog->pRenderer->free_data (pDialog);
318
 
                pDialog->pRendererData = NULL;
319
 
        }
320
 
        
321
 
        pDialog->pRenderer = pRenderer;
322
 
        
323
 
        if (pRenderer != NULL)
324
 
        {
325
 
                cairo_t *pCairoContext = (pSourceContext != NULL ? pSourceContext : cairo_dock_create_drawing_context_generic (CAIRO_CONTAINER (pDialog)));
326
 
                
327
 
                if (pRenderer->configure != NULL)
328
 
                        pDialog->pRendererData = pRenderer->configure (pDialog, pCairoContext, pConfig);
329
 
                
330
 
                if (pSourceContext == NULL)
331
 
                        cairo_destroy (pCairoContext);
332
 
        }
333
 
}
334
 
 
335
 
void cairo_dock_set_dialog_renderer_by_name (CairoDialog *pDialog, const gchar *cRendererName, cairo_t *pSourceContext, CairoDialogRendererConfigPtr pConfig)
336
 
{
337
 
        cd_message ("%s (%s)", __func__, cRendererName);
338
 
        CairoDialogRenderer *pRenderer = (cRendererName != NULL ? cairo_dock_get_dialog_renderer (cRendererName) : NULL);
339
 
        
340
 
        cairo_dock_set_dialog_renderer (pDialog, pRenderer, pSourceContext, pConfig);
341
 
}
342
 
 
343
 
 
344
 
void cairo_dock_render_desklet_with_new_data (CairoDesklet *pDesklet, CairoDeskletRendererDataPtr pNewData)
345
 
{
346
 
        if (pDesklet->pRenderer != NULL && pDesklet->pRenderer->update != NULL)
347
 
                pDesklet->pRenderer->update (pDesklet, pNewData);
348
 
        
349
 
        gtk_widget_queue_draw (pDesklet->container.pWidget);
350
 
}
351
 
 
352
 
void cairo_dock_render_dialog_with_new_data (CairoDialog *pDialog, CairoDialogRendererDataPtr pNewData)
353
 
{
354
 
        if (pDialog->pRenderer != NULL && pDialog->pRenderer->update != NULL)
355
 
                pDialog->pRenderer->update (pDialog, pNewData);
356
 
        
357
 
        if (pDialog->pInteractiveWidget != NULL)
358
 
                cairo_dock_damage_interactive_widget_dialog (pDialog);
359
 
        else
360
 
                gtk_widget_queue_draw (pDialog->container.pWidget);
361
 
}
362
 
 
363
 
 
364
 
CairoDialogDecorator *cairo_dock_get_dialog_decorator (const gchar *cDecoratorName)
365
 
{
366
 
        CairoDialogDecorator *pDecorator = NULL;
367
 
        if (cDecoratorName != NULL)
368
 
                pDecorator = g_hash_table_lookup (s_hDialogDecoratorTable, cDecoratorName); 
369
 
        return pDecorator;
370
 
}
371
 
 
372
 
void cairo_dock_register_dialog_decorator (const gchar *cDecoratorName, CairoDialogDecorator *pDecorator)
373
 
{
374
 
        cd_message ("%s (%s)", __func__, cDecoratorName);
375
 
        g_hash_table_insert (s_hDialogDecoratorTable, g_strdup (cDecoratorName), pDecorator);
376
 
}
377
 
 
378
 
void cairo_dock_remove_dialog_decorator (const gchar *cDecoratorName)
379
 
{
380
 
        g_hash_table_remove (s_hDialogDecoratorTable, cDecoratorName);
381
 
}
382
 
 
383
 
void cairo_dock_set_dialog_decorator (CairoDialog *pDialog, CairoDialogDecorator *pDecorator)
384
 
{
385
 
        pDialog->pDecorator = pDecorator;
386
 
}
387
 
void cairo_dock_set_dialog_decorator_by_name (CairoDialog *pDialog, const gchar *cDecoratorName)
388
 
{
389
 
        cd_message ("%s (%s)", __func__, cDecoratorName);
390
 
        CairoDialogDecorator *pDecorator = cairo_dock_get_dialog_decorator (cDecoratorName);
391
 
        
392
 
        cairo_dock_set_dialog_decorator (pDialog, pDecorator);
393
 
}
394
 
 
395
 
 
396
 
void cairo_dock_update_renderer_list_for_gui (void)
397
 
{
398
 
        cairo_dock_build_renderer_list_for_gui (s_hRendererTable);
399
 
}
400
 
 
401
 
void cairo_dock_update_desklet_decorations_list_for_gui (void)
402
 
{
403
 
        cairo_dock_build_desklet_decorations_list_for_gui (s_hDeskletDecorationsTable);
404
 
}
405
 
 
406
 
void cairo_dock_update_desklet_decorations_list_for_applet_gui (void)
407
 
{
408
 
        cairo_dock_build_desklet_decorations_list_for_applet_gui (s_hDeskletDecorationsTable);
409
 
}
410
 
 
411
 
void cairo_dock_update_animations_list_for_gui (void)
412
 
{
413
 
        cairo_dock_build_animations_list_for_gui (s_hAnimationsTable);
414
 
}
415
 
 
416
 
void cairo_dock_update_dialog_decorator_list_for_gui (void)
417
 
{
418
 
        cairo_dock_build_dialog_decorator_list_for_gui (s_hDialogDecoratorTable);
419
 
}
420
 
 
421
 
 
422
 
static int iNbAnimation = 0;
423
 
int cairo_dock_register_animation (const gchar *cAnimation, const gchar *cDisplayedName)
424
 
{
425
 
        cd_message ("%s (%s)", __func__, cAnimation);
426
 
        iNbAnimation ++;
427
 
        CairoDockAnimationRecord *pRecord = g_new (CairoDockAnimationRecord, 1);
428
 
        pRecord->id = iNbAnimation;
429
 
        pRecord->cDisplayedName = cDisplayedName;
430
 
        g_hash_table_insert (s_hAnimationsTable, g_strdup (cAnimation), pRecord);
431
 
        return iNbAnimation;
432
 
}
433
 
 
434
 
void cairo_dock_free_animation_record (CairoDockAnimationRecord *pRecord)
435
 
{
436
 
        g_free (pRecord);
437
 
}
438
 
 
439
 
int cairo_dock_get_animation_id (const gchar *cAnimation)
440
 
{
441
 
        g_return_val_if_fail (cAnimation != NULL, 0);
442
 
        CairoDockAnimationRecord *pRecord = g_hash_table_lookup (s_hAnimationsTable, cAnimation);
443
 
        return (pRecord ? pRecord->id : 0);
444
 
}
445
 
 
446
 
const gchar *cairo_dock_get_animation_displayed_name (const gchar *cAnimation)
447
 
{
448
 
        g_return_val_if_fail (cAnimation != NULL, NULL);
449
 
        CairoDockAnimationRecord *pRecord = g_hash_table_lookup (s_hAnimationsTable, cAnimation);
450
 
        return (pRecord ? pRecord->cDisplayedName : NULL);
451
 
}
452
 
 
453
 
void cairo_dock_unregister_animation (const gchar *cAnimation)
454
 
{
455
 
        g_hash_table_remove (s_hAnimationsTable, cAnimation);
456
 
}