← Back to branch summary

~cairo-dock-team/ubuntu/precise/cairo-dock/3.0.0.0beta1

« back to all changes in this revision

Viewing changes to src/cairo-dock-renderer-manager.c

  • Committer: Bazaar Package Importer
  • Author(s): Julien Lavergne
  • Date: 2008-09-14 16:26:12 UTC
  • mfrom: (1.1.1 upstream)
  • Revision ID: james.westby@ubuntu.com-20080914162612-t6aa8pr2o0qry48o
Tags: 1.6.2.3-0ubuntu1
* New upstream release.
* debian/control
 - Update to 3.8.0 (no change needed).
 - Add libxtst-dev as Build-Depends.
* debian/cairo-dock-data.install
 - Add usr/share/cairo-dock/emblems directory.
* debian/watch
 - Update location.
* debian/rules
 - Add a get-orig-source rule.

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/cairo-dock-renderer-manager.c
7
7
 
8
8
******************************************************************************/
9
9
#include <stdlib.h>
 
10
#include <string.h>
10
11
 
11
12
#include "cairo-dock-draw.h"
12
13
#include "cairo-dock-icons.h"
23
24
extern gchar *g_cMainDockDefaultRendererName;
24
25
extern gchar *g_cSubDockDefaultRendererName;
25
26
 
 
27
extern int g_iDockRadius;
 
28
 
26
29
static GHashTable *s_hRendererTable = NULL;  // table des fonctions de rendus de dock.
27
30
static GHashTable *s_hDeskletRendererTable = NULL;  // table des fonctions de rendus des desklets.
28
 
 
29
 
 
30
 
CairoDockRenderer *cairo_dock_get_renderer (gchar *cRendererName, gboolean bForMainDock)
 
31
static GHashTable *s_hDialogRendererTable = NULL;  // table des fonctions de rendus des dialogues.
 
32
 
 
33
 
 
34
CairoDockRenderer *cairo_dock_get_renderer (const gchar *cRendererName, gboolean bForMainDock)
31
35
{
32
36
        //g_print ("%s (%s, %d)\n", __func__, cRendererName, bForMainDock);
33
37
        CairoDockRenderer *pRenderer = NULL;
48
52
        return pRenderer;
49
53
}
50
54
 
51
 
void cairo_dock_register_renderer (gchar *cRendererName, CairoDockRenderer *pRenderer)
 
55
void cairo_dock_register_renderer (const gchar *cRendererName, CairoDockRenderer *pRenderer)
52
56
{
53
57
        cd_message ("%s (%s)", __func__, cRendererName);
54
58
        g_hash_table_insert (s_hRendererTable, g_strdup (cRendererName), pRenderer);
55
59
}
56
60
 
57
 
void cairo_dock_remove_renderer (gchar *cRendererName)
 
61
void cairo_dock_remove_renderer (const gchar *cRendererName)
58
62
{
59
63
        g_hash_table_remove (s_hRendererTable, cRendererName);
60
64
}
61
65
 
62
66
 
63
 
CairoDeskletRenderer *cairo_dock_get_desklet_renderer (gchar *cRendererName)
 
67
CairoDeskletRenderer *cairo_dock_get_desklet_renderer (const gchar *cRendererName)
64
68
{
65
69
        if (cRendererName != NULL)
66
70
                return g_hash_table_lookup (s_hDeskletRendererTable, cRendererName);
68
72
                return NULL;
69
73
}
70
74
 
71
 
void cairo_dock_register_desklet_renderer (gchar *cRendererName, CairoDeskletRenderer *pRenderer)
 
75
void cairo_dock_register_desklet_renderer (const gchar *cRendererName, CairoDeskletRenderer *pRenderer)
72
76
{
73
77
        cd_message ("%s (%s)", __func__, cRendererName);
74
78
        g_hash_table_insert (s_hDeskletRendererTable, g_strdup (cRendererName), pRenderer);
75
79
}
76
80
 
77
 
void cairo_dock_remove_desklet_renderer (gchar *cRendererName)
 
81
void cairo_dock_remove_desklet_renderer (const gchar *cRendererName)
78
82
{
79
83
        g_hash_table_remove (s_hDeskletRendererTable, cRendererName);
80
84
}
81
85
 
 
86
void cairo_dock_predefine_desklet_renderer_config (CairoDeskletRenderer *pRenderer, const gchar *cConfigName, CairoDeskletRendererConfigPtr pConfig)
 
87
{
 
88
        g_return_if_fail (cConfigName != NULL && pConfig != NULL);
 
89
        CairoDeskletRendererPreDefinedConfig *pPreDefinedConfig = g_new (CairoDeskletRendererPreDefinedConfig, 1);
 
90
        pPreDefinedConfig->cName = g_strdup (cConfigName);
 
91
        pPreDefinedConfig->pConfig = pConfig;
 
92
        pRenderer->pPreDefinedConfigList = g_list_prepend (pRenderer->pPreDefinedConfigList, pPreDefinedConfig);
 
93
}
 
94
 
 
95
CairoDeskletRendererConfigPtr cairo_dock_get_desklet_renderer_predefined_config (const gchar *cRendererName, const gchar *cConfigName)
 
96
{
 
97
        CairoDeskletRenderer *pRenderer = cairo_dock_get_desklet_renderer (cRendererName);
 
98
        g_return_val_if_fail (pRenderer != NULL && cConfigName != NULL, NULL);
 
99
        
 
100
        GList *c;
 
101
        CairoDeskletRendererPreDefinedConfig *pPreDefinedConfig;
 
102
        for (c = pRenderer->pPreDefinedConfigList; c != NULL; c = c->next)
 
103
        {
 
104
                pPreDefinedConfig = c->data;
 
105
                if (strcmp (pPreDefinedConfig->cName, cConfigName) == 0)
 
106
                        return pPreDefinedConfig->pConfig;
 
107
        }
 
108
        return NULL;
 
109
}
 
110
 
 
111
 
 
112
CairoDialogRenderer *cairo_dock_get_dialog_renderer (const gchar *cRendererName)
 
113
{
 
114
        if (cRendererName != NULL)
 
115
                return g_hash_table_lookup (s_hDialogRendererTable, cRendererName);
 
116
        else
 
117
                return NULL;
 
118
}
 
119
 
 
120
void cairo_dock_register_dialog_renderer (const gchar *cRendererName, CairoDialogRenderer *pRenderer)
 
121
{
 
122
        cd_message ("%s (%s)", __func__, cRendererName);
 
123
        g_hash_table_insert (s_hDialogRendererTable, g_strdup (cRendererName), pRenderer);
 
124
}
 
125
 
 
126
void cairo_dock_remove_dialog_renderer (const gchar *cRendererName)
 
127
{
 
128
        g_hash_table_remove (s_hDialogRendererTable, cRendererName);
 
129
}
82
130
 
83
131
 
84
132
void cairo_dock_initialize_renderer_manager (void)
96
144
                g_free,
97
145
                g_free);
98
146
        
 
147
        s_hDialogRendererTable = g_hash_table_new_full (g_str_hash,
 
148
                g_str_equal,
 
149
                g_free,
 
150
                g_free);
 
151
        
99
152
        cairo_dock_register_default_renderer ();
100
153
}
101
154
 
102
155
 
103
 
void cairo_dock_set_renderer (CairoDock *pDock, gchar *cRendererName)
 
156
void cairo_dock_set_renderer (CairoDock *pDock, const gchar *cRendererName)
104
157
{
105
158
        g_return_if_fail (pDock != NULL);
106
159
        cd_message ("%s (%s)", __func__, cRendererName);
123
176
}
124
177
 
125
178
 
126
 
void cairo_dock_set_desklet_renderer (CairoDesklet *pDesklet, CairoDeskletRenderer *pRenderer, cairo_t *pSourceContext, gboolean bLoadIcons, gpointer *pConfig)
 
179
void cairo_dock_set_desklet_renderer (CairoDesklet *pDesklet, CairoDeskletRenderer *pRenderer, cairo_t *pSourceContext, gboolean bLoadIcons, CairoDeskletRendererConfigPtr pConfig)
127
180
{
128
181
        g_return_if_fail (pDesklet != NULL);
129
 
        cd_message ("%s (%x)", __func__, pRenderer);
 
182
        cd_debug ("%s (%x)", __func__, pRenderer);
130
183
        
131
 
        if (pDesklet->pRenderer != NULL && pDesklet->pRenderer->free_data != NULL)
 
184
        if (pDesklet->pRenderer != NULL && pDesklet->pRenderer->free_data != NULL)  // meme si pDesklet->pRendererData == NULL.
132
185
        {
133
186
                pDesklet->pRenderer->free_data (pDesklet);
134
187
                pDesklet->pRendererData = NULL;
154
207
        }
155
208
}
156
209
 
157
 
void cairo_dock_set_desklet_renderer_by_name (CairoDesklet *pDesklet, gchar *cRendererName, cairo_t *pSourceContext, gboolean bLoadIcons, gpointer *pConfig)
 
210
void cairo_dock_set_desklet_renderer_by_name (CairoDesklet *pDesklet, const gchar *cRendererName, cairo_t *pSourceContext, gboolean bLoadIcons, CairoDeskletRendererConfigPtr pConfig)
158
211
{
159
212
        cd_message ("%s (%s, %d)", __func__, cRendererName, bLoadIcons);
160
213
        CairoDeskletRenderer *pRenderer = (cRendererName != NULL ? cairo_dock_get_desklet_renderer (cRendererName) : NULL);
161
214
        
162
 
        cairo_t *pCairoContext = (pSourceContext != NULL ? pSourceContext : cairo_dock_create_context_from_window (CAIRO_CONTAINER (pDesklet)));
163
 
        
164
 
        cairo_dock_set_desklet_renderer (pDesklet, pRenderer, pCairoContext, bLoadIcons, pConfig);
165
 
        
166
 
        if (pSourceContext == NULL)
167
 
                cairo_destroy (pCairoContext);
 
215
        cairo_dock_set_desklet_renderer (pDesklet, pRenderer, pSourceContext, bLoadIcons, pConfig);
 
216
}
 
217
 
 
218
 
 
219
void cairo_dock_set_dialog_renderer (CairoDialog *pDialog, CairoDialogRenderer *pRenderer, cairo_t *pSourceContext, CairoDialogRendererConfigPtr pConfig)
 
220
{
 
221
        g_return_if_fail (pDialog != NULL);
 
222
        cd_debug ("%s (%x)", __func__, pRenderer);
 
223
        
 
224
        if (pDialog->pRenderer != NULL && pDialog->pRenderer->free_data != NULL)
 
225
        {
 
226
                pDialog->pRenderer->free_data (pDialog);
 
227
                pDialog->pRendererData = NULL;
 
228
        }
 
229
        
 
230
        pDialog->pRenderer = pRenderer;
 
231
        
 
232
        if (pRenderer != NULL)
 
233
        {
 
234
                cairo_t *pCairoContext = (pSourceContext != NULL ? pSourceContext : cairo_dock_create_context_from_window (CAIRO_CONTAINER (pDialog)));
 
235
                
 
236
                if (pRenderer->configure != NULL)
 
237
                        pDialog->pRendererData = pRenderer->configure (pDialog, pCairoContext, pConfig);
 
238
                
 
239
                if (pSourceContext == NULL)
 
240
                        cairo_destroy (pCairoContext);
 
241
        }
 
242
}
 
243
 
 
244
void cairo_dock_set_dialog_renderer_by_name (CairoDialog *pDialog, const gchar *cRendererName, cairo_t *pSourceContext, CairoDialogRendererConfigPtr pConfig)
 
245
{
 
246
        cd_message ("%s (%s)", __func__, cRendererName);
 
247
        CairoDialogRenderer *pRenderer = (cRendererName != NULL ? cairo_dock_get_dialog_renderer (cRendererName) : NULL);
 
248
        
 
249
        cairo_dock_set_dialog_renderer (pDialog, pRenderer, pSourceContext, pConfig);
 
250
}
 
251
 
 
252
 
 
253
void cairo_dock_render_desklet_with_new_data (CairoDesklet *pDesklet, CairoDeskletRendererDataPtr pNewData)
 
254
{
 
255
        if (pDesklet->pRenderer != NULL && pDesklet->pRenderer->update != NULL)
 
256
                pDesklet->pRenderer->update (pDesklet, pNewData);
 
257
        
 
258
        gtk_widget_queue_draw_area (pDesklet->pWidget,
 
259
                .5*g_iDockRadius,
 
260
                .5*g_iDockRadius,
 
261
                pDesklet->iWidth - g_iDockRadius,
 
262
                pDesklet->iHeight- g_iDockRadius);  // marche avec glitz ?...
 
263
}
 
264
 
 
265
void cairo_dock_render_dialog_with_new_data (CairoDialog *pDialog, CairoDialogRendererDataPtr pNewData)
 
266
{
 
267
        if (pDialog->pRenderer != NULL && pDialog->pRenderer->update != NULL)
 
268
                pDialog->pRenderer->update (pDialog, pNewData);
 
269
        
 
270
        if (pDialog->pInteractiveWidget != NULL)
 
271
                gtk_widget_queue_draw_area (pDialog->pWidget,
 
272
                        pDialog->iMargin,
 
273
                        (pDialog->bDirectionUp ?
 
274
                                pDialog->iMargin + pDialog->iMessageHeight :
 
275
                                pDialog->iHeight - pDialog->iMargin - pDialog->iInteractiveHeight),
 
276
                        pDialog->iInteractiveWidth,
 
277
                        pDialog->iInteractiveHeight);  // marche avec glitz ?...
 
278
        else
 
279
                gtk_widget_queue_draw (pDialog->pWidget);
168
280
}
169
281
 
170
282