25 #include "private/LayoutSaver_p.h"
26 #include "private/DockRegistry_p.h"
27 #include "private/DockWidgetBase_p.h"
28 #include "private/FloatingWindow_p.h"
29 #include "private/Frame_p.h"
30 #include "private/LayoutWidget_p.h"
31 #include "private/Logging_p.h"
32 #include "private/Position_p.h"
61 LayoutSaver::Layout *LayoutSaver::Layout::s_currentLayoutBeingRestored =
nullptr;
67 return InternalRestoreOption::None;
69 return InternalRestoreOptions(InternalRestoreOption::SkipMainWindowGeometry)
70 | InternalRestoreOption::RelativeFloatingWindowGeometry;
72 qWarning() << Q_FUNC_INFO <<
"Unknown options" << options;
77 bool LayoutSaver::Private::s_restoreInProgress =
false;
81 QVariantList variantList;
82 variantList.reserve(strs.
size());
84 variantList.push_back(str);
92 stringList.
reserve(variantList.size());
93 for (
const QVariant &variant : variantList)
100 : d(new Private(options))
113 QFile f(jsonFilename);
115 qWarning() << Q_FUNC_INFO <<
"Failed to open" << jsonFilename << f.
errorString();
125 QFile f(jsonFilename);
127 qWarning() << Q_FUNC_INFO <<
"Failed to open" << jsonFilename << f.
errorString();
139 if (!d->m_dockRegistry->isSane()) {
140 qWarning() << Q_FUNC_INFO <<
"Refusing to serialize this layout. Check previous warnings.";
144 LayoutSaver::Layout layout;
147 d->m_dockRegistry->ensureAllFloatingWidgetsAreMorphed();
150 layout.mainWindows.reserve(mainWindows.
size());
152 if (d->matchesAffinity(mainWindow->affinities()))
153 layout.mainWindows.push_back(mainWindow->serialize());
157 layout.floatingWindows.reserve(floatingWindows.
size());
158 for (KDDockWidgets::FloatingWindow *floatingWindow : floatingWindows) {
159 if (d->matchesAffinity(floatingWindow->affinities()))
160 layout.floatingWindows.push_back(floatingWindow->serialize());
165 layout.closedDockWidgets.reserve(closedDockWidgets.
size());
167 if (d->matchesAffinity(dockWidget->affinities()))
168 layout.closedDockWidgets.push_back(dockWidget->d->serialize());
175 layout.allDockWidgets.reserve(dockWidgets.
size());
177 if (d->matchesAffinity(dockWidget->affinities())) {
178 auto dw = dockWidget->d->serialize();
179 dw->lastPosition = dockWidget->d->lastPositions().serialize();
180 layout.allDockWidgets.push_back(dw);
184 return layout.toJson();
189 d->clearRestoredProperty();
202 m_saver->d->deleteEmptyFrames();
208 FrameCleanup cleanup(
this);
209 LayoutSaver::Layout layout;
210 if (!layout.fromJson(data)) {
211 qWarning() << Q_FUNC_INFO <<
"Failed to parse json data";
215 if (!layout.isValid()) {
219 layout.scaleSizes(d->m_restoreOptions);
221 d->floatWidgetsWhichSkipRestore(layout.mainWindowNames());
223 Private::RAIIIsRestoring isRestoring;
228 d->m_dockRegistry->clear(d->m_dockRegistry->dockWidgets(layout.dockWidgetsToClose()),
229 d->m_dockRegistry->mainWindows(layout.mainWindowNames()),
233 for (
const LayoutSaver::MainWindow &mw : qAsConst(layout.mainWindows)) {
234 MainWindowBase *mainWindow = d->m_dockRegistry->mainWindowByName(mw.uniqueName);
236 if (
auto mwFunc =
Config::self().mainWindowFactoryFunc()) {
237 mainWindow = mwFunc(mw.uniqueName);
239 qWarning() <<
"Failed to restore layout create MainWindow with name" << mw.uniqueName <<
"first";
244 if (!d->matchesAffinity(mainWindow->
affinities()))
247 if (!(d->m_restoreOptions & InternalRestoreOption::SkipMainWindowGeometry)) {
248 d->deserializeWindowGeometry(mw, mainWindow->
window());
251 w->setWindowState(mw.windowState);
256 if (!mainWindow->deserialize(mw))
261 for (LayoutSaver::FloatingWindow &fw : layout.floatingWindows) {
262 if (!d->matchesAffinity(fw.affinities) || fw.skipsRestore())
266 : DockRegistry::self()->mainwindows().at(fw.parentIndex);
269 fw.floatingWindowInstance = floatingWindow;
270 d->deserializeWindowGeometry(fw, floatingWindow);
271 if (!floatingWindow->deserialize(fw)) {
272 qWarning() << Q_FUNC_INFO <<
"Failed to deserialize floating window";
278 for (
const auto &dw : qAsConst(layout.closedDockWidgets)) {
279 if (d->matchesAffinity(dw->affinities)) {
280 DockWidgetBase::deserialize(dw);
285 for (
const auto &dw : qAsConst(layout.allDockWidgets)) {
286 if (!d->matchesAffinity(dw->affinities))
290 d->m_dockRegistry->dockByName(dw->uniqueName, DockRegistry::DockByNameFlag::ConsultRemapping)) {
291 dockWidget->d->lastPositions().deserialize(dw->lastPosition);
293 qWarning() << Q_FUNC_INFO <<
"Couldn't find dock widget" << dw->uniqueName;
302 d->m_affinityNames = affinityNames;
305 d->m_affinityNames <<
QString();
320 if (dw->property(
"kddockwidget_was_restored").toBool())
327 void LayoutSaver::Private::clearRestoredProperty()
331 dw->setProperty(
"kddockwidget_was_restored",
QVariant());
336 void LayoutSaver::Private::deserializeWindowGeometry(
const T &saved,
QWidgetOrQuick *topLevel)
344 KDDockWidgets::Private::setTopLevelGeometry(saved.geometry, topLevel);
350 LayoutSaver::Private::Private(RestoreOptions options)
351 : m_dockRegistry(DockRegistry::self())
356 bool LayoutSaver::Private::matchesAffinity(
const QStringList &affinities)
const
358 return m_affinityNames.isEmpty() || affinities.
isEmpty()
359 || DockRegistry::self()->affinitiesMatch(m_affinityNames, affinities);
362 void LayoutSaver::Private::floatWidgetsWhichSkipRestore(
const QStringList &mainWindowNames)
369 for (
MainWindowBase *mw : DockRegistry::self()->mainWindows(mainWindowNames)) {
371 for (
auto dw : docks) {
372 if (dw->skipsRestore()) {
373 dw->setFloating(
true);
379 void LayoutSaver::Private::deleteEmptyFrames()
384 for (
auto frame : m_dockRegistry->frames()) {
385 if (!frame->beingDeletedLater() && frame->isEmpty() && !frame->isCentralFrame())
390 std::unique_ptr<QSettings> LayoutSaver::Private::settings()
const
392 auto settings = std::unique_ptr<QSettings>(
new QSettings(qApp->organizationName(),
393 qApp->applicationName()));
394 settings->beginGroup(QStringLiteral(
"KDDockWidgets::LayoutSaver"));
401 return Private::s_restoreInProgress;
404 bool LayoutSaver::Layout::isValid()
const
406 if (serializationVersion != KDDOCKWIDGETS_SERIALIZATION_VERSION) {
407 qWarning() << Q_FUNC_INFO <<
"Serialization format is too old"
408 << serializationVersion <<
"current=" << KDDOCKWIDGETS_SERIALIZATION_VERSION;
412 for (
auto &m : mainWindows) {
417 for (
auto &m : floatingWindows) {
422 for (
auto &m : allDockWidgets) {
430 QByteArray LayoutSaver::Layout::toJson()
const
436 bool LayoutSaver::Layout::fromJson(
const QByteArray &jsonData)
448 QVariantMap LayoutSaver::Layout::toVariantMap()
const
451 map.insert(QStringLiteral(
"serializationVersion"), serializationVersion);
452 map.insert(QStringLiteral(
"mainWindows"), toVariantList<LayoutSaver::MainWindow>(mainWindows));
453 map.insert(QStringLiteral(
"floatingWindows"), toVariantList<LayoutSaver::FloatingWindow>(floatingWindows));
454 map.insert(QStringLiteral(
"closedDockWidgets"), ::dockWidgetNames(closedDockWidgets));
455 map.insert(QStringLiteral(
"allDockWidgets"), toVariantList(allDockWidgets));
456 map.insert(QStringLiteral(
"screenInfo"), toVariantList<LayoutSaver::ScreenInfo>(screenInfo));
461 void LayoutSaver::Layout::fromVariantMap(
const QVariantMap &map)
463 allDockWidgets.clear();
464 const QVariantList dockWidgetsV = map.value(QStringLiteral(
"allDockWidgets")).toList();
465 for (
const QVariant &v : dockWidgetsV) {
466 const QVariantMap dwV = v.toMap();
467 const QString name = dwV.value(QStringLiteral(
"uniqueName")).toString();
468 auto dw = LayoutSaver::DockWidget::dockWidgetForName(name);
469 dw->fromVariantMap(dwV);
470 allDockWidgets.push_back(dw);
473 closedDockWidgets.clear();
474 const QVariantList closedDockWidgetsV = map.value(QStringLiteral(
"closedDockWidgets")).toList();
475 closedDockWidgets.reserve(closedDockWidgetsV.size());
476 for (
const QVariant &v : closedDockWidgetsV) {
477 closedDockWidgets.push_back(LayoutSaver::DockWidget::dockWidgetForName(v.toString()));
480 serializationVersion = map.value(QStringLiteral(
"serializationVersion")).toInt();
481 mainWindows = fromVariantList<LayoutSaver::MainWindow>(map.value(QStringLiteral(
"mainWindows")).toList());
482 floatingWindows = fromVariantList<LayoutSaver::FloatingWindow>(map.value(QStringLiteral(
"floatingWindows")).toList());
483 screenInfo = fromVariantList<LayoutSaver::ScreenInfo>(map.value(QStringLiteral(
"screenInfo")).toList());
486 void LayoutSaver::Layout::scaleSizes(InternalRestoreOptions options)
488 if (mainWindows.isEmpty())
491 const bool skipsMainWindowGeometry = options & InternalRestoreOption::SkipMainWindowGeometry;
492 if (!skipsMainWindowGeometry) {
501 for (
auto &mw : mainWindows)
507 const bool useRelativeSizesForFloatingWidgets =
508 options & InternalRestoreOption::RelativeFloatingWindowGeometry;
510 if (useRelativeSizesForFloatingWidgets) {
511 for (
auto &fw : floatingWindows) {
512 LayoutSaver::MainWindow mw = mainWindowForIndex(fw.parentIndex);
513 if (mw.scalingInfo.isValid())
514 fw.scaleSizes(mw.scalingInfo);
518 const ScalingInfo firstScalingInfo = mainWindows.constFirst().scalingInfo;
519 if (firstScalingInfo.isValid()) {
520 for (
auto &dw : allDockWidgets) {
524 dw->scaleSizes(firstScalingInfo);
529 LayoutSaver::MainWindow LayoutSaver::Layout::mainWindowForIndex(
int index)
const
531 if (index < 0 || index >= mainWindows.size())
534 return mainWindows.at(index);
537 LayoutSaver::FloatingWindow LayoutSaver::Layout::floatingWindowForIndex(
int index)
const
539 if (index < 0 || index >= floatingWindows.size())
542 return floatingWindows.at(index);
545 QStringList LayoutSaver::Layout::mainWindowNames()
const
548 names.
reserve(mainWindows.size());
549 for (
const auto &mw : mainWindows) {
550 names << mw.uniqueName;
556 QStringList LayoutSaver::Layout::dockWidgetNames()
const
559 names.
reserve(allDockWidgets.size());
560 for (
const auto &dw : allDockWidgets) {
561 names << dw->uniqueName;
567 QStringList LayoutSaver::Layout::dockWidgetsToClose()
const
572 names.
reserve(allDockWidgets.size());
573 auto registry = DockRegistry::self();
574 for (
const auto &dw : allDockWidgets) {
575 if (
DockWidgetBase *dockWidget = registry->dockByName(dw->uniqueName)) {
579 if (dockWidget->skipsRestore()) {
580 if (
auto fw = dockWidget->floatingWindow()) {
589 names << dw->uniqueName;
596 bool LayoutSaver::Frame::isValid()
const
601 if (!geometry.isValid()) {
602 qWarning() << Q_FUNC_INFO <<
"Invalid geometry";
607 qWarning() << Q_FUNC_INFO <<
"Invalid id";
612 qWarning() << Q_FUNC_INFO <<
"Invalid options" << options;
616 if (!dockWidgets.isEmpty()) {
617 if (currentTabIndex >= dockWidgets.size() || currentTabIndex < 0) {
618 qWarning() << Q_FUNC_INFO <<
"Invalid tab index" << currentTabIndex << dockWidgets.
size();
623 for (
auto &dw : dockWidgets) {
631 bool LayoutSaver::Frame::hasSingleDockWidget()
const
633 return dockWidgets.size() == 1;
636 bool LayoutSaver::Frame::skipsRestore()
const
638 return std::all_of(dockWidgets.cbegin(), dockWidgets.cend(), [](LayoutSaver::DockWidget::Ptr dw) {
639 return dw->skipsRestore();
643 LayoutSaver::DockWidget::Ptr LayoutSaver::Frame::singleDockWidget()
const
645 if (!hasSingleDockWidget())
648 return dockWidgets.first();
651 QVariantMap LayoutSaver::Frame::toVariantMap()
const
654 map.insert(QStringLiteral(
"id"),
id);
655 map.insert(QStringLiteral(
"isNull"), isNull);
656 map.insert(QStringLiteral(
"objectName"), objectName);
657 map.insert(QStringLiteral(
"geometry"), Layouting::rectToMap(geometry));
658 map.insert(QStringLiteral(
"options"), options);
659 map.insert(QStringLiteral(
"currentTabIndex"), currentTabIndex);
661 map.insert(QStringLiteral(
"dockWidgets"), dockWidgetNames(dockWidgets));
666 void LayoutSaver::Frame::fromVariantMap(
const QVariantMap &map)
674 id = map.value(QStringLiteral(
"id")).toString();
675 isNull = map.value(QStringLiteral(
"isNull")).toBool();
676 objectName = map.value(QStringLiteral(
"objectName")).toString();
677 geometry = Layouting::mapToRect(map.value(QStringLiteral(
"geometry")).toMap());
679 currentTabIndex = map.value(QStringLiteral(
"currentTabIndex")).toInt();
681 const QVariantList dockWidgetsV = map.value(QStringLiteral(
"dockWidgets")).toList();
684 dockWidgets.reserve(dockWidgetsV.size());
685 for (
const auto &variant : dockWidgetsV) {
686 DockWidget::Ptr dw = DockWidget::dockWidgetForName(variant.toString());
687 dockWidgets.push_back(dw);
691 bool LayoutSaver::DockWidget::isValid()
const
693 return !uniqueName.isEmpty();
696 void LayoutSaver::DockWidget::scaleSizes(
const ScalingInfo &scalingInfo)
698 lastPosition.scaleSizes(scalingInfo);
701 bool LayoutSaver::DockWidget::skipsRestore()
const
703 if (
DockWidgetBase *dw = DockRegistry::self()->dockByName(uniqueName))
704 return dw->skipsRestore();
709 QVariantMap LayoutSaver::DockWidget::toVariantMap()
const
714 map.insert(QStringLiteral(
"uniqueName"), uniqueName);
715 map.insert(QStringLiteral(
"lastPosition"), lastPosition.toVariantMap());
720 void LayoutSaver::DockWidget::fromVariantMap(
const QVariantMap &map)
725 const QString affinityName = map.value(QStringLiteral(
"affinityName")).toString();
730 uniqueName = map.value(QStringLiteral(
"uniqueName")).toString();
731 lastPosition.fromVariantMap(map.value(QStringLiteral(
"lastPosition")).toMap());
734 bool LayoutSaver::FloatingWindow::isValid()
const
736 if (!multiSplitterLayout.isValid())
739 if (!geometry.isValid()) {
740 qWarning() << Q_FUNC_INFO <<
"Invalid geometry";
747 bool LayoutSaver::FloatingWindow::hasSingleDockWidget()
const
749 return multiSplitterLayout.hasSingleDockWidget();
752 LayoutSaver::DockWidget::Ptr LayoutSaver::FloatingWindow::singleDockWidget()
const
754 return multiSplitterLayout.singleDockWidget();
757 bool LayoutSaver::FloatingWindow::skipsRestore()
const
759 return multiSplitterLayout.skipsRestore();
762 void LayoutSaver::FloatingWindow::scaleSizes(
const ScalingInfo &scalingInfo)
764 scalingInfo.applyFactorsTo( geometry);
767 QVariantMap LayoutSaver::FloatingWindow::toVariantMap()
const
770 map.insert(QStringLiteral(
"multiSplitterLayout"), multiSplitterLayout.toVariantMap());
771 map.insert(QStringLiteral(
"parentIndex"), parentIndex);
772 map.insert(QStringLiteral(
"geometry"), Layouting::rectToMap(geometry));
773 map.insert(QStringLiteral(
"screenIndex"), screenIndex);
774 map.insert(QStringLiteral(
"screenSize"), Layouting::sizeToMap(screenSize));
775 map.insert(QStringLiteral(
"isVisible"), isVisible);
783 void LayoutSaver::FloatingWindow::fromVariantMap(
const QVariantMap &map)
785 multiSplitterLayout.fromVariantMap(map.value(QStringLiteral(
"multiSplitterLayout")).toMap());
786 parentIndex = map.value(QStringLiteral(
"parentIndex")).toInt();
787 geometry = Layouting::mapToRect(map.value(QStringLiteral(
"geometry")).toMap());
788 screenIndex = map.value(QStringLiteral(
"screenIndex")).toInt();
789 screenSize = Layouting::mapToSize(map.value(QStringLiteral(
"screenSize")).toMap());
790 isVisible = map.value(QStringLiteral(
"isVisible")).toBool();
794 const QString affinityName = map.value(QStringLiteral(
"affinityName")).toString();
800 bool LayoutSaver::MainWindow::isValid()
const
802 if (!multiSplitterLayout.isValid())
806 qWarning() << Q_FUNC_INFO <<
"Invalid option" << options;
813 void LayoutSaver::MainWindow::scaleSizes()
815 if (scalingInfo.isValid()) {
821 scalingInfo = ScalingInfo(uniqueName, geometry);
824 QVariantMap LayoutSaver::MainWindow::toVariantMap()
const
827 map.insert(QStringLiteral(
"options"),
int(options));
828 map.insert(QStringLiteral(
"multiSplitterLayout"), multiSplitterLayout.toVariantMap());
829 map.insert(QStringLiteral(
"uniqueName"), uniqueName);
830 map.insert(QStringLiteral(
"geometry"), Layouting::rectToMap(geometry));
831 map.insert(QStringLiteral(
"screenIndex"), screenIndex);
832 map.insert(QStringLiteral(
"screenSize"), Layouting::sizeToMap(screenSize));
833 map.insert(QStringLiteral(
"isVisible"), isVisible);
835 map.insert(QStringLiteral(
"windowState"), windowState);
846 void LayoutSaver::MainWindow::fromVariantMap(
const QVariantMap &map)
848 options = KDDockWidgets::MainWindowOptions(map.value(QStringLiteral(
"options")).toInt());
849 multiSplitterLayout.fromVariantMap(map.value(QStringLiteral(
"multiSplitterLayout")).toMap());
850 uniqueName = map.value(QStringLiteral(
"uniqueName")).toString();
851 geometry = Layouting::mapToRect(map.value(QStringLiteral(
"geometry")).toMap());
852 screenIndex = map.value(QStringLiteral(
"screenIndex")).toInt();
853 screenSize = Layouting::mapToSize(map.value(QStringLiteral(
"screenSize")).toMap());
854 isVisible = map.value(QStringLiteral(
"isVisible")).toBool();
859 const QString affinityName = map.value(QStringLiteral(
"affinityName")).toString();
865 dockWidgetsPerSideBar.clear();
867 const QVariantList dockWidgets = map.
value(QStringLiteral(
"sidebar-%1").arg(
int(loc))).toList();
868 if (!dockWidgets.isEmpty())
873 bool LayoutSaver::MultiSplitter::isValid()
const
875 if (layout.isEmpty())
886 bool LayoutSaver::MultiSplitter::hasSingleDockWidget()
const
888 return frames.size() == 1 && frames.cbegin()->hasSingleDockWidget();
891 LayoutSaver::DockWidget::Ptr LayoutSaver::MultiSplitter::singleDockWidget()
const
893 if (!hasSingleDockWidget())
896 return frames.cbegin()->singleDockWidget();
899 bool LayoutSaver::MultiSplitter::skipsRestore()
const
901 return std::all_of(frames.cbegin(), frames.cend(), [](
const LayoutSaver::Frame &frame) {
902 return frame.skipsRestore();
906 QVariantMap LayoutSaver::MultiSplitter::toVariantMap()
const
909 result.insert(QStringLiteral(
"layout"), layout);
912 for (
auto &frame : frames)
913 framesV.insert(frame.id, frame.toVariantMap());
915 result.insert(QStringLiteral(
"frames"), framesV);
919 void LayoutSaver::MultiSplitter::fromVariantMap(
const QVariantMap &map)
921 layout = map.value(QStringLiteral(
"layout")).toMap();
922 const QVariantMap framesV = map.value(QStringLiteral(
"frames")).toMap();
924 for (
const QVariant &frameV : framesV) {
925 LayoutSaver::Frame frame;
926 frame.fromVariantMap(frameV.toMap());
927 frames.insert(frame.id, frame);
931 void LayoutSaver::Position::scaleSizes(
const ScalingInfo &scalingInfo)
933 scalingInfo.applyFactorsTo( lastFloatingGeometry);
936 QVariantMap LayoutSaver::Position::toVariantMap()
const
939 map.insert(QStringLiteral(
"lastFloatingGeometry"), Layouting::rectToMap(lastFloatingGeometry));
940 map.insert(QStringLiteral(
"tabIndex"), tabIndex);
941 map.insert(QStringLiteral(
"wasFloating"), wasFloating);
942 map.insert(QStringLiteral(
"placeholders"), toVariantList<LayoutSaver::Placeholder>(placeholders));
947 void LayoutSaver::Position::fromVariantMap(
const QVariantMap &map)
949 lastFloatingGeometry = Layouting::mapToRect(map.value(QStringLiteral(
"lastFloatingGeometry")).toMap());
950 tabIndex = map.value(QStringLiteral(
"tabIndex")).toInt();
951 wasFloating = map.value(QStringLiteral(
"wasFloating")).toBool();
952 placeholders = fromVariantList<LayoutSaver::Placeholder>(map.value(QStringLiteral(
"placeholders")).toList());
955 QVariantMap LayoutSaver::ScreenInfo::toVariantMap()
const
958 map.insert(QStringLiteral(
"index"), index);
959 map.insert(QStringLiteral(
"geometry"), Layouting::rectToMap(geometry));
960 map.insert(QStringLiteral(
"name"), name);
961 map.insert(QStringLiteral(
"devicePixelRatio"), devicePixelRatio);
966 void LayoutSaver::ScreenInfo::fromVariantMap(
const QVariantMap &map)
968 index = map.value(QStringLiteral(
"index")).toInt();
969 geometry = Layouting::mapToRect(map.value(QStringLiteral(
"geometry")).toMap());
970 name = map.value(QStringLiteral(
"name")).toString();
971 devicePixelRatio = map.value(QStringLiteral(
"devicePixelRatio")).
toDouble();
974 QVariantMap LayoutSaver::Placeholder::toVariantMap()
const
977 map.insert(QStringLiteral(
"isFloatingWindow"), isFloatingWindow);
978 map.insert(QStringLiteral(
"itemIndex"), itemIndex);
980 if (isFloatingWindow)
981 map.insert(QStringLiteral(
"indexOfFloatingWindow"), indexOfFloatingWindow);
983 map.insert(QStringLiteral(
"mainWindowUniqueName"), mainWindowUniqueName);
988 void LayoutSaver::Placeholder::fromVariantMap(
const QVariantMap &map)
990 isFloatingWindow = map.value(QStringLiteral(
"isFloatingWindow")).toBool();
991 indexOfFloatingWindow = map.value(QStringLiteral(
"indexOfFloatingWindow"), -1).toInt();
992 itemIndex = map.value(QStringLiteral(
"itemIndex")).toInt();
993 mainWindowUniqueName = map.value(QStringLiteral(
"mainWindowUniqueName")).toString();
996 LayoutSaver::ScalingInfo::ScalingInfo(
const QString &mainWindowId,
QRect savedMainWindowGeo)
998 auto mainWindow = DockRegistry::self()->mainWindowByName(mainWindowId);
1000 qWarning() << Q_FUNC_INFO <<
"Failed to find main window with name" << mainWindowName;
1004 if (!savedMainWindowGeo.
isValid() || savedMainWindowGeo.
isNull()) {
1005 qWarning() << Q_FUNC_INFO <<
"Invalid saved main window geometry" << savedMainWindowGeo;
1009 if (!mainWindow->geometry().isValid() || mainWindow->geometry().isNull()) {
1010 qWarning() << Q_FUNC_INFO <<
"Invalid main window geometry" << mainWindow->geometry();
1014 this->mainWindowName = mainWindowId;
1015 this->savedMainWindowGeometry = savedMainWindowGeo;
1016 realMainWindowGeometry = mainWindow->window()->geometry();
1017 widthFactor = double(realMainWindowGeometry.width()) / savedMainWindowGeo.
width();
1018 heightFactor = double(realMainWindowGeometry.height()) / savedMainWindowGeo.
height();
1021 void LayoutSaver::ScalingInfo::translatePos(
QPoint &pt)
const
1023 const int deltaX = pt.
x() - savedMainWindowGeometry.x();
1024 const int deltaY = pt.
y() - savedMainWindowGeometry.y();
1026 const double newDeltaX = deltaX * widthFactor;
1027 const double newDeltaY = deltaY * heightFactor;
1029 pt.
setX(qCeil(savedMainWindowGeometry.x() + newDeltaX));
1030 pt.
setY(qCeil(savedMainWindowGeometry.y() + newDeltaY));
1033 void LayoutSaver::ScalingInfo::applyFactorsTo(
QPoint &pt)
const
1038 void LayoutSaver::ScalingInfo::applyFactorsTo(
QSize &sz)
const
1044 void LayoutSaver::ScalingInfo::applyFactorsTo(
QRect &rect)
const
1052 applyFactorsTo( size);
1053 applyFactorsTo( pos);
1059 LayoutSaver::Private::RAIIIsRestoring::RAIIIsRestoring()
1061 LayoutSaver::Private::s_restoreInProgress =
true;
1064 LayoutSaver::Private::RAIIIsRestoring::~RAIIIsRestoring()
1066 LayoutSaver::Private::s_restoreInProgress =
false;