← Back to branch summary

~ubuntu-branches/ubuntu/raring/nautilus/raring

« back to all changes in this revision

Viewing changes to src/nautilus-properties-window.c

  • Committer: Package Import Robot
  • Author(s): Sebastien Bacher, Jeremy Bicha
  • Date: 2012-01-31 13:45:01 UTC
  • mfrom: (1.17.25)
  • Revision ID: package-import@ubuntu.com-20120131134501-yn7mqny7fgzx9fao
Tags: 1:3.3.4-0ubuntu1
https://launchpad.net/bugs/126540
https://launchpad.net/bugs/61786
https://launchpad.net/bugs/503330
https://launchpad.net/bugs/846289
https://launchpad.net/bugs/575719
https://launchpad.net/bugs/230098
* New upstream version which fixes:
  - "Opening Popupmenu in Context of Folder with List-View impossible?"
    (lp: #126540)
  - "'Create folder in here' context menu option for nautilus" (lp: #61786)
  - the file count and the size count change in opposite direction.
    (lp: #503330)
  - the mounts in the place menu should have a properties entry.
    (lp: #846289)
  - add command line option to select file (lp: #575719)
  - Media in 'Places' side bar should have same context menu as in 
    'Computer' (lp: #230098)
* debian/nautilus-data.install:
  - updated, ui and icons have been moved into gresources
* debian/patches/05_desktop_menu_export.patch:
   - updated to correctly include the gresources desktop definition

[ Jeremy Bicha ]
* New upstream release.
* debian/control.in:
  - Bump minimum GTK and glib
* Refreshed patches
* Dropped upstream patches:
  - 17_dont_allow_new_tab_on_desktop.patch
  - 18_fix_crash_in_get_current_uri.patch
  - 19_lazily_initialize_notification_service.patch
  - git_sideplace_sorting.patch
  - git_next_row.patch
  - git_dont_document_browser_option.patch
  - git_browser_compat.patch
  - git_bookmarks_reordering.patch
  - git_listview_context_menus.patch
  - git_use_gtk_grid.patch

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/nautilus-properties-window.c
158
158
        GList *original_files;
159
159
        GList *target_files;
160
160
        GtkWidget *parent_widget;
 
161
        char *startup_id;
161
162
        char *pending_key;
162
163
        GHashTable *pending_files;
163
164
} StartupData;
687
688
                set_name_field (window, original_name, current_name);
688
689
 
689
690
                if (original_name == NULL || 
690
 
                    eel_strcmp (original_name, current_name) != 0) {
 
691
                    g_strcmp0 (original_name, current_name) != 0) {
691
692
                        g_object_set_data_full (G_OBJECT (window->details->name_field),
692
693
                                                "original_name",
693
694
                                                current_name,
2590
2591
        double free, used;
2591
2592
        double angle1, angle2, split, xc, yc, radius;
2592
2593
        GtkAllocation allocation;
 
2594
        GtkStyleContext *notebook_ctx;
 
2595
        GdkRGBA bg_color;
2593
2596
 
2594
2597
        window = NAUTILUS_PROPERTIES_WINDOW (data);
2595
2598
        gtk_widget_get_allocation (widget, &allocation);
2596
2599
 
2597
2600
        width  = allocation.width;
2598
2601
        height = allocation.height;
2599
 
        
2600
 
                
 
2602
 
 
2603
        notebook_ctx = gtk_widget_get_style_context (GTK_WIDGET (window->details->notebook));
 
2604
        gtk_style_context_get_background_color (notebook_ctx,
 
2605
                                                gtk_widget_get_state_flags (GTK_WIDGET (window->details->notebook)),
 
2606
                                                &bg_color);
 
2607
 
 
2608
        cairo_save (cr);
 
2609
        gdk_cairo_set_source_rgba (cr, &bg_color);
 
2610
        cairo_paint (cr);
 
2611
        cairo_restore (cr);
 
2612
 
2601
2613
        free = (double)window->details->volume_free / (double)window->details->volume_capacity;
2602
2614
        used =  1.0 - free;
2603
2615
 
2850
2862
create_pie_widget (NautilusPropertiesWindow *window)
2851
2863
{
2852
2864
        NautilusFile            *file;
2853
 
        GtkTable                *table;
 
2865
        GtkGrid                 *grid;
2854
2866
        GtkStyleContext         *style;
2855
2867
        GtkWidget               *pie_canvas;
2856
2868
        GtkWidget               *used_canvas;
2875
2887
        
2876
2888
        uri = nautilus_file_get_activation_uri (file);
2877
2889
        
2878
 
        table = GTK_TABLE (gtk_table_new (4, 3, FALSE));
2879
 
 
2880
 
        style = gtk_widget_get_style_context (GTK_WIDGET (table));
 
2890
        grid = GTK_GRID (gtk_grid_new ());
 
2891
        gtk_container_set_border_width (GTK_CONTAINER (grid), 5);
 
2892
        gtk_grid_set_column_spacing (GTK_GRID (grid), 5);
 
2893
        style = gtk_widget_get_style_context (GTK_WIDGET (grid));
2881
2894
 
2882
2895
        if (!gtk_style_context_lookup_color (style, "chart_rgba_1", &window->details->used_color)) {
2883
2896
                window->details->used_color.red = USED_FILL_R;
2900
2913
        gtk_widget_set_size_request (pie_canvas, 200, 200);
2901
2914
 
2902
2915
        used_canvas = gtk_drawing_area_new ();
 
2916
        gtk_widget_set_valign (used_canvas, GTK_ALIGN_CENTER);
 
2917
        gtk_widget_set_halign (used_canvas, GTK_ALIGN_CENTER);
2903
2918
        gtk_widget_set_size_request (used_canvas, 20, 20);
2904
2919
        /* Translators: "used" refers to the capacity of the filesystem */
2905
2920
        used_label = gtk_label_new (g_strconcat (used, " ", _("used"), NULL));
2906
2921
 
2907
2922
        free_canvas = gtk_drawing_area_new ();
2908
 
        gtk_widget_set_size_request (free_canvas,20,20);
 
2923
        gtk_widget_set_valign (free_canvas, GTK_ALIGN_CENTER);
 
2924
        gtk_widget_set_halign (free_canvas, GTK_ALIGN_CENTER);
 
2925
        gtk_widget_set_size_request (free_canvas, 20, 20);
2909
2926
        /* Translators: "free" refers to the capacity of the filesystem */
2910
2927
        free_label = gtk_label_new (g_strconcat (free, " ", _("free"), NULL));  
2911
2928
 
2930
2947
        g_free (used);
2931
2948
        g_free (free);
2932
2949
 
2933
 
        gtk_table_attach (table, pie_canvas , 0, 1, 0, 4, GTK_FILL,     GTK_SHRINK, 5, 5);
2934
 
                
2935
 
        gtk_table_attach (table, used_canvas, 1, 2, 0, 1, 0,            0,          5, 5);      
2936
 
        gtk_table_attach (table, used_label , 2, 3, 0, 1, GTK_FILL,     0,          5, 5);      
2937
 
 
2938
 
        gtk_table_attach (table, free_canvas, 1, 2, 1, 2, 0,            0,          5, 5);      
2939
 
        gtk_table_attach (table, free_label , 2, 3, 1, 2, GTK_FILL,     0,          5, 5);
2940
 
        
2941
 
        gtk_table_attach (table, capacity_label , 1, 3, 2, 3, GTK_FILL, 0,          5, 5);
2942
 
        gtk_table_attach (table, fstype_label , 1, 3, 3, 4, GTK_FILL, 0,          5, 5);
 
2950
        gtk_container_add_with_properties (GTK_CONTAINER (grid), pie_canvas,
 
2951
                                           "height", 4,
 
2952
                                           NULL);
 
2953
        gtk_grid_attach_next_to (grid, used_canvas, pie_canvas,
 
2954
                                 GTK_POS_RIGHT, 1, 1);
 
2955
        gtk_grid_attach_next_to (grid, used_label, used_canvas,
 
2956
                                 GTK_POS_RIGHT, 1, 1);
 
2957
 
 
2958
        gtk_grid_attach_next_to (grid, free_canvas, used_canvas,
 
2959
                                 GTK_POS_BOTTOM, 1, 1);
 
2960
        gtk_grid_attach_next_to (grid, free_label, free_canvas,
 
2961
                                 GTK_POS_RIGHT, 1, 1);
 
2962
 
 
2963
        gtk_grid_attach_next_to (grid, capacity_label, free_canvas,
 
2964
                                 GTK_POS_BOTTOM, 2, 1);
 
2965
        gtk_grid_attach_next_to (grid, fstype_label, capacity_label,
 
2966
                                 GTK_POS_BOTTOM, 2, 1);
2943
2967
        
2944
2968
        g_signal_connect (pie_canvas, "draw",
2945
2969
                          G_CALLBACK (paint_pie_chart), window);
2948
2972
        g_signal_connect (free_canvas, "draw",
2949
2973
                          G_CALLBACK (paint_free_legend), window);
2950
2974
                
2951
 
        return GTK_WIDGET (table);
 
2975
        return GTK_WIDGET (grid);
2952
2976
}
2953
2977
 
2954
2978
static GtkWidget*
3012
3036
 
3013
3037
        window->details->icon_chooser = NULL;
3014
3038
 
3015
 
        /* Table */
 
3039
        /* Grid */
3016
3040
 
3017
3041
        vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
3018
3042
        gtk_widget_show (vbox);
3495
3519
        check_button = gtk_check_button_new_with_mnemonic (label);
3496
3520
        gtk_widget_show (check_button);
3497
3521
 
3498
 
        gtk_grid_attach_next_to (grid, check_button, sibling,
3499
 
                                 GTK_POS_RIGHT, 1, 1);
 
3522
        if (sibling) {
 
3523
                gtk_grid_attach_next_to (grid, check_button, sibling,
 
3524
                                         GTK_POS_RIGHT, 1, 1);
 
3525
        } else {
 
3526
                gtk_container_add (GTK_CONTAINER (grid), check_button);
 
3527
        }
3500
3528
 
3501
3529
        set_up_permissions_checkbox (window, 
3502
3530
                                     check_button, 
4607
4635
startup_data_new (GList *original_files, 
4608
4636
                  GList *target_files,
4609
4637
                  const char *pending_key,
4610
 
                  GtkWidget *parent_widget)
 
4638
                  GtkWidget *parent_widget,
 
4639
                  const char *startup_id)
4611
4640
{
4612
4641
        StartupData *data;
4613
4642
        GList *l;
4616
4645
        data->original_files = nautilus_file_list_copy (original_files);
4617
4646
        data->target_files = nautilus_file_list_copy (target_files);
4618
4647
        data->parent_widget = parent_widget;
 
4648
        data->startup_id = g_strdup (startup_id);
4619
4649
        data->pending_key = g_strdup (pending_key);
4620
4650
        data->pending_files = g_hash_table_new (g_direct_hash,
4621
4651
                                                g_direct_equal);
4634
4664
        nautilus_file_list_free (data->target_files);
4635
4665
        g_hash_table_destroy (data->pending_files);
4636
4666
        g_free (data->pending_key);
 
4667
        g_free (data->startup_id);
4637
4668
        g_free (data);
4638
4669
}
4639
4670
 
4740
4771
        NautilusPropertiesWindow *window;
4741
4772
        GList *l;
4742
4773
 
4743
 
        window = NAUTILUS_PROPERTIES_WINDOW (gtk_widget_new (nautilus_properties_window_get_type (), NULL));
 
4774
        window = NAUTILUS_PROPERTIES_WINDOW (gtk_widget_new (NAUTILUS_TYPE_PROPERTIES_WINDOW, NULL));
4744
4775
 
4745
4776
        window->details->original_files = nautilus_file_list_copy (startup_data->original_files);
4746
4777
        
4747
4778
        window->details->target_files = nautilus_file_list_copy (startup_data->target_files);
4748
4779
 
4749
4780
        gtk_window_set_wmclass (GTK_WINDOW (window), "file_properties", "Nautilus");
4750
 
        gtk_window_set_screen (GTK_WINDOW (window),
4751
 
                               gtk_widget_get_screen (startup_data->parent_widget));
 
4781
 
 
4782
        if (startup_data->parent_widget) {
 
4783
                gtk_window_set_screen (GTK_WINDOW (window),
 
4784
                                       gtk_widget_get_screen (startup_data->parent_widget));
 
4785
        }
 
4786
 
 
4787
        if (startup_data->startup_id) {
 
4788
                gtk_window_set_startup_id (GTK_WINDOW (window), startup_data->startup_id);
 
4789
        }
4752
4790
 
4753
4791
        gtk_window_set_type_hint (GTK_WINDOW (window), GDK_WINDOW_TYPE_HINT_DIALOG);
4754
4792
 
4940
4978
                eel_timed_wait_stop 
4941
4979
                        (cancel_create_properties_window_callback, startup_data);
4942
4980
        }
4943
 
        if (cancel_destroy_handler) {
 
4981
        if (cancel_destroy_handler && startup_data->parent_widget) {
4944
4982
                g_signal_handlers_disconnect_by_func (startup_data->parent_widget,
4945
4983
                                                      G_CALLBACK (parent_widget_destroyed_callback),
4946
4984
                                                      startup_data);
4976
5014
 
4977
5015
 
4978
5016
void
4979
 
nautilus_properties_window_present (GList *original_files,
4980
 
                                    GtkWidget *parent_widget) 
 
5017
nautilus_properties_window_present (GList       *original_files,
 
5018
                                    GtkWidget   *parent_widget,
 
5019
                                    const gchar *startup_id) 
4981
5020
{
4982
5021
        GList *l, *next;
4983
5022
        GtkWidget *parent_window;
4987
5026
        char *pending_key;
4988
5027
 
4989
5028
        g_return_if_fail (original_files != NULL);
4990
 
        g_return_if_fail (GTK_IS_WIDGET (parent_widget));
 
5029
        g_return_if_fail (parent_widget == NULL || GTK_IS_WIDGET (parent_widget));
4991
5030
 
4992
5031
        /* Create the hash tables first time through. */
4993
5032
        if (windows == NULL) {
5003
5042
        /* Look to see if there's already a window for this file. */
5004
5043
        existing_window = get_existing_window (original_files);
5005
5044
        if (existing_window != NULL) {
5006
 
                gtk_window_set_screen (existing_window,
5007
 
                                       gtk_widget_get_screen (parent_widget));
 
5045
                if (parent_widget)
 
5046
                        gtk_window_set_screen (existing_window,
 
5047
                                               gtk_widget_get_screen (parent_widget));
 
5048
                else if (startup_id)
 
5049
                        gtk_window_set_startup_id (existing_window, startup_id);
 
5050
 
5008
5051
                gtk_window_present (existing_window);
5009
5052
                return;
5010
5053
        }
5022
5065
        startup_data = startup_data_new (original_files, 
5023
5066
                                         target_files,
5024
5067
                                         pending_key,
5025
 
                                         parent_widget);
 
5068
                                         parent_widget,
 
5069
                                         startup_id);
5026
5070
 
5027
5071
        nautilus_file_list_free (target_files);
5028
5072
        g_free(pending_key);
5032
5076
         */
5033
5077
        
5034
5078
        g_hash_table_insert (pending_lists, startup_data->pending_key, startup_data->pending_key);
5035
 
        g_signal_connect (parent_widget, "destroy",
5036
 
                          G_CALLBACK (parent_widget_destroyed_callback), startup_data);
 
5079
        if (parent_widget) {
 
5080
                g_signal_connect (parent_widget, "destroy",
 
5081
                                  G_CALLBACK (parent_widget_destroyed_callback), startup_data);
5037
5082
 
5038
 
        parent_window = gtk_widget_get_ancestor (parent_widget, GTK_TYPE_WINDOW);
 
5083
                parent_window = gtk_widget_get_ancestor (parent_widget, GTK_TYPE_WINDOW);
 
5084
        } else
 
5085
                parent_window = NULL;
5039
5086
 
5040
5087
        eel_timed_wait_start
5041
5088
                (cancel_create_properties_window_callback,
5043
5090
                 _("Creating Properties window."),
5044
5091
                 parent_window == NULL ? NULL : GTK_WINDOW (parent_window));
5045
5092
 
5046
 
 
5047
5093
        for (l = startup_data->target_files; l != NULL; l = next) {
5048
5094
                next = l->next;
5049
5095
                nautilus_file_call_when_ready