def __init__(self, log_enable=None):
QtWidgets.QMenu.__init__(self)
self.setTitle('Y Axis')
# Annotations
self.annotations = self.addMenu('Annotations')
self.single_marker = self.annotations.addAction('Single Marker')
self.dual_markers = self.annotations.addAction('Dual Markers')
self.clear_annotations = self.annotations.addAction('Clear all')
# range
self.range = QtWidgets.QMenu()
self.range.setTitle('Range')
self.range_group = QtWidgets.QActionGroup(self)
self.range_group.setExclusive(True)
self.range_auto = QtWidgets.QAction(
'&Auto',
self.range_group,
checkable=True,
toolTip=
'Automatically adjust the y-axis range to show all visible data.')
self.range_auto.setChecked(True)
self.range.addAction(self.range_auto)
self.range_group.addAction(self.range_auto)
self.range_manual = QtWidgets.QAction(
'&Manual',
self.range_group,
checkable=True,
toolTip='Manually zoom and pan the y-axis range.')
self.range.addAction(self.range_manual)
self.range_group.addAction(self.range_manual)
self.addMenu(self.range)
self.scale = QtWidgets.QMenu()
self.scale.setTitle('Scale')
self.scale_group = QtWidgets.QActionGroup(self)
self.scale_group.setExclusive(True)
self.scale_linear = QtWidgets.QAction(
'&Linear',
self.scale_group,
checkable=True,
toolTip='Use a "normal" linear y-axis scale.')
self.scale_linear.setChecked(True)
self.scale.addAction(self.scale_linear)
self.scale_group.addAction(self.scale_linear)
self.scale_logarithmic = QtWidgets.QAction(
'Lo&garithmic',
self.scale_group,
checkable=True,
toolTip='Use a logarithmic y-axis scale.')
self.scale.addAction(self.scale_logarithmic)
self.scale_group.addAction(self.scale_logarithmic)
if log_enable:
self.addMenu(self.scale)
self.hide_request = QtWidgets.QAction('&Hide', self)
self.hide_request.setToolTip('Hide this signal.')
self.addAction(self.hide_request)
def menu_exec(self, pos):
menu = QtWidgets.QMenu()
set_text = menu.addAction('&Edit text')
set_text.triggered.connect(self._edit_text)
show_text = menu.addAction('&Show Text')
show_text.setCheckable(True)
show_text.setChecked(self._text_item.isVisible())
show_text.triggered.connect(self._show_text)
center_y = menu.addAction('&Center Y')
center_y.setCheckable(True)
center_y.setChecked(self._state['y'] is None)
center_y.triggered.connect(self._center_y)
group_id = self._state['group_id']
appearance_menu = menu.addMenu('&Appearance')
appearance_group = QtWidgets.QActionGroup(appearance_menu)
appearance_actions = []
for idx, (_, name, shape) in enumerate(SHAPES_DEF):
action = appearance_menu.addAction(name)
action.setCheckable(True)
action.setChecked(group_id == idx)
action.triggered.connect(self._group_id_setter(name))
appearance_group.addAction(action)
appearance_actions.append(action)
remove = menu.addAction('&Remove')
remove.triggered.connect(self._remove)
menu.exec_(pos)
def layout_menu(self):
mb = self.menuBar()
edit_menu = mb.addMenu("&Edit")
theme_menu = edit_menu.addMenu("Theme")
self.theme_act_grp = QtWidgets.QActionGroup(theme_menu)
self.theme_act_grp.setExclusive(True)
def _add_theme(attr_name, name):
nonlocal theme_menu
action = QtWidgets.QAction(name)
self.theme_actions[attr_name] = action
action.setCheckable(True)
action.triggered.connect(self.on_theme_action_triggered)
self.theme_act_grp.addAction(action)
theme_menu.addAction(action)
_add_theme("light", "Light")
_add_theme("dark", "Dark")
tools_menu = mb.addMenu("Tools")
self.logging_level_action = tools_menu.addAction("Logging Levels")
self.logging_level_action.triggered.connect(
self.on_logging_level_menu_action)
timeout_debug_action = tools_menu.addAction("Simulate API Timeouts")
timeout_debug_action.setCheckable(True)
timeout_debug_action.triggered.connect(
self.on_timeout_debug_action_checkbox)
tools_menu.addAction(timeout_debug_action)
def __init__(self):
loader = QUiLoader()
filePath = os.path.join(os.path.dirname(__file__), 'bug_426.ui')
self.widget = loader.load(filePath)
self.group = QtWidgets.QActionGroup(self.widget)
self.widget.show()
QtCore.QTimer.singleShot(0, self.widget.close)
def __init__(self, *args, **kwargs):
QtWidgets.QMainWindow.__init__(self, *args, **kwargs)
menu_bar = self.menuBar()
store_menu = QtWidgets.QMenu('Store', self)
menu_bar.addMenu(store_menu)
store_root_menu = store_menu.addMenu('Set root')
store_root_profiles_action_group = QtWidgets.QActionGroup(
store_root_menu, exclusive=True)
for name in os.listdir('/nix/var/nix/profiles'):
if name.startswith('system'):
if len(name) == len('system'):
pass
else:
#system_profile_number = name[len('system')+1:]
system_profile_path = os.path.realpath(
'/nix/var/nix/profiles/' + name)
action = QtWidgets.QAction(
'/nix/var/nix/profiles/' + name,
store_root_menu,
checkable=True
) #+(' (current)' if os.path.realpath('/run/current-system') else ''))
profiles.append(system_profile_path)
store_root_menu.addAction(action)
store_root_profiles_action_group.addAction(action)
for username in os.listdir('/nix/var/nix/profiles/per-user'):
for name in os.listdir('/nix/var/nix/profiles/per-user/' +
username):
if name.startswith('profile'):
if len(name) == len('profile'):
pass
else:
#system_profile_number = name[len('profile')+1:]
system_profile_path = os.path.realpath(
'/nix/var/nix/profiles/per-user/' + username +
'/' + name)
profiles.append(system_profile_path)
action = QtWidgets.QAction(
'/nix/var/nix/profiles/per-user/' + username +
'/' + name,
store_root_menu,
checkable=True)
store_root_menu.addAction(action)
store_root_profiles_action_group.addAction(action)
summary_view.profiles = profiles
store_root_profiles_action_group.triggered.connect(
self.store_root_profiles_action__handler)
store_root_path_action = store_root_menu.addAction('Store path...')
store_root_path_action.triggered.connect(
self.store_root_path_action__handler)
central_widget = QtWidgets.QWidget()
central_widget.setLayout(layout_base)
self.setCentralWidget(central_widget)
def build_menus(self, layout):
self.menu_bar = QtWidgets.QMenuBar()
# Palette Size
self.apply_menu = QtWidgets.QMenu("Apply to: ",
None) # type: QtWidgets.QMenu
self.apply_menu.setTearOffEnabled(True)
self.menu_bar.addMenu(self.apply_menu)
self.palette_mode_menu = QtWidgets.QMenu(
"Palette:") # type: QtWidgets.QMenu
self.menu_bar.addMenu(self.palette_mode_menu)
self.util_menu = self.menu_bar.addMenu("Util") # type: QtWidgets.QMenu
# Mode Menu Items
self.palette_mode_grp = QtWidgets.QActionGroup(self.palette_mode_menu)
self.palette_mode_actions = {}
palette_modes = [
PALETTE_MODES.BASIC, PALETTE_MODES.STANDARD,
PALETTE_MODES.ADVANCED, PALETTE_MODES.EXTREME
]
for palette_mode in palette_modes:
action = QtWidgets.QAction(palette_mode.capitalize(), None)
action.setData(palette_mode)
action.setCheckable(True)
self.palette_mode_actions[palette_mode] = action
self.palette_mode_menu.addAction(action)
self.palette_mode_grp.addAction(action)
# Type Menu Actions
self.layer_chkbx = QtWidgets.QAction(APPLY_MODES.LAYER.capitalize(),
None) # type: QtWidgets.QAction
self.layer_chkbx.setCheckable(True)
self.apply_menu.addAction(self.layer_chkbx)
self.object_chkbx = QtWidgets.QAction(APPLY_MODES.OBJECT.capitalize(),
None)
self.object_chkbx.setCheckable(True)
self.apply_menu.addAction(self.object_chkbx)
self.outliner_chkbx = QtWidgets.QAction(
APPLY_MODES.OUTLINER.capitalize(), None)
self.outliner_chkbx.setCheckable(True)
self.apply_menu.addAction(self.outliner_chkbx)
self.clear_menu = QtWidgets.QAction("Clear",
None) # type: QtWidgets.QAction
self.util_menu.addAction(self.clear_menu)
layout.addWidget(self.menu_bar)
def _context_menu_exec(self, pos):
menu = QtWidgets.QMenu()
show_stats_menu = menu.addMenu('&Show statistics')
show_stats_group = QtWidgets.QActionGroup(show_stats_menu)
show_stats_items = []
for txt, v in [['&Top', 'top'], ['&Bottom', 'bottom'], ['&Off',
'off']]:
item = self._construct_stats_item(show_stats_menu, txt, v)
show_stats_group.addAction(item)
show_stats_items.append(item)
marker_remove = menu.addAction('&Remove')
marker_remove.triggered.connect(self._remove)
menu.exec_(pos)
def menu_exec(self, pos):
instances = [] # hold on to QT objects
menu = QtWidgets.QMenu()
menu.setToolTipsVisible(True)
submenus = {}
if self._pair is not None:
plugins = self._cmdp['Plugins/#registered']
for name in plugins.range_tools.keys():
m, subm = menu, submenus
name_parts = name.split('/')
while len(name_parts) > 1:
name_part = name_parts.pop(0)
if name_part not in subm:
subm[name_part] = [m.addMenu(name_part), {}]
m, subm = subm[name_part]
else:
m, subm = subm[name_part]
t = QtWidgets.QAction(name_parts[0], self)
t.triggered.connect(self._range_tool_factory(name))
m.addAction(t)
instances.append(t)
zoom = menu.addAction('&Zoom to fit')
zoom.triggered.connect(self._on_zoom)
show_stats_menu = menu.addMenu('&Show statistics')
show_stats_group = QtWidgets.QActionGroup(show_stats_menu)
left = show_stats_menu.addAction('&Left')
left.setCheckable(True)
left.setChecked(self.statistics_show == 'left')
left.triggered.connect(lambda: self._on_statistics_show('left'))
show_stats_group.addAction(left)
right = show_stats_menu.addAction('&Right')
right.setCheckable(True)
right.setChecked(self.statistics_show == 'right')
right.triggered.connect(lambda: self._on_statistics_show('right'))
show_stats_group.addAction(right)
off = show_stats_menu.addAction('&Off')
off.setCheckable(True)
off.setChecked(self.statistics_show == 'off')
off.triggered.connect(lambda: self._on_statistics_show('off'))
show_stats_group.addAction(off)
marker_remove = menu.addAction('&Remove')
marker_remove.triggered.connect(self._remove)
menu.exec_(pos)
def build(parent, imagesPath, iconSize=25, height=20, marginSize=5):
"""
build widget
@param parent : parent qt layout
@imagesPath : str path
"""
#- Easy Inbetween---------------------------------------------------------------
mainLayout = parent
sliderLayout = QtWidgets.QVBoxLayout()
UIData.labelMode = QtWidgets.QLabel()
UIData.labelMode.setText('Mode : Object')
# ---- menuItem
UIData.labelMode.setContextMenuPolicy(QtCore.Qt.CustomContextMenu)
UIData.labelMode.customContextMenuRequested.connect(popupHandler)
UIData.popupMenu = QtWidgets.QMenu()
ag = QtWidgets.QActionGroup(UIData.labelMode, exclusive=True)
UIData.menuObject = ag.addAction(
QtWidgets.QAction('Object', UIData.popupMenu, checkable=True))
UIData.popupMenu.addAction(UIData.menuObject)
UIData.menuKeyFrame = ag.addAction(
QtWidgets.QAction('Keyframe', UIData.popupMenu, checkable=True))
UIData.popupMenu.addAction(UIData.menuKeyFrame)
UIData.menuLinear = ag.addAction(
QtWidgets.QAction('Keyframe (no overshoot)',
UIData.popupMenu,
checkable=True))
UIData.popupMenu.addAction(UIData.menuLinear)
UIData.slider = BSlider.BSlider(colorEnum="blue",
width=280,
minValue=-7,
maxValue=7,
offsetValue=5,
scaleValue=10.0,
startValue=0,
presetsStep=1,
handleText="EI")
UIData.slider.valueChanged.connect(easyInBetweenChange)
sliderLayout.addWidget(UIData.labelMode)
sliderLayout.addWidget(UIData.slider)
mainLayout.addLayout(sliderLayout)
readEIBMode()
def __init__(self, action_list, middle_action=None, parent=None):
self.action_list = action_list
super(ButtonSelectableAction, self).__init__(
default_action=action_list[0], middle_action=middle_action, parent=parent, context_menu=False)
self.custom_menu = qw.QMenu(parent=self)
self.action_group = qw.QActionGroup(self)
for action in self.action_list:
action.setCheckable(True)
self.custom_menu.addAction(action)
self.action_group.addAction(action)
self.action_list[0].setChecked(True)
self.setContextMenuPolicy(qc.Qt.CustomContextMenu)
self.action_group.triggered[qw.QAction].connect(self.actionTriggered)
def contextMenuEvent(self, event):
menu = self.createStandardContextMenu()
suggestion_group = QtWidgets.QActionGroup(menu)
if self._is_multiple:
if self.choices:
sep = menu.insertSeparator(menu.actions()[0])
fm = menu.fontMetrics()
for suggestion in self.choices:
label = str(suggestion).replace('\n', ' ')
label = fm.elidedText(label, Qt.ElideMiddle, self.width())
action = QtWidgets.QAction(label, suggestion_group)
action.setData(str(suggestion))
menu.insertAction(sep, action)
elif self.spell_check:
cursor = self.cursorForPosition(event.pos())
block_pos = cursor.block().position()
for word, start, end in self.spell_check.find_words(
cursor.block().text()):
if start > cursor.positionInBlock():
break
if end <= cursor.positionInBlock():
continue
cursor.setPosition(block_pos + start)
cursor.setPosition(block_pos + end,
QtGui.QTextCursor.KeepAnchor)
break
suggestions = self.spell_check.suggest(cursor.selectedText())
if suggestions:
sep = menu.insertSeparator(menu.actions()[0])
for suggestion in suggestions:
action = QtWidgets.QAction(suggestion, suggestion_group)
menu.insertAction(sep, action)
action = menu.exec_(event.globalPos())
if action and action.actionGroup() == suggestion_group:
if self._is_multiple:
self.set_value(action.data())
else:
cursor.setPosition(block_pos + start)
cursor.setPosition(block_pos + end,
QtGui.QTextCursor.KeepAnchor)
cursor.insertText(action.iconText())
def build(parent,
imagesPath,
iconSize = 25,
height = 20,
marginSize = 5):
"""
build widget
@param parent : parent qt layout
@imagesPath : str path
"""
#- Reset It---------------------------------------------------------------
mainLayout = parent
iconImagePath = os.path.join(imagesPath, 'mgloc.png').replace('\\', '/')
iconHoverImagePath = os.path.join(imagesPath, 'mgloc_hi.png').replace('\\', '/')
UIData.button = QtWidgets.QPushButton('')
UIData.button.clicked.connect(run)
UIData.button.setToolTip("select object and run, it will craete locator per option")
UIData.button.setStyleSheet(
'''
QPushButton{image:url(%s); border:0px; width:%s; height:%s}
QPushButton:hover{image:url(%s); border:0px;}
QPushButton:pressed { background-color: rgba(0, 255,255, 10);}
''' %(iconImagePath, iconSize, iconSize, iconHoverImagePath)
)
# ---- menuItem
UIData.button.setContextMenuPolicy(QtCore.Qt.CustomContextMenu)
UIData.button.customContextMenuRequested.connect(popupHandler)
UIData.popupMenu = QtWidgets.QMenu()
ag = QtWidgets.QActionGroup(UIData.button, exclusive=True)
UIData.menuConstraint = ag.addAction(QtWidgets.QAction('Constrain to Object', UIData.popupMenu, checkable=True))
UIData.popupMenu.addAction(UIData.menuConstraint)
UIData.menuBake = ag.addAction(QtWidgets.QAction('Bake', UIData.popupMenu, checkable=True))
UIData.popupMenu.addAction(UIData.menuBake)
UIData.menuDriver = ag.addAction(QtWidgets.QAction('Drive Object', UIData.popupMenu, checkable=True))
UIData.popupMenu.addAction(UIData.menuDriver)
UIData.button.show()
mainLayout.addWidget(UIData.button)
readMGLMode()
def build(parent, imagesPath, iconSize=25, height=20, marginSize=5):
"""
build widget
@param parent : parent qt layout
@imagesPath : str path
"""
#- Decalcomanie---------------------------------------------------------------
mainLayout = parent
iconImagePath = os.path.join(imagesPath,
'decalcomanie.png').replace('\\', '/')
iconHoverImagePath = os.path.join(imagesPath,
'decalcomanie_hi.png').replace(
'\\', '/')
UIData.button = QtWidgets.QPushButton('')
UIData.button.clicked.connect(run)
UIData.button.setToolTip("Copy Left or Right anim to Right or Left")
UIData.button.setStyleSheet('''
QPushButton{image:url(%s); border:0px; width:%s; height:%s}
QPushButton:hover{image:url(%s); border:0px;}
QPushButton:pressed { background-color: rgba(0, 255,255, 10);}
''' % (iconImagePath, iconSize, iconSize, iconHoverImagePath))
# ---- menuItem
UIData.button.setContextMenuPolicy(QtCore.Qt.CustomContextMenu)
UIData.button.customContextMenuRequested.connect(popupHandler)
UIData.popupMenu = QtWidgets.QMenu()
ag = QtWidgets.QActionGroup(UIData.button, exclusive=True)
UIData.menuPose = ag.addAction(
QtWidgets.QAction('Mirror Pose of Current Frame',
UIData.popupMenu,
checkable=True))
UIData.popupMenu.addAction(UIData.menuPose)
UIData.menuAnim = ag.addAction(
QtWidgets.QAction('Mirror Animation', UIData.popupMenu,
checkable=True))
UIData.popupMenu.addAction(UIData.menuAnim)
UIData.button.show()
mainLayout.addWidget(UIData.button)
readDCNMode()
def makePlotMenu(self, name, plots, style_fn):
if len(plots) < 1:
return
menu = QtWidgets.QMenu(name, self.lineStyleMenu)
group = QtWidgets.QActionGroup(menu)
action = QtWidgets.QAction("All", group)
action.triggered.connect(lambda: AllLineStyleDialog(
self, name, self.getCanvas(), plots, style_fn).exec_())
group.addAction(action)
sep = QtWidgets.QAction(group)
sep.setSeparator(True)
group.addAction(sep)
for y in plots:
style = style_fn(y)
action = QtWidgets.QAction(style.label, group)
action.triggered.connect(
lambda yin=y, stylein=style: LineStyleDialog(
self, yin, self.getCanvas(), stylein, style_fn
).exec_())
group.addAction(action)
menu.addActions(group.actions())
self.lineStyleMenu.addMenu(menu)
def add_menubar_items(self, items, parent, level):
if not items:
return
for item in items:
itype = item.get('type', None)
if itype == 'separator':
parent.addSeparator()
continue
if itype == 'menu':
menu = parent.addMenu(item['text'])
if 'items' in item:
self.add_menubar_items(item['items'], menu, level + 1)
continue
if itype == 'radio':
radio = QtWidgets.QActionGroup(self.main, exclusive=True)
for item in item['items']:
action = self.add_action(item, parent)
action.setCheckable(True)
action.setChecked(item['checked'])
radio.addAction(action)
continue
self.add_action(item, parent)
def initUI(self):
grid = QtWidgets.QGridLayout()
#Create actions dictionary and group dictionary
self.atomActionGroup = QtWidgets.QActionGroup(self, exclusive=True)
self.atomActions = {}
#for atomname in self.editor.atomtypes.keys(): Gives unsorted list
for key in self.ptable.keys():
atomname = self.ptable[key]["Symbol"]
action = QtWidgets.QAction( '%s'%atomname,
self,
statusTip="Set atomtype to %s"%atomname,
triggered=self.atomtypePush, objectName=atomname,
checkable=True)
self.atomActionGroup.addAction(action)
self.atomActions[atomname] = action
if action.objectName() == "C":
action.setChecked(True)
button = QtWidgets.QToolButton()
button.setDefaultAction(action)
button.setFocusPolicy(QtCore.Qt.NoFocus)
button.setMaximumWidth(40)
if self.ptable[key]["Group"] != None:
grid.addWidget(button, self.ptable[key]["Period"], self.ptable[key]["Group"])
else:
if key <72:
grid.addWidget(button, 9, key-54)
else:
grid.addWidget(button, 10, key-86)
#Ensure spacing between main table and actinides/lathanides
grid.addWidget(QtWidgets.QLabel(''), 8,1)
self.setLayout(grid)
self.move(300, 150)
self.setWindowTitle('Periodic Table')
def createActions(self):
self.newAction = QtWidgets.QAction(QtGui.QIcon(":/images/new.png"),
self.tr("&New"), self)
self.newAction.setShortcut(self.tr("Ctrl+N"))
self.newAction.setStatusTip(self.tr("Create a new file"))
self.newAction.triggered.connect(self.newFile)
self.openAction = QtWidgets.QAction(QtGui.QIcon(":/images/open.png"),
self.tr("&Open..."), self)
self.openAction.setShortcut(self.tr("Ctrl+O"))
self.openAction.setStatusTip(self.tr("Open an existing file"))
self.openAction.triggered.connect(self.open)
self.saveAction = QtWidgets.QAction(QtGui.QIcon(":/images/save.png"),
self.tr("&Save"), self)
self.saveAction.setShortcut(self.tr("Ctrl+S"))
self.saveAction.setStatusTip(self.tr("Save the file to disk"))
self.saveAction.triggered.connect(self.save)
self.saveAsAction = QtWidgets.QAction(self.tr("Save &As..."), self)
self.saveAsAction.setStatusTip(
self.tr("Save the file under a new name"))
self.saveAsAction.triggered.connect(self.saveAs)
self.exitAction = QtWidgets.QAction(self.tr("E&xit"), self)
self.exitAction.setShortcut(self.tr("Ctrl+Q"))
self.exitAction.setStatusTip(self.tr("Exit the application"))
self.exitAction.triggered.connect(self.close)
self.cutAction = QtWidgets.QAction(QtGui.QIcon(":/images/cut.png"),
self.tr("Cu&t"), self)
self.cutAction.setShortcut(self.tr("Ctrl+X"))
self.cutAction.setStatusTip(
self.tr("Cut the current selection to the clipboard"))
self.cutAction.triggered.connect(self.cut)
self.copyAction = QtWidgets.QAction(QtGui.QIcon(":/images/copy.png"),
self.tr("&Copy"), self)
self.copyAction.setShortcut(self.tr("Ctrl+C"))
self.copyAction.setStatusTip(
self.tr("Copy the current selection to the clipboard"))
self.copyAction.triggered.connect(self.copy)
self.pasteAction = QtWidgets.QAction(QtGui.QIcon(":/images/paste.png"),
self.tr("&Paste"), self)
self.pasteAction.setShortcut(self.tr("Ctrl+V"))
self.pasteAction.setStatusTip(
self.tr("Paste the clipboard's contents at the cursor position"))
self.pasteAction.triggered.connect(self.paste)
self.closeAction = QtWidgets.QAction(self.tr("Cl&ose"), self)
self.closeAction.setShortcut(self.tr("Ctrl+F4"))
self.closeAction.setStatusTip(self.tr("Close the active window"))
self.closeAction.triggered.connect(self.workspace.closeActiveSubWindow)
self.closeAllAction = QtWidgets.QAction(self.tr("Close &All"), self)
self.closeAllAction.setStatusTip(self.tr("Close all the windows"))
self.closeAllAction.triggered.connect(
self.workspace.closeAllSubWindows)
self.tileAction = QtWidgets.QAction(self.tr("&Tile"), self)
self.tileAction.setStatusTip(self.tr("Tile the windows"))
self.tileAction.triggered.connect(self.workspace.tileSubWindows)
self.cascadeAction = QtWidgets.QAction(self.tr("&Cascade"), self)
self.cascadeAction.setStatusTip(self.tr("Cascade the windows"))
self.cascadeAction.triggered.connect(self.workspace.cascadeSubWindows)
self.nextAction = QtWidgets.QAction(self.tr("Ne&xt"), self)
self.nextAction.setShortcut(self.tr("Ctrl+F6"))
self.nextAction.setStatusTip(
self.tr("Move the focus to the next window"))
self.nextAction.triggered.connect(self.workspace.activateNextSubWindow)
self.previousAction = QtWidgets.QAction(self.tr("Pre&vious"), self)
self.previousAction.setShortcut(self.tr("Ctrl+Shift+F6"))
self.previousAction.setStatusTip(
self.tr("Move the focus to the previous window"))
self.previousAction.triggered.connect(
self.workspace.activatePreviousSubWindow)
self.separatorAction = QtWidgets.QAction(self)
self.separatorAction.setSeparator(True)
self.aboutAction = QtWidgets.QAction(self.tr("&About"), self)
self.aboutAction.setStatusTip(
self.tr("Show the application's About box"))
self.aboutAction.triggered.connect(self.about)
self.aboutQtAction = QtWidgets.QAction(self.tr("About &Qt"), self)
self.aboutQtAction.setStatusTip(
self.tr("Show the Qt library's About box"))
self.aboutQtAction.triggered.connect(qApp.aboutQt)
self.windowActionGroup = QtWidgets.QActionGroup(self)
def __init__(self, parent=None):
super(SignalLoggerUI, self).__init__(parent)
self.__init__ui = ui.MainWindow()
self.ui = ui.MainWindow()
self.ui.setupUi(self)
self.tab_re = re.compile('^Plot [0-9]+$')
self.data = {}
self.gridStyles = {
'left': LineStyle(),
'right': LineStyle(linestyle=':')
}
self.gridStyleFile = \
os.path.expanduser("~") + "/.config/signal_logger/grid_style.json"
if os.path.exists(self.gridStyleFile):
with open(self.gridStyleFile) as f:
data = json.load(f)
for k in self.gridStyles.keys():
if k in data:
self.gridStyles[k] = LineStyle(**data[k])
UserPlot.__new__.__defaults__ = (self.gridStyles['left'],
self.gridStyles['right'], {}, {},
GraphLabels(), {})
self.user_plot_file = os.path.expanduser(
"~") + "/.config/signal_logger/custom_plots.json"
self.reload_user_plots()
self.styleMenu = QtWidgets.QMenu("Style", self.ui.menubar)
# Line style menu
self.lineStyleMenu = QtWidgets.QMenu("Lines", self.styleMenu)
def fillLineStyleMenu(self):
self.lineStyleMenu.clear()
canvas = self.getCanvas()
def makePlotMenu(self, name, plots, style_fn):
if len(plots) < 1:
return
menu = QtWidgets.QMenu(name, self.lineStyleMenu)
group = QtWidgets.QActionGroup(menu)
action = QtWidgets.QAction("All", group)
action.triggered.connect(lambda: AllLineStyleDialog(
self, name, self.getCanvas(), plots, style_fn).exec_())
group.addAction(action)
sep = QtWidgets.QAction(group)
sep.setSeparator(True)
group.addAction(sep)
for y in plots:
style = style_fn(y)
action = QtWidgets.QAction(style.label, group)
action.triggered.connect(
lambda yin=y, stylein=style: LineStyleDialog(
self, yin, self.getCanvas(), stylein, style_fn
).exec_())
group.addAction(action)
menu.addActions(group.actions())
self.lineStyleMenu.addMenu(menu)
makePlotMenu(self, "Left", canvas.axes_plots.keys(),
canvas.style_left)
makePlotMenu(self, "Right", canvas.axes2_plots.keys(),
canvas.style_right)
self.lineStyleMenu.aboutToShow.connect(lambda: fillLineStyleMenu(self))
self.styleMenu.addMenu(self.lineStyleMenu)
# Grid style menu
self.gridStyleMenu = QtWidgets.QMenu("Grids", self.styleMenu)
self.gridDisplayActionGroup = QtWidgets.QActionGroup(
self.gridStyleMenu)
self.gridDisplayActionGroup.setExclusive(True)
self.leftGridAction = QtWidgets.QAction("Left",
self.gridDisplayActionGroup)
self.leftGridAction.triggered.connect(
lambda: GridStyleDialog(self, "left", self.getCanvas(),
self.getCanvas().grid).exec_())
self.gridDisplayActionGroup.addAction(self.leftGridAction)
self.rightGridAction = QtWidgets.QAction("Right",
self.gridDisplayActionGroup)
self.rightGridAction.triggered.connect(
lambda: GridStyleDialog(self, "right", self.getCanvas(),
self.getCanvas().grid2).exec_())
self.gridDisplayActionGroup.addAction(self.rightGridAction)
self.gridStyleMenu.addActions(self.gridDisplayActionGroup.actions())
self.styleMenu.addMenu(self.gridStyleMenu)
# Labels
self.titleAction = QtWidgets.QAction("Title, labels and fonts",
self.styleMenu)
self.titleAction.triggered.connect(
lambda: LabelsTitleEditDialog(self, self.getCanvas()).exec_())
self.styleMenu.addAction(self.titleAction)
self.ui.menubar.addMenu(self.styleMenu)
self.addApplicationShortcut(QtCore.Qt.CTRL + QtCore.Qt.Key_O,
self.shortcutOpenFile)
self.addApplicationShortcut(QtCore.Qt.CTRL + QtCore.Qt.Key_W,
self.shortcutCloseTab)
self.addApplicationShortcut(QtCore.Qt.CTRL + QtCore.Qt.Key_PageDown,
self.shortcutNextTab)
self.addApplicationShortcut(QtCore.Qt.CTRL + QtCore.Qt.Key_PageUp,
self.shortcutPreviousTab)
self.addApplicationShortcut(QtCore.Qt.CTRL + QtCore.Qt.Key_T,
self.shortcutNewTab)
self.addApplicationShortcut(QtCore.Qt.CTRL + QtCore.Qt.Key_S,
self.save_user_plot)
self.addApplicationShortcut(QtCore.Qt.CTRL + QtCore.Qt.Key_A,
self.shortcutAxesDialog)
def createActionGroup(parent, action_id, actions):
"""Creates an action group."""
g = QtWidgets.QActionGroup(parent)
for action in actions:
g.addAction(action)
Groups[action_id] = g
def setupUi(self, main_window):
main_window.setObjectName("main_window")
main_window.resize(640, 480)
self.central_widget = QtWidgets.QWidget(main_window)
self.central_widget.setObjectName("central_widget")
self.verticalLayout = QtWidgets.QVBoxLayout(self.central_widget)
self.verticalLayout.setObjectName("verticalLayout")
self.widget = QtWidgets.QWidget(self.central_widget)
self.widget.setObjectName("widget")
self.verticalLayout_2 = QtWidgets.QVBoxLayout(self.widget)
self.verticalLayout_2.setContentsMargins(0, 0, 0, 0)
self.verticalLayout_2.setObjectName("verticalLayout_2")
self.splitter = QtWidgets.QSplitter(self.widget)
self.splitter.setOrientation(QtCore.Qt.Horizontal)
self.splitter.setObjectName("splitter")
self.list_view_stacked = QtWidgets.QStackedWidget(self.splitter)
self.list_view_stacked.setObjectName("list_view_stacked")
self.network_event_list_page = QtWidgets.QWidget()
self.network_event_list_page.setObjectName("network_event_list_page")
self.verticalLayout_3 = QtWidgets.QVBoxLayout(self.network_event_list_page)
self.verticalLayout_3.setSpacing(0)
self.verticalLayout_3.setContentsMargins(0, 0, 0, 0)
self.verticalLayout_3.setObjectName("verticalLayout_3")
self.network_event_list = NetworkEventList(self.network_event_list_page)
sizePolicy = QtWidgets.QSizePolicy(QtWidgets.QSizePolicy.Preferred, QtWidgets.QSizePolicy.Preferred)
sizePolicy.setHorizontalStretch(0)
sizePolicy.setVerticalStretch(0)
sizePolicy.setHeightForWidth(self.network_event_list.sizePolicy().hasHeightForWidth())
self.network_event_list.setSizePolicy(sizePolicy)
self.network_event_list.setSizeAdjustPolicy(QtWidgets.QAbstractScrollArea.AdjustToContents)
self.network_event_list.setRootIsDecorated(False)
self.network_event_list.setUniformRowHeights(True)
self.network_event_list.setItemsExpandable(False)
self.network_event_list.setAllColumnsShowFocus(True)
self.network_event_list.setExpandsOnDoubleClick(False)
self.network_event_list.setObjectName("network_event_list")
self.network_event_list.header().setDefaultSectionSize(35)
self.network_event_list.header().setMinimumSectionSize(20)
self.verticalLayout_3.addWidget(self.network_event_list)
self.list_view_stacked.addWidget(self.network_event_list_page)
self.message_list_page = QtWidgets.QWidget()
self.message_list_page.setObjectName("message_list_page")
self.verticalLayout_4 = QtWidgets.QVBoxLayout(self.message_list_page)
self.verticalLayout_4.setSpacing(0)
self.verticalLayout_4.setContentsMargins(0, 0, 0, 0)
self.verticalLayout_4.setObjectName("verticalLayout_4")
self.message_list = MessageList(self.message_list_page)
self.message_list.setRootIsDecorated(False)
self.message_list.setUniformRowHeights(True)
self.message_list.setItemsExpandable(False)
self.message_list.setAllColumnsShowFocus(True)
self.message_list.setExpandsOnDoubleClick(False)
self.message_list.setObjectName("message_list")
self.message_list.header().setDefaultSectionSize(39)
self.message_list.header().setMinimumSectionSize(20)
self.verticalLayout_4.addWidget(self.message_list)
self.list_view_stacked.addWidget(self.message_list_page)
self.object_tree = ObjectTree(self.splitter)
self.object_tree.setStyleSheet("")
self.object_tree.setUniformRowHeights(True)
self.object_tree.setAnimated(True)
self.object_tree.setAllColumnsShowFocus(True)
self.object_tree.setObjectName("object_tree")
self.hex_viewer = HexViewer(self.splitter)
self.hex_viewer.setMinimumSize(QtCore.QSize(0, 0))
self.hex_viewer.setObjectName("hex_viewer")
self.verticalLayout_2.addWidget(self.splitter)
self.verticalLayout.addWidget(self.widget)
main_window.setCentralWidget(self.central_widget)
self.menubar = QtWidgets.QMenuBar(main_window)
self.menubar.setGeometry(QtCore.QRect(0, 0, 640, 21))
self.menubar.setObjectName("menubar")
self.menu_file = QtWidgets.QMenu(self.menubar)
self.menu_file.setObjectName("menu_file")
self.menuView = QtWidgets.QMenu(self.menubar)
self.menuView.setObjectName("menuView")
main_window.setMenuBar(self.menubar)
self.statusbar = QtWidgets.QStatusBar(main_window)
self.statusbar.setObjectName("statusbar")
main_window.setStatusBar(self.statusbar)
self.action_open = QtWidgets.QAction(main_window)
self.action_open.setObjectName("action_open")
self.list_view_selector = QtWidgets.QActionGroup(main_window)
self.list_view_selector.setObjectName("list_view_selector")
self.action_view_network_event_list = QtWidgets.QAction(self.list_view_selector)
self.action_view_network_event_list.setCheckable(True)
self.action_view_network_event_list.setChecked(True)
self.action_view_network_event_list.setObjectName("action_view_network_event_list")
self.action_view_message_list = QtWidgets.QAction(self.list_view_selector)
self.action_view_message_list.setCheckable(True)
self.action_view_message_list.setObjectName("action_view_message_list")
self.menu_file.addAction(self.action_open)
self.menuView.addAction(self.action_view_network_event_list)
self.menuView.addAction(self.action_view_message_list)
self.menubar.addAction(self.menu_file.menuAction())
self.menubar.addAction(self.menuView.menuAction())
self.retranslateUi(main_window)
self.list_view_stacked.setCurrentIndex(0)
QtCore.QMetaObject.connectSlotsByName(main_window)
def __init__(self, parent=None):
# Initialise the UI
self.display = None
super(MainWindow, self).__init__(parent)
self.ui = Ui_MainWindow()
self.ui.setupUi(self)
# Current file
self._filename = None
self._filetype = None
self._last_file_handler = None
# Importers / Exporters
self._file_handlers = []
# Update our window caption
self._caption = "Zoxel"
# Our global state + user plugins
if platform.system() == "Windows":
appdata = os.path.expandvars("%APPDATA%")
elif platform.system() == "Darwin":
appdata = os.path.expanduser("~/Library/Application Support")
else:
appdata = os.path.expanduser("~/.local/share")
self.user_plugins_path = os.path.join(appdata, "Zoxel", "plugins")
if not os.path.isdir(self.user_plugins_path):
os.makedirs(self.user_plugins_path, 16877)
QtCore.QCoreApplication.setOrganizationName("Zoxel")
QtCore.QCoreApplication.setApplicationName("Zoxel")
QtCore.QSettings.setDefaultFormat(QtCore.QSettings.IniFormat)
QtCore.QSettings.setPath(QtCore.QSettings.IniFormat,
QtCore.QSettings.UserScope, appdata)
self.settings = QtCore.QSettings()
self.state = {}
# Our animation timer
self._timer = QtCore.QTimer(self)
self.connect(self._timer, QtCore.SIGNAL("timeout()"),
self.on_animation_tick)
self._anim_speed = 200
# Load our state if possible
self.load_state()
# Create our GL Widget
try:
glw = GLWidget(self.ui.glparent)
self.ui.glparent.layout().addWidget(glw)
self.display = glw
except Exception as E:
QtWidgets.QMessageBox.warning(self, "Initialisation Failed",
str(E))
exit(1)
# Load default model dimensions
width = self.get_setting("default_model_width")
height = self.get_setting("default_model_height")
depth = self.get_setting("default_model_depth")
if width:
self.resize_voxels(width, height, depth)
# Resize is detected as a change, discard changes
self.display.voxels.saved()
# Create our palette widget
voxels = PaletteWidget(self.ui.palette,
RGBvalue=self.ui.paletteRGBvalue)
self.ui.palette.layout().addWidget(voxels)
self.color_palette = voxels
# More UI state
value = self.get_setting("display_axis_grids")
if value is not None:
self.ui.action_axis_grids.setChecked(value)
self.display.axis_grids = value
value = self.get_setting("background_color")
if value is not None:
self.display.background = QtGui.QColor.fromRgb(*value)
value = self.get_setting("voxel_edges")
if value is not None:
self.display.voxel_edges = value
self.ui.action_voxel_edges.setChecked(value)
else:
self.ui.action_voxel_edges.setChecked(self.display.voxel_edges)
value = self.get_setting("occlusion")
if value is None:
value = True
self.display.voxels.occlusion = value
self.ui.action_occlusion.setChecked(value)
# Connect some signals
if self.display:
self.display.voxels.notify = self.on_data_changed
self.display.mouse_click_event.connect(self.on_tool_mouse_click)
self.display.start_drag_event.connect(self.on_tool_drag_start)
self.display.end_drag_event.connect(self.on_tool_drag_end)
self.display.drag_event.connect(self.on_tool_drag)
if self.color_palette:
self.color_palette.changed.connect(self.on_color_changed)
# Initialise our tools
self._tool_group = QtWidgets.QActionGroup(self.ui.toolbar_drawing)
self._tools = []
self._tools_priorities = {}
# Setup window
self.update_caption()
self.refresh_actions()
self.display.ready = True
# Update Check
try:
latest_tag = urllib.urlopen(
"https://github.com/chrmoritz/zoxel/releases/latest").geturl()
if not latest_tag.endswith(ZOXEL_TAG):
responce = QtWidgets.QMessageBox.question(
self,
"Outdated Zoxel version",
"A new version of Zoxel is available! Do you want to update now?",
buttons=(QtWidgets.QMessageBox.Yes
| QtWidgets.QMessageBox.No),
defaultButton=QtWidgets.QMessageBox.Yes)
if responce == QtWidgets.QMessageBox.Yes:
webbrowser.open(latest_tag, 2)
sys.exit(0)
except IOError:
pass
def CreateActions(self):
self.openAction = QAction(QIcon(self.pixmappath + 'open.png'),
'O&pen',
self,
shortcut=QKeySequence.Open,
statusTip="Open an existing file",
triggered=self.openFile)
self.saveAction = QAction(QIcon(self.pixmappath + '/icons8-Save.png'),
'S&ave',
self,
shortcut=QKeySequence.Open,
statusTip="Save file",
triggered=self.saveFile)
self.saveAsAction = QAction(QIcon(self.pixmappath +
'icons8-Save as.png'),
'S&ave As',
self,
shortcut=QKeySequence.Open,
statusTip="Save file as ..",
triggered=self.saveAsFile)
self.exitAction = QAction(QIcon(self.pixmappath +
'icons8-Shutdown.png'),
'E&xit',
self,
shortcut="Ctrl+Q",
statusTip="Exit the Application",
triggered=self.exitFile)
self.aboutAction = QAction(QIcon(self.pixmappath + 'about.png'),
'A&bout',
self,
statusTip="Displays info about text editor",
triggered=self.aboutHelp)
self.aboutQtAction = QAction(
"About &Qt",
self,
statusTip="Show the Qt library's About box",
triggered=QApplication.aboutQt)
self.openPtableAction = QAction(
QIcon(self.pixmappath + 'ptable.png'),
'O&pen Periodic Table',
self,
shortcut=QKeySequence.Open,
statusTip="Open the periodic table for atom type selection",
triggered=self.openPtable)
#Edit actions
self.actionActionGroup = QtWidgets.QActionGroup(self, exclusive=True)
self.selectAction = QAction(QIcon(self.pixmappath +
'icons8-Cursor.png'),
'S&elect',
self,
shortcut="Ctrl+S",
statusTip="Select Atoms",
triggered=self.setAction,
objectName="Select",
checkable=True)
self.actionActionGroup.addAction(self.selectAction)
self.addAction = QAction(QIcon(self.pixmappath + 'icons8-Edit.png'),
'A&dd',
self,
shortcut="Ctrl+A",
statusTip="Add Atoms",
triggered=self.setAction,
objectName="Add",
checkable=True)
self.actionActionGroup.addAction(self.addAction)
self.addBondAction = QAction(QIcon(self.pixmappath +
'icons8-Pinch.png'),
'Add B&ond',
self,
shortcut="Ctrl+B",
statusTip="Add Bond",
triggered=self.setAction,
objectName="Add Bond",
checkable=True)
self.actionActionGroup.addAction(self.addBondAction)
self.replaceAction = QAction(QIcon(self.pixmappath +
'icons8-Replace Atom.png'),
'R&eplace',
self,
shortcut="Ctrl+R",
statusTip="Replace Atom/Bond",
triggered=self.setAction,
objectName="Replace",
checkable=True)
self.actionActionGroup.addAction(self.replaceAction)
self.rsAction = QAction(QIcon(self.pixmappath + 'Change_R_S.png'),
'T&oggle R/S',
self,
shortcut="Ctrl+o",
statusTip="Toggle Stereo Chemistry",
triggered=self.setAction,
objectName="RStoggle",
checkable=True)
self.actionActionGroup.addAction(self.rsAction)
self.ezAction = QAction(QIcon(self.pixmappath + 'Change_E_Z.png'),
'Toggle &E/Z',
self,
shortcut="Ctrl+E",
statusTip="Toggle Bond Stereo Chemistry",
triggered=self.setAction,
objectName="EZtoggle",
checkable=True)
self.actionActionGroup.addAction(self.ezAction)
self.removeAction = QAction(QIcon(self.pixmappath +
'icons8-Cancel.png'),
'D&elete',
self,
shortcut="Ctrl+D",
statusTip="Delete Atom or Bond",
triggered=self.setAction,
objectName="Remove",
checkable=True)
self.actionActionGroup.addAction(self.removeAction)
self.increaseChargeAction = QAction(QIcon(self.pixmappath +
'icons8-Increase Font.png'),
'I&ncrease Charge',
self,
shortcut="Ctrl++",
statusTip="Increase Atom Charge",
triggered=self.setAction,
objectName="Increase Charge",
checkable=True)
self.actionActionGroup.addAction(self.increaseChargeAction)
self.decreaseChargeAction = QAction(QIcon(self.pixmappath +
'icons8-Decrease Font.png'),
'D&ecrease Charge',
self,
shortcut="Ctrl+-",
statusTip="Decrease Atom Charge",
triggered=self.setAction,
objectName="Decrease Charge",
checkable=True)
self.actionActionGroup.addAction(self.decreaseChargeAction)
self.addAction.setChecked(True)
#BondTypeActions
self.bondtypeActionGroup = QtWidgets.QActionGroup(self, exclusive=True)
self.singleBondAction = QAction(QIcon(self.pixmappath +
'icons8-Single.png'),
'S&ingle Bond',
self,
shortcut="Ctrl+S",
statusTip="Set bondtype to SINGLE",
triggered=self.setBondType,
objectName="SINGLE",
checkable=True)
self.bondtypeActionGroup.addAction(self.singleBondAction)
self.doubleBondAction = QAction(QIcon(self.pixmappath +
'icons8-Double.png'),
'Double Bond',
self,
shortcut="Ctrl+S",
statusTip="Set bondtype to DOUBLE",
triggered=self.setBondType,
objectName="DOUBLE",
checkable=True)
self.bondtypeActionGroup.addAction(self.doubleBondAction)
self.tripleBondAction = QAction(QIcon(self.pixmappath +
'icons8-Triple.png'),
'Triple Bond',
self,
shortcut="Ctrl+S",
statusTip="Set bondtype to TRIPLE",
triggered=self.setBondType,
objectName="TRIPLE",
checkable=True)
self.bondtypeActionGroup.addAction(self.tripleBondAction)
self.singleBondAction.setChecked(True)
#Build dictionary of ALL available bondtypes in RDKit
self.bondActions = {}
for key in self.editor.bondtypes.keys():
action = QAction('%s' % key,
self,
statusTip="Set bondtype to %s" % key,
triggered=self.setBondType,
objectName=key,
checkable=True)
self.bondtypeActionGroup.addAction(action)
self.bondActions[key] = action
#Replace defined actions
self.bondActions["SINGLE"] = self.singleBondAction
self.bondActions["DOUBLE"] = self.doubleBondAction
self.bondActions["TRIPLE"] = self.tripleBondAction
#Misc Actions
self.undoAction = QAction(QIcon(self.pixmappath + 'prev.png'),
'U&ndo',
self,
shortcut="Ctrl+U",
statusTip="Undo/Redo changes to molecule",
triggered=self.editor.undo,
objectName="undo")
self.clearCanvasAction = QAction(QIcon(self.pixmappath +
'icons8-Trash.png'),
'C&lear Canvas',
self,
shortcut="Ctrl+X",
statusTip="Clear Canvas (no warning)",
triggered=self.clearCanvas,
objectName="Clear Canvas")
#Atom Actions in actiongroup, reuse from ptable widget
self.atomActions = []
for atomname in [
"H", "B", "C", "N", "O", "F", "P", "S", "Cl", "Br", "I"
]:
action = self.ptable.atomActions[atomname]
if action.objectName() == "C":
action.setChecked(True)
self.atomActions.append(action)
self.loglevelactions = {}
for key in self.loglevels:
self.loglevelactions[key] = QAction(
key,
self,
statusTip="Set logging level to %s" % key,
triggered=self.setLogLevel,
objectName="loglevel:%s" % key)
def createMenuBar(self):
# create Action
def menuItem(name, func , parent, **kws):
newAction = QtWidgets.QAction(name, self)
if 'checkable' in kws:
newAction.setCheckable(kws['checkable'])
if 'checked' in kws:
# if kws['checked'].isdigit():
# newAction.setChecked(bool(int(kws['checked'])))
if 'value' in kws and kws['value'] != 'isCheck':
newAction.setChecked(kws['checked'] == kws['value'])
else:
newAction.setChecked(kws['checked'])
if 'value' in kws:
def emitValue():
if kws['value'] == 'isCheck':
# print newAction.isChecked()
func(newAction.isChecked())
return
func(kws['value'])
newAction.triggered.connect(emitValue)
else:
newAction.triggered.connect(func)
if parent:
parent.addAction(newAction)
return newAction
self.reset_action = QtWidgets.QAction('Reset', self)
self.reset_action.setToolTip('Reset UI To Default Value')
self.reset_action.setStatusTip('Reset UI To Default Value')
self.reset_action.triggered.connect(self.resetUI)
# create Menu
self.menubar = self.menuBar()
self.optionmenu = self.menubar.addMenu('Option')
self.optionmenu.addAction(self.reset_action)
self.optionmenu.addSeparator().setText('Connect Action')
# self.toggleConnectThroughLocAction = menuItem(
# 'Create Control for Childrens', partial(setUIValue, 'controlmaker_createForHie'), self.optionmenu, value ='isCheck',
# checkable=True, checked=getUIValue('controlmaker_createForHie'))
self.toggleConnectThroughLocAction = menuItem(
'Connect Through Loc', partial(setUIValue, 'controlmaker_connectUseLoc'), self.optionmenu, value ='isCheck',
checkable=True, checked=getUIValue('controlmaker_connectUseLoc'))
self.connectTypeGroup = QtWidgets.QActionGroup(self)
self.toggleConnectTranslateAction = menuItem(
'Connect Translate', partial(setUIValue, 'controlmaker_connectType'), self.connectTypeGroup, value='translate',
checkable=True, checked=getUIValue('controlmaker_connectType'))
self.toggleConnectRotateAction = menuItem(
'Connect Rotate', partial(setUIValue, 'controlmaker_connectType'), self.connectTypeGroup, value='rotate',
checkable=True, checked=getUIValue('controlmaker_connectType'))
self.toggleConnectAllAction = menuItem(
'Connect All', partial(setUIValue, 'controlmaker_connectType'), self.connectTypeGroup, value='all',
checkable=True, checked=getUIValue('controlmaker_connectType'))
self.togglePoConstraintAction = menuItem(
'Point Constraint', partial(setUIValue, 'controlmaker_connectType'), self.connectTypeGroup, value='point',
checkable=True, checked=getUIValue('controlmaker_connectType'))
self.toggleOConstraintAction = menuItem(
'Orient Constraint', partial(setUIValue, 'controlmaker_connectType'), self.connectTypeGroup, value='orient',
checkable=True, checked=getUIValue('controlmaker_connectType'))
self.togglePConstraintAction = menuItem(
'Parent Constraint', partial(setUIValue, 'controlmaker_connectType'), self.connectTypeGroup, value='parent',
checkable=True, checked=getUIValue('controlmaker_connectType'))
self.toggleConnectAction = menuItem(
'None', partial(setUIValue, 'controlmaker_connectType'), self.connectTypeGroup, value=0,
checkable=True, checked=getUIValue('controlmaker_connectType'))
# self.toggleConnectAction.setChecked(True)
self.optionmenu.addAction(self.toggleConnectTranslateAction)
self.optionmenu.addAction(self.toggleConnectRotateAction)
self.optionmenu.addAction(self.toggleConnectAllAction)
self.optionmenu.addAction(self.togglePoConstraintAction)
self.optionmenu.addAction(self.toggleOConstraintAction)
self.optionmenu.addAction(self.togglePConstraintAction)
self.optionmenu.addAction(self.toggleConnectAction)
self.toggleCreateSelectOffset = menuItem(
'Create Select Offset', partial(setUIValue, 'controlmaker_createSelOffset') , self.optionmenu, value ='isCheck',
checkable=True, checked=getUIValue('controlmaker_createSelOffset'))
self.toggleTakeObjectName = menuItem(
'Use Object Name', partial(setUIValue, 'controlmaker_useObjectName') , self.optionmenu, value ='isCheck',
checkable=True, checked=getUIValue('controlmaker_useObjectName'))
self.optionmenu.addSeparator().setText('Other Action')
self.toggleCreateOffset = menuItem(
'Create Control Offset', partial(setUIValue, 'controlmaker_createCtlOffset') , self.optionmenu, value ='isCheck',
checkable=True, checked=getUIValue('controlmaker_createCtlOffset'))
self.toggleParent = menuItem(
'Create Parent Chain', partial(setUIValue, 'controlmaker_createChain') , self.optionmenu, value ='isCheck',
checkable=True, checked=getUIValue('controlmaker_createChain'))
def editorMenu(self) -> None:
fileMenu = self.menuBar().addMenu("&File")
# Set up new RSI
newAction = fileMenu.addAction("&New")
newAction.setShortcut(QtG.QKeySequence.New)
newAction.triggered.connect(self.newRsi)
# Set up file opening
openAction = fileMenu.addAction("&Open")
openAction.setIcon(
QtG.QIcon.fromTheme(
"document-open",
self.style().standardIcon(QtW.QStyle.SP_DialogOpenButton)))
openAction.setShortcut(QtG.QKeySequence.Open)
openAction.triggered.connect(self.openRsi)
# Set up file saving
saveAction = fileMenu.addAction("&Save")
saveAction.setIcon(
QtG.QIcon.fromTheme(
"document-save",
self.style().standardIcon(QtW.QStyle.SP_DialogSaveButton)))
saveAction.setShortcut(QtG.QKeySequence.Save)
saveAction.triggered.connect(self.saveRsi)
saveAsAction = fileMenu.addAction("Save As")
saveAsAction.setShortcut(QtG.QKeySequence.SaveAs)
saveAsAction.triggered.connect(self.saveAsRsi)
fileMenu.addSeparator()
importAction = fileMenu.addAction("&Import")
importAction.triggered.connect(self.importDmi)
fileMenu.addSeparator()
# TODO: Set up preferences
preferencesAction = fileMenu.addAction("Preferences")
preferencesAction.setShortcut(QtG.QKeySequence.Preferences)
preferencesAction.triggered.connect(self.editConfig)
editMenu = self.menuBar().addMenu("&Edit")
# Undo
undoAction = editMenu.addAction("&Undo")
undoAction.setIcon(
QtG.QIcon.fromTheme(
"edit-undo",
self.style().standardIcon(QtW.QStyle.SP_ArrowLeft)))
undoAction.setShortcut(QtG.QKeySequence.Undo)
undoAction.triggered.connect(self.undoStack.undo)
# Redo
redoAction = editMenu.addAction("&Redo")
redoAction.setIcon(
QtG.QIcon.fromTheme(
"edit-redo",
self.style().standardIcon(QtW.QStyle.SP_ArrowRight)))
redoAction.setShortcut(QtG.QKeySequence.Redo)
redoAction.triggered.connect(self.undoStack.redo)
# Undo history
undoMenu = editMenu.addMenu("Undo history")
undoHistory = QtW.QUndoView(parent=undoMenu)
undoHistory.setStack(self.undoStack)
undoAction = QtW.QWidgetAction(undoMenu)
undoAction.setDefaultWidget(undoHistory)
undoMenu.addAction(undoAction)
editMenu.addSeparator()
self.directionGroup = QtW.QActionGroup(editMenu)
for direction in [1, 4, 8]:
action = self.directionGroup.addAction(
f'{direction} direction{"s" if direction > 1 else ""}')
action.setData(direction)
editMenu.addAction(action)
self.directionGroup.setEnabled(False)
self.directionGroup.triggered.connect(
lambda action: self.undoStack.push(
SetDirectionsCommand(self, action.data())))
def initMenu(self):
menu = self.menuBar()
# menu.resize(100,20)
task = menu.addMenu(u'任务')
addtask = task.addAction(u'添加任务')
addtask.setToolTip(u'添加一个新的下载任务')
addtask.setShortcut(QtCore.Qt.CTRL | QtCore.Qt.Key_N)
addtask.triggered.connect(self.add)
deltask = task.addAction(u'删除任务')
deltask.setToolTip(u'删除一个已存在的任务')
deltask.setShortcut(QtCore.Qt.CTRL | QtCore.Qt.Key_D)
deltask.triggered.connect(self.delete)
task.addSeparator()
starttask = task.addAction(u'开始任务')
starttask.setToolTip(u'启动一个未完成的任务')
starttask.setShortcut(QtCore.Qt.CTRL | QtCore.Qt.Key_S)
starttask.triggered.connect(self.start)
pasuetask = task.addAction(u'暂停任务')
pasuetask.setToolTip(u'暂停一个未完成的任务')
pasuetask.setShortcut(QtCore.Qt.CTRL | QtCore.Qt.Key_P)
pasuetask.triggered.connect(self.pasue)
display = menu.addMenu(u'查看')
displaygroup = QtWidgets.QActionGroup(display)
discomplate = display.addAction(u'已完成')
discomplate.setCheckable(True)
discomplate.setToolTip(u'显示已完成任务列表')
discomplate.setShortcut(QtCore.Qt.CTRL | QtCore.Qt.Key_C)
discomplate.setData(True)
disrun = display.addAction(u'未完成',
checkable=True,
checked=True,
data=False)
disrun.setCheckable(True)
disrun.setChecked(True)
disrun.setToolTip(u'显示正在进行任务列表')
disrun.setShortcut(QtCore.Qt.CTRL | QtCore.Qt.Key_R)
disrun.setData(False)
display.addAction(disrun)
display.addAction(discomplate)
displaygroup.addAction(disrun)
displaygroup.addAction(discomplate)
# displaygroup.setExclusive(True)
displaygroup.triggered.connect(self.switchState)
#另一种QAction方法
display.addSeparator()
debug = display.addMenu('Debug')
debuggroup = QtWidgets.QActionGroup(debug)
self.debugon = QtWidgets.QAction('On',
debug,
checkable=True,
data=True)
self.debugoff = QtWidgets.QAction('Off',
debug,
checkable=True,
checked=True,
data=False)
debug.addAction(self.debugon)
debug.addAction(self.debugoff)
debuggroup.addAction(self.debugon)
debuggroup.addAction(self.debugoff)
debuggroup.triggered.connect(self.switchDebug)
option = menu.addMenu(u'设置')
editconn = QtWidgets.QAction(u'设置链接',
option,
StatusTip='设置xware服务器地址和端口')
editconn.setShortcut(QtCore.Qt.CTRL | QtCore.Qt.Key_O)
editconn.triggered.connect(self.setConn)
option.addAction(editconn)
def __buildWidgets(self):
"""
Create the widgets.
"""
self.__main = QtWidgets.QMainWindow()
self.__main.setWindowTitle('Centipede')
self.__main.resize(1080, 720)
self.__main.setWindowIcon(
QtGui.QIcon(self.__uiResource("icons/centipede.png"))
)
centralWidget = QtWidgets.QWidget()
self.__main.setCentralWidget(centralWidget)
centralWidget.setLayout(QtWidgets.QVBoxLayout())
treeArea = QtWidgets.QSplitter()
sourceLayout = QtWidgets.QVBoxLayout()
sourceBarLayout = QtWidgets.QHBoxLayout()
self.__sourcePath = QtWidgets.QLineEdit()
self.__sourcePath.setReadOnly(True)
self.__sourceDirButton = QtWidgets.QPushButton()
self.__sourceDirButton.setToolTip('Selects a source directory')
self.__sourceDirButton.setIcon(
QtGui.QIcon(self.__uiResource("icons/folder.png"))
)
# refresh
self.__sourceRefreshButton = QtWidgets.QPushButton()
self.__sourceRefreshButton.setToolTip('Refreshes the source directory')
self.__sourceRefreshButton.setVisible(False)
self.__sourceRefreshButton.setIcon(
self.__sourceRefreshButton.style().standardIcon(QtWidgets.QStyle.SP_BrowserReload)
)
# view mode
self.__sourceViewModeButton = QtWidgets.QPushButton("View Mode")
self.__sourceViewModeButton.setToolTip('Changes the view mode')
self.__sourceViewModeButton.setIcon(
QtGui.QIcon(self.__uiResource("icons/viewMode.png"))
)
self.__sourceViewModeMenu = QtWidgets.QMenu(self.__sourceViewModeButton)
self.__sourceViewModeButton.setMenu(self.__sourceViewModeMenu)
# filter
self.__sourceFilterButton = QtWidgets.QPushButton("Filter View")
self.__sourceFilterButton.setToolTip('Filters out specific crawler types')
self.__sourceFilterButton.setIcon(
QtGui.QIcon(self.__uiResource("icons/filterView.png"))
)
self.__sourceFilterMenu = QtWidgets.QMenu(self.__sourceFilterButton)
self.__sourceFilterButton.setMenu(self.__sourceFilterMenu)
self.__sourceDirButton.clicked.connect(self.__onSelectSourceDir)
self.__sourceRefreshButton.clicked.connect(self.__onRefreshSourceDir)
self.__sourcePath.textChanged.connect(self.updateSource)
sourceBarLayout.addWidget(self.__sourceDirButton)
sourceBarLayout.addWidget(self.__sourcePath)
sourceBarLayout.addWidget(self.__sourceRefreshButton)
sourceBarLayout.addWidget(self.__sourceViewModeButton)
sourceBarLayout.addWidget(self.__sourceFilterButton)
sourceLayout.addLayout(sourceBarLayout)
self.__sourceAreaWidget = QtWidgets.QWidget()
self.__sourceAreaWidget.setLayout(sourceLayout)
targetLayout = QtWidgets.QVBoxLayout()
self.__nextButton = QtWidgets.QPushButton("Next")
self.__nextButton.setIcon(
QtGui.QIcon(self.__uiResource("icons/next.png"))
)
self.__nextButton.clicked.connect(self.updateTarget)
self.__backButton = QtWidgets.QPushButton("Back")
self.__backButton.setIcon(
QtGui.QIcon(self.__uiResource("icons/back.png"))
)
self.__backButton.setVisible(False)
self.__backButton.clicked.connect(self.__onBack)
self.__targetAreaWidget = QtWidgets.QWidget()
self.__targetAreaWidget.setVisible(False)
self.__targetAreaWidget.setLayout(targetLayout)
self.__runOnTheFarmCheckbox = QtWidgets.QCheckBox("Run on the farm")
if self.__runOnTheFarm and self.__runOnTheFarm.lower() in ["true", "1"]:
self.__runOnTheFarmCheckbox.setChecked(True)
self.__runOnTheFarmCheckbox.setVisible(False)
targetBarLayout = QtWidgets.QHBoxLayout()
targetLayout.addLayout(targetBarLayout)
treeArea.addWidget(self.__sourceAreaWidget)
treeArea.addWidget(self.__targetAreaWidget)
self.__sourceTree = self.__treeWidget(["Source"])
self.__sourceTree.itemChanged.connect(self.__onSourceTreeItemCheckedChanged)
self.__sourceTree.customContextMenuRequested.connect(self.__onSourceTreeContextMenu)
self.__targetTree = self.__treeWidget(["Target"])
self.__targetTree.customContextMenuRequested.connect(self.__onTargetTreeContextMenu)
sourceLayout.addWidget(self.__sourceTree)
targetLayout.addWidget(self.__targetTree)
# header
headerLayout = QtWidgets.QHBoxLayout()
centralWidget.layout().addLayout(headerLayout)
logo = QtWidgets.QLabel()
logo.setPixmap(QtGui.QPixmap(self.__uiResource("icons/header.png")).scaledToHeight(64, QtCore.Qt.SmoothTransformation))
logo.setSizePolicy(QtWidgets.QSizePolicy.Fixed, QtWidgets.QSizePolicy.Fixed)
headerLayout.addWidget(
logo
)
headerLayout.addStretch()
centralWidget.layout().addWidget(treeArea)
buttonLayout = QtWidgets.QHBoxLayout()
centralWidget.layout().addLayout(buttonLayout)
self.__runButton = QtWidgets.QPushButton('Run')
self.__runButton.setVisible(False)
self.__runButton.setToolTip('Performs the tasks')
self.__runButton.setIcon(
QtGui.QIcon(self.__uiResource("icons/run.png"))
)
self.__runButton.clicked.connect(self.__onPerformTasks)
buttonLayout.addWidget(self.__runOnTheFarmCheckbox)
buttonLayout.addStretch()
buttonLayout.addWidget(self.__backButton)
buttonLayout.addWidget(self.__nextButton)
buttonLayout.addWidget(self.__runButton)
self.__main.show()
# updating view mode
self.__viewModeActionGroup = QtWidgets.QActionGroup(self)
self.__checkedViewMode = None
for viewMode in self.__viewModes:
viewAction = self.__sourceViewModeMenu.addAction(viewMode.capitalize())
viewAction.setActionGroup(self.__viewModeActionGroup)
viewAction.setCheckable(True)
viewAction.changed.connect(self.__onChangeView)
if (viewMode == self.__viewModes[0]):
viewAction.setChecked(True)
def __init__(self, parent=None):
super(ImageView, self).__init__(parent)
# OpenGL rendering window
self.image_plane = ImagePlane(self)
self.image_plane.setSizePolicy(
QtWidgets.QSizePolicy(QtWidgets.QSizePolicy.Expanding,
QtWidgets.QSizePolicy.Expanding))
# Top menu bar
self.file_menu = QtWidgets.QMenu("File")
self.file_menu.addAction("Load image...", self.load_image,
QtCore.Qt.CTRL + QtCore.Qt.Key_L)
self.file_menu.addAction("Exit", self.close)
self.color_menu = QtWidgets.QMenu("Color")
self.input_cs_menu = self.color_menu.addMenu("Input color space")
self.input_cs_action_group = QtWidgets.QActionGroup(self)
self.input_cs_action_group.setExclusive(True)
self.display_menu = self.color_menu.addMenu("Display")
self.display_action_group = QtWidgets.QActionGroup(self)
self.display_action_group.setExclusive(True)
self.menu_bar = QtWidgets.QMenuBar()
self.menu_bar.addMenu(self.file_menu)
self.menu_bar.addMenu(self.color_menu)
self.view_label = QtWidgets.QLabel("View")
self.view_box = QtWidgets.QComboBox()
self.exposure_label = QtWidgets.QLabel("Exposure")
self.exposure_spinbox = QtWidgets.QDoubleSpinBox()
self.exposure_spinbox.setRange(-6.0, 6.0)
self.exposure_spinbox.setValue(self.image_plane.exposure())
self.gamma_label = QtWidgets.QLabel("Gamma")
self.gamma_spinbox = QtWidgets.QDoubleSpinBox()
self.gamma_spinbox.setRange(0.0, 4.0)
self.gamma_spinbox.setValue(self.image_plane.gamma())
color_management_layout = QtWidgets.QHBoxLayout()
color_management_layout.setContentsMargins(7, 5, 7, 5)
color_management_layout.setSpacing(5)
color_management_layout.addWidget(self.view_label)
color_management_layout.addWidget(self.view_box)
color_management_layout.addStretch()
color_management_layout.addWidget(self.exposure_label)
color_management_layout.addWidget(self.exposure_spinbox)
color_management_layout.addWidget(self.gamma_label)
color_management_layout.addWidget(self.gamma_spinbox)
# Main layout
layout = QtWidgets.QVBoxLayout()
layout.setContentsMargins(0, 0, 0, 0)
layout.setSpacing(0)
layout.addWidget(self.menu_bar)
layout.addLayout(color_management_layout)
layout.addWidget(self.image_plane)
self.setLayout(layout)
# Connect signals/slots
self.input_cs_action_group.triggered.connect(
self._on_input_colorspace_changed)
self.display_action_group.triggered.connect(self._on_display_changed)
self.view_box.currentIndexChanged[str].connect(self._on_view_changed)
self.exposure_spinbox.valueChanged.connect(self._on_exposure_changed)
self.gamma_spinbox.valueChanged.connect(self._on_gamma_changed)
# Init GUI
self._init_ocio()
self.resize(QtCore.QSize(1280, 720))
def build(parent, imagesPath, iconSize=25, height=20, marginSize=5):
"""
build widget
@param parent : parent qt layout
@imagesPath : str path
"""
#- Lockdown---------------------------------------------------------------
mainLayout = parent
layout = QtWidgets.QHBoxLayout()
layout.setAlignment(QtCore.Qt.AlignCenter)
#---- button reverse
iconImagePath = os.path.join(imagesPath,
'lockdown_reverse.png').replace('\\', '/')
iconHoverImagePath = os.path.join(imagesPath,
'lockdown_reverse_hi.png').replace(
'\\', '/')
buttonLeft = QtWidgets.QPushButton('')
buttonLeft.clicked.connect(partial(run, 'reverse'))
buttonLeft.setToolTip("lock reverse")
buttonLeft.setStyleSheet('''
QPushButton{image:url(%s); border:0px; width:%s; height:%s}
QPushButton:hover{image:url(%s); border:0px;}
QPushButton:pressed { background-color: rgba(0, 255,255, 10);}
''' % (iconImagePath, iconSize, iconSize, iconHoverImagePath))
buttonLeft.show()
#---- textfield
UIData.qLineEditLockdown = QtWidgets.QLineEdit()
UIData.qLineEditLockdown.setFixedWidth(30)
UIData.qLineEditLockdown.setSizePolicy(QtWidgets.QSizePolicy.Minimum,
QtWidgets.QSizePolicy.Minimum)
UIData.qLineEditLockdown.setText("3")
UIData.qLineEditLockdown.setAlignment(QtCore.Qt.AlignCenter)
UIData.qLineEditLockdown.setToolTip('shifting amount, integer is expected')
UIData.qLineEditLockdown.setStyleSheet('''
QLineEdit { background-color: #333333; }
''')
# ---- menuItem
UIData.qLineEditLockdown.setContextMenuPolicy(QtCore.Qt.CustomContextMenu)
UIData.qLineEditLockdown.customContextMenuRequested.connect(popupHandler)
UIData.popupMenu = QtWidgets.QMenu()
ag = QtWidgets.QActionGroup(UIData.qLineEditLockdown, exclusive=True)
UIData.menuTr = ag.addAction(
QtWidgets.QAction('Translate Only', UIData.popupMenu, checkable=True))
UIData.popupMenu.addAction(UIData.menuTr)
UIData.menuRo = ag.addAction(
QtWidgets.QAction('Rotate Only', UIData.popupMenu, checkable=True))
UIData.popupMenu.addAction(UIData.menuRo)
UIData.menuBo = ag.addAction(
QtWidgets.QAction('Both', UIData.popupMenu, checkable=True))
UIData.popupMenu.addAction(UIData.menuBo)
UIData.popupMenu.addSeparator()
UIData.popupReset = UIData.popupMenu.addAction("clear key")
#---- button forward
iconImagePath = os.path.join(imagesPath,
'lockdown_forward.png').replace('\\', '/')
iconHoverImagePath = os.path.join(imagesPath,
'lockdown_forward_hi.png').replace(
'\\', '/')
buttonRight = QtWidgets.QPushButton('')
buttonRight.clicked.connect(partial(run, 'forward'))
buttonRight.setToolTip("lock forward")
buttonRight.setStyleSheet('''
QPushButton{image:url(%s); border:0px; width:%s; height:%s}
QPushButton:hover{image:url(%s); border:0px;}
QPushButton:pressed { background-color: rgba(0, 255,255, 10);}
''' % (iconImagePath, iconSize, iconSize, iconHoverImagePath))
buttonRight.show()
layout.addWidget(buttonLeft)
layout.addWidget(UIData.qLineEditLockdown)
layout.addWidget(buttonRight)
mainLayout.addLayout(layout)
readLDNMode()
def __init__(self, parent=None):
super(MainWindow, self).__init__(parent)
self.setupUi(self)
self.actiongrp_thumbs_size = QtWidgets.QActionGroup(self)
self.actiongrp_thumbs_size.addAction(self.action_small_thumbs)
self.actiongrp_thumbs_size.addAction(self.action_normal_thumbs)
self.actiongrp_thumbs_caption = QtWidgets.QActionGroup(self)
self.actiongrp_thumbs_caption.addAction(self.action_caption_none)
self.actiongrp_thumbs_caption.addAction(self.action_caption_filename)
self.action_caption_none.setChecked(True)
# threads
self._dir_watcher_thread = QThread()
self._img_loader_thread = QThread()
# helpers
self._meta_files_mgr = MetaFilesManager()
self._meta_files_mgr.connect()
self._watch = Watcher()
self._img_loader = ImageLoader()
self.listView_thumbs = ThumbsListView(self.frame_thumbs)
self.listView_thumbs.setFrameShape(QtWidgets.QFrame.NoFrame)
self.vlayout_frame_thumbs.addWidget(self.listView_thumbs)
# connections
self._setup_connections()
# Populates the folder list
self._setup_scan_dir_list_model()
# Properties widget
self.vlayout_properties = QtWidgets.QVBoxLayout(
self.toolbox_metadata_properties)
self.vlayout_properties.setContentsMargins(0, 0, 0, 0)
self.vlayout_properties.setSpacing(0)
self.properties_widget = PropertiesWidget(
self.toolbox_metadata_properties)
self.vlayout_properties.addWidget(self.properties_widget)
self.statusBar().showMessage("Ready")
# settings
self.hslider_thumb_size.setValue(
settings.get(SettingType.UI_THUMBS_SIZE, 128, 'int'))
thumb_caption_type = settings.get(
SettingType.UI_THUMBS_CAPTION_DISPLAY_MODE,
Thumb_Caption_Type.NoCaption.name)
if thumb_caption_type == Thumb_Caption_Type.FileName.name:
self.action_caption_filename.setChecked(True)
if settings.get(SettingType.UI_METADATA_SHOW_PROPS, False, 'bool'):
self.toolBox_metadata.setCurrentIndex(0)
self.toolbutton_properties.setChecked(True)
self.toolbutton_tags.setChecked(False)
self.action_properties.setChecked(True)
self.action_tags.setChecked(False)
self.frame_metadata.show()
elif settings.get(SettingType.UI_METADATA_SHOW_TAGS, False, 'bool'):
self.toolBox_metadata.setCurrentIndex(1)
self.toolbutton_properties.setChecked(False)
self.toolbutton_tags.setChecked(True)
self.action_properties.setChecked(False)
self.action_tags.setChecked(True)
self.frame_metadata.show()
else:
self.frame_metadata.hide()
# Set event filters
self.btn_slideshow.installEventFilter(self)
self._curr_img_serial = 1
def createActionGroup(parent, id, actions):
g = QtWidgets.QActionGroup(parent)
for action in actions:
g.addAction(action)
Groups[id] = g
