आपका लुक और फील - पार्ट I बनाना

शुभ दोपहर, अभिभावक!

काफी कुछ स्विंग और ग्राफिक्स के बारे में कहा गया है, और थोड़ा उल्लेख तीसरे पक्ष के पुस्तकालयों द्वारा प्रदान की गई विभिन्न उत्कृष्ट विशेषताओं से किया गया है।

आज, मैं आपके दरबार में "अंतिम सीमांत" को उन सभी संभावनाओं में प्रस्तुत करूँगा, जो स्विंग हमें प्रदान करती हैं - अपना स्वयं का लुक और फील क्लास, साथ ही इस प्रक्रिया में आवश्यक सभी चीज़ों का निर्माण करना।

मुझे तुरंत कहना चाहिए - यदि आप अपना उदाहरण लिखना चाहते हैं, न कि केवल "दिलचस्प" अंक, तो कुछ दिलचस्प बिंदुओं पर खर्च करने के लिए तैयार रहें - यदि आप निश्चित रूप से कम या ज्यादा जीवंत और किसी भी अनुप्रयोगों में प्रयोग करने योग्य हैं। एक "आवरण" के रूप में, साथ ही साथ आपके द्वारा बनाए गए लाफ का समर्थन करना जारी रखने के लिए।

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

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

MyLookAndFeel.java

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

तो, हम तैयार BasicLookAndFeel का उपयोग करते हैं और कई आवश्यक तरीकों को फिर से परिभाषित करते हैं जो हमारे भविष्य के LaF का वर्णन करते हैं:

सार्वजनिक वर्ग MyLookAndFeel BasicLookAndFeel का विस्तार करता है
{
सार्वजनिक स्ट्रिंग getDescription ()
{
// विवरण LaF
वापसी "क्रॉस-प्लेटफ़ॉर्म जावा लुक एंड फील" ;
}

सार्वजनिक स्ट्रिंग getName ()
{
// नाम एलएएफ
वापसी "MyLookAndFeel" ;
}

सार्वजनिक स्ट्रिंग getID ()
{
// विशिष्ट पहचानकर्ता एलएएफ
वापसी getName ();
}

सार्वजनिक बूलियन है NativeLookAndFeel ()
{
// क्या यह एलएएफ वर्तमान प्लेटफॉर्म के लिए बाध्य है (क्या यह एक देशी कार्यान्वयन है)
झूठे लौटना ;
}

सार्वजनिक बूलियन
{
// क्या यह एलएएफ वर्तमान प्लेटफॉर्म पर समर्थित है?
सच लौटना ;
}
}

अब यह किसी भी एप्लिकेशन को बनाने से पहले एक "जादू" लाइन लागू करने के लिए बनी हुई है और यह हमारे LaF का उपयोग करेगी:

UIManager। setLookAndFeel ( MyLookAndFeel । वर्ग । getCanonicalName () );

यहाँ हमें एक सरल उदाहरण के साथ मिलता है:


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

यह सौंदर्य प्रसाधनों पर काम करने के लिए बनी हुई है - यही हम करेंगे!

घटक स्टाइल

इसलिए, हमें प्रत्येक घटक को संशोधित करने के लिए कुछ चीजों की आवश्यकता है, चलो सबसे स्पष्ट एक के साथ शुरू करते हैं - चयनित घटक के लिए एक यूआई वर्ग बनाते हैं।

सरलता के लिए, आइए एक बटन लें - घटक जो किसी के लिए सबसे अधिक परिचित है।
BasicLookAndFeel के अनुरूप, हर J- घटक के लिए एक BasicUI-कार्यान्वयन है, जो स्टाइल घटकों के लिए आवश्यक संचालन को बहुत सरल और कम करता है। एक बटन के लिए, यह अनुमान लगाना मुश्किल नहीं है, यह BasicButtonUI है - हम इसे वारिस करेंगे और इसे फिर से परिभाषित करेंगे।

सभी यूआई कक्षाओं में, विशेष विधियों के अलावा (प्रत्येक वर्ग के लिए उनका अपना है, उस घटक के आधार पर जिसके लिए यह यूआई है) कंपोनेंटीयू से विरासत में मिली कई मानक विधियां हैं - एक शुरुआत के लिए, उन पर विचार करें:

1. सार्वजनिक शून्य इंस्टॉलयूआई (JComponent c)
   यह विधि विशिष्ट J- घटक पर UI वर्ग को "स्थापित" करने के लिए डिज़ाइन की गई है। यह इस पद्धति में है कि यह आपके यूआई के सही प्रतिपादन और संचालन के लिए जे-घटक या किसी अन्य डेटा के लिए किसी श्रोता को परिभाषित करने के लायक है।
   इस विधि को किसी भी J- घटक को बनाते समय updateUI () से पुकारा जाता है।
   
   
2. सार्वजनिक शून्य अनइंस्टॉलयूआई (JComponent c)
   इस पद्धति में, आपके द्वारा घटक में जोड़े गए सभी श्रोताओं को हटाने के लिए, साथ ही अधिक अनावश्यक डेटा की मेमोरी को हटाने के लिए यह बहुत ही वांछनीय है।
   इस विधि को setUI (ComponentUI newUI) से पुकारा जाता है जब घटक अपने वर्तमान UI को बदलता है, या जब घटक पूरी तरह से हटा दिया जाता है और इसकी निर्भरता "साफ़" हो जाती है।
   
   
3. सार्वजनिक शून्य पेंट (ग्राफिक्स जी, JComponent c)
   यह विधि सीधे घटक को प्रदान करने में शामिल है। यह विधि यूआई कक्षाओं में महत्वपूर्ण है, क्योंकि यह किसी भी राज्य में घटक के दृश्य डिजाइन को निर्धारित करता है।
   इस विधि को परोक्ष रूप से पेंटकंपोनेंट (ग्राफिक्स जी) से एक घटक के किसी भी प्रतिपादन / पुनर्विकास के लिए कहा जाता है, जो कि JComponent वर्ग के किसी भी वंशज में मौजूद है, यानी, यह विधि केवल तब काम करती है जब पुनर्वितरण की वास्तविक आवश्यकता होती है, और आवश्यक क्लिप को भी ध्यान में रखा जाता है (यह सब लागू है) पेंटकंपोनेंट (ग्राफिक्स जी ) में।
   
   
4. सार्वजनिक शून्य अद्यतन (ग्राफिक्स जी, JComponent c)
   यह विधि पेंट (ग्राफ़िक्स g, JComponent c) के लिए बस एक छोटा सा जोड़ है, लेकिन यह ऐसा है जिसे JCompords के लिए paintComponent (ग्राफ़िक्स g) से बुलाया जाता है और फिर UI वर्ग से पहले वर्णित पेंट्स (Graphics g, JComponent c) को कॉल किया जाता है। वास्तव में, यह विधि ऑब्जेक्ट की "अप्रचलित" पृष्ठभूमि को अधिलेखित करती है और फिर "क्लीन शीट" पर रेंडर करती है।
   
   
5. सार्वजनिक आयाम getPreferredSize (JComponent c)
   यह विधि उस घटक के वांछित आकार को निर्धारित करती है जिस पर यह यूआई वर्ग स्थापित है।
   इसे Jomomponent या इसके किसी वारिस पर समान नाम की getPreferredSize () विधि से, यदि आवश्यक हो, वांछित घटक आकार को पुनर्गणना करने के लिए कहा जाता है।
   
   
6. सार्वजनिक आयाम getMinimumSize (JComponent c)
   सार्वजनिक आयाम getMaximumSize (JComponent c)
   इन विधियों में से दो न्यूनतम और अधिकतम आकार के घटकों को निर्धारित करते हैं और आकार बदलते समय विभिन्न लेआउट प्रबंधकों द्वारा ध्यान में रखा जा सकता है। डिफ़ॉल्ट रूप से, वे उसी मान को वापस लौटाते हैं जैसे getPreferredSize (JComponent c) , UI वर्ग में लागू किया गया है और पहले वर्णित है।
   
   
7. सार्वजनिक बूलियन में शामिल है (JComponent c, int x, int y)
   यह विधि निर्धारित करती है कि बिंदु इस घटक से संबंधित है या नहीं। माउस घटनाओं के सही प्रसंस्करण के लिए, अधिकांश भाग के लिए यह आवश्यक है। किसी भी माउस घटना में, यह किसी दिए गए बिंदु पर "देखे गए" ऊपरवाले घटक को प्रेषित होता है। और यह पता लगाने के लिए ठीक है कि किसी दिए गए बिंदु पर कौन से घटक बहुत ऊपर स्थित हैं, वहां स्थित घटकों को क्रमिक रूप से पूछताछ की जाती है। यही है, इस पद्धति का उपयोग करते हुए, आप उदाहरण के लिए, घटनाओं को अपने घटक द्वारा उन जगहों से गुजरने के लिए मजबूर कर सकते हैं जहां यह वास्तव में खींचा नहीं गया है और एक घटना प्राप्त करने की आवश्यकता नहीं है (उदाहरण के लिए, टैब के दाईं ओर खाली क्षेत्र या गोल बटन के कोने वाले क्षेत्र)।
   इस विधि को समाहित (int x, int y) से कहा जाता है, जो JComponent वर्ग के सभी वंशजों पर मौजूद है।

मैं एक और महत्वपूर्ण विधि के बारे में थोड़ी देर बाद बात करूंगा ...

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

भ्रमित न होने के लिए, एक बार फिर मैं उल्लेखित वर्गों / विधियों की एक सूची दूंगा:

JComponent

• अपडेटयूआई ()
• सेतु
• PaintComponent (ग्राफिक्स जी)
• getPreferredSize ()
• समाहित है (इंट x, int y)

ComponentUI

• सार्वजनिक शून्य इंस्टॉलयूआई (JComponent c)
• सार्वजनिक शून्य अनइंस्टॉलयूआई (JComponent c)
• सार्वजनिक शून्य पेंट (ग्राफिक्स जी, JComponent c)
• सार्वजनिक शून्य अद्यतन (ग्राफिक्स जी, JComponent c)
• सार्वजनिक आयाम getPreferredSize (JComponent c)
• सार्वजनिक आयाम getMinimumSize (JComponent c)
• सार्वजनिक आयाम getMaximumSize (JComponent c)
• सार्वजनिक बूलियन में शामिल है (JComponent c, int x, int y)

दरअसल, ComponentUI से इन बुनियादी तरीकों के आधार पर, किसी भी घटक के सभी UI वर्ग बनाए जाते हैं। आपके जीवन को सरल बनाने के लिए, बेसिकयू कक्षाएं कई अन्य तरीके भी प्रदान करती हैं जो एक घटक के प्रतिपादन को निर्दिष्ट और सरल करते हैं।

LookAndFeel के बारे में थोड़ा और

मैं LookAndFeel वर्ग के निर्माण का थोड़ा और विवरण जोड़ूंगा ताकि बाद में उस पर वापस न लौटा जा सके।

लुकएंडफील को शुरू करते समय UIDefaults में ऊपर वर्णित मानक घटकों के लिए यूआई कक्षाओं को निर्दिष्ट करने की संभावना के अलावा, कई अन्य चीजें भी हैं जो लुकएंडफिल वर्ग के साथ चलती हैं। उनमें से अधिकांश को आपको शायद ही लागू करने / फिर से परिभाषित करने की आवश्यकता है, क्योंकि वे पहले से ही BasicLookAndFeel वर्ग में हैं, लेकिन आदेश के लिए यह जानने योग्य है कि वहां क्या चल रहा है।

अतः, लुकफैंड क्लास में प्रस्तुत विधियों पर विचार करें:

1. installColors (JComponent c, स्ट्रिंग defaultBgName, स्ट्रिंग defaultFgName)
   installColorsAndFont (JComponent c, स्ट्रिंग defaultBgName, स्ट्रिंग defaultFgName, स्ट्रिंग defaultFontName)
   installBorder (JComponent c, स्ट्रिंग defaultBorderName)
   स्थापना रद्द करें (JComponent c)
   installProperty (JComponent c, String propertyName, Object propertyValue)
   makeKeyBindings (ऑब्जेक्ट [] की-बाइंडिंग लिस्ट)
   makeInputMap (ऑब्जेक्ट [] कुंजी)
   makeComponentInputMap (JComponent c, ऑब्जेक्ट [] कुंजियाँ)
   loadKeyBindings (इनपुट मैप रेटपॉइंट, ऑब्जेक्ट [] कुंजियाँ)
   मेकइकॉन (अंतिम वर्ग <?> आधारक्लास, अंतिम स्ट्रिंग gifFile)
   getDesktopPropertyValue (स्ट्रिंग systemPropertyName, ऑब्जेक्ट फ़ॉलबैकवैल्यू)
   स्थिर तरीकों का यह सब विशाल सेट लगभग एक ही उद्देश्य के लिए लुकएंडफील वर्ग में उपलब्ध है - कुंजियों का सरलीकृत उपयोग और इन कुंजियों से विभिन्न घटकों के लिए निर्धारित मान। फिर चाहे वह बैकग्राउंड हो या फॉन्ट कलर, टेक्स्ट फील्ड के लिए कीबोर्ड शॉर्टकट या फिर कंपोनेंट बॉर्डर। उनका उपयोग अलग-अलग UI कक्षाओं में और UIDefaults में अधिकांश भाग के लिए किया जाता है। प्रत्येक व्यक्ति विधि के उद्देश्य का वर्णन करने में कोई विशेष समझदारी नहीं है, क्योंकि यह प्रत्येक विधि से पहले टिप्पणियों में विस्तार से वर्णित है।
   
   
2. सार्वजनिक लेआउटशैली getLayoutStyle ()
   यह विधि लेआउटसिटी क्लास का एक उदाहरण देता है, जो विभिन्न लेआउट में घटकों के व्यवहार को निर्धारित करता है। उदाहरण के लिए, यह निर्धारित कर सकता है कि एक लेबल और एक पाठ क्षेत्र के बीच कौन सा इंडेंटेशन पसंद किया जाता है, एक ही कंटेनर पर एक के बाद एक स्थित है (हाँ, ऐसे विशिष्ट मामलों तक सही)। हालाँकि, यह एक बहुत ही सारगर्भित बात है और वास्तव में इस श्रेणी में परिभाषित मापदंडों का उपयोग करने वाले बहुत कम लेआउट हैं, और इस बिंदु को डेवलपर्स ने कक्षा में टिप्पणियों में भी नोट किया था। उदाहरण के लिए, स्विंग में, लेआउटसाइल का उपयोग करने वाला एकमात्र लेआउट GroupLayout है, जो इसकी विशिष्टता को देखते हुए, अजीब नहीं है।
   
   
3. सार्वजनिक शून्य प्रदान करता हैफ्रेडबैक (घटक घटक)
   इस विधि को हर बार कहा जाता है जब उपयोगकर्ता कुछ गैरकानूनी कार्रवाई करता है (उदाहरण के लिए, एक खाली पाठ क्षेत्र में बैकस्पेस दबाता है या एक अनुपयुक्त क्षेत्र के पाठ को हटाने की कोशिश करता है, आदि)। मानक कार्यान्वयन में, ऐसे मामलों में केवल टूलकिट.गेटफॉल्टटूलकिट () .beep () विधि को कॉल किया जाता है, जो गलत संचालन की एक छोटी ध्वनि संकेत निभाता है, वर्तमान ओएस के लिए मानक। हालांकि, आप हमेशा इस व्यवहार को किसी अन्य में बदल सकते हैं (उदाहरण के लिए, इस कष्टप्रद * बीप * को पूरी तरह से हटा दें)।
   
   
4. सार्वजनिक चिह्न getDisabledIcon (JComponent घटक, चिह्न आइकन)
   यह विधि वर्तमान LookAndFeel के अनुरूप लॉक किए गए आइकन का प्रदर्शन लौटाती है। इस विधि का उपयोग अन्य मानक घटकों के लॉक बटन, लेबल और लॉक किए गए तत्वों के आइकन प्रदर्शित करने के लिए किया जाता है। यदि आपके पास "लॉक" प्रकार का आइकन बनाने के लिए एक अधिक सफल / तेज़ तरीका है - इस विधि के पुनर्वितरण के लिए जाएं!
   
   
5. सार्वजनिक आइकन getDisabledSelectedIcon (JComponent घटक, चिह्न आइकन)
   यह विधि पिछले एक के समान है, केवल "चयनित" आइकन के लिए काम करती है। मानक कार्यान्वयन में, पिछली विधि ट्राइट है।
   
   
6. सार्वजनिक स्ट्रिंग getName ()
   सार्वजनिक स्ट्रिंग getID ()
   सार्वजनिक स्ट्रिंग getDescription ()
   सार्वजनिक बूलियन है NativeLookAndFeel ()
   सार्वजनिक बूलियन
   लुकएंडफेल क्लास बनाते समय इन विधियों का वर्णन पहले किया जा चुका है। वे केवल इस LookAndFeel के बारे में मूलभूत जानकारी प्रदान करते हैं
   
   
7. सार्वजनिक बूलियन getSupportsWindowDecorations ()
   यह विधि और अधिक दिलचस्प है - यह UIManager को बताता है कि क्या RootPaneUI इस LookAndFeel द्वारा वापस लौटा है या नहीं। यही है, एक मानक सिस्टम डिज़ाइन के बजाय एक विंडो डिज़ाइन बनाएं। यदि यह विधि सही है, तो आपने अपने रूटपैन्यूई में एक विशिष्ट विंडो सजावट लागू की है - बस दो निम्नलिखित विधियों का पालन करें:

   जेफ्रेम । setDefaultLookAndFeelDecorated ( सच );
   JDialog । setDefaultLookAndFeelDecorated ( सच );
   

   किसी भी JDialog / JFrame उदाहरण को एक विशेष डिज़ाइन में लपेटने के लिए। उसी के बारे में कि इस तरह के डिज़ाइन कैसे बनाएं, ताकि स्प्रे न करें, मैं नियत समय में एक अलग विषय लिखूंगा।
   
   
8. सार्वजनिक शून्य प्रारंभिक ()
   सार्वजनिक शून्य अनैच्छिक ()
   इन विधियों को सीधे स्थापना के दौरान कहा जाता है और, तदनुसार, UIManager के माध्यम से LookAndFeel का परिवर्तन। वे सही ढंग से काम करने के लिए किसी भी वैश्विक श्रोताओं को बनाने और आपके लुकफील के लिए आवश्यक किसी भी चर को बनाने के लिए लपेट सकते हैं।
   
   
9. सार्वजनिक UIDefaults getDefaults ()
   यह विधि, सभी घटकों के मूल डिजाइन के आधार पर, और बड़ी है। यह लुकएंडफेल को काम करने के लिए और इसके व्यक्तिगत यूआई कक्षाओं के लिए आवश्यक विभिन्न चर (फोंट, रंग, हॉटकी, आदि) की सभी विशाल विविधता प्रदान करता है। BasicLookAndFeel में, इस विधि को 3 अलग-अलग भागों में विभाजित किया गया है:
   1. initClassDefaults (UIDefaults तालिका)
      हमने बटन के UI वर्ग को "प्रतिस्थापित" करने के लिए MyLookAndFeel में इस विधि को फिर से परिभाषित किया है, और यह ठीक है कि इसे इस उद्देश्य के लिए पुन: परिभाषित किया जाना चाहिए।
      
      
   2. initSystemColorDefaults (UIDefaults तालिका)
      यह विधि विभिन्न तत्वों के मानक रंगों (विषम रूप से पर्याप्त - हेक्स मान) को परिभाषित करती है।
      
      
   3. initComponentDefaults (UIDefaults तालिका)
      इस सबसे बड़ी विधि में, यदि आवश्यक हो तो फोंट, रंग, कीबोर्ड शॉर्टकट, बॉर्डरबोर्ड और प्रत्येक व्यक्तिगत घटक की अन्य छोटी चीजें निर्धारित की जाती हैं।
   
   
   

शायद अब आप पहले यूआई वर्ग को स्थानांतरित करने के लिए पर्याप्त सीख चुके हैं ...

MyButtonUI.java

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

सार्वजनिक वर्ग MyButtonUI, BasicButtonUI का विस्तार करता है
{
सार्वजनिक शून्य इंस्टॉलयूआई ( JComponent c )
{
// बेसिक UI क्लास में लागू UI इंस्टॉलेशन को छोड़ना सुनिश्चित करें
सुपर । इंस्टॉलयूआई ( सी );

// वांछित JButton सेटिंग्स सेट करें
// अमूर्तता के लिए, AbstractButton का उपयोग करें, क्योंकि इसमें वह सब कुछ है जो हमें चाहिए
AbstractButton बटन = ( AbstractButton ) c ;
बटन । setOpaque ( झूठा );
बटन । setFocusable ( true );
बटन । सेटमैर्जिन ( नए इनसेट्स ( 0, 0, 0, 0 ) );
बटन । setBorder ( BorderFactory । createEmptyBorder ( 4, 4, 4, 4 ) );
}

सार्वजनिक शून्य पेंट ( ग्राफिक्स जी , JComponent c )
{
Graphics2D g2d = ( Graphics2D ) जी ;
जी 2 डी । setRenderingHint ( RenderingHints । KEY_ANTIALIASING , RenderingHints । VALUE_ANTIALIAS_ON );

AbstractButton बटन = ( AbstractButton ) c ;
ButtonModel बटन बटन = बटन । getModel ();

// बटन एक गोल आयताकार होगा

// बटन पृष्ठभूमि
जी 2 डी । सेटपेंट ( नया ग्रेडिएंटपेंट ( 0, 0, रंग । सफेद , 0, सी । गेटहाइट ) ()।
नया रंग ( 200, 200, 200 ) );
// राउंडिंग की आवश्यकता किसी फॉर्म को ड्राइंग करते समय अधिक से अधिक करने की होती है,
// अन्यथा प्रकाश की पृष्ठभूमि किनारों के आसपास चमक जाएगी
जी 2 डी । fillRoundRect ( 0, 0, c । getWidth (), c । getHeight (), 8, 8 );

// बटन बॉर्डर
जी 2 डी । सेटपेंट ( रंग । ग्रे );
// यह याद रखना महत्वपूर्ण है कि आकार को घटक की चौड़ाई / ऊंचाई से 1px छोटा बनाया जाना चाहिए,
// अन्यथा, आंकड़ा का दायां और निचला किनारा घटक सीमा से बाहर पॉप जाएगा और दिखाई नहीं देगा
// यह फिल पर लागू नहीं होता है, क्योंकि भरने के दौरान पिक्सल के अंतिम कॉलम / पंक्ति को नजरअंदाज कर दिया जाता है
जी 2 डी । drawRoundRect ( 0, 0, c । getWidth () - 1, c । getHeight () - 1, 6, 6 );

// बटन दबाते समय ड्राइंग को शिफ्ट करें
यदि ( बटनमॉडल .PPressed () )
{
जी 2 डी । अनुवाद ( 1, 1 );
}

// टेक्स्ट और इमेज आइकन बनाएं
सुपर । पेंट ( जी , सी );
}
}

अब आपको MyLookAndFeel में MyButtonUI का उपयोग करने की आवश्यकता है ताकि यह सभी बटनों के लिए स्वतः स्थापित हो जाए। ऐसा करने के लिए, MyLookAndFeel वर्ग में, हम initClassDefaults (UIDefaults तालिका) विधि को इनहेरिट करते हैं और आवश्यक मान को फिर से परिभाषित करते हैं:

संरक्षित शून्य initClassDefaults ( UIDefaults तालिका )
{
// अभी भी डिफ़ॉल्ट आरंभीकरण को छोड़ दें, क्योंकि हमने अभी तक सब कुछ लागू नहीं किया है
// J घटकों के लिए विभिन्न UI कक्षाएं
सुपर । initClassDefaults ( तालिका );

// और यहाँ, वास्तव में, सबसे महत्वपूर्ण है
तालिका । put ( "ButtonUI" , MyButtonUI । class । getCanonicalName () );
}

अब हमारे पुराने उदाहरण को चलाएं और हमारे "अपडेटेड" बटन को देखने के लिए तैयार रहें:


हम्म, कुछ गलत हो गया ... क्या हमने यूआई क्लास में कहीं गड़बड़ की है?
आइए यूआई बटन को सीधे सेट करने का प्रयास करें:

अंतिम JButton jButton = नया JButton ( "JButton" );
जे बटन setUI ( नया MyButtonUI () );
add ( jButton );

हम कोशिश करते हैं:

नहीं, UI ठीक है। क्या गलत है?

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

यह विधि ComponentUI में मौजूद है, लेकिन यह है ... सार्वजनिक स्थैतिक !? सवाल यह है कि, अमूर्त ComponentUI एक स्थिर विधि क्यों है जिसे ओवरराइड नहीं किया जा सकता है (यही वजह है कि मैंने इसे बहुत दूर नहीं देखा)?

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

सार्वजनिक स्थैतिक संघटक createUI ( JComponent c ) {
AppContext appContext = AppContext । getAppContext ();
बेसिकबटनयूआई बटनयूआई =
( BasicButtonUI ) appContext । get ( BASIC_BUTTON_UI_KEY );
अगर ( buttonUI == null ) {
बटनयूआई = नया बेसिकबटनयूआई ();
appContext । put ( BASIC_BUTTON_UI_KEY , buttonUI );
}
वापसी बटनयूआई ;
}

दरअसल, यही कारण है कि हमारे MyButtonUI का उपयोग नहीं किया गया था। इस निरीक्षण को ठीक करें और MyButtonUI में createUI (JComponent c) विधि जोड़ें:

सार्वजनिक स्थैतिक संघटक createUI ( JComponent c )
{
// हमारे यूआई का एक उदाहरण बनाएँ
नई MyButtonUI () लौटें ;
}

चलिए फिर से अपना उदाहरण देते हैं, लेकिन JButton को UI की जबरन स्थापना के बिना:

हुर्रे, यह काम करता है!

युक्ति: यदि आपका वही UI वर्ग एक निश्चित प्रकार के सभी घटकों के लिए उपयोग किया जा सकता है, तो आपको इसे करना चाहिए। MyButtonUI के साथ हमारे मामले में, यह भी संभव है, इसलिए हम उपरोक्त विधि को थोड़ा संशोधित करेंगे:

निजी स्थिर MyButtonUI उदाहरण = अशक्त ;

सार्वजनिक स्थैतिक संघटक createUI ( JComponent c )
{
// हमारे यूआई का एक उदाहरण बनाएँ
अगर ( उदाहरण == अशक्त )
{
उदाहरण = नया MyButtonUI ();
}
वापसी उदाहरण ;
}

यूआई के इस उपयोग के साथ, हम आवश्यक मेमोरी पर और प्रत्येक व्यक्ति जेबटन के लिए बनाए गए MyButtonUI वर्ग के अत्यधिक इंस्टेंस पर दोनों को बचा सकते हैं। हालाँकि, यदि आप प्रत्येक घटक के UI को अलग से अलग करने की क्षमता जोड़ना चाहते हैं, तो यह विकल्प काम नहीं करेगा।

मरहम में उड़ना

अब हम जानते हैं कि बटन के लिए हमारी अपनी UI क्लास में LookAndFeel कैसे बनाएं और इंस्टॉल करें, लेकिन अन्य घटकों के बारे में क्या? सब कुछ समान है, सब कुछ समान है - आपको आवश्यक UI कक्षाओं के साथ initClassDefaults (UIDefaults तालिका) विधि को पूरक करने की आवश्यकता है। अंतिम रूप में, यह कुछ इस तरह दिखना चाहिए:

संरक्षित शून्य initClassDefaults ( UIDefaults तालिका )
{
// लेबल
तालिका । डाल ( "लेबलयूआई" , ... );
तालिका । डाल ( "ToolTipUI" , ... );

// बटन
तालिका । डाल ( "बटनयूआई" , ... );
तालिका । डाल ( "ToggleButtonUI" , ... );
तालिका । डाल ( "चेकबॉक्सयूआई" , ... );
तालिका । put ( "RadioButtonUI" , ... );

// मेनू
तालिका । डाल ( "मेनूबरी" , ... );
तालिका । डाल ( "मीनू" , ... );
तालिका । डाल ( "पॉपअपमेन्यूई" , ... );
तालिका । डाल ( "MenuItemUI" , ... );
तालिका । डाल ( "CheckBoxMenuItemUI" , ... );
तालिका । put ( "RadioButtonMenuItemUI" , ... );
तालिका । डाल ( "पॉपअपमेन्यूसेपरटेरुई" , ... );

// सेपरेटर
तालिका । put ( "सेपरेटरयूआई" , ... );

// स्क्रॉल करें
तालिका । डाल ( "स्क्रॉलबरी" , ... );
तालिका । डाल ( "स्क्रॉलपनी" , ... );

// पाठ
तालिका । डाल ( "TextFieldUI" , ... );
तालिका । put ( "PasswordFieldUI" , ... );
तालिका । डाल ( "FormattedTextFieldUI" , ... );
तालिका । डाल ( "TextAreaUI" , ... );
तालिका । put ( "EditorPaneUI" , ... );
तालिका । डाल ( "TextPaneUI" , ... );

// टूलबार
तालिका । डाल ( "टूलबरी" , ... );
तालिका । डाल ( "ToolBarSeparatorUI" , ... );

// टेबल
तालिका । डाल ( "TableUI" , ... );
तालिका । डाल ( "TableHeaderUI" , ... );

// चयनकर्ता
तालिका । डाल ( "ColorChooserUI" , ... );
तालिका । put ( "FileChooserUI" , ... );

// कंटेनर
तालिका । डाल ( "पैनलयूआई" , ... );
तालिका । डाल ( "ViewportUI" , ... );
तालिका । डाल ( "रूटपैनियू" , ... );
तालिका । डाल ( "TabbedPaneUI" , ... );
तालिका । डाल ( "स्प्लिटपैनयूआई" , ... );

// जटिल घटक
तालिका । put ( "ProgressBarUI" , ... );
तालिका । डाल ( "स्लाइडरिउडी" , ... );
तालिका । डाल ( "स्पिनरयूआई" , ... );
तालिका । डाल ( "TreeUI" , ... );
तालिका । डाल ( "लिस्टीयू" , ... );
तालिका । डाल ( "कॉम्बो बॉक्सयूआई" , ... );

// डेस्कटॉप पेन
तालिका । डाल ( "DesktopPaneUI" , ... );
तालिका । डाल ( "DesktopIconUI" , ... );
तालिका । डाल ( "इंटरनलफ्रैमुई" , ... );

// विकल्प फलक
तालिका । डाल ( "OptionPaneUI" , ... );
}

बेशक, प्रत्येक "..." के स्थान पर एक विशिष्ट यूआई वर्ग का एक रास्ता होना चाहिए जो एक विशेष जे-घटक की उपस्थिति को निर्धारित करता है।

अब आप कम से कम लगभग कल्पना कर सकते हैं कि मानक स्वाइप घटकों के लिए सभी यूआई को पूरा करने के लिए कितना काम (और समय) करना होगा।

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

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

शायद आदेश के लिए, सीधे ऊपर दिए गए कोड में दी गई सूची पर जाएं ...

पाठ घटक

बेसिकलाबीयूआई - जेलाबेल

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

सभी की जरूरत है - सादा या HTML पाठ, साथ ही अंडरस्कोर mnemonics का प्रतिपादन - BasicLabelUI में है।

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

स्विंगिंग यूटिलिटीज 2 । drawStringUnderlineCharAt ( l , g , s , mnemIndex , textX , textY );

वास्तव में, मुख्य कार्य स्विंगिंग यूटिलिटीज 2 वर्ग द्वारा किया जाता है।

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

हम झूमेंगे नहीं और आगे बढ़ेंगे।

BasicToolTipUI - JToolTip

JLabel घटक की तुलना में कोई सरल नहीं है। वास्तव में, JToolTip (अमूर्त रूप से बोलते हुए) पृष्ठभूमि पर पाठ और कुछ प्रकार की सीमा के साथ है।

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

इसके अलावा, यदि आप JToolTip को setOpaque (गलत) पर सेट करते हैं और यह वर्तमान विंडो के भीतर होगा, तो यह वास्तव में पारदर्शी होगा। यदि टूलटिप को एक अलग JWindow में प्रदर्शित किया जाता है, तो यह ट्रिक अब काम नहीं करेगी।

अब तक, इस स्थिति से बाहर निकलने के लिए कई तरकीबें हैं - हाल ही में प्रदर्शित सुविधाओं के साथ खिड़की को पारदर्शी बनाने के लिए (1.7+ में संस्करण 1.6 u10 + या विंडो विधियों में AWTUtilities) या उस क्षेत्र का "स्क्रीनशॉट" लेने के लिए जिस पर टूलिप प्रदर्शित है और इसे पृष्ठभूमि के रूप में रखें। ।

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

बटन

बेसिकबटनई - जेबटन

ऊपर MyButtonUI उदाहरण में, मैंने BasicButtonUI में परिभाषित विधियों का उपयोग नहीं किया, लेकिन बस पेंट विधि (ग्राफिक्स जी, JComponent c) को पूरी तरह से फिर से परिभाषित किया ।

करो या विरासत के तरीके:
पेंटबटनप्रेस्ड (ग्राफिक्स जी, एब्स्ट्रक्टन बी)
पेंटटेक्स्ट (ग्राफिक्स जी, एब्सट्रिब्यूटन बी, रेक्टेंगल टेक्सट्रेक्ट, स्ट्रिंग टेक्स्ट)
पेंटआईकॉन (ग्राफिक्स जी, जेकॉमप्लांट सी, रेक्टेंगल आइकरेक्ट)
पेंटफोकस (ग्राफिक्स जी, एब्सट्रैक्ट बी) , आयत textRect, आयत iconRect)
मामला पूरी तरह से तुम्हारा है और निर्भर करता है, बल्कि, बटन की जटिलता पर खींचा जा रहा है।

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

किसी भी मामले में, परिणाम समान होगा, जब तक कि निश्चित रूप से आप कहीं भी गलती नहीं करते हैं।

BasicToggleButtonUI - JToggleButton

JToggleButton के लिए कोई ToggleButtonUI वर्ग नहीं है - केवल BasicToggleButtonUI को BasicButtonUI से विरासत में मिला है और उनके बीच लगभग कोई अंतर नहीं है। बस अब, JToggleButton में, बटन मॉडल चयनित = वास्तविक स्थिति को ले सकता है, लेकिन JButton में नहीं, हालाँकि मॉडल स्वयं दोनों मामलों में समान है।

तदनुसार, दृश्य अंतर केवल यह है कि JToggleButton माउस के साथ घटक को पकड़े बिना प्रेस की स्थिति में रह सकता है। इस मामले में, न तो प्रतिपादन और न ही तर्क वास्तव में किसी भी तरह से बदलता है।

इसलिए, मेरे लिए JButton और JToggleButton दोनों के UI को एक ही वर्ग के साथ लागू करना तर्कसंगत है या दृश्य स्वच्छता के लिए विरासत में मिला है (MyToggleButtonUI, MyButtonUI को बढ़ाता है), और निश्चित रूप से, स्थैतिक createUI विधि (JComponent c) को जोड़ना न भूलें MyToggleButtonUI में।

BasicRadioButtonUI - JRadioButton

JToggleButton के समान - इस घटक में RadioButtonUI वर्ग नहीं है। BasicRadioButtonUI, BasicToggleButtonUI से विरासत में मिला है और केवल रेंडर किए गए आइकन और एक मानक पृष्ठभूमि की कमी में भिन्न है।

BasicCheckBoxUI - JCheckBox

यह UI आइकन को छोड़कर, BasicRadioButtonUI को पूरी तरह से डुप्लिकेट करता है।

मेन्यू

BasicMenuBarUI - JMenuBar

यह घटक JMenu घटकों के लिए एक "स्टैंड" है और स्वयं के अलावा, पृष्ठभूमि को छोड़कर, यह कुछ भी आकर्षित नहीं करता है।

हालाँकि, जब BasicMenuBarUI को ओवरराइड किया जाता है, तो यह घटक सीमा को फिर से परिभाषित करने के लिए भी सार्थक है, जिसमें "विरासत" प्रभाव होता है।

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

सिस्टम । setProperty ( "apple.laf.useScreenMenuBar" , "सही" );

मैक ओएस पर चलने पर।

BasicMenuItemUI - JMenuItem

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

BasicMenuItemUI में कई स्रोत-प्रायोजित विधियाँ हैं:

1. paintMenuItem (ग्राफिक्स जी, JComponent c, Icon checkIcon, Icon arrowIcon, Color Background, Color अग्रभूमि, int defaultTextIconGap)
   मुख्य विधि जो मेनू आइटम के विभिन्न भागों की ड्राइंग को एकत्रित करती है।
   
   
2. पेंटबैकैकग्राउंड (ग्राफिक्स जी, जेमेनयूइटेम
   मेनू इटेम, कलर बीजीकलर) मेनू आइटम की पृष्ठभूमि को खींचता है।
   
   
3. PaintCheckIcon (ग्राफ़िक्स g, MenuItemLayoutHelper lh, MenuItemLayoutHelper.LayoutResult lr, Color holdc, Color अग्रभूमि)
   JRadioututMenuItem या JCheckBoxMenuItem के लिए एक चयन आइकन बनाता है।
   
   
4. paintIcon( Graphics g, MenuItemLayoutHelper lh, MenuItemLayoutHelper.LayoutResult lr, Color holdc )
   , JMenuItem' JMenu.
   
   
5. paintText( Graphics g, MenuItemLayoutHelper lh, MenuItemLayoutHelper.LayoutResult lr )
   .
   
   
6. paintAccText( Graphics g, MenuItemLayoutHelper lh, MenuItemLayoutHelper.LayoutResult lr )
   , ( «Alt+F4»).
   
   
7. paintArrowIcon( Graphics g, MenuItemLayoutHelper lh, MenuItemLayoutHelper.LayoutResult lr, Color foreground )
   , JMenu.

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

और यह केवल सभी दलिया की शुरुआत है, फिर यह बेहतर है।

अलग-अलग तत्वों के आकार और स्थानों की सभी गणना MenuItemLayoutHelper वर्ग में की जाती है, जो आम तौर पर दूसरे पैकेज (sun.swing) में स्थित होती है और इसे किसी भी तरह से नहीं बदला जा सकता है। इसके अलावा, यह वर्ग कुछ पुराने JDK और OpenJDK विधानसभाओं में शामिल नहीं है।

नतीजतन, अगर एक तरह से या किसी अन्य आप तत्वों या उनके आकारों के स्थान से संतुष्ट नहीं हैं, तो आपको ट्रिक्स और ट्रिक्स का सहारा लेना होगा और हर संभव तरीके से मानक MenuItemLayoutHelper डेटा को दरकिनार करना होगा (उदाहरण के लिए, मुझे 16x16 आइकन में एक स्थान के साथ एक पंक्ति में सभी मेनू आइटम को संरेखित करना था, यहां तक ​​कि यदि कोई तत्व निर्दिष्ट नहीं है)।

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

BasicMenuUI - JMenu

यह UI 1 इन 1, BasicMenuItemUI के कार्यान्वयन को दोहराता है, लेकिन आपको बुराइयों के बारे में कम चुनना है - या तो अपने BasicMenuItemUI के कार्यान्वयन को विरासत में लें और BasicMenuUI से JMenu के तर्क की नकल करें, या BasicMenuUI से विरासत में लें और अपने वंशज BasicMenuItemUI से दृश्य कार्यान्वयन की प्रतिलिपि बनाएँ।

मैंने दूसरा विकल्प चुना, क्योंकि मेरे कोड को समझना अभी भी आसान है, और दृश्य डिजाइन की नकल करने की तुलना में तर्क में किसी भी बदलाव का समर्थन करना अधिक कठिन होगा।

BasicCheckBoxMenuItemUI - JCheckBoxMenuItem
BasicRadioButtonMenuItemUI - JRadioButtonMenuItem

इन दोनों UI वर्गों को BasicMenuItemUI के आपके कार्यान्वयन से विवेक के बिना विस्तारित किया जा सकता है और आप केवल चेकबॉक्स / रेडियो बटन चयन को आकर्षित करने की विधि को फिर से परिभाषित कर सकते हैं।

या आप इस प्रतिपादन को सीधे अपने BasicMenuItemUI वंशज में लागू कर सकते हैं, और केवल UI की दो डेटा का विस्तार केवल स्थैतिक createUI (JComponent c) विधि को जोड़कर कर सकते हैं ।

BasicPopupMenuSeparatorUI - JSeparator

यह वर्ग केवल थोड़ा संशोधित BasicSeparatorUI का प्रतिनिधित्व करता है और विशेष रूप से JPopupMenu में मेनू आइटम को अलग करने के लिए उपयोग किया जाता है। JSeparator घटक स्वयं एक सरल ड्रॉ स्ट्रिप / लाइन / लाइन है और इसका उपयोग इंटरफ़ेस के तार्किक भागों को नेत्रहीन रूप से अलग करने के लिए किया जाता है।

किसी दिए गए UI वर्ग को ओवरराइड करते समय, यह मानक पेंट विधि (ग्राफिक्स जी, जेकंपोनेंट सी) को बदलने के लिए पर्याप्त है, इसमें विभाजक की वांछित उपस्थिति है।

BasicPopupMenuUI - JPopupMenu

दरअसल, मेन्यू सीरीज़ का आखिरी कंपोनेंट JPopupMenu है। इस घटक के संचालन के लिए आवश्यक सभी तर्क BasicPopupMenuUI में कार्यान्वित किए जाते हैं, इसलिए हमें केवल अपने स्वाद के रूप को बदलना होगा।

यहां वास्तव में दो बिंदु हैं - मेनू बॉर्डर, जो पॉप-अप मेनू के किनारे से आंतरिक तत्वों और मेनू पृष्ठभूमि के ड्राइंग के इंडेंट को निर्धारित करता है।

बॉर्डर को इंस्टॉलयूआई (JComponent c) विधि में स्थापित किया जाना चाहिए , और रेंडरिंग हमेशा की तरह, पेंट (ग्राफिक्स g, JComponent c) विधि में किया जाना चाहिए ।

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

ऐसा करने के लिए, सच्चाई को यूआई वर्ग में वर्तमान पॉप-अप मेनू को याद रखना होगा और, पृष्ठभूमि को आकर्षित करते समय, तत्वों की स्थिति का पता लगाना होगा, साथ ही पृष्ठभूमि को फिर से परिभाषित करने के लिए चयन में परिवर्तन को सही ढंग से सुनना होगा।

जारी रखने के लिए ...

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

यदि आपने उपरोक्त सभी सामग्रियों को पहले ही पढ़ लिया है और महारत हासिल कर ली है, तो आप अपने एलएएफ को लागू करना शुरू करने का प्रयास कर सकते हैं या बस यूआई की कई कक्षाओं को फिर से परिभाषित करने का प्रयास कर सकते हैं।

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

इसके बारे में और पढ़ें, साथ ही एक सप्ताह में अगली कड़ी में शेष यूआई कक्षाएं। और आपके ध्यान के लिए धन्यवाद!

यदि आपके पास Java LookAndFeel / UI के बारे में कोई सवाल है - तो टिप्पणी में सदस्यता समाप्त करने के लिए स्वतंत्र महसूस करें! मैं यथासंभव उनका जवाब देने की कोशिश करूंगा।

PS एक अच्छा पठनीय कोड हाइलाइटिंग के लिए dzz.org परियोजना के लिए विशेष धन्यवाद ।