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 gio.ActionT;
26 
27 public  import gio.c.functions;
28 public  import gio.c.types;
29 public  import glib.ErrorG;
30 public  import glib.GException;
31 public  import glib.Str;
32 public  import glib.Variant;
33 public  import glib.VariantType;
34 public  import gtkc.giotypes;
35 
36 
37 /**
38  * #GAction represents a single named action.
39  * 
40  * The main interface to an action is that it can be activated with
41  * g_action_activate().  This results in the 'activate' signal being
42  * emitted.  An activation has a #GVariant parameter (which may be
43  * %NULL).  The correct type for the parameter is determined by a static
44  * parameter type (which is given at construction time).
45  * 
46  * An action may optionally have a state, in which case the state may be
47  * set with g_action_change_state().  This call takes a #GVariant.  The
48  * correct type for the state is determined by a static state type
49  * (which is given at construction time).
50  * 
51  * The state may have a hint associated with it, specifying its valid
52  * range.
53  * 
54  * #GAction is merely the interface to the concept of an action, as
55  * described above.  Various implementations of actions exist, including
56  * #GSimpleAction.
57  * 
58  * In all cases, the implementing class is responsible for storing the
59  * name of the action, the parameter type, the enabled state, the
60  * optional state type and the state and emitting the appropriate
61  * signals when these change.  The implementor is responsible for filtering
62  * calls to g_action_activate() and g_action_change_state() for type
63  * safety and for the state being enabled.
64  * 
65  * Probably the only useful thing to do with a #GAction is to put it
66  * inside of a #GSimpleActionGroup.
67  */
68 public template ActionT(TStruct)
69 {
70 	/** Get the main Gtk struct */
71 	public GAction* getActionStruct(bool transferOwnership = false)
72 	{
73 		if (transferOwnership)
74 			ownedRef = false;
75 		return cast(GAction*)getStruct();
76 	}
77 
78 
79 	/**
80 	 * Activates the action.
81 	 *
82 	 * @parameter must be the correct type of parameter for the action (ie:
83 	 * the parameter type given at construction time).  If the parameter
84 	 * type was %NULL then @parameter must also be %NULL.
85 	 *
86 	 * If the @parameter GVariant is floating, it is consumed.
87 	 *
88 	 * Params:
89 	 *     parameter = the parameter to the activation
90 	 *
91 	 * Since: 2.28
92 	 */
93 	public void activate(Variant parameter)
94 	{
95 		g_action_activate(getActionStruct(), (parameter is null) ? null : parameter.getVariantStruct());
96 	}
97 
98 	/**
99 	 * Request for the state of @action to be changed to @value.
100 	 *
101 	 * The action must be stateful and @value must be of the correct type.
102 	 * See g_action_get_state_type().
103 	 *
104 	 * This call merely requests a change.  The action may refuse to change
105 	 * its state or may change its state to something other than @value.
106 	 * See g_action_get_state_hint().
107 	 *
108 	 * If the @value GVariant is floating, it is consumed.
109 	 *
110 	 * Params:
111 	 *     value = the new state
112 	 *
113 	 * Since: 2.30
114 	 */
115 	public void changeState(Variant value)
116 	{
117 		g_action_change_state(getActionStruct(), (value is null) ? null : value.getVariantStruct());
118 	}
119 
120 	/**
121 	 * Checks if @action is currently enabled.
122 	 *
123 	 * An action must be enabled in order to be activated or in order to
124 	 * have its state changed from outside callers.
125 	 *
126 	 * Returns: whether the action is enabled
127 	 *
128 	 * Since: 2.28
129 	 */
130 	public bool getEnabled()
131 	{
132 		return g_action_get_enabled(getActionStruct()) != 0;
133 	}
134 
135 	/**
136 	 * Queries the name of @action.
137 	 *
138 	 * Returns: the name of the action
139 	 *
140 	 * Since: 2.28
141 	 */
142 	public string getName()
143 	{
144 		return Str.toString(g_action_get_name(getActionStruct()));
145 	}
146 
147 	/**
148 	 * Queries the type of the parameter that must be given when activating
149 	 * @action.
150 	 *
151 	 * When activating the action using g_action_activate(), the #GVariant
152 	 * given to that function must be of the type returned by this function.
153 	 *
154 	 * In the case that this function returns %NULL, you must not give any
155 	 * #GVariant, but %NULL instead.
156 	 *
157 	 * Returns: the parameter type
158 	 *
159 	 * Since: 2.28
160 	 */
161 	public VariantType getParameterType()
162 	{
163 		auto p = g_action_get_parameter_type(getActionStruct());
164 
165 		if(p is null)
166 		{
167 			return null;
168 		}
169 
170 		return new VariantType(cast(GVariantType*) p);
171 	}
172 
173 	/**
174 	 * Queries the current state of @action.
175 	 *
176 	 * If the action is not stateful then %NULL will be returned.  If the
177 	 * action is stateful then the type of the return value is the type
178 	 * given by g_action_get_state_type().
179 	 *
180 	 * The return value (if non-%NULL) should be freed with
181 	 * g_variant_unref() when it is no longer required.
182 	 *
183 	 * Returns: the current state of the action
184 	 *
185 	 * Since: 2.28
186 	 */
187 	public Variant getState()
188 	{
189 		auto p = g_action_get_state(getActionStruct());
190 
191 		if(p is null)
192 		{
193 			return null;
194 		}
195 
196 		return new Variant(cast(GVariant*) p, true);
197 	}
198 
199 	/**
200 	 * Requests a hint about the valid range of values for the state of
201 	 * @action.
202 	 *
203 	 * If %NULL is returned it either means that the action is not stateful
204 	 * or that there is no hint about the valid range of values for the
205 	 * state of the action.
206 	 *
207 	 * If a #GVariant array is returned then each item in the array is a
208 	 * possible value for the state.  If a #GVariant pair (ie: two-tuple) is
209 	 * returned then the tuple specifies the inclusive lower and upper bound
210 	 * of valid values for the state.
211 	 *
212 	 * In any case, the information is merely a hint.  It may be possible to
213 	 * have a state value outside of the hinted range and setting a value
214 	 * within the range may fail.
215 	 *
216 	 * The return value (if non-%NULL) should be freed with
217 	 * g_variant_unref() when it is no longer required.
218 	 *
219 	 * Returns: the state range hint
220 	 *
221 	 * Since: 2.28
222 	 */
223 	public Variant getStateHint()
224 	{
225 		auto p = g_action_get_state_hint(getActionStruct());
226 
227 		if(p is null)
228 		{
229 			return null;
230 		}
231 
232 		return new Variant(cast(GVariant*) p, true);
233 	}
234 
235 	/**
236 	 * Queries the type of the state of @action.
237 	 *
238 	 * If the action is stateful (e.g. created with
239 	 * g_simple_action_new_stateful()) then this function returns the
240 	 * #GVariantType of the state.  This is the type of the initial value
241 	 * given as the state. All calls to g_action_change_state() must give a
242 	 * #GVariant of this type and g_action_get_state() will return a
243 	 * #GVariant of the same type.
244 	 *
245 	 * If the action is not stateful (e.g. created with g_simple_action_new())
246 	 * then this function will return %NULL. In that case, g_action_get_state()
247 	 * will return %NULL and you must not call g_action_change_state().
248 	 *
249 	 * Returns: the state type, if the action is stateful
250 	 *
251 	 * Since: 2.28
252 	 */
253 	public VariantType getStateType()
254 	{
255 		auto p = g_action_get_state_type(getActionStruct());
256 
257 		if(p is null)
258 		{
259 			return null;
260 		}
261 
262 		return new VariantType(cast(GVariantType*) p);
263 	}
264 }