← Back to branch summary

~ubuntu-branches/ubuntu/saucy/cairo-dock-plug-ins/saucy

« back to all changes in this revision

Viewing changes to rhythmbox/src/3dcover-draw.c

  • Committer: Bazaar Package Importer
  • Author(s): Didier Roche
  • Date: 2009-08-26 21:07:39 UTC
  • Revision ID: james.westby@ubuntu.com-20090826210739-gyjuuqezrzuluao4
Tags: upstream-2.0.8.1
Import upstream version 2.0.8.1

Show diffs side-by-side

added added

removed removed

Lines of Context:
rhythmbox/src/3dcover-draw.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 <stdlib.h>
 
21
#include <math.h>
 
22
 
 
23
#include "rhythmbox-struct.h"
 
24
#include "rhythmbox-config.h"
 
25
#include "rhythmbox-draw.h"
 
26
#include "3dcover-draw.h"
 
27
 
 
28
#define _check_error(erreur) \
 
29
        if (erreur != NULL) { \
 
30
                cd_warning (erreur->message);\
 
31
                g_error_free (erreur);\
 
32
                erreur = NULL; }
 
33
 
 
34
#define _make_texture_at_size(texture, cGroupName, cKeyName, w, h)\
 
35
        cImageName = g_key_file_get_string (pKeyFile, cGroupName, cKeyName, &erreur);\
 
36
        _check_error(erreur);\
 
37
        if (cImageName != NULL) {\
 
38
                g_string_printf (sImagePath, "%s/%s", cThemePath, cImageName);\
 
39
                pSurface = cairo_dock_create_surface_for_icon (sImagePath->str, myDrawContext, w, h);\
 
40
                texture = cairo_dock_create_texture_from_surface (pSurface);\
 
41
                cairo_surface_destroy (pSurface);\
 
42
                g_free (cImageName); }
 
43
 
 
44
#define _draw_osd(texture, x_, y_, w_, h_)\
 
45
        X = myData.osdPausecoordX - myData.osdPausesizeX/2;\
 
46
        Y = myData.osdPausecoordY - myData.osdPausesizeY/2;\
 
47
        _transform_coords(X, Y, u1, v1);\
 
48
        X = myData.osdPausecoordX - myData.osdPausesizeX/2;\
 
49
        Y = myData.osdPausecoordY + myData.osdPausesizeY/2;\
 
50
        _transform_coords(X, Y, u2, v2);\
 
51
        X = myData.osdPausecoordX + myData.osdPausesizeX/2;\
 
52
        Y = myData.osdPausecoordY + myData.osdPausesizeY/2;\
 
53
        _transform_coords(X, Y, u3, v3);\
 
54
        X = myData.osdPausecoordX + myData.osdPausesizeX/2;\
 
55
        Y = myData.osdPausecoordY - myData.osdPausesizeY/2;\
 
56
        _transform_coords(X, Y, u4, v4);\
 
57
        glBindTexture (GL_TEXTURE_2D, texture);\
 
58
        glBegin (GL_QUADS);\
 
59
        glTexCoord2d (0,0);\
 
60
        glVertex3f (- iWidth/2 + u1, + iHeight/2 - v1, 0);\
 
61
        glTexCoord2d (0,1);\
 
62
        glVertex3f (- iWidth/2 + u2, + iHeight/2 - v2, 0);\
 
63
        glTexCoord2d (1,1);\
 
64
        glVertex3f (- iWidth/2 + u3, + iHeight/2 - v3, 0);\
 
65
        glTexCoord2d (1,0);\
 
66
        glVertex3f (- iWidth/2 + u4, + iHeight/2 - v4, 0);\
 
67
        glEnd ();
 
68
 
 
69
gboolean cd_opengl_load_3D_theme (CairoDockModuleInstance *myApplet, gchar *cThemePath)
 
70
{
 
71
        gchar *cImageName;
 
72
        cairo_surface_t *pSurface;
 
73
        gchar *cConfFilePath = g_strdup_printf ("%s/%s", cThemePath, "theme.conf");
 
74
        GKeyFile *pKeyFile = cairo_dock_open_key_file (cConfFilePath);
 
75
        g_free (cConfFilePath);
 
76
        if (pKeyFile == NULL)
 
77
                return FALSE;
 
78
        
 
79
        gchar *cThemePathUpToDate = NULL;
 
80
        gint iVersion = g_key_file_get_integer (pKeyFile, "Description", "Version", NULL);
 
81
        if (iVersion != 2)
 
82
        {
 
83
                /// effacer le theme et le recuperer sur le serveur...
 
84
                g_print ("theme en version inferieure => sera mis a jour...\n");
 
85
                // on ferme la config de l'actuel theme.
 
86
                g_key_file_free (pKeyFile);
 
87
                pKeyFile = NULL;
 
88
                
 
89
                // on supprime le theme.
 
90
                g_return_val_if_fail (cThemePath && *cThemePath == '/', FALSE);
 
91
                gchar *cCommand = g_strdup_printf ("rm -rf '%s'", cThemePath);
 
92
                int r = system (cCommand);
 
93
                g_free (cCommand);
 
94
                
 
95
                // on recupere le theme distant.
 
96
                pKeyFile = cairo_dock_open_key_file (myApplet->cConfFilePath);
 
97
                if (pKeyFile != NULL)
 
98
                {
 
99
                        gboolean bFlushConfFileNeeded = FALSE;
 
100
                        cThemePathUpToDate = CD_CONFIG_GET_THEME_PATH ("Configuration", "theme", "themes", "cd_box_simple");
 
101
                        cThemePath = cThemePathUpToDate;
 
102
                        g_key_file_free (pKeyFile);
 
103
                        pKeyFile = NULL;
 
104
                        
 
105
                        // on ouvre la config du nouveau theme.
 
106
                        cConfFilePath = g_strdup_printf ("%s/%s", cThemePath, "theme.conf");
 
107
                        pKeyFile = cairo_dock_open_key_file (cConfFilePath);
 
108
                        g_free (cConfFilePath);
 
109
                        if (pKeyFile == NULL)
 
110
                                return FALSE;
 
111
                }
 
112
                g_return_val_if_fail (pKeyFile != NULL, FALSE);
 
113
        }
 
114
        
 
115
        GError *erreur = NULL;
 
116
        GString *sImagePath = g_string_new ("");        
 
117
        
 
118
        //\_______________ les images d'avant et arriere plan.
 
119
        int iWidth, iHeight;
 
120
        CD_APPLET_GET_MY_ICON_EXTENT (&iWidth, &iHeight);
 
121
        double fImageWidth, fImageHeight;  // dimensions de la surface generee.
 
122
        double fZoomX=1, fZoomY=1;  // facteur de zoom qui lui a ete applique.
 
123
        
 
124
        cImageName = g_key_file_get_string (pKeyFile, "Pictures", "frame", &erreur);
 
125
        _check_error(erreur);
 
126
        if (cImageName != NULL)
 
127
        {
 
128
                g_string_printf (sImagePath, "%s/%s", cThemePath, cImageName);
 
129
                pSurface = cairo_dock_create_surface_from_image (sImagePath->str,
 
130
                        myDrawContext,
 
131
                        1.,
 
132
                        iWidth, iHeight,
 
133
                        CAIRO_DOCK_FILL_SPACE,
 
134
                        &fImageWidth, &fImageHeight,
 
135
                        &fZoomX, &fZoomY);
 
136
                
 
137
                myData.TextureFrame = cairo_dock_create_texture_from_surface (pSurface);
 
138
                cairo_surface_destroy (pSurface);
 
139
                g_free (cImageName);
 
140
        }
 
141
        
 
142
        cImageName = g_key_file_get_string (pKeyFile, "Pictures", "reflect", &erreur);
 
143
        _check_error(erreur);
 
144
        if (cImageName != NULL)
 
145
        {
 
146
                g_string_printf (sImagePath, "%s/%s", cThemePath, cImageName);
 
147
                pSurface = cairo_dock_create_surface_from_image (sImagePath->str,
 
148
                        myDrawContext,
 
149
                        1.,
 
150
                        iWidth, iHeight,
 
151
                        CAIRO_DOCK_FILL_SPACE,
 
152
                        &fImageWidth, &fImageHeight,
 
153
                        NULL, NULL);
 
154
                
 
155
                myData.TextureReflect = cairo_dock_create_texture_from_surface (pSurface);
 
156
                cairo_surface_destroy (pSurface);
 
157
                g_free (cImageName);
 
158
        }
 
159
        
 
160
        //\_______________ les coordonnees des 4 coins de la pochette
 
161
        // dans le referentiel du cadre (directement obtenues avec Gimp) => dans le referentiel de l'icone iWidth x iHeight.
 
162
        myData.itopleftX = g_key_file_get_integer (pKeyFile, "Configuration", "topleftX", &erreur) * fZoomX;
 
163
        _check_error(erreur);
 
164
        myData.itopleftY = g_key_file_get_integer (pKeyFile, "Configuration", "topleftY", &erreur) * fZoomY;
 
165
        _check_error(erreur);
 
166
        
 
167
        myData.ibottomleftX = g_key_file_get_integer (pKeyFile, "Configuration", "bottomleftX", &erreur) * fZoomX;
 
168
        _check_error(erreur);
 
169
        myData.ibottomleftY = g_key_file_get_integer (pKeyFile, "Configuration", "bottomleftY", &erreur) * fZoomY;
 
170
        _check_error(erreur);
 
171
        
 
172
        myData.ibottomrightX = g_key_file_get_integer (pKeyFile, "Configuration", "bottomrightX", &erreur) * fZoomX;
 
173
        _check_error(erreur);
 
174
        myData.ibottomrightY = g_key_file_get_integer (pKeyFile, "Configuration", "bottomrightY", &erreur) * fZoomY;
 
175
        _check_error(erreur);
 
176
        
 
177
        myData.itoprightX = g_key_file_get_integer (pKeyFile, "Configuration", "toprightX", &erreur) * fZoomX;
 
178
        _check_error(erreur);
 
179
        myData.itoprightY = g_key_file_get_integer (pKeyFile, "Configuration", "toprightY", &erreur) * fZoomY;
 
180
        _check_error(erreur);                   
 
181
        
 
182
        //\_______________ On definit la calllist qui déforme la pochette.
 
183
        myData.draw_cover = glGenLists(1);
 
184
        glNewList(myData.draw_cover , GL_COMPILE);
 
185
        glBegin(GL_QUADS);
 
186
        glTexCoord2d (0,0);
 
187
        glVertex3f (-.5 + myData.itopleftX / iWidth,            +.5 - myData.itopleftY / iHeight,               0);
 
188
        glTexCoord2d (0,1);
 
189
        glVertex3f (-.5 + myData.ibottomleftX / iWidth,         +.5 - myData.ibottomleftY /iHeight,             0.);
 
190
        glTexCoord2d (1,1);
 
191
        glVertex3f (-.5 + myData.ibottomrightX / iWidth,        +.5 - myData.ibottomrightY / iHeight,   0.);
 
192
        glTexCoord2d (1,0);
 
193
        glVertex3f (-.5 + myData.itoprightX / iWidth,           +.5 - myData.itoprightY / iHeight,              0.);
 
194
        glEnd();
 
195
        glEndList();
 
196
        
 
197
        //\_______________ les zones cliquables et l'OSD.
 
198
        myData.numberButtons = g_key_file_get_integer (pKeyFile, "Buttons", "number", NULL);
 
199
        if (myData.numberButtons != 0)
 
200
        {
 
201
                myData.osd = g_key_file_get_boolean (pKeyFile, "Buttons", "osd", &erreur);
 
202
                _check_error(erreur);
 
203
                myData.b3dThemesDebugMode = g_key_file_get_boolean (pKeyFile, "Buttons", "debug", &erreur);
 
204
                _check_error(erreur);
 
205
                
 
206
                // Bouton 1
 
207
                myData.button1sizeX = g_key_file_get_integer (pKeyFile, "Button1", "sizeX", &erreur) * fZoomX;
 
208
                _check_error(erreur);
 
209
                myData.button1sizeY = g_key_file_get_integer (pKeyFile, "Button1", "sizeY", &erreur) * fZoomY;
 
210
                _check_error(erreur);
 
211
                myData.button1coordX = g_key_file_get_integer (pKeyFile, "Button1", "X", &erreur) * fZoomX + myData.button1sizeX/2;  // on se ramene au centre.
 
212
                _check_error(erreur);
 
213
                myData.button1coordY = g_key_file_get_integer (pKeyFile, "Button1", "Y", &erreur) * fZoomY + myData.button1sizeY/2;  // on se ramene au centre.
 
214
                _check_error(erreur);
 
215
                
 
216
                _make_texture_at_size (myData.TextureButton1, "Button1", "picture", myData.button1sizeX, myData.button1sizeY);
 
217
                
 
218
                if (myData.osd)
 
219
                {
 
220
                        myData.osdPlaysizeX = g_key_file_get_integer (pKeyFile, "Button1", "osd play sizeX", &erreur) * fZoomX;
 
221
                        _check_error(erreur);
 
222
                        myData.osdPlaysizeY = g_key_file_get_integer (pKeyFile, "Button1", "osd play sizeY", &erreur) * fZoomY;
 
223
                        _check_error(erreur);
 
224
                        myData.osdPlaycoordX = g_key_file_get_integer (pKeyFile, "Button1", "osd play X", &erreur) * fZoomX + myData.osdPlaysizeX/2;
 
225
                        _check_error(erreur);
 
226
                        myData.osdPlaycoordY = g_key_file_get_integer (pKeyFile, "Button1", "osd play Y", &erreur) * fZoomY + myData.osdPlaysizeY/2;
 
227
                        _check_error(erreur);
 
228
                        _make_texture_at_size (myData.TextureOsdPlay, "Button1", "osd_play", myData.osdPlaysizeX, myData.osdPlaysizeY);
 
229
 
 
230
                        myData.osdPausesizeX = g_key_file_get_integer (pKeyFile, "Button1", "osd pause sizeX", &erreur) * fZoomX;
 
231
                        _check_error(erreur);
 
232
                        myData.osdPausesizeY = g_key_file_get_integer (pKeyFile, "Button1", "osd pause sizeY", &erreur) * fZoomY;
 
233
                        _check_error(erreur);
 
234
                        myData.osdPausecoordX = g_key_file_get_integer (pKeyFile, "Button1", "osd pause X", &erreur) * fZoomX + myData.osdPausesizeX/2;
 
235
                        _check_error(erreur);
 
236
                        myData.osdPausecoordY = g_key_file_get_integer (pKeyFile, "Button1", "osd pause Y", &erreur) * fZoomY + myData.osdPausesizeY/2;
 
237
                        _check_error(erreur);
 
238
                        _make_texture_at_size (myData.TextureOsdPause, "Button1", "osd_pause", myData.osdPausesizeX, myData.osdPausesizeY);
 
239
                }
 
240
                
 
241
                // Bouton 4
 
242
                if (myData.numberButtons > 3)
 
243
                {
 
244
                        _check_error(erreur);
 
245
                        myData.button4sizeX = g_key_file_get_integer (pKeyFile, "Button4", "sizeX", &erreur) * fZoomX;
 
246
                        _check_error(erreur);
 
247
                        myData.button4sizeY = g_key_file_get_integer (pKeyFile, "Button4", "sizeY", &erreur) * fZoomY;
 
248
                        _check_error(erreur);
 
249
                        myData.button4coordX = g_key_file_get_integer (pKeyFile, "Button4", "X", &erreur) * fZoomX + myData.button4sizeX/2;
 
250
                        _check_error(erreur);
 
251
                        myData.button4coordY = g_key_file_get_integer (pKeyFile, "Button4", "Y", &erreur) * fZoomY + myData.button4sizeY/2;
 
252
                        
 
253
                        _make_texture_at_size (myData.TextureButton4, "Button4", "picture", myData.button4sizeX, myData.button4sizeY);
 
254
                        
 
255
                        if (myData.osd)
 
256
                        {
 
257
                                myData.osdHomesizeX = g_key_file_get_integer (pKeyFile, "Button4", "osd sizeX", &erreur) * fZoomX;
 
258
                                _check_error(erreur);
 
259
                                myData.osdHomesizeY = g_key_file_get_integer (pKeyFile, "Button4", "osd sizeY", &erreur) * fZoomY;
 
260
                                _check_error(erreur);
 
261
                                myData.osdHomecoordX = g_key_file_get_integer (pKeyFile, "Button4", "osd X", &erreur) * fZoomX + myData.osdHomesizeX/2;
 
262
                                _check_error(erreur);
 
263
                                myData.osdHomecoordY = g_key_file_get_integer (pKeyFile, "Button4", "osd Y", &erreur) * fZoomY + myData.osdHomesizeY/2;
 
264
                                _check_error(erreur);
 
265
                                _make_texture_at_size (myData.TextureOsdHome, "Button4", "osd", myData.osdHomesizeX, myData.osdHomesizeY);
 
266
                        }
 
267
                }
 
268
                
 
269
                // Bouton 3
 
270
                if (myData.numberButtons > 2)
 
271
                {
 
272
                        myData.button3sizeX = g_key_file_get_integer (pKeyFile, "Button3", "sizeX", &erreur) * fZoomX;
 
273
                        _check_error(erreur);
 
274
                        myData.button3sizeY = g_key_file_get_integer (pKeyFile, "Button3", "sizeY", &erreur) * fZoomY;
 
275
                        _check_error(erreur);
 
276
                        myData.button3coordX = g_key_file_get_integer (pKeyFile, "Button3", "X", &erreur) * fZoomX + myData.button3sizeX/2;
 
277
                        _check_error(erreur);
 
278
                        myData.button3coordY = g_key_file_get_integer (pKeyFile, "Button3", "Y", &erreur) * fZoomY + myData.button3sizeY/2;
 
279
                        _check_error(erreur);
 
280
                        
 
281
                        _make_texture_at_size (myData.TextureButton3, "Button3", "picture", myData.button3sizeX, myData.button3sizeY);
 
282
                        
 
283
                        if (myData.osd)
 
284
                        {
 
285
                                myData.osdNextsizeX = g_key_file_get_integer (pKeyFile, "Button3", "osd sizeX", &erreur) * fZoomX;
 
286
                                _check_error(erreur);
 
287
                                myData.osdNextsizeY = g_key_file_get_integer (pKeyFile, "Button3", "osd sizeY", &erreur) * fZoomY;
 
288
                                _check_error(erreur);
 
289
                                myData.osdNextcoordX = g_key_file_get_integer (pKeyFile, "Button3", "osd X", &erreur) * fZoomX + myData.osdNextsizeX/2;
 
290
                                _check_error(erreur);
 
291
                                myData.osdNextcoordY = g_key_file_get_integer (pKeyFile, "Button3", "osd Y", &erreur) * fZoomY + myData.osdNextsizeY/2;
 
292
                                _check_error(erreur);
 
293
                                _make_texture_at_size (myData.TextureOsdNext, "Button3", "osd", myData.osdNextsizeX, myData.osdNextsizeY);
 
294
                        }
 
295
                }
 
296
                
 
297
                // Bouton 2
 
298
                if (myData.numberButtons > 1)
 
299
                {
 
300
                        myData.button2sizeX = g_key_file_get_integer (pKeyFile, "Button2", "sizeX", &erreur) * fZoomX;
 
301
                        _check_error(erreur);
 
302
                        myData.button2sizeY = g_key_file_get_integer (pKeyFile, "Button2", "sizeY", &erreur) * fZoomY;
 
303
                        _check_error(erreur);
 
304
                        myData.button2coordX = g_key_file_get_integer (pKeyFile, "Button2", "X", &erreur) * fZoomX + myData.button2sizeX/2;
 
305
                        _check_error(erreur);
 
306
                        myData.button2coordY = g_key_file_get_integer (pKeyFile, "Button2", "Y", &erreur) * fZoomY + myData.button2sizeY/2;
 
307
                        _check_error(erreur);
 
308
                        
 
309
                        _make_texture_at_size (myData.TextureButton2, "Button2", "picture", myData.button2sizeX, myData.button2sizeY);
 
310
                        
 
311
                        if (myData.osd)
 
312
                        {
 
313
                                myData.osdPrevsizeX = g_key_file_get_integer (pKeyFile, "Button2", "osd sizeX", &erreur) * fZoomX;
 
314
                                _check_error(erreur);
 
315
                                myData.osdPrevsizeY = g_key_file_get_integer (pKeyFile, "Button2", "osd sizeY", &erreur) * fZoomY;
 
316
                                _check_error(erreur);
 
317
                                myData.osdPrevcoordX = g_key_file_get_integer (pKeyFile, "Button2", "osd X", &erreur) * fZoomX + myData.osdPrevsizeX/2;
 
318
                                _check_error(erreur);
 
319
                                myData.osdPrevcoordY = g_key_file_get_integer (pKeyFile, "Button2", "osd Y", &erreur) * fZoomY + myData.osdPrevsizeY/2;
 
320
                                _check_error(erreur);
 
321
                                _make_texture_at_size (myData.TextureOsdPrev, "Button2", "osd", myData.osdPrevsizeX, myData.osdPrevsizeY);
 
322
                        }
 
323
                }
 
324
        }
 
325
        g_key_file_free (pKeyFile);
 
326
        g_free (cThemePathUpToDate);
 
327
        return TRUE;
 
328
}
 
329
 
 
330
void cd_opengl_reset_opengl_datas (CairoDockModuleInstance *myApplet)
 
331
{
 
332
        if (myData.draw_cover != 0)
 
333
        {
 
334
                glDeleteLists (myData.draw_cover, 1);
 
335
                myData.draw_cover = 0;
 
336
        }
 
337
        if(myData.TextureFrame != 0)
 
338
        {
 
339
                _cairo_dock_delete_texture (myData.TextureFrame);
 
340
                myData.TextureFrame = 0;
 
341
        }
 
342
        if(myData.iPrevTextureCover != 0)
 
343
        {       
 
344
                _cairo_dock_delete_texture (myData.iPrevTextureCover);
 
345
                myData.iPrevTextureCover = 0;
 
346
        }
 
347
        if(myData.TextureCover != 0)
 
348
        {       
 
349
                _cairo_dock_delete_texture (myData.TextureCover);
 
350
                myData.TextureCover = 0;
 
351
        }
 
352
        if(myData.TextureReflect != 0)
 
353
        {
 
354
                _cairo_dock_delete_texture (myData.TextureReflect);
 
355
                myData.TextureReflect = 0;
 
356
        }
 
357
        if(myData.TextureButton1 != 0)
 
358
        {
 
359
                _cairo_dock_delete_texture (myData.TextureButton1);
 
360
                myData.TextureButton1 = 0;
 
361
        }
 
362
        if(myData.TextureButton2 != 0)
 
363
        {
 
364
                _cairo_dock_delete_texture (myData.TextureButton2);
 
365
                myData.TextureButton2 = 0;
 
366
        }
 
367
        if(myData.TextureButton3 != 0)
 
368
        {
 
369
                _cairo_dock_delete_texture (myData.TextureButton3);
 
370
                myData.TextureButton3 = 0;
 
371
        }
 
372
        if(myData.TextureButton4 != 0)
 
373
        {
 
374
                _cairo_dock_delete_texture (myData.TextureButton4);
 
375
                myData.TextureButton4 = 0;
 
376
        }
 
377
        if(myData.TextureOsdPlay != 0)
 
378
        {
 
379
                _cairo_dock_delete_texture (myData.TextureOsdPlay);
 
380
                myData.TextureOsdPlay = 0;
 
381
        }
 
382
        if(myData.TextureOsdPause != 0)
 
383
        {
 
384
                _cairo_dock_delete_texture (myData.TextureOsdPause);
 
385
                myData.TextureOsdPause = 0;
 
386
        }
 
387
        if(myData.TextureOsdPrev != 0)
 
388
        {
 
389
                _cairo_dock_delete_texture (myData.TextureOsdPrev);
 
390
                myData.TextureOsdPrev = 0;
 
391
        }
 
392
        if(myData.TextureOsdNext != 0)
 
393
        {
 
394
                _cairo_dock_delete_texture (myData.TextureOsdNext);
 
395
                myData.TextureOsdNext = 0;
 
396
        }
 
397
        if(myData.TextureOsdHome != 0)
 
398
        {
 
399
                _cairo_dock_delete_texture (myData.TextureOsdHome);
 
400
                myData.TextureOsdHome = 0;
 
401
        }
 
402
        myData.mouseOnButton1 = myData.mouseOnButton2 = myData.mouseOnButton3 = myData.mouseOnButton4 = 0;
 
403
        myData.iButton1Count = myData.iButton2Count = myData.iButton3Count = myData.iButton4Count = 0;
 
404
        myData.iState = 0;
 
405
        myData.iCoverTransition = 0;
 
406
}
 
407
 
 
408
 
 
409
#define _transform_coords(X, Y, x, y) \
 
410
        dx1 = 1. - fabs (X - X1) / W;\
 
411
        dy1 = 1. - fabs (Y - Y1) / H;\
 
412
        dx2 = 1. - fabs (X - X2) / W;\
 
413
        dy2 = 1. - fabs (Y - Y2) / H;\
 
414
        dx3 = 1. - fabs (X - X3) / W;\
 
415
        dy3 = 1. - fabs (Y - Y3) / H;\
 
416
        dx4 = 1. - fabs (X - X4) / W;\
 
417
        dy4 = 1. - fabs (Y - Y4) / H;\
 
418
        x = X + dx1 * dy1 * t1x + dx2 * dy2 * t2x + dx3 * dy3 * t3x + dx4 * dy4 * t4x;\
 
419
        y = Y + dx1 * dy1 * t1y + dx2 * dy2 * t2y + dx3 * dy3 * t3y + dx4 * dy4 * t4y;
 
420
 
 
421
void cd_opengl_scene (CairoDockModuleInstance *myApplet, int iWidth, int iHeight)
 
422
{
 
423
        //g_print ("%s (%d)\n", __func__, myData.iCoverTransition);
 
424
        _cairo_dock_enable_texture ();
 
425
        _cairo_dock_set_blend_source ();
 
426
        
 
427
        // on dessine le cadre.
 
428
        _cairo_dock_apply_texture_at_size_with_alpha (myData.TextureFrame, iWidth, iHeight, 1.);
 
429
        
 
430
        // on dessine la couverture.
 
431
        glPushMatrix ();
 
432
        glScalef (iWidth, iHeight, 1.);
 
433
        if (myData.iPrevTextureCover != 0 && myData.iCoverTransition != 0)
 
434
        {
 
435
                _cairo_dock_set_blend_over ();
 
436
                _cairo_dock_set_alpha ((double)myData.iCoverTransition/NB_TRANSITION_STEP);
 
437
                glBindTexture(GL_TEXTURE_2D, myData.iPrevTextureCover);
 
438
                glCallList(myData.draw_cover);
 
439
        }
 
440
        if (myData.TextureCover != 0)
 
441
        {
 
442
                _cairo_dock_set_blend_over ();
 
443
                _cairo_dock_set_alpha (1.-(double)myData.iCoverTransition/NB_TRANSITION_STEP);
 
444
                glBindTexture(GL_TEXTURE_2D, myData.TextureCover);
 
445
                glCallList(myData.draw_cover);
 
446
        }
 
447
        glPopMatrix ();
 
448
        _cairo_dock_set_blend_over ();
 
449
        
 
450
        
 
451
        // on dessine les boutons qui sont allumes.
 
452
        if (myData.iButton1Count)
 
453
        {
 
454
                glPushMatrix ();
 
455
                glTranslatef (-iWidth/2 + myData.button1coordX, +iHeight/2 - myData.button1coordY, 0.);
 
456
                _cairo_dock_apply_texture_at_size_with_alpha (myData.TextureButton1, myData.button1sizeX, myData.button1sizeY, (double)myData.iButton1Count/NB_TRANSITION_STEP);
 
457
                glPopMatrix ();
 
458
        }
 
459
        if (myData.iButton2Count)
 
460
        {
 
461
                glPushMatrix ();
 
462
                glTranslatef (-iWidth/2 + myData.button2coordX, +iHeight/2 - myData.button2coordY, 0.);
 
463
                _cairo_dock_apply_texture_at_size_with_alpha (myData.TextureButton2, myData.button2sizeX, myData.button2sizeY, (double)myData.iButton2Count/NB_TRANSITION_STEP);
 
464
                glPopMatrix ();
 
465
        }
 
466
        if (myData.iButton3Count)
 
467
        {
 
468
                glPushMatrix ();
 
469
                glTranslatef (-iWidth/2 + myData.button3coordX, +iHeight/2 - myData.button3coordY, 0.);
 
470
                _cairo_dock_apply_texture_at_size_with_alpha (myData.TextureButton3, myData.button3sizeX, myData.button3sizeY, (double)myData.iButton3Count/NB_TRANSITION_STEP);
 
471
                glPopMatrix ();
 
472
        }
 
473
        if (myData.iButton4Count)
 
474
        {
 
475
                glPushMatrix ();
 
476
                glTranslatef (-iWidth/2 + myData.button4coordX, +iHeight/2 - myData.button4coordY, 0.);
 
477
                _cairo_dock_apply_texture_at_size_with_alpha (myData.TextureButton4, myData.button4sizeX, myData.button4sizeY, (double)myData.iButton4Count/NB_TRANSITION_STEP);
 
478
                glPopMatrix ();
 
479
        }
 
480
        
 
481
        // on determine la transformation pour les OSD.
 
482
        // en majuscule : coordonees initiales.
 
483
        double W = iWidth, H = iHeight;
 
484
        double X1 = 0, Y1 = 0;
 
485
        double X2 = W, Y2 = 0;
 
486
        double X3 = W, Y3 = H;
 
487
        double X4 = 0, Y4 = H;
 
488
        // translation du point P1(0;0)
 
489
        double x1 = myData.ibottomleftX, y1 = myData.ibottomleftY;
 
490
        double t1x = x1 - X1;
 
491
        double t1y = y1 - X1;
 
492
        // translation du point P2(500;0)
 
493
        double x2 = myData.ibottomrightX, y2 = myData.ibottomrightY;
 
494
        double t2x = x2 - X2;
 
495
        double t2y = y2 - Y2;
 
496
        // translation du point P2(500;500)
 
497
        double x3 = myData.itoprightX, y3 = myData.itoprightY;
 
498
        double t3x = x3 - X3;
 
499
        double t3y = y3 - Y3;
 
500
        // translation du point P2(0;500)
 
501
        double x4 = myData.itopleftX, y4 = myData.itopleftY;
 
502
        double t4x = x4 - X4;
 
503
        double t4y = y4 - Y4;
 
504
        
 
505
        double dx1, dy1, dx2, dy2, dx3, dy3, dx4, dy4;  // ponderations.
 
506
        double X, Y;  // coordonnees initiales d'un coin de l'OSD.
 
507
        double u1, v1, u2, v2, u3, v3, u4, v4;  // coordonnees finales des coins de l'OSD.
 
508
        
 
509
        // on dessine les OSD.
 
510
        //if(myData.bIsRunning && myData.iState != 0)
 
511
        {
 
512
                _cairo_dock_set_alpha (1.);
 
513
                if (myData.mouseOnButton1)
 
514
                {
 
515
                        if (myData.playing)
 
516
                        {
 
517
                                _draw_osd (myData.TextureOsdPause, myData.osdPausecoordX, myData.osdPausecoordY, myData.osdPausesizeX, myData.osdPausesizeY);
 
518
                                //g_print ("%.1f;%.1f ; %.1f;%.1f ;%.1f;%.1f ;%.1f;%.1f\n", u1, v1, u2, v2,u3,v3,u4,v4);
 
519
                        }
 
520
                        else
 
521
                        {
 
522
                                _draw_osd (myData.TextureOsdPlay, myData.osdPlaycoordX, myData.osdPlaycoordY, myData.osdPlaysizeX, myData.osdPlaysizeY);
 
523
                                //g_print ("%.1f;%.1f ; %.1f;%.1f ;%.1f;%.1f ;%.1f;%.1f\n", u1, v1, u2, v2,u3,v3,u4,v4);
 
524
                        }
 
525
                }
 
526
                else if (myData.mouseOnButton2)
 
527
                {
 
528
                        _draw_osd (myData.TextureOsdPrev, myData.osdPrevcoordX, myData.osdPrevcoordY, myData.osdPrevsizeX, myData.osdPrevsizeY);
 
529
                }
 
530
                else if (myData.mouseOnButton3)
 
531
                {
 
532
                        _draw_osd (myData.TextureOsdNext, myData.osdNextcoordX, myData.osdNextcoordY, myData.osdNextsizeX, myData.osdNextsizeY);
 
533
                }
 
534
                else if (myData.mouseOnButton4)
 
535
                {
 
536
                        _draw_osd (myData.TextureOsdHome, myData.osdHomecoordX, myData.osdHomecoordY, myData.osdHomesizeX, myData.osdHomesizeY);
 
537
                }
 
538
                else if (! myData.playing)
 
539
                {
 
540
                        _draw_osd (myData.TextureOsdPause, myData.osdPausecoordX, myData.osdPausecoordY, myData.osdPausesizeX, myData.osdPausesizeY);
 
541
                }
 
542
                else if (myData.playing && ! myData.cover_exist)
 
543
                {
 
544
                        _draw_osd (myData.TextureOsdPlay, myData.osdPlaycoordX, myData.osdPlaycoordY, myData.osdPlaysizeX, myData.osdPlaysizeY);
 
545
                }
 
546
        }
 
547
        
 
548
        
 
549
        // on dessine les reflets.
 
550
        _cairo_dock_set_blend_pbuffer ();
 
551
        if (myData.TextureReflect != 0)
 
552
                _cairo_dock_apply_texture_at_size_with_alpha (myData.TextureReflect, iWidth, iHeight, 1.);
 
553
        
 
554
        _cairo_dock_disable_texture ();
 
555
}
 
556
 
 
557
 
 
558
void cd_opengl_render_to_texture (CairoDockModuleInstance *myApplet)
 
559
{
 
560
        int iWidth, iHeight;
 
561
        CD_APPLET_GET_MY_ICON_EXTENT (&iWidth, &iHeight);
 
562
        
 
563
        CD_APPLET_START_DRAWING_MY_ICON_OR_RETURN ();
 
564
        
 
565
        cd_opengl_scene (myApplet, iWidth, iHeight);
 
566
        
 
567
        CD_APPLET_FINISH_DRAWING_MY_ICON;
 
568
}
 
569
 
 
570
 
 
571
int cd_opengl_check_buttons_state (CairoDockModuleInstance *myApplet)
 
572
{       
 
573
        if (myDesklet->iWidth == 0 || myDesklet->iHeight == 0 || myData.numberButtons == 0)  // precaution.
 
574
                return FALSE;
 
575
        
 
576
        //\_________________ On convertit les coordonnees du pointeur dans le referentiel de l'icone.
 
577
        myData.iMouseX = myDesklet->iMouseX - myDesklet->iLeftSurfaceOffset;
 
578
        myData.iMouseY = myDesklet->iMouseY - myDesklet->iTopSurfaceOffset;
 
579
        
 
580
        //\_________________ On teste le survole des differents boutons :
 
581
        // Test du survol button 1 :
 
582
        myData.mouseOnButton1 = (
 
583
                myData.iMouseX > (myData.button1coordX - (myData.button1sizeX/2)) &&
 
584
                myData.iMouseX < (myData.button1coordX + (myData.button1sizeX/2)) && 
 
585
                myData.iMouseY > (myData.button1coordY - (myData.button1sizeY/2)) &&
 
586
                myData.iMouseY < (myData.button1coordY + (myData.button1sizeY/2))
 
587
        );
 
588
        if (myData.numberButtons > 3)
 
589
        {
 
590
                // Test du survol button 4 :
 
591
                myData.mouseOnButton4 = (
 
592
                        myData.iMouseX > (myData.button4coordX - (myData.button4sizeX/2)) &&
 
593
                        myData.iMouseX < (myData.button4coordX + (myData.button4sizeX/2)) && 
 
594
                        myData.iMouseY > (myData.button4coordY - (myData.button4sizeY/2)) &&
 
595
                        myData.iMouseY < (myData.button4coordY + (myData.button4sizeY/2))
 
596
                );
 
597
        }
 
598
        if (myData.numberButtons > 2)
 
599
        {
 
600
                // Test du survol button 3 :
 
601
                myData.mouseOnButton3 = (
 
602
                        myData.iMouseX > (myData.button3coordX - (myData.button3sizeX/2)) &&
 
603
                        myData.iMouseX < (myData.button3coordX + (myData.button3sizeX/2)) && 
 
604
                        myData.iMouseY > (myData.button3coordY - (myData.button3sizeY/2)) &&
 
605
                        myData.iMouseY < (myData.button3coordY + (myData.button3sizeY/2))
 
606
                );
 
607
        }
 
608
        if (myData.numberButtons > 1)
 
609
        {
 
610
                // Test du survol button 2 :
 
611
                myData.mouseOnButton2 = (
 
612
                        myData.iMouseX > (myData.button2coordX - (myData.button2sizeX/2)) &&
 
613
                        myData.iMouseX < (myData.button2coordX + (myData.button2sizeX/2)) && 
 
614
                        myData.iMouseY > (myData.button2coordY - (myData.button2sizeY/2)) &&
 
615
                        myData.iMouseY < (myData.button2coordY + (myData.button2sizeY/2))
 
616
                );
 
617
        }
 
618
        
 
619
        return (myData.mouseOnButton1 << 0) |
 
620
                        (myData.mouseOnButton2 << 1) |
 
621
                        (myData.mouseOnButton3 << 2) |
 
622
                        (myData.mouseOnButton4 << 3);
 
623
}