GpsGate Server JavaScript API

Event  1.0.0

GpsGate Server JavaScript API > Event > Franson.Event
Search:
 
Filters

static Class Franson.Event

namespace

Properties

_topics - private object

hidden dummy object to create a broadcast system see publish, subscribe

Methods

connectOnce

EventHandler connectOnce(source, eventName, objOrFunc, [funcOrStr])
see isConnected(). same arguments and same condition applies.
Parameters:
source <object|DOM|string>
eventName <string>
objOrFunc <object|function>
[funcOrStr] <function|string>
Returns: EventHandler
null if already connected

disconnect

private void disconnect(handlers)
convenience function that accepts array as input also (and multiple arguments).
see MochiKit.Signal.disconnect() todo: accept (silently) null args also?
Parameters:
handlers <EventHandler|EventHandler[]|..>
Returns: void

findAllEventHandlers

EventHandler[] findAllEventHandlers(source)
extracts all listeners attached to source. ok name?
Parameters:
source <object|DOM|string>
Returns: EventHandler[]

findEventHandler

EventHandler findEventHandler(source, eventName, objOrFunc, [funcOrStr])
todo: could create several versions/overloads.
findEventHandler(source) => all handlers connected.
findEventHandler(source, eventName) => all handlers listening to eventName.
findEventHandler(source, handler) => all events the handler is attached via.
findEventHandler(eventName) => all events hook to eventName regardless of obj.
Parameters:
source <object|DOM|string>
eventName <string>
objOrFunc <object|function>
[funcOrStr] <function|string>
Returns: EventHandler

forwardEvent

EventHandler forwardEvent(from, srcEventName, to, [dstEventName=srcEventName])
Useful when creating wrappers/adapters.
todo: add support for some kind of parameter control? at least a pass-no-params flag?
Parameters:
from <object> Source object
srcEventName <string>
to <object> Destination object
[dstEventName=srcEventName] <string>
Returns: EventHandler

getTotalNumberOfListeners

integer getTotalNumberOfListeners()
for debugging purposes, to be able to detect handler leaks. note that it won't return 0 even at the very first call since MochiKit needs a couple of events for internal use (page-unload etc)
Returns: integer

isConnected

boolean isConnected(source, eventName, objOrFunc, [funcOrStr])
Note: observe that this will not work if called with a closure as parameter (closures are by definition unique on each instantiation)
Parameters:
source <object|DOM|string>
eventName <string>
objOrFunc <object|function>
[funcOrStr] <function|string>
Returns: boolean

listenOnce

Eventhandler listenOnce(source, eventName, handler)
execute the handler (incl cleanup) just once.
todo: should support context obj
Parameters:
source <object|DOM|string>
eventName <string>
handler <function>
Returns: Eventhandler
only needed in case termination before the event is necessary, typically ignored.

listenOnMany

private EventHandler[] listenOnMany(sources, eventName, objOrFunc, [funcOrStr])
(for now)
Parameters:
sources <Array[object|DOM|string]>
eventName <string>
objOrFunc <object|function>
[funcOrStr] <function|string>
Returns: EventHandler[]

listenToMultiple

private EventHandler[] listenToMultiple(src, eventNames, objOrFunc, [funcOrStr])
connect single handler to multiple events.
Useful?
Parameters:
src <object|DOM|string>
eventNames <string[]>
objOrFunc <object|function>
[funcOrStr] <function|string>
Returns: EventHandler[]

listenToRadioGroup

private EventHandler[] listenToRadioGroup(groupName, handler)
test todo: same for checkbox buttons todo: currently hardwired to use onclick. expose 'onfocus' etc? todo: hmm, would be convenient if MochiKit.Signal.disconnect would recognize array-like params and then disconnect each?
Parameters:
groupName <string>
handler <function(Event)>
Returns: EventHandler[]

listenUntil

Eventhandler listenUntil(source, eventName, predicateHandler)
disconnects automatically when predicate returns true.
todo: support context obj
Parameters:
source <object|DOM|string>
eventName <string>
predicateHandler <function> callback handler, when returing true disconnects
Returns: Eventhandler
only needed in case termination before the event is necessary, typically ignored (the purpose of this function..).

normalize

MochiKit.Signal.Event normalize(e)
note: this doesn't (can't) set the .src() property of e.
Parameters:
e <event> browser-native event (if passed a Mochi.Event it is returned as-is)
Returns: MochiKit.Signal.Event

onOutsideClick

EventHandler onOutsideClick(source, handler)
Meta-event that triggers when a user clicks outside an object (used in the popup-controls for example)
note: doesn't take overlapping elems into account, only geometry (and visibility)
todo: hmm, could be implemented as enableOnOutSideClickEvent(elem) also that fires a MochiKit.Signal.signal(source, 'onoutsideclick', e). and make listeners use connect(source, 'onoutsideclick', handler) hookup?
Parameters:
source <DOM|string> - todo: support multiple elements?
handler <function>
Returns: EventHandler

preventDefault

void preventDefault(e)
to be used to hook on events with a unique function (connectOnce compatible) for example.
todo: could add some more Event methods (and also generalize this)
function version of Event.preventDefault()
Parameters:
e <MochiKit.Signal.Event> (Not a native event)
Returns: void

publish

void publish(topic, [args])
broadcasts a signal to all listeners to the topic attached via subscribe()
ref dojo.publish() (difference is that this allows multiple arguments)
Parameters:
topic <string>
[args] <[object, ...]> optional multiple arguments passed to the listeners
Returns: void

purgeDomNode

void purgeDomNode(elem)
removes all signals connected to the elem tree.
todo: optionally control type of signal to remove? (supply purge fn and/or event-name(s))
Parameters:
elem <DOMNode|string>
Returns: void

singleConnect

private EventHandler singleConnect()
makes sure this connection to source is the only one listening to eventName useful? (name?) see connectOnce
Returns: EventHandler

stop

void stop(e)
function version of Event.stop()
Parameters:
e <MochiKit.Signal.Event> (Not a native event)
Returns: void

stopPropagation

void stopPropagation(e)
function version of Event.stopPropagation()
Parameters:
e <MochiKit.Signal.Event> (Not a native event)
Returns: void

subscribe

EventHandler subscribe(topic, objOrFunc, [funcOrStr])
same syntax as MochiKit.Signal.connect() but with source (first param) already bound.
see also publish()
ref dojo.subscribe()
Parameters:
topic <string>
objOrFunc <object|function>
[funcOrStr] <function|string>
Returns: EventHandler

unsubscribe

void unsubscribe(handle)
disconnects a signal attached with subscribe()
same as disconnect (alias), mostly for symmetry (same as dojo) (or skip?) ref dojo.unsubscribe()
Parameters:
handle <EventHandler>
Returns: void

Classes

Files

Properties

Copyright © 2009 Franson Technology AB, Sweden. All rights reserved.