WX.Python की कथा

हेलो हभब!

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

प्रारंभिक डेटा

कुछ सिद्धांत-परिचय।

1. कार्रवाई में wxPython (रूसी) - पुस्तक का रूसी संस्करण (मैं इसकी गुणवत्ता और उत्पत्ति के बारे में कुछ नहीं कह सकता, क्योंकि मैं मूल पसंद करता हूं, लेकिन वास्तव में यह कार्रवाई में wxPython (अंग्रेजी) है) - यहां यह कागज के रूप में $ 54 (इलेक्ट्रॉनिक) मुझे आशा है कि आप इसे स्वयं पा लेंगे।) आम राय यह है कि पुस्तक उत्कृष्ट है। सब कुछ विस्तार से लिखा गया है और निश्चित रूप से, कई बिंदु विस्तृत नहीं हैं, और कुछ चीजें सबसे अच्छी तरह से प्रलेखन में देखी जाती हैं, लेकिन सामान्य तौर पर, सभी उदाहरण सही हैं, काम कर रहे हैं। शुरुआती लोगों के लिए बढ़िया।

2.wxPython 2.8 एप्लीकेशन डेवलपमेंट कुकबुक । मैंने इस पुस्तक को रूसी संस्करण में खोजने की कोशिश भी नहीं की, क्योंकि सबसे अधिक संभावना है कि यह वहाँ नहीं है। इस पुस्तक में GUI फ़ॉर्म लिखने के लिए "रेसिपी" शामिल है, जो अक्सर तुच्छ नहीं होती हैं और पार्स करना आसान नहीं होता है (हालाँकि किताब में प्रत्येक पंक्ति को समझने की कोशिशें हैं। पढ़ना काफी आसान है।

3. python.su विभिन्न विषयों पर विषयों के अच्छे डेटाबेस के साथ एक उत्कृष्ट मंच है। इसे एक विज्ञापन न मानें, लेकिन यह वास्तव में अच्छा है, यह अफ़सोस की बात है कि यह हाल ही में काम नहीं कर रहा है।

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

आगे देखते हुए, मैं तुरंत कई साधनों की सलाह देना चाहता हूं जो मुझे पुस्तकालय के साथ लंबे समय तक काम करने के बाद मिला था।

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

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

परिचय

इससे पहले कि आप विभिन्न प्रकार की खिड़कियों और उनके गुणों में तल्लीन करना शुरू करें, आपको कुछ बिंदुओं को सीखने की जरूरत है, जिसके बिना यह समझना मुश्किल होगा कि यह क्या और कैसे होना चाहिए:
1. सभी आइटम सिज़र में होने चाहिए। Sizer ( wx.Sizer ) एक निश्चित अदृश्य रूप तत्व है जो फॉर्म के सभी घटकों के स्थान को इंगित करता है।
2. पदानुक्रम इस प्रकार है: प्रपत्र ( wx.Frame ) पर एक sizer है, एक कंटेनर पैनल ( wx.Panel ) sizer में जोड़ा गया है, एक और sizer पैनल में जोड़ा गया है, और सभी तत्व पहले से ही इस sizer में जोड़ दिए गए हैं।
3. पैनल में एक घटक को जोड़ने के बिना इसे जोड़ना गलत है (और wxFormBuilder आपको ऐसा करने की अनुमति नहीं देगा )।
4. सभी नियंत्रणों के गुण पूरी तरह से निर्धारित नहीं हो सकते हैं। मान लीजिए, यदि पाठ इनपुट फ़ील्ड का आकार आपके लिए महत्वपूर्ण नहीं है, तो यह स्वचालित रूप से मानक के रूप में बनाया जाएगा।

मूल तत्व

Wx में कई प्रकार के रूप हैं:
wx.Dialog - एक संवाद बॉक्स।
wx.Frame - मानक कार्यक्षमता (न्यूनतम ( wx.ICONIZE ) के साथ एक विंडो का प्रतिनिधित्व करने वाला सामान्य रूप, अधिकतम ( wx.MAXIMIZE ), करीब ( wx.Close ))।

कोड में wx.Frame का सामान्य प्रतिनिधित्व:

wx.Frame.__init__ ( self, parent=None, id = wx.ID_ANY, title = u"NameWindow", pos = wx.DefaultPosition, size = wx.Size( int,int ), style = wx.CAPTION ) 

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

 wx.Frame.__init__ (self, parent = None) 

वह एक फॉर्म भी निकालेगा, और फॉर्म के सभी गुण मानक होंगे।

स्वयं और माता - पिता किसी भी रूप के दो आवश्यक पैरामीटर हैं।

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

संवाद और फ्रेम के बीच अंतर इस प्रकार हैं:
1. डायलॉग मोडल विंडो, अर्थात जब तक आप इस विंडो में कार्य नहीं करते हैं, तब तक उपयोगकर्ता किसी अन्य विंडो में नहीं जा सकेगा
यह आवेदन।
2. डायलॉग विंडो में पहले से ही एक पैनल होता है, इसलिए, डायलॉग बॉक्स के लिए केवल एक sizer की आवश्यकता होती है और सभी तत्वों को पहले से ही इस sizer पर रखा जाना चाहिए।
3. संवाद बॉक्स बटन पर अतिरिक्त घटनाओं के बिना कर सकते हैं (उस पर अधिक बाद में)।

पुस्तकालय के पास विभिन्न नियंत्रणों की प्रचुरता अद्भुत है। इसमें बटन से लेकर नोटबुक तक टैब के साथ सब कुछ है (इनमें कई प्रकार हैं)।

यहां सब कुछ के बारे में बात करना बेकार है, यह कई महीनों तक चलेगा, इसलिए हम लगभग सभी नियंत्रणों और तत्वों के लिए मानक क्षणों की व्याख्या करते हुए, संक्षेप में कई तत्वों पर जाएंगे।

सरलतम तत्वों को निम्नलिखित कोड कोड में दिखाया गया है:

 class regexps ( wx.Frame ): def __init__( self, main, schema, table, connection ): wx.Frame.__init__ ( self, parent=None, id = wx.ID_ANY, title = u"Data Quality --     ", pos = wx.DefaultPosition, size = wx.Size( 510,477 ), style = wx.CAPTION|wx.STAY_ON_TOP|wx.TAB_TRAVERSAL ) sizer1 = wx.BoxSizer( wx.HORIZONTAL ) self.regexps_notebook = wx.Notebook( self, wx.ID_ANY, wx.DefaultPosition, wx.DefaultSize, 0 ) self.dq_params_tab = wx.Panel( self.regexps_notebook, wx.ID_ANY, wx.DefaultPosition, wx.DefaultSize, wx.TAB_TRAVERSAL ) 

प्रकार की विंडो की प्रारंभ wx.Frame , जैसा कि आप देख सकते हैं, सभी गुण मौजूद हैं। उनमें से कुछ मानक मूल्यों को दिए गए हैं। यह शैलियों के लेआउट पर ध्यान देने योग्य है। हमें शीर्ष पट्टी के साथ एक विंडो मिलती है, और सिस्टम मेनू एक निष्क्रिय क्लोज बटन के रूप में। साथ ही, विंडो हमेशा सक्रिय रहेगी ( wx.STAY_ON_TOP )। Sizer घोषणा। Sizer प्रकार wx.BoxSizer एक बॉक्स है। सभी संस्करणों को एक के बाद एक क्षैतिज या लंबवत (तर्क के लिए पारित तर्क इस के लिए जिम्मेदार है, इस मामले में wx.HORIZONTAL )। नोटबुक विज्ञापन (टैब्ड पैनल)। सबसे पहले, उसे एक नाम दिया गया था: self.regexps_notebook , ताकि आप इसे किसी भी क्लास विधि से बना सकें। अगला गुण के साथ wx.Notebook घटक की घोषणा है। लैपटॉप पर फिट होने वाले पैनल की एक घोषणा। ध्यान दें कि लैपटॉप पर रखा गया पैनल सभी टैब के लिए प्लेटफ़ॉर्म होगा। इसके अलावा, पैनल को एक लैपटॉप टैब के रूप में रखने के लिए एक अलग सिज़र की आवश्यकता नहीं होती है (यह इस तथ्य का खंडन करता है कि सभी तत्व sizers में होने चाहिए, अर्थात यह इस नियम का अपवाद है)

  sizer2 = wx.BoxSizer( wx.VERTICAL ) self.use_param_checkbox = wx.CheckBox( self.dq_params_tab, wx.ID_ANY, u" ", wx.DefaultPosition, wx.DefaultSize, 0 ) 

दूसरे सिस्टर की घोषणा। Sizer का न्यूनतम आकार। एक नया चेकबॉक्स घटक जोड़ें। इसे self.dq_params_tab पैनल में जोड़ें, अर्थात लैपटॉप टैब पर।

  sizer2.Add( self.use_param_checkbox, 0, wx.ALL, 5 ) self.params_quality_choices = [1,2,3,4,5,6,7,8,9,10] self.params_choice_pull = wx.Choice( self.dq_params_tab, wx.ID_ANY, wx.DefaultPosition, wx.DefaultSize, self.params_quality_choices, 0 ) #   ,        wx.Choice. self.params_choice_pull.SetSelection( 0 ) #     . self.static_line = wx.StaticLine( self.dq_params_tab, wx.ID_ANY, wx.DefaultPosition, wx.DefaultSize, wx.LI_HORIZONTAL ) 

एक महत्वपूर्ण बिंदु। Sizer में निर्मित चेकबॉक्स को जोड़ने पर, यह वह है जो पैनल (टैब) पर है। परिवर्धन की निम्न संरचना है: sizer2 - निर्मित sizer, जोड़ें - हम आइटम जोड़ें विधि को कहते हैं, और Add विधि के तर्क: क्या जोड़ें ( self.use_param_checkbox , wx.ALL - यह एक प्रदर्शन पैरामीटर है, इस मामले में एलमेनसेट को पूर्ण आकार में दिखाया जाएगा, 0 (यह तत्व का आनुपातिकता है और 5 (यह तत्व की सीमा का आकार है) अगला मानों के साथ ड्रॉप-डाउन सूची की घोषणा है। वास्तव में .params_quality_choices मूल्यों की एक सूची है। अगला, wx.Choice तत्व है।) जो भी omeschaetsya टैब।

  sizer2.Add( self.static_line, 0, wx.EXPAND |wx.ALL, 5 ) self.static_text = wx.StaticText( self.dq_params_tab, wx.ID_ANY, u"  ", wx.DefaultPosition, wx.DefaultSize, 0 ) sizer2.Add( self.static_text, 0, wx.ALL, 5 ) self.weights_txt = wx.TextCtrl( self.dq_params_tab, validator = WeightsValidator() ) sizer2.Add( self.weights_txt, 0, wx.ALL, 5 ) 

यहां हमारे पास एक अतिरिक्त विकल्प है। wx.EXPAND - इसका मतलब है कि जोड़े गए तत्व को उसके आकार के आधार पर चौड़ाई में बढ़ाया जाएगा। Wx.TextCtrl दर्ज करने के लिए एक टेक्स्ट फ़ील्ड जोड़ना। यहां एक अतिरिक्त सत्यापनकर्ता विकल्प है । इस पर एक अन्य कोड में चर्चा की जाएगी।

  self.dq_params_tab.SetSizer( sizer2 ) self.dq_params_tab.Layout() sizer2.Fit( self.dq_params_tab ) #    . self.regexps_notebook.AddPage( self.dq_params_tab, u" ", False ) self.regexps_tab = wx.Panel( self.regexps_notebook, wx.ID_ANY, wx.DefaultPosition, wx.DefaultSize, wx.TAB_TRAVERSAL ) sizer3 = wx.BoxSizer( wx.VERTICAL ) 

एक दिलचस्प बिंदु पर आया। Sizer ( sizer2 ) में सभी तत्वों को जोड़ने के बाद, जो पैनल ( self.dq_params_tab ) पर है, पैनल के पूरे क्षेत्र में sizer को "विस्तारित" करना और पैनल पर sizer को ठीक करना आवश्यक है।

  regexps_listboxChoices = [] self.regexps_listbox = wx.ListBox( self.regexps_tab, wx.ID_ANY, wx.DefaultPosition, wx.DefaultSize, regexps_listboxChoices, wx.LB_HSCROLL|wx.LB_SINGLE ) #   (wx.grid.Grid).   ,   mysql, oracle, sqlite and etc.    ,   . self.check_grid = wx.grid.Grid( self.check_sql_tab, wx.ID_ANY, wx.DefaultPosition, wx.Size(480,407), wx.HSCROLL|wx.VSCROLL ) #   ,    . # Grid self.check_grid.CreateGrid( 5, 5 ) #   . self.check_grid.EnableEditing( False ) self.check_grid.EnableGridLines( True ) self.check_grid.EnableDragGridSize( False ) self.check_grid.SetMargins( 0, 0 ) #    # Columns self.check_grid.EnableDragColMove( False ) self.check_grid.EnableDragColSize( False ) self.check_grid.SetColLabelSize( 20 ) self.check_grid.SetColLabelAlignment( wx.ALIGN_CENTRE, wx.ALIGN_CENTRE ) #  . # Rows self.check_grid.AutoSizeRows( True ) self.check_grid.EnableDragRowSize( True ) self.check_grid.SetRowLabelSize( 40 ) self.check_grid.SetRowLabelAlignment( wx.ALIGN_CENTRE, wx.ALIGN_CENTRE ) 

एक सूची बॉक्स ( wx.ListBox ) जोड़ना। विकल्प wx.LB_HSCROLL | wx.LB_SINGLE क्षैतिज स्क्रॉल की उपस्थिति के बारे में बात करता है और सूची में केवल एक आइटम का चयन किया जा सकता है। एक ग्रिड का निर्माण। टिप्पणियों में आगे सब कुछ वर्णित है।

इंडेंटेशन सिंटेक्स थोड़ा अस्पष्ट है, क्योंकि लाइनें लंबी हैं। यह पुस्तकालय का वाक्य विन्यास है।

समान निर्माण और तत्वों की व्यवस्था कोड में गायब है, लेकिन अगर हम पूरे मॉड्यूल का पूरा कोड चलाते हैं, तो हम निम्नलिखित देखेंगे (यदि कोई पूर्ण कोड में रुचि रखता है, तो लिखें):


पहला टैब

दूसरा टैब

तीसरा टैब।

भवन नियंत्रण सूची

कुछ सरल तत्वों की जांच करने के बाद, हम और अधिक जटिल चीजों की ओर बढ़ेंगे।

नियंत्रण पत्र एक सार्वभौमिक तत्व है और हम इसे विभिन्न अनुप्रयोगों में बहुत बार देखते हैं।

अब हम यादृच्छिक डेटा के लिए एक कंट्रोल शीट बनाने के लिए कोड का विश्लेषण करेंगे।

 class main_stat(listmix.ColumnSorterMixin): def __init__( self, rows, columns ): data = [] self.columns = columns self.rows = rows self.list = wx.ListCtrl(self.main.panelMainStat, 0, style=wx.LC_REPORT | wx.BORDER_NONE | wx.LC_EDIT_LABELS | wx.LC_SORT_ASCENDING | wx.LC_SINGLE_SEL) 

कक्षा को एक तर्क के रूप में घोषित करते हुए, हम डेटा में स्तंभों को सॉर्ट करने के लिए एक सूची ' लिस्ट ' पास करते हैं। इसके बाद लीफ कंट्रोल का इनिशियलाइज़ेशन होता है जिसमें सभी सबसे गुप्त होते हैं।
हम इसमें कॉलम ( कॉलम ) और रो ( पंक्तियों ) का नाम देते हैं। पंक्तियों के साथ सूची की लंबाई स्तंभों के नाम के साथ सूची की लंबाई के बराबर होनी चाहिए। Listcontrol self.list को कॉल करें और इसे गुणों को असाइन करें ।
गुणों के बारे में: wx.LC_REPORT शैली - शीर्ष पर स्तंभ नामों के रूप में पत्ती नियंत्रण, स्तंभ के नीचे सभी डेटा, जैसे तालिका, एक प्रकार की समानता। इसलिए बाकी शैलियों को अंग्रेजी से अनुवाद के आधार पर समझा जा सकता है।

  for col, text in enumerate(self.columns): self.list.InsertColumn(col, text) for item in rows: info = '%s:(%s)' % (col, item) data.append(info) index = self.list.InsertStringItem(sys.maxint, item[0]) for col, text in enumerate(item[1:]): self.list.SetStringItem(index, col+1, text) 

अगला, थोड़ा चालाक डेटा पीढ़ी एल्गोरिथ्म। इसका wx से कोई लेना-देना नहीं है, इसलिए मैंने विस्तार से नहीं लिखा। लेकिन बात यह है
नियंत्रण पत्रक के लिए डेटा निम्नानुसार होना चाहिए:
पंक्तियों = {1 :( "data0", "data0.1", "data0.2"), 2 :( "data1", "data1.0", "data1.1", "data1.2"), ... }
उपरोक्त एल्गोरिथ्म इस फॉर्म में यादृच्छिक डेटा लाता है।

  self.list.SetSize((900, 200)) self.list.SetColumnWidth(0, 120) self.list.Bind(wx.EVT_LIST_COL_CLICK, self.OnColClick, self.list) self.list.Bind(wx.EVT_COMMAND_RIGHT_CLICK, self.OnRightClick) self.list.Bind(wx.EVT_LIST_ITEM_SELECTED, self.OnItemSelected) self.itemDataMap = data listmix.ColumnSorterMixin.__init__(self, 3) 

हम नियंत्रण शीट का आकार, स्तंभ का आकार और घटना बिंदिम (इस पर बाद में अधिक) सेट करते हैं। निम्नलिखित काफी कोड का एक काम नहीं है, क्योंकि
self.itemDataMap दिए गए डेटा के बराबर होना चाहिए जैसा कि ऊपर दिखाया गया है, फिलहाल डेटा को बिना छांटे बिना सूची नियंत्रण में दर्ज किया गया है।

  def getColumnText(self, index, col): item = self.list.GetItem(index, col) return item.GetText() def OnRightClick(self, event): index = self.list.GetFirstSelected() print index def OnColClick(self, event): print ("OnColClick: %d\n" % event.GetColumn()) event.Skip() def OnItemSelected(self, event): self.currentItem = event.m_itemIndex self.data = (self.getColumnText(self.currentItem, 1), self.getColumnText(self.currentItem, 2), self.getColumnText(self.currentItem, 3), self.getColumnText(self.currentItem, 4))( True ) 

डेटा वाली लाइन पर राइट-क्लिक करना हमें इस लाइन का सीरियल नंबर दिखाता है। OnColClick विधि हमें कॉलम सीरियल नंबर देगी। और डेटा के साथ एक पंक्ति का चयन करते समय, हम एक चर में हैं
self.data एक सूची उस डेटा के साथ लिखी जाएगी जिसे हमने चुना था (बस यहां, getColumnText विधि का उपयोग किया जाता है, इसके साथ हम प्रत्येक कॉलम से डेटा खींचते हैं।


निर्मित पत्ती नियंत्रण का एक उदाहरण।

मेन्यू

अब, किसी भी आवेदन के अभिन्न अंग पर चलते हैं - मेनू।

  self.menubar = wx.MenuBar( 0 ) self.BD = wx.Menu() self.m_menuItem1 = wx.MenuItem( self.BD, 1, u"  ", u'    ', wx.ITEM_NORMAL ) self.BD.AppendItem(self.m_menuItem1, ) self.m_menuItem2 = wx.MenuItem( self.BD, 2, u" \tCtrl+T", u'       ', wx.ITEM_NORMAL ) self.BD.AppendItem( self.m_menuItem2 ) self.m_menuItem3 = wx.MenuItem( self.BD, 3, u"  \tCtrl+Q", u'       ', wx.ITEM_NORMAL ) self.BD.AppendItem( self.m_menuItem3 ) 

मेनूबार विज्ञापन। मेनू बार एक स्ट्रिप है जहां ड्रॉप-डाउन सूची वाले सभी मेनू आइटम स्थित हैं। self.BD = wx.Menu () - एक मेनू आइटम बनाएं, फिर जोड़ें
मेनू आइटम स्वयं में। बीडी। आइए अधिक विस्तार से विश्लेषण करें:

 self.m_menuItem1 = wx.MenuItem( self.BD, 1, u"  ", u'    ', wx.ITEM_NORMAL ) 

wx.MenuItem ( किस मेनू में हम मेनू आइटम, आईडी, नाम \ हॉटकी जोड़ते हैं, स्टेटस बार में प्रदर्शित हेल्प टेक्स्ट (यदि कोई हो), मेनू आइटम का प्रकार )
नाम के बाद, हॉटकी के बाद \ t (टैब कैरेक्टर) होता है, जिस पर क्लिक करने पर मेनू आइटम को एक्टिव होने पर कॉल किया जाएगा। इस घटना को अतिरिक्त रूप से संसाधित करना आवश्यक नहीं है।
मेनू आइटम के प्रकार भिन्न हो सकते हैं:
wx.ITEM_RADIO - रेडियो बटन के वीडियो में एक आइटम, wx.ITEM_CHECK - एक चेकबॉक्स के रूप में,
अगला, हम उसी तरह कई मेनू आइटम जोड़ते हैं।

  self.statusbar = self.CreateStatusBar( 1, wx.ST_SIZEGRIP, wx.ID_ANY ) self.BD.Enable(2, False) self.statusbar.SetStatusText(u'  ,       ,        .') 

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


और यहाँ मेनू है।

घटना संचालित पर्यावरण

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

 self.ok_btn = wx.Button( self.m_panel5, wx.ID_ANY, u"OK", wx.DefaultPosition, wx.DefaultSize, 0 ) 

और हम बटन दबाकर प्रोग्राम 2 + 2 जोड़ना चाहते हैं:

 self.ok_btn.Bind( wx.EVT_BUTTON, self.OnOk ) #     # self.Bind( wx.EVT_BUTTON, self.OnOk, self.ok_btn ) def OnOk(self, event): a = 2+2 print a 

ओनोक विधि एक बटन के क्लिक पर काम करेगी। दरअसल यह घटनाओं का पूरा बिंदु है। अंतर केवल wx.EVT_BUTTON में हैं (संसाधित होने की स्थिति में) और वह तत्व जिस पर हम इस ईवेंट को लटकाते हैं (हमारे मामले में, यह self.ok_btn बटन है।

 # 1 self.Bind(wx.EVT_MENU, self.About, id=10) # 2 self.Bind( wx.EVT_IDLE, self.OnInit ) 

इवेंट नंबर 1 को संबंधित मेनू आइटम दबाकर ट्रिगर किया जाएगा, और इवेंट नंबर 2 जब एक फॉर्म निष्क्रिय (उपयोगकर्ता निष्क्रियता) प्रकट होता है।

प्रमाणकों

किसी भी पाठ क्षेत्र को अपेक्षित त्रुटियों से बचाने के लिए उपयोगकर्ता द्वारा सत्यापित किया जाना चाहिए। ऐसा करने के लिए, wx सत्यापनकर्ताओं - स्व-लिखित चेक प्रदान करता है। वे स्व-लिखित हैं, क्योंकि कोई अंतर्निहित चेक नहीं हैं, प्रत्येक सत्यापनकर्ता का वर्णन किया जाना चाहिए।

यहाँ स्पष्टीकरण के साथ एक उदाहरण दिया गया है:

 class Numbers(wx.PyValidator): def __init__(self): wx.PyValidator.__init__(self) self.Bind(wx.EVT_CHAR, self.OnChar) def Clone(self): return Numbers() def Validate(self, win): tc = self.GetWindow() val = tc.GetValue() for x in val: if x not in string.digits: return False return True def OnChar(self, event): key = event.GetKeyCode() try: # 8    backspace if chr(key) in string.digits or chr(key) == '.' or key == 8: event.Skip() else: return False except ValueError, info: print chr(key) print info return 

हम एक वर्ग बनाते हैं जिसके तर्क के साथ हम wx.PyValidator देते हैं जो कहता है कि यह वर्ग सत्यापनकर्ता है।
OnChar विधि का वर्णन self.Bind इवेंट (wx.EVT_CHAR, self.OnChar) द्वारा किया जाता है, और जब कीबोर्ड से वर्ण दर्ज किए जाते हैं, तो इसे निष्पादित किया जाएगा। कुंजी = event.GetKeyCode () कमांड के साथ, हम प्रत्येक प्रेस के लिए कोड को पकड़ते हैं, और अंतर्निहित chr () फ़ंक्शन कोड कुंजी को दबाए गए कुंजी के सामान्य प्रतिनिधित्व में अनुवाद करता है। string.digits में 0 से 9 तक संख्याओं की एक सूची होती है, स्ट्रिंग क्लास में भी लगभग सभी वर्ण होते हैं जो कीबोर्ड से दर्ज किए जाते हैं, हेक्सडिटिज तक (दुर्भाग्यवश ascii वर्ण भी हैं, लेकिन रूसी भाषा, जैसा कि मैं समझता हूं, दर्ज नहीं करता है )।

मान्य विधि
tc = self.GetWindow () उस विंडो को परिभाषित करता है जहां टेक्स्ट फ़ील्ड स्थित है, दर्ज मूल्य को वैल करें , फिर सत्यापन चक्र। यह सत्यापनकर्ता उपयोगकर्ता को संख्या, अवधि और बैकस्पेस को छोड़कर एक कुंजी को दबाने की अनुमति नहीं देगा। बैकस्पेस की बात करते हुए, wx सभी कुंजियों का वर्णन करता है, उदाहरण के लिए wx.WXK_Numpad0, लेकिन बैकस्पेस नहीं है, F1 से लेकर न्यूक्लॉक तक सब कुछ है, इसलिए मुझे प्रमुख मानों को ट्रैक करना पड़ा।

सत्यापनकर्ता को लिखने के बाद, आपको एक पाठ क्षेत्र को परिभाषित करने और इसे उस सत्यापनकर्ता को इंगित करने की आवश्यकता है जो इसके अनुरूप है।

 self.ip_ctrl = wx.TextCtrl( self.m_panel5, wx.ID_ANY, wx.EmptyString, wx.DefaultPosition, wx.Size( 190,-1 ), 0, Numbers() ) 

बस इतना ही। लेख बहुत बड़ा और थोड़ा गड़बड़ निकला। ऐसा इसलिए है क्योंकि यदि आप wx.ListCtrl को बाध्य करने वाली सभी संपत्तियों और घटनाओं का वर्णन करना शुरू करते हैं, तो लेख इससे भी अधिक निकलेगा। यदि आपको लेख पसंद आया है और यह जारी रखने के लिए समझ में आता है, तो मैं अगले एक लिखना शुरू करूंगा, लाइब्रेरी के अन्य तत्वों और विशेषताओं का खुलासा करना, उदाहरण के लिए wx.aui - यह टैब के साथ एक उन्नत नोटबुक है, जहां यह प्रकट होगा।

आपका ध्यान देने के लिए धन्यवाद।

अलावा:
कोड
वर्ग regexps (wx.Frame):

डीई __init __ (स्व, मुख्य, स्कीमा, टेबल, कनेक्शन):

wx.Frame .__ init__ (स्व, माता-पिता = कोई नहीं, आईडी = wx.ID_ANY, ...)

सुपर के माध्यम से अधिक अच्छी तरह से फिर से लिखा जा सकता है:

वर्ग regexps (wx.Frame):

डीई __init __ (स्व, मुख्य, स्कीमा, टेबल, कनेक्शन):

सुपर (regexps, self) .__ init__ (माता-पिता = कोई नहीं, id = wx.ID_ANY, ...)

जेने द्वारा