← Back to branch summary

~ubuntu-branches/ubuntu/oneiric/cairo-dock/oneiric-201106091216

« back to all changes in this revision

Viewing changes to src/cairo-dock-menu.c

  • Committer: Bazaar Package Importer
  • Author(s): Matthieu Baerts (matttbe)
  • Date: 2010-08-09 23:26:12 UTC
  • mfrom: (1.1.10 upstream)
  • Revision ID: james.westby@ubuntu.com-20100809232612-yp4c6ig3jt1bzpdv
Tags: 2.2.0~0beta4-0ubuntu1
https://launchpad.net/bugs/614624
https://launchpad.net/bugs/518453
https://launchpad.net/bugs/521369
https://launchpad.net/bugs/521762
https://launchpad.net/bugs/526466
https://launchpad.net/bugs/535083
* New Upstream Version (LP: #614624)
* Fixed a few bugs on LP:
 - LP: #518453: Dock appears under all windows
                 (Compiz - fullscreen window)
 - LP: #521369: Separator are not removed when closing
                 grouped windows
 - LP: #521762: Some sentences are not correct
 - LP: #526466: Icons of apps with same class shouldn't
                 be stacked by default
 - LP: #535083: Dialogues looks ugly when a lot of them
                 appears at the same time
 - More details on the 'ChangeLog' file
* debian/rules:
 - Autotools has been replaced by CMake
 - Man pages are now included in the source code
* debian/copyright:
 - Updated with the new pathes and new files
* debian/control:
 - Autotools has been replaced by CMake
 - Added libcurl4-gnutls-dev as Build-deps
 - Bump Standard-Version to 3.9.1
* debian/cairo-dock-core.install:
 - Man pages are now included in the source code
 - All sonames are now installed into lib32 or lib64
* debian/cairo-dock-dev.install:
 - pkgconfig is now installed into lib32 or lib64

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/cairo-dock-menu.c
29
29
#include <glib/gstdio.h>
30
30
#include <gdk/gdkx.h>
31
31
 
 
32
#include "config.h"
32
33
#include "cairo-dock-config.h"
33
34
#include "cairo-dock-draw.h"
34
35
#include "cairo-dock-animations.h"
36
37
#include "cairo-dock-icons.h"
37
38
#include "cairo-dock-callbacks.h"
38
39
#include "cairo-dock-applications-manager.h"
 
40
#include "cairo-dock-application-facility.h"
39
41
#include "cairo-dock-desktop-file-factory.h"
40
 
#include "cairo-dock-launcher-factory.h"
 
42
#include "cairo-dock-launcher-manager.h"
41
43
#include "cairo-dock-modules.h"
42
44
#include "cairo-dock-dock-factory.h"
43
45
#include "cairo-dock-dock-facility.h"
44
46
#include "cairo-dock-themes-manager.h"
 
47
#include "cairo-dock-gui-themes.h"
45
48
#include "cairo-dock-notifications.h"
46
 
#include "cairo-dock-dialogs.h"
 
49
#include "cairo-dock-dialog-manager.h"
47
50
#include "cairo-dock-file-manager.h"
48
51
#include "cairo-dock-log.h"
49
 
#include "cairo-dock-desklet.h"
 
52
#include "cairo-dock-desklet-factory.h"
50
53
#include "cairo-dock-X-utilities.h"
51
54
#include "cairo-dock-dock-manager.h"
52
55
#include "cairo-dock-class-manager.h"
53
56
#include "cairo-dock-gui-factory.h"
54
57
#include "cairo-dock-gui-manager.h"
55
58
#include "cairo-dock-internal-accessibility.h"
 
59
#include "cairo-dock-internal-taskbar.h"
56
60
#include "cairo-dock-internal-icons.h"
57
61
#include "cairo-dock-container.h"
58
62
#include "cairo-dock-keyfile-utilities.h"
59
 
#include "cairo-dock-renderer-manager.h"
 
63
#include "cairo-dock-backends-manager.h"
 
64
#include "cairo-dock-X-manager.h"
60
65
#include "cairo-dock-menu.h"
61
66
 
62
 
#define CAIRO_DOCK_CONF_PANEL_WIDTH 800
 
67
#define CAIRO_DOCK_CONF_PANEL_WIDTH 1000
63
68
#define CAIRO_DOCK_CONF_PANEL_HEIGHT 600
64
69
#define CAIRO_DOCK_LAUNCHER_PANEL_WIDTH 600
65
70
#define CAIRO_DOCK_LAUNCHER_PANEL_HEIGHT 350
69
74
#define CAIRO_DOCK_PLUGINS_EXTRAS_URL "http://www.glx-dock.org/mc_album.php?a=4"
70
75
 
71
76
extern CairoDock *g_pMainDock;
 
77
extern CairoDockDesktopGeometry g_desktopGeometry;
72
78
 
73
79
extern gchar *g_cConfFile;
74
80
extern gchar *g_cCurrentLaunchersPath;
75
81
extern gchar *g_cCurrentThemePath;
76
 
extern gchar *g_cCairoDockDataDir;
 
82
extern gchar *g_cCurrentIconsPath;
77
83
 
78
 
extern int g_iNbDesktops;
79
 
extern int g_iNbViewportX,g_iNbViewportY ;
80
 
extern int g_iXScreenWidth[2], g_iXScreenHeight[2];  // change tous les g_iScreen par g_iXScreen le 28/07/2009
81
84
extern gboolean g_bLocked;
82
85
extern gboolean g_bForceCairo;
83
86
extern gboolean g_bEasterEggs;
91
94
        cairo_dock_show_main_gui ();
92
95
}
93
96
 
94
 
static void _cairo_dock_configure_root_dock_position (GtkMenuItem *pMenuItem, CairoDock *pDock)
 
97
static GtkWidget *s_pRootDockConfigWindow = NULL;
 
98
static gboolean on_apply_config_root_dock (const gchar *cDockName)
 
99
{
 
100
        CairoDock *pDock = cairo_dock_search_dock_from_name (cDockName);
 
101
        cairo_dock_reload_one_root_dock (cDockName, pDock);
 
102
        return FALSE;  // FALSE <=> ne pas recharger.
 
103
}
 
104
static void on_destroy_root_dock (gchar *cInitConfFile)
 
105
{
 
106
        s_pRootDockConfigWindow = NULL;
 
107
}
 
108
static void _cairo_dock_configure_root_dock (GtkMenuItem *pMenuItem, CairoDock *pDock)
95
109
{
96
110
        g_return_if_fail (pDock->iRefCount == 0 && ! pDock->bIsMainDock);
97
111
        
107
121
                g_free (cCommand);
108
122
        }
109
123
        
110
 
        gchar *cTitle = g_strdup_printf (_("Set position for the dock '%s'"), cDockName);
111
 
        gboolean config_ok = cairo_dock_build_generic_gui (cConfFilePath, NULL, cTitle, CAIRO_DOCK_CONF_PANEL_WIDTH, CAIRO_DOCK_CONF_PANEL_HEIGHT, NULL, NULL, NULL, NULL);
 
124
        if (s_pRootDockConfigWindow != NULL)
 
125
                gtk_widget_destroy (s_pRootDockConfigWindow);
 
126
        
 
127
        gchar *cTitle = g_strdup_printf (_("Configuration of the '%s' dock"), cDockName);
 
128
        s_pRootDockConfigWindow = cairo_dock_build_generic_gui (cConfFilePath,
 
129
                NULL,
 
130
                cTitle,
 
131
                CAIRO_DOCK_CONF_PANEL_WIDTH, CAIRO_DOCK_CONF_PANEL_HEIGHT,
 
132
                (CairoDockApplyConfigFunc) on_apply_config_root_dock,
 
133
                (gpointer)cDockName,
 
134
                (GFreeFunc) on_destroy_root_dock);
112
135
        g_free (cTitle);
113
136
        
114
 
        if (config_ok)
115
 
        {
116
 
                cairo_dock_get_root_dock_position (cDockName, pDock);
117
 
                
118
 
                cairo_dock_load_buffers_in_one_dock (pDock);  // recharge les icones et les applets.
119
 
                cairo_dock_synchronize_sub_docks_position (pDock, TRUE);
120
 
                
121
 
                cairo_dock_set_default_renderer (pDock);
122
 
                cairo_dock_update_dock_size (pDock);
123
 
                cairo_dock_calculate_dock_icons (pDock);
124
 
                
125
 
                cairo_dock_place_root_dock (pDock);
126
 
                if (myAccessibility.bReserveSpace)
127
 
                        cairo_dock_reserve_space_for_dock (pDock, TRUE);
128
 
                gtk_widget_queue_draw (pDock->container.pWidget);
129
 
        }
130
 
        
131
137
        g_free (cConfFilePath);
132
138
}
133
139
 
197
203
        GtkWidget *pLink = gtk_link_button_new_with_label (CAIRO_DOCK_SITE_URL, "Cairo-Dock (2007-2010)\n version "CAIRO_DOCK_VERSION);
198
204
        gtk_box_pack_start (GTK_BOX (pVBox), pLink, FALSE, FALSE, 0);
199
205
        
200
 
        pLink = gtk_link_button_new_with_label (CAIRO_DOCK_FORUM_URL, _("Community's site"));
201
 
        gtk_widget_set_tooltip_text (pLink, _("A problem ? A suggestion ? Want to talk to us ? You're welcome !"));
 
206
        pLink = gtk_link_button_new_with_label (CAIRO_DOCK_FORUM_URL, _("Community site"));
 
207
        gtk_widget_set_tooltip_text (pLink, _("Problems? Suggestions? Just want to talk to us? Come on over!"));
202
208
        gtk_box_pack_start (GTK_BOX (pVBox), pLink, FALSE, FALSE, 0);
203
209
        
204
 
        pLink = gtk_link_button_new_with_label (CAIRO_DOCK_FILE_HOST_URL, _("Development's site"));
205
 
        gtk_widget_set_tooltip_text (pLink, _("Find out the latest version of Cairo-Dock here !."));
 
210
        pLink = gtk_link_button_new_with_label (CAIRO_DOCK_FILE_HOST_URL, _("Development site"));
 
211
        gtk_widget_set_tooltip_text (pLink, _("Find the latest version of Cairo-Dock here !"));
206
212
        gtk_box_pack_start (GTK_BOX (pVBox), pLink, FALSE, FALSE, 0);
207
213
        
208
214
        pLink = gtk_link_button_new_with_label (CAIRO_DOCK_PLUGINS_EXTRAS_URL, _("Cairo-Dock-Plug-ins-Extras"));
209
 
        gtk_widget_set_tooltip_text (pLink, _("Get more applets !"));
 
215
        gtk_widget_set_tooltip_text (pLink, _("Other applets"));
210
216
        gtk_box_pack_start (GTK_BOX (pVBox), pLink, FALSE, FALSE, 0);
211
217
        
212
 
        /*gchar *cImagePath = g_strdup_printf ("%s/%s", CAIRO_DOCK_SHARE_DATA_DIR, CAIRO_DOCK_LOGO);
213
 
        GtkWidget *pImage = gtk_image_new_from_file (cImagePath);
214
 
        g_free (cImagePath);
215
 
#if GTK_MINOR_VERSION >= 12
216
 
        gtk_message_dialog_set_image (GTK_MESSAGE_DIALOG (pDialog), pImage);
217
 
#endif*/
218
218
        GtkWidget *pNoteBook = gtk_notebook_new ();
219
219
        gtk_notebook_set_scrollable (GTK_NOTEBOOK (pNoteBook), TRUE);
220
220
        gtk_notebook_popup_enable (GTK_NOTEBOOK (pNoteBook));
221
 
        //gtk_container_add (GTK_CONTAINER (GTK_DIALOG(pDialog)->vbox), pNoteBook);
222
221
        gtk_box_pack_start (GTK_BOX (pContentBox), pNoteBook, TRUE, TRUE, 0);
223
222
        
224
223
        _cairo_dock_add_about_page (pNoteBook,
225
224
                _("Development"),
226
225
                "<b>Main developer :</b>\n  Fabounet (Fabrice Rey)\n\
227
226
<b>Original idea/first development :</b>\n  Mac Slow\n\
228
 
<b>Applets :</b>\n  Fabounet\n  Necropotame\n  Ctaf\n  ChAnGFu\n  Tofe\n  Paradoxxx_Zero\n  Mav\n  Nochka85\n  Ours_en_pluche\n\
 
227
<b>Applets :</b>\n  Fabounet\n  Necropotame\n  Ctaf\n  ChAnGFu\n  Tofe\n  Paradoxxx_Zero\n  Mav\n  Nochka85\n  Ours_en_pluche\n  Eduardo Mucelli\n\
229
228
<b>Patchs :</b>\n  Special thanks to Augur for his great help with OpenGL\n  Ctaf\n  M.Tasaka\n  Matttbe\n  Necropotame\n  Robrob\n  Smidgey\n  Tshirtman\n");
230
229
        _cairo_dock_add_about_page (pNoteBook,
231
230
                _("Artwork"),
236
235
                "<b>Installation script and web hosting :</b>\n  Mav\n\
237
236
<b>Site (glx-dock.org) :</b>\n  Necropotame\n  Matttbe\n  Tdey\n\
238
237
<b>LaunchPad :</b>\n  Matttbe\n  Mav\n\
239
 
<b>Suggestions/Comments/Beta-Testers :</b>\n  AuraHxC\n  Chilperik\n  Cybergoll\n  Damster\n  Djoole\n  Glattering\n  Mav\n  Necropotame\n  Nochka85\n  Ppmt\n  RavanH\n  Rhinopierroce\n  Rom1\n  Sombrero\n  Vilraleur");
 
238
<b>Suggestions/Comments/Beta-Testers :</b>\n  AuraHxC\n  Chilperik\n  Cybergoll\n  Damster\n  Djoole\n  Glattering\n  Franksuse64\n  Mav\n  Necropotame\n  Nochka85\n  Ppmt\n  RavanH\n  Rhinopierroce\n  Rom1\n  Sombrero\n  Vilraleur");
240
239
        
241
240
        cairo_dock_dialog_window_created ();
242
241
        gtk_widget_show_all (pDialog);
266
265
                g_free (cCommand);
267
266
        }
268
267
}
 
268
static void _cairo_dock_show_third_party_applets (GtkMenuItem *pMenuItem, gpointer data)
 
269
{
 
270
        _launch_url ("http://www.glx-dock.org/mc_album.php?a=4");
 
271
}
269
272
 
270
273
static void _cairo_dock_present_help (GtkMenuItem *pMenuItem, gpointer data)
271
274
{
302
305
        //cairo_dock_on_delete (pDock->container.pWidget, NULL, pDock);
303
306
        Icon *pIcon = NULL;
304
307
        if (CAIRO_DOCK_IS_DOCK (pContainer))
305
 
        {
306
 
                pIcon = cairo_dock_get_dialogless_icon ();
307
 
                pContainer = CAIRO_CONTAINER (g_pMainDock);
308
 
        }
309
 
        else
 
308
                pIcon = cairo_dock_get_dialogless_icon (CAIRO_DOCK (pContainer));
 
309
        else if (CAIRO_DOCK_IS_DESKLET (pContainer))
310
310
                pIcon = CAIRO_DESKLET (pContainer)->pIcon;
311
311
        
312
 
        int answer = cairo_dock_ask_question_and_wait (_("Quit Cairo-Dock ?"), pIcon, pContainer);
313
 
        g_print ("quit : %d (yes:%d)\n", answer, GTK_RESPONSE_YES);
 
312
        int answer = cairo_dock_ask_question_and_wait (_("Quit Cairo-Dock?"), pIcon, pContainer);
 
313
        cd_debug ("quit : %d (yes:%d)\n", answer, GTK_RESPONSE_YES);
314
314
        if (answer == GTK_RESPONSE_YES)
315
315
                gtk_main_quit ();
316
316
}
317
317
 
318
318
 
319
 
gboolean cairo_dock_notification_build_container_menu (gpointer *pUserData, CairoContainer *pContainer, GtkWidget *menu)
 
319
gboolean cairo_dock_notification_build_container_menu (gpointer *pUserData, Icon *icon, CairoContainer *pContainer, GtkWidget *menu, gboolean *bDiscardMenu)
320
320
{
321
321
        //\_________________________ On ajoute le sous-menu Cairo-Dock, toujours present.
322
322
        GtkWidget *pMenuItem, *image;
333
333
 
334
334
        if (! cairo_dock_is_locked ())
335
335
        {
336
 
                pMenuItem = cairo_dock_add_in_menu_with_stock_and_data (_("Configure"),
337
 
                        GTK_STOCK_PREFERENCES,
338
 
                        (GFunc)_cairo_dock_edit_and_reload_conf,
339
 
                        pSubMenu,
340
 
                        NULL);
341
 
                gtk_widget_set_tooltip_text (pMenuItem, _("Configure the behaviour, appearance, and applets."));
342
 
                
343
336
                if (CAIRO_DOCK_IS_DOCK (pContainer) && ! CAIRO_DOCK (pContainer)->bIsMainDock && CAIRO_DOCK (pContainer)->iRefCount == 0)
344
337
                {
345
 
                        pMenuItem = cairo_dock_add_in_menu_with_stock_and_data (_("Set up this dock"),
 
338
                        pMenuItem = cairo_dock_add_in_menu_with_stock_and_data (_("Configure this dock"),
346
339
                                GTK_STOCK_EXECUTE,
347
 
                                (GFunc)_cairo_dock_configure_root_dock_position,
 
340
                                (GFunc)_cairo_dock_configure_root_dock,
348
341
                                pSubMenu,
349
342
                                CAIRO_DOCK (pContainer));
350
 
                        gtk_widget_set_tooltip_text (pMenuItem, _("Set up the position of this main dock."));
 
343
                        gtk_widget_set_tooltip_text (pMenuItem, _("Customize the position, visibility and appearance of this main dock."));
351
344
                }
352
345
                
 
346
                pMenuItem = cairo_dock_add_in_menu_with_stock_and_data (_("Configure"),
 
347
                        GTK_STOCK_PREFERENCES,
 
348
                        (GFunc)_cairo_dock_edit_and_reload_conf,
 
349
                        pSubMenu,
 
350
                        NULL);
 
351
                gtk_widget_set_tooltip_text (pMenuItem, _("Configure behaviour, appearance, and applets."));
 
352
                
353
353
                pMenuItem = cairo_dock_add_in_menu_with_stock_and_data (_("Manage themes"), 
354
354
                        CAIRO_DOCK_SHARE_DATA_DIR"/icon-appearance.svg",
355
355
                        (GFunc)_cairo_dock_initiate_theme_management,
356
356
                        pSubMenu,
357
357
                        NULL);
358
 
                gtk_widget_set_tooltip_text (pMenuItem, _("Choose amongst many themes on the server, and save your current theme."));
 
358
                gtk_widget_set_tooltip_text (pMenuItem, _("Choose from amongst many themes on the server or save your current theme."));
359
359
                
360
360
                pMenuItem = gtk_separator_menu_item_new ();
361
361
                gtk_menu_shell_append (GTK_MENU_SHELL (pSubMenu), pMenuItem);
362
362
                
363
 
                pMenuItem = cairo_dock_add_in_menu_with_stock_and_data (myAccessibility.bLockIcons ? _("unlock icons") : _("lock icons"),
 
363
                pMenuItem = cairo_dock_add_in_menu_with_stock_and_data (myAccessibility.bLockIcons ? _("Unlock icons") : _("Lock icons"),
364
364
                        CAIRO_DOCK_SHARE_DATA_DIR"/icon-lock-icons.svg",
365
365
                        (GFunc)_cairo_dock_lock_icons,
366
366
                        pSubMenu, NULL);
368
368
        }
369
369
        if (! g_bLocked)
370
370
        {
371
 
                pMenuItem = cairo_dock_add_in_menu_with_stock_and_data (myAccessibility.bLockAll ? _("unlock dock") : _("lock dock"),
 
371
                pMenuItem = cairo_dock_add_in_menu_with_stock_and_data (myAccessibility.bLockAll ? _("Unlock dock") : _("Lock dock"),
372
372
                        CAIRO_DOCK_SHARE_DATA_DIR"/icon-lock-icons.svg",
373
373
                        (GFunc)_cairo_dock_lock_all,
374
374
                        pSubMenu,
383
383
                        (GFunc)_cairo_dock_quick_hide,
384
384
                        pSubMenu,
385
385
                        CAIRO_DOCK (pContainer));
386
 
                gtk_widget_set_tooltip_text (pMenuItem, _("It will hide the dock until you enter inside with the mouse."));
 
386
                gtk_widget_set_tooltip_text (pMenuItem, _("This will hide the dock until you hover over it with the mouse."));
387
387
        }
388
388
        
389
389
        gchar *cCairoAutoStartDirPath = g_strdup_printf ("%s/.config/autostart", g_getenv ("HOME"));
406
406
                (GFunc)_cairo_dock_present_help,
407
407
                pSubMenu,
408
408
                NULL);
409
 
        gtk_widget_set_tooltip_text (pMenuItem, _("There is no problem, there is only solution (and a lot of useful hints !)."));
 
409
        gtk_widget_set_tooltip_text (pMenuItem, _("There are no problems, only solutions (and a lot of useful hints!)"));
 
410
        
 
411
        pMenuItem = cairo_dock_add_in_menu_with_stock_and_data (_("Get more applets!"),
 
412
                GTK_STOCK_ADD,
 
413
                (GFunc)_cairo_dock_show_third_party_applets,
 
414
                pSubMenu,
 
415
                NULL);
 
416
        gtk_widget_set_tooltip_text (pMenuItem, _("Third-party applets provide integration with many programs, like Pidgin"));
410
417
        
411
418
        cairo_dock_add_in_menu_with_stock_and_data (_("About"),
412
419
                GTK_STOCK_ABOUT,
435
442
{
436
443
        Icon *icon = data[0];
437
444
        CairoDock *pDock = data[1];
438
 
 
439
 
        gchar *question = g_strdup_printf (_("You're about removing this icon (%s) from the dock. Sure ?"), (icon->cInitialName != NULL ? icon->cInitialName : (icon->cName ? icon->cName : "no name")));
 
445
        
 
446
        const gchar *cName = (icon->cInitialName != NULL ? icon->cInitialName : icon->cName);
 
447
        if (cName == NULL)
 
448
        {
 
449
                if (CAIRO_DOCK_IS_SEPARATOR (icon))
 
450
                        cName = _("separator");
 
451
                else
 
452
                        cName = "no name";
 
453
        }
 
454
        gchar *question = g_strdup_printf (_("You're about to remove this icon (%s) from the dock. Are you sure?"), cName);
440
455
        int answer = cairo_dock_ask_question_and_wait (question, icon, CAIRO_CONTAINER (pDock));
441
456
        g_free (question);
442
457
        if (answer != GTK_RESPONSE_YES)
447
462
                gboolean bDestroyIcons = ! CAIRO_DOCK_IS_APPLI (icon);
448
463
                if (icon->pSubDock->icons != NULL && ! CAIRO_DOCK_IS_URI_LAUNCHER (icon) && icon->cClass == NULL)  // alors on propose de repartir les icones de son sous-dock dans le dock principal.
449
464
                {
450
 
                        int answer = cairo_dock_ask_question_and_wait (_("Do you want to re-dispatch the icons contained inside this container into the dock ?\n (otherwise they will be destroyed)"), icon, CAIRO_CONTAINER (pDock));
 
465
                        int answer = cairo_dock_ask_question_and_wait (_("Do you want to re-dispatch the icons contained inside this container into the dock?\n(otherwise they will be destroyed)"), icon, CAIRO_CONTAINER (pDock));
451
466
                        g_return_if_fail (answer != GTK_RESPONSE_NONE);
452
467
                        if (answer == GTK_RESPONSE_YES)
453
468
                                bDestroyIcons = FALSE;
454
469
                }
455
 
                cairo_dock_destroy_dock (icon->pSubDock, (CAIRO_DOCK_IS_APPLI (icon) && icon->cClass != NULL ? icon->cClass : icon->cName), (bDestroyIcons ? NULL : g_pMainDock), (bDestroyIcons ? NULL : CAIRO_DOCK_MAIN_DOCK_NAME));
 
470
                if (!bDestroyIcons)
 
471
                {
 
472
                        const gchar *cDockName = cairo_dock_search_dock_name (pDock);
 
473
                        cairo_dock_remove_icons_from_dock (icon->pSubDock, pDock, cDockName);
 
474
                }
 
475
                cairo_dock_destroy_dock (icon->pSubDock, (CAIRO_DOCK_IS_APPLI (icon) && icon->cClass != NULL ? icon->cClass : icon->cName));
456
476
                icon->pSubDock = NULL;
457
477
        }
458
478
        
463
483
{
464
484
        //\___________________ On determine l'ordre d'insertion suivant l'endroit du clique.
465
485
        double fOrder;
466
 
        if (CAIRO_DOCK_IS_LAUNCHER (icon))
 
486
        if (icon != NULL)
467
487
        {
468
488
                if (pDock->container.iMouseX < icon->fDrawX + icon->fWidth * icon->fScale / 2)  // a gauche.
469
489
                {
478
498
        }
479
499
        else
480
500
                fOrder = CAIRO_DOCK_LAST_ORDER;
481
 
 
482
 
        //\___________________ On cree un fichier de lanceur avec des valeurs par defaut.
483
 
        GError *erreur = NULL;
484
 
        const gchar *cDockName = cairo_dock_search_dock_name (pDock);
485
 
        gchar *cNewDesktopFileName;
486
 
        switch (iLauncherType)
487
 
        {
488
 
                case CAIRO_DOCK_DESKTOP_FILE_FOR_CONTAINER :
489
 
                        cNewDesktopFileName = cairo_dock_add_desktop_file_for_container (cDockName, fOrder, pDock, &erreur);
490
 
                break ;
491
 
                case CAIRO_DOCK_DESKTOP_FILE_FOR_LAUNCHER :
492
 
                        cNewDesktopFileName = cairo_dock_add_desktop_file_for_launcher (cDockName, fOrder, pDock, &erreur);
493
 
                break ;
494
 
                case CAIRO_DOCK_DESKTOP_FILE_FOR_SEPARATOR :
495
 
                        cNewDesktopFileName = cairo_dock_add_desktop_file_for_separator (cDockName, fOrder, pDock, &erreur);
496
 
                break ;
497
 
                default :
498
 
                return ;
499
 
        }
500
 
        if (erreur != NULL)
501
 
        {
502
 
                cd_warning ("while trying to create a new launcher : %s\nCheck that you have writing permissions on ~/.config/cairo-dock", erreur->message);
503
 
                g_error_free (erreur);
504
 
                return ;
505
 
        }
506
 
        
507
 
        //\___________________ On cree l'icone et on l'insere.
508
 
        cairo_t* pCairoContext = cairo_dock_create_drawing_context_generic (CAIRO_CONTAINER (pDock));
509
 
        Icon *pNewIcon = cairo_dock_create_icon_from_desktop_file (cNewDesktopFileName, pCairoContext);
510
 
        cairo_destroy (pCairoContext);
511
 
        
512
 
        if (iLauncherType == CAIRO_DOCK_DESKTOP_FILE_FOR_SEPARATOR)
513
 
                pNewIcon->iType = (icon ? icon->iType : CAIRO_DOCK_LAUNCHER);
514
 
        else if (pNewIcon->cName == NULL)
515
 
                pNewIcon->cName = g_strdup (_("Undefined"));
516
 
        
517
 
        CairoDock *pParentDock = cairo_dock_search_dock_from_name (pNewIcon->cParentDockName);  // existe forcement puique a ete cree au besoin.
518
 
        cairo_dock_insert_icon_in_dock (pNewIcon, pParentDock, CAIRO_DOCK_UPDATE_DOCK_SIZE, CAIRO_DOCK_ANIMATE_ICON);
519
 
 
520
 
        cairo_dock_launch_animation (CAIRO_CONTAINER (pParentDock));
521
 
        cairo_dock_mark_theme_as_modified (TRUE);
522
 
        
523
 
        g_free (cNewDesktopFileName);
 
501
        
 
502
        //\___________________ On cree et on charge l'icone a partir d'un des templates.
 
503
        Icon *pNewIcon = cairo_dock_add_new_launcher_by_type (iLauncherType, pDock, fOrder, (icon ? icon->iType : CAIRO_DOCK_LAUNCHER));
 
504
        if (pNewIcon == NULL)
 
505
        {
 
506
                cd_warning ("Couldn't create create the icon.\nCheck that you have writing permissions on ~/.config/cairo-dock and its sub-folders");
 
507
                return ;
 
508
        }
524
509
        
525
510
        //\___________________ On ouvre automatiquement l'IHM pour permettre de modifier ses champs.
526
511
        if (iLauncherType != CAIRO_DOCK_DESKTOP_FILE_FOR_SEPARATOR)  // inutile pour un separateur.
531
516
{
532
517
        Icon *icon = data[0];
533
518
        CairoDock *pDock = data[1];
534
 
        
535
519
        _cairo_dock_create_launcher (icon, pDock, CAIRO_DOCK_DESKTOP_FILE_FOR_LAUNCHER);
536
520
}
537
521
 
538
 
static void cairo_dock_add_container (GtkMenuItem *pMenuItem, gpointer *data)
 
522
static void cairo_dock_add_sub_dock (GtkMenuItem *pMenuItem, gpointer *data)
539
523
{
540
524
        Icon *icon = data[0];
541
525
        CairoDock *pDock = data[1];
542
 
 
543
526
        _cairo_dock_create_launcher (icon, pDock, CAIRO_DOCK_DESKTOP_FILE_FOR_CONTAINER);
544
527
}
545
528
 
 
529
static void cairo_dock_add_main_dock (GtkMenuItem *pMenuItem, gpointer *data)
 
530
{
 
531
        gchar *cDockName = cairo_dock_add_root_dock_config ();
 
532
        CairoDock *pDock = cairo_dock_create_dock (cDockName, NULL);
 
533
        cairo_dock_reload_one_root_dock (cDockName, pDock);
 
534
        
 
535
        cairo_dock_show_general_message (_("The new dock has been created.\nNow move some launchers or applets into it by right-clicking on the icon -> move to another dock"), 10000);  // on le place pas sur le nouveau dock, car sa fenetre n'est pas encore bien placee (0,0).
 
536
}
 
537
 
546
538
static void cairo_dock_add_separator (GtkMenuItem *pMenuItem, gpointer *data)
547
539
{
548
540
        Icon *icon = data[0];
549
541
        CairoDock *pDock = data[1];
550
 
        if (icon != NULL)
551
 
                _cairo_dock_create_launcher (icon, pDock, CAIRO_DOCK_DESKTOP_FILE_FOR_SEPARATOR);
 
542
        _cairo_dock_create_launcher (icon, pDock, CAIRO_DOCK_DESKTOP_FILE_FOR_SEPARATOR);
552
543
}
553
544
 
554
545
static void _cairo_dock_modify_launcher (GtkMenuItem *pMenuItem, gpointer *data)
558
549
        
559
550
        if (icon->cDesktopFileName == NULL || strcmp (icon->cDesktopFileName, "none") == 0)
560
551
        {
561
 
                cairo_dock_show_temporary_dialog_with_icon (_("This icon doesn't have a desktop file."), icon, CAIRO_CONTAINER (pDock), 4000, "same icon");
 
552
                cairo_dock_show_temporary_dialog_with_icon (_("Sorry, this icon doesn't have a configuration file."), icon, CAIRO_CONTAINER (pDock), 4000, "same icon");
562
553
                return ;
563
554
        }
564
555
        
569
560
{
570
561
        Icon *pIcon = g_object_get_data (G_OBJECT (pMenuItem), "launcher");
571
562
        
 
563
        //\_________________________ on cree si besoin le fichier de conf d'un nouveau dock racine.
572
564
        gchar *cValidDockName;
573
565
        if (cDockName == NULL)  // nouveau dock
574
566
        {
575
 
                cValidDockName = cairo_dock_get_unique_dock_name ("dock");
576
 
                
577
 
                // on cree le fichier de conf des maintenant pour pouvoir placer le nouveau dock a l'oppose du main dock.
578
 
                gchar *cCommand = g_strdup_printf ("cp '%s/%s' '%s/%s.conf'", CAIRO_DOCK_SHARE_DATA_DIR, CAIRO_DOCK_MAIN_DOCK_CONF_FILE, g_cCurrentThemePath, cValidDockName);
579
 
                int r = system (cCommand);
580
 
                g_free (cCommand);
581
 
                
582
 
                gchar *cDesktopFilePath = g_strdup_printf ("%s/%s.conf", g_cCurrentThemePath, cValidDockName);
583
 
                cairo_dock_update_conf_file (cDesktopFilePath,
584
 
                        G_TYPE_INT,
585
 
                        "Position",
586
 
                        "screen border",
587
 
                        (g_pMainDock->container.bIsHorizontal ?
588
 
                                (g_pMainDock->container.bDirectionUp ? 1 : 0) :
589
 
                                (g_pMainDock->container.bDirectionUp ? 3 : 2)),
590
 
                        G_TYPE_INVALID);
591
 
                g_free (cDesktopFilePath);
 
567
                cValidDockName = cairo_dock_add_root_dock_config ();
592
568
        }
593
569
        else
594
570
        {
595
571
                cValidDockName = g_strdup (cDockName);
596
572
        }
597
573
        
 
574
        //\_________________________ on met a jour le fichier de conf de l'icone.
 
575
        gchar *cCurrentDockName = pIcon->cParentDockName;
 
576
        pIcon->cParentDockName = NULL;
 
577
        cairo_dock_update_icon_s_container_name (pIcon, cValidDockName);
 
578
        g_free (pIcon->cParentDockName);
 
579
        pIcon->cParentDockName = cCurrentDockName;
 
580
        
 
581
        //\_________________________ on recharge l'icone, ce qui va creer le dock.
598
582
        if (CAIRO_DOCK_IS_STORED_LAUNCHER (pIcon))
599
583
        {
600
 
                gchar *cDesktopFilePath = g_strdup_printf ("%s/%s", g_cCurrentLaunchersPath, pIcon->cDesktopFileName);
601
 
                cairo_dock_update_conf_file (cDesktopFilePath,
602
 
                        G_TYPE_STRING, "Desktop Entry", "Container", cValidDockName,
603
 
                        G_TYPE_INVALID);
604
 
                g_free (cDesktopFilePath);
605
584
                cairo_dock_reload_launcher (pIcon);
606
585
        }
607
586
        else if (CAIRO_DOCK_IS_APPLET (pIcon))
608
587
        {
609
 
                cairo_dock_update_conf_file (pIcon->pModuleInstance->cConfFilePath,
610
 
                        G_TYPE_STRING, "Icon", "dock name", cValidDockName,
611
 
                        G_TYPE_INVALID);
612
588
                cairo_dock_reload_module_instance (pIcon->pModuleInstance, TRUE);  // TRUE <=> reload config.
613
589
        }
 
590
        
 
591
        CairoDock *pNewDock = cairo_dock_search_dock_from_name (cValidDockName);
 
592
        if (pNewDock && pNewDock->icons && pNewDock->icons->next == NULL)  // le dock vient d'etre cree avec cette icone.
 
593
                cairo_dock_show_general_message (_("The new dock has been created.\nYou can customize it by right-clicking on it -> cairo-dock -> configure this dock."), 8000);  // on le place pas sur le nouveau dock, car sa fenetre n'est pas encore bien placee (0,0).
614
594
        g_free (cValidDockName);
615
595
}
 
596
 
616
597
static void _add_one_dock_to_menu (const gchar *cName, CairoDock *pDock, GtkWidget *pMenu)
617
598
{
618
599
        // on elimine les sous-dock d'appli, d'applets, ou de repertoire.
631
612
        g_object_set_data (G_OBJECT (pMenuItem), "launcher", pIcon);
632
613
}
633
614
 
634
 
  ///////////////////////////////////////////////////////////////////
635
 
 /////////// LES OPERATIONS SUR LES FICHIERS ///////////////////////
636
 
///////////////////////////////////////////////////////////////////
637
 
 
638
 
static void _cairo_dock_show_file_properties (GtkMenuItem *pMenuItem, gpointer *data)
639
 
{
640
 
        Icon *icon = data[0];
641
 
        CairoDock *pDock = data[1];
642
 
        //g_print ("%s (%s)\n", __func__, icon->cName);
643
 
 
644
 
        guint64 iSize = 0;
645
 
        time_t iLastModificationTime = 0;
646
 
        gchar *cMimeType = NULL;
647
 
        int iUID=0, iGID=0, iPermissionsMask=0;
648
 
        if (cairo_dock_fm_get_file_properties (icon->cCommand, &iSize, &iLastModificationTime, &cMimeType, &iUID, &iGID, &iPermissionsMask))
649
 
        {
650
 
                GtkWidget *pDialog = gtk_message_dialog_new (GTK_WINDOW (pDock->container.pWidget),
651
 
                        GTK_DIALOG_DESTROY_WITH_PARENT,
652
 
                        GTK_MESSAGE_INFO,
653
 
                        GTK_BUTTONS_OK,
654
 
                        "Properties :");
655
 
 
656
 
                GString *sInfo = g_string_new ("");
657
 
                g_string_printf (sInfo, "<b>%s</b>", icon->cName);
658
 
 
659
 
                GtkWidget *pLabel= gtk_label_new (NULL);
660
 
                gtk_label_set_use_markup (GTK_LABEL (pLabel), TRUE);
661
 
                gtk_label_set_markup (GTK_LABEL (pLabel), sInfo->str);
662
 
 
663
 
                GtkWidget *pFrame = gtk_frame_new (NULL);
664
 
                gtk_container_set_border_width (GTK_CONTAINER (pFrame), 3);
665
 
                gtk_frame_set_label_widget (GTK_FRAME (pFrame), pLabel);
666
 
                gtk_frame_set_shadow_type (GTK_FRAME (pFrame), GTK_SHADOW_OUT);
667
 
                gtk_container_add (GTK_CONTAINER (GTK_DIALOG (pDialog)->vbox), pFrame);
668
 
 
669
 
                GtkWidget *pVBox = gtk_vbox_new (FALSE, 3);
670
 
                gtk_container_add (GTK_CONTAINER (pFrame), pVBox);
671
 
 
672
 
                pLabel = gtk_label_new (NULL);
673
 
                gtk_label_set_use_markup (GTK_LABEL (pLabel), TRUE);
674
 
                g_string_printf (sInfo, "<u>Size</u> : %lld bytes", iSize);
675
 
                if (iSize > 1024*1024)
676
 
                        g_string_append_printf (sInfo, " (%.1f Mo)", 1. * iSize / 1024 / 1024);
677
 
                else if (iSize > 1024)
678
 
                        g_string_append_printf (sInfo, " (%.1f Ko)", 1. * iSize / 1024);
679
 
                gtk_label_set_markup (GTK_LABEL (pLabel), sInfo->str);
680
 
                gtk_container_add (GTK_CONTAINER (pVBox), pLabel);
681
 
 
682
 
                pLabel = gtk_label_new (NULL);
683
 
                gtk_label_set_use_markup (GTK_LABEL (pLabel), TRUE);
684
 
                struct tm epoch_tm;
685
 
                localtime_r (&iLastModificationTime, &epoch_tm);  // et non pas gmtime_r.
686
 
                gchar *cTimeChain = g_new0 (gchar, 100);
687
 
                strftime (cTimeChain, 100, "%F, %T", &epoch_tm);
688
 
                g_string_printf (sInfo, "<u>Last Modification</u> : %s", cTimeChain);
689
 
                g_free (cTimeChain);
690
 
                gtk_label_set_markup (GTK_LABEL (pLabel), sInfo->str);
691
 
                gtk_container_add (GTK_CONTAINER (pVBox), pLabel);
692
 
 
693
 
                if (cMimeType != NULL)
694
 
                {
695
 
                        pLabel = gtk_label_new (NULL);
696
 
                        gtk_label_set_use_markup (GTK_LABEL (pLabel), TRUE);
697
 
                        g_string_printf (sInfo, "<u>Mime Type</u> : %s", cMimeType);
698
 
                        gtk_label_set_markup (GTK_LABEL (pLabel), sInfo->str);
699
 
                        gtk_container_add (GTK_CONTAINER (pVBox), pLabel);
700
 
                }
701
 
 
702
 
                GtkWidget *pSeparator = gtk_hseparator_new ();
703
 
                gtk_container_add (GTK_CONTAINER (pVBox), pSeparator);
704
 
 
705
 
                pLabel = gtk_label_new (NULL);
706
 
                gtk_label_set_use_markup (GTK_LABEL (pLabel), TRUE);
707
 
                g_string_printf (sInfo, "<u>User ID</u> : %d / <u>Group ID</u> : %d", iUID, iGID);
708
 
                gtk_label_set_markup (GTK_LABEL (pLabel), sInfo->str);
709
 
                gtk_container_add (GTK_CONTAINER (pVBox), pLabel);
710
 
 
711
 
                pLabel = gtk_label_new (NULL);
712
 
                gtk_label_set_use_markup (GTK_LABEL (pLabel), TRUE);
713
 
                int iOwnerPermissions = iPermissionsMask >> 6;  // 8*8.
714
 
                int iGroupPermissions = (iPermissionsMask - (iOwnerPermissions << 6)) >> 3;
715
 
                int iOthersPermissions = (iPermissionsMask % 8);
716
 
                g_string_printf (sInfo, "<u>Permissions</u> : %d / %d / %d", iOwnerPermissions, iGroupPermissions, iOthersPermissions);
717
 
                gtk_label_set_markup (GTK_LABEL (pLabel), sInfo->str);
718
 
                gtk_container_add (GTK_CONTAINER (pVBox), pLabel);
719
 
 
720
 
                gtk_widget_show_all (GTK_DIALOG (pDialog)->vbox);
721
 
                gtk_window_set_position (GTK_WINDOW (pDialog), GTK_WIN_POS_CENTER_ALWAYS);
722
 
                int answer = gtk_dialog_run (GTK_DIALOG (pDialog));
723
 
                gtk_widget_destroy (pDialog);
724
 
 
725
 
                g_string_free (sInfo, TRUE);
726
 
                g_free (cMimeType);
727
 
        }
728
 
}
729
 
 
730
 
static void _cairo_dock_mount_unmount (GtkMenuItem *pMenuItem, gpointer *data)
731
 
{
732
 
        Icon *icon = data[0];
733
 
        CairoDock *pDock = data[1];
734
 
        cd_message ("%s (%s / %s)\n", __func__, icon->cName, icon->cBaseURI);
735
 
 
736
 
        gboolean bIsMounted = FALSE;
737
 
        gchar *cActivationURI = cairo_dock_fm_is_mounted (icon->cBaseURI, &bIsMounted);
738
 
        cd_message ("  cActivationURI : %s; bIsMounted : %d\n", cActivationURI, bIsMounted);
739
 
        g_free (cActivationURI);
740
 
 
741
 
        if (! bIsMounted)
742
 
        {
743
 
                cairo_dock_fm_mount (icon, CAIRO_CONTAINER (pDock));
744
 
        }
745
 
        else
746
 
                cairo_dock_fm_unmount (icon, CAIRO_CONTAINER (pDock));
747
 
}
748
 
 
749
 
static void _cairo_dock_eject (GtkMenuItem *pMenuItem, gpointer *data)
750
 
{
751
 
        Icon *icon = data[0];
752
 
        CairoDock *pDock = data[1];
753
 
        cd_message ("%s (%s / %s)\n", __func__, icon->cName, icon->cCommand);
754
 
        cairo_dock_fm_eject_drive (icon->cCommand);
755
 
}
756
 
 
757
 
 
758
 
static void _cairo_dock_delete_file (GtkMenuItem *pMenuItem, gpointer *data)
759
 
{
760
 
        Icon *icon = data[0];
761
 
        CairoDock *pDock = data[1];
762
 
        cd_message ("%s (%s)\n", __func__, icon->cName);
763
 
 
764
 
        gchar *question = g_strdup_printf (_("You're about deleting this file\n  (%s)\nfrom your hard-disk. Sure ?"), icon->cCommand);
765
 
        int answer = cairo_dock_ask_question_and_wait (question, icon, CAIRO_CONTAINER (pDock));
766
 
        g_free (question);
767
 
        if (answer == GTK_RESPONSE_YES)
768
 
        {
769
 
                gboolean bSuccess = cairo_dock_fm_delete_file (icon->cCommand);
770
 
                if (! bSuccess)
771
 
                {
772
 
                        cd_warning ("couldn't delete this file.\nCheck that you have writing rights on this file.\n");
773
 
                        gchar *cMessage = g_strdup_printf (_("Attention : couldn't delete this file.\nCheck that you have writing rights on it."));
774
 
                        cairo_dock_show_temporary_dialog_with_default_icon (cMessage, icon, CAIRO_CONTAINER (pDock), 4000);
775
 
                        g_free (cMessage);
776
 
                }
777
 
                ///cairo_dock_remove_icon_from_dock (pDock, icon);
778
 
                ///cairo_dock_update_dock_size (pDock);
779
 
 
780
 
                if (icon->cDesktopFileName != NULL)
781
 
                {
782
 
                        gchar *icon_path = g_strdup_printf ("%s/%s", g_cCurrentLaunchersPath, icon->cDesktopFileName);
783
 
                        g_remove (icon_path);
784
 
                        g_free (icon_path);
785
 
                }
786
 
 
787
 
                ///cairo_dock_free_icon (icon);
788
 
        }
789
 
}
790
 
 
791
 
static void _cairo_dock_rename_file (GtkMenuItem *pMenuItem, gpointer *data)
792
 
{
793
 
        Icon *icon = data[0];
794
 
        CairoDock *pDock = data[1];
795
 
        cd_message ("%s (%s)", __func__, icon->cName);
796
 
 
797
 
        gchar *cNewName = cairo_dock_show_demand_and_wait (_("Rename to :"), icon, CAIRO_CONTAINER (pDock), icon->cName);
798
 
        if (cNewName != NULL && *cNewName != '\0')
799
 
        {
800
 
                gboolean bSuccess = cairo_dock_fm_rename_file (icon->cCommand, cNewName);
801
 
                if (! bSuccess)
802
 
                {
803
 
                        cd_warning ("couldn't rename this file.\nCheck that you have writing rights, and that the new name does not already exist.");
804
 
                        cairo_dock_show_temporary_dialog_with_icon_printf (_("Attention : couldn't rename %s.\nCheck that you have writing rights,\n and that the new name does not already exist."), icon, CAIRO_CONTAINER (pDock), 5000, NULL, icon->cCommand);
805
 
                }
806
 
        }
807
 
        g_free (cNewName);
808
 
}
809
 
 
810
615
  //////////////////////////////////////////////////////////////////
811
616
 /////////// LES OPERATIONS SUR LES APPLETS ///////////////////////
812
617
//////////////////////////////////////////////////////////////////
813
618
 
814
 
 
815
619
static void _cairo_dock_initiate_config_module (GtkMenuItem *pMenuItem, gpointer *data)
816
620
{
817
 
        g_print ("%s ()\n", __func__);
 
621
        cd_debug ("%s ()\n", __func__);
818
622
        Icon *icon = data[0];
819
623
        CairoContainer *pContainer= data[1];
820
624
        if (CAIRO_DOCK_IS_DESKLET (pContainer))
832
636
                icon = (CAIRO_DESKLET (pContainer))->pIcon;  // l'icone cliquee du desklet n'est pas forcement celle qui contient le module !
833
637
        g_return_if_fail (CAIRO_DOCK_IS_APPLET (icon));
834
638
        
835
 
        cairo_dock_update_conf_file (icon->pModuleInstance->cConfFilePath,
836
 
                G_TYPE_BOOLEAN, "Desklet", "initially detached", CAIRO_DOCK_IS_DOCK (pContainer),
837
 
                G_TYPE_INVALID);
838
 
        cairo_dock_update_desklet_detached_state_in_gui (icon->pModuleInstance, CAIRO_DOCK_IS_DOCK (pContainer));
839
 
        cairo_dock_reload_module_instance (icon->pModuleInstance, TRUE);
840
 
        if (icon->pModuleInstance->pDesklet)  // on a detache l'applet.
841
 
                cairo_dock_zoom_out_desklet (icon->pModuleInstance->pDesklet);
 
639
        cairo_dock_detach_module_instance (icon->pModuleInstance);
842
640
}
843
641
 
844
642
static void _cairo_dock_remove_module_instance (GtkMenuItem *pMenuItem, gpointer *data)
849
647
                icon = (CAIRO_DESKLET (pContainer))->pIcon;  // l'icone cliquee du desklet n'est pas forcement celle qui contient le module !
850
648
        g_return_if_fail (CAIRO_DOCK_IS_APPLET (icon));
851
649
        
852
 
        gchar *question = g_strdup_printf (_("You're about removing this applet (%s) from the dock. Sure ?"), icon->pModuleInstance->pModule->pVisitCard->cModuleName);
 
650
        gchar *question = g_strdup_printf (_("You're about to remove this applet (%s) from the dock. Are you sure?"), icon->pModuleInstance->pModule->pVisitCard->cModuleName);
853
651
        int answer = cairo_dock_ask_question_and_wait (question, icon, CAIRO_CONTAINER (pContainer));
854
652
        if (answer == GTK_RESPONSE_YES)
855
653
        {
878
676
{
879
677
        Icon *icon = data[0];
880
678
        CairoDock *pDock = data[1];
881
 
 
882
679
        if (CAIRO_DOCK_IS_APPLI (icon))
883
680
                cairo_dock_close_xwindow (icon->Xid);
884
681
}
 
682
static void _cairo_dock_remove_custom_appli_icon (GtkMenuItem *pMenuItem, gpointer *data)
 
683
{
 
684
        Icon *icon = data[0];
 
685
        CairoDock *pDock = data[1];
 
686
        if (! CAIRO_DOCK_IS_APPLI (icon))
 
687
                return;
 
688
        gchar *cCustomIcon = g_strdup_printf ("%s/%s.png", g_cCurrentIconsPath, icon->cClass);
 
689
        if (!g_file_test (cCustomIcon, G_FILE_TEST_EXISTS))
 
690
        {
 
691
                g_free (cCustomIcon);
 
692
                cCustomIcon = g_strdup_printf ("%s/%s.svg", g_cCurrentIconsPath, icon->cClass);
 
693
                if (!g_file_test (cCustomIcon, G_FILE_TEST_EXISTS))
 
694
                {
 
695
                        g_free (cCustomIcon);
 
696
                        cCustomIcon = NULL;
 
697
                }
 
698
        }
 
699
        if (cCustomIcon != NULL)
 
700
        {
 
701
                gchar *cCommand = g_strdup_printf ("rm -f \"%s\"", cCustomIcon);
 
702
                int r = system (cCommand);
 
703
                g_free (cCommand);
 
704
                cairo_dock_reload_icon_image (icon, CAIRO_CONTAINER (pDock));
 
705
                cairo_dock_redraw_icon (icon, CAIRO_CONTAINER (pDock));
 
706
        }
 
707
}
885
708
static void _cairo_dock_kill_appli (GtkMenuItem *pMenuItem, gpointer *data)
886
709
{
887
710
        Icon *icon = data[0];
888
711
        CairoDock *pDock = data[1];
889
 
 
890
712
        if (CAIRO_DOCK_IS_APPLI (icon))
891
713
                cairo_dock_kill_xwindow (icon->Xid);
892
714
}
894
716
{
895
717
        Icon *icon = data[0];
896
718
        CairoDock *pDock = data[1];
897
 
        if (icon->Xid > 0)
 
719
        if (CAIRO_DOCK_IS_APPLI (icon))
898
720
        {
899
721
                cairo_dock_minimize_xwindow (icon->Xid);
900
722
        }
904
726
{
905
727
        Icon *icon = data[0];
906
728
        CairoDock *pDock = data[1];
907
 
        if (icon->Xid > 0)
 
729
        if (CAIRO_DOCK_IS_APPLI (icon))
908
730
        {
909
731
                cairo_dock_show_xwindow (icon->Xid);
910
732
        }
927
749
        g_return_if_fail (icon->Xid != 0 && icon->cClass != NULL);
928
750
        
929
751
        // on trouve le .desktop du programme.
930
 
        g_print ("%s (%s)\n", __func__, icon->cClass);
 
752
        cd_debug ("%s (%s)\n", __func__, icon->cClass);
931
753
        gchar *cDesktopFilePath = g_strdup_printf ("/usr/share/applications/%s.desktop", icon->cClass);
932
754
        if (! g_file_test (cDesktopFilePath, G_FILE_TEST_EXISTS))  // on n'a pas trouve la, on cherche chez KDE.
933
755
        {
955
777
        // on cree un nouveau lanceur a partir de la classe.
956
778
        if (cDesktopFilePath != NULL)
957
779
        {
958
 
                g_print ("cDesktopFilePath : %s\n", cDesktopFilePath);
959
 
                cairo_dock_add_new_launcher_by_uri (cDesktopFilePath, g_pMainDock, CAIRO_DOCK_LAST_ORDER);
 
780
                cd_message ("found desktop file : %s\n", cDesktopFilePath);
 
781
                cairo_dock_add_new_launcher_by_uri (cDesktopFilePath, g_pMainDock, CAIRO_DOCK_LAST_ORDER);  // on l'ajoute dans le main dock.
960
782
        }
961
783
        else
962
784
        {
963
 
                cairo_dock_show_temporary_dialog_with_default_icon (_("Sorry, couldn't find the corresponding description file.\nConsider drag and dropping the launcher from the Applications Menu."), icon, CAIRO_CONTAINER (pDock), 8000);
 
785
                cairo_dock_show_temporary_dialog_with_default_icon (_("Sorry, couldn't find the corresponding description file.\nConsider dragging and dropping the launcher from the Applications Menu."), icon, CAIRO_CONTAINER (pDock), 8000);
964
786
        }
965
787
        g_free (cDesktopFilePath);
966
788
}
969
791
{
970
792
        Icon *icon = data[0];
971
793
        CairoDock *pDock = data[1];
972
 
        if (icon->Xid > 0)
 
794
        if (CAIRO_DOCK_IS_APPLI (icon))
973
795
        {
974
796
                cairo_dock_maximize_xwindow (icon->Xid, ! icon->bIsMaximized);
975
797
        }
979
801
{
980
802
        Icon *icon = data[0];
981
803
        CairoDock *pDock = data[1];
982
 
        if (icon->Xid > 0)
 
804
        if (CAIRO_DOCK_IS_APPLI (icon))
983
805
        {
984
806
                cairo_dock_set_xwindow_fullscreen (icon->Xid, ! icon->bIsFullScreen);
985
807
        }
990
812
        //g_print ("%s ()\n", __func__);
991
813
        Icon *icon = data[0];
992
814
        CairoDock *pDock = data[1];
993
 
        if (icon->Xid > 0)
 
815
        if (CAIRO_DOCK_IS_APPLI (icon))
994
816
        {
995
 
                int iCurrentDesktop = cairo_dock_get_current_desktop ();
996
 
                cairo_dock_move_xwindow_to_nth_desktop (icon->Xid, iCurrentDesktop, 0, 0);  // on ne veut pas decaler son viewport par rapport a nous.
 
817
                cairo_dock_move_window_to_current_desktop (icon);
 
818
                if (!icon->bIsHidden)
 
819
                        cairo_dock_show_xwindow (icon->Xid);
997
820
        }
998
821
}
999
822
 
1006
829
        int iViewPortNumberY = GPOINTER_TO_INT (user_data[2]);
1007
830
        int iViewPortNumberX = GPOINTER_TO_INT (user_data[3]);
1008
831
        cd_message ("%s (%d;%d;%d)", __func__, iDesktopNumber, iViewPortNumberX, iViewPortNumberY);
1009
 
        if (icon->Xid > 0)
 
832
        if (CAIRO_DOCK_IS_APPLI (icon))
1010
833
        {
1011
 
                int iCurrentViewPortX, iCurrentViewPortY;
1012
 
                cairo_dock_get_current_viewport (&iCurrentViewPortX, &iCurrentViewPortY);
1013
 
                cd_debug (" current_viewport : %d;%d", iCurrentViewPortX, iCurrentViewPortY);
1014
 
                
1015
 
                cairo_dock_move_xwindow_to_nth_desktop (icon->Xid, iDesktopNumber, iViewPortNumberX * g_iXScreenWidth[CAIRO_DOCK_HORIZONTAL] - iCurrentViewPortX, iViewPortNumberY * g_iXScreenHeight[CAIRO_DOCK_HORIZONTAL] - iCurrentViewPortY);
 
834
                cairo_dock_move_window_to_desktop (icon, iDesktopNumber, iViewPortNumberX, iViewPortNumberY);
1016
835
        }
1017
836
}
1018
837
 
1020
839
{
1021
840
        Icon *icon = data[0];
1022
841
        CairoDock *pDock = data[1];
1023
 
        if (icon->Xid > 0)
 
842
        if (CAIRO_DOCK_IS_APPLI (icon))
1024
843
        {
1025
844
                gboolean bIsAbove=FALSE, bIsBelow=FALSE;
1026
845
                cairo_dock_xwindow_is_above_or_below (icon->Xid, &bIsAbove, &bIsBelow);
1029
848
}
1030
849
 
1031
850
  //////////////////////////////////////////////////////////////////
1032
 
 /////////// LES OPERATIONS SUR LES CLASSES ///////////////////////
 
851
 ///////////// LES OPERATIONS SUR LES CLASSES /////////////////////
1033
852
//////////////////////////////////////////////////////////////////
1034
853
 
1035
854
static void _cairo_dock_show_class (GtkMenuItem *pMenuItem, gpointer *data)
1043
862
        for (ic = icon->pSubDock->icons; ic != NULL; ic = ic->next)
1044
863
        {
1045
864
                pIcon = ic->data;
1046
 
                if (pIcon->Xid != 0)
 
865
                if (CAIRO_DOCK_IS_APPLI (pIcon))
1047
866
                {
1048
867
                        cairo_dock_show_xwindow (pIcon->Xid);
1049
868
                }
1061
880
        for (ic = icon->pSubDock->icons; ic != NULL; ic = ic->next)
1062
881
        {
1063
882
                pIcon = ic->data;
1064
 
                if (pIcon->Xid != 0)
 
883
                if (CAIRO_DOCK_IS_APPLI (pIcon))
1065
884
                {
1066
885
                        cairo_dock_minimize_xwindow (pIcon->Xid);
1067
886
                }
1079
898
        for (ic = icon->pSubDock->icons; ic != NULL; ic = ic->next)
1080
899
        {
1081
900
                pIcon = ic->data;
1082
 
                if (pIcon->Xid != 0)
 
901
                if (CAIRO_DOCK_IS_APPLI (pIcon))
1083
902
                {
1084
903
                        cairo_dock_close_xwindow (pIcon->Xid);
1085
904
                }
1102
921
        for (ic = icon->pSubDock->icons; ic != NULL; ic = ic->next)
1103
922
        {
1104
923
                pIcon = ic->data;
1105
 
                if (pIcon->Xid != 0)
 
924
                if (CAIRO_DOCK_IS_APPLI (pIcon))
1106
925
                {
1107
 
                        int iCurrentViewPortX, iCurrentViewPortY;
1108
 
                        cairo_dock_get_current_viewport (&iCurrentViewPortX, &iCurrentViewPortY);
1109
 
                        cd_debug (" current_viewport : %d;%d", iCurrentViewPortX, iCurrentViewPortY);
1110
 
                        
1111
 
                        cairo_dock_move_xwindow_to_nth_desktop (pIcon->Xid, iDesktopNumber, iViewPortNumberX * g_iXScreenWidth[CAIRO_DOCK_HORIZONTAL] - iCurrentViewPortX, iViewPortNumberY * g_iXScreenHeight[CAIRO_DOCK_HORIZONTAL] - iCurrentViewPortY);
 
926
                        cairo_dock_move_window_to_desktop (pIcon, iDesktopNumber, iViewPortNumberX, iViewPortNumberY);
1112
927
                }
1113
928
        }
1114
929
}
1119
934
        CairoDock *pDock = data[1];
1120
935
        g_return_if_fail (icon->pSubDock != NULL);
1121
936
        
1122
 
        int iCurrentDesktop = cairo_dock_get_current_desktop ();
1123
937
        Icon *pIcon;
1124
938
        GList *ic;
1125
939
        for (ic = icon->pSubDock->icons; ic != NULL; ic = ic->next)
1126
940
        {
1127
941
                pIcon = ic->data;
1128
 
                if (pIcon->Xid != 0)
 
942
                if (CAIRO_DOCK_IS_APPLI (pIcon))
1129
943
                {
1130
 
                        cairo_dock_move_xwindow_to_nth_desktop (pIcon->Xid, iCurrentDesktop, 0, 0);  // on ne veut pas decaler son viewport par rapport a nous.
 
944
                        cairo_dock_move_window_to_current_desktop (pIcon);
1131
945
                }
1132
946
        }
1133
947
}
1136
950
 ///////////////// LES OPERATIONS SUR LES DESKLETS /////////////////
1137
951
///////////////////////////////////////////////////////////////////
1138
952
 
 
953
static inline void _cairo_dock_set_desklet_accessibility (CairoDesklet *pDesklet, CairoDeskletVisibility iVisibility)
 
954
{
 
955
        cairo_dock_set_desklet_accessibility (pDesklet, iVisibility, TRUE);  // TRUE <=> save state in conf.
 
956
}
1139
957
static void _cairo_dock_keep_below (GtkCheckMenuItem *pMenuItem, gpointer *data)
1140
958
{
1141
 
        Icon *icon = data[0];
1142
959
        CairoDesklet *pDesklet = data[1];
1143
 
        if (icon == NULL)  // cas de l'applet Terminal par exemple.
1144
 
                icon = pDesklet->pIcon;
1145
 
        
1146
 
        gboolean bBelow = gtk_check_menu_item_get_active (GTK_CHECK_MENU_ITEM (pMenuItem));
1147
 
        g_print (" %s (%d)\n", __func__, bBelow);
1148
 
        gtk_window_set_keep_below (GTK_WINDOW(pDesklet->container.pWidget), bBelow);
1149
 
        if (CAIRO_DOCK_IS_APPLET (icon) && bBelow)
1150
 
                cairo_dock_update_conf_file (icon->pModuleInstance->cConfFilePath,
1151
 
                        G_TYPE_INT, "Desklet", "accessibility", CAIRO_DESKLET_KEEP_BELOW,
1152
 
                        G_TYPE_INVALID);
 
960
        if (gtk_check_menu_item_get_active (GTK_CHECK_MENU_ITEM (pMenuItem)))
 
961
                _cairo_dock_set_desklet_accessibility (pDesklet, CAIRO_DESKLET_KEEP_BELOW);
1153
962
}
1154
963
 
1155
964
static void _cairo_dock_keep_normal (GtkCheckMenuItem *pMenuItem, gpointer *data)
1156
965
{
1157
 
        Icon *icon = data[0];
1158
966
        CairoDesklet *pDesklet = data[1];
1159
 
        if (icon == NULL)  // cas de l'applet Terminal par exemple.
1160
 
                icon = pDesklet->pIcon;
1161
 
        
1162
 
        gboolean bNormal = gtk_check_menu_item_get_active (GTK_CHECK_MENU_ITEM (pMenuItem));
1163
 
        g_print (" %s (%d)\n", __func__, bNormal);
1164
 
        if (CAIRO_DOCK_IS_APPLET (icon) && bNormal)
1165
 
                cairo_dock_update_conf_file (icon->pModuleInstance->cConfFilePath,
1166
 
                        G_TYPE_INT, "Desklet", "accessibility", CAIRO_DESKLET_NORMAL,
1167
 
                        G_TYPE_INVALID);
 
967
        if (gtk_check_menu_item_get_active (GTK_CHECK_MENU_ITEM (pMenuItem)))
 
968
                _cairo_dock_set_desklet_accessibility (pDesklet, CAIRO_DESKLET_NORMAL);
1168
969
}
1169
970
 
1170
971
static void _cairo_dock_keep_above (GtkCheckMenuItem *pMenuItem, gpointer *data)
1171
972
{
1172
 
        Icon *icon = data[0];
1173
973
        CairoDesklet *pDesklet = data[1];
1174
 
        if (icon == NULL)  // cas de l'applet Terminal par exemple.
1175
 
                icon = pDesklet->pIcon;
1176
 
        
1177
 
        gboolean bAbove = gtk_check_menu_item_get_active (GTK_CHECK_MENU_ITEM (pMenuItem));
1178
 
        g_print (" %s (%d)\n", __func__, bAbove);
1179
 
        gtk_window_set_keep_above (GTK_WINDOW(pDesklet->container.pWidget), bAbove);
1180
 
        if (CAIRO_DOCK_IS_APPLET (icon) && bAbove)
1181
 
                cairo_dock_update_conf_file (icon->pModuleInstance->cConfFilePath,
1182
 
                        G_TYPE_INT, "Desklet", "accessibility", CAIRO_DESKLET_KEEP_ABOVE,
1183
 
                        G_TYPE_INVALID);
 
974
        if (gtk_check_menu_item_get_active (GTK_CHECK_MENU_ITEM (pMenuItem)))
 
975
                _cairo_dock_set_desklet_accessibility (pDesklet, CAIRO_DESKLET_KEEP_ABOVE);
1184
976
}
1185
977
 
1186
 
//for compiz fusion "widget layer"
1187
 
//set behaviour in compiz to: (class=Cairo-dock & type=utility)
1188
978
static void _cairo_dock_keep_on_widget_layer (GtkMenuItem *pMenuItem, gpointer *data)
1189
979
{
1190
 
        Icon *icon = data[0];
1191
980
        CairoDesklet *pDesklet = data[1];
1192
 
        if (icon == NULL)  // cas de l'applet Terminal par exemple.
1193
 
                icon = pDesklet->pIcon;
1194
 
        
1195
 
        cairo_dock_hide_desklet (pDesklet);
1196
 
        Window Xid = GDK_WINDOW_XID (pDesklet->container.pWidget->window);
1197
 
 
1198
 
        gboolean bOnCompizWidgetLayer = gtk_check_menu_item_get_active (GTK_CHECK_MENU_ITEM (pMenuItem));
1199
 
        g_print (" %s (%d)\n", __func__, bOnCompizWidgetLayer);
1200
 
        if (bOnCompizWidgetLayer)
1201
 
                cairo_dock_set_xwindow_type_hint (Xid, "_NET_WM_WINDOW_TYPE_UTILITY");
1202
 
                //gtk_window_set_type_hint(GTK_WINDOW(pDock->container.pWidget), GDK_WINDOW_TYPE_HINT_UTILITY);
1203
 
        else
1204
 
                cairo_dock_set_xwindow_type_hint (Xid, "_NET_WM_WINDOW_TYPE_NORMAL");
1205
 
                //gtk_window_set_type_hint(GTK_WINDOW(pDock->container.pWidget), GDK_WINDOW_TYPE_HINT_NORMAL);
1206
 
        cairo_dock_show_desklet (pDesklet);
1207
 
        
1208
 
        if (CAIRO_DOCK_IS_APPLET (icon) && bOnCompizWidgetLayer)
1209
 
                cairo_dock_update_conf_file (icon->pModuleInstance->cConfFilePath,
1210
 
                        G_TYPE_INT, "Desklet", "accessibility", CAIRO_DESKLET_ON_WIDGET_LAYER,
1211
 
                        G_TYPE_INVALID);
1212
 
        
1213
 
        if (bOnCompizWidgetLayer)  // on verifie que la regle de Compiz est correcte.
1214
 
        {
1215
 
                // on recupere la regle
1216
 
                gchar *cDbusAnswer = cairo_dock_launch_command_sync ("dbus-send --print-reply --type=method_call --dest=org.freedesktop.compiz /org/freedesktop/compiz/widget/screen0/match org.freedesktop.compiz.get");
1217
 
                g_print ("cDbusAnswer : '%s'\n", cDbusAnswer);
1218
 
                gchar *cRule = NULL;
1219
 
                gchar *str = strchr (cDbusAnswer, '\n');
1220
 
                if (str)
1221
 
                {
1222
 
                        str ++;
1223
 
                        while (*str == ' ')
1224
 
                                str ++;
1225
 
                        if (strncmp (str, "string", 6) == 0)
1226
 
                        {
1227
 
                                str += 6;
1228
 
                                while (*str == ' ')
1229
 
                                        str ++;
1230
 
                                if (*str == '"')
1231
 
                                {
1232
 
                                        str ++;
1233
 
                                        gchar *ptr = strrchr (str, '"');
1234
 
                                        if (ptr)
1235
 
                                        {
1236
 
                                                *ptr = '\0';
1237
 
                                                cRule = g_strdup (str);
1238
 
                                        }
1239
 
                                }
1240
 
                        }
1241
 
                }
1242
 
                g_free (cDbusAnswer);
1243
 
                g_print ("got rule : '%s'\n", cRule);
1244
 
                
1245
 
                /// gerer le cas ou Compiz n'est pas lance : comment le distinguer d'une regle vide ?...
1246
 
                if (cRule == NULL)
1247
 
                {
1248
 
                        cd_warning ("couldn't get Widget Layer rule from Compiz");
1249
 
                }
1250
 
                
1251
 
                // on complete la regle si necessaire.
1252
 
                if (cRule == NULL || *cRule == '\0' || (g_strstr_len (cRule, -1, "class=Cairo-dock & type=utility") == NULL && g_strstr_len (cRule, -1, "(class=Cairo-dock) & (type=utility)") == NULL && g_strstr_len (cRule, -1, "name=cairo-dock & type=utility") == NULL))
1253
 
                {
1254
 
                        gchar *cNewRule = (cRule == NULL || *cRule == '\0' ?
1255
 
                                g_strdup ("(class=Cairo-dock & type=utility)") :
1256
 
                                g_strdup_printf ("(%s) | (class=Cairo-dock & type=utility)", cRule));
1257
 
                        g_print ("set rule : %s\n", cNewRule);
1258
 
                        gchar *cCommand = g_strdup_printf ("dbus-send --print-reply --type=method_call --dest=org.freedesktop.compiz /org/freedesktop/compiz/widget/screen0/match org.freedesktop.compiz.set string:\"%s\"", cNewRule);
1259
 
                        cairo_dock_launch_command_sync (cCommand);
1260
 
                        g_free (cCommand);
1261
 
                        g_free (cNewRule);
1262
 
                }
1263
 
                g_free (cRule);
1264
 
        }
 
981
        if (gtk_check_menu_item_get_active (GTK_CHECK_MENU_ITEM (pMenuItem)))
 
982
                _cairo_dock_set_desklet_accessibility (pDesklet, CAIRO_DESKLET_ON_WIDGET_LAYER);
1265
983
}
1266
984
 
1267
985
static void _cairo_dock_keep_space (GtkCheckMenuItem *pMenuItem, gpointer *data)
1268
986
{
1269
 
        Icon *icon = data[0];
1270
987
        CairoDesklet *pDesklet = data[1];
1271
 
        if (icon == NULL)  // cas de l'applet Terminal par exemple.
1272
 
                icon = pDesklet->pIcon;
1273
 
        
1274
 
        gboolean bReserveSpace = gtk_check_menu_item_get_active (GTK_CHECK_MENU_ITEM (pMenuItem));
1275
 
        g_print (" %s (%d)\n", __func__, bReserveSpace);
1276
 
        
1277
 
        Window Xid = GDK_WINDOW_XID (pDesklet->container.pWidget->window);
1278
 
        pDesklet->bSpaceReserved = bReserveSpace;
1279
 
        //cairo_dock_set_xwindow_type_hint (Xid, bReserveSpace ? "_NET_WM_WINDOW_TYPE_DOCK" : "_NET_WM_WINDOW_TYPE_NORMAL");
1280
 
        cairo_dock_reserve_space_for_desklet (pDesklet, bReserveSpace);
1281
 
        
1282
 
        if (CAIRO_DOCK_IS_APPLET (icon) && bReserveSpace)
1283
 
                cairo_dock_update_conf_file (icon->pModuleInstance->cConfFilePath,
1284
 
                        G_TYPE_INT, "Desklet", "accessibility", CAIRO_DESKLET_RESERVE_SPACE,
1285
 
                        G_TYPE_INVALID);
 
988
        if (gtk_check_menu_item_get_active (GTK_CHECK_MENU_ITEM (pMenuItem)))
 
989
                _cairo_dock_set_desklet_accessibility (pDesklet, CAIRO_DESKLET_RESERVE_SPACE);
1286
990
}
1287
991
 
1288
992
static void _cairo_dock_set_on_all_desktop (GtkCheckMenuItem *pMenuItem, gpointer *data)
1289
993
{
1290
 
        Icon *icon = data[0];
1291
994
        CairoDesklet *pDesklet = data[1];
1292
 
        if (icon == NULL)  // cas de l'applet Terminal par exemple.
1293
 
                icon = pDesklet->pIcon;
1294
 
        
1295
995
        gboolean bSticky = gtk_check_menu_item_get_active (GTK_CHECK_MENU_ITEM (pMenuItem));
1296
 
        g_print ("%s (%d)\n", __func__, bSticky);
1297
 
        int iNumDesktop;
1298
 
        if (bSticky)
1299
 
        {
1300
 
                gtk_window_stick (GTK_WINDOW (pDesklet->container.pWidget));
1301
 
                iNumDesktop = -1;
1302
 
        }
1303
 
        else
1304
 
        {
1305
 
                gtk_window_unstick (GTK_WINDOW (pDesklet->container.pWidget));
1306
 
                int iCurrentDesktop, iCurrentViewportX, iCurrentViewportY;
1307
 
                cairo_dock_get_current_desktop_and_viewport (&iCurrentDesktop, &iCurrentViewportX, &iCurrentViewportY);
1308
 
                iNumDesktop = iCurrentDesktop * g_iNbViewportX * g_iNbViewportY + iCurrentViewportX * g_iNbViewportY + iCurrentViewportY;
1309
 
                g_print (">>> on colle ce desklet sur le bureau %d\n", iNumDesktop);
1310
 
        }
1311
 
        if (CAIRO_DOCK_IS_APPLET (icon))
1312
 
                cairo_dock_update_conf_file (icon->pModuleInstance->cConfFilePath,
1313
 
                        G_TYPE_BOOLEAN, "Desklet", "sticky", bSticky,
1314
 
                        G_TYPE_INT, "Desklet", "num desktop", iNumDesktop,
1315
 
                        G_TYPE_INVALID);
 
996
        cairo_dock_set_desklet_sticky (pDesklet, bSticky);
1316
997
}
1317
998
 
1318
999
static void _cairo_dock_lock_position (GtkMenuItem *pMenuItem, gpointer *data)
1319
1000
{
1320
 
        Icon *icon = data[0];
1321
1001
        CairoDesklet *pDesklet = data[1];
1322
 
        if (icon == NULL)  // cas de l'applet Terminal par exemple.
1323
 
                icon = pDesklet->pIcon;
1324
 
        
1325
 
        pDesklet->bPositionLocked = ! pDesklet->bPositionLocked;
1326
 
        if (CAIRO_DOCK_IS_APPLET (icon))
1327
 
                cairo_dock_update_conf_file (icon->pModuleInstance->cConfFilePath,
1328
 
                        G_TYPE_BOOLEAN, "Desklet", "locked", pDesklet->bPositionLocked,
1329
 
                        G_TYPE_INVALID);
 
1002
        gboolean bLocked = gtk_check_menu_item_get_active (GTK_CHECK_MENU_ITEM (pMenuItem));
 
1003
        cairo_dock_lock_desklet_position (pDesklet, bLocked);
1330
1004
}
1331
1005
 
1332
1006
 
1335
1009
        static gpointer *s_pDesktopData = NULL;
1336
1010
        GtkWidget *pMenuItem, *image;
1337
1011
        
1338
 
        if (g_iNbDesktops > 1 || g_iNbViewportX > 1 || g_iNbViewportY > 1)
 
1012
        if (g_desktopGeometry.iNbDesktops > 1 || g_desktopGeometry.iNbViewportX > 1 || g_desktopGeometry.iNbViewportY > 1)
1339
1013
        {
1340
1014
                int i, j, k, iDesktopCode;
1341
1015
                const gchar *cLabel;
1342
 
                if (g_iNbDesktops > 1 && (g_iNbViewportX > 1 || g_iNbViewportY > 1))
 
1016
                if (g_desktopGeometry.iNbDesktops > 1 && (g_desktopGeometry.iNbViewportX > 1 || g_desktopGeometry.iNbViewportY > 1))
1343
1017
                        cLabel = bAll ? _("Move all to desktop %d - face %d") : _("Move to desktop %d - face %d");
1344
 
                else if (g_iNbDesktops > 1)
 
1018
                else if (g_desktopGeometry.iNbDesktops > 1)
1345
1019
                        cLabel = bAll ? _("Move all to desktop %d") : _("Move to desktop %d");
1346
1020
                else
1347
1021
                        cLabel = bAll ? _("Move all to face %d") : _("Move to face %d");
1348
1022
                GString *sDesktop = g_string_new ("");
1349
1023
                g_free (s_pDesktopData);
1350
 
                s_pDesktopData = g_new0 (gpointer, 4 * g_iNbDesktops * g_iNbViewportX * g_iNbViewportY);
 
1024
                s_pDesktopData = g_new0 (gpointer, 4 * g_desktopGeometry.iNbDesktops * g_desktopGeometry.iNbViewportX * g_desktopGeometry.iNbViewportY);
1351
1025
                gpointer *user_data;
1352
1026
                
1353
 
                for (i = 0; i < g_iNbDesktops; i ++)  // on range par bureau.
 
1027
                for (i = 0; i < g_desktopGeometry.iNbDesktops; i ++)  // on range par bureau.
1354
1028
                {
1355
 
                        for (j = 0; j < g_iNbViewportY; j ++)  // puis par rangee.
 
1029
                        for (j = 0; j < g_desktopGeometry.iNbViewportY; j ++)  // puis par rangee.
1356
1030
                        {
1357
 
                                for (k = 0; k < g_iNbViewportX; k ++)
 
1031
                                for (k = 0; k < g_desktopGeometry.iNbViewportX; k ++)
1358
1032
                                {
1359
 
                                        if (g_iNbDesktops > 1 && (g_iNbViewportX > 1 || g_iNbViewportY > 1))
1360
 
                                                g_string_printf (sDesktop, cLabel, i+1, j*g_iNbViewportX+k+1);
1361
 
                                        else if (g_iNbDesktops > 1)
 
1033
                                        if (g_desktopGeometry.iNbDesktops > 1 && (g_desktopGeometry.iNbViewportX > 1 || g_desktopGeometry.iNbViewportY > 1))
 
1034
                                                g_string_printf (sDesktop, cLabel, i+1, j*g_desktopGeometry.iNbViewportX+k+1);
 
1035
                                        else if (g_desktopGeometry.iNbDesktops > 1)
1362
1036
                                                g_string_printf (sDesktop, cLabel, i+1);
1363
1037
                                        else
1364
 
                                                g_string_printf (sDesktop, cLabel, j*g_iNbViewportX+k+1);
1365
 
                                        iDesktopCode = i * g_iNbViewportY * g_iNbViewportX + j * g_iNbViewportY + k;
 
1038
                                                g_string_printf (sDesktop, cLabel, j*g_desktopGeometry.iNbViewportX+k+1);
 
1039
                                        iDesktopCode = i * g_desktopGeometry.iNbViewportY * g_desktopGeometry.iNbViewportX + j * g_desktopGeometry.iNbViewportY + k;
1366
1040
                                        user_data = &s_pDesktopData[4*iDesktopCode];
1367
1041
                                        user_data[0] = data;
1368
1042
                                        user_data[1] = GINT_TO_POINTER (i);
1376
1050
                g_string_free (sDesktop, TRUE);
1377
1051
        }
1378
1052
}
 
1053
static void _add_add_entry (GtkWidget *pMenu, gpointer *data, gboolean bAddSeparator, gboolean bAddLauncher)
 
1054
{
 
1055
        GtkWidget *pMenuItem = gtk_separator_menu_item_new ();
 
1056
        gtk_menu_shell_append  (GTK_MENU_SHELL (pMenu), pMenuItem);
 
1057
        
 
1058
        pMenuItem = _add_entry_in_menu (_("Add"), GTK_STOCK_ADD, NULL, pMenu);
 
1059
        GtkWidget *pSubMenuAdd = gtk_menu_new ();
 
1060
        gtk_menu_item_set_submenu (GTK_MENU_ITEM (pMenuItem), pSubMenuAdd);
 
1061
        
 
1062
        _add_entry_in_menu (_("Add a sub-dock"), GTK_STOCK_ADD, cairo_dock_add_sub_dock, pSubMenuAdd);
 
1063
        
 
1064
        _add_entry_in_menu (_("Add a main dock"), GTK_STOCK_ADD, cairo_dock_add_main_dock, pSubMenuAdd);
 
1065
        
 
1066
        if (bAddSeparator)
 
1067
                _add_entry_in_menu (_("Add a separator"), GTK_STOCK_ADD, cairo_dock_add_separator, pSubMenuAdd);
 
1068
        
 
1069
        if (bAddLauncher)
 
1070
        {
 
1071
                pMenuItem = _add_entry_in_menu (_("Add a custom launcher"), GTK_STOCK_ADD, cairo_dock_add_launcher, pSubMenuAdd);
 
1072
                gtk_widget_set_tooltip_text (pMenuItem, _("Usually you would drag a launcher from the menu and drop it on the dock."));
 
1073
        }
 
1074
}
1379
1075
gboolean cairo_dock_notification_build_icon_menu (gpointer *pUserData, Icon *icon, CairoContainer *pContainer, GtkWidget *menu)
1380
1076
{
1381
1077
        static gpointer *data = NULL;
1392
1088
        {
1393
1089
                if (! cairo_dock_is_locked ())
1394
1090
                {
1395
 
                        pMenuItem = gtk_separator_menu_item_new ();
1396
 
                        gtk_menu_shell_append  (GTK_MENU_SHELL (menu), pMenuItem);
1397
 
                        
1398
 
                        pMenuItem = _add_entry_in_menu (_("Add"), GTK_STOCK_ADD, NULL, menu);
1399
 
                        GtkWidget *pSubMenuAdd = gtk_menu_new ();
1400
 
                        gtk_menu_item_set_submenu (GTK_MENU_ITEM (pMenuItem), pSubMenuAdd);
1401
 
                        
1402
 
                        _add_entry_in_menu (_("Add a sub-dock"), GTK_STOCK_ADD, cairo_dock_add_container, pSubMenuAdd);
1403
 
                        
1404
 
                        _add_entry_in_menu (_("Add a separator"), GTK_STOCK_ADD, cairo_dock_add_separator, pSubMenuAdd);
1405
 
                        
1406
 
                        pMenuItem = _add_entry_in_menu (_("Add a custom launcher"), GTK_STOCK_ADD, cairo_dock_add_launcher, pSubMenuAdd);
1407
 
                        gtk_widget_set_tooltip_text (pMenuItem, _("Usually you would drag a launcher from the menu and drop it into the dock."));
 
1091
                        _add_add_entry (menu, data, FALSE, TRUE);
1408
1092
                }
1409
1093
                return CAIRO_DOCK_LET_PASS_NOTIFICATION;
1410
1094
        }
1411
1095
 
1412
 
        //\_________________________ On rajoute des actions suivant le type de l'icone.
1413
 
        ///if (CAIRO_DOCK_IS_LAUNCHER (icon) || CAIRO_DOCK_IS_USER_SEPARATOR (icon) || (icon != NULL && icon->cDesktopFileName != NULL))  // le dernier cas est la pour les cas ou l'utilisateur aurait par megarde efface la commande du lanceur (cas qui ne devrait plus arriver).
 
1096
        //\_________________________ On rajoute des actions de modifications sur le dock.
 
1097
        if (! cairo_dock_is_locked () && CAIRO_DOCK_IS_DOCK (pContainer) && icon && (cairo_dock_get_icon_order (icon) == cairo_dock_get_group_order (CAIRO_DOCK_LAUNCHER) || cairo_dock_get_icon_order (icon) == cairo_dock_get_group_order (CAIRO_DOCK_APPLET)))
1414
1098
        {
1415
 
                //\_________________________ On rajoute les actions sur les icones de fichiers.
1416
 
                if (CAIRO_DOCK_IS_URI_LAUNCHER (icon))
1417
 
                {
1418
 
                        if (icon->iVolumeID > 0)
1419
 
                        {
1420
 
                                gboolean bIsMounted = FALSE;
1421
 
                                cd_message ("%s (%s / %s)\n", __func__, icon->cName, icon->cCommand);
1422
 
                                gchar *cActivationURI = cairo_dock_fm_is_mounted  (icon->cBaseURI, &bIsMounted);
1423
 
                                cd_message ("  cActivationURI : %s; bIsMounted : %d\n", cActivationURI, bIsMounted);
1424
 
                                g_free (cActivationURI);
1425
 
 
1426
 
                                pMenuItem = gtk_menu_item_new_with_label (bIsMounted ? _("Unmount") : _("Mount"));
1427
 
                                gtk_menu_shell_append  (GTK_MENU_SHELL (menu), pMenuItem);
1428
 
                                g_signal_connect (G_OBJECT (pMenuItem), "activate", G_CALLBACK(_cairo_dock_mount_unmount), data);
1429
 
                                
1430
 
                                if (cairo_dock_fm_can_eject (icon->cCommand))
1431
 
                                {
1432
 
                                        pMenuItem = gtk_menu_item_new_with_label (_("Eject"));
1433
 
                                        gtk_menu_shell_append  (GTK_MENU_SHELL (menu), pMenuItem);
1434
 
                                        g_signal_connect (G_OBJECT (pMenuItem), "activate", G_CALLBACK(_cairo_dock_eject), data);
1435
 
                                }
1436
 
                        }
1437
 
                        else
1438
 
                        {
1439
 
                                pMenuItem = gtk_menu_item_new_with_label (_("Delete this file"));
1440
 
                                gtk_menu_shell_append  (GTK_MENU_SHELL (menu), pMenuItem);
1441
 
                                g_signal_connect (G_OBJECT (pMenuItem), "activate", G_CALLBACK(_cairo_dock_delete_file), data);
1442
 
 
1443
 
                                pMenuItem = gtk_menu_item_new_with_label (_("Rename this file"));
1444
 
                                gtk_menu_shell_append  (GTK_MENU_SHELL (menu), pMenuItem);
1445
 
                                g_signal_connect (G_OBJECT (pMenuItem), "activate", G_CALLBACK(_cairo_dock_rename_file), data);
1446
 
 
1447
 
                                pMenuItem = gtk_menu_item_new_with_label (_("Properties"));
1448
 
                                gtk_menu_shell_append  (GTK_MENU_SHELL (menu), pMenuItem);
1449
 
                                g_signal_connect (G_OBJECT (pMenuItem), "activate", G_CALLBACK(_cairo_dock_show_file_properties), data);
1450
 
                        }
1451
 
                        if (icon->cDesktopFileName == NULL)  // un lanceur sans fichier .desktop, on est donc dans un sous-dock ou l'on ne peut pas faire d'autre action.
1452
 
                                return CAIRO_DOCK_LET_PASS_NOTIFICATION;
1453
 
                }
1454
 
                
1455
 
                //\_________________________ On rajoute des actions de modifications sur le dock.
1456
 
                if (! cairo_dock_is_locked () && CAIRO_DOCK_IS_DOCK (pContainer) && icon && cairo_dock_get_icon_order (icon) == cairo_dock_get_group_order (CAIRO_DOCK_LAUNCHER))
1457
 
                {
1458
 
                        pMenuItem = gtk_separator_menu_item_new ();
1459
 
                        gtk_menu_shell_append  (GTK_MENU_SHELL (menu), pMenuItem);
1460
 
        
1461
 
                        pMenuItem = _add_entry_in_menu (_("Add"), GTK_STOCK_ADD, NULL, menu);
1462
 
                        GtkWidget *pSubMenuAdd = gtk_menu_new ();
1463
 
                        gtk_menu_item_set_submenu (GTK_MENU_ITEM (pMenuItem), pSubMenuAdd);
1464
 
                        
1465
 
                        _add_entry_in_menu (_("Add a sub-dock"), GTK_STOCK_ADD, cairo_dock_add_container, pSubMenuAdd);
1466
 
                        
1467
 
                        _add_entry_in_menu (_("Add a separator"), GTK_STOCK_ADD, cairo_dock_add_separator, pSubMenuAdd);
1468
 
                        
1469
 
                        pMenuItem = _add_entry_in_menu (_("Add a custom launcher"), GTK_STOCK_ADD, cairo_dock_add_launcher, pSubMenuAdd);
1470
 
                        gtk_widget_set_tooltip_text (pMenuItem, _("Usually you would drag a launcher from the menu and drop it into the dock."));
 
1099
                Icon *pPointingIcon = cairo_dock_search_icon_pointing_on_dock (CAIRO_DOCK (pContainer), NULL);
 
1100
                if (!pPointingIcon || CAIRO_DOCK_IS_CONTAINER_LAUNCHER (pPointingIcon))
 
1101
                {
 
1102
                        _add_add_entry (menu, data, ! CAIRO_DOCK_IS_SEPARATOR (icon), cairo_dock_get_icon_order (icon) == cairo_dock_get_group_order (CAIRO_DOCK_LAUNCHER));
1471
1103
                
1472
1104
                        if (icon->cDesktopFileName != NULL && icon->cParentDockName != NULL)  // possede un .desktop.
1473
1105
                        {
1474
1106
                                pMenuItem = gtk_separator_menu_item_new ();
1475
1107
                                gtk_menu_shell_append (GTK_MENU_SHELL (menu), pMenuItem);
1476
1108
                        
 
1109
                                _add_entry_in_menu (CAIRO_DOCK_IS_USER_SEPARATOR (icon) ? _("Modify this separator") : _("Modify this launcher"), GTK_STOCK_EDIT, _cairo_dock_modify_launcher, menu);
 
1110
                                
1477
1111
                                pMenuItem = _add_entry_in_menu (CAIRO_DOCK_IS_USER_SEPARATOR (icon) ? _("Remove this separator") : _("Remove this launcher"), GTK_STOCK_REMOVE, _cairo_dock_remove_launcher, menu);
1478
 
                                gtk_widget_set_tooltip_text (pMenuItem, _("You can remove a launcher by dragging it with the mouse out of the dock."));
1479
 
                        
1480
 
                                _add_entry_in_menu (CAIRO_DOCK_IS_USER_SEPARATOR (icon) ? _("Modify this separator") : _("Modify this launcher"), GTK_STOCK_EDIT, _cairo_dock_modify_launcher, menu);
 
1112
                                gtk_widget_set_tooltip_text (pMenuItem, _("You can remove a launcher by dragging it out of the dock with the mouse ."));
1481
1113
                                
1482
1114
                                pMenuItem = _add_entry_in_menu (_("Move to another dock"), GTK_STOCK_JUMP_TO, NULL, menu);
1483
1115
                                GtkWidget *pSubMenuDocks = gtk_menu_new ();
1484
1116
                                gtk_menu_item_set_submenu (GTK_MENU_ITEM (pMenuItem), pSubMenuDocks);
1485
1117
                                g_object_set_data (G_OBJECT (pSubMenuDocks), "launcher", icon);
1486
 
                                pMenuItem = cairo_dock_add_in_menu_with_stock_and_data (_("A new main dock"), GTK_STOCK_NEW, (GFunc)_cairo_dock_move_launcher_to_dock, pSubMenuDocks, NULL);
 
1118
                                pMenuItem = cairo_dock_add_in_menu_with_stock_and_data (_("New main dock"), GTK_STOCK_NEW, (GFunc)_cairo_dock_move_launcher_to_dock, pSubMenuDocks, NULL);
1487
1119
                                g_object_set_data (G_OBJECT (pMenuItem), "launcher", icon);
1488
1120
                                cairo_dock_foreach_docks ((GHFunc) _add_one_dock_to_menu, pSubMenuDocks);
1489
1121
                        }
1490
1122
                }
1491
1123
        }
1492
1124
        
 
1125
        //\_________________________ On rajoute les actions sur les applis.
1493
1126
        if (CAIRO_DOCK_IS_APPLI (icon))
1494
1127
        {
1495
1128
                pMenuItem = gtk_separator_menu_item_new ();
1523
1156
                
1524
1157
                _add_desktops_entry (pSubMenuOtherActions, FALSE, data);
1525
1158
                
 
1159
                if (myTaskBar.bOverWriteXIcons)
 
1160
                {
 
1161
                        gchar *cCustomIcon = g_strdup_printf ("%s/%s.png", g_cCurrentIconsPath, icon->cClass);
 
1162
                        if (!g_file_test (cCustomIcon, G_FILE_TEST_EXISTS))
 
1163
                        {
 
1164
                                g_free (cCustomIcon);
 
1165
                                cCustomIcon = g_strdup_printf ("%s/%s.svg", g_cCurrentIconsPath, icon->cClass);
 
1166
                                if (!g_file_test (cCustomIcon, G_FILE_TEST_EXISTS))
 
1167
                                {
 
1168
                                        g_free (cCustomIcon);
 
1169
                                        cCustomIcon = NULL;
 
1170
                                }
 
1171
                        }
 
1172
                        if (cCustomIcon != NULL)
 
1173
                        {
 
1174
                                _add_entry_in_menu (_("Remove custom icon"), GTK_STOCK_REMOVE, _cairo_dock_remove_custom_appli_icon, pSubMenuOtherActions);
 
1175
                        }
 
1176
                }
 
1177
                
1526
1178
                _add_entry_in_menu (_("Kill"), GTK_STOCK_CANCEL, _cairo_dock_kill_appli, pSubMenuOtherActions);
1527
1179
                
1528
1180
                //\_________________________ On rajoute les actions courantes sur les icones d'applis.
1538
1190
                
1539
1191
                _add_entry_in_menu (_("Show"), GTK_STOCK_FIND, _cairo_dock_show_appli, menu);
1540
1192
                
1541
 
                _add_entry_in_menu (icon->bIsMaximized ? _("Unmaximize") : _("Maximize"), icon->bIsMaximized ? CAIRO_DOCK_SHARE_DATA_DIR"/icon-restore.png" : CAIRO_DOCK_SHARE_DATA_DIR"/icon-maximize.png", _cairo_dock_maximize_appli, menu);
 
1193
                _add_entry_in_menu (icon->bIsMaximized ? _("Unmaximise") : _("Maximise"), icon->bIsMaximized ? CAIRO_DOCK_SHARE_DATA_DIR"/icon-restore.png" : CAIRO_DOCK_SHARE_DATA_DIR"/icon-maximize.png", _cairo_dock_maximize_appli, menu);
1542
1194
                
1543
1195
                if (! icon->bIsHidden)
1544
 
                        _add_entry_in_menu (_("Minimize"), CAIRO_DOCK_SHARE_DATA_DIR"/icon-minimize.png", _cairo_dock_minimize_appli, menu);
 
1196
                        _add_entry_in_menu (_("Minimise"), CAIRO_DOCK_SHARE_DATA_DIR"/icon-minimize.png", _cairo_dock_minimize_appli, menu);
1545
1197
 
1546
1198
                _add_entry_in_menu (_("Close (middle-click)"), CAIRO_DOCK_SHARE_DATA_DIR"/icon-close.png", _cairo_dock_close_appli, menu);
1547
1199
        }
1550
1202
                pMenuItem = gtk_separator_menu_item_new ();
1551
1203
                gtk_menu_shell_append (GTK_MENU_SHELL (menu), pMenuItem);
1552
1204
                
1553
 
                //\_________________________ On rajoute les actions supplementaires sur toutes les icones du sous-dock.
 
1205
                //\_________________________ On rajoute les actions supplementaires sur la classe.
1554
1206
                pMenuItem = gtk_menu_item_new_with_label (_("Other actions"));
1555
1207
                gtk_menu_shell_append  (GTK_MENU_SHELL (menu), pMenuItem);
1556
1208
                GtkWidget *pSubMenuOtherActions = gtk_menu_new ();
1567
1219
                
1568
1220
                _add_entry_in_menu (_("Show all"), GTK_STOCK_FIND, _cairo_dock_show_class, menu);
1569
1221
 
1570
 
                _add_entry_in_menu (_("Minimize all"), CAIRO_DOCK_SHARE_DATA_DIR"/icon-minimize.png", _cairo_dock_minimize_class, menu);
 
1222
                _add_entry_in_menu (_("Minimise all"), CAIRO_DOCK_SHARE_DATA_DIR"/icon-minimize.png", _cairo_dock_minimize_class, menu);
1571
1223
                
1572
1224
                _add_entry_in_menu (_("Close all"), CAIRO_DOCK_SHARE_DATA_DIR"/icon-close.png", _cairo_dock_close_class, menu);
1573
1225
        }
1574
1226
        
1575
 
        if (g_pMainDock != NULL && (CAIRO_DOCK_IS_APPLET (icon) || CAIRO_DOCK_IS_DESKLET (pContainer)))
 
1227
        //\_________________________ On rajoute les actions sur les applets/desklets.
 
1228
        if (CAIRO_DOCK_IS_APPLET (icon) || CAIRO_DOCK_IS_DESKLET (pContainer))
1576
1229
        {
1577
1230
                Icon *pIconModule;
1578
1231
                if (CAIRO_DOCK_IS_APPLET (icon))
1592
1245
        
1593
1246
                        if (pIconModule->pModuleInstance->bCanDetach)
1594
1247
                        {
1595
 
                                _add_entry_in_menu (CAIRO_DOCK_IS_DOCK (pContainer) ? _("Detach this applet") : _("Return to dock"), CAIRO_DOCK_IS_DOCK (pContainer) ? GTK_STOCK_DISCONNECT : GTK_STOCK_CONNECT, _cairo_dock_detach_module, menu);
 
1248
                                _add_entry_in_menu (CAIRO_DOCK_IS_DOCK (pContainer) ? _("Detach this applet") : _("Return to the dock"), CAIRO_DOCK_IS_DOCK (pContainer) ? GTK_STOCK_DISCONNECT : GTK_STOCK_CONNECT, _cairo_dock_detach_module, menu);
1596
1249
                        }
1597
1250
                        
1598
1251
                        _add_entry_in_menu (_("Remove this applet"), GTK_STOCK_REMOVE, _cairo_dock_remove_module_instance, menu);
1608
1261
                                GtkWidget *pSubMenuDocks = gtk_menu_new ();
1609
1262
                                gtk_menu_item_set_submenu (GTK_MENU_ITEM (pMenuItem), pSubMenuDocks);
1610
1263
                                g_object_set_data (G_OBJECT (pSubMenuDocks), "launcher", pIconModule);
1611
 
                                pMenuItem = cairo_dock_add_in_menu_with_stock_and_data (_("A new main dock"), GTK_STOCK_NEW, (GFunc)_cairo_dock_move_launcher_to_dock, pSubMenuDocks, NULL);
 
1264
                                pMenuItem = cairo_dock_add_in_menu_with_stock_and_data (_("New main dock"), GTK_STOCK_NEW, (GFunc)_cairo_dock_move_launcher_to_dock, pSubMenuDocks, NULL);
1612
1265
                                g_object_set_data (G_OBJECT (pMenuItem), "launcher", pIconModule);
1613
1266
                                cairo_dock_foreach_docks ((GHFunc) _add_one_dock_to_menu, pSubMenuDocks);
1614
1267
                        }
1662
1315
                if (bIsUtility)
1663
1316
                        gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(pMenuItem), TRUE);
1664
1317
                g_signal_connect(G_OBJECT(pMenuItem), "toggled", G_CALLBACK(_cairo_dock_keep_on_widget_layer), data);
1665
 
                gtk_widget_set_tooltip_text (pMenuItem, _("set behaviour in Compiz to: (name=cairo-dock & type=utility)"));
 
1318
                gtk_widget_set_tooltip_text (pMenuItem, _("Set behaviour in Compiz to: (name=cairo-dock & type=utility)"));
1666
1319
                
1667
1320
                pMenuItem = gtk_radio_menu_item_new_with_label(group, _("Reserve space"));
1668
1321
                group = gtk_radio_menu_item_get_group(GTK_RADIO_MENU_ITEM(pMenuItem));
1686
1339
 
1687
1340
        return CAIRO_DOCK_LET_PASS_NOTIFICATION;
1688
1341
}
1689
 
 
1690
 
 
1691
 
 
1692
 
static void _cairo_dock_delete_menu (GtkMenuShell *menu, CairoDock *pDock)
1693
 
{
1694
 
        g_return_if_fail (CAIRO_DOCK_IS_DOCK (pDock));
1695
 
        pDock->bMenuVisible = FALSE;
1696
 
        
1697
 
        cd_message ("on force a quitter");
1698
 
        pDock->container.bInside = TRUE;
1699
 
        ///pDock->bAtBottom = FALSE;
1700
 
        cairo_dock_emit_leave_signal (pDock);
1701
 
        /*cairo_dock_on_leave_notify (pDock->container.pWidget,
1702
 
                NULL,
1703
 
                pDock);*/
1704
 
}
1705
 
void cairo_dock_popup_menu_on_container (GtkWidget *menu, CairoContainer *pContainer)
1706
 
{
1707
 
        if (CAIRO_DOCK_IS_DOCK (pContainer))
1708
 
        {
1709
 
                if (g_signal_handler_find (menu,
1710
 
                        G_SIGNAL_MATCH_FUNC | G_SIGNAL_MATCH_DATA,
1711
 
                        0,
1712
 
                        0,
1713
 
                        NULL,
1714
 
                        _cairo_dock_delete_menu,
1715
 
                        pContainer) == 0)  // on evite de connecter 2 fois ce signal, donc la fonction est appelable plusieurs fois.
1716
 
                {
1717
 
                        g_signal_connect (G_OBJECT (menu),
1718
 
                                "deactivate",
1719
 
                                G_CALLBACK (_cairo_dock_delete_menu),
1720
 
                                pContainer);
1721
 
                }
1722
 
                CAIRO_DOCK (pContainer)->bMenuVisible = TRUE;
1723
 
        }
1724
 
        
1725
 
        gtk_widget_show_all (menu);
1726
 
 
1727
 
        gtk_menu_popup (GTK_MENU (menu),
1728
 
                NULL,
1729
 
                NULL,
1730
 
                NULL,
1731
 
                NULL,
1732
 
                1,
1733
 
                gtk_get_current_event_time ());
1734
 
}
1735
 
 
1736
 
 
1737
 
GtkWidget *cairo_dock_add_in_menu_with_stock_and_data (const gchar *cLabel, const gchar *gtkStock, GFunc pFunction, GtkWidget *pMenu, gpointer pData)
1738
 
{
1739
 
        GtkWidget *pMenuItem = gtk_image_menu_item_new_with_label (cLabel);
1740
 
        if (gtkStock)
1741
 
        {
1742
 
                GtkWidget *image = NULL;
1743
 
                if (*gtkStock == '/')
1744
 
                {
1745
 
                        GdkPixbuf *pixbuf = gdk_pixbuf_new_from_file_at_size (gtkStock, 16, 16, NULL);
1746
 
                        image = gtk_image_new_from_pixbuf (pixbuf);
1747
 
                        g_object_unref (pixbuf);
1748
 
                }
1749
 
                else
1750
 
                {
1751
 
                        image = gtk_image_new_from_stock (gtkStock, GTK_ICON_SIZE_MENU);
1752
 
                }
1753
 
                gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (pMenuItem), image);
1754
 
        }
1755
 
        gtk_menu_shell_append  (GTK_MENU_SHELL (pMenu), pMenuItem);
1756
 
        if (pFunction)
1757
 
                g_signal_connect (G_OBJECT (pMenuItem), "activate", G_CALLBACK (pFunction), pData);
1758
 
        return pMenuItem;
1759
 
}
1760
 
 
1761
 
 
1762
 
GtkWidget *cairo_dock_build_menu (Icon *icon, CairoContainer *pContainer)
1763
 
{
1764
 
        static GtkWidget *s_pMenu = NULL;
1765
 
        if (s_pMenu != NULL)
1766
 
        {
1767
 
                gtk_widget_destroy (s_pMenu);
1768
 
                s_pMenu = NULL;
1769
 
        }
1770
 
        g_return_val_if_fail (pContainer != NULL, NULL);
1771
 
        
1772
 
        //\_________________________ On construit le menu.
1773
 
        GtkWidget *menu = gtk_menu_new ();
1774
 
        s_pMenu = menu;
1775
 
        
1776
 
        //\_________________________ On passe la main a ceux qui veulent y rajouter des choses.
1777
 
        cairo_dock_notify (CAIRO_DOCK_BUILD_CONTAINER_MENU, pContainer, menu);
1778
 
        
1779
 
        cairo_dock_notify (CAIRO_DOCK_BUILD_ICON_MENU, icon, pContainer, menu);
1780
 
        
1781
 
        return menu;
1782
 
}