unit TraceDx;

{ Diese Unit wird in Projekte eingebunden und stellt die Aufruf-Schnittstelle für Befehle
  und Anzeigen zur TraceServer-Anwendung zur Verfügung. Aufruf-Vorlagen siehe "TraceDxSamples.txt".

  Die Kommunikation kann über Windows-Messages, Pipes oder IP erfolgen, letzteres auch
  Rechner-übergreifend im Netzwerk.

  Die TraceDx-Unit initialisiert sich beim ersten Aufruf.
  Falls vorhanden wird dafür die Datei "<Projektname>.TraceDx.ini" im Projekt-Verzeichnis gelesen.
  Andernfalls werden Standardwerte benutzt.

  Es kann im Client ein TraceDx-Menü angefügt bzw zusätzlich erstellt werden.
  
  Falls Trace für DLL:
  Unit-Daten existieren jeweils pro App und DLL mehrfach.
  Schreiben in Datei wäre konkurrierend, ist deshalb aus DLL grundsätzlich ausgeschaltet.
}

interface

type

  tTraceColor   = ( tcDefault, tcBlue, tcRed, tcGreen, tcOrange );
  tRetType      = ( rtNull, rtByte, rtWord, rtCardinal, rtInteger, rtInt64, rtSingle, rtDouble, rtExtended, rtString );

  tMessageTypes = ( mtAppOnMessage, mtMainWindowHook, mtWindowProc, mtWinSend, mtWinSendTimeOut, mtWinSendCallBack, mtWinPost);
  tMsgParam     = ( paNul, paInt, paIntWords, paHex, paHexWords );

  TMessageSelector  = record
                        Name       : string;
                        Enabled    : boolean;
                        Color      : tTraceColor;
                        UseShowList: boolean;
                        ShowList,
                        HideList   : TArray<TWinMessage>;
                      end;


  TTraceDx = record
    public
      (* Trace löschen *)
      class procedure Clear();

      (* Trace Trennlinie *)
      class procedure Line();

      (* Ausgabe aller Traces in Datei _TraceDx.log.  Verzeichnis ist ExeDir falls beschreibbar, sonst User\Documents *)
      class procedure SetFileEnabled( b: boolean );

      (* Ausgabe zum im TraceServer
      class procedure SetViewEnabled( b: boolean );

      (* Ausgabe in ein von der Applikation zur Verfügung gestelltes TMemo/TListbox/TRichEdit *)
      class procedure SetInternalView( v: TComponent );

      (* Filter setzen auf Client-Seite (mehr Rechenaufwand, weniger Datenverkehr zum Server *)
      (* Mehrere Filter-Strings durch ";" trennen, Negativ-Filter mit "-" einleiten          *)
      (* Die Anzahl ausgefilterter Zeilen NACH der letzten nicht gefilterten wird ggf im     *)
      (* StatusBar "Lines = ..." angezeigt						     *)
      class procedure SetFilter( const s: string );

      (* Appzustand "Idle" als gepunktete Trennlinie anzeigen                                *)
      class procedure ShowIdle( b: boolean );

      (* Standard-Farbe für folgende Send() setzen.                                                                *)
      (*   Override false: Gilt nur für Send() OHNE Farbangabe                                                     *)
      (*   Override true : Überschreibt alle im Send() mitgegebenen Farb-Parameter                                 *)
      (* Sinn: Bei DLLs oder mehreren Programmen im Trace Herkunft der Trace-Zeile durch eine Farbe kennzeichnen   *)
      class procedure SetColor( aColor: tTraceColor; aOverride: boolean = false );

      (* Inc/Dec für Einrückung falls OHNE zugehörigen neuen Call gebraucht *)
      class procedure IncIndent;
      class procedure DecIndent;

      (* Ausgabe mit Einrückung gemäß Call-Ebene *)
      class procedure Send     (                 const Method: string                                 ; tc: tTraceColor = tcIntern ); overload; static;
      class procedure Send     (                 const Method: string;  const s    : string           ; tc: tTraceColor = tcIntern ); overload; static;
      class procedure Send     (                 const Method: string;  const s1,s2: string           ; tc: tTraceColor = tcIntern ); overload; static;
      class procedure Send     (                 const Method: string;  const i    : integer          ; tc: tTraceColor = tcIntern ); overload; static;
      class procedure Send     (                 const Method: string;  const i1,i2: integer          ; tc: tTraceColor = tcIntern ); overload; static;
      class procedure Send     (                 const Method: string;  const i    : int64            ; tc: tTraceColor = tcIntern ); overload; static;
      class procedure Send     (                 const Method: string;  const c    : cardinal         ; tc: tTraceColor = tcIntern ); overload; static;
      class procedure Send     (                 const Method: string;  const c1,c2: cardinal         ; tc: tTraceColor = tcIntern ); overload; static;
      class procedure Send     (                 const Method: string;  const b    : boolean          ; tc: tTraceColor = tcIntern ); overload; static;
      class procedure Send     (                 const Method: string;  const b1,b2: boolean          ; tc: tTraceColor = tcIntern ); overload; static;
      class procedure Send     (                 const Method: string;  const f    : single           ; tc: tTraceColor = tcIntern ); overload; static;
      class procedure Send     (                 const Method: string;  const f    : double           ; tc: tTraceColor = tcIntern ); overload; static;
      class procedure Send     (                 const Method: string;  const f1,f2: double           ; tc: tTraceColor = tcIntern ); overload; static;
      class procedure Send     (                 const Method: string;  const p    : pointer          ; tc: tTraceColor = tcIntern ); overload; static;
      class procedure Send     (                 const Method: string;  const p1,p2: pointer          ; tc: tTraceColor = tcIntern ); overload; static;
      class procedure Send     (                 const Method: string;  const p    : TPoint           ; tc: tTraceColor = tcIntern ); overload; static;
      class procedure Send     (                 const Method: string;  const p1,p2: TPoint           ; tc: tTraceColor = tcIntern ); overload; static;
      class procedure Send     (                 const Method: string;  const r    : TRect            ; tc: tTraceColor = tcIntern ); overload; static;
      class procedure Send     (                 const Method: string;  const m    : TMessage;
                                                                        const W    : tMsgParam = paNul;
                                                                        const L    : tMsgParam = paNul; tc: tTraceColor = tcIntern ); overload; static;
      class procedure Send     (                 const Method: string;  const c    : TClass           ; tc: tTraceColor = tcIntern ); overload; static;
      class procedure Send     (                 const Method: string;  const o    : TObject          ; tc: tTraceColor = tcIntern ); overload; static;
      class procedure SendE<T> (                 const Method: string;  const enum : T                ; tc: tTraceColor = tcIntern ); overload; static;
      class procedure SendS<T> (                 const Method: string;  const &set : T                ; tc: tTraceColor = tcIntern ); overload; static;
      class procedure Send<T>  (                 const Method: string;  const v    : T;
                                                                        ToString   : TFunc<T,string>  ; tc: tTraceColor = tcIntern ); overload; static;
      class procedure Send     (                 const Method: string;  const a    : array of const   ; tc: tTraceColor = tcIntern ); overload; static;
      class procedure Send<T>  (                 const Method: string;  const a    : array of T;
                                                                        const c    : integer;
                                                                        ToString   : TFunc<T,string>  ; tc: tTraceColor = tcIntern ); overload; static;
      class procedure Send     (                 const Method: string;  const sl   : TStringList;
                                                                        const c    : integer          ; tc: tTraceColor = tcIntern ); overload; static;
      class procedure Send     (                 const Method: string;  const sl   : TStringList;
                                                                        const c    : integer;
                                                                        ObjToString: TFunc<NativeInt,string>
                                                                                                      ; tc: tTraceColor = tcIntern ); overload; static;

      class procedure Send<T>  (                 const Method: string;  const l    : TList;
                                                                        const c    : integer;
                                                                        ToString   : TFunc<T,string>  ; tc: tTraceColor = tcIntern ); overload; static;
      class procedure Send<T>  (                 const Method: string;  const l    : TList<T>;
                                                                        const c    : integer;
                                                                        ToString   : TFunc<T,string>  ; tc: tTraceColor = tcIntern ); overload; static;
      class procedure Send<K,V>(                 const Method: string;  const d    : TDictionary<K,V>;
                                                                        const c    : integer;
                                                                        ToString   : TFunc<K,V,string>; tc: tTraceColor = tcIntern ); overload; static;

      (* ... und Class zur Erst-Identifikation *)
      class procedure Send     ( Scope: TClass;  const Method: string                                 ; tc: tTraceColor = tcIntern ); overload; static;
      class procedure Send     ( Scope: TClass;  const Method: string;  const s    : string           ; tc: tTraceColor = tcIntern ); overload; static;
      class procedure Send     ( Scope: TClass;  const Method: string;  const s1,s2: string           ; tc: tTraceColor = tcIntern ); overload; static;
      class procedure Send     ( Scope: TClass;  const Method: string;  const i    : integer          ; tc: tTraceColor = tcIntern ); overload; static;
      class procedure Send     ( Scope: TClass;  const Method: string;  const i1,i2: integer          ; tc: tTraceColor = tcIntern ); overload; static;
      class procedure Send     ( Scope: TClass;  const Method: string;  const i    : int64            ; tc: tTraceColor = tcIntern ); overload; static;
      class procedure Send     ( Scope: TClass;  const Method: string;  const c    : cardinal         ; tc: tTraceColor = tcIntern ); overload; static;
      class procedure Send     ( Scope: TClass;  const Method: string;  const c1,c2: cardinal         ; tc: tTraceColor = tcIntern ); overload; static;
      class procedure Send     ( Scope: TClass;  const Method: string;  const b    : boolean          ; tc: tTraceColor = tcIntern ); overload; static;
      class procedure Send     ( Scope: TClass;  const Method: string;  const b1,b2: boolean          ; tc: tTraceColor = tcIntern ); overload; static;
      class procedure Send     ( Scope: TClass;  const Method: string;  const f    : single           ; tc: tTraceColor = tcIntern ); overload; static;
      class procedure Send     ( Scope: TClass;  const Method: string;  const f    : double           ; tc: tTraceColor = tcIntern ); overload; static;
      class procedure Send     ( Scope: TClass;  const Method: string;  const f1,f2: double           ; tc: tTraceColor = tcIntern ); overload; static;
      class procedure Send     ( Scope: TClass;  const Method: string;  const p    : pointer          ; tc: tTraceColor = tcIntern ); overload; static;
      class procedure Send     ( Scope: TClass;  const Method: string;  const p1,p2: pointer          ; tc: tTraceColor = tcIntern ); overload; static;
      class procedure Send     ( Scope: TClass;  const Method: string;  const p    : TPoint           ; tc: tTraceColor = tcIntern ); overload; static;
      class procedure Send     ( Scope: TClass;  const Method: string;  const p1,p2: TPoint           ; tc: tTraceColor = tcIntern ); overload; static;
      class procedure Send     ( Scope: TClass;  const Method: string;  const r    : TRect            ; tc: tTraceColor = tcIntern ); overload; static;
      class procedure Send     ( Scope: TClass;  const Method: string;  const m    : TMessage;
                                                                        const W    : tMsgParam = paNul;
                                                                        const L    : tMsgParam = paNul; tc: tTraceColor = tcIntern ); overload; static;
      class procedure Send     ( Scope: TClass;  const Method: string;  const c    : TClass           ; tc: tTraceColor = tcIntern ); overload; static;
      class procedure Send     ( Scope: TClass;  const Method: string;  const o    : TObject          ; tc: tTraceColor = tcIntern ); overload; static;
      class procedure SendE<T> ( Scope: TClass;  const Method: string;  const enum : T                ; tc: tTraceColor = tcIntern ); overload; static;
      class procedure SendS<T> ( Scope: TClass;  const Method: string;  const &set : T                ; tc: tTraceColor = tcIntern ); overload; static;
      class procedure Send<T>  ( Scope: TClass;  const Method: string;  const v    : T;
                                                                        ToString   : TFunc<T,string>  ; tc: tTraceColor = tcIntern ); overload; static;
      class procedure Send     ( Scope: TClass;  const Method: string;  const a    : array of const   ; tc: tTraceColor = tcIntern ); overload; static;
      class procedure Send<T>  ( Scope: TClass;  const Method: string;  const a    : array of T;
                                                                        const c    : integer;
                                                                        ToString   : TFunc<T,string>  ; tc: tTraceColor = tcIntern ); overload; static;
      class procedure Send     ( Scope: TClass;  const Method: string;  const sl   : TStringList      ;
                                                                        const c    : integer          ; tc: tTraceColor = tcIntern ); overload; static;
      class procedure Send     ( Scope: TClass;  const Method: string;  const sl   : TStringList;
                                                                        const c    : integer;
                                                                        ObjToString: TFunc<NativeInt,string>
                                                                                                      ; tc: tTraceColor = tcIntern ); overload; static;
      class procedure Send<T>  ( Scope: TClass;  const Method: string;  const l    : TList;
                                                                        const c    : integer;
                                                                        ToString   : TFunc<T,string>  ; tc: tTraceColor = tcIntern ); overload; static;
      class procedure Send<T>  ( Scope: TClass;  const Method: string;  const l    : TList<T>;
                                                                        const c    : integer;
                                                                        ToString   : TFunc<T,string>  ; tc: tTraceColor = tcIntern ); overload; static;
      class procedure Send<K,V>( Scope: TClass;  const Method: string;  const d    : TDictionary<K,V>;
                                                                        const c    : integer;
                                                                        ToString   : TFunc<K,V,string>; tc: tTraceColor = tcIntern ); overload; static;

      (* ... und Objekt zur Erst-Identifikation *)
      class procedure Send     ( Scope: TObject; const Method: string                                 ; tc: tTraceColor = tcIntern ); overload; static;
      class procedure Send     ( Scope: TObject; const Method: string;  const s    : string           ; tc: tTraceColor = tcIntern ); overload; static;
      class procedure Send     ( Scope: TObject; const Method: string;  const s1,s2: string           ; tc: tTraceColor = tcIntern ); overload; static;
      class procedure Send     ( Scope: TObject; const Method: string;  const i    : integer          ; tc: tTraceColor = tcIntern ); overload; static;
      class procedure Send     ( Scope: TObject; const Method: string;  const i1,i2: integer          ; tc: tTraceColor = tcIntern ); overload; static;
      class procedure Send     ( Scope: TObject; const Method: string;  const i    : int64            ; tc: tTraceColor = tcIntern ); overload; static;
      class procedure Send     ( Scope: TObject; const Method: string;  const c    : cardinal         ; tc: tTraceColor = tcIntern ); overload; static;
      class procedure Send     ( Scope: TObject; const Method: string;  const c1,c2: cardinal         ; tc: tTraceColor = tcIntern ); overload; static;
      class procedure Send     ( Scope: TObject; const Method: string;  const b    : boolean          ; tc: tTraceColor = tcIntern ); overload; static;
      class procedure Send     ( Scope: TObject; const Method: string;  const b1,b2: boolean          ; tc: tTraceColor = tcIntern ); overload; static;
      class procedure Send     ( Scope: TObject; const Method: string;  const f    : single           ; tc: tTraceColor = tcIntern ); overload; static;
      class procedure Send     ( Scope: TObject; const Method: string;  const f    : double           ; tc: tTraceColor = tcIntern ); overload; static;
      class procedure Send     ( Scope: TObject; const Method: string;  const f1,f2: double           ; tc: tTraceColor = tcIntern ); overload; static;
      class procedure Send     ( Scope: TObject; const Method: string;  const p    : pointer          ; tc: tTraceColor = tcIntern ); overload; static;
      class procedure Send     ( Scope: TObject; const Method: string;  const p1,p2: pointer          ; tc: tTraceColor = tcIntern ); overload; static;
      class procedure Send     ( Scope: TObject; const Method: string;  const p    : TPoint           ; tc: tTraceColor = tcIntern ); overload; static;
      class procedure Send     ( Scope: TObject; const Method: string;  const p1,p2: TPoint           ; tc: tTraceColor = tcIntern ); overload; static;
      class procedure Send     ( Scope: TObject; const Method: string;  const r    : TRect            ; tc: tTraceColor = tcIntern ); overload; static;
      class procedure Send     ( Scope: TObject; const Method: string;  const m    : TMessage;
                                                                        const W    : tMsgParam = paNul;
                                                                        const L    : tMsgParam = paNul; tc: tTraceColor = tcIntern ); overload; static;
      class procedure Send     ( Scope: TObject; const Method: string;  const c    : TClass           ; tc: tTraceColor = tcIntern ); overload; static;
      class procedure Send     ( Scope: TObject; const Method: string;  const o    : TObject          ; tc: tTraceColor = tcIntern ); overload; static;
      class procedure SendE<T> ( Scope: TObject; const Method: string;  const enum : T                ; tc: tTraceColor = tcIntern ); overload; static;
      class procedure SendS<T> ( Scope: TObject; const Method: string;  const &set : T                ; tc: tTraceColor = tcIntern ); overload; static;
      class procedure Send<T>  ( Scope: TObject; const Method: string;  const v    : T;
                                                                        ToString   : TFunc<T,string>  ; tc: tTraceColor = tcIntern ); overload; static;
      class procedure Send     ( Scope: TObject; const Method: string;  const a    : array of const   ; tc: tTraceColor = tcIntern ); overload; static;
      class procedure Send<T>  ( Scope: TObject; const Method: string;  const a    : array of T;
                                                                        const c    : integer;
                                                                        ToString   : TFunc<T,string>  ; tc: tTraceColor = tcIntern ); overload; static;
      class procedure Send     ( Scope: TObject; const Method: string;  const sl   : TStringList      ;
                                                                        const c    : integer          ; tc: tTraceColor = tcIntern ); overload; static;
      class procedure Send     ( Scope: TObject; const Method: string;  const sl   : TStringList;
                                                                        const c    : integer;
                                                                        ObjToString: TFunc<NativeInt,string>
                                                                                                      ; tc: tTraceColor = tcIntern ); overload; static;
      class procedure Send<T>  ( Scope: TObject; const Method: string;  const l    : TList;
                                                                        const c    : integer;
                                                                        ToString   : TFunc<T,string>  ; tc: tTraceColor = tcIntern ); overload; static;
      class procedure Send<T>  ( Scope: TObject; const Method: string;  const l    : TList<T>;
                                                                        const c    : integer;
                                                                        ToString   : TFunc<T,string>  ; tc: tTraceColor = tcIntern ); overload; static;
      class procedure Send<K,V>( Scope: TObject; const Method: string;  const d    : TDictionary<K,V>;
                                                                        const c    : integer;
                                                                        ToString   : TFunc<K,V,string>; tc: tTraceColor = tcIntern ); overload; static;


      (* Ausgabe mit zusätzlicher Ein- und Ausrückung *)
      (* Wegen Compiler-Fehler geht nicht:
             if b
               then TTrace.Call(...
               else TTrace.Call(...                                                                                      *)
      class function Call     (                 const Method: string                                 ; tc: tTraceColor = tcIntern ): IInterface; overload; static;
      class function Call     (                 const Method: string;  const s    : string           ; tc: tTraceColor = tcIntern ): IInterface; overload; static;
      class function Call     (                 const Method: string;  const s1,s2: string           ; tc: tTraceColor = tcIntern ): IInterface; overload; static;
      class function Call     (                 const Method: string;  const i    : integer          ; tc: tTraceColor = tcIntern ): IInterface; overload; static;
      class function Call     (                 const Method: string;  const i1,i2: integer          ; tc: tTraceColor = tcIntern ): IInterface; overload; static;
      class function Call     (                 const Method: string;  const i    : int64            ; tc: tTraceColor = tcIntern ): IInterface; overload; static;
      class function Call     (                 const Method: string;  const c    : cardinal         ; tc: tTraceColor = tcIntern ): IInterface; overload; static;
      class function Call     (                 const Method: string;  const c1,c2: cardinal         ; tc: tTraceColor = tcIntern ): IInterface; overload; static;
      class function Call     (                 const Method: string;  const b    : boolean          ; tc: tTraceColor = tcIntern ): IInterface; overload; static;
      class function Call     (                 const Method: string;  const b1,b2: boolean          ; tc: tTraceColor = tcIntern ): IInterface; overload; static;
      class function Call     (                 const Method: string;  const f    : single           ; tc: tTraceColor = tcIntern ): IInterface; overload; static;
      class function Call     (                 const Method: string;  const f    : double           ; tc: tTraceColor = tcIntern ): IInterface; overload; static;
      class function Call     (                 const Method: string;  const f1,f2: double           ; tc: tTraceColor = tcIntern ): IInterface; overload; static;
      class function Call     (                 const Method: string;  const p    : pointer          ; tc: tTraceColor = tcIntern ): IInterface; overload; static;
      class function Call     (                 const Method: string;  const p1,p2: pointer          ; tc: tTraceColor = tcIntern ): IInterface; overload; static;
      class function Call     (                 const Method: string;  const p    : TPoint           ; tc: tTraceColor = tcIntern ): IInterface; overload; static;
      class function Call     (                 const Method: string;  const p1,p2: TPoint           ; tc: tTraceColor = tcIntern ): IInterface; overload; static;
      class function Call     (                 const Method: string;  const r    : TRect            ; tc: tTraceColor = tcIntern ): IInterface; overload; static;
      class function Call     (                 const Method: string;  const m    : TMessage;
                                                                       const W    : tMsgParam = paNul;
                                                                       const L    : tMsgParam = paNul; tc: tTraceColor = tcIntern ): IInterface; overload; static;
      class function Call     (                 const Method: string;  const c    : TClass           ; tc: tTraceColor = tcIntern ): IInterface; overload; static;
      class function Call     (                 const Method: string;  const o    : TObject          ; tc: tTraceColor = tcIntern ): IInterface; overload; static;
      class function CallE<T> (                 const Method: string;  const enum : T                ; tc: tTraceColor = tcIntern ): IInterface; overload; static;
      class function CallS<T> (                 const Method: string;  const &set : T                ; tc: tTraceColor = tcIntern ): IInterface; overload; static;
      class function Call<T>  (                 const Method: string;  const v    : T;
                                                                       ToString   : TFunc<T,string>  ; tc: tTraceColor = tcIntern ): IInterface; overload; static;
      class function Call     (                 const Method: string;  const a    : array of const   ; tc: tTraceColor = tcIntern ): IInterface; overload; static;
      class function Call<T>  (                 const Method: string;  const a    : array of T;
                                                                       const c    : integer;
                                                                       ToString   : TFunc<T,string>  ; tc: tTraceColor = tcIntern ): IInterface; overload; static;
      class function Call     (                 const Method: string;  const sl   : TStringList;
                                                                       const c    : integer          ; tc: tTraceColor = tcIntern ): IInterface; overload; static;
      class function Call     (                 const Method: string;  const sl   : TStringList;
                                                                       const c    : integer;
                                                                       ObjToString: TFunc<NativeInt,string>
                                                                                                     ; tc: tTraceColor = tcIntern ): IInterface; overload; static;
      class function Call<T>  (                 const Method: string;  const l    : TList;
                                                                       const c    : integer;
                                                                       ToString   : TFunc<T,string>  ; tc: tTraceColor = tcIntern ): IInterface; overload; static;
      class function Call<T>  (                 const Method: string;  const l    : TList<T>;
                                                                       const c    : integer;
                                                                       ToString   : TFunc<T,string>  ; tc: tTraceColor = tcIntern ): IInterface; overload; static;
      class function Call<K,V>(                 const Method: string;  const d    : TDictionary<K,V>;
                                                                       const c    : integer;
                                                                       ToString   : TFunc<K,V,string>; tc: tTraceColor = tcIntern ): IInterface; overload; static;

      (* ... und Class zur Erst-Identifikation *)
      class function Call     ( Scope: TClass;  const Method: string                                 ; tc: tTraceColor = tcIntern ): IInterface; overload; static;
      class function Call     ( Scope: TClass;  const Method: string;  const s    : string           ; tc: tTraceColor = tcIntern ): IInterface; overload; static;
      class function Call     ( Scope: TClass;  const Method: string;  const s1,s2: string           ; tc: tTraceColor = tcIntern ): IInterface; overload; static;
      class function Call     ( Scope: TClass;  const Method: string;  const i    : integer          ; tc: tTraceColor = tcIntern ): IInterface; overload; static;
      class function Call     ( Scope: TClass;  const Method: string;  const i1,i2: integer          ; tc: tTraceColor = tcIntern ): IInterface; overload; static;
      class function Call     ( Scope: TClass;  const Method: string;  const i    : int64            ; tc: tTraceColor = tcIntern ): IInterface; overload; static;
      class function Call     ( Scope: TClass;  const Method: string;  const c    : cardinal         ; tc: tTraceColor = tcIntern ): IInterface; overload; static;
      class function Call     ( Scope: TClass;  const Method: string;  const c1,c2: cardinal         ; tc: tTraceColor = tcIntern ): IInterface; overload; static;
      class function Call     ( Scope: TClass;  const Method: string;  const b    : boolean          ; tc: tTraceColor = tcIntern ): IInterface; overload; static;
      class function Call     ( Scope: TClass;  const Method: string;  const b1,b2: boolean          ; tc: tTraceColor = tcIntern ): IInterface; overload; static;
      class function Call     ( Scope: TClass;  const Method: string;  const f    : single           ; tc: tTraceColor = tcIntern ): IInterface; overload; static;
      class function Call     ( Scope: TClass;  const Method: string;  const f    : double           ; tc: tTraceColor = tcIntern ): IInterface; overload; static;
      class function Call     ( Scope: TClass;  const Method: string;  const f1,f2: double           ; tc: tTraceColor = tcIntern ): IInterface; overload; static;
      class function Call     ( Scope: TClass;  const Method: string;  const p    : pointer          ; tc: tTraceColor = tcIntern ): IInterface; overload; static;
      class function Call     ( Scope: TClass;  const Method: string;  const p1,p2: pointer          ; tc: tTraceColor = tcIntern ): IInterface; overload; static;
      class function Call     ( Scope: TClass;  const Method: string;  const p    : TPoint           ; tc: tTraceColor = tcIntern ): IInterface; overload; static;
      class function Call     ( Scope: TClass;  const Method: string;  const p1,p2: TPoint           ; tc: tTraceColor = tcIntern ): IInterface; overload; static;
      class function Call     ( Scope: TClass;  const Method: string;  const r    : TRect            ; tc: tTraceColor = tcIntern ): IInterface; overload; static;
      class function Call     ( Scope: TClass;  const Method: string;  const m    : TMessage;
                                                                       const W    : tMsgParam = paNul;
                                                                       const L    : tMsgParam = paNul; tc: tTraceColor = tcIntern ): IInterface; overload; static;
      class function Call     ( Scope: TClass;  const Method: string;  const c    : TClass           ; tc: tTraceColor = tcIntern ): IInterface; overload; static;
      class function Call     ( Scope: TClass;  const Method: string;  const o    : TObject          ; tc: tTraceColor = tcIntern ): IInterface; overload; static;
      class function CallE<T> ( Scope: TClass;  const Method: string;  const enum : T                ; tc: tTraceColor = tcIntern ): IInterface; overload; static;
      class function CallS<T> ( Scope: TClass;  const Method: string;  const &set : T                ; tc: tTraceColor = tcIntern ): IInterface; overload; static;
      class function Call<T>  ( Scope: TClass;  const Method: string;  const v    : T;
                                                                       ToString   : TFunc<T,string>  ; tc: tTraceColor = tcIntern ): IInterface; overload; static;
      class function Call     ( Scope: TClass;  const Method: string;  const a    : array of const   ; tc: tTraceColor = tcIntern ): IInterface; overload; static;
      class function Call<T>  ( Scope: TClass;  const Method: string;  const a    : array of T;
                                                                       const c    : integer;
                                                                       ToString   : TFunc<T,string>  ; tc: tTraceColor = tcIntern ): IInterface; overload; static;
      class function Call     ( Scope: TClass;  const Method: string;  const sl   : TStringList;
                                                                       const c    : integer          ; tc: tTraceColor = tcIntern ): IInterface; overload; static;
      class function Call     ( Scope: TClass;  const Method: string;  const sl   : TStringList;
                                                                       const c    : integer;
                                                                       ObjToString: TFunc<NativeInt,string>
                                                                                                     ; tc: tTraceColor = tcIntern ): IInterface; overload; static;
      class function Call<T>  ( Scope: TClass;  const Method: string;  const l    : TList;
                                                                       const c    : integer;
                                                                       ToString   : TFunc<T,string>  ; tc: tTraceColor = tcIntern ): IInterface; overload; static;
      class function Call<T>  ( Scope: TClass;  const Method: string;  const l    : TList<T>;
                                                                       const c    : integer;
                                                                       ToString   : TFunc<T,string>  ; tc: tTraceColor = tcIntern ): IInterface; overload; static;
      class function Call<K,V>( Scope: TClass;  const Method: string;  const d    : TDictionary<K,V>;
                                                                       const c    : integer;
                                                                       ToString   : TFunc<K,V,string>; tc: tTraceColor = tcIntern ): IInterface; overload; static;

      (* ... und Objekt zur Erst-Identifikation *)
      class function Call     ( Scope: TObject; const Method: string                                 ; tc: tTraceColor = tcIntern ): IInterface; overload; static;
      class function Call     ( Scope: TObject; const Method: string;  const s    : string           ; tc: tTraceColor = tcIntern ): IInterface; overload; static;
      class function Call     ( Scope: TObject; const Method: string;  const s1,s2: string           ; tc: tTraceColor = tcIntern ): IInterface; overload; static;
      class function Call     ( Scope: TObject; const Method: string;  const i    : integer          ; tc: tTraceColor = tcIntern ): IInterface; overload; static;
      class function Call     ( Scope: TObject; const Method: string;  const i1,i2: integer          ; tc: tTraceColor = tcIntern ): IInterface; overload; static;
      class function Call     ( Scope: TObject; const Method: string;  const i    : int64            ; tc: tTraceColor = tcIntern ): IInterface; overload; static;
      class function Call     ( Scope: TObject; const Method: string;  const c    : cardinal         ; tc: tTraceColor = tcIntern ): IInterface; overload; static;
      class function Call     ( Scope: TObject; const Method: string;  const c1,c2: cardinal         ; tc: tTraceColor = tcIntern ): IInterface; overload; static;
      class function Call     ( Scope: TObject; const Method: string;  const b    : boolean          ; tc: tTraceColor = tcIntern ): IInterface; overload; static;
      class function Call     ( Scope: TObject; const Method: string;  const b1,b2: boolean          ; tc: tTraceColor = tcIntern ): IInterface; overload; static;
      class function Call     ( Scope: TObject; const Method: string;  const f    : single           ; tc: tTraceColor = tcIntern ): IInterface; overload; static;
      class function Call     ( Scope: TObject; const Method: string;  const f    : double           ; tc: tTraceColor = tcIntern ): IInterface; overload; static;
      class function Call     ( Scope: TObject; const Method: string;  const f1,f2: double           ; tc: tTraceColor = tcIntern ): IInterface; overload; static;
      class function Call     ( Scope: TObject; const Method: string;  const p    : pointer          ; tc: tTraceColor = tcIntern ): IInterface; overload; static;
      class function Call     ( Scope: TObject; const Method: string;  const p1,p2: pointer          ; tc: tTraceColor = tcIntern ): IInterface; overload; static;
      class function Call     ( Scope: TObject; const Method: string;  const p    : TPoint           ; tc: tTraceColor = tcIntern ): IInterface; overload; static;
      class function Call     ( Scope: TObject; const Method: string;  const p1,p2: TPoint           ; tc: tTraceColor = tcIntern ): IInterface; overload; static;
      class function Call     ( Scope: TObject; const Method: string;  const r    : TRect            ; tc: tTraceColor = tcIntern ): IInterface; overload; static;
      class function Call     ( Scope: TObject; const Method: string;  const m    : TMessage;
                                                                       const W    : tMsgParam = paNul;
                                                                       const L    : tMsgParam = paNul; tc: tTraceColor = tcIntern ): IInterface; overload; static;
      class function Call     ( Scope: TObject; const Method: string;  const c    : TClass           ; tc: tTraceColor = tcIntern ): IInterface; overload; static;
      class function Call     ( Scope: TObject; const Method: string;  const o    : TObject          ; tc: tTraceColor = tcIntern ): IInterface; overload; static;
      class function CallE<T> ( Scope: TObject; const Method: string;  const enum : T                ; tc: tTraceColor = tcIntern ): IInterface; overload; static;
      class function CallS<T> ( Scope: TObject; const Method: string;  const &set : T                ; tc: tTraceColor = tcIntern ): IInterface; overload; static;
      class function Call<T>  ( Scope: TObject; const Method: string;  const v    : T;
                                                                       ToString   : TFunc<T,string>  ; tc: tTraceColor = tcIntern ): IInterface; overload; static;
      class function Call     ( Scope: TObject; const Method: string;  const a    : array of const   ; tc: tTraceColor = tcIntern ): IInterface; overload; static;
      class function Call<T>  ( Scope: TObject; const Method: string;  const a    : array of T;
                                                                       const c    : integer;
                                                                       ToString   : TFunc<T,string>  ; tc: tTraceColor = tcIntern ): IInterface; overload; static;
      class function Call     ( Scope: TObject; const Method: string;  const sl   : TStringList;
                                                                       const c    : integer          ; tc: tTraceColor = tcIntern ): IInterface; overload; static;
      class function Call     ( Scope: TObject; const Method: string;  const sl   : TStringList;
                                                                       const c    : integer;
                                                                       ObjToString: TFunc<NativeInt,string>
                                                                                                     ; tc: tTraceColor = tcIntern ): IInterface; overload; static;
      class function Call<T>  ( Scope: TObject; const Method: string;  const l    : TList;
                                                                       const c    : integer;
                                                                       ToString   : TFunc<T,string>  ; tc: tTraceColor = tcIntern ): IInterface; overload; static;
      class function Call<T>  ( Scope: TObject; const Method: string;  const l    : TList<T>;
                                                                       const c    : integer;
                                                                       ToString   : TFunc<T,string>  ; tc: tTraceColor = tcIntern ): IInterface; overload; static;
      class function Call<K,V>( Scope: TObject; const Method: string;  const d    : TDictionary<K,V>;
                                                                       const c    : integer;
                                                                       ToString   : TFunc<K,V,string>; tc: tTraceColor = tcIntern ): IInterface; overload; static;


      (* Call mit String und ggf Parametern, inc Call-Ebene. Melde Return automatisch, ggf mit Text und Variablen-Inhalt *)
      class function CallRet     (                 const Method: string                                 ; rp: Pointer = nil; rt: TTraceDxBase.tResultType = rtNull; const rs: string = ''; tc: tTraceColor = tcIntern ): IInterface; overload; static;
      class function CallRet     (                 const Method: string;  const s    : string           ; rp: Pointer = nil; rt: TTraceDxBase.tResultType = rtNull; const rs: string = ''; tc: tTraceColor = tcIntern ): IInterface; overload; static;
      class function CallRet     (                 const Method: string;  const s1,s2: string           ; rp: Pointer = nil; rt: TTraceDxBase.tResultType = rtNull; const rs: string = ''; tc: tTraceColor = tcIntern ): IInterface; overload; static;
      class function CallRet     (                 const Method: string;  const i    : integer          ; rp: Pointer = nil; rt: TTraceDxBase.tResultType = rtNull; const rs: string = ''; tc: tTraceColor = tcIntern ): IInterface; overload; static;
      class function CallRet     (                 const Method: string;  const i1,i2: integer          ; rp: Pointer = nil; rt: TTraceDxBase.tResultType = rtNull; const rs: string = ''; tc: tTraceColor = tcIntern ): IInterface; overload; static;
      class function CallRet     (                 const Method: string;  const i    : int64            ; rp: Pointer = nil; rt: TTraceDxBase.tResultType = rtNull; const rs: string = ''; tc: tTraceColor = tcIntern ): IInterface; overload; static;
      class function CallRet     (                 const Method: string;  const c    : cardinal         ; rp: Pointer = nil; rt: TTraceDxBase.tResultType = rtNull; const rs: string = ''; tc: tTraceColor = tcIntern ): IInterface; overload; static;
      class function CallRet     (                 const Method: string;  const c1,c2: cardinal         ; rp: Pointer = nil; rt: TTraceDxBase.tResultType = rtNull; const rs: string = ''; tc: tTraceColor = tcIntern ): IInterface; overload; static;
      class function CallRet     (                 const Method: string;  const b    : boolean          ; rp: Pointer = nil; rt: TTraceDxBase.tResultType = rtNull; const rs: string = ''; tc: tTraceColor = tcIntern ): IInterface; overload; static;
      class function CallRet     (                 const Method: string;  const b1,b2: boolean          ; rp: Pointer = nil; rt: TTraceDxBase.tResultType = rtNull; const rs: string = ''; tc: tTraceColor = tcIntern ): IInterface; overload; static;
      class function CallRet     (                 const Method: string;  const f    : single           ; rp: Pointer = nil; rt: TTraceDxBase.tResultType = rtNull; const rs: string = ''; tc: tTraceColor = tcIntern ): IInterface; overload; static;
      class function CallRet     (                 const Method: string;  const f    : double           ; rp: Pointer = nil; rt: TTraceDxBase.tResultType = rtNull; const rs: string = ''; tc: tTraceColor = tcIntern ): IInterface; overload; static;
      class function CallRet     (                 const Method: string;  const f1,f2: double           ; rp: Pointer = nil; rt: TTraceDxBase.tResultType = rtNull; const rs: string = ''; tc: tTraceColor = tcIntern ): IInterface; overload; static;
      class function CallRet     (                 const Method: string;  const p    : pointer          ; rp: Pointer = nil; rt: TTraceDxBase.tResultType = rtNull; const rs: string = ''; tc: tTraceColor = tcIntern ): IInterface; overload; static;
      class function CallRet     (                 const Method: string;  const p1,p2: pointer          ; rp: Pointer = nil; rt: TTraceDxBase.tResultType = rtNull; const rs: string = ''; tc: tTraceColor = tcIntern ): IInterface; overload; static;
      class function CallRet     (                 const Method: string;  const p    : TPoint           ; rp: Pointer = nil; rt: TTraceDxBase.tResultType = rtNull; const rs: string = ''; tc: tTraceColor = tcIntern ): IInterface; overload; static;
      class function CallRet     (                 const Method: string;  const p1,p2: TPoint           ; rp: Pointer = nil; rt: TTraceDxBase.tResultType = rtNull; const rs: string = ''; tc: tTraceColor = tcIntern ): IInterface; overload; static;
      class function CallRet     (                 const Method: string;  const r    : TRect            ; rp: Pointer = nil; rt: TTraceDxBase.tResultType = rtNull; const rs: string = ''; tc: tTraceColor = tcIntern ): IInterface; overload; static;
      class function CallRet     (                 const Method: string;  const m    : TMessage;
                                                                          const W    : tMsgParam = paNul;
                                                                          const L    : tMsgParam = paNul; rp: Pointer = nil; rt: TTraceDxBase.tResultType = rtNull; const rs: string = ''; tc: tTraceColor = tcIntern ): IInterface; overload; static;
      class function CallRet     (                 const Method: string;  const c    : TClass           ; rp: Pointer = nil; rt: TTraceDxBase.tResultType = rtNull; const rs: string = ''; tc: tTraceColor = tcIntern ): IInterface; overload; static;
      class function CallRet     (                 const Method: string;  const o    : TObject          ; rp: Pointer = nil; rt: TTraceDxBase.tResultType = rtNull; const rs: string = ''; tc: tTraceColor = tcIntern ): IInterface; overload; static;
      class function CallRetE<T> (                 const Method: string;  const enum : T                ; rp: Pointer = nil; rt: TTraceDxBase.tResultType = rtNull; const rs: string = ''; tc: tTraceColor = tcIntern ): IInterface; overload; static;
      class function CallRetS<T> (                 const Method: string;  const &set : T                ; rp: Pointer = nil; rt: TTraceDxBase.tResultType = rtNull; const rs: string = ''; tc: tTraceColor = tcIntern ): IInterface; overload; static;
      class function CallRet<T>  (                 const Method: string;  const v    : T;
                                                                          ToString   : TFunc<T,string>  ; rp: Pointer = nil; rt: TTraceDxBase.tResultType = rtNull; const rs: string = ''; tc: tTraceColor = tcIntern ): IInterface; overload; static;
      class function CallRet     (                 const Method: string;  const a    : array of const   ; rp: Pointer = nil; rt: TTraceDxBase.tResultType = rtNull; const rs: string = ''; tc: tTraceColor = tcIntern ): IInterface; overload; static;
      class function CallRet<T>  (                 const Method: string;  const a    : array of T;
                                                                          const c    : integer;
                                                                          ToString   : TFunc<T,string>  ; rp: Pointer = nil; rt: TTraceDxBase.tResultType = rtNull; const rs: string = ''; tc: tTraceColor = tcIntern ): IInterface; overload; static;

      class function CallRet     (                 const Method: string;  const sl   : TStringList;
                                                                          const c    : integer          ; rp: Pointer = nil; rt: TTraceDxBase.tResultType = rtNull; const rs: string = ''; tc: tTraceColor = tcIntern ): IInterface; overload; static;
      class function CallRet     (                 const Method: string;  const sl   : TStringList;
                                                                          const c    : integer;
                                                                          ObjToString: TFunc<NativeInt,string>
                                                                                                        ; rp: Pointer = nil; rt: TTraceDxBase.tResultType = rtNull; const rs: string = ''; tc: tTraceColor = tcIntern ): IInterface; overload; static;
      class function CallRet<T>  (                 const Method: string;  const l    : TList;
                                                                          const c    : integer;
                                                                          ToString   : TFunc<T,string>  ; rp: Pointer = nil; rt: TTraceDxBase.tResultType = rtNull; const rs: string = ''; tc: tTraceColor = tcIntern ): IInterface; overload; static;
      class function CallRet<T>  (                 const Method: string;  const l    : TList<T>;
                                                                          const c    : integer;
                                                                          ToString   : TFunc<T,string>  ; rp: Pointer = nil; rt: TTraceDxBase.tResultType = rtNull; const rs: string = ''; tc: tTraceColor = tcIntern ): IInterface; overload; static;
      class function CallRet<K,V>(                 const Method: string;  const d    : TDictionary<K,V>;
                                                                          const c    : integer;
                                                                          ToString   : TFunc<K,V,string>; rp: Pointer = nil; rt: TTraceDxBase.tResultType = rtNull; const rs: string = ''; tc: tTraceColor = tcIntern ): IInterface; overload; static;

      (* ... und Class zur Erst-Identifikation *)
      class function CallRet     ( Scope: TClass;  const Method: string                                 ; rp: Pointer = nil; rt: TTraceDxBase.tResultType = rtNull; const rs: string = ''; tc: tTraceColor = tcIntern ): IInterface; overload; static;
      class function CallRet     ( Scope: TClass;  const Method: string;  const s    : string           ; rp: Pointer = nil; rt: TTraceDxBase.tResultType = rtNull; const rs: string = ''; tc: tTraceColor = tcIntern ): IInterface; overload; static;
      class function CallRet     ( Scope: TClass;  const Method: string;  const s1,s2: string           ; rp: Pointer = nil; rt: TTraceDxBase.tResultType = rtNull; const rs: string = ''; tc: tTraceColor = tcIntern ): IInterface; overload; static;
      class function CallRet     ( Scope: TClass;  const Method: string;  const i    : integer          ; rp: Pointer = nil; rt: TTraceDxBase.tResultType = rtNull; const rs: string = ''; tc: tTraceColor = tcIntern ): IInterface; overload; static;
      class function CallRet     ( Scope: TClass;  const Method: string;  const i1,i2: integer          ; rp: Pointer = nil; rt: TTraceDxBase.tResultType = rtNull; const rs: string = ''; tc: tTraceColor = tcIntern ): IInterface; overload; static;
      class function CallRet     ( Scope: TClass;  const Method: string;  const i    : int64            ; rp: Pointer = nil; rt: TTraceDxBase.tResultType = rtNull; const rs: string = ''; tc: tTraceColor = tcIntern ): IInterface; overload; static;
      class function CallRet     ( Scope: TClass;  const Method: string;  const c    : cardinal         ; rp: Pointer = nil; rt: TTraceDxBase.tResultType = rtNull; const rs: string = ''; tc: tTraceColor = tcIntern ): IInterface; overload; static;
      class function CallRet     ( Scope: TClass;  const Method: string;  const c1,c2: cardinal         ; rp: Pointer = nil; rt: TTraceDxBase.tResultType = rtNull; const rs: string = ''; tc: tTraceColor = tcIntern ): IInterface; overload; static;
      class function CallRet     ( Scope: TClass;  const Method: string;  const b    : boolean          ; rp: Pointer = nil; rt: TTraceDxBase.tResultType = rtNull; const rs: string = ''; tc: tTraceColor = tcIntern ): IInterface; overload; static;
      class function CallRet     ( Scope: TClass;  const Method: string;  const b1,b2: boolean          ; rp: Pointer = nil; rt: TTraceDxBase.tResultType = rtNull; const rs: string = ''; tc: tTraceColor = tcIntern ): IInterface; overload; static;
      class function CallRet     ( Scope: TClass;  const Method: string;  const f    : single           ; rp: Pointer = nil; rt: TTraceDxBase.tResultType = rtNull; const rs: string = ''; tc: tTraceColor = tcIntern ): IInterface; overload; static;
      class function CallRet     ( Scope: TClass;  const Method: string;  const f    : double           ; rp: Pointer = nil; rt: TTraceDxBase.tResultType = rtNull; const rs: string = ''; tc: tTraceColor = tcIntern ): IInterface; overload; static;
      class function CallRet     ( Scope: TClass;  const Method: string;  const f1,f2: double           ; rp: Pointer = nil; rt: TTraceDxBase.tResultType = rtNull; const rs: string = ''; tc: tTraceColor = tcIntern ): IInterface; overload; static;
      class function CallRet     ( Scope: TClass;  const Method: string;  const p    : pointer          ; rp: Pointer = nil; rt: TTraceDxBase.tResultType = rtNull; const rs: string = ''; tc: tTraceColor = tcIntern ): IInterface; overload; static;
      class function CallRet     ( Scope: TClass;  const Method: string;  const p1,p2: pointer          ; rp: Pointer = nil; rt: TTraceDxBase.tResultType = rtNull; const rs: string = ''; tc: tTraceColor = tcIntern ): IInterface; overload; static;
      class function CallRet     ( Scope: TClass;  const Method: string;  const p    : TPoint           ; rp: Pointer = nil; rt: TTraceDxBase.tResultType = rtNull; const rs: string = ''; tc: tTraceColor = tcIntern ): IInterface; overload; static;
      class function CallRet     ( Scope: TClass;  const Method: string;  const p1,p2: TPoint           ; rp: Pointer = nil; rt: TTraceDxBase.tResultType = rtNull; const rs: string = ''; tc: tTraceColor = tcIntern ): IInterface; overload; static;
      class function CallRet     ( Scope: TClass;  const Method: string;  const r    : TRect            ; rp: Pointer = nil; rt: TTraceDxBase.tResultType = rtNull; const rs: string = ''; tc: tTraceColor = tcIntern ): IInterface; overload; static;
      class function CallRet     ( Scope: TClass;  const Method: string;  const m    : TMessage;
                                                                          const W    : tMsgParam = paNul;
                                                                          const L    : tMsgParam = paNul; rp: Pointer = nil; rt: TTraceDxBase.tResultType = rtNull; const rs: string = ''; tc: tTraceColor = tcIntern ): IInterface; overload; static;
      class function CallRet     ( Scope: TClass;  const Method: string;  const c    : TClass           ; rp: Pointer = nil; rt: TTraceDxBase.tResultType = rtNull; const rs: string = ''; tc: tTraceColor = tcIntern ): IInterface; overload; static;
      class function CallRet     ( Scope: TClass;  const Method: string;  const o    : TObject          ; rp: Pointer = nil; rt: TTraceDxBase.tResultType = rtNull; const rs: string = ''; tc: tTraceColor = tcIntern ): IInterface; overload; static;
      class function CallRetE<T> ( Scope: TClass;  const Method: string;  const enum : T                ; rp: Pointer = nil; rt: TTraceDxBase.tResultType = rtNull; const rs: string = ''; tc: tTraceColor = tcIntern ): IInterface; overload; static;
      class function CallRetS<T> ( Scope: TClass;  const Method: string;  const &set : T                ; rp: Pointer = nil; rt: TTraceDxBase.tResultType = rtNull; const rs: string = ''; tc: tTraceColor = tcIntern ): IInterface; overload; static;
      class function CallRet<T>  ( Scope: TClass;  const Method: string;  const v    : T;
                                                                          ToString   : TFunc<T,string>  ; rp: Pointer = nil; rt: TTraceDxBase.tResultType = rtNull; const rs: string = ''; tc: tTraceColor = tcIntern ): IInterface; overload; static;
      class function CallRet     ( Scope: TClass;  const Method: string;  const a    : array of const   ; rp: Pointer = nil; rt: TTraceDxBase.tResultType = rtNull; const rs: string = ''; tc: tTraceColor = tcIntern ): IInterface; overload; static;
      class function CallRet<T>  ( Scope: TClass;  const Method: string;  const a    : array of T;
                                                                          const c    : integer;
                                                                          ToString   : TFunc<T,string>  ; rp: Pointer = nil; rt: TTraceDxBase.tResultType = rtNull; const rs: string = ''; tc: tTraceColor = tcIntern ): IInterface; overload; static;

      class function CallRet     ( Scope: TClass;  const Method: string;  const sl   : TStringList;
                                                                          const c    : integer          ; rp: Pointer = nil; rt: TTraceDxBase.tResultType = rtNull; const rs: string = ''; tc: tTraceColor = tcIntern ): IInterface; overload; static;
      class function CallRet     ( Scope: TClass;  const Method: string;  const sl   : TStringList;
                                                                          const c    : integer;
                                                                          ObjToString: TFunc<NativeInt,string>
                                                                                                        ; rp: Pointer = nil; rt: TTraceDxBase.tResultType = rtNull; const rs: string = ''; tc: tTraceColor = tcIntern ): IInterface; overload; static;
      class function CallRet<T>  ( Scope: TClass;  const Method: string;  const l    : TList;
                                                                          const c    : integer;
                                                                          ToString   : TFunc<T,string>  ; rp: Pointer = nil; rt: TTraceDxBase.tResultType = rtNull; const rs: string = ''; tc: tTraceColor = tcIntern ): IInterface; overload; static;
      class function CallRet<T>  ( Scope: TClass;  const Method: string;  const l    : TList<T>;
                                                                          const c    : integer;
                                                                          ToString   : TFunc<T,string>  ; rp: Pointer = nil; rt: TTraceDxBase.tResultType = rtNull; const rs: string = ''; tc: tTraceColor = tcIntern ): IInterface; overload; static;
      class function CallRet<K,V>( Scope: TClass;  const Method: string;  const d    : TDictionary<K,V>;
                                                                          const c    : integer;
                                                                          ToString   : TFunc<K,V,string>; rp: Pointer = nil; rt: TTraceDxBase.tResultType = rtNull; const rs: string = ''; tc: tTraceColor = tcIntern ): IInterface; overload; static;

      (* ... und Objekt zur Erst-Identifikation *)
      class function CallRet     ( Scope: TObject; const Method: string                                 ; rp: Pointer = nil; rt: TTraceDxBase.tResultType = rtNull; const rs: string = ''; tc: tTraceColor = tcIntern ): IInterface; overload; static;
      class function CallRet     ( Scope: TObject; const Method: string;  const s    : string           ; rp: Pointer = nil; rt: TTraceDxBase.tResultType = rtNull; const rs: string = ''; tc: tTraceColor = tcIntern ): IInterface; overload; static;
      class function CallRet     ( Scope: TObject; const Method: string;  const s1,s2: string           ; rp: Pointer = nil; rt: TTraceDxBase.tResultType = rtNull; const rs: string = ''; tc: tTraceColor = tcIntern ): IInterface; overload; static;
      class function CallRet     ( Scope: TObject; const Method: string;  const i    : integer          ; rp: Pointer = nil; rt: TTraceDxBase.tResultType = rtNull; const rs: string = ''; tc: tTraceColor = tcIntern ): IInterface; overload; static;
      class function CallRet     ( Scope: TObject; const Method: string;  const i1,i2: integer          ; rp: Pointer = nil; rt: TTraceDxBase.tResultType = rtNull; const rs: string = ''; tc: tTraceColor = tcIntern ): IInterface; overload; static;
      class function CallRet     ( Scope: TObject; const Method: string;  const i    : int64            ; rp: Pointer = nil; rt: TTraceDxBase.tResultType = rtNull; const rs: string = ''; tc: tTraceColor = tcIntern ): IInterface; overload; static;
      class function CallRet     ( Scope: TObject; const Method: string;  const c    : cardinal         ; rp: Pointer = nil; rt: TTraceDxBase.tResultType = rtNull; const rs: string = ''; tc: tTraceColor = tcIntern ): IInterface; overload; static;
      class function CallRet     ( Scope: TObject; const Method: string;  const c1,c2: cardinal         ; rp: Pointer = nil; rt: TTraceDxBase.tResultType = rtNull; const rs: string = ''; tc: tTraceColor = tcIntern ): IInterface; overload; static;
      class function CallRet     ( Scope: TObject; const Method: string;  const b    : boolean          ; rp: Pointer = nil; rt: TTraceDxBase.tResultType = rtNull; const rs: string = ''; tc: tTraceColor = tcIntern ): IInterface; overload; static;
      class function CallRet     ( Scope: TObject; const Method: string;  const b1,b2: boolean          ; rp: Pointer = nil; rt: TTraceDxBase.tResultType = rtNull; const rs: string = ''; tc: tTraceColor = tcIntern ): IInterface; overload; static;
      class function CallRet     ( Scope: TObject; const Method: string;  const f    : single           ; rp: Pointer = nil; rt: TTraceDxBase.tResultType = rtNull; const rs: string = ''; tc: tTraceColor = tcIntern ): IInterface; overload; static;
      class function CallRet     ( Scope: TObject; const Method: string;  const f    : double           ; rp: Pointer = nil; rt: TTraceDxBase.tResultType = rtNull; const rs: string = ''; tc: tTraceColor = tcIntern ): IInterface; overload; static;
      class function CallRet     ( Scope: TObject; const Method: string;  const f1,f2: double           ; rp: Pointer = nil; rt: TTraceDxBase.tResultType = rtNull; const rs: string = ''; tc: tTraceColor = tcIntern ): IInterface; overload; static;
      class function CallRet     ( Scope: TObject; const Method: string;  const p    : pointer          ; rp: Pointer = nil; rt: TTraceDxBase.tResultType = rtNull; const rs: string = ''; tc: tTraceColor = tcIntern ): IInterface; overload; static;
      class function CallRet     ( Scope: TObject; const Method: string;  const p1,p2: pointer          ; rp: Pointer = nil; rt: TTraceDxBase.tResultType = rtNull; const rs: string = ''; tc: tTraceColor = tcIntern ): IInterface; overload; static;
      class function CallRet     ( Scope: TObject; const Method: string;  const p    : TPoint           ; rp: Pointer = nil; rt: TTraceDxBase.tResultType = rtNull; const rs: string = ''; tc: tTraceColor = tcIntern ): IInterface; overload; static;
      class function CallRet     ( Scope: TObject; const Method: string;  const p1,p2: TPoint           ; rp: Pointer = nil; rt: TTraceDxBase.tResultType = rtNull; const rs: string = ''; tc: tTraceColor = tcIntern ): IInterface; overload; static;
      class function CallRet     ( Scope: TObject; const Method: string;  const r    : TRect            ; rp: Pointer = nil; rt: TTraceDxBase.tResultType = rtNull; const rs: string = ''; tc: tTraceColor = tcIntern ): IInterface; overload; static;
      class function CallRet     ( Scope: TObject; const Method: string;  const m    : TMessage;
                                                                          const W    : tMsgParam = paNul;
                                                                          const L    : tMsgParam = paNul; rp: Pointer = nil; rt: TTraceDxBase.tResultType = rtNull; const rs: string = ''; tc: tTraceColor = tcIntern ): IInterface; overload; static;
      class function CallRet     ( Scope: TObject; const Method: string;  const c    : TClass           ; rp: Pointer = nil; rt: TTraceDxBase.tResultType = rtNull; const rs: string = ''; tc: tTraceColor = tcIntern ): IInterface; overload; static;
      class function CallRet     ( Scope: TObject; const Method: string;  const o    : TObject          ; rp: Pointer = nil; rt: TTraceDxBase.tResultType = rtNull; const rs: string = ''; tc: tTraceColor = tcIntern ): IInterface; overload; static;
      class function CallRetE<T> ( Scope: TObject; const Method: string;  const enum : T                ; rp: Pointer = nil; rt: TTraceDxBase.tResultType = rtNull; const rs: string = ''; tc: tTraceColor = tcIntern ): IInterface; overload; static;
      class function CallRetS<T> ( Scope: TObject; const Method: string;  const &set : T                ; rp: Pointer = nil; rt: TTraceDxBase.tResultType = rtNull; const rs: string = ''; tc: tTraceColor = tcIntern ): IInterface; overload; static;
      class function CallRet<T>  ( Scope: TObject; const Method: string;  const v    : T;
                                                                          ToString   : TFunc<T,string>  ; rp: Pointer = nil; rt: TTraceDxBase.tResultType = rtNull; const rs: string = ''; tc: tTraceColor = tcIntern ): IInterface; overload; static;
      class function CallRet     ( Scope: TObject; const Method: string;  const a    : array of const   ; rp: Pointer = nil; rt: TTraceDxBase.tResultType = rtNull; const rs: string = ''; tc: tTraceColor = tcIntern ): IInterface; overload; static;
      class function CallRet<T>  ( Scope: TObject; const Method: string;  const a    : array of T;
                                                                          const c    : integer;
                                                                          ToString   : TFunc<T,string>  ; rp: Pointer = nil; rt: TTraceDxBase.tResultType = rtNull; const rs: string = ''; tc: tTraceColor = tcIntern ): IInterface; overload; static;

      class function CallRet     ( Scope: TObject; const Method: string;  const sl   : TStringList;
                                                                          const c    : integer          ; rp: Pointer = nil; rt: TTraceDxBase.tResultType = rtNull; const rs: string = ''; tc: tTraceColor = tcIntern ): IInterface; overload; static;
      class function CallRet     ( Scope: TObject; const Method: string;  const sl   : TStringList;
                                                                          const c    : integer;
                                                                          ObjToString: TFunc<NativeInt,string>
                                                                                                        ; rp: Pointer = nil; rt: TTraceDxBase.tResultType = rtNull; const rs: string = ''; tc: tTraceColor = tcIntern ): IInterface; overload; static;
      class function CallRet<T>  ( Scope: TObject; const Method: string;  const l    : TList;
                                                                          const c    : integer;
                                                                          ToString   : TFunc<T,string>  ; rp: Pointer = nil; rt: TTraceDxBase.tResultType = rtNull; const rs: string = ''; tc: tTraceColor = tcIntern ): IInterface; overload; static;
      class function CallRet<T>  ( Scope: TObject; const Method: string;  const l    : TList<T>;
                                                                          const c    : integer;
                                                                          ToString   : TFunc<T,string>  ; rp: Pointer = nil; rt: TTraceDxBase.tResultType = rtNull; const rs: string = ''; tc: tTraceColor = tcIntern ): IInterface; overload; static;
      class function CallRet<K,V>( Scope: TObject; const Method: string;  const d    : TDictionary<K,V>;
                                                                          const c    : integer;
                                                                          ToString   : TFunc<K,V,string>; rp: Pointer = nil; rt: TTraceDxBase.tResultType = rtNull; const rs: string = ''; tc: tTraceColor = tcIntern ): IInterface; overload; static;

      (* Call mit String und ggf Parametern, inc Call-Ebene. Verberge alle Traces bis Return auf diese Ebene *)
      class function CallHide     (                 const Method: string                                 ; tc: tTraceColor = tcIntern ): IInterface; overload; static;
      class function CallHide     (                 const Method: string;  const s    : string           ; tc: tTraceColor = tcIntern ): IInterface; overload; static;
      class function CallHide     (                 const Method: string;  const s1,s2: string           ; tc: tTraceColor = tcIntern ): IInterface; overload; static;
      class function CallHide     (                 const Method: string;  const i    : integer          ; tc: tTraceColor = tcIntern ): IInterface; overload; static;
      class function CallHide     (                 const Method: string;  const i1,i2: integer          ; tc: tTraceColor = tcIntern ): IInterface; overload; static;
      class function CallHide     (                 const Method: string;  const i    : int64            ; tc: tTraceColor = tcIntern ): IInterface; overload; static;
      class function CallHide     (                 const Method: string;  const c    : cardinal         ; tc: tTraceColor = tcIntern ): IInterface; overload; static;
      class function CallHide     (                 const Method: string;  const c1,c2: cardinal         ; tc: tTraceColor = tcIntern ): IInterface; overload; static;
      class function CallHide     (                 const Method: string;  const b    : boolean          ; tc: tTraceColor = tcIntern ): IInterface; overload; static;
      class function CallHide     (                 const Method: string;  const b1,b2: boolean          ; tc: tTraceColor = tcIntern ): IInterface; overload; static;
      class function CallHide     (                 const Method: string;  const f    : single           ; tc: tTraceColor = tcIntern ): IInterface; overload; static;
      class function CallHide     (                 const Method: string;  const f    : double           ; tc: tTraceColor = tcIntern ): IInterface; overload; static;
      class function CallHide     (                 const Method: string;  const f1,f2: double           ; tc: tTraceColor = tcIntern ): IInterface; overload; static;
      class function CallHide     (                 const Method: string;  const p    : pointer          ; tc: tTraceColor = tcIntern ): IInterface; overload; static;
      class function CallHide     (                 const Method: string;  const p1,p2: pointer          ; tc: tTraceColor = tcIntern ): IInterface; overload; static;
      class function CallHide     (                 const Method: string;  const p    : TPoint           ; tc: tTraceColor = tcIntern ): IInterface; overload; static;
      class function CallHide     (                 const Method: string;  const p1,p2: TPoint           ; tc: tTraceColor = tcIntern ): IInterface; overload; static;
      class function CallHide     (                 const Method: string;  const r    : TRect            ; tc: tTraceColor = tcIntern ): IInterface; overload; static;
      class function CallHide     (                 const Method: string;  const m    : TMessage;
                                                                           const W    : tMsgParam = paNul;
                                                                           const L    : tMsgParam = paNul; tc: tTraceColor = tcIntern ): IInterface; overload; static;
      class function CallHide     (                 const Method: string;  const c    : TClass           ; tc: tTraceColor = tcIntern ): IInterface; overload; static;
      class function CallHide     (                 const Method: string;  const o    : TObject          ; tc: tTraceColor = tcIntern ): IInterface; overload; static;
      class function CallHideE<T> (                 const Method: string;  const enum : T                ; tc: tTraceColor = tcIntern ): IInterface; overload; static;
      class function CallHideS<T> (                 const Method: string;  const &set : T                ; tc: tTraceColor = tcIntern ): IInterface; overload; static;
      class function CallHide<T>  (                 const Method: string;  const v    : T;
                                                                           ToString   : TFunc<T,string>  ; tc: tTraceColor = tcIntern ): IInterface; overload; static;
      class function CallHide     (                 const Method: string;  const a    : array of const   ; tc: tTraceColor = tcIntern ): IInterface; overload; static;
      class function CallHide<T>  (                 const Method: string;  const a    : array of T;
                                                                           const c    : integer;
                                                                           ToString   : TFunc<T,string>  ; tc: tTraceColor = tcIntern ): IInterface; overload; static;

      class function CallHide     (                 const Method: string;  const sl   : TStringList;
                                                                           const c    : integer          ; tc: tTraceColor = tcIntern ): IInterface; overload; static;
      class function CallHide     (                 const Method: string;  const sl   : TStringList;
                                                                           const c    : integer;
                                                                           ObjToString: TFunc<NativeInt,string>
                                                                                                         ; tc: tTraceColor = tcIntern ): IInterface; overload; static;
      class function CallHide<T>  (                 const Method: string;  const l    : TList;
                                                                           const c    : integer;
                                                                           ToString   : TFunc<T,string>  ; tc: tTraceColor = tcIntern ): IInterface; overload; static;
      class function CallHide<T>  (                 const Method: string;  const l    : TList<T>;
                                                                           const c    : integer;
                                                                           ToString   : TFunc<T,string>  ; tc: tTraceColor = tcIntern ): IInterface; overload; static;
      class function CallHide<K,V>(                 const Method: string;  const d    : TDictionary<K,V>;
                                                                           const c    : integer;
                                                                           ToString   : TFunc<K,V,string>; tc: tTraceColor = tcIntern ): IInterface; overload; static;

      (* ... und Class zur Erst-Identifikation *)
      class function CallHide     ( Scope: TClass;  const Method: string                                 ; tc: tTraceColor = tcIntern ): IInterface; overload; static;
      class function CallHide     ( Scope: TClass;  const Method: string;  const s    : string           ; tc: tTraceColor = tcIntern ): IInterface; overload; static;
      class function CallHide     ( Scope: TClass;  const Method: string;  const s1,s2: string           ; tc: tTraceColor = tcIntern ): IInterface; overload; static;
      class function CallHide     ( Scope: TClass;  const Method: string;  const i    : integer          ; tc: tTraceColor = tcIntern ): IInterface; overload; static;
      class function CallHide     ( Scope: TClass;  const Method: string;  const i1,i2: integer          ; tc: tTraceColor = tcIntern ): IInterface; overload; static;
      class function CallHide     ( Scope: TClass;  const Method: string;  const i    : int64            ; tc: tTraceColor = tcIntern ): IInterface; overload; static;
      class function CallHide     ( Scope: TClass;  const Method: string;  const c    : cardinal         ; tc: tTraceColor = tcIntern ): IInterface; overload; static;
      class function CallHide     ( Scope: TClass;  const Method: string;  const c1,c2: cardinal         ; tc: tTraceColor = tcIntern ): IInterface; overload; static;
      class function CallHide     ( Scope: TClass;  const Method: string;  const b    : boolean          ; tc: tTraceColor = tcIntern ): IInterface; overload; static;
      class function CallHide     ( Scope: TClass;  const Method: string;  const b1,b2: boolean          ; tc: tTraceColor = tcIntern ): IInterface; overload; static;
      class function CallHide     ( Scope: TClass;  const Method: string;  const f    : single           ; tc: tTraceColor = tcIntern ): IInterface; overload; static;
      class function CallHide     ( Scope: TClass;  const Method: string;  const f    : double           ; tc: tTraceColor = tcIntern ): IInterface; overload; static;
      class function CallHide     ( Scope: TClass;  const Method: string;  const f1,f2: double           ; tc: tTraceColor = tcIntern ): IInterface; overload; static;
      class function CallHide     ( Scope: TClass;  const Method: string;  const p    : pointer          ; tc: tTraceColor = tcIntern ): IInterface; overload; static;
      class function CallHide     ( Scope: TClass;  const Method: string;  const p1,p2: pointer          ; tc: tTraceColor = tcIntern ): IInterface; overload; static;
      class function CallHide     ( Scope: TClass;  const Method: string;  const p    : TPoint           ; tc: tTraceColor = tcIntern ): IInterface; overload; static;
      class function CallHide     ( Scope: TClass;  const Method: string;  const p1,p2: TPoint           ; tc: tTraceColor = tcIntern ): IInterface; overload; static;
      class function CallHide     ( Scope: TClass;  const Method: string;  const r    : TRect            ; tc: tTraceColor = tcIntern ): IInterface; overload; static;
      class function CallHide     ( Scope: TClass;  const Method: string;  const m    : TMessage;
                                                                           const W    : tMsgParam = paNul;
                                                                           const L    : tMsgParam = paNul; tc: tTraceColor = tcIntern ): IInterface; overload; static;
      class function CallHide     ( Scope: TClass;  const Method: string;  const c    : TClass           ; tc: tTraceColor = tcIntern ): IInterface; overload; static;
      class function CallHide     ( Scope: TClass;  const Method: string;  const o    : TObject          ; tc: tTraceColor = tcIntern ): IInterface; overload; static;
      class function CallHideE<T> ( Scope: TClass;  const Method: string;  const enum : T                ; tc: tTraceColor = tcIntern ): IInterface; overload; static;
      class function CallHideS<T> ( Scope: TClass;  const Method: string;  const &set : T                ; tc: tTraceColor = tcIntern ): IInterface; overload; static;
      class function CallHide<T>  ( Scope: TClass;  const Method: string;  const v    : T;
                                                                           ToString   : TFunc<T,string>  ; tc: tTraceColor = tcIntern ): IInterface; overload; static;
      class function CallHide     ( Scope: TClass;  const Method: string;  const a    : array of const   ; tc: tTraceColor = tcIntern ): IInterface; overload; static;
      class function CallHide<T>  ( Scope: TClass;  const Method: string;  const a    : array of T;
                                                                           const c    : integer;
                                                                           ToString   : TFunc<T,string>  ; tc: tTraceColor = tcIntern ): IInterface; overload; static;

      class function CallHide     ( Scope: TClass;  const Method: string;  const sl   : TStringList;
                                                                           const c    : integer          ; tc: tTraceColor = tcIntern ): IInterface; overload; static;
      class function CallHide     ( Scope: TClass;  const Method: string;  const sl   : TStringList;
                                                                           const c    : integer;
                                                                           ObjToString: TFunc<NativeInt,string>
                                                                                                         ; tc: tTraceColor = tcIntern ): IInterface; overload; static;
      class function CallHide<T>  ( Scope: TClass;  const Method: string;  const l    : TList;
                                                                           const c    : integer;
                                                                           ToString   : TFunc<T,string>  ; tc: tTraceColor = tcIntern ): IInterface; overload; static;
      class function CallHide<T>  ( Scope: TClass;  const Method: string;  const l    : TList<T>;
                                                                           const c    : integer;
                                                                           ToString   : TFunc<T,string>  ; tc: tTraceColor = tcIntern ): IInterface; overload; static;
      class function CallHide<K,V>( Scope: TClass;  const Method: string;  const d    : TDictionary<K,V>;
                                                                           const c    : integer;
                                                                           ToString   : TFunc<K,V,string>; tc: tTraceColor = tcIntern ): IInterface; overload; static;

      (* ... und Objekt zur Erst-Identifikation *)
      class function CallHide     ( Scope: TObject; const Method: string                                 ; tc: tTraceColor = tcIntern ): IInterface; overload; static;
      class function CallHide     ( Scope: TObject; const Method: string;  const s    : string           ; tc: tTraceColor = tcIntern ): IInterface; overload; static;
      class function CallHide     ( Scope: TObject; const Method: string;  const s1,s2: string           ; tc: tTraceColor = tcIntern ): IInterface; overload; static;
      class function CallHide     ( Scope: TObject; const Method: string;  const i    : integer          ; tc: tTraceColor = tcIntern ): IInterface; overload; static;
      class function CallHide     ( Scope: TObject; const Method: string;  const i1,i2: integer          ; tc: tTraceColor = tcIntern ): IInterface; overload; static;
      class function CallHide     ( Scope: TObject; const Method: string;  const i    : int64            ; tc: tTraceColor = tcIntern ): IInterface; overload; static;
      class function CallHide     ( Scope: TObject; const Method: string;  const c    : cardinal         ; tc: tTraceColor = tcIntern ): IInterface; overload; static;
      class function CallHide     ( Scope: TObject; const Method: string;  const c1,c2: cardinal         ; tc: tTraceColor = tcIntern ): IInterface; overload; static;
      class function CallHide     ( Scope: TObject; const Method: string;  const b    : boolean          ; tc: tTraceColor = tcIntern ): IInterface; overload; static;
      class function CallHide     ( Scope: TObject; const Method: string;  const b1,b2: boolean          ; tc: tTraceColor = tcIntern ): IInterface; overload; static;
      class function CallHide     ( Scope: TObject; const Method: string;  const f    : single           ; tc: tTraceColor = tcIntern ): IInterface; overload; static;
      class function CallHide     ( Scope: TObject; const Method: string;  const f    : double           ; tc: tTraceColor = tcIntern ): IInterface; overload; static;
      class function CallHide     ( Scope: TObject; const Method: string;  const f1,f2: double           ; tc: tTraceColor = tcIntern ): IInterface; overload; static;
      class function CallHide     ( Scope: TObject; const Method: string;  const p    : pointer          ; tc: tTraceColor = tcIntern ): IInterface; overload; static;
      class function CallHide     ( Scope: TObject; const Method: string;  const p1,p2: pointer          ; tc: tTraceColor = tcIntern ): IInterface; overload; static;
      class function CallHide     ( Scope: TObject; const Method: string;  const p    : TPoint           ; tc: tTraceColor = tcIntern ): IInterface; overload; static;
      class function CallHide     ( Scope: TObject; const Method: string;  const p1,p2: TPoint           ; tc: tTraceColor = tcIntern ): IInterface; overload; static;
      class function CallHide     ( Scope: TObject; const Method: string;  const r    : TRect            ; tc: tTraceColor = tcIntern ): IInterface; overload; static;
      class function CallHide     ( Scope: TObject; const Method: string;  const m    : TMessage;
                                                                           const W    : tMsgParam = paNul;
                                                                           const L    : tMsgParam = paNul; tc: tTraceColor = tcIntern ): IInterface; overload; static;
      class function CallHide     ( Scope: TObject; const Method: string;  const c    : TClass           ; tc: tTraceColor = tcIntern ): IInterface; overload; static;
      class function CallHide     ( Scope: TObject; const Method: string;  const o    : TObject          ; tc: tTraceColor = tcIntern ): IInterface; overload; static;
      class function CallHideE<T> ( Scope: TObject; const Method: string;  const enum : T                ; tc: tTraceColor = tcIntern ): IInterface; overload; static;
      class function CallHideS<T> ( Scope: TObject; const Method: string;  const &set : T                ; tc: tTraceColor = tcIntern ): IInterface; overload; static;
      class function CallHide<T>  ( Scope: TObject; const Method: string;  const v    : T;
                                                                           ToString   : TFunc<T,string>  ; tc: tTraceColor = tcIntern ): IInterface; overload; static;
      class function CallHide     ( Scope: TObject; const Method: string;  const a    : array of const   ; tc: tTraceColor = tcIntern ): IInterface; overload; static;
      class function CallHide<T>  ( Scope: TObject; const Method: string;  const a    : array of T;
                                                                           const c    : integer;
                                                                           ToString   : TFunc<T,string>  ; tc: tTraceColor = tcIntern ): IInterface; overload; static;

      class function CallHide     ( Scope: TObject; const Method: string;  const sl   : TStringList;
                                                                           const c    : integer          ; tc: tTraceColor = tcIntern ): IInterface; overload; static;
      class function CallHide     ( Scope: TObject; const Method: string;  const sl   : TStringList;
                                                                           const c    : integer;
                                                                           ObjToString: TFunc<NativeInt,string>
                                                                                                         ; tc: tTraceColor = tcIntern ): IInterface; overload; static;
      class function CallHide<T>  ( Scope: TObject; const Method: string;  const l    : TList;
                                                                           const c    : integer;
                                                                           ToString   : TFunc<T,string>  ; tc: tTraceColor = tcIntern ): IInterface; overload; static;
      class function CallHide<T>  ( Scope: TObject; const Method: string;  const l    : TList<T>;
                                                                           const c    : integer;
                                                                           ToString   : TFunc<T,string>  ; tc: tTraceColor = tcIntern ): IInterface; overload; static;
      class function CallHide<K,V>( Scope: TObject; const Method: string;  const d    : TDictionary<K,V>;
                                                                           const c    : integer;
                                                                           ToString   : TFunc<K,V,string>; tc: tTraceColor = tcIntern ): IInterface; overload; static;

      (* Ergänzung zur vorigen Zeile *)
      class procedure Add     ( const Method: string                                  ); overload; static;
      class procedure Add     ( const Method: string;  const s    : string            ); overload; static;
      class procedure Add     ( const Method: string;  const s1,s2: string            ); overload; static;
      class procedure Add     ( const Method: string;  const i    : integer           ); overload; static;
      class procedure Add     ( const Method: string;  const i1,i2: integer           ); overload; static;
      class procedure Add     ( const Method: string;  const i    : int64             ); overload; static;
      class procedure Add     ( const Method: string;  const c    : cardinal          ); overload; static;
      class procedure Add     ( const Method: string;  const c1,c2: cardinal          ); overload; static;
      class procedure Add     ( const Method: string;  const b    : boolean           ); overload; static;
      class procedure Add     ( const Method: string;  const b1,b2: boolean           ); overload; static;
      class procedure Add     ( const Method: string;  const f    : single            ); overload; static;
      class procedure Add     ( const Method: string;  const f    : double            ); overload; static;
      class procedure Add     ( const Method: string;  const f1,f2: double            ); overload; static;
      class procedure Add     ( const Method: string;  const p    : pointer           ); overload; static;
      class procedure Add     ( const Method: string;  const p1,p2: pointer           ); overload; static;
      class procedure Add     ( const Method: string;  const p    : TPoint            ); overload; static;
      class procedure Add     ( const Method: string;  const p1,p2: TPoint            ); overload; static;
      class procedure Add     ( const Method: string;  const r    : TRect             ); overload; static;
      class procedure Add     ( const Method: string;  const m    : TMessage;
                                                       const W    : tMsgParam = paNul;
                                                       const L    : tMsgParam = paNul ); overload; static;
      class procedure Add     ( const Method: string;  const c    : TClass            ); overload; static;
      class procedure Add     ( const Method: string;  const o    : TObject           ); overload; static;
      class procedure AddE<T> ( const Method: string;  const enum : T                 ); overload; static;
      class procedure AddS<T> ( const Method: string;  const &set : T                 ); overload; static;
      class procedure Add<T>  ( const Method: string;  const v    : T;
                                                       ToString   : TFunc<T,string>   ); overload; static;
      class procedure Add     ( const Method: string;  const a    : array of const    ); overload; static;
      class procedure Add<T>  ( const Method: string;  const a    : array of T;
                                                       const c    : integer;
                                                       ToString   : TFunc<T,string>   ); overload; static;

      class procedure Add     ( const Method: string;  const sl   : TStringList;
                                                       const c    : integer           ); overload; static;
      class procedure Add     ( const Method: string;  const sl   : TStringList;
                                                       const c    : integer;
                                                       ObjToString: TFunc<NativeInt,string>
                                                                                      ); overload; static;
      class procedure Add<T>  ( const Method: string;  const l    : TList;
                                                       const c    : integer;
                                                       ToString   : TFunc<T,string>   ); overload; static;
      class procedure Add<T>  ( const Method: string;  const l    : TList<T>;
                                                       const c    : integer;
                                                       ToString   : TFunc<T,string>   ); overload; static;
      class procedure Add<K,V>( const Method: string;  const d    : TDictionary<K,V>;
                                                       const c    : integer;
                                                       ToString   : TFunc<K,V,string> ); overload; static;