क्यूटी: एक कस्टम इवेंट प्रकार को परिभाषित करना

Question

मैंने QEvent को उप-वर्गीकरण करके अपने क्यूटी एप्लिकेशन में एक कस्टम ईवेंट बनाया है।

class MyEvent : public QEvent 
{ 
    public: 
    MyEvent() : QEvent((QEvent::Type)2000)) {} 
    ~MyEvent(){} 
} 

आदेश इस ईवेंट की जांच करने के लिए, मैं एक घटना() विधि में निम्न कोड का उपयोग करें:

if (event->type() == (QEvent::Type)2000) 
{ 
    ... 
} 

मैं अपने आवेदन में कहीं कस्टम घटना के प्रकार परिभाषित करने में सक्षम होना चाहते हैं ताकि मुझे अपने ईवेंट विधियों में वास्तविक पूर्णांक डालने की आवश्यकता न हो। तो मेरी घटना() पद्धतियों में मैं कैसे और कहाँ कोड में मैं यह कर सकता है

if (event->type() == MyEventType) 
{ 
    ... 
} 

किसी भी विचार की तरह कुछ करने में सक्षम होना चाहते हैं?

Answer 1

घटना प्रकार अपने विशिष्ट वर्ग की पहचान करता है, मैं इसे वहाँ डाल चाहते हैं:

class MyEvent : public QEvent { 
public: 
    static const QEvent::Type myType = static_cast<QEvent::Type>(2000); 
    // ... 
}; 

// usage: 
if(evt->type() == MyEvent::myType) { 
    // ... 
} 

Answer 2

सुविधा के लिए आप रजिस्टर और एक कस्टम घटना आरक्षण QEvent :: registerEventType() स्थिर समारोह का उपयोग कर सकते अपने आवेदन के लिए टाइप करें। ऐसा करने से आप अपने आवेदन में कहीं और इस्तेमाल होने वाले कस्टम इवेंट प्रकार को गलती से दोबारा उपयोग करने से बच सकते हैं।

उदाहरण:

class QCustomEvent : public QEvent 
{ 
public: 
    QCustomEvent() : QEvent(QCustomEvent::type()) 
    {} 

    virtual ~QCustomEvent() 
    {} 

    static QEvent::Type type() 
    { 
     if (customEventType == QEvent::None) 
     { 
      int generatedType = QEvent::registerEventType() 
      customEventType = static_cast<QEvent::Type>(generatedType); 
     } 
     return customEventType; 
    } 

private: 
    static QEvent::Type customEventType; 
}; 

QEvent::Type QCustomEvent::customEventType = QEvent::None; 

Answer 3

इस तरह की समस्याओं से निपटने का मुहावरेदार भी तरह से, एक टेम्पलेट आवरण वर्ग बनाने के लिए CRTP लाभ है। प्रत्येक कस्टम इवेंट प्रकार के लिए, इस तरह का टेम्पलेट एक नए प्रकार का प्रतिनिधित्व करता है, इस प्रकार एक अलग staticType() सदस्य प्रत्येक प्रकार के लिए मौजूद है, जो इसके अद्वितीय पंजीकृत प्रकार को लौटाता है।

नीचे मैं की पहचान प्रकार के तीन तरीके दे:

1. staticType() तक - यह केवल उपयोगी भीतर आवेदन की एक मंगलाचरण है, और प्रकार QEvent साथ प्रयोग किया जा रहा है। मान को किसी एप्लिकेशन के आमंत्रण के बीच रहने की गारंटी नहीं है। वे एक लॉग इन की तरह टिकाऊ स्टोरेज में हैं।

2. localDurableType() द्वारा - वे invocations और उसी कंपाइलर के साथ recompilations के बीच जारी रहेगा। जटिल घटनाओं को परिभाषित करते समय यह durableType() विधि की मैन्युअल परिभाषा बचाता है।

3. durableType() द्वारा - वे वास्तव में क्रॉस प्लेटफॉर्म हैं और जब तक आप अपने कोड के भीतर ईवेंट क्लास नाम बदल नहीं लेते तब तक वही रहेगा। यदि आप NEW_QEVENT मैक्रो का उपयोग नहीं कर रहे हैं तो आपको durableType() मैन्युअल रूप से परिभाषित करना होगा।

दोनों localDurableType() और durableType()qHash में परिवर्तन की वजह से क्यूटी 4 और 5 betwen भिन्न होते हैं।

आप दो तरीकों में से किसी में शीर्ष लेख का उपयोग:

#include "EventWrapper.h" 

class MyComplexEvent : public EventWrapper<MyComplexEvent> { 
    // An event with custom data members 
    static int durableType() { return qHash("MyEvent"); } 
    ... 
}; 

NEW_QEVENT(MySimpleEvent) // A simple event carrying no data but its type. 

EventWrapper।एच

#ifndef EVENTWRAPPER_H 
#define EVENTWRAPPER_H 

#include <QEvent> 
#include <QHash> 

template <typename T> class EventWrapper : public QEvent { 
public: 
    EventWrapper() : QEvent(staticType())) {} 
    static QEvent::Type staticType() { 
     static int type = QEvent::registerEventType(); 
     return static_cast<QEvent::Type>(type); 
    } 
    static int localDurableType() { 
     static int type = qHash(typeid(T).name()); 
     return type; 
    } 
}; 

#define NEW_QEVENT(Name) \ 
    class Name : public EventWrapper<Name> \ 
    { static int durableType() { \ 
     static int durable = qHash(#Name); return durable; \ 
    } }; 

#endif // EVENTWRAPPER_H