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()
