atspi/atspi-editabletext.c

   1 /*
   2  * AT-SPI - Assistive Technology Service Provider Interface
   3  * (Gnome Accessibility Project; http://developer.gnome.org/projects/gap)
   4  *
   5  * Copyright 2001, 2002 Sun Microsystems Inc.,
   6  * Copyright 2001, 2002 Ximian, Inc.
   7  *
   8  * This library is free software; you can redistribute it and/or
   9  * modify it under the terms of the GNU Library General Public
  10  * License as published by the Free Software Foundation; either
  11  * version 2 of the License, or (at your option) any later version.
  12  *
  13  * This library is distributed in the hope that it will be useful,
  14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  16  * Library General Public License for more details.
  17  *
  18  * You should have received a copy of the GNU Library General Public
  19  * License along with this library; if not, write to the
  20  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  21  * Boston, MA 02111-1307, USA.
  22  */
  23
  24 #include "atspi-private.h"
  25
  26 #if 0
  27 /* TODO: implement */
  28 /**
  29  * atspi_editable_text_set_attributes:
  30  * @obj: a pointer to the #AtspiEditableText object to modify.
  31  * @attributes: a string indicating the attributes to apply to the range,
  32  *        delimited by ':'.
  33  * @startOffset: a #gint indicating the start of the desired text range.
  34  * @endOffset: a #gint indicating the first character past the desired range.
  35  *
  36  * Sets the attributes applied to a range of text from an #AtspiEditableText
  37  *          object, and the bounds of the range.
  38  *
  39  * Returns: #TRUE if the operation was successful, otherwise #FALSE.
  40  **/
  41 gboolean
  42 atspi_editable_text_set_attributes (AtspiEditableText *obj,
  43                                     const char *attributes,
  44                                     gint start_pos,
  45                                     gint end_pos,
  46                                     GError **error
  47 {
  48   dbus_int32_t d_start_pos = start_pos, d_end_pos = end_pos;
  49   dbus_bool_t retval = FALSE;
  50
  51   cspi_return_val_if_fail (obj != NULL, FALSE);
  52
  53   _atspi_dbus_call (obj, atspi_interface_editable_text, "SetAttributes", error, "sii=>b", attributes, d_start_pos, d_end_pos, &retval);
  54
  55   return retval;
  56 }
  57 #endif
  58
  59 /**
  60  * atspi_editable_text_set_text_contents:
  61  * @obj: a pointer to the #AtspiEditableText object to modify.
  62  * @new_contents: a character string, encoded in UTF-8, which is to
  63  *      become the new text contents of the #AtspiEditableText object.
  64  *
  65  * Replace the entire text contents of an #AtspiEditableText object.
  66  *
  67  * Returns: #TRUE if the operation was successful, otherwise #FALSE.
  68  **/
  69 gboolean
  70 atspi_editable_text_set_text_contents (AtspiEditableText *obj,
  71                                        const gchar *new_contents,
  72                                        GError **error)
  73 {
  74   dbus_bool_t retval = FALSE;
  75
  76   g_return_val_if_fail (obj != NULL, FALSE);
  77
  78   _atspi_dbus_call (obj, atspi_interface_editable_text, "SetTextContents", error, "s=>b", new_contents, &retval);
  79
  80   return retval;
  81 }
  82
  83 /**
  84  * atspi_editable_text_insert_text:
  85  * @obj: a pointer to the #AtspiEditableText object to modify.
  86  * @position: a #gint indicating the character offset at which to insert
  87  *       the new text.
  88  * @text: a string representing the text to insert, in UTF-8 encoding.
  89  * @length:  the number of characters of text to insert. If the character
  90  * count of text is less than or equal to length, the entire contents
  91  * of text will be inserted.
  92  *
  93  * Inserts text into an #AtspiEditableText object.
  94  * As with all character offsets, the specified @position may not be the
  95  * same as the resulting byte offset, since the text is in a
  96  * variable-width encoding.
  97  *
  98  * Returns: #TRUE if the operation was successful, otherwise #FALSE.
  99  **/
 100 gboolean
 101 atspi_editable_text_insert_text (AtspiEditableText *obj,
 102                                  gint position,
 103                                  const gchar *text,
 104                                  gint length,
 105                                  GError **error)
 106 {
 107   dbus_int32_t d_position = position, d_length = length;
 108   dbus_bool_t retval = FALSE;
 109
 110   g_return_val_if_fail (obj != NULL, FALSE);
 111
 112   _atspi_dbus_call (obj, atspi_interface_editable_text, "InsertText", error, "isi=>b", d_position, text, d_length, &retval);
 113
 114   return retval;
 115 }
 116
 117 /**
 118  * atspi_editable_text_copy_text:
 119  * @obj: a pointer to the #AtspiEditableText object to modify.
 120  * @start_pos: a #gint indicating the starting character offset
 121  *       of the text to copy.
 122  * @end_pos: a #gint indicating the offset of the first character
 123  *       past the end of the text section to be copied.
 124  *
 125  * Copies text from an #AtspiEditableText object into the system clipboard.
 126  *
 127  * see: #atspi_editable_text_paste_text
 128  *
 129  * Returns: #TRUE if the operation was successful, otherwise #FALSE.
 130  **/
 131 gboolean
 132 atspi_editable_text_copy_text (AtspiEditableText *obj,
 133                                gint start_pos,
 134                                gint end_pos,
 135                                GError **error)
 136 {
 137   dbus_int32_t d_start_pos = start_pos, d_end_pos = end_pos;
 138
 139   g_return_val_if_fail (obj != NULL, FALSE);
 140
 141   _atspi_dbus_call (obj, atspi_interface_editable_text, "CopyText", error, "ii", d_start_pos, d_end_pos);
 142
 143   return TRUE;
 144 }
 145
 146 /**
 147  * atspi_editable_text_cut_text:
 148  * @obj: a pointer to the #AtspiEditableText object to modify.
 149  * @start_pos: a #gint indicating the starting character offset
 150  *       of the text to cut.
 151  * @end_pos: a #gint indicating the offset of the first character
 152  *       past the end of the text section to be cut.
 153  *
 154  * Deletes text from an #AtspiEditableText object, copying the
 155  *       excised portion into the system clipboard.
 156  *
 157  * see: #atspi_editable_text_paste_text
 158  *
 159  * Returns: #TRUE if operation was successful, #FALSE otherwise.
 160  **/
 161 gboolean
 162 atspi_editable_text_cut_text (AtspiEditableText *obj,
 163                               gint start_pos,
 164                               gint end_pos,
 165                               GError **error)
 166 {
 167   dbus_int32_t d_start_pos = start_pos, d_end_pos = end_pos;
 168   dbus_bool_t retval = FALSE;
 169
 170   g_return_val_if_fail (obj != NULL, FALSE);
 171
 172   _atspi_dbus_call (obj, atspi_interface_editable_text, "CutText", error, "ii=>b", d_start_pos, d_end_pos, &retval);
 173
 174   return retval;
 175 }
 176
 177 /**
 178  * atspi_editable_text_delete_text:
 179  * @obj: a pointer to the #AtspiEditableText object to modify.
 180  * @start_pos: a #gint indicating the starting character offset
 181  *       of the text to delete.
 182  * @end_pos: a #gint indicating the offset of the first character
 183  *       past the end of the text section to be deleted.
 184  *
 185  * Deletes text from an #AtspiEditableText object, without copying the
 186  *       excised portion into the system clipboard.
 187  *
 188  * see: #atspi_editable_text_cut_text
 189  *
 190  * Returns: #TRUE if the operation was successful, otherwise #FALSE.
 191  **/
 192 gboolean
 193 atspi_editable_text_delete_text (AtspiEditableText *obj,
 194                                  gint start_pos,
 195                                  gint end_pos,
 196                                  GError **error)
 197 {
 198   dbus_int32_t d_start_pos = start_pos, d_end_pos = end_pos;
 199   dbus_bool_t retval = FALSE;
 200
 201   g_return_val_if_fail (obj != NULL, FALSE);
 202
 203   _atspi_dbus_call (obj, atspi_interface_editable_text, "DeleteText", error, "ii=>b", d_start_pos, d_end_pos, &retval);
 204
 205   return retval;
 206 }
 207
 208 /**
 209  * atspi_editable_text_paste_text:
 210  * @obj: a pointer to the #AtspiEditableText object to modify.
 211  * @position: a #gint indicating the character offset at which to insert
 212  *       the new text.
 213  *
 214  * Inserts text from the system clipboard into an #AtspiEditableText object.
 215  * As with all character offsets, the specified @position may not be the
 216  *       same as the resulting byte offset, since the text is in a
 217  *       variable-width encoding.
 218  *
 219  * Returns: #TRUE if the operation was successful, otherwise #FALSE.
 220  **/
 221 gboolean
 222 atspi_editable_text_paste_text (AtspiEditableText *obj,
 223                                 gint position,
 224                                 GError **error)
 225 {
 226   dbus_int32_t d_position = position;
 227   dbus_bool_t retval = FALSE;
 228
 229   g_return_val_if_fail (obj != NULL, FALSE);
 230
 231   _atspi_dbus_call (obj, atspi_interface_editable_text, "PasteText", error, "i=>b", d_position, &retval);
 232
 233   return retval;
 234 }
 235
 236 static void
 237 atspi_editable_text_base_init (AtspiEditableText *klass)
 238 {
 239 }
 240
 241 GType
 242 atspi_editable_text_get_type (void)
 243 {
 244   static GType type = 0;
 245
 246   if (!type) {
 247     static const GTypeInfo tinfo =
 248     {
 249       sizeof (AtspiEditableText),
 250       (GBaseInitFunc) atspi_editable_text_base_init,
 251       (GBaseFinalizeFunc) NULL,
 252     };
 253
 254     type = g_type_register_static (G_TYPE_INTERFACE, "AtspiEditableText", &tinfo, 0);
 255
 256   }
 257   return type;
 258 }