2. Pencere İşlemleri

Pygtk ile çalışabilmek için gereken temel bilgileri bir önceki bölümde verdiğimize göre artık asıl konumuza gelebiliriz. Bu bölümde Pygtk’yi kullanarak nasıl pencere oluşturacağımızı, oluşturduğumuz bu pencereyi nasıl şekillendirebileceğimizi inceleyeceğiz.

Bu bölümde inceleyeceğimiz ilk konu, boş bir pencere oluşturmak... O halde hiç gecikmeden yolumuza devam edelim.

2.1. Pencere Oluşturmak

Arayüz programlamada en temel konu, içi boş da olsa çalışan bir pencere oluşturabilmektir. İşte biz de bu bölümde bu en temel konuya değineceğiz.

Pygtk ile boş bir pencere oluşturmak için şu kodları yazıyoruz:

import gtk

pencere = gtk.Window()
pencere.show()

gtk.main()

Gördüğünüz gibi, Pygtk ile sadece dört satır yazarak boş bir pencere meydana getirebiliyoruz. Şimdi biz bu satırları tek tek inceleyerek, durumu olabildiğince anlaşılır bir hale getirmeye çalışacağız...

İlk satırda gördüğümüz “import gtk” kodu, ana modülümüz olan “gtk”yi içe aktarmamızı sağlıyor. Bu modülü mutlaka içe aktarmamız gerekir. Aksi halde yazacağımız kodlar hata vermekten başka bir işe yaramayacaktır.

Daha sonraki satırda “pencere = gtk.Window()” biçiminde bir ifade görüyoruz. Burada gtk modülünün Window() adlı fonksiyonunu çağırdık ve buna “pencere” adını verdik. Bu satır bizim boş bir pencere oluşturmamızı sağlıyor. Ama bu, oluşturduğumuz pencerenin ekranda görünmesi için yeterli olmayacaktır. Oluşturduğumuz pencerenin ekranda görünmesi için ilk olarak “pencere.show()” satırı yardımıyla bir de “penceremizi göstermemiz” gerekiyor.

Aslında şimdiye kadar penceremizi ekranda gösterebilmek için yapmamız gereken her şeyi yaptık. Ama henüz programımızın kendisini başlatacak kodu yazmadık. Pencerenin ekranda görünebilmesi için bir adım daha atmamız gerekecek. Bir Pygtk uygulamasının hayat bulabilmesi için gereken kod “gtk.main()”dir. Bunu da yukarıdaki kodlarda en son satıra yazdık.

Burada şunu bilmemiz gerekiyor: “gtk.Window()”, pencere oluşturmamızı sağlayan koddur. “pencere.show()” oluşturduğumuz bu pencereyi arayüz üzerinde gösterebilmek için gereklidir. “gtk.main()” satırı ise genel olarak uygulamanın bütününe hayat verme işlevi görür. Dolayısıyla uygulamanın bütününe hayat vermediğiniz sürece sadece pencerenin ekranda görünmesini sağlamak işinize yaramayacaktır...

Yukarıda yazdığımız kod ekrana boş bir pencere açmamızı sağlasa da aslında bu işi yapmak için standart yol değildir. Bir Pygtk uygulaması yazarken, yapmak istediğimiz asıl işi yapan kodları yazmanın yanısıra bazı başka hususları da göz önünde bulundurmamız gerekir. Mesela bir önceki bölümde bahsettiğimiz, “eski Pygtk sürümü” meselesi... Pygtk uygulamalarında, sistemdeki Pygtk sürümünü kontrol etmek oldukça standartlaşmış bir uygulamadır. O yüzden isterseniz biz de bu standarda uyup kodlarımızı biraz düzenleyelim:

import pygtk
pygtk.require20()
import gtk

pencere = gtk.Window(gtk.WINDOW_TOPLEVEL)
pencere.show()

gtk.main()

Burada yeni olarak, ilk baştaki iki satırı görüyoruz:

import pygtk
pygtk.require20()

Bu iki satırın her zaman en başa yazılması gerekir. Daha doğrusu bunları mutlaka gtk modülünden önce içe aktarmalıyız... Burada ilk satır pygtk adlı modülü içe aktarıyor. “pygtk.require20()” satırı ise, programımız için Pygtk’nin 2.x sürümünü kullanmak istediğimizi belirtiyor. Böylelikle, eğer sistemimizde mesela Pygtk’nin 1.x numaralı bir sürümü varsa, programımızın yanlışlıkla o sürümle açılmasını engellemiş oluyoruz...

Bu iki satırın bazı programlarda şöyle yazıldığını da görebilirsiniz:

import pygtk
pygtk.require("2.0")

İsterseniz bu yazım şeklini de benimseyebilirsiniz, ama yeni kodlarda artık genellikle “pygtk.require20()” biçimi tercih ediliyor.

Yukarıdaki kodlardaki başka bir yenilik ise “gtk.WINDOW_TOPLEVEL” parametresi. Bu parametre, penceremizin, bir pencerenin sahip olması gereken bütün özellikleri taşımasını sağlar. Biz bu parametreyi yazmasak da Pygtk varsayılan olarak o parametre yazılmış gibi davranacaktır... Dolayısıyla bu olmazsa penceremiz bozuk görünmez, ama yine de bu parametreyi kullanmak işimizi sağlama almamızı sağlar... Bu parametrenin tam olarak ne işe yaradığını anlamak için isterseniz “gtk.WINDOW_TOPLEVEL” yerine, “gtk.WINDOW_POPUP” yazarak programı çalıştırmayı deneyebilirsiniz. Bu şekilde oluşturulan pencerenin başlık çubuğu olmayacaktır. Dolayısıyla bu pencereyi ne sürükleyebilirsiniz, ne de kapatabilirsiniz... Böyle bir pencere oluşturmanın gerektiği yerler de vardır, ama şimdi değil... Bu pencereyi kapatmak için CTRL+C veya CTRL+Z tuşlarına basmanız gerekiyor...

Yukarıdaki kodları kullanarak gayet başarılı bir şekilde ilk penceremizi oluşturduk. Ama itiraf etmek gerekirse, Pygtk uygulamalarının yukarıdaki şekilde yazıldığı pek görülmez. Özellikle internet üzerinde bulacağımız kaynaklar, kodları hep sınıflı yapı içinde gösteriyor. Hem kodlarımızın daha düzenli olması, hem sonradan kodlarımızın bakımını kolaylaştırmak hem de internet üzerindeki kaynaklardan daha verimli yararlanabilmek için biz de bu belgede kodlarımızı sınıflı yapı içinde sunmayı tercih edeceğiz. O halde yukarıdaki kodları standart bir Pygtk uygulaması haline nasıl getireceğimize bakalım:

import pygtk
pygtk.require20()
import gtk

class IlkPencere(object):
    def __init__(self):
        self.pencere = gtk.Window(gtk.WINDOW_TOPLEVEL)
        self.pencere.show()

    def main(self):
        gtk.main()

ilk = IlkPencere()
ilk.main()

Gördüğünüz gibi, sınıfsız kodları sınıflı bir yapıya çevirmek o kadar da zor değil... Önce “IlkPencere” adında bir sınıf oluşturuyoruz. Sınıfımız, Python’daki yeni tip sınıfların gerektirdiği şekilde “object” sınıfını miras alıyor... Bu arada, eğer sınıflı yapılar konusunda eksikleriniz varsa Nesne Tabanlı Programlama konusuna göz gezdirmek isteyebilirsiniz...

Sınıfımızı tanımladıktan sonra, ilk olarak bir “__init__” fonksiyonu yazıyoruz. Programımız çalışmaya başlar başlamaz, bu fonksiyon içinde yer alan kodlar işletilecektir. Bu fonksiyon içinde boş penceremizi oluşturacak kodları yazıyoruz.

Programımızın dinamosu niteliğindeki “gtk.main()” için ise ayrı bir fonksiyon yazdık. Bu fonksiyonu “main()” olarak isimlendirdik. Elbette siz bu fonksiyona daha farklı bir isim verebilirsiniz. Ama açıkçası, bu fonksiyon adı da tıpkı “self” gibi kemikleşmiş bir adlandırmadır. Yazdığınız kodları okuyan kişilerin bir an da olsa duraksamaması için bu fonksiyonu sizin de “main()” olarak adlandırmanızı tavsiye ederim.

Kapanış bölümünde “IlkPencere()” adlı sınıfımızı örnekliyoruz (instantiate). Sınıf örneğimizin adı “ilk”. Sınıfımızı bu şekilde örnekledikten sonra, “ilk.main()” ifadesi yardımıyla “IlkPencere” adlı sınıfımızın içindeki “main()” fonksiyonunu çağırıyoruz. Böylece programımız çalışmaya başlıyor...

Yukarıda yazdığımız kodları çalıştırmak için, programımızın bulunduğu dizin içinde bir komut satırı açıp, orada şu komutu veriyoruz (programımızı “deneme.py” olarak adlandırdığımızı varsayarsak...)

python deneme.py

Bu arada, Pygtk henüz Python’un 3.x sürümleriyle uyumlu değildir. Dolayısıyla programımızı çalıştırmak için Python’un 2.x sürümlerinden birini kullanacağız. Özellikle Windows kullanıcılarının, “python” komutunu verdiklerinde Python’un hangi sürümünün çalıştığına dikkat etmeleri gerekiyor...

Bu noktada bir şey dikkatinizi çekmiş olmalı: Programlarımızı başarıyla çalıştırabiliyoruz, ama aynı başarıyla kapatamıyoruz!... Pencere üzerinde çarpı işaretine tıkladığımızda penceremiz kayboluyor, ama aslında programımız alttan alta çalışmaya devam ediyor. Programı komut satırından çalıştırdıysanız, programı kapattıktan sonra imlecin alt satıra geçmemiş olmasından bunu anlayabilirsiniz... Bu durumda programı kapatmak için CTRL+C veya CTRL+Z tuşlarına basmamız gerekiyor...

Elbette programımız görünmediği halde alttan alta çalışmaya devam etmesi tercih edilecek bir şey değil. Yazdığımız programların kapanmasını nasıl sağlayabileceğimizi bir-iki bölüm sonra inceleyeceğiz. Biz şimdilik CTRL+C veya CTRL+Z tuşlarını kullanmayı sürdürelim...

2.2. Pencereye Başlık Eklemek

Bir önceki bölümde boş bir pencereyi nasıl oluşturacağımızı görmüştük. İsterseniz artık oluşturduğumuz pencereyi biraz düzenlemeye, bu pencereye yeni özellikler eklemeye girişelim. Mesela oluşturduğumuz pencereye bir başlık ekleyelim...

Pygtk ile yazılmış bir programa başlık ekleme işi set_title() metoduyla yapılır. Gelin isterseniz hemen bununla ilgili küçük 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.set_title("Bu bir başlıktır!")
        self.pencere.show()

    def main(self):
        gtk.main()

uyg = Uygulama()
uyg.main()

Eğer istediğimiz şey bir pencerenin başlığını ayarlamak değil de başlığın ne olduğunu bulmak ise, get_title() metodu işimize yarayacaktı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.set_title("Bu bir başlıktır!")
        print self.pencere.get_title()
        self.pencere.show()

    def main(self):
        gtk.main()

uyg = Uygulama()
uyg.main()

Programımızı çalıştırdığımızda, pencere başlığının konsol ekranına yazıldığını göreceğiz... Eğer pencere başlığı komut satırına yazılırken Türkçe harfler düzgün görünmüyorsa ilgili satırı şöyle yazabilirsiniz:

print unicode(self.pencere.get_title(), "utf-8")

Burada Türkçe karakterleri düzgün gösterebilmek için pencere başlığını Unicode kod çözücülerinden biri olan “utf-8” ile kodladık. Eğer Unicode konusu ilginizi çekiyorsa veya bu konuda eksikleriniz olduğunu düşünüyorsanız http://www.istihza.com/py2/unicode.html adresindeki makalemizi inceleyebilirsiniz...

Gördüğünüz gibi, penceremizin başlığını set_title() metodunu kullanarak kolayca belirleyebiliyoruz. get_title() metodunu kullanarak ise penceremizin başlığının ne olduğunu öğrenebiliyoruz. Ancak burada dikkatimizi çeken başka bir nokta var. Pencere boyutları tam istediğimiz gibi değil. Mesela pencere başlığını görebilmek için pencereyi elle boyutlandırmamız gerekiyor. İşte bir sonraki bölümümüzün konusu pencere boyutlarını elle değil de kodlar yardımıyla ayarlamak...

2.3. Pencere Boyutunu Ayarlamak

Pygtk ile oluşturduğumuz bir pencere varsayılan olarak 200x200 piksel boyutunda olacaktır. Ama bizim ihtiyacımız olan pencere boyutu her zaman bu olmayabilir. Eğer Pygtk penceresinin boyutunu kendimiz belirlemek istersek, resize() adlı metottan 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.set_title("Bu bir başlıktır!")
        self.pencere.resize(500, 500)
        self.pencere.show()

    def main(self):
        gtk.main()

uyg = Uygulama()
uyg.main()

Bu şekilde, 500x500 piksel boyutunda bir pencere oluşturmuş olduk. resize() metodunun formülü şöyledir:

pencere.resize(genişlik, yükseklik)

Dolayısıyla, parantez içinde parametre olarak vereceğimiz ilk değer pencerenin genişliğini, ikinci değer ise pencerenin yüksekliğini belirleyecektir...

Eğer oluşturduğumuz pencerenin tam ekran olarak açılmasını istersek maximize() adlı metottan yararlanabiliriz:

#-*-coding: utf-8 -*-

import pygtk
pygtk.require20()
import gtk

class Uygulama(object):
    def __init__(self):
        self.pencere = gtk.Window(gtk.WINDOW_TOPLEVEL)
        self.pencere.set_title("Bu bir başlıktır!")
        self.pencere.maximize()
        self.pencere.show()

    def main(self):
        gtk.main()

uyg = Uygulama()
uyg.main()

Eğer programımızın çalışması esnasındaki bir aşamada tam ekran halindeki bir pencereyi tam ekran konumundan çıkarmak istersek de unmaximize() metodunu kullanabiliriz...

Pencerenin boyutunu değiştirmeyi öğrendik. Peki ya bu pencerenin konumunu değiştirmek istersek ne yapacağız? İsterseniz onu da bir sonraki bölümde anlatalım...

2.4. Pencere Konumunu Ayarlamak

Pencere boyutunu ayarlamayı bir önceki bölümde öğrenmiştik. Gelelim penceremizin konumunu ayarlamaya... Bu işi move() metodunu kullanarak gerçekleştireceğiz:

#-*-coding: utf-8 -*-

import pygtk
pygtk.require20()
import gtk

class Uygulama(object):
    def __init__(self):
        self.pencere = gtk.Window(gtk.WINDOW_TOPLEVEL)
        self.pencere.set_title("Bu bir başlıktır!")
        print self.pencere.get_title()
        self.pencere.resize(500, 500)
        self.pencere.move(700, 100)
        self.pencere.show()

    def main(self):
        gtk.main()

uyg = Uygulama()
uyg.main()

Burada parantez içindeki ilk rakam pencerenin x düzlemindeki konumunu (soldan sağa), ikinci rakam ise y düzlemindeki konumunu gösteriyor (yukarıdan aşağıya).

Eğer penceremizi ekranın tam ortasında konumlandırmak istersek set_position() metodundan 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.set_title("Bu bir başlıktır!")
        print self.pencere.get_title()
        self.pencere.resize(500, 500)
        self.pencere.set_position(gtk.WIN_POS_CENTER)
        self.pencere.show()

    def main(self):
        gtk.main()

uyg = Uygulama()
uyg.main()

Yukarıdaki kodlar, oluşturduğumuz pencerenin, ekranın ortasında açılmasını sağlayacaktır. Burada gtk.WIN_POS_CENTER parametresi yerine şunları da kullanabiliriz:

gtk.WIN_POS_NONE:

Pencere konumu üzerinde herhangi bir değişiklik yapılmayacağını belirtir.

gtk.WIN_POS_CENTER:

Pencereyi ekranın ortasına yerleştirir.

gtk.WIN_POS_MOUSE:

Pencere, farenin o anda bulunduğu konumda açılır.

gtk.WIN_POS_CENTER_ALWAYS:

Pencerenin boyutu değişse de, pencereyi hep ekranın ortasında tutar.

gtk.WIN_POS_CENTER_ON_PARENT:

Eğer ikinci bir pencere varsa bu pencerenin ana pencereyi ortalamasını sağlar.

Pygtk’da pencere konumunu belirlemek için kullandığımız iki farklı metot olduğuna dikkat edin. Bunlardan birincisi move(), ikincisi ise set_position() metodudur... move() metodunu, pencereyi ekran üzerinde özel bir konuma getirmek istediğimizde kullanıyoruz. set_position() metodu ise pencereyi belli konumlara yerleştirmemizi sağlıyor. Örneğin bir pencereyi soldan 300, üstten ise 500. piksele yerleştirmek istersek move() metodunu kullanacağız. Ama eğer pencereyi mesela ekranın ortasına yerleştireceksek, set_position() metodundan yararlanacağız.

2.5. Pencereleri Sağlıklı bir Şekilde Kapatmak

Önceki bölümlerde, Pygtk’yi kullanarak boş bir pencere oluşturmayı, pencereye bir başlık eklemeyi, oluşturduğumuz pencereyi konumlandırmayı ve boyutlandırmayı öğrenmiştik. Ama farkettik ki oluşturduğumuz bir pencereyi kapatmaya çalıştığımızda bir sorunla karşı karşıyayız. Sorun şu ki, aslında oluşturduğumuz pencereyi kapattığımızda programımız kapanmıyor. Programdan çıkmak için CTRL+C veya CTRL+Z tuşlarına basarak programı kapanmaya zorlamamız gerekiyor... Bu bölümde, bir Pygtk uygulamasını sağlıklı bir şekilde nasıl kapatabileceğimizi göreceğiz. İsterseniz öncelikle tekrar boş bir pencere oluşturalım:

import pygtk
pygtk.require20()
import gtk

class Pencere(object):
    def __init__(self):
        self.pencere = gtk.Window(gtk.WINDOW_TOPLEVEL)
        self.pencere.show()

    def main(self):
        gtk.main()

uyg = Pencere()
uyg.main()

Yazdığımız bu kodların başarılı bir şekilde boş pencere oluşturacağını biliyoruz, ama aynı başarıyla kapanmayacağını da biliyoruz... Şimdi bu kodlara şöyle bir ekleme yapalım:

import pygtk
pygtk.require20()
import gtk

class Pencere(object):
    def __init__(self):
        self.pencere = gtk.Window(gtk.WINDOW_TOPLEVEL)
        self.pencere.connect("delete_event", gtk.main_quit)
        self.pencere.show()

    def main(self):
        gtk.main()

uyg = Pencere()
uyg.main()

Buraya self.pencere.connect("delete_event", gtk.main_quit) diye yeni bir satır ekledik. Bu kodları çalıştırdığımızda, pencerenin çarpı düğmesine bastığımız zaman programımız düzgün bir şekilde kapanacaktır. Bu kodların getirdiği değişikliği konsoldaki imlecin durumundan da görebiliriz. Artık CTRL+C veya CTRL+Z tuşlarına basmak zorunda kalmadan programımızı sonlandırabiliyoruz.

Burada yaptığımız şey, penceremizin çarpı tuşuna bir görev atamaktan ibaret. Pencere üzerindeki çarpı tuşuna bastığımız anda, “gtk” modülünün main_quit() adlı metodu devreye girip programımızın kapanmasını sağlayacak. Pygtk’da “pencerenin çarpı tuşuna basma hareketi”, “delete_event” olarak adlandırılır. Dolayısıyla yukarıdaki yeni satırı Türkçe olarak şöyle ifade edebiliriz:

pencere.bağla("çarpıya_basma_hareketi", gtk.programı_kapat)

Yukarıdaki Türkçe ifadeden anladığımız gibi, “bağla” kelimesine karşılık gelen “connect” ifadesi, temelde pencere aracını bir göreve “bağlıyor”... Bu görevi de parantez içinde tanımlıyoruz. Buna göre, pencere aracına bağladığımız görev, “üzerindeki çarpıya basıldığında” (delete_event), “programdan tamamen çıkmak” (gtk.main_quit)

Yukarıdaki kodlarda biz gtk.main_quit() metodunu doğrudan satır içine yazdık. Kolay yöntem budur. Ama eğer istersek bunu ayrı bir fonksiyon olarak da tanımlayabiliriz:

import pygtk
pygtk.require20()
import gtk

class Pencere(object):
    def __init__(self):
        self.pencere = gtk.Window(gtk.WINDOW_TOPLEVEL)
        self.pencere.connect("delete_event", self.kapat)
        self.pencere.show()

    def kapat(self, penar, event):
        gtk.main_quit()

    def main(self):
        gtk.main()

uyg = Pencere()
uyg.main()

Burada “kapat” adlı yeni bir fonksiyon tanımlayıp, connect() metodu içinde doğrudan bu fonksiyona gönderme yapıyoruz. Ayrıca “kapat” fonksiyonu içinde birtakım parametreler belirlediğimize de dikkat edin. Bir “olay” (event) tanımlarken (mesela “delete_event” bir olaydır), olaya ait fonksiyonun en az iki parametre alması gerekir. Bu parametrelerden biri “pencere aracına”, öteki ise “olayın kendisine” gönderme yapar. Bizim örneğimizde pencere aracına gönderme yapan parametreye “penar”, olaya gönderme yapan parametreye ise “event” adını verdik. Siz bu parametreleri istediğiniz şekilde adlandırabilirsiniz. Ama özellikle “event” parametresinin adını değiştirmemenizi öneririm. Çünkü bu da tıpkı “self” ve “main” gibi yerleşmiş bir ifadedir...

Böylelikle Pygtk kullanılarak yazılmış en basit uygulamanın nasıl olması gerektiğini öğrenmiş olduk. Basit bir Pygtk uygulamasında yer alan temel aşamaları şöyle bir gözden geçirelim:

Öncelikle gerekli modülleri içe aktarıyoruz:

import pygtk
pygtk.require20()
import gtk

Burada içe aktardığımız pygtk modülünü, sürüm kontrolü için kullandık. “pygtk.require20()” satırı, sistemimizde birden fazla pygtk sürümü olması durumunda, programımızı bu sürümlerden hangisiyle çalıştırmak istediğimizi belirlememizi sağlıyor. Modern Pygtk uygulamaları “2.x” sürümleri kullanılarak yazılır. Dolayısıyla biz de bu satır yardımıyla, kullanılacak sürümü “2.x” olarak belirliyoruz. Son olarak da gtk modülünü içe aktardık. “gtk”, programımızda asıl işi yapan modüldür.

Ardından program kodlarımızı yerleştirmek için bir sınıf tanımlıyoruz. Bu sınıf, Python’daki yeni tipte sınıfların gerektirdiği şekilde mutlaka bir başka sınıftan miras almak durumunda... Bizim burada özel olarak miras almak istediğimiz bir sınıf bulunmadığı için, “object” sınıfını miras alarak bu aşamayı geçiyoruz:

class Pencere(object):

Tanımladığımız sınıfın bir “__init__” fonksiyonu olması gerekiyor. Programımız ilk çalışmaya başladığı anda sahip olacağı özellikleri bu __init__ fonksiyonu içinde belirliyoruz. Mesela pencereyi ve öteki araçları bu fonksiyon içinde tanımlayabiliriz. Henüz pencerenin kendisi dışında bir araç belirlemediğimiz için buraya şimdilik sadece boş pencereyi oluşturacak kodları yazıyoruz:

def __init__(self):
    self.pencere = gtk.Window(gtk.WINDOW_TOPLEVEL)
    self.pencere.connect("delete_event", self.kapat)
    self.pencere.show()

Burada pencere oluşturmak için gtk modülünün Window() fonksiyonundan yararlandığımıza dikkat edin. Ayrıca oluşturduğumuz pencerenin, bir pencerenin sahip olması gereken bütün özellikleri barındıracağından emin olmak için yine gtk modülünün WINDOW_TOPLEVEL niteliğini de parametre olarak gtk.Window fonksiyonu içinde belirtiyoruz.

Ardından, yazdığımız programın düzgün kapanmasını sağlamak için pencerenin çarpı tuşuna bir görev atıyoruz. Burada connect() adlı fonksiyondan faydalanarak, çarpı işaretini, daha sonra tanımlayacağımız kapat() adlı fonksiyona bağlıyoruz. Pygtk’da bu “çarpı tuşuna basma hareketi” “delete_event” olarak adlandırılır... Ayrıca bu “delete_event”, teknik dille ifade etmek gerekirse, bir “olay”dır (event).

Sonraki satırda gördüğümüz “self.pencere.show()” ifadesi de oldukça önemlidir. Eğer bu satırı yazmazsak, oluşturduğumuz pencere ekranda görünmez... show() metodunu kullanarak penceremizi ekranda gösteriyoruz.

Sıra geldi programı kapatma fonksiyonumuzu tanımlamaya... Bu işlemi şu kodlar yardımıyla yapıyoruz:

def kapat(self, penar, event):
    gtk.main_quit()

Burada önemli nokta, kapat fonksiyonunun en az iki parametre alması... Biz birinci parametreyi “penar”, ikinci parametreyi ise “event” olarak adlandırdık. Siz istediğiniz adları verebilirsiniz bu parametrelere. Ama en azından “event” kelimesini değiştirmemenizi tavsiye ederim. Burada “penar” parametresi, çarpı tuşuna basma hareketinin ait olduğu pencere aracına işaret ediyor (yani pencerenin kendisine...). “event” parametresi ise olayın kendisine atıfta bulunuyor (yani “delete_event” adlı olaya...). Programımızı sonlandırmak için ise “gtk” modülünün main_quit() adlı metodundan yararlanıyoruz.

Eğer “penar” ve “event” parametrelerinin tam olarak neye işaret ettiğini daha net bir şekilde görmek isterseniz fonksiyonunuzu şöyle yazabilirsiniz:

def kapat(self, penar, event):
    print type(penar)
    print type(event)
    gtk.main_quit()

Fonksiyonunuzu bu şekilde yazıp programı çalıştırdığınızda ve pencerenin çarpı simgesine bastığınızda komut satırında şu çıktıları göreceksiniz:

<type 'gtk.Window'>
<type 'gtk.gdk.Event'>

Demek ki gerçekten de “penar” parametresi “gtk.Window()” aracını (yani penceremizi); “event” parametresi ise “gtk.gdk.Event” adlı olayı (bizim örneğimizde “delete_event” adlı olayı) gösteriyor...

Programımızın asıl itici gücü olan fonksiyonu ise şöyle yazdık:

def main(self):
    gtk.main()

Bu fonksiyon, programımızın çalışmaya başladığını gösteriyor. Bir başka ifadeyle, bu fonksiyon yardımıyla programımıza hayat öpücüğü veriyoruz...

Son olarak, yazdığımız sınıfı örnekliyoruz:

uyg = Pencere()

Eğer sınıf içinde belirttiğimiz main() fonksiyonunu bir motor olarak düşünürsek, bu motorun pervanesini de şu kodla döndürüyoruz:

uyg.main()

2.6. Pencerelere Simge Eklemek

Bildiğiniz gibi, pek çok programda pencerenin sol üst köşesinde programa ait ufak bir simge yer alır. Eğer programcı, yazdığı bir program için herhangi bir simge belirlemezse pencerenin sol üst köşesi boş kalacaktır. İşte simdi biz o alanı nasıl kendi zevkimize göre doldurabileceğimizi öğreneceğiz.

Yazdığınız bir programın simgesini pencerenin sol üst köşesine yerleştirebilmek için Pygtk’de set_icon_from_file() adlı bir metottan yararlanabilirsiniz. Örneğin:

#-*-coding: utf-8-*-
import pygtk
pygtk.require20()
import gtk

class Uygulama(object):
    def __init__(self):
        self.pencere = gtk.Window(gtk.WINDOW_TOPLEVEL)
        self.pencere.resize(500, 500)
        self.pencere.set_position(gtk.WIN_POS_CENTER)
        self.pencere.connect("delete_event", gtk.main_quit)
        self.pencere.set_title("PROGRAM")
        self.pencere.set_icon_from_file("falanca.png")
        self.pencere.show()

    def main(self):
        gtk.main()

uyg = Uygulama()
uyg.main()

set_icon_from_file() adlı metot bilgisayarınızda kayıtlı olan bir resmi alıp uygulama simgesi haline getirecektir. Eğer yukarıdaki kodları çalıştırdığınız halde pencerenin sol üst köşesinde herhangi bir simge görmüyorsanız, bunun sorumlusu kullandığınız sistem temasıdır. Mesela Ubuntu’da “Human-Clearlooks” adlı tema uygulama simgelerini göstermez. Ama eğer uygulamanızı simge durumuna küçültecek olursanız, kullandığınız resmi panel üzerinde görebilirsiniz... Ayrıca kullandığınız temayı değiştirerek de uygulamaların simgelerini görünür hale getirebilirsiniz.

2.7. Boyutlandırılamayan Pencereler Oluşturmak

Bir Pygtk penceresi normal şartlar altında kullanıcı tarafından boyutlandırılabilir. Yani bir pencerenin sağını solunu çekerek bu pencereyi büyütebilir veya küçültebilirsiniz. Ama siz yazdığınız bazı programlarda kullanıcının pencereyi boyutlandırmasına müsaade etmek istemiyor olabilirsiniz. Mesela bir hesap makinesi uygulamasında programcı sabit bir pencere boyutu belirleyip bu pencere boyutunun değiştirilmesini engellemek isteyebilir... Eğer siz de yazdığınız programların boyutlandırılmasını istemiyorsanız Pygtk’deki set_resizable() adlı metottan yararlanabilirsiniz:

#-*-coding: utf-8-*-
import pygtk
pygtk.require20()
import gtk

class Uygulama(object):
    def __init__(self):
        self.pencere = gtk.Window(gtk.WINDOW_TOPLEVEL)
        self.pencere.set_size_request(500, 500)
        self.pencere.set_resizable(False)
        self.pencere.set_position(gtk.WIN_POS_CENTER)
        self.pencere.connect("delete_event", gtk.main_quit)
        self.pencere.set_title("BOYUTLANDIRILAMAZ")
        self.pencere.show()

    def main(self):
        gtk.main()

uyg = Uygulama()
uyg.main()

Burada dikkatimizi çeken iki nokta var. Birincisi, daha önce pencereleri boyutlandırmak için kullandığımız resize() metodu yerine burada set_size_request() adlı başka bir metot kullandık. İkincisi, pencerenin elle boyutlandırılmasını engellemek için set_resizable() adlı bir metoda “False” parametresi verdik.

Bu kodlarda gördüğümüz set_size_request() metodu Pygtk’de pencere boyutlandırmanın başka bir yoludur. Burada bu metot yardımıyla penceremizin boyutunu 500x500 olarak ayarladık. resize() metodu ile set_size_request() metodu arasındaki farkı Pencere Araçlarının Yerleşimi adlı bölümde inceleyeceğiz.

Burada bizi asıl ilgilendiren, set_resizable() metodudur. Bu metodun varsayılan değeri “True”dir ve bu değere sahip olduğunda pencerelerimiz elle rahatlıkla boyutlandırılabilir. Ama eğer biz bu metodun değerini “False” yapacak olursak, kullanıcılarımız artık bu pencereyi boyutlandıramaz.

2.8. Saydam/Şeffaf Pencereler Oluşturmak

Pygtk’de, oluşturduğunuz pencereleri saydam/şeffaf hale getirmek de mümkündür. Ancak bu işlev her işletim sisteminde aynı şekilde çalışmaz. Pygtk’de pencereleri şeffaflaştırmak için set_opacity() adlı bir metottan yararlanıyoruz. Mesela:

#-*-coding: utf-8-*-
import pygtk
pygtk.require20()
import gtk

class Uygulama(object):
    def __init__(self):
        self.pencere = gtk.Window(gtk.WINDOW_TOPLEVEL)
        self.pencere.set_size_request(500, 500)
        self.pencere.set_position(gtk.WIN_POS_CENTER)
        self.pencere.connect("delete_event", gtk.main_quit)
        self.pencere.set_title("ŞEFFAF")
        self.pencere.set_opacity(0.5)
        self.pencere.show()

    def main(self):
        gtk.main()

uyg = Uygulama()
uyg.main()

Burada şeffaflaştırma işini yerine getiren satır “self.pencere.set_opacity(0.5)”tir. set_opacity() metodu “0” ve “1” arası bir değer alır. Bu metodun değeri 0’a yaklaştıkça pencere daha da şeffaflaşacak, 1’e yaklaştıkça ise şeffaflığı azalacaktır.

Dediğimiz gibi, bu metodun platformlara göre bazı kısıtlamaları vardır. Örneğin Windows üzerinde bu metot her zaman çalışır. Ancak GNU/Linux’ta bu metodun çalışabilmesi için masaüstü efektlerinin veya “Compiz Fusion”un açık olması gerekir. Eğer Ubuntu kullanıyorsanız, bu metodu çalıştırabilmek için Sistem > Tercihler > Görünüm yolunu takip ederek Görsel efektler sekmesinde “extra” ayarını seçmeniz gerekiyor...

Bununla ilgili ufak bir örnek daha yapalım:

import pygtk
pygtk.require20()
import gtk
import time

class Uygulama(object):
    def __init__(self):
        self.pencere = gtk.Window(gtk.WINDOW_TOPLEVEL)
        self.pencere.set_title("DENEME")
        self.pencere.set_position(gtk.WIN_POS_CENTER)
        self.pencere.connect("destroy", gtk.main_quit)
        for i in range(11):
            while gtk.events_pending():
                gtk.main_iteration()

            self.pencere.set_opacity(i*0.1)
            self.pencere.show()
            time.sleep(0.1)

    def main(self):
        gtk.main()

uyg = Uygulama()
uyg.main()

Bu örnekte Pygtk penceresi yavaş yavaş şeffaftan görünüre geçecektir. Ancak set_opacity() metoduna ilişkin olarak yukarıda anlattıklarımızdan yola çıkarak, bu metoda çok fazla itibar edilmemesi gerektiğini söyleyebiliriz.

Böylece bir konuyu daha bitirmiş olduk. Dilerseniz şimdi bu noktaya kadar öğrendiğimiz bütün metotları ve bu metotların görevlerini kısaca listeleyelim:

gtk.Window()

Ana pencereyi oluşturmamızı sağlar. Şu parametreleri alır:

“gtk.WINDOW_TOPLEVEL”

“gtk.WINDOW_POPUP”

set_title()

Pencerelere başlık ekler.

get_title()

Pencere başlığının ne olduğunu söyler.

resize()

Pencere boyutunu ayarlar.

show()

Pencere araçlarını gösterir.

maximize()

Pencereleri tam ekran haline getirir.

unmaximize()

Pencereyi tam ekran konumundan çıkarır.

move()

Pencereleri özel bir konuma taşımamızı sağlar.

set_position()

Pencereleri belirli bir konuma taşımamızı sağlar. Bu metot şu parametrelerden birini alır:

“gtk.WIN_POS_NONE”,

“gtk.WIN_POS_CENTER”,

“gtk.WIN_POS_MOUSE”,

“gtk.WIN_POS_CENTER_ALWAYS”,

“gtk.WIN_POS_CENTER_ON_PARENT”

connect()

Pencerelere ve pencere araçlarına görev atamamızı sağlar.

main()

Programın çalışmasını sağlar.

main_quit()

Programdan çıkılmasını sağlar.

set_icon_from_file()

Pencerelere uygulama simgesi eklememizi sağlar.

set_size_request()

Pencereleri boyutlandırmanın başka bir yoludur.

set_resizable()

Pencerelerin elle boyutlandırılıp boyutlandırılamayacağını belirler.

set_opacity()

Pencerelerin şeffaflaşmasını sağlar.

Gördüğünüz gibi, Pygtk ile ilgili epey şey öğrendik. Öğrendiğimiz bu bilgiler sayesinde artık Pygtk’yi kullanarak boş bir pencere oluşturabiliyor ve bu boş pencerenin bazı niteliklerini değiştirebiliyoruz. Ama boş bir pencere oluşturmanın pek keyifli bir iş olmadığı ortada... O yüzden isterseniz, oluşturduğumuz pencereye başka öğeleri nasıl ekleyeceğimizi de öğrenelim.