Free gtk2 software for linux

Gtk2 is a Perl interface to the 2.x series of the Gimp Toolkit library.

SYNOPSIS

use Gtk2 -init;
# Gtk2->init; works if you didnt use -init on use
my $window = Gtk2::Window->new (toplevel);
my $button = Gtk2::Button->new (Quit);
$button->signal_connect (clicked => sub { Gtk2->main_quit });
$window->add ($button);
$window->show_all;
Gtk2->main;

ABSTRACT

Perl bindings to the 2.x series of the Gtk+ widget set. This module allows you to write graphical user interfaces in a perlish and object-oriented way, freeing you from the casting and memory management in C, yet remaining very close in spirit to original API.

The Gtk2 module allows a perl developer to use the Gtk+ graphical user interface library. Find out more about Gtk+ at http://www.gtk.org.

The GTK+ Reference Manual is also a handy companion when writing Gtk programs in any language. http://developer.gnome.org/doc/API/2.0/gtk/ The perl bindings follow the C API very closely, and the C reference documentation should be considered the canonical source.

gtk2-perl project is the collective name for a set of perl bindings for Gtk+ 2.x and various related libraries. These modules make it easy to write Gtk and Gnome applications using a natural, perlish, object-oriented syntax.

This set of extension modules gives the Perl developer full access to the gtk+ widget set and several gnome libraries in a perlish, object-oriented way.

You can create new widgets and non-gui objects, and do just about anything you can do in C. We also include POD for every object (installed as manpages), and provide tools for binding other GObject-based libraries to Perl.

Gtk2::devel is the internal workings of the gtk2-perl language bindings.

This document is a supplement to Glib::devel, and assumes you have read and understood all about how the base Glib bindings work. Most of this will seem like nonsense, otherwise.
Here we focus on the ways in which Gtk2 extends Glibs concepts for binding the Gtk+ C libraries to perl, a methodology and set of tools you can use to wrap your own GObject-based libraries.

GtkObject

GtkObject adds the idea of a floating reference to GObject. A GObject is created with one reference which must be explicitly removed by its owner. GtkObject has a floating reference which is sunk by the code which wants to own it. This makes it less painful to create lots of objects in a row (you dont have to unref them).

To allow for this difference in procedure for taking ownership of an object, Glib allows you to register a "sink" function for a particular class. When asked to create a wrapper that owns the object, gperl_new_object will compare the list of registered sink functions with the type of the object; if the object is descended from a type, that sink function will be run on the object. The default one is g_object_unref(), of course. (this is inspired by pygtk.)
Thus, in Gtk2::Objects boot code, we register gtk_object_sink as the sink func for types derived from GtkObject. Now all wrappers for these types will be owned the proper way.

Of course, since gtk_object_sink() does nothing if the object isnt floating, it doesnt hurt anything if you always call gperl_new_object with "own" set to TRUE. So, to make life a little easier, Gtk2 defines another function

SV * gtk2perl_new_gtkobject (GtkObject * o);

Which does nothing more than

{
return gperl_new_object (G_OBJECT (o), TRUE);
}

Its also important to know that this is largely done for you by the typemap.

Gtk2::Helper is a Perl module for convenience functions for the Gtk2 module.

SYNOPSIS

use Gtk2::Helper;

# Handle I/O watchers easily, like Gtk 1.x did
$tag = Gtk2::Helper->add_watch ( $fd, $cond, $callback, $data )
$rc = Gtk2::Helper->remove_watch ( $tag )

ABSTRACT

This module collects Gtk2 helper functions, which should make implementing some common tasks easier.

Gtk2::Helper->add_watch ( ... )

$tag = Gtk2::Helper->add_watch ( $fd, $cond, $callback, $data )

This method is a wrapper for Glib::IO->add_watch. The callback is called every time when its safe to read from or write to the watched filehandle.

$fd

Unix file descriptor to be watched. If you use the FileHandle module you get this value from the FileHandle->fileno() method.

$cond

May be either in or out, depending if you want to read from the filehandle (in) or write to it (out).

$callback

A subroutine reference or closure, which is called, if you can safely operate on the filehandle, without the risk of blocking your application, because the filehandle is not ready for reading resp. writing.

But aware: you should not use Perls builtin read and write functions here because these operate always with buffered I/O. Use low level sysread() and syswrite() instead. Otherwise Perl may read more data into its internal buffer as your callback actually consumes. But Glib wont call the callback on data which is already in Perls buffer, only when events on the the underlying Unix file descriptor occur.

The callback subroutine should return always true. Two signal watchers are connected internally (the I/O watcher, and a HUP watcher, which is called on eof() or other exceptions). Returning false from a watcher callback, removes the correspondent watcher automatically. Because we have two watchers internally, only one of them is removed, but probably not both. So always return true and use Gtk2::Helper->remove_watch to disable a watcher, which was installed with Gtk2::Helper->add_watch.

(Gtk2::Helper could circumvent this by wrapping your callback with a closure returning always true. But why adding another level of indirection if writing a simple "1;" at the end of your callback solves this problem? ;)

$data

This data is passed to the callback.

$tag

The method returns a tag which represents the created watcher. Later you need to pass this tag to Gtk2::Helper->remove_watch to remove the watcher.

Gtk2::TrayIcon is a Perl interface to the EggTrayIcon library.

SYNOPSIS

use Gtk2::TrayIcon;
Gtk2->init;

my $icon= Gtk2::TrayIcon->new("test");
my $label= Gtk2::Label->new("test");
$icon->add($label);
$icon->show_all;

Gtk2->main;

ABSTRACT

This module allows a Perl developer to embed an arbitrary widget in a System Tray like the Gnome notification area.

EggTrayIcon is slated for inclusion in Gtk+ at some point, which is the reason the Gtk2::TrayIcon namespace. As all egg libs, EggTrayIcon is not considered api stable and its not installed as a shared object.

Enough about what it is not, Gtk2::TrayIcon is first and foremost a simple way of giving a Gtk2 script access to the system tray.

System Trays are found in both KDE and Gnome. But neither support the spec fully (see below).

Gtk2::TrayIcon is a subclass of Gtk2::Plug and should be used as such.

Gtk2::Ex::Utils is a Perl module with extra Gtk2 Utilities for working with Gnome2/Gtk2 in Perl.

SYNOPSIS

use Gtk2::Ex::Utils qw( :main );

# do stuff
...

# Update the UI and react to pending events
process_pending_events();

# do more stuff
...

# Exit the program with a value of 255 for some reason
process_main_exit( 255 );

This module provides simple utility functions useful for Gnome2/Gtk2 Perl programming.

sylpheed-gtk2 is a Gtk+2 port of the Sylpheed. Sylpheed is an e-mail client and news reader based on GTK+ GUI toolkit, and runs on X Window System.
Sylpheed is a free software distributed under the GNU GPL.
The development of Sylpheed sets the following things as its goal:
- Quick response by keeping CPU and memory usage to a minimum
- Fast processing even though a folder contains large number of messages
(more than 10 thousand)
- Enables intuitive operation by simple, graceful, and well-polished
interface
- Similar operation methods to other mailers.
- Readily available with simple configuration
- Fully equipped with features required as a mailer
- Full support of Japanese, and support of i18n
- Enables flexible interaction with external commands
- Stable, and dont lose any data (to the utmost) in case of crash
The interface is also designed to emulate the Emacs-based mailers, and almost all commands are accessible with the keyboard. So you will able to migrate to Sylpheed
without much discomfort in the case where you are accustomed to other
mailers. It has a look similar like Outlook Express, Becky!, Datula.
The messages are managed by MH format, and youll be able to use it together
with another mailer based on MH format (like Mew). It has less possibility
of losing mails on failures since one file corresponds to one mail. You can
import or export mbox format messages. You can also utilize fetchmail or/and
procmail, and external programs on receiving (like inc or imget).
Main features:
- Supported protocols
- POP3
- IMAP4rev1
- SMTP
- NNTP
- SSL/TLSv1 (POP3, SMTP, IMAP4rev1, NNTP)
- IPv6
- Features
- multiple accounts
- thread display
- powerful filtering
- MIME (attachments)
- integrated News reader
- SMTP AUTH support
- CRAM-MD5 authentication (SMTP AUTH / IMAP4rev1)
- APOP authentication (POP3)
- PGP signature / encryption (requires GPGME)
- built-in image view
- X-Face display
- user-defined headers
- color label
- Mew/Wanderlust compatible key bind
- multiple MH folder support
- mbox importing / exporting
- external editor
- message queueing
- automatic mail checking
- draft message
- template
- line-wrapping
- clickable URI
- XML-based address book
- newly arrived and unread message management
- printing
- offline mode
- remote operation by command line
- per-folder configuration
- LDAP, vCard, and JPilot support
- Drag & Drop
- autoconf, automake support
- internationalization of messages by gettext
- support of many code sets, including UTF-8 (Unicode)

Gtk2::TrayManager is a Perl bindings for EggTrayManager.

SYNOPSIS

use Gtk2 -init;
use Gtk2::TrayManager;

my $screen = Gtk2::Gdk::Screen->get_default;

if (Gtk2::TrayManager->check_running($screen)) {
print STDERR "A tray manager is already running, sorry!n";
exit 256;
}

my $tray = Gtk2::TrayManager->new;
$tray->manage_screen($screen);
$tray->set_orientation(vertical);

$tray->signal_connect(tray_icon_added, sub {
# $_[1] is a Gtk2::Socket
});

$tray->signal_connect(tray_icon_removed, sub {
# $_[1] is a Gtk2::Socket
});

The EggTrayManager library is used internally by GNOME to implement the server-side of the Notification Area (or system tray) protocol. Gtk2::TrayManager allows you to create notification area applications using Gtk2-Perl.