Difference between revisions of "Lazarus IDE Tools/de"
m |
|||
Line 346: | Line 346: | ||
=== Invert Assignments === | === Invert Assignments === | ||
− | ; | + | ;Kurz gefasst: : "Invert Assignments" takes some selected pascal statements and inverts all assignments from this code. Dieses Werkzeug ist hilfreich für das Umwandeln a "save" code to a "load" one and inverse operation. |
− | + | Beispiel:<br> | |
procedure DoSomething; | procedure DoSomething; | ||
begin | begin | ||
Line 355: | Line 355: | ||
AValueHouse:=BValueHouse; | AValueHouse:=BValueHouse; | ||
end; | end; | ||
− | Select the lines with assignments ( | + | Select the lines with assignments (zwischen begin und end) and do Invert Assignments. All assignments will be inverted and identation will be add automatically. Zum Beispiel: |
− | + | Resultat: | |
procedure DoSomething; | procedure DoSomething; | ||
begin | begin |
Revision as of 15:26, 21 July 2006
│
Deutsch (de) │
English (en) │
español (es) │
suomi (fi) │
français (fr) │
日本語 (ja) │
한국어 (ko) │
Nederlands (nl) │
português (pt) │
русский (ru) │
slovenčina (sk) │
中文(中国大陆) (zh_CN) │
Überblick
Die IDE verwendet eine Bibliothek von pascal source parsing and editing tools, genannt die "CodeTools". Diese Werkzeuge bieten Features wie find declaration, Codevervollständigung, extraction, moving inserting und beautifying pascal sources. Diese Funktionen sparen ihnen eine Menge Zeit und doppelte Arbeit. Sie sind anpassbar und jedes Feature ist verfügbar mittels Tastenkombinationen (siehe Editoreinstellungen).
Weil sie ausschließlich an den Quellen arbeiten und FPC, Delphi und Kylix Code verstehen, benötigen sie keine kompilierten Units oder einen installierten Borland Compiler. Sie können Delphi und FPC Code zur selben Zeit bearbeiten. Sie können sogar mit verschiedenen Delphi und FPC Versionen zur selben Zeit arbeiten. Dies macht die Portierung von Delphi Code sehr viel einfacher.
Übersichtstabelle der IDE Tastenkombinationen
Declaration Jumping | Ctrl+Click (springt zur Deklaration eines type oder Variablen) |
Method Jumping | Ctrl+Shift+Up (schaltet zwischen Definition und Rumpf um) |
Code-Schablonen | Ctrl+J |
Codevervollständigung (Class Completion) | Ctrl+Shift+C |
Bezeichnervervollständigung | Ctrl+Space |
Word Completion | Ctrl+W |
Method Jumping
Um zwischen einem Prozedurrumpf (begin..end) und der Prozedurendefinition (procedure Name;) zu springen verwenden sie Ctrl+Shift+Up.
Zum Beispiel:
interface procedure DoSomething; // Prozedurendefinition implementation procedure DoSomething; // Prozedurrumpf begin end;
Wenn der Cursor auf dem Prozedurrumpf ist und sie Ctrl+Shift+Up drücken, dann wird der Cursor zur Definition springen. Erneutes Drücken von Ctrl+Shift+Up wird wieder zum Rumpf springen, nach 'begin'.
Dies funktioniert ebenfalls zwischen Methoden (Prozeduren in Klassen).
Hinweise: 'Method Jumping' springt zur selben Prozedur mit dem selben Namen und Parameterliste. Wenn es keine bestimmte Prozedur gibt, springt es zum besten Kandidaten und positioniert den Cursor auf dem ersten Unterschied. (Für Delphianer: Delphi kann dies nicht tun).
Zum Beispiel eine Prozedur mit verschiedenen Parametertypen:
interface procedure DoSomething(p: char); // Prozedurdefinition implementation procedure DoSomething(p: string); // Prozedurrumpf begin end;
Das Springen von der Definition zum Rumpf wird den Cursor auf dem 'string' Schlüsselwort positionieren. Dies kann verwendet werden für das Umbenennen von Methoden und/oder dem Ändern von Parametern.
Zum Beispiel:
Sie benannten 'DoSomething' in 'MakeIt' um:
interface procedure MakeIt; // Prozedurdefinition implementation procedure DoSomething; // Prozedurrumpf begin end;
Dann springen sie von MakeIt zum Rumpf. Die IDE sucht nach einem passenden Rumpf, findet keinen, und sucht daher nach einem Kandidaten. Weil sie nur die Prozedur umbenannt haben gibt es exakt einen Rumpf ohne Definition (DoSomething) und daher wird sie zu DoSomething springen und den Cursor rechts neben 'DoSomething' positionieren. Dann können sie es dort auch unbenennen. Das funktioniert für Parameter ebenfalls.
Include Dateien
Include Dateien sind Dateien, die mit der ($I filename) oder ($INCLUDE filename) Compiler Direktive in die Quellen eingefügt werden. Lazarus und FPC verwenden eine Menge von diesen Dingen um Redundanz zu reduzieren und unlesbare ($IFDEF) Konstrukte zu vermeiden um verschiedene Plattformen zu unterstützen.
Im Gegensatz zu Delphi bietet die Lazarus IDE volle Unterstützung für include Dateien. Sie können zum Beispiel von der Methode in der .pas Datei zum Methodenrumpf in der include Datei springen. Alle CodeTools wie Codevervollständigung berücksichtigen Include Dateien als spezielle Schranken.
Zum Beispiel: Wenn Codevervollständigung einen neuen Methodenrumpf hinzufügt hinter anderen Methodenrümpfen, behält es beide in der selben Datei. Auf diese Weise können sie ganze Klassenimplementierungen in Include Dateien verwenden, wie es die LCL für nahezu alle Bedienelemente tut.
Aber es gibt eine Anfängerfalle: Wenn sie eine include Datei zum ersten mal öffnen und method jumping oder find declaration ausprobieren, erhalten sie eine Fehlermeldung. Die IDE weiß nicht, zu welcher Unit die include Datei gehört. Sie müssen die Unit zuerst öffnen.
Sobald die IDE die Unit analysiert, wird sie die Include-Direktive dort analysieren und die IDE wird sich an diese Beziehung erinnern. Sie wird diese Informationen beim Beenden speichern und on project save to ~/.lazarus/includelinks.xml. Wenn sie das nächste Mal diese Include-Datei öffnen und jump or do a find declaration, the IDE will internally open the unit and the jump will work.
Dieser Mechanismus hat natürlich Grenzen. Einige Include-Dateien sind zweimal oder mehrfach einbezogen. Zum Beispiel: lcl/include/winapih.inc.
Das Springen von den Prozedur-/Methodendefinitionen in diese Include-Datei zu den Rümpfen hängt von ihren letzten Aktionen ab. Wenn sie an lcl/lclintf.pp gearbeitet haben dann wird die IDE zu winapi.inc springen. Wenn sie an lcl/interfacebase.pp gearbeitet haben, dann wird sie zu lcl/include/interfacebase.inc springen (oder einer der anderen Include-Dateien). Wenn sie an beiden arbeiten, dann können sie verwirrt werden. ;)
Code-Schablonen
Code-Schablonen konvertieren einen Bezeichner in einen Text oder Code-Fragment.
Die Code-Schablonen Vorgabetastenkombination ist Ctrl+J. Sie können einen Bezeichner eintippen, Ctrl+J drücken und der Bezeichner wird durch den Text ersetzt, der für den Bezeichner definiert ist. Code-Schablonen können definiert werden in Einstellungen -> Code-Schablonen.
Beispiel: Schreiben sie den Bezeichner 'classf', hinterlassen den Cursor rechts hinter dem 'f' und drücken Ctrl+J. Das 'classf' wird ersetzt durch
T = class(T) private public constructor Create; destructor Destroy; override; end;
und der Cursor ist hinter dem 'T'. Sie können die Liste der Vorlagen abrufen in dem sie den Cursor an eine freie Stelle positionieren (nicht auf einem Bezeichner) und Ctrl+J drücken. Die Liste der Code-Schablonen wird auftauchen. Verwenden sie die Cursortasten oder tippen einige Buchstaben um eine auszuwählen. Return erzeugt die gewählte Vorlage und Escape schließt das pop up.
Codevervollständigung
Codevervollständigung ist zu finden im IDE Menü Bearbeiten -> Quelltext vervollständigen und hat als standard short cut Ctrl+Shift+C.
Für Delphianer: Delphi bezeichnet mit Codevervollständigung die Funktion, welche die Liste der Bezeichner an der aktuellen Quellenposition zeigt (Ctrl+Space). Unter Lazarus wird dies Bezeichnervervollständigung genannt.
Codevervollständigung kombiniert verschiedene mächtige Funktionen. Beispiele:
- Class Completion: komplettiert Eigenschaften, fügt Methodenrümpfe hinzu, add private variables and private access methods
- Forward Procedure Completion: fügt Prozedurenrümpfe hinzu
- Event Assignment Completion: completes event assignments and adds method definition and body
- Variable Declaration Completion: fügt lokale Variablendefinitionen hinzu
Welche Funktion genutzt wird, hängt von der Cursorposition im Editor ab.
Class Completion
Das mächtigste Codevervollständigung Feature ist Class Completion. Sie schreiben eine Klasse, fügen die Methoden und Eigenschaften hinzu und Codevervollständigung wird die Methodenrümpfe hinzufügen, die Eigenschaftszugriff Methoden/Variablen und die private Variablen.
Zum Beispiel: Erzeugen sie eine Klasse (siehe Code-Schablonen um einige Tipparbeit zu sparen):
TExample = class(TObject) public constructor Create; destructor Destroy; override; end;
Positionieren sie den Cursor irgendwo in der Klasse und drücken Ctrl+Shift+C. Dies wird die fehlenden Methodenrümpfe erzeugen und den Cursor zu dem ersten erzeugten Methodenrumpf bewegen, so daß sie jetzt mit dem Schreiben des class Codes beginnen können:
{ TExample } constructor TExample.Create; begin | end; destructor TExample.Destroy; begin inherited Destroy; end;
Anmerkung: Das '|' ist der Cursor und nicht hinzugefügt.
Hinweis: Sie können zwischen einer Methode und ihrem Rumpf springen mit Ctrl+Shift+Up.
Sie können sehen, daß die IDE auch den 'inherited Destroy' Aufruf hinzugefügt hat. Dies wird getan, wenn es ein 'override' Schlüsselwort in der class Definition gibt.
Jetzt fügen sie eine Methode DoSomething hinzu:
TExample = class(TObject) public constructor Create; procedure DoSomething(i: integer); destructor Destroy; override; end;
Dann drücken sie Ctrl+Shift+C und die IDE wird hinzufügen
procedure TExample.DoSomething(i: integer); begin | end;
Sie können sehen, daß der neue Methodenrumpf eingefügt wurde zwischen Create und Destroy, exakt wie in der class Definition. This way the bodies keep the same logical ordering as you define. You can define the insertion policy in Einstellungen -> Codetools Einstellungen -> Quelltexterzeugung.
Complete Properties
Fügen sie eine Eigenschaft AnInteger hinzu:
TExample = class(TObject) public constructor Create; procedure DoSomething(i: integer); destructor Destroy; override; property AnInteger: Integer; end;
Drücken sie Ctrl+Shift+C und sie werden erhalten:
procedure TExample.SetAnInteger(const AValue: integer); begin |if FAnInteger=AValue then exit; FAnInteger:=AValue; end;
Die Codevervollständigung hat added a Write access modifier and added some common code. Jump to the class with Ctrl+Shift+Up um die neue class zu sehen:
TExample = class(TObject) private FAnInteger: integer; procedure SetAnInteger(const AValue: integer); public constructor Create; procedure DoSomething(i: integer); destructor Destroy; override; property AnInteger: integer read FAnInteger write SetAnInteger; end;
The property was extended by a Read and Write access modifier. The class got the new section 'private' with a Variable 'FAnInteger' and the method 'SetAnInteger'. It is a common Delphi style rule to prepend private variables with an 'F' and the write method with a 'Set'. Wenn sie das nicht mögen, dann können sie es ändern unter Einstellungen -> Codetools Einstellungen -> Quelltexterzeugung.
Creating a read only property:
property PropName: PropType read;
Wird erweitert zu
property PropName: PropType read FPropName;
Creating a write only property:
property PropName: PropType write;
Wird erweitert zu
property PropName: PropType write SetPropName;
Creating a read only property with a Read method:
property PropName: PropType read GetPropName;
Will be kept and a GetPropName function will be added:
function GetpropName: PropType;
Creating a property with a stored modifier:
property PropName: PropType stored;
Wird erweitert zu
property PropName: PropType read FPropName write SetPropName stored PropNameIsStored;
Because stored is used for streaming read and write modifiers are automatically added as well.
Hinweis: Bezeichnervervollständigung also recognizes incomplete properties and will suggest the default names. Zum Beispiel:
property PropName: PropType read |;
Platzieren sie den Cursor eine Leerstelle hinter dem 'read' Schlüsselwort und drücken Ctrl+Space für die Bezeichnervervollständigung. It will present you the variable 'FPropName' and the procedure 'SetPropName'.
Forward Procedure Completion
Forward Procedure Completion ist ein Teil der Codevervollständigung und fügt fehlende Prozedurrümpfe hinzu. Es wird aufgerufen, wenn der Cursor auf einer vorwärts definierten Prozedur ist.
Zum Beispiel: Fügen sie eine neue Prozedur zum interface Abschnitt hinzu:
procedure DoSomething;
Platzieren sie den Cursor darauf und drücken Ctrl+Shift+C für Codevervollständigung. Es wird im implementation Abschnitt erzeugen:
procedure DoSomething; begin | end;
Hinweis: Sie können zwischen einer Prozedurdefinition und ihrem Rumpf springen mit Ctrl+Shift+Up.
Der neue Prozedurrumpf wird vor den class Methoden eingefügt. Wenn es bereits einige Prozeduren im Interface Abschnitt gibt, versucht die IDE die Ordnung einzuhalten. Zum Beispiel:
procedure Proc1; procedure Proc2; // neue Prozedur procedure Proc3;
Wenn die Rümpfe von Proc1 und Proc3 bereits existieren, dann wird der Proc2 Rumpf zwischen den Rümpfen von Proc1 und Proc3 eingefügt. Dieses Verhalten kann eingestellt werden in Einstellungen -> CodeTools Einstellungen -> Quelltexterzeugung.
Mehrere Prozeduren:
procedure Proc1_Old; // Rumpf existiert procedure Proc2_New; // Rumpf existiert nicht procedure Proc3_New; // " procedure Proc4_New; // " procedure Proc5_Old; // Rumpf existiert
Code Completion wird alle 3 Prozedurrümpfe hinzufügen (Proc2_New, Proc3_New, Proc4_New).
Warum wird es Forward Procedure Completion genannt?
Weil es nicht nur für Prozeduren funktioniert, die im interface definiert sind, sondern auch für Prozeduren mit dem "forward" Bezeichner.
Event Assignment Completion
Event Assignment Completion ist ein Teil der Codevervollständigung und komplettiert eine einzelne Ereignis:=| Anweisung. Es wird aufgerufen, wenn der Cursor hinter an assignment to einem Ereignis ist.
Zum Beispiel: In einer Methode, sagen wir dem FormCreate Ereignis, fügen wir eine Zeile 'OnPaint:=' hinzu:
procedure TForm1.Form1Create(Sender: TObject); begin OnPaint:=| end;
Das '|' ist der Cursor und sollte nicht eingegeben werden. Dann drücken sie Ctrl+Shift+C für die Codevervollständigung. Die Anweisung wird komplettiert zu
OnPaint:=@Form1Paint;
Eine neue Methode Form1Paint wird zur TForm1 class hinzugefügt. Dann wird class completion gestartet und sie erhalten:
procedure TForm1.Form1Paint(Sender: TObject); begin | end;
Das funktioniert wie das Hinzufügen von Methoden im Objektinspektor.
Anmerkung:
Sie müssen den Cursor hinter dem ':=' assignment operator platzieren. Wenn sie den Cursor auf dem Bezeichner platzieren (z.B. OnPaint) wird Codevervollständigung "Local Variable Completion" aufrufen, welches fehlschlägt, weil OnPaint bereits definiert ist.
Hinweis:
Sie können den neuen Methodennamen selbst definieren. Zum Beispiel:
OnPaint:=@ThePaintMethod;
Variable Declaration Completion
Variable Declaration Completion ist ein Teil der Codevervollständigung und fügt eine lokale Variablendefinition zu einer Identifier:=Term; Anweisung hinzu. Sie wird aufgerufen, wenn der Cursor auf dem Bezeichner auf einer Zuweisung oder einem Parameter ist.
Zum Beispiel:
procedure TForm1.Form1Create(Sender: TObject); begin i:=3; end;
Platzieren sie den Cursor auf dem 'i' oder genau dahinter. Dann drücken sie Ctrl+Shift+C für die Codevervollständigung und sie werden erhalten:
procedure TForm1.Form1Create(Sender: TObject); var i: Integer; begin i:=3; end;
Die CodeTools prüfen zuerst, ob der Bezeichner 'i' bereits definiert ist und wenn nicht werden sie die Deklaration 'var i: integer;' hinzufügen. Der Typ des Bezeichners wird erraten vom Ausdruck rechts des Abgrenzungs ':=' Operators. Zahlen wie die 3 sind mit Integer vorbelegt.
Ein anderes Beispiel: type
TWhere = (Behind, Middle, InFront); procedure TForm1.Form1Create(Sender: TObject); var a: array[TWhere] of char; begin for Where:=Low(a) to High(a) do writeln(a[Where]); end;
Platzieren sie den Cursor auf 'Where' und drücken Ctrl+Shift+C für die Codevervollständigung. Sie erhalten:
procedure TForm1.Form1Create(Sender: TObject); var a: array[TWhere] of char; Where: TWhere; begin for Where:=Low(a) to High(a) do writeln(a[Where]); end;
Seit Version 0.9.11 komplettiert Lazarus auch Parameter. Zum Beispiel
procedure TForm1.FormPaint(Sender: TObject); begin with Canvas do begin Line(x1,y1,x2,y2); end; end;
Platzieren sie den Cursor auf 'x1' und drücken Ctrl+Shift+C für die Codevervollständigung. Sie erhalten:
procedure TForm1.FormPaint(Sender: TObject); var x1: integer; begin with Canvas do begin Line(x1,y1,x2,y2); end; end;
Kommentare und Codevervollständigung
Codevervollständigung versucht die Kommentare dort zu behalten, wo sie hingehören. Zum Beispiel:
FList: TList; // list of TComponent FInt: integer;
Wenn eine neue Variable zwischen FList und FInt eingesetzt wird, dann wird der Kommentar in der FList Zeile beibehalten. Das selbe gilt für
FList: TList; { list of TComponent Dies ist ein Kommentar über mehrere Zeilen, starting in the FList line, so codetools assumes it belongs to the FLIst line and will not break this relationship. Code is inserted behind the comment. } FInt: integer;
Wenn der Kommentar in der nächsten Zeile startet:
FList: TList; // list of TComponent { This comment belongs to the statement below. New code is inserted above this comment and behind the comment of the FList line. } FInt: integer;
Refactoring
Invert Assignments
- Kurz gefasst
- : "Invert Assignments" takes some selected pascal statements and inverts all assignments from this code. Dieses Werkzeug ist hilfreich für das Umwandeln a "save" code to a "load" one and inverse operation.
Beispiel:
procedure DoSomething; begin AValueStudio:= BValueStudio; AValueAppartment :=BValueAppartment; AValueHouse:=BValueHouse; end;
Select the lines with assignments (zwischen begin und end) and do Invert Assignments. All assignments will be inverted and identation will be add automatically. Zum Beispiel:
Resultat:
procedure DoSomething; begin BValueStudio := AValueStudio; BValueAppartment := AValueAppartment; BValueHouse := AValueHouse; end;
Extract Procedure
- Kurz gefasst
- : "Extract Procedure" nimmt die ausgewählten Pascal Anweisungen und erstellt eine neue Prozedur/Methode aus diesem Code. Dieses Werkzeug ist hilfreich um große Prozeduren aufzusplitten oder um eine neue Prozedur einfach aus dem Code zu erstellen.
Ein einfaches Beispiel:
procedure DoSomething; begin CallSomething; end;
Markieren sie die Zeile "CallSomething;" und führen Extract Proc aus. Ein Dialog taucht auf und sie können den Typ und Namen der zu erstellenden Prozedur wählen. Zum Beispiel: procedure, "NewProc". Result:
procedure NewProc; begin CallSomething; end; procedure DoSomething; begin NewProc; end;
Sie können sehen, daß die neue Prozedur "NewProc" erzeugt wurde mit the selection as body und der alte Code durch einen Aufruf ersetzt wurde.
Lokale Variablen und Parameter:
"Extract Proc" scans for used variables and automatically creates the
parameter list and local variables. Example:
procedure TForm1.DoSomething(var Erni, Bert: integer); var i: Integer; // Comment begin Erni:=Erni+Bert; for i:=Erni to 5 do begin | end; end;
Select the for loop and create a new Procedure "NewProc". The local variable i is only used in the selection, so it will be moved to the new procedure. Erni is also used in the remaining code, so it will become a parameter.
Result:
procedure NewProc(const Erni: integer); var i: Integer; // Comment begin for i:=Erni to 5 do begin | end; end; procedure TForm1.DoSomething(var Erni, Bert: integer); begin Erni:=Erni+Bert; NewProc(Erni); end;
You can see "i" was moved to the new procedure (Note: including its comment) and Erni.
Limitations:
Pascal ist eine sehr mächtige Sprache. Erwarten sie daher nicht, daß es mit jedem Code funktioniert. Aktuelle Limits/ToDos:
- check if selection bounds on statement bounds
- "with" statements
Find Declaration
Positionieren sie den Cursor auf einem Bezeichner und starten Find Declaration. Das wird die Deklaration dieses Bezeichners suchen, die Datei öffnen und zu ihr springen.
Jede find declaration setzt einen Sprungpunkt. Das bedeutet, sie springen mit find declaration zur Deklaration und einfach zurück mit Suche -> Zurückspringen.
Es gibt einige Unterschiede zu Delphi: Die CodeTools arbeiten mit den Quellen, den normalen Pascal Regeln folgend, anstelle der Verwendung des Compiler output. Der Compiler liefert den finalen Typ zurück. Die CodeTools sehen die Quellen und alle Schritte dazwischen. Zum Beispiel:
Die 'Visible' Eigenschaft wird zuerst in TControl (controls.pp) definiert, dann neu definiert in TCustomForm und letztlich in TForm neu definiert. Das Aufrufen von find declaration auf Visible wird sie zuerst zu Visible in TForm bringen. Dann können sie Find Declaration erneut aufrufen um zu Visible in TCustomForm zu springen und erneut um zu Visible in TControl zu springen.
Das selbe gilt für Typen wie TColor. Für den Compiler ist es einfach ein 'longint'. Aber in den Quellen ist es definiert als
TGraphicsColor = -$7FFFFFFF-1..$7FFFFFFF; TColor = TGraphicsColor;
Und das selbe für forward defined classes: Zum Beispiel gibt es in TControl eine private Variable
FHostDockSite: TWinControl;
Find declaration auf TWinControl springt zur forward definition
TWinControl = class;
Und ein erneuter Aufruf springt zur realen Implementierung
TWinControl = class(TControl)
Auf diese Weise können sie jeden Bezeichner aufspüren und jeden overload finden.
Goto Include Directive
"Zu Include Direktive springen" im Suche Menü der IDE springt zur {$I filename} Anweisung, wo die aktuelle include Datei verwendet wird.
Projekt veröffentlichen
Erzeugt eine Kopie des gesamten Projekts. Wenn sie jemandem einfach die Quellen und Kompilereinstellungen ihres Codes senden wollen, dann ist dies Funktion ihr Freund.
Ein normales Projektverzeichnis enthält eine Menge an Informationen. Das meiste davon wird für eine Veröffentlichung nicht benötigt: Die .lpi Datei enthält Sessioninformationen (wie Cursorposition und Lesezeichen geschlossener Units) und das Projektverzeichnis enthält eine Menge von .ppu und .o Dateien und das executable. Um eine .lpi Datei zu erzeugen nur mit den Basisinformationen und nur den Quellen, zusammen mit allen Unterverteichnissen verwenden sie "Projekt veröffentlichen".
Anmerkung: Seit Version 0.9.13 gibt es eine neue Projekteinstellung die ihnen erlaubt, Sessioninformationen in einer anderen Datei als der normalen .lpi Datei zu speichern. Diese neue Datei endet mit der .lps Erweiterung und enthält nur Sessioninformationen, was die .lpi Datei viel übersichtlicher macht.
In dem Dialog können sie den exclude und include Filter einstellen, und mit dem Kommando danach können sie den Output in ein Archiv komprimieren.
Ursprüngliche Mitwirkende
Diese Seite wurde von der epikwiki Version konvertiert.
- Seite und anfängliche Vorlage erstellt - 4/6/2004 VlxAdmin
- Anfangsinhalt eingestellt - 4/10/2004 MattiasG
- Kleine Wiki- und Formatierungs-Berichtigungen - 4/11/2004 VlxAdmin
- Ergebnistabelle für IDETools shortcuts hinzugefügt - 12 July 2004 User:Kirkpatc