[Templates] Probleme mit Einrückungen

[Namenloser]

Hallo

Da ich recht häufig mit Objektlisten arbeite, habe ich mir folgendes Template geschrieben (sry dass es so lang ist):

XML-Code:

<?xml version="1.0" encoding="utf-8" ?>
<codetemplate   xmlns="http://schemas.borland.com/Delphi/2005/codetemplates"
            version="1.0.0">
   <template name="objlist" invoke="manual">
      <point name="TMyObjectList">
         <text>
            TMyObjectList
         </text>
         <hint>
            Klassenname der Liste
         </hint>
      </point>
      <point name="TMyObject">
         <text>
            TMyObject
         </text>
         <hint>
            Klassenname der Listeneinträge
         </hint>
      </point>  
      <description>
         Typensichere Objektliste
      </description>
      <author>
         Philip Zander
      </author>
      <code language="Delphi" context="typedecl" delimiter="|">
<![CDATA[
|*||TMyObjectList| = class(TObjectList)
|*|private
|*|protected
|*||*|function GetItem(Index: Integer): |TMyObject|;
|*||*|procedure SetItem(Index: Integer; AObject: |TMyObject|);
|*|public
|*||*|function Add(AObject: |TMyObject|): Integer;
|*||*|function Extract(Item: |TMyObject|): |TMyObject|;
|*||*|function Remove(AObject: |TMyObject|): Integer;
|*||*|function IndexOf(AObject: |TMyObject|): Integer;
|*||*|procedure Insert(Index: Integer; AObject: |TMyObject|);
|*||*|function First: |TMyObject|;
|*||*|function Last: |TMyObject|;
|*||*|property Items[Index: Integer]: |TMyObject| read GetItem write SetItem; default;
|*|end;

{ |TMyObjectList| }

function |TMyObjectList|.Add(AObject: |TMyObject|): Integer;
begin
|*|inherited Add(AObject);
end;

function |TMyObjectList|.Extract(Item: |TMyObject|): |TMyObject|;
begin
|*|Result := |TMyObject|(inherited Extract(Item));
end;

function |TMyObjectList|.First: |TMyObject|;
begin
|*|Result := |TMyObject|(inherited First);
end;

function |TMyObjectList|.GetItem(Index: Integer): |TMyObject|;
begin
|*|Result := |TMyObject|(inherited GetItem(Index));
end;

function |TMyObjectList|.IndexOf(AObject: |TMyObject|): Integer;
begin
|*|Result := inherited IndexOf(AObject);
end;

procedure |TMyObjectList|.Insert(Index: Integer; AObject: |TMyObject|);
begin
|*|inherited Insert(Index, AObject);
end;

function |TMyObjectList|.Last: |TMyObject|;
begin
|*|Result := |TMyObject|(inherited Last);
end;

function |TMyObjectList|.Remove(AObject: |TMyObject|): Integer;
begin
|*|Result := inherited Remove(AObject);
end;

procedure |TMyObjectList|.SetItem(Index: Integer; AObject: |TMyObject|);
begin
|*|inherited SetItem(Index, AObject);
end;
]]>
      </code>
   </template>
</codetemplate>

Soweit ich es den mitgelieferten Templates entnehmen konnte, nutzt man |*| zur Einrückung. Leider funktioniert das nicht so ganz, denn egal wo ich das Template einfüge, es wird immer zu einer "ungeraden" Spalte eingerückt, also z.B. so:

Delphi-Quellcode:

.
  TCollision = class
  private
    FObjectB: TGameObject;
    FObjectA: TGameObject;
    procedure SetObjectA(const Value: TGameObject);
    procedure SetObjectB(const Value: TGameObject);
  published
  public
    property ObjectA: TGameObject read FObjectA write SetObjectA;
    property ObjectB: TGameObject read FObjectB write SetObjectB;
  end;
  ^---------- Hier ist die Einrückung (2 Spalten)

   TCollisionList = class(TObjectList)
  ^---------- 1 Spalte zu viel
   protected
     function GetItem(Index: Integer): TCollision;
     procedure SetItem(Index: Integer; AObject: TCollision);
   public
     function Add(AObject: TCollision): Integer;
     function Extract(Item: TCollision): TCollision;
     function Remove(AObject: TCollision): Integer;
     function IndexOf(AObject: TCollision): Integer;
     procedure Insert(Index: Integer; AObject: TCollision);
     function First: TCollision;
     function Last: TCollision;
     property Items[Index: Integer]: TCollision read GetItem write SetItem; default;
   end;

 { TCollisionList }

Die folgenden Zeilen sind ebenfalls um eins zu viel eingerückt, leider wird das im Post offenbar falsch dargsetellt...

 function TCollisionList.Add(AObject: TCollision): Integer;
 begin
   inherited Add(AObject);
 end;

 function TCollisionList.Extract(Item: TCollision): TCollision;
 begin
   Result := TCollision(inherited Extract(Item));
 end;

 function TCollisionList.First: TCollision;
 begin
   Result := TCollision(inherited First);
 end;

 ...

Das passiert immer, und lässt sich auch nicht umgehen, wenn man den Cursor um eins nach links oder rechts verschiebt.

Wie behebt man das? Es ist nervig, wenn man sich Arbeit sparen will, und dann manuell in jeder Zeile ein zeichen entfernen darf...

Ich benutze übrigens Turbo Delphi.