/src/wrappers/gtk/library/gtk_action_group.e
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