def buildMenu(self):
        menu = self._menu
        menu.clear()

        # Add action to remove bookmark
        action = menu.addAction(translate("filebrowser", "Remove project"))
        action._id = "remove"
        action.setCheckable(False)

        # Add action to change name
        action = menu.addAction(translate("filebrowser", "Change project name"))
        action._id = "name"
        action.setCheckable(False)

        menu.addSeparator()

        # Add check action for adding to Pythonpath
        action = menu.addAction(translate("filebrowser", "Add path to Python path"))
        action._id = "pythonpath"
        action.setCheckable(True)
        d = self.currentDict()
        if d:
            checked = bool(d and d["addToPythonpath"])
            action.setChecked(checked)

        # Add action to cd to the project directory
        action = menu.addAction(translate("filebrowser", "Go to this directory in the current shell"))
        action._id = "cd"
        action.setCheckable(False)

    def __init__(self):
        QtWidgets.QWizardPage.__init__(self)
        
        self.setTitle(translate('importwizard', 'Select file'))
        
        self.txtFilename = QtWidgets.QLineEdit()
        self.btnBrowse = QtWidgets.QPushButton(translate('importwizard', 'Browse...'))
        self.preview = QtWidgets.QPlainTextEdit()
        self.preview.setReadOnly(True)

        vlayout = QtWidgets.QVBoxLayout()
        hlayout = QtWidgets.QHBoxLayout()

        
        hlayout.addWidget(self.txtFilename)
        hlayout.addWidget(self.btnBrowse)
        vlayout.addLayout(hlayout)
        vlayout.addWidget(QtWidgets.QLabel(translate('importwizard', 'Preview:')))
        vlayout.addWidget(self.preview)
        
        self.setLayout(vlayout)
        
        self.registerField('fname', self.txtFilename)
        
        self.btnBrowse.clicked.connect(self.onBrowseClicked)
        self.txtFilename.editingFinished.connect(self.updatePreview)
        self._isComplete = False

 def _duplicateOrRename(self, rename):
     
     # Get dirname and filename
     dirname, filename = os.path.split(self._item.path())
     
     # Get title and label
     if rename:
         title = translate("filebrowser", "Rename")
         label = translate("filebrowser", "Give the new name for the file")
     else:
         title = translate("filebrowser", "Duplicate")
         label = translate("filebrowser", "Give the name for the new file")
         filename = 'Copy of ' + filename
     
     # Ask for new filename
     s = QtGui.QInputDialog.getText(self.parent(), title,
                 label + ':\n%s' % self._item.path(),
                 QtGui.QLineEdit.Normal,
                 filename
             )
     if isinstance(s, tuple):
         s = s[0] if s[1] else ''
     
     # Push rename task
     if s:
         newpath = os.path.join(dirname, s)
         task = tasks.RenameTask(newpath=newpath, removeold=rename)
         self._item._proxy.pushTask(task)

    def onMenuTriggered(self, action):
        d = self.currentDict()
        if not d:
            return

        if action._id == "remove":
            # Remove this project
            self.parent().removeStarredDir(d.path)

        elif action._id == "name":
            # Open dialog to ask for name
            name = QtGui.QInputDialog.getText(
                self.parent(),
                translate("filebrowser", "Project name"),
                translate("filebrowser", "New project name:"),
                text=d["name"],
            )
            if isinstance(name, tuple):
                name = name[0] if name[1] else ""
            if name:
                d["name"] = name
            self.updateProjectList()

        elif action._id == "pythonpath":
            # Flip add-to-pythonpath flag
            d["addToPythonpath"] = not d["addToPythonpath"]

        elif action._id == "cd":
            # cd to the directory
            shell = pyzo.shells.getCurrentShell()
            if shell:
                shell.executeCommand("cd " + d.path + "\n")

    def buildMenu(self):
        menu = self._menu
        menu.clear()
        
        # Add action to remove bookmark
        action = menu.addAction(translate('filebrowser', 'Remove project'))
        action._id = 'remove'
        action.setCheckable(False)
        
        # Add action to change name
        action = menu.addAction(translate('filebrowser', 'Change project name'))
        action._id = 'name'
        action.setCheckable(False)
        
        menu.addSeparator()
        
        # Add check action for adding to Pythonpath
        action = menu.addAction(translate('filebrowser', 'Add path to Python path'))
        action._id = 'pythonpath'
        action.setCheckable(True)
        d = self.currentDict()
        if d:
            checked = bool( d and d['addToPythonpath'] )
            action.setChecked(checked)

        # Add action to cd to the project directory
        action = menu.addAction(translate('filebrowser', 'Go to this directory in the current shell'))
        action._id = 'cd'
        action.setCheckable(False)

 def __init__(self, parent, distro=None):
     QtWidgets.QWidget.__init__(self, parent)
     self.setMinimumSize(360, 256)  # Ensure title fits nicely
     
     # Create label widget and costumize
     self._label = QtWidgets.QLabel(self)
     self._label.setTextFormat(QtCore.Qt.RichText)
     self._label.setOpenExternalLinks(True)
     self._label.setWordWrap(True)
     self._label.setMargin(20)
     
     # Set font size (absolute value)
     font = self._label.font()
     font.setPointSize(11)  #(font.pointSize()+1)
     self._label.setFont(font)
     
     # Build
     text_title = translate('splash', 'This is <b>Pyzo</b><br />the Python IDE for scientific computing')
     text_version = translate('splash', 'Version')
     text_os = translate('splash', 'Pyzo is open source software and freely available for everyone.')
     text = splash_text.format(version=pyzo.__version__,
                               text_title=text_title, text_version=text_version, text_os=text_os)
     
     # Set text
     self._label.setText(text)
     
     layout = QtWidgets.QVBoxLayout(self)
     self.setLayout(layout)
     layout.addStretch(1)
     layout.addWidget(self._label, 0)
     layout.addStretch(1)

 def onMenuTriggered(self, action):
     d = self.currentDict()
     if not d:
         return
     
     if action._id == 'remove':
         # Remove this project
         self.parent().removeStarredDir(d.path)
     
     elif action._id == 'name':
         # Open dialog to ask for name
         name = QtWidgets.QInputDialog.getText(self.parent(),
                             translate('filebrowser', 'Project name'),
                             translate('filebrowser', 'New project name:'),
                             text=d['name'],
                         )
         if isinstance(name, tuple):
             name = name[0] if name[1] else ''
         if name:
             d['name'] = name
         self.updateProjectList()
     
     elif action._id == 'pythonpath':
         # Flip add-to-pythonpath flag
         d['addToPythonpath'] = not d['addToPythonpath']
 
     elif action._id == 'cd':
         # cd to the directory
         shell = pyzo.shells.getCurrentShell()
         if shell:
             shell.executeCommand('cd '+d.path+'\n')

 def onLanguageChange(self):
     languageName = self._langBox.currentText()        
     if pyzo.config.settings.language == languageName:
         return
     # Save new language
     pyzo.config.settings.language = languageName
     setLanguage(pyzo.config.settings.language)
     # Notify user
     text = translate('wizard', """
     The language has been changed for this wizard.
     Pyzo needs to restart for the change to take effect application-wide.
     """)
     m = QtWidgets.QMessageBox(self)
     m.setWindowTitle(translate("wizard", "Language changed"))
     m.setText(text)
     m.setIcon(m.Information)
     m.exec_()
     
     # Get props of current wizard
     geo = self.wizard().geometry()
     parent = self.wizard().parent()
     # Close ourself!        
     self.wizard().close()
     # Start new one
     w = PyzoWizard(parent)
     w.setGeometry(geo)
     w.show()

 def onBtnExecuteClicked(self):
     shell = pyzo.shells.getCurrentShell()
     if shell is None:
         QtWidgets.QMessageBox.information(self, 
             translate('importwizard', 'Import data wizard'),
             translate('importwizard', 'No current shell active'))
         return
         
     shell.executeCode(self.getCode(), 'importwizard')

 def onDelete(self):
     # Ask for new filename
     b = QtGui.QMessageBox.question(self.parent(), 
                 translate("filebrowser", "Delete"), 
                 translate("filebrowser", "Are you sure that you want to delete") + 
                 ':\n%s' % self._item.path(),
                 QtGui.QMessageBox.Yes | QtGui.QMessageBox.Cancel,
             )       
     # Push delete task
     if b is QtGui.QMessageBox.Yes:            
         self._item._proxy.pushTask(tasks.RemoveTask())

    def open(self, filename):
        if self.isVisible():
            QtWidgets.QMessageBox.information(self, 
                translate('importwizard', 'Import data wizard'),
                translate('importwizard', 'The import data wizard is already open'))
            return

        self.restart()
        self.selectFilePage.txtFilename.setText(filename)
        self.selectFilePage.updatePreview()
        self.show()

 def __init__(self, parent = None):
     super().__init__(parent)
     
     # Widgets
     self._search = QtWidgets.QLineEdit(self)
     self._list = QtWidgets.QListWidget(self)
     
     # Set monospace
     font = self._list.font()
     font.setFamily(pyzo.config.view.fontname)
     self._list.setFont(font)
     
     # Layout
     layout = QtWidgets.QVBoxLayout(self)
     self.setLayout(layout)
     layout.addWidget(self._search, 0)
     layout.addWidget(self._list, 1)
     
     # Customize line edit
     self._search.setPlaceholderText(translate('menu', 'Search'))
     self._search.textChanged.connect(self._on_search)
     
     # Drag/drop
     self._list.setSelectionMode(self._list.ExtendedSelection)
     self._list.setDragEnabled(True)
     self._list.doubleClicked.connect(self._onDoubleClicked)
     
     # Context menu
     self._menu = Menu(self, translate("menu", "History"))
     self._menu.addItem(translate("menu", "Copy ::: Copy selected lines"),
         pyzo.icons.page_white_copy, self.copy, "copy")
     self._menu.addItem(translate("menu", "Run ::: Run selected lines in current shell"),
         pyzo.icons.run_lines, self.runSelection, "run")
     self._menu.addItem(translate("menu", "Remove ::: Remove selected history items(s)"),
         pyzo.icons.delete, self.removeSelection, "remove")
     
     self._list.setContextMenuPolicy(QtCore.Qt.CustomContextMenu)
     self._list.customContextMenuRequested.connect(self._onCustomContextMenuRequested)
     
     # Populate
     for command in pyzo.command_history.get_commands():
         self._list.addItem(command)
     
     # Scroll to end of list on start up
     self._list.setCurrentRow(self._list.count()-1)
     item = self._list.currentItem()
     self._list.scrollToItem(item)
     
     # Keep up to date ...
     pyzo.command_history.command_added.connect(self._on_command_added)
     pyzo.command_history.command_removed.connect(self._on_command_removed)
     pyzo.command_history.commands_reset.connect(self._on_commands_reset)

 def __init__(self, parent, config, path=None):
     QtWidgets.QWidget.__init__(self, parent)
     
     # Store config
     self.config = config
     
     # Create star button
     self._projects = Projects(self)
     
     # Create path input/display lineEdit
     self._pathEdit = PathInput(self)
     
     # Create file system proxy
     self._fsProxy = proxies.NativeFSProxy()
     self.destroyed.connect(self._fsProxy.stop)
     
     # Create tree widget
     self._tree = Tree(self)
     self._tree.setPath(cleanpath(self.config.path))
     
     # Create name filter
     self._nameFilter = NameFilter(self)
     #self._nameFilter.lineEdit().setToolTip('File filter pattern')
     self._nameFilter.setToolTip(translate('filebrowser', 'Filename filter'))
     self._nameFilter.setPlaceholderText(self._nameFilter.toolTip())
     
     # Create search filter
     self._searchFilter = SearchFilter(self)
     self._searchFilter.setToolTip(translate('filebrowser', 'Search in files'))
     self._searchFilter.setPlaceholderText(self._searchFilter.toolTip())
     
     # Signals to sync path.
     # Widgets that can change the path transmit signal to _tree
     self._pathEdit.dirUp.connect(self._tree.setFocus)
     self._pathEdit.dirUp.connect(self._tree.setPathUp)
     self._pathEdit.dirChanged.connect(self._tree.setPath)
     self._projects.dirChanged.connect(self._tree.setPath)
     #
     self._nameFilter.filterChanged.connect(self._tree.onChanged) # == update
     self._searchFilter.filterChanged.connect(self._tree.onChanged)
     # The tree transmits signals to widgets that need to know the path
     self._tree.dirChanged.connect(self._pathEdit.setPath)
     self._tree.dirChanged.connect(self._projects.setPath)
     
     self._layout()
     
     # Set and sync path ...
     if path is not None:
         self._tree.SetPath(path)
     self._tree.dirChanged.emit(self._tree.path())

 def updateProjectList(self):
     # Get sorted version of starredDirs
     starredDirs = self.parent().starredDirs
     starredDirs.sort(key=lambda p: p.lower())
     # Refill the combo box
     self._combo.clear()
     for p in starredDirs:
         name = self.parent().dictForStarredDir(p).name
         self._combo.addItem(name, p)
     # Insert dummy item
     if starredDirs:
         self._combo.insertItem(0, translate("filebrowser", "Projects:"), "")  # No-project item
     else:
         self._combo.addItem(translate("filebrowser", "Click star to bookmark current dir"), "")

 def updateProjectList(self):
     # Get sorted version of starredDirs
     starredDirs = self.parent().starredDirs
     starredDirs.sort(key=lambda p:self.parent().dictForStarredDir(p).name.lower())
     # Refill the combo box
     self._combo.clear()
     if starredDirs:
         self._combo.addItem(translate('filebrowser', 'Projects:'), '') # No-project item
         for p in starredDirs:
             name = self.parent().dictForStarredDir(p).name
             self._combo.addItem(name, p)
     else:
         self._combo.addItem(
             translate('filebrowser', 'Click star to bookmark current dir'), '')

 def __init__(self, parent):
     # Do not pass parent, because is a sublayout
     QtWidgets.QVBoxLayout.__init__(self)
     
     # Create sub-widget
     self._edit1 = QtWidgets.QLineEdit(parent)
     self._edit1.textEdited.connect(self.onEditChanged)
     if sys.platform.startswith('win'):
         self._edit1.setPlaceholderText('C:\\path\\to\\script.py')
     else:
         self._edit1.setPlaceholderText('/path/to/script.py')
     #
     self._edit2 = QtWidgets.QTextEdit(parent)
     self._edit2.zoomOut(1)
     self._edit2.setMaximumHeight(80)
     self._edit2.setMinimumWidth(200)
     self._edit2.textChanged.connect(self.onEditChanged)
     
     # Layout
     self.setSpacing(1)
     self.addWidget(self._edit1)
     self.addWidget(self._edit2)
     
     # Create radio widget for system default
     t = translate('shell', 'Use system default')
     self._radio_system = QtWidgets.QRadioButton(t, parent)
     self._radio_system.toggled.connect(self.onCheckChanged)
     self.addWidget(self._radio_system)
     if self.DISABLE_SYSTEM_DEFAULT:
         self._radio_system.hide()
     
     # Create radio widget for file
     t = translate('shell', 'File to run at startup')
     self._radio_file = QtWidgets.QRadioButton(t, parent)
     self._radio_file.toggled.connect(self.onCheckChanged)
     self.addWidget(self._radio_file)
     
     # Create radio widget for code
     t = translate('shell', 'Code to run at startup')
     self._radio_code = QtWidgets.QRadioButton(t, parent)
     self._radio_code.toggled.connect(self.onCheckChanged)
     self.addWidget(self._radio_code)
     
     # The actual value of this shell config attribute
     self._value = ''
     
     # A buffered version, so that clicking the text box does not
     # remove the value at once
     self._valueFile = ''
     self._valueCode = '\n'

 def __init__(self, fname):
     super().__init__()
     
     self._file = None
     
     try:
         filename = os.path.join(pyzo.appDataDir, fname)
         if not os.path.isfile(filename):
             open(filename, 'wt').close()
         file = self._file = open(filename, 'r+', encoding = 'utf-8')
     
         # Truncate the file to my max number of lines
         lines = file.readlines()
         if len(lines) > self.maxLines:
             lines = lines[-self.maxLines:]
             
             # move to start of file, write the last lines and truncate
             file.seek(0)
             file.writelines(lines)
             file.truncate()
         
         # Move to the end of the file for appending
         file.seek(0, 2) # 2 = relative to end
         
         self.setStringList([line.rstrip() for line in lines])
         
     except Exception as e:
         print (translate('pyzoHistoryViewer', 'An error occurred while loading the history: ' + str(e)))
         self._file = None
     
     # When data is appended for the first time, a marker will be appended first
     self._firstTime = True

 def __init__(self, parent):
     QtWidgets.QWizard.__init__(self, parent)
     
     # Set some appearance stuff
     self.setMinimumSize(600, 500)
     self.setWindowTitle(translate('wizard', 'Getting started with Pyzo'))
     self.setWizardStyle(self.ModernStyle)
     self.setButtonText(self.CancelButton, 'Stop')
     
     # Set logo
     pm = QtGui.QPixmap()
     pm.load(os.path.join(pyzo.pyzoDir, 'resources', 'appicons', 'pyzologo48.png'))
     self.setPixmap(self.LogoPixmap, pm)
     
     # Define pages
     klasses = [ IntroWizardPage, 
                 TwocomponentsWizardPage, EditorWizardPage, 
                 ShellWizardPage1, ShellWizardPage2,
                 RuncodeWizardPage1, RuncodeWizardPage2, 
                 ToolsWizardPage1, ToolsWizardPage2,
                 FinalPage]
     
     # Create pages
     self._n = len(klasses)        
     for i, klass in enumerate(klasses):
         self.addPage(klass(self, i))

def retranslate(t):
    """ To allow retranslating after selecting the language.
    """
    if hasattr(t, 'original'):
        return translate('wizard', t.original)
    else:        
        return t

 def onBtnInsertClicked(self):
     editor = pyzo.editors.getCurrentEditor()
     if editor is None:
         QtWidgets.QMessageBox.information(self, 
             translate('importwizard', 'Import data wizard'),
             translate('importwizard', 'No current file open'))
         return
     
     code = self.getCode()
     
     # Format tabs/spaces according to editor setting
     if editor.indentUsingSpaces():
         code = code.replace('\t', ' ' * editor.indentWidth())
     
     
     # insert code at start of line
     cursor = editor.textCursor()
     cursor.movePosition(cursor.StartOfBlock)
     cursor.insertText(code)