atk/atkhyperlink.c

   1 /* ATK -  Accessibility Toolkit
   2  * Copyright 2001, 2002, 2003 Sun Microsystems Inc.
   3  *
   4  * This library is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU Lesser General Public
   6  * License as published by the Free Software Foundation; either
   7  * version 2 of the License, or (at your option) any later version.
   8  *
   9  * This library is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12  * Lesser General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU Lesser General Public
  15  * License along with this library; if not, write to the
  16  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  17  * Boston, MA 02111-1307, USA.
  18  */
  19
  20 #include "atkhyperlink.h"
  21 #include "atkintl.h"
  22
  23 enum
  24 {
  25   LINK_ACTIVATED,
  26
  27   LAST_SIGNAL
  28 };
  29
  30 enum
  31 {
  32   PROP_0,  /* gobject convention */
  33
  34   PROP_SELECTED_LINK,
  35   PROP_NUMBER_ANCHORS,
  36   PROP_END_INDEX,
  37   PROP_START_INDEX,
  38   PROP_LAST
  39 };
  40
  41 static void atk_hyperlink_class_init (AtkHyperlinkClass *klass);
  42 static void atk_hyperlink_init       (AtkHyperlink      *link,
  43                                       AtkHyperlinkClass *klass);
  44
  45 static void atk_hyperlink_real_get_property (GObject            *object,
  46                                              guint              prop_id,
  47                                              GValue             *value,
  48                                              GParamSpec         *pspec);
  49
  50 static void atk_hyperlink_action_iface_init (AtkActionIface *iface);
  51
  52 static guint atk_hyperlink_signals[LAST_SIGNAL] = { 0, };
  53
  54 static gpointer  parent_class = NULL;
  55
  56 GType
  57 atk_hyperlink_get_type (void)
  58 {
  59   static GType type = 0;
  60
  61   if (!type)
  62     {
  63       static const GTypeInfo typeInfo =
  64       {
  65         sizeof (AtkHyperlinkClass),
  66         (GBaseInitFunc) NULL,
  67         (GBaseFinalizeFunc) NULL,
  68         (GClassInitFunc) atk_hyperlink_class_init,
  69         (GClassFinalizeFunc) NULL,
  70         NULL,
  71         sizeof (AtkHyperlink),
  72         0,
  73         (GInstanceInitFunc) atk_hyperlink_init,
  74       } ;
  75
  76       static const GInterfaceInfo action_info =
  77       {
  78         (GInterfaceInitFunc) atk_hyperlink_action_iface_init,
  79         (GInterfaceFinalizeFunc) NULL,
  80         NULL
  81       };
  82
  83       type = g_type_register_static (G_TYPE_OBJECT, "AtkHyperlink", &typeInfo, 0) ;
  84       g_type_add_interface_static (type, ATK_TYPE_ACTION, &action_info);
  85     }
  86   return type;
  87 }
  88
  89 static void
  90 atk_hyperlink_class_init (AtkHyperlinkClass *klass)
  91 {
  92   GObjectClass *gobject_class = G_OBJECT_CLASS (klass);
  93
  94   parent_class = g_type_class_peek_parent (klass);
  95
  96   gobject_class->get_property = atk_hyperlink_real_get_property;
  97
  98   klass->link_activated = NULL;
  99
 100   g_object_class_install_property (gobject_class,
 101                                    PROP_SELECTED_LINK,
 102                                    g_param_spec_boolean ("selected-link",
 103                                                          _("Selected Link"),
 104                                                          _("Specifies whether the AtkHyperlink object is selected"),
 105                                                          FALSE,
 106                                                          G_PARAM_READABLE));
 107   g_object_class_install_property (gobject_class,
 108                                    PROP_NUMBER_ANCHORS,
 109                                    g_param_spec_int ("number-of-anchors",
 110                                                      _("Number of Anchors"),
 111                                                      _("The number of anchors associated with the AtkHyperlink object"),
 112                                                      0,
 113                                                      G_MAXINT,
 114                                                      0,
 115                                                      G_PARAM_READABLE));
 116   g_object_class_install_property (gobject_class,
 117                                    PROP_END_INDEX,
 118                                    g_param_spec_int ("end-index",
 119                                                      _("End index"),
 120                                                      _("The end index of the AtkHyperlink object"),
 121                                                      0,
 122                                                      G_MAXINT,
 123                                                      0,
 124                                                      G_PARAM_READABLE));
 125   g_object_class_install_property (gobject_class,
 126                                    PROP_END_INDEX,
 127                                    g_param_spec_int ("start-index",
 128                                                      _("Start index"),
 129                                                      _("The start index of the AtkHyperlink object"),
 130                                                      0,
 131                                                      G_MAXINT,
 132                                                      0,
 133                                                      G_PARAM_READABLE));
 134   atk_hyperlink_signals[LINK_ACTIVATED] =
 135     g_signal_new ("link_activated",
 136                   G_TYPE_FROM_CLASS (klass),
 137                   G_SIGNAL_RUN_LAST,
 138                   G_STRUCT_OFFSET (AtkHyperlinkClass, link_activated),
 139                   NULL, NULL,
 140                   g_cclosure_marshal_VOID__VOID,
 141                   G_TYPE_NONE,
 142                   0);
 143
 144 }
 145
 146 static void
 147 atk_hyperlink_init  (AtkHyperlink        *link,
 148                      AtkHyperlinkClass   *klass)
 149 {
 150 }
 151
 152 static void
 153 atk_hyperlink_real_get_property (GObject    *object,
 154                                  guint      prop_id,
 155                                  GValue     *value,
 156                                  GParamSpec *pspec)
 157 {
 158   AtkHyperlink* link;
 159
 160   link = ATK_HYPERLINK (object);
 161
 162   switch (prop_id)
 163     {
 164     case PROP_SELECTED_LINK:
 165       g_value_set_boolean (value, atk_hyperlink_is_selected_link (link));
 166       break;
 167     case PROP_NUMBER_ANCHORS:
 168       g_value_set_int (value,  atk_hyperlink_get_n_anchors (link));
 169       break;
 170     case PROP_END_INDEX:
 171       g_value_set_int (value, atk_hyperlink_get_end_index (link));
 172       break;
 173     case PROP_START_INDEX:
 174       g_value_set_int (value, atk_hyperlink_get_start_index (link));
 175       break;
 176     default:
 177       break;
 178     }
 179 }
 180
 181 /**
 182  * atk_hyperlink_get_uri:
 183  * @link_: an #AtkHyperlink
 184  * @i: a (zero-index) integer specifying the desired anchor
 185  *
 186  * Get a the URI associated with the anchor specified
 187  * by @i of @link_.
 188  *
 189  * Multiple anchors are primarily used by client-side image maps.
 190  *
 191  * Returns: a string specifying the URI
 192  **/
 193 gchar*
 194 atk_hyperlink_get_uri (AtkHyperlink *link,
 195                        gint         i)
 196 {
 197   AtkHyperlinkClass *klass;
 198
 199   g_return_val_if_fail (ATK_IS_HYPERLINK (link), NULL);
 200
 201   klass = ATK_HYPERLINK_GET_CLASS (link);
 202   if (klass->get_uri)
 203     return (klass->get_uri) (link, i);
 204   else
 205     return NULL;
 206 }
 207
 208 /**
 209  * atk_hyperlink_get_object:
 210  * @link_: an #AtkHyperlink
 211  * @i: a (zero-index) integer specifying the desired anchor
 212  *
 213  * Returns the item associated with this hyperlinks nth anchor.
 214  * For instance, the returned #AtkObject will implement #AtkText
 215  * if @link_ is a text hyperlink, #AtkImage if @link_ is an image
 216  * hyperlink etc.
 217  *
 218  * Multiple anchors are primarily used by client-side image maps.
 219  *
 220  * Returns: an #AtkObject associated with this hyperlinks i-th anchor
 221  **/
 222 AtkObject*
 223 atk_hyperlink_get_object (AtkHyperlink *link,
 224                           gint         i)
 225 {
 226   AtkHyperlinkClass *klass;
 227
 228   g_return_val_if_fail (ATK_IS_HYPERLINK (link), NULL);
 229
 230   klass = ATK_HYPERLINK_GET_CLASS (link);
 231   if (klass->get_object)
 232     return (klass->get_object) (link, i);
 233   else
 234     return NULL;
 235 }
 236
 237 /**
 238  * atk_hyperlink_get_end_index:
 239  * @link_: an #AtkHyperlink
 240  *
 241  * Gets the index with the hypertext document at which this link ends.
 242  *
 243  * Returns: the index with the hypertext document at which this link ends
 244  **/
 245 gint
 246 atk_hyperlink_get_end_index (AtkHyperlink *link)
 247 {
 248   AtkHyperlinkClass *klass;
 249
 250   g_return_val_if_fail (ATK_IS_HYPERLINK (link), 0);
 251
 252   klass = ATK_HYPERLINK_GET_CLASS (link);
 253   if (klass->get_end_index)
 254     return (klass->get_end_index) (link);
 255   else
 256     return 0;
 257 }
 258
 259 /**
 260  * atk_hyperlink_get_start_index:
 261  * @link_: an #AtkHyperlink
 262  *
 263  * Gets the index with the hypertext document at which this link begins.
 264  *
 265  * Returns: the index with the hypertext document at which this link begins
 266  **/
 267 gint
 268 atk_hyperlink_get_start_index (AtkHyperlink *link)
 269 {
 270   AtkHyperlinkClass *klass;
 271
 272   g_return_val_if_fail (ATK_IS_HYPERLINK (link), 0);
 273
 274   klass = ATK_HYPERLINK_GET_CLASS (link);
 275   if (klass->get_start_index)
 276     return (klass->get_start_index) (link);
 277   else
 278     return 0;
 279 }
 280
 281 /**
 282  * atk_hyperlink_is_valid:
 283  * @link_: an #AtkHyperlink
 284  *
 285  * Since the document that a link is associated with may have changed
 286  * this method returns %TRUE if the link is still valid (with
 287  * respect to the document it references) and %FALSE otherwise.
 288  *
 289  * Returns: whether or not this link is still valid
 290  **/
 291 gboolean
 292 atk_hyperlink_is_valid (AtkHyperlink *link)
 293 {
 294   AtkHyperlinkClass *klass;
 295
 296   g_return_val_if_fail (ATK_IS_HYPERLINK (link), FALSE);
 297
 298   klass = ATK_HYPERLINK_GET_CLASS (link);
 299   if (klass->is_valid)
 300     return (klass->is_valid) (link);
 301   else
 302     return FALSE;
 303 }
 304
 305 /**
 306  * atk_hyperlink_is_inline:
 307  * @link_: an #AtkHyperlink
 308  *
 309  * Indicates whether the link currently displays some or all of its
 310  *           content inline.  Ordinary HTML links will usually return
 311  *           %FALSE, but an inline &lt;src&gt; HTML element will return
 312  *           %TRUE.
 313 a *
 314  * Returns: whether or not this link displays its content inline.
 315  *
 316  **/
 317 gboolean
 318 atk_hyperlink_is_inline (AtkHyperlink *link)
 319 {
 320   AtkHyperlinkClass *klass;
 321
 322   g_return_val_if_fail (ATK_IS_HYPERLINK (link), FALSE);
 323
 324   klass = ATK_HYPERLINK_GET_CLASS (link);
 325   if (klass->link_state)
 326     return (klass->link_state (link) & ATK_HYPERLINK_IS_INLINE);
 327   else
 328     return FALSE;
 329 }
 330
 331 /**
 332  * atk_hyperlink_get_n_anchors:
 333  * @link_: an #AtkHyperlink
 334  *
 335  * Gets the number of anchors associated with this hyperlink.
 336  *
 337  * Returns: the number of anchors associated with this hyperlink
 338  **/
 339 gint
 340 atk_hyperlink_get_n_anchors (AtkHyperlink *link)
 341 {
 342   AtkHyperlinkClass *klass;
 343
 344   g_return_val_if_fail (ATK_IS_HYPERLINK (link), 0);
 345
 346   klass = ATK_HYPERLINK_GET_CLASS (link);
 347   if (klass->get_n_anchors)
 348     return (klass->get_n_anchors) (link);
 349   else
 350     return 0;
 351 }
 352
 353 /**
 354  * atk_hyperlink_is_selected_link:
 355  * @link_: an #AtkHyperlink
 356  *
 357  * Determines whether this AtkHyperlink is selected
 358  *
 359  * Returns: True is the AtkHyperlink is selected, False otherwise
 360  **/
 361 gboolean
 362 atk_hyperlink_is_selected_link (AtkHyperlink *link)
 363 {
 364   AtkHyperlinkClass *klass;
 365
 366   g_return_val_if_fail (ATK_IS_HYPERLINK (link), FALSE);
 367
 368   klass = ATK_HYPERLINK_GET_CLASS (link);
 369   if (klass->is_selected_link)
 370     return (klass->is_selected_link) (link);
 371   else
 372     return FALSE;
 373 }
 374
 375 static void atk_hyperlink_action_iface_init (AtkActionIface *iface)
 376 {
 377   /*
 378    * We do nothing here
 379    *
 380    * When we come to derive a class from AtkHyperlink we will provide an
 381    * implementation of the AtkAction interface.
 382    */
 383 }