class MainWindow(QMainWindow):
def __init__(self):
super().__init__()
self.setWindowTitle("Assignment")
self.scene = QGraphicsScene()
self.resize(800, 600)
self.button = QPushButton("Draw Text Boxes")
self.scene.addWidget(self.button)
self.view = QGraphicsView()
self.view.setScene(self.scene)
self.setCentralWidget(self.view)
self.button.clicked.connect(self.buttonClicked)
self.view.viewport().installEventFilter(self)
self.drawing = False
self.lastPoint = QPoint()
self.startPoint = QPoint()
def mousePressEvent(self, event):
if event.button() == Qt.LeftButton:
self.startPoint = self.view.mapToScene(event.pos())
self.drawing = True
def mouseReleaseEvent(self, event):
if Qt.LeftButton and self.drawing:
self.lastPoint = self.view.mapToScene(event.pos())
self.update()
def paintEvent(self, event):
if self.drawing :
self.view.le = QPlainTextEdit()
width = QtCore.QRectF(self.startPoint, self.lastPoint).size().width()
height = QtCore.QRectF(self.startPoint, self.lastPoint).size().height()
x = self.startPoint.x()
y = self.startPoint.y()
if width > 1 and height > 1:
self.view.le.setGeometry(x, y, width, height)
self.qsizegrip = QSizeGrip(self.view.le)
self.scene.addWidget(self.view.le)
def buttonClicked(self):
self.button.hide()
def eventFilter(self, obj, event):
if obj is self.view.viewport():
if event.type() == QEvent.MouseButtonPress:
pass
# self.mousePressEvent(event)
elif event.type() == QEvent.MouseButtonRelease:
self.mouseReleaseEvent(event)
return QWidget.eventFilter(self, obj, event)
class Main_Window(QMainWindow):
def __init__(self):
QMainWindow.__init__(self)
self.image = QPixmap("sec_shield.png")
self.item = QGraphicsPixmapItem(self.image)
self.scene = QGraphicsScene()
self.scene.addItem(self.item)
self.view = QGraphicsView()
self.view.setScene(self.scene)
self.view.show()
class MainWindow(QMainWindow):
def __init__(self):
# super(MainWindow, self).__init__()
super().__init__()
# self.ui = QMainWindow()
self.label = QLabel(f'<h1>Hello World</h1>')
self.setGeometry(10, 70, 1000, 700)
self.view = QGraphicsView()
self.scene = QGraphicsScene()
self.scene.setSceneRect(0, 0, 800, 520)
self.view.setScene(self.scene)
# greenBrush = QBrush(Qt.green)
# blueBrush = QBrush(Qt.blue)
# outlinePen = QPen(Qt.black)
# outlinePen.setWidth(2)
# self.rectangle = self.scene.addRect(100, 0, 80, 100, outlinePen, blueBrush)
# self.ellipse = self.scene.addEllipse(0, -100, 300, 60, outlinePen, greenBrush)
# self.text = self.scene.addText('Hello World')
# item = SlotItem(1);
# self.scene.addItem(item)
self.bracket1 = BracketItem(1)
self.bracket1.setPos(10, 10)
self.bracket2 = BracketItem(2)
self.bracket2.setPos(10, 300)
self.bracket3 = BracketItem(3)
self.bracket3.setPos(450, 10)
self.bracket4 = BracketItem(4)
self.bracket4.setPos(450, 300)
self.scene.addItem(self.bracket1)
self.scene.addItem(self.bracket2)
self.scene.addItem(self.bracket3)
self.scene.addItem(self.bracket4)
# self.bracket1.drawNodes()
self.setCentralWidget(self.view)
class MainWindow(QMainWindow):
def __init__(self):
QMainWindow.__init__(self)
self.game_scene = GameScene()
self.mask_scene = MaskScene(self)
self.start_scene = StartScene(self.mask_scene)
self.main_widget = QWidget()
self.graph_view = QGraphicsView(self.main_widget)
self.mask_view = QGraphicsView(self.main_widget)
self.init()
def init(self):
self.setWindowTitle('QTank')
self.resize(content_width + 20, content_height + 20)
self.game_scene.setSceneRect(0, 0, content_width, content_height)
self.graph_view.setGeometry(
QRect(5, 5, content_width + 5, content_height + 5))
self.graph_view.setScene(self.start_scene)
self.mask_view.setSceneRect(0, 0, content_width, content_height)
self.mask_view.setGeometry(
QRect(5, 5, content_width + 5, content_height + 5))
self.mask_view.setStyleSheet('background: transparent')
self.mask_view.setScene(self.mask_scene)
self.setCentralWidget(self.main_widget)
def enter_game_scene(self):
self.graph_view.setScene(self.game_scene)
def start_game(self, players: int):
self.game_scene.start(players)
class DisplayWidget(QStackedWidget):
imageClicked = Signal(int, QEvent)
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
self.max_columns = None # Set when presenter starts # Max cols for multimages
self.cached_images = {} # Cache read of image from disk
self.start()
def emitter(self, index, event):
self.imageClicked.emit(index, event)
def start(self):
# Layout for single images
self.single_image = QWidget()
self.single_image_layout = QGridLayout()
self.single_image_view = QGraphicsView()
self.single_image_scene = QGraphicsScene()
self.single_image_view.setScene(self.single_image_scene)
self.single_image_layout.addWidget(self.single_image_view)
self.single_image.setLayout(self.single_image_layout)
# Layout for multiple images
self.multiple_image = QWidget()
self.multiple_image_view_layout = QVBoxLayout()
self.multiple_image_layout = QGraphicsGridLayout()
self.multiple_image_view = QGraphicsView()
self.multiple_image_scene = QGraphicsScene()
self.multiple_image_view.setScene(self.multiple_image_scene)
self.panel = QGraphicsWidget()
self.multiple_image_scene.addItem(self.panel)
self.multiple_image_view_layout.addWidget(self.multiple_image_view)
self.panel.setLayout(self.multiple_image_layout)
self.multiple_image.setLayout(self.multiple_image_view_layout)
self.addWidget(self.single_image)
self.addWidget(self.multiple_image)
def setMaxColumns(self, max_cols):
self.max_columns = max_cols
def images_load(self, images):
""" Take list of images and display in main window """
num = len(images)
if num == 0:
return
width = self.width()
maxcol = self.max_columns
if num < maxcol:
maxcol = num
colwidth = width / maxcol
# Set proper widget for display of multiple or single images
if num > 1:
self.setCurrentWidget(self.multiple_image)
# Clear the layout
while self.multiple_image_layout.count():
self.multiple_image_layout.removeAt(0)
# Clear the scene
for child in self.panel.childItems():
child.setParent(None)
else:
self.setCurrentWidget(self.single_image)
self.single_image_scene.clear()
self.single_image_scene.setSceneRect(
self.single_image_scene.itemsBoundingRect())
# Display images or image
row = 0
col = -1
for index, image in images.items():
col += 1
if col >= maxcol:
col = 0
row += 1
# Used any cached reads
if index not in self.cached_images.keys():
image_reader = QImageReader()
image_reader.setDecideFormatFromContent(True)
image_reader.setFileName(image.getFilename())
self.cached_images[index] = image_reader.read()
cached_image = self.cached_images[index]
pixmap = QPixmap(cached_image)
if num > 1:
pixmap = pixmap.scaledToWidth(colwidth - 20)
rec = MultiImageWidget(pixmap, basename(image.getFilename()),
index)
rec.imageClicked.connect(self.emitter)
self.multiple_image_layout.addItem(rec, row, col)
else:
self.single_image_scene.addPixmap(pixmap)
adjusted = self.multiple_image_scene.itemsBoundingRect()
adjusted.adjust(0, 0, 0, 8 * row)
self.multiple_image_scene.setSceneRect(adjusted)
class QPOIViewer(QWidget):
"""
POI Viewer QWidget
"""
TAG_SPACING = 50
LEGEND_X = -50
LEGEND_Y = 0
LEGEND_WIDTH = 10
TRACE_FUNC_X = 0
TRACE_FUNC_Y = 0
TRACE_FUNC_WIDTH = 50
TRACE_FUNC_MINHEIGHT = 1000
TAB_HEADER_SIZE = 40
MAX_WINDOW_SIZE = 500
MARK_X = LEGEND_X
MARK_WIDTH = TRACE_FUNC_X - LEGEND_X + TRACE_FUNC_WIDTH
MARK_HEIGHT = 1
POIID_COLUMN = 0
CRASH_COLUMN = 1
CATEGORY_COLUMN = 2
DIAGNOSE_COLUMN = 3
COLUMN_FIELD = ['id', 'bbl', 'category', 'diagnose']
def __init__(self, workspace, parent=None, diagnose_handler=None):
super().__init__(parent=parent)
self.workspace = workspace
self._diagnose_handler = diagnose_handler
self.mark = None
self.legend = None
self.legend_height = 0
self.legend_img = None
self.trace_func_unit_height = 0
self.trace_func = None
self.trace_id = None
self.tabView = None
self.traceView = None
self.traceScene = None
self.POITraceTab = None
self.multiPOITab : QWidget = None
self.multiPOIList : QTableWidget = None
self.mark = None
self.curr_position = 0
self._use_precise_position = False
self._selected_traces = []
self._selected_poi = None
self._init_widgets()
self.selected_ins.am_subscribe(self._subscribe_select_ins)
self.poi_trace.am_subscribe(self._subscribe_set_trace)
self.multi_poi.am_subscribe(self._subscribe_add_poi)
self.multiPOIList.cellDoubleClicked.connect(self._on_cell_double_click)
self.multiPOIList.itemChanged.connect(self._on_diagnose_change)
#
# Forwarding properties
#
@property
def disasm_view(self):
"""
Get the current disassembly view (if there is one), or create a new one as needed.
"""
view = self.workspace.view_manager.current_view_in_category("disassembly")
if view is None:
view = self.workspace._get_or_create_disassembly_view()
return view
@property
def poi_trace(self):
return self.workspace.instance.poi_trace
@property
def multi_poi(self):
return self.workspace.instance.multi_poi
@property
def selected_ins(self):
return self.disasm_view.infodock.selected_insns
def _init_widgets(self):
_l.debug("QPOI Viewer Initiating")
self.tabView = QTabWidget() # QGraphicsView()
self.tabView.setContentsMargins(0, 0, 0, 0)
#
# POI trace Tab
#
self.POITraceTab = QWidget()
self.POITraceTab.setContentsMargins(0, 0, 0, 0)
singleLayout = QVBoxLayout()
singleLayout.setSpacing(0)
singleLayout.setContentsMargins(0, 0, 0, 0)
self.traceView = QGraphicsView()
self.traceScene = QGraphicsScene()
self.traceView.setScene(self.traceScene)
singleLayout.addWidget(self.traceView)
self.POITraceTab.setLayout(singleLayout)
#
# multiPOI Tab
#
self.multiPOITab = QMultiPOITab(self)
# self.multiPOITab = QWidget()
multiLayout = QVBoxLayout()
multiLayout.setSpacing(0)
multiLayout.setContentsMargins(0, 0, 0, 0)
self.multiPOIList = QTableWidget(0, 4) # row, col
self.multiPOIList.setHorizontalHeaderItem(0, QTableWidgetItem("ID"))
self.multiPOIList.setHorizontalHeaderItem(1, QTableWidgetItem("Crash Point"))
self.multiPOIList.setHorizontalHeaderItem(2, QTableWidgetItem("Tag"))
self.multiPOIList.setHorizontalHeaderItem(3, QTableWidgetItem("Diagnose"))
self.multiPOIList.horizontalHeader().setStretchLastSection(True)
self.multiPOIList.horizontalHeader().setSectionResizeMode(QHeaderView.ResizeToContents)
self.multiPOIList.setSelectionBehavior(QAbstractItemView.SelectRows)
multiLayout.addWidget(self.multiPOIList)
self.multiPOITab.setLayout(multiLayout)
self.tabView.addTab(self.multiPOITab, "POI List")
self.tabView.addTab(self.POITraceTab, "POI Trace")
self.POI_TRACE = 1
self.MULTI_POI = 0
layout = QVBoxLayout()
layout.addWidget(self.tabView)
layout.setContentsMargins(0, 0, 0, 0)
self.setLayout(layout)
self.show()
def _reset(self):
self.traceScene.clear() #clear items
self.mark = None
self.legend = None
self.legend_height = 0
self.trace_func = QGraphicsItemGroup()
self.trace_id = QGraphicsItemGroup()
self.traceScene.addItem(self.trace_func)
self.hide()
#
# Event
#
def _on_cell_double_click(self, row, _):
_l.debug("row %d is double clicked", row)
first_cell = self.multiPOIList.item(row, 0)
if first_cell is None:
return
poi_id = first_cell.text()
poi = self.multi_poi.am_obj.get_poi_by_id(poi_id)
if poi is None:
return
# sanity checks
if not isinstance(poi, dict):
return
if 'output' not in poi or not isinstance(poi['output'], dict):
return
if 'bbl_history' not in poi['output']:
return
trace = poi['output']['bbl_history']
if self._selected_poi != poi_id and trace is not None:
# render the trace
self.poi_trace.am_obj = TraceStatistics(self.workspace, trace, trace_id=poi_id)
# show the trace statistic in POI trace
self.poi_trace.am_event()
# show covered basic blocks and functions
self.multi_poi.am_obj.reload_heatmap(poi_id)
# redraw function view
view = self.workspace.view_manager.first_view_in_category('functions')
if view is not None:
view.refresh()
# redraw disassembly view
view = self.workspace.view_manager.first_view_in_category('disassembly')
if view is not None:
view.redraw_current_graph()
if trace is not None:
# switch to POI trace tab
self.tabView.setCurrentIndex(self.POI_TRACE)
self._selected_poi = poi_id
second_cell = self.multiPOIList.item(row, 1)
crash_addr = None
if second_cell is not None:
try:
crash_addr = int(second_cell.text(), 16)
except ValueError:
pass
if crash_addr is not None:
# show the crashing address
view = self.workspace.view_manager.first_view_in_category('disassembly')
if view is not None:
crash_func = self._get_func_from_addr(crash_addr)
if crash_func is not None:
self.workspace.on_function_selected(crash_func)
self.selected_ins.clear()
self.selected_ins.update([crash_addr])
self.selected_ins.am_event()
view.current_graph.show_instruction(crash_addr)
def _on_diagnose_change(self, item: QTableWidgetItem):
column = item.column()
row = item.row()
poi_id = self.multiPOIList.item(row, self.POIID_COLUMN).text()
content = item.text()
original_content = self.multi_poi.am_obj.get_content_by_id_column(poi_id, column)
_l.debug('updaing %s, content: %s, original: %s', poi_id, content, original_content)
if not self._is_identical(content, original_content):
updated_poi = self.multi_poi.update_poi(poi_id, column, content)
self._diagnose_handler.submit_updated_poi(poi_id, updated_poi)
def _subscribe_add_poi(self):
_l.debug('add a poi to multi poi list')
if self.multi_poi.am_none:
self.multi_poi.am_obj = MultiPOI(self.workspace)
poi_ids = self.multi_poi.am_obj.get_all_poi_ids()
self.multiPOIList.clearContents()
self._populate_poi_table(self.multiPOIList, poi_ids)
self.show()
def _subscribe_set_trace(self):
_l.debug('on set trace in poi trace viewer')
self._reset()
if self.poi_trace.am_none:
return
_l.debug('minheight: %d, count: %d', self.TRACE_FUNC_MINHEIGHT,
self.poi_trace.count)
if self.poi_trace.count <= 0:
_l.warning("No valid addresses found in trace to show. Check base address offsets?")
self.poi_trace.am_obj = None
self.poi_trace.am_event()
return
if self.TRACE_FUNC_MINHEIGHT < self.poi_trace.count * 15:
self.trace_func_unit_height = 15
show_func_tag = True
else:
self.trace_func_unit_height = self.TRACE_FUNC_MINHEIGHT / self.poi_trace.count
show_func_tag = True
self.legend_height = int(self.poi_trace.count * self.trace_func_unit_height)
self._show_trace_func(show_func_tag)
self._show_legend()
self._set_mark_color()
self._refresh_multi_list()
# boundingSize = self.traceScene.itemsBoundingRect().width()
# windowSize = boundingSize
# if boundingSize > self.MAX_WINDOW_SIZE:
# windowSize = self.MAX_WINDOW_SIZE
# self.traceScene.setSceneRect(self.traceScene.itemsBoundingRect()) #resize
# if windowSize > self.width():
# self.setMinimumWidth(windowSize)
self.show()
def _subscribe_select_ins(self, **kwargs): # pylint: disable=unused-argument
if self.poi_trace.am_none:
return
if self.mark is not None:
for i in self.mark.childItems():
self.mark.removeFromGroup(i)
self.traceScene.removeItem(i)
self.traceScene.removeItem(self.mark)
self.mark = QGraphicsItemGroup()
self.traceScene.addItem(self.mark)
if self.selected_ins:
addr = next(iter(self.selected_ins))
positions = self.poi_trace.get_positions(addr)
if positions: #if addr is in list of positions
# handle case where insn was selected from disas view
if not self._use_precise_position:
self.curr_position = positions[0] - self.poi_trace.count
for p in positions:
color = self._get_mark_color(p, self.poi_trace.count)
y = self._get_mark_y(p)
if p == self.poi_trace.count + self.curr_position: #add thicker line for 'current' mark
self.mark.addToGroup(self.traceScene.addRect(self.MARK_X, y, self.MARK_WIDTH,
self.MARK_HEIGHT*4,
QPen(QColor('black')), QBrush(color)))
else:
self.mark.addToGroup(self.traceScene.addRect(self.MARK_X, y, self.MARK_WIDTH,
self.MARK_HEIGHT, QPen(color), QBrush(color)))
self.traceScene.update() #force redraw of the traceScene
self.scroll_to_position(self.curr_position)
def _get_func_from_addr(self, addr):
if self.workspace.instance.cfg.am_none:
return None
bbl = self.workspace.instance.cfg.get_any_node(addr, anyaddr=True)
function_addr = bbl.function_address
return self.workspace.instance.project.kb.functions.get(function_addr)
def _populate_poi_table(self, view, poi_ids):
view.clearContents()
view.setRowCount(len(poi_ids))
row = 0 #start after label row
for poi_id in poi_ids:
poi = self.multi_poi.am_obj.get_poi_by_id(poi_id)
_l.debug('populating poi: %s', poi)
category = poi['category']
output = poi['output']
crash_addr = output['bbl']
if crash_addr is not None:
crash = hex(crash_addr)
else:
crash = None
diagnose = output.get('diagnose')
_l.debug('poi_ids: %s', poi_ids)
_l.debug('current poi id: %s', poi_id)
self._set_item(view, row, self.POIID_COLUMN, poi_id, editable=False)
self._set_item(view, row, self.CRASH_COLUMN, crash, editable=True)
self._set_item(view, row, self.CATEGORY_COLUMN, category, editable=True)
self._set_item(view, row, self.DIAGNOSE_COLUMN, diagnose, editable=True)
row += 1
_l.debug('poi_ids: %s', poi_ids)
@staticmethod
def _set_item(view, row, column, text, editable=True):
if not text:
text = ""
item = QTableWidgetItem(text)
if not editable:
item.setFlags(item.flags() ^ Qt.ItemIsEditable)
view.setItem(row, column, item)
def _refresh_multi_list(self):
multiPOI = self.multi_poi.am_obj
trace_ids = multiPOI.get_all_poi_ids()
self.multiPOIList.clearContents()
self._populate_poi_table(self.multiPOIList, trace_ids)
if self._selected_traces and self.multiPOIList.rowCount() > 0:
self.multiPOIList.item(0, 0).setSelected(True)
self.multiPOIList.item(0, 1).setSelected(True)
else:
for row in range(self.multiPOIList.rowCount()):
item = self.multiPOIList.item(row, 0)
inputItem = self.multiPOIList.item(row, 1)
if item.text() in self._selected_traces:
item.setSelected(True)
inputItem.setSelected(True)
self.multi_poi.am_event()
def _on_tab_change(self):
multiPOI = self.multi_poi.am_obj
if self.tabView.currentIndex() == self.MULTI_POI:
multiPOI.is_active_tab = True
self._refresh_multi_list()
elif self.tabView.currentIndex() == self.POI_TRACE:
multiPOI = self.multi_poi.am_obj
multiPOI.is_active_tab = False
# self._show_trace_ids()
def scroll_to_position(self, position):
relative_pos = self.poi_trace.count + position
y_offset = self._get_mark_y(relative_pos)
scrollValue = 0
if y_offset > 0.5 * self.traceView.size().height():
scrollValue = y_offset - 0.5 * self.traceView.size().height()
scrollValue = min(scrollValue, self.traceView.verticalScrollBar().maximum())
self.traceView.verticalScrollBar().setValue(scrollValue)
self._use_precise_position = False
def jump_next_insn(self):
# for some reason indexing is done backwards
if self.curr_position + self.poi_trace.count < self.poi_trace.count - 1:
self.curr_position += 1
self._use_precise_position = True
bbl_addr = self.poi_trace.get_bbl_from_position(self.curr_position)
func = self.poi_trace.get_func_from_position(self.curr_position)
self._jump_bbl(func, bbl_addr)
def jump_prev_insn(self):
if self.curr_position + self.poi_trace.count > 0:
self.curr_position -= 1
self._use_precise_position = True
bbl_addr = self.poi_trace.get_bbl_from_position(self.curr_position)
func = self.poi_trace.get_func_from_position(self.curr_position)
self._jump_bbl(func, bbl_addr)
def mousePressEvent(self, event):
button = event.button()
pos = self._to_logical_pos(event.pos())
if button == Qt.LeftButton and self.tabView.currentIndex() == self.POI_TRACE and self._at_legend(pos):
func = self._get_func_from_y(pos.y())
bbl_addr = self._get_bbl_from_y(pos.y())
self._use_precise_position = True
self.curr_position = self._get_position(pos.y())
self._jump_bbl(func, bbl_addr)
def _jump_bbl(self, func, bbl_addr):
disasm_view = self.disasm_view
if disasm_view is not None:
all_insn_addrs = self.workspace.instance.project.factory.block(bbl_addr).instruction_addrs
# TODO: replace this with am_events perhaps?
self.workspace.on_function_selected(func)
self.selected_ins.clear()
self.selected_ins.update(all_insn_addrs)
self.selected_ins.am_event()
# TODO: this ought to happen automatically as a result of the am_event
disasm_view.current_graph.show_instruction(bbl_addr)
def _get_mark_color(self, i, total):
relative_gradient_pos = i * 1000 // total
return self.legend_img.pixelColor(self.LEGEND_WIDTH // 2,
relative_gradient_pos)
def _get_mark_y(self, i):
return self.TRACE_FUNC_Y + self.trace_func_unit_height * i
def _show_trace_func(self, show_func_tag=True):
x = self.TRACE_FUNC_X
y = self.TRACE_FUNC_Y
prev_name = None
for position in self.poi_trace.trace_func:
func_name = position.func_name
color = self.poi_trace.get_func_color(func_name)
self.trace_func.addToGroup(self.traceScene.addRect(x, y,
self.TRACE_FUNC_WIDTH, self.trace_func_unit_height,
QPen(color), QBrush(color)))
if show_func_tag is True and func_name != prev_name:
tag = self.traceScene.addText(func_name, QFont("Source Code Pro", 7))
tag.setPos(x + self.TRACE_FUNC_WIDTH +
self.TAG_SPACING, y -
tag.boundingRect().height() // 2)
self.trace_func.addToGroup(tag)
anchor = self.traceScene.addLine(
self.TRACE_FUNC_X + self.TRACE_FUNC_WIDTH, y,
x + self.TRACE_FUNC_WIDTH + self.TAG_SPACING, y)
self.trace_func.addToGroup(anchor)
prev_name = func_name
y += self.trace_func_unit_height
@staticmethod
def _make_legend_gradient(x1, y1, x2, y2):
gradient = QLinearGradient(x1, y1, x2, y2)
gradient.setColorAt(0.0, Qt.red)
gradient.setColorAt(0.4, Qt.yellow)
gradient.setColorAt(0.6, Qt.green)
gradient.setColorAt(0.8, Qt.blue)
gradient.setColorAt(1.0, Qt.darkBlue)
return gradient
def _show_legend(self):
pen = QPen(Qt.transparent)
gradient = self._make_legend_gradient(self.LEGEND_X, self.LEGEND_Y,
self.LEGEND_X, self.LEGEND_Y + self.legend_height)
brush = QBrush(gradient)
self.legend = self.traceScene.addRect(self.LEGEND_X, self.LEGEND_Y,
self.LEGEND_WIDTH, self.legend_height, pen, brush)
reference_gradient = self._make_legend_gradient(0, 0, self.LEGEND_WIDTH, 1000)
base_img = QImage(self.LEGEND_WIDTH, 1000, QImage.Format.Format_ARGB32)
p = QPainter(base_img)
p.fillRect(base_img.rect(),reference_gradient)
self.legend_img = base_img #reference shade
def _set_mark_color(self):
_l.debug('trace count: %d', self.poi_trace.count)
for p in range(self.poi_trace.count):
color = self._get_mark_color(p, self.poi_trace.count)
self.poi_trace.set_mark_color(p, color)
def _at_legend(self, pos):
x = pos.x()
y = pos.y()
return self.TRACE_FUNC_X + self.LEGEND_X < x < self.traceView.width() and \
self.TRACE_FUNC_Y < y < self.TRACE_FUNC_Y + self.legend_height
def _to_logical_pos(self, pos):
x_offset = self.traceView.horizontalScrollBar().value()
y_offset = self.traceView.verticalScrollBar().value()
return QPoint(pos.x() + x_offset, pos.y() + y_offset)
def _get_position(self, y):
y_relative = y - self.legend_height - self.TAB_HEADER_SIZE
return int(y_relative // self.trace_func_unit_height)
def _get_bbl_from_y(self, y):
position = self._get_position(y)
return self.poi_trace.get_bbl_from_position(position)
def _get_func_from_y(self, y):
position = self._get_position(y)
func = self.poi_trace.get_func_from_position(position)
return func
#
# Context Menu
#
def menu_add_empty_poi(self):
_l.debug('adding a new empty poi item')
if self._diagnose_handler.get_image_id() is None:
QMessageBox.warning(self.workspace.main_window,
"No CHESS target available",
"No angr project is loaded, or you did not associate the current project with a CHESS "
"target. Please load a binary and associate it with a CHESS target before creating "
"POIs.")
return
poi_id = str(uuid4())
if self.multi_poi.am_none:
self.multi_poi.am_obj = MultiPOI(self.workspace)
empty_poi = deepcopy(EMPTY_POI)
self.multi_poi.add_poi(poi_id, empty_poi)
self.multi_poi.am_event()
self._diagnose_handler.submit_updated_poi(poi_id, empty_poi)
def menu_remove_poi(self):
items = self.multiPOIList.selectedItems()
row = items.pop().row()
poi_id = self.multiPOIList.item(row, 0).text()
_l.debug('removing ID %s', poi_id)
self.multi_poi.remove_poi(poi_id)
self.multi_poi.am_event()
@staticmethod
def _is_identical(content, original_content):
if content == original_content:
return True
if content == '' and original_content is None:
return True
try:
if int(content, 16) == int(original_content):
return True
except (TypeError, ValueError):
return False
return False
class colorPicker(QDialog):
"custom colorDialog from Orthallelous"
currentColorChanged = Signal(QColor)
colorSelected = Signal(QColor)
def __init__(self, initial=None, parent=None):
super(colorPicker, self).__init__(parent)
self.setup()
self.setColor(initial)
def currentColor(self):
return self._color
def setColor(self, qcolor=None):
if qcolor is None: self._color = QColor('#ffffff')
else: self._color = QColor(qcolor)
self._colorEdited()
@staticmethod
def getColor(initial=None, parent=None, title=None):
dialog = colorPicker(initial, parent)
if title: dialog.setWindowTitle(title)
result = dialog.exec_()
color = dialog._color
return color
def closeValid(self):
"emits colorSelected signal with valid color on OK"
self.currentColorChanged.emit(self._color)
self.colorSelected.emit(self._color)
self.close()
def closeInvalid(self):
"emits colorSelected signal with invalid color on Cancel"
self._color = QColor()
self.colorSelected.emit(QColor())
self.close()
def setOption(self, option, Bool=True):
if option == QColorDialog.NoButtons:
if not Bool:
self.dialogButtons.blockSignals(False)
self.dialogButtons.setEnabled(True)
self.dialogButtons.show()
else:
self.dialogButtons.blockSignals(True)
self.dialogButtons.setEnabled(False)
self.dialogButtons.hide()
self.setFixedSize(self.sizeHint())
def _colorEdited(self):
"internal color editing"
sender, color = self.sender(), self._color
for i in self.inputs:
i.blockSignals(True)
# get values
if sender in self.rgbInputs: # RGB
color.setRgb(*[i.value() for i in self.rgbInputs])
elif sender in self.hsvInputs: # HSV
color.setHsv(*[i.value() for i in self.hsvInputs])
elif sender in self.cmykInputs: # CMYK
color.setCmyk(*[i.value() for i in self.cmykInputs])
elif sender is self.htmlInput: # HTML
color.setNamedColor('#' + str(self.htmlInput.text()).lower())
elif sender is self.colorWheel: # WHEEL
color = self._color = self.colorWheel.getColor()
elif sender is self.colorNamesCB: # NAMED
dat = self.colorNamesCB.itemData(self.colorNamesCB.currentIndex())
try:
color = self._color = QColor(dat.toString()) # PyQt
except:
color = self._color = QColor(str(dat)) # PySide
self.colorNamesCB.setToolTip(self.colorNamesCB.currentText())
else:
pass
# set values
for i, j in zip(color.getRgb()[:-1], self.rgbInputs):
j.setValue(i)
for i, j in zip(color.getHsv()[:-1], self.hsvInputs):
j.setValue(i)
for i, j in zip(color.getCmyk()[:-1], self.cmykInputs):
j.setValue(i)
self.htmlInput.setText(color.name()[1:])
self.colorWheel.setColor(color)
idx = self.colorNamesCB.findData(color.name())
self.colorNamesCB.setCurrentIndex(idx) # will be blank if not in list
pal = self.colorDisplay.palette()
pal.setColor(self.colorDisplay.backgroundRole(), color)
self.colorDisplay.setPalette(pal)
#self.colorDisplay.setStyleSheet('background:' + color.name())
for i in self.inputs:
i.blockSignals(False)
self.currentColorChanged.emit(color)
def pickColor(self):
"pick a color on the screen, part 1"
# screenshot desktop
self._img = QApplication.primaryScreen().grabWindow(0)
self._view = QGraphicsView(self)
scene = QGraphicsScene(self) # display screenshot at full size
self._view.setWindowFlags(Qt.FramelessWindowHint)
self._view.setWindowFlags(Qt.WindowType_Mask)
self._view.setHorizontalScrollBarPolicy(Qt.ScrollBarAlwaysOff)
self._view.setVerticalScrollBarPolicy(Qt.ScrollBarAlwaysOff)
scene.addPixmap(self._img) #; self._view.setScene(scene)
self._mag = magnifier()
self._mag.setBackground(self._img)
self._mag.setSize(11, 11)
scene.addItem(self._mag)
self._view.setScene(scene)
self._appview = QApplication
self._appview.setOverrideCursor(Qt.CrossCursor)
self._view.showFullScreen()
self._view.mousePressEvent = self._pickedColor
def _pickedColor(self, event):
"pick a color on the screen, part 2"
color = QColor(self._img.toImage().pixel(event.globalPos()))
self._view.hide()
self._appview.restoreOverrideCursor()
self._color = color
self._colorEdited()
self._mag = self._appview = self._view = self._img = None
def showColors(self):
"show location of colors on color wheel"
if self.showButton.isChecked(): self.colorWheel.showNamedColors(True)
else: self.colorWheel.showNamedColors(False)
def useRandom(self, state=True):
"toggles show colors button and random color button"
if state:
self.showButton.blockSignals(True)
self.showButton.setChecked(False)
self.showButton.hide()
self.showColors()
self.rndButton.blockSignals(False)
self.rndButton.show()
else:
self.showButton.blockSignals(False)
self.showButton.show()
self.rndButton.blockSignals(True)
self.rndButton.hide()
def randomColor(self):
"select a random color"
rand = random.randint
col = QColor()
col.setHsv(rand(0, 359), rand(0, 255), rand(0, 255))
#col.setRgb(rand(0, 255), rand(0, 255), rand(0, 255))
self.setColor(col)
return col
def getNamedColors(self):
"returns a list [(name, #html)] from the named colors combobox"
lst = []
for i in range(self.colorNamesCB.count()):
name = str(self.colorNamesCB.itemText(i))
try: # PyQt
html = str(self.colorNamesCB.itemData(i).toString())
except AttributeError: # PySide
html = str(self.colorNamesCB.itemData(i))
lst.append((name, html))
return lst
def addNamedColors(self, lst):
"add a list [('name', '#html'), ] of named colors (repeats removed)"
col = self.getNamedColors() + lst
lst = [(i[0], QColor(i[1])) for i in col]
sen = set()
add = sen.add # http://stackoverflow.com/a/480227
uni = [x for x in lst if not (x[1].name() in sen or add(x[1].name()))]
self.colorNamesCB.clear()
for i, j in sorted(uni, key=lambda q: q[1].getHsv()):
icon = QPixmap(16, 16)
icon.fill(j)
self.colorNamesCB.addItem(QIcon(icon), i, j.name())
self.colorWheel.setNamedColors([(i, j.name()) for i, j in uni])
self.cNameLabel.setToolTip('Named colors\n{:,} colors'.format(
len(uni)))
def setup(self):
self.setAttribute(Qt.WA_DeleteOnClose)
fixed = QSizePolicy(QSizePolicy.Fixed, QSizePolicy.Fixed)
rightCenter = (Qt.AlignRight | Qt.AlignVCenter)
# all the input boxes
self.inputGrid = QGridLayout()
self.inputGrid.setSpacing(5)
h_spc = self.inputGrid.horizontalSpacing()
v_spc = self.inputGrid.verticalSpacing()
# RGB
self.redInput = QSpinBox()
self.grnInput = QSpinBox()
self.bluInput = QSpinBox()
self.rgbInputs = [self.redInput, self.grnInput, self.bluInput]
self.redLabel = QLabel('&R:')
self.redLabel.setToolTip('Red')
self.grnLabel = QLabel('&G:')
self.grnLabel.setToolTip('Green')
self.bluLabel = QLabel('&B:')
self.bluLabel.setToolTip('Blue')
self.rgbLabels = [self.redLabel, self.grnLabel, self.bluLabel]
self.redLabel.setBuddy(self.redInput)
self.grnLabel.setBuddy(self.grnInput)
self.bluLabel.setBuddy(self.bluInput)
# HSV
self.hueInput = QSpinBox()
self.satInput = QSpinBox()
self.valInput = QSpinBox()
self.hsvInputs = [self.hueInput, self.satInput, self.valInput]
self.hueInput.setWrapping(True)
self.hueLabel = QLabel('&H:')
self.hueLabel.setToolTip('Hue')
self.satLabel = QLabel('&S:')
self.satLabel.setToolTip('Saturation')
self.valLabel = QLabel('&V:')
self.valLabel.setToolTip('Value')
self.hsvLabels = [self.hueLabel, self.satLabel, self.valLabel]
self.hueLabel.setBuddy(self.hueInput)
self.satLabel.setBuddy(self.satInput)
self.valLabel.setBuddy(self.valInput)
# CMYK
self.cInput = QSpinBox()
self.mInput = QSpinBox()
self.yInput = QSpinBox()
self.kInput = QSpinBox()
self.cmykInputs = [self.cInput, self.mInput, self.yInput, self.kInput]
self.cLabel = QLabel('&C:')
self.cLabel.setToolTip('Cyan')
self.mLabel = QLabel('&M:')
self.mLabel.setToolTip('Magenta')
self.yLabel = QLabel('&Y:')
self.yLabel.setToolTip('Yellow')
self.kLabel = QLabel('&K:')
self.kLabel.setToolTip('Black')
self.cmykLabels = [self.cLabel, self.mLabel, self.yLabel, self.kLabel]
self.cLabel.setBuddy(self.cInput)
self.mLabel.setBuddy(self.mInput)
self.yLabel.setBuddy(self.yInput)
self.kLabel.setBuddy(self.kInput)
for i in self.rgbInputs + self.hsvInputs + self.cmykInputs:
i.setRange(0, 255)
i.setFixedSize(35, 22)
i.setAlignment(Qt.AlignCenter)
i.setButtonSymbols(QAbstractSpinBox.NoButtons)
self.hueInput.setRange(0, 359)
# HTML
self.htmlInput = QLineEdit()
self.htmlInput.setFixedSize(35 + 22 + h_spc, 22) # spans 2 cols
self.htmlInput.setPlaceholderText('html')
self.htmlInput.setAlignment(Qt.AlignCenter)
regex = QRegExp('[0-9A-Fa-f]{1,6}')
valid = QRegExpValidator(regex)
self.htmlInput.setValidator(valid)
self.htmlLabel = QLabel('&#')
self.htmlLabel.setToolTip('Web color')
self.htmlLabel.setBuddy(self.htmlInput)
self.inputLabels = (self.rgbLabels + self.hsvLabels + self.cmykLabels +
[
self.htmlLabel,
])
for i in self.inputLabels:
i.setFixedSize(22, 22)
i.setAlignment(rightCenter)
#i.setFrameShape(QFrame.Box)
self.inputs = self.rgbInputs + self.hsvInputs + self.cmykInputs
for i in self.inputs:
i.valueChanged.connect(self._colorEdited)
self.htmlInput.editingFinished.connect(self._colorEdited)
# picker button
self.pickButton = QPushButton('&Pick')
self.pickButton.setToolTip('Pick a color from the screen')
self.pickButton.setFixedSize(35, 22)
self.pickButton.clicked.connect(self.pickColor)
# color display
self.colorDisplay = QFrame()
self.colorDisplay.setFixedSize(55, 4 * 22 + 3 * v_spc) # spans 4 rows
self.colorDisplay.setFrameShape(QFrame.Panel)
self.colorDisplay.setFrameShadow(QFrame.Sunken)
self.colorDisplay.setAutoFillBackground(True)
# show button / random button
self.showButton = QPushButton('Sho&w')
self.showButton.setToolTip('Show named colors on color wheel')
self.showButton.setFixedSize(35, 22)
self.showButton.setCheckable(True)
self.showButton.clicked.connect(self.showColors)
self.rndButton = QPushButton('R&and')
self.rndButton.setToolTip('Select a random color')
self.rndButton.setFixedSize(35, 22)
self.rndButton.clicked.connect(self.randomColor)
# color wheel
self.colorWheel = wheel()
self.colorWheel.setFixedSize(256, 256) #265, 265)
self.colorWheel.currentColorChanged.connect(self.setColor)
# named colors combo box
self.colorNamesCB = QComboBox()
self.colorNamesCB.setFixedSize(70 + 66 + 4 * h_spc, 22) # spans 5 cols
#self.colorNamesCB.addItem('- Color Names -')
self.cNameLabel = QLabel('&Named:')
self.cNameLabel.setBuddy(self.colorNamesCB)
self.cNameLabel.setAlignment(rightCenter)
#self.cNameLabel.setFrameShape(QFrame.Box)
self.cNameLabel.setFixedSize(55, 22)
lst = [i for i in QColor.colorNames() if str(i) != 'transparent']
lst = [(i, QColor(i)) for i in lst]
lst.append(('Cosmic latte', '#fff8e7'))
lst.append(('rebeccapurple', '#663399'))
self.addNamedColors(lst)
self.colorNamesCB.currentIndexChanged.connect(self._colorEdited)
self.inputs += [self.htmlInput, self.colorWheel, self.colorNamesCB]
# ok/cancel buttons
self.dialogButtons = QDialogButtonBox(QDialogButtonBox.Ok
| QDialogButtonBox.Cancel)
self.dialogButtons.accepted.connect(self.closeValid)
self.dialogButtons.rejected.connect(self.closeInvalid)
self.dialogButtons.setCenterButtons(True)
# pass QColorDialog.NoButtons, False to setOption to remove
# assemble grid!
# 0 1 2 3 4 5 6
#
# color wheeeeeeeeeeeeellll 0
# disp r: rrr h: hhh c: ccc 1
# disp g: ggg s: sss m: mmm 2
# disp b: bbb v: vvv y: yyy 3
# disp ## -html- pic k: kkk 4
# name coooommmboooobox rnd 5
#.addWidget(widget, row, col, rspan, cspan)
self.inputGrid.addWidget(self.colorWheel, 0, 0, 1, 7)
self.inputGrid.addWidget(self.colorDisplay, 1, 0, 4, 1)
for i, lab in enumerate(self.rgbLabels, 1):
self.inputGrid.addWidget(lab, i, 1, 1, 1)
self.inputGrid.addWidget(self.htmlLabel, 4, 1, 1, 1)
for i, wid in enumerate(self.rgbInputs, 1):
self.inputGrid.addWidget(wid, i, 2)
self.inputGrid.addWidget(self.htmlInput, 4, 2, 1, 2)
for i, lab in enumerate(self.hsvLabels, 1):
self.inputGrid.addWidget(lab, i, 3, 1, 1)
for i, wid in enumerate(self.hsvInputs, 1):
self.inputGrid.addWidget(wid, i, 4, 1, 1)
self.inputGrid.addWidget(self.pickButton, 4, 4, 1, 1)
for i, lab in enumerate(self.cmykLabels, 1):
self.inputGrid.addWidget(lab, i, 5, 1, 1)
for i, wid in enumerate(self.cmykInputs, 1):
self.inputGrid.addWidget(wid, i, 6, 1, 1)
self.inputGrid.addWidget(self.colorNamesCB, 5, 1, 1, 5)
self.inputGrid.addWidget(self.cNameLabel, 5, 0, 1, 1)
self.inputGrid.addWidget(self.showButton, 5, 6, 1, 1)
self.inputGrid.addWidget(self.rndButton, 5, 6, 1, 1)
self.inputGrid.addWidget(self.dialogButtons, 6, 0, 1, 7)
self.setWindowTitle('Select color')
ico = self.style().standardIcon(QStyle.SP_DialogResetButton)
self.setWindowIcon(ico)
self.setLayout(self.inputGrid)
self.setFixedSize(self.sizeHint())
self.useRandom() #False)
return
spread(-self._height / 2, self._inputPortGraphics)
spread(self._height / 2, self._outputPortGraphics)
def getHeight(self):
self.updateActionRect()
return self._height
def getWidth(self):
self.updateActionRect()
return self._width
if __name__ == "__main__":
app = QApplication()
v = QGraphicsView()
s = QGraphicsScene()
v.setScene(s)
action = ComponentAction()
p1 = Port()
p2 = Port()
p3 = Port()
action.addInputPort(p1)
action.addInputPort(p2)
action.addOutputPort(p3)
A = ActionGraphics(action)
s.addItem(A)
v.show()
sys.exit(app.exec_())
class TMSTester(QMainWindow):
def __init__(self, width, height):
super(TMSTester, self).__init__(None)
self.setStyleSheet("background: transparent")
self.canvasSize = QRectF(QPointF(0, 0), QPointF(width, height))
self.view = QGraphicsView()
self.view.setTransformationAnchor(QGraphicsView.AnchorUnderMouse)
self.view.setDragMode(QGraphicsView.ScrollHandDrag)
self.scene = QGraphicsScene(0, 0, width, height, self.view)
self.view.setScene(self.scene)
self.centreCoordinate = QPointF(-32.2138204, 115.0387413)
self.zoom = 3
self.mapLayer = TMSLayer('CRUSE:World_Bathymetric_Heightmap',
self.canvasSize, self.centreCoordinate, 3)
self.mapLayerHandle = self.scene.addWidget(self.mapLayer)
self.setCentralWidget(self.view)
self.mapLayer.setFocus()
def mouseMoveEvent(self, event):
tcX = self.mapLayer.requiredTiles['left']
tcY = self.mapLayer.requiredTiles['top']
offsetX = self.mapLayer.canvasSize.width() / 2 - (
self.mapLayer.centrePoint.x() - tcX) * TILE_DIMENSION
offsetY = self.mapLayer.canvasSize.height() / 2 + (
self.mapLayer.centrePoint.y() - (tcY + 1)) * TILE_DIMENSION
xTile = tcX + ((event.pos().x() - offsetX) / 256)
yTile = (tcY + 1) - ((event.pos().y() - offsetY) / 256)
self.mapLayer.centreCoordinate = self.mapLayer.tileToGeographic(
xTile, yTile, self.mapLayer.tileZoomIndex)
print('{}'.format(self.mapLayer.centreCoordinate))
def mousePressEvent(self, event):
tcX = self.mapLayer.requiredTiles['left']
tcY = self.mapLayer.requiredTiles['top']
offsetX = self.mapLayer.canvasSize.width() / 2 - (
self.mapLayer.centrePoint.x() - tcX) * TILE_DIMENSION
offsetY = self.mapLayer.canvasSize.height() / 2 + (
self.mapLayer.centrePoint.y() - (tcY + 1)) * TILE_DIMENSION
xTile = tcX + ((event.pos().x() - offsetX) / 256)
yTile = (tcY + 1) - ((event.pos().y() - offsetY) / 256)
centreCoordinate = self.mapLayer.tileToGeographic(
xTile, yTile, self.mapLayer.tileZoomIndex)
self.mapLayer.updateCentre(centreCoordinate)
def wheelEvent(self, event):
'''
Only used for zooming.
'''
self.view.setTransformationAnchor(QGraphicsView.AnchorUnderMouse)
self.view.viewport().installEventFilter(self)
if event.delta() > 0:
self.zoom *= 1 + (event.delta() / 120) * 0.1
scale = 1 + (self.zoom % self.mapLayer.tileZoomIndex)
else:
self.zoom *= (1 + (event.delta() / 120) * 0.1)
scale = 1 / (1 + (self.zoom % self.mapLayer.tileZoomIndex))
rasterZoom = self.mapLayer.tileZoomIndex + 2**(
floor(log(self.zoom, 2)) + 0) - 1
if scale <= 2:
self.view.scale(scale, scale)
else:
self.view.scale(1 / scale, 1 / scale)
self.mapLayer.updateZoom(rasterZoom)
print('zoom:{} scale:{} raster:{}'.format(self.zoom, scale,
rasterZoom))
def eventFilter(self, qobject, event):
if (event.type() == QEvent.Wheel):
return True
else:
return False
def keyPressEvent(self, event):
if event.key() == Qt.Key_Left:
self.centreCoordinate = QPointF(
self.mapLayer.centreCoordinate.x(),
self.mapLayer.centreCoordinate.y() -
self.mapLayer.tileZoomIndex)
self.mapLayer.updateCentre(self.centreCoordinate)
if event.key() == Qt.Key_Right:
self.centreCoordinate = QPointF(
self.mapLayer.centreCoordinate.x(),
self.mapLayer.centreCoordinate.y() +
self.mapLayer.tileZoomIndex)
self.mapLayer.updateCentre(self.centreCoordinate)
if event.key() == Qt.Key_Up:
self.centreCoordinate = QPointF(
self.mapLayer.centreCoordinate.x() +
self.mapLayer.tileZoomIndex,
self.mapLayer.centreCoordinate.y())
self.mapLayer.updateCentre(self.centreCoordinate)
if event.key() == Qt.Key_Down:
self.centreCoordinate = QPointF(
self.mapLayer.centreCoordinate.x() -
self.mapLayer.tileZoomIndex,
self.mapLayer.centreCoordinate.y())
self.mapLayer.updateCentre(self.centreCoordinate)
if event.key() == Qt.Key_Z:
self.zoom *= 1.3
self.mapLayer.updateZoom(self.zoom)
if event.key() == Qt.Key_X:
self.zoom /= 1.3
self.mapLayer.updateZoom(self.zoom)
if event.key() == Qt.Key_P:
self.centreCoordinate = QPointF(-32.2138204, 115.0387413)
self.mapLayer.updateCentre(self.centreCoordinate)
if event.key() == Qt.Key_A:
self.centreCoordinate = QPointF(-35.09138204, 138.07387413)
self.mapLayer.updateCentre(self.centreCoordinate)
if event.key() == Qt.Key_M:
self.centreCoordinate = QPointF(0, 0)
self.mapLayer.updateCentre(self.centreCoordinate)
self.mapLayer.updateCanvasSize(self.canvasSize)
class QTraceViewer(QWidget):
TAG_SPACING = 50
LEGEND_X = -50
LEGEND_Y = 0
LEGEND_WIDTH = 10
TRACE_FUNC_X = 0
TRACE_FUNC_Y = 0
TRACE_FUNC_WIDTH = 50
TRACE_FUNC_MINHEIGHT = 1000
MARK_X = LEGEND_X
MARK_WIDTH = TRACE_FUNC_X - LEGEND_X + TRACE_FUNC_WIDTH
MARK_HEIGHT = 1
def __init__(self, workspace, disasm_view, parent=None):
super().__init__(parent=parent)
self.workspace = workspace
self.disasm_view = disasm_view
self.view = None
self.scene = None
self.mark = None
self.curr_position = 0
self._use_precise_position = False
self._init_widgets()
self.trace.am_subscribe(self._on_set_trace)
self.selected_ins.am_subscribe(self._on_select_ins)
self.view.installEventFilter(self)
#
# Forwarding properties
#
@property
def trace(self):
return self.workspace.instance.trace
@property
def selected_ins(self):
return self.disasm_view.infodock.selected_insns
def _init_widgets(self):
self.view = QGraphicsView()
self.scene = QGraphicsScene()
self.view.setScene(self.scene)
self._reset()
layout = QHBoxLayout()
layout.addWidget(self.view)
layout.setContentsMargins(0, 0, 0, 0)
layout.setAlignment(self.view, Qt.AlignLeft)
self.setLayout(layout)
def _reset(self):
self.scene.clear() #clear items
self.mark = None
self.legend = None
self.legend_height = 0
self.trace_func = QGraphicsItemGroup()
self.scene.addItem(self.trace_func)
self.hide()
def _on_set_trace(self, **kwargs):
self._reset()
if self.trace.am_obj is not None:
l.debug('minheight: %d, count: %d', self.TRACE_FUNC_MINHEIGHT,
self.trace.count)
if self.trace.count <= 0:
l.warning(
"No valid addresses found in trace to show. Check base address offsets?"
)
self.trace.am_obj = None
self.trace.am_event()
return
if self.TRACE_FUNC_MINHEIGHT < self.trace.count * 15:
self.trace_func_unit_height = 15
show_func_tag = True
else:
self.trace_func_unit_height = self.TRACE_FUNC_MINHEIGHT / self.trace.count
show_func_tag = True
self.legend_height = int(self.trace.count *
self.trace_func_unit_height)
self._show_trace_func(show_func_tag)
self._show_legend()
self._set_mark_color()
self.scene.setSceneRect(self.scene.itemsBoundingRect()) #resize
self.setFixedWidth(self.scene.itemsBoundingRect().width())
self.view.setFixedWidth(self.scene.itemsBoundingRect().width())
self.show()
def _on_select_ins(self, **kwargs):
if self.trace == None:
return
if self.mark is not None:
for i in self.mark.childItems():
self.mark.removeFromGroup(i)
self.scene.removeItem(i)
self.scene.removeItem(self.mark)
self.mark = QGraphicsItemGroup()
self.scene.addItem(self.mark)
if self.selected_ins:
addr = next(iter(self.selected_ins))
positions = self.trace.get_positions(addr)
if positions: #if addr is in list of positions
if not self._use_precise_position: #handle case where insn was selected from disas view
self.curr_position = positions[0] - self.trace.count
for p in positions:
color = self._get_mark_color(p, self.trace.count)
y = self._get_mark_y(p, self.trace.count)
if p == self.trace.count + self.curr_position: #add thicker line for 'current' mark
self.mark.addToGroup(
self.scene.addRect(self.MARK_X, y, self.MARK_WIDTH,
self.MARK_HEIGHT * 4,
QPen(QColor('black')),
QBrush(color)))
else:
self.mark.addToGroup(
self.scene.addRect(self.MARK_X, y, self.MARK_WIDTH,
self.MARK_HEIGHT, QPen(color),
QBrush(color)))
#y = self._get_mark_y(positions[0], self.trace.count)
#self.view.verticalScrollBar().setValue(y - 0.5 * self.view.size().height())
self.scene.update() #force redraw of the scene
self.scroll_to_position(self.curr_position)
def scroll_to_position(self, position):
relative_pos = self.trace.count + position
y_offset = self._get_mark_y(relative_pos, self.trace.count)
scrollValue = 0
if y_offset > 0.5 * self.view.size().height():
scrollValue = y_offset - 0.5 * self.view.size().height()
scrollValue = min(scrollValue, self.view.verticalScrollBar().maximum())
self.view.verticalScrollBar().setValue(scrollValue)
self._use_precise_position = False
def jump_next_insn(self):
if self.curr_position + self.trace.count < self.trace.count - 1: #for some reason indexing is done backwards
self.curr_position += 1
self._use_precise_position = True
func_name = self.trace.trace_func[self.curr_position].func_name
func = self._get_func_from_func_name(func_name)
bbl_addr = self.trace.trace_func[self.curr_position].bbl_addr
self._jump_bbl(func, bbl_addr)
def jump_prev_insn(self):
if self.curr_position + self.trace.count > 0:
self.curr_position -= 1
self._use_precise_position = True
func_name = self.trace.trace_func[self.curr_position].func_name
func = self._get_func_from_func_name(func_name)
bbl_addr = self.trace.trace_func[self.curr_position].bbl_addr
self._jump_bbl(func, bbl_addr)
def eventFilter(self, object, event): #specifically to catch arrow keys
# more elegant solution to link w/ self.view's scroll bar keypressevent?
if event.type() == QEvent.Type.KeyPress:
if not (event.modifiers() & Qt.ShiftModifier): #shift + arrowkeys
return False
key = event.key()
if key == Qt.Key_Up or key == Qt.Key_Left:
self.jump_prev_insn()
elif key == Qt.Key_Down or key == Qt.Key_Right:
self.jump_next_insn()
return True
return False # pass through all other events
def mousePressEvent(self, event):
button = event.button()
pos = self._to_logical_pos(event.pos())
if button == Qt.LeftButton and self._at_legend(pos):
func = self._get_func_from_y(pos.y())
bbl_addr = self._get_bbl_from_y(pos.y())
self._use_precise_position = True
self.curr_position = self._get_position(pos.y())
self._jump_bbl(func, bbl_addr)
def _jump_bbl(self, func, bbl_addr):
all_insn_addrs = self.workspace.instance.project.factory.block(
bbl_addr).instruction_addrs
# TODO: replace this with am_events perhaps?
self.workspace.on_function_selected(func)
self.selected_ins.clear()
self.selected_ins.update(all_insn_addrs)
self.selected_ins.am_event()
# TODO: this ought to happen automatically as a result of the am_event
self.disasm_view.current_graph.show_instruction(bbl_addr)
def _get_mark_color(self, i, total):
relative_gradient_pos = i * 1000 // total
return self.legend_img.pixelColor(self.LEGEND_WIDTH // 2,
relative_gradient_pos)
def _get_mark_y(self, i, total):
return self.TRACE_FUNC_Y + self.trace_func_unit_height * i
def _show_trace_func(self, show_func_tag):
x = self.TRACE_FUNC_X
y = self.TRACE_FUNC_Y
prev_name = None
for position in self.trace.trace_func:
bbl_addr = position.bbl_addr
func_name = position.func_name
l.debug('Draw function %x, %s', bbl_addr, func_name)
color = self.trace.get_func_color(func_name)
self.trace_func.addToGroup(
self.scene.addRect(x, y, self.TRACE_FUNC_WIDTH,
self.trace_func_unit_height, QPen(color),
QBrush(color)))
if show_func_tag is True and func_name != prev_name:
tag = self.scene.addText(func_name,
QFont("Source Code Pro", 7))
tag.setPos(x + self.TRACE_FUNC_WIDTH + self.TAG_SPACING,
y - tag.boundingRect().height() // 2)
self.trace_func.addToGroup(tag)
anchor = self.scene.addLine(
self.TRACE_FUNC_X + self.TRACE_FUNC_WIDTH, y,
x + self.TRACE_FUNC_WIDTH + self.TAG_SPACING, y)
self.trace_func.addToGroup(anchor)
prev_name = func_name
y += self.trace_func_unit_height
def _make_legend_gradient(self, x1, y1, x2, y2):
gradient = QLinearGradient(x1, y1, x2, y2)
gradient.setColorAt(0.0, Qt.red)
gradient.setColorAt(0.4, Qt.yellow)
gradient.setColorAt(0.6, Qt.green)
gradient.setColorAt(0.8, Qt.blue)
gradient.setColorAt(1.0, Qt.darkBlue)
return gradient
def _show_legend(self):
pen = QPen(Qt.transparent)
gradient = self._make_legend_gradient(
self.LEGEND_X, self.LEGEND_Y, self.LEGEND_X,
self.LEGEND_Y + self.legend_height)
brush = QBrush(gradient)
self.legend = self.scene.addRect(self.LEGEND_X, self.LEGEND_Y,
self.LEGEND_WIDTH, self.legend_height,
pen, brush)
reference_gradient = self._make_legend_gradient(
0, 0, self.LEGEND_WIDTH, 1000)
base_img = QImage(self.LEGEND_WIDTH, 1000, QImage.Format.Format_ARGB32)
p = QPainter(base_img)
p.fillRect(base_img.rect(), reference_gradient)
self.legend_img = base_img #reference shade
def _set_mark_color(self):
for p in range(self.trace.count):
color = self._get_mark_color(p, self.trace.count)
self.trace.set_mark_color(p, color)
def _at_legend(self, pos):
x = pos.x()
y = pos.y()
if self.TRACE_FUNC_X + self.LEGEND_X < x < self.view.width() and \
self.TRACE_FUNC_Y < y < self.TRACE_FUNC_Y + self.legend_height:
return True
else:
return False
def _to_logical_pos(self, pos):
x_offset = self.view.horizontalScrollBar().value()
y_offset = self.view.verticalScrollBar().value()
return QPoint(pos.x() + x_offset, pos.y() + y_offset)
def _get_position(self, y):
y_relative = y - self.legend_height
return int(y_relative // self.trace_func_unit_height)
def _get_bbl_from_y(self, y):
position = self._get_position(y)
return self.trace.get_bbl_from_position(position)
def _get_func_from_func_name(self, func_name):
return self.workspace.instance.kb.functions.function(name=func_name)
def _get_func_from_y(self, y):
position = self._get_position(y)
func_name = self.trace.get_func_name_from_position(position)
return self._get_func_from_func_name(func_name)
class Window(QMainWindow):
"""Class to create main widnow
Creates main window for displaying frame read from a connected camera.
The main window contains memu bar, tool bar, status bar, sliders and the
boxes showing the camera's information. These widget are created and added to
main window in the instance method of this class.
"""
def __init__(
self, device: int = 0, suffix: str = "png", camtype: str = "usb_cam",
color: str = "RGB", dst: str = ".", param: str = "full",
rule: str = "Sequential", parent=None):
super(Window, self).__init__(parent)
self.device = device
self.camtype = camtype
self.colorspace = color
self.image_suffix = suffix
self.video_codec = "AVC1"
self.video_suffix = "avi"
self.dst = Path(dst)
self.parent_dir = Path(__file__).parent.resolve()
self.filename_rule_lst = FileIO.file_save
self.filename_rule = FileIO.file_save_lst[-1]
self.is_display = True
self.param_separate = False
self.slot = Slot(self)
cam = self.get_cam()
self.camera = cam(self.device, self.colorspace, parent=self)
self.support_params = self.camera.get_supported_params()
self.current_params = self.camera.get_current_params(param)
# List of camera properties with temporal initial values
self.prop_table = [
["Fourcc", "aa"],
["Width", 640],
["Height", 480],
["FPS", 30.0],
["Bit depth", 8],
["File naming style", self.filename_rule]
]
self.setup()
self.set_timer()
def get_cam(self) -> str:
"""Return camera object according to current OS.
Detects what OS you are using, return camera objects in order to function properly.
- Linux: LinuxCamera
- RaspberryPi OS: RaspiCamera
- Windows: WindowsCamera
Returns:
Camera class
"""
if self.camtype == "raspi":
return RaspiCamera
self.system = platform.system()
if re.search("linux", self.system, re.IGNORECASE):
return LinuxCamera
elif re.search("windows", self.system, re.IGNORECASE):
return WindowsCamera
else:
return "Unknown type"
def setup(self):
"""Setup the main window for displaying frame and widget.
Creates a QMainWindow object, then add menubar, toolbar, statusbar, widgets and layout
into the window.
"""
self.setFocusPolicy(Qt.ClickFocus)
self.setContentsMargins(20, 0, 20, 0)
self.information_window_setup()
self.view_setup()
self.layout_setup()
self.image_setup()
self.toolbar_setup()
self.setWindowTitle("usbcamGUI")
self.update_prop_table()
self.adjust_windowsize()
self.set_theme()
def adjust_windowsize(self):
"""Adjusts the main window size
"""
system = Utility.get_os()
if system == "linux":
w, h, _ = self.get_screensize()
wscale = 0.5
hscale = 0.7
self.resize(wscale * w, hscale * h)
else:
self.resize(800, 600)
def set_theme(self):
"""Set color theme of the main window.
"""
self.style_theme = "light"
self.style_theme_sheet = ":/{}.qss".format(self.style_theme)
self.slot.switch_theme()
self.set_font(self.camera.font_family, self.camera.font_size)
def set_font(self, family: str = "Yu Gothic", size: int = 14):
"""Sets font-family and size of UI.
Args:
family (str, optional): Font-family. Defaults to "Yu Gothic".
size (int, optional): Font-size. Defaults to 20.
"""
self.setStyleSheet('font-family: "{}"; font-size: {}px;'.format(family, size))
def set_timer(self):
"""Set QTimer
Creates a QTimer object to update frame on view area. The interval is set to the inverse
of camera FPS.
"""
self.qtime_factor = 0.8
self.fps = 30.0
if self.fps:
self.msec = 1 / self.fps * 1000 * self.qtime_factor
else:
self.msec = 1 / 30.0 * 1000 * self.qtime_factor
self.timer = QTimer()
self.timer.setInterval(self.msec)
self.timer.timeout.connect(self.next_frame)
self.timer.start()
def stop_timer(self):
"""Deactivate the Qtimer object.
"""
self.timer.stop()
def start_timer(self):
"""Activate the Qtimer object.
"""
self.fps = 30.0
if self.fps:
self.msec = 1 / self.fps * 1000 * self.qtime_factor
else:
self.msec = 1 / 30.0 * 1000 * self.qtime_factor
self.timer.setInterval(self.msec)
self.timer.start()
def toolbar_setup(self):
"""Create toolbar
"""
self.toolbar = QToolBar("test", self)
self.addToolBar(self.toolbar)
current_size = str(self.font().pointSize())
lst = [str(i) for i in range(6, 14)]
lst.extend([str(i) for i in range(14, 40, 2)])
index = lst.index(current_size)
self.fontsize_combo = QComboBox()
self.fontsize_combo.addItems(lst)
self.fontsize_combo.setCurrentIndex(index)
self.fontsize_combo.currentTextChanged.connect(self.slot.set_fontsize)
self.fontsize_label = QLabel("Font size")
self.fontsize_label.setFrameShape(QFrame.Box)
self.comb = QFontComboBox()
self.toolbar.addWidget(self.save_button)
self.toolbar.addWidget(self.stop_button)
self.toolbar.addWidget(self.rec_button)
self.toolbar.addWidget(self.close_button)
self.toolbar.addWidget(self.theme_button)
self.toolbar.addWidget(self.help_button)
self.toolbar.addWidget(self.fontsize_label)
self.toolbar.addWidget(self.fontsize_combo)
self.toolbar.setStyleSheet(
"""
QToolBar {spacing:5px;}
"""
)
def view_setup(self):
"""Set view area to diplay read frame in part of the main window
"""
self.view = QGraphicsView()
self.scene = QGraphicsScene()
self.view.setScene(self.scene)
self.width = 640
self.height = 480
self.scene.setSceneRect(0, 0, self.width, self.height)
self.view.setMouseTracking(True)
self.view.setSizeAdjustPolicy(QAbstractScrollArea.AdjustToContents)
self.view.setCacheMode(QGraphicsView.CacheBackground)
self.view.setViewportUpdateMode(QGraphicsView.SmartViewportUpdate)
def layout_setup(self):
"""Set layout of objects on the window.
"""
self.window = QWidget()
self.setCentralWidget(self.window)
#self.view.mouseMoveEvent = self.get_coordinates
self.main_layout = QHBoxLayout()
self.window.setLayout(self.main_layout)
self.add_actions()
self.add_menubar()
self.add_statusbar()
self.button_block = self.add_buttons()
self.slider_group = self.add_params()
self.prop_block = self.add_prop_window()
self.create_mainlayout()
def image_setup(self):
"""Creates a Qimage to assign frame, then initialize with an image which has zero in all pixels.
"""
self.frame = np.zeros((640, 480, 3), dtype=np.uint8)
#cinit = np.ctypeslib.as_ctypes(self.frame)
#self.frame.buffer = sharedctypes.RawArray(cinit._type_, cinit)
self.qimage = QImage(
self.frame.data,
640,
480,
640 * 3,
QImage.Format_RGB888
)
self.pixmap = QPixmap.fromImage(self.qimage)
def add_actions(self):
"""Add actions executed when press each item in the memu window.
"""
self.save_act = self.create_action("&Save", self.save_frame, "Ctrl+s")
self.stop_act = self.create_action("&Pause", self.stop_frame, "Ctrl+p", checkable=True)
self.rec_act = self.create_action("&Record", self.record, "Ctrl+r", True)
self.quit_act = self.create_action("&Quit", self.slot.quit, "Ctrl+q")
self.theme_act = self.create_action("Switch &Theme", self.slot.switch_theme, "Ctrl+t")
self.param_act = self.create_action("Choose parameter slider", self.slot.switch_paramlist, "Ctrl+g")
self.show_paramlist_act = self.create_action("Parameters &List", self.slot.show_paramlist, "Ctrl+l")
self.show_shortcut_act = self.create_action("&Keybord shortcut", self.slot.show_shortcut, "Ctrl+k")
self.font_act = self.create_action("&Font", self.slot.set_font, "Ctrl+f")
self.usage_act = self.create_action("&Usage", self.slot.usage, "Ctrl+h")
self.about_act = self.create_action("&About", self.slot.about, "Ctrl+a")
def create_action(self, text: str, slot: Callable, key: str = None, checkable: bool = False,
check_defalut: bool = False) -> QAction:
"""Create a QAction object.
Args:
text (str): Text shown on menu.
slot (Callable): A method called when click the menu.
key (str, optional): Shortcut key. Defaults to None.
checkable (bool, optional): Add a checkbox into the menu. Defaults to False.
check_defalut (bool, optional): Check default status. Defaults to False.
Returns:
QAction: PySide2 QAction
"""
act = QAction(text)
act.setShortcut(key)
if checkable:
act.setCheckable(True)
act.setChecked(check_defalut)
act.toggled.connect(slot)
else:
act.triggered.connect(slot)
return act
def add_menubar(self):
"""Create menu bar, then add to the main window.
"""
self.menubar = QMenuBar()
self.setMenuBar(self.menubar)
self.file_tab = QMenu("&File")
self.file_tab.addAction(self.save_act)
self.file_tab.addAction(self.stop_act)
self.file_tab.addAction(self.rec_act)
self.file_tab.addSeparator()
self.file_tab.addAction(self.quit_act)
#self.file_tab.setSizePolicy(policy)
self.view_tab = QMenu("&View")
self.view_tab.addAction(self.theme_act)
self.view_tab.addAction(self.font_act)
self.view_tab.addAction(self.param_act)
self.view_tab.addAction(self.show_shortcut_act)
self.view_tab.addAction(self.show_paramlist_act)
self.help_tab = QMenu("&Help")
self.help_tab.addAction(self.usage_act)
self.help_tab.addAction(self.about_act)
self.menubar.addMenu(self.file_tab)
self.menubar.addMenu(self.view_tab)
self.menubar.addMenu(self.help_tab)
self.menubar.setStyleSheet(
"""
QMenuBar {
font-size: 16px;
spacing:10px;
padding-top: 5px;
padding-bottom: 10px;
}
"""
)
def add_statusbar(self):
"""Create status bar, then add to the main window.
The status bar shows the coordinates on the frame where the cursor is located and
its pixel value. The pixel value has RGB if the format of is color (RGB), does grayscale
value if grayscale.
"""
self.statbar_list = []
if self.colorspace == "rgb":
self.stat_css = {
"postion": "color: white",
"R": "color: white;",
"G": "color: white;",
"B": "color: white;",
"alpha": "color: white;",
}
else:
self.stat_css = {
"postion": "color: black;",
"gray": "color: black"
}
for s in self.stat_css.values():
stat = QStatusBar(self)
stat.setStyleSheet(s)
self.statbar_list.append(stat)
first = True
for stat in self.statbar_list:
if first:
self.setStatusBar(stat)
self.statbar_list[0].reformat()
first = False
else:
self.statbar_list[0].addPermanentWidget(stat)
def add_buttons(self):
"""Add push buttons on the window.
Add quit, save stop and usage buttons on the windows. When press each button, the set
method (called "slot" in Qt framework) are execeuted.
"""
self.save_button = self.create_button("&Save", self.save_frame, None, None, "Save the frame")
self.stop_button = self.create_button("&Pause", self.stop_frame, None, None, "Stop reading frame", True)
self.rec_button = self.create_button("&Rec", self.record, None, None, "Start recording", True)
self.close_button = self.create_button("&Quit", self.slot.quit, None, None, "Quit the program")
self.theme_button = self.create_button("Light", self.slot.switch_theme, None, None, "Switche color theme")
self.help_button = self.create_button("&Usage", self.slot.usage, None, None, "Show usage")
self.frame_button = self.create_button(
"Properties",
self.slot.change_frame_prop,
None,
tip="Change properties",
minsize=(150, 30)
)
self.default_button = self.create_button(
"&Default params",
self.set_param_default,
"Ctrl+d",
tip="Set default parameters",
minsize=(150, 30)
)
self.filerule_button = self.create_button(
"&Naming style",
self.slot.set_file_rule,
"Ctrl+n",
tip="Change naming style",
minsize=(150, 30)
)
hbox = QHBoxLayout()
hbox.addWidget(self.save_button)
hbox.addWidget(self.stop_button)
hbox.addWidget(self.rec_button)
hbox.addWidget(self.close_button)
hbox.addWidget(self.theme_button)
hbox.addWidget(self.help_button)
return hbox
def create_button(self, text: str, slot: Callable, key: str = None, icon: Icon = None,
tip: str = None, checkable: bool = False, minsize: tuple = None) -> QPushButton:
"""Create a QPushButton object.
Args:
text (str): Text shown on the button.
slot (Callable): A method called when click the button.
key (str, optional): Shortcut key. Defaults to None.
icon (Icon, optional): An icon shown on the button. Defaults to None.
tip (str, optional): A tips shown when position the pointer on the button. Defaults to None.
checkable (bool, optional): Add button to checkbox. Defaults to False.
msize (tuple, optional): Minimum size of the button box, (width, height).
Returns:
QPushButton: PySide2 QPushButton
"""
button = QPushButton(text)
if checkable:
button.setCheckable(True)
button.toggled.connect(slot)
else:
button.clicked.connect(slot)
if key:
button.setShortcut(key)
if icon:
button.setIcon(QIcon(icon))
if tip:
button.setToolTip(tip)
if minsize:
button.setMinimumSize(minsize[0], minsize[1])
else:
button.setMinimumSize(80, 30)
return button
def add_params(self) -> QGridLayout:
"""Set the properties of camera parameter.
Set the properties of camera parameter, then add sliders to change each parameter.
When change value on the slider, the value of paramter also changes by the caller
function.
"""
lst = self.current_params
for key, value in lst.items():
self.add_slider(key)
# add sliders
self.slider_table = QGridLayout()
self.slider_table.setSpacing(15)
self.slider_table.setContentsMargins(20, 20, 20, 20)
for row, param in enumerate(self.current_params):
self.slider_table.addWidget(self.current_params[param]["slider_label"], row, 0)
self.slider_table.addWidget(self.current_params[param]["slider"], row, 1)
self.slider_table.addWidget(self.current_params[param]["slider_value"], row, 2)
if len(self.current_params) > 15:
self.param_separate = True
else:
self.param_separate = False
return self.slider_table
def update_params(self, plist: list) -> QGridLayout:
"""Update camera's paramters and sliders shown on the windows.
"""
#self.current_params.clear()
self.current_params = self.camera.get_current_params("selected", plist)
for key, value in self.current_params.items():
self.add_slider(key)
# add sliders
grid = QGridLayout()
grid.setSpacing(15)
grid.setContentsMargins(20, 20, 20, 20)
for row, param in enumerate(self.current_params):
grid.addWidget(self.current_params[param]["slider_label"], row, 0)
grid.addWidget(self.current_params[param]["slider"], row, 1)
grid.addWidget(self.current_params[param]["slider_value"], row, 2)
if len(self.current_params) > 15:
self.param_separate = True
else:
self.param_separate = False
self.slider_group = grid
self.update_mainlayout()
self.update_prop_table()
self.write_text("update sliders")
return grid
def add_slider(self, param: str):
"""Creates slider, labels to show pamarater's name and its value.
Args:
param (str): A parameter to create slider.
"""
min_ = self.current_params[param]["min"]
max_ = self.current_params[param]["max"]
step = self.current_params[param]["step"]
value = self.current_params[param]["value"]
slider = QSlider(Qt.Horizontal)
if max_:
slider.setRange(min_, max_)
else:
slider.setRange(0, 1)
slider.setValue(int(value))
slider.setTickPosition(QSlider.TicksBelow)
slider.valueChanged.connect(lambda val, p=param: self.set_sliderval(p, val))
if step:
if max_ < 5:
slider.setTickInterval(step)
else:
slider.setTickInterval(10)
slider_label = QLabel(param)
slider_value = QLabel(str(value))
slider_label.setAlignment(Qt.AlignLeft | Qt.AlignVCenter)
slider_value.setAlignment(Qt.AlignLeft | Qt.AlignVCenter)
self.current_params[param]["slider"] = slider
self.current_params[param]["slider_label"] = slider_label
self.current_params[param]["slider_value"] = slider_value
def add_prop_window(self) -> QGridLayout:
"""Create a table to show the current properties of camera.
Returns:
QGridLayout: PySide2 QGridLayout
"""
header = ["property", "value"]
self.prop_table_widget = QTableWidget(self)
self.prop_table_widget.setColumnCount(len(header))
self.prop_table_widget.setRowCount(len(self.prop_table))
self.prop_table_widget.setHorizontalHeaderLabels(header)
self.prop_table_widget.verticalHeader().setVisible(False)
self.prop_table_widget.setAlternatingRowColors(True)
self.prop_table_widget.horizontalHeader().setStretchLastSection(True)
self.prop_table_widget.setEditTriggers(QAbstractItemView.NoEditTriggers)
self.prop_table_widget.setFocusPolicy(Qt.NoFocus)
for row, content in enumerate(self.prop_table):
for col, elem in enumerate(content):
self.item = QTableWidgetItem(elem)
self.prop_table_widget.setItem(row, col, self.item)
self.prop_table_widget.setSizePolicy(QSizePolicy.Minimum, QSizePolicy.Minimum)
#self.prop_table_widget.resizeColumnsToContents()
#self.prop_table_widget.resizeRowsToContents()
self.prop_table_widget.setVerticalScrollBarPolicy(Qt.ScrollBarAlwaysOff)
self.prop_table_widget.setHorizontalScrollBarPolicy(Qt.ScrollBarAlwaysOff)
self.prop_table_widget.setSizeAdjustPolicy(QAbstractScrollArea.AdjustToContentsOnFirstShow)
self.prop_table_widget.setColumnWidth(0, 150)
self.prop_table_widget.setColumnWidth(1, 150)
vbox = QVBoxLayout()
vbox.addWidget(self.prop_table_widget)
vbox.setContentsMargins(20, 20, 20, 20)
self.prop_group = QGroupBox("Frame Properties")
self.prop_group.setLayout(vbox)
return self.prop_group
def information_window_setup(self):
"""Creates information window.
Creates the information window where the event related to camera or window.
"""
self.text_edit = QTextEdit()
self.text_edit.setReadOnly(True)
self.text_edit.show()
vbox = QVBoxLayout()
vbox.addWidget(self.text_edit)
self.text_edit_box = QGroupBox("Information", self)
self.text_edit_box.setLayout(vbox)
self.text_edit_box.setAlignment(Qt.AlignLeft)
def create_mainlayout(self):
"""Create the main layout which consists of view area and information window.
"""
self.main_layout.addLayout(self.create_view_area_layout())
self.main_layout.addLayout(self.create_information_layout())
def update_mainlayout(self):
"""Recreate the main layout.
"""
self.delete_layout(self.information_layout)
self.delete_layout(self.upper_right)
self.add_prop_window()
self.main_layout.addLayout(self.create_information_layout())
def delete_layout(self, layout):
"""Delete layout
Args:
layout (QBoxLayout): QBoxLayout class object to delete
"""
while layout.count():
child = layout.takeAt(0)
if child.widget():
child.widget().deleteLater()
try:
child.spacerIitem().deleteLater()
except:
pass
def create_view_area_layout(self) -> QVBoxLayout:
"""Creates view area layout
"""
self.view_area_layout = QVBoxLayout()
self.view_area_layout.addWidget(self.view, 2)
self.view_area_layout.addWidget(self.text_edit_box)
return self.view_area_layout
def create_information_layout(self):
"""Creates information part layout
upper-left: current properties
upper-right: buttons
lower: sliders
"""
if self.param_separate:
self.entry_box = QVBoxLayout()
self.entry_box.addWidget(self.frame_button)
self.entry_box.addWidget(self.filerule_button)
self.entry_box.addWidget(self.default_button)
self.entry_box.addStretch(1)
self.entry_box.setSpacing(20)
self.entry_box.setContentsMargins(20, 20, 20, 20)
self.button_group_box = QGroupBox("Buttons", self)
self.button_group_box.setLayout(self.entry_box)
self.button_group_box.setAlignment(Qt.AlignLeft)
self.upper_right = QVBoxLayout()
self.upper_right.addWidget(self.prop_group, 1)
self.upper_right.addWidget(self.button_group_box, 1)
self.slider_group_box = QGroupBox("Parameters")
self.slider_group_box.setLayout(self.slider_group)
self.slider_group_box.setContentsMargins(20, 20, 20, 20)
self.information_layout = QHBoxLayout()
self.information_layout.addLayout(self.upper_right, 1)
self.information_layout.addWidget(self.slider_group_box, 2)
#self.information_layout.addStretch(1)
return self.information_layout
else:
self.entry_box = QVBoxLayout()
self.entry_box.addWidget(self.frame_button)
self.entry_box.addWidget(self.filerule_button)
self.entry_box.addWidget(self.default_button)
self.entry_box.addStretch(1)
self.entry_box.setSpacing(20)
self.entry_box.setContentsMargins(20, 20, 20, 20)
self.button_group_box = QGroupBox("Buttons", self)
self.button_group_box.setLayout(self.entry_box)
self.button_group_box.setAlignment(Qt.AlignLeft)
self.upper_right = QHBoxLayout()
self.upper_right.addWidget(self.prop_group)
self.upper_right.addWidget(self.button_group_box)
self.slider_group_box = QGroupBox("Parameters")
self.slider_group_box.setLayout(self.slider_group)
self.slider_group_box.setContentsMargins(20, 20, 20, 20)
self.information_layout = QVBoxLayout()
self.information_layout.addLayout(self.upper_right)
self.information_layout.addWidget(self.slider_group_box)
self.information_layout.setSpacing(30)
return self.information_layout
# decorator
def display(func):
def wrapper(self, *args, **kwargs):
try:
self.is_display = False
self.stop_timer()
func(self, *args, **kwargs)
finally:
self.is_display = True
self.start_timer()
return wrapper
def stop_frame(self, checked: bool):
"""Stop reading next frame.
Args:
checked (bool): True when presse the Stop button (toggle on). False when press
again (toggel off).
"""
if checked:
self.write_text("Stop !!")
self.is_display = False
self.stop_button.setText('Start')
self.stop_button.setChecked(True)
self.stop_act.setText('Start')
self.stop_act.setChecked(True)
else:
self.write_text("Start !!")
self.is_display = True
self.stop_button.setText('&Pause')
self.stop_button.setChecked(False)
self.stop_act.setText('&Pause')
self.stop_act.setChecked(False)
def keyPressEvent(self, event):
"""Exit the program
This method will be called when press the Escape key on the window.
"""
if event.key() == Qt.Key_Escape:
QApplication.quit()
def get_coordinates(self, event):
"""Show the current coordinates and value in the pixel where the cursor is located.
The status bar is updates by the obtained values.
"""
if self.item is self.view.itemAt(event.pos()):
sp = self.view.mapToScene(event.pos())
lp = self.item.mapFromScene(sp).toPoint()
(x, y) = lp.x(), lp.y()
#color = self.frame.image.pixel(x, y)
color = self.qimage.pixelColor(x, y)
if self.colorspace == "rgb":
value = color.getRgb()
elif self.colorspace == "gray":
value = color.value()
# Return none if the coordinates are out of range
if x < 0 and self.frame.width < x:
return
elif y < 0 and self.frame.height < y:
return
if self.frame.img_is_rgb:
status_list = [
"( x : {}, y :{} )".format(x, y),
"R : {}".format(value[0]),
"G : {}".format(value[1]),
"B : {}".format(value[2]),
"alpha : {}".format(value[3])
]
else:
status_list = [
"( x : {}, y :{} )".format(x, y),
"gray value : {}".format(value),
]
for statbar, stat in zip(self.statbar_list, status_list):
statbar.showMessage(stat)
def next_frame(self):
"""Get next frame from the connected camera.
Get next frame, set it to the view area and update.
"""
#print("display :", self.is_display)
if self.is_display:
self.camera.read_frame()
self.convert_frame()
self.scene.clear()
self.scene.addPixmap(self.pixmap)
self.update()
#print("update")
def convert_frame(self):
"""Convert the class of frame
Create qimage, qpixmap objects from ndarray frame for displaying on the window.
"""
if self.colorspace == "rgb":
self.qimage = QImage(
self.camera.frame.data,
self.camera.frame.shape[1],
self.camera.frame.shape[0],
self.camera.frame.shape[1] * 3,
QImage.Format_RGB888
)
elif self.colorspace == "gray":
self.qimage = QImage(
self.camera.frame.data,
self.camera.frame.shape[1],
self.camera.frame.shape[0],
self.camera.frame.shape[1] * 1,
QImage.Format_Grayscale8)
self.pixmap.convertFromImage(self.qimage)
def save_frame(self):
"""Save the frame on the window as an image.
"""
if self.filename_rule == "Manual":
self.save_frame_manual()
if not self.filename:
return None
prm = re.sub(r"\.(.*)", ".csv", str(self.filename))
else:
self.filename = FileIO.get_filename(self.filename_rule, self.image_suffix, self.parent_dir)
prm = str(self.filename).replace(self.image_suffix, "csv")
if not self.dst.exists():
self.dst.mkdir(parents=True)
im = Image.fromarray(self.camera.frame)
im.save(self.filename)
# make a parameter file
with open(prm, "w") as f:
for name, key in self.current_params.items():
f.write("{},{}\n".format(name, self.current_params[name]["value"]))
self.write_text("{:<10}: {}".format("save image", self.filename))
self.write_text("{:<10}: {}".format("save param", prm))
def update_prop_table(self):
"""Updates the table that shows the camera properties.
"""
w, h, cc, f = self.camera.get_properties()
self.prop_table = [
["Fourcc", cc],
["Width", int(w)],
["Height", int(h)],
["FPS", "{:.1f}".format(f)],
["Bit depth", 8],
["Naming Style", self.filename_rule]
]
col = 1
for row in range(len(self.prop_table)):
text = str(self.prop_table[row][col])
self.prop_table_widget.item(row, col).setText(text)
def record(self):
"""Start or end recording
"""
if self.camera.is_recording:
self.camera.stop_recording()
self.rec_button.setText('&Rec')
self.rec_act.setText('&Record')
self.write_text("save : {}".format(self.video_filename))
else:
self.video_filename = FileIO.get_filename(self.filename_rule, self.video_suffix, self.parent_dir)
self.camera.start_recording(self.video_filename, self.video_codec)
self.rec_button.setText('Stop rec')
self.rec_act.setText('Stop record')
@display
def save_frame_manual(self) -> bool:
"""Determine file name of image to save with QFileDialog
"""
self.dialog = QFileDialog()
self.dialog.setWindowTitle("Save File")
self.dialog.setNameFilters([
"image (*.jpg *.png *.tiff *.pgm)",
"All Files (*)"
])
self.dialog.setAcceptMode(QFileDialog.AcceptSave)
self.dialog.setOption(QFileDialog.DontUseNativeDialog)
if self.dialog.exec_():
r = self.dialog.selectedFiles()
# If the file name doesn't include supproted suffixes, add to the end.
if re.search(".pgm$|.png$|.jpg$|.tiff$", r[0]):
self.filename = r[0]
else:
self.filename = "{}.{}".format(r[0], self.image_suffix)
return True
else:
return False
def get_screensize(self):
"""Get current screen size from the output of linux cmd `xrandr`.
"""
cmd = ["xrandr"]
ret = subprocess.check_output(cmd)
output = ret.decode()
pattern = r"current(\s+\d+\s+x\s+\d+)"
m = re.search(pattern, output)
if m:
size = re.sub(" ", "", m.group(1))
w, h = map(int, size.split("x"))
return w, h, size
else:
return None
def set_sliderval(self, param: str, value: int):
"""Changes a camera parameter.
Updates the label on the right of the slider if input value is valid.
Args:
param (str): A camera parameter
value (int): its value
"""
val = self.camera.set_parameter(param, value)
self.current_params[param]["value"] = str(val)
self.current_params[param]["slider_value"].setText(str(value))
def set_param_default(self):
"""Sets all paramters to default.
"""
for param, values in self.current_params.items():
default = values["default"]
self.camera.set_parameter(param, default)
self.current_params[param]["slider"].setValue(int(default))
self.current_params[param]["slider_value"].setText(str(default))
def get_properties(self) -> list:
"""Get the current camera properties.
Returns:
list: parameters. fourcc, width, height, fps.
"""
tmp = []
for row in range(4):
tmp.append(self.prop_table[row][1])
return tmp
def write_text(self, text: str, level: str = "info", color: str = None):
"""Writes the message into information window.
Args:
text (str): A text to write.
level (str, optional): Log lebel of the message. Defaults to "info".
color (str, optional): Font color. Defaults to None.
"""
now = datetime.now().strftime("%Y-%m-%d %H:%M:%S.%f")
now = now[:-3]
if color == "red":
form = f"<font color='red'>[{level.upper():<4} {now}] {text}</font>"
elif color == "yellow":
form = f"<font color='yellow'>[{level.upper():<4} {now}] {text}</font>"
else:
form = f"[{level.upper():<4} {now}] {text}"
self.text_edit.append(form)
class QTraceViewer(QWidget):
"""
Load a basic block trace through json and visualize it in the disassembly
Ref: https://github.com/angr/angr-management/pull/122
"""
TAG_SPACING = 50
LEGEND_X = -50
LEGEND_Y = 0
LEGEND_WIDTH = 10
TRACE_FUNC_X = 0
TRACE_FUNC_Y = 0
TRACE_FUNC_WIDTH = 50
TRACE_FUNC_MINHEIGHT = 1000
TAB_HEADER_SIZE = 40
MAX_WINDOW_SIZE = 500
MARK_X = LEGEND_X
MARK_WIDTH = TRACE_FUNC_X - LEGEND_X + TRACE_FUNC_WIDTH
MARK_HEIGHT = 1
def __init__(self, workspace, disasm_view, parent=None):
super().__init__(parent=parent)
self.workspace = workspace
self.disasm_view = disasm_view
self.mark = None
self.legend = None
self.legend_height = 0
self.legend_img = None
self.trace_func_unit_height = 0
self.trace_func = None
self.trace_id = None
self.view = None
self.traceView = None
self.traceTab = None
self.traceScene = None
self.multiView = None
self.listView = None
self.mark = None
self.curr_position = 0
self._use_precise_position = False
self._selected_traces = []
self._init_widgets()
self.trace.am_subscribe(self._on_set_trace)
self.selected_ins.am_subscribe(self._on_select_ins)
self.traceTab.installEventFilter(self)
#
# Forwarding properties
#
@property
def trace(self):
return self.workspace.instance.trace
@property
def multi_trace(self):
return self.workspace.instance.multi_trace
@property
def selected_ins(self):
return self.disasm_view.infodock.selected_insns
def _init_widgets(self):
self.view = QTabWidget() # QGraphicsView()
self.traceTab = QWidget()
tracelayout = QVBoxLayout()
self.traceView = QGraphicsView()
self.traceScene = QGraphicsScene()
self.traceView.setScene(self.traceScene)
self.listView = QTableWidget(0, 2) # row, col
self.listView.setHorizontalHeaderItem(0, QTableWidgetItem("Trace ID"))
self.listView.setHorizontalHeaderItem(1, QTableWidgetItem("Input ID"))
self.listView.setSelectionMode(QAbstractItemView.SingleSelection)
self.listView.setSelectionBehavior(QAbstractItemView.SelectRows)
# self.listView.horizontalHeader().setStretchLastSection(True)
# self.listView.horizontalHeader().setSectionResizeModel(0, QHeaderView.Stretch)
self.listView.cellClicked.connect(self._switch_current_trace)
self.traceSeedButton = QPushButton("View Input Seed")
self.traceSeedButton.clicked.connect(self._view_input_seed)
tracelayout.addWidget(self.traceView)
tracelayout.addWidget(self.listView)
tracelayout.addWidget(self.traceSeedButton)
self.traceTab.setLayout(tracelayout)
self.multiView = QWidget()
multiLayout = QVBoxLayout()
self.multiTraceList = QTableWidget(0, 2) # row, col
self.multiTraceList.setSelectionMode(QAbstractItemView.MultiSelection)
self.multiTraceList.setSelectionBehavior(QAbstractItemView.SelectRows)
self.multiTraceList.setHorizontalScrollMode(
self.multiTraceList.ScrollPerPixel)
self.multiTraceList.setHorizontalHeaderItem(
0, QTableWidgetItem("Trace ID"))
self.multiTraceList.setHorizontalHeaderItem(
1, QTableWidgetItem("Input ID"))
self.selectMultiTrace = QPushButton("Refresh Heatmap")
self.selectMultiTrace.clicked.connect(self._refresh_heatmap)
multiLayout.addWidget(self.multiTraceList)
multiLayout.addWidget(self.selectMultiTrace)
self.multiView.setLayout(multiLayout)
self.view.addTab(self.traceTab, "SingleTrace")
self.view.addTab(self.multiView, "MultiTrace HeatMap")
self.SINGLE_TRACE = 0
self.MULTI_TRACE = 1
self.view.currentChanged.connect(self._on_tab_change)
self._reset()
layout = QVBoxLayout()
layout.addWidget(self.view)
layout.setContentsMargins(0, 0, 0, 0)
layout.setAlignment(self.view, Qt.AlignLeft)
self.setLayout(layout)
def _reset(self):
self.traceScene.clear() #clear items
self.listView.clearContents()
self.multiTraceList.clearContents()
self.mark = None
self.legend = None
self.legend_height = 0
self.trace_func = QGraphicsItemGroup()
self.trace_id = QGraphicsItemGroup()
self.traceScene.addItem(self.trace_func)
self.hide()
def _view_input_seed(self):
current_trace_stats = self.trace.am_obj
input_id = current_trace_stats.input_id
inputSeed = self.multi_trace.am_obj.get_input_seed_for_id(input_id)
msgText = "%s" % inputSeed
msgDetails = "Input for [%s]" % current_trace_stats.id
msgbox = QMessageBox()
msgbox.setWindowTitle("Seed Input")
msgbox.setDetailedText(msgDetails)
msgbox.setText(msgText)
msgbox.setStandardButtons(QMessageBox.Ok)
msgbox.exec()
def _switch_current_trace(self, row):
if self.listView.rowCount() <= 0:
return
current_trace = self.trace.am_obj.id
new_trace = self.multiTraceList.item(row, 0).text()
if current_trace == new_trace:
return
trace_stats = self.multi_trace.am_obj.get_trace_with_id(new_trace)
if trace_stats:
self.trace.am_obj = trace_stats
self._on_set_trace()
def _on_set_trace(self):
self._reset()
if self.trace.am_none or self.trace.count is None:
return
l.debug('minheight: %d, count: %d', self.TRACE_FUNC_MINHEIGHT,
self.trace.count)
if self.trace.count <= 0:
l.warning(
"No valid addresses found in trace to show. Check base address offsets?"
)
self.trace.am_obj = None
self.trace.am_event()
return
if self.TRACE_FUNC_MINHEIGHT < self.trace.count * 15:
self.trace_func_unit_height = 15
show_func_tag = True
else:
self.trace_func_unit_height = self.TRACE_FUNC_MINHEIGHT / self.trace.count
show_func_tag = True
self.legend_height = int(self.trace.count *
self.trace_func_unit_height)
self._show_trace_func(show_func_tag)
self._show_legend()
self._show_trace_ids()
self._set_mark_color()
self._refresh_multi_list()
boundingSize = self.traceScene.itemsBoundingRect().width()
windowSize = boundingSize
if boundingSize > self.MAX_WINDOW_SIZE:
windowSize = self.MAX_WINDOW_SIZE
self.traceScene.setSceneRect(
self.traceScene.itemsBoundingRect()) #resize
self.setFixedWidth(windowSize)
# self.listScene.setSceneRect(self.listScene.itemsBoundingRect()) #resize
self.multiView.setFixedWidth(windowSize)
cellWidth = windowSize // 2
self.listView.setColumnWidth(0, cellWidth)
self.listView.setColumnWidth(1, cellWidth)
self.listView.setFixedHeight(self.multiView.height() // 4)
self.multiTraceList.setColumnWidth(0, cellWidth)
self.multiTraceList.setColumnWidth(1, cellWidth)
self.view.setFixedWidth(windowSize)
self.show()
def _populate_trace_table(self, view, trace_ids):
numIDs = len(trace_ids)
view.clearContents()
view.setRowCount(numIDs)
row = 0 #start after label row
for traceID in trace_ids:
inputID = self.multi_trace.am_obj.get_input_id_for_trace_id(
traceID)
if inputID is None:
self.workspace.log("No inputID found for trace %s" % traceID)
view.setItem(row, 0, QTableWidgetItem(traceID))
view.setItem(row, 1, QTableWidgetItem(inputID))
row += 1
def _refresh_heatmap(self):
multiTrace = self.multi_trace.am_obj
multiTrace.clear_heatmap()
multiTrace.is_active_tab = True
selected_items = self.multiTraceList.selectedItems()
self._selected_traces.clear()
for row in range(self.multiTraceList.rowCount()):
item = self.multiTraceList.item(row, 0)
if item in selected_items:
self._selected_traces.append(item.text())
multiTrace.reload_heatmap(self._selected_traces)
self.multi_trace.am_event()
def _refresh_multi_list(self):
multiTrace = self.multi_trace.am_obj
trace_ids = multiTrace.get_all_trace_ids()
self.multiTraceList.clearContents()
self._populate_trace_table(self.multiTraceList, trace_ids)
if self._selected_traces and self.multiTraceList.rowCount() > 0:
self.multiTraceList.item(0, 0).setSelected(True)
self.multiTraceList.item(0, 1).setSelected(True)
else:
for row in range(self.multiTraceList.rowCount()):
item = self.multiTraceList.item(row, 0)
inputItem = self.multiTraceList.item(row, 1)
if item.text() in self._selected_traces:
item.setSelected(True)
inputItem.setSelected(True)
self.multi_trace.am_event()
def _on_tab_change(self):
# self._reset()
multiTrace = self.multi_trace.am_obj
if self.view.currentIndex() == self.MULTI_TRACE:
multiTrace.is_active_tab = True
self._refresh_multi_list()
elif self.view.currentIndex() == self.SINGLE_TRACE:
multiTrace = self.multi_trace.am_obj
multiTrace.is_active_tab = False
self._show_trace_ids()
def _on_select_ins(self, **kwargs): # pylint: disable=unused-argument
if self.trace.am_none:
return
if self.mark is not None:
for i in self.mark.childItems():
self.mark.removeFromGroup(i)
self.traceScene.removeItem(i)
self.traceScene.removeItem(self.mark)
self.mark = QGraphicsItemGroup()
self.traceScene.addItem(self.mark)
if self.selected_ins:
addr = next(iter(self.selected_ins))
positions = self.trace.get_positions(addr)
if positions: #if addr is in list of positions
if not self._use_precise_position: #handle case where insn was selected from disas view
self.curr_position = positions[0] - self.trace.count
for p in positions:
color = self._get_mark_color(p, self.trace.count)
y = self._get_mark_y(p)
if p == self.trace.count + self.curr_position: #add thicker line for 'current' mark
self.mark.addToGroup(
self.traceScene.addRect(self.MARK_X, y,
self.MARK_WIDTH,
self.MARK_HEIGHT * 4,
QPen(QColor('black')),
QBrush(color)))
else:
self.mark.addToGroup(
self.traceScene.addRect(self.MARK_X, y,
self.MARK_WIDTH,
self.MARK_HEIGHT,
QPen(color),
QBrush(color)))
self.traceScene.update() #force redraw of the traceScene
self.scroll_to_position(self.curr_position)
def scroll_to_position(self, position):
relative_pos = self.trace.count + position
y_offset = self._get_mark_y(relative_pos)
scrollValue = 0
if y_offset > 0.5 * self.traceView.size().height():
scrollValue = y_offset - 0.5 * self.traceView.size().height()
scrollValue = min(scrollValue,
self.traceView.verticalScrollBar().maximum())
self.traceView.verticalScrollBar().setValue(scrollValue)
self._use_precise_position = False
def jump_next_insn(self):
if self.curr_position + self.trace.count < self.trace.count - 1: #for some reason indexing is done backwards
self.curr_position += 1
self._use_precise_position = True
bbl_addr = self.trace.get_bbl_from_position(self.curr_position)
func = self.trace.get_func_from_position(self.curr_position)
self._jump_bbl(func, bbl_addr)
def jump_prev_insn(self):
if self.curr_position + self.trace.count > 0:
self.curr_position -= 1
self._use_precise_position = True
bbl_addr = self.trace.get_bbl_from_position(self.curr_position)
func = self.trace.get_func_from_position(self.curr_position)
self._jump_bbl(func, bbl_addr)
def eventFilter(self, obj, event): #specifically to catch arrow keys #pylint: disable=unused-argument
# more elegant solution to link w/ self.view's scroll bar keypressevent?
if event.type() == QEvent.Type.KeyPress:
if not event.modifiers() & Qt.ShiftModifier: #shift + arrowkeys
return False
key = event.key()
if key in [Qt.Key_Up, Qt.Key_Left]:
self.jump_prev_insn()
elif key in [Qt.Key_Down, Qt.Key_Right]:
self.jump_next_insn()
return True
return False # pass through all other events
def mousePressEvent(self, event):
button = event.button()
pos = self._to_logical_pos(event.pos())
if button == Qt.LeftButton and self.view.currentIndex(
) == self.SINGLE_TRACE and self._at_legend(pos):
func = self._get_func_from_y(pos.y())
bbl_addr = self._get_bbl_from_y(pos.y())
self._use_precise_position = True
self.curr_position = self._get_position(pos.y())
self._jump_bbl(func, bbl_addr)
def _jump_bbl(self, func, bbl_addr):
all_insn_addrs = self.workspace.instance.project.factory.block(
bbl_addr).instruction_addrs
# TODO: replace this with am_events perhaps?
if func is None:
return
self.workspace.on_function_selected(func)
self.selected_ins.clear()
self.selected_ins.update(all_insn_addrs)
self.selected_ins.am_event()
# TODO: this ought to happen automatically as a result of the am_event
self.disasm_view.current_graph.show_instruction(bbl_addr)
def _get_mark_color(self, i, total):
relative_gradient_pos = i * 1000 // total
return self.legend_img.pixelColor(self.LEGEND_WIDTH // 2,
relative_gradient_pos)
def _get_mark_y(self, i):
return self.TRACE_FUNC_Y + self.trace_func_unit_height * i
def _show_trace_ids(self):
trace_ids = self.multi_trace.get_all_trace_ids()
# traceID = self.listScene.addText(id_txt, QFont("Source Code Pro", 7))
# traceID.setPos(5,5)
self.listView.clearContents()
self._populate_trace_table(self.listView, trace_ids)
if len(self.listView.selectedItems()) <= 0 and not self.trace.am_none:
for row in range(self.listView.rowCount()):
item = self.listView.item(row, 0)
inputItem = self.listView.item(row, 1)
if self.trace.id in item.text():
item.setSelected(True)
inputItem.setSelected(True)
break
def _show_trace_func(self, show_func_tag):
x = self.TRACE_FUNC_X
y = self.TRACE_FUNC_Y
prev_name = None
for position in self.trace.trace_func:
bbl_addr = position.bbl_addr
func_name = position.func_name
l.debug('Draw function %x, %s', bbl_addr, func_name)
color = self.trace.get_func_color(func_name)
self.trace_func.addToGroup(
self.traceScene.addRect(x, y, self.TRACE_FUNC_WIDTH,
self.trace_func_unit_height,
QPen(color), QBrush(color)))
if show_func_tag is True and func_name != prev_name:
tag = self.traceScene.addText(func_name,
QFont("Source Code Pro", 7))
tag.setPos(x + self.TRACE_FUNC_WIDTH + self.TAG_SPACING,
y - tag.boundingRect().height() // 2)
self.trace_func.addToGroup(tag)
anchor = self.traceScene.addLine(
self.TRACE_FUNC_X + self.TRACE_FUNC_WIDTH, y,
x + self.TRACE_FUNC_WIDTH + self.TAG_SPACING, y)
self.trace_func.addToGroup(anchor)
prev_name = func_name
y += self.trace_func_unit_height
@staticmethod
def _make_legend_gradient(x1, y1, x2, y2):
gradient = QLinearGradient(x1, y1, x2, y2)
gradient.setColorAt(0.0, Qt.red)
gradient.setColorAt(0.4, Qt.yellow)
gradient.setColorAt(0.6, Qt.green)
gradient.setColorAt(0.8, Qt.blue)
gradient.setColorAt(1.0, Qt.darkBlue)
return gradient
def _show_legend(self):
pen = QPen(Qt.transparent)
gradient = self._make_legend_gradient(
self.LEGEND_X, self.LEGEND_Y, self.LEGEND_X,
self.LEGEND_Y + self.legend_height)
brush = QBrush(gradient)
self.legend = self.traceScene.addRect(self.LEGEND_X, self.LEGEND_Y,
self.LEGEND_WIDTH,
self.legend_height, pen, brush)
reference_gradient = self._make_legend_gradient(
0, 0, self.LEGEND_WIDTH, 1000)
base_img = QImage(self.LEGEND_WIDTH, 1000, QImage.Format.Format_ARGB32)
p = QPainter(base_img)
p.fillRect(base_img.rect(), reference_gradient)
self.legend_img = base_img #reference shade
def _set_mark_color(self):
for p in range(self.trace.count):
color = self._get_mark_color(p, self.trace.count)
self.trace.set_mark_color(p, color)
def _at_legend(self, pos):
x = pos.x()
y = pos.y()
return self.TRACE_FUNC_X + self.LEGEND_X < x < self.traceView.width() and \
self.TRACE_FUNC_Y < y < self.TRACE_FUNC_Y + self.legend_height
def _to_logical_pos(self, pos):
x_offset = self.traceView.horizontalScrollBar().value()
y_offset = self.traceView.verticalScrollBar().value()
return QPoint(pos.x() + x_offset, pos.y() + y_offset)
def _get_position(self, y):
y_relative = y - self.legend_height - self.TAB_HEADER_SIZE
return int(y_relative // self.trace_func_unit_height)
def _get_bbl_from_y(self, y):
position = self._get_position(y)
return self.trace.get_bbl_from_position(position)
def _get_func_from_y(self, y):
position = self._get_position(y)
func = self.trace.get_func_from_position(position)
return func
class ImageView(TopicMessageView):
"""
Popup image viewer
"""
name = 'Image'
def __init__(self, timeline, parent, topic):
super(ImageView, self).__init__(timeline, parent, topic)
self._image = None
self._image_topic = None
self._image_stamp = None
self.quality = Image.NEAREST # quality hint for scaling
# TODO put the image_topic and image_stamp on the picture or display them in some fashion
self._overlay_font_size = 14.0
self._overlay_indent = (4, 4)
self._overlay_color = (0.2, 0.2, 1.0)
self._image_view = QGraphicsView(parent)
self._image_view.resizeEvent = self._resizeEvent
self._scene = QGraphicsScene()
self._image_view.setScene(self._scene)
parent.layout().addWidget(self._image_view)
# MessageView implementation
def _resizeEvent(self, event):
# TODO make this smarter. currently there will be no scrollbar even if the timeline extends beyond the viewable area
self._scene.setSceneRect(0, 0, self._image_view.size().width() - 2, self._image_view.size().height() - 2)
self.put_image_into_scene()
def message_viewed(self, bag, msg_details):
"""
refreshes the image
"""
TopicMessageView.message_viewed(self, bag, msg_details)
topic, msg, t = msg_details[:3]
if not msg:
self.set_image(None, topic, 'no message')
else:
self.set_image(msg, topic, msg.header.stamp)
def message_cleared(self):
TopicMessageView.message_cleared(self)
self.set_image(None, None, None)
# End MessageView implementation
def put_image_into_scene(self):
if self._image:
resized_image = self._image.resize((self._image_view.size().width() - 2, self._image_view.size().height() - 2), self.quality)
QtImage = ImageQt(resized_image)
pixmap = QPixmap.fromImage(QtImage)
self._scene.clear()
self._scene.addPixmap(pixmap)
def set_image(self, image_msg, image_topic, image_stamp):
self._image_msg = image_msg
if image_msg:
self._image = image_helper.imgmsg_to_pil(image_msg)
else:
self._image = None
self._image_topic = image_topic
self._image_stamp = image_stamp
self.put_image_into_scene()
class AbstractStateGraphScene(AbstractGeneralGraphSceneClass):
__metaclass__ = AbstractGeneralGraphScene_Meta
signalStateEditing = Signal(object)
signalTransitionEditing = Signal(dict)
signalTransitionAddition = Signal(dict)
signalSymbolDataRemoved = Signal()
def __init__(self, parent):
super(AbstractStateGraphScene, self).__init__(parent)
self._stateIdToNodeDict = {}
self.view = QGraphicsView()
self.view.setScene(self)
self.view.setRenderHints(QPainter.Antialiasing
| QPainter.TextAntialiasing)
self.setSceneRect(0, 0, 800, 600)
@abstractmethod
@Slot(dict)
def addNode(self, state):
pass
def setupNode(self, node):
seqNumber = len(self._stateIdToNodeDict)
node.setPos(
QPointF(10 + (40 * (seqNumber % 5)),
45 + (40 * ((seqNumber / 5) % 7))))
self.addItem(node)
self.clearSelection()
def updateNodeLabels(self):
nodes = list(self._stateIdToNodeDict.values())
for node in nodes:
node.setLabel(nodes.index(node))
def findNodeIndex(self, stateId):
nodes = list(self._stateIdToNodeDict.values())
node = self._stateIdToNodeDict[stateId]
return nodes.index(node)
@Slot(dict)
def updateNodeFromInfo(self, info):
node = self._stateIdToNodeDict[info['stateId']]
if info['isAcceptable'] != node.isAcceptable:
node.toggleFinalNodeBorder()
self.update()
@Slot(object)
def updateCurrentState(self, newStateId):
nodes = list(self._stateIdToNodeDict.values())
for node in nodes:
if node.isCurrent:
node.toggleCurrentState()
newCurrent = self._stateIdToNodeDict[newStateId]
newCurrent.toggleCurrentState()
@abstractmethod
@Slot(dict)
def addEdge(self, edgeInfo):
pass
def isItemNode(self, graphicsItem):
return graphicsItem in self._stateIdToNodeDict.values()
@abstractmethod
def selectedNode(self):
pass
def findStateId(self, targetNode):
for stateId, node in self._stateIdToNodeDict.items():
if node is targetNode:
return stateId
@abstractmethod
def selectedEdge(self):
pass
@abstractmethod
def selectedTwoNodes(self):
pass
@Slot(str)
def deleteForStateId(self, stateId):
node = self._stateIdToNodeDict[stateId]
edges = node.getEdges()
if len(edges) > 0:
for edge in edges:
self.removeItem(edge)
del edges[:]
del self._stateIdToNodeDict[stateId]
self.removeItem(node)
self.updateNodeLabels()
@Slot(object)
def deleteTransitionsForInput(self, input):
toDelete = []
for stateId in self._stateIdToNodeDict:
node = self._stateIdToNodeDict[stateId]
edgesForInput = node.getEdgesForInput(input)
toDelete.extend(edgesForInput)
if len(toDelete) > 0:
for edge in toDelete:
self.removeItem(edge)
del toDelete[:]
self.signalSymbolDataRemoved.emit()
@Slot(dict)
def deleteStateTransitionForInput(self, transitionInfo):
node = self._stateIdToNodeDict[transitionInfo.fromStateId]
edgesForInput = node.getEdgesFromSelf(transitionInfo.onInput)
for edge in edgesForInput:
self.removeItem(edge)
del edgesForInput[:]
def mousePressEvent(self, event: QGraphicsSceneMouseEvent):
selectedNodes = self.selectedTwoNodes()
if selectedNodes is not None:
self.signalTransitionAddition.emit({
'fromState':
self.findStateId(selectedNodes['fromNode']),
'toState':
self.findStateId(selectedNodes['toNode']),
'input':
None
})
self.clearSelection()
super(AbstractStateGraphScene, self).mousePressEvent(event)
def mouseDoubleClickEvent(self, event: QGraphicsSceneMouseEvent):
selectedNode = self.selectedNode()
selectedEdge = self.selectedEdge()
if selectedNode is not None:
stateId = self.findStateId(selectedNode)
self.signalStateEditing.emit(stateId)
self.clearSelection()
elif selectedEdge is not None:
transitionInfo = {'input': selectedEdge.input()}
transitionInfo['fromState'] = self.findStateId(
selectedEdge.fromNode)
transitionInfo['toState'] = self.findStateId(selectedEdge.toNode)
self.signalTransitionEditing.emit(transitionInfo)
self.clearSelection()
super(AbstractStateGraphScene, self).mouseDoubleClickEvent(event)
def setScene(self, scene):
QGraphicsView.setScene(self, scene)
self.centerOn(scene.mid_build)
scene.mid_build.setSelected(True)
print(f'Rect Pos: {rectItem.pos()}')
textItem = QGraphicsSimpleTextItem("Foundation of Qt")
scene.addItem(textItem)
print(f'Text Pos: {textItem.pos()}')
textItem.setPos(50, 0)
print(f'Text Pos: {textItem.pos()}')
ellipseItem = QGraphicsEllipseItem(QRectF(170, 20, 100, 75))
ellipseItem.setPen(QPen(Qt.darkBlue))
ellipseItem.setBrush(Qt.blue)
scene.addItem(ellipseItem)
points = [
QPointF(10, 10),
QPointF(0, 90),
QPointF(40, 70),
QPointF(80, 110),
QPointF(70, 20)
]
polygonItem = QGraphicsPolygonItem(QPolygonF(points))
polygonItem.setPen(QPen(Qt.darkGreen))
polygonItem.setBrush(Qt.yellow)
scene.addItem(polygonItem)
view = QGraphicsView()
view.setScene(scene)
view.show()
sys.exit(app.exec_())
class MainWindow(QMainWindow):
def __init__(self):
# load setting json file
with open('setting.json') as f:
self.app_setting = json.load(f)
# Status of window
super().__init__()
self.title = 'Image Editor'
self.left = 70
self.top = 70
self.width = 800
self.height = 700
# Status of view image
self.org_qimg = None
self.org_img_width = 0
self.org_img_height = 0
self.layer_pixmap = None
self.layer_width = 0
self.layer_height = 0
self.layer_alpha = 50.0
# Prepare color bar data
self.colormap_gain = self.app_setting["SoftwareSetting"]["process"][
"colormap"]["gain"]
self.colormap_offset_x = self.app_setting["SoftwareSetting"][
"process"]["colormap"]["offset_x"]
self.colormap_offset_green = self.app_setting["SoftwareSetting"][
"process"]["colormap"]["offset_green"]
self.colormap_data = [
colormap.colorBarRGB(x * 0.001, self.colormap_offset_x,
self.colormap_offset_green,
self.colormap_gain) for x in range(1000)
]
self.img_edit_mode = 'cursor'
self.draw_color = QColor(255, 0, 0)
self.draw_tool_size = 5
self.eraser_color = QColor(0, 0, 0, 0)
# setup user interface components
self.setup_ui()
# Setup user interface components
def setup_ui(self):
# Set main window title
self.setWindowTitle(self.title)
# Set main wiodow initial position
self.setGeometry(self.left, self.top, self.width, self.height)
# Set up mainWindow's layout
self.mainWidget = QWidget(self) # Note not to forget this code.
self.main_layout = QVBoxLayout()
# Set menu for main window
self.main_menu = self.menuBar()
self.file_menu = self.main_menu.addMenu('File')
self.edit_menu = self.main_menu.addMenu('Edit')
self.help_menu = self.main_menu.addMenu('Help')
self.main_layout.addWidget(self.main_menu)
# Set "Original Image Open" menu
self.org_img_open_button = QAction(
self.style().standardIcon(getattr(QStyle, 'SP_FileDialogStart')),
'Open Orginal Image', self)
self.org_img_open_button.setShortcut('Ctrl+O')
self.org_img_open_button.triggered.connect(self.open_org_img_dialog)
self.file_menu.addAction(self.org_img_open_button)
# Set "Save layer image" menu
self.layer_img_save_button = QAction(
self.style().standardIcon(getattr(QStyle, 'SP_FileDialogEnd')),
'Save Layer Image', self)
self.layer_img_save_button.setShortcut('Ctrl+S')
self.layer_img_save_button.triggered.connect(self.save_layer_image)
self.file_menu.addAction(self.layer_img_save_button)
# Set "Save compose image(original + layer image)" menu
self.compose_img_save_button = QAction(
self.style().standardIcon(getattr(QStyle, 'SP_FileDialogEnd')),
'Save Compose Image', self)
self.compose_img_save_button.setShortcut('Ctrl+D')
self.compose_img_save_button.triggered.connect(self.save_compose_image)
self.file_menu.addAction(self.compose_img_save_button)
# Set "exit software" menu
self.exit_button = QAction(
self.style().standardIcon(getattr(QStyle, 'SP_DialogCloseButton')),
'Exit', self)
self.exit_button.setShortcut('Ctrl-Q')
self.exit_button.setStatusTip('Exit software')
self.exit_button.triggered.connect(self.close)
self.file_menu.addAction(self.exit_button)
self.upper_layout = QHBoxLayout()
self.main_layout.addLayout(self.upper_layout)
# Set image display area
self.gview_default_size = 500
self.graphics_view = QGraphicsView()
self.graphics_view.setFixedSize(self.gview_default_size,
self.gview_default_size)
self.graphics_view.setObjectName("imageDisplayArea")
self.upper_layout.addWidget(self.graphics_view)
# image display area's contents
self.scene = GraphicsSceneForMainView(self.graphics_view, self)
self.imgs_pixmap = []
self.imgs = []
self.img_status_layout = QVBoxLayout()
self.upper_layout.addLayout(self.img_status_layout)
# Set tranparency value of layer image
self.transparency_title_label = QLabel('layer transparency value')
self.img_status_layout.addWidget(self.transparency_title_label)
transparency = round((1.0 - self.layer_alpha / 255.0) * 100)
self.img_transparency_edit = QLineEdit(str(transparency))
self.img_transparency_sld = QSlider(Qt.Horizontal)
self.img_transparency_sld.setFocusPolicy(Qt.NoFocus)
self.img_transparency_sld.setRange(0, 100)
self.img_transparency_sld.setValue(transparency)
self.transparency_layout = QFormLayout()
self.transparency_layout.addRow(self.img_transparency_sld,
self.img_transparency_edit)
self.img_status_layout.addLayout(self.transparency_layout)
# Signal of transparency value changed
self.img_transparency_sld.valueChanged.connect(
self.transparency_change_sld)
self.img_transparency_edit.textChanged.connect(
self.transparency_change_edit)
self.img_editor_layout = QVBoxLayout()
self.img_status_layout.addLayout(self.img_editor_layout)
# Set layer image editor tool
self.img_editor_tool1_layout = QHBoxLayout()
self.img_editor_layout.addLayout(self.img_editor_tool1_layout)
self.tool_button_size = 64
# Set Mouse cursor
self.mouse_cursor_button = QPushButton()
self.mouse_cursor_button.setIcon(QIcon('icon/cursor.png'))
self.mouse_cursor_button.setCheckable(True)
self.mouse_cursor_button.setIconSize(
QSize(self.tool_button_size, self.tool_button_size))
self.img_editor_tool1_layout.addWidget(self.mouse_cursor_button)
# Set Pen
self.pen_button = QPushButton()
self.pen_button.setIcon(QIcon('icon/pen.png'))
self.pen_button.setCheckable(True)
self.pen_button.setIconSize(
QSize(self.tool_button_size, self.tool_button_size))
self.img_editor_tool1_layout.addWidget(self.pen_button)
# Set Eraser
self.eraser_button = QPushButton()
self.eraser_button.setIcon(QIcon('icon/eraser.png'))
self.eraser_button.setCheckable(True)
self.eraser_button.setIconSize(
QSize(self.tool_button_size, self.tool_button_size))
self.img_editor_tool1_layout.addWidget(self.eraser_button)
# Group button of mouse cursor, pen, eraser
self.img_editor_tool1_group1 = QButtonGroup()
self.img_editor_tool1_group1.addButton(self.mouse_cursor_button, 1)
self.img_editor_tool1_group1.addButton(self.pen_button, 2)
self.img_editor_tool1_group1.addButton(self.eraser_button, 3)
# Set signal-slot of image editor button
self.mouse_cursor_button.toggled.connect(
self.mouse_cursor_button_toggled)
self.pen_button.toggled.connect(self.pen_button_toggled)
self.eraser_button.toggled.connect(self.eraser_button_toggled)
# Set color bar
self.color_bar_width = 64
self.color_bar_height = 256
self.color_bar_view = QGraphicsView()
self.color_bar_view.setFixedSize(self.color_bar_width + 3,
self.color_bar_height + 3)
self.color_bar_scene = GraphicsSceneForTools()
self.color_bar_img = QImage(self.color_bar_width,
self.color_bar_height,
QImage.Format_RGB888)
for i in range(self.color_bar_height):
# Set drawing pen for colormap
ii = round(i * (1000 / 256))
color = QColor(self.colormap_data[ii][0],
self.colormap_data[ii][1],
self.colormap_data[ii][2])
pen = QPen(color, 1, Qt.SolidLine, \
Qt.SquareCap, Qt.RoundJoin)
self.color_bar_scene.addLine(0,
self.color_bar_height - i - 1,
self.color_bar_width,
self.color_bar_height - i - 1,
pen=pen)
for j in range(self.color_bar_width):
self.color_bar_img.setPixelColor(j,
self.color_bar_height - i - 1,
color)
self.color_bar_scene.set_img_content(self.color_bar_img)
self.color_bar_view.setScene(self.color_bar_scene)
# Connect signal to slot of color_bar_scene
self.color_bar_scene.img_info.connect(self.set_selected_color)
self.img_editor_tool1_layout.addWidget(self.color_bar_view)
# Set thickness of Pen or Eraser
self.draw_status_layout = QVBoxLayout()
self.draw_thick_title_label = QLabel('thickness of pen or eraser')
self.draw_status_layout.addWidget(self.draw_thick_title_label)
self.draw_thick_edit = QLineEdit(str(self.draw_tool_size))
self.draw_thick_sld = QSlider(Qt.Horizontal)
self.draw_thick_sld.setFocusPolicy(Qt.NoFocus)
self.draw_thick_sld.setRange(1, 30)
self.draw_thick_sld.setValue(self.draw_tool_size)
self.draw_thick_layout = QFormLayout()
self.draw_thick_layout.addRow(self.draw_thick_sld,
self.draw_thick_edit)
self.draw_status_layout.addLayout(self.draw_thick_layout)
self.img_editor_layout.addLayout(self.draw_status_layout)
# Signal of draw thickness value changed
self.draw_thick_sld.valueChanged.connect(self.draw_thick_change_sld)
self.draw_thick_edit.textChanged.connect(self.draw_thick_change_edit)
# Set view area of selected color
self.select_color_view_size = 64
self.select_color_view = QGraphicsView()
self.select_color_view.setFixedSize(self.select_color_view_size + 3,
self.select_color_view_size + 3)
self.select_color_scene = QGraphicsScene()
brush = QBrush(self.draw_color)
self.select_color_rect = self.select_color_scene.addRect(QRect(0, 0, self.select_color_view_size, self.select_color_view_size), \
brush=brush)
self.select_color_view.setScene(self.select_color_scene)
self.select_color_title_label = QLabel('Selected color')
self.selected_color_layout = QFormLayout()
self.selected_color_layout.addRow(self.select_color_title_label,
self.select_color_view)
self.img_editor_layout.addLayout(self.selected_color_layout)
# Set save button
self.save_button_layout = QHBoxLayout()
self.img_status_layout.addLayout(self.save_button_layout)
self.layer_save_button = QPushButton('Save layer image')
self.layer_save_button.setIcon(QIcon('icon/layer_save.png'))
self.layer_save_button.setIconSize(
QSize(self.tool_button_size, self.tool_button_size))
self.compose_save_button = QPushButton(
'Save composed original and layer image')
self.compose_save_button.setIcon(QIcon('icon/compose_save.png'))
self.compose_save_button.setIconSize(
QSize(self.tool_button_size, self.tool_button_size))
self.save_button_layout.addWidget(self.layer_save_button)
self.save_button_layout.addWidget(self.compose_save_button)
self.layer_save_button.clicked.connect(self.save_layer_image)
self.compose_save_button.clicked.connect(self.save_compose_image)
# Set display area of selected file path
self.org_img_path_title_label = QLabel('original image file: ')
self.org_img_path_label = QLabel('')
self.file_path_layout = QFormLayout()
self.file_path_layout.addRow(self.org_img_path_title_label,
self.org_img_path_label)
self.bottom_layout = QVBoxLayout()
self.bottom_layout.addLayout(self.file_path_layout)
self.main_layout.addLayout(self.bottom_layout)
self.mainWidget.setLayout(self.main_layout)
self.setCentralWidget(self.mainWidget)
# Original image select Function
def open_org_img_dialog(self):
options = QFileDialog.Options()
org_img_default_path = self.app_setting["SoftwareSetting"][
"file_path"]["org_img_dir"]
self.org_img_file_path, selected_filter = QFileDialog.getOpenFileName(self, 'Select original image', org_img_default_path, \
'Image files(*.jpg *jpeg *.png)', options=options)
org_img_dir_path, org_img_file = os.path.split(self.org_img_file_path)
org_img_bare_name, org_img_ext = os.path.splitext(org_img_file)
self.org_img_path_label.setText(self.org_img_file_path)
self.set_image_on_viewer()
def set_image_on_viewer(self):
# Delete existing image item
if len(self.imgs_pixmap) != 0:
for item in self.imgs_pixmap:
self.scene.removeItem(item)
self.scene.clear_contents()
self.imgs_pixmap.clear()
self.imgs.clear()
# load original image
self.org_qimg = QImage(self.org_img_file_path)
self.org_pixmap = QPixmap.fromImage(self.org_qimg)
org_img_size = self.org_qimg.size()
self.org_img_width = org_img_size.width()
self.org_img_height = org_img_size.height()
# Set layer image
self.layer_qimg = QImage(self.org_img_width, self.org_img_height,
QImage.Format_RGBA8888)
self.layer_qimg.fill(QColor(0, 0, 0, self.layer_alpha))
self.layer_pixmap = QPixmap.fromImage(self.layer_qimg)
self.imgs.append(self.org_qimg)
self.imgs.append(self.layer_qimg)
# Set image to scene
self.imgs_pixmap.append(QGraphicsPixmapItem(self.org_pixmap))
self.scene.addItem(self.imgs_pixmap[-1])
self.imgs_pixmap.append(QGraphicsPixmapItem(self.layer_pixmap))
self.scene.addItem(self.imgs_pixmap[-1])
self.scene.set_img_contents(self.imgs)
# Set scene to graphics view
self.graphics_view.setScene(self.scene)
self.graphics_view.setAlignment(Qt.AlignHCenter | Qt.AlignVCenter)
self.show()
# Slot function of transparency slider changed
def transparency_change_sld(self, value):
self.img_transparency_edit.setText(str(value))
self.layer_alpha = int(255 * (1.0 - (value / 100)))
# Change layer image's transparency(alpha value)
for y in range(self.org_img_height):
for x in range(self.org_img_width):
self.layer_qimg.setPixelColor(
QPoint(x, y), QColor(0, 0, 0, self.layer_alpha))
self.layer_pixmap = QPixmap.fromImage(self.layer_qimg)
# remove previous layer image
self.scene.removeItem(self.imgs_pixmap[-1])
self.imgs_pixmap.pop(-1)
# add new layer image to scene
self.imgs_pixmap.append(QGraphicsPixmapItem(self.layer_pixmap))
self.scene.addItem(self.imgs_pixmap[-1])
self.show()
# Slot function of transparency text edit changed
def transparency_change_edit(self, value):
if int(value) < 0 or int(value) > 100:
return
self.img_transparency_sld.setValue(int(value))
self.layer_alpha = int(255 * (1.0 - (int(value) / 100.0)))
# Change layer image's transparency(alpha value)
for y in range(self.org_img_height):
for x in range(self.org_img_width):
self.layer_qimg.setPixelColor(
QPoint(x, y), QColor(0, 0, 0, self.layer_alpha))
self.layer_pixmap = QPixmap.fromImage(self.layer_qimg)
# remove previous layer image
self.scene.removeItem(self.imgs_pixmap[-1])
self.imgs_pixmap.pop(-1)
# add new layer image to scene
self.imgs_pixmap.append(QGraphicsPixmapItem(self.layer_pixmap))
self.scene.addItem(self.imgs_pixmap[-1])
self.show()
# slot(receiver of signal) of mouse_cursor_button toggled
def mouse_cursor_button_toggled(self, checked):
if checked:
self.img_edit_mode = 'cursor'
self.scene.set_mode(self.img_edit_mode)
self.color_bar_scene.set_mode(self.img_edit_mode)
# slot(receiver of signal) of pen_button toggled
def pen_button_toggled(self, checked):
if checked:
self.img_edit_mode = 'pen'
self.scene.set_mode(self.img_edit_mode)
self.color_bar_scene.set_mode(self.img_edit_mode)
# slot(receiver of signal) of eraser_button toggled
def eraser_button_toggled(self, checked):
if checked:
self.img_edit_mode = 'eraser'
self.scene.set_mode(self.img_edit_mode)
self.color_bar_scene.set_mode(self.img_edit_mode)
self.draw_color = self.eraser_color
self.select_color_scene.removeItem(self.select_color_rect)
brush = QBrush(self.draw_color)
self.select_color_rect = self.select_color_scene.addRect(QRect(0, 0, self.select_color_view_size, self.select_color_view_size), \
brush=brush)
self.select_color_view.setScene(self.select_color_scene)
# Slot of color bar clicked for selection color
def set_selected_color(self, color):
# Delete existng image item
self.select_color_scene.removeItem(self.select_color_rect)
self.draw_color = color
brush = QBrush(self.draw_color)
self.select_color_rect = self.select_color_scene.addRect(QRect(0, 0, self.select_color_view_size, self.select_color_view_size), \
brush=brush)
self.select_color_view.setScene(self.select_color_scene)
# Slot function of draw thicikeness slider changed
def draw_thick_change_sld(self, value):
self.draw_thickness_edit.setText(str(value))
self.draw_tool_size = value
# Slot function of draw thicikeness text editor changed
def draw_thick_change_edit(self, value):
if int(value) < 1 or int(value) > 30:
return
self.draw_thickness_sld.setValue(int(value))
def make_layer_image(self):
for i, line in enumerate(self.scene.lines):
pen = self.scene.pens[i]
pen_size = int(pen.width())
pen_color = pen.color()
# start pixel of line
x1 = int(line.x1())
y1 = int(line.y1())
# end pixel of line
x2 = int(line.x2())
y2 = int(line.y2())
dx = int(line.dx())
dy = int(line.dy())
# When only 1pixl line
if dx <= 1 and dy <= 1:
draw_pix_x1_s = max(x1 - int(pen_size / 2), 0)
draw_pix_x1_e = min(x1 + int(pen_size / 2),
self.org_img_width - 1)
draw_pix_y1_s = max(y1 - int(pen_size / 2), 0)
draw_pix_y1_e = min(y1 + int(pen_size / 2),
self.org_img_height - 1)
# for Pen's size
for y in range(draw_pix_y1_s, draw_pix_y1_e):
for x in range(draw_pix_x1_s, draw_pix_x1_e):
self.layer_qimg.setPixelColor(x, y, pen_color)
draw_pix_x2_s = max(x2 - int(pen_size / 2), 0)
draw_pix_x2_e = min(x2 + int(pen_size / 2),
self.org_img_width - 1)
draw_pix_y2_s = max(y2 - int(pen_size / 2), 0)
draw_pix_y2_e = min(y2 + int(pen_size / 2),
self.org_img_height - 1)
# for Pen's size
for y in range(draw_pix_y2_s, draw_pix_y2_e):
for x in range(draw_pix_x2_s, draw_pix_x2_e):
self.layer_qimg.setPixelColor(x, y, pen_color)
else:
# For avoid devide by 0
if dx == 0:
for y in range(y1, y2 + 1):
draw_pix_y_s = y - int(pen_size / 2)
draw_pix_y_e = y + int(pen_size / 2)
# for Pen's size
for yy in range(draw_pix_y_s, draw_pix_y_e):
self.layer_qimg.setPixelColor(x1, yy, pen_color)
else:
grad = dy / dx
# Choose coordinates with small slope not to skip pixels
if grad >= 1.0:
for x in range(dx):
y = y1 + int(grad * x + 0.5)
draw_pix_x_s = max(x1 + x - int(pen_size / 2), 0)
draw_pix_x_e = min(x1 + x + int(pen_size / 2),
self.org_img_width - 1)
draw_pix_y_s = max(y - int(pen_size / 2), 0)
draw_pix_y_e = min(y + int(pen_size / 2),
self.org_img_height - 1)
# for Pen's size
for yy in range(draw_pix_y_s, draw_pix_y_e + 1):
for xx in range(draw_pix_x_s,
draw_pix_x_e + 1):
self.layer_qimg.setPixelColor(
xx, yy, pen_color)
else:
for y in range(dy):
x = x1 + int(1 / grad * y + 0.5)
draw_pix_y_s = max(y1 + y - int(pen_size / 2), 0)
draw_pix_y_e = min(y1 + y + int(pen_size / 2),
self.org_img_height - 1)
draw_pix_x_s = max(x - int(pen_size / 2), 0)
draw_pix_x_e = min(x + int(pen_size / 2),
self.org_img_width - 1)
# for Pen's size
for yy in range(draw_pix_y_s, draw_pix_y_e + 1):
for xx in range(draw_pix_x_s,
draw_pix_x_e + 1):
self.layer_qimg.setPixelColor(
xx, yy, pen_color)
# Slot function of save layer image button clicked
def save_layer_image(self):
self.make_layer_image()
layer_img_default_path = self.app_setting["SoftwareSetting"][
"file_path"]["layer_img_dir"]
options = QFileDialog.Options()
file_name, selected_filete = QFileDialog.getSaveFileName(self, 'Save layer image', layer_img_default_path, \
'image files(*.png, *jpg)', options=options)
#print('layer image save name:{file}'.format(file=file_name))
self.layer_qimg.save(file_name)
ret = QMessageBox(self, 'Success', 'layer image is saved successfully',
QMessageBox.Ok)
# Make composed orignal and layered image
def make_compose_image(self):
self.make_layer_image()
self.compose_qimg = QImage(self.org_img_width, self.org_img_height,
QImage.Format_RGBA8888)
painter = QPainter(self.compose_qimg)
painter.setCompositionMode(QPainter.CompositionMode_SourceOver)
painter.drawImage(0, 0, self.org_qimg)
painter.setCompositionMode(QPainter.CompositionMode_SourceOver)
painter.drawImage(0, 0, self.layer_qimg)
painter.end()
# Slot function of save composer original and layer image button clicked
def save_compose_image(self):
self.make_compose_image()
compose_img_default_path = self.app_setting["SoftwareSetting"][
"file_path"]["compose_img_dir"]
options = QFileDialog.Options()
file_name, selected_fileter = QFileDialog.getSaveFileName(self, 'Save composed image', compose_img_default_path, \
'image files(*.png, *jpg)', options=options)
#print('compose image save name:{file}'.format(file=file_name))
self.compose_qimg.save(file_name)
ret = QMessageBox(self, 'Success',
'compose image is saved successfully',
QMessageBox.Ok)
class CroppingImageWidget(QtWidgets.QWidget):
def __init__(self, cam_item, parent=None):
super(CroppingImageWidget, self).__init__(parent)
self._set_layout()
self._camera_item = cam_item
if DARK_THEME:
self._set_dark_theme()
self._create_items(cam_item)
self.scene.setSceneRect(cam_item.boundingRect())
def _create_items(self, cam_item):
l = 0.2 * cam_item.boundingRect().width()
r = 0.8 * cam_item.boundingRect().width()
t = 0.2 * cam_item.boundingRect().height()
b = 0.8 * cam_item.boundingRect().height()
cropper = CropperGraphicsItem(cam_item, l, r, t, b)
offset = 1000
self.line_left = CroppingLineGraphicsItem(
l,
-offset,
cam_item.boundingRect().height() + 2 * offset,
0,
r,
vertical=True)
self.line_right = CroppingLineGraphicsItem(
r,
-offset,
cam_item.boundingRect().height() + 2 * offset,
l,
cam_item.boundingRect().width(),
vertical=True)
self.line_top = CroppingLineGraphicsItem(
t, -offset,
cam_item.boundingRect().width() + 2 * offset, 0, b)
self.line_bottom = CroppingLineGraphicsItem(
b, -offset,
cam_item.boundingRect().width() + 2 * offset, t,
cam_item.boundingRect().height())
self.line_left.changed_pos_sig.changed_pos_sig.connect(
cropper.on_left_changed)
self.line_right.changed_pos_sig.changed_pos_sig.connect(
cropper.on_right_changed)
self.line_top.changed_pos_sig.changed_pos_sig.connect(
cropper.on_top_changed)
self.line_bottom.changed_pos_sig.changed_pos_sig.connect(
cropper.on_bottom_changed)
for line in [
self.line_left, self.line_right, self.line_top,
self.line_bottom
]:
line.changed_pos_sig.changed_pos_sig.connect(self.scene.update)
for item in [
cam_item, cropper, self.line_left, self.line_right,
self.line_top, self.line_bottom
]:
self.scene.addItem(item)
self.line_left.changed_pos_sig.changed_pos_sig.connect(
self.line_right.set_min)
self.line_right.changed_pos_sig.changed_pos_sig.connect(
self.line_left.set_max)
self.line_top.changed_pos_sig.changed_pos_sig.connect(
self.line_bottom.set_min)
self.line_bottom.changed_pos_sig.changed_pos_sig.connect(
self.line_top.set_max)
def resizeEvent(self, event):
"""
ResiczeEvent do nadpisania w qgraphicsView
"""
self.graphics_view.fitInView(self._camera_item.boundingRect(),
Qt.KeepAspectRatio)
QGraphicsView.resizeEvent(self.graphics_view, event)
def _set_layout(self):
"""
tworzy layout okna i tyle
"""
self.layout = QGridLayout()
self.scene = QGraphicsScene(self)
self.graphics_view = QGraphicsView(self)
self.graphics_view.setScene(self.scene)
self.graphics_view.show()
self.layout.addWidget(self.graphics_view, 0, 0)
self.setLayout(self.layout)
self.graphics_view.resizeEvent = self.resizeEvent
def _set_dark_theme(self):
"""
ustawia piekny ciemny motyw
"""
qApp = QtWidgets.qApp
qApp.setStyle("Fusion")
default_font = QtWidgets.qApp.font()
default_font.setPointSize(default_font.pointSize() + 2)
qApp.setFont(default_font)
dark_palette = QPalette()
dark_palette.setColor(QPalette.Window, QColor(53, 53, 53))
dark_palette.setColor(QPalette.WindowText, Qt.white)
dark_palette.setColor(QPalette.Base, QColor(30, 30, 30))
dark_palette.setColor(QPalette.AlternateBase, QColor(53, 53, 53))
dark_palette.setColor(QPalette.ToolTipBase, Qt.white)
dark_palette.setColor(QPalette.ToolTipText, Qt.white)
dark_palette.setColor(QPalette.Text, Qt.white)
dark_palette.setColor(QPalette.Button, QColor(53, 53, 53))
dark_palette.setColor(QPalette.ButtonText, Qt.white)
dark_palette.setColor(QPalette.BrightText, Qt.red)
dark_palette.setColor(QPalette.Link, QColor(42, 130, 218))
dark_palette.setColor(QPalette.Highlight, QColor(42, 130, 218))
dark_palette.setColor(QPalette.HighlightedText, Qt.black)
qApp.setPalette(dark_palette)
qApp.setStyleSheet(
"QToolTip { color: #ffffff; background-color: #2a82da; border: 1px solid white; }"
)
def get_border(self):
"""
zwraca zaznaczony/skrojony prostokat
"""
return (self.line_left.get_pos(), self.line_right.get_pos(),
self.line_top.get_pos(), self.line_bottom.get_pos())
def __init__(self, *args, **kwargs):
super(MainWindow, self).__init__(*args, **kwargs)
view = QGraphicsView()
self.scene = QGraphicsScene()
self.scene.setSceneRect(QRectF(0, 0, *WINDOW_SIZE))
felt = QBrush(QPixmap(os.path.join('images', 'felt.png')))
self.scene.setBackgroundBrush(felt)
name = QGraphicsPixmapItem()
name.setPixmap(QPixmap(os.path.join('images', 'ronery.png')))
name.setPos(QPointF(170, 375))
self.scene.addItem(name)
view.setScene(self.scene)
# Timer for the win animation only.
self.timer = QTimer()
self.timer.setInterval(5)
self.timer.timeout.connect(self.win_animation)
self.animation_event_cover = AnimationCover()
self.scene.addItem(self.animation_event_cover)
menu = self.menuBar().addMenu("&Game")
deal_action = QAction(
QIcon(os.path.join('images', 'playing-card.png')), "Deal...", self)
deal_action.triggered.connect(self.restart_game)
menu.addAction(deal_action)
menu.addSeparator()
deal1_action = QAction("1 card", self)
deal1_action.setCheckable(True)
deal1_action.triggered.connect(lambda: self.set_deal_n(1))
menu.addAction(deal1_action)
deal3_action = QAction("3 card", self)
deal3_action.setCheckable(True)
deal3_action.setChecked(True)
deal3_action.triggered.connect(lambda: self.set_deal_n(3))
menu.addAction(deal3_action)
dealgroup = QActionGroup(self)
dealgroup.addAction(deal1_action)
dealgroup.addAction(deal3_action)
dealgroup.setExclusive(True)
menu.addSeparator()
rounds3_action = QAction("3 rounds", self)
rounds3_action.setCheckable(True)
rounds3_action.setChecked(True)
rounds3_action.triggered.connect(lambda: self.set_rounds_n(3))
menu.addAction(rounds3_action)
rounds5_action = QAction("5 rounds", self)
rounds5_action.setCheckable(True)
rounds5_action.triggered.connect(lambda: self.set_rounds_n(5))
menu.addAction(rounds5_action)
roundsu_action = QAction("Unlimited rounds", self)
roundsu_action.setCheckable(True)
roundsu_action.triggered.connect(lambda: self.set_rounds_n(None))
menu.addAction(roundsu_action)
roundgroup = QActionGroup(self)
roundgroup.addAction(rounds3_action)
roundgroup.addAction(rounds5_action)
roundgroup.addAction(roundsu_action)
roundgroup.setExclusive(True)
menu.addSeparator()
quit_action = QAction("Quit", self)
quit_action.triggered.connect(self.quit)
menu.addAction(quit_action)
self.deck = []
self.deal_n = 3 # Number of cards to deal each time
self.rounds_n = 3 # Number of rounds (restacks) before end.
for suit in SUITS:
for value in range(1, 14):
card = Card(value, suit)
self.deck.append(card)
self.scene.addItem(card)
card.signals.doubleclicked.connect(
lambda card=card: self.auto_drop_card(card))
self.setCentralWidget(view)
self.setFixedSize(*WINDOW_SIZE)
self.deckstack = DeckStack()
self.deckstack.setPos(OFFSET_X, OFFSET_Y)
self.scene.addItem(self.deckstack)
# Set up the working locations.
self.works = []
for n in range(7):
stack = WorkStack()
stack.setPos(OFFSET_X + CARD_SPACING_X * n, WORK_STACK_Y)
self.scene.addItem(stack)
self.works.append(stack)
self.drops = []
# Set up the drop locations.
for n in range(4):
stack = DropStack()
stack.setPos(OFFSET_X + CARD_SPACING_X * (3 + n), OFFSET_Y)
stack.signals.complete.connect(self.check_win_condition)
self.scene.addItem(stack)
self.drops.append(stack)
# Add the deal location.
self.dealstack = DealStack()
self.dealstack.setPos(OFFSET_X + CARD_SPACING_X, OFFSET_Y)
self.scene.addItem(self.dealstack)
# Add the deal click-trigger.
dealtrigger = DealTrigger()
dealtrigger.signals.clicked.connect(self.deal)
self.scene.addItem(dealtrigger)
self.shuffle_and_stack()
self.setWindowTitle("Ronery")
self.show()
