def _get_menu(self):
# main menu
menu = QMenu()
main_menu_action_group = QActionGroup(menu)
main_menu_action_group.setObjectName("main")
# character menu
map_action = QAction(menu)
map_action.setText("Toggle Map")
main_menu_action_group.addAction(map_action)
separator = QAction(menu)
separator.setSeparator(True)
main_menu_action_group.addAction(separator)
characters_action = QAction(menu)
characters_action.setText("Switch Characters")
main_menu_action_group.addAction(characters_action)
separator = QAction(menu)
separator.setSeparator(True)
main_menu_action_group.addAction(separator)
settings_action = QAction(menu)
settings_action.setText("Settings")
main_menu_action_group.addAction(settings_action)
quit_action = QAction(menu)
quit_action.setText("Quit")
main_menu_action_group.addAction(quit_action)
menu.addActions(main_menu_action_group.actions())
menu.triggered[QAction].connect(self._menu_actions)
return menu
def context_menu(self, point):
"""Show a context menu on the chart."""
menu = QMenu(self)
menu.addActions(self.context_menu_actions)
point = self.chart_view.viewport().mapToGlobal(point)
menu.popup(point)
def handler_context_menu_requested(self, pos):
menu = QMenu(self)
switch_widgets_action = QAction(self)
if self.slider_widget.isHidden():
switch_widgets_action.setText("Show slider")
else:
switch_widgets_action.setText("Show value")
switch_widgets_action.triggered.connect(
self.handler_switch_widgets_action_triggered)
anim_options_action = QAction("Animation options", self)
anim_options_action.triggered.connect(
self.handler_anim_options_action_triggered)
tracking_action = QAction(self)
if self.slider.hasTracking():
tracking_action.setText("Turn tracking off")
else:
tracking_action.setText("Turn tracking on")
tracking_action.triggered.connect(
self.handler_tracking_action_triggered)
menu.addActions(
[switch_widgets_action, anim_options_action, tracking_action])
menu.exec(self.mapToGlobal(pos))
def _create_filter_menus(self):
# Airport filters
arrDep_action_group = QActionGroup(self)
self._add_filter_action(arrDep_action_group,
'All',
self.list_model.filter_arrDep_all,
ticked=True)
self._add_filter_action(arrDep_action_group, 'On map',
self.list_model.filter_arrDep_inRange)
if env.airport_data != None:
self._add_filter_action(arrDep_action_group, 'Here only',
self.list_model.filter_arrDep_here)
arrDep_filter_menu = QMenu()
arrDep_filter_menu.addActions(arrDep_action_group.actions())
self.filterArrDep_button.setMenu(arrDep_filter_menu)
# Date filters
date_action_group = QActionGroup(self)
self._add_filter_action(date_action_group, '+/- 3 days',
self.list_model.filter_date_week)
self._add_filter_action(date_action_group,
'Today (~24 h)',
self.list_model.filter_date_today,
ticked=True)
date_filter_menu = QMenu()
date_filter_menu.addActions(date_action_group.actions())
self.filterDate_button.setMenu(date_filter_menu)
class SystemTrayIcon(QSystemTrayIcon):
""" run the server the background, use this icon to display the main window
"""
close_app = pyqtSignal()
show_app = pyqtSignal()
def __init__(self):
super(SystemTrayIcon, self).__init__()
self.set_up_icon()
def set_up_icon(self):
""" set an icon, add a menu and add actions to the menu
"""
self.__menu = QMenu()
self.__show = QAction("Show")
self.__quit = QAction("Quit")
# signals --> slots
self.__show.triggered.connect(self.show_app_slot)
self.__quit.triggered.connect(self.close_app_slot)
self.__menu.addActions([self.__show, self.__quit])
self.setIcon(QIcon('app.png'))
self.setContextMenu(self.__menu)
@pyqtSlot()
def close_app_slot(self):
self.close_app.emit()
@pyqtSlot()
def show_app_slot(self):
self.setVisible(False)
self.show_app.emit()
def context_menu(self, point):
"""Generate a popup menu from the actions in self.context_menu_actions."""
menu = QMenu(self)
menu.addActions(self.context_menu_actions)
point = self.table.viewport().mapToGlobal(point)
menu.popup(point)
def create_ui(self):
# 第二部，添加各种菜单
# 1.获取菜单栏
menubar = self.menuBar()
# 2.在菜单栏上添加菜单
file_menu = menubar.addMenu('File')
# menubar.setNativeMenuBar(False) Mac电脑加
edit_menu = menubar.addMenu('Edit')
# 3.在菜单上添加选项
fa1 = QAction('New Project', self)
# 给选项绑定事件
fa1.triggered.connect(self.new_project)
fa2 = QAction(QIcon('files/logo.jpg'), 'open', self)
fa2.triggered.connect(self.open_action)
# 给选项添加快快捷键
fa2.setShortcut('ctrl+o')
# 添加子菜单
file_p_menu = QMenu('子菜单1', self)
file_menu.addMenu(file_p_menu)
fp3 = QAction('子菜单里面的内容1', self)
fp4 = QAction('子菜单里面的内容2', self)
file_p_menu.addActions([fp3, fp4])
# 将选项添加到菜单上
file_menu.addActions([fa1, fa2])
def showContextMenu(self, pos):
menu = QMenu()
self.add_standard_menu_actions(menu)
actions_to_add =[]
if len(self.dataView.selectedIndexes()) == 1:
menu.addSeparator()
action_copy = QAction("Copy testcase")
action_copy.triggered.connect(self.copy_testcase)
menu.addAction(action_copy)
menu.addSeparator()
if self.dataView.selectedIndexes():
run_selected_action = QAction(self.tr("Run selected"), menu)
run_selected_action.triggered.connect(self.run_selected)
actions_to_add.append(run_selected_action)
if self.dataTable.rowCount() > 0:
run_all_action = QAction(self.tr("Run all"), menu)
run_all_action.triggered.connect(self.run_tests)
actions_to_add.append(run_all_action)
if actions_to_add:
menu.addSeparator()
menu.addActions(actions_to_add)
menu.exec_(self.dataView.viewport().mapToGlobal(pos))
def open_menu(self, position):
if not self.controller.user_is_technical_engineer:
return
menu = QMenu()
treeItem = self.ui.treeCameras.itemAt(position)
if not treeItem:
add_checkpoint = QAction(_('Add checkpoint'), menu)
add_checkpoint.triggered.connect(
self.controller.add_checkpoint_clicked)
menu.addAction(add_checkpoint)
else:
if treeItem.text(1) == '':
add_camera = QAction(_('Add camera'), menu)
add_camera.triggered.connect(
self.controller.add_camera_clicked)
change_address = QAction(_('Сhange address'), menu)
change_address.triggered.connect(
self.controller.change_address_clicked)
delete_checkpoint = QAction(_('Delete checkpoint'), menu)
delete_checkpoint.triggered.connect(
self.controller.delete_checkpoint_clicked)
menu.addActions(
[add_camera, change_address, delete_checkpoint])
else:
delete_camera = QAction(_('Delete camera'), menu)
delete_camera.triggered.connect(
self.controller.delete_camera_clicked)
menu.addAction(delete_camera)
menu.exec_(self.ui.treeCameras.viewport().mapToGlobal(position))
def initMenu(self):
"""
Public slot to initialize the multi project menu.
@return the menu generated (QMenu)
"""
menu = QMenu(self.tr('&Multiproject'), self.parent())
self.recentMenu = QMenu(self.tr('Open &Recent Multiprojects'), menu)
self.__menus = {
"Main": menu,
"Recent": self.recentMenu,
}
# connect the aboutToShow signals
self.recentMenu.aboutToShow.connect(self.__showContextMenuRecent)
self.recentMenu.triggered.connect(self.__openRecent)
menu.aboutToShow.connect(self.__showMenu)
# build the main menu
menu.setTearOffEnabled(True)
menu.addActions(self.actGrp1.actions())
self.menuRecentAct = menu.addMenu(self.recentMenu)
menu.addSeparator()
menu.addAction(self.closeAct)
menu.addSeparator()
menu.addAction(self.saveAct)
menu.addAction(self.saveasAct)
menu.addSeparator()
menu.addAction(self.addProjectAct)
menu.addSeparator()
menu.addAction(self.propsAct)
self.menu = menu
return menu
def context_menu_media_list(self, position):
menu = QMenu("Options")
logger.info("Creating context menu for media list")
menu.addSection("Selected: {}".format(
len(self.lst_media.selectedItems())))
menu.addActions(self.action_list)
menu.exec_(self.lst_media.mapToGlobal(position))
def _fill_context_menu_with_model_item_actions(self, context_menu: QMenu):
"""
Find all model items that should be available in the context menu and create QActions for each, by
using the available logic in popupmenu.PopupMenu.
"""
# Get phrase folders to add to main menu
logger.info(
"Rebuilding model item actions, adding all items marked for access through the tray icon."
)
folders = [
folder for folder in self.config_manager.allFolders
if folder.show_in_tray_menu
]
items = [
item for item in self.config_manager.allItems
if item.show_in_tray_menu
]
# Only extract the QActions, but discard the PopupMenu instance.
# This is done, because the PopupMenu class is not directly usable as a context menu here.
menu = popupmenu.PopupMenu(self.app.service, folders, items, False,
"AutoKey")
new_item_actions = menu.actions()
context_menu.addActions(new_item_actions)
for action in new_item_actions: # type: QAction
# QMenu does not take the ownership when adding QActions, so manually re-parent all actions.
# This causes the QActions to be destroyed when the context menu is cleared or re-created.
action.setParent(context_menu)
if not context_menu.isEmpty():
# Avoid a stray separator line, if no items are marked for display in the context menu.
context_menu.addSeparator()
def on_ProjectTreeView_customContextMenuRequested(self, point: QPoint) -> None:
"""Displays context menu for the ProjectWidget to create/delete/rename files in the project tree"""
if not self.ProjectManager.is_project_loaded():
return
menu = QMenu()
clicked_item = self.ui.ProjectTreeView.indexAt(point)
# Actions in order: CreateFile, CreateFolder, Rename, Delete
allow_actions = []
menu_actions = [self.ui.actionCreateFolder, self.ui.actionCreateFile, self.ui.actionRename,
self.ui.actionDelete]
# Make action available based on what item was clicked on
if clicked_item.data() is None:
allow_actions += (True, True, False, False)
elif self.ProjectManager.FsModel.isDir(clicked_item):
allow_actions += [True, True, True, True]
else:
allow_actions += [False, False, True, True]
for i in range(len(menu_actions)):
menu_actions[i].setEnabled(allow_actions[i])
menu_actions[i].setData(QVariant(point))
menu.addActions(menu_actions)
menu.exec_(self.ui.ProjectTreeView.mapToGlobal(point))
def _on_context_menu_requiested(self, pos):
item = self.itemAt(pos)
if item is None:
return
menu = QMenu(self)
allowed_children = item.node.ALLOWED_CHILDREN
actions = []
if len(allowed_children) > 0:
submenu = QMenu(menu)
submenu.setTitle("Add node")
menu.addMenu(submenu)
for c in allowed_children:
child_cls = getattr(nodes, c)
add_node_action = QAction(repr(child_cls), submenu)
add_node_action.triggered.connect(
partial(
self._on_add_node_action,
parent=item.node,
child_cls=child_cls,
item=item,
)
)
actions.append(add_node_action)
submenu.addActions(actions)
if len(item.node._children) == 0:
remove_node_action = QAction("Remove node", menu)
menu.addAction(remove_node_action)
remove_node_action.triggered.connect(
partial(self._on_remove_node_action, item)
)
menu.exec(self.viewport().mapToGlobal(pos))
def generate_torrents_menu(self, index):
infohash = str(
self.ui.torrents_table.model().model_data[index.row()][0])
name = str(self.ui.torrents_table.model().model_data[index.row()][1])
print(infohash)
menu = QMenu(self)
pause = QAction("Pause", self)
resume = QAction("Resume", self)
delete = QAction("Delete", self)
show_content = QAction("Show content", self)
copy_magnet_link = QAction("Copy magnet link", self)
copy_infohash = QAction("Copy info hash", self)
pause.triggered.connect(lambda: self.pause_torrent(infohash))
resume.triggered.connect(lambda: self.resume_torrent(infohash))
delete.triggered.connect(lambda: self.delete_torrent(infohash, name))
show_content.triggered.connect(lambda: self.show_content(infohash))
copy_magnet_link.triggered.connect(
lambda: self.copy_magnet_link(infohash))
copy_infohash.triggered.connect(lambda: self.copy_infohash(infohash))
menu.addActions([
pause, resume, show_content, copy_infohash, copy_magnet_link,
delete
])
return menu
class MainWindow(QMainWindow):
""" This is the main window of the Qt application. """
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
# ---------------------------------------------------------------------
# Setup Window
# ---------------------------------------------------------------------
self.setWindowTitle("Developer Dashboard")
self.setWindowIcon(QIcon('logo.png'))
# ---------------------------------------------------------------------
# Menus/ Widgets
# ---------------------------------------------------------------------
# Create an instance of an Actions object. This contains all the QActions
# to be used in this application.
self.actions = Actions()
# Create a MainWidget object. Note the Actions are being passed in.
self.mainWidget = CentralWidget(self.actions)
# Set the central widget
self.setCentralWidget(self.mainWidget)
# Create an application menu (this will be a sub-menu)
self.dashboardMenu = QMenu("dashboard")
# Add actions to the application menu
self.dashboardMenu.addActions(self.actions.getDashboardActions())
# Create an options menu
self.optionsMenu = QMenu("Options")
# Add the dashboard menu to the options menu
self.optionsMenu.addMenu(self.dashboardMenu)
# Add actions to the options menu
self.optionsMenu.addActions(self.actions.getOptionsActions())
# Add the options menu to the menu bar
self.menuBar().addMenu(self.optionsMenu)
# Create a tool bar
self.toolBar = QToolBar()
# Add actions to the tool bar
self.toolBar.addActions(self.actions.getToolBarActions())
# Add the tool bar to this MainWindow
self.addToolBar(self.toolBar)
# Connect the signals
self.actions.exitAction.triggered.connect(self.quit)
self.mainWidget.quitApplication.connect(self.quit)
self.actions.clearAction.triggered.connect(self.mainWidget.clearForm)
self.actions.resetAction.triggered.connect(self.mainWidget.resetScores)
self.actions.aboutAction.triggered.connect(self.mainWidget.aboutInfo)
def quit(self):
exit(0)
def contextMenuEvent(self, e):
""" Event handler.
"""
menu = QMenu(self)
menu.addActions([self.load, self.remove, self.clearList])
# show the menu only if the mouse is pointing a list item
if self.itemAt(e.pos()):
menu.popup(e.globalPos())
def right_click(self, pos: QPoint):
right_click_menu = QMenu()
copy_action = QAction('复制', self)
copy_action.triggered.connect(partial(self.copy_range, pos))
paste_action = QAction('黏贴', self)
paste_action.triggered.connect(partial(self.paste_range, pos))
right_click_menu.addActions([copy_action, paste_action])
right_click_menu.exec_(QCursor().pos())
def contextMenuEvent(self, event):
menu = QMenu(self)
menu.addActions(self.actionFaces.actions())
menu.addSeparator()
menu.addAction(self.actionQuit)
menu.exec_(event.globalPos())
def context_menu_media_info_box(self, position):
menu = QMenu("Options")
logger.info("Creating context menu for current media")
menu.addActions(self.action_list)
self.highlight_first_unwatched()
if not self.lst_media.selectedItems():
return
menu.exec_(
self.basic_view_widget.grp_current_media.mapToGlobal(position))
def widget_init(self):
menu = QMenu()
# actionTest = QAction('测试Action', self)
# 手动添加快捷键
self.pushButton.setShortcut('Ctrl+1')
actions = [self.actionEnter, self.actionCEnter]
[action.setCheckable(True) for action in actions]
menu.addActions(actions)
self.pushButton_5.setMenu(menu)
def __init__(self, parent=None):
QWidget.__init__(self, parent)
self.setupUi(self)
self.pull_menuButton.setIcon(QIcon(IconFile.pixmap_strip))
self.deleteStrip_button.setIcon(QIcon(IconFile.button_bin))
self.rack_filter_model = RackedStripsFilterModel(self)
self.stripRacks_view.setModel(self.rack_filter_model)
self.current_view_mode = StripRacksPane.DIVIDE
self.updateViewFromMode()
# PULL menu
self.pullFplDetails_action = QAction('Pull FPL details', self)
self.pullXpdrDetails_action = QAction('Pull XPDR details', self)
pull_menu = QMenu()
pull_menu.addAction(self.pullFplDetails_action)
pull_menu.addAction(self.pullXpdrDetails_action)
self.pullFplDetails_action.triggered.connect(
lambda: pull_FPL_details(self))
self.pullXpdrDetails_action.triggered.connect(
lambda: pull_XPDR_details(self))
self.pull_menuButton.setMenu(pull_menu)
# VIEW menu
createNewRack_action = QAction('New rack...', self)
createNewRack_action.setIcon(QIcon(IconFile.action_newRack))
createNewRack_action.triggered.connect(self.createNewRack)
moveRacks_action = QAction('Bring racks to this view...', self)
moveRacks_action.triggered.connect(self.moveRacksToView)
self.view_mode_action_group = QActionGroup(self)
for mode, txt in zip(
StripRacksPane.view_modes,
['Divided width', 'Horizontal scroll', 'Tabbed racks']):
view_action = QAction(txt, self)
view_action.setCheckable(True)
view_action.triggered.connect(
lambda toggle, m=mode: self.selectViewMode(m))
self.view_mode_action_group.addAction(view_action)
if mode == self.current_view_mode:
view_action.setChecked(True)
view_menu = QMenu()
view_menu.addAction(createNewRack_action)
view_menu.addAction(moveRacks_action)
view_menu.addSeparator()
view_menu.addActions(self.view_mode_action_group.actions())
self.view_menuButton.setMenu(view_menu)
# Other buttons and signals
self.updateButtonsAndActions()
self.deleteStrip_button.clicked.connect(
lambda: discard_strip(self, selection.strip, False))
self.shelf_button.stripDropped.connect(
lambda strip: discard_strip(self, strip, True))
self.shelf_button.clicked.connect(signals.openShelfRequest.emit)
# External signals below. CAUTION: these must all be disconnected on widget deletion
env.strips.columnsRemoved.connect(self.updateAfterRackDeletion)
signals.rackEdited.connect(self.updateAfterRackEdit)
signals.rackVisibilityTaken.connect(self.hideRacks)
signals.selectionChanged.connect(self.updateSelections)
signals.selectionChanged.connect(self.updateButtonsAndActions)
signals.mainWindowClosing.connect(self.close)
def show_pkg_actions(self, pkg: PackageView):
menu_row = QMenu()
menu_row.setSizePolicy(QSizePolicy.MinimumExpanding, QSizePolicy.Preferred)
menu_row.setObjectName('app_actions')
menu_row.setCursor(QCursor(Qt.PointingHandCursor))
if pkg.model.installed:
if pkg.model.has_history():
def show_history():
self.window.begin_show_history(pkg)
menu_row.addAction(QCustomMenuAction(parent=menu_row,
label=self.i18n["manage_window.apps_table.row.actions.history"],
action=show_history,
button_name='app_history'))
if pkg.model.can_be_downgraded():
def downgrade():
if ConfirmationDialog(title=self.i18n['manage_window.apps_table.row.actions.downgrade'],
body=self._parag(self.i18n[
'manage_window.apps_table.row.actions.downgrade.popup.body'].format(
self._bold(str(pkg)))),
i18n=self.i18n).ask():
self.window.begin_downgrade(pkg)
menu_row.addAction(QCustomMenuAction(parent=menu_row,
label=self.i18n["manage_window.apps_table.row.actions.downgrade"],
action=downgrade,
button_name='app_downgrade'))
if pkg.model.supports_ignored_updates():
if pkg.model.is_update_ignored():
action_label = self.i18n["manage_window.apps_table.row.actions.ignore_updates_reverse"]
button_name = 'revert_ignore_updates'
else:
action_label = self.i18n["manage_window.apps_table.row.actions.ignore_updates"]
button_name = 'ignore_updates'
def ignore_updates():
self.window.begin_ignore_updates(pkg)
menu_row.addAction(QCustomMenuAction(parent=menu_row,
label=action_label,
button_name=button_name,
action=ignore_updates))
if bool(pkg.model.get_custom_supported_actions()):
actions = [self._map_custom_action(pkg, a, menu_row) for a in pkg.model.get_custom_supported_actions()]
menu_row.addActions(actions)
menu_row.adjustSize()
menu_row.popup(QCursor.pos())
menu_row.exec_()
def initUI(self):
# ponto central da tela disponível
centro = QDesktopWidget().availableGeometry().center()
# setGeometry == move + resize
# x0, y0, xf, yf
largura = 800
altura = 600
self.setGeometry((centro.x() - int(largura/2)),centro.y() - int(altura/2),largura,altura)
self.setWindowTitle('Exemplo para Barra de Status, Barra de Menus e centralização')
# barra de status
# busca a Barra de Status de Objeto QMainWindow e mostra mensagem
self.statusBar().showMessage('Barra de Status: pronta!')
# barra de menus
# cria menu 'Arquivo'
# QMainWindow contém MenuBar e é adicionado 'Arquivo' com hotkey (&)
menuArquivo = self.menuBar().addMenu('&Arquivo')
# cria-se uma action, que é a ação de um item de menu
sairAction = QAction('Sair', self)
sairAction.setShortcut('Ctrl+Q')
sairAction.setStatusTip('Sair da Aplicação')
sairAction.triggered.connect(self.encerraApp)
menuArquivo.addAction(sairAction)
menuVisao = self.menuBar().addMenu('&Visualização')
# Action para Ocultar ou Mostrar Barra de Status
ocultarMostrarAction = QAction('Mostrar Barra de Status', self, checkable=True)
ocultarMostrarAction.setStatusTip('Oculta Barra de Status')
ocultarMostrarAction.setChecked(True)
ocultarMostrarAction.triggered.connect(self.hideShowStatusBarr)
menuVisao.addAction(ocultarMostrarAction)
# Menu Janela
menuJanela = self.menuBar().addMenu('&Janela')
# Submenu Janela -> Opções
submenuJanelaOpcoes = QMenu('Opções', self)
menuJanela.addMenu(submenuJanelaOpcoes)
# Ações do submenuJanela
maximizarAction = QAction('Maximizar', self)
maximizarAction.triggered.connect(self.maximizarJanela)
minimizarAction = QAction('Minimizar', self)
minimizarAction.triggered.connect(self.minimizarJanela)
restaurarAction = QAction('Restaurar', self)
restaurarAction.triggered.connect(self.restaurarJanela)
# adição no submenu menuJanela
submenuJanelaOpcoes.addActions([maximizarAction, minimizarAction,restaurarAction])
# chamada ao método para criar uma Barra de Ferramentas
# tentativa de organizar melhor o código
self.criaToolBar()
self.show()
pass
def contextMenuEvent(self,event):
print(event)
menu=QMenu(self)
act1=QAction('选择',self)
act2=QAction('编辑',self)
act3=QAction('退出',self)
menu.addActions([act1,act2,act3])
action=menu.exec_(self.mapToGlobal(event.pos()))
if action is act3:
print(act3)
QApplication.instance().quit()
def contextMenuEvent(self, event) -> None:
# 创建菜单对象
right_menu = QMenu(self)
# 在右键菜单上添加选项或者子菜单
a1 = QAction('copy', self)
a2 = QAction('cut', self)
a3 = QAction('pash', self)
right_menu.addActions([a1, a2, a3])
# 让菜单下显示在当前窗口鼠标所在位置
right_menu.exec_(self.mapToGlobal(event.pos()))
def __setup_context_menu(self):
# here's the custom menu (actions will be made in/visible as required)
rclickmenu = QMenu(self.mod_structure_view)
rclickmenu.addActions(
[self.action_unset_toplevel,
self.action_set_toplevel,
self.action_rename,
self.action_delete,
self.action_create_directory])
return rclickmenu
def get_rclickmenu(self, for_view):
# here's the custom menu (actions will be made in/visible
# as required)
rclickmenu = QMenu(for_view)
rclickmenu.addActions(
[self.action_unset_toplevel,
self.action_set_toplevel,
self.action_rename,
self.action_delete,
self.action_create_directory])
return rclickmenu
class PinToolBox(QToolButton):
""" Pin Tool button in Node menu. """
def __init__(self, parent, text: str, tooltip: str, icon_path: str,
icon_size: int, signal: str, refresh_button):
super().__init__(parent)
self.pin_name = text
self.pin_id = int(signal.split('-')[4])
self.refresh = refresh_button
self.setText(self.pin_name)
self.setToolTip(tooltip)
self.setIcon(QIcon(icon_path))
self.setIconSize(QSize(icon_size, icon_size))
self.setAutoRaise(True)
self.setToolButtonStyle(Qt.ToolButtonTextUnderIcon)
self.setObjectName(signal)
# set right menu for tool button
self.right_menu = QMenu()
self.setContextMenuPolicy(Qt.DefaultContextMenu)
def contextMenuEvent(self, event):
# make title
title = QAction(f'{self.pin_name}')
title.setDisabled(True)
self.right_menu.addAction(title)
self.right_menu.addSeparator()
# make body
body = self.get_right_menu_body()
self.right_menu.addActions(body)
# show
self.right_menu.exec(QCursor.pos())
def get_right_menu_body(self):
""" Operations that will execute on Pin. """
delete = QAction('Delete it')
delete.triggered.connect(self.delete_action)
export = QAction('Export it')
export.triggered.connect(self.export_action)
return delete, export
# ----------ACTIONS----------
def delete_action(self):
remove_custom_pin(self.pin_id)
self.refresh.click()
def export_action(self):
pass
def _context_menu(self, point):
"""
Called when the widget is right-clicked to display the context menu.
:param point: the location where the click happened
"""
logger.debug("Opening widget context menu")
menu = QMenu(self)
# Add the network settings
settings = QAction('Network Settings', menu)
iconPath = self._plugin.resource('settings.png')
settings.setIcon(QIcon(iconPath))
# Add a handler on the action
def settingsActionTriggered():
dialog = NetworkSettingsDialog(self._plugin)
dialog.exec_()
settings.triggered.connect(settingsActionTriggered)
menu.addAction(settings)
# Add each of the servers
if self._plugin.core.servers:
menu.addSeparator()
serverGroup = QActionGroup(self)
def serverActionTriggered(serverAction):
if not self._plugin.network.connected and \
serverAction.isChecked():
self._plugin.network.connect(serverAction._server.host,
serverAction._server.port)
else:
self._plugin.network.disconnect()
for server in self._plugin.core.servers:
isConnected = self._plugin.network.connected \
and server.host == self._plugin.network.host \
and server.port == self._plugin.network.port
serverAction = QAction('%s:%d' % (server.host, server.port),
menu,
checkable=True)
serverAction._server = server
serverAction.setChecked(isConnected)
serverGroup.addAction(serverAction)
menu.addActions(serverGroup.actions())
serverGroup.triggered.connect(serverActionTriggered)
# Show the context menu
menu.exec_(self.mapToGlobal(point))
def _image_processing_tools_ctx_menu(self, pos: QPoint):
menu = QMenu(self)
action1 = QAction("Reset Image")
action1.setData("reset")
action2 = QAction("Equalize Histogram")
action2.setData("equalize_histo")
action3 = QAction("Correct Lightness")
action3.setData("correct_l")
action4 = QAction("Cluster Image")
action4.setData("clustering")
menu.addActions([action1, action2, action3, action4])
action = menu.exec_(self.img_adjust_page.mapToGlobal(pos))
if action:
self._process_image_adjust_oper(action)
def prepare_tray_menu(self, menu: QMenu):
actions = {}
quit_act = QAction("Quit", self)
show_hide_act = QAction("Show / Hide", self)
torrents_act = QAction("Torrents", self)
start_island = QAction("Start Island", self)
stop_island = QAction("Stop Island", self)
restart_island = QAction("Restart Island", self)
config_act = QAction("Config...", self)
quit_act.setIcon(QIcon("resources/icons/exit.svg"))
show_hide_act.setIcon(QIcon("resources/icons/plus-minus.png"))
torrents_act.setIcon(QIcon("resources/icons/torrents.png"))
start_island.setIcon(QIcon("resources/icons/play.png"))
stop_island.setIcon(QIcon("resources/icons/stop.png"))
restart_island.setIcon(QIcon("resources/icons/reload.png"))
config_act.setIcon(QIcon("resources/icons/settings.png"))
menu.addAction(show_hide_act)
menu.addSeparator()
menu.addActions([start_island, stop_island, restart_island])
menu.addSeparator()
menu.addAction(torrents_act)
menu.addSeparator()
menu.addAction(config_act)
menu.addSeparator()
menu.addAction(quit_act)
torrents_act.triggered.connect(self.show_my_torrents)
config_act.triggered.connect(self.open_config)
quit_act.triggered.connect(self.quit_app)
show_hide_act.triggered.connect(self.show_hide)
start_island.triggered.connect(self.get_main_control_handler("launch"))
stop_island.triggered.connect(self.get_main_control_handler("stop"))
restart_island.triggered.connect(
self.get_main_control_handler("restart"))
start_island.setEnabled(False)
stop_island.setEnabled(False)
restart_island.setEnabled(False)
actions["start"] = start_island
actions["stop"] = stop_island
actions["restart"] = restart_island
actions["config"] = config_act
actions["torrent"] = torrents_act
actions["show"] = show_hide_act
actions["quit"] = quit_act
return actions
def __setup_context_menu(self):
# here's the custom menu (actions will be made in/visible as required)
rclickmenu = QMenu(self.mod_structure_view)
rclickmenu.addActions(
[
self.action_unset_toplevel,
self.action_set_toplevel,
self.action_rename,
self.action_delete,
self.action_create_directory,
]
)
return rclickmenu
def init_Action(self):
#文件菜单
openFile = QAction("打开", self)
self.fileMenu.addAction(openFile)
openFile.triggered.connect(self.openFile)
newFile = QAction('新建', self)
newFile.setShortcut('Ctrl+N')
newFile.triggered.connect(self.addNewTab)
self.fileMenu.addAction(newFile)
saveFile = QAction('保存', self)
saveFile.setShortcut('Ctrl+S')
saveFile.triggered.connect(self.saveFile)
self.fileMenu.addAction(saveFile)
exitWin = QAction("退出", self)
self.fileMenu.addAction(exitWin)
exitWin.triggered.connect(self.exitWindow)
#编辑菜单
copy = QAction("复制", self)
copy.setShortcut("Ctrl+C")
self.editMenu.addAction(copy)
cut = QAction("剪切", self)
cut.setShortcut("Ctrl+X")
self.editMenu.addAction(cut)
paste = QAction("粘贴", self)
paste.setShortcut("Ctrl+V")
self.editMenu.addAction(paste)
#工具菜单
option = QAction("选项", self)
self.toolMenu.addAction(option)
language = QMenu("语言", self)
self.toolMenu.addMenu(language)
bash = QAction("Bash", self)
bash.triggered.connect(self.chgBashLexer)
cpp = QAction("C++", self)
cpp.triggered.connect(self.chgCppLexer)
py = QAction("Python", self)
py.triggered.connect(self.chgPyLexer)
java = QAction("Java", self)
java.triggered.connect(self.chgJavaLexer)
language.addActions([bash, cpp, py, java])
#帮助菜单
help = QAction("使用教程", self)
self.helpMenu.addAction(help)
knowUs = QAction("了解我们", self)
self.helpMenu.addAction(knowUs)
knowUs.triggered.connect(self.openUrl)
def __install_toolbar(self, rela_actions):
menu = QMenu()
tool_button = QToolButton()
tool_button.setIcon(QIcon(":img/create_new_relation"))
tool_button.setMenu(menu)
tool_button.setPopupMode(QToolButton.InstantPopup)
for item in self.TOOLBAR_ITEMS:
if item:
if item == "relation_menu":
# Install menu for relation
menu.addActions(rela_actions)
self.toolbar.addWidget(tool_button)
else:
self.toolbar.addAction(self.__ACTIONS[item])
else:
self.toolbar.addSeparator()
def get_rclickmenu(self, for_view):
# here's the custom menu (actions will be made in/visible
# as required)
rclickmenu = QMenu(for_view)
rclickmenu.addActions(
[
self.action_unset_toplevel,
self.action_set_toplevel,
self.action_rename,
self.action_delete,
self.action_create_directory,
]
)
return rclickmenu
def _fill_context_menu_with_model_item_actions(self, context_menu: QMenu):
"""
Find all model items that should be available in the context menu and create QActions for each, by
using the available logic in popupmenu.PopupMenu.
"""
# Get phrase folders to add to main menu
logger.info("Rebuilding model item actions, adding all items marked for access through the tray icon.")
folders = [folder for folder in self.config_manager.allFolders if folder.show_in_tray_menu]
items = [item for item in self.config_manager.allItems if item.show_in_tray_menu]
# Only extract the QActions, but discard the PopupMenu instance.
# This is done, because the PopupMenu class is not directly usable as a context menu here.
menu = popupmenu.PopupMenu(self.app.service, folders, items, False, "AutoKey")
new_item_actions = menu.actions()
context_menu.addActions(new_item_actions)
for action in new_item_actions: # type: QAction
# QMenu does not take the ownership when adding QActions, so manually re-parent all actions.
# This causes the QActions to be destroyed when the context menu is cleared or re-created.
action.setParent(context_menu)
if not context_menu.isEmpty():
# Avoid a stray separator line, if no items are marked for display in the context menu.
context_menu.addSeparator()
def initMenu(self):
"""
Public slot to initialize the multi project menu.
@return the menu generated (QMenu)
"""
menu = QMenu(self.tr('&Multiproject'), self.parent())
self.recentMenu = QMenu(self.tr('Open &Recent Multiprojects'),
menu)
self.__menus = {
"Main": menu,
"Recent": self.recentMenu,
}
# connect the aboutToShow signals
self.recentMenu.aboutToShow.connect(self.__showContextMenuRecent)
self.recentMenu.triggered.connect(self.__openRecent)
menu.aboutToShow.connect(self.__showMenu)
# build the main menu
menu.setTearOffEnabled(True)
menu.addActions(self.actGrp1.actions())
self.menuRecentAct = menu.addMenu(self.recentMenu)
menu.addSeparator()
menu.addAction(self.closeAct)
menu.addSeparator()
menu.addAction(self.saveAct)
menu.addAction(self.saveasAct)
menu.addSeparator()
menu.addAction(self.addProjectAct)
menu.addSeparator()
menu.addAction(self.propsAct)
self.menu = menu
return menu
class SuggestionsDialog(Tool, Ui_SuggestionsDialog):
''' Suggest possible strokes for the last written words. '''
TITLE = _('Suggestions')
ICON = ':/lightbulb.svg'
ROLE = 'suggestions'
SHORTCUT = 'Ctrl+J'
WORD_RX = re.compile(r'(?:\w+|[^\w\s]+)\s*')
STYLE_TRANSLATION, STYLE_STROKES = range(2)
# Anatomy of the text document:
# - "root" frame:
# - 0+ "suggestions" frames
# - 1+ "translation" frames
# - 1-10 "strokes" frames
def __init__(self, engine):
super(SuggestionsDialog, self).__init__(engine)
self.setupUi(self)
self._last_suggestions = None
# Toolbar.
self.layout().addWidget(ToolBar(
self.action_ToggleOnTop,
self.action_SelectFont,
self.action_Clear,
))
self.action_Clear.setEnabled(False)
# Font popup menu.
self._font_menu = QMenu()
self._font_menu_text = QAction(_('&Text'), self._font_menu)
self._font_menu_strokes = QAction(_('&Strokes'), self._font_menu)
self._font_menu.addActions([self._font_menu_text, self._font_menu_strokes])
engine.signal_connect('translated', self.on_translation)
self.suggestions.setFocus()
self.restore_state()
self.finished.connect(self.save_state)
def _get_font(self, name):
return getattr(self.suggestions, name)
def _set_font(self, name, font):
setattr(self.suggestions, name, font)
def _restore_state(self, settings):
for name in (
'text_font',
'strokes_font',
):
font_string = settings.value(name)
if font_string is None:
continue
font = QFont()
if not font.fromString(font_string):
continue
self._set_font(name, font)
ontop = settings.value('ontop', None, bool)
if ontop is not None:
self.action_ToggleOnTop.setChecked(ontop)
self.on_toggle_ontop(ontop)
def _save_state(self, settings):
for name in (
'text_font',
'strokes_font',
):
font = self._get_font(name)
font_string = font.toString()
settings.setValue(name, font_string)
ontop = bool(self.windowFlags() & Qt.WindowStaysOnTopHint)
settings.setValue('ontop', ontop)
def _show_suggestions(self, suggestion_list):
self.suggestions.append(suggestion_list)
self.action_Clear.setEnabled(True)
@staticmethod
def tails(ls):
''' Return all tail combinations (a la Haskell)
tails :: [x] -> [[x]]
>>> tails('abcd')
['abcd', 'bcd', 'cd', d']
'''
for i in range(len(ls)):
yield ls[i:]
def on_translation(self, old, new):
# Check for new output.
for a in reversed(new):
if a.text and not a.text.isspace():
break
else:
return
# Get the last 10 words.
with self._engine:
last_translations = self._engine.translator_state.translations
retro_formatter = RetroFormatter(last_translations)
split_words = retro_formatter.last_words(10, rx=self.WORD_RX)
suggestion_list = []
for phrase in self.tails(split_words):
phrase = ''.join(phrase)
suggestion_list.extend(self._engine.get_suggestions(phrase))
if not suggestion_list and split_words:
suggestion_list = [Suggestion(split_words[-1], [])]
if suggestion_list and suggestion_list != self._last_suggestions:
self._last_suggestions = suggestion_list
self._show_suggestions(suggestion_list)
def on_select_font(self):
action = self._font_menu.exec_(QCursor.pos())
if action is None:
return
if action == self._font_menu_text:
name = 'text_font'
font_options = ()
elif action == self._font_menu_strokes:
name = 'strokes_font'
font_options = (QFontDialog.MonospacedFonts,)
font = self._get_font(name)
font, ok = QFontDialog.getFont(font, self, '', *font_options)
if ok:
self._set_font(name, font)
def on_toggle_ontop(self, ontop):
flags = self.windowFlags()
if ontop:
flags |= Qt.WindowStaysOnTopHint
else:
flags &= ~Qt.WindowStaysOnTopHint
self.setWindowFlags(flags)
self.show()
def on_clear(self):
self.action_Clear.setEnabled(False)
self._last_suggestions = None
self.suggestions.clear()
def setupTextActions(self):
tb = QToolBar(self)
tb.setWindowTitle("Format Actions")
self.addToolBar(tb)
menu = QMenu("F&ormat", self)
self.menuBar().addMenu(menu)
self.actionTextBold = QAction(
QIcon.fromTheme('format-text-bold',
QIcon(rsrcPath + '/textbold.png')),
"&Bold", self, priority=QAction.LowPriority,
shortcut=Qt.CTRL + Qt.Key_B, triggered=self.textBold,
checkable=True)
bold = QFont()
bold.setBold(True)
self.actionTextBold.setFont(bold)
tb.addAction(self.actionTextBold)
menu.addAction(self.actionTextBold)
self.actionTextItalic = QAction(
QIcon.fromTheme('format-text-italic',
QIcon(rsrcPath + '/textitalic.png')),
"&Italic", self, priority=QAction.LowPriority,
shortcut=Qt.CTRL + Qt.Key_I, triggered=self.textItalic,
checkable=True)
italic = QFont()
italic.setItalic(True)
self.actionTextItalic.setFont(italic)
tb.addAction(self.actionTextItalic)
menu.addAction(self.actionTextItalic)
self.actionTextUnderline = QAction(
QIcon.fromTheme('format-text-underline',
QIcon(rsrcPath + '/textunder.png')),
"&Underline", self, priority=QAction.LowPriority,
shortcut=Qt.CTRL + Qt.Key_U, triggered=self.textUnderline,
checkable=True)
underline = QFont()
underline.setUnderline(True)
self.actionTextUnderline.setFont(underline)
tb.addAction(self.actionTextUnderline)
menu.addAction(self.actionTextUnderline)
menu.addSeparator()
grp = QActionGroup(self, triggered=self.textAlign)
# Make sure the alignLeft is always left of the alignRight.
if QApplication.isLeftToRight():
self.actionAlignLeft = QAction(
QIcon.fromTheme('format-justify-left',
QIcon(rsrcPath + '/textleft.png')),
"&Left", grp)
self.actionAlignCenter = QAction(
QIcon.fromTheme('format-justify-center',
QIcon(rsrcPath + '/textcenter.png')),
"C&enter", grp)
self.actionAlignRight = QAction(
QIcon.fromTheme('format-justify-right',
QIcon(rsrcPath + '/textright.png')),
"&Right", grp)
else:
self.actionAlignRight = QAction(
QIcon.fromTheme('format-justify-right',
QIcon(rsrcPath + '/textright.png')),
"&Right", grp)
self.actionAlignCenter = QAction(
QIcon.fromTheme('format-justify-center',
QIcon(rsrcPath + '/textcenter.png')),
"C&enter", grp)
self.actionAlignLeft = QAction(
QIcon.fromTheme('format-justify-left',
QIcon(rsrcPath + '/textleft.png')),
"&Left", grp)
self.actionAlignJustify = QAction(
QIcon.fromTheme('format-justify-fill',
QIcon(rsrcPath + '/textjustify.png')),
"&Justify", grp)
self.actionAlignLeft.setShortcut(Qt.CTRL + Qt.Key_L)
self.actionAlignLeft.setCheckable(True)
self.actionAlignLeft.setPriority(QAction.LowPriority)
self.actionAlignCenter.setShortcut(Qt.CTRL + Qt.Key_E)
self.actionAlignCenter.setCheckable(True)
self.actionAlignCenter.setPriority(QAction.LowPriority)
self.actionAlignRight.setShortcut(Qt.CTRL + Qt.Key_R)
self.actionAlignRight.setCheckable(True)
self.actionAlignRight.setPriority(QAction.LowPriority)
self.actionAlignJustify.setShortcut(Qt.CTRL + Qt.Key_J)
self.actionAlignJustify.setCheckable(True)
self.actionAlignJustify.setPriority(QAction.LowPriority)
tb.addActions(grp.actions())
menu.addActions(grp.actions())
menu.addSeparator()
pix = QPixmap(16, 16)
pix.fill(Qt.black)
self.actionTextColor = QAction(QIcon(pix), "&Color...", self,
triggered=self.textColor)
tb.addAction(self.actionTextColor)
menu.addAction(self.actionTextColor)
tb = QToolBar(self)
tb.setAllowedAreas(Qt.TopToolBarArea | Qt.BottomToolBarArea)
tb.setWindowTitle("Format Actions")
self.addToolBarBreak(Qt.TopToolBarArea)
self.addToolBar(tb)
comboStyle = QComboBox(tb)
tb.addWidget(comboStyle)
comboStyle.addItem("Standard")
comboStyle.addItem("Bullet List (Disc)")
comboStyle.addItem("Bullet List (Circle)")
comboStyle.addItem("Bullet List (Square)")
comboStyle.addItem("Ordered List (Decimal)")
comboStyle.addItem("Ordered List (Alpha lower)")
comboStyle.addItem("Ordered List (Alpha upper)")
comboStyle.addItem("Ordered List (Roman lower)")
comboStyle.addItem("Ordered List (Roman upper)")
comboStyle.activated.connect(self.textStyle)
self.comboFont = QFontComboBox(tb)
tb.addWidget(self.comboFont)
self.comboFont.activated[str].connect(self.textFamily)
self.comboSize = QComboBox(tb)
self.comboSize.setObjectName("comboSize")
tb.addWidget(self.comboSize)
self.comboSize.setEditable(True)
db = QFontDatabase()
for size in db.standardSizes():
self.comboSize.addItem("%s" % (size))
self.comboSize.activated[str].connect(self.textSize)
self.comboSize.setCurrentIndex(
self.comboSize.findText(
"%s" % (QApplication.font().pointSize())))
def __init__(self, supported_exts, parent=None):
super().__init__(parent)
self._diasshowRunning = False
# a dummy widget to center actions
spacer1 = QWidget()
spacer1.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Preferred)
self.addWidget(spacer1)
self.supportedExts = supported_exts
self._fromFile = self.addAction(QIcon("icons/image-outline.svg"), "", self.chooseFile) # load images from file
self._fromFile.setToolTip("Load image")
self._fromFolder = self.addAction(QIcon("icons/folder-open.svg"), "", self.chooseFolder) # load images from folder
self._fromFolder.setToolTip("Load from directory")
# View in native size, fit width, fit height or fit image
self._imageMode = QToolButton(self)
self._imageMode.setIcon(QIcon("icons/eye-outline.svg"))
self._imageMode.setToolTip("Image view mode")
self._imageMode.setPopupMode(QToolButton.InstantPopup)
self.addWidget(self._imageMode)
# imageMode menu
imageModeMenu = QMenu(self)
imageModeActions = QActionGroup(imageModeMenu)
imModeAct1 = imageModeActions.addAction("Native size")
imModeAct1.setCheckable(True)
imModeAct1.triggered.connect(lambda: self.imageModeChanged.emit(0))
imModeAct2 = imageModeActions.addAction("Fit in view")
imModeAct2.setCheckable(True)
imModeAct2.triggered.connect(lambda: self.imageModeChanged.emit(1))
imModeAct3 = imageModeActions.addAction("Fit width")
imModeAct3.setCheckable(True)
imModeAct3.triggered.connect(lambda: self.imageModeChanged.emit(2))
imModeAct4 = imageModeActions.addAction("Fit height")
imModeAct4.setCheckable(True)
imModeAct4.triggered.connect(lambda: self.imageModeChanged.emit(3))
imageModeActions.setExclusive(True)
imageModeMenu.addActions(imageModeActions.actions())
self._imageMode.setMenu(imageModeMenu)
self._imgDirection = self.addAction(QIcon("icons/arrow-move-outline.svg"), "", self.imageDirectionChanged.emit) # Horizontal or Vertical
self._imgDirection.setToolTip("Toggle image direction")
# start or stop diasshow
self._playDias = self.addAction(QIcon("icons/media-play-outline.svg"), "", self.diasshowState)
self._playDias.setToolTip("Start/stop diasshow")
#diasshow menu
self._diasMenu = QMenu(self)
self._diasMenu.addAction("5 seconds", lambda: self.diasshowState(5))
self._diasMenu.addAction("10 seconds", lambda: self.diasshowState(10))
self._diasMenu.addAction("30 seconds", lambda: self.diasshowState(30))
self._diasMenu.addAction("5 minutes", lambda: self.diasshowState(60*5))
self._diasMenu.addAction("10 minutes", lambda: self.diasshowState(600))
self._playDias.setMenu(self._diasMenu)
self._zoomIn = self.addAction(QIcon("icons/zoom-in-outline.svg"), "", lambda: self.zoomChanged.emit(True))
self._zoomOut = self.addAction(QIcon("icons/zoom-out-outline.svg"), "", lambda: self.zoomChanged.emit(False))
self._rotateCW = self.addAction(QIcon("icons/rotate-cw-outline.svg"), "", self.rotateChanged.emit) # Clockwise
self._rotateCW.setToolTip("Rotate Clockwise")
#self._rotateCCW = self.addAction("Rotate Left") # Counter clockwise
# a dummy widget to center actions
spacer2 = QWidget()
spacer2.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Preferred)
self.addWidget(spacer2)
class SuggestionsDialog(QDialog, Ui_SuggestionsDialog, WindowState):
ROLE = 'suggestions'
WORDS_RX = re.compile(r'[-\'"\w]+|[^\w\s]')
STYLE_TRANSLATION, STYLE_STROKES = range(2)
# Anatomy of the text document:
# - "root" frame:
# - 0+ "suggestions" frames
# - 1+ "translation" frames
# - 1-10 "strokes" frames
def __init__(self, engine):
super(SuggestionsDialog, self).__init__()
self.setupUi(self)
suggestions = SuggestionsWidget()
self.layout().replaceWidget(self.suggestions, suggestions)
self.suggestions = suggestions
self._engine = engine
self._words = u''
self._last_suggestions = None
# Toolbar.
self.layout().addWidget(ToolBar(
self.action_ToggleOnTop,
self.action_SelectFont,
self.action_Clear,
))
self.action_Clear.setEnabled(False)
# Font popup menu.
self._font_menu = QMenu()
self._font_menu_text = QAction(_('&Text'), self._font_menu)
self._font_menu_strokes = QAction(_('&Strokes'), self._font_menu)
self._font_menu.addActions([self._font_menu_text, self._font_menu_strokes])
engine.signal_connect('translated', self.on_translation)
self.suggestions.setFocus()
self.restore_state()
self.finished.connect(self.save_state)
def _get_font(self, name):
return getattr(self.suggestions, name)
def _set_font(self, name, font):
setattr(self.suggestions, name, font)
def _restore_state(self, settings):
for name in (
'text_font',
'strokes_font',
):
font_string = settings.value(name)
if font_string is None:
continue
font = QFont()
if not font.fromString(font_string):
continue
self._set_font(name, font)
def _save_state(self, settings):
for name in (
'text_font',
'strokes_font',
):
font = self._get_font(name)
font_string = font.toString()
settings.setValue(name, font_string)
def _show_suggestions(self, suggestion_list):
self.suggestions.prepend(suggestion_list)
self.action_Clear.setEnabled(True)
@staticmethod
def tails(ls):
''' Return all tail combinations (a la Haskell)
tails :: [x] -> [[x]]
>>> tails('abcd')
['abcd', 'bcd', 'cd', d']
'''
for i in range(len(ls)):
yield ls[i:]
def on_translation(self, old, new):
for action in old:
remove = len(action.text)
self._words = self._words[:-remove]
self._words = self._words + action.replace
for action in new:
remove = len(action.replace)
if remove > 0:
self._words = self._words[:-remove]
self._words = self._words + action.text
# Limit phrasing memory to 100 characters, because most phrases probably
# don't exceed this length
self._words = self._words[-100:]
suggestion_list = []
split_words = self.WORDS_RX.findall(self._words)
for phrase in self.tails(split_words):
phrase = u' '.join(phrase)
suggestion_list.extend(self._engine.get_suggestions(phrase))
if not suggestion_list and split_words:
suggestion_list = [Suggestion(split_words[-1], [])]
if suggestion_list and suggestion_list != self._last_suggestions:
self._last_suggestions = suggestion_list
self._show_suggestions(suggestion_list)
def on_select_font(self):
action = self._font_menu.exec_(QCursor.pos())
if action is None:
return
if action == self._font_menu_text:
name = 'text_font'
font_options = ()
elif action == self._font_menu_strokes:
name = 'strokes_font'
font_options = (QFontDialog.MonospacedFonts,)
font = self._get_font(name)
font, ok = QFontDialog.getFont(font, self, '', *font_options)
if ok:
self._set_font(name, font)
def on_toggle_ontop(self, ontop):
flags = self.windowFlags()
if ontop:
flags |= Qt.WindowStaysOnTopHint
else:
flags &= ~Qt.WindowStaysOnTopHint
self.setWindowFlags(flags)
self.show()
def on_clear(self):
self.action_Clear.setEnabled(False)
self._last_suggestions = None
self.suggestions.clear()
class vMCDA(object):
def __init__(self, iface):
# Save the reference to the QGIS interface
self.iface = iface
#initialize plugin directory
self.pluginDir = os.path.dirname(__file__)
# initialize locale
locale = QSettings().value("locale/userLocale")[0:2]
localePath = os.path.join(self.pluginDir, 'i18n', 'opeNoise_{}.qm'.format(locale))
if os.path.exists(localePath):
self.translator = QTranslator()
self.translator.load(localePath)
if qVersion() > '4.3.3':
QCoreApplication.installTranslator(self.translator)
def initGui(self): # aggiunge alla GUI di QGis i pulsanti per richiamare il plugin
# creiamo l'azione che lancerà il plugin
self.geoMCDAmenu = QMenu(QCoreApplication.translate("vectorMCDA", "&vectorMCDA"))
self.geoMCDAmenu.setIcon(QIcon(":/plugins/VectorMCDA/icons/Tree.png"))
self.actionWeightedSum = QAction("geoWeightedSum",self.iface.mainWindow() )
self.actionWeightedSum.triggered.connect(self.runGeoWeightedSum )
self.actionTOPSIS = QAction( "geoTOPSIS", self.iface.mainWindow() )
self.actionTOPSIS.triggered.connect(self.runGeoTOPSIS )
self.actionFuzzy = QAction( "geoFuzzy", self.iface.mainWindow() )
self.actionFuzzy.triggered.connect(self.runGeoFuzzy )
self.actionFuzzy.setDisabled(True)
self.actionElectre = QAction( "geoConcordance", self.iface.mainWindow() )
self.actionElectre.triggered.connect(self.runGeoElectre )
self.actionPromethee = QAction( "geoPromethee", self.iface.mainWindow() )
self.actionPromethee.triggered.connect(self.runGeoPromethee )
self.actionRSDB = QAction( "geoRSDB", self.iface.mainWindow() )
self.actionRSDB.triggered.connect(self.runGeoRSDB )
self.actionRSDB = QAction( "geoRULES", self.iface.mainWindow() )
self.actionRSDB.triggered.connect(self.runGeoRULES )
self.actionXMCDA = QAction( "geoXMCDA", self.iface.mainWindow() )
self.actionXMCDA.triggered.connect(self.runGeoXMCDA )
self.actionUmbriaSuit = QAction( "geoUmbriaSUIT", self.iface.mainWindow() )
self.actionUmbriaSuit.triggered.connect(self.runGeoUmbriaSuit )
self.actionFuzzy.setDisabled(True)
#self.actionTEMPLATE = QAction( "geoTEMPLATE", self.iface.mainWindow() )
#self.actionTEMPLATE.triggered.connect(self.runGeoTEMPLATE )
# aggiunge il plugin alla toolbar
self.geoMCDAmenu.addActions([self.actionWeightedSum,self.actionTOPSIS,self.actionFuzzy,\
self.actionElectre,self.actionPromethee,self.actionRSDB,self.actionXMCDA,self.actionUmbriaSuit])
self.menu = self.iface.pluginMenu()
self.menu.addMenu( self.geoMCDAmenu )
def unload(self): # rimuove dalla GUI i pulsanti aggiunti dal plugin
#self.iface.removeToolBarIcon( self.action )
self.iface.removePluginMenu( "&geoWeightedSum", self.actionWeightedSum )
self.iface.removePluginMenu( "&geoTOPSIS", self.actionTOPSIS )
self.iface.removePluginMenu( "&geoFuzzy", self.actionFuzzy )
self.iface.removePluginMenu( "&geoConcordance", self.actionElectre )
self.iface.removePluginMenu( "&geoPromethee", self.actionPromethee )
self.iface.removePluginMenu( "&geoRSDB", self.actionRSDB )
self.iface.removePluginMenu( "&geoRULES", self.actionRSDB )
self.iface.removePluginMenu( "&geoXMCDA", self.actionXMCDA )
self.iface.removePluginMenu( "&geoUmbriaSuit", self.actionUmbriaSuit )
#self.iface.removePluginMenu( "&geoTEMPLATE", self.actionTEMPLATE )
def runGeoWeightedSum(self): # richiamato al click sull'azione
from .geoWeightedSum import geoWeightedSumDialog
self.activeLayer = self.iface.activeLayer()
if ((self.activeLayer == None) or (self.activeLayer.type() != QgsMapLayer.VectorLayer)):
result=QMessageBox.question(self.iface.mainWindow(), "VectorMCDA",
("No active layer found\n" "Please make active one or more vector layer\n" \
"Do you need documents or data ?"), QMessageBox.Yes | QMessageBox.No, QMessageBox.No)
if result == QMessageBox.Yes:
webbrowser.open("http://maplab.alwaysdata.net/geomcda.html")
else:
dlg = geoWeightedSumDialog(self.iface)
dlg.exec_()
def runGeoTOPSIS(self): # richiamato al click sull'azione
from .geoTOPSIS import geoTOPSISDialog
self.activeLayer = self.iface.activeLayer()
if ((self.activeLayer == None) or (self.activeLayer.type() != QgsMapLayer.VectorLayer)):
result=QMessageBox.question(self.iface.mainWindow(), "VectorMCDA",
("No active layer found\n" "Please make active one or more vector layer\n" \
"Do you need documents or data ?"), QMessageBox.Yes | QMessageBox.No, QMessageBox.No)
if result == QMessageBox.Yes:
webbrowser.open("http://maplab.alwaysdata.net/geomcda.html")
else:
dlg = geoTOPSISDialog(self.iface)
dlg.exec_()
def runGeoFuzzy(self): # richiamato al click sull'azione
from .geoFuzzy import geoFuzzyDialog
self.activeLayer = self.iface.activeLayer()
if ((self.activeLayer == None) or (self.activeLayer.type() != QgsMapLayer.VectorLayer)):
result=QMessageBox.question(self.iface.mainWindow(), "VectorMCDA",
("No active layer found\n" "Please make active one or more vector layer\n" \
"Do you need documents or data ?"), QMessageBox.Yes | QMessageBox.No, QMessageBox.No)
if result == QMessageBox.Yes:
webbrowser.open("http://maplab.alwaysdata.net/geomcda.html")
else:
dlg = geoFuzzyDialog(self.iface)
dlg.exec_()
def runGeoElectre(self): # richiamato al click sull'azione
from .geoElectre import geoElectreDialog
self.activeLayer = self.iface.activeLayer()
if ((self.activeLayer == None) or (self.activeLayer.type() != QgsMapLayer.VectorLayer)):
result=QMessageBox.question(self.iface.mainWindow(), "VectorMCDA",
("No active layer found\n" "Please make active one or more vector layer\n" \
"Do you need documents or data ?"), QMessageBox.Yes | QMessageBox.No, QMessageBox.No)
if result == QMessageBox.Yes:
webbrowser.open("http://maplab.alwaysdata.net/geomcda.html")
else:
dlg = geoElectreDialog(self.iface)
dlg.exec_()
def runGeoPromethee(self): # richiamato al click sull'azione
from .geoPromethee import geoPrometheeDialog
self.activeLayer = self.iface.activeLayer()
if ((self.activeLayer == None) or (self.activeLayer.type() != QgsMapLayer.VectorLayer)):
result=QMessageBox.question(self.iface.mainWindow(), "VectorMCDA",
("No active layer found\n" "Please make active one or more vector layer\n" \
"Do you need documents or data ?"), QMessageBox.Yes | QMessageBox.No, QMessageBox.No)
if result == QMessageBox.Yes:
webbrowser.open("http://maplab.alwaysdata.net/geomcda.html")
else:
dlg = geoPrometheeDialog(self.iface)
dlg.exec_()
def runGeoRSDB(self): # richiamato al click sull'azione
from geoRSDB import geoRSDBDialog
self.activeLayer = self.iface.activeLayer()
if ((self.activeLayer == None) or (self.activeLayer.type() != QgsMapLayer.VectorLayer)):
result=QMessageBox.question(self.iface.mainWindow(), "VectorMCDA",
("No active layer found\n" "Please make active one or more vector layer\n" \
"Do you need documents or data ?"), QMessageBox.Yes | QMessageBox.No, QMessageBox.No)
if result == QMessageBox.Yes:
webbrowser.open("http://maplab.alwaysdata.net/geomcda.html")
else:
dlg = geoRSDBDialog(self.iface)
dlg.exec_()
def runGeoRULES(self): # richiamato al click sull'azione
from .geoRULES import geoRULESDialog
self.activeLayer = self.iface.activeLayer()
if ((self.activeLayer == None) or (self.activeLayer.type() != QgsMapLayer.VectorLayer)):
result=QMessageBox.question(self.iface.mainWindow(), "VectorMCDA",
("No active layer found\n" "Please make active one or more vector layer\n" \
"Do you need documents or data ?"), QMessageBox.Yes | QMessageBox.No, QMessageBox.No)
if result == QMessageBox.Yes:
webbrowser.open("http://maplab.alwaysdata.net/geomcda.html")
else:
dlg = geoRULESDialog(self.iface)
dlg.exec_()
def runGeoXMCDA(self): # richiamato al click sull'azione
from .geoXMCDA import geoXMCDADialog
self.activeLayer = self.iface.activeLayer()
if ((self.activeLayer == None) or (self.activeLayer.type() != QgsMapLayer.VectorLayer)):
result=QMessageBox.question(self.iface.mainWindow(), "VectorMCDA",
("No active layer found\n" "Please make active one or more vector layer\n" \
"Do you need documents or data ?"), QMessageBox.Yes | QMessageBox.No, QMessageBox.No)
if result == QMessageBox.Yes:
webbrowser.open("http://maplab.alwaysdata.net/geomcda.html")
else:
dlg = geoXMCDADialog(self.iface)
dlg.exec_()
def runGeoUmbriaSuit(self):
from .geoSUIT import geoSUITDialog
self.activeLayer = self.iface.activeLayer()
if ((self.activeLayer == None) or (self.activeLayer.type() != QgsMapLayer.VectorLayer)):
result=QMessageBox.question(self.iface.mainWindow(), "geoUmbriaSUIT in VectorMCDA",
("No active layer found\n" "Please make active one or more vector layer\n" \
"Do you need documents or data ?"), QMessageBox.Yes | QMessageBox.No, QMessageBox.No)
if result == QMessageBox.Yes:
webbrowser.open("http://maplab.alwaysdata.net/geoUmbriaSUIT.html")
else:
dlg = geoSUITDialog(self.iface)
dlg.exec_()
def runGeoTEMPLATE(self): # richiamato al click sull'azione
from .geoTEMPLATE import geoTEMPLATEDialog
self.activeLayer = self.iface.activeLayer()
if ((self.activeLayer == None) or (self.activeLayer.type() != QgsMapLayer.VectorLayer)):
result=QMessageBox.question(self.iface.mainWindow(), "VectorMCDA",
("No active layer found\n" "Please make active one or more vector layer\n" \
"Do you need documents or data ?"), QMessageBox.Yes | QMessageBox.No, QMessageBox.No)
if result == QMessageBox.Yes:
webbrowser.open("http://maplab.alwaysdata.net/geomcda.html")
else:
dlg = geoTEMPLATEDialog(self.iface)
dlg.exec_()
class LibraryUI(QTreeWidget):
trackChange = pyqtSignal(QTreeWidgetItem, int)
unknownTrack = pyqtSignal(str)
meta = ["TRACKNUMBER", "TITLE", "ALBUMARTIST", "ALBUM", "LENGTH", "BITRATE", "STYLE"]
def __init__(self):
super().__init__()
self.setIndentation(0)
self.setSortingEnabled(True)
self.setContextMenuPolicy(Qt.CustomContextMenu)
self.setSelectionMode(QAbstractItemView.ExtendedSelection)
self.metadataUI = MetadataUI()
self.songMenu = QMenu("Actions")
self.addMenu = QMenu("Actions")
self._connect_widgets()
self._init_menus()
def init_playlist(self, lib):
for song_meta in lib.values():
info = ['' for i in range(7)]
try:
for i in range(7):
if i == 4:
length = int(song_meta.get(self.meta[i])[0]) / 1000
mins = int(length / 60)
secs = int(length - 60 * mins)
info[i] = str(mins) + ":%02d" % secs
elif i == 5:
info[i] = song_meta.get(self.meta[i])[0] + " kbit/s"
else:
info[i] = song_meta.get(self.meta[i])[0]
except:
pass
item = QTreeWidgetItem()
for i in range(7):
item.setText(i, info[i])
item.setData(0, 1, QUrl.fromLocalFile(song_meta.get("DIR")))
self.addTopLevelItem(item)
headers = ["#", "Title", "Artist", "Album", "Dur.", "Bitrate", "Genre"]
self.setColumnCount(6)
self.header().setDefaultAlignment(Qt.AlignCenter)
self.setHeaderLabels(headers)
self.setColumnWidth(0, 50)
self.setColumnWidth(1, 200)
self.setColumnWidth(2, 150)
self.setColumnWidth(3, 150)
self.setColumnWidth(4, 50)
self.setColumnWidth(5, 100)
self.setColumnWidth(6, 50)
def next_track(self):
item = self.itemBelow(self.currentItem())
if item is None:
item = self.topLevelItem(0)
self.setCurrentItem(item)
self.trackChange.emit(item, 0)
def prev_track(self):
item = self.itemAbove(self.currentItem())
if item is None:
item = self.topLevelItem(self.topLeveLitemCount() - 1)
self.setCurrentItem(item)
self.trackChange.emit(item, 0)
def _connect_widgets(self):
self.customContextMenuRequested.connect(self.show_menu)
self.metadataUI.save_metadata.connect(self.save_metadata)
self.metadataUI.closeButton.clicked.connect(self.close_metadata)
@pyqtSlot(QPoint)
def show_menu(self, point):
if self.currentItem() is None:
self.addMenu.exec(self.mapToGlobal(point))
else:
self.songMenu.exec(self.mapToGlobal(point))
def _init_menus(self):
self._init_song_menu()
self._init_add_menu()
def _init_add_menu(self):
self.menuAdd = QAction("Add Songs...", self.addMenu)
self.addMenu.addAction(self.menuAdd)
def _init_song_menu(self):
self.menuPlay = QAction("Play Song", self.songMenu)
self.menuEdit = QAction("Edit Metadata", self.songMenu)
self.songMenu.addActions([self.menuPlay, self.menuEdit])
self.menuPlay.triggered.connect(self.current_track)
self.menuEdit.triggered.connect(self.show_metadata)
def current_track(self):
self.trackChange.emit(self.currentItem(), 0)
def show_metadata(self):
self.setEnabled(False)
self.metadataUI.load_data(self.currentItem())
self.metadataUI.show()
def close_metadata(self):
self.setEnabled(True)
def save_metadata(self, data):
edit = taglib.File(self.currentItem().data(0,1).path())
for i in range(5):
if i == 1:
edit.tags[self.meta[i]] = self._parse_time_string(data[self.meta[i]])
else:
edit.tags[self.meta[i]] = data[self.meta[i]]
self.currentItem().setText(i, data[self.meta[i]])
edit.save()
self.setEnabled(True)
def _parse_time_string(self, val):
ms = val.split(":")
return str((int(ms[0]) * 60 + int(ms[1])) * 1000)
