Already implemented listeners remains unchanged when restoring and saving again a project.

Author: dddomodossola

editor/editor.py

@@ -302,11 +302,26 @@ def load(self, ifile, configuration):
         members_list = app_init_fnc.__dict__.values()
         for m in members_list:
             if inspect.isfunction(m) and m.__name__ not in ['__init__', 'main', 'idle']:
-                setattr(self, m.__name__, self.fakeListenerFunc)
-        return app_init_fnc.construct_ui(self)
-
-    def fakeListenerFunc(*args):
-        pass
+                #setattr(self, m.__name__, self.fakeListenerFunc)
+                import types
+                setattr(self, m.__name__, types.MethodType( m, self ))
+        root_widget = app_init_fnc.construct_ui(self)
+        self.create_callback_copy(root_widget)
+        return root_widget
+
+    def create_callback_copy(self, widget):
+        if not hasattr( widget, 'children' ):
+            return #no nested code
+        #for all the methods of this widget
+        for (setOnEventListenerFuncname,setOnEventListenerFunc) in inspect.getmembers(widget):
+            #if the member is decorated by decorate_set_on_listener
+            if hasattr(setOnEventListenerFunc, '_event_info'):
+                #if there is a callback
+                if getattr(widget, setOnEventListenerFuncname).callback: 
+                    getattr(widget, setOnEventListenerFuncname).callback_copy = getattr(widget, setOnEventListenerFuncname).callback
+                    getattr(widget, setOnEventListenerFuncname).connect(None)
+        for w in widget.children.values():
+            self.create_callback_copy(w)
 
     def check_pending_listeners(self, widget, widgetVarName, force=False):
         code_nested_listener = ''
@@ -378,19 +393,18 @@ def repr_widget_for_editor(self, widget): #widgetVarName is the name with which
             #if the member is decorated by decorate_set_on_listener
             if hasattr(setOnEventListenerFunc, '_event_info'):
                 #if there is a callback
-                if getattr(widget, setOnEventListenerFuncname).callback: 
+                if hasattr(getattr(widget, setOnEventListenerFuncname), 'callback_copy'): 
                     listenerPrototype = setOnEventListenerFunc._event_info['prototype']
-                    listener = getattr(widget, setOnEventListenerFuncname).callback.__self__
-                    
-                    if getattr(widget, setOnEventListenerFuncname) == widget.onclick:
-                        if widget.backup_onclick_listener == None:
-                            continue
-                        listener = widget.backup_onclick_listener.__self__
+                    listener = getattr(widget, setOnEventListenerFuncname).callback_copy.__self__
 
                     listenerFunctionName = setOnEventListenerFunc._event_info['name'] + "_" + widget.attributes['editor_varname']
-                        
+                    
                     listenerClassFunction = prototypes.proto_code_function%{'funcname': listenerFunctionName,
                                                                                 'parameters': listenerPrototype}
+                    #override, if already implemented, we use this code
+                    if hasattr(listener, listenerFunctionName):
+                        listenerClassFunction = inspect.getsource(getattr(listener, listenerFunctionName))
+                                                                            
                     self.pending_listener_registration.append({'done':False,
                         'eventsource':widget, 
                         'eventlistener':listener,
@@ -638,7 +652,6 @@ def configure_widget_for_editing(self, widget):
 
         if not 'editor_varname' in widget.attributes:
             return
-        widget.backup_onclick_listener = widget.onclick.callback
         widget.onclick.connect(self.on_widget_selection)
 
         #setup of the on_dropped function of the widget in order to manage the dragNdrop 

editor/editor_widgets.py

@@ -138,27 +138,22 @@ def __init__(self, widget, listenersList, eventConnectionFuncName, eventConnecti
             ddi = gui.DropDownItem(w.attributes['editor_varname'])
             ddi.listenerInstance = w
             self.dropdown.append(ddi)
-        if self.eventConnectionFunc.callback: #if the callback is not None, and so there is a listener
-            connectedListenerName = eventConnectionFunc.callback.__self__.attributes['editor_varname']
+        if hasattr(self.eventConnectionFunc, 'callback_copy'): #if the callback is not None, and so there is a listener
+            connectedListenerName = eventConnectionFunc.callback_copy.__self__.attributes['editor_varname']
             self.dropdown.set_value( connectedListenerName )
 
     def on_connection(self, widget, dropDownValue):
-        if self.eventConnectionFuncName == 'onclick':
-            back = self.refWidget.onclick.callback
-            self.refWidget.onclick.callback = self.refWidget.backup_onclick_listener
-        
         if self.dropdown.get_value()=='None':
             self.eventConnectionFunc.connect(None)
         else:
             listener = self.dropdown._selected_item.listenerInstance
             listener.attributes['editor_newclass'] = "True"
             print("Event: " + self.eventConnectionFuncName + " signal connection to: " + listener.attributes['editor_varname'] + "   from:" + self.refWidget.attributes['editor_varname'])
+            back_callback = getattr(self.refWidget, self.eventConnectionFuncName).callback
             listener.__class__.fakeListenerFunc = fakeListenerFunc
             getattr(self.refWidget, self.eventConnectionFuncName).connect(listener.fakeListenerFunc)
-
-        if self.eventConnectionFuncName == 'onclick':
-            self.refWidget.backup_onclick_listener = self.refWidget.onclick.callback
-            self.refWidget.onclick.callback = back
+            getattr(self.refWidget, self.eventConnectionFuncName).callback_copy = getattr(self.refWidget, self.eventConnectionFuncName).callback
+            getattr(self.refWidget, self.eventConnectionFuncName).callback = back_callback
 
 
 def fakeListenerFunc(self,*args):
@@ -204,17 +199,11 @@ def update(self, widget, widget_tree):
         for (setOnEventListenerFuncname,setOnEventListenerFunc) in inspect.getmembers(widget):
             #if the member is decorated by decorate_set_on_listener and the function is referred to this event
             if hasattr(setOnEventListenerFunc, '_event_info'):
-                if setOnEventListenerFuncname == "onclick":
-                    backup_editor_onclick = widget.onclick.callback
-                    widget.onclick.callback = widget.backup_onclick_listener
-                    setOnEventListenerFunc = widget.onclick
                 self.container.append( SignalConnection(widget, 
                     self.listeners_list, 
                     setOnEventListenerFuncname, 
                     setOnEventListenerFunc, 
                     width='100%') )
-                if setOnEventListenerFuncname == "onclick":
-                    widget.onclick.callback = backup_editor_onclick
 
 
 class ProjectConfigurationDialog(gui.GenericDialog, gui.EventSource):