← Back to branch summary

~ubuntu-branches/ubuntu/oneiric/gnome-panel/oneiric

« back to all changes in this revision

Viewing changes to gnome-panel/panel.c

  • Committer: Bazaar Package Importer
  • Author(s): Sebastien Bacher
  • Date: 2011-05-30 11:04:49 UTC
  • mfrom: (1.3.4 upstream)
  • mto: This revision was merged to the branch mainline in revision 204.
  • Revision ID: james.westby@ubuntu.com-20110530110449-ut1tc5t61rpvf9e3
Tags: upstream-3.0.2
Import upstream version 3.0.2

Show diffs side-by-side

added added

removed removed

Lines of Context:
gnome-panel/panel.c
18
18
#include <glib/gi18n.h>
19
19
#include <gio/gio.h>
20
20
#include <gdk/gdkkeysyms.h>
 
21
#include <gtk/gtkx.h>
21
22
 
22
23
#include <libpanel-util/panel-glib.h>
23
24
 
24
25
#include "panel.h"
25
26
 
26
27
#include "applet.h"
27
 
#include "drawer.h"
28
28
#include "button-widget.h"
29
29
#include "launcher.h"
 
30
#include "panel-bindings.h"
30
31
#include "panel-context-menu.h"
31
32
#include "panel-util.h"
32
 
#include "panel-config-global.h"
33
 
#include "panel-gconf.h"
34
 
#include "panel-profile.h"
35
33
#include "panel-applet-frame.h"
36
34
#include "panel-action-button.h"
37
35
#include "panel-menu-bar.h"
38
36
#include "panel-separator.h"
39
 
#include "panel-compatibility.h"
40
37
#include "panel-multiscreen.h"
41
38
#include "panel-toplevel.h"
42
39
#include "panel-menu-button.h"
43
40
#include "panel-globals.h"
44
41
#include "panel-lockdown.h"
45
42
#include "panel-icon-names.h"
 
43
#include "panel-layout.h"
 
44
#include "panel-schemas.h"
 
45
#include "panel-user-menu.h"
46
46
 
47
47
enum {
48
48
        TARGET_URL,
78
78
                button_widget_set_orientation (BUTTON_WIDGET (info->widget), orientation);
79
79
                break;
80
80
        case PANEL_OBJECT_MENU_BAR:
81
 
                panel_menu_bar_set_orientation (PANEL_MENU_BAR (info->widget), orientation);
82
 
                break;
83
 
        case PANEL_OBJECT_DRAWER: {
84
 
                Drawer      *drawer = info->data;
85
 
                PanelWidget *panel_widget;
86
 
 
87
 
                panel_widget = panel_toplevel_get_panel_widget (drawer->toplevel);
88
 
 
89
 
                button_widget_set_orientation (BUTTON_WIDGET (info->widget), orientation);
90
 
 
91
 
                gtk_widget_queue_resize (GTK_WIDGET (drawer->toplevel));
92
 
                gtk_container_foreach (GTK_CONTAINER (panel_widget),
93
 
                                       orient_change_foreach,
94
 
                                       panel_widget);
95
 
                }
 
81
        case PANEL_OBJECT_USER_MENU:
 
82
                panel_menu_bar_object_set_orientation (PANEL_MENU_BAR_OBJECT (info->widget), orientation);
96
83
                break;
97
84
        case PANEL_OBJECT_SEPARATOR:
98
85
                panel_separator_set_orientation (PANEL_SEPARATOR (info->widget),
160
147
                        PANEL_APPLET_FRAME (info->widget), panel->background.type);
161
148
                break;
162
149
        case PANEL_OBJECT_MENU_BAR:
163
 
                panel_menu_bar_change_background (PANEL_MENU_BAR (info->widget));
 
150
        case PANEL_OBJECT_USER_MENU:
 
151
                panel_menu_bar_object_change_background (PANEL_MENU_BAR_OBJECT (info->widget));
164
152
                break;
165
153
        case PANEL_OBJECT_SEPARATOR:
166
154
                panel_separator_change_background (PANEL_SEPARATOR (info->widget));
206
194
        back_change(info,PANEL_WIDGET(widget));
207
195
}
208
196
 
209
 
static void
210
 
panel_applet_removed(GtkWidget *widget, GtkWidget *applet, gpointer data)
211
 
{
212
 
        PanelToplevel *toplevel;
213
 
        AppletInfo    *info;
214
 
 
215
 
        toplevel = PANEL_WIDGET (widget)->toplevel;
216
 
        info = g_object_get_data (G_OBJECT (applet), "applet_info");
217
 
 
218
 
        if (info->type == PANEL_OBJECT_DRAWER) {
219
 
                Drawer *drawer = info->data;
220
 
 
221
 
                if (drawer->toplevel)
222
 
                        panel_toplevel_queue_auto_hide (toplevel);
223
 
        }
224
 
}
225
 
 
226
197
static gboolean
227
198
deactivate_idle (gpointer data)
228
199
{
229
200
        PanelData *pd = data;
230
201
        pd->deactivate_idle = 0;
231
202
 
232
 
        pd->insertion_pos = -1;
 
203
        pd->insert_pack_type = PANEL_OBJECT_PACK_START;
233
204
 
234
205
        return FALSE;
235
206
}
252
223
}
253
224
 
254
225
static void
255
 
panel_recreate_context_menu (PanelData *pd)
256
 
{
257
 
        if (pd->menu)
258
 
                g_object_unref (pd->menu);
259
 
        pd->menu = NULL;
260
 
}
261
 
 
262
 
static void
263
226
panel_destroy (PanelToplevel *toplevel,
264
227
               PanelData     *pd)
265
228
{
266
 
        panel_lockdown_notify_remove (G_CALLBACK (panel_recreate_context_menu),
267
 
                                      pd);
268
 
 
269
229
        if (pd->menu) {
270
230
                g_signal_handlers_disconnect_by_func (pd->menu,
271
231
                                                      context_menu_deactivate,
298
258
        panel_applet_save_position (info, info->id, FALSE);
299
259
}
300
260
 
 
261
static void
 
262
panel_menu_lockdown_changed (PanelLockdown *lockdown,
 
263
                             gpointer       user_data)
 
264
{
 
265
        PanelData *pd = user_data;
 
266
 
 
267
        if (pd->menu) {
 
268
                if (gtk_widget_get_visible (pd->menu))
 
269
                        gtk_menu_shell_deactivate (GTK_MENU_SHELL (pd->menu));
 
270
 
 
271
                g_signal_handlers_disconnect_by_func (pd->menu,
 
272
                                                      context_menu_deactivate,
 
273
                                                      pd);
 
274
 
 
275
                g_object_unref (pd->menu);
 
276
                pd->menu = NULL;
 
277
        }
 
278
}
 
279
 
301
280
static GtkWidget *
302
281
panel_menu_get (PanelWidget *panel, PanelData *pd)
303
282
{
304
283
        if (!pd->menu) {
305
 
                pd->menu = g_object_ref_sink (panel_context_menu_create (panel));
306
 
                g_signal_connect (pd->menu, "deactivate",
307
 
                                  G_CALLBACK (context_menu_deactivate),
308
 
                                  pd);
309
 
                g_signal_connect (pd->menu, "show",
310
 
                                  G_CALLBACK (context_menu_show), pd);
 
284
                pd->menu = panel_context_menu_create (panel);
 
285
                if (pd->menu != NULL) {
 
286
                        g_object_ref_sink (pd->menu);
 
287
                        g_signal_connect (pd->menu, "deactivate",
 
288
                                          G_CALLBACK (context_menu_deactivate),
 
289
                                          pd);
 
290
                        g_signal_connect (pd->menu, "show",
 
291
                                          G_CALLBACK (context_menu_show), pd);
 
292
 
 
293
                        panel_lockdown_on_notify (panel_lockdown_get (),
 
294
                                                  NULL,
 
295
                                                  G_OBJECT (pd->menu),
 
296
                                                  panel_menu_lockdown_changed,
 
297
                                                  pd);
 
298
                }
311
299
        }
312
300
 
313
301
        return pd->menu;
329
317
 
330
318
        pd = g_object_get_data (G_OBJECT (panel_widget->toplevel), "PanelData");
331
319
        menu = panel_menu_get (panel_widget, pd);
332
 
        g_object_set_data (G_OBJECT (menu), "menu_panel", panel_widget);
 
320
        if (menu)
 
321
                g_object_set_data (G_OBJECT (menu), "menu_panel", panel_widget);
333
322
 
334
323
        return menu;
335
324
}
349
338
 
350
339
        current_event = gtk_get_current_event ();
351
340
        if (current_event->type == GDK_BUTTON_PRESS)
352
 
                panel_data->insertion_pos = panel_widget_get_cursorloc (panel_widget);
 
341
                panel_data->insert_pack_type = panel_widget_get_insert_pack_type_at_cursor (panel_widget);
353
342
        else
354
 
                panel_data->insertion_pos = -1;
 
343
                panel_data->insert_pack_type = PANEL_OBJECT_PACK_START;
355
344
        
356
345
        menu = make_popup_panel_menu (panel_widget);
357
346
        if (!menu)
366
355
}
367
356
 
368
357
static gboolean
369
 
panel_popup_menu_signal (PanelToplevel *toplevel)
370
 
{
371
 
        return panel_popup_menu (toplevel, 3, GDK_CURRENT_TIME);
372
 
}
373
 
 
374
 
static gboolean
375
358
panel_button_press_event (PanelToplevel  *toplevel,
376
359
                          GdkEventButton *event)
377
360
{
 
361
        guint modifiers;
 
362
 
378
363
        if (event->button != 3)
379
364
                return FALSE;
380
365
 
381
 
        return panel_popup_menu (toplevel, event->button, event->time);
 
366
        modifiers = event->state & gtk_accelerator_get_default_mod_mask ();
 
367
 
 
368
        if (modifiers == panel_bindings_get_mouse_button_modifier_keymask ())
 
369
                return panel_popup_menu (toplevel, event->button, event->time);
 
370
 
 
371
        return FALSE;
382
372
}
383
373
 
384
374
static gboolean
385
 
panel_key_press_event (GtkWidget   *widget,
386
 
                       GdkEventKey *event)
 
375
panel_key_press_event (PanelToplevel *toplevel,
 
376
                       GdkEventKey   *event)
387
377
{
388
 
        /*
389
 
         * If the focus widget is a GtkSocket, i.e. the
390
 
         * focus is in an applet in another process, then key 
391
 
         * bindings do not work. We get around this by
392
 
         * activating the key bindings here.
393
 
         */ 
394
 
        if (GTK_IS_SOCKET (gtk_window_get_focus (GTK_WINDOW (widget))) &&
395
 
            event->keyval == GDK_F10 &&
396
 
            (event->state & gtk_accelerator_get_default_mod_mask ()) == GDK_CONTROL_MASK)
397
 
                return gtk_bindings_activate (GTK_OBJECT (widget),
398
 
                                              event->keyval,
399
 
                                              event->state);
 
378
        gboolean is_popup = FALSE;
 
379
 
 
380
        /* We're not connecting to the popup-menu signal since we want to be
 
381
         * able to handle keybinding of popup-menu + modifier from metacity */
 
382
 
 
383
        panel_util_key_event_is_popup (event, NULL, &is_popup);
 
384
        if (!is_popup)
 
385
                panel_util_key_event_is_popup_panel (event, &is_popup, NULL);
 
386
 
 
387
        if (is_popup)
 
388
                return panel_popup_menu (toplevel, 3, event->time);
400
389
 
401
390
        return FALSE;
 
391
}
 
392
 
 
393
static GSettings *
 
394
get_settings_background_for_toplevel (PanelToplevel *toplevel)
 
395
{
 
396
        char      *toplevel_settings_path;
 
397
        GSettings *settings;
 
398
        GSettings *settings_background;
 
399
 
 
400
        g_object_get (toplevel, "settings-path", &toplevel_settings_path, NULL);
 
401
        settings = g_settings_new_with_path (PANEL_TOPLEVEL_SCHEMA,
 
402
                                             toplevel_settings_path);
 
403
        settings_background = g_settings_get_child (settings,
 
404
                                                    PANEL_BACKGROUND_SCHEMA_CHILD);
 
405
 
 
406
        g_object_unref (settings);
 
407
        g_free (toplevel_settings_path);
 
408
 
 
409
        return settings_background;
402
410
}
403
411
 
404
412
static gboolean
405
413
set_background_image_from_uri (PanelToplevel *toplevel,
406
414
                               const char    *uri)
407
415
{
408
 
        char *image;
409
 
 
410
 
        if ( ! panel_profile_is_writable_background_type (toplevel) ||
411
 
             ! panel_profile_is_writable_background_image (toplevel))
412
 
                return FALSE;
413
 
 
414
 
        if (!(image = g_filename_from_uri (uri, NULL, NULL)))
415
 
                return FALSE;
416
 
 
417
 
        panel_profile_set_background_image (toplevel, image);
418
 
        panel_profile_set_background_type (toplevel, PANEL_BACK_IMAGE);
419
 
 
420
 
        g_free (image);
 
416
        GFile     *file;
 
417
        GSettings *settings;
 
418
 
 
419
        file = g_file_new_for_uri (uri);
 
420
        if (!g_file_is_native (file)) {
 
421
                g_object_unref (file);
 
422
                return FALSE;
 
423
        }
 
424
        g_object_unref (file);
 
425
 
 
426
        settings = get_settings_background_for_toplevel (toplevel);
 
427
 
 
428
        if (!g_settings_is_writable (settings,
 
429
                                     PANEL_BACKGROUND_TYPE_KEY) ||
 
430
            !g_settings_is_writable (settings,
 
431
                                     PANEL_BACKGROUND_IMAGE_URI_KEY)) {
 
432
                g_object_unref (settings);
 
433
                return FALSE;
 
434
        }
 
435
 
 
436
        g_settings_set_string (settings, PANEL_BACKGROUND_IMAGE_URI_KEY, uri);
 
437
        g_settings_set_enum (settings, PANEL_BACKGROUND_TYPE_KEY, PANEL_BACK_IMAGE);
 
438
 
 
439
        g_object_unref (settings);
421
440
 
422
441
        return FALSE;
423
442
}
426
445
set_background_color (PanelToplevel *toplevel,
427
446
                      guint16       *dropped)
428
447
{
429
 
        PanelColor color;
 
448
        GSettings *settings;
 
449
        GdkRGBA    color;
 
450
        char      *color_str;
430
451
 
431
452
        if (!dropped)
432
453
                return FALSE;
433
454
 
434
 
        if ( ! panel_profile_is_writable_background_type (toplevel) ||
435
 
             ! panel_profile_is_writable_background_color (toplevel))
436
 
                return FALSE;
437
 
 
438
 
        color.gdk.red   = dropped [0];
439
 
        color.gdk.green = dropped [1];
440
 
        color.gdk.blue  = dropped [2];
441
 
        color.alpha     = 65535;
442
 
 
443
 
        panel_profile_set_background_color (toplevel, &color);
444
 
        panel_profile_set_background_type (toplevel, PANEL_BACK_COLOR);
445
 
 
446
 
        return TRUE;
447
 
}
448
 
 
449
 
static gboolean
450
 
drop_url (PanelWidget *panel,
451
 
          int          position,
452
 
          const char  *url)
 
455
        settings = get_settings_background_for_toplevel (toplevel);
 
456
 
 
457
        if (!g_settings_is_writable (settings,
 
458
                                     PANEL_BACKGROUND_TYPE_KEY) ||
 
459
            !g_settings_is_writable (settings,
 
460
                                     PANEL_BACKGROUND_COLOR_KEY)) {
 
461
                g_object_unref (settings);
 
462
                return FALSE;
 
463
        }
 
464
 
 
465
        color.red   = dropped [0] / 65535.;
 
466
        color.green = dropped [1] / 65535.;
 
467
        color.blue  = dropped [2] / 65535.;
 
468
        color.alpha = 1.;
 
469
 
 
470
        color_str = gdk_rgba_to_string (&color);
 
471
 
 
472
        g_settings_set_string (settings, PANEL_BACKGROUND_COLOR_KEY, color_str);
 
473
        g_settings_set_enum (settings, PANEL_BACKGROUND_TYPE_KEY, PANEL_BACK_COLOR);
 
474
 
 
475
        g_free (color_str);
 
476
        g_object_unref (settings);
 
477
 
 
478
        return TRUE;
 
479
}
 
480
 
 
481
static gboolean
 
482
reset_background (PanelToplevel *toplevel)
 
483
{
 
484
        GSettings *settings;
 
485
 
 
486
        settings = get_settings_background_for_toplevel (toplevel);
 
487
 
 
488
        if (!g_settings_is_writable (settings,
 
489
                                     PANEL_BACKGROUND_TYPE_KEY)) {
 
490
                g_object_unref (settings);
 
491
                return FALSE;
 
492
        }
 
493
 
 
494
        g_settings_set_enum (settings, PANEL_BACKGROUND_TYPE_KEY, PANEL_BACK_NONE);
 
495
 
 
496
        g_object_unref (settings);
 
497
 
 
498
        return TRUE;
 
499
}
 
500
 
 
501
static gboolean
 
502
drop_url (PanelWidget         *panel,
 
503
          PanelObjectPackType  pack_type,
 
504
          int                  pack_index,
 
505
          const char          *url)
453
506
{
454
507
        enum {
455
508
                NETSCAPE_URL_URL,
461
514
 
462
515
        g_return_val_if_fail (url != NULL, FALSE);
463
516
 
464
 
        if (!panel_profile_id_lists_are_writable ())
 
517
        if (!panel_layout_is_writable ())
465
518
                return FALSE;
466
519
 
467
520
        netscape_url = g_strsplit (url, "\n", 2);
479
532
        else
480
533
                name = netscape_url[NETSCAPE_URL_NAME];
481
534
 
482
 
        panel_launcher_create_from_info (panel->toplevel, position, FALSE,
 
535
        panel_launcher_create_from_info (panel->toplevel, pack_type, pack_index,
 
536
                                         FALSE,
483
537
                                         netscape_url[NETSCAPE_URL_URL],
484
538
                                         name, comment, PANEL_ICON_REMOTE);
485
539
 
490
544
}
491
545
 
492
546
static gboolean
493
 
drop_menu (PanelWidget *panel,
494
 
           int          position,
495
 
           const char  *menu_filename,
496
 
           const char  *menu_path)
 
547
drop_menu (PanelWidget         *panel,
 
548
           PanelObjectPackType  pack_type,
 
549
           int                  pack_index,
 
550
           const char          *menu_filename,
 
551
           const char          *menu_path)
497
552
{
498
 
        if (!panel_profile_id_lists_are_writable ())
 
553
        if (!panel_layout_is_writable ())
499
554
                return FALSE;
500
555
 
501
556
        return panel_menu_button_create (panel->toplevel,
502
 
                                         position,
 
557
                                         pack_type, pack_index,
503
558
                                         menu_filename,
504
559
                                         menu_path,
505
 
                                         menu_path != NULL,
506
560
                                         NULL);
507
561
 
508
562
}
509
563
 
510
564
static gboolean
511
 
drop_uri (PanelWidget *panel,
512
 
          int          position,
513
 
          const char  *uri,
514
 
          const char  *fallback_icon)
 
565
drop_uri (PanelWidget         *panel,
 
566
          PanelObjectPackType  pack_type,
 
567
          int                  pack_index,
 
568
          const char          *uri,
 
569
          const char          *fallback_icon)
515
570
{
516
571
        char  *name;
517
572
        char  *comment;
519
574
        char  *icon;
520
575
        GFile *file;
521
576
 
522
 
        if (!panel_profile_id_lists_are_writable ())
 
577
        if (!panel_layout_is_writable ())
523
578
                return FALSE;
524
579
 
525
580
        name = panel_util_get_label_for_uri (uri);
541
596
        comment = g_strdup_printf (_("Open '%s'"), buf);
542
597
        g_free (buf);
543
598
 
544
 
        panel_launcher_create_from_info (panel->toplevel, position, FALSE,
545
 
                                         uri, name, comment, icon);
 
599
        panel_launcher_create_from_info (panel->toplevel, pack_type, pack_index,
 
600
                                         FALSE, uri, name, comment, icon);
546
601
 
547
602
        g_free (name);
548
603
        g_free (comment);
552
607
}
553
608
 
554
609
static gboolean
555
 
drop_nautilus_desktop_uri (PanelWidget *panel,
556
 
                           int          pos,
557
 
                           const char  *uri)
 
610
drop_nautilus_desktop_uri (PanelWidget         *panel,
 
611
                           PanelObjectPackType  pack_type,
 
612
                           int                  pack_index,
 
613
                           const char          *uri)
558
614
{
559
615
        gboolean    success;
560
616
        const char *id;
565
621
                        return FALSE;
566
622
 
567
623
        success = TRUE;
568
 
        id = panel_profile_get_toplevel_id (panel->toplevel);
 
624
        id = panel_toplevel_get_id (panel->toplevel);
569
625
        basename = uri + strlen ("x-nautilus-desktop:///");
570
626
 
571
627
        if (strncmp (basename, "trash", strlen ("trash")) == 0)
572
 
                panel_applet_frame_create (panel->toplevel, pos,
 
628
                panel_applet_frame_create (panel->toplevel, pack_type, pack_index,
573
629
                                           "OAFIID:GNOME_Panel_TrashApplet");
574
 
        else if (strncmp (basename, "home", strlen ("home")) == 0)
575
 
                panel_launcher_create_with_id (id, pos,
576
 
                                               "nautilus-home.desktop");
577
 
        else if (strncmp (basename, "computer", strlen ("computer")) == 0)
578
 
                panel_launcher_create_with_id (id, pos,
579
 
                                               "nautilus-computer.desktop");
 
630
        else if (strncmp (basename, "home", strlen ("home")) == 0) {
 
631
                char  *name;
 
632
                char  *uri;
 
633
                GFile *file;
 
634
 
 
635
                file = g_file_new_for_path (g_get_home_dir ());
 
636
                uri = g_file_get_uri (file);
 
637
                name = panel_util_get_label_for_uri (uri);
 
638
                g_free (uri);
 
639
                g_object_unref (file);
 
640
 
 
641
                panel_launcher_create_from_info (panel->toplevel,
 
642
                                                 pack_type, pack_index,
 
643
                                                 TRUE, /* is_exec? */
 
644
                                                 "nautilus --no-desktop", /* exec */
 
645
                                                 name, /* name */
 
646
                                                 _("Open your personal folder"), /* comment */
 
647
                                                 PANEL_ICON_HOME); /* icon name */
 
648
 
 
649
                g_free (name);
 
650
        } else if (strncmp (basename, "computer", strlen ("computer")) == 0)
 
651
                panel_launcher_create_from_info (panel->toplevel,
 
652
                                                 pack_type, pack_index,
 
653
                                                 TRUE, /* is_exec? */
 
654
                                                 "nautilus --no-desktop computer://", /* exec */
 
655
                                                 _("Computer"), /* name */
 
656
                                                 _("Browse all local and remote disks and folders accessible from this computer"), /* comment */
 
657
                                                 PANEL_ICON_COMPUTER); /* icon name */
580
658
        else if (strncmp (basename, "network", strlen ("network")) == 0)
581
 
                panel_launcher_create_with_id (id, pos,
582
 
                                               "nautilus-scheme.desktop");
 
659
                panel_launcher_create_from_info (panel->toplevel,
 
660
                                                 pack_type, pack_index,
 
661
                                                 TRUE, /* is_exec? */
 
662
                                                 "nautilus --no-desktop network://", /* exec */
 
663
                                                 _("Network"), /* name */
 
664
                                                 _("Browse bookmarked and local network locations"), /* comment */
 
665
                                                 PANEL_ICON_NETWORK); /* icon name */
583
666
        else
584
667
                success = FALSE;
585
668
 
587
670
}
588
671
 
589
672
static gboolean
590
 
drop_urilist (PanelWidget *panel,
591
 
              int          pos,
592
 
              char        *urilist)
 
673
drop_urilist (PanelWidget         *panel,
 
674
              PanelObjectPackType  pack_type,
 
675
              int                  pack_index,
 
676
              char                *urilist)
593
677
{
594
678
        char     **uris;
 
679
        GFile     *home;
 
680
        GFile     *trash;
 
681
        GFile     *computer;
 
682
        GFile     *network;
595
683
        gboolean   success;
596
684
        int        i;
597
685
 
598
686
        uris = g_uri_list_extract_uris (urilist);
 
687
        home = g_file_new_for_path (g_get_home_dir ());
 
688
        trash = g_file_new_for_uri ("trash://");
 
689
        computer = g_file_new_for_uri ("computer://");
 
690
        network = g_file_new_for_uri ("network://");
599
691
 
600
692
        success = TRUE;
601
693
        for (i = 0; uris[i]; i++) {
615
707
                        /* FIXME: probably do this only on link,
616
708
                         * in fact, on link always set up a link,
617
709
                         * on copy do all the other stuff.  Or something. */
618
 
                        if ( ! drop_url (panel, pos, uri))
 
710
                        if ( ! drop_url (panel, pack_type, pack_index, uri))
619
711
                                success = FALSE;
620
712
                        continue;
621
713
                }
622
714
 
623
715
                if (g_ascii_strncasecmp (uri, "x-nautilus-desktop:",
624
716
                                         strlen ("x-nautilus-desktop:")) == 0) {
625
 
                        success = drop_nautilus_desktop_uri (panel, pos, uri);
 
717
                        success = drop_nautilus_desktop_uri (panel,
 
718
                                                             pack_type, pack_index,
 
719
                                                             uri);
626
720
                        continue;
627
721
                }
628
722
 
629
723
                file = g_file_new_for_uri (uri);
 
724
 
 
725
                if (g_file_equal (home, file)) {
 
726
                        success = drop_nautilus_desktop_uri (panel,
 
727
                                                             pack_type, pack_index,
 
728
                                                             "x-nautilus-desktop:///home");
 
729
                        g_object_unref (file);
 
730
                        continue;
 
731
                } else if (g_file_equal (trash, file)) {
 
732
                        success = drop_nautilus_desktop_uri (panel,
 
733
                                                             pack_type, pack_index,
 
734
                                                             "x-nautilus-desktop:///trash");
 
735
                        g_object_unref (file);
 
736
                        continue;
 
737
                } else if (g_file_equal (computer, file)) {
 
738
                        success = drop_nautilus_desktop_uri (panel,
 
739
                                                             pack_type, pack_index,
 
740
                                                             "x-nautilus-desktop:///computer");
 
741
                        g_object_unref (file);
 
742
                        continue;
 
743
                } else if (g_file_equal (network, file)) {
 
744
                        success = drop_nautilus_desktop_uri (panel,
 
745
                                                             pack_type, pack_index,
 
746
                                                             "x-nautilus-desktop:///network");
 
747
                        g_object_unref (file);
 
748
                        continue;
 
749
                }
 
750
 
630
751
                info = g_file_query_info (file,
631
752
                                          "standard::type,"
632
753
                                          "standard::content-type,"
652
773
                                   (!strcmp (mime, "application/x-gnome-app-info") ||
653
774
                                    !strcmp (mime, "application/x-desktop") ||
654
775
                                    !strcmp (mime, "application/x-kde-app-info"))) {
655
 
                                if (panel_profile_id_lists_are_writable ())
656
 
                                        panel_launcher_create (panel->toplevel, pos, uri);
 
776
                                if (panel_layout_is_writable ())
 
777
                                        panel_launcher_create (panel->toplevel,
 
778
                                                               pack_type, pack_index,
 
779
                                                               uri);
657
780
                                else
658
781
                                        success = FALSE;
659
782
                        } else if (type != G_FILE_TYPE_DIRECTORY && can_exec) {
661
784
 
662
785
                                filename = g_file_get_path (file);
663
786
 
664
 
                                if (panel_profile_id_lists_are_writable ())
 
787
                                if (panel_layout_is_writable ())
665
788
                                        /* executable and local, so add a
666
789
                                         * launcher with it */
667
790
                                        ask_about_launcher (filename, panel,
668
 
                                                            pos, TRUE);
 
791
                                                            pack_type);
669
792
                                else
670
793
                                        success = FALSE;
671
794
                                g_free (filename);
672
795
                        } else {
673
 
                                if (!drop_uri (panel, pos, uri,
 
796
                                if (!drop_uri (panel, pack_type, pack_index, uri,
674
797
                                               PANEL_ICON_UNKNOWN))
675
798
                                        success = FALSE;
676
799
                        }
677
800
                } else {
678
 
                        if (!drop_uri (panel, pos, uri, PANEL_ICON_UNKNOWN))
 
801
                        if (!drop_uri (panel, pack_type, pack_index,
 
802
                                       uri, PANEL_ICON_UNKNOWN))
679
803
                                success = FALSE;
680
804
                }
681
805
 
683
807
                g_object_unref (file);
684
808
        }
685
809
 
 
810
        g_object_unref (home);
 
811
        g_object_unref (trash);
 
812
        g_object_unref (computer);
 
813
        g_object_unref (network);
686
814
        g_strfreev (uris);
687
815
 
688
816
        return success;
689
817
}
690
818
 
691
819
static gboolean
692
 
drop_internal_icon (PanelWidget *panel,
693
 
                    int          pos,
694
 
                    const char  *icon_name,
695
 
                    int          action)
 
820
drop_internal_icon (PanelWidget         *panel,
 
821
                    PanelObjectPackType  pack_type,
 
822
                    int                  pack_index,
 
823
                    const char          *icon_name,
 
824
                    int                  action)
696
825
{
697
826
        Launcher *old_launcher = NULL;
698
827
 
699
828
        if (!icon_name)
700
829
                return FALSE;
701
830
 
702
 
        if (!panel_profile_id_lists_are_writable ())
 
831
        if (!panel_layout_is_writable ())
703
832
                return FALSE;
704
833
 
705
834
        if (action == GDK_ACTION_MOVE)
706
835
                old_launcher = find_launcher (icon_name);
707
836
        
708
 
        if (!panel_launcher_create_copy (panel->toplevel, pos, icon_name))
 
837
        if (!panel_launcher_create_copy (panel->toplevel, pack_type, pack_index,
 
838
                                         icon_name))
709
839
                return FALSE;
710
840
 
711
841
        if (old_launcher && old_launcher->button) {
 
842
                const char *object_id;
 
843
 
712
844
                if (old_launcher->prop_dialog) {
713
845
                        g_signal_handler_disconnect (old_launcher->button,
714
846
                                                     old_launcher->destroy_handler);
715
847
                        launcher_properties_destroy (old_launcher);
716
848
                }
717
 
                panel_profile_delete_object (old_launcher->info);
 
849
 
 
850
                object_id = panel_applet_get_id (old_launcher->info);
 
851
                panel_layout_delete_object (object_id);
718
852
        }
719
853
 
720
854
        return TRUE;
721
855
}
722
856
 
723
857
static gboolean
724
 
move_applet (PanelWidget *panel, int pos, int applet_index)
 
858
move_applet (PanelWidget         *panel,
 
859
             PanelObjectPackType  pack_type,
 
860
             int                  pack_index,
 
861
             int                  applet_index)
725
862
{
726
863
        GSList     *applet_list;
727
864
        AppletInfo *info;
731
868
 
732
869
        info = g_slist_nth_data (applet_list, applet_index);
733
870
 
734
 
        if ( ! panel_applet_can_freely_move (info))
 
871
        if (info == NULL || info->widget == NULL ||
 
872
            !panel_applet_can_freely_move (info))
735
873
                return FALSE;
736
874
 
737
 
        if (pos < 0)
738
 
                pos = 0;
739
 
 
740
875
        parent = gtk_widget_get_parent (info->widget);
741
876
 
742
 
        if (info != NULL &&
743
 
            info->widget != NULL &&
744
 
            parent != NULL &&
 
877
        if (parent != NULL &&
745
878
            PANEL_IS_WIDGET (parent)) {
746
 
                GSList *forb;
747
 
                forb = g_object_get_data (G_OBJECT (info->widget),
748
 
                                          PANEL_APPLET_FORBIDDEN_PANELS);
749
 
                if ( ! g_slist_find (forb, panel))
750
 
                        panel_widget_reparent (PANEL_WIDGET (parent),
751
 
                                               panel,
752
 
                                               info->widget,
753
 
                                               pos);
 
879
                panel_widget_reparent (PANEL_WIDGET (parent),
 
880
                                       panel,
 
881
                                       info->widget,
 
882
                                       pack_type, pack_index);
754
883
        }
755
884
 
756
885
        return TRUE;
757
886
}
758
887
 
759
888
static gboolean
760
 
drop_internal_applet (PanelWidget *panel, int pos, const char *applet_type,
761
 
                      int action)
 
889
drop_internal_applet (PanelWidget         *panel,
 
890
                      PanelObjectPackType  pack_type,
 
891
                      int                  pack_index,
 
892
                      const char          *applet_type,
 
893
                      int                  action)
762
894
{
763
895
        int applet_index = -1;
764
896
        gboolean remove_applet = FALSE;
767
899
        if (applet_type == NULL)
768
900
                return FALSE;
769
901
 
770
 
        if (sscanf (applet_type, "MENU:%d", &applet_index) == 1 ||
771
 
            sscanf (applet_type, "DRAWER:%d", &applet_index) == 1) {
 
902
        if (sscanf (applet_type, "MENU:%d", &applet_index) == 1) {
772
903
                if (action != GDK_ACTION_MOVE)
773
 
                        g_warning ("Only MOVE supported for menus/drawers");
774
 
                success = move_applet (panel, pos, applet_index);
 
904
                        g_warning ("Only MOVE supported for menus");
 
905
                success = move_applet (panel, pack_type, pack_index, applet_index);
775
906
 
776
907
        } else if (strncmp (applet_type, "MENU:", strlen ("MENU:")) == 0) {
777
908
                const char *menu;
782
913
 
783
914
                if (!menu_path) {
784
915
                        if (strncmp (menu, "MAIN", strlen ("MAIN")) == 0)
785
 
                                success = drop_menu (panel, pos, NULL, NULL);
 
916
                                success = drop_menu (panel, pack_type, pack_index,
 
917
                                                     NULL, NULL);
786
918
                        else
787
 
                                success = drop_menu (panel, pos, menu, NULL);
 
919
                                success = drop_menu (panel, pack_type, pack_index,
 
920
                                                     menu, NULL);
788
921
                } else {
789
922
                        char *menu_filename;
790
923
 
791
924
                        menu_filename = g_strndup (menu, menu_path - menu);
792
925
                        menu_path++;
793
 
                        success = drop_menu (panel, pos,
 
926
                        success = drop_menu (panel, pack_type, pack_index,
794
927
                                             menu_filename, menu_path);
795
928
                        g_free (menu_filename);
796
929
                }
797
930
 
798
 
        } else if (!strcmp (applet_type, "DRAWER:NEW")) {
799
 
                if (panel_profile_id_lists_are_writable ()) {
800
 
                        panel_drawer_create (panel->toplevel, pos, NULL, FALSE, NULL);
801
 
                        success = TRUE;
802
 
                } else {
803
 
                        success = FALSE;
804
 
                }
805
 
 
806
931
        } else if (!strncmp (applet_type, "ACTION:", strlen ("ACTION:"))) {
807
 
                if (panel_profile_id_lists_are_writable ()) {
 
932
                if (panel_layout_is_writable ()) {
808
933
                        remove_applet = panel_action_button_load_from_drag (
809
934
                                                        panel->toplevel,
810
 
                                                        pos,
 
935
                                                        pack_type, pack_index,
811
936
                                                        applet_type,
812
937
                                                        &applet_index);
813
938
                        success = TRUE;
816
941
                }
817
942
 
818
943
        } else if (!strcmp (applet_type, "MENUBAR:NEW")) {
819
 
                if (panel_profile_id_lists_are_writable ()) {
820
 
                        panel_menu_bar_create (panel->toplevel, pos);
 
944
                if (panel_layout_is_writable ()) {
 
945
                        panel_menu_bar_create (panel->toplevel,
 
946
                                               pack_type, pack_index);
821
947
                        success = TRUE;
822
948
                } else {
823
949
                        success = FALSE;
824
950
                }
825
951
 
826
952
        } else if (!strcmp(applet_type,"SEPARATOR:NEW")) {
827
 
                if (panel_profile_id_lists_are_writable ()) {
828
 
                        panel_separator_create (panel->toplevel, pos);
 
953
                if (panel_layout_is_writable ()) {
 
954
                        panel_separator_create (panel->toplevel,
 
955
                                                pack_type, pack_index);
 
956
                        success = TRUE;
 
957
                } else {
 
958
                        success = FALSE;
 
959
                }
 
960
 
 
961
        } else if (!strcmp (applet_type, "USERMENU:NEW")) {
 
962
                if (panel_layout_is_writable ()) {
 
963
                        panel_user_menu_create (panel->toplevel,
 
964
                                                pack_type, pack_index);
829
965
                        success = TRUE;
830
966
                } else {
831
967
                        success = FALSE;
832
968
                }
833
969
 
834
970
        } else if (!strcmp(applet_type,"LAUNCHER:ASK")) {
835
 
                if (panel_profile_id_lists_are_writable ()) {
836
 
                        ask_about_launcher (NULL, panel, pos, TRUE);
 
971
                if (panel_layout_is_writable ()) {
 
972
                        ask_about_launcher (NULL, panel, pack_type);
837
973
                        success = TRUE;
838
974
                } else {
839
975
                        success = FALSE;
850
986
                info = g_slist_nth_data (applet_list, applet_index);
851
987
 
852
988
                if (info)
853
 
                        panel_profile_delete_object (info);
 
989
                        panel_layout_delete_object (panel_applet_get_id (info));
854
990
        }
855
991
 
856
992
        return success;
883
1019
        return target_list;
884
1020
}
885
1021
 
886
 
gboolean
 
1022
static gboolean
887
1023
panel_check_dnd_target_data (GtkWidget      *widget,
888
1024
                             GdkDragContext *context,
889
1025
                             guint          *ret_info,
945
1081
        }
946
1082
}
947
1083
 
948
 
gboolean
 
1084
static gboolean
949
1085
panel_check_drop_forbidden (PanelWidget    *panel,
950
1086
                            GdkDragContext *context,
951
1087
                            guint           info,
954
1090
        if (!panel)
955
1091
                return FALSE;
956
1092
 
957
 
        if (panel_lockdown_get_locked_down ())
 
1093
        if (panel_lockdown_get_panels_locked_down_s ())
958
1094
                return FALSE;
959
1095
 
960
 
        if (info == TARGET_APPLET_INTERNAL) {
961
 
                GtkWidget *source_widget;
962
 
 
963
 
                source_widget = gtk_drag_get_source_widget (context);
964
 
 
965
 
                if (BUTTON_IS_WIDGET (source_widget)) {
966
 
                        GSList *forb;
967
 
 
968
 
                        forb = g_object_get_data (G_OBJECT (source_widget),
969
 
                                                  PANEL_APPLET_FORBIDDEN_PANELS);
970
 
 
971
 
                        if (g_slist_find (forb, panel))
972
 
                                return FALSE;
973
 
                }
974
 
        }
975
 
 
976
1096
        if (info == TARGET_ICON_INTERNAL ||
977
1097
            info == TARGET_APPLET_INTERNAL) {
978
1098
                if (gdk_drag_context_get_actions (context) & GDK_ACTION_MOVE)
1054
1174
        panel_toplevel_queue_auto_hide (toplevel);
1055
1175
}
1056
1176
 
1057
 
void
1058
 
panel_receive_dnd_data (PanelWidget      *panel,
1059
 
                        guint             info,
1060
 
                        int               pos,
1061
 
                        GtkSelectionData *selection_data,
1062
 
                        GdkDragContext   *context,
1063
 
                        guint             time_)
 
1177
static void
 
1178
panel_receive_dnd_data (PanelWidget         *panel,
 
1179
                        guint                info,
 
1180
                        PanelObjectPackType  pack_type,
 
1181
                        int                  pack_index,
 
1182
                        GtkSelectionData    *selection_data,
 
1183
                        GdkDragContext      *context,
 
1184
                        guint                time_)
1064
1185
{
1065
1186
        const guchar *data;
1066
1187
        gboolean      success = FALSE;
1067
1188
 
1068
 
        if (panel_lockdown_get_locked_down ()) {
 
1189
        if (panel_lockdown_get_panels_locked_down_s ()) {
1069
1190
                gtk_drag_finish (context, FALSE, FALSE, time_);
1070
1191
                return;
1071
1192
        }
1074
1195
 
1075
1196
        switch (info) {
1076
1197
        case TARGET_URL:
1077
 
                success = drop_urilist (panel, pos, (char *)data);
 
1198
                success = drop_urilist (panel, pack_type, pack_index, (char *)data);
1078
1199
                break;
1079
1200
        case TARGET_NETSCAPE_URL:
1080
 
                success = drop_url (panel, pos, (char *)data);
 
1201
                success = drop_url (panel, pack_type, pack_index, (char *)data);
1081
1202
                break;
1082
1203
        case TARGET_COLOR:
1083
1204
                success = set_background_color (panel->toplevel, (guint16 *) data);
1086
1207
                success = set_background_image_from_uri (panel->toplevel, (char *) data);
1087
1208
                break;
1088
1209
        case TARGET_BACKGROUND_RESET:
1089
 
                if (panel_profile_is_writable_background_type (panel->toplevel)) {
1090
 
                        panel_profile_set_background_type (panel->toplevel, PANEL_BACK_NONE);
1091
 
                        success = TRUE;
1092
 
                } else {
1093
 
                        success = FALSE;
1094
 
                }
 
1210
                success = reset_background (panel->toplevel);
1095
1211
                break;
1096
1212
        case TARGET_DIRECTORY:
1097
 
                success = drop_uri (panel, pos, (char *)data,
 
1213
                success = drop_uri (panel, pack_type, pack_index, (char *)data,
1098
1214
                                    PANEL_ICON_FOLDER);
1099
1215
                break;
1100
1216
        case TARGET_APPLET:
1102
1218
                        gtk_drag_finish (context, FALSE, FALSE, time_);
1103
1219
                        return;
1104
1220
                }
1105
 
                if (panel_profile_id_lists_are_writable ()) {
1106
 
                        panel_applet_frame_create (panel->toplevel, pos, (char *) data);
 
1221
                if (panel_layout_is_writable ()) {
 
1222
                        panel_applet_frame_create (panel->toplevel,
 
1223
                                                   pack_type, pack_index,
 
1224
                                                   (char *) data);
1107
1225
                        success = TRUE;
1108
1226
                } else {
1109
1227
                        success = FALSE;
1110
1228
                }
1111
1229
                break;
1112
1230
        case TARGET_APPLET_INTERNAL:
1113
 
                success = drop_internal_applet (panel, pos, (char *)data,
 
1231
                success = drop_internal_applet (panel, pack_type, pack_index,
 
1232
                                                (char *)data,
1114
1233
                                                gdk_drag_context_get_selected_action (context));
1115
1234
                break;
1116
1235
        case TARGET_ICON_INTERNAL:
1117
 
                success = drop_internal_icon (panel, pos, (char *)data,
 
1236
                success = drop_internal_icon (panel, pack_type, pack_index,
 
1237
                                              (char *)data,
1118
1238
                                              gdk_drag_context_get_selected_action (context));
1119
1239
                break;
1120
1240
        default:
1134
1254
                       guint             info,
1135
1255
                       guint             time)
1136
1256
{
1137
 
        PanelWidget *panel_widget;
1138
 
        int          pos;
 
1257
        PanelWidget         *panel_widget;
 
1258
        PanelObjectPackType  pack_type = PANEL_OBJECT_PACK_START;
 
1259
        int                  pack_index = 0;
1139
1260
 
1140
1261
        g_return_if_fail (PANEL_IS_TOPLEVEL (widget));
1141
1262
 
1149
1270
 
1150
1271
        panel_widget = panel_toplevel_get_panel_widget (PANEL_TOPLEVEL (widget));
1151
1272
 
1152
 
        pos = panel_widget_get_cursorloc (panel_widget);
 
1273
        panel_widget_get_insert_at_cursor (panel_widget, &pack_type, &pack_index);
1153
1274
        
1154
 
        /* 
1155
 
         * -1 passed to panel_applet_register will turn on 
1156
 
         * the insert_at_pos flag for panel_widget_add_full,
1157
 
         * which will not place it after the first applet.
1158
 
         */
1159
 
        if(pos < 0)
1160
 
                pos = -1;
1161
 
        else if(pos > panel_widget->size)
1162
 
                pos = panel_widget->size;
1163
 
 
1164
1275
        panel_receive_dnd_data (
1165
 
                panel_widget, info, pos, selection_data, context, time);
 
1276
                panel_widget, info, pack_type, pack_index,
 
1277
                selection_data, context, time);
1166
1278
}
1167
1279
 
1168
1280
static void
1173
1285
                          G_CALLBACK(panel_applet_added),
1174
1286
                          NULL);
1175
1287
        g_signal_connect (G_OBJECT(panel),
1176
 
                          "applet_removed",
1177
 
                          G_CALLBACK(panel_applet_removed),
1178
 
                          NULL);
1179
 
        g_signal_connect (G_OBJECT(panel),
1180
1288
                          "applet_move",
1181
1289
                          G_CALLBACK(panel_applet_move),
1182
1290
                          NULL);
1203
1311
        pd = g_new0 (PanelData,1);
1204
1312
        pd->menu = NULL;
1205
1313
        pd->panel = GTK_WIDGET (toplevel);
1206
 
        pd->insertion_pos = -1;
 
1314
        pd->insert_pack_type = PANEL_OBJECT_PACK_START;
1207
1315
        pd->deactivate_idle = 0;
1208
1316
 
1209
1317
        panel_list = g_slist_append (panel_list, pd);
1210
1318
        
1211
1319
        g_object_set_data (G_OBJECT (toplevel), "PanelData", pd);
1212
1320
 
1213
 
        panel_lockdown_notify_add (G_CALLBACK (panel_recreate_context_menu),
1214
 
                                   pd);
1215
 
 
1216
1321
        panel_widget_setup (panel_widget);
1217
1322
 
1218
1323
        g_signal_connect (toplevel, "drag_data_received",
1230
1335
                          G_CALLBACK (panel_key_press_event), NULL);
1231
1336
        g_signal_connect (toplevel, "button-press-event",
1232
1337
                          G_CALLBACK (panel_button_press_event), NULL);
1233
 
        g_signal_connect (toplevel, "popup-menu",
1234
 
                          G_CALLBACK (panel_popup_menu_signal), NULL);
1235
1338
 
1236
1339
        g_signal_connect_swapped (toplevel, "notify::orientation",
1237
1340
                                  G_CALLBACK (panel_orient_change), panel_widget);
1250
1353
        return gtk_window_get_screen (GTK_WINDOW (panel->toplevel));
1251
1354
}
1252
1355
 
1253
 
gboolean
1254
 
panel_is_applet_right_stick (GtkWidget *applet)
1255
 
{
1256
 
        GtkWidget   *parent;
1257
 
        PanelWidget *panel_widget;
1258
 
 
1259
 
        g_return_val_if_fail (GTK_IS_WIDGET (applet), FALSE);
1260
 
 
1261
 
        parent = gtk_widget_get_parent (applet);
1262
 
 
1263
 
        g_return_val_if_fail (PANEL_IS_WIDGET (parent), FALSE);
1264
 
 
1265
 
        panel_widget = PANEL_WIDGET (parent);
1266
 
 
1267
 
        if (!panel_toplevel_get_expand (panel_widget->toplevel))
1268
 
                return FALSE;
1269
 
 
1270
 
        return panel_widget_is_applet_stuck (panel_widget, applet);
1271
 
}
1272
 
 
1273
1356
static void
1274
1357
panel_delete_without_query (PanelToplevel *toplevel)
1275
1358
{
1276
 
        PanelWidget *panel_widget;
1277
 
 
1278
 
        panel_widget = panel_toplevel_get_panel_widget (toplevel);
1279
 
 
1280
 
        if (panel_toplevel_get_is_attached (toplevel) &&
1281
 
            panel_widget->master_widget) {
1282
 
                AppletInfo *info;
1283
 
 
1284
 
                info = g_object_get_data (G_OBJECT (panel_widget->master_widget),
1285
 
                                          "applet_info");
1286
 
 
1287
 
                panel_profile_delete_object (info);
1288
 
        } else
1289
 
                panel_profile_delete_toplevel (toplevel);
 
1359
        panel_layout_delete_toplevel (panel_toplevel_get_id (toplevel));
1290
1360
} 
1291
1361
 
1292
1362
static void
1316
1386
{
1317
1387
 
1318
1388
        GtkWidget *dialog;
1319
 
        char *text1;
1320
 
        char *text2;
1321
 
 
1322
 
        if (panel_toplevel_get_is_attached (toplevel)) {
1323
 
                text1 = _("Delete this drawer?");
1324
 
                text2 = _("When a drawer is deleted, the drawer and its\n"
1325
 
                         "settings are lost.");
1326
 
        } else {
1327
 
                text1 = _("Delete this panel?");
1328
 
                text2 = _("When a panel is deleted, the panel and its\n"
1329
 
                         "settings are lost.");
1330
 
        }
1331
1389
 
1332
1390
        dialog = gtk_message_dialog_new (
1333
1391
                        GTK_WINDOW (toplevel),
1334
1392
                        GTK_DIALOG_MODAL,
1335
1393
                        GTK_MESSAGE_WARNING,
1336
1394
                        GTK_BUTTONS_NONE,
1337
 
                        "%s", text1);
 
1395
                        "%s", _("Delete this panel?"));
1338
1396
        
1339
1397
        gtk_message_dialog_format_secondary_text (GTK_MESSAGE_DIALOG (dialog),
1340
 
                                                  "%s", text2); 
 
1398
                                                  "%s",
 
1399
                                                  _("When a panel is deleted, the panel and its\n"
 
1400
                                                  "settings are lost."));
 
1401
 
1341
1402
        gtk_dialog_add_buttons (GTK_DIALOG (dialog),
1342
1403
                                GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
1343
1404
                                GTK_STOCK_DELETE, GTK_RESPONSE_OK,
1389
1450
void
1390
1451
panel_delete (PanelToplevel *toplevel)
1391
1452
{
 
1453
        GSettings   *settings;
 
1454
        gboolean     confirm;
1392
1455
        PanelWidget *panel_widget;
1393
1456
 
 
1457
        settings = g_settings_new (PANEL_GENERAL_SCHEMA);
 
1458
        confirm = g_settings_get_boolean (settings,
 
1459
                                          PANEL_GENERAL_CONFIRM_PANEL_REMOVAL_KEY);
 
1460
        g_object_unref (settings);
 
1461
 
1394
1462
        panel_widget = panel_toplevel_get_panel_widget (toplevel);
1395
1463
 
1396
 
        if (!panel_global_config_get_confirm_panel_remove () ||
 
1464
        if (!confirm ||
1397
1465
            !g_list_length (panel_widget->applet_list)) {
1398
1466
                panel_delete_without_query (toplevel);
1399
1467
                return;