Ejemplo n.º 1
0
    def wheelEvent(self, event):
        if event.modifiers() == Qt.CTRL and event.angleDelta().x() == 0:
            self.zoom(event.pos(), self.mapToScene(event.pos()), event.angleDelta().y())
            event.accept()
            return True

        QGraphicsView.wheelEvent(self, event)
Ejemplo n.º 2
0
    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)
Ejemplo n.º 3
0
    def __init__(self, parent):
        super().__init__(parent)
        self._scene = QGraphicsScene(self)
        self._graphics_view = QGraphicsView(self._scene, self)

        layout = QVBoxLayout(self)
        layout.addWidget(self._graphics_view)

        self._pixmap_item = SpriteGraphicsItem(self)
        self._scene.addItem(self._pixmap_item)

        self._image = QImage(SPRITE_SIZE, SPRITE_SIZE, QImage.Format_ARGB32)
        self.sprite = [[0] * SPRITE_SIZE] * SPRITE_SIZE

        button_layout = QHBoxLayout(self)
        layout.addLayout(button_layout)
        self._color_button_group = QButtonGroup(self)
        for color in COLORS:
            button = QPushButton(self)
            button.setCheckable(True)
            button.setText(f"{color}")
            self._color_button_group.addButton(button, color)
            button_layout.addWidget(button)

        self._selected_color = 0
        self._color_button_group.button(self._selected_color).setChecked(True)
        QObject.connect(self._color_button_group, SIGNAL("buttonClicked(int)"),
                        self._color_selected)

        self._update_scaling()
Ejemplo n.º 4
0
    def create_ui(self):
        button = QPushButton("Rotate - ", self)
        button.setGeometry(200, 450, 100, 50)
        button.clicked.connect(self.rotateMinus)

        button2 = QPushButton("Rotate + ", self)
        button2.setGeometry(320, 450, 100, 50)
        button2.clicked.connect(self.rotatePlus)

        scene = QGraphicsScene(self)

        greenBrush = QBrush(Qt.green)
        blueBrush = QBrush(Qt.blue)

        blackPen = QPen(Qt.black)
        blackPen.setWidth(5)

        ellipse = scene.addEllipse(10, 10, 200, 200, blackPen, greenBrush)
        rect = scene.addRect(-100, -100, 200, 200, blackPen, blueBrush)

        scene.addText("antoine-libert.com", QFont("Sanserif", 15))

        ellipse.setFlag(QGraphicsItem.ItemIsMovable)
        rect.setFlag(QGraphicsItem.ItemIsMovable)

        self.view = QGraphicsView(scene, self)
        self.view.setGeometry(0, 0, 640, 440)
    def test_click_insn(self):
        main_window = self._open_a_project()
        func = main_window.workspace.instance.project.kb.functions['main']
        self.assertIsNotNone(func)

        # display function main
        disasm_view = main_window.workspace._get_or_create_disassembly_view()
        disasm_view._t_flow_graph_visible = True
        disasm_view.display_function(func)

        # get and click the first bbl of function main
        block = disasm_view.current_graph._insaddr_to_block.get(func.addr)
        insn = block.addr_to_insns[func.addr]
        scene = QGraphicsScene()
        scene.addItem(insn)
        view = QGraphicsView(scene)
        QTest.mouseClick(view.viewport(), Qt.MouseButton.LeftButton)

        # assert that slacrs logged the information
        sleep(5)
        self.session = Slacrs(database=Conf.checrs_backend_str).session()
        result = self.session.query(HumanActivity).filter(
            HumanActivity.project_md5 == self.project_md5,
            HumanActivity.addr == insn.addr,
        ).one()
        self.session.close()
        self.assertIsNotNone(result)
Ejemplo n.º 6
0
def main(argv):
    app = QApplication(argv)

    scene = QGraphicsScene(0, 0, 500, 500)
    scene.setItemIndexMethod(QGraphicsScene.NoIndex)

    brush = QBrush(Qt.red)

    brush_brics = QBrush(QPixmap('brick_texture.jpg'))
    brush_brics.setStyle(Qt.TexturePattern)

    pen = QPen()
    pen.setWidth(5)
    pen.setStyle(Qt.DashLine)

    rectItem = RectItem('r1', 20, 10, 200, 100)
    rectItem.setBrush(brush)

    rectItem2 = RectItem('r2', 20, 10, 150, 250)
    rectItem2.setPen(pen)
    rectItem2.setBrush(brush_brics)
    rectItem2.setOpacity(70)
    arrowItem = ArrowItem(QLine(50, 200, 300, 400))
    scene.addItem(arrowItem)
    scene.addItem(rectItem)
    scene.addItem(rectItem2)

    view = QGraphicsView(scene)
    view.show()

    return app.exec_()
Ejemplo n.º 7
0
    def __init__(self, parent=None):
        super().__init__(parent)

        self.show_buttons_layout = QHBoxLayout()
        self.show_buttons_layout.setAlignment(QtGui.Qt.AlignCenter)
        self.show_st_button = QPushButton(text="Show ST")
        self.show_bu_button = QPushButton(text="Show BU")
        self.show_buttons_layout.addWidget(self.show_st_button)
        self.show_buttons_layout.addWidget(self.show_bu_button)

        self.display = QGraphicsView()
        self.display.setMinimumSize(256, 256)

        self.portrait_name_label = QLabel(text="(None)")
        self.portrait_name_label.setAlignment(QtGui.Qt.AlignCenter)

        self.navigation_buttons_layout = QHBoxLayout()
        self.navigation_buttons_layout.setAlignment(QtGui.Qt.AlignCenter)
        self.back_button = QPushButton("<")
        self.current_image_label = QLabel(text="0 / 0")
        self.forward_button = QPushButton(">")
        self.navigation_buttons_layout.addWidget(self.back_button)
        self.navigation_buttons_layout.addWidget(self.current_image_label)
        self.navigation_buttons_layout.addWidget(self.forward_button)

        self.main_layout = QVBoxLayout()
        self.main_layout.setAlignment(QtGui.Qt.AlignCenter)
        self.main_layout.addLayout(self.show_buttons_layout)
        self.main_layout.addWidget(self.display)
        self.main_layout.addWidget(self.portrait_name_label)
        self.main_layout.addLayout(self.navigation_buttons_layout)
        self.setLayout(self.main_layout)
Ejemplo n.º 8
0
 def __init__(self, parent):
     QGraphicsView.__init__(self, parent)
     self.setMinimumSize(BoardScene.BOARD_WIDTH, BoardScene.BOARD_WIDTH)
     self.setMaximumSize(BoardScene.BOARD_WIDTH, BoardScene.BOARD_WIDTH)
     self.scene = BoardScene()
     self.setScene(self.scene)
     self.show()
Ejemplo n.º 9
0
 def mouseDoubleClickEvent(self, event):
     if event.button() == Qt.LeftButton:
         if self.next_fit:
             self.zoom_fit()
         else:
             self.zoom_full()
     QGraphicsView.mouseDoubleClickEvent(self, event)
Ejemplo n.º 10
0
    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
Ejemplo n.º 11
0
class Window(QMainWindow):
    def __init__(self):
        super().__init__()

        self.setWindowTitle("Pyside2 QGraphic View")
        self.setGeometry(300, 200, 640, 520)

        self.create_ui()

        self.show()

    def create_ui(self):

        scene = QGraphicsScene(self)

        greenBrush = QBrush(Qt.red)
        blueBrush = QBrush(Qt.blue)

        blackPen = QPen(Qt.black)
        blackPen.setWidth(1)

        ellipse = scene.addEllipse(0, 0, 20, 20, blackPen, greenBrush)
        ellipse2 = scene.addEllipse(-30, -30, 20, 20, blackPen, blueBrush)

        ellipse.setFlag(QGraphicsItem.ItemIsMovable)
        ellipse2.setFlag(QGraphicsItem.ItemIsMovable)

        self.view = QGraphicsView(scene, self)
        self.view.setGeometry(0, 0, 640, 440)
Ejemplo n.º 12
0
 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)
Ejemplo n.º 13
0
 def resizeEvent(self, event):
     # FIXME: Se la finestra viene massimizzata, il valore di fit_scale non si aggiorna
     if self.matrix().m11() <= self.fit_scale:
         self.zoom_fit()
     else:
         self.notify_change()
     QGraphicsView.resizeEvent(self, event)
Ejemplo n.º 14
0
def find_display_size(display: GameDisplay, view: QGraphicsView,
                      target_size: QSize) -> QSize:
    max_width = None
    max_height = None
    min_width = min_height = 1
    display_width = display.width()
    display_height = display.height()
    while True:
        scene_size = view.contentsRect().size()
        if scene_size.width() == target_size.width():
            min_width = max_width = display_width
        elif scene_size.width() < target_size.width():
            min_width = display_width + 1
        else:
            max_width = display_width - 1
        if scene_size.height() == target_size.height():
            min_height = max_height = display_height
        elif scene_size.height() < target_size.height():
            min_height = display_height + 1
        else:
            max_height = display_height - 1
        if max_width is None:
            display_width *= 2
        else:
            display_width = (min_width + max_width) // 2
        if max_height is None:
            display_height *= 2
        else:
            display_height = (min_height + max_height) // 2
        if min_width == max_width and min_height == max_height:
            return QSize(display_width, display_height)
        display.resize(display_width, display_height)
        view.grab()  # Force layout recalculation.
Ejemplo n.º 15
0
        def __init__(self):
            QGraphicsView.__init__(self)

            # Image is displayed as a QPixmap in a QGraphicsScene attached to this QGraphicsView.
            self.scene = QGraphicsScene()
            self.setScene(self.scene)

            # Store a local handle to the scene's current image pixmap.
            self._pixmapHandle = None

            # Image aspect ratio mode.
            # !!! ONLY applies to full image. Aspect ratio is always ignored when zooming.
            #   Qt.IgnoreAspectRatio: Scale image to fit viewport.
            #   Qt.KeepAspectRatio: Scale image to fit inside viewport, preserving aspect ratio.
            #   Qt.KeepAspectRatioByExpanding: Scale image to fill the viewport, preserving aspect ratio.
            self.aspectRatioMode = Qt.KeepAspectRatio

            # Scroll bar behaviour.
            #   Qt.ScrollBarAlwaysOff: Never shows a scroll bar.
            #   Qt.ScrollBarAlwaysOn: Always shows a scroll bar.
            #   Qt.ScrollBarAsNeeded: Shows a scroll bar only when zoomed.
            self.setHorizontalScrollBarPolicy(Qt.ScrollBarAlwaysOn)
            self.setVerticalScrollBarPolicy(Qt.ScrollBarAlwaysOn)

            self.setTransformationAnchor(QGraphicsView.AnchorUnderMouse)

            # Stack of QRectF zoom boxes in scene coordinates.
            self.zoomStack = []

            # Flags for enabling/disabling mouse interaction.
            self.canZoom = True
            self.canPan = True
Ejemplo n.º 16
0
    def build_core_ui(self):
        """Sets up the core elements of this window.

        Notes:
            Setting up QGraphicsScene:
                https://stackoverflow.com/questions/23174481/pyside-qt-layout-not-working
        """
        self.base_widget = QWidget(self)
        self.layout_base = QHBoxLayout(self.base_widget)
        self.layout_canvas = QVBoxLayout()
        self.setContentsMargins(0, 0, 0, 0)
        # Setup the QGraphics items to display out zones as active elements.
        scene_zone = QRect(0, 0, self.canvas_width, self.canvas_height)
        self.scene = QGraphicsScene(scene_zone, self)
        self.canvas = QGraphicsView(self.scene, self)
        self.canvas.setFixedSize(self.canvas_width + 1, self.canvas_height + 1)
        # Draw faint bullseye for target.
        self.scene.addEllipse(self.get_center_rect(300), Qt.NoPen,
                              self.brush_overlay)
        self.scene.addEllipse(self.get_center_rect(200), Qt.NoPen,
                              self.brush_innerlay)
        self.scene.addEllipse(self.get_center_rect(100), Qt.NoPen,
                              self.brush_overlay)
        self.layout_canvas.addWidget(self.canvas)
        self.lbl_island = QLabel("Island Areas:")
        self.layout_canvas.addWidget(self.lbl_island)
        self.layout_base.addLayout(self.layout_canvas)
        # Set the core widget to the window.
        self.setCentralWidget(self.base_widget)
Ejemplo n.º 17
0
    def initUI(self):
        self.setWindowTitle(self.tr("Game of Life"))
        self.setLayout(QVBoxLayout())
        self.layout().setSpacing(0)
        self.layout().setContentsMargins(0, 0, 0, 0)

        self.comboBox = QComboBox()
        self.comboBox.addItems([*QGameOfLife.Games.keys()])
        self.comboBox.currentTextChanged.connect(self.select)
        self.layout().addWidget(self.comboBox)

        self.scene = QGraphicsScene()
        self.view = QGraphicsView(self.scene)
        self.view.setHorizontalScrollBarPolicy(Qt.ScrollBarAlwaysOff)
        self.view.setVerticalScrollBarPolicy(Qt.ScrollBarAlwaysOff)
        self.view.setSizePolicy(
            QSizePolicy(QSizePolicy.Preferred, QSizePolicy.Preferred))
        self.view.setFrameShape(QFrame.NoFrame)
        self.layout().addWidget(self.view)

        self.item = None
        self.timer = QTimer()
        self.timer.setInterval(10)
        self.timer.timeout.connect(self.tick)
        initialGame = random.choice([*QGameOfLife.Games.keys()])
        self.select(initialGame)
        self.view.fitInView(self.item, Qt.KeepAspectRatioByExpanding)
        self.comboBox.setCurrentText(initialGame)
Ejemplo n.º 18
0
    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)
Ejemplo n.º 19
0
 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)
Ejemplo n.º 20
0
 def mouseReleaseEvent(self, event):
     """ Stop mouse pan or zoom mode (apply zoom if valid).
     """
     QGraphicsView.mouseReleaseEvent(self, event)
     scenePos = self.mapToScene(event.pos())
     if event.button() == Qt.LeftButton:
         self.setDragMode(QGraphicsView.NoDrag)
         self.leftMouseButtonReleased.emit(scenePos.x(), scenePos.y())
Ejemplo n.º 21
0
 def wheelEvent(self, e: QWheelEvent):
     if e.modifiers() & Qt.ControlModifier:
         if e.delta() > 0:
             self.view.zoomIn(6)
         else:
             self.view.zoomOut(6)
     else:
         QGraphicsView.wheelEvent(e)
Ejemplo n.º 22
0
 def mousePressEvent(self, evt):
     # do nothing if we don't click on an item
     if not self.itemAt(evt.pos()):
         return
     # only one item can be selected at a time, so deselect if any
     for item in self.scene().selectedItems():
         item.setSelected(False)
     QGraphicsView.mousePressEvent(self, evt)
Ejemplo n.º 23
0
 def initializeGview(self):
     self.scene = GraphicsScene()
     self.scene.setSceneRect(0, 0, 480, 480)
     self.scene.click.connect(self.keepNode)
     self.addNode()
     self.view = QGraphicsView(self.scene)
     self.view.setGeometry(0, 0, 500, 500)
     self.view.scale(1, 1)
Ejemplo n.º 24
0
 def mousePressEvent(self, event):
     """ Start mouse pan or zoom mode.
     """
     scenePos = self.mapToScene(event.pos())
     if event.button() == Qt.LeftButton:
         if self.canPan:
             self.setDragMode(QGraphicsView.ScrollHandDrag)
         self.leftMouseButtonPressed.emit(scenePos.x(), scenePos.y())
     QGraphicsView.mousePressEvent(self, event)
Ejemplo n.º 25
0
 def __init__(self, parent):
     QGraphicsView.__init__(self, parent)
     self.setMinimumWidth(180)
     self.setMaximumWidth(180)
     self.scene = QGraphicsScene()
     self.setScene(self.scene)
     self.text_item = QGraphicsSimpleTextItem()
     self.scene.addItem(self.text_item)
     self.show()
Ejemplo n.º 26
0
class MainWindow(QMainWindow):
    def __init__(self):
        super().__init__()
        self.setWindowTitle("Assignment")
        self.scene = QGraphicsScene()
        self.button = QPushButton("Draw Text Boxes")
        #        self.image = QImage(self.size(), QImage.Format_RGB32)
        #        self.image.fill(Qt.black)
        self.scene.addWidget(self.button)

        self.view = QGraphicsView(self.scene)
        #        self.view.resize(800, 600)
        self.setCentralWidget(self.view)

        self.button.clicked.connect(self.buttonClicked)
        self.view.viewport().installEventFilter(self)

        self.drawing = False
        self.brushSize = 2
        self.brushColor = Qt.black
        self.lastPoint = QPoint()

    def mousePressEvent(self, event):
        #        super(MainWindow, self).mousePressEvent(event)
        if event.button() == Qt.LeftButton:
            self.drawing = True
            self.startPoint = event.pos()
            print(self.drawing)

    def mouseReleaseEvent(self, event):
        if (Qt.LeftButton & self.drawing):
            self.lastPoint = event.pos()
            print(self.startPoint)
            painter = QPainter()
            painter.setPen(
                QPen(self.brushColor, self.brushSize, Qt.SolidLine,
                     Qt.RoundCap, Qt.RoundJoin))
            painter.drawRect(QtCore.QRect(self.startPoint, self.lastPoint))
            self.update()


#    def paintEvent(self, event):
#        canvasPainter = QPainter(self)
#        canvasPainter.drawImage(self.rect())

    def buttonClicked(self):
        self.button.hide()

    def eventFilter(self, obj, event):
        if obj is self.view.viewport():
            if event.type() == QEvent.MouseButtonPress:
                print('mouse press event = ', event.pos())
            elif event.type() == QEvent.MouseButtonRelease:
                self.mouseReleaseEvent(event)
                print('mouse release event = ', event.pos())

        return QWidget.eventFilter(self, obj, event)
Ejemplo n.º 27
0
 def __init__(self,pslScene):
     QGraphicsView.__init__(self)
     self.setScene(pslScene)
     self.scene=pslScene
     self.drawingPolygonEnabled = False
     self.polygonIndex = 0
     self.polygon=[]
     self.polygonArray=[]
     self.polygonArray.append(self.polygon)
Ejemplo n.º 28
0
 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()
Ejemplo n.º 29
0
 def graphics_view_on_key_press(self, event):
     key = event.key()
     if key in (Qt.Key_Left, Qt.Key_Right, Qt.Key_Up, Qt.Key_Down,
                Qt.Key_PageUp, Qt.Key_PageDown):
         # This causes the graphics view to ignore these keys so they can be caught by the bag_widget keyPressEvent
         event.ignore()
     else:
         # Maintains functionality for all other keys QGraphicsView implements
         QGraphicsView.keyPressEvent(self.graphics_view, event)
Ejemplo n.º 30
0
    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()
    def test_setParentItem(self):
        global qgraphics_item_painted

        scene = QGraphicsScene()
        scene.addText("test")
        view = QGraphicsView(scene)

        rect = self.createRoundRect(scene)
        view.show()
        QTimer.singleShot(1000, self.quit_app)
        self.app.exec_()
        self.assert_(qgraphics_item_painted)
Ejemplo n.º 32
0
 def resizeEvent(self, event):
     if self.scene():
         self.scene().setSceneRect(QRectF(QPointF(0, 0), event.size()))
         self._chart.resize(event.size())
         self._coordX.setPos(
             self._chart.size().width()/2 - 50,
             self._chart.size().height() - 20)
         self._coordY.setPos(
             self._chart.size().width()/2 + 50,
             self._chart.size().height() - 20)
         for callout in self._callouts:
             callout.updateGeometry()
     QGraphicsView.resizeEvent(self, event)
Ejemplo n.º 33
0
    def testIt(self):
        scene = QGraphicsScene()

        minSize = QSizeF(30, 100)
        prefSize = QSizeF(210, 100)
        maxSize = QSizeF(300, 100)

        a = createItem(minSize, prefSize, maxSize, "A")
        b = createItem(minSize, prefSize, maxSize, "B")
        c = createItem(minSize, prefSize, maxSize, "C")
        d = createItem(minSize, prefSize, maxSize, "D")

        view = QGraphicsView(scene)
        view.show()
        self.app.exec_()
Ejemplo n.º 34
0
    def initUI(self):
        self.setWindowTitle(self.tr("Game of Life"))
        self.setLayout(QVBoxLayout())
        self.layout().setSpacing(0)
        self.layout().setContentsMargins(0, 0, 0, 0)

        self.comboBox = QComboBox()
        self.comboBox.addItems([*QGameOfLife.Games.keys()])
        self.comboBox.currentTextChanged.connect(self.select)
        self.layout().addWidget(self.comboBox)

        self.scene = QGraphicsScene()
        self.view = QGraphicsView(self.scene)
        self.view.setHorizontalScrollBarPolicy(Qt.ScrollBarAlwaysOff)
        self.view.setVerticalScrollBarPolicy(Qt.ScrollBarAlwaysOff)
        self.view.setSizePolicy(QSizePolicy(QSizePolicy.Preferred, QSizePolicy.Preferred))
        self.view.setFrameShape(QFrame.NoFrame)
        self.layout().addWidget(self.view)

        self.item = None
        self.timer = QTimer()
        self.timer.setInterval(10)
        self.timer.timeout.connect(self.tick)
        initialGame = random.choice([*QGameOfLife.Games.keys()])
        self.select(initialGame)
        self.view.fitInView(self.item, Qt.KeepAspectRatioByExpanding)
        self.comboBox.setCurrentText(initialGame)
    def testQGraphicsProxyWidget(self):
        scene = QGraphicsScene()

        proxy = QGraphicsProxyWidget(None, Qt.Window)
        widget = QLabel('Widget')
        proxy.setWidget(widget)
        proxy.setCacheMode(QGraphicsItem.DeviceCoordinateCache)
        scene.addItem(proxy)
        scene.setSceneRect(scene.itemsBoundingRect())

        view = QGraphicsView(scene)
        view.setRenderHints(QPainter.Antialiasing|QPainter.SmoothPixmapTransform)
        view.setViewportUpdateMode(QGraphicsView.BoundingRectViewportUpdate)
        view.show()

        timer = QTimer.singleShot(100, self.app.quit)
        self.app.exec_()
Ejemplo n.º 36
0
class QGameOfLife(QWidget):

    Games = {
        "Game of Life": (GameOfLife, {'fill_rate': 0.50}),
        "Bacteria": (GrayScottDiffusion, {'coeffs': (0.16, 0.08, 0.035, 0.065)}),
        "Coral": (GrayScottDiffusion, {'coeffs': (0.16, 0.08, 0.062, 0.062)}),
        "Fingerprint": (GrayScottDiffusion, {'coeffs': (0.19, 0.05, 0.060, 0.062)}),
        "Spirals": (GrayScottDiffusion, {'coeffs': (0.10, 0.10, 0.018, 0.050)}),
        "Unstable": (GrayScottDiffusion, {'coeffs': (0.16, 0.08, 0.020, 0.055)}),
        "Worms": (GrayScottDiffusion, {'coeffs': (0.16, 0.08, 0.050, 0.065)}),
        "Zebrafish": (GrayScottDiffusion, {'coeffs': (0.16, 0.08, 0.035, 0.060)}),
    }

    def __init__(self, size=(400, 400)):
        super(QGameOfLife, self).__init__()
        self.size = size
        self.game = None
        self.initUI()
        self.show()

    def initUI(self):
        self.setWindowTitle(self.tr("Game of Life"))
        self.setLayout(QVBoxLayout())
        self.layout().setSpacing(0)
        self.layout().setContentsMargins(0, 0, 0, 0)

        self.comboBox = QComboBox()
        self.comboBox.addItems([*QGameOfLife.Games.keys()])
        self.comboBox.currentTextChanged.connect(self.select)
        self.layout().addWidget(self.comboBox)

        self.scene = QGraphicsScene()
        self.view = QGraphicsView(self.scene)
        self.view.setHorizontalScrollBarPolicy(Qt.ScrollBarAlwaysOff)
        self.view.setVerticalScrollBarPolicy(Qt.ScrollBarAlwaysOff)
        self.view.setSizePolicy(QSizePolicy(QSizePolicy.Preferred, QSizePolicy.Preferred))
        self.view.setFrameShape(QFrame.NoFrame)
        self.layout().addWidget(self.view)

        self.item = None
        self.timer = QTimer()
        self.timer.setInterval(10)
        self.timer.timeout.connect(self.tick)
        initialGame = random.choice([*QGameOfLife.Games.keys()])
        self.select(initialGame)
        self.view.fitInView(self.item, Qt.KeepAspectRatioByExpanding)
        self.comboBox.setCurrentText(initialGame)

    def select(self, name: str):
        self.timer.stop()
        Game, args = QGameOfLife.Games[name]
        self.game = Game(self.size, **args)
        self.tick()
        self.timer.start()

    def tick(self):
        self.game.tick()
        bitmap = self.game.visualize()
        image = QImage(bitmap.data, bitmap.shape[1], bitmap.shape[0], QImage.Format_Grayscale8)
        self.scene.removeItem(self.item)
        pixmap = QPixmap.fromImage(image)
        self.item = self.scene.addPixmap(pixmap)

    def resizeEvent(self, event: QResizeEvent):
        self.view.fitInView(self.item, Qt.KeepAspectRatioByExpanding)

    def sizeHint(self) -> QSize:
        return QSize(self.size[0], self.size[1])
Ejemplo n.º 37
0
 def mouseMoveEvent(self, event):
     self._coordX.setText("X: {0:.2f}"
         .format(self._chart.mapToValue(event.pos()).x()))
     self._coordY.setText("Y: {0:.2f}"
         .format(self._chart.mapToValue(event.pos()).y()))
     QGraphicsView.mouseMoveEvent(self, event)