source: sasview/src/sas/qtgui/MainWindow/GuiManager.py @ 17e2d502

ESS_GUIESS_GUI_batch_fittingESS_GUI_bumps_abstractionESS_GUI_iss1116ESS_GUI_openclESS_GUI_orderingESS_GUI_sync_sascalc
Last change on this file since 17e2d502 was 17e2d502, checked in by Piotr Rozyczko <piotr.rozyczko@…>, 5 years ago

Batch page serialization/deserialization
  • Property mode set to 100644
File size: 40.1 KB
Line 
1import sys
2import os
3import subprocess
4import logging
5import json
6import webbrowser
7import traceback
8
9from PyQt5.QtWidgets import *
10from PyQt5.QtGui import *
11from PyQt5.QtCore import Qt, QLocale, QUrl
12
13import matplotlib as mpl
14mpl.use("Qt5Agg")
15
16from twisted.internet import reactor
17# General SAS imports
18from sas import get_local_config, get_custom_config
19from sas.qtgui.Utilities.ConnectionProxy import ConnectionProxy
20from sas.qtgui.Utilities.SasviewLogger import setup_qt_logging
21
22import sas.qtgui.Utilities.LocalConfig as LocalConfig
23import sas.qtgui.Utilities.GuiUtils as GuiUtils
24
25import sas.qtgui.Utilities.ObjectLibrary as ObjectLibrary
26from sas.qtgui.Utilities.TabbedModelEditor import TabbedModelEditor
27from sas.qtgui.Utilities.PluginManager import PluginManager
28from sas.qtgui.Utilities.GridPanel import BatchOutputPanel
29from sas.qtgui.Utilities.ResultPanel import ResultPanel
30
31from sas.qtgui.Utilities.ReportDialog import ReportDialog
32from sas.qtgui.MainWindow.UI.AcknowledgementsUI import Ui_Acknowledgements
33from sas.qtgui.MainWindow.AboutBox import AboutBox
34from sas.qtgui.MainWindow.WelcomePanel import WelcomePanel
35from sas.qtgui.MainWindow.CategoryManager import CategoryManager
36
37from sas.qtgui.MainWindow.DataManager import DataManager
38
39from sas.qtgui.Calculators.SldPanel import SldPanel
40from sas.qtgui.Calculators.DensityPanel import DensityPanel
41from sas.qtgui.Calculators.KiessigPanel import KiessigPanel
42from sas.qtgui.Calculators.SlitSizeCalculator import SlitSizeCalculator
43from sas.qtgui.Calculators.GenericScatteringCalculator import GenericScatteringCalculator
44from sas.qtgui.Calculators.ResolutionCalculatorPanel import ResolutionCalculatorPanel
45from sas.qtgui.Calculators.DataOperationUtilityPanel import DataOperationUtilityPanel
46
47# Perspectives
48import sas.qtgui.Perspectives as Perspectives
49from sas.qtgui.Perspectives.Fitting.FittingPerspective import FittingWindow
50from sas.qtgui.MainWindow.DataExplorer import DataExplorerWindow, DEFAULT_PERSPECTIVE
51
52from sas.qtgui.Utilities.AddMultEditor import AddMultEditor
53
54logger = logging.getLogger(__name__)
55
56class Acknowledgements(QDialog, Ui_Acknowledgements):
57    def __init__(self, parent=None):
58        QDialog.__init__(self, parent)
59        self.setupUi(self)
60
61class GuiManager(object):
62    """
63    Main SasView window functionality
64    """
65    def __init__(self, parent=None):
66        """
67        Initialize the manager as a child of MainWindow.
68        """
69        self._workspace = parent
70        self._parent = parent
71
72        # Decide on a locale
73        QLocale.setDefault(QLocale('en_US'))
74
75        # Redefine exception hook to not explicitly crash the app.
76        sys.excepthook = self.info
77
78        # Add signal callbacks
79        self.addCallbacks()
80
81        # Assure model categories are available
82        self.addCategories()
83
84        # Create the data manager
85        # TODO: pull out all required methods from DataManager and reimplement
86        self._data_manager = DataManager()
87
88        # Create action triggers
89        self.addTriggers()
90
91        # Currently displayed perspective
92        self._current_perspective = None
93
94        # Populate the main window with stuff
95        self.addWidgets()
96
97        # Fork off logging messages to the Log Window
98        handler = setup_qt_logging()
99        handler.messageWritten.connect(self.appendLog)
100
101        # Log the start of the session
102        logging.info(" --- SasView session started ---")
103        # Log the python version
104        logging.info("Python: %s" % sys.version)
105
106        # Set up the status bar
107        self.statusBarSetup()
108
109        # Current tutorial location
110        self._tutorialLocation = os.path.abspath(os.path.join(GuiUtils.HELP_DIRECTORY_LOCATION,
111                                              "_downloads",
112                                              "Tutorial.pdf"))
113
114    def info(self, type, value, tb):
115        logger.error("SasView threw exception: " + str(value))
116        traceback.print_exception(type, value, tb)
117
118    def addWidgets(self):
119        """
120        Populate the main window with widgets
121
122        TODO: overwrite close() on Log and DR widgets so they can be hidden/shown
123        on request
124        """
125        # Add FileDialog widget as docked
126        self.filesWidget = DataExplorerWindow(self._parent, self, manager=self._data_manager)
127        ObjectLibrary.addObject('DataExplorer', self.filesWidget)
128
129        self.dockedFilesWidget = QDockWidget("Data Explorer", self._workspace)
130        self.dockedFilesWidget.setFloating(False)
131        self.dockedFilesWidget.setWidget(self.filesWidget)
132
133        # Modify menu items on widget visibility change
134        self.dockedFilesWidget.visibilityChanged.connect(self.updateContextMenus)
135
136        self._workspace.addDockWidget(Qt.LeftDockWidgetArea, self.dockedFilesWidget)
137        self._workspace.resizeDocks([self.dockedFilesWidget], [305], Qt.Horizontal)
138
139        # Add the console window as another docked widget
140        self.logDockWidget = QDockWidget("Log Explorer", self._workspace)
141        self.logDockWidget.setObjectName("LogDockWidget")
142        self.logDockWidget.visibilityChanged.connect(self.updateLogContextMenus)
143
144
145        self.listWidget = QTextBrowser()
146        self.logDockWidget.setWidget(self.listWidget)
147        self._workspace.addDockWidget(Qt.BottomDockWidgetArea, self.logDockWidget)
148
149        # Add other, minor widgets
150        self.ackWidget = Acknowledgements()
151        self.aboutWidget = AboutBox()
152        self.categoryManagerWidget = CategoryManager(self._parent, manager=self)
153
154        self.grid_window = None
155        self.grid_window = BatchOutputPanel(parent=self)
156        if sys.platform == "darwin":
157            self.grid_window.menubar.setNativeMenuBar(False)
158        self.grid_subwindow = self._workspace.workspace.addSubWindow(self.grid_window)
159        self.grid_subwindow.setVisible(False)
160        self.grid_window.windowClosedSignal.connect(lambda: self.grid_subwindow.setVisible(False))
161
162        self.results_panel = ResultPanel(parent=self._parent, manager=self)
163        self.results_frame = self._workspace.workspace.addSubWindow(self.results_panel)
164        self.results_frame.setVisible(False)
165        self.results_panel.windowClosedSignal.connect(lambda: self.results_frame.setVisible(False))
166
167        self._workspace.toolBar.setVisible(LocalConfig.TOOLBAR_SHOW)
168        self._workspace.actionHide_Toolbar.setText("Show Toolbar")
169
170        # Add calculators - floating for usability
171        self.SLDCalculator = SldPanel(self)
172        self.DVCalculator = DensityPanel(self)
173        self.KIESSIGCalculator = KiessigPanel(self)
174        self.SlitSizeCalculator = SlitSizeCalculator(self)
175        self.GENSASCalculator = GenericScatteringCalculator(self)
176        self.ResolutionCalculator = ResolutionCalculatorPanel(self)
177        self.DataOperation = DataOperationUtilityPanel(self)
178
179    def addCategories(self):
180        """
181        Make sure categories.json exists and if not compile it and install in ~/.sasview
182        """
183        try:
184            from sas.sascalc.fit.models import ModelManager
185            from sas.qtgui.Utilities.CategoryInstaller import CategoryInstaller
186            model_list = ModelManager().cat_model_list()
187            CategoryInstaller.check_install(model_list=model_list)
188        except Exception:
189            import traceback
190            logger.error("%s: could not load SasView models")
191            logger.error(traceback.format_exc())
192
193    def updateLogContextMenus(self, visible=False):
194        """
195        Modify the View/Data Explorer menu item text on widget visibility
196        """
197        if visible:
198            self._workspace.actionHide_LogExplorer.setText("Hide Log Explorer")
199        else:
200            self._workspace.actionHide_LogExplorer.setText("Show Log Explorer")
201
202    def updateContextMenus(self, visible=False):
203        """
204        Modify the View/Data Explorer menu item text on widget visibility
205        """
206        if visible:
207            self._workspace.actionHide_DataExplorer.setText("Hide Data Explorer")
208        else:
209            self._workspace.actionHide_DataExplorer.setText("Show Data Explorer")
210
211    def statusBarSetup(self):
212        """
213        Define the status bar.
214        | <message label> .... | Progress Bar |
215
216        Progress bar invisible until explicitly shown
217        """
218        self.progress = QProgressBar()
219        self._workspace.statusbar.setSizeGripEnabled(False)
220
221        self.statusLabel = QLabel()
222        self.statusLabel.setText("Welcome to SasView")
223        self._workspace.statusbar.addPermanentWidget(self.statusLabel, 1)
224        self._workspace.statusbar.addPermanentWidget(self.progress, stretch=0)
225        self.progress.setRange(0, 100)
226        self.progress.setValue(0)
227        self.progress.setTextVisible(True)
228        self.progress.setVisible(False)
229
230    def fileWasRead(self, data):
231        """
232        Callback for fileDataReceivedSignal
233        """
234        pass
235
236    def showHelp(self, url):
237        """
238        Open a local url in the default browser
239        """
240        GuiUtils.showHelp(url)
241
242    def workspace(self):
243        """
244        Accessor for the main window workspace
245        """
246        return self._workspace.workspace
247
248    def perspectiveChanged(self, perspective_name):
249        """
250        Respond to change of the perspective signal
251        """
252        # Close the previous perspective
253        self.clearPerspectiveMenubarOptions(self._current_perspective)
254        if self._current_perspective:
255            self._current_perspective.setClosable()
256            self._current_perspective.close()
257            self._workspace.workspace.removeSubWindow(self._current_perspective)
258        # Default perspective
259        self._current_perspective = Perspectives.PERSPECTIVES[str(perspective_name)](parent=self)
260
261        self.setupPerspectiveMenubarOptions(self._current_perspective)
262
263        subwindow = self._workspace.workspace.addSubWindow(self._current_perspective)
264
265        # Resize to the workspace height
266        workspace_height = self._workspace.workspace.sizeHint().height()
267        perspective_size = self._current_perspective.sizeHint()
268        perspective_width = perspective_size.width()
269        self._current_perspective.resize(perspective_width, workspace_height-10)
270
271        self._current_perspective.show()
272
273    def updatePerspective(self, data):
274        """
275        Update perspective with data sent.
276        """
277        assert isinstance(data, list)
278        if self._current_perspective is not None:
279            self._current_perspective.setData(list(data.values()))
280        else:
281            msg = "No perspective is currently active."
282            logging.info(msg)
283
284    def communicator(self):
285        """ Accessor for the communicator """
286        return self.communicate
287
288    def perspective(self):
289        """ Accessor for the perspective """
290        return self._current_perspective
291
292    def updateProgressBar(self, value):
293        """
294        Update progress bar with the required value (0-100)
295        """
296        assert -1 <= value <= 100
297        if value == -1:
298            self.progress.setVisible(False)
299            return
300        if not self.progress.isVisible():
301            self.progress.setTextVisible(True)
302            self.progress.setVisible(True)
303
304        self.progress.setValue(value)
305
306    def updateStatusBar(self, text):
307        """
308        Set the status bar text
309        """
310        self.statusLabel.setText(text)
311
312    def appendLog(self, msg):
313        """Appends a message to the list widget in the Log Explorer. Use this
314        instead of listWidget.insertPlainText() to facilitate auto-scrolling"""
315        self.listWidget.append(msg.strip())
316
317    def createGuiData(self, item, p_file=None):
318        """
319        Access the Data1D -> plottable Data1D conversion
320        """
321        return self._data_manager.create_gui_data(item, p_file)
322
323    def setData(self, data):
324        """
325        Sends data to current perspective
326        """
327        if self._current_perspective is not None:
328            self._current_perspective.setData(list(data.values()))
329        else:
330            msg = "Guiframe does not have a current perspective"
331            logging.info(msg)
332
333    def findItemFromFilename(self, filename):
334        """
335        Queries the data explorer for the index corresponding to the filename within
336        """
337        return self.filesWidget.itemFromFilename(filename)
338
339    def quitApplication(self):
340        """
341        Close the reactor and exit nicely.
342        """
343        # Display confirmation messagebox
344        quit_msg = "Are you sure you want to exit the application?"
345        reply = QMessageBox.question(
346            self._parent,
347            'Information',
348            quit_msg,
349            QMessageBox.Yes,
350            QMessageBox.No)
351
352        # Exit if yes
353        if reply == QMessageBox.Yes:
354            reactor.callFromThread(reactor.stop)
355            return True
356
357        return False
358
359    def checkUpdate(self):
360        """
361        Check with the deployment server whether a new version
362        of the application is available.
363        A thread is started for the connecting with the server. The thread calls
364        a call-back method when the current version number has been obtained.
365        """
366        version_info = {"version": "0.0.0"}
367        c = ConnectionProxy(LocalConfig.__update_URL__, LocalConfig.UPDATE_TIMEOUT)
368        response = c.connect()
369        if response is None:
370            return
371        try:
372            content = response.read().strip()
373            logging.info("Connected to www.sasview.org. Latest version: %s"
374                            % (content))
375            version_info = json.loads(content)
376            self.processVersion(version_info)
377        except ValueError as ex:
378            logging.info("Failed to connect to www.sasview.org:", ex)
379
380    def processVersion(self, version_info):
381        """
382        Call-back method for the process of checking for updates.
383        This methods is called by a VersionThread object once the current
384        version number has been obtained. If the check is being done in the
385        background, the user will not be notified unless there's an update.
386
387        :param version: version string
388        """
389        try:
390            version = version_info["version"]
391            if version == "0.0.0":
392                msg = "Could not connect to the application server."
393                msg += " Please try again later."
394                self.communicate.statusBarUpdateSignal.emit(msg)
395
396            elif version.__gt__(LocalConfig.__version__):
397                msg = "Version %s is available! " % str(version)
398                if "download_url" in version_info:
399                    webbrowser.open(version_info["download_url"])
400                else:
401                    webbrowser.open(LocalConfig.__download_page__)
402                self.communicate.statusBarUpdateSignal.emit(msg)
403            else:
404                msg = "You have the latest version"
405                msg += " of %s" % str(LocalConfig.__appname__)
406                self.communicate.statusBarUpdateSignal.emit(msg)
407        except:
408            msg = "guiframe: could not get latest application"
409            msg += " version number\n  %s" % sys.exc_info()[1]
410            logging.error(msg)
411            msg = "Could not connect to the application server."
412            msg += " Please try again later."
413            self.communicate.statusBarUpdateSignal.emit(msg)
414
415    def actionWelcome(self):
416        """ Show the Welcome panel """
417        self.welcomePanel = WelcomePanel()
418        self._workspace.workspace.addSubWindow(self.welcomePanel)
419        self.welcomePanel.show()
420
421    def showWelcomeMessage(self):
422        """ Show the Welcome panel, when required """
423        # Assure the welcome screen is requested
424        show_welcome_widget = True
425        custom_config = get_custom_config()
426        if hasattr(custom_config, "WELCOME_PANEL_SHOW"):
427            if isinstance(custom_config.WELCOME_PANEL_SHOW, bool):
428                show_welcome_widget = custom_config.WELCOME_PANEL_SHOW
429            else:
430                logging.warning("WELCOME_PANEL_SHOW has invalid value in custom_config.py")
431        if show_welcome_widget:
432            self.actionWelcome()
433
434    def addCallbacks(self):
435        """
436        Method defining all signal connections for the gui manager
437        """
438        self.communicate = GuiUtils.Communicate()
439        self.communicate.fileDataReceivedSignal.connect(self.fileWasRead)
440        self.communicate.statusBarUpdateSignal.connect(self.updateStatusBar)
441        self.communicate.updatePerspectiveWithDataSignal.connect(self.updatePerspective)
442        self.communicate.progressBarUpdateSignal.connect(self.updateProgressBar)
443        self.communicate.perspectiveChangedSignal.connect(self.perspectiveChanged)
444        self.communicate.updateTheoryFromPerspectiveSignal.connect(self.updateTheoryFromPerspective)
445        self.communicate.deleteIntermediateTheoryPlotsSignal.connect(self.deleteIntermediateTheoryPlotsByModelID)
446        self.communicate.plotRequestedSignal.connect(self.showPlot)
447        self.communicate.plotFromFilenameSignal.connect(self.showPlotFromFilename)
448        self.communicate.updateModelFromDataOperationPanelSignal.connect(self.updateModelFromDataOperationPanel)
449
450    def addTriggers(self):
451        """
452        Trigger definitions for all menu/toolbar actions.
453        """
454        # disable not yet fully implemented actions
455        self._workspace.actionUndo.setVisible(False)
456        self._workspace.actionRedo.setVisible(False)
457        self._workspace.actionReset.setVisible(False)
458        self._workspace.actionStartup_Settings.setVisible(False)
459        self._workspace.actionImage_Viewer.setVisible(False)
460        self._workspace.actionCombine_Batch_Fit.setVisible(False)
461        # orientation viewer set to invisible SASVIEW-1132
462        self._workspace.actionOrientation_Viewer.setVisible(False)
463
464        # File
465        self._workspace.actionLoadData.triggered.connect(self.actionLoadData)
466        self._workspace.actionLoad_Data_Folder.triggered.connect(self.actionLoad_Data_Folder)
467        self._workspace.actionOpen_Project.triggered.connect(self.actionOpen_Project)
468        self._workspace.actionOpen_Analysis.triggered.connect(self.actionOpen_Analysis)
469        self._workspace.actionSave.triggered.connect(self.actionSave_Project)
470        self._workspace.actionSave_Analysis.triggered.connect(self.actionSave_Analysis)
471        self._workspace.actionQuit.triggered.connect(self.actionQuit)
472        # Edit
473        self._workspace.actionUndo.triggered.connect(self.actionUndo)
474        self._workspace.actionRedo.triggered.connect(self.actionRedo)
475        self._workspace.actionCopy.triggered.connect(self.actionCopy)
476        self._workspace.actionPaste.triggered.connect(self.actionPaste)
477        self._workspace.actionReport.triggered.connect(self.actionReport)
478        self._workspace.actionReset.triggered.connect(self.actionReset)
479        self._workspace.actionExcel.triggered.connect(self.actionExcel)
480        self._workspace.actionLatex.triggered.connect(self.actionLatex)
481        # View
482        self._workspace.actionShow_Grid_Window.triggered.connect(self.actionShow_Grid_Window)
483        self._workspace.actionHide_Toolbar.triggered.connect(self.actionHide_Toolbar)
484        self._workspace.actionStartup_Settings.triggered.connect(self.actionStartup_Settings)
485        self._workspace.actionCategory_Manager.triggered.connect(self.actionCategory_Manager)
486        self._workspace.actionHide_DataExplorer.triggered.connect(self.actionHide_DataExplorer)
487        self._workspace.actionHide_LogExplorer.triggered.connect(self.actionHide_LogExplorer)
488        # Tools
489        self._workspace.actionData_Operation.triggered.connect(self.actionData_Operation)
490        self._workspace.actionSLD_Calculator.triggered.connect(self.actionSLD_Calculator)
491        self._workspace.actionDensity_Volume_Calculator.triggered.connect(self.actionDensity_Volume_Calculator)
492        self._workspace.actionKeissig_Calculator.triggered.connect(self.actionKiessig_Calculator)
493        #self._workspace.actionKIESSING_Calculator.triggered.connect(self.actionKIESSING_Calculator)
494        self._workspace.actionSlit_Size_Calculator.triggered.connect(self.actionSlit_Size_Calculator)
495        self._workspace.actionSAS_Resolution_Estimator.triggered.connect(self.actionSAS_Resolution_Estimator)
496        self._workspace.actionGeneric_Scattering_Calculator.triggered.connect(self.actionGeneric_Scattering_Calculator)
497        self._workspace.actionPython_Shell_Editor.triggered.connect(self.actionPython_Shell_Editor)
498        self._workspace.actionImage_Viewer.triggered.connect(self.actionImage_Viewer)
499        self._workspace.actionOrientation_Viewer.triggered.connect(self.actionOrientation_Viewer)
500        self._workspace.actionFreeze_Theory.triggered.connect(self.actionFreeze_Theory)
501        # Fitting
502        self._workspace.actionNew_Fit_Page.triggered.connect(self.actionNew_Fit_Page)
503        self._workspace.actionConstrained_Fit.triggered.connect(self.actionConstrained_Fit)
504        self._workspace.actionCombine_Batch_Fit.triggered.connect(self.actionCombine_Batch_Fit)
505        self._workspace.actionFit_Options.triggered.connect(self.actionFit_Options)
506        self._workspace.actionGPU_Options.triggered.connect(self.actionGPU_Options)
507        self._workspace.actionFit_Results.triggered.connect(self.actionFit_Results)
508        self._workspace.actionAdd_Custom_Model.triggered.connect(self.actionAdd_Custom_Model)
509        self._workspace.actionEdit_Custom_Model.triggered.connect(self.actionEdit_Custom_Model)
510        self._workspace.actionManage_Custom_Models.triggered.connect(self.actionManage_Custom_Models)
511        self._workspace.actionAddMult_Models.triggered.connect(self.actionAddMult_Models)
512        self._workspace.actionEditMask.triggered.connect(self.actionEditMask)
513
514        # Window
515        self._workspace.actionCascade.triggered.connect(self.actionCascade)
516        self._workspace.actionTile.triggered.connect(self.actionTile)
517        self._workspace.actionArrange_Icons.triggered.connect(self.actionArrange_Icons)
518        self._workspace.actionNext.triggered.connect(self.actionNext)
519        self._workspace.actionPrevious.triggered.connect(self.actionPrevious)
520        self._workspace.actionClosePlots.triggered.connect(self.actionClosePlots)
521        # Analysis
522        self._workspace.actionFitting.triggered.connect(self.actionFitting)
523        self._workspace.actionInversion.triggered.connect(self.actionInversion)
524        self._workspace.actionInvariant.triggered.connect(self.actionInvariant)
525        self._workspace.actionCorfunc.triggered.connect(self.actionCorfunc)
526        # Help
527        self._workspace.actionDocumentation.triggered.connect(self.actionDocumentation)
528        self._workspace.actionTutorial.triggered.connect(self.actionTutorial)
529        self._workspace.actionAcknowledge.triggered.connect(self.actionAcknowledge)
530        self._workspace.actionAbout.triggered.connect(self.actionAbout)
531        self._workspace.actionWelcomeWidget.triggered.connect(self.actionWelcome)
532        self._workspace.actionCheck_for_update.triggered.connect(self.actionCheck_for_update)
533
534        self.communicate.sendDataToGridSignal.connect(self.showBatchOutput)
535        self.communicate.resultPlotUpdateSignal.connect(self.showFitResults)
536
537    #============ FILE =================
538    def actionLoadData(self):
539        """
540        Menu File/Load Data File(s)
541        """
542        self.filesWidget.loadFile()
543
544    def actionLoad_Data_Folder(self):
545        """
546        Menu File/Load Data Folder
547        """
548        self.filesWidget.loadFolder()
549
550    def actionOpen_Project(self):
551        """
552        Menu Open Project
553        """
554        self.filesWidget.loadProject()
555
556    def actionOpen_Analysis(self):
557        """
558        """
559        self.filesWidget.loadAnalysis()
560        pass
561
562    def actionSave_Project(self):
563        """
564        Menu Save Project
565        """
566        filename = self.filesWidget.saveProject()
567
568        # datasets
569        all_data = self.filesWidget.getAllData()
570
571        # fit tabs
572        params = self.perspective().serializeAllFitpage()
573
574        # project dictionary structure:
575        # analysis[data.id] = [{"fit_data":[data, checkbox, child data],
576        #                       "fit_params":[fitpage_state]}
577        # "fit_params" not present if dataset not sent to fitting
578        analysis = {}
579
580        for id, data in all_data.items():
581            if id=='is_batch':
582                analysis['is_batch'] = data
583                continue
584            data_content = {"fit_data":data}
585            if id in params.keys():
586                # this dataset is represented also by the fit tab. Add to it.
587                data_content["fit_params"] = params[id]
588            analysis[id] = data_content
589
590        with open(filename, 'w') as outfile:
591            GuiUtils.saveData(outfile, analysis)
592
593    def actionSave_Analysis(self):
594        """
595        Menu File/Save Analysis
596        """
597        per = self.perspective()
598        if not isinstance(per, FittingWindow):
599            return
600        # get fit page serialization
601        params = per.serializeCurrentFitpage()
602        data_id = per.currentTabDataId()
603        tab_id = per.currentTab.tab_id
604        data = self.filesWidget.getDataForID(data_id)
605        analysis = {}
606        analysis['fit_data'] = data
607        analysis['fit_params'] = params
608
609        self.filesWidget.saveAnalysis(analysis, tab_id)
610
611        pass
612
613    def actionQuit(self):
614        """
615        Close the reactor, exit the application.
616        """
617        self.quitApplication()
618
619    #============ EDIT =================
620    def actionUndo(self):
621        """
622        """
623        print("actionUndo TRIGGERED")
624        pass
625
626    def actionRedo(self):
627        """
628        """
629        print("actionRedo TRIGGERED")
630        pass
631
632    def actionCopy(self):
633        """
634        Send a signal to the fitting perspective so parameters
635        can be saved to the clipboard
636        """
637        self.communicate.copyFitParamsSignal.emit("")
638        self._workspace.actionPaste.setEnabled(True)
639        pass
640
641    def actionPaste(self):
642        """
643        Send a signal to the fitting perspective so parameters
644        from the clipboard can be used to modify the fit state
645        """
646        self.communicate.pasteFitParamsSignal.emit()
647
648    def actionReport(self):
649        """
650        Show the Fit Report dialog.
651        """
652        report_list = None
653        if getattr(self._current_perspective, "currentTab"):
654            try:
655                report_list = self._current_perspective.currentTab.getReport()
656            except Exception as ex:
657                logging.error("Report generation failed with: " + str(ex))
658
659        if report_list is not None:
660            self.report_dialog = ReportDialog(parent=self, report_list=report_list)
661            self.report_dialog.show()
662
663    def actionReset(self):
664        """
665        """
666        logging.warning(" *** actionOpen_Analysis logging *******")
667        print("actionReset print TRIGGERED")
668        sys.stderr.write("STDERR - TRIGGERED")
669        pass
670
671    def actionExcel(self):
672        """
673        Send a signal to the fitting perspective so parameters
674        can be saved to the clipboard
675        """
676        self.communicate.copyExcelFitParamsSignal.emit("Excel")
677
678    def actionLatex(self):
679        """
680        Send a signal to the fitting perspective so parameters
681        can be saved to the clipboard
682        """
683        self.communicate.copyLatexFitParamsSignal.emit("Latex")
684
685    #============ VIEW =================
686    def actionShow_Grid_Window(self):
687        """
688        """
689        self.showBatchOutput(None)
690
691    def showBatchOutput(self, output_data):
692        """
693        Display/redisplay the batch fit viewer
694        """
695        self.grid_subwindow.setVisible(True)
696        if output_data:
697            self.grid_window.addFitResults(output_data)
698
699    def actionHide_Toolbar(self):
700        """
701        Toggle toolbar vsibility
702        """
703        if self._workspace.toolBar.isVisible():
704            self._workspace.actionHide_Toolbar.setText("Show Toolbar")
705            self._workspace.toolBar.setVisible(False)
706        else:
707            self._workspace.actionHide_Toolbar.setText("Hide Toolbar")
708            self._workspace.toolBar.setVisible(True)
709        pass
710
711    def actionHide_DataExplorer(self):
712        """
713        Toggle Data Explorer vsibility
714        """
715        if self.dockedFilesWidget.isVisible():
716            self.dockedFilesWidget.setVisible(False)
717        else:
718            self.dockedFilesWidget.setVisible(True)
719        pass
720
721    def actionHide_LogExplorer(self):
722        """
723        Toggle Data Explorer vsibility
724        """
725        if self.logDockWidget.isVisible():
726            self.logDockWidget.setVisible(False)
727        else:
728            self.logDockWidget.setVisible(True)
729        pass
730
731    def actionStartup_Settings(self):
732        """
733        """
734        print("actionStartup_Settings TRIGGERED")
735        pass
736
737    def actionCategory_Manager(self):
738        """
739        """
740        self.categoryManagerWidget.show()
741
742    #============ TOOLS =================
743    def actionData_Operation(self):
744        """
745        """
746        self.communicate.sendDataToPanelSignal.emit(self._data_manager.get_all_data())
747
748        self.DataOperation.show()
749
750    def actionSLD_Calculator(self):
751        """
752        """
753        self.SLDCalculator.show()
754
755    def actionDensity_Volume_Calculator(self):
756        """
757        """
758        self.DVCalculator.show()
759
760    def actionKiessig_Calculator(self):
761        """
762        """
763        self.KIESSIGCalculator.show()
764
765    def actionSlit_Size_Calculator(self):
766        """
767        """
768        self.SlitSizeCalculator.show()
769
770    def actionSAS_Resolution_Estimator(self):
771        """
772        """
773        try:
774            self.ResolutionCalculator.show()
775        except Exception as ex:
776            logging.error(str(ex))
777            return
778
779    def actionGeneric_Scattering_Calculator(self):
780        """
781        """
782        try:
783            self.GENSASCalculator.show()
784        except Exception as ex:
785            logging.error(str(ex))
786            return
787
788    def actionPython_Shell_Editor(self):
789        """
790        Display the Jupyter console as a docked widget.
791        """
792        # Import moved here for startup performance reasons
793        from sas.qtgui.Utilities.IPythonWidget import IPythonWidget
794        terminal = IPythonWidget()
795
796        # Add the console window as another docked widget
797        self.ipDockWidget = QDockWidget("IPython", self._workspace)
798        self.ipDockWidget.setObjectName("IPythonDockWidget")
799        self.ipDockWidget.setWidget(terminal)
800        self._workspace.addDockWidget(Qt.RightDockWidgetArea, self.ipDockWidget)
801
802    def actionFreeze_Theory(self):
803        """
804        Convert a child index with data into a separate top level dataset
805        """
806        self.filesWidget.freezeCheckedData()
807
808    def actionOrientation_Viewer(self):
809        """
810        Make sasmodels orientation & jitter viewer available
811        """
812        from sasmodels.jitter import run as orientation_run
813        try:
814            orientation_run()
815        except Exception as ex:
816            logging.error(str(ex))
817
818    def actionImage_Viewer(self):
819        """
820        """
821        print("actionImage_Viewer TRIGGERED")
822        pass
823
824    #============ FITTING =================
825    def actionNew_Fit_Page(self):
826        """
827        Add a new, empty Fit page in the fitting perspective.
828        """
829        # Make sure the perspective is correct
830        per = self.perspective()
831        if not isinstance(per, FittingWindow):
832            return
833        per.addFit(None)
834
835    def actionConstrained_Fit(self):
836        """
837        Add a new Constrained and Simult. Fit page in the fitting perspective.
838        """
839        per = self.perspective()
840        if not isinstance(per, FittingWindow):
841            return
842        per.addConstraintTab()
843
844    def actionCombine_Batch_Fit(self):
845        """
846        """
847        print("actionCombine_Batch_Fit TRIGGERED")
848        pass
849
850    def actionFit_Options(self):
851        """
852        """
853        if getattr(self._current_perspective, "fit_options_widget"):
854            self._current_perspective.fit_options_widget.show()
855        pass
856
857    def actionGPU_Options(self):
858        """
859        Load the OpenCL selection dialog if the fitting perspective is active
860        """
861        if hasattr(self._current_perspective, "gpu_options_widget"):
862            self._current_perspective.gpu_options_widget.show()
863        pass
864
865    def actionFit_Results(self):
866        """
867        """
868        self.showFitResults(None)
869
870    def showFitResults(self, output_data):
871        """
872        Show bumps convergence plots
873        """
874        self.results_frame.setVisible(True)
875        if output_data:
876            self.results_panel.onPlotResults(output_data, optimizer=self.perspective().optimizer)
877
878    def actionAdd_Custom_Model(self):
879        """
880        """
881        self.model_editor = TabbedModelEditor(self)
882        self.model_editor.show()
883
884    def actionEdit_Custom_Model(self):
885        """
886        """
887        self.model_editor = TabbedModelEditor(self, edit_only=True)
888        self.model_editor.show()
889
890    def actionManage_Custom_Models(self):
891        """
892        """
893        self.model_manager = PluginManager(self)
894        self.model_manager.show()
895
896    def actionAddMult_Models(self):
897        """
898        """
899        # Add Simple Add/Multiply Editor
900        self.add_mult_editor = AddMultEditor(self)
901        self.add_mult_editor.show()
902
903    def actionEditMask(self):
904
905        self.communicate.extMaskEditorSignal.emit()
906
907    #============ ANALYSIS =================
908    def actionFitting(self):
909        """
910        Change to the Fitting perspective
911        """
912        self.perspectiveChanged("Fitting")
913        # Notify other widgets
914        self.filesWidget.onAnalysisUpdate("Fitting")
915
916    def actionInversion(self):
917        """
918        Change to the Inversion perspective
919        """
920        self.perspectiveChanged("Inversion")
921        self.filesWidget.onAnalysisUpdate("Inversion")
922
923    def actionInvariant(self):
924        """
925        Change to the Invariant perspective
926        """
927        self.perspectiveChanged("Invariant")
928        self.filesWidget.onAnalysisUpdate("Invariant")
929
930    def actionCorfunc(self):
931        """
932        Change to the Corfunc perspective
933        """
934        self.perspectiveChanged("Corfunc")
935        self.filesWidget.onAnalysisUpdate("Corfunc")
936
937    #============ WINDOW =================
938    def actionCascade(self):
939        """
940        Arranges all the child windows in a cascade pattern.
941        """
942        self._workspace.workspace.cascadeSubWindows()
943
944    def actionTile(self):
945        """
946        Tile workspace windows
947        """
948        self._workspace.workspace.tileSubWindows()
949
950    def actionArrange_Icons(self):
951        """
952        Arranges all iconified windows at the bottom of the workspace
953        """
954        self._workspace.workspace.arrangeIcons()
955
956    def actionNext(self):
957        """
958        Gives the input focus to the next window in the list of child windows.
959        """
960        self._workspace.workspace.activateNextSubWindow()
961
962    def actionPrevious(self):
963        """
964        Gives the input focus to the previous window in the list of child windows.
965        """
966        self._workspace.workspace.activatePreviousSubWindow()
967
968    def actionClosePlots(self):
969        """
970        Closes all Plotters and Plotter2Ds.
971        """
972        self.filesWidget.closeAllPlots()
973        pass
974
975    #============ HELP =================
976    def actionDocumentation(self):
977        """
978        Display the documentation
979
980        TODO: use QNetworkAccessManager to assure _helpLocation is valid
981        """
982        helpfile = "/index.html"
983        self.showHelp(helpfile)
984
985    def actionTutorial(self):
986        """
987        Open the tutorial PDF file with default PDF renderer
988        """
989        # Not terribly safe here. Shell injection warning.
990        # isfile() helps but this probably needs a better solution.
991        if os.path.isfile(self._tutorialLocation):
992            result = subprocess.Popen([self._tutorialLocation], shell=True)
993
994    def actionAcknowledge(self):
995        """
996        Open the Acknowledgements widget
997        """
998        self.ackWidget.show()
999
1000    def actionAbout(self):
1001        """
1002        Open the About box
1003        """
1004        # Update the about box with current version and stuff
1005
1006        # TODO: proper sizing
1007        self.aboutWidget.show()
1008
1009    def actionCheck_for_update(self):
1010        """
1011        Menu Help/Check for Update
1012        """
1013        self.checkUpdate()
1014
1015    def updateTheoryFromPerspective(self, index):
1016        """
1017        Catch the theory update signal from a perspective
1018        Send the request to the DataExplorer for updating the theory model.
1019        """
1020        self.filesWidget.updateTheoryFromPerspective(index)
1021
1022    def deleteIntermediateTheoryPlotsByModelID(self, model_id):
1023        """
1024        Catch the signal to delete items in the Theory item model which correspond to a model ID.
1025        Send the request to the DataExplorer for updating the theory model.
1026        """
1027        self.filesWidget.deleteIntermediateTheoryPlotsByModelID(model_id)
1028
1029    def updateModelFromDataOperationPanel(self, new_item, new_datalist_item):
1030        """
1031        :param new_item: item to be added to list of loaded files
1032        :param new_datalist_item:
1033        """
1034        if not isinstance(new_item, QStandardItem) or \
1035                not isinstance(new_datalist_item, dict):
1036            msg = "Wrong data type returned from calculations."
1037            raise AttributeError(msg)
1038
1039        self.filesWidget.model.appendRow(new_item)
1040        self._data_manager.add_data(new_datalist_item)
1041
1042    def showPlotFromFilename(self, filename):
1043        """
1044        Pass the show plot request to the data explorer
1045        """
1046        if hasattr(self, "filesWidget"):
1047            self.filesWidget.displayFile(filename=filename, is_data=True)
1048
1049    def showPlot(self, plot, id):
1050        """
1051        Pass the show plot request to the data explorer
1052        """
1053        if hasattr(self, "filesWidget"):
1054            self.filesWidget.displayData(plot, id)
1055
1056    def uncheckAllMenuItems(self, menuObject):
1057        """
1058        Uncheck all options in a given menu
1059        """
1060        menuObjects = menuObject.actions()
1061
1062        for menuItem in menuObjects:
1063            menuItem.setChecked(False)
1064
1065    def checkAnalysisOption(self, analysisMenuOption):
1066        """
1067        Unchecks all the items in the analysis menu and checks the item passed
1068        """
1069        self.uncheckAllMenuItems(self._workspace.menuAnalysis)
1070        analysisMenuOption.setChecked(True)
1071
1072    def clearPerspectiveMenubarOptions(self, perspective):
1073        """
1074        When closing a perspective, clears the menu bar
1075        """
1076        for menuItem in self._workspace.menuAnalysis.actions():
1077            menuItem.setChecked(False)
1078
1079        if isinstance(self._current_perspective, Perspectives.PERSPECTIVES["Fitting"]):
1080            self._workspace.menubar.removeAction(self._workspace.menuFitting.menuAction())
1081
1082    def setupPerspectiveMenubarOptions(self, perspective):
1083        """
1084        When setting a perspective, sets up the menu bar
1085        """
1086        self._workspace.actionReport.setEnabled(False)
1087        self._workspace.actionOpen_Analysis.setEnabled(False)
1088        self._workspace.actionSave_Analysis.setEnabled(False)
1089        if hasattr(perspective, 'isSerializable') and perspective.isSerializable():
1090            self._workspace.actionOpen_Analysis.setEnabled(True)
1091            self._workspace.actionSave_Analysis.setEnabled(True)
1092
1093        if isinstance(perspective, Perspectives.PERSPECTIVES["Fitting"]):
1094            self.checkAnalysisOption(self._workspace.actionFitting)
1095            # Put the fitting menu back in
1096            # This is a bit involved but it is needed to preserve the menu ordering
1097            self._workspace.menubar.removeAction(self._workspace.menuWindow.menuAction())
1098            self._workspace.menubar.removeAction(self._workspace.menuHelp.menuAction())
1099            self._workspace.menubar.addAction(self._workspace.menuFitting.menuAction())
1100            self._workspace.menubar.addAction(self._workspace.menuWindow.menuAction())
1101            self._workspace.menubar.addAction(self._workspace.menuHelp.menuAction())
1102            self._workspace.actionReport.setEnabled(True)
1103
1104        elif isinstance(perspective, Perspectives.PERSPECTIVES["Invariant"]):
1105            self.checkAnalysisOption(self._workspace.actionInvariant)
1106        elif isinstance(perspective, Perspectives.PERSPECTIVES["Inversion"]):
1107            self.checkAnalysisOption(self._workspace.actionInversion)
1108        elif isinstance(perspective, Perspectives.PERSPECTIVES["Corfunc"]):
1109            self.checkAnalysisOption(self._workspace.actionCorfunc)
Note: See TracBrowser for help on using the repository browser.