Lazarus IDE Tools/de

From Lazarus wiki
Revision as of 22:36, 6 January 2007 by Swen (talk | contribs)
Jump to navigationJump to search

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
Parameter Hinweise Ctrl+Shift+Space

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 ebenfalls für Parameter.

Include Dateien

Include Dateien sind Dateien, die mit der ($I Dateiname) oder ($INCLUDE Dateiname) 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 diese Include-Datei das nächste Mal öffnen und eine find declaration durchführen, wird die IDE die Unit intern öffnen und das Springen wird funktionieren.

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.

Parameter Hinweise

Parameter Hinweise zeigen eine Hinweisbox mit den Parameter-Deklarationen für die aktuelle Parameterliste.

Zum Beispiel

 Canvas.FillRect(|);

Platzieren sie den Cursor in den Klammern und drücken Ctrl+Shift+Space. Eine Hinweisbox erscheint mit den Parametern von FillRect.

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 sowie private Variablen und private Zugriffsmethoden
  • 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
  • Reversed class completion: fügt Methoden-Deklarationen für Methodenrümpfe 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. Die Klasse erhielt den neuen Abschnitt 'private' mit einer Variable 'FAnInteger' und der Methode '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. Es wird ihnen die Variable 'FPropName' und die Prozedur 'SetPropName' präsentieren.

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;

Reversed Class Completion

"Reversed Class Completion" ist ein Teil der Codevervollständigung and adds a private method declaration for the current method body. It is invoked, when the cursor is in a method body, not yet defined in the class. Dieses Feature ist seit Lazarus 0.9.21 verfügbar.

Zum Beispiel:

 procedure TForm1.DoSomething(Sender: TObject);
 begin
 end;

Die Methode DoSomething ist noch nicht in TForm1 deklariert. Drücken sie Ctrl+Shift+C und die IDE wird "procedure DoSomething(Sender: TObject);" zu den privaten Methoden von TForm1 hinzufügen.

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 eines "save" Code in einen "load" Code und umgekehrt.

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;

Prozedur extrahieren

Kurz gefasst
: "Prozedur extrahieren" 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 'Prozedur extrahieren' 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 der Auswahl als Rumpf, und der alte Code durch einen Aufruf ersetzt wurde.

Lokale Variablen und Parameter:
"Prozedur extrahieren" scannt nach verwendeten Variablen und erzeugt automatisch die Parameterliste und die lokalen Variablen. Beispiel:

procedure TForm1.DoSomething(var Erni, Bert: integer);
var
  i: Integer; // Kommentar
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.

Einschränkungen:
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