Difference between revisions of "Extending the IDE/de"

From Lazarus wiki
Jump to navigationJump to search
Line 375: Line 375:
 
end;
 
end;
 
</Delphi>
 
</Delphi>
 +
 +
Für weitere Makros siehe: [[IDE Macros in paths and filenames]].
  
 
== Der Name der ausführbaren Ziel-Datei eines Projekts ==
 
== Der Name der ausführbaren Ziel-Datei eines Projekts ==

Revision as of 23:35, 26 January 2011

Deutsch (de) English (en) español (es) français (fr) 日本語 (ja) русский (ru) slovenčina (sk) 中文(中国大陆)‎ (zh_CN)

Erweitern der IDE

Überblick

Die IDE unterstützt verschiedene Erweiterungen:

Komponenten
Komponenten werden in der Palette installiert. Z.B. TButton erzeugt Buttons.
Komponenten-Editoren
Komponenteneditoren werden benutzt, wenn Sie auf eine Komponente im Designer doppelklicken oder um einige extra Items im Popupmenü des Designers hinzuzufügen, indem man auf eine Komponente rechtsklickt.
Eigenschafts-Editoren
Stellen die Editierfähigkeiten im Objektinspektor zur Verfügung.
Experten
Das sind alle anderen Typen von Editoren. Sie registrieren neue Menüpunkte, Tatenkürzel oder erweitern andere Merkmale der IDE.


Es gibt 2 Möglichkeiten, Ihre eigenen Plugins in Lazarus zu integrieren:

  1. Erstellen Sie ein Package, installieren Sie es und registrieren Sie das Plugin mit der Prozedur 'Register' in einer Unit.
  2. Erweitern Sie den Lazarus Code und senden Sie Ihr SVN diff an die Lazarus-Mailing-Liste.

Menüpunkte

Sie können neue Menüpunkte anfügen, bestehende Menüpunkte verstecken oder verschieben und Untermenüs oder Abschnitte hinzufügen. Für Ihre eigenen Formulare können Sie das TMainMenu/TPopupMenu registrieren, sodass andere Packages darauf zugreifen und Ihr Formular erweitern können. Die Unit MenuIntf des IDEIntf-Packages enthält die gesamte Registrierung für Menüs und viele Standard-Menüpunkte der IDE selbst.

Einen Menüpunkt hinzufügen

Ein einzelner Menüpunkt wie 'View Object Inspector' wird TIDEMenuCommand genannt. Sie können einen erzeugen mit dem Befehl RegisterIDEMenuCommand, der in zwei Formen mit Unmengen von Parametern vorkommen kann:

<Delphi>function RegisterIDEMenuCommand(Parent: TIDEMenuSection;

                               const Name, Caption: string;
                               const OnClickMethod: TNotifyEvent = nil;
                               const OnClickProc: TNotifyProcedure = nil;
                               const Command: TIDECommand = nil;
                               const ResourceName: String = 
                               ): TIDEMenuCommand; overload;

function RegisterIDEMenuCommand(const Path, Name, Caption: string;

                               const OnClickMethod: TNotifyEvent = nil;
                               const OnClickProc: TNotifyProcedure = nil;
                               const Command: TIDECommand = nil;
                               const ResourceName: String = 
                               ): TIDEMenuCommand; overload;</Delphi>

Der Unterschied zwischen diesen beiden Formen liegt nur darin, wie Sie die 'parent menu section' angeben. Geben Sie diesen Menüabschnitt direkt an oder oder indirekt mittels eines Pfades. Viele Standardmenüs finden Sie in der Unit MenuIntf. Zum Beispiel den Abschnitt mnuTools, der das Menü Tools aus dem IDE-Hauptmenü liefert. Es enthält einen Abschnitt itmSecondaryTools, das ist der empfohlene Abschnitt für "Third party tools".

Das folgende Beispiel registriert einen neuen Menübefehl mit dem Namen 'MyTool', der Beschriftung 'Start my tool' und führt beim Klicken die Prozedur StartMyTool aus: <Delphi>procedure StartMyTool; begin

 ...wird ausgeführt, wenn der Menüpunkt angeklickt wird...

end;

procedure Register; begin

 RegisterIDEMenuCommand(itmSecondaryTools, 'MyTool','Start my tool',nil,@StartMyTool);

end;</Delphi>

Falls Sie statt der Prozedur eine Methode aufrufen wollen, dann verwenden Sie den OnClickMethod Parameter.

Dieser Menüpunkt hat kein Tastenkürzel. Wenn Sie ein Tastenkürzel brauchen, dann erzeugen Sie einen TIDECommand und übergeben das Kürzel im Command Parameter. Zum Beispiel:

<Delphi>uses ... IDECommands, MenuIntf; ... var

 Key: TIDEShortCut;
 Cat: TIDECommandCategory;
 CmdMyTool: TIDECommand;

begin

 // register IDE shortcut and menu item
 Key := IDEShortCut(VK_UNKNOWN,[],VK_UNKNOWN,[]);
 Cat := IDECommandList.FindCategoryByName(CommandCategoryToolMenuName);
 CmdMyTool := RegisterIDECommand(Cat,'Start my tool', 'Starts my tool to do some stuff', Key, nil, @StartMyTool);
 RegisterIDEMenuCommand(itmSecondaryTools, 'MyTool', 'Start my tool', nil, nil, CmdMyTool);

end;</Delphi>

Konfigurationsdateien

Laden/Speichern von Einstellungen

Alle Konfigurationsdateien der IDE werden in einem einzigen Verzeichnis als xml-Dateien gespeichert. Auch Packages können dort ihre eigenen Dateien ablegen. Das primäre Konfigurationsverzeichnis kann ermittelt werden mit:

<Delphi>uses LazIDEIntf; ...

 Directory := LazarusIDE.GetPrimaryConfigPath;</Delphi>

Packages erzeugen ihre eigenen xml-Dateien mit:

<Delphi>uses

 ..., LCLProc, BaseIDEIntf, LazConfigStorage;

const

 Version = 1;

var

 Config: TConfigStorage;
 SomeValue: String;
 SomeInteger: Integer;
 SomeBoolean: Boolean;
 FileVersion: LongInt;

begin

 SomeValue:='Default';
 SomeInteger:=3;
 SomeBoolean:=true;
 // speichere die Einstellungen
 try
   Config:=GetIDEConfigStorage('mysettings.xml',false);
   try
     // store the version number so future extensions can handle old config files
     Config.SetDeleteValue('Path/To/The/Version',Version,0);
     // store string variable "SomeValue"
     // if SomeValue has the default value the entry is not stored,
     // so only the differences to the default are stored.
     // This way the xml is kept short and defaults may change in future.
     Config.SetDeleteValue('Path/To/Some/Value',SomeValue,'Default');
     Config.SetDeleteValue('Path/To/Some/Integer',SomeInteger,3);
     Config.SetDeleteValue('Path/To/Some/Boolean',SomeBoolean,true);
     // there are more overloads for SetDeleteValue, find out with Ctrl+Space
   finally
     Config.Free;
   end;
 except
   on E: Exception do begin
     DebugLn(['Saving mysettings.xml failed: ',E.Message]);
   end;
 end;
 // lade die Einstellungen
 try
   Config:=GetIDEConfigStorage('mysettings.xml',true);
   try
     // read the version of the config
     FileVersion:=Config.GetValue('Path/To/The/Version',0);
     // read a string variable "SomeValue". If the entry does not exist, use
     // the Default
     SomeValue:=Config.GetValue('Path/To/Some/Value','Default');
     SomeInteger:=Config.GetValue('Path/To/Some/Integer',3);
     SomeBoolean:=Config.GetValue('Path/To/Some/Boolean',true);
   finally
     Config.Free;
   end;
 except
   on E: Exception do begin
     DebugLn(['Loading mysettings.xml failed: ',E.Message]);
   end;
 end;

end;</Delphi>

Komponenten

Komponenten schreiben

Sie können mit dem Lazarus Package-Editor eine neue, eigene Komponente erstellen. Sie erreichen den Editor über die Menüführung "Datei --> Neu --> Package, Standard Package". Es öffnet sich ein Fenster mit dem Datei- und Komponentenbaum Ihres Packages. Über die dort angezeigten Schaltflächen können Sie Ihr Package einrichten:

  • Speichern: Hier können Sie Ihre Komponente oder Ihr Package unter einen Namen Ihrer Wahl speichern.
  • Hinzufügen: Hier erscheint ein Fenster mit mehreren Tabs. Die wichtisten im Überblick: Im Tab Neue Datei können Sie zum Beispiel Units und Formulardateien für Ihr Projekt erstellen. Eine bereits vorhandene Unit können Sie im Reiter Neue Unit einbinden. Wenn Sie Ihre Komponente auf eine bereits existierende Komponente aufbauen wollen, können Sie diese im Tab Neue Komponente auswählen.
  • Einstellungen: In diesem Dialog können Sie neben der Beschreibung Ihrer Komponente und ihrer Versionierung auch den Package-Typ einstellen sowie Sprachregelungen treffen.
  • Installieren: Wenn Ihre Komponente fertig erstellt ist, können Sie sie über diesen Knopf in die IDE einbinden.
  • Compilereinstellungen: Hier lässt sich festlegen, mit welchen Optionen und Compiler-Argumenten Ihr Package kompiliert werden soll.

Hinweis: Detailierte Informationen zum Package-Editor finden Sie hier.

Beispiel: Eine von TButton abgeleitete Komponente erstellen:

  1. Öffnen Sie den Package-Editor wie oben geschrieben
  2. Klicken Sie auf "Hinzufügen --> Neue Komponente"
  3. Wählen Sie als Basisklasse "TButton", und füllen die Felder wie folgt aus: Neuer Klassenname: TMeinButton, Palettenseite: Misc, Unit Dateiname: meinbutton.pas (diese Datei wird erstellt), Unit Name: MeinButton
  4. Klicken Sie auf Ok - und schon können Sie in der Unit meinbutton.pas den TButton an Ihre Bedürfnisse anpassen.

Einer neuen Komponente ein Icon für die Komponentenpalette geben

Zum Beispiel wollen wir TMyButton ein Icon geben. Erzeugen sie eine Bilddatei im Format .bmp, .xpm oder .png mit dem selben Namen wie die Komponentenklasse, z.B. tmybutton.png und speichern sie diese im Package-Quelltextverzeichnis. Das Bild kann mit einem beliebigen Grafikprogramm (z.B. Gimp) erzeugt werden und sollte nicht größer sein als 24x24 Pixel. Konvertieren Sie das Bild in eine .lrs Datei mit dem 'lazres' Werkzeug, das Sie im Verzeichnis 'lazarus/tools' finden:

 ~/lazarus/tools/lazres mybutton.lrs tmybutton.png

Das erzeugt eine Pascal Include Datei, die im Initialisierungs-Abschnitt von mybutton.pas verwendet wird:

 initialization
   {$I mybutton.lrs}

Installieren Sie das Package.

Eine Komponente aus der Palette verstecken

Package IDEIntf, unit componentreg:

IDEComponentPalette.FindComponent('TButton').Visible:=false;

Komponenten-Editoren schreiben

Ein Komponenten-Editor verarbeitet Dinge wie einen Doppelklick auf eine Komponente im Designer oder das Hinzufügen von Menüpunkten bei einem Rechtsklick auf eine Komponente. Einen Komponenten-Editor zu schreiben ist einfach. Siehe die Unit componenteditors.pas vom Package IDEIntf für zahlreiche Beispiele. Um beispielweise beim Doppelklick einen Editor anzuzeigen, siehe: TCheckListBoxComponentEditor.

Eigenschafts-Editoren schreiben

Jeder Eigenschaftstyp (integer, string, TFont, ...) im Objektinspektor benötigt einen Eigenschafts-Editor. Wenn Ihre Komponente eine Eigenschaft 'Password' vom Typ string hat, können Sie einen Eigenschafts-Editor definieren für Ihre besondere Komponenten-Klasse, mit genau diesem Typ. Die Unit propedits.pp aus dem Package IDEIntf enthält viele der Standard-Eigenschafts-Editoren, die von der IDE selbst verwendet werden. Zum Beispiel ist der TStringPropertyEditor der vorgegebene Editor für alle Strings, während TComponentNamePropertyEditor spezieller ist und nur TComponent.Name bearbeitet.

Designer

Einen Designer-Mediator schreiben

Der Standard-Designer erlaubt es, die Steuerelemente der LCL visuell zu bearbeiten, wo hingegen alle anderen nur als Symbole angezeigt werden. Um Steuerelemente (die nicht aus der LCL stammen) ebenfalls visuell bearbeiten zu können, sollten Sie einen Designer-Mediator erzeugen. Dieser kann dazu verwendet werden, Webseiten zu entwerfen, UML Diagramme oder andere Widgetsets wie fpGUI. Es gibt ein ausführliches Beispiel unter: in examples/designnonlcl/.

  • Installieren Sie das Beispielspackacke examples/designnonlcl/notlcldesigner.lpk und starten Sie die IDE neu. Dadurch werden der Designer-Mediator für TMyWidget-Komponenten registriert und die neuen Komponenten TMyButton, TMyGroupBox zur Komponentenpalette hinzugefügt.
  • Öffnen Sie das Beispielsprojekt examples/designnonlcl/project/NonLCL1.lpi.
  • Öffnen Sie die unit1.pas und zeigen Sie das Formular im Designer an (mit F12). Sie sollten jetzt die Komponenten als rote Rechtecke dargestellt sehen, die Sie genau so wie LCL-Steuerelemente auswählen, verschieben oder in der Größe verändern können.

Einen neuen einzigartigen Komponentennamen erzeugen

<Delphi> uses FormEditingIntf;

...

NewName:=FormEditingHook.CreateUniqueComponentName(AComponent);

// Or if you need to create the name before creating the component:

NewName:=FormEditingHook.CreateUniqueComponentName(ComponentClassName,OwnerComponent); // ComponentClassName will be used as prefix, without a leading T. // OwnerComponent is the new owner of the new component. </Delphi>

Eine Komponente im Designer/Objektinspektor auswählen

<Delphi>uses propedits; .. GlobalDesignHook.SelectOnlyThis(AComponent);</Delphi>

Ereignis-Handler

Es gibt einige Ereignisse in der IDE, für die Plugins ihre eigenen Handler hinzufügen können.

Designerereignisse

In propedits.pp gibt es ein "GlobalDesignHook" Objekt, das verschiedene Ereignisse zum Entwurf verwaltet. Jedes Ereignis ruft eine List von Handlern auf. Die Vorgabe-Handler werden von der IDE angefügt. Sie können eigene Handler mit den Methoden AddHandlerXXX und RemoveHandlerXXX anfügen. Diese werden aufgerufen vor den Vorgabe-Handlern.

Beispiele:

 Einfügen Ihres Handlers (das geschieht normalerweise im Konstruktor Ihres Objekts):
   GlobalDesignHook.AddHandlerComponentAdded(@YourOnComponentAdded);
Entfernen Ihrer Handlers: GlobalDesignHook.RemoveHandlerComponentAdded(@YourOnComponentAdded);
Sie können alle Handler auf einmal entfernen. Zum Beispiel, ist es eine gute Idee, diese Zeile im Destruktor des Objekts anzufügen: GlobalDesignHook.RemoveAllHandlersForObject(Self);

Die Handler von GlobalDesignHook:

 // lookup root
 ChangeLookupRoot
   Called when the "LookupRoot" changed.
   The "LookupRoot" is the owner object of the currently selected components.
   Normally this is a TForm.
// methods CreateMethod GetMethodName GetMethods MethodExists RenameMethod ShowMethod Called MethodFromAncestor ChainCall
// components GetComponent GetComponentName GetComponentNames GetRootClassName ComponentRenamed Called when a component was renamed ComponentAdded Called when a new component was added to the LookupRoot ComponentDeleting Called before a component is freed. DeleteComponent Called by the IDE to delete a component. GetSelectedComponents Get the current selection of components.
// persistent objects GetObject GetObjectName GetObjectNames
// modifing Modified Revert RefreshPropertyValues

Benachrichtigt werden, wenn ein Formular im Designer modifiziert wurde

Jedes LCL-Formular hat einen Designer des Typs TIDesigner. Die IDE erzeugt Designer der Type TComponentEditorDesigner, die in der IDEIntf Unit componenteditors definiert ist. Ein Beispiel:

<Delphi>procedure TYourAddOn.OnDesignerModified(Sender: TObject); var

 IDEDesigner: TComponentEditorDesigner;

begin

 IDEDesigner:=TComponentEditorDesigner(Sender);
 ...

end;

procedure TYourAddOn.ConnectDesignerForm(Form1: TCustomForm); var

 IDEDesigner: TComponentEditorDesigner;

begin

 IDEDesigner:=TComponentEditorDesigner(Form1.Designer);
 IDEDesigner.AddHandlerModified(@OnDesignerModified);

end;</Delphi>

Projektereignisse

Diese Ereignisse sind definiert in der Unit LazIDEIntf.


  • LazarusIDE.AddHandlerOnProjectClose: wird aufgerufen bevor ein Projekt geschlossen wird
  • LazarusIDE.AddHandlerOnProjectOpened: wird aufgerufen nachdem das Projekt vollständig geöffnet wurde (wenn beispielsweise alle erforderlichen Packages geladen und die Units im Quelltext-Editor geöffnet wurden)
  • LazarusIDE.AddHandlerOnSavingAll: wird aufgerufen bevor die IDE alles speichert
  • LazarusIDE.AddHandlerOnSavedAll: wird aufgerufen nachdem die IDE alles gespeichert hat
  • LazarusIDE.AddHandlerOnProjectBuilding: wird aufgerufen bevor die IDE das Projekt erstellt
  • LazarusIDE.AddHandlerOnProjectDependenciesCompiling: wird aufgerufen bevor die IDE die Packageabhängigkeiten eines Projekts kompiliert
  • LazarusIDE.AddHandlerOnProjectDependenciesCompiled: wird aufgerufen nachdem die IDE die Packageabhängigkeiten eines Projekts kompiliert hat

Andere IDE Ereignisse

  • LazarusIDE.AddHandlerOnIDERestoreWindows: wird aufgerufen, wenn die IDE ihre Fernster wiederherstellt (bevor das erste Projekt geöffnet wird)
  • LazarusIDE.AddHandlerOnIDEClose: wird aufgerufen, wenn die IDE beendet wird (nach closequery, also keine Interaktivität mehr)
  • LazarusIDE.AddHandlerOnQuickSyntaxCheck: wird aufgerufen, wenn der Menüpunkt oder das Tastenkürzel für die Schnelle Syntaxüberprüfung aussgeführt wird

Projekt

Aktuelles Projekt

Das aktuelle Hauptprojekt erhalten Sie mit LazarusIDE.ActiveProject. (unit LazIDEIntf)

Alle Units des aktuellen Projekts

Um alle Pascal-Units des aktuellen Hauptprojektes der IDE zu durchlaufen benutzen Sie zum Beispiel:

<Delphi> uses LCLProc, FileUtil, LazIDEIntf, ProjectIntf;

procedure ListProjectUnits; var

 LazProject: TLazProject;
 i: Integer;
 LazFile: TLazProjectFile;

begin

 LazProject:=LazarusIDE.ActiveProject;
 if LazProject<>nil then
   for i:=0 to LazProject.FileCount-1 do
   begin
     LazFile:=LazProject.Files[i];
     if LazFile.IsPartOfProject
     and FilenameIsPascalUnit(LazFile.Filename)
     then
       debugln(LazFile.Filename);
   end;

end; </Delphi>

Die .lpr, .lpi und .lps Datei eines Projekts

<Delphi> uses LCLProc, FileUtil, ProjectIntf, LazIDEIntf; var

 LazProject: TLazProject;

begin

 LazProject:=LazarusIDE.ActiveProject;
 // jedes Projekt hat eine .lpi Datei:
 DebugLn(['Project lpi file: ',LazProject.ProjectInfoFile]);
 // if the project session information is stored in a separate .lps file:
 if LazProject.SessionStorage<>pssNone then
   DebugLn(['Project lps file: ',LazProject.ProjectSessionFile]);
 // If the project has a .lpr file it is the main source file:
 if (LazProject.MainFile<>nil)
 and (CompareFileExt(LazProject.MainFile.Filename,'lpr')=0) then
   DebugLn(['Project has lpr file: ',LazProject.MainFile.Filename]);

end; </Delphi>

Für weitere Makros siehe: IDE Macros in paths and filenames.

Der Name der ausführbaren Ziel-Datei eines Projekts

Es gibt ein Makro $(TargetFile), das in Pfaden und externen Werkzeugen verwendet werden kann. Beispiel:

<Delphi> uses MacroIntf;

function MyGetProjectTargetFile: string; begin

 Result:='$(TargetFile)';
 if not IDEMacros.SubstituteMacros(Result) then
   raise Exception.Create('unable to retrieve target file of project');

end; </Delphi>

Add your own project type

todo

Add your own file type

Sie können Einträge hinzufügen zum 'Neu ...' Dialog:

  • See the unit ProjectIntf of the package IDEIntf.
  • Choose a base class TFileDescPascalUnit for normal units or TFileDescPascalUnitWithResource for a new form/datamodule.

Add a new file type

Dieses Beispiel entstammt der ide/mainintf.pas Datei und registriert eine einfache Textdatei:

<Delphi> uses ProjectIntf; ...

 { TFileDescText }
 TFileDescText = class(TProjectFileDescriptor)
 public
   constructor Create; override;
   function GetLocalizedName: string; override;
   function GetLocalizedDescription: string; override;
 end;

... { TFileDescText }

constructor TFileDescText.Create; begin

 inherited Create;
 Name:=FileDescNameText;
 DefaultFilename:='text.txt';
 AddToProject:=false;

end;

function TFileDescText.GetLocalizedName: string; begin

 Result:='Text';

end;

function TFileDescText.GetLocalizedDescription: string; begin

 Result:=lisNewDlgCreateANewEmptyTextFile;

end; </Delphi>

Add a new form type

This example is from the ide/mainintf.pas and registers the normal form:

<Delphi> uses ProjectIntf;

...

 TFileDescPascalUnitWithForm = class(TFileDescPascalUnitWithResource)
 public
   constructor Create; override;
   function GetInterfaceUsesSection: string; override;
   function GetLocalizedName: string; override;
   function GetLocalizedDescription: string; override;
 end;

...

{ TFileDescPascalUnitWithForm }

constructor TFileDescPascalUnitWithForm.Create; begin

 inherited Create;
 Name:=FileDescNameLCLForm;
 ResourceClass:=TForm;
 UseCreateFormStatements:=true;

end;

function TFileDescPascalUnitWithForm.GetInterfaceUsesSection: string; begin

 Result:='Classes, SysUtils, FileUtil, LResources, Forms, Controls, Graphics, Dialogs';

end;

function TFileDescPascalUnitWithForm.GetLocalizedName: string; begin

 Result:='Form';

end;

function TFileDescPascalUnitWithForm.GetLocalizedDescription: string; begin

 Result:=lisNewDlgCreateANewUnitWithALCLForm;

end; </Delphi>

CodeTools in der IDE

Before using the codetools you should commit the current changes of the source editor to the codetool buffers:

<Delphi> uses LazIDEIntf; ...

 // save changes in source editor to codetools
 LazarusIDE.SaveSourceEditorChangesToCodeCache(-1); // -1: commit all source editors

</Delphi>

Hinzufügen einer resource Direktive zu einer Datei

Dies fügt eine {$R example.res} Direktive zu einer Pascal Unit hinzu:

<Delphi> procedure AddResourceDirectiveToPascalSource(const Filename: string); var

 ExpandedFilename: String;
 CodeBuf: TCodeBuffer;

begin

 // make sure the filename is trimmed and contains a full path
 ExpandedFilename:=CleanAndExpandFilename(Filename);
 
 // save changes in source editor to codetools
 LazarusIDE.SaveSourceEditorChangesToCodeCache(-1);
 // die Datei laden
 CodeBuf:=CodeToolBoss.LoadFile(ExpandedFilename,true,false);
 // die resource Direktive hinzufügen
 if not CodeToolBoss.AddResourceDirective(CodeBuf,'example.res') then
   LazarusIDE.DoJumpToCodeToolBossError;

end; </Delphi>

The codetools provides also functions like FindResourceDirective and RemoveDirective.


 Adding your handler (this is normally done in the constructor of your object):
   GlobalDesignHook.AddHandlerComponentAdded(@YourOnComponentAdded);
Removing your handler: GlobalDesignHook.RemoveHandlerComponentAdded(@YourOnComponentAdded);
You can remove all handlers at once. For example, it is a good idea to add this line in the destructor of object: GlobalDesignHook.RemoveAllHandlersForObject(Self);

Die Handlers des GlobalDesignHook:

 // lookup root
 ChangeLookupRoot
   Called when the "LookupRoot" changed.
   The "LookupRoot" is the owner object of the currently selected components.
   Normally this is a TForm.
// Methoden CreateMethod GetMethodName GetMethods MethodExists RenameMethod ShowMethod Called MethodFromAncestor ChainCall
// Komponenten GetComponent GetComponentName GetComponentNames GetRootClassName ComponentRenamed Called when a component was renamed ComponentAdded Called when a new component was added to the LookupRoot ComponentDeleting Called before a component is freed. DeleteComponent Called by the IDE to delete a component. GetSelectedComponents Get the current selection of components.
// persistente Objekte GetObject GetObjectName GetObjectNames
// modifing Modified Revert RefreshPropertyValues

Hilfe

Hilfe für die Quellen hinzufügen

Erzeugen sie zuerst eine THelpDatabase: <delphi>

 HelpDB:=TFPDocHTMLHelpDatabase(
    HelpDatabases.CreateHelpDatabase('EinNameIhrerWahlFürDieDatenbank',
                                            TFPDocHTMLHelpDatabase,true));
 HelpDB.DefaultBaseURL:='http://ihre.hilfe.org/';
 FPDocNode:=THelpNode.CreateURL(HelpDB,
                  'Package1 - A new package',
                  'file://index.html');
 HelpDB.TOCNode:=THelpNode.Create(HelpDB,FPDocNode);// einmal als Inhaltsverzeichnis
 DirectoryItem:=THelpDBISourceDirectory.Create(FPDocNode,'$(PkgDir)/lcl',
                                 '*.pp;*.pas',false);// und einmal als normale Seite
 HelpDB.RegisterItem(DirectoryItem);

</delphi>

Zeilen zum Nachrichtenfenster hinzufügen

<Delphi> unit IDEMsgIntf; ... var Dir: String; begin

 Dir:=GetCurrentDir;
 IDEMessagesWindow.BeginBlock;
 IDEMessagesWindow.AddMsg('unit1.pas(30,4) Error: Identifier not found "a"',Dir,0);
 IDEMessagesWindow.EndBlock;

end; </Delphi>