lib/gtk3_4/gtk_core.nit

   1 # This file is part of NIT ( http://www.nitlanguage.org ).
   2 #
   3 # Copyright 2011-2013 Alexis Laferrière <alexis.laf@xymus.net>
   4 # Copyright 2013 Nathan Heu <heu.nathan@courrier.uqam.ca>
   5 #
   6 # Licensed under the Apache License, Version 2.0 (the "License");
   7 # you may not use this file except in compliance with the License.
   8 # You may obtain a copy of the License at
   9 #
  10 #     http://www.apache.org/licenses/LICENSE-2.0
  11 #
  12 # Unless required by applicable law or agreed to in writing, software
  13 # distributed under the License is distributed on an "AS IS" BASIS,
  14 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  15 # See the License for the specific language governing permissions and
  16 # limitations under the License.
  17
  18 # Classes and services to use libGTK widgets
  19 module gtk_core
  20 import gtk_enums
  21 import gdk_enums
  22
  23 in "C Header" `{
  24         #include <gtk/gtk.h>
  25 `}
  26
  27 `{
  28                 /* callback user data */
  29                 typedef struct {
  30                         GtkCallable to_call;
  31                         nullable_Object user_data;
  32                 } NitGtkSignal;
  33
  34                 void nit_gtk_callback_func( GtkWidget *widget,
  35                                                         gpointer   callback_data ) {
  36                         NitGtkSignal *data;
  37                         data = (NitGtkSignal*)callback_data;
  38                         GtkCallable_signal( data->to_call, widget, data->user_data );
  39                 }
  40 `}
  41
  42 redef interface Object
  43         protected fun init_gtk `{ gtk_init( 0, NULL ); `}
  44         protected fun run_gtk `{ gtk_main(); `}
  45         protected fun quit_gtk `{ gtk_main_quit(); `}
  46 end
  47
  48 interface GtkCallable
  49         # return true to stop event processing, false to let it propagate
  50         fun signal( sender : GtkWidget, user_data : nullable Object ) is abstract
  51 end
  52
  53 extern GdkEvent `{GdkEvent *`}
  54 end
  55
  56
  57 #Base class for all widgets
  58 #@https://developer.gnome.org/gtk3/stable/GtkWidget.html
  59 extern GtkWidget `{GtkWidget *`}
  60         fun show_all is extern `{ gtk_widget_show_all( recv ); `}
  61
  62         fun signal_connect( signal_name : String, to_call : GtkCallable, user_data : nullable Object ) is extern import String::to_cstring, GtkCallable::signal, Object as not nullable `{
  63                 NitGtkSignal *data = malloc( sizeof(NitGtkSignal) );
  64
  65                 GtkCallable_incr_ref( to_call );
  66                 Object_incr_ref( user_data );
  67
  68                 data->to_call = to_call;
  69                 data->user_data = user_data;
  70
  71                 /*Use G_CALLBACK() to cast the callback function to a GCallback*/
  72                 g_signal_connect( recv,
  73                                                         String_to_cstring( signal_name ),
  74                                                         G_CALLBACK(nit_gtk_callback_func),
  75                                                         data );
  76         `}
  77
  78         redef fun == ( o ) do return o isa GtkWidget and equal_to_gtk_widget( o )
  79
  80         private fun equal_to_gtk_widget( o : GtkWidget ) : Bool `{
  81                 return recv == o;
  82         `}
  83
  84         fun request_size( width, height : Int ) `{
  85                 gtk_widget_set_size_request( recv, width, height );
  86         `}
  87
  88         fun bg_color=( state : GtkStateType, color : GdkRGBA ) is extern `{
  89                 gtk_widget_override_background_color( recv, state, color);
  90         `}
  91
  92         #with gtk it's possible to set fg_color to all widget : is it correct? is fg color inherited?
  93         #GdkColor color;
  94         fun fg_color=( state : GtkStateType, color : GdkRGBA ) is extern `{
  95                 gtk_widget_override_color( recv, state, color);
  96         `}
  97
  98         # Sets the sensitivity of a widget. sensitive -> the user can interact with it.
  99         # Insensitive -> widget "grayed out" and the user can"t interact with them
 100         fun sensitive=(sensitive : Bool) is extern `{
 101                 gtk_widget_set_sensitive(recv, sensitive);
 102         `}
 103
 104         # return the sensitivity of the widget
 105         fun sensitive: Bool is extern `{
 106                 return gtk_widget_get_sensitive(recv);
 107         `}
 108 end
 109
 110 #Base class for widgets which contain other widgets
 111 #@https://developer.gnome.org/gtk3/stable/GtkContainer.html
 112 extern GtkContainer `{GtkContainer *`}
 113         super GtkWidget
 114
 115         # Add a widget to the container
 116         fun add( widget : GtkWidget ) is extern `{
 117                 gtk_container_add( recv, widget );
 118         `}
 119 end
 120
 121 #A container with just one child
 122 #@https://developer.gnome.org/gtk3/stable/GtkBin.html
 123 extern GtkBin `{GtkBin *`}
 124         super GtkContainer
 125
 126         fun child : GtkWidget is extern `{
 127                 return gtk_bin_get_child( recv );
 128         `}
 129 end
 130
 131 #Toplevel which can contain other widgets
 132 #@https://developer.gnome.org/gtk3/stable/GtkWindow.html
 133 extern GtkWindow `{GtkWindow *`}
 134         super GtkBin
 135
 136         new ( flag : Int ) is extern `{
 137                 GtkWindow *win;
 138
 139                 win = GTK_WINDOW(gtk_window_new( flag ));
 140                 g_signal_connect(win, "destroy", G_CALLBACK(gtk_main_quit), NULL);
 141                 return win;
 142         `}
 143
 144         fun title=( title : String ) is extern import String::to_cstring `{
 145                 gtk_window_set_title( recv, String_to_cstring( title ) );
 146         `}
 147
 148         #The "destroy" signal is emitted when a widget is destroyed, either by explicitly calling gtk_widget_destroy() or when the widget is unparented. Top-level GtkWindows are also destroyed when the Close window control button is clicked.
 149         fun on_close( to_call : GtkCallable, user_data : nullable Object )
 150         do
 151                 signal_connect( "destroy", to_call, user_data )
 152         end
 153
 154         fun resizable : Bool is extern `{
 155                 return gtk_window_get_resizable( recv );
 156         `}
 157
 158         fun resizable=( is_resizable : Bool) is extern `{
 159                 return gtk_window_set_resizable( recv, is_resizable );
 160         `}
 161
 162         #Activates the current focused widget within the window.
 163         #returns TRUE if a widget got activated.
 164         fun activate_focus : Bool is extern `{
 165                 return gtk_window_activate_focus( recv );
 166         `}
 167
 168         #Sets a window modal or non-modal. Modal windows prevent interaction with other windows in the same application.
 169         fun modal=( is_modal : Bool ) is extern `{
 170                 gtk_window_set_modal( recv, is_modal );
 171         `}
 172
 173         #Windows can't actually be 0x0 in size, they must be at least 1x1
 174         #but passing 0 for width and height is OK, resulting in a 1x1 default size.
 175         #params width in pixels, or -1 to unset the default width
 176         #params height in pixels, or -1 to unset the default height
 177         fun default_size( width : Int, height : Int ) is extern `{
 178                 gtk_window_set_default_size( recv, width, height );
 179         `}
 180
 181         #Activates the default widget for the window
 182         #unless the current focused widget has been configured to receive the default action (see gtk_widget_set_receives_default()), in which case the focused widget is activated.
 183         fun activate_default : Bool is extern `{
 184                 return gtk_window_activate_default( recv );
 185         `}
 186
 187         fun gravity : GdkGravity is extern `{
 188                 return gtk_window_get_gravity( recv );
 189         `}
 190
 191         fun gravity=( window_grav : GdkGravity ) is extern `{
 192                 gtk_window_set_gravity( recv, window_grav );
 193         `}
 194
 195 #       fun position : GtkWindowPosition is extern `{
 196 #               return gtk_window_get_position( recv );
 197 #       `}
 198 #
 199 #       fun position=( window_pos : GtkWindowPosition ) is extern `{
 200 #               gtk_window_set_position( recv, window_pos );
 201 #       `}
 202
 203         fun active : Bool is extern `{
 204                 return gtk_window_is_active( recv );
 205         `}
 206
 207         #Returns whether the input focus is within this GtkWindow. For real toplevel windows, this is identical to gtk_window_is_active(), but for embedded windows, like GtkPlug, the results will differ.
 208         fun has_toplevel_focus : Bool is extern `{
 209                 return gtk_window_has_toplevel_focus( recv );
 210         `}
 211
 212         fun get_focus : GtkWidget is extern `{
 213                 return gtk_window_get_focus( recv );
 214         `}
 215
 216         fun set_focus( widget : GtkWidget ) is extern `{
 217                 return gtk_window_set_focus( recv, widget );
 218         `}
 219
 220         fun get_default_widget : GtkWidget is extern `{
 221                 return gtk_window_get_default_widget( recv );
 222         `}
 223
 224         fun set_default_widget( widget : GtkWidget ) is extern `{
 225                 return gtk_window_set_default( recv, widget );
 226         `}
 227
 228         fun maximize is extern `{
 229                 return gtk_window_maximize( recv );
 230         `}
 231
 232         fun unmaximize is extern `{
 233                 return gtk_window_unmaximize( recv );
 234         `}
 235
 236         fun fullscreen is extern `{
 237                 return gtk_window_fullscreen( recv );
 238         `}
 239
 240         fun unfullscreen is extern `{
 241                 return gtk_window_unfullscreen( recv );
 242         `}
 243
 244         fun keep_above=( setting : Bool ) is extern `{
 245                 gtk_window_set_keep_above( recv, setting );
 246         `}
 247
 248         fun keep_below=( setting : Bool ) is extern `{
 249                 gtk_window_set_keep_below( recv, setting );
 250         `}
 251 end
 252
 253 #A bin with a decorative frame and optional label
 254 #https://developer.gnome.org/gtk3/stable/GtkFrame.html
 255 extern GtkFrame `{GtkFrame *`}
 256         super GtkBin
 257
 258         new ( lbl : String ) is extern import String::to_cstring`{
 259                 return (GtkFrame *)gtk_frame_new( String_to_cstring( lbl ) );
 260         `}
 261
 262         fun frame_label : String is extern`{
 263                 return NativeString_to_s( (char *)gtk_frame_get_label( recv ) );
 264         `}
 265
 266         fun frame_label=( lbl : String ) is extern import String::to_cstring`{
 267                 gtk_frame_set_label( recv, String_to_cstring( lbl ) );
 268         `}
 269
 270         fun label_widget : GtkWidget is extern `{
 271                 return gtk_frame_get_label_widget( recv );
 272         `}
 273
 274         fun label_widget=( widget : GtkWidget ) is extern `{
 275                 gtk_frame_set_label_widget( recv, widget );
 276         `}
 277
 278         fun shadow_type : GtkShadowType is extern `{
 279                 return gtk_frame_get_shadow_type( recv );
 280         `}
 281
 282         fun shadow_type=( stype : GtkShadowType ) is extern `{
 283                 gtk_frame_set_shadow_type( recv, stype );
 284         `}
 285
 286         #fun label_align : GtkShadowType is extern `{
 287         #`}
 288
 289         fun label_align=( xalign : Float, yalign : Float ) is extern `{
 290                 gtk_frame_set_label_align( recv, xalign, yalign );
 291         `}
 292 end
 293
 294 #Pack widgets in a rows and columns
 295 #@https://developer.gnome.org/gtk3/3.3/GtkGrid.html
 296 extern GtkGrid `{GtkGrid *`}
 297         super GtkContainer
 298
 299         # Create a grid with a fixed number of rows and columns
 300         new ( rows : Int, columns : Int, homogeneous : Bool ) `{
 301                 return (GtkGrid*)gtk_grid_new(); // rows, columns, homogeneous );
 302         `}
 303
 304         # Set a widget child inside the grid at a given position
 305         fun attach( child : GtkWidget, left, top, width, height : Int ) `{
 306                 gtk_grid_attach( recv, child, left, top, width, height );
 307         `}
 308 end
 309
 310 #The tree interface used by GtkTreeView
 311 #@https://developer.gnome.org/gtk3/stable/GtkTreeModel.html
 312 extern GtkTreeModel `{GtkTreeModel *`}
 313 end
 314
 315 #An abstract class for laying out GtkCellRenderers
 316 #@https://developer.gnome.org/gtk3/stable/GtkCellArea.html
 317 extern GtkCellArea `{GtkCellArea *`}
 318 end
 319
 320 #Base class for widgets with alignments and padding
 321 #@https://developer.gnome.org/gtk3/3.2/GtkMisc.html
 322 extern GtkMisc `{GtkMisc *`}
 323         super GtkWidget
 324
 325         fun alignment : GtkAlignment is abstract
 326
 327         fun alignment=( x : Float, y : Float ) is extern `{
 328                 gtk_misc_set_alignment( recv, x, y );
 329         `}
 330
 331         fun padding : GtkAlignment is abstract
 332
 333         fun padding=( x : Float, y : Float ) is extern `{
 334                 gtk_misc_set_padding( recv, x, y );
 335         `}
 336
 337 end
 338
 339 #A single line text entry field
 340 #@https://developer.gnome.org/gtk3/3.2/GtkEntry.html
 341 extern GtkEntry `{GtkEntry *`}
 342         super GtkWidget
 343
 344         new is extern `{
 345                  return (GtkEntry *)gtk_entry_new();
 346         `}
 347
 348         fun text : String is extern import String::to_cstring`{
 349                 return NativeString_to_s( (char *)gtk_entry_get_text( recv ) );
 350         `}
 351
 352         fun text=( value : String) is extern import String::to_cstring`{
 353                 gtk_entry_set_text( recv, String_to_cstring( value ) );
 354         `}
 355
 356         fun visible : Bool is extern `{
 357                 return gtk_entry_get_visibility( recv );
 358         `}
 359
 360         fun visible=( is_visible : Bool) is extern `{
 361                 gtk_entry_set_visibility( recv, is_visible );
 362         `}
 363
 364         fun max_length : Int is extern `{
 365                 return gtk_entry_get_max_length( recv );
 366         `}
 367
 368         fun max_length=( max : Int) is extern `{
 369                 gtk_entry_set_max_length( recv, max );
 370         `}
 371 end
 372
 373 #Base class for widgets which visualize an adjustment
 374 #@https://developer.gnome.org/gtk3/3.2/GtkRange.html
 375 extern GtkRange `{GtkRange *`}
 376         super GtkWidget
 377
 378         #Gets the current position of the fill level indicator.
 379         fun fill_level : Float is extern `{
 380                 return gtk_range_get_fill_level( recv );
 381         `}
 382
 383         fun fill_level=( level : Float ) is extern `{
 384                 gtk_range_set_fill_level( recv, level );
 385         `}
 386
 387         #Gets whether the range is restricted to the fill level.
 388         fun restricted_to_fill_level : Bool is extern `{
 389                 return gtk_range_get_restrict_to_fill_level( recv );
 390         `}
 391
 392         fun restricted_to_fill_level=( restricted : Bool ) is extern `{
 393                 gtk_range_set_restrict_to_fill_level( recv, restricted );
 394         `}
 395
 396         #Gets whether the range displays the fill level graphically.
 397         fun show_fill_level : Bool is extern `{
 398                 return gtk_range_get_show_fill_level( recv );
 399         `}
 400
 401         fun show_fill_level=( is_displayed : Bool ) is extern `{
 402                 gtk_range_set_show_fill_level( recv, is_displayed );
 403         `}
 404
 405         fun adjustment : GtkAdjustment is extern `{
 406                 return gtk_range_get_adjustment( recv );
 407         `}
 408
 409         fun adjustment=( value : GtkAdjustment ) is extern `{
 410                 gtk_range_set_adjustment( recv, value );
 411         `}
 412
 413         fun inverted : Bool is extern `{
 414                 return gtk_range_get_inverted( recv );
 415         `}
 416
 417         fun inverted=( setting : Bool ) is extern `{
 418                 gtk_range_set_inverted( recv, setting );
 419         `}
 420
 421         fun value : Float is extern `{
 422                 return gtk_range_get_value( recv );
 423         `}
 424
 425         fun value=( val : Float ) is extern `{
 426                 gtk_range_set_value( recv, val );
 427         `}
 428
 429         fun set_increments( step : Float, page : Float ) is extern `{
 430                 gtk_range_set_increments( recv, step, page );
 431         `}
 432
 433         fun set_range( min : Float, max : Float ) is extern `{
 434                 gtk_range_set_range( recv, min, max );
 435         `}
 436
 437         fun round_digits : Int is extern `{
 438                 return gtk_range_get_round_digits( recv );
 439         `}
 440
 441         fun round_digits=( nb : Int ) is extern `{
 442                 gtk_range_set_round_digits( recv, nb );
 443         `}
 444
 445         fun size_fixed : Bool is extern `{
 446                 return gtk_range_get_slider_size_fixed( recv );
 447         `}
 448
 449         fun size_fixed=( is_fixed : Bool ) is extern `{
 450                 return gtk_range_set_slider_size_fixed( recv, is_fixed );
 451         `}
 452
 453         fun flippable : Bool is extern `{
 454                 return gtk_range_get_flippable( recv );
 455         `}
 456
 457         fun min_size=( is_flippable : Bool ) is extern `{
 458                 return gtk_range_set_flippable( recv, is_flippable );
 459         `}
 460
 461         fun min_slider_size : Int is extern `{
 462                 return gtk_range_get_min_slider_size( recv );
 463         `}
 464
 465         fun min_slider_size=( size : Int ) is extern `{
 466                 return gtk_range_set_min_slider_size( recv, size );
 467         `}
 468 end
 469
 470 #A slider widget for selecting a value from a range
 471 #@https://developer.gnome.org/gtk3/3.2/GtkScale.html
 472 extern GtkScale `{GtkScale *`}
 473         super GtkRange
 474
 475         new ( orientation : GtkOrientation, adjustment : GtkAdjustment ) is extern `{
 476                 return (GtkScale *)gtk_scale_new( orientation, adjustment );
 477         `}
 478
 479         new with_range ( orientation : GtkOrientation, min : Float, max : Float, step : Float ) is extern `{
 480                 return (GtkScale *)gtk_scale_new_with_range( orientation, min, max, step );
 481         `}
 482
 483         fun digits : Int is extern `{
 484                 return gtk_scale_get_digits( recv );
 485         `}
 486
 487         fun digits=( nb_digits : Int ) is extern `{
 488                 gtk_scale_set_digits( recv, nb_digits );
 489         `}
 490
 491         fun draw_value : Bool is extern `{
 492                 return gtk_scale_get_draw_value( recv );
 493         `}
 494
 495         fun draw_value=( is_displayed : Bool ) is extern `{
 496                 gtk_scale_set_draw_value( recv, is_displayed );
 497         `}
 498
 499         fun value_position : GtkPositionType is extern `{
 500                 return gtk_scale_get_value_pos( recv );
 501         `}
 502
 503         fun value_position=( pos : GtkPositionType ) is extern `{
 504                 gtk_scale_set_value_pos( recv, pos );
 505         `}
 506
 507         fun has_origin : Bool is extern `{
 508                 return gtk_scale_get_has_origin( recv );
 509         `}
 510
 511         fun has_origin=( orig : Bool ) is extern `{
 512                 gtk_scale_set_has_origin( recv, orig );
 513         `}
 514
 515         fun add_mark( value : Float, position : GtkPositionType, markup : String ) is extern import String::to_cstring`{
 516                 gtk_scale_add_mark( recv, value, position, String_to_cstring( markup ) );
 517         `}
 518
 519         #Removes any marks that have been added with gtk_scale_add_mark().
 520         fun clear_marks is extern `{
 521                 gtk_scale_clear_marks( recv );
 522         `}
 523
 524         #get layout
 525         #get layout offsets
 526
 527 end
 528
 529 #A scrollbar
 530 #@https://developer.gnome.org/gtk3/3.2/GtkScrollbar.html
 531 extern GtkScrollbar `{GtkScrollbar *`}
 532         super GtkRange
 533
 534                 new ( orientation : GtkOrientation, adjustment : GtkAdjustment ) is extern `{
 535                 return (GtkScrollbar *)gtk_scrollbar_new( orientation, adjustment );
 536         `}
 537 end
 538
 539 #A widget that displays a small to medium amount of text
 540 #@https://developer.gnome.org/gtk3/3.2/GtkLabel.html
 541 extern GtkLabel `{GtkLabel *`}
 542         super GtkMisc
 543
 544         # Create a GtkLabel with text
 545         new ( text : String ) is extern import String::to_cstring `{
 546                 return (GtkLabel*)gtk_label_new( String_to_cstring( text ) );
 547         `}
 548
 549         # Set the text of the label
 550         fun text=( text : String ) import String::to_cstring `{
 551                 gtk_label_set_text( recv, String_to_cstring( text ) );
 552         `}
 553
 554         # Returns the text of the label
 555         fun text : String import NativeString::to_s `{
 556                 return NativeString_to_s( (char*)gtk_label_get_text( recv ) );
 557         `}
 558
 559         # Sets the angle of rotation for the label.
 560         # An angle of 90 reads from from bottom to top, an angle of 270, from top to bottom.
 561         fun angle=( degre : Float ) `{
 562                 gtk_label_set_angle( recv, degre );
 563         `}
 564
 565         # Returns the angle of rotation for the label.
 566         fun angle : Float `{
 567                 return gtk_label_get_angle( recv );
 568         `}
 569
 570 end
 571
 572 #A widget displaying an image
 573 #@https://developer.gnome.org/gtk3/3.2/GtkImage.html
 574 extern GtkImage `{GtkImage *`}
 575         super GtkMisc
 576
 577         # Create a GtkImage
 578         new is extern `{
 579                 return (GtkImage*)gtk_image_new( );
 580         `}
 581
 582         # Create a GtkImage with text
 583         new file( filename : String ) is extern import String::to_cstring `{
 584                 return (GtkImage*)gtk_image_new_from_file( String_to_cstring( filename ) );
 585         `}
 586
 587         fun pixel_size : Int is extern `{
 588                 return gtk_image_get_pixel_size( recv );
 589         `}
 590
 591         fun pixel_size=( size : Int) is extern `{
 592                 gtk_image_set_pixel_size( recv, size );
 593         `}
 594
 595         fun clear is extern `{
 596                 gtk_image_clear( recv );
 597         `}
 598 end
 599
 600 #enum GtkImageType
 601 #Describes the image data representation used by a GtkImage.
 602 #@https://developer.gnome.org/gtk3/3.2/GtkImage.html#GtkImageType
 603 extern GtkImageType `{GtkImageType`}
 604         # There is no image displayed by the widget.
 605         new empty `{ return GTK_IMAGE_EMPTY; `}
 606
 607         # The widget contains a GdkPixbuf.
 608         new pixbuf `{ return GTK_IMAGE_PIXBUF; `}
 609
 610         # The widget contains a stock icon name.
 611         new stock `{ return GTK_IMAGE_STOCK; `}
 612
 613         # The widget contains a GtkIconSet.
 614         new icon_set `{ return GTK_IMAGE_ICON_SET; `}
 615
 616         # The widget contains a GdkPixbufAnimation.
 617         new animation `{ return GTK_IMAGE_ANIMATION; `}
 618
 619         # The widget contains a named icon.
 620         new icon_name `{ return GTK_IMAGE_ICON_NAME; `}
 621
 622         # The widget contains a GIcon.
 623         new gicon `{ return GTK_IMAGE_GICON; `}
 624 end
 625
 626 #Displays an arrow
 627 #@https://developer.gnome.org/gtk3/3.2/GtkArrow.html
 628 extern GtkArrow `{GtkArrow *`}
 629         super GtkMisc
 630
 631         new ( arrow_type : GtkArrowType, shadow_type : GtkShadowType ) is extern `{
 632                 return (GtkArrow *)gtk_arrow_new( arrow_type, shadow_type );
 633         `}
 634
 635         fun set( arrow_type : GtkArrowType, shadow_type : GtkShadowType ) is extern `{
 636                 gtk_arrow_set( recv, arrow_type, shadow_type );
 637         `}
 638 end
 639
 640 #A widget that emits a signal when clicked on
 641 #@https://developer.gnome.org/gtk3/stable/GtkButton.html
 642 extern GtkButton `{GtkButton *`}
 643         super GtkBin
 644
 645         new is extern `{
 646                 return (GtkButton *)gtk_button_new(  );
 647         `}
 648
 649         #Create a GtkButton with text
 650         new with_label( text : String ) is extern import String::to_cstring `{
 651                 return (GtkButton *)gtk_button_new_with_label( String_to_cstring( text ) );
 652         `}
 653
 654         new from_stock( stock_id : String ) is extern import String::to_cstring `{
 655                 return (GtkButton *)gtk_button_new_from_stock( String_to_cstring( stock_id ) );
 656         `}
 657
 658         fun text : String is extern `{
 659                 return NativeString_to_s( (char *)gtk_button_get_label( recv ) );
 660         `}
 661
 662         fun text=( value : String ) is extern import String::to_cstring`{
 663                 gtk_button_set_label( recv, String_to_cstring( value ) );
 664         `}
 665
 666         fun on_click( to_call : GtkCallable, user_data : nullable Object ) do
 667                         signal_connect( "clicked", to_call, user_data )
 668         end
 669
 670 end
 671
 672 #A button which pops up a scale
 673 #@https://developer.gnome.org/gtk3/stable/GtkScaleButton.html
 674 extern GtkScaleButton `{GtkScaleButton *`}
 675         super GtkButton
 676
 677         #const gchar **icons
 678         new( size: GtkIconSize, min: Float, max: Float, step: Float ) is extern `{
 679                 return (GtkScaleButton *)gtk_scale_button_new( size, min, max, step, (const char **)0 );
 680         `}
 681 end
 682
 683 #Create buttons bound to a URL
 684 #@https://developer.gnome.org/gtk3/stable/GtkLinkButton.html
 685 extern GtkLinkButton `{GtkLinkButton *`}
 686         super GtkButton
 687
 688         new( uri: String ) is extern import String::to_cstring `{
 689                 return (GtkLinkButton *)gtk_link_button_new( String_to_cstring(uri) );
 690         `}
 691 end
 692
 693 #A container which can hide its child
 694 #https://developer.gnome.org/gtk3/stable/GtkExpander.html
 695 extern GtkExpander `{GtkExpander *`}
 696         super GtkBin
 697
 698         new( lbl : String) is extern import String::to_cstring`{
 699                 return (GtkExpander *)gtk_expander_new( String_to_cstring( lbl ) );
 700         `}
 701
 702         new with_mnemonic( lbl : String) is extern import String::to_cstring`{
 703                 return (GtkExpander *)gtk_expander_new_with_mnemonic(String_to_cstring( lbl ));
 704         `}
 705
 706         fun expanded : Bool is extern `{
 707                 return gtk_expander_get_expanded( recv );
 708         `}
 709
 710         fun expanded=( is_expanded : Bool ) is extern `{
 711                 gtk_expander_set_expanded( recv, is_expanded );
 712         `}
 713
 714         fun spacing : Int is extern `{
 715                 return gtk_expander_get_spacing( recv );
 716         `}
 717
 718         fun spacing=( pixels : Int ) is extern `{
 719                 gtk_expander_set_spacing( recv, pixels );
 720         `}
 721
 722         fun label_text : String is extern `{
 723                 return NativeString_to_s( (char *)gtk_expander_get_label( recv ) );
 724         `}
 725
 726         fun label_text=( lbl : String ) is extern import String::to_cstring`{
 727                 gtk_expander_set_label( recv, String_to_cstring( lbl ) );
 728         `}
 729
 730         fun use_underline : Bool is extern `{
 731                 return gtk_expander_get_use_underline( recv );
 732         `}
 733
 734         fun use_underline=( used : Bool) is extern `{
 735                 gtk_expander_set_use_underline( recv, used );
 736         `}
 737
 738         fun use_markup : Bool is extern `{
 739                 return gtk_expander_get_use_markup( recv );
 740         `}
 741
 742         fun use_markup=( used : Bool) is extern `{
 743                  gtk_expander_set_use_markup( recv, used );
 744         `}
 745
 746         fun label_widget : GtkWidget is extern `{
 747                 return gtk_expander_get_label_widget( recv );
 748         `}
 749
 750         fun label_widget=( widget : GtkWidget ) is extern `{
 751                 gtk_expander_set_label_widget( recv, widget );
 752         `}
 753
 754         fun label_fill : Bool is extern `{
 755                 return gtk_expander_get_label_fill( recv );
 756         `}
 757
 758         fun label_fill=( fill : Bool ) is extern `{
 759                 gtk_expander_set_label_fill( recv, fill );
 760         `}
 761
 762         fun resize_toplevel : Bool is extern `{
 763                 return gtk_expander_get_resize_toplevel( recv );
 764         `}
 765
 766         fun resize_toplevel=( resize : Bool ) is extern `{
 767                 gtk_expander_set_resize_toplevel( recv, resize );
 768         `}
 769
 770 end
 771
 772 #An abstract class for laying out GtkCellRenderers
 773 #@https://developer.gnome.org/gtk3/stable/GtkCellArea.html
 774 extern GtkComboBox `{GtkComboBox *`}
 775         super GtkBin
 776
 777         new is extern `{
 778                 return (GtkComboBox *)gtk_combo_box_new( );
 779         `}
 780
 781         new with_entry is extern `{
 782                 return (GtkComboBox *)gtk_combo_box_new_with_entry( );
 783         `}
 784
 785         new with_model( model : GtkTreeModel ) is extern `{
 786                 return (GtkComboBox *)gtk_combo_box_new_with_model( model );
 787         `}
 788
 789         new with_model_and_entry( model : GtkTreeModel ) is extern `{
 790                 return (GtkComboBox *)gtk_combo_box_new_with_model_and_entry( model );
 791         `}
 792
 793         new with_area( area : GtkCellArea ) is extern `{
 794                 return (GtkComboBox *)gtk_combo_box_new_with_area( area );
 795         `}
 796
 797         new with_area_and_entry( area : GtkCellArea ) is extern `{
 798                 return (GtkComboBox *)gtk_combo_box_new_with_area_and_entry( area );
 799         `}
 800
 801         fun wrap_width : Int is extern `{
 802                 return gtk_combo_box_get_wrap_width( recv );
 803         `}
 804
 805         fun wrap_width=( width : Int ) is extern `{
 806                 gtk_combo_box_set_wrap_width( recv, width );
 807         `}
 808
 809         fun row_span_col : Int is extern `{
 810                 return gtk_combo_box_get_row_span_column( recv );
 811         `}
 812
 813         fun row_span_col=( row_span : Int ) is extern `{
 814                 gtk_combo_box_set_row_span_column( recv, row_span );
 815         `}
 816
 817         fun col_span_col : Int is extern `{
 818                 return gtk_combo_box_get_column_span_column( recv );
 819         `}
 820
 821         fun col_span_col=( col_span : Int ) is extern `{
 822                 gtk_combo_box_set_column_span_column( recv, col_span );
 823         `}
 824
 825         fun active_item : Int is extern `{
 826                 return gtk_combo_box_get_active( recv );
 827         `}
 828
 829         fun active_item=( active : Int ) is extern `{
 830                 gtk_combo_box_set_active( recv, active );
 831         `}
 832
 833         #fun active_iter : GtkTreeIter is extern `{
 834         #`}
 835         #
 836         #fun active_iter=( active : Bool ) is extern `{
 837         #`}
 838
 839         fun column_id : Int is extern `{
 840                 return gtk_combo_box_get_id_column( recv );
 841         `}
 842
 843         fun column_id=( id_column : Int ) is extern `{
 844                 gtk_combo_box_set_id_column( recv, id_column );
 845         `}
 846
 847         fun active_id : String is extern `{
 848                 return NativeString_to_s( (char *)gtk_combo_box_get_active_id( recv ) );
 849         `}
 850
 851         fun active_id=( id_active : String ) is extern import String::to_cstring`{
 852                 gtk_combo_box_set_active_id( recv, String_to_cstring( id_active ) );
 853         `}
 854
 855         fun model : GtkTreeModel is extern `{
 856                 return gtk_combo_box_get_model( recv );
 857         `}
 858
 859         fun model=( model : GtkTreeModel ) is extern `{
 860                 gtk_combo_box_set_model( recv, model );
 861         `}
 862
 863         fun popup is extern `{
 864                 gtk_combo_box_popup( recv );
 865         `}
 866
 867         fun popdown is extern `{
 868                 gtk_combo_box_popdown( recv );
 869         `}
 870
 871         fun title : String is extern`{
 872                 return NativeString_to_s( (char *)gtk_combo_box_get_title( recv ) );
 873         `}
 874
 875         fun title=( t : String ) is extern import String::to_cstring`{
 876                 gtk_combo_box_set_title( recv, String_to_cstring( t ) );
 877         `}
 878
 879         fun has_entry : Bool is extern `{
 880                 return gtk_combo_box_get_has_entry( recv );
 881         `}
 882
 883         fun with_fixed : Bool is extern `{
 884                 return gtk_combo_box_get_popup_fixed_width( recv );
 885         `}
 886
 887         fun with_fixed=( fixed : Bool ) is extern `{
 888                 gtk_combo_box_set_popup_fixed_width( recv, fixed );
 889         `}
 890 end
 891
 892 #Show a spinner animation
 893 #@https://developer.gnome.org/gtk3/3.2/GtkSpinner.html
 894 extern GtkSpinner `{GtkSpinner *`}
 895         super GtkWidget
 896
 897         new is extern `{
 898                  return (GtkSpinner *)gtk_spinner_new();
 899         `}
 900
 901         fun start is extern `{
 902                 return gtk_spinner_start( recv );
 903         `}
 904
 905         fun stop is extern `{
 906                 return gtk_spinner_stop( recv );
 907         `}
 908 end
 909
 910 #A "light switch" style toggle
 911 #@https://developer.gnome.org/gtk3/3.2/GtkSwitch.html
 912 extern GtkSwitch `{GtkSwitch *`}
 913         super GtkWidget
 914
 915         new is extern `{
 916                  return (GtkSwitch *)gtk_switch_new();
 917         `}
 918
 919         fun active : Bool is extern `{
 920                 return gtk_switch_get_active( recv );
 921         `}
 922
 923         fun active=( is_active : Bool ) is extern `{
 924                 return gtk_switch_set_active( recv, is_active );
 925         `}
 926 end
 927
 928
 929 #A widget which controls the alignment and size of its child
 930 #https://developer.gnome.org/gtk3/stable/GtkAlignment.html
 931 extern GtkAlignment `{GtkAlignment *`}
 932         super GtkBin
 933
 934         new ( xalign : Float, yalign : Float, xscale : Float, yscale : Float ) is extern `{
 935                 return (GtkAlignment *)gtk_alignment_new( xalign, yalign, xscale, yscale );
 936         `}
 937
 938         fun set ( xalign : Float, yalign : Float, xscale : Float, yscale : Float ) is extern `{
 939                 gtk_alignment_set( recv, xalign, yalign, xscale, yscale );
 940         `}
 941
 942         #get_padding
 943         #set_padding
 944 end
 945
 946 #A representation of an adjustable bounded value
 947 #@https://developer.gnome.org/gtk3/stable/GtkAdjustment.html#GtkAdjustment.description
 948 extern GtkAdjustment `{GtkAdjustment *`}
 949
 950 end
 951
 952 extern GdkColor `{GdkColor*`}
 953         new is extern `{
 954                 GdkColor * col = malloc(sizeof(GdkColor));
 955                 /*gdk_color_parse( "red", recv );*/
 956                 gdk_color_parse( "red", col);
 957                 return col;
 958         `}
 959 end
 960
 961 extern GdkRGBA `{GdkRGBA*`}
 962         new is extern `{
 963         `}
 964 end
 965