lolengine
/
binaries
1
0
Vork 0
Code Kwesties 0 Pull-aanvragen 0 Publicaties 0 Wiki Activiteit
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
2 Commits
2 Branches
7.3 MiB
 
 
 
 
 
 
Branch: master
Branches Labels
${ item.name }
Maak branch ${ searchTerm }
van 'master'
${ noResults }
binaries/gtk-2.22.1/include/gtk-2.0/gtk/gtktextiter.h

308 regels
13 KiB
Ruw Permalink Blame Geschiedenis 

  1. /* GTK - The GIMP Toolkit

  2.  * gtktextiter.h Copyright (C) 2000 Red Hat, 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. /*

  21.  * Modified by the GTK+ Team and others 1997-2000.  See the AUTHORS

  22.  * file for a list of people on the GTK+ Team.  See the ChangeLog

  23.  * files for a list of changes.  These files are distributed with

  24.  * GTK+ at ftp://ftp.gtk.org/pub/gtk/.

  25.  */

  26. 

  27. #if defined(GTK_DISABLE_SINGLE_INCLUDES) && !defined (__GTK_H_INSIDE__) && !defined (GTK_COMPILATION)

  28. #error "Only <gtk/gtk.h> can be included directly."

  29. #endif

  30. 

  31. #ifndef __GTK_TEXT_ITER_H__

  32. #define __GTK_TEXT_ITER_H__

  33. 

  34. #include <gtk/gtktexttag.h>

  35. #include <gtk/gtktextchild.h>

  36. 

  37. G_BEGIN_DECLS

  38. 

  39. typedef enum {

  40.   GTK_TEXT_SEARCH_VISIBLE_ONLY = 1 << 0,

  41.   GTK_TEXT_SEARCH_TEXT_ONLY    = 1 << 1

  42.   /* Possible future plans: SEARCH_CASE_INSENSITIVE, SEARCH_REGEXP */

  43. } GtkTextSearchFlags;

  44. 

  45. /*

  46.  * Iter: represents a location in the text. Becomes invalid if the

  47.  * characters/pixmaps/widgets (indexable objects) in the text buffer

  48.  * are changed.

  49.  */

  50. 

  51. typedef struct _GtkTextBuffer GtkTextBuffer;

  52. 

  53. #define GTK_TYPE_TEXT_ITER     (gtk_text_iter_get_type ())

  54. 

  55. struct _GtkTextIter {

  56.   /* GtkTextIter is an opaque datatype; ignore all these fields.

  57.    * Initialize the iter with gtk_text_buffer_get_iter_*

  58.    * functions

  59.    */

  60.   /*< private >*/

  61.   gpointer dummy1;

  62.   gpointer dummy2;

  63.   gint dummy3;

  64.   gint dummy4;

  65.   gint dummy5;

  66.   gint dummy6;

  67.   gint dummy7;

  68.   gint dummy8;

  69.   gpointer dummy9;

  70.   gpointer dummy10;

  71.   gint dummy11;

  72.   gint dummy12;

  73.   /* padding */

  74.   gint dummy13;

  75.   gpointer dummy14;

  76. };

  77. 

  78. 

  79. /* This is primarily intended for language bindings that want to avoid

  80.    a "buffer" argument to text insertions, deletions, etc. */

  81. GtkTextBuffer *gtk_text_iter_get_buffer (const GtkTextIter *iter);

  82. 

  83. /*

  84.  * Life cycle

  85.  */

  86. 

  87. GtkTextIter *gtk_text_iter_copy     (const GtkTextIter *iter);

  88. void         gtk_text_iter_free     (GtkTextIter       *iter);

  89. 

  90. GType        gtk_text_iter_get_type (void) G_GNUC_CONST;

  91. 

  92. /*

  93.  * Convert to different kinds of index

  94.  */

  95. 

  96. gint gtk_text_iter_get_offset      (const GtkTextIter *iter);

  97. gint gtk_text_iter_get_line        (const GtkTextIter *iter);

  98. gint gtk_text_iter_get_line_offset (const GtkTextIter *iter);

  99. gint gtk_text_iter_get_line_index  (const GtkTextIter *iter);

  100. 

  101. gint gtk_text_iter_get_visible_line_offset (const GtkTextIter *iter);

  102. gint gtk_text_iter_get_visible_line_index (const GtkTextIter *iter);

  103. 

  104. 

  105. /*

  106.  * "Dereference" operators

  107.  */

  108. gunichar gtk_text_iter_get_char          (const GtkTextIter  *iter);

  109. 

  110. /* includes the 0xFFFC char for pixmaps/widgets, so char offsets

  111.  * into the returned string map properly into buffer char offsets

  112.  */

  113. gchar   *gtk_text_iter_get_slice         (const GtkTextIter  *start,

  114.                                           const GtkTextIter  *end);

  115. 

  116. /* includes only text, no 0xFFFC */

  117. gchar   *gtk_text_iter_get_text          (const GtkTextIter  *start,

  118.                                           const GtkTextIter  *end);

  119. /* exclude invisible chars */

  120. gchar   *gtk_text_iter_get_visible_slice (const GtkTextIter  *start,

  121.                                           const GtkTextIter  *end);

  122. gchar   *gtk_text_iter_get_visible_text  (const GtkTextIter  *start,

  123.                                           const GtkTextIter  *end);

  124. 

  125. GdkPixbuf* gtk_text_iter_get_pixbuf (const GtkTextIter *iter);

  126. GSList  *  gtk_text_iter_get_marks  (const GtkTextIter *iter);

  127. 

  128. GtkTextChildAnchor* gtk_text_iter_get_child_anchor (const GtkTextIter *iter);

  129. 

  130. /* Return list of tags toggled at this point (toggled_on determines

  131.  * whether the list is of on-toggles or off-toggles)

  132.  */

  133. GSList  *gtk_text_iter_get_toggled_tags  (const GtkTextIter  *iter,

  134.                                           gboolean            toggled_on);

  135. 

  136. gboolean gtk_text_iter_begins_tag        (const GtkTextIter  *iter,

  137.                                           GtkTextTag         *tag);

  138. 

  139. gboolean gtk_text_iter_ends_tag          (const GtkTextIter  *iter,

  140.                                           GtkTextTag         *tag);

  141. 

  142. gboolean gtk_text_iter_toggles_tag       (const GtkTextIter  *iter,

  143.                                           GtkTextTag         *tag);

  144. 

  145. gboolean gtk_text_iter_has_tag           (const GtkTextIter   *iter,

  146.                                           GtkTextTag          *tag);

  147. GSList  *gtk_text_iter_get_tags          (const GtkTextIter   *iter);

  148. 

  149. gboolean gtk_text_iter_editable          (const GtkTextIter   *iter,

  150.                                           gboolean             default_setting);

  151. gboolean gtk_text_iter_can_insert        (const GtkTextIter   *iter,

  152.                                           gboolean             default_editability);

  153. 

  154. gboolean gtk_text_iter_starts_word        (const GtkTextIter   *iter);

  155. gboolean gtk_text_iter_ends_word          (const GtkTextIter   *iter);

  156. gboolean gtk_text_iter_inside_word        (const GtkTextIter   *iter);

  157. gboolean gtk_text_iter_starts_sentence    (const GtkTextIter   *iter);

  158. gboolean gtk_text_iter_ends_sentence      (const GtkTextIter   *iter);

  159. gboolean gtk_text_iter_inside_sentence    (const GtkTextIter   *iter);

  160. gboolean gtk_text_iter_starts_line        (const GtkTextIter   *iter);

  161. gboolean gtk_text_iter_ends_line          (const GtkTextIter   *iter);

  162. gboolean gtk_text_iter_is_cursor_position (const GtkTextIter   *iter);

  163. 

  164. gint     gtk_text_iter_get_chars_in_line (const GtkTextIter   *iter);

  165. gint     gtk_text_iter_get_bytes_in_line (const GtkTextIter   *iter);

  166. 

  167. gboolean       gtk_text_iter_get_attributes (const GtkTextIter *iter,

  168. 					     GtkTextAttributes *values);

  169. PangoLanguage* gtk_text_iter_get_language   (const GtkTextIter *iter);

  170. gboolean       gtk_text_iter_is_end         (const GtkTextIter *iter);

  171. gboolean       gtk_text_iter_is_start       (const GtkTextIter *iter);

  172. 

  173. /*

  174.  * Moving around the buffer

  175.  */

  176. 

  177. gboolean gtk_text_iter_forward_char         (GtkTextIter *iter);

  178. gboolean gtk_text_iter_backward_char        (GtkTextIter *iter);

  179. gboolean gtk_text_iter_forward_chars        (GtkTextIter *iter,

  180.                                              gint         count);

  181. gboolean gtk_text_iter_backward_chars       (GtkTextIter *iter,

  182.                                              gint         count);

  183. gboolean gtk_text_iter_forward_line         (GtkTextIter *iter);

  184. gboolean gtk_text_iter_backward_line        (GtkTextIter *iter);

  185. gboolean gtk_text_iter_forward_lines        (GtkTextIter *iter,

  186.                                              gint         count);

  187. gboolean gtk_text_iter_backward_lines       (GtkTextIter *iter,

  188.                                              gint         count);

  189. gboolean gtk_text_iter_forward_word_end     (GtkTextIter *iter);

  190. gboolean gtk_text_iter_backward_word_start  (GtkTextIter *iter);

  191. gboolean gtk_text_iter_forward_word_ends    (GtkTextIter *iter,

  192.                                              gint         count);

  193. gboolean gtk_text_iter_backward_word_starts (GtkTextIter *iter,

  194.                                              gint         count);

  195.                                              

  196. gboolean gtk_text_iter_forward_visible_line   (GtkTextIter *iter);

  197. gboolean gtk_text_iter_backward_visible_line  (GtkTextIter *iter);

  198. gboolean gtk_text_iter_forward_visible_lines  (GtkTextIter *iter,

  199.                                                gint         count);

  200. gboolean gtk_text_iter_backward_visible_lines (GtkTextIter *iter,

  201.                                                gint         count);

  202. 

  203. gboolean gtk_text_iter_forward_visible_word_end     (GtkTextIter *iter);

  204. gboolean gtk_text_iter_backward_visible_word_start  (GtkTextIter *iter);

  205. gboolean gtk_text_iter_forward_visible_word_ends    (GtkTextIter *iter,

  206.                                              gint         count);

  207. gboolean gtk_text_iter_backward_visible_word_starts (GtkTextIter *iter,

  208.                                              gint         count);

  209. 

  210. gboolean gtk_text_iter_forward_sentence_end     (GtkTextIter *iter);

  211. gboolean gtk_text_iter_backward_sentence_start  (GtkTextIter *iter);

  212. gboolean gtk_text_iter_forward_sentence_ends    (GtkTextIter *iter,

  213.                                                  gint         count);

  214. gboolean gtk_text_iter_backward_sentence_starts (GtkTextIter *iter,

  215.                                                  gint         count);

  216. /* cursor positions are almost equivalent to chars, but not quite;

  217.  * in some languages, you can't put the cursor between certain

  218.  * chars. Also, you can't put the cursor between \r\n at the end

  219.  * of a line.

  220.  */

  221. gboolean gtk_text_iter_forward_cursor_position   (GtkTextIter *iter);

  222. gboolean gtk_text_iter_backward_cursor_position  (GtkTextIter *iter);

  223. gboolean gtk_text_iter_forward_cursor_positions  (GtkTextIter *iter,

  224.                                                   gint         count);

  225. gboolean gtk_text_iter_backward_cursor_positions (GtkTextIter *iter,

  226.                                                   gint         count);

  227. 

  228. gboolean gtk_text_iter_forward_visible_cursor_position   (GtkTextIter *iter);

  229. gboolean gtk_text_iter_backward_visible_cursor_position  (GtkTextIter *iter);

  230. gboolean gtk_text_iter_forward_visible_cursor_positions  (GtkTextIter *iter,

  231.                                                           gint         count);

  232. gboolean gtk_text_iter_backward_visible_cursor_positions (GtkTextIter *iter,

  233.                                                           gint         count);

  234. 

  235. 

  236. void     gtk_text_iter_set_offset         (GtkTextIter *iter,

  237.                                            gint         char_offset);

  238. void     gtk_text_iter_set_line           (GtkTextIter *iter,

  239.                                            gint         line_number);

  240. void     gtk_text_iter_set_line_offset    (GtkTextIter *iter,

  241.                                            gint         char_on_line);

  242. void     gtk_text_iter_set_line_index     (GtkTextIter *iter,

  243.                                            gint         byte_on_line);

  244. void     gtk_text_iter_forward_to_end     (GtkTextIter *iter);

  245. gboolean gtk_text_iter_forward_to_line_end (GtkTextIter *iter);

  246. 

  247. void     gtk_text_iter_set_visible_line_offset (GtkTextIter *iter,

  248.                                                 gint         char_on_line);

  249. void     gtk_text_iter_set_visible_line_index  (GtkTextIter *iter,

  250.                                                 gint         byte_on_line);

  251. 

  252. /* returns TRUE if a toggle was found; NULL for the tag pointer

  253.  * means "any tag toggle", otherwise the next toggle of the

  254.  * specified tag is located.

  255.  */

  256. gboolean gtk_text_iter_forward_to_tag_toggle (GtkTextIter *iter,

  257.                                               GtkTextTag  *tag);

  258. 

  259. gboolean gtk_text_iter_backward_to_tag_toggle (GtkTextIter *iter,

  260.                                                GtkTextTag  *tag);

  261. 

  262. typedef gboolean (* GtkTextCharPredicate) (gunichar ch, gpointer user_data);

  263. 

  264. gboolean gtk_text_iter_forward_find_char  (GtkTextIter          *iter,

  265.                                            GtkTextCharPredicate  pred,

  266.                                            gpointer              user_data,

  267.                                            const GtkTextIter    *limit);

  268. gboolean gtk_text_iter_backward_find_char (GtkTextIter          *iter,

  269.                                            GtkTextCharPredicate  pred,

  270.                                            gpointer              user_data,

  271.                                            const GtkTextIter    *limit);

  272. 

  273. gboolean gtk_text_iter_forward_search  (const GtkTextIter *iter,

  274.                                         const gchar       *str,

  275.                                         GtkTextSearchFlags flags,

  276.                                         GtkTextIter       *match_start,

  277.                                         GtkTextIter       *match_end,

  278.                                         const GtkTextIter *limit);

  279. 

  280. gboolean gtk_text_iter_backward_search (const GtkTextIter *iter,

  281.                                         const gchar       *str,

  282.                                         GtkTextSearchFlags flags,

  283.                                         GtkTextIter       *match_start,

  284.                                         GtkTextIter       *match_end,

  285.                                         const GtkTextIter *limit);

  286. 

  287. 

  288. /*

  289.  * Comparisons

  290.  */

  291. gboolean gtk_text_iter_equal           (const GtkTextIter *lhs,

  292.                                         const GtkTextIter *rhs);

  293. gint     gtk_text_iter_compare         (const GtkTextIter *lhs,

  294.                                         const GtkTextIter *rhs);

  295. gboolean gtk_text_iter_in_range        (const GtkTextIter *iter,

  296.                                         const GtkTextIter *start,

  297.                                         const GtkTextIter *end);

  298. 

  299. /* Put these two in ascending order */

  300. void     gtk_text_iter_order           (GtkTextIter *first,

  301.                                         GtkTextIter *second);

  302. 

  303. G_END_DECLS

  304. 

  305. #endif

  306.