jcl-checkins-diff Mailing List for JEDI Code Library (Page 29)

SourceForge Headquarters 1320 Columbia Street Suite 310 San Diego, CA 92101 +1 (858) 422-6466

Revision: 3192
          http://jcl.svn.sourceforge.net/jcl/?rev=3192&view=rev
Author:   outchy
Date:     2010-02-18 21:16:35 +0000 (Thu, 18 Feb 2010)

Log Message:
-----------
New classes to help event broadcasts.

Modified Paths:
--------------
    trunk/jcl/source/common/JclNotify.pas

Modified: trunk/jcl/source/common/JclNotify.pas
===================================================================

--- trunk/jcl/source/common/JclNotify.pas	2010-02-18 11:15:10 UTC (rev 3191)
+++ trunk/jcl/source/common/JclNotify.pas	2010-02-18 21:16:35 UTC (rev 3192)
@@ -24,7 +24,7 @@
 {                                                                                                  }
 {**************************************************************************************************}
 {                                                                                                  }
-{ Last modified: $Date::                                                                         $ }
+{ Last modified: $Date::                                                                        $ }
 { Revision:      $Rev::                                                                          $ }
 { Author:        $Author::                                                                       $ }
 {                                                                                                  }
@@ -101,6 +101,72 @@
     procedure Remove(listener: IJclListener); stdcall;
   end;
 
+type
+  TJclMethodArray = array of TMethod;
+
+  // base class for all object methods broadcasts
+  TJclMethodBroadCast = class
+  protected
+    FHandlers: TJclMethodArray;
+    FHandlerCount: Integer;
+    function GetHandler(Index: Integer): TMethod;
+  public
+    function AddHandler(const AHandler: TMethod): Integer;
+    procedure RemoveHandler(const AHandler: TMethod);
+    procedure DeleteHandler(Index: Integer);
+    property HandlerCount: Integer read FHandlerCount;
+  end;
+
+  // This class broadcasts a notification event to a list of handlers
+  TJclNotifyEventBroadcast = class(TJclMethodBroadCast)
+  protected
+    function GetHandler(Index: Integer): TNotifyEvent;
+  public
+    function AddHandler(const AHandler: TNotifyEvent): Integer;
+    procedure RemoveHandler(const AHandler: TNotifyEvent);
+    procedure Notify(Sender: TObject);
+    property Handlers[Index: Integer]: TNotifyEvent read GetHandler;
+  end;
+
+  TJclProcedureEvent = procedure of object;
+
+  // This class broadcasts an event to a list of handlers
+  TJclProcedureEventBroadcast = class(TJclMethodBroadCast)
+  protected
+    function GetHandler(Index: Integer): TJclProcedureEvent;
+  public
+    function AddHandler(const AHandler: TJclProcedureEvent): Integer;
+    procedure RemoveHandler(const AHandler: TJclProcedureEvent);
+    procedure CallAllProcedures;
+    property Handlers[Index: Integer]: TJclProcedureEvent read GetHandler;
+  end;
+
+  TJclBooleanProcedureEvent = procedure(Value: Boolean) of object;
+
+  // This class broadcasts an event to a list of handlers
+  TJclBooleanProcedureEventBroadcast = class(TJclMethodBroadCast)
+  protected
+    function GetHandler(Index: Integer): TJclBooleanProcedureEvent;
+  public
+    function AddHandler(const AHandler: TJclBooleanProcedureEvent): Integer;
+    procedure RemoveHandler(const AHandler: TJclBooleanProcedureEvent);
+    procedure CallAllProcedures(Value: Boolean);
+    property Handlers[Index: Integer]: TJclBooleanProcedureEvent read GetHandler;
+  end;
+
+  TJclBooleanEvent = function: Boolean of object;
+
+  // This class broadcasts a predicate to a list of handlers
+  TJclBooleanEventBroadcast = class(TJclMethodBroadCast)
+  protected
+    function GetHandler(Index: Integer): TJclBooleanEvent;
+  public
+    function AddHandler(const AHandler: TJclBooleanEvent): Integer;
+    procedure RemoveHandler(const AHandler: TJclBooleanEvent);
+    function LogicalAnd: Boolean;
+    property Handlers[Index: Integer]: TJclBooleanEvent read GetHandler;
+  end;
+
 {$IFDEF UNITVERSIONING}
 const
   UnitVersioning: TUnitVersionInfo = (
@@ -202,6 +268,169 @@
   // do nothing; descendants should override this method to process incoming notifications
 end;
 
+//=== { TNotifyEventBroadcast } ==============================================
+
+function TJclMethodBroadcast.AddHandler(
+  const AHandler: TMethod): Integer;
+var
+  HandlerLength: Integer;
+begin
+  HandlerLength := Length(FHandlers);
+  if FHandlerCount >= HandlerLength then
+  begin
+    if HandlerLength > 0 then
+      HandlerLength := HandlerLength * 2
+    else
+      HandlerLength := 4;
+    SetLength(FHandlers, HandlerLength);
+  end;
+  Result := FHandlerCount;
+  Inc(FHandlerCount);
+  FHandlers[Result] := AHandler;
+end;
+
+procedure TJclMethodBroadcast.DeleteHandler(Index: Integer);
+var
+  I: Integer;
+  HandlerLength: Integer;
+begin
+  for I := Index to FHandlerCount - 2 do
+    FHandlers[I] := FHandlers[I + 1];
+
+  HandlerLength := Length(FHandlers);
+  Dec(FHandlerCount);
+  if (FHandlerCount > 0) and ((2 * FHandlerCount) < HandlerLength) then
+  begin
+    HandlerLength := HandlerLength div 2;
+    SetLength(FHandlers, HandlerLength);
+  end;
+end;
+
+function TJclMethodBroadcast.GetHandler(Index: Integer): TMethod;
+begin
+  Result := FHandlers[Index];
+end;
+
+procedure TJclMethodBroadcast.RemoveHandler(const AHandler: TMethod);
+var
+  Index: Integer;
+begin
+  for Index := FHandlerCount - 1 downto 0 do
+    if (TMethod(FHandlers[Index]).Code = TMethod(AHandler).Code) and
+       (TMethod(FHandlers[Index]).Data = TMethod(AHandler).Data) then
+      DeleteHandler(Index);
+end;
+
+//=== { TJclNotifyEventBroadcast } ===========================================
+
+function TJclNotifyEventBroadcast.AddHandler(
+  const AHandler: TNotifyEvent): Integer;
+begin
+  Result := inherited AddHandler(TMethod(AHandler));
+end;
+
+function TJclNotifyEventBroadcast.GetHandler(Index: Integer): TNotifyEvent;
+begin
+  Result := TNotifyEvent(inherited GetHandler(Index));
+end;
+
+procedure TJclNotifyEventBroadcast.Notify(Sender: TObject);
+var
+  Index: Integer;
+begin
+  for Index := 0 to FHandlerCount - 1 do
+    TNotifyEvent(FHandlers[Index])(Sender);
+end;
+
+procedure TJclNotifyEventBroadcast.RemoveHandler(const AHandler: TNotifyEvent);
+begin
+  inherited RemoveHandler(TMethod(AHandler));
+end;
+
+//=== { TJclProcedureBroadcast } =============================================
+
+function TJclProcedureEventBroadcast.AddHandler(
+  const AHandler: TJclProcedureEvent): Integer;
+begin
+  Result := inherited AddHandler(TMethod(AHandler));
+end;
+
+function TJclProcedureEventBroadcast.GetHandler(Index: Integer): TJclProcedureEvent;
+begin
+  Result := TJclProcedureEvent(inherited GetHandler(Index));
+end;
+
+procedure TJclProcedureEventBroadcast.CallAllProcedures;
+var
+  Index: Integer;
+begin
+  for Index := 0 to FHandlerCount - 1 do
+    TJclProcedureEvent(FHandlers[Index]);
+end;
+
+procedure TJclProcedureEventBroadcast.RemoveHandler(const AHandler: TJclProcedureEvent);
+begin
+  inherited RemoveHandler(TMethod(AHandler));
+end;
+
+//=== { TJclBooleanProcedureBroadcast } =============================================
+
+function TJclBooleanProcedureEventBroadcast.AddHandler(
+  const AHandler: TJclBooleanProcedureEvent): Integer;
+begin
+  Result := inherited AddHandler(TMethod(AHandler));
+end;
+
+function TJclBooleanProcedureEventBroadcast.GetHandler(Index: Integer): TJclBooleanProcedureEvent;
+begin
+  Result := TJclBooleanProcedureEvent(inherited GetHandler(Index));
+end;
+
+procedure TJclBooleanProcedureEventBroadcast.CallAllProcedures(Value: Boolean);
+var
+  Index: Integer;
+begin
+  for Index := 0 to FHandlerCount - 1 do
+    TJclBooleanProcedureEvent(FHandlers[Index])(Value);
+end;
+
+procedure TJclBooleanProcedureEventBroadcast.RemoveHandler(const AHandler: TJclBooleanProcedureEvent);
+begin
+  inherited RemoveHandler(TMethod(AHandler));
+end;
+
+//=== { TJclBooleanEventBroadcast } ==========================================
+
+function TJclBooleanEventBroadcast.AddHandler(
+  const AHandler: TJclBooleanEvent): Integer;
+begin
+  Result := inherited AddHandler(TMethod(AHandler));
+end;
+
+function TJclBooleanEventBroadcast.GetHandler(Index: Integer): TJclBooleanEvent;
+begin
+  Result := TJclBooleanEvent(inherited GetHandler(Index));
+end;
+
+function TJclBooleanEventBroadcast.LogicalAnd: Boolean;
+var
+  Index: Integer;
+begin
+  Result := True;
+  for Index := 0 to FHandlerCount - 1 do
+  begin
+    Result := TJclBooleanEvent(FHandlers[Index]);
+    if not Result then
+      Break;
+  end;
+end;
+
+procedure TJclBooleanEventBroadcast.RemoveHandler(
+  const AHandler: TJclBooleanEvent);
+begin
+  inherited RemoveHandler(TMethod(AHandler));
+end;
+
 {$IFDEF UNITVERSIONING}
 initialization
   RegisterUnitVersion(HInstance, UnitVersioning);


This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site.




2006	Jan	Feb	Mar	Apr (20)	May (48)	Jun (8)	Jul (23)	Aug (41)	Sep (42)	Oct (22)	Nov (17)	Dec (36)
2007	Jan (43)	Feb (42)	Mar (17)	Apr (39)	May (16)	Jun (35)	Jul (37)	Aug (47)	Sep (49)	Oct (9)	Nov (52)	Dec (37)
2008	Jan (48)	Feb (21)	Mar (7)	Apr (2)	May (5)	Jun (17)	Jul (17)	Aug (40)	Sep (58)	Oct (38)	Nov (19)	Dec (32)
2009	Jan (67)	Feb (46)	Mar (54)	Apr (34)	May (37)	Jun (52)	Jul (67)	Aug (72)	Sep (48)	Oct (35)	Nov (27)	Dec (12)
2010	Jan (56)	Feb (46)	Mar (19)	Apr (14)	May (21)	Jun (3)	Jul (13)	Aug (48)	Sep (34)	Oct (51)	Nov (16)	Dec (32)
2011	Jan (36)	Feb (14)	Mar (12)	Apr (3)	May (5)	Jun (24)	Jul (15)	Aug (30)	Sep (21)	Oct (4)	Nov (25)	Dec (23)
2012	Jan (45)	Feb (42)	Mar (19)	Apr (14)	May (13)	Jun (7)	Jul (3)	Aug (46)	Sep (21)	Oct (10)	Nov (2)	Dec
2013	Jan (5)	Feb	Mar	Apr	May	Jun	Jul	Aug	Sep	Oct	Nov	Dec

jcl-checkins-diff Mailing List for JEDI Code Library (Page 29)

jcl-checkins-diff — SVN file check-in notifications with file differences included