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 atk.Util;
26 
27 private import atk.ObjectAtk;
28 private import glib.Str;
29 private import gobject.ObjectG;
30 private import gtkc.atk;
31 public  import gtkc.atktypes;
32 
33 
34 /**
35  * A set of ATK utility functions which are used to support event
36  * registration of various types, and obtaining the 'root' accessible
37  * of a process and information about the current ATK implementation
38  * and toolkit version.
39  */
40 public struct Util
41 {
42 	/**
43 	 */
44 
45 	public static GType getType()
46 	{
47 		return atk_util_get_type();
48 	}
49 
50 	/**
51 	 * Adds the specified function to the list of functions to be called
52 	 * when an object receives focus.
53 	 *
54 	 * Deprecated: Focus tracking has been dropped as a feature
55 	 * to be implemented by ATK itself. If you need focus tracking on your
56 	 * implementation, subscribe to the #AtkObject::state-change "focused" signal.
57 	 *
58 	 * Params:
59 	 *     focusTracker = Function to be added to the list of functions to be called
60 	 *         when an object receives focus.
61 	 *
62 	 * Return: added focus tracker id, or 0 on failure.
63 	 */
64 	public static uint addFocusTracker(AtkEventListener focusTracker)
65 	{
66 		return atk_add_focus_tracker(focusTracker);
67 	}
68 
69 	/**
70 	 * Adds the specified function to the list of functions to be called
71 	 * when an ATK event of type event_type occurs.
72 	 *
73 	 * The format of event_type is the following:
74 	 * "ATK:<atk_type>:<atk_event>:<atk_event_detail>
75 	 *
76 	 * Where "ATK" works as the namespace, <atk_interface> is the name of
77 	 * the ATK type (interface or object), <atk_event> is the name of the
78 	 * signal defined on that interface and <atk_event_detail> is the
79 	 * gsignal detail of that signal. You can find more info about gsignal
80 	 * details here:
81 	 * http://developer.gnome.org/gobject/stable/gobject-Signals.html
82 	 *
83 	 * The first three parameters are mandatory. The last one is optional.
84 	 *
85 	 * For example:
86 	 * ATK:AtkObject:state-change
87 	 * ATK:AtkText:text-selection-changed
88 	 * ATK:AtkText:text-insert:system
89 	 *
90 	 * Toolkit implementor note: ATK provides a default implementation for
91 	 * this virtual method. ATK implementors are discouraged from
92 	 * reimplementing this method.
93 	 *
94 	 * Toolkit implementor note: this method is not intended to be used by
95 	 * ATK implementors but by ATK consumers.
96 	 *
97 	 * ATK consumers note: as this method adds a listener for a given ATK
98 	 * type, that type should be already registered on the GType system
99 	 * before calling this method. A simple way to do that is creating an
100 	 * instance of #AtkNoOpObject. This class implements all ATK
101 	 * interfaces, so creating the instance will register all ATK types as
102 	 * a collateral effect.
103 	 *
104 	 * Params:
105 	 *     listener = the listener to notify
106 	 *     eventType = the type of event for which notification is requested
107 	 *
108 	 * Return: added event listener id, or 0 on failure.
109 	 */
110 	public static uint addGlobalEventListener(GSignalEmissionHook listener, string eventType)
111 	{
112 		return atk_add_global_event_listener(listener, Str.toStringz(eventType));
113 	}
114 
115 	/**
116 	 * Adds the specified function to the list of functions to be called
117 	 * when a key event occurs.  The @data element will be passed to the
118 	 * #AtkKeySnoopFunc (@listener) as the @func_data param, on notification.
119 	 *
120 	 * Params:
121 	 *     listener = the listener to notify
122 	 *     data = a #gpointer that points to a block of data that should be sent to the registered listeners,
123 	 *         along with the event notification, when it occurs.
124 	 *
125 	 * Return: added event listener id, or 0 on failure.
126 	 */
127 	public static uint addKeyEventListener(AtkKeySnoopFunc listener, void* data)
128 	{
129 		return atk_add_key_event_listener(listener, data);
130 	}
131 
132 	/**
133 	 * Specifies the function to be called for focus tracker initialization.
134 	 * This function should be called by an implementation of the
135 	 * ATK interface if any specific work needs to be done to enable
136 	 * focus tracking.
137 	 *
138 	 * Deprecated: Focus tracking has been dropped as a feature
139 	 * to be implemented by ATK itself.
140 	 *
141 	 * Params:
142 	 *     init = Function to be called for focus tracker initialization
143 	 */
144 	public static void focusTrackerInit(AtkEventListenerInit init)
145 	{
146 		atk_focus_tracker_init(init);
147 	}
148 
149 	/**
150 	 * Cause the focus tracker functions which have been specified to be
151 	 * executed for the object.
152 	 *
153 	 * Deprecated: Focus tracking has been dropped as a feature
154 	 * to be implemented by ATK itself. As #AtkObject::focus-event was
155 	 * deprecated in favor of a #AtkObject::state-change signal, in order
156 	 * to notify a focus change on your implementation, you can use
157 	 * atk_object_notify_state_change() instead.
158 	 *
159 	 * Params:
160 	 *     object = an #AtkObject
161 	 */
162 	public static void focusTrackerNotify(ObjectAtk object)
163 	{
164 		atk_focus_tracker_notify((object is null) ? null : object.getObjectAtkStruct());
165 	}
166 
167 	/**
168 	 * Gets the currently focused object.
169 	 *
170 	 * Return: the currently focused object for the current
171 	 *     application
172 	 *
173 	 * Since: 1.6
174 	 */
175 	public static ObjectAtk getFocusObject()
176 	{
177 		auto p = atk_get_focus_object();
178 		
179 		if(p is null)
180 		{
181 			return null;
182 		}
183 		
184 		return ObjectG.getDObject!(ObjectAtk)(cast(AtkObject*) p);
185 	}
186 
187 	/**
188 	 * Gets the root accessible container for the current application.
189 	 *
190 	 * Return: the root accessible container for the current
191 	 *     application
192 	 */
193 	public static ObjectAtk getRoot()
194 	{
195 		auto p = atk_get_root();
196 		
197 		if(p is null)
198 		{
199 			return null;
200 		}
201 		
202 		return ObjectG.getDObject!(ObjectAtk)(cast(AtkObject*) p);
203 	}
204 
205 	/**
206 	 * Gets name string for the GUI toolkit implementing ATK for this application.
207 	 *
208 	 * Return: name string for the GUI toolkit implementing ATK for this application
209 	 */
210 	public static string getToolkitName()
211 	{
212 		return Str.toString(atk_get_toolkit_name());
213 	}
214 
215 	/**
216 	 *
217 	 *
218 	 * Deprecated: Focus tracking has been dropped as a feature
219 	 * to be implemented by ATK itself. If you need focus tracking on your
220 	 * implementation, subscribe to the #AtkObject::state-change "focused" signal.
221 	 *
222 	 * Removes the specified focus tracker from the list of functions
223 	 * to be called when any object receives focus.
224 	 *
225 	 * Params:
226 	 *     trackerId = the id of the focus tracker to remove
227 	 */
228 	public static void removeFocusTracker(uint trackerId)
229 	{
230 		atk_remove_focus_tracker(trackerId);
231 	}
232 
233 	/**
234 	 * @listener_id is the value returned by #atk_add_global_event_listener
235 	 * when you registered that event listener.
236 	 *
237 	 * Toolkit implementor note: ATK provides a default implementation for
238 	 * this virtual method. ATK implementors are discouraged from
239 	 * reimplementing this method.
240 	 *
241 	 * Toolkit implementor note: this method is not intended to be used by
242 	 * ATK implementors but by ATK consumers.
243 	 *
244 	 * Removes the specified event listener
245 	 *
246 	 * Params:
247 	 *     listenerId = the id of the event listener to remove
248 	 */
249 	public static void removeGlobalEventListener(uint listenerId)
250 	{
251 		atk_remove_global_event_listener(listenerId);
252 	}
253 
254 	/**
255 	 * @listener_id is the value returned by #atk_add_key_event_listener
256 	 * when you registered that event listener.
257 	 *
258 	 * Removes the specified event listener.
259 	 *
260 	 * Params:
261 	 *     listenerId = the id of the event listener to remove
262 	 */
263 	public static void removeKeyEventListener(uint listenerId)
264 	{
265 		atk_remove_key_event_listener(listenerId);
266 	}
267 }