GTK2-Perl Tutorial [ALPHA]

# Use the TRUE and FALSE constants exported by the Glib module.
use Glib qw/TRUE FALSE/;
use Gtk2 '-init';

# This is a callback function. We simply say hello to the world, and destroy
# the window object in order to close the program.
sub hello
{
	my ($widget, $window) = @_;
	print "Hello, World\n";

	$window->destroy;
}

sub delete_event
{
	# If you return FALSE in the "delete_event" signal handler,
	# GTK will emit the "destroy" signal. Returning TRUE means
	# you don't want the window to be destroyed.
	# This is useful for popping up 'are you sure you want to quit?'
	# type dialogs.
	print "delete event occurred\n";

	# Change TRUE to FALSE and the main window will be destroyed with
	# a "delete_event".
	return TRUE;
}

# create a new window
$window = Gtk2::Window->new('toplevel');

# When the window is given the "delete_event" signal (this is given
# by the window manager, usually by the "close" option, or on the
# titlebar), we ask it to call the delete_event () functio
# as defined above. No data is passed to the callback function.
$window->signal_connect(delete_event => \&delete_event);

# Here we connect the "destroy" event to a signal handler.
# This event occurs when we call Gtk2::Widget::destroy on the window,
# or if we return FALSE in the "delete_event" callback. Perl supports
# anonymous subs, so we can use one of them for one line callbacks.
$window->signal_connect(destroy => sub { Gtk2->main_quit; });

# Sets the border width of the window.
$window->set_border_width(10);

# Creates a new button with a label "Hello World".
$button = Gtk2::Button->new("Hello World");

# When the button receives the "clicked" signal, it will call the function
# hello() with the window reference passed to it.The hello() function is
# defined above.
$button->signal_connect(clicked => \&hello, $window);

# This packs the button into the window (a gtk container).
$window->add($button);

# The final step is to display this newly created widget.
$button->show;

# and the window
$window->show;

# All GTK applications must have a call to the main() method. Control ends here
# and waits for an event to occur (like a key press or a mouse event).
Gtk2->main;

0;

unsigned Glib::Object->signal_connect($instance,
                                      $name,
			              $func,
				      $data=undef);

sub callback_func
{
	my ($widget, $data) = @_;
	
	#...
}

$instance->signal_connect($signal_name => sub {
		# ...
	});

$some_object->some_method();
$other_object->signal_connect($signal_name => sub {
		# ...
		$some_object->some_other_method();
	});

sub callback_func
{
	my ($widget, $event, $data) = @_;
	
	#...

	return $ret;
}

'nothing' / 'GDK_NOTHING'
'delete' / 'GDK_DELETE'
'destroy' / 'GDK_DESTROY'
'expose' / 'GDK_EXPOSE'
'motion-notify' / 'GDK_MOTION_NOTIFY'
'button-press' / 'GDK_BUTTON_PRESS'
'2button-press' / 'GDK_2BUTTON_PRESS'
'3button-press' / 'GDK_3BUTTON_PRESS'
'button-release' / 'GDK_BUTTON_RELEASE'
'key-press' / 'GDK_KEY_PRESS'
'key-release' / 'GDK_KEY_RELEASE'
'enter-notify' / 'GDK_ENTER_NOTIFY'
'leave-notify' / 'GDK_LEAVE_NOTIFY'
'focus-change' / 'GDK_FOCUS_CHANGE'
'configure' / 'GDK_CONFIGURE'
'map' / 'GDK_MAP'
'unmap' / 'GDK_UNMAP'
'property-notify' / 'GDK_PROPERTY_NOTIFY'
'selection-clear' / 'GDK_SELECTION_CLEAR'
'selection-request' / 'GDK_SELECTION_REQUEST'
'selection-notify' / 'GDK_SELECTION_NOTIFY'
'proximity-in' / 'GDK_PROXIMITY_IN'
'proximity-out' / 'GDK_PROXIMITY_OUT'
'drag-enter' / 'GDK_DRAG_ENTER'
'drag-leave' / 'GDK_DRAG_LEAVE'
'drag-motion' / 'GDK_DRAG_MOTION'
'drag-status' / 'GDK_DRAG_STATUS'
'drop-start' / 'GDK_DROP_START'
'drop-finished' / 'GDK_DROP_FINISHED'
'client-event' / 'GDK_CLIENT_EVENT'
'visibility-notify' / 'GDK_VISIBILITY_NOTIFY'
'no-expose' / 'GDK_NO_EXPOSE'
'scroll' / 'GDK_SCROLL'
'window-state' / 'GDK_WINDOW_STATE'
'setting' / 'GDK_SETTING'

$button->signal_connect(button_press_event => \&button_press_callback);

use Glib qw/TRUE FALSE/;

use Gtk2 '-init';

sub hello {
	my ($widget, $window) = @_;
	
	print "Hello, World\n";

	$window->destroy;
}

sub delete_event
{
    print "delete event occurred\n";

    return TRUE; 
}

$window = Gtk2::Window->new('toplevel');

$window->signal_connect(delete_event => \&delete_event);
$window->signal_connect(destroy => sub { Gtk2->main_quit; });

$window->set_border_width(10);

$button = Gtk2::Button->new("Hello World");

$button->signal_connect(clicked => \&hello, $window);

$window->add($button);

$button->show;

$window->show;

Gtk2->main;

0;

unsigned Glib::Object->signal_connect($instance,
                                      $name,
			              $func,
				      $data=undef);

Glib::Object->signal_handler_disconnect($instance, $id);

Glib::Object->signal_handler_block($instance, $id);

Glib::Object->signal_handlers_block_by_func($instance, $func, $data);

Glib::Object->signal_handler_unblock($instance, $id);

Glib::Object->signal_handlers_unblock_by_func($instance, $func, $data);

use Glib qw/TRUE FALSE/;
use Gtk2 '-init';

# Our new improved callback.  The data passed to this function
# is printed to stdout.
sub callback
{
	my ($button, $data) = @_;
	
	print "Hello again - $data was pressed\n";
}

# another callback
sub delete_event
{
	Gtk2->main_quit;
	return FALSE;
}

# Create a new window
$window = Gtk2::Window->new('toplevel');

# This is a new call, which just set the title for our
# new window to "Hello Buttons!"
$window->set_title("Hello Buttons!");

# Here we just set a handler for the delete_event that immediately
# exits GTK.
$window->signal_connect(delete_event => \&delete_event);

# Sets the border width of the window.
$window->set_border_width(10);

# We create a box to pack widgets into.  This is described in detail
# in the "packing" section. The box is not really visible, it
# is just used as a tool to arrange widgets.
$box1 = Gtk2::HBox->new(FALSE, 0);

# Put the box into the main window.
$window->add($box1);

# Creates a new button with the label "Button 1".
$button = Gtk2::Button->new("Button 1");

# Now when the button is clicked, we call the "callback" function
# with the string "button 1" as its argument.
$button->signal_connect(clicked => \&callback, 'button 1');

# Instead of Gtk2::Container::add, we pack this button into the invisible
# box, which has been packed into the window.
$box1->pack_start($button, TRUE, TRUE, 0);

# Always remember this step, this tells GTK that our preparation for this
# button is complete, and it can now be displayed.
$button->show;

# Do the same steps again to create a second button.
$button = Gtk2::Button->new("Button 2");

# Call the same callback function with a different argument, passing the string
# "button 2" instead.
$button->signal_connect(clicked => \&callback, 'button 2');

$box1->pack_start($button, TRUE, TRUE, 0);

# The order in which we show the buttons is not really important, but I
# recommend showing the window last, so it all pops up at once.

$button->show;

$box1->show;

$window->show;

# Rest in main and wait for the fun to begin!
Gtk2->main;

0;

Gtk2::Box->pack_start ($instance, $child, $expand, $fill, $padding);

$box = Gtk2->HBox->new($homogenous, $spacing);

use Glib qw/TRUE FALSE/;
use Gtk2 '-init';

sub delete_event
{
	Gtk2->main_quit;
	return FALSE;
}

# Make a new hbox filled with button-labels. Arguments for the 
# variables we're interested are passed in to this function. 
# We do not show the box, but do show everything inside.
sub make_box
{
	my ($homogeneous, $spacing, $expand, $fill, $padding) = @_;
	
	# Create a new hbox with the appropriate homogeneous
	# and spacing settings
	$box = Gtk2::HBox->new($homogenous, $spacing);

	# Create a series of buttons with the appropriate settings
	$button = Gtk2::Button->new("Gtk2::HBox::pack");
	$box->pack_start($button, $expand, $fill, $padding);
	$button->show;

	$button = Gtk2::Button->new("(box,");
	$box->pack_start($button, $expand, $fill, $padding);
	$button->show;

	$button = Gtk2::Button->new("button,");
	$box->pack_start($button, $expand, $fill, $padding);
	$button->show;
	
	# Create a button with the label depending on the value of $expand.
	if ($expand == TRUE)
	{
		$button = Gtk2::Button->new("TRUE,");
	}
	else
	{
		$button = Gtk2::Button->new("FALSE,");
	}

	$box->pack_start($button, $expand, $fill, $padding);
	$button->show;
	
	# This is the same as the button creation for "expand"
	# above, but uses the shorthand form.
	$button = Gtk2::Button->new($fill ? "TRUE," : "FALSE,");
	$box->pack_start($button, $expand, $fill, $padding);
	$button->show;

	$button = Gtk2::Button->new("$padding");
	$box->pack_start($button, $expand, $fill, $padding);
	$button->show;

	return $box;
}

die "usage: packbox.pl num, where num is 1, 2, or 3.\n"
	unless defined $ARGV[0];

# Create our window
$window = Gtk2::Window->new('toplevel');

# You should always remember to connect the delete_event signal
# to the main window. This is very important for proper intuitive
# behavior
$window->signal_connect(delete_event => \&delete_event);
$window->set_border_width(10);

# We create a vertical box (vbox) to pack the horizontal boxes into.
# This allows us to stack the horizontal boxes filled with buttons one
# on top of the other in this vbox.
$box1 = Gtk2::VBox->new(FALSE, 0);
$which = $ARGV[0];

# which example to show. These correspond to the pictures above.
if (1 == $which)
{
	# create a new label.
	$label = Gtk2::Label->new("Gtk2::HBox->new (FALSE, 0);");

	# Align the label to the left side.  We'll discuss this function and
	# others in the section on Widget Attributes.
	$label->set_alignment(0.0, 0.0);

	# Pack the label into the vertical box (vbox box1).  Remember that 
	# widgets added to a vbox will be packed one on top of the other in
	# order.
	$box1->pack_start($label, FALSE, FALSE, 0);

	# Show the label
	$label->show;

	# Call our make box function - homogeneous = FALSE, spacing = 0,
	# expand = FALSE, fill = FALSE, padding = 0
	$box2 = make_box(FALSE, 0, FALSE, FALSE, 0);
	$box1->pack_start($box2, FALSE, FALSE, 0);
	$box2->show;

	# Call our make box function - homogeneous = FALSE, spacing = 0,
	# expand = TRUE, fill = FALSE, padding = 0
	$box2 = make_box(FALSE, 0, TRUE, FALSE, 0);
	$box1->pack_start($box2, FALSE, FALSE, 0);
	$box2->show;

	# Args are: homogeneous, spacing, expand, fill, padding
	$box2 = make_box(FALSE, 0, TRUE, TRUE, 0);
	$box1->pack_start($box2, FALSE, FALSE, 0);
	$box2->show;

	# Creates a separator, we'll learn more about these later,
	# but they are quite simple.
	$separator = Gtk2::HSeparator->new;

	# Pack the separator into the vbox. Remember each of these
	# widgets is being packed into a vbox, so they'll be stacked
	# vertically.
	$box1->pack_start($separator, FALSE, TRUE, 5);
	$separator->show;

	# Create another new label, and show it.
	$label = Gtk2::Label->new("Gtk2::HBox->new (TRUE, 0);");
	$label->set_alignment(0.0, 0.0);
	$box1->pack_start($label, FALSE, FALSE, 0);
	$label->show;
	
	# Args are: homogeneous, spacing, expand, fill, padding
	$box2 = make_box(TRUE, 0, TRUE, FALSE, 0);
	$box1->pack_start($box2, FALSE, FALSE, 0);
	$box2->show;
	
	# Args are: homogeneous, spacing, expand, fill, padding
	$box2 = make_box(TRUE, 0, TRUE, TRUE, 0);
	$box1->pack_start($box2, FALSE, FALSE, 0);
	$box2->show;

	# Another new separator.
	$separator = Gtk2::HSeparator->new;
	# The last 3 arguments to gtk_box_pack_start are:
	# expand, fill, padding.
	$box1->pack_start($separator, FALSE, TRUE, 5);
	$separator->show;
}
elsif (2 == $which)
{
	# Create a new label, remember box1 is a vbox as created
	# near the beginning
	$label = Gtk2::Label->new("Gtk2::HBox->new (FALSE, 10);");
	$label->set_alignment(0.0, 0.0);
	$box1->pack_start($label, FALSE, FALSE, 0);
	$label->show;

	# Args are: homogeneous, spacing, expand, fill, padding
	$box2 = make_box(FALSE, 10, TRUE, FALSE, 0);
	$box1->pack_start($box2, FALSE, FALSE, 0);
	$box2->show;

	# Args are: homogeneous, spacing, expand, fill, padding
	$box2 = make_box(FALSE, 10, TRUE, TRUE, 0);
	$box1->pack_start($box2, FALSE, FALSE, 0);
	$box2->show;

	$separator = Gtk2::HSeparator->new;
	# The last 3 arguments to gtk_box_pack_start are:
	# expand, fill, padding.
	$box1->pack_start($separator, FALSE, TRUE, 5);
	$separator->show;

	$label = Gtk2::Label->new("Gtk2::HBox->new (FALSE, 0);");
	$label->set_alignment(0.0, 0.0);
	$box1->pack_start($label, FALSE, FALSE, 0);
	$label->show;

	# Args are: homogeneous, spacing, expand, fill, padding
	$box2 = make_box(FALSE, 0, TRUE, FALSE, 10);
	$box1->pack_start($box2, FALSE, FALSE, 0);
	$box2->show;

	# Args are: homogeneous, spacing, expand, fill, padding
	$box2 = make_box(FALSE, 0, TRUE, TRUE, 10);
	$box1->pack_start($box2, FALSE, FALSE, 0);
	$box2->show;

	$separator = Gtk2::HSeparator->new;
	# The last 3 arguments to gtk_box_pack_start are:
	# expand, fill, padding.
	$box1->pack_start($separator, FALSE, TRUE, 5);
	$separator->show;
}
elsif (3 == $which)
{
	# This demonstrates the ability to use gtk_box_pack_end() to
	# right justify widgets. First, we create a new box as before.
	$box2 = make_box(FALSE, 0, FALSE, FALSE, 0);

	# Create the label that will be put at the end.
	$label = Gtk2::Label->new("end");
	# Pack it using Gtk2::Box::pack_end(), so it is put on the right
	# side of the hbox created in the make_box() call.
	$box2->pack_end($label, FALSE, FALSE, 0);
	# Show the label.
	$label->show;

	# Pack box2 into box1 (the vbox remember ? :)
	$box1->pack_start($box2, FALSE, FALSE, 0);
	$box2->show;

	# A separator for the bottom.
	$separator = Gtk2::HSeparator->new;
	# This explicitly sets the separator to 400 pixels wide by 5 pixels
	# high. This is so the hbox we created will also be 400 pixels wide,
	# and the "end" label will be separated from the other labels in the
	# hbox. Otherwise, all the widgets in the hbox would be packed as
	# close together as possible.
	$separator->set_size_request(400, 5);
	# pack the separator into the vbox (box1) created near the start
	$box1->pack_start($separator, FALSE, TRUE, 5);
	$separator->show;
}

# Create another new hbox.. remember we can use as many as we need!
$quitbox = Gtk2::HBox->new(FALSE, 0);

# Our quit button.
$button = Gtk2::Button->new("Quit");

# Setup the signal to terminate the program when the button is clicked
$button->signal_connect(clicked => sub { Gtk2->main_quit; });

# Pack the button into the quitbox.
# The last 3 arguments to gtk_box_pack_start are:
# expand, fill, padding.
$quitbox->pack_start($button, TRUE, FALSE, 0);
# pack the quitbox into the vbox (box1)
$box1->pack_start($quitbox, FALSE, FALSE, 0);

# Pack the vbox (box1) which now contains all our widgets, into the
# main window.
$window->add($box1);

# And show everything left
$button->show;
$quitbox->show;

$box1->show;

# Showing the window last so everything pops up at once.
$window->show;

# And of course, our main function.
Gtk2->main;

# Control returns here when gtk_main_quit() is called, but not when
# exit() is used.
0;

$widget = Gtk2::Table->new ($rows, $columns, $homogeneous=FALSE)

 0          1          2
0+----------+----------+
 |          |          |
1+----------+----------+
 |          |          |
2+----------+----------+

Gtk2::Table->attach($table,
                    $child,
	            $left_attach, $right_attach,
		    $top_attach, $bottom_attach,
		    $xoptions, $yoptions,
		    $xpadding, $ypadding);

Gtk2::Table->attach_defaults($table,
                             $widget,
			     $left_attach, $right_attach,
			     $top_attach, $bottom_attach);

Gtk2::Table->set_row_spacing($table, $row, $spacing);

Gtk2::Table->set_col_spacing($table, $column, $spacing);

Gtk2::Table->set_row_spacings($table, $spacing);

Gtk2::Table->set_col_spacings($table, $spacing);

use Glib qw/TRUE FALSE/;
use Gtk2 '-init';

# Our callback.
# The data passed to this function is printed to stdout
sub callback
{
	my ($widget, $data) = @_;
	print "Hello again - $data was pressed\n";
}

# This callback quits the program
sub delete_event
{
	Gtk2->main_quit;
	return FALSE;
}

# Create a new window
$window = Gtk2::Window->new('toplevel');

# Set the window title
$window->set_title("Table");

# Set a handler for delete_event that immediately exits GTK.
$window->signal_connect(delete_event => \&delete_event);

# Sets the border width of the window.
$window->set_border_width(20);

# Create a 2x2 table
$table = Gtk2::Table->new(2, 2, TRUE);

# Put the table in the main window
$window->add($table);

# Create first button
$button = Gtk2::Button->new("button 1");

# When the button is clicked, we call the "callback" function
# with the string "button 1" as its argument
$button->signal_connect(clicked => \&callback, 'button 1');

# Insert button 1 into the upper left quadrant of the table
$table->attach_defaults($button, 0, 1, 0, 1);

$button->show;

# Create second button
$button = Gtk2::Button->new("button 2");

# When the button is clicked, we call the "callback" function
# with the string "button 2" as its argument
$button->signal_connect(clicked => \&callback, 'button 2');

# Insert button 2 into the upper right quadrant of the table
$table->attach_defaults($button, 1, 2, 0, 1);

$button->show;

# Create "Quit" button
$button = Gtk2::Button->new("Quit");

# When the button is clicked, we call the "delete_event" function
# and the program exits
$button->signal_connect(clicked => \&delete_event);

# Insert the quit button into the both lower quadrants of the table
$table->attach_defaults($button, 0, 2, 1, 2);

$button->show;

$table->show;
$window->show;

Gtk2->main;

0;

Glib::Object
 |  
 Gtk2::Object
  +Gtk2::Widget
  | +Gtk2::Misc
  | | +Gtk2::Label
  | | | `Gtk2::AccelLabel
  | | +Gtk2::Arrow
  | | `Gtk2::Image
  | +Gtk2::Container
  | | +Gtk2::Bin
  | | | +Gtk2::Alignment
  | | | +Gtk2::Frame
  | | | | `Gtk2::AspectFrame
  | | | +Gtk2::Button
  | | | | +Gtk2::ToggleButton
  | | | | | `Gtk2::CheckButton
  | | | | |   `Gtk2::RadioButton
  | | | | `Gtk2::OptionMenu
  | | | +Gtk2::Item
  | | | | +Gtk2::MenuItem
  | | | |   +Gtk2::CheckMenuItem
  | | | |   | `Gtk2::RadioMenuItem
  | | | |   +Gtk2::ImageMenuItem
  | | | |   +Gtk2::SeparatorMenuItem
  | | | |   `Gtk2::TearoffMenuItem
  | | | +Gtk2::Window
  | | | | +Gtk2::Dialog
  | | | | | +Gtk2::ColorSelectionDialog
  | | | | | +Gtk2::FileSelection
  | | | | | +Gtk2::FontSelectionDialog
  | | | | | +Gtk2::InputDialog
  | | | | | `Gtk2::MessageDialog
  | | | | `Gtk2::Plug
  | | | +Gtk2::EventBox
  | | | +Gtk2::HandleBox
  | | | +Gtk2::ScrolledWindow
  | | | `Gtk2::Viewport
  | | +Gtk2::Box
  | | | +Gtk2::ButtonBox
  | | | | +Gtk2::HButtonBox
  | | | | `Gtk2::VButtonBox
  | | | +Gtk2::VBox
  | | | | +Gtk2::ColorSelection
  | | | | +Gtk2::FontSelection
  | | | | `Gtk2::GammaCurve
  | | | `Gtk2::HBox
  | | |   +Gtk2::Combo
  | | |   `Gtk2::Statusbar
  | | +Gtk2::Fixed
  | | +Gtk2::Paned
  | | | +Gtk2::HPaned
  | | | `Gtk2::VPaned
  | | +Gtk2::Layout
  | | +Gtk2::MenuShell
  | | | +Gtk2::MenuBar
  | | | `Gtk2::Menu
  | | +Gtk2::Notebook
  | | +Gtk2::Socket
  | | +Gtk2::Table
  | | +Gtk2::TextView
  | | +Gtk2::Toolbar
  | | `Gtk2::TreeView
  | +Gtk2::Calendar
  | +Gtk2::DrawingArea
  | | `Gtk2::Curve
  | +Gtk2::Editable
  | | +Gtk2::Entry
  | |   `Gtk2::SpinButton
  | +Gtk2::Ruler
  | | +Gtk2::HRuler
  | | `Gtk2::VRuler
  | +Gtk2::Range
  | | +Gtk2::Scale
  | | | +Gtk2::HScale
  | | | `Gtk2::VScale
  | | `Gtk2::Scrollbar
  | |   +Gtk2::HScrollbar
  | |   `Gtk2::VScrollbar
  | +Gtk2::Separator
  | | +Gtk2::HSeparator
  | | `Gtk2::VSeparator
  | +Gtk2::Invisible
  | +Gtk2::Preview
  | `Gtk2::ProgressBar
  +Gtk2::Adjustment
  +Gtk2::CellRenderer
  | +Gtk2::CellRendererPixbuf
  | +Gtk2::CellRendererText
  | +Gtk2::CellRendererToggle
  +Gtk2::ItemFactory
  +Gtk2::Tooltips
  `Gtk2::TreeViewColumn

Gtk2::Alignment
Gtk2::Arrow
Gtk2::Bin
Gtk2::Box
Gtk2::Button
Gtk2::CheckButton
Gtk2::Fixed
Gtk2::Image
Gtk2::Label
Gtk2::MenuItem
Gtk2::Notebook
Gtk2::Paned
Gtk2::RadioButton
Gtk2::Range
Gtk2::ScrolledWindow
Gtk2::Separator
Gtk2::Table
Gtk2::Toolbar
Gtk2::AspectFrame
Gtk2::Frame
Gtk2::VBox
Gtk2::HBox
Gtk2::VSeparator
Gtk2::HSeparator

use Glib qw/TRUE FALSE/;
use Gtk2 '-init';

# Create a new hbox with an image and a label packed into it and return
# the box.
sub xpm_label_box {
	my ($xpm_filename, $label_text) = @_;

	# create box for image and label 
	my $box = Gtk2::HBox->new(FALSE, 0);
	$box->set_border_width(2);

	# now on to the image stuff
	my $image = Gtk2::Image->new_from_file($xpm_filename);
	
	# Create a label for the button
	my $label = Gtk2::Label->new($label_text);
	
	# pack the image and label into the box
	$box->pack_start($image, FALSE, FALSE, 3);
	$box->pack_start($label, FALSE, FALSE, 3);

	$image->show;
	$label->show;

	return $box
}

# our usual callback function
sub callback {
	my $widget = shift;
	my $data   = shift;
	printf "Hello again - %s was pressed\n", $data;
}

##################
# main starts here

# create a new window
my $window = Gtk2::Window->new('toplevel');

$window->set_title("Pixmap'd Buttons!");

# it's a good idea to do this for all windows
$window->signal_connect("destroy" => sub { Gtk2->main_quit; });
$window->signal_connect("delete-event" => sub { Gtk2->main_quit; });

# sets the border width of the window
$window->set_border_width(10);

# create a new button
my $button = Gtk2::Button->new();

# connect the 'clicked' signal of the button to our callback
$button->signal_connect("clicked" => \&callback, "cool button");

# this calls our box creating function
my $box = xpm_label_box("info.xpm", "cool button");

# pack and show all our widgets
$box->show();

$button->add($box);

$button->show();

$window->add($button);

$window->show();

# rest in the GTK main loop and wait for the fun to begin!
Gtk2->main;

0;
	

$togglebutton = Gtk2::ToggleButton->new($mnemonic);

$togglebutton = Gtk2::ToggleButton->new_with_label($label);

$togglebutton = Gtk2::ToggleButton->new_with_mnemonic($label);

sub toggle_button_callback {
    my $button = shift;
    
    if ($button->get_active) {
        # if control reaches here, the toggle button is down
    } else {
        # if control reaches here, the toggle button is up
    }   
} 

$checkbutton = Gtk2::CheckButton->new($mnemonic);

$checkbutton = Gtk2::CheckButton->new_with_label($label);

$radiobutton = Gtk2::RadioButton->new($member_or_listref=undef, $label=undef);

$radiobutton = Gtk2::RadioButton->new_from_widget($group, $label=undef);

$radiobutton = Gtk2::RadioButton->new_with_label($member_or_listref=undef, $label=undef);

$radiobutton = Gtk2::RadioButton->new_with_label_from_widget($group, $label=undef);

$radiobutton = Gtk2::RadioButton->new_with_mnemonic($member_or_listref=undef, $label=undef);

$radiobutton = Gtk2::RadioButton->new_with_mnemonic_from_widget($group, $label=undef);

Gtk2::RadioButton->get_group();

$radiobutton = Gtk2::RadioButton->new_with_label(
                 $button1->get_group(),
                 "button2");

$radiobutton = Gtk2::RadioButton->new_with_label_from_widget(
	         $button2, 
                 "button3");

Gtk2::ToggleButton->set_active($toggle_button, gboolean state);

use Glib qw/TRUE FALSE/;
use Gtk2 '-init';

$window = Gtk2::Window->new('toplevel');
$window->signal_connect(delete_event => sub { Gtk2->main_quit; return FALSE; });
$window->set_title("radio buttons");
$window->set_border_width(0);

$box1 = Gtk2::VBox->new(FALSE, 0);
$window->add($box1);
$box1->show;

$box2 = Gtk2::VBox->new(FALSE, 10);
$box2->set_border_width(10);
$box1->pack_start($box2, TRUE, TRUE, 0);
$box2->show;

$button = Gtk2::RadioButton->new(undef, "button 1");
$box2->pack_start($button, TRUE, TRUE, 0);
$button->show;

@group = $button->get_group;
$button = Gtk2::RadioButton->new_with_label(@group, "button 2");
$button->set_active(TRUE);
$box2->pack_start($button, TRUE, TRUE, 0);
$button->show;

$button = Gtk2::RadioButton->new_with_label_from_widget($button, "button 3");
$box2->pack_start($button, TRUE, TRUE, 0);
$button->show;

$separator = Gtk2::HSeparator->new;
$box1->pack_start($separator, FALSE, TRUE, 0);
$separator->show;

$box2 = Gtk2::VBox->new(FALSE, 10);
$box2->set_border_width(10);
$box1->pack_start($box2, FALSE, TRUE, 0);
$box2->show;

$button = Gtk2::Button->new("close");
$button->signal_connect(clicked => sub { Gtk2->main_quit; });
$box2->pack_start($button, TRUE, TRUE, 0);
$button->can_default(TRUE);
$button->grab_default;
$button->show;
$window->show;

Gtk2->main;

0;

$adjustment = Gtk2::Adjustment->new($value,
                                    $lower,
				    $upper,
				    $step_increment,
				    $page_increment,
				    $page_size);

  # creates its own adjustment
  $viewport = Gtk2::ViewPort->new(undef, undef);
  # uses the newly-created adjustment for the scrollbar as well
  $vscrollbar = Gtk2::VScrollBar->new($viewport->get_vadjustment());

$scrollbar = Gtk2::HScrollBar->new($adjustment=undef);

$scrollbar = Gtk2::VScrollBar->new($adjustment=undef);

use Glib qw/TRUE FALSE/;
use Gtk2 '-init';

my ($hscale, $vscale);

sub cb_pos_menu_select
{
	my ($widget, $pos) = @_;
	$hscale->set_value_pos($pos);
	$vscale->set_value_pos($pos);
}

sub cb_update_menu_select
{
	my ($widget, $policy) = @_;
	$hscale->set_update_policy($policy);
	$vscale->set_update_policy($policy);
}

sub cb_digits_scale
{
	my ($adjustment) = @_;
	# Set the number of decimal places to which adj->value is rounded
	$hscale->set_digits($adjustment->value);
	$vscale->set_digits($adjustment->value);
}

# We do not have a Glib::CLAMP function, so we provide it here.
sub clamp ($val, $low, $high)
{
	return (($val > $high) ? $high : (($val < $low) ? $low : $val));
}

sub cb_page_size
{
	my ($get, $set) = @_;
	
	# Set the page size and page increment size of the sample
	# adjustment to the value specified by the "Page Size" scale
	$set->page_size($get->value);
	$set->page_increment($get->value);

	# This sets the adjustment and make it emit the "changed" signal to
	# reconfigure all the widgets that are attached to this signal.
	$set->set_value(clamp ($set->value,
	                       $set->upper - $set->page_size,
			       $set->lower));
	
	$set->signal_emit("changed");
}

sub cb_draw_value
{
	my $button = shift;
	$hscale->set_draw_value($button->get_active());
	$vscale->set_draw_value($button->get_active());
}

# Convenience functions
sub make_menu_item
{
	my ($name, $func, $data) = @_;
	$item = Gtk2::MenuItem->new_with_label($name);
	$item->signal_connect(activate => $func, $data);
	$item->show;

	return $item;
}

sub scale_set_default_values
{
	my $scale = shift;
	$scale->set_update_policy('continuous');
	$scale->set_digits(1);
	$scale->set_value_pos('top');
	$scale->set_draw_value(TRUE);
}

# makes the sample window
sub create_range_controls
{
	# Standard window-creating stuff
	$window = Gtk2::Window->new('toplevel');
	$window->signal_connect(destroy => sub { Gtk2->main_quit; });
	$window->set_title("range controls");

	$box1 = Gtk2::VBox->new(FALSE, 0);
	$window->add($box1);
	$box1->show;

	$box2 = Gtk2::HBox->new(FALSE, 10);
	$box2->set_border_width(10);
	$box1->pack_start($box2, TRUE, TRUE, 0);
	$box2->show;

	# value, lower, upper, step_increment, page_increment, page_size
	# Note that the page_size value only makes a difference for
	# scrollbar widgets, and the highest value you'll get is actually
	# (upper - page_size).
	$adj1 = Gtk2::Adjustment->new(0.0, 0.0, 101.0, 0.1, 1.0, 1.0);

	$vscale = Gtk2::VScale->new($adj1);
	scale_set_default_values($vscale);
	$box2->pack_start($vscale, TRUE, TRUE, 0);
	$vscale->show;

	$box3 = Gtk2::VBox->new(FALSE, 10);
	$box2->pack_start($box3, TRUE, TRUE, 0);
	$box3->show;

	# Reuse the same adjustment
	$hscale = Gtk2::HScale->new($adj1);
	$hscale->set_size_request(200, -1);
	scale_set_default_values($hscale);
	$box3->pack_start($hscale, TRUE, TRUE, 0);
	$hscale->show;
	
	# Reuse the same adjustment again
	$scrollbar = Gtk2::HScrollBar->new($adj1);
	# Notice how this causes the scales to always be updated
	# continuously when the scrollbar is moved
	$scrollbar->set_update_policy('continuous');
	$box3->pack_start($scrollbar, TRUE, TRUE, 0);
	$scrollbar->show;
	
	$box2 = Gtk2::HBox->new(FALSE, 10);
	$box2->set_border_width(10);
	$box1->pack_start($box2, TRUE, TRUE, 0);
	$box2->show;

	# A checkbutton to control whether the value is displayed or not
	$button = Gtk2::CheckButton->new("Display value on scale widgets");
	$button->set_active(TRUE);
	$button->signal_connect(toggled => \&cb_draw_value);
	$box2->pack_start($button, TRUE, TRUE, 0);
	$button->show;

	$box2 = Gtk2::HBox->new(FALSE, 10);
	$box2->set_border_width(10);

	# An option menu to change the position of the value
	$label = Gtk2::Label->new("Scale Value Position:");
	$box2->pack_start($label, FALSE, FALSE, 0);
	$label->show;

	$opt = Gtk2::OptionMenu->new;
	$menu = Gtk2::Menu->new;

	$item = make_menu_item("Top", \&cb_pos_menu_select, 'top');
	$menu->append($item);
	
	$item = make_menu_item("Bottom", \&cb_pos_menu_select, 'bottom');
	$menu->append($item);

	$item = make_menu_item("Left", \&cb_pos_menu_select, 'left');
	$menu->append($item);

	$item = make_menu_item("Right", \&cb_pos_menu_select, 'right');
	$menu->append($item);

	$opt->set_menu($menu);
	$box2->pack_start($opt, TRUE, TRUE, 0);
	$opt->show;

	$box1->pack_start($box2, TRUE, TRUE, 0);
	$box2->show;

	$box2 = Gtk2::HBox->new(FALSE, 10);
	$box2->set_border_width(10);

	# Yet another option menu, this time for the update policy of the
	# scale widgets
	$label = Gtk2::Label->new("Scale Update Policy:");
	$box2->pack_start($label, FALSE, FALSE, 0);
	$label->show;

	$opt = Gtk2::OptionMenu->new;
	$menu = Gtk2::Menu->new;

	$item = make_menu_item("Continuous", \&cb_update_menu_select, 'continuous');
	$menu->append($item);

	$item = make_menu_item("Discontinuous", \&cb_update_menu_select, 'discontinuous');
	$menu->append($item);

	$item = make_menu_item("Delayed", \&cb_update_menu_select, 'delayed');
	$menu->append($item);

	$opt->set_menu($menu);
	$box2->pack_start($opt, TRUE, TRUE, 0);
	$opt->show;

	$box1->pack_start($box2, TRUE, TRUE, 0);
	$box2->show;

	$box2 = Gtk2::HBox->new(FALSE, 10);
	$box2->set_border_width(10);

	# An HScale widget for adjusting the number of digits on the
	# sample scales.
	$label = Gtk2::Label->new("Scale Digits:");
	$box2->pack_start($label, FALSE, FALSE, 0);
	$label->show;

	$adj2 = Gtk2::Adjustment->new(1.0, 0.0, 5.0, 1.0, 1.0, 0.0);
	$adj2->signal_connect(value_changed => \&cb_digits_scale);
	$scale = Gtk2::HScale->new($adj2);
	$scale->set_digits(0);
	$box2->pack_start($scale, TRUE, TRUE, 0);
	$scale->show;

	$box1->pack_start($box2, TRUE, TRUE, 0);
	$box2->show;

	$box2 = Gtk2::HBox->new(FALSE, 10);
	$box2->set_border_width(10);

	# And, one last HScale widget for adjusting the page size of the
	# scrollbar.
	$label = Gtk2::Label->new("Scrollbar Page Size:");
	$box2->pack_start($label, FALSE, FALSE, 0);
	$label->show;

	$adj2 = Gtk2::Adjustment->new(1.0, 1.0, 101.0, 1.0, 1.0, 0.0);
	$adj2->signal_connect(value_changed => \&cb_page_size, $adj1);
	$scale = Gtk2::HScale->new($adj2);
	$scale->set_digits(0);
	$box2->pack_start($scale, TRUE, TRUE, 0);
	$scale->show;
	
	$box1->pack_start($box2, TRUE, TRUE, 0);
	$box2->show;

	$separator = Gtk2::HSeparator->new;
	$box1->pack_start($separator, FALSE, TRUE, 0);
	$separator->show;

	$box2 = Gtk2::VBox->new(FALSE, 10);
	$box2->set_border_width(10);
	$box1->pack_start($box2, FALSE, TRUE, 0);
	$box2->show;

	$button = Gtk2::Button->new("Quit");
	$button->signal_connect(clicked => sub { Gtk2->main_quit; });
	$box2->pack_start($button, TRUE, TRUE, 0);
	$button->can_default(TRUE);
	$button->grab_default;
	$button->show;

	$window->show;
}

create_range_controls();

Gtk2->main;

0;

$label = Gtk2::Label->new($str=undef);

$label = Gtk2::Label->new_with_mnemonic($str);

Gtk2::Label->set_text($label, $string);

$text = Gtk2::Label->get_text($label);                    

Gtk2::Label->set_justify($label, $jtype);

  left
  right
  center (the default)
  fill

Gtk2::Label->set_line_wrap($label, $wrap);

Gtk2::Label->set_pattern($label, $pattern);

use Glib qw/TRUE FALSE/;
use Gtk2 '-init';

$window = Gtk2::Window->new('toplevel');
$window->signal_connect(destroy => sub { Gtk2->main_quit; });

$window->set_title("Label");
$vbox = Gtk2::VBox->new(FALSE, 5);
$hbox = Gtk2::HBox->new(FALSE, 5);
$window->add($hbox);
$hbox->pack_start($vbox, FALSE, FALSE, 0);
$window->set_border_width(5);

$frame = Gtk2::Frame->new("Normal Label");
$label = Gtk2::Label->new("This is a Normal label");
$frame->add($label);
$vbox->pack_start($frame, FALSE, FALSE, 0);

$frame = Gtk2::Frame->new("Multi-line Label");
$label = Gtk2::Label->new("This is a Multi-line label.\nSecond line\n" .
                          "Third line");
$frame->add($label);
$vbox->pack_sta