source: appstream-generator/build/girepo/gio/MenuItem.d @ 4841

Last change on this file since 4841 was 4841, checked in by Juanma, 2 years ago

Initial release

File size: 11.6 KB
Line 
1/*
2 * Licensed under the GNU Lesser General Public License Version 3
3 *
4 * This library is free software: you can redistribute it and/or modify
5 * it under the terms of the GNU Lesser General Public License as published by
6 * the Free Software Foundation, either version 3 of the license, or
7 * (at your option) any later version.
8 *
9 * This software is distributed in the hope that it will be useful,
10 * but WITHOUT ANY WARRANTY; without even the implied warranty of
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
12 * GNU Lesser General Public License for more details.
13 *
14 * You should have received a copy of the GNU Lesser General Public License
15 * along with this library.  If not, see <http://www.gnu.org/licenses/>.
16 */
17
18// generated automatically - do not change
19
20
21module gio.MenuItem;
22
23private import gi.gio;
24public  import gi.giotypes;
25private import gio.IconIF;
26private import gio.MenuModel;
27private import glib.ConstructionException;
28private import glib.Str;
29private import glib.Variant;
30private import glib.VariantType;
31private import gobject.ObjectG;
32
33
34/**
35 * #GMenuItem is an opaque structure type.  You must access it using the
36 * functions below.
37 *
38 * Since: 2.32
39 */
40public class MenuItem : ObjectG
41{
42        /** the main Gtk struct */
43        protected GMenuItem* gMenuItem;
44
45        /** Get the main Gtk struct */
46        public GMenuItem* getMenuItemStruct()
47        {
48                return gMenuItem;
49        }
50
51        /** the main Gtk struct as a void* */
52        protected override void* getStruct()
53        {
54                return cast(void*)gMenuItem;
55        }
56
57        protected override void setStruct(GObject* obj)
58        {
59                gMenuItem = cast(GMenuItem*)obj;
60                super.setStruct(obj);
61        }
62
63        /**
64         * Sets our main struct and passes it to the parent class.
65         */
66        public this (GMenuItem* gMenuItem, bool ownedRef = false)
67        {
68                this.gMenuItem = gMenuItem;
69                super(cast(GObject*)gMenuItem, ownedRef);
70        }
71
72
73        /** */
74        public static GType getType()
75        {
76                return g_menu_item_get_type();
77        }
78
79        /**
80         * Creates a new #GMenuItem.
81         *
82         * If @label is non-%NULL it is used to set the "label" attribute of the
83         * new item.
84         *
85         * If @detailed_action is non-%NULL it is used to set the "action" and
86         * possibly the "target" attribute of the new item.  See
87         * g_menu_item_set_detailed_action() for more information.
88         *
89         * Params:
90         *     label = the section label, or %NULL
91         *     detailedAction = the detailed action string, or %NULL
92         *
93         * Returns: a new #GMenuItem
94         *
95         * Since: 2.32
96         *
97         * Throws: ConstructionException GTK+ fails to create the object.
98         */
99        public this(string label, string detailedAction)
100        {
101                auto p = g_menu_item_new(Str.toStringz(label), Str.toStringz(detailedAction));
102               
103                if(p is null)
104                {
105                        throw new ConstructionException("null returned by new");
106                }
107               
108                this(cast(GMenuItem*) p, true);
109        }
110
111        /**
112         * Creates a #GMenuItem as an exact copy of an existing menu item in a
113         * #GMenuModel.
114         *
115         * @item_index must be valid (ie: be sure to call
116         * g_menu_model_get_n_items() first).
117         *
118         * Params:
119         *     model = a #GMenuModel
120         *     itemIndex = the index of an item in @model
121         *
122         * Returns: a new #GMenuItem.
123         *
124         * Since: 2.34
125         *
126         * Throws: ConstructionException GTK+ fails to create the object.
127         */
128        public this(MenuModel model, int itemIndex)
129        {
130                auto p = g_menu_item_new_from_model((model is null) ? null : model.getMenuModelStruct(), itemIndex);
131               
132                if(p is null)
133                {
134                        throw new ConstructionException("null returned by new_from_model");
135                }
136               
137                this(cast(GMenuItem*) p, true);
138        }
139
140        /**
141         * Queries the named @attribute on @menu_item.
142         *
143         * If @expected_type is specified and the attribute does not have this
144         * type, %NULL is returned.  %NULL is also returned if the attribute
145         * simply does not exist.
146         *
147         * Params:
148         *     attribute = the attribute name to query
149         *     expectedType = the expected type of the attribute
150         *
151         * Returns: the attribute value, or %NULL
152         *
153         * Since: 2.34
154         */
155        public Variant getAttributeValue(string attribute, VariantType expectedType)
156        {
157                auto p = g_menu_item_get_attribute_value(gMenuItem, Str.toStringz(attribute), (expectedType is null) ? null : expectedType.getVariantTypeStruct());
158               
159                if(p is null)
160                {
161                        return null;
162                }
163               
164                return new Variant(cast(GVariant*) p, true);
165        }
166
167        /**
168         * Queries the named @link on @menu_item.
169         *
170         * Params:
171         *     link = the link name to query
172         *
173         * Returns: the link, or %NULL
174         *
175         * Since: 2.34
176         */
177        public MenuModel getLink(string link)
178        {
179                auto p = g_menu_item_get_link(gMenuItem, Str.toStringz(link));
180               
181                if(p is null)
182                {
183                        return null;
184                }
185               
186                return ObjectG.getDObject!(MenuModel)(cast(GMenuModel*) p, true);
187        }
188
189        /**
190         * Sets or unsets the "action" and "target" attributes of @menu_item.
191         *
192         * If @action is %NULL then both the "action" and "target" attributes
193         * are unset (and @target_value is ignored).
194         *
195         * If @action is non-%NULL then the "action" attribute is set.  The
196         * "target" attribute is then set to the value of @target_value if it is
197         * non-%NULL or unset otherwise.
198         *
199         * Normal menu items (ie: not submenu, section or other custom item
200         * types) are expected to have the "action" attribute set to identify
201         * the action that they are associated with.  The state type of the
202         * action help to determine the disposition of the menu item.  See
203         * #GAction and #GActionGroup for an overview of actions.
204         *
205         * In general, clicking on the menu item will result in activation of
206         * the named action with the "target" attribute given as the parameter
207         * to the action invocation.  If the "target" attribute is not set then
208         * the action is invoked with no parameter.
209         *
210         * If the action has no state then the menu item is usually drawn as a
211         * plain menu item (ie: with no additional decoration).
212         *
213         * If the action has a boolean state then the menu item is usually drawn
214         * as a toggle menu item (ie: with a checkmark or equivalent
215         * indication).  The item should be marked as 'toggled' or 'checked'
216         * when the boolean state is %TRUE.
217         *
218         * If the action has a string state then the menu item is usually drawn
219         * as a radio menu item (ie: with a radio bullet or equivalent
220         * indication).  The item should be marked as 'selected' when the string
221         * state is equal to the value of the @target property.
222         *
223         * See g_menu_item_set_action_and_target() or
224         * g_menu_item_set_detailed_action() for two equivalent calls that are
225         * probably more convenient for most uses.
226         *
227         * Params:
228         *     action = the name of the action for this item
229         *     targetValue = a #GVariant to use as the action target
230         *
231         * Since: 2.32
232         */
233        public void setActionAndTargetValue(string action, Variant targetValue)
234        {
235                g_menu_item_set_action_and_target_value(gMenuItem, Str.toStringz(action), (targetValue is null) ? null : targetValue.getVariantStruct());
236        }
237
238        /**
239         * Sets or unsets an attribute on @menu_item.
240         *
241         * The attribute to set or unset is specified by @attribute. This
242         * can be one of the standard attribute names %G_MENU_ATTRIBUTE_LABEL,
243         * %G_MENU_ATTRIBUTE_ACTION, %G_MENU_ATTRIBUTE_TARGET, or a custom
244         * attribute name.
245         * Attribute names are restricted to lowercase characters, numbers
246         * and '-'. Furthermore, the names must begin with a lowercase character,
247         * must not end with a '-', and must not contain consecutive dashes.
248         *
249         * must consist only of lowercase
250         * ASCII characters, digits and '-'.
251         *
252         * If @value is non-%NULL then it is used as the new value for the
253         * attribute.  If @value is %NULL then the attribute is unset. If
254         * the @value #GVariant is floating, it is consumed.
255         *
256         * See also g_menu_item_set_attribute() for a more convenient way to do
257         * the same.
258         *
259         * Params:
260         *     attribute = the attribute to set
261         *     value = a #GVariant to use as the value, or %NULL
262         *
263         * Since: 2.32
264         */
265        public void setAttributeValue(string attribute, Variant value)
266        {
267                g_menu_item_set_attribute_value(gMenuItem, Str.toStringz(attribute), (value is null) ? null : value.getVariantStruct());
268        }
269
270        /**
271         * Sets the "action" and possibly the "target" attribute of @menu_item.
272         *
273         * The format of @detailed_action is the same format parsed by
274         * g_action_parse_detailed_name().
275         *
276         * See g_menu_item_set_action_and_target() or
277         * g_menu_item_set_action_and_target_value() for more flexible (but
278         * slightly less convenient) alternatives.
279         *
280         * See also g_menu_item_set_action_and_target_value() for a description of
281         * the semantics of the action and target attributes.
282         *
283         * Params:
284         *     detailedAction = the "detailed" action string
285         *
286         * Since: 2.32
287         */
288        public void setDetailedAction(string detailedAction)
289        {
290                g_menu_item_set_detailed_action(gMenuItem, Str.toStringz(detailedAction));
291        }
292
293        /**
294         * Sets (or unsets) the icon on @menu_item.
295         *
296         * This call is the same as calling g_icon_serialize() and using the
297         * result as the value to g_menu_item_set_attribute_value() for
298         * %G_MENU_ATTRIBUTE_ICON.
299         *
300         * This API is only intended for use with "noun" menu items; things like
301         * bookmarks or applications in an "Open With" menu.  Don't use it on
302         * menu items corresponding to verbs (eg: stock icons for 'Save' or
303         * 'Quit').
304         *
305         * If @icon is %NULL then the icon is unset.
306         *
307         * Params:
308         *     icon = a #GIcon, or %NULL
309         *
310         * Since: 2.38
311         */
312        public void setIcon(IconIF icon)
313        {
314                g_menu_item_set_icon(gMenuItem, (icon is null) ? null : icon.getIconStruct());
315        }
316
317        /**
318         * Sets or unsets the "label" attribute of @menu_item.
319         *
320         * If @label is non-%NULL it is used as the label for the menu item.  If
321         * it is %NULL then the label attribute is unset.
322         *
323         * Params:
324         *     label = the label to set, or %NULL to unset
325         *
326         * Since: 2.32
327         */
328        public void setLabel(string label)
329        {
330                g_menu_item_set_label(gMenuItem, Str.toStringz(label));
331        }
332
333        /**
334         * Creates a link from @menu_item to @model if non-%NULL, or unsets it.
335         *
336         * Links are used to establish a relationship between a particular menu
337         * item and another menu.  For example, %G_MENU_LINK_SUBMENU is used to
338         * associate a submenu with a particular menu item, and %G_MENU_LINK_SECTION
339         * is used to create a section. Other types of link can be used, but there
340         * is no guarantee that clients will be able to make sense of them.
341         * Link types are restricted to lowercase characters, numbers
342         * and '-'. Furthermore, the names must begin with a lowercase character,
343         * must not end with a '-', and must not contain consecutive dashes.
344         *
345         * Params:
346         *     link = type of link to establish or unset
347         *     model = the #GMenuModel to link to (or %NULL to unset)
348         *
349         * Since: 2.32
350         */
351        public void setLink(string link, MenuModel model)
352        {
353                g_menu_item_set_link(gMenuItem, Str.toStringz(link), (model is null) ? null : model.getMenuModelStruct());
354        }
355
356        /**
357         * Sets or unsets the "section" link of @menu_item to @section.
358         *
359         * The effect of having one menu appear as a section of another is
360         * exactly as it sounds: the items from @section become a direct part of
361         * the menu that @menu_item is added to.  See g_menu_item_new_section()
362         * for more information about what it means for a menu item to be a
363         * section.
364         *
365         * Params:
366         *     section = a #GMenuModel, or %NULL
367         *
368         * Since: 2.32
369         */
370        public void setSection(MenuModel section)
371        {
372                g_menu_item_set_section(gMenuItem, (section is null) ? null : section.getMenuModelStruct());
373        }
374
375        /**
376         * Sets or unsets the "submenu" link of @menu_item to @submenu.
377         *
378         * If @submenu is non-%NULL, it is linked to.  If it is %NULL then the
379         * link is unset.
380         *
381         * The effect of having one menu appear as a submenu of another is
382         * exactly as it sounds.
383         *
384         * Params:
385         *     submenu = a #GMenuModel, or %NULL
386         *
387         * Since: 2.32
388         */
389        public void setSubmenu(MenuModel submenu)
390        {
391                g_menu_item_set_submenu(gMenuItem, (submenu is null) ? null : submenu.getMenuModelStruct());
392        }
393}
Note: See TracBrowser for help on using the repository browser.