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 glib.OptionGroup;
26 
27 private import glib.ConstructionException;
28 private import glib.Str;
29 private import glib.c.functions;
30 public  import glib.c.types;
31 public  import gtkc.glibtypes;
32 private import gtkd.Loader;
33 
34 
35 /**
36  * A `GOptionGroup` struct defines the options in a single
37  * group. The struct has only private fields and should not be directly accessed.
38  * 
39  * All options in a group share the same translation function. Libraries which
40  * need to parse commandline options are expected to provide a function for
41  * getting a `GOptionGroup` holding their options, which
42  * the application can then add to its #GOptionContext.
43  */
44 public class OptionGroup
45 {
46 	/** the main Gtk struct */
47 	protected GOptionGroup* gOptionGroup;
48 	protected bool ownedRef;
49 
50 	/** Get the main Gtk struct */
51 	public GOptionGroup* getOptionGroupStruct(bool transferOwnership = false)
52 	{
53 		if (transferOwnership)
54 			ownedRef = false;
55 		return gOptionGroup;
56 	}
57 
58 	/** the main Gtk struct as a void* */
59 	protected void* getStruct()
60 	{
61 		return cast(void*)gOptionGroup;
62 	}
63 
64 	/**
65 	 * Sets our main struct and passes it to the parent class.
66 	 */
67 	public this (GOptionGroup* gOptionGroup, bool ownedRef = false)
68 	{
69 		this.gOptionGroup = gOptionGroup;
70 		this.ownedRef = ownedRef;
71 	}
72 
73 	~this ()
74 	{
75 		if ( Linker.isLoaded(LIBRARY_GLIB) && ownedRef )
76 			g_option_group_unref(gOptionGroup);
77 	}
78 
79 
80 	/**
81 	 * Creates a new #GOptionGroup.
82 	 *
83 	 * Params:
84 	 *     name = the name for the option group, this is used to provide
85 	 *         help for the options in this group with `--help-`@name
86 	 *     description = a description for this group to be shown in
87 	 *         `--help`. This string is translated using the translation
88 	 *         domain or translation function of the group
89 	 *     helpDescription = a description for the `--help-`@name option.
90 	 *         This string is translated using the translation domain or translation function
91 	 *         of the group
92 	 *     userData = user data that will be passed to the pre- and post-parse hooks,
93 	 *         the error hook and to callbacks of %G_OPTION_ARG_CALLBACK options, or %NULL
94 	 *     destroy = a function that will be called to free @user_data, or %NULL
95 	 *
96 	 * Returns: a newly created option group. It should be added
97 	 *     to a #GOptionContext or freed with g_option_group_unref().
98 	 *
99 	 * Since: 2.6
100 	 *
101 	 * Throws: ConstructionException GTK+ fails to create the object.
102 	 */
103 	public this(string name, string description, string helpDescription, void* userData, GDestroyNotify destroy)
104 	{
105 		auto p = g_option_group_new(Str.toStringz(name), Str.toStringz(description), Str.toStringz(helpDescription), userData, destroy);
106 
107 		if(p is null)
108 		{
109 			throw new ConstructionException("null returned by new");
110 		}
111 
112 		this(cast(GOptionGroup*) p);
113 	}
114 
115 	/**
116 	 * Adds the options specified in @entries to @group.
117 	 *
118 	 * Params:
119 	 *     entries = a %NULL-terminated array of #GOptionEntrys
120 	 *
121 	 * Since: 2.6
122 	 */
123 	public void addEntries(GOptionEntry* entries)
124 	{
125 		g_option_group_add_entries(gOptionGroup, entries);
126 	}
127 
128 	/**
129 	 * Frees a #GOptionGroup. Note that you must not free groups
130 	 * which have been added to a #GOptionContext.
131 	 *
132 	 * Deprecated: Use g_option_group_unref() instead.
133 	 *
134 	 * Since: 2.6
135 	 */
136 	public void free()
137 	{
138 		g_option_group_free(gOptionGroup);
139 		ownedRef = false;
140 	}
141 
142 	alias doref = ref_;
143 	/**
144 	 * Increments the reference count of @group by one.
145 	 *
146 	 * Returns: a #GOptionGroup
147 	 *
148 	 * Since: 2.44
149 	 */
150 	public OptionGroup ref_()
151 	{
152 		auto p = g_option_group_ref(gOptionGroup);
153 
154 		if(p is null)
155 		{
156 			return null;
157 		}
158 
159 		return new OptionGroup(cast(GOptionGroup*) p, true);
160 	}
161 
162 	/**
163 	 * Associates a function with @group which will be called
164 	 * from g_option_context_parse() when an error occurs.
165 	 *
166 	 * Note that the user data to be passed to @error_func can be
167 	 * specified when constructing the group with g_option_group_new().
168 	 *
169 	 * Params:
170 	 *     errorFunc = a function to call when an error occurs
171 	 *
172 	 * Since: 2.6
173 	 */
174 	public void setErrorHook(GOptionErrorFunc errorFunc)
175 	{
176 		g_option_group_set_error_hook(gOptionGroup, errorFunc);
177 	}
178 
179 	/**
180 	 * Associates two functions with @group which will be called
181 	 * from g_option_context_parse() before the first option is parsed
182 	 * and after the last option has been parsed, respectively.
183 	 *
184 	 * Note that the user data to be passed to @pre_parse_func and
185 	 * @post_parse_func can be specified when constructing the group
186 	 * with g_option_group_new().
187 	 *
188 	 * Params:
189 	 *     preParseFunc = a function to call before parsing, or %NULL
190 	 *     postParseFunc = a function to call after parsing, or %NULL
191 	 *
192 	 * Since: 2.6
193 	 */
194 	public void setParseHooks(GOptionParseFunc preParseFunc, GOptionParseFunc postParseFunc)
195 	{
196 		g_option_group_set_parse_hooks(gOptionGroup, preParseFunc, postParseFunc);
197 	}
198 
199 	/**
200 	 * Sets the function which is used to translate user-visible strings,
201 	 * for `--help` output. Different groups can use different
202 	 * #GTranslateFuncs. If @func is %NULL, strings are not translated.
203 	 *
204 	 * If you are using gettext(), you only need to set the translation
205 	 * domain, see g_option_group_set_translation_domain().
206 	 *
207 	 * Params:
208 	 *     func = the #GTranslateFunc, or %NULL
209 	 *     data = user data to pass to @func, or %NULL
210 	 *     destroyNotify = a function which gets called to free @data, or %NULL
211 	 *
212 	 * Since: 2.6
213 	 */
214 	public void setTranslateFunc(GTranslateFunc func, void* data, GDestroyNotify destroyNotify)
215 	{
216 		g_option_group_set_translate_func(gOptionGroup, func, data, destroyNotify);
217 	}
218 
219 	/**
220 	 * A convenience function to use gettext() for translating
221 	 * user-visible strings.
222 	 *
223 	 * Params:
224 	 *     domain = the domain to use
225 	 *
226 	 * Since: 2.6
227 	 */
228 	public void setTranslationDomain(string domain)
229 	{
230 		g_option_group_set_translation_domain(gOptionGroup, Str.toStringz(domain));
231 	}
232 
233 	/**
234 	 * Decrements the reference count of @group by one.
235 	 * If the reference count drops to 0, the @group will be freed.
236 	 * and all memory allocated by the @group is released.
237 	 *
238 	 * Since: 2.44
239 	 */
240 	public void unref()
241 	{
242 		g_option_group_unref(gOptionGroup);
243 	}
244 }