File indexing completed on 2024-12-08 13:22:28

 /*
  *  Copyright 2016 Marco Martin <mart@kde.org>
  *
  *   This program is free software; you can redistribute it and/or modify
  *   it under the terms of the GNU Library General Public License as
  *   published by the Free Software Foundation; either version 2, or
  *   (at your option) any later version.
  *
  *   This program is distributed in the hope that it will be useful,
  *   but WITHOUT ANY WARRANTY; without even the implied warranty of
  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *   GNU General Public License for more details
  *
  *   You should have received a copy of the GNU Library General Public
  *   License along with this program; if not, write to the
  *   Free Software Foundation, Inc.,
  *   51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
  */
 
 #include "screenpool.h"
 
 // local
 #include <config-latte.h>
 
 // Qt
 #include <QDebug>
 #include <QFile>
 #include <QGuiApplication>
 #include <QScreen>
 
 // KDE
 #include <KLocalizedString>
 
 // X11
 #if HAVE_X11
     #include <QtX11Extras/QX11Info>
     #include <xcb/xcb.h>
     #include <xcb/randr.h>
     #include <xcb/xcb_event.h>
 #endif
 
 namespace Latte {
 
 ScreenPool::ScreenPool(KSharedConfig::Ptr config, QObject *parent)
     : QObject(parent),
       m_configGroup(KConfigGroup(config, QStringLiteral("ScreenConnectors")))
 {
     qApp->installNativeEventFilter(this);
 
     m_configSaveTimer.setSingleShot(true);
     connect(&m_configSaveTimer, &QTimer::timeout, this, [this]() {
         m_configGroup.sync();
     });
 }
 
 void ScreenPool::load()
 {
     m_primaryConnector = QString();
     m_connectorForId.clear();
     m_idForConnector.clear();
 
     QScreen *primary = qGuiApp->primaryScreen();
 
     if (primary) {
         m_primaryConnector = primary->name();
 
         if (!m_primaryConnector.isEmpty()) {
             //m_connectorForId[0] = m_primaryConnector;
             //m_idForConnector[m_primaryConnector] = 0;
         }
     }
 
     //restore the known ids to connector mappings
     for (const QString &key : m_configGroup.keyList()) {
         QString connector = m_configGroup.readEntry(key, QString());
         qDebug() << "connector :" << connector << " - " << key;
 
         if (!key.isEmpty() && !connector.isEmpty() &&
             !m_connectorForId.contains(key.toInt()) &&
             !m_idForConnector.contains(connector)) {
             m_connectorForId[key.toInt()] = connector;
             m_idForConnector[connector] = key.toInt();
             qDebug() << "Known Screen - " << connector << " - " << key.toInt();
         } else if (m_idForConnector.value(connector) != key.toInt()) {
             m_configGroup.deleteEntry(key);
         }
     }
 
     // if there are already connected unknown screens, map those
     // all needs to be populated as soon as possible, otherwise
     // containment->screen() will return an incorrect -1
     // at startup, if it' asked before corona::addOutput()
     // is performed, driving to the creation of a new containment
     for (QScreen *screen : qGuiApp->screens()) {
         if (!m_idForConnector.contains(screen->name())) {
             insertScreenMapping(firstAvailableId(), screen->name());
         }
     }
 }
 
 ScreenPool::~ScreenPool()
 {
     m_configGroup.sync();
 }
 
 
 QString ScreenPool::reportHtml(const QList<int> &assignedScreens) const
 {
     QString report;
 
     report += "<table cellspacing='8'>";
     report += "<tr><td align='center'><b>" + i18nc("screen id","ID") + "</b></td>" +
             "<td align='center'><b>" + i18nc("screen name", "Name") + "</b></td>" +
             "<td align='center'><b>" + i18nc("screen type", "Type") + "</b></td>" +
             "<td align='center'><b>" + i18n("Docks/Panels") + "</b></td></tr>";
 
     report += "<tr><td colspan='4'><hr></td></tr>";
 
     for(const QString &connector : m_connectorForId) {
         int scrId = id(connector);
         bool hasViews = assignedScreens.contains(scrId);
         bool primary = m_primaryConnector == connector;
         bool secondary = !primary && screenExists(scrId);
 
         report += "<tr>";
 
         //! ScreenId
         QString idStr = "[" + QString::number(scrId) + "]";
         if (primary || secondary) {
             idStr = "<b>" + idStr +"</b>";
         }
         report += "<td align='center'>" + idStr + "</td>";
 
         //! ScreenName and Primary flag
         QString connectorStr = connector;
         if (primary || secondary) {
             connectorStr = "<b>"+ connector + "</b>";
         }
         report += "<td align='center'>" + connectorStr + "</td>";
 
         //! ScreenType
         QString typeStr = "";
         if (primary) {
             typeStr = "<b><font color='green'>[" + i18nc("primary screen","Primary") + "]</font></b>";
         } else if (secondary) {
             typeStr = "<b>[" + i18nc("secondary screen","Secondary") + "]</b>";
         } else {
             typeStr = "<i>" + i18nc("inactive screen","inactive") + "</i>";
         }
 
         report += "<td align='center'>" + typeStr +"</td>";
 
         //! Screen has not assigned any docks/panels
         QString notAssignedStr = "";
         if (!hasViews) {
             notAssignedStr = "<font color='red'><i>[" + i18nc("it has not latte docks/panels", "none") + "]</i></font>";
         } else {
             notAssignedStr = " ✔ ";
         }
 
         report += "<td align='center'>" + notAssignedStr +"</td>";
 
         report += "</tr>";
     }
 
     report += "</table>";
 
     return report;
 }
 
 void ScreenPool::reload(QString path)
 {
     QFile rcfile(QString(path + "/lattedockrc"));
 
     if (rcfile.exists()) {
         qDebug() << "load screen connectors from ::: " << rcfile.fileName();
         KSharedConfigPtr newFile = KSharedConfig::openConfig(rcfile.fileName());
         m_configGroup = KConfigGroup(newFile, QStringLiteral("ScreenConnectors"));
         load();
     }
 
 
 
 }
 
 int ScreenPool::primaryScreenId() const
 {
     return id(qGuiApp->primaryScreen()->name());
 }
 
 QString ScreenPool::primaryConnector() const
 {
     return m_primaryConnector;
 }
 
 void ScreenPool::setPrimaryConnector(const QString &primary)
 {
     //the ":" check fixes the strange plasma/qt issues when changing layouts
     //there are case that the QScreen instead of the correct screen name
     //returns "0:0", this check prevents from breaking the screens database
     //from garbage ids
     if ((m_primaryConnector == primary) || primary.startsWith(":")) {
         return;
     }
 
     Q_ASSERT(m_idForConnector.contains(primary));
 
     /* int oldIdForPrimary = m_idForConnector.value(primary);
 
      m_idForConnector[primary] = 0;
      m_connectorForId[0] = primary;
      m_idForConnector[m_primaryConnector] = oldIdForPrimary;
      m_connectorForId[oldIdForPrimary] = m_primaryConnector;
      m_primaryConnector = primary;
     */
     save();
 }
 
 void ScreenPool::save()
 {
     QMap<int, QString>::const_iterator i;
 
     for (i = m_connectorForId.constBegin(); i != m_connectorForId.constEnd(); ++i) {
         m_configGroup.writeEntry(QString::number(i.key()), i.value());
     }
 
     //write to disck every 30 seconds at most
     m_configSaveTimer.start(30000);
 }
 
 void ScreenPool::insertScreenMapping(int id, const QString &connector)
 {
     //Q_ASSERT(!m_connectorForId.contains(id) || m_connectorForId.value(id) == connector);
     //Q_ASSERT(!m_idForConnector.contains(connector) || m_idForConnector.value(connector) == id);
 
     //the ":" check fixes the strange plasma/qt issues when changing layouts
     //there are case that the QScreen instead of the correct screen name
     //returns "0:0", this check prevents from breaking the screens database
     //from garbage ids
     if (connector.startsWith(":"))
         return;
 
     qDebug() << "add connector..." << connector;
 
     if (id == 0) {
         m_primaryConnector = connector;
     } else {
         m_connectorForId[id] = connector;
         m_idForConnector[connector] = id;
     }
 
     save();
 }
 
 int ScreenPool::id(const QString &connector) const
 {
     if (!m_idForConnector.contains(connector)) {
         return -1;
     }
 
     return m_idForConnector.value(connector);
 }
 
 QString ScreenPool::connector(int id) const
 {   
     Q_ASSERT(m_connectorForId.contains(id));
 
     return m_connectorForId.value(id);
 }
 
 int ScreenPool::firstAvailableId() const
 {
     //start counting from 10, first numbers will
     //be used for special cases.
     //e.g primaryScreen, id=0
     int i = 10;
 
     //find the first integer not stored in m_connectorForId
     //m_connectorForId is the only map, so the ids are sorted
     for (const int &existingId : m_connectorForId.keys()) {
         if (i != existingId) {
             return i;
         }
 
         ++i;
     }
 
     return i;
 }
 
 QList <int> ScreenPool::knownIds() const
 {
     return m_connectorForId.keys();
 }
 
 bool ScreenPool::hasId(int id) const
 {
     return ((id!=-1) && m_connectorForId.keys().contains(id));
 }
 
 bool ScreenPool::screenExists(int id) const
 {
     if (id != -1 && knownIds().contains(id)) {
         QString scrName = connector(id);
 
         for (const auto scr : qGuiApp->screens()) {
             if (scr->name() == scrName) {
                 return true;
             }
         }
     }
 
     return false;
 }
 
 QScreen *ScreenPool::screenForId(int id)
 {
     const auto screens = qGuiApp->screens();
     QScreen *screen{qGuiApp->primaryScreen()};
 
     if (id != -1 && knownIds().contains(id)) {
         QString scrName = connector(id);
 
         for (const auto scr : screens) {
             if (scr->name() == scrName) {
                 return scr;
             }
         }
     }
 
     return screen;
 }
 
 
 bool ScreenPool::nativeEventFilter(const QByteArray &eventType, void *message, long int *result)
 {
     Q_UNUSED(result);
 #if HAVE_X11
 
     // a particular edge case: when we switch the only enabled screen
     // we don't have any signal about it, the primary screen changes but we have the same old QScreen* getting recycled
     // see https://bugs.kde.org/show_bug.cgi?id=373880
     // if this slot will be invoked many times, their//second time on will do nothing as name and primaryconnector will be the same by then
     if (eventType != "xcb_generic_event_t") {
         return false;
     }
 
     xcb_generic_event_t *ev = static_cast<xcb_generic_event_t *>(message);
 
     const auto responseType = XCB_EVENT_RESPONSE_TYPE(ev);
 
     const xcb_query_extension_reply_t *reply = xcb_get_extension_data(QX11Info::connection(), &xcb_randr_id);
 
     if (responseType == reply->first_event + XCB_RANDR_SCREEN_CHANGE_NOTIFY) {
         if (qGuiApp->primaryScreen()->name() != primaryConnector()) {
             //new screen?
             if (id(qGuiApp->primaryScreen()->name()) < 0) {
                 insertScreenMapping(firstAvailableId(), qGuiApp->primaryScreen()->name());
             }
 
             //switch the primary screen in the pool
             setPrimaryConnector(qGuiApp->primaryScreen()->name());
 
             emit primaryPoolChanged();
         }
     }
 
 #endif
     return false;
 }
 
 }
 
 #include "moc_screenpool.cpp"