Debian Codegraph @

slider/src/applet-transitions.c

raw
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 <stdlib.h>
21 #include <string.h>
22 #include <math.h>
23
24 #include "applet-transitions.h"
25
26 ///#define _cd_slider_erase_surface(myApplet) cairo_dock_erase_cairo_context (myDrawContext)
27
28 /**#define _cd_slider_add_background_to_slide(myApplet, fX, fY, alpha, slide) do { \
29 if (myConfig.pBackgroundColor[3] != 0) {\
30 cairo_set_source_rgba (myDrawContext, myConfig.pBackgroundColor[0], myConfig.pBackgroundColor[1], myConfig.pBackgroundColor[2], alpha * myConfig.pBackgroundColor[3]);\
31 cairo_rectangle (myDrawContext, fX, fY, slide.fImgW, slide.fImgH);\
32 cairo_fill (myDrawContext); } } while (0)
33 #define _cd_slider_add_background_to_slide_opengl(myApplet, fX, fY, alpha, slide) do { \
34 glColor4f (myConfig.pBackgroundColor[0], myConfig.pBackgroundColor[1], myConfig.pBackgroundColor[2], alpha * myConfig.pBackgroundColor[3]);\
35 glPolygonMode (GL_FRONT, GL_FILL);\
36 glEnable (GL_BLEND);\
37 glBlendFunc (GL_ONE, GL_ZERO);\
38 if (myConfig.pBackgroundColor[3] != 0) {\
39 glBegin(GL_QUADS);\
40 glVertex3f(fX - slide.fImgW/2, fY - slide.fImgH/2, 0.);\
41 glVertex3f(fX + slide.fImgW/2, fY - slide.fImgH/2, 0.);\
42 glVertex3f(fX + slide.fImgW/2, fY + slide.fImgH/2, 0.);\
43 glVertex3f(fX - slide.fImgW/2, fY + slide.fImgH/2, 0.);\
44 glEnd(); } } while (0)*/
45
46 static void _cd_slider_add_background_to_slide (GldiModuleInstance *myApplet, double fX, double fY, double alpha, SliderImageArea *slide)
47 {
48 if (myConfig.pBackgroundColor[3] != 0)
49 {
50 cairo_set_source_rgba (myDrawContext, myConfig.pBackgroundColor[0], myConfig.pBackgroundColor[1], myConfig.pBackgroundColor[2], alpha * myConfig.pBackgroundColor[3]);
51 if (myConfig.iBackgroundType == 2)
52 {
53 int iLineWidth = _get_frame_linewidth (myApplet);
54 double fRadius = MIN (5, .25*iLineWidth);
55 cairo_save (myDrawContext);
56 cairo_translate (myDrawContext, fX - .5*iLineWidth, fY);
57 cairo_dock_draw_rounded_rectangle (myDrawContext, fRadius, iLineWidth, slide->fImgW - (2*fRadius), slide->fImgH - iLineWidth);
58 cairo_set_line_width (myDrawContext, iLineWidth);
59 cairo_stroke (myDrawContext);
60 cairo_restore (myDrawContext);
61 }
62 else
63 {
64 cairo_rectangle (myDrawContext, fX, fY, slide->fImgW, slide->fImgH);
65 cairo_fill (myDrawContext);
66 }
67 }
68 }
69 #define _cd_slider_add_background_to_current_slide(myApplet, fX, fY, alpha) _cd_slider_add_background_to_slide (myApplet, fX, fY, alpha, &myData.slideArea)
70 #define _cd_slider_add_background_to_prev_slide(myApplet, fX, fY, alpha) _cd_slider_add_background_to_slide (myApplet, fX, fY, alpha, &myData.prevSlideArea)
71
72 static void _cd_slider_add_background_to_slide_opengl(GldiModuleInstance *myApplet, double fX, double fY, double alpha, SliderImageArea *slide)
73 {
74 if (myConfig.pBackgroundColor[3] != 0)
75 {
76 glDisable (GL_TEXTURE_2D);
77 glColor4f (myConfig.pBackgroundColor[0], myConfig.pBackgroundColor[1], myConfig.pBackgroundColor[2], alpha * myConfig.pBackgroundColor[3]);
78 if (myConfig.iBackgroundType == 2)
79 {
80 int iLineWidth = _get_frame_linewidth (myApplet);
81 double fRadius = 1.33 * MIN (5, .25*iLineWidth);
82 glPushMatrix ();
83 glTranslatef (fX, fY, 0.); // centre du rectangle.
84 glBlendFunc (GL_ONE, GL_ZERO);
85 cairo_dock_draw_rounded_rectangle_opengl (slide->fImgW - (2*fRadius) + iLineWidth, slide->fImgH + iLineWidth, fRadius, 0, NULL); // we fill the rectangle, because the stroke function in opengl does not handle wide lines very well.
86 glPopMatrix ();
87 glPolygonMode (GL_FRONT, GL_FILL);
88 }
89 else
90 {
91 glPolygonMode (GL_FRONT, GL_FILL);
92 glEnable (GL_BLEND);
93 glBlendFunc (GL_ONE, GL_ZERO);
94 if (myConfig.pBackgroundColor[3] != 0)
95 {
96 glBegin(GL_QUADS);
97 glVertex3f(fX - slide->fImgW/2, fY - slide->fImgH/2, 0.);
98 glVertex3f(fX + slide->fImgW/2, fY - slide->fImgH/2, 0.);
99 glVertex3f(fX + slide->fImgW/2, fY + slide->fImgH/2, 0.);
100 glVertex3f(fX - slide->fImgW/2, fY + slide->fImgH/2, 0.);
101 glEnd();
102 }
103 }
104 }
105 }
106 #define _cd_slider_add_background_to_current_slide_opengl(myApplet, fX, fY, alpha) _cd_slider_add_background_to_slide_opengl (myApplet, fX, fY, alpha, &myData.slideArea)
107 #define _cd_slider_add_background_to_prev_slide_opengl(myApplet, fX, fY, alpha) _cd_slider_add_background_to_slide_opengl (myApplet, fX, fY, alpha, &myData.prevSlideArea)
108
109 void cd_slider_draw_default (GldiModuleInstance *myApplet)
110 {
111 if (CD_APPLET_MY_CONTAINER_IS_OPENGL)
112 {
113 CD_APPLET_START_DRAWING_MY_ICON_OR_RETURN ();
114
115 _cd_slider_add_background_to_current_slide_opengl (myApplet, 0., 0., 1.);
116
117 _cairo_dock_set_blend_alpha ();
118 glEnable (GL_TEXTURE_2D);
119 glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
120
121 _cairo_dock_apply_texture_at_size_with_alpha (myData.iTexture, myData.slideArea.fImgW, myData.slideArea.fImgH, 1.);
122
123 _cairo_dock_disable_texture ();
124 CD_APPLET_FINISH_DRAWING_MY_ICON;
125 }
126 else
127 {
128 CD_APPLET_START_DRAWING_MY_ICON_OR_RETURN_CAIRO ();
129 //\______________________ On efface le fond
130 ///_cd_slider_erase_surface (myApplet);
131
132 //\______________________ On empeche la transparence
133 _cd_slider_add_background_to_current_slide (myApplet, myData.slideArea.fImgX, myData.slideArea.fImgY, 1.);
134
135 //\______________________ On dessine la nouvelle surface.
136 cairo_set_source_surface (myDrawContext, myData.pCairoSurface, myData.slideArea.fImgX, myData.slideArea.fImgY);
137 cairo_paint (myDrawContext);
138 CD_APPLET_FINISH_DRAWING_MY_ICON_CAIRO;
139 }
140 }
141
142 gboolean cd_slider_fade (GldiModuleInstance *myApplet) {
143 myData.iAnimCNT ++;
144 myData.fAnimAlpha = 1.*myData.iAnimCNT / myConfig.iNbAnimationStep;
145 if (myData.fAnimAlpha > 1)
146 myData.fAnimAlpha = 1;
147
148 if (CD_APPLET_MY_CONTAINER_IS_OPENGL)
149 {
150 CD_APPLET_START_DRAWING_MY_ICON_OR_RETURN (FALSE);
151
152 //Fond précédent.
153 if (myData.iPrevTexture != 0)
154 _cd_slider_add_background_to_prev_slide_opengl (myApplet, 0., 0., 1 - myData.fAnimAlpha);
155
156 //On empeche la transparence.
157 _cd_slider_add_background_to_current_slide_opengl (myApplet, 0., 0., myData.fAnimAlpha);
158
159 _cairo_dock_set_blend_alpha ();
160 glEnable (GL_TEXTURE_2D);
161 glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
162
163 //Image précédente
164 if (myData.iPrevTexture != 0)
165 {
166 _cairo_dock_apply_texture_at_size_with_alpha (myData.iPrevTexture, myData.prevSlideArea.fImgW, myData.prevSlideArea.fImgH, 1 - myData.fAnimAlpha);
167 }
168
169 //Image courante.
170 _cairo_dock_apply_texture_at_size_with_alpha (myData.iTexture, myData.slideArea.fImgW, myData.slideArea.fImgH, myData.fAnimAlpha);
171
172 _cairo_dock_disable_texture ();
173 CD_APPLET_FINISH_DRAWING_MY_ICON;
174 }
175 else
176 {
177 CD_APPLET_START_DRAWING_MY_ICON_OR_RETURN_CAIRO (FALSE);
178 //On efface le fond
179 ///_cd_slider_erase_surface (myApplet);
180
181 //Fond précédent.
182 if (myData.pPrevCairoSurface != NULL)
183 _cd_slider_add_background_to_prev_slide (myApplet, myData.prevSlideArea.fImgX, myData.prevSlideArea.fImgY, 1 - myData.fAnimAlpha);
184
185 //On empeche la transparence.
186 _cd_slider_add_background_to_current_slide (myApplet, myData.slideArea.fImgX, myData.slideArea.fImgY, myData.fAnimAlpha);
187
188 //Image précédente
189 if (myData.pPrevCairoSurface != NULL) {
190 cairo_set_source_surface (myDrawContext, myData.pPrevCairoSurface, myData.prevSlideArea.fImgX, myData.prevSlideArea.fImgY);
191 cairo_paint_with_alpha (myDrawContext, 1 - myData.fAnimAlpha);
192 }
193
194 cairo_set_source_surface (myDrawContext, myData.pCairoSurface, myData.slideArea.fImgX, myData.slideArea.fImgY);
195 cairo_paint_with_alpha (myDrawContext, myData.fAnimAlpha);
196 CD_APPLET_FINISH_DRAWING_MY_ICON_CAIRO;
197 }
198
199 return (myData.fAnimAlpha < .99);
200 }
201
202 gboolean cd_slider_blank_fade (GldiModuleInstance *myApplet) {
203 myData.iAnimCNT ++;
204 myData.fAnimAlpha = 1 - 1.*myData.iAnimCNT / myConfig.iNbAnimationStep;
205 if (myData.fAnimAlpha < 0)
206 myData.fAnimAlpha = 0;
207
208 if (CD_APPLET_MY_CONTAINER_IS_OPENGL)
209 {
210 CD_APPLET_START_DRAWING_MY_ICON_OR_RETURN (FALSE);
211
212 //On empeche la transparence
213 _cd_slider_add_background_to_current_slide_opengl (myApplet, 0., 0., 1.);
214
215 glBlendFunc (GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
216 glEnable (GL_TEXTURE_2D);
217 glEnable (GL_BLEND);
218 glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
219
220 //Image
221 glColor4f (1., 1., 1., 1.);
222 cairo_dock_apply_texture_at_size (myData.iTexture, myData.slideArea.fImgW, myData.slideArea.fImgH);
223
224 //Masque
225 glDisable (GL_TEXTURE_2D);
226 glColor4f (1., 1., 1., myData.fAnimAlpha);
227 glBegin(GL_QUADS);
228 glVertex3f(-.5*myData.slideArea.fImgW, .5*myData.slideArea.fImgH, 0.);
229 glVertex3f( .5*myData.slideArea.fImgW, .5*myData.slideArea.fImgH, 0.);
230 glVertex3f( .5*myData.slideArea.fImgW, -.5*myData.slideArea.fImgH, 0.);
231 glVertex3f(-.5*myData.slideArea.fImgW, -.5*myData.slideArea.fImgH, 0.);
232 glEnd();
233
234 glDisable (GL_BLEND);
235 CD_APPLET_FINISH_DRAWING_MY_ICON;
236 }
237 else
238 {
239 CD_APPLET_START_DRAWING_MY_ICON_OR_RETURN_CAIRO (FALSE);
240 //On efface le fond
241 ///_cd_slider_erase_surface (myApplet);
242
243 //On empeche la transparence
244 _cd_slider_add_background_to_current_slide (myApplet, myData.slideArea.fImgX, myData.slideArea.fImgY, 1.);
245
246 //Image
247 cairo_set_source_surface (myDrawContext, myData.pCairoSurface, myData.slideArea.fImgX, myData.slideArea.fImgY);
248 cairo_paint (myDrawContext);
249
250 //Masque
251 cairo_set_source_rgba (myDrawContext, 1., 1., 1., myData.fAnimAlpha);
252 cairo_rectangle(myDrawContext, 0., 0., myData.iSurfaceWidth, myData.iSurfaceHeight);
253 cairo_fill(myDrawContext);
254 CD_APPLET_FINISH_DRAWING_MY_ICON_CAIRO;
255 }
256
257 return (myData.fAnimAlpha > 0.01);
258 }
259
260 gboolean cd_slider_fade_in_out (GldiModuleInstance *myApplet) {
261 myData.iAnimCNT ++;
262 if (myData.iAnimCNT <= myConfig.iNbAnimationStep) // courbe de alpha : \__/
263 myData.fAnimAlpha = 1. * (myConfig.iNbAnimationStep - myData.iAnimCNT) / myConfig.iNbAnimationStep;
264 else if (myData.iAnimCNT <= 1.5 * myConfig.iNbAnimationStep)
265 {
266 return TRUE; // on ne fait rien, texture inchangee.
267 }
268 else
269 myData.fAnimAlpha = 1. * (myData.iAnimCNT - 1.5 * myConfig.iNbAnimationStep) / myConfig.iNbAnimationStep;
270
271 if (CD_APPLET_MY_CONTAINER_IS_OPENGL)
272 {
273 CD_APPLET_START_DRAWING_MY_ICON_OR_RETURN (FALSE);
274
275 if (myData.iAnimCNT < myConfig.iNbAnimationStep && myData.iPrevTexture != 0) // image precedente en train de disparaitre
276 {
277 //On empeche la transparence
278 _cd_slider_add_background_to_prev_slide_opengl (myApplet, 0., 0., myData.fAnimAlpha);
279
280 //Image
281 glBlendFunc (GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
282 glEnable (GL_TEXTURE_2D);
283 glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
284 glColor4f (1., 1., 1., myData.fAnimAlpha);
285 cairo_dock_apply_texture_at_size (myData.iPrevTexture, myData.prevSlideArea.fImgW, myData.prevSlideArea.fImgH);
286 }
287 else if (myData.iAnimCNT > myConfig.iNbAnimationStep) // image courante en train d'apparaitre.
288 {
289 //On empeche la transparence
290 _cd_slider_add_background_to_current_slide_opengl (myApplet, 0., 0., myData.fAnimAlpha);
291
292 //Image
293 glBlendFunc (GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
294 glEnable (GL_TEXTURE_2D);
295 glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
296 glColor4f (1., 1., 1., myData.fAnimAlpha);
297 cairo_dock_apply_texture_at_size (myData.iTexture, myData.slideArea.fImgW, myData.slideArea.fImgH);
298 }
299
300 glDisable (GL_TEXTURE_2D);
301 glDisable (GL_BLEND);
302 CD_APPLET_FINISH_DRAWING_MY_ICON;
303 }
304 else
305 {
306 CD_APPLET_START_DRAWING_MY_ICON_OR_RETURN_CAIRO (FALSE);
307 //On efface le fond
308 ///_cd_slider_erase_surface (myApplet);
309
310 if (myData.iAnimCNT < myConfig.iNbAnimationStep) // image precedente en train de disparaitre
311 {
312 //On empeche la transparence
313 _cd_slider_add_background_to_prev_slide (myApplet, myData.prevSlideArea.fImgX, myData.prevSlideArea.fImgY, myData.fAnimAlpha);
314 //Image
315 cairo_set_source_surface (myDrawContext, myData.pPrevCairoSurface, myData.prevSlideArea.fImgX, myData.prevSlideArea.fImgY);
316 }
317 else if (myData.iAnimCNT > myConfig.iNbAnimationStep) // image courante en train d'apparaitre.
318 {
319 //On empeche la transparence
320 _cd_slider_add_background_to_current_slide (myApplet, myData.slideArea.fImgX, myData.slideArea.fImgY, myData.fAnimAlpha);
321 //Image
322 cairo_set_source_surface (myDrawContext, myData.pCairoSurface, myData.slideArea.fImgX, myData.slideArea.fImgY);
323 }
324 cairo_paint_with_alpha (myDrawContext, myData.fAnimAlpha);
325 CD_APPLET_FINISH_DRAWING_MY_ICON_CAIRO;
326 }
327
328 return (myData.fAnimAlpha < .99);
329 }
330
331 gboolean cd_slider_side_kick (GldiModuleInstance *myApplet) {
332 myData.iAnimCNT += myData.sens;
333 int xcumul = myData.iAnimCNT * (myData.iAnimCNT + 1) / 2;
334 xcumul *= (10./myConfig.iNbAnimationStep); /// au pif, a calculer ...
335 if (xcumul > myData.iSurfaceWidth) // en fait il faudrait regarder x > (iSurfaceWidth + fImgW)/2, mais comme ca on se prend pas la tete avec la difference de fImgW et fprevImgW, et ca laisse une petite tampo pendant laquelle l'icone est vide, c'est bien.
336 myData.sens = -1; // donc le coup d'apres on sera a nouveau en-dessous du seuil.
337
338 if (CD_APPLET_MY_CONTAINER_IS_OPENGL)
339 {
340 CD_APPLET_START_DRAWING_MY_ICON_OR_RETURN (FALSE);
341
342 if (myData.sens == 1) // image precedente qui part sur la gauche.
343 {
344 _cd_slider_add_background_to_prev_slide_opengl (myApplet, - xcumul, 0., 1.);
345
346 glBlendFunc (GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
347 glEnable (GL_TEXTURE_2D);
348 glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
349 glColor4f (1., 1., 1., 1.);
350
351 glTranslatef (- xcumul, 0., 0.);
352 cairo_dock_apply_texture_at_size (myData.iPrevTexture, myData.prevSlideArea.fImgW, myData.prevSlideArea.fImgH);
353 }
354 else // image courante qui vient de la droite.
355 {
356 _cd_slider_add_background_to_current_slide_opengl (myApplet, xcumul, 0., 1.);
357
358 glBlendFunc (GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
359 glEnable (GL_TEXTURE_2D);
360 glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
361 glColor4f (1., 1., 1., 1.);
362
363 glTranslatef (xcumul, 0., 0.);
364 cairo_dock_apply_texture_at_size (myData.iTexture, myData.slideArea.fImgW, myData.slideArea.fImgH);
365 }
366
367 glDisable (GL_TEXTURE_2D);
368 glDisable (GL_BLEND);
369 CD_APPLET_FINISH_DRAWING_MY_ICON;
370 }
371 else
372 {
373 CD_APPLET_START_DRAWING_MY_ICON_OR_RETURN_CAIRO (FALSE);
374 //On efface le fond
375 ///_cd_slider_erase_surface (myApplet);
376
377 if (myData.sens == 1) // image precedente qui part sur la gauche.
378 {
379 _cd_slider_add_background_to_prev_slide (myApplet, myData.prevSlideArea.fImgX - xcumul, myData.prevSlideArea.fImgY, 1.);
380
381 cairo_set_source_surface (myDrawContext, myData.pPrevCairoSurface, myData.prevSlideArea.fImgX - xcumul, myData.prevSlideArea.fImgY);
382 }
383 else // image courante qui vient de la droite.
384 {
385 _cd_slider_add_background_to_current_slide (myApplet, myData.slideArea.fImgX + xcumul, myData.slideArea.fImgY, 1.);
386
387 cairo_set_source_surface (myDrawContext, myData.pCairoSurface, myData.slideArea.fImgX + xcumul, myData.slideArea.fImgY);
388 }
389 cairo_paint (myDrawContext);
390 CD_APPLET_FINISH_DRAWING_MY_ICON_CAIRO;
391 }
392
393 return (myData.iAnimCNT > 0);
394 }
395
396 gboolean cd_slider_diaporama (GldiModuleInstance *myApplet) {
397 static double a = .75;
398 myData.iAnimCNT ++;
399 myData.fAnimAlpha = 1.*myData.iAnimCNT / myConfig.iNbAnimationStep;
400 if (myData.fAnimAlpha > 1)
401 myData.fAnimAlpha = 1;
402
403 if (CD_APPLET_MY_CONTAINER_IS_OPENGL)
404 {
405 CD_APPLET_START_DRAWING_MY_ICON_OR_RETURN (FALSE);
406
407 gldi_gl_container_set_perspective_view_for_icon (myIcon);
408 glScalef (1., -1., 1.);
409
410 if (myData.iPrevTexture != 0 && myData.fAnimAlpha < a)
411 {
412 glPushMatrix ();
413
414 glTranslatef (-myData.iSurfaceWidth/2, 0., 0.);
415 glRotatef (120. * (myData.fAnimAlpha/a), 0., 1., 0.);
416 glTranslatef (myData.iSurfaceWidth/2, 0., 0.);
417
418 //On empeche la transparence
419 _cd_slider_add_background_to_prev_slide_opengl (myApplet, 0., 0., 1.);
420
421 //Image
422 _cairo_dock_enable_texture ();
423 _cairo_dock_set_blend_alpha ();
424 _cairo_dock_set_alpha (1.);
425 cairo_dock_apply_texture_at_size (myData.iPrevTexture, myData.prevSlideArea.fImgW, myData.prevSlideArea.fImgH);
426
427 glPopMatrix ();
428 }
429
430 if (myData.fAnimAlpha > 1-a)
431 {
432 glTranslatef (myData.iSurfaceWidth/2, 0., 0.);
433 glRotatef (-120. * (1-myData.fAnimAlpha)/a, 0., 1., 0.);
434 glTranslatef (-myData.iSurfaceWidth/2, 0., 0.);
435
436 //On empeche la transparence
437 _cd_slider_add_background_to_current_slide_opengl (myApplet, 0., 0., 1.);
438
439 //Image
440 _cairo_dock_enable_texture ();
441 _cairo_dock_set_blend_alpha ();
442 _cairo_dock_set_alpha (1.);
443 glColor4f (1., 1., 1., 1.);
444 cairo_dock_apply_texture_at_size (myData.iTexture, myData.slideArea.fImgW, myData.slideArea.fImgH);
445 }
446
447 _cairo_dock_disable_texture ();
448
449 CD_APPLET_FINISH_DRAWING_MY_ICON;
450
451 if (myDock)
452 gldi_gl_container_set_ortho_view (myContainer);
453 }
454 else
455 {
456 CD_APPLET_START_DRAWING_MY_ICON_OR_RETURN_CAIRO (FALSE);
457 //On efface le fond
458 ///_cd_slider_erase_surface (myApplet);
459
460 //Image précédante
461 if (myData.pPrevCairoSurface != NULL)
462 {
463 _cd_slider_add_background_to_prev_slide (myApplet, myData.prevSlideArea.fImgX - myData.fAnimAlpha * myData.iSurfaceWidth, myData.prevSlideArea.fImgY, 1.);
464
465 cairo_set_source_surface (myDrawContext, myData.pPrevCairoSurface, myData.prevSlideArea.fImgX - myData.fAnimAlpha * myData.iSurfaceWidth, myData.prevSlideArea.fImgY);
466 cairo_paint(myDrawContext);
467 }
468
469 //Image courante.
470 _cd_slider_add_background_to_current_slide (myApplet, myData.slideArea.fImgX + myData.iSurfaceWidth * (1 - myData.fAnimAlpha), myData.slideArea.fImgY, 1.);
471
472 cairo_set_source_surface (myDrawContext, myData.pCairoSurface, myData.slideArea.fImgX + myData.iSurfaceWidth * (1 - myData.fAnimAlpha), myData.slideArea.fImgY);
473 cairo_paint(myDrawContext);
474 CD_APPLET_FINISH_DRAWING_MY_ICON_CAIRO;
475 }
476
477 return (myData.fAnimAlpha < .999);
478 }
479
480 gboolean cd_slider_grow_up (GldiModuleInstance *myApplet) {
481 myData.iAnimCNT ++;
482 myData.fAnimAlpha = 1.*myData.iAnimCNT / myConfig.iNbAnimationStep;
483 if (myData.fAnimAlpha > 1)
484 myData.fAnimAlpha = 1;
485
486 if (CD_APPLET_MY_CONTAINER_IS_OPENGL)
487 {
488 CD_APPLET_START_DRAWING_MY_ICON_OR_RETURN (FALSE);
489
490 glPushMatrix ();
491 glScalef (myData.fAnimAlpha, myData.fAnimAlpha, 1.);
492 _cd_slider_add_background_to_current_slide_opengl (myApplet, 0., 0., 1.);
493 glPopMatrix ();
494
495 glBlendFunc (GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
496 glEnable (GL_TEXTURE_2D);
497 glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
498
499 glColor4f (1., 1., 1., 1.);
500 cairo_dock_apply_texture_at_size (myData.iTexture, myData.slideArea.fImgW * myData.fAnimAlpha, myData.slideArea.fImgH * myData.fAnimAlpha);
501
502 glDisable (GL_TEXTURE_2D);
503 glDisable (GL_BLEND);
504 CD_APPLET_FINISH_DRAWING_MY_ICON;
505 }
506 else
507 {
508 CD_APPLET_START_DRAWING_MY_ICON_OR_RETURN_CAIRO (FALSE);
509 //On efface le fond
510 ///_cd_slider_erase_surface (myApplet);
511
512 //On met a l'échelle en recentrant.
513 cairo_save(myDrawContext);
514 cairo_translate (myDrawContext, (myData.iSurfaceWidth - myData.slideArea.fImgW * myData.fAnimAlpha) / 2, (myData.iSurfaceHeight - myData.slideArea.fImgH * myData.fAnimAlpha) / 2);
515 cairo_scale(myDrawContext, myData.fAnimAlpha, myData.fAnimAlpha);
516
517 //On empeche la transparence et on affiche l'image
518 _cd_slider_add_background_to_current_slide (myApplet, 0., 0., 1.);
519 cairo_set_source_surface (myDrawContext, myData.pCairoSurface, 0., 0.);
520
521 cairo_paint_with_alpha (myDrawContext, myData.fAnimAlpha);
522 cairo_restore(myDrawContext);
523 CD_APPLET_FINISH_DRAWING_MY_ICON_CAIRO;
524 }
525
526 return (myData.fAnimAlpha < .99);
527 }
528
529 gboolean cd_slider_shrink_down (GldiModuleInstance *myApplet) {
530 myData.iAnimCNT ++;
531 myData.fAnimAlpha = 2 - 1.*myData.iAnimCNT / myConfig.iNbAnimationStep;
532 if (myData.fAnimAlpha < 1)
533 myData.fAnimAlpha = 1;
534
535 if (CD_APPLET_MY_CONTAINER_IS_OPENGL)
536 {
537 CD_APPLET_START_DRAWING_MY_ICON_OR_RETURN (FALSE);
538
539 glPushMatrix ();
540 glScalef (myData.fAnimAlpha, myData.fAnimAlpha, 1.);
541 _cd_slider_add_background_to_current_slide_opengl (myApplet, 0., 0., 1.);
542 glPopMatrix ();
543
544 glBlendFunc (GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
545 glEnable (GL_TEXTURE_2D);
546 glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
547
548 glColor4f (1., 1., 1., 1.);
549 cairo_dock_apply_texture_at_size (myData.iTexture, myData.slideArea.fImgW * myData.fAnimAlpha, myData.slideArea.fImgH * myData.fAnimAlpha);
550
551 glDisable (GL_TEXTURE_2D);
552 glDisable (GL_BLEND);
553 CD_APPLET_FINISH_DRAWING_MY_ICON;
554 }
555 else
556 {
557 CD_APPLET_START_DRAWING_MY_ICON_OR_RETURN_CAIRO (FALSE);
558 //On efface le fond
559 ///_cd_slider_erase_surface (myApplet);
560
561 //On met a l'échelle en recentrant.
562 cairo_save(myDrawContext);
563 cairo_translate (myDrawContext, (myData.iSurfaceWidth - myData.slideArea.fImgW * myData.fAnimAlpha) / 2, (myData.iSurfaceHeight - myData.slideArea.fImgH * myData.fAnimAlpha) / 2);
564 cairo_scale(myDrawContext, myData.fAnimAlpha, myData.fAnimAlpha);
565
566 //On empeche la transparence et on affiche l'image
567 _cd_slider_add_background_to_current_slide (myApplet, 0., 0., 1.);
568 cairo_set_source_surface (myDrawContext, myData.pCairoSurface, 0., 0.);
569
570 cairo_paint_with_alpha (myDrawContext, myData.fAnimAlpha);
571 cairo_restore(myDrawContext);
572 CD_APPLET_FINISH_DRAWING_MY_ICON_CAIRO;
573 }
574
575 return (myData.fAnimAlpha > 1.01);
576 }
577
578 gboolean cd_slider_cube (GldiModuleInstance *myApplet) {
579 myData.iAnimCNT ++;
580 myData.fAnimAlpha = 1.*myData.iAnimCNT / myConfig.iNbAnimationStep;
581 if (myData.fAnimAlpha > 1)
582 myData.fAnimAlpha = 1;
583
584 if (CD_APPLET_MY_CONTAINER_IS_OPENGL)
585 {
586 CD_APPLET_START_DRAWING_MY_ICON_OR_RETURN (FALSE);
587
588 gldi_gl_container_set_perspective_view_for_icon (myIcon);
589 glScalef (1., -1., 1.);
590
591 double fTheta = - 45. + myData.fAnimAlpha * 90.; // -45 -> 45
592 glTranslatef (0., 0., - myData.iSurfaceWidth * sqrt(2)/2 * cos (fTheta/180.*G_PI)); // pour faire tenir le cube dans la fenetre.
593 glEnable (GL_DEPTH_TEST);
594
595 // image precedente.
596 if (fTheta < 25) // inutile de dessiner si elle est derriere l'image courante, par l'effet de perspective (en fait 22.5, mais bizarrement ca a l'air un peu trop tot).
597 {
598 glPushMatrix ();
599 glRotatef (45. + fTheta, 0., 1., 0.); // 0 -> 90
600 glTranslatef (0., 0., myData.slideArea.fImgW/2-1);
601
602 _cd_slider_add_background_to_prev_slide_opengl (myApplet, 0., 0., 1.);
603
604 glBlendFunc (GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
605 glEnable (GL_TEXTURE_2D);
606 glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
607
608 glTranslatef (0., 0., 1.);
609 glColor4f (1., 1., 1., 1.);
610 cairo_dock_apply_texture_at_size (myData.iPrevTexture, myData.prevSlideArea.fImgW, myData.prevSlideArea.fImgH);
611 glDisable (GL_TEXTURE_2D);
612 glPopMatrix ();
613 }
614 // image courante a 90deg.
615 glRotatef (45. + fTheta, 0., 1., 0.); // 0 -> 90
616 if (myData.prevSlideArea.fImgW != 0)
617 glTranslatef (- myData.prevSlideArea.fImgW/2+1, 0., 0.);
618 else
619 glTranslatef (- myData.iSurfaceWidth/2+1, 0., 0.);
620
621 glPushMatrix ();
622 glRotatef (-90., 0., 1., 0.);
623 _cd_slider_add_background_to_current_slide_opengl (myApplet, 0., 0., 1.);
624 glPopMatrix ();
625
626 glBlendFunc (GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
627 glEnable (GL_TEXTURE_2D);
628
629 glTranslatef (-1., 0., 0.);
630 glRotatef (-90., 0., 1., 0.);
631 glColor4f (1., 1., 1., 1.);
632 cairo_dock_apply_texture_at_size (myData.iTexture, myData.slideArea.fImgW, myData.slideArea.fImgH);
633
634 glDisable (GL_DEPTH_TEST);
635 glDisable (GL_TEXTURE_2D);
636 glDisable (GL_BLEND);
637 CD_APPLET_FINISH_DRAWING_MY_ICON;
638
639 if (myDock)
640 gldi_gl_container_set_ortho_view (myContainer);
641 }
642 else
643 {
644 cd_slider_draw_default (myApplet);
645 return FALSE;
646 }
647 return (myData.fAnimAlpha < .99);
648 }