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.TextTag; 26 27 private import gdk.Event; 28 private import glib.ConstructionException; 29 private import glib.Str; 30 private import gobject.ObjectG; 31 private import gobject.Signals; 32 private import gtk.TextIter; 33 public import gtkc.gdktypes; 34 private import gtkc.gtk; 35 public import gtkc.gtktypes; 36 37 38 /** 39 * You may wish to begin by reading the 40 * [text widget conceptual overview][TextWidget] 41 * which gives an overview of all the objects and 42 * data types related to the text widget and how they work together. 43 * 44 * Tags should be in the #GtkTextTagTable for a given #GtkTextBuffer 45 * before using them with that buffer. 46 * 47 * gtk_text_buffer_create_tag() is the best way to create tags. 48 * See “gtk3-demo” for numerous examples. 49 * 50 * For each property of #GtkTextTag, there is a “set” property, e.g. 51 * “font-set” corresponds to “font”. These “set” properties reflect 52 * whether a property has been set or not. 53 * They are maintained by GTK+ and you should not set them independently. 54 */ 55 public class TextTag : ObjectG 56 { 57 /** the main Gtk struct */ 58 protected GtkTextTag* gtkTextTag; 59 60 /** Get the main Gtk struct */ 61 public GtkTextTag* getTextTagStruct() 62 { 63 return gtkTextTag; 64 } 65 66 /** the main Gtk struct as a void* */ 67 protected override void* getStruct() 68 { 69 return cast(void*)gtkTextTag; 70 } 71 72 protected override void setStruct(GObject* obj) 73 { 74 gtkTextTag = cast(GtkTextTag*)obj; 75 super.setStruct(obj); 76 } 77 78 /** 79 * Sets our main struct and passes it to the parent class. 80 */ 81 public this (GtkTextTag* gtkTextTag, bool ownedRef = false) 82 { 83 this.gtkTextTag = gtkTextTag; 84 super(cast(GObject*)gtkTextTag, ownedRef); 85 } 86 87 88 /** */ 89 public static GType getType() 90 { 91 return gtk_text_tag_get_type(); 92 } 93 94 /** 95 * Creates a #GtkTextTag. Configure the tag using object arguments, 96 * i.e. using g_object_set(). 97 * 98 * Params: 99 * name = tag name, or %NULL 100 * 101 * Return: a new #GtkTextTag 102 * 103 * Throws: ConstructionException GTK+ fails to create the object. 104 */ 105 public this(string name) 106 { 107 auto p = gtk_text_tag_new(Str.toStringz(name)); 108 109 if(p is null) 110 { 111 throw new ConstructionException("null returned by new"); 112 } 113 114 this(cast(GtkTextTag*) p, true); 115 } 116 117 /** 118 * Emits the “event” signal on the #GtkTextTag. 119 * 120 * Params: 121 * eventObject = object that received the event, such as a widget 122 * event = the event 123 * iter = location where the event was received 124 * 125 * Return: result of signal emission (whether the event was handled) 126 */ 127 public bool event(ObjectG eventObject, Event event, TextIter iter) 128 { 129 return gtk_text_tag_event(gtkTextTag, (eventObject is null) ? null : eventObject.getObjectGStruct(), (event is null) ? null : event.getEventStruct(), (iter is null) ? null : iter.getTextIterStruct()) != 0; 130 } 131 132 /** 133 * Get the tag priority. 134 * 135 * Return: The tag’s priority. 136 */ 137 public int getPriority() 138 { 139 return gtk_text_tag_get_priority(gtkTextTag); 140 } 141 142 /** 143 * Sets the priority of a #GtkTextTag. Valid priorities 144 * start at 0 and go to one less than gtk_text_tag_table_get_size(). 145 * Each tag in a table has a unique priority; setting the priority 146 * of one tag shifts the priorities of all the other tags in the 147 * table to maintain a unique priority for each tag. Higher priority 148 * tags “win” if two tags both set the same text attribute. When adding 149 * a tag to a tag table, it will be assigned the highest priority in 150 * the table by default; so normally the precedence of a set of tags 151 * is the order in which they were added to the table, or created with 152 * gtk_text_buffer_create_tag(), which adds the tag to the buffer’s table 153 * automatically. 154 * 155 * Params: 156 * priority = the new priority 157 */ 158 public void setPriority(int priority) 159 { 160 gtk_text_tag_set_priority(gtkTextTag, priority); 161 } 162 163 int[string] connectedSignals; 164 165 bool delegate(ObjectG, Event, TextIter, TextTag)[] onListeners; 166 /** 167 * The ::event signal is emitted when an event occurs on a region of the 168 * buffer marked with this tag. 169 * 170 * Params: 171 * object = the object the event was fired from (typically a #GtkTextView) 172 * event = the event which triggered the signal 173 * iter = a #GtkTextIter pointing at the location the event occured 174 * 175 * Return: %TRUE to stop other handlers from being invoked for the 176 * event. %FALSE to propagate the event further. 177 */ 178 void addOn(bool delegate(ObjectG, Event, TextIter, TextTag) dlg, ConnectFlags connectFlags=cast(ConnectFlags)0) 179 { 180 if ( "event" !in connectedSignals ) 181 { 182 Signals.connectData( 183 this, 184 "event", 185 cast(GCallback)&callBack, 186 cast(void*)this, 187 null, 188 connectFlags); 189 connectedSignals["event"] = 1; 190 } 191 onListeners ~= dlg; 192 } 193 extern(C) static int callBack(GtkTextTag* texttagStruct, GObject* object, GdkEvent* event, GtkTextIter* iter, TextTag _texttag) 194 { 195 foreach ( bool delegate(ObjectG, Event, TextIter, TextTag) dlg; _texttag.onListeners ) 196 { 197 if ( dlg(ObjectG.getDObject!(ObjectG)(object), ObjectG.getDObject!(Event)(event), ObjectG.getDObject!(TextIter)(iter), _texttag) ) 198 { 199 return 1; 200 } 201 } 202 203 return 0; 204 } 205 }