def set_plot(self, plot):

        Signals.disconnect_list(self._signals)
        self.backend is not None and self.backend.disconnect()

        if plot is None:
            return

        
        self.plot = plot
        self.set_title( "Plot: %s" % plot.key )
        
        self.backend = project.new_backend('gnuplot/x11', plot=plot)

        # connect signals for treeview
        # these are disconnect by the backend if it closes
        Signals.connect(self.backend, 'gnuplot-send-cmd', self.on_send_cmd)
        Signals.connect(self.backend, 'gnuplot-finish-cmd', self.on_finish_cmd)
        Signals.connect(self.backend, 'gnuplot-start-plotting', self.on_start_plotting)

        # connect signal for plot
        # these should be disconnected before the plot needs to do it.
        self._signals += [
            Signals.connect(plot, "plot-changed", (lambda sender: self.backend.draw())),
            Signals.connect(plot, "closed", (lambda sender: self.destroy()))
            ]

        self.backend.draw()
Пример #2
0
    def set_backend(self, backend):
        """ Set the backend to the new value (implies setting a new layer). """
        if self.backend != backend:
            Signals.disconnect_list(self.backend_signals)

            self.backend = backend

            if self.backend is not None:
                # If no active layer is set, even though there are layers,
                # then we should set the first layer as being active.
                if self.backend.layer is None and len(self.backend.plot.layers) > 0:
                    self.backend.layer = self.backend.plot.layers[0]
                self.layer = self.backend.layer

                # make sure we keep track of changes to the active layer
                self.backend_signals.append(
                    Signals.connect(backend, "notify::layer",
                                    (lambda sender, layer: self.set_layer(layer)))
                    )
            else:
                self.layer = None

            # propagate the new backend to all tools
            self.dock.foreach((lambda tool: tool.set_backend(self.backend)))
            
            # Adjust the active index of the combobox so that the new
            # backend is displayed.
            if self.backend is None:
                index = -1
            else:
                model = self.combobox.get_model()
                index = self.project.backends.index(backend)
            self.combobox.set_active(index)
Пример #3
0
 def set_layer(self, layer):
     if layer == self.layer:
         return
     
     Signals.disconnect_list(self.layer_signals)
     self.layer = layer
     
     if layer is not None:
         # maybe connect to layer properties: is it visible, position, ...
         pass
     self.update_layer()
Пример #4
0
 def set_layer(self, layer):
     if layer == self.layer:
         return
     
     Signals.disconnect_list(self.layer_signals)
     self.layer = layer
     
     if layer is not None:
         self.layer_signals.append(
             Signals.connect(self.layer, "notify::labels", self.on_notify_labels)
             )
     self.update_layer()
Пример #5
0
 def set_backend(self, backend):
     if backend == self.backend:
         return
     
     Signals.disconnect_list(self.backend_signals)
     self.backend = backend
     self.update_backend()
     
     if backend is not None:            
         self.set_layer(backend.layer)
     else:
         self.set_layer(None)            
Пример #6
0
    def set_plot(self, plot):
        if plot == self.plot:
            return        

        Signals.disconnect_list(self.plot_signals)
        if plot is not None:
            self.layer = plot.current_layer
            self.plot_signals.append(
                Signals.connect(plot, "notify::current_layer", self.on_notify_layer)
                )
        else:
            self.layer = None

        self.set_sensitive(plot is not None)

        self.plot = plot        
        self.update_plot()
Пример #7
0
    def set_project(self, project):
        if project == self.project:
            return

        Signals.disconnect_list(self.project_signals)            
        if project is not None:
            # update combobox again if plots change
            self.project_signals.extend(
                [Signals.connect(project, 'notify::backends',
                                 (lambda sender: self.update_combobox())),
                 #Signals.connect(project.app, 'backend-changed',
                 #                (lambda sender, backend: self.set_backend(backend)))
                 ])

        self.dock.foreach((lambda tool: tool.set_data('project', project)))
        
        self.project = project
        self.update_combobox()
Пример #8
0
    def set_project(self, project):
        if project == self.project:
            return

        Signals.disconnect_list(self.project_signals)            
        if project is not None:
            # update combobox again if plots change
            self.project_signals.extend(
                [Signals.connect(project, 'notify::plots',
                                 (lambda sender: self.update_combobox())),
                 Signals.connect(project.app, 'notify::current_plot',
                                 (lambda sender, plot: self.set_plot(plot)))
                 ])

        self.dock.foreach((lambda tool: tool.set_data('project', project)))
        
        self.project = project
        self.update_combobox()
        self.update_plot()