Einleitung

Zurück zum Inhaltsverzeichnis

Dieses Dokument beschreibt, wie du deine eigenen Nucleus Plugins erstellen kannst.

Inhaltsverzeichnis

• Einleitung
• Dein erstes Plugin
• Übersicht über die Klasse NucleusPlugin
• Die Skinvariablen (skinvar) <%plugin(...)%>
• The Templatevariable (templatevar) <%plugin(...)%>
• Aktionen in action.php
• Ereignisse und wie man darauf reagiert
• Optionen speichern
• Datenbanktabellen
• Den Adminbereich zur Verfügung stellen
• Hilfeseiten bereitstellen
• Plugin Abhängigkeitscheck

Einleitung

Nucleus erlaubt jedem, Funktionalitäten zu ergänzen, ohne den bestehenden PHP Code ändern zu müssen. Erweiterungen sind simple PHP Skripte, die bestimmte Funktionen implementieren. Erweiterungen können einfach zwischen verschiedenen Nucleusbenutzern ausgetauscht werden. Die Installation ist einfach: Die Datei in das entsprechende Verzeichnis kopieren und Nucleus Bescheid geben das sie da ist.

Einige Vorteile von Nucleus Erweiterungen:

• Funktionalität kann einfach zum Nucleus Framework hinzugefügt werden, ohne viel über dessen Implementation wissen zu müssen.
• Installiere nur Plugins die du brauchst. Das spart Zeit bei der Seitengenerierung.

Alle Plugindateien sollten in das in config.php aufgeführte Verzeichnis gespielt werden. Normalerweise ist dies .../nucleus/plugins/. Plugindateien sind NP_name.php benannt, wobei name der Name des Plugins ist. Einige Plugins benötigen ein Unterverzeichnis mit gleichem Namen name um zusätzliche Dateien des Adminbereiches zu speichern.

Dein erstes Plugin

Lass uns dein erstes Plugin erstellen. Jedes Plugin ist eine PHP Klasse welche von der Klasse NucleusPlugin abgeleitet ist.

<?php

class NP_HelloWorld extends NucleusPlugin
{
	// Name des Plugins
	function getName()
	{
		return 'Hallo Welt';
	}

	// Autor des Plugins
	function getAuthor()
	{
		return 'Wouter Demuynck';
	}

	// Eine URL zur Pluginwebseite.
	// Kann auch mailto:foo@bar.com sein.
	function getURL()
	{
		return 'http://nucleuscms.org/';
	}

	// Version des Plugins
	function getVersion()
	{
		return '1.0';
	}

	// Eine Beschreibung, wie sie auf der Seite 
	// "Installierte Plugins" angezeigt wird
	function getDescription()
	{
		return 'Einfach ein Beispielplugin.';
	}

	function doSkinVar($skinType)
	{
		echo 'Hallo Welt';
	}

	function supportsFeature ($what)
	{
		switch ($what)
		{
			case 'SqlTablePrefix':
				return 1;
			default:
				return 0;
		}
	}

}
?>

1. Füge den Code in eine Datei mit dem Namen NP_HalloWelt.php ein und kopiere diese in dein Pluginverzeichnis (plugins). Achtung: Es darf sich kein Leerzeichen zwischen dem letzten ?> bzw. dem ersten <?php befinden!. NP steht übrigens für "Nucleus Plugin".
2. Öffne den Nucleus Administrationsbereich und gehe zu Nucleus Management/Manage Plugins
3. Du wirst nun das HalloWelt Plugin zum installieren vorfinden. Wenn alles erfolgreich installiert wurde, erscheint der Name in der Liste der installierten Plugins.
4. Nun editiere eines deiner Skins und füge das Folgende an einer Stelle ein, von der du weißt wo sie später erscheinen wird.

   <%HalloWelt%>

   Beachte die Groß-/Kleinschreibung des Namens (HalloWelt).
5. Jetzt rufe die Seite, die das Skin benutzt auf. "Hallo Welt" sollte an der Stelle erscheinen, an die du die Variable geschrieben hast.

Na, das war doch nicht so schwer, oder? Weiter gehts.

Übersicht über die Klasse NucleusPlugin

Alle Nucleus Plugins müssen von der PHP Klasse NucleusPlugin erben. Das klingt komplizierter als es ist. Es macht dein Leben sogar einfacher, da du nur die Methoden implementieren musst, die dein Plugin benötigt. Außerdem erhätst du Zugriff auf einige hilfreiche Funktionen.

Unten ist eine Übersicht der Methoden, die NucleusPlugin bietet und welche im eigenen Plugin überschrieben werden können. Wenn du den Quelltext der Klasse selbst sehen möchtest, er ist unter nucleus/libs/PLUGIN.php zu finden.

Neben den überschreibbaren Funktionen bietet die Klasse NucleusPlugin einige zusätzliche Funktionen, welche du nicht überschreiben solltest. Sie können aber innerhalb deines Plugins mit $this->funktionsname() aufgerufen werden.

Die Skinvariablen (skinvar)

Beschreibung

Du kannst eigene Skinvariablen erstellen und diese aufrufen: <%plugin(Pluginname,Parameter)%> oder <%Pluginname(Parameter)%> (falls das nicht im Konflikt mit existierenden Variablen steht). Parameter werden durch Komma getrennt.

Um Skinvariablen zu verwalten, musst du doSkinVar überschreiben. Einige Beispiele von Funktionssignaturen:

function doSkinVar($skinType)
function doSkinVar($skinType, $param1, $param2)
function doSkinVar($skinType, $skinVar, $param1, $param2)
function doSkinVar($skinType, $skinVar, $param1 = 'Standardwert')

• Der $skinType Parameter ist 'index', 'item', 'archive', 'archivelist', 'member', 'error', 'search', 'imagepopup' oder 'template'
• $skinVar ist der erste Parameter, der als ein Typ der Skinvariable interpretiert wird. Z.B. <%plugin(Pluginname,Variablentyp)%>)
• Du kannst doSkinVar() (ohne Parameterangabe) benutzen und die Parameter über die PHP Funktion func_get_args() auslesen. Das ist praktisch, falls du mehrere verschiedene Typen von Skinvariablen mit verschiedener Anzahl von Parametern behandeln möchtest.

Hinweis

• (v2.0b) Der Name des Skins, welches gerade gelesen wird, ist in der globalen Variable $currentSkinName vermerkt.

The Templatevariable (templatevar)

Beschreibung

Templatevariablen arbeiten prinzipiel genau so wie Skinvariablen. Es gibt zwei Unterschiede:

1. Sie werden aus Templates heraus aufgerufen, nicht aus Skins heraus.
2. Sie bekommen keinen Parameter $skinType. Statt dessen erhalten Templatevariablen extra Parameter mit Informationen über das Item und den Kommentar, welcher gerade gelesen wird:
   • Die Funktion doTemplateVar bekommt ein &$item Parameter.
   • Die Funktion doTemplateCommentsVar bekommt ein &$item und ein &$comment Parameter.
   Beachte das & !

Templatevariablen werden genau so aufgerufen wie Skinvariablen (mit <%plugin(Pluginname,Parameter)%> oder <%Pluginname(Parameter)%>)

Alle Templatevariablen werden normalerweise der Funktion doSkinVar übergeben mit 'template' als Parameter skinType.

In deiner eigenen Implementation musst du die Funktion doTemplateVar und/oder doTemplateCommentsVar überschreiben. Diese sind äquivalent zu doSkinVar, außer dass der Parameter skinType fehlt.

function doTemplateVar(&$item)
function doTemplateVar(&$item, $param1, $param2)
function doTemplateVar(&$item, $type, $param1, $param2)
function doTemplateVar(&$item, $type, $param1 = 'Standardwert')
function doTemplateCommentsVar(&$item, &$comment)
function doTemplateCommentsVar(&$item, &$comment, $param1, $param2)
function doTemplateCommentsVar(&$item, &$comment, $type, $param1, $param2)
function doTemplateCommentsVar(&$item, &$comment, $type, $param1 = 'Standardwert')

Hinweis

• (v2.0b) Der Name des Templates, welches gerade benutzt wird, ist in der globalen Variable $currentTemplateName vermerkt.

Aktionen in action.php

Pluginaktionen können mittels action.php ausgeführt werden, dasselbe Skript, welches zum Empfang von Kommentaren und Karma-Votes benutzt wird. Du kannst es sowohl mit GET als auch POST aufrufen. Benötigte Parameter sind action (sollte 'plugin' sein), name (Name des Plugins) und type (Typ der angeforderten Aktion).

Um diese Aktionen zu ermöglichen, sollte die Funktion doAction($actionType) implementiert werden. Zusätzliche Parameter der URL können über requestVar('name') ausgelesen werden (requestVar behandelt magic_quotes_gpc, welches PHP hinzufügt)

Wenn deine doAction einen String liefert, wird dies als Fehler interpretiert und eine Meldung wird angezeigt.

Ereignisse und wie man darauf reagiert

Nucleusplugins können sich auf Ereignisse registrieren, welche auftreten, wenn etwas wichtiges passiert. Das Plugin kann dann bestimmte Aktionen ausführen oder Text ausgeben.

Beispiel

Unten ist ein Beispiel wie ein Plugin sich auf PreAddComment registriert. PreAddComment ist ein Ereignis, welches direkt vor dem Einfügen eines Kommentares zu einem Blog generiert wird.

class NP_Acronyms extends NucleusPlugin {
  ...
  function getEventList() { return array('PreAddComment'); }
  ...
  function event_PreAddComment(&$data) {
	// replace acronym HTML
	$data['comment']['body'] =
		strreplace('HTML',
				   '<acronym title="HyperText Markup Language">HTML</acronym>',
				   $data['comment']['body']);
  }
}

Dieses Plugin ersetzt den Text HTML in jedem Kommentar mit <acronym title="HyperText Markup Language">HTML</acronym>. Das acronym-Tag ist ein HTML-Tag das dem Autor erlaubt, zusätzliche Informationen über Akronyme anzugeben.

Registrieren auf Events

Es folgen die Schritte, die du beacten musst um dich auf Ereignisse zu registrieren:

1. Füge den Ereignisnamen in das Array ein, welches von getEventList geliefert wird.
2. Erzeuge eine Funktion mit der Signatur event_Ereignisname($data), in welchem die Behandlung des Ereignisses stattfindet.

Mehrere Plugins können sich auf das selbe Ereignis registrieren. Die Reihenfolge, in der diese Plugins benachrichtigt werden ist die der Liste der Plugins im Administrationsbereich. Plugins, die sich weiter oben in der Liste befinden, werden eher benachrichtigt.

Parameter

Die Funktion event_Ereignisname erhält nur einen Parameter, $data, dessen Inhalt sich von Ereignis zu Ereignis unterscheidet. Es ist ein assoziatives Array. Objekte und Arrays in diesem Array werden per Reference übergeben. Änderungen daran bleiben daher erhalten.

Die Ereignisliste unten benutzt Farben um zu kennzeichnen, ob Änderungen an den Parametern von Nucleus gesehen werden oder nicht:

• Übergabe per Referenz: Wenn Änderungen an den Parametern erfolgen, werden diese von Nucleus gesehen.
• Übergabe per Wert: Eine Kopie der Daten wird gemacht, bevor sie an die Ereignisbehandlung des Plugins übergeben werden. Änderungen am Inhalt von diesen Variablen werden automatisch verworfen.

Objekte, welche als Parameter übergeben werden, sind wie folgt gekennzeichnet: object. Die meisten Objekte werden als Referenz übergeben, wodurch sie folgendermaßen aussehen: object by ref

Ereignisliste

<h3>Pluginname</h3>
<p>dein Zeug</p>

<h4>Pluginname</h4><form method="post" action="..."><p>
Dein Zeug
</p></form>

<h4>Pluginname</h4><form method="post" action="..."><p>
Dein Zeug
</p></form>

<h4>Pluginname</h4><form method="post" action="..."><p>
Dein Zeug
</p></form>

Optionen speichern

Eine Reihe von Methoden werden angeboten um das setzen und abfragen von Optionen für Plugins einfacher zu machen. Diese Optionen können direkt aus dem Administrationsbereich von Nucleus editiert werden. Dies beseitigt die Notwendigkeit, einen eigenen Administrationsbereich zur Verfügung stellen zu müssen. Außerdem müssen Optionen nicht innerhalb der PHP Datei gespeichert werden.

Folgende Optionen stehen in verschiedenen Kontexten zur Verfügung:

1. Globale Optionen: Editierbar auf dem Administrationsbereich des Pluginbereichs.
2. Blog Optionen: Editierbar auf der Blogeinstellungen Seite.
3. Category options: Editierbar auf der Blogeinstellungen Seite (unter 'Kategorie bearbeiten').
4. Mitglieder Optionen: Editierbar auf der 'Mitglieder bearbeiten' Seite
5. Einträge Optionen: Editierbar auf der 'Eintrag hinzufügen' oder 'Eintrag bearbeiten'

Optionstypen

Verschiedene Typen von Optionen werden zur Verfügung gestellt

text

Einfacher Text

yesno

Entweder den Wert 'yes' oder den Wert 'no' (im Eingabebereich als Auswahlfeld (radio button))

password

Textfeld (kein Text bei Eingabe)

textarea (v2.2)

Textfeld mit mehreren Zeilen

select (v2.2)

Auswahlmenu. Benötigt zusätzliche Informationen der Form: Option 1|wert1|Option 2|wert2|Option 3|wert3

Metainformationen über Optionen

Ab Nucleus Version 3.2 können Optionen über Metainformationen auf bestimmte Werte beschränkt werden. Diese Metainformationen werden im Feld $typeExtras als Semikolongetrennte Liste gespeichert. Bemerkung: In einem Auswahlmenu muss die Liste der erste Wert in $typeExtras sein.

Einige Beispiele:

// Erzeugt eine Textoption die nur numerische Eingaben erlaubt
$this->createBlogOption('FooBar', 'foobar', 'text', '0', 'datatype=numerical');
// Erzeugt ein Auswahlmenu das nur numerische Eingaben erlaubt
$this->createItemOption('FooBar', 'foobar', 'select', '0', '0|0|1|1|2|2;datatype=numerical');
// Erzeugt ein nicht beschreibbares Textfeld
$this->createOption('FooBar', 'foobar', 'textarea', 'This textarea is readonly', 'access=readonly');

Einschränkungen

1. Der Name einer Option darf aus maximal 20 Zeichen bestehen.
2. Die Beschreibung einer Option darf maximal 255 Zeichen enthalten.
3. Der Wert einer Option hat kein Limit. (Vor v2.5 war das Limit 128 Zeichen).
4. Die Zeichen '=', '|' und ';' dürfen nicht in Auswahllisten benutzt werden (für Werte) oder in Metainformationen über Optionen

Die Methoden

createOption($name, $desc, $type, $defValue = '', $typeExtras = '')

Erzeugt eine neue Option im globalen Kontext

(v2.2) createBlogOption($name, $desc, $type, $defValue = '', $typeExtras = '')

Erzeugt eine Option im blog Kontext (siehe createOption)

(v2.2) createCategoryOption($name, $desc, $type, $defValue = '', $typeExtras = '')

Erzeugt eine Option im category Kontext (siehe createOption)

(v2.2) createMemberOption($name, $desc, $type, $defValue = '', $typeExtras = '')

Erzeugt eine Option im member Kontext (siehe createOption)

(v3.2) createItemOption($name, $desc, $type, $defValue = '', $typeExtras = '')

Erzeugt eine Option im item Kontext (siehe createOption)

setOption($name, $value)

Ändern von bereits existierenden Optionen

(v2.2) setBlogOption($blogid, $name, $value)

Ändert einen Wert für eine blog Option. Das Attribut blogid kennzeichnet für welchen Blog die Option gültig ist. (Andere Optionen siehe setOption)

(v2.2) setCategoryOption($catid, $name, $value)

Ändert einen Wert für eine category Option. Das Attribut catid kennzeichnet für welchen Blog die Option gültig ist. (Andere Optionen siehe setOption)

(v2.2) setMemberOption($memberid, $name, $value)

Ändert einen Wert für eine member Option. Das Attribut memberid kennzeichnet für welchen Blog die Option gültig ist. (Andere Optionen siehe setOption)

(v3.2) setItemOption($itemid, $name, $value)

Ändert einen Wert für eine item Option. Das Attribut itemid kennzeichnet für welchen Blog die Option gültig ist. (Andere Optionen siehe setOption)

getOption($name)

Liefert den Wert für eine Option aus der Datenbank

(v2.2) getBlogOption($blogid, $name)

Liefert den Wert für eine blog Option. blogid kennzeichnet den Blog, für den der Wert abgefragt wurde (andere Parameter: siehe getOption)

(v2.2) getCategoryOption($catid, $name)

Liefert den Wert für eine category Option. catid kennzeichnet den Blog, für den der Wert abgefragt wurde (andere Parameter: siehe getOption)

(v2.2) getMemberOption($memberid, $name)

Liefert den Wert für eine member Option. memberid kennzeichnet den Blog, für den der Wert abgefragt wurde (andere Parameter: siehe getOption)

(v3.2) getItemOption($itemid, $name)

Liefert den Wert für eine item Option. itemid kennzeichnet den Blog, für den der Wert abgefragt wurde (andere Parameter: siehe getOption)

deleteOption($name)

Eine Option löschen

(v2.2) deleteBlogOption($name)

Löscht eine blog Option (siehe deleteOption)

(v2.2) deleteCategoryOption($name)

Löscht eine category Option (siehe deleteOption)

(v2.2) deleteMemberOption($name)

Löscht eine member Option (siehe deleteOption)

(v3.2) deleteItemOption($name)

Löscht eine item Option (siehe deleteOption)

(v2.2) getAllBlogOptions($name)

Liefert alle Werte für eine bestimmte blog Option. Das Ergebnis ist ein assoziatives Array mit einem Eintrag für jede exitierende blogid.

(v2.2) getAllCategoryOptions($name)

Liefert alle Werte für eine bestimmte category Option. Das Ergebnis ist ein assoziatives Array mit einem Eintrag für jede exitierende catid.

(v2.2) getAllMemberOptions($name)

Liefert alle Werte für eine bestimmte member Option. Das Ergebnis ist ein assoziatives Array mit einem Eintrag für jede exitierende memberid.

(v3.2) getAllItemOptions($name)

Liefert alle Werte für eine bestimmte item Option. Das Ergebnis ist ein assoziatives Array mit einem Eintrag für jede exitierende itemid.

(v3.2) getBlogOptionTop($name, $amount = 10, $sort = 'desc')

Liefert den ersten Wert für eine bestimmte Option. Das Ergebnis ist ein Array. Jedes Element des Arrays ist wiederum ein Array mit einem Wert ('value') für jede memberid ('id').

(v3.2) getMemberOptionTop($name, $amount = 10, $sort = 'desc')

Liefert den ersten Wert für eine bestimmte Option. Das Ergebnis ist ein Array. Jedes Element des Arrays ist wiederum ein Array mit einem Wert ('value') für jede Mitglieder-Id ('id'). Für Parameter, siehe getBlogOptionTop)

(v3.2) getCategoryOptionTop($name, $amount = 10, $sort = 'desc')

Liefert den ersten Wert für eine bestimmte Option. Das Ergebnis ist ein Array. Jedes Element des Arrays ist wiederum ein Array mit einem Wert ('value') für jede Kategorie-Id ('id'). Für Parameter, siehe getBlogOptionTop)

(v3.2) getItemOptionTop($name, $amount = 10, $sort = 'desc')

Liefert den ersten Wert für eine bestimmte Option. Das Ergebnis ist ein Array. Jedes Element des Arrays ist wiederum ein Array mit einem Wert ('value') für jede Item-Id ('id'). Für Parameter, siehe getBlogOptionTop)

Datenbanktabellen

Zugriff auf Tabellen von Nucleus

Bis Version 2.0 war der Zugriff auf Tabellen von Nucleus einfach eine SQL Anfrage auf eine der nucleus_ Tabellen. Seit es möglich ist, auf einen selbstdefinierten Tabellennamen in Nucleus Version >2.0 zuzugreifen, sind einige Vorkehrungen bei der Entwicklung von Plugins zu treffen:

1. Benutze die globale Funktion sql_table('item'), statt auf einen festen Tabellennamens wie nucleus_item zuzugreifen.
2. Stelle sicher, dass dein Plugin 1 (true) zurückliefert, wenn supportsFeature('SqlTablePrefix') aufgerufen wird. Ansonsten wird das Plugin nicht von Nucleus Versionen >2.0 geladen werden, falls ein benutzerdefiniertes Präfix gesetzt wurde (als Vorkehrung).

Beachte, dass die globale Funktion sql_table nicht in Nucleus Versionen bis 2.0 verfügbar ist. Wenn du diese Methode benutzt und möchtest, dass dein Plugin mit Nucleus Versionen <= 2.0 funktioniert, füge den folgenden Quelltext am Anfang deiner Pluginklasse ein:

<?php

// Plugin sollte mit Nucleus Version <=2.0 funktionieren
if (!function_exists('sql_table'))
{
	function sql_table($name) {
		return 'nucleus_' . $name;
	}
}

class NP_HalloWelt extends NucleusPlugin {
...
}

?>

Deine eigenen Tabellen

Falls dein Plugin eigene Datenbanktabellen benötigt, solltest du sie in der Funktion install erzeugen und in unInstall wieder entfernen.

Einige Hinweise

• Benutze bitte Namen wie z.B. nucleus_plug_plugin-name um Konflikte mit anderen Plugins zu vermeiden. Erzeuge die Namen mit sql_table('plug_plugname') um sicherzustellen, dass sie mit den eingestellten, benutzerdefinierten Präfixen arbeiten.
• Du brauchst die Verbindung zur Datenbank nicht selbst erzeugen. Du kannst Abfragen mit dem PHP Kommando mysql_query() machen.
• Wenn du eine Datenverbindung selbst öffnest, stelle sicher, dass du die Nucleus verbindung anschließend wiederherstellst. Du kannst dies mit sql_connect() am Ende deiner Funktion tun. Es könnte vorteilhaft sein, dies im Konstruktor bereits zu tun um ständiges neuverbinden zu vermeiden. Du solltest dann die Link-Id in $this->db speichern und das jeder Anfrage als Parameter mitgeben.
• Überschreibe die Funktion getTableList() um sicher zu stellen, dass deine Tabelle gesichert wird, wenn die Backupfunktion von Nucleus benutzt wird.

Den Adminbereich zur Verfügung stellen

Ab Nucleus Version 2.5 können Plugins eigene Administrationsbereich erzeugen, die mit dem Administrationsbereich von Nucleus interagieren. Auf diese Seiten kann entweder über die Pluginadministration oder das Schnellmenu links zugegriffen werden.

Grundlagen

Um einen Administrationsbereich zur Verfügung zu stellen sind folgende Schritte notwendig:

1. Erzeuge ein Unterverzeichnis im Pluginverzeichnis und benenne es pluginname, falls dein Plugin NP_Pluginname heißt. Beachte das der Name kleingeschrieben wird!
2. Erzeuge eine Date index.php in diesem Verzeichnis mit folgendem Inhalt:

   <?php
   
   	// Wenn sich dein Pluginverzeichnis nicht an der Standardstelle befindet,
   	// bearbeite diese Variable um auf das Verzeichnis zu verweisen, welches
   	// config.php enthält
   	$strRel = '../../../';
   
   	include($strRel . 'config.php');
   	if (!$member->isLoggedIn())
   		doError('Nicht eingeloggt.');
   
   	include($DIR_LIBS . 'PLUGINADMIN.php');
   
   	// Erzeuge die Administrationsseite
   	$oPluginAdmin = new PluginAdmin('Pluginname');
   	$oPluginAdmin->start();
   
   	echo '<h2>Pluginname</h2>';
   
   	echo '<p>Hier stehen die Einstellungen<p>';
   
   	$oPluginAdmin->end();
   
   ?>

3. Registrier dich auf das Ereignis QuickMenu und füge folgenden Code in dein Plugin ein:

   function event_QuickMenu(&$data) {
   		array_push(
   			$data['options'],
   			array(
   				'title' => 'Pluginname',
   				'url' => $this->getAdminURL(),
   				'tooltip' => 'Tooltiptext'
   			)
   		);
   	}

4. Implementiere folgendes:

   function hasAdminArea()
   {
   	return 1;
   }

Abwägung

• Füge nicht einfach einen Eintrag in das Schnellmenu, nur weil es möglich ist. Stell dir dazu vor, 100 Plugins machen alle daselbe, was in einer ziemlichen Unordnung enden würde. Selbst wenn du einen Eintrag dem Menu hinzufügst, biete eine Möglichkeit an, diesen aus- oder einzublenden (entweder für alle Mitglieder oder sogar Mitgliederspezifisch).
• Die Variable $strRel in index.php muss aktualisiert werden wenn sich dein Plugin nicht im Verzeichnis nucleus/plugins/ befindet.
• Dein Adminbereich muss korrektes XHTML erzeugen. Ansonsten wird die Seite falsch in Gecko-basierten Browsern (Mozilla etc) angezeigt.

Die Klasse PluginAdmin

Der Sinn von PluginAdmin ist es, dir zu helfen. Einmal erstellt, kannst du $oPluginAdmin->plugin aufrufen um Objektinstanzen deines Plugins zu erhalten.

Hilfeseiten bereitstellen

Ab Nucleus Version 3.2 können Plugins Hilfeseiten mit einer Übersicht über das Plugin, die verfügbaren Skinvars and Templatevars, wo weitere Informationen zu finden sind etc. zur Verfügung stellen.

Die Hilfeseite ist über die Pluginübersicht des Administrationsbereichs zugänglich.

Grundlagen

Um eine Hilfeseite zur Verfügung zu stellen sind folgende Schritte notwendig:

1. Erzeuge ein Unterverzeichnis im Pluginverzeichnis und benenne es pluginname, falls dein Plugin NP_Pluginname heißt. Beachte das der Name kleingeschrieben wird! Das ist praktisch daselbe Verzeichnis, wie für den Administrationsbereich.
2. Erzeuge eine Datei help.html in diesem Verzeichnis. Hier kannst du dein Plugin dokumentieren. Du kannst folgendes als eine gute Basis benutzen:

   <h3>Plugin Übersicht</h3>
   
   <p>Die einzige Aufgabe dieses Plugins ist zu zeigen, wie die Pluginhilfeseiten funktionieren.</p>
   
   <h3>Installation</h3>
   
   <p>Wenn du das hier lesen kannst, hast du das Plugin schon installiert :-)</p>
   
   <h3>SkinVars</h3>
   
   <p>Da dieses Plugin nur ein Test ist, enthält es keine Skinvars oder Templatevars. Wenn es welche hätte, dann würde folgendes gelten:
   
   <ul><li><b><%HelpPageTestCase1%></b>: tut irgendwas</li>
   <li><b><%HelpPageTestCase1(foobar)%></b>: tut was ganz anderes</li></ul></p>
   
   <h3>Hilfe und Bugreports</h3>
   
   <p>Für weitere Hilfe und/oder Bugreports, benutze bitte folgendes Forum:
   <a href="http://forum.nucleuscms.org/viewtopic.php?t=<TOPIC_ID_GOES_HERE>">
   http://forum.nucleuscms.org/viewtopic.php?t=<TOPIC_ID_GOES_HERE></a></p>
   
   <h3>Versionen</h3>
   
   <ul><li>Version 0.1: erster Versuch</li>
   <li>Version 0.0: noch ersterer Versuch ;-)</li></ul>

3. Liefere einen Wert größer als 0 für die Funktion supportsFeature('HelpPage'):

   function supportsFeature($what) {
   	switch($what) {
   	case 'HelpPage':
   		return 1;
   	  default:
   		return 0;
   	}
     }

Plugin Abhängigkeitscheck

Seit Version 3.2 können Plugins Abhängigkeiten zu anderen Plugins deklarieren. Das ist besonders hilfreich für Plugins um kaputte Abhängigkeiten zu erkennen, die sonst die korrekte Ausführung verhindern würden.

Eine Abhängigkeit deklarieren

Nimm folgendes (reales) Beispiel:

NP_PageLinkList hängt von NP_BlogWithOffset ab, also wollen wir sicher stellen, dass ein Benutzer NP_BlogWithOffset vor NP_PageLinkList installieren muss. Mit dieser Schnittstelle ermöglicht es Nucleus dem Programmierer des Plugins, diese Abhängigkeit vor der Installation zu kontrollieren.

NP_PageLinkList muss so verändert werden, dass es NP_BlogWithOffset als seine Abhängikkeit deklariert. Wenn ein Plugin installiert wird, ruft der Kern von Nucleus eine Funktion getPluginDep() auf. Diese Funktion liefert eine Liste von Plugins, die es benötigt. Diese Liste wird anschließend mit allen bereits installierten Plugins überprüft. Nucleus wird die Installation verweigern, wenn ein Plugin auf der Liste noch nicht installiert ist.

Alles was man tun muss ist, die Funktion in NP_PageLinkList bereitzustellen:

function getPluginDep() {
	 return array('NP_BlogWithOffset');
}

Nucleus verhindert ausserdem, dass Plugins deinstalliert werden, von denen noch installierte Plugins abhängen.