1 /* 2 * This file is part of gtkD. 3 * 4 * gtkD is free software; you can redistribute it and/or modify 5 * it under the terms of the GNU Lesser General Public License 6 * as published by the Free Software Foundation; either version 3 7 * of the License, or (at your option) any later version, with 8 * some exceptions, please read the COPYING file. 9 * 10 * gtkD is distributed in the hope that it will be useful, 11 * but WITHOUT ANY WARRANTY; without even the implied warranty of 12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 13 * GNU Lesser General Public License for more details. 14 * 15 * You should have received a copy of the GNU Lesser General Public License 16 * along with gtkD; if not, write to the Free Software 17 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110, USA 18 */ 19 20 // generated automatically - do not change 21 // find conversion definition on APILookup.txt 22 // implement new conversion functionalities on the wrap.utils pakage 23 24 25 module gtk.EditableIF; 26 27 private import glib.Str; 28 private import gobject.Signals; 29 public import gtkc.gdktypes; 30 private import gtkc.gtk; 31 public import gtkc.gtktypes; 32 private import std.algorithm; 33 34 35 /** 36 * The #GtkEditable interface is an interface which should be implemented by 37 * text editing widgets, such as #GtkEntry and #GtkSpinButton. It contains functions 38 * for generically manipulating an editable widget, a large number of action 39 * signals used for key bindings, and several signals that an application can 40 * connect to to modify the behavior of a widget. 41 * 42 * As an example of the latter usage, by connecting 43 * the following handler to #GtkEditable::insert-text, an application 44 * can convert all entry into a widget into uppercase. 45 * 46 * ## Forcing entry to uppercase. 47 * 48 * |[<!-- language="C" --> 49 * #include <ctype.h>; 50 * 51 * void 52 * insert_text_handler (GtkEditable *editable, 53 * const gchar *text, 54 * gint length, 55 * gint *position, 56 * gpointer data) 57 * { 58 * gchar *result = g_utf8_strup (text, length); 59 * 60 * g_signal_handlers_block_by_func (editable, 61 * (gpointer) insert_text_handler, data); 62 * gtk_editable_insert_text (editable, result, length, position); 63 * g_signal_handlers_unblock_by_func (editable, 64 * (gpointer) insert_text_handler, data); 65 * 66 * g_signal_stop_emission_by_name (editable, "insert_text"); 67 * 68 * g_free (result); 69 * } 70 * ]| 71 */ 72 public interface EditableIF{ 73 /** Get the main Gtk struct */ 74 public GtkEditable* getEditableStruct(); 75 76 /** the main Gtk struct as a void* */ 77 protected void* getStruct(); 78 79 80 /** 81 * Copies the contents of the currently selected content in the editable and 82 * puts it on the clipboard. 83 */ 84 public void copyClipboard(); 85 86 /** 87 * Removes the contents of the currently selected content in the editable and 88 * puts it on the clipboard. 89 */ 90 public void cutClipboard(); 91 92 /** 93 * Deletes the currently selected text of the editable. 94 * This call doesn’t do anything if there is no selected text. 95 */ 96 public void deleteSelection(); 97 98 /** 99 * Deletes a sequence of characters. The characters that are deleted are 100 * those characters at positions from @start_pos up to, but not including 101 * @end_pos. If @end_pos is negative, then the characters deleted 102 * are those from @start_pos to the end of the text. 103 * 104 * Note that the positions are specified in characters, not bytes. 105 * 106 * Params: 107 * startPos = start position 108 * endPos = end position 109 */ 110 public void deleteText(int startPos, int endPos); 111 112 /** 113 * Retrieves a sequence of characters. The characters that are retrieved 114 * are those characters at positions from @start_pos up to, but not 115 * including @end_pos. If @end_pos is negative, then the characters 116 * retrieved are those characters from @start_pos to the end of the text. 117 * 118 * Note that positions are specified in characters, not bytes. 119 * 120 * Params: 121 * startPos = start of text 122 * endPos = end of text 123 * 124 * Return: a pointer to the contents of the widget as a 125 * string. This string is allocated by the #GtkEditable 126 * implementation and should be freed by the caller. 127 */ 128 public string getChars(int startPos, int endPos); 129 130 /** 131 * Retrieves whether @editable is editable. See 132 * gtk_editable_set_editable(). 133 * 134 * Return: %TRUE if @editable is editable. 135 */ 136 public bool getEditable(); 137 138 /** 139 * Retrieves the current position of the cursor relative to the start 140 * of the content of the editable. 141 * 142 * Note that this position is in characters, not in bytes. 143 * 144 * Return: the cursor position 145 */ 146 public int getPosition(); 147 148 /** 149 * Retrieves the selection bound of the editable. start_pos will be filled 150 * with the start of the selection and @end_pos with end. If no text was 151 * selected both will be identical and %FALSE will be returned. 152 * 153 * Note that positions are specified in characters, not bytes. 154 * 155 * Params: 156 * startPos = location to store the starting position, or %NULL 157 * endPos = location to store the end position, or %NULL 158 * 159 * Return: %TRUE if an area is selected, %FALSE otherwise 160 */ 161 public bool getSelectionBounds(out int startPos, out int endPos); 162 163 /** 164 * Inserts @new_text_length bytes of @new_text into the contents of the 165 * widget, at position @position. 166 * 167 * Note that the position is in characters, not in bytes. 168 * The function updates @position to point after the newly inserted text. 169 * 170 * Params: 171 * newText = the text to append 172 * newTextLength = the length of the text in bytes, or -1 173 * position = location of the position text will be inserted at 174 */ 175 public void insertText(string newText, int newTextLength, ref int position); 176 177 /** 178 * Pastes the content of the clipboard to the current position of the 179 * cursor in the editable. 180 */ 181 public void pasteClipboard(); 182 183 /** 184 * Selects a region of text. The characters that are selected are 185 * those characters at positions from @start_pos up to, but not 186 * including @end_pos. If @end_pos is negative, then the 187 * characters selected are those characters from @start_pos to 188 * the end of the text. 189 * 190 * Note that positions are specified in characters, not bytes. 191 * 192 * Params: 193 * startPos = start of region 194 * endPos = end of region 195 */ 196 public void selectRegion(int startPos, int endPos); 197 198 /** 199 * Determines if the user can edit the text in the editable 200 * widget or not. 201 * 202 * Params: 203 * isEditable = %TRUE if the user is allowed to edit the text 204 * in the widget 205 */ 206 public void setEditable(bool isEditable); 207 208 /** 209 * Sets the cursor position in the editable to the given value. 210 * 211 * The cursor is displayed before the character with the given (base 0) 212 * index in the contents of the editable. The value must be less than or 213 * equal to the number of characters in the editable. A value of -1 214 * indicates that the position should be set after the last character 215 * of the editable. Note that @position is in characters, not in bytes. 216 * 217 * Params: 218 * position = the position of the cursor 219 */ 220 public void setPosition(int position); 221 /** 222 * The ::changed signal is emitted at the end of a single 223 * user-visible operation on the contents of the #GtkEditable. 224 * 225 * E.g., a paste operation that replaces the contents of the 226 * selection will cause only one signal emission (even though it 227 * is implemented by first deleting the selection, then inserting 228 * the new content, and may cause multiple ::notify::text signals 229 * to be emitted). 230 */ 231 gulong addOnChanged(void delegate(EditableIF) dlg, ConnectFlags connectFlags=cast(ConnectFlags)0) 232 ; 233 234 /** 235 * This signal is emitted when text is deleted from 236 * the widget by the user. The default handler for 237 * this signal will normally be responsible for deleting 238 * the text, so by connecting to this signal and then 239 * stopping the signal with g_signal_stop_emission(), it 240 * is possible to modify the range of deleted text, or 241 * prevent it from being deleted entirely. The @start_pos 242 * and @end_pos parameters are interpreted as for 243 * gtk_editable_delete_text(). 244 * 245 * Params: 246 * startPos = the starting position 247 * endPos = the end position 248 */ 249 gulong addOnDeleteText(void delegate(int, int, EditableIF) dlg, ConnectFlags connectFlags=cast(ConnectFlags)0) 250 ; 251 252 /** 253 * This signal is emitted when text is inserted into 254 * the widget by the user. The default handler for 255 * this signal will normally be responsible for inserting 256 * the text, so by connecting to this signal and then 257 * stopping the signal with g_signal_stop_emission(), it 258 * is possible to modify the inserted text, or prevent 259 * it from being inserted entirely. 260 * 261 * Params: 262 * newText = the new text to insert 263 * newTextLength = the length of the new text, in bytes, 264 * or -1 if new_text is nul-terminated 265 * position = the position, in characters, 266 * at which to insert the new text. this is an in-out 267 * parameter. After the signal emission is finished, it 268 * should point after the newly inserted text. 269 */ 270 gulong addOnInsertText(void delegate(string, int, void*, EditableIF) dlg, ConnectFlags connectFlags=cast(ConnectFlags)0) 271 ; 272 273 }