def __init__(self, appdata: CnaData, name: str):
self.scene = QGraphicsScene()
QGraphicsView.__init__(self, self.scene)
palette = self.palette()
palette.setColor(QPalette.Base, Qt.white)
self.setPalette(palette)
self.appdata = appdata
self.name = name
self.setAcceptDrops(True)
self.drag = False
self.reaction_boxes: Dict[str, ReactionBox] = {}
self._zoom = 0
self.drag = False
self.drag_start = None
# initial scale
self._zoom = self.appdata.project.maps[self.name]["zoom"]
if self._zoom > 0:
for _ in range(1, self._zoom):
self.scale(INCREASE_FACTOR, INCREASE_FACTOR)
if self._zoom < 0:
for _ in range(self._zoom, -1):
self.scale(DECREASE_FACTOR, DECREASE_FACTOR)
# connect events to methods
self.horizontalScrollBar().valueChanged.connect(self.on_hbar_change)
self.verticalScrollBar().valueChanged.connect(self.on_vbar_change)
def __init__(self, camera, **settings):
super(CroppableCameraView, self).__init__()
self.setRenderHint(QPainter.Antialiasing)
self.cam = camera
self.is_live = False
self._cmin = 0
self._cmax = None
self.settings = settings
self._selecting = False
self.needs_resize = False
self.latest_array = None
self.setVerticalScrollBarPolicy(Qt.ScrollBarAlwaysOff)
self.setHorizontalScrollBarPolicy(Qt.ScrollBarAlwaysOff)
self.scene = QGraphicsScene()
#self.setFrameStyle(QFrame.NoFrame)
self.setScene(self.scene)
self.pixmapitem = self.scene.addPixmap(QPixmap())
self._uncropped_pixmap = None
self.setMouseTracking(True)
self.start = None
c1 = QColor(0, 100, 220, 150)
self.c2 = QColor(0, 100, 220, 50)
self.c3 = QColor(0, 100, 220, 0)
pen = QPen(c1, 2)
self.selrect = self.scene.addRect(1, 1, 1, 1, pen, self.c3)
self.selrect.setZValue(100)
self.selrect.hide()
def showImage(self, posterPath: str):
self.removeImage()
imgData = requests.get(self.__poster_url__ + posterPath)
pix = QPixmap()
pix.loadFromData(imgData.content)
item = QGraphicsPixmapItem(pix)
self.__scene__ = QGraphicsScene(self)
self.__scene__.addItem(item)
self.ui.graphicsView.setScene(self.__scene__)
self.resizeImage()
def setup_gfx_ui():
# design overview
self.motor_display_view = QGraphicsView()
self.motor_display_scene = QGraphicsScene()
self.motor_display_view.setScene(self.motor_display_scene)
self.motor_display_view.show()
# sliced cross section
self.grain_slice_view = QGraphicsView()
self.grain_slice_scene = QGraphicsScene()
self.grain_slice_view.setScene(self.grain_slice_scene)
self.grain_slice_view.show()
# splitter
self.splt_gfx = QSplitter(Qt.Horizontal)
self.splt_gfx.addWidget(self.motor_display_view)
self.splt_gfx.addWidget(self.grain_slice_view)
self.splt_gfx.setStretchFactor(0, 10)
self.splt_gfx.setStretchFactor(1, 3)
self.splt_gfx.setMinimumHeight(50)
def __init__(self, **kwargs):
super(GraphicsView, self).__init__(**kwargs)
self._scene = QGraphicsScene(parent=self)
self.current_image = QGraphicsPixmapItem()
self._scene.addItem(self.current_image)
self.setScene(self._scene)
self.fitInView(self._scene.sceneRect(), Qt.KeepAspectRatio)
self.setTransformationAnchor(QGraphicsView.AnchorUnderMouse)
self.setHorizontalScrollBarPolicy(Qt.ScrollBarAlwaysOn)
self.setVerticalScrollBarPolicy(Qt.ScrollBarAlwaysOn)
self.setMouseTracking(True)
self.setRenderHint(QPainter.Antialiasing)
def __init__(self, parent=None):
super(SvgView, self).__init__(parent)
self.signal = NodeSignal()
self.renderer = SvgView.Native
self.__svg_items = []
self.__wrapper_item = None
self.__svg_renderer = QSvgRenderer()
self.setScene(QGraphicsScene(self))
self.setTransformationAnchor(QGraphicsView.AnchorUnderMouse)
self.setDragMode(QGraphicsView.ScrollHandDrag)
self.setViewportUpdateMode(QGraphicsView.FullViewportUpdate)
self.setViewport(QWidget())
self.setBackgroundBrush(
QBrush(QColor(QPalette().color(QPalette.Active, QPalette.Window))))
def __init__(self, parent=None):
super(GraphicsView, self).__init__(parent)
self.scene = QGraphicsScene()
self.pixmapItem = QGraphicsPixmapItem()
self.scene.setSceneRect(0, 0, 500, 500)
self.setScene(self.scene)
self.scene.addItem(self.pixmapItem)
#would eventually make this fit to size of screen, waiting cause it's annoying.
self.buildingParams = []
self.scalef = [1, 1]
self.Buildings()
def __init__(self, parent=None):
super(DataGraphWidget, self).__init__(parent=parent)
# Set up scene
self.scene = QGraphicsScene(self)
self.scene.setItemIndexMethod(QGraphicsScene.NoIndex)
self.scene.setSceneRect(0, 0, 800, 300)
self.setScene(self.scene)
self.setWindowTitle("Glue data graph")
self.setRenderHint(QPainter.Antialiasing)
self.setTransformationAnchor(QGraphicsView.AnchorUnderMouse)
self.setResizeAnchor(QGraphicsView.AnchorViewCenter)
self.selection_level = 0
def __init__(self, item) -> None:
QGraphicsView.__init__(self)
scene = QGraphicsScene(self)
self.setScene(scene)
item.setMinimumSize(QSize(150, 150))
item.setMaximum(36000)
item.setSingleStep(100)
item.setPageStep(100)
item.setInvertedAppearance(True)
item.setWrapping(True)
item.setNotchTarget(.1)
item.setNotchesVisible(True)
graphics_item = scene.addWidget(item)
graphics_item.setRotation(-90)
# make the QGraphicsView invisible.
self.setHorizontalScrollBarPolicy(Qt.ScrollBarAlwaysOff)
self.setVerticalScrollBarPolicy(Qt.ScrollBarAlwaysOff)
self.setFixedHeight(item.height())
self.setFixedWidth(item.width())
self.setStyleSheet("border: 0px;")
def __init__(self, parent: QWidget):
super(QRotatableView, self).__init__(parent)
scene = QGraphicsScene(self)
self.setScene(scene)
self.dial = QDial()
self.dial.setMinimumSize(QSize(150, 150))
self.dial.setSingleStep(100)
self.dial.setPageStep(100)
self.dial.setInvertedAppearance(True)
self.dial.setWrapping(True)
self.dial.setNotchTarget(0.1)
self.dial.setNotchesVisible(True)
self.dial.valueChanged.connect(self.__value_changed)
self.set_maximum(360)
graphics_item = scene.addWidget(self.dial)
graphics_item.setRotation(-90)
# make the QGraphicsView invisible.
self.setHorizontalScrollBarPolicy(Qt.ScrollBarAlwaysOff)
self.setVerticalScrollBarPolicy(Qt.ScrollBarAlwaysOff)
self.setFixedHeight(self.dial.height())
self.setFixedWidth(self.dial.width())
self.setStyleSheet("border: 0px;")
def __init__(self, parent=None):
super(TestWidgetItem, self).__init__(parent)
scene = QGraphicsScene()
self.setScene(scene)
self.line_item = LineItem()
self.line_item.setLine(0, 0, 10, 10)
self.line_item2 = LineItem()
self.line_item2.setLine(30, 30, 40, 40)
self.circle_item = CenterManipulatorItem()
self.circle_item.setRect(10, 10, 50, 50)
self.text_item = TextItem()
self.scene().addItem(self.text_item)
self.scene().addItem(self.circle_item)
self.scene().addItem(self.line_item)
self.scene().addItem(self.line_item2)
self.scene().setSceneRect(0,0,100,100)
self.setMouseTracking(True)
def __init__(self):
super().__init__()
self.labeledSlider = VLabeledSlider()
self._qscene = QGraphicsScene()
self._qscene.setSceneRect(-self._size / 2, -self._size / 2, self._size,
self._size)
self._qview = BlockDiagramView(scene=self._qscene, parent=self)
layout = QHBoxLayout()
layout.addWidget(self.labeledSlider, 0)
layout.addWidget(self._qview, 1)
layout.setAlignment(Qt.AlignCenter)
self.widgetLayout = layout
groupBox = QGroupBox()
groupBox.setTitle("Block diagram")
groupBox.setLayout(layout)
parentLayout = QVBoxLayout()
parentLayout.addWidget(groupBox)
self.setLayout(parentLayout)
def __init__(self, width, height, pixel_ratio, path):
super().__init__()
self.ui = Ui_MainWindow()
self.ui.setupUi(self)
# overwrite dimesions specified in slideShow3.py, as they are specific to MacBookPro display, and QTDesigner
# has its own idea on what they should be. This code should work on any size display
self.resize(width, height)
self.ui.graphicsView.setGeometry(QtCore.QRect(0, 0, width, height))
self.ui.menubar.setGeometry(QtCore.QRect(0, 0, width, 0))
self.width = width
self.height = height
self.pixel_ratio = pixel_ratio
self.path = path
self.imageFiles = []
self.slideIndex = -1
self.random_index_number = 0
self.random = ""
self.imageFiles, self.random_index, self.path, self.max_index = self.getImageNames2(
)
self.helpFile = os.path.join(
os.path.dirname(os.path.realpath(sys.argv[0])), "instructions.png")
#print(self.helpFile)
self.scene = QGraphicsScene(self)
#self.scene.setAlignment(QtCore.Qt.AlignCenter)
self.ui.actionDir.triggered.connect(self.openFileNameDialog)
self.ui.actionStart_Slide_Show.triggered.connect(self.slide_show)
self.ui.actionRandom_Slide_Show.triggered.connect(
self.random_slide_show)
eventFilter = MouseEventFilter(self.scene)
self.scene.installEventFilter(eventFilter)
self.ui.actionHelp.triggered.connect(self.helpWindow)
#self.show()
self.showFullScreen()
def __init__(self, item):
super().__init__()
self._shown = False
self.modified_callback = None
scene = QGraphicsScene()
self.scene = scene
self.scene_item = item
scene.addItem(item)
layout = QBoxLayout(QBoxLayout.TopToBottom, self)
scene_view = View(self)
self.scene_view = scene_view
scene_view.setScene(scene)
scene_view.setMinimumSize(350, 350)
scene_view.setRenderHint(QPainter.Antialiasing)
layout.addWidget(scene_view)
self.double_click_callback = None
self.mouse_press_callback = None
if hasattr(self.scene_item, "mouse_pressed_in"):
self.mouse_press_callback = self.scene_item.mouse_pressed_in
if hasattr(self.scene_item, "double_clicked_in_background"):
self.double_click_callback = \
self.scene_item.double_clicked_in_background
if hasattr(self.scene_item, "mouse_moved_in_scene"):
self.scene_view.mouse_move_callback = \
self.scene_item.mouse_moved_in_scene
self.menus = []
view_menu = QMenu("&View")
self.view_menu = view_menu
self.menus.append(view_menu)
export_menu = QMenu("&Export")
self.menus.append(export_menu)
self.tools = []
fit_action = QAction("&Fit", self)
fit_action.setShortcut("0")
fit_action.setIcon(QIcon.fromTheme("zoom-fit-best"))
fit_action.setStatusTip("Fit the entire scene to the viewport")
fit_action.triggered.connect(self.scene_view.fit_all_in_view)
view_menu.addAction(fit_action)
self.tools.append(fit_action)
reset_action = QAction("&Reset (1:1)", self)
reset_action.setShortcut("9")
reset_action.setIcon(QIcon.fromTheme("zoom-original"))
reset_action.setStatusTip("Reset the view to 100% scale")
reset_action.triggered.connect(self.scene_view.reset_scale)
view_menu.addAction(reset_action)
self.tools.append(reset_action)
zoom_in_action = QAction("Zoom &In", self)
zoom_in_action.setShortcuts(["+", "="])
zoom_in_action.setStatusTip("Zoom in")
zoom_in_action.triggered.connect(lambda: self.scene_view.zoom_in())
view_menu.addAction(zoom_in_action)
zoom_out_action = QAction("Zoom &Out", self)
zoom_out_action.setShortcuts(["-", "_"])
zoom_out_action.setStatusTip("Zoom out")
zoom_out_action.triggered.connect(lambda: self.scene_view.zoom_out())
view_menu.addAction(zoom_out_action)
export_svg_action = QAction("As &SVG...", self)
export_svg_action.setStatusTip("Export the current tab as an SVG file")
export_svg_action.triggered.connect(lambda: export_as_svg(self.scene))
export_menu.addAction(export_svg_action)
export_png_action = QAction("As PN&G...", self)
export_png_action.setStatusTip("Export the current tab as an PNG file")
export_png_action.triggered.connect(lambda: export_as_png(self.scene))
export_menu.addAction(export_png_action)
export_pdf_action = QAction("As &PDF...", self)
export_pdf_action.setStatusTip("Export the current tab as an PDF file")
export_pdf_action.triggered.connect(lambda: export_as_pdf(self.scene))
export_menu.addAction(export_pdf_action)
export_svg_clip_action = QAction("To Clipboard as SVG", self)
export_svg_clip_action.setStatusTip(
"Export the current tab to the clipoard in SVG format")
export_svg_clip_action.triggered.connect(
lambda: export_to_clipboard_as_svg(self.scene))
export_menu.addAction(export_svg_clip_action)
export_image_clip_action = QAction("To &Clipboard as Image", self)
export_image_clip_action.setStatusTip(
"Export the current tab to the clipoard as an image")
export_image_clip_action.triggered.connect(
lambda: export_to_clipboard_as_image(self.scene))
export_menu.addAction(export_image_clip_action)
self.resize(800, 600)
def load_graphics_image(self, image_address: str):
self.graphics_scene = QGraphicsScene()
self.graphics_scene.addPixmap(QPixmap(image_address))
self.graphicsView.setScene(self.graphics_scene)
def __init__(self, *args, **kwargs):
self.scene = QGraphicsScene()
super(FlatStem, self).__init__(self.scene, *args, **kwargs)
self._length = length
def spacing(self):
return self._spacing
def setSpacing(self, spacing):
self._spacing = spacing
if __name__ == '__main__':
import sys
from qtpy.QtWidgets import QApplication, QGraphicsView, QGraphicsScene
from qtpy.QtGui import QCursor
app = QApplication(sys.argv)
v = QGraphicsView()
s = QGraphicsScene()
v.setSceneRect(0, 0, 200, 200)
v.setScene(s)
# GRADIENT
g = drawColorTypeGradient(attrs.HUE, 100, 100)
g.setFinalStop(0, 300)
s.setBackgroundBrush(QBrush(g))
#LINE
l = DualColoredLineSegment()
l.setLine(0, 0, 300, 300)
s.addItem(l)
v.show()
v.move(QCursor.pos())
sys.exit(app.exec_())