OTA: Deklaration suchen/finden

[sahimba]

Fahre ich, mit gedrückter CTRL-Taste im Editor über ein Symbol, so unterstreicht Delphi dieses. Ein Mausklick führt nun zu der entsprechenden Deklaration.
Bietet mir die OTA hier eine Möglichkeit, mich in den Vorgang einzuklinken? Konkret möchte ich einen Ausdruck der Art
ABC-123 mit meinem Bugtrackingsystem verknüpfen.
Im Popup des Code-Editors einen Eintrag hinzuzügen welcher dann die Cursorposition verwendet um "dort" einen entsprechenden Ausdruck zu finden und zu verarbeiten ist mir soweit gelungen, aber man möchte es ja immer noch etwas schöner haben
Prost!
Stefan

PS: Und falls es da schon etwas "fertiges" gibt oder andere Alternativen... nur zu.

[nahpets]

Nur mal ein paar Fragmente, mit denen Du weiterschauen kannst:

Delphi-Quellcode:

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.

Die Fragmente stammen aus einem Experten für Delpghi 7. Keine Ahnung, ob das für neuere Delphiversionen brauchbar und/oder auch nur im Ansatz kompilierfähig sein könnte.

Zum "Ideenklauen" mag es eventuell reichen.

[sahimba]

Herzlichen Dank,
das eine oder andere Schnippsel werde ich vielleicht brauchen können.
Schönen Samstag!
Stefan