PyGObject ഉപയോഗിച്ച് Linux ഡെസ്ക്ടോപ്പിന് കീഴിൽ GUI ആപ്ലിക്കേഷനുകൾ എങ്ങനെ സൃഷ്ടിക്കാം - ഭാഗം 1

ലിനക്സിൽ ആപ്ലിക്കേഷനുകൾ സൃഷ്ടിക്കുന്നത് വ്യത്യസ്ത വഴികളിലൂടെ ചെയ്യാം, എന്നാൽ പരിമിതമായ വഴികളുണ്ട്, അതിനാൽ ഏറ്റവും ലളിതവും പ്രവർത്തനപരവുമായ പ്രോഗ്രാമിംഗ് ഭാഷകളും ലൈബ്രറികളും ഉപയോഗിക്കുന്നു, അതുകൊണ്ടാണ് ലിനക്സിന് കീഴിൽ ആപ്ലിക്കേഷനുകൾ സൃഷ്ടിക്കുന്നതിനെക്കുറിച്ച് ഞങ്ങൾ പെട്ടെന്ന് നോക്കാൻ പോകുന്നത്. \PyGObject എന്ന് വിളിക്കപ്പെടുന്ന Python പ്രോഗ്രാമിംഗ് ഭാഷയുള്ള GTK+ ലൈബ്രറി ഉപയോഗിക്കുന്ന ഡെസ്ക്ടോപ്പ്.

PyGObject, Python പോലുള്ള പ്രോഗ്രാമിംഗ് ഭാഷകൾക്കായി ബൈൻഡിംഗ് സൃഷ്ടിക്കാൻ GObject Introspection ഉപയോഗിക്കുന്നു, PyGTK-യിൽ നിന്നുള്ള അടുത്ത തലമുറയാണ് PyGObject, PyGObject = Python + GTK3 എന്ന് നിങ്ങൾക്ക് പറയാം.

ഇന്ന്, GTK+ ലൈബ്രറിയും PyGobject ഭാഷയും ഉപയോഗിച്ച് Linux ഡെസ്uക്uടോപ്പിന് കീഴിൽ GUI (ഗ്രാഫിക്കൽ യൂസർ ഇന്റർഫേസ്) ആപ്ലിക്കേഷനുകൾ സൃഷ്uടിക്കുന്നതിനെക്കുറിച്ചുള്ള ഒരു പരമ്പര ഞങ്ങൾ ആരംഭിക്കാൻ പോകുന്നു, സീരീസ് ഇനിപ്പറയുന്ന വിഷയങ്ങൾ ഉൾക്കൊള്ളുന്നു:

ഒന്നാമതായി, നിങ്ങൾക്ക് പൈത്തണിൽ കുറച്ച് അടിസ്ഥാന അറിവ് ഉണ്ടായിരിക്കണം; പൈത്തൺ വളരെ ആധുനികവും ഉപയോഗിക്കാൻ എളുപ്പമുള്ളതുമായ പ്രോഗ്രാമിംഗ് ഭാഷയാണ്. ലോകത്തിലെ ഏറ്റവും പ്രശസ്തമായ പ്രോഗ്രാമിംഗ് ഭാഷകളിൽ ഒന്നാണിത്, പൈത്തൺ ഉപയോഗിച്ച് നിങ്ങൾക്ക് നിരവധി മികച്ച ആപ്ലിക്കേഷനുകളും ഉപകരണങ്ങളും സൃഷ്ടിക്കാൻ കഴിയും. codeacademy.com-ൽ ഉള്ളതുപോലുള്ള ചില സൗജന്യ കോഴ്uസുകൾ നിങ്ങൾക്ക് എടുക്കാം അല്ലെങ്കിൽ പൈത്തണിനെക്കുറിച്ചുള്ള ചില പുസ്തകങ്ങൾ ഇവിടെ വായിക്കാം:

ഡെസ്ക്ടോപ്പ് ആപ്ലിക്കേഷനുകൾക്കായി ഗ്രാഫിക്കൽ യൂസർ ഇന്റർഫേസുകൾ സൃഷ്ടിക്കുന്നതിനുള്ള ഒരു ഓപ്പൺ സോഴ്സ് ക്രോസ്-പ്ലാറ്റ്ഫോം ടൂൾകിറ്റാണ് GTK+, GIMP-നുള്ള GUI ടൂൾകിറ്റായി 1998-ലാണ് ഇത് ആദ്യമായി ആരംഭിച്ചത്, പിന്നീട് ഇത് മറ്റ് പല ആപ്ലിക്കേഷനുകളിലും ഉപയോഗിച്ചു. താമസിയാതെ GUI-കൾ സൃഷ്ടിക്കുന്നതിനുള്ള ഏറ്റവും പ്രശസ്തമായ ലൈബ്രറികളിൽ ഒന്നായി. LGPL ലൈസൻസിന് കീഴിലാണ് GTK+ പുറത്തിറങ്ങുന്നത്.

Linux-ന് കീഴിൽ GUI ആപ്ലിക്കേഷനുകൾ സൃഷ്ടിക്കുന്നു

GTK+ & Python ഉപയോഗിച്ച് ആപ്ലിക്കേഷനുകൾ സൃഷ്ടിക്കുന്നതിന് 2 വഴികളുണ്ട്:

1. കോഡ് ഉപയോഗിച്ച് മാത്രം ഗ്രാഫിക്കൽ ഇന്റർഫേസ് എഴുതുന്നു.
2. GTK+ ഇന്റർഫേസുകൾ എളുപ്പത്തിൽ രൂപകൽപ്പന ചെയ്യുന്നതിനുള്ള RAD ടൂളായ \Glade പ്രോഗ്രാം ഉപയോഗിച്ച് ഗ്രാഫിക്കൽ ഇന്റർഫേസ് രൂപകൽപ്പന ചെയ്യുന്നു, Glade ഒരു XML ഫയലായി GUI സൃഷ്ടിക്കുന്നു, അത് നിർമ്മിക്കാൻ ഏത് പ്രോഗ്രാമിംഗ് ഭാഷയിലും ഉപയോഗിക്കാം. GUI, GUI-യുടെ XML ഫയൽ എക്uസ്uപോർട്ട് ചെയ്uതതിന് ശേഷം, ഞങ്ങൾക്ക് ആവശ്യമുള്ള ജോലികൾ ചെയ്യാൻ XML ഫയലിനെ ഞങ്ങളുടെ പ്രോഗ്രാമുമായി ലിങ്ക് ചെയ്യാൻ കഴിയും.

രണ്ട് വഴികളും ഞങ്ങൾ ചുരുക്കത്തിൽ വിശദീകരിക്കും.

കോഡ് മാത്രം ഉപയോഗിച്ച് GUI എഴുതുന്നത് നൂബ് പ്രോഗ്രാമർമാർക്ക് അൽപ്പം ബുദ്ധിമുട്ടുള്ളതും സമയം പാഴാക്കുന്നതുമാണ്, പക്ഷേ ഇത് ഉപയോഗിച്ച്, Glade പോലുള്ള ചില ടൂളുകൾ ഉപയോഗിച്ച് ഞങ്ങൾ സൃഷ്ടിക്കുന്നതിനേക്കാൾ കൂടുതൽ പ്രവർത്തനക്ഷമമായ GUI-കൾ ഞങ്ങളുടെ പ്രോഗ്രാമുകൾക്കായി സൃഷ്ടിക്കാൻ കഴിയും.

ഇനി പറയുന്ന ഉദാഹരണം എടുക്കാം.

#!/usr/bin/python
# -*- coding: utf-8 -*-

from gi.repository import Gtk

class ourwindow(Gtk.Window):

    def __init__(self):
        Gtk.Window.__init__(self, title="My Hello World Program")
        Gtk.Window.set_default_size(self, 400,325)
        Gtk.Window.set_position(self, Gtk.WindowPosition.CENTER)

        button1 = Gtk.Button("Hello, World!")
        button1.connect("clicked", self.whenbutton1_clicked)

        self.add(button1)
        
    def whenbutton1_clicked(self, button):
      print "Hello, World!"

window = ourwindow()        
window.connect("delete-event", Gtk.main_quit)
window.show_all()
Gtk.main()

മുകളിലെ കോഡ് പകർത്തി ഒരു \test.py ഫയലിൽ ഒട്ടിച്ച് test.py ഫയലിൽ 755 അനുമതി സജ്ജീകരിച്ച് \./test.py< ഉപയോഗിച്ച് ഫയൽ റൺ ചെയ്യുക.”, അതാണ് നിങ്ങൾക്ക് ലഭിക്കുക.

# nano test.py
# chmod 755 test.py
# ./test.py

ബട്ടണിൽ ക്ലിക്കുചെയ്യുന്നതിലൂടെ, ടെർമിനലിൽ അച്ചടിച്ച \ഹലോ, വേൾഡ്! വാചകം നിങ്ങൾ കാണുന്നു:

കോഡ് വിശദമായി വിശദീകരിക്കാം.

1. #!/usr/bin/python: പൈത്തൺ ഇന്റർപ്രെറ്ററിനായുള്ള ഡിഫോൾട്ട് പാത്ത് (മിക്ക കേസുകളിലും പതിപ്പ് 2.7), ഈ വരി എല്ലാ പൈത്തൺ ഫയലിലെയും ആദ്യ വരി ആയിരിക്കണം.
2. # -*- കോഡിംഗ്: utf-8 -*-: ഇവിടെ ഞങ്ങൾ ഫയലിനായി ഡിഫോൾട്ട് കോഡിംഗ് സജ്ജീകരിച്ചു, നിങ്ങൾക്ക് ഇംഗ്ലീഷ് ഇതര ഭാഷകളെ പിന്തുണയ്uക്കണമെങ്കിൽ UTF-8 ആണ് മികച്ചത്, വിടുക അത് അങ്ങനെയാണ്.
3. gi.repository import Gtk-ൽ നിന്ന്: ഞങ്ങളുടെ പ്രോഗ്രാമിൽ ഉപയോഗിക്കുന്നതിന് GTK 3 ലൈബ്രറി ഞങ്ങൾ ഇവിടെ ഇറക്കുമതി ചെയ്യുന്നു.
4. Class ourwindow(Gtk.Window): ഇവിടെ ഞങ്ങൾ ഒരു പുതിയ ക്ലാസ് സൃഷ്uടിക്കുന്നു, അതിനെ \നമ്മുടെ വിൻഡോ എന്ന് വിളിക്കുന്നു, ഞങ്ങൾ ക്ലാസ് ഒബ്uജക്റ്റ് തരവും \Gtk.Window ആയി സജ്ജീകരിക്കുന്നു.
5. def __init__(self): പുതിയതൊന്നുമില്ല, ഞങ്ങൾ ഇവിടെ പ്രധാന വിൻഡോ ഘടകങ്ങൾ നിർവചിക്കുന്നു.
6. Gtk.Window.__init__(self, title=”My Hello World Program”): \My Hello World Program ശീർഷകം \ourwindow ആയി സജ്ജീകരിക്കാൻ ഞങ്ങൾ ഈ ലൈൻ ഉപയോഗിക്കുന്നു വിൻഡോ, നിങ്ങൾക്ക് വേണമെങ്കിൽ തലക്കെട്ട് മാറ്റാം.
7. Gtk.Window.set_default_size(self, 400,325): ഈ ലൈനിന് വിശദീകരണം ആവശ്യമാണെന്ന് ഞാൻ കരുതുന്നില്ല, ഇവിടെ ഞങ്ങൾ ഞങ്ങളുടെ വിൻഡോയുടെ ഡിഫോൾട്ട് വീതിയും ഉയരവും സജ്ജമാക്കുകയാണ്.
8. Gtk.Window.set_position(self, Gtk.WindowPosition.CENTER): ഈ ലൈൻ ഉപയോഗിച്ച്, നമുക്ക് വിൻഡോയുടെ സ്ഥിരസ്ഥിതി സ്ഥാനം സജ്ജമാക്കാൻ കഴിയും, ഈ സാഹചര്യത്തിൽ, ഞങ്ങൾ അത് സജ്ജീകരിക്കും. \Gtk.WindowPosition.CENTER പാരാമീറ്റർ ഉപയോഗിച്ച് മധ്യഭാഗത്തേക്ക്, നിങ്ങൾക്ക് വേണമെങ്കിൽ, മൗസ് പോയിന്റർ പൊസിഷനിലെ വിൻഡോ തുറക്കുന്നതിന് നിങ്ങൾക്ക് അത് \Gtk.WindowPosition.MOUSE ആയി മാറ്റാം.
9. button1 = Gtk.Button(“ഹലോ, വേൾഡ്!”): ഞങ്ങൾ ഒരു പുതിയ Gtk.Button സൃഷ്uടിച്ചു, ഞങ്ങൾ അതിനെ \button1 എന്ന് വിളിച്ചു, ബട്ടണിന്റെ സ്ഥിരസ്ഥിതി ടെക്uസ്uറ്റ്\ആണ് ഹലോ, വേൾഡ്!”, നിങ്ങൾക്ക് വേണമെങ്കിൽ ഏത് Gtk വിജറ്റും സൃഷ്ടിക്കാം.
10. button1.connect(“clicked”, self.whenbutton1_clicked): ഇവിടെ ഞങ്ങൾ \clicked സിഗ്നലിനെ \whenbutton1_clicked പ്രവർത്തനവുമായി ലിങ്ക് ചെയ്യുന്നു, അങ്ങനെ ബട്ടൺ ക്ലിക്ക് ചെയ്യുമ്പോൾ, \whenbutton1_clicked പ്രവർത്തനം സജീവമാക്കി.
11. self.add(button1): നമ്മുടെ Gtk വിജറ്റുകൾ ദൃശ്യമാകണമെങ്കിൽ, അവ സ്ഥിരസ്ഥിതി വിൻഡോയിലേക്ക് ചേർക്കണം, ഈ ലളിതമായ വരി \button1 വിജറ്റ് വിൻഡോയിലേക്ക് ചേർക്കുന്നു, ഇത് ചെയ്യേണ്ടത് വളരെ അത്യാവശ്യമാണ്.
12. def whenbutton1_clicked(self, button): ഇപ്പോൾ ഞങ്ങൾ ഇവിടെ \whenbutton1_clicked പ്രവർത്തനം നിർവചിക്കുന്നു, \button1 വിജറ്റ് ക്ലിക്ക് ചെയ്യുമ്പോൾ എന്താണ് സംഭവിക്കാൻ പോകുന്നതെന്ന് ഞങ്ങൾ നിർവചിക്കുന്നു, \(സ്വയം, ബട്ടൺ)” പാരാമീറ്റർ സിഗ്നൽ പാരന്റ് ഒബ്ജക്റ്റ് തരം വ്യക്തമാക്കുന്നതിന് പ്രധാനമാണ്.
13. “ഹലോ, വേൾഡ്!”: ഞാൻ ഇവിടെ കൂടുതൽ വിശദീകരിക്കേണ്ടതില്ല.
14. window = ourwindow(): നമ്മൾ ഒരു പുതിയ ഗ്ലോബൽ വേരിയബിൾ സൃഷ്uടിച്ച് അതിനെ ourwindow() ക്ലാസ്സിലേക്ക് സജ്ജീകരിക്കേണ്ടതുണ്ട്, അതുവഴി GTK+ ലൈബ്രറി ഉപയോഗിച്ച് നമുക്ക് അതിനെ പിന്നീട് വിളിക്കാം.
15. window.connect(“delete-event”, Gtk.main_quit): ഇപ്പോൾ ഞങ്ങൾ \delete-event സിഗ്നലിനെ \Gtk.main_quit പ്രവർത്തനവുമായി ബന്ധിപ്പിക്കുകയാണ്, ഇതാണ് ഞങ്ങളുടെ പ്രോഗ്രാം വിൻഡോ സ്വയമേവ അടച്ചതിനുശേഷം എല്ലാ വിജറ്റുകളും ഇല്ലാതാക്കുന്നതിന് പ്രധാനമാണ്.
16. window.show_all(): വിൻഡോ കാണിക്കുന്നു.
17. Gtk.main(): Gtk ലൈബ്രറി പ്രവർത്തിപ്പിക്കുന്നു.

അത്രയേയുള്ളൂ, എളുപ്പമല്ലേ? ചില വലിയ ആപ്ലിക്കേഷനുകൾ സൃഷ്ടിക്കാൻ ഞങ്ങൾ ആഗ്രഹിക്കുന്നുവെങ്കിൽ വളരെ പ്രവർത്തനക്ഷമവുമാണ്. കോഡ്-മാത്രം വഴി ഉപയോഗിച്ച് GTK+ ഇന്റർഫേസുകൾ സൃഷ്ടിക്കുന്നതിനെക്കുറിച്ചുള്ള കൂടുതൽ വിവരങ്ങൾക്ക്, നിങ്ങൾക്ക് ഔദ്യോഗിക ഡോക്യുമെന്റേഷൻ വെബ്സൈറ്റ് ഇവിടെ സന്ദർശിക്കാവുന്നതാണ്:

പൈത്തൺ GTK3 ട്യൂട്ടോറിയലുകൾ

ലേഖനത്തിന്റെ തുടക്കത്തിൽ ഞാൻ പറഞ്ഞതുപോലെ, ഞങ്ങളുടെ പ്രോഗ്രാമുകൾക്ക് ആവശ്യമായ ഇന്റർഫേസുകൾ സൃഷ്ടിക്കുന്നതിനുള്ള വളരെ എളുപ്പമുള്ള ഉപകരണമാണ് ഗ്ലേഡ്, ഇത് ഡവലപ്പർമാർക്കിടയിൽ വളരെ പ്രസിദ്ധമാണ്, കൂടാതെ നിരവധി മികച്ച ആപ്ലിക്കേഷൻ ഇന്റർഫേസുകൾ ഇത് ഉപയോഗിച്ച് സൃഷ്ടിച്ചു. ഈ രീതിയെ \ദ്രുത ആപ്ലിക്കേഷൻ വികസനം എന്ന് വിളിക്കുന്നു.

ഡെബിയൻ/ഉബുണ്ടു/മിന്റ് റണ്ണിൽ, ഗ്ലേഡ് ഉപയോഗിക്കാൻ തുടങ്ങുന്നതിന് നിങ്ങൾ ഇൻസ്റ്റാൾ ചെയ്യണം:

$ sudo apt­-get install glade

RedHat/Fedora/CentOS-ൽ, പ്രവർത്തിപ്പിക്കുക:

# yum install glade

നിങ്ങൾ പ്രോഗ്രാം ഡൌൺലോഡ് ചെയ്ത് ഇൻസ്റ്റാൾ ചെയ്ത ശേഷം, അത് പ്രവർത്തിപ്പിച്ചതിന് ശേഷം, ഇടതുവശത്ത് ലഭ്യമായ Gtk വിഡ്ജറ്റുകൾ നിങ്ങൾ കാണും, ഒരു പുതിയ വിൻഡോ സൃഷ്ടിക്കുന്നതിന് \വിൻഡോ വിജറ്റിൽ ക്ലിക്കുചെയ്യുക.

ഒരു പുതിയ ശൂന്യ വിൻഡോ സൃഷ്ടിക്കുന്നത് നിങ്ങൾ ശ്രദ്ധിക്കും.

നിങ്ങൾക്ക് ഇപ്പോൾ അതിലേക്ക് ചില വിജറ്റുകൾ ചേർക്കാം, ഇടത് ടൂൾബാറിൽ, \ബട്ടൺ വിജറ്റിൽ ക്ലിക്ക് ചെയ്യുക, തുടർന്ന് വിൻഡോയിലേക്ക് ബട്ടൺ ചേർക്കുന്നതിന് ശൂന്യമായ വിൻഡോയിൽ ക്ലിക്ക് ചെയ്യുക.

ബട്ടൺ ഐഡി \button1 ആണെന്ന് നിങ്ങൾ ശ്രദ്ധിക്കും, ഇപ്പോൾ വലത് ടൂൾബാറിലെ സിഗ്നലുകൾ ടാബിലേക്ക് പോയി \ക്ലിക്ക് ചെയ്ത സിഗ്നലിനായി തിരഞ്ഞ്\നൽകുക. അതിനടിയിൽ button1_clicked.

ഇപ്പോൾ ഞങ്ങൾ ഞങ്ങളുടെ GUI സൃഷ്ടിച്ചു, നമുക്ക് അത് കയറ്റുമതി ചെയ്യാം. \ഫയൽ” മെനുവിൽ ക്ലിക്ക് ചെയ്ത് \സംരക്ഷിക്കുക തിരഞ്ഞെടുക്കുക, \myprogram.glade എന്ന പേരിൽ ഫയൽ നിങ്ങളുടെ ഹോം ഡയറക്ടറിയിൽ സംരക്ഷിക്കുക. >” എന്നിട്ട് പുറത്തുകടക്കുക.

ഇപ്പോൾ, ഒരു പുതിയ \test.py ഫയൽ സൃഷ്ടിക്കുക, അതിനുള്ളിൽ ഇനിപ്പറയുന്ന കോഡ് നൽകുക.

#!/usr/bin/python
# -*- coding: utf-8 -*-

from gi.repository import Gtk

class Handler:
    def button_1clicked(self, button):
      print "Hello, World!"

builder = Gtk.Builder()
builder.add_from_file("myprogram.glade")
builder.connect_signals(Handler())

ournewbutton = builder.get_object("button1")
ournewbutton.set_label("Hello, World!")

window = builder.get_object("window1")

window.connect("delete-event", Gtk.main_quit)
window.show_all()
Gtk.main()

ഫയൽ സംരക്ഷിക്കുക, അതിന് മുമ്പത്തെപ്പോലെ 755 അനുമതികൾ നൽകുക, \./test.py ഉപയോഗിച്ച് പ്രവർത്തിപ്പിക്കുക, അതാണ് നിങ്ങൾക്ക് ലഭിക്കുക.

# nano test.py
# chmod 755 test.py
# ./test.py

ബട്ടണിൽ ക്ലിക്ക് ചെയ്യുക, \ഹലോ, വേൾഡ്! എന്ന വാചകം ടെർമിനലിൽ അച്ചടിച്ചിരിക്കുന്നത് നിങ്ങൾ ശ്രദ്ധിക്കും.

ഇനി നമുക്ക് പുതിയ കാര്യങ്ങൾ വിശദീകരിക്കാം:

1. ക്ലാസ് ഹാൻഡ്uലർ: GUI-യ്uക്കായി ഞങ്ങൾ സൃഷ്uടിക്കുന്ന പ്രവർത്തനങ്ങളുടെയും സിഗ്നലുകളുടെയും നിർവചനങ്ങൾ ഉൾക്കൊള്ളുന്ന \ഹാൻഡ്uലർ എന്ന ഒരു ക്ലാസ് ഞങ്ങൾ ഇവിടെ സൃഷ്uടിക്കുന്നു.
2. builder = Gtk.Builder(): ഞങ്ങൾ \builder എന്ന പേരിൽ ഒരു പുതിയ ആഗോള വേരിയബിൾ സൃഷ്ടിച്ചു, അത് Gtk.Builder വിജറ്റ് ആണ്, .glade ഫയൽ ഇറക്കുമതി ചെയ്യുന്നതിന് ഇത് പ്രധാനമാണ്.< /ലി>
3. builder.add_from_file(“myprogram.glade”): ഞങ്ങളുടെ പ്രോഗ്രാമിന്റെ സ്ഥിരസ്ഥിതി GUI ആയി ഉപയോഗിക്കുന്നതിന് ഞങ്ങൾ \myprogram.glade ഫയൽ ഇവിടെ ഇറക്കുമതി ചെയ്യുന്നു.
4. builder.connect_signals(Handler()): ഈ ലൈൻ .glade ഫയലിനെ ഹാൻഡ്uലർ ക്ലാസുമായി ബന്ധിപ്പിക്കുന്നു, അതുവഴി \ഹാൻഡ്uലർ ക്ലാസിന് കീഴിൽ ഞങ്ങൾ നിർവചിക്കുന്ന പ്രവർത്തനങ്ങളും സിഗ്നലുകളും നന്നായി പ്രവർത്തിക്കുമ്പോൾ ഞങ്ങൾ പ്രോഗ്രാം പ്രവർത്തിപ്പിക്കുന്നു.
5. ournewbutton = builder.get_object(“button1”): ഇപ്പോൾ ഞങ്ങൾ .glade ഫയലിൽ നിന്ന് \button1 ഒബ്uജക്റ്റ് ഇറക്കുമതി ചെയ്യുന്നു, ഞങ്ങൾ അത് ആഗോള വേരിയബിളിലേക്കും\കൈമാറുകയാണ്. ഞങ്ങളുടെ പ്രോഗ്രാമിൽ പിന്നീട് ഉപയോഗിക്കുന്നതിന് ournewbutton.
6. ournewbutton.set_label(“ഹലോ, വേൾഡ്!”): സ്ഥിരസ്ഥിതി ബട്ടൺ ടെക്uസ്uറ്റ് \ഹലോ, വേൾഡ്! എന്നതിലേക്ക് സജ്ജീകരിക്കാൻ ഞങ്ങൾ \set.label രീതി ഉപയോഗിച്ചു. വാചകം.
7. window = builder.get_object(“window1”): ഇവിടെ ഞങ്ങൾ \window1 ഒബ്uജക്റ്റ് പ്രോഗ്രാമിൽ പിന്നീട് കാണിക്കുന്നതിനായി .glade ഫയലിൽ നിന്ന് വിളിച്ചു.

അത്രമാത്രം! Linux-ന് കീഴിൽ നിങ്ങളുടെ ആദ്യ പ്രോഗ്രാം നിങ്ങൾ വിജയകരമായി സൃഷ്ടിച്ചു!

തീർച്ചയായും എന്തെങ്കിലും ചെയ്യുന്ന ഒരു യഥാർത്ഥ ആപ്ലിക്കേഷൻ സൃഷ്uടിക്കുന്നതിന് കൂടുതൽ സങ്കീർണ്ണമായ കാര്യങ്ങൾ ചെയ്യാനുണ്ട്, അതിനാലാണ് GTK+ ഡോക്യുമെന്റേഷനും GObject API-യും പരിശോധിക്കാൻ ഞാൻ നിങ്ങളോട് ശുപാർശ ചെയ്യുന്നത്:

1. GTK+ റഫറൻസ് മാനുവൽ
2. Python GObject API റഫറൻസ്
3. PyGObject റഫറൻസ്

ലിനക്സ് ഡെസ്ക്ടോപ്പിന് കീഴിൽ നിങ്ങൾ മുമ്പ് ഏതെങ്കിലും ആപ്ലിക്കേഷൻ വികസിപ്പിച്ചിട്ടുണ്ടോ? ഏത് പ്രോഗ്രാമിംഗ് ഭാഷയും ഉപകരണങ്ങളും ഇത് ചെയ്യാൻ ഉപയോഗിച്ചു? Python & GTK 3 ഉപയോഗിച്ച് ആപ്ലിക്കേഷനുകൾ സൃഷ്ടിക്കുന്നതിനെക്കുറിച്ച് നിങ്ങൾ എന്താണ് ചിന്തിക്കുന്നത്?