def contextMenuEvent(self, event):
menu = QMenu(self)
remove_icon = resources.icon(name='delete')
remove_action = QAction(remove_icon, 'Remove', menu)
remove_tooltip = 'Delete selected project'
remove_action.setStatusTip(remove_tooltip)
remove_action.setToolTip(remove_tooltip)
remove_action.triggered.connect(self._on_remove_project)
folder_icon = resources.icon(name='open_folder', extension='png')
folder_action = QAction(folder_icon, 'Open in Browser', menu)
open_project_in_explorer_tooltip = 'Open project folder in explorer'
folder_action.setStatusTip(open_project_in_explorer_tooltip)
folder_action.setToolTip(open_project_in_explorer_tooltip)
folder_action.triggered.connect(self._on_open_in_browser)
image_icon = resources.icon(name='picture', extension='png')
set_image_action = QAction(image_icon, 'Set Project Image', menu)
set_project_image_tooltip = 'Set the image used by the project'
set_image_action.setToolTip(set_project_image_tooltip)
set_image_action.setStatusTip(set_project_image_tooltip)
set_image_action.triggered.connect(self._on_set_project_image)
for action in [remove_action, None, folder_action, None, set_image_action]:
if action is None:
menu.addSeparator()
else:
menu.addAction(action)
menu.exec_(self.mapToGlobal(event.pos()))
def contextMenuEvent(self, event):
menu = QMenu(self)
remove_icon = resources.icon(name='delete')
remove_action = QAction(remove_icon, 'Remove', menu)
remove_action.setStatusTip(consts.DELETE_PROJECT_TOOLTIP)
remove_action.setToolTip(consts.DELETE_PROJECT_TOOLTIP)
remove_action.triggered.connect(self._on_remove_project)
folder_icon = resources.icon(name='open_folder', extension='png')
folder_action = QAction(folder_icon, 'Open in Browser', menu)
folder_action.setStatusTip(consts.OPEN_PROJECT_IN_EXPLORER_TOOLTIP)
folder_action.setToolTip(consts.OPEN_PROJECT_IN_EXPLORER_TOOLTIP)
folder_action.triggered.connect(self._on_open_in_browser)
image_icon = resources.icon(name='picture', extension='png')
set_image_action = QAction(image_icon, 'Set Project Image', menu)
set_image_action.setToolTip(consts.SET_PROJECT_IMAGE_TOOLTIP)
set_image_action.setStatusTip(consts.SET_PROJECT_IMAGE_TOOLTIP)
set_image_action.triggered.connect(self._on_set_project_image)
for action in [
remove_action, None, folder_action, None, set_image_action
]:
if action is None:
menu.addSeparator()
else:
menu.addAction(action)
menu.exec_(self.mapToGlobal(event.pos()))
def create_settings_menu(self):
"""
Creates and returns the settings menu for this widget
:return: QMenu
"""
menu = QMenu('Item View', self)
menu.setIcon(resources.icon('eye'))
menu.addSeparator()
# copy_text_menu = self.tree_widget().create_copy_text_menu()
# menu.addMenu(copy_text_menu)
# menu.addSeparator()
size_action = action.SliderAction('Size', menu)
size_action.slider().setMinimum(10)
size_action.slider().setMaximum(200)
size_action.slider().setValue(self.zoom_amount())
size_action.slider().valueChanged.connect(self.set_zoom_amount)
menu.addAction(size_action)
border_action = action.SliderAction('Border', menu)
border_action.slider().setMinimum(0)
border_action.slider().setMaximum(20)
border_action.slider().setValue(self.padding())
border_action.slider().valueChanged.connect(self.set_padding)
menu.addAction(border_action)
spacing_action = action.SliderAction('Spacing', menu)
spacing_action.slider().setMinimum(self.DEFAULT_MIN_SPACING)
spacing_action.slider().setMaximum(self.DEFAULT_MAX_SPACING)
spacing_action.slider().setValue(self.spacing())
spacing_action.slider().valueChanged.connect(self.set_spacing)
menu.addAction(spacing_action)
menu.addAction(action.SeparatorAction('Label Options', menu))
for option in item.LabelDisplayOption.values():
option_action = QAction(option.title(), menu)
option_action.setCheckable(True)
option_action.setChecked(option == self.label_display_option())
option_callback = partial(self.set_label_display_option, option)
option_action.triggered.connect(option_callback)
menu.addAction(option_action)
return menu
def _create_header_menu(self, column):
"""
Internal function that creates a new header menu
:param column, iht
:return: QMenu
"""
menu = QMenu(self)
label = self.label_from_column(column)
hide_action = menu.addAction('Hide "{}"'.format(label))
hide_callback = partial(self.setColumnHidden, column, True)
hide_action.triggered.connect(hide_callback)
menu.addSeparator()
resize_action = menu.addAction('Resize to Contents')
resize_callback = partial(self.resizeColumnToContents, column)
resize_action.triggered.connect(resize_callback)
return menu
def _create_hide_column_menu(self):
"""
Internal function that creates the hide column menu
:return: QMenu
"""
menu = QMenu('Show/Hide Column', self)
show_all_action = menu.addAction('Show All')
show_all_action.triggered.connect(self.show_all_columns)
hide_all_action = menu.addAction('Hide All')
hide_all_action.triggered.connect(self.hide_all_columns)
menu.addSeparator()
for column in range(self.columnCount()):
label = self.label_from_column(column)
is_hidden = self.isColumnHidden(column)
action = menu.addAction(label)
action.setCheckable(True)
action.setChecked(not is_hidden)
action_callback = partial(self.setColumnHidden, column,
not is_hidden)
action.triggered.connect(action_callback)
return menu
class MultiSelectComboBox(QFrame):
'''
This class offers comboBox to select multiple objects at once
'''
selectionDone = Signal(list)
def __init__(self, parent=None, msg='--Select--', triState=False):
super(MultiSelectComboBox, self).__init__(parent)
loadUi(osp.join(uiPath, 'multiSelectComboBox.ui'), self)
self.triState = triState
self.msg = msg
self.menu = QMenu(self)
self.menu.setStyleSheet("QMenu { menu-scrollable: 1; }")
self.button.setMenu(self.menu)
self.menu.hideEvent = self.menuHideEvent
self.setHintText(self.msg)
def addDefaultWidgets(self):
button = QPushButton('Invert Selection', self)
button.clicked.connect(self.invertSelection)
checkableAction = QWidgetAction(self.menu)
checkableAction.setDefaultWidget(button)
self.menu.addAction(checkableAction)
btn = self.addItem('Select All')
btn.clicked.connect(lambda: self.toggleAll(btn))
self.menu.addSeparator()
def invertSelection(self):
for cBox in self.getWidgetItems():
cBox.setChecked(not cBox.isChecked())
self.toggleSelectAllButton()
def toggleAll(self, btn):
for cBox in self.getWidgetItems():
cBox.setCheckState(btn.checkState())
def toggleSelectAllButton(self):
flag = True
for cBox in self.getWidgetItems():
if not cBox.isChecked():
flag = False
break
for action in self.menu.actions():
if type(action) == QAction:
continue
widget = action.defaultWidget()
if widget.text() == 'Select All':
widget.setChecked(flag)
def setHintText(self, text):
self.button.setText(text)
def menuHideEvent(self, event):
items = self.getSelectedItems()
if items:
s = ''
if len(items) > 2:
s = ',...'
self.button.setText(','.join(items[:2]) + s)
else:
self.setHintText(self.msg)
if event:
QMenu.hideEvent(self.menu, event)
self.selectionDone.emit(items)
def getSelectedItems(self):
return [
cBox.text().strip() for cBox in self.getWidgetItems()
if cBox.isChecked()
]
def getState(self):
return {
cBox.text().strip(): cBox.checkState()
for cBox in self.getWidgetItems()
}
def getWidgetItems(self):
return [
cBox for cBox in [
action.defaultWidget() for action in self.menu.actions()
if not type(action) is QAction
] if cBox.text().strip() != 'Select All'
and cBox.text().strip() != 'Invert Selection'
]
def getItems(self):
return [cBox.text().strip() for cBox in self.getWidgetItems()]
def addItem(self, item, selected=False):
checkBox = QCheckBox(item, self.menu)
checkBox.setTristate(self.triState)
if selected:
checkBox.setChecked(True)
checkableAction = QWidgetAction(self.menu)
checkableAction.setDefaultWidget(checkBox)
self.menu.addAction(checkableAction)
return checkBox
def appendItems(self, items, selected=None):
self.addItems(items, selected=selected, clear=False)
def addItems(self, items, selected=None, clear=True):
items = sorted(items)
if clear:
self.clearItems()
self.addDefaultWidgets()
for item in items:
sel = False
if selected and item in selected:
sel = True
btn = self.addItem(item, sel)
btn.clicked.connect(self.toggleSelectAllButton)
if selected:
self.menuHideEvent(None)
def clearItems(self):
self.menu.clear()
self.setHintText(self.msg)
def _setup_menubar(self):
"""
Internal function that setups menu bar for the widget
:return:
"""
menubar = self.menuBar()
save_icon = resources.icon('save')
load_icon = resources.icon('open_folder')
play_icon = resources.icon('play')
clear_icon = resources.icon('delete')
resume_icon = resources.icon('resume')
undo_icon = resources.icon('undo')
redo_icon = resources.icon('redo')
copy_icon = resources.icon('copy')
cut_icon = resources.icon('cut')
paste_icon = resources.icon('paste')
tab_icon = resources.icon('tab')
quote_icon = resources.icon('quote')
rename_icon = resources.icon('rename')
keyboard_icon = resources.icon('keyboard')
help_icon = resources.icon('help')
file_menu = QMenu('File', menubar)
menubar.addMenu(file_menu)
save_session_action = QAction(save_icon, 'Save Session', file_menu)
load_script_action = QAction(load_icon, 'Load Script', file_menu)
save_script_action = QAction(save_icon, 'Save Script', file_menu)
file_menu.addAction(save_session_action)
file_menu.addAction(load_script_action)
file_menu.addAction(save_script_action)
load_script_action.setShortcut('Ctrl+O')
# load_script_action.setShortcutContext(Qt.WidgetShortcut)
save_script_action.setShortcut('Ctrl+S')
# save_script_action.setShortcutContext(Qt.WidgetShortcut)
edit_menu = QMenu('Edit', self)
menubar.addMenu(edit_menu)
undo_action = QAction(undo_icon, 'Undo', edit_menu)
redo_action = QAction(redo_icon, 'Redo', edit_menu)
copy_action = QAction(copy_icon, 'Copy', edit_menu)
cut_action = QAction(cut_icon, 'Cut', edit_menu)
paste_action = QAction(paste_icon, 'Paste', edit_menu)
tab_to_spaces_action = QAction(tab_icon, 'Tab to Spaces', edit_menu)
comment_action = QAction(quote_icon, 'Comment', edit_menu)
find_and_replace = QAction(rename_icon, 'Find and Replace', edit_menu)
edit_menu.addAction(undo_action)
edit_menu.addAction(redo_action)
edit_menu.addSeparator()
edit_menu.addAction(copy_action)
edit_menu.addAction(cut_action)
edit_menu.addAction(paste_action)
edit_menu.addSeparator()
edit_menu.addAction(tab_to_spaces_action)
edit_menu.addAction(comment_action)
edit_menu.addAction(find_and_replace)
run_menu = QMenu('Run', self)
menubar.addMenu(run_menu)
self._execute_all_action = QAction(play_icon, 'Execute All', run_menu)
self._execute_all_action.setShortcut('Ctrl+Shift+Return')
self._execute_all_action.setShortcutContext(Qt.ApplicationShortcut)
self._execute_selected_action = QAction(resume_icon,
'Execute Selected', run_menu)
self._execute_selected_action.setShortcut('Ctrl+Return')
self._execute_selected_action.setShortcutContext(
Qt.WidgetWithChildrenShortcut)
self._clear_output_action = QAction(clear_icon, 'Clear Output',
run_menu)
run_menu.addAction(self._execute_all_action)
run_menu.addAction(self._execute_selected_action)
run_menu.addAction(self._clear_output_action)
help_menu = QMenu('Help', self)
menubar.addMenu(help_menu)
show_shortcuts_action = QAction(keyboard_icon, 'Show Shortcuts',
help_menu)
print_help_action = QAction(help_icon, 'Print Help', help_menu)
help_menu.addAction(show_shortcuts_action)
help_menu.addSeparator()
help_menu.addAction(print_help_action)
undo_action.setShortcut('Ctrl+Z')
undo_action.setShortcutContext(Qt.WidgetShortcut)
redo_action.setShortcut('Ctrl+Y')
redo_action.setShortcutContext(Qt.WidgetShortcut)
copy_action.setShortcut('Ctrl+C')
copy_action.setShortcutContext(Qt.WidgetShortcut)
cut_action.setShortcut('Ctrl+X')
cut_action.setShortcutContext(Qt.WidgetShortcut)
paste_action.setShortcut('Ctrl+V')
paste_action.setShortcutContext(Qt.WidgetShortcut)
comment_action.setShortcut(QKeySequence(Qt.ALT + Qt.Key_Q))
comment_action.setShortcutContext(Qt.WidgetShortcut)
self._execute_all_action.triggered.connect(
self._controller.execute_script)
self._execute_selected_action.triggered.connect(
partial(self._controller.execute_script, True))
self._clear_output_action.triggered.connect(
partial(self._controller.set_output_text, ''))
# open_settings_folder_action.triggered.connect(self._open_settings)
# show_shortcuts_action.triggered.connect(self._open_shortcuts)
# print_help_action.triggered.connect(self.editor_help)
save_session_action.triggered.connect(
self._controller.save_current_session)
save_script_action.triggered.connect(self._controller.save_script)
load_script_action.triggered.connect(self._controller.load_script)
undo_action.triggered.connect(self._scripts_tab.undo)
redo_action.triggered.connect(self._scripts_tab.redo)
copy_action.triggered.connect(self._scripts_tab.copy)
cut_action.triggered.connect(self._scripts_tab.cut)
paste_action.triggered.connect(self._scripts_tab.paste)
tab_to_spaces_action.triggered.connect(
self._controller.convert_tab_to_spaces)
# find_and_replace.triggered.connect(self._open_find_replace)
comment_action.triggered.connect(self._scripts_tab.comment)
return menubar
class Option(base.BaseWidget, object):
updateValues = Signal(object)
widgetClicked = Signal(object)
def __init__(self, name, parent=None, main_widget=None, *args, **kwargs):
self._name = name
self._option_object = None
self._parent = main_widget
super(Option, self).__init__(parent=parent)
self._original_background_color = self.palette().color(
self.backgroundRole())
self._option_type = self.get_option_type()
self._option_widget = self.get_option_widget()
if self._option_widget:
self.main_layout.addWidget(self._option_widget)
self._setup_option_widget_value_change()
self.setContextMenuPolicy(Qt.CustomContextMenu)
self.customContextMenuRequested.connect(self._on_item_menu)
self._context_menu = None
def get_main_layout(self):
main_layout = layouts.HorizontalLayout()
main_layout.setContentsMargins(0, 0, 0, 0)
main_layout.setSpacing(0)
return main_layout
def ui(self):
super(Option, self).ui()
def mousePressEvent(self, event):
super(Option, self).mousePressEvent(event)
if not event.button() == Qt.LeftButton:
return
parent = self.get_parent()
if parent:
parent.supress_select = True
self.widgetClicked.emit(self)
def get_option_type(self):
return None
def get_option_widget(self):
return None
def get_name(self):
name = self._option_widget.get_label_text()
return name
def set_name(self, name):
self._option_widget.set_label_text(name)
def set_value(self, value):
pass
def get_value(self):
pass
def get_parent(self):
parent = self.parent()
grand_parent = parent.parent()
if hasattr(grand_parent, 'group'):
parent = grand_parent
if not hasattr(parent, 'child_layout'):
return
# We cannot use this because of import problems
# if parent.__class__ == optionlist.OptionList:
if parent.__class__.__name__ == 'OptionList':
return parent
return parent
def rename(self):
title = self.get_name()
new_name = qtutils.get_string_input('Rename Option', old_name=title)
found = self._get_widget_names()
if new_name == title or new_name is None or new_name == '':
return
while new_name in found:
new_name = name_utils.increment_last_number(new_name)
self.set_name(new_name)
self.updateValues.emit(True)
def remove(self):
parent = self.get_parent()
if self in self._parent._current_widgets:
remove_index = self._parent._current_widgets.index(self)
self._parent._current_widgets.pop(remove_index)
parent.child_layout.removeWidget(self)
self.deleteLater()
self.updateValues.emit(True)
def move_up(self):
parent = self.get_parent()
if not parent:
parent = self.parent()
layout = parent.child_layout
index = layout.indexOf(self)
if index == 0:
return
index -= 1
parent.child_layout.removeWidget(self)
layout.insertWidget(index, self)
self.updateValues.emit(True)
def move_down(self):
parent = self.get_parent()
if not parent:
parent = self.parent()
layout = parent.child_layout
index = layout.indexOf(self)
if index == 0:
return
index += 1
parent.child_layout.removeWidget(self)
layout.insertWidget(index, self)
self.updateValues.emit(True)
def copy_to(self, parent):
name = self.get_name()
value = self.get_value()
new_inst = self.__class__(name)
new_inst.set_value(value)
parent.child_layout.addWidget(new_inst)
def set_option_object(self, option_object):
self._option_object = option_object
def _setup_option_widget_value_change(self):
pass
def _copy(self):
self._parent.set_widget_to_copy(self)
def _get_widget_names(self):
item_count = self.parent().child_layout.count()
found = list()
for i in range(item_count):
item = self.parent().child_layout.itemAt(i)
widget = item.widget()
widget_label = widget.get_name()
found.append(widget_label)
return found
def _create_context_menu(self):
self._context_menu = QMenu()
move_up_icon = resources.icon('sort_up')
move_down_icon = resources.icon('sort_down')
rename_icon = resources.icon('rename')
remove_icon = resources.icon('delete')
copy_icon = resources.icon('copy')
move_up_action = QAction(move_up_icon, 'Move Up', self._context_menu)
self._context_menu.addAction(move_up_action)
move_down_action = QAction(move_down_icon, 'Move Down',
self._context_menu)
self._context_menu.addAction(move_down_action)
self._context_menu.addSeparator()
copy_action = QAction(copy_icon, 'Copy', self._context_menu)
self._context_menu.addAction(copy_action)
rename_action = QAction(rename_icon, 'Rename', self._context_menu)
self._context_menu.addAction(rename_action)
remove_action = QAction(remove_icon, 'Remove', self._context_menu)
self._context_menu.addAction(remove_action)
move_up_action.triggered.connect(self.move_up)
move_down_action.triggered.connect(self.move_down)
rename_action.triggered.connect(self.rename)
remove_action.triggered.connect(self.remove)
def _on_item_menu(self, pos):
if not self._parent or not self._parent.is_edit_mode():
return
if not self._context_menu:
self._create_context_menu()
self._context_menu.exec_(self.mapToGlobal(pos))
def _on_value_changed(self):
self.updateValues.emit(False)
