1
<!DOCTYPE HTML PUBLIC "-//Norman Walsh//DTD DocBook HTML 1.0//EN">
5
>The Structure Of A Plugin</TITLE
8
CONTENT="Modular DocBook HTML Stylesheet"><LINK
10
TITLE="Gimp Python Documentation"
11
HREF="pygimp.html"><LINK
13
TITLE="Gimp Python Documentation"
14
HREF="pygimp.html"><LINK
16
TITLE="The Procedural Database"
17
HREF="procedural-database.html"></HEAD
30
>Gimp Python Documentation</TH
51
HREF="procedural-database.html"
64
NAME="STRUCTURE-OF-PLUGIN"
65
>The Structure Of A Plugin</A
68
>The majority of code in this package resides in
72
>, but this provides a poor
73
interface for implementing some portions of a plugin. For this
74
reason, there is a python module called
78
> that sets out a structure for
79
plugins and implements some things that were either too dificult
80
or impossible to do in C.</P
82
>The main purpose of <TT
86
implement an object oriented structure for plug-ins. As well as
87
this, it handles tracebacks, which are otherwise ignored by
91
>, and gives a method to call
92
other Gimp-Python plug-ins without going through the procedural
100
>An Example Plugin</A
103
>As in a lot of manuals, the first thing you examine is an
104
example, so here is an example. I have included it before
105
explaining what it does to allow more advanced programmers to
106
see the structure up front. It is a translation of the clothify
107
Script-Fu extension:</P
112
>Example 1. A sample python plugin</B
121
CLASS="PROGRAMLISTING"
126
have_gimp11 = gimp.major_version > 1 or \
127
gimp.major_version == 1 and gimp.minor_version >= 1
129
def python_clothify(timg, tdrawable, bx=9, by=9,
130
azimuth=135, elevation=45, depth=3):
131
bx = 9 ; by = 9 ; azimuth = 135 ; elevation = 45 ; depth = 3
132
width = tdrawable.width
133
height = tdrawable.height
134
img = gimp.image(width, height, RGB)
135
layer_one = gimp.layer(img, "X Dots", width, height, RGB_IMAGE,
139
pdb.gimp_edit_fill(layer_one)
141
pdb.gimp_edit_fill(img, layer_one)
142
img.add_layer(layer_one, 0)
143
pdb.plug_in_noisify(img, layer_one, 0, 0.7, 0.7, 0.7, 0.7)
144
layer_two = layer_one.copy()
145
layer_two.mode = MULTIPLY_MODE
146
layer_two.name = "Y Dots"
147
img.add_layer(layer_two, 0)
148
pdb.plug_in_gauss_rle(img, layer_one, bx, 1, 0)
149
pdb.plug_in_gauss_rle(img, layer_two, by, 0, 1)
151
bump_layer = img.active_layer
152
pdb.plug_in_c_astretch(img, bump_layer)
153
pdb.plug_in_noisify(img, bump_layer, 0, 0.2, 0.2, 0.2, 0.2)
154
pdb.plug_in_bump_map(img, tdrawable, bump_layer, azimuth,
155
elevation, depth, 0, 0, 0, 0, TRUE, FALSE, 0)
159
"python_fu_clothify",
160
"Make the specified layer look like it is printed on cloth",
161
"Make the specified layer look like it is printed on cloth",
165
"<Image>/Python-Fu/Alchemy/Clothify",
168
(PF_INT, "x_blur", "X Blur", 9),
169
(PF_INT, "y_blur", "Y Blur", 9),
170
(PF_INT, "azimuth", "Azimuth", 135),
171
(PF_INT, "elevation", "elevation", 45),
172
(PF_INT, "depth", "Depth", 3)
188
NAME="IMPORTANT-MODULES"
192
>In this plugin, a number of modules are imported. The
193
important ones are:</P
202
>: this module provides a
203
simple interface for writing plugins, similar to what
204
script-fu provides. It provides the GUI for entering in
205
parameters in interactive mode and performs some sanity
206
checks when registering the plugin.</P
208
>By using "from gimpfu import *", this module also
209
provides an easy way to get all the commonly used symbols
210
into the plugin's namespace.</P
217
>: the main part of the gimp
218
extension. This is imported with gimpfu.</P
225
>: a number of useful
226
constants. This is also automatically imported with
231
>The pdb variable is a variable for accessing the
232
procedural database. It is imported into the plugin's namespace
233
with gimpfu for convenience.</P
240
NAME="PLUGIN-FRAMEWORK"
244
>With pygimp-0.4, the gimpfu module was introduced. It
245
simplifies writing plugins a lot. It handles the run mode
246
(interactive, non interactive or run with last values),
247
providing a GUI for interactive mode and saving the last used
250
>Using the gimpfu plugin, all you need to do is write the
251
function that should be run, make a call to
257
>, and finally a call to
263
> to get the plugin started.</P
265
>If the plugin is to be run on an image, the first
266
parameter to the plugin function should be the image, and the
267
second should be the current drawable (do not worry about the
268
run_mode parameter). Plugins that do not act on an existing
269
image (and hence go in the toolbox's menus) do not need these
270
parameters. Any other parameters are specific to the
273
>After defining the plugin function, you need to call
279
> to register the plugin with gimp
280
(When the plugin is run to query it, this information is passed
281
to gimp. When it is run interactively, this information is used
282
to construct the GUI). The parameters to
341
>Most of these parameters are quite self explanatory. The
342
menupath option should start with <Image%gt;/ for image
343
plugins and <Toolbox>/ for toolbox plugins. The remainder
344
of the menupath is a slash separated path to its menu item.</P
346
>The params parameter holds a list parameters for the
347
function. It is a list of tuples. Note that you do not have to
348
specify the run_type, image or drawable parameters, as gimpfu
349
will add these automatically for you. The tuple format is
350
(type, name, description, default [, extra]). The allowed type
480
>These values map onto the standard PARAM_* constants. The
481
reason to use the extra constants is that they give gimpfu more
482
information, so it can produce a better interface (for instance,
483
the PF_FONT type is equivalent to PARAM_STRING, but in the GUI
484
you get a small button that will bring up a font selection
487
>The PF_SLIDER, PF_SPINNER and PF_ADJUSTMENT types require
488
the extra parameter. It is of the form (min, max, step), and
489
gives the limits for the spin button or slider.</P
491
>The results parameter is a list of 3-tuples of the form
492
(type, name, description). It defines the return values for the
493
function. If there is only a single return value, the plugin
494
function should return just that value. If there is more than
495
one, the plugin function should return a tuple of results.</P
497
>The final parameter to <TT
503
the plugin function itself.</P
505
>After registering one or more plugin functions, you must
511
> function. This will cause
512
the plugin to start running. A GUI will be displayed when
513
needed, and your plugin function will be called at the
514
appropriate times.</P
548
HREF="procedural-database.html"
557
>Gimp Python Documentation</TD
567
>The Procedural Database</TD
b'\\ No newline at end of file'
added
removed
plug-ins/pygimp/doc/structure-of-plugin.html
