| AbstractFormat | AbstractFormat maybe used as base class for specialized formats |
| ActionMapper | ActionMapper is the central class in our implementation of the mvc pattern. It calls the different Controllers based on the sreferring Controller and the given action |
| AdminController | AdminController is used as an entry point to the admintool |
| Adodbseq | |
| AdodbseqBase | |
| AdodbseqRDBMapper | |
| AnonymousUser | Anonymous User |
| Application | The main application class. Does all the initialization |
| ArrayOutputStrategy | This OutputStrategy outputs an object's content into an array |
| ArrayUtil | ArrayUtil provides support for array manipulation |
| AssociateController | AssociateController is a controller that (dis-)associates Nodes (by setting the parent/child relations) |
| AsyncPagingController | AsyncPagingController is a controller that allows to navigate lists |
| AuthUser | AuthUser provides a storage and methods for user data used for authentication/authorization purposes. This class requires php >= 4.1.0 |
| AuthUserRDB | AuthUser that gets configuration from an database |
| AuthUserXML | AuthUser that gets configuration from an XML file |
| BackupController | This Controller creates a backup (action 'makebackup') from a directory and restores (action 'restorebackup') a created one to that directory respectively. It creates a directory named after the 'backupName' parameter in the backup directory whose name is determined by the configuration key 'backupDir' (section 'cms'). Then it copies all files found in the directory given in the 'sourceDir' parameter to that directory. Subclasses may add additional work packages by overriding the BackupController::getAdditionalWorkPackage method |
| BatchController | BatchController allows to define work packages that will be processed in a sequence. It simplifies the usage of LongTaskController functionality for splitting different bigger tasks into many smaller (similar) tasks where the whole number of tasks isn't known at designtime |
| BusyLockManager | BusyLockManager acts as if half of the resources are locked. Use this to simulate heavy concurrency |
| ChangeListener | ChangeListener defines an interface for classes that want to be notified when a value of an persistent object changes |
| ChildrenListController | ChildrenListController is a controller that loads chilren of a given node and displays the result in a list |
| CommitVisitor | The CommitVisitor is used to commit the object's changes to the object storage. The objects must implement the PersistentObject interface |
| ConcurrencyController | ConcurrencyController is a controller that allows to lock/unlock objects |
| ConfigController | ConfigController is used to edit configuration files. The controller uses the global variable CONFIG_PATH to locate the configuration files. The global variables CONFIG_EXTENSION and MAIN_CONFIG_FILE are used to determine which files are configuration files and which one is the default one |
| Controller | Controller is the base class of all controllers. If a Controller has a view it is expected to reside in the directory configured in section smarty.templateDir. Additional smarty directories ('templates_c', 'configs', 'cache') are expected in a subdirectory of the template directory named 'smarty' |
| ControllerDelegate | ControllerDelegate is used to define an interface to vary the behaviour of the Controller base class. The methods are called by the Controller base class on defined variation points and get the currently executed controller as parameter |
| ControllerMessage | ControllerMessages are sent between Controllers and are used to transfer data between them. ControllerMessages are dispatched by ActionMapper, which decides upon the message's controller, context and action parameter to which Controller it will be send |
| CopyController | CopyController is a controller that copies Nodes |
| CSVUtil | CSVUtil provides basic support for csv file functionality. The first line of a csv file is supposed to hold the field names |
| DataConverter | DataConverter is the base class for all converter classes. It defines the interface for converting data between storage and application |
| DefaultControlRenderer | DefaultControlRenderer is responsible for rendering html input controls. Each control is defined in a smarty template, which is configured by the appropriate entry in the configuration section 'htmlform' (e.g. the text input control has the entry 'text'). The templates get a default set of variables assigned. Additional variables, needed only for certain controls, are assigned in the appropriate configure method (e.g. 'configure_text'). which may be overridden by subclasses |
| DefaultDataConverter | The default dataconverter |
| DefaultOutputStrategy | This OutputStrategy outputs an object's content to the Log category DefaultOutputStrategy. Classes used must implement the toString() method |
| DefaultValueRenderer | DefaultValueRenderer is responsible for rendering (Node) values of a given display type. Each display type is defined in a smarty template, which is configured by the appropriate entry in the configuration section 'htmldisplay' (e.g. the image display type has the entry 'image'). The templates get a default set of variables assigned. Additional variables, needed only for certain display types, are assigned in the appropriate configure method (e.g. 'configure_image') which may be overridden by subclasses |
| DeleteController | DeleteController is a controller that delete Nodes |
| DisplayController | DisplayController is a simple controller demonstrating how to display a Node using the displaynode.tpl template |
| DotOutputStrategy | This OutputStrategy outputs an object's content in a dot file |
| EditRightsController | EditRightsController is used to edit rights on a resource |
| ElementImageOutputStrategy | This OutputStrategy outputs a tree of objects into an image file. It must be configured with a map that was calculated by a LayoutVisitor |
| EncodingUtil | EncodingUtil provides helper functions for working with different encodings mainly UTF-8 |
| ExitController | ExitController stops the script execution immediatly by calling the exit function |
| FailureController | FailureController is a controller that shows an error page to the user |
| FileUtil | FileUtil provides basic support for file functionality like HTTP file upload |
| Formatter | Formatter is is the single entry point for request/response formatting. It chooses the configured formatter based on the format property of the message by getting the value XXXFormat from the configuration section 'implementation' |
| FormUtil | FormUtil provides basic support for HTML forms. It's mainly for creating input controls from definition strings |
| FTPUtil | FTPUtil provides support for ftp functionality |
| GraphicsUtil | GraphicsUtil provides support for graphic manipulation |
| HierarchicalFormat | HierarchicalFormat maybe used as base class for formats that are able to represent hierarchical data like JSON or XML. This format automatically iterates over data when de-/serializing and uses template methods to implement the specific format |
| HTMLDataConverter | HTMLDataConverter converts data between storage and HTML files |
| HTMLFormat | HTMLFormat realizes the HTML request/response format. Since all data from the external representation arrives in form fields, grouping of values has to be done via the field names. So Nodes are represented by their values whose field names are of the form value-<datatype>-<name>-<oid>. All of these values will be removed from the request and replaced by Node instances representing the data. The each node is stored under its oid in the data array |
| I18nUtil | I18nUtil provides support i18n functionality |
| IFormat | IFormat defines the interface for all formatter classes. Formatter classes are used to map external data representations like JSON, XML/SOAP or HTML to internal ones. All data values are supposed to be scalar or array values except for Nodes, for which each external representation defines a special notation |
| ImageOutputStrategy | This OutputStrategy outputs a tree of objects into an image file. It must be configured with a map that was calculated by a LayoutVisitor |
| InifileParser | InifileParser provides basic services for parsing a ini file from the file system |
| InsertController | InsertController is a controller that inserts Nodes |
| InternalLink | InternalLink contains static methods for handling internal application links. These links are useful in an scenario, where an object represents a page and several subobjects represent page elements |
| JSONFormat | JSONFormat realizes the JSON request/response format. All data will be de-/serialized using the json_encode/json_encode method if avalaible or JSON.php as fallback, except for Nodes. Nodes are serialized into an array before encoding (see JSONFormat::serializeValue). On serialization the data will be outputted directly using the print command |
| JSONUtil | JSONUtil provides helper functions for JSON |
| LayoutVisitor | The LayoutVisitor is used to position a tree of objects on a plane (the objects must implement the getParent()). It uses a simple algorithm that positions the objects on a discrete array with distance 1 so that all leaves are equal distant from their neighbours. The positions are stored in a map that is provided by the getMap() method |
| LinkConverter | LinkConverter converts internal absolute urls to relative ones when saving to the database and vice versa. Since StringUtil::getUrls() is used to detect urls, only urls in hmtl elements are detected when converting from storage to application (relative to absolute). If the url is not in an html element (e.g. if the whole data is an url) the conversion works only from application to storage (absolute to relative) |
| ListboxController | ListboxController is a controller that uses g_getOIDs to retrieve listbox data |
| Lock | Lock represents a lock on an object |
| LockManager | LockManager is used to handle lock requests on objects |
| LockManagerRDB | LockManagerRDB implements a LockManager for relational databases |
| Locktable | |
| LocktableBase | |
| LocktableRDBMapper | |
| Log | Log is used to log application events. The implementation is a wrapper over log4php. All methods may be called in a static way |
| LoginController | LoginController is a controller that handles the login process |
| LogOutputStrategy | This OutputStrategy outputs an object's content to the logger category LogOutputStrategy, loglevel info Used classes must implement the toString() method |
| LongTaskController | LongTaskController is a controller that may be used as base class for tasks, that require a long execution time such as construction of a list of pages |
| Mail | Class to send mails |
| MapVisitor | The MapVisitor is used to extract data from the visited objects into an associative array. Subclasses define the map structure and content |
| Message | Use the Message class to output messages. You need not instantiate a Message object because the methods may be called like static class methods e.g. $translated = Message::get('text to translate') |
| MultipleActionController | MultipleActionController is a controller that executes multiple actions by passing them do the appropriate controllers and returning all results as once |
| MySQLBackupController | This Controller enhances the file backup defined by BackupController by a backup of a given MySQL database |
| MySQLDateConverter | MySQLDateConverter converts MySQL dates to a date localized to the users or application settings |
| NMUserRole | |
| NMUserRoleBase | |
| NMUserRoleRDBMapper | |
| Node | Node is the basic component for building trees (although a Node can have one than more parents). The Node class implements the 'Composite Pattern', so no special tree class is required, all interaction is performed using the Node interface. Subclasses for specialized Nodes must implement this interface so that clients don't have to know about special Node classes. Use the methods addChild(), deleteChild() to build/modify trees |
| NodeIterator | NodeIterator is used to iterate over a tree/list build of objects using a Depth-First-Algorithm. Classes used with the NodeIterator must implement the getChildren() and getOID() methods. NodeIterator implements the 'Iterator Pattern'. The base class NodeIterator defines the interface for all specialized Iterator classes |
| NodeListController | NodeListController is a controller that loads nodes of a given type and displays the result in a list |
| NodeProcessor | NodeProcessor is used to iterate over all values of a Node and apply a given callback function |
| NodeRDBMapper | NodeRDBMapper maps Node objects to a relational database schema where each Node type has its own table. It defines a persistence mechanism that specialized mappers customize by overriding the given template methods |
| NodeSerializer | NodeSerializer provides helper functions to de-/serialize Nodes |
| NodeToSingleTableMapper | NodeToSingleTableMapper maps nodes of different types to the database. It uses a relational database scheme that simulates a xml tree. That means all nodes share one table |
| NodeUnifiedRDBMapper | NodeUnifiedRDBMapper maps Node objects to a relational database schema where each Node type has its own table. In comparison to NodeRDBMapper it implements almost all template methods from the base classes and defines the sql queries. The newly defined template methods make it easier for application developers to implement own mapper subclasses. The wCMFGenerator uses this class as base class for all mappers. Besides some methods that define table/column names, the main effort lies in implementing the getObjectDefinitionImpl() method wich needs the following extra definitions:
- extra key _refs see NodeUnifiedRDBMapper::getObjectDefinitionImpl()
- in _datadef array the following keys are added:
- column_name The name of the database column
- in _parents array the following keys are added:
- is_navigable True/False wether the parent is navigable from this object or not
- table_name The name of the database table of the parent
- pk_columns An array of the name(s) of the primary key columns of the parent table
- fk_columns The name of the foreign key column that point from the object's table to the parent table (compound foreign keys are not supported yet)
- in _children array the following keys are added:
- is_navigable True/False wether the child is navigable from this object or not
- table_name The name of the database table
- pk_columns An array of the name(s) of the primary key columns of the child table
- fk_column The name of the foreign key column that point from the child table to the object's table (compound foreign keys are not supported yet)
- order_by An array of columns to sort by default
|
| NodeUtil | NodeUtil provides services for the Node class. All methods are static |
| NodeXMLDBMapper | NodeXMLDBMapper maps Node objects to a xml file using the CXmlDb class. http://sourceforge.net/projects/phpxmldb |
| NodeXMLMapper | NodeXMLMapper maps nodes to a xml file |
| NullLockManager | NullLockManager acts as if no LockManager was installed. Use this to disable locking |
| NullNode | NullNode is an implementation of the NullObject pattern, It inherits all functionality from Node (acts like a Node) and is only distinguishable from a Node instance by it's class or oid. If a Node's parent is a NullNode instance, than they should be separated in the data store (e.g. the foreign key should be null, if allowed by the database). NullNode child instances should be ignored. The object id is created using the following code: PersistenceFacade::composeOID(array('type' => $this->_type, 'id' => NULL)) |
| NullView | NullView is a stub class that implements all view methods |
| Obfuscator | This class allows to obfuscate strings. By passing an objuscated string to the method Obfuscator::unveil() the orginal string is returned. This is especially useful, if you want to place a secret string inside a client view as a parameter and want to get the original string back as the request is processed |
| ObjectFactory | ObjectFactory loads class definitions and instantiates classes |
| ObjectQuery | ObjectQuery is the base class for object queries. This class provides the user with object templates on which query conditions may be set. Object templates are Node instances whose attribute values are used as conditions on the appropriate attributes. A value inludes the operator to be applied to it. For example $authorTpl->setValue("name", "LIKE '%ingo%'") means searching for authors whose name contains 'ingo'. Operator and value should be separated by a space. If no operator is given LIKE '%...' is assumed |
| OutputStrategy | OutputStrategy is used to write an object's content to a destination (called 'document') using a special format. OutputStrategy implements the 'Strategy Pattern'. The abstract base class OutputStrategy defines the interface for all specialized OutputStrategy classes |
| OutputVisitor | The OutputVisitor is used to output an object's content to different destinations and formats. The spezial output destination/format may be configured by using the corresponding OutputStrategy, which is set using the setOutputStrategy() method |
| PageExportController | PageExportController is an abstract controller that is used as base class for Controller classes that export content to pages defined by templates. Export is triggered by any action except 'preview' and 'continue'. On 'preview' action PageExportController creates a preview corresponding to a given oid and context |
| PagingController | PagingController is a controller that allows to navigate lists |
| PagingInfo | PagingInfo contains information about a paged list |
| PDF | PDF extends FPDF/FPDI |
| PDFPage | PDFPage instances define the content of a pdf page by using a set of FPDF/FPDI commands inside the PDFPage::render method |
| PDFTemplate | PDFTemplate is used to output pdf files based on a given pdf template. PDFTemplate uses FPDI/FPDF. PDFPage instances are used to render data onto the template pages |
| PersistenceFacade | PersistenceFacade delegates persistence operations to the type-specific PersistenceMappers |
| PersistenceMapper | PersistenceMapper is the base class for all mapper classes |
| PersistentIterator | PersistentIterator is used to iterate over a tree/list build of oids using a Depth-First-Algorithm. To persist its state use the PersistentIterator::save() method, to restore its state use the static PersistentIterator::load() method, which returns the loaded instance. States are identified by an unique id, which is provided after saving. PersistentIterator implements the 'Iterator Pattern' |
| PersistentObject | PersistentObject is the base class of all persistent objects. It implements the basic persistence methods (save(), delete()) which will be delegated to the PersistenceMapper class that contsructed the object. The PersistentObject holds the object data in an associative array of the following structure: |
| Position | Stores a coordinate tuple for use with the LayoutVisitor |
| PrincipalController | PrincipalController is used to edit users and roles |
| RDBMapper | RDBMapper maps objects of one type to a relational database schema. It defines a persistence mechanism that specialized mappers customize by overriding the given template methods |
| Request | Request holds the request values that are used as input to Controller instances. It is typically instantiated and filled by the ActionMapper |
| ResourceListController | ResourceListController is a controller that fetches a resource list from the server and displays it using the resourcelist.tpl template. For each resource type and subtype there has to be a method defined which is named getlist_'type'_'subtype'. This method returns an assoziative array with the urls of the resources as keys and a user defined array as values. The returned array will be assigned to the view in a variable named resourceList. For example for the resource type 'link' with subtype 'content' there has to be a method getlist_link_content. This controller defines three methods getlist_link_content, getlist_link_resource and getlist_image_resource. Users may override these methods to implement special application requirements. The template resourcelist.tpl is usually opened in a popup window. When selecting a resource it calls the method SetUrl(value, fieldName) of the opener window, which is supposed to set the selected value in the input field identified by fieldName. In addition to listing files the controller processes the actions 'createDir' and 'delete' |
| ResourceTreeController | ResourceTreeController allows to browse cms content in a tree view and set links when selecting a resource. It works together with resourcetree.tpl |
| Response | Response holds the response values that are used as output from Controller instances. It is typically instantiated by the ActionMapper instance and filled during Controller execution |
| RightsManager | RightsManager is used to handle all authorization requests |
| Role | Abstract base class for role classes that represent a user role |
| RoleImpl | |
| RoleRDB | |
| RoleRDBBase | |
| RoleRDBRDBMapper | |
| RoleXML | |
| SaveController | SaveController is a controller that saves Node data |
| SearchController | SearchController is a controller that exectutes a search for oids and displays them in a paged list. If a type is given in the parameters, it will search for oids of that type where the attribute values match the given ones (advanced search). Otherwise it searches for a given searchterm in all nodes and displays the result in a list (simple search). If the action is definesearch, it will display an input form for node values to search for |
| SessionData | This class provides a unified access to session data |
| SimpleBatchController | SimpleBatchController is a controller demonstrating the use of BatchController for cutting a long task into a fixed number of smaller tasks |
| SimpleLongTaskController | SimpleLongTaskController is a controller demonstrating the use of LongTaskController for cutting a long task into a fixed number of smaller tasks |
| SimplePagingController | SimplePagingController is a controller demonstrating the use of PagingController for splitting long lists into several pages |
| SOAPController | SOAPController is a controller that handles SOAPRequests |
| SOAPFormat | SOAPFormat realizes the SOAP request/response format. Nodes are serialized into an array (the nusoap library creates the XML) |
| SortController | SortController is a controller that sorts Nodes of same type |
| Storable | This class defines the interface for classes that can be stored in the session |
| StringQuery | StringQuery executes queries from a string representation. Queries are constructed like WHERE clauses in sql, except that foreign key relations between the different types are not necessary. Attributes have to be defined with the appropriate type prepended, e.g. Author.name instead of name |
| StringUtil | StringUtil provides support for string manipulation |
| Table | Table is a PersistentObject that holds a table structure. The rows of the table correspond to the value names of the PersistentObject and the columns to the datatypes. So if you want to set the value of row $i and column $j to $value call $table->setValue($i, $value, $j). To retrieve the corresponding value call $value = $table->getValue($i, $j) |
| TableRDBMapper | TableRDBMapper maps Table objects to a relational database schema where one object contains several table rows |
| TableUnifiedRDBMapper | TableRDBMapper maps Table objects to a relational database schema where one object contains several table rows. In comparison to TableRDBMapper it implements the template methods in a way that handles unified table definitions (e.g. tables are named as the type, primary keys are named 'id' and attribute names correspond to table columns). Subclasses simply need to define $_type as the mapper type and implement the getObjectDefinition() method |
| TerminateController | TerminateController stops the action processing by returning false in executeKernel |
| TreeViewController | TreeViewController is used to visualize cms data in a tree view |
| TreeViewOutputStrategy | This OutputStrategy outputs the object's content in a DHTML Treeview |
| URIUtil | URIUtil provides support for uri manipulation |
| User | Abstract base class for user classes that represent a system user |
| UserController | UserController is used to edit data of the current users |
| UserImpl | |
| UserManager | UserManager is used to edit users and roles. UserManager supports the following operations:
- create/remove a user
- create/remove a role
- add/remove a user to/from a role
- change a users password
|
| UserManagerRDB | UserManagerRDB is a UserManager that stores user and role information in a database using RDBMappers. The User and Role implementation classes are defined by the configuration keys 'User' and 'Role' in the [implementation] section |
| UserManagerXML | UserManagerXML is a UserManager that stores user and role information in an XML file |
| UserRDB | |
| UserRDBBase | |
| UserRDBRDBMapper | |
| UserXML | |
| View | View is used by Controller to handle the view presentation in MVC pattern. View is a subclass of Smarty that is customized for use with the wCMF |
| ViewController | ViewController is a controller that has no logic. It is used to display a static view only |
| Visitor | Visitor is used to extend an object's functionality by not extending its interface. Classes to use with the Visitor must implement the acceptVisitor() method. Visitor implements the 'Visitor Pattern'. It implements the 'Template Method Pattern' to allow subclasses to do any Pre- and Post Visit operations (doPreVisit() and doPostVisit() methods). The abstract base class Visitor defines the interface for all specialized Visitor classes |
| WCMFException | Use the WCMFException class to handle errors. You need not instantiate a WCMFException object because the methods may be called like static class methods e.g. $translated = WCMFWCMFException::throwEx('error message', __FILE__, __LINE__) |
| WCMFInifileParser | WCMFInifileParser adds methods for wcmf specific inifiles. This class is a decorator to the InifileParser class, showing only the readonly methods of InifileParser in it's interface. The advantage in using the InifileParser singleton inside this class is that its instance will hold the same configuration data as the WCMFInifileParser instance does.
For this reason other classes may use the InifileParser instance not knowing about the WCMFInifileParser class at all |
| XMLDataConverter | XMLDataConverter converts data between storage and XML files |
| XMLExportController | XMLExportController exports the content tree into an XML file |
| XMLOutputStrategy | This OutputStrategy outputs an object's content in a xml file using the default format |
| XMLUtil | XMLUtil helps in using XML files as storage. XMLUtil is a subclass of CXmlDb that is customized for use with the wemove cms framework |
