← Back to branch summary

~ubuntu-branches/ubuntu/quantal/cairo-dock-plug-ins/quantal-201208191523

« back to all changes in this revision

Viewing changes to dock-rendering/src/rendering-diapo-simple.c

  • Committer: Bazaar Package Importer
  • Author(s): Matthieu Baerts (matttbe)
  • Date: 2010-09-07 02:38:17 UTC
  • mfrom: (1.1.6 upstream)
  • Revision ID: james.westby@ubuntu.com-20100907023817-ish9a53i2wn0m7zg
Tags: 2.2.0~0rc1-0ubuntu1
https://launchpad.net/bugs/632054
https://launchpad.net/bugs/616176
https://launchpad.net/bugs/604034
https://launchpad.net/bugs/582452
* New Upstream Version (LP: #632054)
* Fixed a few bugs on LP:
 - LP: #616176 Dust Bin Hang and Incorrect Configuration
 - LP: #604034 Change terminal tab's name lost the color
 - LP: #582452 GMenu does not contain any applications
* Fixed a few bugs on glx-dock forum:
 - Fixed support of GMusicBrowser.
 - AlsaMixer has no emblem.
 - Status-Notifier doesn't be drawed into the dock.
* Updated translations
* debian/control:
 - Added cairo-dock-core as build-depends in order to prevent
   some builds errors.

Show diffs side-by-side

added added

removed removed

Lines of Context:
dock-rendering/src/rendering-diapo-simple.c
48
48
extern gboolean my_diapo_simple_draw_background;
49
49
extern gboolean my_diapo_simple_display_all_labels;
50
50
 
51
 
extern gdouble  my_diapo_simple_color_scrollbar_line[4];
52
 
extern gdouble  my_diapo_simple_color_scrollbar_inside[4];
53
 
extern gdouble  my_diapo_simple_color_grip[4];
 
51
extern gdouble my_diapo_simple_color_scrollbar_line[4];
 
52
extern gdouble my_diapo_simple_color_scrollbar_inside[4];
 
53
extern gdouble my_diapo_simple_color_grip[4];
54
54
 
55
55
const gint X_BORDER_SPACE = 40;  // espace laisse de chaque cote pour eviter de sortir trop facilement (et pour laisser de la place pour les etiquettes).
56
56
const gint ARROW_TIP = 5;  // pour gerer la pointe de la fleche.
66
66
        gboolean bDraggingScrollbar;  // si le clic est couramment enfonce sur la scrollbar.
67
67
        guint iSidPressEvent;  // sid du clic
68
68
        guint iSidReleaseEvent;  // sid du relachement du clic
69
 
        gint iClickY;  // hauteur ou on a clique, en coordonnees fenetre
 
69
        gint iClickY;  // hauteur ou on a clique, en coordonnees container.
70
70
        gint iClickOffset;  // hauteur scrollee au moment du clic
71
71
        } CDSlideData;
72
72
 
86
86
static guint _cd_rendering_diapo_simple_guess_grid (GList *pIconList, guint *nRowX, guint *nRowY)
87
87
{
88
88
        // Calcul du nombre de lignes (nY) / colonnes (nX) :
89
 
        guint count = g_list_length (pIconList);
 
89
        guint count = 0;  // g_list_length (pIconList)
 
90
        Icon *icon;
 
91
        GList *ic;
 
92
        for (ic = pIconList; ic != NULL; ic = ic->next)
 
93
        {
 
94
                icon = ic->data;
 
95
                if (! CAIRO_DOCK_ICON_TYPE_IS_SEPARATOR (icon))
 
96
                        count ++;
 
97
        }
 
98
        
90
99
        if (count == 0)
91
100
        {
92
101
                *nRowX = 0;
105
114
        return count;
106
115
}
107
116
 
108
 
const double sr = .5;  // screen ratio
109
 
 
110
117
static void _set_scroll (CairoDock *pDock, int iOffsetY)
111
118
{
112
119
        //g_print ("%s (%d)\n", __func__, iOffsetY);
168
175
        if (pButton->type == GDK_BUTTON_PRESS && pButton->button == 1)
169
176
        {
170
177
                double x_arrow = pDock->iMaxDockWidth - X_BORDER_SPACE - fScrollbarWidth;
171
 
                if (pButton->x > x_arrow)  // on a clique dans la zone de scroll.
172
 
                {
173
 
                        //g_print ("click (y=%d, scroll=%d)\n", (int) pButton->y, pData->iScrollOffset);
 
178
                int x, y;
 
179
                if (pDock->container.bIsHorizontal)
 
180
                {
 
181
                        x = pButton->x;
 
182
                        y = pButton->y;
 
183
                }
 
184
                else
 
185
                {
 
186
                        x = pButton->y;
 
187
                        y = pButton->x;
 
188
                }
 
189
                if (x > x_arrow)  // on a clique dans la zone de scroll.
 
190
                {
 
191
                        //g_print ("click (y=%d, scroll=%d)\n", (int) y, pData->iScrollOffset);
174
192
                        
175
193
                        // on regarde sur quoi on clic.
176
194
                        double y_arrow_top, y_arrow_bottom;
184
202
                                y_arrow_bottom = pDock->iMaxDockHeight - my_diapo_simple_lineWidth;
185
203
                                y_arrow_top = my_diapo_simple_arrowHeight + ARROW_TIP + my_diapo_simple_lineWidth;
186
204
                        }
187
 
                        if (pButton->y > y_arrow_top - fScrollbarArrowGap/2 && pButton->y < y_arrow_top + fArrowHeight + fScrollbarArrowGap/2)  // bouton haut
 
205
                        if (y > y_arrow_top - fScrollbarArrowGap/2 && y < y_arrow_top + fArrowHeight + fScrollbarArrowGap/2)  // bouton haut
188
206
                        {
189
207
                                _set_scroll (pDock, 0);
190
208
                        }
191
 
                        else if (pButton->y < y_arrow_bottom + fScrollbarArrowGap/2 && pButton->y > y_arrow_bottom - fArrowHeight - fScrollbarArrowGap/2)  // bouton bas
 
209
                        else if (y < y_arrow_bottom + fScrollbarArrowGap/2 && y > y_arrow_bottom - fArrowHeight - fScrollbarArrowGap/2)  // bouton bas
192
210
                        {
193
211
                                _set_scroll (pDock, pData->iDeltaHeight);
194
212
                        }
195
213
                        else  // scrollbar
196
214
                        {
197
215
                                pData->bDraggingScrollbar = TRUE;
198
 
                                pData->iClickY = pButton->y;
 
216
                                pData->iClickY = y;
199
217
                                pData->iClickOffset = pData->iScrollOffset;
200
218
                        }
201
219
                }
235
253
                
236
254
                int delta = pDock->container.iMouseY - pData->iClickY;
237
255
                _set_scroll (pDock, (pData->iClickOffset + (double)delta / (y_arrow_top - y_arrow_bottom - 2*(fArrowHeight+fScrollbarArrowGap) - fGripHeight) * pData->iDeltaHeight));
 
256
                return CAIRO_DOCK_INTERCEPT_NOTIFICATION;
238
257
        }
239
 
        return CAIRO_DOCK_INTERCEPT_NOTIFICATION;
 
258
        return CAIRO_DOCK_LET_PASS_NOTIFICATION;
240
259
}
241
260
gboolean cd_slide_on_leave (gpointer data, CairoDock *pDock, gboolean *bStartAnimation)
242
261
{
249
268
        
250
269
        return (pData->bDraggingScrollbar ? CAIRO_DOCK_INTERCEPT_NOTIFICATION : CAIRO_DOCK_LET_PASS_NOTIFICATION);
251
270
}
 
271
const double sr = .5;  // screen ratio
252
272
static void cd_rendering_calculate_max_dock_size_diapo_simple (CairoDock *pDock)
253
273
{
254
274
        // On calcule la configuration de la grille sans contrainte.
257
277
        guint nIcones = 0;  // nb icones.
258
278
        int iDeltaHeight = 0;  // hauteur ne pouvant rentrer dans le dock.
259
279
        int iMaxIconWidth = 0;
 
280
        int iDockWidth, iDockHeight;  // dimension dock.
 
281
        int Ws = g_desktopGeometry.iXScreenWidth[CAIRO_DOCK_HORIZONTAL];  // dimensions ecran.
 
282
        int Hs = g_desktopGeometry.iXScreenHeight[CAIRO_DOCK_HORIZONTAL];
260
283
        nIcones = _cd_rendering_diapo_simple_guess_grid(pDock->icons, &nRowsX, &nRowsY);
261
284
        
262
285
        // On calcule la taille de l'affichage avec contrainte taille ecran.
264
287
        {
265
288
                // on calcule la largeur avec contrainte, ce qui donne aussi le nombre de lignes.
266
289
                iMaxIconWidth = ((Icon*)pDock->icons->data)->fWidth;  // approximation un peu bof.
267
 
                pDock->iMaxDockWidth = nRowsX * (iMaxIconWidth + my_diapo_simple_iconGapX) + 2*X_BORDER_SPACE;
268
 
                int iMaxWidth = sr * g_desktopGeometry.iXScreenWidth[pDock->container.bIsHorizontal];
269
 
                if (pDock->iMaxDockWidth > iMaxWidth)
 
290
                iDockWidth = nRowsX * (iMaxIconWidth + my_diapo_simple_iconGapX) + 2*X_BORDER_SPACE;
 
291
                int iMaxWidth = sr * Ws;
 
292
                if (iDockWidth > iMaxWidth)
270
293
                {
271
294
                        nRowsX = (iMaxWidth - 2*X_BORDER_SPACE) / (iMaxIconWidth + my_diapo_simple_iconGapX);
272
295
                        nRowsY = ceil((double) nIcones / nRowsX);
273
 
                        pDock->iMaxDockWidth = nRowsX * (iMaxIconWidth + my_diapo_simple_iconGapX) + 2*X_BORDER_SPACE;
274
 
                        //g_print ("%d -> %d\n", iMaxWidth, pDock->iMaxDockWidth);
 
296
                        iDockWidth = nRowsX * (iMaxIconWidth + my_diapo_simple_iconGapX) + 2*X_BORDER_SPACE;
 
297
                        //g_print ("%d -> %d\n", iMaxWidth, iDockWidth);
275
298
                }
276
299
                
277
300
                // on calcule la hauteur avec contrainte, ce qui donne aussi la marge de defilement.
278
 
                pDock->iMaxDockHeight = (nRowsY - 1) * (pDock->iMaxIconHeight * pDock->container.fRatio + my_diapo_simple_iconGapY) +  // les icones
 
301
                iDockHeight = (nRowsY - 1) * (pDock->iMaxIconHeight * pDock->container.fRatio + my_diapo_simple_iconGapY) +  // les icones
279
302
                        pDock->iMaxIconHeight * pDock->container.fRatio * my_diapo_simple_fScaleMax +  // les icones des bords zooment
280
303
                        myLabels.iLabelSize +  // le texte des icones de la 1ere ligne
281
304
                        my_diapo_simple_lineWidth + // les demi-lignes du haut et du bas
282
305
                        my_diapo_simple_arrowHeight + ARROW_TIP;  // la fleche etendue
283
 
                int iMaxHeight = MIN (pDock->iMaxDockWidth, sr * g_desktopGeometry.iXScreenHeight[pDock->container.bIsHorizontal]);
284
 
                if (pDock->iMaxDockHeight > iMaxHeight)
 
306
                int iMaxHeight = sr * Hs;
 
307
                if (iDockHeight > iMaxHeight)
285
308
                {
286
309
                        nRowsY = (iMaxHeight - (my_diapo_simple_arrowHeight + ARROW_TIP + my_diapo_simple_lineWidth + myLabels.iLabelSize + pDock->iMaxIconHeight * pDock->container.fRatio * my_diapo_simple_fScaleMax)) / (pDock->iMaxIconHeight * pDock->container.fRatio + my_diapo_simple_iconGapY);
287
 
                        int iMaxDockHeight0 = pDock->iMaxDockHeight;
288
 
                        pDock->iMaxDockHeight = (nRowsY - 1) * (pDock->iMaxIconHeight * pDock->container.fRatio + my_diapo_simple_iconGapY) +
 
310
                        int iMaxDockHeight0 = iDockHeight;
 
311
                        iDockHeight = (nRowsY - 1) * (pDock->iMaxIconHeight * pDock->container.fRatio + my_diapo_simple_iconGapY) +
289
312
                                pDock->iMaxIconHeight * pDock->container.fRatio * my_diapo_simple_fScaleMax +
290
313
                                myLabels.iLabelSize +
291
314
                                my_diapo_simple_lineWidth +
292
315
                                my_diapo_simple_arrowHeight + ARROW_TIP;
293
 
                        iDeltaHeight = iMaxDockHeight0 - pDock->iMaxDockHeight;
294
 
                        //g_print ("%d -> %d\n", iMaxHeight, pDock->iMaxDockHeight);
 
316
                        iDeltaHeight = iMaxDockHeight0 - iDockHeight;
 
317
                        //g_print ("%d -> %d\n", iMaxHeight, iDockHeight);
295
318
                }
296
 
                
297
 
                pDock->iMinDockWidth = pDock->iMaxDockWidth - 2*X_BORDER_SPACE;
298
 
                pDock->iMinDockHeight = pDock->iMaxDockHeight;
299
319
        }
300
320
        else
301
321
        {
302
 
                pDock->iMaxDockWidth = pDock->iMinDockWidth = X_BORDER_SPACE * 2 + 1;
303
 
                pDock->iMaxDockHeight = pDock->iMinDockHeight = my_diapo_simple_lineWidth + my_diapo_simple_arrowHeight + ARROW_TIP + 1;
 
322
                iDockWidth = X_BORDER_SPACE * 2 + 1;
 
323
                iDockHeight = my_diapo_simple_lineWidth + my_diapo_simple_arrowHeight + ARROW_TIP + 1;
304
324
        }
305
325
        
306
 
        // pas de decorations.
307
 
        pDock->iDecorationsHeight = 0;
308
 
        pDock->iDecorationsWidth  = 0;
309
 
        
310
 
        // On affecte ca aussi au cas ou.
311
 
        pDock->fFlatDockWidth = pDock->iMaxDockWidth;
312
 
        pDock->fMagnitudeMax = my_diapo_simple_fScaleMax / (1+g_fAmplitude);
313
 
        
314
326
        CDSlideData *pData = pDock->pRendererData;
315
327
        if (pData == NULL)
316
328
        {
335
347
        {
336
348
                int iScrollMargin = iMaxIconWidth * (my_diapo_simple_fScaleMax - 1) / 2
337
349
                        + fScrollbarIconGap
338
 
                        + fScrollbarWidth;  // donc a droite on a : derniere icone en taille max + demi-gapx + + gab + scrollbar + X_BORDER_SPACE
339
 
                pDock->iMaxDockWidth += iScrollMargin;
340
 
        }
 
350
                        + fScrollbarWidth;  // donc a droite on a : derniere icone en taille max + demi-gapx + gap + scrollbar + X_BORDER_SPACE
 
351
                iDockWidth += iScrollMargin;
 
352
        }
 
353
        
 
354
        // taille du dock
 
355
        //if (pDock->container.bIsHorizontal)
 
356
        {
 
357
                pDock->iMaxDockWidth = iDockWidth;
 
358
                pDock->iMaxDockHeight = iDockHeight;
 
359
        }
 
360
        /*else  // pareil, sauf la fleche qui sera sur les cotes.
 
361
        {
 
362
                pDock->iMaxDockWidth = iDockHeight - (my_diapo_simple_arrowHeight + ARROW_TIP);
 
363
                pDock->iMaxDockHeight = iDockWidth + my_diapo_simple_arrowHeight + ARROW_TIP;
 
364
        }*/
 
365
        pDock->iMinDockWidth = pDock->iMaxDockWidth - 2*X_BORDER_SPACE;
 
366
        pDock->iMinDockHeight = pDock->iMaxDockHeight;
 
367
        // pas de decorations.
 
368
        pDock->iDecorationsHeight = 0;
 
369
        pDock->iDecorationsWidth  = 0;
 
370
        // On affecte ca aussi au cas ou.
 
371
        pDock->fFlatDockWidth = pDock->iMaxDockWidth;
 
372
        pDock->fMagnitudeMax = my_diapo_simple_fScaleMax / (1+g_fAmplitude);
341
373
}
342
374
 
343
375
 
347
379
static void cairo_dock_draw_frame_horizontal_for_diapo_simple (cairo_t *pCairoContext, CairoDock *pDock)
348
380
{
349
381
        const gdouble arrow_dec = 2;
350
 
        gdouble fFrameWidth  = pDock->iMaxDockWidth - 2 * X_BORDER_SPACE - 0 * my_diapo_simple_radius;
 
382
        gdouble fFrameWidth  = pDock->iMaxDockWidth - 2 * X_BORDER_SPACE;
351
383
        gdouble fFrameHeight = pDock->iMaxDockHeight - (my_diapo_simple_arrowHeight + ARROW_TIP + my_diapo_simple_lineWidth);
352
 
        gdouble fDockOffsetX = X_BORDER_SPACE + 0*my_diapo_simple_radius;
 
384
        gdouble fDockOffsetX = X_BORDER_SPACE;
353
385
        gdouble fDockOffsetY = (pDock->container.bDirectionUp ? .5*my_diapo_simple_lineWidth : my_diapo_simple_arrowHeight + ARROW_TIP);
354
386
        
355
387
        cairo_move_to (pCairoContext, fDockOffsetX, fDockOffsetY);
412
444
static void cairo_dock_draw_frame_vertical_for_diapo_simple (cairo_t *pCairoContext, CairoDock *pDock)
413
445
{
414
446
        const gdouble arrow_dec = 2;
415
 
        gdouble fFrameWidth  = pDock->iMaxDockWidth - 2 * X_BORDER_SPACE - 2 * my_diapo_simple_radius;
 
447
        gdouble fFrameWidth  = pDock->iMaxDockWidth - 2 * X_BORDER_SPACE;
416
448
        gdouble fFrameHeight = pDock->iMaxDockHeight - (my_diapo_simple_arrowHeight + ARROW_TIP + my_diapo_simple_lineWidth);
417
 
        gdouble fDockOffsetX = X_BORDER_SPACE + my_diapo_simple_radius;
 
449
        gdouble fDockOffsetX = X_BORDER_SPACE;
418
450
        gdouble fDockOffsetY = (pDock->container.bDirectionUp ? .5*my_diapo_simple_lineWidth : my_diapo_simple_arrowHeight + ARROW_TIP);
419
451
        
420
452
        cairo_move_to (pCairoContext, fDockOffsetY, fDockOffsetX);
544
576
                cairo_save (pCairoContext);
545
577
                cairo_set_line_width (pCairoContext, 2.);
546
578
                
 
579
                if (! pDock->container.bIsHorizontal)
 
580
                {
 
581
                        cairo_translate (pCairoContext, pDock->container.iHeight/2, pDock->container.iWidth/2);
 
582
                        cairo_rotate (pCairoContext, G_PI/2);
 
583
                        cairo_scale (pCairoContext, 1., -1.);
 
584
                        cairo_translate (pCairoContext, -pDock->container.iWidth/2, -pDock->container.iHeight/2);
 
585
                }
 
586
                
547
587
                double x_arrow = pDock->iMaxDockWidth - X_BORDER_SPACE - fScrollbarWidth/2;  // pointe de la fleche.
548
588
                double y_arrow_top, y_arrow_bottom;
549
589
                if (pDock->container.bDirectionUp)
624
664
                                0.,
625
665
                                (pDock->container.bDirectionUp ? my_diapo_simple_lineWidth : h),  // top left corner.
626
666
                                pDock->container.iWidth,
627
 
                                pDock->container.iHeight - h);
628
 
                        cairo_clip (pCairoContext);
629
 
                }  // sinon clip inutile.
 
667
                                pDock->container.iHeight - h - my_diapo_simple_lineWidth);
 
668
                }
 
669
                else
 
670
                {
 
671
                        cairo_rectangle (pCairoContext,
 
672
                                (pDock->container.bDirectionUp ? my_diapo_simple_lineWidth : h),  // top left corner.
 
673
                                0.,
 
674
                                pDock->container.iHeight - h - my_diapo_simple_lineWidth,
 
675
                                pDock->container.iWidth);
 
676
                }
 
677
                cairo_clip (pCairoContext);
630
678
        }
631
679
        
632
680
        // on dessine les icones, l'icone pointee en dernier.
636
684
        {
637
685
                icon = ic->data;
638
686
                if (CAIRO_DOCK_ICON_TYPE_IS_SEPARATOR (icon))
 
687
                {
 
688
                        ic = cairo_dock_get_next_element (ic, pDock->icons);
639
689
                        continue;
640
 
                
641
 
                if (icon->bPointed)
642
 
                {
643
 
                        
644
690
                }
645
691
                
646
692
                cairo_save (pCairoContext);
647
 
                /// faire un clip si scroll != 0 ...
648
693
                cairo_dock_render_one_icon (icon, pDock, pCairoContext, 1., FALSE);
649
694
                cairo_restore (pCairoContext);
650
695
                
754
799
                fScrollOffset = (pDock->container.bDirectionUp ? - pData->iScrollOffset : pData->iScrollOffset);
755
800
        
756
801
        // On calcule la position de base pour toutes les icones
757
 
        int iOffsetY = .5 * pDock->iMaxIconHeight * pDock->container.fRatio * (my_diapo_simple_fScaleMax - 1) +  // les icones de la 1ere ligne zooment
758
 
                myLabels.iLabelSize +  // le texte des icones de la 1ere ligne
759
 
                .5 * my_diapo_simple_lineWidth +  // demi-ligne du haut;
760
 
                fScrollOffset;
761
 
        
 
802
        int iOffsetY;
 
803
        if (pDock->container.bDirectionUp)
 
804
                iOffsetY = .5 * pDock->iMaxIconHeight * pDock->container.fRatio * (my_diapo_simple_fScaleMax - 1) +  // les icones de la 1ere ligne zooment
 
805
                        myLabels.iLabelSize +  // le texte des icones de la 1ere ligne
 
806
                        .5 * my_diapo_simple_lineWidth +  // demi-ligne du haut;
 
807
                        fScrollOffset;
 
808
        else
 
809
                iOffsetY = .5 * pDock->iMaxIconHeight * pDock->container.fRatio * (my_diapo_simple_fScaleMax - 1) +  // les icones de la 1ere ligne zooment
 
810
                                .5 * my_diapo_simple_lineWidth +  // demi-ligne du bas;
 
811
                                fScrollOffset;
762
812
        double fFoldingX = (pDock->fFoldingFactor > .2 ? (pDock->fFoldingFactor - .2) / .8 : 0.);  // placement de 1 a 0.2
763
813
        double fFoldingY = (pDock->fFoldingFactor > .5 ? (pDock->fFoldingFactor - .5) / .5 : 0.);  // placement de 1 a 0.5
764
814
        Icon* icon;
776
826
                if (pDock->container.bDirectionUp)
777
827
                        icon->fY = iOffsetY + (icon->fHeight + my_diapo_simple_iconGapY) * y;
778
828
                else
779
 
                        icon->fY = pDock->container.iHeight - iOffsetY - icon->fHeight - (nRowsY - 1 - y) * (icon->fHeight + my_diapo_simple_iconGapY) + (my_diapo_simple_arrowHeight + ARROW_TIP);  // la ligne du haut quand le dock est en bas, reste en haut quand le dock est en haut.
 
829
                {
 
830
                        icon->fY = pDock->container.iHeight - iOffsetY - icon->fHeight - (nRowsY - 1 - y) * (icon->fHeight + my_diapo_simple_iconGapY);
 
831
                }
780
832
                
781
833
                // on en deduit le zoom par rapport a la position de la souris.
782
834
                gdouble distanceE = sqrt ((icon->fX + icon->fWidth/2 - Mx) * (icon->fX + icon->fWidth/2 - Mx) + (icon->fY + icon->fHeight/2 - My) * (icon->fY + icon->fHeight/2 - My));
820
872
                else
821
873
                {
822
874
                        icon->bPointed = FALSE;
823
 
                        ///icon->fAlpha *= 0.75;
824
875
                }
825
876
                
826
877
                // On affecte tous les parametres qui n'ont pas été défini précédement
850
901
{
851
902
        if (pDock->icons == NULL)
852
903
                return NULL;
853
 
        
854
 
        // On calcule la configuration de la grille
855
 
        gint nRowsX = 0;
856
 
        gint nRowsY = 0;
857
 
        gint nIcones = 0;
858
 
        ///nIcones = _cd_rendering_diapo_simple_guess_grid (pDock->icons, &nRowsX, &nRowsY);
859
 
        
860
904
        CDSlideData *pData = pDock->pRendererData;
861
905
        g_return_val_if_fail (pData != NULL, NULL);
862
 
        nRowsX = pData->nRowsX;
863
 
        nRowsY = pData->nRowsY;
864
 
        /*int iMaxIconWidth = ((Icon*)pDock->icons->data)->fWidth;  // approximation un peu bof.
865
 
        nRowsX = (pDock->iMaxDockWidth - 2*X_BORDER_SPACE) / (iMaxIconWidth + my_diapo_simple_iconGapX);
866
 
        nRowsY = (pDock->iMaxDockHeight - (my_diapo_simple_arrowHeight + ARROW_TIP + my_diapo_simple_lineWidth + myLabels.iLabelSize + pDock->iMaxIconHeight * pDock->container.fRatio * my_diapo_simple_fScaleMax)) / (pDock->iMaxIconHeight * pDock->container.fRatio + my_diapo_simple_iconGapY);*/
 
906
        
 
907
        // On recupere la configuration de la grille
 
908
        gint nRowsX = pData->nRowsX;
 
909
        gint nRowsY = pData->nRowsY;
867
910
        
868
911
        // On calcule les parametres des icones
869
912
        Icon *pPointedIcon = _cd_rendering_calculate_icons_for_diapo_simple (pDock, nRowsX, nRowsY, pDock->container.iMouseX, pDock->container.iMouseY);
1033
1076
        double fFrameWidth  = pDock->iMaxDockWidth - 2*X_BORDER_SPACE;  // longueur du trait horizontal.
1034
1077
        double fFrameHeight = pDock->iMaxDockHeight - (my_diapo_simple_arrowHeight + ARROW_TIP + my_diapo_simple_lineWidth);  // hauteur du cadre avec les rayons et sans la pointe.
1035
1078
        double fDockOffsetX, fDockOffsetY;
1036
 
        
1037
1079
        fDockOffsetX = X_BORDER_SPACE;
1038
1080
        fDockOffsetY = my_diapo_simple_arrowHeight+ARROW_TIP;
1039
 
        ///fFrameWidth  = pDock->iMaxDockWidth - 2*X_BORDER_SPACE;  // longueur du trait horizontal.
1040
 
        ///fFrameHeight = pDock->iMaxDockHeight- (my_diapo_simple_arrowHeight + ARROW_TIP + my_diapo_simple_lineWidth);  // hauteur du cadre avec les rayons et sans la pointe.
1041
1081
        
1042
1082
        //\_____________ On genere les coordonnees du contour.
1043
1083
        CairoDockGLPath *pFramePath = cd_generate_frame_path_without_arrow (fFrameWidth, fFrameHeight, fRadius);
1082
1122
        CDSlideData *pData = pDock->pRendererData;
1083
1123
        if (pData != NULL && pData->iDeltaHeight != 0)
1084
1124
        {
1085
 
                glPushMatrix ();
1086
1125
                if (pScrollPath == NULL)
1087
1126
                        pScrollPath = cairo_dock_new_gl_path (4, 0., 0., 0, 0);  // des triangles ou des rectangles => 4 points max.
1088
1127
                glLineWidth (2.);
1089
 
                
 
1128
                glPushMatrix ();
 
1129
                if (!pDock->container.bIsHorizontal)
 
1130
                {
 
1131
                        glTranslatef (pDock->container.iHeight/2, pDock->container.iWidth/2, 0.);
 
1132
                        glRotatef (-90., 0., 0., 1.);
 
1133
                        glScalef (1., -1., 1.);  // comme si bDirectionUp
 
1134
                        glTranslatef (-pDock->container.iWidth/2, -pDock->container.iHeight/2, 0.);
 
1135
                }
1090
1136
                double x_arrow = pDock->iMaxDockWidth - X_BORDER_SPACE - fScrollbarWidth/2;  // pointe de la fleche.
1091
1137
                double y_arrow_top, y_arrow_bottom;
1092
1138
                if (pDock->container.bDirectionUp)
1145
1191
                cairo_dock_gl_path_rel_line_to (pScrollPath, 0., - fGripHeight);
1146
1192
                cairo_dock_gl_path_rel_line_to (pScrollPath, -fScrollbarWidth, 0.);
1147
1193
                cairo_dock_fill_gl_path (pScrollPath, 0);
1148
 
                
1149
1194
                glPopMatrix ();
1150
1195
        }
1151
1196
        
1166
1211
        if (pData != NULL && pData->iDeltaHeight != 0) // on fait un clip pour les icones qui debordent.
1167
1212
        {
1168
1213
                int h = my_diapo_simple_arrowHeight + ARROW_TIP + my_diapo_simple_lineWidth;
 
1214
                glEnable (GL_SCISSOR_TEST);
1169
1215
                if (pDock->container.bIsHorizontal)
1170
1216
                {
1171
 
                        glEnable (GL_SCISSOR_TEST);
1172
1217
                        glScissor (0,
1173
 
                                (pDock->container.bDirectionUp ? h : 0),  // lower left corner of the scissor box.
 
1218
                                (pDock->container.bDirectionUp ? h : my_diapo_simple_lineWidth),  // lower left corner of the scissor box.
1174
1219
                                pDock->container.iWidth,
1175
 
                                pDock->container.iHeight - h);
1176
 
                }  // sinon clip inutile.
 
1220
                                pDock->container.iHeight - h - my_diapo_simple_lineWidth);
 
1221
                }
 
1222
                else
 
1223
                {
 
1224
                        glScissor ((!pDock->container.bDirectionUp ? h : my_diapo_simple_lineWidth),  // lower left corner of the scissor box.
 
1225
                                my_diapo_simple_lineWidth,
 
1226
                                pDock->container.iHeight - h - my_diapo_simple_lineWidth,
 
1227
                                pDock->container.iWidth);
 
1228
                }
1177
1229
        }
1178
1230
        
1179
1231
        Icon *icon;
1182
1234
        {
1183
1235
                icon = ic->data;
1184
1236
                if (CAIRO_DOCK_ICON_TYPE_IS_SEPARATOR (icon))
 
1237
                {
 
1238
                        ic = cairo_dock_get_next_element (ic, pDock->icons);
1185
1239
                        continue;
 
1240
                }
1186
1241
                
1187
1242
                cairo_dock_render_one_icon_opengl (icon, pDock, 1., FALSE);
1188
1243
                
1282
1337
 
1283
1338
void cd_rendering_register_diapo_simple_renderer (const gchar *cRendererName)
1284
1339
{
1285
 
//////////////////////////////////////////////////////////////////////////////////////// On definit le renderer :
1286
 
        CairoDockRenderer *pRenderer = g_new0 (CairoDockRenderer, 1);                                           //Nouvelle structure    
1287
 
        pRenderer->cReadmeFilePath = g_strdup_printf ("%s/readme-diapo-simple-view", MY_APPLET_SHARE_DATA_DIR);        //On affecte le readme
1288
 
        pRenderer->cPreviewFilePath = g_strdup_printf ("%s/preview-diapo-simple.jpg", MY_APPLET_SHARE_DATA_DIR);       // la preview
1289
 
        pRenderer->compute_size = cd_rendering_calculate_max_dock_size_diapo_simple;                        //La fonction qui défini les bornes     
1290
 
        pRenderer->calculate_icons = cd_rendering_calculate_icons_diapo_simple;                                        //qui calcule les param des icones      
1291
 
        pRenderer->render = cd_rendering_render_diapo_simple;                                                          //qui initie le calcul du rendu         
1292
 
        pRenderer->render_optimized = NULL;//cd_rendering_render_diapo_simple_optimized;                                      //pareil en mieux                       
1293
 
        pRenderer->set_subdock_position = cairo_dock_set_subdock_position_linear;                               // ?                                    
1294
 
        pRenderer->render_opengl = cd_rendering_render_diapo_simple_opengl;
1295
 
        
1296
 
        pRenderer->free_data = cd_rendering_free_slide_data;
1297
 
        
1298
 
        
1299
 
        pRenderer->bUseReflect = FALSE;                                                                         // On dit non au reflections
1300
 
        pRenderer->cDisplayedName = D_ (cRendererName);
1301
 
        
1302
 
        cairo_dock_register_renderer (cRendererName, pRenderer);                                    //Puis on signale l'existence de notre rendu
 
1340
        CairoDockRenderer *pRenderer = g_new0 (CairoDockRenderer, 1);
 
1341
        // interface
 
1342
        pRenderer->compute_size         = cd_rendering_calculate_max_dock_size_diapo_simple;
 
1343
        pRenderer->calculate_icons      = cd_rendering_calculate_icons_diapo_simple;
 
1344
        pRenderer->render               = cd_rendering_render_diapo_simple;
 
1345
        pRenderer->render_optimized     = NULL;
 
1346
        pRenderer->render_opengl        = cd_rendering_render_diapo_simple_opengl;
 
1347
        pRenderer->free_data            = cd_rendering_free_slide_data;
 
1348
        pRenderer->set_subdock_position = cairo_dock_set_subdock_position_linear;
 
1349
        // parametres
 
1350
        pRenderer->cReadmeFilePath      = g_strdup (MY_APPLET_SHARE_DATA_DIR"/readme-diapo-simple-view");
 
1351
        pRenderer->cPreviewFilePath     = g_strdup (MY_APPLET_SHARE_DATA_DIR"/preview-diapo-simple.jpg");
 
1352
        pRenderer->bUseReflect = FALSE;  // pas de reflections
 
1353
        pRenderer->cDisplayedName = D_(cRendererName);
 
1354
        
 
1355
        cairo_dock_register_renderer (cRendererName, pRenderer);
1303
1356
}