Example #1
0
    def modelChooserDlg(parent=None, selectables=None, host=None, asMimeData=False, singleModel=False, windowTitle='Model Chooser'):
        '''Static method that launches a modal dialog containing a TaurusModelChooser

        :param parent: (QObject) parent for the dialog
        :param selectables: (list<TaurusElementType>) if passed, only elements of the tree whose
                            type is in the list will be selectable.
        :param host: (QObject) Tango host to be explored by the chooser
        :param asMimeData: (bool) If False (default),  a list of models will be.
                           returned. If True, a `QMimeData` object will be
                           returned instead. See :meth:`getListedModels` for a
                           detailed description of this QMimeData object.
        :param singleModel: (bool) If True, the selection will be of just one
                            model. Otherwise (default) a list of models can be selected
        :param windowTitle: (str) Title of the dialog (default="Model Chooser")

        :return: (list,bool or QMimeData,bool) Returns a models,ok tuple. models can be
                 either a list of models or a QMimeData object, depending on
                 `asMimeData`. ok is True if the dialog was accepted (by
                 clicking on the "update" button) and False otherwise
        '''
        dlg = Qt.QDialog(parent)
        dlg.setWindowTitle(windowTitle)
        dlg.setWindowIcon(Qt.QIcon("logos:taurus.png"))
        layout = Qt.QVBoxLayout()
        w = TaurusModelChooser(
            parent=parent, selectables=selectables, host=host, singleModel=singleModel)
        layout.addWidget(w)
        dlg.setLayout(layout)
        w.updateModels.connect(dlg.accept)
        dlg.exec_()
        return w.getListedModels(asMimeData=asMimeData), (dlg.result() == dlg.Accepted)
Example #2
0
def main3():
    asMimeData = True
    app = Qt.QApplication([])
    dlg = Qt.QDialog()
    dlg.setWindowTitle('Archiving Tree')
    dlg.setWindowIcon(Qt.QIcon("logos:taurus.png"))
    layout = Qt.QVBoxLayout()
    w = TaurusModelChooser(
        parent=dlg) #, selectables=selectables, host=host, singleModel=singleModel)
    layout.addWidget(w)
    dlg.setLayout(layout)
    w.updateModels.connect(dlg.accept)
    dlg.exec_()
    return w.getListedModels(asMimeData=asMimeData), (dlg.result() == dlg.Accepted)    
Example #3
0
 def addChannel(self, channel=None):
     qmodel = self.getQModel()
     dataSource = qmodel.dataSource()
     if channel is None:
         shown = [n for n, d in getChannelConfigs(dataSource)]
         avail_channels = qmodel.getAvailableChannels()
         clist = [ch_info['name'] for ch_name, ch_info in avail_channels.items()
                  if ch_name not in shown]
         clist = sorted(clist) + ['(Other...)']
         chname, ok = Qt.QInputDialog.getItem(
             self, "New Channel", "Choose channel:", clist, 0, False)
         if not ok:
             return
     chname = str(chname)
     if chname == '(Other...)':
         models, ok = TaurusModelChooser.modelChooserDlg(parent=self, singleModel=False, windowTitle='Choose source of data',
                                                         selectables=[TaurusElementType.Attribute])
         if not ok:
             return
         for m in models:
             qmodel.addChannel(
                 chname=m, ctrlname='__tango__', external=True)
     else:
         for ch_info in avail_channels.values():
             if ch_info['name'] == chname:
                 qmodel.addChannel(chinfo=ch_info)
Example #4
0
 def chooseModel(self):
     '''shows a model chooser'''
     from taurus.qt.qtgui.panel import TaurusModelChooser
     selectables = [TaurusElementType.Attribute]
     models, ok = TaurusModelChooser.modelChooserDlg(
         selectables=selectables, singleModel=True)
     if ok and len(models) == 1:
         self.setModel(models[0])
Example #5
0
 def _showTaurusTree(self):
     if self._widget is None:
         self._widget = TaurusModelChooser()
         #self._adapter = TaurusPyMcaAdapter()
         Qt.QObject.connect(self._widget, 
                 Qt.SIGNAL("updateModels"),
                 self.onSelectionChanged)
     self._widget.show()
Example #6
0
File: tools.py Project: cmft/taurus
 def activate_command(self, plot, checked):
     """Activate tool"""
     # show a dialog
     models, ok = TaurusModelChooser.modelChooserDlg(
         parent=plot, selectables=[TaurusElementType.Attribute])
     if ok:
         # create image items and add them to the plot
         for m in models:
             item = make.image(taurusmodel=m)
             plot.add_item(item)
Example #7
0
 def _showTaurusTree(self):
     if self._widget is None:
         self._widget = TaurusModelChooser()
         #self._adapter = TaurusPyMcaAdapter()
         if Release.version_info >= (4,):
             self._widget.updateModels.connect(self.onSelectionChanged)
         else:
             Qt.QObject.connect(self._widget, 
                     Qt.SIGNAL("updateModels"),
                     self.onSelectionChanged)
     self._widget.show()
Example #8
0
File: tools.py Project: cmft/taurus
 def activate_command(self, plot, checked):
     """Activate tool"""
     # show a dialog
     models, ok = TaurusModelChooser.modelChooserDlg(
             parent=plot,
             selectables=[TaurusElementType.Attribute],
             singleModel=self.singleModel
     )
     if ok:
         if self.singleModel:
             if models:
                 self.manager.setModel(models[0])
             else:
                 self.manager.setModel('')
         else:
             self.manager.setModel(models)
Example #9
0
def TaurusDevicePanelMain():
    '''A launcher for TaurusDevicePanel.'''
    import sys
    from taurus.qt.qtgui.application import TaurusApplication
    from taurus.core.util import argparse

    parser = argparse.get_taurus_parser()
    parser.set_usage("%prog [options] [devname [attrs]]")
    parser.set_description("Taurus Application inspired in Jive and Atk Panel")
    parser.add_option("", "--config-file", dest="config_file", default=None,
                      help="load a config file (TODO: document this option)")

    app = TaurusApplication(cmd_line_parser=parser, app_name="TaurusDevicePanel",
                            app_version=taurus.Release.version)
    args = app.get_command_line_args()
    options = app.get_command_line_options()

    w = TaurusDevicePanel()
    w.show()

    if len(args) == 0:
        from taurus.qt.qtgui.panel import TaurusModelChooser
        models, ok = TaurusModelChooser.modelChooserDlg(w,
                                                        selectables=[
                                                            TaurusElementType.Member],
                                                        singleModel=True)
        model = models[0] if ok and models else None
        filters = ''
    else:
        model = args[0]
        filters = args[1:]

    if options.config_file is not None:
        w.loadConfigFile(options.config_file)
    elif model and filters:
        w.setAttributeFilters({model: filters})

    w.setModel(model)

    sys.exit(app.exec_())
Example #10
0
class TaurusPlugin1D(Plugin1DBase.Plugin1DBase, QObjectTaurusListener):
    def __init__(self, plotWindow, **kw):
        Plugin1DBase.Plugin1DBase.__init__(self, plotWindow, **kw)
        QObjectTaurusListener.__init__(self)
        
        # "standard" way to handle multiple calls
        self.methodDict = {}
        text  = "Show the device selector.\n"
        text += "Make sure your TANGO_HOST\n"
        text += "environment variable is set"
        function = self._showTaurusTree
        info = text
        icon = None
        self.methodDict["Show"] =[function,
                                       info,
                                       icon]
        self._oldModels = []
        self._newModels = []
        self._widget = None

    def handleEvent(self, evt_src, evt_type, evt_value):
        if evt_type not in (TaurusEventType.Change,
                            TaurusEventType.Periodic):
            return
        y = evt_value.value
        x = numpy.arange(y.shape[0])
        self.addCurve(x, y, legend=evt_src.getNormalName())

    def onSelectionChanged(self, models):
        if self._oldModels in [None, []]:
            self._attrDict = {}
            for model in models:
                try:
                    attr = Attribute(model)
                except:
                    # old PyTango versions do not handle unicode
                    attr = Attribute(str(model))
                #force a read -> attr.read()
                attr.addListener(self)
                legend = qt.safe_str(attr.getNormalName())
                self._attrDict[legend] = attr
            self._oldModels = models
        else:
            keptModels = []
            newModels = []
            for model in models:
                if model in self._oldModels:
                    keptModels.append(model)
                else:
                    newModels.append(model)
            for model in self._oldModels:
                if model not in keptModels:
                    attr = Attribute(model)
                    attr.removeListener(self)
                    legend = qt.safe_str(attr.getNormalName())
                    if legend in self._attrDict:
                        del self._attrDict[legend]
                    print("Trying to remove ", legend)
                    self.removeCurve(legend, replot=False)
            for model in newModels:
                attr = Attribute(model)
                # attr.read()
                attr.addListener(self)
                legend = qt.safe_str(attr.getNormalName())
                self._attrDict[legend] = attr
            self._oldModels = keptModels + newModels

    #Methods to be implemented by the plugin
    # I should put this mechanism in the base class ...
    def getMethods(self, plottype=None):
        """
        A list with the NAMES  associated to the callable methods
        that are applicable to the specified plot.

        Plot type can be "SCAN", "MCA", None, ...
        """
        # visualize everywhere, therefore ignore MCA or SCAN
        # if plottype in ["MCA"]:
        #    return []
        names = list(self.methodDict.keys())
        names.sort()
        return names

    def getMethodToolTip(self, name):
        """
        Returns the help associated to the particular method name or None.
        """
        return self.methodDict[name][1]

    def getMethodPixmap(self, name):
        """
        Returns the pixmap associated to the particular method name or None.
        """
        return self.methodDict[name][2]

    def applyMethod(self, name):
        """
        The plugin is asked to apply the method associated to name.
        """
        self.methodDict[name][0]()
        return


    def _showTaurusTree(self):
        if self._widget is None:
            self._widget = TaurusModelChooser()
            #self._adapter = TaurusPyMcaAdapter()
            if Release.version_info >= (4,):
                self._widget.updateModels.connect(self.onSelectionChanged)
            else:
                Qt.QObject.connect(self._widget, 
                        Qt.SIGNAL("updateModels"),
                        self.onSelectionChanged)
        self._widget.show()