4. Pencere Araçlarının Yerleşimi¶
Şimdiye kadar yazdığımız Pygtk uygulamalarında hep ana pencere üzerine tek bir pencere aracı yerleştirdik. Dikkat ettiyseniz hiç bir uygulamamızda aynı anda birden fazla pencere aracı kullanmadık. Çünkü şimdiye kadar öğrendiğimiz bilgiler tek bir pencere üzerine aynı anda birden fazla pencere aracı yerleştirmemize müsaade etmiyordu. Ama artık bu işi nasıl yapacağımızı öğrenmemizin vakti geldi... İşte biz de bu bölümde, Pygtk uygulamalarına nasıl aynı anda birden fazla pencere ekleyebileceğimizi öğreneceğiz.
Bu dediğimiz işlemi gerçekleştirebilmek için, Pygtk bize birkaç farklı seçenek sunuyor. Bu bölümde bize sunulan bu yöntemleri tek tek incelemeye çalışacağız.
4.1. Fixed() Haznesi¶
Yukarıdaki “giriş” bölümünde bahsettiğimiz gibi, Pygtk’de pencere araçlarını yerleştirmek için elimizde birkaç farklı seçenek vardır. Fixed() haznesini kullanmak da bu seçenekler biridir. Öncelikle “hazne”nin ne demek olduğunu anlamaya çalışalım... Programlama dillerinde “hazne”; “başka nesneleri içinde barındıran bir araç” olarak tarif edilebilir. “Hazne” kelimesinin İngilizce’deki karşılığı “container”...
Bu bölümde göreceğimiz “Fixed()” adlı araç da bir haznedir. Fixed() adlı bu hazne, Pytgtk ile oluşturacağımız pencere araçlarını içinde barındırma vazifesi görür. İsterseniz hemen bunun nasıl kullanılacağına ilişkin bir örnek verelim:
#-*-coding:utf-8-*-
import pygtk
pygtk.require20()
import gtk
class Uygulama(object):
def __init__(self):
self.pencere = gtk.Window(gtk.WINDOW_TOPLEVEL)
self.pencere.connect("delete_event", gtk.main_quit)
self.pencere.set_position(gtk.WIN_POS_CENTER)
self.pencere.set_border_width(10)
self.dugme1 = gtk.Button("Birinci")
self.dugme2 = gtk.Button("İkinci")
self.dugme3 = gtk.Button("Üçüncü")
self.hazne = gtk.Fixed()
self.pencere.add(self.hazne)
self.hazne.put(self.dugme1, 0, 0)
self.hazne.put(self.dugme2, 65, 0)
self.hazne.put(self.dugme3, 120, 0)
self.dugme1.show()
self.dugme2.show()
self.dugme3.show()
self.hazne.show()
self.pencere.show()
def main(self):
gtk.main()
uyg = Uygulama()
uyg.main()
Burada öncelikle “gtk.Fixed()” adlı sınıfı örnekliyoruz ve buna “self.hazne” adını veriyoruz. Zira “gtk.Fixed()” bir hazne olmasının yanısıra, GTK içindeki sınıflardan biridir aynı zamanda... Dolayısıyla bu sınıfı programımız içinde kullanabilmek için öncelikle bunu örneklememiz gerekiyor.
Örnekleme işlemini tamamladıktan sonra haznemizi ana pencereye ekliyoruz. Bu işlemi yapmak için “self.pencere.add(self.hazne)” kodunu kullandık. Haznemizi ana pencereye eklediğimize göre, pencere araçlarımızı hazne içine koymaya başlayabiliriz... Gördüğünüz gibi, önce pencereyi oluşturuyoruz, ardından haznemizi oluşturup bunu pencereye ekliyoruz, son olarak da pencere araçlarını hazneye yerleştiriyoruz. Pencere araçlarımızı hazneye yerleştirebilmek için put() adlı fonksiyondan yararlanacağız. Bu fonksiyonun formülü şöyledir:
hazne.put(pencere_aracı, x_düzlemindeki_konum, y_düzlemindeki_konum)
Bu formüle göre, “self.hazne.put(self.dugme1, 0, 0)” ifadesi şu anlama geliyor:
düğme1’i, x düzleminde (yani soldan sağa) 0. noktaya; y düzleminde ise (yani yukarıdan aşağıya) 0. noktaya gelecek şekilde hazne içine yerleştir!
Aynı mantığı kullanarak öteki düğmelerimizi de sırasıyla x düzleminde 65. ve 120. noktalara; y düzleminde ise 0. ve 0. noktalara gelecek şekilde hazne içine yerleştiriyoruz.
Sıra geldi bütün araçlarımızı göstermeye... Araçlarımızı gösterirken içten dışa doğru ilerlemenizi öneririm.
Buna göre ilk önce düğmeleri gösteriyoruz:
self.dugme1.show()
self.dugme2.show()
self.dugme3.show()
Daha sonra haznemizi gösteriyoruz:
self.hazne.show()
Son olarak da en dışta yer alan penceremizi gösteriyoruz:
self.pencere.show()
Bu arada size bir ipucu vereyim. Gördüğünüz gibi her aracı tek tek göstermek biraz yorucu ve sıkıcı oluyor. Pygtk bu konuda da bizi büyük bir dertten kurtaracak ve daha az benzin yakmamızı sağlayacak bir metot sunuyor bize. Bu şekilde bütün araçları tek tek göstermek yerine şöyle bir şey yazabiliriz:
self.pencere.show_all()
Yani kodlarımız şöyle görünecek:
#-*-coding:utf-8-*-
import pygtk
pygtk.require20()
import gtk
class Uygulama(object):
def __init__(self):
self.pencere = gtk.Window(gtk.WINDOW_TOPLEVEL)
self.pencere.connect("delete_event", gtk.main_quit)
self.pencere.set_position(gtk.WIN_POS_CENTER)
self.pencere.set_border_width(10)
self.dugme1 = gtk.Button("Birinci")
self.dugme2 = gtk.Button("İkinci")
self.dugme3 = gtk.Button("Üçüncü")
self.hazne = gtk.Fixed()
self.pencere.add(self.hazne)
self.hazne.put(self.dugme1, 0, 0)
self.hazne.put(self.dugme2, 65, 0)
self.hazne.put(self.dugme3, 120, 0)
self.pencere.show_all()
def main(self):
gtk.main()
uyg = Uygulama()
uyg.main()
show_all() metodu pencere üzerindeki bütün araçları gösterecektir. Dolayısıyla bu metodu ana pencereye bağlamaya dikkat ediyoruz...
“Fixed()” adlı haznenin put() adlı fonksiyonundan başka bir de move() adlı bir fonksiyonu vardır. “move” kelimesinin Türkçe’de “hareket etmek” anlamına geldiğini söylersek, herhalde bu fonksiyonun işlevi az çok ortaya çıkacaktır... move() fonksiyonu, Fixed() haznesi içindeki pencere araçlarını hareket ettirmemizi, yani bunların yerlerini değiştirmemizi sağlar.
Bununla ilgili basit bir örnek verelim:
#-*-coding:utf-8-*-
import pygtk
pygtk.require20()
import gtk
class Uygulama(object):
def __init__(self):
self.pencere = gtk.Window(gtk.WINDOW_TOPLEVEL)
self.pencere.connect("delete_event", gtk.main_quit)
self.pencere.set_position(gtk.WIN_POS_CENTER)
self.pencere.set_border_width(10)
self.dugme1 = gtk.Button("Tıkla!")
self.dugme1.connect("clicked", self.oynat)
self.dugme2 = gtk.Button("İkinci")
self.dugme3 = gtk.Button("Üçüncü")
self.hazne = gtk.Fixed()
self.pencere.add(self.hazne)
self.hazne.put(self.dugme1, 0, 0)
self.hazne.put(self.dugme2, 65, 0)
self.hazne.put(self.dugme3, 120, 0)
self.pencere.show_all()
def oynat(self, penar):
self.hazne.move(self.dugme2, 65, 50)
self.hazne.move(self.dugme3, 120, 100)
def main(self):
gtk.main()
uyg = Uygulama()
uyg.main()
move() fonksiyonunun nasıl kullanıldığını görüyorsunuz... Bu fonksiyon gtk.Fixed() sınıfına ait olduğu ve biz de bu sınıfı daha önceden “hazne” adıyla örneklediğimiz için, bu fonksiyonu “self.hazne.move()” şeklinde kullanıyoruz. Bu fonksiyonun birinci parametresi, hareket ettirilecek pencere aracıdır. İkinci ve üçüncü parametreler ise pencere aracının x ve y düzlemlerine göre hangi konumlara taşınacağını gösteren iki adet tamsayıdır. Bu programı çalıştırdığımızda, “Tıkla!” etiketli düğmeye bastığımız zaman “İkinci” ve “Üçüncü” etiketli düğmeler yer değiştirecektir...
Bu yeni bilgiyi kullanarak biraz daha “ilginç” şeyler de yapabiliriz. Mesela fareyle üzerine gelindiğinde etrafa kaçışan düğmeler yapabiliriz bu move() fonksiyonunu kullanarak...
#-*-coding:utf-8-*-
import pygtk
pygtk.require20()
import gtk
import random
class Uygulama(object):
def __init__(self):
self.pencere = gtk.Window(gtk.WINDOW_TOPLEVEL)
self.pencere.connect("delete_event", gtk.main_quit)
self.pencere.set_position(gtk.WIN_POS_CENTER)
self.pencere.resize(500, 500)
self.dugme1 = gtk.Button("Birinci")
self.dugme1.connect("enter", self.salla)
self.dugme2 = gtk.Button("İkinci")
self.dugme2.connect("enter", self.salla)
self.dugme3 = gtk.Button("Üçüncü")
self.dugme3.connect("enter", self.salla)
self.hazne = gtk.Fixed()
self.pencere.add(self.hazne)
self.hazne.put(self.dugme1, 0, 0)
self.hazne.put(self.dugme2, 65, 0)
self.hazne.put(self.dugme3, 120, 0)
self.pencere.show_all()
def salla(self, penar):
self.hazne.move(penar, random.randint(0,450), random.randint(0, 450))
def main(self):
gtk.main()
uyg = Uygulama()
uyg.main()
Buradaki salla() fonksiyonunu biraz açıklayalım:
move() fonksiyonunun hangi parametrelere ihtiyaç duyduğunu biliyoruz. Bu fonksiyonu kullanabilmek için ilk parametre olarak hareket ettirilecek pencere aracını yazmamız gerekiyor. İkinci ve üçüncü parametrelerde ise konum bilgilerini veriyoruz... Daha önceden, Pygtk’de sinyalleri bağladığımız fonksiyonların self hariç en az bir parametreye sahip olması gerektiğini söylemiştik. Bu parametre, sinyalin bağlanacağı pencere aracı olacak. Dolayısıyla salla() fonksiyonunun parametresinden ötürü zaten elimizde pencere aracının adı var... İşte biz bu pencere aracını move() fonksiyonu içinde de kullanacağız. Böylelikle her bir düğme için ayrı fonksiyon yazmamıza gerek kalmıyor... Elimizdeki bilgilere göre move() fonksiyonunu rahatlıkla oluşturabiliyoruz. random modülünün ürettiği rastgele sayılar sayesinde de düğmelerin üzerine fare ile her gelişimizde düğmelerin her biri farklı konumlara kaçışıyor. Farenin düğme üzerine gelme anını “enter” ile gösterdiğimizi önceki bölümde söylemiştik. Dolayısıyla düğmelere görev atarken “clicked” yerine “enter” sinyalini yazmayı unutmuyoruz. Peki bu kaçışan düğmeleri yakalama ihtimalimiz var mı? Evet, çok düşük bir ihtimal de olsa var... Eğer random modülünün art arda ürettiği sayılar birbirine çok yakın olursa düğmeleri yakalayabiliriz...
Gördüğünüz gibi, Fixed() haznesi içine yerleştirdiğimiz düğmeler, üzerinde yazan etiketin boyutunu alıyor. Dolayısıyla “Tamam” ve “git” gibi iki farklı etikete sahip iki düğmenin boyutu birbirinden farklı olacaktır. Bir örnek verelim:
#-*-coding:utf-8-*-
import pygtk
pygtk.require20()
import gtk
class Uygulama(object):
def __init__(self):
self.pencere = gtk.Window(gtk.WINDOW_TOPLEVEL)
self.pencere.connect("delete_event", gtk.main_quit)
self.pencere.set_position(gtk.WIN_POS_CENTER)
self.pencere.set_border_width(10)
self.etiket1 = gtk.Label("e.posta al!")
self.etiket2 = gtk.Label("e.posta gönder!")
self.etiket3 = gtk.Label("e.posta sil!")
self.dugme1 = gtk.Button("Al!")
self.dugme2 = gtk.Button("Gönder!")
self.dugme3 = gtk.Button("Sil")
self.hazne = gtk.Fixed()
self.pencere.add(self.hazne)
self.hazne.put(self.etiket1, 0, 10)
self.hazne.put(self.etiket2, 0, 50)
self.hazne.put(self.etiket3, 0, 90)
self.hazne.put(self.dugme1, 110, 7)
self.hazne.put(self.dugme2, 110, 47)
self.hazne.put(self.dugme3, 110, 87)
self.pencere.show_all()
def main(self):
gtk.main()
uyg = Uygulama()
uyg.main()
Gördüğünüz gibi, buradaki düğmelerin her birinin boyutu birbirinden farklı... Eğer istediğiniz buysa sorun yok, ama eğer bütün düğmelerin aynı boyutta olmasını isterseniz set_size_request() adlı metodu kullanmanız gerekecek:
#-*-coding:utf-8-*-
import pygtk
pygtk.require20()
import gtk
class Uygulama(object):
def __init__(self):
self.pencere = gtk.Window(gtk.WINDOW_TOPLEVEL)
self.pencere.connect("delete_event", gtk.main_quit)
self.pencere.set_position(gtk.WIN_POS_CENTER)
self.pencere.set_border_width(10)
self.etiket1 = gtk.Label("e.posta al!")
self.etiket2 = gtk.Label("e.posta gönder!")
self.etiket3 = gtk.Label("e.posta sil!")
self.dugme1 = gtk.Button("Al!")
self.dugme1.set_size_request(65, 25)
self.dugme2 = gtk.Button("Gönder!")
self.dugme2.set_size_request(65, 25)
self.dugme3 = gtk.Button("Sil")
self.dugme3.set_size_request(65, 25)
self.hazne = gtk.Fixed()
self.pencere.add(self.hazne)
self.hazne.put(self.etiket1, 0, 10)
self.hazne.put(self.etiket2, 0, 50)
self.hazne.put(self.etiket3, 0, 90)
self.hazne.put(self.dugme1, 110, 7)
self.hazne.put(self.dugme2, 110, 47)
self.hazne.put(self.dugme3, 110, 87)
self.pencere.show_all()
def main(self):
gtk.main()
uyg = Uygulama()
uyg.main()
Burada set_size_request() metodunu kullanarak bütün düğmelerin boyutunu “65x25” piksel olarak ayarladık. Bu set_size_request() metodu yalnızca düğmelerle kullanılan bir metot değildir. Mesela bu metodu pencereleri boyutlandırmak için de kullanabiliriz:
#-*-coding:utf-8-*-
import pygtk
pygtk.require20()
import gtk
class Uygulama(object):
def __init__(self):
self.pencere = gtk.Window(gtk.WINDOW_TOPLEVEL)
self.pencere.connect("delete_event", gtk.main_quit)
self.pencere.set_position(gtk.WIN_POS_CENTER)
self.pencere.set_size_request(100, 100)
self.pencere.show()
def main(self):
gtk.main()
uyg = Uygulama()
uyg.main()
Hatırlarsanız, daha önceki derslerimizde pencereleri boyutlandırmak için resize() adlı başka bir metot kullanmıştık. Hem resize(), hem de set_size_request() yaygın olarak pencere boyutlandırma işlemleri için kullanılır. Ama aslında bu iki metodun birbirinden önemli bir farkı vardır. resize() metodunu kullanarak boyutlandırdığımız bir pencereyi daha sonradan kenarlarından sürükleyip istediğimiz boyuta kadar küçültüp büyütebiliriz. Ama set_size_request() metodunu kullandığımızda, oluşan pencere ancak set_size_request() metodu içinde belirtilen boyutlar kadar küçültülebilir. Bu dediğimi tam olarak anlamak için hem resize() hem de set_size_request() metoduyla ayrı ayrı iki pencere oluşturup elle boyutlandırmayı denemeniz gerekiyor... Bunu yaptığınızda göreceksiniz ki, aslında set_size_request() metodu, bir pencerenin sahip olabileceği minimum boyutu belirlememizi sağlıyor...
Böylece Pygtk’de pencere araçlarını arayüz üzerine yerleştirmemizi sağlayan yöntemlerden birini görmüş olduk. Ancak bununla ilgili size bir iyi, bir de kötü haberim var... Önce iyi haberle başlayayım:
İyi haber, Fixed() haznesinin kullanımının karmaşık olmamasıdır. Bu hazneyi kullanarak işlerinizi rahatlıkla halledebilirsiniz. Fixed() haznesinin fazla bir özelliği olmadığı için, öteki araçlara kıyasla öğrenmesi daha kolaydır... Şimdi gelelim kötü habere:
Pygtk programlarında Fixed() haznesi hemen hemen hiç kullanılmaz!... Çünkü bu aracın zayıflıkları güçlü yanlarından çok daha fazladır ve kimi yerlerde programınızın arayüzünün berbat olmasına yol açabilir. Fixed() haznesi, pencere araçlarını arayüz üzerinde sabit noktalara yerleştirir. Dolayısıyla kullanıcılarınız sistemlerindeki temayı değiştirirlerse programınızın arayüzü üzerinde kaymalar meydana gelebilir. Ayrıca sizin programı yazdığınız sistemdeki yazıtiplerinin boyutu ile, programı kullanan kişilerin sistemindeki yazıtipi boyutları arasındaki farklılıklar düğme ve etiketlerin taşmasına neden olabilir. Mesela yukarıda verdiğimiz örneklerin Windows ve GNU/Linux’ta aynı şekilde görüneceğinin garantisi yoktur... Hatta aynı işletim sistemleri içinde dahi pencere araçlarının görünüşünde büyük farklılıklar ortaya çıkabilir. Bunun dışında, özellikle çok-dilli uygulamalar geliştiriyorsanız bu hazneyi kullanmaktan kaçınmanız gerekecektir. Çünkü bir etiket başka bir dile çevrildiğinde büyük ihtimalle kapladığı alan da değişecek ve pencere araçlarının üst üste binmesine yol açabilecektir. Aynı şekilde, eğer tasarladığınız bir uygulama sağdan sola doğru yazılan bir dile çevrilmek istenirse, kullandığınız Fixed() haznesinden dolayı bu gerçekleşemeyecektir. Çünkü bu haznenin “bidi” (çift-yönlü yazım) desteği bulunmuyor... Bunun dışında, bu hazne ile yerleştirilmiş bir öğede değişiklik yaptığınızda öteki öğelerin yerlerini de en baştan ayarlamanız gerekecektir.
4.2. Table() Pencere Aracı¶
Bu bölümde, Fixed() haznesinden çok daha yetenekli bir araçtan söz edeceğiz. Hatırlarsanız, sahip olduğu dezavantajlardan ötürü, yazdığımız uygulamalarda mümkün olduğunca Fixed() haznesini kullanmaktan kaçınmamız gerektiğini söylemiştik. Fixed() haznesinin tersine, bu bölümde öğreneceğimiz Table() adlı pencere aracı bir hayli esnek ve güçlüdür.
“Table” Türkçe’de “tablo” anlamına gelir. İsminden de anlaşılacağı gibi, bu araç bize düğmelerimizi, etiketlerimizi ve başka pencere araçlarımızı arayüz üstüne bir tablo şeklinde dizme imkanı sağlayacak. Burada “tablo” derken, satır ve sütünlara sahip bir düzenden söz ediyoruz. Oluşturmak istediğimiz pencere araçlarını, Table() aracının satır ve/veya sütunlarına yerleştireceğiz.
Table() pencere aracı şekil olarak ekran üzerinde şuna benzer bir yapı oluşturur:
0 1 2
0+----------+----------+
| | |
1+----------+----------+
| | |
2+----------+----------+
Yukarıdaki çizim, 2 satır ve 2 sütundan oluşan, “2x2” boyutlarındaki bir tabloyu gösteriyor. İşte biz de oluşturacağımız pencere araçlarını bu satır ve sütunlara yerleştireceğiz. İsterseniz hemen bunun kullanımıyla ilgili ufak bir örnek verelim:
tablo = gtk.Table(2, 2)
Bu şekilde, 2 satır ve 2 sütundan oluşan bir tablo oluşturmuş olduk. Yani yukarıdaki çizime benzer bir tablo elde ettik.
Tabloya pencere aracı eklemek için attach() adlı metottan faydalanacağız. Bu metodu şöyle kullanıyoruz:
tablo.attach(penar, sütun_başlangıcı, sütun_sonu, satır_başlangıcı, satır_sonu)
Burada “penar”, tabloya ekleyeceğimiz pencere aracının kendisi oluyor. Öteki parametreler ise pencere aracının yerleştirileceği tablo koordinatlarını gösteriyor. Dolayısıyla bir tabloya pencere aracı ekleyebilmek için, oluşturduğumuz tablonun satır ve sütun numaralarını göz önünde bulundurmamız gerekiyor. Gelin isterseniz bununla ilgili basit bir örnek yapalım.
Öncelikle şu kodları yazıyoruz:
#-*-coding:utf-8-*-
import pygtk
pygtk.require20()
import gtk
Şimdi bir sınıf oluşturup temel bilgileri bu sınıf içine yerleştirelim:
class Uygulama(object):
def __init__(self):
self.pencere= gtk.Window(gtk.WINDOW_TOPLEVEL)
self.pencere.connect("delete_event", gtk.main_quit)
Şimdi de tabloya yerleştireceğimiz düğmeleri oluşturalım:
self.dgm1 = gtk.Button("düğme1")
self.dgm2 = gtk.Button("düğme2")
self.dgm3 = gtk.Button("düğme3")
self.dgm4 = gtk.Button("düğme4")
Buraya kadar olan kısmı topluca görelim:
#-*-coding:utf-8-*-
import pygtk
pygtk.require20()
import gtk
class Uygulama(object):
def __init__(self):
self.pencere= gtk.Window(gtk.WINDOW_TOPLEVEL)
self.pencere.connect("delete_event", gtk.main_quit)
self.dgm1 = gtk.Button("düğme1")
self.dgm2 = gtk.Button("düğme2")
self.dgm3 = gtk.Button("düğme3")
self.dgm4 = gtk.Button("düğme4")
Bu kısımda bilmediğimiz herhangi bir şey yok. Burada gördüğümüz her şeyi önceki konulardan biliyoruz. Şimdi yolumuza devam edelim. Öncelikle 2x2 boyutlarında bir tablo oluşturuyoruz:
self.tablo = gtk.Table(2, 2)
İlk düğmemizi bu tablonun sol üst köşesine yerleştirelim:
self.tablo.attach(self.dgm1, 0, 1, 0, 1)
Gördüğünüz gibi, attach() adlı fonksiyona parametre olarak ilk önce tabloya yerleştireceğimiz pencere aracını yazdık (self.dgm1). Öteki sayılar ise düğmenin tam koordinatlarını gösteriyor. Amacımız bu düğmeyi tablonun sol üst köşesine yerleştirmek. Koordinatları yazarken yukarıda verdiğimiz çizimi göz önünde bulundurmanız işinizi epey kolaylaştıracaktır. O çizime göre düğmemiz tam olarak şöyle görünecek:
0 1 2
0+----------+----------+
| DÜĞME 1 | |
1+----------+----------+
| | |
2+----------+----------+
Gördüğünüz gibi, düğmemizin bulunduğu konum şöyle:
sütun_başlangıcı=0
sütun_sonu=1
satır_başlangıcı=0
satır_sonu=1
Şimdi ikinci düğmemizi yerleştirelim. İkinci düğmeyi tablonun sol alt köşesine yerleştireceğiz. Düğmemiz şöyle görünecek:
0 1 2
0+----------+----------+
| | |
1+----------+----------+
| DÜĞME 2 | |
2+----------+----------+
Düğmemizin konumu şöyle:
sütun_başlangıcı=0
sütun_sonu=1
satır_başlangıcı=1
satır_sonu=2
Buna göre attach() fonksiyonunu şu şekilde yazıyoruz:
self.tablo.attach(self.dgm2, 0, 1, 1, 2)
Sıra geldi üçüncü düğmemizi yerleştirmeye... Bunu tablonun sağ üst köşesine yerleştireceğiz:
0 1 2
0+----------+----------+
| | DÜĞME 3 |
1+----------+----------+
| | |
2+----------+----------+
Bu düğmemizin konumu da şöyle:
sütun_başlangıcı=1
sütun_sonu=2
satır_başlangıcı=0
satır_sonu=1
Buna göre attach() fonksiyonu şöyle olacak:
self.tablo.attach(self.dgm3, 1, 2, 0, 1)
Sıra geldi son düğmemizi yerleştirmeye... Bunu da tablonun sağ alt köşesine yerleştireceğiz:
0 1 2
0+----------+----------+
| | |
1+----------+----------+
| | DÜĞME 4 |
2+----------+----------+
Buna göre bu düğmemizin konumu da şöyle olmalı:
sütun_başlangıcı=1
sütun_sonu=2
satır_başlangıcı=1
satır_sonu=2
attach() fonksiyonumuzu yazıyoruz:
self.tablo.attach(self.dgm4, 1, 2, 1, 2)
Düğmelerimizi tablonun uygun yerlerine yerleştirdiğimize göre kodlarımızın son haline şöyle bir topluca bakalım:
#-*-coding:utf-8-*-
import pygtk
pygtk.require20()
import gtk
class Uygulama(object):
def __init__(self):
self.pencere= gtk.Window(gtk.WINDOW_TOPLEVEL)
self.pencere.connect("delete_event", gtk.main_quit)
self.dgm1 = gtk.Button("düğme1")
self.dgm2 = gtk.Button("düğme2")
self.dgm3 = gtk.Button("düğme3")
self.dgm4 = gtk.Button("düğme4")
self.tablo = gtk.Table(2, 2)
self.tablo.attach(self.dgm1, 0, 1, 0, 1)
self.tablo.attach(self.dgm2, 0, 1, 1, 2)
self.tablo.attach(self.dgm3, 1, 2, 0, 1)
self.tablo.attach(self.dgm4, 1, 2, 1, 2)
Bu noktadan sonra artık tablomuzu ana pencereye eklememiz gerekiyor. Bunu da şu komutla yapıyoruz:
self.pencere.add(self.tablo)
Pencere üzerindeki bütün öğeleri gösteriyoruz:
self.pencere.show_all()
main() fonksiyonumuzu yazıyoruz:
def main(self):
gtk.main()
Son olarak da sınıfımızı örnekleyip main() fonksiyonunu çağırıyoruz:
uyg = Uygulama()
uyg.main()
Böylece şu kodları elde etmiş oluyoruz:
#-*-coding:utf-8-*-
import pygtk
pygtk.require20()
import gtk
class Uygulama(object):
def __init__(self):
self.pencere= gtk.Window(gtk.WINDOW_TOPLEVEL)
self.pencere.connect("delete_event", gtk.main_quit)
self.dgm1 = gtk.Button("düğme1")
self.dgm2 = gtk.Button("düğme2")
self.dgm3 = gtk.Button("düğme3")
self.dgm4 = gtk.Button("düğme4")
self.tablo = gtk.Table(2, 2)
self.tablo.attach(self.dgm1, 0, 1, 0, 1)
self.tablo.attach(self.dgm2, 0, 1, 1, 2)
self.tablo.attach(self.dgm3, 1, 2, 0, 1)
self.tablo.attach(self.dgm4, 1, 2, 1, 2)
self.pencere.add(self.tablo)
self.pencere.show_all()
def main(self):
gtk.main()
uyg = Uygulama()
uyg.main()
Gördüğünüz gibi, pencere araçlarını tabloya yerleştirmek o kadar da zor değil. Tek yapmamız gereken, araçları hangi koordinatlara yerleştirdiğimize dikkat etmek...
Bu kodlar yardımıyla arayüz üzerine yerleştirdiğimiz düğmeler, dikkat ederseniz, birbirlerine bitişik duruyorlar. Ama biz her zaman düğmelerimizin arayüz üzerinde tıkış tıkış durmasını istemeyebiliriz. Eğer düğmeler arasına mesafe koymak istersek, satırlar ve sütunlar için ayrı ayrı olmak üzere iki farklı metottan yararlanacağız. İsterseniz durumu sözle değil, örnekler üzerinden açıklamaya çalışalım:
#-*-coding:utf-8-*-
import pygtk
pygtk.require20()
import gtk
class Uygulama(object):
def __init__(self):
self.pencere= gtk.Window(gtk.WINDOW_TOPLEVEL)
self.pencere.connect("delete_event", gtk.main_quit)
self.dgm1 = gtk.Button("düğme1")
self.dgm2 = gtk.Button("düğme2")
self.dgm3 = gtk.Button("düğme3")
self.dgm4 = gtk.Button("düğme4")
self.tablo = gtk.Table(2, 2)
self.tablo.set_row_spacings(10) #satırlar arasında boşluk bırakıyoruz
self.tablo.set_col_spacings(10) #sütunlar arasında boşluk bırakıyoruz
self.tablo.attach(self.dgm1, 0, 1, 0, 1)
self.tablo.attach(self.dgm2, 0, 1, 1, 2)
self.tablo.attach(self.dgm3, 1, 2, 0, 1)
self.tablo.attach(self.dgm4, 1, 2, 1, 2)
self.pencere.add(self.tablo)
self.pencere.show_all()
def main(self):
gtk.main()
uyg = Uygulama()
uyg.main()
Koyu harflerle gösterdiğimiz kodlar yardımıyla arayüz üzerinde bulunan tablomuzun satırları ve sütunları arasında 10’ar piksellik boşluklar oluşturduk. Böylece düğmelerimizi birbirinden ayırmış olduk...
Eğer bütün satırlar veya sütunlar üzerinde işlem yapmak yerine, sadece istediğimiz satırlar veya sütunlar üzerinde işlem yapmak istersek şu metotlardan yararlanacağız:
#-*-coding:utf-8-*-
import pygtk
pygtk.require20()
import gtk
class Uygulama(object):
def __init__(self):
self.pencere= gtk.Window(gtk.WINDOW_TOPLEVEL)
self.pencere.connect("delete_event", gtk.main_quit)
self.dgm1 = gtk.Button("düğme1")
self.dgm2 = gtk.Button("düğme2")
self.dgm3 = gtk.Button("düğme3")
self.dgm4 = gtk.Button("düğme4")
self.tablo = gtk.Table(2, 2)
self.tablo.set_row_spacing(0, 10) #0. satıra 10 piksellik bir
#boşluk yerleştiriyoruz.
self.tablo.set_col_spacing(0, 10) #0. sütuna 10 piksellik bir
#boşluk yerleştiriyoruz.
self.tablo.attach(self.dgm1, 0, 1, 0, 1)
self.tablo.attach(self.dgm2, 0, 1, 1, 2)
self.tablo.attach(self.dgm3, 1, 2, 0, 1)
self.tablo.attach(self.dgm4, 1, 2, 1, 2)
self.pencere.add(self.tablo)
self.pencere.show_all()
def main(self):
gtk.main()
uyg = Uygulama()
uyg.main()
Bu kodların tam olarak nasıl çalıştığı ve ne işe yaradığı, 4x4’ten daha büyük tablolarda daha net olarak görünecektir...
Table() adlı aracı tanıtırken, bu aracı şu şekilde kullandığımızı söylemiştik:
tablo = gtk.Table(2, 2)
Daha önce de söylediğimiz gibi, burada “2x2” boyutunda bir tablo oluşturuyoruz. Yani oluşturduğumuz tabloda 2 adet satır, 2 adet de sütun bulunuyor... Esasında “gtk.Table()” fonksiyonunun tam formülü şöyledir:
gtk.Table(rows, columns, homogeneous)
Gördüğünüz gibi, bu araç aslında toplam üç parametre alıyor. “rows” parametresine satır sayısını, “columns” parametresine ise sütun sayısını yazıyoruz. Sadece “gtk.Table(2, 2)” yazmak yerine, “gtk.Table(rows=2, columns=2)” yazmak, parantez içindeki sayıların hangisinin satır, hangisinin sütun olduğunu akılda tutmak açısından daha kolay olacaktır. Dolayısıyla siz de gtk.Table() fonksiyonu yardımıyla bir tablo oluştururken, parantez içine yazdığınız sayıların neyin karşılığı olduğunu da belirtmeyi tercih edebilirsiniz...
Yukarıdaki formülde dikkatimizi çeken başka bir şey de elbette parametre sayısının üç olması... Şimdiye kadar “homogeneous” adlı bu üçüncü parametreyi görmemiştik. Ama şimdi “homogeneous” parametresinin ne olduğunu bize öğretecek bir örnek yapacağız:
“homogeneous” parametresinin temel görevi, birbirinden farklı boyutlardaki düğmelerin hepsini aynı boyuta getirmektir... Hemen şöyle bir örnek verelim:
#-*-coding:utf-8-*-
import pygtk
pygtk.require20()
import gtk
class Uygulama(object):
def __init__(self):
self.pencere= gtk.Window(gtk.WINDOW_TOPLEVEL)
self.pencere.connect("delete_event", gtk.main_quit)
self.dgm1 = gtk.Button("tamam")
self.dgm2 = gtk.Button("çık")
self.tablo = gtk.Table(rows=1, columns=2)
self.tablo.attach(self.dgm1, 0, 1, 0, 1)
self.tablo.attach(self.dgm2, 1, 2, 0, 1)
self.pencere.add(self.tablo)
self.pencere.show_all()
def main(self):
gtk.main()
uyg = Uygulama()
uyg.main()
Burada “1” satır ve “2” sütundan oluşan bir tablo meydana getirdik. Bu tablonun sol üst köşesine bir düğmemizi, sağ üst köşesine ise öteki düğmemizi yerleştirdik. Yalnız dikkat ederseniz, düğme etiketlerinin uzunlukları birbirinden farklı olduğu için, düğmelerin boyutları da birbirinden farklı oluyor. Eğer düğmenin üzerindeki etiketin uzunluğu ne olursa olsun bütün düğmelerinizin aynı boyda olmasını isterseniz, “homogeneous” parametresi imdadınıza yetişecektir:
#-*-coding:utf-8-*-
import pygtk
pygtk.require20()
import gtk
class Uygulama(object):
def __init__(self):
self.pencere= gtk.Window(gtk.WINDOW_TOPLEVEL)
self.pencere.connect("delete_event", gtk.main_quit)
self.dgm1 = gtk.Button("tamam")
self.dgm2 = gtk.Button("çık")
self.tablo = gtk.Table(rows=1, columns=2, homogeneous=True)
self.tablo.attach(self.dgm1, 0, 1, 0, 1)
self.tablo.attach(self.dgm2, 1, 2, 0, 1)
self.pencere.add(self.tablo)
self.pencere.show_all()
def main(self):
gtk.main()
uyg = Uygulama()
uyg.main()
Buradaki “homogeneous” parametresine “True” değerini verirsek tablo üzerindeki bütün düğmeler aynı boyda olacak; bu parametrenin değerini “False” yaptığımızda ise her bir düğme farklı boyutta olacaktır... Eğer bu parametreyi hiç yazmazsak, Pygtk sanki bu parametrenin değeri “False” olarak belirlenmiş gibi davranacaktır...
Aslında bu parametre doğrudan düğmenin boyutuna müdahale etmiyor. Bu parametrenin müdahale ettiği şey tablonun satır ve sütunlarının boyutu. “homogeneous” parametresini “True” olarak ayarladığımızda, tablo üzerindeki satır ve sütunlar, tablo üzerindeki en geniş düğmenin boyutunu alıyor. Yani satır ve sütunlar, boyutları açısından tablo üzerine “homojen” olarak dağılıyor. Satır ve sütunlar tablo üzerine “homojen” olarak dağılınca da düğmelerimiz, içinde bulundukları satır veya sütunu kaplayacak şekilde genişliyor. Bu parametrenin değerini “False” olarak ayarladığımızda veya hiç yazmadığımızda ise tablo üzerindeki satır ve sütunlar, içinde barındırdıkları düğmelerin boyutunu alıyor. Eğer düğmenin etiketi kısa ise düğmenin kendisi de kısa olacağı için, bu düğmenin bulunduğu satır veya sütun da dar oluyor... Bu açıklama biraz karışık gelmiş olabilir. gtk.Table() aracının nerede nasıl davrandığını anlamanın en iyi yolu kendi kendinize denemeler yapmaktır. Mesela biz şimdi şöyle bir örnek verelim:
#-*-coding:utf-8-*-
import pygtk
pygtk.require20()
import gtk
class Uygulama(object):
def __init__(self):
self.pencere= gtk.Window(gtk.WINDOW_TOPLEVEL)
self.pencere.connect("delete_event", gtk.main_quit)
self.dgm1 = gtk.Button("tamam")
self.dgm2 = gtk.Button("çık")
self.tablo = gtk.Table(rows=4, columns=4, homogeneous=True)
self.tablo.attach(self.dgm1, 2, 3, 3, 4)
self.tablo.attach(self.dgm2, 3, 4, 3, 4)
self.pencere.add(self.tablo)
self.pencere.show_all()
def main(self):
gtk.main()
uyg = Uygulama()
uyg.main()
Bu örnek, “homogeneous” adlı parametrenin alttan alta neler karıştırdığını açık bir şekilde ortaya koyuyor. Burada “homogeneous” parametresinin değeri “True” olduğu için, tablo üzerindeki bütün satır ve sütunlar, en geniş düğmenin (yani “tamam” etiketli düğmenin) boyutunu aldı. “çık” etiketli düğme, “tamam” etiketli düğmeye kıyasla daha kısa olduğu için, “homogeneous=True” ifadesinin etkisiyle, içinde bulunduğu satırın tamamını kaplayacak şekilde genişledi. Dikkat ederseniz, tablomuz “4x4” boyutunda. Yani tablo üzerinde toplam 4 satır ve 4 sütun var. Ama arayüz üzerinde sadece iki adet düğme yer alıyor. Biz bu iki düğmeyi tablonun sağ alt köşelerine yerleştirdik. Bu arada, boş satır ve sütunların da, boş olmalarına rağmen, tablo üzerindeki en geniş düğmenin boyutunu aldığına dikkat edin... Burada “homogeneous” parametresinin değerini “False” olarak ayarlarsanız, boş satır ve sütunların yokluk derecesine kadar daraldığını göreceksiniz...
Dediğimiz gibi, bir tablodaki satır ve sütunları “homojen” olarak dağıttığımızda, düğmeler, içinde yer aldıkları satır ve sütunların içini tamamen kaplayacak şekilde genişleyecektir. “homojen” olarak dağıtılmamış bir tabloda ise düğmeler farklı boyutlarda olacaktır. Bir örnek vermek gerekirse:
#-*-coding:utf-8-*-
import pygtk
pygtk.require20()
import gtk
class Uygulama(object):
def __init__(self):
self.pencere= gtk.Window(gtk.WINDOW_TOPLEVEL)
self.pencere.connect("delete_event", gtk.main_quit)
self.dgm1 = gtk.Button("a")
self.dgm2 = gtk.Button("abcd")
self.dgm3 = gtk.Button("123456")
self.dgm4 = gtk.Button("fdsfdfsdfsd")
self.tablo = gtk.Table(rows=2, columns=3)
self.tablo.attach(self.dgm1, 0, 1, 0, 1)
self.tablo.attach(self.dgm2, 1, 2, 0, 1)
self.tablo.attach(self.dgm3, 2, 3, 0, 1)
self.tablo.attach(self.dgm4, 0, 3, 1, 2)
self.pencere.add(self.tablo)
self.pencere.show_all()
def main(self):
gtk.main()
uyg = Uygulama()
uyg.main()
Gördüğünüz gibi bu kodlarda “homogeneous=True” gibi bir ifade kullanmadığımız için düğmeler birbirinden farklı boyutlara sahip. Bir de şuna bakalım:
#-*-coding:utf-8-*-
import pygtk
pygtk.require20()
import gtk
class Uygulama(object):
def __init__(self):
self.pencere= gtk.Window(gtk.WINDOW_TOPLEVEL)
self.pencere.connect("delete_event", gtk.main_quit)
self.dgm1 = gtk.Button("a")
self.dgm2 = gtk.Button("abcd")
self.dgm3 = gtk.Button("123456")
self.dgm4 = gtk.Button("fdsfdfsdfsd")
self.tablo = gtk.Table(rows=2, columns=3, homogeneous=True)
self.tablo.attach(self.dgm1, 0, 1, 0, 1)
self.tablo.attach(self.dgm2, 1, 2, 0, 1)
self.tablo.attach(self.dgm3, 2, 3, 0, 1)
self.tablo.attach(self.dgm4, 0, 3, 1, 2)
self.pencere.add(self.tablo)
self.pencere.show_all()
def main(self):
gtk.main()
uyg = Uygulama()
uyg.main()
Burada “homogeneous” parametresinin değerini “True” olarak ayarladığımız için bütün düğmeler aynı boyuta geldi. Tablonun ikinci satırındaki “fdsfdfsdfsd” etiketli düğmenin boyutunun öteki bütün düğmelerden farklı olması sizi şaşırtmasın. Zira o düğmenin boyutunu elimizle biz kendimiz ayarladık... Dikkat ettiyseniz, o düğmeyi tabloya eklerken kullandığımız “self.tablo.attach(self.dgm4, 0, 3, 1, 2)” kodu o düğmeyi ikinci satırın tamamını kaplayacak şekilde ayarlıyor. (satır_başlangıcı=0, satır_sonu=3)
Şimdi bir deneme yapalım. Yukarıdaki kodlarla oluşturduğunuz pencereyi kenarından fare yardımıyla çekip büyütün. Gördüğünüz gibi, düğmeler de pencereyle birlikte büyüyüp küçülüyor. Bu durumun “homogeneous” parametresiyle ilgisi yoktur. Bu parametreyi “True” da yapsanız “False” da yapsanız, pencereyi fare ile büyütüp küçülttüğünüzde düğmeler de pencereyle beraber büyüyüp küçülecektir. Neden? Çünkü bu davranışı belirleyen parametre “homogeneous” değil, henüz öğrenmediğimiz başka bir parametredir. Şimdi bu davranışı tetikleyen parametrenin ne olduğuna bakacağız.
Yukarıdaki şekilde oluşturduğumuz pencerelerde düğmeler pencereyle birlikte genişleyip daralır. Bunun nedeni, tabloya eklenen düğmelerin, varsayılan olarak “gtk.EXPAND” ve “gtk.FILL” adlı iki parametreye sahip olmasıdır... Şimdi bu parametrelerin ne işe yaradığını göreceğiz. Şu kod parçasına bakalım:
self.tablo.attach(self.dgm1, 0, 1, 0, 1)
self.tablo.attach(self.dgm2, 1, 2, 0, 1)
self.tablo.attach(self.dgm3, 2, 3, 0, 1)
self.tablo.attach(self.dgm4, 0, 3, 1, 2)
Dört adet düğmeyi tabloya bu şekilde yerleştirdiğimizde aslında Pygtk bu kodları şu şekilde algılayacaktır:
self.tablo.attach(self.dgm1, 0, 1, 0, 1, gtk.EXPAND|gtk.FILL, gtk.EXPAND|gtk.FILL)
self.tablo.attach(self.dgm2, 1, 2, 0, 1, gtk.EXPAND|gtk.FILL, gtk.EXPAND|gtk.FILL)
self.tablo.attach(self.dgm3, 2, 3, 0, 1, gtk.EXPAND|gtk.FILL, gtk.EXPAND|gtk.FILL)
self.tablo.attach(self.dgm4, 0, 3, 1, 2, gtk.EXPAND|gtk.FILL, gtk.EXPAND|gtk.FILL)
Yukarıda verdiğimiz bu kodlardaki ilk satırı ele alalım:
self.tablo.attach(self.dgm1, 0, 1, 0, 1, gtk.EXPAND|gtk.FILL, gtk.EXPAND|gtk.FILL)
Buradaki ilk “gtk.EXPAND|gtk.FILL” komutu “xoptions” olarak anılır... ikinci “gtk.EXPAND|gtk.FILL” ise “yoptions” olarak anılır... “xoptions” kelimesi “x seçenekleri”; “yoptions” kelimesi ise “y seçenekleri” anlamına gelir. Burada “x seçenekleri” ifadesiyle kastedilen, bir düğmenin “x düzleminde kapsayacağı alana ilişkin seçenekler”dir. Aynı şekilde “y seçenekleri” ifadesiyle kastedilen şey de bir düğmenin “y düzleminde kapsayacağı alana ilişkin seçenekler”dir... Bu bilgiye göre, yukarıdaki formülde yer alan ilk “gtk.EXPAND|gtk.FILL” ifadesi şu anlama geliyor:
pencere büyüyüp küçüldüğünde düğmemiz x düzleminde (yani soldan sağa doğru) hem genişlesin (expand), hem de içinde bulunduğu satır veya sütunu kaplasın (fill)
Aynı formüldeki ikinci “gtk.EXPAND|gtk.FILL” ifadesi ise şu anlama geliyor:
pencere büyüyüp küçüldüğünde düğmemiz y düzleminde (yani yukarıdan aşağıda doğru) hem genişlesin (expand), hem de içinde bulunduğu satırı veya sütunu kaplasın (fill)
Şimdi bu parametrelerin işlevini daha net anlayabilmek için ilk “gtk.EXPAND|gtk.FILL” ifadesindeki “gtk.FILL” kısmını silin. Yani kodunuz şöyle olsun:
self.tablo.attach(self.dgm1, 0, 1, 0, 1, gtk.EXPAND, gtk.EXPAND|gtk.FILL)
self.tablo.attach(self.dgm2, 1, 2, 0, 1, gtk.EXPAND, gtk.EXPAND|gtk.FILL)
self.tablo.attach(self.dgm3, 2, 3, 0, 1, gtk.EXPAND, gtk.EXPAND|gtk.FILL)
self.tablo.attach(self.dgm4, 0, 3, 1, 2, gtk.EXPAND, gtk.EXPAND|gtk.FILL)
Gördüğünüz gibi, “gtk.FILL” ifadesini kaldırınca arayüzün görüntüsü değişti. Artık düğmelerimiz, içinde bulundukları satır ve sütunları kaplamıyor. Yalnız burada “xoptions” parametresinin değerinde yer alan “gtk.FILL” ifadesini sildiğimiz için bu değişiklik yalnızca “x düzlemini” etkiliyor. Bu parametrelerin tam olarak ne işe yaradığını anlamak için kendi kendinize çeşitli kombinasyonlar denemenizi öneririm...
“gtk.FILL” ve gtk.EXPAND” dışında Pygtk’de “gtk.SHRINK” adlı bir parametre daha bulunur. Bu parametre ise düğmelerin “büzüşmesini”, yani kesinlikle büyüyüp küçülmemesini sağlar. Şu örnek ne demek istediğimi açıklayacaktır:
#-*-coding:utf-8-*-
import pygtk
pygtk.require20()
import gtk
class Uygulama(object):
def __init__(self):
self.pencere= gtk.Window(gtk.WINDOW_TOPLEVEL)
self.pencere.connect("delete_event", gtk.main_quit)
self.dgm1 = gtk.Button("a")
self.dgm2 = gtk.Button("abcd")
self.dgm3 = gtk.Button("123456")
self.dgm4 = gtk.Button("fdsfdfsdfsd")
self.tablo = gtk.Table(rows=2, columns=3, homogeneous=True)
self.tablo.attach(self.dgm1, 0, 1, 0, 1, gtk.SHRINK, gtk.SHRINK)
self.tablo.attach(self.dgm2, 1, 2, 0, 1, gtk.SHRINK, gtk.SHRINK)
self.tablo.attach(self.dgm3, 2, 3, 0, 1, gtk.SHRINK, gtk.SHRINK)
self.tablo.attach(self.dgm4, 0, 3, 1, 2, gtk.SHRINK, gtk.SHRINK)
self.pencere.add(self.tablo)
self.pencere.show_all()
def main(self):
gtk.main()
uyg = Uygulama()
uyg.main()
Bu kodlarla oluşturduğumuz pencereyi ne şekilde boyutlandırırsak boyutlandıralım, düğmeler oldukları yere çakılı vaziyette kalacaktır.
4.3. Box() Sınıfı¶
Pygtk’de pencere araçlarını pencere üzerine yerleştirebilmek için şimdiye kadar iki adet araç öğrendik. Bunlar pygtk içindeki Fixed() ve Table() adlı araçlardı. Bu iki araç arasında en çok kullanılanı Table()’dir. Fixed() haznesi her ne kadar oldukça kolay bir kullanıma sahip olsa da, Pygtk uygulamalarında hemen hemen hiç kullanılmaz. Bunun sebeplerini Fixed() haznesini işlerken anlatmıştık... Table() adlı aracın yanısıra, Pygtk’de pencere araçlarını pencere üzerine yerleştirmek için yaygın olarak kullanılan başka bir araç daha var. Bu bölümde işleyeceğimiz bu aracın genel adı “Box()”. Ancak biz bu Box() sınıfını doğrudan kullanmayacağız. Bunun yerine, Box() adlı sınıftan türetilmiş “Hbox()” ve “Vbox()” adlı alt sınıflardan yararlanacağız. Ayrıca HBox() ve VBox()’tan farklı olarak ButtonBox() sınıfından türetilen “HButtonBox()” ve “VButtonBox()” adlı sınıflara da, aralarındaki benzerliklerden ötürü bu bölümde değineceğiz.
Bu bölümde “Hbox()”, “Vbox()”, “HButtonBox()” ve VButtonBox()” sınıflarını sırayla inceleyeceğiz. O halde gelin hemen işe koyulalım...
4.4. HBox() Haznesi¶
HBox() da tıpkı Table() gibi bir haznedir. Yani bu araç, başka pencere araçlarını üzerinde taşıma vazifesi görür. İngilizce’de bu haznenin açılımı “Horizontal Box”tur. Bu ifade Türkçe’de “Yatay Kutu” anlamına gelir. Dolayısıyla bu hazne, içine yerleştirdiğimiz pencere araçlarını pencerenin yatay düzlemine yerleştirir. Bunun tam olarak ne demek olduğunu biraz sonra göreceğiz.
Pygtk’de bir yatay kutu oluşturabilmek için şu kodları kullanıyoruz:
kutu = gtk.HBox()
Gelin isterseniz bu kodu doğal ortamında görelim:
import pygtk
pygtk.require20()
import gtk
class Uygulama(object):
def __init__(self):
self.pencere = gtk.Window(gtk.WINDOW_TOPLEVEL)
self.pencere.connect("delete_event", gtk.main_quit)
self.kutu = gtk.HBox()
self.pencere.add(self.kutu)
self.pencere.show_all()
def main(self):
gtk.main()
uyg = Uygulama()
uyg.main()
Bu kodları çalıştırdığımızda pencere üzerinde pek bir değişiklik görmeyeceğiz. Yani sanki boş bir pencere oluşturmuş gibi olduk bu kodlar yardımıyla... Bu kodlar arasına yazdığımız “self.kutu = gtk.HBox()” satırının hiç bir etkisinin olmaması (aslında olmamış gibi görünmesi), oluşturduğumuz kutunun henüz boş olmasından kaynaklanıyor. Yani henüz oluşturduğumuz kutuya herhangi bir pencere aracı eklemediğimiz için, doğal olarak kutu boş görünüyor. Bu arada oluşturduğumuz kutuyu add() metodu yardımıyla ana penceremize eklemeyi unutmuyoruz...
Şimdi bu kutuyu nasıl dolduracağımızı görelim:
import pygtk
pygtk.require20()
import gtk
class Uygulama(object):
def __init__(self):
self.pencere = gtk.Window(gtk.WINDOW_TOPLEVEL)
self.pencere.connect("delete_event", gtk.main_quit)
self.dugme = gtk.Button("DENEME")
self.kutu = gtk.HBox()
self.kutu.pack_start(self.dugme)
self.pencere.add(self.kutu)
self.pencere.show_all()
def main(self):
gtk.main()
uyg = Uygulama()
uyg.main()
Burada hayatımıza pack_start() adlı yeni bir metot giriyor... Bu metot, HBox() kutusu içine yerleştirdiğimiz pencere araçlarını yatay düzlem üzerinde soldan sağa doğru dizmemizi sağlar. İsterseniz birden fazla pencere aracını kullanarak daha net bir örnek vermeye çalışalım:
import pygtk
pygtk.require20()
import gtk
class Uygulama(object):
def __init__(self):
self.pencere = gtk.Window(gtk.WINDOW_TOPLEVEL)
self.pencere.connect("delete_event", gtk.main_quit)
self.dugme = gtk.Button("DENEME")
self.dugme1 = gtk.Button("DENEME1")
self.dugme2 = gtk.Button("DENEME2")
self.dugme3 = gtk.Button("DENEME3")
self.dugme4 = gtk.Button("DENEME4")
self.kutu = gtk.HBox()
self.kutu.pack_start(self.dugme)
self.kutu.pack_start(self.dugme1)
self.kutu.pack_start(self.dugme2)
self.kutu.pack_start(self.dugme3)
self.kutu.pack_start(self.dugme4)
self.pencere.add(self.kutu)
self.pencere.show_all()
def main(self):
gtk.main()
uyg = Uygulama()
uyg.main()
Gördüğünüz gibi, her bir düğmemizi pack_start() metodu yardımıyla “HBox()” üzerine tek tek yerleştirdik. Burada düğmelerin soldan sağa doğru sıralandığına dikkat edin. Eğer bu düğmeleri sağdan sola doğru sıralamak istersek pack_end() metodundan yararlanacağız:
import pygtk
pygtk.require20()
import gtk
class Uygulama(object):
def __init__(self):
self.pencere = gtk.Window(gtk.WINDOW_TOPLEVEL)
self.pencere.connect("delete_event", gtk.main_quit)
self.dugme = gtk.Button("DENEME")
self.dugme1 = gtk.Button("DENEME1")
self.dugme2 = gtk.Button("DENEME2")
self.dugme3 = gtk.Button("DENEME3")
self.dugme4 = gtk.Button("DENEME4")
self.kutu = gtk.HBox()
self.kutu.pack_end(self.dugme)
self.kutu.pack_end(self.dugme1)
self.kutu.pack_end(self.dugme2)
self.kutu.pack_end(self.dugme3)
self.kutu.pack_end(self.dugme4)
self.pencere.add(self.kutu)
self.pencere.show_all()
def main(self):
gtk.main()
uyg = Uygulama()
uyg.main()
Burada “DENEME” etiketli düğmenin en sağda yer aldığına, öteki düğmelerin de buna uygun şekilde sağdan sola doğru dizilmiş olduğuna dikkat edin...
HBox() adlı hazne iki parametre alır. Bunlardan biri “homogeneous”, ikincisi ise “spacing”dir. “homogeneous” parametresini Table() pencere aracını işlerken de görmüştük. Bu parametre burada da aynı görevde kullanılır. “spacing” parametresi ise pencere araçları arasında boşluk bırakabilmemizi sağlar:
import pygtk
pygtk.require20()
import gtk
class Uygulama(object):
def __init__(self):
self.pencere = gtk.Window(gtk.WINDOW_TOPLEVEL)
self.pencere.connect("delete_event", gtk.main_quit)
self.dugme = gtk.Button("D")
self.dugme2 = gtk.Button("DEN")
self.dugme3 = gtk.Button("DENEM")
self.dugme4 = gtk.Button("DENEME")
self.kutu = gtk.HBox(homogeneous=False, spacing=10)
self.kutu.pack_end(self.dugme)
self.kutu.pack_end(self.dugme2)
self.kutu.pack_end(self.dugme3)
self.kutu.pack_end(self.dugme4)
self.pencere.add(self.kutu)
self.pencere.show_all()
def main(self):
gtk.main()
uyg = Uygulama()
uyg.main()
Burada “homogeneous” parametresini “False” olarak ayarladığımız için, HBox() içindeki düğmelerin boyutları birbirinden farklı oldu. Eğer bu parametreyi “True” olarak ayarlarsak (varsayılan değer False’dir), HBox() içindeki bütün düğmeler, en uzun etiketli düğmenin boyutunu alacak, dolayısıyla bütün düğmeler aynı boyda olacaktır...
Aynı kodlar içinde gördüğümüz “spacing” adlı parametreye verdiğimiz değer sayesinde ise, düğmeler arasında 10 piksellik boşluklar oluşturduk. Böylece düğmelerimizi dip dibe yaşamaktan kurtarmış olduk...
Bunun dışında, pack_start() ve pack_end() metotları da bazı parametreler alabilir. Bu metotların alabileceği parametre sayısı 3’tür:
expand: True veya False değeri alır. Düğmelerin genişleyip genişlemeyeceğini belirler.
fill: True veya False değeri alır. Düğmelerin, kutuyu kaplayıp kaplamayacaklarını belirler.
padding: Düğmeler arasındaki mesafeyi belirler.
Bununla ilgili bir örnek verelim:
import pygtk
pygtk.require20()
import gtk
class Uygulama(object):
def __init__(self):
self.pencere = gtk.Window(gtk.WINDOW_TOPLEVEL)
self.pencere.connect("delete_event", gtk.main_quit)
self.dugme = gtk.Button("D")
self.dugme2 = gtk.Button("DEN")
self.dugme3 = gtk.Button("DENEM")
self.dugme4 = gtk.Button("DENEME")
self.kutu = gtk.HBox()
self.kutu.pack_start(self.dugme, expand=False, fill=False, padding=10)
self.kutu.pack_start(self.dugme2, expand=False, fill=False, padding=10)
self.kutu.pack_start(self.dugme3, expand=False, fill=False, padding=10)
self.kutu.pack_start(self.dugme4, expand=False, fill=False, padding=10)
self.pencere.add(self.kutu)
self.pencere.show_all()
def main(self):
gtk.main()
uyg = Uygulama()
uyg.main()
Bu kodları çalıştırdığımızda, pencereyi ucundan çekip büyütünce düğmelerin ne tepki verdiğine dikkat edin...
Son bir not olarak şunu da söyleyelim. Eğer isterseniz pack_start() yerine sadece add() metodunu da kullanabilirsiniz:
import pygtk
pygtk.require20()
import gtk
class Uygulama(object):
def __init__(self):
self.pencere = gtk.Window(gtk.WINDOW_TOPLEVEL)
self.pencere.connect("delete_event", gtk.main_quit)
self.dugme = gtk.Button("D")
self.dugme2 = gtk.Button("DEN")
self.dugme3 = gtk.Button("DENEM")
self.dugme4 = gtk.Button("DENEME")
self.kutu = gtk.HBox()
self.kutu.add(self.dugme)
self.kutu.add(self.dugme2)
self.kutu.add(self.dugme3)
self.kutu.add(self.dugme4)
self.pencere.add(self.kutu)
self.pencere.show_all()
def main(self):
gtk.main()
uyg = Uygulama()
uyg.main()
Ancak tabii ki pack_start() metodu, add() metoduna kıyasla daha gelişmiş bir araçtır. Eğer add() metodunun sağladığı özellikler bana yeter, diyorsanız yukarıdaki gibi bir yazım tarzı işlerinizi kolaylaştırabilir...
4.5. VBox() Haznesi¶
Bir önceki bölümde incelediğimiz HBox() haznesi, pencere araçlarını pencere üzerinde yatay olarak diziyordu. Şimdi öğreneceğimiz VBox() haznesi ise pencere araçlarını pencere üzerinde dikey olarak dizecek...
VBox() haznesini de tıpkı HBox() haznesine benzer şekilde oluşturuyoruz:
import pygtk
pygtk.require20()
import gtk
class Uygulama(object):
def __init__(self):
self.pencere = gtk.Window(gtk.WINDOW_TOPLEVEL)
self.pencere.connect("delete_event", gtk.main_quit)
self.kutu = gtk.VBox()
self.pencere.add(self.kutu)
self.pencere.show_all()
def main(self):
gtk.main()
uyg = Uygulama()
uyg.main()
Elbette, bu kodların işe yarar bir şey ortaya çıkarabilmesi için burada da pack_start() ve pack_end() metotlarından yararlanmamız gerekiyor:
import pygtk
pygtk.require20()
import gtk
class Uygulama(object):
def __init__(self):
self.pencere = gtk.Window(gtk.WINDOW_TOPLEVEL)
self.pencere.connect("delete_event", gtk.main_quit)
self.kutu = gtk.VBox()
self.etiket1 = gtk.Button("Etiket 1")
self.etiket2 = gtk.Button("Etiket 2")
self.etiket3 = gtk.Button("Etiket 3")
self.kutu.pack_start(self.etiket1)
self.kutu.pack_start(self.etiket2)
self.kutu.pack_start(self.etiket3)
self.pencere.add(self.kutu)
self.pencere.show_all()
def main(self):
gtk.main()
uyg = Uygulama()
uyg.main()
Gördüğünüz gibi, “VBox()” haznesinin, “HBox()” haznesinden kullanım olarak hiçbir farkı yok. Bu ikisi arasındaki tek fark, HBox()’un düğmeleri soldan sağa (veya sağdan sola) dizmesi, VBox()’un ise düğmeleri yukarıdan aşağıya (veya aşağıdan yukarıya) dizmesidir... HBox() haznesini incelerken öğrendiğimiz her şeyi VBox() ile de kullanabilirsiniz...
Pygtk’de HBox() ve VBox() haznelerini, istediğiniz arayüz tasarımını oluşturabilmek için istediğiniz sayıda ve istediğiniz şekilde kullanabilirsiniz. Dilerseniz, bu konuyu kapatmadan önce bir örnek daha vererek HBox() ve VBox() haznelerinin esnekliğini görelim:
#-*-coding:utf-8-*-
import pygtk
pygtk.require20()
import gtk
class Uygulama(object):
def __init__(self):
#Normal bir şekilde penceremizi oluştup biçimlendiriyoruz...
self.pencere = gtk.Window(gtk.WINDOW_TOPLEVEL)
self.pencere.set_title(u"Örnek bir Uygulama")
self.pencere.connect("destroy", self.kapat)
self.pencere.set_border_width(10)
#Bir VBox() oluşturuyoruz. Bu, daha sonra içine düğmelerimizi
#yerleştireceğimiz iki farklı HBox()'u barındıracak... Böylece
#arayüz üzerinde HBox()'ların içindeki düğmeler alt alta görünecek
self.anavbox = gtk.VBox(True, 0)
self.pencere.add(self.anavbox)
#Üst sıradaki düğmeleri barındıracak olan HBox()'u oluşturuyoruz.
self.hbox1 = gtk.HBox(True, 0)
#Biraz önce oluşturduğumuz HBox()'u ana VBox() içine yerleştiriyoruz
self.anavbox.pack_start(self.hbox1)
#Şimdi de ikinci sıradaki düğmeleri barındıracak olan HBox()'u
#oluşturalım...
self.hbox2 = gtk.HBox(True, 0)
#Bunu da ana VBox() içine yerleştiriyoruz.
self.anavbox.pack_start(self.hbox2)
#Şimdi üst ve alt sırada yer alacak düğmeleri birer demet halinde
#tanımlayalım. Bu demetin her öğesi, kendi içinde iki öğeden oluşuyor.
#İlk öğe düğmenin adı, ikinci öğe ise düğmeye atanacak fonksiyonu temsil
#ediyor... Ben burada her sıradaki düğmeler için örnek olarak birer
#tane fonksiyon belirledim (self.kapat ve self.merhaba). Siz isterseniz
#her bir düğme için ayrı bir fonksiyon belirleyebilirsiniz...
ust_btnler = (("kapat", self.kapat),
("btn2", None),
("btn3", None),
("btn4", None))
alt_btnler = (("btn5", None),
("merhaba", self.merhaba),
("btn7", None),
("btn8", None))
#Üst ve alt sıradaki düğmeleri birer for döngüsü ile iki hamlede
#oluşturuyoruz. Burada "penar_olustur()" adlı bir fonksiyondan
#yardım alıyoruz. Bu fonksiyonu aşağıda tanımlayacağız.
for ust_oge in ust_btnler:
self.penar_olustur(ust_oge[0], ust_oge[1], self.hbox1)
for alt_oge in alt_btnler:
self.penar_olustur(alt_oge[0], alt_oge[1], self.hbox2)
#Bu da "penar_olustur()" adlı yardımcı fonksiyonumuz... Bu fonksiyon bizi
#aynı şeyleri tekrar tekrar yazmaktan kurtarıyor. Fonksiyonumuz "self"
#dışında üç parametre alıyor. İlk parametre olarak düğmenin adını veriyoruz.
#İkinci parametremiz düğmeye atanacak fonksiyonu gösteriyor. Üçüncü
#parametreyi ise düğmenin hangi HBox()'a yerleştirileceğini belirleyebilmek
#için kullanacağız...
def penar_olustur(self, metin, komut, penar):
self.btn = gtk.Button(metin)
#Yukarıda tanımladığımız demetler içinde ben "None" değerini
#kullandığım için normalde Python bize TypeError hatası verecektir.
#Bu hatanın programımızı çökertmemesi için aşağıdaki try... except...
#bloğunu yazıyoruz.
try:
self.btn.connect("clicked", komut)
except TypeError:
pass
penar.pack_start(self.btn)
self.pencere.show_all()
def kapat(self, penar):
gtk.main_quit()
def merhaba(self, penar):
print u"Merhaba Dünya"
def main(self):
gtk.main()
uyg = Uygulama()
uyg.main()
Dediğimiz gibi, bu kodlarda üst ve alt satırda yer alacak düğmeleri iki farklı demet (tuple) içinde tanımladık. Biz burada demetler yerine sözlüklerden de yararlanabilirdik. Ama eğer sözlük kullanacak olursak, sözlükler sırasız veri tipleri oldukları için düğmeler ekranda bizim istediğimiz sırada görünmeyecektir... O yüzden yukarıdaki durum için en iyi yol, ikişer öğeli demetlerden oluşan iki ana demet tanımlamaktır.
4.6. HButtonBox() ve VButtonBox() Hazneleri¶
HButtonBox() ve VButtonBox() hazneleri HBox() ve VBox() haznelerine çok benzer. Bu yüzden “gtk.ButtonBox()” sınıfından türetilmiş bu hazneleri bu bölümde incelemeyi uygun bulduk. HButtonBox() ve VButtonBox() hazneleri HBox() ve VBox() haznelerine benzemekle birlikte, HButtonBox() veya VButtonBox() ile paketlenen düğmeler, pencere üzerine uygun bir şekilde dağılmalarını sağlayacak ayarları otomatik olarak elde ederler... Peki bu ne demek oluyor? Galiba en iyisi bu durumu bir örnekle açıklamak olacak:
import pygtk
pygtk.require20()
import gtk
class Uygulama(object):
def __init__(self):
self.pencere = gtk.Window(gtk.WINDOW_TOPLEVEL)
self.pencere.resize(300, 300)
self.pencere.connect("delete_event", gtk.main_quit)
self.kutu = gtk.HButtonBox()
self.etiket1 = gtk.Button("Etiket 1")
self.etiket2 = gtk.Button("Etiket 2")
self.kutu.add(self.etiket1)
self.kutu.add(self.etiket2)
self.pencere.add(self.kutu)
self.pencere.show_all()
def main(self):
gtk.main()
uyg = Uygulama()
uyg.main()
Burada gördüğünüz gibi, “HButtonBox()” haznesini oluşturma işlemi HBox()’u oluşturma işlemini aynısı. Ayrıca burada self.etiket1 ve self.etiket2’yi self.kutu’ya eklerken add() metodundan yararlanıyoruz. İsterseniz burada da pack_start() ve pack_end() metotlarını kullanabilirsiniz. Ama açıkçası HBoxButton() için add() gibi basit bir metot kullanmak yeterli olacaktır...
İsterseniz yukarıdaki kodlarda “self.kutu = gtk.HButtonBox()” satırını “self.kutu = gtk.HBox()” şeklinde değiştirip çalıştırın. HButtonBox() içine yerleştirilmiş düğmelerin HBox() içine yerleştirilmiş düğmelere göre farklı bir görünüme sahip olduğunu göreceksiniz. “gtk.HBox()” haznesini kullanarak bu şekilde bir görünüm elde etmek epey zordur. Dolayısıyla eğer istediğiniz görünüm buysa, gtk.HBox() ile cebelleşmek yerine doğrudan gtk.HButtonBox() haznesinden faydalanabilirsiniz...
Eğer HButtonBox() içine yerleştirdiğiniz düğmelerin konumuyla oynamak isterseniz, set_layout() adlı bir metot epey işinize yarayacaktır. Bu metodu şu şekilde kullanıyoruz:
import pygtk
pygtk.require20()
import gtk
class Uygulama(object):
def __init__(self):
self.pencere = gtk.Window(gtk.WINDOW_TOPLEVEL)
self.pencere.resize(300, 300)
self.pencere.connect("delete_event", gtk.main_quit)
self.kutu = gtk.HButtonBox()
self.kutu.set_layout(gtk.BUTTONBOX_SPREAD)
self.etiket1 = gtk.Button("Etiket 1")
self.etiket2 = gtk.Button("Etiket 2")
self.kutu.add(self.etiket1)
self.kutu.add(self.etiket2)
self.pencere.add(self.kutu)
self.pencere.show_all()
def main(self):
gtk.main()
uyg = Uygulama()
uyg.main()
Burada parantez içinde kullandığımız “gtk.BUTTONBOX_SPREAD” yerine kullanabileceğimiz birkaç farklı seçenek vardır elimizde:
gtk.BUTTONBOX_SPREAD : Düğmeleri ortalar
gtk.BUTTONBOX_START : Düğmeleri sola yaslar
gtk.BUTTONBOX_END : Düğmeleri sağa yaslar
gtk.BUTTONBOX_EDGE : Düğmeleri kenarlara yaslar
Bu parametreleri kullanarak, düğmeleri pencerenin farklı yerlerinde konumlandırabiliriz...
HButtonBox() dışında bir VButtonBox() diye bir şey vardır... Tahmin edebileceğiniz gibi, bu hazne HButtonBox()’un aksine düğmeleri düşey düzleme yerleştiriyor. VButtonBox()’un kullanımı ile HButtonBox()’un kullanımı aynıdır. Bunlar arasındaki tek fark bu iki haznenin düğmeleri pencere üzerinde konumlandırdığı yerdir.
Bununla ilgili küçük bir örnek yapalım:
import pygtk
pygtk.require20()
import gtk
class Uygulama(object):
def __init__(self):
self.pencere = gtk.Window(gtk.WINDOW_TOPLEVEL)
self.pencere.resize(300, 300)
self.pencere.connect("delete_event", gtk.main_quit)
self.kutu = gtk.VButtonBox()
self.kutu.set_layout(gtk.BUTTONBOX_END)
self.etiket1 = gtk.Button("Etiket 1")
self.etiket2 = gtk.Button("Etiket 2")
self.kutu.add(self.etiket1)
self.kutu.add(self.etiket2)
self.pencere.add(self.kutu)
self.pencere.show_all()
def main(self):
gtk.main()
uyg = Uygulama()
uyg.main()
Bu kodlar, pencere üzerindeki düğmeleri pencerenin dip kısmına yerleştirecektir...
Buraya kadar Pygtk ile ilgili öğrendiklerimizi kullanarak şöyle bir örnek uygulama yazabiliriz:
#-*-coding:utf-8-*-
import pygtk
pygtk.require20()
import gtk
class Uygulama(object):
def __init__(self):
#penceremizi oluşturalım
self.pencere = gtk.Window(gtk.WINDOW_TOPLEVEL)
#penceremiz için bir başlık belirleyelim
self.pencere.set_title("Emin misiniz?")
#penceremizi boyutlandıralım
self.pencere.resize(150, 150)
#penceremizin kenar çizgisi ile öğeler arasında
#25 piksellik boşluk bırakalım.
self.pencere.set_border_width(25)
#penceremizi ekranın tam ortasında konumlandıralım
self.pencere.set_position(gtk.WIN_POS_CENTER)
#penceremizin "x" düğmesine basıldığında penceremiz
#sağlıklı bir şekilde kapansın...
self.pencere.connect("delete_event", gtk.main_quit)
#etiketimizi belirliyoruz
self.soru = gtk.Label("Çıkmak istediğinizden emin misiniz?")
#"Vazgeç" düğmesini oluşturalım
self.iptal = gtk.Button("Vazgeç")
#"Vazgeç" düğmesine tıklandığında "fonk" adlı
#fonksiyonumuz çalışsın. connect() metodunun üçüncü
#parametresine düğmemizin adını yazıyoruz.
self.iptal.connect("clicked", self.fonk, "Vazgeç")
#"Çık" adlı düğmemiz...
self.terket = gtk.Button("Çık")
#Bu düğmeyi de "fonk" adlı fonksiyona bağlıyoruz.
#Yine üçüncü parametre olarak düğme adını yazıyoruz.
self.terket.connect("clicked", self.fonk, "Çık")
#dikey kutumuz... Öteki öğelerle arasına 10
#piksel boşluk bırakıyoruz.
self.vbox = gtk.VBox(spacing=10)
#dikey kutumuzu paketliyoruz. Bu kutu içinde "soru" adlı
#pencere aracımız yer alacak. Ayrıca "expand" ve "fill"
#parametrelerine "False" değerini vererek pencere aracımızın
#boyutlandırma işleminden etkilenmemesini sağlıyoruz.
self.vbox.pack_start(self.soru, expand=False, fill=False)
#Şimdi de bir adet HButtonBox() haznesi oluşturuyoruz...
self.hbut = gtk.HButtonBox()
#HButtonBox() haznesini doğruca VBox() haznesinin içine
#yerleştiriyoruz. Unutmayın, ana pencereye yalnızca tek
#bir pencere aracı eklenebilir!...
self.vbox.pack_start(self.hbut)
#HButtonBox() içine iptal ve terket düğmelerini yerleştirelim.
self.hbut.add(self.iptal)
self.hbut.add(self.terket)
#HButtonBox() içindeki düğmeleri kutu içine ortalıyoruz
self.hbut.set_layout(gtk.BUTTONBOX_SPREAD)
#VBox() haznesini doğrudan pencere üzerine yerleştiriyoruz.
self.pencere.add(self.vbox)
#Son olarak bütün pencere araçlarını gösteriyoruz
self.pencere.show_all()
def fonk(self, penar, data):
#Ana fonksiyonumuz... Burada kullanıcının hangi
#düğmeye bastığını komut satırında göstereceğiz
#Bunun için, connect() metoduna üçüncü parametre
#olarak eklediğimiz veriyi kullanacağız.
print "%s düğmesine basıldı"%data
#Eğer kullanıcı "Çık" adlı düğmeye basarsa
#komut satırına "Programdan çıkılıyor..."
#yazdıralım ve programı kapatalım
if data == "Çık":
print "Programdan çıkılıyor..."
gtk.main_quit()
#Eğer kullanıcının bastığı düğme "Çık" değilse
#"İşlem iptal edildi!..." çıktısı veriyoruz...
else:
print "İşlem iptal edildi!..."
def main(self):
gtk.main()
uyg = Uygulama()
uyg.main()
Bu kodlar içinde özellikle dikkat etmemiz gereken kısım, iki farklı hazneyi (VBox ve HButtonBox) pencere üzerine nasıl yerleştirdiğimizdir. Gördüğünüz gibi, haznelerden birini ana pencere üzerine yerleştirirken (VBox), ötekini de öbür haznenin içine yerleştirdik (HButtonBox). Çünkü, ana pencere üzerine hem VBox’u, hem de HButtonBox’u aynı anda yerleştiremeyiz. Ana pencere sadece tek bir pencere aracı alabilir...
Bu arada kullandığınız konsol Türkçe karakterleri düzgün gösteremiyorsa yukarıdaki kodlarda yer alan karakter dizilerini unicode olarak tanımlamak işinize yarayabilir. Yani mesela:
print u"Programdan çıkılıyor..."
print u"İşlem iptal edildi!..."
...şeklinde karakter dizilerinin önüne “u” harfi getirebilirsiniz...