~ci-train-bot/qtubuntu/qtubuntu-ubuntu-xenial-landing-057

// Local

#include "window.h"

#include "clipboard.h"

#include "input.h"

#include "screen.h"

#include "logging.h"

 

Q_LOGGING_CATEGORY(ubuntumirclientBufferSwap, "ubuntumirclient.bufferSwap", QtWarningMsg)

 

namespace

{

 

    return reinterpret_cast<EGLNativeWindowType>(mir_buffer_stream_get_egl_native_window(stream));

}

 

const char *qtWindowStateToStr(Qt::WindowState state)

{

    switch (state) {

    }

}

 

WId makeId()

{

    static int id = 1;

    }

}

 

{

    auto spec = makeSurfaceSpec(window, input, connection);

    const auto title = window->title().toUtf8();

 

    setSizingConstraints(spec.get(), window->minimumSize(), window->maximumSize(), window->sizeIncrement());

 

        mir_surface_spec_set_fullscreen_on_output(spec.get(), screen->mirOutputId());

    }

 

    auto surface = mir_surface_create_sync(spec.get());

    Q_ASSERT(mir_surface_is_valid(surface));

    return surface;

        , mPlatformWindow(platformWindow)

        , mInput(input)

        , mConnection(connection)

        , mEglDisplay(screen->eglDisplay())

        , mEglSurface(eglCreateWindowSurface(mEglDisplay, screen->eglConfig(), nativeWindowFor(mMirSurface), nullptr))

        , mNeedsRepaint(false)

        , mParented(mWindow->transientParent() || mWindow->parent())

    {

        // Window manager can give us a final size different from what we asked for

        // so let's check what we ended up getting

        MirSurfaceParameters parameters;

        auto geom = mWindow->geometry();

        geom.setWidth(parameters.width);

        geom.setHeight(parameters.height);

 

        // Assume that the buffer size matches the surface size at creation time

        mBufferSize = geom.size();

    UbuntuSurface& operator=(UbuntuSurface const&) = delete;

 

    void resize(const QSize& newSize);

 

    void onSwapBuffersDone();

    void handleSurfaceResized(int width, int height);

    int needsRepaint() const;

 

    EGLSurface eglSurface() const { return mEglSurface; }

    MirSurface *mirSurface() const { return mMirSurface; }

 

private:

    static void surfaceEventCallback(MirSurface* surface, const MirEvent *event, void* context);

    void postEvent(const MirEvent *event);

 

    QWindow * const mWindow;

    UbuntuWindow * const mPlatformWindow;

    const EGLDisplay mEglDisplay;

    const EGLSurface mEglSurface;

 

    bool mNeedsRepaint;

    bool mParented;

    QSize mBufferSize;

 

    QMutex mTargetSizeMutex;

{

    qCDebug(ubuntumirclient,"resize(window=%p, width=%d, height=%d)", mWindow, size.width(), size.height());

 

        qCDebug(ubuntumirclient, "resize(window=%p) - not resizing, window is maximized or fullscreen", mWindow);

        return;

    }

    mir_surface_apply_spec(mMirSurface, spec.get());

}

 

void UbuntuSurface::updateTitle(const QString& newTitle)

{

    const auto title = newTitle.toUtf8();

    return 0;

}

 

void UbuntuSurface::onSwapBuffersDone()

{

    static int sFrameNumber = 0;

    }

}

 

    : QObject(nullptr)

    , QPlatformWindow(w)

    , mId(makeId())

    , mClipboard(clipboard)

{

}

 

UbuntuWindow::~UbuntuWindow()

    // updated size but it still needs re-rendering so another redraw may be needed.

    // A mir API to drop the currently held buffer would help here, so that we wouldn't have to redraw twice

    auto const numRepaints = mSurface->needsRepaint();

    qCDebug(ubuntumirclient, "handleSurfaceResize(window=%p) redraw %d times", window(), numRepaints);

    for (int i = 0; i < numRepaints; i++) {

        qCDebug(ubuntumirclient, "handleSurfaceResize(window=%p) repainting width=%d, height=%d", window(), geometry().size().width(), geometry().size().height());

{

    QMutexLocker lock(&mMutex);

    qCDebug(ubuntumirclient, "setWindowState(window=%p, %s)", this, qtWindowStateToStr(state));

}

 

/*

    window is always on the top-left corner, right below the indicators panel if not

    in fullscreen.

 */

{

        newGeometry.setY(0);

        QPlatformWindow::setGeometry(newGeometry);

        QWindowSystemInterface::handleGeometryChange(window(), newGeometry);

    }

    QMutexLocker lock(&mMutex);

    qCDebug(ubuntumirclient, "setVisible (window=%p, visible=%s)", window(), visible ? "true" : "false");

 

 

    lock.unlock();

    QWindowSystemInterface::handleExposeEvent(window(), exposeRect);

    QWindowSystemInterface::flushWindowSystemEvents();

}

    mSurface->setSizingConstraints(win->minimumSize(), win->maximumSize(), win->sizeIncrement());

}

 

void* UbuntuWindow::eglSurface() const

{

    return mSurface->eglSurface();

    QMutexLocker lock(&mMutex);

    mSurface->onSwapBuffersDone();

}