Class Index
Archetype.Class.Methods
Mixed into class-instances, so that these methods will become available as
instance methods
Archetype.Component
Class for loading components
Archetype.component.abstractComponent
Describes the Standard Component Interface
Archetype.component.graphicalComponent
Archetype.Component manager. Sets up components, load their dependencies, etc.
Should only be used through the convenient "Archetype.Component." wrappers
Archetype.Loggers.AbstractLogger
Defines an abstract logger that does nothing but no error when called :)
Archetype.Loggers.AlertLogger
This logger is full of breaks.
Can be usefull for step by step or testing on very pour client.
Archetype.Loggers.BodyLogger
Defines an logger that appends the log at the end of the body of the page.
quite messy, not well coded (inline style :'( ), but pretty efficient to debug notably on IE
Archetype.Loggers.FirebugLogger
Defines an logger designed to work with firebug (and maybe with safari console)
Archetype.Loggers.NullLogger
Defines a null logger for production environment.
No log will be displayed.
Archetype.methodBuilders.eventListeners
Automatic event Listener for your component. Just add a "on" prefix to a method for it to
automatically listen for the event named after this prefix.
The listener will get the event in first parameter, and can get the data posted by the event
with (say we will use the variable "event" as first parameter) event.event_data.data
Archetype.methodBuilders.eventSenders
Automatic event Sender for your component.
It's a convenient way to send an event with arguments without using the event API.
The original method isn't called so Prototype.emptyfunction, it's alias _ , or any empty function
should do the trick for the definition
Archetype.methodBuilders.public_private
Basic method Builder used to differentiate public & private variable based on their name.
All methods are bound to their object (this will always be the objects "this", even in a event listener)
Event.Broker
Description:
Allows listeners to subscribe to event types, and remain
blissfully unaware of the available publishers of those events
Requires prototype.js
Usage:
You'll usually want to create a copy of the Broker object by mixing
it in with one of your own classes as follows:
Object.extend( your_obj, Event.Broker )
Publishers register the event types they send with a call to
your_broker_object.registerEventsPublisher
and "unregister" via your_broker_object.unregisterEventsPublisher
Nothing changes for the event listeners, except they call their
listen() method once for each event type (passing a reference
to the broker) instead of once per event type per publisher
Event.Listener
MIX IN: Event.Listener
Description:
easily add support for receiving totally custom events
(to any object or class) by mixing this class into
your own
Usage:
To receive custom events:
1. mix this class with your own via
Object.extend( [your class or prototype], EventListener )
2. listen for events by calling (from your object)
this.listen()
(see params for this.listen, below)
Event.Publisher
Description:
add support (to any object or class) by mixing this class into your own
Requires prototype.js
Usage:
To publish custom events:
1. mix this class with your own via
Object.extend( [your class or prototype], Event.Publisher )
2. post events by calling
this.dispatchEvent( [event name], [data for event] )
To activate and deactivate the event-tracing feature, just call
this.toggleEventsTrace()
Event.Tracer
Singleton Object: Event.Tracer
Description:
provides some minimal event debugging/tracing/logging
Event.Tracer is a sort of singleton
Only use Event.Tracer for starting and stopping the event tracing
service, and for acquiring a reference to the live tracing object
(which is returned by both find_tracer and start_trace)
IMPORTANT
You only need to use this file when debugging your custom events.
Requires:
prototype.js
the custom events services provided by event_mixins.js
Usage:
Start up event tracing by calling Event.Tracer.startTrace( viewport )
viewport is a div (or the id of a div) on your page where trace
output will be written
returns: a reference to an instance of Event.Tracer.prototype
(not the singleton)
Kill the tracer (disable tracing in all publishers) with:
Event.Tracer.stopTrace()
Note that you can start the tracer (if it's not already running)
and register your publishers, all in one step, with a call like:
[publisher].toggleEventsTrace()
MethodManager
Manage Method Builders to apply to a Archetype.Component Definition
Slidy.components.container
Slidy.components.slideChangeHandler
Slidy.components.slideCounter
Slidy.components.slideManager