cspi/spi_component.c

   1 /*
   2  *
   3  * AccessibleComponent function implementations
   4  *
   5  */
   6
   7 #include <cspi/spi-private.h>
   8
   9 /**
  10  * AccessibleComponent_ref:
  11  * @obj: a pointer to an object implementing #AccessibleComponent on which to operate.
  12  *
  13  * Increment the reference count for an #AccessibleComponent.
  14  *
  15  * Returns: (no return code implemented yet).
  16  *
  17  **/
  18 int
  19 AccessibleComponent_ref (AccessibleComponent *obj)
  20 {
  21   cspi_object_ref (obj);
  22   return 0;
  23 }
  24
  25 /**
  26  * AccessibleComponent_unref:
  27  * @obj: a pointer to the object implementing #AccessibleComponent on which to operate.
  28  *
  29  * Decrement the reference count for an #AccessibleComponent.
  30  *
  31  * Returns: (no return code implemented yet).
  32  *
  33  **/
  34 int
  35 AccessibleComponent_unref (AccessibleComponent *obj)
  36 {
  37   cspi_object_unref (obj);
  38   return 0;
  39 }
  40
  41 /**
  42  * AccessibleComponent_contains:
  43  * @obj: a pointer to the #AccessibleComponent to query.
  44  * @x: a #long specifying the x coordinate in question.
  45  * @y: a #long specifying the y coordinate in question.
  46  * @ctype: the desired coordinate system of the point (@x, @y)
  47  *         (e.g. CSPI_COORD_TYPE_WINDOW, CSPI_COORD_TYPE_SCREEN).
  48  *
  49  * Query whether a given #AccessibleComponent contains a particular point.
  50  *
  51  * Returns: a #TRUE if the specified component contains the point (@x, @y),
  52  *          otherwise #FALSE.
  53  **/
  54 SPIBoolean
  55 AccessibleComponent_contains (AccessibleComponent *obj,
  56                               long int x,
  57                               long int y,
  58                               AccessibleCoordType ctype)
  59 {
  60   return Accessibility_Component_contains (CSPI_OBJREF (obj),
  61                                            (CORBA_long) x,
  62                                            (CORBA_long) y,
  63                                            ctype,
  64                                            cspi_ev ());
  65 }
  66
  67 /**
  68  * AccessibleComponent_getAccessibleAtPoint:
  69  * @obj: a pointer to the #AccessibleComponent to query.
  70  * @x: a #long specifying the x coordinate of the point in question.
  71  * @y: a #long specifying the y coordinate of the point in question.
  72  * @ctype: the coordinate system of the point (@x, @y)
  73  *         (e.g. CSPI_COORD_TYPE_WINDOW, CSPI_COORD_TYPE_SCREEN).
  74  *
  75  * Get the accessible child at a given coordinate within an #AccessibleComponent.
  76  *
  77  * Returns: a pointer to an #Accessible child of the specified component which
  78  *          contains the point (@x, @y), or NULL of no child contains the point.
  79  **/
  80 Accessible *
  81 AccessibleComponent_getAccessibleAtPoint (AccessibleComponent *obj,
  82                                           long int x,
  83                                           long int y,
  84                                           AccessibleCoordType ctype)
  85 {
  86   Accessibility_Accessible child;
  87
  88   child = Accessibility_Component_getAccessibleAtPoint(CSPI_OBJREF (obj),
  89                                                        (CORBA_long) x,
  90                                                        (CORBA_long) y,
  91                                                        ctype,
  92                                                        cspi_ev ());
  93   return cspi_object_add (child);
  94 }
  95
  96 /**
  97  * AccessibleComponent_getExtents:
  98  * @obj: a pointer to the #AccessibleComponent to query.
  99  * @x: a pointer to a #long into which the minimum x coordinate will be returned.
 100  * @y: a pointer to a #long into which the minimum y coordinate will be returned.
 101  * @width: a pointer to a #long into which the x extents (width) will be returned.
 102  * @height: a pointer to a #long into which the y extents (height) will be returned.
 103  * @ctype: the desired coordinate system into which to return the results,
 104  *         (e.g. CSPI_COORD_TYPE_WINDOW, CSPI_COORD_TYPE_SCREEN).
 105  *
 106  * Get the bounding box of the specified #AccessibleComponent.
 107  *
 108  **/
 109 void
 110 AccessibleComponent_getExtents (AccessibleComponent *obj,
 111                                 long int *x,
 112                                 long int *y,
 113                                 long int *width,
 114                                 long int *height,
 115                                 AccessibleCoordType ctype)
 116 {
 117   Accessibility_BoundingBox bbox;
 118   bbox = Accessibility_Component_getExtents (CSPI_OBJREF (obj),
 119                                              ctype,
 120                                              cspi_ev ());
 121   cspi_warn_ev (cspi_ev (), "AccessibleComponent_getExtents");
 122   *x = bbox.x;
 123   *y = bbox.y;
 124   *width = bbox.width;
 125   *height = bbox.height;
 126 }
 127
 128 /**
 129  * AccessibleComponent_getPosition:
 130  * @obj: a pointer to the #AccessibleComponent to query.
 131  * @x: a pointer to a #long into which the minimum x coordinate will be returned.
 132  * @y: a pointer to a #long into which the minimum y coordinate will be returned.
 133  * @ctype: the desired coordinate system into which to return the results,
 134  *         (e.g. CSPI_COORD_TYPE_WINDOW, CSPI_COORD_TYPE_SCREEN).
 135  *
 136  * Get the minimum x and y coordinates of the specified #AccessibleComponent.
 137  *
 138  **/
 139 void
 140 AccessibleComponent_getPosition (AccessibleComponent *obj,
 141                                  long int *x,
 142                                  long int *y,
 143                                  AccessibleCoordType ctype)
 144 {
 145   Accessibility_Component_getPosition (CSPI_OBJREF (obj),
 146                                        (CORBA_long *) x,
 147                                        (CORBA_long *) y,
 148                                        ctype,
 149                                        cspi_ev ());
 150 }
 151
 152 /**
 153  * AccessibleComponent_getSize:
 154  * @obj: a pointer to the #AccessibleComponent to query.
 155  * @width: a pointer to a #long into which the x extents (width) will be returned.
 156  * @height: a pointer to a #long into which the y extents (height) will be returned.
 157  *
 158  * Get the size of the specified #AccessibleComponent.
 159  *
 160  **/
 161 void
 162 AccessibleComponent_getSize (AccessibleComponent *obj,
 163                              long int *width,
 164                              long int *height)
 165 {
 166   Accessibility_Component_getSize (CSPI_OBJREF (obj),
 167                                    (CORBA_long *) width,
 168                                    (CORBA_long *) height,
 169                                    cspi_ev ());
 170 }
 171
 172 /**
 173  * AccessibleComponent_getLayer:
 174  * @obj: a pointer to the #AccessibleComponent to query.
 175  *
 176  * Query which layer the component is painted into, to help determine its
 177  *      visibility in terms of stacking order.
 178  *
 179  * Returns: the #AccessibleComponentLayer into which this component is painted.
 180  **/
 181 AccessibleComponentLayer
 182 AccessibleComponent_getLayer (AccessibleComponent *obj)
 183 {
 184   Accessibility_ComponentLayer zlayer;
 185   AccessibleComponentLayer retval;
 186
 187   zlayer = Accessibility_Component_getLayer (CSPI_OBJREF (obj),
 188                                              cspi_ev ());
 189   switch (zlayer)
 190     {
 191     case Accessibility_LAYER_BACKGROUND:
 192       retval = SPI_LAYER_BACKGROUND;
 193       break;
 194     case Accessibility_LAYER_CANVAS:
 195       retval = SPI_LAYER_CANVAS;
 196       break;
 197     case Accessibility_LAYER_WIDGET:
 198       retval = SPI_LAYER_WIDGET;
 199       break;
 200     case Accessibility_LAYER_MDI:
 201       retval = SPI_LAYER_MDI;
 202       break;
 203     case Accessibility_LAYER_POPUP:
 204       retval = SPI_LAYER_POPUP;
 205       break;
 206     case Accessibility_LAYER_OVERLAY:
 207       retval = SPI_LAYER_OVERLAY;
 208       break;
 209     default:
 210       retval = SPI_LAYER_INVALID;
 211       break;
 212     }
 213   return retval;
 214 }
 215
 216 /**
 217  * AccessibleComponent_getMDIZOrder:
 218  * @obj: a pointer to the #AccessibleComponent to query.
 219  *
 220  * Query the z stacking order of a component which is in the MDI layer.
 221  *       (Bigger z-order numbers mean nearer the top)
 222  *
 223  * Returns: a short integer indicating the stacking order of the component
 224  *       in the MDI layer, or -1 if the component is not in the MDI layer.
 225  **/
 226 short
 227 AccessibleComponent_getMDIZOrder (AccessibleComponent *obj)
 228 {
 229   return (short) Accessibility_Component_getMDIZOrder (CSPI_OBJREF (obj),
 230                                                        cspi_ev ());
 231 }
 232
 233 /**
 234  * AccessibleComponent_grabFocus:
 235  * @obj: a pointer to the #AccessibleComponent on which to operate.
 236  *
 237  * Attempt to set the keyboard input focus to the specified
 238  *         #AccessibleComponent.
 239  *
 240  **/
 241 void
 242 AccessibleComponent_grabFocus (AccessibleComponent *obj)
 243 {
 244   ;
 245 }