uCCRefreshTitleFieldOnChange.pas

{ So richtig ersichtlich ist es nicht für was das zu gebrauchen aber here we go…  }

{ Diese Klasse speichert das OnChange Event eines TField-Objektes und
ersetzt das OnChange-Event mit einer eigenen Funktion. Die eigene
Funktion ruft das original OnChange-Event auf und das eigene
OnAlert-Event auf, so es denn vorhanden ist. }

unit uCCRefreshTitleFieldOnChange;


{der interface-bereich ist das was bei c in den header-dateien steht }
interface


uses SysUtils, Windows, Classes, SuperGlobal, DB;

{ TField ist ein Datenbankfeld einer Datenbankanfrage und ^TField ist
ein Pointer auf ein solches Feld und mit Type _PTField definiert man
das als Datentype. }
Type _PTField = ^TField;

{ Eine Klasse das von TObject erbt. TObject ist eine supersimple
Basisklasse von der man Erben kann. }
Type TRefreshTitleOnFieldChange = Class(TObject)
        { Standard-Konstruktor }
	Constructor Create();	overload;
        { Destruktor, obvious ;-) }
	Destructor Destroy();	override;
	Strict Private
                { Das Datenbankfeld das Überwacht werden soll }
		m_MyField: _PTField;
		m_DynEvent_Orig_OnChange: Procedure(Sender: TField) Of Object;
                { Das Callback Ereignis das aufgerufen werden soll,
		wenn sich etwas an dem Datenbankfeld ändert. }
		m_NotifyEvent: TNotifyEvent;

                { Der setter für das Datenbankfeld. Speichert das
                Feld, Speichert das OnChange-Event des TField-Objektes
                in m_DynEvent_Orig_OnChange und setzt das
                OnChange-Event des TField-Objekt auf p_DynEvent_NewOnChange }
		Procedure Setm_MyField(const Value: _PTField);
                { OnChange-Event für ein TField-Objekt. Ruft die
                Funktion m_DynEvent_Orig_OnChange und m_NotifyEvent
                auf, so sie denn vorhanden sind. }
		Procedure p_DynEvent_NewOnChange(Sender: TField);
	Public
		Constructor Create(const Field: _PTField);	overload;
                { Eine property ist eine Art Variable das zwei
                attribute read und write hat, man kann bei read und
                write entweder eine Funktion oder eine Variable
                angeben. Wenn man bei read eine funktion angibt dann
                muss diese so aussehen: 'function funktionsname() :
                datentyp'. Wenn man bei write eine Prozedur angibt
                muss diese so aussehen: 'procedure
                funktionsname(parameter : datentyp)'. }
                { Read heist das er von der Variable m_MyField liest
                und Write heist das er die Prozedur Setm_MyField mit
                einem Parameter aufruft. }
                Property Field: _PTField Read m_MyField Write Setm_MyField;
                { read liest von der Variable m_NotifyEvent und write
                schreibt in die Variable m_NotifyEvent}
		Property OnAlert: TNotifyEvent		Read m_NotifyEvent Write m_NotifyEvent;
end;


{der implementation-bereich ist das was bei c in der c-datei steht }
implementation

{ TRefreshTitleOnFieldChange }

constructor TRefreshTitleOnFieldChange.Create;
begin
	inherited Create();
	m_MyField:= NIL;
	m_DynEvent_Orig_OnChange:= NIL;
end;


constructor TRefreshTitleOnFieldChange.Create(const Field: _PTField);
begin
	Create();
	Self.Field:= Field;
end;


destructor TRefreshTitleOnFieldChange.Destroy;
begin
	Self.OnAlert:= NIL;
	inherited;
end;


procedure TRefreshTitleOnFieldChange.p_DynEvent_NewOnChange(Sender: TField);
begin
        { Assigned liefert true zurück wenn die variable nicht NIL ist }
	If Assigned(m_DynEvent_Orig_OnChange) Then
                { Das original OnChange-Event aus dem TField wird aufgerufen }
		m_DynEvent_Orig_OnChange(Sender);
		
	If Assigned(Self.OnAlert) Then
                { Das eigene OnAlert-Event wird aufgerufen }
		Self.OnAlert(Self);
end;


procedure TRefreshTitleOnFieldChange.Setm_MyField(const Value: _PTField);
begin
	m_MyField:= Value;
	If Assigned(m_MyField.OnChange) Then
		m_DynEvent_Orig_OnChange:= m_MyField.OnChange;

	m_MyField.OnChange:= p_DynEvent_NewOnChange;
end;


end.