libspi/value.c

   1 /*
   2  * AT-SPI - Assistive Technology Service Provider Interface
   3  * (Gnome Accessibility Project; http://developer.gnome.org/projects/gap)
   4  *
   5  * Copyright 2008 Novell, Inc.
   6  * Copyright 2001, 2002 Sun Microsystems Inc.,
   7  * Copyright 2001, 2002 Ximian, 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 "accessible.h"
  26 #include <math.h>
  27
  28 static AtkValue *
  29 get_value_from_path (const char *path, void *user_data)
  30 {
  31   AtkObject *obj = spi_dbus_get_object (path);
  32   if (!obj || !ATK_IS_VALUE(obj))
  33     return NULL;
  34   return ATK_VALUE (obj);
  35 }
  36
  37 static double
  38 get_double_from_gvalue (GValue * gvalue)
  39 {
  40   double retval = 0;
  41   if (G_TYPE_IS_FUNDAMENTAL (G_VALUE_TYPE (gvalue)))
  42     {
  43       switch (gvalue->g_type)
  44         {
  45         case G_TYPE_DOUBLE:
  46           retval = g_value_get_double (gvalue);
  47           break;
  48         case G_TYPE_FLOAT:
  49           retval = g_value_get_float (gvalue);
  50           break;
  51         case G_TYPE_ULONG:
  52           retval = g_value_get_ulong (gvalue);
  53           break;
  54         case G_TYPE_LONG:
  55           retval = g_value_get_long (gvalue);
  56           break;
  57         case G_TYPE_UINT:
  58           retval = g_value_get_uint (gvalue);
  59           break;
  60         case G_TYPE_INT:
  61           retval = g_value_get_int (gvalue);
  62           break;
  63         case G_TYPE_UCHAR:
  64           retval = g_value_get_uchar (gvalue);
  65           break;
  66         case G_TYPE_CHAR:
  67           retval = g_value_get_char (gvalue);
  68           break;
  69         case G_TYPE_BOOLEAN:
  70           retval = g_value_get_boolean (gvalue);
  71           break;
  72         }
  73     }
  74   else
  75     {
  76       g_warning ("SpiValue requested from a non-fundamental type\n");
  77     }
  78   return retval;
  79 }
  80
  81 static gboolean
  82 get_double_from_variant (DBusMessageIter * iter, double *out)
  83 {
  84   DBusMessageIter sub;
  85
  86   dbus_message_iter_recurse (iter, &sub);
  87   switch (dbus_message_iter_get_arg_type (&sub))
  88     {
  89     case DBUS_TYPE_DOUBLE:
  90       {
  91         dbus_message_iter_get_basic (&sub, out);
  92         return TRUE;
  93       }
  94     case DBUS_TYPE_UINT32:
  95       {
  96         dbus_uint32_t v;
  97         dbus_message_iter_get_basic (&sub, &v);
  98         *out = (double) v;
  99         return TRUE;
 100       }
 101     case DBUS_TYPE_INT32:
 102       {
 103         dbus_int32_t v;
 104         dbus_message_iter_get_basic (&sub, &v);
 105         *out = (double) v;
 106         return TRUE;
 107       }
 108     case DBUS_TYPE_UINT16:
 109       {
 110         dbus_uint16_t v;
 111         dbus_message_iter_get_basic (&sub, &v);
 112         *out = (double) v;
 113         return TRUE;
 114       }
 115     case DBUS_TYPE_INT16:
 116       {
 117         dbus_int16_t v;
 118         dbus_message_iter_get_basic (&sub, &v);
 119         *out = (double) v;
 120         return TRUE;
 121       }
 122     case DBUS_TYPE_BYTE:
 123       {
 124         char v;
 125         dbus_message_iter_get_basic (&sub, &v);
 126         *out = (double) v;
 127         return TRUE;
 128       }
 129     case DBUS_TYPE_BOOLEAN:
 130       {
 131         dbus_bool_t v;
 132         dbus_message_iter_get_basic (&sub, &v);
 133         *out = (double) v;
 134         return TRUE;
 135       }
 136     default:
 137       return FALSE;
 138     }
 139 }
 140
 141 static void
 142 gvalue_set_from_double (GValue * gvalue, double value)
 143 {
 144   if (G_TYPE_IS_FUNDAMENTAL (G_VALUE_TYPE (gvalue)))
 145     {
 146       switch (gvalue->g_type)
 147         {
 148         case G_TYPE_DOUBLE:
 149           g_value_set_double (gvalue, value);
 150           break;
 151         case G_TYPE_FLOAT:
 152           g_value_set_float (gvalue, value);
 153           break;
 154         case G_TYPE_ULONG:
 155           g_value_set_ulong (gvalue, value);
 156           break;
 157         case G_TYPE_LONG:
 158           g_value_set_long (gvalue, value);
 159           break;
 160         case G_TYPE_UINT:
 161           g_value_set_uint (gvalue, value);
 162           break;
 163         case G_TYPE_INT:
 164           g_value_set_int (gvalue, value);
 165           break;
 166         case G_TYPE_UCHAR:
 167           g_value_set_uchar (gvalue, value);
 168           break;
 169         case G_TYPE_CHAR:
 170           g_value_set_char (gvalue, value);
 171           break;
 172         case G_TYPE_BOOLEAN:
 173           g_value_set_boolean (gvalue, ((fabs (value) > 0.5) ? 1 : 0));
 174           break;
 175         }
 176     }
 177   else
 178     {
 179       g_warning ("SpiValue change requested for a non-fundamental type\n");
 180     }
 181 }
 182
 183 static dbus_bool_t
 184 impl_get_minimumValue (const char *path, DBusMessageIter * iter,
 185                        void *user_data)
 186 {
 187   AtkValue *value = get_value_from_path (path, user_data);
 188   GValue gvalue = { 0, };
 189   if (!value)
 190     return FALSE;
 191   atk_value_get_minimum_value (value, &gvalue);
 192   return droute_return_v_double (iter, get_double_from_gvalue (&gvalue));
 193 }
 194
 195 static dbus_bool_t
 196 impl_get_maximumValue (const char *path, DBusMessageIter * iter,
 197                        void *user_data)
 198 {
 199   AtkValue *value = get_value_from_path (path, user_data);
 200   GValue gvalue = { 0, };
 201   if (!value)
 202     return FALSE;
 203   atk_value_get_maximum_value (value, &gvalue);
 204   return droute_return_v_double (iter, get_double_from_gvalue (&gvalue));
 205 }
 206
 207 static dbus_bool_t
 208 impl_get_minimumIncrement (const char *path, DBusMessageIter * iter,
 209                            void *user_data)
 210 {
 211   AtkValue *value = get_value_from_path (path, user_data);
 212   GValue gvalue = { 0, };
 213   if (!value)
 214     return FALSE;
 215   atk_value_get_minimum_value (value, &gvalue);
 216   return droute_return_v_double (iter, get_double_from_gvalue (&gvalue));
 217 }
 218
 219 static dbus_bool_t
 220 impl_get_currentValue (const char *path, DBusMessageIter * iter,
 221                        void *user_data)
 222 {
 223   AtkValue *value = get_value_from_path (path, user_data);
 224   GValue gvalue = { 0, };
 225   if (!value)
 226     return FALSE;
 227   atk_value_get_current_value (value, &gvalue);
 228   return droute_return_v_double (iter, get_double_from_gvalue (&gvalue));
 229 }
 230
 231 static dbus_bool_t
 232 impl_set_currentValue (const char *path, DBusMessageIter * iter,
 233                        void *user_data)
 234 {
 235   AtkValue *value = get_value_from_path (path, user_data);
 236   GValue gvalue = { 0, };
 237   double dbl;
 238
 239   if (!value)
 240     return FALSE;
 241   if (!get_double_from_variant (iter, &dbl))
 242     return FALSE;
 243   atk_value_get_current_value (value, &gvalue);
 244   gvalue_set_from_double (&gvalue, dbl);
 245   return TRUE;
 246 }
 247
 248 static DRouteProperty properties[] = {
 249   {impl_get_minimumValue, NULL, "minimumValue"},
 250   {impl_get_maximumValue, NULL, "maximumValue"},
 251   {impl_get_minimumIncrement, NULL, "minimumIncrement"},
 252   {impl_get_currentValue, impl_set_currentValue, "currentValue"},
 253   {NULL, NULL, NULL}
 254 };
 255
 256 void
 257 spi_initialize_value (DRouteData * data)
 258 {
 259   droute_add_interface (data, "org.freedesktop.atspi.Value", NULL,
 260                         properties,
 261                         (DRouteGetDatumFunction) get_value_from_path, NULL);
 262 };