예제 #1
0
void QQuickPinchArea::clearPinch()
{
    Q_D(QQuickPinchArea);

    d->touchPoints.clear();
    if (d->inPinch) {
        d->inPinch = false;
        QPointF pinchCenter = mapFromScene(d->sceneLastCenter);
        QQuickPinchEvent pe(pinchCenter, d->pinchLastScale, d->pinchLastAngle, d->pinchRotation);
        pe.setStartCenter(d->pinchStartCenter);
        pe.setPreviousCenter(pinchCenter);
        pe.setPreviousAngle(d->pinchLastAngle);
        pe.setPreviousScale(d->pinchLastScale);
        pe.setStartPoint1(mapFromScene(d->sceneStartPoint1));
        pe.setStartPoint2(mapFromScene(d->sceneStartPoint2));
        pe.setPoint1(mapFromScene(d->lastPoint1));
        pe.setPoint2(mapFromScene(d->lastPoint2));
        emit pinchFinished(&pe);
        if (d->pinch && d->pinch->target())
            d->pinch->setActive(false);
    }
    d->pinchStartDist = 0;
    d->pinchActivated = false;
    d->initPinch = false;
    d->pinchRejected = false;
    d->stealMouse = false;
    d->id1 = -1;
    QQuickWindow *win = window();
    if (win && win->mouseGrabberItem() == this)
        ungrabMouse();
    setKeepMouseGrab(false);
}
예제 #2
0
void Highlight::setItem(QQuickItem *item)
{
    if (m_item)
        m_item->disconnect(this);

    if (item) {
        connect(item, &QQuickItem::xChanged, this, &Highlight::adjust);
        connect(item, &QQuickItem::yChanged, this, &Highlight::adjust);
        connect(item, &QQuickItem::widthChanged, this, &Highlight::adjust);
        connect(item, &QQuickItem::heightChanged, this, &Highlight::adjust);
        connect(item, &QQuickItem::rotationChanged, this, &Highlight::adjust);
        connect(item, &QQuickItem::transformOriginChanged, this, &Highlight::adjust);
    }
    QQuickWindow *view = item->window();
    QQuickItem * contentItem = view->contentItem();
    if (contentItem) {
        connect(contentItem, &QQuickItem::xChanged, this, &Highlight::adjust);
        connect(contentItem, &QQuickItem::yChanged, this, &Highlight::adjust);
        connect(contentItem, &QQuickItem::widthChanged, this, &Highlight::adjust);
        connect(contentItem, &QQuickItem::heightChanged, this, &Highlight::adjust);
        connect(contentItem, &QQuickItem::rotationChanged, this, &Highlight::adjust);
        connect(contentItem, &QQuickItem::transformOriginChanged, this, &Highlight::adjust);
    }
    m_item = item;
    setContentsSize(view->size());
    adjust();
}
예제 #3
0
void QQuickMouseArea::mouseReleaseEvent(QMouseEvent *event)
{
    Q_D(QQuickMouseArea);
    d->stealMouse = false;
    if (!d->enabled && !d->pressed) {
        QQuickItem::mouseReleaseEvent(event);
    } else {
        d->saveEvent(event);
        setPressed(event->button(), false);
        if (!d->pressed) {
            // no other buttons are pressed
#ifndef QT_NO_DRAGANDDROP
            if (d->drag)
                d->drag->setActive(false);
#endif
            // If we don't accept hover, we need to reset containsMouse.
            if (!acceptHoverEvents())
                setHovered(false);
            QQuickWindow *w = window();
            if (w && w->mouseGrabberItem() == this)
                ungrabMouse();
            setKeepMouseGrab(false);
        }
    }
    d->doubleClick = false;
}
예제 #4
0
파일: goqml.cpp 프로젝트: chai2010/qml
QImage_ *windowGrabWindow(QQuickWindow_ *win)
{
    QQuickWindow *qwin = reinterpret_cast<QQuickWindow *>(win);
    QImage *image = new QImage;
    *image = qwin->grabWindow().convertToFormat(QImage::Format_ARGB32_Premultiplied);
    return image;
}
예제 #5
0
void Highlight::setItem(QQuickItem *item)
{
    if (m_item)
        m_item->disconnect(this);

    if (item) {
        connect(item, SIGNAL(xChanged()), SLOT(adjust()));
        connect(item, SIGNAL(yChanged()), SLOT(adjust()));
        connect(item, SIGNAL(widthChanged()), SLOT(adjust()));
        connect(item, SIGNAL(heightChanged()), SLOT(adjust()));
        connect(item, SIGNAL(rotationChanged()), SLOT(adjust()));
        connect(item, SIGNAL(transformOriginChanged(TransformOrigin)),
                SLOT(adjust()));
    }
    QQuickWindow *view = item->window();
    QQuickItem * contentItem = view->contentItem();
    if (contentItem) {
        connect(contentItem, SIGNAL(xChanged()), SLOT(adjust()));
        connect(contentItem, SIGNAL(yChanged()), SLOT(adjust()));
        connect(contentItem, SIGNAL(widthChanged()), SLOT(adjust()));
        connect(contentItem, SIGNAL(heightChanged()), SLOT(adjust()));
        connect(contentItem, SIGNAL(rotationChanged()), SLOT(adjust()));
        connect(contentItem, SIGNAL(transformOriginChanged(TransformOrigin)),
                SLOT(adjust()));
    }
    m_item = item;
    setContentsSize(view->size());
    adjust();
}
예제 #6
0
int main(int argc, char *argv[])
{
    QApplication app(argc, argv);
    QStandardItemModel model;
    model.appendRow(new QStandardItem("Norway"));
    model.appendRow(new QStandardItem("Netherlands"));
    model.appendRow(new QStandardItem("New Zealand"));
    model.appendRow(new QStandardItem("Namibia"));
    model.appendRow(new QStandardItem("Nicaragua"));
    model.appendRow(new QStandardItem("North Korea"));
    model.appendRow(new QStandardItem("Northern Cyprus "));
    model.appendRow(new QStandardItem("Sweden"));
    model.appendRow(new QStandardItem("Denmark"));

    QStringList strings;
    strings << "Norway" << "Sweden" << "Denmark";

    QQmlApplicationEngine engine;
    engine.rootContext()->setContextProperty("standardmodel", &model);
    engine.rootContext()->setContextProperty("stringmodel", strings);
    engine.load(QUrl("main.qml"));
    QObject *topLevel = engine.rootObjects().value(0);

    QQuickWindow *window = qobject_cast<QQuickWindow *>(topLevel);
    if ( !window ) {
        qWarning("Error: Your root item has to be a Window.");
        return -1;
    }
    window->show();
    return app.exec();
}
예제 #7
0
void QQuickMultiPointTouchArea::touchEvent(QTouchEvent *event)
{
    switch (event->type()) {
    case QEvent::TouchBegin:
    case QEvent::TouchUpdate:
    case QEvent::TouchEnd: {
        //if e.g. a parent Flickable has the mouse grab, don't process the touch events
        QQuickWindow *c = window();
        QQuickItem *grabber = c ? c->mouseGrabberItem() : 0;
        if (grabber && grabber != this && grabber->keepMouseGrab() && grabber->isEnabled()) {
            QQuickItem *item = this;
            while ((item = item->parentItem())) {
                if (item == grabber)
                    return;
            }
        }
        updateTouchData(event);
        if (event->type() == QEvent::TouchEnd)
            ungrab();
        break;
    }
    case QEvent::TouchCancel:
        ungrab();
        break;
    default:
        QQuickItem::touchEvent(event);
        break;
    }
}
예제 #8
0
void Highlight::adjust()
{
    if (!m_item)
        return;

    bool success = false;
    m_transform = m_item->itemTransform(0, &success);
    if (!success)
        m_transform = QTransform();

    setSize(QSizeF(m_item->width(), m_item->height()));
    qreal scaleFactor = 1;
    QPointF originOffset = QPointF(0,0);
    QQuickWindow *view = m_item->window();
    if (view->contentItem()) {
        scaleFactor = view->contentItem()->scale();
        originOffset -= view->contentItem()->position();
    }
    // The scale transform for the overlay needs to be cancelled
    // as the Item's transform which will be applied to the painter
    // takes care of it.
    parentItem()->setScale(1/scaleFactor);
    setPosition(originOffset);
    update();
}
예제 #9
0
    void createTexture()
    {
        if (bufferRef)
            bufferRef.destroyTexture();
        bufferRef = nextBuffer;

        QQuickWindow *window = static_cast<QQuickWindow *>(surface->mainOutput()->window());

        // If the next buffer is NULL do not delete the current texture. If the client called
        // attach(0) the surface is going to be unmapped anyway, if instead the client attached
        // a valid buffer but died before we got here we want to keep the old buffer around
        // in case some destroy animation is run.
        if (bufferRef) {
            delete texture;

            if (bufferRef.isShm()) {
                texture = window->createTextureFromImage(bufferRef.image());
            } else {
                QQuickWindow::CreateTextureOptions opt = 0;
                if (surface->useTextureAlpha()) {
                    opt |= QQuickWindow::TextureHasAlphaChannel;
                }
                texture = window->createTextureFromId(bufferRef.createTexture(), surface->size(), opt);
            }
            texture->bind();
        }

        update = false;
    }
QuickWindowNodeInstance::Pointer QuickWindowNodeInstance::create(QObject *object)
{
    QQuickWindow *quickWindow = qobject_cast<QQuickWindow*>(object);

    Q_ASSERT(quickWindow);

    Pointer instance(new QuickWindowNodeInstance(quickWindow));

    instance->setHasContent(anyItemHasContent(quickWindow->contentItem()));
    quickWindow->contentItem()->setFlag(QQuickItem::ItemHasContents, true);

    static_cast<QQmlParserStatus*>(quickWindow->contentItem())->classBegin();

    instance->populateResetHashes();

    QQuickItemPrivate *privateItem = static_cast<QQuickItemPrivate*>(QObjectPrivate::get(quickWindow->contentItem()));

    if (privateItem->window) {
        if (!privateItem->parentItem)
            QQuickWindowPrivate::get(privateItem->window)->parentlessItems.remove(quickWindow->contentItem());
        privateItem->derefWindow();
        privateItem->window = 0;
    }

    return instance;
}
예제 #11
0
void TestService::setTargetWindow(QObject* _window)
{
    QQuickWindow* window = qobject_cast<QQuickWindow*>(_window);
    if (window)
        m_targetWindow = window;
    window->requestActivate();
}
예제 #12
0
void tst_applicationwindow::defaultFocus()
{
    QQmlEngine engine;
    QQmlComponent component(&engine);
    component.loadUrl(testFileUrl("defaultFocus.qml"));
    QObject* created = component.create();
    QScopedPointer<QObject> cleanup(created);
    Q_UNUSED(cleanup);
    QVERIFY(created);

    QQuickWindow* window = qobject_cast<QQuickWindow*>(created);
    QVERIFY(window);
    window->show();
    window->requestActivate();
    QVERIFY(QTest::qWaitForWindowActive(window));
    QVERIFY(QGuiApplication::focusWindow() == window);

    QQuickItem* contentItem = window->contentItem();
    QVERIFY(contentItem);
    QVERIFY(contentItem->hasActiveFocus());

    // A single item in an ApplicationWindow with focus: true should receive focus.
    QQuickItem* item = findItem<QQuickItem>(window->contentItem(), "item");
    QVERIFY(item);
    QVERIFY(item->hasFocus());
    QVERIFY(item->hasActiveFocus());
}
예제 #13
0
// A very simple implementation where we assume that there's only one window and that it's a
// QQuickWindow. Thus the id parameter is irrelevant.
//
// Idea: Make the id contain the objectName of the QQuickWindow once we care about a multi-display
//       compositor?
//       Strictly speaking that could be the actual QWindow::winId(), but that's mostly a
//       meaningless arbitrary number.
QImage WindowScreenshotProvider::requestImage(const QString &id, QSize *size, const QSize &requestedSize)
{
    Q_UNUSED(id);
    Q_UNUSED(requestedSize);

    QWindowList windows = QGuiApplication::topLevelWindows();

    if (windows.count() != 1) {
        size->rwidth() = 0;
        size->rheight() = 0;
        return QImage();
    }

    QQuickWindow *quickWindow = qobject_cast<QQuickWindow *>(windows[0]);

    if (!quickWindow) {
        size->rwidth() = 0;
        size->rheight() = 0;
        return QImage();
    }

    QImage image = quickWindow->grabWindow();
    size->rwidth() = image.width();
    size->rheight() = image.height();
    return image;
}
예제 #14
0
void Compositor::onXdgToplevelCreated(QWaylandXdgToplevel *toplevel, QWaylandXdgSurface *shellSurface)
//void Compositor::onXdgSurfaceCreated(QWaylandXdgSurface *shellSurface)
{
    unsigned int windowId = mNextWindowId++;
    QWaylandSurface *surface = shellSurface->surface();

    qDebug() << Q_FUNC_INFO << "windowId" << windowId << surface;

    QQuickWindow *defaultOutputWindow = static_cast<QQuickWindow*>(defaultOutput()->window());
    CompositorWindow *window = new CompositorWindow(windowId, defaultOutputWindow->contentItem());

    window->setOutput(defaultOutput()); //useful ?
    window->setFlag(QQuickItem::ItemIsFocusScope, true);
    // window->setUseTextureAlpha(true);

    window->initialize(shellSurface);
    window->setSize(surface->size());
    window->setTouchEventsEnabled(true);

    mWindows.insert(windowId, window);

    connect(window, &CompositorWindow::readyChanged, this, &Compositor::windowIsReady);
    connect(window, &QWaylandQuickItem::surfaceDestroyed, this, &Compositor::onSurfaceDestroyed);

    window->sendWindowIdToClient();
}
예제 #15
0
QT_BEGIN_NAMESPACE

#ifndef QT_NO_WIDGETS
#define Application QApplication
#else
#define Application QGuiApplication
#endif

int main(int argc, char *argv[])
{
    Application app(argc, argv);
    QScreen* sc = app.primaryScreen();
    if(sc){
        sc->setOrientationUpdateMask(Qt::LandscapeOrientation
                             | Qt::PortraitOrientation
                             | Qt::InvertedLandscapeOrientation
                             | Qt::InvertedPortraitOrientation);
    }
    QQmlApplicationEngine engine(QUrl("qrc:/main.qml"));
    QObject *topLevel = engine.rootObjects().value(0);
    QQuickWindow *window = qobject_cast<QQuickWindow *>(topLevel);
    if ( !window ) {
        qWarning("Error: Your root item has to be a Window.");
        return -1;
    }
    window->showFullScreen();
    return app.exec();
}
예제 #16
0
int main(int argc, char ** argv)
{
	QApplication app(argc, argv);

	qmlRegisterType<Hider>("com.ics.demo", 1, 0, "Hider");

	int rc = 0;

	QQmlEngine engine;
	QQmlComponent *component = new QQmlComponent(&engine);

	QObject::connect(&engine, SIGNAL(quit()), QCoreApplication::instance(), SLOT(quit()));

    component->loadUrl(QUrl("../../Source/main.qml"));

	Hider::image_provider = new ImageProvider;
	engine.addImageProvider("images", Hider::image_provider);

	if (!component->isReady() ) {
		qWarning("%s", qPrintable(component->errorString()));
		return -1;
	}

	QObject *topLevel = component->create();
	QQuickWindow *window = qobject_cast<QQuickWindow *>(topLevel);

	QSurfaceFormat surfaceFormat = window->requestedFormat();
	window->setFormat(surfaceFormat);
	window->show();

	rc = app.exec();

	delete component;
	return rc;
}
예제 #17
0
void QQuickWindowAttached::windowChanged(QQuickWindow *window)
{
    if (window != m_window) {
        QQuickWindow* oldWindow = m_window;
        m_window = window;

        if (oldWindow)
            oldWindow->disconnect(this);

        if (!window)
            return; // No values to get, therefore nothing to emit

        if (!oldWindow || window->visibility() != oldWindow->visibility())
            emit visibilityChanged();
        if (!oldWindow || window->isActive() != oldWindow->isActive())
            emit activeChanged();
        if (!oldWindow || window->activeFocusItem() != oldWindow->activeFocusItem())
            emit activeFocusItemChanged();
        emit contentItemChanged();

        // QQuickWindowQmlImpl::visibilityChanged also exists, and window might even
        // be QQuickWindowQmlImpl, but that's not what we are connecting to.
        // So this is actual window state rather than a buffered or as-requested one.
        // If we used the metaobject connect syntax there would be a warning:
        // QMetaObjectPrivate::indexOfSignalRelative - QMetaObject::indexOfSignal:
        // signal visibilityChanged(QWindow::Visibility) from QQuickWindow redefined in QQuickWindowQmlImpl
        connect(window, &QQuickWindow::visibilityChanged,
                this, &QQuickWindowAttached::visibilityChanged);
        connect(window, &QQuickWindow::activeChanged,
                this, &QQuickWindowAttached::activeChanged);
        connect(window, &QQuickWindow::activeFocusItemChanged,
                this, &QQuickWindowAttached::activeFocusItemChanged);
    }
}
예제 #18
0
파일: main.cpp 프로젝트: NightOfTwelve/qwx
int main(int argc, char* argv[]) 
{                                                                        
    QtSingleApplication app(argc, argv);

    if (app.isRunning())
        return 0;

    app.setApplicationName(CODE_NAME);
    app.setApplicationVersion(APPLICATION_VERSION);
    // TODO: session management testcase
    // http://marc.info/?l=kde-core-devel&m=144832700109449
    // KDEBUG-341930
    // perhaps we need to wait Qt5.9.x to fix it ;-)
    //app.setQuitOnLastWindowClosed(false);

    I18N i18n(TRANSLATIONS_PATH, APPLICATION_ENCODING);
    i18n.translate();

    qmlRegisterType<QwxUUID>("cn.com.isoft.qwx", 1, 0, "QwxUUID");
    qmlRegisterType<Scan>("cn.com.isoft.qwx", 1, 0, "Scan");
    qmlRegisterType<Cookie>("cn.com.isoft.qwx", 1, 0, "Cookie");
    qmlRegisterType<StatReport>("cn.com.isoft.qwx", 1, 0, "StatReport");
    qmlRegisterType<Init>("cn.com.isoft.qwx", 1, 0, "Init");
    qmlRegisterType<Sync>("cn.com.isoft.qwx", 1, 0, "Sync");
    qmlRegisterType<Contact>("cn.com.isoft.qwx", 1, 0, "Contact");
    qmlRegisterType<HeadImg>("cn.com.isoft.qwx", 1, 0, "HeadImg");
    qmlRegisterType<StatusNotify>("cn.com.isoft.qwx", 1, 0, "StatusNotify");
    qmlRegisterType<SendMsg>("cn.com.isoft.qwx", 1, 0, "SendMsg");
    qmlRegisterType<Monitor>("cn.com.isoft.qwx", 1, 0, "Monitor");
    qmlRegisterType<GetMsg>("cn.com.isoft.qwx", 1, 0, "GetMsg");
    qmlRegisterType<CircleImage>("cn.com.isoft.qwx", 1, 0, "CircleImage");
    qmlRegisterType<Process>("cn.com.isoft.qwx", 1, 0, "Process");
    qmlRegisterType<XiaoDouBi>("cn.com.isoft.qwx", 1, 0, "XiaoDouBi");
    qmlRegisterType<ChatLog>("cn.com.isoft.qwx", 1, 0, "ChatLog");
    qmlRegisterType<Emotion>("cn.com.isoft.qwx", 1, 0, "Emotion");
    qmlRegisterType<LogOut>("cn.com.isoft.qwx", 1, 0, "LogOut");
    qmlRegisterType<IpCity>("cn.com.isoft.qwx", 1, 0, "IpCity");
    qmlRegisterType<Weather>("cn.com.isoft.qwx", 1, 0, "Weather");
    qmlRegisterType<Clipboard>("cn.com.isoft.qwx", 1, 0, "Clipboard");

    QQmlApplicationEngine engine(QUrl("qrc:/qml/main.qml")); 
    QObject* topLevel = engine.rootObjects().value(0);
    QQuickWindow* window = qobject_cast<QQuickWindow*>(topLevel); 
    if (!window) {
        qWarning("Error: Your root item has to be a Window.");
        return -1;
    }
    // FIXME: it does not work for KWin 5.7.x
    // https://blog.martin-graesslin.com/blog/2016/07/multi-screen-woes-in-plasma-5-7/
    // Newly opened windows not placed on the primary screen
#if QWX_DEBUG
    qDebug() << "DEBUG:" << app.primaryScreen()->availableGeometry();
#endif
    window->setScreen(app.primaryScreen());
    window->show();

    return app.exec();
}
예제 #19
0
/*------------------------------------------------------------------------------
|    OpenMAXILPlayerControl::appendCommand
+-----------------------------------------------------------------------------*/
void OpenMAXILPlayerControl::appendCommand(PlayerCommand* command)
{
   QMutexLocker locker(&m_pendingCommandsMutex);
   m_pendingCommands.append(command);

   QQuickWindow* window = m_quickItem->window();
   if (window)
      window->update();
}
예제 #20
0
bool QQuickMouseArea::sendMouseEvent(QMouseEvent *event)
{
    Q_D(QQuickMouseArea);
    QPointF localPos = mapFromScene(event->windowPos());

    QQuickWindow *c = window();
    QQuickItem *grabber = c ? c->mouseGrabberItem() : 0;
    bool stealThisEvent = d->stealMouse;
    if ((stealThisEvent || contains(localPos)) && (!grabber || !grabber->keepMouseGrab())) {
        QMouseEvent mouseEvent(event->type(), localPos, event->windowPos(), event->screenPos(),
                               event->button(), event->buttons(), event->modifiers());
        mouseEvent.setAccepted(false);

        switch (event->type()) {
        case QEvent::MouseMove:
            mouseMoveEvent(&mouseEvent);
            break;
        case QEvent::MouseButtonPress:
            mousePressEvent(&mouseEvent);
            break;
        case QEvent::MouseButtonRelease:
            mouseReleaseEvent(&mouseEvent);
            stealThisEvent = d->stealMouse;
            break;
        default:
            break;
        }
        grabber = c ? c->mouseGrabberItem() : 0;
        if (grabber && stealThisEvent && !grabber->keepMouseGrab() && grabber != this)
            grabMouse();

        return stealThisEvent;
    }
    if (event->type() == QEvent::MouseButtonRelease) {
        if (d->pressed) {
            d->pressed &= ~event->button();
            emit pressedButtonsChanged();
            if (!d->pressed) {
                // no other buttons are pressed
                d->stealMouse = false;
                if (c && c->mouseGrabberItem() == this)
                    ungrabMouse();
                emit canceled();
                emit pressedChanged();
                emit containsPressChanged();
                if (d->hovered) {
                    d->hovered = false;
                    emit hoveredChanged();
                }
            }
        }
    }
    return false;
}
예제 #21
0
void QuickMozView::itemChange(ItemChange change, const ItemChangeData &)
{
    if (change == ItemSceneChange) {
        QQuickWindow *win = window();
        if (!win)
            return;
        connect(win, SIGNAL(beforeRendering()), this, SLOT(beforeRendering()), Qt::DirectConnection);
        connect(win, SIGNAL(sceneGraphInitialized()), this, SLOT(sceneGraphInitialized()), Qt::DirectConnection);
        win->setClearBeforeRendering(false);
    }
}
예제 #22
0
QRect QAccessibleQuickItem::viewRect() const
{
    // ### no window in some cases.
    if (!item()->window()) {
        return QRect();
    }

    QQuickWindow *window = item()->window();
    QPoint screenPos = window->mapToGlobal(QPoint(0,0));
    return QRect(screenPos, window->size());
}
예제 #23
0
	Handle<Value> QuickWindowWrap::show(const Arguments& args)
	{
		HandleScope scope;

		QuickWindowWrap *obj_wrap = ObjectWrap::Unwrap<QuickWindowWrap>(args.This());

		QQuickWindow *view = obj_wrap->GetObject();
		view->setFormat(view->requestedFormat());
		view->show();

		return scope.Close(Undefined());
	}
예제 #24
0
/*!
   \reimp
*/
QSGTextureProvider *QQuickPaintedItem::textureProvider() const
{
    Q_D(const QQuickPaintedItem);
    QQuickWindow *w = window();
    if (!w || !w->openglContext() || QThread::currentThread() != w->openglContext()->thread()) {
        qWarning("QQuickPaintedItem::textureProvider: can only be queried on the rendering thread of an exposed window");
        return 0;
    }
    if (!d->textureProvider)
        d->textureProvider = new QQuickPaintedItemTextureProvider();
    d->textureProvider->node = d->node;
    return d->textureProvider;
}
예제 #25
0
void QuickMozView::itemChange(ItemChange change, const ItemChangeData &)
{
    if (change == ItemSceneChange) {
        QQuickWindow *win = window();
        if (!win)
            return;
        // All of these signals are emitted from scene graph rendering thread.
        connect(win, SIGNAL(beforeRendering()), this, SLOT(refreshNodeTexture()), Qt::DirectConnection);
        connect(win, SIGNAL(beforeSynchronizing()), this, SLOT(createThreadRenderObject()), Qt::DirectConnection);
        connect(win, SIGNAL(sceneGraphInvalidated()), this, SLOT(clearThreadRenderObject()), Qt::DirectConnection);
        win->setClearBeforeRendering(false);
    }
}
예제 #26
0
파일: main.cpp 프로젝트: ahmad88me/PoqteMon
int main(int argc, char *argv[])
{
     QGuiApplication app(argc, argv);
     QQmlApplicationEngine engine;
     //qmlRegisterType<NetworkComm>("Networking", 1, 0, "Networkcomm");
     qmlRegisterType<FileIO, 1>("FileIO", 1, 0, "FileIO");
     engine.load(QUrl("qrc:/main.qml"));
     QObject *topLevel = engine.rootObjects().value(0);
     QQuickWindow *window = qobject_cast<QQuickWindow *>(topLevel);
     //engine.load(QUrl("qrc:/main.qml"));
     window->show();
     return app.exec();
}
예제 #27
0
int main(int argc, char *argv[])
{
    QApplication app(argc, argv);
    Vibrator vibrator;

    QQmlApplicationEngine engine;
    engine.load(QUrl(QStringLiteral("qrc:/main.qml")));
    QQuickWindow *window = qobject_cast<QQuickWindow *>(engine.rootObjects().first());
    window->showFullScreen();
    engine.rootContext()->setContextProperty("Vibrator", &vibrator);

    return app.exec();
}
예제 #28
0
/*------------------------------------------------------------------------------
|    OpenMAXILPlayerControl::onItemSceneChanged
+-----------------------------------------------------------------------------*/
void OpenMAXILPlayerControl::onItemSceneChanged()
{
   QQuickWindow* window = m_quickItem->window();
   if (!window)
      return;

   connect(window, SIGNAL(sceneGraphInitialized()),
           this, SLOT(onSceneGraphInitialized()), Qt::DirectConnection);
   connect(window, SIGNAL(afterRendering()),
           this, SLOT(onAfterRendering()), Qt::DirectConnection);

   window->update();
}
예제 #29
0
void WindowManager::registerQuickItem( QQuickItem* item )
{
    if ( !item ) return;

    QQuickWindow *window = item->window();
    if (window) {
        QQuickItem *contentItem = window->contentItem();
        contentItem->setAcceptedMouseButtons( Qt::LeftButton );
        contentItem->removeEventFilter( this );
        contentItem->installEventFilter( this );
    }

}
예제 #30
0
void AbstractThumbnailItem::findParentEffectWindow()
{
    if (effects) {
        QQuickWindow *qw = window();
        if (!qw) {
            qDebug() << "No QQuickWindow assigned yet";
            return;
        }
        if (auto *w = static_cast<EffectWindowImpl*>(effects->findWindow(qw->winId()))) {
            m_parent = QWeakPointer<EffectWindowImpl>(w);
        }
    }
}