atk/atkhyperlink.c

   1 /* ATK -  Accessibility Toolkit
   2  * Copyright 2001 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
  22
  23 static void atk_hyperlink_class_init (AtkHyperlinkClass *klass);
  24 static void atk_hyperlink_init       (AtkHyperlink      *link,
  25                                       AtkHyperlinkClass *klass);
  26
  27 static void atk_hyperlink_action_iface_init (AtkActionIface *iface);
  28
  29 static gpointer  parent_class = NULL;
  30
  31 GType
  32 atk_hyperlink_get_type (void)
  33 {
  34   static GType type = 0;
  35
  36   if (!type)
  37     {
  38       static const GTypeInfo typeInfo =
  39       {
  40         sizeof (AtkHyperlinkClass),
  41         (GBaseInitFunc) NULL,
  42         (GBaseFinalizeFunc) NULL,
  43         (GClassInitFunc) atk_hyperlink_class_init,
  44         (GClassFinalizeFunc) NULL,
  45         NULL,
  46         sizeof (AtkHyperlink),
  47         0,
  48         (GInstanceInitFunc) atk_hyperlink_init,
  49       } ;
  50
  51       static const GInterfaceInfo action_info =
  52       {
  53         (GInterfaceInitFunc) atk_hyperlink_action_iface_init,
  54         (GInterfaceFinalizeFunc) NULL,
  55         NULL
  56       };
  57
  58       type = g_type_register_static (G_TYPE_OBJECT, "AtkHyperlink", &typeInfo, 0) ;
  59       g_type_add_interface_static (type, ATK_TYPE_ACTION, &action_info);
  60     }
  61   return type;
  62 }
  63
  64 static void
  65 atk_hyperlink_class_init (AtkHyperlinkClass *klass)
  66 {
  67   parent_class = g_type_class_peek_parent (klass);
  68
  69 }
  70
  71 static void
  72 atk_hyperlink_init  (AtkHyperlink        *link,
  73                      AtkHyperlinkClass   *klass)
  74 {
  75 }
  76
  77 /**
  78  * atk_hyperlink_get_uri:
  79  * @link_: an #AtkHyperlink
  80  * @i: a (zero-index) integer specifying the desired anchor
  81  *
  82  * Get a the URI associated with the anchor specified
  83  * by @i of @link_.
  84  *
  85  * Multiple anchors are primarily used by client-side image maps.
  86  *
  87  * Returns: a string specifying the URI
  88  **/
  89 gchar*
  90 atk_hyperlink_get_uri (AtkHyperlink *link,
  91                        gint         i)
  92 {
  93   AtkHyperlinkClass *klass;
  94
  95   g_return_val_if_fail (ATK_IS_HYPERLINK (link), NULL);
  96
  97   klass = ATK_HYPERLINK_GET_CLASS (link);
  98   if (klass->get_uri)
  99     return (klass->get_uri) (link, i);
 100   else
 101     return NULL;
 102 }
 103
 104 /**
 105  * atk_hyperlink_get_object:
 106  * @link_: an #AtkHyperlink
 107  * @i: a (zero-index) integer specifying the desired anchor
 108  *
 109  * Returns the item associated with this hyperlinks nth anchor.
 110  * For instance, the returned #AtkObject will implement #AtkText
 111  * if @link_ is a text hyperlink, #AtkImage if @link_ is an image
 112  * hyperlink etc.
 113  *
 114  * Multiple anchors are primarily used by client-side image maps.
 115  *
 116  * Returns: an #AtkObject associated with this hyperlinks i-th anchor
 117  **/
 118 AtkObject*
 119 atk_hyperlink_get_object (AtkHyperlink *link,
 120                           gint         i)
 121 {
 122   AtkHyperlinkClass *klass;
 123
 124   g_return_val_if_fail (ATK_IS_HYPERLINK (link), NULL);
 125
 126   klass = ATK_HYPERLINK_GET_CLASS (link);
 127   if (klass->get_object)
 128     return (klass->get_object) (link, i);
 129   else
 130     return NULL;
 131 }
 132
 133 /**
 134  * atk_hyperlink_get_end_index:
 135  * @link_: an #AtkHyperlink
 136  *
 137  * Gets the index with the hypertext document at which this link ends.
 138  *
 139  * Returns: the index with the hypertext document at which this link ends
 140  **/
 141 gint
 142 atk_hyperlink_get_end_index (AtkHyperlink *link)
 143 {
 144   AtkHyperlinkClass *klass;
 145
 146   g_return_val_if_fail (ATK_IS_HYPERLINK (link), 0);
 147
 148   klass = ATK_HYPERLINK_GET_CLASS (link);
 149   if (klass->get_end_index)
 150     return (klass->get_end_index) (link);
 151   else
 152     return 0;
 153 }
 154
 155 /**
 156  * atk_hyperlink_get_start_index:
 157  * @link_: an #AtkHyperlink
 158  *
 159  * Gets the index with the hypertext document at which this link begins.
 160  *
 161  * Returns: the index with the hypertext document at which this link begins
 162  **/
 163 gint
 164 atk_hyperlink_get_start_index (AtkHyperlink *link)
 165 {
 166   AtkHyperlinkClass *klass;
 167
 168   g_return_val_if_fail (ATK_IS_HYPERLINK (link), 0);
 169
 170   klass = ATK_HYPERLINK_GET_CLASS (link);
 171   if (klass->get_start_index)
 172     return (klass->get_start_index) (link);
 173   else
 174     return 0;
 175 }
 176
 177 /**
 178  * atk_hyperlink_is_valid:
 179  * @link_: an #AtkHyperlink
 180  *
 181  * Since the document that a link is associated with may have changed
 182  * this method returns %TRUE if the link is still valid (with
 183  * respect to the document it references) and %FALSE otherwise.
 184  *
 185  * Returns: whether or not this link is still valid
 186  **/
 187 gboolean
 188 atk_hyperlink_is_valid (AtkHyperlink *link)
 189 {
 190   AtkHyperlinkClass *klass;
 191
 192   g_return_val_if_fail (ATK_IS_HYPERLINK (link), FALSE);
 193
 194   klass = ATK_HYPERLINK_GET_CLASS (link);
 195   if (klass->is_valid)
 196     return (klass->is_valid) (link);
 197   else
 198     return FALSE;
 199 }
 200
 201 /**
 202  * atk_hyperlink_is_inline:
 203  * @link_: an #AtkHyperlink
 204  *
 205  * Indicates whether the link currently displays some or all of its
 206  *           content inline.  Ordinary HTML links will usually return
 207  *           %FALSE, but an inline &lt;src&gt; HTML element will return
 208  *           %TRUE.
 209 a *
 210  * Returns: whether or not this link displays its content inline.
 211  *
 212  **/
 213 gboolean
 214 atk_hyperlink_is_inline (AtkHyperlink *link)
 215 {
 216   AtkHyperlinkClass *klass;
 217
 218   g_return_val_if_fail (ATK_IS_HYPERLINK (link), FALSE);
 219
 220   klass = ATK_HYPERLINK_GET_CLASS (link);
 221   if (klass->link_state)
 222     return (klass->link_state (link) & ATK_HYPERLINK_IS_INLINE);
 223   else
 224     return FALSE;
 225 }
 226
 227 /**
 228  * atk_hyperlink_get_n_anchors:
 229  * @link_: an #AtkHyperlink
 230  *
 231  * Gets the number of anchors associated with this hyperlink.
 232  *
 233  * Returns: the number of anchors associated with this hyperlink
 234  **/
 235 gint
 236 atk_hyperlink_get_n_anchors (AtkHyperlink *link)
 237 {
 238   AtkHyperlinkClass *klass;
 239
 240   g_return_val_if_fail (ATK_IS_HYPERLINK (link), 0);
 241
 242   klass = ATK_HYPERLINK_GET_CLASS (link);
 243   if (klass->get_n_anchors)
 244     return (klass->get_n_anchors) (link);
 245   else
 246     return 0;
 247 }
 248
 249 static void atk_hyperlink_action_iface_init (AtkActionIface *iface)
 250 {
 251   /*
 252    * We do nothing here
 253    *
 254    * When we come to derive a class from AtkHyperlink we will provide an
 255    * implementation of the AtkAction interface.
 256    *
 257    * This depends on being able to override an interface in a derived class
 258    * which currently (March 2001) is not implemented but will be in GTK+ 2.0.
 259    */
 260 }