🕴🏽 👨‍💼 🐀 क्यूटी गतिशीलता का उपयोग करते हुए, C ++ / Qt में कार्टोग्राफिक मोबाइल एप्लिकेशन का विकास 👨🏿‍🤝‍👨🏽 👩🏿‍🏭 🌻

यह पोस्ट " स्मार्ट फ़ोन फॉर स्मार्ट पोस्ट " प्रतियोगिता में भाग लेती है

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

सामग्री की तालिका

ग्राफिक्स देखें वास्तुकला

ग्राफिक अभ्यावेदन की वास्तुकला इस अर्थ में मॉडल / दृश्य की वास्तुकला के समान है कि इसमें QGraphicsScene डेटा संग्रहीत करने के लिए एक वर्ग है और इस डेटा QGraphicsView को देखने के लिए एक वर्ग है। यदि आवश्यक हो तो एक ही दृश्य को विभिन्न दृश्यों के साथ देखा जा सकता है। ग्राफिक दृश्य में तत्व होते हैं - अमूर्त वर्ग QGraphicsItem से प्राप्त कक्षाओं की वस्तुएं।
शुरुआत से ही, गति और विस्तार क्षमताओं को बढ़ाने के उद्देश्य से ग्राफिक अभ्यावेदन की वास्तुकला को विकसित करने में बहुत प्रयास किया गया था। दृश्यों को छोटा, घुमाया और मुद्रित किया जा सकता है, और उन्हें प्रदर्शित करने के लिए, बिल्ट-इन Qt इंजन और OpenGL लाइब्रेरी दोनों का उपयोग करें। वास्तुकला एनीमेशन और ड्रैग एंड ड्रॉप का भी समर्थन करता है। ग्राफिक दृश्य इकाइयों से हजारों तत्वों के दसियों तक प्रस्तुत करने के लिए उपयुक्त हैं, एक अच्छा चित्रण 40,000 चिप्स का उदाहरण है। QWidget से प्राप्त विजेट को भी मंच पर रखा जा सकता है, इसके लिए आपको विजेट को QGraphicsProxyWidget वर्ग के कंस्ट्रक्टर के पास करना होगा और मंच पर प्रॉक्सी विजेट रखना होगा। प्रॉक्सी विजेट (या QWidget ऑब्जेक्ट स्वयं) धीमे हैं, लेकिन क्या यह मंदी ध्यान देने योग्य होगी, यह एप्लिकेशन पर निर्भर करता है (अधिक जानकारी के लिए, QtLabs [En] देखें)।

ग्राफिक तत्वों का परिचय

QGraphicsItem वर्ग सभी ग्राफिक तत्वों का आधार वर्ग है। आप इसके उदाहरण नहीं बना सकते, क्योंकि इसमें दो विशुद्ध रूप से आभासी विधियाँ हैं: बाउंडिंग रेक्ट () और पेंट () । पेंट () विधि QWidget :: paintEvent () विधि से मेल खाती है, इसके कार्यान्वयन में एक तत्व शामिल होना चाहिए। बाउंडिंगरेक्ट () विधि तत्व के बाउंडिंग आयत के बारे में बुनियादी ढांचे को सूचित करती है - इसका उपयोग टकरावों का पता लगाने के लिए किया जाता है और दृष्टि से बाहर होने वाले तत्व को फिर से बनाने के लिए नहीं। यह वर्ग माउस और कीबोर्ड इवेंट, ड्रैग एंड ड्रॉप, तत्वों के समूह के लिए सहायता प्रदान करता है। घटना प्रसंस्करण निम्नानुसार काम करता है, दृश्य माउस और कीबोर्ड इवेंट प्राप्त करता है, फिर यह उन्हें दृश्य के लिए घटनाओं में तब्दील करता है, दृश्य के निर्देशांक के अनुसार निर्देशांक बदलता है, और फिर घटना वांछित तत्व को पारित की जाती है।

QtLocation मॉड्यूल

QtLocation मॉड्यूल डेवलपर को स्थिति संबंधी जानकारी तक पहुंचने के लिए एक सुविधाजनक इंटरफ़ेस प्रदान करता है। एपीआई आपको सूचना के स्रोत से सार करने की अनुमति देता है, जो अन्य स्रोतों से उपग्रहों या डेटा की एक सूची हो सकती है।
QtLocation नेविगेशन के विभिन्न पहलुओं से संबंधित कक्षाओं के एक सेट के साथ आता है। इसमें QGeoPositionInfoSource जैसे हार्डवेयर से संबंधित वर्ग शामिल हैं, जो एक वैश्विक पोजिशनिंग सिस्टम (GPS) या अन्य स्थान स्रोतों, और QGeoSatelicInfoSource का उपयोग करके उपयोगकर्ता की स्थिति के बारे में जानकारी प्रदान करता है, जिसका उपयोग उपग्रह पोजीशनिंग जानकारी प्राप्त करने के लिए किया जाता है।
मॉड्यूल में कई वर्ग शामिल हैं जिनका मुख्य उद्देश्य स्थान की जानकारी का वर्णन करना है, उदाहरण के लिए QGeoCoordinate , जिसमें अक्षांश, देशांतर और ऊंचाई शामिल है। QGeoBoundingBox और QGeoBoundingCircle के रूप में QtLocation भौगोलिक क्षेत्रों का प्रतिनिधित्व करने का एक तरीका प्रदान करता है, या तो एक अमूर्त रूप में, जैसे QGeoBoundingArea या अधिक सटीक।

मानचित्र और सेवाएँ

इससे पहले कि हम नक्शे, दृश्यों और विचारों के साथ काम करना शुरू कर सकें, हमें पहले भौगोलिक डेटा के स्रोत तक पहुंचना होगा। ऐसा करने का एक सामान्य तरीका QGeoServiceProvider का उपयोग करना है । यह पता लगाने के लिए कि कौन-सी सेवाएँ उपलब्ध हैं, आप QGeoServiceProvider :: availableServiceProviders () का उपयोग कर सकते हैं, जो यदि कोई सेवाएँ उपलब्ध नहीं हैं, तो एक खाली QStringList लौटा देगा, इसलिए डेवलपर को इस विकल्प की जाँच करनी चाहिए:

QStringList services = QGeoServiceProvider::availableServiceProviders(); if (services.isEmpty()) { //      }

एक बार सेवा प्रदाता प्राप्त हो जाने के बाद, हम QGeoMappingManager प्राप्त कर सकते हैं, जो हमें मानचित्र छवि प्राप्त करने की अनुमति देगा।

  QGeoMappingManager *manager = service.mappingManager();

मानचित्र या रूटिंग पर ऑब्जेक्ट खोजने के लिए प्रबंधक से अनुरोध करने के लिए, आपको searchManager () या routingManager () को कॉल करने की आवश्यकता है।
उपयोगकर्ता के लिए एक नक्शा बनाने के लिए, QtLocation हमें QGeoMappingManager से डेटा प्रदर्शित करने के लिए QGraphicsGeoMap वर्ग प्रदान करता है। हमें बस सामान्य तरीके से एक दृश्य और एक दृश्य बनाना है, और दृश्य में एक मानचित्र जोड़ना है:

  QGraphicsScene scene; QGraphicsView view; view.setScene(&scene); QGraphicsGeoMap *geoMap = new QGraphicsGeoMap(manager); scene.addItem(geoMap);

GPS निर्देशांक प्राप्त करना

GPS निर्देशांक प्राप्त करने के लिए, आपको QGeoPositionInfoSource कॉल करके QGeoPositionInfoSource बनाने की आवश्यकता है :: createDefaultSource () , जो आपको QGeoPositionInfo के निर्देशांक के बारे में विभिन्न जानकारी तक पहुँच प्रदान करता है । जिन ग्राहकों को स्थान डेटा की आवश्यकता होती है, वे स्थिति से कनेक्ट हो सकते हैं () सिग्नल ताकि QGeoPositionInfoSource startUpdates () या requestUpdate () कॉल करके इस सिग्नल को भेजना शुरू कर दे ।
ग्राहक का एक उदाहरण जो स्थान डेटा प्राप्त करता है:

  class MyClass : public QObject { Q_OBJECT public: MyClass(QObject *parent = 0) : QObject(parent) { QGeoPositionInfoSource *source = QGeoPositionInfoSource::createDefaultSource(this); if (source) { connect(source, SIGNAL(positionUpdated(QGeoPositionInfo)), this, SLOT(positionUpdated(QGeoPositionInfo))); source->startUpdates(); } } private slots: void positionUpdated(const QGeoPositionInfo &info) { qDebug() << "Position updated:" << info; } };

यदि नियमित स्थिति अपडेट की आवश्यकता होती है, तो इन अपडेट को कितनी बार होना चाहिए, यह निर्धारित करने के लिए setUpdateInterval () का उपयोग किया जा सकता है। यदि कोई अंतराल निर्दिष्ट नहीं है, तो उपलब्ध होने पर अपडेट आते हैं। उदाहरण के लिए, यदि क्लाइंट एप्लिकेशन को हर 30 सेकंड में अपडेट करने की आवश्यकता होती है:

  // Emit updates every 30 seconds if available QGeoPositionInfoSource *source = QGeoPositionInfoSource::createDefaultSource(someParent); if (source) source->setUpdateInterval(30000);

एक दिए गए समन्वय के लिए एनिमेटेड संक्रमण

इसलिए, हमें एक सामान्य विचार मिला कि सब कुछ कैसे काम करता है, अब हम कोड पर जा सकते हैं। किसी दिए गए समन्वय के लिए चिकनी मानचित्र आंदोलन बनाने के लिए, हमें QGraphicsGeoMap वर्ग द्वारा प्रदान की गई कार्यक्षमता का विस्तार करने की आवश्यकता है:

 class GeoMap : public QGraphicsGeoMap { Q_OBJECT Q_PROPERTY(double centerLatitude READ centerLatitude WRITE setCenterLatitude) Q_PROPERTY(double centerLongitude READ centerLongitude WRITE setCenterLongitude) public: GeoMap(QGeoMappingManager *manager, QGraphicsItem *parent = 0); void animatedPanTo(const QGeoCoordinate& center); double centerLatitude() const { return center().latitude(); } void setCenterLatitude(double lat); double centerLongitude() const { return center().longitude(); } void setCenterLongitude(double lon); //...

और आवेदन:

 void GeoMap::animatedPanTo(const QtMobility::QGeoCoordinate ¢er) { QGeoCoordinate curStart(this->center()); if (curStart == center) return; //        setStatusBarText(QString("Panning to %1").arg(center.toString(QGeoCoordinate::Degrees))); QPropertyAnimation *latAnim = new QPropertyAnimation(this, "centerLatitude"); latAnim->setEndValue(center.latitude()); latAnim->setDuration(300); QPropertyAnimation *lonAnim = new QPropertyAnimation(this, "centerLongitude"); lonAnim->setEndValue(center.longitude()); lonAnim->setDuration(300); QParallelAnimationGroup *group = new QParallelAnimationGroup; group->addAnimation(latAnim); group->addAnimation(lonAnim); group->start(QAbstractAnimation::DeleteWhenStopped); } void GeoMap::setCenterLatitude(double lat) { QGeoCoordinate c = center(); c.setLatitude(lat); setCenter( c); } void GeoMap::setCenterLongitude(double lon) { QGeoCoordinate c = center(); c.setLongitude(lon); setCenter( c); }

अब, जब AnimPanTo () को कॉल किया जाता है , तो मानचित्र सुचारू रूप से निर्दिष्ट समन्वय पर और इच्छित कोण पर ले जाएगा, अर्थात्। यदि वर्तमान केंद्र के संबंध में नया समन्वय अधिक है, तो नक्शा और इसी तरह आगे बढ़ेगा। चूंकि QPropertyAnimation डिफ़ॉल्ट रूप से QGeoCoordinate के साथ काम नहीं करता है, मैंने मानचित्र को दो गुणों के साथ पूरक किया है जो एनीमेशन (समर्थित प्रकारों की सूची ) के साथ काम कर सकते हैं। बेशक, आप अपने इंटरपोलर को पंजीकृत कर सकते थे और QGeoCoordinate को QVariant के लिए पंजीकृत कर सकते थे , लेकिन गुणों के साथ यह मुझे बहुत अधिक समझने योग्य और सुरुचिपूर्ण लगता है।

चुटकी का इशारा

Qt में एक जेस्चर प्रोग्रामिंग फ्रेमवर्क शामिल है जो कि इनपुट पद्धति की परवाह किए बिना, उन्हें घटनाओं की एक श्रृंखला से उत्पन्न करता है। एक इशारा एक माउस आंदोलन, टच स्क्रीन पर एक स्पर्श या अन्य स्रोतों से घटनाओं की एक श्रृंखला हो सकती है। Qt में, जेस्चर प्रोसेसिंग को निम्नलिखित वर्गों द्वारा दर्शाया गया है: QPanGesture , QPinchGesture, और QSwipeGesture । सलीवर का उपयोग छवि को बढ़ाने या कम करने के लिए किया जाता है, हमारे मामले में यह मानचित्र के पैमाने को बदल देगा। इसे कक्षा में कार्यान्वित करने के लिए, आपको इस जेस्चर को ग्रैग्योरचर (Qt :: PinchGesture) विधि कहकर सक्षम करने की आवश्यकता है और इसे हमारे मानचित्र के दृश्य () में संसाधित करें:

 bool GeoMap::sceneEvent(QEvent *event) { switch (event->type()) { case QEvent::Gesture: { if (QGestureEvent *gesture = static_cast<QGestureEvent *>(event)) { if (QPinchGesture *pinch = static_cast<QPinchGesture *>(gesture->gesture(Qt::PinchGesture))) { qreal scale = qLn(pinch->scaleFactor())/qLn(2); qreal zoom = 0; zoom = scale > 0 ? 1 : -1; setZoomLevel(zoomLevel() + zoom); return true; } } } default: break; } return QGraphicsGeoMap::sceneEvent(event); }

क्यूटी आपको इशारों के साथ, स्क्रीन पर घटनाओं को छूने की अनुमति देता है। विजेट के लिए उन्हें स्वीकार करने के लिए, आपको Qt :: WA_AcceptTouchEvents विशेषता सेट करने की आवश्यकता है, और ग्राफिक तत्वों के लिए, acceptTouchEvents (सच) को कॉल करें।

काइनेटिक स्क्रॉल

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

 protected: void mousePressEvent(QGraphicsSceneMouseEvent *event); void mouseMoveEvent(QGraphicsSceneMouseEvent *event); void mouseReleaseEvent(QGraphicsSceneMouseEvent *event); void mouseDoubleClickEvent(QGraphicsSceneMouseEvent *event); void wheelEvent(QGraphicsSceneWheelEvent *event); void keyPressEvent(QKeyEvent * event); void keyReleaseEvent(QKeyEvent * event); bool sceneEvent(QEvent *event); private slots: void kineticTimerEvent(); private: void panFloatWrapper(const QPointF & delta); void applyPan(const Qt::KeyboardModifiers & modifiers); void setStatusBarText(const QString &text); private: bool panActive; bool panDecellerate; // Fractional pan, used by panFloatWrapper QPointF remainingPan; // current kinetic panning speed, in pixel/msec QPointF kineticPanSpeed; QPoint panDir; QTimer kineticTimer; QTime lastMoveTime; // An entry in the mouse history. first=speed, second=time typedef QPair<QPointF, QTime> MouseHistoryEntry; // A history of the last (currently 5) mouse move events is stored in order to smooth out // movement detection for kinetic panning QList<MouseHistoryEntry> mouseHistory; StatusBarItem *m_statusBar; };

सबसे दिलचस्प बात, ज़ाहिर है, कार्यान्वयन में, पहले हम आंदोलन को नियंत्रित करने के लिए सेटिंग्स पर विचार करेंगे:

 //////////////////////////////////////////////////////////////////////////////// // TODO: Some of these could be exposed in a GUI and should probably be put elsewhere in that case // (and made non-const) // Kinect annimation properties static const bool enableKineticPanning = true; // time until kinetic panning speed slows down to 50%, in msec static const qreal kineticPanningHalflife = 160.0; // keyboard panning speed without modifiers, in pixels/msec static const qreal panSpeedNormal = 0.3; // keyboard panning speed with shift, in pixels/msec static const qreal panSpeedFast = 1.0; // minimum panning speed, in pixels/msec static const qreal kineticPanSpeedThreshold = 0.005; // temporal resolution. Smaller values take more CPU but improve visual quality static const int kineticPanningResolution = 20; // maximum time between last mouse move and mouse release for kinetic panning to kick in static const int holdTimeThreshold = 100; ////////////////////////////////////////////////////////////////////////////////

मुझे लगता है कि कुछ भी समझाने की जरूरत नहीं है, टिप्पणियों से सब कुछ स्पष्ट है।
कार्यान्वयन के बाकी:

 void GeoMap::mousePressEvent(QGraphicsSceneMouseEvent *event) { setFocus(); if (event->button() == Qt::LeftButton) { panActive = true; // When pressing, stop the timer and stop all current kinetic panning kineticTimer.stop(); kineticPanSpeed = QPointF(); lastMoveTime = QTime::currentTime(); } event->accept(); } void GeoMap::mouseMoveEvent(QGraphicsSceneMouseEvent *event) { if (panActive) { setCursor(Qt::ClosedHandCursor); // Calculate time delta QTime currentTime = QTime::currentTime(); int deltaTime = lastMoveTime.msecsTo(currentTime); lastMoveTime = currentTime; // Calculate position delta QPointF delta = event->lastPos() - event->pos(); // Calculate and set speed if (deltaTime > 0) { kineticPanSpeed = delta / deltaTime; mouseHistory.push_back(MouseHistoryEntry(kineticPanSpeed, currentTime)); mouseHistory.pop_front(); } // Pan map panFloatWrapper(delta); } event->accept(); } void GeoMap::mouseReleaseEvent(QGraphicsSceneMouseEvent * event) { if (event->button() == Qt::LeftButton && panActive) { panActive = false; setCursor(Qt::OpenHandCursor); if (!enableKineticPanning || lastMoveTime.msecsTo(QTime::currentTime()) > holdTimeThreshold) { return; } kineticPanSpeed = QPointF(); int entries_considered = 0; QTime currentTime = QTime::currentTime(); foreach(MouseHistoryEntry entry, mouseHistory) { // first=speed, second=time int deltaTime = entry.second.msecsTo(currentTime); if (deltaTime < holdTimeThreshold) { kineticPanSpeed += entry.first; entries_considered++; } } if (entries_considered > 0) kineticPanSpeed /= entries_considered; lastMoveTime = currentTime; // When releasing the mouse button/finger while moving, // start the kinetic panning timer kineticTimer.start(); panDecellerate = true; } event->accept(); } void GeoMap::mouseDoubleClickEvent(QGraphicsSceneMouseEvent * event) { setFocus(); animatedPanTo(screenPositionToCoordinate(event->pos())); event->accept(); } // ... void GeoMap::kineticTimerEvent() { QTime currentTime = QTime::currentTime(); int deltaTime = lastMoveTime.msecsTo(currentTime); lastMoveTime = currentTime; if (panDecellerate) kineticPanSpeed *= qPow(qreal(0.5), qreal(deltaTime / kineticPanningHalflife)); QPointF scaledSpeed = kineticPanSpeed * deltaTime; if (kineticPanSpeed.manhattanLength() < kineticPanSpeedThreshold) { // Kinetic panning is almost halted -> stop it. kineticTimer.stop(); return; } panFloatWrapper(scaledSpeed); } // Wraps the pan(int, int) method to achieve floating point accuracy, // which is needed to scroll smoothly. void GeoMap::panFloatWrapper(const QPointF & delta) { // Add to previously stored panning distance remainingPan += delta; // Convert to integers QPoint move = remainingPan.toPoint(); // Commit mouse movement pan(move.x(), move.y()); // Store committed mouse movement remainingPan -= move; }

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

स्टेटस बार के लिए आइटम

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

 // An animated status bar item that appears at the bottom // of the map class StatusBarItem : public QObject, public QGraphicsRectItem { Q_OBJECT Q_PROPERTY(int offset READ offset WRITE setOffset) public: explicit StatusBarItem(); ~StatusBarItem(); int offset() const; void setRect(qreal x, qreal y, qreal w, qreal h); public slots: void setText(QString text); void showText(QString text, quint32 timeout=3000); void show(); void hide(); void setOffset(int offset); private: int m_offset; QGraphicsSimpleTextItem *m_textItem; };

सबसे पहले, तत्व स्वयं एक आयत है जिसमें QGraphicsSimpleTextItem शामिल है और बस इसे नियंत्रित करता है। आइए इस वर्ग के कार्यान्वयन को देखें:

 StatusBarItem::StatusBarItem() { m_offset = 0; setPen(QPen(QBrush(), 0)); setBrush(QBrush(QColor(0,0,0,120))); m_textItem = new QGraphicsSimpleTextItem(this); m_textItem->setBrush(QBrush(Qt::white)); setText(""); } StatusBarItem::~StatusBarItem() { } void StatusBarItem::setText(QString text) { m_textItem->setText(text); QRectF rect = m_textItem->boundingRect(); QPointF delta = this->rect().center() - rect.center(); m_textItem->setPos(delta.x(), delta.y()); } int StatusBarItem::offset() const { return m_offset; } void StatusBarItem::setRect(qreal x, qreal y, qreal w, qreal h) { QGraphicsRectItem::setRect(x, y + m_offset, w, h); QFont f; f.setFixedPitch(true); f.setPixelSize(h/1.1); m_textItem->setFont(f); setText(m_textItem->text()); } void StatusBarItem::setOffset(int offset) { this->setY(this->y() - m_offset + offset); m_offset = offset; } void StatusBarItem::showText(QString text, quint32 timeout) { setText(text); show(); QTimer::singleShot(timeout, this, SLOT(hide())); } void StatusBarItem::show() { QPropertyAnimation *anim = new QPropertyAnimation(this, "offset"); anim->setStartValue(0); anim->setEndValue(-1 * rect().height()); anim->setDuration(500); anim->start(QAbstractAnimation::DeleteWhenStopped); } void StatusBarItem::hide() { QPropertyAnimation *anim = new QPropertyAnimation(this, "offset"); anim->setStartValue(m_offset); anim->setEndValue(0); anim->setDuration(500); anim->start(QAbstractAnimation::DeleteWhenStopped); }

एनीमेशन तत्व की स्थिति को नियंत्रित करता है और, विधि के आधार पर, तत्व को या तो ऊपर या नीचे खींचता है। Qt का आदर्श वाक्य "कोड कम है। अधिक बनाएँ। ” पूरी तरह से चालू है।

स्केल तत्व

यहां मैं स्केलिंग के लिए बटनों के कार्यान्वयन पर विचार करना चाहता था, लेकिन आखिरी समय में मैंने अपना विचार बदल दिया (परिणामी लेख की मात्रा को देखकर) और केवल इसके संचालन के मूल सिद्धांत का वर्णन किया। तो, यह एक नियमित QGraphicsRectItem है , जिसमें दृश्य और अलगाव के लिए + और - , और QGraphicsLineItem प्रदर्शित करने के लिए दो पाठ तत्व शामिल हैं। तत्व उपयोगकर्ता क्रियाओं का जवाब देता है और दबाए जाने पर, यह या तो नक्शे के पैमाने को बढ़ाता है या घटाता है:

  //       //  ,      0      m_geoMap->setZoomLevel(m_geoMap->zoomLevel() + zoomLevel(event->pos()));

सिद्धांत रूप में, तत्व को QGraphicsItem से एक विरासत के साथ लागू किया जा सकता है और बस हमें आवश्यक जानकारी खींचनी चाहिए, लेकिन मैंने सोचा कि विभिन्न ग्राफिक तत्वों के साथ काम करना अधिक दृश्य था। जो कोई भी इस वर्ग को बदल सकता है, जिसके बाद यह कम स्मृति का उपभोग करेगा।

युक्तियाँ और चालें

QGraphicsView को रेंडर करने के लिए OpenGL का उपयोग करने के लिए, आपको बस QGLWidget को इस तरह सेट करना होगा:

 #ifndef QT_NO_OPENGL setViewport(new QGLWidget(QGLFormat(QGL::SampleBuffers))); viewport()->setMouseTracking(true); setRenderHint(QPainter::HighQualityAntialiasing, true); #endif

और QGraphicsView के लिए ध्वज सेट करें, क्योंकि QGLWidget आंशिक स्क्रीन अपडेट का समर्थन नहीं करता है:

  graphicsView->setViewportUpdateMode(QGraphicsView::FullViewportUpdate);

इसके अलावा, यदि आपके पास दृश्य में बहुत सारे एनिमेटेड या गतिशील तत्व हैं, तो बेहतर प्रदर्शन के लिए, आप तत्व अनुक्रमण को अक्षम कर सकते हैं:

  graphicsScene->setItemIndexMethod(QGraphicsScene::NoIndex);

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

निष्कर्ष

लेख बड़ा निकला, और यह मुझे लगता है कि इसे अनिश्चित काल तक विस्तारित किया जा सकता है। हमने वस्तुओं को खोजने के लिए एपीआई पर विचार नहीं किया, एक मार्ग बिछाया, और लैंडमार्क एपीआई के साथ काम किया (यदि किसी को दिलचस्पी है, उदाहरण 1 और 2 देखें )। इस आलेख में, हम ग्राफिक्स व्यू फ्रेमवर्क से परिचित हुए, QtLocation API का उपयोग करते समय मुख्य बिंदु, मुझे आशा है, एनीमेशन फ्रेमवर्क के साथ काम करना सीखा और नक्शे के जड़त्वीय आंदोलन के कार्यान्वयन की जांच की, नक्शे के प्रबंधन के लिए विभिन्न तत्व और पाठ की जानकारी प्रदर्शित करना। सामान्य तौर पर, यह एक मानचित्र प्रदर्शित करने के लिए एक अच्छा घटक बन गया, जिसे एक पूर्ण नाविक तक विस्तारित किया जा सकता है। एप्लिकेशन को कार्रवाई में आज़माने के लिए, आपको Qt SDK को इंस्टॉल करना होगा और Qt एमुलेटर के लिए प्रोजेक्ट को कॉपी करना होगा। अंत में, कुछ उपयोगी लिंक।

संदर्भ

लेख पर PS टिप्पणियाँ स्वागत है, यह मेरे जैसे अनुभवहीन लेखक के लिए बहुत उपयोगी होगा। अग्रिम धन्यवाद।

क्यूटी गतिशीलता का उपयोग करते हुए, C ++ / Qt में कार्टोग्राफिक मोबाइल एप्लिकेशन का विकास