def setupInterface(self, main):
# Dock widget
action = QAction("Sample Python Plugin", main)
action.setCheckable(True)
widget = FortuneWidget(main, action)
main.addPluginDockWidget(widget, action)
# Dissassembly context menu
menu = main.getContextMenuExtensions(
cutter.MainWindow.ContextMenuType.Disassembly)
self.disas_action = menu.addAction(
"CutterSamplePlugin dissassembly action")
self.disas_action.triggered.connect(self.handle_disassembler_action)
self.main = main
# Context menu for tables with addressable items like Flags,Functions,Strings,Search results,...
addressable_item_menu = main.getContextMenuExtensions(
cutter.MainWindow.ContextMenuType.Addressable)
self.addr_submenu = addressable_item_menu.addMenu(
"CutterSamplePlugin") # create submenu
adrr_action = self.addr_submenu.addAction("Action 1")
self.addr_submenu.addSeparator(
) # can use separator and other qt functionality
adrr_action2 = self.addr_submenu.addAction("Action 2")
adrr_action.triggered.connect(self.handle_addressable_item_action)
adrr_action2.triggered.connect(self.handle_addressable_item_action)
def setupInterface(self, main):
action = QAction("JIR2 String Decoder", main)
action.setCheckable(False)
action.triggered.connect(self.decodeAll)
pluginsMenu = main.getMenuByType(main.MenuType.Plugins)
pluginsMenu.addAction(action)
def add_menu_density(self, parent, menu):
""""""
self.menu_density_ = menu
action_group = QActionGroup(menu)
try:
action_group.setExclusive(True)
except:
action_group.exclusive = True
for density in map(str, range(-3, 4)):
action = QAction(parent)
# action.triggered.connect(self._wrapper(parent, density, self.extra_values, self.update_buttons))
action.triggered.connect(lambda: self.update_theme_event(parent))
try:
action.setText(density)
action.setCheckable(True)
action.setChecked(density == '0')
action.setActionGroup(action_group)
menu.addAction(action)
action_group.addAction(action)
except: # snake_case, true_property
action.text = density
action.checkable = True
action.checked = density == '0'
action.action_group = action_group
menu.add_action(action)
action_group.add_action(action)
def get_synchronize_with_submenu(self) -> QMenu:
"""
Get submenu for 'Synchronize with' context menu.
"""
mnu = QMenu("&Synchronize with", self)
groups = {
v.sync_state
for v in self.workspace.view_manager.views
if (v is not self) and isinstance(v, SynchronizedView)
}
if len(groups) == 0:
act = QAction('None available', self)
act.setEnabled(False)
mnu.addAction(act)
else:
for group in groups:
act = QAction(
', '.join(
[v.caption for v in group.views if v is not self]),
self)
act.setCheckable(True)
act.setChecked(group is self.sync_state)
act.toggled.connect(
lambda checked, s=group: self.sync_with_state_object(
s if checked else None))
mnu.addAction(act)
return mnu
def init_toolbar(self):
for button in self.tag_button_group.buttons():
self.tag_button_group.removeButton(button)
for action in self.actions:
self.removeAction(action)
action = QAction("untagged")
self.insertAction(self.empty_action, action)
action.setCheckable(True)
button = self.widgetForAction(action)
self.tag_button_group.addButton(button, id=0)
self.actions = [action]
self.db_map_ids = [[(db_map, 0) for db_map in self.db_maps]]
tag_data = {}
for db_map in self.db_maps:
for parameter_tag in self.db_mngr.get_items(db_map, "parameter tag"):
tag_data.setdefault(parameter_tag["tag"], {})[db_map] = parameter_tag["id"]
for tag, db_map_data in tag_data.items():
action = QAction(tag)
self.insertAction(self.empty_action, action)
action.setCheckable(True)
button = self.widgetForAction(action)
self.tag_button_group.addButton(button, id=len(self.db_map_ids))
self.actions.append(action)
self.db_map_ids.append(list(db_map_data.items()))
self.tag_button_group.buttonToggled["int", "bool"].connect(
lambda i, checked: self.tag_button_toggled.emit(self.db_map_ids[i], checked)
)
def add_menu_theme(self, parent, menu):
""""""
self.menu_theme_ = menu
action_group = QActionGroup(menu)
try:
action_group.setExclusive(True)
except:
action_group.exclusive = True
for i, theme in enumerate(['default'] + list_themes()):
action = QAction(parent)
# action.triggered.connect(self._wrapper(parent, theme, self.extra_values, self.update_buttons))
action.triggered.connect(lambda: self.update_theme_event(parent))
try:
action.setText(theme)
action.setCheckable(True)
action.setChecked(not bool(i))
action.setActionGroup(action_group)
menu.addAction(action)
action_group.addAction(action)
except: # snake_case, true_property
action.text = theme
action.checkable = True
action.checked = not bool(i)
action.action_group = action_group
menu.add_action(action)
action_group.add_action(action)
def __init__(self):
super().__init__()
self.setWindowTitle("My App")
label = QLabel("Hello!")
label.setAlignment(Qt.AlignCenter)
self.setCentralWidget(label)
toolbar = QToolBar("My main toolbar")
toolbar.setIconSize(QSize(16, 16))
self.addToolBar(toolbar)
button_action = QAction(QIcon("bug.png"), "Your button", self)
button_action.setStatusTip("This is your button")
button_action.triggered.connect(self.onMyToolBarButtonClick)
button_action.setCheckable(True)
toolbar.addAction(button_action)
toolbar.addSeparator()
button_action2 = QAction(QIcon("bug.png"), "Your button2", self)
button_action2.setStatusTip("This is your button2")
button_action2.triggered.connect(self.onMyToolBarButtonClick)
button_action2.setCheckable(True)
toolbar.addAction(button_action2)
toolbar.addWidget(QLabel("Hello"))
toolbar.addWidget(QCheckBox())
self.setStatusBar(QStatusBar(self))
def __init__(self):
self.ctrlcv = ControlCV()
QMainWindow.__init__(self)
self.setWindowFlags(Qt.WindowStaysOnTopHint
| Qt.WindowMinimizeButtonHint
| Qt.WindowCloseButtonHint
| Qt.MSWindowsFixedSizeDialogHint)
self.setWindowTitle("ClipBoard")
self.menu = self.menuBar()
self.file_menu = self.menu.addMenu("File")
self.action_menu = self.menu.addMenu("Action")
exit_action = QAction("Exit", self)
exit_action.setShortcut("Ctrl+Q")
exit_action.triggered.connect(self.exit_app)
self.file_menu.addAction(exit_action)
load_action = QAction("Load", self)
load_action.triggered.connect(self.load_from_file)
self.file_menu.addAction(load_action)
switch_action = QAction("Switch", self)
switch_action.setCheckable(True)
switch_action.triggered.connect(self.switch_window)
self.action_menu.addAction(switch_action)
resize_action = QAction("Resize", self)
resize_action.setCheckable(True)
resize_action.triggered.connect(self.resize_window)
self.action_menu.addAction(resize_action)
main_widget = QWidget()
layout = QGridLayout()
main_widget.setLayout(layout)
self.clip_panel = [QLabel('') for i in range(9)]
for i in range(9):
self.clip_panel[i].setText('')
self.clip_panel[i].setStyleSheet("border:0.51px solid grey;")
layout.addWidget(self.clip_panel[i], int(i / 3), i % 3, 1, 1)
self.setCentralWidget(main_widget)
def create_scene_action(self, scene_name: str, is_active: bool):
s = QAction(IconRsc.get_icon('document'), scene_name, self.action_grp)
s.setCheckable(True)
s.setChecked(is_active)
s.triggered.connect(self._toggle_scene)
self.addAction(s)
def register_menu_command(self, cmd):
menu_path = cmd.menu.split("/")
menu = self._ensure_menu(menu_path)
label = cmd.item_label
if cmd.item_shortcut:
label += "\t%s" % cmd.item_shortcut
item = QAction(label, self._key_capturer)
item.setShortcutContext(Qt.WidgetShortcut)
# We must add a separate action to the menu, otherwise the shortcut is being triggered even when the menubar is focused.
menu_action = menu.addAction(label)
self._key_capturer.addAction(item)
item.triggered.connect(cmd)
menu_action.triggered.connect(cmd)
item.setCheckable(cmd.checkable)
menu_action.setCheckable(cmd.checkable)
if cmd.item_shortcut:
seq = QKeySequence(cmd.item_shortcut)
item.setShortcut(seq)
if cmd.item_name:
self._menu_items_by_name[cmd.item_name] = menu_action
if cmd.checkable:
item.toggled.connect(
lambda checked, mi=menu_action: safe_set_checked(mi, checked))
menu_action.toggled.connect(
lambda checked, si=item: safe_set_checked(si, checked))
def __init__(self):
super().__init__()
widget = QWidget()
self.setCentralWidget(widget)
menubar = self.menuBar()
menu = menubar.addMenu("&Menu") # "&"" allows short cut access "alt+M"
action_text = QAction("텍스트", self)
menu.addAction(action_text)
action_text.setCheckable(True)
menu.addSeparator()
submenu = menu.addMenu("submenu")
action_icon = QAction(QIcon("icon.png"), "아이콘", self)
submenu.addAction(action_icon)
action_icon.triggered.connect(self.on_click)
action_icon.setCheckable(True)
self.setStatusBar(QStatusBar(self))
action_text.setStatusTip("액션_텍스트")
action_icon.setStatusTip("액션_아이콘")
def create_action(self, icon, name, short_cut, checkable=False):
"""Create an action an return"""
action = QAction(QIcon('./media/{}'.format(icon)), name, self._window)
action.setShortcut(short_cut)
action.setCheckable(checkable)
action.setToolTip(name)
return action
class Profiling(ProfilingService):
"""
GUI part of the nexxT profiling service.
"""
def __init__(self):
super().__init__()
srv = Services.getService("MainWindow")
profMenu = srv.menuBar().addMenu("Pr&ofiling")
self.loadDockWidget = srv.newDockWidget("Load", None,
Qt.BottomDockWidgetArea)
self.loadDisplay = LoadDisplayWidget(self.loadDockWidget)
self.loadDockWidget.setWidget(self.loadDisplay)
self.loadDataUpdated.connect(self.loadDisplay.newLoadData)
self.threadDeregistered.connect(self.loadDisplay.removeThread)
self.spanDockWidget = srv.newDockWidget("Profiling", None,
Qt.BottomDockWidgetArea)
self.spanDisplay = SpanDisplayWidget(self.spanDockWidget)
self.spanDockWidget.setWidget(self.spanDisplay)
self.spanDataUpdated.connect(self.spanDisplay.newSpanData)
self.threadDeregistered.connect(self.spanDisplay.removeThread)
self.actLoadEnabled = QAction("Enable Load Monitor")
self.actLoadEnabled.setCheckable(True)
self.actLoadEnabled.setChecked(True)
self.actLoadEnabled.toggled.connect(self.setLoadMonitorEnabled)
self.actProfEnabled = QAction("Enable Port Profiling")
self.actProfEnabled.setCheckable(True)
self.actProfEnabled.setChecked(False)
self.actProfEnabled.toggled.connect(self.setPortProfilingEnabled)
self.setLoadMonitorEnabled(True)
self.setPortProfilingEnabled(False)
profMenu.addAction(self.actLoadEnabled)
profMenu.addAction(self.actProfEnabled)
def setLoadMonitorEnabled(self, enabled):
"""
called when the corresponding QAction is toggled
:param enabled: boolean
:return:
"""
self.actProfEnabled.setEnabled(enabled)
super().setLoadMonitorEnabled(enabled)
def setPortProfilingEnabled(self, enabled):
"""
called when the corresponding QAction is toggled
:param enabled: boolean
:return:
"""
self.actLoadEnabled.setEnabled(not enabled)
super().setPortProfilingEnabled(enabled)
def __init__(self):
super().__init__()
srv = Services.getService("MainWindow")
self.dockWidget = srv.newDockWidget(
"Log",
parent=None,
defaultArea=Qt.BottomDockWidgetArea,
allowedArea=Qt.LeftDockWidgetArea | Qt.BottomDockWidgetArea)
self.logWidget = LogView()
self.dockWidget.setWidget(self.logWidget)
logMenu = srv.menuBar().addMenu("&Log")
mainLogger = logging.getLogger()
self.handler = LogHandler(self.logWidget)
mainLogger.addHandler(self.handler)
self.logWidget.destroyed.connect(
lambda: mainLogger.removeHandler(self.handler))
self.actFollow = QAction("Follow")
self.actFollow.setCheckable(True)
self.actFollow.setChecked(True)
self.actClear = QAction("Clear")
self.actSingleLine = QAction("Single Line")
self.actSingleLine.setCheckable(True)
self.actSingleLine.setChecked(True)
self.logWidget.setUniformRowHeights(True)
self.actFollow.toggled.connect(self.logWidget.setFollow)
self.actClear.triggered.connect(self.logWidget.clear)
self.actSingleLine.toggled.connect(self.logWidget.setUniformRowHeights)
self.actDisable = QAction("Disable")
self.actDisable.triggered.connect(self.setLogLevel)
self.actGroup = QActionGroup(self)
self.actGroup.setExclusive(True)
levelno = mainLogger.level
self.loglevelMap = {}
for lv in ["INTERNAL", "DEBUG", "INFO", "WARNING", "ERROR"]:
a = QAction(lv[:1] + lv[1:].lower())
a.setCheckable(True)
loglevel = getattr(logging, lv)
self.loglevelMap[a] = loglevel
setattr(self, "setLogLevel_" + lv, self.setLogLevel)
a.triggered.connect(getattr(self, "setLogLevel_" + lv))
self.actGroup.addAction(a)
if levelno == loglevel:
a.setChecked(True)
else:
a.setChecked(False)
logMenu.addAction(a)
self.loglevelMap[self.actDisable] = 100
logMenu.addAction(self.actDisable)
logMenu.addSeparator()
logMenu.addAction(self.actClear)
logMenu.addAction(self.actFollow)
logMenu.addAction(self.actSingleLine)
def translate_element(menu, entry, index=None):
if index is None:
before = None
else:
try:
before = menu.actions()[index]
except IndexError:
before = None
if entry is None:
entry = MenuSeparator()
elif type(entry) is tuple and len(entry) == 2 and callable(entry[1]):
entry = MenuEntry(*entry)
elif type(entry) is tuple and len(entry) == 2 and hasattr(
entry[1], '__iter__'):
entry = Menu(*entry)
if isinstance(entry, MenuEntry):
action = QAction(entry.caption)
action.triggered.connect(entry.action)
entry.qaction = action
if entry.shortcut is not None:
action.setShortcut(entry.shortcut)
if entry.checkable:
action.setCheckable(True)
action.setChecked(entry.checked_initially)
if not entry.default_enabled:
action.setDisabled(True)
if before is None:
menu.addAction(action)
else:
menu.insertAction(before, action)
elif isinstance(entry, MenuSeparator):
if before is None:
menu.addSeparator()
else:
menu.insertSeparator(before)
elif isinstance(entry, Menu):
if before is None:
menu.addMenu(entry.qmenu())
else:
menu.insertMenu(before, entry.qmenu())
elif isinstance(entry, QMenu):
if before is None:
menu.addMenu(entry)
else:
menu.insertMenu(before, entry)
elif isinstance(entry, QAction):
if before is None:
menu.addAction(entry)
else:
menu.insertAction(before, entry)
else:
raise TypeError('Unsupported type', type(entry))
def __initialize_views(self, options, central):
# Create docks view and main widget
valid_options = [(View.graph, "Graph"), (View.tree, "Tree"),
(View.osg, "3D"), (View.scene, "2D")]
# Creation of docks and mainwidget
for widget_type, widget_name in valid_options:
if widget_type == central and central != View.none:
viewer = self.__create_widget(widget_type)
self.window.setCentralWidget(viewer)
widget_c = WidgetContainer()
widget_c.widget = viewer
widget_c.name = widget_name
widget_c.type = widget_type
self.widgets[widget_name] = widget_c
self.widgets_by_type[widget_type] = widget_c
self.main_widget = viewer
elif options & widget_type:
viewer = self.__create_widget(widget_type)
widget_c = WidgetContainer()
widget_c.widget = viewer
widget_c.name = widget_name
widget_c.type = widget_type
self.widgets[widget_name] = widget_c
self.widgets_by_type[widget_type] = widget_c
self.__create_dock_and_menu(widget_name, viewer)
if View.graph in self.widgets_by_type:
new_action = QAction("Animation", self)
new_action.setStatusTip("Toggle animation")
new_action.setCheckable(True)
new_action.setChecked(False)
self.forces_menu.addAction(new_action)
new_action.triggered.connect(lambda: self.widgets_by_type[
View.graph].widget.toggle_animation(True))
# Tabification of current docks
previous = None
for dock_name, dock_widget in self.docks.items():
if previous:
self.window.tabifyDockWidget(previous, dock_widget)
previous = dock_widget
# Connection of tree to graph signals
if "Tree" in self.docks:
if self.main_widget:
graph_widget = self.main_widget
if graph_widget:
tree_widget = self.docks["Tree"].widget()
tree_widget.node_check_state_changed_signal.connect(
lambda node_id: graph_widget.hide_show_node_SLOT(
node_id, 2))
if len(self.docks) > 0 or central != None:
self.window.show()
else:
self.window.showMinimized()
def _init_toolbar(self):
super(MPLNavigationToolbar, self)._init_toolbar()
self.addSeparator()
a = QAction('MEAS')
a.setShortcut(QtCore.Qt.CTRL + QtCore.Qt.Key_A)
self.insertAction(self._actions['zoom'], a)
self._actions['measure'] = a
a.setToolTip('Measure time difference')
a.setCheckable(True)
a.triggered.connect(self.measure)
a.setIcon(QIcon('Resources\\measure.png'))
def _registerWindow(self, window, nameChangedSignal):
act = QAction("<unnamed>", self)
act.setCheckable(True)
act.toggled.connect(window.setVisible)
window.visibleChanged.connect(act.setChecked)
nameChangedSignal.connect(act.setText)
self.windows[shiboken2.getCppPointer(window)[0]] = act # pylint: disable=no-member
self.menu.addAction(act)
logger.debug("Registering window %s, new len=%d",
shiboken2.getCppPointer(window), len(self.windows)) # pylint: disable=no-member
window.destroyed.connect(self._windowDestroyed)
def setupInterface(self, main):
# Create a new action (menu item)
action = QAction("APT32 Graph Deobfuscator", main)
action.setCheckable(False)
# Connect the action to a function - cleaner.
# A click on this action will trigger the function
action.triggered.connect(self.cleaner)
# Add the action to the "Windows -> Plugins" menu
pluginsMenu = main.getMenuByType(main.MenuType.Plugins)
pluginsMenu.addAction(action)
def setupInterface(self, main):
print("[9] inside setupInterface")
if self.widget is None:
action = QAction("IPyCutter", main)
action.setCheckable(True)
self.widget = cutter_qtconsole.IPythonConsole(
self.kernel.connection_file, main, action)
self.widget.create()
main.addPluginDockWidget(self.widget, action)
self.widget.show()
def __init__(self):
super().__init__()
self.setWindowTitle("My App")
label = QLabel("Hello!")
# The `Qt` namespace has a lot of attributes to customize
# widgets. See: http://doc.qt.io/qt-5/qt.html
label.setAlignment(Qt.AlignCenter)
# Set the central widget of the Window. Widget will expand
# to take up all the space in the window by default.
self.setCentralWidget(label)
toolbar = QToolBar("My main toolbar")
toolbar.setIconSize(QSize(16, 16))
self.addToolBar(toolbar)
button_action = QAction(QIcon("bug.png"), "&Your button", self)
button_action.setStatusTip("This is your button")
button_action.triggered.connect(self.onMyToolBarButtonClick)
button_action.setCheckable(True)
# You can enter keyboard shortcuts using key names (e.g. Ctrl+p)
# Qt.namespace identifiers (e.g. Qt.CTRL + Qt.Key_P)
# or system agnostic identifiers (e.g. QKeySequence.Print)
button_action.setShortcut(QKeySequence("Ctrl+p"))
toolbar.addAction(button_action)
toolbar.addSeparator()
button_action2 = QAction(QIcon("bug.png"), "Your &button2", self)
button_action2.setStatusTip("This is your button2")
button_action2.triggered.connect(self.onMyToolBarButtonClick)
button_action2.setCheckable(True)
toolbar.addAction(button_action)
toolbar.addWidget(QLabel("Hello"))
toolbar.addWidget(QCheckBox())
self.setStatusBar(QStatusBar(self))
menu = self.menuBar()
file_menu = menu.addMenu("&File")
file_menu.addAction(button_action)
file_menu.addSeparator()
file_submenu = file_menu.addMenu("Submenu")
file_submenu.addAction(button_action2)
def createLanguageMenu(self):
langPath = self.own_path + "languages" + os.sep
langDirectory = QDir(langPath)
for language_file in langDirectory.entryList(['*.qm']):
language_code = language_file.split('.')[0]
language = QLocale.languageToString(QLocale(language_code).language())
language_icon = QIcon(langPath + language_code + '.png')
action = QAction(language_icon, language, self)
action.setCheckable(True)
action.setData(language_code)
self.menuLanguage.addAction(action)
self.langGroup.addAction(action)
class LanguageMenu(QMenu):
def __init__(self, ui: QMainWindow):
super(LanguageMenu, self).__init__(_("Sprache"), ui)
self.ui = ui
self.en, self.de = QAction(), QAction()
self.setup()
def setup(self):
self.en = QAction('English [en]', self)
self.en.setCheckable(True)
en_call = ConnectCall('en',
target=self.change_language,
parent=self.en)
self.en.triggered.connect(en_call.call)
self.de = QAction('Deutsch [de]', self)
self.de.setCheckable(True)
de_call = ConnectCall('de',
target=self.change_language,
parent=self.de)
self.de.triggered.connect(de_call.call)
self.addActions([self.de, self.en])
self.aboutToShow.connect(self.update_menu)
def change_language(self, l: str):
if AppSettings.language == l:
return
if 'de' == l:
title = 'Sprache auswählen'
msg = 'Die Anwendung muss neu gestartet werden um die Sprache auf Deutsch zu aendern.<br>' \
'Bitte File > Exit waehlen und Anwendung anschließend erneut starten.'
else:
title = 'Change Language'
msg = 'The Application needs to be restarted to change the language to English.<br>' \
'Please choose Datei > Beenden to exit and then start the application again.'
AppSettings.language = l
msg_box = GenericMsgBox(self.ui, title, msg)
msg_box.exec()
def update_menu(self):
self.de.setChecked(False)
self.en.setChecked(False)
if AppSettings.language.casefold() == 'de':
self.de.setChecked(True)
elif AppSettings.language.casefold() == 'en':
self.en.setChecked(True)
def make_display_rule_action(display_rule,
group: Optional[QActionGroup] = None
) -> QAction:
def make_check_closure():
def closure():
display_rule.value = action.isChecked()
return closure
action = QAction(f"&{display_rule.menu_text}", group)
action.setCheckable(True)
action.setChecked(display_rule.value)
action.toggled.connect(make_check_closure())
return action
class ChartTools(QWidget):
def __init__(self, chm, algManager, parent=None):
QWidget.__init__(self, parent)
self.mainLay = QVBoxLayout(self)
self.scrollLay = QFormLayout(self)
self.mainLay.addLayout(self.scrollLay)
self.scrollStepChooser = chm.createScrollStepChooser()
self.scrollLay.addRow('Scroll Step', self.scrollStepChooser)
viewRangeChooser = chm.createViewRangeChooser()
self.scrollLay.addRow('View Range', viewRangeChooser)
self.chartTimer = QTimer()
self.chartTimer.timeout.connect(chm.getChart().scrollForward)
options = {'x1' : 1000,
'x2' : 500,
'x4' : 250,
'x8' : 125}
self.updateChooser = Chooser(options)
self.updateChooser.setCurrentText('x1')
self.chartTimer.setInterval(self.updateChooser.getCurrentValue())
self.updateChooser.currentValueChanged.connect(self.chartTimer.setInterval)
self.scrollLay.addRow('Updates Per Sec', self.updateChooser)
self.startBtn = QPushButton('Run')
self.startBtn.setCheckable(True)
self.a = QAction('SCROLL')
self.startBtn.addAction(self.a)
self.a.setShortcut(QtCore.Qt.CTRL + QtCore.Qt.Key_Space)
self.a.setCheckable(True)
self.a.triggered.connect(self.startBtn.toggle)
self.startBtn.toggled.connect(self.setAutoscroller)
self.scrollLay.addRow(self.startBtn)
chartSelector = chm.createSelector(algManager)
self.mainLay.addWidget(chartSelector)
def setAutoscroller(self, newState):
if newState:
self.chartTimer.start()
self.startBtn.setText('Stop')
else:
self.chartTimer.stop()
self.startBtn.setText('Run')
def __init__(self, mainWin=None):
"""
@param mainWin: should be the app main window
@type mainWin: QMainWindow
"""
self.mainWin = mainWin
# init form
self.initWins()
actionSub = QAction('Show SubFolders', None)
actionSub.setCheckable(True)
actionSub.setChecked(False)
actionSub.triggered.connect(lambda checked=False, action=actionSub: self.hSubfolders(action)) # named arg checked is always sent
self.actionSub = actionSub
# init context menu
self.initCMenu()
def _add_db_map_tag_actions(self, db_map, parameter_tags):
action_texts = [a.text() for a in self.actions]
for parameter_tag in parameter_tags:
if parameter_tag["tag"] in action_texts:
# Already a tag named after that, add db_map id information
i = action_texts.index(parameter_tag["tag"])
self.db_map_ids[i].append((db_map, parameter_tag["id"]))
else:
action = QAction(parameter_tag["tag"])
self.insertAction(self.empty_action, action)
action.setCheckable(True)
button = self.widgetForAction(action)
self.tag_button_group.addButton(button, id=len(self.db_map_ids))
self.actions.append(action)
self.db_map_ids.append([(db_map, parameter_tag["id"])])
action_texts.append(action.text())
def __initialize_file_menu(self):
file_menu = self.window.menuBar().addMenu(self.window.tr("&File"))
file_submenu = file_menu.addMenu("Save")
save_action = QAction("Save", self)
file_submenu.addAction(save_action)
rgbd = QAction("RGBD", self)
rgbd.setCheckable(True)
rgbd.setChecked(False)
file_submenu.addAction(rgbd)
laser = QAction("Laser", self)
laser.setCheckable(True)
laser.setChecked(False)
file_submenu.addAction(laser)
# save_action
save_action.triggered.connect(
lambda: self.__save_json_file(rgbd, laser))
def __add_project_to_menu(self, project: "Project"):
"""Creates a new entry for the passed project. Clicking on the project will make
it the active project on the project manager."""
project_action = QAction(project.name, self)
project_action.setCheckable(True)
index = self.__project_manager.projects.index(project)
project_action.triggered.connect(
lambda _=False, index=index: self.__project_manager.
set_active_project(index))
self.__projects_actions_group.addAction(project_action)
self.addAction(project_action)
LOGGER.debug("Created ProjectMenu Action (Index %s): %s", index,
project_action)
class SettingsMenu(QMenu):
def __init__(self, ui):
super(SettingsMenu, self).__init__(_('Einstellungen'), ui)
self.ui = ui
check_icon = IconRsc.get_icon('check_box_empty')
check_icon.addPixmap(IconRsc.get_pixmap('check_box'), QIcon.Normal,
QIcon.On)
self.open_action = QAction(
check_icon, _('PSD Datei nach dem Erstellen automatisch öffnen'),
self)
self.open_action.setCheckable(True)
self.open_action.setChecked(AppSettings.app['open_editor'])
self.open_action.toggled.connect(self.toggle_psd_open_action)
self.addAction(self.open_action)
self.addSeparator()
img_icon = IconRsc.get_icon('setting')
set_ps_path = QAction(img_icon, _('Erweiterte Einstellungen'), self)
set_ps_path.triggered.connect(self.open_settings_dialog)
self.addAction(set_ps_path)
def toggle_psd_open_action(self):
AppSettings.app['open_editor'] = self.open_action.isChecked()
def update_btn_desc(self):
editor = Path(AppSettings.app['editor_path'])
if editor.exists() and editor.is_file():
self.ui.lastFileBtn.setDescription(
_('Mit benutzerdefiniertem Editor öffnen'))
else:
self.ui.lastFileBtn.setDescription(
_('Mit Standardanwendung öffnen'))
# Update resolution buttons from app settings
self.ui.update_resolution(from_settings=True)
def open_settings_dialog(self):
psd_settings_window = PhotoshopSettings(self.ui)
psd_settings_window.accepted.connect(self.update_btn_desc)
psd_settings_window.rejected.connect(self.update_btn_desc)
psd_settings_window.open()
