From d49056b3eccf118bbd678a5bdc0ff037dd34eb9e Mon Sep 17 00:00:00 2001 From: Ralph Martin Fischer Date: Wed, 4 Nov 2026 21:11:26 +0100 Subject: [PATCH] =?UTF-8?q?Schwebende=20Panels=20als=20Geschwister=20des?= =?UTF-8?q?=20obersten=20Fensters;=20=E2=9C=95=20an=20jedem=20Panel?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Zwei Betreiberwuensche vom 2026-11-04, mit den Panels als eigene Fenster in Longpath: "nicht alle offenen fenster lassen sich durch anklicken in den vordergrund schieben." -- Die Panels hingen am (verborgenen) Logbuch-Fenster, Longpaths eigene am Hauptfenster: zwei Geschwisterkreise, und ein Klick hebt nur innerhalb des eigenen. PanelContainerWidget::setFloating klettert jetzt zum OBERSTEN Fenster; als Geschwister eines Fensters gilt die Klickreihenfolge fuer alle. Eigenstaendig aendert sich nichts (kein Elternfenster). "alle fenster muessen sich mit X schliessen lassen!" -- Neben dem ↙ steht im rahmenlosen Fenster ein ✕ (PanelHeaderBar:: setCloseAffordanceEnabled, chromlos als Knopf neben dem Schloss): zurueck in die Flaeche UND ausgeblendet (schliessenUndAusblenden, Signal versteckt), wie ein weggenommener Haken in Fenster > Panels. MainWindow::setzePanelSichtbar/istPanelSichtbar nach aussen; der Haken (setzePanelSchwebend) holt ein ausgeblendetes Panel sichtbar hervor, und das ✕ sichert das Profil. test_einbettung::geschwisterDesOberstenFenstersUndDasKreuz. Co-Authored-By: Claude Fable 5.1 --- src/ui/MainWindow.cpp | 26 +++++++++++ src/ui/MainWindow.h | 4 ++ src/ui/PanelContainerWidget.cpp | 53 +++++++++++++++++++++-- src/ui/PanelContainerWidget.h | 6 +++ src/ui/PanelHeaderBar.cpp | 16 +++++++ src/ui/PanelHeaderBar.h | 8 ++++ tests/test_einbettung.cpp | 77 +++++++++++++++++++++++++++++++++ 7 files changed, 186 insertions(+), 4 deletions(-) diff --git a/src/ui/MainWindow.cpp b/src/ui/MainWindow.cpp index 346d2be..11d5116 100644 --- a/src/ui/MainWindow.cpp +++ b/src/ui/MainWindow.cpp @@ -3044,6 +3044,24 @@ QList MainWindow::panelEintraege() return eintraege; } +void MainWindow::setzePanelSichtbar(const QString& id, bool sichtbar) +{ + if (!m_panelLayoutManager) { return; } + PanelContainerWidget* panel = m_panelLayoutManager->panel(id); + if (!panel) { return; } + if (panel->isVisible() == sichtbar && !(sichtbar && panel->isFloating())) { return; } + panel->setVisible(sichtbar); + if (sichtbar) { m_panelLayoutManager->revealPanel(id); } + if (m_layoutProfileManager) { m_layoutProfileManager->saveActiveProfileState(); } +} + +bool MainWindow::istPanelSichtbar(const QString& id) const +{ + if (!m_panelLayoutManager) { return false; } + const PanelContainerWidget* panel = m_panelLayoutManager->panel(id); + return panel && panel->isVisible(); +} + bool MainWindow::istPanelSchwebend(const QString& id) const { return m_panelLayoutManager && m_panelLayoutManager->isPanelFloating(id); @@ -3058,6 +3076,14 @@ void MainWindow::setzePanelSchwebend(const QString& id, bool schwebend) // Aus dem Seitenbereich holen: dort ist es eine Seite, kein // Fenster, und setPanelFloating() faende es nicht in der Flaeche. takePanelOutOfSideArea(id); + // Ein ausgeblendetes Panel (✕) kommt ueber den Haken wieder: + // erst sichtbar, dann schwebend. + if (!panel->isVisible()) { panel->setVisible(true); } + // Das ✕ am schwebenden Panel sichert das Profil -- einmal + // verdrahtet, so oft es will. + connect(panel, &PanelContainerWidget::versteckt, this, [this](const QString&) { + if (m_layoutProfileManager) { m_layoutProfileManager->saveActiveProfileState(); } + }, Qt::UniqueConnection); m_panelLayoutManager->setPanelFloating(id, true); // Ein nie gezeigtes Hauptfenster hat keine ausgelegte Flaeche: // das Panel kaeme mit der Groesse 0x0 daher. Dann die Groesse diff --git a/src/ui/MainWindow.h b/src/ui/MainWindow.h index 3944d0a..721e776 100644 --- a/src/ui/MainWindow.h +++ b/src/ui/MainWindow.h @@ -123,6 +123,10 @@ class MainWindow : public QMainWindow { void setzePanelSchwebend(const QString& id, bool schwebend); // Das Panel als Fenster (oder nullptr, wenn es die Kennung nicht gibt). QWidget* panelFenster(const QString& id) const; + // Ein- oder ausblenden wie ueber Fenster > Panels (und das Profil + // sichern). Fuer das ✕ in Longpath und den Haken dort. + void setzePanelSichtbar(const QString& id, bool sichtbar); + bool istPanelSichtbar(const QString& id) const; class SideAreaWidget* sideAreaForTest() const { return m_sideArea; } void applyWaterfallVisibilityForTest() { applyWaterfallVisibility(); } void putPanelIntoSideAreaForTest(const QString& id); diff --git a/src/ui/PanelContainerWidget.cpp b/src/ui/PanelContainerWidget.cpp index 6b7f03c..a8dc15c 100644 --- a/src/ui/PanelContainerWidget.cpp +++ b/src/ui/PanelContainerWidget.cpp @@ -59,6 +59,7 @@ PanelContainerWidget::PanelContainerWidget(const QString& id, const QString& tit m_headerBar->installEventFilter(this); connect(m_headerBar, &PanelHeaderBar::lockToggled, this, &PanelContainerWidget::setLocked); connect(m_headerBar, &PanelHeaderBar::dockRequested, this, [this]() { setFloating(false); }); + connect(m_headerBar, &PanelHeaderBar::closeRequested, this, [this]() { schliessenUndAusblenden(); }); layout->addWidget(m_headerBar); layout->addWidget(content, 1); } @@ -83,10 +84,22 @@ bool s_rahmenlosSchwebend = false; void PanelContainerWidget::setzeRahmenlosSchwebend(bool an) { s_rahmenlosSchwebend = an; } bool PanelContainerWidget::rahmenlosSchwebend() { return s_rahmenlosSchwebend; } +void PanelContainerWidget::schliessenUndAusblenden() +{ + // Betreiber 2026-11-04: "alle fenster muessen sich mit X schliessen + // lassen!" Schliessen = zurueck in die Flaeche und dort ausgeblendet, + // wie ein weggenommener Haken in Fenster > Panels. Wieder da ist es + // ueber den Haken (im Logbuch oder in Longpath). + setFloating(false); + setVisible(false); + emit versteckt(m_id); +} + void PanelContainerWidget::zeigeRueckwegAffordanz(bool an) { if (m_headerBar) { m_headerBar->setDockAffordanceEnabled(an); + m_headerBar->setCloseAffordanceEnabled(an); } if (m_contentHasOwnChrome) { if (an && !m_overlayDockButton) { @@ -100,10 +113,24 @@ void PanelContainerWidget::zeigeRueckwegAffordanz(bool an) setFloating(false); }); } + if (an && !m_overlayCloseButton) { + m_overlayCloseButton = new QPushButton(QString::fromUtf8("✕"), this); + m_overlayCloseButton->setObjectName(QStringLiteral("panelOverlayCloseButton")); + m_overlayCloseButton->setFixedSize(24, 18); + m_overlayCloseButton->setCursor(Qt::PointingHandCursor); + m_overlayCloseButton->setToolTip(QStringLiteral("Schließen (zurück ins Logbuch, ausgeblendet)")); + m_overlayCloseButton->setStyleSheet(Style::iconButtonStyle()); + connect(m_overlayCloseButton, &QPushButton::clicked, this, [this]() { + schliessenUndAusblenden(); + }); + } if (m_overlayDockButton) { m_overlayDockButton->setVisible(an); - layoutOverlayWidgets(); } + if (m_overlayCloseButton) { + m_overlayCloseButton->setVisible(an); + } + layoutOverlayWidgets(); } } @@ -199,6 +226,18 @@ void PanelContainerWidget::setFloating(bool floating) // haengt es daran -- es folgt beim Minimieren, beim Wechsel // des Schirms und beim Schliessen. QWidget* hauptfenster = m_dockTarget ? m_dockTarget->window() : window(); + // Das OBERSTE Fenster, nicht das naechste (2026-11-04): in Longpath + // ist dieses Hauptfenster selbst ein Werkzeugfenster am + // Longpath-Hauptfenster. Haengt ein Panel am Logbuch und Longpaths + // eigene Panels am Hauptfenster, sind es zwei Geschwisterkreise, + // und ein Klick hebt nur innerhalb des eigenen Kreises -- Betreiber: + // "nicht alle offenen fenster lassen sich durch anklicken in den + // vordergrund schieben." Als Geschwister EINES Fensters gilt die + // Klickreihenfolge fuer alle. Eigenstaendig aendert sich nichts + // (das Hauptfenster hat dann kein Elternfenster). + while (hauptfenster && hauptfenster->parentWidget()) { + hauptfenster = hauptfenster->parentWidget()->window(); + } if (s_rahmenlosSchwebend) { // Ohne Systemrahmen, eckig, mit eigenem Rueckweg (↙) -- siehe // setzeRahmenlosSchwebend(). WA_MacAlwaysShowToolWindow: ein @@ -270,9 +309,15 @@ void PanelContainerWidget::layoutOverlayWidgets() m_overlayLockButton->raise(); } if (m_overlayDockButton && m_overlayLockButton) { - // Rechts vom Schloss, wie in der Kopfzeile. - m_overlayDockButton->move(width() - m_overlayLockButton->width() - 6 - - m_overlayDockButton->width() - 4, 6); + // Links vom Schloss: ↙ dann ✕ ganz rechts -- wie in der Kopfzeile. + int x = width() - m_overlayLockButton->width() - 6; + if (m_overlayCloseButton && m_overlayCloseButton->isVisible()) { + x -= m_overlayCloseButton->width() + 4; + m_overlayCloseButton->move(x, 6); + m_overlayCloseButton->raise(); + } + x -= m_overlayDockButton->width() + 4; + m_overlayDockButton->move(x, 6); m_overlayDockButton->raise(); } } diff --git a/src/ui/PanelContainerWidget.h b/src/ui/PanelContainerWidget.h index bb961ae..a814a4e 100644 --- a/src/ui/PanelContainerWidget.h +++ b/src/ui/PanelContainerWidget.h @@ -171,6 +171,10 @@ class PanelContainerWidget : public QWidget { // z-order on this signal. The container already raise()s itself // immediately regardless of whether anything is listening. void raiseRequested(const QString& id); + // ✕ am schwebenden Panel (rahmenlos, in Longpath): das Panel ist + // zurueckgedockt UND ausgeblendet. Wer das Profil fuehrt, sichert + // daraufhin (MainWindow). + void versteckt(const QString& id); protected: void resizeEvent(QResizeEvent* event) override; @@ -208,6 +212,8 @@ class PanelContainerWidget : public QWidget { // Header mode only. PanelHeaderBar* m_headerBar = nullptr; QPushButton* m_overlayDockButton = nullptr; // ↙ im rahmenlosen Fenster, chromlos + QPushButton* m_overlayCloseButton = nullptr; // ✕ ebenso + void schliessenUndAusblenden(); // Chromeless mode only -- a small overlay lock badge raised above // `content`, since there is no PanelHeaderBar to host one. diff --git a/src/ui/PanelHeaderBar.cpp b/src/ui/PanelHeaderBar.cpp index c4d9ea8..08450dd 100644 --- a/src/ui/PanelHeaderBar.cpp +++ b/src/ui/PanelHeaderBar.cpp @@ -27,6 +27,7 @@ PanelHeaderBar::PanelHeaderBar(const QString& title, QWidget* parent) , m_lockButton(new QPushButton(this)) , m_optionsButton(new QPushButton(QString::fromUtf8("⚙"), this)) , m_dockButton(new QPushButton(QString::fromUtf8("↙"), this)) + , m_closeButton(new QPushButton(QString::fromUtf8("✕"), this)) { setFixedHeight(kHeaderHeight); @@ -81,6 +82,21 @@ PanelHeaderBar::PanelHeaderBar(const QString& title, QWidget* parent) m_dockButton->setVisible(false); layout->addWidget(m_dockButton); connect(m_dockButton, &QPushButton::clicked, this, &PanelHeaderBar::dockRequested); + + // ✕ rechts vom ↙ -- dieselbe Reihenfolge wie an Longpaths Fenstern. + m_closeButton->setObjectName(QStringLiteral("panelHeaderCloseButton")); + m_closeButton->setFixedSize(kOptionsButtonW, kOptionsButtonH); + m_closeButton->setCursor(Qt::PointingHandCursor); + m_closeButton->setToolTip(QStringLiteral("Schließen (zurück ins Logbuch, ausgeblendet)")); + m_closeButton->setStyleSheet(Style::iconButtonStyle()); + m_closeButton->setVisible(false); + layout->addWidget(m_closeButton); + connect(m_closeButton, &QPushButton::clicked, this, &PanelHeaderBar::closeRequested); +} + +void PanelHeaderBar::setCloseAffordanceEnabled(bool enabled) +{ + m_closeButton->setVisible(enabled); } void PanelHeaderBar::setDockAffordanceEnabled(bool enabled) diff --git a/src/ui/PanelHeaderBar.h b/src/ui/PanelHeaderBar.h index 5d8a307..d7785b5 100644 --- a/src/ui/PanelHeaderBar.h +++ b/src/ui/PanelHeaderBar.h @@ -84,6 +84,11 @@ class PanelHeaderBar : public QWidget { // war bisher der Rueckweg (PanelContainerWidget::closeEvent). Das // Zeichen ist dasselbe wie an Longpaths eigenen Fenstern. void setDockAffordanceEnabled(bool enabled); + // ✕ ganz rechts, opt-in wie ↙ (2026-11-04, Betreiber: "alle fenster + // muessen sich mit X schliessen lassen!"). Schliessen heisst fuer ein + // Panel: zurueck ins Logbuch UND ausgeblendet -- wie ein Haken im + // Menue Fenster > Panels, der weggenommen wird. + void setCloseAffordanceEnabled(bool enabled); signals: // Emitted only when the operator actually clicks the lock button -- @@ -100,6 +105,8 @@ class PanelHeaderBar : public QWidget { // Klick auf ↙ -- der Besitzer dockt das Panel zurueck. void dockRequested(); + // Klick auf ✕. + void closeRequested(); protected: void paintEvent(QPaintEvent* event) override; @@ -112,6 +119,7 @@ class PanelHeaderBar : public QWidget { QPushButton* m_lockButton; QPushButton* m_optionsButton; QPushButton* m_dockButton; + QPushButton* m_closeButton; bool m_locked = false; }; diff --git a/tests/test_einbettung.cpp b/tests/test_einbettung.cpp index 3c8704d..00010ab 100644 --- a/tests/test_einbettung.cpp +++ b/tests/test_einbettung.cpp @@ -17,6 +17,7 @@ #include #include +#include #include #include @@ -39,6 +40,7 @@ private slots: void fensterUndControllerEntstehenImFremdenProzess(); void panelsLassenSichVonAussenAbloesen(); void rahmenlosSchwebendIstEckigMitRueckweg(); + void geschwisterDesOberstenFenstersUndDasKreuz(); }; void TestEinbettung::dasDatenverzeichnisHaengtNichtAmProzessnamen() @@ -225,5 +227,80 @@ void TestEinbettung::rahmenlosSchwebendIstEckigMitRueckweg() PanelContainerWidget::setzeRahmenlosSchwebend(false); } +// Betreiber 2026-11-04: "nicht alle offenen fenster lassen sich durch +// anklicken in den vordergrund schieben" -- und: "alle fenster muessen +// sich mit X schliessen lassen!" Haengt dieses Hauptfenster selbst an +// einem Elternfenster (Longpath), wird ein schwebendes Panel ein +// Geschwister am OBERSTEN Fenster, nicht ein Kind des Logbuchs. Und das +// ✕ dockt es zurueck und blendet es aus; setzePanelSchwebend holt es +// wieder sichtbar hervor. +void TestEinbettung::geschwisterDesOberstenFenstersUndDasKreuz() +{ + QTemporaryDir ordner; + QVERIFY(ordner.isValid()); + AppController controller; + QString fehler; + QVERIFY2(controller.openDatabase(datenbankPfad(ordner.path()), &fehler), + qPrintable(fehler)); + ContestSettings s = controller.settings(); + s.ownCallsign = QStringLiteral("OE5SOS"); + s.ownGrid = QStringLiteral("JN67UT"); + s.rigctldHost.clear(); + s.rotor1Enabled = false; + s.rotor2Enabled = false; + s.esmEnabled = false; + controller.setSettings(s); + + QWidget oberstes; + oberstes.resize(800, 600); + oberstes.show(); + QVERIFY(QTest::qWaitForWindowExposed(&oberstes, 10000)); + auto* fenster = new MainWindow(controller, &oberstes); + fenster->setWindowFlags((fenster->windowFlags() & ~Qt::WindowType_Mask) | Qt::Tool); + PanelContainerWidget::setzeRahmenlosSchwebend(true); + + fenster->setzePanelSchwebend(QStringLiteral("chat"), true); + QWidget* chat = fenster->panelFenster(QStringLiteral("chat")); + QVERIFY(chat && chat->isWindow()); + QCOMPARE(chat->parentWidget(), static_cast(&oberstes)); + + QPushButton* kreuz = nullptr; + for (QPushButton* b : chat->findChildren()) { + if (b->objectName() == QStringLiteral("panelHeaderCloseButton")) { kreuz = b; } + } + QVERIFY2(kreuz && kreuz->isVisible(), "das ✕ muss in der Kopfzeile stehen"); + QSignalSpy versteckt(fenster->panelFenster(QStringLiteral("chat")) ? qobject_cast(chat) : nullptr, + &PanelContainerWidget::versteckt); + kreuz->click(); + QVERIFY(!fenster->istPanelSchwebend(QStringLiteral("chat"))); + QVERIFY2(!chat->isVisible(), "nach ✕ ist das Panel ausgeblendet"); + QVERIFY(!fenster->istPanelSichtbar(QStringLiteral("chat"))); + QCOMPARE(versteckt.count(), 1); + + // Der Haken holt es wieder: sichtbar und schwebend. + fenster->setzePanelSchwebend(QStringLiteral("chat"), true); + QVERIFY(chat->isWindow()); + QVERIFY(fenster->istPanelSichtbar(QStringLiteral("chat"))); + + // Chromloses Panel (Karte): ✕ als Knopf neben dem Schloss. + fenster->setzePanelSchwebend(QStringLiteral("map"), true); + QWidget* karte = fenster->panelFenster(QStringLiteral("map")); + // Kopfzeile oder (chromlos) Overlay -- je nachdem, wie die Karte + // gerade gebaut ist; beide tragen das ✕. + QPushButton* kartenKreuz = nullptr; + for (QPushButton* b : karte->findChildren()) { + if (b->objectName() == QStringLiteral("panelOverlayCloseButton") + || b->objectName() == QStringLiteral("panelHeaderCloseButton")) { kartenKreuz = b; } + } + QVERIFY2(kartenKreuz && kartenKreuz->isVisible(), "auch die Karte braucht ✕"); + kartenKreuz->click(); + QVERIFY(!karte->isWindow()); + QVERIFY(!karte->isVisible()); + + PanelContainerWidget::setzeRahmenlosSchwebend(false); + fenster->setzePanelSchwebend(QStringLiteral("chat"), false); + delete fenster; +} + QTEST_MAIN(TestEinbettung) #include "test_einbettung.moc"