761 lines
21 KiB
HTML
761 lines
21 KiB
HTML
|
|
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
|
|
<HTML><HEAD><TITLE>Man page of Glib</TITLE>
|
|
</HEAD><BODY>
|
|
<H1>Glib</H1>
|
|
Section: User Contributed Perl Documentation (3pm)<BR>Updated: 2020-02-18<BR><A HREF="#index">Index</A>
|
|
<A HREF="/cgi-bin/man/man2html">Return to Main Contents</A><HR>
|
|
|
|
|
|
|
|
|
|
|
|
|
|
<A NAME="lbAB"> </A>
|
|
<H2>NAME</H2>
|
|
|
|
Glib - Perl wrappers for the GLib utility and Object libraries
|
|
<A NAME="lbAC"> </A>
|
|
<H2>SYNOPSIS</H2>
|
|
|
|
|
|
|
|
|
|
|
|
<PRE>
|
|
use Glib;
|
|
|
|
</PRE>
|
|
|
|
|
|
<A NAME="lbAD"> </A>
|
|
<H2>ABSTRACT</H2>
|
|
|
|
|
|
|
|
This module provides perl access to GLib and GLib's GObject libraries.
|
|
GLib is a portability and utility library; GObject provides a generic
|
|
type system with inheritance and a powerful signal system. Together
|
|
these libraries are used as the foundation for many of the libraries
|
|
that make up the Gnome environment, and are used in many unrelated
|
|
projects.
|
|
<A NAME="lbAE"> </A>
|
|
<H2>DESCRIPTION</H2>
|
|
|
|
|
|
|
|
This wrapper attempts to provide a perlish interface while remaining
|
|
as true as possible to the underlying C <FONT SIZE="-1">API,</FONT> so that any reference
|
|
materials you can find on using GLib may still apply to using the
|
|
libraries from perl. This module also provides facilities for creating
|
|
wrappers for other GObject-based libraries. The ``<FONT SIZE="-1">SEE ALSO''</FONT> section
|
|
contains pointers to all sorts of good information.
|
|
<A NAME="lbAF"> </A>
|
|
<H2>PERL VERSUS C</H2>
|
|
|
|
|
|
|
|
GLib provides to C programs many of the same facilities Perl offers
|
|
natively. Where GLib's functionality overlaps Perl's, Perl's is favored.
|
|
Some concepts have been eliminated entirely, as Perl is a higher-level
|
|
language than C. In other instances we've had to add or change APIs to
|
|
make sense in Perl. Here's a quick run-down:
|
|
<A NAME="lbAG"> </A>
|
|
<H3>Perl Already Does That</H3>
|
|
|
|
|
|
|
|
The GLib types GList (a doubly-linked list), GSList (singly-linked list),
|
|
GHashTable, GArray, etc have all been replaced by native Perl datatypes. In
|
|
fact, many functions which take GLists or arrays simply accept lists on the
|
|
Perl stack. For the most part, GIOChannels are no more functional than Perl
|
|
file handles, so you won't see any GIOChannels. GClosures are not visible at
|
|
the Perl level, because Perl code references do the same thing. Just about any
|
|
function taking either a C function pointer or a GClosure will accept a code
|
|
reference in Perl. (In fact, you can probably get away with just a subroutine
|
|
name in many spots, provided you aren't using strict subs.)
|
|
<A NAME="lbAH"> </A>
|
|
<H3>Don't Worry About That</H3>
|
|
|
|
|
|
|
|
Some concepts have been eliminated; you need never worry about
|
|
reference-counting on GObjects or having to free GBoxed structures. Perl is a
|
|
garbage-collected language, and we've put a lot of work into making the
|
|
bindings take care of memory for you in a way that feels natural to a Perl
|
|
developer. You won't see GValues in Perl (that's just a C structure with Perl
|
|
scalar envy, anyway).
|
|
<A NAME="lbAI"> </A>
|
|
<H3>This Is Now That</H3>
|
|
|
|
|
|
|
|
Other GLib concepts have been converted to an analogous Perl concept.
|
|
<P>
|
|
|
|
The GType id will never be seen in Perl, as the package name serves that
|
|
purpose. Several packages corresponding to the GTypes of the fundamental types
|
|
have been registered for you:
|
|
<P>
|
|
|
|
|
|
|
|
<PRE>
|
|
G_TYPE_STRING Glib::String
|
|
G_TYPE_INT Glib::Int
|
|
G_TYPE_UINT Glib::UInt
|
|
G_TYPE_DOUBLE Glib::Double
|
|
G_TYPE_BOOLEAN Glib::Boolean
|
|
|
|
</PRE>
|
|
|
|
|
|
<P>
|
|
|
|
The remaining fundamentals (char/uchar, short, float, etc) are also registered
|
|
so that we can properly interact with properties of C objects, but perl really
|
|
only uses ints, uints, and doubles. Oh, and we created a GBoxed type for Perl
|
|
scalars so you can use scalars where any boxed type would be allowed (e.g.
|
|
GtkTreeModel columns):
|
|
<P>
|
|
|
|
|
|
|
|
<PRE>
|
|
Glib::Scalar
|
|
|
|
</PRE>
|
|
|
|
|
|
<P>
|
|
|
|
Functions that can return false and set a GError in C raise an exception in
|
|
Perl, using an exception object based on the GError for $@; see Glib::Error.
|
|
Trapping exceptions in signals is a sticky issue, so they get their own
|
|
section; see <FONT SIZE="-1">EXCEPTIONS</FONT>.
|
|
<P>
|
|
|
|
Enumerations and flags are treated as strings and arrays of strings,
|
|
respectively. GLib provides a way to register nicknames for enumeration
|
|
values, and the Perl bindings use these nicknames for the real values, so that
|
|
we never have to deal with numbers in Perl. This can get a little cumbersome
|
|
for bitfields, but it's very nice when you forget a flag value, as the bindings
|
|
will tell you what values are accepted when you pass something invalid. Also,
|
|
the bindings consider the - and _ characters to be equivalent, so that signal
|
|
and property names can be properly stringified by the => operator. For
|
|
example, the following are equivalent:
|
|
<P>
|
|
|
|
|
|
|
|
<PRE>
|
|
# property foo-matic of type FooType, using the
|
|
# value FOO_SOMETHING_COOL. its nickname would be
|
|
# 'something-cool'. you may use either the full
|
|
# name or the nickname when supplying values to perl.
|
|
$object->set ('foo-matic', 'FOO_SOMETHING_COOL');
|
|
$object->set ('foo_matic', 'something_cool');
|
|
$object->set (foo_matic => 'something-cool');
|
|
|
|
</PRE>
|
|
|
|
|
|
<P>
|
|
|
|
Beware that Perl will always return to you the nickname form, with the dash.
|
|
<P>
|
|
|
|
Flags have some additional magic abilities in the form of overloaded
|
|
operators:
|
|
<P>
|
|
|
|
|
|
|
|
<PRE>
|
|
+ or | union of two flagsets ("add")
|
|
- difference of two flagsets ("sub", "remove")
|
|
* or & intersection of two bitsets ("and")
|
|
/ or ^ symmetric difference ("xor", you will rarely need this)
|
|
>= contains-operator ("is the left set a superset of the right set?")
|
|
== equality
|
|
|
|
</PRE>
|
|
|
|
|
|
<P>
|
|
|
|
In addition, flags in boolean context indicate whether they are empty or
|
|
not, which allows you to write common operations naturally:
|
|
<P>
|
|
|
|
|
|
|
|
<PRE>
|
|
$widget->set_events ($widget->get_events - "motion_notify_mask");
|
|
$widget->set_events ($widget->get_events - ["motion_notify_mask",
|
|
"button_press_mask"]);
|
|
|
|
# shift pressed (both work, it's a matter of taste)
|
|
if ($event->state >= "shift-mask") { ...
|
|
if ($event->state * "shift-mask") { ...
|
|
|
|
# either shift OR control pressed?
|
|
if ($event->state * ["shift-mask", "control-mask"]) { ...
|
|
|
|
# both shift AND control pressed?
|
|
if ($event->state >= ["shift-mask", "control-mask"]) { ...
|
|
|
|
</PRE>
|
|
|
|
|
|
<P>
|
|
|
|
In general, <TT>"+"</TT> and <TT>"-"</TT> work as expected to add or remove flags. To test
|
|
whether <I>any</I> bits are set in a mask, you use <TT>"$mask * ..."</TT>, and to test
|
|
whether <I>all</I> bits are set in a mask, you use <TT>"$mask >= ..."</TT>.
|
|
<P>
|
|
|
|
When dereferenced as an array <TT>@$flags</TT> or <TT>"$flags->[...]"</TT>, you can
|
|
access the flag values directly as strings (but you are not allowed to
|
|
modify the array), and when stringified <TT>"$flags"</TT> a flags value will
|
|
output a human-readable version of its contents.
|
|
<A NAME="lbAJ"> </A>
|
|
<H3>It's All the Same</H3>
|
|
|
|
|
|
|
|
For the most part, the remaining bits of GLib are unchanged. GMainLoop is now
|
|
Glib::MainLoop, GObject is now Glib::Object, GBoxed is now Glib::Boxed, etc.
|
|
<A NAME="lbAK"> </A>
|
|
<H2>FILENAMES, URIS AND ENCODINGS</H2>
|
|
|
|
|
|
|
|
Perl knows two datatypes, unicode text and binary bytes. Filenames on
|
|
a system that doesn't use a utf-8 locale are often stored in a local
|
|
encoding (``binary bytes''). Gtk+ and descendants, however, internally
|
|
work in unicode most of the time, so when feeding a filename into a
|
|
GLib/Gtk+ function that expects a filename, you first need to convert it
|
|
from the local encoding to unicode.
|
|
<P>
|
|
|
|
This involves some elaborate guessing, which perl currently avoids, but
|
|
GLib and Gtk+ do. As an exception, some Gtk+ functions want a filename
|
|
in local encoding, but the perl interface usually works around this by
|
|
automatically converting it for you.
|
|
<P>
|
|
|
|
In short: Everything should be in unicode on the perl level.
|
|
<P>
|
|
|
|
The following functions expose the conversion algorithm that GLib uses.
|
|
<P>
|
|
|
|
These functions are only necessary when you want to use perl functions
|
|
to manage filenames returned by a GLib/Gtk+ function, or when you feed
|
|
filenames into GLib/Gtk+ functions that have their source outside your
|
|
program (e.g. commandline arguments, readdir results etc.).
|
|
<P>
|
|
|
|
These functions are available as exports by request (see ``Exports''),
|
|
and also support method invocation syntax for pathological consistency
|
|
with the <FONT SIZE="-1">OO</FONT> syntax of the rest of the bindings.
|
|
<DL COMPACT>
|
|
<DT id="1">$filename = filename_to_unicode $filename_in_local_encoding<DD>
|
|
|
|
|
|
|
|
|
|
|
|
<DT id="2">$filename = Glib->filename_to_unicode ($filename_in_local_encoding)<DD>
|
|
|
|
|
|
|
|
|
|
|
|
Convert a perl string that supposedly contains a filename in local
|
|
encoding into a filename represented as unicode, the same way that GLib
|
|
does it internally.
|
|
|
|
|
|
<P>
|
|
|
|
|
|
Example:
|
|
|
|
|
|
<P>
|
|
|
|
|
|
|
|
|
|
<PRE>
|
|
$gtkfilesel->set_filename (filename_to_unicode $ARGV[1]);
|
|
|
|
</PRE>
|
|
|
|
|
|
|
|
|
|
<P>
|
|
|
|
|
|
This function will <B>croak()</B> if the conversion cannot be made, e.g., because the
|
|
utf-8 is invalid.
|
|
<DT id="3">$filename_in_local_encoding = filename_from_unicode $filename<DD>
|
|
|
|
|
|
|
|
|
|
|
|
<DT id="4">$filename_in_local_encoding = Glib->filename_from_unicode ($filename)<DD>
|
|
|
|
|
|
|
|
|
|
|
|
Converts a perl string containing a filename into a filename in the local
|
|
encoding in the same way GLib does it.
|
|
|
|
|
|
<P>
|
|
|
|
|
|
Example:
|
|
|
|
|
|
<P>
|
|
|
|
|
|
|
|
|
|
<PRE>
|
|
open MY, "<", filename_from_unicode $gtkfilesel->get_filename;
|
|
|
|
</PRE>
|
|
|
|
|
|
</DL>
|
|
<P>
|
|
|
|
It might
|
|
be useful to know that perl currently has no policy at all regarding
|
|
filename issues, if your scalar happens to be in utf-8 internally it will
|
|
use utf-8, if it happens to be stored as bytes, it will use it as-is.
|
|
<P>
|
|
|
|
When dealing with filenames that you need to display, there is a much easier
|
|
way, as of Glib 1.120 and glib 2.6.0:
|
|
<DL COMPACT>
|
|
<DT id="5">$uft8_string = filename_display_name ($filename)<DD>
|
|
|
|
|
|
|
|
|
|
|
|
<DT id="6">$uft8_string = filename_display_basename ($filename)<DD>
|
|
|
|
|
|
|
|
|
|
|
|
Given a <I></I>$filename<I></I> in filename encoding, return the filename, or just
|
|
the file's basename, in utf-8. Unlike the other functions described above,
|
|
this one is guaranteed to return valid utf-8, but the conversion is not
|
|
necessarily reversible. These functions are intended to be used for failsafe
|
|
display of filenames, for example in gtk+ labels.
|
|
|
|
|
|
<P>
|
|
|
|
|
|
Since glib 2.6, Glib 1.12
|
|
</DL>
|
|
<P>
|
|
|
|
The following convert filenames to and from <FONT SIZE="-1">URI</FONT> encoding. (See also
|
|
URI::file.)
|
|
<DL COMPACT>
|
|
<DT id="7">$string = filename_to_uri ($filename, $hostname)<DD>
|
|
|
|
|
|
|
|
|
|
|
|
<DT id="8">$string = Glib->filename_to_uri ($filename, $hostname)<DD>
|
|
|
|
|
|
|
|
|
|
|
|
Return a ``<A HREF="file://''">file://''</A> schema <FONT SIZE="-1">URI</FONT> for a filename. Unsafe and non-ascii chars in
|
|
<TT>$filename</TT> are escaped with <FONT SIZE="-1">URI</FONT> ``%'' forms.
|
|
|
|
|
|
<P>
|
|
|
|
|
|
<TT>$filename</TT> must be an absolute path as a byte string in local filesystem
|
|
encoding. <TT>$hostname</TT> is a utf-8 string, or empty or <TT>"undef"</TT> for no host
|
|
specified. For example,
|
|
|
|
|
|
<P>
|
|
|
|
|
|
|
|
|
|
<PRE>
|
|
filename_to_uri ('/my/x%y/<dir>/foo.html', undef);
|
|
# returns '<A HREF="file:///my/x%25y/%3Cdir%3E/foo.html'">file:///my/x%25y/%3Cdir%3E/foo.html'</A>
|
|
|
|
</PRE>
|
|
|
|
|
|
|
|
|
|
<P>
|
|
|
|
|
|
If <TT>$filename</TT> is a relative path or <TT>$hostname</TT> doesn't look like a
|
|
hostname then <TT>"filename_to_uri"</TT> croaks with a <TT>"Glib::Error"</TT>.
|
|
|
|
|
|
<P>
|
|
|
|
|
|
When using the class style <TT>"Glib->filename_to_uri"</TT> remember that the
|
|
<TT>$hostname</TT> argument is mandatory. If you forget then it looks like a
|
|
2-argument call with filename of ``Glib'' and hostname of what you meant to be
|
|
the filename.
|
|
<DT id="9">$filename = filename_from_uri ($uri)<DD>
|
|
|
|
|
|
|
|
|
|
|
|
<DT id="10">($filename, $hostname) = filename_from_uri ($uri)<DD>
|
|
|
|
|
|
|
|
|
|
|
|
Extract the filename and hostname from a ``<A HREF="file://''">file://''</A> schema <FONT SIZE="-1">URI.</FONT> In scalar
|
|
context just the filename is returned, in array context both filename and
|
|
hostname are returned.
|
|
|
|
|
|
<P>
|
|
|
|
|
|
The filename returned is bytes in the local filesystem encoding and with the
|
|
<FONT SIZE="-1">OS</FONT> path separator character. The hostname returned is utf-8. For example,
|
|
|
|
|
|
<P>
|
|
|
|
|
|
|
|
|
|
<PRE>
|
|
($f,$h) = filename_from_uri ('<A HREF="file://foo.com/r%26b/bar.html');">file://foo.com/r%26b/bar.html');</A>
|
|
# returns '/r&b/bar.html' and 'foo.com' on Unix
|
|
|
|
</PRE>
|
|
|
|
|
|
|
|
|
|
<P>
|
|
|
|
|
|
If <TT>$uri</TT> is not a ``file:'', or is mal-formed, or the hostname part doesn't
|
|
look like a host name then <TT>"filename_from_uri"</TT> croaks with a
|
|
<TT>"Glib::Error"</TT>.
|
|
</DL>
|
|
<A NAME="lbAL"> </A>
|
|
<H2>EXCEPTIONS</H2>
|
|
|
|
|
|
|
|
The C language doesn't support exceptions; GLib is a C library, and of course
|
|
doesn't support exceptions either. In Perl, we use die and eval to raise
|
|
and trap exceptions as a rather common practice. So, the bindings have to
|
|
work a little black magic behind the scenes to keep GLib from exploding when
|
|
the Perl program uses exceptions. Unfortunately, a little of this magic
|
|
has to leak out to where you can see it at the Perl level.
|
|
<P>
|
|
|
|
Signal and event handlers are run in an eval context; if an exception occurs
|
|
in such a handler and you don't catch it, Perl will report that an error
|
|
occurred, and then go on about its business like nothing happened.
|
|
<P>
|
|
|
|
You may register subroutines as exception handlers, to be called when such
|
|
an exception is trapped. Another function removes them for you.
|
|
<P>
|
|
|
|
|
|
|
|
<PRE>
|
|
$tag = Glib->install_exception_handler (\&my_handler);
|
|
Glib->remove_exception_handler ($tag);
|
|
|
|
</PRE>
|
|
|
|
|
|
<P>
|
|
|
|
The exception handler will get a fresh copy of the $@ of the offending
|
|
exception on the argument stack, and is expected to return non-zero if the
|
|
handler is to remain installed. If it returns false, the handler will be
|
|
removed.
|
|
<P>
|
|
|
|
|
|
|
|
<PRE>
|
|
sub my_handler {
|
|
if ($_[0] =~ m/ftang quisinart/) {
|
|
clean_up_after_ftang ();
|
|
}
|
|
1; # live to fight another day
|
|
}
|
|
|
|
</PRE>
|
|
|
|
|
|
<P>
|
|
|
|
You can register as many handlers as you like; they will all run
|
|
independently.
|
|
<P>
|
|
|
|
An important thing to remember is that exceptions do not cross main loops.
|
|
In fact, exceptions are completely distinct from main loops. If you need
|
|
to quit a main loop when an exception occurs, install a handler that quits
|
|
the main loop, but also ask yourself if you are using exceptions for flow
|
|
control or exception handling.
|
|
<A NAME="lbAM"> </A>
|
|
<H2>LOG MESSAGES</H2>
|
|
|
|
|
|
|
|
GLib's g_log function provides a flexible mechanism for reporting messages,
|
|
and most GLib-based C libraries use this mechanism for warnings, assertions,
|
|
critical messages, etc. The Perl bindings offer a mechanism for routing
|
|
these messages through Perl's native system, <B>warn()</B> and <B>die()</B>. Extensions
|
|
should register the log domains they wrap for this to happen fluidly.
|
|
[<FONT SIZE="-1">FIXME</FONT> say more here]
|
|
<A NAME="lbAN"> </A>
|
|
<H2>64 BIT INTEGERS</H2>
|
|
|
|
|
|
|
|
Since perl's integer data type can only hold 32 bit values on all 32 bit
|
|
machines and even on some 64 bit machines, Glib converts 64 bit integers to and
|
|
from strings if necessary. These strings can then be used to feed one of the
|
|
various big integer modules. Make sure you don't let your strings get into
|
|
numerical context before passing them into a Glib function because in this
|
|
case, perl will convert the number to scientific notation which at this point
|
|
is not understood by Glib's converters.
|
|
<P>
|
|
|
|
Here is an overview of what big integer modules are available. First of all,
|
|
there's Math::BigInt. It has everything you will ever need, but its pure-Perl
|
|
implementation is also rather slow. There are multiple ways around this,
|
|
though.
|
|
<DL COMPACT>
|
|
<DT id="11">Math::BigInt::FastCalc<DD>
|
|
|
|
|
|
Math::BigInt::FastCalc can help avoid the glacial speed of vanilla
|
|
Math::BigInt::Calc. Recent versions of Math::BigInt will automatically
|
|
use Math::BigInt::FastCalc in place of Math::BigInt::Calc when available.
|
|
Other options include Math::BigInt::GMP or Math::BigInt::Pari, which
|
|
however have much larger dependencies.
|
|
<DT id="12">Math::BigInt::Lite<DD>
|
|
|
|
|
|
Then there's Math::BigInt::Lite, which uses native Perl integer operations
|
|
as long as Perl integers have sufficient range, and upgrades itself to
|
|
Math::BigInt when Perl integers would overflow. This must be used in place
|
|
of Math::BigInt.
|
|
<DT id="13">bigint / bignum / bigfloat<DD>
|
|
|
|
|
|
Finally, there's the bigint/bignum/bigfloat pragmata, which automatically load
|
|
the corresponding Math:: modules and which will autobox constants.
|
|
bignum/bigint will automatically use Math::BigInt::Lite if it's available.
|
|
</DL>
|
|
<A NAME="lbAO"> </A>
|
|
<H2>EXPORTS</H2>
|
|
|
|
|
|
|
|
For the most part, gtk2-perl avoids exporting things. Nothing is exported by
|
|
default, but some functions and constants in Glib are available by request;
|
|
you can also get all of them with the export tag ``all''.
|
|
<DL COMPACT>
|
|
<DT id="14">Tag: constants<DD>
|
|
|
|
|
|
|
|
|
|
<PRE>
|
|
TRUE
|
|
FALSE
|
|
SOURCE_CONTINUE
|
|
SOURCE_REMOVE
|
|
G_PRIORITY_HIGH
|
|
G_PRIORITY_DEFAULT
|
|
G_PRIORITY_HIGH_IDLE
|
|
G_PRIORITY_DEFAULT_IDLE
|
|
G_PRIORITY_LOW
|
|
G_PARAM_READWRITE
|
|
|
|
</PRE>
|
|
|
|
|
|
<DT id="15">Tag: functions<DD>
|
|
|
|
|
|
|
|
|
|
<PRE>
|
|
filename_from_unicode
|
|
filename_to_unicode
|
|
filename_from_uri
|
|
filename_to_uri
|
|
filename_display_basename
|
|
filename_display_name
|
|
|
|
</PRE>
|
|
|
|
|
|
</DL>
|
|
<A NAME="lbAP"> </A>
|
|
<H2>SEE ALSO</H2>
|
|
|
|
|
|
|
|
Glib::Object::Subclass explains how to create your own gobject subclasses
|
|
in Perl.
|
|
<P>
|
|
|
|
Glib::index lists the automatically-generated <FONT SIZE="-1">API</FONT> reference for the
|
|
various packages in Glib.
|
|
<P>
|
|
|
|
This module is the basis for the Gtk2 module, so most of the references
|
|
you'll be able to find about this one are tied to that one. The perl
|
|
interface aims to be very simply related to the C <FONT SIZE="-1">API,</FONT> so see the C <FONT SIZE="-1">API</FONT>
|
|
reference documentation:
|
|
<P>
|
|
|
|
|
|
|
|
<PRE>
|
|
GLib - <A HREF="http://developer.gnome.org/doc/API/2.0/glib/">http://developer.gnome.org/doc/API/2.0/glib/</A>
|
|
GObject - <A HREF="http://developer.gnome.org/doc/API/2.0/gobject/">http://developer.gnome.org/doc/API/2.0/gobject/</A>
|
|
|
|
</PRE>
|
|
|
|
|
|
<P>
|
|
|
|
This module serves as the foundation for any module which needs to bind
|
|
GLib-based C libraries to perl.
|
|
<P>
|
|
|
|
|
|
|
|
<PRE>
|
|
Glib::devel - Binding developer's overview of Glib's internals
|
|
Glib::xsapi - internal API reference for GPerl
|
|
Glib::ParseXSDoc - extract API docs from xs sources.
|
|
Glib::GenPod - turn the output of Glib::ParseXSDoc into POD
|
|
Glib::MakeHelper - Makefile.PL utilities for Glib-based extensions
|
|
|
|
Yet another document, available separately, ties it all together:
|
|
<A HREF="http://gtk2-perl.sourceforge.net/doc/binding_howto.pod.html">http://gtk2-perl.sourceforge.net/doc/binding_howto.pod.html</A>
|
|
|
|
</PRE>
|
|
|
|
|
|
<P>
|
|
|
|
For gtk2-perl itself, see its website at
|
|
<P>
|
|
|
|
|
|
|
|
<PRE>
|
|
gtk2-perl - <A HREF="http://gtk2-perl.sourceforge.net/">http://gtk2-perl.sourceforge.net/</A>
|
|
|
|
</PRE>
|
|
|
|
|
|
<P>
|
|
|
|
A mailing list exists for discussion of using gtk2-perl and related
|
|
modules. Archives and subscription information are available at
|
|
<A HREF="http://lists.gnome.org/.">http://lists.gnome.org/.</A>
|
|
<A NAME="lbAQ"> </A>
|
|
<H2>AUTHORS</H2>
|
|
|
|
|
|
|
|
muppet, <scott at asofyet dot org>, who borrowed heavily from the work
|
|
of Göran Thyni, <gthyni at kirra dot net> and Guillaume Cottenceau
|
|
<gc at mandrakesoft dot com> on the first gtk2-perl module, and from
|
|
the sourcecode of the original gtk-perl and pygtk projects. Marc Lehmann
|
|
<pcg at goof dot com> did lots of great work on the magic of making
|
|
Glib::Object wrapper and subclassing work like they should. Ross McFarland
|
|
<rwmcfa1 at neces dot com> wrote quite a bit of the documentation generation
|
|
tools. Torsten Schoenfeld <kaffeetisch at web dot de> contributed little
|
|
patches and tests here and there.
|
|
<A NAME="lbAR"> </A>
|
|
<H2>COPYRIGHT AND LICENSE</H2>
|
|
|
|
|
|
|
|
Copyright 2003-2011 by muppet and the gtk2-perl team
|
|
<P>
|
|
|
|
This library is free software; you can redistribute it and/or modify
|
|
it under the terms of the Lesser General Public License (<FONT SIZE="-1">LGPL</FONT>). For
|
|
more information, see <A HREF="http://www.fsf.org/licenses/lgpl.txt">http://www.fsf.org/licenses/lgpl.txt</A>
|
|
<P>
|
|
|
|
<HR>
|
|
<A NAME="index"> </A><H2>Index</H2>
|
|
<DL>
|
|
<DT id="16"><A HREF="#lbAB">NAME</A><DD>
|
|
<DT id="17"><A HREF="#lbAC">SYNOPSIS</A><DD>
|
|
<DT id="18"><A HREF="#lbAD">ABSTRACT</A><DD>
|
|
<DT id="19"><A HREF="#lbAE">DESCRIPTION</A><DD>
|
|
<DT id="20"><A HREF="#lbAF">PERL VERSUS C</A><DD>
|
|
<DL>
|
|
<DT id="21"><A HREF="#lbAG">Perl Already Does That</A><DD>
|
|
<DT id="22"><A HREF="#lbAH">Don't Worry About That</A><DD>
|
|
<DT id="23"><A HREF="#lbAI">This Is Now That</A><DD>
|
|
<DT id="24"><A HREF="#lbAJ">It's All the Same</A><DD>
|
|
</DL>
|
|
<DT id="25"><A HREF="#lbAK">FILENAMES, URIS AND ENCODINGS</A><DD>
|
|
<DT id="26"><A HREF="#lbAL">EXCEPTIONS</A><DD>
|
|
<DT id="27"><A HREF="#lbAM">LOG MESSAGES</A><DD>
|
|
<DT id="28"><A HREF="#lbAN">64 BIT INTEGERS</A><DD>
|
|
<DT id="29"><A HREF="#lbAO">EXPORTS</A><DD>
|
|
<DT id="30"><A HREF="#lbAP">SEE ALSO</A><DD>
|
|
<DT id="31"><A HREF="#lbAQ">AUTHORS</A><DD>
|
|
<DT id="32"><A HREF="#lbAR">COPYRIGHT AND LICENSE</A><DD>
|
|
</DL>
|
|
<HR>
|
|
This document was created by
|
|
<A HREF="/cgi-bin/man/man2html">man2html</A>,
|
|
using the manual pages.<BR>
|
|
Time: 00:05:44 GMT, March 31, 2021
|
|
</BODY>
|
|
</HTML>
|