unit TestExperte;
interface
uses
ToolsAPI,
Dialogs,
...
;
type
TTestExperte =
class(TNotifierObject, IOTAWIzard, IOTAKeyboardBinding)
protected
// Tastaturshortcut zuordnen
function GetBindingType: TBindingType;
procedure BindKeyboard(
const BindingServices: IOTAKeyBindingServices);
// Auf Tastenkombination Alt + F1 reagieren.
procedure AltF1(
const Context: IOTAKeyContext; KeyCode: TShortCut;
var BindingResult: TKeyBindingResult);
// Text von der aktuellen Cursorposition holen
function GetTopBufferText :
String;
public
constructor Create;
procedure Execute;
...
end;
Var
MainServices : INTAServices;
ActionServices : IOTAActionServices;
CodeInsideServices : IOTACodeInsightServices;
DebuggerServices : IOTADebuggerServices;
EditorServices : IOTAEditorServices;
KeyBindingServices : IOTAKeyBindingServices;
KeyboardDiagnostics : IOTAKeyboardDiagnostics;
KeyboardServices : IOTAKeyboardServices;
MessageServices : IOTAMessageServices;
ModuleServices : IOTAModuleServices;
PackageServices : IOTAPackageServices;
Services : IOTAServices;
WizardServices : IOTAWizardServices;
procedure Register;
implementation
uses
TypInfo,
...
;
procedure Register;
var
KS: IOTAKeyboardServices;
begin
RegisterPackageWizard(TTestExperte.create
as IOTAWizard);
if Supports(BorlandIDEServices, IOTAKeyBoardServices, KS)
then begin
KS.AddKeyboardBinding(TTestExperte.Create);
end;
end;
procedure InitExpert;
begin
MainServices := (BorlandIDEServices
as INTAServices);
ActionServices := (BorlandIDEServices
as IOTAActionServices);
CodeInsideServices := (BorlandIDEServices
as IOTACodeInsightServices);
DebuggerServices := (BorlandIDEServices
as IOTADebuggerServices);
EditorServices := (BorlandIDEServices
as IOTAEditorServices);
KeyBindingServices := (BorlandIDEServices
as IOTAKeyBindingServices);
KeyboardDiagnostics := (BorlandIDEServices
as IOTAKeyboardDiagnostics);
KeyboardServices := (BorlandIDEServices
as IOTAKeyboardServices);
MessageServices := (BorlandIDEServices
as IOTAMessageServices);
ModuleServices := (BorlandIDEServices
as IOTAModuleServices);
PackageServices := (BorlandIDEServices
as IOTAPackageServices);
Services := (BorlandIDEServices
as IOTAServices);
WizardServices := (BorlandIDEServices
as IOTAWizardServices);
end;
{ Die Prozedur räumt beim Beenden des Experten auf }
procedure DoneExpert;
begin
(BorlandIDEServices
as IOTAMessageServices).ClearToolMessages;
end;
{ Verbindungsmethode zur Tastatus. }
function TTestExperte.GetBindingType: TBindingType;
begin
Result := btPartial;
end;
{ Zuordnung der Tastaturkürzel zu einer Methode. }
procedure TTestExperte.BindKeyboard(
const BindingServices: IOTAKeyBindingServices);
begin
BindingServices.AddKeyBinding([Shortcut(VK_F1, [ssAlt])], AltF1,
nil);
end;
{ Text von der aktuellen Position im Editor holen. }
function TTestExperte.GetTopBufferText :
String;
Var
sText :
String;
ch : Char;
bOk : Boolean;
i : Integer;
begin
// markierten Text aus dem Editor holen.
sText := EditorServices.TopBuffer.EditBlock.Text;
// Ist kein Text markiert?
If sText = '
'
Then Begin
with EditorServices.TopBuffer.EditPosition
do begin
Repeat
// Ein Zeichen nach links gehen
bOk := Move(Row, Column - 1);
// Hat das funktioniert?
If bOk
then begin
// Zeichen lesen
ch :=
Read(1)[1];
// Ist es ein Buchstabe?
Case ch
Of
'
A'..'
Z','
a'..'
z','
.' : ;
// bOk := True;
else
// Nein, dann Schalter für Schleifenabbruch setzen.
bOk := false;
End;
end;
Until not bOk;
// Mit dem Cursor ein Zeichen nach rechts,
// wenns kein Buchstabe oder Punkt ist
Case Read(1)[1]
Of
'
A'..'
Z','
a'..'
z','
.' :;
else
Move(Row, Column + 1);
end;
// und dann die nächsten 100 Zeichen
sText := Trim(
Read(100));
i := 1;
bOK := False;
// Das erste Zeichen suchen, das kein Buchstabe ist bzw. kein Punkt.
Repeat
Case sText[i]
Of
'
A'..'
Z','
a'..'
z','
.' :;
else
bOk := True;
end;
Inc(i);
Until (i >= Length(sText))
Or bOk;
// Das wird unser Suchbegriff
sText := Copy(sText,1,i - 2);
end;
// Ein eventuell vorhandenes Semikolon wird entfernt.
sText := AnsiReplaceText(sText,'
;','
');
sText := Trim(sText);
i := Pos('
',sText);
If i > 0
Then sText := Copy(sText,1,i - 1);
end;
Result := sText;
end;
{ Routine, die auf die Tastaturkombination Alt+F1 reagiert. }
procedure TTestExperte.AltF1(
const Context: IOTAKeyContext; KeyCode: TShortCut;
var BindingResult: TKeyBindingResult);
begin
// markierten Text holen,
// ist kein Text markiert, wird versucht, die Zeichenfolge zu extrahieren,
// die sich "rund um die Cursorposition" befindet.
ShowMessage(GetTopBufferText);
BindingResult := krHandled;
end;
{ Konstruktor des Experten. }
Constructor TTestExperte.Create;
begin
inherited;
Execute;
end;
procedure TTestExperte.Execute;
begin
...
// Falls hier was zu tuen sein sollte...
end;
initialization
InitExpert;
finalization
DoneExpert;
end.