def __initActions(self):
"""
Private method to initialize the actions.
"""
self.qFileDialogAction = E5Action(
self.tr('QFileDialog Wizard'),
self.tr('Q&FileDialog Wizard...'), 0, 0, self,
'wizards_qfiledialog')
self.qFileDialogAction.setStatusTip(self.tr('QFileDialog Wizard'))
self.qFileDialogAction.setWhatsThis(self.tr(
"""<b>QFileDialog Wizard</b>"""
"""<p>This wizard opens a dialog for entering all the parameters"""
""" needed to create a QFileDialog. The generated code is"""
""" inserted at the current cursor position.</p>"""
))
self.qFileDialogAction.triggered.connect(self.__handleQFileDialog)
self.e5FileDialogAction = E5Action(
self.tr('E5FileDialog Wizard'),
self.tr('E&5FileDialog Wizard...'), 0, 0, self,
'wizards_e5filedialog')
self.e5FileDialogAction.setStatusTip(self.tr('E5FileDialog Wizard'))
self.e5FileDialogAction.setWhatsThis(self.tr(
"""<b>E5FileDialog Wizard</b>"""
"""<p>This wizard opens a dialog for entering all the parameters"""
""" needed to create an E5FileDialog. The generated code is"""
""" inserted at the current cursor position.</p>"""
))
self.e5FileDialogAction.triggered.connect(self.__handleE5FileDialog)
self.__ui.addE5Actions(
[self.qFileDialogAction, self.e5FileDialogAction],
'wizards')
def createActions(self):
self.syncAct = E5Action(self.tr('Sync project'),
UI.PixmapCache.getIcon("sync.png"),
self.tr('Sync project'), 0, 0, self,
'project_sync')
self.syncAct.setStatusTip(
self.tr('Sync the project with a Pycom Device'))
self.syncAct.setWhatsThis(
self.tr("""<b>Sync project</b>"""
"""<p>This syncs the project files into a """
"""Pycom device.</p>"""))
self.syncAct.triggered.connect(self.__syncAct)
self.syncAct.setEnabled(False)
self.runThisAct = E5Action(self.tr('Run this code'),
UI.PixmapCache.getIcon("1rightarrow.png"),
self.tr('Run this code'), 0, 0, self,
'run_this')
self.runThisAct.setStatusTip(
self.tr('Run current code within a Pycom Device'))
self.runThisAct.setWhatsThis(
self.tr("""<b>Run this code</b>"""
"""<p>This makes the current code run into a """
"""Pycom device.</p>"""))
self.runThisAct.triggered.connect(self.__runThisAct)
self.runThisAct.setEnabled(False)
def initActions(self):
"""
Public method to generate the action objects.
"""
self.hgTransplantAct = E5Action(
self.tr('Transplant Changesets'),
UI.PixmapCache.getIcon("vcsTransplant.png"),
self.tr('Transplant Changesets'), 0, 0, self,
'mercurial_transplant')
self.hgTransplantAct.setStatusTip(
self.tr('Transplant changesets from another branch'))
self.hgTransplantAct.setWhatsThis(
self.tr(
"""<b>Transplant Changesets</b>"""
"""<p>This transplants changesets from another branch on top"""
""" of the current working directory with the log of the"""
""" original changeset.</p>"""))
self.hgTransplantAct.triggered.connect(self.__hgTransplant)
self.actions.append(self.hgTransplantAct)
self.hgTransplantContinueAct = E5Action(
self.tr('Continue Transplant Session'),
self.tr('Continue Transplant Session'), 0, 0, self,
'mercurial_transplant_continue')
self.hgTransplantContinueAct.setStatusTip(
self.tr('Continue the last transplant session after repair'))
self.hgTransplantContinueAct.setWhatsThis(
self.tr("""<b>Continue Transplant Session</b>"""
"""<p>This continues the last transplant session after"""
""" repair.</p>"""))
self.hgTransplantContinueAct.triggered.connect(
self.__hgTransplantContinue)
self.actions.append(self.hgTransplantContinueAct)
def initActions(self):
"""
Public method to generate the action objects.
"""
self.hgHisteditStartAct = E5Action(
self.tr('Start'), UI.PixmapCache.getIcon("vcsEditHistory.png"),
self.tr('Start'), 0, 0, self, 'mercurial_histedit_start')
self.hgHisteditStartAct.setStatusTip(
self.tr('Start a new changeset history editing session'))
self.hgHisteditStartAct.setWhatsThis(
self.tr(
"""<b>Start</b>"""
"""<p>This starts a new history editing session. A dialog"""
""" will be presented to modify the edit plan.</p>"""))
self.hgHisteditStartAct.triggered.connect(self.__hgHisteditStart)
self.actions.append(self.hgHisteditStartAct)
self.hgHisteditContinueAct = E5Action(self.tr('Continue'),
self.tr('Continue'), 0, 0, self,
'mercurial_histedit_continue')
self.hgHisteditContinueAct.setStatusTip(
self.tr(
'Continue an interrupted changeset history editing session'))
self.hgHisteditContinueAct.setWhatsThis(
self.
tr("""<b>Continue</b>"""
"""<p>This continues an interrupted history editing session.</p>"""
))
self.hgHisteditContinueAct.triggered.connect(self.__hgHisteditContinue)
self.actions.append(self.hgHisteditContinueAct)
self.hgHisteditAbortAct = E5Action(self.tr('Abort'), self.tr('Abort'),
0, 0, self,
'mercurial_histedit_abort')
self.hgHisteditAbortAct.setStatusTip(
self.tr('Abort an interrupted changeset history editing session'))
self.hgHisteditAbortAct.setWhatsThis(
self.
tr("""<b>Abort</b>"""
"""<p>This aborts an interrupted history editing session.</p>"""
))
self.hgHisteditAbortAct.triggered.connect(self.__hgHisteditAbort)
self.actions.append(self.hgHisteditAbortAct)
self.hgHisteditEditPlanAct = E5Action(self.tr('Edit Plan'),
self.tr('Edit Plan'), 0, 0, self,
'mercurial_histedit_edit_plan')
self.hgHisteditEditPlanAct.setStatusTip(
self.tr('Edit the remaining actions list'))
self.hgHisteditEditPlanAct.setWhatsThis(
self.
tr("""<b>Edit Plan</b>"""
"""<p>This opens an editor to edit the remaining actions list"""
""" of an interrupted history editing session.</p>"""))
self.hgHisteditEditPlanAct.triggered.connect(self.__hgHisteditEditPlan)
self.actions.append(self.hgHisteditEditPlanAct)
def __initActions(self):
"""
Private method to define the user interface actions.
"""
# list of all actions
self.__actions = []
self.addConnectionAct = E5Action(
self.tr('Add Connection'),
UI.PixmapCache.getIcon("databaseConnection.png"),
self.tr('Add &Connection...'), 0, 0, self,
'sql_file_add_connection')
self.addConnectionAct.setStatusTip(
self.tr('Open a dialog to add a new database connection'))
self.addConnectionAct.setWhatsThis(
self.tr("""<b>Add Connection</b>"""
"""<p>This opens a dialog to add a new database"""
""" connection.</p>"""))
self.addConnectionAct.triggered.connect(
self.__browser.addConnectionByDialog)
self.__actions.append(self.addConnectionAct)
self.exitAct = E5Action(self.tr('Quit'),
UI.PixmapCache.getIcon("exit.png"),
self.tr('&Quit'),
QKeySequence(self.tr("Ctrl+Q", "File|Quit")),
0, self, 'sql_file_quit')
self.exitAct.setStatusTip(self.tr('Quit the SQL browser'))
self.exitAct.setWhatsThis(
self.tr("""<b>Quit</b>"""
"""<p>Quit the SQL browser.</p>"""))
self.exitAct.triggered.connect(qApp.closeAllWindows)
self.aboutAct = E5Action(self.tr('About'), self.tr('&About'), 0, 0,
self, 'sql_help_about')
self.aboutAct.setStatusTip(
self.tr('Display information about this software'))
self.aboutAct.setWhatsThis(
self.tr(
"""<b>About</b>"""
"""<p>Display some information about this software.</p>"""))
self.aboutAct.triggered.connect(self.__about)
self.__actions.append(self.aboutAct)
self.aboutQtAct = E5Action(self.tr('About Qt'), self.tr('About &Qt'),
0, 0, self, 'sql_help_about_qt')
self.aboutQtAct.setStatusTip(
self.tr('Display information about the Qt toolkit'))
self.aboutQtAct.setWhatsThis(
self.tr(
"""<b>About Qt</b>"""
"""<p>Display some information about the Qt toolkit.</p>"""))
self.aboutQtAct.triggered.connect(self.__aboutQt)
self.__actions.append(self.aboutQtAct)
def initActions(self):
"""
Public method to generate the action objects.
"""
self.vcsNewAct = E5Action(
self.tr('New from repository'),
UI.PixmapCache.getIcon("vcsCheckout.png"),
self.tr('&New from repository...'),
0, 0, self, 'vcs_new')
self.vcsNewAct.setStatusTip(self.tr(
'Create a new project from the VCS repository'
))
self.vcsNewAct.setWhatsThis(self.tr(
"""<b>New from repository</b>"""
"""<p>This creates a new local project from the VCS"""
""" repository.</p>"""
))
self.vcsNewAct.triggered.connect(self._vcsCheckout)
self.actions.append(self.vcsNewAct)
self.vcsExportAct = E5Action(
self.tr('Export from repository'),
UI.PixmapCache.getIcon("vcsExport.png"),
self.tr('&Export from repository...'),
0, 0, self, 'vcs_export')
self.vcsExportAct.setStatusTip(self.tr(
'Export a project from the repository'
))
self.vcsExportAct.setWhatsThis(self.tr(
"""<b>Export from repository</b>"""
"""<p>This exports a project from the repository.</p>"""
))
self.vcsExportAct.triggered.connect(self._vcsExport)
self.actions.append(self.vcsExportAct)
self.vcsAddAct = E5Action(
self.tr('Add to repository'),
UI.PixmapCache.getIcon("vcsCommit.png"),
self.tr('&Add to repository...'),
0, 0, self, 'vcs_add')
self.vcsAddAct.setStatusTip(self.tr(
'Add the local project to the VCS repository'
))
self.vcsAddAct.setWhatsThis(self.tr(
"""<b>Add to repository</b>"""
"""<p>This adds (imports) the local project to the VCS"""
""" repository.</p>"""
))
self.vcsAddAct.triggered.connect(self._vcsImport)
self.actions.append(self.vcsAddAct)
def initActions(self):
"""
Public method to generate the action objects.
"""
self.hgGpgListAct = E5Action(
self.tr('List Signed Changesets'),
UI.PixmapCache.getIcon("changesetSignList.png"),
self.tr('List Signed Changesets...'),
0, 0, self, 'mercurial_gpg_list')
self.hgGpgListAct.setStatusTip(self.tr(
'List signed changesets'
))
self.hgGpgListAct.setWhatsThis(self.tr(
"""<b>List Signed Changesets</b>"""
"""<p>This opens a dialog listing all signed changesets.</p>"""
))
self.hgGpgListAct.triggered.connect(self.__hgGpgSignatures)
self.actions.append(self.hgGpgListAct)
self.hgGpgVerifyAct = E5Action(
self.tr('Verify Signatures'),
UI.PixmapCache.getIcon("changesetSignVerify.png"),
self.tr('Verify Signatures'),
0, 0, self, 'mercurial_gpg_verify')
self.hgGpgVerifyAct.setStatusTip(self.tr(
'Verify all signatures there may be for a particular revision'
))
self.hgGpgVerifyAct.setWhatsThis(self.tr(
"""<b>Verify Signatures</b>"""
"""<p>This verifies all signatures there may be for a particular"""
""" revision.</p>"""
))
self.hgGpgVerifyAct.triggered.connect(self.__hgGpgVerifySignatures)
self.actions.append(self.hgGpgVerifyAct)
self.hgGpgSignAct = E5Action(
self.tr('Sign Revision'),
UI.PixmapCache.getIcon("changesetSign.png"),
self.tr('Sign Revision'),
0, 0, self, 'mercurial_gpg_sign')
self.hgGpgSignAct.setStatusTip(self.tr(
'Add a signature for a selected revision'
))
self.hgGpgSignAct.setWhatsThis(self.tr(
"""<b>Sign Revision</b>"""
"""<p>This adds a signature for a selected revision.</p>"""
))
self.hgGpgSignAct.triggered.connect(self.__hgGpgSign)
self.actions.append(self.hgGpgSignAct)
def __projectBrowserShowMenu(self, menuName, menu):
"""
Private slot called, when the the project browser menu or a submenu is
about to be shown.
@param menuName name of the menu to be shown (string)
@param menu reference to the menu (QMenu)
"""
if menuName == "Checks" and \
e5App().getObject("Project").getProjectLanguage() in \
self.syntaxCheckService.getLanguages():
self.__projectBrowserMenu = menu
if self.__projectBrowserAct is None:
self.__projectBrowserAct = E5Action(
self.tr('Check Syntax'),
self.tr('&Syntax...'), 0, 0,
self, "")
self.__projectBrowserAct.setWhatsThis(self.tr(
"""<b>Check Syntax...</b>"""
"""<p>This checks Python files for syntax errors.</p>"""
))
self.__projectBrowserAct.triggered.connect(
self.__projectBrowserSyntaxCheck)
if self.__projectBrowserAct not in menu.actions():
menu.addAction(self.__projectBrowserAct)
def __setUiSwitchMenu(self):
pluginManager = e5App().getObject("PluginManager")
self.__LiteUiEnabled = pluginManager.isPluginActive('PluginLiteUI')
if self.__LiteUiEnabled == True:
# the LiteUI interface is running, show a menu for full interface
menuText = self.tr("Switch to expert interface")
else:
menuText = self.tr("Switch to lite interface")
settingsMenu = self.__ui.getMenu("settings")
tooltipText = self.tr(menuText +
'. This action will reset the program')
self.switchUiStyleAct = E5Action(menuText, menuText + '...', 0, 0,
self, 'switch_ui_style')
self.switchUiStyleAct.setStatusTip(tooltipText)
self.switchUiStyleAct.setWhatsThis("""<b>""" + menuText + """</b>"""
"""<b>""" + tooltipText +
"""</b>""")
self.switchUiStyleAct.triggered.connect(self.__switchUi)
self.__ui.actions.append(self.switchUiStyleAct)
settingsMenu.addAction(self.switchUiStyleAct)
settingsMenu.addSeparator()
def activate(self):
"""
Public method to activate this plugin.
@return tuple of None and activation status (boolean)
"""
menu = e5App().getObject("Project").getMenu("Apidoc")
if menu:
self.__projectAct = \
E5Action(
self.tr('Generate documentation (eric6_doc)'),
self.tr('Generate &documentation (eric6_doc)'), 0, 0,
self, 'doc_eric6_doc')
self.__projectAct.setStatusTip(
self.tr('Generate API documentation using eric6_doc'))
self.__projectAct.setWhatsThis(self.tr(
"""<b>Generate documentation</b>"""
"""<p>Generate API documentation using eric6_doc.</p>"""
))
self.__projectAct.triggered.connect(self.__doEricdoc)
e5App().getObject("Project").addE5Actions([self.__projectAct])
menu.addAction(self.__projectAct)
e5App().getObject("Project").showMenu.connect(self.__projectShowMenu)
return None, True
def __projectBrowserShowMenu(self, menuName, menu):
"""
Private slot called, when the the project browser context menu or a
submenu is about to be shown.
@param menuName name of the menu to be shown (string)
@param menu reference to the menu (QMenu)
"""
if menuName == "Checks" and \
e5App().getObject("Project").getProjectLanguage() in \
["Python3", "Python2", "Python"]:
self.__projectBrowserMenu = menu
if self.__projectBrowserAct is None:
self.__projectBrowserAct = E5Action(
self.tr('Check Indentations'),
self.tr('&Indentations...'), 0, 0,
self, "")
self.__projectBrowserAct.setWhatsThis(self.tr(
"""<b>Check Indentations...</b>"""
"""<p>This checks Python files"""
""" for bad indentations using tabnanny.</p>"""
))
self.__projectBrowserAct.triggered.connect(
self.__projectBrowserTabnanny)
if self.__projectBrowserAct not in menu.actions():
menu.addAction(self.__projectBrowserAct)
def activate(self):
"""
Public method to activate the translator.
"""
from .TranslatorWidget import TranslatorWidget
self.__widget = TranslatorWidget(self.__plugin, self)
self.__ui.addSideWidget(
self.__ui.BottomSide, self.__widget,
UI.PixmapCache.getIcon(
os.path.join(os.path.dirname(__file__), "icons", "flag.png")),
self.tr("Translator"))
self.__activateAct = E5Action(self.tr('Translator'),
self.tr('T&ranslator'),
QKeySequence(self.tr("Alt+Shift+R")), 0,
self, 'translator_activate')
self.__activateAct.setStatusTip(
self.tr("Switch the input focus to the Translator window."))
self.__activateAct.setWhatsThis(
self.tr("""<b>Activate Translator</b>"""
"""<p>This switches the input focus to the Translator"""
""" window.</p>"""))
self.__activateAct.triggered.connect(self.__activateWidget)
self.__ui.addE5Actions([self.__activateAct], 'ui')
menu = self.__ui.getMenu("subwindow")
menu.addAction(self.__activateAct)
def __projectBrowserShowMenu(self, menuName, menu):
"""
Private slot called, when the the project browser menu or a submenu is
about to be shown.
@param menuName name of the menu to be shown (string)
@param menu reference to the menu (QMenu)
"""
if menuName == "Checks" and \
e5App().getObject("Project").getProjectLanguage() in \
["Python3", "Python2", "Python"]:
self.__projectBrowserMenu = menu
if self.__projectBrowserAct is None:
self.__projectBrowserAct = E5Action(
self.tr('Check Code Style'), self.tr('&Code Style...'), 0,
0, self, "")
self.__projectBrowserAct.setWhatsThis(
self.
tr("""<b>Check Code Style...</b>"""
"""<p>This checks Python files for compliance to the"""
""" code style conventions given in various PEPs.</p>"""
))
self.__projectBrowserAct.triggered.connect(
self.__projectBrowserCodeStyleCheck)
if self.__projectBrowserAct not in menu.actions():
menu.addAction(self.__projectBrowserAct)
def activate(self):
"""
Public method to activate this plugin.
@return tuple of None and activation status (boolean)
"""
menu = e5App().getObject("Project").getMenu("Checks")
if menu:
self.__projectAct = E5Action(
self.tr('Check Indentations'),
self.tr('&Indentations...'), 0, 0,
self, 'project_check_indentations')
self.__projectAct.setStatusTip(
self.tr('Check indentations using tabnanny.'))
self.__projectAct.setWhatsThis(self.tr(
"""<b>Check Indentations...</b>"""
"""<p>This checks Python files"""
""" for bad indentations using tabnanny.</p>"""
))
self.__projectAct.triggered.connect(self.__projectTabnanny)
e5App().getObject("Project").addE5Actions([self.__projectAct])
menu.addAction(self.__projectAct)
self.__editorAct = E5Action(
self.tr('Check Indentations'),
self.tr('&Indentations...'), 0, 0,
self, "")
self.__editorAct.setWhatsThis(self.tr(
"""<b>Check Indentations...</b>"""
"""<p>This checks Python files"""
""" for bad indentations using tabnanny.</p>"""
))
self.__editorAct.triggered.connect(self.__editorTabnanny)
e5App().getObject("Project").showMenu.connect(self.__projectShowMenu)
e5App().getObject("ProjectBrowser").getProjectBrowser("sources")\
.showMenu.connect(self.__projectBrowserShowMenu)
e5App().getObject("ViewManager").editorOpenedEd.connect(
self.__editorOpened)
e5App().getObject("ViewManager").editorClosedEd.connect(
self.__editorClosed)
for editor in e5App().getObject("ViewManager").getOpenEditors():
self.__editorOpened(editor)
return None, True
def initActions(self):
"""
Public method to generate the action objects.
"""
self.hgRebaseAct = E5Action(
self.tr('Rebase Changesets'),
UI.PixmapCache.getIcon("vcsRebase.png"),
self.tr('Rebase Changesets'),
0, 0, self, 'mercurial_rebase')
self.hgRebaseAct.setStatusTip(self.tr(
'Rebase changesets to another branch'
))
self.hgRebaseAct.setWhatsThis(self.tr(
"""<b>Rebase Changesets</b>"""
"""<p>This rebases changesets to another branch.</p>"""
))
self.hgRebaseAct.triggered.connect(self.__hgRebase)
self.actions.append(self.hgRebaseAct)
self.hgRebaseContinueAct = E5Action(
self.tr('Continue Rebase Session'),
self.tr('Continue Rebase Session'),
0, 0, self, 'mercurial_rebase_continue')
self.hgRebaseContinueAct.setStatusTip(self.tr(
'Continue the last rebase session after repair'
))
self.hgRebaseContinueAct.setWhatsThis(self.tr(
"""<b>Continue Rebase Session</b>"""
"""<p>This continues the last rebase session after repair.</p>"""
))
self.hgRebaseContinueAct.triggered.connect(self.__hgRebaseContinue)
self.actions.append(self.hgRebaseContinueAct)
self.hgRebaseAbortAct = E5Action(
self.tr('Abort Rebase Session'),
self.tr('Abort Rebase Session'),
0, 0, self, 'mercurial_rebase_abort')
self.hgRebaseAbortAct.setStatusTip(self.tr(
'Abort the last rebase session'
))
self.hgRebaseAbortAct.setWhatsThis(self.tr(
"""<b>Abort Rebase Session</b>"""
"""<p>This aborts the last rebase session.</p>"""
))
self.hgRebaseAbortAct.triggered.connect(self.__hgRebaseAbort)
self.actions.append(self.hgRebaseAbortAct)
def activate(self):
"""
Public method to activate this plugin.
@return tuple of None and activation status (boolean)
"""
menu = e5App().getObject("Project").getMenu("Checks")
if menu:
self.__projectAct = E5Action(self.tr('Check Code Style'),
self.tr('&Code Style...'), 0, 0, self,
'project_check_pep8')
self.__projectAct.setStatusTip(self.tr('Check code style.'))
self.__projectAct.setWhatsThis(
self.tr(
"""<b>Check Code Style...</b>"""
"""<p>This checks Python files for compliance to the"""
""" code style conventions given in various PEPs.</p>"""))
self.__projectAct.triggered.connect(self.__projectCodeStyleCheck)
e5App().getObject("Project").addE5Actions([self.__projectAct])
menu.addAction(self.__projectAct)
self.__editorAct = E5Action(self.tr('Check Code Style'),
self.tr('&Code Style...'), 0, 0, self, "")
self.__editorAct.setWhatsThis(
self.tr("""<b>Check Code Style...</b>"""
"""<p>This checks Python files for compliance to the"""
""" code style conventions given in various PEPs.</p>"""))
self.__editorAct.triggered.connect(self.__editorCodeStyleCheck)
e5App().getObject("Project").showMenu.connect(self.__projectShowMenu)
e5App().getObject("ProjectBrowser").getProjectBrowser("sources")\
.showMenu.connect(self.__projectBrowserShowMenu)
e5App().getObject("ViewManager").editorOpenedEd.connect(
self.__editorOpened)
e5App().getObject("ViewManager").editorClosedEd.connect(
self.__editorClosed)
for editor in e5App().getObject("ViewManager").getOpenEditors():
self.__editorOpened(editor)
return None, True
def __initActions(self):
"""
Private method to initialize the actions.
"""
acts = []
self.aboutAct = E5Action(
self.tr('About {0}').format(UI.Info.Program),
UI.PixmapCache.getIcon("helpAbout.png"),
self.tr('&About {0}').format(UI.Info.Program), 0, 0, self,
'about_eric')
self.aboutAct.setStatusTip(
self.tr('Display information about this software'))
self.aboutAct.setWhatsThis(
self.tr("""<b>About {0}</b>"""
"""<p>Display some information about this software.</p>"""
).format(UI.Info.Program))
self.aboutAct.triggered.connect(self.__about)
self.aboutAct.setMenuRole(QAction.AboutRole)
acts.append(self.aboutAct)
self.aboutQtAct = E5Action(self.tr('About Qt'),
UI.PixmapCache.getIcon("helpAboutQt.png"),
self.tr('About &Qt'), 0, 0, self,
'about_qt')
self.aboutQtAct.setStatusTip(
self.tr('Display information about the Qt toolkit'))
self.aboutQtAct.setWhatsThis(
self.tr(
"""<b>About Qt</b>"""
"""<p>Display some information about the Qt toolkit.</p>"""))
self.aboutQtAct.triggered.connect(self.__aboutQt)
self.aboutQtAct.setMenuRole(QAction.AboutQtRole)
acts.append(self.aboutQtAct)
self.__ui.addE5Actions(acts, 'ui')
def __addLinksIntoHelp(self):
helpMenu = self.__ui.getMenu("help")
menuText = "Go to Pycom documentation"
tooltipText = "Open a web browser with the boards' documentation"
self.goPycomDocAct = E5Action(menuText, menuText + '...', 0, 0, self,
'go_to_doc')
self.goPycomDocAct.setStatusTip(tooltipText)
self.goPycomDocAct.setWhatsThis("""<b>""" + menuText + """</b>"""
"""<b>""" + tooltipText + """</b>""")
self.goPycomDocAct.triggered.connect(self.__goPycomDoc)
self.__ui.actions.append(self.goPycomDocAct)
helpMenu.addAction(self.goPycomDocAct)
helpMenu.addSeparator()
def __installMenu(self, text, menuText, tooltip, whatsthis, name,
callback):
menu = self.__ui.getMenu('help')
reportAct = E5Action(self.tr(text), self.tr(menuText), 0, 0, self,
name)
reportAct.setStatusTip(self.tr(tooltip))
reportAct.setWhatsThis(
self.tr("<b>" + text + "...</b>" + "<p>" + whatsthis + "</p>"))
act = self.__ui.getMenuAction("help", name)
menu.insertAction(act, reportAct)
menu.removeAction(act)
reportAct.triggered.connect(callback)
return reportAct
def __initAction(self):
"""
Private method to initialize the action.
"""
self.action = E5Action(self.tr('E5MessageBox Wizard'),
self.tr('&E5MessageBox Wizard...'), 0, 0, self,
'wizards_e5messagebox')
self.action.setStatusTip(self.tr('E5MessageBox Wizard'))
self.action.setWhatsThis(
self.
tr("""<b>E5MessageBox Wizard</b>"""
"""<p>This wizard opens a dialog for entering all the parameters"""
""" needed to create an E5MessageBox. The generated code is"""
""" inserted at the current cursor position.</p>"""))
self.action.triggered.connect(self.__handle)
self.__ui.addE5Actions([self.action], 'wizards')
def __initAction(self):
"""
Private method to initialize the action.
"""
self.__action = E5Action(
self.tr('Virtualenv Configurator'),
self.tr('&Virtualenv Configurator...'),
0, 0, self,
'virtualenv_configurator')
self.__action.setStatusTip(self.tr('Virtualenv Wizard'))
self.__action.setWhatsThis(self.tr(
"""<b>Virtualenv Configurator</b>"""
"""<p>This opens a dialog for entering all the parameters"""
""" needed to create a Python virtual environment using"""
""" virtualenv or pyvenv.</p>"""
))
self.__action.triggered.connect(self.__handle)
def initActions(self):
"""
Public method to generate the action objects.
"""
self.hgStripAct = E5Action(self.tr('Strip changesets'),
UI.PixmapCache.getIcon("fileDelete.png"),
self.tr('Strip changesets'), 0, 0, self,
'mercurial_strip')
self.hgStripAct.setStatusTip(
self.tr('Strip changesets from a repository'))
self.hgStripAct.setWhatsThis(
self.tr("""<b>Strip changesets</b>"""
"""<p>This deletes a changeset and all its descendants"""
""" from a repository. Each removed changeset will be"""
""" stored in .hg/strip-backup as a bundle file.</p>"""))
self.hgStripAct.triggered.connect(self.__hgStrip)
self.actions.append(self.hgStripAct)
def __initAction(self):
"""
Private method to initialize the action.
"""
self.action = E5Action(self.tr('QRegExp Wizard'),
self.tr('Q&RegExp Wizard...'), 0, 0, self,
'wizards_qregexp')
self.action.setStatusTip(self.tr('QRegExp Wizard'))
self.action.setWhatsThis(
self.
tr("""<b>QRegExp Wizard</b>"""
"""<p>This wizard opens a dialog for entering all the parameters"""
""" needed to create a QRegExp. The generated code is inserted"""
""" at the current cursor position.</p>"""))
self.action.triggered.connect(self.__handle)
self.__ui.addE5Actions([self.action], 'wizards')
def initActions(self):
"""
Public method to generate the action objects.
"""
self.hgCloseheadAct = E5Action(self.tr('Close Heads'),
UI.PixmapCache.getIcon("closehead"),
self.tr('Close Heads'), 0, 0, self,
'mercurial_closehead')
self.hgCloseheadAct.setStatusTip(
self.tr('Close arbitrary heads without checking them out first'))
self.hgCloseheadAct.setWhatsThis(
self.
tr("""<b>Close Heads</b>"""
"""<p>This closes arbitrary heads without the need to check them"""
""" out first.</p>"""))
self.hgCloseheadAct.triggered.connect(self.__hgClosehead)
self.actions.append(self.hgCloseheadAct)
def __initAction(self):
"""
Private method to initialize the action.
"""
self.__action = E5Action(self.tr('setup.py Wizard'),
self.tr('&setup.py Wizard...'), 0, 0, self,
'wizards_setup_py')
self.__action.setStatusTip(self.tr('setup.py Wizard'))
self.__action.setWhatsThis(
self.
tr("""<b>setup.py Wizard</b>"""
"""<p>This wizard opens a dialog for entering all the parameters"""
""" needed to create the basic contents of a setup.py file. The"""
""" generated code is inserted at the current cursor position."""
"""</p>"""))
self.__action.triggered.connect(self.__handle)
self.__ui.addE5Actions([self.__action], 'wizards')
def __initAction(self):
"""
Private method to initialize the action.
"""
self.__action = E5Action(self.tr('eric Plug-in Wizard'),
self.tr('&eric Plug-in Wizard...'), 0, 0,
self, 'wizards_eric_plugin')
self.__action.setStatusTip(self.tr('eric Plug-in Wizard'))
self.__action.setWhatsThis(
self.
tr("""<b>eric Plug-in Wizard</b>"""
"""<p>This wizard opens a dialog for entering all the parameters"""
""" needed to create the basic contents of an eric plug-in file."""
""" The generated code is inserted at the current cursor"""
""" position.</p>"""))
self.__action.triggered.connect(self.__handle)
self.__ui.addE5Actions([self.__action], 'wizards')
def initActions(self):
"""
Public method to generate the action objects.
"""
self.hgFetchAct = E5Action(self.tr('Fetch changes'),
UI.PixmapCache.getIcon("vcsUpdate.png"),
self.tr('Fetch changes'), 0, 0, self,
'mercurial_fetch')
self.hgFetchAct.setStatusTip(
self.tr('Fetch changes from a remote repository'))
self.hgFetchAct.setWhatsThis(
self.
tr("""<b>Fetch changes</b>"""
"""<p>This pulls changes from a remote repository into the """
"""local repository. If the pulled changes add a new branch"""
""" head, the head is automatically merged, and the result of"""
""" the merge is committed. Otherwise, the working directory"""
""" is updated to include the new changes.</p>"""))
self.hgFetchAct.triggered.connect(self.__hgFetch)
self.actions.append(self.hgFetchAct)
def __init__(self, replace, vm, parent=None, sliding=False):
"""
Constructor
@param replace flag indicating a replace widget is called
@param vm reference to the viewmanager object
@param parent parent widget of this widget (QWidget)
@param sliding flag indicating the widget is embedded in the
sliding widget (boolean)
"""
super(SearchReplaceWidget, self).__init__(parent)
self.__viewmanager = vm
self.__isMiniEditor = vm is parent
self.__replace = replace
self.__sliding = sliding
if sliding:
self.__topWidget = parent
self.findHistory = vm.getSRHistory('search')
if replace:
from .Ui_ReplaceWidget import Ui_ReplaceWidget
self.replaceHistory = vm.getSRHistory('replace')
self.ui = Ui_ReplaceWidget()
whatsThis = self.tr("""<b>Find and Replace</b>
<p>This dialog is used to find some text and replace it with another text.
By checking the various checkboxes, the search can be made more specific.
The search string might be a regular expression. In a regular expression,
special characters interpreted are:</p>
""")
else:
from .Ui_SearchWidget import Ui_SearchWidget
self.ui = Ui_SearchWidget()
whatsThis = self.tr("""<b>Find</b>
<p>This dialog is used to find some text. By checking the various checkboxes,
the search can be made more specific. The search string might be a regular
expression. In a regular expression, special characters interpreted are:</p>
""")
self.ui.setupUi(self)
if not replace:
self.ui.wrapCheckBox.setChecked(True)
whatsThis += self.tr("""<table border="0">
<tr><td><code>.</code></td><td>Matches any character</td></tr>
<tr><td><code>(</code></td><td>This marks the start of a region for tagging a
match.</td></tr>
<tr><td><code>)</code></td><td>This marks the end of a tagged region.
</td></tr>
<tr><td><code>\\n</code></td>
<td>Where <code>n</code> is 1 through 9 refers to the first through ninth
tagged region when replacing. For example, if the search string was
<code>Fred([1-9])XXX</code> and the replace string was
<code>Sam\\1YYY</code>, when applied to <code>Fred2XXX</code> this would
generate <code>Sam2YYY</code>.</td></tr>
<tr><td><code>\\<</code></td>
<td>This matches the start of a word using Scintilla's definitions of words.
</td></tr>
<tr><td><code>\\></code></td>
<td>This matches the end of a word using Scintilla's definition of words.
</td></tr>
<tr><td><code>\\x</code></td>
<td>This allows you to use a character x that would otherwise have a special
meaning. For example, \\[ would be interpreted as [ and not as the start of a
character set.</td></tr>
<tr><td><code>[...]</code></td>
<td>This indicates a set of characters, for example, [abc] means any of the
characters a, b or c. You can also use ranges, for example [a-z] for any lower
case character.</td></tr>
<tr><td><code>[^...]</code></td>
<td>The complement of the characters in the set. For example, [^A-Za-z] means
any character except an alphabetic character.</td></tr>
<tr><td><code>^</code></td>
<td>This matches the start of a line (unless used inside a set, see above).
</td></tr>
<tr><td><code>$</code></td> <td>This matches the end of a line.</td></tr>
<tr><td><code>*</code></td>
<td>This matches 0 or more times. For example, <code>Sa*m</code> matches
<code>Sm</code>, <code>Sam</code>, <code>Saam</code>, <code>Saaam</code>
and so on.</td></tr>
<tr><td><code>+</code></td>
<td>This matches 1 or more times. For example, <code>Sa+m</code> matches
<code>Sam</code>, <code>Saam</code>, <code>Saaam</code> and so on.</td></tr>
</table>
<p>When using the Extended (C++11) regular expression mode more features are
available, generally similar to regular expression support in JavaScript. See
the documentation of your C++ runtime for details on what is supported.<p>
""")
self.setWhatsThis(whatsThis)
# set icons
self.ui.closeButton.setIcon(UI.PixmapCache.getIcon("close.png"))
self.ui.findPrevButton.setIcon(
UI.PixmapCache.getIcon("1leftarrow.png"))
self.ui.findNextButton.setIcon(
UI.PixmapCache.getIcon("1rightarrow.png"))
if replace:
self.ui.replaceButton.setIcon(
UI.PixmapCache.getIcon("editReplace.png"))
self.ui.replaceSearchButton.setIcon(
UI.PixmapCache.getIcon("editReplaceSearch.png"))
self.ui.replaceAllButton.setIcon(
UI.PixmapCache.getIcon("editReplaceAll.png"))
# set line edit completers
self.ui.findtextCombo.setCompleter(None)
self.ui.findtextCombo.lineEdit().returnPressed.connect(
self.__findByReturnPressed)
if replace:
self.ui.replacetextCombo.setCompleter(None)
self.ui.replacetextCombo.lineEdit().returnPressed.connect(
self.on_replaceButton_clicked)
# define actions
self.findNextAct = E5Action(self.tr('Find Next'), self.tr('Find Next'),
0, 0, self, 'search_widget_find_next')
self.findNextAct.triggered.connect(self.on_findNextButton_clicked)
self.findNextAct.setShortcutContext(Qt.WidgetWithChildrenShortcut)
self.findPrevAct = E5Action(self.tr('Find Prev'), self.tr('Find Prev'),
0, 0, self, 'search_widget_find_prev')
self.findPrevAct.triggered.connect(self.on_findPrevButton_clicked)
self.findPrevAct.setShortcutContext(Qt.WidgetWithChildrenShortcut)
if replace:
self.replaceAndSearchAct = E5Action(
self.tr("Replace and Search"), self.tr("Replace and Search"),
0, 0, self, "replace_widget_replace_search")
self.replaceAndSearchAct.triggered.connect(
self.on_replaceSearchButton_clicked)
self.replaceAndSearchAct.setEnabled(False)
self.replaceAndSearchAct.setShortcutContext(
Qt.WidgetWithChildrenShortcut)
self.replaceSelectionAct = E5Action(
self.tr("Replace Occurrence"), self.tr("Replace Occurrence"),
0, 0, self, "replace_widget_replace_occurrence")
self.replaceSelectionAct.triggered.connect(
self.on_replaceButton_clicked)
self.replaceSelectionAct.setEnabled(False)
self.replaceSelectionAct.setShortcutContext(
Qt.WidgetWithChildrenShortcut)
self.replaceAllAct = E5Action(self.tr("Replace All"),
self.tr("Replace All"), 0, 0, self,
"replace_widget_replace_all")
self.replaceAllAct.triggered.connect(
self.on_replaceAllButton_clicked)
self.replaceAllAct.setEnabled(False)
self.replaceAllAct.setShortcutContext(
Qt.WidgetWithChildrenShortcut)
self.addAction(self.findNextAct)
self.addAction(self.findPrevAct)
if replace:
self.addAction(self.replaceAndSearchAct)
self.addAction(self.replaceSelectionAct)
self.addAction(self.replaceAllAct)
# disable search and replace buttons and actions
self.__setFindNextEnabled(False)
self.__setFindPrevEnabled(False)
if replace:
self.__setReplaceAndSearchEnabled(False)
self.__setReplaceSelectionEnabled(False)
self.__setReplaceAllEnabled(False)
self.adjustSize()
self.havefound = False
self.__pos = None
self.__findBackwards = False
self.__selections = []
self.__finding = False
def initActions(self):
"""
Public method to generate the action objects.
"""
self.hgConvertToLargefilesAct = E5Action(
self.tr('Convert repository to largefiles'),
self.tr('Convert repository to largefiles...'), 0, 0, self,
'mercurial_convert_to_largefiles')
self.hgConvertToLargefilesAct.setStatusTip(
self.
tr('Convert the repository of the project to a largefiles repository.'
))
self.hgConvertToLargefilesAct.setWhatsThis(
self.tr(
"""<b>Convert repository to largefiles</b>"""
"""<p>This converts the repository of the project to a"""
""" largefiles repository. A new project is created. The"""
""" current one is kept as a backup.</p>"""))
self.hgConvertToLargefilesAct.triggered.connect(
lambda: self.__hgLfconvert("largefiles"))
self.actions.append(self.hgConvertToLargefilesAct)
self.hgConvertToNormalAct = E5Action(
self.tr('Convert repository to normal'),
self.tr('Convert repository to normal...'), 0, 0, self,
'mercurial_convert_to_normal')
self.hgConvertToNormalAct.setStatusTip(
self.tr(
'Convert the repository of the project to a normal repository.'
))
self.hgConvertToNormalAct.setWhatsThis(
self.tr(
"""<b>Convert repository to normal</b>"""
"""<p>This converts the repository of the project to a"""
""" normal repository. A new project is created. The current"""
""" one is kept as a backup.</p>"""))
self.hgConvertToNormalAct.triggered.connect(
lambda: self.__hgLfconvert("normal"))
self.actions.append(self.hgConvertToNormalAct)
self.hgLfPullAct = E5Action(self.tr('Pull Large Files'),
UI.PixmapCache.getIcon("vcsUpdate.png"),
self.tr('Pull Large Files'), 0, 0, self,
'mercurial_pull_largefiles')
self.hgLfPullAct.setStatusTip(
self.tr('Pull large files from a remote repository'))
self.hgLfPullAct.setWhatsThis(
self.
tr("""<b>Pull Large Files</b>"""
"""<p>This pulls missing large files from a remote repository"""
""" into the local repository.</p>"""))
self.hgLfPullAct.triggered.connect(self.__hgLfPull)
self.actions.append(self.hgLfPullAct)
self.hgLfSummaryAct = E5Action(
self.tr('Show Summary'), UI.PixmapCache.getIcon("vcsSummary.png"),
self.tr('Show summary...'), 0, 0, self,
'mercurial_summary_largefiles')
self.hgLfSummaryAct.setStatusTip(
self.tr(
'Show summary information of the working directory status'))
self.hgLfSummaryAct.setWhatsThis(
self.tr("""<b>Show summary</b>"""
"""<p>This shows some summary information of the working"""
""" directory status.</p>"""))
self.hgLfSummaryAct.triggered.connect(self.__hgLfSummary)
self.actions.append(self.hgLfSummaryAct)
self.hgVerifyLargeAct = E5Action(
self.tr('Verify large files of current revision'),
self.tr('Verify large files of current revision...'), 0, 0, self,
'mercurial_verify_large')
self.hgVerifyLargeAct.setStatusTip(
self.tr(
'Verify that all large files in the current revision exist'))
self.hgVerifyLargeAct.setWhatsThis(
self.tr("""<b>Verify large files of current revision</b>"""
"""<p>This verifies that all large files in the current"""
""" revision exist.</p>"""))
self.hgVerifyLargeAct.triggered.connect(
lambda: self.__hgLfVerify("large"))
self.actions.append(self.hgVerifyLargeAct)
self.hgVerifyLfaAct = E5Action(
self.tr('Verify large files of all revision'),
self.tr('Verify large files of all revision...'), 0, 0, self,
'mercurial_verify_lfa')
self.hgVerifyLfaAct.setStatusTip(
self.tr('Verify that all large files in all revisions exist'))
self.hgVerifyLfaAct.setWhatsThis(
self.tr("""<b>Verify large files of all revision</b>"""
"""<p>This verifies that all large files in all"""
""" revisions exist.</p>"""))
self.hgVerifyLfaAct.triggered.connect(lambda: self.__hgLfVerify("lfa"))
self.actions.append(self.hgVerifyLfaAct)
self.hgVerifyLfcAct = E5Action(
self.tr('Verify large files contents'),
self.tr('Verify large files contents...'), 0, 0, self,
'mercurial_verify_lfc')
self.hgVerifyLfcAct.setStatusTip(
self.tr('Verify the contents of all large files'))
self.hgVerifyLfcAct.setWhatsThis(
self.tr(
"""<b>Verify large files contents</b>"""
"""<p>This verifies the contents of all large files.</p>"""))
self.hgVerifyLfcAct.triggered.connect(lambda: self.__hgLfVerify("lfc"))
self.actions.append(self.hgVerifyLfcAct)
def initActions(self):
"""
Public method to generate the action objects.
"""
self.hgPurgeAct = E5Action(self.tr('Purge Files'),
UI.PixmapCache.getIcon("fileDelete.png"),
self.tr('Purge Files'), 0, 0, self,
'mercurial_purge')
self.hgPurgeAct.setStatusTip(
self.tr('Delete files and directories not known to Mercurial'))
self.hgPurgeAct.setWhatsThis(
self.
tr("""<b>Purge Files</b>"""
"""<p>This deletes files and directories not known to Mercurial."""
""" That means that purge will delete:<ul>"""
"""<li>unknown files (marked with "not tracked" in the status"""
""" dialog)</li>"""
"""<li>empty directories</li>"""
"""</ul>Note that ignored files will be left untouched.</p>"""))
self.hgPurgeAct.triggered.connect(self.__hgPurge)
self.actions.append(self.hgPurgeAct)
self.hgPurgeAllAct = E5Action(self.tr('Purge All Files'),
self.tr('Purge All Files'), 0, 0, self,
'mercurial_purge_all')
self.hgPurgeAllAct.setStatusTip(
self.tr(
'Delete files and directories not known to Mercurial including'
' ignored ones'))
self.hgPurgeAllAct.setWhatsThis(
self.
tr("""<b>Purge All Files</b>"""
"""<p>This deletes files and directories not known to Mercurial."""
""" That means that purge will delete:<ul>"""
"""<li>unknown files (marked with "not tracked" in the status"""
""" dialog)</li>"""
"""<li>empty directories</li>"""
"""<li>ignored files and directories</li>"""
"""</ul></p>"""))
self.hgPurgeAllAct.triggered.connect(self.__hgPurgeAll)
self.actions.append(self.hgPurgeAllAct)
self.hgPurgeListAct = E5Action(
self.tr('List Files to be Purged'),
UI.PixmapCache.getIcon("fileDeleteList.png"),
self.tr('List Files to be Purged...'), 0, 0, self,
'mercurial_purge_list')
self.hgPurgeListAct.setStatusTip(
self.tr('List files and directories not known to Mercurial'))
self.hgPurgeListAct.setWhatsThis(
self.
tr("""<b>List Files to be Purged</b>"""
"""<p>This lists files and directories not known to Mercurial."""
""" These would be deleted by the "Purge Files" menu entry.</p>"""
))
self.hgPurgeListAct.triggered.connect(self.__hgPurgeList)
self.actions.append(self.hgPurgeListAct)
self.hgPurgeAllListAct = E5Action(
self.tr('List All Files to be Purged'),
self.tr('List All Files to be Purged...'), 0, 0, self,
'mercurial_purge_all_list')
self.hgPurgeAllListAct.setStatusTip(
self.tr(
'List files and directories not known to Mercurial including'
' ignored ones'))
self.hgPurgeAllListAct.setWhatsThis(
self.
tr("""<b>List All Files to be Purged</b>"""
"""<p>This lists files and directories not known to Mercurial"""
""" including ignored ones. These would be deleted by the"""
""" "Purge All Files" menu entry.</p>"""))
self.hgPurgeAllListAct.triggered.connect(self.__hgPurgeAllList)
self.actions.append(self.hgPurgeAllListAct)
