def __init__(self, stdscr, site, surveyed):
View.__init__(self, stdscr)
self._site = site
self._surveyed = surveyed
(h, w) = self._stdscr.getmaxyx()
self._win = self._stdscr.derwin(16, 48, (h - 16) / 2, (w - 48) / 2)
def __init__(self, topoWidget):
View.__init__(self, topoWidget, "Elastic Tree")
self.logDisplay = self.topoWidget.parent.logWidget.logDisplay
utilBtn = QtGui.QPushButton('Change Util Bound')
infoBtn = QtGui.QPushButton('What is ElasticTree?')
self.connect(utilBtn, QtCore.SIGNAL('clicked()'),
self.changeUtil)
self.connect(infoBtn, QtCore.SIGNAL('clicked()'), self.showInfo)
# self.connect(powerBtn, QtCore.SIGNAL('clicked()'),
# self.showPowerStats)
# self.buttons.append(powerBtn)
self.buttons.append(utilBtn)
self.buttons.append(infoBtn)
self.utilBound = 0.01
self.slider = QtGui.QSlider(QtCore.Qt.Horizontal, self)
self.slider.setMinimum(0)
self.slider.setMaximum(100)
self.buttons.append(self.slider)
self.sliderValue = 0
self.stats = {} # maps tuples (dpid, port) to utilization
self.powerSliderSignal.connect(self.changeSlider)
self.indicator = QtGui.QLabel()
self.buttons.append(self.indicator)
def __init__(self, stdscr, wildcatting_, setting):
View.__init__(self, stdscr)
self._wildcatting = wildcatting_
self._setting = setting
(h, w) = stdscr.getmaxyx()
bwh = h - (self.TOP_BORDER * 2)
bww = w - (self.SIDE_BORDER * 2)
field = wildcatting_.getPlayerField()
rows, cols = field.getHeight(), field.getWidth()
self._border_win = stdscr.derwin(bwh, bww, 1, 3)
self._field_win = stdscr.derwin(rows, cols, 2, 4)
bkgd = Colors.get(curses.COLOR_WHITE, curses.COLOR_BLACK)
self._field_win.bkgdset(" ", bkgd)
probView = wildcatting.view.OilFieldProbabilityView(
self._field_win, wildcatting_)
drillCostView = wildcatting.view.OilFieldDrillCostView(
self._field_win, wildcatting_, setting.getMinDrillCost(),
setting.getMaxDrillCost())
depthView = wildcatting.view.OilFieldDepthView(self._field_win,
wildcatting_)
self._views = [probView, drillCostView, depthView]
self._currentView = 0
self._week = None
self._fact = None
self._fh, self._fw = self._field_win.getmaxyx()
self._colorChooser = wildcatting.view.ColorChooser()
self._x, self._y = 0, 0
def __init__(self, frame, font_size=30, text_align=Label.CENTER, **kwargs):
View.__init__(self, frame)
self._original_image = None
self._disabled_image = None
self._checked_image = None
self.image = None
self.label = None
self.font_size = font_size
self._checked = False
self.on_tapped = Signal()
for key, value in kwargs.items():
if key == 'image':
self._original_image = value
self.image = value
if key == 'disabled_image':
self._disabled_image = value
if key == 'checked_image':
self._checked_image = value
if key == 'text':
self.label = Label(self.frame, value, self.font_size,
colors.WHITE, text_align)
def __init__(self, topoWidget):
View.__init__(self, topoWidget, "FlowTracer")
# Buttons
infoBtn = QtGui.QPushButton('What is FlowTracer?')
self.connect(infoBtn, QtCore.SIGNAL('clicked()'), self.showInfo)
traceBtn = QtGui.QPushButton('Trace!')
self.connect(traceBtn, QtCore.SIGNAL('clicked()'), self.trace_flow)
self.buttons.append(infoBtn)
self.buttons.append(traceBtn)
# Signals
self.topologyInterface.flowtracer_received_signal.connect( \
self.got_json_msg )
# Subscribe to messages from backend
msg = {}
msg["_mux"] = "gui"
msg["type"] = "flowtracer"
msg["command"] = "subscribe"
msg["msg_type"] = "highlight"
self.topologyInterface.send( msg )
self.highlighted_path = []
self.querynode = None
def __init__(self, app):
View.__init__(self, app)
self.app_window.feedview.listbox.connect('row-activated', self.show_entries)
self.app_window.feedhandler.connect("feed-updated", self.update_entryview)
self.listbox = Gtk.ListBox()
self.add(self.listbox)
def __init__(self, element, composition, timeline):
goocanvas.Group.__init__(self)
View.__init__(self)
Zoomable.__init__(self)
self.element = element
self.comp = composition
self.timeline = timeline
self.bg = goocanvas.Rect(height=self.__HEIGHT__,
fill_color_rgba=self.__NORMAL__,
line_width=0)
self.content = Preview(self.element)
self.name = goocanvas.Text(x=10,
text=os.path.basename(
unquote(element.factory.name)),
font="Sans 9",
fill_color_rgba=0x000000FF,
alignment=pango.ALIGN_LEFT)
self.start_handle = StartHandle(element,
timeline,
height=self.__HEIGHT__)
self.end_handle = EndHandle(element, timeline, height=self.__HEIGHT__)
for thing in (self.bg, self.content, self.start_handle,
self.end_handle, self.name):
self.add_child(thing)
if element:
self.zoomChanged()
self.normal()
def __init__(self, topoWidget):
View.__init__(self, topoWidget, "Monitoring")
# Monitoring view buttons
infoBtn = QtGui.QPushButton('What is Monitoring?')
self.connect(infoBtn, QtCore.SIGNAL('clicked()'), self.showInfo)
self.buttons.append(infoBtn)
for b in self.buttons:
b.setCheckable(True)
# maps tuples (dpid, port) to utilization
self.stats = {}
self.topologyInterface.monitoring_received_signal.connect( \
self.got_monitoring_msg )
# Subscribe for linkutils
msg = {}
msg["_mux"] = "gui"
msg ["type"] = "monitoring"
msg ["command"] = "subscribe"
msg ["msg_type"] = "linkutils"
self.topologyInterface.send( msg )
def __init__(self, stdscr, report):
View.__init__(self, stdscr)
self._report = report
(h, w) = self._stdscr.getmaxyx()
self._win = self._stdscr.derwin(16, 48, (h - 16) / 2, (w - 48) / 2)
def __init__(self, element, composition, timeline):
goocanvas.Group.__init__(self)
View.__init__(self)
Zoomable.__init__(self)
self.element = element
self.comp = composition
self.timeline = timeline
self.bg = goocanvas.Rect(
height=self.__HEIGHT__,
fill_color_rgba=self.__NORMAL__,
line_width=0)
self.content = Preview(self.element)
self.name = goocanvas.Text(
x=10,
text=os.path.basename(unquote(element.factory.name)),
font="Sans 9",
fill_color_rgba=0x000000FF,
alignment=pango.ALIGN_LEFT)
self.start_handle = StartHandle(element, timeline,
height=self.__HEIGHT__)
self.end_handle = EndHandle(element, timeline,
height=self.__HEIGHT__)
for thing in (self.bg, self.content, self.start_handle, self.end_handle, self.name):
self.add_child(thing)
if element:
self.zoomChanged()
self.normal()
def __init__(self, app):
View.__init__(self, app)
self.app_window.entrylist.listbox.connect('row-activated', self.show_entry_details)
self.scrolled_window.set_policy(Gtk.PolicyType.NEVER, Gtk.PolicyType.NEVER)
self.overlay = Gtk.Overlay()
self.web = WebKit.WebView()
self.web.set_size_request(300, 200)
scw = Gtk.ScrolledWindow()
scw.add(self.web)
self.overlay.add(scw)
self.add(self.overlay)
self.headline = ""
self.plot = ""
self.author = ""
self.prev_listbox = None
self.entry_id = None
image = Gtk.Image.new_from_icon_name('edit-redo-symbolic', Gtk.IconSize.BUTTON)
self.browse_button = Gtk.Button(label=" Show Article ", image=image)
self.browse_button.set_valign(Gtk.Align.END)
self.browse_button.set_halign(Gtk.Align.START)
self.browse_button.set_margin_start(20)
self.browse_button.set_margin_bottom(15)
self.browse_button.set_relief(Gtk.ReliefStyle.NONE)
self.browse_button.connect("clicked", self.browse_link)
self.browse_button.set_always_show_image (True)
self.overlay.add_overlay(self.browse_button)
self.overlay.show()
def __init__(self, parent, controller):
View.__init__(self, parent, controller)
self.mindate = datetime.date.today() - datetime.timedelta(days=30)
self.calendar = Calendar(self,
font="Comic_Sans 14",
selectmode='day',
locale='en_US',
mindate=self.mindate,
disabledforeground='red',
cursor="hand2")
self.calendar.tag_config('Komunia',
background='yellow',
foreground='black')
self.calendar.tag_config('Wesele',
background='red',
foreground='black')
self.calendar.tag_config('Spotkanie biznesowe',
background='blue',
foreground='white')
self.calendar.tag_config('Urodziny',
background='black',
foreground='yellow')
self.button_frame = tk.Frame(self)
self.buttons = []
self.__build_grid()
self.grid_columnconfigure(0, weight=1)
def __init__(self, topoWidget):
View.__init__(self, topoWidget, "Monitoring")
# Monitoring view buttons
infoBtn = QtGui.QPushButton('What is Monitoring?')
self.connect(infoBtn, QtCore.SIGNAL('clicked()'), self.showInfo)
self.buttons.append(infoBtn)
for b in self.buttons:
b.setCheckable(True)
# maps tuples (dpid, port) to utilization
self.stats = {}
self.topologyInterface.monitoring_received_signal.connect( \
self.got_monitoring_msg )
# Subscribe for linkutils
msg = {}
msg["type"] = "monitoring"
msg["command"] = "subscribe"
msg["msg_type"] = "linkutils"
self.topologyInterface.send(msg)
def __init__(self, topoWidget):
View.__init__(self, topoWidget)
self.name = "Traffic Engineering"
# TE view buttons
TTBtn = QtGui.QPushButton('&Tunnel Table')
TEDBtn = QtGui.QPushButton('Traffic Engineering &Database')
NewTunBtn = QtGui.QPushButton('New Tunnel...')
DelTunBtn = QtGui.QPushButton('Delete Tunnel...')
self.connect(TTBtn, QtCore.SIGNAL('clicked()'), self.handle_TTBtnClick)
self.connect(TEDBtn, QtCore.SIGNAL('clicked()'), self.request_TED)
self.connect(NewTunBtn, QtCore.SIGNAL('clicked()'), self.new_tunnel)
self.connect(DelTunBtn, QtCore.SIGNAL('clicked()'), self.remove_tunnel)
self.buttons.append(TTBtn)
self.buttons.append(TEDBtn)
self.buttons.append(NewTunBtn)
self.buttons.append(DelTunBtn)
self.buttons[0].setCheckable(True)
#self.buttons[2].setCheckable(True)
#self.buttons[3].setCheckable(True)
# tunnel descriptions, taken from te backend
self.tunnels = []
# backup tables, string taken from te backend
self.backup_tables = ""
# unprotected hops per tunnel, string taken from te backend
self.uprotected_hops = ""
# unaccommodated tunnels, string taken from te backend
self.unaccomodated_tunnels = ""
# latest TED, string taken from te backend
self.ted = ""
# tunnel colors (tid:color)
self.tunnel_colors = {'default':QtCore.Qt.blue,\
1:QtGui.QColor(QtCore.Qt.red),\
2:QtGui.QColor(QtCore.Qt.yellow)}
# draw tunnel? (tid:true/false)
self.tunnel_displays = {1:True, 2:True} #{0:False, 1:False}
# connect signals to slots
self.topologyInterface.tunnels_reply_received_signal.connect \
(self.show_tunnel_table)
self.topologyInterface.ted_reply_received_signal.connect \
(self.show_TED)
self.topologyInterface.link_status_change_signal.connect \
(self.update_tunnel_table)
self.popupTT = False
def __init__(self, *args):
View.__init__(self, *args)
# Recent files menu
self._recentFiles = LastValues(self.NAME, self._CONFIG_SECTION_MENU,
"recent", 5)
self._actionClearMenu = self._elements["actionClearMenu"]
self._menuRecentFiles = self._menuFile[1]
self._actionClearMenu.triggered.connect(self._recentFiles.clear)
self._actionClearMenu.triggered.connect(self._updateRecentFiles)
# Widgets
self._treeWidget = self._elements["treeWidgetInfo"]
self._tabWidget = self._elements["tabWidgetResults"]
self._tabWidget.setTabBar(ClosableTabBar())
self._widgetConsole = self._elements["widgetConsole"]
self._buttonShowConsole = self._elements["buttonShowConsole"]
self._buttonHideConsole = self._elements["buttonHideConsole"]
self._splitterConsole = self._elements["splitterConsole"]
self._buttonSaveOutput = self._elements["buttonSaveOutput"]
self._textEdit = self._elements["textEditConsole"]
self._tabs = {}
self._treeWidget.setColumnCount(2)
self._treeWidget.header().resizeSection(2, 0)
self._treeWidget.header().setHorizontalScrollMode(
QtGui.QAbstractItemView.ScrollPerPixel)
self._treeWidget.header().setResizeMode(
1, QtGui.QHeaderView.ResizeToContents)
self._treeWidget.header().setResizeMode(2, QtGui.QHeaderView.Fixed)
self._treeWidget.header().setStretchLastSection(True)
self._widgetConsole.setVisible(False)
self._buttonHideConsole.setVisible(False)
self._tabWidget.currentChanged[int].connect(self._displaySelected)
self._tabWidget.tabCloseRequested.connect(self._closeTabOfIndex)
self._buttonShowConsole.clicked.connect(self._showConsole)
self._buttonHideConsole.clicked.connect(self._hideConsole)
self._buttonSaveOutput.clicked.connect(self._saveOutput)
# Actions
self._elements["actionOpen"].triggered.connect(self._openDialog)
self._elements["actionClose"].triggered.connect(self._closeCurrentTab)
self._actionExpand = self._elements["actionExpand"]
self._actionExpandAll = self._elements["actionExpandAll"]
self._actionCollapse = self._elements["actionCollapse"]
self._actionCollapseAll = self._elements["actionCollapseAll"]
# Console channel
self._hideConsole()
consoleChannelHelper = ConsoleChannelHelper(textEdit=self._textEdit)
channels.add(ConsoleChannel,
"_ui_console",
console=consoleChannelHelper)
self._splitterConsole.handle(1).setEnabled(False)
# Tab channel
self._resultChannelHelper = ResultChannelHelper(self)
channels.add(ResultChannel,
"_ui_result",
result=self._resultChannelHelper)
def __init__(self, parent, controller):
View.__init__(self, parent, controller)
self.entry_frame = tk.Frame(self)
self.entry_frame.grid_rowconfigure(0, weight=1)
self.entry_frame.grid_columnconfigure(0, weight=1)
self.entries = {}
def __init__(self, stdscr, count):
View.__init__(self, stdscr)
self._count = count
self._textpads = []
(h, w) = self._stdscr.getmaxyx()
self._win = self._stdscr.derwin(16, 48, (h - 16) / 2, (w - 48) / 2)
def __init__(self, stdscr, gameId, isMaster, players):
View.__init__(self, stdscr)
self._gameId = gameId
self._isMaster = isMaster
self._players = players
(h, w) = self._stdscr.getmaxyx()
self._win = self._stdscr.derwin(16, 48, (h - 16) / 2, (w - 48) / 2)
def __init__(self, parent, controller):
View.__init__(self, parent, controller)
self.scroll_frame = tk.Scrollbar(self)
self.description = tk.Label(self)
self.button_frame = tk.Frame(self)
self.buttons = []
self.__build_grid()
def __init__(self, parent):
View.__init__(self, parent)
self._devices = TestDeviceList(self._elements["treeWidgetDevices"])
self._actionStart = self._elements["actionStart"]
self._actionStop = self._elements["actionStop"]
self._actionPause = self._elements["actionPause"]
self._actionResume = self._elements["actionResume"]
self._actionStart.triggered.connect(self._startTests)
self._actionStop.triggered.connect(self._stopTests)
self._actionPause.triggered.connect(self._pauseTests)
self._actionResume.triggered.connect(self._resumeTests)
self._actionStart.setVisible(True)
self._actionStop.setVisible(False)
self._actionPause.setVisible(False)
self._actionResume.setVisible(False)
# Summary channel
channels.add("SummaryChannel", "_ui_summary")
# Progress channel
pBar = QtGui.QProgressBar()
pBar.setAlignment(QtCore.Qt.AlignHCenter | QtCore.Qt.AlignVCenter)
font = pBar.font()
font.setBold(True)
pBar.setFont(font)
self._parent.getStatusBar().addPermanentWidget(pBar, 1)
self._progress = ProgressChannelHelper(pBar)
channels.add(ProgressChannel, "_ui_progress", progress=self._progress)
self._progress.testStarted.connect(self._onTestStarted)
self._progress.testStopped.connect(self._onTestStopped)
self._progress.stopped.connect(self._onStopped)
self._tests = Tests(self._elements["treeWidgetLocations"],
self._elements["treeWidgetTests"],
self._elements["treeWidgetModels"])
self._elements["actionAdd"].triggered.connect(self._tests.addLocation)
self._elements["actionRemove"].triggered.connect(
self._tests.removeLocation)
self._elements["actionExpand"].triggered.connect(
self._tests.expandSelected)
self._elements["actionExpandAll"].triggered.connect(
self._tests.expandAll)
self._elements["actionCollapse"].triggered.connect(
self._tests.collapseSelected)
self._elements["actionCollapseAll"].triggered.connect(
self._tests.collapseAll)
self._elements["actionRefresh"].triggered.connect(self._tests.refresh)
# Initialize private test variables
self._suiteRuns = 0
self._todoSuites = 0
self._testResult = None
self._testRunner = None
def __init__(self, topoWidget):
View.__init__(self, topoWidget, "Traffic Engineering")
# TE view buttons
TTBtn = QtGui.QPushButton('&Tunnel Table')
TEDBtn = QtGui.QPushButton('Traffic Engineering &Database')
NewTunBtn = QtGui.QPushButton('New Tunnel...')
DelTunBtn = QtGui.QPushButton('Delete Tunnel...')
self.connect(TTBtn, QtCore.SIGNAL('clicked()'), self.handle_TTBtnClick)
self.connect(TEDBtn, QtCore.SIGNAL('clicked()'), self.request_TED)
self.connect(NewTunBtn, QtCore.SIGNAL('clicked()'), self.new_tunnel)
self.connect(DelTunBtn, QtCore.SIGNAL('clicked()'), self.remove_tunnel)
self.buttons.append(TTBtn)
self.buttons.append(TEDBtn)
self.buttons.append(NewTunBtn)
self.buttons.append(DelTunBtn)
self.buttons[0].setCheckable(True)
#self.buttons[2].setCheckable(True)
#self.buttons[3].setCheckable(True)
# tunnel descriptions, taken from te backend
self.tunnels = []
# backup tables, string taken from te backend
self.backup_tables = ""
# unprotected hops per tunnel, string taken from te backend
self.uprotected_hops = ""
# unaccommodated tunnels, string taken from te backend
self.unaccomodated_tunnels = ""
# latest TED, string taken from te backend
self.ted = ""
# tunnel colors (tid:color)
self.tunnel_colors = {'default':QtCore.Qt.blue,\
1:QtGui.QColor(QtCore.Qt.red),\
2:QtGui.QColor(QtCore.Qt.yellow)}
# draw tunnel? (tid:true/false)
self.tunnel_displays = {1: True, 2: True} #{0:False, 1:False}
# connect signals to slots
self.topologyInterface.tunnels_reply_received_signal.connect \
(self.show_tunnel_table)
self.topologyInterface.ted_reply_received_signal.connect \
(self.show_TED)
self.topologyInterface.link_status_change_signal.connect \
(self.update_tunnel_table)
self.popupTT = False
def __init__(self, parent):
View.__init__(self, parent)
self._devices = TestDeviceList(self._elements["treeWidgetDevices"])
self._actionStart = self._elements["actionStart"]
self._actionStop = self._elements["actionStop"]
self._actionPause = self._elements["actionPause"]
self._actionResume = self._elements["actionResume"]
self._actionStart.triggered.connect(self._startTests)
self._actionStop.triggered.connect(self._stopTests)
self._actionPause.triggered.connect(self._pauseTests)
self._actionResume.triggered.connect(self._resumeTests)
self._actionStart.setVisible(True)
self._actionStop.setVisible(False)
self._actionPause.setVisible(False)
self._actionResume.setVisible(False)
# Summary channel
channels.add("SummaryChannel", "_ui_summary")
# Progress channel
pBar = QtGui.QProgressBar()
pBar.setAlignment(QtCore.Qt.AlignHCenter | QtCore.Qt.AlignVCenter)
font = pBar.font()
font.setBold(True)
pBar.setFont(font)
self._parent.getStatusBar().addPermanentWidget(pBar, 1)
self._progress = ProgressChannelHelper(pBar)
channels.add(ProgressChannel, "_ui_progress", progress=self._progress)
self._progress.testStarted.connect(self._onTestStarted)
self._progress.testStopped.connect(self._onTestStopped)
self._progress.stopped.connect(self._onStopped)
self._tests = Tests(self._elements["treeWidgetLocations"],
self._elements["treeWidgetTests"],
self._elements["treeWidgetModels"])
self._elements["actionAdd"].triggered.connect(self._tests.addLocation)
self._elements["actionRemove"].triggered.connect(
self._tests.removeLocation)
self._elements["actionExpand"].triggered.connect(
self._tests.expandSelected)
self._elements["actionExpandAll"].triggered.connect(
self._tests.expandAll)
self._elements["actionCollapse"].triggered.connect(
self._tests.collapseSelected)
self._elements["actionCollapseAll"].triggered.connect(
self._tests.collapseAll)
self._elements["actionRefresh"].triggered.connect(self._tests.refresh)
# Initialize private test variables
self._suiteRuns = 0
self._todoSuites = 0
self._testResult = None
self._testRunner = None
def __init__(self, parent, controller):
View.__init__(self, parent, controller)
self.button_frame = tk.Frame(self)
self.button_frame.grid(row=0, column=0)
self.buttons = []
self.__build_buttons()
self.grid_columnconfigure(0, weight=1)
def __init__(self, *args):
View.__init__(self, *args)
# Recent files menu
self._recentFiles = LastValues(self.NAME, self._CONFIG_SECTION_MENU,
"recent", 5)
self._actionClearMenu = self._elements["actionClearMenu"]
self._menuRecentFiles = self._menuFile[1]
self._actionClearMenu.triggered.connect(self._recentFiles.clear)
self._actionClearMenu.triggered.connect(self._updateRecentFiles)
# Widgets
self._treeWidget = self._elements["treeWidgetInfo"]
self._tabWidget = self._elements["tabWidgetResults"]
self._tabWidget.setTabBar(ClosableTabBar())
self._widgetConsole = self._elements["widgetConsole"]
self._buttonShowConsole = self._elements["buttonShowConsole"]
self._buttonHideConsole = self._elements["buttonHideConsole"]
self._splitterConsole = self._elements["splitterConsole"]
self._buttonSaveOutput = self._elements["buttonSaveOutput"]
self._textEdit = self._elements["textEditConsole"]
self._tabs = {}
self._treeWidget.setColumnCount(2)
self._treeWidget.header().resizeSection(2, 0)
self._treeWidget.header().setHorizontalScrollMode(
QtGui.QAbstractItemView.ScrollPerPixel)
self._treeWidget.header().setResizeMode(1,
QtGui.QHeaderView.ResizeToContents)
self._treeWidget.header().setResizeMode(2, QtGui.QHeaderView.Fixed)
self._treeWidget.header().setStretchLastSection(True)
self._widgetConsole.setVisible(False)
self._buttonHideConsole.setVisible(False)
self._tabWidget.currentChanged[int].connect(self._displaySelected)
self._tabWidget.tabCloseRequested.connect(self._closeTabOfIndex)
self._buttonShowConsole.clicked.connect(self._showConsole)
self._buttonHideConsole.clicked.connect(self._hideConsole)
self._buttonSaveOutput.clicked.connect(self._saveOutput)
# Actions
self._elements["actionOpen"].triggered.connect(self._openDialog)
self._elements["actionClose"].triggered.connect(self._closeCurrentTab)
self._actionExpand = self._elements["actionExpand"]
self._actionExpandAll = self._elements["actionExpandAll"]
self._actionCollapse = self._elements["actionCollapse"]
self._actionCollapseAll = self._elements["actionCollapseAll"]
# Console channel
self._hideConsole()
consoleChannelHelper = ConsoleChannelHelper(textEdit=self._textEdit)
channels.add(ConsoleChannel, "_ui_console",
console=consoleChannelHelper)
self._splitterConsole.handle(1).setEnabled(False)
# Tab channel
self._resultChannelHelper = ResultChannelHelper(self)
channels.add(ResultChannel, "_ui_result",
result=self._resultChannelHelper)
def __init__(self, instance, element, timeline, **kwargs):
self.app = instance
self.element = element
self.timeline = timeline
goocanvas.Image.__init__(self,
pixbuf=TRIMBAR_PIXBUF,
line_width=0,
**kwargs)
View.__init__(self)
Zoomable.__init__(self)
def __init__(self, element, timeline, **kwargs):
self.element = element
self.timeline = timeline
goocanvas.Rect.__init__(self,
width=5,
fill_color_rgba=0x00000022,
line_width=0,
**kwargs)
View.__init__(self)
Zoomable.__init__(self)
def __init__(self, element, timeline, **kwargs):
self.element = element
self.timeline = timeline
goocanvas.Rect.__init__(self,
width=5,
fill_color_rgba=0x00000022,
line_width=0,
**kwargs
)
View.__init__(self)
Zoomable.__init__(self)
def __init__(self, topoWidget):
View.__init__(self, topoWidget, "RAD")
#self.name = "RAD"
self.logDisplay = self.topoWidget.parent.logWidget.logDisplay
infoBtn = QtGui.QPushButton('What is RAD?')
self.connect(infoBtn, QtCore.SIGNAL('clicked()'), self.showInfo)
self.buttons.append(infoBtn)
self.nodeMenu.addAction('Draw DAG', self.draw_DAG)
def __init__(self, parent):
View.__init__(self, parent)
self._tabWidget = self._elements["tabWidget"]
self._tabWidget.currentChanged[int].connect(self._updateView)
self._tabWidget.tabCloseRequested.connect(self._close)
self._tabWidget.setTabBar(ClosableTabBar())
self._actionRefresh = self._elements["actionRefresh"]
self._actionRefreshAll = self._elements["actionRefreshAll"]
self._actionExpand = self._elements["actionExpand"]
self._actionExpandAll = self._elements["actionExpandAll"]
self._actionCollapse = self._elements["actionCollapse"]
self._actionCollapseAll = self._elements["actionCollapseAll"]
self._actionSearch = self._elements["actionSearch"]
self._actionSave = self._elements["actionSave"]
self._actionSaveAll = self._elements["actionSaveAll"]
self._actionOpen = self._elements["actionOpen"]
self._actionClose = self._elements["actionClose"]
self._actionOpen.triggered.connect(self._openDialog)
self._actionClose.triggered.connect(self._close)
# Recent files menu
self._recentFiles = LastValues(self.NAME, self._CONFIG_SECTION_MENU,
"recent", 5)
self._actionClearMenu = self._elements["actionClearMenu"]
self._menuRecentFiles = self._menuFile[1]
self._actionClearMenu.triggered.connect(self._recentFiles.clear)
self._actionClearMenu.triggered.connect(self.updateRecentFiles)
self._tabs = {}
self._offlineDevs = {}
self._readOnly = False
self.search = SearchDialog(self)
self._actionSearch.triggered.connect(self.search.run)
self._dialogs = {
'keyboard': KeyboardDialog(self),
'mouse': MouseDialog(self)
}
# widgets
self._states = self._elements["listWidgetStates"]
self._relations = self._elements["listWidgetRelations"]
self._attributes = self._elements["treeWidgetAttributes"]
self._text = self._elements["textEditText"]
self._changeText = self._elements["buttonChangeText"]
self._actions = self._elements["groupBoxActions"]
self._actionButtons = QtGui.QButtonGroup(self)
self._value = self._elements["spinBoxValue"]
self._changeValue = self._elements["buttonChangeValue"]
self._mouse = self._elements["buttonMouse"]
self._keyboard = self._elements["buttonKeyboard"]
self.clear()
def __init__(self, topoWidget):
View.__init__(self, topoWidget, "RAD")
#self.name = "RAD"
self.logDisplay = self.topoWidget.parent.logWidget.logDisplay
infoBtn = QtGui.QPushButton('What is RAD?')
self.connect(infoBtn, QtCore.SIGNAL('clicked()'), self.showInfo)
self.buttons.append(infoBtn)
self.nodeMenu.addAction( 'Draw DAG', self.draw_DAG )
def __init__(self, parent):
View.__init__(self, parent)
self._tabWidget = self._elements["tabWidget"]
self._tabWidget.currentChanged[int].connect(self._updateView)
self._tabWidget.tabCloseRequested.connect(self._close)
self._tabWidget.setTabBar(ClosableTabBar())
self._actionRefresh = self._elements["actionRefresh"]
self._actionRefreshAll = self._elements["actionRefreshAll"]
self._actionExpand = self._elements["actionExpand"]
self._actionExpandAll = self._elements["actionExpandAll"]
self._actionCollapse = self._elements["actionCollapse"]
self._actionCollapseAll = self._elements["actionCollapseAll"]
self._actionSearch = self._elements["actionSearch"]
self._actionSave = self._elements["actionSave"]
self._actionSaveAll = self._elements["actionSaveAll"]
self._actionOpen = self._elements["actionOpen"]
self._actionClose = self._elements["actionClose"]
self._actionOpen.triggered.connect(self._openDialog)
self._actionClose.triggered.connect(self._close)
# Recent files menu
self._recentFiles = LastValues(self.NAME, self._CONFIG_SECTION_MENU,
"recent", 5)
self._actionClearMenu = self._elements["actionClearMenu"]
self._menuRecentFiles = self._menuFile[1]
self._actionClearMenu.triggered.connect(self._recentFiles.clear)
self._actionClearMenu.triggered.connect(self.updateRecentFiles)
self._tabs = {}
self._offlineDevs = {}
self._readOnly = False
self.search = SearchDialog(self)
self._actionSearch.triggered.connect(self.search.run)
self._dialogs = {
'keyboard': KeyboardDialog(self),
'mouse': MouseDialog(self)
}
# widgets
self._states = self._elements["listWidgetStates"]
self._relations = self._elements["listWidgetRelations"]
self._attributes = self._elements["treeWidgetAttributes"]
self._text = self._elements["textEditText"]
self._changeText = self._elements["buttonChangeText"]
self._actions = self._elements["groupBoxActions"]
self._actionButtons = QtGui.QButtonGroup(self)
self._value = self._elements["spinBoxValue"]
self._changeValue = self._elements["buttonChangeValue"]
self._mouse = self._elements["buttonMouse"]
self._keyboard = self._elements["buttonKeyboard"]
self.clear()
def __init__(self, instance, element, timeline, **kwargs):
self.app = instance
self.element = element
self.timeline = timeline
goocanvas.Image.__init__(self,
pixbuf = TRIMBAR_PIXBUF,
line_width=0,
pointer_events=goocanvas.EVENTS_FILL,
**kwargs
)
View.__init__(self)
Zoomable.__init__(self)
def __init__(self, topoWidget):
View.__init__(self, topoWidget)
self.name = "Monitoring"
# Monitoring view buttons
mrSvcBtn = QtGui.QPushButton('&MapReduce Cluster')
storageSvcBtn = QtGui.QPushButton('&Storage Cluster')
resetSvcBtn = QtGui.QPushButton('&Reset')
infoBtn = QtGui.QPushButton('What is Monitoring?')
'''
self.connect(mrSvcBtn, QtCore.SIGNAL('clicked()'),
self.show_map_reduce_cluster)
self.connect(storageSvcBtn, QtCore.SIGNAL('clicked()'),
self.show_storage_cluster)
self.connect(resetSvcBtn, QtCore.SIGNAL('clicked()'),
self.reset_services)
'''
self.connect(infoBtn, QtCore.SIGNAL('clicked()'),
self.show_monitoring_info)
self.buttons.append(mrSvcBtn)
self.buttons.append(storageSvcBtn)
self.buttons.append(resetSvcBtn)
self.buttons.append(infoBtn)
for b in self.buttons:
b.setCheckable(True)
#self.buttons[0].setChecked(True)
self.stats = {} # maps tuples (dpid, port) to utilization
self.service_subset = set([])
self.service_name = ""
# Connect methods to signals
#self.get_port_stats_sig.connect( self.get_port_stats )
# Connect to signal from communication to handle switch query replies
#self.topologyInterface.switch_query_reply_received_signal.connect( \
# self.show_stats_reply )
#self.topologyInterface.topology_received_signal.connect( \
# self.show_topology_reply )
self.topologyInterface.monitoring_received_signal.connect( \
self.got_monitoring_msg )
# Subscribe for linkutils
msg = {}
msg ["type"] = "monitoring"
msg ["command"] = "subscribe"
msg ["msg_type"] = "linkutils"
self.topologyInterface.send( msg )
def __init__(self, environment):
View.__init__(self)
self.environ = environment
self.currmessage = ''
self.currrule = ''
#self.currdetstatus = ''
#self.currstatus = ''
self.percentage = 0
self.normal = [LogPriority.CRITICAL, LogPriority.ERROR,
LogPriority.WARNING]
self.verbose = [LogPriority.CRITICAL, LogPriority.INFO,
LogPriority.ERROR, LogPriority.WARNING]
def __init__(self, stdscr, report, field):
View.__init__(self, stdscr)
self._report = report
self._field = field
(h, w) = self._stdscr.getmaxyx()
self._win = self._stdscr.derwin(16, 48, (h - 16) / 2, (w - 48) / 2)
self._colorChooser = wildcatting.view.ProbabilityColorChooser()
# start cursor on nextPlayer prompt
self._cursorTurn = None
self._page = (report.getWeek() - 1) / 13
def __init__(self, topoWidget):
View.__init__(self, topoWidget, "Default")
self.a = QtGui.QLabel(" Toggle: (<font color='green'>N</font>)odes")
self.b = QtGui.QLabel(" Node(<font color='green'>I</font>)Ds \
Lin(<font color='green'>K</font>)s")
self.c = QtGui.QLabel(" (<font color='green'>L</font>)inkIDs \
(<font color='green'>P</font>)orts")
self.d = QtGui.QLabel(" (<font color='green'>R</font>)efresh \
Topology")
self.buttons.append(self.a)
self.buttons.append(self.b)
self.buttons.append(self.c)
self.buttons.append(self.d)
def __init__(self, instance, element, track, timeline):
goocanvas.Group.__init__(self)
View.__init__(self)
Zoomable.__init__(self)
self.app = instance
self.track = track
self.timeline = timeline
self.namewidth = 0
self.nameheight = 0
self.bg = goocanvas.Rect(height=self.height, line_width=0)
self.content = Preview(element)
self.name = goocanvas.Text(x=NAME_HOFFSET + NAME_PADDING,
y=NAME_VOFFSET + NAME_PADDING,
operator=cairo.OPERATOR_ADD,
alignment=pango.ALIGN_LEFT)
self.namebg = goocanvas.Rect(radius_x=2,
radius_y=2,
x=NAME_HOFFSET,
y=NAME_VOFFSET,
line_width=0)
self.start_handle = StartHandle(self.app,
element,
timeline,
height=self.height)
self.end_handle = EndHandle(self.app,
element,
timeline,
height=self.height)
self.selection_indicator = goocanvas.Rect(
visibility=goocanvas.ITEM_INVISIBLE,
line_width=0.0,
height=self.height)
for thing in (self.bg, self.content, self.selection_indicator,
self.start_handle, self.end_handle, self.namebg,
self.name):
self.add_child(thing)
for prop, interpolator in element.getInterpolators().itervalues():
self.add_child(Curve(instance, element, interpolator, 50))
self.element = element
self.settings = instance.settings
self.normal()
def __init__(self, instance, element, track, timeline):
goocanvas.Group.__init__(self)
View.__init__(self)
Zoomable.__init__(self)
self.app = instance
self.track = track
self.timeline = timeline
self.namewidth = 0
self.nameheight = 0
self.bg = goocanvas.Rect(
height=self.height,
line_width=1)
self.content = Preview(self.app, element)
self.name = goocanvas.Text(
x= NAME_HOFFSET + NAME_PADDING,
y= NAME_VOFFSET + NAME_PADDING,
operator = cairo.OPERATOR_ADD,
alignment=pango.ALIGN_LEFT)
self.namebg = goocanvas.Rect(
radius_x = 2,
radius_y = 2,
x = NAME_HOFFSET,
y = NAME_VOFFSET,
line_width = 0)
self.start_handle = StartHandle(self.app, element, timeline,
height=self.height)
self.end_handle = EndHandle(self.app, element, timeline,
height=self.height)
self.selection_indicator = goocanvas.Rect(
visibility=goocanvas.ITEM_INVISIBLE,
line_width = 0.0,
height=self.height)
for thing in (self.bg, self.content, self.selection_indicator,
self.start_handle, self.end_handle, self.namebg, self.name):
self.add_child(thing)
for prop, interpolator in element.getInterpolators().itervalues():
self.add_child(Curve(instance, element, interpolator))
self.element = element
self.settings = instance.settings
self.unfocus()
def __init__(self,parent=None,indexProjector=None):
QtGui.QFrame.__init__(self,parent)
View.__init__(self,parent,indexProjector,"plot")
self.hbox = QtGui.QHBoxLayout(self)
margin = 20
self.hbox.setContentsMargins(margin,margin,margin,margin)
self.dataItemY = None
self.dataItemX = None
self.initPlot()
self.hbox.addWidget(self.plot)
self.setLayout(self.hbox)
self.setAcceptDrops(True)
self.plotMode = "plot"
#self.setPixelStack()
self.setWindowSize()
self.nBins = 200
self.img = None
def __init__(self,
frame,
text,
font_size=18,
color=colors.WHITE,
halign=0,
valign=0):
View.__init__(self, frame)
self.font = Font(None, font_size)
self.halign = halign
self.valign = valign
self._text = text
self._enabled = False
self.color = color
self.layout()
def __init__(self, parent=None, indexProjector=None):
QtGui.QFrame.__init__(self, parent)
View.__init__(self, parent, indexProjector, "plot")
self.hbox = QtGui.QHBoxLayout(self)
margin = 20
self.hbox.setContentsMargins(margin, margin, margin, margin)
self.dataItemY = None
self.dataItemX = None
self.initPlot()
self.hbox.addWidget(self.plot)
self.setLayout(self.hbox)
self.setAcceptDrops(True)
self.plotMode = "plot"
#self.setPixelStack()
self.setWindowSize()
self.nBins = 200
self.img = None
def __init__(self, frame, image):
"""Create an image view from an image.
frame.topleft
where to position the view.
frame.size
if (0, 0) the frame.size is set to the image's size;
otherwise, the image is scaled to this size.
"""
assert image is not None
if frame is None:
frame = pygame.Rect((0, 0), image.get_size())
elif frame.w == 0 and frame.h == 0:
frame.size = image.get_size()
View.__init__(self, frame)
self._enabled = False
self.image = image
def __init__(self, topoWidget):
# Custom view name must be defined here
View.__init__(self, topoWidget, "STP")
# Add custom view buttons
infoBtn = QtGui.QPushButton('What is STP?')
self.connect(infoBtn, QtCore.SIGNAL('clicked()'), self.showInfo)
self.buttons.append(infoBtn)
# Connect signal raised when msg arrives from backend to handler
self.topologyInterface.spanning_tree_received_signal.connect( \
self.got_json_msg )
# Subscribe for stp_ports
msg = {}
msg["type"] = "spanning_tree"
msg["command"] = "subscribe"
msg["msg_type"] = "stp_ports"
self.topologyInterface.send(msg)
# Holds ST state (enabled links, root)
self.stp_ports = {} # Format {dpid : [port1, ..., portn]}
def __init__(self, topoWidget):
# Custom view name must be defined here
View.__init__(self, topoWidget, "STP")
# Add custom view buttons
infoBtn = QtGui.QPushButton('What is STP?')
self.connect(infoBtn, QtCore.SIGNAL('clicked()'), self.showInfo)
self.buttons.append(infoBtn)
# Connect signal raised when msg arrives from backend to handler
self.topologyInterface.spanning_tree_received_signal.connect( \
self.got_json_msg )
# Subscribe for stp_ports
msg = {}
msg ["type"] = "spanning_tree"
msg ["command"] = "subscribe"
msg ["msg_type"] = "stp_ports"
self.topologyInterface.send( msg )
# Holds ST state (enabled links, root)
self.stp_ports = {} # Format {dpid : [port1, ..., portn]}
def __init__(self, topoWidget):
# Custom view name must be defined here
View.__init__(self, topoWidget, "Routing")
# Add custom view buttons
infoBtn = QtGui.QPushButton('What is Routing?')
self.connect(infoBtn, QtCore.SIGNAL('clicked()'), self.showInfo)
self.buttons.append(infoBtn)
self.topologyInterface.routing_received_signal.connect( \
self.got_json_msg )
# Subscribe to messages from backend
msg = {}
msg["type"] = "sample_routing"
msg["command"] = "subscribe"
msg["msg_type"] = "highlight"
self.topologyInterface.send(msg)
# throw paths that we want to highlight in this queue and remove them
# after a while to restore color.
self.highlighted_paths = deque()
def __init__(self, topoWidget):
# Custom view name must be defined here
View.__init__(self, topoWidget, "Routing")
# Add custom view buttons
infoBtn = QtGui.QPushButton('What is Routing?')
self.connect(infoBtn, QtCore.SIGNAL('clicked()'), self.showInfo)
self.buttons.append(infoBtn)
self.topologyInterface.routing_received_signal.connect( \
self.got_json_msg )
# Subscribe to messages from backend
msg = {}
msg ["type"] = "sample_routing"
msg ["command"] = "subscribe"
msg ["msg_type"] = "highlight"
self.topologyInterface.send( msg )
# throw paths that we want to highlight in this queue and remove them
# after a while to restore color.
self.highlighted_paths = deque()
def __init__(self, app):
View.__init__(self, app)
self.app_window.feedhandler.connect(
"feed-add-exception",
self.exception_handling
)
listbox_entries = Gtk.ListBox()
listbox_entries.set_selection_mode(Gtk.SelectionMode.NONE)
frame_entries = Gtk.Frame()
frame_entries.add(listbox_entries)
listbox_options = Gtk.ListBox()
listbox_options.set_selection_mode(Gtk.SelectionMode.NONE)
frame_options = Gtk.Frame()
frame_options.add(listbox_options)
self.change_mode = False
self.current_feed = None
self.button_apply_changes = None
self.button_discard = None
self.button_suggest = None
def build_listbox_row(start_element, end_element):
box = Gtk.Box(orientation=Gtk.Orientation.HORIZONTAL)
box.pack_start(start_element, False, False, 15)
box.pack_end(end_element, False, False, 15)
box.set_border_width(6)
listbox_row = Gtk.ListBoxRow()
listbox_row.add(box)
return listbox_row
def build_separator_row():
sep = Gtk.Separator()
listbox_row = Gtk.ListBoxRow()
listbox_row.add(sep)
return sep
url_label = Gtk.Label("Feed-URL:")
self.url_entry = Gtk.Entry()
self.url_entry.set_width_chars(40)
self.url_entry.set_placeholder_text("Type in the URL of Feed ...")
url_listbox_row = build_listbox_row(url_label, self.url_entry)
naming_label = Gtk.Label("Set a Feed name:")
self.naming_entry = Gtk.Entry()
self.naming_entry.set_width_chars(40)
self.naming_entry.set_placeholder_text("Type in the name for Feed ...")
name_listbox_row = build_listbox_row(naming_label, self.naming_entry)
update_label = Gtk.Label("Update feed automatic")
self.update_switch = Gtk.Switch()
self.update_switch.set_active(True)
self.update_switch.connect('notify::active', self.set_update_spin_state)
update_listbox_row = build_listbox_row(update_label, self.update_switch)
update_interval_label = Gtk.Label("Choose update-interval, in minutes")
self.update_spin = Gtk.SpinButton()
adjust_interval = Gtk.Adjustment(0, 1, 120, 1, 0, 0)
self.update_spin.set_adjustment(adjust_interval)
self.update_spin.set_value(10) # default update-intervall
update_interval_listbox_row = build_listbox_row(update_interval_label, self.update_spin)
delete_label = Gtk.Label("Days, after messages will be deleted")
self.delete_spin = Gtk.SpinButton()
adjust_delete = Gtk.Adjustment(0, 1, 360, 1, 10, 0)
self.delete_spin.set_adjustment(adjust_delete)
self.delete_spin.set_value(30) # default delete-value
delete_listbox_row = build_listbox_row(delete_label, self.delete_spin)
notify_label = Gtk.Label("Enable system-notifications")
self.notify_switch = Gtk.Switch()
self.notify_switch.set_active(True)
notify_listbox_row = build_listbox_row(notify_label, self.notify_switch)
listbox_entries.add(url_listbox_row)
listbox_entries.add(build_separator_row())
listbox_entries.add(name_listbox_row)
listbox_options.add(update_listbox_row)
listbox_options.add(build_separator_row())
listbox_options.add(update_interval_listbox_row)
listbox_options.add(build_separator_row())
listbox_options.add(delete_listbox_row)
listbox_options.add(build_separator_row())
listbox_options.add(notify_listbox_row)
listbox_label_entries = Gtk.Label()
listbox_label_entries.set_markup("<b>{dates}</b>".format(dates="Dates of Feed"))
listbox_label_options = Gtk.Label()
listbox_label_options.set_markup("<b>{options}</b>".format(options="More Options"))
listbox_label_entries.set_halign(Gtk.Align.START)
listbox_label_options.set_halign(Gtk.Align.START)
listbox_label_entries.set_margin_bottom(15)
listbox_label_options.set_margin_bottom(15)
listbox_label_options.set_margin_top(30)
self._container = Gtk.Box(orientation=Gtk.Orientation.VERTICAL)
self._container.add(listbox_label_entries)
self._container.add(frame_entries)
self._container.add(listbox_label_options)
self._container.add(frame_options)
self._container.set_border_width(50)
self.add(self._container)
def __init__(self, controller, environment, logger):
"""
Constructor for the GUI class. The following __init__ statements pull
in functionality from the parent classes. The constructor requires
the controller and environment objects be passed in.
@param controller: The stonix controller object
@param environment: The stonix environment object
@author: David Kennel
"""
View.__init__(self)
QMainWindow.__init__(self)
main_window.Ui_MainWindow.__init__(self)
self.controller = controller
self.environ = environment
self.logger = logger
self.icon_path = self.environ.get_icon_path()
self.setupUi(self)
# Edit pane should be hidden / disabled by default
self.frame_rule_details.hide()
self.revert_button.setEnabled(False)
self.fix_button.setEnabled(False)
self.report_button.setEnabled(False)
# Set the title of the main window to stonix and version number
try:
self.euid = os.geteuid()
except OSError:
detailedresults = traceback.format_exc()
self.logger.log(LogPriority.DEBUG, detailedresults)
self.stonixversion = self.environ.getstonixversion()
userstr = ''
if self.euid == 0:
# for macs we say admin instead of root
userstr = 'admin'
else:
userstr = 'user'
self.setWindowTitle("STONIX-" + str(self.stonixversion) + \
" (running in " + str(userstr) + " context)")
# Connect UI events to actions
self.rule_list_widget.setSortingEnabled(True)
self.rule_list_widget.itemSelectionChanged.connect(self.rulelistselchange)
self.actionQuit.triggered.connect(self.guiexit)
self.actionRun_All.triggered.connect(self.runall)
self.actionReport_All.triggered.connect(self.reportall)
self.actionRevert_All.triggered.connect(self.revertall)
self.actionStop.triggered.connect(self.abortrun)
self.actionGuiHelp.triggered.connect(self.openHelpBrowser)
self.fix_button.clicked.connect(self.runrule)
self.report_button.clicked.connect(self.reportrule)
self.revert_button.clicked.connect(self.revertrule)
self.save_button.clicked.connect(self.savechanges)
self.cancel_button.clicked.connect(self.clearchanges)
self.actionAbout.triggered.connect(self.helpabout)
self.actionLog.triggered.connect(self.showlogbrowser)
# set up search box
self.searchbox = QLineEdit(self)
self.searchbox.resize(250, 30)
self.searchbox.move(self.width() - self.searchbox.width() - 2, 2)
self.searchbox.textEdited.connect(self.updateSearchResults)
self.searchbox.setToolTip("Search rule names and descriptions")
self.searchbox.setObjectName("SearchBox")
self.searchbox.show()
# Initialize icon variables
logicon = os.path.join(self.icon_path, "message-news.png")
exiticon = os.path.join(self.icon_path, "application-exit.png")
fixallicon = os.path.join(self.icon_path, "system-software-update.png")
reportallicon = os.path.join(self.icon_path, "system-search.png")
revertallicon = os.path.join(self.icon_path, "warning_48.png")
cancelrunicon = os.path.join(self.icon_path, "cancel.png")
helpquestionmark = os.path.join(self.icon_path, "help.ico")
# Commented out setStatusTip calls to keep them from stomping on run
# messages
self.actionLog.setIcon((QIcon(logicon)))
self.actionLog.setObjectName("actionLog")
self.actionLog.setShortcut('Ctrl+L')
#self.actionLog.setStatusTip('View Run Log')
self.actionQuit.setIcon(QIcon(exiticon))
self.actionQuit.setMenuRole(QAction.QuitRole)
self.actionQuit.setObjectName("actionQuit")
self.actionQuit.setShortcut('Ctrl+Q')
#self.actionQuit.setStatusTip('Quit application')
self.actionAbout.setObjectName("actionAbout")
self.actionRun_All.setIcon(QIcon(fixallicon))
self.actionRun_All.setObjectName("actionRun_All")
self.actionRun_All.setShortcut('Ctrl+R')
#self.actionRun_All.setStatusTip('Run Fix All')
self.actionReport_All.setIcon(QIcon(reportallicon))
self.actionReport_All.setObjectName("actionReport_All")
self.actionReport_All.setShortcut('Ctrl+G')
#self.actionReport_All.setStatusTip('Run Report All')
self.actionRevert_All.setIcon(QIcon(revertallicon))
self.actionRevert_All.setObjectName("actionRevert_All")
self.actionGuiHelp.setIcon(QIcon(helpquestionmark))
self.actionGuiHelp.setObjectName("actionGuiHelp")
self.actionGuiHelp.setShortcut('Ctrl+H')
#self.actionRevert_All.setStatusTip('Attempt to Revert All Changes')
#self.actionEdit_Selected = QtGui.QAction(MainWindow)
#self.actionEdit_Selected.setObjectName("actionEdit_Selected")
self.actionStop.setIcon(QIcon(cancelrunicon))
self.actionStop.setObjectName("actionStop")
self.actionStop.setShortcut('Ctrl+K')
#self.actionStop.setStatusTip('Stop Current Run')
self.questionmark = os.path.join(self.icon_path, "questionmark_48.png")
self.compliant = os.path.join(self.icon_path, "security-high.png")
self.notcompliant = os.path.join(self.icon_path, "security-low.png")
self.warning = os.path.join(self.icon_path, "security-medium.png")
self.toolbar = self.addToolBar('Run Controls')
self.toolbar.addAction(self.actionRun_All)
self.toolbar.addAction(self.actionReport_All)
self.toolbar.addAction(self.actionStop)
self.toolbar.addAction(self.actionGuiHelp)
self.toolbar.setToolButtonStyle(Qt.ToolButtonTextUnderIcon)
# Build rule list
self.rule_data = self.controller.getallrulesdata()
rnamelist = []
for rnum in self.rule_data:
icon = QIcon()
icon.addPixmap(QPixmap(os.path.join(self.icon_path,
self.questionmark)),
QIcon.Normal, QIcon.Off)
item = QListWidgetItem(self.rule_list_widget)
brush = QBrush(QColor(211, 211, 211, 255))
brush.setStyle(Qt.SolidPattern)
item.setBackground(brush)
item.setIcon(icon)
item.setText(self.rule_data[rnum][0])
rnamelist.append(item.text())
self.rule_list_widget.sortItems()
self.red = QColor(255, 102, 112)
self.green = QColor(153, 255, 153)
self.yellow = QColor(255, 255, 0)
# Setup a frame inside the scroll area
self.ci_container = QFrame()
self.ci_contlayout = QVBoxLayout()
# create the ciFrames
self.ruleci = {}
# print rnamelist
for rulename in rnamelist:
self.logger.log(LogPriority.DEBUG,
['gui.GUI.init',
'processing options for: ' + rulename])
rulenum = self.controller.getrulenumbyname(rulename)
self.ruleci[rulename] = CiFrame(self, rulenum, self.controller,
self.logger)
self.ci_contlayout.addWidget(self.ruleci[rulename])
self.ruleci[rulename].hide()
self.ci_container.setLayout(self.ci_contlayout)
self.conf_items_scroll_area.setWidget(self.ci_container)
self.err = None
self.rule_list_widget.setCurrentRow(0)
self.rulelistselchange()
self.threads = []
# Set up the status and progress bars
self.statusBar().showMessage('Ready')
self.pbar = QProgressBar(self.statusBar())
self.statusBar().addPermanentWidget(self.pbar)
self.raise_()
self.show()
self.searchbox.raise_()
self.getSearchText()
