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