From: billh Date: Tue, 11 Dec 2001 13:58:46 +0000 (+0000) Subject: Modified Value.idl interface to use unions, removes the assumption that X-Git-Tag: AT_SPI2_ATK_2_12_0~1475 X-Git-Url: http://review.tizen.org/git/?p=platform%2Fcore%2Fuifw%2Fat-spi2-atk.git;a=commitdiff_plain;h=0f5127d4190c958799a217626fdd1a6906d33122 Modified Value.idl interface to use unions, removes the assumption that values are always floats or transferable to and from floats. Introduced SValue union. git-svn-id: http://svn.gnome.org/svn/at-spi/trunk@174 e2bd861d-eb25-0410-b326-f6ed22b6b98c --- diff --git a/ChangeLog b/ChangeLog index 7580c01..77e8179 100644 --- a/ChangeLog +++ b/ChangeLog @@ -1,4 +1,21 @@ +2001-12-11 Bill Haneman + * idl/Value.idl: + Changed Value interface to use SValue (scalars) rather than + assuming all values are floats. This allows floats, doubles, + longs, shorts, and unsigned values to be manipulated. + Introduced Accessibility:SValue union. + + * libspi/value.c: + Updated to use new API above, and to work correctly with GValues + of different types in AtkValue. + + * cspi/spi_value.c: + Updated to use new API above. cspi's API is as yet unchanged. + + * TODO: + Updated the Value revision action item. + 2001-12-10 Bill Haneman * test/test-simple.c: diff --git a/TODO b/TODO index 3335798..6786cbc 100644 --- a/TODO +++ b/TODO @@ -1,9 +1,11 @@ TODO: idl: - possibly change Value.idl interface to return a value union. [Bill] + possibly change Value.idl interface to return a value +union. [Bill] *DONE* + cspi: - API change required if above IDL change is made. + API change required if above IDL change is made. [Bill] libspi: diff --git a/cspi/spi_value.c b/cspi/spi_value.c index bfc5545..13a1f84 100644 --- a/cspi/spi_value.c +++ b/cspi/spi_value.c @@ -1,5 +1,62 @@ #include +static void +svalue_set_from_float (Accessibility_SValue *sval, float newValue) +{ + switch (sval->_d) + { + case Accessibility_SHORTVAL: + sval->_u.val_short = CLAMP (newValue, G_MINSHORT, G_MAXSHORT); + break; + case Accessibility_USHORTVAL: + sval->_u.val_ushort = CLAMP (newValue, 0, G_MAXUSHORT); + break; + case Accessibility_LONGVAL: + sval->_u.val_long = CLAMP (newValue, G_MINLONG, G_MAXLONG); + break; + case Accessibility_ULONGVAL: + sval->_u.val_ulong = CLAMP (newValue, 0, G_MAXULONG); + break; + case Accessibility_FLOATVAL: + sval->_u.val_float = newValue; + break; + case Accessibility_DOUBLEVAL: + sval->_u.val_double = newValue; + break; + } +} + + +static float +svalue_to_float (Accessibility_SValue *sval) +{ + float retval = 0.0; + switch (sval->_d) + { + case Accessibility_SHORTVAL: + retval = sval->_u.val_short; + break; + case Accessibility_USHORTVAL: + retval = sval->_u.val_ushort; + break; + case Accessibility_LONGVAL: + retval = sval->_u.val_long; + break; + case Accessibility_ULONGVAL: + retval = sval->_u.val_ulong; + break; + case Accessibility_FLOATVAL: + retval = sval->_u.val_float; + break; + case Accessibility_DOUBLEVAL: + retval = sval->_u.val_double; + break; + } + + return retval; +} + + /** * AccessibleValue_ref: * @obj: a pointer to the #AccessibleValue implementor on which to operate. @@ -36,16 +93,16 @@ AccessibleValue_unref (AccessibleValue *obj) float AccessibleValue_getMinimumValue (AccessibleValue *obj) { - float retval; + Accessibility_SValue sval; cspi_return_val_if_fail (obj != NULL, 0.0); - retval = + sval = Accessibility_Value__get_minimumValue (CSPI_OBJREF (obj), cspi_ev ()); - + cspi_return_val_if_ev ("getMinimumValue", 0.0); - return retval; + return svalue_to_float (&sval); } /** @@ -59,16 +116,16 @@ AccessibleValue_getMinimumValue (AccessibleValue *obj) float AccessibleValue_getCurrentValue (AccessibleValue *obj) { - float retval; + Accessibility_SValue sval; cspi_return_val_if_fail (obj != NULL, 0.0); - retval = + sval = Accessibility_Value__get_currentValue (CSPI_OBJREF (obj), cspi_ev ()); cspi_return_val_if_ev ("getCurrentValue", 0.0); - return retval; + return svalue_to_float (&sval); } /** @@ -82,16 +139,16 @@ AccessibleValue_getCurrentValue (AccessibleValue *obj) float AccessibleValue_getMaximumValue (AccessibleValue *obj) { - float retval; + Accessibility_SValue sval; cspi_return_val_if_fail (obj != NULL, 0.0); - retval = + sval = Accessibility_Value__get_maximumValue (CSPI_OBJREF (obj), cspi_ev ()); cspi_return_val_if_ev ("getMaximumValue", 0.0); - return retval; + return svalue_to_float (&sval); } /** @@ -108,10 +165,17 @@ SPIBoolean AccessibleValue_setCurrentValue (AccessibleValue *obj, float newValue) { + Accessibility_SValue sval; cspi_return_val_if_fail (obj != NULL, FALSE); + /* erk, this is ugly */ + sval = Accessibility_Value__get_currentValue ( + CSPI_OBJREF (obj), cspi_ev ()); + + svalue_set_from_float (&sval, newValue); + Accessibility_Value__set_currentValue ( - CSPI_OBJREF (obj), (CORBA_float) newValue, cspi_ev ()); + CSPI_OBJREF (obj), &sval, cspi_ev ()); cspi_return_val_if_ev ("setCurrentValue", FALSE); diff --git a/idl/Accessibility_Value.idl b/idl/Accessibility_Value.idl index 430ef4f..aa18fce 100644 --- a/idl/Accessibility_Value.idl +++ b/idl/Accessibility_Value.idl @@ -22,10 +22,28 @@ module Accessibility { + enum ValueType { + SHORTVAL, + USHORTVAL, + LONGVAL, + ULONGVAL, + FLOATVAL, + DOUBLEVAL + }; + + union SValue switch (ValueType) { + case Accessibility::SHORTVAL: short val_short; + case Accessibility::USHORTVAL: unsigned short val_ushort; + case Accessibility::LONGVAL: long val_long; + case Accessibility::ULONGVAL: unsigned long val_ulong; + case Accessibility::FLOATVAL: float val_float; + case Accessibility::DOUBLEVAL: double val_double; + }; + interface Value : Bonobo::Unknown { - readonly attribute float minimumValue; - readonly attribute float maximumValue; - readonly attribute float minimumIncrement; - attribute float currentValue; + readonly attribute SValue minimumValue; + readonly attribute SValue maximumValue; + readonly attribute SValue minimumIncrement; + attribute SValue currentValue; }; }; diff --git a/idl/Value.idl b/idl/Value.idl index 430ef4f..aa18fce 100644 --- a/idl/Value.idl +++ b/idl/Value.idl @@ -22,10 +22,28 @@ module Accessibility { + enum ValueType { + SHORTVAL, + USHORTVAL, + LONGVAL, + ULONGVAL, + FLOATVAL, + DOUBLEVAL + }; + + union SValue switch (ValueType) { + case Accessibility::SHORTVAL: short val_short; + case Accessibility::USHORTVAL: unsigned short val_ushort; + case Accessibility::LONGVAL: long val_long; + case Accessibility::ULONGVAL: unsigned long val_ulong; + case Accessibility::FLOATVAL: float val_float; + case Accessibility::DOUBLEVAL: double val_double; + }; + interface Value : Bonobo::Unknown { - readonly attribute float minimumValue; - readonly attribute float maximumValue; - readonly attribute float minimumIncrement; - attribute float currentValue; + readonly attribute SValue minimumValue; + readonly attribute SValue maximumValue; + readonly attribute SValue minimumIncrement; + attribute SValue currentValue; }; }; diff --git a/libspi/value.c b/libspi/value.c index 372bb0d..fcd0a20 100644 --- a/libspi/value.c +++ b/libspi/value.c @@ -29,23 +29,25 @@ /* Static function declarations */ +static Accessibility_SValue +gvalue_to_svalue (GValue *gvalue); static void spi_value_class_init (SpiValueClass *klass); static void spi_value_init (SpiValue *value); -static CORBA_float +static Accessibility_SValue impl__get_minimumValue (PortableServer_Servant _servant, - CORBA_Environment * ev); -static CORBA_float + CORBA_Environment * ev); +static Accessibility_SValue impl__get_maximumValue (PortableServer_Servant _servant, - CORBA_Environment * ev); -static CORBA_float + CORBA_Environment * ev); +static Accessibility_SValue impl__get_currentValue (PortableServer_Servant _servant, - CORBA_Environment * ev); + CORBA_Environment * ev); static void -impl__set_currentValue (PortableServer_Servant _servant, - const CORBA_float value, - CORBA_Environment * ev); +impl__set_currentValue (PortableServer_Servant _servant, + const Accessibility_SValue * value, + CORBA_Environment * ev); BONOBO_TYPE_FUNC_FULL (SpiValue, @@ -98,64 +100,134 @@ get_value_from_servant (PortableServer_Servant servant) return ATK_VALUE (object->atko); } +static Accessibility_SValue +gvalue_to_svalue (GValue *gvalue) +{ + Accessibility_SValue sval; + if (G_VALUE_HOLDS_DOUBLE (gvalue)) + { + sval._d = Accessibility_DOUBLEVAL; + sval._u.val_double = g_value_get_double (gvalue); + } + else if (G_VALUE_HOLDS_FLOAT (gvalue)) + { + sval._d = Accessibility_FLOATVAL; + sval._u.val_float = g_value_get_float (gvalue); + } + else if (G_VALUE_HOLDS_ULONG (gvalue)) + { + sval._d = Accessibility_ULONGVAL; + sval._u.val_ulong = g_value_get_ulong (gvalue); + } + else if (G_VALUE_HOLDS_LONG (gvalue)) + { + sval._d = Accessibility_LONGVAL; + sval._u.val_long = g_value_get_long (gvalue); + } + else if (G_VALUE_HOLDS_UINT (gvalue)) + { + sval._d = Accessibility_USHORTVAL; + sval._u.val_ushort = CLAMP (g_value_get_uint (gvalue), 0, G_MAXUSHORT); + } + else if (G_VALUE_HOLDS_INT (gvalue)) + { + sval._d = Accessibility_SHORTVAL; + sval._u.val_short = CLAMP (g_value_get_int (gvalue), G_MINSHORT, G_MAXSHORT); + } + else + { + sval._d = Accessibility_SHORTVAL; + sval._u.val_short = 0; + } + return sval; +} + +static void +gvalue_set_from_svalue (GValue *gvalue, Accessibility_SValue *sval) +{ + switch (sval->_d) + { + case Accessibility_DOUBLEVAL: + g_value_init (gvalue, G_TYPE_DOUBLE); + g_value_set_double (gvalue, sval->_u.val_double); + break; + case Accessibility_FLOATVAL: + g_value_init (gvalue, G_TYPE_FLOAT); + g_value_set_float (gvalue, sval->_u.val_float); + break; + case Accessibility_ULONGVAL: + g_value_init (gvalue, G_TYPE_ULONG); + g_value_set_ulong (gvalue, sval->_u.val_ulong); + break; + case Accessibility_LONGVAL: + g_value_init (gvalue, G_TYPE_LONG); + g_value_set_long (gvalue, sval->_u.val_long); + break; + case Accessibility_USHORTVAL: + g_value_init (gvalue, G_TYPE_UINT); + g_value_set_uint (gvalue, sval->_u.val_ushort); + break; + case Accessibility_SHORTVAL: + g_value_init (gvalue, G_TYPE_INT); + g_value_set_int (gvalue, sval->_u.val_short); + break; + default: + g_value_init (gvalue, G_TYPE_INT); + g_value_set_int (gvalue, 0); + } +} -static CORBA_float +static Accessibility_SValue impl__get_minimumValue (PortableServer_Servant servant, CORBA_Environment *ev) { GValue gvalue = {0, }; AtkValue *value = get_value_from_servant (servant); - g_return_val_if_fail (value != NULL, 0.0); - - /* - * FIXME: ahem, there's no guarantee that - * atk_value_get_minimum_value returns a float. - * What we really need is a generic value API here - */ + g_return_val_if_fail (value != NULL, gvalue_to_svalue (&gvalue)); g_value_init (&gvalue, G_TYPE_DOUBLE); atk_value_get_minimum_value (value, &gvalue); - return (CORBA_float) g_value_get_double (&gvalue); + return gvalue_to_svalue (&gvalue); } -static CORBA_float +static Accessibility_SValue impl__get_maximumValue (PortableServer_Servant servant, CORBA_Environment *ev) { GValue gvalue = {0, }; AtkValue *value = get_value_from_servant (servant); - g_return_val_if_fail (value != NULL, 0.0); + g_return_val_if_fail (value != NULL, gvalue_to_svalue (&gvalue)); g_value_init (&gvalue, G_TYPE_DOUBLE); atk_value_get_maximum_value (value, &gvalue); - return (CORBA_float) g_value_get_double (&gvalue); + return gvalue_to_svalue (&gvalue); } -static CORBA_float +static Accessibility_SValue impl__get_currentValue (PortableServer_Servant servant, CORBA_Environment *ev) { GValue gvalue = {0, }; AtkValue *value = get_value_from_servant (servant); - g_return_val_if_fail (value != NULL, 0.0); + g_return_val_if_fail (value != NULL, gvalue_to_svalue (&gvalue)); g_value_init (&gvalue, G_TYPE_DOUBLE); atk_value_get_current_value (value, &gvalue); - return (CORBA_float) g_value_get_double (&gvalue); + return gvalue_to_svalue (&gvalue); } static void impl__set_currentValue (PortableServer_Servant servant, - const CORBA_float value, + const Accessibility_SValue *value, CORBA_Environment *ev) { GValue gvalue = {0, }; @@ -163,8 +235,7 @@ impl__set_currentValue (PortableServer_Servant servant, g_return_if_fail (avalue != NULL); - g_value_init (&gvalue, G_TYPE_DOUBLE); - g_value_set_double (&gvalue, (gdouble) value); + gvalue_set_from_svalue (&gvalue, value); atk_value_set_current_value (avalue, &gvalue); }