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.GestureDrag;
26 
27 private import glib.ConstructionException;
28 private import gobject.ObjectG;
29 private import gobject.Signals;
30 private import gtk.Gesture;
31 private import gtk.GestureSingle;
32 private import gtk.Widget;
33 public  import gtkc.gdktypes;
34 private import gtkc.gtk;
35 public  import gtkc.gtktypes;
36 
37 
38 /**
39  * #GtkGestureDrag is a #GtkGesture implementation that recognizes drag
40  * operations. The drag operation itself can be tracked throught the
41  * #GtkGestureDrag::drag-begin, #GtkGestureDrag::drag-update and
42  * #GtkGestureDrag::drag-end signals, or the relevant coordinates be
43  * extracted through gtk_gesture_drag_get_offset() and
44  * gtk_gesture_drag_get_start_point().
45  */
46 public class GestureDrag : GestureSingle
47 {
48 	/** the main Gtk struct */
49 	protected GtkGestureDrag* gtkGestureDrag;
50 
51 	/** Get the main Gtk struct */
52 	public GtkGestureDrag* getGestureDragStruct()
53 	{
54 		return gtkGestureDrag;
55 	}
56 
57 	/** the main Gtk struct as a void* */
58 	protected override void* getStruct()
59 	{
60 		return cast(void*)gtkGestureDrag;
61 	}
62 
63 	protected override void setStruct(GObject* obj)
64 	{
65 		gtkGestureDrag = cast(GtkGestureDrag*)obj;
66 		super.setStruct(obj);
67 	}
68 
69 	/**
70 	 * Sets our main struct and passes it to the parent class.
71 	 */
72 	public this (GtkGestureDrag* gtkGestureDrag, bool ownedRef = false)
73 	{
74 		this.gtkGestureDrag = gtkGestureDrag;
75 		super(cast(GtkGestureSingle*)gtkGestureDrag, ownedRef);
76 	}
77 
78 
79 	/** */
80 	public static GType getType()
81 	{
82 		return gtk_gesture_drag_get_type();
83 	}
84 
85 	/**
86 	 * Returns a newly created #GtkGesture that recognizes drags.
87 	 *
88 	 * Params:
89 	 *     widget = a #GtkWidget
90 	 *
91 	 * Return: a newly created #GtkGestureDrag
92 	 *
93 	 * Since: 3.14
94 	 *
95 	 * Throws: ConstructionException GTK+ fails to create the object.
96 	 */
97 	public this(Widget widget)
98 	{
99 		auto p = gtk_gesture_drag_new((widget is null) ? null : widget.getWidgetStruct());
100 		
101 		if(p is null)
102 		{
103 			throw new ConstructionException("null returned by new");
104 		}
105 		
106 		this(cast(GtkGestureDrag*) p, true);
107 	}
108 
109 	/**
110 	 * If the @gesture is active, this function returns %TRUE and
111 	 * fills in @x and @y with the coordinates of the current point,
112 	 * as an offset to the starting drag point.
113 	 *
114 	 * Params:
115 	 *     x = X offset for the current point
116 	 *     y = Y offset for the current point
117 	 *
118 	 * Return: %TRUE if the gesture is active
119 	 *
120 	 * Since: 3.14
121 	 */
122 	public bool getOffset(out double x, out double y)
123 	{
124 		return gtk_gesture_drag_get_offset(gtkGestureDrag, &x, &y) != 0;
125 	}
126 
127 	/**
128 	 * If the @gesture is active, this function returns %TRUE
129 	 * and fills in @x and @y with the drag start coordinates,
130 	 * in window-relative coordinates.
131 	 *
132 	 * Params:
133 	 *     x = X coordinate for the drag start point
134 	 *     y = Y coordinate for the drag start point
135 	 *
136 	 * Return: %TRUE if the gesture is active
137 	 *
138 	 * Since: 3.14
139 	 */
140 	public bool getStartPoint(out double x, out double y)
141 	{
142 		return gtk_gesture_drag_get_start_point(gtkGestureDrag, &x, &y) != 0;
143 	}
144 
145 	int[string] connectedSignals;
146 
147 	void delegate(double, double, GestureDrag)[] onDragBeginListeners;
148 	/**
149 	 * This signal is emitted whenever dragging starts.
150 	 *
151 	 * Params:
152 	 *     startX = X coordinate, relative to the widget allocation
153 	 *     startY = Y coordinate, relative to the widget allocation
154 	 *
155 	 * Since: 3.14
156 	 */
157 	void addOnDragBegin(void delegate(double, double, GestureDrag) dlg, ConnectFlags connectFlags=cast(ConnectFlags)0)
158 	{
159 		if ( "drag-begin" !in connectedSignals )
160 		{
161 			Signals.connectData(
162 				this,
163 				"drag-begin",
164 				cast(GCallback)&callBackDragBegin,
165 				cast(void*)this,
166 				null,
167 				connectFlags);
168 			connectedSignals["drag-begin"] = 1;
169 		}
170 		onDragBeginListeners ~= dlg;
171 	}
172 	extern(C) static void callBackDragBegin(GtkGestureDrag* gesturedragStruct, double startX, double startY, GestureDrag _gesturedrag)
173 	{
174 		foreach ( void delegate(double, double, GestureDrag) dlg; _gesturedrag.onDragBeginListeners )
175 		{
176 			dlg(startX, startY, _gesturedrag);
177 		}
178 	}
179 
180 	void delegate(double, double, GestureDrag)[] onDragEndListeners;
181 	/**
182 	 * This signal is emitted whenever the dragging is finished.
183 	 *
184 	 * Params:
185 	 *     offsetX = X offset, relative to the start point
186 	 *     offsetY = Y offset, relative to the start point
187 	 *
188 	 * Since: 3.14
189 	 */
190 	void addOnDragEnd(void delegate(double, double, GestureDrag) dlg, ConnectFlags connectFlags=cast(ConnectFlags)0)
191 	{
192 		if ( "drag-end" !in connectedSignals )
193 		{
194 			Signals.connectData(
195 				this,
196 				"drag-end",
197 				cast(GCallback)&callBackDragEnd,
198 				cast(void*)this,
199 				null,
200 				connectFlags);
201 			connectedSignals["drag-end"] = 1;
202 		}
203 		onDragEndListeners ~= dlg;
204 	}
205 	extern(C) static void callBackDragEnd(GtkGestureDrag* gesturedragStruct, double offsetX, double offsetY, GestureDrag _gesturedrag)
206 	{
207 		foreach ( void delegate(double, double, GestureDrag) dlg; _gesturedrag.onDragEndListeners )
208 		{
209 			dlg(offsetX, offsetY, _gesturedrag);
210 		}
211 	}
212 
213 	void delegate(double, double, GestureDrag)[] onDragUpdateListeners;
214 	/**
215 	 * This signal is emitted whenever the dragging point moves.
216 	 *
217 	 * Params:
218 	 *     offsetX = X offset, relative to the start point
219 	 *     offsetY = Y offset, relative to the start point
220 	 *
221 	 * Since: 3.14
222 	 */
223 	void addOnDragUpdate(void delegate(double, double, GestureDrag) dlg, ConnectFlags connectFlags=cast(ConnectFlags)0)
224 	{
225 		if ( "drag-update" !in connectedSignals )
226 		{
227 			Signals.connectData(
228 				this,
229 				"drag-update",
230 				cast(GCallback)&callBackDragUpdate,
231 				cast(void*)this,
232 				null,
233 				connectFlags);
234 			connectedSignals["drag-update"] = 1;
235 		}
236 		onDragUpdateListeners ~= dlg;
237 	}
238 	extern(C) static void callBackDragUpdate(GtkGestureDrag* gesturedragStruct, double offsetX, double offsetY, GestureDrag _gesturedrag)
239 	{
240 		foreach ( void delegate(double, double, GestureDrag) dlg; _gesturedrag.onDragUpdateListeners )
241 		{
242 			dlg(offsetX, offsetY, _gesturedrag);
243 		}
244 	}
245 }