703 lines
19 KiB
C++
Executable File
703 lines
19 KiB
C++
Executable File
// NOTE: removing a screen after the OpApp was started results in an invisible screen
|
|
// NOTE: adding and removing a screen after the OpApp was started in tablet mode will make mmm do weird things
|
|
|
|
#include "lts_multi_monitor.h"
|
|
#include "lts_multi_monitor_selector_normal.h"
|
|
#include "lts_multi_monitor_selector_wide.h"
|
|
#include "lts_screen_normal.h"
|
|
#include "lts_screen_wide.h"
|
|
#include "lts_dummy_widget.h"
|
|
#include "lts_screen_container.h"
|
|
|
|
#include <LtsWidgets/lts_message_dialog.h>
|
|
#include <LtsWidgets/lts_base_layout_widget.h>
|
|
#include <LtsSession/lts_session_data.h>
|
|
|
|
#include <QGuiApplication>
|
|
#include <QScreen>
|
|
#include <QPointer>
|
|
#include <QWidget>
|
|
#include <QRect>
|
|
#include <QMessageBox>
|
|
#include <QDebug>
|
|
#ifdef Q_OS_WIN
|
|
#include <QtPlatformHeaders/qwindowswindowfunctions.h>
|
|
#endif
|
|
|
|
|
|
namespace LtsMultiMonitor
|
|
{
|
|
static LtsMultiMonitor *s_ltsMultiMonitor = nullptr;
|
|
|
|
|
|
LtsMultiMonitor *LtsMultiMonitor::getInstance()
|
|
{
|
|
if (!s_ltsMultiMonitor)
|
|
{
|
|
s_ltsMultiMonitor = new LtsMultiMonitor;
|
|
qAddPostRoutine(&cleanupLtsMultiMonitor);
|
|
}
|
|
return s_ltsMultiMonitor;
|
|
}
|
|
|
|
void LtsMultiMonitor::cleanupLtsMultiMonitor()
|
|
{
|
|
delete s_ltsMultiMonitor;
|
|
s_ltsMultiMonitor = nullptr;
|
|
}
|
|
|
|
|
|
LtsMultiMonitor::LtsMultiMonitor()
|
|
: QObject(nullptr)
|
|
, m_mainScreen(nullptr)
|
|
, m_active(false)
|
|
, m_initialized(false)
|
|
, m_skipScreenId(-1)
|
|
, m_subSkipScreenId(-1)
|
|
// , m_dummy(new QWidget())
|
|
, m_overlapBaseLayouts(false)
|
|
, m_debugMargins(false)
|
|
{}
|
|
|
|
|
|
LtsMultiMonitor::~LtsMultiMonitor()
|
|
{
|
|
// if (m_superParent)
|
|
// m_superParent->deleteLater();
|
|
|
|
for (auto i = m_screens.begin(); i != m_screens.end(); ++i)
|
|
{
|
|
LtsScreenBase *screen = *i;
|
|
disconnect(screen, &QObject::destroyed, this, &LtsMultiMonitor::screenDied);
|
|
screen->deleteLater();
|
|
}
|
|
|
|
//qDeleteAll(m_screens);
|
|
//delete m_dummy;
|
|
//m_dummy->deleteLater();
|
|
}
|
|
|
|
|
|
void LtsMultiMonitor::screenDied()
|
|
{
|
|
// qWarning() << "whoops! a screen died!";
|
|
Q_ASSERT(false);
|
|
}
|
|
|
|
|
|
void LtsMultiMonitor::init()
|
|
{
|
|
// TODO: reinit if device is a tablet, to refresh screen count for attaching screens live
|
|
if (LtsSessionData::LtsSessionData::getInstance()->isTablet())
|
|
{
|
|
m_overlapBaseLayouts = true;
|
|
m_initialized = true;
|
|
return;
|
|
}
|
|
|
|
if (m_initialized || !m_active)
|
|
return;
|
|
|
|
QList<QScreen *> screenList = QGuiApplication::screens();
|
|
const QScreen &mainScreen = *QGuiApplication::primaryScreen();
|
|
|
|
// qWarning() << "skip screen" << m_skipScreenId << "part" << m_subSkipScreenId;
|
|
|
|
//for (int i = 0; i < screenList.count(); i++)
|
|
for (auto i = screenList.constBegin(); i != screenList.constEnd(); ++i)
|
|
{
|
|
const QScreen &screen = **i;//screenList.at(i);
|
|
|
|
// only add screen if it was not already added, by its serial number
|
|
bool found = false;
|
|
|
|
for (LtsScreenBase *ltsScreen : qAsConst(m_screens))
|
|
{
|
|
if (ltsScreen->serialNumber() == screen.name())
|
|
{
|
|
found = true;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (found)
|
|
continue;
|
|
|
|
// more like "possible" screen id as there can be some continues, etc.
|
|
int screenId = m_nextScreenId++;
|
|
// qWarning() << "screen id" << screenId;
|
|
|
|
QRect screenGeo(screen.geometry());
|
|
|
|
if (screenId == m_skipScreenId) // do not create LtsScreenBase where AVM is (or at least limit the "sub screens")
|
|
{
|
|
if (m_subSkipScreenId == 0)
|
|
{
|
|
// left left side of screen empty
|
|
QRect newScreenGeo(screenGeo);
|
|
|
|
newScreenGeo.moveLeft(screenGeo.x() + (screenGeo.width() / 2)/* + 1*/);
|
|
newScreenGeo.setWidth(screenGeo.width() / 2);
|
|
|
|
screenGeo = newScreenGeo;
|
|
}
|
|
else if (m_subSkipScreenId == 1)
|
|
{
|
|
// left right side of screen empty
|
|
QRect newScreenGeo(screenGeo);
|
|
|
|
newScreenGeo.setWidth(screenGeo.width() / 2); // starts to malfunction in old gnome starting from 1.78 ...
|
|
|
|
screenGeo = newScreenGeo;
|
|
}
|
|
else // completely skip LtsScreenBase creation if no sub screen is set
|
|
{
|
|
// qWarning() << "skipping" << screenId;
|
|
continue;
|
|
}
|
|
}
|
|
|
|
// qWarning() << "screenGeo" << screenGeo;
|
|
|
|
bool isUltraWideView = (screenGeo.width() > 3000);
|
|
|
|
LtsScreenBase *newScreen;
|
|
if (isUltraWideView)
|
|
{
|
|
newScreen = new LtsScreenWide(screenGeo, screenId, m_debugMargins, screen.name());
|
|
}
|
|
else
|
|
{
|
|
auto *newScreenNormal = new LtsScreenNormal(std::move(screenGeo), screenId, m_debugMargins, screen.name());
|
|
newScreen = newScreenNormal;
|
|
|
|
// see https://devhub.defence-elec.de/confluence/x/yLjeDg 13.1
|
|
connect(newScreenNormal, &LtsScreenNormal::signalMakeAllSwole,
|
|
this, &LtsMultiMonitor::signalMakeAllSwole);
|
|
connect(this, &LtsMultiMonitor::signalMakeAllSwole,
|
|
newScreenNormal, &LtsScreenNormal::signalMakeSwole);
|
|
}
|
|
|
|
connect(newScreen, &QObject::destroyed, this, &LtsMultiMonitor::screenDied);
|
|
|
|
if ((&mainScreen) == (&screen))
|
|
m_mainScreen = newScreen;
|
|
|
|
m_screens.append(newScreen);
|
|
}
|
|
if (m_screens.isEmpty())
|
|
{
|
|
QMessageBox::critical(nullptr, QString(), tr("No screens found - cannot start application."));
|
|
abort();
|
|
}
|
|
|
|
if (m_mainScreen == nullptr)
|
|
m_mainScreen = m_screens.first();
|
|
|
|
m_initialized = true;
|
|
emit signalScreenCountChanged(screenCount());
|
|
}
|
|
|
|
|
|
int LtsMultiMonitor::screenCount() const
|
|
{
|
|
return m_screens.count();
|
|
}
|
|
|
|
|
|
bool LtsMultiMonitor::cancelAndProcessIfInactive(QWidget *widget) const
|
|
{
|
|
if (m_active)
|
|
return false;
|
|
|
|
widget->activateWindow(); // no mmm => show as discrete window
|
|
widget->show();
|
|
|
|
place(widget);
|
|
|
|
return true;
|
|
}
|
|
|
|
|
|
void LtsMultiMonitor::place(QWidget *widget)
|
|
{
|
|
/* tell the blw that it was now sucessfully placed and is shown / ready to use
|
|
* e.g. for autostarting a replay only if it is already visible, so the user
|
|
* doesn't miss out on the replay's beginning
|
|
*
|
|
* -- as this method returns here, we have to emit 'successfullyPlaced' here,
|
|
* as the widget is now visible as its own widget
|
|
*/
|
|
auto *blw = qobject_cast<LtsWidgets::LtsBaseLayoutWidget *>(widget);
|
|
if (blw != nullptr)
|
|
emit blw->signalSuccessfullyPlaced();
|
|
}
|
|
|
|
|
|
bool LtsMultiMonitor::putScreen(QWidget *widget, int screenId, int screenPart)
|
|
{
|
|
Q_ASSERT(widget != nullptr);
|
|
if (widget == nullptr)
|
|
return false; // fail-safe
|
|
|
|
if (cancelAndProcessIfInactive(widget))
|
|
return true;
|
|
|
|
init();
|
|
|
|
if (overlapBaseLayouts(widget)) // NOTE: call 'init' before 'overlapBaseLayouts'
|
|
return true;
|
|
|
|
|
|
bool isSecondary = isWidgetSecondary(widget);
|
|
qWarning() << "putScreen: isSecondary" << isSecondary;
|
|
|
|
for (LtsScreenBase *screen : qAsConst(m_screens))
|
|
{
|
|
if (screen->screenId() != screenId)
|
|
continue;
|
|
|
|
screen->switchToTemp(isSecondary ? LtsScreenBase::WidgetType::SecondaryWidget : LtsScreenBase::WidgetType::MainWidget);
|
|
|
|
try
|
|
{
|
|
screen->putWidget(widget, screenPart);
|
|
}
|
|
catch (...)
|
|
{
|
|
screen->revertSwitch();
|
|
// qWarning() << "LtsMultiMonitor:::putScreen: cannot put widget on screen "<<screenId<<" at part "<<screenPart<<"! Using selectScreen()!";
|
|
return selectScreen(widget);
|
|
}
|
|
|
|
screen->check();
|
|
// qWarning() << "mep" << QStringLiteral("%1:%2").arg(QString::fromUtf8(__FILE__).split(QStringLiteral("/")).last()).arg(__LINE__);
|
|
place(widget);
|
|
screen->finalizeSwitch();
|
|
return true;
|
|
}
|
|
|
|
// qWarning() << "LtsMultiMonitor:::putScreen: screen"<<screenId<<"not available! Using selectScreen()!";
|
|
return selectScreen(widget);
|
|
}
|
|
|
|
bool LtsMultiMonitor::putScreenAutomatically(QWidget *widget)
|
|
{
|
|
if (widget == nullptr)
|
|
return false;
|
|
|
|
if (cancelAndProcessIfInactive(widget))
|
|
return true;
|
|
|
|
init();
|
|
|
|
if (overlapBaseLayouts(widget)) // NOTE: call 'init' before 'overlapBaseLayouts'
|
|
return true;
|
|
|
|
for (LtsScreenBase *screen : qAsConst(m_screens))
|
|
{
|
|
if (screen->screenId() == m_skipScreenId || !screen->isEmpty())
|
|
continue;
|
|
|
|
screen->switchToTemp(LtsScreenBase::WidgetType::SecondaryWidget);
|
|
|
|
try //first try on part 1
|
|
{
|
|
screen->putWidget(widget, 1);
|
|
}
|
|
catch (...)
|
|
{
|
|
try //if part 1 failed, try part 2
|
|
{
|
|
screen->putWidget(widget, 2);
|
|
}
|
|
catch (...) //if part 2 failed, try next screen
|
|
{
|
|
screen->revertSwitch();
|
|
continue;
|
|
}
|
|
}
|
|
|
|
screen->check();
|
|
place(widget);
|
|
screen->finalizeSwitch();
|
|
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
|
|
bool LtsMultiMonitor::isOverlapBaseLayouts() const
|
|
{
|
|
return (m_overlapBaseLayouts /*&& m_screens.count() == 1*/); // TODO: reactivate if mmm works with external monitors on a tablet
|
|
}
|
|
|
|
|
|
void LtsMultiMonitor::freezeMagicCorner(int screenId)
|
|
{
|
|
|
|
for (auto *screen : qAsConst(m_screens))
|
|
{
|
|
|
|
if (screen->screenId() == screenId)
|
|
{
|
|
LtsScreenNormal* normalScreen = qobject_cast<LtsScreenNormal*>(screen);
|
|
if(normalScreen->child()->hasMainWidget() && normalScreen->child()->hasSecondaryWidget())
|
|
{
|
|
normalScreen->hideMagicCorner(true);
|
|
if(normalScreen->child()->activeWidgetType() == LtsScreenBase::WidgetType::MainWidget)
|
|
normalScreen->child()->toggle();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void LtsMultiMonitor::unfreezeMagicCorner(int screenId)
|
|
{
|
|
|
|
for (auto *screen : qAsConst(m_screens))
|
|
{
|
|
|
|
if (screen->screenId() == screenId)
|
|
{
|
|
LtsScreenNormal* normalScreen = qobject_cast<LtsScreenNormal*>(screen);
|
|
if(normalScreen->child()->hasMainWidget() && normalScreen->child()->hasSecondaryWidget())
|
|
normalScreen->hideMagicCorner(false);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
bool LtsMultiMonitor::overlapBaseLayouts(QWidget *widget)
|
|
{
|
|
if (!isOverlapBaseLayouts())
|
|
return false;
|
|
|
|
/* only overlap base layouts if the main screen is the only screen - if
|
|
* another screen is connected to the tablet, the new screen should be
|
|
* selectable, too */
|
|
|
|
Q_ASSERT(qobject_cast<FullscreenVideoDummyWidget *>(widget) == nullptr);
|
|
if (qobject_cast<FullscreenVideoDummyWidget *>(widget) != nullptr)
|
|
{
|
|
// qWarning() << "tried to put a dummy widget on a tablet device... - ignore";
|
|
return false;
|
|
}
|
|
|
|
|
|
// FullscreenVideoDummyWidget *dummy = qobject_cast<FullscreenVideoDummyWidget *>(widget);
|
|
// if (dummy != nullptr)
|
|
// {
|
|
// widget->setParent(m_dummy);
|
|
// emit dummy->signalWidgetPlaced(QRect());
|
|
// }
|
|
// else
|
|
// {
|
|
// widget->show(); // as discrete window
|
|
// place(widget);
|
|
// }
|
|
|
|
|
|
#ifdef Q_OS_WIN
|
|
widget->winId(); // make sure windowHandle() is not a nullptr
|
|
QWindowsWindowFunctions::setHasBorderInFullScreen(widget->windowHandle(), true);
|
|
#endif
|
|
|
|
widget->activateWindow();
|
|
widget->showFullScreen();
|
|
|
|
place(widget);
|
|
|
|
return true;
|
|
}
|
|
|
|
|
|
bool LtsMultiMonitor::selectAndSwap(QWidget *widget)
|
|
{
|
|
if (!m_active)
|
|
return false; // no swap if mmm not active
|
|
|
|
Q_ASSERT(!isOverlapBaseLayouts()); // swap button not allowed on tablet
|
|
if (isOverlapBaseLayouts())
|
|
return false; // don't allow swap if overlay mode is active (as that would make no sense)
|
|
|
|
|
|
// look for the screen which contains the widget
|
|
LtsScreenContainer *oldContainer = nullptr; // TODO C++17: std::optional
|
|
for (LtsScreenBase *_screen : qAsConst(m_screens))
|
|
{
|
|
try
|
|
{
|
|
oldContainer = _screen->containerOfWidget(widget);
|
|
}
|
|
catch (...){}
|
|
}
|
|
|
|
if (oldContainer == nullptr)
|
|
{
|
|
// qWarning() << "!!! mep" << __FILE__ << __LINE__;
|
|
LtsWidgets::LtsMessageDialog::showMessage(widget, tr("Could not determine screen id for this swap!<br>Swapping not possible, please try again later."));
|
|
return false;
|
|
}
|
|
|
|
// qWarning() << "oldContainer" << (quintptr)oldContainer;
|
|
|
|
|
|
return selectScreen(widget, oldContainer); // NOTE: the screen later TAKES the widget from the clicked container and puts it into the OLD container given
|
|
}
|
|
|
|
|
|
LtsScreenBase *LtsMultiMonitor::widgetsScreen(QWidget *widget)
|
|
{
|
|
for (LtsScreenBase *screen : qAsConst(m_screens))
|
|
if (screen->hasWidget(widget))
|
|
return screen;
|
|
return nullptr;
|
|
}
|
|
|
|
|
|
bool LtsMultiMonitor::isWidgetSecondary(QWidget *widget)
|
|
{
|
|
#ifndef GUEZ_MODE
|
|
return false;
|
|
#endif
|
|
|
|
auto *blw = qobject_cast<LtsWidgets::LtsBaseLayoutWidget *>(widget);
|
|
auto *secondaryWidget = qobject_cast<SecondaryWidget *>(widget); // full screen video & script editor's screen widget
|
|
|
|
bool isSecondaryWidget = ((blw != nullptr && blw->isSecondaryWidget()) || secondaryWidget != nullptr);
|
|
|
|
// if (isSec)
|
|
|
|
return isSecondaryWidget;
|
|
}
|
|
|
|
|
|
class StupidDeleter
|
|
{
|
|
public:
|
|
explicit StupidDeleter(LtsScreenBase *screen)
|
|
: m_screen(screen)
|
|
{}
|
|
|
|
~StupidDeleter()
|
|
{
|
|
//qWarning() << "####### Deleter";
|
|
if (m_screen != nullptr)
|
|
{
|
|
//qWarning() << "####### REVERTED";
|
|
m_screen->revertSwitch();
|
|
}
|
|
//else qWarning() << "####### NOT REVERTED !!!!";
|
|
}
|
|
|
|
void reset()
|
|
{
|
|
//qWarning() << "####### RESET";
|
|
m_screen = nullptr;
|
|
}
|
|
|
|
|
|
private:
|
|
LtsScreenBase *m_screen;
|
|
};
|
|
|
|
|
|
bool LtsMultiMonitor::selectScreen(QWidget *widget, LtsScreenContainer *swap, bool putOnMainIfFree, bool ltsScreenNormalOnly, const QVector<QWidget *> &irreplacableWidgets)
|
|
{
|
|
Q_ASSERT(widget != nullptr);
|
|
if (widget == nullptr)
|
|
return false; // fail-safe
|
|
|
|
if (cancelAndProcessIfInactive(widget))
|
|
return true;
|
|
|
|
init();
|
|
|
|
if (overlapBaseLayouts(widget)) // NOTE: call 'init' before 'overlapBaseLayouts'
|
|
return true;
|
|
|
|
bool isSecondary = isWidgetSecondary(widget);
|
|
//qWarning() << "selectScreen: isSecondary" << isSecondary;
|
|
|
|
if (!isSecondary) // the allEmpty stuff is only for main widgets!!
|
|
{
|
|
bool allEmpty = putOnMainIfFree; // initial value
|
|
for (LtsScreenBase *screen : qAsConst(m_screens))
|
|
{
|
|
screen->switchToTemp(LtsScreenBase::WidgetType::MainWidget);
|
|
bool isEmpty = screen->isEmpty();
|
|
screen->revertSwitch();
|
|
|
|
if (isEmpty)
|
|
continue;
|
|
|
|
allEmpty = false;
|
|
break;
|
|
}
|
|
|
|
//qWarning() << "allEmpty" << allEmpty;
|
|
|
|
if (allEmpty)
|
|
{
|
|
/* if ALL screens in the entire mmm are empty, then just put the widget on
|
|
* the main screen */
|
|
|
|
m_mainScreen->switchToTemp(LtsScreenBase::WidgetType::MainWidget);
|
|
|
|
try
|
|
{
|
|
m_mainScreen->putWidget(widget);
|
|
}
|
|
catch (...)
|
|
{
|
|
qWarning() << "failed - reverting";
|
|
m_mainScreen->revertSwitch();
|
|
|
|
Q_ASSERT_X(false, __FUNCTION__, "screen promised to be empty but 'putWidgetSomewhere' method failed regardless");
|
|
// qWarning() << "woopsie";
|
|
|
|
auto *blw = qobject_cast<LtsWidgets::LtsBaseLayoutWidget *>(widget);
|
|
if (blw != nullptr)
|
|
emit blw->signalClose();
|
|
else
|
|
widget->deleteLater();
|
|
|
|
return false; // fail-safe
|
|
}
|
|
|
|
m_mainScreen->check();
|
|
place(widget);
|
|
m_mainScreen->finalizeSwitch();
|
|
return true;
|
|
}
|
|
}
|
|
|
|
|
|
auto *selectionProcessWatcher = new QObject;
|
|
|
|
// finally show selectors
|
|
bool minOnce = false;
|
|
|
|
for (auto i = m_screens.begin(); i != m_screens.end(); ++i)
|
|
{
|
|
LtsScreenBase *screen = *i;
|
|
|
|
screen->switchToTemp(isSecondary ? LtsScreenBase::WidgetType::SecondaryWidget : LtsScreenBase::WidgetType::MainWidget);
|
|
|
|
StupidDeleter _(screen);
|
|
|
|
if (screen->isIrreplaceable()) // do not create mms for a screen that is fully irreplaceable
|
|
{
|
|
// qWarning() << "screen marked as irreplacable, skipping"<<screen;
|
|
continue;
|
|
}
|
|
|
|
bool skip = false;
|
|
for (QWidget *widget : qAsConst(irreplacableWidgets))
|
|
{
|
|
// qWarning() << "does screen have" << widget<<screen;
|
|
if (screen->hasWidget(widget))
|
|
{
|
|
// qWarning() << "yes, skipping!";
|
|
skip = true;
|
|
continue;
|
|
}
|
|
|
|
// qWarning() << "no, selection available";
|
|
}
|
|
|
|
if (skip)
|
|
continue;
|
|
|
|
MultiMonitorSelectorBase *mms;
|
|
if (qobject_cast<LtsScreenNormal *>(screen) != nullptr)
|
|
{
|
|
auto *screenNormal = static_cast<LtsScreenNormal *>(screen);
|
|
mms = new MultiMonitorSelectorNormal(screenNormal, isSecondary, irreplacableWidgets);
|
|
}
|
|
else if (qobject_cast<LtsScreenWide *>(screen) != nullptr && !ltsScreenNormalOnly)
|
|
{
|
|
auto *screenWide = static_cast<LtsScreenWide *>(screen);
|
|
mms = new MultiMonitorSelectorWide(screenWide, nullptr, irreplacableWidgets);
|
|
}
|
|
else
|
|
continue;
|
|
|
|
|
|
QPointer<QWidget> widgetPtr(widget);
|
|
|
|
|
|
connect(widget, &QWidget::destroyed,
|
|
mms, &MultiMonitorSelectorBase::close);
|
|
connect(mms, &MultiMonitorSelectorBase::rejected,//signalAbort,
|
|
this, [widgetPtr, swap]()
|
|
{
|
|
// qWarning() << "mep" << QStringLiteral("%1:%2").arg(QString::fromUtf8(__FILE__).split(QStringLiteral("/")).last()).arg(__LINE__);
|
|
|
|
if (!widgetPtr || swap != nullptr) // don't delete widget if it was a swap, just let it live where it currently is living
|
|
return;
|
|
|
|
// qWarning() << "mep" << QStringLiteral("%1:%2").arg(QString::fromUtf8(__FILE__).split(QStringLiteral("/")).last()).arg(__LINE__);
|
|
|
|
//qWarning() << "###### REJECTED!!!!";
|
|
|
|
auto *blw = qobject_cast<LtsWidgets::LtsBaseLayoutWidget *>(widgetPtr.data());
|
|
if (blw != nullptr)
|
|
emit blw->signalClose();
|
|
else
|
|
widgetPtr->deleteLater();
|
|
});
|
|
connect(mms, &MultiMonitorSelectorBase::signalSelected,
|
|
this, [this, mms, widgetPtr]()
|
|
{
|
|
// qWarning() << "mep" << QStringLiteral("%1:%2").arg(QString::fromUtf8(__FILE__).split(QStringLiteral("/")).last()).arg(__LINE__);
|
|
|
|
for (LtsScreenBase *screen : qAsConst(m_screens))
|
|
screen->check();
|
|
|
|
// qWarning() << "mep" << QStringLiteral("%1:%2").arg(QString::fromUtf8(__FILE__).split(QStringLiteral("/")).last()).arg(__LINE__);
|
|
|
|
if (widgetPtr)
|
|
place(widgetPtr.data());
|
|
|
|
// qWarning() << "mep" << QStringLiteral("%1:%2").arg(QString::fromUtf8(__FILE__).split(QStringLiteral("/")).last()).arg(__LINE__);
|
|
|
|
mms->deleteLater();
|
|
emit signalSelected();
|
|
|
|
//qWarning() << "mep" << QStringLiteral("%1:%2").arg(QString::fromUtf8(__FILE__).split(QStringLiteral("/")).last()).arg(__LINE__);
|
|
});
|
|
connect(mms, &MultiMonitorSelectorBase::destroyed,
|
|
selectionProcessWatcher, &QObject::deleteLater);
|
|
connect(selectionProcessWatcher, &QObject::destroyed,
|
|
mms, &MultiMonitorSelectorBase::close);
|
|
|
|
mms->setSwap(swap);
|
|
mms->setWidget(widget);
|
|
mms->show();
|
|
_.reset();
|
|
minOnce = true;
|
|
}
|
|
|
|
if (!minOnce)
|
|
{
|
|
selectionProcessWatcher->deleteLater();
|
|
auto *blw = qobject_cast<LtsWidgets::LtsBaseLayoutWidget *>(widget);
|
|
if (blw != nullptr)
|
|
emit blw->signalClose();
|
|
else
|
|
widget->deleteLater();
|
|
|
|
LtsWidgets::LtsMessageDialog::showMessage(m_mainScreen->screenDialog(), tr("There are no free screens available to select from."));
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
|
|
} // namespace LtsMultiMonitor
|