hata mesajina sebep olabilecek kod buraya yazilir.
}
finally
{
bir önceki hata moduna dön.
}
SetErrorMode( wOldErrorMode );
end;
end;
Delphi - .....................................
toplama makaleler
TOPLAMA MAKALELER
Class Procedure
Pek çoğumuzun bilmediğini düşündüğüm bir konuya rastladım geçenlerde. Sizinle paylaşmak istedim. "Class Procedure" kavramını biliyor musunuz? Bir nesneyi "create" eder, daha sonra da "destroy" işimizi bitiririz. Şimdi bu işlemleri komponenti oluşturup, yine kendisine "destroy" yaptırabiliriz. Örneğimizde bir form ve butonlar, TRcihEdit içerisine açılan, kullanıcıya bağlı bir text dosyasını göreceğiz. Formumuza Form2 adını verelim.
form2 := TForm2.create(application);
try
form2.RichEd.lines.LoadFromFile(filename);
result := form2.ShowModal;
finally
form2.release;
end;
TForm2 bir class procedure ve ona bağlı Execute functionını kullanıyor.
type
TForm2 = class(TForm)
Panel1: TPanel;
RichEd: TRichEdit;
Panel2: TPanel;
BitBtn1: TBitBtn;
BitBtn2: TBitBtn;
private
{ Private declarations }
public
class function Execute(filename:string):TModalResult;
end;
implementation
{$R *.DFM}
class function TForm2.Execute(filename:string):TModalResult;
var Form2: TForm2;
begin;
form2 := TForm2.create(application);
try
form2.RichEd.lines.LoadFromFile(filename);
result := form2.ShowModal;
finally
form2.release;
end;
end;
CLASS ifadesi ile functionın tanımlandığına dikkat edin. Böylelikle form create edilmeden bizim fonksyonumuz kullanıma hazır hale geliyor. Bunuda Form2 classına referans vererek yaparız. Diğer bir formdan bizim fonksyonu kullanmak istersek aşağıdaki gibi bir kod yazmamız yeterli.
TForm2.execute('c:autoexec.bat');
Böylece form "create" edilecek, autoexec.bat dosyası görüntülenebilecektir. Formu kapatmak içinse "OK" ve "CANCEL" (free - destroy) yeterli olacaktır. Elbette bu bir fonksyon olduğuna göre geri dönen değeri de kontrol ettirebiliriz.
if TForm2.execute('c:autoexec.bat') = mrOK
then label1.caption := 'OK'
else label1.caption := 'Cancel';
REG
Delphi'de TIniFile ve TRegIniFile Bileşenleri
Delphi ile yazdığınız programlarda çeşitli ayarları ve hatta bilgileri saklamak istiyorsunuz ama bunun için pratik bir yol bulamadınız mı? Ya da bilgileri saklamak ve okumak için TextFile'dan daha iyi bir alternatif mi arıyorsunuz? Buyrun...
İçerik Başlıkları
TIniFile ve TRegIniFile
TIniFile ve TRegIniFile
TIniFile
Yazdığınız programlardaki ayarları ya da saklamak istediğiniz verileri sistematik ve pratik bir şekilde saklayıp, istediğinizde de aynı rahatlıkla okumanızı sağlayacak bileşenimizin adı TIniFile. Hemen belirtelim bu bileşeni kullanmak için "IniFiles" unit'ini programınıza dahil etmeniz gerekiyor.
".ini" uzantısına sahip dosyaları eğer notepad ile açtıysanız köşeli parantezlerle belirtilen ana bölümlerin altında çeşitli değişkenler ve karşılarına eşittirden sonra yazılmış çeşitli değerler olduğunu görmüşsünüzdür. Eğer bunu hiç yapmadıysanız açın bakın bir tanesine, öyleler :). Burada köşeli parantezler arasında kalan kısım o "bölümün(section)" adı oluyor. Farklı bölümlerde aynı isimde değişkenler kullanılabiliyor. Ayrıca bu bölümler verileri kategorize etmenize de yarıyor. Bileşenimiz direk bir bölüme ait herhangi bir değişkenin değerini okuyabildiği gibi size bütün bölüm adlarını, bir bölümün içindeki değişken adlarını, isim-değişken çiftlerini de çeşitli şekillerde verebiliyor. Yani oldukça esnek bir kullanım sözkonusu. Lafı daha fazla uzatmadan nasıl kullanıldıklarına bakalım...
Öncelikle TIniFile tipide bir değişken tanımlıyoruz.
ayarlar: TIniFile;
Daha sonra bunu oluşturmamız gerekiyor.
ayarlar:= TIniFile(dosyaadi);
Buradaki "dosyaadi" string tipinde bir değişken veya direk elle girilen bir değer olabilir. Oluşturulacak veya okunacak ini dosyasının tam yolunu içermeli. Eğer bu isimde bir dosya yoksa oluşturulur ve yine dosya yoksa bile okuma işlemleri esnasında sorun çıkmaz merak etmeyin. Oraya da geliyoruz yavaş yavaş.
Şimdi, önce yazma işlemlerinden bahsedelim bence. Sonuçta daha elimizde hazır bir dosya yok. Bu bileşen sık kullanılan birçok değişken tipini rahatça yazmaya yarayan fonksiyonlara sahip. String tipinde bir değer yazmak için
ayarlar.WriteString('bölüm','değişkenadı',değer);
Şeklinde bir fonksiyon kullanabilirsiniz mesela. Burada bölüm yerine bölüm adı, değişken adı yerine dosyadaki değişken adı ve değer yerine de yazılacak değeri koymalısnız. Buradaki tüm parametreler sabit değerler olabileceği gibi string tipinde, gerekli bilgileri taşıyan değişkenler de olabilirler. String yazdırma dışında aynı şekilde kullanılan sadece sonundaki değer parametresi, yazacağı değişken tipine göre değişen
WriteInteger, WriteBool, WriteDate, WriteDateTime, WriteTime, WriteFloat ve WriteBinaryStream fonksyionları var. Bunlardan sonuncu olanı KESİNLİKLE önermiyorum. Hem gereksiz yere boyutu arttırıyor hem de belirli bir boyuttan daha büyük dosyalarla çalışmıyor.
Şimdi bu fonksiyonların okuma versiyonlarının bir örneğini göstereceğim, çünkü yapı tamamen aynı. Sadece isimler ve tipler değişiyor. String okuma fonksiyonumuz
Gördüğünüz gibi burada farklı olarak "varsayılan değer" bölümü var. Bu bölüm eğer okumaya çalıştığınız değişken herhangi bir sebepten yoksa(dosya yok, ilgili bölüm yok, değişken yok) değer olarak buraya koyulan değeri döndürüyor. Yani burada "okunan" isimli değişkene ya dosyadan okunan değer ya da böyle bir değer okunamadıysa varsayılan değer atanıyor. Yani dosyanın olup olmaması çok büyük bir sorun değil :). Bütün diğer yazma fonksiyonlarının başındaki "Write" kısımlarını "Read" yapıp yukarıdaki kurala göre kullanabilirsiniz.
Bir de çoklu değer okumak için kullanılan fonksiyonlar var. Mesela "ReadSection" fonksiyonu.
ayarlar.ReadSection(bölümadı,liste);
Bu fonksiyon, "bölümadı" ile belirtilen bölümdeki tüm değişken isimlerini "liste" yerine vereceğiniz TStrings tipindeki yapıya kopyalar.
ayarlar.ReadSections(liste);
Bu fonksiyon "liste" ile verilen TStrings tipindeki yapıya dosyadaki bölüm isimlerini kopyalar.
ayarlar.ReadSectionValues(bölümadı,liste);
Bu fonksiyon da "bölümadı" ile belirtilen bölümdeki "değişken=değer" çiftlerini "liste" yerine verdiğiniz TStrings yapısına kopyalar.
Böylece fonksiyonlarımızın sonuna geldik. İşiniz bitince değişkeni serbest bırakmayı unutmayın.
ayarlar.Free;
TRegIniFile
Bu tip de TIniFile'ın değerleri kayıt defterinde saklayan versiyonudur. Bunu kullanmak için "Registry" unit'ini projenize dahil etmeniz gerekir. Kullanımında TIniFile'dan tek farkı bunu oluşturuken(create metoduyla) dosya adı yerine HKEY_CURRENT_USER ana anahtarı altında bir alt anahtar adı girmeniz gerekmesi. Bu istediğiniz kadar içerideki bir anahtar olabilir(örn: SoftwareMicrosoftWindows). Kayıt defteri ile daha detaylı bilgi için "Windows" başlığı altındaki "Kayıt Defteri" yazı diziine bakabilirsiniz. Diğer tüm fonksiyonlar ve kullanımları aynı. Yine işiniz bitince bunu da serbest bırakmalısınız. Kolay gelsin.
Event ve Sender KavramlarıEvent ve Sender Kavramları
Aşağıda TButton için tanımlanmış bir OnClick olayını görüyorsunuz.
procedure TForm1.Button1Click(Sender: TObject);
begin
...
end;
ButtonClick olayında görüldüğü üzere TObject tipinde Sender değişkeni tanımlanıyor. Sender değişkeni ile hangi komponentin işlem gerçekleştirdiğini anlayabiliriz. Bçylelikle komponentin değişik işlevleri ve özelliklerine hükmetmemiz kolaylaşır. Bunun yanında TObject nesnesi ile yardımlaşıp farklı komponentlerin aynı Event procedurelerini kullanabilmelerini sağlayabiliriz.
Örneğin, aşağıdaki procedure tanımlamasını public bölümünde gerçekleştirdiğimizde, Object Inpector penceresinde Events penceresinden Click olaylarından MySenderDenemeClick seçilebilir.
Kısacası birden fazla nesnenin tek OnClick eventına hükmetmesi sağlanmış olur. Örneğin birden fazla butonun Clickini tek Click eventına bağlayıp tek elden çalıştırabilirsiniz.
procedure TForm1.Button1Click(Sender: TObject);
begin
{Ortak kod tanımlamalarını yazabilirsiniz.}
{...}
if Sender = Button1 then
ShowMessage('Button1 click olayı !')
else if Sender = MenuItem1 then
ShowMessage('MenuItem1 click olayı!')
else
ShowMessage('Farklı bir nesne click olayı !');
end;
Genelde kullanılan yaklaşım nesnenin adından kontrol gerçekleştirmektir.
procedure TForm1.Button2Click(Sender: TObject);
begin
Button1Click(Button2);
{' 'Farklı bir nesne click olayı !' sonucunu döndüren kod}
end;
"is"Kavramları "as"
Sender TObject nesnesinden türediğinden, herhangi bir nesne Sender üzerinden işlem yapabilir. "is" kullanımı ile hangi nesneden geldiğini kontrol edebiliriz.
if Sender is TButton then
Yapılacak işler
else
Değilse yapılacak işler;
Aşağıdaki kodda sender için Edit1 nesnesi kullanılmıştır.
procedure TForm1.Edit1Exit(Sender: TObject);
begin
Button1Click(Edit1);
end;
Yukarıdaki koddaShowMessage('Farklı bir nesne click olayı !'); yerine aşağıdaki kodu eklediğimizde TEdit nesnesini kontrol etmiş oluruz.
{... else}
begin
if Sender is TButton then
ShowMessage('Farklı bir nesne olayı...')
else if Sender is TEdit then
with Sender as TEdit do
begin
Text:= 'Edit1Exit olayı gerçekleşti';
Width:= Width * 2;
Height := Height * 2;
end {begin with}
end;
______________________________________________--
TListView bileşeni
Makaleler TListView bileşeni ve Pratik Kullanımı TListView bileşeni ve Pratik Kullanımı
Explorer tarzı bir görünüm sağlayan bu bileşeni bir çok uygulamada kullanabilirsiniz. Bu bileşenin kullanımı hakkında detaylı bilgi, çeşitli tüyolar ve bir kaç güzel fonksiyon ilginizi çekerse buyrun okuyun :)
İçerik Başlıkları
TListView
TListView
Öncelikle TListView bileşenin ne olduğunu iyice açıklayalım. Bu bileşen Explorer penceresinde gördüğünüz, dosyaların, klasörlerin gösterildiği yerle aynı özelliklere sahip olan bir bileşen. Yani bu bileşenin içinde çeşitli alt birimler oluşturup bunlara bir simge ve başka alt bilgiler ekleyip, şık bir şekilde ekrana yansıtabiliriyorsunuz. Bu bileşen "Win32" kategorisi altında bulunuyor.
Hemen söyleyelim öğelerin yönetimi oldukça kolay. TStringList'ten bildiğimiz Add, Delete gibi metodların biraz değiştirilmiş hallerini burada da kullanabiliyoruz. Bir farkla, burada ekleme fonksiyonu parametre almıyor ve dönüş değeri olarak da eklenen öğeye ait bir adres ya da daha anlaşılır bir şekilde TListItem tipinde bir değişken döndürüyor. Bu değişken sayesinde yeni eklenen öğeyi rahatça düzenleyebiliyoruz. Bu bileşeni simgelerle birlikte kullanmak isterseniz(ki başka türlü çok da güzel görünmüyor zaten ) formunuza bir "TImageList" bileşeni eklemeniz gerekiyor. Hatta iki tane eklemelisiniz. Bunlardan biri 32x32'lik büyük simgeleri taşırken diğeri de 16x16'lık küçük simgeleri taşıyacak. TListView bileşeninin "LargeImages" ve "SmallImages" özelliklerini ilgili ImageList'lerle ilişkilendirmeyi unutmayın.(Özellikler bölümünden ilgili ImageList'i seçin.)
Gelelim TListItem'ın nasıl birşey olduğuna. Bunu iyi bilmelisiniz çünkü TListView bileşeninin tüm öğeleri bu tipte. Hemen özelliklerini tek tek inceleyelim:
Caption(string): Bu özellik adından da anlaşılacağı üzere öğenin başlık bilgisini, yani ekranda görüntülenecek olan metni tutuyor.(yenioge.Caption:='Adı';)
Checked(Boolean): Bu özellik -eğer TListView'un "checkboxes" özelliği true ise- öğenin tikli olup olmadığını belirtiyor.
Cut(Boolean): Bu özellik simgenin kesme işlemi yapıldığı sıradaki gibi yarı saydam görüntülenip görüntülenmeyeceğini belirtiyor.
DropTarget(Boolean): Bu özellik true yapıldığında, öğe bırakma-bölgesi olarak gösterilir ve ListView içindeki diğer tüm öğelerin bu özelliği false yapılır.
ImageIndex(Integer): Bu özellik öğenin ilişkilendirilmiş ImageList içindeki kaç numaralı resmi simge olarak kullanacağını belirtir. Değeri -1 olduğunda bir simge gösterilmez.
Index(Integer): Bu özellik öğenin ListView içindeki yerini belirtir. İlk öğenin Index'i 0'dır.
OverlayIndex(Integer): Bu özellik kulanılacak üst katman resminin(overlay image) ImageList içindeki yerini belirtir.
Selected(Boolean): Bu özellik öğenin seçili olup olmadığını belirtir. ListView içinde birden fazla öğe seçildiğinde öğenin seçili olup olmadığını bu özelliğine bakarak anlayabiliriz.
SubItemImages(Array of Integer): Bu özellik öğenin alt öğelerinin resim numaralarını tutar. Eğer alt öğelerin yanında resim görüntülemek istiyorsanız "SubItemImages[1]:=5" gibi bir ifadeyle bunu yapabilirsiniz. Burada köşeli ayraçlar arasındaki "1" alt öğenin indexini ve "5" de resim indexini belirtiyor.
SubItems(TStrings): Bu özellik alt öğeleri tutar. Alt öğe eklemek, silmek veya yönetmek oldukça basittir. Bir Memo ya da ListBox bileşeninin öğelerini yönetmekle hemen hemen aynıdır. TStrings tipini biraz bilmeniz yeterli.
Evet işimize yarayan özellikler bunlar. Şimdi ListView'a geri dönelim isterseniz. ColumnClick ve Columns adı altında 2 özelliğimiz var dikkat ettiyseniz. Bunlardan "Columns" ayrıntılı gösterimdeki sütunların isimlerini temsil ediyor. Yani örneğin her öğenizin 2 alt öğesi(subitem) var. O zaman "columns" bölümüne toplam 3 başlık eklemeniz gerekiyor. Birincisi öğenin adının bulunduğu sütunun adı, diğerleri de sırasıyla birinci ve ikinci alt öğelerin başlığı olacak. ColumnClick özelliğini true yaparsanız bu sütunlara tıklanabilecek ve siz bu tıklama olaylarını yönetebileceksiniz, ki bu iş genelde o sütundaki alt öğeye göre sıralama yapmak için kullanılır.
Ve son 2 önemli özelliğimiz, SortType ve ViewStyle. Sort type alfabetik sıralamanın neye göre yapılacağını belirtir. stNone bir sıralama yapmazken stName sadece başlıklara göre, stData alt öğelere göre, stBoth ise her iki bilgiye göre sıralama yapar. Ayrıca bunu stNone yapıp kendi sıralama sisteminizi de geliştirebilirsiniz. Bunun için ListView bileşeninizin onCompare olayına bir kaç kod yazmanız gerekiyor. Ayrıca sıralama fonksiyonunun çalışması için de "AlphaSort" metodunu çağırmalısınız.(Listview1.AlphaSort;) onCompare olayında size 2 tane TListItem öğesi veriliyor ve siz buraya yazacağınız kodla hangisinin daha önce gelmesi gerektiğini belirtiyorsunuz. Eğer Item1 daha önce gelmeliyse Compare değerini sıfırdan küçük, daha sonra gelmeliyse Compare değerini sıfırdan büyük yapmalısınız. Eğer ikisi de eşitse o zaman bu değeri 0 yapmanız gerekiyor. ViewStyle özelliği de aktif olan gösterim tipini belirtiyor. vsIcon bildiğiniz "Büyük Simge" gösterimi, ve burada LargeImages'a bağlı ImageList kullanılıyor. Diğer tüm modlarda SmallIcons'a bağlı ImageList kullanılıyor. vsSmallIcons, küçük simgeler; vsList, liste ve vsReport, ayrıntılı gösterimi temsil ediyor. Bu değerleri program çalışırken de değiştirip farklı görünümler arasında geçiş yapabilirsiniz.
Evet, bu kadar ön bilgiden sonra sanırım ListView bileşenimize çalışma zamanı nasıl öğe ekleyip, bunları nasıl yöneteceğimizi öğrenmeye hazırız. Öncelikle TListItem tipinde bir değişken tanımlamalısınız. Daha sonra TListView.Items.Add fonksiyonuyla oluşturmalı, değişkenimize bağlamalı ve gerekli düzenlemeleri yapmalısınız.
Bir ListView bileşeninde toplu ve büyük değişiklikler yapmadan önce "BeginUpdate" ve bu işlemlerin sonunda da "EndUpdate" metodlarını çağırmak işlem hızını oldukça arttıracaktır. Bu komutlar her değişiklik olduğunda ekranın güncellenmesini engeller ve sonra işiniz bittiğinde tüm değişikliğin bir defada gösterilmesini sağlar. ListView'un "Clear" metodu, ListView'un içini güzelce temizler :). Ayrıca istediğiniz öğeyi silebilir, öğelerin yerini değiştirebilir ve daha başka birçok şey yapabilirsiniz. Hepsini burada anlatmam inanın çok zor. Yalnız yazıyı bir örnekle bitirmek istiyorum.
Örneğimiz bir TStringList içinde depolanmış dosya isimlerini ListView içinde göstermek. Ayrıca bu dosya isimlerinde dosya yolları da var ve biz bunu ayırıp her dosyanın ilk alt öğesinin bu dosyanın yolunu göstermesini de sağlayacağız.
Bunu yapmadan önce ImageList'imize istediğimiz simgeleri eklemeliyiz. Bunu yaptıktan sonra kodlara geçebiliriz:
Evet yukarıdaki örnek kodların da yardımıyla TListView bileşenini daha rahat ve etkin kullanabileceğinizi umuyorum. Kolay gelsin...
TListBox Üzerine TEdit Yerleştirmek
TListBox görsel nesnesinin görevi string tipteki verileri collection olarak scroll kullanma imkanı vererek listeleyebilmesidir. Ancak listede verilen string ifadeleri edit yapabilmek mümkün değildir. Bu işlemi gerçekleştirmek için nesnemize TEdit yerleştirebilirsek bunu başarabiliriz.
Formun OnCreate olayında Tedit nesnemizi dynamic olarak create edebiliriz. TListBox nesnesinin OnClick olayında TEdit nesnesini koordinatlarını belirterek yerleştirmemiz gerekir. Ayrıca TEdit içerisinde enter tuşu kullanıldığında da eski bilgi yerine yeni bilgiyi insert yapmamız gerekir. Şimdi kaynak kodu görelim:
type
TForm1 = class(TForm)
...
private
ListEdit : TEdit;
procedure ListEditKeyPress(Sender: TObject; var Key: Char) ;
end;
...
procedure TForm1.FormCreate(Sender: TObject) ;
begin
ListEdit := TEdit.Create(self) ;
ListEdit.Visible := false;
ListEdit.Ctl3D := false;
ListEdit.BorderStyle := bsNone;
ListEdit.Parent := ListBox1;
ListEdit.Width := ListBox1.ClientWidth;
ListEdit.OnKeyPress := ListEditKeyPress;
end;
procedure TForm1.ListBox1Click(Sender: TObject) ;
var
ii : integer;
lRect: TRect;
NASIL YAZILIMCI OLUNUR
İnsan bir çay poşetine benzer; Sıcak suyun içine atana kadar gerçek rengini bilemezsiniz.
Nasıl Yazılımcı Olunur?
Yazılım yazmak aynı zamanda teknik bir iştir. Program yazmak isteyen tüm arkadaşlarımın, alt kısımlarda yazacaklarımı dikkatle okumasını istiyorum. Yazdıklarım tamamen benim ifade özgürlüğümdür.
Yazılım yazmak kolay gibi görünsede uğraş isteyen bir meslektir. Zor değildir fakat kesinlikle bazı durumlarda çok sabır gerektiren bir meslektir.Yazılım yazmak için bir kere sabırlı olmak gerekir. Yazılım yazmaya başlamadan önce mutlaka araştırın. Sizlere bazı kaynaklar yazacağım. Bu kaynakları bilgisayarınıza indirip bir cd haline getirmenizi öneririm.
Evet başlıyoruz...
1. Elinizde program yazmak için bir uygulama yoksa Delphi 7 Data Architect Trial versiyonunu indirin. Program yazmak için Delphi dilini kullanacağız.
2. Size yön gösterecek ve bazı kaynakları nasıl kullanacağınız konusunda hazır kod programları lazım, tüm yazılımcıların mutlaka kullandığı meşhur Kodbank 3.1 i (3.57 Mb.) indiriniz. Kodbank 3.1 iniçerisinde sadece gönüllü üyeler tarafından verilmiş örnek kodlar vardır. Tabii kodbankasını kullanabilmek için pasaportum üyesi olmanız gerekir. Üyelik ücretsizdir.
3. Delphicilerin buluştuğu bir platformun Delphi Türkiye Off Line V3 (20.10 Mb.) (yani yardım dosyasını) indiriniz. Delphi Türkiye sitesinin full halini bu programla kullanabilirsiniz.
4. Yine Delphi Türkiye tarafından hazırlanmış bulunan Power Point Sunularını (2.32 Mb.) ek kaynak olarak indirebilirsiniz.
5. Eğer veritabanı kavramını Türkçe olarak ve kolay anlamak istiyorsanız (kişisel önerim) mutlaka size Advantage Veri Tabanı Yöneticisi Türkçe yi (3.59 Mb.) öreririm. (sonraki makalelerimde bil hassa ele alacağım)
6. www.enderarslanturk.com.trProgramlama kısmını sürekli ziyaret ediniz. İleriki zamanlarda aşama aşama bilgiler bulabileceksiniz. Ayrıca bu sayfayı bir çok arkadaşınıza önerebilirsiniz.
Bunların haricinde inanılmaz delphi kaynakları mevcuttur. Ayrıca şunuda belirtmek isterimki diğer program yazma dillerine oranla delphi programlamaya ait kaynaklar daha fazladır. Kendim delphi programlamacısı olduğum için böyle düşünüyorum. Eğer yanılıyorsam pcim çöksün.
Delphi Türkiye Video Seminerleri:
1.Delphi IDE (19.60 Mb.)
2.Object Pascal (13.43 Mb.)
3.İleri Object Pascal (28.53 Mb.)
4.Component hiyerarşisi ve component yazma (18.52 Mb.)
5.Veritabanı (17.27 Mb.)
6.SQL (35.86 Mb.)
7.Interbase/Firebird veritabanları (18.79 Mb.)
8.DelphiTurkiye.com daki makale'nin pratik bir uygulamasi (20.19 Mb.)
9.Raporlama (15.98 Mb.)
10. Delphi 8 (Delphi .net) ve .net framework (8.61 Mb.)
11. Data modelleme (23.02 Mb.)
12. Sybase Power Designer data modelleme (15.43 Mb.)
13. Örnek olaylar üzerinde İleri SQL (22.40 Mb.)
14. Modellemesi yapılan programın Delphi tarafında IBX ve FireBird ile sıfırdan yazılması (44.27 Mb.)
Teknik bir arızadan dolayı 13. ve 14. seminerlerde ses yoktur. Hem Delphi Türkiye Off Line V3 dosyasını yapmalarından dolayı hem de video seminerler için Delphi Türkiye ekibine teşekkür ederim.
Veritabanı yani bilgilerin tutulacağı alt yapıya sıra gelince size ilk bakışta alt yapı kullanımını rahatlıkla anlamanız için Advantange Database 'i öneririm. Advantage Database için, Türkiye distribitörlüğü tarafından hazırlanan Advantage Veritabanı Yöneticisinin Türkçe arayüzünü kullanabilirsiniz. Kullanımı gayet kolay ve basittir. Hatta veritabanı için hazırlanmış video seminerleri mutlaka indirip arşivinize ekleyiniz. Advantage Database ile ilgili ileriki zamanlarda ek bilgileri programlama kısmında bulabileceksiniz.
Advantage veri tabanına ait video seminerler:
1. Veritabanı yöneticisi ile veri tabanı oluşturma (203.94 Kb.)
2. Veritabanı yöneticisi ile tablo oluşturma (343.34 Kb.)
3. Veritabanı yöneticisi ile kullanıcı ve gruplarla çalışmak (193.48 Kb.)
4. Delphi bileşenleri ile tablolara bağlantı (174.54 Kb.)
5. Delphi bileşenleri ile advantage bağlantısı (207.81 Kb.)
Advantage veri tabanı için çok geniş bilgi içeren pdf formatında (acrobat reader) kullanım kitapçığı (1.44 Mb.) hazırlanmıştır.
Burada vermiş olduğum bilgilerin haricinde belirttiğim üzere daha nice kaynaklar mevcuttur. Mesela SQLNedir.com internet siteside bunlardan biridir.Oda ne site devre dışı.
Arkadaşlar bildiğiniz kaynakları buraya yazabilirsiniz. Sıra dışı kaynakların olmasında fayda vardır. İndiren arkadaşlar yorum yazabilirler mi
İşte en alt seviye programlama dili olan, hatta tam bir programlama dili bile olmayan Assembly'e başlayabilmeniz için anlaşılır ve pratik bir giriş yazısı...
İçerik Başlıkları
Giriş
Giriş
Öncelikle hemen söyleyeyim bu yazı programlamayla EN AZ orta seviye ilgilenenlere yöneliktir. Yani bu kritere uymuyorsanız bence hiç bulaşmayın, sonra program yazma işinden tiksinebilirsiniz :). Tabi tiksinme kısmı şaka ama yine de size çok sıkıcı gelebilir. Neyse uzatmadan başlayalım yazımıza.
Programlarınızı yazdığınız ortamları merak ettiniz mi hiç? Acaba onlar nasıl yapıldılar? Ya da ilk programlama dili nasıl ve hangi dille yazıldı(biliyorum biraz garip bir cümle oldu)? İşte bütün bu sorulara genel olarak verilebilecek cevap ASSEMBLY'dir. Assembly, aslında makina dili diye de geçer. Bu dili kullanırken -ki aslında tam olarak bir dil demek de yanlış- işlemcinin temel komut setinde ne varsa onları kullanırsınız. Aynı zamanda bildiğiniz şekilde değişken oluşturma ve yönetme şansınız da yoktur(Örn "int i=10;" gibi komutlarınız yok). Tabi bunlar yüzeysel yorumlar. Çünkü Assembly kullanırken bütün bunları -birçok fonksiyon, değişken yönetimi vs.- siz yaparsınız. Yani bir değişkenin saklanacağı bellek adresi, uzunluğu vs. tamamen sizin denetiminiz ve sorumluluğunuzdadır.
Şimdi önce isterseniz gelin programlama dillerinin sınıflandırılmasına bakalım. Programlama dilleri makinaya yakınlığından insana yakınlığına göre sıralanır. Mesela .NET dillerinden C# insana en yakın dillerden biridir. Bir çok alt seviye işlem derleyici tarafından otomatik yapılır veya yapılması için gerekli kod programa eklenir. Bunun yanında C en alt seviye dillerden biridir. Bellek denetimi gibi şeyler programcıya bırakılmıştır ama bu dille yapabilecekleriniz ve alacağınız performans C#'tan çok daha fazla olacaktır. İşte assembly bu sınıflandırmada makinaya en yakın yerde bulunuyor. Eğer bu dili iyi öğrenirseniz ve kullanabilirseniz deyim yerindeyse bilgisayara takla bile attırabilirsiniz.
Bilgisayarlar verileri 2'lik sistemde işler ancak 16'lık sistemde saklarlar. Örneğin 2 sayıyı toplamak istediğinizde bunlar işlemciye bitler şeklinde iletilir ki bu 2'lik sistemdir. Ancak bunları bir dosyaya yazmak isterseniz bu sefer bir byte'lık alanlara yazarsınız ki bu alanlardaki bilgiler de 16'lık sistemde saklanır. Biz de bilgisayarda artık EN ALT seviyede uğraşacağımıza göre bu sistemleri iyi bilmeli, bu sistemler ve 10'luk sistem arasındaki dönüşümleri rahatça yapabilmeliyiz.
Bilgisayarda saklanan ve işlenen verilerden bahsetmişken hemen bunların çalışan programlar için nerelerde yapıldığına bakalım. Normal dillerle yazılan programların tamamı değişkenleri bellekte saklar. Her değişkene ait bir bellek adresi vardır. Hatta pointerlar'la haşır neşir olanlar bu bellek adresilerini anımsayacaklardır. İşte assembly kullanırken bu pointerlar bizim değişkenlerimizi temsil edecek dersek çok da yanlış olmaz. Ancak işlemci komutları genelde doğrudan bellek üzerinde işlem yapmak yapmak yerine genelde REGISTER adını verdiğimiz işlemci çekirdeği üzerindeki sabit değişkenler üzerinde değişiklikler yaparlar.
Bellekle ilgili bilmeniz gereken bir başka şey ise belleğin segmentlere ayrılmış olduğudur. Segment sözcüğünü dilimize kabaca KATMAN olarak çevirebiliriz. Bu katmanlarda benzer tip veriler bir arada tutulur. Örneğin Code Segment(CS)'ta programınızın kodları bulunurken Data Segment(DS)'ta kullandığınız bazı değişkenlerin verileri tutulur. Bunların yanında Stack Segment(SS) ve Extra Segment(ES) gibi başka katmanlar da bulunur. Tüm bu katmanların başlangıç adresleri yanlarında parantez içinde belirttiğim kısaltmalarla aynı adlardaki özel registerlarda tutulur. Bunları yeri geldiğinde göreceğiz. Segmentlerin içindeki hücrelere ulaşmak için de offsetleri(adresleri) kullanırız. Veri yazma ve oku işlemleri DS üzerinde yapılır. O zaman biz bir bellek okuması veya yazması yapacağımız zaman sadece işlemi yapacağımız offseti bilmek zorundayız. İşlemci otomatik olarak DS'de tutlan değere bizim verdiğmiz offset değerini ekler ve ilgili hücreye veriyi yazar yada bu hücreden veriyi okur.
Assembly dilindeki komutlar yani işlemcinin temel komutları genelde 2 parametre kullanır -ki bunlara artık OPERAND diyeceğiz- ve bunlar register adı, bellek bölgesi ya da sabit bir sayı olabilirler. Örnek vermek gerekirse: MOV komutu bri register ya da bellek bölgesine değer atamak için kullanılır. İlk operand atama yapılacak bellek bölgesi ya da register adı, ikinci operand da oraya atanacak değeri içeren bir başka bellek bölgesi, register ya da sabit sayı olabilir. Yeri gelmişken operandları ayırmak için aralarına ","(yazıyla=virgül, rakamla=?!?! ) koyuluyor. O zaman offseti 100 olan bellek bölgesine 10 değerini atamak için "MOV [$64],$0A" komutunu vermemiz gerekiyor. Dikkat ettiyseniz 100 yerine $64 ve 10 yerine de $0A yazdım. Çoğu assembler(asm kodlarını derleyen program) direk onluk tabandaki sayıları kabul eder ve siz 16'lık tabanda bir sayı girmek istediğiniz zaman başına $ işaretini koymanızı ister. Ancak debug gibi basit ve alt seviye bir derleyici kullanırsanız bütün sayılar standart oalrak 16'lık sitemde yorumlanacaktır. Bu arada komutta da gördüğünüz gibi bellek bölgelerine ulaşmak veya oralarda işlem yapmak için offsetini köşeli parantez içinde yazmamız gerekiyor. Ve son olarak o komut aslında hatalı. Çünkü bellek bölgesine byte cinsinden mi word(2 byte'lık veri) cinsinden mi yazacağımızı belirtmedik. O ne ki derseniz hemen açıklayayım. Bellek bölgeleri aslında 1 word'lük kapasiteye sahiptirler ancak oralara sabit sayılar atanırken 1 byte uzunluğundaki veriler de yazılabilir. Bunu açıklığa kavuşturmak için operandlardan önce "BYTE PTR" ya da "WORD PTR" yazmamız gerekiyor. Vay be, bir komutla amma çok şey anlatmış oldum!
Aslında buraya öyle detaylı bir kullanım rehberi ya da birçok komutun kullanım şeklini falan yazmayı düşünmüyorum. Çünkü hem ben o konuda anlatabilecek kadar yetkin değilim hem de zaten bu yazının amacı giriş yapmanızı sağlamak. Zaten sadece assembly kullanarak bir program yazmak aslında biraz çılgınlık (kabul ediyorum zamanında 16bitlik programlar yazdık biz arkadaşımla ama cidden kafayı yeme noktasına geldik ). Bu sebeple buradan öğrendiğiniz genel bilgiler ve komutları öğrenebileceğiniz bir kaynağın da yardımıyla programlarınızda hız artışı veya boyut azaltışı(!) yapabilirsiniz.
Bu kadar gevezelikten sonra genel kullanım ve birkaç komut açıklamsıyla yazımızı bitrelim. Daha önce de dediğim gibi burada komutlardan sonra operand giriyorsunuz. Bazı komutlar operandsız da olabiliyor. Ve bir komut en çok 2 operand alabiliyor(aslında daha çok alan da olabilir ama bildiğim kadarıyla 2 ile sınırlı). Daha önce bahsettiğim MOV komutu 2 operand alır. İlk operand atama yapılacak yeri belirtirken ikinci operand atama yapılacak değeri belirtir. Buraya sabit bir sayı yazabileceğinizi gibi birbellek bölgesi ya da register adı da yazabilirsiniz.
XOR komutu ilk operand ile ikinci operandı XOR mantıksal işleminden geçirir ve sonucu ilk operanda atar. AND, OR gibi diğre mantıksal operasyon komutları da aynı şekilde çalışır.({a:=a xor b} deyimi assemblyde {xor a,b}'ye denk gelir)
PUSH komutu arkasından verilen operandın değerini bellek yığınına atar ve arkasından çağırılan POP komutuyla bu değeri POP komutunun operandına geri yükler. Yanlız burada işlemin sırayla olduğunu unutmamanız gerekiyor. Yani
PUSH EAX
PUSH EBX
.
.
POP EAX
POP EBX
gibi bir komut yazarsanız EAX'ın değeri EBX'e, EBX'in değeri de EAX'a atanmış olur. Çünkü en son EBX'in push edilmesine rağmen ilk POP işleminde EAX kullanıldı. Özetlersek ilk giren son çıkar ya da son giren ilk çıkar diyebiliriz.
CMP komutu kıyaslama yapmak için kullanılır. Verilen ilk opranddan ikinci operand çıkartılır ancak operandların değerlerinde bir değişiklik olmaz. Bu işlem sadece FLAG adı verilen bazı kontrol bitlerinin değerlerinin değişmesine sebep olur ki bu da zaten kıyaslama sonucunda yapılacak işlemi berlemek için yeterlidir. Şöyle ki: burada BASIC'tenbildiğiniz "GO TO"ya benzer bir yapı kullanılıyor. Yani şu şöyleyse buraya git ve oradan devam et gibi bir yapı var. Bunları da GO TO değil JMP, JNZ gibi atlama komutlarıyla yapıyorsunuz. JMP komutu hiçbir koşul gözetmeden operand olarak verilen adrese atlar ve oradan devam eder. JNZ ise "Zero Flag"i olarak geçen ve son işlemin sonucu 0 ise değeri 1 yapılan bir bitin değerine göre atlama yapar. CMP işleminde de iki operandın değeri birbirinden çıkarıldığında sonuç sıfır ise bu iki değer birbirine eşit demektir ki bu durumda JNZ komutu(Jump if Not Zero) hiçbirşey yapmaz çünkü "Zero Flag"i 1'dir. Yani sonuç sıfırdır. JZ komutu ise JNZ'nin tam aksine Jump if Zero yani sonuç sıfırsa şu adrese git anlamına gelir. Yine az önceki durumu düşünürsek bu komutu kulanırsanız program belirtilen adrese sıçrayacak ve buradan devam edecektir.
Son olarak for ve/veya while döngülerine karşılık gelen LOOP komutunu da verelim. For döngülerinde kullandığınız değişken sanırım genel de "i" oluyor. Burada ise bu iş için standart olarak ECX register'ı kullanılıyor. Bu register'a döngünün kaç kez çalıştırlacağını atadıktan sonra işletilecek komutların sonuna LOOP {adres} komutunu yazıp adres olarak da komutların başlangıç adresini verirseniz tam bir for döngüsü elde etmiş olacaksınız. Yalnız burada dikkat etmeniz gereken birkaç nokta var. Öncelikle döngü komutu içerisinde ASLA ECX'in değerini değiştirmemelisiniz. Değiştirmek zorunda kalırsanız da mutlaka PUSH ve POP komutlarını gerekli şekilde kullanıp orijinal değerini geri döndürmeniz gerekir. Aksi takdirde döngünün uzunluğu alakasız şekilde değişebilir. İkinci olarak, LOOP'a operand olarak verdiğiniz adres ECX'registerına döngü sayısını atadığınız yerden sonra olmazsa programınız sonsuz döngüye girer. LOOP'un 2 farklı versiyonu daha var: LOOPZ ve LOOPNZ. Bunlar da hem ECX'in değerine bakıyorlar hem de "Zero Flag"inin değerine. LOOPZ, Loop if zero; LOOPNZ ise loop if not zero yani LOOPZ sıfır olduğu sürece, LOOPNZ de sıfır olmadığı sürece döngüye devam et anlamına geliyor. Eğer döngü içinde bir CMP işlemi varsa bu komutlardan birini kullanarak döngü sayısı bitmeden döngüden çıkılmasınıa sağlayabilirsiniz.(Bu da döngü içinde kullandığımız "break;" komutuna benziyor.)
Evet arkadaşlar biraz dağınık bir yazı oldu, farkındayım. Ama bu kadar geniş ve zor bir konuyu basitçe anlatmak benim için gerçekten çok zor. Ne kadar detaya gireceğimi, hangi komutlardan nasıl bahsedeceğimi belirlemek zor oldu. Umarım yararlı bir yazı olmuştur. Bir de bitirmeden önce bu yazıyı yazmama yardımcı olan değerli arkadaşlarım Yaman UMUROĞLU ve Şenol ÖZKAN'a buradan teşekkürlerimi yolluyorum. Bir sorunuz olursa e-posta adresim aşağıda, çekinmeden mektup yollayabilirsiniz.
Delphi - .....................................
Renk paletlerinin hazırlanması ve kullanımı
Renk Paletlerinin yaratılması ve kullanımı
Delphi uygulamasında çizim yapılırken, gereken paletin yaratılması ve kullanılması nasıl olur?
Eğer palet değiştirme yolu ile animasyon yapılacaksa, en az 256 renk modunda çalışılmalı ve, aşağıdaki kod örneğinde geçen bütün PC_NOCOLLAPSE değerleri PC_RESERVED olarak değiştirilmelidir.
Palet yaratmanın yanı sıra, yapılması gereken diğer işlemler de şunlardır.
1. Formun GetPalette davranışı,yeni paleti döndürecek şekilde değiştirilmelidir.
2. Boyamaya başlamadan hemen önce, yeni palet seçilmelidir.
