2001-11-13 Michael Meeks <michael@ximian.com>
[platform/core/uifw/at-spi2-atk.git] / 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 2001 Sun Microsystems Inc.
6  *
7  * This library is free software; you can redistribute it and/or
8  * modify it under the terms of the GNU Library General Public
9  * License as published by the Free Software Foundation; either
10  * version 2 of the License, or (at your option) any later version.
11  *
12  * This library is distributed in the hope that it will be useful,
13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
15  * Library General Public License for more details.
16  *
17  * You should have received a copy of the GNU Library General Public
18  * License along with this library; if not, write to the
19  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
20  * Boston, MA 02111-1307, USA.
21  */
22
23 /*
24  * component.c : bonobo wrapper for accessible component implementation
25  *
26  */
27 #include <config.h>
28 #include <bonobo/Bonobo.h>
29
30 #include <stdio.h>
31
32 /*
33  * This pulls the CORBA definitions for the "Accessibility::Accessible" server
34  */
35 #include <libspi/Accessibility.h>
36
37 /*
38  * This pulls the definition of the SpiValue bonobo object
39  */
40 #include "value.h"
41
42 /*
43  * Static function declarations
44  */
45
46 static void
47 spi_value_class_init (SpiValueClass *klass);
48 static void
49 spi_value_init (SpiValue *value);
50 static void
51 spi_value_finalize (GObject *obj);
52 static CORBA_float
53 impl__get_minimumValue (PortableServer_Servant _servant,
54                         CORBA_Environment * ev);
55 static        CORBA_float
56 impl__get_maximumValue (PortableServer_Servant _servant,
57                         CORBA_Environment * ev);
58 static CORBA_float
59 impl__get_currentValue (PortableServer_Servant _servant,
60                         CORBA_Environment * ev);
61 static void 
62 impl__set_currentValue (PortableServer_Servant _servant,
63                         const CORBA_float value,
64                         CORBA_Environment * ev);
65
66
67
68 static GObjectClass *parent_class;
69
70
71 GType
72 spi_value_get_type (void)
73 {
74   static GType type = 0;
75
76   if (!type) {
77     static const GTypeInfo tinfo = {
78       sizeof (SpiValueClass),
79       (GBaseInitFunc) NULL,
80       (GBaseFinalizeFunc) NULL,
81       (GClassInitFunc) spi_value_class_init,
82       (GClassFinalizeFunc) NULL,
83       NULL, /* class data */
84       sizeof (SpiValue),
85       0, /* n preallocs */
86       (GInstanceInitFunc) spi_value_init,
87                         NULL /* value table */
88     };
89
90     /*
91      * Bonobo_type_unique auto-generates a load of
92      * CORBA structures for us. All derived types must
93      * use bonobo_type_unique.
94      */
95     type = bonobo_type_unique (
96                                BONOBO_OBJECT_TYPE,
97                                POA_Accessibility_Value__init,
98                                NULL,
99                                G_STRUCT_OFFSET (SpiValueClass, epv),
100                                &tinfo,
101                                "SpiAccessibleValue");
102   }
103
104   return type;
105 }
106
107 static void
108 spi_value_class_init (SpiValueClass *klass)
109 {
110   GObjectClass * object_class = (GObjectClass *) klass;
111   POA_Accessibility_Value__epv *epv = &klass->epv;
112   parent_class = g_type_class_peek_parent (klass);
113
114   object_class->finalize = spi_value_finalize;
115
116
117   /* Initialize epv table */
118
119   epv->_get_minimumValue = impl__get_minimumValue;
120   epv->_get_maximumValue = impl__get_maximumValue;
121   epv->_get_currentValue = impl__get_currentValue;
122   epv->_set_currentValue = impl__set_currentValue;
123 }
124
125 static void
126 spi_value_init (SpiValue *value)
127 {
128 }
129
130 static void
131 spi_value_finalize (GObject *obj)
132 {
133   SpiValue *value = SPI_VALUE (obj);
134   g_object_unref (value->atko);
135   value->atko = NULL;
136   parent_class->finalize (obj);
137 }
138
139 SpiValue *
140 spi_value_interface_new (AtkObject *obj)
141 {
142   SpiValue *new_value = 
143     SPI_VALUE(g_object_new (SPI_VALUE_TYPE, NULL));
144   new_value->atko = obj;
145   g_object_ref (obj);
146   return new_value;
147 }
148
149
150
151 static CORBA_float
152 impl__get_minimumValue (PortableServer_Servant _servant,
153                        CORBA_Environment * ev)
154 {
155   SpiValue *value = SPI_VALUE (bonobo_object_from_servant (_servant));
156   GValue gvalue = {0, };
157
158   g_value_init (&gvalue, G_TYPE_FLOAT);
159   atk_value_get_minimum_value (ATK_VALUE(value->atko), &gvalue);
160   return (CORBA_float) g_value_get_float (&gvalue);
161 }
162
163
164
165 static        CORBA_float
166 impl__get_maximumValue (PortableServer_Servant _servant,
167                         CORBA_Environment * ev)
168 {
169   SpiValue *value = SPI_VALUE (bonobo_object_from_servant (_servant));
170   GValue gvalue = {0, };
171
172   g_value_init (&gvalue, G_TYPE_FLOAT);
173   atk_value_get_maximum_value (ATK_VALUE(value->atko), &gvalue);
174   return (CORBA_float) g_value_get_float (&gvalue);
175 }
176
177
178
179 static CORBA_float
180 impl__get_currentValue (PortableServer_Servant _servant,
181                         CORBA_Environment * ev)
182 {
183   SpiValue *value = SPI_VALUE (bonobo_object_from_servant (_servant));
184   GValue gvalue = {0, };
185
186   g_value_init (&gvalue, G_TYPE_FLOAT);
187   atk_value_get_current_value (ATK_VALUE(value->atko), &gvalue);
188   return (CORBA_float) g_value_get_float (&gvalue);
189 }
190
191
192 static void 
193 impl__set_currentValue (PortableServer_Servant _servant,
194                         const CORBA_float value,
195                         CORBA_Environment * ev)
196 {
197   SpiValue *val = SPI_VALUE (bonobo_object_from_servant (_servant));
198   GValue gvalue = {0, };
199
200   g_value_init (&gvalue, G_TYPE_FLOAT);
201   g_value_set_float (&gvalue, (gfloat) value);
202   atk_value_set_current_value (ATK_VALUE(val->atko), &gvalue);
203 }
204
205