def __init__(self, actions, parent=None):
QWidget.__init__(self, parent)
itab_item.ITabItem.__init__(self)
self.actions = actions
self.graphicView = QGraphicsView(self)
self.scene = QGraphicsScene()
self.graphicView.setScene(self.scene)
self.graphicView.setViewportUpdateMode(
QGraphicsView.BoundingRectViewportUpdate)
vLayout = QVBoxLayout(self)
self.setLayout(vLayout)
vLayout.addWidget(self.graphicView)
self.scene.setItemIndexMethod(QGraphicsScene.NoIndex)
self.scene.setSceneRect(-200, -200, 400, 400)
self.graphicView.setMinimumSize(400, 400)
actualProject = self.actions.ide.explorer.get_actual_project()
arrClasses = self.actions._locator.get_classes_from_project(
actualProject)
#FIXME:dirty need to fix
self.mX = -400
self.mY = -320
self.hightestY = self.mY
filesList = []
for elem in arrClasses:
#loking for paths
filesList.append(elem[2])
for path in set(filesList):
self.create_class(path)
def setUp(self):
import logging
from PyQt4.QtGui import QApplication, QGraphicsScene, QGraphicsView, \
QPainter
from PyQt4.QtCore import QTimer
logging.basicConfig()
self.app = QApplication([])
self.scene = QGraphicsScene()
self.view = QGraphicsView(self.scene)
self.view.setRenderHints(
QPainter.Antialiasing | \
QPainter.SmoothPixmapTransform | \
QPainter.TextAntialiasing
)
self.view.resize(500, 300)
self.view.show()
QTimer.singleShot(10000, self.app.exit)
def my_excepthook(*args):
sys.setrecursionlimit(1010)
traceback.print_exc(limit=4)
self._orig_excepthook = sys.excepthook
sys.excepthook = my_excepthook
self.singleShot = QTimer.singleShot
def __init__(self, parent=None):
super(MainForm, self).__init__(parent)
self.Running = False
self.scene = QGraphicsScene(self)
self.scene.setSceneRect(0, 0, SCENESIZEX, SCENESIZEY)
self.view = QGraphicsView()
self.view.setRenderHint(QPainter.Antialiasing)
self.view.setScene(self.scene)
self.view.setFocusPolicy(Qt.NoFocus)
#self.zoomSlider = QSlider(Qt.Horizontal)
#self.zoomSlider.setRange(5, 200)
#self.zoomSlider.setValue(100)
self.pauseButton = QPushButton("Pa&use")
self.quitButton = QPushButton("&Quit")
layout = QVBoxLayout()
layout.addWidget(self.view)
#layout.addWidget(self.zoomSlider)
layout.addWidget(self.pauseButton)
layout.addWidget(self.quitButton)
self.setLayout(layout)
#self.connect(self.zoomSlider, SIGNAL("valueChanged(int))"),
# self.zoom)
self.connect(self.pauseButton, SIGNAL("clicked()"), self.pauseOrResume)
self.connect(self.quitButton, SIGNAL("clicked()"), self.accept)
self.readNodes()
self.zoom(1.0)
self.populate()
#self.startTimer(INTERVAL)
self.setWindowTitle("TdPaleo")
def createWidget(self):
"""
Create the widget
"""
self.diagramScene = QGraphicsScene(self)
self.view = QGraphicsView(self.diagramScene)
self.view.setRenderHint(QPainter.Antialiasing)
# set the main layout
layout = QVBoxLayout()
self.logEdit = QTextEdit()
self.logEdit.setReadOnly(True)
hSplitter2 = QSplitter(self)
hSplitter2.setOrientation(Qt.Vertical)
hSplitter2.addWidget(self.view)
hSplitter2.addWidget(self.logEdit)
hSplitter2.setStretchFactor(0, 1)
layout.addWidget(hSplitter2)
self.setLayout(layout)
def setUp(self):
QAppTestCase.setUp(self)
self.scene = CanvasScene()
self.view = QGraphicsView(self.scene)
self.view.setRenderHint(QPainter.Antialiasing)
self.view.show()
self.view.resize(600, 400)
def __init__(self):
QWidget.__init__(self)
self.setFixedSize(640,480)
top = QWidget()
topLayout = QHBoxLayout()
top.setLayout(topLayout)
title = QLabel("尋寶遊戲");
title.setFont(QFont("verdana",25,QFont.Bold))
topLayout.addWidget(title)
lcd = QLCDNumber()
lcd.setSegmentStyle(QLCDNumber.Flat)
lcd.setFrameStyle(QFrame.StyledPanel|QFrame.Plain)
topLayout.addWidget(lcd)
self.myScene = scene.Scene()
self.connect(self.myScene, SIGNAL("steroidTaken(int)"), lcd, SLOT("display(int)"))
view = QGraphicsView()
view.setAutoFillBackground(True)
view.setScene(self.myScene)
layout = QVBoxLayout()
layout.addWidget(top)
layout.addWidget(view)
self.setLayout(layout)
def __init__(self):
# init the widget
#QWidget.__init__(self, parent)
# set up the scene
self.scene = QGraphicsScene()
self.scene.setSceneRect(0, 0, 800, 600)
# add a view of that scene
self.view = QGraphicsView()
self.view.setScene(self.scene)
self.view.setRenderHint(QPainter.Antialiasing)
self.view.setFixedSize(800, 600)
self.view.setHorizontalScrollBarPolicy(Qt.ScrollBarAlwaysOff)
self.view.setVerticalScrollBarPolicy(Qt.ScrollBarAlwaysOff)
# set the screen sync to vertical retrace
val = "1"
# Set for nVidia linux
os.environ["__GL_SYNC_TO_VBLANK"] = val
# Set for recent linux Mesa DRI Radeon
os.environ["LIBGL_SYNC_REFRESH"] = val
qglf = QGLFormat()
qglf.setSampleBuffers(True)
self.glw = QGLWidget(qglf)
self.glw.setAutoBufferSwap(False)
self.view.setViewport(self.glw)
#self.view.showFullScreen()
self.view.show()
self.last_finish = 0
QTimer.singleShot(0, self.glw.swapBuffers)
def test_editlinksnode(self):
from ...registry.tests import small_testing_registry
reg = small_testing_registry()
file_desc = reg.widget("Orange.widgets.data.owfile.OWFile")
bayes_desc = reg.widget("Orange.widgets.classify.ownaivebayes."
"OWNaiveBayes")
source_node = SchemeNode(file_desc, title="This is File")
sink_node = SchemeNode(bayes_desc)
scene = QGraphicsScene()
view = QGraphicsView(scene)
node = EditLinksNode(node=source_node)
scene.addItem(node)
node = EditLinksNode(direction=Qt.RightToLeft)
node.setSchemeNode(sink_node)
node.setPos(300, 0)
scene.addItem(node)
view.show()
view.resize(800, 300)
self.app.exec_()
def __setupUi(self):
layout = QVBoxLayout()
# Scene with the link editor.
self.scene = LinksEditScene()
self.view = QGraphicsView(self.scene)
self.view.setHorizontalScrollBarPolicy(Qt.ScrollBarAlwaysOff)
self.view.setVerticalScrollBarPolicy(Qt.ScrollBarAlwaysOff)
self.view.setRenderHint(QPainter.Antialiasing)
self.scene.editWidget.geometryChanged.connect(self.__onGeometryChanged)
# Ok/Cancel/Clear All buttons.
buttons = QDialogButtonBox(
QDialogButtonBox.Ok | QDialogButtonBox.Cancel
| QDialogButtonBox.Reset, Qt.Horizontal)
clear_button = buttons.button(QDialogButtonBox.Reset)
clear_button.setText(self.tr("Clear All"))
buttons.accepted.connect(self.accept)
buttons.rejected.connect(self.reject)
clear_button.clicked.connect(self.scene.editWidget.clearLinks)
layout.addWidget(self.view)
layout.addWidget(buttons)
self.setLayout(layout)
layout.setSizeConstraint(QVBoxLayout.SetFixedSize)
self.setSizeGripEnabled(False)
def __init__(self, parent=None):
super(TestDlg, self).__init__(parent)
self.mymodel = None
self.myscene = DragEnabledScene(QRectF(-400,-300,800,600))
self.myview = QGraphicsView()
self.myview.setScene(self.myscene)
self.myfile = None
layout = QVBoxLayout()
layout.addWidget(self.myview)
buttonLayout = QHBoxLayout()
self.savebutton = QPushButton('Save')
self.loadbutton = QPushButton('Load')
self.renderbutton = QPushButton('Accept')
buttonLayout.addWidget(self.savebutton)
buttonLayout.addWidget(self.loadbutton)
buttonLayout.addWidget(self.renderbutton)
layout.addLayout(buttonLayout)
self.statusbar = QStatusBar()
layout.addWidget(self.statusbar)
self.statusbar.showMessage("Ready.",2000)
self.setLayout(layout)
self.loadfromInitData()
self.savebutton.pressed.connect(self.saveMatrix)
self.loadbutton.pressed.connect(self.loadMatrix)
self.myscene.selectionChanged.connect(self.updateStatus)
self.myscene.modelchanged.connect(self.changeModel)
self.renderbutton.pressed.connect(self.testDistance)
def __init__(self, parent=None):
super().__init__(parent)
## Attributes
self.data = None
self.distances = None
self.groups = None
self.unique_pos = None
self.base_group_index = 0
## GUI
box = gui.widgetBox(self.controlArea, "Info")
self.info_box = gui.widgetLabel(box, "\n")
## Separate By box
box = gui.widgetBox(self.controlArea, "Separate By")
self.split_by_model = itemmodels.PyListModel(parent=self)
self.split_by_view = QListView()
self.split_by_view.setSelectionMode(QListView.ExtendedSelection)
self.split_by_view.setModel(self.split_by_model)
box.layout().addWidget(self.split_by_view)
self.split_by_view.selectionModel().selectionChanged.connect(
self.on_split_key_changed)
## Sort By box
box = gui.widgetBox(self.controlArea, "Sort By")
self.sort_by_model = itemmodels.PyListModel(parent=self)
self.sort_by_view = QListView()
self.sort_by_view.setSelectionMode(QListView.ExtendedSelection)
self.sort_by_view.setModel(self.sort_by_model)
box.layout().addWidget(self.sort_by_view)
self.sort_by_view.selectionModel().selectionChanged.connect(
self.on_sort_key_changed)
## Distance box
box = gui.widgetBox(self.controlArea, "Distance Measure")
gui.comboBox(box,
self,
"selected_distance_index",
items=[name for name, _ in self.DISTANCE_FUNCTIONS],
callback=self.on_distance_measure_changed)
self.scene = QGraphicsScene()
self.scene_view = QGraphicsView(self.scene)
self.scene_view.setRenderHints(QPainter.Antialiasing)
self.scene_view.setAlignment(Qt.AlignLeft | Qt.AlignVCenter)
self.mainArea.layout().addWidget(self.scene_view)
self.scene_view.installEventFilter(self)
self._disable_updates = False
self._cached_distances = {}
self._base_index_hints = {}
self.main_widget = None
self.resize(800, 600)
def __init__(self,parent=None, signalManager = None):
OWWidget.__init__(self, parent, signalManager, "Sieve diagram", True)
#self.controlArea.setMinimumWidth(250)
#set default settings
self.data = None
self.attrX = ""
self.attrY = ""
self.attrCondition = ""
self.attrConditionValue = ""
self.showLines = 1
self.showCases = 0
self.showInColor = 1
self.attributeSelectionList = None
self.stopCalculating = 0
self.canvas = QGraphicsScene()
self.canvasView = QGraphicsView(self.canvas, self.mainArea)
self.mainArea.layout().addWidget(self.canvasView)
self.canvasView.setVerticalScrollBarPolicy(Qt.ScrollBarAlwaysOff)
self.canvasView.setHorizontalScrollBarPolicy(Qt.ScrollBarAlwaysOff)
#GUI
self.attrSelGroup = gui.widgetBox(self.controlArea, box = "Shown attributes")
self.attrXCombo = gui.comboBox(self.attrSelGroup, self, value="attrX", label="X attribute:", orientation="horizontal", tooltip = "Select an attribute to be shown on the X axis", callback = self.updateGraph, sendSelectedValue = 1, valueType = str, labelWidth = 70)
self.attrYCombo = gui.comboBox(self.attrSelGroup, self, value="attrY", label="Y attribute:", orientation="horizontal", tooltip = "Select an attribute to be shown on the Y axis", callback = self.updateGraph, sendSelectedValue = 1, valueType = str, labelWidth = 70)
gui.separator(self.controlArea)
self.conditionGroup = gui.widgetBox(self.controlArea, box = "Condition")
self.attrConditionCombo = gui.comboBox(self.conditionGroup, self, value="attrCondition", label="Attribute:", orientation="horizontal", callback = self.updateConditionAttr, sendSelectedValue = 1, valueType = str, labelWidth = 70)
self.attrConditionValueCombo = gui.comboBox(self.conditionGroup, self, value="attrConditionValue", label="Value:", orientation="horizontal", callback = self.updateGraph, sendSelectedValue = 1, valueType = str, labelWidth = 70)
gui.separator(self.controlArea)
box2 = gui.widgetBox(self.controlArea, box = "Visual settings")
gui.checkBox(box2, self, "showLines", "Show lines", callback = self.updateGraph)
hbox = gui.widgetBox(box2, orientation = "horizontal")
gui.checkBox(hbox, self, "showCases", "Show data examples...", callback = self.updateGraph)
gui.checkBox(hbox, self, "showInColor", "...in color", callback = self.updateGraph)
gui.separator(self.controlArea)
# self.optimizationDlg = OWSieveOptimization(self, self.signalManager)
# optimizationButtons = gui.widgetBox(self.controlArea, "Dialogs", orientation = "horizontal")
# gui.button(optimizationButtons, self, "VizRank", callback = self.optimizationDlg.reshow, debuggingEnabled = 0, tooltip = "Find attribute groups with highest value dependency")
gui.rubber(self.controlArea)
# self.wdChildDialogs = [self.optimizationDlg] # used when running widget debugging
# self.graphButton.clicked.connect(self.saveToFileCanvas)
self.icons = gui.attributeIconDict
self.resize(800, 550)
random.seed()
def test_graphicstextwidget(self):
scene = QGraphicsScene()
view = QGraphicsView(scene)
text = GraphicsTextWidget()
text.setHtml("<center><b>a text</b></center><p>paragraph</p>")
scene.addItem(text)
view.show()
view.resize(400, 300)
self.app.exec_()
def main():
app = QApplication(sys.argv)
mainView = QGraphicsView()
scene = QGraphicsScene()
pixmap = QPixmap(r":/8a130311.png")
scene.addPixmap(
pixmap.scaled(100, 100, QtCore.Qt.IgnoreAspectRatio,
QtCore.Qt.SmoothTransformation))
mainView.setScene(scene)
mainView.show()
app.exec_()
def __init__(self):
QWidget.__init__(self)
self.main_layout = QGridLayout()
self.steps_spin = QSpinBox()
self.steps_spin.setRange(1, 12)
self.steps_label = QLabel("steps:")
self.steps_slider = QSlider(1) #horizontal
self.steps_slider.setRange(1, 12)
self.smooth_spin = QSpinBox()
self.smooth_spin.setRange(1, 100)
self.smooth_label = QLabel("smoothness:")
self.smooth_slider = QSlider(1) #horizontal
self.smooth_slider.setRange(0, 100)
self.smooth_slider.setSingleStep(1)
self.dampen_spin = QSpinBox()
self.dampen_spin.setRange(1, 100)
self.dampen_label = QLabel("dampening:")
self.dampen_slider = QSlider(1) #horizontal
self.dampen_slider.setRange(0, 100)
self.dampen_slider.setSingleStep(1)
self.update_button = QPushButton("update")
self.view = QGraphicsView()
self.main_layout.addWidget(self.steps_spin, 0, 0)
self.main_layout.addWidget(self.steps_label, 0, 1)
self.main_layout.addWidget(self.steps_slider, 0, 2)
self.main_layout.addWidget(self.smooth_spin, 1, 0)
self.main_layout.addWidget(self.smooth_label, 1, 1)
self.main_layout.addWidget(self.smooth_slider, 1, 2)
self.main_layout.addWidget(self.dampen_spin, 2, 0)
self.main_layout.addWidget(self.dampen_label, 2, 1)
self.main_layout.addWidget(self.dampen_slider, 2, 2)
self.main_layout.addWidget(self.update_button, 3, 0, 1, 3)
self.main_layout.addWidget(
self.view,
4,
0,
1, #rowSpan
3) #columnSpan
self.setLayout(self.main_layout)
def __init__ (self):
QMainWindow.__init__ (self)
self.controller = Controller ()
self.listener = LeapListener (self)
self.controller.add_listener (self.listener)
self.mode = "gallery"
self.scroll = False
self.direction = ""
self.direction_x = 0
self.scroll_velocity = 0
self.current_index = 0
# List containing images for the gallery
self.list_view = QListWidget ()
self.list_view.setFlow (0)
self.list_view.setHorizontalScrollMode (1)
self.list_view.setMouseTracking (True)
self.list_view.itemClicked.connect (self.show_image)
# Setting the style of the ListView, background, item selected, etc
self.list_view.setStyleSheet ("""
QListWidget::item:hover {background: transparent;}
QListWidget::item:disabled:hover {background: transparent;}
QListWidget::item:hover:!active {background: transparent;}
QListWidget::item:selected:active {background: transparent;}
QListWidget::item:selected:!active {background: transparent;}
QListWidget::item:selected:disabled {background: transparent;}
QListWidget::item:selected:!disabled {background: transparent;}
QListWidget {background: #2C3539}
""")
# Image viewer
self.scene = QGraphicsScene ()
self.viewer = QGraphicsView (self.scene)
self.stackedWidget = QStackedWidget ()
self.stackedWidget.addWidget (self.list_view)
self.stackedWidget.addWidget (self.viewer)
self.setCentralWidget (self.stackedWidget)
self.resize (500, 400)
self.showMaximized ()
scan = ScanLibrary ("/home/chris/Example")
threads.append (scan)
self.connect (scan, SIGNAL (scan.signal), self.add_images_to_list)
scan.start ()
self.connect (self, SIGNAL ("scrollChanged(bool)"), self.scroll_view)
def axis_view(orientation):
ax = pg.AxisItem(orientation=orientation, maxTickLength=7)
scene = QGraphicsScene()
scene.addItem(ax)
view = QGraphicsView(
scene,
horizontalScrollBarPolicy=Qt.ScrollBarAlwaysOff,
verticalScrollBarPolicy=Qt.ScrollBarAlwaysOn,
alignment=Qt.AlignLeft | Qt.AlignVCenter)
view.setFixedHeight(ax.size().height())
ax.line = SliderLine(orientation=Qt.Horizontal,
length=ax.size().height())
scene.addItem(ax.line)
return view, ax
def render(self):
self.create_menu('Sound', self.song_actions)
self.create_menu('Speed', self.speed_actions)
view = QGraphicsView(self.scene)
self.setCentralWidget(view)
#set window to size of background image, need some extra pixels to fit menu bar and crap
#TODO: Do not need this on Ubuntu
self.resize(self.background_pixmap.width() + 2,
self.background_pixmap.height() + 23)
self.center_window()
self.setWindowTitle(Application.NAME)
self.setWindowIcon(QIcon(FileLocation.ICON_IMAGE_LOCATION))
def main():
app = QApplication(sys.argv)
grview = QGraphicsView()
scene = QGraphicsScene()
scene.setSceneRect(0, 0, 680, 459)
scene.addPixmap(QPixmap('01.png'))
grview.setScene(scene)
item = GraphicsRectItem(0, 0, 300, 150)
scene.addItem(item)
grview.fitInView(scene.sceneRect(), Qt.KeepAspectRatio)
grview.show()
sys.exit(app.exec_())
def __set_layout(self):
"""
Set layout of this widget
"""
self.scene = QGraphicsScene()
layout = QHBoxLayout()
self.view = QGraphicsView(self.scene)
self.view.setFocusPolicy(Qt.StrongFocus)
self.view.installEventFilter(self)
self.view.setHorizontalScrollBarPolicy(Qt.ScrollBarAlwaysOff)
self.view.setVerticalScrollBarPolicy(Qt.ScrollBarAlwaysOff)
layout.addWidget(self.view)
self.setLayout(layout)
def __initializeUi(self):
"""
Initializes the Widget ui.
"""
LOGGER.debug("> Initializing '{0}' ui.".format(self.__class__.__name__))
self.Previous_Image_pushButton.setIcon(QIcon(os.path.join(self.__uiResourcesDirectory, self.__uiPreviousImage)))
self.Next_Image_pushButton.setIcon(QIcon(os.path.join(self.__uiResourcesDirectory, self.__uiNextImage)))
self.Zoom_In_pushButton.setIcon(QIcon(os.path.join(self.__uiResourcesDirectory, self.__uiZoomInImage)))
self.Zoom_Out_pushButton.setIcon(QIcon(os.path.join(self.__uiResourcesDirectory, self.__uiZoomOutImage)))
len(self.__paths) <= 1 and self.Navigation_frame.hide()
LOGGER.debug("> Initializing graphics View.")
self.__graphicsView = QGraphicsView()
self.__graphicsView.setHorizontalScrollBarPolicy(Qt.ScrollBarAlwaysOff)
self.__graphicsView.setVerticalScrollBarPolicy(Qt.ScrollBarAlwaysOff)
self.__graphicsView.setTransformationAnchor(QGraphicsView.AnchorUnderMouse)
self.__graphicsView.setDragMode(QGraphicsView.ScrollHandDrag)
# Reimplementing QGraphicsView wheelEvent method.
self.__graphicsView.wheelEvent = self.wheelEvent
LOGGER.debug("> Initializing graphics scene.")
self.__graphicsScene = QGraphicsScene(self.__graphicsView)
self.__graphicsScene.setItemIndexMethod(QGraphicsScene.NoIndex)
self.__graphicsScene.setSceneRect(-(float(self.__graphicsSceneWidth)) / 2,
- (float(self.__graphicsSceneHeight)) / 2,
float(self.__graphicsSceneWidth),
float(self.__graphicsSceneHeight))
self.__graphicsView.setScene(self.__graphicsScene)
self.__graphicsView.setBackgroundBrush(QBrush(self.__graphicsSceneBackgroundColor))
self.Images_Previewer_frame_gridLayout.addWidget(self.__graphicsView)
# Signals / Slots.
self.__container.engine.imagesCaches.QImage.contentAdded.connect(self.__engine_imagesCaches_QImage__contentAdded)
self.Previous_Image_pushButton.clicked.connect(self.__Previous_Image_pushButton__clicked)
self.Next_Image_pushButton.clicked.connect(self.__Next_Image_pushButton__clicked)
self.Zoom_Out_pushButton.clicked.connect(self.__Zoom_Out_pushButton__clicked)
self.Zoom_In_pushButton.clicked.connect(self.__Zoom_In_pushButton__clicked)
self.Zoom_Fit_pushButton.clicked.connect(self.__Zoom_Fit_pushButton__clicked)
def test(self):
raw = numpy.load(
os.path.join(volumina._testing.__path__[0],
'lena.npy')).astype(numpy.uint32)
ars = _ArraySource2d(raw)
ims = DummyItemSource(ars)
req = ims.request(QRect(0, 0, 256, 256))
item = req.wait()
assert isinstance(item, QGraphicsItem)
DEBUG = False
if DEBUG:
from PyQt4.QtGui import QApplication, QGraphicsView, QGraphicsScene
app = QApplication([])
scene = QGraphicsScene()
scene.addItem(item)
view = QGraphicsView(scene)
view.show()
view.raise_()
app.exec_()
def __init__(self, parent=None):
super(TakeDragGame, self).__init__(parent)
# This is always the same
self.dot2 = QGraphicsTextItem(':')
self.dot1 = QGraphicsTextItem(':')
self.animations = []
self.digits = []
self.main_layout = QHBoxLayout()
self.setLayout(self.main_layout)
self.scene = QGraphicsScene()
self.scene.setSceneRect(0, 0, 600, 400)
self.view = QGraphicsView()
self.view.setScene(self.scene)
# TODO: Check if its better with opengl or not
# self.view.setViewport(QtOpenGL.QGLWidget())
self.main_layout.addWidget(self.view)
# self.setWindowState(Qt.WindowMaximized)
self.view.setAlignment(Qt.AlignTop | Qt.AlignLeft)
self.image_bank = None
self.create_and_add_images()
def showSet(self):
#self.snippet_preview
bound = self.boundaries[self.current]
#print self.current
#print bound[1]
image = self.images[bound[0]][bound[1][1] - 2:bound[1][3] + 3,
bound[1][0] - 2:bound[1][2] + 2]
self.drawSnippet(self.snippet_preview, image)
for gview in self.gviews:
self.grid.removeWidget(gview)
gview.deleteLater()
gview = None
for ledit in self.ledits:
self.grid.removeWidget(ledit)
ledit.deleteLater()
ledit = None
self.gviews = []
self.ledits = []
letters = len(self.words[self.current])
for i in range(letters):
gview = QGraphicsView()
self.grid.addWidget(gview, 0, i)
self.gviews.append(gview)
gview.setMaximumSize(50, self.settings['snippet_size'])
gview.setVerticalScrollBarPolicy(1)
gview.setHorizontalScrollBarPolicy(1)
self.drawSnippet(gview, self.words[self.current][i][0])
ledit = QLineEdit()
self.grid.addWidget(ledit, 1, i)
self.ledits.append(ledit)
ledit.setMaximumSize(50, self.settings['input_size'])
ledit.setAlignment(Qt.AlignHCenter)
ledit.setText(self.words[self.current][i][1])
for index, item in zip(range(50), self.ledits):
item.textEdited.connect(partial(self.changeText, index))
self.repaint()
"""
y = mappedParentRect.top(
) + NodeGraphicsItem.LEAFSIZE[1] / 2
elif y > mappedParentRect.bottom(
) - NodeGraphicsItem.LEAFSIZE[1] / 2:
y = mappedParentRect.bottom(
) - NodeGraphicsItem.LEAFSIZE[1] / 2
value = QPointF(x, y)
elif change == QGraphicsItem.ItemPositionHasChanged:
self.model.pos = value if isinstance(
value, QPointF) else value.toPointF()
return super(NodeGraphicsItem, self).itemChange(change, value)
if __name__ == '__main__':
from PyQt4.QtGui import QApplication, QGraphicsView, QGraphicsScene
from treenode import TreeNode
import sys
app = QApplication(sys.argv)
myview = QGraphicsView()
myscene = QGraphicsScene(QRectF(-400, -300, 800, 600))
myview.setScene(myscene)
rootnode = TreeNode(0, 'root')
parentnode = TreeNode(1, 'grass land', parent=rootnode)
leafnode = TreeNode(2, 'grass 1', parent=parentnode)
# leafnode2 = TreeNode(3,'earth',parent=parentnode)
myscene.addItem(NodeGraphicsItem(parentnode))
myview.show()
app.exec_()
def __init__(self, parent=None):
super().__init__(parent)
# Output changed flag
self._changed = False
# Diagram update is in progress
self._updating = False
# Input update is in progress
self._inputUpdate = False
# All input tables have the same domain.
self.samedomain = True
# Input datasets in the order they were 'connected'.
self.data = OrderedDict()
# Extracted input item sets in the order they were 'connected'
self.itemsets = OrderedDict()
# GUI
box = gui.widgetBox(self.controlArea, "Info")
self.info = gui.widgetLabel(box, "No data on input\n")
self.identifiersBox = gui.radioButtonsInBox(
self.controlArea,
self,
"useidentifiers", [],
box="Data Instance Identifiers",
callback=self._on_useidentifiersChanged)
self.useequalityButton = gui.appendRadioButton(
self.identifiersBox, "Use instance equality")
rb = gui.appendRadioButton(self.identifiersBox, "Use identifiers")
self.inputsBox = gui.indentedBox(self.identifiersBox,
sep=gui.checkButtonOffsetHint(rb))
self.inputsBox.setEnabled(bool(self.useidentifiers))
for i in range(5):
box = gui.widgetBox(self.inputsBox,
"Data set #%i" % (i + 1),
addSpace=False)
box.setFlat(True)
model = itemmodels.VariableListModel(parent=self)
cb = QComboBox()
cb.setModel(model)
cb.activated[int].connect(self._on_inputAttrActivated)
box.setEnabled(False)
# Store the combo in the box for later use.
box.combo_box = cb
box.layout().addWidget(cb)
gui.rubber(self.controlArea)
box = gui.widgetBox(self.controlArea, "Output")
cb = gui.checkBox(box, self, "autocommit", "Commit on any change")
b = gui.button(box, self, "Commit", callback=self.commit, default=True)
gui.setStopper(self, b, cb, "_changed", callback=self.commit)
# Main area view
self.scene = QGraphicsScene()
self.view = QGraphicsView(self.scene)
self.view.setRenderHint(QPainter.Antialiasing)
self.view.setBackgroundRole(QPalette.Window)
self.view.setFrameStyle(QGraphicsView.StyledPanel)
self.mainArea.layout().addWidget(self.view)
self.vennwidget = VennDiagram()
self.vennwidget.resize(400, 400)
self.vennwidget.itemTextEdited.connect(self._on_itemTextEdited)
self.scene.selectionChanged.connect(self._on_selectionChanged)
self.scene.addItem(self.vennwidget)
self.resize(self.controlArea.sizeHint().width() + 550,
max(self.controlArea.sizeHint().height(), 550))
self._queue = []
def __init__(self, dataDir="", parent=None):
QWidget.__init__(self, parent)
self.renderer = QSvgRenderer(dataDir + "poker.svg")
self.scene = QGraphicsScene()
self.chat = QGraphicsSimpleTextItem()
self.table = QGraphicsSvgItem(dataDir + "poker.svg")
self.table.setSharedRenderer(self.renderer)
self.table.setElementId("table")
self.table.setMatrix(self.renderer.matrixForElement("transform_table"))
self.scene.addItem(self.chat)
self.scene.addItem(self.table)
self.board = []
for i in range(5):
card = AnimatedGraphicsSvgItem(dataDir + "svg-cards.svg",
self.table)
card.setElementId("back")
parent = self.renderer.matrixForElement("transform_table")
child = self.renderer.matrixForElement("transform_card%i" % i)
cardMatrix = child.translate(-parent.dx(), -parent.dy())
card.setMatrix(cardMatrix)
#card.setFlag(QGraphicsSvgItem.ItemIsMovable, True)
card.scale(0.5, 0.5)
card.hide()
self.scene.addItem(card)
self.board.append(card)
self.seats = []
self.names = []
self.moneys = []
self.bets = []
for i in range(10):
seat = SeatItem()
def seatClickedEvent(seat=i):
seatClickedCallback = self.seatClicked
seatClickedCallback(seat)
seat.event = seatClickedEvent
seat.setSharedRenderer(self.renderer)
seat.setElementId("seat")
seat.setMatrix(
self.renderer.matrixForElement("transform_seat%i" % i))
self.scene.addItem(seat)
self.seats.append(seat)
name = QGraphicsSimpleTextItem(seat)
name.setMatrix(self.renderer.matrixForElement("seat_name"))
self.scene.addItem(name)
self.names.append(name)
money = QGraphicsSimpleTextItem(seat)
money.setMatrix(self.renderer.matrixForElement("seat_money"))
self.scene.addItem(money)
self.moneys.append(money)
bet = QGraphicsSimpleTextItem()
bet.setMatrix(self.renderer.matrixForElement("transform_bet%i" %
i))
self.scene.addItem(bet)
self.bets.append(bet)
self.pots = []
for i in range(9):
pot = QGraphicsSimpleTextItem()
pot.setMatrix(self.renderer.matrixForElement("transform_pot%i" %
i))
self.scene.addItem(pot)
self.pots.append(pot)
self.view = QGraphicsView(self)
self.view.setScene(self.scene)
self.view.resize(800, 600)
self.fold = ActionItem()
self.fold.setText("fold")
self.fold.setPos(0, 550)
self.scene.addItem(self.fold)
self.fold.event = lambda: self.foldClicked()
self.check = ActionItem()
self.check.setText("check")
self.check.setPos(50, 550)
self.scene.addItem(self.check)
self.check.event = lambda: self.checkClicked()
self.call = ActionItem()
self.call.setText("call")
self.call.setPos(100, 550)
self.scene.addItem(self.call)
self.call.event = lambda: self.callClicked()
self.bet = ActionItem()
self.bet.setText("bet")
self.bet.setPos(150, 550)
self.scene.addItem(self.bet)
self.bet.event = lambda: self.betClicked()
def __init__(self, parent=None):
super().__init__(parent)
self.info = gui.widgetLabel(gui.widgetBox(self.controlArea, "Info"),
"Waiting for input\n")
self.imageAttrCB = gui.comboBox(
self.controlArea,
self,
"imageAttr",
box="Image Filename Attribute",
tooltip="Attribute with image filenames",
callback=[self.clearScene, self.setupScene],
addSpace=True)
self.titleAttrCB = gui.comboBox(self.controlArea,
self,
"titleAttr",
box="Title Attribute",
tooltip="Attribute with image title",
callback=self.updateTitles,
addSpace=True)
gui.hSlider(self.controlArea,
self,
"zoom",
box="Zoom",
minValue=1,
maxValue=100,
step=1,
callback=self.updateZoom,
createLabel=False)
gui.separator(self.controlArea)
gui.auto_commit(self.controlArea, self, "autoCommit", "Commit",
"Auto commit")
gui.rubber(self.controlArea)
self.scene = GraphicsScene()
self.sceneView = QGraphicsView(self.scene, self)
self.sceneView.setAlignment(Qt.AlignTop | Qt.AlignLeft)
self.sceneView.setRenderHint(QPainter.Antialiasing, True)
self.sceneView.setRenderHint(QPainter.TextAntialiasing, True)
self.sceneView.setFocusPolicy(Qt.WheelFocus)
self.sceneView.setVerticalScrollBarPolicy(Qt.ScrollBarAlwaysOn)
self.sceneView.installEventFilter(self)
self.mainArea.layout().addWidget(self.sceneView)
self.scene.selectionChanged.connect(self.onSelectionChanged)
self.scene.selectionRectPointChanged.connect(
self.onSelectionRectPointChanged, Qt.QueuedConnection)
self.graphButton.clicked.connect(self.saveScene)
self.resize(800, 600)
self.thumbnailWidget = None
self.sceneLayout = None
self.selectedIndices = []
#: List of _ImageItems
self.items = []
self._errcount = 0
self._successcount = 0
self.loader = ImageLoader(self)
start = time.time()
path_items = generate_path_items_for_labels(pen_table, labels_img, None)
print "generate took {}".format(time.time() - start) # 52 ms
edges_item = SegmentationEdgesItem(path_items, pen_table)
def assign_random_color(id_pair, buttons):
print "handling click: {}".format(id_pair)
pen = pen_table[id_pair]
if pen:
pen = QPen(pen)
else:
pen = QPen()
random_color = QColor(*list(np.random.randint(0, 255, (3, ))))
pen.setColor(random_color)
pen_table[id_pair] = pen
edges_item.edgeClicked.connect(assign_random_color)
scene = QGraphicsScene()
scene.addItem(edges_item)
transform = QTransform()
transform.scale(5.0, 5.0)
view = QGraphicsView(scene)
view.setTransform(transform)
view.show()
view.raise_()
app.exec_()
def __init__(self, parent=None):
super().__init__(parent)
self.matrix = None
self.items = None
self.linkmatrix = None
self.root = None
self._displayed_root = None
self.cutoff_height = 0.0
self._invalidated = False
gui.comboBox(gui.widgetBox(self.controlArea, "Linkage"),
self,
"linkage",
items=LINKAGE,
callback=self._invalidate_clustering)
box = gui.widgetBox(self.controlArea, "Annotation")
self.label_cb = gui.comboBox(box,
self,
"annotation_idx",
callback=self._update_labels)
self.label_cb.setModel(itemmodels.VariableListModel())
self.label_cb.model()[:] = ["None", "Enumeration"]
box = gui.radioButtons(self.controlArea,
self,
"pruning",
box="Pruning",
callback=self._invalidate_pruning)
grid = QGridLayout()
box.layout().addLayout(grid)
grid.addWidget(gui.appendRadioButton(box, "None", addToLayout=False),
0, 0)
self.max_depth_spin = gui.spin(box,
self,
"max_depth",
minv=1,
maxv=100,
callback=self._invalidate_pruning,
keyboardTracking=False)
grid.addWidget(
gui.appendRadioButton(box, "Max depth", addToLayout=False), 1, 0)
grid.addWidget(self.max_depth_spin, 1, 1)
box = gui.radioButtons(self.controlArea,
self,
"selection_method",
box="Selection",
callback=self._selection_method_changed)
grid = QGridLayout()
box.layout().addLayout(grid)
grid.addWidget(gui.appendRadioButton(box, "Manual", addToLayout=False),
0, 0)
grid.addWidget(
gui.appendRadioButton(box, "Height ratio", addToLayout=False), 1,
0)
self.cut_ratio_spin = gui.spin(box,
self,
"cut_ratio",
0,
100,
step=1e-1,
spinType=float,
callback=self._selection_method_changed)
self.cut_ratio_spin.setSuffix("%")
grid.addWidget(self.cut_ratio_spin, 1, 1)
grid.addWidget(gui.appendRadioButton(box, "Top N", addToLayout=False),
2, 0)
self.top_n_spin = gui.spin(box,
self,
"top_n",
1,
20,
callback=self._selection_method_changed)
grid.addWidget(self.top_n_spin, 2, 1)
box.layout().addLayout(grid)
self.controlArea.layout().addStretch()
box = gui.widgetBox(self.controlArea, "Output")
gui.checkBox(box,
self,
"append_clusters",
"Append cluster IDs",
callback=self._invalidate_output)
ibox = gui.indentedBox(box)
name_edit = gui.lineEdit(ibox, self, "cluster_name")
name_edit.editingFinished.connect(self._invalidate_output)
cb = gui.comboBox(
ibox,
self,
"cluster_role",
callback=self._invalidate_output,
items=["Attribute", "Class variable", "Meta variable"])
form = QFormLayout(fieldGrowthPolicy=QFormLayout.AllNonFixedFieldsGrow,
labelAlignment=Qt.AlignLeft,
spacing=8)
form.addRow("Name", name_edit)
form.addRow("Place", cb)
ibox.layout().addSpacing(5)
ibox.layout().addLayout(form)
ibox.layout().addSpacing(5)
cb = gui.checkBox(box, self, "autocommit", "Commit automatically")
b = gui.button(box, self, "Commit", callback=self.commit, default=True)
gui.setStopper(self, b, cb, "_invalidated", callback=self.commit)
self.scene = QGraphicsScene()
self.view = QGraphicsView(
self.scene,
horizontalScrollBarPolicy=Qt.ScrollBarAlwaysOff,
verticalScrollBarPolicy=Qt.ScrollBarAlwaysOn,
alignment=Qt.AlignLeft | Qt.AlignVCenter)
def axis_view(orientation):
ax = pg.AxisItem(orientation=orientation, maxTickLength=7)
scene = QGraphicsScene()
scene.addItem(ax)
view = QGraphicsView(
scene,
horizontalScrollBarPolicy=Qt.ScrollBarAlwaysOff,
verticalScrollBarPolicy=Qt.ScrollBarAlwaysOn,
alignment=Qt.AlignLeft | Qt.AlignVCenter)
view.setFixedHeight(ax.size().height())
ax.line = SliderLine(orientation=Qt.Horizontal,
length=ax.size().height())
scene.addItem(ax.line)
return view, ax
self.top_axis_view, self.top_axis = axis_view("top")
self.mainArea.layout().setSpacing(1)
self.mainArea.layout().addWidget(self.top_axis_view)
self.mainArea.layout().addWidget(self.view)
self.bottom_axis_view, self.bottom_axis = axis_view("bottom")
self.mainArea.layout().addWidget(self.bottom_axis_view)
self._main_graphics = QGraphicsWidget()
self._main_layout = QGraphicsLinearLayout(Qt.Horizontal)
self._main_layout.setSpacing(1)
self._main_graphics.setLayout(self._main_layout)
self.scene.addItem(self._main_graphics)
self.dendrogram = DendrogramWidget()
self.dendrogram.setSizePolicy(QSizePolicy.MinimumExpanding,
QSizePolicy.MinimumExpanding)
self.dendrogram.selectionChanged.connect(self._invalidate_output)
self.dendrogram.selectionEdited.connect(self._selection_edited)
fm = self.fontMetrics()
self.dendrogram.setContentsMargins(5,
fm.lineSpacing() / 2, 5,
fm.lineSpacing() / 2)
self.labels = GraphicsSimpleTextList()
self.labels.setSizePolicy(QSizePolicy.Preferred, QSizePolicy.Preferred)
self.labels.setAlignment(Qt.AlignLeft)
self.labels.setMaximumWidth(200)
self.labels.layout().setSpacing(0)
self._main_layout.addItem(self.dendrogram)
self._main_layout.addItem(self.labels)
self._main_layout.setAlignment(self.dendrogram,
Qt.AlignLeft | Qt.AlignVCenter)
self._main_layout.setAlignment(self.labels,
Qt.AlignLeft | Qt.AlignVCenter)
self.view.viewport().installEventFilter(self)
self.top_axis_view.viewport().installEventFilter(self)
self.bottom_axis_view.viewport().installEventFilter(self)
self._main_graphics.installEventFilter(self)
self.cut_line = SliderLine(self.dendrogram, orientation=Qt.Horizontal)
self.cut_line.valueChanged.connect(self._dendrogram_slider_changed)
self.cut_line.hide()
self.bottom_axis.line.valueChanged.connect(self._axis_slider_changed)
self.top_axis.line.valueChanged.connect(self._axis_slider_changed)
self.dendrogram.geometryChanged.connect(self._dendrogram_geom_changed)
self._set_cut_line_visible(self.selection_method == 1)
