Merge pull request #41 from Amrykid/master

Updated events.nim

2 files changed, 39 insertions, 26 deletions

diff --git a/lib/pure/events.nim b/lib/pure/events.nim
index 00d6797d2..413256657 100644
--- a/lib/pure/events.nim
+++ b/lib/pure/events.nim
@@ -11,48 +11,62 @@
 ##
 ## This module implements an event system that is not dependant on external
 ## graphical toolkits. It was originally called ``NimEE`` because 
-## it was inspired by Ptyhon's PyEE module.
-
+## it was inspired by Python's PyEE module. There are two ways you can use events: one is a python-inspired way; the other is more of a C-style way.
+## .. code-block:: Nimrod
+##   var ee = initEventEmitter()
+##   var genericargs: TEventArgs
+##   proc handleevent(e: TEventArgs) =
+##       echo("Handled!")
+##
+##   # Python way
+##   ee.on("EventName", handleevent)
+##   ee.emit("EventName", genericargs)
+## 
+##   # C/Java way
+##   # Declare a type
+##   type
+##       TSomeObject = object of TObject
+##           SomeEvent: TEventHandler
+##   var myobj: TSomeObject
+##   myobj.SomeEvent = initEventHandler("SomeEvent")
+##   myobj.SomeEvent.addHandler(handleevent)
+##   ee.emit(myobj.SomeEvent, genericargs)
 type
-  TEventArgs* = object of TObject ## Base object for event arguments
-                                  ## that are passed to callback functions.
-  TEventHandler = tuple[name: string, handlers: seq[proc(e:TEventArgs)]]
-  PEventHandler* = ref TEventHandler ## An eventhandler for an event.
+  TEventArgs* = object of TObject ## Base object for event arguments that are passed to callback functions.
+  TEventHandler* = tuple[name: string, handlers: seq[proc(e:TEventArgs)]] ## An eventhandler for an event.
 
 type
-  TEventEmitter = object {.pure, final.}
-    s: seq[PEventHandler]
-  PEventEmitter* = ref TEventEmitter ## An object that fires events and 
-                                     ## holds event handlers for an object.
+  TEventEmitter* = object {.pure, final.} ## An object that fires events and holds event handlers for an object.
+    s: seq[TEventHandler]
   EInvalidEvent* = object of EInvalidValue
     
-proc newEventHandler*(name: string): PEventHandler =
+proc initEventHandler*(name: string): TEventHandler =
   ## Initializes an EventHandler with the specified name and returns it.
-  new(result)
+  #new(result)
   result.handlers = @[]
   result.name = name
 
-proc addHandler*(handler: PEventHandler, func: proc(e: TEventArgs)) =
+proc addHandler*(handler: var TEventHandler, func: proc(e: TEventArgs)) =
   ## Adds the callback to the specified event handler.
   handler.handlers.add(func)
 
-proc removeHandler*(handler: PEventHandler, func: proc(e: TEventArgs)) =
+proc removeHandler*(handler: var TEventHandler, func: proc(e: TEventArgs)) =
   ## Removes the callback from the specified event handler.
   for i in countup(0, len(handler.handlers) -1):
     if func == handler.handlers[i]:
       handler.handlers.del(i)
       break
     
-proc clearHandlers*(handler: PEventHandler) =
+proc clearHandlers*(handler: var TEventHandler) =
   ## Clears all of the callbacks from the event handler.
   setLen(handler.handlers, 0)
 
-proc getEventhandler(emitter: PEventEmitter, event: string): int =
+proc getEventhandler(emitter: var TEventEmitter, event: string): int =
   for k in 0..high(emitter.s):
     if emitter.s[k].name == event: return k
   return -1
 
-proc on*(emitter: PEventEmitter, event: string, func: proc(e: TEventArgs)) =
+proc on*(emitter: var TEventEmitter, event: string, func: proc(e: TEventArgs)) =
   ## Assigns a event handler with the specified callback. If the event
   ## doesn't exist, it will be created.
   var i = getEventHandler(emitter, event)
@@ -63,12 +77,12 @@ proc on*(emitter: PEventEmitter, event: string, func: proc(e: TEventArgs)) =
   else:
     addHandler(emitter.s[i], func)
   
-proc emit*(emitter: PEventEmitter, eventhandler: PEventHandler, 
+proc emit*(emitter: var TEventEmitter, eventhandler: var TEventHandler, 
            args: TEventArgs) =
   ## Fires an event handler with specified event arguments.
   for func in items(eventhandler.handlers): func(args)
 
-proc emit*(emitter: PEventEmitter, event: string, args: TEventArgs) =
+proc emit*(emitter: var TEventEmitter, event: string, args: TEventArgs) =
   ## Fires an event handler with specified event arguments.
   var i = getEventHandler(emitter, event)
   if i >= 0:
@@ -76,8 +90,7 @@ proc emit*(emitter: PEventEmitter, event: string, args: TEventArgs) =
   else:
     raise newException(EInvalidEvent, "invalid event: " & event)
 
-proc newEventEmitter*(): PEventEmitter =
+proc initEventEmitter*(): TEventEmitter =
   ## Creates and returns a new EventEmitter.
-  new(result)
-  result.s = @[]
-
+  #new(result)
+  result.s = @[]
\ No newline at end of file
diff --git a/tests/accept/run/tevents.nim b/tests/accept/run/tevents.nim
index 2811c9625..fb94b1f79 100644
--- a/tests/accept/run/tevents.nim
+++ b/tests/accept/run/tevents.nim
@@ -18,7 +18,7 @@ proc handleprintevent2*(e: TEventArgs) =
     var args: TPrintEventArgs = TPrintEventArgs(e)
     write(stdout, "HandlePrintEvent2: Output -> printing for " & args.user)
     
-var ee = newEventEmitter()
+var ee = initEventEmitter()
 
 var eventargs: TPrintEventArgs
 eventargs.user = "ME\n"
@@ -34,10 +34,10 @@ ee.emit("print", eventargs)
 
 type
   TSomeObject = object of TObject
-    PrintEvent: PEventHandler
+    PrintEvent: TEventHandler
 
 var obj: TSomeObject
-obj.PrintEvent = newEventHandler("print")
+obj.PrintEvent = initEventHandler("print")
 obj.PrintEvent.addHandler(handleprintevent2)
 
 ee.emit(obj.PrintEvent, eventargs)