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 #GtkTextTagTable::tag-changed signal on the #GtkTextTagTable where
119 	 * the tag is included.
120 	 *
121 	 * The signal is already emitted when setting a #GtkTextTag property. This
122 	 * function is useful for a #GtkTextTag subclass.
123 	 *
124 	 * Params:
125 	 *     sizeChanged = whether the change affects the #GtkTextView layout.
126 	 *
127 	 * Since: 3.20
128 	 */
129 	public void changed(bool sizeChanged)
130 	{
131 		gtk_text_tag_changed(gtkTextTag, sizeChanged);
132 	}
133 
134 	/**
135 	 * Emits the “event” signal on the #GtkTextTag.
136 	 *
137 	 * Params:
138 	 *     eventObject = object that received the event, such as a widget
139 	 *     event = the event
140 	 *     iter = location where the event was received
141 	 *
142 	 * Return: result of signal emission (whether the event was handled)
143 	 */
144 	public bool event(ObjectG eventObject, Event event, TextIter iter)
145 	{
146 		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;
147 	}
148 
149 	/**
150 	 * Get the tag priority.
151 	 *
152 	 * Return: The tag’s priority.
153 	 */
154 	public int getPriority()
155 	{
156 		return gtk_text_tag_get_priority(gtkTextTag);
157 	}
158 
159 	/**
160 	 * Sets the priority of a #GtkTextTag. Valid priorities
161 	 * start at 0 and go to one less than gtk_text_tag_table_get_size().
162 	 * Each tag in a table has a unique priority; setting the priority
163 	 * of one tag shifts the priorities of all the other tags in the
164 	 * table to maintain a unique priority for each tag. Higher priority
165 	 * tags “win” if two tags both set the same text attribute. When adding
166 	 * a tag to a tag table, it will be assigned the highest priority in
167 	 * the table by default; so normally the precedence of a set of tags
168 	 * is the order in which they were added to the table, or created with
169 	 * gtk_text_buffer_create_tag(), which adds the tag to the buffer’s table
170 	 * automatically.
171 	 *
172 	 * Params:
173 	 *     priority = the new priority
174 	 */
175 	public void setPriority(int priority)
176 	{
177 		gtk_text_tag_set_priority(gtkTextTag, priority);
178 	}
179 
180 	int[string] connectedSignals;
181 
182 	bool delegate(ObjectG, Event, TextIter, TextTag)[] onListeners;
183 	/**
184 	 * The ::event signal is emitted when an event occurs on a region of the
185 	 * buffer marked with this tag.
186 	 *
187 	 * Params:
188 	 *     object = the object the event was fired from (typically a #GtkTextView)
189 	 *     event = the event which triggered the signal
190 	 *     iter = a #GtkTextIter pointing at the location the event occurred
191 	 *
192 	 * Return: %TRUE to stop other handlers from being invoked for the
193 	 *     event. %FALSE to propagate the event further.
194 	 */
195 	void addOn(bool delegate(ObjectG, Event, TextIter, TextTag) dlg, ConnectFlags connectFlags=cast(ConnectFlags)0)
196 	{
197 		if ( "event" !in connectedSignals )
198 		{
199 			Signals.connectData(
200 				this,
201 				"event",
202 				cast(GCallback)&callBack,
203 				cast(void*)this,
204 				null,
205 				connectFlags);
206 			connectedSignals["event"] = 1;
207 		}
208 		onListeners ~= dlg;
209 	}
210 	extern(C) static int callBack(GtkTextTag* texttagStruct, GObject* object, GdkEvent* event, GtkTextIter* iter, TextTag _texttag)
211 	{
212 		foreach ( bool delegate(ObjectG, Event, TextIter, TextTag) dlg; _texttag.onListeners )
213 		{
214 			if ( dlg(ObjectG.getDObject!(ObjectG)(object), ObjectG.getDObject!(Event)(event), ObjectG.getDObject!(TextIter)(iter), _texttag) )
215 			{
216 				return 1;
217 			}
218 		}
219 		
220 		return 0;
221 	}
222 }