[gimp-perl] Load enums from GIMP, not hardcoding. Bug 502556
- From: Kevin Cozens <kcozens src gnome org>
- To: commits-list gnome org
- Cc:
- Subject: [gimp-perl] Load enums from GIMP, not hardcoding. Bug 502556
- Date: Wed, 26 Mar 2014 19:50:32 +0000 (UTC)
commit 8a661d4b7a0d0d816e75cdbf5cd7aa968513c67b
Author: Ed J <m8r-35s8eo mailinator com>
Date: Wed Mar 26 04:41:11 2014 +0000
Load enums from GIMP, not hardcoding. Bug 502556
Gimp.pm | 235 ++++++++++--------------------------------------------
Gimp.xs | 99 ++++++++++++++---------
Gimp/Constant.pm | 40 +++++++++
Gimp/Lib.pm | 7 +-
Gimp/Lib.xs | 65 +++++++++++----
Net/Net.pm | 19 +++--
Perl-Server | 1 +
t/import.t | 15 ++--
t/load.t | 81 ++++++++++++++-----
t/perlplugin.t | 27 +++----
t/run.t | 18 ++--
11 files changed, 296 insertions(+), 311 deletions(-)
---
diff --git a/Gimp.pm b/Gimp.pm
index 0adaa56..86bb056 100644
--- a/Gimp.pm
+++ b/Gimp.pm
@@ -18,166 +18,9 @@ BEGIN {
require DynaLoader;
@ISA = qw(DynaLoader);
bootstrap Gimp $VERSION;
- }
+ };
}
-my @_param = qw(
- PDB_BOUNDARY PDB_CHANNEL PDB_COLOR PDB_DISPLAY PDB_DRAWABLE
- PDB_END PDB_FLOAT PDB_IMAGE PDB_INT32 PDB_FLOATARRAY
- PDB_INT16 PDB_PARASITE PDB_STRING PDB_PATH PDB_INT16ARRAY
- PDB_INT8 PDB_INT8ARRAY PDB_LAYER PDB_REGION PDB_STRINGARRAY
- PDB_SELECTION PDB_STATUS PDB_INT32ARRAY
-);
-
-# constants that, in some earlier version, were autoloaded
-my @_consts = (@_param,
-#ENUM_NAME#
-'NEGATIVE_CONVOL', 'ABSOLUTE_CONVOL', 'NORMAL_CONVOL', 'DODGE',
-'BURN', 'PDB_SUCCESS', 'PDB_CANCEL', 'PDB_CALLING_ERROR',
-'PDB_PASS_THROUGH', 'PDB_EXECUTION_ERROR', 'SHARPEN_CONVOLVE', 'BLUR_CONVOLVE',
-'PAINT_INCREMENTAL', 'PAINT_CONSTANT', 'ORIENTATION_HORIZONTAL','ORIENTATION_UNKNOWN',
-'ORIENTATION_VERTICAL', 'OFFSET_TRANSPARENT', 'OFFSET_BACKGROUND', 'GRADIENT_SPIRAL_CLOCKWISE',
-'GRADIENT_CONICAL_ASYMMETRIC', 'GRADIENT_SPIRAL_ANTICLOCKWISE', 'GRADIENT_SHAPEBURST_DIMPLED',
'GRADIENT_CONICAL_SYMMETRIC',
-'GRADIENT_BILINEAR', 'GRADIENT_LINEAR', 'GRADIENT_RADIAL',
'GRADIENT_SHAPEBURST_ANGULAR',
-'GRADIENT_SHAPEBURST_SPHERICAL', 'GRADIENT_SQUARE', 'PDB_COLOR', 'PDB_END',
-'PDB_LAYER', 'PDB_INT8ARRAY', 'PDB_PATH', 'PDB_INT16',
-'PDB_FLOAT', 'PDB_DISPLAY', 'PDB_STRING', 'PDB_INT16ARRAY',
-'PDB_IMAGE', 'PDB_INT32', 'PDB_SELECTION', 'PDB_STATUS',
-'PDB_STRINGARRAY', 'PDB_CHANNEL', 'PDB_FLOATARRAY', 'PDB_INT32ARRAY',
-'PDB_DRAWABLE', 'PDB_BOUNDARY', 'PDB_REGION', 'PDB_PARASITE',
-'PDB_INT8', 'HISTOGRAM_BLUE', 'HISTOGRAM_VALUE', 'HISTOGRAM_GREEN',
-'HISTOGRAM_ALPHA', 'HISTOGRAM_RED', 'SHADOWS', 'HIGHLIGHTS',
-'MIDTONES', 'POINTS', 'PIXELS', 'STACK_TRACE_ALWAYS',
-'STACK_TRACE_NEVER', 'STACK_TRACE_QUERY', 'GRAIN_EXTRACT_MODE', 'COLOR_ERASE_MODE',
-'COLOR_MODE', 'LIGHTEN_ONLY_MODE', 'DIFFERENCE_MODE', 'DODGE_MODE',
-'BEHIND_MODE', 'ADDITION_MODE', 'MULTIPLY_MODE', 'GRAIN_MERGE_MODE',
-'SOFTLIGHT_MODE', 'HUE_MODE', 'SCREEN_MODE', 'BURN_MODE',
-'NORMAL_MODE', 'OVERLAY_MODE', 'HARDLIGHT_MODE', 'DARKEN_ONLY_MODE',
-'SUBTRACT_MODE', 'SATURATION_MODE', 'DISSOLVE_MODE', 'VALUE_MODE',
-'DIVIDE_MODE', 'IMAGE_CLONE', 'PATTERN_CLONE', 'UNIT_PIXEL',
-'UNIT_PICA', 'UNIT_END', 'UNIT_POINT', 'UNIT_MM',
-'UNIT_INCH', 'RGB_IMAGE', 'INDEXEDA_IMAGE', 'INDEXED_IMAGE',
-'GRAYA_IMAGE', 'RGBA_IMAGE', 'GRAY_IMAGE', 'MESSAGE_BOX',
-'ERROR_CONSOLE', 'CONSOLE', 'BRUSH_SOFT', 'BRUSH_HARD',
-'PLUGIN', 'TEMPORARY', 'EXTENSION', 'INTERNAL',
-'INDEXED', 'GRAY', 'RGB', 'CYAN_HUES',
-'ALL_HUES', 'BLUE_HUES', 'MAGENTA_HUES', 'GREEN_HUES',
-'YELLOW_HUES', 'RED_HUES', 'WEB_PALETTE', 'REUSE_PALETTE',
-'MONO_PALETTE', 'CUSTOM_PALETTE', 'MAKE_PALETTE', 'FSLOWBLEED_DITHER',
-'NO_DITHER', 'FIXED_DITHER', 'FS_DITHER', 'PATTERN_BUCKET_FILL',
-'FG_BUCKET_FILL', 'BG_BUCKET_FILL', 'INDEXED_CHANNEL', 'BLUE_CHANNEL',
-'ALPHA_CHANNEL', 'GRAY_CHANNEL', 'RED_CHANNEL', 'GREEN_CHANNEL',
-'RUN_NONINTERACTIVE', 'RUN_WITH_LAST_VALS', 'RUN_INTERACTIVE', 'REPEAT_NONE',
-'REPEAT_TRIANGULAR', 'REPEAT_SAWTOOTH', 'MASK_DISCARD', 'MASK_APPLY',
-'ADD_WHITE_MASK', 'ADD_SELECTION_MASK', 'ADD_ALPHA_TRANSFER_MASK', 'ADD_BLACK_MASK',
'ADD_ALPHA_MASK',
-'ADD_COPY_MASK', 'TRANSPARENT_FILL', 'BACKGROUND_FILL', 'FOREGROUND_FILL',
-'WHITE_FILL', 'PATTERN_FILL', 'CHANNEL_OP_SUBTRACT', 'CHANNEL_OP_REPLACE',
-'CHANNEL_OP_INTERSECT', 'CHANNEL_OP_ADD', 'FLATTEN_IMAGE', 'EXPAND_AS_NECESSARY',
-'CLIP_TO_BOTTOM_LAYER', 'CLIP_TO_IMAGE', 'CUSTOM_MODE', 'FG_TRANSPARENT_MODE',
-'FG_BG_HSV_MODE', 'FG_BG_RGB_MODE',
-#ENUM_NAME#
- 'PDB_CALLING_ERROR', 'PDB_EXECUTION_ERROR', 'PDB_PASS_THROUGH',
- 'PDB_SUCCESS', 'PARASITE_PERSISTENT', 'PARASITE_ATTACH_PARENT',
- 'PARASITE_PARENT_PERSISTENT', 'PARASITE_ATTACH_GRANDPARENT', 'PARASITE_GRANDPARENT_PERSISTENT',
- 'PARASITE_UNDOABLE', 'PARASITE_PARENT_UNDOABLE', 'PARASITE_GRANDPARENT_UNDOABLE',
- 'TRACE_NONE', 'TRACE_CALL', 'TRACE_TYPE', 'TRACE_NAME', 'TRACE_DESC', 'TRACE_ALL',
- 'COMPRESSION_NONE', 'COMPRESSION_LZW', 'COMPRESSION_PACKBITS',
- 'WRAP', 'SMEAR', 'BLACK',
-
- 'EXPORT_CAN_HANDLE_RGB', 'EXPORT_CAN_HANDLE_GRAY', 'EXPORT_CAN_HANDLE_INDEXED',
- 'EXPORT_CAN_HANDLE_BITMAP', 'EXPORT_CAN_HANDLE_ALPHA', 'EXPORT_CAN_HANDLE_LAYERS',
- 'EXPORT_CAN_HANDLE_LAYERS_AS_ANIMATION', 'EXPORT_CAN_HANDLE_LAYER_MASKS', 'EXPORT_NEEDS_ALPHA',
- 'EXPORT_CANCEL', 'EXPORT_IGNORE', 'EXPORT_EXPORT',
- 'ROTATE_90', 'ROTATE_270', 'ROTATE_180',
- 'TRUE', 'FALSE'
-);
-
-#ENUM_DEFS#
-sub NEGATIVE_CONVOL (){ 2} sub ABSOLUTE_CONVOL (){ 1} sub NORMAL_CONVOL (){ 0}
-sub DODGE (){ 0} sub BURN (){ 1} sub PDB_SUCCESS (){ 3}
-sub PDB_CANCEL (){ 4} sub PDB_CALLING_ERROR (){ 1} sub PDB_PASS_THROUGH (){ 2}
-sub PDB_EXECUTION_ERROR (){ 0} sub SHARPEN_CONVOLVE (){ 1} sub BLUR_CONVOLVE (){ 0}
-sub PAINT_INCREMENTAL (){ 1} sub PAINT_CONSTANT (){ 0}
-sub ORIENTATION_HORIZONTAL(){ 0} sub ORIENTATION_UNKNOWN (){ 2} sub ORIENTATION_VERTICAL (){ 1}
-sub OFFSET_TRANSPARENT (){ 1} sub OFFSET_BACKGROUND (){ 0} sub GRADIENT_SPIRAL_CLOCKWISE (){ 9}
-sub GRADIENT_CONICAL_ASYMMETRIC (){ 5} sub GRADIENT_SPIRAL_ANTICLOCKWISE (){10} sub
GRADIENT_SHAPEBURST_DIMPLED (){ 8}
-sub GRADIENT_CONICAL_SYMMETRIC (){ 4} sub GRADIENT_BILINEAR (){ 1} sub GRADIENT_LINEAR
(){ 0}
-sub GRADIENT_RADIAL (){ 2} sub GRADIENT_SHAPEBURST_ANGULAR (){ 6} sub
GRADIENT_SHAPEBURST_SPHERICAL (){ 7}
-sub SQUARE (){ 3} sub PDB_COLOR (){10} sub PDB_END (){22}
-sub PDB_LAYER (){14} sub PDB_INT8ARRAY (){ 7} sub PDB_PATH (){19}
-sub PDB_INT16 (){ 1} sub PDB_FLOAT (){ 3} sub PDB_DISPLAY (){12}
-sub PDB_STRING (){ 4} sub PDB_INT16ARRAY (){ 6} sub PDB_IMAGE (){13}
-sub PDB_INT32 (){ 0} sub PDB_SELECTION (){17} sub PDB_STATUS (){21}
-sub PDB_STRINGARRAY (){ 9} sub PDB_CHANNEL (){15} sub PDB_FLOATARRAY (){ 8}
-sub PDB_INT32ARRAY (){ 5} sub PDB_DRAWABLE (){16} sub PDB_BOUNDARY (){18}
-sub PDB_REGION (){11} sub PDB_PARASITE (){20} sub PDB_INT8 (){ 2}
-sub HISTOGRAM_BLUE (){ 3} sub HISTOGRAM_VALUE (){ 0} sub HISTOGRAM_GREEN (){ 2}
-sub HISTOGRAM_ALPHA (){ 4} sub HISTOGRAM_RED (){ 1} sub SHADOWS (){ 0}
-sub HIGHLIGHTS (){ 2} sub MIDTONES (){ 1} sub POINTS (){ 1}
-sub PIXELS (){ 0} sub STACK_TRACE_ALWAYS (){ 2} sub STACK_TRACE_NEVER (){ 0}
-sub STACK_TRACE_QUERY (){ 1} sub GRAIN_EXTRACT_MODE (){20} sub COLOR_ERASE_MODE (){22}
-sub COLOR_MODE (){13} sub LIGHTEN_ONLY_MODE (){10} sub DIFFERENCE_MODE (){ 6}
-sub DODGE_MODE (){16} sub BEHIND_MODE (){ 2} sub ADDITION_MODE (){ 7}
-sub MULTIPLY_MODE (){ 3} sub GRAIN_MERGE_MODE (){21} sub SOFTLIGHT_MODE (){19}
-sub HUE_MODE (){11} sub SCREEN_MODE (){ 4} sub BURN_MODE (){17}
-sub NORMAL_MODE (){ 0} sub OVERLAY_MODE (){ 5} sub HARDLIGHT_MODE (){18}
-sub DARKEN_ONLY_MODE (){ 9} sub SUBTRACT_MODE (){ 8} sub SATURATION_MODE (){12}
-sub DISSOLVE_MODE (){ 1} sub VALUE_MODE (){14} sub DIVIDE_MODE (){15}
-sub IMAGE_CLONE (){ 0} sub PATTERN_CLONE (){ 1} sub UNIT_PIXEL (){ 0}
-sub UNIT_PICA (){ 4} sub UNIT_END (){ 5} sub UNIT_POINT (){ 3}
-sub UNIT_MM (){ 2} sub UNIT_INCH (){ 1} sub RGB_IMAGE (){ 0}
-sub INDEXEDA_IMAGE (){ 5} sub INDEXED_IMAGE (){ 4} sub GRAYA_IMAGE (){ 3}
-sub RGBA_IMAGE (){ 1} sub GRAY_IMAGE (){ 2} sub MESSAGE_BOX (){ 0}
-sub ERROR_CONSOLE (){ 2} sub CONSOLE (){ 1} sub BRUSH_SOFT (){ 1}
-sub BRUSH_HARD (){ 0} sub PLUGIN (){ 1} sub TEMPORARY (){ 3}
-sub EXTENSION (){ 2} sub INTERNAL (){ 0} sub INDEXED (){ 2}
-sub GRAY (){ 1} sub RGB (){ 0} sub CYAN_HUES (){ 4}
-sub ALL_HUES (){ 0} sub BLUE_HUES (){ 5} sub MAGENTA_HUES (){ 6}
-sub GREEN_HUES (){ 3} sub YELLOW_HUES (){ 2} sub RED_HUES (){ 1}
-sub WEB_PALETTE (){ 2} sub REUSE_PALETTE (){ 1} sub MONO_PALETTE (){ 3}
-sub CUSTOM_PALETTE (){ 4} sub MAKE_PALETTE (){ 0} sub FSLOWBLEED_DITHER (){ 2}
-sub NO_DITHER (){ 0} sub FIXED_DITHER (){ 3} sub FS_DITHER (){ 1}
-sub PATTERN_BUCKET_FILL (){ 2} sub FG_BUCKET_FILL (){ 0} sub BG_BUCKET_FILL (){ 1}
-sub INDEXED_CHANNEL (){ 4} sub BLUE_CHANNEL (){ 2} sub ALPHA_CHANNEL (){ 5}
-sub GRAY_CHANNEL (){ 3} sub RED_CHANNEL (){ 0} sub GREEN_CHANNEL (){ 1}
-sub RUN_NONINTERACTIVE (){ 1} sub RUN_WITH_LAST_VALS (){ 2} sub RUN_INTERACTIVE (){ 0}
-sub REPEAT_NONE (){ 0} sub REPEAT_TRIANGULAR (){ 2} sub REPEAT_SAWTOOTH (){ 1}
-sub MASK_DISCARD (){ 1} sub MASK_APPLY (){ 0} sub ADD_WHITE_MASK (){ 0}
-sub ADD_ALPHA_TRANSFER_MASK (){3 }
-sub ADD_SELECTION_MASK (){ 4} sub ADD_BLACK_MASK (){ 1} sub ADD_ALPHA_MASK (){ 2}
-sub ADD_COPY_MASK (){ 5} sub TRANSPARENT_FILL (){ 3} sub BACKGROUND_FILL (){ 1}
-sub FOREGROUND_FILL (){ 0} sub WHITE_FILL (){ 2} sub NO_FILL (){ 4}
-sub CHANNEL_OP_SUBTRACT (){ 1} sub CHANNEL_OP_REPLACE (){ 2} sub CHANNEL_OP_INTERSECT (){ 3}
-sub CHANNEL_OP_ADD (){ 0} sub FLATTEN_IMAGE (){ 3} sub EXPAND_AS_NECESSARY (){ 0}
-sub CLIP_TO_BOTTOM_LAYER (){ 2} sub CLIP_TO_IMAGE (){ 1} sub CUSTOM_MODE (){ 3}
-sub FG_TRANSPARENT_MODE (){ 2} sub FG_BG_HSV_MODE (){ 1} sub FG_BG_RGB_MODE (){ 0}
-sub ROTATE_90 (){ 0} sub ROTATE_270 (){ 2} sub ROTATE_180 (){ 1}
-#ENUM_DEFS#
-
-sub WRAP (){ 0 }
-sub SMEAR (){ 1 }
-sub BLACK (){ 2 }
-
-# defined in Gimp.xs for some reason
-#sub EXPORT_CAN_HANDLE_RGB (){1}
-#sub EXPORT_CAN_HANDLE_GRAY (){2}
-#sub EXPORT_CAN_HANDLE_INDEXED (){4}
-#sub EXPORT_CAN_HANDLE_BITMAP (){8}
-#sub EXPORT_CAN_HANDLE_ALPHA (){16}
-#sub EXPORT_CAN_HANDLE_LAYERS (){32}
-#sub EXPORT_CAN_HANDLE_LAYERS_AS_ANIMATION (){64}
-#sub EXPORT_CAN_HANDLE_LAYER_MASKS (){128}
-#sub EXPORT_NEEDS_ALPHA (){256}
-
-# file_tiff_*
-sub COMPRESSION_NONE (){ 0 }
-sub COMPRESSION_LZW (){ 1 }
-sub COMPRESSION_PACKBITS (){ 2 }
-
-# True/False for PDB
-sub TRUE (){ 1 }
-sub FALSE (){ 0 }
-
use Gimp::ColorDB;
use Carp qw(croak);
@@ -185,19 +28,32 @@ my @_procs = ('main', '__', 'N_');
#my @_default = (@_procs, ':consts' ,':_auto2');
my @_default = (@_procs, ':consts');
my @POLLUTE_CLASSES;
+my $net_init;
# we really abuse the import facility..
sub import($;@) {
my $pkg = shift;
- warn "$pkg->import(@_)" if $verbose;
+ warn "$$-$pkg->import(@_)" if $verbose;
my $up = caller;
my @export;
+ # make sure we can call GIMP functions - start net conn if required
+ map { $net_init = $1 if /net_init=(\S+)/; } @_;
+ if ($interface_type eq "net") {
+ map { *{"Gimp::$_"} = \&{"Gimp::Constant::$_"} }
+ qw(RUN_INTERACTIVE RUN_NONINTERACTIVE);
+ Gimp::Net::gimp_init(grep {defined} $net_init);
+ }
+ warn "$$-Loading constants" if $verbose;
+ # now get constants from GIMP
+ require Gimp::Constant;
+ import Gimp::Constant;
+
@_= _default unless @_;
-
+
for(map { $_ eq ":DEFAULT" ? @_default : $_ } @_) {
if ($_ eq ":auto") {
- push(@export,@_consts,@_procs);
+ push @export,@Gimp::Constant::EXPORT,@_procs;
*{"$up\::AUTOLOAD"} = sub {
croak "Cannot call '$AUTOLOAD' at this time" unless initialized();
my ($class,$name) = $AUTOLOAD =~ /^(.*)::(.*?)$/;
@@ -206,7 +62,7 @@ sub import($;@) {
goto &$AUTOLOAD;
};
} elsif ($_ eq ":_auto2") {
- push(@export,@_consts,@_procs);
+ push @export,@Gimp::Constant::EXPORT,@_procs;
*{"$up\::AUTOLOAD"} = sub {
warn __"$function: calling $AUTOLOAD without specifying the :auto import tag is deprecated!\n";
croak __"Cannot call '$AUTOLOAD' at this time" unless initialized();
@@ -221,13 +77,15 @@ sub import($;@) {
push @{"$class\::PREFIXES"}, @{"Gimp::$class\::PREFIXES"};
}
} elsif ($_ eq ":consts") {
- push(@export,@_consts);
+ push @export,@Gimp::Constant::EXPORT;
} elsif ($_ eq ":param") {
- push(@export,@_param);
+ push @export,@Gimp::Constant::PARAMS;
} elsif (/^interface=(\S+)$/) {
croak __"interface=... tag is no longer supported\n";
- } elsif ($_=~/spawn_options=(\S+)/) {
+ } elsif (/spawn_options=(\S+)/) {
$spawn_opts = $1;
+ } elsif (/net_init=(\S+)/) {
+ # already used above, no-op
} elsif ($_ ne "") {
push(@export,$_);
} elsif ($_ eq "") {
@@ -460,16 +318,17 @@ if ($interface_type=~/^lib$/i) {
} else {
croak __"interface '$interface_type' unsupported.";
}
+warn "$$-Using interface '$interface_type'" if $Gimp::verbose;
eval "require $interface_pkg" or croak $@;
$interface_pkg->import;
+warn "$$-Finished loading '$interface_pkg'" if $Gimp::verbose;
# create some common aliases
for(qw(gimp_procedural_db_proc_exists gimp_call_procedure set_trace initialized)) {
*$_ = \&{"$interface_pkg\::$_"};
}
-*init = \&{"$interface_pkg\::gimp_init"};
*end = \&{"$interface_pkg\::gimp_end"};
*lock = \&{"$interface_pkg\::lock"};
*unlock= \&{"$interface_pkg\::unlock"};
@@ -486,7 +345,7 @@ sub ignore_functions(@) {
sub AUTOLOAD {
my ($class,$name) = $AUTOLOAD =~ /^(.*)::(.*?)$/;
- warn "AUTOLOAD $AUTOLOAD(@_)" if $Gimp::verbose;
+ warn "$$-AUTOLOAD $AUTOLOAD(@_)" if $Gimp::verbose;
for(@{"$class\::PREFIXES"}) {
my $sub = $_.$name;
if (exists $ignore_function{$sub}) {
@@ -512,10 +371,11 @@ sub AUTOLOAD {
goto &$AUTOLOAD;
} elsif (gimp_procedural_db_proc_exists($sub)) {
*{$AUTOLOAD} = sub {
- warn "gimp_call_procedure(@_)" if $Gimp::verbose;
+ warn "$$-gimp_call_procedure{0}(@_)" if $Gimp::verbose;
shift unless ref $_[0];
unshift @_, $sub;
#goto &gimp_call_procedure; # does not work, PERLBUG! #FIXME
+ warn "$$-gimp_call_procedure{1}(@_)" if $Gimp::verbose;
my @r = eval { gimp_call_procedure (@_) };
die $@ if $@; wantarray ? @r : $r[0];
};
@@ -766,8 +626,8 @@ special handling. Currently they do not work when used over C<Gimp::Net>.
=head1 OUTLINE OF A GIMP PLUG-IN
-All plug-ins (with the exception of those using C<Gimp::init>) I<must>
-contain a call to C<Gimp::main>.
+All plug-ins (running in "plugin mode") I<must> finish with a call to
+C<Gimp::main>.
The return code should be immediately handed out to exit:
@@ -843,7 +703,7 @@ using OO-Syntax:
Gimp->gimp_palette_set_foreground([20,5,7]);
Gimp->palette_set_background("cornsilk");
- Palette->set_foreground('#1230f0');
+ Gimp::Palette->set_foreground('#1230f0');
As you can see, you can also drop part of the name prefixes with this
syntax, so its actually shorter to write and hopefully clearer to read.
@@ -880,20 +740,12 @@ which is too late for registering types.
This function has not been well tested.
-=item Gimp::init([connection-argument]), Gimp::end()
-
-These is an alternative interface that replaces the call to Gimp::main
-and the net callback. At the moment it only works for the Net interface
-(L<Gimp::Net>), and not as a native plug-in. Here's an example:
-
- use Gimp;
-
- Gimp::init;
- <do something with GIMP>
+=item use Gimp qw(net_init=...);
-The optional argument to init has the same format as the GIMP_HOST variable
-described in L<Gimp::Net>. Calling C<Gimp::end> is optional. This is used
-in the process of testing the module ('make test').
+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 PDB_INT32.
=item Gimp::lock(), Gimp::unlock()
@@ -910,8 +762,8 @@ interface.
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>, 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 rgb.txt)
=item Gimp::initialized()
@@ -1025,8 +877,8 @@ has a section:
SOME SYNTAX ALTERNATIVES
$image = Gimp->image_new (width,height,type)
- $image = new Image (width,height,type)
- $image = image_new Display (width,height,type)
+ $image = new Gimp::Image (width,height,type)
+ $image = image_new Gimp::Display (width,height,type)
=head1 DEBUGGING AIDS
@@ -1133,7 +985,7 @@ 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).
-=item DISPLAY, IMAGE, LAYER, CHANNEL, DRAWABLE, SELECTION, VECTORS
+=item DISPLAY, IMAGE, LAYER, CHANNEL, DRAWABLE, SELECTION, VECTORS, ITEM
these will be mapped to corresponding objects (IMAGE => Gimp::Image). In
trace output you will see small integers (the image/layer/etc..-ID)
@@ -1143,9 +995,10 @@ trace output you will see small integers (the image/layer/etc..-ID)
represented as an array ref [name, flags, data], where name and data
should be perl strings and flags is the numerical flag value.
-=item REGION, BOUNDARY, PATH, STATUS
+=item STATUS
-Not yet supported.
+Not yet supported, except implicitly - this is how exceptions (from
+"die") get returned in "net mode".
=back
diff --git a/Gimp.xs b/Gimp.xs
index 7fe87c0..8bbdf1d 100644
--- a/Gimp.xs
+++ b/Gimp.xs
@@ -45,7 +45,6 @@ _exit()
#endif
abort();
-
BOOT:
#ifdef ENABLE_NLS
setlocale (LC_MESSAGES, ""); /* calling twice doesn't hurt, no? */
@@ -83,43 +82,6 @@ xs_exit(status)
CODE:
exit (status);
-BOOT:
-{
- HV *stash = gv_stashpvn ("Gimp", 4, TRUE);
-
- newCONSTSUB (stash, "PARASITE_PERSISTENT", newSViv (GIMP_PARASITE_PERSISTENT));
- newCONSTSUB (stash, "PARASITE_UNDOABLE", newSViv (GIMP_PARASITE_UNDOABLE));
-
- newCONSTSUB (stash, "PARASITE_ATTACH_PARENT", newSViv (GIMP_PARASITE_ATTACH_PARENT));
- newCONSTSUB (stash, "PARASITE_PARENT_PERSISTENT", newSViv (GIMP_PARASITE_PARENT_PERSISTENT));
- newCONSTSUB (stash, "PARASITE_PARENT_UNDOABLE", newSViv (GIMP_PARASITE_PARENT_UNDOABLE));
-
- newCONSTSUB (stash, "PARASITE_ATTACH_GRANDPARENT", newSViv (GIMP_PARASITE_ATTACH_GRANDPARENT));
- newCONSTSUB (stash, "PARASITE_GRANDPARENT_PERSISTENT", newSViv (GIMP_PARASITE_GRANDPARENT_PERSISTENT));
- newCONSTSUB (stash, "PARASITE_GRANDPARENT_UNDOABLE", newSViv (GIMP_PARASITE_GRANDPARENT_UNDOABLE));
-
- newCONSTSUB (stash, "TRACE_NONE", newSViv (TRACE_NONE));
- newCONSTSUB (stash, "TRACE_CALL", newSViv (TRACE_CALL));
- newCONSTSUB (stash, "TRACE_TYPE", newSViv (TRACE_TYPE));
- newCONSTSUB (stash, "TRACE_NAME", newSViv (TRACE_NAME));
- newCONSTSUB (stash, "TRACE_DESC", newSViv (TRACE_DESC));
- newCONSTSUB (stash, "TRACE_ALL" , newSViv (TRACE_ALL ));
-
- newCONSTSUB (stash, "EXPORT_CAN_HANDLE_RGB", newSViv (GIMP_EXPORT_CAN_HANDLE_RGB));
- newCONSTSUB (stash, "EXPORT_CAN_HANDLE_GRAY", newSViv (GIMP_EXPORT_CAN_HANDLE_GRAY));
- newCONSTSUB (stash, "EXPORT_CAN_HANDLE_INDEXED", newSViv (GIMP_EXPORT_CAN_HANDLE_INDEXED));
- newCONSTSUB (stash, "EXPORT_CAN_HANDLE_ALPHA", newSViv (GIMP_EXPORT_CAN_HANDLE_ALPHA ));
- newCONSTSUB (stash, "EXPORT_CAN_HANDLE_BITMAP", newSViv (GIMP_EXPORT_CAN_HANDLE_BITMAP));
- newCONSTSUB (stash, "EXPORT_CAN_HANDLE_LAYERS", newSViv (GIMP_EXPORT_CAN_HANDLE_LAYERS));
- newCONSTSUB (stash, "EXPORT_CAN_HANDLE_LAYERS_AS_ANIMATION", newSViv
(GIMP_EXPORT_CAN_HANDLE_LAYERS_AS_ANIMATION));
- newCONSTSUB (stash, "EXPORT_CAN_HANDLE_LAYER_MASKS", newSViv (GIMP_EXPORT_CAN_HANDLE_LAYER_MASKS));
- newCONSTSUB (stash, "EXPORT_NEEDS_ALPHA", newSViv (GIMP_EXPORT_NEEDS_ALPHA));
-
- newCONSTSUB (stash, "EXPORT_CANCEL", newSViv (GIMP_EXPORT_CANCEL));
- newCONSTSUB (stash, "EXPORT_IGNORE", newSViv (GIMP_EXPORT_CANCEL));
- newCONSTSUB (stash, "EXPORT_EXPORT", newSViv (GIMP_EXPORT_EXPORT));
-}
-
MODULE = Gimp PACKAGE = Gimp::RAW
# some raw byte/bit-manipulation (e.g. for avi and miff), use PDL instead
@@ -257,4 +219,65 @@ convert_bgr_rgb_inplace (datasv)
OUTPUT:
datasv
+# when move back to separate .xs, change MODULE
+MODULE = Gimp PACKAGE = Gimp::Constant
+
+PROTOTYPES: ENABLE
+#define ADD_GIMP_CONST(name, value) { \
+ newCONSTSUB(stash, name, newSViv (value)); \
+ av_push(inxs, newSVpv(name, 0)); \
+}
+
+BOOT:
+{
+ HV *stash = gv_stashpvn ("Gimp::Constant", strlen("Gimp::Constant"), TRUE);
+ AV *inxs = get_av("Gimp::Constant::INXS", GV_ADD);
+
+ ADD_GIMP_CONST("RUN_INTERACTIVE", GIMP_RUN_INTERACTIVE);
+ ADD_GIMP_CONST("RUN_NONINTERACTIVE", GIMP_RUN_NONINTERACTIVE);
+ ADD_GIMP_CONST("RUN_WITH_LAST_VALS", GIMP_RUN_WITH_LAST_VALS);
+
+ ADD_GIMP_CONST("PARASITE_PERSISTENT", GIMP_PARASITE_PERSISTENT);
+ ADD_GIMP_CONST("PARASITE_UNDOABLE", GIMP_PARASITE_UNDOABLE);
+
+ ADD_GIMP_CONST("PARASITE_ATTACH_PARENT", GIMP_PARASITE_ATTACH_PARENT);
+ ADD_GIMP_CONST("PARASITE_PARENT_PERSISTENT", GIMP_PARASITE_PARENT_PERSISTENT);
+ ADD_GIMP_CONST("PARASITE_PARENT_UNDOABLE", GIMP_PARASITE_PARENT_UNDOABLE);
+
+ ADD_GIMP_CONST("PARASITE_ATTACH_GRANDPARENT", GIMP_PARASITE_ATTACH_GRANDPARENT);
+ ADD_GIMP_CONST("PARASITE_GRANDPARENT_PERSISTENT", GIMP_PARASITE_GRANDPARENT_PERSISTENT);
+ ADD_GIMP_CONST("PARASITE_GRANDPARENT_UNDOABLE", GIMP_PARASITE_GRANDPARENT_UNDOABLE);
+
+ ADD_GIMP_CONST("TRACE_NONE", TRACE_NONE);
+ ADD_GIMP_CONST("TRACE_CALL", TRACE_CALL);
+ ADD_GIMP_CONST("TRACE_TYPE", TRACE_TYPE);
+ ADD_GIMP_CONST("TRACE_NAME", TRACE_NAME);
+ ADD_GIMP_CONST("TRACE_DESC", TRACE_DESC);
+ ADD_GIMP_CONST("TRACE_ALL" , TRACE_ALL );
+
+ ADD_GIMP_CONST("EXPORT_CAN_HANDLE_RGB", GIMP_EXPORT_CAN_HANDLE_RGB);
+ ADD_GIMP_CONST("EXPORT_CAN_HANDLE_GRAY", GIMP_EXPORT_CAN_HANDLE_GRAY);
+ ADD_GIMP_CONST("EXPORT_CAN_HANDLE_INDEXED", GIMP_EXPORT_CAN_HANDLE_INDEXED);
+ ADD_GIMP_CONST("EXPORT_CAN_HANDLE_ALPHA", GIMP_EXPORT_CAN_HANDLE_ALPHA );
+ ADD_GIMP_CONST("EXPORT_CAN_HANDLE_BITMAP", GIMP_EXPORT_CAN_HANDLE_BITMAP);
+ ADD_GIMP_CONST("EXPORT_CAN_HANDLE_LAYERS", GIMP_EXPORT_CAN_HANDLE_LAYERS);
+ ADD_GIMP_CONST("EXPORT_CAN_HANDLE_LAYERS_AS_ANIMATION", GIMP_EXPORT_CAN_HANDLE_LAYERS_AS_ANIMATION);
+ ADD_GIMP_CONST("EXPORT_CAN_HANDLE_LAYER_MASKS", GIMP_EXPORT_CAN_HANDLE_LAYER_MASKS);
+ ADD_GIMP_CONST("EXPORT_NEEDS_ALPHA", GIMP_EXPORT_NEEDS_ALPHA);
+
+ ADD_GIMP_CONST("EXPORT_CANCEL", GIMP_EXPORT_CANCEL);
+ ADD_GIMP_CONST("EXPORT_IGNORE", GIMP_EXPORT_CANCEL);
+ ADD_GIMP_CONST("EXPORT_EXPORT", GIMP_EXPORT_EXPORT);
+
+ ADD_GIMP_CONST("TRUE", TRUE);
+ ADD_GIMP_CONST("FALSE", FALSE);
+
+ ADD_GIMP_CONST("UNIT_PIXEL", GIMP_UNIT_PIXEL);
+ ADD_GIMP_CONST("UNIT_INCH", GIMP_UNIT_INCH);
+ ADD_GIMP_CONST("UNIT_MM", GIMP_UNIT_MM);
+ ADD_GIMP_CONST("UNIT_POINT", GIMP_UNIT_POINT);
+ ADD_GIMP_CONST("UNIT_PICA", GIMP_UNIT_PICA);
+ ADD_GIMP_CONST("UNIT_END", GIMP_UNIT_END);
+ ADD_GIMP_CONST("UNIT_PERCENT", GIMP_UNIT_PERCENT);
+}
diff --git a/Gimp/Constant.pm b/Gimp/Constant.pm
new file mode 100644
index 0000000..5ecd9da
--- /dev/null
+++ b/Gimp/Constant.pm
@@ -0,0 +1,40 @@
+package Gimp::Constant;
+
+use Exporter 'import';
+
+BEGIN {
+ $VERSION = 2.3001;
+# XS code in Gimp.xs... for now
+# eval {
+# require XSLoader;
+# XSLoader::load Gimp::Constant $VERSION;
+# } or do {
+# require DynaLoader;
+# @ISA = qw(DynaLoader);
+# bootstrap Gimp::Constant $VERSION;
+# }
+}
+
+use vars qw(@EXPORT @PARAMS @INXS);
+
+my %sub2value;
+
+for my $class (Gimp->enums_get_type_names) {
+ if ($class eq 'GimpRunMode') {
+ # done in XS - special case as need in Gimp::Net
+ next;
+ }
+ my %gname2value = Gimp->enums_list_type($class);
+ map {
+ my $gname = $_;
+ s#^GIMP_##;
+ $sub2value{$_} = $gname2value{$gname};
+ push @PARAMS, $_ if $class eq GimpPDBArgType;
+ } keys %gname2value;
+}
+
+ EXPORT = (@INXS, keys %sub2value);
+
+map { my $sub = $_; *{$sub} = sub { $sub2value{$sub} }; } keys %sub2value;
+
+1;
diff --git a/Gimp/Lib.pm b/Gimp/Lib.pm
index e4bcc27..265b6f5 100644
--- a/Gimp/Lib.pm
+++ b/Gimp/Lib.pm
@@ -7,6 +7,7 @@ BEGIN {
$VERSION = 2.3001;
require XSLoader;
XSLoader::load Gimp::Lib $VERSION;
+ warn "$$-Loading ".__PACKAGE__ if $Gimp::verbose;
}
use subs qw(
@@ -79,6 +80,8 @@ sub gimp_drawable_bounds {
(@b[0,1],$b[2]-$b[0],$b[3]-$b[1]);
}
+warn "$$-Finished loading ".__PACKAGE__ if $Gimp::verbose;
+
1;
__END__
@@ -92,8 +95,8 @@ Gimp::Lib - Interface to libgimp (as opposed to Gimp::Net)
=head1 DESCRIPTION
-This is the package that interfaces to The Gimp via the libgimp interface,
-i.e. the normal interface to use with the Gimp. You don't normally use this
+This is the package that interfaces to GIMP via the libgimp interface,
+i.e. the normal interface to use with GIMP. You don't normally use this
module directly, look at the documentation for the package "Gimp".
=head1 AUTHOR
diff --git a/Gimp/Lib.xs b/Gimp/Lib.xs
index a5dcf3e..f2e897f 100644
--- a/Gimp/Lib.xs
+++ b/Gimp/Lib.xs
@@ -1340,26 +1340,20 @@ gimp_main(...)
char *argv [10];
int argc = 0;
- if (items == 0)
- {
- AV *av = perl_get_av ("ARGV", FALSE);
-
- argv [argc++] = SvPV_nolen (perl_get_sv ("0", FALSE));
- if (av && av_len (av) < 10-1)
- {
- while (argc-1 <= av_len (av))
- argv [argc] = SvPV_nolen (*av_fetch (av, argc-1, 0)),
- argc++;
- }
- else
- croak ("internal error (please report): too many arguments to main");
- }
- else
+ if (items != 0)
croak (__("arguments to main not yet supported!"));
+ AV *av = perl_get_av ("ARGV", FALSE);
+
+ argv [argc++] = SvPV_nolen (perl_get_sv ("0", FALSE));
+ if (!(av && av_len (av) < 10-1))
+ croak ("internal error (please report): too many arguments to main");
+ while (argc-1 <= av_len (av))
+ argv [argc] = SvPV_nolen (*av_fetch (av, argc-1, 0)),
+ argc++;
- gimp_is_initialized = 1;
+ gimp_is_initialized = 1;
RETVAL = gimp_main (&PLUG_IN_INFO, argc, argv);
- gimp_is_initialized = 0;
+ gimp_is_initialized = 0;
/*exit (0);*/ /*D*//* shit, some memory problem here, so just exit */
}
OUTPUT:
@@ -1395,6 +1389,40 @@ gimp_micro_version()
OUTPUT:
RETVAL
+void
+gimp_enums_get_type_names()
+INIT:
+ gimp_enums_init ();
+ gint n_type_names;
+ const gchar **etn;
+ int i;
+PPCODE:
+ etn = gimp_enums_get_type_names (&n_type_names);
+ if (!etn) XSRETURN_EMPTY;
+ EXTEND(SP, n_type_names);
+ for (i = 0; i < n_type_names; i++) {
+ PUSHs(sv_2mortal(newSVpv(etn[i], 0)));
+ }
+
+# return list of pair => value, ...
+void
+gimp_enums_list_type(name)
+ const char *name
+INIT:
+ GType enum_type;
+ GEnumClass *enum_class;
+ GEnumValue *value;
+ HV *ret_hash;
+PPCODE:
+ if (!(enum_type = g_type_from_name (name)))
+ croak (__("gimp_enums_list_type(%s) invalid name"), name);
+ if (!(enum_class = g_type_class_peek (enum_type)))
+ croak (__("gimp_enums_list_type(%s) invalid class"), name);
+ for (value = enum_class->values; value->value_name; value++) {
+ XPUSHs(sv_2mortal(newSVpv(value->value_name,0)));
+ XPUSHs(sv_2mortal(newSViv(value->value)));
+ }
+
# checks whether a gimp procedure exists
int
gimp_procedural_db_proc_exists(char *proc_name)
@@ -2245,6 +2273,9 @@ gimp_pixel_rgn_data(...)
#endif
BOOT:
+#if (GLIB_MAJOR_VERSION < 2 || (GLIB_MAJOR_VERSION == 2 && GLIB_MINOR_VERSION < 36))
+ g_type_init();
+#endif
trace_file = PerlIO_stderr ();
g_log_set_handler(
"LibGimp",
diff --git a/Net/Net.pm b/Net/Net.pm
index 4cc6906..1641971 100644
--- a/Net/Net.pm
+++ b/Net/Net.pm
@@ -25,7 +25,7 @@ package Gimp::Net;
# Aelem1\0elem2...
# Rclass\0scalar-value
-BEGIN { warn "Loading ".__PACKAGE__ if $Gimp::verbose; }
+BEGIN { warn "$$-Loading ".__PACKAGE__ if $Gimp::verbose; }
use strict 'vars';
use vars qw($VERSION $trace_res);
@@ -81,7 +81,7 @@ sub command {
sub import {
my $pkg = shift;
- warn "$pkg->import(@_)" if $Gimp::verbose;
+ warn "$$-$pkg->import(@_)" if $Gimp::verbose;
return if @_;
# overwrite some destroy functions
*Gimp::Tile::DESTROY=
@@ -93,7 +93,7 @@ sub import {
}
sub gimp_call_procedure {
- warn "Net::gimp_call_procedure[$trace_level](@_)" if $Gimp::verbose;
+ warn "$$-Net::gimp_call_procedure[$trace_level](@_)" if $Gimp::verbose;
my $func = shift;
unshift @_, $trace_level if $trace_level;
my @response = command($trace_level ? "TRCE" : "EXEC", $func, @_);
@@ -143,7 +143,7 @@ my @gimp_gui_functions = qw(
sub start_server {
my $opt = shift;
$opt = $Gimp::spawn_opts unless $opt;
- print __"start_server \"$opt\"" if $Gimp::verbose;
+ warn __"$$-start_server($opt)" if $Gimp::verbose;
croak __"unable to create socketpair for gimp communications: $!"
unless ($server_fh, my $gimp_fh) =
IO::Socket->socketpair(AF_UNIX, SOCK_STREAM, PF_UNSPEC);
@@ -161,15 +161,16 @@ sub start_server {
unless ($Gimp::verbose) {
open STDIN,"</dev/null";
open STDOUT,">/dev/null";
- open STDERR,">&1";
+ #open STDERR,">&1";
}
my @args;
- my $flags = PS_FLAG_BATCH | ($Gimp::verbose ? PS_FLAG_QUIET : 0);
+ my $flags = PS_FLAG_BATCH | ($Gimp::verbose ? 0 : PS_FLAG_QUIET);
my $args = join ' ',
&Gimp::RUN_NONINTERACTIVE,
$flags,
fileno($gimp_fh),
int($Gimp::verbose);
+ warn __"$$-extension-perl-server args='$args'" if $Gimp::verbose;
push(@args,"--no-data") if $opt=~s/(^|:)no-?data//;
push(@args,"-i") unless $opt=~s/(^|:)gui//;
push(@args,"--verbose") if $Gimp::verbose;
@@ -217,7 +218,7 @@ sub try_connect {
sub gimp_init {
$Gimp::in_top=1;
- warn "gimp_init(@_)" if $Gimp::verbose;
+ warn "$$-gimp_init(@_)" if $Gimp::verbose;
if (@_) {
$server_fh = try_connect ($_[0]);
} elsif (defined($Gimp::host)) {
@@ -251,10 +252,11 @@ sub gimp_init {
$initialized = 1;
Gimp::_initialized_callback;
+ warn "$$-Finished gimp_init(@_)" if $Gimp::verbose;
}
sub gimp_end {
- warn "gimp_end - gimp_pid=$gimp_pid" if $Gimp::verbose;
+ warn "$$-gimp_end - gimp_pid=$gimp_pid" if $Gimp::verbose;
$initialized = 0;
#close $server_fh if $server_fh;
undef $server_fh;
@@ -262,7 +264,6 @@ sub gimp_end {
}
sub gimp_main {
- gimp_init;
no strict 'refs';
$Gimp::in_top=0;
eval { Gimp::callback("-net") };
diff --git a/Perl-Server b/Perl-Server
index a5587bb..6d159a4 100755
--- a/Perl-Server
+++ b/Perl-Server
@@ -1,6 +1,7 @@
#!/usr/bin/perl
use strict;
+#BEGIN { $Gimp::verbose = 1; }
use Gimp qw(__ N_);
use Gimp::Net ();
diff --git a/t/import.t b/t/import.t
index f01f1bd..33d9126 100644
--- a/t/import.t
+++ b/t/import.t
@@ -1,15 +1,14 @@
use strict;
use Test::More;
-#BEGIN { $Gimp::verbose = 1; }
-use Gimp qw(:auto);
+our ($dir, $DEBUG);
+BEGIN {
+# $Gimp::verbose = 1;
+ $DEBUG = 0;
+ require 't/gimpsetup.pl';
+}
+use Gimp qw(:auto), "net_init=spawn/";
#Gimp::set_trace(TRACE_ALL);
-our $dir;
-our $DEBUG = 0;
-require 't/gimpsetup.pl';
-
-Gimp::init("spawn/");
-
eval { Image->new(10,10,RGB); };
ok($@, 'polluting version should fail');
diff --git a/t/load.t b/t/load.t
index 30d58f7..8aaa571 100644
--- a/t/load.t
+++ b/t/load.t
@@ -1,31 +1,68 @@
use strict;
use Test::More;
-#BEGIN { $Gimp::verbose = 1; }
-BEGIN { use_ok('Gimp', qw(:auto canonicalise_color)); }
-require 't/gimpsetup.pl';
+our ($dir, $DEBUG);
+BEGIN {
+# $Gimp::verbose = 1;
+ $DEBUG = 0;
+ require 't/gimpsetup.pl';
+}
+BEGIN { use_ok('Gimp', qw(:auto canonicalise_color net_init=spawn/)); }
#Gimp::set_trace(TRACE_ALL);
-Gimp::init("spawn/");
my %CONST_DATA = (
- PDB_FLOAT => 3,
- PDB_PATH => 19,
- ABSOLUTE_CONVOL => 1,
- PDB_PASS_THROUGH => 2,
- GRADIENT_SPIRAL_ANTICLOCKWISE => 10,
- HISTOGRAM_BLUE => 3,
- STACK_TRACE_QUERY => 1,
- DISSOLVE_MODE => 1,
- UNIT_POINT => 3,
- MAGENTA_HUES => 6,
- RUN_INTERACTIVE => 0,
- CLIP_TO_IMAGE => 1,
- COMPRESSION_LZW => 1,
- TRACE_ALL => 255,
- ROTATE_90 => 0,
- TRUE => 1,
- BLACK => 2,
- EXPORT_CAN_HANDLE_GRAY => 2,
+ 'ADD_COPY_MASK' => 5,
+ 'FG_TRANSPARENT_MODE' => 2,
+ 'BRUSH_SOFT' => 1,
+ 'BRUSH_GENERATED_SQUARE' => 1,
+ 'PATTERN_BUCKET_FILL' => 2,
+ 'CHANNEL_OP_REPLACE' => 2,
+ 'GRAY_CHANNEL' => 3,
+ 'PATTERN_CLONE' => 1,
+ 'FS_DITHER' => 1,
+ 'CUSTOM_PALETTE' => 4,
+ 'ABSOLUTE_CONVOL' => 1,
+ 'SHARPEN_CONVOLVE' => 1,
+ 'DESATURATE_LUMINOSITY' => 1,
+ 'DODGE' => 0,
+ 'TRANSPARENT_FILL' => 3,
+ 'FOREGROUND_EXTRACT_SIOX' => 0,
+ 'GRADIENT_SEGMENT_HSV_CCW' => 1,
+ 'GRADIENT_SEGMENT_SINE' => 2,
+ 'GRADIENT_SHAPEBURST_ANGULAR' => 6,
+ 'GRID_ON_OFF_DASH' => 2,
+ 'HISTOGRAM_BLUE' => 3,
+ 'MAGENTA_HUES' => 6,
+ 'ICON_TYPE_INLINE_PIXBUF' => 1,
+ 'RGB' => 0,
+ 'GRAY_IMAGE' => 2,
+ 'INK_BLOB_TYPE_CIRCLE' => 0,
+ 'INTERPOLATION_LINEAR' => 1,
+ 'GRAIN_EXTRACT_MODE' => 20,
+ 'MASK_DISCARD' => 1,
+ 'CLIP_TO_IMAGE' => 1,
+ 'ERROR_CONSOLE' => 2,
+ 'OFFSET_BACKGROUND' => 0,
+ 'ORIENTATION_VERTICAL' => 1,
+ 'PDB_ERROR_HANDLER_PLUGIN' => 1,
+ 'EXTENSION' => 2,
+ 'PDB_SUCCESS' => 3,
+ 'PAINT_CONSTANT' => 0,
+ 'PROGRESS_COMMAND_PULSE' => 4,
+ 'REPEAT_SAWTOOTH' => 1,
+ 'ROTATE_180' => 1,
+ 'RUN_WITH_LAST_VALS' => 2,
+ 'SELECT_CRITERION_S' => 5,
+ 'POINTS' => 1,
+ 'STACK_TRACE_NEVER' => 0,
+ 'TEXT_DIRECTION_RTL' => 1,
+ 'TEXT_HINT_STYLE_MEDIUM' => 2,
+ 'TEXT_JUSTIFY_FILL' => 3,
+ 'MIDTONES' => 1,
+ 'TRANSFORM_FORWARD' => 0,
+ 'TRANSFORM_RESIZE_CROP' => 2,
+ 'USER_DIRECTORY_PICTURES' => 4,
+ 'VECTORS_STROKE_TYPE_BEZIER' => 0,
);
{
diff --git a/t/perlplugin.t b/t/perlplugin.t
index a44a240..a6724c4 100644
--- a/t/perlplugin.t
+++ b/t/perlplugin.t
@@ -1,18 +1,14 @@
use strict;
use Test::More;
-#BEGIN { $Gimp::verbose = 1; }
-use Gimp qw(:auto);
-#Gimp::set_trace(TRACE_ALL);
-use Config;
-
-our $dir;
-our $myplugins;
-our $DEBUG = 0;
-require 't/gimpsetup.pl';
-
-my $plugin = "$myplugins/test_perl_filter";
-write_plugin($DEBUG, $plugin, $Config{startperl}.
- "\nBEGIN { \$Gimp::verbose = ".int($Gimp::verbose).'; }'.<<'EOF');
+our ($dir, $DEBUG, $myplugins);
+BEGIN {
+# $Gimp::verbose = 1;
+ $DEBUG = 0;
+ require 't/gimpsetup.pl';
+ use Config;
+ my $plugin = "$myplugins/test_perl_filter";
+ write_plugin($DEBUG, $plugin, $Config{startperl}.
+ "\nBEGIN { \$Gimp::verbose = ".int($Gimp::verbose).'; }'.<<'EOF');
use strict;
use Gimp qw(:auto __ N_);
@@ -111,8 +107,9 @@ sub boilerplate_params {
exit main;
EOF
-
-Gimp::init("spawn/");
+}
+use Gimp qw(:auto), "net_init=spawn/";
+#Gimp::set_trace(TRACE_ALL);
ok((my $i = Gimp::Image->new(10,10,RGB)), 'new image');
ok(
diff --git a/t/run.t b/t/run.t
index f979940..a8892a3 100644
--- a/t/run.t
+++ b/t/run.t
@@ -1,15 +1,15 @@
use strict;
-use Test::More tests => 15;
-#BEGIN { $Gimp::verbose = 1; }
-use Gimp qw(:auto);
+use Test::More;
+
+our ($dir, $DEBUG);
+BEGIN {
+# $Gimp::verbose = 1;
+ $DEBUG = 0;
+ require 't/gimpsetup.pl';
+}
+use Gimp qw(:auto), "net_init=spawn/";
#Gimp::set_trace(TRACE_ALL);
-our $dir;
-our $DEBUG = 0;
-require 't/gimpsetup.pl';
-
-Gimp::init("spawn/");
-
ok((my $i = new Gimp::Image(10,10,RGB)), 'OO Syntax for new image');
ok(
(my $l = $i->layer_new(10,10,RGBA_IMAGE,"new layer",100,VALUE_MODE)),
[
Date Prev][
Date Next] [
Thread Prev][
Thread Next]
[
Thread Index]
[
Date Index]
[
Author Index]
