← Back to branch summary

~cairo-dock-team/ubuntu/natty/cairo-dock/2.3.0-2.1

« back to all changes in this revision

Viewing changes to src/implementations/cairo-dock-graph.c

  • Committer: Bazaar Package Importer
  • Author(s): Matthieu Baerts (matttbe)
  • Date: 2010-09-07 20:31:25 UTC
  • mfrom: (1.1.11 upstream)
  • Revision ID: james.westby@ubuntu.com-20100907203125-tkq6wc8rw0flx5se
Tags: 2.2.0~0rc1-0ubuntu1
https://launchpad.net/bugs/632055
https://launchpad.net/bugs/618336
https://launchpad.net/bugs/614686
https://launchpad.net/bugs/612617
https://launchpad.net/bugs/612355
https://launchpad.net/bugs/611733
* New Upstream Version (LP: #632055)
* Fixed a few bugs on LP:
 - LP: #618336 all button tips visible if icons 'maximum zoom' set to 1.0
 - LP: #614686 create new sud-dock icon that looking like flat
 - LP: #612617 Add custom launchers or sub-docks, can't modify name.
 - LP: #612355 Add option in config file to set GL/Cairo mode            
 - LP: #611733 icon labels go off-screen
* Fixed a crash when changing theme or gauges
* Updated translations

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/implementations/cairo-dock-graph.c
43
43
        
44
44
        CairoDataRenderer *pRenderer = CAIRO_DATA_RENDERER (pGraph);
45
45
        CairoDataToRenderer *pData = cairo_data_renderer_get_data (pRenderer);
 
46
        int iNbValues = cairo_data_renderer_get_nb_values (pRenderer);
46
47
        
47
48
        if (pGraph->pBackgroundSurface != NULL)
48
49
        {
50
51
                cairo_paint (pCairoContext);
51
52
        }
52
53
        
53
 
        int iNbDrawings = pData->iNbValues / pRenderer->iRank;
 
54
        int iNbDrawings = iNbValues / pRenderer->iRank;
54
55
        if (iNbDrawings == 0)
55
56
                return;
56
57
        
62
63
        double fValue;
63
64
        cairo_pattern_t *pGradationPattern;
64
65
        int i;
65
 
        for (i = 0; i < pData->iNbValues; i ++)
 
66
        for (i = 0; i < iNbValues; i ++)
66
67
        {
 
68
                cairo_save (pCairoContext);
67
69
                if (! pGraph->bMixGraphs)
68
70
                        cairo_translate (pCairoContext,
69
71
                                0.,
155
157
                        }
156
158
                        cairo_stroke (pCairoContext);
157
159
                }
 
160
                cairo_restore (pCairoContext);
 
161
                
 
162
                cairo_dock_render_overlays_to_context (pRenderer, i, pCairoContext);
158
163
        }
159
164
}
160
165
 
174
179
                _cairo_dock_disable_texture ();
175
180
        }
176
181
        
177
 
        
 
182
        /// to be continued ...
178
183
}
179
184
 
180
185
 
291
296
        }
292
297
        return pGradationPattern;
293
298
}
 
299
#define dc .5
 
300
#define _guess_color(i) (((pGraph->fLowColor[i] < pGraph->fHighColor[i] && pGraph->fLowColor[i] > dc) || pGraph->fLowColor[i] > 1-dc) ? pGraph->fLowColor[i] - dc : pGraph->fLowColor[i] + dc)
 
301
//#define _guess_color(i) (1. - pGraph->fLowColor[i])
 
302
static void _set_overlay_zones (CairoDockGraph *pGraph)
 
303
{
 
304
        CairoDataRenderer *pRenderer = CAIRO_DATA_RENDERER (pGraph);
 
305
        int iNbValues = cairo_data_renderer_get_nb_values (pRenderer);
 
306
        int iWidth = pRenderer->iWidth, iHeight = pRenderer->iHeight;
 
307
        int i;
 
308
        
 
309
        // on complete le data-renderer.
 
310
        int iNbDrawings = iNbValues / pRenderer->iRank;
 
311
        double fMargin = pGraph->fMargin;
 
312
        double fOneGraphHeight = iHeight - 2*fMargin;
 
313
        fOneGraphHeight /= iNbDrawings;
 
314
        double fOneGraphWidth = iWidth - 2*fMargin;
 
315
        fOneGraphWidth /= iNbDrawings;
 
316
        int iTextWidth = MIN (48, pRenderer->iWidth/2);  // on definit une taille pour les zones de texte.
 
317
        int iTextHeight = MIN (16, fOneGraphHeight/1.5);
 
318
        int iLabelWidth = MIN (48, pRenderer->iWidth/2);  // on definit une taille pour les zones de texte.
 
319
        int iLabelHeight = MIN (16, fOneGraphHeight/2.);
 
320
        int h = fOneGraphHeight/8;  // ecart du texte au-dessus de l'axe Ox.
 
321
        CairoDataRendererTextParam *pValuesText;
 
322
        CairoDataRendererEmblem *pEmblem;
 
323
        CairoDataRendererText *pLabel;
 
324
        for (i = 0; i < iNbValues; i ++)
 
325
        {
 
326
                /// rajouter l'alignement gauche/centre/droit ...
 
327
                if (pRenderer->pLabels)  // les labels en haut a gauche.
 
328
                {
 
329
                        pLabel = &pRenderer->pLabels[i];
 
330
                        if (iLabelHeight > 8)  // sinon trop petit, et empiete sur la valeur.
 
331
                        {
 
332
                                if (pGraph->bMixGraphs)
 
333
                                {
 
334
                                        pLabel->param.fX = (double)(fMargin + i * fOneGraphWidth + iLabelWidth/2) / iWidth - .5;
 
335
                                        pLabel->param.fY = (double)(iHeight - fMargin - iLabelHeight/2) / iHeight - .5;
 
336
                                }
 
337
                                else
 
338
                                {
 
339
                                        pLabel->param.fX = (double) (fMargin + iLabelWidth/2) / iWidth - .5;
 
340
                                        pLabel->param.fY = .5 - (double)(fMargin + h + i * fOneGraphHeight + iLabelHeight/2) / iHeight;
 
341
                                }
 
342
                                pLabel->param.fWidth = (double)iLabelWidth / iWidth;
 
343
                                pLabel->param.fHeight = (double)iLabelHeight / iHeight;
 
344
                                pLabel->param.pColor[0] = myLabels.quickInfoTextDescription.fBackgroundColor[0];
 
345
                                pLabel->param.pColor[1] = myLabels.quickInfoTextDescription.fBackgroundColor[1];
 
346
                                pLabel->param.pColor[2] = myLabels.quickInfoTextDescription.fBackgroundColor[2];
 
347
                                pLabel->param.pColor[3] = 1.;  // meme couleur que les axes.
 
348
                        }
 
349
                        else
 
350
                        {
 
351
                                pLabel->param.fWidth = pLabel->param.fHeight = 0;
 
352
                        }
 
353
                }
 
354
                if (pRenderer->pValuesText)  // les valeurs en bas au milieu.
 
355
                {
 
356
                        pValuesText = &pRenderer->pValuesText[i];
 
357
                        if (pGraph->bMixGraphs)
 
358
                        {
 
359
                                pValuesText->fX = (double)(fMargin + i * fOneGraphWidth + iTextWidth/2) / iWidth - .5;
 
360
                                pValuesText->fY = (double)(fMargin + h + iTextHeight/2) / iHeight - .5;
 
361
                        }
 
362
                        else
 
363
                        {
 
364
                                pValuesText->fX = (double)0.;  // centered.
 
365
                                pValuesText->fY = .5 - (double)(fMargin + (i+1) * fOneGraphHeight - iTextHeight/2 - h) / iHeight;
 
366
                        }
 
367
                        pValuesText->fWidth = (double)iTextWidth / iWidth;
 
368
                        pValuesText->fHeight = (double)iTextHeight / iHeight;
 
369
                        if (pGraph->fBackGroundColor[3] > .2 && pGraph->fBackGroundColor[3] < .7)
 
370
                        {
 
371
                                pValuesText->pColor[0] = pGraph->fBackGroundColor[0];
 
372
                                pValuesText->pColor[1] = pGraph->fBackGroundColor[1];
 
373
                                pValuesText->pColor[2] = pGraph->fBackGroundColor[2];
 
374
                                //g_print ("bg color: %.2f;%.2f;%.2f\n", pGraph->fBackGroundColor[0], pGraph->fBackGroundColor[1], pGraph->fBackGroundColor[2]);
 
375
                        }
 
376
                        else
 
377
                        {
 
378
                                pValuesText->pColor[0] = _guess_color (0);
 
379
                                pValuesText->pColor[1] = _guess_color (1);
 
380
                                pValuesText->pColor[2] = _guess_color (2);
 
381
                                //g_print ("line color: %.2f;%.2f;%.2f\n", pGraph->fLowColor[0], pGraph->fLowColor[1], pGraph->fLowColor[2]);
 
382
                        }
 
383
                        //g_print ("text color: %.2f;%.2f;%.2f\n", pValuesText->pColor[0], pValuesText->pColor[1], pValuesText->pColor[2]);
 
384
                        pValuesText->pColor[3] = 1.;
 
385
                }
 
386
        }
 
387
}
 
388
 
294
389
static void cairo_dock_load_graph (CairoDockGraph *pGraph, CairoContainer *pContainer, CairoGraphAttribute *pAttribute)
295
390
{
296
391
        CairoDataRenderer *pRenderer = CAIRO_DATA_RENDERER (pGraph);
297
 
        CairoDataToRenderer *pData = cairo_data_renderer_get_data (pRenderer);
298
392
        
299
393
        int iWidth = pRenderer->iWidth, iHeight = pRenderer->iHeight;
300
394
        if (iWidth == 0 || iHeight == 0)
301
395
                return ;
302
396
        
 
397
        int iNbValues = cairo_data_renderer_get_nb_values (pRenderer);
303
398
        pGraph->iType = pAttribute->iType;
304
399
        pGraph->bMixGraphs = pAttribute->bMixGraphs;
305
 
        pGraph->dataRenderer.iRank = (pAttribute->bMixGraphs ? pData->iNbValues : 1);
 
400
        pRenderer->iRank = (pAttribute->bMixGraphs ? iNbValues : 1);
306
401
        
307
 
        pGraph->fHighColor = g_new0 (double, 3 * pData->iNbValues);
 
402
        pGraph->fHighColor = g_new0 (double, 3 * iNbValues);
308
403
        if (pAttribute->fHighColor != NULL)
309
 
                memcpy (pGraph->fHighColor, pAttribute->fHighColor, 3 * pData->iNbValues * sizeof (double));
310
 
        pGraph->fLowColor = g_new0 (double, 3 * pData->iNbValues);
 
404
                memcpy (pGraph->fHighColor, pAttribute->fHighColor, 3 * iNbValues * sizeof (double));
 
405
        pGraph->fLowColor = g_new0 (double, 3 * iNbValues);
311
406
        if (pAttribute->fLowColor != NULL)
312
 
                memcpy (pGraph->fLowColor, pAttribute->fLowColor, 3 * pData->iNbValues * sizeof (double));
 
407
                memcpy (pGraph->fLowColor, pAttribute->fLowColor, 3 * iNbValues * sizeof (double));
313
408
 
314
409
        int i;
315
 
        pGraph->pGradationPatterns = g_new (cairo_pattern_t *, pData->iNbValues);
316
 
        for (i = 0; i < pData->iNbValues; i ++)
 
410
        pGraph->pGradationPatterns = g_new (cairo_pattern_t *, iNbValues);
 
411
        for (i = 0; i < iNbValues; i ++)
317
412
        {
318
413
                pGraph->pGradationPatterns[i] = _cairo_dock_create_graph_pattern (pGraph,
319
414
                        &pGraph->fLowColor[3*i],
321
416
                        0.);
322
417
        }
323
418
        
324
 
        pGraph->iRadius = pAttribute->iRadius;
 
419
        pGraph->iRadius = MAX (pAttribute->iRadius, MIN (iWidth, iHeight)/3.);
325
420
        pGraph->fMargin = pGraph->iRadius * (1. - sqrt(2)/2);
326
421
        if (pAttribute->fBackGroundColor != NULL)
327
422
                memcpy (pGraph->fBackGroundColor, pAttribute->fBackGroundColor, 4 * sizeof (double));
332
427
                pGraph->fMargin,
333
428
                pGraph->fBackGroundColor,
334
429
                pGraph->iType,
335
 
                pData->iNbValues / pRenderer->iRank);
336
 
        if (g_bUseOpenGL)
 
430
                iNbValues / pRenderer->iRank);
 
431
        if (g_bUseOpenGL && 0)
337
432
                pGraph->iBackgroundTexture = cairo_dock_create_texture_from_surface (pGraph->pBackgroundSurface);
 
433
        
 
434
        // on complete le data-renderer.
 
435
        _set_overlay_zones (pGraph);
338
436
}
339
437
 
340
438
 
341
439
static void cairo_dock_reload_graph (CairoDockGraph *pGraph)
342
440
{
343
441
        CairoDataRenderer *pRenderer = CAIRO_DATA_RENDERER (pGraph);
344
 
        CairoDataToRenderer *pData = cairo_data_renderer_get_data (pRenderer);
 
442
        int iNbValues = cairo_data_renderer_get_nb_values (pRenderer);
345
443
        int iWidth = pRenderer->iWidth, iHeight = pRenderer->iHeight;
346
444
        if (pGraph->pBackgroundSurface != NULL)
347
445
                cairo_surface_destroy (pGraph->pBackgroundSurface);
348
 
        pGraph->pBackgroundSurface = _cairo_dock_create_graph_background (iWidth, iHeight, pGraph->iRadius, pGraph->fMargin, pGraph->fBackGroundColor, pGraph->iType, pData->iNbValues / pRenderer->iRank);
 
446
        pGraph->pBackgroundSurface = _cairo_dock_create_graph_background (iWidth, iHeight, pGraph->iRadius, pGraph->fMargin, pGraph->fBackGroundColor, pGraph->iType, iNbValues / pRenderer->iRank);
349
447
        if (pGraph->iBackgroundTexture != 0)
350
448
                _cairo_dock_delete_texture (pGraph->iBackgroundTexture);
351
 
        if (g_bUseOpenGL)
 
449
        if (g_bUseOpenGL && 0)
352
450
                pGraph->iBackgroundTexture = cairo_dock_create_texture_from_surface (pGraph->pBackgroundSurface);
353
451
        else
354
452
                pGraph->iBackgroundTexture = 0;
355
453
        int i;
356
 
        for (i = 0; i < pGraph->dataRenderer.data.iNbValues; i ++)
 
454
        for (i = 0; i < iNbValues; i ++)
357
455
        {
358
456
                if (pGraph->pGradationPatterns[i] != NULL)
359
457
                        cairo_pattern_destroy (pGraph->pGradationPatterns[i]);
360
458
                pGraph->pGradationPatterns[i] = _cairo_dock_create_graph_pattern (pGraph, &pGraph->fLowColor[3*i], &pGraph->fHighColor[3*i], 0.);
361
459
        }
 
460
        
 
461
        // on re-complete le data-renderer.
 
462
        _set_overlay_zones (pGraph);
362
463
}
363
464
 
364
465
 
365
 
static void cairo_dock_free_graph (CairoDockGraph *pGraph)
 
466
static void cairo_dock_unload_graph (CairoDockGraph *pGraph)
366
467
{
367
468
        cd_debug ("");
368
 
        if (pGraph == NULL)
369
 
                return ;
370
469
        if (pGraph->pBackgroundSurface != NULL)
371
470
                cairo_surface_destroy (pGraph->pBackgroundSurface);
372
471
        if (pGraph->iBackgroundTexture != 0)
373
472
                _cairo_dock_delete_texture (pGraph->iBackgroundTexture);
 
473
        
 
474
        CairoDataRenderer *pRenderer = CAIRO_DATA_RENDERER (pGraph);
 
475
        int iNbValues = cairo_data_renderer_get_nb_values (pRenderer);
374
476
        int i;
375
 
        for (i = 0; i < pGraph->dataRenderer.data.iNbValues; i ++)
 
477
        for (i = 0; i < iNbValues; i ++)
376
478
        {
377
479
                if (pGraph->pGradationPatterns[i] != NULL)
378
480
                        cairo_pattern_destroy (pGraph->pGradationPatterns[i]);
381
483
        g_free (pGraph->pGradationPatterns);
382
484
        g_free (pGraph->fHighColor);
383
485
        g_free (pGraph->fLowColor);
384
 
        g_free (pGraph);
385
486
}
386
487
 
387
488
 
389
490
  //////////////////////////////////////////
390
491
 /////////////// RENDERER /////////////////
391
492
//////////////////////////////////////////
392
 
CairoDockGraph *cairo_dock_new_graph (void)
 
493
void cairo_dock_register_data_renderer_graph (void)
393
494
{
394
 
        CairoDockGraph *pGraph = g_new0 (CairoDockGraph, 1);
395
 
        pGraph->dataRenderer.interface.new                              = (CairoDataRendererNewFunc) cairo_dock_new_graph;
396
 
        pGraph->dataRenderer.interface.load                             = (CairoDataRendererLoadFunc) cairo_dock_load_graph;
397
 
        pGraph->dataRenderer.interface.render                   = (CairoDataRendererRenderFunc) cairo_dock_render_graph;
398
 
        pGraph->dataRenderer.interface.render_opengl    = (CairoDataRendererRenderOpenGLFunc) NULL;
399
 
        pGraph->dataRenderer.interface.reload                   = (CairoDataRendererReloadFunc) cairo_dock_reload_graph;
400
 
        pGraph->dataRenderer.interface.free                             = (CairoDataRendererFreeFunc) cairo_dock_free_graph;
401
 
        return pGraph;
 
495
        CairoDockDataRendererRecord *pRecord = g_new0 (CairoDockDataRendererRecord, 1);
 
496
        pRecord->interface.load                 = (CairoDataRendererLoadFunc) cairo_dock_load_graph;
 
497
        pRecord->interface.render               = (CairoDataRendererRenderFunc) cairo_dock_render_graph;
 
498
        pRecord->interface.render_opengl        = (CairoDataRendererRenderOpenGLFunc) NULL;
 
499
        pRecord->interface.reload               = (CairoDataRendererReloadFunc) cairo_dock_reload_graph;
 
500
        pRecord->interface.unload               = (CairoDataRendererUnloadFunc) cairo_dock_unload_graph;
 
501
        pRecord->iStructSize                    = sizeof (CairoDockGraph);
 
502
        pRecord->cThemeDirName = NULL;
 
503
        pRecord->cDefaultTheme = NULL;
 
504
        
 
505
        cairo_dock_register_data_renderer ("graph", pRecord);
402
506
}