Mein erstes PyGtk Plugin

[PeterPKHG]

So gelungen, jedenfalls kann man es benutzen
Im Prinzip könnte ich noch etwas Hilfe gebrauchen, um die Kinderkrankheiten zu entfernen ("unwichtige", alles funktioniert schliesslich ). Krankheiten , die nicht echt stören, sind diese:
1. "x left corner" sieht so aus x left corner und ich weiss noch nicht warum, die y left corne ist eigentlich identisch aber ist OK.
2. Wenn man die erste Kugel erzeugt OHNE flatten erscheint im Gimp-Fenster nur eine Auswahl, warum nicht gleich das Resultat??
Wenn man nun das Plugin beendet und auf das Fenster klickt erscheint das eigentliche Resultat WOHL??!!
3. Kommentare sind noch nicht überall und sinnvoll vorhanden.
4. ??? (habt ihr etwas entdeckt?)

So nun den code in einen Bestand kopieren, an eine passenden Stelle setzen (LInux, Mac-user nicht chmod executable vergessen! )
*/.gimp-2.8/plug-ins (z. B.) , wo und wie es anders kann ist u.a. hier im Forum zu finden ...

DER wichtigste Grund: 'Normale' (Python) Plug-ins sind 'nur' 1-dimensional und verschwinden nach ihrer einmaligen Benutzung (oder bin ich nicht vollständig informiert?)
Dieses Plugin benutzt PyGtk und ist so gemacht, dass man an den Parametern drehen kann, dann ausführen, so oft man will, bis dass man "Cancel" klickt . Und es ist so eingestellt, dass es immer ein "oberstes" Fenster bleibt, sprich sichtbar.
UND 2-dimensional!!!!

Wo erscheint es in Gimp? Klar unter PKHG und dann GlasPlugin ...

Und nun mal ausprobieren und euren Kommentar hierhin schreiben, bitte.

#!/usr/bin/env python
# -*- coding: utf-8 -*-
#PeterPKHG Version 0.1, mit noch kleinen (unwichtigen) Kinderkrankheiten
#import gimp
import gimpplugin

from gimpenums import *
#pdb = gimp.pdb
import gtk
import gimpui

import os
import sys
##########
from gimpfu import *
from math import pi

def easy_selection_copy(image, drawable):
    #gimp.context_push()
    #image.undo_group_start()
    #
    #pdb.gimp_message_get_handler(ERROR_CONSOLE)
    #
    """
    if not pdb.gimp_item_is_layer(drawable):
        pdb.gimp_message("The layer or layer group is not selected.")
        image.undo_group_end()
        gimp.context_pop()
        return
    if pdb.gimp_selection_is_empty(image):
        pdb.gimp_message("The selection is empty.")
        image.undo_group_end()
        gimp.context_pop()
        return
    """
    selection = pdb.gimp_selection_save(image) #selection is a channel!
    parent = pdb.gimp_item_get_parent(drawable)
    position = pdb.gimp_image_get_item_position(image, drawable)
    layer_new = pdb.gimp_layer_copy(drawable, TRUE)
    pdb.gimp_image_insert_layer(image, layer_new, parent, position)
    layer_new.name = "Layer via Copy"
    layer_new.add_alpha()
    pdb.gimp_image_select_item(image, CHANNEL_OP_REPLACE, selection)
    pdb.gimp_image_select_item(image, CHANNEL_OP_INTERSECT, layer_new)
    created_mask = layer_new.create_mask(ADD_SELECTION_MASK)
    layer_new.add_mask(created_mask)
    layer_new.remove_mask(MASK_APPLY)
    selection_bounds = pdb.gimp_selection_bounds(image)
    selection_width = selection_bounds[3] - selection_bounds[1]
    selection_height = selection_bounds[4] - selection_bounds[2]
    layer_offset_x, layer_offset_y = pdb.gimp_drawable_offsets(layer_new)
    layer_new.resize(
            selection_width,
            selection_height,
            layer_offset_x - selection_bounds[1],
            layer_offset_y - selection_bounds[2]
            )
    image.remove_channel(selection)
    pdb.gimp_selection_none(image)
    gimp.displays_flush()
    #image.undo_group_end()
    #gimp.context_pop()
    return layer_new #PKHG>noetig fuer namen geben an layer

""" Nur zum kapieren ...
def response(dialog, response):
    if response == gtk.RESPONSE_YES:
        debug('yes, yes!') #in place of print ==> msys konsole!
    elif response == gtk.RESPONSE_NO:
        debug( 'oh no!')
    else:
        debug( 'I am deeply confused')
    dialog.destroy()

    def yes_or_no(msg, title, responseCallback, parent=None):
    dialog = gtk.MessageDialog(
        parent         = parent,
        flags          = gtk.DIALOG_DESTROY_WITH_PARENT,
        type           = gtk.MESSAGE_INFO,
        buttons        = gtk.BUTTONS_YES_NO,
        message_format = msg)
    dialog.set_title(title)
    dialog.connect('response', responseCallback)
    dialog.show()
"""
   
    
def glaskugelstart(image, layer, x, y, circelsize, flatten):
    """
    Auf dem Weg zu einer verschiebbaren Lupe/Kugel
    an Hand von
    http://www.gimpforum.de/showthread.php?p=139128
    """
    gimp.message(str(circelsize) + " " + str(flatten))
    gimp.context_push()
    image.undo_group_start()
    #PKHG>hier via parameter image = gimp.image_list()[0]
    #easy_selection_copy(image, drawable)
    drawable = layer0 = image.layers[-1]
    layer0.name = "HG"
    has_alpha = pdb.gimp_drawable_has_alpha(drawable)
    if not has_alpha:
        pdb.gimp_layer_add_alpha(layer0)
    #pdb.gimp_image_select_ellipse(image, operation, x, y, width, height)
    #The selection operation { CHANNEL-OP-ADD (0), CHANNEL-OP-SUBTRACT (1), CHANNEL-OP-REPLACE (2), CHANNEL-OP-INTERSECT (3) }
    pdb.gimp_image_select_ellipse(image, 0, x, y, circelsize, circelsize)
    layer2 = easy_selection_copy(image, drawable)
    #PKHG>OK so far return
    #layer2 = layer.copy()
    #pdb.gimp_image_add_layer(image, layer2, 0)
    layer2.name = "Kugel HG"
    #https://docs.gimp.org/en/plug-in-whirl-pinch.html
    pdb.plug_in_whirl_pinch(image,layer2,0,-0.25,1)
    pdb.plug_in_applylens(image,layer2,2,1,1,0)
    layer3 = layer2.copy()
    pdb.gimp_image_add_layer(image, layer3, 0)
    layer2 = pdb.gimp_drawable_transform_rotate_default(layer2, pi, True, layer3.width/2, layer3.height/2, False, 0)
    pdb.gimp_layer_set_mode(layer3,5) # 5 is overlay
    layer = pdb.gimp_image_merge_down(image, layer3,0) #PKHG>test
    if flatten:
        layer = pdb.gimp_image_flatten(image)
    else:
        gimp.message("No flatten used, do it by hand?!")
    image.undo_group_end()
    gimp.context_pop()

def debug(val):
    gimp.message(str(val))

def debugErr(e):
    exc_type, exc_obj, exc_tb = sys.exc_info()
    fname = os.path.split(exc_tb.tb_frame.f_code.co_filename)[1]
    debug(fname+'\n'+str(exc_tb.tb_lineno)+'\n'+str(e))

class gGlasPKHG(object):
    global image
    titDel=("Delete")
    newG=("Add new")
    tabs=[]
    
    def __init__(self, runmode, img):
        self.kugel_size = 100
        self.x_upper_left_corner = 0
        self.y_upper_left_corner = 0
        self.flatten_picture = False
        self.img = img
        if runmode == RUN_INTERACTIVE:
            self.showDialog()
        elif runmode == RUN_WITH_LAST_VALS:
            self.showDialog()
        elif runmode == RUN_NONINTERACTIVE:
            return
        
    def checkBoxButtonUsed(self, widget, data = None):
        print "%s was toggled %s" % (data, ("OFF", "ON")[widget.get_active()])
        tmp = ("OFF", "ON")[widget.get_active()]
        #gimp.message(str(tmp))
        debug(tmp)
        if tmp == "ON":
            self.flatten_picture = True
        else:
            self.flatten_picture = False
    def tt(self,w, data=None):
        s=w.get_text()
        v=self.parseVal(s)
        w.set_value(v)
        
    def on_scrolled(self, widget, data=None):
        tmp = int(self.adj_hscrollbar.value)
        self.hscroll_label.set_text("circelsize: " + str(tmp))
        self.kugel_size = tmp
        tmp_x = int(self.adj_hxscr.value)
        self.x_upper_left_corner = tmp_x
        self.hsc_xlab.set_text("  x left corner: " + str(tmp_x))
        tmp_y = int(self.adj_hyscroll.value)
        self.y_upper_left_corner = tmp_y
        self.hsc_ylab.set_text("  y left corner: " + str(tmp_y))
        
    def callback(self, widget, data=None):
        global gimp
        print( "Hello again - %s was pressed" % data)
        result = False
        if data == "Glaskugel":
            tmplist = gimp.image_list()
            if tmplist:
                image = tmplist[-1]
                glaskugelstart(image, None, self.x_upper_left_corner, self.y_upper_left_corner, self.kugel_size, self.flatten_picture)
            else:
                gimp.message("Kein Bild geladen")
            return 1  #beeindigd het maken ...
 
    def showDialog(self):
        self.dialog = gimpui.Dialog("Guide lab", "rotdlg")
        """ Ja geht auch
        self.dialog = gtk.Dialog("My dialog",
                   None,
                   gtk.DIALOG_MODAL | gtk.DIALOG_DESTROY_WITH_PARENT,
                   (gtk.STOCK_CANCEL, gtk.RESPONSE_REJECT,
                    gtk.STOCK_OK, gtk.RESPONSE_ACCEPT)
            )
        """
        self.dialog.set_position(gtk.WIN_POS_CENTER)  #WIN_POS_CENTER ???!!! ..POS_MOUSE
        #  self.dialog.vbox.hbox1 = gtk.HBox(False, 1)
        #self.dialog.vbox.hbox1.show()
        #self.dialog.vbox.hbox1.pack_start(self.dialog.vbox.hbox1, True, True,1) 
        #def pack_start(child, expand=True, fill=True, padding=0)
        #self.dialog.vbox.pack_start(self.dialog.vbox.hbox1, True, True, 1)
        #self.dialog.vbox.hbox1.pack_start(self.table, True, True, 1)
                
        #PKHG>GEHT so nicht: mytest_button = self.dialog.add_button('yes_or_no("mijn mede","test",response)',"gtk.RESPONSE_YES")
        
        cancel_button = self.dialog.add_button(gtk.STOCK_CANCEL, gtk.RESPONSE_CANCEL)
        cancel_button.connect("clicked", self.kobtn)
        self.table = gtk.Table(5, 4, True)
        self.table.show()
        self.dialog.vbox.add(self.table)
        self.create = gtk.Button("    Glaskugel    ")
        self.create.connect("clicked", self.callback, "Glaskugel")
        self.create.show()
        self.table.attach(self.create, 0, 1, 0, 1)

        self.hsc_xlab = gtk.Label(" x left corner:   0")
        self.hsc_xlab.show()
        self.table.attach(self.hsc_xlab, 0, 1, 2, 3 )
        
        self.hscroll_label = gtk.Label("circelsize: 100")
        self.hscroll_label.show()
        self.table.attach(self.hscroll_label, 0, 1, 1, 2 )
        
        self.adj_hscrollbar = gtk.Adjustment(100,10,1000,10,50,1)
        self.adj_hscrollbar.connect("value_changed", self.on_scrolled)
        self.hscrollbar = gtk.HScrollbar(self.adj_hscrollbar)
        #self.hscrollbar.set_update_policy(gtk.UPDATE_CONTINUOUS)
        self.hscrollbar.show()
        self.table.attach(self.hscrollbar, 1, 2, 1, 2)

        
        self.hsc_xlab = gtk.Label("x left corner:  0 ")
        self.hsc_xlab.set_width_chars(25)
        self.hsc_xlab.set_justify(gtk.JUSTIFY_FILL)
        self.hsc_xlab.show()
        self.table.attach(self.hsc_xlab, 0, 1, 2, 3 )
        
        self.adj_hxscr = gtk.Adjustment(0,10,1000,10,50,1)
        self.adj_hxscr.connect("value_changed", self.on_scrolled)
        self.hscroll_x = gtk.HScrollbar(self.adj_hxscr)
        self.hscroll_x.show()
        self.table.attach(self.hscroll_x, 1, 2, 2, 3 )

        self.hsc_ylab = gtk.Label(" y left corner:   0 ")
        self.hsc_ylab.show()
        self.table.attach(self.hsc_ylab, 2, 3, 2, 3 )
        
        self.adj_hyscroll = gtk.Adjustment(0,10,1000,10,50,1)
        self.adj_hyscroll.connect("value_changed", self.on_scrolled)
        self.hscroll_y = gtk.HScrollbar(self.adj_hyscroll)
        self.hscroll_y.show()
        self.table.attach(self.hscroll_y, 3, 4, 2, 3 )

        self.flattenCheckBox = gtk.CheckButton("flatten Picture")
        self.flattenCheckBox.connect("toggled", self.checkBoxButtonUsed, "flatten Picture")
        self.flattenCheckBox.show()
        self.table.attach(self.flattenCheckBox, 0, 1, 3, 4)
        
        self.dialog.connect("expose-event",self.expose)
        self.dialog.show()
        self.dialog.set_keep_above(True) #PKHG>OK so was es sagt (bleibend oberstes Fenster)
        self.dialog.run()
    
    def expose(self,widget, otro):
        #debug('desde dialog expose-event')
        return
    
    def kobtn(self, widget):
        return

class glasPluginPKHG(gimpplugin.plugin):
    def start(self):
        gimp.main(self.init, self.quit, self.query, self._run)
    def init(self):
        pass
    def quit(self):
        pass
    def query(self):
        cright = "PeterPKHG"
        date = "August2016"
        plug_descr = ("PeterPKHG")
        plug_params = [(PDB_INT32, "run_mode", "Run mode"), (PDB_IMAGE, "image", "Input image"),]
        gimp.install_procedure("fuerGlasPKHG", plug_descr, plug_descr, "PeterPKHG", cright, date, "<Image>/PKHG/GlasPlugin ...", "RGB*, GRAY*", PLUGIN, plug_params,[])

    def fuerGlasPKHG(self, runmode, img):
        gGlasPKHG(runmode, img)

if __name__ == '__main__':
    glasPluginPKHG().start()