Alıntı (cos00kun):

>     Window w = cast(Window)b.getObject("pencere1");
>     b.connectSignals(null);
>     w.addOnHide( delegate void(Widget aux){ Main.quit(); } );
> ```

>

'cast()' tür dönüşümü yapıyor. 'getObject' kullanarak ise kimliği 'pencere1' olan ve Glade ile oluşturduğumuz GtkWindow nesnesine erişim sağlıyoruz.

Sinyal bir olay olduğunda bildirim almak ve nesnenin davranışını kullanıcı ihtiyaçlarına göre özelleştirmek için kullanılan bir yöntemdir. Her sinyal (işaret) '"sınıf_ismi::sinyal_ismi"' şeklinde benzersiz olarak tanımlanabilir. Burada sınıf ismi örneğin 'GtkButton' ve işaret ismi ''tıklandı'' şeklinde olabilir.

Alıntı (cos00kun):
>
>  2 , 3 ve 4. sorularım cevap beklemekte bilginiz ve vaktiniz doğrultusunda beklemekteyim özür dileyerek  ;-)
>

2. soruyu tam anlamadım. 3. soru'yu da bir örnek üzerinde izah edebilirmisin.

-- 
[ Bu gönderi, <http://ddili.org/forum>'dan dönüştürülmüştür. ]

Teşekkürler..
3. sorumun örneğini haftasonu yazıp size sorarım tekrardan ancak bu arada yeni şey daha sorma gereği duydum.
sayfanızda yayınlanmış bir örnekte

import gtk.Ana;
import gtk.AnaPencere;
import gtk.Kalbur;
import gtk.Düğme;

class Pencere: AnaPencere
{
   Kalbur kalbur;
   Düğme düğme1, düğme2, düğme3, düğme4, düğme5, düğme6;

   this()
   {
       super("Kalbur örneği");
       kalbur = new Kalbur();
       ekle(kalbur);

       düğme1 = new Düğme("Düğme1");
       düğme2 = new Düğme("Düğme2");
       düğme3 = new Düğme("Düğme3");
       düğme4 = new Düğme("Düğme4");
       düğme5 = new Düğme("Düğme5");
       düğme6 = new Düğme("Düğme6");

       kalbur.ekle(düğme1);
       kalbur.iliştir(düğme2, 1, 0, 2, 1);
       kalbur.yanınaİliştir(düğme3, düğme1, ALT, 1, 2);
       kalbur.yanınaİliştir(düğme4, düğme3, SAĞ, 2, 1);
       kalbur.iliştir(düğme5, 1, 2, 1, 1);
       kalbur.yanınaİliştir(düğme6, düğme5, SAĞ, 1, 1);

       tümünüGöster();
   }
}

void main(string[] değişkenler)
{
   Ana.ilklendir(değişkenler);
   auto pencere = new Pencere();
   Ana.çalıştır();
}

bir kod yazmışsınız. burada

   kalbur.yanınaİliştir(düğme4, düğme3, SAĞ, 2, 1);
   kalbur.iliştir(düğme5, 1, 2, 1, 1);

şu satırları anlama konusunda güçlük yaşıyorum.. Aslında " kalbur.yanınaİliştir(düğme4, düğme3, SAĞ, 2, 1);" Bunda problem yok gayet net şekilde anlaşılıyor ve benim anladığım düğme4 nesnesini düğme3 nesnesinin SAĞ kısmına koy ve bunu 2 sutun ile 1 satırlık yer işkal edecek durumda konumla demek. Ancak alttaki satırda " kalbur.iliştir(düğme5, 1, 2, 1, 1);" buradaki düğme5 nesnesinden sonra yazan ilk "1" ve "2" nin anlamını çözemedim ?

--
[ Bu gönderi, http://ddili.org/forum'dan dönüştürülmüştür. ]

Kendimce bir mantık geliştirdim Erdem hocam ama doğrumudur emin değilim şöyle ki;
'kalbur.iliştir(düğme5, 1, 2, 1, 1);' 'düğme5' widgetini al ilk widgetin yada sol en üst köşedeki saırdan itibaren '1' sağ git oradan '2' aşağıya in '1 'sutunluk genişlikte ve '1' satırlık yükseklikte konumlandır.

Bu mantığa göre sanki herşey oturuyor gibi sadece başlangıç noktası yada referans noktası ilk widgetmidir yoksa sol en üst köşedeki ilk hücremidir onu çözemedim.

--
[ Bu gönderi, http://ddili.org/forum'dan dönüştürülmüştür. ]

http://programlama.tk/resim/resim/gtksoru.png

Sanırım resim üzerinde daha anlaşılır. düğme2'den sonra gelen parametre sol tarafta kaç sütün olduğunu gösteriyor. Bir sonraki üstte ne kadar satır olduğunu gösteriyor.

Daha sonraki parametre genişliğe gelirsek bu da düğmenin kaç sütün kaplayacağını, yükseklik ise kaç satır kaplayacağını belirtiyor.

Aynı durumu 5. düğme için de düşünebilirsin.

--
[ Bu gönderi, http://ddili.org/forum'dan dönüştürülmüştür. ]

Resim harika oldu sağolun.. aslında benim yazdığımla hafiften örtüşüyor gibi :-)
peki Erdem hocam kalbur.iliştir(düğme2, 4, 3, 1, 1); yaptığımızda neden kalbur.iliştir(düğme2, 1, 1, 1, 1); gibi davranıyor ? Bu mantığa göre sol tarafta 4 sutun üst tarafta 3 satır olarak düğme2 yi eklemesi gerekirken o kadar boşluk oluşmuyor acaba bunun sebebi grid yani kalbur sınıfının nesne olarak üretildiği anda dafault bir değerinin olmasımıdır ?
teşekkürler..

import gtk.Main;
import gtk.MainWindow;
import gtk.Grid;
import gtk.Button;

class Pencere: MainWindow
{
   Grid kalbur;
   Button düğme1, düğme2;

   this()
   {
       super("Kalbur örneği");
       kalbur = new Grid();
       add(kalbur);
	resize(560,250);

       düğme1 = new Button("Düğme1");
       düğme2 = new Button("Düğme2");
       kalbur.add(düğme1);
       kalbur.attach(düğme2,3,4,1,1);

       showAll();
   }
}

void main(string[] değişkenler)
{
   Main.init(değişkenler);
   auto pencere = new Pencere();
   Main.run();
}

--
[ Bu gönderi, http://ddili.org/forum'dan dönüştürülmüştür. ]

Çünkü anladığım kadarıyla düğme2'yi göreceli olarak düğme1'in bir tarafına yerleştiriyoruz. Yani sağına altına ya da köşesine.

       //kalbur.attach(düğme2,1,0,2,1);
       //kalbur.attach(düğme2,0,1,2,1);
       kalbur.attach(düğme2,1,1,2,1);

--
[ Bu gönderi, http://ddili.org/forum'dan dönüştürülmüştür. ]

hiç öyle düşünmemiştim ama çok doğru bu.. buna ek olarak aşağıdaki kodu çalıştırıp edindiğim tecrübe doğrultusunda şunu da söyleyebiliyoruz sanırım;

attach() işlevini kullanırken aslında gridi genişleyebilen bir hücre alanı gibide düşünebiliriz zira eklenen her yeni nesne (widget işte adı her ne ise) aslında hücreyi yukarı-aşağı yada sağa-sola olarak bir genişletme yapmaktadır. Bu durumda ilk nesne baz alınmak kaydıyla yukarıda bahsettiğimiz parametreleri değerleri kadar oynatabilmekteyiz.. Örneğimize bakarsak;

import gtk.Main;
import gtk.MainWindow;
import gtk.Grid;
import gtk.Button;

class Pencere: MainWindow
{
   Grid kalbur;
   Button düğme1, düğme2, düğme3,düğme4,düğme5,düğme6,düğme7;

   this()
   {
       super("Kalbur örneği");
       kalbur = new Grid();
       add(kalbur);
	resize(560,250);

       düğme1 = new Button("Düğme1");
       düğme2 = new Button("Düğme2");
		düğme3 = new Button("Düğme3");
		düğme4 = new Button("Düğme4");
		düğme5 = new Button("Düğme5");
		düğme6 = new Button("Düğme6");
		düğme7 = new Button("Düğme6");

       kalbur.add(düğme1);
       kalbur.attach(düğme2,1,1,1,1);
		kalbur.attach(düğme3,2,2,1,1);
		kalbur.attach(düğme4,3,3,1,1);
		kalbur.attach(düğme5,4,4,1,1);
		kalbur.attach(düğme6,5,5,1,1);
		kalbur.attach(düğme7,2,6,1,1);

       showAll();
   }
}

void main(string[] değişkenler)
{
   Main.init(değişkenler);
   auto pencere = new Pencere();
   Main.run();
}

normalde kalbur.attach(düğme7,2,6,1,1); bu satırı düğme1 den sonra direk eklemiş olsaydık düğme birde mevcut gridimiz aslında 1 satır ve 1 sutunluk bir yer işkal edeceğinden dolayı sadece düğme1 den 1 sutun yada 1 satır hareket mümkündü Oysa kalbur.attach(düğme6,5,5,1,1); ifadesi ile aslında grid 5 satır ve 5 sutunluk genişlemiş olduğundan dolayı düğme1 baz alınmak kaydıyla kalbur.attach(düğme7,2,6,1,1); ifadesindeki 2 ve 6 iparametreleri haliyle iş yapacaktır..
desteğiniz için çok sağolun

--
[ Bu gönderi, http://ddili.org/forum'dan dönüştürülmüştür. ]

Erdem hocam selamlar..
sitenizdeki bir örnek hakkında bir soru soracağım;

import gtk.Ana;
import gtk.AnaPencere;
import gtk.Düğme;
import gtk.Kutu;

import std.stdio;

class Pencere: AnaPencere
{
   Kutu anaKutu;
   Düğme düğme;

   this()
   {
       super("Düğme örneği");

       çerçeveGenişliğiBelirle(10);

       anaKutu = new Kutu(YATAY, 6);
       ekle(anaKutu);

       düğme = new Düğme("Bana tıklayın");
       düğme.tıklandığında(&banaTıklayınaTıklandı);
       anaKutu.atSepete(düğme, true, true, 0);

       düğme = new Düğme("_Aç");
       düğme.tıklandığında(&açDüğmesineTıklandı);
       anaKutu.atSepete(düğme, true, true, 0);

       düğme = new Düğme("_Kapat");
       düğme.tıklandığında(&kapatDüğmesineTıklandı);
       anaKutu.atSepete(düğme, true, true, 0);

       tümünüGöster();
   }

   void banaTıklayınaTıklandı(Düğme düğme)
   {
       writeln("\"Bana tıklayın\" düğmesine tıklandı");
   }

   void açDüğmesineTıklandı(Düğme düğme)
   {
       writeln("\"Aç\" düğmesine tıklandı");
   }

   void kapatDüğmesineTıklandı(Düğme düğme)
   {
       writeln("Uygulamayı kapatıyorum");
       Ana.çıkış();
   }
}

void main(string[] değişkenler)
{
   Ana.ilklendir(değişkenler);
   auto pencere = new Pencere();
   Ana.çalıştır();
}

Burada 'düğme.tıklandığında(&banaTıklayınaTıklandı);' ifadesinde "'&banaTıklayınaTıklandı'" ile anladığım kadarıyla 'banaTıklayınaTıklandı' işlevi çalıştırılıyor.. Bu noktada '"&"' yu kullanmamızın sebebi nedir ?

ayrıca aşağıdaki kısımda;

' void banaTıklayınaTıklandı(Düğme düğme)
{
writeln(""Bana tıklayın" düğmesine tıklandı");
}'

banaTıklayınaTıklandı() işlevinde (Düğme düğme) nesnesi arguman olarak veriliyor fonksiyon içinde hiç kullanılmamasına rağmen ?

Teşekkür ederim..

--
[ Bu gönderi, http://ddili.org/forum'dan dönüştürülmüştür. ]

Alıntı (cos00kun):

Bu basitçe düğme tıklandığında bu işlevi çağır demek.

Alıntı (cos00kun):

	gulong addOnClicked(void delegate(Button) dlg, ConnectFlags connectFlags=cast(ConnectFlags)0)
	{
              /* .. */
	}

tıklandığında 'addOnClicked' işlevinin bildirim şu şekilde. Parametre olarak da bir düğme alıyor. Böylece 'addOnClicked' işlevinin de hangi düğmenin tıklandığından haberi olmuş oluyor.

--
[ Bu gönderi, http://ddili.org/forum'dan dönüştürülmüştür. ]

GtkD kütüphanesinde Layout sınıfı ne işe yarıyor peki ? Layoutların genelde kullanım amacı nedir ?
teşekkürler

--
[ Bu gönderi, http://ddili.org/forum'dan dönüştürülmüştür. ]