GTK+ ile ilgili temel bilgiler, Bölüm 2: GTK+ nasıl kullanılır?

Uygulamalı giriş

Düzey: Orta

Maciej Katafiasz (ibmdw@mathrick.org), Öğrenci, Bilgisayar Bilimleri

10 Ocak 2006

"GTK+ ile ilgili temel bilgiler" başlıklı üç bölümden oluşan dizinin ikincisi olan bu makale GTK+ ile programlamaya giriş yapmanızı sağlar. Bu makalede, C dilinde yazılmış örnek bir GTK+ uygulaması analiz edilir, daha sonra aynı uygulamanın Python ve C# dilinde yazılmış hali gösterilir. Son olarak, GTK+ ile daha hızlı ve daha iyi uygulamalar geliştirmenize yardımcı olacak bazı yararlı ipuçları anlatılır.

Bu makalede, sınıf, nesne, yöntem ve kalıtım (inheritance) gibi nesne yönelimli temel kavramlarla ilgili bilgi sahibi olduğunuz varsayılır. Ayrıca, C dilinde program yazabilir olmanız gerekmese de, C dili sözdizimini temel olarak anlıyor olmanız gerekir.

Bir GTK+ uygulamasının C dilindeki anatomisi

Kodun en iyi şekilde bir örnekle anlatılabileceğini düşünüyorum. Bu makalede, C dilinde yazılmış, "Hello World" adında kısa bir uygulama kullanacağım. Kısa ve bir uygulama olarak yararlılığı tartışılır olsa da, bu uygulamanın kodu GTK+ ile programlama yaparken karşılaşabileceğiniz ilginç kavramların çoğunu gösterir (bkz. Liste 1).

#include <gtk/gtk.h>
#include <libintl.h>

#define _(x) gettext (x)
#define N_(x) (x)

#define GETTEXT_PACKAGE "gtk-hello"
#define LOCALEDIR "mo"

static char *greetings[] = { "Hello World",
			     "Witaj świecie",
			     "世界に今日は" };

static char* choose_greeting ()
{
  return greetings[g_random_int_range (0, G_N_ELEMENTS (greetings))];
}

static void cb_button_click(GtkButton *button, gpointer data)
{
  GtkWidget *label = GTK_WIDGET(data);

  g_assert(label != NULL);
  gtk_label_set_text(GTK_LABEL (label), choose_greeting());
}

static gboolean cb_delete(GtkWidget *window, gpointer data)
{
  gtk_main_quit();
  return FALSE;
}

int main (int argc, char *argv[])
{
  GtkWidget* window, *button, *label, *vbox;
  
  bindtextdomain (GETTEXT_PACKAGE, LOCALEDIR);
  bind_textdomain_codeset (GETTEXT_PACKAGE, "UTF-8");
  textdomain (GETTEXT_PACKAGE);

  gtk_init(&argc, &argv);

  window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
  button = gtk_button_new_with_label (_("Hello World"));
  label = gtk_label_new (choose_greeting());
  vbox = gtk_vbox_new(FALSE, 0);

  gtk_container_add(GTK_CONTAINER (window), vbox);
  gtk_container_add(GTK_CONTAINER (vbox), label);
  gtk_container_add(GTK_CONTAINER (vbox), button);

  g_signal_connect(G_OBJECT (window), "delete-event", 
		   G_CALLBACK(cb_delete), NULL);

  g_signal_connect (G_OBJECT (button), "clicked", 
		    G_CALLBACK (cb_button_click), label);

  gtk_widget_show_all(window);
  gtk_main();

  return 0;
}

Genel görünüm

Ayrıntılara girmeden önce, Hello World programını çalıştırdığınızda neler olacağı aşağıda verilmiştir:

1. GTK+ ve uluslararasılaştırma (i18n) desteği başlatılır.
2. Pencere bileşenleri (widget) yaratılır.
3. Pencere bileşenleri, GTK+ ürününün bunların ekranda nasıl görüntüleneceğini bilmesini sağlayacak şekilde düzenlenir.
4. İki sinyal tanıtıcısı bağlanır; bunlardan biri kullanıcı pencereyi kapattığında uygulamadan çıkılmasını, diğeri ise kullanıcı düğmeyi tıklattığında görüntülenen iletinin değiştirilmesini sağlar.
5. Pencere ekranda görüntülenir ve uygulama gtk_main() işlevini çağırarak ana döngüyü etkinleştirir.
6. Ana döngü, kullanıcı pencereyi kapatıp gtk_main_quit() işlevi çağrılıncaya kadar çalışır.

Başlatma

Aşağıdaki satırlar GTK+ ve i18n desteğini başlatır:

int main (int argc, char *argv[])
{
  GtkWidget* window, *button, *label, *vbox;
  
  bindtextdomain (GETTEXT_PACKAGE, LOCALEDIR);
  bind_textdomain_codeset (GETTEXT_PACKAGE, "UTF-8");
  textdomain (GETTEXT_PACKAGE);

  gtk_init(&argc, &argv);

main bildirimi her C programcısı tarafından bilinir. (Bir C programcısı değilseniz, bunun uygulamanızın yürütülmesini başlatan işlev olduğunu bilmeniz yeterlidir.)

Sonraki satırda, GtkWidget türüne ilişkin birkaç işaretçi bildirimi yer alır. GTK+, nesne yönelimli bir araç takımıdır. Bu nedenle, çeşitli pencere bileşeni türlerini gerçekleştirmek için kalıtım gibi genel nesne yönelimli kavramları kullanır. Bir dil olarak C, nesne yönelimi için yerleşik desteğe sahip değildir. GTK+, bu eksikliği, C standardının gerektirdiği gibi, bazı akıllı yöntemler ve yararlı özellikler kullanarak giderir. Bu şemada, nesneler işaretçilerle gösterilir ve GtkWidget, sınıf (class) adı verilen temel türdür. GTK+ hiyerarşisindeki diğer tüm sınıflar bundan türetilir. Bu nedenle, değişkenleri GtkWidget* olarak belirledim.

Sonraki üç satır, arabirim uluslararasılaştırma desteği için programınızın başına eklemeniz gereken çağrılardır. Gerçek bir uygulamada LOCALEDIR ve GETTEXT_PACKAGE bildirimlerini el ile girmeniz gerekmez. Oluşturma sisteminiz bu bildirimleri sizin için kendisi gerçekleştirir. Ancak, bu basit örnekte, bildirimler neyin gerekli olduğunun netleştirilmesine yardımcı olur.

Son satır gtk_init() işlevi için bir çağrıdır. Bu işlevi çağırmalı ve başka bir GTK+ çağrısı yapılmadan önce programınızın başlatılması için kullanılan bağımsız değişkenleri bu işleve geçirmelisiniz. Bunu yapmazsanız, kendilerini düzgün bir şekilde başlatma şansı olmamış çeşitli altsistemlerden bazı hatalar alırsınız.

Pencere bileşenlerinin yaratılması

Bu dört satır, farklı _new() işlevlerine çağrılardır.

  window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
  button = gtk_button_new_with_label (_("Hello World"));
  label = gtk_label_new (choose_greeting());
  vbox = gtk_vbox_new(FALSE, 0);

Tahmin edebileceğiniz gibi, bu işlevler yeni pencere bileşenleri yaratır. Bu nedenle, bunlar pencere bileşenlerini gösteren nesneler için yapıcı (constructor) öğelerdir. C++ dilinde, yapıcılar özel bir şekilde işaretlenir ve özel bir sözdizimi kullanılarak çağrılır. Ancak, C dili, nesne yönelimini desteklemediği için bunların sıradan işlevlerden bir farkı yoktur. Yalnızca işlev adlarına eklenen _new() soneki bunların aslında yapıcı olduğunu gösterir. gtk_* ad alanındaki her yapıcının GtkWidget'a bir işaretçi döndürmesi bir kuraldır. Böylece, değişkenleri bu türle bildirerek, bir yapıcı çağrısının sonucunu doğrudan ilgili değişkene atayabilirsiniz.

Tek tek yapıcılara bakarsanız, yarattıkları pencere bileşenlerine uygun farklı parametreler aldıklarını görürsünüz. Özellikle, gtk_window_new (GTK_WINDOW_TOPLEVEL) yeni bir TOPLEVEL penceresi yaratır; bu, başlık çubuğu, kapatma düğmesi ya da pencereleme sisteminizin eklediği diğer öğelerin bulunduğu, kullanıcının bir pencere olarak gördüğü görüntüye karşılık gelen bir pencere bileşenidir.

Label (etiket) ve button (düğme) yapıcılarına ilişkin çağrılar bunlardan tam olarak bekleneni gerçekleştirir. Ancak, dizenin başında ve sonundaki alt çizgi ve parantezin ( _()) button (düğme) öğesine geçirildiğine dikkat edin. Bu makro gettext() yordamını çağırır ve arabiriminizi çevirmek için gereklidir. (gettext hakkında ek bilgi için bkz. Kaynaklar.)

Şifreli gibi görünen gtk_vbox_new(FALSE, 0) dikey bir kutu (VBox) yaratır. Bu pencere bileşeni ekranda görülebilir bir piksele karşılık gelmese de, az sonra göreceğiniz gibi, GTK+ ürününün denetimleri nasıl yerleştirdiği konusunda önemli bir rol oynar.

Düzenin belirlenmesi

Aşağıdaki üç satır pencere bileşenlerinin düzenini belirler:

    gtk_container_add(GTK_CONTAINER (window), vbox);
    gtk_container_add(GTK_CONTAINER (vbox), label);
    gtk_container_add(GTK_CONTAINER (vbox), button);

Bu satırlar, GtkContainer türündeki nesne yönelimli yöntemlere ilişkin çağrılardır. Uygulama programı arabirimi (API) başvurusuna bakarsanız, GtkContainer öğesinin GtkWidget öğesinden kalıtım alındığını ve tüm yöntemlerinin ilk parametre olarak GtkContainer* öğesini aldıklarını görürsünüz. Bu nedenle, GtkContainer* yöntemin üzerinde çalışması gereken nesne örneğidir (instance). Değişkenlerin türü GtkWidget* olduğu için ve C derleyicisi nesne yönelimli kalıtımı (inheritance) desteklemediği için, derleyiciyi, GtkContainer* parametresini bekleyen bir işleve bu değişkenleri geçirmesinin güvenliği olduğu konusunda ikna etmeniz gerekir. GTK_CONTAINER() makrosu, GtkContainer öğesine tip açısından güvenli (type-safe) bir "casting" şekli uygulayarak gerçekleştirir. Tip açısından güvenli, makronun, belirlenen işlemin, "cast" işlemine başlanmadan önce verilen tipte gerçekleştirilebileceğini doğruladığı anlamına gelir. Makro işlemi gerçekleştiremezse, bir uyarı gönderir.

GTK+, kutu düzeni modelini kullandığı için, ekranda pencere bileşenlerinin nerelere yerleştirileceğini açık olarak belirtmeniz gerekmez. Bunun yerine, hangi pencere bileşeninin başka bir bileşenin içinde yer alacağını belirtirsiniz. Hello World uygulamasında, her bir gtk_container_add() yöntem çağrısı, uygulamaya ilk parametreyi ya da üst pencere bileşenini (parent widget) almasını ve ikinci parametreyi ya da alt pencere bileşenini (child widget) bunun içine yerleştirmesini söyler. Bu örnekte kullanılan VBox pencere bileşeni, alt öğelerini dikey olarak yığan bir düzen denetimi türüdür. İçine bir etiket ya da düğme yerleştirdiğinizde, sonuçta düğme etiketin altında görüntülenir.

Tüm yapmanız gereken bu kadardır. Daha önce mutlak konumlama (absolute positioning) modelini (Win32 gibi bazı araç takımlarında kullanılan model) kullanarak pencere bileşenlerini el ile ayarlamanız ya da boyutlandırmanız gerektiyse, GTK+ ürününde bütün bunların sizin için otomatik olarak yapıldığını öğrenmek sizi memnun edecektir.

Sinyallerin ve ana döngünün bağlanması

Pencere bileşenlerini yaratıp düzenledikten sonra, sıra bunlara mantık eklemeye gelir. Birçok GUI araç takımı gibi GTK+ da olaylarla yönlendirilen bir çerçevedir (event-driven framework). Bunun için, ana döngünün etrafında düzenlenir. Ana döngü sürekli bir denetleme-dağıtma-uyku çevrimi (check-dispatch-sleep) içinde çalışır. Bir olay oluştuğunda, bu olayla ilişkilendirilmiş olan nesne, ana döngüyü bu olaydan haberdar etmek üzere bir sinyal gönderir. Daha sonra ana döngü, sinyalleri ve işleyicileri arasındaki iç eşleme tablosuna bakar (bunlara geri çağrı (callback) da denir) ve belirli bir nesne üzerindeki belirli bir sinyal için kaydedilmiş olan işleyicileri çağırır.

Hello World kodunda, geri çağrıların kaydı aşağıdaki gibidir:

g_signal_connect(G_OBJECT (window),  "delete-event", 
                 G_CALLBACK(cb_delete), NULL);
g_signal_connect (G_OBJECT(button), "clicked", 
                  G_CALLBACK(cb_button_click), label);

GTK+ ürününde sinyallere bağlandığınıza dikkat edin. İlk satır cb_delete işlevini window nesnesindeki delete-event sinyaline bağlar. Benzer şekilde, ikinci satırdaki cb_button_click işlevi, button nesnesindeki clicked sinyaline bağlar. İkinci bağlama çağrısındaki dördüncü parametre olan label parametresine dikkat edin. Daha sonra, bunun cb_button_click işlevinde nasıl kullanıldığını göreceksiniz.

Bu, kullanıcı pencereyi kapattığında uygulamadan çıkılmasını sağlayan cb_delete işlevidir:

static gboolean cb_delete(GtkWidget *window, gpointer data)
{
  gtk_main_quit();
  return FALSE;
}

Bu işlev GtkWidget* değişkenini ve belirlenmemiş bir data işaretçisini (gpointer, void* türüne eşdeğerdir) alır çünkü "delete-event" için gerçekleştirilen her her geri çağrının bu prototipi izlemesi gerekir. Ancak, bu işlev için bu bağımsız değişkenlere gerek olmadığından bunlar dikkate alınmaz. İşlev, ana döngüden çıkılmasını sağlayan gtk_main_quit() yordamını çağırır. GtkWidget için tanımlanan delete-event sinyaline ilişkin geri çağrı prototipi bir boole sonucu bildirdiğinden, bu işlev bir boole değeri döndürür. Boole değeri GTK+'nın yapacağı işlemi belirler. İşlev TRUE (Doğru) değerini döndürürse, olay işlenmiş sayılır ve pencere bileşenini pencereleme sisteminden kaldıran varsayılan işleyici çağrılmaz. Örneğin kaydedilmemiş verileri soran ve kullanıcının yanıtına bağlı olarak pencerenin kapanmasını durduran bir ileti görüntülemek isterseniz bu yararlı olacaktır.

Aşağıda, kullanıcı düğmeyi tıklattığında görüntülenen iletiyi değiştiren cb_button_click işlevi yer alır:

static void cb_button_click(GtkButton *button, gpointer data)
{
  GtkWidget *label = GTK_WIDGET(data);

  g_assert(label != NULL);
  gtk_label_set_text(GTK_LABEL (label), choose_greeting());
}

Gördüğünüz gibi, bu işlev cb_delete işlevine benzer, ancak bu işlev herhangi bir değer döndürmez ve GtkWidget yerine GtkButton* değerini alır. Kod, data işaretçisini GtkLabel'a ilişkin bir işaretçiye dönüştürür. Geri çağrı kaydındaki etiket parametresini hatırlıyor musunuz? Artık, data işaretçisi, geri çağrı her gerçekleştirildiğinde bu etikete ilişkin göstergeyi içerecektir. Geri çağrınıza her yeni bilgi eklemek istediğinizde data bağımsız değişkenini kullanabilirsiniz. Benzer şekilde, sinyali gönderen nesneye erişmeniz gerekirse, bu geri çağrı örneğinde button olan ilk parametreyi kullanırsınız.

Etikete ilişkin işaretçiyi aldıktan sonra, kod, etiketin (label) NULL değerine eşit olup olmadığını belirlemek için g_assert makrosunu kullanır. g_assert makrosu, Glib (GTK+'nın kullandığı yararlı C tipleri ve yordamlarını içeren bir kitaplık) kitaplığından alınan bir yardımcı program makrosudur ve kendisine geçirilen koşul karşılanmazsa (burada, koşul label'ın NULL'a eşit olup olmadığıdır), programı durdurur. Label'ın NULL değerine eşit olması, programcının bir hata yaptığını gösterdiği için, bu, kod üretime girmeden öncehatanın yakalanmasını sağlar.

Pencerenin görüntülenmesi

Geri çağrılar bağlandıktan sonra, gtk_widget_show_all() işlevi pencerenin (yani tüm pencere bileşenlerinin) ekranda görünmesini sağlar (bkz. Şekil 1).

Ana döngünün etkinleştirilmesi

Her şey hazırlanıp görünür olduğunda gtk_main() işlevi ana döngüyü etkinleştirir. Ana döngü belirsiz bir döngüye girer ve bir kullanıcı pencereyi kapatarak gtk_main_quit() işlevini çağırıncaya kadar olayları bekler ve geri çağrıları gerçekleştirir.

NOT: Hala koddaki herhangi bir şeyle ilgili bir sorunuz varsa ekteki kaynak koduna bakın. Bu, makalede gösterdiğim örnekle benzerdir, ancak her bir satıra ilişkin açıklamalar içerir.

Derleme ve çalıştırma

Bu programı derlemek için C derleyicisi ve GTK+ için geliştirme dosyaları (üstbilgiler ve kitaplıklar) gerekir. Bu öğelerin nasıl edinileceğine ilişkin bilgi için bkz. Kaynaklar.

Dosyaları kurduktan sonra, kaynak kodunu açın, kodun açıldığı dizine geçin ve make komutunu çalıştırın:

$ tar -xzf gtk_hello.tgz
$ cd gtk_hello
$ make

NOT: Microsoft® Windows® kullanıyorsanız, make komutunu çalıştırmak yerine, Microsoft Visual Studio™.NET'i açın ve "hello" projesini çalıştırın.

Diğer programlama dillerinde GTK+

GTK+'yı birçok programlama dilinde kullanabilirsiniz. Bunu yapmak için ilişkilendirmeleri (bindings) kullanın. İlişkilendirmeler, belirli bir dil için hazırlanmış olan ve GTK+ API'sini o dile uygun bir şekilde gösteren özel paketlerdir.

Örneğin, Hello World uygulamasını Python ve C# dillerine çevirdim. GTK+'yı bu dillerle çalıştırabilmek için, Python ve Mono/.NET'in yanı sıra, sırasıyla PyGTK ve Gtk# paketleri gerekir (bkz. Kaynaklar).

PyGTK dilinde Hello World

Liste 6'da, Hello World uygulamasının kodu Python diline çevrilmiş olarak gösterilir.

import pygtk
pygtk.require('2.0')
import gtk
import random

greetings = ["Hello World", "Witaj Świecie", "世界に今日は"]
def choose_greeting (greets):
    return greets[random.randint (0, len(greets) - 1)]

def cb_clicked(button, label):
    label.set_text(choose_greeting(greetings))

window = gtk.Window ()
vbox = gtk.VBox ()
button = gtk.Button("Hello World")
label = gtk.Label (choose_greeting (greetings))

window.add(vbox)
vbox.add(label)
vbox.pack_start(button, False, False)

window.connect("delete-event", lambda a,b: gtk.main_quit())
button.connect("clicked", cb_clicked, label)

window.show_all()
gtk.main()

Sıkıştırılmış Python kodu sayesinde, uygulamanın bu biçimi C dilinde yazılmış biçiminden daha kısadır. Bunun dışında, aynı görünür. Kodun, Python deyimleri kullanılacak şekilde çevrilmiştir, ancak API aynı şekilde kalır.

Gtk# dilinde Hello World

C# dili daha uzun bildirimler gerektirdiği için Hello World uygulamasının Gtk# dilindeki kodu C dilindeki biçiminden biraz daha uzundur. Bu nedenle, bu örnekte kaynak kodun tamamını kullanmadım. Kaynak kod ekteki karşıdan yüklenebilir dosyada yer almaktadır. Aşağıda ana kavramların C dilinden C# diline nasıl çevrildiğine ilişkin kısa bir örnek yer alır:

  class GtkHello : Gtk.Window
  {

Yeni bir pencere yaratıp hazırlamak yerine, Gtk.Window sınıfını bir altsınıfa koyup kurulum kodunun tamamını bir yapıcıya taşırsınız. Bu yaklaşım Gtk# diline özgü değildir. Aslında bu, bir pencerenin birden çok kopyası gerektiğinde C programlarında sık kullanılan bir yaklaşımdır. Ancak, C# dilinde alt sınıfların kullanımı o kadar kolaydır ki, tek bir örnek için bile bu yapılabilir (özellikle de C# dilinin en az bir sınıf bildirmenizi gerektirdiği düşünülürse).

  this.DeleteEvent += new DeleteEventHandler(DeleteCB);
  button.Clicked += new EventHandler(ButtonClickCB);

Gördüğünüz gibi, GTK+ sinyalleri C# dilinin yerel olay kavramlarına çevrilir. Adlar, C# adlandırma kurallarına daha uygun olacak şekilde biraz değiştirilir.

  private void DeleteCB (object o, DeleteEventArgs args)
  {
    Application.Quit ();
    args.RetVal = true;
  }

C# olaylarının oluşturulma şekli nedeniyle, delete-event işleyicisinin prototipi biraz farklıdır. Geri çağrınızdan true değerini döndürmek yerine bunu args.RetVal aracılığıyla geçirirsiniz. gtk_main() ve gtk_main_quit() çifti sırasıyla Application.Run() ve Application.Quit() ile değiştirilir.

Yararlı araçlar

GTK+ ile uygulama geliştirirken, birkaç araç hayatınızı kolaylaştırabilir. En önemli araçlardan bazıları Glade, Libglade ve Devhelp'tir.

Glade ve Libglade

Glade bir arabirim oluşturucu, yani bir programı kaynak koddan el ile oluşturmak yerine uygulamanızı grafik olarak oluşturmanızı sağlayan bir programdır. Bundan daha da önemli olan, ikinci bileşen Libglade'dir. Adından da anlaşılacağı gibi, Libglade, Glade'in kullanıcı arabirimi açıklamasını depolamak için kullandığı Genişletilebilir Biçimleme Dili'ni (XML; Extensible Markup Language) okumanızı sağlar. Libglade'i kullanarak, uygulamanızın arabirimini, hiçbir koda gerek duymadan, doğrudan bu açıklamadan oluşturabilirsiniz.

Şekil 2'de, birkaç pencere bileşeni içeren basit bir Libglade uygulaması görüntülenir.

Liste 8'de, Şekil 2'de gösterilen Libglade uygulamasının tam kaynak kodu gösterilmektedir.

#include <gtk/gtk.h>
#include <glade/glade.h>

int main (int argc, char *argv[])
{
  GladeXML *ui;
  gtk_init(&argc, &argv);

  /* Read user interface description from glade file */
  ui = glade_xml_new ("glade_hello.glade", "main_window", NULL);
  /* Automatically connect signals */
  glade_xml_signal_autoconnect(ui);
  gtk_main();

  return 0;
}   

Gördüğünüz gibi, açıklamalar ve boş satırlar dahil tüm uygulama 17 satırdan oluşur. Gerçek uygulamalar bu kadar kısa olmayacaksa da, Libglade, okunabilirlik, modülerlik ve kodun bakımı konularında size çok önemli avantajlar sağlar.

Bu programın nasıl oluşturulduğunu daha yakından incelemek isterseniz, bunu, bu makaleye ilişkin örneklerin devamıyla birlikte ekteki karşıdan yüklenebilir dosyada bulabilirsiniz.

Devhelp

Devhelp, GTK+ belgelerini oluşturmak için kullanılan ve Pango ve GNOME gibi ilgili projelerde de yararlanılan standart araç olan gtk-doc ile oluşturulmuş biçimdeki belgeleri okumanız için tasarlanmış bir belge tarayıcıdır. Devhelp'i kullanarak bir işlev dizininde hızlı bir şekilde arama yapabilir ve kurulu belgelere göz atabilir; böylece gereken bilgileri çok daha hızlı bulabilirsiniz. Devhelp bir GNOME uygulamasıdır. Bu nedenle, bunu çalıştırabilmek için GNOME'un üzerinde çalıştığı, POSIX uyumlu bir işletim sistemine (Linux® ya da Sun Solaris gibi) ve GNOME çalıştırma zamanı kitaplıklarına gereksiniminiz vardır. GNOME'un kendisini çalıştırmanız gerekmez.

Başka bir platform kullanırsanız, GTK+ belgelerini okumanın birçok başka yolu vardır. Mono projesi, genellikle Gtk# başvurusu önceden yüklenmiş olarak gönderilen Monodoc tarayıcısını içerir. Windows için GTK+ yükleyicileri de genellikle, Visual Studio® gibi çeşitli geliştirme araçlarıyla okunmaya uygun biçimlerdeki belgeler içerir. Son olarak, belgeleri her zaman bir Web tarayıcı kullanarak çevrimiçi olarak da okuma olanağı vardır, ancak hızı ve program belgelerinde arama yapmaya yardımcı olmak üzere tasarlanmış ek özellikleri nedeniyle özel bir tarayıcı tercih edilir.

Sonraki bölüm

Bu makalede, GTK+ ile programlamada kullanılan temel kavramları öğrendiniz. Ayrıca GTK+'yı C dili dışındaki dillerde, GTK+'yı kullandığınız genel yöntemi koruyup ilgili dillere özel deyimleri kullanarak nasıl kullanacağınızı da gördünüz. Son olarak, daha hızlı bir şekilde daha iyi uygulamalar geliştirmenizi sağlayacak araçlarla tanıştınız.

Bu dizinin son bölümünde, GTK+ ile uygulama geliştirmenin diğer bir yönüne, yayma konusuna daha yakından bakacaksınız. Bu makalede, taşınabilirlik özellikleri ve kuruluş kolaylığı dahil, seçenekleriniz ayrıntılı olarak analiz edilecek. Son olarak, GTK+'ya daha geniş bir açıdan, kullanıcılarınıza daha iyi hizmet verecek uygulamalar oluşturmanıza yardımcı olacak canlı bir topluluğa sahip bir proje olarak bakacaksınız.

Karşıdan yükleme

Kaynaklar

• developerWorks "GTK+ ile ilgili temel bilgiler" dizisinin tüm makalelerini okuyabilirsiniz.
  
  
• GNU Gettext, uygulamaların çalıştırma zamanında çevrilmesi için kullanılan bir kitaplıktır.
  
  
• Libglade Reference Manual, GTK+ arabirimlerinin dinamik olarak oluşturulması için kullanılabilecek bir kitaplıktır.
  
  
• Araç takımıyla ilgili ek bilgi için GTK+ Web sitesini ziyaret edebilirsiniz.
  
  
• Kapsamlı GTK+ API Documentation sayfası, tüm geliştiriciler için önemli bir sayfadır.
  
  
• The Official GNOME 2 Developer's Guide (yazan Matthias Warkus, No Starch Press, 2004), GTK+ ile programlama dahil, GNOME 2 konusunu ele alır.
  
  
• Açık kaynak teknolojileri konusunda kendinizi geliştirmenize ve bunları IBM ürünleriyle kullanmanıza yardımcı olacak kapsamlı nasıl yapılır bilgileri, araçlar ve proje güncellemeleri için developerWorks Open source zone (Açık kaynak bölgesi) sayfasını ziyaret edebilirsiniz.
  
  

• Microsoft .NET ortamı GTK+ ilişkilendirmesi olan Gtk# olanağını edinebilirsiniz.
  
  
• GTK+ Web sitesinden resmi GTK+ kaynak kodu tar dosyalarını edinebilirsiniz.
  
  
• Python için GTK+ ilişkilendirmelerini bulabileceğiniz resmi PyGTK sitesini ziyaret edebilirsiniz.
  
  
• Gazpacho, PyGTK ile yazılmış Glade UI açıklama dosyaları için kullanabileceğiniz gelişmiş bir editördür.
  
  
• Devhelp, GNOME için programcılara yönelik bir belge tarayıcıdır.
  
  
• GTK+ ürününü kullanan, kullanılabilirlik odaklı masaüstü kurulumu GNOME için ilgili Web sitesini ziyaret edebilirsiniz.
  
  
• Yine GTK+ ürünüyle geliştirilmiş, hızlı ve kolay bir masaüstü olan Xfce olanağını deneyebilirsiniz.
  
  
• Gnomefiles Web sitesini ziyaret ederek, burada GTK+ ile hazırlanmış 1.000'den fazla uygulama bulabilirsiniz.
  
  
• Bilgisayarınıza yükleyebileceğiniz ya da DVD'sini edinebileceğiniz IBM deneme yazılımı ile yeni açık kaynak geliştirme projenizde değişiklik yapabilirsiniz.
  
  

• GTK+ ile yazılım geliştirme konusunda destek ve sorularınızın yanıtları için GTK+ e-posta listelerine bakabilirsiniz.
  
  
• developerWorks web günlüklerine katılarak developerWorks topluluğuna erişebilirsiniz.

Yazar hakkında