atspi/atspi-stateset.c

   1 /*
   2  * AT-SPI - Assistive Technology Service Provider Interface
   3  * (Gnome Accessibility Project; http://developer.gnome.org/projects/gap)
   4  *
   5  * Copyright 2001, 2002 Sun Microsystems Inc.,
   6  * Copyright 2001, 2002 Ximian, Inc.
   7  * Copyright 2010, 2011 Novell, Inc.
   8  *
   9  * This library is free software; you can redistribute it and/or
  10  * modify it under the terms of the GNU Library General Public
  11  * License as published by the Free Software Foundation; either
  12  * version 2 of the License, or (at your option) any later version.
  13  *
  14  * This library is distributed in the hope that it will be useful,
  15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  17  * Library General Public License for more details.
  18  *
  19  * You should have received a copy of the GNU Library General Public
  20  * License along with this library; if not, write to the
  21  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  22  * Boston, MA 02111-1307, USA.
  23  */
  24
  25 #include "atspi-private.h"
  26
  27 static void atspi_state_set_class_init (AtspiStateSetClass *klass);
  28
  29 G_DEFINE_TYPE (AtspiStateSet, atspi_state_set, G_TYPE_OBJECT)
  30
  31 static void
  32 atspi_state_set_init (AtspiStateSet *set)
  33 {
  34   set->states = 0;
  35 }
  36
  37 static void
  38 atspi_state_set_class_init (AtspiStateSetClass* klass)
  39 {
  40 }
  41
  42 /*
  43  * atspi_state_set_new:
  44  *
  45  * @states: (element-type AtspiStateType): An array of states with which to initialize
  46  * the state set.
  47  *
  48  * Returns: A new #AtspiStateSet with the given states.
  49  **/
  50 AtspiStateSet *
  51 atspi_state_set_new (GArray *states)
  52 {
  53   AtspiStateSet *set = g_object_new (ATSPI_TYPE_STATE_SET, NULL);
  54   gint i;
  55
  56   if (!set || !states)
  57     return set;
  58
  59   for (i = 0; i < states->len; i++)
  60     atspi_state_set_add (set, g_array_index (states, AtspiStateType, i));
  61   return set;
  62 }
  63
  64 AtspiStateSet *
  65 _atspi_state_set_new_internal (AtspiAccessible *accessible, gint64 states)
  66 {
  67   AtspiStateSet *set;
  68
  69   set = g_object_new (ATSPI_TYPE_STATE_SET, NULL);
  70   g_return_val_if_fail (set != NULL, NULL);
  71
  72   set->accessible = accessible;
  73   set->states = states;
  74   return set;
  75 }
  76
  77 void
  78 atspi_state_set_set_by_name (AtspiStateSet *set, const gchar *name, gboolean enabled)
  79 {
  80   GTypeClass *type_class;
  81   GEnumValue *value;
  82
  83   type_class = g_type_class_ref (ATSPI_TYPE_STATE_TYPE);
  84
  85   if (set->accessible &&
  86       !(set->accessible->cached_properties & ATSPI_CACHE_STATES))
  87     return;
  88
  89   value = g_enum_get_value_by_nick (G_ENUM_CLASS (type_class), name);
  90   if (!value)
  91   {
  92     g_warning ("AT-SPI: Attempt to set unknown state '%s'", name);
  93   }
  94
  95   if (enabled)
  96     set->states |= ((gint64)1 << value->value);
  97   else
  98     set->states &= ~((gint64)1 << value->value);
  99 }
 100
 101 static void
 102 refresh_states (AtspiStateSet *set)
 103 {
 104   GArray *state_array;
 105   dbus_uint32_t *states;
 106
 107   if (!set->accessible ||
 108       (set->accessible->cached_properties & ATSPI_CACHE_STATES))
 109     return;
 110
 111   if (!_atspi_dbus_call (set->accessible, atspi_interface_accessible, "GetState", NULL, "=>au", &state_array))
 112     return;
 113
 114   states = (dbus_uint32_t *) state_array->data;
 115
 116   set->states = ((gint64)states [1]) << 32;
 117   set->states |= (gint64) states [0];
 118   g_array_free (state_array, TRUE);
 119 }
 120
 121 /**
 122  * atspi_state_set_add:
 123  *
 124  * @set: a pointer to the #AtspiStateSet object on which to operate.
 125  * @state: an #AtspiStateType to be added to the specified #AtspiStateSet.
 126  *
 127  * Add a particular #AtspiState to an #AtspiStateSet (i.e. set the
 128  *       given state to #TRUE in the stateset.
 129  *
 130  **/
 131 void
 132 atspi_state_set_add (AtspiStateSet *set, AtspiStateType state)
 133 {
 134   g_return_if_fail (set != NULL);
 135   set->states |= (((gint64)1) << state);
 136 }
 137
 138 /**
 139  * atspi_state_set_compare:
 140  * @set: a pointer to the first #AtspiStateSet object on which to operate.
 141  * @set: a pointer to the second #AtspiStateSet setect on which to operate.
 142  *
 143  * Determine the differences between two instances of #AtspiStateSet.
 144  *.
 145  * @see AtspiStateSet_equals().
 146  *
 147  * Returns: (transfer full): an #AtspiStateSet object containing all states
 148  *          contained on one of the two sets but not the other.
 149  *
 150  **/
 151 AtspiStateSet *
 152 atspi_state_set_compare (AtspiStateSet *set,
 153                          AtspiStateSet *set2)
 154 {
 155   g_return_val_if_fail (set != NULL, NULL);
 156   g_return_val_if_fail (set2 != NULL, NULL);
 157
 158   return _atspi_state_set_new_internal (NULL, set->states ^ set2->states);
 159 }
 160
 161 /**
 162  * atspi_state_set_contains:
 163  * @set: a pointer to the #AtspiStateSet object on which to operate.
 164  * @state: an #AtspiStateType for which the specified #AtspiStateSet
 165  *       will be queried.
 166  *
 167  * Determine whether a given #AtspiStateSet includes a given state; that is,
 168  *       whether @state is true for the stateset in question.
 169  *
 170  * Returns: #TRUE if @state is true/included in the given #AtspiStateSet,
 171  *          otherwise #FALSE.
 172  *
 173  **/
 174 gboolean
 175 atspi_state_set_contains (AtspiStateSet *set,
 176                              AtspiStateType state)
 177 {
 178   if (!set)
 179     return FALSE;
 180   refresh_states (set);
 181   return (set->states & ((gint64)1 << state)) ? TRUE : FALSE;
 182 }
 183
 184 /**
 185  * atspi_state_set_equals:
 186  * @set: a pointer to the first #AtspiStateSet object on which to operate.
 187  * @set2: a pointer to the second #AtspiStateSet object on which to operate.
 188  *
 189  * Determine whether two instances of #AtspiStateSet are equivalent (i.e.
 190  *         consist of the same #AtspiStates).  Useful for checking multiple
 191  *         state variables at once; construct the target state then compare against it.
 192  *
 193  * @see AtspiStateSet_compare().
 194  *
 195  * Returns: #TRUE if the two #AtspiStateSets are equivalent,
 196  *          otherwise #FALSE.
 197  *
 198  **/
 199 gboolean
 200 atspi_state_set_equals (AtspiStateSet *set,
 201                            AtspiStateSet *set2)
 202 {
 203   if (set == set2)
 204     return TRUE;
 205   if (set == NULL || set2 == NULL)
 206     return FALSE;
 207   return (set->states == set2->states);
 208 }
 209
 210 /**
 211  * atspi_state_set_get_states:
 212  *
 213  * @set: The #AtspiStateSet to be queried.
 214  *
 215  * Return the states in an #AtspiStateSet as an array.
 216  *
 217  * Returns: (element-type AtspiStateType) (transfer full): A #GArray of state
 218  *          types representing the current state.
 219  **/
 220 GArray *
 221 atspi_state_set_get_states (AtspiStateSet *set)
 222 {
 223   gint i = 0;
 224   guint64 val = 1;
 225   GArray *ret;
 226
 227   g_return_val_if_fail (set != NULL, NULL);
 228   refresh_states (set);
 229   ret = g_array_new (TRUE, TRUE, sizeof (AtspiStateType));
 230   if (!ret)
 231     return NULL;
 232   for (i = 0; i < 64; i++)
 233   {
 234     if (set->states & val)
 235     {
 236       GArray *new_array = g_array_append_val (ret, i);
 237       if (new_array)
 238         ret = new_array;
 239     }
 240     val <<= 1;
 241   }
 242   return ret;
 243 }
 244
 245 /**
 246  * atspi_state_set_is_empty:
 247  *
 248  * @set: The #AtspiStateSet to query.
 249  *
 250  * Returns: #TRUE if the state set contains no states; #FALSE otherwise.
 251  **/
 252 gboolean
 253 atspi_state_set_is_empty (AtspiStateSet *set)
 254 {
 255   return (set->states == 0);
 256 }
 257
 258 /**
 259  * atspi_state_set_remove:
 260  *
 261  * @set: a pointer to the #AtspiStateSet object on which to operate.
 262  * @state: an #AtspiStateType to remove from the specifiedn state set.
 263  *
 264  * Remove a particular #AtspiState to an #AtspiStateSet (i.e. set the
 265  *       given state to #FALSE in the stateset.)
 266  *
 267  **/
 268 void
 269 atspi_state_set_remove (AtspiStateSet *set, AtspiStateType state)
 270 {
 271   g_return_if_fail (set != NULL);
 272   set->states &= ~((gint64)1 << state);
 273 }
 274