Home Map Index Search News Archives Links About LF
[Top bar]
[Bottom bar]
Bu makalenin farklı dillerde bulunduğu adresler: English  Castellano  Deutsch  Francais  Turkce  

convert to palmConvert to PalmDoc

Hilaire Fernandes
tarafından Hilaire Fernandes

Yazar hakkında:

Hilaire Fernandes, Gnome masaüstleri için ücretsiz eğitim yazılımlarının gelişimini tanıtan bir organizasyon olan OFSET 'in ikinci başkanıdır. Ayrıca, ödül kazanan Dr.Geo adındaki etkileşimli geometri yazılımını yazmıştır ve şu sıralar Dr.Genius adında Gnome masaüstünde çalışan başka bir matematik eğitim yazılımı ile uğraşmaktadır.


İçerik:

Python ile Gnome Uygulamaları Geliştirme(Bölüm 1)

Çeviri : Özlem Erdaş

Gnome

Özet:

Bu makaleler serisi özellikle Gnome programlama ve GNU/Linux 'a yeni başlayanlar için yazılmıştır. Seçilen geliştirme dili Pyhon, C gibi derlemeli dillerde yaygın olan aşırı yükten kaçınmaktadır. Bu makaleyi okumadan önce Python programlama hakkında bir miktar bilgi gerekmektedir.


 

Gereken Araçlar:

Bu makalede tanımlanan programı çalıştırabilmek için en azından şuna ihtiyacınız var:

Pyhton-Gnome ve LibGlade 'i kaynaklardan yüklemek için:

./configure
make
make install

ufak bir hile olacaktır. (Daha fazla açıklama için
[  http://www.linuxgazette.com/issue38/pollman.html ] Ayrıca Python ortam değişkeni PYTHONPATH 'in Python-Gnome birimlerinin yüklendiği yola ayarlı olup olmadığını kontrol etmelisiniz. Bu yol /usr/local/lib/python1.5/site-packages ya da /usr/lib/python1.5/site-packages/ olabilir. Burada Gnome ve LibGlade için gerekli bütün bağlantıları bulursunuz, mesela libglade.py birimini orada bulabilirsiniz. PYTHONPATH 'i ayarlamak için .bash_profile 'a sadece şunu ekleyin:

PYTHONPATH=/usr/local/lib/python1.5/site-packages
export PYTHONPATH

Unutmayın ki bu değişken takımını elde etmek için Python kodunuzu bir terminalden çalıştırmanız gerekebilir.


 

Glade, LibGlade & Python etkileşimi

Glade, Damon Chaplin tarafından geliştirilen bir arayüz kurucusudur. Gnome/Gtk grafiksel kullanıcı arayüzlerinin grafiksel ve etkileşimli yapılarına izin verir. Glade'de oluşturulan arayüz bir xml dosyasında saklanabilir ya da doğrudan C kaynak ağacında yeralmak üzere C koduna ihraç edilebilir. Glade ayrıca arayüzün çeşitli kısımlarına iliştirilecek olan işleyicilerin-fonksiyonların- adlarının tanımlanmasına izin verir. Mesela belirli bir menü parçasına basıldığında çağrılacak olan fonksiyon (adı).

LibGlade, James Henstridge'in bir Glade xml dosyası tarafından temsil edilen arayüzü oluşturmak için yazmış olduğu bir kütüphanedir. Uygulama sadece xml dosyasından - genelde .glade uzantısıyla biten - haberdar olmayı gerektirir ve sonra LibGlade kütüphaneyi bundan oluşturabilir. James Henstridge ayrıca Gnome-Python paketinde bulunan LibGlade Python bağlantısını yazmıştır. LibGlade ayrıca .glade dosyasında tanımlanan işleyicicilerden Python kodunda tanımlanan fonksiyonlara otomatik-bağlantıya izin verir.

Aşağıdaki garfik genel mekanizmayı göstermektedir. Python bağlantısının nasıl uygulandığını anlamak için bazen PYTHONPATH 'te yerleşmiş Gtk, Gnome ve LibGlade Python birimlerine bakmak ve onları C Gtk/Gnome geliştirici dökümanlarla karşılaştırmak gerekir.

 

couleur adlı ilk örnek

Gnome-Python programlamaya bir ilk yaklaşım olarak, çocukların aynı renkteki şekilleri tanımasını gerektiren basit bir renk oyununu öneririm. Bu örnek grafiğe yöneliktir ve Gnome Canvas ve Gnome Uygulama Penceresi gibi Gnome'un güzel özelliklerini sunar. oyunun kuralları oldukça basittir: Oyun tahtası değişik renlere sahip 16 şekil - daireler, yıldızlar ve kareler - ile doldurulmuştur. Bu 16 şekil 8 çift özdeş renge bölünmüştür. Oyunu bitirmek için sadece bu 8 çifti başarıyla seçmek gerekir. Fikir edinmek için bu makalenin sonundaki kaynak koda bakmak ve sonra buradan tekrar başlamak isteyebilirsiniz.

 

Glade ile bir arayüz inşa etmek

Hünerli Aletler

Glade'i başlattıktan sonra iki pencereniz olacaktır. Birisi Palette adındaki hünerli alet kutusudur. Bu pencerede GTK+ Basic, GTK+ Additional ve Gnome içinden aletin türlerini seçebilirsiniz. Eğer Gnome aletiniz yoksa Glade, Gnome desteği olmadan derlenebilir. Kaynak Glade paketinin configure(yapılanması)'unu kontrol edin. configure --help konfigürasyon seçeneklerini açıklar.

Asıl alandaki öbür pencere yaratılan aletleri listeler.

Glade ile önce Gnome Uygulama Penceresini yaratacağız. Bu alet menu çubuğu ve alet çubuğu olan bir penceredir. Gnome Uygulama Penceresinin dibinde ayrıca bir durum çubuğu bulunur. Gnome Uygulama Penceresini yarattıktan sonra Widget Tree(alet ağacı) diyaloğunu açın (Glade'de görünüm menüsünde bulabilirsiniz). Şimdi bu alette tam olarak nelerin bulunduğunu keşfedebilirsiniz.

Bundan sonra Gnome uygulama aletinin asıl alanına bir kanvas ekleyin. properties(özellikler) diyaloğundan maksimal koordinatları 400'e, maksimal yükseklik ve genişliği de 400'e ayarlayın.


şimdi bir Gnome hakkında Diyaloğu oluşturun. Diyaloğun içeriğini Alet tabakasındaki properties(özellikler) diyaloğundan ayarlayabilirsiniz.

Bütün bu aletler Palette 'in Gnome kategorisinde yeralmaktadır.

Şimdi kullanılmayan ikon düğmelerini ve menu parçalarını kaldırın. Alet çubuğundaki Open(Aç) ve Save(Kaydet) ikon düğmelerini kaldırın. Sonra menü çubuğunu düzenleyin (farenin sağ tuşuyla tıklayıp edit menu(menüyü düzenle) 'yü seçin) ve File->New, File->Exit, Setting->Preferences ve Help->About hariç bütün menüleri kaldırın.

Alet ve işleyicilerin isimlerini ayarlamak

Aşağıdaki isimleri bu aletlere uygulayın, böylece onları bu isimlerle Python'da kullanabiliriz:

Gnome Application Window(Gnome Uygulama Penceresi):
colorApp
Gnome About Dialog(Gnome Hakkında Diyaloğu):
about

İşleyici isimleri, belirli bir alette bir olay meydana geldiğinde çağrılacak fonksiyon isimleridir. Bunun anlamı, Python'daki fonksiyonları bu isimleri kullanarak - ileride göreceğiniz gibi - tanımlayacağımızdır. Örneğin, kullanıcı yeni ikon düğmesine bastığında oyunu yenileyecek bir fonksiyon çağırmak istiyoruz diyelim. Bunu Glade'den kurmak için ilk önce aleti seçmeniz, sonra da properties(özellikler) diyaloğundaki Signals(Sinyaller) tabakasından ayarlamadınz gerekir.

Bizim örneğimiz, sinyal tıklanır. İşleyici, fonksiyon adıdır. Aşağıdaki diziler, kullanılan tüm sinyalleri ve işleyicileri sunar:

about(hakkında) diyaloğunda:

Widget name Signal Handler
about clicked gtk_widget_destroy
about close gtk_widget_destroy
about destroy gtk_widget_destroy

gtk_widget_destroy işleyicisi GTK'da öntanımlıdır. Sadece aleti yokeder.

colorApp penceresinde. İlk olarak, Glade parçalar menüsü için sinyalleri/işleyicileri otomatik olarak seçer. İsimlerini kontrol edebilirsiniz. İsimlerini bu dizinin sonuna ekledim. Hem yeni menü parçasının hem de yeni ikon düğmesinin aynı işleyiciyi paylaşacağını göreceksiniz, normal olarak benzer amaçları vardır:

Widget name Signal Handler
button1 (new icon button
on the toolbar		 clicked on_new_activate
new activate on_new_activate
colorApp destroy on_exit1_activate
exit1 activate on_exit1_activate
about1 activate on_about_activate

Son dokunuş

Glade alet çubuğundaki Options(Seçenekler) düğmesinden Project Options 'ı çağırın. General(Genel) tabakasında, plan girişlerini aşağıdaki gibi ayarlayın:

Aletleri temsil eden dosya color.glade 'dir. Yolu, kendi ana dizininize ayarlayın.

Şimdi File(Dosya) menüsünden dosyayı kaydedin. Kaynak kodunu kurmayın, bu özelliği biz kullanmıyoruz.
Glade ile işimiz şimdi bitti, artık Python ile başlayabiliriz.

 

Python kodu

Kodun tamamı dökümanın sonundadır. Kod, color.glade dosyasıyla aynı yere kaydedilmelidir.

 

Gerekli birimleri dahil etmek

from math import cos, sin, pi
from whrandom import randint
from gtk import *
from gnome.ui import *
from GDK import *
from libglade import *

math ve whrandom birimlerinden, Gnome ait olmayan cos, sin, randint gibi özel fonksiyonları ve pi değişkenini dahil ediyoruz. Gnome'a özel birimler gtk, GDK ve gnome.ui 'dir. C'de, gnome.h'yi dahil etmek bütün Gnome başlıklarını dahil etmemizi sağlar. Pyhton'da, ilk önce Gnome fonksiyonunun kullanmak istediğiniz bağlantısının hangi birimde yerleştiğini bulmanız gerekir. Örneğin, bir terminal penceresinden (kabuk)aşağıdaki komutla "canvas" dizisini içeren birimi arayabilirsiniz: 

cd /usr/local/lib/python1.5/site-packages/gnome
grep canvas *.py

Yukarıdaki komut Gnome bağlantısının /usr/local/lib/python1.5/site-packages altında kurulmuş olduğunu varsayar.

 

Libglade ile arayüz yükleme

Bu örenekte şekiller - özellikle yıldızlar, daireler ve kareler - için Gnome Canvas'ı kullanıyoruz. Kanvas grafik parçaları (elips, nokta, doğru, dikdörtgen), yazı parçaları ve hatta aletler için bir yer tutucudur. Aslında bir kanvas bazı kanvas gruplarını da içerebilir. Sonuçta bir kanvas grubuna kanvas parçaları - bizim şekillerimiz - yerleştirilebilir. Varsayılan durumda, bir kanvas kök kanvas grubu adında varsayılan bir kanvas grubunu içerebilir. Biz bu grubu şekillerimizi yerleştirmek için kullanacağız.

İlk başta bazı evrensel değişkenler tanımlanır:

Çağrılacak ilk fonksiyon - initColor - color.glade dosyasından aletler oluşturur ve işleyicileri otomatik olarak aletlere bağlar:

def initColor ():
    global rootGroup, canvas
    wTree = GladeXML ("color.glade",
                      "colorApp")
    dic = {"on_about_activate": on_about_activate,
           "on_exit1_activate": mainquit,
           "on_new_activate":on_new_activate}
    wTree.signal_autoconnect (dic)
    canvas = wTree.get_widget ("canvas")
    rootGroup = canvas.root ()

Bir aleti oluşturmak için GladeXML fonksiyonu kullanılır. Tabii ki color.glade dosyasına giden yolu ayarlamanız gerekir. Bizim Glade ile tanımladığımız colorApp Gnome Uygulama Penceresini oluşturur ve gösterir. Dönüş değeri kullanışlı yöntemlerle bir nesnedir - gerçekte bir sınıf.

Sonra Python'da tanımladığımız işleyicileri, color.glade 'de tanımladığımız aletlere bağlarız. Bunun için, color.glade dosyasında tanımlanan işleyici adlarının anahtarlarını tutan bir sözlük oluşturmamız gerekir: on_about_activate, on_exit1_activate ve on_new_activate. Bu anahtarlarla bağlantılı değerler Python'da tanımlanmış fonksiyon isimleridir.
Sonuç olarak, signal_autoconnect metodu işin geri kalan kısmını bizim için yapar.

En sonunda GladeXML 'in çağrılışı süresince oluşturulan kanvasın referansını - Python'da bir GnomeCanvas nesnesi - ve kök kanvas grubunu - bir GnomeCanvasGroup nesnesi - geri getiririz.

Faydalı tavsiyeler

Python için Gnome bağlantısını kapsayan gerçek bir elkitabı yoktur. Ancak, Gnome sanal yörelerinde C'de Gnome programlama ile ilgili pek çok döküman mevcuttur. Bu dökümanlara bakmak faydalı olabilir fakat Python için Gnome bağlantısına da bakmanız da gerekecektir:

Bağlantı şurada yerleşmiştir: /usr/local/lib/python1.5/site-packages/gnome/ ya da /usr/lib/python1.5/site-packages/gnome/

Bağlantıya gözatmak bazı şeyleri gösterir:

  1. libglade.py bağlantısında:
  2. gnome/ui.py bağlantısı:

Python'daki her Gnome kullanılışında ilgili dökümanlara ulaşmak için aynı şeyleri yapabiliriz. Bu fonksiyonlar hakkında daha fazla bilgi almanız için ilgili Gnome dökümanlarını okuyun.

 

İşleyicileri tanımlama

GUI'ye oto-bağlantı için üç işleyici mevcuttur. Bunlar on_about_activate, on_new_activate ve mainquit. Sonuncusu gerçekte işleyişi durduran ve Python'dan çıkışı sağlayan bir Python fonksiyonudur. 

def on_about_activate(obj):
    "display the about dialog"
    about = GladeXML ("color.glade", "about").get_widget ("about")
    about.show ()

Bu işleyici Hakkında(About) Diyaloğunu açar. Öncelikle hakkında(about) diyaloğunu hatırlatalım - gerçekte LibGlade bu diyaloğu GladeXML nesnesi sayesinde kurar. Hatırlayın; GladeXML, get_widget metodunu içeren bir Python nesnesidir. Bu metod show metodunu içeren bir GtkWidget nesnesi döndürür.

Tavsiyeler

gtk.py bağlantısındaki GtkWidget nesnesini arayın. Bu nesnenin bir show metoduna sahip olduğunu görebilirsiniz. Bir önceki işleyici gövdesi şu şekilde yazılabilir: GladeXML("color.glade","about").get_widget("about").show().

def on_new_activate (obj):
    global rootGroup, colorShape
    for item in colorShape:
        item.destroy ()
    del colorShape[0:]
    buildGameArea (rootGroup)

Bu işeyici yeni oyun alanını tekrar inşa eder. Öncelikle varolan şekiller yokedilir. Şekiller GtkObject nesnelerinden türetilen GnomeCanvasItem nesneleridir. destroy metodu GtkObject nesnesinde yeralır. Daha sonra yeni oyun alanı inşa edilir.

 

GnomeCanvasItem

Şekli tanımlama

buildGameArea fonksiyonu GnomeCanvasGroup grubunda oyun alanının yaratılmasını düzenler. Şekiller - GnomeCanvasItem -, buildShape fonksiyonunun çağrılmasıyla oluşur. Bu şek,ller daire, kare ya da yıldız olabilir.

Yaratılan şekle bağlı olarak aşağıdaki kodla şekiller yaratılır: 

item = group.add ("ellipse", x1 = x - r, y1 = y - r,
                  x2 = x + r, y2 = y + r, fill_color = color,
                  outline_color = "black", width_units = 2.5)

[...]

item = group.add ("rect", x1 = x - a, y1 = y - a,
                  x2 = x + a, y2 = y + a, fill_color = color,
                  outline_color = "black", width_units = 2.5)

[...]

item = group.add ("polygon", points = pts, fill_color = color,
                  outline_color = "black", width_units = 2.5)

group değişkeni GnomeCanvasGroup nesnesinin referansını tutar. Eğer ui.py bağlantısının içine bakarsak, GnomeCanvasGroup grubunun bir add metodu olduğunu görürüz. İlk argüman olan tp eklenecek parçanın türünü içeren bir dizi bekler. Sonraki argümanları anahtar kelime argümanları ve değerlerinden oluşan çiftlerdir, her biri bir sözlüğe karşı gelir. Mevcut anahtar kelimelerin tüm listesini elde etmek için ui.py 'deki GnomeCanvasRect, GnomeCanvasEllipse ve GnomeCanvasPolygon nesnelerine bir göz atın.

elips ve dikdörtgen birbirlerine benzerler, iki apsis ve ordinat koordinatları birbirine zıt iki tepe noktası tanımlar, üst-sol ve alt-sağ. Kanvasın orijin noktası varsayılan değer olarak kanvasın üst-sol kısmında yerleşmiştir. polygon points anahtar kelimesinin değerini bekler, bu anahtar kelime çokgenin noktalarını belirleyen çift koordinatların listesidir.

Şekle olay ekleme

Şimdi yarattığımız her şekle bir olay bağlayacağız. Bu buildShape fonksiyonunun sonunda yapılır:

item.connect ('event', shapeEvent)
colorShape.append (item)

Sadece GnomeCanvasItem 'ın ata nesnelerinden olan GtkObject 'in connect metodunu kullanacağız. Bunun ilk argümanı sinyaldir. GnomeCanvasItem 'ın bütün olay çeşitlerini kapsayan event adlı tek bir sinyali olduğundan dolayı yalnızca bu argümanı event olarak ayarlayacağız. İkinci argüman bizim yazdığımız işleyici adıdır, burada shapeEvent olacak. Büyük olasılıkla üçüncü argümana veri geçirebiliriz, ama burada buna ihtiyacımız yok. İşte bu kadar!

 

Olayın şekli

Şimdi şekiller için işleyici yaratılışı:

def shapeEvent (item, event):
    global selectedItem, itemToSelect, colorShape
    if event.type == ENTER_NOTIFY and selectedItem != item:
        #highligh outline
        item.set(outline_color = 'white')
    elif event.type == LEAVE_NOTIFY and selectedItem != item:
        #unlight outline
        item.set(outline_color = 'black')
    elif event.type == BUTTON_PRESS:
        #select the item
        if not selectedItem:
            item.set (outline_color = 'white')
            selectedItem = item
        elif item['fill_color_gdk'] == selectedItem['fill_color_gdk'] \
             and item != selectedItem:
            #destroy both item
            item.destroy ()
            selectedItem.destroy ()
            colorShape.remove (item)
            colorShape.remove (selectedItem)
            selectedItem, itemToSelect = None, itemToSelect - 1
            if itemToSelect == 0:
                buildGameArea (rootGroup)
    return 1

İşleyici çağrıldığında, item değişkeni olayın oluştuğu şeklin referansını içerir ve event de olayı içerir. GdkEvent olayında sadece üç çeşit olayla ilgileneceğiz:

Sonuç olarak işleyici her zaman TRUE (1) döndürür. Bunun anlamı: sinyalin başka parçalara yayılmamasıdır. Bunu olmasını istemeyiz, çünkü bizim şeklimiz asla üstüste binmez.  

Son söz

Bütün Python kodunu Gnome'a uygun olarak bırakmadım, anlaşılması çok da güç olmamalı. Bu basit dersteki temel amacım bazı şeylerin nasıl çalıştığını kendi kendinize anlayabileceğinizi göstermekti: Python için Gnome bağlantısına bakmak ve C programlama için Gnome dökümanlarını okumak. Tabii ki Gnome Canvas ve Glade/LibGlade'in ne kadar kolay ve güçlü olduğunu da gösterdim. Şu andan itibaren bu kodu genişleterek yapabileceğiniz pek çok şey var. (Bu makale için kaynak dosyaları burada bulabilirsiniz.)

 

Ek: Kaynağın tamamı

#!/usr/bin/python
# Couleur - Teo Serie
# Copyright Hilaire Fernandes 2000
# Release under the terms of the GPL licence version 2
# You can get a copy of the license at http://www.gnu.org
#
# Select shapes with same color
#
from math import cos, sin, pi
from whrandom import randint
from gtk import *
from gnome.ui import *
from GDK import *
from libglade import *

width, itemToSelect = 400, 8
selectedItem = rootGroup = canvas = None
# to keep trace of the canvas item
colorShape =[];

def on_about_activate(obj):
    "display the about dialog"
    about = GladeXML ("color.glade", "about").get_widget ("about")
    about.show ()

def on_new_activate (obj):
    global rootGroup, colorShape
    for item in colorShape:
        item.destroy ()
    del colorShape[0:]
    buildGameArea (rootGroup)

def shapeEvent (item, event):
    global selectedItem, itemToSelect, colorShape
    if event.type == ENTER_NOTIFY and selectedItem != item:
        #highligh outline
        item.set(outline_color = 'white')
    elif event.type == LEAVE_NOTIFY and selectedItem != item:
        #unlight outline
        item.set(outline_color = 'black')
    elif event.type == BUTTON_PRESS:
        #select the item
        if not selectedItem:
            item.set (outline_color = 'white')
            selectedItem = item
        elif item['fill_color_gdk'] == selectedItem['fill_color_gdk'] \
             and item != selectedItem:
            #destroy both item
            item.destroy ()
            selectedItem.destroy ()
            colorShape.remove (item)
            colorShape.remove (selectedItem)
            selectedItem, itemToSelect = None, itemToSelect - 1
            if itemToSelect == 0:
                buildGameArea (rootGroup)
    return 1

def buildShape (group, number, type, color):
    "build a shape of 'type' and 'color'"
    global colorShape
    w = width / 4
    x, y, r = (number % 4) * w + w / 2, (number / 4) * w + w / 2, w / 2 - 2
    if type == 'circle':
        item = buildCircle (group, x, y, r, color)
    elif type == 'squarre':
        item = buildSquare (group, x, y, r, color)
    elif type == 'star':
        item = buildStar (group, x, y, r, 0.4, randint (3, 15), color)
    elif type == 'star2':
        item = buildStar (group, x, y, r, 0.6, randint (3, 15), color)
    item.connect ('event', shapeEvent)
    colorShape.append (item)

def buildCircle (group, x, y, r, color):
    item = group.add ("ellipse", x1 = x - r, y1 = y - r,
                      x2 = x + r, y2 = y + r, fill_color = color,
                      outline_color = "black", width_units = 2.5)
    return item

def buildSquare (group, x, y, a, color):
    item = group.add ("rect", x1 = x - a, y1 = y - a,
                      x2 = x + a, y2 = y + a, fill_color = color,
                      outline_color = "black", width_units = 2.5)
    return item

def buildStar (group, x, y, r, k, n, color):
    "k: factor to get the internal radius"
    "n: number of branch"
    angleCenter = 2 * pi / n
    pts = []
    for i in range (n):
        #external points of the star
        pts.append (x + r * cos (i * angleCenter))
        pts.append (y + r * sin (i * angleCenter))
        #internal points of the star
        pts.append (x + r * k * cos (i * angleCenter + angleCenter / 2))
        pts.append (y + r * k * sin (i * angleCenter + angleCenter / 2))
    pts.append (pts[0])
    pts.append (pts[1])
    item = group.add ("polygon", points = pts, fill_color = color,
                      outline_color = "black", width_units = 2.5)
    return item

def getEmptyCell (l, n):
    "get the n-th non null element of l"
    length, i = len (l), 0
    while i < length:
        if l[i] == 0:
            n = n - 1
        if n < 0:
            return i
        i = i + 1
    return i

def buildGameArea (group):
    global itemToSelect, selectedItem
    itemColor = ['red', 'yellow', 'green', 'brown', 'blue', 'magenta',
                 'darkgreen', 'bisque1']
    itemShape = ['circle', 'squarre', 'star', 'star2']
    emptyCell = [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0]
    itemToSelect, i, selectedItem = 8, 15, None
    for color in itemColor:
        # two items of same color
        n = 2
        while n > 0:
            cellRandom = randint (0, i)
            cellNumber = getEmptyCell (emptyCell, cellRandom)
            emptyCell[cellNumber] = 1
            buildShape (group, cellNumber, itemShape[randint (0, 3)], color)
            i, n = i - 1, n - 1

def initColor ():
    global rootGroup, canvas
    wTree = GladeXML ("color.glade",
                      "colorApp")
    dic = {"on_about_activate": on_about_activate,
           "on_exit1_activate": mainquit,
           "on_new_activate":on_new_activate}
    wTree.signal_autoconnect (dic)
    canvas = wTree.get_widget ("canvas")
    rootGroup = canvas.root ()

initColor ()
buildGameArea (rootGroup)
mainloop ()
 

Bu yazı için görüş bildiriminde bulunabilirsiniz

Her yazı kendi görüş bildirim sayfasına sahiptir. Bu sayfaya yorumlarınızı yazabilir ve diğer okuyucuların yorumlarına bakabilirsiniz.
 talkback page 
Görselyöre sayfalarının bakımı, LinuxFocus Editörleri tarafından yapılmaktadır
© Hilaire Fernandes, FDL
LinuxFocus.org
Burayı klikleyerek hataları rapor edebilir ya da yorumlarınızı Linuxfocus'a gönderebilirsiniz
 Çeviri bilgisi:
en -> -- Hilaire Fernandes
en -> tr Özlem Erdaş

2001-01-29, generated by lfparser version 2.6