← Back to branch summary

~3v1n0/unity/light-shortcuts

« back to all changes in this revision

Viewing changes to plugins/unityshell/src/unity-quicklist-menu-item-accessible.cpp

  • Committer: Marco Trevisan (Treviño)
  • Date: 2013-04-26 12:41:09 UTC
  • Revision ID: mail@3v1n0.net-20130426124109-t3b2shjah2omiqa2
Unity: Remove all the views, but the Shortcuts

Show diffs side-by-side

added added

removed removed

Lines of Context:
plugins/unityshell/src/unity-quicklist-menu-item-accessible.cpp
1
 
/*
2
 
 * Copyright (C) 2011 Canonical Ltd
3
 
 *
4
 
 * This program is free software: you can redistribute it and/or modify
5
 
 * it under the terms of the GNU General Public License version 3 as
6
 
 * published by the Free Software Foundation.
7
 
 *
8
 
 * This program is distributed in the hope that it will be useful,
9
 
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
10
 
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
11
 
 * GNU General Public License for more details.
12
 
 *
13
 
 * You should have received a copy of the GNU General Public License
14
 
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
15
 
 *
16
 
 * Authored by: Alejandro Piñeiro Iglesias <apinheiro@igalia.com>
17
 
 */
18
 
 
19
 
/**
20
 
 * SECTION:unity-quicklist_menu_item-accessible
21
 
 * @Title: UnityQuicklistMenuItemAccessible
22
 
 * @short_description: Implementation of the ATK interfaces for #QuicklistMenuItem
23
 
 * @see_also: QuicklistMenuItem
24
 
 *
25
 
 * #UnityQuicklistMenuItemAccessible implements the required ATK interfaces for
26
 
 * #QuicklistMenuItem, mainly exposing the text as his name, as this
27
 
 * #object is mainly used as a label
28
 
 *
29
 
 */
30
 
 
31
 
#include <glib/gi18n.h>
32
 
 
33
 
#include "unity-quicklist-menu-item-accessible.h"
34
 
 
35
 
#include "unitya11y.h"
36
 
#include "QuicklistMenuItem.h"
37
 
#include "QuicklistMenuItemLabel.h"
38
 
#include "QuicklistMenuItemSeparator.h"
39
 
 
40
 
/* GObject */
41
 
static void unity_quicklist_menu_item_accessible_class_init(UnityQuicklistMenuItemAccessibleClass* klass);
42
 
static void unity_quicklist_menu_item_accessible_init(UnityQuicklistMenuItemAccessible* self);
43
 
static void unity_quicklist_menu_item_accessible_dispose(GObject* object);
44
 
 
45
 
/* AtkObject.h */
46
 
static void         unity_quicklist_menu_item_accessible_initialize(AtkObject* accessible,
47
 
                                                                    gpointer   data);
48
 
static const gchar* unity_quicklist_menu_item_accessible_get_name(AtkObject* obj);
49
 
static AtkStateSet* unity_quicklist_menu_item_accessible_ref_state_set(AtkObject* obj);
50
 
 
51
 
/* private */
52
 
static void on_parent_selection_change_cb(AtkSelection* selection,
53
 
                                          gpointer data);
54
 
 
55
 
G_DEFINE_TYPE(UnityQuicklistMenuItemAccessible, unity_quicklist_menu_item_accessible,  NUX_TYPE_VIEW_ACCESSIBLE);
56
 
 
57
 
 
58
 
#define UNITY_QUICKLIST_MENU_ITEM_ACCESSIBLE_GET_PRIVATE(obj)           \
59
 
  (G_TYPE_INSTANCE_GET_PRIVATE ((obj), UNITY_TYPE_QUICKLIST_MENU_ITEM_ACCESSIBLE, \
60
 
                                UnityQuicklistMenuItemAccessiblePrivate))
61
 
 
62
 
struct _UnityQuicklistMenuItemAccessiblePrivate
63
 
{
64
 
  gboolean selected;
65
 
 
66
 
  guint on_parent_selection_change_id;
67
 
  guint on_parent_change_id;
68
 
};
69
 
 
70
 
using unity::QuicklistMenuItem;
71
 
using unity::QuicklistMenuItemLabel;
72
 
using unity::QuicklistMenuItemSeparator;
73
 
 
74
 
static void
75
 
unity_quicklist_menu_item_accessible_class_init(UnityQuicklistMenuItemAccessibleClass* klass)
76
 
{
77
 
  GObjectClass* gobject_class = G_OBJECT_CLASS(klass);
78
 
  AtkObjectClass* atk_class = ATK_OBJECT_CLASS(klass);
79
 
 
80
 
  gobject_class->dispose = unity_quicklist_menu_item_accessible_dispose;
81
 
 
82
 
  /* AtkObject */
83
 
  atk_class->get_name = unity_quicklist_menu_item_accessible_get_name;
84
 
  atk_class->initialize = unity_quicklist_menu_item_accessible_initialize;
85
 
  atk_class->ref_state_set = unity_quicklist_menu_item_accessible_ref_state_set;
86
 
 
87
 
  g_type_class_add_private(gobject_class, sizeof(UnityQuicklistMenuItemAccessiblePrivate));
88
 
}
89
 
 
90
 
static void
91
 
unity_quicklist_menu_item_accessible_init(UnityQuicklistMenuItemAccessible* self)
92
 
{
93
 
  UnityQuicklistMenuItemAccessiblePrivate* priv =
94
 
    UNITY_QUICKLIST_MENU_ITEM_ACCESSIBLE_GET_PRIVATE(self);
95
 
 
96
 
  self->priv = priv;
97
 
}
98
 
 
99
 
static void
100
 
unity_quicklist_menu_item_accessible_dispose(GObject* object)
101
 
{
102
 
  UnityQuicklistMenuItemAccessible* self = UNITY_QUICKLIST_MENU_ITEM_ACCESSIBLE(object);
103
 
  AtkObject* parent = NULL;
104
 
 
105
 
  parent = atk_object_get_parent(ATK_OBJECT(object));
106
 
 
107
 
  if (UNITY_IS_QUICKLIST_MENU_ITEM_ACCESSIBLE(parent))
108
 
  {
109
 
    if (self->priv->on_parent_selection_change_id != 0)
110
 
      g_signal_handler_disconnect(parent, self->priv->on_parent_selection_change_id);
111
 
  }
112
 
 
113
 
  if (self->priv->on_parent_change_id != 0)
114
 
    g_signal_handler_disconnect(object, self->priv->on_parent_change_id);
115
 
 
116
 
  G_OBJECT_CLASS(unity_quicklist_menu_item_accessible_parent_class)->dispose(object);
117
 
}
118
 
 
119
 
AtkObject*
120
 
unity_quicklist_menu_item_accessible_new(nux::Object* object)
121
 
{
122
 
  AtkObject* accessible = NULL;
123
 
 
124
 
  g_return_val_if_fail(dynamic_cast<QuicklistMenuItem*>(object), NULL);
125
 
 
126
 
  accessible = ATK_OBJECT(g_object_new(UNITY_TYPE_QUICKLIST_MENU_ITEM_ACCESSIBLE, NULL));
127
 
 
128
 
  atk_object_initialize(accessible, object);
129
 
 
130
 
  return accessible;
131
 
}
132
 
 
133
 
/* AtkObject.h */
134
 
static gboolean
135
 
menu_item_is_a_separator(QuicklistMenuItem* menu_item)
136
 
{
137
 
  QuicklistMenuItemSeparator* separator = NULL;
138
 
 
139
 
  separator = dynamic_cast<QuicklistMenuItemSeparator*>(menu_item);
140
 
 
141
 
  if (separator != NULL)
142
 
    return TRUE;
143
 
  else
144
 
    return FALSE;
145
 
}
146
 
 
147
 
static void
148
 
on_parent_change_cb(gchar* property,
149
 
                    GValue* value,
150
 
                    gpointer data)
151
 
{
152
 
  AtkObject* parent = NULL;
153
 
  UnityQuicklistMenuItemAccessible* self = NULL;
154
 
 
155
 
  g_return_if_fail(UNITY_IS_QUICKLIST_MENU_ITEM_ACCESSIBLE(data));
156
 
  self = UNITY_QUICKLIST_MENU_ITEM_ACCESSIBLE(data);
157
 
 
158
 
  parent = atk_object_get_parent(ATK_OBJECT(self));
159
 
 
160
 
  if (parent == NULL)
161
 
    return;
162
 
 
163
 
  self->priv->on_parent_selection_change_id =
164
 
    g_signal_connect(parent, "selection-changed",
165
 
                     G_CALLBACK(on_parent_selection_change_cb), self);
166
 
}
167
 
 
168
 
static void
169
 
unity_quicklist_menu_item_accessible_initialize(AtkObject* accessible,
170
 
                                                gpointer data)
171
 
{
172
 
  nux::Object* nux_object = NULL;
173
 
  QuicklistMenuItem* menu_item = NULL;
174
 
  UnityQuicklistMenuItemAccessible* self = NULL;
175
 
 
176
 
  ATK_OBJECT_CLASS(unity_quicklist_menu_item_accessible_parent_class)->initialize(accessible, data);
177
 
  self = UNITY_QUICKLIST_MENU_ITEM_ACCESSIBLE(accessible);
178
 
 
179
 
  nux_object = nux_object_accessible_get_object(NUX_OBJECT_ACCESSIBLE(accessible));
180
 
  menu_item = dynamic_cast<QuicklistMenuItem*>(nux_object);
181
 
 
182
 
  if (menu_item == NULL)
183
 
    return;
184
 
 
185
 
  if (menu_item_is_a_separator(menu_item))
186
 
    atk_object_set_role(accessible, ATK_ROLE_SEPARATOR);
187
 
  else
188
 
    atk_object_set_role(accessible, ATK_ROLE_MENU_ITEM);
189
 
 
190
 
  /* we could do that by redefining ->set_parent */
191
 
  self->priv->on_parent_change_id =
192
 
    g_signal_connect(accessible, "notify::accessible-parent",
193
 
                     G_CALLBACK(on_parent_change_cb), self);
194
 
}
195
 
 
196
 
 
197
 
 
198
 
static const gchar*
199
 
unity_quicklist_menu_item_accessible_get_name(AtkObject* obj)
200
 
{
201
 
  const gchar* name = NULL;
202
 
 
203
 
  g_return_val_if_fail(UNITY_IS_QUICKLIST_MENU_ITEM_ACCESSIBLE(obj), NULL);
204
 
 
205
 
  name = ATK_OBJECT_CLASS(unity_quicklist_menu_item_accessible_parent_class)->get_name(obj);
206
 
  if (name == NULL)
207
 
  {
208
 
    QuicklistMenuItem* menu_item = NULL;
209
 
 
210
 
    menu_item = dynamic_cast<QuicklistMenuItem*>(nux_object_accessible_get_object(NUX_OBJECT_ACCESSIBLE(obj)));
211
 
    if (menu_item != NULL)
212
 
    {
213
 
      name = menu_item->GetLabel().c_str();
214
 
    }
215
 
  }
216
 
 
217
 
  return name;
218
 
}
219
 
 
220
 
static AtkStateSet*
221
 
unity_quicklist_menu_item_accessible_ref_state_set(AtkObject* obj)
222
 
{
223
 
  AtkStateSet* state_set = NULL;
224
 
  UnityQuicklistMenuItemAccessible* self = NULL;
225
 
  nux::Object* nux_object = NULL;
226
 
 
227
 
  g_return_val_if_fail(UNITY_IS_QUICKLIST_MENU_ITEM_ACCESSIBLE(obj), NULL);
228
 
  self = UNITY_QUICKLIST_MENU_ITEM_ACCESSIBLE(obj);
229
 
 
230
 
  state_set = ATK_OBJECT_CLASS(unity_quicklist_menu_item_accessible_parent_class)->ref_state_set(obj);
231
 
 
232
 
  nux_object = nux_object_accessible_get_object(NUX_OBJECT_ACCESSIBLE(obj));
233
 
 
234
 
  if (nux_object == NULL) /* defunct */
235
 
    return state_set;
236
 
 
237
 
  /* by default */
238
 
  atk_state_set_add_state(state_set, ATK_STATE_FOCUSABLE);
239
 
  atk_state_set_add_state(state_set, ATK_STATE_ENABLED);
240
 
  atk_state_set_add_state(state_set, ATK_STATE_SENSITIVE);
241
 
 
242
 
  if (self->priv->selected)
243
 
  {
244
 
    atk_state_set_add_state(state_set, ATK_STATE_FOCUSED);
245
 
    atk_state_set_add_state(state_set, ATK_STATE_SELECTED);
246
 
    atk_state_set_add_state(state_set, ATK_STATE_ACTIVE);
247
 
  }
248
 
  else
249
 
  {
250
 
    /* we clean the states that could come from NuxAreaAccessible */
251
 
    atk_state_set_remove_state(state_set, ATK_STATE_FOCUSED);
252
 
  }
253
 
 
254
 
  return state_set;
255
 
}
256
 
 
257
 
/* private */
258
 
static void
259
 
check_selected(UnityQuicklistMenuItemAccessible* self)
260
 
{
261
 
  AtkObject* selected_item = NULL;
262
 
  AtkObject* parent = NULL;
263
 
  nux::Object* nux_object = NULL;
264
 
  gboolean found = FALSE;
265
 
 
266
 
  nux_object = nux_object_accessible_get_object(NUX_OBJECT_ACCESSIBLE(self));
267
 
  if (nux_object == NULL) /* state is defunct */
268
 
    return;
269
 
 
270
 
  parent = atk_object_get_parent(ATK_OBJECT(self));
271
 
  if (parent == NULL)
272
 
    return;
273
 
 
274
 
  selected_item = atk_selection_ref_selection(ATK_SELECTION(parent), 0);
275
 
 
276
 
  if (ATK_OBJECT(self) == selected_item)
277
 
    found = TRUE;
278
 
 
279
 
  if (found != self->priv->selected)
280
 
  {
281
 
    gboolean return_val = FALSE;
282
 
 
283
 
    self->priv->selected = found;
284
 
    atk_object_notify_state_change(ATK_OBJECT(self),
285
 
                                   ATK_STATE_FOCUSED,
286
 
                                   found);
287
 
    atk_object_notify_state_change(ATK_OBJECT(self),
288
 
                                   ATK_STATE_SELECTED,
289
 
                                   found);
290
 
    atk_object_notify_state_change(ATK_OBJECT(self),
291
 
                                   ATK_STATE_ACTIVE,
292
 
                                   found);
293
 
 
294
 
    g_signal_emit_by_name(self, "focus-event", self->priv->selected, &return_val);
295
 
  }
296
 
}
297
 
 
298
 
static void
299
 
on_parent_selection_change_cb(AtkSelection* selection,
300
 
                              gpointer data)
301
 
{
302
 
  g_return_if_fail(UNITY_IS_QUICKLIST_MENU_ITEM_ACCESSIBLE(data));
303
 
 
304
 
  check_selected(UNITY_QUICKLIST_MENU_ITEM_ACCESSIBLE(data));
305
 
}