Python Plug-In in Gimp 3

Wiederkehrende Aufgaben können in ein Plug-In zusammengefasst werden und stehen dann über das Menu abrufbar bereit. Alle Funktionen von Gimp 3 und sogar die Plug-Ins können mit Python aufgerufen werden. Hier geht es zunächst um den grundlegenden Rahmen eines Plug-Ins.

Gimp.Plugin - Basisklasse für Plugins

Die Basisklasse für ein Plugin ist Gimp.Plugin. Von dieser Klasse muss eine eigene Klasse für das Plugin abgeleitet sein und eine paar Methoden implementieren.

import gi
gi.require_version('Gimp', '3.0')
from gi.repository import Gimp

class MeinPlugin(Gimp.PlugIn):
    def do_query_procedures(self):
        return [ 'name fuer den procedure browser' ]
    def do_create_procedure(self, name):
        procedure = Gimp.ImageProcedure.new(...)
        ...
        return procedure   # dazu gleich mehr

Gimp.main(MeinPlugin.__gtype__, sys.argv)

Plugin-Name

Der Name des Plugin wird mit der Methode do_query_procedure() bei der Initialisierung an Gimp übergeben und kann dann im Procedure Browser gesucht werden. Hier erhält der Anwender eine Übersicht der Parameter für einen Aufruf.

Plugin anmelden/initialisieren

Die Initialisierung und Anmeldung des Plugin bei Gimp erfolgt in der Methode do_create_procedure().

Internationalisation (i18n)

Mit der Methode set_i18n() kann die automatische Lokalisierung einer Benutzeroberfläche gesteuert werden:

def do_set_i18n (self, name):
    return False

Das Beispiel schaltet die Lokalisierung ab.

Gimp.ImageProcedure - Initialisierung im Detail

Ein Objekt der Klasse Gimp.ImageProcedure muss bei der Initialisierung erstellt und von der Funktion do_create_procedure() zurückgeliefert werden. Es stellt das auszuführende Programm des Plugin dar. Hier werden verschiedene Parameter für die Darstellung in Gimp gesetzt und die tatsächliche Funktion des Plugin registriert.

procedure = Gimp.ImageProcedure.new(self, name,
                                    Gimp.PDBProcType.PLUGIN,
                                    name_meiner_plugin_funktion, None)

In diesem Beispiel soll die Funktion name_meiner_plugin_funktion beim Aufruf des Plugin ausgeführt werden.

RunMode

Ein Plugin kann auf verschiedene Arten aufgerufen werden. Die vermutlich häufigsten sind:

• Start durch den User (Gimp.RunMode.INTERACTIVE)
• Aufruf von einem anderen Plugin (Gimp.RunMode.NONINTERACTIVE)

Der Procedure Browser zeigt für Plugins noch weitere Möglichkeiten an.

Eingabefelder für einen Dialog definieren

In dem Plugin kann ein Dialog zur Dateneingabe dargestellt werden. Die darzustellenden Elemente müssen in do_create_procedure() definiert werden.

Für eine Liste der GUI-Elemente siehe Online Resourcen: PyGObject API Reference

Ein paar Beispiele für Eingabefelder: Zahlen, Zeichenketten:

procedure.add_int_argument ( 'month', 'Monat', None,
                            1, 12, MONTH, GObject.ParamFlags.READWRITE )
procedure.add_string_argument ( 'oholiday', 'Nicht einheitliche Feiertage', None, OTHERHOLIDAY,
                            GObject.ParamFlags.READWRITE )

Diese Elemente können einfach in der Methode do_create_procedure() vor der Rückgabe des procedure-Objekts eingefügt werden.

Neben diesen einfachen Eingabefeldern sind auch komplexe GUI-Elemente für zum Beispiel eine Farb-/Zeichensatzauswahl oder Auswahllisten vorhanden:

add_color_argument()
add_font_argument()
add_choice_argument()

Einen Dialog anzeigen

Die Anzeige eines Dialogs erfolgt in der Plugin-Funktion (im folgenden Beispiel plugin_run() genannt) mit der Erzeugung eines Objekts der Klasse GimpUI.ProcedureDialog.

Der Aufbau eines Dialogs kann detailiert gesteuert werden. In dem Beispiel werden alle in do_create_procedure() erzeugten Elemente mit dem Aufruf dialog.fill( [] ) angezeigt. Dies sorgt für eine Darstellung in der Reihenfolge der Erstellung.

gi.require_version('GimpUi', '3.0')
from gi.repository import GimpUi

def plugin_run(procedure, run_mode, image, drawables, config, data):
  if run_mode == Gimp.RunMode.INTERACTIVE:
    GimpUi.init('executable_name')  # Der Programm-/Dateiname
    # nicht der Procedure-Name
    dialog = GimpUi.ProcedureDialog.new(procedure, config, 'Titel-Text')
    dialog.fill( [] )   # Alle in 'create procedure' erzeugten Items anzeigen
    if not dialog.run():
      dialog.destroy()
      return procedure.new_return_values(Gimp.PDBStatusType.CANCEL, None)
    else:
      dialog.destroy()

  month      = config.get_property('month')

Als Name beim Aufuf von GimpUI.init() wird der Dateiname des Programms empfohlen. Dieser muss nicht mit dem Namen für den Procedure Browser identisch sein.

Der Dialog wird mit dialog.run() dargestellt. Wenn die Ausführung erfolgreich war können die zuvor definierten GUI-Elemente ausgelesen werden: config.get_property()

Mit oder ohne Bild

Das aktive Bild wird dem Plugin beim Aufruf übergeben. Damit weiss das Programm dann wo es seine Arbeit verrichten kann. Ohne Bild machen viele Aktionen keinen Sinn, der Menu-Eintrag sollte ausgeblendet, ein Aufruf nicht möglich sein.

Für ein Programm, das sein Bild selbst erstellt oder andere Funktionen ausführt kann ein Aufruf auch ohne Bild ermöglicht werden:

procedure.set_sensitivity_mask( Gimp.ProcedureSensitivityMask.ALWAYS )

Wenn das Plugin auf ein Bild angewiesen ist kann der Menueintrag ausgeblendet werden:

procedure.set_sensitivity_mask (Gimp.ProcedureSensitivityMask.DRAWABLE |
                                Gimp.ProcedureSensitivityMask.NO_DRAWABLES)

Der Menu-Eintrag für ein Plugin

Die Platzierung im Menu kann mit den Funktionen set_menu_label() und add_menu_path() gesteuert werden.

...
  def do_create_procedure(self, name: str) -> Gimp.ImageProcedure:
    procedure = Gimp.ImageProcedure.new(self, name,
                                        Gimp.PDBProcType.PLUGIN,
                                        plugin_run, None)
    procedure.set_sensitivity_mask( Gimp.ProcedureSensitivityMask.ALWAYS )
    procedure.set_menu_label('Mein Plugin...')  # der Menueintrag
    procedure.set_attribution('Autor', 'Infotext Procedure Browser', 'Jahr')
    procedure.set_image_types('*')
    procedure.add_menu_path ('<Image>File/Create')   # der Menupfad
    ..

Ein Plugin kann durchaus in der obersten Menuzeile von Gimp landen. Dies kann durch einen nicht vorhandenen Pfad erreicht werden.

Gimp 3, Python-Plugin und der BOM

Ein Python-Plugin kann ohne Probleme auf allen Plattformen von Gimp verwendet werden. Mit dem Editor SubEthaEdit auf dem Mac wollte Gimp das Script nach Änderungen nicht mehr laden.

Die Lösung: Der Editor schreibt ein BOM (binary object marker) an den Anfang der UTF-8 codierten Datei. Damit wird ein Plugin auf Linux und macOS nicht mehr von Gimp geladen.

Die Linux-Editoren geany und bluefish schreiben kein BOM bei UTF-8-Dateien.

In vim kann das BOM mit :set bomb ein- und mit :set nobomb ausgeschaltet werden.

Debugging

Leider kann ein Plugin über die unterschiedlichsten Problem stolpern. Und egal wie hoch das Debug-Level in Gimp geschraubt wird - Ein Plugin stirbt ohne Meldung!

Edit > Preferences > Debugging > Debug policy

Zum Einkreisen von Fehlern sollte die Error console in Gimp aktiviert werden:

Windows > Dockable Dialogs > Error console

Ausgaben der Funktion Gimp.message() landen hier. Notfalls muss vor jedem Aufruf einer Funktion die Parameterliste hier ausgegeben werden.

Online Resourcen

Ein einfaches Beispiel für ein Plugin ist auf der Gimp Website zu finden:

Plugin Tutorial Python

Eine API-Referenz findet sich hier:

PyGObject API Reference

Hier sind z. B. die Klassen Gimp und Gegl mit allen Methoden und Parametern gelistet. Auch die verschiedenen Konstanten, z. B. Gimp.ImageBaseType, Gimp.Unit oder Gimp.TextJustification. Diese werden häufig in Aufrufen benötigt.

zum Seitenanfang

Letzte Aktualisierung: 2025-07