Projects/GTK-Perl/FrequentlyAskedQuestions

gtk

ppm install Bundle::Gnome2
    C:\Temp> ppm install http://gtk2-perl.sourceforge.net/win32/ppm/Gtk2.ppd
    C:\Temp> ppm install http://gtk2-perl.sourceforge.net/win32/ppm/Glib.ppd
make test
perl Makefile.PL
*** can not find package gobject-2.0 >= 2.0.0
*** check that it is properly installed and available in PKG_CONFIG_PATH
  at Makefile.PL line 81
$ apt-get install libglib2.0-dev
$ apt-get install libgtk2.0-dev
  # choose a location for the sandbox
  export SANDBOX=$HOME/local

  # tell perl how to find stuff installed under that prefix.
  # NOTE the use of lib/perl5/site_perl !
  export PERL5LIB=$SANDBOX/lib/perl5/site_perl:$PERL5LIB

  # and an alias to reduce typing errors:
  alias do_makefile_pl='perl Makefile.PL PREFIX=$SANDBOX'

  # you probaby want to install other software to this sandbox,
  # as well.  we can do the same thing for regular libraries.
  export PATH=$SANDBOX/bin:$PATH
  export LD_LIBRARY_PATH=$SANDBOX/lib:$LD_LIBRARY_PATH
  export MANPATH=$SANDBOX/share/man:$MANPATH
  alias do_configure='./configure --prefix=$SANDBOX'

  # now we can build a bunch of modules...
  (cd ExtUtils-Depends && do_makefile_pl && make all test install)
  (cd ExtUtils-PkgConfig && do_makefile_pl && make all test install)
  (cd Glib && do_makefile_pl && make all test install)
  (cd Gtk2 && do_makefile_pl && make all test install)
  (cd Gnome2::Canvas && do_makefile_pl && make all test install)

  # and run scripts that use them.
  my_really_cool_gtk2perl_script
  Gtk2->main();
  while there are sources ready
    if there are events pending
      process events
    if there are timeout sources
      execute timeouts
    if there are idle sources
      execute idles
 while(1) { ... } 
Glib::Timeout->add()
Glib::Idle->add()
Glib::IO->add_watch()
  /* Built-in stock icon sizes */
  typedef enum
  {
    GTK_ICON_SIZE_INVALID,        /* 'invalid'       */
    GTK_ICON_SIZE_MENU,           /* 'menu'          */
    GTK_ICON_SIZE_SMALL_TOOLBAR,  /* 'small-toolbar' */
    GTK_ICON_SIZE_LARGE_TOOLBAR,  /* 'large-toolbar' */
    GTK_ICON_SIZE_BUTTON,         /* 'button'        */
    GTK_ICON_SIZE_DND,            /* 'dnd'           */
    GTK_ICON_SIZE_DIALOG          /* 'dialog'        */
  } GtkIconSize;
 $icon->set_from_stock('gtk-apply', 'large-toolbar'); 
  /* priorities for path lookups */
  typedef enum
  {
    GTK_PATH_PRIO_LOWEST      = 0,  /* 'lowest'      */
    GTK_PATH_PRIO_GTK         = 4,  /* 'gtk'         */
    GTK_PATH_PRIO_APPLICATION = 8,  /* 'application' */
    GTK_PATH_PRIO_THEME       = 10, /* 'theme'       */
    GTK_PATH_PRIO_RC          = 12, /* 'rc'          */
    GTK_PATH_PRIO_HIGHEST     = 15  /* 'highest'     */
  } GtkPathPriorityType;
 Gtk2->gtk_rc_parse_priority ($scanner, ['lowest', 'rc', 'gtk'] ); 
  my $label = Gtk2::Lable->new('Initial string');
  my $button = Gtk2::Button->new;
  $button->signal_connect (clicked => sub {
                   # with this closure we get to label directly
                   # and thanks to the magic (ref counting) of perl we
                   #  don't have to worry about the label going away
                   $label->set_text('Clicked string');
      }, $user_data);
  # basic 1 variable in
  $button->signal_connect (clicked => sub {
                my $btn = shift;
                my $udata = shift;
        }, $user_data);

  # two variables in via an inline array reference, 
  # caught as an array reference
  $button->signal_connect (clicked => sub {
                my $btn = shift;
                my $udata = shift;
                # $udata->[0], $udata->[1]
        }, [ $user_data1, $user_data2 ] );

  # two variables in via an inline array reference, 
  # caught as an array
  $button->signal_connect (clicked => sub {
                my $btn = shift;
                my @udata = @{shift(@_)};
        }, [ $user_data1, $user_data2 ] );

  # two variables in via an inline array reference, 
  # caught into seperate variables
  $button->signal_connect (clicked => sub {
                my $btn = shift;
                my ($udata1, $udata2) = @{shift(@_)};
        }, [ $user_data1, $user_data2 ] );

  # a hash passed in via an inline hash reference,
  # caught as a hash reference
  $button->signal_connect (clicked => sub {
                my $btn = shift;
                my $udata = shift;
                # $udata->{user_data1}, $udata->{user_data2}
        }, { 
                user_data1 => $user_data1,
                user_data2 => $user_data2,
        });

  # a hash passed in via an inline hash reference,
  # caught as a hash 
  $button->signal_connect (clicked => sub {
                my $btn = shift;
                my %udata = %{shift(@_)};
        }, { 
                user_data1 => $user_data1,
                user_data2 => $user_data2,
        });

  # an array passed in by taking a reference to an array
  # caught into an array
  my @array = ( $user_data1, $user_data2 );
  $button->signal_connect (clicked => sub {
                my $btn = shift;
                my @udata = @{shift(@_)};
        }, \@array);

  # a hash passed in by taking a reference to a hash,
  # caught as a hash 
  my %hash = (
        user_data1 => $user_data1,
        user_data2 => $user_data2,
  );
  $button->signal_connect (clicked => sub {
                my $btn = shift;
                my %udata = %{shift(@_)};
        }, \%hash);
   $object1 == $object2
   $object1 != $object2
$object->get_data (key)
$object->set_data (key,val)
Glib::Object->new_from_pointer (pointer)
Glib::String
Glib::Boolean
Glib::Int
Glib::Uint
Glib::Double
Glib::Scalar
  # reading from a file encoded in iso-8859-15 (latin1 + Euro)
        use Encode;
        open my $in, "<:encoding(iso-8859-15)", $infile or die;
        while(<$in>) {
                # $_ is ready for use with Gtk2
                ...
        }

  # writing the to a iso-8859-15 encoded file
        use Encode;
        open my $out, ">:encoding(iso-8859-15)", $outfile or die;
        print $out, "...";
        use Encode qw(decode encode);
        my $octets= broken_sub();
        my $string= decode("iso-8859-15", $octets); # ready for Gtk2
        my $label = Gtk2::Label->new($string);
        $string= $label->get_text;
        $octets= encode("iso-8859-15", $string);
  $button->signal_connect (clicked => sub {
          eval { 
              do_something_that_might_croak_or_die();
              # or just
              die "a horrible death";
          }
          if( $@ )
          {
              # handle things here
          }
      } );
  $button->signal_connect (clicked => sub {
          die "a horrible death";
      } );
  # and try catching it somewhere else
  Glib->install_exception_handler (sub {
          my $msg = shift;
          my $udata = shift;
          # msg = what used to be in $@
  }, $user_data);
  Glib->install_exception_handler (sub {
          warn shift;
          exit -1;
  });
  #!/usr/bin/perl -w

  my $gtk;

  if (eval "use Gtk2 -init; 1") {
          warn "Gtk2 is available";
          $gtk = 'Gtk2';
  } elsif (eval "use Gtk -init; 1") {
          warn "Gtk is available";
          $gtk = 'Gtk';
  } else {
          die "neither Gtk2 nor Gtk is available, can't run!\n";
  }

  my $window = "$gtk\::Window"->new ('toplevel');
  $window->signal_connect (delete_event => sub { $gtk->main_quit; 1 });
  my $vbox = "$gtk\::VBox"->new;
  $window->add ($vbox);
  $vbox->pack_start ("$gtk\::Label"->new ("using $gtk"), 0, 0, 0);
  my $button = "$gtk\::Button"->new ("Quit");
  $vbox->pack_start ($button, 0, 0, 0);
  $button->signal_connect (clicked => sub { $gtk->main_quit; });

  $window->show_all;

  $gtk->main;
Gtk2::SimpleList
######################################################################
#  Example of howto use the Gtk2::Helper functions to get input from
#  a file descriptor.
######################################################################

use Gtk2 '-init';
use Gtk2::Helper;
use strict;

my $buffer;

sub create_widgets {
    my $wm   = Gtk2::Window->new;
    my $vbox = Gtk2::VBox->new;
    my $sw   = Gtk2::ScrolledWindow->new( undef, undef );
    my $tw   = Gtk2::TextView->new();
    $buffer = $tw->get_buffer();
    $wm->set_default_size( 400, 300 );
    $sw->add( $tw );
    $sw->set_policy( 'automatic', 'automatic' );
    $vbox->pack_start( $sw, 1, 1, 0 );

    my $button = Gtk2::Button->new( "Quit" );
    $vbox->pack_start( $button, 0, 0, 0 );
    $button->signal_connect( clicked => sub { exit } );
    $wm->add( $vbox );

    $wm->show_all();
}

create_widgets();

open my $pipe, '-|', perl => -e => '$|++; for my $i (0..9) { $sum+= $i; print "Line $i: sum = $sum\n"; sleep 1;}'
    or die "Failed running perl subprocess\n";

my $tag;

$tag = Gtk2::Helper->add_watch( fileno( $pipe ), in => sub {
    if ( eof( $pipe ) ) {
        Gtk2::Helper->remove_watch( $tag );
        close( $pipe );
    }
    else {
        my $line = <$pipe>;
        $buffer->insert( $buffer->get_end_iter, $line );
    }

    return 1;
} );

Gtk2->main;
open my $pipe, '-|', 'program', 'with', 'args'
$tag = Gtk2::Helper->add_watch( $fileno, 'in', sub {...} )
Helper->add_watch()
# adding a predefined response
$dialog->add_button ('gtk-ok' => 'ok');
# or a custom response
$dialog->add_button ('something' => 42);

# modally
if ('ok' eq $dialog->run) {
    # whatever
}

# or via the signal
$dialog->signal_connect (response => sub {
    my ($widget, $response) = @_;
    if ($response eq 'accept') {
        # was a predefined one
    } elsif ($response eq 42) {
        # was a custom one
    }
});
use Gtk2::Pango;
use Gtk2 '-init';
use Gtk2::Ex::Simple::List;
use Glib qw /TRUE FALSE/;

# Declare the lists
my $leftlist  = Gtk2::Ex::Simple::List->new ('Left'     => 'text',);
my $rightlist = Gtk2::Ex::Simple::List->new ('Right'=> 'text',);
$leftlist->get_selection->set_mode ('multiple');
$rightlist->get_selection->set_mode ('multiple');

# For dragging from left to right
$leftlist->drag_source_set (['button1_mask', 'button3_mask'],['copy', 'move'], 
        {'target' => "STRING", 'flags' => [], 'info' => 0});
$rightlist->drag_dest_set('all', ['copy', 'move'], 
        {'target' => "STRING", 'flags' => [], 'info' => 0});
$leftlist->signal_connect ('drag-data-get', \&source_drag_data_get);
$rightlist->signal_connect('drag-data-received', \&drag_data_received, $leftlist);

# For dragging from right to left (just the inverse)
$rightlist->drag_source_set (['button1_mask', 'button3_mask'], ['copy', 'move'], 
        {'target' => "STRING", 'flags' => [], 'info' => 0});
$leftlist->drag_dest_set('all', ['copy', 'move'], 
        {'target' => "STRING", 'flags' => [], 'info' => 0});
$rightlist->signal_connect ('drag-data-get', \&source_drag_data_get);
$leftlist->signal_connect('drag-data-received', \&drag_data_received, $rightlist);

# Populate the leftlist
@{$leftlist->{data}} = ('one', 'two', 'three', 'four', 'five', 'six', 'seven');

# Pack the widgets and display
my $hbox = Gtk2::HBox->new(FALSE);
$hbox->pack_start($leftlist, TRUE, TRUE, 0);
$hbox->pack_start($rightlist, TRUE, TRUE, 0);
my $window = Gtk2::Window->new;
$window->signal_connect(destroy => sub { Gtk2->main_quit; });
$window->add($hbox);
$window->set_default_size(400,350);
$window->show_all;
Gtk2->main;

sub source_drag_data_get {
        my ($widget, $context, $data, $info, $time) = @_;
        $data->set ($data->target, 0, 0);
}

sub drag_data_received {
        my ($tolist, $context, $x, $y, $data, $info, $time, $fromlist) = @_;
        my @selectedindices = $fromlist->get_selected_indices;
        _move_from_to ($fromlist, $tolist, \@selectedindices);
}

sub _move_from_to {
        my ($fromlist, $tolist, $selectedindices) = @_;
        # Populate the tolist
        foreach my $i (@$selectedindices) {
                push @{$tolist->{data}}, $fromlist->{data}->[$i];
        }
        my %hash = map { $_ => 1 } @$selectedindices;
        my @temp;
        # Remove entries from fromlist
        for my $i (0 .. $#{ @{$fromlist->{data}}) {
                push @temp, $fromlist->{data}->[$i]->[0] unless exists($hash{$i});
        }
        @{$fromlist->{data}} = @temp;   
}
  $widget->drag_dest_set(["drop","motion","highlight"],
                         ["copy","private","default","move","link","ask"]);
  $widget->signal_connect(drag_data_received => \&drop_handler);

  my $target_list = Gtk2::TargetList->new();
  my $atom = Gtk2::Gdk::Atom->new("text/uri-list");
  $target_list->add($atom, 0, 0);
  $widget->drag_dest_set_target_list($target_list);

  sub drop_handler {
    my ($treeview, $context, $widget_x, $widget_y, $data, $info, $time) = @_;
    my @uris = Gnome2::VFS::URI->list_parse($data->data);
    for my $uri (@uris) {
      print "received %s\n", $uri->to_string();
    }
  }
use Glib ':constants';
use Gtk2 '-init';

# create a window with a scrolled text view.
my $window = Gtk2::Window->new();
$window->signal_connect(destroy => sub { Gtk2->main_quit });
$window->set_default_size(450, 200);

my $scroll = Gtk2::ScrolledWindow->new();
$scroll->set_policy('never', 'automatic');

my $textview = Gtk2::TextView->new();
$scroll->add($textview);
$window->add($scroll);
$window->show_all();

my $buffer = $textview->get_buffer();

# create a mark at the end of the buffer, with right gravity,
# so that when you insert text, the mark always stays on
# the right (at the end).
my $end_mark = $buffer->create_mark ('end', $buffer->get_end_iter, FALSE);

# every time we insert text, scroll to that mark.
$buffer->signal_connect (insert_text => sub {
    $textview->scroll_to_mark ($end_mark, 0.0, TRUE, 0.0, 1.0);
});

# display the output of some long-running command...
open my $pipe, 'sleep 1; ls -l |'
    or die "Unable to open pipe: $!\n";

Glib::IO->add_watch (fileno $pipe, ['in', 'hup'], sub {
    my ($fd, $condition) = @_;

    if ($condition >= 'in') {
        while (<$pipe>) {
            $buffer->insert ($buffer->get_end_iter, $_);
        }
    }

    if ($condition >= 'hup') {
        close $pipe;
        return FALSE;
    }

    return TRUE;
});

Gtk2->main();

0;
use constant COLUMN_TEXT => 0;
my $model = Gtk2::ListStore->new('Glib::String');

$model->set($model->append, COLUMN_TEXT, 'foo' );
$model->set($model->append, COLUMN_TEXT, 'bar' );
$model->set($model->append, COLUMN_TEXT, 'baz' );
$model->set($model->append, COLUMN_TEXT, 'blah');

my $view = Gtk2::TreeView->new($model);
my $cell = Gtk2::CellRendererText->new;
my $column = Gtk2::TreeViewColumn->new_with_attributes('My Column',
                                                       $cell,
                                                       text => COLUMN_TEXT);
$column->set_cell_data_func($cell, sub {
        my ($column, $cell, $model, $iter) = @_;
        if    ($model->get($iter, COLUMN_TEXT) eq 'foo') {
            # this offers a bit more flexibility
            $cell->set('background-gdk', Gtk2::Gdk::Color->parse('#ff0000'));
        }
        elsif ($model->get($iter, COLUMN_TEXT) eq 'bar') {
            # this is more straightforward
            $cell->set('background', 'blue'));
        }
        else                                             {
            # this is important, since we are using the same cell renderer
            # for a column.
            $cell->set('background-set', FALSE);
        }
    });

$view->append_column($column);
Gtk2::TreeViewColumn
background
use constant {
    COLUMN_TEXT  => 0,
    COLUMN_COLOR => 1,
};
my $model = Gtk2::ListStore->new('Glib::String', 'Glib::String');
$model->set($model->append, COLUMN_TEXT, 'foo',  COLUMN_COLOR, 'red'  );
$model->set($model->append, COLUMN_TEXT, 'bar',  COLUMN_COLOR, 'blue' );
$model->set($model->append, COLUMN_TEXT, 'baz',  COLUMN_COLOR, undef  ); # undef means 'no color'
$model->set($model->append, COLUMN_TEXT, 'blah', COLUMN_COLOR, 'green');

my $view = Gtk2::TreeView->new($model);

my $column = Gtk2::TreeViewColumn->new_with_attributes('My Column',
                                                       Gtk2::CellRendererText->new,
                                                       text => COLUMN_TEXT,
                                                       background => COLUMN_COLOR);
$view->append_column($column);
  package Gtk2::EntryPlus;

  use strict;
  use warnings;
  use Carp;
  use Gtk2;
  use base 'Gtk2::Entry';

  sub new
  {
        my $class = shift;
        # create an entry
        my $self = Gtk2::Entry->new(@_);
        # rebless it to an Gtk2::EntryPlus
        bless $self, $class;
        return $self;
  }

  sub show
  {
          my $entryplus = shift;
          # this doesn't do anything but show you how to call 
          # a parent method if you really override this function
          # you'd do something here. note that this won't really
          # work as you'd expect for various reasons explained in
          # Glib::Subclass, take a look at that if you're wanting
          # to override C object functions. This is just an
          # example of using SUPER
          $entryplus->SUPER::show;
  }

  sub save_to_file
  {
          my $entryplus = shift;
          my $filename = shift;

          open my $out, '>', $filename
                  or croak "ERROR: unable to open file "
                          ."($filename) for output";
          print $out $entryplus->get_text;
          close $out;
  }

  sub load_from_file
  {
          my $entryplus = shift;
          my $filename = shift;

          open my $in, '<', $filename
                  or croak "ERROR: unable to open file "
                          ."($filename) for output";
          $entryplus->set_text(do { local $/; <$in> });
  }

  package MAIN;

  use Gtk2 '-init';

  my $win = Gtk2::Window->new;
  my $entryplus = Gtk2::EntryPlus->new;
  $entryplus->set_text('Hello');
  $entryplus->save_to_file('entryplus.txt');
  Glib::Timeout->add( 1000, sub {
                $entryplus->set_text('World');
                0;
        });
  Glib::Timeout->add( 2000, sub {
                $entryplus->load_from_file('entryplus.txt');
                # we should be back to 'Hello' here
                0;
        });
  $win->add($entryplus);
  $entryplus->show;
  $win->show;
  Gtk2->main;
Gtk2::GladeXML
use strict;
use Glib;
use Gtk2;

print "\n";
printf "Glib %s \n", $Glib::VERSION;
printf "Gtk2 %s \n", $Gtk2::VERSION;
print "\n";

# The version info stuff appeared in 1.040.
print "Glib built for ".join(".", Glib->GET_VERSION_INFO).", running with "
    .join(".", &Glib::major_version, &Glib::minor_version, &Glib::micro_version)
    ."\n"
  if $Glib::VERSION >= 1.040;
print "Gtk2 built for ".join(".", Gtk2->GET_VERSION_INFO).", running with "
    .join(".", &Gtk2::major_version, &Gtk2::minor_version, &Gtk2::micro_version)
    ."\n"
  if $Gtk2::VERSION >= 1.040;
print "\n";

Gtk2	Supports
version	gtk+ 2.0	gtk+ 2.2	gtk+ 2.4	gtk+ 2.6
1.00x	yes	yes	no	no
1.02x	yes	yes	yes	no
1.04x	yes	yes	yes	no
1.06x	yes	yes	yes	no
1.08x	yes	yes	yes	yes

General Information

What is Gtk2-Perl?

What are those acronyms (gtk, gtk+, Gtk-Perl, Gtk2-Perl, gtk2-perl-xs, ...) anyway?

Is there a Gtk2-Perl mailing list?

Is there a gtk+ (C) F.A.Q

Is there a Gtk2-Perl IRC channel?

Downloading, Building, Installing Gtk2-Perl

Where can i get the latest releases of Gtk2-Perl?

What do i need to run Gtk2-Perl applications?

Are there Pre-built Packages available?

Can i get Gtk2-Perl for Microsoft Windows?

How do I obtain the current, unreleased, code of Gtk2-Perl?

Everything hangs at Gtk2->init or Gtk2 '-init' / What's up 'make test' just stops as soon as it starts

Why "make test" sometimes fails?

Help! FreeBSD wants to use Perl 5.6, but the Gtk2 port needs 5.8! What do I do?

Why sometimes Makefile.PL fails?

What's a "sandbox"? - or - How can a keep from hosing my system?

Where can i find the key with which the Gtk-Perl rpms are signed?

Getting Started Developing with Gtk2-Perl

Where can I find introductory documentation and tutorials for developing with Gtk2-Perl?

Developing with Gtk2-Perl

Why sometimes the UI does not update?

How are enums and flags different from the C bindings?

What's involved in porting from Gtk-Perl to Gtk2-Perl?

How do you pass complex user data to signal callback?

Where is g_object_unref / g_boxed_free / other resource deallocator? These documents tell me i must use them...

How do i tell if two references point to the same object / widget?

How do i keep data with an object?

But what about g_object_get_data and g_object_set_data?

I have this C pointer that i know points to a GObject/GtkWidget -- how can i get a Perl reference out of it?

How do i get a GType?

Okay then, how do i create string or integer columns in GtkTreeModels?

Why does my timer / idle only run once or it doesn't seem to run at all?

Do you have any tips for dealing with character encodings in perl, in relation to Gtk2-Perl?

My app doesn't die when there's a problem in a signal callback, I just get some strange error message, what's up with that?

Can I create an application that can run under both Gtk-Perl and Gtk2-Perl?

I read that CList is deprecated, so what do i use?

Can I use threads with Gtk2-Perl?

How do I keep my GUI updating while doing a long file read?

How do I set the color of a widget?

Widget Specific Development Information

What's up with the response values for Gtk2::Dialog?

I need to use the pango constant PANGO_XXX_XXX where is it?

Show me a simple example for Drag-n-Drop

Nautilus to Gtk2 Drag-n-Drop

How do I scroll to the bottom of a TextView?

How do I set the background/foreground color of a Gtk2::CellRenderer?

Developing Your Own Widgets with Gtk2-Perl

How do I create a new widget as a subclass of an existing Gtk widget?

Wrapping C Gtk+ Modules/Widgets in Gtk2-Perl

I want to use the FooFrobnicator library with gtk2-perl, where are the perl bindings?

Other Miscellaneous Questions

Where's the Glade option to generate perl code?

why aren't there any capitals letters, and why aren't the grammar correct in the documentation?

What version supports the FooBar widget? Can i use Gtk2-Perl x.yy with gtk+ a.b.c?

How do I know which version of Gtk2 and which version of Glib I am running ?