🕐 🗳️ 🕛 Q3 पर i3 विंडो मैनेजर के लिए एक पैनल लिखना 🤛🏼 👩‍👩‍👧‍👦 👾

i3 मेरी पसंदीदा टाइल विंडो मैनेजर है। लेकिन हाल ही में, अपने डेस्कटॉप की एक और पुनरावृत्ति होने के बाद, मुझे एक अप्रिय बात सामने आई: मेरे मूल पैनल की कार्यक्षमता मेरी सभी कल्पनाओं को साकार करने के लिए पर्याप्त नहीं है। विशेष रूप से, वह नहीं जानती कि सीमाओं का रंग कैसे बदलना या बदलना है। और लिनक्सॉइड क्या करता है जब सॉफ्टवेयर इसे सूट नहीं करता है और कोई विकल्प नहीं हैं (और कोई नहीं हैं)? यह सही है, मौजूदा को पैच करें, या अपना खुद का लिखें। मुझे xcb से निपटने की बिल्कुल इच्छा नहीं है, जिस पर मानक पैनल लिखा है, इसलिए मैं दूसरे रास्ते पर चला गया। C ++ को भाषा के रूप में चुना गया था। फ्रेमवर्क के बारे में केओ से पूछें

प्रस्तावना

सामान्य रूप से एक पैनल क्या है? इस विषय पर विकिपीडिया हमें बताता है:
“टास्कबार (अंग्रेजी टास्कबार) - एक आवेदन जो अन्य कार्यक्रमों को लॉन्च करने या पहले से चल रहे प्रबंधन के लिए उपयोग किया जाता है, और एक टूलबार है। विशेष रूप से अनुप्रयोग विंडो प्रबंधित करने के लिए उपयोग किया जाता है। "
लेकिन खिड़की के टाइल प्रबंधकों में, चीजें इतनी सरल नहीं हैं। उनमें खिड़कियां एक-दूसरे को ओवरलैप नहीं करती हैं। प्रबंधक प्रत्येक विंडो को उसके स्थान (टाइल) को आवंटित करता है, जिस पर यह खिड़की फैली हुई है। एक उदाहरण के लिए:

आप देखते हैं? सभी खिड़कियां दृष्टि में हैं। तो ऐसे प्रबंधकों में टास्कबार की आवश्यकता का प्रश्न अपने आप ही गायब हो जाता है। लेकिन एक स्क्रीन पर आप कई एप्लिकेशन फिट नहीं कर सकते। क्या करें? और यहाँ कई डेस्कटॉप की अवधारणा आती है। यह सुविधाजनक है! हर मिनट खिड़कियों के फोकस, उनके आकार और स्थिति को बदलने की आवश्यकता नहीं है। मैंने पहले डेस्कटॉप पर स्विच किया - यहां आपके लिए विकास अनुप्रयोगों का एक सेट है, दूसरे पर स्विच किया गया है - इसके आगे फ़ाइल प्रबंधक और खिलाड़ी को रखें। और इसी तरह। सैद्धांतिक रूप से, अनंत रूप से कई डेस्कटॉप हो सकते हैं, लेकिन एक समय में 10 से अधिक का उपयोग करना काफी समस्याग्रस्त हो सकता है।
तो, हमारा पैनल खिड़कियों को नियंत्रित नहीं करेगा, लेकिन डेस्कटॉप। इसलिए, मैं वाक्यांश "टास्कबार" के बजाय केवल "पैनल" शब्द का उपयोग करना पसंद करता हूं।

विकास शुरू करें

चूंकि दोस्ती मुस्कुराहट के साथ शुरू होती है, इसलिए अधिकांश क्यूटी एप्लिकेशन एक विजेट के साथ शुरू होते हैं। इसलिए हम परंपरा से नहीं हटेंगे और सबसे पहले हम अपने भविष्य के पैनल के लिए एक विजेट लिखेंगे। अभी के लिए, यह QWidget से विरासत में मिला एक वर्ग होगा। कंस्ट्रक्टर और विध्वंसक के साथ।

class Q3Panel : public QWidget { Q_OBJECT public: Q3Panel(QWidget *parent = 0); ~Q3Panel(); };

यदि आप अब इस विजेट को प्रदर्शित करते हैं, तो आपको दर्द से परिचित # D4D0C8 रंग में एक खाली विंडो दिखाई देगी। इसे एक पैनल में बदलने के लिए, हमें एक छोटे से जादू की जरूरत है और एक झंडे को बदलना होगा।

 setAttribute(Qt::WA_X11NetWmWindowTypeDock, true);

बस इसे हमारे विजेट कंस्ट्रक्टर में जोड़ें। इस प्रकार, आपने हमारी विंडो _NET_WM_WINDOW_TYPE X11 की संपत्ति को _NET_WM_WINDOW_TYPE_DOCK मान पर सेट किया है। अब यह सिर्फ एक खिड़की नहीं है, बल्कि एक डॉक है! आइए देखें:

यहाँ यह है, मेरे सपनों का पैनल, भारी! बहुत बड़ा, वास्तव में। आकार और स्थिति पर नियंत्रण हमें चोट नहीं पहुंचाएगा।

 void Q3Panel::setup(int height) { QRect screen = QApplication::desktop()->screenGeometry(); resize(screen.width(), height); int x, y; x = screen.left(); y = position() == top ? screen.top() : screen.bottom(); move(x, y); }

इस पद्धति में, चर स्क्रीन में, हमें तथाकथित रूट विंडो की ज्यामिति मिलती है। आकार () विधि को कॉल करने से हमारे पैनल की चौड़ाई स्क्रीन की चौड़ाई के बराबर हो जाती है, और पारित पैरामीटर के बराबर ऊँचाई हो जाती है। चर x में हम अपनी स्क्रीन के बाएं समन्वय को लिखते हैं, और y में - स्थिति के आधार पर ऊपर या नीचे। फिर हम अपने पैनल को निर्देशांक (x, y) के साथ ले जाते हैं। स्थिति (), जैसा कि आप शायद पहले ही अनुमान लगा चुके हैं, छिपी हुई संपत्ति के साथ काम करने के दो तरीकों में से एक है:

 public: Position position() { return _position; }; void setPosition(Position position) { _position = position; }; private: Position _position;

अब हम अपने पैनल के आकार और स्थिति को नियंत्रित कर सकते हैं। यह अगले चरण पर आगे बढ़ने का समय है।

I3 के साथ चैटिंग

तो हम सबसे दिलचस्प भाग के लिए मिला। हमारे विंडो मैनेजर को प्रबंधित करने के लिए, आपको किसी तरह उसके साथ संवाद करने की आवश्यकता है। सौभाग्य से, बॉक्स से बाहर i3 यूनिक्स सॉकेट के रूप में इस तरह के एक आईपीसी विधि का समर्थन करता है। और इससे भी अधिक सौभाग्य से, Qt के पास उनके साथ काम करने के लिए एक बहुत ही सुविधाजनक वर्ग है - QLocalSocket।
लेकिन पहले, प्रोटोकॉल का एक संक्षिप्त विवरण। संदेश इस प्रकार है:

< > < > < > <>

अब, पहले चीजें पहले। जादुई स्ट्रिंग "i3-ipc" है। इसका एकमात्र उद्देश्य प्रोटोकॉल का संस्करण नियंत्रण है। इसके बाद एक 32-बिट नंबर होता है जिसमें संदेश का आकार संग्रहीत होता है। फिर उसी 32-बिट प्रकार का संदेश, और फिर संदेश स्वयं। संदेश प्रकार निम्नलिखित मान ले सकता है:

COMMAND (0) - संदेश में एक कमांड है
GET_WORKSPACES (1) - डेस्कटॉप की एक सूची प्राप्त करें
SUBSCRIBE (2) - एक विशिष्ट घटना के लिए सदस्यता लें
GET_OUTPUTS (3) - आउटपुट डिवाइस की एक सूची प्राप्त करें
GET_TREE (4) - सभी डेस्कटॉप पर सभी विंडो की एक सूची प्राप्त करें
GET_MARKS (5) - कंटेनर पहचानकर्ताओं की एक सूची प्राप्त करें
GET_BAR_CONFIG (6) - i3 कॉन्फ़िगरेशन से पैनल कॉन्फ़िगरेशन प्राप्त करें

इस सभी कार्यक्षमता का उपयोग करके, आप सुविधाओं के एक समूह के साथ एक पैनल बना सकते हैं, लेकिन इस लेख के भाग के रूप में हम डेस्कटॉप को प्रदर्शित करने और स्विच करने के लिए खुद को सीमित करेंगे। इसके लिए हमें 3 प्रकार के संदेशों की आवश्यकता है: COMMAND, GET_WORKSPACES और SUBSCRIBE। अब प्रत्येक के बारे में अधिक। अरे हाँ, मैं लगभग भूल गया था। I3 को प्राप्त और भेजने वाले डेटा का प्रारूप json है।

टिप्पणी : मैं सभी संभावित आदेशों का वर्णन नहीं करूंगा - उनमें से बहुत सारे हैं। डेस्कटॉप को स्विच करने के लिए, हमें केवल एक की आवश्यकता है: "कार्यक्षेत्र संख्या X", जहां एक्स डेस्कटॉप की संख्या है। कमांड की प्रतिक्रिया एक साहचर्य सरणी है जिसमें केवल एक संपत्ति है - "सफलता", जो सही या गलत हो सकती है। उत्तर उदाहरण:

 { "success": true }

GET_WORKSPACES : संदेश निकाय रिक्त है, उत्तर डेस्कटॉप की एक सूची है, जिनमें से प्रत्येक में निम्नलिखित शामिल हैं:

num (पूर्णांक) - तार्किक डेस्कटॉप संख्या
name (string) - डेस्कटॉप का नाम UTF-8 एन्कोडिंग में
दृश्यमान (बूलियन) - क्या डेस्कटॉप प्रदर्शित होता है। कई आउटपुट डिवाइस के मामले में, एक साथ कई डेस्कटॉप प्रदर्शित किए जा सकते हैं।
फोकस्ड (बूलियन) - क्या डेस्कटॉप फोकस में है। एक ही समय में केवल एक ही डेस्कटॉप फोकस में हो सकता है।
अत्यावश्यक (बूलियन) - क्या डेस्कटॉप पर एक विंडो है जिसे उपयोगकर्ता का ध्यान देने की आवश्यकता है (यहां मैं गलत हो सकता हूं, लेकिन मैंने इसे इस तरह से समझा)
rect (नक्शा) - x और y निर्देशांक, चौड़ाई और ऊंचाई वाले डेस्कटॉप ज्यामिति
आउटपुट (स्ट्रिंग) - आउटपुट डिवाइस जिस पर डेस्कटॉप प्रदर्शित होता है

उत्तर उदाहरण:

 [ { "num": 0, "name": "1", "visible": true, "focused": true, "urgent": false, "rect": { "x": 0, "y": 0, "width": 1280, "height": 800 }, "output": "LVDS1" }, { "num": 1, "name": "2", "visible": false, "focused": false, "urgent": false, "rect": { "x": 0, "y": 0, "width": 1280, "height": 800 }, "output": "LVDS1" } ]

SUBSCRIBE : i3 आपको घटनाओं की सदस्यता लेने की अनुमति देता है। कुल 2 प्रकार के कार्यक्रम हैं:

कार्यक्षेत्र (0) - डेस्कटॉप संबंधित घटनाएँ। शरीर में केवल एक गुण होता है - "परिवर्तन", जो मान ले सकता है:
- फोकस - जब फ़ोकस दूसरे डेस्कटॉप पर स्विच करता है
- init - नया डेस्कटॉप बनाते समय
- खाली - खाली डेस्कटॉप हटाने पर
आउटपुट (1) - आउटपुट डिवाइस से जुड़ी घटनाएं।

ईवेंट संदेश पूरी तरह से मानक संदेश के समान है, एकमात्र अंतर यह है कि संदेश प्रकार का सबसे महत्वपूर्ण बिट 1 पर सेट है। इसलिए, दो प्रकार की घटनाओं में, हम केवल पहले में रुचि रखते हैं। इसका शरीर एक स्ट्रिंग गुण "परिवर्तित" के साथ एक सहयोगी सरणी है, जो "फोकस", "init", "खाली" और "तत्काल" मान ले सकता है। उत्तर उदाहरण:

 { "change": "focus" }

प्रोटोकॉल के ज्ञान के साथ सशस्त्र, आप हमारे ग्राहक को लागू करना शुरू कर सकते हैं। हम 2 सॉकेट का उपयोग करेंगे: एक को घटनाओं की सदस्यता दी जाएगी, दूसरे की मदद से हम कमांड भेजेंगे और डेस्कटॉप की एक सूची प्राप्त करेंगे। सामान्य एल्गोरिथ्म इस प्रकार है:

संयुक्त
डेस्कटॉप की सूची को अद्यतन करना
कार्यक्षेत्र की घटनाओं की सदस्यता लें
की प्रतीक्षा कर रहा है
घटना के आने पर, हम डेस्कटॉप की सूची को अपडेट करते हैं
गोटो ४

आपको याद दिला दूं कि यूनिक्स सॉकेट के लिए पहचानकर्ता फाइल सिस्टम में एक फाइल है। आप इसका नाम “I3_SOCKET_PATH” रूट विंडो प्रॉपर्टी को पढ़कर या i3 --get-socketpath पर कॉल करके प्राप्त कर सकते हैं। मैंने कम से कम प्रतिरोध का रास्ता अपनाया:

 QString I3Ipc::getSocketPath() { QProcess i3process; i3process.start("i3 --get-socketpath", QIODevice::ReadOnly); if (!i3process.waitForFinished()) { qDebug() << i3process.errorString(); exit(EXIT_FAILURE); } return QString(i3process.readAllStandardOutput()).remove(QChar('\n')); }

अब, सॉकेट फ़ाइल का पथ जानने के बाद, आप सर्वर से जुड़ सकते हैं:

 void I3Ipc::reconnect() { mainSocket->abort(); eventSocket->abort(); QString socketPath = getSocketPath(); mainSocket->connectToServer(socketPath); eventSocket->connectToServer(socketPath); if (!mainSocket->waitForConnected() || !eventSocket->waitForConnected()) { qDebug() << "Connection timeout!"; exit(EXIT_FAILURE); } subscribe(); }

और डेटा भेजें:

 QByteArray I3Ipc::pack(int type, QString payload) { QByteArray b; QDataStream s(&b, QIODevice::WriteOnly); s.setByteOrder(QDataStream::LittleEndian); s.writeRawData(I3_IPC_MAGIC, qstrlen(I3_IPC_MAGIC)); s << (quint32) payload.size(); s << (quint32) type; s.writeRawData(payload.toAscii().data(), payload.size()); return b; } void I3Ipc::send(int type, QString payload) { send(type, payload, mainSocket); } void I3Ipc::send(int type, QString payload, QLocalSocket* socket) { socket->write(pack(type, payload)); }

यदि आप प्रोटोकॉल भाग को ध्यान से पढ़ते हैं, तो यह कोड आपके लिए स्पष्ट होना चाहिए। हम डेटा पैक करते हैं और सॉकेट पर लिखते हैं। I3_IPC_MAGIC - प्रोटोकॉल का वर्णन करने वाली शीर्ष लेख फ़ाइल <i3 / ipc.h> से निरंतर।
Concerning setByteOrder (): BigEndian QDataStream बाइट ऑर्डर के लिए मानक है, और i3 देशी में डेटा की प्रतीक्षा करता है, इसलिए या तो इस तरह की बैसाखी या char और memcpy () सरणियों के पक्ष में QDataStream को छोड़ना होगा। हमने सीखा कि डेटा कैसे भेजें, अब हम सीखेंगे कि उत्तर कैसे स्वीकार करें:

 void I3Ipc::read() { QLocalSocket *socket = (QLocalSocket*)sender(); if (socket->bytesAvailable() < (int) (qstrlen(I3_IPC_MAGIC) + sizeof(quint32) * 2)) return; QDataStream s(socket); s.setByteOrder(QDataStream::LittleEndian); quint32 msgType, payloadSize; s.skipRawData(qstrlen(I3_IPC_MAGIC)); s >> payloadSize; s >> msgType; while (socket->bytesAvailable() < payloadSize) { if (!socket->waitForReadyRead()) { qDebug() << "Reading timeout!"; exit(EXIT_FAILURE); } } char buf[payloadSize]; s.readRawData(buf, payloadSize); QByteArray jsonPayload(buf, payloadSize); if (msgType >> 31) { if (msgType == I3_IPC_EVENT_WORKSPACE) { emit workspaceEvent(); } } else { if (msgType == I3_IPC_REPLY_TYPE_WORKSPACES) { emit workspaceReply(jsonPayload); } } }

यहां, सब कुछ बेहद सरल है: हम 14 बाइट्स जमा होने तक इंतजार करते हैं (6 एक मैजिक स्ट्रिंग और दो 4-बाइट नंबर हैं), हम 6 बाइट्स को छोड़ते हैं और संदेश का आकार पढ़ते हैं और चर में टाइप करते हैं। यह केवल संदेश के लिए प्रतीक्षा करने के लिए ही रहता है और, प्रकार के आधार पर, उपयुक्त संकेत भेजता है।
अब प्रत्येक ईवेंट के बाद हमें json फॉर्मेट में डेस्कटॉप की अप-टू-डेट सूची प्राप्त होगी। इसे "सामान्य" स्थिति में लाने के लिए, हम QJson लाइब्रेरी का उपयोग करेंगे। कई वितरणों में, यह रिपॉजिटरी में है, और यदि नहीं, तो कोई भी इसे खुद को इकट्ठा करने के लिए परेशान नहीं करता है। तो, हम कनेक्ट करते हैं:

 LIBS += -lqjson

.Pro फ़ाइल में और

 #include <qjson/parser.h>

हेडर फ़ाइल में। QJson का उपयोग करना बेहद आसान है।

 void Q3Panel::workspaceReplySlot(const QByteArray jsonPayload) { bool ok; QList<QVariant> workspacesList = jsonParser->parse(jsonPayload, &ok).toList(); if (!ok) { qDebug() << "Parser error: " << jsonParser->errorString(); return; } workspaces->clear(); for (int i = 0; i < workspacesList.size(); ++i) { QMap<QString, QVariant> w = workspacesList.at(i).toMap(); workspaces->insert(w.value("num").toUInt(), workspaceInfo(w.value("name").toString(), w.value("focused").toBool(), w.value("urgent").toBool())); } emit updateWorkspacesWidget(workspaces); }

वर्कस्पेस एक हैश टेबल है जिसमें हम डेस्कटॉप के बारे में जानकारी स्टोर करते हैं। इसकी कुंजी क्विंट 16 डेस्कटॉप नंबर है, और मूल्य इस संरचना है:

 struct workspaceInfo { QString name; bool focused; bool urgent; workspaceInfo(QString _n, bool _f = 0, bool _u = 0) { name = _n; focused = _f; urgent = _u; } };

यहां सब कुछ सरल और स्पष्ट है। हम जानते हैं कि डेस्कटॉप के बारे में जानकारी कैसे प्राप्त करें, और स्टोर भी करें। एक ट्रिफ़ल बचा है: इसे प्रदर्शित करने के लिए और एक विशिष्ट डेस्कटॉप पर क्लिक करके विंडो मैनेजर को एक कमांड भेजें। आप विभिन्न तरीकों से जा सकते हैं, मैंने QHBoxLayout के आधार पर अपने विजेट को लिखने का फैसला किया। कुछ भी जटिल नहीं है, एक हैश तालिका स्टोर करें जहां कुंजी डेस्कटॉप नंबर है और मान वर्कस्पेसबटन बटन का लिंक है। WorkspaceButton को QToolButton से विरासत में मिला है और यह आकार बदलने और शैली की अपनी नीति को छोड़कर कुछ भी नया नहीं दर्शाता है। डेस्कटॉप की सूची के प्रत्येक अपडेट के बाद, विजेट को अपडेट किया जाना चाहिए। यह संभव होगा कि सभी बटन हटा दें और एक नया बनाएं, लेकिन हम थोड़े अलग तरीके से जाएंगे:

 void WorkspacesWidget::updateWorkspacesWidgetSlot(const QHash<qint16, workspaceInfo> *workspaces) { clearLayout(); QHash<qint16, workspaceInfo>::const_iterator wi = workspaces->constBegin(); while (wi != workspaces->constEnd()) { if (buttons->contains(wi.key())) { buttons->value(wi.key())->setFocused(wi.value().focused); } else { addButton(wi.key(), wi.value().focused, wi.value().name); } ++wi; } QHash<qint16, WorkspaceButton*>::const_iterator bi = buttons->constBegin(); QList<qint16> toDelete; while (bi != buttons->constEnd()) { if (!workspaces->contains(bi.key())) { delete bi.value(); toDelete << bi.key(); } else { mainLayout->addWidget(bi.value()); } ++bi; } for (int i = 0; i < toDelete.size(); ++i) { buttons->remove(toDelete.at(i)); } } void WorkspacesWidget::clearLayout() { while (mainLayout->takeAt(0)); } void WorkspacesWidget::addButton(quint16 num, bool focused, QString name) { WorkspaceButton* newButton = new WorkspaceButton(name, focused); connect(newButton, SIGNAL(clicked()), this, SLOT(buttonClickedSlot())); buttons->insert(num, newButton); }

सबसे पहले, हम QHBoxLayout को साफ़ करते हैं और कार्यक्षेत्रों के माध्यम से जाते हैं और, यदि वर्तमान डेस्कटॉप के लिए पहले से ही एक बटन है, तो केंद्रित संपत्ति को अपडेट करें। यदि कोई बटन नहीं है, तो इसे जोड़ें। फिर हम यह देखने के लिए सभी बटन तत्वों की जांच करते हैं कि डेस्कटॉप अभी भी मौजूद है या नहीं। और, यदि मौजूद है, तो QHBoxLayout पर जोड़ें। यदि नहीं, तो हटाएं। मुझे नहीं पता कि यह तरीका कितना इष्टतम है, लेकिन यह मुझे हर बार सभी बटन को हटाने और फिर से बनाने की तुलना में बहुत अच्छा लग रहा था।
वह सब है! यहाँ यह है, हमारा पैनल:

यह ठीक से काम करता है, डेस्कटॉप, स्विच दिखाता है। लेकिन यह सिर्फ बुनियादी कार्यक्षमता है, कार्यक्षमता के मामले में मानक पैनल को पकड़ने और उससे आगे निकलने के लिए, यह सेटिंग्स, ट्रे, मेनू और घड़ी को जोड़ने के लिए बनी हुई है। इसके बारे में अगले लेख में, जब तक, निश्चित रूप से, विषय दिलचस्प होगा।

स्रोत कोड रिपोजिटरी

Q3 पर i3 विंडो मैनेजर के लिए एक पैनल लिखना

प्रस्तावना

विकास शुरू करें

I3 के साथ चैटिंग

More articles: