PageRenderTime 36ms CodeModel.GetById 8ms app.highlight 13ms RepoModel.GetById 2ms app.codeStats 0ms

/src/wrappers/gtk/library/gtk_action_group.e

http://github.com/tybor/Liberty
Specman e | 812 lines | 101 code | 223 blank | 488 comment | 2 complexity | a5210098bca0624afeec96870693ec21 MD5 | raw file
  1indexing
  2	description: "A group of actions."
  3	copyright: "[
  4					Copyright (C) 2007 Paolo Redaelli, GTK+ team
  5					
  6					This library is free software; you can redistribute it and/or
  7					modify it under the terms of the GNU Lesser General Public License
  8					as published by the Free Software Foundation; either version 2.1 of
  9					the License, or (at your option) any later version.
 10					
 11					This library is distributed in the hopeOA that it will be useful, but
 12					WITHOUT ANY WARRANTY; without even the implied warranty of
 13					MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 14					Lesser General Public License for more details.
 15
 16					You should have received a copy of the GNU Lesser General Public
 17					License along with this library; if not, write to the Free Software
 18					Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
 19					02110-1301 USA
 20			]"
 21
 22	wrapped_version: "2.10.6"
 23
 24class GTK_ACTION_GROUP
 25	-- Actions are organised into groups. An action group is
 26	-- essentially a map from names to GtkAction objects.
 27
 28	-- All actions that would make sense to use in a particular context
 29	-- should be in a single group. Multiple action groups may be used
 30	-- for a particular user interface. In fact, it is expected that
 31	-- most nontrivial applications will make use of multiple
 32	-- groups. For example, in an application that can edit multiple
 33	-- documents, one group holding global actions (e.g. quit, about,
 34	-- new), and one group per document holding actions that act on
 35	-- that document (eg. save, cut/copy/paste, etc). Each window's
 36	-- menus would be constructed from a combination of two action
 37	-- groups.
 38
 39	-- Accelerators are handled by the GTK+ accelerator map. All
 40	-- actions are assigned an accelerator path (which normally has the
 41	-- form <Actions>/group-name/action-name) and a shortcut is
 42	-- associated with this accelerator path. All menuitems and tool
 43	-- items take on this accelerator path. The GTK+ accelerator map
 44	-- code makes sure that the correct shortcut is displayed next to
 45	-- the menu item.
 46
 47inherit G_OBJECT
 48
 49creation make, from_external_pointer
 50
 51feature {} -- Creation
 52
 53	make (a_name: STRING) is
 54			-- Creates a new GtkActionGroup object. `a_name' is used as
 55			-- the name of the action group and it is used when
 56			-- associating keybindings with the actions.
 57		do
 58			from_external_pointer (gtk_action_group_new (a_name.to_external))
 59		end
 60
 61feature 
 62	name: CONST_STRING is
 63			-- the name of the action group.
 64		do
 65			create Result.from_external(gtk_action_group_get_name(handle))
 66		ensure not_void: Result /= Void
 67		end
 68
 69
 70	--  gtk_action_group_get_sensitive ()
 71
 72	-- gboolean    gtk_action_group_get_sensitive  (GtkActionGroup *action_group);
 73
 74	--   Returns TRUE if the group is sensitive. The constituent actions can only
 75	--   be logically sensitive (see gtk_action_is_sensitive()) if they are
 76	--   sensitive (see gtk_action_get_sensitive()) and their group is sensitive.
 77
 78	--   action_group : the action group
 79	--   Returns :      TRUE if the group is sensitive.
 80
 81	--   Since 2.4
 82
 83	--   --------------------------------------------------------------------------
 84
 85	--  gtk_action_group_set_sensitive ()
 86
 87	-- void        gtk_action_group_set_sensitive  (GtkActionGroup *action_group,
 88	--                                              gboolean sensitive);
 89
 90	--   Changes the sensitivity of action_group
 91
 92	--   action_group : the action group
 93	--   sensitive :    new sensitivity
 94
 95	--   Since 2.4
 96
 97	--   --------------------------------------------------------------------------
 98
 99	--  gtk_action_group_get_visible ()
100
101	-- gboolean    gtk_action_group_get_visible    (GtkActionGroup *action_group);
102
103	--   Returns TRUE if the group is visible. The constituent actions can only be
104	--   logically visible (see gtk_action_is_visible()) if they are visible (see
105	--   gtk_action_get_visible()) and their group is visible.
106
107	--   action_group : the action group
108	--   Returns :      TRUE if the group is visible.
109
110	--   Since 2.4
111
112	--   --------------------------------------------------------------------------
113
114	--  gtk_action_group_set_visible ()
115
116	-- void        gtk_action_group_set_visible    (GtkActionGroup *action_group,
117	--                                              gboolean visible);
118
119	--   Changes the visible of action_group.
120
121	--   action_group : the action group
122	--   visible :      new visiblity
123
124	--   Since 2.4
125
126	--   --------------------------------------------------------------------------
127
128	--  gtk_action_group_get_action ()
129
130	-- GtkAction*  gtk_action_group_get_action     (GtkActionGroup *action_group,
131	--                                              const gchar *action_name);
132
133	--   Looks up an action in the action group by name.
134
135	--   action_group : the action group
136	--   action_name :  the name of the action
137	--   Returns :      the action, or NULL if no action by that name exists
138
139	--   Since 2.4
140
141	--   --------------------------------------------------------------------------
142
143	--  gtk_action_group_list_actions ()
144
145	-- GList*      gtk_action_group_list_actions   (GtkActionGroup *action_group);
146
147	--   Lists the actions in the action group.
148
149	--   action_group : the action group
150	--   Returns :      an allocated list of the action objects in the action group
151
152	--   Since 2.4
153
154	--   --------------------------------------------------------------------------
155
156	--  gtk_action_group_add_action ()
157
158	-- void        gtk_action_group_add_action     (GtkActionGroup *action_group,
159	--                                              GtkAction *action);
160
161	--   Adds an action object to the action group. Note that this function does
162	--   not set up the accel path of the action, which can lead to problems if a
163	--   user tries to modify the accelerator of a menuitem associated with the
164	--   action. Therefore you must either set the accel path yourself with
165	--   gtk_action_set_accel_path(), or use gtk_action_group_add_action_with_accel
166	--   (..., NULL).
167
168	--   action_group : the action group
169	--   action :       an action
170
171	--   Since 2.4
172
173	--   --------------------------------------------------------------------------
174
175	--  gtk_action_group_add_action_with_accel ()
176
177	-- void        gtk_action_group_add_action_with_accel
178	--                                             (GtkActionGroup *action_group,
179	--                                              GtkAction *action,
180	--                                              const gchar *accelerator);
181
182	--   Adds an action object to the action group and sets up the accelerator.
183
184	--   If accelerator is NULL, attempts to use the accelerator associated with
185	--   the stock_id of the action.
186
187	--   Accel paths are set to <Actions>/group-name/action-name.
188
189	--   action_group : the action group
190	--   action :       the action to add
191	--   accelerator :  the accelerator for the action, in the format understood by
192	--                  gtk_accelerator_parse(), or "" for no accelerator, or NULL
193	--                  to use the stock accelerator
194
195	--   Since 2.4
196
197	--   --------------------------------------------------------------------------
198
199	--  gtk_action_group_remove_action ()
200
201	-- void        gtk_action_group_remove_action  (GtkActionGroup *action_group,
202	--                                              GtkAction *action);
203
204	--   Removes an action object from the action group.
205
206	--   action_group : the action group
207	--   action :       an action
208
209	--   Since 2.4
210
211	--   --------------------------------------------------------------------------
212
213	--  GtkActionEntry
214
215	-- typedef struct {
216	--   const gchar     *name;
217	--   const gchar     *stock_id;
218	--   const gchar     *label;
219	--   const gchar     *accelerator;
220	--   const gchar     *tooltip;
221	--   GCallback  callback;
222	-- } GtkActionEntry;
223
224	--   GtkActionEntry structs are used with gtk_action_group_add_actions() to
225	--   construct actions.
226
227	--   const gchar *name;        The name of the action.
228	--   const gchar *stock_id;    The stock id for the action, or the name of an
229	--                             icon from the icon theme.
230	--   const gchar *label;       The label for the action. This field should
231	--                             typically be marked for translation, see
232	--                             gtk_action_group_set_translation_domain().
233	--   const gchar *accelerator; The accelerator for the action, in the format
234	--                             understood by gtk_accelerator_parse().
235	--   const gchar *tooltip;     The tooltip for the action. This field should
236	--                             typically be marked for translation, see
237	--                             gtk_action_group_set_translation_domain().
238	--   GCallback callback;       The function to call when the action is
239	--                             activated.
240
241	--   --------------------------------------------------------------------------
242
243	--  gtk_action_group_add_actions ()
244
245	-- void        gtk_action_group_add_actions    (GtkActionGroup *action_group,
246	--                                              const GtkActionEntry *entries,
247	--                                              guint n_entries,
248	--                                              gpointer user_data);
249
250	--   This is a convenience function to create a number of actions and add them
251	--   to the action group.
252
253	--   The "activate" signals of the actions are connected to the callbacks and
254	--   their accel paths are set to <Actions>/group-name/action-name.
255
256	--   action_group : the action group
257	--   entries :      an array of action descriptions
258	--   n_entries :    the number of entries
259	--   user_data :    data to pass to the action callbacks
260
261	--   Since 2.4
262
263	--   --------------------------------------------------------------------------
264
265	--  gtk_action_group_add_actions_full ()
266
267	-- void        gtk_action_group_add_actions_full
268	--                                             (GtkActionGroup *action_group,
269	--                                              const GtkActionEntry *entries,
270	--                                              guint n_entries,
271	--                                              gpointer user_data,
272	--                                              GDestroyNotify destroy);
273
274	--   This variant of gtk_action_group_add_actions() adds a GDestroyNotify
275	--   callback for user_data.
276
277	--   action_group : the action group
278	--   entries :      an array of action descriptions
279	--   n_entries :    the number of entries
280	--   user_data :    data to pass to the action callbacks
281	--   destroy :      destroy notification callback for user_data
282
283	--   Since 2.4
284
285	--   --------------------------------------------------------------------------
286
287	--  GtkToggleActionEntry
288
289	-- typedef struct {
290	--   const gchar     *name;
291	--   const gchar     *stock_id;
292	--   const gchar     *label;
293	--   const gchar     *accelerator;
294	--   const gchar     *tooltip;
295	--   GCallback  callback;
296	--   gboolean   is_active;
297	-- } GtkToggleActionEntry;
298
299	--   GtkToggleActionEntry structs are used with
300	--   gtk_action_group_add_toggle_actions() to construct toggle actions.
301
302	--   const gchar *name;        The name of the action.
303	--   const gchar *stock_id;    The stock id for the action, or the name of an
304	--                             icon from the icon theme.
305	--   const gchar *label;       The label for the action. This field should
306	--                             typically be marked for translation, see
307	--                             gtk_action_group_set_translation_domain().
308	--   const gchar *accelerator; The accelerator for the action, in the format
309	--                             understood by gtk_accelerator_parse().
310	--   const gchar *tooltip;     The tooltip for the action. This field should
311	--                             typically be marked for translation, see
312	--                             gtk_action_group_set_translation_domain().
313	--   GCallback callback;       The function to call when the action is
314	--                             activated.
315	--   gboolean is_active;       The initial state of the toggle action.
316
317	--   --------------------------------------------------------------------------
318
319	--  gtk_action_group_add_toggle_actions ()
320
321	-- void        gtk_action_group_add_toggle_actions
322	--                                             (GtkActionGroup *action_group,
323	--                                              const GtkToggleActionEntry *entries,
324	--                                              guint n_entries,
325	--                                              gpointer user_data);
326
327	--   This is a convenience function to create a number of toggle actions and
328	--   add them to the action group.
329
330	--   The "activate" signals of the actions are connected to the callbacks and
331	--   their accel paths are set to <Actions>/group-name/action-name.
332
333	--   action_group : the action group
334	--   entries :      an array of toggle action descriptions
335	--   n_entries :    the number of entries
336	--   user_data :    data to pass to the action callbacks
337
338	--   Since 2.4
339
340	--   --------------------------------------------------------------------------
341
342	--  gtk_action_group_add_toggle_actions_full ()
343
344	-- void        gtk_action_group_add_toggle_actions_full
345	--                                             (GtkActionGroup *action_group,
346	--                                              const GtkToggleActionEntry *entries,
347	--                                              guint n_entries,
348	--                                              gpointer user_data,
349	--                                              GDestroyNotify destroy);
350
351	--   This variant of gtk_action_group_add_toggle_actions() adds a
352	--   GDestroyNotify callback for user_data.
353
354	--   action_group : the action group
355	--   entries :      an array of toggle action descriptions
356	--   n_entries :    the number of entries
357	--   user_data :    data to pass to the action callbacks
358	--   destroy :      destroy notification callback for user_data
359
360	--   Since 2.4
361
362	--   --------------------------------------------------------------------------
363
364	--  GtkRadioActionEntry
365
366	-- typedef struct {
367	--   const gchar *name;
368	--   const gchar *stock_id;
369	--   const gchar *label;
370	--   const gchar *accelerator;
371	--   const gchar *tooltip;
372	--   gint   value;
373	-- } GtkRadioActionEntry;
374
375	--   GtkRadioActionEntry structs are used with
376	--   gtk_action_group_add_radio_actions() to construct groups of radio actions.
377
378	--   const gchar *name;        The name of the action.
379	--   const gchar *stock_id;    The stock id for the action, or the name of an
380	--                             icon from the icon theme.
381	--   const gchar *label;       The label for the action. This field should
382	--                             typically be marked for translation, see
383	--                             gtk_action_group_set_translation_domain().
384	--   const gchar *accelerator; The accelerator for the action, in the format
385	--                             understood by gtk_accelerator_parse().
386	--   const gchar *tooltip;     The tooltip for the action. This field should
387	--                             typically be marked for translation, see
388	--                             gtk_action_group_set_translation_domain().
389	--   gint value;               The value to set on the radio action. See
390	--                             gtk_radio_action_get_current_value().
391
392	--   --------------------------------------------------------------------------
393
394	--  gtk_action_group_add_radio_actions ()
395
396	-- void        gtk_action_group_add_radio_actions
397	--                                             (GtkActionGroup *action_group,
398	--                                              const GtkRadioActionEntry *entries,
399	--                                              guint n_entries,
400	--                                              gint value,
401	--                                              GCallback on_change,
402	--                                              gpointer user_data);
403
404	--   This is a convenience routine to create a group of radio actions and add
405	--   them to the action group.
406
407	--   The "changed" signal of the first radio action is connected to the
408	--   on_change callback and the accel paths of the actions are set to
409	--   <Actions>/group-name/action-name.
410
411	--   action_group : the action group
412	--   entries :      an array of radio action descriptions
413	--   n_entries :    the number of entries
414	--   value :        the value of the action to activate initially, or -1 if no
415	--                  action should be activated
416	--   on_change :    the callback to connect to the changed signal
417	--   user_data :    data to pass to the action callbacks
418
419	--   Since 2.4
420
421	--   --------------------------------------------------------------------------
422
423	--  gtk_action_group_add_radio_actions_full ()
424
425	-- void        gtk_action_group_add_radio_actions_full
426	--                                             (GtkActionGroup *action_group,
427	--                                              const GtkRadioActionEntry *entries,
428	--                                              guint n_entries,
429	--                                              gint value,
430	--                                              GCallback on_change,
431	--                                              gpointer user_data,
432	--                                              GDestroyNotify destroy);
433
434	--   This variant of gtk_action_group_add_radio_actions() adds a GDestroyNotify
435	--   callback for user_data.
436
437	--   action_group : the action group
438	--   entries :      an array of radio action descriptions
439	--   n_entries :    the number of entries
440	--   value :        the value of the action to activate initially, or -1 if no
441	--                  action should be activated
442	--   on_change :    the callback to connect to the changed signal
443	--   user_data :    data to pass to the action callbacks
444	--   destroy :      destroy notification callback for user_data
445
446	--   Since 2.4
447
448	--   --------------------------------------------------------------------------
449
450	--  gtk_action_group_set_translate_func ()
451
452	-- void        gtk_action_group_set_translate_func
453	--                                             (GtkActionGroup *action_group,
454	--                                              GtkTranslateFunc func,
455	--                                              gpointer data,
456	--                                              GtkDestroyNotify notify);
457
458	--   Sets a function to be used for translating the label and tooltip of
459	--   GtkActionGroupEntrys added by gtk_action_group_add_actions().
460
461	--   If you're using gettext(), it is enough to set the translation domain with
462	--   gtk_action_group_set_translation_domain().
463
464	--   action_group : a GtkActionGroup
465	--   func :         a GtkTranslateFunc
466	--   data :         data to be passed to func and notify
467	--   notify :       a GtkDestroyNotify function to be called when action_group
468	--                  is destroyed and when the translation function is changed
469	--                  again
470
471	--   Since 2.4
472
473	--   --------------------------------------------------------------------------
474
475	--  gtk_action_group_set_translation_domain ()
476
477	-- void        gtk_action_group_set_translation_domain
478	--                                             (GtkActionGroup *action_group,
479	--                                              const gchar *domain);
480
481	--   Sets the translation domain and uses dgettext() for translating the label
482	--   and tooltip of GtkActionEntrys added by gtk_action_group_add_actions().
483
484	--   If you're not using gettext() for localization, see
485	--   gtk_action_group_set_translate_func().
486
487	--   action_group : a GtkActionGroup
488	--   domain :       the translation domain to use for dgettext() calls
489
490	--   Since 2.4
491
492	--   --------------------------------------------------------------------------
493
494	--  gtk_action_group_translate_string ()
495
496	-- const gchar* gtk_action_group_translate_string
497	--                                             (GtkActionGroup *action_group,
498	--                                              const gchar *string);
499
500	--   Translates a string using the specified translate_func(). This is mainly
501	--   intended for language bindings.
502
503	--   action_group : a GtkActionGroup
504	--   string :       a string
505	--   Returns :      the translation of string
506
507	--   Since 2.6
508
509
510feature -- TODO: Properties
511
512
513	--   "name"                 gchararray            : Read / Write / Construct Only
514	--   "sensitive"            gboolean              : Read / Write
515	--   "visible"              gboolean              : Read / Write
516
517	--Property Details
518
519	--  The "name" property
520
521	--   "name"                 gchararray            : Read / Write / Construct Only
522
523	--   A name for the action group.
524
525	--   Default value: NULL
526
527	--   --------------------------------------------------------------------------
528
529	--  The "sensitive" property
530
531	--   "sensitive"            gboolean              : Read / Write
532
533	--   Whether the action group is enabled.
534
535	--   Default value: TRUE
536
537	--   --------------------------------------------------------------------------
538
539	--  The "visible" property
540
541	--   "visible"              gboolean              : Read / Write
542
543	--   Whether the action group is visible.
544
545	--   Default value: TRUE
546
547
548feature -- TODO: Signals
549
550
551	-- "connect-proxy"
552	--             void        user_function      (GtkActionGroup *action_group,
553	--                                             GtkAction      *action,
554	--                                             GtkWidget      *proxy,
555	--                                             gpointer        user_data)         :
556	-- "disconnect-proxy"
557	--             void        user_function      (GtkActionGroup *action_group,
558	--                                             GtkAction      *action,
559	--                                             GtkWidget      *proxy,
560	--                                             gpointer        user_data)         :
561	-- "post-activate"
562	--             void        user_function      (GtkActionGroup *action_group,
563	--                                             GtkAction      *action,
564	--                                             gpointer        user_data)         :
565	-- "pre-activate"
566	--             void        user_function      (GtkActionGroup *action_group,
567	--                                             GtkAction      *action,
568	--                                             gpointer        user_data)         :
569
570	--Signal Details
571
572	--  The "connect-proxy" signal
573
574	-- void        user_function                  (GtkActionGroup *action_group,
575	--                                             GtkAction      *action,
576	--                                             GtkWidget      *proxy,
577	--                                             gpointer        user_data)         :
578
579	--   The connect_proxy signal is emitted after connecting a proxy to an action
580	--   in the group. Note that the proxy may have been connected to a different
581	--   action before.
582
583	--   This is intended for simple customizations for which a custom action class
584	--   would be too clumsy, e.g. showing tooltips for menuitems in the statusbar.
585
586	--   GtkUIManager proxies the signal and provides global notification just
587	--   before any action is connected to a proxy, which is probably more
588	--   convenient to use.
589
590	--   action_group : the group
591	--   action :       the action
592	--   proxy :        the proxy
593	--   user_data :    user data set when the signal handler was connected.
594
595	--   Since 2.4
596
597	--   --------------------------------------------------------------------------
598
599	--  The "disconnect-proxy" signal
600
601	-- void        user_function                  (GtkActionGroup *action_group,
602	--                                             GtkAction      *action,
603	--                                             GtkWidget      *proxy,
604	--                                             gpointer        user_data)         :
605
606	--   The disconnect_proxy signal is emitted after disconnecting a proxy from an
607	--   action in the group.
608
609	--   GtkUIManager proxies the signal and provides global notification just
610	--   before any action is connected to a proxy, which is probably more
611	--   convenient to use.
612
613	--   action_group : the group
614	--   action :       the action
615	--   proxy :        the proxy
616	--   user_data :    user data set when the signal handler was connected.
617
618	--   Since 2.4
619
620	--   --------------------------------------------------------------------------
621
622	--  The "post-activate" signal
623
624	-- void        user_function                  (GtkActionGroup *action_group,
625	--                                             GtkAction      *action,
626	--                                             gpointer        user_data)         :
627
628	--   The post_activate signal is emitted just after the action in the
629	--   action_group is activated
630
631	--   This is intended for GtkUIManager to proxy the signal and provide global
632	--   notification just after any action is activated.
633
634	--   action_group : the group
635	--   action :       the action
636	--   user_data :    user data set when the signal handler was connected.
637
638	--   Since 2.4
639
640	--   --------------------------------------------------------------------------
641
642	--  The "pre-activate" signal
643
644	-- void        user_function                  (GtkActionGroup *action_group,
645	--                                             GtkAction      *action,
646	--                                             gpointer        user_data)         :
647
648	--   The pre_activate signal is emitted just before the action in the
649	--   action_group is activated
650
651	--   This is intended for GtkUIManager to proxy the signal and provide global
652	--   notification just before any action is activated.
653
654	--   action_group : the group
655	--   action :       the action
656	--   user_data :    user data set when the signal handler was connected.
657
658	--   Since 2.4
659feature -- size
660	struct_size: INTEGER is
661		external "C inline use <gtk/gtk.h>"
662		alias "sizeof(GtkActionGroup)"
663		end
664
665feature {} -- External calls
666	gtk_action_group_new (a_name: POINTER): POINTER is
667			-- GtkActionGroup* gtk_action_group_new (const gchar *name);
668		external "C use <gtk/gtk.h>"
669		end
670
671	gtk_action_group_get_name (an_action_group: POINTER): POINTER is
672			-- const gchar* gtk_action_group_get_name (GtkActionGroup
673			-- *action_group);
674		external "C use <gtk/gtk.h>"
675		end
676
677	gtk_action_group_get_sensitive (an_action_group: POINTER): INTEGER is
678			-- gboolean gtk_action_group_get_sensitive (GtkActionGroup
679			-- *action_group);
680		external "C use <gtk/gtk.h>"
681		end
682
683	gtk_action_group_set_sensitive (an_action_group: POINTER; a_sensitive: INTEGER) is
684			-- void gtk_action_group_set_sensitive (GtkActionGroup
685			-- *action_group, gboolean sensitive);
686		external "C use <gtk/gtk.h>"
687		end
688
689	gtk_action_group_get_visible (an_action_group: POINTER): INTEGER is
690			-- gboolean gtk_action_group_get_visible (GtkActionGroup
691			-- *action_group);
692		external "C use <gtk/gtk.h>"
693		end
694
695	gtk_action_group_set_visible (an_action_group: POINTER; a_setting: INTEGER) is
696			-- void gtk_action_group_set_visible (GtkActionGroup
697			-- *action_group, gboolean visible);
698		external "C use <gtk/gtk.h>"
699		end
700
701	gtk_action_group_get_action (an_action_group, a_action_name: POINTER): POINTER is
702			-- GtkAction*  gtk_action_group_get_action (GtkActionGroup *action_group, const gchar *action_name);
703		external "C use <gtk/gtk.h>"
704		end
705
706	gtk_action_group_list_actions (an_action_group: POINTER): POINTER is
707			-- GList* gtk_action_group_list_actions (GtkActionGroup
708			-- *action_group);
709		external "C use <gtk/gtk.h>"
710		end
711
712	gtk_action_group_add_action (an_action_group, an_action: POINTER) is
713			-- void gtk_action_group_add_action (GtkActionGroup
714			-- *action_group, GtkAction *action);
715		external "C use <gtk/gtk.h>"
716		end
717
718	gtk_action_group_add_action_with_accel (an_action_group, an_action, an_accelerator: POINTER) is
719			-- void gtk_action_group_add_action_with_accel
720			-- (GtkActionGroup *action_group, GtkAction *action, const
721			-- gchar *accelerator);
722		external "C use <gtk/gtk.h>"
723		end
724
725	gtk_action_group_remove_action (an_action_group, an_action: POINTER) is
726			-- void gtk_action_group_remove_action (GtkActionGroup
727			-- *action_group, GtkAction *action);
728		external "C use <gtk/gtk.h>"
729		end
730
731	--             GtkActionEntry;
732	
733	gtk_action_group_add_actions (an_action_group, some_entries: POINTER; guint_n_entries: INTEGER; user_data: POINTER) is
734			-- void gtk_action_group_add_actions (GtkActionGroup
735			-- *action_group, const GtkActionEntry *entries, guint
736			-- n_entries, gpointer user_data);
737
738			-- TODO: guint_n_entries should be NATURAL since it is a guint
739		external "C use <gtk/gtk.h>"
740		end
741	
742	gtk_action_group_add_actions_full (an_action_group, some_entries: POINTE; guint_n_entries: INTEGER; user_data, gdestroynotify: POINTER) is
743			-- void gtk_action_group_add_actions_full (GtkActionGroup
744			-- *action_group, const GtkActionEntry *entries, guint
745			-- n_entries, gpointer user_data, GDestroyNotify destroy);
746
747			-- TODO: guint_n_entries should be NATURAL since it is a guint
748		external "C use <gtk/gtk.h>"
749		end
750
751	--             GtkToggleActionEntry;
752
753	gtk_action_group_add_toggle_actions (an_action_group, some_entrires: POINTER; guint_n_entries: INTEGER; user_data: POINTER) is
754			-- void gtk_action_group_add_toggle_actions (GtkActionGroup
755			-- *action_group, const GtkToggleActionEntry *entries, guint
756			-- n_entries, gpointer user_data);
757
758			-- TODO: guint_n_entries should be NATURAL since it is a guint
759		external "C use <gtk/gtk.h>"
760		end
761	
762	gtk_action_group_add_toggle_actions_full (an_action_group, some_entries: POINTER; guint_n_entries: INTEGER; user_data, gdestroynotify: POINTER) is
763			-- void gtk_action_group_add_toggle_actions_full
764			-- (GtkActionGroup *action_group, const GtkToggleActionEntry
765			-- *entries, guint n_entries, gpointer user_data,
766			-- GDestroyNotify destroy);
767
768			-- TODO: guint_n_entries should be NATURAL since it is a guint
769		external "C use <gtk/gtk.h>"
770		end
771
772	-- GtkRadioActionEntry;
773	
774	gtk_action_group_add_radio_actions (an_action_group, some_entries: POINTER; guint_n_entries, a_value: INTEGER; on_change_gcallback, user_data: POINTER) is
775			-- void gtk_action_group_add_radio_actions (GtkActionGroup
776			-- *action_group, const GtkRadioActionEntry *entries, guint
777			-- n_entries, gint value, GCallback on_change, gpointer
778			-- user_data);
779
780			-- TODO: guint_n_entries should be NATURAL since it is a guint
781		external "C use <gtk/gtk.h>"
782		end
783	
784	gtk_action_group_add_radio_actions_full (an_action_group, some_entries: POINTER; guint_n_entries, a_value: INTEGER; on_change_gcallback, user_data, gdestroynotify: POINTER) is
785			-- void gtk_action_group_add_radio_actions_full
786			-- (GtkActionGroup *action_group, const GtkRadioActionEntry
787			-- *entries, guint n_entries, gint value, GCallback
788			-- on_change, gpointer user_data, GDestroyNotify destroy);
789
790			-- TODO: guint_n_entries should be NATURAL since it is a guint
791		external "C use <gtk/gtk.h>"
792		end
793
794	gtk_action_group_set_translate_func (an_action_group, a_gtktranslatefunc, some_data, a_gtkdestroynotify: POINTER) is
795			-- void gtk_action_group_set_translate_func (GtkActionGroup
796			-- *action_group, GtkTranslateFunc func, gpointer data,
797			-- GtkDestroyNotify notify);
798		external "C use <gtk/gtk.h>"
799		end
800	
801	gtk_action_group_set_translation_domain (an_action_group, a_domain: POINTER) is
802			-- void gtk_action_group_set_translation_domain
803			-- (GtkActionGroup *action_group, const gchar *domain);
804		external "C use <gtk/gtk.h>"
805		end
806
807	gtk_action_group_translate_string (an_action_group, a_string: POINTER): POINTER is
808			-- const gchar* gtk_action_group_translate_string
809			-- (GtkActionGroup *action_group, const gchar *string);
810		external "C use <gtk/gtk.h>"
811		end
812end -- class GTK_ACTION_GROUP