[tt-rss.git] / classes / pluginhost.php

<?php
class PluginHost {
	private $pdo;
	private $hooks = array();
	private $plugins = array();
	private $handlers = array();
	private $commands = array();
	private $storage = array();
	private $feeds = array();
	private $api_methods = array();
	private $plugin_actions = array();
	private $owner_uid;
	private $debug;
	private $last_registered;
	private static $instance;

	const API_VERSION = 2;

	// Hooks marked with *1 are run in global context and available
	// to plugins loaded in config.php only

	const HOOK_ARTICLE_BUTTON = 1;
	const HOOK_ARTICLE_FILTER = 2;
	const HOOK_PREFS_TAB = 3;
	const HOOK_PREFS_TAB_SECTION = 4;
	const HOOK_PREFS_TABS = 5;
	const HOOK_FEED_PARSED = 6;
	const HOOK_UPDATE_TASK = 7; // *1
	const HOOK_AUTH_USER = 8;
	const HOOK_HOTKEY_MAP = 9;
	const HOOK_RENDER_ARTICLE = 10;
	const HOOK_RENDER_ARTICLE_CDM = 11;
	const HOOK_FEED_FETCHED = 12;
	const HOOK_SANITIZE = 13;
	const HOOK_RENDER_ARTICLE_API = 14;
	const HOOK_TOOLBAR_BUTTON = 15;
	const HOOK_ACTION_ITEM = 16;
	const HOOK_HEADLINE_TOOLBAR_BUTTON = 17;
	const HOOK_HOTKEY_INFO = 18;
	const HOOK_ARTICLE_LEFT_BUTTON = 19;
	const HOOK_PREFS_EDIT_FEED = 20;
	const HOOK_PREFS_SAVE_FEED = 21;
	const HOOK_FETCH_FEED = 22;
	const HOOK_QUERY_HEADLINES = 23;
	const HOOK_HOUSE_KEEPING = 24; // *1
	const HOOK_SEARCH = 25;
	const HOOK_FORMAT_ENCLOSURES = 26;
	const HOOK_SUBSCRIBE_FEED = 27;
	const HOOK_HEADLINES_BEFORE = 28;
	const HOOK_RENDER_ENCLOSURE = 29;
	const HOOK_ARTICLE_FILTER_ACTION = 30;
	const HOOK_ARTICLE_EXPORT_FEED = 31;
	const HOOK_MAIN_TOOLBAR_BUTTON = 32;
	const HOOK_ENCLOSURE_ENTRY = 33;
	const HOOK_FORMAT_ARTICLE = 34;
	const HOOK_FORMAT_ARTICLE_CDM = 35;
	const HOOK_FEED_BASIC_INFO = 36;
	const HOOK_SEND_LOCAL_FILE = 37;

	const KIND_ALL = 1;
	const KIND_SYSTEM = 2;
	const KIND_USER = 3;

	function __construct() {
		$this->pdo = Db::pdo();

		$this->storage = array();
	}

	private function __clone() {
		//
	}

	public static function getInstance() {
		if (self::$instance == null)
			self::$instance = new self();

		return self::$instance;
	}

	private function register_plugin($name, $plugin) {
		//array_push($this->plugins, $plugin);
		$this->plugins[$name] = $plugin;
	}

	// needed for compatibility with API 1
	function get_link() {
		return false;
	}

	function get_dbh() {
		return Db::get();
	}

	function get_pdo() {
		return $this->pdo;
	}
	
	function get_plugin_names() {
		$names = array();

		foreach ($this->plugins as $p) {
			array_push($names, get_class($p));
		}

		return $names;
	}

	function get_plugins() {
		return $this->plugins;
	}

	function get_plugin($name) {
		return $this->plugins[strtolower($name)];
	}

	function run_hooks($type, $method, $args) {
		foreach ($this->get_hooks($type) as $hook) {
			$hook->$method($args);
		}
	}

	function add_hook($type, $sender) {
		if (!is_array($this->hooks[$type])) {
			$this->hooks[$type] = array();
		}

		array_push($this->hooks[$type], $sender);
	}

	function del_hook($type, $sender) {
		if (is_array($this->hooks[$type])) {
			$key = array_Search($sender, $this->hooks[$type]);
			if ($key !== FALSE) {
				unset($this->hooks[$type][$key]);
			}
		}
	}

	function get_hooks($type) {
		if (isset($this->hooks[$type])) {
			return $this->hooks[$type];
		} else {
			return array();
		}
	}
	function load_all($kind, $owner_uid = false, $skip_init = false) {

		$plugins = array_merge(glob("plugins/*"), glob("plugins.local/*"));
		$plugins = array_filter($plugins, "is_dir");
		$plugins = array_map("basename", $plugins);

		asort($plugins);

		$this->load(join(",", $plugins), $kind, $owner_uid, $skip_init);
	}

	function load($classlist, $kind, $owner_uid = false, $skip_init = false) {
		$plugins = explode(",", $classlist);

		$this->owner_uid = (int) $owner_uid;

		foreach ($plugins as $class) {
			$class = trim($class);
			$class_file = strtolower(basename($class));

			if (!is_dir(__DIR__."/../plugins/$class_file") &&
					!is_dir(__DIR__."/../plugins.local/$class_file")) continue;

			// try system plugin directory first
			$file = __DIR__ . "/../plugins/$class_file/init.php";

			if (!file_exists($file)) {
				$file = __DIR__ . "/../plugins.local/$class_file/init.php";
			}

			if (!isset($this->plugins[$class])) {
				if (file_exists($file)) require_once $file;

				if (class_exists($class) && is_subclass_of($class, "Plugin")) {
					$plugin = new $class($this);

					$plugin_api = $plugin->api_version();

					if ($plugin_api < PluginHost::API_VERSION) {
						user_error("Plugin $class is not compatible with current API version (need: " . PluginHost::API_VERSION . ", got: $plugin_api)", E_USER_WARNING);
						continue;
					}

					$this->last_registered = $class;

					switch ($kind) {
					case $this::KIND_SYSTEM:
						if ($this->is_system($plugin)) {
							if (!$skip_init) $plugin->init($this);
							$this->register_plugin($class, $plugin);
						}
						break;
					case $this::KIND_USER:
						if (!$this->is_system($plugin)) {
							if (!$skip_init) $plugin->init($this);
							$this->register_plugin($class, $plugin);
						}
						break;
					case $this::KIND_ALL:
						if (!$skip_init) $plugin->init($this);
						$this->register_plugin($class, $plugin);
						break;
					}
				}
			}
		}
	}

	function is_system($plugin) {
		$about = $plugin->about();

		return @$about[3];
	}

	// only system plugins are allowed to modify routing
	function add_handler($handler, $method, $sender) {
		$handler = str_replace("-", "_", strtolower($handler));
		$method = strtolower($method);

		if ($this->is_system($sender)) {
			if (!is_array($this->handlers[$handler])) {
				$this->handlers[$handler] = array();
			}

			$this->handlers[$handler][$method] = $sender;
		}
	}

	function del_handler($handler, $method, $sender) {
		$handler = str_replace("-", "_", strtolower($handler));
		$method = strtolower($method);

		if ($this->is_system($sender)) {
			unset($this->handlers[$handler][$method]);
		}
	}

	function lookup_handler($handler, $method) {
		$handler = str_replace("-", "_", strtolower($handler));
		$method = strtolower($method);

		if (is_array($this->handlers[$handler])) {
			if (isset($this->handlers[$handler]["*"])) {
				return $this->handlers[$handler]["*"];
			} else {
				return $this->handlers[$handler][$method];
			}
		}

		return false;
	}

	function add_command($command, $description, $sender, $suffix = "", $arghelp = "") {
		$command = str_replace("-", "_", strtolower($command));

		$this->commands[$command] = array("description" => $description,
			"suffix" => $suffix,
			"arghelp" => $arghelp,
			"class" => $sender);
	}

	function del_command($command) {
		$command = "-" . strtolower($command);

		unset($this->commands[$command]);
	}

	function lookup_command($command) {
		$command = "-" . strtolower($command);

		if (is_array($this->commands[$command])) {
			return $this->commands[$command]["class"];
		} else {
			return false;
		}

		return false;
	}

	function get_commands() {
		return $this->commands;
	}

	function run_commands($args) {
		foreach ($this->get_commands() as $command => $data) {
			if (isset($args[$command])) {
				$command = str_replace("-", "", $command);
				$data["class"]->$command($args);
			}
		}
	}

	function load_data() {
		if ($this->owner_uid)  {
			$sth = $this->pdo->prepare("SELECT name, content FROM ttrss_plugin_storage
				WHERE owner_uid = ?");
			$sth->execute([$this->owner_uid]);

			while ($line = $sth->fetch()) {
				$this->storage[$line["name"]] = unserialize($line["content"]);
			}
		}
	}

	private function save_data($plugin) {
		if ($this->owner_uid) {
			$this->pdo->beginTransaction();

			$sth = $this->pdo->prepare("SELECT id FROM ttrss_plugin_storage WHERE
				owner_uid= ? AND name = ?");
			$sth->execute([$this->owner_uid, $plugin]);

			if (!isset($this->storage[$plugin]))
				$this->storage[$plugin] = array();

			$content = serialize($this->storage[$plugin]);

			if ($sth->fetch()) {
				$sth = $this->pdo->prepare("UPDATE ttrss_plugin_storage SET content = ?
					WHERE owner_uid= ? AND name = ?");
				$sth->execute([(string)$content, $this->owner_uid, $plugin]);

			} else {
				$sth = $this->pdo->prepare("INSERT INTO ttrss_plugin_storage
					(name,owner_uid,content) VALUES
					(?, ?, ?)");
				$sth->execute([$plugin, $this->owner_uid, (string)$content]);
			}

			$this->pdo->commit();
		}
	}

	function set($sender, $name, $value, $sync = true) {
		$idx = get_class($sender);

		if (!isset($this->storage[$idx]))
			$this->storage[$idx] = array();

		$this->storage[$idx][$name] = $value;

		if ($sync) $this->save_data(get_class($sender));
	}

	function get($sender, $name, $default_value = false) {
		$idx = get_class($sender);

		if (isset($this->storage[$idx][$name])) {
			return $this->storage[$idx][$name];
		} else {
			return $default_value;
		}
	}

	function get_all($sender) {
		$idx = get_class($sender);

		return $this->storage[$idx];
	}

	function clear_data($sender) {
		if ($this->owner_uid) {
			$idx = get_class($sender);

			unset($this->storage[$idx]);

			$sth = $this->pdo->prepare("DELETE FROM ttrss_plugin_storage WHERE name = ?
				AND owner_uid = ?");
			$sth->execute([$idx, $this->owner_uid]);
		}
	}

	function set_debug($debug) {
		$this->debug = $debug;
	}

	function get_debug() {
		return $this->debug;
	}

	// Plugin feed functions are *EXPERIMENTAL*!

	// cat_id: only -1 is supported (Special)
	function add_feed($cat_id, $title, $icon, $sender) {
		if (!$this->feeds[$cat_id]) $this->feeds[$cat_id] = array();

		$id = count($this->feeds[$cat_id]);

		array_push($this->feeds[$cat_id],
			array('id' => $id, 'title' => $title, 'sender' => $sender, 'icon' => $icon));

		return $id;
	}

	function get_feeds($cat_id) {
		return $this->feeds[$cat_id];
	}

	// convert feed_id (e.g. -129) to pfeed_id first
	function get_feed_handler($pfeed_id) {
		foreach ($this->feeds as $cat) {
			foreach ($cat as $feed) {
				if ($feed['id'] == $pfeed_id) {
					return $feed['sender'];
				}
			}
		}
	}

	static function pfeed_to_feed_id($label) {
		return PLUGIN_FEED_BASE_INDEX - 1 - abs($label);
	}

	static function feed_to_pfeed_id($feed) {
		return PLUGIN_FEED_BASE_INDEX - 1 + abs($feed);
	}

	function add_api_method($name, $sender) {
		if ($this->is_system($sender)) {
			$this->api_methods[strtolower($name)] = $sender;
		}
	}

	function get_api_method($name) {
		return $this->api_methods[$name];
	}

	function add_filter_action($sender, $action_name, $action_desc) {
		$sender_class = get_class($sender);

		if (!isset($this->plugin_actions[$sender_class]))
			$this->plugin_actions[$sender_class] = array();

		array_push($this->plugin_actions[$sender_class],
			array("action" => $action_name, "description" => $action_desc, "sender" => $sender));
	}

	function get_filter_actions() {
		return $this->plugin_actions;
	}
}
Commit	Line	Data
	1	<?php
	2	class PluginHost {
	3	private $pdo;
	4	private $hooks = array();
	5	private $plugins = array();
	6	private $handlers = array();
	7	private $commands = array();
	8	private $storage = array();
	9	private $feeds = array();
	10	private $api_methods = array();
	11	private $plugin_actions = array();
	12	private $owner_uid;
	13	private $debug;
	14	private $last_registered;
	15	private static $instance;
	16
	17	const API_VERSION = 2;
	18
	19	// Hooks marked with *1 are run in global context and available
	20	// to plugins loaded in config.php only
	21
	22	const HOOK_ARTICLE_BUTTON = 1;
	23	const HOOK_ARTICLE_FILTER = 2;
	24	const HOOK_PREFS_TAB = 3;
	25	const HOOK_PREFS_TAB_SECTION = 4;
	26	const HOOK_PREFS_TABS = 5;
	27	const HOOK_FEED_PARSED = 6;
	28	const HOOK_UPDATE_TASK = 7; // *1
	29	const HOOK_AUTH_USER = 8;
	30	const HOOK_HOTKEY_MAP = 9;
	31	const HOOK_RENDER_ARTICLE = 10;
	32	const HOOK_RENDER_ARTICLE_CDM = 11;
	33	const HOOK_FEED_FETCHED = 12;
	34	const HOOK_SANITIZE = 13;
	35	const HOOK_RENDER_ARTICLE_API = 14;
	36	const HOOK_TOOLBAR_BUTTON = 15;
	37	const HOOK_ACTION_ITEM = 16;
	38	const HOOK_HEADLINE_TOOLBAR_BUTTON = 17;
	39	const HOOK_HOTKEY_INFO = 18;
	40	const HOOK_ARTICLE_LEFT_BUTTON = 19;
	41	const HOOK_PREFS_EDIT_FEED = 20;
	42	const HOOK_PREFS_SAVE_FEED = 21;
	43	const HOOK_FETCH_FEED = 22;
	44	const HOOK_QUERY_HEADLINES = 23;
	45	const HOOK_HOUSE_KEEPING = 24; // *1
	46	const HOOK_SEARCH = 25;
	47	const HOOK_FORMAT_ENCLOSURES = 26;
	48	const HOOK_SUBSCRIBE_FEED = 27;
	49	const HOOK_HEADLINES_BEFORE = 28;
	50	const HOOK_RENDER_ENCLOSURE = 29;
	51	const HOOK_ARTICLE_FILTER_ACTION = 30;
	52	const HOOK_ARTICLE_EXPORT_FEED = 31;
	53	const HOOK_MAIN_TOOLBAR_BUTTON = 32;
	54	const HOOK_ENCLOSURE_ENTRY = 33;
	55	const HOOK_FORMAT_ARTICLE = 34;
	56	const HOOK_FORMAT_ARTICLE_CDM = 35;
	57	const HOOK_FEED_BASIC_INFO = 36;
	58	const HOOK_SEND_LOCAL_FILE = 37;
	59
	60	const KIND_ALL = 1;
	61	const KIND_SYSTEM = 2;
	62	const KIND_USER = 3;
	63
	64	function __construct() {
	65	$this->pdo = Db::pdo();
	66
	67	$this->storage = array();
	68	}
	69
	70	private function __clone() {
	71	//
	72	}
	73
	74	public static function getInstance() {
	75	if (self::$instance == null)
	76	self::$instance = new self();
	77
	78	return self::$instance;
	79	}
	80
	81	private function register_plugin($name, $plugin) {
	82	//array_push($this->plugins, $plugin);
	83	$this->plugins[$name] = $plugin;
	84	}
	85
	86	// needed for compatibility with API 1
	87	function get_link() {
	88	return false;
	89	}
	90
	91	function get_dbh() {
	92	return Db::get();
	93	}
	94
	95	function get_pdo() {
	96	return $this->pdo;
	97	}
	98
	99	function get_plugin_names() {
	100	$names = array();
	101
	102	foreach ($this->plugins as $p) {
	103	array_push($names, get_class($p));
	104	}
	105
	106	return $names;
	107	}
	108
	109	function get_plugins() {
	110	return $this->plugins;
	111	}
	112
	113	function get_plugin($name) {
	114	return $this->plugins[strtolower($name)];
	115	}
	116
	117	function run_hooks($type, $method, $args) {
	118	foreach ($this->get_hooks($type) as $hook) {
	119	$hook->$method($args);
	120	}
	121	}
	122
	123	function add_hook($type, $sender) {
	124	if (!is_array($this->hooks[$type])) {
	125	$this->hooks[$type] = array();
	126	}
	127
	128	array_push($this->hooks[$type], $sender);
	129	}
	130
	131	function del_hook($type, $sender) {
	132	if (is_array($this->hooks[$type])) {
	133	$key = array_Search($sender, $this->hooks[$type]);
	134	if ($key !== FALSE) {
	135	unset($this->hooks[$type][$key]);
	136	}
	137	}
	138	}
	139
	140	function get_hooks($type) {
	141	if (isset($this->hooks[$type])) {
	142	return $this->hooks[$type];
	143	} else {
	144	return array();
	145	}
	146	}
	147	function load_all($kind, $owner_uid = false, $skip_init = false) {
	148
	149	$plugins = array_merge(glob("plugins/"), glob("plugins.local/"));
	150	$plugins = array_filter($plugins, "is_dir");
	151	$plugins = array_map("basename", $plugins);
	152
	153	asort($plugins);
	154
	155	$this->load(join(",", $plugins), $kind, $owner_uid, $skip_init);
	156	}
	157
	158	function load($classlist, $kind, $owner_uid = false, $skip_init = false) {
	159	$plugins = explode(",", $classlist);
	160
	161	$this->owner_uid = (int) $owner_uid;
	162
	163	foreach ($plugins as $class) {
	164	$class = trim($class);
	165	$class_file = strtolower(basename($class));
	166
	167	if (!is_dir(__DIR__."/../plugins/$class_file") &&
	168	!is_dir(__DIR__."/../plugins.local/$class_file")) continue;
	169
	170	// try system plugin directory first
	171	$file = __DIR__ . "/../plugins/$class_file/init.php";
	172
	173	if (!file_exists($file)) {
	174	$file = __DIR__ . "/../plugins.local/$class_file/init.php";
	175	}
	176
	177	if (!isset($this->plugins[$class])) {
	178	if (file_exists($file)) require_once $file;
	179
	180	if (class_exists($class) && is_subclass_of($class, "Plugin")) {
	181	$plugin = new $class($this);
	182
	183	$plugin_api = $plugin->api_version();
	184
	185	if ($plugin_api < PluginHost::API_VERSION) {
	186	user_error("Plugin $class is not compatible with current API version (need: " . PluginHost::API_VERSION . ", got: $plugin_api)", E_USER_WARNING);
	187	continue;
	188	}
	189
	190	$this->last_registered = $class;
	191
	192	switch ($kind) {
	193	case $this::KIND_SYSTEM:
	194	if ($this->is_system($plugin)) {
	195	if (!$skip_init) $plugin->init($this);
	196	$this->register_plugin($class, $plugin);
	197	}
	198	break;
	199	case $this::KIND_USER:
	200	if (!$this->is_system($plugin)) {
	201	if (!$skip_init) $plugin->init($this);
	202	$this->register_plugin($class, $plugin);
	203	}
	204	break;
	205	case $this::KIND_ALL:
	206	if (!$skip_init) $plugin->init($this);
	207	$this->register_plugin($class, $plugin);
	208	break;
	209	}
	210	}
	211	}
	212	}
	213	}
	214
	215	function is_system($plugin) {
	216	$about = $plugin->about();
	217
	218	return @$about[3];
	219	}
	220
	221	// only system plugins are allowed to modify routing
	222	function add_handler($handler, $method, $sender) {
	223	$handler = str_replace("-", "_", strtolower($handler));
	224	$method = strtolower($method);
	225
	226	if ($this->is_system($sender)) {
	227	if (!is_array($this->handlers[$handler])) {
	228	$this->handlers[$handler] = array();
	229	}
	230
	231	$this->handlers[$handler][$method] = $sender;
	232	}
	233	}
	234
	235	function del_handler($handler, $method, $sender) {
	236	$handler = str_replace("-", "_", strtolower($handler));
	237	$method = strtolower($method);
	238
	239	if ($this->is_system($sender)) {
	240	unset($this->handlers[$handler][$method]);
	241	}
	242	}
	243
	244	function lookup_handler($handler, $method) {
	245	$handler = str_replace("-", "_", strtolower($handler));
	246	$method = strtolower($method);
	247
	248	if (is_array($this->handlers[$handler])) {
	249	if (isset($this->handlers[$handler]["*"])) {
	250	return $this->handlers[$handler]["*"];
	251	} else {
	252	return $this->handlers[$handler][$method];
	253	}
	254	}
	255
	256	return false;
	257	}
	258
	259	function add_command($command, $description, $sender, $suffix = "", $arghelp = "") {
	260	$command = str_replace("-", "_", strtolower($command));
	261
	262	$this->commands[$command] = array("description" => $description,
	263	"suffix" => $suffix,
	264	"arghelp" => $arghelp,
	265	"class" => $sender);
	266	}
	267
	268	function del_command($command) {
	269	$command = "-" . strtolower($command);
	270
	271	unset($this->commands[$command]);
	272	}
	273
	274	function lookup_command($command) {
	275	$command = "-" . strtolower($command);
	276
	277	if (is_array($this->commands[$command])) {
	278	return $this->commands[$command]["class"];
	279	} else {
	280	return false;
	281	}
	282
	283	return false;
	284	}
	285
	286	function get_commands() {
	287	return $this->commands;
	288	}
	289
	290	function run_commands($args) {
	291	foreach ($this->get_commands() as $command => $data) {
	292	if (isset($args[$command])) {
	293	$command = str_replace("-", "", $command);
	294	$data["class"]->$command($args);
	295	}
	296	}
	297	}
	298
	299	function load_data() {
	300	if ($this->owner_uid) {
	301	$sth = $this->pdo->prepare("SELECT name, content FROM ttrss_plugin_storage
	302	WHERE owner_uid = ?");
	303	$sth->execute([$this->owner_uid]);
	304
	305	while ($line = $sth->fetch()) {
	306	$this->storage[$line["name"]] = unserialize($line["content"]);
	307	}
	308	}
	309	}
	310
	311	private function save_data($plugin) {
	312	if ($this->owner_uid) {
	313	$this->pdo->beginTransaction();
	314
	315	$sth = $this->pdo->prepare("SELECT id FROM ttrss_plugin_storage WHERE
	316	owner_uid= ? AND name = ?");
	317	$sth->execute([$this->owner_uid, $plugin]);
	318
	319	if (!isset($this->storage[$plugin]))
	320	$this->storage[$plugin] = array();
	321
	322	$content = serialize($this->storage[$plugin]);
	323
	324	if ($sth->fetch()) {
	325	$sth = $this->pdo->prepare("UPDATE ttrss_plugin_storage SET content = ?
	326	WHERE owner_uid= ? AND name = ?");
	327	$sth->execute([(string)$content, $this->owner_uid, $plugin]);
	328
	329	} else {
	330	$sth = $this->pdo->prepare("INSERT INTO ttrss_plugin_storage
	331	(name,owner_uid,content) VALUES
	332	(?, ?, ?)");
	333	$sth->execute([$plugin, $this->owner_uid, (string)$content]);
	334	}
	335
	336	$this->pdo->commit();
	337	}
	338	}
	339
	340	function set($sender, $name, $value, $sync = true) {
	341	$idx = get_class($sender);
	342
	343	if (!isset($this->storage[$idx]))
	344	$this->storage[$idx] = array();
	345
	346	$this->storage[$idx][$name] = $value;
	347
	348	if ($sync) $this->save_data(get_class($sender));
	349	}
	350
	351	function get($sender, $name, $default_value = false) {
	352	$idx = get_class($sender);
	353
	354	if (isset($this->storage[$idx][$name])) {
	355	return $this->storage[$idx][$name];
	356	} else {
	357	return $default_value;
	358	}
	359	}
	360
	361	function get_all($sender) {
	362	$idx = get_class($sender);
	363
	364	return $this->storage[$idx];
	365	}
	366
	367	function clear_data($sender) {
	368	if ($this->owner_uid) {
	369	$idx = get_class($sender);
	370
	371	unset($this->storage[$idx]);
	372
	373	$sth = $this->pdo->prepare("DELETE FROM ttrss_plugin_storage WHERE name = ?
	374	AND owner_uid = ?");
	375	$sth->execute([$idx, $this->owner_uid]);
	376	}
	377	}
	378
	379	function set_debug($debug) {
	380	$this->debug = $debug;
	381	}
	382
	383	function get_debug() {
	384	return $this->debug;
	385	}
	386
	387	// Plugin feed functions are EXPERIMENTAL!
	388
	389	// cat_id: only -1 is supported (Special)
	390	function add_feed($cat_id, $title, $icon, $sender) {
	391	if (!$this->feeds[$cat_id]) $this->feeds[$cat_id] = array();
	392
	393	$id = count($this->feeds[$cat_id]);
	394
	395	array_push($this->feeds[$cat_id],
	396	array('id' => $id, 'title' => $title, 'sender' => $sender, 'icon' => $icon));
	397
	398	return $id;
	399	}
	400
	401	function get_feeds($cat_id) {
	402	return $this->feeds[$cat_id];
	403	}
	404
	405	// convert feed_id (e.g. -129) to pfeed_id first
	406	function get_feed_handler($pfeed_id) {
	407	foreach ($this->feeds as $cat) {
	408	foreach ($cat as $feed) {
	409	if ($feed['id'] == $pfeed_id) {
	410	return $feed['sender'];
	411	}
	412	}
	413	}
	414	}
	415
	416	static function pfeed_to_feed_id($label) {
	417	return PLUGIN_FEED_BASE_INDEX - 1 - abs($label);
	418	}
	419
	420	static function feed_to_pfeed_id($feed) {
	421	return PLUGIN_FEED_BASE_INDEX - 1 + abs($feed);
	422	}
	423
	424	function add_api_method($name, $sender) {
	425	if ($this->is_system($sender)) {
	426	$this->api_methods[strtolower($name)] = $sender;
	427	}
	428	}
	429
	430	function get_api_method($name) {
	431	return $this->api_methods[$name];
	432	}
	433
	434	function add_filter_action($sender, $action_name, $action_desc) {
	435	$sender_class = get_class($sender);
	436
	437	if (!isset($this->plugin_actions[$sender_class]))
	438	$this->plugin_actions[$sender_class] = array();
	439
	440	array_push($this->plugin_actions[$sender_class],
	441	array("action" => $action_name, "description" => $action_desc, "sender" => $sender));
	442	}
	443
	444	function get_filter_actions() {
	445	return $this->plugin_actions;
	446	}
	447	}