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

ESS_GUIESS_GUI_bumps_abstractionESS_GUI_iss1116ESS_GUI_openclESS_GUI_sync_sascalc
Last change on this file since a8e6394 was d9e7792, checked in by Piotr Rozyczko <piotr.rozyczko@…>, 5 years ago

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