Exemple #1
0
    def __init__(self, program_dir, home_dir):
        """
        **Properties**:
       
            *_program_dir* (string):
                The path to this program. It has to end with the top-level directory swan.
            *_CACHEDIR* (string):
                The default path of the cache directory.
            *_currentdirty* (boolean):
                Whether or not the current (virtual unit) mapping is dirty because of changes.
            *_globaldirty* (boolean):
                Whether or not one or more (virtual unit) mappings are dirty.
            *_preferences* (dictionary):
                A dictionary containing all preferences in (key, value) pairs.
                The dictionary will be loaded at program start or set to default values.
            *_PREFS* (dictionary):
                The preferences dictionary containing the default values.
            *_prodir* (string):
                The path where the project files will be written to by default.
            *_mystorage* (:class:`stg.mystorage.MyStorage`):
                The class which handles the data and the project files.
        
        """
        QtGui.QMainWindow.__init__(self)
        self.ui = Ui_Main()
        self.ui.setupUi(self)
        
        #properties{
        self._program_dir = program_dir
        self._CACHEDIR = join(program_dir, "cache") 
        self._currentdirty = False
        self._globaldirty = False
        self._preferences = None
        self._PREFS =       {   "defaultProName":"swan.txt",
                                "zinStep":24,
                                "cacheDir":self._CACHEDIR,
                                "zoutStep":24,
                                "expandStep":5,
                                "collapseStep":5,
                                }
        self._prodir = join(home_dir)
        
        #preferences have to be present for the storage.
        self.load_preferences()
        
        self._mystorage = MyStorage(program_dir, self._preferences["cacheDir"])
        #}
        self.setWindowTitle(title)

        #for the virtual unit overview
        self.vu = VUnits()
        self.vu.setWindowTitle("Virtual Units")

        #connect channel selection
        self.ui.selector.doChannel.connect(self.do_channel)
        #connect layer selection
        self.ui.layers.doLayer.connect(self.plot_all)
        #connect unit selection
        self.ui.units.doUnits.connect(self.plot_all)
        #connect view change
        self.ui.views.currentChanged.connect(self.check_layers)
        #connect loading progress
        self._mystorage.progress.connect(self.setProgress)
        self.ui.view_2.progress.connect(self.setProgress)
        #connect progress bar showing/hiding
        self.ui.view_2.progressBar.connect(self.showProgressBar)
        #connect redraw signal of the views
        self.ui.view_4.redraw.connect(self.plot_all)
        self.vu.redraw.connect(self.plot_all)
        #connect channel loading
        self.vu.load.connect(self.load_channel)
        
        #setting the horizontal widgets with equal sizes
        self.ui.splitter_2.setSizes([int(self.ui.splitter_2.width()/2) for i in xrange(2)])
        
        #shortcut reference
        self.plots = self.ui.plotGrid.child
        self.selector = self.ui.selector
        
        self.load_icons()
        self.check_dirs()
        
        self.check_layers(self.ui.views.currentIndex())
        
        #setting up the progress bar
        self.p = QtGui.QProgressBar()
        self.p.setRange(0, 100)
        self.p.setValue(0)
        self.ui.statusbar.addPermanentWidget(self.p)
        self.p.hide()

        if onLinux:
            #starting memory usage task
            timer = QtCore.QTimer(self)
            self.timer = timer
            self.memorytask = MemoryTask(timer, self.ui.statusbar)
            self.memorytask.start()
Exemple #2
0
class Main(QtGui.QMainWindow):
    """
    This is the main window.
    
    It is the parent widget of all other widgets and closing it quits
    the application.
    
    This class has methods to handle the user actions either by itself or
    by delegating to the child widgets.
    
    **Arguments:**
    
        *program_dir* (string):
            The directory in which the program is located. It has to end with the top-level directory swan.
        *home_dir* (string):
            The directory where the project files will be written to by default.
            If you didn't execute *run.py* with an additional argument this will be your home directory. 
            Otherwise it will be the one you gave as an argument.
    
    """

    def __init__(self, program_dir, home_dir):
        """
        **Properties**:
       
            *_program_dir* (string):
                The path to this program. It has to end with the top-level directory swan.
            *_CACHEDIR* (string):
                The default path of the cache directory.
            *_currentdirty* (boolean):
                Whether or not the current (virtual unit) mapping is dirty because of changes.
            *_globaldirty* (boolean):
                Whether or not one or more (virtual unit) mappings are dirty.
            *_preferences* (dictionary):
                A dictionary containing all preferences in (key, value) pairs.
                The dictionary will be loaded at program start or set to default values.
            *_PREFS* (dictionary):
                The preferences dictionary containing the default values.
            *_prodir* (string):
                The path where the project files will be written to by default.
            *_mystorage* (:class:`stg.mystorage.MyStorage`):
                The class which handles the data and the project files.
        
        """
        QtGui.QMainWindow.__init__(self)
        self.ui = Ui_Main()
        self.ui.setupUi(self)
        
        #properties{
        self._program_dir = program_dir
        self._CACHEDIR = join(program_dir, "cache") 
        self._currentdirty = False
        self._globaldirty = False
        self._preferences = None
        self._PREFS =       {   "defaultProName":"swan.txt",
                                "zinStep":24,
                                "cacheDir":self._CACHEDIR,
                                "zoutStep":24,
                                "expandStep":5,
                                "collapseStep":5,
                                }
        self._prodir = join(home_dir)
        
        #preferences have to be present for the storage.
        self.load_preferences()
        
        self._mystorage = MyStorage(program_dir, self._preferences["cacheDir"])
        #}
        self.setWindowTitle(title)

        #for the virtual unit overview
        self.vu = VUnits()
        self.vu.setWindowTitle("Virtual Units")

        #connect channel selection
        self.ui.selector.doChannel.connect(self.do_channel)
        #connect layer selection
        self.ui.layers.doLayer.connect(self.plot_all)
        #connect unit selection
        self.ui.units.doUnits.connect(self.plot_all)
        #connect view change
        self.ui.views.currentChanged.connect(self.check_layers)
        #connect loading progress
        self._mystorage.progress.connect(self.setProgress)
        self.ui.view_2.progress.connect(self.setProgress)
        #connect progress bar showing/hiding
        self.ui.view_2.progressBar.connect(self.showProgressBar)
        #connect redraw signal of the views
        self.ui.view_4.redraw.connect(self.plot_all)
        self.vu.redraw.connect(self.plot_all)
        #connect channel loading
        self.vu.load.connect(self.load_channel)
        
        #setting the horizontal widgets with equal sizes
        self.ui.splitter_2.setSizes([int(self.ui.splitter_2.width()/2) for i in xrange(2)])
        
        #shortcut reference
        self.plots = self.ui.plotGrid.child
        self.selector = self.ui.selector
        
        self.load_icons()
        self.check_dirs()
        
        self.check_layers(self.ui.views.currentIndex())
        
        #setting up the progress bar
        self.p = QtGui.QProgressBar()
        self.p.setRange(0, 100)
        self.p.setValue(0)
        self.ui.statusbar.addPermanentWidget(self.p)
        self.p.hide()

        if onLinux:
            #starting memory usage task
            timer = QtCore.QTimer(self)
            self.timer = timer
            self.memorytask = MemoryTask(timer, self.ui.statusbar)
            self.memorytask.start()
        
        #self.showMaximized()
        
        
    #### action handler ####
    
    ### menu:File ###
    
    @QtCore.pyqtSlot(bool)
    def on_action_New_Project_triggered(self):
        """
        This method is called if you click on *File->New Project*.
        
        Shows a :class:`src.file_dialog.File_Dialog` to choose files and after accepting it creates a
        new project. The project consists of two files. One is a .txt file which contains
        the data file paths and the other one is a .vum file which contains
        the :class:`src.virtualunitmap.VirtualUnitMap`.
        
        The default names for the files are swan.txt and swan_vum.vum.
        If they already exist, they will be changed to swan(1).txt and swan(1)_vum.vum.
        If they exist, too, the number in the brackets will be incremented until the files
        don't exist.
        
        You can choose another default name in the preferences. 
        Look at :class:`src.preferences_dialog.Preferences_Dialog` for more. 
        
        """
        self.dirty_project()
        
        dia = File_Dialog()
        if dia.exec_():
            files = dia.get_files()
            files.sort()
            
            channel = self._mystorage.get_channel()
            
            success = self._mystorage.load_project(self._prodir, self._preferences["defaultProName"], channel, files)
            
            if success and self.do_channel(self._mystorage.get_channel(), self._mystorage.get_last_channel()):
                filesStr = self._mystorage.get_files(True)
                #setting filelist detail
                self.set_detail(4, filesStr)
                
                self.save_project()
                self.update_project()
                self.reset_dirty()
                self.selector.select_only(self._mystorage.get_channel())
                self.set_status("Created new project successfully.")
            else:
                self.set_status("No files given. Nothing loaded.")
                
    @QtCore.pyqtSlot(bool)
    def on_action_Load_Project_triggered(self):
        """
        This method is called if you click on *File->Load Project*.
        
        You have to choose a .txt project file which contains correct paths to the data files.
        Loads the project by reading the .txt file and the .vum file.
        
        """
        self.dirty_project()
        filename = str(QtGui.QFileDialog.getOpenFileName(self, QtCore.QString("Choose the file which includes the absolute paths"), QtCore.QString(self._prodir)))
        if filename:
            (prodir, proname) = split(filename)
            
            channel = self._mystorage.get_channel()
            
            success = self._mystorage.load_project(prodir, proname, channel)
                       
            if success and self.do_channel(self._mystorage.get_channel(), self._mystorage.get_last_channel()):
                filesStr = self._mystorage.get_files(True)
                #setting filelist detail
                self.set_detail(4, filesStr)   
                
                self.save_project()
                self.update_project()
                self.reset_dirty()
                self.selector.select_only(self._mystorage.get_channel())             
                self.set_status("Loaded project successfully.")
            else:
                self.set_status("No files given. Nothing loaded.")
    
    @QtCore.pyqtSlot(bool)
    def on_action_Save_Project_triggered(self):
        """
        This method is called if you click on *File->Save Project*.
        
        Works like :func:`on_action_Save_as_triggered()` but without asking you to type in a save name.
        
        """
        if self.check_project():
            self.save_project()
                
    @QtCore.pyqtSlot(bool)
    def on_action_Save_as_triggered(self):
        """
        This method is called if you click on *File->Save as*.
        
        Saves your project under a new name by showing you a dialog 
        where you can type the new project name (the one with the .txt extension).
        After that your loaded files will be written into that file
        (the absolute path to the files) so that you can later load them.
        
        The :class:`src.virtualunitmap.VirtualUnitMap` will be saved to 
        the file with the .vum extension.
        
        """
        if self.check_project():
            filename = str(QtGui.QFileDialog.getSaveFileName(self, QtCore.QString("Choose a savename"), QtCore.QString(self._prodir)))
            if filename:
                self._mystorage.save_project_as(filename)
                self.update_project()
                self.save_project()
                
    @QtCore.pyqtSlot(bool)
    def on_action_Load_connector_map_triggered(self):
        """
        This method is called if you click on *File->Load connector map*.
        
        Loads a connector map given as a .csv file.
        
        Delegates the loading to :func:`load_connector_map`.
        
        """
        filename = str(QtGui.QFileDialog.getOpenFileName(self, "Choose a file", self._prodir))
        try:
            self.load_connector_map(filename)
        except ValueError:
            QtGui.QMessageBox.critical(self, "Loading error", "The connector map could not be loaded")

    @QtCore.pyqtSlot(bool)
    def on_action_Export_to_csv_triggered(self):
        """
        This method is called if you click on *File->Export to csv*.

        Exports the virtual unit mappings to a csv file.

        """
        filename = str(QtGui.QFileDialog.getSaveFileName(self, QtCore.QString("Choose a savename"), QtCore.QString(self._prodir)))
        if filename:
            try:
                if filename.endswith(".csv"):
                    filename = filename[:-4]
                Export.export_csv(filename, self._mystorage.load_map())
            except IOError:
                QtGui.QMessageBox.critical(self, "Export error", "The virtual unit maps could not be exported")

    @QtCore.pyqtSlot(bool)
    def on_action_Export_to_odML_triggered(self):
        """
        This method is called if you click on *File->Export to odML*.

        Exports the virtual unit mappings to an odML file.

        """
        filename = str(QtGui.QFileDialog.getSaveFileName(self, QtCore.QString("Choose a savename"), QtCore.QString(self._prodir)))
        if filename:
            try:
                if filename.endswith(".odml"):
                    filename = filename[:-5]
                Export.export_odml(filename, self._mystorage.load_map())
            except IOError:
                QtGui.QMessageBox.critical(self, "Export error", "The virtual unit maps could not be exported")

    def closeEvent(self, event):
        """
        This method is called if you click on *File->Quit*.
        
        Quits the application.
        If there are unsaved mappings, you will have a chance to save them.
        
        The event will be always accepted.
        
        **Arguments**
        
            *event* (:class:`PyQt4.QtCore.QEvent`)
        """
        self.dirty_project()
        event.accept()
        
    ### menu:Edit ###
    
    @QtCore.pyqtSlot(bool)
    def on_action_Recalculate_mapping_triggered(self):
        """
        This method is called if you click on *Edit->Recalculate mapping*.
        
        Delegates the calculating to another class. Updates the overview.
        
        See :func:`src.mystorage.MyStorage.recalculate`.
        
        """
        if self._mystorage.has_project():
            answer = QtGui.QMessageBox.question(self, "Recalculate mapping", "Are you sure you want to do this?", 
                                                QtGui.QMessageBox.Yes | QtGui.QMessageBox.No, 
                                                defaultButton=QtGui.QMessageBox.No)
            
            if answer == QtGui.QMessageBox.Yes:
                self._mystorage.recalculate()
                self._currentdirty = True
                self._globaldirty = True
                self.plot_all()
                
    @QtCore.pyqtSlot(bool)
    def on_action_Revert_mapping_triggered(self):
        """
        This method is called if you click on *Edit->Revert mapping*.
        
        Delegates the reverting to another class. Updates the overview.
        
        See :func:`src.mystorage.MyStorage.revert`.
        
        """
        if self._mystorage.has_project():
            answer = QtGui.QMessageBox.question(self, "Revert mapping", "Are you sure you want to do this?", 
                                                QtGui.QMessageBox.Yes | QtGui.QMessageBox.No, 
                                                defaultButton=QtGui.QMessageBox.No)
            
            if answer == QtGui.QMessageBox.Yes:
                self._mystorage.revert()
                self.reset_current_dirty()
                self.plot_all()
    
    @QtCore.pyqtSlot(bool)
    def on_action_Swap_triggered(self):
        """
        This method is called if you click on *Edit->Swap*.
        
        Swaps two plots if two are selected.
        Otherwise nothing will happen.
        
        The swapping itself is done somewhere else.
        
        See :func:`src.mystorage.MyStorage.swap`.
        
        """
        plots = self.plots.get_selection()
        if len(plots) == 2: 
            #get the positions
            p1 = plots[0]
            p2 = plots[1]
            m = p1.pos[1]
            n1 = p1.pos[0]
            n2 = p2.pos[0]
            
            #swapping
            self._mystorage.swap(m, n1, n2)
            self.plot_all()
            self.plots.reset_selection()

            #setting tooltips
            self.plots.set_tooltips(self._mystorage.get_tooltips())
            
            self._currentdirty = True
            self._globaldirty = True
            
    @QtCore.pyqtSlot(bool)
    def on_action_Zoom_in_triggered(self):
        """
        This method is called if you click on *Edit->Zoom in*.
        
        Zooms the overview in. The zoom step can be set in the preferences.
        
        See :class:`src.preferences_dialog.Preferences_Dialog`.
        
        """
        self.plots.zoom_in(self._preferences["zinStep"])

    @QtCore.pyqtSlot(bool)
    def on_action_Zoom_out_triggered(self):
        """
        This method is called if you click on *Edit->Zoom out*.
        
        Zooms the overview out. The zoom step can be set in the preferences.
        
        See :class:`src.preferences_dialog.Preferences_Dialog`.
        
        """
        self.plots.zoom_out(self._preferences["zoutStep"])
    
    @QtCore.pyqtSlot(bool)    
    def on_action_Expand_overview_triggered(self):
        """
        This method is called if you click on *Edit->Expand overview*.
        
        Increases the y range of the plots in the overview.
        The step can be set in the preferences.
        
        See :class:`src.preferences_dialog.Preferences_Dialog`.
        
        """
        self.plots.expand(self._preferences["expandStep"])

    @QtCore.pyqtSlot(bool)    
    def on_action_Collapse_overview_triggered(self):
        """
        This method is called if you click on *Edit->Collapse overview*.
        
        Decreases the y range of the plots in the overview.
        The step can be set in the preferences.
        
        See :class:`src.preferences_dialog.Preferences_Dialog`.
        
        """
        self.plots.collapse(self._preferences["collapseStep"])
        
    @QtCore.pyqtSlot(bool)    
    def on_action_Preferences_triggered(self):
        """
        This method is called if you click on *Edit->Preferences*.
        
        Shows you a :class:`src.preferences_dialog.Preferences_Dialog`
        to view and change the preferences.
        
        """
        dia = Preferences_Dialog(self._preferences.copy(), self._PREFS.copy())
        if dia.exec_():
            pref = dia.get_preferences()
            self._preferences = pref
            self.save_preferences()
            self._mystorage.set_cache_dir(pref["cacheDir"])

    ### menu:View ###

    @QtCore.pyqtSlot(bool)
    def on_action_Virtual_Units_triggered(self):
        """
        This method is called if you click on *View->Virtual units*.

        Shows an overview for the virtual units.

        """
        self.vu.show()
            
    ### menu:Help ###
    
    @QtCore.pyqtSlot(bool)
    def on_action_Tutorials_triggered(self):
        """
        This method is called if you click on *Help->Tutorials*.
        
        Shows you tutorials and help for this application.
        
        """
        p = join(self._program_dir, "doc", "build", "html", "tutorial.html")
        d = "file://" + p
        web.open_new_tab(d)
    
    @QtCore.pyqtSlot(bool)
    def on_action_About_triggered(self):
        """
        This method is called if you click on *Help->About*.
        
        Shows you information about the application.
        
        """
        QtGui.QMessageBox.information(self, "About", about)
    
    
    #### signal handler ####
    
    def do_channel(self, channel, lastchannel):
        """
        Loads the data from the given electrode and plots it.
        
        **Arguments**
        
            *channel* (integer):
                The electrode channel that will be loaded.
            *lastchannel* (integer):
                The channel that was loaded before.
        
            **Returns**: boolean
                Whether or not there was something to load for the electrode.
        
        """
        if self._mystorage.has_project() and not self._mystorage.is_loading() and not self.ui.view_2.isLoading:
            #initialize the progress bar
            self.p.setValue(0)
            self.p.show()
            
            self.check_cache()
            
            #let the user know that loading can be take some time
            if onLinux:
                self.memorytask.stop_timer()
            self.set_status("Loading ... This may take a while ...", 0)
                        
            QtGui.QApplication.setOverrideCursor(QtGui.QCursor(QtCore.Qt.WaitCursor))
            
            #checking if the last channel's mapping was dirty
            if self._currentdirty:
                self.selector.set_dirty(lastchannel, True)
                self._currentdirty = False
            
            #loading            
            (n, m) = self._mystorage.load_channel(channel)
            
            self.ui.units.init_units(n)

            #deactivate loading the movie data for performance reasons
            self.ui.view_2.shouldLoad = False
            
            #reset the data of the movie
            self.ui.view_2.reset()

            #plotting
            self.plots.make_plots(n, m)
            data = self._mystorage.get_data()
            min0, max0 = data.get_yscale()
            self.plots.set_yranges(min0, max0)
            self.ui.view_2.set_range(min0, max0)
            self.plot_all()
            
            #setting channel detail
            self.set_detail(3, str(channel))
            
            #setting tooltips
            self.plots.set_tooltips(self._mystorage.get_tooltips())
            
            self.p.hide()
            QtGui.QApplication.restoreOverrideCursor()
            if onLinux:
                self.memorytask.start_timer()
            return True
        elif self._mystorage.is_loading() or self.ui.view_2.isLoading:
            self.selector.select_only(self._mystorage.get_channel())
        return False
    
    def plot_all(self, i=None, visible=None):
        """
        Plots everything that has to be plotted.
        
        It is possible to make a row in 
        the :class:`src.virtualunitmap.VirtualUnitMap` (un)visible 
        by passing extra arguments.
        This method is called every time something has to be plotted or updated.
        
        **Arguments**
        
            *i* (integer or None):
                The index of the row you want to make invisible.
                Default: None
            *visible* (boolean or None):
                Whether or not the row given by i should be visible.
                Default: None
        
        """
        if self._mystorage.has_project():
            QtGui.QApplication.setOverrideCursor(QtGui.QCursor(QtCore.Qt.WaitCursor))
            
            vum = self._mystorage.get_map()
            data = self._mystorage.get_data()
            vum_all = self._mystorage.get_mappings()

            if i is not None and visible is not None :
                vum.set_visible(i, visible)
            
            l1 = ["average", "standard deviation"]
            l2 = ["units-ISI", "session-ISI"]
            
            #plotting
            #plots: pyqtgraph plotwidget overview
            self.plots.do_plot(vum, data)
            #view_1: 2D mpl plot
            self.ui.view_1.do_plot(vum, data, self.ui.layers.get_checked_layers(l1))
            #view_2: mpl movie plot
            #setting the data instead of plotting something because the plotting
            #will be managed at another place
            self.ui.view_2.set_data(vum, data)
            #view_3: 3D mpl plot
            self.ui.view_3.do_plot(vum, data, self.ui.layers.get_checked_layers(l1))
            #view_4: ISI mpl plot
            self.ui.view_4.do_plot(vum, data, self.ui.layers.get_checked_layers(l2))
            #vu: Virtual unit overview
            self.vu.do_plot(vum_all, data)

            QtGui.QApplication.restoreOverrideCursor()
            
    def check_layers(self, i):
        """
        Checks if there are layers to hide for the current view.
        
        **Arguments**
        
            *i* (integer):
                The current view's index.
        
        """
        l1 = ["average", "standard deviation"]
        l2 = ["units-ISI", "session-ISI"]
        if i == 0:
            #view_1: 2D mpl plot
            self.ui.layers.enable_layers(False, self.ui.layers.get_layers())
            self.ui.layers.enable_layers(True, l1)
        elif i == 1:
            #view_2: mpl movie plot
            self.ui.layers.enable_layers(False, self.ui.layers.get_layers())        
        elif i == 2:
            #view_3: 3D mpl plot
            self.ui.layers.enable_layers(False, self.ui.layers.get_layers())
            self.ui.layers.enable_layers(True, l1)
        elif i == 3:
            #view_4: ISI mpl plot
            self.ui.layers.enable_layers(False, self.ui.layers.get_layers())
            self.ui.layers.enable_layers(True, l2)            
            
    def setProgress(self, i):
        """
        Sets the progress in the status bar.

        **Arguments**
                
            *i* (integer):
                The value to be set.
        
        """
        self.p.setValue(i)
        
    def showProgressBar(self, show):
        """
        Shows or hides the progress bar.

        **Arguments**
                
            *show* (boolean):
                Whether or not the progress bar should be shown.
        
        """
        if show:
            self.p.show()
        else:
            self.p.hide()

    def load_channel(self, channel):
        """
        Loads a channel.

        This method is connected to the load signal of the
        :class:`src.VUnits` class.

        **Arguments**

            *channel* (integer):
                The channel to load.

        """
        item = self.selector.get_item(channel)
        if item is not None:
            if item.selectable:
                self.selector.select_channel(item, channel)
                self.selector.select_only(channel)
            

    #### general methods ####
    
    def dirty_project(self):
        """
        Lets you save your project before losing your progress.
        
        Shows you a confirmation dialog and if you accept, the project
        will be saved.
        
        """
        if self._globaldirty:
            answer = QtGui.QMessageBox.question(self, QtCore.QString("Confirmation"), 
                                                QtCore.QString("There are changes to be lost.\nDo you want to save your project first?"),
                                                buttons = QtGui.QMessageBox.Discard | QtGui.QMessageBox.Yes,
                                                defaultButton = QtGui.QMessageBox.Yes)
            if answer == QtGui.QMessageBox.Yes:
                self.on_action_Save_Project_triggered()
                
    def update_project(self):
        """
        Updates the project data like the project name and the directory.
        Shows the changed values in the details tab.
        
        """
        if self._mystorage.has_project():
            (prodir, proname) = split(self._mystorage.get_project_path())
            vumname = basename(self._mystorage.get_map_path())
            #setting project details
            self.set_detail(0, proname)
            self.set_detail(1, prodir)
            self.set_detail(2, vumname)
         
    def check_project(self):
        """
        Checks if there is currently a project loaded.
         
            **Returns**: boolean
                Whether or not there is a project loaded.
         
        """
        if not self._mystorage.has_project():
            QtGui.QMessageBox.warning(self, QtCore.QString("Error"), QtCore.QString("No project loaded."))
            return False
        else:
            return True
        
    def save_project(self):
        """
        Saves the project.
        
        See :func:`src.mystorage.MyStorage.save_project`.
        
        """
        self._mystorage.save_project()
        self.reset_dirty()
        self.set_status("Saved project successfully")
        
    def reset_dirty(self):
        """
        Resets the project to a not dirty state.
        
        """
        self._currentdirty = False
        self._globaldirty = False
        self.selector.reset_dirty()

    def reset_current_dirty(self):
        """
        Resets the current channel.

        """
        self._currentdirty = False
        self.selector.set_dirty(self._mystorage.get_channel(), False)
        if len(self.selector.get_dirty_channels()) == 0:
            self._globaldirty = False

    def set_detail(self, i, value):
        """
        Sets a detail in the details tab.
        
        **Arguments**
        
            *i* (integer):
                The index of the detail.
            *value* (string):
                The value that should be shown.
        
        """
        self.ui.details.item(i, 0).setText(value)
        
    def check_dirs(self):
        """
        Checks if all directories exist which are needed by the program.
        If not, they will be created.
        
        """
        data_dir = join(self._program_dir, "data")
        if not isdir(data_dir):
            mkdir(data_dir)
        self.check_cache()
    
    def check_cache(self):
        """
        Checks if the cache directory exists.
        If not, it will be created.
        
        """
        if not isdir(self._preferences["cacheDir"]):
            mkdir(self._preferences["cacheDir"])
            
    def load_icons(self):
        """
        Loads the icons.
        
        """
        try:
            prefix = ":" + sep + "icons" + sep
            #File
            icon = QtGui.QIcon()
            icon.addPixmap(QtGui.QPixmap(prefix + "new.png"), QtGui.QIcon.Normal, QtGui.QIcon.Off)
            self.ui.action_New_Project.setIcon(icon)
            icon = QtGui.QIcon()
            icon.addPixmap(QtGui.QPixmap(prefix + "open.png"), QtGui.QIcon.Normal, QtGui.QIcon.Off)
            self.ui.action_Load_Project.setIcon(icon)
            icon = QtGui.QIcon()
            icon.addPixmap(QtGui.QPixmap(prefix + "save.png"), QtGui.QIcon.Normal, QtGui.QIcon.Off)
            self.ui.action_Save_Project.setIcon(icon)
            icon = QtGui.QIcon()
            icon.addPixmap(QtGui.QPixmap(prefix + "save_as.png"), QtGui.QIcon.Normal, QtGui.QIcon.Off)
            self.ui.action_Save_as.setIcon(icon)
            #Edit
            icon = QtGui.QIcon()
            icon.addPixmap(QtGui.QPixmap(prefix + "revert.png"), QtGui.QIcon.Normal, QtGui.QIcon.Off)
            self.ui.action_Revert_mapping.setIcon(icon)
            icon = QtGui.QIcon()
            icon.addPixmap(QtGui.QPixmap(prefix + "swap.png"), QtGui.QIcon.Normal, QtGui.QIcon.Off)
            self.ui.action_Swap.setIcon(icon)
            icon = QtGui.QIcon()
            icon.addPixmap(QtGui.QPixmap(prefix + "zoom_in.png"), QtGui.QIcon.Normal, QtGui.QIcon.Off)
            self.ui.action_Zoom_in.setIcon(icon)
            icon = QtGui.QIcon()
            icon.addPixmap(QtGui.QPixmap(prefix + "zoom_out.png"), QtGui.QIcon.Normal, QtGui.QIcon.Off)
            self.ui.action_Zoom_out.setIcon(icon)
            icon = QtGui.QIcon()
            icon.addPixmap(QtGui.QPixmap(prefix + "expand.png"), QtGui.QIcon.Normal, QtGui.QIcon.Off)
            self.ui.action_Expand_overview.setIcon(icon)
            icon = QtGui.QIcon()
            icon.addPixmap(QtGui.QPixmap(prefix + "collapse.png"), QtGui.QIcon.Normal, QtGui.QIcon.Off)
            self.ui.action_Collapse_overview.setIcon(icon)
            icon = QtGui.QIcon()
            icon.addPixmap(QtGui.QPixmap(prefix + "preferences.png"), QtGui.QIcon.Normal, QtGui.QIcon.Off)
            self.ui.action_Preferences.setIcon(icon)
        except:
            pass
        
    def load_connector_map(self, filename):
        """
        Loads a connector map given as a .csv file.
        
        The file has to contain two columns. The first will be ignored but must exist
        (e.g. the numbers 1-100) and the other one has to contain the mapped channel numbers.
        Choose **,** as delimiter.
        
        **Arguments**
        
            *filename* (string):
                The csv file to load.
        
            **Raises**: :class:`ValueError`
                If the connector map could not be loaded.
                
        """
        if filename:
            delimiter = ','
            try:
                with open(filename, "rb") as fn:
                    channel_list = []
                    reader = csv.reader(fn, delimiter=delimiter)
                    for row in reader:
                        #just read the second column
                        channel_list.append(int(row[1]))
                
                channels = self.selector.get_dirty_channels()
               
                #overwrite existing mapping
                self.selector.set_channels(channel_list)
                self.selector.reset_sel()
                self.selector.reset_dirty()
                
                #the dirty channels and the selected one has to be set again
                for channel in channels:
                    self.selector.set_dirty(channel, True)
                
                self.selector.select_only(self._mystorage.get_channel())
            except:
                raise ValueError
        
    def load_preferences(self):
        """
        Loads the preferences from the preferences file.
        If it doesn't exist, defaults are used.
        
        """
        name = join(self._program_dir, "data", "preferences.pkl")
        if exists(name):
            prefs = pkl.load(open(name, "rb"))
            self._preferences = prefs
        else:
            self._preferences = self._PREFS.copy()
    
    def save_preferences(self):
        """
        Writes the preferences to a file.
        
        """
        name = join(self._program_dir, "data", "preferences.pkl")
        with open(name, "wb") as fn:
            pkl.dump(self._preferences, fn)
        
    def set_status(self, content, duration=5000):
        """
        Shows a message in the status bar for a given duration.
        
        **Arguments**
        
            *content* (string):
                The message.
            *duration* (integer):
                The duration in ms.
                Default: 5000 
        
        """
        self.ui.statusbar.showMessage(QtCore.QString(content), duration)