source: sasview/src/sas/qtgui/Perspectives/Invariant/InvariantPerspective.py @ e540cd2

ESS_GUIESS_GUI_DocsESS_GUI_batch_fittingESS_GUI_bumps_abstractionESS_GUI_iss1116ESS_GUI_iss879ESS_GUI_iss959ESS_GUI_openclESS_GUI_orderingESS_GUI_sync_sascalc
Last change on this file since e540cd2 was e540cd2, checked in by Piotr Rozyczko <piotr.rozyczko@…>, 8 years ago

Status bar, progress bar, initial treeview context menu + minor cleanup
  • Property mode set to 100755
File size: 23.5 KB
Line 
1# global
2import sys
3import os
4from PyQt4 import QtCore
5from PyQt4 import QtGui
6from PyQt4 import QtWebKit
7
8from twisted.internet import threads
9from twisted.internet import reactor
10
11# sas-global
12from sas.sascalc.invariant import invariant
13from sas.sasgui.guiframe.dataFitting import Data1D
14# from sas.qtgui.GuiUtils import *
15from GuiUtils import *
16
17# local
18from UI.TabbedInvariantUI import tabbedInvariantUI
19from InvariantDetails import DetailsDialog
20from Plotter import Plotter
21from InvariantUtils import WIDGETS
22
23# The minimum q-value to be used when extrapolating
24Q_MINIMUM = 1e-5
25# The maximum q-value to be used when extrapolating
26Q_MAXIMUM = 10
27# the ratio of maximum q value/(qmax of data) to plot the theory data
28Q_MAXIMUM_PLOT = 3
29
30
31class MyModel(object):
32    def __init__(self):
33        self._model = QtGui.QStandardItemModel(self)
34
35    def addItem(self, item):
36        item = QtGui.QStandardItem(str(item))
37        self._model.appendRow(item)
38
39class InvariantWindow(tabbedInvariantUI):
40    # The controller which is responsible for managing signal slots connections
41    # for the gui and providing an interface to the data model.
42    def __init__(self, manager=None, parent=None):
43        super(InvariantWindow, self).__init__(parent)
44        self.setWindowTitle("Invariant Perspective")
45
46        # initial input params
47        self._background = 0.0
48        self._scale = 1.0
49        self._contrast = 1.0
50        self._porod = 1.0
51        self._npoints_low = 10
52        self._npoints_high = 10
53        self._power_low = 4
54
55        self._manager = manager
56        self._reactor = self._manager.reactor()
57        self._model_item = QtGui.QStandardItem()
58
59        self._helpView = QtWebKit.QWebView()
60        self.detailsDialog = DetailsDialog(self)
61        self._plotter = Plotter(self)
62
63        self._low_extrapolate = False
64        self._low_guinier  = True
65        self._low_fit  = True
66        self._high_extrapolate = False
67        self._high_power_value  = False
68
69        self.communicate = Communicate()
70
71        # Mask file selector
72        ###################################################
73        self._path = "cyl_400_20.txt"
74        from sas.sascalc.dataloader.loader import  Loader
75        loader = Loader()
76        try:
77            self._data = loader.load(self._path)
78        except:
79            raise
80        ###################################################
81
82        self.lineEdit_8.setText(str(Q_MINIMUM))
83        self.lineEdit_9.setText(str(Q_MAXIMUM))
84
85        # Let's choose the Standard Item Model.
86        self.model = QtGui.QStandardItemModel(self)
87
88        # Connect buttons to slots.
89        # Needs to be done early so default values propagate properly.
90        self.setupSlots()
91
92        # Set up the model.
93        self.setupModel()
94
95        # Set up the mapper
96        self.setupMapper()
97
98    def closeEvent(self, event):
99        """
100        Overwrite the default close method of QWidget
101        """
102        # No close on perspectives - one must always be active.
103        event.ignore()
104
105    def communicator(self):
106        """ Getter for the communicator """
107        return self.communicate
108
109    def updateFromModel(self):
110        """
111        update the globals based on the data in the model
112        """
113        self._background = float(self.model.item(WIDGETS.W_BACKGROUND).text())
114        self._contrast   = float(self.model.item(WIDGETS.W_CONTRAST).text())
115        self._scale      = float(self.model.item(WIDGETS.W_SCALE).text())
116
117        # High extrapolate
118        self._low_extrapolate = ( str(self.model.item(WIDGETS.W_ENABLE_LOWQ).text()) == 'true')
119        self._low_points = float(self.model.item(WIDGETS.W_NPTS_LOWQ).text())
120        self._low_guinier  = ( str(self.model.item(WIDGETS.W_LOWQ_GUINIER).text()) == 'true')
121        self._low_fit  = ( str(self.model.item(WIDGETS.W_LOWQ_FIT).text()) == 'true')
122        self._low_power_value  = float(self.model.item(WIDGETS.W_LOWQ_POWER_VALUE).text())
123
124        # High extrapolating
125        self._high_extrapolate = ( str(self.model.item(WIDGETS.W_ENABLE_HIGHQ).text()) == 'true')
126        self._high_points  = float(self.model.item(WIDGETS.W_NPTS_HIGHQ).text())
127        self._high_fit  = ( str(self.model.item(WIDGETS.W_HIGHQ_FIT).text()) == 'true')
128        self._high_power_value  = float(self.model.item(WIDGETS.W_HIGHQ_POWER_VALUE).text())
129
130    def calculateInvariant(self):
131        """
132        Use twisted to thread the calculations away.
133        """
134        # Find out if extrapolation needs to be used.
135        extrapolation = None
136        if self._low_extrapolate  and not self._high_extrapolate:
137            extrapolation = "low"
138        elif not self._low_extrapolate  and self._high_extrapolate:
139            extrapolation = "high"
140        elif self._low_extrapolate and self._high_extrapolate:
141            extrapolation = "both"
142        try:
143            # modify the Calculate button to indicate background process
144            self.pushButton.setText("Calculating...")
145            self.pushButton.setEnabled(False)
146            self.style = self.pushButton.styleSheet()
147            self.pushButton.setStyleSheet("background-color: rgb(255, 255, 0); color: rgb(0, 0, 0)")
148            # Send the calculations to separate thread.
149            d = threads.deferToThread(self.calculateThread, extrapolation)
150            # Add deferred callback for call return
151            d.addCallback(self.plotResult)
152        except Exception as ex:
153            # Set the button back to available
154            self.pushButton.setEnabled(True)
155            self.pushButton.setText("Calculate")
156            self.pushButton.setStyleSheet(self.style)
157
158
159    def plotResult(self, model):
160        """
161        """
162        if self._low_extrapolate or self._high_extrapolate:
163            self._plotter.show()
164        self.model = model
165        self.mapper.toFirst()
166
167        # Set the button back to available
168        self.pushButton.setEnabled(True)
169        self.pushButton.setText("Calculate")
170        self.pushButton.setStyleSheet(self.style)
171
172        # Send the modified model item to DE for keeping in the model
173        self.communicate.updateModelFromPerspectiveSignal.emit(self._model_item)
174
175
176    def calculateThread(self, extrapolation):
177        """
178        Perform Invariant calculations.
179
180        TODO: Create a dictionary of results to be sent to DE on completion.
181        """
182        self.updateFromModel()
183
184        qstar_low = 0.0
185        qstar_low_err = 0.0
186        qstar_high = 0.0
187        qstar_high_err = 0.0
188        qstar_total = 0.0
189        qstar_total_low_err = 0.0
190
191        # Prepare the invariant object
192        inv = invariant.InvariantCalculator(data=self._data,
193                                            background = self._background,
194                                            scale = self._scale)
195
196        if self._low_extrapolate:
197            function_low = "power_law"
198            if self._low_guinier:
199                function_low = "guinier"
200            if self._low_fit:
201                self._low_power_value = None
202            inv.set_extrapolation(range="low",
203                                  npts=self._low_points,
204                                  function=function_low,
205                                  power=self._low_power_value)
206
207        if self._high_extrapolate:
208            function_low = "power_law"
209            inv.set_extrapolation(range="high",
210                                  npts=self._high_points,
211                                  function=function_low,
212                                  power=self._low_power_value)
213
214        #Compute invariant
215        # TODO: proper exception handling and logic -
216        # display info, update lineedits, don't run extrapolations etc.
217        calculation_failed = False
218        try:
219            qstar_total, qstar_total_error         = inv.get_qstar_with_error()
220        except Exception as ex:
221            calculation_failed = True
222            # Display relevant information
223            item = QtGui.QStandardItem("ERROR")
224            self.model.setItem(WIDGETS.W_INVARIANT, item)
225            item = QtGui.QStandardItem("ERROR")
226            self.model.setItem(WIDGETS.W_INVARIANT_ERR, item)
227        try:
228            volume_fraction, volume_fraction_error = \
229                inv.get_volume_fraction_with_error(self._contrast)
230        except Exception as ex:
231            calculation_failed = True
232            # Display relevant information
233            item = QtGui.QStandardItem("ERROR")
234            self.model.setItem(WIDGETS.W_VOLUME_FRACTION, item)
235            item = QtGui.QStandardItem("ERROR")
236            self.model.setItem(WIDGETS.W_VOLUME_FRACTION_ERR, item)
237        try:
238            surface, surface_error                 = \
239                inv.get_surface_with_error(self._contrast, self._porod)
240        except Exception as ex:
241            calculation_failed = True
242            # Display relevant information
243            item = QtGui.QStandardItem("ERROR")
244            self.model.setItem(WIDGETS.W_SPECIFIC_SURFACE, item)
245            item = QtGui.QStandardItem("ERROR")
246            self.model.setItem(WIDGETS.W_SPECIFIC_SURFACE_ERR, item)
247
248        if(calculation_failed):
249            # TODO: NOTIFY THE GUI MANAGER!!
250            self.mapper.toFirst()
251            return self.model
252
253        self._plotter.clean()
254        self._plotter.x_label("Q(A$^{-1}$)")
255        self._plotter.y_label("Intensity(cm$^{-1}$)")
256
257        if self._low_extrapolate:
258            # for presentation in InvariantDetails
259            qstar_low, qstar_low_err = inv.get_qstar_low()
260            extrapolated_data = inv.get_extra_data_low(self._low_points)
261            power_low = inv.get_extrapolation_power(range='low')
262
263            #inv.data = extrapolated_data
264            #qstar_total, qstar_total_error = inv.get_qstar_with_error()
265
266            # Plot the chart
267            title = "Low-Q extrapolation"
268            self._plotter.data(extrapolated_data)
269            self._plotter.title(title)
270            self._plotter.plot()
271
272            # Convert the data into plottable
273            extrapolated_data = self._manager.createGuiData(extrapolated_data)
274
275            # Add the plot to the model item
276            # variant_item = QtCore.QVariant(self._plotter)
277            variant_item = QtCore.QVariant(extrapolated_data)
278
279            # This needs to run in the main thread
280            reactor.callFromThread(updateModelItem, self._model_item, variant_item, title)
281
282        if self._high_extrapolate:
283            # for presentation in InvariantDetails
284            qmax_plot = Q_MAXIMUM_PLOT * max(self._data.x)
285            if qmax_plot > Q_MAXIMUM:
286                qmax_plot = Q_MAXIMUM
287            qstar_high, qstar_high_err = inv.get_qstar_high()
288            power_high = inv.get_extrapolation_power(range='high')
289            high_out_data = inv.get_extra_data_high(q_end=qmax_plot, npts=500)
290
291            # Convert the data into plottable
292            high_out_data = self._manager.createGuiData(high_out_data)
293
294            # find how to add this plot to the existing plot for low_extrapolate
295            # Plot the chart
296            title = "High-Q extrapolation"
297            self._plotter.data(high_out_data)
298            self._plotter.title(title)
299            self._plotter.plot()
300
301            # Add the plot to the model item
302            # variant_item = QtCore.QVariant(self._plotter)
303            variant_item = QtCore.QVariant(high_out_data)
304            # This needs to run in the main thread
305            reactor.callFromThread(updateModelItem, self._model_item, variant_item, title)
306
307        item = QtGui.QStandardItem(str(float('%.5g'% volume_fraction)))
308        self.model.setItem(WIDGETS.W_VOLUME_FRACTION, item)
309        item = QtGui.QStandardItem(str(float('%.5g'% volume_fraction_error)))
310        self.model.setItem(WIDGETS.W_VOLUME_FRACTION_ERR, item)
311        item = QtGui.QStandardItem(str(float('%.5g'% surface)))
312        self.model.setItem(WIDGETS.W_SPECIFIC_SURFACE, item)
313        item = QtGui.QStandardItem(str(float('%.5g'% surface_error)))
314        self.model.setItem(WIDGETS.W_SPECIFIC_SURFACE_ERR, item)
315        item = QtGui.QStandardItem(str(float('%.5g'% qstar_total)))
316        self.model.setItem(WIDGETS.W_INVARIANT, item)
317        item = QtGui.QStandardItem(str(float('%.5g'% qstar_total_error)))
318        self.model.setItem(WIDGETS.W_INVARIANT_ERR, item)
319
320        #item = QtGui.QStandardItem(str(float('%.5g'% qstar_total)))
321        #self.model.setItem(WIDGETS.D_TOTAL_QSTAR, item)
322        #item = QtGui.QStandardItem(str(float('%.5g'% qstar_total_err)))
323        #self.model.setItem(WIDGETS.D_TOTAL_QSTAR_ERR, item)
324        item = QtGui.QStandardItem(str(float('%.5g'% qstar_low)))
325        self.model.setItem(WIDGETS.D_LOW_QSTAR, item)
326        item = QtGui.QStandardItem(str(float('%.5g'% qstar_low_err)))
327        self.model.setItem(WIDGETS.D_LOW_QSTAR_ERR, item)
328        item = QtGui.QStandardItem(str(float('%.5g'% qstar_high)))
329        self.model.setItem(WIDGETS.D_HIGH_QSTAR, item)
330        item = QtGui.QStandardItem(str(float('%.5g'% qstar_high_err)))
331        self.model.setItem(WIDGETS.D_HIGH_QSTAR_ERR, item)
332
333        self.mapper.toFirst()
334
335        return self.model
336               
337    def title(self):
338        """
339        Perspective name
340        """
341        return "Invariant panel"
342
343    def status(self):
344        """
345        """
346        self.detailsDialog.setModel(self.model)
347        self.detailsDialog.showDialog()
348
349    def help(self):
350        """
351        """
352        _TreeLocation = "html/user/sasgui/perspectives/invariant/invariant_help.html"
353        self._helpView.load(QtCore.QUrl(_TreeLocation))
354        self._helpView.show()
355
356    def setupSlots(self):
357        self.pushButton.clicked.connect(self.calculateInvariant)
358        self.pushButton_2.clicked.connect(self.status)
359        self.pushButton_3.clicked.connect(self.help)
360
361        self.radioButton.toggled.connect(self.lowGuinierAndPowerToggle)
362        self.radioButton_8.toggled.connect(self.hiFitAndFixToggle)
363
364        self.radioButton_3.toggled.connect(self.lowFitAndFixToggle)
365
366        # Bug workaround for QDataWidgetMapper() not reacting to checkbox clicks.
367        # https://bugreports.qt.io/browse/QTBUG-1818
368        self.checkBox.clicked.connect(self.setFocus)
369        self.checkBox_2.clicked.connect(self.setFocus)
370
371        self.model.itemChanged.connect(self.modelChanged)
372
373    def modelChanged(self, item):
374        """
375        """
376        if item.row() == WIDGETS.W_ENABLE_LOWQ:
377            toggle = (str(item.text()) == 'true')
378            self._low_extrapolate = toggle
379            self.lowQToggle(toggle)
380        elif item.row() == WIDGETS.W_ENABLE_HIGHQ:
381            toggle = (str(item.text()) == 'true')
382            self._high_extrapolate = toggle
383            self.highQToggle(toggle)
384       
385    def lowGuinierAndPowerToggle(self, toggle):
386        """
387        """
388        self._low_guinier = toggle
389        toggle = not toggle
390        self.lineEdit_11.setEnabled(toggle)
391        self.radioButton_3.setEnabled(toggle)
392        self.radioButton_4.setEnabled(toggle)
393        self.lineEdit_11.setEnabled(toggle and (not self._low_fit))
394
395    def lowFitAndFixToggle(self, toggle):
396        """
397        """
398        self._low_fit = toggle
399        toggle = not toggle
400        self.lineEdit_11.setEnabled(toggle)
401
402    def hiFitAndFixToggle(self, toggle):
403        """
404        """
405        self.lineEdit_13.setEnabled(toggle)
406
407    def highQToggle(self, clicked):
408        """
409        Disable/enable High Q extrapolation
410        """
411        self.radioButton_7.setEnabled(clicked)
412        self.radioButton_8.setEnabled(clicked)
413        self.lineEdit_12.setEnabled(clicked)
414        self.lineEdit_13.setEnabled(clicked)
415
416    def lowQToggle(self, clicked):
417        """
418        Disable/enable Low Q extrapolation
419        """
420        self.radioButton.setEnabled(clicked)
421        self.radioButton_2.setEnabled(clicked)
422        self.lineEdit_11.setEnabled(clicked and not self._low_fit)
423
424        # Enable subelements
425        self.radioButton_3.setEnabled(clicked and not self._low_guinier)
426        self.radioButton_4.setEnabled(clicked and not self._low_guinier)
427        self.lineEdit_10.setEnabled(clicked and not self._low_guinier)
428
429    def setupModel(self):
430
431        # filename
432        item = QtGui.QStandardItem(self._path)
433        self.model.setItem(WIDGETS.W_FILENAME, item)
434
435        # add Q parameters to the model
436        qmin = min(self._data.x)
437        item = QtGui.QStandardItem(str(qmin))
438        self.model.setItem(WIDGETS.W_QMIN, item)
439        item = QtGui.QStandardItem(str(max(self._data.x)))
440        self.model.setItem(WIDGETS.W_QMAX, item)
441
442        # add custom input params
443        item = QtGui.QStandardItem(str(self._background))
444        self.model.setItem(WIDGETS.W_BACKGROUND, item)
445        item = QtGui.QStandardItem(str(self._contrast))
446        self.model.setItem(WIDGETS.W_CONTRAST, item)
447        item = QtGui.QStandardItem(str(self._scale))
448        self.model.setItem(WIDGETS.W_SCALE, item)
449       
450        # Dialog elements
451        itemf = QtGui.QStandardItem("false")
452        self.model.setItem(WIDGETS.W_ENABLE_HIGHQ, itemf)
453        itemf = QtGui.QStandardItem("false")
454        self.model.setItem(WIDGETS.W_ENABLE_LOWQ, itemf)
455
456        item = QtGui.QStandardItem(str(self._npoints_low))
457        self.model.setItem(WIDGETS.W_NPTS_LOWQ, item)
458        item = QtGui.QStandardItem(str(self._npoints_high))
459        self.model.setItem(WIDGETS.W_NPTS_HIGHQ, item)
460
461        itemt = QtGui.QStandardItem("true")
462        self.model.setItem(WIDGETS.W_LOWQ_GUINIER, itemt)
463
464        itemt = QtGui.QStandardItem("true")
465        self.model.setItem(WIDGETS.W_LOWQ_FIT, itemt)
466        item = QtGui.QStandardItem(str(self._power_low))
467        self.model.setItem(WIDGETS.W_LOWQ_POWER_VALUE, item)
468
469        itemt = QtGui.QStandardItem("true")
470        self.model.setItem(WIDGETS.W_HIGHQ_FIT, itemt)
471        item = QtGui.QStandardItem(str(self._power_low))
472        self.model.setItem(WIDGETS.W_HIGHQ_POWER_VALUE, item)
473
474
475    def setupMapper(self):
476        # Set up the mapper.
477        self.mapper = QtGui.QDataWidgetMapper(self)
478        self.mapper.setOrientation(QtCore.Qt.Vertical)
479        self.mapper.setModel(self.model)
480
481        # Set up the view on the model for testing
482        # self.tableView.setModel(self.model)
483
484        # Filename
485        self.mapper.addMapping(self.lineEdit, WIDGETS.W_FILENAME)
486        # Qmin/Qmax
487        self.mapper.addMapping(self.lineEdit_2, WIDGETS.W_QMIN)
488        self.mapper.addMapping(self.lineEdit_3, WIDGETS.W_QMAX)
489
490        # Background
491        self.mapper.addMapping(self.lineEdit_4, WIDGETS.W_BACKGROUND)
492        # Scale
493        self.mapper.addMapping(self.lineEdit_5, WIDGETS.W_SCALE)
494        # Contrast
495        self.mapper.addMapping(self.lineEdit_6, WIDGETS.W_CONTRAST)
496
497        # Lowq/Highq items
498        self.mapper.addMapping(self.checkBox, WIDGETS.W_ENABLE_LOWQ)
499        self.mapper.addMapping(self.checkBox_2, WIDGETS.W_ENABLE_HIGHQ)
500
501        self.mapper.addMapping(self.lineEdit_10, WIDGETS.W_NPTS_LOWQ)
502        self.mapper.addMapping(self.radioButton, WIDGETS.W_LOWQ_GUINIER)
503
504        self.mapper.addMapping(self.radioButton_3, WIDGETS.W_LOWQ_FIT)
505        self.mapper.addMapping(self.lineEdit_11, WIDGETS.W_LOWQ_POWER_VALUE)
506
507        self.mapper.addMapping(self.radioButton_7, WIDGETS.W_HIGHQ_FIT)
508        self.mapper.addMapping(self.lineEdit_13, WIDGETS.W_HIGHQ_POWER_VALUE)
509   
510        # Output
511        self.mapper.addMapping(self.lineEdit_14, WIDGETS.W_VOLUME_FRACTION)
512        self.mapper.addMapping(self.lineEdit_15, WIDGETS.W_VOLUME_FRACTION_ERR)
513        self.mapper.addMapping(self.lineEdit_16, WIDGETS.W_SPECIFIC_SURFACE)
514        self.mapper.addMapping(self.lineEdit_17, WIDGETS.W_SPECIFIC_SURFACE_ERR)
515        self.mapper.addMapping(self.lineEdit_19, WIDGETS.W_INVARIANT)
516        self.mapper.addMapping(self.lineEdit_18, WIDGETS.W_INVARIANT_ERR)
517
518        self.mapper.toFirst()
519
520    def setData(self, data_item):
521        """
522        Obtain a QStandardItem object and dissect it to get Data1D/2D
523        Pass it over to the calculator
524        """
525        if not isinstance(data_item, list):
526            msg = "Incorrect type passed to the Invariant Perspective"
527            raise AttributeError, msg
528
529        if not isinstance(data_item[0], QtGui.QStandardItem):
530            msg = "Incorrect type passed to the Invariant Perspective"
531            raise AttributeError, msg
532
533        self._model_item = data_item[0]
534
535        # Extract data on 1st child - this is the Data1D/2D component
536        data = self._model_item.child(0).data().toPyObject()
537
538        self.calculate(data_list=[data])
539       
540    def calculate(self, data_list=None):
541        """
542        receive a list of data and compute invariant
543
544        TODO: pass warnings/messages to log
545        """
546        msg = ""
547        data = None
548        if data_list is None:
549            data_list = []
550        if len(data_list) >= 1:
551            if len(data_list) == 1:
552                data = data_list[0]
553            else:
554                data_1d_list = []
555                data_2d_list = []
556                error_msg = ""
557                # separate data into data1d and data2d list
558                for data in data_list:
559                    if data is not None:
560                        if issubclass(data.__class__, Data1D):
561                            data_1d_list.append(data)
562                        else:
563                            error_msg += " %s  type %s \n" % (str(data.name),
564                                                              str(data.__class__.__name__))
565                            data_2d_list.append(data)
566                if len(data_2d_list) > 0:
567                    msg = "Invariant does not support the following data types:\n"
568                    msg += error_msg
569                if len(data_1d_list) == 0:
570                    # remake this as a qt event
571                    #wx.PostEvent(self.parent, StatusEvent(status=msg, info='error'))
572                    return
573
574                # TODO: add msgbox for data choice
575                #msg += "Invariant panel does not allow multiple data!\n"
576                #msg += "Please select one.\n"
577                #if len(data_list) > 1:
578                    #from invariant_widgets import DataDialog
579                    #dlg = DataDialog(data_list=data_1d_list, text=msg)
580                    #if dlg.ShowModal() == wx.ID_OK:
581                    #    data = dlg.get_data()
582                    #else:
583                    #    data = None
584                    #dlg.Destroy()
585
586            if data is None:
587                msg += "invariant receives no data. \n"
588                #wx.PostEvent(self.parent, StatusEvent(status=msg, info='error'))
589                return
590            if not issubclass(data.__class__, Data1D):
591                msg += "invariant cannot be computed for data of "
592                msg += "type %s\n" % (data.__class__.__name__)
593                #wx.PostEvent(self.parent, StatusEvent(status=msg, info='error'))
594                return
595            else:
596                #wx.PostEvent(self.parent, NewPlotEvent(plot=data, title=data.title))
597                try:
598                    self._data = data
599                    self._path = "unique path"
600                    self.calculateInvariant()
601                except:
602                    msg = "Invariant Set_data: " + str(sys.exc_value)
603                    #wx.PostEvent(self.parent, StatusEvent(status=msg, info="error"))
604        else:
605            msg = "invariant cannot be computed for data of "
606            msg += "type %s" % (data.__class__.__name__)
607            #wx.PostEvent(self.parent, StatusEvent(status=msg, info='error'))
608
609    def allowBatch(self):
610        """
611        Tell the caller that we don't accept multiple data instances
612        """
613        return False
614
615if __name__ == "__main__":
616    app = QtGui.QApplication([])
617    import qt4reactor
618    qt4reactor.install()
619    # DO NOT move the following import to the top!
620    # (unless you know what you're doing)
621    from twisted.internet import reactor
622    dlg = InvariantWindow(reactor)
623    dlg.show()
624    reactor.run()
Note: See TracBrowser for help on using the repository browser.