← Back to branch summary

~bregma/qtmir/use-ual-info

« back to all changes in this revision

Viewing changes to src/modules/Unity/Application/session.cpp

  • Committer: CI Train Bot
  • Author(s): Daniel d'Andrada
  • Date: 2015-12-10 13:08:38 UTC
  • mfrom: (423.3.1 origin/multiSurfaceApp2)
  • Revision ID: ci-train-bot@canonical.com-20151210130838-11ftzh83klgfnm74
Make Session hold multiple surfaces

+ Standardize MirSurface debug messages and account for multiple surfaces per app
Approved by: Gerry Boland

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/modules/Unity/Application/session.cpp
68
68
    : SessionInterface(parent)
69
69
    , m_session(session)
70
70
    , m_application(nullptr)
71
 
    , m_surface(nullptr)
72
71
    , m_parentSession(nullptr)
73
72
    , m_children(new SessionModel(this))
74
73
    , m_fullscreen(false)
108
107
void Session::doSuspend()
109
108
{
110
109
    Q_ASSERT(m_state == Session::Suspending);
111
 
    if (m_surface) {
112
 
        m_surface->stopFrameDropper();
 
110
 
 
111
 
 
112
    auto surfaceList = m_surfaces.list();
 
113
    if (surfaceList.empty()) {
 
114
        qCDebug(QTMIR_SESSIONS) << "Application::suspend - no surface to call stopFrameDropper() on!";
113
115
    } else {
114
 
        qDebug() << "Application::suspend - no surface to call stopFrameDropper() on!";
 
116
        for (int i = 0; i < surfaceList.count(); ++i) {
 
117
            surfaceList[i]->stopFrameDropper();
 
118
        }
115
119
    }
116
120
    setState(Suspended);
117
121
}
142
146
    return m_application;
143
147
}
144
148
 
145
 
MirSurfaceInterface* Session::surface() const
 
149
const ObjectListModel<MirSurfaceInterface>* Session::surfaces() const
146
150
{
147
 
    // Only notify QML of surface creation once it has drawn its first frame.
148
 
    if (m_surface && m_surface->isFirstFrameDrawn()) {
149
 
        return m_surface;
150
 
    } else {
151
 
        return nullptr;
152
 
    }
 
151
    return &m_surfaces;
153
152
}
154
153
 
155
154
SessionInterface* Session::parentSession() const
191
190
    Q_EMIT applicationChanged(application);
192
191
}
193
192
 
194
 
void Session::setSurface(MirSurfaceInterface *newSurface)
 
193
void Session::registerSurface(MirSurfaceInterface *newSurface)
195
194
{
196
 
    qCDebug(QTMIR_SESSIONS) << "Session::setSurface - session=" << name() << "surface=" << newSurface;
197
 
 
198
 
    if (newSurface == m_surface) {
199
 
        return;
200
 
    }
201
 
 
202
 
    if (m_surface) {
203
 
        m_surface->disconnect(this);
204
 
    }
205
 
 
206
 
    MirSurfaceInterface *previousSurface = surface();
207
 
    m_surface = newSurface;
208
 
 
209
 
    if (newSurface) {
210
 
        connect(newSurface, &MirSurfaceInterface::stateChanged,
211
 
            this, &Session::updateFullscreenProperty);
212
 
 
213
 
        // Only notify QML of surface creation once it has drawn its first frame.
214
 
        if (m_surface->isFirstFrameDrawn()) {
215
 
            setState(Running);
216
 
        } else {
217
 
            connect(newSurface, &MirSurfaceInterface::firstFrameDrawn,
218
 
                    this, &Session::onFirstSurfaceFrameDrawn);
219
 
        }
220
 
    }
221
 
 
222
 
    if (previousSurface != surface()) {
223
 
        qCDebug(QTMIR_SESSIONS).nospace() << "Session::surfaceChanged - session=" << this
224
 
            << " surface=" << m_surface;
225
 
        Q_EMIT surfaceChanged(m_surface);
 
195
    qCDebug(QTMIR_SESSIONS) << "Session::resgisterSurface - session=" << name() << "surface=" << newSurface;
 
196
 
 
197
    // Only notify QML of surface creation once it has drawn its first frame.
 
198
    if (newSurface->isFirstFrameDrawn()) {
 
199
        appendSurface(newSurface);
 
200
    } else {
 
201
        connect(newSurface, &MirSurfaceInterface::firstFrameDrawn,
 
202
                this, [this, newSurface]() { this->appendSurface(newSurface); });
226
203
    }
227
204
 
228
205
    updateFullscreenProperty();
229
206
}
230
207
 
231
 
void Session::onFirstSurfaceFrameDrawn()
232
 
{
233
 
    qCDebug(QTMIR_SESSIONS).nospace() << "Session::surfaceChanged - session=" << this
234
 
        << " surface=" << m_surface;
235
 
    Q_EMIT surfaceChanged(m_surface);
236
 
    setState(Running);
 
208
void Session::appendSurface(MirSurfaceInterface *newSurface)
 
209
{
 
210
    qCDebug(QTMIR_SESSIONS) << "Session::appendSurface - session=" << name() << "surface=" << newSurface;
 
211
 
 
212
    connect(newSurface, &MirSurfaceInterface::stateChanged,
 
213
        this, &Session::updateFullscreenProperty);
 
214
 
 
215
    m_surfaces.insert(m_surfaces.rowCount(), newSurface);
 
216
 
 
217
    Q_EMIT lastSurfaceChanged(newSurface);
 
218
 
 
219
    if (m_state == Starting) {
 
220
        setState(Running);
 
221
    }
 
222
}
 
223
 
 
224
void Session::removeSurface(MirSurfaceInterface* surface)
 
225
{
 
226
    qCDebug(QTMIR_SESSIONS) << "Session::removeSurface - session=" << name() << "surface=" << surface;
 
227
 
 
228
    surface->disconnect(this);
 
229
 
 
230
    if (m_surfaces.contains(surface)) {
 
231
        bool lastSurfaceWasRemoved = lastSurface() == surface;
 
232
        m_surfaces.remove(surface);
 
233
        if (lastSurfaceWasRemoved) {
 
234
            Q_EMIT lastSurfaceChanged(lastSurface());
 
235
        }
 
236
    }
237
237
}
238
238
 
239
239
void Session::updateFullscreenProperty()
240
240
{
241
 
    if (m_surface) {
242
 
        setFullscreen(m_surface->state() == Mir::FullscreenState);
 
241
    if (m_surfaces.rowCount() > 0) {
 
242
        // TODO: Figure out something better
 
243
        setFullscreen(m_surfaces.list().at(0)->state() == Mir::FullscreenState);
243
244
    } else {
244
245
        // Keep the current value of the fullscreen property until we get a new
245
246
        // surface
289
290
        Q_ASSERT(m_suspendTimer->isActive());
290
291
        m_suspendTimer->stop();
291
292
    } else if (m_state == Suspended) {
292
 
        Q_ASSERT(m_surface);
293
 
        m_surface->startFrameDropper();
 
293
        Q_ASSERT(m_surfaces.rowCount() > 0);
 
294
        auto surfaceList = m_surfaces.list();
 
295
        for (int i = 0; i < surfaceList.count(); ++i) {
 
296
            surfaceList[i]->startFrameDropper();
 
297
        }
294
298
    }
295
299
 
296
300
    session()->set_lifecycle_state(mir_lifecycle_state_resumed);
308
312
 
309
313
void Session::close()
310
314
{
311
 
    qCDebug(QTMIR_SESSIONS) << "Session::close - " << name() << m_surface;
312
 
    if (m_surface) {
313
 
        m_surface->close();
 
315
    qCDebug(QTMIR_SESSIONS) << "Session::close - " << name();
 
316
 
 
317
    auto surfaceList = m_surfaces.list();
 
318
    for (int i = 0; i < surfaceList.count(); ++i) {
 
319
        surfaceList[i]->close();
314
320
    }
315
321
}
316
322
 
321
327
    if (m_state != Stopped) {
322
328
 
323
329
        stopPromptSessions();
 
330
 
324
331
        if (m_suspendTimer->isActive())
325
332
            m_suspendTimer->stop();
326
 
        if (m_surface)
327
 
            m_surface->stopFrameDropper();
 
333
 
 
334
        {
 
335
            auto surfaceList = m_surfaces.list();
 
336
            for (int i = 0; i < surfaceList.count(); ++i) {
 
337
                surfaceList[i]->stopFrameDropper();
 
338
            }
 
339
        }
328
340
 
329
341
        foreachChildSession([](SessionInterface* session) {
330
342
            session->stop();
460
472
    }
461
473
}
462
474
 
 
475
MirSurfaceInterface* Session::lastSurface() const
 
476
{
 
477
    if (m_surfaces.rowCount() > 0) {
 
478
        return m_surfaces.list().last();
 
479
    } else {
 
480
        return nullptr;
 
481
    }
 
482
}
 
483
 
463
484
} // namespace qtmir