Gtk2
view release on metacpan or search on metacpan
ChangeLog.pre-git view on Meta::CPAN
2008-06-22 Torsten Schoenfeld <kaffeetisch@gmx.de>
* xs/GtkGC.xs: Refer to release 1.200 (instead of 1.180) in the
compatibility paragraph about Gtk2::GC->release.
2008-06-22 Torsten Schoenfeld <kaffeetisch@gmx.de>
* t/GtkClipboard.t: Fix test failure that's presumably due to
get_func being run more often than expected. Also use
Gtk2::TestHelper's run_main to replace equivalent Glib::Timeout
constructs.
2008-06-22 Torsten Schoenfeld <kaffeetisch@gmx.de>
* CodeGen.pm (generate_constants_wrappers): Also allow more than
one tab as a separator between constant name and converter.
2008-06-22 Torsten Schoenfeld <kaffeetisch@gmx.de>
* CodeGen.pm: Add Gtk2::CodeGen->generate_constants_wrappers which
examples/assistant.pl view on Meta::CPAN
sub prepare_callback {
my ($assistant, $page) = @_;
if ($page->isa ('Gtk2::Label')) {
print "prepare: ".$page->get_text."\n";
} elsif ($assistant->get_page_type ($page) eq 'progress') {
my $progress = $page->child;
$assistant->set_page_complete ($page, FALSE);
$progress->set_fraction (0.0);
Glib::Timeout->add (300, \&progress_timeout, $assistant);
} else {
print "prepare: ".$assistant->get_current_page,"\n";
}
}
sub create_simple_assistant {
my $widget = shift;
my $assistant = $widget->{assistant};
examples/cairo-clock.pl view on Meta::CPAN
my $cr = Gtk2::Gdk::Cairo::Context->create($self->window);
$cr->rectangle ($event->area->x,
$event->area->y,
$event->area->width,
$event->area->height);
$cr->clip;
$self->{cr} = $cr;
$self->draw;
$self->{timeout} = Glib::Timeout->add(1000, sub {
my $self = shift;
my $alloc = $self->allocation;
my $rect = Gtk2::Gdk::Rectangle->new(0, 0, $alloc->width, $alloc->height);
$self->window->invalidate_rect($rect, FALSE);
return TRUE;
}, $self) unless $self->{timeout};
return FALSE;
examples/cellrenderer_progress.pl view on Meta::CPAN
$col->set_title ("Progress");
$view->append_column ($col);
$renderer = Mup::CellRendererProgress->new;
$col = Gtk2::TreeViewColumn->new;
$col->pack_start ($renderer, TRUE);
$col->add_attribute ($renderer, percentage => COL_PERCENTAGE);
$col->set_title ("Progress");
$view->append_column ($col);
Glib::Timeout->add (50, \&increase_progress_timeout);
return $view;
}
my $window = Gtk2::Window->new;
$window->set_default_size (150, 100);
$window->signal_connect (delete_event => sub {Gtk2->main_quit});
my $view = create_view_and_model();
examples/testdnd.pl view on Meta::CPAN
}
sub popup_leave {
my ($widget, $context, $time) = @_;
if ($in_popup)
{
$in_popup = 0;
if ($popdown_timer)
{
print ("added popdown\n");
$popdown_timer = Gtk2::Timeout->add (500, \&popdown_cb);
}
}
}
sub popup_cb {
if (!$popped_up)
{
if (!$popup_window)
{
my ($button, $table, $i, $j);
examples/testdnd.pl view on Meta::CPAN
}
}
$table->show_all ();
$popup_window->add($table);
}
$popup_window->show;
$popped_up = 1;
}
$popdown_timer = Glib::Timeout->add (500, \&popdown_cb);
print ("added popdown\n");
$popup_timer = 0;
return 0;
}
sub popsite_motion {
my ($widget, $context, $x, $y, $time) = @_;
if (!$popup_timer) {
$popup_timer = Glib::Timeout->add (500, \&popup_cb);
}
return 1;
}
sub popsite_leave {
my ($widget, $context, $time) = @_;
if ($popup_timer)
{
Glib::Source->remove ($popup_timer);
$popup_timer = 0;
examples/thread_usage.pl view on Meta::CPAN
foreach (1..5)
{
$worker = Worker->new ($worklog);
$vbox->pack_start ($worker, FALSE, FALSE, 0);
$worker->set_worker_label ('Worker '.$_);
push @workers, $worker;
}
my $pending = Gtk2::Label->new ('0 jobs pending');
$vbox->pack_start ($pending, FALSE, FALSE, 0);
Glib::Timeout->add (500, sub {
$pending->set_text (Worker->jobs_pending.' jobs pending');
1;
});
my $count = 0;
my $go = Gtk2::Button->new ('_Go');
$vbox->pack_start ($go, FALSE, FALSE, 0);
$go->signal_connect (clicked => sub {
foreach (@workers)
examples/timeouttest.pl view on Meta::CPAN
use Gtk2;
use Data::Dumper;
Gtk2->init;
my $str = 'aaa0';
my $window = Gtk2::Window->new ('toplevel');
$window->signal_connect (delete_event => sub { Gtk2->main_quit; 1 });
$window->set_title ('Timeout Test');
$window->set_border_width (6);
$window->set_default_size (200, 200);
my $vbox = Gtk2::VBox->new (0,0);
$window->add ($vbox);
my $label = Gtk2::Label->new ($str);
$vbox->pack_start ($label, 1, 1, 0);
my $button = Gtk2::ToggleButton->new ('Go');
examples/timeouttest.pl view on Meta::CPAN
$_[0]->child->set_text ('Stop');
} else {
$_[0]->child->set_text ('Go');
}
});
#
# here's a timeout that is always running, but only does something if
# $button is toggled on.
#
my $id = Glib::Timeout->add (100, sub {
if ($_[0][1]->get_active) {
$str++;
$_[0][0]->set_text ($str);
}
1;
}, [$label, $button]);
#
# now let's test timeouts that uninstall themselves.
examples/timeouttest.pl view on Meta::CPAN
my $button2 = Gtk2::ToggleButton->new ('click me');
$vbox->pack_start ($button2, 0, 0, 5);
my $id2 = undef;
$button2->signal_connect (toggled => sub {
if (!$_[0]->get_active) {
# user turned us off before the callback ran
warn "uninstalling $id2";
Glib::Source->remove ($id2);
$id2 = undef;
} else {
$id2 = Glib::Timeout->add (1000, sub {
warn "callback, $_[0]";
$_[0]->set_active (0);
0; # don't run again
}, $_[0]);
}
});
$window->show_all;
Gtk2->main;
gtk-demo/assistant.pl view on Meta::CPAN
}
Gtk2::Gdk::Threads->enter();
return $cont;
}
sub on_assistant_apply($$)
{
my ($widget, $data) = @_;
# Start a timer to simulate changes taking a few seconds to apply.
Glib::Timeout->add(100, \&apply_changes_gradually, undef);
}
sub on_assistant_close_cancel($$)
{
my ($widget, $assistant) = @_;
$$assistant->destroy();
undef $$assistant;
}
gtk-demo/images.pl view on Meta::CPAN
sub start_progressive_loading {
my $image = shift;
#
# This is obviously totally contrived (we slow down loading
# on purpose to show how incremental loading works).
# The real purpose of incremental loading is the case where
# you are reading data from a slow source such as the network.
# The timeout simply simulates a slow data source by inserting
# pauses in the reading process.
#
$load_timeout = Glib::Timeout->add (150, \&progressive_timeout, $image);
}
sub cleanup_callback {
my ($object, $data) = @_;
if ($load_timeout) {
Glib::Source->remove ($load_timeout);
$load_timeout = 0;
}
gtk-demo/pixbufs.pl view on Meta::CPAN
}
use constant CYCLE_LEN => 60;
use constant G_PI => 3.141529;
use POSIX;
sub MAX { $_[0] > $_[1] ? $_[0] : $_[1] }
sub MIN { $_[0] < $_[1] ? $_[0] : $_[1] }
my $frame_num = 0;
# Timeout handler to regenerate the frame
sub timeout {
$background->copy_area (0, 0, $back_width, $back_height, $frame, 0, 0);
my $f = ($frame_num % CYCLE_LEN) / CYCLE_LEN;
my $xmid = $back_width / 2.0;
my $ymid = $back_height / 2.0;
my $radius = MIN ($xmid, $ymid) / 2.0;
gtk-demo/pixbufs.pl view on Meta::CPAN
$window->set_size_request ($back_width, $back_height);
$frame = Gtk2::Gdk::Pixbuf->new ('rgb', FALSE, 8, $back_width, $back_height);
$da = Gtk2::DrawingArea->new;
$da->signal_connect (expose_event => \&expose_cb);
$window->add ($da);
$timeout_id = Glib::Timeout->add (FRAME_DELAY, \&timeout);
}
}
if (!$window->visible) {
$window->show_all;
} else {
$window->destroy;
$window = undef;
}
lib/Gtk2/api.pod view on Meta::CPAN
=over
=item g_object_ref => no replacement
=item g_object_unref => no replacement
=item g_boxed_free => no replacement
The bindings do automatic memory management. You should never need to use these.
=item gtk_timeout_add => Glib::Timeout->add
=item gtk_timeout_remove => Glib::Source->remove
=item gtk_idle_add => Glib::Idle->add
=item gtk_idle_remove => Glib::Source->remove
=item gtk_input_add => Glib::IO->add_watch
=item gtk_input_remove => Glib::Source->remove
( run in 1.000 second using v1.01-cache-2.11-cpan-496ff517765 )