[gimp-perl] Add podregister, some doc tidy-up
- From: Ed J <edj src gnome org>
- To: commits-list gnome org
- Cc:
- Subject: [gimp-perl] Add podregister, some doc tidy-up
- Date: Wed, 23 Apr 2014 05:13:41 +0000 (UTC)
commit 202c80cdc44de251869e8de12ebe4acc6175b6f1
Author: Ed J <m8r-35s8eo mailinator com>
Date: Mon Apr 21 20:59:51 2014 +0100
Add podregister, some doc tidy-up
Gimp.pm | 689 ++++++++++++++++++++++++++++----------------
Gimp/Config.pm.in | 2 +-
Gimp/Data.pm | 14 +-
Gimp/Fu.pm | 442 ++++++++++++++++------------
Gimp/OO.pod | 191 ------------
Gimp/PixelRgn.pod | 4 +-
Gimp/Util.pm | 2 +-
MANIFEST | 1 -
Net/Net.pm | 2 +-
TODO | 3 +-
examples/billboard | 327 ++++++++++-----------
examples/dots | 161 +++++------
examples/dust | 54 +++--
examples/example-fu | 142 +++++-----
examples/exceptiontest | 2 +-
examples/fade-alpha | 408 +++++++--------------------
examples/layerfuncs | 4 +-
examples/redeye | 7 +-
examples/selective_sharpen | 107 ++++---
examples/xachshadow | 41 ++--
t/netplugin.t | 2 +-
21 files changed, 1229 insertions(+), 1376 deletions(-)
---
diff --git a/Gimp.pm b/Gimp.pm
index 1862796..9b00daf 100644
--- a/Gimp.pm
+++ b/Gimp.pm
@@ -335,13 +335,15 @@ sub AUTOLOAD {
sub _pseudoclass {
my ($class, @prefixes)= @_;
- unshift(@prefixes,"");
+ unshift @prefixes,"";
*{"Gimp::$class\::AUTOLOAD"} = \&AUTOLOAD;
- push(@{"Gimp::$class\::PREFIXES"} , @prefixes); @prefixes= {"Gimp::$class\::PREFIXES"};
+ push @{"Gimp::$class\::PREFIXES"}, @prefixes;
+ push @{"Gimp::$class\::ISA"}, 'Gimp::Base';
push @POLLUTE_CLASSES, $class;
+ @{"Gimp::$class\::PREFIXES"}; # to suppress only-once warning
}
-my @plugin_prefixes = qw(plug_in_ perl_fu_);
+my @plugin_prefixes = qw(plug_in_ perl_fu_ script_fu_);
my @image_prefixes = (qw(gimp_image_ gimp_), @plugin_prefixes);
my @item_prefixes = (qw(gimp_item_), @image_prefixes);
my @drawable_prefixes = (qw(gimp_drawable_), @item_prefixes);
@@ -359,7 +361,7 @@ _pseudoclass qw(Gradient gimp_gradient_);
_pseudoclass qw(Gradients gimp_gradients_);
_pseudoclass qw(Edit gimp_edit_);
_pseudoclass qw(Progress gimp_progress_);
-_pseudoclass qw(GimpParasite );
+_pseudoclass qw(Parasite );
push @Gimp::Drawable::ISA, qw(Gimp::Item);
push @Gimp::Vectors::ISA, qw(Gimp::Item);
@@ -391,7 +393,6 @@ sub new($$$$$$$$) {
{
package Gimp::Parasite;
-
sub is_type($$) { $_[0]->[0] eq $_[1] }
sub is_persistent($) { $_[0]->[1] & &Gimp::PARASITE_PERSISTENT }
sub is_error($) { !defined $_[0]->[0] }
@@ -406,154 +407,213 @@ sub compare($$) { $_[0]->[0] eq $_[1]->[0] and
sub new($$$$) { shift; [ _] }
}
+{
+package Gimp::Base;
+use overload '""' => sub { ref($_[0]).'->existing('.${$_[0]}.')'; };
+sub existing($$) { bless \$_[1], $_[0]; }
+sub become($$) { bless $_[0], $_[1]; }
+}
+
1;
__END__
=head1 NAME
-Gimp - a Perl extension for writing Gimp Extensions/Plug-ins/Load &
-Save-Handlers
-
-This is a release of gimp-perl for gimp-2.8. It is not compatible with
-version 2.6 or below of GIMP.
-
-This is mostly a reference manual. For a quick intro, look at
-L<Gimp::Fu>.
+Gimp - write GIMP extensions/plug-ins/load- and save-handlers in Perl
=head1 SYNOPSIS
use Gimp;
use Gimp::Fu; # easy scripting environment
-=head2 IMPORT TAGS
+ podregister {
+ # your code
+ return Gimp::Image->new(100, 100, RGB);
+ };
-Place these in your C<use Gimp qw(...)> command to have added features
-available to your plug-in.
+ exit main;
+ __END__
+ =head1 NAME
-=over 2
+ function_name - Short description of the function
-=item :auto
+ =head1 SYNOPSIS
-Import useful constants, like RGB, RUN_NONINTERACTIVE... as well as all
-libgimp and pdb functions automagically into the caller's namespace.
-This will overwrite your AUTOLOAD function, if you have one. The AUTOLOAD
-function that gets installed must only be used in OO mode - either as
-an object or a class method call - the only exception is when the first
-argument is a reference (including objects):
+ <Image>/Filters/Menu/Location...
- use Gimp qw(:auto);
- Gimp->displays_flush; # fine
- my $name = $layer->get_name; # also fine
- gimp_quit(0); # will lose its parameter, due to Perl's OO implementation!
- Gimp->quit(0); # works correctly
- gimp_image_undo_disable($image); # as does this, by a coincidence
+ =head1 DESCRIPTION
-=item :param
+ Longer description of the function...
-Import constants for plugin parameter types (PDB_INT32, PDB_STRING
-etc.) only.
+=head1 DESCRIPTION
-=item :consts
+Gimp-Perl is a module for writing plug-ins, extensions, standalone
+scripts, and file-handlers for the GNU Image Manipulation Program (GIMP).
+It can be used to automate repetitive tasks, achieve a precision hard
+to get through manual use of GIMP, interface to a web server, or other
+tasks that involve GIMP.
-All constants found by querying GIMP (BG_IMAGE_FILL, RUN_NONINTERACTIVE,
-NORMAL_MODE, PDB_INT32 etc.).
+It is developed on Linux, and should work with similar OSes.
+This is a release of Gimp-Perl for gimp-2.8. It is not compatible with
+version 2.6 or below of GIMP.
-=item :pollute
+To jump straight into how to write GIMP plugins, see L<Gimp::Fu>:
+it is recommended for scripts not requiring custom interfaces
+or specialized execution. If you B<do> need a custom interface, see
+C<examples/example-no-fu> - although L<Gimp::Fu> does also offer custom
+widgets, see the same script using Gimp::Fu in C<examples/fade-alpha>.
+Lots of other examples are in the C<examples/> directory of your gimp-perl
+source tree, some of which will be installed in your plug-ins directory
+if you are running from a package.
-In previous version of C<gimp-perl>, you could refer to GIMP classes
-as either e.g. Gimp::Image, OR Image. Now in order to not pollute the
-namespace, the second option will be available only when this option
-is specified.
+Using the C<Help/Procedure Browser> is a good way to learn GIMP's
+Procedural Database (PDB). For referencing functions you already know of,
+the included script L<gimpdoc> is useful.
-=item spawn_options=I<options>
+Some highlights:
-Set default spawn options to I<options>, see L<Gimp::Net>.
+=over 4
-=item :DEFAULT
+=item *
+
+Access to GIMP's Procedural Database (PDB) for manipulation of
+most objects.
+
+=item *
+
+Program with either a fully object-oriented syntax, or a (deprecated)
+plain PDB (scheme-like) interface.
+
+=item *
-The default set (see below).
+Scripts that use Gimp::Fu can be accessed seamlessly either from
+GIMP's menus, other scripting interfaces like Script-Fu, or from the
+command line (execute the plugin with the C<--help> flag for more
+information).
+
+In the latter case, Gimp::Fu can either connect to a GIMP already running,
+or start up its own.
+
+=item *
+
+Access the pixel-data functions using L<PDL> (see L<Gimp::PixelRgn>)
+giving the same level of control as a C plug-in, with a data language
+wrapper.
+
+=item *
+
+Over 50 example scripts to give you a good starting point, or use out
+of the box.
=back
-The default (unless '' is specified) is C<':consts', 'N_', '__'>.
-(C<'__'> is used for i18n purposes).
+=head1 IMPORT TAGS
-=head1 GETTING STARTED
+Place these in your C<use Gimp qw(...)> command to have added features
+available to your plug-in.
-L<Gimp::Fu> is recommended for scripts not requiring custom interfaces
-or specialized execution. Lots of examples are in the C<examples/>
-directory of your gimp-perl source tree, or installed in your plug-ins
-directory if you are running from a package.
+=over 4
-Using the C<Help/Procedure Browser> is a good way to learn GIMP's
-Procedural Database(pdb). For referencing functions you already know of,
-the included script L<gimpdoc> is useful.
+=item :consts
-=head1 DESCRIPTION
+All constants found by querying GIMP (BG_IMAGE_FILL, RUN_NONINTERACTIVE,
+NORMAL_MODE, PDB_INT32 etc.).
-Gimp-Perl is a module for writing plug-ins, extensions, standalone
-scripts, and file-handlers for The GNU Image Manipulation Program (The
-GIMP). It can be used to automate repetitive tasks, achieve a precision
-hard to get through manual use of GIMP, interface to a web server,
-or other tasks that involve Gimp.
+=item :param
-It is developed on Linux, and should work with similar OSes.
+Import constants for plugin parameter types (PDB_INT32, PDB_STRING
+etc.) only.
-Some highlights:
+=item net_init=I<options>
-=over 2
+This is how to use Gimp-Perl in "net mode". Previous versions of this
+package required a call to Gimp::init. This is no longer necessary. The
+technical reason for this change is that when C<Gimp.pm> loads, it must
+connect to GIMP to load its constants, like C<PDB_INT32>.
-=item *
-Access to GIMP's Procedural Database (pdb) for manipulation of
-most objects.
+Possible options include C<spawn/gui> or C<unix/path/to/socket>. See
+L<Gimp::Net/ENVIRONMENT> for other possibilities. If this is not
+specified, C<Gimp> will try various options, falling back to C<spawn>
+which starts a new GIMP instance.
-=item *
-Use either a plain pdb (scheme-like but with perl OO
-class method) interface or a fully object-oriented syntax,
-i.e. C<Gimp-E<gt>image_new(600,300,RGB)> is the same as C<new
-Gimp::Image(600,300,RGB)>.
+It is important that C<Gimp> be able to connect to an instance of GIMP
+one way or another: otherwise, it will not be able to load the various
+constants on which modules rely. The connection is made when
+C<Gimp::import> is called, after C<Gimp> has been compiled - so don't
+put C<use Gimp ();>
-=item *
-Networked plug-ins look/behave the same as those running from within gimp.
+=item spawn_options=I<options>
-=item *
-Gimp::Fu will start GIMP for you, if it cannot connect to an existing
-GIMP process.
+Set default spawn options to I<options>, see L<Gimp::Net>.
-=item *
-You can access the pixel-data functions using piddles (see
-L<Gimp::PixelRgn>) giving the same level of control as a C plug-in,
-with a data language wrapper.
+=item :DEFAULT
-=item *
-Over 50 example scripts to give you a good starting point, or use as is.
+The default set: C<':consts', 'N_', '__'>. (C<'__'> is used for i18n
+purposes).
+
+=item ''
+
+Over-ride (don't import) the defaults.
+
+=item :auto (DEPRECATED)
+
+Import constants as above, as well as all libgimp and PDB functions
+automagically into the caller's namespace. This will overwrite your
+AUTOLOAD function, if you have one. The AUTOLOAD function that gets
+installed can only be used with PDB functions whose first argument is
+a reference (including objects):
+
+ use Gimp qw(:auto);
+ Gimp->displays_flush; # fine
+ my $name = $layer->get_name; # also fine
+ gimp_quit(0); # will lose its parameter, due to Perl's OO implementation!
+ Gimp->quit(0); # works correctly
+ gimp_image_undo_disable($image); # as does this, by a coincidence
+
+This tag is deprecated, and you will be far better off using Gimp-Perl
+solely in OO mode.
+
+=item :pollute (DEPRECATED)
+
+In previous version of C<gimp-perl>, you could refer to GIMP classes
+as either e.g. Gimp::Image, B<and> as Image. Now in order to not pollute
+the namespace, the second option will be available only when this option
+is specified.
=back
=head1 ARCHITECTURE
There are two modes of operation: the perl is called by GIMP (as a
-plugin/filter) ("plugin mode"), or GIMP is called by perl (which uses the
+plugin/filter) ("B<plugin mode>"), or GIMP is called by perl (which uses the
Gimp::Net functionality) - either connecting to an existing GIMP process
-("net mode"), or starting its own one ("batch mode").
+("B<net mode>"), or starting its own one ("B<batch mode>").
=head2 Plugin
-The perl script is written as a plug-in using C<Gimp::Fu> as described
-above. The architecture is simply that Gimp, on start-up, runs all
-its plug-ins at startup including all the perl scripts in its plugins
-directory. The perl scripts will register themselves as GIMP "procedures"
-in the PDB. When these procedures are called, typically from the menu
-system, the perl script will be run and supplied with the appropriate
-arguments.
+There are four "entry points" into GIMP plugins: B<init>, B<query>,
+B<run>, and B<quit>. Gimp-Perl provides hooks for the last 3; the first
+is implicitly done as the script executes, then either query or run,
+then quit on exit.
+
+The perl script is written as a plug-in, probably using C<Gimp::Fu>.
+GIMP, on start-up, runs all the plug-ins in its plugins directory at
+startup (including all the perl scripts) in "query" mode.
+
+Any plugin will register itself as a GIMP "procedure" in the PDB, during
+its run in "query" mode.
+
+When such a procedure is called, either from the menu system or a
+scripting interface, the plugin will be run in "run" mode, and GIMP will
+supply it with the appropriate arguments.
=head2 From outside GIMP
-The script will use C<Gimp> as above, and use Gimp functions as it
+The script will use C<Gimp> as above, and use GIMP functions as it
wishes. If you are using GIMP interactively, you need to run the Perl
-server (under "Filters/Perl" to allow your script to connect. Otherwise,
+Server (under "Filters/Perl") to allow your script to connect. Otherwise,
the script will start its own GIMP, in "batch mode". Either way,
your script, when it uses GIMP procedures (and Gimp-Perl functions),
-will actually be communicating with the perl server running under GIMP.
+will actually be communicating with the Perl server running under GIMP.
The architecture may be visualised like this:
@@ -573,7 +633,11 @@ The return code should be immediately handed out to exit:
exit Gimp::main;
-Before the call to C<Gimp::main>, I<no> other PDB function must be called.
+It used to be the case that before the call to C<Gimp::main>, I<no>
+other PDB function could be called. This is no longer the case (see
+L</"net_init=I<options>">), but there is no point in doing so outside of a
+"run" hook (unless you have the privilege and joy of writing test modules
+for Gimp-Perl!).
In a C<Gimp::Fu>-script, it will actually call C<Gimp::Fu::main> instead
of C<Gimp::main>:
@@ -592,24 +656,25 @@ C<main> to return at all, but still call C<exit> immediately.
The C<Gimp> module provides routines to be optionally filled in by a
plug-in writer. This does not apply if using C<Gimp::Fu>, as these are
-done automatically.
+done automatically. These are specifically how your program can fit into
+the model of query, run and quit hooks.
-=over 2
+=over 4
=item Gimp::on_query
-Do any activities that must be performed at Gimp startup, when the
-procedure is queried. Should typically have at least one call to
-Gimp->install_procedure.
+Do any activities that must be performed at GIMP startup, when the
+plugin is queried. Should typically have at least one call to
+C<Gimp-E<gt>install_procedure>.
=item Gimp::on_net
-Run when called from a network interface (from the Perl-Server or from
-running it standalone).
+Run when the plugin is executed from the command line, either in "net
+mode" via the Perl-Server, or "batch mode".
=item Gimp::on_lib
-Run only when called from within Gimp.
+Run only when called from within GIMP, i.e. in "plugin mode".
=item Gimp::on_run
@@ -617,7 +682,8 @@ Run when anything calls it (network or lib).
=item Gimp::on_quit
-Run when plugin terminates.
+Run when plugin terminates - allows a plugin (or extension, see below)
+to clean up after itself before it actually exits.
=back
@@ -665,7 +731,7 @@ or also other event sources (including a GUI, or L<Glib::IO>):
# GIMP will call your quit callback
A working, albeit trivial, example is provided in
-examples/example-extension. A summarised example:
+C<examples/example-extension>. A summarised example:
use Gimp;
Gimp::register_callback extension_gp_test => sub {
@@ -694,44 +760,251 @@ examples/example-extension. A summarised example:
};
exit Gimp::main;
-=head1 CALLING GIMP FUNCTIONS
+A more substantial, working, example can be seen in the Perl Server
+extension that enables "net mode": C<examples/Perl-Server>.
-There are two different flavours of gimp-functions. Functions from the
-B<PDB> (the Procedural DataBase), and functions from B<libgimp> (the
-C-language interface library).
+=head1 AVAILABLE GIMP FUNCTIONS
+
+There are two different flavours of GIMP functions: those from
+the Procedural Database (the B<PDB>), and functions from B<libgimp>
+(the C-language interface library).
You can get a listing and description of every PDB function by starting
-the B<DB Browser> extension in GIMP's B<Xtns> menu (but remember to change
- "-" (dashes) to "_" (underscores)).
+GIMP's C<Help/Procedure Browser> extension. Perl requires you to change
+"-" (dashes) to "_" (underscores).
+
+=head1 OBJECT-ORIENTED SYNTAX
+
+Gimp-Perl uses some tricks to map the procedural PDB functions onto full
+classes, with methods. These effectively implement object-oriented C,
+not coincidentally in the style of Glib Objects. GIMP plans to move to
+fully supporting Glib Objects, which may mean some (or no) changes to
+the Gimp-Perl programming interface.
+
+=head2 AVAILABLE CLASSES
+
+Classes for which objects are created:
+
+ Gimp::Base # purely virtual
+ +-Gimp::Color
+ +-Gimp::Image
+ +-Gimp::Selection
+ +-Gimp::Display
+ +-Gimp::Parasite
+ +-Gimp::Item
+ +-Gimp::Vectors
+ +-Gimp::Drawable
+ +-Gimp::Layer
+ +-Gimp::Channel
+
+Classes for which non-PDB objects are created (see L<Gimp::PixelRgn>):
+
+ Gimp::GimpDrawable
+ Gimp::PixelRgn
+ Gimp::Tile
+
+Classes for which objects are not created:
+
+ Gimp
+ Gimp::Brush
+ Gimp::Brushes
+ Gimp::Context
+ Gimp::Edit
+ Gimp::Gradient
+ Gimp::Gradients
+ Gimp::Palette
+ Gimp::Pattern
+ Gimp::Patterns
+ Gimp::Plugin
+ Gimp::Progress
+
+C<Gimp::Base> implements two methods:
-C<libgimp> functions can't be traced (and won't be traceable in the
-foreseeable future).
+=over 4
+
+=item $object->become($class)
+
+Allows an object of one class to change its class to another, but with
+the same ID. No checking is performed. It is intended for use in plugins,
+e.g. where GIMP passes a C<Gimp::Drawable>, but you need a C<Gimp::Layer>:
+
+ my ($image, $layer, $color) = @_;
+ die "Can only operate on a layer\n" unless $layer->is_layer;
+ $layer->become('Gimp::Layer'); # now can call layer methods on it
-To call pdb functions (or equivalent libgimp functions), just treat them like
-normal perl (this requires the use of the C<:auto> import tag - see
-the import C<:auto> note for non-OO limitation; see below for another
-possibility!):
+=item $class->existing($id)
+
+Allows you to instantiate a Gimp-Perl object with the given C<$class>
+and C<$id>. Again, no checking is performed.
+
+=back
+
+It also provides a "stringify" overload method, so debugging output can
+be more readable.
+
+C<Gimp::Parasite> implements these self-explanatory methods:
+
+=over 4
- Gimp->palette_set_foreground([20,5,7]);
- Gimp->palette_set_background("cornsilk");
+=item $parasite = Gimp::Parasite-E<gt>new($name, $flags, $data)
-If you don't use the C<:auto> import tag, you can call all Gimp functions
-using OO-Syntax:
+C<$name> and C<$data> are perl strings, C<flags> is the numerical flag value.
- Gimp->palette_set_foreground([20,5,7]);
- Gimp->palette_set_background("cornsilk");
- Gimp::Palette->set_foreground('#1230f0');
+=item $parasite-E<gt>name
-As you can see, you can also drop part of the name prefixes with this
-syntax, so it's actually shorter to write and hopefully clearer to read.
+=item $parasite-E<gt>flags
+
+=item $parasite-E<gt>data
+
+=item $parasite-E<gt>has_flag($flag)
+
+=item $parasite-E<gt>is_type($type)
+
+=item $parasite-E<gt>is_persistent
+
+=item $parasite-E<gt>is_error
+
+=item $different_parasite = $parasite-E<gt>copy
+
+=item $parasite-E<gt>compare($other_parasite)
+
+=back
+
+=head2 SPECIAL METHODS
+
+Some methods behave differently from how you'd expect, or methods uniquely
+implemented in Perl (that is, not in the PDB). All of these must be
+invoked using the method syntax (C<Gimp-E<gt>> or C<$object-E<gt>>).
+
+=over 4
+
+=item Gimp->install_procedure(name, blurb, help, author, copyright, date, menu_path, image_types, type,
params[, return_vals])
+
+Mostly the same as gimp_install_procedure from the C library. The
+parameters and return values for the functions are each specified as an
+array ref containing array-refs with three elements,
+C<[PARAM_TYPE, "NAME", "DESCRIPTION"]>, e.g.:
+
+ Gimp::on_query {
+ Gimp->install_procedure(
+ $Gimp::Net::PERLSERVERPROC, "Gimp-Perl scripts net server",
+ "Allow scripting GIMP with Perl providing Gimp::Net server",
+ "Marc Lehmann <pcg\ goof com>", "Marc Lehmann", "1999-12-02",
+ N_"<Image>/Filters/Languages/_Perl/_Server", undef,
+ $Gimp::Net::PERLSERVERTYPE,
+ [
+ [&Gimp::PDB_INT32, "run_mode", "Interactive, [non-interactive]"],
+ [&Gimp::PDB_INT32, "flags", "internal flags (must be 0)"],
+ [&Gimp::PDB_INT32, "extra", "multi-purpose"],
+ [&Gimp::PDB_INT32, "verbose", "Gimp verbose var"],
+ ],
+ [],
+ );
+ };
+
+=item Gimp::Progress->init(message,[display])
+
+=item Gimp::Progress->update(percentage)
+
+Initializes or updates a progress bar. In networked modules these are a no-op.
+
+=item Gimp::Image-E<gt>list
+
+=item $image-E<gt>get_layers
+
+=item $image-E<gt>get_channels
+
+These functions return what you would expect: an array of images, layers or
+channels. The reason why this is documented is that the usual way to return
+C<PDB_INT32ARRAY>s would be to return a B<reference> to an B<array of
+integers>, rather than blessed objects:
+
+ perl -MGimp -e '@x = Gimp::Image->list; print "@x\n"'
+ # returns: Gimp::Image->existing(7) Gimp::Image->existing(6)
+
+=item $drawable-E<gt>bounds, $gdrawable-E<gt>bounds
+
+Returns an array (x,y,w,h) containing the upper left corner and the
+size of currently selected parts of the drawable, just as needed by
+C<Gimp::PixelRgn-E<gt>new> and similar functions. Exist for objects of
+both C<Gimp::Drawable> and C<Gimp::GimpDrawable>.
+
+=back
+
+=head2 NORMAL METHODS
+
+If you call a method, C<Gimp> tries to find a GIMP function by
+prepending a number of prefixes until it finds a valid function:
+
+ $image = Gimp->image_new(...); # calls gimp_image_new(...)
+ $image = Gimp::Image->new(...); # calls gimp_image_new as well
+ $image = new Gimp::Image(...); # the same in green
+ Gimp::Palette->set_foreground(...); # calls gimp_palette_set_foreground(..)
+ $image->histogram(...); # calls gimp_histogram($image,...), since
+ # gimp_image_histogram does not exist
+
+Return values from functions are automatically blessed to their
+corresponding classes, e.g.:
+
+ $image = new Gimp::Image(...); # $image is now blessed to Gimp::Image
+ $image->height; # calls gimp_image_height($image)
+ $image->flatten; # likewise gimp_flatten($image)
+
+The object argument (C<$image> in the above examples) is prepended to the
+argument list - this is how Perl does OO.
+
+Another shortcut: many functions want a (redundant) image argument, like
+
+ $image->shear ($layer, ...)
+
+Since all you want is to shear the C<$layer>, not the C<$image>, this is
+confusing as well. In cases like this, Gimp-Perl allows you to write:
+
+ $layer->shear (...)
+
+And automatically infers the additional IMAGE-type argument.
+
+Because method call lookup also search the C<plug_in_>, C<perl_fu_> and
+C<script_fu_> namespaces, any plugin can automatically become a method
+for an image or drawable (see below).
+
+As the (currently) last goodie, if the first argument is of type INT32, its
+name is "run_mode" and there are no other ambiguities, you can omit it, i.e.
+these five calls are equivalent:
+
+ plug_in_gauss_rle(RUN_NONINTERACTIVE, $image, $layer, 8, 1, 1);
+ plug_in_gauss_rle($image, $layer, 8, 1, 1);
+ plug_in_gauss_rle($layer, 8, 1, 1);
+ $layer->plug_in_gauss_rle(8, 1, 1);
+ $layer->gauss_rle(8, 1, 1);
+
+You can call all sorts of sensible and not-so-sensible functions,
+so this feature can be abused:
+
+ patterns_list Gimp::Image; # will call gimp_patterns_list
+ quit Gimp::Plugin; # will quit the Gimp, not an Plugin.
+
+there is no image involved here whatsoever...
+
+The 'gimpdoc' script will also return OO variants when functions
+are described. For example:
+
+ gimpdoc image_new
+
+has a section:
+
+ SOME SYNTAX ALTERNATIVES
+ $image = Gimp->image_new (width,height,type)
+ $image = new Gimp::Image (width,height,type)
+ $image = image_new Gimp::Display (width,height,type)
=head1 SPECIAL FUNCTIONS
In this section, you can find descriptions of special functions, functions
-having different calling conventions/semantics than might be expected
-or otherwise interesting functions. All of these functions must either
-be imported explicitly or called using a namespace override (C<Gimp::>),
-not as Methods (C<Gimp-E<gt>>).
+that have unexpected calling conventions/semantics or are otherwise
+interesting. All of these functions must either be imported explicitly
+or called using a namespace override (C<Gimp::>), not as methods
+(C<Gimp-E<gt>>).
=over 4
@@ -742,43 +1015,26 @@ supported. Initializations can later be done in the init function.
=item Gimp::gtk_init()
-Initialize Gtk in a similar way GIMP itself did it. This automatically
-parses gimp's gtkrc and sets a variety of default settings (visual,
-colormap, gamma, shared memory...).
-
-=item use Gimp qw(net_init=...);
-
-This is how to use Gimp-Perl in "net mode". Previous versions of this
-package required a call to Gimp::init. This is no longer necessary. The
-technical reason for this change is that when C<Gimp.pm> loads, it must
-connect to GIMP to load its constants, like C<PDB_INT32>.
-
-=item Gimp::lock(), Gimp::unlock()
-
-These functions can be used to gain exclusive access to GIMP. After
-calling lock, all accesses by other clients will be blocked and executed
-after the call to unlock. Calls to lock and unlock can be nested.
-
-Currently, these functions only lock the current Perl-Server instance
-against exclusive access, they do nothing when used via the Gimp::Lib
-interface.
+Initialize Gtk in a similar way GIMP itself did. This automatically
+parses GIMP's gtkrc and sets a variety of default settings, including
+visual, colormap, gamma, and shared memory.
=item Gimp::set_rgb_db(filespec)
Use the given rgb database instead of the default one. The format is
the same as the one used by the X11 Consortiums rgb database (you might
have a copy in /usr/lib/X11/rgb.txt). You can view the default database
-with C<perldoc -m Gimp::ColorDB>, at the end of the file (the default
-database is similar, but not identical to the X11 default rgb.txt)
+with C<perldoc -m Gimp::ColorDB>, at the end of the file; the default
+database is similar, but not identical to the X11 default C<rgb.txt>.
=item Gimp::initialized()
-this function returns true whenever it is safe to call gimp functions. This is
+this function returns true whenever it is safe to call GIMP functions. This is
usually only the case after gimp_main has been called.
=item Gimp::register_callback(gimp_function_name, perl_function)
-Using this function you can overwrite the standard Gimp behaviour of
+Using this function you can override the standard Gimp-Perl behaviour of
calling a perl subroutine of the same name as the GIMP function.
The first argument is the name of a registered gimp function that you want
@@ -803,63 +1059,10 @@ For example:
Note that bounds checking is somewhat lax; this assumes relatively
good input.
-=back
-
-=head1 SPECIAL METHODS
-
-This chapter describes methods that behave differently than you might
-expect, or methods uniquely implemented in perl (that is, not in the
-PDB). All of these must be invoked using the method syntax (C<Gimp-E<gt>>
-or C<$object-E<gt>>).
-
-=over 4
-
-=item Gimp->install_procedure(name, blurb, help, author, copyright, date, menu_path, image_types, type,
[params], [return_vals])
-
-Mostly same as gimp_install_procedure from the C library. The
-parameters and return values for the functions are specified as an
-array ref containing either integers or array-refs with three elements,
-[PARAM_TYPE, \"NAME\", \"DESCRIPTION\"].
-
-=item Gimp::Progress->init(message,[])
-
-Initializes a progress bar. In networked modules this is a no-op.
-
-=item Gimp::Progress->update(percentage)
-
-Updates the progress bar. No-op in networked modules.
-
=item gimp_tile_*, gimp_pixel_rgn_*, gimp_drawable_get
With these functions you can access the raw pixel data of drawables. They
-are documented in L<Gimp::PixelRgn>, to keep this manual page short.
-
-=item gimp_call_procedure(procname, arguments...)
-
-This function is actually used to implement the fancy stuff. It's your basic
-interface to the PDB. Every function call is eventually done through his
-function, i.e.:
-
- gimp_image_new(args...);
-
-is replaced by
-
- gimp_call_procedure "gimp_image_new",args...;
-
-at runtime.
-
-=item gimp_list_images, gimp_image_get_layers, gimp_image_get_channels
-
-These functions return what you would expect: an array of images, layers or
-channels. The reason why this is documented is that the usual way to return
-C<PDB_INT32ARRAY>'s would be to return a B<reference> to an B<array of
-integers>, rather than blessed objects.
-
-=item gimp_drawable_bounds drawable/gdrawable
-
-Returns an array (x,y,w,h) containing the upper left corner and the
-size of currently selected parts of the drawable, just as needed by
-Gimp::PixelRgn->new and similar functions.
+are documented in L<Gimp::PixelRgn>.
=item server_eval(string)
@@ -871,21 +1074,15 @@ reported as runtime errors (i.e. throwing an exception).
=back
-=head1 OBJECT ORIENTED SYNTAX
-
-In this manual, only the plain syntax (that lesser languages like C use)
-is described. See L<Gimp::OO> for details on using the object oriented
-syntax. The 'gimpdoc' script will also return OO varients when functions
-are described. For example:
+=head1 PROCEDURAL SYNTAX (DEPRECATED)
-gimpdoc image_new
+To call PDB functions or libgimp functions, you I<can>
+(but shouldn't) treat them like normal procedural perl (this requires
+the use of the C<:auto> import tag - see L</":auto (DEPRECATED)">):
-has a section:
-
-SOME SYNTAX ALTERNATIVES
- $image = Gimp->image_new (width,height,type)
- $image = new Gimp::Image (width,height,type)
- $image = image_new Gimp::Display (width,height,type)
+ gimp_item_set_name($layer, 'bob'); # $layer is an object (i.e. ref) - works
+ gimp_palette_set_foreground([20,5,7]); # works because of array ref
+ gimp_palette_set_background("cornsilk"); # colour turned into array ref!
=head1 DEBUGGING AIDS
@@ -895,9 +1092,9 @@ How to debug your scripts:
=item $Gimp::verbose
-If set to true, will make Gimp say what it's doing on STDOUT. It will
+If set to true, will make Gimp-Perl say what it's doing on STDOUT. It will
also stop L<Gimp::Net>'s normal behaviour of the server-side closing
-STDIN, STDOUT and STDERR. If you want it to be set during loading Gimp.pm,
+STDIN, STDOUT and STDERR. If you want it to be set during loading C<Gimp.pm>,
make sure to do so in a prior C<BEGIN> block:
BEGIN { $Gimp::verbose = 1; }
@@ -905,18 +1102,19 @@ make sure to do so in a prior C<BEGIN> block:
=item Gimp::set_trace (tracemask)
-Tracking down bugs in gimp scripts is difficult, due to a lack of
-reasonable error messages. Often, if anything goes wrong, you only get
-an execution failure.
+You can switch on tracing to see which parameters are used to call PDB
+functions, so you can at least see what was called to cause the error:
-You can switch on tracing to see which parameters are used to call pdb
-functions, so you can at least see what was called to cause the error.
+ Gimp::set_trace(TRACE_ALL);
This function is never exported, so you have to qualify it when calling.
-tracemask is any number of the following flags or'ed together.
+C<libgimp> functions can't be traced (and won't be traceable in the
+foreseeable future).
-=over 8
+C<tracemask> is any number of the following flags or'ed together:
+
+=over 4
=item TRACE_NONE
@@ -924,7 +1122,7 @@ nothing is printed (default).
=item TRACE_CALL
-all pdb calls (and only pdb calls!) are printed
+all PDB calls (and only PDB calls!) are printed
with arguments and return values.
=item TRACE_TYPE
@@ -972,19 +1170,20 @@ setting C<MALLOC_CHECK_> (note trailing underscore) to 3.
=head1 SUPPORTED GIMP DATA TYPES
-Gimp supports different data types like colors, regions, strings. In
-perl, these are represented as:
+GIMP supports different data types like colors, regions, strings. In
+C, these are represented as (C<GIMP_PDB_> omitted for brevity - in
+Gimp-Perl, they are constants starting C<PDB_>):
=over 4
=item INT32, INT16, INT8, FLOAT, STRING
-normal perl scalars. Anything except STRING will be mapped
-to a perl-double.
+normal Perl scalars. Anything except STRING will be mapped
+to a Perl-number.
=item INT32ARRAY, INT16ARRAY, INT8ARRAY, FLOATARRAY, STRINGARRAY, COLORARRAY
-array refs containing scalars of the same type, i.e. [1, 2, 3, 4]. Gimp
+array refs containing scalars of the same type, i.e. [1, 2, 3, 4]. Gimp-Perl
implicitly swallows or generates a preceeding integer argument because the
preceding argument usually (this is a de-facto standard) contains the number
of elements.
@@ -993,7 +1192,7 @@ of elements.
on input, either an array ref with 3 or 4 elements (i.e. [0.1,0.4,0.9]
or [233,40,40]), a X11-like string ("#rrggbb") or a colour name
-("papayawhip") (see set_rgb_db).
+("papayawhip") (see L</"Gimp::set_rgb_db(filespec)">).
=item DISPLAY, IMAGE, LAYER, CHANNEL, DRAWABLE, SELECTION, VECTORS, ITEM
@@ -1002,8 +1201,7 @@ trace output you will see small integers (the image/layer/etc..-ID)
=item PARASITE
-represented as an array ref [name, flags, data], where name and data
-should be perl strings and flags is the numerical flag value.
+represented as a C<Gimp::Parasite> object (see above).
=item STATUS
@@ -1018,9 +1216,14 @@ Marc Lehmann <pcg goof com> (pre-2.0)
Seth Burgess <sjburge gimp org> (2.0+)
-Ed J (with oversight and guidance from Kevin Cozens) (2.3+)
+Kevin Cozens (2.2+)
+
+Ed J (with oversight and guidance from Kevin Cozens) (2.3)
+
+Ed J (2.3000_01+)
=head1 SEE ALSO
-perl(1), gimp(1), L<Gimp::OO>, L<Gimp::Data>, L<Gimp::PixelRgn>,
-L<Gimp::Util>, L<Gimp::UI>, L<Gimp::Config>, L<Gimp::Net>, and L<Gimp::Lib>.
+perl(1), gimp(1), L<Gimp::Fu>, L<Gimp::PixelRgn>, L<Gimp::UI>,
+L<Gimp::Util>, L<Gimp::Data>, L<Gimp::Config>, L<Gimp::Net>, and
+L<Gimp::Lib>.
diff --git a/Gimp/Config.pm.in b/Gimp/Config.pm.in
index 3e48bc1..e1c2703 100644
--- a/Gimp/Config.pm.in
+++ b/Gimp/Config.pm.in
@@ -2,7 +2,7 @@ package Gimp::Config;
=head1 NAME
- Gimp::Config - config options found during configure time.
+ Gimp::Config - Access config options found during configure time.
=head1 DESCRIPTION
diff --git a/Gimp/Data.pm b/Gimp/Data.pm
index 072fcaa..4f5c0c9 100644
--- a/Gimp/Data.pm
+++ b/Gimp/Data.pm
@@ -58,7 +58,7 @@ __END__
=head1 NAME
-Gimp::Data - Set and get state data.
+Gimp::Data - Set and get persistent data.
=head1 SYNOPSIS
@@ -79,22 +79,20 @@ values again (L<Gimp::Fu> does this already).
=head1 %Gimp::Data
-You can store and retrieve anything you like in this hash. It's contents
+You can store and retrieve anything you like in this hash. Its contents
will automatically be stored in Gimp, and can be accessed in later
invocations of your plug-in. Be aware that other plug-ins store data
in the same "hash", so better prefix your key with something unique,
like your plug-in's name. As an example, the Gimp::Fu module uses
"function_name/_fu_data" to store its data.
-This module might use a persistant implementation, i.e. your data might
-survive a restart of the Gimp application, but you cannot count on this.
+As of L<Gimp> version 2.3 (and GIMP 2.8), your data B<will> survive a
+restart of the Gimp application.
C<Gimp::Data> will try to freeze your data when you pass in a reference. On
-retrieval, the data is thawed again. See L<Storable> for more info. This
-might be implemented through either Storable or Data::Dumper, or not
-implemented at all (i.e. silently fail) ;)
+retrieval, the data is thawed again. See L<Data::Dumper> for more info.
-=head1 PERSISTANCE
+=head1 PERSISTENCE
C<Gimp::Data> contains the following functions to ease applications where
persistence for perl data structures is required:
diff --git a/Gimp/Fu.pm b/Gimp/Fu.pm
index 33d823a..4994cfd 100644
--- a/Gimp/Fu.pm
+++ b/Gimp/Fu.pm
@@ -53,13 +53,13 @@ use constant {
};
# key is text, bit in array-ref is number!
-# [ int, human-readable-description, GIMP-data-type-if>PDB_END-or-infer ]
+# [int, human-description, GIMP-data-type-if>PDB_END-or-infer, passthru]
my %pfname2info = (
PF_INT8 => [ PF_INT8, 'integer (8-bit)', ],
PF_INT16 => [ PF_INT16, 'integer (16-bit)', ],
PF_INT32 => [ PF_INT32, 'integer (32-bit)', ],
PF_FLOAT => [ PF_FLOAT, 'number', ],
- PF_STRING => [ PF_STRING, 'string', ],
+ PF_STRING => [ PF_STRING, 'string', undef, 1 ],
PF_INT32ARRAY => [ PF_INT32ARRAY, 'list of integers (32-bit)' ],
PF_INT16ARRAY => [ PF_INT16ARRAY, 'list of integers (16-bit)' ],
PF_INT8ARRAY => [ PF_INT8ARRAY, 'list of integers (8-bit)' ],
@@ -74,31 +74,31 @@ my %pfname2info = (
PF_COLORARRAY => [ PF_COLORARRAY, 'list of colours' ],
PF_VECTORS => [ PF_VECTORS, 'vectors' ],
PF_PARASITE => [ PF_PARASITE, 'parasite' ],
- PF_BRUSH => [ PF_BRUSH, 'brush', Gimp::PDB_STRING, ],
- PF_GRADIENT => [ PF_GRADIENT, 'gradient', Gimp::PDB_STRING, ],
- PF_PATTERN => [ PF_PATTERN, 'pattern', Gimp::PDB_STRING, ],
- PF_FONT => [ PF_FONT, 'font', Gimp::PDB_STRING, ],
+ PF_BRUSH => [ PF_BRUSH, 'brush', Gimp::PDB_STRING, 1 ],
+ PF_GRADIENT => [ PF_GRADIENT, 'gradient', Gimp::PDB_STRING, 1 ],
+ PF_PATTERN => [ PF_PATTERN, 'pattern', Gimp::PDB_STRING, 1 ],
+ PF_FONT => [ PF_FONT, 'font', Gimp::PDB_STRING, 1 ],
PF_TOGGLE => [ PF_TOGGLE, 'boolean', Gimp::PDB_INT8, ],
PF_SLIDER => [ PF_SLIDER, 'number', Gimp::PDB_FLOAT, ],
PF_SPINNER => [ PF_SPINNER, 'integer', Gimp::PDB_INT32, ],
PF_ADJUSTMENT => [ PF_ADJUSTMENT, 'number', Gimp::PDB_FLOAT, ],
PF_RADIO => [ PF_RADIO, 'data', ],
- PF_CUSTOM => [ PF_CUSTOM, 'string', Gimp::PDB_STRING, ],
- PF_FILE => [ PF_FILE, 'filename', Gimp::PDB_STRING, ],
- PF_TEXT => [ PF_TEXT, 'string', Gimp::PDB_STRING, ],
+ PF_CUSTOM => [ PF_CUSTOM, 'string', Gimp::PDB_STRING, 1 ],
+ PF_FILE => [ PF_FILE, 'filename', Gimp::PDB_STRING, 1 ],
+ PF_TEXT => [ PF_TEXT, 'string', Gimp::PDB_STRING, 1 ],
);
$pfname2info{PF_COLOUR} = $pfname2info{PF_COLOR};
$pfname2info{PF_BOOL} = $pfname2info{PF_TOGGLE};
$pfname2info{PF_VALUE} = $pfname2info{PF_FLOAT};
my %pf2info = map {
- my $v = $pfname2info{$_}; ($v->[0] => [ @$v[1,2] ])
+ my $v = $pfname2info{$_}; ($v->[0] => [ @$v[1..3] ])
} keys %pfname2info;
@EXPORT_OK = qw($run_mode save_image);
%EXPORT_TAGS = (
params => [ keys %pfname2info ]
);
- EXPORT = (qw(register main), @{$EXPORT_TAGS{params}});
+ EXPORT = (qw(podregister register main), @{$EXPORT_TAGS{params}});
my @scripts;
@@ -113,29 +113,6 @@ my @save_params = (@image_params, @load_params);
my $image_retval = [PF_IMAGE, "image", "Output image"];
-# expand all the pod directives in string (currently they are only removed)
-sub expand_podsections() {
- my $pod;
- for (@scripts) {
- $_->[2] ||= "=pod(NAME)";
- $_->[3] ||= "=pod(DESCRIPTION)";
- $_->[4] ||= "=pod(AUTHOR)";
- $_->[5] ||= "=pod(AUTHOR)";
- $_->[6] ||= "=pod(DATE)";
-
- for (@{$_}[2,3,4,5,6]) {
- s/=pod\(([^)]*)\)/
- require Gimp::Pod;
- $pod ||= new Gimp::Pod;
- $pod->section($1) || $pod->format;
- /eg;
- }
- }
-}
-
-# the old value of the trace flag
-my $old_trace;
-
sub interact {
require Gimp::UI;
goto &Gimp::UI::interact;
@@ -145,10 +122,10 @@ sub this_script {
return $scripts[0] if @scripts == 1;
# well, not-so-easy-day today
require File::Basename;
- my $exe = File::Basename::basename($0);
+ my ($exe) = File::Basename::fileparse($RealScript, qr/\.[^.]*/);
my @names;
for my $this (@scripts) {
- my $fun = (split /\//,$this->[1])[-1];
+ my $fun = $this->[0];
$fun =~ s/^(?:perl_fu|plug_in)_//;
return $this if lc($exe) eq lc($fun);
push(@names,$fun);
@@ -160,7 +137,7 @@ my $latest_image;
sub string2pf($$) {
my ($s, $type, $name, $desc) = ($_[0], @{$_[1]});
- if($pf2info{$type}->[0] eq 'string') {
+ if($pf2info{$type}->[2]) {
$s;
} elsif($pf2info{$type}->[0] =~ /integer/) {
die __"$s: not an integer\n" unless $s==int($s);
@@ -175,11 +152,11 @@ sub string2pf($$) {
} elsif($type == PF_IMAGE) {
my $image;
if ((my $arg) = $s =~ /%(.+)/) {
- die "image % argument not integer - if file, put './' in front\n"
+ die "Image % argument not integer - if file, put './' in front\n"
unless $arg eq int $arg;
- $image = bless \$arg, 'Gimp::Image';
- eval { $image->get_layers; };
- die "'$arg' not a valid image - need to run Perl Server?\n" if $@;
+ $image = Gimp::Image->existing($arg);
+ die "'$arg' not a valid image - need to run Perl Server?\n"
+ unless $image->is_valid;
} else {
$image = Gimp->file_load(Gimp::RUN_NONINTERACTIVE, $s, $s),
}
@@ -190,17 +167,15 @@ sub string2pf($$) {
$latest_image->get_active_drawable;
} else {
# existing GIMP object - rely on autobless
- die "drawable % argument not integer\n"
+ die "Drawable % argument not integer\n"
unless $arg eq int $arg;
$arg;
}
} else {
- die "must specify drawable as %number or %a (active)\n";
+ die "Must specify drawable as %number or %a (active)\n";
}
- } elsif($type == PF_GRADIENT) {
- $s;
} else {
- die __"conversion from string to type $pf2info{$type}->[0] is not yet implemented\n";
+ die __"Can't convert '$name' from string to '$pf2info{$type}->[0]'\n";
}
}
@@ -218,8 +193,8 @@ Gimp::on_net {
my $this = this_script;
my(%mangleparam2index,@args);
my ($interact, $outputfile) = 1;
- my($perl_sub,$function,$blurb,$help,$author,$copyright,$date,
- $menupath,$imagetypes,$params,$results,$code,$type)= $this;
+ my ($function,$blurb,$help,$author,$copyright,$date,
+ $menupath,$imagetypes,$type,$params,$results,$perl_sub) = @$this;
@mangleparam2index{map mangle_key($_->[1]), @$params} = (0..$#{$params});
die "$0: error - try $0 --help\n" unless Getopt::Long::GetOptions(
'interact|i' => sub { $interact = 1e6 },
@@ -245,7 +220,7 @@ Gimp::on_net {
($interact>0 ? RUN_FULLINTERACTIVE : Gimp::RUN_NONINTERACTIVE),
@args
);
- if ($outputfile and $menupath !~ /^<Load>\//) {
+ if ($outputfile) {
my @images = grep { defined $_ and ref $_ eq "Gimp::Image" } @retvals;
if (@images) {
for my $i (0..$#images) {
@@ -274,46 +249,42 @@ sub datatype(@) {
}
Gimp::on_query {
- expand_podsections;
- script:
- for(@scripts) {
- my($perl_sub,$function,$blurb,$help,$author,$copyright,$date,
- $menupath,$imagetypes,$params,$results,$code,$type)= $_;
-
- for(@$params) {
- next if $_->[0] < Gimp::PDB_END;
- $_->[0] = $pf2info{$_->[0]}->[1] // datatype(values %{+{ {$_->[4]}}});
+ for my $s (@scripts) {
+ for my $p (@{$s->[9]}) {
+ next if $p->[0] < Gimp::PDB_END;
+ $p->[0] = $pf2info{$p->[0]}->[1] // datatype(values %{+{ {$p->[4]}}});
}
-
- warn "$$-Gimp::Fu gimp_install_procedure params (@$params)" if $Gimp::verbose;
- Gimp->install_procedure(
- $function,
- $blurb,
- $help,
- $author,
- $copyright,
- $date,
- $menupath,
- $imagetypes,
- $type,
- [
- [Gimp::PDB_INT32, "run_mode", "Interactive, [non-interactive]"],
- @$params,
- ],
- $results,
- );
+ unshift @{$s->[9]}, [Gimp::PDB_INT32,"run_mode","Interactive:0=yes,1=no"];
+ Gimp->install_procedure(@$s[0..10]);
}
};
+sub podregister (&) { unshift @_, ('') x 9; goto ®ister; }
+sub getpod ($$) {
+ require Gimp::Pod; $_[0] ||= new Gimp::Pod; $_[0]->section($_[1]);
+}
+my %IND2SECT = (
+ 2 => 'DESCRIPTION', 3 => 'AUTHOR', 4 => 'LICENSE',
+ 5 => 'DATE', 6 => 'SYNOPSIS', 7 => 'IMAGE TYPES',
+);
+#(func,blurb,help,author,copyright,date,menupath,imagetypes,params,return,code)
sub register($$$$$$$$$;@) {
no strict 'refs';
+ my @p = @_;
+ splice @p, 9, 0, [] if @p == 10; # optional return values
+ die __"register called with too many or wrong arguments\n" unless @p == 11;
+ my $pod;
+ @p[0,1] = getpod($pod,'NAME') =~ /(.*?)\s*-\s*(.*)/ unless $p[0] or $p[1];
+ ($p[0]) = File::Basename::fileparse($RealScript, qr/\.[^.]*/) unless $p[0];
+ while (my ($k, $v) = each %IND2SECT) { $p[$k] ||= getpod($pod, $v); }
+ $p[8] ||= [ eval getpod($pod, 'PARAMETERS') ]; die $@ if $@;
+ $p[9] ||= [ eval getpod($pod, 'RETURN VALUES') ]; die $@ if $@;
+ for my $i (0..6, 10) {
+ croak "$0: Need arg $i (or POD $IND2SECT{$i} section)" unless $p[$i]
+ }
my ($function, $blurb, $help, $author, $copyright, $date,
- $menupath, $imagetypes, $params) = splice @_, 0, 9;
- my ($results, $code, $type);
-
- $results = (ref $_[0] eq "ARRAY") ? shift : [];
- $code = shift;
-
+ $menupath, $imagetypes, $params, $results, $code) = @p;
+ my $type;
if ($menupath =~ /^<Image>\//) {
$type = Gimp::PLUGIN;
if ($imagetypes) {
@@ -338,11 +309,12 @@ sub register($$$$$$$$$;@) {
undef $menupath;
undef $imagetypes;
} else {
- die __"menupath _must_ start with <Image>, <Load>, <Save>, <Toolbox>/Xtns/, or <None>!";
+ die __<<EOF;
+menupath _must_ start with <Image>, <Load>, <Save>, <Toolbox>/Xtns/, or <None>!
+(got '$menupath')
+EOF
}
- @_==0 or die __"register called with too many or wrong arguments\n";
-
for my $p (@$params,@$results) {
next unless ref $p;
croak __"$function: argument/return value '$p->[1]' has illegal type '$p->[0]'"
@@ -448,8 +420,8 @@ sub register($$$$$$$$$;@) {
};
Gimp::register_callback($function,$perl_sub);
- push(@scripts,[$perl_sub,$function,$blurb,$help,$author,$copyright,$date,
- $menupath,$imagetypes,$params,$results,$code,$type]);
+ push(@scripts,[$function,$blurb,$help,$author,$copyright,$date,
+ $menupath,$imagetypes,$type,$params,$results,$perl_sub]);
}
sub save_image($$) {
@@ -513,8 +485,8 @@ sub main {
interface-arguments are
-o | --output <filespec> write image to disk
-i | --interact let the user edit the values first
- script-arguments are
EOF
+ print " script-arguments are\n" if @{$this->[9]};
for(@{$this->[9]}) {
my $type=$pf2info{$_->[0]}->[0];
my $key=mangle_key($_->[1]);
@@ -526,6 +498,7 @@ EOF
$_->[2],
$default_text;
}
+ 0;
}
1;
@@ -533,65 +506,93 @@ __END__
=head1 NAME
-Gimp::Fu - "easy to use" framework for Gimp scripts
+Gimp::Fu - Easy framework for Gimp-Perl scripts
=head1 SYNOPSIS
use Gimp;
use Gimp::Fu;
+ podregister {
+ # your code
+ };
+ exit main;
+ __END__
+ =head1 NAME
-=head1 DESCRIPTION
+ function_name - Short description of the function
+
+ =head1 SYNOPSIS
-Currently, there are only three functions in this module. This
-fully suffices to provide a professional interface and the
-ability to run this script from within GIMP and standalone
-from the command line.
+ <Image>/Filters/Menu/Location...
-Dov Grobgeld has written an excellent tutorial for Gimp-Perl.
+ =head1 DESCRIPTION
+
+ Longer description of the function...
+
+=head1 DESCRIPTION
+
+This module provides all the infrastructure you need to write Gimp-Perl
+plugins. Dov Grobgeld has written an excellent tutorial for Gimp-Perl.
You can find it at C<http://www.gimp.org/tutorials/Basic_Perl/>.
-=head1 INTRODUCTION
+This distribution comes with many example scripts. One is
+C<examples/example-fu.pl>, which is a small Gimp::Fu-script you can take
+as a starting point for your experiments. You should be able to run it
+from GIMP already by looking at "Filters/Languages/_Perl/Test/Dialog".
-In general, a Gimp::Fu script looks like this:
+Your main interface for using C<Gimp::Fu> is the C<podregister> function.
- #!/path/to/your/perl
+=head1 PODREGISTER
- use Gimp;
- use Gimp::Fu;
+This:
- register <many arguments>, sub {
- your code;
- }
+ podregister {
+ # your code
+ };
+
+does the same as this:
- exit main;
-
-(This distribution comes with example scripts. One is
-C<examples/example-fu.pl>, which is a small Gimp::Fu-script you can take as
-a starting point for your experiments)
-
-=head2 THE REGISTER FUNCTION
-
- register
- "function_name",
- "blurb", "help",
- "author", "copyright",
- "date",
- "menu path",
- "image types",
- [
- [PF_TYPE,name,desc,optional-default,optional-extra-args],
- [PF_TYPE,name,desc,optional-default,optional-extra-args],
- # etc...
- ],
- [
- # like above, but for return values (optional)
- ],
- sub { code };
+ register '', '', '', '', '', '', '', '', '', sub {
+ # your code
+ };
+
+It extracts all the relevant values from your script's POD documentation
+- see the section on L</"EMBEDDED POD DOCUMENTATION"> for an
+explanation. You will also notice you don't need to provide the C<sub>
+keyword, thanks to Perl's prototyping.
+
+=head1 THE REGISTER FUNCTION
+
+ register
+ "function_name",
+ "blurb", "help",
+ "author", "copyright",
+ "date",
+ "menu path",
+ "imagetypes",
+ [
+ [PF_TYPE,name,desc,optional-default,optional-extra-args],
+ [PF_TYPE,name,desc,optional-default,optional-extra-args],
+ # etc...
+ ],
+ [
+ # like above, but for return values (optional)
+ ],
+ sub { code };
+
+All these parameters except the code-ref can be replaced with C<''>, in
+which case they will be substituted with appropriate values from various
+sections (see below) of the POD documentation in your script.
+
+It is B<highly> recommended you use the L</PODREGISTER> interface.
=over 2
=item function name
+Defaults to the NAME section of the POD, the part B<before> the first
+C<->. Falls back to the script's filename.
+
The PDB name of the function, i.e. the name under which it will be
registered in the GIMP database. If it doesn't start with "perl_fu_",
"file_", "plug_in_" or "extension_", it will be prepended. If you
@@ -601,32 +602,41 @@ C<perl_fu_>-prefix.
=item blurb
-A small description of this script/plug-in. Defaults to "=pod(NAME)" (see
-the section on EMBEDDED POD DOCUMENTATION for an explanation of this
-string).
+Defaults to the NAME section of the POD, the part B<after> the first C<->.
+
+A one-sentence description of this script/plug-in.
=item help
-A help text describing this script. Should be longer and more verbose than
-C<blurb>. Default is "=pod(HELP)".
+Defaults to the DESCRIPTION section of the POD.
+
+A help text describing this script. Should give more information than
+C<blurb>.
=item author
-The name (and also the e-mail address if possible!) of the
-script-author. Default is "=pod(AUTHOR)".
+Defaults to the AUTHOR section of the POD.
+
+The name (and also the e-mail address if possible!) of the script-author.
=item copyright
+Defaults to the LICENSE section of the POD.
+
The copyright designation for this script. Important! Save your intellectual
-rights! The default is "=pod(AUTHOR)".
+rights!
=item date
+Defaults to the DATE section of the POD.
+
The "last modified" date of this script. There is no strict syntax here, but
-I recommend ISO format (yyyymmdd or yyyy-mm-dd). Default value is "=pod(DATE)".
+I recommend ISO format (yyyymmdd or yyyy-mm-dd).
=item menu path
+Defaults to the SYNOPSIS section of the POD.
+
The menu entry GIMP should create. B<Note> this is different from
Script-Fu, which asks only for which B<menu> in which to place the entry,
using the second argument to (its equivalent of) C<register> as the actual
@@ -640,14 +650,14 @@ It should start with one of the following:
If the plugin works on or produces an image.
-If the "image types" argument (see below) is defined and non-zero-length,
+If the "imagetypes" argument (see below) is defined and non-zero-length,
L<Gimp::Fu> will supply a C<PF_IMAGE> and C<PF_DRAWABLE> as the first
two parameters to the plugin.
If the plugin is intending to create an image rather than to work on
-an existing one, make sure you supply C<undef> or C<""> as the "image
-types". In that case, L<Gimp::Fu> will supply a C<PF_IMAGE> return value
-if the first return value is not a C<PF_IMAGE>.
+an existing one, make sure you supply C<undef> or C<""> as the
+"imagetypes". In that case, L<Gimp::Fu> will supply a C<PF_IMAGE> return
+value if the first return value is not a C<PF_IMAGE>.
In any case, the plugin will be installed in the specified menu location;
almost always under C<File/Create> or C<Filters>.
@@ -672,14 +682,28 @@ If the script does not need to have a menu entry.
=back
-=item image types
+=item imagetypes
+
+Defaults to the "IMAGE TYPES" section of the POD.
The types of images your script will accept. Examples are "RGB", "RGB*",
"GRAY, RGB" etc... Most scripts will want to use "*", meaning "any type".
-Either C<undef> or "" will mean "none".
+Either C<undef> or "" will mean "none". Not providing the relevant POD
+section is perfectly valid, so long as you intend to create and return
+an image.
=item the parameter array
+Defaults to the "PARAMETERS" section of the POD, passed to C<eval>, e.g.:
+
+ =head PARAMETERS
+
+ [ PF_COLOR, 'color', 'Colour', 'black' ],
+ [ PF_FONT, 'font', 'Font', 'Arial' ],
+
+You don't B<have> to indent it so that POD treats it as verbatim, but
+it will be more readable in the Help viewer if you do.
+
An array reference containing parameter definitions. These are similar to
the parameter definitions used for C<gimp_install_procedure> but include an
additional B<default> value used when the caller doesn't supply one, and
@@ -693,8 +717,8 @@ and drawable (C<PF_DRAWABLE>) B<if and only if> the "image types"
are defined and non-zero-length. Do not specify these yourself - see
the C<menupath> entry above. Also, the C<run_mode> argument is never
given to the script but its value can be accessed in the package-global
-C<$Gimp::Fu::run_mode>. The B<name> is used in the dialog box as a hint. The
-B<description> will be used as a tooltip.
+C<$Gimp::Fu::run_mode>. The B<description> will be used in the dialog
+box as a label.
See the section PARAMETER TYPES for the supported types.
@@ -709,10 +733,14 @@ a C<PF_COLOR>.
=item the return values
+Defaults to the "RETURN VALUES" section of the POD, passed to C<eval>.
+Not providing the relevant POD section is perfectly valid, so long as
+you intend to return no values.
+
This is just like the parameter array except that it describes the
-return values. Specify the type and variable name only. This argument is
-optional. If you wish your plugin to return an image, you must specify
-that, e.g.:
+return values. Specify the type, variable name and description only. This
+argument is optional. If you wish your plugin to return an image, you
+must specify that (unless your "image types" is false, see below), e.g.:
use Gimp;
use Gimp::Fu;
@@ -720,12 +748,17 @@ that, e.g.:
'function_name', "help", "blurb", "author", "copyright", "2014-04-11",
"<Image>/Filters/Render/Do Something...",
"*",
- [ [PF_INT32, "input", "Input value", 1] ],
+ [ [PF_INT32, "imagesize", "Image size", 1] ],
[ [PF_IMAGE, "output image", "Output image"] ],
sub { Gimp::Image->new($_[0], $_[0], RGB) };
If your "image types" is false, then L<Gimp::Fu> will ensure your first
-return parameter is a C<PF_IMAGE>.
+return parameter is a C<PF_IMAGE>. If for some reason you need to return
+an image value that will satisfy the requirement to return the right
+number of values but is invalid, you can return either -1 or C<undef>.
+
+You B<must> return the correct number (and types) of values from your
+function.
=item the code
@@ -733,7 +766,7 @@ This is either an anonymous sub declaration (C<sub { your code here; }>, or a
coderef, which is called when the script is run. Arguments (including the
image and drawable for <Image> plug-ins) are supplied automatically.
-You must make sure your plugin returns the correct types of value, or none:
+You B<must> make sure your plugin returns the correct types of value, or none:
sub {
# no return parameters were specified
@@ -741,12 +774,13 @@ You must make sure your plugin returns the correct types of value, or none:
};
If you want to display images, you must have your script do
-that. C<Gimp::Fu> plugins will thereby be good GIMP "citizens", able to
-fit in with plugins/filters written in other languages.
+that. Gimp::Fu will no longer automatically do that for you, so your
+plugins will thereby be good GIMP "citizens", able to fit in with
+plugins/filters written in other languages.
=back
-=head2 PARAMETER TYPES
+=head1 PARAMETER TYPES
=over 2
@@ -757,7 +791,7 @@ All mapped to sliders or spinners with suitable min/max.
=item PF_FLOAT, PF_VALUE
For C<PF_FLOAT> (or C<PF_VALUE>, a synonym), you should probably use a
-C<PF_ADJUSTMENT> with suitable values.
+C<PF_SPINNER> or C<PF_SLIDER> with suitable values.
=item PF_STRING
@@ -774,23 +808,22 @@ needs to be a suitable Gimp-Perl colour; see L<Gimp::canonicalize_colour>.
=item PF_IMAGE
-A gimp image.
+A GIMP image.
=item PF_DRAWABLE
-A gimp drawable (channel or layer).
+A GIMP drawable (channel or layer).
=item PF_TOGGLE, PF_BOOL
-A boolean value (anything Perl would accept as true or false). The
-description will be used for the toggle-button label.
+A boolean value (anything Perl would accept as true or false).
=item PF_SLIDER
Uses a horizontal scale. To set the range and stepsize, append an
array ref (see L<Gtk2::Adjustment> for an explanation) C<[range_min,
range_max, step_size, page_increment, page_size]> as "extra argument"
-to the description array. Default values will be substitued for missing
+to the description array. Default values will be substituted for missing
entries, like in:
[PF_SLIDER, "alpha value", "the alpha value", 100, [0, 255, 1] ]
@@ -824,21 +857,57 @@ string. The default brush/pattern/gradient-name can be preset.
=item PF_CUSTOM
-PF_CUSTOM is for those of you requiring some non-standard-widget. You have
-to supply a code reference returning three values as the extra argument:
+Example:
+
+ [PF_CUSTOM, "direction", "Direction to fade(0-8)", 4, sub {
+ my $btnTable = new Gtk2::Table(3,3,1);
+ $btnTable->set_border_width(6);
+ my $btn = new Gtk2::RadioButton;
+ my ($u_direction, @buttons);
+ for (my $x=0;$x<3;$x++) {
+ for (my $y=0;$y<3;$y++) {
+ my $dir = $x*3 + $y;
+ $buttons[$dir] = $btn = Gtk2::RadioButton->new_from_widget($btn);
+ $btn->set_mode(0);
+ $btn->signal_connect("clicked", sub { $u_direction = $_[1]; }, $dir);
+ $btn->show;
+ $btnTable->attach_defaults($btn, $x, $x+1, $y, $y+1);
+ my $pixmap = Gtk2::Image->new_from_pixmap(
+ Gtk2::Gdk::Pixmap->colormap_create_from_xpm_d(
+ undef, $btn->get_colormap,
+ $btn->style->bg('normal'), @{$arr[$dir]}
+ )
+ );
+ $pixmap->show;
+ $btn->add($pixmap);
+ }
+ }
+ $btnTable->show;
+ ($btnTable, sub { $buttons[$_[0]]->clicked }, sub { $u_direction });
+ },],
+
+C<PF_CUSTOM> is for those of you requiring some non-standard-widget. You
+supply a reference to code returning three values as the extra argument:
+
+=over 2
+
+=item C<widget>
- (widget, settor, gettor)
+Gtk2 widget that should be used.
-C<widget> is Gtk widget that should be used.
+=item C<settor>
-C<settor> is a function that takes a single argument, the new value for
-the widget (the widget should be updated accordingly).
+Function that takes a single argument, the new value for the widget
+(the widget should be updated accordingly).
-C<gettor> is a function that should return the current value of the widget.
+=item C<gettor>
-While the values can be of any type (as long as it fits into a scalar),
-you should be prepared to get a string when the script is started from the
-command line or via the PDB.
+Function returning the current value of the widget.
+
+=back
+
+The value set and returned must be a string. For an example of this,
+see C<examples/example-no-fu>.
=item PF_FILE
@@ -852,37 +921,26 @@ Save, and Edit (in external editor) buttons.
=back
-=head2 EMBEDDED POD DOCUMENTATION
+=head1 EMBEDDED POD DOCUMENTATION
-The register functions expects strings (actually scalars) for
-documentation, and nobody wants to embed long parts of documentation into
-a string, cluttering the whole script.
-
-Therefore, Gimp::Fu utilizes the Gimp::Pod module to display the full text
-of the pod sections that are embedded in your scripts (see L<perlpod> for
+Gimp::Fu uses the Gimp::Pod module to display the full text
+of the POD sections that are embedded in your scripts (see L<perlpod> for
an explanation of the POD documentation format) when the user hits the
-"Help" button in the dialog box.
-
-Since version 1.094, you can embed specific sections or the full pod
-text into any of the blurb, help, author, copyright and date arguments
-to the register functions. Gimp::Fu will look into all these strings
-for sequences of the form "=pod(section-name)". If found, they will
-be replaced by the text of the corresponding section from the pod
-documentation. If the named section is not found (or is empty, as in
-"=pod()"), the full pod documentation is embedded.
+"Help" button in the dialog box. More importantly, various sections of the
+POD can be used instead of hardcoding strings in the call to C<register>.
-Most of the mentioned arguments have default values (see THE REGISTER
-FUNCTION) that are used when the arguments are undefined, making the
-register call itself much shorter.
+Most of the mentioned arguments have default values (see
+L</"THE REGISTER FUNCTION">) that are used when the arguments are
+undefined or false, making the register call itself much shorter.
-=head2 MISC. FUNCTIONS
+=head1 MISCELLANEOUS FUNCTIONS
-=over
+=over 2
=item C<save_image(img,options_and_path)>
-This is the internal function used to save images. As it does more than just
-gimp_file_save, I thought it would be handy in other circumstances as well.
+This is the internal function used to save images, which does more than
+C<gimp_file_save>.
The C<img> is the image you want to save (which might get changed during
the operation!), C<options_and_path> denotes the filename and optional
diff --git a/Gimp/PixelRgn.pod b/Gimp/PixelRgn.pod
index 0c1c27f..4acfc3e 100644
--- a/Gimp/PixelRgn.pod
+++ b/Gimp/PixelRgn.pod
@@ -1,6 +1,6 @@
=head1 NAME
-Gimp::PixelRgn - how to operate on raw pixels.
+Gimp::PixelRgn - Operate on raw pixels in powerful, efficient way.
=head1 SYNOPSIS
@@ -12,7 +12,7 @@ Gimp::PixelRgn - how to operate on raw pixels.
my $gd = $l->get;
my $region = $gd->pixel_rgn(0,0,10,10,0,0);
my $piddle = $region->get_pixel($x,$y);
- print "@{[ unpdl $piddle ]}\n";
+ print $piddle."\n"; # stringified piddle is readable
=head1 DESCRIPTION
diff --git a/Gimp/Util.pm b/Gimp/Util.pm
index 1027f41..ccc380b 100644
--- a/Gimp/Util.pm
+++ b/Gimp/Util.pm
@@ -1,6 +1,6 @@
=head1 NAME
- Gimp::Util - some handy routines for Gimp-Perl users
+Gimp::Util - Handy routines for Gimp-Perl users
=head1 SYNOPSIS
diff --git a/MANIFEST b/MANIFEST
index 9fd8a9c..cf95f14 100644
--- a/MANIFEST
+++ b/MANIFEST
@@ -19,7 +19,6 @@ Gimp/Fu.pm
Gimp/Lib.pm
Gimp/Lib.xs
Gimp/Makefile.PL
-Gimp/OO.pod
Gimp/PixelRgn.pod
Gimp/Pod.pm
Gimp/Util.pm
diff --git a/Net/Net.pm b/Net/Net.pm
index a2c893f..570ae8b 100644
--- a/Net/Net.pm
+++ b/Net/Net.pm
@@ -516,7 +516,7 @@ also *might* be buffer-overflows (although I do care a lot for these).
The environment variable C<GIMP_HOST> specifies the default server to
contact and/or the password to use. The syntax is
[auth ][tcp/]hostname[:port] for tcp, [auth ]unix/local/socket/path for unix
-and spawn/ for a private gimp instance. Examples are:
+and spawn/ for a private GIMP instance. Examples are:
www.yahoo.com # just kidding ;)
yahoo.com:11100 # non-standard port
diff --git a/TODO b/TODO
index af54eb1..3f8d079 100644
--- a/TODO
+++ b/TODO
@@ -2,8 +2,7 @@ Items as of 2014-04-19 (by Ed J)
* <Load> and <Save> need any registration as such done in Gimp::Fu - see pod
* image in Gimp.pm POD http://perlmaven.com/how-to-add-images-to-cpan -
input image -> output image of a plugin
-* longer example in Gimp.pm/SYNOPSIS
-* examples POD (and Gimp::Pod TLC)
+* examples POD
* Add Gimp::existing (Gimp::Fu IMAGE) and ::become (examples/xachshadows)
* Gimp/Lib.xs is huge, and not very XS-y - lots of it is manually
pushing GIMP data structures onto perl stack and vice versa. Figure
diff --git a/examples/billboard b/examples/billboard
index 06b6027..59f99aa 100755
--- a/examples/billboard
+++ b/examples/billboard
@@ -1,15 +1,11 @@
-#!/usr/bin/perl
-
-#TODO: figure out why adding a -w gives a bunch of "
-# Use of uninitialized value in subroutine entry at /usr/lib/perl/5.8/Gimp.pm
-# line 627." messages and fix it.
+#!/usr/bin/perl -w
# I'm hacking this on top of my sethspin script, so this is doing even more
# stuff it wasn't really designed to do. Hence if you thought sethspin was
# a bit ugly, look at this one...
# I think it was tigert that suggested this. It turned out to be less
-# complex than I orginally thought so I figured I'd give it a spin.
+# complex than I originally thought so I figured I'd give it a spin.
# Seth Burgess
# <sjburges gimp org>
@@ -18,171 +14,171 @@ use Gimp qw(:auto);
use Gimp::Fu;
use Gimp::Util;
+use constant PI => 3.14159;
+
# Uncomment below to spew forth much data about whats going on.
#Gimp::set_trace(TRACE_ALL);
sub saw { # a sawtooth function on PI
- ($val) = @_;
- if ($val < 3.14159/2.0) {
- return ($val/3.14159) ;
- }
- elsif ($val < 3.14159) {
- return (-1+$val/3.14159);
- }
- elsif ($val < 3.14159+3.14159/2.0) {
- return ($val/3.14159) ;
- }
- else {
- return (-1+$val/3.14159);
- }
- }
+ my $val = @_;
+ if ($val < PI * 0.5) {
+ return $val/PI ;
+ } elsif ($val < PI) {
+ return -1 + $val/PI;
+ } elsif ($val < PI * 1.5) {
+ return $val/PI ;
+ } else {
+ return -1 + $val/PI;
+ }
+}
sub spin_layer { # the function for actually spinning the layer
- my ($img, $spin, $dest, $numframes, $prp, $blinds) = @_;
- # Now lets spin it!
- $stepsize = 3.14159/$numframes; # in radians
- for ($i=0; $i<=3.14159; $i+=$stepsize) {
- Gimp->progress_update ($i/3.14159);
- # create a new layer for spinning
- $framelay = ($i < 3.14159/2.0) ? $spin->copy(1) : $dest->copy(1);
- $img->insert_layer($framelay, 0, 0);
- # spin it a step
- # Here I need to make the proper selection, repeatedly if necessary
- $blindheight = $img->height/$blinds;
- for ($j=0; $j<$blinds; $j++) {
- # select a section
- $img->select_rectangle(2, 0, $j*$blindheight, $img->width, $blindheight);
- @x = $img->selection_bounds();
- # x[1],x[2] x[3],x[2]
- # x[1],x[4] x[3],x[4]
- $framelay->transform_perspective_default(
- $x[1]+saw($i)*$prp*$framelay->width,$x[2]+$blindheight *sin($i)/2,
- $x[3]-saw($i)*$prp*$framelay->width,$x[2]+$blindheight *sin($i)/2,
- $x[1]-saw($i)*$prp*$framelay->width,$x[4]-$blindheight *sin($i)/2,
- $x[3]+saw($i)*$prp*$framelay->width,$x[4]-$blindheight *sin($i)/2,
- 1, 1);
-
-# Gimp Perspective Functionality has changed. It used to create a floating
-# selection if there was a selection active already. Now it only does that
-# in interactive - PDB makes it a new layer. Fine by me, wish the docs had
-# changed though.
-# $floater->floating_sel_anchor;
-
- } # end for ($j=0;...
-
- # I need to create another layer behind this spun one now
- $backlayer = $framelay->layer_copy(0);
- $img->insert_layer($backlayer, 0, 1);
- $backlayer->fill(1); # BG-IMAGE-FILL
- }
- for ($i=0; $i<$numframes; $i++) {
- @all_layers = $img->get_layers();
- $img->set_visible($all_layers[$i],$all_layers[$i+1]);
- $img->merge_visible_layers(0);
- }
- @all_layers = $img->get_layers();
- $destfram = $all_layers[$numframes]->copy(0);
- $img->insert_layer($destfram,0,0);
-
- # clean up my temporary layers
- $img->remove_layer($all_layers[$numframes]);
- $img->remove_layer($all_layers[$numframes+1]);
+ my ($img, $spin, $dest, $numframes, $prp, $blinds) = @_;
+ # Now lets spin it!
+ $stepsize = 3.14159/$numframes; # in radians
+ for ($i=0; $i<=3.14159; $i+=$stepsize) {
+ Gimp->progress_update ($i/3.14159);
+ # create a new layer for spinning
+ $framelay = ($i < 3.14159/2.0) ? $spin->copy(1) : $dest->copy(1);
+ $img->insert_layer($framelay, 0, 0);
+ # spin it a step
+ # Here I need to make the proper selection, repeatedly if necessary
+ $blindheight = $img->height/$blinds;
+ for ($j=0; $j<$blinds; $j++) {
+ # select a section
+ $img->select_rectangle(2, 0, $j*$blindheight, $img->width, $blindheight);
+ @x = $img->selection_bounds();
+ # x[1],x[2] x[3],x[2]
+ # x[1],x[4] x[3],x[4]
+ $framelay->transform_perspective_default(
+ $x[1]+saw($i)*$prp*$framelay->width,$x[2]+$blindheight *sin($i)/2,
+ $x[3]-saw($i)*$prp*$framelay->width,$x[2]+$blindheight *sin($i)/2,
+ $x[1]-saw($i)*$prp*$framelay->width,$x[4]-$blindheight *sin($i)/2,
+ $x[3]+saw($i)*$prp*$framelay->width,$x[4]-$blindheight *sin($i)/2,
+ 1, 1);
+
+ # Gimp Perspective Functionality has changed. It used to create
+ # a floating selection if there was a selection active already.
+ # Now it only does that in interactive - PDB makes it a new layer.
+ # Fine by me, wish the docs had changed though.
+ #$floater->floating_sel_anchor;
+
+ } # end for ($j=0;...
+
+ # I need to create another layer behind this spun one now
+ $backlayer = $framelay->layer_copy(0);
+ $img->insert_layer($backlayer, 0, 1);
+ $backlayer->fill(1); # BG-IMAGE-FILL
+ }
+ for ($i=0; $i<$numframes; $i++) {
+ @all_layers = $img->get_layers();
+ $img->set_visible($all_layers[$i],$all_layers[$i+1]);
+ $img->merge_visible_layers(0);
+ }
+ @all_layers = $img->get_layers();
+ $destfram = $all_layers[$numframes]->copy(0);
+ $img->insert_layer($destfram,0,0);
+
+ # clean up my temporary layers
+ $img->remove_layer($all_layers[$numframes]);
+ $img->remove_layer($all_layers[$numframes+1]);
}
-register "billboard",
- "Billboard",
- "Take one image. Spin it about the horizontal axis, and end up with another image. I made it for
easy web buttons, mostly because somebody suggested to me.",
- "Seth Burgess",
- "Seth Burgess <sjburges\ gimp org>",
- "1.3",
- N_"<Image>/Filters/Animation/Billboard...",
- "*",
- [
- [PF_DRAWABLE, "source", "What drawable to spin from?"],
- [PF_DRAWABLE, "destination","What drawable to spin to?"],
- [PF_INT8, "frames", "How many frames to use?", 16],
- [PF_COLOR, "background", "What color to use for background if not transparent", [0,0,0]],
- [PF_SLIDER, "perspective", "How much perspective effect to get", 40, [0,255,5]],
- [PF_TOGGLE, "spin_back", "Also spin back?" , 0],
- [PF_TOGGLE, "convert_indexed", "Convert to indexed?", 1],
- [PF_SPINNER, "billboard_slats", "Number of shades", 3, [1,50,1]],
- ],
- [],
- ['gimp-1.1'],
- sub {
- my($in_img,$src,$dest,$frames,$color,$psp,$spinback,$indexed, $shadenum) = _;
- $maxwide = ($src->width > $dest->width) ? $src->width : $dest->width;
- $maxhigh = ($src->height > $dest->height) ? $src->height: $dest->height;
- $img = gimp_image_new($maxwide, $maxhigh, RGB);
-
-
- $tmpimglayer = $img->add_new_layer(0,3,1);
- $img->display_new;
- Gimp->progress_init("Billboard...",-1);
- Gimp::Context->push();
- Gimp::Context->set_background($color);
- $src->edit_copy();
- $spinlayer = $tmpimglayer->edit_paste(1);
- $spinlayer->floating_sel_to_layer();
-
- $dest->edit_copy();
- $destlayer = $tmpimglayer->edit_paste(1);
- $destlayer->floating_sel_to_layer();
-
- $tmpimglayer->remove_layer;
-
- $spinlayer->resize($maxwide, $maxhigh, $spinlayer->offsets);
- $destlayer->resize($maxwide, $maxhigh, $destlayer->offsets);
- # work around for PF_SLIDER when < 1
- $psp = $psp/255.0;
-
- # need an even number of frames for spinback
- if ($frames%2 && $spinback) {
- $frames++;
- gimp_message("An even number of frames is needed for spin back.\nAdjusted frames up to
$frames");
- }
-
- spin_layer($img, $spinlayer, $destlayer, $spinback ? $frames/2 : $frames-1, $psp, $shadenum);
- $img->set_visible($img->add_new_layer(1),($img->get_layers)[0]);
- $img->merge_visible_layers(0);
-
- if ($spinback) {
- @layerlist = $img->get_layers();
- $img->insert_layer($layerlist[$frames/2]->copy(0),0,0);
- @layerlist = $img->get_layers();
- spin_layer($img, $layerlist[1], $layerlist[0], $frames/2, $psp, $shadenum);
- $img->remove_layer(($img->get_layers)[0]);
- }
-
- # unhide and name layers
- @all_layers = $img->get_layers;
- $img->set_visible(@all_layers);
- for ($i=1; $i<=$frames ; $i++) {
- $all_layers[$i-1]->set_name("Spin Layer $i (50ms)");
- }
- $all_layers[$frames-1]->set_name("Spin Layer SRC (250ms)");
-
- if ($spinback) {
- $all_layers[$frames/2-1]->set_name("Spin Layer DEST (250ms)");
- }
- else { $all_layers[0]->set_name("Spin Layer DEST (250ms)")}
-
-
- # indexed conversion wants a display for some reason
- if ($indexed) {
- $img->convert_indexed(1, # dither type = fs
- MAKE_PALETTE, # palette type
- 255, # number of colors
- 0, # don't dither transparency
- 1, # (ignored)
- "Custom" # custom palette name
- );
- }
-
- Gimp::Context->pop();
- gimp_displays_flush();
- return();
-};
+register
+ "billboard",
+ "Billboard",
+ "Take one image. Spin it about the horizontal axis, and end up with another image. I made it for easy
web buttons, mostly because somebody suggested to me.",
+ "Seth Burgess",
+ "Seth Burgess <sjburges\ gimp org>",
+ "1.3",
+ N_"<Image>/Filters/Animation/Billboard...",
+ "*",
+ [
+ [PF_DRAWABLE, "destination","What drawable to spin to?"],
+ [PF_INT8, "frames", "How many frames to use?", 16],
+ [PF_COLOR, "background", "What color to use for background if not transparent", 'black'],
+ [PF_INT8, "perspective", "How much perspective effect to get", 40],
+ [PF_TOGGLE, "spin_back", "Also spin back?" , 0],
+ [PF_TOGGLE, "convert_indexed", "Convert to indexed?", 1],
+ [PF_SPINNER, "billboard_slats", "Number of shades", 3, [1,50,1]],
+ ],
+ [],
+ sub {
+ my($in_img,$src,$dest,$frames,$color,$psp,$spinback,$indexed,$shadenum)= _;
+ $maxwide = ($src->width > $dest->width) ? $src->width : $dest->width;
+ $maxhigh = ($src->height > $dest->height) ? $src->height: $dest->height;
+ $img = gimp_image_new($maxwide, $maxhigh, RGB);
+
+ $tmpimglayer = $img->add_new_layer(0,3,1);
+ $img->display_new;
+ Gimp->progress_init("Billboard...",-1);
+ Gimp::Context->push();
+ Gimp::Context->set_background($color);
+ $src->edit_copy();
+ $spinlayer = $tmpimglayer->edit_paste(1);
+ $spinlayer->floating_sel_to_layer();
+
+ $dest->edit_copy();
+ $destlayer = $tmpimglayer->edit_paste(1);
+ $destlayer->floating_sel_to_layer();
+
+ $tmpimglayer->remove_layer;
+
+ $spinlayer->resize($maxwide, $maxhigh, $spinlayer->offsets);
+ $destlayer->resize($maxwide, $maxhigh, $destlayer->offsets);
+ # work around for PF_SLIDER when < 1
+ $psp = $psp/255.0;
+
+ # need an even number of frames for spinback
+ if ($frames%2 && $spinback) {
+ $frames++;
+ gimp_message(<<EOF);
+An even number of frames is needed for spin back.
+Adjusted frames up to $frames
+EOF
+ }
+
+ spin_layer($img, $spinlayer, $destlayer, $spinback ? $frames/2 : $frames-1, $psp, $shadenum);
+ $img->set_visible($img->add_new_layer(1),($img->get_layers)[0]);
+ $img->merge_visible_layers(0);
+
+ if ($spinback) {
+ @layerlist = $img->get_layers();
+ $img->insert_layer($layerlist[$frames/2]->copy(0),0,0);
+ @layerlist = $img->get_layers();
+ spin_layer($img, $layerlist[1], $layerlist[0], $frames/2, $psp, $shadenum);
+ $img->remove_layer(($img->get_layers)[0]);
+ }
+
+ # unhide and name layers
+ @all_layers = $img->get_layers;
+ $img->set_visible(@all_layers);
+ for ($i=1; $i<=$frames ; $i++) {
+ $all_layers[$i-1]->set_name("Spin Layer $i (50ms)");
+ }
+ $all_layers[$frames-1]->set_name("Spin Layer SRC (250ms)");
+
+ if ($spinback) {
+ $all_layers[$frames/2-1]->set_name("Spin Layer DEST (250ms)");
+ } else {
+ $all_layers[0]->set_name("Spin Layer DEST (250ms)");
+ }
+
+ # indexed conversion wants a display for some reason
+ if ($indexed) {
+ $img->convert_indexed(1, # dither type = fs
+ MAKE_PALETTE, # palette type
+ 255, # number of colors
+ 0, # don't dither transparency
+ 1, # (ignored)
+ "Custom" # custom palette name
+ );
+ }
+
+ Gimp::Context->pop();
+ gimp_displays_flush();
+ return();
+ };
exit main;
@@ -190,7 +186,4 @@ exit main;
Copyright Seth Burgess.
-Distrubted under the same terms as Gimp-Perl.
-
-=cut
-
+Distributed under the same terms as Gimp-Perl.
diff --git a/examples/dots b/examples/dots
index f29bb44..8312419 100755
--- a/examples/dots
+++ b/examples/dots
@@ -1,109 +1,98 @@
#!/usr/bin/perl
-# <sjburges gimp org>
-# Generate dots within a selection.
-
#BEGIN { $Gimp::verbose = 1; }
-use Gimp qw(:auto __ N_);
+use Gimp;
use Gimp::Fu;
-use Gimp::Util;
-
#Gimp::set_trace(TRACE_ALL);
-register "dots",
- "Dots",
- "Create evenly spaced dots on a layer, within a selection.",
- "Seth Burgess",
- "Seth Burgess <sjburges\ gimp org>",
- "2003-09-20",
- N_"<Image>/Filters/Render/Pattern/Dots...",
- "RGB*, GRAY*",
- [
- [PF_SPINNER, "size", "Diameter of dots", 4, [1,255,1]],
- [PF_COLOR, "dotcolor", "Color of the dots", [0,0,255]],
- [PF_SLIDER, "opacity", "Opacity of dots", 100, [0,100,1]],
- [PF_SPINNER, "xspacing", "Spacing of dots in X dimension", 16, [1,255,1]],
- [PF_SPINNER, "yspacing", "Spacing of dots in Y dimension", 16, [1,255,1]],
- [PF_SPINNER, "xoffset", "Offset of dots in X dimension", 0, [0,255,1]],
- [PF_SPINNER, "yoffset", "Offset of dots in y dimension", 0, [0,255,1]],
- ],
- [],
- sub {
- my($img,$layer,$size,$dotcolor,$opacity,$xspacing,$yspacing,$xoffset,$yoffset) = _;
- my $has_noselection;
- $layer->is_layer || die "A layer is required for this plugin";
-
- $yoffset = $yoffset % $yspacing;
- $xoffset = $xoffset % $xspacing;
-
- $img->undo_group_start;
-
+podregister {
+ my($img,$layer,$size,$color,$opacity,$xspacing,$yspacing,$xoffset,$yoffset) = _;
+ my $has_noselection;
+ $layer->is_layer || die "A layer is required for this plugin";
+ $yoffset %= $yspacing;
+ $xoffset %= $xspacing;
+ $img->undo_group_start;
# Get/save current selection info
- @bounds = $img->selection_bounds;
- if (!$bounds[0])
- {
- $img->selection_all;
- $has_noselection=1;
- }
- $selchannel = $img->selection_save;
-
+ if (!($img->selection_bounds)[0]) {
+ $img->selection_all;
+ $has_noselection=1;
+ }
+ $selchannel = $img->selection_save;
# Generate selection mask of dots on entire image
+ $img->selection_none;
+ for ($x=$xoffset-$xspacing; $x<$img->width+$size+$xspacing; $x+=$xspacing) {
+ for (
+ $y=$yoffset-$yspacing; $y<$img->height+$size+$yspacing; $y+=$yspacing
+ ) {
+ $img->select_ellipse(CHANNEL_OP_ADD,$x-0.5*$size,$y-0.5*$size,
+ $size,$size);
+ }
+ }
+# Set opacity of dots via selection mask
+ Gimp::Context->push;
+ $opc = Gimp::Channel->new($img,$img->width,$img->height,"OPC", 50, [0,0,0]);
+ $img->insert_channel($opc,0,0);
+ Gimp::Context->set_foreground([($opacity/100.0)x3]);
+ $opc->fill(FOREGROUND_FILL);
+ $img->select_item(CHANNEL_OP_INTERSECT, $opc);
+# And mask off with original selection
+ $img->select_item(CHANNEL_OP_INTERSECT, $selchannel);
+# Make the dots
+ Gimp::Context->set_foreground($color);
+ $layer->edit_fill(FOREGROUND_FILL);
+# Cleanup to state before plugin was called
+ if ($has_noselection) {
$img->selection_none;
- for ($x=$xoffset-$xspacing;
- $x<$img->width+$size+$xspacing;
- $x+=$xspacing)
- {
- for ($y=$yoffset-$yspacing;
- $y<$img->height+$size+$yspacing;
- $y+=$yspacing)
- {
- $img->select_ellipse(CHANNEL_OP_ADD,$x-0.5*$size,$y-0.5*$size,
- $size,$size);
- }
- }
+ } else {
+ $img->select_item(CHANNEL_OP_REPLACE, $selchannel);
+ }
+ $img->remove_channel($selchannel);
+ $img->remove_channel($opc);
+ Gimp::Context->pop;
+ $img->undo_group_end;
+ $layer->set_active_layer;
+ return;
+};
-# Set opacity of dots via selection mask
- Gimp::Context->push();
+exit main;
+__END__
- $opc = gimp_channel_new($img,$img->width,$img->height,"OPC", 50, [0,0,0]);
- $img->insert_channel($opc,0,0);
- Gimp::Context->set_foreground([($opacity/100.0)x3]);
- $opc->fill(FOREGROUND_FILL);
- $img->select_item(CHANNEL_OP_INTERSECT, $opc);
+=head1 NAME
-# And mask off with original selection
- $img->select_item(CHANNEL_OP_INTERSECT, $selchannel);
+dots - Create evenly spaced dots on a layer, within a selection
-# Make the dots
- Gimp::Context->set_foreground($dotcolor);
- $layer->edit_fill(FOREGROUND_FILL);
+=head1 SYNOPSIS
-# Cleanup to state before plugin was called
- if ($has_noselection)
- {
- $img->selection_none;
- }
- else
- {
- $img->select_item(CHANNEL_OP_REPLACE, $selchannel);
- }
+<Image>/Filters/Render/Pattern/Dots...
- $img->remove_channel($selchannel);
- $img->remove_channel($opc);
+=head1 DESCRIPTION
- Gimp::Context->pop();
+Create evenly spaced dots of the given colour on a layer, within a
+selection (or on whole layer if no selection).
- $img->undo_group_end;
- $layer->set_active_layer;
+=head1 PARAMETERS
- return();
-};
-exit main;
+ [PF_SPINNER, "size", "Diameter of dots", 4, [1,255,1]],
+ [PF_COLOR, "dotcolor", "Color of the dots", [0,0,255]],
+ [PF_SLIDER, "opacity", "Opacity of dots", 100, [0,100,1]],
+ [PF_SPINNER, "xspacing", "Spacing of dots in X dimension", 16, [1,255,1]],
+ [PF_SPINNER, "yspacing", "Spacing of dots in Y dimension", 16, [1,255,1]],
+ [PF_SPINNER, "xoffset", "Offset of dots in X dimension", 0, [0,255,1]],
+ [PF_SPINNER, "yoffset", "Offset of dots in y dimension", 0, [0,255,1]],
+
+=head1 IMAGE TYPES
+
+RGB*, GRAY*
+
+=head1 AUTHOR
+
+Seth Burgess <sjburges gimp org>
+
+=head1 DATE
+
+2003-09-20
=head1 LICENSE
Copyright Seth Burgess.
Distributed under the same terms as Gimp-Perl.
-
-=cut
-
diff --git a/examples/dust b/examples/dust
index 3bb0343..338dd5a 100755
--- a/examples/dust
+++ b/examples/dust
@@ -52,22 +52,7 @@ use Gimp::Util;
# the next line just shows a graph of the "random" numbers.
#set_seed 0; use PDL; use PDL::Graphics::PGPLOT; line(pdl(float,map gen_rand, 1..500));
-register "dust",
- "",
- "",
- "Marc Lehmann",
- "Marc Lehmann <pcg\ goof com",
- "0.1",
- N_"<Image>/Filters/Render/Add Dust...",
- "*",
- # Eingabeparameter
- # Typ Name Beschreibung Wert
- [
- [PF_FLOAT, 'density', 'dust density in dust/pixel', 0.0001],
- [PF_INT32, 'seed', 'the random seed (0 == unspecified)', 0],
- [PF_SPINNER, 'length', 'the average dust corn length', 50, [1,300]],
- ],
- sub { # Perl-Code
+podregister {
# Die Parameter werden ganz "normal" �bergeben:
my ($image, $layer, $density, $seed, $len) = @_;
@@ -135,11 +120,40 @@ register "dust",
# };
exit main;
+__END__
-=head1 LICENSE
+=head1 NAME
-Copyright Marc Lehman.
-Distributed under the same terms as Gimp-Perl.
+dust - Add dust to image
+
+=head1 SYNOPSIS
+
+<Image>/Filters/Render/Add Dust...
+
+=head1 DESCRIPTION
+
+Add the appearance of dust to an image.
+
+=head1 PARAMETERS
+
+ [PF_FLOAT, 'density', 'dust density in dust/pixel', 0.0001],
+ [PF_INT32, 'seed', 'the random seed (0 == unspecified)', 0],
+ [PF_SPINNER, 'length', 'the average dust corn length', 50, [1,300]],
+
+=head1 IMAGE TYPES
-=cut
+*
+=head1 AUTHOR
+
+Marc Lehmann <pcg goof com>
+
+=head1 DATE
+
+Version 0.1
+
+=head1 LICENSE
+
+Copyright Marc Lehmann.
+
+Distributed under the same terms as Gimp-Perl.
diff --git a/examples/example-fu b/examples/example-fu
index dc98d23..5cf3443 100755
--- a/examples/example-fu
+++ b/examples/example-fu
@@ -1,87 +1,77 @@
#!/usr/bin/perl
+use strict;
use Gimp;
use Gimp::Fu;
-# expand your terminal to 121 across to read easily...
-
-register
- "gimp_fu_example_script", # fill in a function name
- "An example of Gimp::Fu usage, mostly non-functional", # and a short description,
- "Just a starting point to derive new ". # a (possibly multiline) help text
- "scripts. Always remember to put a long".
- "help message here!",
- "Marc Lehmann <pcg\ goof com>", # don't forget your name (author)
- "(c)1998,1999,2000 Marc Lehmann", # and your copyright!
- "20000321", # the date this script was written (YYYYMMDD)
- N_"<Toolbox>/Xtns/Perl/Gimp::Fu Example...", # the menu path - the 'N_' is for internationalization
- "", # image types to accept (RGB, RGAB and GRAYA) - blank or
undef means don't need one
- [ # one of each type of parameter here
- # argument type, switch name , a short description , default value, extra arguments
- [PF_SLIDER , "width" , "The image width" , 360, [300, 500]],
- [PF_SPINNER , "height" , "The image height" , 100, [100, 200]],
- [PF_STRING , "text" , "The Message" , "example text"],
- [PF_INT32 , "bordersize" , "The bordersize" , 10],
- [PF_FLOAT , "borderwidth" , "The borderwidth" , 1/5],
- [PF_FONT , "font" , "The Font Family" ],
- [PF_COLOUR , "text_colour" , "The (foreground) text colour", [10,10,10]],
- [PF_COLOUR , "bg_colour" , "The background colour" , [0xff,0x80,0]],
- [PF_TOGGLE , "ignore_cols" , "Ignore colours" , 0],
- [PF_IMAGE , "extra_image" , "An additonal picture to ignore"],
- [PF_DRAWABLE , "extra_draw" , "Somehting to ignroe as well" ],
- [PF_RADIO , "type" , "The effect type" , 0, [small => 0, large => 1]],
- [PF_BRUSH , "a_brush" , "An unused brush" ],
- [PF_PATTERN , "a_pattern" , "An unused pattern" ],
- [PF_GRADIENT , "a_gradients" , "An unused gradients" ],
- ],
- [
- [PF_IMAGE , "output image", "Output image"],
- ],
- sub {
-
- # now do something useful with our parameters
-
my($width,$height,$text,$brd1,$brd2,$font,$fg,$bg,$ignore,$xtraimg,$xtradrw,$effecttype,$brush,$pattern,$gradient)=
_;
-
- # set tracing, disable this to get rid of the debugging output
- Gimp::set_trace(TRACE_CALL);
-
- # store current context, so that present settings aren't affected
- Gimp::Context->push();
-
- my $img = new Gimp::Image ($width, $height, RGB);
-
- # put an undo group around any modifications, so that
- # they can be undone in one step.
- $img->undo_group_start;
-
- # the __ before the string in the next line indicates text that must be translated
- my $l = new Gimp::Layer ($img, $width, $height, RGB, __"Background", 100, NORMAL_MODE);
- $l->insert_layer(0, 0);
-
- # now a few syntax examples
-
- Gimp::Context->set_foreground($fg) unless $ignore;
- Gimp::Context->set_background($bg) unless $ignore;
-
- fill $l BACKGROUND_FILL;
- my $text_layer = $img->text_fontname(-1, 10, 10, $text, 5, 1, 10, PIXELS, $font);
-
- Gimp::Context->set_foreground("green");
-
- # close the undo push group
- $img->undo_group_end;
-
- # restore original context
- Gimp::Context->pop();
-
- $img; # return the image, as it's on our output parameters
+podregister {
+
my($width,$height,$text,$longtext,$brd1,$brd2,$font,$fg,$bg,$ignore,$xtraimg,$xtradrw,$effecttype,$brush,$pattern,$gradient)=
_;
+ Gimp::set_trace(TRACE_CALL); # remove this to stop debugging output
+ Gimp::Context->push; # store current settings, so present ones preserved
+ my $img = Gimp::Image->new($width, $height, RGB);
+ $img->undo_group_start; # so all actions can be undone in one step
+ # the __ before the string will translate it if available
+ my $l = Gimp::Layer->new($img, $width, $height, RGB, __"Background", 100, NORMAL_MODE);
+ $l->insert_layer(0, 0); # required!
+ # now a few syntax examples
+ Gimp::Context->set_foreground($fg) unless $ignore;
+ Gimp::Context->set_background($bg) unless $ignore;
+ fill $l BACKGROUND_FILL;
+ my $text_layer = $img->text_fontname(-1, 10, 10, $text, 5, 1, 10, PIXELS, $font);
+ Gimp::Context->set_foreground("green");
+ $img->undo_group_end; # close the undo group
+ Gimp::Context->pop; # restore original context
+ Gimp::Display->new($img);
+ $img; # return image, as Gimp::Fu added that to our output parameters
+ # because no-image-input
};
exit main;
-=head1 LICENSE
+__END__
-Copyright Marc Lehman.
-Distributed under the same terms as Gimp-Perl.
+=head1 NAME
+
+example_script - Gimp::Fu example, mostly non-functional
+
+=head1 SYNOPSIS
+
+<Image>/Filters/Languages/_Perl/_Test/Dialog
+
+=head1 DESCRIPTION
+
+Just a starting point to derive new scripts. Always remember to put a
+long help message here!
+
+=head1 PARAMETERS
-=cut
+ # one of each type of parameter here
+ # argument type, variable name, short description, default, extra arguments
+ [PF_SLIDER , "width" , "Image width" , 360, [300, 500]],
+ [PF_SPINNER , "height" , "Image height" , 100, [100, 200]],
+ [PF_STRING , "text" , "Message" , "example text"],
+ [PF_TEXT , "longtext" , "Longer text" , "more example text"],
+ [PF_INT32 , "bordersize" , "Border size" , 10],
+ [PF_FLOAT , "borderwidth" , "Border width" , 1/5],
+ [PF_FONT , "font" , "Font"],
+ [PF_COLOUR , "text_colour" , "Text colour", [10,10,10]],
+ [PF_COLOUR , "bg_colour" , "Background colour" , [0xff,0x80,0]],
+ [PF_TOGGLE , "ignore_cols" , "Ignore colours" , 0],
+ [PF_IMAGE , "extra_image" , "Additional picture to ignore"],
+ [PF_DRAWABLE , "extra_draw" , "Something to ignore as well" ],
+ [PF_RADIO , "type" , "Effect type" , 0, [small => 0, large => 1]],
+ [PF_BRUSH , "a_brush" , "An unused brush"],
+ [PF_PATTERN , "a_pattern" , "An unused pattern"],
+ [PF_GRADIENT , "a_gradients" , "An unused gradients"],
+=head1 AUTHOR
+
+Marc Lehmann <pcg goof com>
+
+=head1 DATE
+
+2000-03-21
+
+=head1 LICENSE
+
+(c) 1998,1999,2000 Marc Lehmann
+Distributed under the same terms as Gimp-Perl.
diff --git a/examples/exceptiontest b/examples/exceptiontest
index c4ab5f2..81f9bfd 100755
--- a/examples/exceptiontest
+++ b/examples/exceptiontest
@@ -21,7 +21,7 @@ sub boilerplate_params {
"test_exception",
boilerplate_params(
'exceptions',
- '<Image>/Filters/Languages/_Perl/Test/Exception', '',
+ '<Image>/Filters/Languages/_Perl/_Test/Exception', '',
),
[],
sub { die "I DIED\n" }
diff --git a/examples/fade-alpha b/examples/fade-alpha
index 1f455cb..da6136d 100755
--- a/examples/fade-alpha
+++ b/examples/fade-alpha
@@ -1,26 +1,17 @@
#!/usr/bin/perl -w
-use Gtk2;
-use Gimp qw(:auto);
-
-use strict 'vars';
-
-# Gimp::set_trace(TRACE_ALL);
+use Gimp;
+use Gimp::Fu;
+use strict;
+# 2014/04/20 Ed J: rewrite to use Gimp::Fu and PF_CUSTOM
# 12/5/03: <sjburges gimp org>
# s/->mask/->get_mask
# 3/21/04: <sjburges gimp org>
# s/AlphaFade/alpha_fade/ to be compatible with PDB naming conventions
-###
-# Globals
-###
-my ($direction, $cancelFlag);
-my ($plugin) = "plug_in_alpha_fade";
-
-# XPM's that I removed the $ and the @'s from (they get intrepreted in
+# XPM's that I removed the $ and the @'s from (they get interpreted in
# strings, which makes for nasty problems).
-
my @arr = (
["24 24 66 1",
" c None",
@@ -783,305 +774,106 @@ my @arr = (
"WWWWWWWWWWWWWWWWWWWWWWWW"
]);
-###
-# Subroutines
-###
-sub do_fade
-{
- my ($image, $drawable) = @_;
- my (@bounds, $mask, $prevBack, $prevFore);
-
- if (!$drawable->is_layer)
- {
- die "$plugin: Cannot operate on anything other than layers; Check that you don't have a channel or
floating selection currently selected.";
- }
-
- $image->undo_group_start;
- @bounds = $image->selection_bounds;
-
- if (!$drawable->has_alpha)
- {
- $drawable->add_alpha;
- }
-
- if ($drawable->get_mask)
- {
- $mask = $drawable->get_mask;
- }
- else
- {
+sub avg { ($_[0] + $_[1]) / 2 }
+
+register
+ "alpha_fade",
+ "Fade the alpha channel of a layer from one side to another",
+ <<EOF,
+Rewritten by Ed J to use Gimp::Fu as demo of PF_CUSTOM widget. Original
+by Seth Burgess, inspired by a mailing list question that asked how to do
+exactly what this does, which is fade the alpha from one side to another.
+EOF
+ "Seth Burgess",
+ "Seth Burgess",
+ "2000",
+ "<Image>/Layer/Transparency/_Fade...",
+ "*",
+ [
+ [PF_CUSTOM, "direction", "Direction to fade(0-8)", 4, sub {
+ my $btnTable = new Gtk2::Table(3,3,1);
+ $btnTable->set_border_width(6);
+ my $btn = new Gtk2::RadioButton;
+ my $u_direction;
+ my @buttons;
+ for (my $x=0;$x<3;$x++) {
+ for (my $y=0;$y<3;$y++) {
+ my $dir = $x*3 + $y;
+ $buttons[$dir] = $btn = Gtk2::RadioButton->new_from_widget($btn);
+ $btn->set_mode(0);
+ $btn->signal_connect("clicked", sub { $u_direction = $_[1]; }, $dir);
+ $btn->show;
+ $btnTable->attach_defaults($btn, $x, $x+1, $y, $y+1);
+ my $pixmap = Gtk2::Image->new_from_pixmap(
+ Gtk2::Gdk::Pixmap->colormap_create_from_xpm_d(
+ undef, $btn->get_colormap,
+ $btn->style->bg('normal'), @{$arr[$dir]}
+ )
+ );
+ $pixmap->show;
+ $btn->add($pixmap);
+ }
+ }
+ $btnTable->show;
+ ($btnTable, sub { $buttons[$_[0]]->clicked }, sub { $u_direction });
+ },
+ ]
+ ],
+ [],
+ sub {
+ my ($image, $drawable, $direction) = @_;
+ die "Can only operate on layers\n" unless $drawable->is_layer;
+ $drawable->become('Gimp::Layer');
+ $image->undo_group_start;
+ my @bounds = $image->selection_bounds;
+ $drawable->add_alpha unless $drawable->has_alpha;
+ my $mask;
+ unless ($mask = $drawable->get_mask) {
$mask = $drawable->create_mask(ADD_ALPHA_MASK);
$drawable->add_mask($mask);
}
-
- Gimp::Context->push();
-
- Gimp::Context->set_background([0.0,0.0,0.0,1.0]);
- Gimp::Context->set_foreground([1.0,1.0,1.0,1.0]);
-
- # Direction Map
- # 0 3 6
- # 1 4 7
- # 2 5 8
-
- # Bounds Map
- # (1,2) (3,2)
- # (1,4) (3,4)
-
- if ($direction==0)
- {
- $mask->edit_blend(FG_BG_RGB_MODE,
- NORMAL_MODE,
- GRADIENT_LINEAR,
- 100.0, # opacity
- 0.0, # offset
- REPEAT_NONE,
- 0, # reverse
- 0, # supersample
- 1, # recursion levels
- 0.1, # supersample threshold
- 0, # dither
- $bounds[3], $bounds[4],
- $bounds[1], $bounds[2]);
- }
- elsif ($direction==1)
- {
- $mask->edit_blend(FG_BG_RGB_MODE, DARKEN_ONLY_MODE, GRADIENT_LINEAR, 100.0, 0.0,
- REPEAT_NONE, 0, 0, 0, 1, 0,
- $bounds[3], ($bounds[2]+$bounds[4])/2,
- $bounds[1], ($bounds[2]+$bounds[4])/2);
-
- }
- elsif ($direction==2)
- {
- $mask->edit_blend(FG_BG_RGB_MODE, DARKEN_ONLY_MODE, GRADIENT_LINEAR, 100.0, 0.0,
- REPEAT_NONE, 0, 0, 0, 1, 0,
- $bounds[3], $bounds[2],
- $bounds[1], $bounds[4]);
-
- }
- elsif ($direction==3)
- {
- $mask->edit_blend(FG_BG_RGB_MODE, DARKEN_ONLY_MODE, GRADIENT_LINEAR, 100.0, 0.0,
- REPEAT_NONE, 0, 0, 0, 1, 0,
- ($bounds[3]+$bounds[1])/2, $bounds[4],
- ($bounds[3]+$bounds[1])/2, $bounds[2]);
- }
- elsif ($direction==4)
- {
- $mask->edit_blend(FG_BG_RGB_MODE, DARKEN_ONLY_MODE, GRADIENT_RADIAL, 100.0, 0.0,
- REPEAT_NONE, 0, 0, 0, 1, 0,
- ($bounds[1]+$bounds[3])/2,
- ($bounds[2]+$bounds[4])/2,
- ($bounds[3]+$bounds[1])/2, $bounds[4]);
-
- }
- elsif ($direction==5)
- {
- $mask->edit_blend(FG_BG_RGB_MODE, DARKEN_ONLY_MODE, GRADIENT_LINEAR, 100.0, 0.0,
- REPEAT_NONE, 0, 0, 0, 1, 0,
- ($bounds[3]+$bounds[1])/2, $bounds[2],
- ($bounds[3]+$bounds[1])/2, $bounds[4]);
- }
- elsif ($direction==6)
- {
- $mask->edit_blend(FG_BG_RGB_MODE, DARKEN_ONLY_MODE, GRADIENT_LINEAR, 100.0, 0.0,
- REPEAT_NONE, 0, 0, 0, 1, 0,
- $bounds[1], $bounds[4],
- $bounds[3], $bounds[2]);
- }
- elsif ($direction==7)
- {
- $mask->edit_blend(FG_BG_RGB_MODE, DARKEN_ONLY_MODE, GRADIENT_LINEAR, 100.0, 0.0,
- REPEAT_NONE, 0, 0, 0, 1, 0,
- $bounds[1], ($bounds[2]+$bounds[4])/2,
- $bounds[3], ($bounds[2]+$bounds[4])/2);
- }
- elsif ($direction==8)
- {
- $mask->edit_blend(FG_BG_RGB_MODE, DARKEN_ONLY_MODE, GRADIENT_LINEAR, 100.0, 0.0,
- REPEAT_NONE, 0, 0, 0, 1, 0,
- $bounds[1], $bounds[2],
- $bounds[3], $bounds[4]);
- }
- if ($direction >=0 && $direction <9)
- {
- $drawable->remove_mask(MASK_APPLY);
- }
-
- Gimp::Context->pop();
- $image->undo_group_end;
-}
-
-sub btn_pressed
-{
- my ($widget, $btnIndex) = @_;
- $direction = $btnIndex;
-}
-
-sub add_pixmap
-{
- my ($window, $but, $num) = @_;
- my @tar = @{$arr[$num]};
- my ($pixmap, $mask) = Gtk2::Gdk::Pixmap->colormap_create_from_xpm_d(undef,
- $but->get_colormap,
- $but->style->bg('normal'),
- @{$arr[$num]});
- my ($pixmapId) = new_from_pixmap Gtk2::Image($pixmap, $mask);
-
- $pixmapId->show;
- $but->add($pixmapId);
-}
-
-sub okCbk
-{
- $cancelFlag = 0;
- Gtk2->main_quit;
-}
-
-sub create_window
-{
- my ($window, $frm, $box1, $hbox, $hsep, $btnTable, $i, $j, $btn);
-
- $window = new Gtk2::Window('toplevel');
- $window->set_name("Alpha Fader");
- $window->set_wmclass("Gimp", "AlphaFader");
-
- $window->signal_connect("destroy" => \&Gtk2::main_quit);
- $window->signal_connect("delete_event" => \&Gtk2::false);
-
- $box1 = new Gtk2::VBox(0, 0);
- $box1->set_spacing(2);
- $window->add($box1);
-
- $frm = new Gtk2::Frame "Fade Type";
- $frm->set_border_width(6);
- $frm->show;
-
- $box1->pack_start($frm, 1, 1, 0);
- $btnTable = new Gtk2::Table(3,3,1);
- $btnTable->set_border_width(6);
- $frm->add($btnTable);
-
- $btn = new Gtk2::RadioButton;
-
- for ($i=0;$i<3;$i++)
- {
- for ($j=0;$j<3;$j++)
- {
- $btn = Gtk2::RadioButton->new_from_widget($btn);
- $btn->set_mode(0);
- $btn->signal_connect("clicked", \&btn_pressed, $i*3+$j);
- $btn->show;
- $btnTable->attach_defaults($btn, $i, $i+1, $j, $j+1);
- add_pixmap($window, $btn, $i*3+$j);
-
- if (Gimp->get_data($plugin) ne "")
- { # if run before, get last data
- if (Gimp->get_data($plugin) == $i*3+$j)
- {
- $btn->clicked;
- }
- }
- else
- { # first run of plug-in, set first button
- if ($i==0 && $j==0)
- {
- $btn->clicked;
- }
- }
- }
- }
-
- $hsep = new Gtk2::HSeparator;
- $box1->pack_start($hsep, 0, 0, 0);
- $hsep->show;
-
- $hbox = new Gtk2::HButtonBox;
- $hbox->set_border_width(2);
- $hbox->set_spacing(4);
- $box1->pack_start($hbox, 0, 0, 0);
- $hbox->show;
-
- $btn = new Gtk2::Button "OK";
- $btn->can_default(1);
- $btn->signal_connect("clicked" => \&okCbk);
- $btn->show;
- $hbox->pack_start($btn, 0, 0, 0);
- $btn->grab_default;
-
- $btn = new Gtk2::Button "Cancel";
- $btn->can_default(1);
- $btn->signal_connect("clicked" => \&Gtk2::main_quit);
- $btn->show;
- $hbox->pack_start($btn, 0, 0, 0);
-
- $btnTable->show;
- $box1->show;
- $window->show;
-}
-
-Gimp::on_run
-{
- my ($interactive, $img, $drw);
- ($interactive, $img, $drw, $direction) = @_;
-
- $cancelFlag = 1;
- if ($interactive==1)
- {
- $cancelFlag = 0;
- }
- elsif ($interactive==2)
- {
- $direction = Gimp->get_data($plugin);
- $cancelFlag = 0;
- }
- else
- {
- init Gtk2;
- create_window;
- main Gtk2;
- }
-
- # Do the gimply stuff on it
- if (!$cancelFlag)
- {
- do_fade($img, $drw);
- Gimp->displays_flush;
- Gimp->set_data($plugin, $direction);
- }
-};
-
-Gimp::on_query {
-gimp_install_procedure(
-$plugin,
-"Fade the alpha channel of a layer from one side to another",
-"This was written as a slightly useful exercise,
-mostly to learn Gtk's excellent perl interface. It was
-inspired by a mailing list question that asked how to do
-exactly what this does, which is fade the alpha from one
-side to another.",
-"Seth Burgess",
-"Seth Burgess",
-"2000",
-"<Image>/Layer/Transparency/Fade...",
-"*",
-PLUGIN,
-[
- [PDB_INT32, "run_mode", "Interactive, [non-interactive"],
- [PDB_IMAGE, "image", "Input image (unused)"],
- [PDB_DRAWABLE, "drawable", "Input drawable"],
- [PDB_INT32, "direction", "Direction to fade(0-8)"]
-],
-[]);
-};
-
-exit Gimp::main;
+ Gimp::Context->push;
+ Gimp::Context->set_background([0.0,0.0,0.0,1.0]);
+ Gimp::Context->set_foreground([1.0,1.0,1.0,1.0]);
+ # Direction Map
+ # 0 3 6
+ # 1 4 7
+ # 2 5 8
+ # Bounds Map
+ # (1,2) (3,2)
+ # (1,4) (3,4)
+ my @blend_args = (
+ FG_BG_RGB_MODE, NORMAL_MODE,
+ ($direction == 4 ? GRADIENT_RADIAL : GRADIENT_LINEAR),
+ 100.0, # opacity
+ 0.0, # offset
+ REPEAT_NONE,
+ 0, # reverse
+ 0, # supersample
+ 1, # recursion levels
+ 0.1, # supersample threshold
+ 0, # dither
+ );
+ my %dir2argfunc = (
+ 0 => sub { @_[3, 4, 1, 2] },
+ 1 => sub { ($_[3], avg(@_[2,4]), $_[1], avg(@_[2,4])) },
+ 2 => sub { @_[3, 2, 1, 4] },
+ 3 => sub { (avg(@_[1,3]), $_[4], avg(@_[1,3]), $_[2]) },
+ 4 => sub { (avg(@_[1,3]), avg(@_[2,4]), avg(@_[1,3]), $_[4]) }, # radial
+ 5 => sub { (avg(@_[1,3]), $_[2], avg(@_[1,3]), $_[4]) },
+ 6 => sub { @_[1, 4, 3, 2] },
+ 7 => sub { ($_[1], avg(@_[2,4]), $_[3], avg(@_[2,4])) },
+ 8 => sub { @_[1, 2, 3, 4] },
+ );
+ $mask->edit_blend(@blend_args, $dir2argfunc{$direction}->(@bounds));
+ $drawable->remove_mask(MASK_APPLY) if $direction >=0 && $direction <9;
+ Gimp::Context->pop;
+ $image->undo_group_end;
+ };
+
+exit main;
=head1 LICENSE
Copyright Seth Burgess.
Distributed under the same terms as Gimp-Perl.
-
-=cut
-
diff --git a/examples/layerfuncs b/examples/layerfuncs
index 3a75954..dfe834d 100755
--- a/examples/layerfuncs
+++ b/examples/layerfuncs
@@ -16,7 +16,9 @@ register "center_layer", "Center Layer",
"Seth Burgess", "Seth Burgess <sjburges\ gimp org>",
"1.0", N_"<Image>/Layer/Center Layer", "*", [], sub {
($img, $layer) = @_;
- $layer->Gimp::Layer::set_offsets(($img->width - $layer->width )/2,
+ die "Must have layer selected\n" unless $layer->is_layer;
+ $layer->become('Gimp::Layer');
+ $layer->set_offsets(($img->width - $layer->width )/2,
($img->height - $layer->height)/2);
return();
};
diff --git a/examples/redeye b/examples/redeye
index 7b01e8c..b9ce98f 100755
--- a/examples/redeye
+++ b/examples/redeye
@@ -122,7 +122,7 @@ __END__
=pod
-=head1 HELP
+=head1 DESCRIPTION
Searches the selection for pixels in which the red component
dominates, and removes the red from those components. The sensitivity
@@ -142,7 +142,4 @@ different sensitivity.
Copyright Geoff Kuenning
-Distrubted under the Gnu Public License v2 or higher.
-
-=cut
-
+Distributed under the Gnu Public License v2 or higher.
diff --git a/examples/selective_sharpen b/examples/selective_sharpen
index eee809b..c87a7b8 100755
--- a/examples/selective_sharpen
+++ b/examples/selective_sharpen
@@ -5,7 +5,7 @@ use Gimp::Fu;
# Gimp::set_trace(TRACE_ALL);
-sub my_code {
+podregister {
my ($img,$original_layer,$sharpen_radius,$sharpen_amt,$sharpen_threshold) = @_;
# sanity stuff
@@ -63,54 +63,69 @@ sub my_code {
$img->undo_group_end;
();
-}
-
-register "selective_sharpen",
- "Selective Sharpen - A method used by tigert to sharpen edges",
- "",
- "Seth Burgess <sjburges\ gimp org>",
- "(c) Seth Burgess 2004",
- "2004/14/04",
- N_"<Image>/Filters/Enhance/Selective Sharpen...",
- "RGB*", [
- [ PF_SPINNER, "sharpen_radius", "Radius of unsharp", 5.0, [0.1,120,0.1]],
- [ PF_SPINNER, "sharpen_amt", "Amount to unsharp", 1.0, [0.0,4.0,0.1]],
- [ PF_SPINNER, "threshold", "What delta to decide to sharp on", 20, [0,255,1]],
- ],
- \&my_code;
+};
exit main;
+__END__
-=head1 LICENSE
-Copyright 2004, Seth Burgess.
-This filter may be distributed under the same terms as Gimp-Perl.
+=head1 NAME
+
+selective_sharpen - Sharpen edges in controlled fashion
+
+=head1 SYNOPSIS
+
+<Image>/Filters/Enhance/Selective Sharpen...
+
+=head1 DESCRIPTION
Taken from an IRC log:
-02:00 <@ tigert> selective sharpening
-02:00 <@ tigert> UnNamed: 1) take the original photo, duplicate the
- layer
-02:01 <@ tigert> UnNamed: 2) convert the copy to grayscale
-02:01 <@ tigert> 3) run edge detect to the gray layer
-02:01 <@ tigert> 4) blur it slightly
-02:01 <@ tigert> 5) boost contrast (I can give you a specific curve or
- such)
-02:01 < sjburges> tigert: on 3, what edge detect?
-02:01 <@ tigert> sjburges: default works
-02:01 <@ tigert> sjburges: size: 3 or 2 (default)
-02:02 <@ tigert> sjburges: then make the boosted, gray edge-detection
- into a selection mask
-02:02 <@ tigert> sjburges: then use unsharp mask to that selection
- (scratch the gray layer)
-02:03 <@ tigert> sjburges: sjburges now, one could do two versions
-02:03 <@ tigert> sjburges: so one version could just be "Select edges"
-02:04 <@ tigert> sjburges: another could ask for unsharp mask
- parameters as well and sharpen
-02:04 <@ tigert> sjburges: the idea for the script is to sharpen it
- without sharpening the noise on flat areas
-02:04 < sjburges> tigert: could you fire me an email, and I can try to
- get to it tonight/tomorrow? It sounds simple enough.
- I need to head to a party for work shortly here
-02:04 <@ tigert> sjburges: ok
-
-=cut
+ 02:00 <@ tigert> selective sharpening
+ 02:00 <@ tigert> UnNamed: 1) take the original photo, duplicate the
+ layer
+ 02:01 <@ tigert> UnNamed: 2) convert the copy to grayscale
+ 02:01 <@ tigert> 3) run edge detect to the gray layer
+ 02:01 <@ tigert> 4) blur it slightly
+ 02:01 <@ tigert> 5) boost contrast (I can give you a specific curve or
+ such)
+ 02:01 < sjburges> tigert: on 3, what edge detect?
+ 02:01 <@ tigert> sjburges: default works
+ 02:01 <@ tigert> sjburges: size: 3 or 2 (default)
+ 02:02 <@ tigert> sjburges: then make the boosted, gray edge-detection
+ into a selection mask
+ 02:02 <@ tigert> sjburges: then use unsharp mask to that selection
+ (scratch the gray layer)
+ 02:03 <@ tigert> sjburges: sjburges now, one could do two versions
+ 02:03 <@ tigert> sjburges: so one version could just be "Select edges"
+ 02:04 <@ tigert> sjburges: another could ask for unsharp mask
+ parameters as well and sharpen
+ 02:04 <@ tigert> sjburges: the idea for the script is to sharpen it
+ without sharpening the noise on flat areas
+ 02:04 < sjburges> tigert: could you fire me an email, and I can try to
+ get to it tonight/tomorrow? It sounds simple enough.
+ I need to head to a party for work shortly here
+ 02:04 <@ tigert> sjburges: ok
+
+=head1 PARAMETERS
+
+ [ PF_SPINNER, "sharpen_radius", "Radius of unsharp", 5.0, [0.1,120,0.1]],
+ [ PF_SPINNER, "sharpen_amt", "Amount to unsharp", 1.0, [0.0,4.0,0.1]],
+ [ PF_SPINNER, "threshold", "What delta to decide to sharp on", 20, [0,255,1]],
+
+=head1 IMAGE TYPES
+
+RGB*
+
+=head1 AUTHOR
+
+Seth Burgess <sjburges gimp org>
+
+=head1 DATE
+
+2004/14/04
+
+=head1 LICENSE
+
+Copyright 2004, Seth Burgess.
+
+This filter may be distributed under the same terms as Gimp-Perl.
diff --git a/examples/xachshadow b/examples/xachshadow
index 5841f48..0aed93b 100755
--- a/examples/xachshadow
+++ b/examples/xachshadow
@@ -13,7 +13,7 @@
# a grid into it at pixelize size
#[Xach] that's a bit roundabout, but it's also in the xcf
#
-# Because the way xach does it is a bit ackward, I'm switching it around a bit
+# Because the way xach does it is a bit awkward, I'm switching it around a bit
# and working from the bottom up..
# Revision 1.1: Marc Lehman <pcg goof com> added undo capability
@@ -23,7 +23,7 @@
# Revision 1.4: Seth Burgess <sjburges gimp org> removed deprecated stuff
#
-use Gimp qw(:auto __ N_);
+use Gimp;
use Gimp::Fu;
register "xach_shadows",
@@ -38,50 +38,47 @@ register "xach_shadows",
[PF_SLIDER, "block_size", "The size of the blocks...", 10, [4, 255, 1]],
],
sub {
- my($img,$drawable,$blocksize) = _;
-
- eval { $img->undo_group_start };
+ my($img,$drawable,$blocksize) = _;
+ die "Must have layer selected\n" unless $drawable->is_layer;
+ $drawable->become('Gimp::Layer');
+ $img->undo_group_start;
Gimp::Context->push();
- # $selection_flag = 0;
- if (!$drawable->has_alpha) {
- $drawable->Gimp::Layer::add_alpha; # not drawable method
- };
+# $selection_flag = 0;
+ $drawable->add_alpha unless $drawable->has_alpha;
Gimp::Context->set_foreground('white');
Gimp::Context->set_background('black');
# This only can be applied to an entire image right now..
# $selection = $img->selection_save;
$img->selection_all;
# Now the fun begins :)
- $drawable->plug_in_pixelize($blocksize);
+ $drawable->pixelize($blocksize);
$shadowlayer = $drawable->layer_copy(0);
$img->insert_layer($shadowlayer,0,0);
$checkmask = $shadowlayer->create_mask(ADD_WHITE_MASK);
$shadowlayer->add_mask($checkmask);
- plug_in_checkerboard ($img, $checkmask, 0, $blocksize);
+ $img->checkerboard($checkmask, 0, $blocksize);
$frontlayer = $shadowlayer->layer_copy(0);
$img->insert_layer($frontlayer,0,0);
Gimp::Context->set_background([0,0,0]);
$shadowlayer->fill(BACKGROUND_FILL);
- $checkmask->plug_in_gauss_iir(0.3*$blocksize, 1, 1);
+ $checkmask->gauss_iir(0.3*$blocksize, 1, 1);
$checkmask->offset (1, 0, 0.2*$blocksize, 0.2*$blocksize);
-
$gridlayer = $img->layer_new($img->width, $img->height, RGBA_IMAGE, "Grid 1", 100, 0);
$img->insert_layer($gridlayer,0,0);
$img->selection_all;
- gimp_edit_clear($gridlayer);
+ $gridlayer->edit_clear;
Gimp::Context->set_background([255,255,255]);
- gimp_edit_fill($gridlayer, BACKGROUND_FILL);
- $gridlayer->plug_in_grid((1, $blocksize, 0, [0,0,0], 255) x 3);
+ $gridlayer->edit_fill(BACKGROUND_FILL);
+ $gridlayer->grid((1, $blocksize, 0, [0,0,0], 255) x 3);
- gimp_layer_set_mode($gridlayer, 3);
+ $gridlayer->set_mode(3);
# Clean up stuff
- Gimp::Context->pop();
+ Gimp::Context->pop;
$img->selection_none;
- eval { $img->undo_group_end };
- gimp_displays_flush();
- return();
+ $img->undo_group_end;
+ return;
};
exit main;
@@ -90,5 +87,3 @@ exit main;
Copyright Seth Burgess.
Distributed under the same terms as Gimp-Perl.
-
-=cut
diff --git a/t/netplugin.t b/t/netplugin.t
index 44aeab6..e6a75c7 100644
--- a/t/netplugin.t
+++ b/t/netplugin.t
@@ -29,7 +29,7 @@ our @testbench;
our %proc2file;
require 't/examples-api.pl';
-my %plug2yes = map { ($_=>1) } qw(dots ); # glowing_steel map_to_gradient
+my %plug2yes = map { ($_=>1) } qw(dots glowing_steel ); # map_to_gradient redeye
@testbench = grep { $plug2yes{$_->[0]} } @testbench;
my @duptest = @{$testbench[0]};
$duptest[3] = [ @{$duptest[3]} ]; # don't change original
[
Date Prev][
Date Next] [
Thread Prev][
Thread Next]
[
Thread Index]
[
Date Index]
[
Author Index]
