def __init__(self, *args, **kwargs): super(DisplayWidget, self).__init__(*args, **kwargs) # We draw to an OpenGL scene, so instantiate # the QGLWidget. gl_format = QtOpenGL.QGLFormat() gl_format.setSampleBuffers(True) gl_format.setDepth(False) self.gl_widget = QtOpenGL.QGLWidget(gl_format) # Set up the view self.view = GraphicsView() self.view.setParent(self) self.view.setViewport(self.gl_widget) self.view.setViewportUpdateMode(QGraphicsView.FullViewportUpdate) # Set up the scene self.scene = OpenGLScene() self.scene.setParent(self) self.overlay_widget = OverlayWidget() self.scene.addWidget(self.overlay_widget) self.overlay_widget.move(QtCore.QPoint(0, 0)) # Assign in the scene to the view. self.view.setScene(self.scene)
def __init__(self, app, logpath, id, sdk_model, row_number): QObject.__init__(self) self.app = app self.logpath = logpath self.window = QMainWindow() self.window.setWindowTitle("Raptor build viewer") self.build_list = BuildListModel(self.logpath) self.controller = BuildController(app, self.build_list, id, sdk_model, row_number) self.view = QDeclarativeView() self.glw = QtOpenGL.QGLWidget() self.view.setViewport(self.glw) self.view.setResizeMode( QtDeclarative.QDeclarativeView.SizeRootObjectToView) self.window.setCentralWidget(self.view) self.rc = self.view.rootContext() self.rc.setContextProperty('controller', self.controller) self.rc.setContextProperty('pyBuildListModel', self.build_list) self.rc.setContextProperty('logpath', self.logpath) self.rc.setContextProperty('info', sdk_model.sdk_info(id)) self.rc.setContextProperty('window', self.window) self.rc.setContextProperty('row', row_number) self.view.setSource('logchooser.qml') self.window.show()
def __init__(self, parent=None): resizable.GraphicsView.__init__(self, parent) cegui.GLContextProvider.__init__(self) # mainly to tone down potential antialiasing self.glFormat = QtOpenGL.QGLFormat() self.glFormat.setSampleBuffers(True) self.glFormat.setSamples(2) self.setViewport(QtOpenGL.QGLWidget(self.glFormat)) # OpenGL doesn't do partial redraws (it isn't practical anyways) self.setViewportUpdateMode(QtGui.QGraphicsView.FullViewportUpdate) # make things slightly faster self.setOptimizationFlags( QtGui.QGraphicsView.DontClipPainter | QtGui.QGraphicsView.DontAdjustForAntialiasing) self.injectInput = False # we might want mouse events self.setMouseTracking(True) # we might want key events self.setFocusPolicy(QtCore.Qt.ClickFocus) # if True, we render always (possibly capped to some FPS) - suitable for live preview # if False, we render only when update() is called - suitable for visual editing self.continuousRendering = True # only applies when we are rendering continuously, it's the max FPS that we will try to achieve self.continuousRenderingTargetFPS = 60
def main(argv): app = QApplication(argv) gl_format = QtOpenGL.QGLFormat() gl_format.setSampleBuffers(True) gl_widget = QtOpenGL.QGLWidget(gl_format) view = GraphicsView() view.setViewport(gl_widget) view.setViewportUpdateMode(QGraphicsView.FullViewportUpdate) scene = OpenGLScene(gl_widget.context()) overlay_widget = OverlayWidget() scene.addWidget(overlay_widget) overlay_widget.change_signal.connect(scene.sliders_changed) scene.rotation_changed.connect(overlay_widget.rotation_changed) overlay_widget.move(QtCore.QPoint(0, 0)) overlay_widget.setAttribute(QtCore.Qt.WA_TranslucentBackground) view.setScene(scene) print view.children() view.show() view.resize(1024, 768) scene.model.setXRotation(45 * 16) sys.exit(app.exec_())
def __init__(self, antialias=False, aspect_locked=False, grid_color=(0, 0, 0, 128), grid_line_width=1.0, use_opengl=False): QtWidgets.QGraphicsView.__init__(self) self.aspect_locked = aspect_locked self.grid_color = grid_color self.grid_line_width = grid_line_width self.setCacheMode(QtWidgets.QGraphicsView.CacheBackground) #self.setFocusPolicy(QtCore.Qt.StrongFocus) #self.setFrameShape(QtGui.QFrame.NoFrame) self.setFrameShape(QtWidgets.QFrame.Box) self.setVerticalScrollBarPolicy(QtCore.Qt.ScrollBarAlwaysOff) self.setHorizontalScrollBarPolicy(QtCore.Qt.ScrollBarAlwaysOff) self.setTransformationAnchor(QtWidgets.QGraphicsView.NoAnchor) #self.setTransformationAnchor(QtGui.QGraphicsView.AnchorViewCenter) self.setResizeAnchor(QtWidgets.QGraphicsView.AnchorViewCenter) self.thaw() if antialias: self.setRenderHints(QtGui.QPainter.Antialiasing) self.setOptimizationFlag(self.DontAdjustForAntialiasing, True) self.setInteractive(False) self.scene = QtWidgets.QGraphicsScene(self) self.setScene(self.scene) #self.aspect_locked = True self.view_rect = QtCore.QRectF(0, 0, 1, 1) self.scene.setSceneRect(self.view_rect) if self.aspect_locked: self.fitInView(self.view_rect, QtCore.Qt.KeepAspectRatio) else: self.fitInView(self.view_rect, QtCore.Qt.IgnoreAspectRatio) if OPENGL_AVAILABLE and use_opengl: if antialias: qglf = QtOpenGL.QGLFormat() qglf.setSampleBuffers(True) qglw = QtOpenGL.QGLWidget(qglf) self.setViewport(qglw) else: self.setViewport(QtOpenGL.QGLWidget()) # dictionary of plot objects such as lines, points, etc. self.plot_items = dict()
def probe(): w = QtOpenGL.QGLWidget() w.makeCurrent() vers = GL.glGetString(GL.GL_VERSION).decode("ascii") v_match = re.match(r"^(\d+(\.\d+)+)\s", vers) # If we can't parse the vers string, who knows what version we have if not v_match: return None g = v_match.group(1).split(".") v1 = int(g[0]) v2 = int(g[1]) return v1, v2
def getSharedWidget(): if not GLWidget.sharedWidget: fmt = QtOpenGL.QGLFormat() fmt.setRgba(True) fmt.setAlpha(True) fmt.setDepth(True) fmt.setDoubleBuffer(True) fmt.setSampleBuffers(True) fmt.setSwapInterval(0) QtOpenGL.QGLFormat.setDefaultFormat(fmt) hiddenWindow = QtOpenGL.QGLWidget(QtOpenGL.QGLContext(fmt)) GLWidget.sharedWidget = hiddenWindow hiddenWindow.makeCurrent() return GLWidget.sharedWidget
def detectSystemResources(cls): try: from PySide import QtOpenGL cls.openGlAvailable = True except ImportError: cls.openGlAvailable = False if cls.openGlAvailable: version_flags = QtOpenGL.QGLFormat.openGLVersionFlags() if version_flags & QtOpenGL.QGLFormat.OpenGL_Version_2_0: cls.glVersion = "2.0 or higher" elif version_flags & QtOpenGL.QGLFormat.OpenGL_Version_1_5: cls.glVersion = "1.5" elif version_flags & QtOpenGL.QGLFormat.OpenGL_Version_1_4: cls.glVersion = "1.4" elif version_flags & QtOpenGL.QGLFormat.OpenGL_Version_1_3: cls.glVersion = "1.3 or lower" cls.debug("- OpenGL version:", cls.glVersion) glw = QtOpenGL.QGLWidget() if (not QtOpenGL.QGLFormat.hasOpenGL() or not glw.format().directRendering() or not (version_flags & QtOpenGL.QGLFormat.OpenGL_Version_1_5) or glw.depth() < 24): cls.openGlAdequate = False cls.debug("- OpenGL not recommended on this system") else: cls.openGlAdequate = False cls.debug("- OpenGL not supported by current build of Qt") if sys.platform == 'win32': # For now. cls.direct3dAvailable = False # Check if X Render is present. if hasattr(QtGui.QPixmap, 'x11PictureHandle'): tmp = QtGui.QPixmap(1, 1) if not tmp.x11PictureHandle(): cls.xRenderPresent = False cls.debug("- X render not present") w = QtGui.QWidget() cls.debug("- Color depth: %d" % w.depth())
def __init__(self, app, window, logpath=None): QObject.__init__(self) self.app = app self.sdk_list_model = SDKListModel() self.controller = SDKController(app, self.sdk_list_model) self.view = QDeclarativeView() self.glw = QtOpenGL.QGLWidget() self.view.setViewport(self.glw) self.view.setResizeMode( QtDeclarative.QDeclarativeView.SizeRootObjectToView) window.setCentralWidget(self.view) self.rc = self.view.rootContext() self.rc.setContextProperty('sdk_controller', self.controller) self.rc.setContextProperty('pySDKListModel', self.sdk_list_model) self.view.setSource('sdkchooser.qml')
def __init__(self, tabbedEditor): resizable.GraphicsView.__init__(self) multi.EditMode.__init__(self) self.wheelZoomEnabled = True self.middleButtonDragScrollEnabled = True self.lastMousePosition = None scene = QtGui.QGraphicsScene() self.setScene(scene) self.setFocusPolicy(QtCore.Qt.ClickFocus) self.setFrameStyle(QtGui.QFrame.NoFrame) if settings.getEntry("imageset/visual/partial_updates").value: # the commented lines are possible optimisation, I found out that they don't really # speed it up in a noticeable way so I commented them out #self.setOptimizationFlag(QGraphicsView.DontSavePainterState, True) #self.setOptimizationFlag(QGraphicsView.DontAdjustForAntialiasing, True) #self.setCacheMode(QGraphicsView.CacheBackground) self.setViewportUpdateMode( QtGui.QGraphicsView.MinimalViewportUpdate) #self.setRenderHint(QPainter.Antialiasing, False) #self.setRenderHint(QPainter.TextAntialiasing, False) #self.setRenderHint(QPainter.SmoothPixmapTransform, False) else: # use OpenGL for view redrawing # depending on the platform and hardware this may be faster or slower self.setViewport(QtOpenGL.QGLWidget()) self.setViewportUpdateMode(QtGui.QGraphicsView.FullViewportUpdate) self.scene().selectionChanged.connect(self.slot_selectionChanged) self.tabbedEditor = tabbedEditor self.setDragMode(QtGui.QGraphicsView.RubberBandDrag) self.setBackgroundBrush(QtGui.QBrush(QtCore.Qt.lightGray)) self.imagesetEntry = None self.dockWidget = ImagesetEditorDockWidget(self) self.setupActions()
def __build_main_window(self): """ Builds the QML interface """ self.mainwindow = QtGui.QMainWindow() self.mainview = QtDeclarative.QDeclarativeView() if OPENGL: glw = QtOpenGL.QGLWidget() self.mainview.setViewport(glw) self.mainview.setResizeMode( QtDeclarative.QDeclarativeView.SizeRootObjectToView) self.engine = self.mainview.engine() self.engine.rootContext().setBaseUrl( QtCore.QUrl.fromLocalFile(os.path.join(ROOT_DIR, "guiQML"))) #set up the family tree list to select from self.dbman = DbManager(self.dbstate, self.engine, self.load_db)
def setUp(self): if self.ctx is None: f = QtOpenGL.QGLFormat() f.setVersion(3, 2) f.setProfile(QtOpenGL.QGLFormat.CoreProfile) self.ctx = QtOpenGL.QGLContext(f) self.mockWidget = QtOpenGL.QGLWidget(self.ctx) self.assertTrue(self.ctx.isValid()) self.ctx.makeCurrent() # Compile the two shaders individually s1 = S.compileShader(VERT_1, GL.GL_VERTEX_SHADER) s2 = S.compileShader(FRAG_1, GL.GL_FRAGMENT_SHADER) # now build the whole program self.prog = S.compileProgram(s1, s2)
def main(argv): # Launch a DeclarativeView app = ButtleApp(argv) decView = QtDeclarative.QDeclarativeView() decView.setViewport(QtOpenGL.QGLWidget()) decView.setViewportUpdateMode( QtDeclarative.QDeclarativeView.FullViewportUpdate) if tuttleofx_installed: QtDeclarative.qmlRegisterType(GLViewport_tuttleofx, "Viewport", 1, 0, "GLViewport") else: QtDeclarative.qmlRegisterType(GLViewport_pil, "Viewport", 1, 0, "GLViewport") decView.setSource(os.path.join(currentFilePath, "Viewer.qml")) decView.setResizeMode(QtDeclarative.QDeclarativeView.SizeRootObjectToView) decView.setWindowTitle("Viewer OpenGL") decView.show() app.exec_()
def initializeSceneGraph(self, graph, ui, **kwargs): """ Instantiate the GraphicsScene. Optionally set the current view widget to a :py:class:`~QtOpenGL.QGLWidget` widget. :param Graph graph: graph instance. :param :py:class:`~QMainWindow` ui: parent window. """ use_gl = kwargs.get('use_gl', ui.use_gl) if use_gl: from PySide import QtOpenGL self.setViewport( QtOpenGL.QGLWidget( QtOpenGL.QGLFormat(QtOpenGL.QGL.SampleBuffers))) log.info('initializing OpenGL renderer.') # pass the Graph instance to the GraphicsScene scene = GraphicsScene(self, graph=graph, ui=ui) scene.setSceneRect(-5000, -5000, 10000, 10000) self.setScene(scene)
def main(): app = QtGui.QApplication(sys.argv) # A new instance of QApplication app.setFont(Branding.font()) pix = QtGui.QPixmap(':img/img/lasp_logo_640.png') splash = QtGui.QSplashScreen(pixmap=pix) splash.show() mw = QtGui.QGraphicsView() glwidget = gl.QGLWidget() mw.setViewport(glwidget) bs = BarScene(None, np.array([10, 20, 300]), 2, ylim=(0, 1)) mw.setScene(bs) bs.set_ydata(np.array([[.1, .2], [.7, .8], [.9, 1]])) # timer = QTimer. print(ASCEEColors.bggreen.getRgb()) mw.show() # Show the form splash.finish(mw) app.exec_() # and execute the app
def __init__(self, app, difftext, leftfile, rightfile): QObject.__init__(self) self.app = app self.difftext = difftext self.window = QMainWindow() self.window.setWindowTitle("Log Diffs") self.leftfile = leftfile self.rightfile = rightfile self.view = QDeclarativeView() self.glw = QtOpenGL.QGLWidget() self.view.setViewport(self.glw) self.view.setResizeMode( QtDeclarative.QDeclarativeView.SizeRootObjectToView) self.window.setCentralWidget(self.view) self.rc = self.view.rootContext() self.rc.setContextProperty('controller', self) self.rc.setContextProperty('difftext', self.difftext) self.view.setSource('diffview.qml') self.window.show()
def setRenderingSystem(self): if Colors.direct3dRendering: viewport.setAttribute(QtCore.Qt.WA_MSWindowsUseDirect3D) self.setCacheMode(QtGui.QGraphicsView.CacheNone) Colors.debug("- using Direct3D") elif Colors.openGlRendering: from PySide import QtOpenGL viewport = QtOpenGL.QGLWidget( QtOpenGL.QGLFormat(QtOpenGL.QGL.SampleBuffers)) if Colors.noScreenSync: viewport.format().setSwapInterval(0) viewport.setAutoFillBackground(False) self.setCacheMode(QtGui.QGraphicsView.CacheNone) Colors.debug("- using OpenGL") else: viewport = QtGui.QWidget() self.setCacheMode(QtGui.QGraphicsView.CacheBackground) Colors.debug("- using software rendering") self.setViewport(viewport)
def main(argv): parser = optparse.OptionParser() parser.add_option("-f", "--fullscreen", dest="fullscreen", help="Start application in fullscreen mode", action="store_true", default=False) (options, args) = parser.parse_args() app = QtGui.QApplication(argv) view = QtDeclarative.QDeclarativeView() view.setSource(QtCore.QUrl("main.qml")) view.setResizeMode(QtDeclarative.QDeclarativeView.SizeRootObjectToView) if options.fullscreen: from PySide import QtOpenGL glw = QtOpenGL.QGLWidget() view.setViewport(glw) view.showFullScreen() else: view.show() app.exec_()
def __init__(self, *args, **kwargs): super(DisplayWidget, self).__init__(*args, **kwargs) # We draw to an OpenGL scene, so instantiate # the QGLWidget. gl_format = QtOpenGL.QGLFormat() gl_format.setSampleBuffers(True) self.gl_widget = QtOpenGL.QGLWidget(gl_format) # Set up the view self.view = GraphicsView() self.view.setViewport(self.gl_widget) self.view.setViewportUpdateMode(QGraphicsView.FullViewportUpdate) # Set up the scene self.scene = OpenGLScene() # Add the controls to it self.overlay_widget = OverlayWidget() self.scene.addWidget(self.overlay_widget) self.overlay_widget.move(QtCore.QPoint(0,0)) self.overlay_widget.setAttribute(QtCore.Qt.WA_TranslucentBackground) # Assign in the scene to the view. self.view.setScene(self.scene) #self.view.show() #self.view.resize(800,600) # Set the scene and view to be a child of this class self.view.setParent(self) self.scene.setParent(self)
def set_opengl_enabled(self, flag): if flag: gl_widget = QtOpenGL.QGLWidget( QtOpenGL.QGLFormat(QtOpenGL.QGL.SampleBuffers)) gl_widget.setMouseTracking(True) self.setViewport(gl_widget)
def __init__(self, width, height): super(Panel, self).__init__() self.selectedX = 0 self.selectedY = 0 self.width = width self.height = height self.flipped = False self.flipLeft = True self.setHorizontalScrollBarPolicy(QtCore.Qt.ScrollBarAlwaysOff) self.setVerticalScrollBarPolicy(QtCore.Qt.ScrollBarAlwaysOff) self.setCacheMode(QtGui.QGraphicsView.CacheBackground) self.setViewportUpdateMode(QtGui.QGraphicsView.FullViewportUpdate) self.setRenderHints(QtGui.QPainter.Antialiasing | QtGui.QPainter.SmoothPixmapTransform | QtGui.QPainter.TextAntialiasing) self.setBackgroundBrush(QtGui.QBrush(QtGui.QPixmap('./images/blue_angle_swirl.jpg'))) if QtOpenGL.QGLFormat.hasOpenGL(): self.setViewport(QtOpenGL.QGLWidget(QtOpenGL.QGLFormat(QtOpenGL.QGL.SampleBuffers))) self.setMinimumSize(50, 50) self.selectionTimeLine = QtCore.QTimeLine(150, self) self.flipTimeLine = QtCore.QTimeLine(500, self) bounds = QtCore.QRectF((-width / 2.0) * 150, (-height / 2.0) * 150, width * 150, height * 150) self.scene = QtGui.QGraphicsScene(bounds, self) self.setScene(self.scene) self.baseItem = RoundRectItem(bounds, QtGui.QColor(226, 255, 92, 64)) self.scene.addItem(self.baseItem) embed = QtGui.QWidget() self.ui = Ui_BackSide() self.ui.setupUi(embed) self.ui.hostName.setFocus() self.backItem = RoundRectItem(bounds, embed.palette().window(), embed) self.backItem.setTransform(QtGui.QTransform().rotate(180, QtCore.Qt.YAxis)) self.backItem.setParentItem(self.baseItem) self.selectionItem = RoundRectItem(QtCore.QRectF(-60, -60, 120, 120), QtCore.Qt.gray) self.selectionItem.setParentItem(self.baseItem) self.selectionItem.setZValue(-1) self.selectionItem.setPos(self.posForLocation(0, 0)) self.startPos = self.selectionItem.pos() self.endPos = QtCore.QPointF() self.grid = [] for y in range(height): self.grid.append([]) for x in range(width): item = RoundRectItem(QtCore.QRectF(-54, -54, 108, 108), QtGui.QColor(214, 240, 110, 128)) item.setPos(self.posForLocation(x, y)) item.setParentItem(self.baseItem) item.setFlag(QtGui.QGraphicsItem.ItemIsFocusable) self.grid[y].append(item) rand = QtCore.qrand() % 9 if rand == 0 : item.setPixmap(QtGui.QPixmap(':/images/kontact_contacts.png')) elif rand == 1: item.setPixmap(QtGui.QPixmap(':/images/kontact_journal.png')) elif rand == 2: item.setPixmap(QtGui.QPixmap(':/images/kontact_notes.png')) elif rand == 3: item.setPixmap(QtGui.QPixmap(':/images/kopeteavailable.png')) elif rand == 4: item.setPixmap(QtGui.QPixmap(':/images/metacontact_online.png')) elif rand == 5: item.setPixmap(QtGui.QPixmap(':/images/minitools.png')) elif rand == 6: item.setPixmap(QtGui.QPixmap(':/images/kontact_journal.png')) elif rand == 7: item.setPixmap(QtGui.QPixmap(':/images/kontact_contacts.png')) elif rand == 8: item.setPixmap(QtGui.QPixmap(':/images/kopeteavailable.png')) else: pass item.qobject.activated.connect(self.flip) self.grid[0][0].setFocus() self.backItem.qobject.activated.connect(self.flip) self.selectionTimeLine.valueChanged.connect(self.updateSelectionStep) self.flipTimeLine.valueChanged.connect(self.updateFlipStep) self.splash = SplashItem() self.splash.setZValue(5) self.splash.setPos(-self.splash.rect().width()/2, self.scene.sceneRect().top()) self.scene.addItem(self.splash) self.splash.grabKeyboard() self.updateSelectionStep(0) self.setWindowTitle("Pad Navigator Example")
pa.addAnimation(anim) anim = QtCore.QPropertyAnimation(parent, 'rotation', parent) anim.setDuration(100) anim.setStartValue(-180) anim.setEndValue(0) pa.addAnimation(anim) pa.start(QtCore.QAbstractAnimation.DeleteWhenStopped) zenItems = [ZenWrapper(zenItem.rstrip()) for zenItem in open(__file__) if zenItem.strip() and not zenItem.startswith(' ')] controller = Controller() zenItemList = ZenListModel(zenItems) app = QtGui.QApplication(sys.argv) view = QtDeclarative.QDeclarativeView() glw = QtOpenGL.QGLWidget() view.setViewport(glw) view.setWindowTitle(__doc__) view.setResizeMode(QtDeclarative.QDeclarativeView.SizeRootObjectToView) rc = view.rootContext() rc.setContextProperty('controller', controller) rc.setContextProperty('pythonListModel', zenItemList) view.setSource(__file__.replace('.py', '.qml')) view.show() app.exec_()
def main(argv): #preload Tuttle tuttle.core().preload() # give to QML acces to TimerPlayer defined in buttleofx/gui/viewer QtDeclarative.qmlRegisterType(TimerPlayer, "TimerPlayer", 1, 0, "TimerPlayer") # add new QML type QtDeclarative.qmlRegisterType(Finder, "FolderListViewItem", 1, 0, "FolderListView") if tuttleofx_installed: QtDeclarative.qmlRegisterType(GLViewport_tuttleofx, "Viewport", 1, 0, "GLViewport") else: QtDeclarative.qmlRegisterType(GLViewport_pil, "Viewport", 1, 0, "GLViewport") # init undo_redo contexts cmdManager = CommandManager() cmdManager.setActive() cmdManager.clean() # create QApplication app = ButtleApp(argv) # create the declarative view view = QtDeclarative.QDeclarativeView() view.setViewport(QtOpenGL.QGLWidget()) view.setViewportUpdateMode(QtDeclarative.QDeclarativeView.FullViewportUpdate) # data buttleData = ButtleDataSingleton().get().init(view, currentFilePath) # manager buttleManager = ButtleManagerSingleton().get().init() # event buttleEvent = ButtleEventSingleton().get() # Menus fileMenu = MenuWrapper("file", 0, view, app) editMenu = MenuWrapper("edit", 0, view, app) addMenu = MenuWrapper("buttle/", 1, view, app) # expose data to QML rc = view.rootContext() rc.setContextProperty("_buttleApp", app) rc.setContextProperty("_buttleData", buttleData) rc.setContextProperty("_buttleManager", buttleManager) rc.setContextProperty("_buttleEvent", buttleEvent) rc.setContextProperty("_fileMenu", fileMenu) rc.setContextProperty("_editMenu", editMenu) rc.setContextProperty("_addMenu", addMenu) # set the view view.setSource(os.path.join(currentFilePath, "MainWindow.qml")) view.setResizeMode(QtDeclarative.QDeclarativeView.SizeRootObjectToView) view.setWindowTitle("ButtleOFX") view.setWindowIcon(QtGui.QIcon("blackMosquito.png")) view.setWindowIconText("ButtleOFX") view.setVisible(True) # Declare we are using instant coding tool on this view qic = QmlInstantCoding(view, verbose=True) # Add any source file (.qml and .js by default) in current working directory qic.addFilesFromDirectory(os.getcwd(), recursive=True) #add._menu.popup(view.mapToGlobal(QtCore.QPoint(0, 0))) view.show() app.exec_()
def __init__(self, width=256, height=256, title=None, visible=True, aspect=None, decoration=True, fullscreen=False, config=None, context=None, color=(0, 0, 0, 1), vsync=False): window.Window.__init__(self, width=width, height=height, title=title, visible=visible, aspect=aspect, decoration=decoration, fullscreen=fullscreen, config=config, context=context, color=color) if config is None: config = configuration.Configuration() set_configuration(config) __glformat__.setSwapInterval(1 if vsync else 0) self._native_app = QtGui.QApplication.instance() if self._native_app is None: self._native_app = QtGui.QApplication(sys.argv) context = QtOpenGL.QGLContext(__glformat__) if context.isValid(): self._native_window = QtOpenGL.QGLWidget(context) else: self._native_window = QtOpenGL.QGLWidget(__glformat__) self._native_window.resize(width, height) self._native_window.makeCurrent() self._native_window.setAutoBufferSwap(False) self._native_window.setMouseTracking(True) self._native_window.setWindowTitle(self._title) self._native_window.show() def paint_gl(): self.dispatch_event("on_draw", 0.0) self._native_window.paintGL = paint_gl def resize_gl(width, height): self.dispatch_event("on_resize", width, height) self._native_window.resizeGL = resize_gl def close_event(event): __windows__.remove(self) for i in range(len(self._timer_stack)): handler, interval = self._timer_stack[i] self._clock.unschedule(handler) self.dispatch_event("on_close") self._native_window.closeEvent = close_event def mouse_press_event(event): x = event.pos().x() y = event.pos().y() button = __mouse_map__.get(event.button(), window.mouse.UNKNOWN) self._button = button self._mouse_x = x self._mouse_y = y self.dispatch_event("on_mouse_press", x, y, button) self._native_window.mousePressEvent = mouse_press_event def mouse_release_event(event): x = event.pos().x() y = event.pos().y() button = __mouse_map__.get(event.button(), window.mouse.UNKNOWN) self._button = window.mouse.NONE self._mouse_x = x self._mouse_y = y self.dispatch_event("on_mouse_release", x, y, button) self._native_window.mouseReleaseEvent = mouse_release_event def mouse_move_event(event): x = event.pos().x() y = event.pos().y() dx = x - self._mouse_x dy = y - self._mouse_y self._mouse_x = x self._mouse_y = y if self._button is not window.mouse.NONE: self.dispatch_event('on_mouse_drag', x, y, dx, dy, self._button) else: self.dispatch_event('on_mouse_motion', x, y, dx, dy) self._native_window.mouseMoveEvent = mouse_move_event def wheel_event(event): if event.orientation == QtCore.Qt.Horizontal: offset_x = event.delta() offset_y = 0 else: offset_x = 0 offset_y = event.delta() x = event.pos().x() y = event.pos().y() self.dispatch_event("on_mouse_scroll", x, y, offset_x / 10.0, offset_y / 10.0) self._native_window.wheelEvent = wheel_event def key_press_event(event): code = self._keyboard_translate(event.key()) modifiers = self._modifiers_translate(event.modifiers()) self.dispatch_event("on_key_press", code, modifiers) self.dispatch_event("on_character", event.text()) self._native_window.keyPressEvent = key_press_event def key_release_event(event): code = self._keyboard_translate(event.key()) modifiers = self._modifiers_translate(event.modifiers()) self.dispatch_event("on_key_release", code, modifiers) self._native_window.keyReleaseEvent = key_release_event __windows__.append(self)
def __init__(self): QtCore.QObject.__init__(self) self.FOTOSHARE_VERSION = "0.9.7" #Oberfläche und Instanzierungen für QML2Py Funktionen self.view = QtDeclarative.QDeclarativeView() #OpenGL Rendering self.glw = QtOpenGL.QGLWidget() self.view.setViewport(self.glw) self.view.setSource(QtCore.QUrl('/opt/FotoShareN9/qml/main.qml')) self.root = self.view.rootObject() #instantiate the Python object self.controller = Controller() #expose the object to QML self.context = self.view.rootContext() self.context.setContextProperty('controller', self.controller) self.config_path = '/home/user/.config/fotoshare.cfg' #loads all important data and settings self.preload_settings() #Holds pid of daemon, if running, else it's empty. self.pid = '' #returns the pid of a running daemon to self.pid self.getPID() print "The daemons PID is: " + str(self.pid) #set GUI Buttons etc. depending from settings ---------------- #check for first start self.is_first_start() #create new settings cfg if version needs new one self.check_version() #check if daemon boots on startup and set slider on GUI self.check_daemon_startup() #check resize switch and slider self.check_resize_options() #check other options from GUI ButtonRows self.check_button_options() #check that dropbox is linked or not and show on UI self.check_dropbox_link() #Change menu text in dependency to log status in cfg self.check_log_file() #holds ssh hostkey self.hostkey = None #Holds dropbox appkey and app secret for authentification self.APP_KEY = 'uvxyouqhkdljbdn' self.APP_SECRET = '09sd2chtvifn5aj' self.ACCESS_TYPE = 'app_folder' #Connections from Controller() class for QML/Py communication self.controller.signal_settings_saver.connect(self.save_settings) self.controller.signal_settings_loader.connect(self.load_settings) #Connection for daemon start self.controller.signal_daemon_on_off.connect(self.start_stop_daemon) #Connection for daemon on boot option self.controller.signal_startupDaemon.connect( self.activate_startup_daemon) #Connection for resize switch/slider self.controller.signal_resize_photos.connect(self.save_resize_option) #Connections for option ButtonRow elements self.controller.signal_notification_select.connect( self.save_notification_type) self.controller.signal_video_select.connect( self.save_video_upload_option) self.controller.signal_wifi3g_select.connect(self.save_wifi3g_option) self.controller.signal_upload_type_select.connect( self.save_upload_type) self.controller.signal_save_interval_time.connect( self.save_interval_times) #TIMES not TIME! ;) #Test connections and settings set in GUI self.controller.signal_contest.connect(self.test_connection) #Reset all settings self.controller.signal_settings_reset.connect(self.reset_settings) #Activate LOG File self.controller.signal_activate_log.connect(self.enable_log) #Dropbox authentification process stuff self.controller.signal_dropbox_authweb.connect( self.get_dropbox_auth_weblink) self.controller.signal_dropbox_authsave.connect( self.save_dropbox_auth_token) self.controller.signal_dropbox_unlink.connect( self.unlink_dropbox_connection)
def __init__(self, panora, type, size=(854, 480)): self.panora = panora self.activePage = None # Create Qt application and the QDeclarative view class ModifiedQDeclarativeView(QDeclarativeView): def __init__(self, gui): QDeclarativeView.__init__(self) self.gui = gui def closeEvent(self, event): print("shutting down") self.gui.panora.destroy() self.app = QApplication(sys.argv) self.view = ModifiedQDeclarativeView(self) # try OpenGl acceleration glw = QtOpenGL.QGLWidget() self.view.setViewport(glw) self.window = QMainWindow() self.window.resize(*size) self.window.setCentralWidget(self.view) self.view.setResizeMode(QDeclarativeView.SizeRootObjectToView) # add image providers # self.pageProvider = MangaPageImageProvider(self) self.iconProvider = IconImageProvider() # self.view.engine().addImageProvider("page",self.pageProvider) self.view.engine().addImageProvider("icons", self.iconProvider) rc = self.view.rootContext() # make the main context accessible from QML rc.setContextProperty("panora", Panora(self)) # make options accessible from QML options = Options(self.panora) rc.setContextProperty("options", options) # make platform module accessible from QML platform = Platform(self.panora) rc.setContextProperty("platform", platform) # activate translation translator = QtCore.QTranslator(self.app) if self.panora.args.locale is not None: localeId = self.panora.args.locale else: localeId = locale.getlocale()[0] translator.load("gui/qml/i18n/qml_" + localeId) self.app.installTranslator(translator) # Set the QML file and show self.view.setSource(QUrl('gui/qml/main.qml')) self.view.show() self.window.closeEvent = self._qtWindowClosed self.rootObject = self.view.rootObject() self.toggleFullscreen() # check if first start dialog has to be shown if self.panora.get("QMLShowFirstStartDialog", True): self.rootObject.openFirstStartDialog()