Lomiri
TopLevelWindowModel.cpp
1/*
2 * Copyright (C) 2016-2017 Canonical Ltd.
3 * Copyright 2019 UBports Foundation
4 *
5 * This program is free software: you can redistribute it and/or modify it under
6 * the terms of the GNU Lesser General Public License version 3, as published by
7 * the Free Software Foundation.
8 *
9 * This program is distributed in the hope that it will be useful, but WITHOUT
10 * ANY WARRANTY; without even the implied warranties of MERCHANTABILITY,
11 * SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
12 * Lesser General Public License for more details.
13 *
14 * You should have received a copy of the GNU Lesser General Public License
15 * along with this program. If not, see <http://www.gnu.org/licenses/>.
16 */
17
18#include "TopLevelWindowModel.h"
19#include "WindowManagerObjects.h"
20
21// lomiri-api
22#include <lomiri/shell/application/ApplicationInfoInterface.h>
23#include <lomiri/shell/application/ApplicationManagerInterface.h>
24#include <lomiri/shell/application/MirSurfaceInterface.h>
25#include <lomiri/shell/application/MirSurfaceListInterface.h>
26#include <lomiri/shell/application/SurfaceManagerInterface.h>
27
28// Qt
29#include <QDebug>
30
31// local
32#include "Window.h"
33#include "Workspace.h"
34#include "InputMethodManager.h"
35
36Q_LOGGING_CATEGORY(TOPLEVELWINDOWMODEL, "toplevelwindowmodel", QtInfoMsg)
37
38#define DEBUG_MSG qCDebug(TOPLEVELWINDOWMODEL).nospace().noquote() << __func__
39#define INFO_MSG qCInfo(TOPLEVELWINDOWMODEL).nospace().noquote() << __func__
40
41namespace lomiriapi = lomiri::shell::application;
42
43TopLevelWindowModel::TopLevelWindowModel(Workspace* workspace)
44 : m_nullWindow(createWindow(nullptr)),
45 m_workspace(workspace),
46 m_surfaceManagerBusy(false)
47{
48 connect(WindowManagerObjects::instance(), &WindowManagerObjects::applicationManagerChanged,
49 this, &TopLevelWindowModel::setApplicationManager);
50 connect(WindowManagerObjects::instance(), &WindowManagerObjects::surfaceManagerChanged,
51 this, &TopLevelWindowModel::setSurfaceManager);
52
53 setApplicationManager(WindowManagerObjects::instance()->applicationManager());
54 setSurfaceManager(WindowManagerObjects::instance()->surfaceManager());
55
56 connect(m_nullWindow, &Window::focusedChanged, this, [this] {
57 Q_EMIT rootFocusChanged();
58 });
59}
60
61TopLevelWindowModel::~TopLevelWindowModel()
62{
63}
64
65void TopLevelWindowModel::setApplicationManager(lomiriapi::ApplicationManagerInterface* value)
66{
67 if (m_applicationManager == value) {
68 return;
69 }
70
71 DEBUG_MSG << "(" << value << ")";
72
73 Q_ASSERT(m_modelState == IdleState);
74 m_modelState = ResettingState;
75
76 beginResetModel();
77
78 if (m_applicationManager) {
79 disconnect(m_applicationManager, 0, this, 0);
80 }
81
82 m_applicationManager = value;
83
84 if (m_applicationManager) {
85 connect(m_applicationManager, &QAbstractItemModel::rowsInserted,
86 this, [this](const QModelIndex &/*parent*/, int first, int last) {
87 if (!m_workspace || !m_workspace->isActive())
88 return;
89
90 for (int i = first; i <= last; ++i) {
91 auto application = m_applicationManager->get(i);
92 addApplication(application);
93 }
94 });
95
96 connect(m_applicationManager, &QAbstractItemModel::rowsAboutToBeRemoved,
97 this, [this](const QModelIndex &/*parent*/, int first, int last) {
98 for (int i = first; i <= last; ++i) {
99 auto application = m_applicationManager->get(i);
100 removeApplication(application);
101 }
102 });
103 }
104
105 refreshWindows();
106
107 endResetModel();
108 m_modelState = IdleState;
109}
110
111void TopLevelWindowModel::setSurfaceManager(lomiriapi::SurfaceManagerInterface *surfaceManager)
112{
113 if (surfaceManager == m_surfaceManager) {
114 return;
115 }
116
117 DEBUG_MSG << "(" << surfaceManager << ")";
118
119 Q_ASSERT(m_modelState == IdleState);
120 m_modelState = ResettingState;
121
122 beginResetModel();
123
124 if (m_surfaceManager) {
125 disconnect(m_surfaceManager, 0, this, 0);
126 }
127
128 m_surfaceManager = surfaceManager;
129
130 if (m_surfaceManager) {
131 connect(m_surfaceManager, &lomiriapi::SurfaceManagerInterface::surfacesAddedToWorkspace, this, &TopLevelWindowModel::onSurfacesAddedToWorkspace);
132 connect(m_surfaceManager, &lomiriapi::SurfaceManagerInterface::surfacesRaised, this, &TopLevelWindowModel::onSurfacesRaised);
133 connect(m_surfaceManager, &lomiriapi::SurfaceManagerInterface::surfaceRemoved, this, &TopLevelWindowModel::onSurfaceDestroyed);
134 connect(m_surfaceManager, &lomiriapi::SurfaceManagerInterface::modificationsStarted, this, &TopLevelWindowModel::onModificationsStarted);
135 connect(m_surfaceManager, &lomiriapi::SurfaceManagerInterface::modificationsEnded, this, &TopLevelWindowModel::onModificationsEnded);
136 }
137
138 refreshWindows();
139
140 endResetModel();
141 m_modelState = IdleState;
142}
143
144void TopLevelWindowModel::addApplication(lomiriapi::ApplicationInfoInterface *application)
145{
146 DEBUG_MSG << "(" << application->appId() << ")";
147
148 if (application->state() != lomiriapi::ApplicationInfoInterface::Stopped && application->surfaceList()->count() == 0) {
149 prependPlaceholder(application);
150 }
151}
152
153void TopLevelWindowModel::removeApplication(lomiriapi::ApplicationInfoInterface *application)
154{
155 DEBUG_MSG << "(" << application->appId() << ")";
156
157 Q_ASSERT(m_modelState == IdleState);
158
159 int i = 0;
160 while (i < m_windowModel.count()) {
161 if (m_windowModel.at(i).application == application) {
162 deleteAt(i);
163 } else {
164 ++i;
165 }
166 }
167}
168
169void TopLevelWindowModel::prependPlaceholder(lomiriapi::ApplicationInfoInterface *application)
170{
171 INFO_MSG << "(" << application->appId() << ")";
172
173 prependSurfaceHelper(nullptr, application);
174}
175
176void TopLevelWindowModel::prependSurface(lomiriapi::MirSurfaceInterface *surface, lomiriapi::ApplicationInfoInterface *application)
177{
178 Q_ASSERT(surface != nullptr);
179
180 connectSurface(surface);
181 m_allSurfaces.insert(surface);
182
183 bool filledPlaceholder = false;
184 for (int i = 0; i < m_windowModel.count() && !filledPlaceholder; ++i) {
185 ModelEntry &entry = m_windowModel[i];
186 if (entry.application == application && (entry.window->surface() == nullptr || !entry.window->surface()->live())) {
187 entry.window->setSurface(surface);
188 INFO_MSG << " appId=" << application->appId() << " surface=" << surface
189 << ", filling out placeholder. after: " << toString();
190 filledPlaceholder = true;
191 }
192 }
193
194 if (!filledPlaceholder) {
195 INFO_MSG << " appId=" << application->appId() << " surface=" << surface << ", adding new row";
196 prependSurfaceHelper(surface, application);
197 }
198}
199
200void TopLevelWindowModel::prependSurfaceHelper(lomiriapi::MirSurfaceInterface *surface, lomiriapi::ApplicationInfoInterface *application)
201{
202
203 Window *window = createWindow(surface);
204
205 connect(window, &Window::stateChanged, this, [=](Mir::State newState) {
206 if (newState == Mir::HiddenState) {
207 // Comply, removing it from our model. Just as if it didn't exist anymore.
208 removeAt(indexForId(window->id()));
209 } else {
210 if (indexForId(window->id()) == -1) {
211 // was probably hidden before. put it back on the list
212 auto *application = m_applicationManager->findApplicationWithSurface(window->surface());
213 Q_ASSERT(application);
214 prependWindow(window, application);
215 }
216 }
217 });
218
219 prependWindow(window, application);
220
221 // Activate the newly-prepended window.
222 window->activate();
223
224 INFO_MSG << " after " << toString();
225}
226
227void TopLevelWindowModel::prependWindow(Window *window, lomiriapi::ApplicationInfoInterface *application)
228{
229 if (m_modelState == IdleState) {
230 m_modelState = InsertingState;
231 beginInsertRows(QModelIndex(), 0 /*first*/, 0 /*last*/);
232 } else {
233 Q_ASSERT(m_modelState == ResettingState);
234 // No point in signaling anything if we're resetting the whole model
235 }
236
237 m_windowModel.prepend(ModelEntry(window, application));
238
239 if (m_modelState == InsertingState) {
240 endInsertRows();
241 Q_EMIT countChanged();
242 Q_EMIT listChanged();
243 m_modelState = IdleState;
244 }
245}
246
247void TopLevelWindowModel::connectWindow(Window *window)
248{
249 connect(window, &Window::focusRequested, this, [this, window]() {
250 if (!window->surface()) {
251 activateEmptyWindow(window);
252 }
253 });
254
255 connect(window, &Window::focusedChanged, this, [this, window](bool focused) {
256 if (window->surface()) {
257 if (focused) {
258 setFocusedWindow(window);
259 m_focusedWindowCleared = false;
260 } else if (m_focusedWindow == window) {
261 // Condense changes to the focused window
262 // eg: Do focusedWindow=A to focusedWindow=B instead of
263 // focusedWindow=A to focusedWindow=null to focusedWindow=B
264 m_focusedWindowCleared = true;
265 } else {
266 // don't clear the focused window if you were not there in the first place
267 // happens when a filled window gets replaced with an empty one (no surface) as the focused window.
268 }
269 }
270 });
271
272 connect(window, &Window::closeRequested, this, [this, window]() {
273 if (!window->surface()) {
274 // do things ourselves as miral doesn't know about this window
275 int id = window->id();
276 int index = indexForId(id);
277 bool focusOther = false;
278 Q_ASSERT(index >= 0);
279 if (window->focused()) {
280 focusOther = true;
281 }
282 m_windowModel[index].application->close();
283 if (focusOther) {
284 activateTopMostWindowWithoutId(id);
285 }
286 }
287 });
288
289 connect(window, &Window::emptyWindowActivated, this, [this, window]() {
290 activateEmptyWindow(window);
291 });
292
293 connect(window, &Window::liveChanged, this, [this, window](bool isAlive) {
294 if (!isAlive && window->state() == Mir::HiddenState) {
295 // Hidden windows are not in the model. So just delete it right away.
296 delete window;
297 }
298 });
299}
300
301void TopLevelWindowModel::activateEmptyWindow(Window *window)
302{
303 Q_ASSERT(!window->surface());
304 DEBUG_MSG << "(" << window << ")";
305
306 // miral doesn't know about empty windows (ie, windows that are not backed up by MirSurfaces)
307 // So we have to activate them ourselves (instead of asking SurfaceManager to do it for us).
308
309 window->setFocused(true);
310 raiseId(window->id());
311 Window *previousWindow = m_focusedWindow;
312 setFocusedWindow(window);
313 if (previousWindow && previousWindow->surface() && previousWindow->surface()->focused()) {
314 m_surfaceManager->activate(nullptr);
315 }
316}
317
318void TopLevelWindowModel::connectSurface(lomiriapi::MirSurfaceInterface *surface)
319{
320 connect(surface, &lomiriapi::MirSurfaceInterface::liveChanged, this, [this, surface](bool live){
321 if (!live) {
322 onSurfaceDied(surface);
323 }
324 });
325 connect(surface, &QObject::destroyed, this, [this, surface](QObject*){ this->onSurfaceDestroyed(surface); });
326}
327
328void TopLevelWindowModel::onSurfaceDied(lomiriapi::MirSurfaceInterface *surface)
329{
330 if (surface->type() == Mir::InputMethodType) {
331 removeInputMethodWindow();
332 return;
333 }
334
335 int i = indexOf(surface);
336 if (i == -1) {
337 return;
338 }
339
340 auto application = m_windowModel[i].application;
341
342 DEBUG_MSG << " application->name()=" << application->name()
343 << " application->state()=" << application->state();
344
345 // assume it got killed by the out-of-memory daemon.
346 //
347 // Leave at most 1 entry in the model and only remove its surface, so shell can display a screenshot
348 // in its place.
349 if (application->surfaceList()->count() == 1)
350 m_windowModel[i].removeOnceSurfaceDestroyed = false;
351 else
352 m_windowModel[i].removeOnceSurfaceDestroyed = true;
353}
354
355void TopLevelWindowModel::onSurfaceDestroyed(lomiriapi::MirSurfaceInterface *surface)
356{
357 int i = indexOf(surface);
358 if (i == -1) {
359 return;
360 }
361
362 if (m_windowModel[i].removeOnceSurfaceDestroyed) {
363 deleteAt(i);
364 } else {
365 auto window = m_windowModel[i].window;
366 window->setFocused(false);
367 m_allSurfaces.remove(surface);
368 INFO_MSG << " Removed surface from entry. After: " << toString();
369 }
370}
371
372Window *TopLevelWindowModel::createWindow(lomiriapi::MirSurfaceInterface *surface)
373{
374 int id = m_nextId.fetchAndAddAcquire(1);
375 return createWindowWithId(surface, id);
376}
377
378Window *TopLevelWindowModel::createNullWindow()
379{
380 return createWindowWithId(nullptr, 0);
381}
382
383Window *TopLevelWindowModel::createWindowWithId(lomiriapi::MirSurfaceInterface *surface, int id)
384{
385 Window *qmlWindow = new Window(id, this);
386 connectWindow(qmlWindow);
387 if (surface) {
388 qmlWindow->setSurface(surface);
389 }
390 return qmlWindow;
391}
392
393void TopLevelWindowModel::onSurfacesAddedToWorkspace(const std::shared_ptr<miral::Workspace>& workspace,
394 const QVector<lomiri::shell::application::MirSurfaceInterface*> surfaces)
395{
396 if (!m_workspace || !m_applicationManager) return;
397 if (workspace != m_workspace->workspace()) {
398 removeSurfaces(surfaces);
399 return;
400 }
401
402 Q_FOREACH(auto surface, surfaces) {
403 if (m_allSurfaces.contains(surface)) continue;
404
405 if (surface->parentSurface()) {
406 // Wrap it in a Window so that we keep focusedWindow() up to date.
407 Window *window = createWindow(surface);
408 connect(surface, &QObject::destroyed, window, [=](){
409 window->setSurface(nullptr);
410 window->deleteLater();
411 });
412 } else {
413 if (surface->type() == Mir::InputMethodType) {
414 connectSurface(surface);
415 setInputMethodWindow(createWindow(surface));
416 } else {
417 auto *application = m_applicationManager->findApplicationWithSurface(surface);
418 if (application) {
419 if (surface->state() == Mir::HiddenState) {
420 // Ignore it until it's finally shown
421 connect(surface, &lomiriapi::MirSurfaceInterface::stateChanged, this, [=](Mir::State newState) {
422 Q_ASSERT(newState != Mir::HiddenState);
423 disconnect(surface, &lomiriapi::MirSurfaceInterface::stateChanged, this, 0);
424 prependSurface(surface, application);
425 });
426 } else {
427 prependSurface(surface, application);
428 }
429 } else {
430 // Must be a prompt session. No need to do add it as a prompt surface is not top-level.
431 // It will show up in the ApplicationInfoInterface::promptSurfaceList of some application.
432 // Still wrap it in a Window though, so that we keep focusedWindow() up to date.
433 Window *promptWindow = createWindow(surface);
434 connect(surface, &QObject::destroyed, promptWindow, [=](){
435 promptWindow->setSurface(nullptr);
436 promptWindow->deleteLater();
437 });
438 }
439 }
440 }
441 }
442}
443
444void TopLevelWindowModel::removeSurfaces(const QVector<lomiri::shell::application::MirSurfaceInterface *> surfaces)
445{
446 int start = -1;
447 int end = -1;
448 for (auto iter = surfaces.constBegin(); iter != surfaces.constEnd();) {
449 auto surface = *iter;
450 iter++;
451
452 // Do removals in adjacent blocks.
453 start = end = indexOf(surface);
454 if (start == -1) {
455 // could be a child surface
456 m_allSurfaces.remove(surface);
457 continue;
458 }
459 while(iter != surfaces.constEnd()) {
460 int index = indexOf(*iter);
461 if (index != end+1) {
462 break;
463 }
464 end++;
465 iter++;
466 }
467
468 if (m_modelState == IdleState) {
469 beginRemoveRows(QModelIndex(), start, end);
470 m_modelState = RemovingState;
471 } else {
472 Q_ASSERT(m_modelState == ResettingState);
473 // No point in signaling anything if we're resetting the whole model
474 }
475
476 for (int index = start; index <= end; index++) {
477 auto window = m_windowModel[start].window;
478 window->setSurface(nullptr);
479 window->setFocused(false);
480
481 if (window == m_previousWindow) {
482 m_previousWindow = nullptr;
483 }
484
485 m_windowModel.removeAt(start);
486 m_allSurfaces.remove(surface);
487 }
488
489 if (m_modelState == RemovingState) {
490 endRemoveRows();
491 Q_EMIT countChanged();
492 Q_EMIT listChanged();
493 m_modelState = IdleState;
494 }
495 }
496}
497
498void TopLevelWindowModel::deleteAt(int index)
499{
500 auto window = m_windowModel[index].window;
501
502 removeAt(index);
503
504 window->setSurface(nullptr);
505
506 delete window;
507}
508
509void TopLevelWindowModel::removeAt(int index)
510{
511 if (m_modelState == IdleState) {
512 beginRemoveRows(QModelIndex(), index, index);
513 m_modelState = RemovingState;
514 } else {
515 Q_ASSERT(m_modelState == ResettingState);
516 // No point in signaling anything if we're resetting the whole model
517 }
518
519 auto window = m_windowModel[index].window;
520 auto surface = window->surface();
521
522 if (!window->surface()) {
523 window->setFocused(false);
524 }
525
526 if (window == m_previousWindow) {
527 m_previousWindow = nullptr;
528 }
529
530 m_windowModel.removeAt(index);
531 m_allSurfaces.remove(surface);
532
533 if (m_modelState == RemovingState) {
534 endRemoveRows();
535 Q_EMIT countChanged();
536 Q_EMIT listChanged();
537 m_modelState = IdleState;
538 }
539
540 if (m_focusedWindow == window) {
541 setFocusedWindow(nullptr);
542 m_focusedWindowCleared = false;
543 }
544
545 if (m_previousWindow == window) {
546 m_previousWindow = nullptr;
547 }
548
549 if (m_closingAllApps) {
550 if (m_windowModel.isEmpty()) {
551 Q_EMIT closedAllWindows();
552 }
553 }
554
555 INFO_MSG << " after " << toString() << " apps left " << m_windowModel.count();
556}
557
558void TopLevelWindowModel::setInputMethodWindow(Window *window)
559{
560 if (m_inputMethodWindow) {
561 qWarning("Multiple Input Method Surfaces created, removing the old one!");
562 delete m_inputMethodWindow;
563 }
564 m_inputMethodWindow = window;
565 Q_EMIT inputMethodSurfaceChanged(m_inputMethodWindow->surface());
566 InputMethodManager::instance()->setWindow(window);
567}
568
569void TopLevelWindowModel::removeInputMethodWindow()
570{
571 if (m_inputMethodWindow) {
572 auto surface = m_inputMethodWindow->surface();
573 if (surface) {
574 m_allSurfaces.remove(surface);
575 }
576 if (m_focusedWindow == m_inputMethodWindow) {
577 setFocusedWindow(nullptr);
578 m_focusedWindowCleared = false;
579 }
580
581 delete m_inputMethodWindow;
582 m_inputMethodWindow = nullptr;
583 Q_EMIT inputMethodSurfaceChanged(nullptr);
584 InputMethodManager::instance()->setWindow(nullptr);
585 }
586}
587
588void TopLevelWindowModel::onSurfacesRaised(const QVector<lomiriapi::MirSurfaceInterface*> &surfaces)
589{
590 DEBUG_MSG << "(" << surfaces << ")";
591 const int raiseCount = surfaces.size();
592 for (int i = 0; i < raiseCount; i++) {
593 int fromIndex = indexOf(surfaces[i]);
594 if (fromIndex != -1) {
595 move(fromIndex, 0);
596 }
597 }
598}
599
600int TopLevelWindowModel::rowCount(const QModelIndex &/*parent*/) const
601{
602 return m_windowModel.count();
603}
604
605QVariant TopLevelWindowModel::data(const QModelIndex& index, int role) const
606{
607 if (index.row() < 0 || index.row() >= m_windowModel.size())
608 return QVariant();
609
610 if (role == WindowRole) {
611 Window *window = m_windowModel.at(index.row()).window;
612 return QVariant::fromValue(window);
613 } else if (role == ApplicationRole) {
614 return QVariant::fromValue(m_windowModel.at(index.row()).application);
615 } else {
616 return QVariant();
617 }
618}
619
620QString TopLevelWindowModel::toString()
621{
622 QString str;
623 for (int i = 0; i < m_windowModel.count(); ++i) {
624 auto item = m_windowModel.at(i);
625
626 QString itemStr = QString("(index=%1,appId=%2,surface=0x%3,id=%4)")
627 .arg(QString::number(i),
628 item.application->appId(),
629 QString::number((qintptr)item.window->surface(), 16),
630 QString::number(item.window->id()));
631
632 if (i > 0) {
633 str.append(",");
634 }
635 str.append(itemStr);
636 }
637 return str;
638}
639
640int TopLevelWindowModel::indexOf(lomiriapi::MirSurfaceInterface *surface)
641{
642 for (int i = 0; i < m_windowModel.count(); ++i) {
643 if (m_windowModel.at(i).window->surface() == surface) {
644 return i;
645 }
646 }
647 return -1;
648}
649
651{
652 for (int i = 0; i < m_windowModel.count(); ++i) {
653 if (m_windowModel[i].window->id() == id) {
654 return i;
655 }
656 }
657 return -1;
658}
659
661{
662 if (index >=0 && index < m_windowModel.count()) {
663 return m_windowModel[index].window;
664 } else {
665 return nullptr;
666 }
667}
668
669lomiriapi::MirSurfaceInterface *TopLevelWindowModel::surfaceAt(int index) const
670{
671 if (index >=0 && index < m_windowModel.count()) {
672 return m_windowModel[index].window->surface();
673 } else {
674 return nullptr;
675 }
676}
677
678lomiriapi::ApplicationInfoInterface *TopLevelWindowModel::applicationAt(int index) const
679{
680 if (index >=0 && index < m_windowModel.count()) {
681 return m_windowModel[index].application;
682 } else {
683 return nullptr;
684 }
685}
686
687int TopLevelWindowModel::idAt(int index) const
688{
689 if (index >=0 && index < m_windowModel.count()) {
690 return m_windowModel[index].window->id();
691 } else {
692 return 0;
693 }
694}
695
697{
698 if (m_modelState == IdleState) {
699 DEBUG_MSG << "(id=" << id << ") - do it now.";
700 doRaiseId(id);
701 } else {
702 DEBUG_MSG << "(id=" << id << ") - Model busy (modelState=" << m_modelState << "). Try again in the next event loop.";
703 // The model has just signalled some change. If we have a Repeater responding to this update, it will get nuts
704 // if we perform yet another model change straight away.
705 //
706 // A bad sympton of this problem is a Repeater.itemAt(index) call returning null event though Repeater.count says
707 // the index is definitely within bounds.
708 QMetaObject::invokeMethod(this, "raiseId", Qt::QueuedConnection, Q_ARG(int, id));
709 }
710}
711
712void TopLevelWindowModel::doRaiseId(int id)
713{
714 int fromIndex = indexForId(id);
715 // can't raise something that doesn't exist or that it's already on top
716 if (fromIndex != -1 && fromIndex != 0) {
717 auto surface = m_windowModel[fromIndex].window->surface();
718 if (surface && surface->live()) {
719 m_surfaceManager->raise(surface);
720 } else {
721 // move it ourselves. Since there's no mir::scene::Surface/miral::Window, there's nothing
722 // miral can do about it.
723 move(fromIndex, 0);
724 }
725 }
726}
727
728void TopLevelWindowModel::setFocusedWindow(Window *window)
729{
730 if (window != m_focusedWindow) {
731 INFO_MSG << "(" << window << ")";
732
733 m_previousWindow = m_focusedWindow;
734
735 m_focusedWindow = window;
736 Q_EMIT focusedWindowChanged(m_focusedWindow);
737
738 if (m_previousWindow && m_previousWindow->focused() && !m_previousWindow->surface()) {
739 // do it ourselves. miral doesn't know about this window
740 m_previousWindow->setFocused(false);
741 }
742 }
743
744 // Reset
745 m_pendingActivation = false;
746}
747
748lomiriapi::MirSurfaceInterface* TopLevelWindowModel::inputMethodSurface() const
749{
750 return m_inputMethodWindow ? m_inputMethodWindow->surface() : nullptr;
751}
752
754{
755 return m_focusedWindow;
756}
757
758void TopLevelWindowModel::move(int from, int to)
759{
760 if (from == to) return;
761 DEBUG_MSG << " from=" << from << " to=" << to;
762
763 if (from >= 0 && from < m_windowModel.size() && to >= 0 && to < m_windowModel.size()) {
764 QModelIndex parent;
765 /* When moving an item down, the destination index needs to be incremented
766 by one, as explained in the documentation:
767 http://qt-project.org/doc/qt-5.0/qtcore/qabstractitemmodel.html#beginMoveRows */
768
769 Q_ASSERT(m_modelState == IdleState);
770 m_modelState = MovingState;
771
772 beginMoveRows(parent, from, from, parent, to + (to > from ? 1 : 0));
773#if QT_VERSION < QT_VERSION_CHECK(5, 6, 0)
774 const auto &window = m_windowModel.takeAt(from);
775 m_windowModel.insert(to, window);
776#else
777 m_windowModel.move(from, to);
778#endif
779 endMoveRows();
780
781 Q_EMIT listChanged();
782 m_modelState = IdleState;
783
784 INFO_MSG << " after " << toString();
785 }
786}
787void TopLevelWindowModel::onModificationsStarted()
788{
789 m_surfaceManagerBusy = true;
790}
791
792void TopLevelWindowModel::onModificationsEnded()
793{
794 if (m_focusedWindowCleared) {
795 setFocusedWindow(nullptr);
796 }
797 // reset
798 m_focusedWindowCleared = false;
799 m_surfaceManagerBusy = false;
800}
801
802void TopLevelWindowModel::activateTopMostWindowWithoutId(int forbiddenId)
803{
804 DEBUG_MSG << "(" << forbiddenId << ")";
805
806 for (int i = 0; i < m_windowModel.count(); ++i) {
807 Window *window = m_windowModel[i].window;
808 if (window->id() != forbiddenId) {
809 window->activate();
810 break;
811 }
812 }
813}
814
815void TopLevelWindowModel::refreshWindows()
816{
817 DEBUG_MSG << "()";
818 clear();
819
820 if (!m_workspace || !m_applicationManager || !m_surfaceManager) return;
821
822 m_surfaceManager->forEachSurfaceInWorkspace(m_workspace->workspace(), [this](lomiri::shell::application::MirSurfaceInterface* surface) {
823 if (surface->parentSurface()) {
824 // Wrap it in a Window so that we keep focusedWindow() up to date.
825 Window *window = createWindow(surface);
826 connect(surface, &QObject::destroyed, window, [=](){
827 window->setSurface(nullptr);
828 window->deleteLater();
829 });
830 } else {
831 if (surface->type() == Mir::InputMethodType) {
832 setInputMethodWindow(createWindow(surface));
833 } else {
834 auto *application = m_applicationManager->findApplicationWithSurface(surface);
835 if (application) {
836 prependSurface(surface, application);
837 } else {
838 // Must be a prompt session. No need to do add it as a prompt surface is not top-level.
839 // It will show up in the ApplicationInfoInterface::promptSurfaceList of some application.
840 // Still wrap it in a Window though, so that we keep focusedWindow() up to date.
841 Window *promptWindow = createWindow(surface);
842 connect(surface, &QObject::destroyed, promptWindow, [=](){
843 promptWindow->setSurface(nullptr);
844 promptWindow->deleteLater();
845 });
846 }
847 }
848 }
849 });
850}
851
852void TopLevelWindowModel::clear()
853{
854 DEBUG_MSG << "()";
855
856 while(m_windowModel.count() > 0) {
857 ModelEntry entry = m_windowModel.takeAt(0);
858 disconnect(entry.window, 0, this, 0);
859 delete entry.window;
860 }
861 m_allSurfaces.clear();
862 setFocusedWindow(nullptr);
863 m_focusedWindowCleared = false;
864 m_previousWindow = nullptr;
865}
866
868{
869 m_closingAllApps = true;
870 for (auto win : m_windowModel) {
871 win.window->close();
872 }
873
874 // This is done after the for loop in the unlikely event that
875 // an app starts in between this
876 if (m_windowModel.isEmpty()) {
877 Q_EMIT closedAllWindows();
878 }
879}
880
882{
883 return !m_nullWindow->focused();
884}
885
886void TopLevelWindowModel::setRootFocus(bool focus)
887{
888 INFO_MSG << "(" << focus << "), surfaceManagerBusy is " << m_surfaceManagerBusy;
889
890 if (m_surfaceManagerBusy) {
891 // Something else is probably being focused already, let's not add to
892 // the noise.
893 return;
894 }
895
896 if (focus) {
897 // Give focus back to previous focused window, only if null window is focused.
898 // If null window is not focused, a different app had taken the focus and we
899 // should repect that, or if a pendingActivation is going on.
900 if (m_previousWindow && !m_previousWindow->focused() && !m_pendingActivation &&
901 m_nullWindow == m_focusedWindow && m_previousWindow != m_nullWindow) {
902 m_previousWindow->activate();
903 } else if (!m_pendingActivation) {
904 // The previous window does not exist any more, focus top window.
905 activateTopMostWindowWithoutId(-1);
906 }
907 } else {
908 if (!m_nullWindow->focused()) {
909 m_nullWindow->activate();
910 }
911 }
912}
913
914// Pending Activation will block refocus of previous focused window
915// this is needed since surface activation with miral is async,
916// and activation of placeholder is sync. This causes a race condition
917// between placeholder and prev window. This results in prev window
918// gets focused, as it will always be later than the placeholder.
920{
921 m_pendingActivation = true;
922}
Q_INVOKABLE void raiseId(int id)
Raises the row with the given id to the top of the window stack (index == count-1)
bool rootFocus
Sets whether a user Window or "nothing" should be focused.
Q_INVOKABLE Window * windowAt(int index) const
Returns the window at the given index.
Q_INVOKABLE lomiri::shell::application::MirSurfaceInterface * surfaceAt(int index) const
Returns the surface at the given index.
Q_INVOKABLE void pendingActivation()
Sets pending activation flag.
Q_INVOKABLE int indexForId(int id) const
Returns the index where the row with the given id is located.
lomiri::shell::application::MirSurfaceInterface * inputMethodSurface
The input method surface, if any.
Q_INVOKABLE int idAt(int index) const
Returns the unique id of the element at the given index.
Q_INVOKABLE void closeAllWindows()
Closes all windows, emits closedAllWindows when done.
void listChanged()
Emitted when the list changes.
Q_INVOKABLE lomiri::shell::application::ApplicationInfoInterface * applicationAt(int index) const
Returns the application at the given index.
Window * focusedWindow
The currently focused window, if any.
A slightly higher concept than MirSurface.
Definition: Window.h:48
int id
A unique identifier for this window. Useful for telling windows apart in a list model as they get mov...
Definition: Window.h:84
void focusRequested()
Emitted when focus for this window is requested by an external party.
lomiri::shell::application::MirSurfaceInterface * surface
Surface backing up this window It might be null if a surface hasn't been created yet (application is ...
Definition: Window.h:92
bool focused
Whether the surface is focused.
Definition: Window.h:71
void activate()
Focuses and raises the window.
Definition: Window.cpp:137
Mir::State state
State of the surface.
Definition: Window.h:64