def _menu_context_tree(self, point):
index = self.indexAt(point)
if not index.isValid():
return
item = self.itemAt(point)
handler = None
menu = QMenu(self)
if item.isFolder or item.parent() is None:
self._add_context_menu_for_folders(menu, item)
elif not item.isFolder:
self._add_context_menu_for_files(menu, item)
if item.parent() is None:
#get the extra context menu for this projectType
handler = settings.get_project_type_handler(item.projectType)
self._add_context_menu_for_root(menu, item)
#menu for all items (legacy API)!
extra_menus = self.extra_menus.get('all', ())
#menu for all items!
extra_menus_by_scope = self.extra_menus_by_scope['all']
for m in (extra_menus + extra_menus_by_scope):
if isinstance(m, QMenu):
menu.addSeparator()
menu.addMenu(m)
#menu for the Project Type(if present)
if handler:
for m in handler.get_context_menus():
if isinstance(m, QMenu):
menu.addSeparator()
menu.addMenu(m)
#show the menu!
menu.exec_(QCursor.pos())
def _menu_context_tree(self, point):
index = self.indexAt(point)
if not index.isValid():
return
item = self.itemAt(point)
handler = None
menu = QMenu(self)
if item.isFolder or item.parent() is None:
self._add_context_menu_for_folders(menu, item)
elif not item.isFolder:
self._add_context_menu_for_files(menu, item)
if item.parent() is None:
#get the extra context menu for this projectType
handler = settings.get_project_type_handler(item.projectType)
self._add_context_menu_for_root(menu, item)
#menu for all items (legacy API)!
extra_menus = self.extra_menus.get('all', ())
#menu for all items!
extra_menus_by_scope = self.extra_menus_by_scope['all']
for m in (extra_menus + extra_menus_by_scope):
if isinstance(m, QMenu):
menu.addSeparator()
menu.addMenu(m)
#menu for the Project Type(if present)
if handler:
for m in handler.get_context_menus():
if isinstance(m, QMenu):
menu.addSeparator()
menu.addMenu(m)
#show the menu!
menu.exec_(QCursor.pos())
def manageActions(self,modelindex,menu):
'''
Returns a menu for managing social tenure relationship information.
'''
editReceivers = self.signalReceivers(self.editAction)
if editReceivers > 0:
self.editAction.triggered.disconnect()
deleteReceivers = self.signalReceivers(self.deleteAction)
if deleteReceivers > 0:
self.deleteAction.triggered.disconnect()
#Add new entities menu
entityAddMenu = QMenu(QApplication.translate("STRNode","Add"),self.parentWidget())
entityAddMenu.setIcon(QIcon(":/plugins/stdm/images/icons/add.png"))
#Define actions for adding related STR entities
confAction = QAction(QIcon(":/plugins/stdm/images/icons/conflict.png"),
QApplication.translate("STRNode","Conflict Information"),self._view)
confAction.triggered.connect(lambda: self.onCreateConflict(modelindex))
#Check if conflict information already exists. If so, then no need of defining twice
if self.strModel.hasConflict():
confAction.setEnabled(False)
entityAddMenu.addAction(confAction)
taxAction = QAction(QIcon(":/plugins/stdm/images/icons/receipt.png"),
QApplication.translate("STRNode","Tax Information"),self._view)
taxAction.triggered.connect(lambda: self.onCreateTaxation(modelindex))
if self.strModel.hasTaxation():
taxAction.setEnabled(False)
entityAddMenu.addAction(taxAction)
#Add source documents menu
addSrcDocMenu = QMenu(QApplication.translate("STRNode","Source Documents"),self.parentWidget())
addSrcDocMenu.setIcon(QIcon(":/plugins/stdm/images/icons/attachment.png"))
titleDeedAction = QAction(QApplication.translate("STRNode","Title Deed"),self._view)
titleDeedAction.triggered.connect(lambda: self.onAddSourceDocument(TITLE_DEED))
addSrcDocMenu.addAction(titleDeedAction)
notaryRefAction = QAction(QApplication.translate("STRNode","Notary Reference"),self._view)
notaryRefAction.triggered.connect(lambda: self.onAddSourceDocument(NOTARY_REF))
addSrcDocMenu.addAction(notaryRefAction)
statRefPaperAction = QAction(QApplication.translate("STRNode","Statutory Reference Paper"),self._view)
statRefPaperAction.triggered.connect(lambda: self.onAddSourceDocument(STATUTORY_REF_PAPER))
addSrcDocMenu.addAction(statRefPaperAction)
surveyorRefAction = QAction(QApplication.translate("STRNode","Surveyor Reference"),self._view)
surveyorRefAction.triggered.connect(lambda: self.onAddSourceDocument(SURVEYOR_REF))
addSrcDocMenu.addAction(surveyorRefAction)
entityAddMenu.addMenu(addSrcDocMenu)
menu.addMenu(entityAddMenu)
menu.addAction(self.editAction)
menu.addAction(self.deleteAction)
#Disable if the user does not have permission.
if not self.parentWidget()._canEdit:
menu.setEnabled(False)
self.editAction.triggered.connect(lambda: self.onEdit(modelindex))
self.deleteAction.triggered.connect(lambda: self.onDelete(modelindex))
def layercontextmenu( layer, pos, parent=None ):
'''Show a context menu to manipulate properties of layer.
layer -- a volumina layer instance
pos -- QPoint
'''
menu = QMenu("Menu", parent)
# Title
title = QAction("%s" % layer.name, menu)
title.setEnabled(False)
menu.addAction(title)
# Export
global _has_lazyflow
if _has_lazyflow:
export = QAction("Export...",menu)
export.setStatusTip("Export Layer...")
export.triggered.connect( partial( get_settings_and_export_layer, layer, menu ) )
menu.addAction(export)
menu.addSeparator()
_add_actions( layer, menu )
# Layer-custom context menu items
menu.addSeparator()
for item in layer.contexts:
if isinstance(item, QAction):
menu.addAction(item)
elif isinstance(item, QMenu):
menu.addMenu(item)
menu.exec_(pos)
def _menu_context_tree(self, point, isRoot=False, root_path=None):
index = self.indexAt(point)
if not index.isValid() and not isRoot:
return
handler = None
menu = QMenu(self)
if isRoot or self.model().isDir(index):
self._add_context_menu_for_folders(menu, isRoot, root_path)
else:
filename = self.model().fileName(index)
lang = file_manager.get_file_extension(filename)
self._add_context_menu_for_files(menu, lang)
if isRoot:
#get the extra context menu for this projectType
handler = settings.get_project_type_handler(
self.project.project_type)
self._add_context_menu_for_root(menu)
menu.addMenu(self._folding_menu)
#menu for the Project Type(if present)
if handler:
for m in handler.get_context_menus():
if isinstance(m, QMenu):
menu.addSeparator()
menu.addMenu(m)
#show the menu!
menu.exec_(QCursor.pos())
def process_custom_menu(self, point):
item = self.select_item_at(point)
if not item:
return
node = item.node
menu = QMenu(self.view)
# Populate menu
if node.tag == 'run':
menu.addAction(self.actGetInfoSimulationRuns)
menu.addAction(self.actDeleteRun)
elif node.tag == 'indicator_batches':
menu.addAction(self.actAddNewIndicatorBatch)
elif node.tag == 'simulation_runs':
menu.addAction(self.actImportRun)
elif node.tag == 'indicator_batch':
menu.addAction(self.actAddVisualizationToBatch)
run_batch_on_menu = QMenu('Run indicator batch on...')
self._createBatchRunMenu(run_batch_on_menu)
menu.addMenu(run_batch_on_menu)
elif node.tag == 'batch_visualization': # get('type') == 'batch_visualization':
menu.addAction(self.actConfigureExistingBatchIndicatorVis)
self.add_default_menu_items_for_node(node, menu)
if not menu.isEmpty():
menu.exec_(QCursor.pos())
def contextMenuEvent(self, e):
menu = QMenu(self)
subMenu = QMenu(menu)
titleHistoryMenu = QCoreApplication.translate("PythonConsole",
"Command History")
subMenu.setTitle(titleHistoryMenu)
subMenu.addAction(QCoreApplication.translate("PythonConsole", "Show"),
self.showHistory, 'Ctrl+Shift+SPACE')
subMenu.addSeparator()
subMenu.addAction(QCoreApplication.translate("PythonConsole", "Save"),
self.writeHistoryFile)
subMenu.addSeparator()
subMenu.addAction(
QCoreApplication.translate("PythonConsole", "Clear File"),
self.clearHistory)
subMenu.addAction(
QCoreApplication.translate("PythonConsole", "Clear Session"),
self.clearHistorySession)
menu.addMenu(subMenu)
menu.addSeparator()
copyAction = menu.addAction(
QCoreApplication.translate("PythonConsole", "Copy"), self.copy,
QKeySequence.Copy)
pasteAction = menu.addAction(
QCoreApplication.translate("PythonConsole", "Paste"), self.paste,
QKeySequence.Paste)
copyAction.setEnabled(False)
pasteAction.setEnabled(False)
if self.hasSelectedText():
copyAction.setEnabled(True)
if QApplication.clipboard().text():
pasteAction.setEnabled(True)
menu.exec_(self.mapToGlobal(e.pos()))
def process_custom_menu(self, point):
''' See XmlController for documentation '''
item = self.select_item_at(point)
if not item:
return
menu = QMenu()
node = item.node
if node.get('executable') == 'True':
menu.addAction(self.actRunScenario)
elif node.get('type') in ['selectable', 'model_choice']:
menu.addAction(self.actMoveNodeUp)
menu.addAction(self.actMoveNodeDown)
elif node.tag == 'models_to_run': # special case of a selectable list
models_menu = QMenu(menu)
models_menu.setTitle('Add model to run')
models_menu.setIcon(IconLibrary.icon('add'))
available_model_names = get_model_names(self.project)
for model_name in available_model_names:
cb = lambda x = model_name, y = self.selected_index(): self.addModel(y, x)
action = self.create_action('model', model_name, cb)
models_menu.addAction(action)
menu.addMenu(models_menu)
self.add_default_menu_items_for_node(node, menu)
if not menu.isEmpty():
menu.exec_(QCursor.pos())
def contextMenuEvent(self, e):
menu = QMenu(self)
subMenu = QMenu(menu)
titleHistoryMenu = QCoreApplication.translate("PythonConsole", "Command History")
subMenu.setTitle(titleHistoryMenu)
subMenu.addAction(
QCoreApplication.translate("PythonConsole", "Show"),
self.showHistory, 'Ctrl+Shift+SPACE')
subMenu.addSeparator()
subMenu.addAction(
QCoreApplication.translate("PythonConsole", "Save"),
self.writeHistoryFile)
subMenu.addSeparator()
subMenu.addAction(
QCoreApplication.translate("PythonConsole", "Clear File"),
self.clearHistory)
subMenu.addAction(
QCoreApplication.translate("PythonConsole", "Clear Session"),
self.clearHistorySession)
menu.addMenu(subMenu)
menu.addSeparator()
copyAction = menu.addAction(
QCoreApplication.translate("PythonConsole", "Copy"),
self.copy, QKeySequence.Copy)
pasteAction = menu.addAction(
QCoreApplication.translate("PythonConsole", "Paste"),
self.paste, QKeySequence.Paste)
copyAction.setEnabled(False)
pasteAction.setEnabled(False)
if self.hasSelectedText():
copyAction.setEnabled(True)
if QApplication.clipboard().text():
pasteAction.setEnabled(True)
menu.exec_(self.mapToGlobal(e.pos()))
def layercontextmenu(layer, pos, parent=None):
"""Show a context menu to manipulate properties of layer.
layer -- a volumina layer instance
pos -- QPoint
"""
menu = QMenu("Menu", parent)
# Title
title = QAction("%s" % layer.name, menu)
title.setEnabled(False)
menu.addAction(title)
# Export
global _has_lazyflow
if _has_lazyflow:
export = QAction("Export...", menu)
export.setStatusTip("Export Layer...")
export.triggered.connect(partial(get_settings_and_export_layer, layer, menu))
menu.addAction(export)
menu.addSeparator()
_add_actions(layer, menu)
# Layer-custom context menu items
menu.addSeparator()
for item in layer.contexts:
if isinstance(item, QAction):
menu.addAction(item)
elif isinstance(item, QMenu):
menu.addMenu(item)
menu.exec_(pos)
def process_custom_menu(self, point):
''' See XmlController for documentation '''
item = self.select_item_at(point)
if not item:
return
menu = QMenu()
node = item.node
if node.get('executable') == 'True':
menu.addAction(self.actRunScenario)
elif node.get('type') in ['selectable', 'model_choice']:
menu.addAction(self.actMoveNodeUp)
menu.addAction(self.actMoveNodeDown)
elif node.tag == 'models_to_run': # special case of a selectable list
models_menu = QMenu(menu)
models_menu.setTitle('Add model to run')
models_menu.setIcon(IconLibrary.icon('add'))
available_model_names = get_model_names(self.project)
for model_name in available_model_names:
cb = lambda x=model_name, y=self.selected_index(
): self.addModel(y, x)
action = self.create_action('model', model_name, cb)
models_menu.addAction(action)
menu.addMenu(models_menu)
self.add_default_menu_items_for_node(node, menu)
if not menu.isEmpty():
menu.exec_(QCursor.pos())
def textEffectMenu(self):
format = self.currentCharFormat()
cursor = self.textCursor()
blockformat = cursor.blockFormat()
menu = QMenu("Text Effect")
for text, shortcut, data, checked in (
("&Bold", "Ctrl+B", notetextedit.Bold,
self.fontWeight() > QFont.Normal),
("&Italic", "Ctrl+I", notetextedit.Italic,
self.fontItalic()),
("&Monospaced", None, notetextedit.Code,
self.fontFixedPitch())
):
action = menu.addAction(text, self.setTextEffect)
#if shortcut is not None:
#action.setShortcut(QKeySequence(shortcut)) # becau
action.setData(QVariant(data))
action.setCheckable(True)
action.setChecked(checked)
menu.addSeparator()
action = menu.addAction("Anchor", self.setTextEffect)
action.setData(notetextedit.Anchor)
action = menu.addAction("Code Block", self.setTextEffect)
action.setData(notetextedit.Pre)
action = menu.addAction("Numbered List", self.setTextEffect)
action.setData(notetextedit.List)
header_menu = QMenu("Header")
action = header_menu.addAction('H1', self.setTextEffect)
action.setData(notetextedit.H1)
action.setCheckable(True)
action.setChecked(self.which_header()=='H1')
action = header_menu.addAction('H2', self.setTextEffect)
action.setData(notetextedit.H2)
action.setCheckable(True)
action.setChecked(self.which_header()=='H2')
action = header_menu.addAction('H3', self.setTextEffect)
action.setData(notetextedit.H3)
action.setCheckable(True)
action.setChecked(self.which_header()=='H3')
action = menu.addAction("Remove All Formatting", self.setTextEffect)
action.setData(notetextedit.Remove)
menu.addMenu(header_menu)
menu.addSeparator()
action = menu.addAction("Save", self.setTextEffect)
action.setData(notetextedit.Save)
self.ensureCursorVisible()
menu.exec_(self.viewport().mapToGlobal(self.cursorRect().center()))
def textEffectMenu(self):
format = self.currentCharFormat()
cursor = self.textCursor()
blockformat = cursor.blockFormat()
menu = QMenu("Text Effect")
for text, shortcut, data, checked in (
("&Bold", "Ctrl+B", notetextedit.Bold,
self.fontWeight() > QFont.Normal),
("&Italic", "Ctrl+I", notetextedit.Italic,
self.fontItalic()),
("&Monospaced", None, notetextedit.Code,
self.fontFixedPitch())
):
action = menu.addAction(text, self.setTextEffect)
#if shortcut is not None:
#action.setShortcut(QKeySequence(shortcut)) # becau
action.setData(QVariant(data))
action.setCheckable(True)
action.setChecked(checked)
menu.addSeparator()
action = menu.addAction("Anchor", self.setTextEffect)
action.setData(notetextedit.Anchor)
action = menu.addAction("Code Block", self.setTextEffect)
action.setData(notetextedit.Pre)
action = menu.addAction("Numbered List", self.setTextEffect)
action.setData(notetextedit.List)
header_menu = QMenu("Header")
action = header_menu.addAction('H1', self.setTextEffect)
action.setData(notetextedit.H1)
action.setCheckable(True)
action.setChecked(self.which_header()=='H1')
action = header_menu.addAction('H2', self.setTextEffect)
action.setData(notetextedit.H2)
action.setCheckable(True)
action.setChecked(self.which_header()=='H2')
action = header_menu.addAction('H3', self.setTextEffect)
action.setData(notetextedit.H3)
action.setCheckable(True)
action.setChecked(self.which_header()=='H3')
action = menu.addAction("Remove All Formatting", self.setTextEffect)
action.setData(notetextedit.Remove)
menu.addMenu(header_menu)
menu.addSeparator()
action = menu.addAction("Save", self.setTextEffect)
action.setData(notetextedit.Save)
self.ensureCursorVisible()
menu.exec_(self.viewport().mapToGlobal(self.cursorRect().center()))
def _menu_context_tree(self, point, isRoot=False, root_path=None):
index = self.indexAt(point)
if not index.isValid() and not isRoot:
return
handler = None
menu = QMenu(self)
if isRoot or self.model().isDir(index):
self._add_context_menu_for_folders(menu, isRoot, root_path)
else:
filename = self.model().fileName(index)
lang = file_manager.get_file_extension(filename)
self._add_context_menu_for_files(menu, lang)
if isRoot:
#get the extra context menu for this projectType
handler = settings.get_project_type_handler(
self.project.project_type)
self._add_context_menu_for_root(menu)
menu.addMenu(self._folding_menu)
#menu for the Project Type(if present)
if handler:
for m in handler.get_context_menus():
if isinstance(m, QMenu):
menu.addSeparator()
menu.addMenu(m)
#show the menu!
menu.exec_(QCursor.pos())
def labelingContextMenu(self,names,op,position5d):
menu = QMenu(self)
menu.setObjectName("carving_context_menu")
posItem = menu.addAction("position %d %d %d" % (position5d[1], position5d[2], position5d[3]))
posItem.setEnabled(False)
menu.addSeparator()
for name in names:
submenu = QMenu(name,menu)
# Load
loadAction = submenu.addAction("Load %s" % name)
loadAction.triggered.connect( partial(op.loadObject, name) )
# Delete
def onDelAction(_name):
self.confirmAndDelete([_name])
if self.render and self._renderMgr.ready:
self._update_rendering()
delAction = submenu.addAction("Delete %s" % name)
delAction.triggered.connect( partial(onDelAction, name) )
if self.render:
if name in self._shownObjects3D:
# Remove
def onRemove3D(_name):
label = self._shownObjects3D.pop(_name)
self._renderMgr.removeObject(label)
self._update_rendering()
removeAction = submenu.addAction("Remove %s from 3D view" % name)
removeAction.triggered.connect( partial(onRemove3D, name) )
else:
# Show
def onShow3D(_name):
label = self._renderMgr.addObject()
self._shownObjects3D[_name] = label
self._update_rendering()
showAction = submenu.addAction("Show 3D %s" % name)
showAction.triggered.connect( partial(onShow3D, name ) )
menu.addMenu(submenu)
if names:
menu.addSeparator()
menu.addSeparator()
if self.render:
showSeg3DAction = menu.addAction( "Show Editing Segmentation in 3D" )
showSeg3DAction.setCheckable(True)
showSeg3DAction.setChecked( self._showSegmentationIn3D )
showSeg3DAction.triggered.connect( self._toggleSegmentation3D )
if op.dataIsStorable():
menu.addAction("Save object").triggered.connect( self.onSaveButton )
menu.addAction("Browse objects").triggered.connect( self.onShowObjectNames )
menu.addAction("Segment").triggered.connect( self.onSegmentButton )
menu.addAction("Clear").triggered.connect( self.topLevelOperatorView.clearCurrentLabeling )
return menu
def __onContextMenu( self, pos ):
" Triggered when a context menu is requested "
pluginMenus = self.__editorsManager.getPluginMenus()
if pluginMenus:
contextMenu = QMenu()
for pluginPath, pluginMenu in pluginMenus.iteritems():
contextMenu.addMenu( pluginMenu )
contextMenu.exec_( QCursor.pos() )
del contextMenu
return
def createMenuFromDict(dictionary):
menu = QMenu()
for name, item in dictionary.iteritems():
if isinstance(item, dict):
submenu = createMenuFromDict(item)
submenu.setTitle(name)
menu.addMenu(submenu)
else:
menu_action = menu.addAction(name)
menu_action.triggered.connect(item)
return menu
def createCtxMenu(self, value, isLink, evt):
'Creates and configures the menu itself'
m = QMenu(self)
sub = QMenu(Label.BROWSER_ASSIGN_TO, m)
m.setTitle(Label.BROWSER_ASSIGN_TO)
for index, label in self._fields.items():
act = QAction(label, m,
triggered=self._makeMenuAction(index, value, isLink))
sub.addAction(act)
m.addMenu(sub)
action = m.exec_(self.mapToGlobal(evt.pos()))
def databaseContextMenu(self, point):
"""
@type point: QPoint
"""
databaseMenu = QMenu()
databaseCreateMenu = databaseMenu.addMenu(QIcon('../resources/icons/application_form_add.png'), 'Create new')
databaseCreateMenu.menuAction().setIconVisibleInMenu(True)
databaseMenu.addMenu(databaseCreateMenu)
createTableMenuItem = databaseCreateMenu.addAction(QIcon('../resources/icons/table.png'), 'Table')
createTableMenuItem.setIconVisibleInMenu(True)
createTableMenuItem.triggered.connect(self.tableTab.createTableAction)
databaseMenu.exec_(self.mainWindow.databaseInfoTable.viewport().mapToGlobal(point))
def context_menu_for_root(self):
menu = QMenu(self)
path = self.current_tree.project.path
action_add_file = menu.addAction(QIcon(":img/new"),
translations.TR_ADD_NEW_FILE)
action_add_folder = menu.addAction(QIcon(
":img/openProj"), translations.TR_ADD_NEW_FOLDER)
action_create_init = menu.addAction(translations.TR_CREATE_INIT)
self.connect(action_add_file, SIGNAL("triggered()"),
lambda: self.current_tree._add_new_file(path))
self.connect(action_add_folder, SIGNAL("triggered()"),
lambda: self.current_tree._add_new_folder(path))
self.connect(action_create_init, SIGNAL("triggered()"),
lambda: self.current_tree._create_init(path))
menu.addSeparator()
actionRunProject = menu.addAction(QIcon(
":img/play"), translations.TR_RUN_PROJECT)
self.connect(actionRunProject, SIGNAL("triggered()"),
self.current_tree._execute_project)
if self.current_tree._added_to_console:
actionRemoveFromConsole = menu.addAction(
translations.TR_REMOVE_PROJECT_FROM_PYTHON_CONSOLE)
self.connect(actionRemoveFromConsole, SIGNAL("triggered()"),
self.current_tree._remove_project_from_console)
else:
actionAdd2Console = menu.addAction(
translations.TR_ADD_PROJECT_TO_PYTHON_CONSOLE)
self.connect(actionAdd2Console, SIGNAL("triggered()"),
self.current_tree._add_project_to_console)
actionShowFileSizeInfo = menu.addAction(translations.TR_SHOW_FILESIZE)
self.connect(actionShowFileSizeInfo, SIGNAL("triggered()"),
self.current_tree.show_filesize_info)
actionProperties = menu.addAction(QIcon(":img/pref"),
translations.TR_PROJECT_PROPERTIES)
self.connect(actionProperties, SIGNAL("triggered()"),
self.current_tree.open_project_properties)
menu.addSeparator()
action_close = menu.addAction(
self.style().standardIcon(QStyle.SP_DialogCloseButton),
translations.TR_CLOSE_PROJECT)
self.connect(action_close, SIGNAL("triggered()"),
self.current_tree._close_project)
#menu for the project
for m in self.current_tree.extra_menus_by_scope['project']:
if isinstance(m, QMenu):
menu.addSeparator()
menu.addMenu(m)
#show the menu!
menu.exec_(QCursor.pos())
def context_menu_for_root(self):
menu = QMenu(self)
path = self.current_tree.project.path
action_add_file = menu.addAction(QIcon(":img/new"),
translations.TR_ADD_NEW_FILE)
action_add_folder = menu.addAction(QIcon(":img/openProj"),
translations.TR_ADD_NEW_FOLDER)
action_create_init = menu.addAction(translations.TR_CREATE_INIT)
self.connect(action_add_file, SIGNAL("triggered()"),
lambda: self.current_tree._add_new_file(path))
self.connect(action_add_folder, SIGNAL("triggered()"),
lambda: self.current_tree._add_new_folder(path))
self.connect(action_create_init, SIGNAL("triggered()"),
lambda: self.current_tree._create_init(path))
menu.addSeparator()
actionRunProject = menu.addAction(QIcon(":img/play"),
translations.TR_RUN_PROJECT)
self.connect(actionRunProject, SIGNAL("triggered()"),
self.current_tree._execute_project)
if self.current_tree._added_to_console:
actionRemoveFromConsole = menu.addAction(
translations.TR_REMOVE_PROJECT_FROM_PYTHON_CONSOLE)
self.connect(actionRemoveFromConsole, SIGNAL("triggered()"),
self.current_tree._remove_project_from_console)
else:
actionAdd2Console = menu.addAction(
translations.TR_ADD_PROJECT_TO_PYTHON_CONSOLE)
self.connect(actionAdd2Console, SIGNAL("triggered()"),
self.current_tree._add_project_to_console)
actionShowFileSizeInfo = menu.addAction(translations.TR_SHOW_FILESIZE)
self.connect(actionShowFileSizeInfo, SIGNAL("triggered()"),
self.current_tree.show_filesize_info)
actionProperties = menu.addAction(QIcon(":img/pref"),
translations.TR_PROJECT_PROPERTIES)
self.connect(actionProperties, SIGNAL("triggered()"),
self.current_tree.open_project_properties)
menu.addSeparator()
action_close = menu.addAction(
self.style().standardIcon(QStyle.SP_DialogCloseButton),
translations.TR_CLOSE_PROJECT)
self.connect(action_close, SIGNAL("triggered()"),
self.current_tree._close_project)
#menu for the project
for m in self.current_tree.extra_menus_by_scope['project']:
if isinstance(m, QMenu):
menu.addSeparator()
menu.addMenu(m)
#show the menu!
menu.exec_(QCursor.pos())
def menuContextTree(self, point):
index = self.indexAt(point)
if not index.isValid():
return
item = self.itemAt(point)
name = item.text(0)
menu=QMenu(self)
if item.isFolder or item.parent() is None:
action_add_file = menu.addAction(QIcon(resources.images['new']), 'Add New File')
self.connect(action_add_file, SIGNAL("triggered()"), self._add_new_file)
action_add_folder = menu.addAction(QIcon(resources.images['openProj']), 'Add New Folder')
self.connect(action_add_folder, SIGNAL("triggered()"), self._add_new_folder)
action_create_init = menu.addAction('Create "__init__" Complete')
self.connect(action_create_init, SIGNAL("triggered()"), self._create_init)
elif not item.isFolder:
action_remove_file = menu.addAction(self.style().standardIcon(QStyle.SP_DialogCloseButton),
'Delete File')
self.connect(action_remove_file, SIGNAL("triggered()"), self._delete_file)
# action_load_symbols = menu.addAction(self.style().standardIcon(QStyle.SP_DialogCloseButton),
# 'Load Symbols')
# self.connect(action_load_symbols, SIGNAL("triggered()"), self._load_file_symbols)
if item.parent() is None:
menu.addSeparator()
actionRunProject = menu.addAction(QIcon(resources.images['play']), 'Run Project')
self.connect(actionRunProject, SIGNAL("triggered()"), self.run_project)
actionMainProject = menu.addAction('Set as Main Project')
self.connect(actionMainProject, SIGNAL("triggered()"), lambda: self.set_default_project(item))
actionProperties = menu.addAction(QIcon(resources.images['pref']), 'Project Properties')
self.connect(actionProperties, SIGNAL("triggered()"), self.open_project_properties)
if self.extraMenus.get(item.projectType, False):
menus = self.extraMenus[item.projectType]
for m in menus:
menu.addSeparator()
menu.addMenu(m)
if self.extraMenus.get(item.lang(), False):
menus = self.extraMenus[item.lang()]
for m in menus:
menu.addSeparator()
menu.addMenu(m)
menu.addSeparator()
action_refresh = menu.addAction(self.style().standardIcon(QStyle.SP_BrowserReload),
'Refresh Project')
self.connect(action_refresh, SIGNAL("triggered()"), self._refresh_project)
action_close = menu.addAction(self.style().standardIcon(QStyle.SP_DialogCloseButton),
'Close Project')
self.connect(action_close, SIGNAL("triggered()"), self._close_project)
menu.exec_(QCursor.pos())
def databaseContextMenu(self, point):
"""
@type point: QPoint
"""
databaseMenu = QMenu()
databaseCreateMenu = databaseMenu.addMenu(
QIcon('../resources/icons/application_form_add.png'), 'Create new')
databaseCreateMenu.menuAction().setIconVisibleInMenu(True)
databaseMenu.addMenu(databaseCreateMenu)
createTableMenuItem = databaseCreateMenu.addAction(
QIcon('../resources/icons/table.png'), 'Table')
createTableMenuItem.setIconVisibleInMenu(True)
createTableMenuItem.triggered.connect(self.tableTab.createTableAction)
databaseMenu.exec_(
self.mainWindow.databaseInfoTable.viewport().mapToGlobal(point))
def showHeaderMenu( self, point ):
# determine the column that was clicked on
index = self.uiPlaylistTREE.header().logicalIndexAt(point)
self._currentHeaderColumn = index
# create the menu
menu = QMenu(self)
act = menu.addAction( 'Sort Ascending' )
act.setIcon( resources.icon( 'img/playlist/sort_ascending.png' ) )
act.triggered.connect( self.sortAscending )
act = menu.addAction( 'Sort Descending' )
act.setIcon( resources.icon( 'img/playlist/sort_descending.png' ) )
act.triggered.connect( self.sortDescending )
menu.addSeparator()
# create a columns menu
columns = menu.addMenu( 'Columns...' )
columns.setIcon( resources.icon( 'img/playlist/columns.png' ) )
for c, col in enumerate(self.COLUMNS):
act = columns.addAction( col )
act.setCheckable(True)
act.setChecked( not self.uiPlaylistTREE.isColumnHidden(c) )
columns.triggered.connect( self.toggleColumnTriggered )
# popup the menu
menu.exec_( QCursor.pos() )
def showHeaderMenu(self, point):
# determine the column that was clicked on
index = self.uiPlaylistTREE.header().logicalIndexAt(point)
self._currentHeaderColumn = index
# create the menu
menu = QMenu(self)
act = menu.addAction('Sort Ascending')
act.setIcon(resources.icon('img/playlist/sort_ascending.png'))
act.triggered.connect(self.sortAscending)
act = menu.addAction('Sort Descending')
act.setIcon(resources.icon('img/playlist/sort_descending.png'))
act.triggered.connect(self.sortDescending)
menu.addSeparator()
# create a columns menu
columns = menu.addMenu('Columns...')
columns.setIcon(resources.icon('img/playlist/columns.png'))
for c, col in enumerate(self.COLUMNS):
act = columns.addAction(col)
act.setCheckable(True)
act.setChecked(not self.uiPlaylistTREE.isColumnHidden(c))
columns.triggered.connect(self.toggleColumnTriggered)
# popup the menu
menu.exec_(QCursor.pos())
def prepareContextMenu(self):
context_menu = QMenu(self)
var = self.selectionModel().currentIndex().internalPointer()
if isinstance(var, TreeStdVariable):
filters.add_actions_for_all_filters(context_menu.addMenu(
"Set Filter for %s..." % var.exp), var)
return context_menu
def contextMenuEvent(self, event):
if self.keepOnTop:
self.keepOnTopMenuText = "Don't keep icon on top"
else:
self.keepOnTopMenuText = 'Keep icon on top'
menu = QMenu(self)
pastebinAction = menu.addAction("Pastebin")
menu.addSeparator()
if len(self.clipboardKeys)>0:
downloadMenu = QMenu('Put on download queue', self)
for idx,key in enumerate(self.clipboardKeys):
label = key[0]+'@'+key[1][:7]+'...'+key[1][-20:]
mItem = downloadMenu.addAction(label)
receiver = lambda taskType=idx:self.dlAction(taskType)
self.connect(mItem, SIGNAL('triggered()'), receiver)
downloadMenu.addAction(mItem)
menu.addMenu(downloadMenu)
browserMenu = QMenu('Open in Browser', self)
for idx,key in enumerate(self.clipboardKeys):
label = key[0]+'@'+key[1][:7]+'...'+key[1][-14:]
bItem = browserMenu.addAction(label)
receiver = lambda taskType=idx:self.brAction(taskType)
self.connect(bItem, SIGNAL('triggered()'), receiver)
browserMenu.addAction(bItem)
menu.addMenu(browserMenu)
menu.addSeparator()
keepOnTopAction = menu.addAction(self.keepOnTopMenuText)
settingsAction = menu.addAction("Settings")
menu.addSeparator()
quitAction = menu.addAction("Quit")
action = menu.exec_(self.mapToGlobal(event.pos()))
if action == quitAction:
self.closeApp()
if action == settingsAction:
self.settings.show()
if action == pastebinAction:
self.pastebin.show()
if action == keepOnTopAction:
if self.keepOnTop:
self.setKeepOnTop(False)
else:
self.setKeepOnTop(True)
def contextMenuEvent(self, event):
if self.keepOnTop:
self.keepOnTopMenuText = "Don't keep icon on top"
else:
self.keepOnTopMenuText = 'Keep icon on top'
menu = QMenu(self)
pastebinAction = menu.addAction("Pastebin")
menu.addSeparator()
if len(self.clipboardKeys) > 0:
downloadMenu = QMenu('Put on download queue', self)
for idx, key in enumerate(self.clipboardKeys):
label = key[0] + '@' + key[1][:7] + '...' + key[1][-20:]
mItem = downloadMenu.addAction(label)
receiver = lambda taskType=idx: self.dlAction(taskType)
self.connect(mItem, SIGNAL('triggered()'), receiver)
downloadMenu.addAction(mItem)
menu.addMenu(downloadMenu)
browserMenu = QMenu('Open in Browser', self)
for idx, key in enumerate(self.clipboardKeys):
label = key[0] + '@' + key[1][:7] + '...' + key[1][-14:]
bItem = browserMenu.addAction(label)
receiver = lambda taskType=idx: self.brAction(taskType)
self.connect(bItem, SIGNAL('triggered()'), receiver)
browserMenu.addAction(bItem)
menu.addMenu(browserMenu)
menu.addSeparator()
keepOnTopAction = menu.addAction(self.keepOnTopMenuText)
settingsAction = menu.addAction("Settings")
menu.addSeparator()
quitAction = menu.addAction("Quit")
action = menu.exec_(self.mapToGlobal(event.pos()))
if action == quitAction:
self.closeApp()
if action == settingsAction:
self.settings.show()
if action == pastebinAction:
self.pastebin.show()
if action == keepOnTopAction:
if self.keepOnTop:
self.setKeepOnTop(False)
else:
self.setKeepOnTop(True)
def menuContextTree(self, point):
index = self.indexAt(point)
if not index.isValid():
return
item = self.itemAt(point)
name = item.text(0)
menu = QMenu(self)
if item.isFolder or item.parent() is None:
action_add_file = menu.addAction(QIcon(resources.images['new']), 'Add New File')
self.connect(action_add_file, SIGNAL("triggered()"), self._add_new_file)
action_add_folder = menu.addAction(QIcon(resources.images['openProj']), 'Add New Folder')
self.connect(action_add_folder, SIGNAL("triggered()"), self._add_new_folder)
action_create_init = menu.addAction('Create "__init__" Complete')
self.connect(action_create_init, SIGNAL("triggered()"), self._create_init)
elif not item.isFolder:
action_remove_file = menu.addAction(self.style().standardIcon(QStyle.SP_DialogCloseButton),
'Delete File')
self.connect(action_remove_file, SIGNAL("triggered()"), self._delete_file)
if item.parent() is None:
menu.addSeparator()
actionRunProject = menu.addAction(QIcon(resources.images['play']), 'Run Project')
self.connect(actionRunProject, SIGNAL("triggered()"), self.run_project)
actionMainProject = menu.addAction('Set as Main Project')
self.connect(actionMainProject, SIGNAL("triggered()"), lambda: self.set_default_project(item))
actionProperties = menu.addAction(QIcon(resources.images['pref']), 'Project Properties')
self.connect(actionProperties, SIGNAL("triggered()"), self.open_project_properties)
if self.extraMenus.get(item.projectType, False):
menus = self.extraMenus[item.projectType]
for m in menus:
menu.addSeparator()
menu.addMenu(m)
if self.extraMenus.get(item.lang(), False):
menus = self.extraMenus[item.lang()]
for m in menus:
menu.addSeparator()
menu.addMenu(m)
menu.addSeparator()
action_refresh = menu.addAction(self.style().standardIcon(QStyle.SP_BrowserReload),
'Refresh Project')
self.connect(action_refresh, SIGNAL("triggered()"), self._refresh_project)
action_close = menu.addAction(self.style().standardIcon(QStyle.SP_DialogCloseButton),
'Close Project')
self.connect(action_close, SIGNAL("triggered()"), self._close_project)
menu.exec_(QCursor.pos())
class DownloadTable(QTableView):
def __init__(self, parent = None):
super(DownloadTable, self).__init__(parent)
self.setHorizontalScrollBarPolicy(Qt.ScrollBarAlwaysOff)
self.setEditTriggers(QAbstractItemView.NoEditTriggers)
# self.setSelectionMode(QAbstractItemView.SingleSelection)
self.setSelectionBehavior(QAbstractItemView.SelectRows)
self.horizontalHeader().setDefaultAlignment(Qt.AlignLeft)
# self.horizontalHeader().setStretchLastSection(True)
self.create_contextmenu()
def initial_view(self, model):
self.setModel(model)
self.hideColumn(4)
self.hideColumn(5)
self.hideColumn(6)
self.hideColumn(7)
self.hideColumn(8)
def create_contextmenu(self):
self.setContextMenuPolicy(Qt.CustomContextMenu)
self.listMenu = QMenu()
self.listMenu1 = QMenu("下载控制")
self.playAction = QAction("播放", self)
self.pauseDownloadAction = QAction("暂停", self)
self.stopDownloadAction = QAction("取消下载", self)
self.startDownloadAction = QAction("开始", self)
self.pauseAllAction = QAction("暂停全部", self)
self.startAllAction = QAction("开始全部", self)
self.stopAllAction = QAction("取消全部", self)
self.removeRowsAction = QAction("移除选中项", self)
self.clearTableAction = QAction("清空列表", self)
self.listMenu1.addAction(self.startDownloadAction)
self.listMenu1.addAction(self.startAllAction)
self.listMenu1.addSeparator()
self.listMenu1.addAction(self.pauseDownloadAction)
self.listMenu1.addAction(self.pauseAllAction)
self.listMenu1.addSeparator()
self.listMenu1.addAction(self.stopDownloadAction)
# self.listMenu.addAction(self.stopAllAction)
self.listMenu.addAction(self.playAction)
self.listMenu.addSeparator()
self.listMenu.addMenu(self.listMenu1)
self.listMenu.addSeparator()
self.listMenu.addAction(self.removeRowsAction)
self.listMenu.addAction(self.clearTableAction)
def process_custom_menu(self, point):
''' See XmlConfig.processCustomMenu for documentation '''
index = self.select_item_at(point)
if not index:
return
node = self.selected_item().node
menu = QMenu(self.view)
if node.tag == 'models':
submenu = QMenu(menu) # to populate with templates
submenu.setTitle('Create model from template')
for action in self.create_from_template_actions:
submenu.addAction(action)
menu.addMenu(submenu)
if node.tag == 'model':
# If the users right clicks a model, give them the option to
# estimate it only if the model has a (non empty) specification
# subnode. If the model holds subgroups -- inform the user how to
# estimate them.
spec_node = node.find('specification')
submodels = None
if spec_node is not None:
submodels = spec_node.getchildren()
if spec_node is not None and submodels:
# check if its groups by type checking the first node
# note: this is not a reliable method if models can have mixed
# submodels and submodel groups.
if submodels[0].tag == 'submodel':
menu.addAction(self.action_run_estimation)
else:
menu.addAction(self.action_show_how_to_estimate_groups)
if node.tag == 'submodel' and not node.get('inherited'):
menu.addAction(self.action_edit_submodel)
if node.tag == 'submodel_group':
menu.addAction(self.action_run_estimation_group)
self.add_default_menu_items_for_node(node, menu)
if not menu.isEmpty():
menu.exec_(QCursor.pos())
def process_custom_menu(self, point):
''' See XmlConfig.processCustomMenu for documentation '''
index = self.select_item_at(point)
if not index:
return
node = self.selected_item().node
menu = QMenu(self.view)
if node.tag == 'models':
submenu = QMenu(menu) # to populate with templates
submenu.setTitle('Create model from template')
for action in self.create_from_template_actions:
submenu.addAction(action)
menu.addMenu(submenu)
if node.tag == 'model':
# If the users right clicks a model, give them the option to
# estimate it only if the model has a (non empty) specification
# subnode. If the model holds subgroups -- inform the user how to
# estimate them.
spec_node = node.find('specification')
submodels = None
if spec_node is not None:
submodels = spec_node.getchildren()
if spec_node is not None and submodels:
# check if its groups by type checking the first node
# note: this is not a reliable method if models can have mixed
# submodels and submodel groups.
if submodels[0].tag == 'submodel':
menu.addAction(self.action_run_estimation)
else:
menu.addAction(self.action_show_how_to_estimate_groups)
if node.tag == 'submodel' and not node.get('inherited'):
menu.addAction(self.action_edit_submodel)
if node.tag == 'submodel_group':
menu.addAction(self.action_run_estimation_group)
self.add_default_menu_items_for_node(node, menu)
if not menu.isEmpty():
menu.exec_(QCursor.pos())
def contextMenuEvent(self, event):
QTreeView.contextMenuEvent(self, event)
if not event.isAccepted():
selectionModel = self.selectionModel()
wrapper = selectionModel.currentIndex().internalPointer()
if isinstance(wrapper, TreeStdVarWrapper):
menu = QMenu()
filters.add_actions_for_all_filters(menu.addMenu("Set Filter for %s..." % wrapper.getExp()), wrapper)
menu.exec_(event.globalPos())
def mousePressEvent(self, event):
QTabWidget.mousePressEvent(self, event)
if self.follow_mode:
return
if event.button() == Qt.RightButton:
index = self.tabBar().tabAt(event.pos())
self.setCurrentIndex(index)
widget = self.widget(index)
if type(widget) is editor.Editor:
#show menu
menu = QMenu()
actionAdd = menu.addAction(self.tr("Add to Project..."))
actionRun = menu.addAction(self.tr("Run this File!"))
menuSyntax = menu.addMenu(self.tr("Change Syntax"))
self._create_menu_syntax(menuSyntax)
menu.addSeparator()
actionClose = menu.addAction(self.tr("Close This Tab"))
actionCloseAll = menu.addAction(self.tr("Close All Tabs"))
actionCloseAllNotThis = menu.addAction(
self.tr("Close Other Tabs"))
menu.addSeparator()
actionSplitH = menu.addAction(
self.tr("Split this Tab (Vertically)"))
actionSplitV = menu.addAction(
self.tr("Split this Tab (Horizontally)"))
#Connect split actions
self.connect(actionSplitH, SIGNAL("triggered()"),
lambda: self._split_this_tab(True))
self.connect(actionSplitV, SIGNAL("triggered()"),
lambda: self._split_this_tab(False))
menu.addSeparator()
actionCopyPath = menu.addAction(
self.tr("Copy file location to Clipboard"))
actionReopen = menu.addAction(
self.tr("Reopen last closed File"))
if len(self.__lastOpened) == 0:
actionReopen.setEnabled(False)
#Connect actions
self.connect(actionRun, SIGNAL("triggered()"),
self._run_this_file)
self.connect(actionAdd, SIGNAL("triggered()"),
self._add_to_project)
self.connect(actionClose, SIGNAL("triggered()"),
lambda: self.removeTab(index))
self.connect(actionCloseAllNotThis, SIGNAL("triggered()"),
self._close_all_tabs_except_this)
self.connect(actionCloseAll, SIGNAL("triggered()"),
self._close_all_tabs)
self.connect(actionCopyPath, SIGNAL("triggered()"),
self._copy_file_location)
self.connect(actionReopen, SIGNAL("triggered()"),
self._reopen_last_tab)
menu.exec_(event.globalPos())
if event.button() == Qt.MidButton:
index = self.tabBar().tabAt(event.pos())
self.removeTab(index)
def mousePressEvent(self, event):
QTabWidget.mousePressEvent(self, event)
if self.follow_mode:
return
if event.button() == Qt.RightButton:
index = self.tabBar().tabAt(event.pos())
self.setCurrentIndex(index)
widget = self.widget(index)
if type(widget) is editor.Editor:
#show menu
menu = QMenu()
actionAdd = menu.addAction(self.tr("Add to Project..."))
actionRun = menu.addAction(self.tr("Run this File!"))
menuSyntax = menu.addMenu(self.tr("Change Syntax"))
self._create_menu_syntax(menuSyntax)
menu.addSeparator()
actionClose = menu.addAction(self.tr("Close This Tab"))
actionCloseAll = menu.addAction(self.tr("Close All Tabs"))
actionCloseAllNotThis = menu.addAction(
self.tr("Close Other Tabs"))
menu.addSeparator()
actionSplitH = menu.addAction(
self.tr("Split this Tab (Vertically)"))
actionSplitV = menu.addAction(
self.tr("Split this Tab (Horizontally)"))
#Connect split actions
self.connect(actionSplitH, SIGNAL("triggered()"),
lambda: self._split_this_tab(True))
self.connect(actionSplitV, SIGNAL("triggered()"),
lambda: self._split_this_tab(False))
menu.addSeparator()
actionCopyPath = menu.addAction(
self.tr("Copy file location to Clipboard"))
actionReopen = menu.addAction(
self.tr("Reopen last closed File"))
if len(self.__lastOpened) == 0:
actionReopen.setEnabled(False)
#Connect actions
self.connect(actionRun, SIGNAL("triggered()"),
self._run_this_file)
self.connect(actionAdd, SIGNAL("triggered()"),
self._add_to_project)
self.connect(actionClose, SIGNAL("triggered()"),
lambda: self.removeTab(index))
self.connect(actionCloseAllNotThis, SIGNAL("triggered()"),
self._close_all_tabs_except_this)
self.connect(actionCloseAll, SIGNAL("triggered()"),
self._close_all_tabs)
self.connect(actionCopyPath, SIGNAL("triggered()"),
self._copy_file_location)
self.connect(actionReopen, SIGNAL("triggered()"),
self._reopen_last_tab)
menu.exec_(event.globalPos())
if event.button() == Qt.MidButton:
index = self.tabBar().tabAt(event.pos())
self.removeTab(index)
def showCentralWidgetContextMenu(self, pos):
menu = QMenu()
title = self.ui.hostsDock.windowTitle()
hostsDockAction = menu.addAction(title)
hostsDockAction.setCheckable(True)
hostsDockAction.setChecked(self.ui.hostsDock.isVisible())
hostsDockAction.triggered.connect(self.changeHostsDockWidgetVisibility)
hostsDockAction = menu.addAction("Tray icon")
hostsDockAction.setCheckable(True)
hostsDockAction.setChecked(self.tray.isVisible())
hostsDockAction.triggered.connect(self.changeTrayIconVisibility)
connectHostMenuTray = ConnectHostMenu(self.hosts, "Connect")
connectHostMenuTray.triggered.connect(self.connectHostFromMenu)
menu.addMenu(connectHostMenuTray)
menu.exec_(self.tabWidget.mapToGlobal(pos))
def contextMenu(self, pos):
menu = QMenu()
menu.addActions(self.contextMenuActions)
difficultyMenu = menu.addMenu("Change difficulty")
difficultyMenu.addActions(self.difficultyActions)
# change position a little to have a corner of the menu where the mouse is
if platform.system() != "Windows":
menu.exec_(self.wordsTable.mapToGlobal(QPoint(pos.x()+18,pos.y() +24)))
else:
menu.exec_(self.wordsTable.mapToGlobal(QPoint(pos.x()+16,pos.y() +24)))
def showCentralWidgetContextMenu(self, pos):
menu = QMenu()
title = self.ui.hostsDock.windowTitle()
hostsDockAction = menu.addAction(title)
hostsDockAction.setCheckable(True)
hostsDockAction.setChecked(self.ui.hostsDock.isVisible())
hostsDockAction.triggered.connect(self.changeHostsDockWidgetVisibility)
hostsDockAction = menu.addAction("Tray icon")
hostsDockAction.setCheckable(True)
hostsDockAction.setChecked(self.tray.isVisible())
hostsDockAction.triggered.connect(self.changeTrayIconVisibility)
connectHostMenuTray = ConnectHostMenu(self.hosts, "Connect")
connectHostMenuTray.triggered.connect(self.connectHostFromMenu)
menu.addMenu(connectHostMenuTray)
menu.exec_(self.tabWidget.mapToGlobal(pos))
def _createSettingsMenu(self):
menu = QMenu("&Settings", self)
# Menu item: Keyboard Shortcuts
def editShortcuts():
mgrDlg = ShortcutManagerDlg(self)
shortcutsAction = menu.addAction("&Keyboard Shortcuts")
shortcutsAction.triggered.connect(editShortcuts)
exportDebugSubmenu = menu.addMenu("Export Operator Diagram")
export0 = exportDebugSubmenu.addAction("Lowest Detail")
export0.triggered.connect( partial(self.exportCurrentOperatorDiagram, 0) )
export1 = exportDebugSubmenu.addAction("Some Detail")
export1.triggered.connect( partial(self.exportCurrentOperatorDiagram, 1) )
export2 = exportDebugSubmenu.addAction("More Detail")
export2.triggered.connect( partial(self.exportCurrentOperatorDiagram, 2) )
export2 = exportDebugSubmenu.addAction("Even More Detail")
export2.triggered.connect( partial(self.exportCurrentOperatorDiagram, 3) )
export3 = exportDebugSubmenu.addAction("Unlimited Detail")
export3.triggered.connect( partial(self.exportCurrentOperatorDiagram, 100) )
exportWorkflowSubmenu = menu.addMenu("Export Workflow Diagram")
exportWorkflow0 = exportWorkflowSubmenu.addAction("Lowest Detail")
exportWorkflow0.triggered.connect( partial(self.exportWorkflowDiagram, 0) )
exportWorkflow1 = exportWorkflowSubmenu.addAction("Some Detail")
exportWorkflow1.triggered.connect( partial(self.exportWorkflowDiagram, 1) )
exportWorkflow2 = exportWorkflowSubmenu.addAction("More Detail")
exportWorkflow2.triggered.connect( partial(self.exportWorkflowDiagram, 2) )
exportWorkflow3 = exportWorkflowSubmenu.addAction("Even More Detail")
exportWorkflow3.triggered.connect( partial(self.exportWorkflowDiagram, 3) )
exportWorkflow4 = exportWorkflowSubmenu.addAction("Unlimited Detail")
exportWorkflow4.triggered.connect( partial(self.exportWorkflowDiagram, 100) )
return menu
def _menu_context_tree(self, point):
index = self.indexAt(point)
if not index.isValid():
return
item = self.itemAt(point)
menu = QMenu(self)
if item.isFolder or item.parent() is None:
self._folder_menu_context_tree(menu, item)
elif not item.isFolder:
self._file_menu_context_tree(menu, item)
if item.parent() is None:
self._project_menu_context_tree(menu, item)
#menu for all items!
for m in self.EXTRA_MENUS.get('all', ()):
menu.addSeparator()
menu.addMenu(m)
#show the menu!
menu.exec_(QCursor.pos())
def __init__(self, undo_stack, delete_act, sel_actions, *args):
"""
Constructor
"""
params = parameters.instance
QGraphicsScene.__init__(self, *args)
self.delete_act = delete_act
self.undo_stack = undo_stack
self.data_manager = None
self._mode = None
self.link = None
self.image_path = None
self.image_name = None
self.background_image = None
self.template = TemplateItem()
self.template.setPos(QPointF(0, 0))
self.template.setVisible(params.show_template)
self.show_template = False
self.points = {}
self.cells = {}
self._real_scene_rect = QRectF()
params.pointParameterChange.connect(self.updatePoints)
params.cellParameterChange.connect(self.updateCells)
params.searchParameterChange.connect(self.updateTemplate)
self.had_selection = None
self.selectionChanged.connect(self.updateSelectionActions)
self.current_data = None
self.back_matrix = QTransform()
self.invert_back_matrix = QTransform()
self.clear()
popup = QMenu("Scene menu")
validate_cell_act = popup.addAction("Validate cell", self.validateCell)
validate_cell_act.setVisible(False)
self._validate_cell_act = validate_cell_act
lifespan_act = popup.addAction("Change cell lifespan", self.changeLifespan)
lifespan_act.setVisible(False)
self.lifespan_act = lifespan_act
make_starshape_act = popup.addAction("Make cell star shaped", self.makeCellStarshaped)
make_starshape_act.setVisible(False)
self.make_starshape_act = make_starshape_act
sel = popup.addMenu("Selection")
for act in sel_actions:
if act == "-":
sel.addSeparator()
else:
sel.addAction(act)
popup.addAction(delete_act)
self._popup = popup
self._sel_rect = None
self._sel_first_pt = None
self._current_cell = None
self._first_point = None
self.mode = TrackingScene.Pan
def __init__(self):
super(QWidget, self).__init__()
self.ui = Ui_MainWindow()
self.ui.setupUi(self)
self.systemTray = QSystemTrayIcon(self)
self.systemTray.setIcon(QIcon(':/images/icon.png'))
self.act_autostart = QAction('开机启动', self)
self.act_autostart.setCheckable(True)
is_autostart = self.is_autostart()
self.act_autostart.setChecked(is_autostart)
self.act_autostart.triggered.connect(self.on_autostart)
act_setting = QAction('设置启动项', self)
act_setting.triggered.connect(self.on_settings)
act_exit = QAction('退出', self)
act_exit.triggered.connect(self.on_exit)
self.menu_run = QMenu('运行', self)
menu = QMenu('菜单', self)
menu.addMenu(self.menu_run)
menu.addAction(act_setting)
menu.addSeparator()
menu.addAction(self.act_autostart)
menu.addAction(act_exit)
self.systemTray.setContextMenu(menu)
self.systemTray.show()
self.showMessage('启动工具正在运行')
self.ui.btn_add.clicked.connect(self.on_add)
self.ui.btn_delete.clicked.connect(self.on_delete)
self.ui.btn_apply.clicked.connect(self.on_apply)
self.ui.btn_env_add.clicked.connect(self.on_env_add)
self.ui.btn_env_del.clicked.connect(self.on_env_del)
self.ui.btn_open.clicked.connect(self.on_open)
self.ui.btn_run.clicked.connect(self.on_run)
self.ui.le_args.textEdited.connect(self.on_edited)
self.ui.le_desc.textEdited.connect(self.on_edited)
self.ui.le_exe.textEdited.connect(self.on_edited)
self.ui.cb_process.currentIndexChanged.connect(self.on_index_changed)
self.ui.le_exe.installEventFilter(self)
self.init()
def _context_menu_requested(self, point):
"""Display context menu for the combo file."""
if self.combo.count() == 0:
# If there is not an Editor opened, don't show the menu
return
menu = QMenu()
actionAdd = menu.addAction(translations.TR_ADD_TO_PROJECT)
actionRun = menu.addAction(translations.TR_RUN_FILE)
menuSyntax = menu.addMenu(translations.TR_CHANGE_SYNTAX)
self._create_menu_syntax(menuSyntax)
menu.addSeparator()
actionClose = menu.addAction(translations.TR_CLOSE_FILE)
actionCloseAll = menu.addAction(translations.TR_CLOSE_ALL_FILES)
actionCloseAllNotThis = menu.addAction(
translations.TR_CLOSE_OTHER_FILES)
menu.addSeparator()
actionSplitH = menu.addAction(translations.TR_SPLIT_VERTICALLY)
actionSplitV = menu.addAction(translations.TR_SPLIT_HORIZONTALLY)
menu.addSeparator()
actionCopyPath = menu.addAction(
translations.TR_COPY_FILE_PATH_TO_CLIPBOARD)
actionShowFileInExplorer = menu.addAction(
translations.TR_SHOW_FILE_IN_EXPLORER)
actionReopen = menu.addAction(translations.TR_REOPEN_FILE)
actionUndock = menu.addAction(translations.TR_UNDOCK_EDITOR)
if len(settings.LAST_OPENED_FILES) == 0:
actionReopen.setEnabled(False)
#Connect actions
self.connect(actionSplitH, SIGNAL("triggered()"),
lambda: self._split(False))
self.connect(actionSplitV, SIGNAL("triggered()"),
lambda: self._split(True))
self.connect(actionRun, SIGNAL("triggered()"),
self._run_this_file)
self.connect(actionAdd, SIGNAL("triggered()"),
self._add_to_project)
self.connect(actionClose, SIGNAL("triggered()"),
self.about_to_close_file)
self.connect(actionCloseAllNotThis, SIGNAL("triggered()"),
self._close_all_files_except_this)
self.connect(actionCloseAll, SIGNAL("triggered()"),
self._close_all_files)
self.connect(actionCopyPath, SIGNAL("triggered()"),
self._copy_file_location)
self.connect(actionShowFileInExplorer, SIGNAL("triggered()"),
self._show_file_in_explorer)
self.connect(actionReopen, SIGNAL("triggered()"),
self._reopen_last_tab)
self.connect(actionUndock, SIGNAL("triggered()"),
self._undock_editor)
menu.exec_(QCursor.pos())
class LapigTools:
def __init__(self, iface):
self.iface = iface
self.menu = QMenu("&LAPIG Tools", self.iface.mainWindow().menuBar())
self.submenu = QMenu("&Time Series Filters")
self.menu.addMenu(self.submenu)
self.tools = []
for key, clazz in tools.__dict__.iteritems():
if inspect.isclass(clazz) and issubclass(
clazz, GenericTool) and key != 'GenericTool':
self.tools.append(clazz(iface))
def initGui(self):
List = []
ListLabel = []
for tool in self.tools:
listA, label = tool.initGui()
List.append(listA)
ListLabel.append(label)
for i in range(len(List)):
if (ListLabel[i]
== 'Savitzky Golay Filter') or (ListLabel[i]
== 'Hagens Filter'):
self.submenu.addAction(List[i])
self.iface.mainWindow().menuBar().insertMenu(
List[i], self.menu)
else:
self.menu.addAction(List[i])
self.iface.mainWindow().menuBar().insertMenu(
List[i], self.menu)
def unload(self):
for tool in self.tools:
tool.unload()
self.menu.deleteLater()
def labelingContextMenu(self,names,op,position5d):
menu = QMenu(self)
menu.setObjectName("carving_context_menu")
menu.addAction("position %d %d %d" % (position5d[1], position5d[2], position5d[3]))
menu.addSeparator()
for name in names:
submenu = QMenu(name,menu)
submenu.addAction("Load %s" % name)
submenu.addAction("Delete %s" % name)
if self.render:
if name in self._shownObjects3D:
submenu.addAction("Remove %s from 3D view" % name)
else:
submenu.addAction("Show 3D %s" % name)
menu.addMenu(submenu)
if names:menu.addSeparator()
if op.dataIsStorable():
menu.addAction("Save objects")
menu.addAction("Browse objects")
menu.addAction("Segment")
menu.addAction("Clear")
return menu
def _menu_context_tree(self, point):
index = self.indexAt(point)
if not index.isValid():
return
handler = None
menu = QMenu(self)
if self.model().isDir(index):
self._add_context_menu_for_folders(menu)
else:
filename = self.model().fileName(index)
lang = file_manager.get_file_extension(filename)
self._add_context_menu_for_files(menu, lang)
menu.addMenu(self._folding_menu)
#menu for the Project Type(if present)
if handler:
for m in handler.get_context_menus():
if isinstance(m, QMenu):
menu.addSeparator()
menu.addMenu(m)
#show the menu!
menu.exec_(QCursor.pos())
def _onTvFilesCustomContextMenuRequested(self, pos ):
"""Connected automatically by uic
"""
menu = QMenu()
menu.addAction( core.actionManager().action( "mFile/mClose/aCurrent" ) )
menu.addAction( core.actionManager().action( "mFile/mSave/aCurrent" ) )
menu.addAction( core.actionManager().action( "mFile/mReload/aCurrent" ) )
menu.addMenu( core.actionManager().action( "mFile/mFileSystem" ).menu() )
menu.addSeparator()
# sort menu
sortMenu = QMenu( self )
group = QActionGroup( sortMenu )
group.addAction( self.tr( "Opening order" ) )
group.addAction( self.tr( "File name" ) )
group.addAction( self.tr( "URL" ) )
group.addAction( self.tr( "Suffixes" ) )
group.triggered.connect(self._onSortTriggered)
sortMenu.addActions( group.actions() )
for i, sortMode in enumerate(["OpeningOrder", "FileName", "URL", "Suffixes"]):
action = group.actions()[i]
action.setData( sortMode )
action.setCheckable( True )
if sortMode == self.model.sortMode():
action.setChecked( True )
aSortMenu = QAction( self.tr( "Sorting" ), self )
aSortMenu.setMenu( sortMenu )
aSortMenu.setIcon( QIcon( ":/enkiicons/sort.png" ))
aSortMenu.setToolTip( aSortMenu.text() )
menu.addAction( sortMenu.menuAction() )
menu.exec_( self.tvFiles.mapToGlobal( pos ) )
class LapigTools:
def __init__(self, iface):
self.iface = iface
self.menu = QMenu( "&LAPIG Tools", self.iface.mainWindow().menuBar() )
self.submenu = QMenu("&Time Series Filters")
self.menu.addMenu(self.submenu)
self.tools = []
for key, clazz in tools.__dict__.iteritems():
if inspect.isclass(clazz) and issubclass(clazz, GenericTool) and key != 'GenericTool':
self.tools.append(clazz(iface))
def initGui(self):
List = []
ListLabel = []
for tool in self.tools:
listA,label = tool.initGui()
List.append(listA)
ListLabel.append(label)
for i in range(len(List)):
if (ListLabel[i] == 'Savitzky Golay Filter') or (ListLabel[i] == 'Hagens Filter'):
self.submenu.addAction(List[i])
self.iface.mainWindow().menuBar().insertMenu(List[i],self.menu)
else:
self.menu.addAction(List[i])
self.iface.mainWindow().menuBar().insertMenu(List[i], self.menu)
def unload(self):
for tool in self.tools:
tool.unload()
self.menu.deleteLater()
def getContextMenu(self):
menu = QMenu()
# closeAction = menu.addAction("Delete")
exportCsvAction = menu.addAction("Export to CSV")
exportCsvAction.triggered.connect(self.saveAllCsv)
toggleLegendAction = menu.addAction("Toggle legend")
toggleLegendAction.triggered.connect(self.toggleLegend)
self.removeSubmenu = menu.addMenu("Remove")
# configureAction.triggered.connect(self.configure)
# self.connect(,SIGNAL("triggered()"),
# self,SLOT("slotShow500x500()"))
# self.connect(action1,SIGNAL("triggered()"),
# self,SLOT("slotShow100x100()"))
return menu
def _openMenu(self, position):
menu = QMenu()
for action in self._actions:
if action is None:
menu.addSeparator()
elif isinstance(action, dict):
for k in action:
submenu = menu.addMenu(k)
for saction in action[k]:
if saction is None:
submenu.addSeparator()
else:
submenu.addAction(saction)
else:
menu.addAction(action)
menu.exec_(self.ui.elementListWidget.viewport().mapToGlobal(position))
def menu_file(parent):
m = QMenu(parent)
m.setTitle(_("menu title", "&File"))
m.addAction(icons.get('document-new'), _("action: new document", "&New"), file_new)
m.addMenu(menu_file_new_from_template(m))
m.addAction(icons.get('tools-score-wizard'), _("New Score with &Wizard..."), file_new_with_wizard)
m.addSeparator()
m.addAction(icons.get('document-open'), _("&Open..."), file_open)
m.addMenu(menu_file_open_recent(m))
m.addSeparator()
m.addMenu(menu_file_import(m))
m.addSeparator()
role = QAction.QuitRole if use_osx_menu_roles() else QAction.NoRole
m.addAction(icons.get('application-exit'), _("&Quit"), app.qApp.quit).setMenuRole(role)
return m
def onQuickDesktopContextMenuRequest(self, pos):
index = self.listView.indexAt(pos)
self.listView.setCurrentIndex(index)
menu = QMenu()
menu.addAction(self.actionCreateShortcut)
menu.addAction(self.actionCreateBookmark)
menu2 = menu.addMenu(self.trUtf8("创建特殊快捷方式(&S)"))
if os.name == "nt":
menu2.addAction(self.actionCreateComputer)
menu2.addAction(self.actionCreateDocuments)
menu2.addAction(self.actionCreatePictures)
menu2.addAction(self.actionCreateMusic)
if index.isValid():
menu.addAction(self.actionRemoveShortcut)
if not self.quickDesktopModel.isSpecialShortcut(index):
menu.addAction(self.actionEditShortcut)
menu.addAction(self.actionRenameShortcut)
try:
getattr(menu, "exec")(QCursor.pos())
except AttributeError:
getattr(menu, "exec_")(QCursor.pos())
def popup(self, pos):
row = self.selectionModel().selection().indexes()[0].row()
if (len(self.data) - 1) < row:
return False
self.contact = Contact.get(Contact.number == int(self.data[row][2]))
menu = QMenu()
menu.addAction(QIcon("{}transfer.png".format(Config.img_media)),
u"Faire un envoi", lambda: self.send_money(self.contact))
menu.addAction(QIcon("{}edit_contact.png".format(Config.img_media)),
u"modifier le contact", lambda: self.edit_contacts(self.contact))
addgroup = menu.addMenu(u"Ajouter au groupe")
delgroup = menu.addMenu(u"Enlever du groupe")
# # Enlever du groupe
no_select = ContactGroup.filter(contact__number=int(self.data[row][2]))
[delgroup.addAction(u"{}".format(grp_ct.group.name), lambda grp_ct=grp_ct: self.del_grp(
grp_ct)) for grp_ct in no_select]
# # Ajout au groupe
lt_grp_select = [(i.group.name) for i in no_select]
[addgroup.addAction(u"{}".format(grp.name), lambda grp=grp: self.add_grp(grp))
for grp in Group.select() if not grp.name in lt_grp_select]
self.action = menu.exec_(self.mapToGlobal(pos))
self.refresh()
def onTableViewContextMenu(self, pos):
m = QMenu()
a = m.addAction('Copy Selected cid')
a.connect(a, SIGNAL("triggered()"),
lambda s=self: QApplication.clipboard().setText(str(s.selectedCards()[0])))
a = m.addAction('Copy Selected nid')
a.connect(a, SIGNAL("triggered()"),
lambda s=self: QApplication.clipboard().setText(str(s.selectedNotes()[0])))
preset_search_menu = m.addMenu("Preset Searches")
a = preset_search_menu.addAction('Review cards due soon with long interval')
a.connect(a, SIGNAL("triggered()"),
lambda b=self: set_search_text_to(b, "prop:due>5 prop:due<7 prop:ivl>=10 is:review"))
a = preset_search_menu.addAction('Unseen cards')
a.connect(a, SIGNAL("triggered()"),
lambda b=self: set_search_text_to(b, "tag:ns*"))
a = m.addAction('Set Columns to Min Size')
a.connect(a, SIGNAL("triggered()"),
lambda s=self: set_column_size_to_default(s))
runHook("Browser.tableViewContextMenuEvent", self, m)
#m.popup(QCursor.pos())
m.exec_(QCursor.pos())
class Window(QMainWindow, Ui_Window):
loginRequested = QtCore.pyqtSignal(str, str)
selectMailboxRequested = QtCore.pyqtSignal(str)
uidListRequested = QtCore.pyqtSignal(str, str)
newMailsRequested = QtCore.pyqtSignal(int)
bodystructureRequested = QtCore.pyqtSignal(int)
mailTextRequested = QtCore.pyqtSignal(int, str, str)
deleteRequested = QtCore.pyqtSignal(list)
saveAttachmentRequested = QtCore.pyqtSignal(int, str, str, unicode)
def __init__(self):
QMainWindow.__init__(self)
QIcon.setThemeName('Adwaita')
self.setupUi(self)
self.settings = QtCore.QSettings(1, 0, "daaq-mail","daaq", self)
self.emails = [unicode(x) for x in self.settings.value('Emails', []).toStringList()]
self.types = [unicode(x) for x in self.settings.value('Types', []).toStringList()]
self.initUi()
self.resize(1024, 714)
self.show()
# create imap client
self.thread = QtCore.QThread(self)
self.imapClient = GmailImap()
self.thread.finished.connect(self.imapClient.deleteLater)
self.imapClient.moveToThread(self.thread)
self.imapClient.loggedIn.connect( self.onLogin)
self.imapClient.mailboxListLoaded.connect( self.setMailboxes)
self.imapClient.mailboxSelected.connect( self.onMailboxSelect)
self.imapClient.uidsListed.connect( self.removeDeleted)
self.imapClient.insertMailRequested.connect(self.insertNewMail)
self.imapClient.bodystructureLoaded.connect(self.setAttachments)
self.imapClient.mailTextLoaded.connect( self.setMailText)
self.loginRequested.connect( self.imapClient.login)
self.selectMailboxRequested.connect( self.imapClient.selectMailbox)
self.uidListRequested.connect( self.imapClient.listUids)
self.newMailsRequested.connect( self.imapClient.getNewMails)
self.bodystructureRequested.connect( self.imapClient.loadBodystructure)
self.mailTextRequested.connect( self.imapClient.loadMailText)
self.saveAttachmentRequested.connect( self.imapClient.saveAttachment)
self.deleteRequested.connect( self.imapClient.deleteMails)
self.thread.start()
# init variables
self.email_id = ''
self.passwd = ''
self.mailbox = ''
self.total_mails = 0
QtCore.QTimer.singleShot(30, self.setupClient)
def initUi(self):
self.toolMenu = QMenu('Menu', self)
self.accountsMenu = QMenu('Select Account', self)
self.accountsMenu.triggered.connect(self.accountSelected)
self.refreshAccountsMenu()
self.toolMenu.addMenu(self.accountsMenu)
self.toolMenu.addAction('Manage Accounts', self.manageAccounts)
self.menuBtn = QToolButton(self)
self.menuBtn.setIcon(QIcon(':/menu.png'))
self.menuBtn.setPopupMode(QToolButton.InstantPopup)
self.menuBtn.setMenu(self.toolMenu)
self.toolBar.insertWidget(self.newMailAction, self.menuBtn)
spacer = QWidget(self)
spacer.setSizePolicy(1|2|4,1|4)
self.toolBar.insertWidget(self.quitAction, spacer)
# Create text browser
self.textViewer = TextViewer(self)
self.verticalLayout.insertWidget(0, self.textViewer, 1)
# mailboxTable shows list of Mailboxes
self.mailboxTable.setFixedWidth(150)
self.mailboxTable.horizontalHeader().setResizeMode(0, QHeaderView.Stretch)
self.mailboxTable.itemClicked.connect(self.onMailboxClick)
# mailsTable is list of mails for a mailbox
self.mailsTable.setFixedWidth(500)
self.mailsTable.horizontalHeader().setResizeMode(0, QHeaderView.Stretch)
self.mailsTable.cellClicked.connect(self.loadMail)
# Attachments table
self.tableWidget.horizontalHeader().setResizeMode(0, QHeaderView.Stretch)
self.tableWidget.hide()
self.tableWidget.cellClicked.connect(self.onAttachmentClick)
# Insert Mail Info Frame
self.mailInfoFrame = MailInfoFrame(self.widget_2)
self.verticalLayout.insertWidget(0, self.mailInfoFrame)
# Create actions
self.replyAction.triggered.connect(self.replyMail)
self.deleteAction.triggered.connect(self.deleteMail)
self.printAction.triggered.connect(self.printMail)
self.quitAction.triggered.connect(self.close)
self.newMailAction.triggered.connect(self.newMail)
def setupClient(self):
""" Login to email server (IMAP) """
email_id = str(self.settings.value('EmailId', '').toString())
if email_id == '':
QMessageBox.warning(self, 'No Account Selected !',
'Please Click on Menu and Select an account to login')
return
kr = Keyring()
passwd = kr.getPassword(email_id)
if not passwd :
QMessageBox.critical(self, 'Not Found !', 'Password not found for the email %s'%email_id)
return
print 'login requested'
self.loginRequested.emit(email_id, passwd)
def onLogin(self, email_id, passwd):
self.email_id = email_id
self.passwd = passwd
if not os.path.exists(ACNT_DIR + email_id + '/mails'):
os.makedirs(str(ACNT_DIR + email_id + '/mails'))
def setMailboxes(self, mailboxes):
#print mailboxes
row = 0
for mailbox in mailboxes:
#print mailbox
mailbox_name = mailbox.split('/')[-1]
#print mailbox_name
self.mailboxTable.insertRow(row)
item = QTableWidgetItem(mailbox_name)
item.mailbox_path = mailbox
self.mailboxTable.setItem(row, 0, item)
row += 1
def onMailboxClick(self, item):
mailbox = item.mailbox_path
if self.mailbox == mailbox : return # Already selected
self.selectMailboxRequested.emit(mailbox)
def onMailboxSelect(self, mailbox, total_mails):
if self.mailbox != '' : self.saveMailInfo()
self.mailbox = mailbox
self.total_mails = total_mails
self.clearMailViewer()
self.mailsTable.clear()
self.mailsTable.setRowCount(0)
QtCore.QTimer.singleShot(30, self.loadCachedMails)
def loadCachedMails(self):
""" fetch list of mails (with headers) in a mailbox """
oldest_uid, latest_uid = None, None
mailbox_file = ACNT_DIR + self.email_id + '/%s.xml'%self.mailbox[:].replace('/', '_')
if os.path.exists(mailbox_file):
# load cached mails
doc = QDomDocument()
doc_file = QtCore.QFile(mailbox_file)
if doc_file.open(QtCore.QIODevice.ReadOnly):
doc.setContent(doc_file)
doc_file.close()
mails = doc.firstChild().toElement()
mail = mails.firstChild()
latest_uid = mail.toElement().attribute('UID')
i = 0
while not mail.isNull():
e = mail.toElement()
self.mailsTable.insertRow(i)
item = MailItem()
item.setData(e.attribute('Sender'), e.attribute('Subject'), e.attribute('UID'),
e.attribute('Message-ID'), e.attribute('Date'), e.attribute('Cached'))
self.mailsTable.setCellWidget(i, 0, item)
self.mailsTable.resizeRowsToContents()
wait(30)
mail = mail.nextSibling()
i += 1
oldest_uid = mails.lastChild().toElement().attribute('UID')
print 'uids', oldest_uid, latest_uid
if latest_uid:
self.uidListRequested.emit(oldest_uid, latest_uid)
else:
self.newMailsRequested.emit(0)
def removeDeleted(self, uids, last_index):
print 'removing deleted mails'
deleted = 0
for i in range(self.mailsTable.rowCount()):
item = self.mailsTable.cellWidget(i-deleted,0)
if item.uid not in uids:
if item.cached : # delete cached files
msg_struct = ACNT_DIR + self.email_id + '/mails/' + item.msg_id[:].replace('/', '_') + '.xml'
msg_file = ACNT_DIR + self.email_id + '/mails/' + item.msg_id[:].replace('/', '_') + '.txt'
if os.path.exists(msg_struct) : os.remove(msg_struct)
if os.path.exists(msg_file) : os.remove(msg_file)
self.mailsTable.removeRow(i-deleted)
deleted += 1
wait(30)
self.newMailsRequested.emit(last_index)
#print 'mails deleted'
def insertNewMail(self, sender, subject, uid, msg_id, date, cached, seen):
#print 'insert new mail', uid
self.mailsTable.insertRow(0)
item = MailItem()
item.setData(sender, subject, uid, msg_id, date, cached, seen)
self.mailsTable.setCellWidget(0, 0, item)
self.mailsTable.resizeRowsToContents()
wait(30)
def loadMail(self, row, column):
""" Fetch body of mail and show them in viewer widget"""
rows = self.mailsTable.selectionModel().selectedRows()
if len(rows)>1 : return # return when multiple is selected
self.clearMailViewer()
self.mailInfoFrame.setData(self.mailsTable.cellWidget(row, column))
wait(30)
msg_id = self.mailInfoFrame.msg_id[:].replace('/', '_')
# Some msg_id contains / character
msg_struct = ACNT_DIR + self.email_id + '/mails/' + msg_id + '.xml'
if os.path.exists(msg_struct):
with open(msg_struct, 'r') as doc_file:
xml_doc = doc_file.read()
self.setAttachments(xml_doc)
else:
self.bodystructureRequested.emit(self.total_mails-row)
def setAttachments(self, xml_doc): # bodystructure dom
msg_id = self.mailInfoFrame.msg_id[:].replace('/', '_')
# save bodystructure
msg_struct = ACNT_DIR + self.email_id + '/mails/' + msg_id + '.xml'
if not os.path.exists(msg_struct):
with open(msg_struct, 'w') as fd:
fd.write(unicode(xml_doc))
# get attachments
text_part_num, txt_enc, attachments = getAttachments(xml_doc)
for [part_num, enc, filename, file_size] in attachments:
ro = self.tableWidget.rowCount()
self.tableWidget.insertRow(ro)
item = QTableWidgetItem(QIcon(':/download.png'), filename)
item.part_num = part_num
item.encoding = enc
self.tableWidget.setItem(ro, 0, item)
self.tableWidget.setItem(ro, 1, QTableWidgetItem(file_size))
if self.tableWidget.rowCount() > 0:
self.tableWidget.show()
# load html body
msg_file = ACNT_DIR + self.email_id + '/mails/' + msg_id + '.txt'
if os.path.exists(msg_file):
with open(msg_file, 'rb') as fd:
html = fd.read()
self.setMailText(unicode(html, 'utf8')) # convert byte string to unicode
else:
row = self.mailsTable.selectionModel().selectedRows()[0].row()
self.mailTextRequested.emit(self.total_mails-row, text_part_num, txt_enc)
self.mailsTable.cellWidget(row, 0).cached = True
def setMailText(self, html):
msg_id = self.mailInfoFrame.msg_id[:].replace('/', '_')
msg_file = ACNT_DIR + self.email_id + '/mails/' + msg_id + '.txt'
if not os.path.exists(msg_file):
with open(msg_file, 'wb') as fd:
fd.write(unicode(html).encode('utf8')) # save text file in byte string
self.textViewer.setText(html)
def onAttachmentClick(self, row, col):
if col != 0 : return
part_num = self.tableWidget.item(row, col).part_num
enc = self.tableWidget.item(row, col).encoding
filename = self.tableWidget.item(row, col).text()
msg_row = self.mailsTable.selectionModel().selectedRows()[0].row()
self.saveAttachmentRequested.emit(self.total_mails-msg_row, part_num, enc, filename)
def replyMail(self):
name, reply_to = splitEmailAddr(self.mailInfoFrame.sender)
if reply_to == '' : reply_to = name
dialog = send_mail.SendMailDialog(self.email_id, self.passwd, self)
dialog.replyTo(reply_to, self.mailInfoFrame.msg_id, self.mailInfoFrame.subject)
dialog.exec_()
def deleteMail(self):
rows = self.mailsTable.selectionModel().selectedRows()
uid_list = [self.mailsTable.cellWidget(row.row(), 0).uid for row in rows]
self.deleteRequested.emit(uid_list)
def printMail(self):
printer = QPrinter(mode=QPrinter.HighResolution)
printer.setCreator("Daaq Mail")
title = 'Daaq Mail'
#title = validateFileName(title)
printer.setDocName(title)
printer.setOutputFileName(DOC_DIR + title + ".pdf")
print_dialog = QPrintPreviewDialog(printer, self)
print_dialog.paintRequested.connect(self.textViewer.print_)
print_dialog.exec_()
def newMail(self):
dialog = send_mail.SendMailDialog(self.email_id, self.passwd, self)
dialog.exec_()
def accountSelected(self, account):
#print account.text(), self.email_id
if str(account.text()) == self.email_id : return
self.settings.setValue('EmailId', account.text())
self.setupClient()
def manageAccounts(self):
dialog = AccountManagerDialog(self.emails, self.types, self)
dialog.exec_()
self.emails, self.types = dialog.emails, dialog.types
self.settings.setValue('Emails', self.emails)
self.settings.setValue('Types', self.types)
if self.emails == []:
self.settings.setValue('EmailId', '')
self.refreshAccountsMenu()
def refreshAccountsMenu(self):
self.accountsMenu.clear()
for each in self.emails:
self.accountsMenu.addAction(each)
def clearMailViewer(self):
self.mailInfoFrame.clear()
self.textViewer.clear()
self.tableWidget.clear()
self.tableWidget.setRowCount(0)
self.tableWidget.hide()
def saveMailInfo(self):
if self.total_mails != self.mailsTable.rowCount(): return
if self.total_mails == 0 : return
# Cache mails in xml file
doc = QDomDocument()
root = doc.createElement('mails')
doc.appendChild(root)
for i in range(self.mailsTable.rowCount()):
item = self.mailsTable.cellWidget(i,0)
mail = doc.createElement('mail')
mail.setAttribute('UID', item.uid)
mail.setAttribute('Message-ID', item.msg_id)
mail.setAttribute('Sender', item.sender)
mail.setAttribute('Subject', unicode(item.subject).encode('utf8'))
mail.setAttribute('Date', item.date)
mail.setAttribute('Cached', item.cached)
root.appendChild(mail)
mailbox_file = ACNT_DIR + self.email_id + '/%s.xml'%self.mailbox[:].replace('/', '_')
with open(mailbox_file, 'w') as doc_file:
doc_file.write(doc.toString())
def closeEvent(self, ev):
self.saveMailInfo()
loop = QtCore.QEventLoop()
self.thread.finished.connect(loop.quit)
self.thread.quit()
loop.exec_()
QMainWindow.closeEvent(self, ev)
