← Back to branch summary

~ubuntu-branches/ubuntu/precise/nautilus/precise-proposed

« back to all changes in this revision

Viewing changes to libnautilus-private/nautilus-icon-container.c

  • Committer: Package Import Robot
  • Author(s): Attila Hammer
  • Date: 2012-10-03 12:34:12 UTC
  • Revision ID: package-import@ubuntu.com-20121003123412-yvjt5s7mo58ldqel
Tags: 1:3.4.2-0ubuntu5
https://launchpad.net/bugs/1060852
* debian/patches/22_fix_rename_editbox_a11y_problem.patch:
  - Fix rename editbox accessibility related problem (LP: #1060852)

Show diffs side-by-side

added added

removed removed

Lines of Context:
libnautilus-private/nautilus-icon-container.c
143
143
        char *action_descriptions[LAST_ACTION];
144
144
} NautilusIconContainerAccessiblePrivate;
145
145
 
146
 
static GType         nautilus_icon_container_accessible_get_type (void);
 
146
static AtkObject *   get_accessible                                 (GtkWidget *widget);
147
147
 
148
148
static void          preview_selected_items                         (NautilusIconContainer *container);
149
149
static void          activate_selected_items                        (NautilusIconContainer *container);
205
205
static void store_layout_timestamps_now (NautilusIconContainer *container);
206
206
static void remove_search_entry_timeout (NautilusIconContainer *container);
207
207
 
208
 
static gpointer accessible_parent_class;
209
 
 
210
 
static GQuark accessible_private_data_quark = 0;
211
 
 
212
208
static const char *nautilus_icon_container_accessible_action_names[] = {
213
209
        "activate",
214
210
        "menu",
5540
5536
        /* Don't chain up to the parent to avoid clearing and redrawing */
5541
5537
}
5542
5538
 
5543
 
 
5544
 
static AtkObject *
5545
 
get_accessible (GtkWidget *widget)
5546
 
{
5547
 
        AtkObject *accessible;
5548
 
        
5549
 
        if ((accessible = eel_accessibility_get_atk_object (widget))) {
5550
 
                return accessible;
5551
 
        }
5552
 
        
5553
 
        accessible = g_object_new 
5554
 
                (nautilus_icon_container_accessible_get_type (), NULL);
5555
 
        
5556
 
        return eel_accessibility_set_atk_object_return (widget, accessible);
5557
 
}
5558
 
 
5559
5539
static void
5560
5540
grab_notify_cb  (GtkWidget        *widget,
5561
5541
                 gboolean          was_grabbed)
5976
5956
        widget_class->motion_notify_event = motion_notify_event;
5977
5957
        widget_class->key_press_event = key_press_event;
5978
5958
        widget_class->popup_menu = popup_menu;
5979
 
        widget_class->get_accessible = get_accessible;
5980
5959
        widget_class->style_updated = style_updated;
5981
5960
        widget_class->grab_notify = grab_notify_cb;
 
5961
        widget_class->get_accessible = get_accessible;
5982
5962
 
5983
5963
        canvas_class = EEL_CANVAS_CLASS (class);
5984
5964
        canvas_class->draw_background = draw_canvas_background;
8557
8537
}
8558
8538
 
8559
8539
/* NautilusIconContainerAccessible */
8560
 
 
8561
 
static NautilusIconContainerAccessiblePrivate *
8562
 
accessible_get_priv (AtkObject *accessible)
8563
 
{
 
8540
typedef struct {
 
8541
        EelCanvasAccessible parent;
8564
8542
        NautilusIconContainerAccessiblePrivate *priv;
8565
 
        
8566
 
        priv = g_object_get_qdata (G_OBJECT (accessible), 
8567
 
                                   accessible_private_data_quark);
8568
 
 
8569
 
        return priv;
8570
 
}
 
8543
} NautilusIconContainerAccessible;
 
8544
 
 
8545
typedef EelCanvasAccessibleClass NautilusIconContainerAccessibleClass;
 
8546
 
 
8547
#define GET_ACCESSIBLE_PRIV(o) ((NautilusIconContainerAccessible *) o)->priv
8571
8548
 
8572
8549
/* AtkAction interface */
8573
 
 
8574
8550
static gboolean
8575
8551
nautilus_icon_container_accessible_do_action (AtkAction *accessible, int i)
8576
8552
{
8619
8595
        
8620
8596
        g_assert (i < LAST_ACTION);
8621
8597
 
8622
 
        priv = accessible_get_priv (ATK_OBJECT (accessible));
 
8598
        priv = GET_ACCESSIBLE_PRIV (accessible);
8623
8599
        
8624
8600
        if (priv->action_descriptions[i]) {
8625
8601
                return priv->action_descriptions[i];
8654
8630
 
8655
8631
        g_assert (i < LAST_ACTION);
8656
8632
 
8657
 
        priv = accessible_get_priv (ATK_OBJECT (accessible));
 
8633
        priv = GET_ACCESSIBLE_PRIV (accessible);
8658
8634
 
8659
8635
        if (priv->action_descriptions[i]) {
8660
8636
                g_free (priv->action_descriptions[i]);
8686
8662
        NautilusIcon *icon;
8687
8663
 
8688
8664
        container = NAUTILUS_ICON_CONTAINER (gtk_accessible_get_widget (GTK_ACCESSIBLE (accessible)));
8689
 
 
8690
 
        priv = accessible_get_priv (accessible);
 
8665
        priv = GET_ACCESSIBLE_PRIV (accessible);
8691
8666
 
8692
8667
        if (priv->selection) {
8693
8668
                g_list_free (priv->selection);
8763
8738
        g_signal_emit_by_name (data, "children_changed", 0, NULL, NULL);
8764
8739
}
8765
8740
 
8766
 
 
8767
8741
static gboolean 
8768
8742
nautilus_icon_container_accessible_add_selection (AtkSelection *accessible, 
8769
8743
                                                  int i)
8819
8793
nautilus_icon_container_accessible_ref_selection (AtkSelection *accessible, 
8820
8794
                                                  int i)
8821
8795
{
 
8796
        NautilusIconContainerAccessiblePrivate *priv;
8822
8797
        AtkObject *atk_object;
8823
 
        NautilusIconContainerAccessiblePrivate *priv;
8824
8798
        GList *item;
8825
8799
        NautilusIcon *icon;
8826
8800
 
8827
8801
        nautilus_icon_container_accessible_update_selection (ATK_OBJECT (accessible));
8828
 
        priv = accessible_get_priv (ATK_OBJECT (accessible));
 
8802
        priv = GET_ACCESSIBLE_PRIV (accessible);
8829
8803
 
8830
8804
        item = (g_list_nth (priv->selection, i));
8831
8805
 
8845
8819
static int
8846
8820
nautilus_icon_container_accessible_get_selection_count (AtkSelection *accessible)
8847
8821
{
 
8822
        NautilusIconContainerAccessiblePrivate *priv;
8848
8823
        int count;
8849
 
        NautilusIconContainerAccessiblePrivate *priv;
8850
8824
 
 
8825
        priv = GET_ACCESSIBLE_PRIV (accessible);
8851
8826
        nautilus_icon_container_accessible_update_selection (ATK_OBJECT (accessible));
8852
 
        priv = accessible_get_priv (ATK_OBJECT (accessible));
8853
 
 
8854
8827
        count = g_list_length (priv->selection);
8855
 
        
 
8828
 
8856
8829
        return count;
8857
8830
}
8858
8831
 
8884
8857
nautilus_icon_container_accessible_remove_selection (AtkSelection *accessible,
8885
8858
                                                     int i)
8886
8859
{
 
8860
        NautilusIconContainerAccessiblePrivate *priv;
8887
8861
        NautilusIconContainer *container;
8888
 
        NautilusIconContainerAccessiblePrivate *priv;
8889
8862
        GList *l;
8890
8863
        GList *selection;
8891
8864
        NautilusIcon *icon;
8896
8869
                return FALSE;
8897
8870
        }
8898
8871
 
 
8872
        container = NAUTILUS_ICON_CONTAINER (widget);
8899
8873
        nautilus_icon_container_accessible_update_selection (ATK_OBJECT (accessible));
8900
 
        priv = accessible_get_priv (ATK_OBJECT (accessible));
8901
8874
 
8902
 
        container = NAUTILUS_ICON_CONTAINER (widget);
8903
 
        
 
8875
        priv = GET_ACCESSIBLE_PRIV (accessible);
8904
8876
        l = g_list_nth (priv->selection, i);
8905
8877
        if (l) {
8906
8878
                icon = l->data;
8986
8958
        if (container->details->rename_widget) {
8987
8959
                i++;
8988
8960
        }
 
8961
 
8989
8962
        return i;
8990
8963
}
8991
8964
 
9012
8985
                
9013
8986
                atk_object = atk_gobject_accessible_for_object (G_OBJECT (icon->item));
9014
8987
                g_object_ref (atk_object);
9015
 
                
 
8988
 
9016
8989
                return atk_object;
9017
8990
        } else {
9018
8991
                if (i == g_list_length (container->details->icons)) {
9027
9000
        }
9028
9001
}
9029
9002
 
 
9003
static GType nautilus_icon_container_accessible_get_type (void);
 
9004
 
 
9005
G_DEFINE_TYPE_WITH_CODE (NautilusIconContainerAccessible, nautilus_icon_container_accessible,
 
9006
                         eel_canvas_accessible_get_type (),
 
9007
                         G_IMPLEMENT_INTERFACE (ATK_TYPE_ACTION, nautilus_icon_container_accessible_action_interface_init)
 
9008
                         G_IMPLEMENT_INTERFACE (ATK_TYPE_SELECTION, nautilus_icon_container_accessible_selection_interface_init))
 
9009
 
9030
9010
static void
9031
9011
nautilus_icon_container_accessible_initialize (AtkObject *accessible, 
9032
9012
                                               gpointer data)
9033
9013
{
9034
9014
        NautilusIconContainer *container;
9035
 
        NautilusIconContainerAccessiblePrivate *priv;
9036
9015
 
9037
 
        if (ATK_OBJECT_CLASS (accessible_parent_class)->initialize) {
9038
 
                ATK_OBJECT_CLASS (accessible_parent_class)->initialize (accessible, data);
 
9016
        if (ATK_OBJECT_CLASS (nautilus_icon_container_accessible_parent_class)->initialize) {
 
9017
                ATK_OBJECT_CLASS (nautilus_icon_container_accessible_parent_class)->initialize (accessible, data);
9039
9018
        }
9040
9019
 
9041
 
        priv = g_new0 (NautilusIconContainerAccessiblePrivate, 1);
9042
 
        g_object_set_qdata (G_OBJECT (accessible), 
9043
 
                            accessible_private_data_quark, 
9044
 
                            priv);
9045
 
 
9046
9020
        if (GTK_IS_ACCESSIBLE (accessible)) {
9047
9021
                nautilus_icon_container_accessible_update_selection 
9048
9022
                        (ATK_OBJECT (accessible));
9049
9023
                
9050
9024
                container = NAUTILUS_ICON_CONTAINER (gtk_accessible_get_widget (GTK_ACCESSIBLE (accessible)));
9051
 
                g_signal_connect (G_OBJECT (container), "selection_changed",
 
9025
                g_signal_connect (container, "selection_changed",
9052
9026
                                  G_CALLBACK (nautilus_icon_container_accessible_selection_changed_cb), 
9053
9027
                                  accessible);
9054
 
                g_signal_connect (G_OBJECT (container), "icon_added",
 
9028
                g_signal_connect (container, "icon_added",
9055
9029
                                  G_CALLBACK (nautilus_icon_container_accessible_icon_added_cb), 
9056
9030
                                  accessible);
9057
 
                g_signal_connect (G_OBJECT (container), "icon_removed",
 
9031
                g_signal_connect (container, "icon_removed",
9058
9032
                                  G_CALLBACK (nautilus_icon_container_accessible_icon_removed_cb), 
9059
9033
                                  accessible);
9060
 
                g_signal_connect (G_OBJECT (container), "cleared",
 
9034
                g_signal_connect (container, "cleared",
9061
9035
                                  G_CALLBACK (nautilus_icon_container_accessible_cleared_cb), 
9062
9036
                                  accessible);
9063
9037
        }
9069
9043
        NautilusIconContainerAccessiblePrivate *priv;
9070
9044
        int i;
9071
9045
 
9072
 
        priv = accessible_get_priv (ATK_OBJECT (object));
 
9046
        priv = GET_ACCESSIBLE_PRIV (object);
 
9047
 
9073
9048
        if (priv->selection) {
9074
9049
                g_list_free (priv->selection);
9075
9050
        }
9079
9054
                        g_free (priv->action_descriptions[i]);
9080
9055
                }
9081
9056
        }
9082
 
        
9083
 
        g_free (priv);
9084
 
 
9085
 
        G_OBJECT_CLASS (accessible_parent_class)->finalize (object);
9086
 
}
9087
 
 
9088
 
static void
9089
 
nautilus_icon_container_accessible_class_init (AtkObjectClass *klass)
9090
 
{
 
9057
 
 
9058
        G_OBJECT_CLASS (nautilus_icon_container_accessible_parent_class)->finalize (object);
 
9059
}
 
9060
 
 
9061
static void
 
9062
nautilus_icon_container_accessible_init (NautilusIconContainerAccessible *self)
 
9063
{
 
9064
        self->priv = G_TYPE_INSTANCE_GET_PRIVATE (self, nautilus_icon_container_accessible_get_type (),
 
9065
                                                  NautilusIconContainerAccessiblePrivate);
 
9066
}
 
9067
 
 
9068
static void
 
9069
nautilus_icon_container_accessible_class_init (NautilusIconContainerAccessibleClass *klass)
 
9070
{
 
9071
        AtkObjectClass *atk_class = ATK_OBJECT_CLASS (klass);
9091
9072
        GObjectClass *gobject_class = G_OBJECT_CLASS (klass);
9092
9073
 
9093
 
        accessible_parent_class = g_type_class_peek_parent (klass);
9094
 
 
9095
9074
        gobject_class->finalize = nautilus_icon_container_accessible_finalize;
9096
9075
 
9097
 
        klass->get_n_children = nautilus_icon_container_accessible_get_n_children;
9098
 
        klass->ref_child = nautilus_icon_container_accessible_ref_child;
9099
 
        klass->initialize = nautilus_icon_container_accessible_initialize;
 
9076
        atk_class->get_n_children = nautilus_icon_container_accessible_get_n_children;
 
9077
        atk_class->ref_child = nautilus_icon_container_accessible_ref_child;
 
9078
        atk_class->initialize = nautilus_icon_container_accessible_initialize;
9100
9079
 
9101
 
        accessible_private_data_quark = g_quark_from_static_string ("icon-container-accessible-private-data");
 
9080
        g_type_class_add_private (klass, sizeof (NautilusIconContainerAccessiblePrivate));
9102
9081
}
9103
9082
 
9104
 
static GType
9105
 
nautilus_icon_container_accessible_get_type (void)
 
9083
static AtkObject *
 
9084
get_accessible (GtkWidget *widget)
9106
9085
{
9107
 
        static GType type = 0;
9108
 
 
9109
 
        if (!type) {
9110
 
                static GInterfaceInfo atk_action_info = {
9111
 
                        (GInterfaceInitFunc) nautilus_icon_container_accessible_action_interface_init,
9112
 
                        (GInterfaceFinalizeFunc) NULL,
9113
 
                        NULL
9114
 
                };              
9115
 
                
9116
 
                static GInterfaceInfo atk_selection_info = {
9117
 
                        (GInterfaceInitFunc) nautilus_icon_container_accessible_selection_interface_init,
9118
 
                        (GInterfaceFinalizeFunc) NULL,
9119
 
                        NULL
9120
 
                };              
9121
 
 
9122
 
                type = eel_accessibility_create_derived_type 
9123
 
                        ("NautilusIconContainerAccessible",
9124
 
                         EEL_TYPE_CANVAS,
9125
 
                         nautilus_icon_container_accessible_class_init);
9126
 
                
9127
 
                g_type_add_interface_static (type, ATK_TYPE_ACTION,
9128
 
                                             &atk_action_info);
9129
 
                g_type_add_interface_static (type, ATK_TYPE_SELECTION,
9130
 
                                             &atk_selection_info);
9131
 
        }
9132
 
 
9133
 
        return type;
 
9086
        AtkObject *accessible;
 
9087
        
 
9088
        if ((accessible = eel_accessibility_get_atk_object (widget))) {
 
9089
                return accessible;
 
9090
        }
 
9091
 
 
9092
        accessible = g_object_new (nautilus_icon_container_accessible_get_type (), "widget", widget, NULL);
 
9093
 
 
9094
        return eel_accessibility_set_atk_object_return (widget, accessible);
9134
9095
}
9135
9096
 
9136
9097
#if ! defined (NAUTILUS_OMIT_SELF_CHECK)