class GlobalSysTray(object):
def __init__(self, parent, name, icon):
object.__init__(self)
self._app = None
self._parent = parent
self._gtk_running = False
self._quit_added = False
self.act_indexes = []
self.sep_indexes = []
self.menu_indexes = []
if TrayEngine == "KDE":
self.menu = KMenu(parent)
self.menu.setTitle(name)
self.tray = KStatusNotifierItem()
self.tray.setAssociatedWidget(parent)
self.tray.setCategory(KStatusNotifierItem.ApplicationStatus)
self.tray.setContextMenu(self.menu)
self.tray.setIconByPixmap(getIcon(icon))
self.tray.setTitle(name)
self.tray.setToolTipTitle(" ")
self.tray.setToolTipIconByPixmap(getIcon(icon))
# Double-click is managed by KDE
elif TrayEngine == "AppIndicator":
self.menu = Gtk.Menu()
self.tray = AppIndicator.Indicator.new(name, icon, AppIndicator.IndicatorCategory.APPLICATION_STATUS)
self.tray.set_menu(self.menu)
# Double-click is not possible with App-Indicators
elif TrayEngine == "Qt":
self.menu = QMenu(parent)
self.tray = QSystemTrayIcon(getIcon(icon))
self.tray.setContextMenu(self.menu)
self.tray.setParent(parent)
self.tray.connect(self.tray, SIGNAL("activated(QSystemTrayIcon::ActivationReason)"), self.qt_systray_clicked)
# -------------------------------------------------------------------------------------------
def addAction(self, act_name_id, act_name_string, is_check=False):
if TrayEngine == "KDE":
act_widget = KAction(act_name_string, self.menu)
act_widget.setCheckable(is_check)
self.menu.addAction(act_widget)
elif TrayEngine == "AppIndicator":
if is_check:
act_widget = Gtk.CheckMenuItem(act_name_string)
else:
act_widget = Gtk.ImageMenuItem(act_name_string)
act_widget.set_image(None)
act_widget.show()
self.menu.append(act_widget)
elif TrayEngine == "Qt":
act_widget = QAction(act_name_string, self.menu)
act_widget.setCheckable(is_check)
self.menu.addAction(act_widget)
else:
act_widget = None
act_obj = [None, None, None, None]
act_obj[iActNameId] = act_name_id
act_obj[iActWidget] = act_widget
self.act_indexes.append(act_obj)
def addSeparator(self, sep_name_id):
if TrayEngine == "KDE":
sep_widget = self.menu.addSeparator()
elif TrayEngine == "AppIndicator":
sep_widget = Gtk.SeparatorMenuItem()
sep_widget.show()
self.menu.append(sep_widget)
elif TrayEngine == "Qt":
sep_widget = self.menu.addSeparator()
else:
sep_widget = None
sep_obj = [None, None, None]
sep_obj[iSepNameId] = sep_name_id
sep_obj[iSepWidget] = sep_widget
self.sep_indexes.append(sep_obj)
def addMenu(self, menu_name_id, menu_name_string):
if TrayEngine == "KDE":
menu_widget = KMenu(menu_name_string, self.menu)
self.menu.addMenu(menu_widget)
elif TrayEngine == "AppIndicator":
menu_widget = Gtk.MenuItem(menu_name_string)
menu_parent = Gtk.Menu()
menu_widget.set_submenu(menu_parent)
menu_widget.show()
self.menu.append(menu_widget)
elif TrayEngine == "Qt":
menu_widget = QMenu(menu_name_string, self.menu)
self.menu.addMenu(menu_widget)
else:
menu_widget = None
menu_obj = [None, None, None]
menu_obj[iMenuNameId] = menu_name_id
menu_obj[iMenuWidget] = menu_widget
self.menu_indexes.append(menu_obj)
# -------------------------------------------------------------------------------------------
def addMenuAction(self, menu_name_id, act_name_id, act_name_string, is_check=False):
i = self.get_menu_index(menu_name_id)
if i < 0: return
menu_widget = self.menu_indexes[i][iMenuWidget]
if TrayEngine == "KDE":
act_widget = KAction(act_name_string, menu_widget)
act_widget.setCheckable(is_check)
menu_widget.addAction(act_widget)
elif TrayEngine == "AppIndicator":
menu_widget = menu_widget.get_submenu()
if is_check:
act_widget = Gtk.CheckMenuItem(act_name_string)
else:
act_widget = Gtk.ImageMenuItem(act_name_string)
act_widget.set_image(None)
act_widget.show()
menu_widget.append(act_widget)
elif TrayEngine == "Qt":
act_widget = QAction(act_name_string, menu_widget)
act_widget.setCheckable(is_check)
menu_widget.addAction(act_widget)
else:
act_widget = None
act_obj = [None, None, None, None]
act_obj[iActNameId] = act_name_id
act_obj[iActWidget] = act_widget
act_obj[iActParentMenuId] = menu_name_id
self.act_indexes.append(act_obj)
def addMenuSeparator(self, menu_name_id, sep_name_id):
i = self.get_menu_index(menu_name_id)
if i < 0: return
menu_widget = self.menu_indexes[i][iMenuWidget]
if TrayEngine == "KDE":
sep_widget = menu_widget.addSeparator()
elif TrayEngine == "AppIndicator":
menu_widget = menu_widget.get_submenu()
sep_widget = Gtk.SeparatorMenuItem()
sep_widget.show()
menu_widget.append(sep_widget)
elif TrayEngine == "Qt":
sep_widget = menu_widget.addSeparator()
else:
sep_widget = None
sep_obj = [None, None, None]
sep_obj[iSepNameId] = sep_name_id
sep_obj[iSepWidget] = sep_widget
sep_obj[iSepParentMenuId] = menu_name_id
self.sep_indexes.append(sep_obj)
#def addSubMenu(self, menu_name_id, new_menu_name_id, new_menu_name_string):
#menu_index = self.get_menu_index(menu_name_id)
#if menu_index < 0: return
#menu_widget = self.menu_indexes[menu_index][1]
##if TrayEngine == "KDE":
##new_menu_widget = KMenu(new_menu_name_string, self.menu)
##menu_widget.addMenu(new_menu_widget)
##elif TrayEngine == "AppIndicator":
##new_menu_widget = Gtk.MenuItem(new_menu_name_string)
##new_menu_widget.show()
##menu_widget.get_submenu().append(new_menu_widget)
##parent_menu_widget = Gtk.Menu()
##new_menu_widget.set_submenu(parent_menu_widget)
##else:
#if (1):
#new_menu_widget = QMenu(new_menu_name_string, self.menu)
#menu_widget.addMenu(new_menu_widget)
#self.menu_indexes.append([new_menu_name_id, new_menu_widget, menu_name_id])
# -------------------------------------------------------------------------------------------
def connect(self, act_name_id, act_func):
i = self.get_act_index(act_name_id)
if i < 0: return
act_widget = self.act_indexes[i][iActWidget]
if TrayEngine == "KDE":
self.tray.connect(act_widget, SIGNAL("triggered()"), act_func)
elif TrayEngine == "AppIndicator":
act_widget.connect("activate", self.gtk_call_func, act_name_id)
elif TrayEngine == "Qt":
self.tray.connect(act_widget, SIGNAL("triggered()"), act_func)
self.act_indexes[i][iActFunc] = act_func
# -------------------------------------------------------------------------------------------
#def setActionChecked(self, act_name_id, yesno):
#index = self.get_act_index(act_name_id)
#if index < 0: return
#act_widget = self.act_indexes[index][1]
##if TrayEngine == "KDE":
##act_widget.setChecked(yesno)
##elif TrayEngine == "AppIndicator":
##if type(act_widget) != Gtk.CheckMenuItem:
##return # Cannot continue
##act_widget.set_active(yesno)
##else:
#if (1):
#act_widget.setChecked(yesno)
def setActionEnabled(self, act_name_id, yesno):
i = self.get_act_index(act_name_id)
if i < 0: return
act_widget = self.act_indexes[i][iActWidget]
if TrayEngine == "KDE":
act_widget.setEnabled(yesno)
elif TrayEngine == "AppIndicator":
act_widget.set_sensitive(yesno)
elif TrayEngine == "Qt":
act_widget.setEnabled(yesno)
def setActionIcon(self, act_name_id, icon):
i = self.get_act_index(act_name_id)
if i < 0: return
act_widget = self.act_indexes[i][iActWidget]
if TrayEngine == "KDE":
act_widget.setIcon(KIcon(icon))
elif TrayEngine == "AppIndicator":
if not isinstance(act_widget, Gtk.ImageMenuItem):
# Cannot use icons here
return
act_widget.set_image(Gtk.Image.new_from_icon_name(icon, Gtk.IconSize.MENU))
#act_widget.set_always_show_image(True)
elif TrayEngine == "Qt":
act_widget.setIcon(getIcon(icon))
def setActionText(self, act_name_id, text):
i = self.get_act_index(act_name_id)
if i < 0: return
act_widget = self.act_indexes[i][iActWidget]
if TrayEngine == "KDE":
act_widget.setText(text)
elif TrayEngine == "AppIndicator":
if isinstance(act_widget, Gtk.ImageMenuItem):
# Fix icon reset
last_icon = act_widget.get_image()
act_widget.set_label(text)
act_widget.set_image(last_icon)
else:
act_widget.set_label(text)
elif TrayEngine == "Qt":
act_widget.setText(text)
def setIcon(self, icon):
if TrayEngine == "KDE":
self.tray.setIconByPixmap(getIcon(icon))
#self.tray.setToolTipIconByPixmap(getIcon(icon))
elif TrayEngine == "AppIndicator":
self.tray.set_icon(icon)
elif TrayEngine == "Qt":
self.tray.setIcon(getIcon(icon))
def setToolTip(self, text):
if TrayEngine == "KDE":
self.tray.setToolTipSubTitle(text)
elif TrayEngine == "AppIndicator":
# ToolTips are disabled in App-Indicators by design
pass
elif TrayEngine == "Qt":
self.tray.setToolTip(text)
# -------------------------------------------------------------------------------------------
#def removeAction(self, act_name_id):
#index = self.get_act_index(act_name_id)
#if index < 0: return
#act_widget = self.act_indexes[index][1]
#parent_menu_widget = self.get_parent_menu_widget(self.act_indexes[index][2])
##if TrayEngine == "KDE":
##parent_menu_widget.removeAction(act_widget)
##elif TrayEngine == "AppIndicator":
##act_widget.hide()
##parent_menu_widget.remove(act_widget)
##else:
#if (1):
#parent_menu_widget.removeAction(act_widget)
#self.act_indexes.pop(index)
#def removeSeparator(self, sep_name_id):
#index = self.get_sep_index(sep_name_id)
#if index < 0: return
#sep_widget = self.sep_indexes[index][1]
#parent_menu_widget = self.get_parent_menu_widget(self.sep_indexes[index][2])
##if TrayEngine == "KDE":
##parent_menu_widget.removeAction(sep_widget)
##elif TrayEngine == "AppIndicator":
##sep_widget.hide()
##parent_menu_widget.remove(sep_widget)
##else:
#if (1):
#parent_menu_widget.removeAction(sep_widget)
#self.sep_indexes.pop(index)
#def removeMenu(self, menu_name_id):
#index = self.get_menu_index(menu_name_id)
#if index < 0: return
#menu_widget = self.menu_indexes[index][1]
#parent_menu_widget = self.get_parent_menu_widget(self.menu_indexes[index][2])
##if TrayEngine == "KDE":
##parent_menu_widget.removeAction(menu_widget.menuAction())
##elif TrayEngine == "AppIndicator":
##menu_widget.hide()
##parent_menu_widget.remove(menu_widget.get_submenu())
##else:
#if (1):
#parent_menu_widget.removeAction(menu_widget.menuAction())
#self.remove_actions_by_menu_name_id(menu_name_id)
#self.remove_separators_by_menu_name_id(menu_name_id)
#self.remove_submenus_by_menu_name_id(menu_name_id)
# -------------------------------------------------------------------------------------------
#def clearAll(self):
##if TrayEngine == "KDE":
##self.menu.clear()
##elif TrayEngine == "AppIndicator":
##for child in self.menu.get_children():
##self.menu.remove(child)
##else:
#if (1):
#self.menu.clear()
#self.act_indexes = []
#self.sep_indexes = []
#self.menu_indexes = []
#def clearMenu(self, menu_name_id):
#menu_index = self.get_menu_index(menu_name_id)
#if menu_index < 0: return
#menu_widget = self.menu_indexes[menu_index][1]
##if TrayEngine == "KDE":
##menu_widget.clear()
##elif TrayEngine == "AppIndicator":
##for child in menu_widget.get_submenu().get_children():
##menu_widget.get_submenu().remove(child)
##else:
#if (1):
#menu_widget.clear()
#list_of_submenus = [menu_name_id]
#for x in range(0, 10): # 10x level deep, should cover all cases...
#for this_menu_name_id, menu_widget, parent_menu_id in self.menu_indexes:
#if parent_menu_id in list_of_submenus and this_menu_name_id not in list_of_submenus:
#list_of_submenus.append(this_menu_name_id)
#for this_menu_name_id in list_of_submenus:
#self.remove_actions_by_menu_name_id(this_menu_name_id)
#self.remove_separators_by_menu_name_id(this_menu_name_id)
#self.remove_submenus_by_menu_name_id(this_menu_name_id)
# -------------------------------------------------------------------------------------------
def getTrayEngine(self):
return TrayEngine
def isTrayAvailable(self):
if TrayEngine in ("KDE", "Qt"):
return QSystemTrayIcon.isSystemTrayAvailable()
elif TrayEngine == "AppIndicator":
# Ubuntu/Unity always has a systray
return True
else:
return False
def handleQtCloseEvent(self, event):
if self.isTrayAvailable() and self._parent.isVisible():
event.accept()
self.__hideShowCall()
return
self.close()
QMainWindow.closeEvent(self._parent, event)
# -------------------------------------------------------------------------------------------
def show(self):
if not self._quit_added:
self._quit_added = True
if TrayEngine != "KDE":
self.addSeparator("_quit")
self.addAction("show", self._parent.tr("Minimize"))
self.addAction("quit", self._parent.tr("Quit"))
self.setActionIcon("quit", "application-exit")
self.connect("show", self.__hideShowCall)
self.connect("quit", self.__quitCall)
if TrayEngine == "KDE":
self.tray.setStatus(KStatusNotifierItem.Active)
elif TrayEngine == "AppIndicator":
self.tray.set_status(AppIndicator.IndicatorStatus.ACTIVE)
elif TrayEngine == "Qt":
self.tray.show()
def hide(self):
if TrayEngine == "KDE":
self.tray.setStatus(KStatusNotifierItem.Passive)
elif TrayEngine == "AppIndicator":
self.tray.set_status(AppIndicator.IndicatorStatus.PASSIVE)
elif TrayEngine == "Qt":
self.tray.hide()
def close(self):
if TrayEngine == "KDE":
self.menu.close()
elif TrayEngine == "AppIndicator":
if self._gtk_running:
self._gtk_running = False
Gtk.main_quit()
elif TrayEngine == "Qt":
self.menu.close()
def exec_(self, app):
self._app = app
if TrayEngine == "AppIndicator":
self._gtk_running = True
return Gtk.main()
else:
return app.exec_()
# -------------------------------------------------------------------------------------------
def get_act_index(self, act_name_id):
for i in range(len(self.act_indexes)):
if self.act_indexes[i][iActNameId] == act_name_id:
return i
else:
print("systray.py - Failed to get action index for %s" % act_name_id)
return -1
def get_sep_index(self, sep_name_id):
for i in range(len(self.sep_indexes)):
if self.sep_indexes[i][iSepNameId] == sep_name_id:
return i
else:
print("systray.py - Failed to get separator index for %s" % sep_name_id)
return -1
def get_menu_index(self, menu_name_id):
for i in range(len(self.menu_indexes)):
if self.menu_indexes[i][iMenuNameId] == menu_name_id:
return i
else:
print("systray.py - Failed to get menu index for %s" % menu_name_id)
return -1
#def get_parent_menu_widget(self, parent_menu_id):
#if parent_menu_id != None:
#menu_index = self.get_menu_index(parent_menu_id)
#if menu_index >= 0:
#return self.menu_indexes[menu_index][1]
#else:
#print("systray.py::Failed to get parent Menu widget for", parent_menu_id)
#return None
#else:
#return self.menu
#def remove_actions_by_menu_name_id(self, menu_name_id):
#h = 0
#for i in range(len(self.act_indexes)):
#act_name_id, act_widget, parent_menu_id, act_func = self.act_indexes[i - h]
#if parent_menu_id == menu_name_id:
#self.act_indexes.pop(i - h)
#h += 1
#def remove_separators_by_menu_name_id(self, menu_name_id):
#h = 0
#for i in range(len(self.sep_indexes)):
#sep_name_id, sep_widget, parent_menu_id = self.sep_indexes[i - h]
#if parent_menu_id == menu_name_id:
#self.sep_indexes.pop(i - h)
#h += 1
#def remove_submenus_by_menu_name_id(self, submenu_name_id):
#h = 0
#for i in range(len(self.menu_indexes)):
#menu_name_id, menu_widget, parent_menu_id = self.menu_indexes[i - h]
#if parent_menu_id == submenu_name_id:
#self.menu_indexes.pop(i - h)
#h += 1
# -------------------------------------------------------------------------------------------
def gtk_call_func(self, gtkmenu, act_name_id):
i = self.get_act_index(act_name_id)
if i < 0: return None
return self.act_indexes[i][iActFunc]
def qt_systray_clicked(self, reason):
if reason in (QSystemTrayIcon.DoubleClick, QSystemTrayIcon.Trigger):
self.__hideShowCall()
# -------------------------------------------------------------------------------------------
def __hideShowCall(self):
if self._parent.isVisible():
self.setActionText("show", self._parent.tr("Restore"))
self._parent.hide()
if self._app:
self._app.setQuitOnLastWindowClosed(False)
else:
self.setActionText("show", self._parent.tr("Minimize"))
if self._parent.isMaximized():
self._parent.showMaximized()
else:
self._parent.showNormal()
if self._app:
self._app.setQuitOnLastWindowClosed(True)
QTimer.singleShot(500, self.__raiseWindow)
def __quitCall(self):
if self._app:
self._app.setQuitOnLastWindowClosed(True)
self._parent.hide()
self._parent.close()
def __raiseWindow(self):
self._parent.activateWindow()
self._parent.raise_()
class MainWindow(QMainWindow):
def __init__(self, parent=None):
""" init UI """
QMainWindow.__init__(self, parent)
self.ui = Ui_MainWindow()
self.ui.setupUi(self)
self.dockToolBarManager = DockToolBarManager(self)
self.dockToolBar(Qt.TopToolBarArea)
self.__bottomDockBar = self.dockToolBar(Qt.BottomToolBarArea)
self.dockToolBar(Qt.LeftToolBarArea)
self.dockToolBar(Qt.RightToolBarArea)
self.ui.actionSaveSession.setEnabled(False)
self.do = DistributedObjects(self)
self.act = self.do.actions
self.debugController = self.do.debugController
self.settings = self.do.settings
self.signalproxy = self.do.signalProxy
self.pluginloader = PluginLoader(self.do)
self.act = self.do.actions
# init RecentFileHandler
self.recentFileHandler = RecentFileHandler(self, self.ui.menuRecentlyUsedFiles, self.do)
self.debugController.executableOpened.connect(self.recentFileHandler.addToRecentFiles)
self.debugController.executableOpened.connect(self.showExecutableName)
self.debugController.executableOpened.connect(self.disableButtons)
# signal proxy
self.signalproxy.inferiorIsRunning.connect(self.targetStartedRunning)
self.signalproxy.inferiorStoppedNormally.connect(self.targetStopped)
self.signalproxy.inferiorReceivedSignal.connect(self.targetStopped)
self.signalproxy.inferiorHasExited.connect(self.targetExited)
self.signalproxy.recordStateChanged.connect(self.setReverseDebugButtonsState)
# Plugin Loader
self.pluginloader.insertPluginAction.connect(self.addPluginAction)
self.ui.actionSavePlugins.triggered.connect(self.showSavePluginsDialog)
self.ui.actionLoadPlugins.triggered.connect(self.showLoadPluginsDialog)
dw = self.insertDockWidget(None, "Log View", Qt.BottomDockWidgetArea, True)
self.logviewhandler = LogViewHandler(dw)
dw.setWidget(self.logviewhandler)
self.notificationFrameHandler = NotificationFrameHandler(self.ui.notificationArea)
self.pluginloader.addAvailablePlugins()
self.setWindowFilePath("<none>")
self.setupUi()
self.readSettings()
self.quickwatch = QuickWatch(self, self.do)
def __makeRunWithArgumentsMenu(self):
self.__runWithArgumentsMenu = QMenu(self)
self.__argumentsEdit = QLineEdit()
self.__argumentsEdit.returnPressed.connect(self.__runWithArgumentsTriggered)
hl = QHBoxLayout(self.__runWithArgumentsMenu)
hl.addWidget(QLabel("Run with arguments:"))
hl.addWidget(self.__argumentsEdit)
w = QWidget(self.__runWithArgumentsMenu)
w.setLayout(hl)
wa = QWidgetAction(self.__runWithArgumentsMenu)
wa.setDefaultWidget(w)
self.__runWithArgumentsMenu.addAction(wa)
self.act.Run.setMenu(self.__runWithArgumentsMenu)
def __runWithArgumentsTriggered(self):
self.__runWithArgumentsMenu.close()
self.debugController.run(str(self.__argumentsEdit.text()))
def setupUi(self):
self.__initActions()
self.ui.statusLabel = QLabel()
self.ui.statusLabel.setText("Not running")
self.ui.statusbar.addPermanentWidget(self.ui.statusLabel)
self.ui.statusIcon = QLabel()
self.ui.statusIcon.setPixmap(QPixmap(":/icons/images/22x22/not_running.png"))
self.ui.statusbar.addPermanentWidget(self.ui.statusIcon)
def __initActions(self):
self.disableButtons()
self.act.Record.setCheckable(True)
self.act.ReverseNext.setEnabled(False)
self.act.ReverseStep.setEnabled(False)
self.act.ReverseFinish.setEnabled(False)
self.act.SaveFile.setEnabled(False)
# debug actions
self.ui.menuDebug.addAction(self.act.Run)
self.ui.menuDebug.addAction(self.act.Continue)
self.ui.menuDebug.addAction(self.act.Interrupt)
self.ui.menuDebug.addAction(self.act.Next)
self.ui.menuDebug.addAction(self.act.Step)
self.ui.menuDebug.addAction(self.act.Finish)
self.ui.menuDebug.addAction(self.act.RunToCursor)
self.ui.menuDebug.addAction(self.act.Record)
self.ui.menuDebug.addAction(self.act.ReverseNext)
self.ui.menuDebug.addAction(self.act.ReverseStep)
# file actions
self.ui.menuFile.insertAction(self.ui.actionSaveSession,
self.act.OpenMenu)
self.ui.menuFile.addAction(self.act.SaveFile)
self.ui.menuFile.addAction(self.act.Exit)
# add them to menubar and also menuView to respect order
self.ui.menubar.addAction(self.ui.menuFile.menuAction())
self.ui.menubar.addAction(self.ui.menuView.menuAction())
self.ui.menubar.addAction(self.ui.menuDebug.menuAction())
self.ui.menubar.addAction(self.ui.menuHelp.menuAction())
# now make toolbar actions
self.act.Open.setMenu(self.ui.menuRecentlyUsedFiles)
self.ui.Main.addAction(self.act.Open)
self.ui.Main.addAction(self.act.SaveFile)
self.ui.Main.addSeparator()
self.__makeRunWithArgumentsMenu()
self.ui.Main.addAction(self.act.Run)
self.ui.Main.addAction(self.act.Continue)
self.ui.Main.addAction(self.act.Interrupt)
self.ui.Main.addAction(self.act.Next)
self.ui.Main.addAction(self.act.Step)
self.ui.reverseBar.addAction(self.act.Record)
self.ui.reverseBar.addAction(self.act.ReverseNext)
self.ui.reverseBar.addAction(self.act.ReverseStep)
self.ui.reverseBar.addAction(self.act.ReverseFinish)
self.ui.Main.addAction(self.act.Finish)
self.ui.Main.addAction(self.act.RunToCursor)
self.ui.Main.addSeparator()
self.ui.Main.addAction(self.act.Exit)
# connect actions
self.__connectActions()
def __connectActions(self):
self.ui.actionRestoreSession.triggered.connect(
self.do.sessionManager.showRestoreSessionDialog)
self.ui.actionSaveSession.triggered.connect(
self.do.sessionManager.showSaveSessionDialog)
self.ui.actionConfigure.triggered.connect(self.do.configStore.edit)
def insertDockWidget(self, widget, name, area, addToggleViewAction, icon=None):
d = AlertableDockWidget(name, self)
d.setObjectName(name)
if widget:
d.setWidget(widget)
if icon:
d.setWindowIcon(icon)
self.dockToolBar(self.dockToolBarManager.dockWidgetAreaToToolBarArea(area)).addDock(d)
if addToggleViewAction:
self.ui.menuShow_View.addAction(d.toggleViewAction())
return d
def insertStatusbarWidget(self, widget):
w = QFrame()
w.setLayout(QHBoxLayout())
w.layout().addWidget(widget)
f = QFrame()
f.setFrameStyle(QFrame.Plain | QFrame.VLine)
w.layout().addWidget(f)
self.ui.statusbar.insertPermanentWidget(0, w)
return w
def removeStatusbarWidget(self, widget):
self.ui.statusbar.removeWidget(widget)
def addPluginAction(self, Action):
""" show plugin as menu entry """
self.ui.menuPlugins.addAction(Action)
def showOpenExecutableDialog(self):
filename = str(QFileDialog.getOpenFileName(self, "Open Executable", self.recentFileHandler.getDirOfLastFile()))
if filename != "":
self.debugController.openExecutable(filename)
def showLoadPluginsDialog(self):
dialog = QFileDialog()
dialog.setNameFilter("*.xml")
filename = str(dialog.getOpenFileName(self, "Load plugin configuration"))
if filename != "":
self.pluginloader.getActivePlugins(filename)
def showSavePluginsDialog(self):
dialog = QFileDialog()
dialog.setNameFilter("*.xml")
filename = str(dialog.getSaveFileName(self, "Save plugin configuration"))
if filename != "":
self.pluginloader.savePluginInfo(filename)
def showExecutableName(self, filename):
self.ui.actionSaveSession.setEnabled(True) # enable saving session
self.setWindowFilePath(filename)
def targetStartedRunning(self):
self.ui.statusLabel.setText("Running")
self.ui.statusIcon.setPixmap(QPixmap(":/icons/images/22x22/running.png"))
self.disableButtons()
self.act.Interrupt.setEnabled(True)
def targetStopped(self, _):
self.ui.statusLabel.setText("Stopped")
self.ui.statusIcon.setPixmap(QPixmap(":/icons/images/22x22/stopped.png"))
self.enableButtons()
self.act.Interrupt.setEnabled(False)
def targetExited(self):
self.ui.statusLabel.setText("Not running")
self.disableButtons()
self.ui.statusIcon.setPixmap(QPixmap(":/icons/images/22x22/not_running.png"))
logging.info("Inferior exited.")
def closeEvent(self, event):
if not self.do.editorController.closeOpenedFiles():
event.ignore() # closing source files may be canceled by user
else:
self.settings.setValue("geometry", self.saveGeometry())
self.settings.setValue("windowState", self.saveState())
self.dockToolBarManager.saveState(self.settings)
QMainWindow.closeEvent(self, event)
self.pluginloader.savePluginInfo()
def readSettings(self):
self.restoreGeometry(self.settings.value("geometry"))
self.restoreState(self.settings.value("windowState"))
self.dockToolBarManager.restoreState(self.settings)
def setReverseDebugButtonsState(self, check):
self.act.ReverseNext.setEnabled(check)
self.act.ReverseStep.setEnabled(check)
self.act.ReverseFinish.setEnabled(check)
def enableButtons(self):
self.act.Continue.setEnabled(True)
self.act.Interrupt.setEnabled(True)
self.act.Next.setEnabled(True)
self.act.Step.setEnabled(True)
self.act.Finish.setEnabled(True)
self.act.RunToCursor.setEnabled(True)
self.act.Record.setEnabled(True)
def disableButtons(self):
self.act.Continue.setEnabled(False)
self.act.Interrupt.setEnabled(False)
self.act.Next.setEnabled(False)
self.act.Step.setEnabled(False)
self.act.Finish.setEnabled(False)
self.act.RunToCursor.setEnabled(False)
self.act.Record.setChecked(False)
self.act.Record.setEnabled(False)
def dockToolBar(self, area):
return self.dockToolBarManager.bar(area)
class FilterTableWidget(QTableWidget):
def __init__(self, parent=None):
super(FilterTableWidget, self).__init__(parent=parent)
self.horizontalHeader = self.horizontalHeader()
self.horizontalHeader.sectionClicked.connect(
self.on_view_horizontalHeader_sectionClicked)
self.keywords = dict([(i, []) for i in range(self.columnCount())])
self.checkBoxs = []
self.col = None
def on_view_horizontalHeader_sectionClicked(self, index):
self.menu = QMenu(self)
self.col = index
data_unique = []
self.checkBoxs = []
self.checkBoxSelect = QCheckBox("Select all", self.menu)
checkableAction = QWidgetAction(self.menu)
checkableAction.setDefaultWidget(self.checkBoxSelect)
self.menu.addAction(checkableAction)
self.checkBoxSelect.setChecked(True)
self.checkBoxSelect.stateChanged.connect(self.onSelect)
for i in range(self.rowCount()):
if not self.isRowHidden(i):
item = self.item(i, index)
if item.text() not in data_unique:
data_unique.append(item.text())
checkBox = QCheckBox(item.text(), self.menu)
checkBox.setChecked(True)
checkBox.stateChanged.connect(self.onClickedElement)
checkableAction = QWidgetAction(self.menu)
checkableAction.setDefaultWidget(checkBox)
self.menu.addAction(checkableAction)
self.checkBoxs.append(checkBox)
btn = QDialogButtonBox(QDialogButtonBox.Ok | QDialogButtonBox.Cancel,
Qt.Horizontal, self.menu)
btn.accepted.connect(self.menuClose)
btn.rejected.connect(self.menu.close)
checkableAction = QWidgetAction(self.menu)
checkableAction.setDefaultWidget(btn)
self.menu.addAction(checkableAction)
headerPos = self.mapToGlobal(self.horizontalHeader.pos())
posY = headerPos.y() + self.horizontalHeader.height()
posX = headerPos.x() + self.horizontalHeader.sectionPosition(index)
self.menu.exec_(QPoint(posX, posY))
def onClickedElement(self):
if self.checkBoxSelect.isChecked():
self.checkBoxSelect.setChecked(False)
def onSelect(self, state):
for checkbox in self.checkBoxs:
checkbox.setChecked(Qt.Checked == state)
def menuClose(self):
self.keywords[self.col] = []
for element in self.checkBoxs:
if element.isChecked():
self.keywords[self.col].append(element.text())
self.filterdata()
self.menu.close()
def filterdata(self):
columnsShow = dict([(i, True) for i in range(self.rowCount())])
for i in range(self.rowCount()):
for j in range(self.columnCount()):
item = self.item(i, j)
if j in self.keywords:
if self.keywords[j]:
if item.text() not in self.keywords[j]:
columnsShow[i] = False
for key, value in columnsShow.iteritems():
self.setRowHidden(key, not value)
class MainWindow(QMainWindow):
def __init__(self, parent=None):
""" init UI """
QMainWindow.__init__(self, parent)
self.ui = Ui_MainWindow()
self.ui.setupUi(self)
self.ui.actionSaveSession.setEnabled(False)
self.distributedObjects = DistributedObjects(self)
self.act = self.distributedObjects.actions
self.debugController = self.distributedObjects.debugController
self.settings = self.distributedObjects.settings
self.signalproxy = self.distributedObjects.signalProxy
self.pluginloader = PluginLoader(self.distributedObjects)
self.editorController = self.distributedObjects.editorController
self.act = self.distributedObjects.actions
# init RecentFileHandler
self.recentFileHandler = RecentFileHandler(self, self.ui.menuRecentlyUsedFiles, self.distributedObjects)
self.debugController.executableOpened.connect(self.recentFileHandler.addToRecentFiles)
self.debugController.executableOpened.connect(self.__observeWorkingBinary)
self.debugController.executableOpened.connect(self.showExecutableName)
self.debugController.executableOpened.connect(self.disableButtons)
# signal proxy
self.signalproxy.inferiorIsRunning.connect(self.targetStartedRunning)
self.signalproxy.inferiorStoppedNormally.connect(self.targetStopped)
self.signalproxy.inferiorReceivedSignal.connect(self.targetStopped)
self.signalproxy.inferiorHasExited.connect(self.targetExited)
# Plugin Loader
self.pluginloader.insertPluginAction.connect(self.addPluginAction)
self.ui.actionSavePlugins.triggered.connect(self.showSavePluginsDialog)
self.ui.actionLoadPlugins.triggered.connect(self.showLoadPluginsDialog)
# Add editor to main window.
self.ui.gridLayout.addWidget(self.distributedObjects.editorController.editor_view, 0, 0, 1, 1)
self.pluginloader.addAvailablePlugins()
self.setWindowFilePath("<none>")
self.setupUi()
self.readSettings()
self.quickwatch = QuickWatch(self, self.distributedObjects)
self.binaryName = None
self.fileWatcher = QFileSystemWatcher()
self.fileWatcher.fileChanged.connect(self.__binaryChanged)
self.__runWithArgumentsMenu = None
self.__argumentsEdit = None
self.__makeRunWithArgumentsMenu()
def __makeRunWithArgumentsMenu(self):
self.__runWithArgumentsMenu = QMenu(self)
self.__argumentsEdit = QLineEdit()
self.__argumentsEdit.returnPressed.connect(self.__runWithArgumentsTriggered)
hl = QHBoxLayout(self.__runWithArgumentsMenu)
hl.addWidget(QLabel("Run with arguments:"))
hl.addWidget(self.__argumentsEdit)
w = QWidget(self.__runWithArgumentsMenu)
w.setLayout(hl)
wa = QWidgetAction(self.__runWithArgumentsMenu)
wa.setDefaultWidget(w)
self.__runWithArgumentsMenu.addAction(wa)
self.act.Run.setMenu(self.__runWithArgumentsMenu)
def __runTriggered(self):
self.debugController.run()
def __runWithArgumentsTriggered(self):
self.__runWithArgumentsMenu.close()
self.debugController.run(str(self.__argumentsEdit.text()))
def setupUi(self):
self.__initActions()
self.ui.statusLabel = QLabel()
self.ui.statusLabel.setText("Not running")
self.ui.statusbar.addPermanentWidget(self.ui.statusLabel)
self.ui.statusIcon = QLabel()
self.ui.statusIcon.setPixmap(QPixmap(":/icons/images/22x22/not_running.png"))
self.ui.statusbar.addPermanentWidget(self.ui.statusIcon)
def __initActions(self):
self.disableButtons()
self.act.Record.setCheckable(True)
self.act.ReverseNext.setEnabled(False)
self.act.ReverseStep.setEnabled(False)
self.act.SaveFile.setEnabled(False)
self.act.Beautify.setCheckable(True)
self.act.Beautify.setChecked(True)
# debug actions
self.ui.menuDebug.addAction(self.act.Run)
self.ui.menuDebug.addAction(self.act.Continue)
self.ui.menuDebug.addAction(self.act.Interrupt)
self.ui.menuDebug.addAction(self.act.Next)
self.ui.menuDebug.addAction(self.act.Step)
self.ui.menuDebug.addAction(self.act.Finish)
self.ui.menuDebug.addAction(self.act.RunToCursor)
self.ui.menuDebug.addAction(self.act.Record)
self.ui.menuDebug.addAction(self.act.ReverseNext)
self.ui.menuDebug.addAction(self.act.ReverseStep)
self.ui.menuDebug.addAction(self.act.Beautify)
# file actions
self.ui.menuFile.insertAction(self.ui.actionSaveSession, self.act.OpenMenu)
self.ui.menuFile.addAction(self.act.SaveFile)
self.ui.menuFile.addAction(self.act.Exit)
# add them to menubar and also menuView to respect order
self.ui.menubar.addAction(self.ui.menuFile.menuAction())
self.ui.menubar.addAction(self.ui.menuView.menuAction())
self.ui.menubar.addAction(self.ui.menuDebug.menuAction())
self.ui.menubar.addAction(self.ui.menuHelp.menuAction())
# now make toolbar actions
self.act.Open.setMenu(self.ui.menuRecentlyUsedFiles)
self.ui.Main.addAction(self.act.Open)
self.ui.Main.addAction(self.act.SaveFile)
self.ui.Main.addSeparator()
self.ui.Main.addAction(self.act.Run)
self.ui.Main.addAction(self.act.Continue)
self.ui.Main.addAction(self.act.Interrupt)
self.ui.Main.addAction(self.act.Next)
self.ui.Main.addAction(self.act.Step)
self.ui.Main.addAction(self.act.Record)
self.ui.Main.addAction(self.act.ReverseNext)
self.ui.Main.addAction(self.act.ReverseStep)
self.ui.Main.addAction(self.act.Finish)
self.ui.Main.addAction(self.act.RunToCursor)
self.ui.Main.addAction(self.act.Beautify)
self.ui.Main.addSeparator()
self.ui.Main.addAction(self.act.Exit)
# connect actions
self.__connectActions()
def __connectActions(self):
# file menu
self.act.Open.triggered.connect(self.showOpenExecutableDialog)
self.act.OpenMenu.triggered.connect(self.showOpenExecutableDialog)
self.act.Exit.triggered.connect(self.close)
self.act.SaveFile.triggered.connect(self.signalproxy.emitSaveCurrentFile)
# debug menu
self.act.Run.triggered.connect(self.__runTriggered)
self.act.Next.triggered.connect(self.debugController.next_)
self.act.Step.triggered.connect(self.debugController.step)
self.act.Continue.triggered.connect(self.debugController.cont)
self.act.Record.triggered.connect(self.toggleRecord)
self.act.ReverseStep.triggered.connect(self.debugController.reverse_step)
self.act.ReverseNext.triggered.connect(self.debugController.reverse_next)
self.act.Beautify.triggered.connect(self.__askBeautify)
self.act.Interrupt.triggered.connect(self.debugController.interrupt)
self.act.Finish.triggered.connect(self.debugController.finish)
self.act.RunToCursor.triggered.connect(self.debugController.inferiorUntil)
self.ui.actionRestoreSession.triggered.connect(self.distributedObjects.sessionManager.showRestoreSessionDialog)
self.ui.actionSaveSession.triggered.connect(self.distributedObjects.sessionManager.showSaveSessionDialog)
self.ui.actionConfigure.triggered.connect(self.distributedObjects.configStore.edit)
def insertDockWidget(self, widget, name, area, addToggleViewAction):
d = AlertableDockWidget(name, self)
d.setObjectName(name)
d.setWidget(widget)
self.addDockWidget(area, d)
if addToggleViewAction:
self.ui.menuShow_View.addAction(d.toggleViewAction())
return d
def insertStatusbarWidget(self, widget):
w = QFrame()
w.setLayout(QHBoxLayout())
w.layout().addWidget(widget)
f = QFrame()
f.setFrameStyle(QFrame.Plain | QFrame.VLine)
w.layout().addWidget(f)
self.ui.statusbar.insertPermanentWidget(0, w)
return w
def removeStatusbarWidget(self, widget):
self.ui.statusbar.removeWidget(widget)
def addPluginAction(self, Action):
""" show plugin as menu entry """
self.ui.menuPlugins.addAction(Action)
def showOpenExecutableDialog(self):
filename = str(QFileDialog.getOpenFileName(self, "Open Executable", self.recentFileHandler.getDirOfLastFile()))
if filename != "":
self.debugController.openExecutable(filename)
def showLoadPluginsDialog(self):
dialog = QFileDialog()
dialog.setNameFilter("*.xml")
filename = str(dialog.getOpenFileName(self, "Load plugin configuration"))
if filename != "":
self.pluginloader.getActivePlugins(filename)
def showSavePluginsDialog(self):
dialog = QFileDialog()
dialog.setNameFilter("*.xml")
filename = str(dialog.getSaveFileName(self, "Save plugin configuration"))
if filename != "":
self.pluginloader.savePluginInfo(filename)
def showExecutableName(self, filename):
self.ui.actionSaveSession.setEnabled(True) # enable saving session
self.setWindowFilePath(filename)
def targetStartedRunning(self):
self.ui.statusLabel.setText("Running")
self.ui.statusIcon.setPixmap(QPixmap(":/icons/images/22x22/running.png"))
self.disableButtons()
self.act.Interrupt.setEnabled(True)
def targetStopped(self, rec):
self.ui.statusLabel.setText("Stopped")
self.ui.statusIcon.setPixmap(QPixmap(":/icons/images/22x22/stopped.png"))
self.enableButtons()
self.act.Interrupt.setEnabled(False)
def targetExited(self):
self.ui.statusLabel.setText("Not running")
self.disableButtons()
self.ui.statusIcon.setPixmap(QPixmap(":/icons/images/22x22/not_running.png"))
def closeEvent(self, event):
if not self.distributedObjects.editorController.closeOpenedFiles():
event.ignore() # closing source files may be canceled by user
else:
self.settings.setValue("geometry", self.saveGeometry())
self.settings.setValue("windowState", self.saveState())
QMainWindow.closeEvent(self, event)
self.pluginloader.savePluginInfo()
def readSettings(self):
self.restoreGeometry(self.settings.value("geometry").toByteArray())
self.restoreState(self.settings.value("windowState").toByteArray())
def toggleRecord(self, check):
if check:
self.debugController.record_start()
self.act.ReverseNext.setEnabled(True)
self.act.ReverseStep.setEnabled(True)
else:
self.debugController.record_stop()
self.act.ReverseNext.setEnabled(False)
self.act.ReverseStep.setEnabled(False)
def enableButtons(self):
self.act.Continue.setEnabled(True)
self.act.Interrupt.setEnabled(True)
self.act.Next.setEnabled(True)
self.act.Step.setEnabled(True)
self.act.Finish.setEnabled(True)
self.act.RunToCursor.setEnabled(True)
self.act.Record.setEnabled(True)
self.act.Beautify.setEnabled(True)
def disableButtons(self):
self.act.Continue.setEnabled(False)
self.act.Interrupt.setEnabled(False)
self.act.Next.setEnabled(False)
self.act.Step.setEnabled(False)
self.act.Finish.setEnabled(False)
self.act.RunToCursor.setEnabled(False)
self.act.Record.setChecked(False)
self.act.Record.setEnabled(False)
self.act.Beautify.setEnabled(False)
def __observeWorkingBinary(self, filename):
""" Private Method to Observe Debugged Binary """
if self.binaryName != None:
self.fileWatcher.removePath(self.binaryName)
self.fileWatcher.addPath(filename)
self.binaryName = filename
def __binaryChanged(self):
""" Slot for FileWatcher - Using QtMessagebox for interaction"""
box = QtGui.QMessageBox()
if (
box.question(self, "Binary Changed!", "Reload File?", QtGui.QMessageBox.Yes, QtGui.QMessageBox.No)
== QtGui.QMessageBox.Yes
):
self.debugController.openExecutable(self.binaryName)
else:
self.fileWatcher.removePath(self.binaryName)
self.fileWatcher.addPath(self.binaryName)
def __askBeautify(self):
""" Warn user before Beautify - Using QtMessagebox for interaction"""
box = QtGui.QMessageBox()
if (
box.question(
self,
"Warning!",
"This deletes the objects in watch and datagraphview.",
QtGui.QMessageBox.Ok,
QtGui.QMessageBox.Cancel,
)
== QtGui.QMessageBox.Ok
):
self.debugController.beautify()
else:
self.act.Beautify.toggle()
class MainWindow(QMainWindow):
def __init__(self, parent=None):
""" init UI """
QMainWindow.__init__(self, parent)
self.ui = Ui_MainWindow()
self.ui.setupUi(self)
self.dockToolBarManager = DockToolBarManager(self)
self.dockToolBar(Qt.TopToolBarArea)
self.__bottomDockBar = self.dockToolBar(Qt.BottomToolBarArea)
self.dockToolBar(Qt.LeftToolBarArea)
self.dockToolBar(Qt.RightToolBarArea)
self.ui.actionSaveSession.setEnabled(False)
self.do = DistributedObjects(self)
self.act = self.do.actions
self.debugController = self.do.debugController
self.settings = self.do.settings
self.signalproxy = self.do.signalProxy
self.pluginloader = PluginLoader(self.do)
self.act = self.do.actions
# init RecentFileHandler
self.recentFileHandler = RecentFileHandler(self, self.ui.menuRecentlyUsedFiles, self.do)
self.debugController.executableOpened.connect(self.recentFileHandler.addToRecentFiles)
self.debugController.executableOpened.connect(self.showExecutableName)
self.debugController.executableOpened.connect(self.disableButtons)
# signal proxy
self.signalproxy.inferiorIsRunning.connect(self.targetStartedRunning)
self.signalproxy.inferiorStoppedNormally.connect(self.targetStopped)
self.signalproxy.inferiorReceivedSignal.connect(self.targetStopped)
self.signalproxy.inferiorHasExited.connect(self.targetExited)
self.signalproxy.recordStateChanged.connect(self.setReverseDebugButtonsState)
# Plugin Loader
self.pluginloader.insertPluginAction.connect(self.addPluginAction)
self.ui.actionSavePlugins.triggered.connect(self.showSavePluginsDialog)
self.ui.actionLoadPlugins.triggered.connect(self.showLoadPluginsDialog)
dw = self.insertDockWidget(None, "Log View", Qt.BottomDockWidgetArea, True)
self.logviewhandler = LogViewHandler(dw)
dw.setWidget(self.logviewhandler)
self.notificationFrameHandler = NotificationFrameHandler(self.ui.notificationArea)
self.pluginloader.addAvailablePlugins()
self.setWindowFilePath("<none>")
self.setupUi()
self.readSettings()
self.quickwatch = QuickWatch(self, self.do)
def __makeRunWithArgumentsMenu(self):
self.__runWithArgumentsMenu = QMenu(self)
self.__argumentsEdit = QLineEdit()
self.__argumentsEdit.returnPressed.connect(self.__runWithArgumentsTriggered)
hl = QHBoxLayout(self.__runWithArgumentsMenu)
hl.addWidget(QLabel("Run with arguments:"))
hl.addWidget(self.__argumentsEdit)
w = QWidget(self.__runWithArgumentsMenu)
w.setLayout(hl)
wa = QWidgetAction(self.__runWithArgumentsMenu)
wa.setDefaultWidget(w)
self.__runWithArgumentsMenu.addAction(wa)
self.act.Run.setMenu(self.__runWithArgumentsMenu)
def __runWithArgumentsTriggered(self):
self.__runWithArgumentsMenu.close()
self.debugController.run(str(self.__argumentsEdit.text()))
def setupUi(self):
self.__initActions()
self.ui.statusLabel = QLabel()
self.ui.statusLabel.setText("Not running")
self.ui.statusbar.addPermanentWidget(self.ui.statusLabel)
self.ui.statusIcon = QLabel()
self.ui.statusIcon.setPixmap(QPixmap(":/icons/images/22x22/not_running.png"))
self.ui.statusbar.addPermanentWidget(self.ui.statusIcon)
def __initActions(self):
self.disableButtons()
self.act.Record.setCheckable(True)
self.act.ReverseNext.setEnabled(False)
self.act.ReverseStep.setEnabled(False)
self.act.ReverseFinish.setEnabled(False)
self.act.SaveFile.setEnabled(False)
# debug actions
self.ui.menuDebug.addAction(self.act.Run)
self.ui.menuDebug.addAction(self.act.Continue)
self.ui.menuDebug.addAction(self.act.Interrupt)
self.ui.menuDebug.addAction(self.act.Next)
self.ui.menuDebug.addAction(self.act.Step)
self.ui.menuDebug.addAction(self.act.Finish)
self.ui.menuDebug.addAction(self.act.RunToCursor)
self.ui.menuDebug.addAction(self.act.Record)
self.ui.menuDebug.addAction(self.act.ReverseNext)
self.ui.menuDebug.addAction(self.act.ReverseStep)
# file actions
self.ui.menuFile.insertAction(self.ui.actionSaveSession,
self.act.OpenMenu)
self.ui.menuFile.addAction(self.act.SaveFile)
self.ui.menuFile.addAction(self.act.Exit)
# add them to menubar and also menuView to respect order
self.ui.menubar.addAction(self.ui.menuFile.menuAction())
self.ui.menubar.addAction(self.ui.menuView.menuAction())
self.ui.menubar.addAction(self.ui.menuDebug.menuAction())
self.ui.menubar.addAction(self.ui.menuHelp.menuAction())
# now make toolbar actions
self.act.Open.setMenu(self.ui.menuRecentlyUsedFiles)
self.ui.Main.addAction(self.act.Open)
self.ui.Main.addAction(self.act.SaveFile)
self.ui.Main.addSeparator()
self.__makeRunWithArgumentsMenu()
self.ui.Main.addAction(self.act.Run)
self.ui.Main.addAction(self.act.Continue)
self.ui.Main.addAction(self.act.Interrupt)
self.ui.Main.addAction(self.act.Next)
self.ui.Main.addAction(self.act.Step)
self.ui.reverseBar.addAction(self.act.Record)
self.ui.reverseBar.addAction(self.act.ReverseNext)
self.ui.reverseBar.addAction(self.act.ReverseStep)
self.ui.reverseBar.addAction(self.act.ReverseFinish)
self.ui.Main.addAction(self.act.Finish)
self.ui.Main.addAction(self.act.RunToCursor)
self.ui.Main.addSeparator()
self.ui.Main.addAction(self.act.Exit)
# connect actions
self.__connectActions()
def __connectActions(self):
self.ui.actionRestoreSession.triggered.connect(
self.do.sessionManager.showRestoreSessionDialog)
self.ui.actionSaveSession.triggered.connect(
self.do.sessionManager.showSaveSessionDialog)
self.ui.actionConfigure.triggered.connect(self.do.configStore.edit)
def insertDockWidget(self, widget, name, area, addToggleViewAction, icon=None):
d = AlertableDockWidget(name, self)
d.setObjectName(name)
if widget:
d.setWidget(widget)
if icon:
d.setWindowIcon(icon)
self.dockToolBar(self.dockToolBarManager.dockWidgetAreaToToolBarArea(area)).addDock(d)
if addToggleViewAction:
self.ui.menuShow_View.addAction(d.toggleViewAction())
return d
def insertStatusbarWidget(self, widget):
w = QFrame()
w.setLayout(QHBoxLayout())
w.layout().addWidget(widget)
f = QFrame()
f.setFrameStyle(QFrame.Plain | QFrame.VLine)
w.layout().addWidget(f)
self.ui.statusbar.insertPermanentWidget(0, w)
return w
def removeStatusbarWidget(self, widget):
self.ui.statusbar.removeWidget(widget)
def addPluginAction(self, Action):
""" show plugin as menu entry """
self.ui.menuPlugins.addAction(Action)
def showOpenExecutableDialog(self):
filename = str(QFileDialog.getOpenFileName(self, "Open Executable", self.recentFileHandler.getDirOfLastFile()))
if filename != "":
self.debugController.openExecutable(filename)
def showLoadPluginsDialog(self):
dialog = QFileDialog()
dialog.setNameFilter("*.xml")
filename = str(dialog.getOpenFileName(self, "Load plugin configuration"))
if filename != "":
self.pluginloader.getActivePlugins(filename)
def showSavePluginsDialog(self):
dialog = QFileDialog()
dialog.setNameFilter("*.xml")
filename = str(dialog.getSaveFileName(self, "Save plugin configuration"))
if filename != "":
self.pluginloader.savePluginInfo(filename)
def showExecutableName(self, filename):
self.ui.actionSaveSession.setEnabled(True) # enable saving session
self.setWindowFilePath(filename)
def targetStartedRunning(self):
self.ui.statusLabel.setText("Running")
self.ui.statusIcon.setPixmap(QPixmap(":/icons/images/22x22/running.png"))
self.disableButtons()
self.act.Interrupt.setEnabled(True)
def targetStopped(self, _):
self.ui.statusLabel.setText("Stopped")
self.ui.statusIcon.setPixmap(QPixmap(":/icons/images/22x22/stopped.png"))
self.enableButtons()
self.act.Interrupt.setEnabled(False)
def targetExited(self):
self.ui.statusLabel.setText("Not running")
self.disableButtons()
self.ui.statusIcon.setPixmap(QPixmap(":/icons/images/22x22/not_running.png"))
logging.info("Inferior exited.")
def closeEvent(self, event):
if not self.do.editorController.closeOpenedFiles():
event.ignore() # closing source files may be canceled by user
else:
self.settings.setValue("geometry", self.saveGeometry())
self.settings.setValue("windowState", self.saveState())
self.dockToolBarManager.saveState(self.settings)
QMainWindow.closeEvent(self, event)
self.pluginloader.savePluginInfo()
def readSettings(self):
if self.settings.value("geometry") is not None:
self.restoreGeometry(self.settings.value("geometry"))
if self.settings.value("windowState") is not None:
self.restoreState(self.settings.value("windowState"))
self.dockToolBarManager.restoreState(self.settings)
def setReverseDebugButtonsState(self, check):
self.act.ReverseNext.setEnabled(check)
self.act.ReverseStep.setEnabled(check)
self.act.ReverseFinish.setEnabled(check)
def enableButtons(self):
self.act.Continue.setEnabled(True)
self.act.Interrupt.setEnabled(True)
self.act.Next.setEnabled(True)
self.act.Step.setEnabled(True)
self.act.Finish.setEnabled(True)
self.act.RunToCursor.setEnabled(True)
self.act.Record.setEnabled(True)
def disableButtons(self):
self.act.Continue.setEnabled(False)
self.act.Interrupt.setEnabled(False)
self.act.Next.setEnabled(False)
self.act.Step.setEnabled(False)
self.act.Finish.setEnabled(False)
self.act.RunToCursor.setEnabled(False)
self.act.Record.setChecked(False)
self.act.Record.setEnabled(False)
def dockToolBar(self, area):
return self.dockToolBarManager.bar(area)
