QtDockTile - डॉक का क्रॉस-प्लेटफॉर्म उपयोग!

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

सभी डॉक के लिए सामान्य

सबसे पहले, आपको उन विशेषताओं की एक सूची को उजागर करने की आवश्यकता है जो सभी डॉक्स के लिए सामान्य हैं:

1. बैज
2. प्रगति सूचक
3. मेन्यू
4. संकेतन

यह सभी कार्यक्षमता बुनियादी है और किसी तरह सात में, मेकोशी में और उबंट में समर्थित है। यह इस आधार पर है कि मूल qtdocktile API बनाया जाएगा, और सभी प्लेटफ़ॉर्म-निर्भर एक्सटेंशन को जोड़ा जाएगा क्योंकि लाइब्रेरी विकसित होती है और इसकी आवश्यकता नहीं होगी।

पुस्तकालय वास्तुकला

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

नमूना पुस्तकालय उपयोग

m_tile->setMenu(ui->menu); connect(ui->pushButton, SIGNAL(clicked()), m_tile, SLOT(alert())); connect(ui->lineEdit, SIGNAL(textChanged(QString)), m_tile, SLOT(setBadge(QString))); connect(ui->horizontalSlider, SIGNAL(valueChanged(int)), m_tile, SLOT(setProgress(int))); 

जैसा कि आप देख सकते हैं, यह बहुत सरल है! लेकिन एक साधारण एपीआई लिखना आधी परेशानी है, अब आपको सभी प्लेटफार्मों के लिए समर्थन लागू करने की आवश्यकता है:

चेतावनी! आगे कई तकनीकी विवरण होंगे, यदि आप उनमें रुचि नहीं रखते हैं, तो आप तुरंत निष्कर्ष को पढ़ने के लिए आगे बढ़ सकते हैं।

एकता के लिए प्लगइन कार्यान्वयन

अजीब तरह से पर्याप्त है, लेकिन एकता के लिए सबसे छोटा और लैकोनिक कार्यान्वयन निकला। सभी एपीआई काफी सरल डब संदेश भेजने पर आधारित है:

 void UnityLauncher::sendMessage(const QVariantMap &map) { QDBusMessage message = QDBusMessage::createSignal(appUri(), "com.canonical.Unity.LauncherEntry", "Update"); QVariantList args; args << appDesktopUri() << map; message.setArguments(args); if (!QDBusConnection::sessionBus().send(message)) qWarning("Unable to send message"); } 

जहां appUri अनुप्रयोग का अद्वितीय नाम है, इस कार्यान्वयन में यह केवल प्रक्रिया के नाम से मेल खाता है, और appDesktopUri प्रपत्र अनुप्रयोग की प्रविष्टि है: //$appUri.desktop।
बैज पर मान को बदलने के लिए, यह निम्न संदेश भेजने के लिए पर्याप्त है:

  QVariantMap map; map.insert(QLatin1String("count"), count); map.insert(QLatin1String("count-visible"), count > 0); sendMessage(map); 

इसी तरह, प्रगति संकेतक और सिग्नलिंग के लिए, मेनू थोड़ा और दिलचस्प है: आपको इसे बनाने के लिए DBusMenuExporter वर्ग का उपयोग करने की आवश्यकता है, जब इसे appUri और एक सूचक QMenu पास करके बनाते हैं। यह सब एपीआई है, अब सीमाओं को सूचीबद्ध करते हैं:

एकता लांचर एपीआई सीमाएँ

1. बैज केवल डिजिटल हैं और केवल 0. से अधिक है, अन्यथा, 0 प्रदर्शित होता है।
2. निर्यात किए गए मेनू में सबमेनस नहीं दिखाया गया है, इसलिए उनसे बचना बेहतर है।
3. यदि मेनू को एपमेनू में भी निर्यात किया जाता है, तो यह गोदी में दिखाई नहीं देगा
4. DBusMenuExporter कार्यान्वयन में एक बग है, जिसके परिणामस्वरूप मेनू की जाँच की गई स्थिति उलटी है

ठीक है, अंतिम: एपीआई काम करने के लिए, आपके पास / usr / शेयर / एप्लिकेशन में एक आइकन होना चाहिए। वैसे, एकता एपीआई आपको मेनू में स्थायी आइटम जोड़ने की अनुमति देता है जो काम तब करता है जब एप्लिकेशन नहीं चल रहा है, यह कुछ इस तरह दिखता है:

 X-Ayatana-Desktop-Shortcuts=NewWindow; [NewWindow Shortcut Group] Name=Open a New Window Name[ast]=Abrir una ventana nueva Name[bn]=Abrir una ventana nueva Name[ca]=Obre una finestra nova Name[da]=Åbn et nyt vindue Name[de]=Ein neues Fenster öffnen Name[es]=Abrir una ventana nueva Name[fi]=Avaa uusi ikkuna Name[fr]=Ouvrir une nouvelle fenêtre Name[gl]=Abrir unha nova xanela Name[he]=פתיחת חלון חדש Name[hr]=Otvori novi prozor Name[hu]=Új ablak nyitása Name[it]=Apri una nuova finestra Name[ja]=新しいウィンドウを開くName[ku]=Paceyeke nû veke Name[lt]=Atverti naują langą Name[nl]=Nieuw venster openen Name[ro]=Deschide o fereastră nouă Name[ru]=   Name[sv]=Öppna ett nytt fönster Name[ug]=يېڭى كۆزنەك ئېچىش Name[uk]=і  і Name[zh_CN]=新建窗口Name[zh_TW]=開啟新視窗Exec=firefox -new-window TargetEnvironment=Unity 

और एक नाश्ते के लिए स्क्रीनशॉट के एक जोड़े:

एकता:

KDE (चिह्न कार्य):


प्लगइन लिखते समय, मैंने टुटवे के काम को क्यूटीआईएम के लिए इस्तेमाल किया।

मैकोस एक्स के लिए प्लगइन कार्यान्वयन

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

  const char *utf8String = badge.toUtf8().constData(); NSString *cocoaString = [[NSString alloc] initWithUTF8String:utf8String]; [[NSApp dockTile] setBadgeLabel:cocoaString]; [cocoaString release]; 

प्रगति संकेतक बनाना थोड़ा अधिक कठिन हो गया है: डॉक एपीआई में कोई अंतर्निहित विधि नहीं है, लेकिन डॉक आइकन में आपकी छवि खींचने के लिए एक विधि है। ज्यादा परेशान न करने के लिए, मैंने अभी-अभी QtCreator से इंडिकेटर के कार्यान्वयन को लिया, क्योंकि LGPL लाइसेंस चुपचाप मेरे कानों के साथ इस तरह के झगड़े की अनुमति देता है।

स्क्रीनशॉट

विंडोज 7 टास्कबार के लिए कार्यान्वयन

और अंत में, सबसे स्वादिष्ट! यदि अन्य प्रणालियों में प्लगइन्स लिखने की प्रक्रिया कम या ज्यादा सुचारू रूप से चली गई, तो सबसे लोकप्रिय डेस्कटॉप ओएस के लिए, सब कुछ इतना बादल रहित नहीं निकला, मुझे अपने आप को विभिन्न बुरे शब्दों बिल गेट्स, स्टीव बाल्मर और नामहीन प्रोग्रामर के साथ याद रखना पड़ा, जिन्होंने विभिन्न रेक को सावधानीपूर्वक रखा! लिखने के दौरान, वाक्यांश को मरना चाहिए, wtf और जैसे कि अच्छे पुराने विंडोस तक कई बार उठता है।
Wchar_t * के बजाय LPCSTR जैसे अजीब अपठनीय प्रकार हैं और सभी क्षेत्रों में हंगेरियन संकेतन और महान और भयानक COM, एक शब्द में, कोड शैली बस भयानक है। और एबीआई में एक समस्या भी है जिसके परिणामस्वरूप एमएस कंपाइलर द्वारा संकलित कोड सी + + लाइब्रेरी को minGW द्वारा संकलित कोड से जोड़ना असंभव है। खैर, एपीआई कुछ अजीब है क्योंकि मुझे कुछ बैसाखियों में जाना पड़ा। इसके अलावा, कूद सूचियों के उदाहरणों में एटीएल पुस्तकालय का उपयोग होता है, जो केवल एक भुगतान स्टूडियो में उपलब्ध है और इस कारण से हमारे लिए उपयुक्त नहीं है।
ABI के साथ समस्याओं को हल करने के लिए, dtf और मैंने टास्कबार की COM एपीआई पर एक न्यूनतम C आवरण बनाने का फैसला किया ताकि भविष्य में किसी भी संकलक से इसे गतिशील रूप से जोड़ना संभव हो सके।
एपीआई यह बहुत सरल निकला, रैपर स्वयं क्यूटी पर निर्भर नहीं है और इसे कहीं से भी उपयोग किया जा सकता है, हालांकि यह पूरी तरह से लिखा गया है और पूरी तरह से winAPI की शैली में नहीं है।

 ... EXPORT void setApplicationId(const wchar_t *appId); EXPORT void setOverlayIcon(HWND winId, HICON icon, wchar_t *description = 0); EXPORT void clearOverlayIcon(HWND winId); EXPORT void setProgressValue(HWND winId, int percents); EXPORT void setProgressState(HWND winId, ProgressState state); ... 

मैंने सबसे सरल से शुरू किया: मैंने एक प्रगति संकेतक बनाने का फैसला किया, इसके लिए कोड पहले से ही कॉमरेड डीटीएफ द्वारा लिखा गया था, इसलिए स्थानांतरण के साथ कोई विशेष कठिनाइयां नहीं थीं।

 //    static ITaskbarList3 *windowsTaskBar() { ITaskbarList3 *taskbar; if(S_OK != CoCreateInstance(CLSID_TaskbarList, 0, CLSCTX_INPROC_SERVER, IID_ITaskbarList3, (void**)&taskbar)) return 0; return taskbar; } ... //   void setProgressValue(HWND winId, int progress) { ITaskbarList3 *taskbar = windowsTaskBar(); if (!taskbar) return; taskbar->HrInit(); taskbar->SetProgressValue(winId, progress, 100); taskbar->SetProgressState(winId, progress ? TBPF_NORMAL : TBPF_NOPROGRESS); taskbar->Release(); } //    void setProgressState(HWND winId, ProgressState state) { TBPFLAG flags; ITaskbarList3 *taskbar = windowsTaskBar(); if (!taskbar) return; taskbar->HrInit(); switch (state) { default: case ProgressStateNone : flags = TBPF_NOPROGRESS; break; case ProgressStateNormal : flags = TBPF_NORMAL; break; case ProgressStatePaused : flags = TBPF_PAUSED; break; case ProgressStateError : flags = TBPF_ERROR; break; case ProgressStateIndeterminate : flags = TBPF_INDETERMINATE; break; } taskbar->SetProgressState(winId, flags); taskbar->Release(); } 

मैंने setOverlayIcon विधि के माध्यम से बैज को लागू किया, और मैंने आइकन को स्वयं आकर्षित किया और इसे HtON में Qt का उपयोग करके बदल दिया

 QPixmap WindowsTaskBar::createBadge(const QString &badge) const { QPixmap pixmap(overlayIconSize()); QRect rect = pixmap.rect(); rect.adjust(1, 1, -1, -1); pixmap.fill(Qt::transparent); QPainter painter(&pixmap); painter.setRenderHint(QPainter::Antialiasing); QPalette palette = window()->palette(); painter.setBrush(palette.toolTipBase()); QPen pen = painter.pen(); pen.setColor(palette.color(QPalette::ToolTipText)); painter.setPen(pen); QString label = QFontMetrics(painter.font()).elidedText(badge, Qt::ElideMiddle, rect.width()); painter.drawRoundedRect(rect, 5, 5); painter.drawText(rect, Qt::AlignCenter | Qt::TextSingleLine, label); return pixmap; } 

परिणामस्वरूप, केवल 2 वर्ण बैज में डाले जा सकते हैं। आइकन का आकार QStyle :: pixelMetrics के माध्यम से सेट किया गया है, मुझे पता चला कि ओवरलेआईकॉन के अन्य कार्यान्वयन सिर्फ 16x16 आइकन खींचते हैं और डीपीआई की परवाह नहीं करते हैं, इसलिए मेरे मॉनिटर पर आइकन धुंधला हो जाता है।
और अब सबसे दिलचस्प बात कूद सूचियों का कार्यान्वयन है। यही कारण है कि बूढ़े बिली ने अनुपस्थिति में सुना, बहुत सारे स्नेह भरे शब्द उसे संबोधित किए!

परीक्षण संख्या 1 - एपीआई प्रतिबंधों के आधार पर QAction क्रमांकन

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

 struct ActionInfo { const char *id; wchar_t *name; wchar_t *description; wchar_t *iconPath; ActionType type; void *data; //    -                 . }; typedef void (*ActionInvoker)(void*); //  ,      void *data 

अब शून्य * डेटा के रहस्य को प्रकट करते हैं:

 typedef QVector<ActionInfo> ActionInfoList; //   ++,          typedef QVector<wchar_t> WCharArray; //  wchar_t * static WCharArray toWCharArray(const QString &str) { WCharArray array(str.length() + 1); str.toWCharArray(array.data()); return array; } struct Data { Data(QAction *action) : action(action), icon(action->icon()), id(QUuid::createUuid().toByteArray()), name(toWCharArray(action->text())), description(toWCharArray(action->toolTip())), iconPath(toWCharArray(icon.filePath())) { } QWeakPointer<QAction> action; TemporaryIcon icon; QByteArray id; WCharArray name; WCharArray description; WCharArray iconPath; }; void invokeQAction(void *pointer) { Data *data = reinterpret_cast<Data*>(pointer); if (data->action) { qDebug() << data->action.data(); data->action.data()->trigger(); } } 

यहाँ इस तरह की क्रियाओं का क्रमबद्ध वर्णन है। मैंने मैन्युअल नई की संख्या को कम करने और हटाने की कोशिश की - सब कुछ स्वचालित रूप से होता है। यह ऐसा दृष्टिकोण है जो सुनिश्चित करता है कि आपके बाल चिकने और रेशमी होंगे!

अब मंच की सीमाओं को याद करते हैं और समझते हैं कि हम किन क्रियाओं को क्रमबद्ध कर सकते हैं और जिन्हें अनदेखा करना बेहतर है। तो, जंप सूचियों में कोई सबमेनस नहीं हैं, यहां कोई अक्षम और जांच योग्य आइटम नहीं हैं, कुल मदों की संख्या 20 तक सीमित है। लेकिन विभाजक हैं, यह कुछ इस तरह से निकलता है:

  if (!action->menu() && action->isVisible() && action->isEnabled() && !action->isCheckable()) list.append(serialize(action)); ... ActionInfo JumpListsMenuExporterPrivate::serialize(QAction *action) { Data *data = new Data(action); ActionType type = action->isSeparator() ? ActionTypeSeparator : ActionTypeNormal; ActionInfo info = { data->id.constData(), data->name.data(), data->description.data(), data->iconPath.data(), type, data }; return info; } 

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

क्रम संख्या 2 - जंपिंग पॉपलिस्ट

कूद सूचियों को भरने के लिए, आपको शुरुआती विधि को कॉल करने की आवश्यकता है

 void JumpListsManager::beginList() { if (m_destList) return; ICustomDestinationList *list; HRESULT res = CoCreateInstance(CLSID_DestinationList, 0, CLSCTX_INPROC_SERVER, IID_ICustomDestinationList, (void**)&list); if (FAILED(res)) { return; } UINT maxSlots; m_destList = list; m_destList->SetAppID(m_appId); m_destList->BeginList(&maxSlots, IID_IObjectArray, (void**)&m_destListContent); m_destListContent->Release(); IObjectArray *objArray; CoCreateInstance(CLSID_EnumerableObjectCollection, 0, CLSCTX_INPROC_SERVER, IID_IObjectArray, (void**)&objArray); objArray->QueryInterface(IID_IObjectCollection, (void**)&m_destListContent); objArray->Release(); } 

फिर इस सूची को भरें

 void JumpListsManager::addTask(ActionInfo *info) { if (!m_destList) return; IShellLinkW *task; HRESULT res = CoCreateInstance(CLSID_ShellLink, 0, CLSCTX_INPROC_SERVER, IID_IShellLinkW, (void**)&task); if (FAILED(res)) return; task->SetDescription(info->description); task->SetPath(L"rundll32.exe"); task->SetArguments(makeArgs(info).c_str()); if (info->iconPath) task->SetIconLocation(info->iconPath, 0); IPropertyStore *title; PROPVARIANT titlepv; res = task->QueryInterface(IID_IPropertyStore, (void**)&title); if (FAILED(res)) { task->Release(); return; } InitPropVariantFromString(info->name, &titlepv); title->SetValue(PKEY_Title, titlepv); title->Commit(); PropVariantClear(&titlepv); res = m_destListContent->AddObject(task); title->Release(); task->Release(); m_actionInfoMap.insert(std::make_pair(info->id, info)); //    :      id    . } ... void JumpListsManager::addSeparator() { IShellLinkW *separator; IPropertyStore *propStore; PROPVARIANT pv; HRESULT res = CoCreateInstance(CLSID_ShellLink, 0, CLSCTX_INPROC_SERVER, IID_IShellLinkW, (void**)&separator); if (FAILED(res)) return; res = separator->QueryInterface(IID_IPropertyStore, (void**)&propStore); if (FAILED(res)) { separator->Release(); return; } InitPropVariantFromBoolean(TRUE, &pv); propStore->SetValue(PKEY_AppUserModel_IsDestListSeparator, pv); PropVariantClear(&pv); propStore->Commit(); propStore->Release(); res = m_destListContent->AddObject(separator); separator->Release(); } 

और कमिटमेंट विधि को बुलाओ

 void JumpListsManager::commitList() { if (!m_destList) return; m_destList->AddUserTasks(m_destListContent); m_destList->CommitList(); m_destList->Release(); m_destListContent->Release(); m_destList = 0; m_destListContent = 0; } 

Verbose, क्या आपको नहीं मिला? लेकिन अफसोस, आपको बुलेट को काटने और कोड के सैकड़ों लाइनों को स्क्रिबल करना जारी रखना होगा, अन्यथा कुछ भी काम नहीं करेगा, लेकिन क्या हम असली आदमी हैं और कठिनाइयों से डरते नहीं हैं? और अगर हम डरते नहीं हैं, तो चलो एक कॉलबैक लागू करें!

क्रम संख्या 3 - कॉलबैक लागू करना

तो हमारे पास क्या है? जंपलिस्ट में एक आइटम को सक्रिय करना कुछ आदेशों के साथ कमांड को कॉल करता है। लेकिन हम इसके माध्यम से कैसे कह सकते हैं कि हम एक विशिष्ट आईडी के साथ एक्शनइन्फो ढूंढना चाहते हैं और कॉलबैक करना चाहते हैं?
Dtf और मैंने इस बारे में लंबे समय तक सोचा और उन्होंने rundll के माध्यम से सब कुछ करने का प्रस्ताव रखा, जो दिए गए तर्कों के साथ पुस्तकालय से एक विशिष्ट विधि को कॉल करने में सक्षम है।
नतीजतन, एक विधि का जन्म हुआ जो एक एक्शन आईडी लेता है, 42042 पोर्ट पर एक सॉकेट खोलता है और प्राप्त आईडी को इसमें पास करता है, और लाइब्रेरी इस सॉकेट को सुनता है और, आईडी प्राप्त होने पर, शांति से कॉलबैक करता है और हमारे वांछित QAction को बुलाया जाता है!

 std::wstring JumpListsManager::makeArgs(ActionInfo *info) { std::wstring args = m_wrapperPath; #ifdef _WIN64 args += L",_RundllCallback@28 "; // WARNING: TEST ME! // ptr×3 + int #else args += L",_RundllCallback@16 "; #endif // Convert to a wchar_t* size_t origsize = strlen(info->id) + 1; const size_t newsize = 64; size_t convertedChars = 0; wchar_t buffer[newsize]; mbstowcs_s(&convertedChars, buffer, origsize, info->id, _TRUNCATE); args += buffer; return args; } 

और अंतिम विधि: उस फ़ंक्शन को लागू करना जो रैंडल कॉल करता है

 EXPORT void CALLBACK RundllCallback(HWND hwnd, HINSTANCE hinst, LPSTR cmdLine, int cmdShow); void CALLBACK RundllCallback(HWND, HINSTANCE, LPSTR cmdLine, int) { WSADATA wsaData; WSAStartup(MAKEWORD(2, 2), &wsaData); SOCKET sk; sk = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP); if (sk == INVALID_SOCKET) { WSACleanup(); return; } sockaddr_in sai; sai.sin_family = AF_INET; sai.sin_addr.s_addr = inet_addr("127.0.0.1"); sai.sin_port = htons(Handler::port); if (connect(sk, reinterpret_cast<SOCKADDR*>(&sai), sizeof(sai)) == SOCKET_ERROR) { WSACleanup(); return; } std::string cmd = cmdLine; send(sk, cmd.c_str(), cmd.size(), 0); closesocket(sk); WSACleanup(); } 

यह सब है, आज के लिए पर्याप्त कोड है, आप आसानी से सांस ले सकते हैं, चलिए संक्षेप करते हैं:

विंडोज़ कार्यान्वयन में सीमाएँ

1. बैज में केवल दो बैज
2. हमारे जोड़तोड़ के परिणामस्वरूप, कूद सूचियों से अंतिम फाइलें खो जाती हैं।
3. क्रियाओं का समर्थन नहीं किया जाता है - स्विच और निष्क्रिय क्रियाएं
4. सबमेनस समर्थित नहीं

स्क्रीनशॉट:

निष्कर्ष

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

• एक सबमेनू नहीं है
• Switchable या अक्षम आइटम नहीं है
• कुछ बिंदु होने चाहिए
• सेटमेनू के माध्यम से सेट होने के बाद इसे बदला नहीं जाना चाहिए

और टिप्पणियों की एक जोड़ी:

• डॉक का सही काम केवल एक आवेदन के मामले में संभव है, क्यूटी सिंगल एप्लीकेशन या अन्य समान साधनों के साथ डॉक का उपयोग करें
• बैज में 100 से कम सकारात्मक संख्या का उपयोग करना बेहतर है

अन्य मामलों में, सभी प्लेटफार्मों पर कुछ उपलब्ध नहीं होगा। सिद्धांत रूप में, यह घातक नहीं है, लेकिन आपको इसे याद रखने की आवश्यकता है!
एकता प्लग-इन को लागू करने में मदद के लिए Torkve का धन्यवाद, Macos X संस्करण को लागू करने में मदद के लिए Windows प्लग-इन और QtCreator डेवलपर्स को लागू करने में बहुत मदद के लिए dtf ।
स्रोत कोड github पर उपलब्ध है। सुधार और सुधार का स्वागत है।
धमकी
क्या डॉकमैनगर एपीआई को लागू करने के लिए कोई तैयार है?