KDevelop El Kitabı

# KDevelop El Kitabı

Bu belgelendirme, KDE UserBase KDevelop4/El Kitabı sayfasından dönüştürülmüştür.

Çeviri: Emir SARI
Baskı KDevelop 4.4 (KDE
4.9) (2012‒08‒19)

Yasal Uyarı

KDevelop, çok çeşitli programlama görevlerinde kullanılan bir tümleşik geliştirme ortamıdır.

Bölüm 1. KDevelop nedir?
KDevelop nedir?

# Bölüm 1. KDevelop nedir?

KDevelop, C++ (ve diğer başka diller) için KDE tarafından geliştirilen bir tümleşik geliştirme ortamıdır. Linux® üzerinde çalışır (örneğin, GNOME gibi başka masaüstü ortamlarını kullansanız bile); ancak başka UNIX® varyantlarında ve Windows üzerinde de kullanabilirsiniz.

KDevelop, tüm çağdaş tümleşik geliştirme ortamlarının kolaylıklarını sunar. Büyük proje ve uygulamalar için en önemli özelliklerinden biri ise KDevelop C++ anlar: Tüm kod tabanını ayrıştırır ve hangi sınıfların hangi üye işlevleri içerdiğini, değişkenlerin nerede tanımlandığını, türlerinin ne olduğunu ve kodunuz hakkında bunun gibi birçok şeyi bilir. Örneğin, projelerinizden bir tanesinin aşağıdaki gibi bir sınıf beyan ettiğini varsayalım:

    class Car {
      // …
      public:
        std::string get_color () const;
    };

ve sonrasında programınızda aşağıdaki kod parçasının olduğunu:

    Car my_ride;
    // bu değişkenle bir şeyler yap
    std::string color = my_ride.ge

Son satırdaki `my_ride` ögesinin `Car` türünün bir değişkeni olduğunu anımsar ve hem `ge` ögesini `get_color()` olarak tamamlamayı önerir; çünkü bu, `Car` sınıfında böyle başlayan tek değişkendir. Yazmayı sürdürmek yerine tam sözcüğü almak için yalnızca Giriş düğmesine basın; bu size zaman kazandırır; yanlış yazımları önler ve büyük projelerdeki yüzlerce veya binlerce değişkeni veya sınıfı ezberlemekten sizi kurtarır.

İkinci bir örnek olarak, aşağıdaki gibi bir kodunuz olduğunu varsayalım:

    double foo ()
    {
      double var = my_func();
     return var * var;
    }
    double bar ()
    {
      double var = my_func();
      return var * var * var;
    }

`bar` işlevindeki `var` sembolünün üzerine fareyi getirirseniz bu sembolün tüm kullanımlarını görme seçeneğini elde edersiniz. Üzerine tıkladığınızda, yalnızca bu değişkenin `bar` işlevindeki kullanımları gösterilir; çünkü KDevelop, `foo` işlevindeki `var` değişkeninin bununla hiçbir ilgisi olmadığını anlar. Benzer şekilde, değişken adına sağ tıklamak, değişkeni yeniden adlandırmanıza olanak tanır; bunu yapmak yalnızca `bar` içindeki değişkene dokunur, `foo` içindeki aynı adlı değişkene dokunmaz.

Ancak KDevelop yalnızca akıllı bir kod düzenleyicisi değildir; KDevelop yazılımının iyi yaptığı başka şeyler de vardır. Açıkça, kaynak kodunu farklı renklerle vurgular; özelleştirilebilir bir girintileme sistemine sahiptir; GNU hata ayıklayıcısı gdb için tümleşik bir arayüze sahiptir; fareyi bu işlevin bir kullanımının üzerine getirdiğinizde size bir işlevin belgelendirmesini gösterebilir; farklı türdeki yapı ortamları ve derleyicilerle (örneğin make ve cmake tabanlı projelerle) ve bu kılavuzda anlatılan birçok başka güzel şeyle bağlantı kurabilir.

Bölüm 2. Oturumlar ve projeler: KDevelop temelleri
Oturumlar ve projeler: KDevelop temelleri

# Bölüm 2. Oturumlar ve projeler: KDevelop temelleri

Bu bölümde, KDevelop yazılımının dünyayı nasıl gördüğüne ve işi nasıl yapılandırdığına dair bazı terminolojileri ele alacağız. Özellikle, oturumlar ve projeler kavramlarını tanıtacağız ve KDevelop yazılımında üzerinde çalışmak istediğiniz projeleri nasıl ayarlayabileceğinizi açıklayacağız.

## Terminoloji

KDevelop, oturumlar ve projeler kavramlarını kullanır. Bir oturum, birbirleriyle ilgisi olan tüm projeleri içerir. Aşağıdaki örnekler için hem bir kitaplığın hem de onu kullanan bir uygulamanın geliştiricisi olduğunuzu varsayalım. Çekirdek KDE kitaplıklarının birincisi, KDevelop yazılımını ise ikincisi olarak düşünebilirsiniz. Başka bir örnek: Diyelim ki bir Linux® çekirdeği geliştiricisisiniz; ancak henüz çekirdek ağacına eklenmemiş bir Linux® aygıt sürücüsü üzerinde çalışıyorsunuz.

Yani ikincisini örnek olarak alırsak, KDevelop üzerinde iki projeye sahip bir oturumunuz olurdu: Linux® çekirdeği ve aygıt sürücüsü. Bunları tek bir oturumda gruplamak isteyeceksiniz (her biri tek bir projeye sahip iki oturum yerine) çünkü sürücü için kaynak kodu yazdığınızda KDevelop üzerinde çekirdek işlevlerini ve veri yapılarını görebilmek faydalı olacaktır — örneğin çekirdek işlevi ve değişken adlarının kendiliğinden genişletilmesini sağlayabilmeniz veya aygıt sürücüsünde çalışırken çekirdek işlevi belgelendirmesini görebilmeniz için.

Şimdi sizin de bir KDE geliştiricisi olduğunuzu düşünelim. O zaman KDE’yi bir proje olarak içeren ikinci bir oturumunuz olurdu. Prensipte tüm bunlar için sadece bir oturumunuz olabilirdi; ancak bunun gerçek bir nedeni yoktur: KDE çalışmanızda çekirdek veya aygıt sürücüsü işlevlerine erişmeniz gerekmez; ve Linux® çekirdeği üzerinde çalışırken KDE sınıf adlarının kendiliğinden genişletilmesini istemezsiniz. Son olarak, KDE kitaplıklarından bazılarını derlemek, Linux® çekirdeğini yeniden derlemekten bağımsızdır (oysa aygıt sürücüsünü derlediğinizde, çekirdek üstbilgi dosyalarından bazıları değişmişse Linux® çekirdeğini yeniden derlemek de iyi olur).

Son olarak, oturumların bir diğer kullanımı da hem projenin geçerli geliştirme sürümünde hem de bir dalda çalışmanız durumunda gerçekleşir: bu durumda, KDevelop yazılımının ana dalda ve dala ait sınıfları karıştırmasını istemezsiniz; böylece aynı proje kümesine sahip ancak farklı dizinlerden (farklı geliştirme dallarına karşılık gelen) iki oturumunuz olur.

Bir oturum açmak ve var olan bir projeyi içe aktarmak
Bir oturum açmak ve var olan bir projeyi içe aktarmak

## Bir oturum açmak ve var olan bir projeyi içe aktarmak

Şimdilik Linux® çekirdeği ve aygıt sürücüsü örneğimizle sürdürelim — kendi projeleriniz yerine bu iki örneği kullanmak isteyebilirsiniz. Bu iki örneği içeren iki projeyle yeni bir oturum oluşturmak için sol üstteki Oturum → Yeni Oturum Başlat menü ögesini (veya bu KDevelop yazılımını ilk kullanımınızsa ilk açılıştaki boş oturumu) kullanın.

Şimdi bu oturumu, şu an için bir yerde hâlihazırda var olduğunu varsaydığımız projelerle doldurmak istiyoruz (projeleri sıfırdan başlatma durumu bu kılavuzun başka bir yerinde ele alınmıştır). Bunun için projenin sabit diskinizde bir yerde olup olmamasına veya bir sunucudan indirilmesi gerekip gerekmediğine bağlı olarak özünde iki yöntem vardır.

### 1. seçenek: Bir sürüm denetim sistemi sunucusundan bir proje içe aktarmak

Öncelikle kurmak istediğimiz projenin —Linux® çekirdeğinin— bir sunucudaki bir sürüm denetim sisteminde bulunduğunu; ancak henüz yerel sabit diskinize çıkış yapmadığınızı varsayalım. Bu durumda, Proje menüsüne giderek Linux® çekirdeğini geçerli oturum içinde bir proje olarak oluşturun ve ardından şu adımları izleyin:

- Bir proje içe aktarmak için Proje → Proje Getir menü seçeneğini kullanın.

- Daha sonra, kaynak dosyalarının nereden gelmesi gerektiğine bağlı olarak, geçerli oturumda yeni bir proje başlatmak için birden fazla seçeneğiniz olur: KDevelop yazılımını var olan bir dizine yönlendirebilirsiniz (aşağıdaki 2. seçeneğe bakın) veya KDevelop yazılımının kaynakları bir depodan almasını isteyebilirsiniz.

- Daha önceden çıkışını yaptığınız bir sürüm olmadığını varsayarsak:

  - İletişim kutusunda Kaynak Seç altında Dosya Sisteminden, Subversion, Git, GitHub veya KDE seçeneklerinden birini seçin.

  - Kaynakların çıkış yapılacağı hedef olarak bir çalışma dizini seçin.

  - Kaynak dosyalarının edinilebileceği deponun konumunu belirten bir URL seçin.

  - Al düğmesine tıklayın. Bağlantınızın hızına ve projenin büyüklüğüne bağlı olarak bu biraz vakit alabilir. Ne yazık ki, KDevelop 4.2.x sürümünde ilerleme çubuğu bir şey bildirmez; ancak

        du -sk /projeye/olan/KDevelop/yolu

    komutunun çıktısına bakarak ne kadar verinin indirildiğine bakabilirsiniz.

### Not

İlerleme çubuğuyla ilgili olan sorun KDevelop 256832 numaralı hata kaydında bildirildi.

### Not

Bu süreçte ayrıca proje için geçerli bir konum belirtmeniz gerekiyor hata iletisini da alıyorum, ancak bu ileti yok sayılabilir.

- Bu dizinde bir KDevelop proje dosyası seçmenizi ister. Büyük olasılıkla henüz bir tane olmadığından, yalnızca Sonraki düğmesine basın.

- Bir kez daha Sonraki düğmesine tıklayın.

- KDevelop şimdi bir proje yöneticisi seçmenizi isteyecek. Bu proje standart UNIX® make dosyalarını kullanıyorsa özel makefile proje yöneticisini seçin.

- KDevelop daha sonra tüm projeyi ayrıştırmaya başlayacaktır. Yine, tüm dosyaları ve dizin sınıflarını vb. incelemek oldukça uzun sürecektir. Ana pencerenin sağ alt kısmında, bu sürecin ne kadar sürdüğünü gösteren bir ilerleme çubuğu vardır (Birden çok işlemci çekirdeğiniz varsa bu süreci Ayarlar → KDevelop Uygulamasını Yapılandır menü ögesini seçip sonrasında solda Arka Plan Ayrıştırıcısı seçeneğinden arka planda ayrıştırma için kullanılacak iş parçacığı sayısını artırarark ivmelendirebilirsiniz).

### Seçenek 2: Hâlihazırda sabit diskinizde bulunan bir projeyi içe aktarmak

Alternatif olarak, üzerinde çalışmak istediğiniz proje sabit diskinizde hâlihazırda bulunuyorsa (örneğin, internetten bir tar arşivi indirmiş olabilirsiniz, bir sürüm denetim sisteminden çıkış yapmış olabilirsiniz veya yalnızca sizin sabit diskinizde bulunan bir proje de olabilir) o zaman Projeler → Proje Aç/İçe Aktar menü seçeneğini kullanın ve iletişim kutusundan projenizin bulunduğu dizini seçin.

İkinci bir proje olarak bir uygulamayı ayarlamak
İkinci bir proje olarak bir uygulamayı ayarlamak

## İkinci bir proje olarak bir uygulamayı ayarlamak

Yapmak isteyeceğiniz bir sonraki şey aynı oturumda diğer projeleri ayarlamaktır. Yukarıdaki örnekte, aygıt sürücüsünü ikinci proje olarak eklemek isteyebilirsiniz, bunu da tam olarak aynı adımları kullanarak yapabilirsiniz.

Birden fazla uygulamanız veya kitaplığınız varsa oturumunuza daha fazla proje eklemek için adımları yinelemeniz yeterlidir.

En baştan proje oluşturmak
En baştan proje oluşturmak

## En baştan proje oluşturmak

Elbette sıfırdan yeni bir projeye başlama olasılığınız da vardır. Bunu, size bir şablon seçim iletişim kutusu sağlayacak Projeler → Şablondan Yeni… menü ögesiyle yapabilirsiniz. Bazı proje şablonları KDevelop ile verilir; daha fazlasını K Uygulama Şablonu uygulamasını kurarak edinebilirsiniz. İletişim kutusundan proje türünü ve programlama dilini seçin, projeniz için bir ad ve konum girip Sonraki düğmesine tıklayın.

İletişim kutusunun ikinci sayfası bir sürüm denetim sistemi kurmanıza olanak tanır. Kullanmak istediğiniz sistemi seçin ve gerekirse sisteme özgü yapılandırmayı doldurun. Bir sürüm denetim sistemi kullanmak istemiyorsanız veya daha sonra elle ayarlamak isterseniz Yok seçeneğini seçin. Seçiminizden memnunsanız Bitir düğmesine tıklayın.

Projeniz artık oluşturuldu, bu yüzden onu yapmayı veya kurmayı deneyebilirsiniz. Bazı şablonlar kod içinde yorumlar veya hatta ayrı bir README dosyası içerecektir ve bunları önce okumanız önerilir. Ardından, istediğiniz özellikleri ekleyerek projeniz üzerinde çalışmaya başlayabilirsiniz.

Bölüm 3. Kaynak kodu ile çalışmak
Kaynak kodu ile çalışmak

# Bölüm 3. Kaynak kodu ile çalışmak

Hata ayıklamanın yanı sıra, kaynak kodunu okumak ve yazmak, yazılım geliştirirken en çok zaman harcayacağınız şeydir. Bu amaçla, KDevelop size kaynak kodlarını keşfetmeniz ve yazmayı daha üretken hale getirmeniz için birçok farklı yol sunar. Aşağıdaki bölümlerde daha ayrıntılı olarak açıklandığı üzere, KDevelop yalnızca bir kaynak düzenleyicisi değildir — bunun yerine, oturumunuzun kaynak kodunu toplu olarak oluşturan dosyalardaki çıkarılan bilgilerin farklı görünümlerini size sunan bir kaynak yönetim sistemidir.

## Araçlar ve görünümler

Projelerle çalışmak için KDevelop araçlar kavramını kullanır. Bir araç, kaynağın belirli bir görünümünü veya onunla gerçekleştirilebilecek bir eylemi sağlar. Araçlar, pencerenizin çevresi etrafındaki düğmelerle temsil edilir (sol ve sağ kenar boşlukları boyunca dikey metinde veya alt kenar boşluğu boyunca yatay olarak). Üzerilerine tıklarsanız ana pencere içinde bir alt pencereye genişlerler, bir görünüm de diyebilirsiniz; araç düğmesine yeniden tıklarsanız alt pencere bir kez daha kaybolur.

Bir alt pencereyi yok etmek için alt pencerenin sağ üst köşesindeki x işaretine de tıklayabilirsiniz.

Yukarıdaki resimde, sol ve sağ kenarlara hizalanmış belirli bir araç seçimi gösterilmektedir; resimde, solda Sınıflar aracı, sağda Kod Parçacıkları aracı açıktır ve ortada bir kaynak dosyası düzenleyicisi vardır. Pratikte, çoğu zaman muhtemelen sadece düzenleyiciniz ve belki de Sınıflar veya Kod Tarayıcısı aracınız solda açık olacaktır. Diğer araç görünümü, büyük olasılıka aracı kullandığınızda yalnızca geçici olarak açık olacaktır ve bu da çoğu zaman düzenleyici için daha fazla alan bırakacaktır.

KDevelop yazılımını ilk kez çalıştırdığınızda, Projeler araç düğmesine hâlihazırda sahip olmalısınız. Üzerine tıklayın: Altta oturuma eklediğiniz projeleri gösteren bir alt pencere ve üstte projelerinizin dizinlerinin bir dosya sistemi görünümü açılacaktır.

KDevelop ile kullanabileceğiniz birçok başka araç vardır; ancak bunların hepsi başlangıçta ortamda düğmeler olarak kullanılabilir değildir. Birkaç tane eklemek için Pencereler → Araç Görünümü Ekle menü girdisini kullanın. Aşağıda belki işinize yarayabilecek birkaç tanesini bulacaksınız:

- Sınıflar: Projelerinizden birinde veya oturumunuzda tanımlanmış tüm sınıfların, tüm üye işlevleri ve değişkenleriyle birlikte tam listesi. Üyelerden herhangi birine tıklamak, tıkladığınız ögenin konumunda bir kaynak düzenleyicisi penceresi açar.

- Belgeler: Son zamanlarda açılan dosyaların bazılarını türlerine göre listeler (örneğin kaynak, yama, düz metin dosyaları).

- Kod Tarayıcısı: Dosyadaki imleç konumunuza bağlı olarak bu araç, ilişkili olan şeyleri gösterir. Örneğin, bir `#include` satırındaysanız içerdiğiniz dosya hakkında bilgi gösterir, örneğin o dosyada hangi sınıfların beyan edildiği gibi; dosya kapsamında boş bir satırdaysanız geçerli dosyada beyan edilen ve tanımlanan sınıfları ve işlevleri gösterir (tümünü bağlantı olarak; bunlara tıklamak sizi dosyada beyanın veya tanımın gerçekte bulunduğu noktaya götürür); bir işlev tanımındaysanız beyanın nerede olduğunu gösterir ve işlevin kullanıldığı yerlerin bir listesini sunar.

- Dosya Sistemi: Dosya sisteminin ağaç görünümünü gösterir.

- Belgelendirme: Kılavuz sayfalarında ve diğer yardım belgelerinde arama yapmanıza olanak tanır.

- Kod Parçaları: Bu, sürekli yeniden kullanılan ve her kerede yazmak istemeyeceğiniz metin dizileri sağlar. Örneğin, yukarıdaki resmin oluşturulduğu projede, şöyle kod yazmaya sıklıkla gereksinim duyulur:

    for (typename Triangulation< dim>::active_cell_iterator cell
          = triangulation.begin_active();
       cell != triangulation.end();
       ++cell)

Bu garip bir ifadedir; ancak böyle bir döngüye her gereksinim duyduğunuzda neredeyse tam olarak buna benzeyecektir — bu da onu bir kod parçası için iyi bir aday yapar.

- Konsol: Arada sırada girmek isteyebileceğiniz komutlar için KDevelop ana penceresinde bir komut satırı penceresi açar (örneğin `./configure` çalıştırmak için).

Araçların ve görünümlerin tam bir listesine buradan ulaşabilirsiniz.

Birçok programcı için dikey ekran alanı en önemlisidir. Bu amaçla, araç görünümlerinizi pencerenin sol ve sağ kenarına yerleştirebilirsiniz: Bir aracı taşımak için sağ fare düğmesiyle sembolüne tıklayın ve yeni bir konum seçin.

Kaynak koda göz atmak
Kaynak koda göz atmak

## Kaynak koda göz atmak

### Yerel bilgi

KDevelop kaynak kodlarını anlar ve bunun bir sonucu olarak, programınızda olan değişkenler ve işlevler hakkında size bilgi sağlamada pek iyidir. Örneğin, bir kod parçasıyla çalışırken 1316. satırdaki `cell` simgesinin üzerine fareyi getirdiğinizde ne olacağını aşağıda görebilirsiniz (klavye odaklı çalışıyorsanız, Seçenek düğmesini bir süre basılı tutarak aynı etkiyi elde edebilirsiniz):

KDevelop, değişkenin türünü içeren bir araç ipucu, (burada: `DoFHandler<dim>active_cell_iterator`), bu değişkenin nerede beyan edildiğini, (kapsayıcısını, burada bu bir yerel değişken olduğundan kapsayan `get_maximal_velocity` işlevidir), ne olduğunu (bir değişken; bir işlev, sınıf veya ad alanı değil) ve nerede beyan edildiğini (az yukarıda, 1314. satırda) gösterir.

Geçerli bağlamda, farenin üzerinde gezindiği sembolün ilişkili bir belgelendirmesi yoktur. Bu örnekte fare, 1318. satırdaki `get_this_mpi_process` sembolünün üzerine gelseydi, sonuç şu olurdu:

Burada KDevelop, tümüyle farklı bir dosyadaki (`utilities.h`, ki bu dosya aslında aynı oturumun farklı bir projesinde yer almaktadır) beyana, beyana eşlik eden doxygen tarzı yorumla birlikte çapraz başvurmuştur.

Bu araç ipuçlarını daha da kullanışlı kılan şey devingen olmalarıdır: Değişkenin beyan edildiği bağlam hakkında bilgi almak için kapsayıcıya tıklayabilirim (başka bir deyişle `Sistem` ad alanı; örneğin nerede beyan edildiği, kullanıldığı veya belgelendirmesinin nerede olduğu hakkında) ve imleç konumunu sembolün beyan edildiği konuma sıfırlayacak mavi bağlantılara tıklayabilirim (örneğin, `utilities.h`, 289. satır) veya bana bu sembolün geçerli dosyada veya geçerli oturumun tüm projelerinde kullanıldığı yerlerin bir listesini alabilirim. İkincisi örneğin, belirli bir işlevin büyük bir kod tabanında nasıl kullanıldığını keşfetmek istiyorsanız genellikle yararlıdır.

### Not

Bir araç ipucundaki bilgiler geçicidir — Seçenek düğmesine basılı tutmanıza veya farenizi üzerinde gezdirmenize bağlıdır. Bunun için daha kalıcı bir yer istiyorsanız alt pencerelerden birinde Kod Tarayıcısı araç görünümünü açın. Örneğin, burada imleç yukarıdaki örnektekiyle aynı işlevin üzerindedir ve soldaki araç görünümü, önceki araç ipucundakiyle aynı türde bilgileri sunar:

İmleci sağda hareket ettirmek, solda sunulan bilgileri değiştirir. Dahası, sağ üstteki Geçerli Görünümü Kilitle düğmesine tıklamak, bu bilgileri kilitlemenizi ve orada sunulan bilgileri incelerken imleç hareketinden bağımsız hale getirmenizi sağlar.

### Not

Bu tür bağlam bilgileri KDevelop yazılımında yalnızca kaynak düzenleyicisinde değil, birçok başka yerde de bulunur. Örneğin, bir tamamlama listesinde Seçenek düğmesine basılı tutmak (örneğin tez aç yaparken) geçerli sembol hakkındaki bağlam bilgilerini de verir.

### Dosya kapsamı bilgisi

Bir sonraki düzey, şu anda üzerinde çalıştığınız tüm kaynak dosyası hakkında bilgi edinmektir. Bu amaçla, imleci geçerli dosyadaki dosya kapsamına yerleştirin ve Kod Tarayıcısı aracının görünümünün ne gösterdiğine bakın:

Burada, geçerli dosyada bildirilen veya beyan edilen ad alanlarının, sınıfların ve işlevlerin bir listesi gösterilir ve bu dosyada neler olup bittiğine dair genel bir bakış sunulur ve dosyada yukarı aşağı sarma yapmadan veya belirli bir sembolü aramadan doğrudan bu beyanlardan veya tanımlardan herhangi birine gitmenize olanak tanır.

### Not

Dosya kapsamı için gösterilen bilgiler, aşağıda kaynak kodunda gezinme konusunda açıklanan “Ana Hat” kipinde sunulan bilgilerle aynıdır; fark, ana hat kipinin yalnızca geçici bir araç ipucu olmasıdır.

### Proje ve oturum kapsamı bilgisi

Bir projenin tümü (veya aslında bir oturumdaki tüm projeler) hakkında bilgi edinmenin birçok yolu vardır. Bu tür bilgiler genellikle çeşitli araç görünümleri aracılığıyla sağlanır. Örneğin, Sınıflar araç görünümü, bir oturumdaki tüm projeler için tüm sınıfların ve çevreleyen ad alanlarının bir ağaç yapısını, bu sınıfların her birinin üye işlevleri ve değişkenleriyle birlikte sağlar:

Bir girdinin üzerine gelindiğinde sembol, beyan ve tanım konumu ve kullanımları hakkında yeniden bilgi sağlanır. Bu ağaç görünümünde bir girdiye çift tıklandığında sembolün beyan edildiği veya tanımlandığı konumda bir düzenleyici penceresi açılır.

Ancak global bilgilere bakmanın başka yolları da vardır. Örneğin, Belgeler aracı, bir projenin, bu projenin hangi tür dosyalardan veya diğer belgelerden oluştuğu açısından bir görünüm sağlar:

### Gökkuşağı renkli vurgulamanın açıklaması

K Geliştir, kaynak kodundaki farklı nesneleri vurgulamak için çeşitli renkler kullanır. Farklı renklerin ne anlama geldiğini biliyorsanız tek bir karakter okumadan, yalnızca renklere bakarak kaynak kodundan tez çok fazla bilgi çıkarabilirsiniz. Vurgulama kuralları aşağıdaki gibidir:

- Sınıf/Yapı türündeki nesnelerin, enümerasyonların (değerler ve tür), (global) işlevlerin ve sınıf üyelerinin her birinin kendine ait bir rengi vardır (sınıflar yeşil, enümerasyonlar koyu kırmızı ve üyeler koyu sarı veya mor, (global) işlevler her zaman mor renktedir).

- Tüm global değişkenler koyu yeşil renkle gösterilir.

- Başka bir türün tür tanımı olan tanımlayıcılar mavi–yeşil renktedir.

- Nesnelerin tüm beyanları ve tanımları kalın yazıyla gösterilmiştir.

- Bir üyeye tanımlandığı bağlamın (temel veya türetilmiş sınıf) içinden erişiliyorsa üye sarı renkte, aksi takdirde mor renkte görünür.

- Eğer bir üye özel veya korumalı ise kullanıldığında biraz daha koyu bir renge bürünür.

- Bir işlev gövdesi kapsamına yerel değişkenler için gökkuşağı renkleri tanımlayıcının bir karmasına göre seçilir. Bu, işleve ait parametreleri içerir. Bir tanımlayıcı, kapsamı içinde her zaman aynı renge sahip olacaktır (ancak aynı tanımlayıcı, farklı bir nesneyi temsil ediyorsa yani daha iç içe geçmiş bir kapsamda yeniden tanımlanıyorsa farklı bir renk alacaktır) ve genellikle farklı kapsamlarda aynı tanımlayıcı adı için aynı rengi alırsınız. Bu nedenle, aynı adlara sahip parametreler alan birden fazla işleviniz varsa argümanların hepsi aynı renk açısından görünecektir. Bu gökkuşağı renkleri, ayarlar iletişim kutusundaki global renklendirmeden ayrı olarak kapatılabilir.

- KDevelop yazılımının karşılık gelen beyanı belirleyemediği tanımlayıcılar beyaz renkle gösterilir. Bu bazen eksik `#include` yönergelerinden kaynaklanabilir.

- Bu renklendirmeye ek olarak, Kate’den bilindiği gibi normal düzenleyici sözdizim vurgulaması uygulanacaktır. Bir çakışma olması durumunda KDevelop yazılımının anlamsal vurgulaması her zaman düzenleyici vurgulamasını geçersiz kılacaktır.

Kaynak kodda dolaşmak
Kaynak kodda dolaşmak

## Kaynak kodda dolaşmak

Önceki bölümde kaynak kodunu keşfetmeyi; yani semboller, dosyalar ve projeler hakkında bilgi edinmeyi ele aldık. Sonraki adım kaynak tabanınızda, yani içinde dolaşmaktır. Bunun olanaklı olduğu çeşitli düzeyler vardır: Yerel, bir dosya içinde ve bir proje içinde.

### Not

Kodda dolaşmanın birçok yoluna KDevelop ana penceresindeki Dolaşım menüsünden erişilebilir.

### Yerel dolaşım

KDevelop bir düzenleyiciden çok daha fazlasıdır; ancak aynı zamanda bir kod düzenleyicisidir de. Doğal olarak, bir kaynak kodu dosyasında imleci yukarı, aşağı, sağa ve sola hareket ettirebilirsiniz. Ayrıca, Sayfa Yukarı ve Sayfa Aşağı düğmelerini ve herhangi başka kullanışlı bir düzenleyiciden alışık olduğunuz diğer tüm komutları kullanabilirsiniz.

### Dosya kapsamı dolaşımı ve ana hat kipi

Dosya temelinde KDevelop, kaynak kodunda dolaşım için birçok olası yol sunmaktadır. Örneğin:

- Ana Hat: Geçerli dosyada ne olduğunu en az üç farklı şekilde ana hatlarıyla öğrenebilirsiniz:

  - Ana pencerenin sağ üst köşesindeki Ana Hat metin kutusuna tıklamak veya Seçenek+Kontrol+N düğme kombinasyonunu kullanmak, tüm işlev ve sınıf beyanlarını listeleyen bir açılır menü açar:

    Daha sonra hangisine atlayacağınızı seçebilirsiniz veya —eğer çok sayıda varsa— gösterilen adlarda görünebilecek herhangi bir metni yazmaya başlayabilirsiniz; bu durumda, yazmayı sürdürdükçe, daha önce yazılmış metinle uyuşmayan adlar kaldırılacağı için liste giderek küçülür ve siz seçimlerden birini çok daha rahat kullanabilirsiniz.

  - İmleci dosya kapsamında konumlandırmak (başka bir deyişle herhangi bir işlev/sınıf beyanının veya tanımının dışında konumlandırmak) ve Kod Tarayıcısı aracını açmak:

    Bu ayrıca, size geçerli dosyada neler olup bittiğine dair bir ana hat sunar ve nereye atlamak istediğinizi seçmenize olanak tanır.

  - Açık dosyalardan birinin sekmesinin üzerine fareyi getirdiğinizde, o sekmedeki dosyanın ana hatları da görüntülenir.

- Kaynak dosyaları, işlev beyanları veya tanımlarının bir listesi olarak düzenlenir. Seçenek+Kontrol+Sayfa Yukarı ve Seçenek+Kontrol+Sayfa Aşağı düğmelerine basmak, bu dosyadaki önceki veya sonraki işlev tanımına atlar.

### Proje ve oturum kapsamında dolaşım: Anlamsal dolaşım

Diğer yerlerde belirtildiği gibi, KDevelop genellikle tek tek kaynak dosyalarını dikkate almaz, bunun yerine projeleri bir bütün olarak (veya daha doğrusu, geçerli oturumun parçası olan tüm projeleri) ele alır. Sonuç olarak, tüm projelerde dolaşmak için birçok olasılık sunar. Bunlardan bazıları kaynak koda göz atmak bölümünde daha önce açıkladığımız şeylerden türetilmiştir, diğerleri ise gerçekten farklıdır. Ortak tema, bu gezinme özelliklerinin kodun anlamsal anlayışına dayanmasıdır; yani size tüm projeleri ayrıştırmayı ve verileri bağlamayı gerektiren bir şey sunarlar. Aşağıdaki liste, potansiyel olarak çok sayıda dosyaya dağılmış kaynak kodunda gezinmenin bazı yollarını gösterir:

- Kaynak koda göz atmak bölümünde görüldüğü üzere, fareyle üzerine gelerek veya Seçenek düğmesini bir süre basılı tutarak bireysel ad alanları, sınıf, işlev veya değişken adlarını açıklayan bir araç ipucu gösterebilirsiniz. Bir örnek için:

  Bir sembolün beyanı için bağlantılara tıklamak veya kullanım listesini genişletmek, gerekirse ilgili dosyayı açıp imleci ilgili konuma yerleştirmek suretiyle bu konumlara atlamanızı sağlar. Benzer bir etki, daha önce tartışılan Kod Tarayıcısı araç görünümü kullanılarak da elde edilebilir.

- Araç ipucundaki bağlantılara tıklamak zorunda kalmadan bir sembolün beyanına atlamanın daha tez bir yolu da Kaynak Tarama Kipi kipini Seçenek veya Kontrol düğmelerine basılı tutarak geçici olarak etkinleştirmektir. Bu kipte, bir sembolün beyanına doğrudan atlamak için üzerine tıklamak yeterlidir.

- Tez Aç: Diğer dosyalara veya konumlara atlamanın çok güçlü bir yolu, KDevelop yazılımındaki çeşitli tez aç yöntemlerini kullanmaktır. Bunların dört sürümü vardır:

  - Tez Sınıf Aç (Dolaşım → Tez Sınıf Aç veya Seçenek+Kontrol+C): Bu oturumda tüm sınıfların bir listesini alırsınız. Bir sınıfın adını (bir kısmını) yazmaya başlayın ve liste yalnızca şu ana kadar yazdıklarınızla gerçekten eşleşenlere doğru azalmayı sürdürecektir. Liste yeterince kısaysa yukarı ve aşağı düğmelerini kullanarak bir öge seçin ve KDevelop sizi sınıfın beyan edildiği yere götürecektir.

  - Tez İşlev aç (Dolaşım → Tez İşlev Aç veya Seçenek+Kontrol+M): Geçerli oturumdaki projelerin parçası olan tüm (üye) işlevlerin bir listesini alırsınız ve yukarıdakiyle aynı biçimde seçim yapabilirsiniz. Bu listenin hem işlev beyanlarını hem de tanımlarını içerebileceğini unutmayın.

  - Tez Dosya Aç (Dolaşım → Tez Dosya Aç veya Seçenek+Kontrol+O): Geçerli oturumdaki projelerin parçası olan tüm dosyaların bir listesini alırsınız ve yukarıda belirtildiği gibi bunlardan seçim yapabilirsiniz.

  - Evrensel Tez Aç (Dolaşım → Tez Aç veya Seçenek+Kontrol+Q): Yukarıdaki komutlardan hangisinin hangi düğme inasyonuna bağlı olduğunu unutursanız bu bir evrensel İsviçre çakısıdır — size seçebileceğiniz tüm dosyaların, işlevlerin, sınıfların ve diğer şeylerin birleştirilmiş bir listesini sunar.

- Beyana/Tanıma Git: Bir (üye) işlevi uygularken; örneğin işlev argümanlarının listesini beyan ve tanım arasında eşzamanlı tutmak veya belgelendirmeyi güncellemek için sıklıkla işlevin beyan edildiği noktaya geri dönmek gerekir. Bunu yapmak için imleci işlev adına yerleştirin ve işlevin beyan edildiği yere atlamak için Dolaşım → Beyana Git ögesini seçin (veya Kontrol+. kombinasyonunu kullanın). Özgün konuma geri gitmek için birçok yol vardır:

  - Dolaşım → Tanıma Git (veya Kontrol+, kombinasyonunu kullanın).

  - Dolaşım → Önceki Bakılan Bağlam (veya Meta+Sol Ok Düğmesi), aşağıda açıklandığı üzere.

### Not

Bir sembolün beyanına atlamak, yalnızca imleci şu anda uyguladığınız işlevin adına yerleştirdiğinizde işe yarayan bir şey değildir. Aksine, diğer semboller için de işe yarar: İmleci bir (yerel, global veya üye) değişkenin üzerine koymak ve beyanına atlamak sizi beyanın konumuna da götürür. Benzer şekilde, imleci bir sınıfın adına, örneğin bir işlev beyanının değişkenine yerleştirebilir ve beyanın konumuna atlayabilirsiniz.

- Şuna Geç: Tanım/Beyan: Yukarıdaki örnekte, geçerli işlevin beyanının yapıldığı yere gitmek için öncelikle imleci işlev adının üzerine getirmeniz gerekmektedir. Bu adımdan kaçınmak için imlecin üzerinde olduğu işlevin beyanına atlamak üzere Dolaşım → Şuna Geç: Tanım/Beyan ögesini seçebilirsiniz (veya Üst Karakter+Kontrol+C kombinasyonunu kullanın). Aynı menü girdisini ikinci kez seçtiğinizde işlevin tanımlandığı yere geri dönersiniz.

- Önceki/Sonraki Kullanım: İmleci bir yerel değişkenin adının üzerine koymak ve Dolaşım → Sonraki Kullanım ögesini seçmek (veya Meta+Üst Karakter+Sağ Ok Düğmesi) sizi bu değişkenin koddaki sonraki kullanımına götürür (Bunun yalnızca değişken adının bir sonraki oluşunu aramadığını, aynı ada sahip; ancak farklı kapsamlardaki değişkenlerin farklı olduğunu da hesaba kattığını unutmayın). Aynısı işlev adları için de geçerlidir. Dolaşım → Önceki Kullanım (veya Meta+Üst Karakter+Sol Ok Düğmesi) sizi bu değişkenin koddaki önceki kullanımına götürür.

### Not

Bu komutların döngü içinde geçtiği tüm ad kullanımlarının listesini görmek için imleci üzerine getirin ve Kod Tarayıcısı araç görünümünü açın veya Seçenek düğmesine basılı tutun. Bu, Koda göz atmak bölümünde ayrıntılı olarak açıklanmıştır.

- Bağlam Listesi: Web tarayıcılarında en son ziyaret edilen web sayfalarının listesinde ileri ve geri gidebilmenizi sağlayan bir özellik bulunmaktadır. KDevelop yazılımında da aynı özellik bulunur; ancak web siteleri yerine bağlamları ziyaret edersiniz. Bağlam, imlecin geçerli konumudur ve imleç komutları dışında herhangi bir şey kullanarak imleci uzaklaştırarak onu değiştirebilirsiniz; örneğin, Kod Tarayıcısı araç görünümünde, Dolaşım menüsünde verilen seçeneklerden birinde veya başka herhangi bir dolaşım komutunda bir araç ipucu tarafından sağlanan bir konuma tıklayarak. Dolaşım → Önceki Bakılan Bağlam (Meta+Sol Ok Düğmesi) ve Dolaşım → Sonraki Bakılan Bağlam (Meta+Sağ Ok Düğmesi) sizi aynı web tarayıcılarının ileri ve geri düğmelerini tıkladığınızda yaptığı gibi bağlamlar arasında getirir ve götürür.

- Son olarak, kod tabanınızdaki farklı yerlere gitmenize olanak tanıyan araç görünümleri vardır. Örneğin, Sınıflar aracı size geçerli oturumun tüm projelerinde bulunan tüm ad alanlarının ve sınıfların bir listesini sağlar ve bu listeyi genişleterek bu sınıfların her birinin üye işlevlerini ve değişkenlerini görmenize olanak tanır:

  Bir ögeye çift tıklamak (veya sağ fare düğmesiyle bağlam menüsünde dolanmak) ögenin beyanının konumuna atlamanıza olanak tanır. Diğer araçlar da benzer şeylere olanak tanırlar; örneğin, Projeler araç görünümü, bir oturumun parçası olan dosyaların bir listesini sağlar:

  Yine, bir dosyaya çift tıklamak onu açar.

Kaynak kodu yazmak
Kaynak kodu yazmak

## Kaynak kodu yazmak

KDevelop projelerinizin kaynak kodunu anladığı için daha fazla kod yazmanıza yardımcı olabilir. Aşağıda bunu yapmanın bazı yolları özetlenmektedir.

### Kendiliğinden tamamlama

Büyük olasılıkla yeni kod yazarken tüm özellikler arasında en kullanışlı olanı kendiliğinden tamamlamadır. Örneğin, aşağıdaki kod parçasını düşünün:

    class Car {
      // …
      public:
        std::string get_color () const;
    };
    void foo()
    {
      Car my_ride;
      // bu değişkenle bir şeyler yap
      std::string color = my_ride.ge

Son satırdaki `my_ride` ögesinin `Car` türünün bir değişkeni olduğunu anımsar ve hem `ge` ögesini `get_color()` olarak tamamlamayı önerir; çünkü bu, `Car` sınıfında böyle başlayan tek değişkendir. Yazmayı sürdürmek yerine tam sözcüğü almak için yalnızca Giriş düğmesine basın; bu size zaman kazandırır; yanlış yazımları önler ve büyük projelerdeki yüzlerce veya binlerce değişkeni veya sınıfı ezberlemekten sizi kurtarır.

Dönüş türü ve genel olup olmadığı dışında işlev hakkında daha fazla bilgi almak için araç ipucuna tıklayabileceğinizi unutmayın:

Kendiliğinden tamamlama özelliği, projenizde uzun değişken ve işlev adları kullanıyorsanız sizi çok fazla yazmaktan kurtarabilir; ayrıca, adların yanlış yazılmasını (ve bunun sonucunda derleyici hatalarını) önler ve işlevlerin tam adlarını hatırlamayı çok daha basit hale getirir; örneğin, tüm alıcılarınız `get_` ile başlıyorsa kendiliğinden tamamlama özelliği yalnızca ilk dört harfi yazdığınızda size olası alıcıların bir listesini sunabilir ve büyük olasılıkla bu süreçte size hangi işlevin doğru olduğunu hatırlatır. Kendiliğinden tamamlamanın çalışması için ne `Car` sınıfının ne de `my_ride` değişkeninin bildiriminin şu anda kod yazdığınız yerle aynı dosyada olması gerekmediğini unutmayın. KDevelop yalnızca bu sınıfların ve değişkenlerin bağlantılı olduğunu bilmelidir; başka bir deyişle bu bağlantıların yapıldığı dosyaların şu anda üzerinde çalıştığınız projenin bir parçası olması gerekir.

### Not

KDevelop kod tamamlama konusunda size ne zaman yardımcı olacağını her zaman bilemez. Kendiliğinden tamamlama araç ipucu kendiliğinden açılmazsa tamamlamaların listesini elle açmak için Kontrol+Space düğmelerine basın. Genel olarak, kendiliğinden tamamlamanın çalışması için KDevelop yazılımının kaynak dosyalarınızı ayrıştırması gerekir. Bu, KDevelop yazılımını başlattıktan sonra geçerli oturumun projelerinin bir parçası olan tüm dosyalar için arka planda ve ayrıca bir saniyenin bir kısmı için yazmayı bıraktıktan sonra gerçekleşir (gecikme yapılandırılabilir).

### Not

KDevelop, yalnızca dosyanın MIME türüne göre kaynak kod olarak kabul ettiği dosyaları ayrıştırır. Bu tür, bir dosya ilk kez kaydedilmeden önce ayarlanmaz; sonuç olarak, yeni bir dosya oluşturmak ve içine kod yazmaya başlamak, ilk kez kaydedilene kadar kendiliğinden tamamlama için ayrıştırmayı tetiklemeyecektir.

### Not

Önceki notta olduğu gibi, kendiliğinden tamamlamanın çalışması için KDevelop üstbilgi dosyalarındaki bildirimleri bulabilmelidir. Bunun için bir dizi öntanımlı yolda arama yapar. Kendiliğinden bir üstbilgi dosyası bulamazsa bir üstbilgi dosyasının adının altını kırmızıyla çizecektir; bu durumda, KDevelop yazılımına bu dosyaları ve sağladıkları bilgileri nerede bulacağını açıkça söylemek için üzerine sağ tıklayın.

### Not

Kendiliğinden tamamlamayı yapılandırma hakkında bilgiyi kılavuzun bu bölümünde bulabilirsiniz.

### Yeni sınıflar eklemek ve üye işlevler gerçeklemek

KDevelop, yeni sınıflar eklemek için bir yardımcıya sahiptir. Prosedür, Yeni bir sınıf oluşturmak bölümünde açıklanmıştır. `Class` kategorisinden Temel C++ şablonu seçilerek basit bir C++ sınıfı oluşturulabilir. Yardımcıda, önceden tanımlanmış bazı üye işlevleri seçebiliriz; örneğin, boş bir yapıcı, bir kopya yapıcısı ve bir yıkıcı.

Yardımcıyı tamamladıktan sonra, yeni dosyalar oluşturulur ve düzenleyicide açılır. Üstbilgi dosyası hâlihazırda include korumalarına sahiptir ve yeni sınıf seçtiğimiz tüm üye işlevlere sahiptir. Sonraki iki adım, sınıfı ve üye işlevleri belgelemek ve bunları uygulamak olacaktır. Sınıfları ve işlevleri belgelendirmeye yönelik yardımcıları aşağıda tartışacağız. Eklenmiş olan özel işlevleri uygulamak için işlevlerin iskeletinin zaten sağlanmış olduğu bus.cpp sekmesine gitmeniz yeterlidir:

Yeni üye işlevler eklemek için bus.h sekmesine geri dönün ve bir işlevin adını ekleyin. Örneğin, şunu ekleyelim:

Uygulamaya nasıl başladığıma dikkat edin. Ancak, birçok kodlama tarzında, işlev üstbilgi dosyasında değil, ilgili .cpp dosyasında uygulanmalıdır. Bu amaçla, imleci işlevin adının üzerine getirin ve Kod → Kaynağa Taşı seçeneğini seçin veya Kontrol+Seçenek+S düğmelerine basın. Bu, süslü ayraçlar arasındaki kodu üstbilgi dosyasından kaldırır (ve işlev beyanını sonlandırmak için gerektiği şekilde noktalı virgülle değiştirir) ve kaynak dosyaya taşır:

Yazmaya nasıl başladığıma ve `students` değişkeninin büyük olasılıkla `Bus` sınıfının bir üye değişkeni olması gerektiğini; ancak henüz eklemediğimi ima etmek istediğime dikkat edin. Ayrıca KDevelop yazılımının değişken hakkında hiçbir şey bilmediğini açıkça belirtmek için nasıl altını çizdiğine dikkat edin. Ancak bu sorun çözülebilir: Değişken adına tıklandığında aşağıdaki araç ipucu görüntülenir:

(Aynısı üzerine sağ tıklayarak veya Çöz: Şöyle Beyan Et seçilerek yapılabilir.) “3 — private unsigned int” seçmeme (ya fareyle ya da Seçenek+3 düğmelerine basarak) ve üstbilgi dosyasında nasıl olduğuna bakmama izin verin:

Şunu belirtmek gerekir ki KDevelop beyan edilecek değişkenin türünü, onu ilklendirmek için kullanılan ifadeden çıkarır. Örneğin, eklemeyi aşağıdaki oldukça şüpheli şekilde yazmış olsaydık, değişkeni `double` türünde bildirmeyi önerecekti:

Son bir nokta olarak: Kod → Kaynağa Taşı kullanan yöntem, yeni üye işlevi her zaman istediğiniz yere yerleştirmez. Örneğin, `inline` olarak imlenmesini ve üstbilgi dosyasının en altına yerleştirilmesini isteyebilirsiniz. Böyle bir durumda, beyanı yapın ve işlevin tanımını yazmaya şu şekilde başlayın:

KDevelop buraya gelebilecek tüm olası tamamlamaları kendiliğinden sunar. İki `add_students` girdisinden biri seçildiğinde, argüman listesinin tamamını dolduran aşağıdaki kod ortaya çıkar:

### Not

Örnekte, kendiliğinden tamamlama aracının sunduğu seçeneklerden birini kabul etmek doğru imzayı verir; ancak ne yazık ki zaten yazılmış olan `inline` imleyicisini siler. Bu, KDevelop 274245 numaralı hatada bildirilmiştir.

### Beyanları belgelendirmek

İyi kod, hem işlevlerdeki algoritmaların uygulanması düzeyinde hem de arayüz düzeyinde iyi belgelendirilmiş koddur — yani sınıflar, (üye ve global) işlevler ve (üye veya global) değişkenler, amaçlarını, argümanların olası değerlerini, ön ve son koşullarını açıklamak için belgelendirilmelidir. Arayüzün belgelendirilmesi söz konusu olduğunda, doxygen, daha sonra çıkarılabilen ve aranabilir web sayfalarında görüntülenebilen yorumları biçimlendirmek için fiili standart haline gelmiştir.

KDevelop, bir sınıfı veya üye işlevi belgelendiren yorumların çerçevesini oluşturmak için kısa bir yol sağlayarak bu tarz yorumları destekler. Örneğin, bu kodu hâlihazırda yazdığınızı varsayalım:

    class Car {
      public:
        std::string get_color () const;
    };

Şimdi hem sınıfa hem de üye işleve belgelendirme eklemek istersiniz. Bu amaçla, imleci ilk satıra getirin ve Kod → Beyanı Belgelendir seçeneğini kullanın veya Seçenek+Üst Karakter+D düğmelerine basın. KDevelop aşağıdakiyle yanıt verecektir:

İmleç, bu sınıfın kısa açıklamasını (`@brief` doxygen anahtar sözcüğünden sonra) doldurmanız için hâlihazırda gri renkli alandadır. Daha sonra bu bölüme sınıfın ne yaptığına dair daha ayrıntılı bir genel bakış sağlayan belgelendirme eklemeyi sürdürebilirsiniz:

Düzenleyici yorumun içindeyken, yorum metni yeşil renkte vurgulanır (imleci yorumun dışına taşıdığınızda vurgulama kaybolur). Bir satırın sonuna geldiğinizde, Giriş düğmesine basın ve KDevelop kendiliğinden yıldız işaretiyle başlayan yeni bir satır başlatacak ve imleci bir karakter girintili olarak yerleştirecektir.

Şimdi işlevi beyanın olduğu satıra koyup Kod → Beyanı Belgelendir seçerek veya Seçenek+Üst Karakter+D düğmelerine basarak üye işlevi belgelendirelim:

Yine KDevelop, işlevin kendisi için belgelendirmenin yanı sıra geri dönüş türünü de içeren bir yorumun iskeletini kendiliğinden oluşturur. Geçerli durumda, işlevin adı hemen hemen kendini açıklayıcıdır; ancak çoğu zaman işlev argümanları olmayabilir ve ayrı ayrı belgelendirilmelidir. Bunu göstermek için biraz daha ilginç bir işlevin ve KDevelop yazılımının kendiliğinden oluşturduğu yorumu ele alalım:

Burada, önerilen yorum, örneğin bireysel parametreler için tüm doxygen alanlarını hâlihazırda içerir.

### Değişkenleri, işlevleri ve sınıfları yeniden adlandırmak

Bazen bir işlevi, sınıfı veya değişkeni yeniden adlandırmak isteyebilirsiniz. Örneğin, hâlihazırda şöyle bir kodumuz olduğunu varsayalım:

Daha sonra `remove_students` adından memnun olmadığımızı ve örneğin `throw_out_students` demeyi tercih ettiğimizi fark ederiz. Ad için bir arama–değiştirme yapabiliriz; ancak bunun iki dezavantajı vardır:

- İşlev birden fazla dosyada kullanılabilir.

- Özünde yalnızca bu işlevi yeniden adlandırmak istiyoruz ve aynı ada sahip olabilecek; ancak başka sınıflarda veya ad alanlarında bildirilmiş işlevlere dokunmuyoruz.

Bu iki sorun da, imleci işlevin adının herhangi bir oluşuna taşıyıp Kod → Beyanı Yeniden Adlandır seçerek (veya ada sağ tıklayarak veya Yeniden Adlandır: Bus::remove_students) çözülebilir. Bu, işlevin yeni adını girebileceğiniz ve işlevin gerçekten kullanıldığı tüm yerleri görebileceğiniz bir iletişim kutusu getirir:

### Kod parçacıkları

Çoğu projede kaynak kodda sıklıkla yazılması gereken kod parçaları vardır. Örnekler şunlardır: Derleyici yazarları için tüm komutlar üzerinde bir döngü; kullanıcı arayüzü yazarları için kullanıcı girdisinin geçerli olup olmadığını denetlemek ve değilse bir hata kutusu açmak; bu satırların yazarının projesinde ise aşağıdaki türden bir kod olacaktır:

    for (typename Triangulation::active_cell_iterator
           cell = triangulation.begin_active();
         cell != triangulation.end(); ++cell)
      … cell ile bir şeyler yap …

Bu tür bir metni sürekli baştan yazmak yerine (bu tür şeylerde yanlış yazmak pek kolaydır), KDevelop yazılımının Kod Parçacıkları aracını kullanmak yardımcı olabilir. Bunu yapmak için araç görünümünü açın (ilgili düğme görünümünüzde yoksa Araçlar ve Görünümler bölümüne bakın). Sonrasında “Depo Ekle” düğmesine tıklayın (adı biraz garip gelebilir — bu, belirli bir tür kaynak dosyalar için; örneğin C++ kaynakları için belirli bir tür parçacık kataloğu eklemenize izin verir) ve boş bir depo oluşturun. Sonrasında bir parçacık eklemek için düğmesine tıklayın ve şöyle bir iletişim kutusu göreceksiniz:

### Not

Bir kod parçacığı adında boşluk veya diğer özel karakterler bulunmayabilir; çünkü normal bir işlev veya değişken adı gibi görünmelidir (bir sonraki paragrafta açıklığa kavuşacak nedenlerden dolayı).

Bu şekilde tanımlanmış bir kod parçacığını kullanmak için kodu düzenlerken, herhangi bir işlev veya değişken adını yazdığınız gibi kod parçacığının adını yazabilirsiniz. Bu ad, kendiliğinden tamamlama için kullanılabilir hale gelecektir —yani yukarıdaki gibi bir kod parçacığı için uzun ve açıklayıcı bir ad kullanmanın hiçbir zararı yoktur— ve kendiliğinden tamamlama araç ipucunun önerisini kabul ettiğinizde (örneğin yalnızca Giriş düğmesine basarak), kod parçacığı adının önceden girilmiş kısmı parçacığın tam açılımı ile değiştirilecek ve düzgün bir şekilde girintilenecektir:

Bunun çalışması için Kod Parçacıkları araç görünümünün açık veya görünür olması gerekmediğini unutmayın: araç görünümüne yalnızca yeni kod parçacıkları tanımlamak için gereksinim duyarsınız. Bir parçacığı genişletmenin daha az kullanışlı olsa da alternatif bir yolu, ilgili araç görünümünde üzerine tıklamaktır.

### Not

Kod parçacıkları, burada anlatılanlardan çok daha güçlüdür. Onlarla yapabileceklerinizin tam bir listesi için ayrıntılı belgelendirmeye bir göz atın.

Kipler ve çalışma kümeleri
Kipler ve çalışma kümeleri

## Kipler ve çalışma kümeleri

Buraya kadar geldiyseniz KDevelop ana penceresinin sağ üst kısmına bir göz atın: Resimde gösterildiği üzere, KDevelop yazılımının içinde olabileceği üç kip vardır: Kod (kaynak kodu ile çalışma konusunda geçerli bölümde tartıştığımız kip), Hata Ayıkla (Programlarda hata ayıklamak bölümüne bakın) ve Gözden Geçir (Sürüm denetim sistemleriyle çalışmak bölümüne bakın).

Her kipin çevresinde yığılmış kendi araç kümeleri vardır ve her kip aynı zamanda o anda açık olan dosya ve belgelerden oluşan bir çalışma kümesine sahiptir. Ayrıca, bu çalışma kümelerinin her biri geçerli bir oturumla ilişkilidir; başka bir deyişle yukarıda gösterilen ilişkiye sahibiz. Çalışma kümesindeki dosyaların aynı oturumdan geldiğini; ancak aynı oturumun parçası olan farklı projelerden gelebileceğini unutmayın.

Eğer KDevelop programını ilk kez açıyorsanız çalışma kümesi boştur — açık dosya yoktur. Ancak düzenleme (veya hata ayıklama veya diğer kiplerde gözden geçirme) için dosya açtıkça çalışma kümeniz büyür. Çalışma kümenizin boş olmadığı, aşağıda gösterildiği gibi sekmede bir sembolle gösterilir. Ne zaman KDevelop programını kapatıp daha sonra yeniden başlatırsanız çalışma kümesinin kaydedildiğini ve geri yüklendiğini fark edeceksiniz; başka bir deyişle aynı açık dosya kümesine sahip olursunuz.

Farenizi çalışma kümesi sembolünün üzerine getirirseniz bu çalışma kümesinde o anda hangi dosyaların açık olduğunu gösteren bir araç ipucu alırsınız (burada: `step-32.cc` ve `step-1.cc` dosyaları). Kırmızı eksi işaretine tıklandığında ilgili dosyanın sekmesi kapatılır. Belki daha da önemlisi, ilgili düğmeye tıklamak, tüm çalışma kümesini bir kerede kapatmanıza olanak tanır (başka bir deyişle o anda açık olan tüm dosyaları kapatmak için). Bununla birlikte, bir çalışma kümesini kapatmak, yalnızca tüm dosyaları kapatmakla kalmaz, aslında çalışma kümesini kaydeder ve yeni, henüz boş olan bir tane açar. Bunu şurada görebilirsiniz:

Üç kip sekmesinin solundaki iki sembole dikkat edin (kalp ve solundaki tanımlanamayan sembol). Bu iki sembolün her biri, o anda açık olan çalışma kümesine ek olarak kaydedilmiş bir çalışma kümesini temsil eder. Farenizi kalp sembolünün üzerine getirirseniz buna benzer bir şey görürsünüz:

İlgili çalışma kümesinin iki dosya ve bunlara karşılık gelen proje adlarını içerdiğini gösterir: `Makefile` ve `changes.h`. Yükle seçeneğine tıklamak geçerli çalışma kümesini (burada gösterildiği gibi `tria.h` ve `tria.cc` dosyaları açıktır) kapatıp kaydedecek ve bunun yerine seçilen çalışma kümesini açacaktır. Ayrıca bir çalışma kümesini kalıcı olarak silebilirsiniz, bu da onu kayıtlı çalışma kümelerinden kaldırır.

Bazı kullanışlı klavye kısayolları
Bazı kullanışlı klavye kısayolları

## Bazı kullanışlı klavye kısayolları

KDevelop programının düzenleyicisi, tüm olağan düzenleme işlemleri için standart klavye kısayollarını takip eder. Bununla birlikte, kaynak kodu düzenlerken bazıları belirli düğme kombinasyonlarına bağlı olan bir dizi daha gelişmiş işlemi de destekler. Aşağıdakiler sıklıkla özellikle yararlıdır:

Kodda gezinmek
Kontrol+Seçenek+O | Tez Dosya Aç: Bir dosya adının bir kısmını girin ve geçerli oturumun projelerinin dizin ağaçlarında diziyle eşleşen tüm dosyalar arasından seçim yapın; dosya daha sonra açılacaktır.
Kontrol+Seçenek+C | Tez Sınıf Aç: Bir sınıf adının bir kısmını girin ve eşleşen tüm sınıf adları arasından seçim yapın; imleç daha sonra sınıf beyanına atlayacaktır.
Kontrol+Seçenek+M | Tez İşlev Aç: Bir (üye) işlev adının bir kısmını girin ve eşleşen tüm adlar arasından seçim yapın; listenin hem beyanları hem de tanımları gösterdiğine ve imlecin seçilen ögeye atlayacağına dikkat edin.
Kontrol+Seçenek+Q | Evrensel Tez Aç: Herhangi bir şey yazın (dosya adı, sınıf adı, işlev adı) ve aralarından seçim yapabileceğiniz eşleşenlerin bir listesini alın.
Kontrol+Seçenek+N | Ana Hat: Bu dosyada olan her şeyin bir listesini sağlar; örneğin sınıf beyanları ve işlev tanımları.
Kontrol+, | İmleç o anda bir işlev beyanı üzerindeyse işlevin tanımına atlar.
Kontrol+. | İmleç o anda bir işlev tanımındaysa bir işlevin veya değişkenin beyanına atlayın.
Kontrol+Seçenek+Sayfa Aşağı | Sonraki işleve atla
Kontrol+Seçenek+Sayfa Yukarı | Önceki işleve atla
Kontrol+G | Satıra git

Ara ve değiştir
Kontrol+F | Bul
F3 | Sonrakini bul
Kontrol+R | Değiştir
Kontrol+Seçenek+F | Birden çok dosyada bul ve değiştir

Diğer şeyler
Kontrol+_ | Bir düzey daralt: Örneğin bir işlev içindeki büyük resme odaklanmak istiyorsanız bu bloğu görünümden kaldırın.
Kontrol++ | Bir düzey genişlet: Daraltmayı geri alın.
Kontrol+D | Seçili metni veya geçerli satırı yorum yapın.
Kontrol+Üst Karakter+D | Seçilen metindeki veya geçerli satırdaki yorumu kaldırın.
Seçenek+Üst Karakter+D | Geçerli işlevi belgelendirin. İmleç bir işlev veya sınıf beyanı üzerindeyse bu düğmeye basıldığında tüm parametrelerin, dönüş değerlerinin vb. listesiyle önceden doldurulmuş doxygen tarzı bir yorum oluşturulur;
Kontrol+T | İmlecin üzerindeki ve bir önceki karakterin yerini değiştirin.
Kontrol+K | Geçerli satırı silin (not: bu yalnızca emacs’in “buradan satır sonuna kadar silme işlemi” değildir).

Bölüm 4. Şablonlar ile kod üretimi
Şablonlar ile kod üretimi

# Bölüm 4. Şablonlar ile kod üretimi

KDevelop kaynak kodu dosyaları oluşturmak ve aynı kod sürekli yazmaktan kaçınmak için şablonlar kullanır.

## Yeni bir sınıf oluşturmak

Kod üretimi için en yaygın kullanım büyük olasılıkla yeni sınıflar yazmaktır. Var olan bir projede yeni bir sınıf oluşturmak için bir proje klasörüne sağ tıklayın ve Şablondan Oluştur… ögesini seçin. Aynı iletişim kutusu Dosya → Şablondan Yeni… ile de çağrılabilir; ancak bir proje klasörü kullanmanın yararı, çıktı dosyaları için bir taban URL belirleyebilmektir. Kategori seçimi görünümünde `Sınıf` seçimini yapın ve sonraki iki görünümde istenen dili ve şablonu seçin. Bir sınıf şablonu seçtikten sonra yeni sınıfın ayrıntılarını belirtmeniz gerekir.

Öncelikle yeni sınıf için bir tanımlayıcı belirtmeniz gerekir. Bu basit bir ad (`Bus` gibi) veya ad alanlarıyla birlikte tam bir tanımlayıcı (`Transportation::Bus` gibi) olabilir. İkinci durumda, KDevelop tanımlayıcıyı ayrıştıracak ve ad alanlarını gerçek addan doğru bir biçimde ayıracaktır. Aynı sayfada, yeni sınıf için temel sınıflar ekleyebilirsiniz. Bazı şablonların kendi başlarına bir temel sınıf seçtiklerini fark edebilirsiniz, bunu kaldırmakta ve/veya başka temel sınıflar eklemekte özgürsünüz. C++ için `public QObject`, PHP için `extends SomeClass` veya Python için yalnızca sınıfın adı gibi dile bağlı olan tam kalıtım ifadesini buraya yazmalısınız.

Bir sonraki sayfada, miras alınan tüm sınıflardan sanal yöntemlerin yanı sıra bazı öntanımlı kurucular, yıkıcılar ve işleçleren oluşan bir seçki sunulur. Bir yöntem imzasının yanındaki onay kutusunu işaretlemek, bu yöntemi yeni sınıfta uygulayacaktır.

Sonraki düğmesine tıkladığınızda, sınıfa üye ekleyebileceğiniz bir sayfa açılır. Seçilen şablona bağlı olarak, bunlar yeni sınıfta üye değişkenler olarak görünebilir veya şablon bunlar için ayarlayıcıları ve alıcıları olan özellikler oluşturabilir. C++ gibi değişken türlerinin bildirilmesi gereken bir dilde, üyenin hem türünü hem de adını belirtmeniz gerekir, örneğin `int number` veya `QString name` gibi. Diğer dillerde, türü belirtmeyebilirsiniz; ancak yine de girmek iyi bir uygulamadır; çünkü seçilen şablon yine de bunu kullanabilir.

İlerleyen sayfalarda, yeni sınıfınız için bir lisans seçebilir, seçili şablonun gerektirdiği özel seçenekleri ayarlayabilir ve oluşturulan tüm dosyalar için çıktı konumlarını yapılandırabilirsiniz. Bitir seçeneğine tıklayarak yardımcıyı tamamlar ve yeni sınıfı oluşturursunuz. Üretilen dosyalar düzenleyicide açılacaktır, böylece hemen kod eklemeye başlayabilirsiniz.

Yeni bir C++ sınıfı oluşturduktan sonra, sınıfı bir proje hedefine ekleme seçeneği sunulacaktır. İletişim sayfasından bir hedef seçin veya sayfayı kapatın ve dosyaları elle bir hedefe ekleyin.

`Qt Nesnesi` şablonunu seçtiyseniz öntanımlı yöntemlerden bazılarını işaretlediyseniz ve iki üye değişken eklediyseniz çıktı aşağıdaki resimdeki gibi görünmelidir.

Veri üyelerinin, erişimci işlevler ve Q_PROPERTY makroları ile Qt özelliklerine dönüştürüldüğünü görebilirsiniz. Hatta ayarlayıcı işlevlerine argümanlar, uygun olan yerlerde const-reference ile aktarılır. Ek olarak, özel bir sınıf bildirilir ve Q_DECLARE_PRIVATE ile özel bir işaretçi oluşturulur. Bütün bunlar şablon tarafından yapılır, ilk adımda farklı bir şablon seçmek çıktıyı tümüyle değiştirebilir.

Yeni bir birim testi oluşturmak
Yeni bir birim testi oluşturmak

## Yeni bir birim testi oluşturmak

Çoğu test çatıları, her testin aynı zamanda bir sınıf olmasını gerektirse de, KDevelop birim testlerinin oluşturulmasını basitleştirmek için bir yöntem içerir. Yeni bir test oluşturmak için bir proje klasörüne sağ tıklayın ve Şablondan Oluştur… seçeneğini seçin. Şablon seçim sayfasında, kategori olarak `Test` seçin, ardından programlama dilinizi ve şablonunuzu belirledikten sonra Sonraki düğmesine tıklayın.

Test adı ve test senaryolarının bir listesi istenecektir. Test senaryoları için yalnızca bir ad listesi belirtmeniz gerekir. PyUnit ve PHPUnit gibi bazı birim test çerçeveleri, test senaryolarının özel bir önekle başlamasını gerektirir. KDevelop içinde, şablon öneki eklemekten sorumludur, bu nedenle burada test senaryolarına önek eklemeniz gerekmez. Sonraki düğmesine tıkladıktan sonra, üretilen dosyalar için lisans ve çıktı konumlarını belirtin ve test oluşturulacaktır.

Bu şekilde oluşturulan birim testleri kendiliğinden herhangi bir hedefe eklenmeyecektir. CTest veya başka bir test çatısı kullanıyorsanız yeni dosyaları bir hedefe eklediğinizden emin olun.

Diğer dosyalar
Diğer dosyalar

## Diğer dosyalar

Şablonlardan kod üretirken sınıflar ve birim testleri özel ilgi görse de, aynı yöntem her türlü kaynak kod dosyası için kullanılabilir. Örneğin, bir CMake Find modülü veya bir .desktop dosyası için bir şablon kullanılabilir. Bu, Şablondan Oluştur… seçilerek ve istenen kategori ve şablon seçilerek yapılabilir. Seçilen kategori ne `Sınıf` ne de `Test` ise yalnızca lisansı, şablon tarafından belirtilen özel seçenekleri ve çıktı dosyası konumlarını seçme seçeneğiniz olacaktır. Sınıflar ve testlerde olduğu gibi, yardımcıyı tamamlamak dosyaları oluşturacak ve düzenleyicide açacaktır.

Şablonları yönetmek
Şablonları yönetmek

## Şablonları yönetmek

Dosya → Şablondan Yeni… yardımcısından, Daha Fazla Şablon Al… düğmesine tıklayarak ek dosya şablonları da indirebilirsiniz. Bu, ek şablonları kurabileceğiniz, güncelleyebileceğiniz veya kaldırabileceğiniz bir Yeni Şeyler Al iletişim kutusunu açar. Ayrıca şablonlar için Ayarlar → KDevelop Uygulamasını Yapılandır → Şablonlar düğmesine tıklayarak ulaşabileceğiniz bir yapılandırma modülü de bulunmaktadır. Buradan hem dosya şablonlarını (yukarıda açıklanmıştır) hem de proje şablonlarını (yeni projeler oluşturmak için kullanılır) yönetebilirsiniz.

Elbette, kullanılabilir şablonlardan hiçbiri projenize uygun değilse her zaman yenilerini oluşturabilirsiniz. En kolay yol büyük olasılıkla var olan bir şablonu kopyalayıp değiştirmektir; ancak kısa bir öğretici ve daha uzun bir belirtim belgesi size yardımcı olmak için oradadır. Kurulu bir şablonu kopyalamak için Ayarlar → K Geliştir Uygulamasını Yapılandır… → Şablonlar ögesine tıklayarak şablon yöneticisini açın, kopyalamak istediğiniz şablonu seçin ve ardından Şablonu Çıkar düğmesine tıklayın. Bir hedef klasör seçin, ardından Tamam düğmesine tıklayın; şablonun içeriği seçilen klasöre çıkarılacaktır. Artık çıkarılan dosyaları açıp değiştirerek şablonu düzenleyebilirsiniz. İşiniz bittikten sonra, şablon yöneticisini açıp uygun sekmeyi (Proje Şablonları veya Dosya Şablonları) etkinleştirerek ve Şablonu Yükle seçeneğine tıklayarak yeni şablonunuzu KDevelop uygulamasına aktarabilirsiniz. `.kdevtemplate` veya `.desktop` sonekine sahip olan şablon açıklama dosyasını açın. KDevelop dosyaları bir şablon arşivine sıkıştıracak ve şablonu içe aktaracaktır.

### Not

Var olan bir şablonu kopyalarken, yeniden içe aktarmadan önce yeniden adlandırdığınızdan emin olun. Aksi takdirde, ya eski şablonun üzerine yazarsınız ya da aynı ada sahip iki şablon elde edersiniz. Bir şablonu yeniden adlandırmak için açıklama dosyasını benzersiz bir adla yeniden adlandırın (ancak soneki koruyun) ve açıklama dosyasındaki `Ad` girişini değiştirin.

Sıfırdan bir şablon yazmak istiyorsanız yeni bir proje oluşturarak ve `K Geliştir` kategorisindeki `C++ Sınıfı Şablonu` projesini seçerek örnek bir C++ sınıfı şablonuyla başlayabilirsiniz.

Bölüm 5. Özel Makefiles ile proje yapmak (derlemek)
Özel Makefiles ile proje yapmak (derlemek)

# Bölüm 5. Özel Makefiles ile proje yapmak (derlemek)

Birçok proje, make programı tarafından yorumlanan Make dosyalarını kullanarak kaynak dosyalarının nasıl derlenmesi gerektiğini (ve bir kaynak veya üstbilgi dosyası değiştiğinde hangi dosyaların yeniden derlenmesi gerektiğini) açıklar (örneğin, bkz. GNU make). Basit projeler için böyle bir dosyayı elle oluşturmak genellikle çok kolaydır. Daha büyük projeler genellikle Make dosyalarını GNU autotools (autoconf, autoheader, automake) ile tümleştirirler. Bu bölümde, projeniz için bir Makefile olduğunu ve KDevelop yazılımına bununla nasıl etkileşimde bulunacağını öğretmek istediğinizi varsayalım.

### Not

KDevelop 4.x, bu bölüm yazıldığı sırada GNU autotools hakkında bilgi sahibi değildir. Eğer projeniz bunları kullanıyorsa `./configure` veya diğer ilgili komutları komut satırında elle çalıştırmanız gerekecektir. Bunu KDevelop içinde yapmak istiyorsanız size bir kabuk penceresi görünümü veren Konsole aracını açın (gerekirse Pencereler → Araç Görünümü Ekle menüsünü kullanarak ana pencerenin çevresine ekleyin) ve bu görünümde komut satırından `./configure` komutunu çalıştırın.

İlk adım KDevelop yazılımına, Makefile dosyalarınızdaki hedefleri öğretmektir. Bunu yapmanın iki yolu vardır: Makefile hedeflerini tek tek seçmek ve sık sık oluşturmak isteyebileceğiniz bir hedef kümesi seçmek. Her iki yaklaşım için de, KDevelop yazılımının ana penceresinin çevresindeki Projeler düğmesine tıklayarak Projeler aracını açın (bu düğmeye sahip değilseniz yukarıda bir aracın düğmesini nasıl ekleyeceğinize bakın). Projeler araç penceresi iki bölümden oluşur: Projeler — başlıklı üst yarı— tüm projelerinizi listeler ve altta yatan dizin ağaçlarını genişletmenize izin verir. Proje Seçimi — başlıklı alt yarı, Proje → Seçimi Yap menü ögesini seçerseniz veya F8 düğmesine basarsanız yapılacak projelerin bir alt kümesini listeler; bu kısma aşağıda geri döneceğiz.

## Bireysel Makefile hedeflerini yapmak

Proje görünümünün üst kısmında, bir proje için diyelim ki belirli bir Makefile hedefini çalıştırmak istediğiniz proje için alt ağacı genişletin. Bu size (i) bu proje altındaki dizinler, (ii) bu proje için üst düzey dizindeki dosyalar, (iii) KDevelop yazılımının tanımlayabileceği Makefile hedefleri için simgeler verecektir. Bu kategoriler sağdaki resimde gösterilmektedir. Unutmayın ki KDevelop, Makefile sözdizimini belirli bir dereceye kadar anlar ve bu nedenle size bu Makefile içinde tanımlanan hedefleri sunabilir (ancak hedefler oluşturulmuşsa veya örtükse bu anlayışın sınırları vardır).

Burada listelenen hedeflerden herhangi birini yapmak için farenin sağ düğmesiyle üzerine tıklayın ve Yap seçeneğini seçin. Örneğin, bunu “clean” hedefi ile yapmak basitçe “make clean” komutunu çalıştıracaktır. Bunun gerçekleştiğini açılan ve komutu ve çıktıyı gösteren Yap başlıklı alt pencerede görebilirsiniz. (Bu pencere Yap aracına karşılık gelir, bu nedenle ana pencerenin çevresindeki Yap araç düğmesini kullanarak pencereyi kapatabilir ve daha sonra yeniden açabilirsiniz. Resmin sağ alt kısmında gösterilmektedir).

Sürekli yapı için bir Makefile hedefleri koleksiyonu seçmek
Sürekli yapı için bir Makefile hedefleri koleksiyonu seçmek

## Sürekli yapı için bir Makefile hedefleri koleksiyonu seçmek

Bir şey yapmak istediğiniz her zaman tek tek Makefile hedeflerine sağ tıklamak sizi yoracaktır. Bunun yerine, oturumdaki bir veya daha fazla proje için çok fazla fare çalışması yapmadan sürekli olarak oluşturabileceğimiz bireysel hedeflere sahip olmak isteriz. İşte bu noktada “Hedef Seçimlerini Yap” kavramı devreye girer: Üstteki düğme listesinde Seçimi Yap düğmesine bastığınızda, Proje → Seçimi Yap menü ögesini seçtiğinizde veya F8 işlev tuşuna bastığınızda birbiri ardına oluşturulan Makefile hedeflerinin bir koleksiyonudur.

Seçili Makefile hedeflerinin listesi Projeler araç görünümünün alt yarısında gösterilir.

Öntanımlı olarak seçim tüm projeleri içerir; ancak bunu değiştirebilirsiniz. Örneğin, proje listeniz üç proje içeriyorsa (bir temel kitaplık L ve iki uygulama A ve B), ancak şu anda yalnızca A projesi üzerinde çalışıyorsanız B projesini seçimde vurgulayarak ve düğmesine basarak seçimden kaldırmak isteyebilirsiniz. Ayrıca, büyük olasılıkla listenin sağındaki düğmeleri kullanarak seçimdeki girdileri yukarı ve aşağı hareket ettirerek L kütüphanesinin A projesinden önce yapıldığından emin olmak istersiniz. Ayrıca, belirli bir Makefile hedefine sağ tıklayıp Yapı Kümesine Ekle seçeneğini seçerek veya yalnızca vurgulayıp düğmesine basarak seçimde içerebilirsiniz.

KDevelop seçimi oluşturduğunuzda ne yapacağınızı yapılandırmanıza olanak tanır. Bu amaçla, Proje → Yapılandırmayı Aç menü ögesini kullanın. Burada; örneğin “make”komutunun yürütmesi gereken eşzamanlı iş sayısını seçebilirsiniz — bilgisayarınızda örneğin 8 işlemci çekirdeği varsa, bu alana 8 girmek yararlı bir seçim olacaktır. Bu iletişim kutusunda, Öntanımlı make hedefi, seçimdeki tüm hedefler için kullanılan bir Makefile hedefidir.

Hata iletileri ile ne yapmalı
Hata iletileri ile ne yapmalı

## Hata iletileri ile ne yapmalı

Derleyici bir hata iletisiyle karşılaşırsa hata iletisinin bulunduğu satıra tıklamanız yeterlidir; düzenleyici, hatanın rapor edildiği satıra (ve varsa sütuna) atlayacaktır. Hata iletisine bağlı olarak KDevelop, size hatayı düzeltmek için birkaç olası eylem de sunabilir; örneğin bilinmeyen bir sembol bulunursa daha önce bildirilmemiş bir değişkeni bildirerek.

Bölüm 6. KDevelop içinde programlar çalıştırmak
KDevelop içinde programlar çalıştırmak

# Bölüm 6. KDevelop içinde programlar çalıştırmak

Bir program yaptıktan sonra, onu çalıştırmak isteyeceksiniz. Bunu yapmak üzere projeleriniz için Başlatmalar seçeneğini yapılandırmanız gerekir. Bir Başlat, bir yürütülebilir dosyanın adı, bir dizi komut satırı parametresi ve bir yürütme ortamından (“bu programı bir kabukta çalıştır” veya “bu programı hata ayıklayıcısında çalıştır” gibi) oluşur.

## KDevelop içinde başlatmaları ayarlamak

Bunu ayarlamak için Çalıştır → Başlatmaları Yapılandır menü ögesine gidin, başlatma eklemek istediğiniz projeyi vurgulayın ve düğmesine tıklayın. Ardından yürütülebilir dosyanın adını ve programı çalıştırmak istediğiniz yolu girin. Yürütülebilir dosyanın çalıştırılması önce yürütülebilir dosyanın ve/veya diğer kitaplıklarıtn yapılmasına bağlıysa bunları alttaki listeye eklemek isteyebilirsiniz: Açılır menüden Yap ögesini seçin, ardından metin kutusunun sağındaki simgesine basın ve yapılmasını istediğiniz hedefi seçin. Yukarıdaki örnekte, program gerçekten çalıştırılmadan önce hem temel kitaplığın hem de uygulama programının derlendiğinden ve güncel olduğundan emin olmak için `1.deal.II` projesinden tümü ve `1.step-32` projesinden `step-32` hedeflerini seçtim. Hazır oradayken, Hata Ayıkla sembolüne tıklayarak ve hata ayıklayıcısı programın adını ekleyerek bir hata ayıklama başlatması da yapılandırabilirsiniz; bu sistemin öntanımlı hata ayıklayıcısıysa (örneğin Linux® üzerinde gdb), bu adımı atmanıza gerek yoktur.

Şimdi programı çalıştırmayı deneyebilirsiniz: KDevelop yazılımının ana pencere menüsünden Çalıştır → Başlatmayı Yürüt seçeneğini seçin (veya Üst Karakter+F9) ve programınız KDevelop içindeki ayrı bir alt pencerede çalışacaktır. Yukarıdaki resim sonucu gösterir: Yeni Çalıştır araç alt penceresi, çalıştırılan programın çıktısını (bu durumda `step-32`) gösterir.

### Not

Birden fazla başlatma yapılandırdıysanız Üst Karakter+F9 düğmesine bastığınızda hangisinin çalışacağını Çalıştır → Geçerli Başlatma Yapılandırması seçeneğine giderek seçebilirsiniz. Bununla birlikte, bir yapılandırmanın adını düzenlemenin açık olmayan bir yolu vardır: Çalıştır → Geçerli Başlatma Yapılandırması ögesini seçtiğinizde aldığınız iletişim kutusunda, soldaki ağaç görünümünde yapılandırmanın adına çift tıklayın, bu da yapılandırmanın adını düzenlemenize olanak tanır.

Bazı kullanışlı klavye kısayolları
Bazı kullanışlı klavye kısayolları

## Bazı kullanışlı klavye kısayolları

Bir program çalıştırmak
F8 | Yap (make programını çağır)
Üst Karakter+F9 | Çalıştır
Seçenek+F9 | Programı hata ayıklayıcısında çalıştırın; önceden kesme noktaları ayarlamak isteyebilirsiniz; örneğin kaynak koddaki belirli bir satıra fareyle sağ tıklayarak.

Bölüm 7. KDevelop içinde programlarda hata ayıklamak
KDevelop içinde programlarda hata ayıklamak

# Bölüm 7. KDevelop içinde programlarda hata ayıklamak

## Bir programı hata ayıklayıcısında çalıştırmak

Bir başlatmayı yapılandırdığınızda (bkz. Programlar Çalıştırmak), aynı zamanda onu bir hata ayıklayıcısında da çalıştırabilirsiniz: Çalıştır → Başlatma Hatalarını Ayıkla seçin veya Seçenek+F9 kısayolunu kullanın. gdb uygulamasına aşinaysanız bu, gdb uygulamasını yapılandırmada belirtilen yürütülebilirle başlatmakla ve `Çalıştır` yapmakla aynı şeydir. Bu, program bir yerde `abort()` çağrısı yaparsa (örneğin başarısız bir doğrulamaya denk gelirseniz) veya bir segmentasyon hatası varsa hata ayıklayıcısının duracağı anlamına gelir. Öte yandan, program sonuna kadar çalışırsa (doğru şeyi yaparak veya yapmadan), hata ayıklayıcı program bitmeden kendi kendine durmayacaktır. İkinci durumda, hata ayıklama başlatmasını çalıştırmadan önce hata ayıklayıcısının durmasını istediğiniz kod tabanınızın tüm satırlarında bir kesme noktası ayarlamak isteyeceksiniz. Bunu, imleci böyle bir satırın üzerine getirip Çalıştır → Kesme Noktasını Aç/Kapat menü ögesini seçerek veya bir satıra sağ tıklayıp bağlam menüsünden Kesme Noktasını Aç/Kapat ile yapabilirsiniz.

Bir programı hata ayıklayıcısında çalıştırmak KDevelop yazılımını farklı bir kipe sokacaktır: Ana pencerenin çevresindeki tüm “Araç” düğmelerini düzenleme kipi yerine hata ayıklama için uygun olanlarla değiştirecektir. Pencerenin sağ üst kısmına bakarak hangi kipte olduğunuzu görebilirsiniz: Gözden Geçir, Hata Ayıkla ve Kod adında sekmeler vardır; bunlara tıklamak üç kip arasında geçiş yapmanızı sağlar; her kipin kendine ait bir dizi araç görünümü vardır ve bunları Araçlar ve Görünümler bölümünde Kod araçlarını yapılandırdığımız şekilde yapılandırabilirsiniz.

Hata ayıklayıcısı durduğunda (bir kesme noktasında veya `abort()` yönteminin çağrıldığı bir noktada) programınız hakkında çeşitli bilgileri inceleyebilirsiniz. Örneğin, yukarıdaki resimde, altta Çerçeve Yığını aracını seçtik (kabaca gdb uygulamasının “backtrace” ve “info threads” komutlarına eşdeğerdir), bu araç solda programınızda o anda çalışmakta olan çeşitli iş parçacıklarını (burada toplam 8) ve sağda yürütmenin geçerli durma noktasına nasıl geldiğini gösterir (burada: `main()` `run()` yöntemini çağırdı; `run()` yönteminin kendisi tarafından çağrılan bir işlevde dursaydık liste daha uzun olurdu). Sol tarafta, geçerli nesne (`this` değişkeninin işaret ettiği nesne) dahil olmak üzere yerel değişkenleri inceleyebiliriz.

Buradan itibaren yapabileceğiniz çeşitli olasılıklar vardır: Geçerli satırı yürütebilir (F10, gdb uygulamasının “next” komutu), işlevlere adım atabilir (F11, gdb uygulamasının “step” komutu) veya işlevi sonuna kadar çalıştırabilirsiniz (F12, gdb uygulamasının “finish” komutu). Her aşamada, KDevelop solda gösterilen değişkenleri geçerli değerlerine günceller. Ayrıca fareyi kodunuzdaki bir sembolün üzerine getirebilirsiniz, örneğin bir değişken; KDevelop daha sonra bu sembolün geçerli değerini gösterecek ve bu değişkenin değeri bir dahaki zamnda değiştiğinde programı yürütme sırasında durdurmayı teklif edecektir. Eğer gdb biliyorsanız alttaki GDB araç düğmesine de tıklayabilir ve örneğin bir değişkenin değerini değiştirmek için gdb komutlarını girme olanağına sahip olabilirsiniz (bunun için şu anda başka bir yol yok gibi görünüyor).

Hata ayıklayıcısını çalışan bir sürece iliştirmek
Hata ayıklayıcısını çalışan bir sürece iliştirmek

## Hata ayıklayıcısını çalışan bir sürece iliştirmek

Bazen, hâlihazırda çalışmakta olan bir programda hata ayıklamak istenebilir. Bunun için bir senaryo, MPI kullanarak paralel programlarda hata ayıklamak veya uzun süredir çalışan bir arka plan işleminde hata ayıklamaktır. Bunu yapmak için Çalıştır → Sürece İliştir menü girdisine gidin, bu da yukarıdaki gibi bir pencere açacaktır. Şu anda KDevelop içinde açık olan projenizle eşleşen programı seçmek isteyeceksiniz — benim durumumda bu step-32 programı olacaktır.

Bu program listesi kafa karıştırıcı olabilir; çünkü burada gösterilen durumda olduğu gibi genellikle uzundur. Pencerenin sağ üst köşesindeki açılır kutuya giderek hayatınızı biraz daha kolaylaştırabilirsiniz. Öntanımlı değer Kullanıcı Süreçleri, başka bir deyişle bu makinede oturum açmış olan herhangi bir kullanıcı tarafından çalıştırılan tüm programlar (bu sizin masaüstü veya dizüstü bilgisayarınızsa, root ve çeşitli hizmet hesapları dışında büyük olasılıkla tek kullanıcı sizsiniz); ancak liste root kullanıcısı tarafından çalıştırılan süreçleri içermez. Öz Süreçler seçeneğini seçerek listeyi sınırlayabilir ve diğer kullanıcılar tarafından çalıştırılan tüm programları kaldırabilirsiniz. Ya da daha iyisi: Yalnızca Programlar seçeneğini seçerek resmî olarak sizin adınız altında çalışan; ancak pencere yöneticisi, arka plan görevleri gibi genellikle etkileşimde bulunmadığınız ve hata ayıklama için olası adaylar olmayan birçok işlemi kaldırabilirsiniz.

Bir süreci seçtikten sonra, ona bağlanmak sizi KDevelop uygulamasının hata ayıklama kipine sokacak, tüm olağan hata ayıklayıcısı araç görünümlerini açacak ve programı ona bağlandığınızda olduğu konumda durduracaktır. Daha sonra kesme noktaları, görünüm noktaları ya da gerekli olan her şeyi ayarlamak ve Çalıştır → Sürdür menü ögesine giderek programı yürütmeyı sürdürmek isteyebilirsiniz.

Bazı kullanışlı klavye kısayolları
Bazı kullanışlı klavye kısayolları

## Bazı kullanışlı klavye kısayolları

Hata ayıklamak
F10 | Üzerinden atla (gdb’nin “next” işlevi)
F11 | İçeri adım (gdb’nin “step” işlevi)
F12 | Dışarı adım (gdb’s “finish” işlevi)

Bölüm 8. Sürüm denetim sistemi ile çalışmak
Sürüm denetim sistemi ile çalışmak

# Bölüm 8. Sürüm denetim sistemi ile çalışmak

Daha büyük projelerle çalışıyorsanız kaynak kodun subversion veya git gibi bir sürüm denetim sistemi tarafından yönetiliyor olması olasıdır. Aşağıdaki açıklama subversion göz önünde bulundurularak yazılmıştır; ancak git veya desteklenen başka bir sürüm denetim sistemi kullanıyorsanız da aynı şekilde geçerli olacaktır.

İlk olarak, bir projenin bulunduğu dizin sürüm denetimi altındaysa KDevelop bunu kendiliğinden fark edecektir. Başka bir deyişle: Projenizi kurarken KDevelop uygulamasına bir kopyasını kendisinin denetlemesini söylemenize gerek yoktur; KDevelop uygulamasını daha önce depodan bir kopyasını çıkış yaptığınız bir dizine yönlendirmenizde bir sakınca yoktur. Sürüm denetimi altında böyle bir dizininiz varsa Projeler araç görünümünü açın. Daha sonra yapabileceğiniz birkaç şey vardır:

- Dizininiz güncelliğini yitirmişse depodan güncelleyebilirsiniz: Farenin sağ düğmesiyle proje adına tıklayın, Subversion menüsüne gidin ve Güncelle seçeneğini seçin. Bu, bu projeye ait tüm dosyaları depoya göre güncel hale getirecektir

- Bu eylemi tek tek alt dizinlerle veya dosyalarla sınırlamak istiyorsanız bu projenin ağaç görünümünü istediğiniz düzeye genişletin ve bir alt dizine veya dosya adına sağ tıklayın, ardından yukarıdaki işlemin aynısını yapın.

- Bir veya daha fazla dosyayı düzenlediyseniz bu projenin görünümünü bu dosyaların bulunduğu dizine genişletin ve dizine sağ tıklayın. Bu size farklı seçenekler sunan Subversion menü ögesini verir. Düzenlediğiniz sürüm ile daha önce çıkış yaptığınız depodaki sürüm (“base” revizyonu) arasındaki farkları görmek için Taban ile Karşılaştır ögesini seçin. Ortaya çıkan görünüm bu dizindeki tüm dosyalar için “farkları” gösterecektir.

- Yalnızca tek bir dosyayı düzenlediyseniz proje görünümünde ilgili dosya adına sağ tıklayarak bu dosya için Subversion menüsünü de elde edebilirsiniz. Daha da basit olarak, bu dosyayı açtığınız Düzenleyici görünümüne sağ tıklamak da size bu menü seçeneğini verecektir.

- Düzenlenmiş bir veya daha fazla dosyayı denetlemek istiyorsanız tek bir dosyaya, alt dizine veya tüm projeye sağ tıklayın ve Subversion → İşle ögesini seçin. Bu sizi KDevelop ana penceresinin sağ üst köşesinde görebileceğiniz gibi Kod ve Hata Ayıkla kiplerinin yanındaki üçüncü kip olan Gözden Geçir kipine geçirecektir. Sağdaki resim size bunun nasıl göründüğünü göstermektedir. Gözden Geçir kipinde, üst kısım size tüm alt dizin/proje ve değişiklikleri vurgulanmış her bir değiştirilmiş dosya için farkları gösterir (pencerenin bu kısmındaki çeşitli sekmelere bakın). Öntanımlı olarak, değiştirilen tüm dosyalar işlemek üzere olduğunuz değişiklik kümesinde yer alır; ancak değişiklikleri işlemek istediğiniz şeyle ilgisizse bazı dosyaların seçimini kaldırabilirsiniz. Örneğin, sağdaki örnekte `step-32.cc` ve `step-32.prm` dosyalarının seçimini kaldırdım; çünkü bu dosyalardaki değişikliklerin bu projede yaptığım diğer değişikliklerle hiçbir ilgisi yok ve bunları henüz denetlemek istemiyorum (daha sonra bunu ayrı bir işleme ile yapmak isteyebilirim). Değişiklikleri gözden geçirdikten sonra metin kutusuna bir işleme iletisi girebilir ve sağdaki İşle düğmesine basarak işleyebilirsiniz.

- Farklılıkları görmede olduğu gibi, tek bir dosyayı denetlemek istiyorsanız Subversion → İşle menü ögesini almak için düzenleyici penceresine sağ tıklayabilirsiniz.

Bölüm 9. KDevelop yazılımını özelleştirmek
KDevelop yazılımını özelleştirmek

# Bölüm 9. KDevelop yazılımını özelleştirmek

Örneğin farklı klavye kısayollarına alışkın olduğunuz için veya projeniz kaynak kod için farklı bir girinti biçemi gerektirdiği için KDevelop yazılımının öntanımlı görünüşünü veya davranışını değiştirmek istediğiniz zamanlar olabilir. Aşağıdaki bölümlerde, KDevelop yazılımının bu tür gereksinimler için nasıl özelleştirilebileceğinin çeşitli yollarını kısaca açıklıyoruz.

## Düzenleyiciyi özelleştirmek

KDevelop uygulamasının yerleşik düzenleyicisi içinde ve çevresinde yapılandırılabilecek bir dizi yararlı şey vardır. Daha evrensel kullanım için Düzenleyici → Görünüm → Satır Numaralarını Göster menü girdisini kullanarak satır numaralandırmayı açmak, derleyici hata iletilerini veya hata ayıklama iletilerini koddaki konumlarla eşleştirmeyi kolaylaştırır. Aynı alt menüde Simge Kenarlığı özelliğini de açmak isteyebilirsiniz — KDevelop, kodunuzun solunda, geçerli satırda bir kesme noktası olup olmadığı gibi simgeleri gösterecek bir sütun gösterir.

Kod girintilemesini özelleştirmek
Kod girintilemesini özelleştirmek

## Kod girintilemesini özelleştirmek

Çoğumuz kodun belirli bir şekilde biçimlendirilmesini isteriz. Birçok proje de belirli bir girinti biçemini zorunlu kılar. Her ikisi de KDevelop uygulamasının girintileme biçemiyle eşleşmeyebilir. Ancak, bu özelleştirilebilirdir: Ayarlar → KDevelop Uygulamasını Özelleştir menü ögesine gidin, ardından soldaki Kaynak Biçimlendiricisi ögesine tıklayın. Yaygın olarak kullanılan önceden tanımlanmış girintileme biçemlerinden birini seçebilir veya yeni bir biçem ekleyip düzenleyerek kendi biçeminizi tanımlayabilirsiniz. Projenizin kaynaklarının geçmişte girintilendiği biçemi tam olarak yeniden oluşturmanın bir yolu olmayabilir; ancak yeni bir biçem için ayarları kullanarak yaklaşabilirsiniz; aşağıdaki iki resimde bir örnek gösterilmektedir.

### Not

KDevelop 4.2.2 ile belirli bir MIME türü için yeni bir biçem oluşturabilirsiniz (örneğin C++ başlık dosyaları için); ancak bu biçem diğer MIME türleri için olası biçemler listesinde görünmez (örneğin C++ kaynak dosyaları için); ancak elbette her iki dosya türü için de aynı biçemi kullanmak yararlı olacaktır. Bu nedenle, biçemi bir kez üstbilgi ve bir kez de kaynak dosyaları için olmak üzere iki kez tanımlamanız gerekecektir. Bu durum 272335 numaralı hata raporunda bildirilmiştir.

Klavye kısayollarını özelleştirmek
Klavye kısayollarını özelleştirmek

## Klavye kısayollarını özelleştirmek

KDevelop, Ayarlar → Kısayolları Yapılandır menüsü aracılığıyla zevkinize göre değiştirebileceğiniz neredeyse sınırsız bir klavye kısayolları listesine sahiptir (bazıları bu kılavuzdaki çeşitli bölümlerin “Kullanışlı klavye kısayolları” bölümünde listelenmiştir). İletişim kutusunun üst kısmında bir arama sözcüğü girebilirsiniz ve yalnızca eşleşen komutları gösterir; daha sonra bu komuta hangi düğme kombinasyonunun bağlı olduğunu düzenleyebilirsiniz.

Değiştirilmesi çok faydalı bulunan iki tanesi Hizala özelliğini Sekme düğmesine ayarlamaktır (birçok kişi genellikle sekmeleri elle girmez ve düzenleyicinin kodun yerleşimini seçmesini tercih eder; değiştirilen kısayolla, Sekme düğmesine basmak KDevelop kodunu girintili/çıkıntılı/hizalı hale getirir). İkincisi ise Kontrol+B üzerine Kesme Noktasını Aç/Kapat koymaktır; çünkü bu oldukça sık yapılan bir işlemdir.

Kodu kendiliğinden tamamlamayı özelleştirmek
Kodu kendiliğinden tamamlamayı özelleştirmek

## Kodu kendiliğinden tamamlamayı özelleştirmek

Kod tamamlama bu kılavuzun kaynak kodu yazma bölümünde ele alınmıştır. KDevelop yazılımında bu, iki kaynaktan gelir: Düzenleyici ve ayrıştırma işletkesi. Düzenleyici (Kate) daha geniş KDE ortamının bir bileşenidir ve aynı belgenin diğer bölümlerinde daha önce gördüğü sözcüklere dayalı kendiliğinden tamamlama sunar. Bu tür kendiliğinden tamamlamalar araç ipucunda kendisinden önce gelen simge ile tanımlanabilir:

Düzenleyicinin kod tamamlama özelliği Ayarlar → Düzenleyiciyi Yapılandır → Düzenleme → Kendiliğinden Tamamlama aracılığıyla özelleştirilebilir. Özellikle, kendiliğinden tamamlama devreye girmeden önce bir sözcükte kaç karakter yazmanız gerektiğini seçebilirsiniz.

Öte yandan, KDevelop yazılımının öz kendiliğinden tamamlaması, bağlamla ilgili anlamsal bilgileri dikkate aldığı için çok daha güçlüdür. Örneğin, burada gösterildiği gibi `object.`, vb. yazdığınızda hangi üye işlevleri sunacağını bilir:

Bu bağlam bilgisi, belirli bir dosya kaydedildikten sonra kullanılabilen çeşitli dil desteği eklentilerinden gelir (böylece dosya türünü denetlenebilir ve doğru dil desteğini kullanabilir).

KDevelop yazılımının tamamlanması, bir şeyi tamamlayabileceği hemen hemen her yerde, siz yazarken görünecek şekilde ayarlanmıştır. Bu, Ayarlar → KDevelop Uygulamasını Yapılandır → Dil Desteği içinde yapılandırılabilir. Hâlihazırda ayarlanmamışsa (öntanımlı olarak olması gerektiği gibi) Kendiliğinden Çağırmayı Etkinleştir seçeneğinin ayarlandığından emin olun.

KDevelop içinde bir tamamlamayı göstermenin iki yolu vardır: Minimal Kendiliğinden Tamamlama tamamlama araç ipuçlarında yalnızca temel bilgileri gösterir (başka bir deyişle ad alanı, sınıf, işlev veya değişken adı). Bu, Kate tamamlamasına benzer görünecektir (simgeler dışında).

Öte yandan Tam Tamamlama, ek olarak her girdinin türünü ve işlevler söz konusu olduğunda aldıkları argümanları da gösterecektir. Ayrıca, o anda bir işlevin argümanlarını dolduruyorsanız tam tamamlama imlecin üzerinde üzerinde çalıştığınız geçerli argümanı gösteren ek bir bilgi kutusuna sahip olacaktır.

KDevelop yazılımının kod tamamlaması ayrıca “en iyi eşleşmeler” olarak bilinen, hem minimal hem de tam tamamlamada o anda beklenen türle eşleşen tamamlama ögelerini en üste getirmeli ve yeşil renkle vurgulamalıdır.

Yapılandırma iletişim kutusundaki tamamlama düzeyi için üç olası seçenek vardır:

- Her zaman minimal tamamlama: Hiçbir zaman “tam tamamlamayı” gösterme

- Minimal kendiliğinden tamamlama: “Tam tamamlamayı” yalnızca kendiliğinden tamamlama elle tetiklendiğinde göster (başka bir deyişle, Kontrol+Boşluk kombinasyonunu kullandığınızda)

- Her zaman tam tamamlma: Her zaman “tam tamamlamayı” göster

Bölüm 10. Emeği Geçenler ve Lisanslar
Emeği Geçenler ve Lisanslar

# Bölüm 10. Emeği Geçenler ve Lisanslar

Belgelendirme telif hakkı için UserBase KDevelop4/Kılavuz sayfası geçmişine bakın.

Çeviri: Emir SARI `(emir_sari AT icloud.com)`

Bu belgelendirme, GNU Serbest Belge Lisansı (GFDL) altında dağıtılmaktadır.