ວິທີການສ້າງໂປແກຼມ GUI ພາຍໃຕ້ Linux Desktop ໂດຍໃຊ້ PyGObject - ພາກທີ 1


ການສ້າງໂປແກຼມໃນ Linux ສາມາດເຮັດໄດ້ໂດຍໃຊ້ວິທີທີ່ແຕກຕ່າງກັນ, ແຕ່ວ່າມີວິທີການ ຈຳ ກັດ, ສະນັ້ນການໃຊ້ພາສາແລະຫໍສະ ໝຸດ ທີ່ງ່າຍດາຍແລະມີປະສິດຕິພາບສູງທີ່ສຸດ, ນັ້ນແມ່ນເຫດຜົນທີ່ພວກເຮົາຈະຕ້ອງໄດ້ເບິ່ງໄວໆໃນການສ້າງໂປແກຼມຕ່າງໆພາຍໃຕ້ Linux desktop ໂດຍໃຊ້ຫ້ອງສະຫມຸດ GTK + ດ້ວຍພາສາການຂຽນໂປແກມ Python ເຊິ່ງເອີ້ນວ່າ "PyGObject".

PyGObject ໃຊ້ GObject Introspection ເພື່ອສ້າງການຜູກມັດ ສຳ ລັບພາສາການຂຽນໂປແກຼມເຊັ່ນ Python, PyGObject ແມ່ນຄົນຮຸ່ນຫລັງຈາກ PyGTK, ທ່ານສາມາດເວົ້າໄດ້ວ່າ PyGObject = Python + GTK3.

ມື້ນີ້, ພວກເຮົາຈະເລີ່ມຕົ້ນຊຸດກ່ຽວກັບການສ້າງໂປແກຼມ GUI (Graphical User Interface) ພາຍໃຕ້ Linux desktop ໂດຍໃຊ້ຫ້ອງສະຫມຸດ GTK + ແລະ PyGobject , ຊຸດຈະມີຫົວຂໍ້ຕໍ່ໄປນີ້:

ກ່ອນອື່ນ ໝົດ, ທ່ານຕ້ອງມີຄວາມຮູ້ພື້ນຖານບາງຢ່າງໃນ Python; Python ແມ່ນພາສາການຂຽນໂປແກຼມທີ່ທັນສະ ໄໝ ແລະງ່າຍດາຍ. ມັນແມ່ນ ໜຶ່ງ ໃນພາສາການຂຽນໂປແກຼມທີ່ມີຊື່ສຽງທີ່ສຸດໃນໂລກ, ໂດຍໃຊ້ Python, ທ່ານຈະສາມາດສ້າງໂປແກຼມໂປຼແກຼມແລະເຄື່ອງມືທີ່ດີຫຼາຍຢ່າງ. ທ່ານອາດຈະຮຽນຫຼັກສູດຟຣີເຊັ່ນວ່າຢູ່ທີ່ codeacademy.com ຫຼືທ່ານອາດຈະອ່ານປື້ມບາງຢ່າງກ່ຽວກັບ Python ທີ່:

GTK + ແມ່ນຊຸດຂໍ້ມູນແບບເປີດ - ແຫຼ່ງເພື່ອສ້າງອິນເຕີເຟດຜູ້ໃຊ້ແບບກາຟິກ ສຳ ລັບການ ນຳ ໃຊ້ desktop, ມັນໄດ້ເລີ່ມຕົ້ນໃນປີ 1998 ເປັນຊຸດເຄື່ອງມື GUI ສຳ ລັບ GIMP, ຕໍ່ມາ, ມັນຖືກ ນຳ ໃຊ້ໃນຫລາຍໂປແກຼມອື່ນແລະ ບໍ່ດົນກໍ່ກາຍເປັນ ໜຶ່ງ ໃນບັນດາຫໍສະມຸດທີ່ມີຊື່ສຽງທີ່ສຸດໃນການສ້າງ GUIs. GTK + ຖືກປ່ອຍພາຍໃຕ້ໃບອະນຸຍາດ LGPL.

ການສ້າງໂປແກຼມ GUI ພາຍໃຕ້ Linux

ມີ 2 ວິທີໃນການສ້າງໂປແກຼມໃຊ້ໂດຍໃຊ້ GTK + & Python:

<

  • ຂຽນການໂຕ້ຕອບກາຟິກໂດຍໃຊ້ລະຫັດເທົ່ານັ້ນ.
  • ການອອກແບບອິນເຕີເຟດກຣາຟິກໂດຍໃຊ້ໂປແກມ“ Glade ”; ເຊິ່ງແມ່ນເຄື່ອງມື RAD ໃນການອອກແບບ GTK + ອິນເຕີເຟດໄດ້ງ່າຍ, Glade ສ້າງ GUI ເປັນເອກະສານ XML ເຊິ່ງສາມາດໃຊ້ກັບພາສາການຂຽນໂປແກຼມໃດ ໜຶ່ງ ເພື່ອສ້າງ GUI, ຫຼັງຈາກທີ່ສົ່ງອອກເອກະສານ XML ຂອງ GUI, ພວກເຮົາຈະສາມາດເຊື່ອມໂຍງເອກະສານ XML ກັບພວກເຮົາ ໂຄງການເຮັດວຽກທີ່ພວກເຮົາຕ້ອງການ.
  • ພວກເຮົາຈະອະທິບາຍທັງສອງວິທີໂດຍຫຍໍ້.

    ການຂຽນ GUI ໂດຍໃຊ້ລະຫັດພຽງແຕ່ສາມາດເຮັດໄດ້ຍາກ ສຳ ລັບນັກຂຽນໂປແກຼມ noob ແລະເວລາເສຍເວລາຫຼາຍ, ແຕ່ການໃຊ້ມັນ, ພວກເຮົາສາມາດສ້າງ GUI ທີ່ມີປະໂຫຍດຫຼາຍ ສຳ ລັບໂປແກຼມຂອງພວກເຮົາ, ຫຼາຍກວ່າສິ່ງທີ່ພວກເຮົາສ້າງໂດຍໃຊ້ບາງເຄື່ອງມືເຊັ່ນ: Glade.

    ຂໍໃຫ້ຍົກຕົວຢ່າງຕໍ່ໄປນີ້.

    #!/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 ” ແລະ ກຳ ນົດການອະນຸຍາດ 755 ໃສ່ແຟ້ມ test.py ແລະແລ່ນເອກະສານຕໍ່ມາໂດຍໃຊ້“ ./test.py”, ນັ້ນແມ່ນສິ່ງທີ່ທ່ານຈະໄດ້ຮັບ.

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

    ໂດຍການກົດປຸ່ມ, ທ່ານຈະເຫັນປະໂຫຍກ“ ສະບາຍດີ, ໂລກ! ” ທີ່ພິມອອກຢູ່ປາຍ:

    ຂ້າພະເຈົ້າຂໍອະທິບາຍລະຫັດໃນ ຄຳ ອະທິບາຍລະອຽດ.

    <

  • #!/usr/bin/python : ເສັ້ນທາງເລີ່ມຕົ້ນ ສຳ ລັບນາຍແປພາສາ Python (ຮຸ່ນ 2.7 ໃນກໍລະນີຫຼາຍທີ່ສຸດ), ສາຍນີ້ຕ້ອງເປັນເສັ້ນ ທຳ ອິດໃນທຸກໆເອກະສານ Python.
  • # - * - ລະຫັດ: utf-8 - * - ທີ່ນີ້ພວກເຮົາ ກຳ ນົດຄ່າລະຫັດ ສຳ ລັບແຟ້ມ, UTF-8 ແມ່ນດີທີ່ສຸດຖ້າທ່ານຕ້ອງການສະ ໜັບ ສະ ໜູນ ພາສາທີ່ບໍ່ແມ່ນພາສາອັງກິດ, ອອກຈາກ ມັນຄືແນວນັ້ນ.
  • ຈາກການ ນຳ ເຂົ້າ gtk ທີ່ຢູ່ນີ້ພວກເຮົາ ກຳ ລັງ ນຳ ເຂົ້າຫ້ອງສະ ໝຸດ GTK 3 ເພື່ອ ນຳ ໃຊ້ມັນໃນໂປແກຼມຂອງພວກເຮົາ.
  • Class ourwindow (Gtk.Window): ໃນທີ່ນີ້ພວກເຮົາ ກຳ ລັງສ້າງຊັ້ນຮຽນ ໃໝ່, ເຊິ່ງເອີ້ນວ່າ "ourwindow", ພວກເຮົາຍັງ ກຳ ນົດປະເພດວັດຖຸປະເພດໃຫ້ເປັນ "Gtk.Window".
  • def __init __ (ຕົວເອງ) : ບໍ່ມີຫຍັງ ໃໝ່, ພວກເຮົາ ກຳ ລັງ ກຳ ນົດສ່ວນປະກອບ ສຳ ຄັນຂອງປ່ອງຢ້ຽມທີ່ນີ້.
  • Gtk.Window .__ init __ (ຕົວເອງ, ຫົວຂໍ້ = "My World World Program") : ພວກເຮົາ ກຳ ລັງໃຊ້ເສັ້ນນີ້ເພື່ອ ກຳ ນົດຫົວຂໍ້ "My World World Program" ລົງໃນປ່ອງຢ້ຽມ "ourwindow", ທ່ານອາດຈະປ່ຽນຫົວຂໍ້ຖ້າທ່ານຕ້ອງການ.
  • Gtk.Window.set_default_size (ຕົວເອງ, 400,325) : ຂ້ອຍບໍ່ຄິດວ່າເສັ້ນນີ້ຕ້ອງການ ຄຳ ອະທິບາຍ, ໃນທີ່ນີ້ພວກເຮົາ ກຳ ນົດຄວາມກວ້າງແລະຄວາມສູງ ສຳ ລັບປ່ອງຢ້ຽມຂອງພວກເຮົາ.
  • Gtk.Window.set_position (ຕົວເອງ, Gtk.WindowPosition.CENTER) : ໂດຍໃຊ້ເສັ້ນນີ້, ພວກເຮົາຈະສາມາດ ກຳ ນົດ ຕຳ ແໜ່ງ ເລີ່ມຕົ້ນ ສຳ ລັບ ໜ້າ ຕ່າງ, ໃນກໍລະນີນີ້, ພວກເຮົາ ກຳ ນົດມັນ ເຖິງສູນໂດຍໃຊ້ພາລາມິເຕີ "Gtk.WindowPosition.CENTER", ຖ້າທ່ານຕ້ອງການ, ທ່ານສາມາດປ່ຽນມັນໄປທີ່ "Gtk.WindowPosition.MOUSE" ເພື່ອເປີດ ໜ້າ ຕ່າງໃນ ຕຳ ແໜ່ງ ຕົວຊີ້ເມົາ.
  • button1 = Gtk.Button (“ ສະບາຍດີ, ໂລກ!”) : ພວກເຮົາໄດ້ສ້າງ Gtk.Button ໃໝ່, ແລະພວກເຮົາເອີ້ນມັນວ່າ "ປຸ່ມ 1", ຂໍ້ຄວາມເລີ່ມຕົ້ນຂອງປຸ່ມແມ່ນ "ສະບາຍດີ, ໂລກ!”, ທ່ານອາດຈະສ້າງ Gtk widget ຖ້າທ່ານຕ້ອງການ.
  • button1.connect (“ clicked”, self.whenbutton1_clicked) : ທີ່ນີ້ພວກເຮົາ ກຳ ລັງເຊື່ອມໂຍງສັນຍານທີ່ຖືກ“ ກົດ” ກັບ“ whenbutton1_clicked”, ດັ່ງນັ້ນເມື່ອກົດປຸ່ມ,“ whenbutton1_clicked” ການກະ ທຳ ຈະຖືກເປີດໃຊ້.
  • self.add (button1) : ຖ້າພວກເຮົາຕ້ອງການໃຫ້ບັນດາ Gtk ຂອງພວກເຮົາປາກົດ, ພວກເຮົາຕ້ອງເພີ່ມພວກມັນເຂົ້າໄປໃນ ໜ້າ ຕ່າງແບບ ທຳ ອິດ, ສາຍງ່າຍໆນີ້ຈະເພີ່ມ widget "button1" ໃສ່ ໜ້າ ຕ່າງ, ມັນແມ່ນ ຈຳ ເປັນຫຼາຍໃນການເຮັດສິ່ງນີ້.
  • def whenbutton1_clicked (ຕົວເອງ, ປຸ່ມ) : ດຽວນີ້ພວກເຮົາ ກຳ ນົດການກະ ທຳ ຂອງ "whenbutton1_clicked" ຢູ່ບ່ອນນີ້, ພວກເຮົາ ກຳ ລັງ ກຳ ນົດສິ່ງທີ່ຈະເກີດຂື້ນເມື່ອປຸ່ມ "button1" ຖືກກົດເຂົ້າໄປ, "( ຕົວມັນເອງ, ປຸ່ມ)” ພາລາມິເຕີແມ່ນມີຄວາມ ສຳ ຄັນເພື່ອສະເພາະປະເພດວັດຖຸຂອງເຄື່ອງ ໝາຍ ສັນຍານ.
  • ພິມ“ ສະບາຍດີ, ໂລກ!” : ຂ້ອຍບໍ່ ຈຳ ເປັນຕ້ອງອະທິບາຍເພີ່ມເຕີມຢູ່ບ່ອນນີ້.
  • window = ourwindow() : ພວກເຮົາຕ້ອງສ້າງຕົວແປທົ່ວໂລກ ໃໝ່ ແລະ ກຳ ນົດມັນໄວ້ໃນຊັ້ນຮຽນຂອງພວກເຮົາເພື່ອໃຫ້ພວກເຮົາສາມາດໂທຫາມັນໄດ້ໃນພາຍຫລັງໂດຍໃຊ້ຫ້ອງສະຫມຸດ GTK +.
  • window.connect (“ ລຶບເຫດການ”, Gtk.main_quit) : ດຽວນີ້ພວກເຮົາ ກຳ ລັງເຊື່ອມຕໍ່ສັນຍານ“ ລົບລ້າງເຫດການ” ກັບການກະ ທຳ“ Gtk.main_quit”, ນີ້ແມ່ນສິ່ງ ສຳ ຄັນໃນ ສັ່ງໃຫ້ລຶບທຸກໆ widget ຫຼັງຈາກທີ່ພວກເຮົາປິດໂປຣແກຣມ window ຂອງພວກເຮົາໂດຍອັດຕະໂນມັດ.
  • window.show_all() : ການສະແດງ ໜ້າ ຕ່າງ.
  • Gtk.main() : ແລ່ນຫໍສະມຸດ Gtk.
  • ມັນງ່າຍ, ບໍ່ແມ່ນບໍ? ແລະມີປະໂຫຍດຫຼາຍຖ້າພວກເຮົາຕ້ອງການສ້າງໂປແກຼມໃຫຍ່ໆບາງຢ່າງ. ສຳ ລັບຂໍ້ມູນເພີ່ມເຕີມກ່ຽວກັບການສ້າງອິນເຕີເຟດ GTK + ໂດຍໃຊ້ວິທີການລະຫັດເທົ່ານັ້ນ, ທ່ານສາມາດເຂົ້າເບິ່ງເວບໄຊທ໌ເອກະສານທາງການທີ່:

    ການແນະ ນຳ Python GTK3

    ເຊັ່ນດຽວກັບທີ່ຂ້ອຍໄດ້ກ່າວໃນຕອນຕົ້ນຂອງບົດຂຽນ, Glade ແມ່ນເຄື່ອງມືທີ່ງ່າຍທີ່ສຸດໃນການສ້າງອິນເຕີເຟດທີ່ພວກເຮົາຕ້ອງການ ສຳ ລັບໂປແກຼມຂອງພວກເຮົາ, ມັນມີຊື່ສຽງຫຼາຍໃນບັນດານັກພັດທະນາແລະມີໂປແກຼມອິນເຕີເນັດທີ່ດີຫຼາຍຄົນຖືກສ້າງຂື້ນໂດຍໃຊ້ມັນ. ວິທີນີ້ເອີ້ນວ່າ“ ການພັດທະນາການ ນຳ ໃຊ້ຢ່າງວ່ອງໄວ”.

    ທ່ານຕ້ອງຕິດຕັ້ງ Glade ເພື່ອເລີ່ມຕົ້ນໃຊ້ມັນ, ໃນການ ດຳ ເນີນງານຂອງ Debian/Ubuntu/Mint:

    $ sudo apt­-get install glade
    

    ໃນ RedHat/Fedora/CentOS, ດຳ ເນີນການ:

    # yum install glade
    

    ຫຼັງຈາກທີ່ທ່ານດາວໂຫລດແລະຕິດຕັ້ງໂປແກຼມ, ແລະຫລັງຈາກທ່ານເຮັດມັນ, ທ່ານຈະເຫັນ Gtk widget ຢູ່ເບື້ອງຊ້າຍ, ໃຫ້ຄລິກໃສ່ " window " widget ເພື່ອສ້າງ ໜ້າ ຕ່າງ ໃໝ່.

    ທ່ານຈະສັງເກດເຫັນວ່າປ່ອງຢ້ຽມຫວ່າງເປົ່າ ໃໝ່ ຖືກສ້າງຂື້ນ.

    ດຽວນີ້ທ່ານສາມາດເພີ່ມ widget ບາງຢ່າງໃສ່ມັນ, ຢູ່ແຖບເຄື່ອງມືເບື້ອງຊ້າຍ, ກົດທີ່ປຸ່ມ " ປຸ່ມ ", ແລະກົດທີ່ ໜ້າ ຈໍຫວ່າງເພື່ອເພີ່ມປຸ່ມໃສ່ ໜ້າ ຕ່າງ.

    ທ່ານຈະສັງເກດເຫັນວ່າປຸ່ມປຸ່ມແມ່ນ " ປຸ່ມ 1 ", ດຽວນີ້ ໝາຍ ເຖິງແຖບສັນຍານຢູ່ແຖບເຄື່ອງມືທີ່ຖືກຕ້ອງ, ແລະຄົ້ນຫາສັນຍານ“ ກົດປຸ່ມ ” ແລະໃສ່“ 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
    

    ກົດເຂົ້າປຸ່ມ, ແລະທ່ານຈະສັງເກດເຫັນວ່າປະໂຫຍກ“ ສະບາຍດີ, ໂລກ! ” ຖືກພິມຢູ່ປາຍທາງ.

    ບັດນີ້ໃຫ້ອະທິບາຍສິ່ງ ໃໝ່ໆ:

    <

  • ຜູ້ຈັດການຫ້ອງ : ໃນທີ່ນີ້ພວກເຮົາ ກຳ ລັງສ້າງຊັ້ນຮຽນທີ່ເອີ້ນວ່າ "Handler" ເຊິ່ງຈະລວມມີ ຄຳ ນິຍາມ ສຳ ລັບການກະ ທຳ ແລະສັນຍານ, ພວກເຮົາສ້າງ ສຳ ລັບ GUI.
  • ຜູ້ສ້າງ = Gtk.Builder() : ພວກເຮົາສ້າງຕົວແປທົ່ວໂລກ ໃໝ່ ທີ່ມີຊື່ວ່າ "ຜູ້ສ້າງ" ເຊິ່ງແມ່ນເຄື່ອງມື Gtk.Builder, ນີ້ແມ່ນສິ່ງ ສຳ ຄັນເພື່ອ ນຳ ເຂົ້າເອກະສານ .glade.
  • ຜູ້ກໍ່ສ້າງ .add_from_file ("myprogram.glade") : ທີ່ນີ້ພວກເຮົາ ກຳ ລັງ ນຳ ເຂົ້າເອກະສານ "myprogram.glade" ເພື່ອໃຊ້ເປັນ GUI ເລີ່ມຕົ້ນ ສຳ ລັບໂປແກຼມຂອງພວກເຮົາ.
  • ຜູ້ກໍ່ສ້າງ .connect_signals (Handler()) : ສາຍນີ້ເຊື່ອມຕໍ່ເອກະສານ .glade ກັບຊັ້ນຈັດການ, ດັ່ງນັ້ນການກະ ທຳ ແລະສັນຍານທີ່ພວກເຮົາ ກຳ ນົດພາຍໃຕ້ "Handler" ເຮັດວຽກໄດ້ດີເມື່ອພວກເຮົາ ດໍາເນີນໂຄງການ.
  • ournewbutton = builder.get_object (“ button1”) : ດຽວນີ້ພວກເຮົາ ກຳ ລັງ ນຳ ເຂົ້າວັດຖຸປຸ່ມ "button1" ຈາກເອກະສານ .glade, ພວກເຮົາ ກຳ ລັງສົ່ງມັນໄປທີ່ຕົວແປທົ່ວໂລກ "ournewbutton" ເພື່ອໃຊ້ໃນພາຍຫຼັງໃນໂປແກມຂອງພວກເຮົາ.
  • ournewbutton.set_label (“ ສະບາຍດີ, ໂລກ!”) : ພວກເຮົາໄດ້ ນຳ ໃຊ້ວິທີການ“ set.label” ເພື່ອ ກຳ ນົດຕົວ ໜັງ ສືປຸ່ມຕັ້ງໄວ້ໃຫ້ ຄຳ ວ່າ“ ສະບາຍດີ, ໂລກ!” ປະໂຫຍກ.
  • window = builder.

    ນັ້ນແມ່ນມັນ! ທ່ານໄດ້ສ້າງໂປແກຼມ ທຳ ອິດຂອງທ່ານພາຍໃຕ້ Linux!

    ແນ່ນອນມັນມີຫຼາຍສິ່ງທີ່ສັບສົນຫຼາຍທີ່ຕ້ອງເຮັດເພື່ອສ້າງໂປແກຼມໃຊ້ຈິງໆທີ່ເຮັດບາງສິ່ງບາງຢ່າງ, ນັ້ນແມ່ນເຫດຜົນທີ່ຂ້ອຍແນະ ນຳ ໃຫ້ເຈົ້າພິຈາລະນາເບິ່ງເອກະສານ GTK + ແລະ GObject API ທີ່:

    <

  • ຄູ່ມືການອ້າງອີງ GTK + ເອກະສານອ້າງອີງ
  • Python GObject API ອ້າງອີງ
  • ເອກະສານອ້າງອີງ PyGObject
  • ທ່ານໄດ້ພັດທະນາໂປແກຼມໃດ ໜຶ່ງ ມາກ່ອນພາຍໃຕ້ ໜ້າ ຈໍ Linux ບໍ? ພາສາແລະເຄື່ອງມືການຂຽນໂປແກຼມໃດທີ່ໃຊ້ເພື່ອເຮັດມັນ? ທ່ານຄິດແນວໃດກ່ຽວກັບການສ້າງໂປແກຼມໂດຍໃຊ້ Python & GTK 3?