← Back to branch summary

~cairo-dock-team/ubuntu/precise/cairo-dock-plug-ins/984054

« back to all changes in this revision

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

  • Committer: Bazaar Package Importer
  • Author(s): Matthieu Baerts (matttbe)
  • Date: 2010-08-10 00:05:57 UTC
  • mfrom: (1.1.5 upstream)
  • Revision ID: james.westby@ubuntu.com-20100810000557-pfxoz5w7hbyclcqh
Tags: 2.2.0~0beta4-0ubuntu1
https://launchpad.net/bugs/614625
https://launchpad.net/bugs/483963
https://launchpad.net/bugs/485159
https://launchpad.net/bugs/500677
https://launchpad.net/bugs/500979
https://launchpad.net/bugs/521531
https://launchpad.net/bugs/519915
https://launchpad.net/bugs/526138
https://launchpad.net/bugs/531317
https://launchpad.net/bugs/531319
https://launchpad.net/bugs/537115
https://launchpad.net/bugs/537943
https://launchpad.net/bugs/538637
* New Upstream Version (LP: #614625)
* Fixed a few bugs on LP:
 - LP: #483963: Dustbin applet does not display trashes on all volumes
 - LP: #485159: Some apps have problem with Systray
 - LP: #500677: ~/.xsession-errors is too much used by CD
 - LP: #500979: Shortcuts: the order gets messed up
 - LP: #521531: Mail: crashes on Maildir
 - LP: #519915: GTG: create a new applet to control GTG
 - LP: #526138: GMenu doesn't handle desktop file exec strings properly
 - LP: #531317: CMake: Added an error if the prefix of 'cairo-dock-plugins'
                 is not the same 'cairo-dock-core'
 - LP: #531319: CMake: check the version of 'cairo-dock' when building
                 'cairo-dock-plugins'
 - LP: #537115: Click at the position where icon lavel was, the icon
                 and dock still receive the event
 - LP: #537943: Terminal applet shortkey behaviour
 - LP: #538637: Trash applet doesn't create .trashinfo files on XFCE
 - More details on the 'ChangeLog' file
* debian/rules:
 - Autotools has been replaced by CMake
 - cdbs is now used.
* debian/copyright:
 - Updated with the new applets
* debian/control:
 - Autotools has been replaced by CMake
 - Added libcurl4-gnutls-dev, libindicator-dev, libdbusmenu-glib-dev
   libido-0.1-dev, libical-dev, libdbusmenu-gtk-dev as Build-deps
 - Bump Standard-Version to 3.9.1
 - Wget is required for dnd2share applet
 - Added the exact realease for 'cairo-dock-dev' in order to prevent any
    build error if this package is not already available (thx to didrocks)
* debian/cairo-dock-plug-ins*.install:
 - All sonames are now installed into lib32 or lib64 (lib*)

Show diffs side-by-side

added added

removed removed

Lines of Context:
dock-rendering/src/rendering-diapo.c
 
1
/**
 
2
* This file is a part of the Cairo-Dock project
 
3
*
 
4
* Copyright : (C) see the 'copyright' file.
 
5
* E-mail    : see the 'copyright' file.
 
6
*
 
7
* This program is free software; you can redistribute it and/or
 
8
* modify it under the terms of the GNU General Public License
 
9
* as published by the Free Software Foundation; either version 3
 
10
* of the License, or (at your option) any later version.
 
11
*
 
12
* This program is distributed in the hope that it will be useful,
 
13
* but WITHOUT ANY WARRANTY; without even the implied warranty of
 
14
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 
15
* GNU General Public License for more details.
 
16
* You should have received a copy of the GNU General Public License
 
17
* along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
18
*/
 
19
 
 
20
#include <math.h>
 
21
#include <string.h>
 
22
#include <stdio.h>
 
23
#include <stdlib.h>
 
24
 
 
25
#include <gtk/gtk.h>
 
26
 
 
27
#include <cairo.h>
 
28
 
 
29
#ifdef HAVE_GLITZ
 
30
#include <gdk/gdkx.h>
 
31
#include <glitz-glx.h>
 
32
#include <cairo-glitz.h>
 
33
#endif
 
34
 
 
35
#include "rendering-diapo.h"
 
36
 
 
37
extern gint     my_diapo_iconGapX;
 
38
extern gint     my_diapo_iconGapY;
 
39
extern gdouble  my_diapo_fScaleMax;
 
40
extern gint     my_diapo_sinW;
 
41
extern gboolean my_diapo_lineaire;
 
42
extern gboolean  my_diapo_wide_grid;
 
43
extern gboolean  my_diapo_text_only_on_pointed;
 
44
 
 
45
extern gdouble  my_diapo_color_frame_start[4];
 
46
extern gdouble  my_diapo_color_frame_stop[4];
 
47
extern gboolean my_diapo_fade2bottom;
 
48
extern gboolean my_diapo_fade2right;
 
49
extern guint    my_diapo_arrowWidth;
 
50
extern guint    my_diapo_arrowHeight;
 
51
extern gdouble  my_diapo_arrowShift;
 
52
extern guint    my_diapo_lineWidth;
 
53
extern guint    my_diapo_radius;
 
54
extern gdouble  my_diapo_color_border_line[4];
 
55
extern gboolean my_diapo_draw_background;
 
56
extern gboolean my_diapo_display_all_icons;
 
57
 
 
58
const  gint X_CONST_BORDER_SPACE = 40;
 
59
const  gint Y_CONST_BORDER_SPACE = 40;
 
60
const  gint  MaxTextWidth = 125; 
 
61
 
 
62
void cd_rendering_calculate_max_dock_size_diapo (CairoDock *pDock)
 
63
{
 
64
        guint nRowsX = 0;
 
65
        guint nRowsY = 0;
 
66
        guint nIcones = 0;
 
67
        
 
68
        
 
69
//////////////////////////////////////////////////////////////////////////////////////// On calcule la configuration de la grille :
 
70
        nIcones = cairo_dock_rendering_diapo_guess_grid(pDock->icons, &nRowsX, &nRowsY);   
 
71
        
 
72
        
 
73
        //////////////////////////////////////////////////////////////////////////////////////// On définit les tailles :
 
74
        if(nIcones != 0)
 
75
        {
 
76
                cairo_dock_calculate_icons_positions_at_rest_diapo (pDock->icons, &(pDock->iMinDockWidth), &(pDock->iMinDockHeight), nRowsX);
 
77
                pDock->iMinDockWidth  += X_CONST_BORDER_SPACE * 2;
 
78
                pDock->iMinDockHeight += Y_CONST_BORDER_SPACE * 3 + my_diapo_arrowHeight-60;    // 60 -> pour que la fleche aille plus bas
 
79
                cairo_dock_rendering_diapo_calculate_max_dock_size (pDock->icons, pDock->iMinDockWidth, pDock->iMinDockHeight, &(pDock->iMaxDockWidth), &(pDock->iMaxDockHeight), nRowsX, nRowsY);
 
80
                pDock->iMaxDockWidth  += X_CONST_BORDER_SPACE * 2;
 
81
                pDock->iMaxDockHeight += Y_CONST_BORDER_SPACE * 3 + my_diapo_arrowHeight-60;    // 60 -> pour que la fleche aille plus bas
 
82
                pDock->iMinDockWidth  = pDock->iMaxDockWidth;
 
83
                pDock->iMinDockHeight = pDock->iMaxDockHeight;
 
84
        }
 
85
        else
 
86
        {
 
87
                pDock->iMaxDockWidth = pDock->iMaxDockHeight = pDock->iMinDockWidth = pDock->iMinDockHeight = 0;
 
88
        }
 
89
 
 
90
        
 
91
//////////////////////////////////////////////////////////////////////////////////////// Définition de la zone de déco - 0 pour l'instant
 
92
        pDock->iDecorationsHeight = 0;
 
93
        pDock->iDecorationsWidth  = 0;
 
94
        
 
95
        
 
96
//////////////////////////////////////////////////////////////////////////////////////// On affecte ca aussi au cas où
 
97
        pDock->fFlatDockWidth = pDock->iMinDockWidth;
 
98
}
 
99
 
 
100
 
 
101
void cd_rendering_render_diapo (cairo_t *pCairoContext, CairoDock *pDock)
 
102
{
 
103
        if(my_diapo_draw_background)
 
104
        {
 
105
                //\____________________ On trace le cadre.
 
106
                cairo_save (pCairoContext);
 
107
                cairo_dock_draw_frame_for_diapo (pCairoContext, pDock);
 
108
 
 
109
                //\____________________ On dessine les decorations dedans.
 
110
                cairo_dock_render_decorations_in_frame_for_diapo (pCairoContext, pDock);
 
111
        
 
112
                //\____________________ On dessine le cadre.
 
113
                if (my_diapo_lineWidth > 0)
 
114
                {
 
115
                        cairo_set_line_width (pCairoContext,  my_diapo_lineWidth);
 
116
                                cairo_set_source_rgba (pCairoContext,
 
117
                                        my_diapo_color_border_line[0],
 
118
                                        my_diapo_color_border_line[1],
 
119
                                        my_diapo_color_border_line[2],
 
120
                                        my_diapo_color_border_line[3] * (1. - 0*pDock->fFoldingFactor));
 
121
                        cairo_stroke (pCairoContext);
 
122
                }
 
123
                cairo_restore (pCairoContext);
 
124
        }
 
125
        
 
126
        //\____________________ On dessine la ficelle qui les joint.
 
127
        //TODO Rendre joli !
 
128
        if (myIcons.iStringLineWidth > 0)
 
129
                cairo_dock_draw_string (pCairoContext, pDock, myIcons.iStringLineWidth, FALSE, FALSE);
 
130
        //\____________________ On dessine les icones avec leurs etiquettes.
 
131
        
 
132
        
 
133
//////////////////////////////////////////////////////////////////////////////////////// Si y'en a pas on se barre (dock vide)
 
134
        //if (pFirstDrawnElement == NULL) return;
 
135
        if (pDock->icons == NULL) return;
 
136
        
 
137
 
 
138
//////////////////////////////////////////////////////////////////////////////////////// On parcourt la liste les icones :
 
139
        Icon *icon;
 
140
        GList *ic;
 
141
        for (ic = pDock->icons; ic != NULL; ic = ic->next)
 
142
        {
 
143
        
 
144
//////////////////////////////////////////////////////////////////////////////////////// On recupere la structure d'infos
 
145
                icon = ic->data;
 
146
 
 
147
 
 
148
//////////////////////////////////////////////////////////////////////////////////////// On sauvegarde le contexte de cairo
 
149
                cairo_save (pCairoContext);
 
150
                
 
151
 
 
152
//////////////////////////////////////////////////////////////////////////////////////// On affiche l'icone en cours avec les options :         
 
153
                cairo_dock_render_one_icon (icon, pDock, pCairoContext, 0., FALSE);
 
154
 
 
155
 
 
156
//////////////////////////////////////////////////////////////////////////////////////// On restore le contexte de cairo
 
157
                cairo_restore (pCairoContext);
 
158
                
 
159
                gdouble zoom;
 
160
//////////////////////////////////////////////////////////////////////////////////////// On affiche le texte !
 
161
               if(icon->pTextBuffer != NULL)
 
162
                {
 
163
                        cairo_save (pCairoContext);
 
164
                        zoom = 1;
 
165
                        if(2*icon->fTextXOffset > MaxTextWidth)
 
166
                        {
 
167
                                zoom  = MaxTextWidth / (2*icon->fTextXOffset);
 
168
                                cairo_scale(pCairoContext, zoom, zoom); 
 
169
                        }
 
170
                        if (pDock->container.bIsHorizontal)
 
171
                        {
 
172
                                cairo_set_source_surface (pCairoContext,
 
173
                                        icon->pTextBuffer,                                        
 
174
                                        (icon->fDrawX + (icon->fWidth * icon->fScale)/2)/zoom - icon->fTextXOffset,
 
175
                                        (icon->fDrawY +  (icon->fHeight * icon->fScale)   + (my_diapo_iconGapY / 2)  - 6 )/zoom); // 6 ~= hauteur texte / 2
 
176
                        }
 
177
                        else
 
178
                        {
 
179
                                cairo_set_source_surface (pCairoContext,
 
180
                                        icon->pTextBuffer,  
 
181
                                        (icon->fDrawY + (icon->fWidth * icon->fScale)/2)/zoom - icon->fTextXOffset,
 
182
                                        (icon->fDrawX +  (icon->fHeight * icon->fScale)   + (my_diapo_iconGapY / 2)  - 6)/zoom); // 6 ~= hauteur texte / 2
 
183
 
 
184
                        }
 
185
                        if ((my_diapo_text_only_on_pointed && icon->bPointed) || my_diapo_display_all_icons)
 
186
                                cairo_paint (pCairoContext);
 
187
                        else if (!my_diapo_text_only_on_pointed)
 
188
                                cairo_paint_with_alpha (pCairoContext, 1. + (icon->fScale - my_diapo_fScaleMax)/(my_diapo_fScaleMax - 1));
 
189
                        
 
190
                        cairo_restore (pCairoContext);
 
191
                }
 
192
        }
 
193
}
 
194
 
 
195
static void _cd_rendering_check_if_mouse_inside_diapo (CairoDock *pDock)
 
196
{
 
197
        if (! pDock->container.bInside)
 
198
        {
 
199
                pDock->iMousePositionType = CAIRO_DOCK_MOUSE_OUTSIDE;
 
200
        }
 
201
        else if ((pDock->container.iMouseX < my_diapo_iconGapX) || (pDock->container.iMouseX > pDock->iMaxDockWidth - my_diapo_iconGapX) || (pDock->container.iMouseY < my_diapo_iconGapY) || (pDock->container.iMouseY > pDock->iMaxDockHeight - my_diapo_iconGapY))
 
202
        {
 
203
                pDock->iMousePositionType = CAIRO_DOCK_MOUSE_ON_THE_EDGE;
 
204
        }
 
205
        else
 
206
        {
 
207
                pDock->iMousePositionType = CAIRO_DOCK_MOUSE_INSIDE;
 
208
        }
 
209
}
 
210
Icon *cd_rendering_calculate_icons_diapo (CairoDock *pDock)
 
211
{
 
212
        guint nRowsX = 0;
 
213
        guint nRowsY = 0;
 
214
        guint nIcones = 0;
 
215
        gint posMouseAbsX = 0;
 
216
        gint posMouseAbsY = 0;        
 
217
 
 
218
 
 
219
//////////////////////////////////////////////////////////////////////////////////////// On calcule la configuration de la grille :
 
220
        nIcones = cairo_dock_rendering_diapo_guess_grid(pDock->icons, &nRowsX, &nRowsY);      
 
221
        
 
222
        
 
223
        //\_______________ On calcule la position du curseur.
 
224
        posMouseAbsX = pDock->container.iMouseX; 
 
225
        posMouseAbsY = pDock->container.iMouseY;
 
226
 
 
227
 
 
228
//////////////////////////////////////////////////////////////////////////////////////// On calcule les tailles des icones en fonction de la souris
 
229
        cairo_dock_calculate_wave_with_position_diapo(pDock->icons, posMouseAbsX, posMouseAbsY, nRowsX);
 
230
 
 
231
 
 
232
//////////////////////////////////////////////////////////////////////////////////////// On calcule les positions des icones
 
233
        Icon *pPointedIcon = cairo_dock_calculate_icons_position_for_diapo(pDock, nRowsX, nRowsY, posMouseAbsX, posMouseAbsY);
 
234
 
 
235
        _cd_rendering_check_if_mouse_inside_diapo (pDock);
 
236
        
 
237
        
 
238
        /// caluler bCanDrop ...
 
239
        
 
240
//////////////////////////////////////////////////////////////////////////////////////// On revoie l'icone pointee et NULL sinon
 
241
        return pPointedIcon;
 
242
}
 
243
 
 
244
 
 
245
void cd_rendering_register_diapo_renderer (const gchar *cRendererName)
 
246
{
 
247
//////////////////////////////////////////////////////////////////////////////////////// On definit le renderer :
 
248
        CairoDockRenderer *pRenderer = g_new0 (CairoDockRenderer, 1);                                           //Nouvelle structure    
 
249
        pRenderer->cReadmeFilePath = g_strdup_printf ("%s/readme-diapo-view", MY_APPLET_SHARE_DATA_DIR);        //On affecte le readme
 
250
        pRenderer->cPreviewFilePath = g_strdup_printf ("%s/preview-diapo.jpg", MY_APPLET_SHARE_DATA_DIR);       // la preview
 
251
        pRenderer->compute_size = cd_rendering_calculate_max_dock_size_diapo;                        //La fonction qui défini les bornes     
 
252
        pRenderer->calculate_icons = cd_rendering_calculate_icons_diapo;                                        //qui calcule les param des icones      
 
253
        pRenderer->render = cd_rendering_render_diapo;                                                          //qui initie le calcul du rendu         
 
254
        pRenderer->render_optimized = NULL;                                                                     //pareil en mieux                       
 
255
        pRenderer->set_subdock_position = cairo_dock_set_subdock_position_linear;                               // ?                                    
 
256
        
 
257
        pRenderer->bUseReflect = FALSE;                                                                         // On dit non au reflections
 
258
        
 
259
        cairo_dock_register_renderer (cRendererName, pRenderer);                                    //Puis on signale l'existence de notre rendu
 
260
 
 
261
}
 
262
 
 
263
guint cairo_dock_rendering_diapo_guess_grid(GList *pIconList, guint *nRowX, guint *nRowY)
 
264
{
 
265
//////////////////////////////////////////////////////////////////////////////////////// Calcul du nombre de ligne / colonne :
 
266
        guint count = g_list_length(pIconList);
 
267
        if(my_diapo_wide_grid)
 
268
        {
 
269
                *nRowX = count  ? ceil(sqrt(count)) : 0;
 
270
                *nRowY = count  ? ceil(((double) count) / *nRowX) : 0;
 
271
        }
 
272
        else
 
273
        {
 
274
                *nRowY = count  ? ceil(sqrt(count)) : 0;
 
275
                *nRowX = count  ? ceil(((double) count) / *nRowY) : 0;
 
276
        }
 
277
        return count;
 
278
}
 
279
 
 
280
Icon* cairo_dock_calculate_icons_position_for_diapo(CairoDock *pDock, guint nRowsX, guint nRowsY, gint Mx, gint My)
 
281
{
 
282
//////////////////////////////////////////////////////////////////////////////////////// On calcule la position de base pour toutes les icones :
 
283
        guint i = 0;
 
284
        guint x = 0;
 
285
        guint y = 0;
 
286
        gdouble iconeX = 0.;
 
287
        gdouble iconeY = 0.;
 
288
        guint maxWidth [nRowsX];
 
289
        guint maxHeight[nRowsY];
 
290
        guint curDockWidth  = 0;
 
291
        guint curDockHeight = 0;
 
292
        guint offsetX = 0;
 
293
        guint offsetY = 0;
 
294
        cairo_dock_rendering_diapo_calculate_max_icon_size(pDock->icons, (guint*) &maxWidth, (guint*)  &maxHeight, nRowsX, nRowsY);
 
295
        GList *pointed_ic = NULL;
 
296
//////////////////////////////////////////////////////////////////////////////////////// On crée une liste d'icone des icones à parcourir :
 
297
        GList* ic;
 
298
        Icon* icon;
 
299
        i = 0;
 
300
        for (ic = pDock->icons; ic != NULL; ic = ic->next)
 
301
        {
 
302
                
 
303
//////////////////////////////////////////////////////////////////////////////////////// On recupere la structure d'infos
 
304
                icon = ic->data;
 
305
                cairo_dock_rendering_diapo_get_gridXY_from_index(nRowsX, i, &x, &y);
 
306
                
 
307
                
 
308
//////////////////////////////////////////////////////////////////////////////////////// On affecte les parametres de dessin  :                
 
309
                
 
310
//////////////////////////////////////////////////////////////////////////////////////// On va PAS se servir des fX fY comme d'index de la grille ailleurs qu'ici CAR le fY est changé dans des fonctions de drawing qui devrait pas ! -> je pense que c'est corrige.
 
311
                icon->fX = iconeX;
 
312
                icon->fY = iconeY;      
 
313
 
 
314
 
 
315
//////////////////////////////////////////////////////////////////////////////////////// On passe au réferentiel de l'image :
 
316
                icon->fXMin = icon->fXMax = icon->fXAtRest = //Ca on s'en sert pas encore
 
317
                icon->fDrawX = iconeX + my_diapo_iconGapX + maxWidth [x] / 2  - (icon->fWidth  * icon->fScale) / 2;
 
318
                icon->fDrawY = iconeY + my_diapo_iconGapY + maxHeight[y] / 2  - (icon->fHeight * icon->fScale) / 2;
 
319
                        icon->fDrawX -= (icon->fDrawX - pDock->container.iWidth/2) * pDock->fFoldingFactor;
 
320
                        icon->fDrawY *= pDock->fFoldingFactor;
 
321
 
 
322
 
 
323
//////////////////////////////////////////////////////////////////////////////////////// On prépare pour la suivante :
 
324
                i++;
 
325
                if(!(i % nRowsX)) //  si on est à la fin d'une ligne on change
 
326
                {
 
327
                        curDockWidth = iconeX + maxWidth[x] + 2 * my_diapo_iconGapX;
 
328
                        iconeX  = 0.;
 
329
                        iconeY += maxHeight[y] + 2 * my_diapo_iconGapY;
 
330
                }
 
331
                else // sinon on bouge juste X
 
332
                {
 
333
                        iconeX  += maxWidth[x] + 2 * my_diapo_iconGapX;
 
334
                }
 
335
                       
 
336
                        
 
337
//////////////////////////////////////////////////////////////////////////////////////// On affecte tous les parametres qui n'ont pas été défini précédement
 
338
                icon->fPhase = 0.;
 
339
                icon->fOrientation = 0.;//2. * G_PI * pDock->fFoldingFactor;                // rotation de l'icone
 
340
            if (FALSE)
 
341
                                icon->fWidthFactor = icon->fHeightFactor = 1. - pDock->fFoldingFactor;
 
342
        }
 
343
        if(iconeX != 0.)//cas de la rangé non terminée
 
344
        {
 
345
                iconeY += maxHeight[y] + 2 * my_diapo_iconGapY;
 
346
        }
 
347
        curDockHeight = iconeY;
 
348
 
 
349
        i=0;
 
350
//////////////////////////////////////////////////////////////////////////////////////// On calcule l'offset pour que ce soit centré :
 
351
        offsetX = (pDock->iMaxDockWidth  - curDockWidth ) / 2;
 
352
        offsetY = (pDock->iMaxDockHeight - curDockHeight) / 2;      
 
353
        pDock->container.iWidth  = curDockWidth;
 
354
        pDock->container.iHeight = curDockHeight;
 
355
        pDock->iDecorationsWidth = offsetX;   // Alors désolé mais ca c'est de la grosse feinte : on utilise les tailles de decoration inutilisés
 
356
        pDock->iDecorationsHeight = offsetY;  //  pour passer les offsets aux fonctions de dessin ... c'est sale mais ca marche !  
 
357
        for (ic = pDock->icons; ic != NULL; ic = ic->next)
 
358
        {
 
359
        
 
360
                cairo_dock_rendering_diapo_get_gridXY_from_index(nRowsX, i++, &x, &y);
 
361
//////////////////////////////////////////////////////////////////////////////////////// On recupere la structure d'infos
 
362
                icon = ic->data;
 
363
                icon->fDrawX += offsetX;
 
364
                icon->fDrawY += offsetY;
 
365
 
 
366
                ////////////////////////////////////////////////////////////////////////////////////////On va check de la mouse là :
 
367
                if((Mx > icon->fDrawX - my_diapo_iconGapX) && 
 
368
                   (My > icon->fDrawY - my_diapo_iconGapY) &&
 
369
                   (Mx < icon->fDrawX + maxWidth[x]  + my_diapo_iconGapX) &&
 
370
                   (My < icon->fDrawY + maxHeight[y] +  my_diapo_iconGapY))
 
371
                {        
 
372
                        icon->bPointed = TRUE;    
 
373
                        pointed_ic = ic;
 
374
                        icon->fAlpha = 1.;                           
 
375
                }
 
376
                else
 
377
                {
 
378
                        icon->bPointed = FALSE; 
 
379
                        icon->fAlpha = 0.9;
 
380
                }
 
381
        }
 
382
        return pointed_ic == NULL ? NULL : pointed_ic->data;
 
383
}
 
384
 
 
385
 
 
386
 
 
387
void cairo_dock_calculate_wave_with_position_diapo(GList *pIconList, gint Mx, gint My, guint nRowsX)
 
388
{
 
389
        guint i = 0;
 
390
        guint x = 0;
 
391
        guint y = 0;
 
392
        if (pIconList == NULL) 
 
393
        {
 
394
                cd_debug("Rendering>Diapo -> pIconList == NULL Totaly uncool \n Returning badly...");
 
395
                return;
 
396
        }
 
397
        if(( (Icon*) pIconList->data ) == NULL)
 
398
        {
 
399
                cd_debug("Rendering>Diapo -> (Icon*) pIconList->data == NULL Totaly uncool \n Returning badly...");
 
400
                return;
 
401
        }
 
402
           
 
403
        GList* ic;
 
404
        Icon *icon;
 
405
        for (ic = pIconList; ic != NULL; ic = ic->next)
 
406
        {
 
407
                icon = ic->data;
 
408
                cairo_dock_rendering_diapo_get_gridXY_from_index(nRowsX, i, &x, &y);
 
409
                guint x1 = Mx;
 
410
                gdouble x2 = icon->fDrawX + (icon->fWidth)  / 2 + (my_diapo_fScaleMax - 1) * 20; // formule empirique de chez empirique pour corriger le décalage incalculable... (si vous y arrivez envoyez moi un mail -> mapremierpartiedepseudo.ladeuxieme@gmail.com et je vous appellerais Dieu... merci ! Ateention ! Pas d'entourre les poules hein !)  // fDrawXAtRest
 
411
                guint y1 = My;
 
412
                gdouble y2 = icon->fDrawY + (icon->fHeight) / 2 + (my_diapo_fScaleMax - 1) * 20; // idem  // fDrawYAtRest
 
413
 
 
414
                gdouble distanceE = sqrt( (x1-x2)*(x1-x2) + (y1-y2)*(y1-y2));
 
415
                if(my_diapo_lineaire)
 
416
                {
 
417
                        gdouble eloignementMax = 3. * (icon->fWidth + icon->fHeight)  / 2; 
 
418
                        if(distanceE > eloignementMax)
 
419
                        {
 
420
                                icon->fScale = 1.;
 
421
                        }
 
422
                        else
 
423
                        {
 
424
                                icon->fScale = - (1./eloignementMax) * distanceE + my_diapo_fScaleMax;
 
425
                        }
 
426
                }
 
427
                else
 
428
                {
 
429
                        icon->fPhase = distanceE * G_PI / my_diapo_sinW + G_PI / 2.;
 
430
                        if (icon->fPhase < 0)
 
431
                        {
 
432
                                icon->fPhase = 0;
 
433
                        }
 
434
                        else if (icon->fPhase > G_PI)
 
435
                        {
 
436
                                icon->fPhase = G_PI;
 
437
                        }
 
438
                        icon->fScale = 1. + (my_diapo_fScaleMax-1.) * sin (icon->fPhase);                
 
439
                }
 
440
                i++;
 
441
        }
 
442
}
 
443
 
 
444
        
 
445
//////////////////////////////////////////////////////////////////////////////////////// Fonction calculant la taille maximale du dock 
 
446
void cairo_dock_calculate_icons_positions_at_rest_diapo (GList *pIconList, gint* Wmin, gint* Hmin, guint nRowsX)
 
447
{
 
448
    gdouble iconeX = 0;
 
449
    gdouble iconeY = 0;
 
450
    guint i = 0;
 
451
        GList* ic;
 
452
        Icon *icon;
 
453
        for (ic = pIconList; ic != NULL; ic = ic->next)
 
454
        {
 
455
                icon = ic->data;
 
456
                icon->fDrawX = iconeX;  // fDrawXAtRest
 
457
                icon->fDrawY = iconeY;  // fDrawYAtRest
 
458
                if(!(i % nRowsX)) //  si on est à la fin d'une ligne on change
 
459
                {
 
460
                        *Wmin = iconeX + icon->fWidth + 2 * my_diapo_iconGapX;
 
461
                        iconeX  = 0.;
 
462
                        iconeY += icon->fHeight + 2 * my_diapo_iconGapY;
 
463
                }
 
464
                else // sinon on bouge juste X
 
465
                {
 
466
                        iconeX  += icon->fWidth + 2 * my_diapo_iconGapX;
 
467
                }
 
468
                i++;
 
469
        }
 
470
    if(iconeX != 0.)//cas de la rangée non terminée
 
471
    {
 
472
           iconeY += icon->fHeight + 2 * my_diapo_iconGapY;
 
473
    }
 
474
    *Hmin = iconeY;
 
475
}
 
476
 
 
477
//////////////////////////////////////////////////////////////////////////////////////// Fonction calculant sur chaque colonne et sur chaque ligne la taille d'icone maximale
 
478
void cairo_dock_rendering_diapo_calculate_max_icon_size(GList *pIconList, gint* maxWidth, gint* maxHeight, guint nRowsX, guint nRowsY)
 
479
{
 
480
    guint i = 0;
 
481
    guint x = 0;
 
482
    guint y = 0;
 
483
    for(i = 0 ;  i < nRowsX ; i++) maxWidth [i] = 0;
 
484
    for(i = 0 ;  i < nRowsY ; i++) maxHeight[i] = 0;
 
485
        
 
486
        
 
487
//////////////////////////////////////////////////////////////////////////////////////// On crée une liste d'icone des icones à parcourir :
 
488
        GList* ic;
 
489
        Icon* icon;
 
490
        i = 0;
 
491
        for (ic = pIconList; ic != NULL; ic = ic->next)
 
492
        {
 
493
        
 
494
        
 
495
//////////////////////////////////////////////////////////////////////////////////////// On recupere la structure d'infos
 
496
                icon = ic->data;   
 
497
                cairo_dock_rendering_diapo_get_gridXY_from_index(nRowsX, i, &x, &y);
 
498
                guint W = icon->fWidth  * icon->fScale;
 
499
                guint H = icon->fHeight * icon->fScale;
 
500
                if(W > maxWidth[x])
 
501
                {
 
502
                        maxWidth[x] = W;
 
503
                }
 
504
                if(H > maxHeight[y])
 
505
                {
 
506
                        maxHeight[y] = H;
 
507
                }
 
508
                i++;
 
509
    }    
 
510
}         
 
511
         
 
512
//////////////////////////////////////////////////////////////////////////////////////// Fonction calculant la taille maximale du dock en placant une fausse souris au milieu de la vue
 
513
void cairo_dock_rendering_diapo_calculate_max_dock_size (GList *pIconList, gint Wmin, gint Hmin, gint* Wmax, gint* Hmax, guint nRowsX, guint nRowsY)
 
514
{
 
515
        *Hmax = *Wmax = 0;
 
516
        if (pIconList == NULL)
 
517
                return ;
 
518
        gint maxWidth [nRowsX];
 
519
        gint maxHeight[nRowsY];
 
520
        guint i = 0;       
 
521
        
 
522
        cairo_dock_calculate_wave_with_position_diapo(pIconList, (Wmin / 2) + X_CONST_BORDER_SPACE, (Hmin / 2) + Y_CONST_BORDER_SPACE, nRowsX); 
 
523
        
 
524
        cairo_dock_rendering_diapo_calculate_max_icon_size(pIconList, (guint*)  &maxWidth, (guint*)  &maxHeight, nRowsX, nRowsY);
 
525
        
 
526
        
 
527
        for(i = 0 ;  i < nRowsX ; i++) *Wmax += maxWidth [i] + 2 * my_diapo_iconGapX;
 
528
        for(i = 0 ;  i < nRowsY ; i++) *Hmax += maxHeight[i] + 2 * my_diapo_iconGapY;
 
529
        *Wmax += + 2*X_CONST_BORDER_SPACE;
 
530
        *Hmax += + 2*Y_CONST_BORDER_SPACE;
 
531
}
 
532
 
 
533
//////////////////////////////////////////////////////////////////////////////////////// Fonctions utiles pour transformer l'index de la liste en couple (x,y) sur la grille
 
534
void cairo_dock_rendering_diapo_get_gridXY_from_index(guint nRowsX, guint index, guint* gridX, guint* gridY)
 
535
{
 
536
        *gridX = index % nRowsX;
 
537
        *gridY = (index - *gridX) / nRowsX;
 
538
}
 
539
 
 
540
 
 
541
//////////////////////////////////////////////////////////////////////////////////////// Et inversement (proportionnel)
 
542
guint cairo_dock_rendering_diapo_get_index_from_gridXY(guint nRowsX, guint gridX, guint gridY)
 
543
{
 
544
        return gridX + gridY * nRowsX;
 
545
}
 
546
 
 
547
 
 
548
//////////////////////////////////////////////////////////////////////////////////////// Methodes de dessin :
 
549
 
 
550
 
 
551
static void cairo_dock_draw_frame_horizontal_for_diapo (cairo_t *pCairoContext, CairoDock *pDock)
 
552
{
 
553
        const gdouble arrow_dec = 2;
 
554
        gint fFrameWidth  = pDock->container.iWidth;
 
555
        gint fFrameHeight = pDock->container.iHeight - my_diapo_arrowHeight + 60; //  60->pour que la fleche aille plus bas...
 
556
        gdouble fDockOffsetX = pDock->iDecorationsWidth;
 
557
        gdouble fDockOffsetY = pDock->iDecorationsHeight;
 
558
 
 
559
        cairo_move_to (pCairoContext, fDockOffsetX, fDockOffsetY);
 
560
 
 
561
 
 
562
        //HautGauche -> HautDroit
 
563
        if(pDock->container.bDirectionUp)
 
564
        {
 
565
                cairo_rel_line_to (pCairoContext, fFrameWidth, 0);
 
566
        }
 
567
        else
 
568
        {
 
569
               //On fait la fleche
 
570
                cairo_rel_line_to (pCairoContext,  (fFrameWidth/2 - my_diapo_arrowWidth/2 - my_diapo_arrowShift * fFrameWidth), 0);                //     _
 
571
                cairo_rel_line_to (pCairoContext, + my_diapo_arrowWidth/2 + my_diapo_arrowShift * fFrameWidth - my_diapo_arrowShift * fFrameWidth / arrow_dec,  -my_diapo_arrowHeight);       //  \. 
 
572
                cairo_rel_line_to (pCairoContext, + my_diapo_arrowWidth/2 - my_diapo_arrowShift * fFrameWidth + my_diapo_arrowShift * fFrameWidth / arrow_dec, +my_diapo_arrowHeight);        //    /     
 
573
                cairo_rel_line_to (pCairoContext, (fFrameWidth/2 - my_diapo_arrowWidth/2 + my_diapo_arrowShift * fFrameWidth) , 0);               // _     
 
574
        }
 
575
        //\_________________ Coin haut droit.
 
576
        cairo_rel_curve_to (pCairoContext,
 
577
                0, 0,
 
578
                my_diapo_radius, 0,
 
579
                my_diapo_radius, my_diapo_radius );
 
580
 
 
581
 
 
582
        //HautDroit -> BasDroit
 
583
        cairo_rel_line_to (pCairoContext, 0, fFrameHeight + my_diapo_lineWidth - my_diapo_radius *  2 );
 
584
        //\_________________ Coin bas droit.
 
585
         cairo_rel_curve_to (pCairoContext,
 
586
                        0, 0,
 
587
                        0 , my_diapo_radius,
 
588
                        -my_diapo_radius , my_diapo_radius);
 
589
 
 
590
 
 
591
        //BasDroit -> BasGauche
 
592
        if(!pDock->container.bDirectionUp)
 
593
        {
 
594
                cairo_rel_line_to (pCairoContext, - fFrameWidth , 0);
 
595
        }
 
596
        else
 
597
        {
 
598
                //On fait la fleche
 
599
                cairo_rel_line_to (pCairoContext, - (fFrameWidth/2 - my_diapo_arrowWidth/2 - my_diapo_arrowShift * fFrameWidth), 0);                //     _
 
600
                cairo_rel_line_to (pCairoContext, - my_diapo_arrowWidth/2 - my_diapo_arrowShift * fFrameWidth + my_diapo_arrowShift * fFrameWidth / arrow_dec, my_diapo_arrowHeight);        //    /     
 
601
                cairo_rel_line_to (pCairoContext, - my_diapo_arrowWidth/2 + my_diapo_arrowShift * fFrameWidth - my_diapo_arrowShift * fFrameWidth / arrow_dec, -my_diapo_arrowHeight);       //  \. 
 
602
                cairo_rel_line_to (pCairoContext, - (fFrameWidth/2 - my_diapo_arrowWidth/2 + my_diapo_arrowShift * fFrameWidth) , 0);               // _      
 
603
        }
 
604
        //\_________________ Coin bas gauche.
 
605
        cairo_rel_curve_to (pCairoContext,
 
606
                        0, 0,
 
607
                        -my_diapo_radius, 0,
 
608
                        -my_diapo_radius, -my_diapo_radius );
 
609
                        
 
610
                        
 
611
        //BasGauche -> HautGauche
 
612
        cairo_rel_line_to (pCairoContext, 0, - fFrameHeight - my_diapo_lineWidth + my_diapo_radius * 2);
 
613
        //\_________________ Coin haut gauche.
 
614
        cairo_rel_curve_to (pCairoContext,
 
615
                0, 0,
 
616
                0 , -my_diapo_radius ,
 
617
                my_diapo_radius, -my_diapo_radius );
 
618
 
 
619
}
 
620
 
 
621
 
 
622
static void cairo_dock_draw_frame_vertical_for_diapo (cairo_t *pCairoContext, CairoDock *pDock)
 
623
{
 
624
        const gdouble arrow_dec = 2;
 
625
        gint fFrameWidth  = pDock->container.iWidth;
 
626
        gint fFrameHeight = pDock->container.iHeight - my_diapo_arrowHeight + 60; //  60->pour que la fleche aille plus bas...
 
627
        gdouble fDockOffsetX = pDock->iDecorationsWidth;
 
628
        gdouble fDockOffsetY = pDock->iDecorationsHeight;
 
629
        
 
630
 
 
631
        cairo_move_to (pCairoContext, fDockOffsetY, fDockOffsetX);
 
632
 
 
633
        if(pDock->container.bDirectionUp)
 
634
        {
 
635
                cairo_rel_line_to (pCairoContext, 0, fFrameWidth);
 
636
        }
 
637
        else
 
638
        {
 
639
                cairo_rel_line_to (pCairoContext,0,(fFrameWidth/2 - my_diapo_arrowWidth/2 - my_diapo_arrowShift * fFrameWidth));                //     _
 
640
                cairo_rel_line_to (pCairoContext, -my_diapo_arrowHeight, my_diapo_arrowWidth/2 + my_diapo_arrowShift * fFrameWidth - my_diapo_arrowShift * fFrameWidth / arrow_dec);       //  \. 
 
641
                cairo_rel_line_to (pCairoContext, my_diapo_arrowHeight, + my_diapo_arrowWidth/2 - my_diapo_arrowShift * fFrameWidth + my_diapo_arrowShift * fFrameWidth / arrow_dec);        //    /     
 
642
                cairo_rel_line_to (pCairoContext,0,(fFrameWidth/2 - my_diapo_arrowWidth/2 + my_diapo_arrowShift * fFrameWidth));               // _     
 
643
       }
 
644
        //\_________________ Coin haut droit.
 
645
        cairo_rel_curve_to (pCairoContext,
 
646
                0, 0,
 
647
                0, my_diapo_radius,
 
648
                my_diapo_radius, my_diapo_radius);
 
649
        cairo_rel_line_to (pCairoContext, fFrameHeight + my_diapo_lineWidth - my_diapo_radius * 2, 0);
 
650
        //\_________________ Coin bas droit.
 
651
         cairo_rel_curve_to (pCairoContext,
 
652
                        0, 0,
 
653
                        my_diapo_radius, 0,
 
654
                        my_diapo_radius, -my_diapo_radius);
 
655
                        
 
656
        if(!pDock->container.bDirectionUp)
 
657
        {
 
658
                cairo_rel_line_to (pCairoContext, 0, - fFrameWidth);
 
659
        }
 
660
        else
 
661
        {
 
662
                //On fait la fleche
 
663
                cairo_rel_line_to (pCairoContext, 0, - (fFrameWidth/2 - my_diapo_arrowWidth/2 - my_diapo_arrowShift * fFrameWidth));                 //     _
 
664
                cairo_rel_line_to (pCairoContext,  my_diapo_arrowHeight, - my_diapo_arrowWidth/2 - my_diapo_arrowShift * fFrameWidth + my_diapo_arrowShift * fFrameWidth / arrow_dec);        //    /     
 
665
                cairo_rel_line_to (pCairoContext, -my_diapo_arrowHeight, - my_diapo_arrowWidth/2 + my_diapo_arrowShift * fFrameWidth - my_diapo_arrowShift * fFrameWidth / arrow_dec );       //  \. 
 
666
                cairo_rel_line_to (pCairoContext, 0, - (fFrameWidth/2 - my_diapo_arrowWidth/2 + my_diapo_arrowShift * fFrameWidth));                 // _      
 
667
        }
 
668
 
 
669
        //\_________________ Coin bas gauche.
 
670
         cairo_rel_curve_to (pCairoContext,
 
671
                        0, 0,
 
672
                        0, -my_diapo_radius,
 
673
                        -my_diapo_radius, -my_diapo_radius);
 
674
        cairo_rel_line_to (pCairoContext, - fFrameHeight - my_diapo_lineWidth + my_diapo_radius * 2, 0);
 
675
        //\_________________ Coin haut gauche.
 
676
        cairo_rel_curve_to (pCairoContext,
 
677
                0, 0,
 
678
                -my_diapo_radius, 0,
 
679
                -my_diapo_radius, my_diapo_radius);
 
680
}
 
681
 
 
682
 
 
683
 
 
684
 
 
685
void cairo_dock_draw_frame_for_diapo (cairo_t *pCairoContext, CairoDock *pDock)
 
686
{
 
687
        if (pDock->container.bIsHorizontal)
 
688
                cairo_dock_draw_frame_horizontal_for_diapo (pCairoContext, pDock);
 
689
        else
 
690
                cairo_dock_draw_frame_vertical_for_diapo (pCairoContext, pDock);
 
691
}
 
692
 
 
693
 
 
694
 
 
695
void cairo_dock_render_decorations_in_frame_for_diapo (cairo_t *pCairoContext, CairoDock *pDock)
 
696
{
 
697
////////////////////////////////////////////////////////////////////////////////////////On se fait un beau pattern dégradé :
 
698
 
 
699
        cairo_pattern_t *mon_super_pattern;
 
700
        mon_super_pattern = cairo_pattern_create_linear (0.0, 0.0,
 
701
                                                my_diapo_fade2right  ? pDock->iMaxDockWidth  : 0.0,      // Y'aurait surement des calculs complexes à faire mais 
 
702
                                                my_diapo_fade2bottom ? pDock->iMaxDockHeight : 0.0);     //  a quelques pixels près pour un dégradé : OSEF !
 
703
                                                
 
704
        cairo_pattern_add_color_stop_rgba (mon_super_pattern, 0,
 
705
                        my_diapo_color_frame_start[0],
 
706
                        my_diapo_color_frame_start[1],
 
707
                        my_diapo_color_frame_start[2],
 
708
                        my_diapo_color_frame_start[3] * (1. - 0*pDock->fFoldingFactor)); // de transparent a opaque au depliage
 
709
                                                
 
710
        cairo_pattern_add_color_stop_rgba (mon_super_pattern,1,
 
711
                        my_diapo_color_frame_stop[0],
 
712
                        my_diapo_color_frame_stop[1],
 
713
                        my_diapo_color_frame_stop[2] ,
 
714
                        my_diapo_color_frame_stop[3]  * (1. - 0*pDock->fFoldingFactor)); 
 
715
        cairo_set_source (pCairoContext, mon_super_pattern);
 
716
        
 
717
////////////////////////////////////////////////////////////////////////////////////////On remplit le contexte en le préservant pour pouvoir tracer le contour apres.
 
718
        cairo_fill_preserve (pCairoContext);  
 
719
        cairo_pattern_destroy (mon_super_pattern);    
 
720
}
 
721
 
 
722