👩‍🚒 🆎 🧝 क्यूटी क्रिएटर एक्सटेंशन सिस्टम 🤣 👩🏽‍🏭 🤦🏻

प्रस्तावना

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

परिचय

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

फिर भी, यदि यह दस्तावेज़ नहीं था, तो यह नोट नहीं होगा: मैंने पोस्ट के ढांचे तक बहुत कुछ लिया, जबकि बाद में उत्तरार्द्ध के लिए पोस्ट को प्रासंगिक बनाने के लिए कुछ फेंकने / बदलने / जोड़ने की कोशिश कर रहा था। Qt निर्माता का समय संस्करण 2.4.0।

इस दस्तावेज़ से कौन लाभ उठा सकता है? सबसे पहले, ये निश्चित रूप से क्यूटी-प्रोग्रामर हैं जिन्होंने इस आईडीई को मुख्य विकास पर्यावरण के रूप में चुना है।

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

तो, कट के तहत हमें क्या इंतजार है (तैयार अनुभाग बोल्ड में चिह्नित हैं):

क्यूटी निर्माता बनाएँ
पहला विस्तार
नए मेनू और मेनू आइटम जोड़ना
क्यूटी निर्माता वास्तुकला
एक नया संपादक जोड़ना
एक साइड नेविगेशन बार जोड़ना
सेटिंग्स डायलॉग में एक पेज जोड़ना
खोज संवाद में एक फ़िल्टर जोड़ना
एक नया प्रोजेक्ट प्रकार जोड़ना

आपको याद दिला दूं कि क्यूटी क्रिएटर ट्रोलटेक (नोकिया) द्वारा विकसित क्यूटी ढांचे के साथ काम करने के लिए एक क्रॉस-प्लेटफॉर्म मुफ्त आईडीई है। आपको सिंटैक्स हाइलाइटिंग, सभी एक्सटेंशनों का एक सरल अक्षम करने के साथ इसे एक साधारण पाठ संपादक बनाने से क्या नहीं रोकता है। ध्यान दें, सैकड़ों चित्र!

1. क्यूटी निर्माता बनाएँ

पूरे IDE को असेंबल करना एक काफी सरल क्रिया है। सबसे पहले, हमें क्यूटी क्रिएटर के नवीनतम संस्करण के लिए स्रोत कोड डाउनलोड करना होगा। यह वर्तमान में संस्करण 2.4 है। डाउनलोड / Qt-Creator अनुभाग से qt.nokia.com से फ़ाइल डाउनलोड करें:

अगला, परिणामी संग्रह को अनपैक करें, स्रोत निर्देशिका में बिल्ड उपनिर्देशिका बनाएं, उस पर जाएं, qmake चलाएं और फिर बनाएं:

$ tar -xvf qt-creator-2.4.0-src.tar.gz $ mkdir qt-creator-2.4.0-src/build $ cd qt-creator-2.4.0-src/build/ $ qmake ../qtcreator.pro –recursive $ make

विंडोज उपयोगकर्ताओं के लिए, यह कोड केवल अंतिम पंक्ति में भिन्न हो सकता है - मेक के बजाय, आपको उपयोगकर्ता की वरीयताओं के आधार पर mingw32-make या nmake को कॉल करना होगा।

वह सब है। आप Qt क्रिएटर को बिल्ड / बिन डायरेक्टरी से चला सकते हैं।

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

2. पहला विस्तार

जैसा कि कई मामलों में, आपको एक बहुत ही सरल एक्सटेंशन बनाकर Qt क्रिएटर एक्सटेंशन सिस्टम की खोज शुरू करनी चाहिए। अब हम एक ऐसा एक्सटेंशन बनाने की कोशिश करेंगे जो कुछ भी नहीं करता है, लेकिन हमारे DoNothing एक्सटेंशन के उदाहरण का उपयोग करते हुए, हम लेखन एक्सटेंशन से संबंधित क्यूटी क्रिएटर के आधार वर्गों के बारे में जानेंगे और उपलब्ध एक्सटेंशन की सूची में "DoNothing" लाइन देखेंगे।

2.1 क्यूटी क्रिएटर एक्सटेंशन प्रोजेक्ट बनाना

पहले, यह संस्करण 2.0 तक लगता है, इस चरण को पूरा करने के लिए, निम्न फ़ाइलों को मैन्युअल रूप से बनाना आवश्यक था:

DoNothingPlugin.pro
DoNothingPlugin.h
DoNothingPlugin.cpp
DoNothingPlugin.pluginspec

इसके अलावा, तब आपको या तो विस्तार परियोजना को $$ QT_CREATOR_ROOT / src / plugins निर्देशिका में डालना चाहिए, या इसे किसी अन्य स्थान पर रखकर, आपको .pro फ़ाइल में स्रोत निर्देशिका और Qt निर्माता का निर्माण निर्दिष्ट करना होगा। क्यूटी क्रिएटर के आधुनिक संस्करणों में, प्रोजेक्ट फ़ाइलों को कहीं भी रखा जा सकता है, क्योंकि एक नया प्रकार का विज़ार्ड दिखाई दिया - इसे बनाने के लिए "क्यूटी क्रिएटर मॉड्यूल"। फिलहाल एक नया विस्तार बनाने की प्रक्रिया इस प्रकार है /
बहुत शुरुआत में, सब कुछ हमेशा की तरह है - प्रोजेक्ट के प्रकार का निर्माण किया जाना है,

नाम और पथ को उसकी नियुक्ति की निर्देशिका में दर्ज करने के बाद

असेंबली का उद्देश्य, स्वाभाविक रूप से यह डेस्कटॉप है।

लेकिन उसके बाद, थोड़ा जादू शुरू होता है - हमें मॉड्यूल के लिए विशिष्ट जानकारी भरने की आवश्यकता है:

यहां, सामान्य तौर पर, सब कुछ तस्वीर से स्पष्ट है। यहाँ केवल महत्वपूर्ण फ़ील्ड Qt क्रिएटर के स्रोत / निर्माण निर्देशिका के लिए पथ हैं। हम जादूगर को पूरा करते हैं:

और परिणामी परियोजना संरचना को देखें:

2.2 सेवा फाइलें

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

 TARGET = DoNothing TEMPLATE = lib DEFINES += DONOTHING_LIBRARY # DoNothing files SOURCES += donothingplugin.cpp HEADERS += donothingplugin.h\ donothing_global.h\ donothingconstants.h OTHER_FILES = DoNothing.pluginspec # Qt Creator linking ## set the QTC_SOURCE environment variable to override the setting here QTCREATOR_SOURCES = $$(QTC_SOURCE) isEmpty(QTCREATOR_SOURCES):QTCREATOR_SOURCES=/home/kafeg/devel/Qt/qt-creator-2.4.0-src ## set the QTC_BUILD environment variable to override the setting here IDE_BUILD_TREE = $$(QTC_BUILD) isEmpty(IDE_BUILD_TREE):IDE_BUILD_TREE=/home/kafeg/devel/Qt/qt-creator-2.4.0-src/build ## uncomment to build plugin into user config directory ## <localappdata>/plugins/<ideversion> ## where <localappdata> is eg ## "%LOCALAPPDATA%\Nokia\qtcreator" on Windows Vista and later ## "$XDG_DATA_HOME/Nokia/qtcreator" or "~/.local/share/Nokia/qtcreator" on Linux ## "~/Library/Application Support/Nokia/Qt Creator" on Mac # USE_USER_DESTDIR = yes PROVIDER = DoNothingCompany include($$QTCREATOR_SOURCES/src/qtcreatorplugin.pri) include($$QTCREATOR_SOURCES/src/plugins/coreplugin/coreplugin.pri) LIBS += -L$$IDE_PLUGIN_PATH/Nokia

जैसा कि आप देख सकते हैं, इस उत्पन्न फ़ाइल में नाम (DoNothing) और प्रोजेक्ट का प्रकार (पुस्तकालय) वर्णित हैं, तीन हेडर फाइलें और एक स्रोत फ़ाइल इंगित की गई है, प्लग इन का उल्लेख किया गया है। Qt क्रिएटर स्रोतों का स्थान इंगित किया गया है, बाहर निर्देश दिए गए हैं, निर्देश दिए गए हैं कि असेंबली लाइब्रेरी को Qt क्रिएटर निर्देशिका में स्थापित न करें, लेकिन स्थानीय उपयोगकर्ता निर्देशिका में, प्रदाता को वर्णित किया जाता है, जिस पर लाइब्रेरी फ़ाइलों का अंतिम स्थान निर्भर करता है। अंत में, सभी एक्सटेंशन qtcreatorplugin.pri और coreplugin.pri के लिए आधार फाइलें शामिल हैं, जो सभी आवश्यक पुस्तकालयों के साथ हमारे एक्सटेंशन के सही लिंकिंग के लिए पहले से ही जिम्मेदार हैं।

निम्नलिखित donothing_global.h फ़ाइलें:

 #ifndef DONOTHING_GLOBAL_H #define DONOTHING_GLOBAL_H #include <QtCore/QtGlobal> #if defined(DONOTHING_LIBRARY) # define DONOTHINGSHARED_EXPORT Q_DECL_EXPORT #else # define DONOTHINGSHARED_EXPORT Q_DECL_IMPORT #endif #endif // DONOTHING_GLOBAL_H

और

 #ifndef DONOTHINGCONSTANTS_H #define DONOTHINGCONSTANTS_H namespace DoNothing { namespace Constants { const char * const ACTION_ID = "DoNothing.Action"; const char * const MENU_ID = "DoNothing.Menu"; } // namespace DoNothing } // namespace Constants #endif // DONOTHINGCONSTANTS_H

यहां मुझे लगता है कि आगे की व्याख्या के बिना सब कुछ स्पष्ट है। और जो स्पष्ट नहीं है - यह स्पष्ट हो जाएगा जब हमें भविष्य में इस कोड की आवश्यकता होगी। सेवा फ़ाइलों की सूची DoNothing.pluginspec.in फ़ाइल के साथ पूरी की जा सकती है:

 <plugin name=\"DoNothing\" version=\"0.0.1\" compatVersion=\"0.0.1\"> <vendor>DoNothingCompany</vendor> <copyright>(C) DoNothing Company</copyright> <license>DoNothing Company license text here</license> <description>DoNothing Company short description of plugin here</description> <url>http://www.donothing.com</url> <dependencyList> <dependency name=\"Core\" version=\"$$QTCREATOR_VERSION\"/> </dependencyList> </plugin>

यह फ़ाइल अंततः बाइनरी लाइब्रेरी फ़ाइल के साथ वितरित की जाएगी और हमारे विस्तार का एक सरल विवरण है। और यहाँ वह वर्णित है:

लाइब्रेरी के नाम पर उपयोग किए जाने वाले एक्सटेंशन का नाम जो इसे लागू करता है। (हमारे मामले में, विंडोज पर DoNothing.dll और Unix पर libDoNothing.so)
एक्सटेंशन संस्करण
क्यूटी निर्माता के एक्सटेंशन संस्करण की आवश्यकता है
विक्रेता का नाम
कॉपीराइट
लाइसेंस पाठ
विवरण
विक्रेता url
एक्सटेंशन की सूची जिस पर यह एक्सटेंशन निर्भर करता है।

२.३ विस्तार का कार्यान्वयन

किसी रिक्त प्रोजेक्ट को सफलतापूर्वक संकलित करने के लिए, आपको हमारे विस्तार के लिए दो मुख्य कार्यान्वयन फ़ाइलों की आवश्यकता है। वे क्या पसंद हैं? मुख्य आवश्यकता यह है कि मुख्य एक्सटेंशन क्लास को IPlugin बेस क्लास से विरासत में प्राप्त किया जाना चाहिए और इसके कुछ तरीकों को ओवरराइड करना चाहिए।
donothingplugin.h

 #ifndef DONOTHING_H #define DONOTHING_H #include "donothing_global.h" #include <extensionsystem/iplugin.h> namespace DoNothing { namespace Internal { class DoNothingPlugin : public ExtensionSystem::IPlugin { Q_OBJECT public: DoNothingPlugin(); ~DoNothingPlugin(); bool initialize(const QStringList &arguments, QString *errorString); void extensionsInitialized(); ShutdownFlag aboutToShutdown(); private slots: void triggerAction(); }; } // namespace Internal } // namespace DoNothing #endif // DONOTHING_H

इस कोड के कार्यान्वयन फ़ाइल पर अधिक विस्तार से विचार करें:

 #include "donothingplugin.h" #include "donothingconstants.h" #include <coreplugin/icore.h> #include <coreplugin/icontext.h> #include <coreplugin/actionmanager/actionmanager.h> #include <coreplugin/actionmanager/command.h> #include <coreplugin/actionmanager/actioncontainer.h> #include <coreplugin/coreconstants.h> #include <QtGui/QAction> #include <QtGui/QMessageBox> #include <QtGui/QMainWindow> #include <QtGui/QMenu> #include <QtCore/QtPlugin> using namespace DoNothing::Internal; DoNothingPlugin::DoNothingPlugin() { // Create your members } DoNothingPlugin::~DoNothingPlugin() { // Unregister objects from the plugin manager's object pool // Delete members }

कंस्ट्रक्टर और डिस्ट्रक्टर का उपयोग केवल मूल चर को शुरू करने के लिए किया जाता है जो विगेट्स और / या एक्शन (एक्शन) नहीं हैं।

 bool DoNothingPlugin::initialize(const QStringList &arguments, QString *errorString) { // Register objects in the plugin manager's object pool // Load settings // Add actions to menus // connect to other plugins' signals // "In the initialize method, a plugin can be sure that the plugins it // depends on have initialized their members." Q_UNUSED(arguments) Q_UNUSED(errorString) Core::ActionManager *am = Core::ICore::instance()->actionManager(); QAction *action = new QAction(tr("DoNothing action"), this); Core::Command *cmd = am->registerAction(action, Constants::ACTION_ID, Core::Context(Core::Constants::C_GLOBAL)); cmd->setDefaultKeySequence(QKeySequence(tr("Ctrl+Alt+Meta+A"))); connect(action, SIGNAL(triggered()), this, SLOT(triggerAction())); Core::ActionContainer *menu = am->createMenu(Constants::MENU_ID); menu->menu()->setTitle(tr("DoNothing")); menu->addAction(cmd); am->actionContainer(Core::Constants::M_TOOLS)->addMenu(menu); return true; }

आरटीई क्रिएटर को तब कहा जाता है जब Qt Creator यह तय करता है कि एक्सटेंशन को इनिशियलाइज़ करने का समय आ गया है। यह फ़ंक्शन प्रारंभिक अवस्था को आरंभ करने और क्यूटी क्रिएटर में एक्सटेंशन से संबंधित सभी कार्यों और वस्तुओं को पंजीकृत करने के लिए डिज़ाइन किया गया है।

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

अब हमें केवल यह जानना चाहिए कि यदि आरंभीकरण सफल हो जाता है, तो यह फ़ंक्शन सही लौटना चाहिए, यदि यह विफल हो जाता है, तो गलत वापस लौटाएं और त्रुटि संदेश को त्रुटिशील स्ट्रिंग में मानव भाषा में लिखें।

 void DoNothingPlugin::extensionsInitialized() { // Retrieve objects from the plugin manager's object pool // "In the extensionsInitialized method, a plugin can be sure that all // plugins that depend on it are completely initialized." }

प्रारंभ होने के बाद ExtensionInitialized () पद्धति को कॉल किया जाता है। मुख्य रूप से उन एक्सटेंशन के सहायक के रूप में कार्य करता है जो वर्तमान पर निर्भर करते हैं।

 ExtensionSystem::IPlugin::ShutdownFlag DoNothingPlugin::aboutToShutdown() { // Save settings // Disconnect from signals that are not needed during shutdown // Hide UI (if you add UI that is not in the main window directly) return SynchronousShutdown; }

एक्सटेंशन को मेमोरी से अनलोड किए जाने से पहले aboutToShutdown () विधि कहा जाता है।

 void DoNothingPlugin::triggerAction() { QMessageBox::information(Core::ICore::instance()->mainWindow(), tr("Action triggered"), tr("This is an action from DoNothing.")); } Q_EXPORT_PLUGIN2(DoNothing, DoNothingPlugin)

2.4 बिल्ड और टेस्ट एक्सटेंशन

हमारे एक्सटेंशन का निर्माण करने के लिए, बस कुंजी संयोजन Ctrl + R दबाएं, जिसके बाद एक्सटेंशन को असेंबल किया जाएगा और Qt Ceator की एक्सटेंशन डायरेक्टरी में इंस्टॉल किया जाएगा, लेकिन यह शुरू नहीं होगा, क्योंकि Qt Creator को यह पता नहीं है कि इस लाइब्रेरी को कैसे चलाना है। यह स्थिति एप्लिकेशन लॉन्च सेटिंग पेज (प्रोजेक्ट्स -> लॉन्च -> लॉन्च कॉन्फ़िगरेशन -> प्रोग्राम) पर तय की जा सकती है:

परिणाम लॉन्च किया जाएगा क्यूटी क्रिएटर, उन एक्सटेंशनों की सूची में जिन्हें आप एक नई लाइन देख सकते हैं:

सभी एक्सटेंशन की डायरेक्टरी में कुछ फाइलों के साथ एक नई डायरेक्टरी दिखाई दी:

 kafeg@kafeg-desktop:~/devel/Qt/qt-creator-2.4.0-src/build/lib/qtcreator/plugins/DoNothingCompany$ ls DoNothing.pluginspec libDoNothing.so

इस तरह हम क्यूटी क्रिएटर के सबसे बुनियादी विस्तार को जोड़ सकते हैं। चलिए आगे बढ़ते हैं।

3 नए मेनू और मेनू आइटम जोड़ना

इस भाग में, हम सीखेंगे कि मौजूदा मेनू में नए मेनू आइटम कैसे जोड़ें, और यह भी समझें कि अपना मेनू कैसे बनाएं। लेकिन पहले, क्यूटी निर्माता पैनल मेनू की सामग्री पर एक नज़र डालें:

पैनल में निम्नलिखित डिफ़ॉल्ट तत्व शामिल हैं:

फ़ाइल
-पहले
ओपन
-Recent फाइलें
सुधार
उन्नत
उपकरण
खिड़की
- आउटपुट पैनल
सूचना

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

क्यूटी डेवलपर्स को पता है कि क्यूमेन्यू और क्यूएशन कक्षाओं के संयोजन से मेनू स्वयं कार्यान्वित किए जाते हैं, और क्यूमेन्यूबार वर्ग उन्हें पैनल के रूप में प्रदर्शित करने के लिए जिम्मेदार है।

3.1 कोर :: एक्शन मैनेजर

क्यूटी क्रिएटर का मूल हिस्सा, यह अनिवार्य रूप से सिर्फ एक खाली खिड़की है जो एक्सटेंशन लोड कर सकता है। Qt Creator द्वारा प्रदान की गई सभी कार्यक्षमता को इसके एक्सटेंशन के माध्यम से कार्यान्वित किया जाता है। क्यूटी क्रिएटर का मुख्य विस्तार "कोर" के रूप में जाना जाता है। इस विस्तार के बिना, क्यूटी निर्माता कुछ भी नहीं है।

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

 #include <coreplugin/actionmanager/actionmanager.h> #include <coreplugin/icore.h> ... Core::ActionManager* am = Core::ICore::instance()->actionManager();

3.2 कोर :: एक्शनकंटेनर

ActionContianer Qt Creator में मेनू और मेनू बार प्रदान करता है। इस वर्ग के उदाहरणों को कभी भी सीधे नहीं बनाया जाता है, वे एक्शन मैनजर :: createMenu (), ActionManager :: createMenuBar () और अन्य के माध्यम से एक्सेस किए जाते हैं।

डिफ़ॉल्ट रूप से सभी मेनू से जुड़े ActionContainer के उदाहरण हैं। ActionContainer का एक उदाहरण प्राप्त करने के लिए, आपको निम्नलिखित कोड का उपयोग करना होगा:

 #include <coreplugin/coreconstants.h> #include <coreplugin/actionmanager/actionmanager.h> #include <coreplugin/icore.h> Core::ActionManager* am = Core::ICore::instance()->actionManager(); Core::ActionContainer* ac = am->actionContainer( ID );

निम्न तालिका डिफ़ॉल्ट आईडी दिखाती है जो आपको ActionContainer इंस्टेंसेस प्राप्त करने की अनुमति देती है। कोर दृश्यता अंतरिक्ष में आईडी कास्ट चार * स्थिर चर हैं।

मेन्यू	आईडी
फ़ाइल	कोर :: निरंतर :: M_FILE
फ़ाइल -> नया	कोर :: निरंतर :: M_FILE_NEW
फ़ाइल -> खोलें	कोर :: निरंतर :: M_FILE_OPEN
फ़ाइल -> हाल की फाइलें	कोर :: निरंतर :: M_FILE_RECENTFILES
संपादित करें	कोर :: निरंतर :: M_EDIT
संपादित करें -> उन्नत	कोर :: स्थिरांक :: M_EDIT_ADVANCED
उपकरण	कोर :: स्थिरांक :: M_TOOLS
खिड़की	कोर :: निरंतर :: M_WINDOW
खिड़की के शीशे	कोर :: स्थिरांक :: M_WINDOW_PANES
सहायता	कोर :: निरंतर :: M_HELP

उदाहरण के लिए, यदि हम "सहायता" मेनू के लिए एक संकेतक प्राप्त करना चाहते हैं, तो हमें निम्नलिखित कोड का उपयोग करना चाहिए:

 #include <coreplugin/coreconstants.h> #include <coreplugin/actionmanager/actionmanager.h> #include <coreplugin/icore.h> ... Core::ActionManager* am = Core::ICore::instance()->actionManager(); Core::ActionContainer* ac = am->actionContainer( Core::Constants::M_HELP );

3.3 मेनू और मेनू आइटम जोड़ना

आइए देखें कि हम नए मेनू आइटम कैसे जोड़ सकते हैं। ऐसा करने के लिए, चलिए अपने मौजूदा फंक्शन इनिशियलाइज़ () पर लौटते हैं और इसके कार्यान्वयन को और अधिक विस्तार से देखते हैं।

 bool DoNothingPlugin::initialize(const QStringList &arguments, QString *errorString) { Q_UNUSED(arguments) Q_UNUSED(errorString) Core::ActionManager *am = Core::ICore::instance()->actionManager(); QAction *action = new QAction(tr("DoNothing action"), this); Core::Command *cmd = am->registerAction(action, Constants::ACTION_ID, Core::Context(Core::Constants::C_GLOBAL)); cmd->setDefaultKeySequence(QKeySequence(tr("Ctrl+Alt+Meta+A"))); connect(action, SIGNAL(triggered()), this, SLOT(triggerAction())); Core::ActionContainer *menu = am->createMenu(Constants::MENU_ID); menu->menu()->setTitle(tr("DoNothing")); menu->addAction(cmd); am->actionContainer(Core::Constants::M_TOOLS)->addMenu(menu); return true; }

यहाँ दिखाया गया कोड अब बहुत अधिक समझ में आता है। तो, हमें ActionManager को एक पॉइंटर मिलता है, फिर एक नया मेनू आइटम बनाते हैं और इसे कीबोर्ड शॉर्टकट असाइन करते हैं। फिर हम अपना खुद का मेनू बनाते हैं और उसमें उस आइटम को जोड़ते हैं जो हमने अभी बनाया था। यह भी ध्यान देने योग्य है कि अब स्थिरांक ACTION_ID और MENU_ID काम में आए।

इसके बाद, हमें ActionContainer टूल मेनू (M_TOOLS) का पॉइंटर मिलता है और उसमें अपना मेन्यू जोड़ते हैं।
इसके अलावा, हमारे कीबोर्ड शॉर्टकट को एप्लिकेशन में सभी कीबोर्ड शॉर्टकट की रजिस्ट्री में दर्ज किया गया था और इसकी सेटिंग्स में बदलाव के लिए उपलब्ध है:

यह भी ध्यान दिया जाना चाहिए कि आप कहीं भी अपना मेनू जोड़ सकते हैं। उदाहरण के लिए, यदि हमें अपने मेनू को मुख्य मेनू बार में जोड़ना होगा, तो M_TOOLS स्थिर के बजाय, हम MENU_BAR स्थिरांक का उपयोग करेंगे। और हमारे मेनू को किसी अन्य मेनू के अंदर रखने के लिए, हमें एडमेनू () फ़ंक्शन के लिए एक अतिरिक्त पैरामीटर पास करना चाहिए

 am->actionContainer(Core::Constants::MENU_BAR)->addMenu(am->actionContainer(Core::Constants::M_HELP), menu);

3.3 मेनू आइटम घटनाओं का जवाब

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

 ... connect(action, SIGNAL(triggered()), this, SLOT(triggerAction())); ... void DoNothingPlugin::triggerAction() { QMessageBox::information(Core::ICore::instance()->mainWindow(), tr("Action triggered"), tr("This is an action from DoNothing.")); }

4 क्यूटी निर्माता वास्तुकला

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

4.1 कोर क्यूटी निर्माता

क्यूटी क्रिएटर का कोर सिर्फ एक एक्सटेंशन मैनेजर है। उनके माध्यम से सभी कार्यक्षमता प्रदान की जाती हैं।

Qt Creator की मूल कार्यक्षमता को कोर एक्सटेंशन (Core :: ICore) में लागू किया गया है। हम पिछले हिस्से में पहले ही इस विस्तार को छू चुके हैं। अगला, हम इस विस्तार को कोर के रूप में संदर्भित करेंगे। एक्सटेंशन मैनेजर (ExtensionSystem :: PluginManager) हुक के माध्यम से एक्सटेंशन की बातचीत के लिए सरल विकल्प प्रदान करता है जो कुछ एक्सटेंशन दूसरों को प्रदान कर सकते हैं।

४.२ विस्तार क्या है?

सिस्टम स्तर पर, एक एक्सटेंशन एक साझा पुस्तकालय (विंडोज पर DLL, लिनक्स पर SO, मैक पर DYLIB) है। डेवलपर के दृष्टिकोण से, एक एक्सटेंशन एक मॉड्यूल है जो:

एक्सटेंशनसिस्टम को लागू करता है और लागू करता है :: IPlugin इंटरफ़ेस। पाठ में आगे हम एक समान वर्ग को "प्लगिन क्लास" कहेंगे।
Q_EXPORT_PLUGIN मैक्रो का उपयोग करके प्लगइन वर्ग को निर्यात करता है।
एक्सटेंशन के बारे में मेटाडेटा युक्त (प्लगिन नाम) .pluginspec फ़ाइल प्रदान करता है।
एक या एक से अधिक ऑब्जेक्ट्स प्रदान करता है जिन्हें अन्य एक्सटेंशन का उपयोग करने में रुचि हो सकती है।
अन्य एक्सटेंशन द्वारा प्रदान की गई एक या अधिक वस्तुओं की उपलब्धता की जांच करता है।

हम पहले तीन अंकों के साथ पहले ही मिल चुके हैं, लेकिन कहीं न कहीं हम अंतिम दो पर आ गए हैं।

4.2.1 उपलब्ध वस्तुओं की सूची कैसे प्राप्त करें?

उपलब्ध वस्तुओं को PluginManager के अंदर ऑब्जेक्ट पूल में संग्रहीत किया जाता है। PluginManager से allObjects () विधि ऑब्जेक्ट के पूरे पूल को QObject की ओर इशारा करती है। नीचे वह कोड है जिसके साथ हम उपलब्ध वस्तुओं की सूची प्रिंट कर सकते हैं:

 #include <extensionsystem/pluginmanager.h> ExtensionSystem::PluginManager *pm = ExtensionSystem::PluginManager::instance(); QList<QObject*> objects = pm->allObjects(); QListWidget* listWidget = new QListWidget; Q_FOREACH(QObject* obj, objects) { QString objInfo = QString("%1 (%2)") .arg(obj->objectName()) .arg(obj->metaObject()->className()); listWidget->addItem(objInfo); } listWidget->show();

इस प्रकार, कोड के इस भाग को निष्पादित करने के बाद, हम अपने पास उपलब्ध वस्तुओं की एक लंबी सूची देखेंगे:

सूची में नामों से, हम यह निष्कर्ष निकाल सकते हैं कि वस्तुओं को विभिन्न एक्सटेंशन द्वारा प्रदान किया गया है। मुझे लगता है कि अब हम "प्रदान की गई वस्तु" शब्द की अधिक सटीक परिभाषा दे सकते हैं:

प्रदान की गई (निर्यात की गई) वस्तु QObject क्लास (या उसके वंशज) का एक उदाहरण है जो एक एक्सटेंशन द्वारा प्रदान की जाती है और वस्तुओं के पूल के माध्यम से अन्य एक्सटेंशन के लिए उपलब्ध है।

4.2.2 उपलब्ध वस्तु की सूची में अपनी वस्तु का निर्यात कैसे करें?

इस उद्देश्य के लिए तीन तरीके हैं:

IPlugin :: addAutoReleasedObject (QObject *)
IPlugin :: addObject (QObject *)
PluginManager :: addObject (QObject *)

IPlugin :: addObject () और IPlugin :: addAutoReleasedObject () विधियाँ अनिवार्य रूप से PluginManager :: addObject () विधि को कॉल करती हैं।
IPlugin तरीके सिर्फ सुविधा के लिए हैं। वस्तुओं को जोड़ने के लिए उनका उपयोग करने के लिए एक्सटेंशन की सिफारिश की जाती है। AddAutoReleasedObject () और addObject () विधियों के बीच अंतर यह है कि पहली विधि के माध्यम से जोड़े गए ऑब्जेक्ट स्वचालित रूप से नष्ट हो जाएंगे और एक्सटेंशन के नष्ट होने पर उपलब्ध ऑब्जेक्ट्स (रिवर्स ऑर्डर में) के पूल से हटा दिए जाएंगे। इसके अलावा, किसी भी समय, आप उपलब्ध पूल से ऑब्जेक्ट को मैन्युअल रूप से हटाने के लिए IPlugin :: removeObject (QObject *) विधि कह सकते हैं।

4.2.3 किन वस्तुओं को निर्यात करना है?

एक्सटेंशन किसी भी ऑब्जेक्ट को प्रदान (निर्यात) कर सकते हैं, लेकिन आमतौर पर निर्यात की गई वस्तुओं को कार्यात्मक आधार पर संरचित किया जाता है। अन्य Qt निर्माता कार्यक्षमता निर्यात इंटरफेस के माध्यम से प्रदान की जाती है। यहाँ उनमें से कुछ हैं:

कोर :: InavigationWidgetFactory
कोर :: IEditor
कोर :: IOptionsPage
कोर :: IOutputPane
कोर :: IWizard

सी ++ डेवलपर्स इस तथ्य के आदी हैं कि कक्षाएं आमतौर पर इंटरफेस कहलाती हैं, जिनमें से सभी तरीके विशुद्ध रूप से आभासी और सार्वजनिक हैं। Qt Creator में, इंटरफेस QObject के वंशज हैं जिनके पास एक या अधिक विशुद्ध रूप से आभासी तरीके हैं।

यदि एक्सटेंशन में ऐसी वस्तुएँ हैं जो किसी भी इंटरफ़ेस को लागू करती हैं, तो ऐसी वस्तु को निर्यात किया जाना चाहिए। उदाहरण के लिए, यदि एक्सटेंशन INavigationWidgetFactory इंटरफ़ेस के कार्यान्वयन का निर्यात करता है, तो कोर इसे नेविगेशन पैनल में प्रदर्शित करने के लिए इस कार्यान्वयन में बनाए गए विजेट को स्वचालित रूप से उठाएगा। एक उदाहरण के रूप में, कोर के कार्यान्वयन के माध्यम से नेविगेशन बार में एक साधारण qtablewidget जोड़ने पर विचार करें: INavigationWidgetFit इंटरफ़ेस।

 #include <coreplugin/inavigationwidgetfactory.h> #include <QTableWidget> class NavWidgetFactory : public Core::INavigationWidgetFactory { public: NavWidgetFactory() { } ~NavWidgetFactory() { } Core::NavigationView createWidget() { Core::NavigationView view; view.widget = new QTableWidget(50, 3); return view; } QString displayName() const { return "Spreadsheet"; } int priority() const { return 0; } QString id() const { return "Spreadsheet"; } }; bool DoNothingPlugin::initialize(const QStringList &arguments, QString *errorString) { ... // Provide a navigation widget factory. // Qt Creator's navigation widget will automatically // hook to our INavigationWidgetFactory implementation, which // is the NavWidgetFactory class, and show the QTableWidget // created by it in the navigation panel. addAutoReleasedObject(new NavWidgetFactory); return true; }

और यहाँ परिणाम है:

४.२.४ नए निर्यात किए गए सुविधाओं की अधिसूचना।

जब PluginManager :: addObject () विधि कहलाती है, तो PluginManager एक objectAdded संकेत (QObject *) भेजता है। यह संकेत ट्रैक करने के लिए इस्तेमाल किया जा सकता है कि क्यूटी क्रिएटर चलने के दौरान कौन सी वस्तुएं नई जोड़ी गई थीं।

जाहिर है, एक्सटेंशन इस सिग्नल को इसके किसी भी स्लॉट से कनेक्ट करने के बाद ही प्रोसेस कर सकता है, और इसलिए, यह पूरी तरह से इनिशियलाइज़ेशन के बाद जोड़े गए ऑब्जेक्ट्स के बारे में केवल नोटिफिकेशन प्राप्त करेगा।

आमतौर पर, इस सिग्नल से जुड़ा एक स्लॉट एक या अधिक इंटरफेस की निगरानी करता है। उदाहरण के लिए, यह कोड की तरह लग सकता है जो कि एक नई वस्तु की उपस्थिति का अनुसरण करता है जो INavigationWidgetFactory इंटरफ़ेस को लागू करता है।

 void Plugin::slotObjectAdded(QObject * obj) { INavigationWidgetFactory *factory = Aggregation::query<INavigationWidgetFactory>(obj); if(factory) { // use it here... } }

4.2.4 वस्तु खोज

कभी-कभी एक एक्सटेंशन को एप्लिकेशन में एक ऑब्जेक्ट खोजने की आवश्यकता हो सकती है जो निश्चित कार्यक्षमता प्रदान करता है। अब हम ऐसी वस्तुओं की खोज करने के दो तरीके जानते हैं:

PluginManager :: allObjects () विधि, जो सभी उपलब्ध वस्तुओं की सूची लौटाती है।
सिग्नल से कनेक्ट करें PluginManager :: objectAdded (), जो आपको नई जोड़ी गई वस्तुओं के बारे में एक सूचना प्राप्त करने की अनुमति देता है।

इन विधियों का उपयोग करके, डेवलपर वस्तुओं को ट्रैक कर सकता है। लेकिन वस्तुओं को खोजने के बारे में क्या? इन उद्देश्यों के लिए, PluginManager :: getObjects () विधि है। उदाहरण के लिए, यदि हम उन सभी वस्तुओं को ढूंढना चाहते हैं जो इनविजिविटिगवेटफैक्टरी इंटरफेस को लागू करती हैं, तो हम निम्नलिखित कोड का उपयोग करेंगे:

 ExtensionSystem::PluginManager* pm = ExtensionSystem::PluginManager::instance(); QList<Core::INavigationWidgetFactory*> objects = pm->getObjects<Core::INavigationWidgetFactory>();

4.3 वस्तुओं का एकत्रीकरण

एकत्रीकरण की सहायता से, हम कई विषम QObjects को एक वस्तु में एकत्रित कर सकते हैं। Qt Creator आमतौर पर कई इंटरफेस को संयोजित करने के लिए इस दृष्टिकोण का उपयोग करता है।

 #include <aggregation/aggregate.h> class Interface1 : public QObject { Q_OBJECT public: Interface1() { } ~Interface1() { } }; class Interface2 : public QObject { Q_OBJECT public: Interface2() { } ~Interface2() { } }; Aggregation::Aggregate bundle; bundle.add(new Interface1); bundle.add(new Interface2);

अब बंडल ऑब्जेक्ट में दो ऑब्जेक्ट पर पॉइंटर्स होते हैं। इंटरफेस का उपयोग करने के लिए, हम निम्नलिखित कोड का उपयोग कर सकते हैं:

 Interface1* iface1Ptr = Aggregation::query<Interface1>( &bundle ); Interface2* iface2Ptr = Aggregation::query<Interface2>( &bundle );

आप एक बंडल में कई इंटरफेस शामिल कर सकते हैं:

 Aggregation::Aggregate bundle; bundle.add(new Interface1); bundle.add(new Interface2); bundle.add(new Interface1); bundle.add(new Interface1); QList<Interface1*> iface1Ptrs = Aggregation::query_all<Interface1>( &bundle );

और दोनों जोड़ा इंटरफेस और बंडल को भी हटा दें:

 Aggregation::Aggregate* bundle = new Aggregation::Aggregate; bundle->add(new Interface1); bundle->add(new Interface2); Interface1* iface1Ptr = Aggregation::query<Interface1>(bundle); delete iface1Ptr; // deletes the bundle and all objects in it // same as delete bundle

अब यह स्पष्ट नहीं हो सकता है कि एग्रीगेशन का उल्लेख :: समुच्चयबोधक वस्तुओं का यहाँ होना आवश्यक है, लेकिन निम्नलिखित भागों में यह वर्णित उदाहरणों के कार्यान्वयन और संरचना को सरल बनाने के लिए हमारे लिए उपयोगी होगा।

5 एक नया संपादक जोड़ना (संपादक)

एक बुनियादी स्तर (एक ही कोर प्लगइन) पर, क्यूटी निर्माता एक पाठ संपादक से ज्यादा कुछ नहीं है। हालांकि, उपयुक्त एक्सटेंशन के साथ, इसकी क्षमताओं में काफी विस्तार किया गया है: विभिन्न भाषाओं के लिए वाक्यविन्यास हाइलाइटिंग, C ++ कोड का उपयोग करके रिफलेक्टरिंग और नेविगेशन टूल, और एक टेक्स्ट एडिटर में बहुत अधिक दिखाई देता है। UI (Qt Designer), JS / QML, QRC संसाधन फ़ाइलें, प्रोजेक्ट फ़ाइलें (PRO / PRI), साथ ही प्रकार EXE / DLL / SO की फ़ाइलों के संपादन के लिए एक हेक्स संपादक के संपादन के लिए उपकरण हैं।

इस भाग में, हम एक उदाहरण के रूप में HTML प्रारूप का उपयोग करके अपने स्वयं के फ़ाइल स्वरूपों के लिए संपादकों को बनाने का तरीका समझेंगे। जब हम संपादक के साथ होते हैं, तो हम संपादक को HTML फ़ाइल अपलोड करते हैं और देखते हैं कि क्या होता है।

5.1 बेस क्लास और इंटरफेस

नए संपादक के लिए समर्थन जोड़ने के लिए, हमें चाहिए:

कोर :: IPlugin वर्ग को लागू करें, जो कोर के कार्यान्वयन का निर्यात करता है :: IEditorFactory इंटरफ़ेस। हमने यह पहले सीखा था।
कोर लागू करें: IEditorFactory इंटरफ़ेस। यह इंटरफ़ेस आपको आवश्यक संपादक बनाने की अनुमति देगा, यह उस पर दिए गए माइम प्रकार के आधार पर।
कोर :: IEditor इंटरफ़ेस के कार्यान्वयन के माध्यम से, फ़ाइल संपादक को स्वयं लागू करें। यह कार्यान्वयन एक विजेट प्रदान करेगा जो आपको उनके प्रकार (उदाहरण के लिए: HTML, ODF और अन्य) के आधार पर फ़ाइलों को संपादित करने की अनुमति देता है। संपादक के पास उस फ़ाइल तक पहुंच होनी चाहिए जो वर्तमान में संपादित / प्रदर्शित की जा रही है।
कोर :: इफाइल इंटरफेस लागू करें, जो हार्ड ड्राइव पर फाइलों को लोड करने / सहेजने में मदद करेगा।

अब हम इनमें से प्रत्येक इंटरफेस पर विचार करेंगे।

5.1.1 इंटरफ़ेस कोर :: IFile।

यह इंटरफ़ेस फ़ाइलों और उपयोगकर्ता इंटरफ़ेस के साथ काम करने के बीच एक अमूर्त परत है। यह फ़ाइलों को लोड करने / सहेजने, फ़ाइल नाम सेट करने के लिए विशुद्ध रूप से आभासी तरीके प्रदान करता है, और एप्लिकेशन को फ़ाइल के माइम प्रकार को निर्धारित करने और कुछ झंडे के मूल्यों को प्राप्त करने में भी मदद करता है (उदाहरण के लिए, "संशोधित" और "केवल पढ़ने के लिए")। यह इंटरफ़ेस src / plugins / coreplugin / ifile.h फ़ाइल में घोषित किया गया है :

सवाल उठता है - अगर QFile पहले से मौजूद है तो मुझे IFile की आवश्यकता क्यों है? यहाँ जवाब है:

IFile डेटा को सीधे Core :: IEditor में लोड करता है, QFile के विपरीत, जो एक फाइल को QByteArray में लोड करता है
जब उपयोगकर्ता संपादक में फ़ाइल को संपादित करना शुरू करता है, तो IFile एक संशोधित () संकेत भेज सकता है, लेकिन सामग्री अपरिवर्तित रहती है। QFile बाइट्स भेजता है (डिस्क की सामग्री को बदलने के बाद ही)।
IFile मॉनिटर करता है कि क्या डिस्क पर कोई अन्य फ़ाइल किसी अन्य प्रोग्राम द्वारा बदल दी गई है और यदि हां, तो उसे फिर से लोड करने की पेशकश करता है। कुछ भी करने के लिए इसी तरह की कार्यक्षमता QFile।

5.1.2 इंटरफ़ेस कोर :: IEditor।

इस इंटरफ़ेस के कार्यान्वयन विभिन्न फ़ाइल प्रकारों के लिए संपादकों को प्रदान करते हैं। में घोषित src / plugins / coreplugin / editormanager / ieditor.h

कोर :: IEditor मुख्य रूप से sludeyuschemu तक पहुँच प्रदान करता:

संपादन विजेट (विधि कोर :: IEditor :: विजेट ()), जिसे Qt निर्माता संपादित फ़ाइल की सामग्री को प्रदर्शित करने के लिए उपयोग करता है।
कोर :: IEditor :: फ़ाइल () विधि, जो कोर :: IFile के लिए एक संकेतक है, जिसे Qt Creator डिस्क के साथ काम करने के लिए उपयोग कर सकता है।
एक वैकल्पिक टूलबार जो क्यूटी क्रिएटर को प्रदर्शित कर सकता है जब संपादक सक्रिय हो जाता है।
फ़ाइल में वर्तमान कर्सर स्थिति (कोर :: IEditor :: currentLine () और Core :: IEditor :: currentColumn ())।
खुली फाइलों की सूची में दिखाई देने वाला नाम,

नीचे दिए गए स्क्रीनशॉट से आप देख सकते हैं कि क्या स्थित है।

5.1.3 कोर :: IEditorFactory इंटरफ़ेस

इस इंटरफ़ेस शो के कार्यान्वयन से तत्काल माइम प्रकार के लिए कोर :: IEditor त्वरित करने के तरीके मिलते हैं। Src / plugins / coreplugin / editormanager / ieditorfactory.h में विज्ञापन।

IEditorFactory :: mimeType () विधि संपादक द्वारा समर्थित माइम प्रकार लौटाती है। IEditorFactory :: createEditor () विधि एक विशिष्ट संपादक बनाती है।

5.1.4 कोर :: MimeDatabase Class

कोर :: MimeDatabase Qt Creator में समर्थित सभी माइम प्रकारों को संग्रहीत करता है। यह एक विशिष्ट फ़ाइल के माइम प्रकार को प्राप्त करने में भी मदद करता है। एक उदाहरण:

 #include <coreplugin/mimedatabase.h> Core::ICore* core = Core::ICore::instance(); Core::MimeDatabase* mdb = core->mimeDatabase(); Core::MimeType type1 = mdb->findByFile( QFileInfo("C:/Temp/sample.html") ); qDebug("File Type for sample.html = %s", qPrintable(type1.type())); Core::MimeType type2 = mdb->findByFile( QFileInfo("C:/Temp/TextEdit/Main.cpp") ); qDebug("File Type for Main.cpp = %s", qPrintable(type2.type())); Core::MimeType type3 = mdb->findByFile( QFileInfo("C:/Temp/TextEdit/TextEdit.pro") ); qDebug("File Type for TextEdit.pro = %s", qPrintable(type3.type()));

और निष्कर्ष:

 File Type for sample.html = text/plain File Type for Main.cpp = text/x-c++src File Type for TextEdit.pro = text/plain

काम करने के लिए, कोर :: MimeDatabase किसी भी तरह से फ़ाइल के माइम प्रकार को प्राप्त करने के लिए फ़ाइल प्रत्यय, पैटर्न और अन्य जादुई क्रियाओं का उपयोग करती है। आइए एक उदाहरण का उपयोग करके इसके माइम प्रकार द्वारा फ़ाइल खोलने की प्रक्रिया देखें:

उपयोगकर्ता फ़ाइल खोलता है (फ़ाइल -> खोलें)।
Qt Creator चयनित फ़ाइल के माइम-प्रकार को निर्धारित करने के लिए Core :: MimeDatabase का उपयोग करता है।
Qt क्रिएटर सभी कोर :: IEditorFactory को उनके माइम प्रकार के लिए स्कैन करता है।
Qt Creator ने Core :: IEditorFactory को Core :: IEditor का उदाहरण बनाने के लिए कहा।
कार्यक्षेत्र :: IEditor :: विजेट () द्वारा लौटाया गया विजेट कार्यक्षेत्र में प्रदर्शित होता है।
विधि कोर :: IEditor :: open () को पहले चरण में चयनित फ़ाइल नाम के साथ कहा जाता है।

5.1.5 एक नया माइम प्रकार जोड़ना

यदि हम नए संपादक के लिए समर्थन जोड़ना चाहते हैं, तो हमें हमारे नए संपादक द्वारा समर्थित माइम प्रकार को कोर :: MimeDatabase में पंजीकृत करना होगा। इसे करने के कई तरीके हैं, अब हम XML फ़ाइल बनाकर सरलतम तरीके से देखेंगे। उदाहरण के लिए, हम एक टेक्स्ट / html माइम प्रकार को पंजीकृत करना चाहते हैं और इसे * .html फ़ाइलों के साथ जोड़ते हैं। हम एक XML फ़ाइल बनाते हैं और इसे टेक्स्ट-html-mimetype.xml के रूप में सहेजते हैं :

 <?xml version="1.0" encoding="UTF-8"?> <mime-info xmlns='http://www.freedesktop.org/standards/shared-mime-info'> <mime-type type="text/html"> <sub-class-of type="text/plain"/> <comment>HTML File</comment> <glob pattern="*.html"/> </mime-type> </mime-info>

अब हम इस mime प्रकार को कोर :: MimeDatabase :: addMimeTypes () विधि के माध्यम से पंजीकृत कर सकते हैं:

 Core::ICore* core = Core::ICore::instance(); Core::MimeDatabase* mdb = core->mimeDatabase(); QString errMsg; bool success = mdb->addMimeTypes("text-html-mimetype.xml", errMsg);

जैसे ही हमने ऐसा किया, क्यूटी क्रिएटर तुरंत सभी * .html फाइलों को माइम टाइप टेक्स्ट / html के साथ जोड़ना शुरू कर दिया।

5.2 क्यूटी निर्माता HTML संपादक का विस्तार करें।

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

वर्ग	आधार वर्ग	विवरण
HtmlEditorWidget	QTabWidget	यह दो टैब के साथ एक विजेट होगा, पहले पर अंतिम परिणाम दिखाया गया है, और दूसरे पर दस्तावेज़ का स्रोत।
HtmlFile	कोर :: IFile	HtmlEditorWidget के लिए IFile इंटरफ़ेस का कार्यान्वयन।
एचटीएमएल एडिटर	कोर :: IEditor	HtmlEditorWidget को नियंत्रित करने और HtmlFile के साथ इसके इंटरैक्शन को नियंत्रित करने के लिए IEDitor इम्प्लीटर।
HtmlEditorFactory	कोर :: IEditorFactory	"टाइप / html" माइम प्रकार के आधार पर IEditor के उदाहरण बनाने के लिए IEDitorFactory लागू करता है।
HtmlEditorPlugin	कोर :: IPlugin	इप्लिमेंट्स IPlugin Qt क्रिएटर के साथ उपरोक्त सभी को संवाद करने के लिए।

तो, हम क्यूटी क्रिएटर मॉड्यूल की एक नई परियोजना बनाते हैं, इसे उदाहरण के लिए HTMLEditor कहते हैं, और पढ़ते हैं।

5.2.1 HTML संपादक विजेट लागू करना

डिफ़ॉल्ट रूप से, क्यूटी क्रिएटर HTML फ़ाइलों को देखने के लिए एक साधारण टेक्स्ट एडिटर का उपयोग करता है। हम एक दो-टैब संपादक बना रहे हैं, जिसके एक टैब पर आप पृष्ठ देख सकते हैं, और दूसरे पर - इसे संपादित करें।

 #ifndef HTMLEDITORWIDGET_H #define HTMLEDITORWIDGET_H #include <QTabWidget> #include <QWebView> #include <QPlainTextEdit> struct HtmlEditorWidgetData { QWebView *webView; QPlainTextEdit *textEdit; bool modified; QString path; }; class HtmlEditorWidget : public QTabWidget { Q_OBJECT public: HtmlEditorWidget(QWidget* parent = 0); ~HtmlEditorWidget(); void setContent(const QByteArray& ba, const QString& path=QString()); QByteArray content() const; QString title() const; protected slots: void slotCurrentTabChanged(int tab); void slotContentModified(); signals: void contentModified(); void titleChanged(const QString&); private: HtmlEditorWidgetData* d; }; #endif // HTMLEDITORWIDGET_H

डिजाइनर दो QWebView और QPlainTextEdit विजेट बनाता है, फिर वह उन्हें वर्तमान विजेट के टैब के रूप में जोड़ता है और तीन कनेक्शन बनाता है:

जब उपयोगकर्ता स्रोत को देखने से संपादित करने से आगे बढ़ता है, तो QWeBView की सामग्री को अपडेट किया जाना चाहिए
जब उपयोगकर्ता सामग्री बदलता है, तो संकेत भेजना आवश्यक है
अंत में, आपको QWebView हेडर में परिवर्तन की निगरानी करने की आवश्यकता है।

 #include "htmleditorwidget.h" HtmlEditorWidget::HtmlEditorWidget(QWidget* parent) :QTabWidget(parent) { d = new HtmlEditorWidgetData; d->webView = new QWebView; d->textEdit = new QPlainTextEdit; addTab(d->webView, "Preview"); addTab(d->textEdit, "Source"); //setTabPosition(QTabWidget::South); setTabShape(QTabWidget::Triangular); d->textEdit->setFont( QFont("Courier", 12) ); connect(this, SIGNAL(currentChanged(int)), this, SLOT(slotCurrentTabChanged(int))); connect(d->textEdit, SIGNAL(textChanged()), this, SLOT(slotContentModified())); connect(d->webView, SIGNAL(titleChanged(QString)), this, SIGNAL(titleChanged(QString))); d->modified = false; }

विध्वंसक केवल निजी वस्तु को हटाता है:

 HtmlEditorWidget::~HtmlEditorWidget() { delete d; }

SetContent () विधि webView और textEdit की सामग्री सेट करती है। और सामग्री () विधि तदनुसार सामग्री लौटाती है। शीर्षक () विधि एक स्ट्रिंग लौटाती है जिसे खुली फाइलों की सूची में प्रदर्शित किया जाएगा। खैर, अंतिम दो विधियां निर्माणकर्ता में बनाए गए सिग्नल कनेक्शन को संभालती हैं।

 void HtmlEditorWidget::setContent(const QByteArray& ba, const QString& path) { if(path.isEmpty()) d->webView->setHtml(ba); else d->webView->setHtml("file:///" + path); d->textEdit->setPlainText(ba); d->modified = false; d->path = path; } QByteArray HtmlEditorWidget::content() const { QString htmlText = d->textEdit->toPlainText(); return htmlText.toAscii(); } QString HtmlEditorWidget::title() const { return d->webView->title(); } void HtmlEditorWidget::slotCurrentTabChanged(int tab) { if(tab == 0 && d->modified) setContent( content(), d->path ); } void HtmlEditorWidget::slotContentModified() { d->modified = true; emit contentModified(); }

5.2.2 कोर :: IFile कार्यान्वयन

हम इस इंटरफ़ेस को HtmlFile वर्ग में लागू करते हैं। यह वर्ग कोर :: IFile से कई आभासी तरीकों को लागू करेगा और संपादित किए जा रहे दस्तावेज़ की स्थिति को प्रतिबिंबित करने के लिए संशोधित ध्वज को सेट करने में सक्षम होगा।

 #ifndef HTMLFILE_H #define HTMLFILE_H #include <coreplugin/ifile.h> #include "htmleditorconstants.h" struct HtmlFileData; class HtmlEditor; class HtmlEditorWidget; class HtmlFile : public Core::IFile { Q_OBJECT public: HtmlFile(HtmlEditor* editor, HtmlEditorWidget* editorWidget); ~HtmlFile(); void setModified(bool val=true); bool isModified() const; QString mimeType() const; bool save(QString *errorString, const QString &fileName, bool autoSave); bool reload(QString *errorString, ReloadFlag flag, ChangeType type); void rename(const QString &newName); bool open(const QString &fileName); void setFilename(const QString& filename); QString fileName() const; QString defaultPath() const; QString suggestedFileName() const; QString fileFilter() const; QString fileExtension() const; bool isReadOnly() const; bool isSaveAsAllowed() const; void modified(ReloadBehavior* behavior); protected slots: void modified() { setModified(true); } private: HtmlFileData* d; }; struct HtmlFileData { HtmlFileData() : mimeType(HTMLEditor::Constants::C_HTMLEDITOR_MIMETYPE), editorWidget(0), editor(0), modified(false) { } const QString mimeType; HtmlEditorWidget* editorWidget; HtmlEditor* editor; QString fileName; bool modified; }; #endif // HTMLFILE_H

कंस्ट्रक्टर में, हम बस उन संघों को उजागर करते हैं जिनकी हमें आवश्यकता होती है। विध्वंसक में, निजी ऑब्जेक्ट को हटा दें।

 #include "htmlfile.h" #include <QFile> #include <QFileInfo> #include "htmleditor.h" #include "htmleditorwidget.h" HtmlFile::HtmlFile(HtmlEditor* editor, HtmlEditorWidget* editorWidget) : Core::IFile(editor) { d = new HtmlFileData; d->editor = editor; d->editorWidget = editorWidget; } HtmlFile::~HtmlFile() { delete d; }

SetModified () विधि संशोधित ध्वज को सेट करती है और एक परिवर्तित () सिग्नल भेजती है

 void HtmlFile::setModified(bool val) { if(d->modified == val) return; d->modified = val; emit changed(); } bool HtmlFile::isModified() const { return d->modified; }

यहाँ से हम इस वर्ग के माइम प्रकार को लौटाते हैं।

 QString HtmlFile::mimeType() const { return d->mimeType; }

फ़ाइल का चयन करते समय सहेजें () विधि को कहा जाता है -> मेनू आइटम सहेजें या कीबोर्ड शॉर्टकट Ctrl + S का उपयोग करके। यह वर्तमान संबद्ध फ़ाइल में HtmlEditorWidget (textEdit से) की सामग्री संग्रहीत करता है। फिर संशोधित ध्वज को गलत पर सेट किया गया है।

 bool HtmlFile::save(const QString &fileName) { QFile file(fileName); if(file.open(QFile::WriteOnly)) { d->fileName = fileName; QByteArray content = d->editorWidget->content(); file.write(content); setModified(false); return true; } return false; }

जब आप फ़ाइल का चयन करते हैं तो ओपन () विधि को कहा जाता है -> ओपन। या तो Ctrl + O फ़ाइल को लोड करता है और इसे हमारे संपादन विजेट के सेटकंटेंट () फ़ंक्शन में भेजता है।

 bool HtmlFile::open(const QString &fileName) { QFile file(fileName); if(file.open(QFile::ReadOnly)) { d->fileName = fileName; QString path = QFileInfo(fileName).absolutePath(); d->editorWidget->setContent(file.readAll(), path); d->editor->setDisplayName(d->editorWidget->title()); return true; } return false; } bool HtmlFile::reload(QString *errorString, ReloadFlag flag, ChangeType type) { return open(d->fileName); } void HtmlFile::rename(const QString &newName) { QFile file(d->fileName); file.rename(newName); setFilename(newName); } void HtmlFile::setFilename(const QString& filename) { d->fileName = filename; } QString HtmlFile::fileName() const { return d->fileName; } QString HtmlFile::defaultPath() const { return QString(); } QString HtmlFile::suggestedFileName() const { return QString(); } QString HtmlFile::fileFilter() const { return QString(); } QString HtmlFile::fileExtension() const { return QString(); } bool HtmlFile::isReadOnly() const { return false; } bool HtmlFile::isSaveAsAllowed() const { return true; } void HtmlFile::modified(ReloadBehavior* behavior) { Q_UNUSED(behavior); }

5.2.3 कोर :: IEditor कार्यान्वयन

हम क्यूटी क्रिएटर को हमारे html संपादक विजेट का उपयोग करने और इसे एक HtmlFile के साथ जोड़ने की क्षमता देने के लिए IEditor को लागू कर रहे हैं।

 #ifndef HTMLEDITOR_H #define HTMLEDITOR_H #include <coreplugin/editormanager/ieditor.h> #include <QToolBar> struct HtmlEditorData; class HtmlFile; class HtmlEditorWidget; class HtmlEditor : public Core::IEditor { Q_OBJECT public: HtmlEditor(HtmlEditorWidget* editorWidget); ~HtmlEditor(); bool createNew(const QString& /*contents*/ = QString()); QString displayName() const; IEditor* duplicate(QWidget* /*parent*/); bool duplicateSupported() const; Core::IFile* file(); bool isTemporary() const; const char* kind() const; bool open(const QString& fileName = QString()) ; bool restoreState(const QByteArray& /*state*/); QByteArray saveState() const; void setDisplayName(const QString &title); QToolBar* toolBar(); // From Core::IContext QWidget* widget(); Core::Context context() const; QString id() const; protected slots: void slotTitleChanged(const QString& title) { setDisplayName(title); } private: HtmlEditorData* d; };

HtmlEditorData ऑब्जेक्ट HtmlEditorWidget और HtmlFile ऑब्जेक्ट्स के लिए पॉइंटर्स संग्रहीत करता है, डिस्प्लेनेम वैरिएबल का उपयोग उपयोगकर्ता को प्रदर्शित संपादक के नाम को संग्रहीत करने के लिए किया जाता है।

 struct HtmlEditorData { HtmlEditorData() : editorWidget(0), file(0) { } HtmlEditorWidget* editorWidget; QString displayName; HtmlFile* file; Core::Context context; }; #endif // HTMLEDITOR_H

कंस्ट्रक्टर खुद को इनिशियलाइज़ करता है, HtmlFile का एक उदाहरण बनाता है और तीनों ऑब्जेक्ट्स के बीच एसोसिएशन को चिपकाता है। विध्वंसक, परंपरा से, केवल निजी वस्तु को हटाता है।

 #include "htmleditor.h" #include "htmlfile.h" #include "htmleditorwidget.h" HtmlEditor::HtmlEditor(HtmlEditorWidget* editorWidget) : Core::IEditor(editorWidget) { d = new HtmlEditorData; d->editorWidget = editorWidget; d->file = new HtmlFile(this, editorWidget); //Core::UniqueIDManager* uidm = Core::UniqueIDManager::instance(); d->context = *(new Core::Context(HTMLEditor::Constants::C_HTMLEDITOR)); //<< uidm->uniqueIdentifier(HTMLEditor::Constants::C_HTMLEDITOR); connect(d->editorWidget, SIGNAL(contentModified()), d->file, SLOT(modified())); connect(d->editorWidget, SIGNAL(titleChanged(QString)), this, SLOT(slotTitleChanged(QString))); connect(d->editorWidget, SIGNAL(contentModified()), this, SIGNAL(changed())); } HtmlEditor::~HtmlEditor() { delete d; }

मानचित्रण के लिए तीन सरल कार्य।

 QWidget* HtmlEditor::widget() { return d->editorWidget; } Core::Context HtmlEditor::context() const { return d->context; } Core::IFile* HtmlEditor::file() { return d->file; }

CreateNew () विधि HtmlEditorWidget और HtmlFile की सामग्री को रीसेट करती है।

 bool HtmlEditor::createNew(const QString& contents) { Q_UNUSED(contents); d->editorWidget->setContent(QByteArray()); d->file->setFilename(QString()); return true; }

ओपन () विधि HtmlFile में खोलने के लिए फ़ाइल नाम से गुजरती है।

 bool HtmlEditor::open(const QString &fileName) { return d->file->open(fileName); }

संपादक का प्रकार लौटाता है।

 const char* HtmlEditor::kind() const { return HTMLEditor::Constants::C_HTMLEDITOR; }

displayName का उपयोग कॉम्बोबॉक्स में फ़ाइल नाम को प्रदर्शित करने के लिए किया जाता है।

 QString HtmlEditor::displayName() const { return d->displayName; } void HtmlEditor::setDisplayName(const QString& title) { if(d->displayName == title) return; d->displayName = title; emit changed(); }

अन्य विधियाँ इतनी महत्वपूर्ण नहीं हैं।

 bool HtmlEditor::duplicateSupported() const { return false; } Core::IEditor* HtmlEditor::duplicate(QWidget* parent) { Q_UNUSED(parent); return 0; } QByteArray HtmlEditor::saveState() const { return QByteArray(); } bool HtmlEditor::restoreState(const QByteArray& state) { Q_UNUSED(state); return false; } QToolBar* HtmlEditor::toolBar() { return 0; } bool HtmlEditor::isTemporary() const { return false; } QString HtmlEditor::id() const { return QString(); }

5.2.4 कार्यान्वयन कोर :: IEditorFactory

HtmlEditorFactory वर्ग कोर :: IEditorFactory इंटरफ़ेस को लागू करेगा।

 #ifndef HTMLEDITORFACTORY_H #define HTMLEDITORFACTORY_H #include <coreplugin/editormanager/ieditorfactory.h> #include <QStringList> #include "htmleditorplugin.h" struct HtmlEditorFactoryData; class HtmlEditorFactory : public Core::IEditorFactory { Q_OBJECT public: HtmlEditorFactory(HTMLEditor::Internal::HTMLEditorPlugin* owner); ~HtmlEditorFactory(); QStringList mimeTypes() const; QString kind() const; Core::IEditor* createEditor(QWidget* parent); Core::IFile* open(const QString &fileName); private: HtmlEditorFactoryData* d; }; #endif // HTMLEDITORFACTORY_H

HtmlEditorFactoryData संरचना में HtmlEditorFactory वर्ग का निजी डेटा होता है। इस संरचना का निर्माता HTMLEditor :: Constants :: C_HTMLEDITOR_MIMETYPE में निहित माइम प्रकार से इसकी शुरुआत करता है। यह संपादक प्रकार को मान HTMLEditor :: Constants :: C_HTMLEDITOR के साथ आरंभ करता है। Htmleditorconstants.h फ़ाइल में सभी स्थिरांक घोषित किए जाते हैं।

 #include "htmleditorfactory.h" #include "htmleditorconstants.h" #include <coreplugin/editormanager/editormanager.h> #include "htmleditorwidget.h" #include <QStringList> #include <coreplugin/editormanager/ieditor.h> #include "htmleditor.h" struct HtmlEditorFactoryData { HtmlEditorFactoryData() : kind(HTMLEditor::Constants::C_HTMLEDITOR) { mimeTypes << QString(HTMLEditor::Constants::C_HTMLEDITOR_MIMETYPE); } QString kind; QStringList mimeTypes; };

अगला, सरल परिचित तरीकों की एक बूंद।

 HtmlEditorFactory::HtmlEditorFactory(HTMLEditor::Internal::HTMLEditorPlugin* owner) :Core::IEditorFactory(owner) { d = new HtmlEditorFactoryData; } HtmlEditorFactory::~HtmlEditorFactory() { delete d; } QStringList HtmlEditorFactory::mimeTypes() const { return d->mimeTypes; } QString HtmlEditorFactory::kind() const { return d->kind; }

ओपन () विधि फ़ाइल नाम को संपादक प्रबंधक के पास देती है, जो बदले में या तो एक नया संपादक बनाता है, या मौजूदा में से एक को खोलता है।

 Core::IFile* HtmlEditorFactory::open(const QString& fileName) { Core::EditorManager* em = Core::EditorManager::instance(); Core::IEditor* iface = em->openEditor(fileName, d->kind); return iface ? iface->file() : 0; }

यह विधि HtmlEditor वर्ग का एक उदाहरण देता है।

 Core::IEditor* HtmlEditorFactory::createEditor(QWidget* parent) { HtmlEditorWidget* editorWidget = new HtmlEditorWidget(parent); return new HtmlEditor(editorWidget); }

5.2.5 मुख्य विस्तार वर्ग

हम दूसरे भाग में प्राप्त ज्ञान का उपयोग करके HtmlEditorPlugin वर्ग को लागू करते हैं। सत्य थोड़ा परिवर्तन है इनिशियलाइज़ () विधि।

 bool HTMLEditorPlugin::initialize(const QStringList &arguments, QString *errorString) { Q_UNUSED(arguments) Q_UNUSED(errorString) Core::ICore* core = Core::ICore::instance(); Core::MimeDatabase* mdb = core->mimeDatabase(); QString *errMsg = new QString(); if(!mdb->addMimeTypes(":/text-html-mimetype.xml", errMsg)) return false; addAutoReleasedObject(new HtmlEditorFactory(this)); return true; }

6 एक साइड नेविगेशन बार जोड़ना

Qt क्रिएटर में नेविगेशन बार एक ऐसा क्षेत्र है जिसमें घटक शामिल हो सकते हैं जैसे:

परियोजनाओं
दस्तावेज़ खोलें
बुकमार्क
फाइल सिस्टम
कक्षा अवलोकन
सिंहावलोकन
पदानुक्रम टाइप करें
और अन्य ...

इसके अलावा, हम एक साथ नहीं, बल्कि कई नेविगेशन पैनलों का उपयोग कर सकते हैं।

याद रखें, हमने पहले ही एक नेविगेशन बार को जोड़ने की कोशिश की थी जिसमें पिछले भागों में से एक में लेबल था? अब हम लगभग एक ही काम करेंगे, लेकिन हम कार्य को थोड़ा जटिल करेंगे।

6.1 कोर :: InavigationWidgetFactory

इसलिए, जहां तक हमें याद है, एक नए नेविगेशन पैनल को जोड़ने के लिए, हमें प्लगइन्स / कोरलिब / inavigationwidgetfactory.h फ़ाइल में स्थित कोर :: InavigationWidgetFactory इंटरफ़ेस का अपना कार्यान्वयन बनाने की आवश्यकता है।

6.2 पैनल के लिए विजेट तैयार करना

क्यूटी निर्माता मॉड्यूल परियोजना को फिर से बनाएं। और हम इसे FTPBrowser कहेंगे। हां, ठीक है क्योंकि मूल दस्तावेज में यह उदाहरण था। हमें इस लिंक को देखने के लिए भी डाउनलोड करना चाहिए FtpDirModel वर्ग।

अब हम अपनी परियोजना में एक नई फॉर्म क्लास बनाते हैं और फॉर्म को इस फॉर्म में लाते हैं:

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

 #include <coreplugin/inavigationwidgetfactory.h> class FtpViewNavigationWidgetFactory : public Core::INavigationWidgetFactory { public: FtpViewNavigationWidgetFactory() { } ~FtpViewNavigationWidgetFactory() { } Core::NavigationView createWidget(); QString displayName() const { return "FTP View"; } int priority() const { return 0; } QString id() const { return "Spreadsheet"; } };

CreateWidget () विधि केवल एक नया विजेट बनाती है और इसके लिए एक पॉइंटर लौटाती है। DisplayName () विधि उपयोगकर्ता को प्रदर्शित करने के लिए एक स्ट्रिंग लौटाती है।

 Core::NavigationView FtpViewNavigationWidgetFactory::createWidget() { Core::NavigationView view; view.widget = new FTPBrowserForm; return view; }

यहाँ हमें क्या मिला है:

6.3 पैनल को सहेजना और पुनर्स्थापित करना

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

 void saveSettings(int position, QWidget *widget); void restoreSettings(int position, QWidget *widget);

इन दोनों विधियों को ओवरराइड करके, हम आसानी से अपने विजेट की स्थिति को नियंत्रित कर सकते हैं। यहाँ हमारे कोड से एक छोटा सा उदाहरण है:

 void FtpViewNavigationWidgetFactory::saveSettings(int position, QWidget *widget) { FTPBrowserForm* ftpExp = qobject_cast<FTPBrowserForm*>(widget); if(!ftpExp) return; QSettings *settings = Core::ICore::instance()->settings(); settings->setValue("FtpView.URL", ftpExp->url().toString()); } void FtpViewNavigationWidgetFactory::restoreSettings(int position, QWidget *widget) { FTPBrowserForm* ftpExp = qobject_cast<FTPBrowserForm*>(widget); if(!ftpExp) return; QSettings *settings = Core::ICore::instance()->settings(); QString urlStr = settings->value("FtpView.URL").toString(); ftpExp->setUrl( QUrl(urlStr) ); }

दो सरल कार्य जिनके पैरामीटर पैनल विजेट के लिए स्थिति और सूचक हैं।

फूफ़ ... अभी के लिए बस इतना ही ... बाकी लेख प्रकाशित हो जाएगा ... कब और अगर इसे जोड़ा जाए =)

क्यूटी क्रिएटर एक्सटेंशन सिस्टम