[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.

[Namenloser]

Ich pushe mal vorsichtig... ich brauch nämlich grad wieder eine Objektliste

[mleyen]

Das gleiche Problem hab ich auch und konnt es bisher auch noch nicht lösen.
Anscheinend liegt das Einrückproblem aber nicht an |*| sondern irgendwo anders.
Manche Tamplates rückt er bei mir alles eine Zeile weiter ein und manche richtig.

Ich such nochmal meine alten Vergleiche raus und editier sie rein.


Edit:

Ich hab den Delphi-Bug gefunden.
Da dein Template "objlist" heißt mach mal folgendes:
Wenn du "nur" Strg+Leertaste und Enter auf dein Template drückst rückt er es falsch ein.

Und jetzt kommts:
Tipp mal "o" dann Strg+Leertaste und Enter auf dein Template und *trommelwirbel* tadaaa er rückt es richtig ein.

Hmmm, sehr hilfreich zu wissen.

[Namenloser]

Du hast recht

Vielen Dank!