← Back to branch summary

~ubuntu-branches/ubuntu/oneiric/cairo-dock/oneiric

« back to all changes in this revision

Viewing changes to src/gldit/cairo-dock-data-renderer.c

  • Committer: Bazaar Package Importer
  • Author(s): Matthieu Baerts (matttbe)
  • Date: 2010-09-07 20:31:25 UTC
  • mto: (18.1.1 cairo-dock) (19.1.1 cairo-dock)
  • mto: This revision was merged to the branch mainline in revision 14.
  • Revision ID: james.westby@ubuntu.com-20100907203125-a91ch8odv2r6ziic
Tags: upstream-2.2.0~0rc1
Import upstream version 2.2.0~0rc1

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/gldit/cairo-dock-data-renderer.c
36
36
#include "cairo-dock-config.h"
37
37
#include "cairo-dock-keyfile-utilities.h"
38
38
#include "cairo-dock-packages.h"
 
39
#include "cairo-dock-internal-labels.h"
39
40
#include "cairo-dock-gauge.h"
40
41
#include "cairo-dock-graph.h"
41
42
#include "cairo-dock-data-renderer.h"
45
46
extern gchar *g_cExtrasDirPath;
46
47
 
47
48
#define cairo_dock_set_data_renderer_on_icon(pIcon, pRenderer) (pIcon)->pDataRenderer = pRenderer
48
 
#define cairo_dock_get_icon_data_renderer(pIcon) (pIcon)->pDataRenderer
49
 
 
 
49
#define CD_MIN_TEXT_WITH 24
50
50
 
51
51
static CairoDockGLFont *s_pFont = NULL;
52
52
 
68
68
 
69
69
CairoDataRenderer *cairo_dock_new_data_renderer (const gchar *cRendererName)
70
70
{
71
 
        CairoDataRendererNewFunc init = cairo_dock_get_data_renderer_entry_point (cRendererName);
72
 
        g_return_val_if_fail (init != NULL, NULL);
 
71
        CairoDockDataRendererRecord *pRecord = cairo_dock_get_data_renderer_record (cRendererName);
 
72
        g_return_val_if_fail (pRecord != NULL && pRecord->iStructSize != 0, NULL);
73
73
        
74
74
        if (g_pPrimaryContainer && s_pFont == NULL)
75
75
        {
76
76
                _init_data_renderer_font ();
77
77
        }
78
78
        
79
 
        return init ();
 
79
        CairoDataRenderer *pRenderer = g_malloc0 (pRecord->iStructSize);
 
80
        memcpy (&pRenderer->interface, &pRecord->interface, sizeof (CairoDataRendererInterface));
 
81
        return pRenderer;
80
82
}
81
83
 
82
84
static void _cairo_dock_init_data_renderer (CairoDataRenderer *pRenderer, CairoContainer *pContainer, CairoDataRendererAttribute *pAttribute)
117
119
                }
118
120
        }
119
121
        
 
122
        if (pAttribute->cEmblems != NULL)
 
123
        {
 
124
                pRenderer->pEmblems = g_new0 (CairoDataRendererEmblem, pRenderer->data.iNbValues);
 
125
                int i;
 
126
                for (i = 0; i < pRenderer->data.iNbValues; i ++)
 
127
                {
 
128
                        pRenderer->pEmblems[i].cImagePath = g_strdup (pAttribute->cEmblems[i]);
 
129
                        pRenderer->pEmblems[i].param.fAlpha = 1.;
 
130
                }
 
131
        }
 
132
        if (pAttribute->cLabels != NULL)
 
133
        {
 
134
                pRenderer->pLabels = g_new0 (CairoDataRendererText, pRenderer->data.iNbValues);
 
135
                int i;
 
136
                for (i = 0; i < pRenderer->data.iNbValues; i ++)
 
137
                {
 
138
                        pRenderer->pLabels[i].cText = g_strdup (pAttribute->cLabels[i]);
 
139
                        pRenderer->pLabels[i].param.pColor[3] = 1.;
 
140
                }
 
141
        }
 
142
        pRenderer->pValuesText = g_new0 (CairoDataRendererTextParam, pRenderer->data.iNbValues);
 
143
        
120
144
        //\_______________ On charge les parametres generaux.
121
145
        pRenderer->bUpdateMinMax = pAttribute->bUpdateMinMax;
122
146
        pRenderer->bWriteValues = pAttribute->bWriteValues;
124
148
        pRenderer->iSmoothAnimationStep = 0;
125
149
        pRenderer->format_value = pAttribute->format_value;
126
150
        pRenderer->pFormatData = pAttribute->pFormatData;
127
 
        pRenderer->cTitles = pAttribute->cTitles;
128
 
        memcpy (pRenderer->fTextColor, pAttribute->fTextColor, sizeof (pRenderer->fTextColor));
129
 
        pRenderer->cEmblems = pAttribute->cEmblems;
130
 
}
131
 
 
132
 
static void _cairo_dock_render_to_texture (CairoDataRenderer *pDataRenderer, Icon *pIcon, CairoContainer *pContainer)
 
151
}
 
152
 
 
153
 
 
154
void cairo_dock_render_overlays_to_texture (CairoDataRenderer *pRenderer, int iNumValue)
 
155
{
 
156
        if (pRenderer->pEmblems != NULL)
 
157
        {
 
158
                _cairo_dock_enable_texture ();
 
159
                _cairo_dock_set_blend_over ();
 
160
                
 
161
                CairoDataRendererEmblem *pEmblem;
 
162
                pEmblem = &pRenderer->pEmblems[iNumValue];
 
163
                if (pEmblem->iTexture != 0)
 
164
                {
 
165
                        glBindTexture (GL_TEXTURE_2D, pEmblem->iTexture);
 
166
                        _cairo_dock_set_alpha (pEmblem->param.fAlpha);
 
167
                        _cairo_dock_apply_current_texture_at_size_with_offset (
 
168
                                pEmblem->param.fWidth * pRenderer->iWidth,
 
169
                                pEmblem->param.fHeight * pRenderer->iHeight,
 
170
                                pEmblem->param.fX * pRenderer->iWidth,
 
171
                                pEmblem->param.fY * pRenderer->iHeight);
 
172
                }
 
173
                _cairo_dock_disable_texture ();
 
174
        }
 
175
        
 
176
        if (pRenderer->pLabels != NULL)
 
177
        {
 
178
                _cairo_dock_enable_texture ();
 
179
                _cairo_dock_set_blend_over ();
 
180
                
 
181
                CairoDataRendererText *pLabel;
 
182
                int w, h, dw, dh;
 
183
                pLabel = &pRenderer->pLabels[iNumValue];
 
184
                if (pLabel->iTexture != 0)
 
185
                {
 
186
                        double f = MIN (pLabel->param.fWidth * pRenderer->iWidth / pLabel->iTextWidth, pLabel->param.fHeight * pRenderer->iHeight / pLabel->iTextHeight);  // on garde le ratio du texte.
 
187
                        w = pLabel->iTextWidth * f;
 
188
                        h = pLabel->iTextHeight * f;
 
189
                        dw = w & 1;
 
190
                        dh = h & 1;
 
191
                        
 
192
                        glBindTexture (GL_TEXTURE_2D, pLabel->iTexture);
 
193
                        _cairo_dock_set_alpha (pLabel->param.pColor[3]);
 
194
                        _cairo_dock_apply_current_texture_at_size_with_offset (
 
195
                                w + dw,
 
196
                                h + dh,
 
197
                                pLabel->param.fX * pRenderer->iWidth,
 
198
                                pLabel->param.fY * pRenderer->iHeight);
 
199
                }
 
200
                _cairo_dock_disable_texture ();
 
201
        }
 
202
        
 
203
        if (pRenderer->bWriteValues && pRenderer->bCanRenderValueAsText)
 
204
        {
 
205
                CairoDataRendererTextParam *pText;
 
206
                int w, h, dw, dh;
 
207
                pText = &pRenderer->pValuesText[iNumValue];
 
208
                if (pText->fWidth != 0 && pText->fHeight != 0)
 
209
                {
 
210
                        cairo_data_renderer_format_value (pRenderer, iNumValue);
 
211
                        
 
212
                        CairoDockGLFont *pFont = cairo_dock_get_default_data_renderer_font ();
 
213
                        glColor3f (pText->pColor[0], pText->pColor[1], pText->pColor[2]);
 
214
                        glPushMatrix ();
 
215
                        
 
216
                        w = pText->fWidth * pRenderer->iWidth;
 
217
                        h = pText->fHeight * pRenderer->iHeight;
 
218
                        dw = w & 1;
 
219
                        dh = h & 1;
 
220
                        cairo_dock_draw_gl_text_at_position_in_area (pRenderer->cFormatBuffer,
 
221
                                pFont,
 
222
                                floor (pText->fX * pRenderer->iWidth) + .5*dw,
 
223
                                floor (pText->fY * pRenderer->iHeight) + .5*dh,
 
224
                                w,
 
225
                                h,
 
226
                                TRUE);
 
227
                        
 
228
                        glPopMatrix ();
 
229
                        glColor3f (1.0, 1.0, 1.0);
 
230
                }
 
231
        }
 
232
}
 
233
 
 
234
static void _cairo_dock_render_to_texture (CairoDataRenderer *pRenderer, Icon *pIcon, CairoContainer *pContainer)
133
235
{
134
236
        if (! cairo_dock_begin_draw_icon (pIcon, pContainer, 0))
135
237
                return ;
136
238
        
137
 
        pDataRenderer->interface.render_opengl (pDataRenderer);
 
239
        //\________________ On dessine.
 
240
        glPushMatrix ();
 
241
        if (!pContainer->bIsHorizontal && pRenderer->bRotateWithContainer)
 
242
        {
 
243
                glTranslatef (pRenderer->iWidth/2, pRenderer->iHeight/2, 0.);
 
244
                glRotatef (-90., 0., 0., 1.);
 
245
                glTranslatef (-pRenderer->iHeight/2, -pRenderer->iWidth/2, 0.);
 
246
        }
 
247
        
 
248
        glPushMatrix ();
 
249
        pRenderer->interface.render_opengl (pRenderer);
 
250
        glPopMatrix ();
 
251
        
 
252
        //\________________ On dessine les overlays.
 
253
        /**int iNbValues = cairo_data_renderer_get_nb_values (pRenderer);
 
254
        int i;
 
255
        for (i = 0; i < iNbValues; i ++)
 
256
        {
 
257
                cairo_dock_render_overlays_to_texture (pRenderer, i);
 
258
        }*/
 
259
        glPopMatrix ();
138
260
        
139
261
        cairo_dock_end_draw_icon (pIcon, pContainer);
140
262
}
141
 
static void _cairo_dock_render_to_context (CairoDataRenderer *pDataRenderer, Icon *pIcon, CairoContainer *pContainer, cairo_t *pCairoContext)
 
263
 
 
264
void cairo_dock_render_overlays_to_context (CairoDataRenderer *pRenderer, int iNumValue, cairo_t *pCairoContext)
 
265
{
 
266
        if (pRenderer->pEmblems != NULL)
 
267
        {
 
268
                CairoDataRendererEmblem *pEmblem;
 
269
                pEmblem = &pRenderer->pEmblems[iNumValue];
 
270
                if (pEmblem->pSurface != NULL)
 
271
                {
 
272
                        cairo_set_source_surface (pCairoContext,
 
273
                                pEmblem->pSurface,
 
274
                                (.5 + pEmblem->param.fX - pEmblem->param.fWidth/2) * pRenderer->iWidth,
 
275
                                (.5 - pEmblem->param.fY - pEmblem->param.fHeight/2) * pRenderer->iHeight);
 
276
                        cairo_paint_with_alpha (pCairoContext, pEmblem->param.fAlpha);
 
277
                }
 
278
        }
 
279
        
 
280
        if (pRenderer->pLabels != NULL)
 
281
        {
 
282
                CairoDataRendererText *pLabel;
 
283
                pLabel = &pRenderer->pLabels[iNumValue];
 
284
                if (pLabel->pSurface != NULL)
 
285
                {
 
286
                        double f = MIN (pLabel->param.fWidth * pRenderer->iWidth / pLabel->iTextWidth, pLabel->param.fHeight * pRenderer->iHeight / pLabel->iTextHeight);  // on garde le ratio du texte.
 
287
                        if (pLabel->iTextHeight * f > 7)  // sinon illisible
 
288
                        {
 
289
                                cairo_save (pCairoContext);
 
290
                                cairo_scale (pCairoContext,
 
291
                                        f,
 
292
                                        f);
 
293
                                cairo_set_source_surface (pCairoContext,
 
294
                                        pLabel->pSurface,
 
295
                                        (.5 + pLabel->param.fX) * pRenderer->iWidth/f - pLabel->iTextWidth /2,
 
296
                                        (.5 - pLabel->param.fY) * pRenderer->iHeight/f - pLabel->iTextHeight /2);
 
297
                                cairo_paint_with_alpha (pCairoContext, pLabel->param.pColor[3]);
 
298
                                cairo_restore (pCairoContext);
 
299
                        }
 
300
                }
 
301
        }
 
302
        
 
303
        if (pRenderer->bWriteValues && pRenderer->bCanRenderValueAsText)
 
304
        {
 
305
                CairoDataRendererTextParam *pText;
 
306
                pText = &pRenderer->pValuesText[iNumValue];
 
307
                if (pText->fWidth != 0 && pText->fHeight != 0)
 
308
                {
 
309
                        cairo_data_renderer_format_value (pRenderer, iNumValue);
 
310
                        
 
311
                        cairo_save (pCairoContext);
 
312
                        cairo_set_source_rgb (pCairoContext, pText->pColor[0], pText->pColor[1], pText->pColor[2]);
 
313
                        
 
314
                        PangoLayout *pLayout = pango_cairo_create_layout (pCairoContext);
 
315
                        PangoFontDescription *fd = pango_font_description_from_string ("Monospace 12");
 
316
                        pango_layout_set_font_description (pLayout, fd);
 
317
                        
 
318
                        PangoRectangle ink, log;
 
319
                        pango_layout_set_text (pLayout, pRenderer->cFormatBuffer, -1);
 
320
                        pango_layout_get_pixel_extents (pLayout, &ink, &log);
 
321
                        double fZoom = MIN (pText->fWidth * pRenderer->iWidth / (log.width), pText->fHeight * pRenderer->iHeight / log.height);
 
322
                        
 
323
                        cairo_move_to (pCairoContext,
 
324
                                floor ((.5 + pText->fX) * pRenderer->iWidth - log.width*fZoom/2),
 
325
                                floor ((.5 - pText->fY) * pRenderer->iHeight - log.height*fZoom/2));
 
326
                        cairo_scale (pCairoContext,
 
327
                                fZoom,
 
328
                                fZoom);
 
329
                        pango_cairo_show_layout (pCairoContext, pLayout);
 
330
                        g_object_unref (pLayout);
 
331
                        cairo_restore (pCairoContext);
 
332
                }
 
333
        }
 
334
}
 
335
 
 
336
static void _cairo_dock_render_to_context (CairoDataRenderer *pRenderer, Icon *pIcon, CairoContainer *pContainer, cairo_t *pCairoContext)
142
337
{
143
338
        //\________________ On efface tout.
144
339
        cairo_set_source_rgba (pCairoContext, 0.0, 0.0, 0.0, 0.0);
148
343
        
149
344
        //\________________ On dessine.
150
345
        cairo_save (pCairoContext);
151
 
        pDataRenderer->interface.render (pDataRenderer, pCairoContext);
 
346
        if (!pContainer->bIsHorizontal && pRenderer->bRotateWithContainer)
 
347
        {
 
348
                cairo_translate (pCairoContext, pRenderer->iWidth/2, pRenderer->iHeight/2);
 
349
                cairo_rotate (pCairoContext, G_PI/2);
 
350
                cairo_translate (pCairoContext, -pRenderer->iHeight/2, -pRenderer->iWidth/2);
 
351
        }
 
352
        
 
353
        cairo_save (pCairoContext);
 
354
        pRenderer->interface.render (pRenderer, pCairoContext);
 
355
        cairo_restore (pCairoContext);
 
356
        
 
357
        //\________________ On dessine les overlays.
 
358
        /**int iNbValues = cairo_data_renderer_get_nb_values (pRenderer);
 
359
        int i;
 
360
        for (i = 0; i < iNbValues; i ++)
 
361
        {
 
362
                cairo_dock_render_overlays_to_context (pRenderer, i, pCairoContext);
 
363
        }*/
152
364
        cairo_restore (pCairoContext);
153
365
        
154
366
        if (pContainer->bUseReflect)
183
395
        return CAIRO_DOCK_LET_PASS_NOTIFICATION;
184
396
}
185
397
 
 
398
static void _cairo_dock_finish_load_data_renderer (CairoDataRenderer *pRenderer, gboolean bLoadTextures)
 
399
{
 
400
        int iNbValues = cairo_data_renderer_get_nb_values (pRenderer);
 
401
        //\___________________ On charge les emblemes si l'implementation les a valides.
 
402
        if (pRenderer->pEmblems != NULL)
 
403
        {
 
404
                CairoDataRendererEmblem *pEmblem;
 
405
                cairo_surface_t *pSurface;
 
406
                int i;
 
407
                for (i = 0; i < iNbValues; i ++)
 
408
                {
 
409
                        pEmblem = &pRenderer->pEmblems[i];
 
410
                        if (pEmblem->pSurface != NULL)
 
411
                        {
 
412
                                cairo_surface_destroy (pEmblem->pSurface);
 
413
                                pEmblem->pSurface = NULL;
 
414
                        }
 
415
                        if (pEmblem->iTexture != 0)
 
416
                        {
 
417
                                _cairo_dock_delete_texture (pEmblem->iTexture);
 
418
                                pEmblem->iTexture = 0;
 
419
                        }
 
420
                        if (pEmblem->param.fWidth != 0 && pEmblem->param.fHeight != 0 && pEmblem->cImagePath != NULL)
 
421
                        {
 
422
                                pSurface = cairo_dock_create_surface_from_image_simple (pEmblem->cImagePath,
 
423
                                        pEmblem->param.fWidth * pRenderer->iWidth,
 
424
                                        pEmblem->param.fHeight * pRenderer->iHeight);
 
425
                                if (bLoadTextures)
 
426
                                {
 
427
                                        pEmblem->iTexture = cairo_dock_create_texture_from_surface (pSurface);
 
428
                                        cairo_surface_destroy (pSurface);
 
429
                                }
 
430
                                else
 
431
                                        pEmblem->pSurface = pSurface;
 
432
                        }
 
433
                }
 
434
        }
 
435
        
 
436
        //\___________________ On charge les labels si l'implementation les a valides.
 
437
        if (pRenderer->pLabels != NULL)
 
438
        {
 
439
                CairoDockLabelDescription textDescription;
 
440
                cairo_dock_copy_label_description (&textDescription, &myLabels.quickInfoTextDescription);
 
441
                
 
442
                CairoDataRendererText *pLabel;
 
443
                cairo_surface_t *pSurface;
 
444
                int i;
 
445
                for (i = 0; i < iNbValues; i ++)
 
446
                {
 
447
                        pLabel = &pRenderer->pLabels[i];
 
448
                        if (pLabel->pSurface != NULL)
 
449
                        {
 
450
                                cairo_surface_destroy (pLabel->pSurface);
 
451
                                pLabel->pSurface = NULL;
 
452
                        }
 
453
                        if (pLabel->iTexture != 0)
 
454
                        {
 
455
                                _cairo_dock_delete_texture (pLabel->iTexture);
 
456
                                pLabel->iTexture = 0;
 
457
                        }
 
458
                        if (pLabel->param.fWidth != 0 && pLabel->param.fHeight != 0 && pLabel->cText != NULL)
 
459
                        {
 
460
                                textDescription.fBackgroundColor[3] = 0.;
 
461
                                textDescription.iMargin = 0;
 
462
                                textDescription.bOutlined = TRUE;  /// tester avec et sans ...
 
463
                                textDescription.fColorStart[0] = pLabel->param.pColor[0];
 
464
                                textDescription.fColorStart[1] = pLabel->param.pColor[1];
 
465
                                textDescription.fColorStart[2] = pLabel->param.pColor[2];
 
466
                                textDescription.fColorStop[0] = pLabel->param.pColor[0];
 
467
                                textDescription.fColorStop[1] = pLabel->param.pColor[1];
 
468
                                textDescription.fColorStop[2] = pLabel->param.pColor[2];
 
469
                                pSurface = cairo_dock_create_surface_from_text (pLabel->cText,
 
470
                                        &textDescription,
 
471
                                        &pLabel->iTextWidth, &pLabel->iTextHeight);
 
472
                                if (bLoadTextures)
 
473
                                {
 
474
                                        pLabel->iTexture = cairo_dock_create_texture_from_surface (pSurface);
 
475
                                        cairo_surface_destroy (pSurface);
 
476
                                }
 
477
                                else
 
478
                                        pLabel->pSurface = pSurface;
 
479
                        }
 
480
                }
 
481
        }
 
482
        
 
483
        //\___________________ On regarde si le texte dessine sur l'icone sera suffisamment lisible.
 
484
        if (pRenderer->pValuesText != NULL)
 
485
        {
 
486
                CairoDataRendererTextParam *pText = &pRenderer->pValuesText[0];
 
487
                //g_print ("+++++++pText->fWidth * pRenderer->iWidth : %.2f\n", pText->fWidth * pRenderer->iWidth);
 
488
                pRenderer->bCanRenderValueAsText = (pText->fWidth * pRenderer->iWidth >= CD_MIN_TEXT_WITH);
 
489
        }
 
490
}
 
491
 
186
492
void cairo_dock_add_new_data_renderer_on_icon (Icon *pIcon, CairoContainer *pContainer, CairoDataRendererAttribute *pAttribute)
187
493
{
 
494
        //\___________________ On affecte un nouveau DataRenderer a l'icone.
188
495
        CairoDataRenderer *pRenderer = cairo_dock_new_data_renderer (pAttribute->cModelName);
189
496
        
190
497
        cairo_dock_set_data_renderer_on_icon (pIcon, pRenderer);
194
501
        _cairo_dock_init_data_renderer (pRenderer, pContainer, pAttribute);
195
502
        
196
503
        cairo_dock_get_icon_extent (pIcon, pContainer, &pRenderer->iWidth, &pRenderer->iHeight);
197
 
        if (pAttribute->cEmblems != NULL)       
198
 
                pRenderer->pEmblems = g_new0 (CairoDataRendererEmblem, pAttribute->iNbValues);
199
 
        pRenderer->pTextZones = g_new0 (CairoDataRendererTextZone, pAttribute->iNbValues);
200
 
        
201
 
        pRenderer->interface.load (pRenderer, pContainer, pAttribute);
202
504
        
203
505
        gboolean bLoadTextures = FALSE;
204
506
        if (CAIRO_DOCK_CONTAINER_IS_OPENGL (pContainer) && pRenderer->interface.render_opengl)
206
508
                bLoadTextures = TRUE;
207
509
                cairo_dock_register_notification_on_icon (pIcon, CAIRO_DOCK_UPDATE_ICON_SLOW,
208
510
                        (CairoDockNotificationFunc) cairo_dock_update_icon_data_renderer_notification,
209
 
                        CAIRO_DOCK_RUN_AFTER, NULL);
210
 
        }
211
 
        
212
 
        if (pRenderer->pEmblems != NULL)
213
 
        {
214
 
                CairoDataRendererEmblem *pEmblem;
215
 
                cairo_surface_t *pSurface;
216
 
                int i;
217
 
                for (i = 0; i < pAttribute->iNbValues; i ++)
218
 
                {
219
 
                        pEmblem = &pRenderer->pEmblems[i];
220
 
                        if (pEmblem->fWidth != 0 && pEmblem->fHeight != 0)
221
 
                        {
222
 
                                pSurface = cairo_dock_create_surface_from_image_simple (pAttribute->cEmblems[i],
223
 
                                        pEmblem->fWidth * pRenderer->iWidth,
224
 
                                        pEmblem->fHeight * pRenderer->iHeight);
225
 
                                if (bLoadTextures)
226
 
                                {
227
 
                                        pEmblem->iTexture = cairo_dock_create_texture_from_surface (pSurface);
228
 
                                        cairo_surface_destroy (pSurface);
229
 
                                }
230
 
                                else
231
 
                                        pEmblem->pSurface = pSurface;
232
 
                        }
233
 
                }
234
 
        }
235
 
        
 
511
                        CAIRO_DOCK_RUN_AFTER, NULL);  // pour l'affichage fluide.
 
512
        }
 
513
        
 
514
        //\___________________ On le charge.
 
515
        pRenderer->interface.load (pRenderer, pContainer, pAttribute);
 
516
        
 
517
        //\___________________ On charge les overlays si l'implementation les a valides.
 
518
        _cairo_dock_finish_load_data_renderer (pRenderer, bLoadTextures);
236
519
}
237
520
 
238
521
 
257
540
                        if (fNewValue < pData->pMinMaxValues[2*i])
258
541
                                pData->pMinMaxValues[2*i] = fNewValue;
259
542
                        if (fNewValue > pData->pMinMaxValues[2*i+1])
260
 
                                pData->pMinMaxValues[2*i+1] = fNewValue;
 
543
                                pData->pMinMaxValues[2*i+1] = MAX (fNewValue, pData->pMinMaxValues[2*i]+.1);
261
544
                }
262
545
                pData->pTabValues[pData->iCurrentIndex][i] = fNewValue;
263
546
        }
291
574
                char *str = cBuffer;
292
575
                for (i = 0; i < pData->iNbValues; i ++)
293
576
                {
294
 
                        fValue = cairo_data_renderer_get_normalized_current_value (pRenderer, i);
295
 
                        cairo_data_renderer_format_value_full (pRenderer, fValue, i, str);
 
577
                        cairo_data_renderer_format_value_full (pRenderer, i, str);
296
578
                        
297
579
                        if (i+1 < pData->iNbValues)
298
580
                        {
305
587
                cairo_dock_set_quick_info (pIcon, pContainer, cBuffer);
306
588
                g_free (cBuffer);
307
589
        }
 
590
        else
 
591
                cairo_dock_set_quick_info (pIcon, pContainer, NULL);
308
592
        
309
593
        cairo_dock_redraw_icon (pIcon, pContainer);
310
594
}
316
600
        if (pRenderer == NULL)
317
601
                return ;
318
602
        
 
603
        if (pRenderer->interface.unload)
 
604
                pRenderer->interface.unload (pRenderer);
 
605
        
319
606
        g_free (pRenderer->data.pValuesBuffer);
320
607
        g_free (pRenderer->data.pTabValues);
321
608
        g_free (pRenderer->data.pMinMaxValues);
322
609
        
 
610
        int iNbValues = cairo_data_renderer_get_nb_values (pRenderer);
323
611
        if (pRenderer->pEmblems != NULL)
324
612
        {
325
613
                CairoDataRendererEmblem *pEmblem;
326
614
                int i;
327
 
                for (i = 0; i < pRenderer->data.iNbValues; i ++)
 
615
                for (i = 0; i < iNbValues; i ++)
328
616
                {
329
617
                        pEmblem = &pRenderer->pEmblems[i];
330
618
                        if (pEmblem->pSurface != NULL)
335
623
                g_free (pRenderer->pEmblems);
336
624
        }
337
625
        
338
 
        if (pRenderer->pTextZones != NULL)
339
 
                g_free (pRenderer->pTextZones);
340
 
        
341
 
        pRenderer->interface.free (pRenderer);
 
626
        if (pRenderer->pLabels != NULL)
 
627
        {
 
628
                CairoDataRendererText *pText;
 
629
                int i;
 
630
                for (i = 0; i < iNbValues; i ++)
 
631
                {
 
632
                        pText = &pRenderer->pLabels[i];
 
633
                        if (pText->pSurface != NULL)
 
634
                                cairo_surface_destroy (pText->pSurface);
 
635
                        if (pText->iTexture != 0)
 
636
                                _cairo_dock_delete_texture (pText->iTexture);
 
637
                }
 
638
                g_free (pRenderer->pLabels);
 
639
        }
 
640
        
 
641
        g_free (pRenderer->pValuesText);
 
642
        
 
643
        g_free (pRenderer);
342
644
}
343
645
 
344
646
void cairo_dock_remove_data_renderer_on_icon (Icon *pIcon)
352
654
}
353
655
 
354
656
 
355
 
 
356
657
void cairo_dock_reload_data_renderer_on_icon (Icon *pIcon, CairoContainer *pContainer, CairoDataRendererAttribute *pAttribute)
357
658
{
358
659
        //\_____________ On recupere les donnees de l'actuel renderer.
365
666
                g_return_if_fail (pOldRenderer->interface.reload != NULL);
366
667
                cairo_dock_get_icon_extent (pIcon, pContainer, &pOldRenderer->iWidth, &pOldRenderer->iHeight);
367
668
                pOldRenderer->interface.reload (pOldRenderer);
 
669
                
 
670
                gboolean bLoadTextures = (CAIRO_DOCK_CONTAINER_IS_OPENGL (pContainer) && pOldRenderer->interface.render_opengl);
 
671
                _cairo_dock_finish_load_data_renderer (pOldRenderer, bLoadTextures);
368
672
        }
369
673
        else  // on recree le data-renderer avec les nouveaux attributs.
370
674
        {
371
675
                pAttribute->iNbValues = MAX (1, pAttribute->iNbValues);
372
676
                //\_____________ On recupere les donnees courantes.
373
 
                if (pOldRenderer && pOldRenderer->data.iNbValues == pAttribute->iNbValues)
 
677
                if (pOldRenderer && cairo_data_renderer_get_nb_values (pOldRenderer) == pAttribute->iNbValues)
374
678
                {
375
679
                        pData = g_memdup (&pOldRenderer->data, sizeof (CairoDataToRenderer));
376
680
                        memset (&pOldRenderer->data, 0, sizeof (CairoDataToRenderer));
468
772
        CairoDockDataRendererRecord *pRecord = cairo_dock_get_data_renderer_record (cRendererName);
469
773
        g_return_val_if_fail (pRecord != NULL, NULL);
470
774
        
471
 
        if (pRecord->cThemeDirName == NULL)
 
775
        if (pRecord->cThemeDirName == NULL && pRecord->cDistantThemeDirName == NULL)
472
776
                return NULL;
473
777
        gchar *cGaugeShareDir = g_strdup_printf ("%s/%s", CAIRO_DOCK_SHARE_DATA_DIR, pRecord->cThemeDirName);
474
778
        gchar *cGaugeUserDir = g_strdup_printf ("%s/%s", g_cExtrasDirPath, pRecord->cThemeDirName);
475
 
        GHashTable *pGaugeTable = cairo_dock_list_packages (cGaugeShareDir, cGaugeUserDir, pRecord->cThemeDirName);
 
779
        GHashTable *pGaugeTable = cairo_dock_list_packages (cGaugeShareDir, cGaugeUserDir, pRecord->cDistantThemeDirName);
476
780
        
477
781
        g_free (cGaugeShareDir);
478
782
        g_free (cGaugeUserDir);
485
789
        CairoDockDataRendererRecord *pRecord = cairo_dock_get_data_renderer_record (cRendererName);
486
790
        g_return_val_if_fail (pRecord != NULL, NULL);
487
791
        
488
 
        if (pRecord->cThemeDirName == NULL)
 
792
        if (pRecord->cThemeDirName == NULL && pRecord->cDistantThemeDirName == NULL)
489
793
                return NULL;
490
794
        
491
795
        const gchar *cGaugeShareDir = g_strdup_printf ("%s/%s", CAIRO_DOCK_SHARE_DATA_DIR, pRecord->cThemeDirName);
492
796
        gchar *cGaugeUserDir = g_strdup_printf ("%s/%s", g_cExtrasDirPath, pRecord->cThemeDirName);
493
 
        gchar *cGaugePath = cairo_dock_get_package_path (cThemeName, cGaugeShareDir, cGaugeUserDir, pRecord->cThemeDirName, iType);
 
797
        gchar *cGaugePath = cairo_dock_get_package_path (cThemeName, cGaugeShareDir, cGaugeUserDir, pRecord->cDistantThemeDirName, iType);
494
798
        g_free (cGaugeUserDir);
495
799
        return cGaugePath;
496
800
}
508
812
        gchar *cGaugePath = cairo_dock_get_data_renderer_theme_path (cRendererName, cChosenThemeName, iType);
509
813
        
510
814
        if (cGaugePath == NULL)  // theme introuvable.
511
 
                cGaugePath = g_strdup_printf ("%s/%s", CAIRO_DOCK_SHARE_DATA_DIR, pRecord->cThemeDirName, pRecord->cDefaultTheme);
 
815
                cGaugePath = g_strdup_printf (CAIRO_DOCK_SHARE_DATA_DIR"/%s/%s", pRecord->cThemeDirName, pRecord->cDefaultTheme);
512
816
        
513
817
        if (iType != CAIRO_DOCK_ANY_PACKAGE)
514
818
        {
523
827
 
524
828
void cairo_dock_register_built_in_data_renderers (void)
525
829
{
526
 
        cairo_dock_register_data_renderer_entry_point ("gauge", (CairoDataRendererNewFunc) cairo_dock_new_gauge, "gauges", "Turbo-night-fuel");
527
 
        cairo_dock_register_data_renderer_entry_point ("graph", (CairoDataRendererNewFunc) cairo_dock_new_graph, NULL, NULL);
 
830
        cairo_dock_register_data_renderer_graph ();
 
831
        cairo_dock_register_data_renderer_gauge ();
528
832
}