डेल्फ़ी परिवेश में प्रोग्राम बनाना। ऑब्जेक्ट इंस्पेक्टर: सुविधाओं का उपयोग करना

सभी डेल्फ़ी घटक विज़ुअल कंपोनेंट लाइब्रेरी (वीसीएल) नामक पदानुक्रम का हिस्सा हैं। सभी घटकों का सामान्य पूर्वज TComponent वर्ग (चित्र 9.1.1) है, जिसमें सभी डेल्फ़ी घटकों के लिए सामान्य गुणों का एक न्यूनतम सेट होता है।

कंपोनेंटस्टेट प्रॉपर्टी में घटक की वर्तमान स्थिति को इंगित करने वाले मानों का एक सेट होता है। यहां कुछ संपत्ति मूल्य दिए गए हैं:

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

TComponent वर्ग में बड़ी संख्या में विधियाँ परिभाषित हैं। अधिसूचना पद्धति सबसे अधिक रुचिकर है। जब भी कोई घटक स्वामी की घटक सूची में डाला जाता है या हटाया जाता है तो इसे कॉल किया जाता है। स्वामी घटक सूची के प्रत्येक सदस्य को एक अधिसूचना भेजता है। यह सुनिश्चित करने के लिए कि किसी घटक के अन्य घटकों के संदर्भ मान्य हैं, इस पद्धति को व्युत्पन्न कक्षाओं में ओवरराइड किया गया है। उदाहरण के लिए, जब आप किसी प्रपत्र से Tablel घटक को हटाते हैं, तो DataSourcel घटक की Tablel की डेटासेट संपत्ति शून्य पर सेट हो जाती है।

घटक विकास प्रक्रिया में पाँच चरण शामिल हैं:

पूर्वज वर्ग चुनना;

एक घटक मॉड्यूल बनाना;

एक नए घटक में गुण, विधियाँ और घटनाएँ जोड़ना;

परिक्षण;

डेल्फ़ी परिवेश में एक घटक का पंजीकरण;

9.1. पूर्वज वर्ग चुनना

चित्र में. चित्र 9.1.1 उन आधार वर्गों को दर्शाता है जो वीसीएल की संरचना बनाते हैं। सबसे ऊपर TObject है, जो ऑब्जेक्ट पास्कल में सभी वर्गों का पूर्वज है। इससे टीपीर्सिस्टेंट आता है, जो थ्रेड ऑब्जेक्ट बनाने के लिए आवश्यक तरीके प्रदान करता है। थ्रेड ऑब्जेक्ट एक ऑब्जेक्ट है जिसे थ्रेड में संग्रहीत किया जा सकता है। स्ट्रीम एक ऑब्जेक्ट है जो बाइनरी डेटा (फ़ाइलें) संग्रहीत करने में सक्षम है। चूंकि डेल्फ़ी स्ट्रीम का उपयोग करके फॉर्मफाइल लागू करता है, TComponent TPersistent से लिया गया है, जो सभी घटकों को फॉर्मफाइल में बने रहने की क्षमता देता है।

TComponent वर्ग घटक पदानुक्रम के शीर्ष का प्रतिनिधित्व करता है और नए घटकों को बनाने के लिए उपयोग किए जाने वाले चार आधार वर्गों में से पहला है। TComponent के प्रत्यक्ष वंशज गैर-दृश्य घटक हैं।

9.1.1. टीकंट्रोल क्लास

दृश्य घटक पदानुक्रम का शीर्ष TControl वर्ग है।

TControl वर्ग मूल नियंत्रण की अवधारणा का परिचय देता है। पेरेंट प्रॉपर्टी वह विंडो है जिसमें नियंत्रण होता है। उदाहरण के लिए, यदि पैनल 1 में बटन 1 है, तो बटन 1 की मूल संपत्ति पैनल 1 है।

कंट्रोलस्टाइल प्रॉपर्टी विभिन्न शैलियों को परिभाषित करती है जो केवल दृश्य घटकों पर लागू होती हैं, उदाहरण के लिए:

TControl वर्ग दृश्य घटकों द्वारा उपयोग की जाने वाली अधिकांश संपत्तियों को परिभाषित करता है: पोजिशनिंग गुण (संरेखित करें, बाएं, शीर्ष, ऊंचाई, चौड़ाई), क्लाइंट क्षेत्र गुण (क्लाइंटहाइट, क्लाइंटविड्थ), गुण उपस्थिति(रंग, सक्षम, फ़ॉन्ट, शोहिंट, दृश्यमान), स्ट्रिंग गुण (कैप्शन, नाम, पाठ, संकेत), माउस गुण (कर्सर, ड्रैगकर्सर, ड्रैगकाइंड, ड्रैगमोड)।

इसके अलावा, TControl क्लास इवेंट डिस्पैचिंग विधियों को लागू करता है।

सभी दृश्य घटकों को ग्राफिकल नियंत्रण और विंडो नियंत्रण में विभाजित किया गया है। प्रत्येक प्रकार क्रमशः TGraphicControl और TWinControl से प्राप्त अपने स्वयं के वर्ग पदानुक्रम का प्रतिनिधित्व करता है। इन घटक प्रकारों के बीच मुख्य अंतर यह है कि ग्राफिकल घटक विंडो आईडी का समर्थन नहीं करते हैं, और इसलिए इनपुट फोकस स्वीकार नहीं कर सकते हैं।

विंडो घटकों को आगे दो श्रेणियों में विभाजित किया गया है। TWinControl के प्रत्यक्ष वंशज विंडोज़ में लागू मौजूदा नियंत्रणों के रैपर हैं (उदाहरण के लिए TEdit, TButton, आदि) और इसलिए जानते हैं कि खुद को कैसे आकर्षित करना है।

उन घटकों के लिए जिन्हें विंडो पहचानकर्ता की आवश्यकता होती है लेकिन अंतर्निहित विंडोज़ तत्वों को समाहित नहीं करते हैं जो स्वयं को फिर से तैयार करने की क्षमता प्रदान करते हैं, एक TCustomControl वर्ग है।

9.1.2. TGraphicControl क्लास

TGraphicControl क्लास उन घटकों के लिए एक बेस क्लास है जिन्हें इनपुट फोकस प्राप्त करने की आवश्यकता नहीं है और अन्य नियंत्रणों के माता-पिता के रूप में काम नहीं करते हैं (इन कार्यों के लिए विंडो आईडी की आवश्यकता होती है)।

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

9.1.3. TWinControl क्लास

TWinControl क्लास का उपयोग बेस क्लास के रूप में उन घटकों को बनाने के लिए किया जाता है जो संबंधित विंडो तत्वों को इनकैप्सुलेट करते हैं विंडोज़ प्रबंधनजो स्वयं चित्र बनाते हैं.

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

इस वर्ग के किसी भी वंशज को बनाना CreateWnd विधि को कॉल करने से शुरू होता है, जो पहले विंडो के निर्माण पैरामीटर रिकॉर्ड को आरंभ करने के लिए CreateParams को कॉल करता है, और फिर वास्तविक विंडो पहचानकर्ता बनाने के लिए CreateWindowHandle को कॉल करता है जो पैरामीटर रिकॉर्ड का उपयोग करता है। CreateWnd फिर विंडो आयामों को समायोजित करता है और नियंत्रण का फ़ॉन्ट सेट करता है।

9.1.4. TCustomControl क्लास

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

इस प्रकार, एक नई कक्षा बनाने के लिए कौन सा घटक प्रारंभिक (आधार) होगा, इसके आधार पर 4 मामलों को प्रतिष्ठित किया जा सकता है:

विंडोज़ नियंत्रण (TWinControl) बनाना;

एक ग्राफिकल नियंत्रण (टीग्राफिक-कंट्रोल) बनाना;

एक नया नियंत्रण बनाना (TCustomControl); एक गैर-दृश्य घटक (TComponent) बनाने के बारे में।

9.2. एक घटक मॉड्यूल और परीक्षण अनुप्रयोग बनाना

घटक की पसंद पर निर्णय लेने के बाद, आप घटक मॉड्यूल बनाना शुरू कर सकते हैं। ऐसा करने के लिए, आपको निम्नलिखित चरणों का पालन करना होगा।

फ़ाइल/नया.../घटक या घटक/नया घटक कमांड चलाएँ।

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

ओके बटन पर क्लिक करने के बाद एक नई क्लास का स्केलेटन तैयार हो जाएगा।

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

अभ्यास 9.2.1.एक नया घटक विकसित करें जो TEdit और TLabel घटकों को जोड़ता है। लेबल घटक संपादन फ़ील्ड (TEEdit) के ऊपर स्थित है। जब आप किसी संपादन फ़ील्ड को स्थानांतरित करते हैं, तो TLabel उसका अनुसरण करता है। जब आप कोई संपादन फ़ील्ड हटाते हैं, तो TLabel भी हटा दिया जाता है।

हम नए घटक वर्ग के पूर्वज के रूप में TEdit का उपयोग करते हैं।

घटक/नया घटक कमांड चलाएँ। निम्नलिखित विंडो पैरामीटर सेट करें: पूर्वज प्रकार TEdit

कक्षा का नाम TLabelसंपादित करें

पैलेट पेज टेस्ट

यूनिट फ़ाइल नाम ...\LabelEdit\LabelEdit.pas

ओके बटन पर क्लिक करें, निम्नलिखित कोड स्वचालित रूप से जेनरेट हो जाएगा:

विंडोज़, संदेश, SysUtils, कक्षाएं, ग्राफ़िक्स, नियंत्रण, फ़ॉर्म, संवाद, StdCtrls; प्रकार

TLabelEdit = वर्ग(TEEdit)

(निजी घोषणाएँ)

(संरक्षित घोषणाएँ)

(सार्वजनिक घोषणाएँ)

(प्रकाशित घोषणाएँ)

प्रक्रिया रजिस्टर;

प्रक्रिया रजिस्टर;

रजिस्टरकंपोनेंट्स("टेस्ट", );

मॉड्यूल नई कक्षा की रूपरेखा का वर्णन करता है और एक घटक पंजीकरण प्रक्रिया (रजिस्टर) लिखता है, जो इसे परीक्षण पृष्ठ पर रखता है। घटक मॉड्यूल फ़ाइल सहेजें.

परीक्षण अनुप्रयोग विकास

एक नया प्रोजेक्ट बनाएं. इसकी फ़ाइलों को फ़ोल्डर में सहेजें...\LabelEdit: मॉड्यूल फ़ाइल का नाम Main.pas है, प्रोजेक्ट फ़ाइल टेस्ट एप्लिकेशन, dpr है।

जिस घटक को आप विकसित कर रहे हैं उसका मॉड्यूल नाम परीक्षण आवेदन पत्र के उपयोग अनुभाग में जोड़ें:

उपयोग करता है..., लेबलसंपादित करें;

TForml क्लास के सार्वजनिक अनुभाग में, एक फ़ील्ड जोड़ें

प्रपत्र के ऑनक्रिएट ईवेंट हैंडलर में, गतिशील रूप से एक नया घटक बनाएं:

प्रक्रिया TForml.FormCreate(प्रेषक: TObject);

ले:=टीलेबलएडिट.क्रिएट(स्वयं);

प्रोजेक्ट फ़ाइलें सहेजें.

प्रयोग। सुनिश्चित करें कि जब आप फ़ॉर्म लॉन्च करें तो उसके ऊपरी बाएँ कोने में एक संपादन विंडो दिखाई दे। ♦

9.3. गुण, विधियाँ और घटनाएँ जोड़ना

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

किसी संपत्ति को जोड़ना तीन चरणों में होता है.

1. संपत्ति मूल्य संग्रहीत करने के लिए एक आंतरिक वर्ग फ़ील्ड बनाएं।

2. संपत्ति मूल्यों तक पहुँचने के तरीकों का विवरण और विकास।

3. संपत्ति का विवरण.

TControl वर्ग में, कैप्शन/टेक्स्ट, पैरेंट और संकेत गुणों को निम्नानुसार परिभाषित किया गया है:

TControl = वर्ग(TCComponent)

एफपीरेंट: ट्विनकंट्रोल; (मूल संपत्ति का आंतरिक क्षेत्र)

एफ़टेक्स्ट:पीचार; (टेक्स्ट/कैप्शन प्रॉपर्टी का आंतरिक क्षेत्र)

एफसंकेत: स्ट्रिंग; (संकेत संपत्ति का आंतरिक क्षेत्र)

फ़ंक्शन GetText: Tcaption; (टेक्स्ट/कैप्शन प्रॉपर्टी पढ़ने की विधि)

फ़ंक्शन IsCaptionStored: बूलियन;

फ़ंक्शन IsHintStored: बूलियन;

प्रक्रिया सेटटेक्स्ट (स्थिर मान: टीकैप्शन);

(टेक्स्ट/कैप्शन प्रॉपर्टी लिखने की विधि)

प्रक्रिया सेटपेरेंट(एपैरेंट: TWinControl); आभासी;

संपत्ति कैप्शन: टीकैप्शन पढ़ें गेटटेक्स्ट लिखें सेटटेक्स्ट संग्रहीत IsCaptionStored;

प्रॉपर्टी टेक्स्ट: टीकैप्शन पढ़ें गेटटेक्स्ट लिखें सेटटेक्स्ट;

संपत्ति अभिभावक: TWinControl पढ़ें FParent लिखें SetParent;

संपत्ति घोषणा में निम्नलिखित सिंटैक्स होता है: संपत्ति<имя свойства>: क्वालिफायर टाइप करें;

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

प्रत्येक संपत्ति घोषणा में संपत्ति के नाम के बाद कोलन का उपयोग करके संपत्ति का प्रकार निर्दिष्ट करना होगा।

रीड निर्देश का उपयोग उस विधि को निर्दिष्ट करने के लिए किया जाता है जिसका उपयोग संपत्ति मूल्य को पुनः प्राप्त करने के लिए किया जाएगा। विधि एक फ़ंक्शन होनी चाहिए जिसका रिटर्न प्रकार संपत्ति के प्रकार के समान हो।

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

पढ़ने की विधि विनिर्देश के बाद लेखन विधि विनिर्देशक आता है; लिखने का निर्देश निर्दिष्ट करता है कि संपत्ति को मूल्य निर्दिष्ट करने के लिए किस विधि का उपयोग किया जाएगा। विधि एक ऐसी प्रक्रिया होनी चाहिए जिसमें एक पैरामीटर हो जिसका प्रकार संपत्ति के प्रकार से मेल खाना चाहिए।

किसी संपत्ति मूल्य तक पहुंचने पर, संबंधित विधि पर पुनर्निर्देशन होता है। उदाहरण के लिए, ऑपरेटर s: =Editl. मूलपाठ; स्वचालित रूप से s: =Editl कथन में परिवर्तित हो जाएगा। टेक्स्ट प्राप्त करें; और एडिटल ऑपरेटर। टेक्स्ट: = "टेस्ट" - Editl.Text("टेस्ट") ऑपरेटर में।

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

आंतरिक डेटा भंडारण फ़ील्ड के विपरीत, गुणों को एक प्रक्रिया (या फ़ंक्शन) में एक चर पैरामीटर (var पैरामीटर) के रूप में पारित नहीं किया जा सकता है, ऐसा इसलिए है क्योंकि संपत्ति मेमोरी में मौजूद नहीं है।

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

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

संपत्ति संकेत: स्ट्रिंग पढ़ें FHint लिखें FHint संग्रहीत IsHintStored;

यदि किसी संपत्ति में संग्रहीत निर्देश नहीं है, तो इसे ट्रू पैरामीटर के साथ शामिल माना जाता है।

डिफ़ॉल्ट और नोडफॉल्ट निर्देश डिफ़ॉल्ट संपत्ति मानों को नियंत्रित करते हैं। डिफ़ॉल्ट निर्देश का पालन संपत्ति के समान प्रकार के स्थिरांक द्वारा किया जाना चाहिए, उदाहरण के लिए:

प्रॉपर्टी टैग: लॉन्गिंट रीड एफटीएजी राइट एफटीएजी डिफॉल्ट 0;

नया मान निर्दिष्ट किए बिना विरासत में मिले डिफ़ॉल्ट मान को ओवरराइड करने के लिए, नोडफॉल्ट निर्देश का उपयोग करें। डिफ़ॉल्ट और नोडफॉल्ट निर्देश केवल क्रमिक प्रकारों और सेटों के साथ काम करते हैं जिनकी निचली और ऊपरी सीमाएं 0 से 31 तक की सीमा में होती हैं। यदि ऐसी संपत्ति को डिफ़ॉल्ट और नोडफॉल्ट निर्देशों के बिना घोषित किया जाता है, तो इसे ऐसे माना जाता है जैसे कि इसमें नोडफॉल्ट निर्देश था . वास्तविक प्रकार, पॉइंटर्स और स्ट्रिंग्स के लिए, डिफ़ॉल्ट निर्देश के बाद का मान केवल O, NIL और हो सकता है

(खाली स्ट्रिंग) क्रमशः।

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

मेमोरी विनिर्देशक सरणी गुणों द्वारा समर्थित नहीं हैं, और किसी सरणी संपत्ति का वर्णन करते समय डिफ़ॉल्ट निर्देश का एक अलग उद्देश्य होता है।

9.3.1. सरल गुण

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

आइए TContol क्लास (controls.pas मॉड्यूल) में वर्णित एक सरल Color प्रॉपर्टी बनाने पर विचार करें:

TControl = वर्ग(TCComponent)

फ़ंक्शन IsColorStored: बूलियन;

गुण रंग: TColor पढ़ें FColor लिखें SetColor संग्रहित IsColorStored डिफ़ॉल्ट clWindow;

फ़ंक्शन TControl.IsColorStored: बूलियन;

परिणाम:= पेरेंट कलर नहीं;

प्रक्रिया TControl.SetColor(मान: TColor);

अगर एफ कलर<>तो मूल्य

FParentColor:= ग़लत;

प्रदर्शन(CM_COLORCHANGED, 0, 0) ;

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

9.3.2. एनम प्रकार के गुण

उपयोगकर्ता-परिभाषित गणना योग्य और बूलियन गुणों को ड्रॉप-डाउन सूची से उचित संपत्ति मूल्य का चयन करके ऑब्जेक्ट इंस्पेक्टर विंडो में संपादित किया जा सकता है। आइए आकार घटक (मॉड्यूल extctrls.pas) के उदाहरण का उपयोग करके एक गणना प्रकार की संपत्ति बनाने पर गौर करें।

TShapeType = (stRectangel, stSquare, stRoundRect, stRoundSquare, stEllipse, stCircle);

(पहले आपको एक नया प्रकार परिभाषित करने की आवश्यकता है - संभावित मानों को सूचीबद्ध करें)

एफशेप: टीशेपटाइप;

प्रक्रिया सेटशेप (मान: TShapeType);

संपत्ति आकार: TShapeType पढ़ें FShape लिखें SetShape

डिफ़ॉल्ट स्ट्रेटेंगल;

प्रक्रिया TShape.SetShape(मान: TShapeType);

यदि FShape<>तो मूल्य

इन्वा 1 इडेट; (घटक को फिर से बनाने की गारंटी देता है)

9.3.3. प्रकार गुण सेट करें

एक सेट प्रकार की संपत्ति, जब ऑब्जेक्ट इंस्पेक्टर विंडो में संपादित की जाती है, तो पास्कल सिंटैक्स द्वारा परिभाषित सेट के समान दिखती है। सबसे सरल तरीकाइसे संपादित करें - ऑब्जेक्ट इंस्पेक्टर में संपत्ति का विस्तार करें, परिणामस्वरूप, इसका प्रत्येक तत्व एक अलग बूलियन मान बन जाएगा।

किसी सेट प्रकार की संपत्ति बनाते समय, आपको संबंधित प्रकार बनाने, पहुंच विधियों का वर्णन करने और फिर संपत्ति का वर्णन करने की आवश्यकता होती है। Controls.pas मॉड्यूल में, संरेखित संपत्ति का वर्णन इस प्रकार किया गया है:

TAlign = (alNone, alTop, alBottom, allLeft, alRight, alClient);

TAlignSet = TAlign का सेट; TControl = वर्ग(TCComponent)

प्रक्रिया SetAlign (मान: TAlign);

संपत्ति संरेखित करें: TAlign पढ़ें FAlign लिखें SetAlign डिफ़ॉल्ट alNone;

प्रक्रिया TControl.SetAlign(मान: TAlign);

वर OldAlign: TAlign;

यदि FAlign<>तो मूल्य

OldAlign:= FALign;

एंकर:= एंकरअलाइन;

(नहीं (ComponentState में csDesigning) या (Parent<>शून्य))

यदि ((OldAlign in )=(Value in )) और नहीं (OldAlign in ) और नहीं (Value in ) तो SetBounds(Left, Top, Height, Width)

(घटक सीमाएँ बदलें)

अन्यथा आकार समायोजित करें; (घटक के दिए गए आयाम सेट करता है)

अनुरोध संरेखित करें; ("पैरेंट" को घटक को पुनर्व्यवस्थित करने का निर्देश देता है

संरेखण संपत्ति के मूल्य के अनुसार)

9.3.4. संपत्ति-वस्तु

गुण वस्तुएँ या अन्य घटक हो सकते हैं। उदाहरण के लिए, शेप घटक में ब्रश और रेप ऑब्जेक्ट गुण होते हैं। जब कोई संपत्ति एक वस्तु होती है, तो इसे इंस्पेक्टर विंडो में विस्तारित किया जा सकता है ताकि इसकी अपनी संपत्तियों को भी संशोधित किया जा सके। ऑब्जेक्ट गुण TPersistent वर्ग के वंशज होने चाहिए ताकि उनके प्रकाशित गुणों को डेटा स्ट्रीम में लिखा जा सके और ऑब्जेक्ट इंस्पेक्टर में प्रदर्शित किया जा सके।

किसी घटक की ऑब्जेक्ट प्रॉपर्टी को परिभाषित करने के लिए, आपको पहले उस ऑब्जेक्ट को परिभाषित करना होगा जिसका उपयोग प्रॉपर्टी प्रकार के रूप में किया जाएगा। ग्राफ़िक्स.पास मॉड्यूल TBrush वर्ग का वर्णन करता है:

टीब्रश = क्लास(टीग्राफिक्सऑब्जेक्ट)

प्रक्रिया GetData(var ब्रशडेटा: TBrushData);

प्रक्रिया सेटडेटा (स्थिरांक ब्रशडेटा: TBrushData);

फ़ंक्शन GetBitmap: TBitmap;

प्रक्रिया सेटबिटमैप(मान: TBitmap);

फ़ंक्शन GetColor: TColor;

प्रक्रिया सेट कलर (मान: टी कलर);

फ़ंक्शन GetHandle: HBrush.;

प्रक्रिया सेटहैंडल (मान: HBrush);

फ़ंक्शन GetStyle: TBrushStyle;

प्रक्रिया सेटस्टाइल (मान: TBrushStyle);

कंस्ट्रक्टर क्रिएट; विध्वंसक नष्ट; ओवरराइड;

प्रक्रिया असाइन करें (स्रोत: टीपर्सिस्टेंट); ओवरराइड;

संपत्ति बिटमैप: टीबीटमैप पढ़ें गेटबिटमैप लिखें सेटबिटमैप;

प्रॉपर्टी हैंडल: HBrush पढ़ें GetHandle लिखें SetHandle;

संपत्ति का रंग: TColor पढ़ें GetColor लिखें SetColor

defaultclसफेद;

संपत्ति शैली: TBrushStyle पढ़ें GetStyle लिखें SetStyle

डिफ़ॉल्ट bssolid;

असाइन विधि को TBrush उदाहरण के गुणों के मान की प्रतिलिपि बनाने के लिए डिज़ाइन किया गया है:

प्रक्रिया TBrush.Assign (स्रोत: TPersistent);

यदि स्रोत TBrush है तो

ताला; (वस्तु के उपयोग को रोकता है)

टीब्रश(स्रोत).लॉक;

ब्रशमैनेजर.असाइनरिसोर्स(स्वयं, टीब्रश(स्रोत).एफरिसोर्स);

अंततः टीब्रश(स्रोत).अनलॉक;

अंततः अनलॉक; (लॉक विधि द्वारा शुरू किए गए कोड का अनुभाग समाप्त होता है,

ऑब्जेक्ट को अनब्लॉक करना)

विरासत में मिला असाइनमेंट (स्रोत);

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

TShape = वर्ग(TGraphicControl)

प्रक्रिया सेटब्रश(मान: टीब्रश);

कंस्ट्रक्टर क्रिएट (AOowner: TComponent); ओवरराइडर;

प्रॉपर्टी ब्रश: टीब्रश पढ़ें एफब्रश लिखें सेटब्रश;

कंस्ट्रक्टर TShape.Create(AOowner: TComponent);

विरासत में मिला क्रिएट(एओनर);

FBrush:= TBrush.बनाएँ;

FBrush.OnChange:= स्टाइलचेंज्ड;

विध्वंसक TShape.Destroy;

एफब्रश. स्वतंत्र-विरासत में मिला विनाश;

प्रक्रिया TShape.SetBrush(मान: TBrush);

FBrush.Assign(मान);

9.3.5. सरणी संपत्ति

सरणी गुणों के उदाहरणों में TMemo.Lines, TScreen.Fonts, TStringGrid.Cells जैसे गुण शामिल हैं।

एक सरणी संपत्ति की विशेषताएं इस प्रकार हैं:

ऐरे गुणों को सूचकांक मापदंडों का उपयोग करके घोषित किया जाता है, जिसका उद्देश्य सूचकांक की संख्या और प्रकार को निर्दिष्ट करना है जो संपत्ति द्वारा उपयोग किया जाएगा;

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

TCanvas = वर्ग (TPersistent)

फ़ंक्शन GetPixel(X, Y: पूर्णांक): TColor; (पढ़ने की विधि)

प्रक्रिया SetPixel (X, Y: पूर्णांक; मान: TColor);

(रिकॉर्डिंग विधि)

कंस्ट्रक्टर क्रिएट;

विध्वंसक नष्ट; ओवरराइड;

संपत्ति पिक्सेल: TColor पढ़ें GetPixel लिखें SetPixel;

कंस्ट्रक्टर TCanvas.Create;

विरासत में मिला निर्माण;

कैनवास सूची। जोड़ें (स्वयं); (सूची में वस्तुओं के लिंक जोड़ता है)

विध्वंसक TCanvas.Destroy;

CanvasList.Remove(स्वयं); (सूची से वस्तुओं के लिंक हटाता है)

विरासत में मिला विनाश; अंत;

फ़ंक्शन TCanvas.GetPixel(X, Y: पूर्णांक): TColor;

आवश्यक राज्य();

GetPixel:= Windows.GetPixel(FHandle, X, Y); अंत;

प्रक्रिया TCanvas.SetPixel(X, Y: पूर्णांक; मान: TColor);

आवश्यक राज्य();

Windows.SetPixel(FHandle, X, Y, ColorToRGB(मान));

इस सरणी संपत्ति को निम्नानुसार एक्सेस किया गया है:

कैनवास.पिक्सेल :=clRed; मतलब:

Canvas.SetPixel(10, 20, clRed);

एक सरणी संपत्ति घोषणा का पालन एक डिफ़ॉल्ट निर्देश द्वारा किया जा सकता है। इस मामले में, इसका मतलब यह होगा कि यह संपत्ति इस वर्ग के लिए डिफ़ॉल्ट संपत्ति बन जाती है। उदाहरण के लिए:

TStringArray = वर्ग सार्वजनिक संपत्ति स्ट्रिंग्स: स्ट्रिंग। . . ; गलती करना;

यदि किसी वर्ग में कोई डिफ़ॉल्ट संपत्ति है, तो इस संपत्ति को ऑपरेटर द्वारा एक्सेस किया जा सकता है

<имя компонента>, जो ऑपरेटर के बराबर है

<имя компонента>.<имя свойства>.

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

9.3.6. गुण सारणी

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

TRectangel = वर्ग निजी

Fनिर्देशांक: Longint की सरणी;

फ़ंक्शन गेटकोऑर्डिनेट (सूचकांक: पूर्णांक): लॉन्गिंट;

प्रक्रिया सेटकोऑर्डिनेट (सूचकांक: पूर्णांक; मान: लॉन्गिंट); जनता

संपत्ति बायां: लॉन्गिंट इंडेक्स 0 GetCoorderinate पढ़ें

राइटसेटकोऑर्डिनेट; प्रॉपर्टी टॉप: लॉन्गिंट इंडेक्स 1 GetCoorderinate पढ़ें

राइटसेटकोऑर्डिनेट; प्रॉपर्टी राइट: लॉन्गिंट इंडेक्स 2 GetCoorderinate पढ़ें

राइटसेटकोऑर्डिनेट; प्रॉपर्टी बॉटम: लॉन्गिंट इंडेक्स 3 गेटकोऑर्डिनेट पढ़ें

राइटसेटकोऑर्डिनेट;

उदाहरण के लिए, सूचकांक निर्देश के साथ परिभाषित संपत्ति तक पहुँचना,

आयत.दाएँ:= आयत.बाएँ + 100;

(आयत: Tआयतकोण)

स्वचालित रूप से एक विधि कॉल में परिवर्तित हो गया,

रेक्टेंगल.सेटकोऑर्डिनेट(2, रेक्टेंगल.गेटकोऑर्डिनेट(0) + 100);

9.3.7. ओवरराइडिंग और ओवरराइडिंग गुण

किसी प्रकार को निर्दिष्ट किए बिना संपत्ति की घोषणा को संपत्ति ओवरराइड कहा जाता है। ओवरराइड करने का सबसे सरल तरीका आरक्षित शब्द संपत्ति और एक पहचानकर्ता - संपत्ति का नाम - का उपयोग करना है। इस पद्धति का उपयोग किसी संपत्ति की दृश्यता को बदलने के लिए किया जाता है।

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

टीएन्सेस्टर = वर्ग

संपत्ति का आकार: पूर्णांक पढ़ें FSize; प्रॉपर्टी टेक्स्ट: स्ट्रिंग पढ़ें GetText लिखें SetText; गुण रंग: TColor पढ़ें FColor लिखें SetColor संग्रहित गलत;

Tव्युत्पन्न = वर्ग(TAncestor)

संपत्ति का आकार लिखें SetSize; प्रकाशित संपत्ति पाठ; संपत्ति रंग संग्रहीत सही डिफ़ॉल्ट clBlue;

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

किसी संपत्ति को ओवरराइड करने में उसके प्रकार को निर्दिष्ट करना और विरासत में मिली संपत्ति को छिपाना शामिल है। इसका मतलब यह है कि पूर्वज के समान नाम से एक नई संपत्ति बनाई जाती है। कोई भी संपत्ति घोषणा जिसमें प्रकार का संकेत शामिल है, पूर्ण होनी चाहिए और इसमें कम से कम एक एक्सेस विनिर्देशक शामिल होना चाहिए:

TAncestor = class टाइप करें

गुण मान: पूर्णांक पढ़ें विधि लिखें विधि 2; अंत;

Tवंशज = वर्ग(TAncestor)

संपत्ति मूल्य: पूर्णांक पढ़ें विधि3 लिखें विधि4; अंत;

9.3.8. इवेंट बनाना

कोई ईवेंट उपयोगकर्ता के हस्तक्षेप, ऑपरेटिंग सिस्टम के हस्तक्षेप या प्रोग्राम लॉजिक के कारण होने वाली कोई भी घटना है। एक घटना कुछ प्रोग्राम कोड से जुड़ी होती है जो इस घटना पर प्रतिक्रिया देती है। किसी इवेंट के संग्रह और इस इवेंट के जवाब में निष्पादित कोड को इवेंट प्रॉपर्टी कहा जाता है और इसे एक विधि के संकेतक के रूप में कार्यान्वित किया जाता है। यह प्रॉपर्टी जिस विधि की ओर इशारा करती है उसे इवेंट हैंडलर कहा जाता है।

ईवेंट गुण विधियों के संकेतक से अधिक कुछ नहीं हैं। Controls.pas मॉड्यूल मानक ईवेंट गुणों को परिभाषित करता है।

इवेंट प्रॉपर्टी का विवरण एक नए प्रकार के विवरण से शुरू होता है, जो एक प्रक्रिया है, जिसका एक पैरामीटर TObject प्रकार का प्रेषक है, और ऑब्जेक्ट का निर्देश इस प्रक्रिया को एक विधि बनाता है:

TMouseMoveEvent = ऑब्जेक्ट की प्रक्रिया (प्रेषक: TObject; Shift: TShiftState; X, Y: पूर्णांक);

जब कोई घटना घटती है, जैसे कि माउस को हिलाना, तो संबंधित संदेश Win32 सिस्टम को भेजा जाता है, हमारे मामले में WM_MOUSEMOVE। Win32 सिस्टम इस घटना को उस नियंत्रण में भेजता है जिसके लिए इसका इरादा है और जिस पर उसे किसी न किसी तरह से प्रतिक्रिया देनी होगी। नियंत्रण पहले निष्पादित होने वाले कोड की जाँच करके इस घटना पर प्रतिक्रिया दे सकता है। ऐसा करने के लिए, यह जांचता है कि इवेंट प्रॉपर्टी किसी कोड द्वारा संदर्भित है या नहीं। यदि ऐसा है, तो तत्व इस कोड को निष्पादित करता है, जिसे इवेंट हैंडलर कहा जाता है। किसी संपत्ति घटना से जुड़ी विधि की उपस्थिति का निर्धारण करने का संचालन प्रेषण विधि को सौंपा गया है। इन विधियों को उस घटक की संरक्षित विधियों के रूप में घोषित किया जाता है जिससे वे संबंधित हैं।

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

TControl = वर्ग(TCComponent) निजी

FOnMouseMove: TMouseMoveEvent; (आंतरिक घटना क्षेत्र) प्रक्रिया WMMouseMove(var संदेश: TWMMouseMove); संदेश WM_MOUSEMOVE;

प्रक्रिया माउसमूव(Shift: TShiftState; X, Y: Integer);

गतिशील; (प्रेषण विधि)

संपत्ति OnMouseMove: TMouseMoveEvent FOnMouseMove पढ़ें

FOnMouseMove लिखें;

प्रेषण विधि यह निर्धारित करती है कि क्या कोई इवेंट प्रॉपर्टी किसी विधि पर मौजूद है, और यदि हां, तो यह उचित प्रक्रिया पर नियंत्रण स्थानांतरित करती है:

प्रक्रिया TControl.MouseMove(Shift: TShiftState; X, Y: Integer); शुरू

यदि असाइन किया गया है (FOnMouseMove) तो FOnMouseMove (सेल्फ, शिफ्ट, X, Y); अंत;

ईवेंट प्रोसेसिंग को ओवरराइड करने की क्षमता प्रदान करने के लिए, आपको होने वाली ईवेंट को रोकना होगा, इसे मानक तरीके से संसाधित करना होगा और नियंत्रण को प्रेषण विधि में स्थानांतरित करना होगा:

प्रक्रिया TControl.WMMouseMove(var संदेश: TWMMouseMove); विरासत में मिला शुरू; यदि नहीं (ControlStyle में csNoStdEvents) तो

(ControlStyle सेट में csNoStdEvents सहित मानक माउस और कीबोर्ड घटनाओं को नजरअंदाज करने के लिए मजबूर करता है। यह ध्वज आपको एप्लिकेशन के लॉन्च को तेज करने की अनुमति देता है यदि उसे इन घटनाओं को संसाधित करने की आवश्यकता नहीं है) संदेश के साथ MouseMove(KeysToShiftState(Keys), XPos , YPos); अंत;

9.3.9. विधियाँ बनाना

किसी घटक में विधियाँ जोड़ना किसी अन्य वर्ग में विधियाँ जोड़ने से भिन्न नहीं है। हालाँकि, निम्नलिखित नियमों का पालन किया जाना चाहिए:

विधियों की अन्योन्याश्रयता को समाप्त करना;

उपयोगकर्ता द्वारा बुलाए गए किसी विधि को घटक को ऐसी स्थिति में नहीं रखना चाहिए जिसमें अन्य विधियों का कोई प्रभाव न हो;

विधि का एक सार्थक नाम होना चाहिए.

अभ्यास 9.2.1 (जारी)। आइए नए वर्ग के विवरण में TLabel ऑब्जेक्ट प्रकार की एक संपत्ति जोड़ें:

TLabelEdit = वर्ग(TEEdit)

(निजी घोषणाएँ)

फ़्लैबेल: लेबल; (आंतरिक क्षेत्र)

(संरक्षित घोषणाएँ)

फ़ंक्शन GetLabelCaption: स्ट्रिंग; आभासी;

(लेबल ऑब्जेक्ट प्रॉपर्टी की कैप्शन प्रॉपर्टी को पढ़ने की विधि)

प्रक्रिया SetLabelCaption(कॉन्स्ट मान: स्ट्रिंग); आभासी;

(संपत्ति लेखन विधि

वस्तु संपत्ति का कैप्शन लेबल) सार्वजनिक

(सार्वजनिक घोषणाएँ)

कंस्ट्रक्टर क्रिएट (मालिक: TComponent); ओवरराइड;

विध्वंसक नष्ट; ओवरराइडर;

(प्रकाशित घोषणाएँ)

प्रॉपर्टी लेबलकैप्शन: स्ट्रिंग पढ़ें GetLabelCaption लिखें SetLAbelCaption; अंत;

कंस्ट्रक्टर में, आपको TLabel प्रकार का एक उदाहरण बनाना होगा, आंतरिक फ़ील्ड में इसके लिए एक लिंक सहेजना होगा, और बनाई गई ऑब्जेक्ट की कैप्शन प्रॉपर्टी का मान सेट करना होगा:

कंस्ट्रक्टर TLabelEdit.Create(AOowner: TComponent); शुरू

विरासत में मिला क्रिएट (मालिक);

FLabel:= TLabel.Create(NIL);

(वस्तु संपत्ति का स्वामी मौजूद नहीं है)

FLabel.Caption:= "संपादन के लिए लेबल"; अंत;

जब कोई घटक नष्ट हो जाता है, तो बनाई गई ऑब्जेक्ट संपत्ति द्वारा कब्जा किए गए संसाधनों को जारी करना आवश्यक है:

विध्वंसक TLabelEdit.Destroy;

यदि (FLabel<>शून्य) और (FLabel.parent = NIL) फिर FLabel.free;

विरासत में मिला विनाश;

पढ़ने और लिखने की पहुंच विधियां क्रमशः कैप्शन प्रॉपर्टी के मूल्य को फ़्लैबेल के आंतरिक क्षेत्र में पढ़ती और लिखती हैं:

फ़ंक्शन TLabelEdit.GetLabelCaption: स्ट्रिंग;

परिणाम:= फ़्लैबेल.कैप्शन;

प्रक्रिया TLabelEdit.SetLabelCaption(कॉन्स्ट वैल्यू: स्ट्रिंग);

फ़्लैबेल.कैप्शन:= मान;

प्रयोग। घटक मॉड्यूल सहेजें. परीक्षण एप्लिकेशन चलाएँ. निर्मित घटक कैसे प्रदर्शित होता है? ♦

केवल संपादन घटक अभी भी दिखाई दे रहा है। ऐसा इसलिए है क्योंकि आंतरिक लेबल घटक की मूल संपत्ति परिभाषित नहीं है। याद रखें कि मूल संपत्ति उस घटक को निर्दिष्ट करती है जो उससे संबंधित घटकों को चित्रित करने के लिए जिम्मेदार है।

TLabelEdit वर्ग विवरण के संरक्षित अनुभाग में एक प्रक्रिया जोड़ें

प्रक्रिया सेटपेरेंट(मान: TWinControl); ओवरराइड;

घटक मॉड्यूल के कार्यान्वयन अनुभाग में, प्रक्रिया कोड का वर्णन करें:

प्रक्रिया TLabelEdit.SetParent(मान: TWinControl);

यदि (स्वामी = शून्य) या नहीं (स्वामी.कंपोनेंटस्टेट में सीएस नष्ट हो रहा है)

(जब तक कि घटक के मालिक को परिभाषित नहीं किया जाता है या मालिक को नष्ट नहीं किया जाता है)

फिर FLabel.Parent:=Value;

(घटक का स्वामी सेट करें)

विरासत में मिला सेटपेरेंट(मान);

प्रयोग। चित्र के अनुसार परीक्षण एप्लिकेशन को संशोधित करें। 9.3.1. स्पिनएडिट घटकों के मान लेबलएडिट घटक की स्थिति निर्धारित करते हैं।

परीक्षण एप्लिकेशन चलाएँ.

बाएँ और शीर्ष गुणों के विभिन्न मानों के साथ LabelEdit घटक के प्रदर्शन की जाँच करें। ♦

जब आप संपादन घटक को स्थानांतरित करते हैं, तो लेबल को उसका अनुसरण करना चाहिए। ऐसा करने के लिए, आपको मूव इवेंट - WM_MOVE को इंटरसेप्ट करना होगा। TLabelEdit घटक विवरण के निजी अनुभाग में WMMove ईवेंट हैंडलर हेडर का वर्णन करें:

प्रक्रिया WMMove(var संदेश: TWMMove); संदेश WM_MOVE;

WMMove इवेंट हैंडलर में, मानक इवेंट प्रोसेसिंग के अलावा, लेबल घटक को स्थानांतरित करने के लिए ऑपरेटर शामिल होते हैं:

प्रक्रिया TLabelEdit.WMMove(var Msg: TWMMove); विरासत में मिला शुरू;

अगर फ्लेबेल<>NIL फिर FLabel के साथ SetBounds(Msg.XPos, Msg.Ypos-Height-5, Width, Height);

(प्रक्रिया SetBounds(ALeft, ATop, A Width, AHeight: Integer) सभी नियंत्रण की सीमा गुणों को एक साथ सेट करती है) समाप्त;

प्रयोग। घटक मॉड्यूल कोड सहेजें. परीक्षण एप्लिकेशन चलाएँ और सुनिश्चित करें कि घटक सही ढंग से चलता है। ♦

9.4. डेल्फ़ी परिवेश में एक घटक पंजीकृत करना

पंजीकरण प्रक्रिया घटक को डेल्फ़ी घटक पैलेट में रखती है।

आइए अभ्यास में विकसित TLabelEdit घटक के उदाहरण का उपयोग करके एक घटक स्थापित करने की प्रक्रिया को देखें। 9.2.1.

कंपोनेंट/इंस्टॉल कंपोनेंट कमांड चलाएँ। घटक स्थापित करें संवाद बॉक्स में, यूनिट फ़ाइल नाम पंक्ति में, नए घटक मॉड्यूल का नाम निर्दिष्ट करें - ...\LabelEdit\LabelEdit.pas (चित्र 9.4.1)। ओके पर क्लिक करें।

एक पुष्टि संवाद बॉक्स संदेश के साथ प्रकट होता है "पैकेज dclusr50.bpl बनाया जाएगा फिर इंस्टॉल किया जाएगा। जारी रखना?" (dclusr50.bpl पैकेज पुनः स्थापित किया जाएगा। जारी रखें?), हाँ बटन पर क्लिक करें।

यदि नए घटक की मॉड्यूल फ़ाइल में कोई त्रुटि नहीं है, तो घटक डेल्फ़ी घटक पैलेट में पंजीकृत किया जाएगा और सूचना विंडो "पैकेज सी:\प्रोग्राम फ़ाइलें\बोरलैंड\डेल्फ़िस\प्रोजेक्ट्स\बीपीएल\ dclusrSO" संदेश के साथ प्रदर्शित की जाएगी। बीपीएल स्थापित कर दिया गया है। निम्नलिखित नए घटक पंजीकृत किए गए हैं: TLabelEdit"()। ओके पर क्लिक करें।

परीक्षण पृष्ठ पर घटक पैलेट में एक नया घटक दिखाई देगा (चित्र 9.4.2)।

टिप्पणी। नए घटक के लिए आइकन बदलने के लिए, छवि संपादक प्रोग्राम का उपयोग करें। फ़ाइल/नया/घटक संसाधन फ़ाइल, फिर संसाधन/नया/बिटमैप कमांड चलाएँ। दिखाई देने वाले बिटमैप गुण संवाद बॉक्स में, छवि का आकार 24x24 पिक्सल पर सेट करें, रंग को वीजीए (16 रंग) पर सेट करें, ओके पर क्लिक करें और बिटमैप नाम को घटक के नाम में बदलें (हमारे मामले में TLABELEDIT, दर्ज करना सुनिश्चित करें) बड़े अक्षरों में)। फिर रिसोर्स/एडिट कमांड चलाएँ और वांछित छवि बनाएँ। उसके बाद, फ़ाइल को उस निर्देशिका में सहेजें जहां घटक मॉड्यूल संग्रहीत है, उसी नाम के तहत, लेकिन एक्सटेंशन .DCR के साथ, घटक को फिर से स्थापित करें।

यदि घटक को पुनः स्थापित किया गया है या यदि घटक मॉड्यूल में त्रुटियां हैं, तो पैकेज-dclusr50.dpk घटक पैकेज संपादक प्रदर्शित किया जाएगा (चित्र 9.4.3), जो आपको पैकेज को हटाने, जोड़ने, संकलित करने की अनुमति देता है।

Dclusr50 पैकेज में किए गए परिवर्तनों को सहेजने के लिए, पुष्टि संवाद बॉक्स "प्रोजेक्ट Dclusr50 में परिवर्तन सहेजें?" में ओके बटन पर क्लिक करें। (DclusrSO प्रोजेक्ट में परिवर्तन सहेजें?)।

व्यायाम 9.4.1. एक SimpleTree घटक विकसित करें जो संरचना प्रदर्शित करता है फाइल सिस्टमवृक्ष रूप में (चित्र 9.4.4)।

एक SimpleTree निर्देशिका बनाएँ।

फ़ाइल\नया\घटक कमांड चलाएँ। नए घटक संवाद बॉक्स में, बुनियादी पैरामीटर सेट करें:

पूर्वज वर्ग का नाम दर्ज करें - TCustomControl, क्योंकि यह वर्ग घटक को आकर्षित करने की क्षमता प्रदान करता है और आपको इनपुट फोकस प्राप्त करने की अनुमति देता है;

निर्मित वर्ग का नाम TSimpleTree है;

घटक पैलेट पृष्ठ का नाम जिस पर घटक रखा जाएगा - परीक्षण;

बनाई जा रही कक्षा के विवरण वाली मॉड्यूल फ़ाइल का नाम है ...\SimpleTree\SimleTree.pas;

□ किसी फ़ाइल की खोज के लिए पथ निर्दिष्ट करने के लिए पंक्ति का मान अपरिवर्तित छोड़ दें।

ओके बटन पर क्लिक करने के बाद, एक मॉड्यूल संपादन विंडो खुलेगी...\SimpleTree\SimleTree.pas, जिसमें TSimpleTree क्लास और रजिस्टर प्रक्रिया का विवरण शामिल है।

क्लास विवरण के सार्वजनिक अनुभाग में, क्रिएट कंस्ट्रक्टर का वर्णन करें: कंस्ट्रक्टर क्रिएट (एओनर: टीकंपोनेंट); ओवरराइड;

जिसमें हम माउस घटनाओं को संसाधित करने और घटक फ्रेम की मात्रा निर्धारित करने की क्षमता को परिभाषित करते हैं:

कंस्ट्रक्टर TSimpleTree.Create(AOowner: TComponent); शुरू

विरासत में मिला क्रिएट(एओनर);

नियंत्रण शैली:= ;

(ControlStyle गुण घटक की विभिन्न विशेषताओं के लिए जिम्मेदार है: csFramed - नियंत्रण में एक फ्रेम होता है और Ctrl 3D प्रभावों की आवश्यकता होती है; csCaptureMouse - यह तत्व माउस घटनाओं को रोकता है; csDoubleClicks - जब तत्व पर डबल-क्लिक किया जाता है, तो OnDlClick ईवेंट उत्पन्न होता है; csClickEvents - जब तत्व पर क्लिक किया जाता है और माउस छोड़ा जाता है, तो ऑनक्लिक इवेंट उत्पन्न होता है)

एफबोर्सिएर:=बीएससिंगल; चौड़ाई:= 150; ऊंचाई:= 150;

टैब शीर्ष:= सत्य; (घटक पर स्विच करने की संभावना

टैब कुंजी दबाते समय)

9.2. TSimpleTree क्लास के डिस्ट्रक्टर को ओवरराइड करें।

किसी घटक के उपयोगकर्ता को घटक की उपस्थिति और फॉर्म पर उसकी स्थिति बदलने की अनुमति देने के लिए, एक बॉर्डर प्रॉपर्टी बनाएं और संरेखित करें, एंकर, रंग, सीटीएल 3 डी, फ़ॉन्ट, टैबऑर्डर, टैबस्टॉप गुणों को ओवरराइड करें:

एफबॉर्डर: टीबॉर्डर स्टाइल

प्रकाशित संपत्ति संरेखित करें; संपत्ति एंकर;

प्रॉपर्टी बॉर्डर: TBorderStyle पढ़ें FBorder लिखें SetBorder डिफ़ॉल्ट bsSingle;

संपत्तिरंग; संपत्ति Ctl3D; संपत्ति फ़ॉन्ट; संपत्ति टैबऑर्डर; संपत्ति टैबस्टॉप;

प्रक्रिया TSimpleTree.SetBorder(स्थिर मान: TBorderStyle);

यदि FBorder मान है तो FBorder:=Value शुरू करें; पुनः बनाएँWnd;

(मौजूदा विंडो को नष्ट कर देता है और फिर इसे दोबारा बनाता है)

प्रयोग। घटक फ़ाइल सहेजें.

एक परीक्षण एप्लिकेशन बनाएं. मॉड्यूल फ़ाइल को Main.pas, प्रोजेक्ट फ़ाइल Test.dpr के रूप में सहेजें।

फॉर्म पर एक बटन घटक रखें (कैप्शन प्रॉपर्टी को "घटक बनाएं" में बदलें), बटन के ऑनक्लिक इवेंट के लिए एक हैंडलर बनाएं:

प्रक्रिया TForml.buttonlclick (प्रेषक: TObject);

पेड़:=TSimpleTree.Create(फॉर्मल);

पेड़ से शुरू करें Parent:= forml; वाम:=5; शीर्ष:=5; अंत; अंत;

ट्री वेरिएबल का वर्णन करें और SimpleTree मॉड्यूल शामिल करें।

परीक्षण एप्लिकेशन चलाएँ. फॉर्म पर बटन पर क्लिक करने के बाद, TSimpleTree क्लास का एक उदाहरण प्रदर्शित होना चाहिए। एप्लिकेशन बंद करें और सुनिश्चित करें कि कोई त्रुटि न हो। ♦

आइए घटक में पेड़ (स्क्रॉलबार) को लंबवत रूप से स्क्रॉल करने की क्षमता जोड़ें। CreateParams विधि को ओवरराइड करें, जिसे विंडो बनने से पहले कॉल किया जाता है (Win API CreateWindow फ़ंक्शन को कॉल करने से पहले):

प्रक्रिया CreateParams(varparams: TCreateParams); ओवरराइड;

प्रक्रिया TSimpleTree.CreateParams(var पैरामीटर्स: TCreateParams);

विरासत में मिले CreateParams(Params); पैराम्स के साथ शुरुआत होती है

यदि FBorder = bsSingle है तो Style:=Style या WS_BORDER; शैली:"शैली या WS_VSCROLL; अंत; अंत;

प्रयोग। परीक्षण एप्लिकेशन चलाएँ. सुनिश्चित करें कि आपके द्वारा बनाए जा रहे घटक पर एक लंबवत स्क्रॉल बार दिखाई दे।

डेल्फ़ी सहायता प्रणाली का उपयोग करके, निर्धारित करें कि कौन सी नियंत्रण विंडो शैलियाँ मौजूद हैं और प्रत्येक शैली नियंत्रण विंडो की कार्यक्षमता को कैसे प्रभावित करती है। ♦

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

प्रक्रिया पेंट; ओवरराइड;

प्रक्रिया TSimpleTree.Paint;

आइए एक पेड़ में बड़ी संख्या में तत्व (नोड्स) जोड़ने की प्रक्रिया पर विचार करें। जैसे ही प्रत्येक नोड जोड़ा जाता है (जब तक वे घटक में प्रदर्शित नहीं होते हैं), पेड़ फिर से खींचा जाता है, जिससे पलक झपकती है। इस प्रभाव को रोकने के लिए, हम पेड़ में नोड्स जोड़ते समय "रेंडरिंग" को अवरुद्ध करने के लिए एक तंत्र बनाएंगे, जिसमें दो विधियां होंगी शुरुआतीपेंट (अवरुद्ध करने की शुरुआत) और एंडपेंट (अवरुद्ध करने का अंत):

FUpdateCount: पूर्णांक;

(कन्स्ट्रक्टर में, प्रारंभिक मान को शून्य पर सेट करें) सार्वजनिक

प्रक्रिया आरंभ अद्यतन;

प्रक्रिया समाप्ति अद्यतन;

प्रक्रिया TSimpleTree.BeginUpdate; शुरू

inc(FUpdateCount); अंत;

प्रक्रिया TSimpleTree.EndUpdate; शुरू

दिसंबर(FUpdateCount);

यदि FUpdateCount = 0 तो अमान्य करें; अंत;

नोड्स जोड़ते समय पेड़ को दोबारा बनने से रोकने के लिए, हम निम्नलिखित ऑपरेटर को पेंट विधि में जोड़ते हैं:

यदि FUpdateCount > 0 है तो बाहर निकलें;

नोड की स्थिति की गणना करने के लिए, हम प्रतीक "ए" की चौड़ाई और ऊंचाई के मान का उपयोग करते हैं। आइए क्रमशः दो फ़ील्ड FCharWidth और FCharHeight, टेक्स्ट कैरेक्टर की लंबाई और ऊंचाई दर्ज करें, जिनके मान निम्नलिखित विधि में अपडेट किए जाएंगे:

प्रक्रिया TSimpleTree.UpdateCharMetrics; शुरू

कैनवास.फ़ॉन्ट:= स्व.फ़ॉन्ट;

FCharHeight:= कैनवास.टेक्स्टहाइट('ए') + 2; FCharWidth:= Canvas.TextWidth('A1); समाप्त;

घटक के फ़ॉन्ट और आकार को बदलने की स्थिति के जवाब में UpdateCharMetrics विधि को कॉल किया जाएगा:

प्रक्रिया CMFontChanged(var Msg: TMessage);

संदेश CM_FONTCHANGED; प्रक्रिया WMSize(var Msg: TWMSize); संदेश WM_SIZE;

प्रक्रिया TSimpleTree.CMFontChanged(var Msg: TMessage); "नेगिन

अपडेटचारमेट्रिक्स; अंत;

प्रक्रिया TsimpleTree.WMSize(var Msg: TWMSize); शुरू

अपडेटचारमेट्रिक्स; अंत;

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

प्रॉपर्टी ड्रॉलाइन्स: बूलियन रीड एफड्रॉलाइन्स राइट सेटड्रॉलाइन्स डिफॉल्ट ट्रू;

प्रक्रिया TSimpleTree.SetDrawLines(स्थिर मान: बूलियन); शुरू

यदि FDrawLines<>मान तो शुरू करें

FDrawLines:=मूल्य; पुनः रंगना; अंत; अंत;

कंस्ट्रक्टर में FDrawLines फ़ील्ड के प्रारंभिक मान को परिभाषित करना न भूलें। पेंट विधि को इस प्रकार लिखा जा सकता है:

प्रक्रिया TSimpleTree.Paint;

प्रक्रिया DoDrawNodes;

प्रक्रिया DoDrawLines;

यदि FUpdateCount > 0 है तो बाहर निकलें;

DoDrawNodes; (नोड्स बनाएं)

यदि FDrawLines है तो DoDrawLines; (लाइन खींचना)

DoDrawNodes प्रक्रिया एक निर्देशिका ट्री के नोड्स को खींचती है। हालाँकि, किसी विशेष समय पर, केवल उपयोगकर्ता द्वारा विस्तारित ट्री नोड्स को खींचने की आवश्यकता होती है। हम ट्री नोड्स की सूची को TSimpleTree वर्ग के TList प्रकार के संरक्षित (निजी) फ़ील्ड FDrawList में संग्रहीत करेंगे।

स्व-प्रशासित कार्य

9.3. TSimpleTree क्लास के कंस्ट्रक्टर में, एक FDrawList (TList क्लास का एक उदाहरण) बनाएं, और डिस्ट्रक्टर में, इस वेरिएबल से जुड़ी मेमोरी को मुक्त करें।

FDrawList में ट्री नोड्स के लिए पॉइंटर्स होते हैं। प्रत्येक नोड TSimpleNode वर्ग का एक उदाहरण है:

TSimpleNode = वर्ग(TObject) निजी

Ftree: TSimpleTree/ (पेड़ की ओर सूचक)

एफपैरेंट: टीसिंपलनोड; (मूल नोड)

एफसी बच्चे: टी सूची; (बाल नोड्स की सूची)

एफकैप्शन: स्ट्रिंग; (प्रदर्शित करने के लिए पाठ)

फ़्लेवल: पूर्णांक; (नोड स्तर)

FIndex: पूर्णांक;

(मूल नोड के चाइल्ड नोड्स की सूची में सूचकांक)

एफएक्स, वित्तीय वर्ष: पूर्णांक;

(अंतिम निर्देशांक जिस पर नोड खींचा गया था)

Fविस्तारित: बूलियन; (विस्तारित)

FAbsolutelndex: पूर्णांक; (पेड़ में नोड सूचकांक)

प्रक्रिया पुनः तैयार करना; (अंतिम निर्देशांक का उपयोग करके नोड पुनः आरेखण)

प्रक्रिया DrawAt(X, Y: पूर्णांक);

(X, Y निर्देशांक पर एक नोड बनाएं)

फ़ंक्शन GetChildren(सूचकांक: पूर्णांक): TSimpleNode;

फ़ंक्शन GetChildrenCount: पूर्णांक;

फ़ंक्शन GetSelected: बूलियन;

प्रक्रिया SetSelected(const मान: बूलियन);

प्रक्रिया सेटकैप्शन (स्थिर मान: स्ट्रिंग);

प्रक्रिया SetExpanded(const मान: बूलियन); जनता

कंस्ट्रक्टर क्रिएट (ATree: TSimpleTree);

विध्वंसक नष्ट; ओवरराइड;

प्रक्रिया क्लियरचिल्ड्रेन; (सभी चाइल्ड नोड्स साफ़ करें)

संपत्ति बच्चे: TSimpleNode GetChildren पढ़ें;

संपत्ति चिल्ड्रनकाउंट: पूर्णांक पढ़ें GetChildrenCount;

संपत्ति कैप्शन: स्ट्रिंग पढ़ें FCaption लिखें SetCaption;

संपत्ति स्तर: पूर्णांक पढ़ें FLevel;

संपत्ति चयनित: बूलियन पढ़ें GetSelected लिखें SetSelected;

(चाहे नोड चयनित हो)

संपत्ति Absolutelndex: पूर्णांक पढ़ें FAbsolutelndex;

संपत्ति सूचकांक: पूर्णांक FIndex पढ़ें;

संपत्ति विस्तारित: बूलियन पढ़ें FExpanded लिखें SetExpanded; अंत;

निर्देशिका नाम अद्यतन:

प्रक्रिया TSimpleNode.SetCaption(स्थिर मान: स्ट्रिंग); शुरू

अगर प्रतिक्रिया<>तो मूल्य

कार्रवाई:=मूल्य; जीट्री.अमान्य;

स्वतंत्र पूर्ति के लिए कार्य

9.4. TSimpleNode वर्ग के GetChildrenCount (FChildren सूची में शामिल तत्वों की संख्या लौटाता है) और GetChildren (इंडेक्स संख्या के साथ FChildren सूची तत्व लौटाता है) विधियों को लागू करें।

कृपया ध्यान दें कि TSimpleTree वर्ग घोषणा में TSimpleNode प्रकार का एक तत्व शामिल है, और इसके विपरीत। कंपाइलर को यह बताने के लिए कि TSimpleTree क्लास टाइप सेक्शन में मौजूद है, क्लास का वर्णन इस प्रकार करें:

TSimpleTree = वर्ग; TSimpleNode = वर्ग(TObject)

TSimpleTree = वर्ग(TCustomControl)

आइए TSimpleNode क्लास के तरीकों को लागू करें। कंस्ट्रक्टर फ़ील्ड मानों को आरंभ करता है और एक वेरिएबल के लिए मेमोरी भी आवंटित करता है जिसमें उपनिर्देशिकाओं के लिंक होंगे:

कंस्ट्रक्टर TSimpleNode.Create(ATree: TSimpleTree); शुरू

विरासत में मिला निर्माण;

FChildren:=TList.बनाएँ;

Fविस्तारित:=गलत; अंत;

विध्वंसक FChildren वेरिएबल (बाल निर्देशिकाओं के लिंक की एक सूची) से जुड़ी मेमोरी को मुक्त करता है:

विध्वंसक TSimpleNode.Destroy; शुरू

साफ़ बच्चे; एफसीचिल्ड्रेन। स्वतंत्र-विरासत में मिला विनाश; अंत;

सभी चाइल्ड उपनिर्देशिकाओं को हटाना एक पुनरावर्ती प्रक्रिया द्वारा किया जाता है जो वर्तमान उपनिर्देशिका के चाइल्ड उपनिर्देशिकाओं के लिंक संग्रहीत करने के लिए उपयोग की जाने वाली मेमोरी को मुक्त करता है:

प्रक्रिया TSimpleNode.ClearChildren;

वर i: पूर्णांक; शुरू

i:=0 से FChildren.Count - 1 के लिए

9.5. ट्री नोड्स प्रदर्शित करते समय, TSimpleTree वर्ग के निम्नलिखित गुणों का उपयोग किया गया था:

प्रॉपर्टी टेक्स्ट कलर: टी कलर इंडेक्स 0 GetTreeColor पढ़ें

राइटसेटट्री कलर; प्रॉपर्टी लाइन्स कलर: टी कलर। ..; संपत्ति SelTextColor: TColor संपत्ति SelBackColor: TColor ...;

एक संपत्ति सरणी का उपयोग करके, ऊपर सूचीबद्ध गुणों को लागू करें। क्रिएट कंस्ट्रक्टर में इन गुणों के प्रारंभिक मान सेट करना न भूलें।

हम थोड़ी देर बाद GetSelected, SetSelected, SetExpanded तरीकों के कार्यान्वयन पर लौटेंगे।

इस प्रकार, TSimpleTree.Paint विधि की आंतरिक प्रक्रिया DoDrawNodes, जो ट्री नोड्स प्रदर्शित करती है, को कथनों के निम्नलिखित अनुक्रम को निष्पादित करना होगा:

वर i: पूर्णांक; शुरू

i:=0 से FDrawList.Count - 1 के लिए

TSimpleNode(FDrawList[i]).DrawAt(0, i * FCharHeight); अंत;

NodelnView विधि एक नोड की दृश्यता की जांच करने के लिए डिज़ाइन की गई है (TSimpleTree वर्ग के निजी अनुभाग में वर्णित):

फ़ंक्शन TSimpleTree.NodelnView (नोड: TSimpleNode): बूलियन; शुरू

परिणाम:=FDrawList.IndexOf(नोड) > -1; अंत;

पेंट विधि में एक पेड़ बनाने के लिए रेखाएं खींची जाती हैं) जिसकी आंतरिक प्रक्रिया पेंट विधि की DoDrawLines है:

प्रक्रिया DoDrawLines; वर मैक्सलेवल: पूर्णांक; मैं:पूर्णांक; जे:पूर्णांक; शुरू

अधिकतम स्तर:=0; Canvas.Pen.Color:=लाइन्सकलर;

(रेखा चित्र का रंग सेट करें) i:=0 से FDrawList.Count - 1 के लिए

(हम सभी ट्री नोड्स को देखते हैं) TSimpleNode(FDrawList[i]) के साथ यदि FLevel > 0 है तो करें

Canvas.MoveTo(FX + FCharWidth, FY + FCharHeight div 2); Canvas.LineTo(FX, FY + FCharHeight div 2); यदि (Flndex > 0) और

(NodeInView(FParent.Children) नहीं) फिर Canvas.LineTo(FX, 0) अन्यथा

यदि FIndex=0 तो Canvas .LineTo (FX, FY - FCharHeight div 2) अन्यथा Canvas.LineTo (FX, FParent.Children.FY); यदि फ्लेंडेक्स< FParent.ChildrenCount - 1 then if not NodelnView(FParent.Children) then Canvas.LineTo(FX, ClientHeight); if MaxLevel < FLevel then MaxLevel:=FLevel; end;

i:=l से MaxLevel के लिए j:=0 शुरू करें; जबकि(जे< FDrawList.Count) and

(TSimpleNode(FDrawList[j]).स्तर<>i) do Inc(j); यदि j = FDrawList.Count तो प्रारंभ करें

Canvas.MoveTo((i + 1) * FCharWidth, 0); Canvas.LineTo((i + 1) * FCharWidth, clientHeight); अंत; अंत; अंत;

स्व-प्रशासित कार्य

9.6. TSimpleTree.DoDrawLmes विधि के प्रत्येक कथन की व्याख्या करें। DoDrawLines पद्धति के सभी संभावित कार्यान्वयन दीजिए।

आइए FNodes नोड्स की एक सूची बनाएं। TSimple-Tree वर्ग के विवरण में हम निम्नलिखित तत्वों का परिचय देते हैं:

एफनोड्स: टीलिस्ट; (सभी नोड्स की वैश्विक सरणी)

FStartlndex: पूर्णांक; (पूर्ण नोड सूचकांक,

जिससे हम चित्र बनाना शुरू करते हैं। प्रारंभिक मान शून्य है) FMaxLinesInView: पूर्णांक;

(प्रदर्शित करने के लिए नोड्स की अधिकतम संख्या) FMaxLines: पूर्णांक; (दृश्य नोड्स की अधिकतम संख्या)

फ़ंक्शन GetNode(सूचकांक: पूर्णांक): TSimpleNode; फ़ंक्शन GetNodeCount: पूर्णांक;

संपत्ति नोड्स: TSimpleNode

GetNode पढ़ें; गलती करना; (सूचकांक संख्या के साथ नोड लौटाता है) संपत्ति NodeCount: पूर्णांक GetNodeCount पढ़ें;

(नोड्स की कुल संख्या)

स्व-प्रशासित कार्य

9.7. GetNode और GetNodeCount तरीकों को लागू करें। कंस्ट्रक्टर में FNodes वेरिएबल के लिए मेमोरी आवंटित करना और इसे डिस्ट्रक्टर में मुक्त करना न भूलें।

ट्री नोड्स की सूची अपडेटड्रालिस्ट विधि में तैयार की जाती है, जिसे निम्नलिखित प्रत्येक घटना के जवाब में बुलाया जाएगा:

एक घटक का आकार बदलना,

नए नोड जोड़ना, और स्क्रॉल करना,

किसी गाँठ को मोड़ना या खोलना।

प्रक्रिया TSimpleTree.UpdateDrawList;

फ़ंक्शन सूचीपूर्ण: बूलियन; (सूची पूर्णता की जांच करें)

परिणाम:=FDrawList.Count >= FMaxLinesInView; अंत;

प्रक्रिया फॉर्मड्रॉलिस्ट (नोड: TSimpleNode);

(सूची निर्माण) var i: पूर्णांक; शुरू

यदि ListFull नहीं है तो FDrawList.Add(Node); इंक(एफमैक्सलाइन्स);

यदि नोड. FExpanded फिर प्रारंभ करें (यदि नोड विस्तारित है)

i:=0 से Node.ChildrenCount - 1 के लिए formDrawList(Node.Children[i]) करें; Inc(FMaxLines, Node.ChildrenCount); अंत; अंत;

वर i, न्यूनतम: पूर्णांक; शुरू

FMaxLinesInView:=(क्लाइंटहाइट div FCharHeight) + 1; FDrawList.साफ़ करें; FMaxLines:=0;

यदि FStartlndex + FMaxLinesInView > GetNodeCount तो Min:=GetNodeCount -FSartlndex अन्यथा Min:=FMaxLinesInView; i:=FStartIndex से FStartIndex + न्यूनतम - 1 के लिए

FDrawList.Add(FNodes[i]); (सूची में नोड्स जोड़ें)

i:=0 से GetNodeCount - 1 के लिए करें

(दृश्य नोड्स की अधिकतम संख्या की गणना करें) नोड्स के साथ [i] करें

यदि FParent = शून्य है तो Inc(FMaxLines)
अन्यथा यदि FParent.FExpanded तो Inc(FMaxLines);
अपडेटस्क्रॉलबार; (स्क्रॉलबार स्थिति को अद्यतन करना)

स्क्रॉलबार घटक की स्थिति को अपडेटस्क्रॉलबार विधि का उपयोग करके अद्यतन किया जाता है:

प्रक्रिया TSimpleTree.UpdateScrollBar; var Scrolllnfo: TScrollInfo;

(संरचना जिसमें स्क्रॉलबार डिस्प्ले विकल्प शामिल हैं) प्रारंभ करें

यदि FMaxLinesInView >= FMaxLines तो शोस्क्रॉलबार(हैंडल, SBJVERT, गलत)

(छिपाना ऊर्ध्वाधर पट्टीस्क्रॉल करें) अन्यथा प्रारंभ करें

फिलचार(स्क्रॉलएनएफओ, साइजऑफ(टीएसक्रोलइन्फो), 0); Scrolllnfo.cbSize:=SizeOf(TScrollInfo);

Scrolllnfo. fMask:=SIF_ALL; (स्क्रॉल बार के प्रदर्शन के अनुपात में पृष्ठ का आकार सीमित करें, स्क्रॉलिंग रेंज के लिए न्यूनतम और अधिकतम मान) Scrolllnfo.nMax:=FMaxLines;

(प्रदर्शित पंक्तियों की अधिकतम संख्या)

ScrollInfo.nPage:=FMaxLinesInView; (पंक्तियों की कुल संख्या) ScrollInfo.nPos:=FSartIndex; शोस्क्रॉलबार(हैंडल, SB_VERT, ट्रू);

(ऊर्ध्वाधर स्क्रॉलबार दिखाएं) SetScrollInfo(हैंडल, SB_VERT, Scrolllnfo, True);

(असाइन किए गए पैरामीटर सेट करें) अंत; अंत;

TSimpleTree वर्ग के निजी अनुभाग में, UpdateDrawList और UpdateScrollBar विधियों का विवरण जोड़ें।

घटक का आकार बदलने के लिए UpdateScrollBar विधि को भी कहा जाता है। स्क्रॉलिंग का पूर्ण समर्थन करने के लिए, WMVSCROLL संदेश को संसाधित करना आवश्यक है:

प्रक्रिया WMVScroll(var Msg: TWMVScroll); संदेश WM_VSCROLL;

प्रक्रिया TSimpleTree.WMVScroll(var Msg: TWMVScroll); शुरू

केस संदेश SBJTHUMBPOSITION का स्क्रॉल कोड: प्रारंभ करें

(पूर्ण स्थिति तक स्क्रॉल करें।
वर्तमान स्थिति npos पैरामीटर के मान से निर्धारित होती है)
SetScrollPos(हैंडल, SB_VERT, Msg.Pos, True);
FStartlndex:=Msg.Pos;
अंत;
SB_LINEUP: (ऊपर)

यदि FStartlndex > 0 है तो Dec (FSartlndex) अन्यथा बाहर निकलें;
SB_LINEDOWN: (एक पंक्ति नीचे स्क्रॉल करें)

यदि FStartIndex< FMaxLines - FMaxLinesInView + 1 then

Inc(FStartIndex) अन्यथा बाहर निकलें; अन्यथा बाहर निकलें; अंत;

अद्यतन ड्रा सूची; (सूची अद्यतन)

अमान्य करें; (घटक पुनः आरेखण)

प्रयोग। घटक मॉड्यूल सहेजें. परीक्षण एप्लिकेशन चलाएँ. सुनिश्चित करें कि जब आप स्क्रॉल बार को हिलाते हैं, तो स्क्रॉलबार घटक गायब हो जाता है। ♦

आइए WMSize इवेंट हैंडलर में नोड्स की सूची को अपडेट करने और स्क्रॉलबार को फिर से बनाने के तरीकों के लिए एक कॉल जोड़ें:

प्रक्रिया TsimpleTree.WMSize(var Msg: TWMSize); विरासत में मिला शुरू;

अपडेटचारमेट्रिक्स; अद्यतन ड्रा सूची; अपडेटस्क्रॉलबार; अंत;

प्रयोग। परीक्षण एप्लिकेशन चलाएँ. क्या स्क्रॉल बार दृश्यमान है? समझाइए क्यों। ♦

निर्मित वृक्ष में कम से कम एक नोड होता है। मुख्य नोड TSimpleNode प्रकार के FMainNode फ़ील्ड में संग्रहीत है और केवल-पढ़ने के लिए MainNode प्रॉपर्टी के माध्यम से पहुंच योग्य है।

TSimpleNode प्रकार की चयनित नोड संपत्ति चयनित नोड के लिए एक सूचक है; इस नोड पर लिखने के लिए SetSelectedNode विधि को कॉल किया जाता है।

TSimpleTree वर्ग के सूचीबद्ध गुणों और विधियों का वर्णन करें। SetSelectedNode विधि निम्नानुसार लागू की गई है:

प्रक्रिया TSimpleTree.SetSelectedNode(const मान: TSimpleNode); वर OldNode: TSimpleNode; यदि FSelectedNode प्रारंभ करें<>मान तो शुरू करें

(यदि कोई अन्य नोड चयनित होना चाहिए) OldNode:=FSelectedNode; FSelectedNode:= मान; यदि (ओल्डनोड<>nil) और NodelnView(OldNode) फिर

(यदि पहले चुना गया नोड दृश्यमान है -

इसे दोबारा बनाया जाना चाहिए) OldNode.Redraw;

यदि NodelnView(FSelectedNode) तो (यदि वर्तमान में चयनित नोड दिखाई दे रहा है, तो इसे भी दोबारा बनाया जाना चाहिए)

FSelectedNode.Redraw; अंत; अंत;

TSimpleTree.Create कंस्ट्रक्टर में निम्नलिखित कथन जोड़ें:

FNodes:=TList.बनाएँ;

FMainNode:^TSimpleNode.Create(स्वयं);

FSelectedNode:= FMainNode;

FNodes.Add(FMainNode);

FMainNode.FAbsolutelndex:= 0;

माउस इवेंट को संभालने के लिए, हम माउसडाउन विधि को ओवरराइड करेंगे:

प्रक्रिया TSimpleTree.MouseDown (बटन: TMouseButton; Shift: TShiftState; X, Y: पूर्णांक); वर नोड: TSimpleNode; शुरू

विरासत में मिला माउसडाउन(बटन, शिफ्ट, एक्स, वाई);

(डिफ़ॉल्ट माउस बटन प्रेस इवेंट हैंडलर को कॉल करें)
नोड:=नोडएट; (हम नोड को परिभाषित करते हैं)

यदि नोड<>शून्य फिर चयनितनोड:=नोड;

यदि (Shift = ) और (FSelectedNode<>शून्य) फिर
यदि FSelectedNode . FExpanded (यदि चयनित नोड विस्तारित है)
फिर संक्षिप्त करें

"अबाउट" फॉर्म का उपयोग सूचनात्मक उद्देश्यों के लिए किया जाता है। अक्सर इसमें कार्यक्रम का नाम, उद्देश्य, लेखक आदि शामिल होते हैं लाइसेंस समझौता. अक्सर यह मुख्य मेनू में सहायता->प्रोग्राम के बारे में... के अंतर्गत स्थित होता है।

डेल्फ़ी (डेल्फ़ी, डेल्फ़ी) में "अबाउट" फ़ॉर्म बनाने के लिए, आपको एक नियमित फ़ॉर्म बनाना होगा, जैसा कि नीचे दिए गए चित्र में दिखाया गया है:

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

फॉर्म बनाने के बाद, आपको आवश्यक आयाम सेट करने होंगे और निम्नलिखित सेटिंग्स करने की अनुशंसा की जाती है:

• स्थिति गुण सेट करें. यहां डिफ़ॉल्ट मान poDesigned है, जो यह निर्देशित करता है कि खुलने वाला फॉर्म वहीं दिखाई देगा जहां वह प्रोग्राम बनाए जाने के समय था। इसलिए, आपको इसे सेट करने की आवश्यकता है ताकि फॉर्म उस फॉर्म के सापेक्ष केंद्रित दिखाई दे जिससे इसे बुलाया गया था। ऐसा करने के लिए, स्थिति गुण को poOwnerFormCenter पर सेट करें।
• स्क्रॉल बार को प्रदर्शित होने से रोकने के लिए आप ऑटोस्क्रॉल प्रॉपर्टी को अक्षम भी कर सकते हैं।
• चूंकि फॉर्म में संक्षिप्त स्थैतिक जानकारी होगी, इसलिए रनटाइम पर फॉर्म का आकार बदलने में सक्षम होने की कोई आवश्यकता नहीं है। इसलिए, बॉर्डर स्टाइल प्रॉपर्टी को bsSingle पर सेट करें।
• आपको borderIcons में नेस्टेड संपत्तियों को भी कॉन्फ़िगर करने की आवश्यकता है। आपको biMinimize और biMaximize गुणों को गलत पर सेट करने की आवश्यकता है, जो आपको क्रमशः फॉर्म को छोटा और विस्तारित करने की अनुमति नहीं देगा।

वर्णित सभी सेटिंग्स के अलावा, आप फॉर्म को पृष्ठभूमि से भी सजा सकते हैं। ऐसा करने के लिए, आपको छवि को घटक पैलेट से रखना होगा, जो अतिरिक्त टैब में स्थित है यदि आप डेल्फ़ी 7 में लिख रहे हैं। संपत्ति में, आपको तुरंत मूल्य alClient सेट करने की आवश्यकता है, जो छवि के लिए कंटेनर को खींच देगा पूरे फॉर्म को.

इसके अलावा, TLabel का उपयोग करते समय, आप ट्रांसपेरेंट को सत्य पर सेट कर सकते हैं। यह विकल्प लेबल की पृष्ठभूमि को पारदर्शी बना देगा, जो सहायक पृष्ठभूमि का उपयोग करने पर अधिक अच्छा लगेगा।

निष्कर्ष

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

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

डेल्फ़ी संरचना और सिस्टम आवश्यकताएँ

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

हेतु आवश्यकताओं के संबंध में ऑपरेटिंग सिस्टम, फिर यद्यपि औपचारिक रूप से डेल्फ़ी विंडोज़ के किसी भी 32-बिट संस्करण पर चल सकता है, मैं एनटी लाइन से विंडोज़ का उपयोग करने की दृढ़ता से अनुशंसा करता हूँ, अर्थात। विंडोज़ 2000 या एक्सपी. तथ्य यह है कि विंडोज़ 9x में, अपनी 16-बिट विरासत के कारण, उपलब्ध सिस्टम संसाधनों की मात्रा पर गंभीर सीमाएँ हैं, चाहे आप कितना भी शक्तिशाली पीसी उपयोग करें। इसके अलावा, विंडोज़ 9x अपेक्षाकृत बड़ी - 128 एमबी से अधिक - रैम की मात्रा का भी प्रभावी ढंग से उपयोग नहीं कर सकता है। इस तथ्य का उल्लेख नहीं करने के लिए कि विंडोज 9x मल्टीथ्रेडिंग या डुअल-कोर प्रोसेसर का समर्थन नहीं करता है, जो हाल ही में लोकप्रियता प्राप्त कर रहे हैं, और पीसी हार्डवेयर घटकों के निर्माताओं ने लंबे समय से इस ओएस परिवार के लिए ड्राइवरों को अनुकूलित करना छोड़ दिया है। इन सबका परिणाम आधुनिक कंप्यूटरों पर कम प्रदर्शन और एक जटिल और संसाधन-गहन एप्लिकेशन पर काम करते समय सिस्टम के क्रैश होने का एक बहुत बड़ा जोखिम है।

एक अन्य महत्वपूर्ण मुद्दा मॉनिटर है. फिर, औपचारिक रूप से कोई भी एसवीजीए मॉनिटर पर्याप्त है। लेकिन 1024 गुणा 768 पिक्सेल से कम स्क्रीन रिज़ॉल्यूशन वाले डेल्फ़ी परिवेश में काम करना बेहद कठिन है: ध्यान रखें कि आपको लगातार डेल्फ़ी के नियंत्रण और अपने स्वयं के (विकसित) एप्लिकेशन दोनों को देखने की आवश्यकता होती है। आरामदायक काम के लिए, मैं 1280 गुणा 1024 पिक्सल के कार्यशील रिज़ॉल्यूशन वाले उच्च गुणवत्ता वाले 19" मॉनिटर की सिफारिश करूंगा। इसके अलावा, यदि यह एक नियमित सीआरटी मॉनिटर (या यहां तक ​​कि एक एलसीडी, लेकिन एनालॉग कनेक्शन के साथ) है, तो आप भी ऐसा करेंगे। एक उच्च गुणवत्ता वाले वीडियो कार्ड की आवश्यकता है जो तस्वीर को धुंधला किए बिना बिल्कुल स्पष्ट प्रदान कर सके। सीआरटी मॉनिटर के लिए, कम से कम 85 हर्ट्ज की छवि ताज़ा दर के साथ निर्दिष्ट रिज़ॉल्यूशन के लिए समर्थन सुनिश्चित करना भी महत्वपूर्ण है।

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

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

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

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

इसके अलावा, इस समूह में एक सहायता उपसमूह होगा, और इसमें, कई सहायता फ़ाइलों के बीच, एक और एक होगा, उनमें से और भी अधिक - एमएस एसडीके सहायता फ़ाइलें। इसलिए, आपको इन सभी फ़ाइलों का नियमित रूप से उपयोग करना होगा, और स्थिति न केवल उनकी मात्रा और मात्रा से बढ़ी है, बल्कि इस तथ्य से भी है कि वे रूसी संस्करण में मौजूद नहीं हैं। इस प्रकार, ज्ञान अंग्रेजी मेंडेल्फ़ी और प्रोग्रामिंग दोनों को सामान्य रूप से सीखने में यह एक अच्छी मदद होगी।

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

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

एकीकृत विकास पर्यावरण

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

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

चावल। 2.1. डेल्फ़ी 7 आईडीई डिफ़ॉल्ट दृश्य

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

चावल। 2.2. डेल्फ़ी मुख्य विंडो का "अनुकूलित" दृश्य

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

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

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

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

चावल। 2.3. घटक पैलेट को अनुकूलित करने के लिए वीसीएल का ज्ञान आवश्यक है

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

सभी घटकों को टैब में समूहीकृत किया गया है, जिनकी संख्या और संरचना संस्करण और वितरण विकल्प के आधार पर थोड़ी भिन्न होती है। इस प्रकार, डेल्फ़ी 7 एंटरप्राइज़ में 33 टैब हैं जिनमें एक या दूसरे वीसीएल समूह से संबंधित घटक शामिल हैं (तालिका 2.1)।

तालिका 2.1. डेल्फ़ी 7 एंटरप्राइज़ घटक पैलेट पृष्ठ

पृष्ठ	नाम	विवरण
	मानक	विंडोज़ एप्लिकेशन इंटरफ़ेस के मूल तत्व (मेनू, बटन, हस्ताक्षर, आदि)
	अतिरिक्त	वीसीएल में बेहतर नियंत्रणों का एक सेट मिला
	32-बिट विंडोज़	विंडोज़ 95 और इस ओएस के बाद के संस्करणों के लिए विशिष्ट एप्लिकेशन इंटरफ़ेस तत्व
	प्रणाली	16 विंडोज़ सिस्टम फ़ंक्शंस (टाइमर, ओएलई, डीडीई) पर नियंत्रण और पहुंच
	डेटा प्राप्त करना	डेटाबेस एक्सेस के लिए घटकों का मानक सेट
	डेटा तत्व	डेटाबेस तक पहुँचने के लिए उपयोगकर्ता इंटरफ़ेस तत्व
		dbExpres SQL ड्राइवर का उपयोग करके डेटाबेस तक पहुँचने के लिए घटक
		SOAP के माध्यम से दूरस्थ वेब सर्वर के साथ इंटरैक्ट करने के लिए घटक
		DCOM के माध्यम से सर्वर के साथ इंटरैक्ट करने के लिए घटक
	बोर्लैंड डेटाबेस इंजन	बीडीई के माध्यम से डेटाबेस तक पहुंचने के लिए घटक (सरल डेटाबेस के लिए क्लासिक विकल्प)
		ADO के माध्यम से डेटाबेस के साथ इंटरैक्ट करने के लिए घटक
		इंटरबेस डेटाबेस के साथ सीधे संपर्क के लिए घटक
	इंटरबेस का प्रशासन	इंटरबेस डेटाबेस सर्वर के इंटरैक्शन और प्रबंधन के लिए घटक
		XML के माध्यम से डेटा के साथ इंटरैक्ट करने के लिए घटक
		विभिन्न इंटरनेट प्रोटोकॉल के माध्यम से डेटा के साथ काम करने के लिए घटक
		इंटरनेट के माध्यम से काम करने के लिए ActiveX घटकों का एक सेट
		डेटाबेस में जानकारी संसाधित करने के लिए घटकों का एक सेट
		मानक और विस्तारित संवाद बॉक्स
		विंडोज़ 3.1 के लिए विशिष्ट उपयोगकर्ता इंटरफ़ेस घटक
		कई दृश्य घटक जो आधिकारिक तौर पर समर्थित नहीं हैं
		कई एम्बेडेड ActiveX अनुप्रयोग
	बड़बड़ाना रेपो rts	रिपोर्ट बनाने के लिए घटकों का एक सेट
	इंडी ग्राहक	विभिन्न इंटरनेट प्रोटोकॉल और सेवाओं के लिए क्लाइंट घटकों का एक सेट
	इंडी सर्वर	विभिन्न इंटरनेट प्रोटोकॉल और सेवाओं के लिए घटक सर्वर का एक सेट
	इंडी हैंडलर	घटकों का एक सेट जो आपको इंडी क्लाइंट और सर्वर से संदेश पकड़ने की अनुमति देता है
इंडी मेरे पास एनडीलर हैं	इंडी आई/ओ	अन्य इंडी घटकों की कनेक्शन गतिविधि की निगरानी के लिए घटक
	इंडी यूटिलिटीज	विभिन्न टीसीपी अनुप्रयोगों को विकसित करने में उपयोगी सहायक घटकों का एक सेट
		इसमें एक घटक शामिल है जो आपको COM+ प्रबंधन सर्वर बनाने की अनुमति देता है
IW मानक, डेटा, ग्राहक पक्ष, नियंत्रण		पीडीए और स्मार्टफ़ोन सहित किसी भी वेब क्लाइंट के लिए वेब एप्लिकेशन बनाने के लिए विशेष क्रॉस-प्लेटफ़ॉर्म घटकों का एक सेट
	एमएस ऑफिस सर्वर	Microsoft Office अनुप्रयोगों के साथ इंटरैक्ट करने के लिए ActiveX घटकों का एक सेट

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

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

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

डेल्फ़ी में परियोजनाएँ

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

• डीपीआर - वास्तविक परियोजना फ़ाइल;
• पीएएस - ऑब्जेक्ट पास्कल कोड वाले एप्लिकेशन मॉड्यूल;
• डीएफएम - एप्लिकेशन मॉड्यूल जिसमें एप्लिकेशन विंडो के बारे में जानकारी होती है;
• Res - एम्बेडेड एप्लिकेशन संसाधनों वाली फ़ाइलें (उदाहरण के लिए, आइकन);
• ओबीजे - संकलन के लिए तैयार ऑब्जेक्ट कोड वाली फ़ाइलें;
• सीएफजी, डीओएफ, डीएसके - डेल्फ़ी सेवा फ़ाइलें।

प्रोजेक्ट के मुख्य घटक, प्रोजेक्ट फ़ाइल (डीपीआर) के अलावा, पीएएस और डीएफएम मॉड्यूल हैं। इसके अलावा, प्रत्येक विंडो मॉड्यूल (डीएफएम) का अपना होता है सॉफ्टवेयर मॉड्यूल(पास)।

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

ध्यान
खुद को दोहराने से बचने के लिए, भविष्य में हम क्रियाओं के ऐसे अनुक्रमों को निम्नानुसार नामित करेंगे: फ़ाइल > नया > एप्लिकेशन।

परिणामस्वरूप, हमें एक नया प्रोजेक्ट प्राप्त होगा, जो आगे के उपयोग के लिए पूरी तरह से तैयार है (चित्र 2.1 देखें)। इसके अलावा, यह पहले से ही इस स्तर पर पूरा किया जा सकता है! ऐसा करने के लिए, बस डिबगिंग टूलबार पर स्थित रन बटन पर क्लिक करें, या उसी नाम के मेनू से रन आइटम का चयन करें (रन> रन), लेकिन त्वरित अनुप्रयोग विकास के लिए F9 कुंजी दबाना सबसे अच्छा है: डेल्फ़ी पर्यावरण, कम से कम हॉट कुंजी कुंजी के बुनियादी संयोजनों का ज्ञान" बस आवश्यक है।

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

चावल। 2.4. डेल्फ़ी में सबसे पहला आवेदन

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

चावल। 2.5. ऑब्जेक्ट इंस्पेक्टर विंडो

इसके ऊपरी हिस्से में एक ड्रॉप-डाउन सूची है जिसमें चयनित फॉर्म इंटरफ़ेस के सभी तत्व शामिल हैं; इस मामले में, केवल फॉर्म ही होगा, जिसे ऑब्जेक्ट नाम (फॉर्म 1) के रूप में चिह्नित किया जाएगा। आगे उन सभी ऑब्जेक्ट गुणों की एक सूची है जिन्हें दृश्य विकास प्रक्रिया के दौरान बदला जा सकता है।

टिप्पणी
डेल्फ़ी में वस्तुओं के सभी गुण जिन्हें बदला जा सकता है, उन्हें रन-टाइम (रनटाइम) और डिज़ाइन-टाइम (विकास समय) में विभाजित किया गया है। इसके अलावा, पूर्व को केवल प्रोग्राम चलने के दौरान ही बदला जा सकता है, जबकि बाद वाले दृश्य संपादन के दौरान पहले से ही उपलब्ध हैं।

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

कुछ गुण सीधे मान दर्ज करके नहीं, बल्कि पूर्व निर्धारित मानों में से किसी एक को चुनकर बदले जाते हैं। सबसे सरल मामले में, यह एक गलत-सच्चा विकल्प (गलत या सही) हो सकता है, इस या उस विकल्प को सक्षम या अक्षम कर सकता है। कभी-कभी सूचियाँ बहुत लंबी हो जाती हैं। उदाहरण के लिए, रंग चयन के लिए कई रंग उपलब्ध हैं, जिनमें सिस्टम रंग भी शामिल हैं। उदाहरण के लिए, हमारे मामले में Color प्रॉपर्टी का मान clBtnFace है, जिसका अर्थ है कि बटन का रंग इस पर सेट है विंडोज़ सेटिंग्स. हम इसे किसी अन्य रंग में बदल सकते हैं, या तो एक सिस्टम रंग (उदाहरण के लिए, clCaptionText - विंडो शीर्षक टेक्स्ट का रंग) या एक स्पष्ट रंग, उदाहरण के लिए, clWhite (सफ़ेद)।

आप देख सकते हैं कि कुछ संपत्तियों को "+" चिन्ह से चिह्नित किया गया है। इसका मतलब यह है कि ऐसी संपत्ति एक समग्र संपत्ति है, और यदि आप आइकन पर क्लिक करते हैं, तो व्यक्तिगत पैरामीटर वाली पंक्तियां खुल जाएंगी। उदाहरण के लिए, आप इस तरह से borderIcons प्रॉपर्टी का विस्तार कर सकते हैं और biMinimize पैरामीटर के मान को True से False में बदल सकते हैं। ऐसा करने से, हम विंडो के सिस्टम नियंत्रण के लिए जिम्मेदार संपत्ति के मूल्य को बदल देंगे ताकि संपूर्ण स्क्रीन को भरने के लिए विंडो को अधिकतम करने का कार्य उपलब्ध न हो।

संपादन के लिए ऐसे गुण भी हैं जो एक अलग विंडो खोलते हैं। उदाहरण के लिए, समान रंग को दिए गए विकल्पों की सूची से चुनकर नहीं, बल्कि मानक को खोलकर निर्धारित किया जा सकता है खिड़कियाँ खिड़कीरंग चयन. ऐसा करने के लिए, बस रंग सूची क्षेत्र पर डबल-क्लिक करें। अन्य मामलों में (उदाहरण के लिए, फ़ॉन्ट गुणों का चयन करने के लिए), सेटिंग्स विंडो को ऐसे गुणों के बगल में दीर्घवृत्त वाले बटन पर क्लिक करके बुलाया जा सकता है।

खैर, अभी के लिए, आइए फॉर्म 1 के उन सभी गुणों को एक साथ लाएं जिन्हें हमने बदला है:

कैप्शन: डेल्फ़ी में मेरा पहला एप्लिकेशन रंग: सीएलव्हाइट बॉर्डरआइकॉन्स:

अंतिम संपत्ति एक समग्र संपत्ति है और इसका मूल्य इसके घटकों जैसे कि biSystemMenu और biMinimize को True, और biMaximize और biHelp को गलत पर सेट करके प्राप्त किया जाता है।

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

चावल। 2.6. कुछ मामूली संशोधनों के बाद पहला आवेदन

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

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

अब ध्यान दें! यदि आप किसी प्रोजेक्ट को पहली बार सहेज रहे हैं, तो डेल्फ़ी आपको पहले प्रोजेक्ट फ़ाइल को नहीं, बल्कि सभी सहेजी न गई कार्यशील फ़ाइलों को सहेजने के लिए संकेत देगा। इस स्थिति में यह एक प्रोग्राम फॉर्म फ़ाइल होगी। डिफ़ॉल्ट रूप से, डेल्फ़ी इसे Unit1.pas कहने का सुझाव देगा, लेकिन सभी कार्यशील फ़ाइलों को सार्थक नाम देने के लिए तुरंत इसे एक नियम बनाना बेहतर होगा। विशेष रूप से, चूँकि यह विंडो हमारे एप्लिकेशन में मुख्य (और केवल) है, आइए इसकी फ़ाइल को main.pas कहते हैं। इस तरह, 2 फ़ाइलें एक साथ सहेजी जाएंगी - प्रोग्राम पास और डीएफएम फॉर्म फ़ाइल।

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

सभी घटकों को सहेजने के बाद ही आपको प्रोजेक्ट फ़ाइल को सहेजने के लिए कहा जाएगा। चलिए इसे "प्रथम" कहते हैं। सहेजने के बाद, आप अंततः Ctrl+F9 (या प्रोजेक्ट मेक) दबाकर निष्पादन योग्य फ़ाइल को संकलित कर सकते हैं, डेल्फ़ी को बंद कर सकते हैं और देख सकते हैं कि हमारे पास Project1 फ़ोल्डर में क्या है। और इसमें, जैसा कि वादा किया गया था, एक फाइल होगी main.pas - फॉर्म के लिए प्रोग्राम कोड, main.dfm - फॉर्म का विवरण, फर्स्ट.dpr - प्रोजेक्ट ही, फर्स्ट.res - एक प्रोजेक्ट रिसोर्स फाइल, main.dcu - संकलन के लिए तैयार किया गया एक मॉड्यूल, और निश्चित रूप से, फर्स्ट.exe तैयार एप्लिकेशन की निष्पादन योग्य फ़ाइल है। आपको इसमें सभी डेल्फ़ी सेवा फ़ाइलें भी मिलेंगी, जो प्रोजेक्ट और इसके लिए कार्य वातावरण सेटिंग्स के बारे में अतिरिक्त जानकारी संग्रहीत करती हैं - फर्स्ट.cfg, फर्स्ट.dof और फर्स्ट.dsk फ़ाइलें।

अब इस प्रोजेक्ट पर काम पर लौटने के लिए, बस पहली.डीपीआर फ़ाइल पर डबल-क्लिक करें, परिणामस्वरूप, डेल्फ़ी आईडीई और यह प्रोजेक्ट दोनों इसमें लोड हो जाएंगे।

परियोजनाओं और डिपॉजिटरी के प्रकार

हमने अभी सबसे सामान्य प्रकार का प्रोजेक्ट बनाने पर ध्यान दिया है - विंडोज़ अनुप्रयोगमानक के साथ ग्राफ़िकल इंटरफ़ेस. लेकिन वास्तव में, डेल्फ़ी की क्षमताएं यहीं तक सीमित नहीं हैं; आप कंसोल वाले (पाठ के लिए) सहित विभिन्न प्रकार की प्रकृति के एप्लिकेशन बना सकते हैं विंडोज़ मोड), डायनेमिक लिंक लाइब्रेरीज़ (DLL), Windows NT/2000/XP के लिए सेवाएँ, क्रॉस-प्लेटफ़ॉर्म CLX एप्लिकेशन (डेल्फ़ी 6.7) या Microsoft .NET प्लेटफ़ॉर्म के लिए एप्लिकेशन (डेल्फ़ी 8, 2005)। किसी विशिष्ट प्रकार का एप्लिकेशन बनाने के लिए, फ़ाइल न्यू सबमेनू से अन्य का चयन करें। इस प्रकार, एक विंडो खुलेगी जो आपको नए एप्लिकेशन के प्रकार का चयन करने या मौजूदा प्रोजेक्ट में एक विशिष्ट मॉड्यूल जोड़ने की अनुमति देगी (चित्र 2.7)।

चावल। 2.7. डेल्फ़ी 7 में एक नया एप्लिकेशन या मॉड्यूल का चयन करना

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

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

फ़ॉर्म और डायलॉग टैब पर आप कई मानक डायलॉग बॉक्स और यहां तक ​​कि एक डायलॉग बॉक्स डिज़ाइन विज़ार्ड भी पा सकते हैं।

प्रोजेक्ट्स टैब आपको एक या दूसरे प्रकार का प्रोजेक्ट शुरू करने या मल्टी-विंडो एप्लिकेशन बनाने के लिए विज़ार्ड का उपयोग करने की अनुमति देता है।

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

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

अन्य आईडीई उपकरण

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

डेल्फ़ी के सभी आधुनिक संस्करणों के संबंध में, कोड संपादक में सभी मानक पाठ संपादन क्षमताएं (जैसे कि क्लिपबोर्ड के साथ काम करना) हैं, साथ ही कोड संपादकों की कई विशेषताएं भी हैं, अर्थात्:

1. संपादक हमेशा एक मोनोस्पेस्ड फ़ॉन्ट के साथ काम करता है (अर्थात, सभी अक्षरों की चौड़ाई समान होती है)। यह आवश्यक है क्योंकि अन्यथा प्रोग्राम कोड को नेविगेट करना मुश्किल होगा;
2. मोनोस्पेस मोड आपको स्तंभ लेआउट जैसी विधि का उपयोग करने की अनुमति देता है। दूसरे शब्दों में, आप न केवल अलग-अलग शब्दों या पंक्तियों को कॉपी और स्थानांतरित कर सकते हैं, बल्कि पाठ के आयताकार टुकड़ों को भी काट, कॉपी और पेस्ट कर सकते हैं;
3. संपादक लगातार कर्सर की स्थिति प्रदर्शित करता है, अर्थात। सम्मिलन बिंदु किस पंक्ति और स्तंभ में स्थित है;
4. कोई स्वचालित लाइन रैपिंग नहीं. चूंकि प्रोग्रामिंग में लाइन ब्रेक समेत हर कैरेक्टर का कुछ न कुछ मतलब होता है, इसलिए प्रोग्रामर को यह अनुमान नहीं लगाना पड़ता कि कोड में लाइन का अंत कहां है और स्वचालित हाइफ़न कहां है, सिद्धांत रूप में ऐसा कोई संपादन मोड नहीं है। इसके अलावा, इससे लाइन नंबरों को नेविगेट करना मुश्किल हो जाएगा;
5. सिंटैक्स हाइलाइटिंग कीवर्ड और अन्य विशिष्ट भाषा निर्माणों पर प्रकाश डालता है;
6. पंक्ति में पाठ के अंत में दाएँ तीर के साथ पाठ के माध्यम से आगे बढ़ने पर, कर्सर नीचे नहीं जाता है, बल्कि आगे बढ़ता रहता है;
7. आप बुकमार्क सेट कर सकते हैं, यानी हॉटकी संयोजन का उपयोग करके पाठ में एक स्थान चिह्नित करें और उनके बीच शीघ्रता से जाएँ;
8. प्रमुख वाक्यांशों के लिए कोड का स्वत: प्रतिस्थापन, कोड का स्वत: पूर्ण होना आदि जैसे कार्य भी हैं।

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

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

चावल। 2.8. एक्सप्लोरर के साथ कोड संपादक विंडो और नई फॉर्म फ़ाइल लोड की गई

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

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

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

एक कमांड लाइन एप्लिकेशन बनाना

इसलिए, हम पहले ही डेल्फ़ी आईडीई के सभी मुख्य कार्यों से परिचित हो चुके हैं, और यहां तक ​​कि विंडोज़ के लिए एक सरल एप्लिकेशन भी बना चुके हैं। हालाँकि, पुस्तक के इस भाग का उद्देश्य अभी भी मूल बातें - ऑब्जेक्ट पास्कल भाषा का अध्ययन करना है। इसलिए, इसके अध्ययन के दौरान मामूली (भाषा निर्माण के संबंध में) विवरणों से विचलित न होने के लिए, हम एक कंसोल एप्लिकेशन बनाने के विकल्प पर विचार करेंगे, अर्थात। वास्तव में, डॉस के लिए कार्यक्रम। यह मत सोचिए कि यह एक कदम पीछे होगा, या कि यह लंबे समय से नैतिक रूप से पुराना हो चुका है। वास्तव में, सभी भाषा नियम किसी भी प्रोग्राम के लिए बिल्कुल समान लागू होते हैं, चाहे वह DOS, Windows, .NET, या Linux के अंतर्गत हो। साथ ही, प्लेटफ़ॉर्म-विशिष्ट सुविधाओं के समानांतर अध्ययन की आवश्यकता का अभाव (और इससे भी अधिक, वीसीएल जैसी व्यापक लाइब्रेरी का समानांतर अध्ययन!) हमारे कार्य को काफी सरल बना देगा। इसके अलावा, एक विशिष्ट मामले में कंसोल एप्लिकेशन में केवल एक एकल फ़ाइल शामिल हो सकती है, जो अध्ययन के विषय की समझ को भी सरल बनाती है, जो फिलहाल प्रोग्रामिंग भाषा ही है। ठीक है, एक बार जब आप भाषा सीख लेते हैं, तो पूर्ण विंडोज़ एप्लिकेशन बनाने के लिए इसका उपयोग करना मुश्किल नहीं होगा, और वीसीएल सीखना इस तथ्य के कारण आसान हो जाएगा कि यह स्पष्ट हो जाएगा कि यह क्या, कैसे और क्यों काम करता है।

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

सूची 2.1.एक कमांड लाइन एप्लिकेशन तैयार करना

प्रोग्राम प्रोजेक्ट1; ($APPTYPE CONSOLE) SysUtils का उपयोग करता है; प्रारंभ (TODO -oUser -cConsole मुख्य: यहां कोड डालें) समाप्त।

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

आइए अब अपना पहला प्रोग्राम डेल्फ़ी में स्वयं लिखें! परंपरा के अनुसार, यह "हैलो, वर्ल्ड!" वाक्यांश प्रदर्शित करेगा। ऐसा करने के लिए, उस स्थान पर जहां टिप्पणी स्थित थी, कोड की एक पंक्ति लिखें:

लिखें(हैलो, विश्व!);

सभी! अब हम अपने प्रोग्राम को सहेज और संकलित कर सकते हैं। ऐसा करने के लिए, मानक टूलबार पर सेव या सेव ऑल बटन पर क्लिक करें, फ़ाइल पथ के रूप में अपनी हार्ड ड्राइव पर एक निर्देशिका निर्दिष्ट करें (उदाहरण के लिए, ड्राइव सी पर एक हैलोवर्ल्ड फ़ोल्डर बनाएं), और प्रोग्राम को स्वयं हैलो कहा जा सकता है . इस तरह, हमारा संपूर्ण एप्लिकेशन सहेजा जाएगा, और स्रोत कोड लिस्टिंग 2.2 में दिखाया गया रूप लेगा।

सूची 2.2.नमस्ते कार्यक्रम

प्रोग्राम नमस्ते; ($APPTYPE CONSOLE) SysUtils का उपयोग करता है; लिखना शुरू करें(हैलो, विश्व!); अंत।

कृपया ध्यान दें कि नाम स्वचालित रूप से बदल गया है। अब जो कुछ बचा है वह निष्पादन योग्य (exe) फ़ाइल प्राप्त करना है, जिसके लिए हम Ctrl+F9 दबाकर प्रोग्राम को संकलित करते हैं। अब प्रोग्राम चलाते हैं। चूंकि हमारा प्रोग्राम कमांड लाइन मोड के लिए डिज़ाइन किया गया है, आइए पहले कमांड लाइन खोलें (विंडोज एक्सपी में स्टार्ट> ऑल प्रोग्राम्स> एक्सेसरीज> कमांड प्रॉम्प्ट, या विंडोज 98 में स्टार्ट> प्रोग्राम> एक्सेसरीज> एमएस-डॉस सेशन)। आइए अपने प्रोग्राम को कमांड लाइन पर कॉल करें, इसका पूरा पथ निर्दिष्ट करना न भूलें। उदाहरण के लिए, यदि आपने प्रोजेक्ट को C:\HelloWorld में सहेजा है, और प्रोग्राम का नाम ही Hello रखा है, तो उचित पथ निर्दिष्ट करें, अर्थात:

C:\HelloWorld\hello.exe

प्रोग्राम चलाकर (अर्थात, कमांड लाइन पर पथ दर्ज करके और एंटर दबाकर), आप तुरंत इसके निष्पादन का परिणाम देखेंगे - यह "हैलो, वर्ल्ड!" वाक्यांश प्रदर्शित करेगा, और समाप्त हो जाएगा। वास्तव में, यही कारण है कि हमने पहले कमांड लाइन खोली, और उसके बाद ही प्रोग्राम लॉन्च किया, क्योंकि इसे सीधे लॉन्च करना (विंडोज एक्सप्लोरर के माध्यम से, या सीधे डेल्फ़ी से - F9 का उपयोग करके) इस तथ्य को जन्म देगा कि ए स्वचालित रूप से लॉन्च होने पर MS-DOS सत्र तुरंत बंद हो जाएगा। यह इस तथ्य से समझाया गया है कि कार्यक्रम अपने अंत तक पहुंचने के तुरंत बाद समाप्त हो जाता है, जिसे "अंत" के रूप में नामित किया गया है, और हमारे मामले में यह पाठ के आउटपुट के तुरंत बाद होगा। लेकिन हम "write(Hello, World!);" के बाद सीधे कोड की एक और पंक्ति जोड़कर इस व्यवहार को बदल सकते हैं, जो उपयोगकर्ता द्वारा Enter कुंजी दबाने तक प्रतीक्षा करेगा। यह इस तरह दिखेगा:

अब हम F9 दबाकर अपना एप्लिकेशन सीधे डेल्फ़ी वातावरण से चला सकते हैं। परिणामस्वरूप, आप शिलालेख "हैलो, वर्ल्ड!" देख पाएंगे। जब तक आप एंटर नहीं दबाते, स्वचालित रूप से लॉन्च किए गए कमांड प्रॉम्प्ट कंसोल सत्र की काली विंडो के सामने।

आपको प्रोग्राम के लिए स्रोत कोड शामिल सीडी पर डेमो\पार्ट1\हैलोवर्ल्ड फ़ोल्डर में (या संग्रह में) मिलेगा

मैं यह मार्गदर्शिका लिखने क्यों बैठा?

सबसे पहले, क्योंकि जब मैं वास्तव में अपना पहला घटक लिखना चाहता था, तो मैंने दो किताबें पढ़ीं, और वास्तव में कुछ भी दिलचस्प नहीं निकला। फिर मैंने एक और किताब पढ़ी (कम से कम इसमें एक कामकाजी उदाहरण था), और मुझे यह समझ में आ गया। लेकिन इतना सरल घटक अलग कर दिया गया था कि मुझे हर जटिल चीज़ स्वयं ही करनी पड़ी, कभी-कभी यादृच्छिक रूप से, कभी-कभी मैं बैठकर इसका पता लगाता था, इत्यादि। नतीजा यह हुआ कि मैंने इसका पता लगा लिया, यही मैं आपके लिए चाहता हूं और मुझे उम्मीद है कि इस गाइड में मैं आपकी मदद करूंगा।

मेरे सभी तैयार घटक वेबसाइट http://MihanDelfi.naroad.ru पर पाए जा सकते हैं

घटक किसके लिए हैं?

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

चरण 1. एक विचार के साथ आना

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

एक नया वर्ग बनाने के लिए, 4 मामले हैं:

1. विंडोज़ नियंत्रण बनाना (TWinControl)

2. एक ग्राफ़िकल नियंत्रण बनाना (TGraphicControl)

3. एक नया वर्ग या नियंत्रण बनाएं (TCustomControl)

4. एक गैर-दृश्य घटक बनाना (दृश्यमान नहीं) (TComponent)

अब मैं यह समझाने का प्रयास करूंगा कि दृश्य और गैर-दृश्य घटक क्या हैं। एप्लिकेशन चलने के दौरान दृश्य घटक दिखाई देते हैं और उपयोगकर्ता द्वारा सीधे उनसे इंटरैक्ट किया जा सकता है, उदाहरण के लिए, बटन एक दृश्य घटक है।

गैर-दृश्य घटक केवल एप्लिकेशन डेवलपमेंट (डिज़ाइन-टाइम) के दौरान दिखाई देते हैं, और एप्लिकेशन ऑपरेशन (रन-टाइम) के दौरान वे दिखाई नहीं देते हैं, लेकिन वे कुछ काम कर सकते हैं। सबसे अधिक इस्तेमाल किया जाने वाला गैर-दृश्य घटक टाइमर है।

तो, शब्दों से क्रिया तक आरंभ करने के लिए, आइए कुछ अति सरल घटक बनाने का प्रयास करें (केवल घटकों को बनाने की तकनीक से परिचित होने के उद्देश्य से), और फिर हम इसे जटिल बना देंगे।

चरण 2: एक खाली घटक मॉड्यूल बनाएं

मैं डेल्फ़ी 3 डिवाइस के आधार पर इस चरण पर विचार करूंगा; अन्य संस्करणों में यह प्रक्रिया बहुत अलग नहीं है। आइए एक ऐसा बटन बनाने का प्रयास करें जिस पर क्लिक की संख्या के बारे में जानकारी होगी।

घटक लिखना शुरू करने के लिए, आपको निम्नलिखित कार्य करने होंगे:

उन परियोजनाओं को बंद करें जिन्हें आप विकसित कर रहे थे (फॉर्म और मॉड्यूल)

मुख्य मेनू से घटक -> नया घटक चुनें...

आपके सामने "न्यू कंपोनेंट" नामक एक डायलॉग बॉक्स खुलेगा।

पूर्वज प्रकार फ़ील्ड में, उस घटक के वर्ग का चयन करें जिसे आप संशोधित करना चाहते हैं। हमारे मामले में, आपको TButton वर्ग का चयन करना होगा

कक्षा नाम फ़ील्ड में, उस कक्षा का नाम दर्ज करें जिसे आप प्राप्त करना चाहते हैं। नाम "T" अक्षर से शुरू होना चाहिए। हम वहां लिखेंगे, उदाहरण के लिए, TCountBtn

पैलेट पेज फ़ील्ड में, उस बुकमार्क का नाम निर्दिष्ट करें जिस पर यह घटक स्थापना के बाद दिखाई देगा। आइए वहां MyComponents दर्ज करें (अब आपके पास डेल्फ़ी में घटकों के साथ अपना स्वयं का टैब होगा!)।

यूनिट फ़ाइल नाम फ़ील्ड चयनित घटक नाम के आधार पर स्वचालित रूप से भर जाती है। यह वह पथ है जहां आपका मॉड्यूल सहेजा जाएगा।

खोज पथ फ़ील्ड में कुछ भी बदलने की आवश्यकता नहीं है.

अब क्रिएट यूनिट बटन पर क्लिक करें और आपको निम्नलिखित मिलेगा:

यूनिट काउंटबीटीएन;

उपयोग

StdCtrls;

प्रकार
टीकाउंटबीटीएन = क्लास(टीबटन)

निजी
(निजी घोषणाएँ)

संरक्षित
(संरक्षित घोषणाएँ)

जनता
(सार्वजनिक घोषणाएँ)

प्रकाशित
(प्रकाशित घोषणाएँ)

प्रक्रिया रजिस्टर;

कार्यान्वयन

प्रक्रिया रजिस्टर;
शुरू
रजिस्टरकंपोनेंट्स("मायकंपोनेंट्स", );
अंत;

चरण 3. हम सभी निर्देशों को समझना शुरू करते हैं

यहाँ क्या लिखा है? हाँ, वास्तव में अभी तक कुछ भी दिलचस्प नहीं है। यहां हम एक नई कक्षा TCountBtn और घटक पैलेट में आपके घटक को पंजीकृत करने की एक प्रक्रिया घोषित करते हैं।

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

एफगणना:पूर्णांक;

"एफ" अक्षर मौजूद होना चाहिए। यहां हमने एक छिपा हुआ फ़ील्ड काउंट बनाया है, जो बटन पर क्लिक की संख्या संग्रहीत करेगा।

आदेश संरक्षित. मैं आमतौर पर यहां विभिन्न माउस और कीबोर्ड इवेंट हैंडलर लिखता हूं। हम यहां निम्नलिखित पंक्ति लिखेंगे:

प्रक्रिया क्लिक करें; ओवरराइड;

यह इंगित करता है कि हम घटक पर माउस क्लिक को संभाल लेंगे। शब्द "ओवरराइड" इंगित करता है कि हम पूर्वज घटक के लिए मानक ऑनक्लिक ईवेंट को ओवरराइड करेंगे।

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

प्रक्रिया शोकाउंट;

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

कंस्ट्रक्टर क्रिएट(मालिक:टीकंपोनेंट);ओवरराइड; //कन्स्ट्रक्टर
//संपत्ति गणना

इसलिए सभी घोषणाएँ की जा चुकी हैं और हम सभी घोषित प्रक्रियाओं को सीधे लिखना शुरू कर सकते हैं।

चरण 4. प्रक्रियाएँ और कार्य लिखें।

आइए एक कंस्ट्रक्टर लिखकर शुरुआत करें। इसे कुछ इस प्रकार किया गया है:

कंस्ट्रक्टर TCountBtn.Create(aowner:Tcomponent);
शुरू
विरासत में मिला निर्माण (स्वामी);
अंत;

यहां, सिद्धांत रूप में, आपको कुछ भी समझने की आवश्यकता नहीं है। अपने सभी घटकों में मैंने बिल्कुल यही लिखा है (मैंने केवल घटक वर्ग बदला है और बस इतना ही)। आप यहां किसी भी क्रिया को लिख सकते हैं जो आप घटक के संचालन की शुरुआत में करना चाहते हैं, यानी, फॉर्म पर घटक स्थापित होने के समय। उदाहरण के लिए, हम अपनी काउंट संपत्ति का प्रारंभिक मूल्य निर्धारित कर सकते हैं। लेकिन हम ऐसा नहीं करेंगे.

अब हम एक बटन पर माउस क्लिक को संसाधित करने की प्रक्रिया लिखेंगे:

प्रक्रिया Tcountbtn.क्लिक करें;
शुरू
इनहेरिटेडक्लिक;
एफगणना:=एफगणना+1;
अंत;

"इनहेरिटेड क्लिक" का अर्थ है कि हम माउस क्लिक को संभालने के मानक तरीकों को दोहराते हैं (क्यों परेशान हों और अतिरिक्त काम करें :))।

हमारे पास एक आखिरी प्रक्रिया बची है: शोकाउंट। यह कुछ इस तरह दिख सकता है:

प्रक्रिया TCountBtn.ShowCount;
शुरू

अंत;

यहां एक संदेश प्रदर्शित होता है जो बटन पर क्लिक की संख्या दिखाता है (इसके अलावा, इस बटन का नाम प्रदर्शित होता है, ठीक है, मैंने इसे केवल सौंदर्य प्रयोजनों के लिए जोड़ा है)।

और यदि आपने सब कुछ समझ लिया और इसे सही ढंग से किया, तो आपको निम्नलिखित मिलना चाहिए:

यूनिट काउंटबीटीएन;

उपयोग
विंडोज़, संदेश, SysUtils, कक्षाएं, ग्राफ़िक्स, नियंत्रण, फ़ॉर्म, संवाद,
StdCtrls, ExtCtrls;

प्रकार
टीकाउंटबीटीएन = क्लास(टीबटन)
निजी
(निजी घोषणाएँ)
एफगणना:पूर्णांक;
संरक्षित
(संरक्षित घोषणाएँ)
प्रक्रिया क्लिक करें; ओवरराइड करें;
जनता
(सार्वजनिक घोषणाएँ)
प्रक्रिया शोकाउंट;
प्रकाशित
(प्रकाशित घोषणाएँ)
संपत्ति गणना: पूर्णांक पढ़ें FCount लिखें FCount;

अंत;

प्रक्रिया रजिस्टर;

कार्यान्वयन

प्रक्रिया रजिस्टर;
शुरू

अंत;

शुरू
विरासत में मिला निर्माण (स्वामी);
अंत;

प्रक्रिया Tcountbtn.क्लिक करें;
शुरू
इनहेरिटेडक्लिक;
एफगणना:=एफगणना+1;
अंत;

शुरू
शोमैसेज ("+ कैप्शन+" बटन पर आपने बनाया: "+inttostr(FCount)+" क्लिक करें");
अंत;
अंत।

जल्दी से सहेजें ताकि गलती से टाइप किए गए कोड के बाइट्स न खोएं :))।

चरण 5. घटक स्थापित करें

यदि आप यहां प्रस्तावित सब कुछ लिखने और समझने में सक्षम थे, तो घटक स्थापित करने से आपको कोई समस्या नहीं होनी चाहिए। यहां हर काम बहुत ही सरलता से किया जाता है. मुख्य मेनू से, घटक -> घटक स्थापित करें चुनें। आपके सामने इंस्टाल कंपोनेंट डायलॉग बॉक्स खुल जाएगा। इसमें आपको दो टैब दिखाई देंगे: मौजूदा पैकेज में और नए पैकेज में। आपको अपने घटक को क्रमशः मौजूदा पैकेज या नए पैकेज में स्थापित करने का विकल्प दिया गया है। हम मौजूदा पैकेज से चयन करेंगे.

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

आपको खोज पथ में कुछ भी बदलने की आवश्यकता नहीं है; डेल्फ़ी आपके लिए वहां सब कुछ जोड़ देगा।

पैकेज फ़ाइल नाम फ़ील्ड में, उस पैकेज का नाम चुनें जिसमें आपका घटक स्थापित किया जाएगा। हम प्रस्तावित डिफ़ॉल्ट पैकेज को स्वीकार करेंगे।

अब ओके बटन पर क्लिक करें। और फिर एक चेतावनी प्रकट होती है: पैकेज dclusr30.dpk का पुनर्निर्माण किया जाएगा। जारी रखना? डेल्फ़ी पूछता है: "पैकेज अमुक-अमुक बदल दिया जाएगा। जारी रखें?" निःसंदेह आपको "हां" में उत्तर देना होगा। और यदि आपने सब कुछ सही ढंग से किया, तो एक संदेश दिखाई देगा कि आपका घटक स्थापित है। खैर, आप हुर्रे चिल्ला सकते हैं! यह आपका पहला घटक है.

अपने प्रकार के गुण बनाना

अब हम एक गैर-मानक प्रकार की संपत्ति बनाने का प्रयास करेंगे। आइए इसे एक लेबल - TLabel के उदाहरण का उपयोग करके देखें। इस घटक में निम्नलिखित गुण हैं: संरेखण। यह निम्नलिखित मान ले सकता है: taLeftJustify, taCenter, taRightJustify। आइए संपत्ति बनाना शुरू करें। मैं कुछ भी दिलचस्प नहीं खोज सका, लेकिन फिर भी, मैं उस संपत्ति के उदाहरण का उपयोग करके आपको यह दिखाऊंगा जो मैं लेकर आया था। यह बहुत सरल है और आपको इसका पता लगाने में मदद करेगा। प्रॉपर्टी को शोटाइप (प्रकार TShowTp) कहा जाएगा, हमारे घटक में यह काउंट प्रॉपर्टी प्रदर्शित करने के लिए जिम्मेदार होगा। यदि उपयोगकर्ता शोटाइप प्रॉपर्टी को सामान्य पर सेट करता है, तो बटन वैसे ही काम करेगा जैसे उसने किया था। और यदि उपयोगकर्ता इस प्रॉपर्टी के लिए काउंटटूकैप्शन मान निर्दिष्ट करता है, तो क्लिक की संख्या बटन पर ही प्रदर्शित होगी।

सबसे पहले, हमें एक नया प्रकार घोषित करने की आवश्यकता है। प्रकार शब्द के बाद प्रकार विवरण अवश्य जोड़ा जाना चाहिए। पहले यह ऐसा दिखता था:

प्रकार
टीकाउंटबीटीएन = क्लास(टीबटन)

इसे इस तरह दिखना चाहिए:

TShowTp = (सामान्य, काउंटटूकैप्शन);

टीकाउंटबीटीएन = क्लास(टीबटन)

यहां हमने एक नया प्रकार TShowTp घोषित किया है, जो केवल दो मान ले सकता है। वे सभी मान जिन्हें आप जोड़ना चाहते हैं, अल्पविराम से अलग किए गए हैं।

अब हमें इस प्रकार का एक फ़ील्ड बनाने की आवश्यकता है। हम पहले से ही जानते हैं कि यह कैसे करना है और इसलिए कोई कठिनाई नहीं होनी चाहिए। निजी निर्देश में लिखें:

FShowType:TShowTp;

हमने TShowTp प्रकार का एक शोटाइप फ़ील्ड बनाया।

बेशक, आपको इस संपत्ति को ऑब्जेक्ट इंस्पेक्टर में जोड़ना होगा:

संपत्ति शो प्रकार: TshowTp पढ़ें FshowType लिखें FShowType;

और अंत में, हमारे घटक द्वारा उपयोगकर्ता द्वारा इस संपत्ति में किए गए परिवर्तनों पर प्रतिक्रिया देने के लिए, हमें ऑनक्लिक ईवेंट हैंडलर को थोड़ा बदलने की आवश्यकता है। थोड़े से संशोधन के बाद यह कुछ इस तरह दिखाई दे सकता है:

प्रक्रिया Tcountbtn.क्लिक करें;
शुरू
इनहेरिटेडक्लिक;
एफकाउंट:=एफकाउंट+1;
यदि शोटाइप = सामान्य है तो
कैप्शन:=कैप्शन;


अंत;

मैं समझाऊंगा कि क्या हुआ. सबसे पहले हम काउंटर को एक-एक करके बढ़ाते हैं। फिर हम जांचते हैं कि शोटाइप प्रॉपर्टी का क्या मूल्य है। यदि सामान्य है, तो हम कुछ नहीं करते हैं, लेकिन यदि काउंटटूकैप्शन है, तो हम बटन पर लेबल में क्लिक की संख्या प्रदर्शित करते हैं। यह उतना कठिन नहीं है जितना पहले लग सकता है।

घटक में टाइमर लगाना

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

उपयोग अनुभाग के बाद, जो प्रोग्राम में जोड़े गए मॉड्यूल का वर्णन करता है, TTimer प्रकार का एक वेरिएबल घोषित करें। चलिए इसे टाइमर कहते हैं। यहां कोड का एक छोटा सा भाग है:

यूनिट काउंटबीटीएन;

उपयोग
विंडोज़, संदेश, SysUtils, कक्षाएं, ग्राफ़िक्स, नियंत्रण, फ़ॉर्म, संवाद,
StdCtrls, ExtCtrls;

प्रक्रिया ऑनटाइमर (प्रेषक: TObject);

चूँकि हमारा टाइमर एक वेरिएबल नहीं है, बल्कि एक घटक है, हमें इसे बनाने की भी आवश्यकता है, इसके लिए हम अपने बटन के कंस्ट्रक्टर में लिखेंगे:

कंस्ट्रक्टर TCountBtn.Create(aowner:Tcomponent);
शुरू
विरासत में मिला निर्माण (स्वामी);
टाइमर:=टीटाइमर.क्रिएट(स्वयं);
टाइमर.सक्षम:=सत्य;
टाइमर.ऑनटाइमर:=ऑनटाइमर;
टाइमर.अंतराल:=10000;
अंत;

यहां हमारे टाइमर का एक उदाहरण बनाया गया है और इसकी इटरवल प्रॉपर्टी (मिलीसेकंड में मापी गई) को 10000 (यानी, सरल शब्दों में 10 सेकंड) का मान दिया गया है।

दरअसल, जो कुछ बचा है वह ऑनटाइमर प्रक्रिया को ही लिखना है। मैंने इसे इस प्रकार किया:

प्रक्रिया TCountBtn.OnTimer(प्रेषक: TObject);
शुरू
एफकाउंट:=एफसीकाउंट*2;
अंत;

मोटे तौर पर आपको यही समाप्त करना चाहिए:

यूनिट काउंटबीटीएन;

उपयोग
विंडोज़, संदेश, SysUtils, कक्षाएं, ग्राफ़िक्स, नियंत्रण, फ़ॉर्म, संवाद,
StdCtrls, ExtCtrls;

वार टाइमर: टीटाइमर;
प्रकार
TShowTp = (सामान्य, काउंटटूकैप्शन);
टीकाउंटबीटीएन = क्लास(टीबटन)

निजी
(निजी घोषणाएँ)

एफगणना:पूर्णांक;
FShowType:TShowTp;
संरक्षित
(संरक्षित घोषणाएँ)
प्रक्रिया ऑनटाइमर (प्रेषक: TObject);
प्रक्रिया क्लिक करें; ओवरराइड करें;
जनता
(सार्वजनिक घोषणाएँ)
प्रक्रिया शोकाउंट;
प्रकाशित
(प्रकाशित घोषणाएँ)
संपत्ति गणना: पूर्णांक पढ़ें FCount लिखें FCount;
कंस्ट्रक्टर क्रिएट(मालिक:टीकंपोनेंट);ओवरराइड;
संपत्ति शो प्रकार: TshowTp पढ़ें FshowType लिखें FShowType;
अंत;

प्रक्रिया रजिस्टर;

कार्यान्वयन

प्रक्रिया रजिस्टर;
शुरू
रजिस्टरकंपोनेंट्स("मिहान कंपोनेंट्स", );
अंत;

कंस्ट्रक्टर TCountBtn.Create(मालिक:Tcomponent);
शुरू
विरासत में मिला निर्माण (स्वामी);
टाइमर:=टीटाइमर.क्रिएट(स्वयं);
टाइमर.सक्षम:=गलत;
टाइमर.ऑनटाइमर:=ऑनटाइमर;
टाइमर.अंतराल:=1000;
अंत;

प्रक्रिया Tcountbtn.क्लिक करें;
शुरू
इनहेरिटेडक्लिक;
एफकाउंट:=एफकाउंट+1;
टाइमर.सक्षम:=सत्य;
यदि शोटाइप = सामान्य है तो
कैप्शन:=कैप्शन;
यदि शोटाइप = काउंटटूकैप्शन है तो
कैप्शन:='गिनती='+inttostr(गिनती);
अंत;

प्रक्रिया TCountBtn.ShowCount;
शुरू
शोमैसेज ("+ कैप्शन+" बटन पर आपने बनाया: "+inttostr(FCount)+" क्लिक करें");
अंत;

प्रक्रिया TCountBtn.OnTimer(प्रेषक: TObject);
शुरू
एफकाउंट:=एफसीकाउंट*2;
अंत;

यदि कोई चीज़ आपके लिए काम नहीं करती है, तो पहले जांच लें कि सब कुछ सही ढंग से लिखा गया है या नहीं। फिर जांचें कि क्या आप उपयोग अनुभाग में कुछ मॉड्यूल खो रहे हैं।

किसी घटक को पुनः स्थापित करना

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

आपकी प्रोग्रामिंग के लिए शुभकामनाएँ...

(सी) कॉपीराइट मिखाइल क्रिस्टेंको का है! अन्य साइटों पर पोस्ट करते समय लेखक का नाम और साइट का पता (http://delphid.dax.ru) बताना अनिवार्य है!

• समीक्षा
• नामकरण की परंपरा
• पूर्वज चयन
• एक घटक बनाने का उदाहरण

1. समीक्षा
2. क्योंकि डेल्फ़ी एक खुला वातावरण है और आपको न केवल अपने प्रोग्राम में विज़ुअल कंपोनेंट लाइब्रेरी (वीसीएल) से ऑब्जेक्ट का उपयोग करने की अनुमति देता है, बल्कि नई ऑब्जेक्ट बनाने की भी अनुमति देता है। इसके अलावा, इसके लिए डेल्फ़ी के अलावा किसी और चीज़ की आवश्यकता नहीं है। डेल्फ़ी में एक नया ऑब्जेक्ट बनाना बहुत मुश्किल काम नहीं है, हालाँकि इसके लिए विंडोज़ एपीआई, ऑब्जेक्ट-ओरिएंटेड प्रोग्रामिंग और वीसीएल में क्लास पदानुक्रम के ज्ञान की आवश्यकता होती है।

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

3. वीसीएल में नई वस्तुएं जोड़ना
4. आइए मान लें कि आपके पास एक तैयार घटक है। इसे वीसीएल में कैसे जोड़ें? ऐसा करने के लिए, मेनू आइटम का चयन करें विकल्प|घटक स्थापित करें... एक संवाद दिखाई देगा, जैसा कि चित्र 1 में दिखाया गया है।

   चावल। 1 : नया घटक स्थापना संवाद

   "जोड़ें" पर क्लिक करें और पंजीकरण प्रक्रिया वाले मॉड्यूल को निर्दिष्ट करें, "ओके" पर क्लिक करें और सफल पुनर्संकलन के बाद, नई वस्तु पैलेट में दिखाई देगी।

5. नये घटक के लिए रिक्त
6. डेल्फ़ी परिवेश में एक विशेष विशेषज्ञ होता है जो एक नए घटक के लिए एक टेम्पलेट बनाता है। आप इसे मेनू आइटम फ़ाइल|नया घटक... में कॉल कर सकते हैं (चित्र 2 देखें)

   
   

   चावल। 2 : नया घटक बनाने में विशेषज्ञ

   संवाद में आपको नए वर्ग का नाम (उदाहरण के लिए, TMyButton), वर्ग के पूर्वज (TButton) और पैलेट पृष्ठ को निर्दिष्ट करना होगा जहां नए घटक (नमूने) को रखना है। यदि आप "ओके" पर क्लिक करते हैं, तो विशेषज्ञ एक मॉड्यूल बनाएगा - एक नए घटक के लिए एक टेम्पलेट:

   इकाई इकाई1;

   इंटरफेस

   उपयोग

   SysUtils, WinTypes, WinProcs, संदेश, कक्षाएं, ग्राफ़िक्स, नियंत्रण,

   प्रपत्र, संवाद, StdCtrls;

   प्रकार

   टीएमवाईबटन = क्लास(टीबटन)

   निजी

   (निजी घोषणाएँ)

   संरक्षित

   (संरक्षित घोषणाएँ)

   जनता

   (सार्वजनिक घोषणाएँ)

   प्रकाशित

   (प्रकाशित घोषणाएँ)

   अंत;

   प्रक्रिया रजिस्टर;

   कार्यान्वयन

   प्रक्रिया रजिस्टर;

   शुरू

   रजिस्टरकंपोनेंट्स("नमूने", );

   अंत;

   अंत।

   मॉड्यूल में एक नई कक्षा की घोषणा और घटक पैलेट में इसे पंजीकृत करने की प्रक्रिया शामिल है। प्रक्रिया मेंरजिस्टर घटक पहला पैरामीटर पृष्ठ का नाम है (आप अपना नाम निर्दिष्ट कर सकते हैं - एक नया पृष्ठ दिखाई देगा); दूसरा पैरामीटर रजिस्टर करने के लिए ऑब्जेक्ट का सेट है।

   अब आपको मॉड्यूल को एक नए नाम (उदाहरण के लिए, NEW_BTN.PAS) के तहत सहेजना होगा और नए गुण और तरीके जोड़ना शुरू करना होगा। यह कार्य पूरा होने और नए घटक को डीबग करने के बाद, आप इसे पैलेट में जोड़ सकते हैं (पिछला अध्याय देखें)। लेकिन इससे पहले, एक संसाधन फ़ाइल बनाने की सलाह दी जाती है जिसमें घटक पैलेट में इस ऑब्जेक्ट का प्रतिनिधित्व करने के लिए एक आइकन होगा। संसाधन फ़ाइल को संसाधन कार्यशाला प्रोग्राम का उपयोग करके बनाया जा सकता है, इसे बिल्कुल घटक पंजीकरण मॉड्यूल के समान नाम दिया जाना चाहिए और इसमें .DCR एक्सटेंशन होना चाहिए (यानी, यदि ऑब्जेक्ट NEW_B मॉड्यूल में पंजीकृत हैतमिलनाडु .PAS, तो संसाधन फ़ाइल का नाम NEW_BTN.DCR होगा)। संसाधन फ़ाइल में BITMAP प्रकार का एक संसाधन होना चाहिए - 28x28 पिक्सेल आकार वाला एक चित्र (यदि संभव हो तो छोटा), चित्र का नाम वर्ग के नाम से मेल खाना चाहिए (हमारे मामले में TMYBUTTON)।

7. नामकरण की परंपरा

यदि आपने वीसीएल स्रोत कोड को देखा है, तो आपने देखा होगा कि नई कक्षाओं को परिभाषित करते समय यह कुछ सरल परंपराओं का पालन करता है। डेल्फ़ी को इसकी आवश्यकता नहीं है, विधियों के नाम, गुण आदि। कुछ भी हो सकता है, संकलक को कोई परवाह नहीं है। लेकिन यदि आप इन परंपराओं का पालन करते हैं, तो नए घटकों को विकसित करना और स्रोत कोड को पढ़ना बहुत आसान हो जाएगा।

इसलिए:

• सभी प्रकार की घोषणाएँ T अक्षर से शुरू होती हैं। एक बार फिर, डेल्फ़ी को इसकी आवश्यकता नहीं है, लेकिन यह स्पष्ट करता है कि "TEEdit", उदाहरण के लिए, एक प्रकार की परिभाषा है, न कि एक वर्ग चर या फ़ील्ड।
• संपत्ति के नाम पढ़ने में आसान और जानकारीपूर्ण होने चाहिए। हमें यह याद रखना चाहिए कि उपयोगकर्ता उन्हें ऑब्जेक्ट इंस्पेक्टर में देखेगा। और "TextOrientation" जैसा नाम "TxtOr" की तुलना में कहीं अधिक सुविधाजनक है। यही बात तरीकों पर भी लागू होती है। उपयोगकर्ता के लिए उपलब्ध विधियों के नाम उपयोगकर्ता के अनुकूल होने चाहिए।
• इवेंट प्रकार की प्रॉपर्टी बनाते समय, ऐसी प्रॉपर्टी का नाम "ऑन" से शुरू होना चाहिए (उदाहरण के लिए, ऑनक्लिक, ऑनक्रिएट, आदि)।
• किसी संपत्ति को पढ़ने की विधि का नाम "प्राप्त करें" शब्द से शुरू होना चाहिए। उदाहरण के लिए, GetStyle विधि को स्टाइल प्रॉपर्टी को अवश्य पढ़ना चाहिए।
• किसी प्रॉपर्टी को लिखने की विधि का नाम "सेट" शब्द से शुरू होना चाहिए। उदाहरण के लिए, SetStyle विधि को स्टाइल प्रॉपर्टी पर लिखना होगा।
• संपत्ति डेटा संग्रहीत करने के लिए आंतरिक फ़ील्ड का नाम "F" अक्षर से शुरू होना चाहिए। उदाहरण के लिए, हैंडल प्रॉपर्टी को FHandle फ़ील्ड में संग्रहीत किया जा सकता है।

बेशक, नियमों के अपवाद भी हैं। कभी-कभी उन्हें तोड़ना अधिक सुविधाजनक होता है, उदाहरण के लिए, TTable वर्ग में इवेंट प्रकार के गुण होते हैं जिन्हें beforePost, AfterPost आदि कहा जाता है।

1. पूर्वज चयन

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

• प्रतिवस्तु - यदि डिज़ाइन के दौरान इस घटक के साथ काम करने की आवश्यकता नहीं है तो इसे पूर्वज के रूप में उपयोग किया जा सकता है। यह, उदाहरण के लिए, पर्यावरण चर के मानों वाला एक वर्ग या INI फ़ाइलों के साथ काम करने के लिए एक वर्ग हो सकता है।
• टीघटक - कई अदृश्य घटकों के लिए प्रारंभिक बिंदु। इस वर्ग में डिज़ाइन के दौरान स्वयं को स्ट्रीम में सहेजने/पढ़ने की अंतर्निहित क्षमता है।
• टीग्राफिककंट्रोल - इस वर्ग का उपयोग उन दृश्यमान घटकों को बनाने के लिए करें जिन्हें हैंडल की आवश्यकता नहीं है। ऐसे घटक सीधे अपनी सतह पर आकर्षित होते हैं और इसके लिए कुछ विंडोज़ संसाधनों की आवश्यकता होती है।
• ट्विनकंट्रोल - उन घटकों के लिए बेस क्लास जिनमें एक विंडो है। इस विंडो का अपना हैंडल है; इसका उपयोग एपीआई के माध्यम से विंडोज क्षमताओं तक पहुंचने के लिए किया जाता है।
• TCustomControl - TWinControl के वंशज, कैनवास की अवधारणा और पेंट() विधि का परिचय देते हैं बेहतर नियंत्रणघटक को चित्रित करने के लिए. यह वह वर्ग है जिसका उपयोग खिड़की के हैंडल वाले अधिकांश दृश्यमान घटकों के निर्माण के लिए आधार के रूप में किया जाता है।
• txxxx - TEdit या TButton जैसी कक्षा। इनका उपयोग उनके गुणों और विधियों को और अधिक परिभाषित करने या गुणों के डिफ़ॉल्ट मानों को फिर से परिभाषित करने के लिए किया जाता है।

1. एक घटक बनाने का उदाहरण

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

इकाई New_btn;

इंटरफेस

उपयोग

SysUtils, WinTypes, WinProcs, संदेश, कक्षाएं, ग्राफ़िक्स,

नियंत्रण, प्रपत्र, संवाद, StdCtrls;

प्रकार

टीएमवाईबटन = क्लास(टीबटन)

निजी

(निजी घोषणाएँ)

एफक्लिककाउंट: लॉन्गिंट;

संरक्षित

(संरक्षित घोषणाएँ)

जनता

(सार्वजनिक घोषणाएँ)

कंस्ट्रक्टर क्रिएट (एओनर: टीकंपोनेंट); ओवरराइड;

प्रक्रिया क्लिक करें; ओवरराइड;

संपत्ति ClickCount: Longint पढ़ें FClickCount लिखें

एफक्लिककाउंट;

प्रकाशित

(प्रकाशित घोषणाएँ)

अंत;

प्रक्रिया रजिस्टर;

कार्यान्वयन

कंस्ट्रक्टर TMyButton.Create(AOowner: TComponent);

शुरू

विरासत में मिला क्रिएट(एओनर);

दिखाएँसंकेत:=सत्य;

FClickCount:=0;

अंत;

प्रक्रिया TMyButton.Click;

शुरू

इंक(एफसीक्लिककाउंट);

विरासत में मिला क्लिक;

अंत;

प्रक्रिया रजिस्टर;

शुरू

रजिस्टरकंपोनेंट्स("नमूने", );

अंत;

अंत।

ऑब्जेक्ट बनाते समय किसी प्रॉपर्टी के प्रारंभिक मूल्य को ओवरराइड करने के लिए, आपको कंस्ट्रक्टर को फिर से लिखना होगाबनाएं जिसमें आप इस प्रॉपर्टी को वांछित मान निर्दिष्ट करते हैं (पहले पूर्वज कंस्ट्रक्टर को कॉल करना न भूलें)।

कुंजी स्ट्रोक्स की गिनती के लिए नई संपत्ति को कहा जाता हैगिनती पर क्लिक करें. मूल्य संग्रहीत करने के लिए इसका आंतरिक क्षेत्र - FClickCount Longint प्रकार का है, फ़ील्ड क्षमता लंबे समय तक चलेगी।