~quam-plures-core/quam-plures/qp5_colls-blogs_chaps-cats

 

/**

 * Plugins base class

 * @package plugins

 */

class Plugins

                global $plugins_subdir;

                global $Timer;

 

                $this->plugins_path = $basepath.$plugins_subdir;

                $Timer->resume( 'plugin_init' );

 

                $this->load_events();

                $Timer->pause( 'plugin_init' );

        }

 

        /**

         * Get a list of available Plugin groups

         * @return array

         */

        function get_plugin_groups()

 

        /**

         * Get Plugins in group

         * Will return an array that contents are references to plugins that have the same group.

         * @return array

         */

        function get_Plugins_in_group( $group )

         * {@link Plugins_admin}, because we want to keep it in then in our indices. Note:

         * this should probably always get called on the {@link $Plugins} object, not

         * {@link $admin_Plugins}.

         * @param Plugin

         * @param string New status ("enabled", "disabled", "needs_config", "broken")

         * @return boolean True on success, false on failure.

                }

                else

                {

                        $Plugin->BeforeDisable();

                        $this->unregister( $Plugin );

                }

         * (anymore) and instantiates the Plugin's (User)Settings. Attention: The code of

         * the plugin is set to NULL if it is found to be not unique! To get the original

         * code, use the $orig_code parameter.

         * @param string name of plugin class to instantiate and register

         * @param int ID in database (0 if not installed)

         * @param int Priority in database (-1 to keep default)

         * of the plugin we are registering, even if the code is found to be not unique.

         * @return Plugin Plugin ref to newly created plugin; string in case of error

         */

        {

                global $Messages;

                global $Timer;

                                $this->plugin_errors[$ID]['register'] = $r;

                                $this->set_Plugin_status( $Plugin, 'broken' );

 

                                if( $this->unregister( $Plugin ) )

                                {

                                        // debuglog-add removed

                                $Plugin = & $this->register( $classname, $ID, $priority, $apply_rendering, $classfile_path, false );

                                $this->plugin_errors[$ID]['register'] = $r;

                                $this->set_Plugin_status( $Plugin, 'broken' );

                                if( $this->unregister( $Plugin ) )

                                {

                                        // debuglog-add removed

                }

                // Tell him his name :)

                $Plugin->classname = $classname;

                if( $priority > -1 ) { $Plugin->priority = $priority; }

 

                if( isset( $apply_rendering ) )

                        $this->sorted_IDs[] = & $Plugin->ID;

                }

 

                $this->init_settings( $Plugin );

 

                if( $Plugin->ID > 0 )

                {

                        $tmp_params = array( 'db_row' => $this->index_ID_rows[$Plugin->ID], 'is_installed' => true );

                                // Version has changed since installation or last update

                                $db_deltas = array();

 

                                $tmp_params = array( 'old_version' => $this->index_ID_rows[$Plugin->ID]['plug_version'], 'db_row' => $this->index_ID_rows[$Plugin->ID] );

 

                                if( $this->call_method( $Plugin->ID, 'PluginVersionChanged', $tmp_params ) === false )

                                        $this->set_Plugin_status( $Plugin, 'needs_config' );

                                        if( $this->unregister( $Plugin ) )

                                        {

                                                $Plugin = '';

                                        }

                                }

                                else

                                {

                                        load_funcs( '_core/model/db/_upgrade.funcs.php' );

                                        $db_deltas = db_delta( $Plugin->GetDbLayout() );

 

                                                // No DB changes needed, update (bump or decrease) the version

                                                $Plugins_admin = & get_Cache('Plugins_admin');

 

                                                $DB->query( 'UPDATE T_plugins

                                                        SET plug_version = '.$DB->quote( $Plugin->version ).'

                                                        WHERE plug_ID = '.$Plugin->ID );

 

                                                $this->index_ID_rows[$Plugin->ID]['plug_version'] = $Plugin->version;

                                                if( isset( $Plugins_admin->index_ID_rows[$Plugin->ID] ) )

                                                {

                                                        $Plugins_admin->index_ID_rows[$Plugin->ID]['plug_version'] = $Plugin->version;

                                                }

 

                                                if( ! empty( $Plugin->code ) )

                                                {

                                                        $DB->query( 'DELETE FROM T_items__prerendering

                                                                WHERE itpr_renderers REGEXP "^(.*\.)?'.$DB->escape( $Plugin->code ).'(\..*)?$"' );

                                                }

 

                                                if( $Plugins_admin->save_events( $Plugin, array() ) )

                                                {

                                                        $this->load_events(); // re-load for the current request

 

                                                if( $this->unregister( $Plugin ) )

                                                {

                                                        $Plugin = '';

                                                }

                                        }

                }

                else

                {

                        // We're not instantiating UserSettings/Settings, since that needs a DB backend.

                        $tmp_params = array( 'db_row' => array(), 'is_installed' => false );

                        if( $Plugin->PluginInit( $tmp_params ) === false && $this->unregister( $Plugin ) )

         * Un-register a plugin

         *

         * This does not un-install it from DB, just from the internal indexes.

         * @param Plugin

         * @param boolean Force unregistering (ignored here, but used in Plugins_admin)

         * @return boolean True, if unregistered

        {

                $this->forget_events( $Plugin->ID );

 

                if( isset( $this->index_apply_rendering_codes[$Plugin->apply_rendering] ) )

                {

                        while( ( $key = array_search( $Plugin->code, $this->index_apply_rendering_codes[$Plugin->apply_rendering] ) ) !== false )

         * This gets used when {@link unregister() unregistering} a Plugin or if

         * {@link Plugin::PluginInit()} returned false, which means

         * "do not use it for subsequent events in the request".

         * @param integer Plugin ID

         */

        function forget_events( $plugin_ID )

        {

                foreach( array_keys( $this->index_event_IDs ) as $l_event )

                {

                        while( ( $key = array_search( $plugin_ID, $this->index_event_IDs[$l_event] ) ) !== false )

 

        /**

         * Init {@link Plugin::$Settings} and {@link Plugin::$UserSettings}

         * @param Plugin

         */

        function init_settings( & $Plugin )

         *

         * The plugin must provide setting definitions (through {@link Plugin::GetDefaultSettings()}

         * OR {@link Plugin::GetDefaultUserSettings()}).

         * @param Plugin

         * @param string settings type: "Settings" or "UserSettings"

         * @return boolean NULL, if no Settings

 

                $Timer->resume( 'plugins_inst_'.$set_type );

 

                $method = 'GetDefault'.$set_type;

                $params = array( 'for_editing' => false );

                $Timer->resume( $Plugin->classname.'_(#'.$Plugin->ID.')' );

 

                if( empty( $defaults ) )

                {

                        $Timer->pause( 'plugins_inst_'.$set_type );

                        return NULL;

                }

                if( ! is_array( $defaults ) )

                {

                        // invalid data

                }

 

                if( $set_type == 'UserSettings' )

                        $set_Obj = & $Plugin->Settings;

                }

 

                foreach( $defaults as $l_name => $l_meta )

                {

                        if( isset( $l_meta['layout'] ) )

                                continue;

                        }

 

                        if( isset( $l_meta['defaultvalue'] ) )

                        {

                                $set_Obj->_defaults[$l_name] = $l_meta['defaultvalue'];

         *

         * NOTE: You'll have to call {@link restart()} or {@link load_plugins_table()}

         * before using it.

         * @return Plugin (false if no more plugin).

         */

        function & get_next()

 

        /**

         * Call all plugins for a given event

         * @param string event name, see {@link Plugins_admin::get_supported_events()}

         * @param array Associative array of parameters for the Plugin

         * @return boolean True, if at least one plugin has been called.

 

                        if( ! empty( $this->_stop_propagation ) )

                        {

                                $this->_stop_propagation = false;

                                break;

                        }

 

        /**

         * Call all plugins for a given event, until the first one returns true

         * @param string event name, see {@link Plugins_admin::get_supported_events()}

         * @param array Associative array of parameters for the Plugin

         * @return array The (modified) params array with key "plugin_ID" set to the last called plugin;

 

        /**

         * Call all plugins for a given event, until the first one returns false

         * @param string event name, see {@link Plugins_admin::get_supported_events()}

         * @param array Associative array of parameters for the Plugin

         * @return array The (modified) params array with key "plugin_ID" set to the last called plugin;

        /**

         * Call all plugins for a given event, until the first one returns a value

         * (not NULL) (and $search is fulfilled, if given)

         * @param string event name, see {@link Plugins_admin::get_supported_events()}

         * @param array|NULL Associative array of parameters for the Plugin

         * @param array|NULL If provided, the return value gets checks against this criteria.

 

        /**

         * Trigger an event and return an index of params

         * This is handy to collect return values from all plugins hooking an event.

         * @param string Event name, see {@link Plugins_admin::get_supported_events()}

         * @param array Associative array of parameters for the Plugin

         * @param string Index of $params that should get returned

 

        /**

         * The same as {@link get_trigger_event()}, but stop when the first Plugin returns true

         * @param string Event name, see {@link Plugins_admin::get_supported_events()}

         * @param array Associative array of parameters for the Plugin

         * @param string Index of $params that should get returned

 

        /**

         * Trigger an event and return the first return value of a plugin

         * @param string Event name, see {@link Plugins_admin::get_supported_events()}

         * @param array Associative array of parameters for the Plugin

         * @return mixed NULL if no Plugin returned something or the return value of the first Plugin

 

        /**

         * Trigger an event and return an array of all return values of the relevant plugins

         * @param string Event name, see {@link Plugins_admin::get_supported_events()}

         * @param array Associative array of parameters for the Plugin

         * @param boolean Ignore {@link empty() empty} return values?

 

 

        /**

         *

         * This makes sure that the Timer for the Plugin gets resumed.

         * @param integer Plugin ID

         * @param string Method name.

         * @param array Params (by reference).

         * This is a wrapper around {@link call_method()}.

         *

         * fp> why doesn't call_method always check if it's deactivated?

         * @param integer Plugin ID

         * @param string Method name.

         * @param array Params (by reference).

         * T-Tag: Call a specific plugin by its code

         *

         * This will call the {@link Plugin::TemplateTag()} event handler.

         * @uses Plugins::get_by_code()

         * @uses Plugins::call_method_if_active() TemplateTag

         * @param string plugin code

 

        /**

         * Render the content of an item by calling the relevant renderer plugins

         * @param string content to render (by reference)

         * @param array renderer codes to use for opt-out, opt-in and lazy

         * @param string Output format, see {@link format_to_output()}. Only 'htmlbody',

                        {

                                case 'stealth':

                                case 'always':

 

                                case 'opt-out':

                                case 'opt-in':

                                case 'lazy':

 

                                case 'never':

                        }

                }

 

 

        /**

         * Quick-render a string with a single plugin and format it for output

         * @todo (0000) rename

         * @see format_to_output()

         * @param string Plugin code (must have render() method)

                $Plugin = & $this->get_by_code( $plugin_code );

                if( $Plugin )

                {

                        $events = $this->get_enabled_events( $Plugin->ID );

                        $event = false;

                        if( $params['format'] == 'htmlbody' || $params['format'] == 'htmlentityencoded' )

 

                foreach( $DB->get_results( $this->sql_load_plugins_table, ARRAY_A ) as $row )

                {

                        $this->index_ID_rows[$row['plug_ID']] = $row; // remember the rows to instantiate the Plugin on request

                        if( ! empty( $row['plug_code'] ) )

                        {

         * Get a specific plugin by its ID

         *

         * This is the workhorse when it comes to lazy-instantiating a Plugin.

         * @param integer plugin ID

         * @return Plugin (false in case of error)

         */

 

                        $row = & $this->index_ID_rows[$plugin_ID];

 

                        $Plugin = & $this->register( $row['plug_classname'], $row['plug_ID'], $row['plug_priority'], $row['plug_apply_rendering'] );

 

                        if( is_string( $Plugin ) )

 

        /**

         * Get a plugin by its classname

         * @param string

         * @return Plugin (false in case of error)

         */

 

        /**

         * Get a specific Plugin by its code

         * @param string plugin code

         * @return Plugin (false in case of error)

         */

 

        /**

         * Get a list of Plugins for a given event

         * @param string Event name

         * @return array plugin_ID => & Plugin

         */

 

        /**

         * Get a list of Plugins for a list of events. Every Plugin is only once in this list

         * @param array Array of events

         * @return array plugin_ID => & Plugin

         */

 

        /**

         * Get a list of plugins that provide all given events

         * @return array plugin_ID => & Plugin

         */

        function get_list_by_all_events( $events )

 

        /**

         * Get a list of (enabled) events for a given Plugin ID

         * @param integer Plugin ID

         * @return array

         */

 

        /**

         * Has a plugin a specific event registered and enabled?

         * @param integer

         * @param string

         * @return boolean

 

        /**

         * Check if the requested list of events is provided by any or one plugin

         * @param array|string A single event or a list thereof

         * @return boolean

         */

        function are_events_available( $events, $require_all_in_same_plugin = false )

 

 

        /**

         */

        function load_events()

        {

 

 

        /**

         * Load an object from a Cache plugin or create a new one if we have a

         * cache miss or no caching plugins.

         *

         * @param string object name

         * @param string eval this to create the object. Default is to create an object of class $objectName.

         * @return boolean True, if retrieved from cache; false if not

                        }

                }

 

                if( empty( $eval_create_object ) )

                {

                        $GLOBALS[$objectName] = new $objectName(); // COPY (FUNC)

                        eval( '$GLOBALS[\''.$objectName.'\'] = '.$eval_create_object.';' );

                }

 

                $set_return = $this->trigger_event_first_true( 'CacheObjects',

                        array( 'action' => 'set', 'key' => 'object_'.$objectName, 'data' => & $GLOBALS[$objectName] ) );

 

 

 

        /**

         *

         * @return Plugin (false in case of error)

         */

 

        /**

         * Validate renderer list

         * @param array renderer codes ('default' will include all "opt-out"-ones)

         * @return array validated array of renderer codes

         */

                                }

                        }

                }

                if( isset( $index['lazy'] ) )

                {

                        foreach( $index['lazy'] as $l_code )

                        }

                }

 

                foreach( $validated_renderers as $k => $l_code )

                {

                        if( empty( $l_code ) || strpos( $l_code, '.' ) !== false )