Documentation for classes includes syntax, usage information, and code samples for methods, properties, and event handlers and listeners for those APIs that belong to a specific class in ActionScript. The classes are listed alphabetically. If you are not sure to which class a certain method or property belongs, you can look it up in the Index.
| Class | Package | Description | |
|---|---|---|---|
| WK_Action | wk.advcs.action | ||
| WK_Automaton | wk.automaton | An abstract class for automatons. | |
| WK_AutomatonEvent | 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_ComponentsAction | 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_ComponentsController | 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_ComponentsData | 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_ComponentsService | 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_ComponentsView | 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_Controller | wk.advcs.controller | ||
| WK_Controller | wk.mvcs.controller | ||
| WK_Controllers | 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_Data | wk.advcs.data | ||
| WK_DataEvent | wk.advcs.data | ||
| WK_Enumeration | wk.enumeration | This is the base class of alle WK enumeration classes. | |
| WK_InitADVCS | wk.advcs | ||
| WK_InitADVCSEvent | wk.advcs | ||
| WK_InitMVCS | wk.mvcs | A singleton class to initialze all MVC components. | |
| WK_InitMVCSEvent | wk.mvcs.event | ||
| WK_MealyMachine | wk.automaton | ||
| WK_MealyMachineSimplified | wk.automaton | ||
| WK_Model | wk.mvcs.model | ||
| WK_Model_CS | wk.mvcs.model | ||
| WK_ModelEvent | wk.mvcs.event | ||
| WK_ModelEvent_CS | wk.mvcs.event | ||
| WK_Models | 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_MooreMachine | wk.automaton | ||
| WK_MooreMachineSimplified | wk.automaton | ||
| WK_MovieClip | wk.mvcs.view | ||
| WK_Multiton | 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_Service | wk.advcs.service | ||
| WK_Service | wk.mvcs.service | ||
| WK_Services | 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_SkinnableContainer | wk.advcs.view | ||
| WK_SkinnableContainer | wk.mvcs.view | ||
| WK_Views | 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 :-( } ... | |
| WKI_Action | wki.advcs.action | ||
| WKI_Automaton | wki.automaton | ||
| WKI_Controller | wki.advcs.controller | ||
| WKI_Controller | wki.mvcs.controller | ||
| WKI_Data | wki.advcs.data | ||
| WKI_Model | wki.mvcs.model | ||
| WKI_MovieClip | wki.mvcs.view | ||
| WKI_Service | wki.advcs.service | ||
| WKI_Service | wki.mvcs.service | ||
| WKI_View | wki.advcs.view | ||
| WKI_View | wki.mvcs.view |