| A B C D E F G H I J K L M N O P Q R S T U V W X Y Z |
| WK_Action — class, package wk.advcs.action |
| |
| WK_Action() — Constructor, class wk.advcs.action.WK_Action |
| |
| wk.advcs — package |
| |
| wk.advcs.action — package |
| |
| wk.advcs.controller — package |
| |
| wk.advcs.data — package |
| |
| wk.advcs.service — package |
| |
| wk.advcs.view — package |
| |
| wk.automaton — package |
| |
| WK_Automaton — class, package wk.automaton |
|
An abstract class for automatons. |
| WK_Automaton(p_initial_state:String) — Constructor, class wk.automaton.WK_Automaton |
| |
| WK_AutomatonEvent — class, package wk.automaton |
|
Events of this kind are dispatched by WK_Automatons each
time the state of such a machine is modified due to a user action. |
| WK_AutomatonEvent(p_type:String, p_action:String, p_state:String, p_previous_state:String) — Constructor, class wk.automaton.WK_AutomatonEvent |
| |
| WK_ComponentsAction — class, package wk.advcs.action |
|
An arbitray class MyActionObjects can be made
a singleton by extending WK_ActionObjects,
defining a static constant instance and passing
the class MyActionObjects to the constructor:
import wk.advcs.action.WK_ActionObjects;
public class MyActionObjects extends WK_ActionObejcts
{
public static const instance: MyActionObjects
= WK_ActionObjects.instance(MyActionObjects) as MyActionObjects;
public function MyActionObjects()
{
super(Object(this).constructor); // super(MyActionObjects) does not work :-(
}
... |
| WK_ComponentsAction(p_class:Class) — Constructor, class wk.advcs.action.WK_ComponentsAction |
| |
| WK_ComponentsController — class, package wk.advcs.controller |
|
An arbitray class MyControllerObjects can be made
a singleton by extending WK_ControllerObjects,
defining a static constant instance and passing
the class MyControllerObjects to the constructor:
import wk.advcs.controller.WK_ControllerObjects;
public class MyControllerObjects extends WK_ControllerObejcts
{
public static const instance: MyControllerObjects
= WK_ControllerObjectss.instance(MyControllerObjects) as MyControllerObjects;
public function MyControllerObjects()
{
super(Object(this).constructor); // super(MyControllerObjects) does not work :-(
}
... |
| WK_ComponentsController(p_class:Class) — Constructor, class wk.advcs.controller.WK_ComponentsController |
| |
| WK_ComponentsData — class, package wk.advcs.data |
|
An arbitray class MyDataObjects can be made
a singleton by extending WK_DataObjects,
defining a static constant instance and passing
the class MyDataObjects to the constructor:
import wk.advcs.data.WK_DataObjects;
public class MyDataObjects extends WK_DataObejcts
{
public static const instance: MyDataObjects
= WK_DataObjects.instance(MyDataObjects) as MyDataObjects;
public function MyDataObjects()
{
super(Object(this).constructor); // super(MyDataObjects) does not work :-(
}
... |
| WK_ComponentsData(p_class:Class) — Constructor, class wk.advcs.data.WK_ComponentsData |
| |
| WK_ComponentsService — class, package wk.advcs.service |
|
An arbitray class MyServiceObjects can be made
a singleton by extending WK_ServiceObjects,
defining a static constant instance and passing
the class MyServiceObjects to the constructor:
import wk.advcs.service.WK_ServiceObjects;
public class MyServiceObjects extends WK_ServiceObejcts
{
public static const instance: MyServiceObjects
= WK_ServiceObjects.instance(MyServiceObjects) as MyServiceObjects;
public function MyServiceObjects()
{
super(Object(this).constructor); // super(MyServiceObjects) does not work :-(
}
... |
| WK_ComponentsService(p_class:Class) — Constructor, class wk.advcs.service.WK_ComponentsService |
| |
| WK_ComponentsView — class, package wk.advcs.view |
|
An arbitray class MyViewObjects can be made
a singleton by extending WK_ViewObjects,
defining a static constant instance and passing
the class MyViewObjects to the constructor:
import wk.advcs.view.WK_ViewObjects;
public class MyViewObjects extends WK_ViewObejcts
{
public static const instance: MyViewObjects
= WK_ViewObjects.instance(MyViewObjects) as MyViewObjects;
public function MyViewObjects()
{
super(Object(this).constructor); // super(MyViewObjects) does not work :-(
}
... |
| WK_ComponentsView(p_class:Class) — Constructor, class wk.advcs.view.WK_ComponentsView |
| |
| WK_Controller — class, package wk.advcs.controller |
| |
| WK_Controller — class, package wk.mvcs.controller |
| |
| WK_Controller() — Constructor, class wk.advcs.controller.WK_Controller |
| |
| WK_Controller() — Constructor, class wk.mvcs.controller.WK_Controller |
| |
| WK_Controllers — class, package wk.mvcs.controller |
|
An arbitray class MyControllers can be made
a singleton by extending WK_Controllers,
defining a static constant instance and passing
the class MyControllers to the constructor:
import wk.mvcs.controller.WK_Controllers;
public class MyControllers extends WK_Controllers
{
public static const instance: MyControllers
= WK_Controllers.instance(MyControllers) as MyControllers;
public function MyControllers()
{
super(Object(this).constructor); // super(MyControllers) does not work :-(
}
... |
| WK_Controllers(p_class:Class) — Constructor, class wk.mvcs.controller.WK_Controllers |
| |
| WK_Data — class, package wk.advcs.data |
| |
| WK_Data() — Constructor, class wk.advcs.data.WK_Data |
| |
| WK_DataEvent — class, package wk.advcs.data |
| |
| WK_DataEvent(p_type:String, p_data:wki.advcs.data:WKI_Data, p_bubbles:Boolean, p_cancelable:Boolean) — Constructor, class wk.advcs.data.WK_DataEvent |
| |
| wk.enumeration — package |
| |
| WK_Enumeration — class, package wk.enumeration |
|
This is the base class of alle WK enumeration classes. |
| WK_Enumeration(p_class:Class, p_value:String) — Constructor, class wk.enumeration.WK_Enumeration |
|
This constructor may only be called by sub class constructors. |
| WKI_Action — Interface, package wki.advcs.action |
| |
| wki.advcs.action — package |
| |
| wki.advcs.controller — package |
| |
| wki.advcs.data — package |
| |
| wki.advcs.service — package |
| |
| wki.advcs.view — package |
| |
| wki.automaton — package |
| |
| WKI_Automaton — Interface, package wki.automaton |
| |
| WKI_Controller — Interface, package wki.advcs.controller |
| |
| WKI_Controller — Interface, package wki.mvcs.controller |
| |
| WKI_Data — Interface, package wki.advcs.data |
| |
| WKI_Model — Interface, package wki.mvcs.model |
| |
| WKI_MovieClip — Interface, package wki.mvcs.view |
| |
| wki.mvcs.controller — package |
| |
| wki.mvcs.model — package |
| |
| wki.mvcs.service — package |
| |
| wki.mvcs.view — package |
| |
| WK_InitADVCS — class, package wk.advcs |
| |
| WK_InitADVCS() — Constructor, class wk.advcs.WK_InitADVCS |
|
As WK_InitADVCS is a singleton class, use
instance instead. |
| WK_InitADVCSEvent — class, package wk.advcs |
| |
| WK_InitADVCSEvent(type:String, bubbles:Boolean, cancelable:Boolean) — Constructor, class wk.advcs.WK_InitADVCSEvent |
| |
| WK_InitMVCS — class, package wk.mvcs |
|
A singleton class to initialze all MVC components. |
| WK_InitMVCS() — Constructor, class wk.mvcs.WK_InitMVCS |
|
As WK_InitMVCS is a singleton class, use
instance instead. |
| WK_InitMVCSEvent — class, package wk.mvcs.event |
| |
| WK_InitMVCSEvent(type:String, bubbles:Boolean, cancelable:Boolean) — Constructor, class wk.mvcs.event.WK_InitMVCSEvent |
| |
| WKI_Service — Interface, package wki.advcs.service |
| |
| WKI_Service — Interface, package wki.mvcs.service |
| |
| WKI_View — Interface, package wki.advcs.view |
| |
| WKI_View — Interface, package wki.mvcs.view |
| |
| WK_MealyMachine — class, package wk.automaton |
| |
| WK_MealyMachine(p_initial_state:String, p_transition_function:Object) — Constructor, class wk.automaton.WK_MealyMachine |
|
An mealy automaton is defined by a transition function and
an initial state. |
| WK_MealyMachineSimplified — class, package wk.automaton |
| |
| WK_MealyMachineSimplified(p_initial_state:String, p_transition_function:Object) — Constructor, class wk.automaton.WK_MealyMachineSimplified |
| |
| WK_Model — class, package wk.mvcs.model |
| |
| WK_Model() — Constructor, class wk.mvcs.model.WK_Model |
| |
| WK_Model_CS — class, package wk.mvcs.model |
| |
| WK_Model_CS() — Constructor, class wk.mvcs.model.WK_Model_CS |
| |
| WK_ModelEvent — class, package wk.mvcs.event |
| |
| WK_ModelEvent(p_type:String, p_model:wki.mvcs.model:WKI_Model, p_bubbles:Boolean, p_cancelable:Boolean) — Constructor, class wk.mvcs.event.WK_ModelEvent |
| |
| WK_ModelEvent_CS — class, package wk.mvcs.event |
| |
| WK_ModelEvent_CS(p_type:String, p_model:wki.mvcs.model:WKI_Model, p_bubbles:Boolean, p_cancelable:Boolean) — Constructor, class wk.mvcs.event.WK_ModelEvent_CS |
| |
| WK_Models — class, package wk.mvcs.model |
|
An arbitray class MyModels can be made a singleton
by extending WK_Models,
defining a static constant instance and passing
the class MyModels to the constructor:
import wk.mvc.controller.WK_Models;
public class MyModels extends WK_Models
{
public static const instance: MyModels
= WK_Models.instance(MyModels) as MyModels;
public function MyModels()
{
super(Object(this).constructor); // super(MyModels) does not work :-(
}
... |
| WK_Models(p_class:Class) — Constructor, class wk.mvcs.model.WK_Models |
| |
| WK_MooreMachine — class, package wk.automaton |
| |
| WK_MooreMachine(p_initial_state:String, p_transition_function:Object) — Constructor, class wk.automaton.WK_MooreMachine |
|
A moore automaton is defined by a transition function and
an initial state. |
| WK_MooreMachineSimplified — class, package wk.automaton |
| |
| WK_MooreMachineSimplified(p_initial_state:String, p_transition_function:Object) — Constructor, class wk.automaton.WK_MooreMachineSimplified |
| |
| WK_MovieClip — class, package wk.mvcs.view |
| |
| WK_MovieClip() — Constructor, class wk.mvcs.view.WK_MovieClip |
| |
| WK_Multiton — class, package wk.pattern.singleton |
|
An arbitray class MySingleton can be made a singleton
by defining a static constant instance and invoking
WK_Multiton.ensureSingleton within the constructor:
import wk.pattern.singleton.WK_Multiton;
public class MySingleton
{
public static const instance: MySingleton
= WK_Multiton.instance(MySingleton) as MySingleton;
public function MySingleton()
{
WK_Multiton.ensureSingleton(MySingleton);
}
... |
| wk.mvcs — package |
| |
| wk.mvcs.controller — package |
| |
| wk.mvcs.event — package |
| |
| wk.mvcs.model — package |
| |
| wk.mvcs.service — package |
| |
| wk.mvcs.view — package |
| |
| wk.pattern.singleton — package |
| |
| WK_Service — class, package wk.advcs.service |
| |
| WK_Service — class, package wk.mvcs.service |
| |
| WK_Service() — Constructor, class wk.advcs.service.WK_Service |
| |
| WK_Service() — Constructor, class wk.mvcs.service.WK_Service |
| |
| WK_Services — class, package wk.mvcs.service |
|
An arbitray class MyServices can be made a singleton
by extending WK_Services,
defining a static constant instance and passing
the class MyServices to the constructor:
import wk.mvc.controller.WK_Services;
public class MyModels extends WK_Services
{
public static const instance: MyServices
= WK_Services.instance(MyServices) as MyServices;
public function MyServices()
{
super(Object(this).constructor); // super(MyServices) does not work :-(
}
... |
| WK_Services(p_class:Class) — Constructor, class wk.mvcs.service.WK_Services |
| |
| WK_SkinnableContainer — class, package wk.advcs.view |
| |
| WK_SkinnableContainer — class, package wk.mvcs.view |
| |
| WK_SkinnableContainer() — Constructor, class wk.advcs.view.WK_SkinnableContainer |
| |
| WK_SkinnableContainer() — Constructor, class wk.mvcs.view.WK_SkinnableContainer |
| |
| WK_Views — class, package wk.mvcs.view |
|
An arbitray class MyViews can be made a singleton
by extending WK_Views,
defining a static constant instance and passing
the class MyViews to the constructor:
import wk.mvc.controller.WK_Views;
public class MyModels extends WK_Views
{
public static const instance: MyViews
= WK_Views.instance(MyViews) as MyViews;
public function MyViews()
{
super(Object(this).constructor); // super(MyViews) does not work :-(
}
... |
| WK_Views(p_class:Class) — Constructor, class wk.mvcs.view.WK_Views |
| |
|
| A B C D E F G H I J K L M N O P Q R S T U V W X Y Z |
