Jest coś takiego dla pythona,jak dla pascala, delphi borlanda ?
chodzi o dodawanie graficznej warstwy typu buttony itp.
Jest wiele bibliotek do tworzenia interfejsu graficznego, jak np. Qt, GTK+, Tk czy wxWidgets
→ http://www.riverbankcomputing.co.uk/software/pyqt/intro
No wiem,ale nie o to mi chodzi,Delphi borlanda działa na zasadzie kliknij,przenieś,kliknij
w delphi borlanda sie po prostu przeciąga elementy typu buttony na plansze okna.
I moje pytanie odnośi się czy jest jakaś alternatywa tego dla pythona
Do takiego “klikanego” tworzenia GUI to kojarzę QtDesigner dla Qt i Glade dla GTK+. Pliki tworzone w Glade są uniwersalne i można używać w wielu językach mających dowiązania do GTK+. Co do Qt to nie jestem do końca pewien, ale też się chyba da.
Dzięki,o to mi właśnie chodziło.
Mam dla Ciebie prosty przykład, napisałem go kiedyś na potrzeby testów GTK+C:
#!/usr/bin/env python
#-*- coding: utf-8 -*-
import gtk
def gdy_zamykamy_program(widget, data=None):
print("Program zakończono kliknięciem w przycisk na belce okna!")
gtk.main_quit()
def gdy_klikamy(widget, data=None):
print("Klik i program zakończono!")
gtk.main_quit()
window=gtk.Window()
window.set_default_size(200, 75)
window.set_border_width(10)
window.set_title("Klikamy!")
gtk.window_set_default_icon_name(gtk.STOCK_DIALOG_INFO)
window.connect("destroy", gdy_zamykamy_program, None)
przycisk_w_oknie=gtk.Button("Kliknięcie w button\nkończy pracę programu")
przycisk_w_oknie.connect("clicked", gdy_klikamy, None)
window.add(przycisk_w_oknie)
window.show_all()
gtk.main()
-
zapisz jako plik z rozszerzeniem “py” i nadaj mu prawa do uruchomienia jako program. Program otwiera okno + 1 button. Kliknięcie w button kończy pracę programu. Chcąc podejrzeć komunikaty, uruchom program w terminalu:
python twoja_nazwa.py
uruchomiłem,a kod nie wygląda tak drętwo…
Nie taki diabeł straszny jak go malują 
Ale nie wiem co tu dotyczy rozmiaru buttona…
Przycisk sam rozszerza się wraz z rodzicem (tu - głównym oknem programu). Ogólnie dokumentację GTK+ 2 można znaleźć tutaj: http://library.gnome.org/devel/gtk/stable/
Rozmiar buttona “został nieokreślony”, więc program dobiera go w sposób automatyczny
Określiłem tylko domyślne wymiary okna:
window.set_default_size(200, 75)
oraz szerokość wewnętrznych “marginesów”, które będą niezmienne, jednak widget (tu: button) może zmieniać rozmiar:
window.set_border_width(10)
Dlaczego tak jest? Utworzyłem okno, a okno może przechować tylko 1 “widget”. Widgetem jest tu nasz “button”. Chcąc upchnąć w oknie więcej widgetów, wykorzystajmy coś, co może je wewnątrz siebie przechować. Mamy do wyboru np. widget zwany “fixed” - coś jak ramka, tabliczka, na której przypinasz widgety. Mamy do wyboru pionowe “pudełko na widgety” zwane vbox (od vertical box). Mamy do wyboru poziome “pudełko na widgety” zwane hbox (od horizontal box). Coś się tam pewnie jeszcze znajdzie (?) Zmodyfikowałem nieco wcześniejszy kod, postarałem się, by był też czytelniejszy. Program wciąż robi to samo -> kliknięcie w button lub zamykający okno przycisk spowoduje zakończenie programu i wyświetlenie stosownego komunikatu. Możesz użyć wywołania systemowego, które przy każdym kliknięciu w button uruchomi np. notatnik. Chcąc podejrzeć komunikaty, uruchamiaj program w terminalu, komendą:
python twoja_nazwa.py
Komunikaty wstawiłem po to, by pokazać, że jest to możliwe. W nowym programie wykorzystam ramkę “fixed”. Określiłem rozmiar buttonu (celowo pozostawiłem ten sam napis). Określiłem umiejscowienie buttonu w ramce “fixed”. Przy ramce “fixed”, położenie każdego widgetu ustawiasz z osobna. Odległość widgetu od lewej i od górnej krawędzi okna ustawiasz w pixelach. Postaraj się nie najechać jednym widgetem na drugi, bo będzie to dziwnie wyglądać, lub niżej położony widget stanie się dla klikającego nieosiągalny. Zmień rozmiar i rozmieszczenie. Szybko wyłapiesz o co w tym chodzi. Oto nowy program:
#!/usr/bin/env python
#-*- coding: utf-8 -*-
import gtk
def gdy_zamykamy_program(widget, data=None):
print("Program zakończono kliknięciem w przycisk na belce okna!")
gtk.main_quit()
def gdy_klikamy(widget, data=None):
print("Klik i program zakończono!")
gtk.main_quit()
window=gtk.Window()
window.set_title("Klikamy!")
window.set_default_size(200, 75)
window.set_border_width(20)
gtk.window_set_default_icon_name(gtk.STOCK_DIALOG_INFO)
window.connect("destroy", gdy_zamykamy_program, None)
fixed = gtk.Fixed()
przycisk_w_oknie = gtk.Button("Kliknięcie w button\nkończy pracę")
przycisk_w_oknie.set_size_request(80, 40)
przycisk_w_oknie.connect("clicked", gdy_klikamy, None)
fixed.put(przycisk_w_oknie, 10, 10)
window.add(fixed)
window.show_all()
gtk.main()
Teraz, przeglądając kod widać wyraźnie gdzie program ma swój początek:
#!/usr/bin/env python
* co należy wpisać, by móc korzystać z “ogonków”:
#-*- coding: utf-8 -*-
* jakie biblioteki maja zostać w programie użyte:
import gtk
* definiujesz działania, każdemu z nich nadajesz nazwę:
def gdy_zamykamy_program(widget, data=None):
print("Program zakończono kliknięciem w przycisk na belce okna!")
gtk.main_quit()
def gdy_klikamy(widget, data=None):
print("Klik i program zakończono!")
gtk.main_quit()
W 2 powyższych ustawiłem zakończenie programu, o którym nigdy nie wolno nam zapomnieć (przy zamykaniu okna). * tworzymy okno:
window=gtk.Window()
* ustawiamy właściwości okna -> tytuł, domyślny rozmiar (pixele), “wewnętrzne marginesy”, ikonkę na pasku itp.:
window.set_title("Klikamy!")
window.set_default_size(200, 75)
window.set_border_width(20)
gtk.window_set_default_icon_name(gtk.STOCK_DIALOG_INFO)
* łączymy sygnał kliknięcia - “unicestwienia okna” z jedną z powyższych definicji działania:
window.connect("destroy", gdy_zamykamy_program, None)
Można to zrobić na końcu programu, polecam łączyć sygnały z działaniami bezpośrednio pod każdym nowym widgetem, dzięki temu przy szukaniu błędów wzrok się nam nie rozjedzie * ramkę “fixed” wstawiamy w okno:
fixed = gtk.Fixed()
* tworzymy “button” z chwytliwą nazwą, co ułatwi nam wpięcie się pod predefiniowaną akcję dla wygenerowanego przez button sygnału:
przycisk_w_oknie = gtk.Button("Kliknięcie w button\nkończy pracę")
* określamy właściwości buttonu (lub innego widgetu), tutaj - rozmiar (pixele):
przycisk_w_oknie.set_size_request(80, 40)
* łączymy wygenerowany przez button sygnał z predefiniowaną na początku akcją:
przycisk_w_oknie.connect("clicked", gdy_klikamy, None)
* ładujemy nasz “button” w ramkę “fixed”, określając jego położenie w ramce (odległości znów w pikselach):
fixed.put(przycisk_w_oknie, 10, 10)
Mamy więc przechowującą widgety ramkę - typ: “fixed”. Mamy "widget, typ: “button”. Wszystko już ustawiliśmy, załadowaliśmy button (widget) w ramkę, załadujmy więc ramkę (fixed) w utworzone wcześniej okno:
window.add(fixed)
* nakazujemy programowi wyświetlić zawartość okna, a więc ramkę i to, co w niej umieściliśmy:
window.show_all()
* kończymy nasz program standardowym:
gtk.main()
------------------------------ Na koniec wersja z 2 buttonami. Pozwala na uruchamianie zewnętrznych programów: (tutaj: edytor tekstu “Gedit”) “Wewnętrzny margines” możemy wyłączyć:
# window.set_border_width(20)
Kod:
#!/usr/bin/env python
#-*- coding: utf-8 -*-
import gtk
import subprocess as sub
def gdy_zamykamy_program(widget, data=None):
print("Program zakończono kliknięciem w przycisk na belce okna!")
gtk.main_quit()
def gdy_klikamy(widget, data=None):
print("Klik i program zakończono!")
gtk.main_quit()
def gdy_klikamy_gedit_button(widget, data=None):
sub.Popen("/usr/bin/gedit")
print("Gedit uruchomiony!")
window=gtk.Window()
window.set_title("Klikamy!")
window.set_default_size(300, 175)
# window.set_border_width(20)
gtk.window_set_default_icon_name(gtk.STOCK_DIALOG_INFO)
window.connect("destroy", gdy_zamykamy_program, None)
fixed = gtk.Fixed()
przycisk_w_oknie = gtk.Button("Kliknięcie w button\nkończy pracę")
przycisk_w_oknie.set_size_request(250, 60)
przycisk_w_oknie.connect("clicked", gdy_klikamy, None)
fixed.put(przycisk_w_oknie, 10, 10)
gedit_button = gtk.Button("Uruchom Gedit")
gedit_button.set_size_request(120, 40)
gedit_button.connect("clicked", gdy_klikamy_gedit_button, None)
fixed.put(gedit_button, 100, 100)
window.add(fixed)
window.show_all()
gtk.main()
Powyższy mini-tutorial publikuję na warunkach licencji:
http://creativecommons.org/licenses/by-sa/2.5/pl/
Link: http://forum.dobreprogramy.pl/czy-jest-srodowisko-graficzne-pythona-t439456.html#p2787767
Polecam świetne wprowadzenie do PyGTK (autor: Jan Bodnar):
http://zetcode.com/tutorials/pygtktutorial/
… dla pozostałych “oknotworów” także:
Polecam również forum:
…aktualnie mają z czymś… problem (?)
no to się rozpisałeś…
Dopiero teraz zauważyłem ten post i przeczytałem,bardzo dziękuje za wyjaśnienie.
(Ty prawie kurs tworzenia okien dla początkujących napisałeś