← Back to branch summary

~ubuntu-branches/ubuntu/precise/cairo-dock/precise-updates

« back to all changes in this revision

Viewing changes to src/gldit/cairo-dock-desklet-factory.c

  • Committer: Package Import Robot
  • Author(s): Matthieu Baerts (matttbe)
  • Date: 2012-02-16 01:08:11 UTC
  • mfrom: (1.1.21)
  • Revision ID: package-import@ubuntu.com-20120216010811-yhscmns26s6ngil8
Tags: 3.0.0.0beta1-0ubuntu1
https://launchpad.net/bugs/932041
* New upstream release. (LP: #932041)
* Upstream (short) ChangeLog:
 - The taskbar has been greatly enhanced.
 - The control of the dock from the keyboard is now very powerful:
  - many shortkeys have been added in different applets
  - you can activate a launcher by pressing a shortkey + its number
  - all shortkeys can now be managed in a single place
     in the configuration window.
 - A new Twitter applet lets you tweet in one click.
 - A new applet to inhibit the screensaver in one click.
 - Cairo-Dock now uses GTK3, for a better integration in a Gnome desktop
 - It's possible to donate to support the project!
 - (...)
* debian/patches:
 - Removed all previous patches (now in upstream)
* debian/rules and debian/control:
 - Added multiarch support
* debian/control:
 - libgtk-3-dev is now needed instead of libgtk2.0-dev
 - libgtkglext1-dev is no longer needed
    (replaced by libgl, libglu and libpango)
 - cairo-dock: increase the version of plug-ins packages
    and added: cairo-dock-plug-ins-dbus-interface-python
 - cairo-dock-dev has been replaced by libgldi-dev
    and dependences have been updated
 - Added a new package (libgldi3) in order to support multiarch
    and to fix this lintian error: package-name-doesnt-match-sonames
* debian/cairo-dock-core.install and debian/libgldi3.install:
 - libgldi3 package has been added
 - It contains the library used by cairo-dock
 - MultiArch is supported
* debian/cairo-dock-dev.install and debian/libgldi-dev.install:
 - cairo-dock-dev has been replaced by libgldi-dev
* Updated debian/watch

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/gldit/cairo-dock-desklet-factory.c
28
28
#include <string.h>
29
29
#include <math.h>
30
30
 
31
 
#include <gtk/gtkgl.h>
32
31
#include <GL/gl.h> 
33
32
#include <GL/glu.h> 
34
33
#include <GL/glx.h> 
35
 
#include <gdk/x11/gdkglx.h>
36
34
 
37
35
#include <gdk/gdkx.h>
38
36
#include "cairo-dock-draw.h"
39
37
#include "cairo-dock-module-factory.h"
 
38
#include "cairo-dock-icon-facility.h"  // cairo_dock_set_icon_container
40
39
#include "cairo-dock-module-manager.h"  // cairo_dock_detach_module_instance
41
40
#include "cairo-dock-dialog-manager.h"
42
41
#include "cairo-dock-icon-factory.h"
43
42
#include "cairo-dock-icon-facility.h"
44
 
#include "cairo-dock-config.h"
 
43
#include "cairo-dock-keyfile-utilities.h"
45
44
#include "cairo-dock-X-manager.h"
46
45
#include "cairo-dock-notifications.h"
47
46
#include "cairo-dock-log.h"
70
69
///////////////
71
70
 
72
71
static gboolean on_expose_desklet(GtkWidget *pWidget,
 
72
#if (GTK_MAJOR_VERSION < 3)
73
73
        GdkEventExpose *pExpose,
 
74
#else
 
75
        cairo_t *ctx,
 
76
#endif
74
77
        CairoDesklet *pDesklet)
75
78
{
76
 
        if (pDesklet->iDesiredWidth != 0 && pDesklet->iDesiredHeight != 0 && (pDesklet->iKnownWidth != pDesklet->iDesiredWidth || pDesklet->iKnownHeight != pDesklet->iDesiredHeight))  // skip the drawing until the desklet has reached its size.
 
79
        if (pDesklet->iDesiredWidth != 0 && pDesklet->iDesiredHeight != 0 && (pDesklet->iKnownWidth != pDesklet->iDesiredWidth || pDesklet->iKnownHeight != pDesklet->iDesiredHeight))  // skip the drawing until the desklet has reached its size, only make it transparent.
77
80
        {
78
81
                //g_print ("on saute le dessin\n");
79
82
                if (g_bUseOpenGL)
80
83
                {
81
 
                        GdkGLContext *pGlContext = gtk_widget_get_gl_context (pDesklet->container.pWidget);
82
 
                        GdkGLDrawable *pGlDrawable = gtk_widget_get_gl_drawable (pDesklet->container.pWidget);
83
 
                        if (!gdk_gl_drawable_gl_begin (pGlDrawable, pGlContext))
 
84
                        if (! gldi_glx_begin_draw_container (CAIRO_CONTAINER (pDesklet)))
84
85
                                return FALSE;
85
86
                        
86
 
                        glClear (GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
87
 
                        glLoadIdentity ();
88
 
                        
89
 
                        cairo_dock_apply_desktop_background_opengl (CAIRO_CONTAINER (pDesklet));
90
 
                        
91
 
                        if (gdk_gl_drawable_is_double_buffered (pGlDrawable))
92
 
                                gdk_gl_drawable_swap_buffers (pGlDrawable);
93
 
                        else
94
 
                                glFlush ();
95
 
                        gdk_gl_drawable_gl_end (pGlDrawable);
 
87
                        gldi_glx_end_draw_container (CAIRO_CONTAINER (pDesklet));
96
88
                }
97
89
                else
98
90
                {
104
96
        
105
97
        if (g_bUseOpenGL && pDesklet->pRenderer && pDesklet->pRenderer->render_opengl)
106
98
        {
107
 
                GdkGLContext *pGlContext = gtk_widget_get_gl_context (pDesklet->container.pWidget);
108
 
                GdkGLDrawable *pGlDrawable = gtk_widget_get_gl_drawable (pDesklet->container.pWidget);
109
 
                if (!gdk_gl_drawable_gl_begin (pGlDrawable, pGlContext))
 
99
                if (! gldi_glx_begin_draw_container (CAIRO_CONTAINER (pDesklet)))
110
100
                        return FALSE;
111
101
                
112
 
                glClear (GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
113
 
                glLoadIdentity ();
114
 
                
115
 
                cairo_dock_apply_desktop_background_opengl (CAIRO_CONTAINER (pDesklet));
116
 
                
117
 
                cairo_dock_notify_on_object (&myDeskletsMgr, NOTIFICATION_RENDER_DESKLET, pDesklet, NULL);
118
 
                cairo_dock_notify_on_object (pDesklet, NOTIFICATION_RENDER_DESKLET, pDesklet, NULL);
119
 
                
120
 
                if (gdk_gl_drawable_is_double_buffered (pGlDrawable))
121
 
                        gdk_gl_drawable_swap_buffers (pGlDrawable);
122
 
                else
123
 
                        glFlush ();
124
 
                gdk_gl_drawable_gl_end (pGlDrawable);
 
102
                cairo_dock_notify_on_object (pDesklet, NOTIFICATION_RENDER, pDesklet, NULL);
 
103
                
 
104
                gldi_glx_end_draw_container (CAIRO_CONTAINER (pDesklet));
125
105
        }
126
106
        else
127
107
        {
128
108
                cairo_t *pCairoContext = cairo_dock_create_drawing_context_on_container (CAIRO_CONTAINER (pDesklet));
129
109
                
130
 
                cairo_dock_notify_on_object (&myDeskletsMgr, NOTIFICATION_RENDER_DESKLET, pDesklet, pCairoContext);
131
 
                cairo_dock_notify_on_object (pDesklet, NOTIFICATION_RENDER_DESKLET, pDesklet, pCairoContext);
 
110
                cairo_dock_notify_on_object (pDesklet, NOTIFICATION_RENDER, pDesklet, pCairoContext);
132
111
                
133
112
                cairo_destroy (pCairoContext);
134
113
        }
138
117
 
139
118
static void _cairo_dock_set_desklet_input_shape (CairoDesklet *pDesklet)
140
119
{
141
 
        gtk_widget_input_shape_combine_mask (pDesklet->container.pWidget,
142
 
                NULL,
143
 
                0,
144
 
                0);
 
120
        gldi_container_set_input_shape (CAIRO_CONTAINER (pDesklet), NULL);
 
121
        
145
122
        if (pDesklet->bNoInput)
146
123
        {
147
 
                GdkBitmap *pShapeBitmap = (GdkBitmap*) gdk_pixmap_new (NULL,
148
 
                        pDesklet->container.iWidth,
149
 
                        pDesklet->container.iHeight,
150
 
                        1);
151
 
                
152
 
                cairo_t *pCairoContext = gdk_cairo_create (pShapeBitmap);
153
 
                cairo_set_source_rgba (pCairoContext, 0.0f, 0.0f, 0.0f, 0.0f);
154
 
                cairo_set_operator (pCairoContext, CAIRO_OPERATOR_SOURCE);
155
 
                cairo_paint (pCairoContext);
156
 
                cairo_set_source_rgba (pCairoContext, 1., 1., 1., 1.);
157
 
                cairo_rectangle (pCairoContext,
 
124
                GldiShape *pShapeBitmap = gldi_container_create_input_shape (CAIRO_CONTAINER (pDesklet),
158
125
                        pDesklet->container.iWidth - myDeskletsParam.iDeskletButtonSize,
159
126
                        pDesklet->container.iHeight - myDeskletsParam.iDeskletButtonSize,
160
127
                        myDeskletsParam.iDeskletButtonSize,
161
128
                        myDeskletsParam.iDeskletButtonSize);
162
 
                cairo_fill (pCairoContext);
163
 
                cairo_destroy (pCairoContext);
164
 
                gtk_widget_input_shape_combine_mask (pDesklet->container.pWidget,
165
 
                        pShapeBitmap,
166
 
                        0,
167
 
                        0);
168
 
                g_object_unref (pShapeBitmap);
169
 
                //g_print ("input shape : %dx%d\n", pDesklet->container.iWidth, pDesklet->container.iHeight);
 
129
                
 
130
                gldi_container_set_input_shape (CAIRO_CONTAINER (pDesklet), pShapeBitmap);
 
131
                
 
132
                gldi_shape_destroy (pShapeBitmap);
170
133
        }
171
134
}
172
135
 
179
142
                        G_TYPE_STRING, "Desklet", "size", cSize,
180
143
                        G_TYPE_INVALID);
181
144
                g_free (cSize);
182
 
                cairo_dock_notify_on_object (&myDeskletsMgr, NOTIFICATION_CONFIGURE_DESKLET, pDesklet);
 
145
                cairo_dock_notify_on_object (pDesklet, NOTIFICATION_CONFIGURE_DESKLET, pDesklet);
183
146
        }
184
147
        pDesklet->iSidWriteSize = 0;
185
148
        pDesklet->iKnownWidth = pDesklet->container.iWidth;
189
152
                pDesklet->iDesiredWidth = 0;
190
153
                pDesklet->iDesiredHeight = 0;
191
154
                
192
 
                cairo_t *pCairoContext = cairo_dock_create_drawing_context_generic (CAIRO_CONTAINER (pDesklet));
193
155
                cairo_dock_load_desklet_decorations (pDesklet);
194
 
                cairo_destroy (pCairoContext);
195
156
                
196
157
                if (pDesklet->pIcon != NULL && pDesklet->pIcon->pModuleInstance != NULL)
197
158
                {
222
183
                                        {
223
184
                                                pIcon->iImageWidth = pIcon->fWidth;
224
185
                                                pIcon->iImageHeight = pIcon->fHeight;
225
 
                                                cairo_dock_trigger_load_icon_buffers (pIcon, CAIRO_CONTAINER (pDesklet));
 
186
                                                cairo_dock_trigger_load_icon_buffers (pIcon);
226
187
                                        }
227
188
                                }
228
189
                                
237
198
                        gtk_widget_queue_draw (pDesklet->container.pWidget);  // sinon on ne redessine que l'interieur.
238
199
                }
239
200
                
240
 
                Window Xid = GDK_WINDOW_XID (pDesklet->container.pWidget->window);
241
201
                if (pDesklet->bSpaceReserved)  // l'espace est reserve, on reserve la nouvelle taille.
242
202
                {
243
203
                        _cairo_dock_reserve_space_for_desklet (pDesklet, TRUE);
257
217
                int iNumDesktop = -1;
258
218
                if (! cairo_dock_desklet_is_sticky (pDesklet))
259
219
                {
260
 
                        GdkWindow *window = pDesklet->container.pWidget->window;
261
 
                        Window Xid = GDK_WINDOW_XID (window);
 
220
                        Window Xid = gldi_container_get_Xid (CAIRO_CONTAINER (pDesklet));
262
221
                        cd_debug ("This window (%d) is not sticky", (int) Xid);
263
222
                        int iDesktop = cairo_dock_get_xwindow_desktop (Xid);
264
223
                        int iGlobalPositionX, iGlobalPositionY, iWidthExtent, iHeightExtent;
291
250
                        G_TYPE_INT, "Desklet", "y position", iRelativePositionY,
292
251
                        G_TYPE_INT, "Desklet", "num desktop", iNumDesktop,
293
252
                        G_TYPE_INVALID);
294
 
                cairo_dock_notify_on_object (&myDeskletsMgr, NOTIFICATION_CONFIGURE_DESKLET, pDesklet);
 
253
                cairo_dock_notify_on_object (pDesklet, NOTIFICATION_CONFIGURE_DESKLET, pDesklet);
295
254
        }
296
255
        
297
256
        if (pDesklet->bSpaceReserved)  // l'espace est reserve, on reserve a la nouvelle position.
314
273
        {
315
274
                if ((pEvent->width < pDesklet->container.iWidth || pEvent->height < pDesklet->container.iHeight) && (pDesklet->iDesiredWidth != 0 && pDesklet->iDesiredHeight != 0))
316
275
                {
317
 
                        gdk_window_resize (pDesklet->container.pWidget->window,
 
276
                        gdk_window_resize (gldi_container_get_gdk_window (CAIRO_CONTAINER (pDesklet)),
318
277
                                pDesklet->iDesiredWidth,
319
278
                                pDesklet->iDesiredHeight);
320
279
                }
324
283
                
325
284
                if (g_bUseOpenGL)
326
285
                {
327
 
                        GdkGLContext* pGlContext = gtk_widget_get_gl_context (pWidget);
328
 
                        GdkGLDrawable* pGlDrawable = gtk_widget_get_gl_drawable (pWidget);
329
286
                        GLsizei w = pEvent->width;
330
287
                        GLsizei h = pEvent->height;
331
 
                        if (!gdk_gl_drawable_gl_begin (pGlDrawable, pGlContext))
 
288
                        
 
289
                        if (! gldi_glx_make_current (CAIRO_CONTAINER (pDesklet)))
332
290
                                return FALSE;
333
291
                        
334
292
                        glViewport(0, 0, w, h);
335
293
                        
336
294
                        cairo_dock_set_perspective_view (CAIRO_CONTAINER (pDesklet));
337
 
                        
338
 
                        gdk_gl_drawable_gl_end (pGlDrawable);
339
295
                }
340
296
                
341
297
                if (pDesklet->bNoInput)
386
342
        if (! (pScroll->state & (GDK_SHIFT_MASK | GDK_CONTROL_MASK)))
387
343
        {
388
344
                Icon *icon = cairo_dock_find_clicked_icon_in_desklet (pDesklet);  // can be NULL
389
 
                cairo_dock_notify_on_object (&myContainersMgr, NOTIFICATION_SCROLL_ICON, icon, pDesklet, pScroll->direction);
390
 
                cairo_dock_notify_on_object (CAIRO_CONTAINER (pDesklet), NOTIFICATION_SCROLL_ICON, icon, pDesklet, pScroll->direction);
 
345
                cairo_dock_notify_on_object (pDesklet, NOTIFICATION_SCROLL_ICON, icon, pDesklet, pScroll->direction);
391
346
        }
392
347
        return FALSE;
393
348
}
397
352
        CairoDesklet *pDesklet)
398
353
{
399
354
        cd_debug ("unmap desklet (bAllowMinimize:%d)\n", pDesklet->bAllowMinimize);
400
 
        Window Xid = GDK_WINDOW_XID (pWidget->window);
 
355
        Window Xid = gldi_container_get_Xid (CAIRO_CONTAINER (pDesklet));
401
356
        if (pDesklet->iVisibility == CAIRO_DESKLET_ON_WIDGET_LAYER)  // on the widget layer, let pass the unmap event..
402
357
        //if (cairo_dock_window_is_utility (Xid))  // sur la couche des widgets, on ne fait rien.
403
358
                return FALSE;
473
428
                                        G_TYPE_INT, "Desklet", "rotation", (int) (pDesklet->fRotation / G_PI * 180.),
474
429
                                        G_TYPE_INVALID);
475
430
                                gtk_widget_queue_draw (pDesklet->container.pWidget);
476
 
                                cairo_dock_notify_on_object (&myDeskletsMgr, NOTIFICATION_CONFIGURE_DESKLET, pDesklet);
 
431
                                cairo_dock_notify_on_object (pDesklet, NOTIFICATION_CONFIGURE_DESKLET, pDesklet);
477
432
                        }
478
433
                        else if (pDesklet->retaching)
479
434
                        {
501
456
                                                G_TYPE_INVALID);
502
457
                                        _cairo_dock_set_desklet_input_shape (pDesklet);
503
458
                                        gtk_widget_queue_draw (pDesklet->container.pWidget);
504
 
                                        if (pDesklet->bNoInput)
505
 
                                                cairo_dock_allow_widget_to_receive_data (pDesklet->container.pWidget, G_CALLBACK (on_drag_data_received_desklet), pDesklet);
 
459
                                        /**if (pDesklet->bNoInput)
 
460
                                                gldi_container_enable_drop (CAIRO_CONTAINER (pDesklet), G_CALLBACK (on_drag_data_received_desklet), pDesklet);
506
461
                                        else
507
 
                                                cairo_dock_disallow_widget_to_receive_data (pDesklet->container.pWidget);
 
462
                                                gldi_container_disable_drop (CAIRO_CONTAINER (pDesklet));*/
508
463
                                }
509
464
                        }
510
465
                        else if (pDesklet->rotatingY)
526
481
                        else
527
482
                        {
528
483
                                Icon *pClickedIcon = cairo_dock_find_clicked_icon_in_desklet (pDesklet);
529
 
                                cairo_dock_notify_on_object (&myContainersMgr, NOTIFICATION_CLICK_ICON, pClickedIcon, pDesklet, pButton->state);
530
 
                                cairo_dock_notify_on_object (CAIRO_CONTAINER (pDesklet), NOTIFICATION_CLICK_ICON, pClickedIcon, pDesklet, pButton->state);
 
484
                                cairo_dock_notify_on_object (pDesklet, NOTIFICATION_CLICK_ICON, pClickedIcon, pDesklet, pButton->state);
531
485
                        }
532
486
                        // prudence.
533
487
                        pDesklet->rotating = FALSE;
541
495
                        if (! (pButton->x < myDeskletsParam.iDeskletButtonSize && pButton->y < myDeskletsParam.iDeskletButtonSize) && ! (pButton->x > (pDesklet->container.iWidth - myDeskletsParam.iDeskletButtonSize)/2 && pButton->x < (pDesklet->container.iWidth + myDeskletsParam.iDeskletButtonSize)/2 && pButton->y < myDeskletsParam.iDeskletButtonSize))
542
496
                        {
543
497
                                Icon *pClickedIcon = cairo_dock_find_clicked_icon_in_desklet (pDesklet);  // can be NULL
544
 
                                cairo_dock_notify_on_object (&myContainersMgr, NOTIFICATION_DOUBLE_CLICK_ICON, pClickedIcon, pDesklet);
545
 
                                cairo_dock_notify_on_object (CAIRO_CONTAINER (pDesklet), NOTIFICATION_DOUBLE_CLICK_ICON, pClickedIcon, pDesklet);
 
498
                                cairo_dock_notify_on_object (pDesklet, NOTIFICATION_DOUBLE_CLICK_ICON, pClickedIcon, pDesklet);
546
499
                        }
547
500
                }
548
501
        }
563
516
                        cairo_dock_update_conf_file (pDesklet->pIcon->pModuleInstance->cConfFilePath,
564
517
                                G_TYPE_INT, "Desklet", "rotation", 0,
565
518
                                G_TYPE_INVALID);
566
 
                        cairo_dock_notify_on_object (&myDeskletsMgr, NOTIFICATION_CONFIGURE_DESKLET, pDesklet);
 
519
                        cairo_dock_notify_on_object (pDesklet, NOTIFICATION_CONFIGURE_DESKLET, pDesklet);
567
520
                }
568
521
                else if (pButton->x > (pDesklet->container.iWidth - myDeskletsParam.iDeskletButtonSize)/2 && pButton->x < (pDesklet->container.iWidth + myDeskletsParam.iDeskletButtonSize)/2 && pButton->y < myDeskletsParam.iDeskletButtonSize)
569
522
                {
583
536
                }
584
537
                else
585
538
                {
586
 
                        cairo_dock_notify_on_object (&myContainersMgr, NOTIFICATION_MIDDLE_CLICK_ICON, pDesklet->pIcon, pDesklet);
587
 
                        cairo_dock_notify_on_object (CAIRO_CONTAINER (pDesklet), NOTIFICATION_MIDDLE_CLICK_ICON, pDesklet->pIcon, pDesklet);
 
539
                        cairo_dock_notify_on_object (pDesklet, NOTIFICATION_MIDDLE_CLICK_ICON, pDesklet->pIcon, pDesklet);
588
540
                }
589
541
        }
590
542
        return FALSE;
595
547
        //g_print ("%s (%dx%d)\n", __func__, x, y);
596
548
        
597
549
        //\_________________ On recupere l'URI.
598
 
        gchar *cReceivedData = (gchar *) selection_data->data;  // gtk_selection_data_get_text
 
550
        gchar *cReceivedData = (gchar *) gtk_selection_data_get_text (selection_data);
599
551
        g_return_if_fail (cReceivedData != NULL);
600
552
        int length = strlen (cReceivedData);
601
553
        if (cReceivedData[length-1] == '\n')
622
574
                pDesklet->container.iMouseX = pMotion->x;
623
575
                pDesklet->container.iMouseY = pMotion->y;
624
576
                gboolean bStartAnimation = FALSE;
625
 
                cairo_dock_notify_on_object (&myContainersMgr, NOTIFICATION_MOUSE_MOVED, pDesklet, &bStartAnimation);
626
 
                cairo_dock_notify_on_object (CAIRO_CONTAINER (pDesklet), NOTIFICATION_MOUSE_MOVED, pDesklet, &bStartAnimation);
 
577
                cairo_dock_notify_on_object (pDesklet, NOTIFICATION_MOUSE_MOVED, pDesklet, &bStartAnimation);
627
578
                if (bStartAnimation)
628
579
                        cairo_dock_launch_animation (CAIRO_CONTAINER (pDesklet));
629
580
        }
671
622
                                pIcon->bPointed = TRUE;
672
623
                                
673
624
                                //g_print ("on survole %s\n", pIcon->cName);
674
 
                                cairo_dock_notify_on_object (&myContainersMgr, NOTIFICATION_ENTER_ICON, pIcon, pDesklet, &bStartAnimation);
675
 
                                cairo_dock_notify_on_object (CAIRO_CONTAINER (pDesklet), NOTIFICATION_ENTER_ICON, pIcon, pDesklet, &bStartAnimation);
 
625
                                cairo_dock_notify_on_object (pDesklet, NOTIFICATION_ENTER_ICON, pIcon, pDesklet, &bStartAnimation);
676
626
                        }
677
627
                }
678
628
                else
683
633
                                pPointedIcon->bPointed = FALSE;
684
634
                                
685
635
                                //g_print ("kedal\n");
686
 
                                cairo_dock_notify_on_object (&myContainersMgr, NOTIFICATION_ENTER_ICON, pPointedIcon, pDesklet, &bStartAnimation);
687
 
                                cairo_dock_notify_on_object (CAIRO_CONTAINER (pDesklet), NOTIFICATION_ENTER_ICON, pPointedIcon, pDesklet, &bStartAnimation);
 
636
                                cairo_dock_notify_on_object (pDesklet, NOTIFICATION_ENTER_ICON, pPointedIcon, pDesklet, &bStartAnimation);
688
637
                        }
689
638
                }
690
639
                if (bStartAnimation)
716
665
                pDesklet->container.bInside = TRUE;
717
666
                gtk_widget_queue_draw (pWidget);  // redessin des boutons.
718
667
                
719
 
                ///if (g_bUseOpenGL)
720
 
                {
721
 
                        gboolean bStartAnimation = FALSE;
722
 
                        cairo_dock_notify_on_object (&myDeskletsMgr, NOTIFICATION_ENTER_DESKLET, pDesklet, &bStartAnimation);
723
 
                        cairo_dock_notify_on_object (pDesklet, NOTIFICATION_ENTER_DESKLET, pDesklet, &bStartAnimation);
724
 
                        if (bStartAnimation)
725
 
                                cairo_dock_launch_animation (CAIRO_CONTAINER (pDesklet));
726
 
                }
 
668
                gboolean bStartAnimation = FALSE;
 
669
                cairo_dock_notify_on_object (pDesklet, NOTIFICATION_ENTER_DESKLET, pDesklet, &bStartAnimation);
 
670
                if (bStartAnimation)
 
671
                        cairo_dock_launch_animation (CAIRO_CONTAINER (pDesklet));
727
672
        }
728
673
        return FALSE;
729
674
}
733
678
{
734
679
        //g_print ("%s (%d)\n", __func__, pDesklet->container.bInside);
735
680
        int iMouseX, iMouseY;
736
 
        gdk_window_get_pointer (pWidget->window, &iMouseX, &iMouseY, NULL);
 
681
        GdkWindow *window = gldi_container_get_gdk_window (CAIRO_CONTAINER (pDesklet));
 
682
        gdk_window_get_pointer (window, &iMouseX, &iMouseY, NULL);
737
683
        if (gtk_bin_get_child (GTK_BIN (pDesklet->container.pWidget)) != NULL && iMouseX > 0 && iMouseX < pDesklet->container.iWidth && iMouseY > 0 && iMouseY < pDesklet->container.iHeight)  // en fait on est dans un widget fils, donc on ne fait rien.
738
684
        {
739
685
                return FALSE;
743
689
        gtk_widget_queue_draw (pWidget);  // redessin des boutons.
744
690
        
745
691
        gboolean bStartAnimation = FALSE;
746
 
        cairo_dock_notify_on_object (&myDeskletsMgr, NOTIFICATION_LEAVE_DESKLET, pDesklet, &bStartAnimation);
747
692
        cairo_dock_notify_on_object (pDesklet, NOTIFICATION_LEAVE_DESKLET, pDesklet, &bStartAnimation);
748
693
        if (bStartAnimation)
749
694
                cairo_dock_launch_animation (CAIRO_CONTAINER (pDesklet));
756
701
 /// FACTORY ///
757
702
///////////////
758
703
 
759
 
static void _cairo_dock_set_icon_size (CairoContainer *pContainer, Icon *icon)
 
704
 
 
705
static gboolean _cairo_desklet_animation_loop (CairoContainer *pContainer)
760
706
{
761
707
        CairoDesklet *pDesklet = CAIRO_DESKLET (pContainer);
762
 
        /**if (pDesklet->pRenderer && pDesklet->pRenderer->set_icon_size)
763
 
                pDesklet->pRenderer->set_icon_size (pDesklet, icon);*/
 
708
        gboolean bContinue = FALSE;
 
709
        gboolean bUpdateSlowAnimation = FALSE;
 
710
        pContainer->iAnimationStep ++;
 
711
        if (pContainer->iAnimationStep * pContainer->iAnimationDeltaT >= CAIRO_DOCK_MIN_SLOW_DELTA_T)
 
712
        {
 
713
                bUpdateSlowAnimation = TRUE;
 
714
                pContainer->iAnimationStep = 0;
 
715
                pContainer->bKeepSlowAnimation = FALSE;
 
716
        }
 
717
        
 
718
        if (pDesklet->pIcon != NULL)
 
719
        {
 
720
                gboolean bIconIsAnimating = FALSE;
 
721
                
 
722
                if (bUpdateSlowAnimation)
 
723
                {
 
724
                        cairo_dock_notify_on_object (pDesklet->pIcon, NOTIFICATION_UPDATE_ICON_SLOW, pDesklet->pIcon, pDesklet, &bIconIsAnimating);
 
725
                        pDesklet->container.bKeepSlowAnimation |= bIconIsAnimating;
 
726
                }
 
727
                
 
728
                cairo_dock_notify_on_object (pDesklet->pIcon, NOTIFICATION_UPDATE_ICON, pDesklet->pIcon, pDesklet, &bIconIsAnimating);
 
729
                if (! bIconIsAnimating)
 
730
                        pDesklet->pIcon->iAnimationState = CAIRO_DOCK_STATE_REST;
 
731
                else
 
732
                        bContinue = TRUE;
 
733
        }
 
734
        
 
735
        if (bUpdateSlowAnimation)
 
736
        {
 
737
                cairo_dock_notify_on_object (pDesklet, NOTIFICATION_UPDATE_SLOW, pDesklet, &pContainer->bKeepSlowAnimation);
 
738
        }
 
739
        
 
740
        cairo_dock_notify_on_object (pDesklet, NOTIFICATION_UPDATE, pDesklet, &bContinue);
 
741
        
 
742
        if (! bContinue && ! pContainer->bKeepSlowAnimation)
 
743
        {
 
744
                pContainer->iSidGLAnimation = 0;
 
745
                return FALSE;
 
746
        }
 
747
        else
 
748
                return TRUE;
764
749
}
765
750
 
766
751
CairoDesklet *cairo_dock_new_desklet (void)
773
758
        pDesklet->container.fRatio = 1;
774
759
        pDesklet->container.fRatio = 1;
775
760
        
776
 
        pDesklet->container.iface.set_icon_size = _cairo_dock_set_icon_size;
 
761
        pDesklet->container.iface.animation_loop = _cairo_desklet_animation_loop;
777
762
        
778
763
        GtkWidget* pWindow = cairo_dock_init_container (CAIRO_CONTAINER (pDesklet));
779
 
        cairo_dock_install_notifications_on_object (pDesklet, NB_NOTIFICATIONS_DESKLET);
 
764
        gldi_object_set_manager (GLDI_OBJECT (pDesklet), GLDI_MANAGER (&myDeskletsMgr));
780
765
        
781
766
        gtk_window_set_title (GTK_WINDOW(pWindow), "cairo-dock-desklet");
782
767
        gtk_widget_add_events( pWindow, GDK_BUTTON_PRESS_MASK | GDK_BUTTON_RELEASE_MASK | GDK_POINTER_MOTION_MASK | GDK_POINTER_MOTION_HINT_MASK | GDK_FOCUS_CHANGE_MASK);
784
769
        gtk_window_set_default_size(GTK_WINDOW(pWindow), 10, 10);  // idem.
785
770
 
786
771
        g_signal_connect (G_OBJECT (pWindow),
 
772
                #if (GTK_MAJOR_VERSION < 3)
787
773
                "expose-event",
 
774
                #else
 
775
                "draw",
 
776
                #endif
788
777
                G_CALLBACK (on_expose_desklet),
789
778
                pDesklet);
790
779
        g_signal_connect (G_OBJECT (pWindow),
827
816
                "scroll-event",
828
817
                G_CALLBACK (on_scroll_desklet),
829
818
                pDesklet);
830
 
        cairo_dock_allow_widget_to_receive_data (pWindow, G_CALLBACK (on_drag_data_received_desklet), pDesklet);
 
819
        gldi_container_enable_drop (CAIRO_CONTAINER (pDesklet), G_CALLBACK (on_drag_data_received_desklet), pDesklet);
831
820
        
832
821
        gtk_widget_show_all (pWindow);
833
822
        
843
832
                g_source_remove (pDesklet->iSidWriteSize);
844
833
        if (pDesklet->iSidWritePosition != 0)
845
834
                g_source_remove (pDesklet->iSidWritePosition);
846
 
        cairo_dock_notify_on_object (&myDeskletsMgr, NOTIFICATION_STOP_DESKLET, pDesklet);
847
 
        cairo_dock_notify_on_object (pDesklet, NOTIFICATION_STOP_DESKLET, pDesklet);
848
835
        
849
836
        cairo_dock_steal_interactive_widget_from_desklet (pDesklet);
850
837
 
851
 
        cairo_dock_finish_container (CAIRO_CONTAINER (pDesklet));
 
838
        cairo_dock_finish_container (CAIRO_CONTAINER (pDesklet));  // -> NOTIFICATION_DESTROY
852
839
        
853
840
        if (pDesklet->pRenderer != NULL)
854
841
        {
882
869
        {
883
870
                pDesklet->iDesiredWidth = pAttribute->iDeskletWidth;
884
871
                pDesklet->iDesiredHeight = pAttribute->iDeskletHeight;
885
 
                gdk_window_resize (pDesklet->container.pWidget->window,
 
872
                gdk_window_resize (gldi_container_get_gdk_window (CAIRO_CONTAINER (pDesklet)),
886
873
                        pAttribute->iDeskletWidth,
887
874
                        pAttribute->iDeskletHeight);
888
875
        }
898
885
        iAbsolutePositionY = MAX (0, MIN (g_desktopGeometry.iXScreenHeight[CAIRO_DOCK_HORIZONTAL] - pAttribute->iDeskletHeight, iAbsolutePositionY));
899
886
        
900
887
        if (pAttribute->bOnAllDesktops)
901
 
                gdk_window_move(pDesklet->container.pWidget->window,
 
888
                gdk_window_move (gldi_container_get_gdk_window (CAIRO_CONTAINER (pDesklet)),
902
889
                        iAbsolutePositionX,
903
890
                        iAbsolutePositionY);
904
891
        //g_print (" let's place the deklet at (%d;%d)", iAbsolutePositionX, iAbsolutePositionY);
912
899
        else
913
900
        {
914
901
                gtk_window_unstick (GTK_WINDOW (pDesklet->container.pWidget));
915
 
                Window Xid = GDK_WINDOW_XID (pDesklet->container.pWidget->window);
 
902
                Window Xid = gldi_container_get_Xid (CAIRO_CONTAINER (pDesklet));
916
903
                if (g_desktopGeometry.iNbViewportX > 0 && g_desktopGeometry.iNbViewportY > 0)
917
904
                {
918
905
                        int iNumDesktop, iNumViewportX, iNumViewportY;
934
921
        }
935
922
        pDesklet->bPositionLocked = pAttribute->bPositionLocked;
936
923
        pDesklet->bNoInput = pAttribute->bNoInput;
937
 
        if (pDesklet->bNoInput)
938
 
                cairo_dock_disallow_widget_to_receive_data (pDesklet->container.pWidget);
 
924
        /**if (pDesklet->bNoInput)
 
925
                gldi_container_disable_drop (CAIRO_CONTAINER (pDesklet));*/
939
926
        pDesklet->fRotation = pAttribute->iRotation / 180. * G_PI ;
940
927
        pDesklet->fDepthRotationY = pAttribute->iDepthRotationY / 180. * G_PI ;
941
928
        pDesklet->fDepthRotationX = pAttribute->iDepthRotationX / 180. * G_PI ;
950
937
        //cd_debug ("%s (%dx%d ; %d)", __func__, pDesklet->iDesiredWidth, pDesklet->iDesiredHeight, pDesklet->iSidWriteSize);
951
938
        if (pDesklet->iDesiredWidth == 0 && pDesklet->iDesiredHeight == 0 && pDesklet->iSidWriteSize == 0)
952
939
        {
953
 
                cairo_t *pCairoContext = cairo_dock_create_drawing_context_generic (CAIRO_CONTAINER (pDesklet));
954
940
                cairo_dock_load_desklet_decorations (pDesklet);
955
 
                cairo_destroy (pCairoContext);
956
941
        }
957
942
}
958
943
 
1028
1013
        }
1029
1014
        
1030
1015
        //gtk_container_add (GTK_CONTAINER (pDesklet->container.pWidget), pInteractiveWidget);
1031
 
        GtkWidget *pHBox = gtk_hbox_new (FALSE, 0);
 
1016
        GtkWidget *pHBox = _gtk_hbox_new (0);
1032
1017
        gtk_container_add (GTK_CONTAINER (pDesklet->container.pWidget), pHBox);
1033
1018
        
1034
1019
        gtk_box_pack_start (GTK_BOX (pHBox), pInteractiveWidget, TRUE, TRUE, 0);
1036
1021
        
1037
1022
        if (iRightMargin != 0)
1038
1023
        {
1039
 
                GtkWidget *pMarginBox = gtk_vbox_new (FALSE, 0);
1040
 
                gtk_widget_set (pMarginBox, "width-request", iRightMargin, NULL);
 
1024
                GtkWidget *pMarginBox = _gtk_vbox_new (0);
 
1025
                g_object_set (pMarginBox, "width-request", iRightMargin, NULL);
1041
1026
                gtk_box_pack_start (GTK_BOX (pHBox), pMarginBox, FALSE, FALSE, 0);  // a tester ...
1042
1027
        }
1043
1028
        
1057
1042
                        if (pChildList->next != NULL)
1058
1043
                        {
1059
1044
                                GtkWidget *pMarginBox = GTK_WIDGET (pChildList->next->data);
1060
 
                                gtk_widget_set (pMarginBox, "width-request", iRightMargin, NULL);
 
1045
                                g_object_set (pMarginBox, "width-request", iRightMargin, NULL);
1061
1046
                        }
1062
1047
                        else  // on rajoute le widget de la marge.
1063
1048
                        {
1064
 
                                GtkWidget *pMarginBox = gtk_vbox_new (FALSE, 0);
1065
 
                                gtk_widget_set (pMarginBox, "width-request", iRightMargin, NULL);
 
1049
                                GtkWidget *pMarginBox = _gtk_vbox_new (0);
 
1050
                                g_object_set (pMarginBox, "width-request", iRightMargin, NULL);
1066
1051
                                gtk_box_pack_start (GTK_BOX (pHBox), pMarginBox, FALSE, FALSE, 0);
1067
1052
                        }
1068
1053
                        g_list_free (pChildList);
1118
1103
static void _cairo_dock_reserve_space_for_desklet (CairoDesklet *pDesklet, gboolean bReserve)
1119
1104
{
1120
1105
        cd_debug ("%s (%d)\n", __func__, bReserve);
1121
 
        Window Xid = GDK_WINDOW_XID (pDesklet->container.pWidget->window);
 
1106
        Window Xid = gldi_container_get_Xid (CAIRO_CONTAINER (pDesklet));
1122
1107
        int left=0, right=0, top=0, bottom=0;
1123
1108
        int left_start_y=0, left_end_y=0, right_start_y=0, right_end_y=0, top_start_x=0, top_end_x=0, bottom_start_x=0, bottom_end_x=0;
1124
1109
        int iHeight = pDesklet->container.iHeight, iWidth = pDesklet->container.iWidth;
1170
1155
        
1171
1156
        gtk_window_set_keep_above (GTK_WINDOW (pDesklet->container.pWidget), iVisibility == CAIRO_DESKLET_KEEP_ABOVE);
1172
1157
 
1173
 
        Window Xid = GDK_WINDOW_XID (pDesklet->container.pWidget->window);
 
1158
        Window Xid = gldi_container_get_Xid (CAIRO_CONTAINER (pDesklet));
1174
1159
        cairo_dock_wm_set_on_widget_layer (Xid, iVisibility == CAIRO_DESKLET_ON_WIDGET_LAYER);
1175
1160
        
1176
1161
        if (iVisibility == CAIRO_DESKLET_RESERVE_SPACE)
1222
1207
 
1223
1208
gboolean cairo_dock_desklet_is_sticky (CairoDesklet *pDesklet)
1224
1209
{
1225
 
        GdkWindow *window = pDesklet->container.pWidget->window;
1226
 
        #if (GDK_MAJOR_VERSION >= 3)
1227
 
        return (window->state & GDK_WINDOW_STATE_STICKY);  // API change: http://mail.gnome.org/archives/commits-list/2010-July/msg00002.html
 
1210
        GdkWindow *window = gldi_container_get_gdk_window (CAIRO_CONTAINER (pDesklet));
 
1211
        #if (GTK_MAJOR_VERSION >= 3)
 
1212
        return ((gdk_window_get_state (window)) & GDK_WINDOW_STATE_STICKY);
1228
1213
        #else
1229
1214
        return (((GdkWindowObject*) window)->state & GDK_WINDOW_STATE_STICKY);
1230
1215
        #endif
1263
1248
                {
1264
1249
                        pIcon->iImageWidth = pIcon->fWidth;
1265
1250
                        pIcon->iImageHeight = pIcon->fHeight;
1266
 
                        cairo_dock_trigger_load_icon_buffers (pIcon, CAIRO_CONTAINER (pDesklet));
 
1251
                        cairo_dock_trigger_load_icon_buffers (pIcon);
1267
1252
                }
1268
1253
        }
1269
1254
        
1281
1266
        pDesklet->icons = g_list_insert_sorted (pDesklet->icons,
1282
1267
                icon,
1283
1268
                (GCompareFunc)cairo_dock_compare_icons_order);
1284
 
        icon->pContainerForLoad = CAIRO_CONTAINER (pDesklet);
 
1269
        cairo_dock_set_icon_container (icon, pDesklet);
1285
1270
        
1286
1271
        // calculate icons
1287
1272
        cairo_dock_update_desklet_icons (pDesklet);
1299
1284
        // remove icon
1300
1285
        pDesklet->icons = g_list_delete_link (pDesklet->icons, ic);
1301
1286
        ic =  NULL;
1302
 
        icon->pContainerForLoad = NULL;
 
1287
        cairo_dock_set_icon_container (icon, NULL);
1303
1288
        
1304
1289
        // calculate icons
1305
1290
        cairo_dock_update_desklet_icons (pDesklet);