Delphi - Die Erleuchtung

Was ist Delphi? - Eine Programmiersprache, über die sich Programme in alle möglichen Richtungen schreiben lassen, von Spielen bis zu Server-Client Diensten, auch sehr Systemnahe Programme wie NT-Dienste etc.

Was muss ich kennen lernen?

• Variablen, dass sind Platzhalter, die Speicherplatz für Werte etc frei halten, wie eine Schachtel, in die ich beliebig Gegenstände hineintuen kann, wieder herausnehmen, sie verändern etc.
• Konstanten, mit Zetteln zu vergleichen, auf die man etwas draufschreibt um es sich wieder in Erinnerung zu rufen
• Deklaration - eine Variable "definieren" - Beispiel: Ich habe die Variable mit dem Namen "Zahl1" und ihr werde ich dann ganze Zahlen(natürliche Zahlen) zuweisen, z.B.: 1
• Variablentypen - Diese sind nötig, weil nicht jede Variable gleich viel Speicher frei halten kann, so weise ich sie z.B.: dem Typen Integer zu, in welchem nur(!!) natürliche Zahlen "gespeichert" werden können, oder dem Typen String, in welchem Zeichenketten, also alle sich auf der Tastatur befindlichen Zeichen befinden können, der Unterschied zwischen diesen Typen ist, dass man sie nicht für dasselbe benutzen kann, so kann ich mit Strings z.B nicht rechnen
• Prozeduren, sie sind wie eine Aktion und können aufgerufen werden, so kann man mit Prozeduren etwas machen, wie z.B.: Durch das drücken eines Buttons wird eine Prozedur aufgerufen die eine Schrift sichtbar macht
• Funktionen - Wie in der Mathematik, nur werden sie oft so gebildet, dass sie in Prozeduren benutzt werden, in dem ihnen Werte übergeben werden, womit sie dann etwas machen und dann ein Ergebnis wiedergeben, so könnte ich zum Beispiel eine Prozedur schreiben die beim drücken eines Buttons eine Funktion mit den vom Benutzer angegebenen Werten aufruft, dann wird das Ergebniss, welches die Funktion liefert durch die Prozedur dem Benutzer sichtbar gemacht, dies werde ich aber noch detaillierter erklären
• Formulare - eine grafische Oberfläche auf denen ich Komponenten wie Buttons oder Eingabefelder platzieren kann
• Kompilieren - Der Quellcode, also der Programmtext, wird so umgewandelt, dass ein ausführbares Programm, also eine .exe entsteht
• Debugger - Er kontrolliert unseren Programmcode auf Fehler
• Syntax - Auch unser Programmcode braucht eine Struktur und benutzt sowas wie Satzzeichen

Das sind die Grundlegenden Begriffe, die man kennen lernen sollte, bevor man sich ans praktische Programmieren setzt.

Der Autor dieses Blogs, im weiteren Glamr genannt garantiert weder für die Richtigkeit
der Inhalte, noch werden alle auf dieser Seite vorhandenen Links überprüft, da diese teilweise von den Usern gepostet werden.

Also zu erst würde ich persöhnlich unter Uses die XPMAN einbinden, denn dann passen sich die Komponenten dem Xp Design an, was schon mal ein Fortschritt ist, dann bearbeiten wir die Form im Objektinspektor und zwar so:

• Transparentcolor: Die Farbe, welche nachher im Programm Unsichtbar seien soll, jede Komponente, Bild etc, einfach alles auf dem Formular was diese Farbe hat wird dann Unsichtbar, aber nur im Falle von Transparentcolor:= true
• Transparentcolor:=true - lässt sich im Objektinspektor einstellen und somit wird die Transparentcolor dann Unsichtbar
• Borderstyle:=bsNone - wir haben nicht den normalen Windows Rahmen, denn wir werden uns einen eigenen machen

Als nächstes machen wir uns ein Hintergrundbild für die Form, welche ja Durchsichtig ist, da ihre Farbe die selbe ist wie die Transparentcolor.

Ich habe mich für dieses Entschieden, welches ich jetzt auf die Form legen werde, im Vordergrund sind dann meine Komponenten.



Als Titelleiste mit der man die Form später mit der Maus verschieben sollen kann nehme ich dieses Bild, was als TImage auf meine Form kommt.



Die Komponente TImage die nachher per Mauszug die Form verschieben soll bekommt nun der Prozedur:

procedure TForm2.Image1MouseDown(Sender: TObject; Button: TMouseButton;
Shift: TShiftState; X, Y: Integer);
begin
ReleaseCapture;
Form2.Perform(WM_SYSCOMMAND, $F012, 0);
end;

So, eure GUI ist fertig!
Hier mein Ergebnis:


Damit es funktioniert müssen die Bilder die ihr in die TImages packt als .bmp gespeichert seien! Mit .jpg Bildern funktioniert es nicht.

So hier die Unit Sndkey32 mit deren hilfe sich Tastenanschläge an das jeweils aktive Fenster senden lassen.

Download

Einfach unter Uses Sndkey32 angeben und dann lässt sich die Funktion mit

sendkey('hallo');
oder
sendkey(edit1.text);

aufrufen.

So nun zeige ich euch wie man einen virtuellen Tastenanschlag an ein bestimmtes Fenster sendet.

procedure key(s:string);
var
wnd: HWND; //Das Fenster
i: Integer; //Die Zeichenlänge
begin
wnd := FindWindow(nil,'SRO_Client'); //Das Fenster: Sikroad(Spiel)
if wnd <> 0 then //Fehler? kein Prob
begin
wnd := FindWindow(nil,'SRO_Client');
for i := 1 to Length(s) do //Jedes Zeichen wird ausgelesen und per virtuellem Tastenanschlag gesendet
PostMessage(wnd, WM_Keydown, Word(s[i]), 0); //Taste drücken
PostMessage(wnd, WM_Keyup, Word(s[i]), 0); //und wieder frei geben
end;
end;

Aufgerufen wird das ganze mit:

key('Der Text');

oder sowas wie

key(edit1.text);

Viel spaß beim ausprobieren!

Wenn ihr die Tastenanschläge immer an das aktive Fenster senden wollt dann sucht mal unter Downloads nach Sendkey ;)

Wie man sein Programm beim minimieren in ein Tray Icon verwandelt:


private
TaskBarNewReg : DWORD;
IconData: TNotifyIconData;
public
procedure WndProc(var Msg: TMessage); override;
procedure WMSysCommand(var Message: TWMSysCommand); message WM_SYSCOMMAND;
end;

procedure TForm1.FormCreate(Sender: TObject);
begin
TaskBarNewReg := RegisterWindowMessage('TaskbarCreated');
IconData.cbSize := SizeOf(IconData);
IconData.Wnd := Handle;
IconData.uID := 100;
IconData.uFlags := NIF_MESSAGE + NIF_ICON + NIF_TIP;
IconData.uCallBackMessage := WM_USER + 20;
IconData.hIcon := Application.Icon.Handle;
IconData.szTip := 'Glamr´s Hotkey Tool - drink some beer!';
end;

procedure TForm1.WMSysCommand(var Message: TWMSysCommand);
begin
if Message.CmdType and $FFF0 = SC_MINIMIZE then
begin
Hide;
Shell_NotifyIcon(NIM_ADD, @IconData);
end
else
inherited;
end;


procedure TForm1.FormDestroy(Sender: TObject);
begin
Shell_NotifyIcon(NIM_DELETE, @IconData);
end;

procedure TForm1.WndProc(var Msg: TMessage);
var
Point: TPoint;
begin
if Msg.Msg = WM_USER + 20 then
begin
case Msg.lParam of
WM_RBUTTONDOWN:
begin
SetForegroundWindow(Handle);
GetCursorPos(Point);
PopUpMenu1.PopUp(Point.X, Point.Y);
end;
WM_LBUTTONDOWN:
begin
//ShowMessage('links runter');
end;
// WM_LBUTTONDBLCLK:
//begin
// Fenster anzeigen
//Form1.Show;
// Icon entfernen
//Shell_NotifyIcon(NIM_DELETE, @IconData);
//end;
end;
end
else if Msg.Msg = TaskBarNewReg then
begin
Shell_NotifyIcon(NIM_ADD, @IconData);
end;
inherited;
end;

Bei fragen einfach einen Comment hinterlassen!

Globale Hotkeys benutzen

Hier wie es geht:

procedure TForm1.FormCreate(Sender: TObject);
const
VK_F4 = $73; // F5 wäre dann $74 usw..
VK_F3 = $72;
VK_F2 = $71;
VK_F1 = $70;
begin
id1 := GlobalAddAtom('Hotkey1');
RegisterHotKey(Handle, id1, 0, VK_F1);
id2 := GlobalAddAtom('Hotkey2');
RegisterHotKey(Handle, id2, 0,VK_F2);
id3 := GlobalAddAtom('Hotkey3');
RegisterHotKey(Handle, id3,0, VK_F3);
id4 := GlobalAddAtom('Hotkey4');
RegisterHotKey(Handle, id4, 0, VK_F4);
end;

Hier werden die Hotkeys registriert und damit nutzbar und zwar so:

procedure TForm1.WMHotKey(var Msg: TWMHotKey);
begin
if Msg.HotKey = id1 then
showmessage('Sie haben F1 gedrückt!');
if Msg.HotKey = id2 then
showmessage('Sie haben F2 gedrückt!');
if Msg.HotKey = id3 then
showmessage('Sie haben F3 gedrückt!');
if Msg.HotKey = id4 then
showmessage('Sie haben F4 gedrückt!');
end;

Variablen und Konstanten in Delphi

Es gibt 2 Wege Variablen und Konstanten zu deklarieren die der Anfänger kennen lernen sollte:

• Globale Deklaration
• Lokale Deklaration

Durch eine Globale Deklaration wird die Variable für alle Prozeduren und Funktionen benutzbar gemacht, durch eine Lokale Deklaration nur einer Funktion oder Prozedur.

Veranschaulichung:





Genau so kann man es auch mit Konstanten machen, nur dass diese anders deklariert werden, zb:

Const
MAX_LINES = 3;
CRUDE_PI = 22/7;
HELLO = 'Hello World';
LETTERS = ['A'..'Z', 'a'..'z'];
DECISION = True;


Wofür man manchmal Global oder Lokal Deklariert?

Na, damit die Übersichtlichkeit bleibt, benötigt man nur eine Zählervariable ist es unnötig diese Global zu deklarieren.

Variablentypen die in Delphi sehr gebräuchlich sind:

String - Zeichenkette
Integer - ganze Zahlen
Int64&Longinteger - Integer mit mehr Speicherplatz
HWND - Ein Fenster unter Windows
PAnsiChar - Ein Dateipfad
Real - Dezimalzahlen

Mehr Variablentypen kann man natürlich in Wikipedia finden.

Hier ist mal ein Link zu einer schon vorhandenen Delphi Internetseite die ich jedem wirklich nur ans Herz legen kann.

Die Code Libary hat Glamr und mir auch schon viel geholfen bei unseren Projekten.

Klick zur Libary

Die Community und das Forum kann ich auch wirklich nur empfehlen.
Die Member sind freundlich, hilfsbereit und vor allem Spezialisten auf ihrem Gebiet.

Wenn ihr mal nicht mit den Quellcodes oder anderen Sachen klar fragt uns oder meldet euch im Forum von www.delphipraxis.net an.
Für jeden eine Bereicherung, da das Forum gut sortiert und aktiv ist.

Klick zum Forum

Klick um direkt zur Registrierung zu gelangen.

Guten Morgen.

Ich habe verschiedene Wege gefunden günstiger an Ware zu kommen.

Natürlich dachte ich Diesel Unterwäsche 70% reduziert? Irgendwas kann ja da nicht stimmen.
Ist die Ware original? Oder vllt 2nd Hand? Oder 2. Wahl.
Naja hab ich gedacht versuchen kann ichs ja mal, zurückschicken geht ja auch.

Ich bin wirklich überzeugt von den beiden Anbietern die ich hier vorstelle.

Es sind keine Werbeversprechen! Die Ware ist original und TOP, immer Original verpackt.
Und wenns einem nicht gefällt dann schickt man es zurück und bekommt sein Geld ZURÜCK.
Leider kann man dann nicht einfach was neues bestellen oder eine Nummer größer.

Man kommt in diese Shoppingclubs nur mit Einladung rein.

Zum einen haben wir hier Brands4Friends, hierzu schickt mir eine eMail mit eurer eMail-Adresse und eurem Namen, dann kann ich euch einladen.

Zum anderen haben wir BuyVip. Hier ist das ganze etwas einfacher. Für diesen Dienst gibt es einen Link über den ihr euch anmelden könnt als ob ich euch bereits eingeladen hätte.
Bei BuyVip gibt es den Vorteil das es nicht immer nur eine Aktion gibts sondern viele verschiedene. Im Moment Schmuck, Kleidung und Wein^^

Anmeldung

Nur Leider muss ich dazu sagen das der Versan lange dauert, aber da man es vorher weiß ist es nicht schlimm, wie ich finde.
Bei Brands4Friends nach Abschluss der Aktion 14 Tage.
Bei BuyVip nach Abschluss der Aktion 21 Tage.
Die Versandzeiten haben nichts mit Unseriösität zu tun oder der gleichen, die Ware wird von denen Bestellt wenn sie bestellt haben und wird nach Geldeingang an sie weiterverschickt.

Zu Ergänzen ist noch das die Ware so billig ist, weil sie gerade original ist. Hört sich im ersten Moment wiedersprüchlich an, ist es aber nicht, denn bei der Ware handelt es sich um Ware aus dem Ausland USA, Schweiz & anderen oder aus deutschen Aktionen. Diese Restposten werden von denen aufgekauft und zum Verkauf angeboten.

Ich bin wirklich zufrieden mit den Anbietern.

Delphi 2005
Codename: DiamondBack

Delphi 2005 wurde seit November 2004 ausgeliefert.
Neben nativen Windows-32-Bit-Anwendungen können mit Delphi 2005 auch .NET-Anwendungen in Delphi und C# erstellt werden.
Im Gegensatz zu den Vorversionen Delphi 7 (Win32) und Delphi 8 (.NET) gibt es nun nur noch eine Delphi-IDE oder auch "Borland Developer Studio".

Mit Delphi 2005 hielten umfassende Neuerungen in die IDE Einzug, wie z. B. Refactoring. Auch die Programmiersprache selbst wurde um einige Funktionen, wie z. B. das For-Each-Konstrukt erweitert. Der Compiler kann nun auch sprachspezifisch Zeichen interpretieren. So können im deutschen Quelltext auch die Sonderzeichen ä, ö, ü verwendet werden. Die IDE zeigt umfassende Hilfetexte in einer nie dagewesenen Übersichtlichkeit an. Allerdings traten auch viele Fehler innerhalb der IDE und den mitgelieferten Komponenten auf, was zu einer gewissen Unzufriedenheit bei den Nutzern geführt hat, vor allem auch in Bezug auf die lange Ladezeit der IDE. Erst nach mehreren Updates und einigen inoffiziellen Bugfixes konnte man nach Meinung vieler Entwickler mit der IDE sinnvoll arbeiten.

Externer Downloadlink:
Delphi 2005 Download

Upload.to Links:
Part1:
Part2:

Firmenname: Borland
Aktiennummer: BORL (NESDAQ)

Gründer: Philippe Kahn (französicher Mathelehrer)
Gründungsjahr: 1983
Hauptsitz: Austin (Texas)

Das Unternehmen machte sich hauptsächlich durch , in den 90ern, Microsoft überlegenen Softwareentwickelungen und Entwickelungstools von sich reden.
Unter der Leitung von Philippe Kahn entstand die Programmiersprache Turbo Pascal, die dann weiterentwickelt wurde zu Dekphi.

Mitlerweile beschränkt sich das Unternehmen jedoch mehr auf Softwareprodukte und Entwicklung von Businessapplikationen bzw. Middleware-Werkzeugen und stieg in den Markt internetorientierter Tools wie JBuilder ein. (JBuilder ist eine Entwickelerumgebung für Java)

Im Februar 2006 kündigte Borland an, die Produktlinie der Entwicklungsumgebungen (Delphi, JBuilder etc.) zu verkaufen und sich fortan ausschließlich auf den Bereich des ALM zu konzentrieren. Laut Press Release vom 14.11.2006 wird die IDE-Sparte nun zwar in ein eigenes Unternehmen namens CodeGear ausgegliedert, verbleibt jedoch in Besitz von Borland.

Am 5. September 2006 hat Borland die „Turbo“-Reihe wieder auferstehen lassen - „Turbo Delphi Win32“, „Turbo Delphi .net“, „Turbo C#“ und „Turbo C++" sollen mit den kostenlos erhältlichen „Explorer“-Versionen wieder mehr Programmierer für die IDE-Produkte von Borland werben.

Am 7. Mai 2008 wurde bekanntgegeben, dass die Tochterfirma CodeGear an Embarcadero Technologies verkauft wurde.

Die Delphi Version die auch hier zum Download angeboten wird ist im Prinzip Delphi 9 wird aber offiziel Delphi 2005 geannat.

Andere Produkte:

Tempo
Caliber Analyst
Caliber DefineIT
CaliberRM
Together Technologies
Gauntlet (Software)
SilkCentral Test Manager
SilkTest
SilkPerformer
StarTeam

Ehemalige Entwicklungen von Borland sind:
dBASE (übernommen von Ashton-Tate)
Borland Paradox – Relationales Datenbank-Management-System (verkauft an Corel)
Quattro Pro – Tabellenkalkulation (verkauft an Corel)
Reflex
SideKick
Turbo Basic (verkauft an PowerBASIC Inc.)
Turbo C,
Turbo Pascal, Borland Pascal
Turbo Prolog
WordPerfect (übernommen von Novell, verkauft an Corel)
ObjectVision
Kylix
Eureka (Programm zur Lösung mathematischer Probleme)




teilweise aus wikipedia.de übernommen.

Hier ist der Angekündigte Downloader:

Multi Stream Downloader

0.65 Alpha

Features:
Download mit bis zu 50 Verbindungen
Resume funktion
Hangup Protection
Quelltextfilter
Linksammler
CCF Unterstützung
RSDF Unterstützung
DLC Unterstützung (es werden nur dlc´s ab jD 0.0.888 unterstützt)
YouCrypt Junior
Proxy Support
Chronik
Addon System
Auto Unpacker (für .rar Dateien)

Zur Benutzung ist ein Rapidshare.com Premium Account erforderlich

Upload.to Donwload

Wir unterstützden keineswegs illigale Up- oder Download Aktivitäten!

Mit dem Internet Geld zu verdienen gehört heutzutage mit zu den modernsten.
Es gibt viele Anbieter die einen für die verschiedensten Dinge belohen wollen.
Man kann für Werbung klicken Geld bekommen oder auch dafür mit Werbung zugespammt zu werden, oder auch einfach nur fürs surfen auf bestimmten Seiten.
Leider gibt es viel zu viele schwarze Schafe.
ABER es gibt auch gute und vorbildliche Dienste.
Ein paar werd ich hier mal vorstellen.

Zu erst die Paidmailer. Man bekommt Mails zugeschickt mit Werbung die man bestätigen muss, hierfür bekommt man Geld oder Punkte die umgerechnet werden.

Earnstar
Auszahlungsgrenze: 20 Euro

(Um auf die Website zu gelangen bitte Banner anklicken)

Questler
Auszahlungsgrenze: 5 Euro

(Um auf die Website zu gelangen bitte Banner anklicken)

Profitmails
Auszahlungsgrenze: 5 Euro

(Um auf die Website zu gelangen bitte Banner anklicken)


Für diese 3 Anbieter kann ich mich verbürgen! Ich habe von alles schon Auszahlungen erhalten und keine Probleme gehabt.

Zum anderes gibt es Dienste die für Werbeeinblendungen bezahlen.

Sie haben eine Website?
Diese Website ist gut besucht?
Dann ist Layer-Ads was für sie!

Sie setzten einen Code in ihren Quellcode ein, der bewirkt das wenn jemand die Seite besucht Werbung eingeblendet wird.

Pro 1000 Werbeeinblendungen werden ihnen zwischen 4,00 Euro und 7,50 Euro vergütet.

Auszahlungsgrenze: 15 Euro


(Um auf die Website zu gelangen bitte Banner anklicken)


Weitere Systeme werden zur Zeit von uns getestet und danach ergänzt.

So, nun schreiben wir einen kleinen Rechner.Er soll nicht besonders gut sein aber einfach darstellen wie das Rechnen in Delphi Funktioniert.

Was wir brauchen:

2 Editfelder für die Zahlen mit denen wir Rechnen
1 Label für das Ergebnis
4 Buttons für + - * /

Hier wie es Funktioniert:

die Zahlen die in den Editfeldern stehen sind Strings, da man mit Strings nicht rechnen kann, sondern nur mit Integer(ganze Zahlen: 1,2,3,4...) und Real(Dezimalzahlen: 1,233535 etc.) müssen wir die Stringförmigen Zahlen erst umwandeln, dies ist ganz einfach.

Zu erst brauchen wir 2 Variablen, diese Deklarieren(Registrieren) wir global, da sie von mehreren Prozeduren benötigt werden einfach unter

Var
tform1: tform;

oder wie ihr euer Formular genannt habt, kommt dann noch

zahl1,zahl2: integer;

oder bei Dezimalzahlen

zahl1,zahl2: real;

Nun können wir den Variablen unsere Zahlen aus den Editfeldern zuweisen:

zahl1:=strtoint(edit1.text);
zahl2:=strtoint(edit2.text);

bei Real hieße es strtofloat.

Mit den Zahlen rechnen wir nun so:

zahl1:=strtoint(edit1.text);
zahl2:=strtoint(edit2.text);
label1.caption:=inttostr(zahl1+zahl2);

Dies wäre nun der Fall, dass wir ganze Zahlen benutzen, das inttostr deswegen weil das Label nur Strings anzeigen kann.
Im Falle von Real Variablen wäre es dann Floattostr.

Viel Spaß beim rumprobieren, und denkt daran dass man beim Dividieren keine Integer Variablen benutzen kann.

Nun schreiben wir unser erstes Programm um ein kleines Feeling für die Welt des Programmierens zu bekommen.
Zu erst gehen wir auf Datei -> neues Projekt -> Delphi für Win32 -> VCL Formularanwendung

Wenn wir das gemacht haben dürften unsere Werkzeuge jetzt bereit stehen und wir sehen nicht mehr die Startseite des Programmes.

Als erstes ziehen wir uns jetzt per Drag&Drop eine Komponente TEdit in das Formular, welches wir in der Kategorie Design sehen. Dieses können wir nun beliebig verschieben.
Im Objektinspektor können wir nun Unter "Text" den Text verändern, welcher wenn das Programm gestartet wird in unserem Edit-Feld zu sehen ist.

Nun ziehen wir noch eine Komponente TButton in das Formular und plazieren sie dort wo wir sie hinhaben wollen.
Durch ein Doppelklicken auf die Komponente gelangen wir jetzt in den Code bereich, die Entwicklungsumgebung hat uns schon die procedure Unserformular.unserbutton.onclick bereitgestellt.
Ja richtig, hier können wir nun bestimmen was passieren soll wenn jemand auf den Button klickt. Und durch das Doppelklicken auf den Button im Design Bereich hat das Programm uns Schreibarbeit gespart, Wunderbar!

Die Procedure(Prozedur, also eine Aktion) wurde nun oben in den Bereich, wo alle Komponenten und Aktionen stehen eingetragen, sozusagen in den Index des Programmes.

Unten , in dem Bereich, wo der Inhalt der Aktion beschrieben ist steht jetzt der Umriss unserer Prozedur, auf welchem Formular, was wann diese Aktion wodurch aufrufen soll, wir müssen also nur noch schreiben was passieren soll.

Was wir nun zunächst machen:

Der Inhalt des Editfeldes soll in einem Popup angezeigt werden, hier der Quellcode:

procedure meinformular.meinButtonClick(Sender: TObject);
begin
showmessage(edit1.text);
end;

begin und end sagt aus, dass bei der aktion mehrere Befehle ausgeführt werden können, wir könnten zum Beispiel auch das Editfeld wieder leeren und zwar so:

procedure meinformular.meinButtonClick(Sender: TObject);
begin
showmessage(edit1.text);
edit1.text:='';
end;

Durch das := wird dem Editfeld ein neuer String(Zeichenkette) zugewiesen.
Zeichenketten sind entweder in Form von Variablen vorhanden, oder als Vorgegeben, dann müssen sie wie hier durch ' abgegrenzte sein. Beispiel: 'Mein String steht hier!'

Nun müssen wir das Programm nur noch kompilieren, das machen wir in dem wir auf den grünen Pfeil, der aussieht wie das Play zeichen vom MP3 Player klicken.
Das Programm wird jetzt kompiliert und ausgeführt.

Fertig!

• Die Entwicklungsumgebung

- Definition:

Die Entwicklungsumgebung ist ein Programm, welches uns einen Editor bietet, worin wir unseren Programmcode schreiben, eine Oberfläche zum bearbeiten der GUI(grafische Oberfläche, in die wir Buttons und andere Komponenten einfügen können welche wir mit einer Funktion belegen können) , einen Debugger, welcher uns Fehler - die durch uns oder den PC verursacht wurden anzeigt und einen Compiler - welcher aus dem ganzen ein ausführbares Programm(.exe) macht.

- Was zu tuen ist:

• Zu erst laden wir uns den Installer runter, und zwar hier.
• Dann brauchen wir einen Lizenzschlüssel, welchen wir uns hier als Datei zusenden lassen können, nach Anmeldung wird dieser an die angegebene E-Mail Adresse gesendet.
• Wenn wir den Installer fertig geladen haben installieren wir Delphi 2005.
• Ist die Installation fertig, kopieren wir die datei reg520.txt, welche wir per E-Mail zugesendet bekommen haben in den Ordner: Die Windowsfestplatte, zb. C:\ dann Dokumente und Einstellungen und dann unser Windows-Username, bei mir Admin. Das ganze sähe bei mir so aus: C:\Dokumente und Einstellungen\Admin
• Nun ist unsere Entwicklungsumgebung (Borland Delphi 2005) installiert und registriert.

-Ein neues Projekt

Die Entwicklungsumgebung kann für mehrere Sprachen genutzt werden, dies sind: C# , Delphi für Win32 und Delphi .NET.
Wir programmieren in Delphi für Win32 also interessiert uns der Rest nicht.

In unserer Entwicklungsumgebung haben wir 4 Komponenten, den Debugger, der unserern Quellcode auf Richtigkeit überprüft und eventuelle Probleme beim Programm meldet, den Editor, in dem wir unseren Quellcode schreiben, den Compiler, der aus unserem Projekt ein ausführbares Programm macht und die Designumgebung mit der wir unsere grafische Oberfläche für das Spätere aussehen des Programmes gestalten, vorrausgesetzt wir schreiben ein Programm mit grafischer Oberfläche.