Menü aufrufen
Toggle preferences menu
Persönliches Menü aufrufen
Nicht angemeldet
Ihre IP-Adresse wird öffentlich sichtbar sein, wenn Sie Änderungen vornehmen.

Benutzer:Rene/SGPack: Unterschied zwischen den Versionen

aus Stargate Wiki, dem deutschsprachigen Stargate-Lexikon
Die Seite wurde neu angelegt: „==Beschreibung== SGPack ist eine Sammlung von Mediawiki Erweiterungen die speziell für Stargate-Wiki programmiert wurden. Die Sammlung enthält die folgenden Erw…“
 
 
(124 dazwischenliegende Versionen von 7 Benutzern werden nicht angezeigt)
Zeile 1: Zeile 1:
==Beschreibung==
<user>*</user>
SGPack ist eine Sammlung von Mediawiki Erweiterungen die speziell für Stargate-Wiki programmiert wurden. Die Sammlung enthält die folgenden Erweiterungen:
'''SGPack''' ist eine Sammlung von Mediawiki-Erweiterungen die speziell für Stargate-Wiki programmiert wurden. Es ist zudem möglich die Erweiterungen einzeln zu benutzen. Die Vorgehensweise wird im Abschnitt ''Installation'' erklärt. '''Die Erweiterung benötigt MediaWiki in der Version 1.17 oder später.''' Die Erweiterung SGHtml benötigt die Version 1.24.
* BlockSpammer
{{TOC-right}}
:Die Erweiterung prüft die Änderungen von Anonymen Benutzern. Wird versucht eine Internetadresse einzugeben so wird die Übernahme der Änderungen abgelehnt.
<div style="margin-bottom:10px; margin-right: 270px; padding:0.5em; border:1px solid #CDCDC1; background:#C6E2FF;">
* NewArticle
<div style="float: right;">[[Datei:Nuvola_apps_kservices.png|80px|verweis=]]</div><h2>Installation</h2>
:Um das Anlegen von neuen Artikeln zu erleichtern ermöglicht es diese Erweiterung Artikelvorlagen direkt in den neuen Artikel einzubinden.
<div style="text-align:justify;">
==Copyright==
Die Erweiterung muss in ein eigenes Verzeichnis z.B. SGPack im Verzeichnis ''extensions'' entpackt werden. Dann muss die Datei Localsettings.php um die Zeile
Die Erweiterung unterliegt der GPL (Version 2). Das bedeutet der Einsatz in anderen MediaWikis ist erlaubt solange der Hinweis auf den Author und die GPL erhalten bleibt. Dazu genügt, in diesem Falle, bereits der von der Erweiterung selbst erzeugte Link auf der System Seite [[Spezial:Version]]. Natürlich kann die Erweiterung auch in anderen System benutzt werden, unter Beachtung der GPL.  


Über einen kleinen Hinweis (auf der Diskussionsseite) in welchem Wiki die Erweiterung eingesetzt wird würde ich mich freuen, ist aber keine Pflicht.
<code>require_once("$IP/extensions/SGPack/SGPack.php");</code>


==BlockSpammer==
ergänzt werden. Standardmäßig sind nach der Installation alle Erweiterungen, außer SGHTML und AddWhosOnline, aktiviert. Um einzelne Erweiterungen auszuschließen muss '''nach''' der <code>require_once</code> Anweisung der entsprechende Parameter auf <code>false</code> gesetzt werden.<br />Die neue Version unterstützt nun vollständig das MediaWiki Messagesystem. Alle Texte sind in der Datei SGPack.i18n.php definiert, momentan in Deutsch und Englisch und daher auch in den [[Spezial:MediaWiki-Systemnachrichten|MediaWiki-Systemnachrichten]] zu finden. ''Die Bezeichnung der einzelnen Texte bitte der Datei SGPack.i18n.php entnehmen.''
===Beschreibung===
BlockSpammer ist eine Mediawiki Erweiterung die verhindert das unangemeldete Benutzer (IPs) externe Links in Artikel eintragen. Die Erweiterung prüft Änderungen von nicht angemeldeten Benutzern. Wenn diese einen verdächtigen Eintrag machen wird die Übername der Änderungen verweigert. Momentan prüft die Erweiterung nur auf externe Links.  


==NewArticle==
===Parameter===
===Beschreibung===
{| class="wikitable mw-collapsible mw-collapsed" style="width: 100%;"
Die Erweiterung '''NewArticle''' erzeugt, immer wenn ein neuer Artikel angelegt wird, eine Auswahl an Vorlagen. Wird eine dieser Vorlagen ausgewählt so wird die Vorlage in das Editorfeld eingefügt. Sinn ist es das Erstellen von Artikeln nach den [[Hilfe:Artikelvorlagen|Artikelvorlagen]] zu erleichtern.
! Parameter !! Default !! Bedeutung
|-
| $wgSgpBlockSpammer || true || Aktivieren bzw. deaktivieren der Erweiterung BlockSpammer
|-
| $wgBlockSpammerStayEdit || false || Gibt an ob nach einer Spam Erkennung der Editor wieder erscheint oder dieser geschlossen wird und damit die Eingabe gelöscht wird.
|-
| $wgSgpPageProtection || true || Aktivieren bzw. deaktivieren der Erweiterung [[#PageProtection|PageProtection]]
|-
| $wgPageProtectBlockNamespaces || array(NS_USER) || Geschütze Namensräume. In diesen darf nur der Besitzer selbst schreiben.
|-
| $wgPageProtectOpenNamespaces || array(NS_USER_TALK) || Freie Namensräume. In diesen ist das Schreiben für alle erlaubt.
|-
| $wgPageProtectOwnerAlways || true || Wenn true, kann der Besitzer in den Namensräumen USER und USER_TALK nicht ausgesperrt werden.
|-
| $wgSgpDDInsert || true || Aktivieren bzw. deaktivieren der Erweiterung [[#DropDownInsert|DDInsert]]
|-
| $wgSgpUseIE9Hack || true || Aktivieren bzw. deaktivieren die Erweiterungen [[#IE9 Hack|IE9 Hack]]
|-
| $wgSgpNewArticle || true || Aktivieren bzw. deaktivieren der Erweiterung [[#NewArticle|NewArticle]]
|-
| $wgSgpParserAdds || true || Aktivieren bzw. deaktivieren der Erweiterung [[#Kleine Parser Erweiterungen|ParserAdds]]
|-
| $wgSgpCacheArray || true || Aktivieren bzw. deaktivieren der Erweiterung [[#CacheArray|CacheArray]]
|-
| $wgSgpSGHTML || false || Aktivieren bzw. deaktivieren der Erweiterung [[#SGHtml|SGHTML]]
|-
| $wgSGHTMLImageTop || || Pfad und Name des Bildes für den Sprung nach oben Button z.B. <code>$wgScriptPath.'/skins/common/images/16x16/blue_up.gif'</code>
|-
| $wgSGHTMLImageEdit || || Pfad und Name des Bildes für den Bearbeiten-Button z.B. <code>$wgScriptPath.'/skins/common/images/16x16/edit.png'</code>
|-
| $wgSgpAddWhosOnline || false || Aktivieren bzw. deaktivieren der Erweiterung [[#AddWhosOnline|AddWhosOnline]]
|-
| $wgSgpVideoPlayer || true || Aktivieren bzw. deaktivieren der Erweiterung [[#VideoPlayer|VideoPlayer]]
|-
| $wgSgpVideoPlayerCacheOff || false || Angabe ob der MW-Cache für Video Seiten deaktiviert werden soll
|-
| $wgSgpVideoPlayerEngine || "jwplayer" || Erlaubt die Auswahl des Videoplayers
|}
</div>
</div>


'''''Hinweis:''' Die Erweiterung wurde mit den MediaWiki Versionen 1.10.0+ getestet.''
<div style="margin-bottom:10px; margin-right: 270px; padding:0.5em; border:1px solid #CDCDC1; background:#B9FFC5;">
===Technik===
<div style="float: right;">[[Datei:Green_copyright_shiny.svg|80px|verweis=]]</div><h2>Copyright</h2>
NewArticle ist eine MediaWiki Erweiterung die sich an den Hook AlternateEdit anhängt. Dabei wird bei jedem Aufruf des Editors geprüft ob es sich um einen neuen Artikel handelt. Ist dies der Fall wird die Steuerdatei [[MediaWiki:NewArticle]] ausgelesen und entsprechend der Einleitungstext erzeugt. Das Einfügen des Vorlage erfolgt dann online über eine Javascript. Dazu werden die Vorlagen bei der Erstellung der Seite eingelesen und in eine Javascript Funktion verpackt.
<div style="text-align:justify;">
Die Erweiterung unterliegt der GPL (Version 2). Das bedeutet der Einsatz in anderen MediaWikis ist erlaubt, solange der Hinweis auf den Autor und die GPL erhalten bleibt. Dazu genügt, in diesem Falle, bereits der von der Erweiterung selbst erzeugte Link auf der System-Seite [[Spezial:Version]]. Natürlich kann die Erweiterung auch in anderen Systemen benutzt werden, unter Beachtung der GPL.


Ab der Version 0.9 prüft die Erweiterung auf die Anweisungen <nowiki><noinclude></nowiki> und <nowiki><includeonly></nowiki>. Diese werden erkannt und entsprechend ausgewertet.
Über einen kleinen Hinweis (auf der [[Benutzer Diskussion:Rene/SGPack|Diskussionsseite]]) in welchem Wiki die Erweiterung eingesetzt wird würde ich mich freuen, ist aber keine Pflicht.
</div>
</div>
<div style="margin-bottom:10px; margin-right: 270px; padding:0.5em; border:1px solid #CDCDC1; background:#FEFFE0;">
<div style="float: right;">[[Datei:Ark-icon.svg|80px|verweis=]]</div><h2>Download - Aktuell: V 1.5.01</h2>
<div style="text-align:justify;">
[[Datei:Bullet go.png]]'''[http://www.stargate-wiki.de/download/SGPack.zip SGPack.zip]'''<br />
''Achtung! BlockSpammer enthält einen Fehler. Dieser kann wie folgt behoben werden: [[Benutzer_Diskussion:Rene/SGPack#Fehler_in_BlockSpammer_-_HotFix|Fehler in BlockSpammer]]''
----
;Version 1.2.97
[[Datei:Bullet go.png]]'''[http://www.stargate-wiki.de/download/SGPack.txt SGPack.php]'''<br />
[[Datei:Bullet go.png]]'''[http://www.stargate-wiki.de/download/SGPack.i18n.txt SGPack.i18n.php]'''<br />
''Hinweis: Die Dateien werden jeweils mit der Endung .txt angezeigt bzw. heruntergeladen. Um sie zu benutzen müssen sie mit der Endung .php gespeichert werden''
</div>
</div>


'''''Hinweis''' Es wird geprüft ob es sich um einen neuen Artikel handelt, d.h. ein bereits gespeicherte Artikel ohne Inhalt wird nicht als neu angesehen.''
== Veränderungen seit Version 1.2.94 ==
{{Klappbox
|TITEL =Versionsgeschichte
|INHALT =
* '''1.2.95:''' Sonderzeichenfehler in DropDownInsert behoben - Funktion PHP utf8_decode wird benutzt.
* '''1.2.96:''' Funktionsaufruf wfLoadExtensionMessage entfernt - Wird seit 1.16 nicht mehr benötigt, seit 1.21 nicht mehr unterstützt.
:Fehler in NewArticle - Artikelinhalt mit fetchContent() auslesen statt aus Artikel-Objekt.
:Anpassung der HTML-Erweiterung an die neue Vector-Seiten
:Funktion addKeywords wird in MW 1.22 durch addMeta ersetzt
:userinfo: Fehler abfangen wenn HTTP_USER_AGENT nicht gesetzt.
:<nowiki>#rekursiv</nowiki>: Nicht ersetzte Ausdrücke werden jetzt immer in Klammern zurückgegeben. Zusätzliche Parameter werden richtig weitergegeben.
* '''1.5.00:''' Aufteilung des Pack in einige zusätzliche Dateien (Anpassung an MW Vorgaben):
:SGPack.php: Die Einstellungen und Einbindung in MW
:SGPack_body.php: Die eigentlichen Funktionen (Klassen).
:SGPack.js, SGPack.css: Javascript und CSS Funktionen und Definitionen.
:Die Javascript Funktionen sind nun so weit möglich ausgelagert und werden im HTML Dokument nur noch aufgerufen und nicht mehr definiert.
:Anpassung einiger Anweisungen an MW Standards. Unter anderem: Benutzung der Klasse WikiPage,
:Default Bilder für SGHTML liegen jetzt im SGPack Verzeichnis, es können aber über die entsprechenden Variablen auch andere Bilder verwendet werden.
:SGHTML: Die Vorgabe für die Metakeywords ist jetzt leer. Vermeidet falsche Keywords bei nichts Stargate Wikis.
:Neue Erweiterung: VideoPlayer
* '''1.5.01:''' <code><nowiki>#recursiv</nowiki></code>: Fehler das nicht geklammerte Einzelparameter nicht ersetzt werden behoben.
}}


===Einstellungen===
== BlockSpammer ==
Die Steuerung der Erweiterung erfolgt über Befehle auf der Seite [[MediaWiki:NewArticle]]. Der Aufbau der Seite ist:
BlockSpammer ist eine Erweiterung, die verhindert, dass unangemeldete Benutzer (IPs) unerwünschte Ausdrücke in den Artikeltext oder die Zusammenfassung eintragen.


<pre>
Die Erweiterung prüft nur Änderungen von nicht angemeldeten Benutzern. Wenn diese einen verbotenen Eintrag machen, wird die Übername der Änderungen verweigert. Die Ausdrücke werden anhand von Regex Anweisungen ermittelt. Die Definition der Anweisungen erfolgt in der Systemnachricht <code>blockspammer-regex</code> (Komma getrennte Liste) [[Mediawiki:blockspammer-regex|Beispiel]].
Parameter1==Wert1
 
//
Wird ein Spammausdruck gefunden, so wird das Speichern des Artikels verhindert und der Benutzer auf den Fehler hingewiesen. Die Meldungen können über die Systemnachrichten <code>spamprotectiontitle, spamprotectiontext, spamprotectionmatch, blockspammer-stayedit</code> angepasst werden.
Parameter2==Wert2
 
</pre>
;LocalSettings-Parameter
* <code>$wgBlockSpammerStayEdit</code>
Ist dieser Parameter auf <code>true</code> (Vorgabe) gesetzt so bleibt der Editor aktiv, inklusive der bemängelten Eingaben. Ist der Wert des Parameters dagegen <code>false</code> so wird die Eingabe verworfen und der Editor geschlossen.
 
== NewArticle ==
Die Erweiterung '''NewArticle''' erzeugt, immer wenn ein neuer Artikel angelegt wird, eine Auswahl an Vorlagen. Wird eine dieser Vorlagen ausgewählt so wird die Vorlage in das Editorfeld eingefügt. Sinn ist es, das Erstellen von Artikeln nach den [[Hilfe:Artikelvorlagen|Artikelvorlagen]] zu erleichtern.
 
;Technik:
NewArticle ist eine MediaWiki-Erweiterung, die sich an den Hook ''AlternateEdit'' anhängt. Dabei wird bei jedem Aufruf des Editors geprüft, ob es sich um einen neuen Artikel handelt. Ist dies der Fall, so wird geprüft, ob es zum Namensraum, in dem der neue Artikel erstellt werden soll, eine Steuerdatei ''MediaWiki:NewArticle-<NS>'' gibt. <NS> steht dabei für die Nummer des Namensraums. In dieser Datei kann neben einem Einleitungstext auch eine Liste an möglichen Vorlagen definiert werden. Das Einfügen einer gewählten Vorlage erfolgt dann über eine JavaScript-Funktion.<br />
''Hinweis:'' Es wird geprüft ob es sich um einen neuen Artikel handelt, d.h. ein bereits gespeicherter Artikel ohne Inhalt wird nicht als neu angesehen.
 
;<nowiki>MediaWiki:NewArticle-<NS></nowiki>:
In der Steuerdatei kann ein Text definiert werden, der als Einleitung über dem neuen Artikel angezeigt wird. Der Platzhalter <NS> wird dabei durch die Nummer des Namensraumes ersetzt, für den die Steuerdatei gültig ist. Der Text kann die normale Mediawiki-Syntax benutzen. Das bedeutet, dass z.B. auch Vorlagen eingebunden werden können. Zur Erstellung der Auswahlliste der möglichen Vorlagen werden diese nach dem folgenden Schema definiert:
 
[[[ Einleitung , Vorlagenseite|Beschreibung , Vorlagenseite|Beschreibung , ...]]]
* Einleitung: Der hier angegebene Text erscheint in der Auswahlliste als Einleitung.
* Vorlagenseite: Der Seitenname der Vorlage ohne den Namensraum, also nicht ''Vorlage:Seite'' sondern nur ''Seite''.
* Beschreibung: Der Text der für diese Vorlage in der Liste angezeigt wird.


Die einzelnen Befehlszeilen werden jeweils durch eine Zeile getrennt die '''nur''' die Zeichenfolge '''//''' enthält.
Es gibt keine Begrenzung für die Anzahl an Vorlagen die definiert werden können.


Folgende Werte können für den Parameter benutzt werden:
Wird nur eine Vorlage angegeben, besteht die Möglichkeit statt einer Liste einen Button zu erzeugen. In diesem Falle darf nur keine Einleitung angegeben werden.
*Start - Der Wert nach dem Trennzeichen (==) wird vor der Liste der Vorlagen ausgegeben. Der Text wird direkt als HTML ausgegeben, MediWiki Code wird '''nicht''' ausgewertet.
*End - Wie beim Parameter Start, nur wird der Text als Abschluss nach der Liste der Vorlagen ausgegeben.
*Einleitung - Der Wert wird in der ersten Zeile der Auswahlbox angezeigt. Wird der Parameter nicht angegeben so erscheint dort ''Bitte wählen''.


Bei allen anderen Zeilen ist der Parameter der Text der in der Liste angezeigt wird und der Wert ist der Name des Artikels, ohne die Namensraumangabe. Das folgende Beispiel
[[[ Vorlagenseite|Beschreibung ]]]


<pre>
Innerhalb des Steuerdatei können beliebig viele Auswahllisten bzw. Buttons definiert werden.
Start==<div class="main"><div class="heading">Neuen Artikel anlegen</div>
Du bist dabei einen neuen Artikel in Stargate Wiki zu schreiben. Um dir die Arbeit zu erleichtern
und ein einheitliches Erscheinungsbild der Artikel zu erreichen gibt es in Stargate Wiki Vorlagen
für einzelne Artikelgruppen. Wähle daher bitte aus der Liste das Thema des neuen Artikels aus. Die
entsprechende Artikelvorlage wird dann in das Editorfeld eingefügt und kann sofort bearbeitet
werden.<br /><br />Natürlich kannst du auch einen Artikel ohne Vorlage anlegen. Dies ist z.B. bei
Diskussions-, Weiterleitungs- oder auch Begriffsklärungs-Seiten nötig.<br /><br />
&nbsp;&nbsp;&nbsp;&nbsp;Thema des Artikels
//
Person -> Vorlage:Personenbeschreibung==Personenbeschreibung
//
Objekt -> Vorlage:Objektbeschreibung==Objektbeschreibung
//
Episode -> Vorlage:Episodenbeschreibung==Episodenbeschreibung
//
Darsteller -> Vorlage:Darstellerbeschreibung==Darstellerbeschreibung
//
Planet -> Vorlage:Planetenbeschreibung==Planetenbeschreibung
//
End==<br /><br />Vielen Dank.</div>
</pre>


erzeugt über dem Editorfeld die folgende Ausgabe:
;Beispiel:
[[[Bitte wählen,Benutzerseite|Benutzer (Vorlage:Benutzerseite)]]]


[[Bild:NewArticle.png]]
== SGHtml ==
Die Erweiterung verändert den HTML Code der von MediaWiki erzeugt wird. Dabei werden die folgenden Anpassungen gemacht:
* Alle Überschriften der Ebene 2 (==) erhalten am rechten Rand einen [[Bild:SGPack_Pfeil_hoch.png]] als Link auf den Seitenanfang.
* Bild [[Bild:SGPack_Edit.png]] statt Text '''Bearbeiten''' um einen Abschnitt zu bearbeiten
* Zusätzliche Keywords in den Meta Abschnitt der HTML Seite einbauen. Die Wörter werden als Komma getrennte Liste in der [http://www.stargate-wiki.de/w/index.php?title=Spezial%3AMediaWiki-Systemnachrichten&prefix=sghtml-keywords&filter=all&lang=de&limit=250 MediaWiki Systemnachricht] <code>sghtml-keywords</code> gespeichert.


'''''Hinweis:''' Die CSS-Klassen main und heading sind in Stargate Wiki definiert. Bei einem Einsatz in einem anderen Wiki kann man hier natürlich andere Definitionen benutzen.''
;Technik
Die Erweiterung benutzt die MediaWiki-Hooks '''OutputPageBeforeHTML''' und '''BeforePageDisplay'''.


===Probleme & Ideen===
''Da diese Erweiterung speziell für Stargate Wiki geschrieben wurde ist sie in der Grundeinstellung deaktiviert.''
*Es finden noch kaum Prüfungen auf Fehler statt.
*Text als Wikitext interpretieren.


==SGHtml==
MediaWiki-Version: Die Erweiterung manipuliert das Aussehen der HTML Seite vor der Ausgabe. Das funktioniert nur unter MW 1.24. Daher ist die Erweiterung in früheren Version deaktiviert. Das gilt nicht für die Meta-Keyworte, diese werden immer gesetzt.
===Beschreibung===
Die Erweiterung verändert der HTML Code der von MediaWiki erzeugt wird. Dabei werden die folgenden Anpassungen gemacht:
*Externe Seiten werden in einem eigenen Fenster aufgerufen
*Alle Überschriften der Stufe 2 (==) erhalten am rechten Rand einen ~^ als Link auf den Seitenanfang.
*Bild [[Bild:Bearbeiten.png]] statt Text '''Bearbeiten''' um einen Abschnitt zu bearbeiten
*Werkzeug '''Spoiler aufdecken''' als Javascript-Button einbinden wenn auf der Seite ein Spoiler benutzt wird.
*Pfeile <&#126;, &#126;>,&#126;^ und &#126;V im Artikel durch Bilder (<~,~>,~^,~V) ersetzen.
:'''Hinweis:''' ''Die Erweiterung ersetzt die Pfeile auch im Bereich '''<nowiki><pre></nowiki>''' und '''<nowiki><nowiki></nowiki>'''. Die einzige Möglichkeit dies zu verhindern besteht darin statt dem Zeichen ~ im Text den Code &&#35;126; zu schreiben.''


==Installation==
In der Grundeinstellung nutzt die Erweiterung zwei PublicDomain Bilder aus diesem [http://www.icojam.com/blog/?p=259 Iconset].
Um die Erweiterung zu benutzen müssen die Bilder für die Pfeile in das Verzeichnis ''skins/common/images/16x16'' gespeichert werden. Am einfachsten ist es dazu die Bilder auf dieser Seite mit dem Browser zu speichern und sie dann auf den Server zu laden.
===Programmcode===
Die Erweiterung benutzt die MediaWiki Hooks '''OutputPageBeforeHTML''', '''PersonalUrls''' und '''BeforePageDisplay'''.


==Code==
;LocalSettings-Parameter
Download des Codes: [http://www.stargate-wiki.de/download/SGPack.txt SGPack.php]
* <code>$wgSGHTMLImageTop</code>, <code>$wgSGHTMLImageEdit</code>
<pre><nowiki>
Gibt den Pfad zu den angezeigten Bildern an. Diese sollten das Format 16x16 Pixel haben.
<?php
if(!defined('MEDIAWIKI')) { die('This filse is a MediaWIki extension, it is not a valid entry point'); }


// Information about the extension
== PageProtection ==
$credits = array(
Diese Erweiterung ermöglicht die Kontrolle darüber wer Seiten bearbeiten darf.
    'path' => __FILE__,
    'name' => 'SGPack',
    'version' => '0.5.0',
    'url' => 'http://www.stargate-wiki.de/wiki/Benutzer:Rene/SGPack',
    'author' => 'René Raule',
    'description' => 'Extensions-Pack for [http://www.stargate-wiki.de/ Stargate-Wiki]'.
    '<br/>* Cache-Array: Array Function for templates'.
    '<br/>* SGHTML: Modify HTML-Code (external page, edit button, spoiler)'.
    '<br/>* DDInsert: Insert text by Buttons, Text or DropDownList'.
    '<br/>* PageProtection: Protect User Pages'.
    '<br/>* NewArticle: Choose template for new article'.
    '<br/>* BlockSpammer: Simple spammblocker'.
    '<br/>* ParserAdds: Some small parser-functions (trim,userinfo,recursiv)'
);
$wgExtensionCredits['parserhook'][] = $credits;
$wgExtensionCredits['other'][] = $credits;


/* Register extension , install hook handler */
Gedacht ist die Erweiterung hauptsächlich für die Namensräume Benutzer (NS_USER) und Benutzer Diskussion (NS_USER_TALK). In der Grundeinstellung dürfen die Seiten im Benutzernamensraum nur vom Besitzer bearbeitet werden. Die Seiten im Namensraum Benutzer Diskussion sind dagegen frei, können aber vom Besitzer gesperrt werden. Um den Schutz einer Seite einzustellen muss die Anweisung <code><nowiki><user></nowiki></code> benutzt werden.
$wgExtensionFunctions[] = 'SGP_Setup';  // set Hooks for functions
$wgHooks['LanguageGetMagic'][] = 'SGP_Magic';  // define parser words


// Register parser-extension
* <code><nowiki><user>XYZ,ABC</user></nowiki></code> gibt die Seite nur für die Benutzer XYZ und ABC frei.
function SGP_Setup() {
* <code><nowiki><user>*</user></nowiki></code> gibt die Seite für alle angemeldeten Benutzer frei.
    global $wgParser,$wgHooks,$wgExtensionMessagesFiles;
* <code><nowiki><user>**</user></nowiki></code> gibt die Seite für alle angemeldeten und anonymen Benutzer frei.


    $SGP_CacheArray = new SGP_CacheArray();
Um Seiten im Namensraum Benutzer Diskussion zu schützen, muss zumindest eine <code><nowiki><user></nowiki></code>-Anweisung auf der Seite definiert werden. Um die Seite nur für sich selbst frei zu geben, schreibt man <code><nowiki><user>Mein_Benutzername</user></nowiki></code> auf die Seite. Den selben Effekt erreicht man auch mit dem kurzen <code><nowiki><user>-</user></nowiki></code>. Wo auf der Seite die <code><nowiki><user></nowiki></code>-Anweisung steht spielt keine Rolle. Es empfiehlt sich aber, diese gleich an den Anfang der Seite zu setzen.
    $SGP_ParserAdds = new SGP_ParserAdds();
    $SGP_PageProtection = new SGP_PageProtection();
    $SGP_DDInsert = new SGP_DDInsert();
    $SGP_SGHTML = new SGP_SGHTML();
    $SGP_NewArticle = new SGP_NewArticle();
    $SGP_BlockSpammer = new SGP_BlockSpammer();
    $wgParser->setFunctionHook( 'carray', array(&$SGP_CacheArray,'carray'), SFH_NO_HASH );
    $wgParser->setFunctionHook( 'keys', array(&$SGP_CacheArray,'keys'), SFH_NO_HASH );
    $wgParser->setFunctionHook( 'trim', array(&$SGP_ParserAdds,'trim') , SFH_NO_HASH );
    $wgParser->setFunctionHook( 'userinfo', array(&$SGP_ParserAdds,'userinfo') , SFH_NO_HASH );
    $wgParser->setFunctionHook( 'recursiv', array(&$SGP_ParserAdds,'recursiv') );
    $wgParser->setHook('ddselect',array(&$SGP_DDInsert,'ddISelect'));
    $wgParser->setHook('ddvalue',array(&$SGP_DDInsert,'ddIValue'));
    $wgParser->setHook('ddbutton',array(&$SGP_DDInsert,'ddIButton'));
    $wgParser->setHook('user',array($SGP_PageProtection, 'fnSGPPUser'));
    $wgHooks['userCan'][] = array($SGP_PageProtection, 'fnSGPageProtection'); // check the page permissions
    $wgHooks['OutputPageBeforeHTML'][] = array(&$SGP_SGHTML,'SGHtml');
    $wgHooks['BeforePageDisplay'][] = array(&$SGP_SGHTML,'fnSGHtmlBPD');
    $wgHooks['SkinTemplateContentActions'][] = array(&$SGP_SGHTML,'ContentActions');
    //$wgHooks['PersonalUrls'][] = array(&$SGP_SGHTML,'ShowSpoiler');
    $wgHooks['AlternateEdit'][] = array(&$SGP_NewArticle,'NewArticle');
    $wgHooks['ArticleSave'][] = array(&$SGP_BlockSpammer,'CheckBlockSpammer');
    // load messages
    $wgExtensionMessagesFiles['SGPack'] = dirname(__FILE__) . '/SGPack.i18n.php';
    wfLoadExtensionMessages( 'SGPack' );
}


// Define magic words
Der Besitzer einer Seite kann sich nicht selbst aussperren, das gleiche gilt für die Administratoren.
function SGP_Magic( &$magicWords, $langCode ) {
    $magicWords['carray'] = array( 0, 'carray' );
    $magicWords['keys']  = array( 0, 'keys' );
    $magicWords['trim']  = array( 0, 'trim' );
    $magicWords['userinfo']  = array( 0, 'userinfo' );
    $magicWords['recursiv'] = array( 0, 'recursiv' );
    return true;
}


/* Simple Spam Blocker */
In anderen als den definierten Namensräumen hat die <code><nowiki><user></nowiki></code> Anweisung keine Wirkung und wird einfach ignoriert.
class SGP_BlockSpammer {
    function __construct() {
        global $wgBlockSpammerPatterns;


        if(!is_array($wgBlockSpammerPatterns)) {
;LocalSettings-Parameter
            $wgBlockSpammerPatterns = array ('/http/i', // externe Links beginnen mit: http
* <code>$wgPageProtectBlockNamespaces</code>
                );
: Definiert die geschützten Namensräume für die die Erweiterung aktiviert werden soll. Auf Seiten in diesen Namensräumen kann nur der Besitzer schreibend zugreifen.
        }
* <code>$wgPageProtectOpenNamespaces</code>
    }
: Definiert die freien Namensräume für die die Erweiterung aktiviert werden soll. Dabei ist zu beachten das der Schutz gegen Aussperren nur für den Benutzernamensraum funktioniert.
* <code>$wgPageProtectOwnerAlways</code>
: Über diesen Parameter kann eingestellt werden ob ein Benutzer sich aus der eigenen Seite aussperren kann. Die Vorgabe ist <code>true</code>, der Benutzer kann sich nicht selbst aussperren.
* <code>$wgGroupPermissions[Gruppe]['pageprotection']</code>
:Zur Sicherheit sollte es immer eine Gruppe, in der Regel die Gruppe der Administratoren, geben die auch auf geschützte Seiten zugreifen kann. Dies wird über die Gruppenzugriffsrechte <code>$wgGroupPermissions[Gruppe]['pageprotection']</code> geregelt. Als Vorgabe ist die Gruppe der Administratoren berechtigt auf geschützt Seiten zu zugreifen <code>$wgGroupPermissions['sysop']['pageprotection'] = true;</code>


    function diff($old, $new) {
== DropDownInsert ==
        foreach($old as $oindex => $ovalue) {
Die Idee zu DropDownInsert basiert auf der bekannten [http://www.mediawiki.org/wiki/Extension:CharInsert CharInsert-Erweiterung]. DDInsert geht aber über die Möglichkeiten von CharInsert hinaus. Die Erweiterung stellt die folgenden Befehle bereit:
            $nkeys = array_keys($new, $ovalue);
* <code><nowiki><ddselect titel="TITEL" size="SIZE" name="NAME">... ddvalue ...</ddselect></nowiki></code>
            foreach($nkeys as $nindex) {
:Definiert eine Dropdown-Auswahl. Dabei bedeuten die Parameter
                $matrix[$oindex][$nindex] = isset($matrix[$oindex - 1][$nindex - 1]) ? $matrix[$oindex - 1][$nindex - 1] + 1 : 1;
:* <var>titel</var>: Name Auswahl. Dieser Wert wird angezeigt wenn noch keine Auswahl erfolgt ist. Vorgabe ist '[ bitte wählen ]'.
                if($matrix[$oindex][$nindex] > $maxlen) {
:* <var>size</var>: Angabe wie viele Zeilen angezeigt werden sollen. Vorgabe ist 1
                    $maxlen = $matrix[$oindex][$nindex];
:* <var>name</var>: Der Name der Auswahl. Vorgabe ist „Ausgabe“
                    $omax = $oindex + 1 - $maxlen;
:Die einzelnen Zeilen werden durch ddvalue definiert.
                    $nmax = $nindex + 1 - $maxlen;
* <code><nowiki><ddvalue show="SHOWTEXT" sample="SAMPLETEXT" picture="NAME">... WERT ...</ddvalue></nowiki></code>
                }
:Jede ddvalue Definition entspricht einer Zeile in der DropDown-Auswahl. Dabei bedeuten die Parameter:
            }
:* <var>show</var>: Dieser Text wird in der Auswahl angezeigt. Die Vorgabe ist WERT
        }
:* <var>sample</var>: Der SAMPLETEXT wird beim einfügen als markierter Hinweis angegeben.
        if($maxlen == 0) return array(array('d'=>$old, 'i'=>$new));
:* <var>picture</var>: Wird ein Bild angegeben so wird dieses in der Liste angezeigt (als Hintergrund Bild)
        return array_merge(
:* WERT: Gibt an, was bei der Auswahl in den aktuellen Text eingefügt werden soll. Mit dem Pluszeichen <code>+</code> kann man zudem angeben, wo der Cursor platziert werden soll.
            $this->diff(array_slice($old, 0, $omax), array_slice($new, 0, $nmax)),
* <code><nowiki><ddbutton show="SHOWTEXT" sample="SAMPLETEXT" picture="NAME">... WERT ...</ddbutton></nowiki></code>
            array_slice($new, $nmax, $maxlen),
:Entspricht ddvalue, allerdings werden die Button ohne Auswahlliste, als einzelne Elemente, benutzt.
            $this->diff(array_slice($old, $omax + $maxlen), array_slice($new, $nmax + $maxlen)));
    }


    function diffwalkI($value,$key,$collect) {
== JSButton ==
        if(isset($value['i'])) {
Mit JSButton kann man einen HTML-Button ([http://de.selfhtml.org/html/formulare/klickbuttons.htm#modern <button>]) erzeugen. Mit diesem Button kann man eine Javascript-Funktion aufrufen, welche in Stargate Wiki definiert sein muss.
            foreach($value['i'] as $str) {
<nowiki><jsbutton id="" name="" value="" class="" style="" click="" mover="" mout="">BText</jsbutton></nowiki>
                $collect .= $str;
* <var>id</var>: Id des Buttons
            }
* <var>name</var>: Name des Buttons
        }
* <var>value</var>: Value des Buttons
    }
* <var>class</var>: Klasse des Buttons
   
* <var>style</var>: Style Definition für den Button
    function diffdiff($old,$new) {
* <var>click</var>: Javascript-Funktion für onclick
        $result = $this->diff($old,$new);
* <var>mover</var>: Javascript-Funktion für onmouseover
        $insert = '';
* <var>mout</var>: Javascript-Funktion für onmouseout
        array_walk($result,array($this,'diffwalkI'),&$insert);
* <var>BText</var>: Beschriftung des Buttons
        return $insert;
:Hinweis: Momentan wird Wiki-Syntax in BText nur Teilweise unterstützt. Variablen werden erst mit der neuen Mediawiki Version 1.16 ausgewertet. Um Grafiken einzubinden sollten diese selbst keinen Verweis enthalten und müssen daher mit dem Parameter <var>verweis=</var> definiert werden. Beispiel: <code><nowiki>[[Datei:Bild.jpg|verweis=]]</nowiki></code>. Wird dies nicht so gemacht funktioniert der Button zwar, erzeugt aber keinen gültigen HTML-Code.
    }
   
    function CheckBlockSpammer (&$article,&$user,&$text ) {
        global $wgBlockSpammerPatterns;
        global $wgOut;


        if($user->mId == 0) {
Die Definition der Javascript-Funktion(en) muss entweder in der Datei '''[[Mediawiki:Common.js|Mediawiki:<Skin>.js]]''' oder '''[[Benutzer:{{userinfo:name}}/common.js|Benutzer:<Name>/<Skin>.js]]''' erfolgen.
            $t = $this->diffdiff(explode("\n",$article->mContent),explode("\n",$text));
            foreach ($wgBlockSpammerPatterns as $re) {
                if (preg_match($re, $t)===1) {
                    $wgOut->errorpage('block_spammer_error_page_title', 'block_spammer_error' );
                    return false;
                }
            }
        }
        return true;
    }
}


/* Template for new Article */
== CacheArray ==
class SGP_NewArticle {
Die Parser-Erweiterung CacheArray ermöglicht das Anlegen und Auslesen von Arrays. Das besondere dabei ist, dass diese Arrays nur einmal angelegt werden müssen und dann auch von anderen Seiten benutzt werden können. '''Hinweis:''' ''Natürlich bleibt das Array nicht erhalten, wenn die ursprünglich angefragte Seite an den Browser ausgegeben wurde. Es kann nur während des Seitenaufbaus von aufgerufenen Seiten bzw. Vorlagen benutzt werden.''
    // Umwandeln einer Zeichenkette fuer die JS Funktion unescape()
    function JSencode($text) {
        return rawurlencode(html_entity_decode(htmlentities($text,ENT_QUOTES,'UTF-8')));
    }


    /* Filter des Artikels, noinclude Bereiche entfernen */
{{Klappbox
    function FilterPage($text) {
|TITEL =Befehle
        // <noinclude> Bereiche komplett entfernen
|INHALT =
        $expr = '/(.*)<noinclude>(?s).*<\/noinclude>(.*)/';
* '''carray'''
        $replace = '$1$2';
:Der Befehl zum Setzen, Auslesen und Löschen der Arrays
        $text = preg_replace($expr,$replace,$text);
* '''keys'''
        // <includeonly>, </includeonly> einfach entfernen
:Mehrere Index-Keys zu einem einzigen verbinden
        $expr = '/(.*)<includeonly>|<\/includeonly>(.*)/';
        $replace = '$1$2';
        $text = preg_replace($expr,$replace,$text);
        return $text;
    }


    function NewArticle(&$seite) {
==== carray ====
        global $wgOut;
<nowiki>{{carray:<Name_des_Array>|<Kommando>[''Parameter''…''Array-Werte'']}}</nowiki>
* '''Name_des_Array'''
:Die Erweiterung ist in der Lage, beliebig viele Arrays zu verwalten. Zur Unterscheidung dient dabei der Array-Name.
* '''Kommando'''
Die Steuerung von carray erfolgt über die folgenden Kommandos.
* '''w''' oder '''write'''
:Das Kommando '''write''' füllt das Array mit den angegebenen Werten. Ist das Array bereits angelegt wird der Befehl ignoriert. Um ein Array erneut anzulegen muss es zuerst gelöscht werden, siehe Befehl '''delete'''.
:Die Definition der Array-Werte erfolgt analog zur <code><nowiki>{{#switch:}}</nowiki></code>-Definition. Ein Beispiel:
<pre><nowiki>{{carray:EpName|w
| #default = <span class="error">Episodencode {{K}} ist unbekannt</span>
| SGA_1x01/02 = Aufbruch in eine neue Welt
| SGA_1x01 = Aufbruch in eine neue Welt, Teil 1
| SGA_1x02 = Aufbruch in eine neue Welt, Teil 2
| SGA_1x03 = Dunkle Schatten
| SGA_1x04 = 38 Minuten
}}</nowiki>
</pre>
:Das Array-Element <var>#default</var> wird immer dann ausgegeben, wenn die Anfrage nach einem nicht definierten Wert gestellt wird, siehe Befehl '''read'''. Der Parameter <var><nowiki>{{K}}</nowiki></var> im default-Wert wird durch den Index ersetzt.
* '''r''' oder '''read'''
:Mit dem Kommando '''read''' erfolgt die Abfrage des Arrays. Das folgende Beispiel
<nowiki>{{carray:EpName|r|SGA_1x01}}</nowiki>
würde nach der oben angegebenen Definition den Wert
Aufbruch in eine neue Welt, Teil 1
zurück liefern. Ist kein Wert definiert wird entweder nichts oder, wenn definiert, der Inhalt der Zeile <var>#default</var> ausgegeben.
* '''rw''' oder '''readwrite'''
:Mit der Kombination der Kommandos '''read''' und '''write''' wird das Array zuerst gefüllt und dann die entsprechende Zelle ausgelesen. Der Aufruf muss daher lauten:
<pre><nowiki>{{carray:EpName|rw|SGA_1x01
| #default = <span class="error">Episodencode ungültig</span>
| SGA_1x01/02 = Aufbruch in eine neue Welt
| SGA_1x01 = Aufbruch in eine neue Welt, Teil 1
| SGA_1x02 = Aufbruch in eine neue Welt, Teil 2
| SGA_1x03 = Dunkle Schatten
| SGA_1x04 = 38 Minuten
}}</nowiki></pre>
* '''f''' oder '''file'''
:Das Kommando entspricht '''write''' und erzeugt ebenfalls ein Array. Der Unterschied ist, dass die Daten aus einer anderen Seite gelesen werden. Es wird vor dem Erzeugen geprüft, ob das Array schon vorhanden ist und nur wenn dies nicht der Fall ist wird die Datei geladen. ''Siehe auch [[#Hinweise zum Einsatz]].''
<nowiki>{{carray:EpName|f|Vorlage:EpName/Zuordnung}}</nowiki>
* '''fr''' oder '''fileread'''
: Das Kommando ist eine Kombination aus '''file''' und '''read'''
<nowiki>{{carray:EpName|fr|Vorlage:EpName/Zuordnung|SG1_1x10}}</nowiki>
* '''u''' oder '''used'''
:Um zu prüfen ob ein Array bereits angelegt ist, sollte das Kommando '''used''' benutzt werden. Ist das Array bereits vorhanden, liefert die Anfrage die Anzahl der definierten Array-Elemente, ansonsten wird nichts zurück geliefert.
<nowiki>{{carray:EpName|u}}</nowiki>
* '''c''' oder '''count'''
:Das Kommando gibt die Anzahl der definierten Array-Elemente zurück. Ist das Array noch nicht definiert ist das Ergebnis 0.
<nowiki>{{carray:EpName|c}}</nowiki>
* '''d''' oder '''delete'''
:Mit dem Kommando '''delete''' wird das Array gelöscht. Dies ist immer dann nötig, wenn das Array neu geschrieben werden soll, da das Überschreiben nicht möglich ist.
<nowiki>{{carray:EpName|d}}</nowiki>


        // Pruefen ob der Artikel neu ist
==== keys ====
        if( !$seite->mArticle->exists() ) {
<nowiki>{{keys:[<Mod>:]<Key>[|[<Mod>:]<Key>…]}}</nowiki>
            // Steuerseite einlesen "MediaWiki:NewArticle"
* '''Key'''
            $steuer = new Article(Title::makeTitle(8,'NewArticle'));
:Der Key ist entweder direkt ein Text oder eine Variable. Vor dem Key kann ein Modifierer (Mod) angegeben werden.
            $steuer->getContent();
* '''Mod'''
            // Pruefen ob Steuerseite vorhanden
:Mit dem Modifier kann der Key verändert werden. Definiert sind die Modifier '''l''' zum Umwandeln des Keys in Kleinbuchstaben und '''u''' zum Umwandeln in Großbuchstaben.
            if( $steuer->mContentLoaded ) {
Das Kommando wandelt die Keys entsprechend der Modifier um, entfernt Leerzeichen und fügt zwischen den einzelnen Keys einen Unterstrich '''_''' ein. Das Ergebnis wird dann zurückgeliefert.
                // Ausgabe Puffer Variablen anlegen
<nowiki>{{keys:u: sg1 | 1x01 }}</nowiki>
                $einleitung = ''; $abschluss = ''; $artikelListe = ''; $textErsteWahl = 'Bitte w&auml;hlen';
Ergibt: {{keys:u: sg1| 1x01 }}
                $listenKopf = '<script type="text/javascript">';
                $listenKopf .= 'function NewArticleGo(select) {';
                $listenKopf .= 'var wert=select.options[select.options.selectedIndex].value;';
                $listenKopf .= "insertTags('',unescape(wert),'');";
                $listenKopf .= "}</script>\n";
                $listenKopf .= '<select size="1" id="NewArticleSelect" onchange="NewArticleGo(this);">'."\n";
                // Die einzelnen Zeilen, getrennt durch eine Zeile mit //, in Array einlesen
                $steuerArray = explode("\n//\n", $steuer->mContent);
                foreach( $steuerArray as $index => $value ) {
                    // Die Zeile aufteilen an den Zeichen ==
                    $zeile = explode("==",$value);
                    if( $zeile[0] == 'Start' ) {
                        $einleitung = $zeile[1];
                    } elseif ( $zeile[0] == 'End' )  {
                        $abschluss = $zeile[1];
                    } elseif ( $zeile[0] == 'Einleitung' ) {
                        $textErsteWahl = $zeile[1]; 
                    } else {
                        // Artikel einlesen umwandeln und im HTML Code ablegen
                        $artikel = new Article(Title::makeTitle(10,$zeile[1]));
                        $artikel->getContent();
                        $artikelListe .= '<option value="'.$this->JSencode($this->FilterPage($artikel->mContent)).'">';
                        $artikelListe .= $zeile[0]."</option>\n";
                        unset($artikel);
                    }
                }
                $ersteWahl = '<option value="">'.$textErsteWahl.'</option>'."\n";
                // Ergebniss in die Ausgabe einfuegen
                $wgOut->addHTML($einleitung.$listenKopf.$ersteWahl.$artikelListe.'</select>'.$abschluss);
            }
        }
        return true;
    }
}


/* Modify HTML-Code */
'''Hinweis''' Damit nicht definierte Variablen als solche auch erkannt werden, müssen diese nach dem folgenden Muster eingesetzt werden: Nicht <code><nowiki>{{{1}}}</nowiki></code> sondern <code><nowiki>{{{1|}}}</nowiki></code>.
class SGP_SGHTML {
}}
    private $isSpoiler = false;


    // Letzte Änderungen direkt vor der Ausgabe
==== Hinweise zum Einsatz ====
    function fnSGHtmlBPD(&$out) {
Die Erweiterung kann, richtig eingesetzt, den Aufbau von Seiten beschleunigen, die häufig eine Vorlage aufrufen, welche aus einer großen Anzahl an Werten einen Wert liefert. Dazu sollte eine eigene Seite angelegt werden, die nur das Array füllt. Auf der eigentlichen Vorlagenseite sollte mit dem Befehl '''used''' geprüft werden, ob das Array bereits gesetzt wurde. Wenn nicht, kann die "Full"-Vorlage aufgerufen werden. Sonst sollte immer nur das Array ausgelesen werden.
        $keywords = array('Stargate','Stargate SG-1','Stargate Atlantis','Stargate Universe','Stargate Lexikon');


        if($this->isSpoiler) {
Durch diese Konstruktion erreicht man, dass die große, daher langsame, 'Füll'-Vorlage nur einmal abgearbeitet werden muss und alle weiteren Zugriffe auf das Cache-Array erfolgen.
            $out->addScript('<script type="text/javascript">/*<![CDATA[*/
                function switchSpoiler() {
                var Rows = [document.getElementsByTagName("div"),document.getElementsByTagName("span")];
                for(var c in Rows) { for(var i=0, j=Rows[c].length; element=Rows[c][i]; i++) {
                switch(element.className) { case "spoiler" : element.className = "spoilerOK"; break;
                case "spoilerOK" : element.className = "spoiler"; break; } } }
                var caSpoiler = document.getElementById("ca-Spoiler");
                if(catSpoiler.innerHTML.search(/Spoiler aufdecken/)!=-1) { caSpoiler.innerHTML = caSpoiler.innerHTML.replace(/aufdecken/,"verdecken");
                } else { caSpoiler.innerHTML = caSpoiler.innerHTML.replace(/verdecken/,"aufdecken"); } }
                /*]]>*/</script>');
        }
        // Weitere Meta Begriffe
        foreach($keywords as $word) {
            $out->addKeyword($word);
        }
        return true;
    }


    function ContentActions(&$content_actions) {
Die entsprechende Anweisung sollte wie folgt aussehen, definiert in [[Vorlage:EpName]]
        if($this->isSpoiler) {
            $ref = "javascript:switchSpoiler()";
            $text = 'Spoiler aufdecken';
            $class = 'bt-Spoiler';
            $active = false;
            $content_actions['Spoiler'] = array('class'=>$class,'text'=>$text,'href'=>$ref);
        }
        return true;
    }


    function ShowSpoiler(&$personal_urls,&$wgTitle) {
<nowiki>{{#if: {{carray:EpName|u}} || {{EpName/Zuordnung}} }}{{carray:EpName|r|{{{1}}}}}</nowiki>
        if($this->isSpoiler) {
            $ref = "javascript:switchSpoiler()";
            $text = 'Spoiler aufdecken';
            $class = 'bt-Spoiler';
            $active = false;
            $personal_urls['Spoiler'] = array( 'text' => $text,'href' => $ref,'class' => $class, 'active' => $active );
            $content_actions[] = array('class'=>false,'text'=>$text,'href'=>$ref);
        }
        return true;
    }


    function SGHtml( &$out, &$text ) {
Die Vorlage EpName/Zuordnung füllt das Array ''EpName'' mit Werten, die dann von der Vorlage EpName ausgelesen werden.
        global $wgScriptPath;


        $mTable = array(
'''Wichtiger Hinweis''':
            'class="external text"' => 'class="external text" target="_blank"', // Externe Seiten in eigenem Fenster
Die oben angegebene Vorgehensweise führt zu Problemen bei gesichteten Versionen. Wird diese Erweiterung benutzt, sollte alternativ der Befehl '''file''' bzw. '''fileread''' eingesetzt werden.
            'class="external autonumber"' => 'class="external autonumber" target="_blank"',
            '&lt;~' => '<img src="'.$wgScriptPath.'/skins/common/images/16x16/blue_left.gif" alt="<-" />',
            '~&gt;' => '<img src="'.$wgScriptPath.'/skins/common/images/16x16/blue_right.gif" alt="->" />',
            '~^' => '<img src="'.$wgScriptPath.'/skins/common/images/16x16/blue_up.gif" alt="^" />',
            '~V' => '<img src="'.$wgScriptPath.'/skins/common/images/16x16/blue_down.gif" alt="V" />',
            );


        foreach( $mTable as $from => $to ) {
== Kleine Parser-Erweiterungen ==
            $text = str_replace( $from, $to, $text );
{{Anker|#in}}{{Anker|in}}{{Klappbox|TITEL=#in|anfang}}
        }
Ermittelt ob Elemente in einer Menge enthalten sind. Je nach Suchmodus ist die Suche erfolgreich wenn alle oder mindestens ein Element gefunden wird. Sowohl das Trennzeichen der Elemente als auch die Rückgabe kann definiert werden.
<nowiki>{{ #in: ELEMENT | LISTE | TRENNER | MODUS | RÜCKGABE }}</nowiki>
* ELEMENT
: Eine Liste der zu suchenden Elemente. Getrennt werden die Elemente durch das TRENNER-Zeichen.
* LISTE
: Eine Aufzählung von Elementen, getrennt durch Komma oder durch den in TRENNER angegebene Ausdruck
* TRENNER
: Definiert das Trennzeichen für die Listen. Wird keine Zeichen angegeben so wird das Komma benutzt
* MODUS
: Auswahl wie gesucht werden soll. Ist der MODUS == '''e''' (oder '''s''') genügt es wenn ein Element gefunden wird. Wird kein Wert für MODUS angegeben oder '''a''' so müssen alle Elemente in der Liste vorkommen damit die Suche erfolgreich ist.
* RÜCKGABE
: Eine Liste, getrennt durch TRENNER, der möglichen Rückgabewerte. Der erste Wert wird im Erfolgsfall zurückgegeben der zweite Fall wenn die Suche erfolglos war. Es ist möglich auch nur einer der Werte anzugeben. Um nur einen Wert für den Misserfolg anzugeben muss dieser wie folgt definiert werden: ,WERT (wenn TRENNER == ',')
* Ausgabe
Ist die Suche erfolgreich, so werden alle gefundenen Werte als Liste ausgegeben. Bei einer erfolglosen Suche liefert die Funktion einen leeren String. Dieses Verhalten kann mit dem Parameter RÜCKGABE geändert werden.


        // Ueberschrift finden
;Beispiele
        $suchen = '#<h(\d)><span class="editsection">\[<a href="(.*?)"\s+title="(.*?)">Bearbeiten<\/a>\]<\/span>\s*<span class="mw-headline">(.*?)<\/span>#e';
<nowiki>{{ #in: b,c,d | a,b,c ||e}}</nowiki>
        // Neue Ueberschrift mit Bildern
Die Suche (Modus==e) nach b,c,d in der Liste a,b,c liefert: '''{{ #in: b,c,d | a,b,c ||e}}'''
        // Test ob H2 Ueberschrift, nur dann wird der Link an den Seitenanfang eingefuegt.
<nowiki>{{ #in: b,d | a,b,c ||e|ja,nein}}</nowiki>
        $ersatz = '"<h$1>".($1==2?"';
Die Suche (Modus==e) nach b,d in der Liste a,b,c liefert: '''{{ #in: b,d | a,b,c ||e|ja,nein}}'''
        $ersatz .= '<a href=\"#top\" title=\"Seiten Anfang\" style=\"vertical-align: top; float: right;\"><img src=\"'.$wgScriptPath.'/skins/common/images/16x16/blue_up.gif\" alt=\"^\" /></a>';
<nowiki>{{ #in: b,d | a,b,c |||ja,nein}}</nowiki>
        $ersatz .= '":"").';
Die Suche nach b,d in der Liste a,b,c liefert: '''{{ #in: b,d | a,b,c |||ja,nein}}'''
        $ersatz .= '"<span class=\"mw-headline\">$4</span> <a href=\"$2\" title=\"$3\">';
{{Klappbox|ende}}
        $ersatz .= '<img src=\"'.$wgScriptPath.'/skins/common/images/16x16/edit.png\" alt=\"[bearbeiten]\" style=\"vertical-align:top; margin-top:-3px;\" /></a>"';


        $text = stripslashes(preg_replace($suchen,$ersatz,$text));
{{Anker|trim}}{{Klappbox|TITEL=trim|anfang}}
        $this->isSpoiler = strpos($text,'class="show_spoiler"');
Entfernen von führenden oder nachfolgenden Leerzeichen.
        return true;
<nowiki>{{trim:PARAMETER}}}</nowiki>
    }
* PARAMETER
}
:Der Parameter kann ein Text oder sinnvoller eine Variable sein.
Als Rückgabe erhält man den angegebenen Wert ohne führende oder nachfolgende Leerzeichen. Der Einsatz der Funktion ist bei der Übergabe des Arraykeys sinnvoll, da es vorkommen kann, dass der Wert einer Variablen ein führendes Leerzeichen enthält.
{{Klappbox|ende}}


/* Page Protection */
{{Anker|userinfo}}{{Klappbox|TITEL=userinfo|anfang}}
class SGP_PageProtection {
Liefert einige Informationen zum aktuellen Benutzer.
    // buffer results from fnSGPageProtection to speed up program
<nowiki>{{userinfo:PARAMETER}}</nowiki>
    private $lastResult = array();
* PARAMETER - Auswahl der gewünschten Information. Folgende Werte sind erlaubt
**'''name''' - Benutzername oder bei nicht angemeldeten Benutzern die IP-Adresse.
**'''id''' - Benutzernummer. Die id 0 steht für einen nicht angemeldeten Benutzer.
**'''realname''' - Wirklicher Benutzername
**'''skin''' - Name des Skins
**'''email [{{!}}<benutzer>]''' - Email-Adresse des aktuellen oder angegebenen Benutzers
**'''home [{{!}}<benutzer>]''' - Verweis auf die Benutzerseite des aktuellen oder angegebenen Benutzers
**'''talk [{{!}}<benutzer>]''' - Verweis auf die Diskussionsseite des Benutzers des aktuellen oder angegebenen Benutzers
**'''groups''' - Liefert eine Komma getrennte Liste aller Gruppen des Benutzers
**'''group{{!}}<gname>''' - Prüft ob der Benutzer der Gruppe <gname> angehört. Ist der Benutzer in der Gruppe wird der Gruppenname <gname> zurück gegeben sonst ist die Rückgabe leer.
**'''online{{!}}<name>''' - Prüft ob der Benutzer momentan online ist. Als Resultat liefert der Aufruf: ''online'' bzw. ''offline''.<br>'''Hinweis''' Diese Funktion setzt die Erweiterung [http://www.mediawiki.org/wiki/Extension:WhosOnline WhosOnline] voraus. Ist die Erweiterung nicht installiert, liefert der Aufruf ''unknown''.
**'''browser [{{!}}<kennung>]''' - Ermittelt die Browserkennung des Benutzers. Wird der Parameter angegeben prüft der Befehl ob der Parameter-Text in der Kennung enthalten ist. Ist dies der Fall wird der Parameter zurückgegeben sonst nichts. Wird vom Aufrufer keine Browserinfo geliefert, wird "undefined" zurückgegeben.<br>'''Beispiel''' <code><nowiki>{{userinfo:browser|MSIE 9}}</nowiki></code> liefert ''MSIE 9'' wenn der Internet Explorer in der Version 9 benutzt wird.
{{Klappbox|ende}}


    function __construct() {
{{Anker|#link}}{{Anker|link}}{{Klappbox|TITEL=#link|anfang}}
        global $wgSGPPBlockNamespaces;
Mit der Anweisung #link können HTML-Link Anweisungen in den Seitenkopf eingebaut werden. Eine Übersicht der Möglichkeiten findet man auf [http://de.selfhtml.org/html/kopfdaten/beziehungen.htm selfhtml].
        global $wgSGPPOpenNamespaces;
<nowiki>{{#link:ART|SEITE[|TITEL]}}</nowiki>
        global $wgSGPPOwnerAlways;
* ART: Bezeichnung des Links
        global $wgGroupPermissions;
* SEITE: Name der Seite
       
* TITLE: Wenn angegeben der Titel, sonst wird SEITE benutzt
        // Default values for PageProtection
        if(!is_array($wgSGPPBlockNamespaces)) { $wgSGPPBlockNamespaces = array(NS_USER); }
        if(!is_array($wgSGPPOpenNamespaces)) { $wgSGPPOpenNamespaces = array(NS_USER_TALK); }
        if(!is_bool($wgSGPPOwnerAlways)) { $wgSGPPOwnerAlways = true; }
        if(!is_bool($wgGroupPermissions['sysop']['SGPPEditFree'])) { $wgGroupPermissions['sysop']['SGPPEditFree'] = true; }
    }
   
    /* Handel user-tags, just drop them */
    function fnSGPPUser($input,$argv,&$parser) {
        return '';
    }


    function fnSGPageProtection( $title, $user, $action, &$result ) {
Man kann diese Anweisung z.B. benutzen um Episoden zu verknüpfen. In den Artikel [[Die Invasion, Teil 3]] wird dazu eingebaut:
        global $wgSGPPBlockNamespaces;
<nowiki>{{#link:next|Die_Invasion,_Teil_4}}</nowiki>
        global $wgSGPPOpenNamespaces;
Durch diese Anweisung wird
        global $wgSGPPOwnerAlways;
<nowiki><link rel="next" href="http://www.stargate-wiki.de/wiki/Die_Invasion,_Teil_4" title="Die_Invasion,_Teil_4"/></nowiki>
        global $wgGroupPermissions;
in den Seitenkopf eingebaut. Entsprechend kann man die vorhergehende Episode mit "prev" angeben.


        // if this article was already testet just give the result
Es gibt einige Browser bzw. Browsererweiterungen ''z.B. für [https://addons.mozilla.org/en-US/firefox/addon/link-widgets/ Firefox]'' die diese Angaben auswerten. Außerdem können die Angaben von Maschinen, z.B. der Google-Suche, gelesen und ausgewertet werden.
        if(isset($this->lastResult[$title->getText()][$action])) { return $this->lastResult[$title->getText()][$action]; }
        // Name of actual user
        $username = $user->getName();
        /* Do nothing if ...
          ... usergroup is free */
        if( $user->isAllowed('SGPPEditFree') ) {
            $this->lastResult[$title->getText()][$action] = true;
            return true;
        }
        /* ... wrong namespace */
        if( !in_array($title->mNamespace,array_merge($wgSGPPBlockNamespaces,$wgSGPPOpenNamespaces)) ) {
            $this->lastResult[$title->getText()][$action] = true;
            return true;
        }
        /* ... action not edit or move */
        if( !($action == 'edit' || $action == 'move') ) {
            $this->lastResult[$title->getText()][$action] = true;
            return true;
        }
        /* ... user is owner of article and ownerflag is set (only in USER & USER_TALK namespaces) */
        if( ($title->mNamespace == NS_USER) || ($title->mNamespace == NS_USER_TALK) ) {
            /* get user name, title and get user part out of title */
            $fulltitle = $title->getText();
            list($usertitle,$subtitle) = explode('/',$fulltitle,2);
            if( $wgSGPPOwnerAlways && ($usertitle == $username) ) {
                $this->lastResult[$title->getText()][$action] = true;
                return true;
            }
        }
        /* simple checks are over now, look for user-tags in article content */
        /* get article (? can we find it already somewhere ?) */
        $article = new Article($title);
        $text = $article->fetchContent(0);
        /* drop <nowiki>xxx</nowiki> parts */
        $expr = '/(.*?)<\s*nowiki\s*>(?s).*?<\/\s*nowiki\s*>(.*?)/i';;
        $replace = '$1';
        $text = preg_replace($expr,$replace,$text);
        /* ip-user */
        if( $user->mId == 0 ) {
            /* look for <user>**</user> */
            if( preg_match("/<\s*user\s*>\s*\*\*\s*<\/\s*user\s*>/",$text) > 0 ) {
                $this->lastResult[$title->getText()][$action] = true;
                return true;
            }
        } else {  /* normal user */
            /* look for <user>$username</user> */
            if( preg_match("/<\s*user\s*>\s*$username\s*<\/\s*user\s*>/",$text) > 0 ) {
                $this->lastResult[$title->getText()][$action] = true;
                return true;
            }
            /* look for <user>*</user> */
            if( preg_match("/<\s*user\s*>\s*\*\s*<\/\s*user\s*>/",$text) > 0 ) {
                $this->lastResult[$title->getText()][$action] = true;
                return true;
            }
        }
    /* if open namespaces and no user-tag is defined */
    if( in_array($title->mNamespace,$wgSGPPOpenNamespaces) && preg_match("/<\s*user\s*>.*<\/\s*user\s*>/",$text) == 0 )  {
        $this->lastResult[$title->getText()][$action] = true;
        return true;
        }
    /* Nothing matched so the result ist NOT ALLOWED */
    $this->lastResult[$title->getText()][$action] = false;
    $result = false;
    return false;
    }
}


/* DropDownInsert */
'''Achtung''' Es erfolgt keine Überprüfung des Parameters Art. Es sollten nur die gängigen Bezeichnungen benutzt werden. Diese findet man z.B. bei Selfhtml.
class SGP_DDInsert {
{{Klappbox|ende}}
    private $ddIBlock = array();
   
    // button
    function ddIButton($input,$argv,&$parser) {
        // if no show parameter is given use input also as showText
        $show = isset($argv['show']) ? htmlspecialchars($argv['show']) : $input;
        // get sampleText if given
        $sample = isset($argv['sample']) ? $argv['sample'] : '';
        // picture
        if(isset($argv['picture'])) {
            $image = Image::newFromName($argv['picture']);
            if($image->exists()) {
                $iwidth = $image->getWidth();
                $iheight = $image->getHeight();
                $show = '<img src="'.$image->getURL().'" width="'.$iwidth.'" height="'.$iheight.'" />';
            }
        }
        $einput = explode('+',htmlspecialchars($input,ENT_QUOTES,'UTF-8'));
        $output  = '<a name="'.$name.'"';
        $output .= ' style="padding:1px; font-size:small;"';
        $output .= ' href="javascript:insertTags(\''.$einput[0].'\',\''.$einput[1].'\',\''.$sample.'\');"';
        $output .= '>'.$show.'</a>';
        return $output;
    }
    // Create Output
    function ddIOutput() {
        global $wgOut;


        $cssimage = '';
{{Anker|#recursiv}}{{Anker|recursiv}}{{Klappbox|TITEL=#recursiv|anfang}}
        $output  = '';
Wandelt einen Ausdruck so um, dass eine Vorlage auch mehrfach aufgerufen wird, wenn dies nötig ist. Dazu müssen die Werte die an die Vorlage übergeben werden sollen in () geschrieben werden. Erkennt die Vorlage einen Wert nicht so wird der Wert in das Ergebnis kopiert. Geklammerte Ausdrücke in Verweisen, d.h. Ausdrücke in <code>[[]]</code>, werden nicht beachtet.
        $output .= '<select size="'.$this->ddIBlock['size'].'" name="'.$this->ddIBlock['name'].'"';
<nowiki>{{#recursiv:VORLAGE|TEXT|PARAMETER}}</nowiki>
        $output .= ' onChange="insertTags(unescape(this.options[this.options.selectedIndex].value).split(\'+\')[0],unescape(this.options[this.options.selectedIndex].value).split(\'+\')[1],unescape(this.options[this.options.selectedIndex].value).split(\'+\')[2]); this.options.selectedIndex=0;"';
* VORLAGE
        $output .= '>';
:Name der eigentlichen Vorlage. An diese werden alle ermittelten Werte übergeben.
        $output .= '<option value="++" selected="selected">';
* TEXT
        $output .= $this->ddIBlock['title'];
:Einer oder mehrere Werte die an die Vorlage übergeben werden sollen. Handelt es sich um mehrere Werte so müssen dies in Klammern <code>()</code> geschrieben werden. Nicht beachtet werden Ausdrücke in <code>[[]]</code>.
        $output .= '</option>';
* PARAMETER
        foreach($this->ddIBlock['values'] as $values) {
:Dieser Parameter wird, falls vorhanden, an die Vorlage weitergegeben. Es ist auch möglich beliebig viele weitere Parameter an zu geben, jeweils durch {{!}} getrennt. Diese werden alle weitergegeben.
            $output .= $this->ddILine($values['text'],$values['value'],$values['image']);
::''Achtung: Diese Parameter werden ohne Veränderung weitergegeben.''
        }
        $output .= "</select>";
        return $output;
    }


    // <ddselect title="titleText" size="sizeInt" name="nameText">...</ddselect>
;Beispiel
    function ddISelect($input,$argv,&$parser) {
<nowiki>{{#recursiv:Kürzel/Organisation|(sgc) (sga)}}</nowiki>
        $this->ddIBlock = array('size'=>1,'name'=>'Auswahl','title'=>'[ bitte wählen ]','pwidth'=>0,'pheight'=>1,'values'=>array());
Ergibt: {{#recursiv:Kürzel/Organisation|(sgc) (sga)}}
        if(isset($argv['title'])) {
            $this->ddIBlock['title'] = $argv['title'];
        }
        if(isset($argv['size'])) {
            $this->ddIBlock['size'] = $argv['size'];
        }
        if(isset($argv['name'])) {
            $this->ddIBlock['name'] = $argv['name'];
        }
        $parser->recursiveTagParse($input);
        return $this->ddIOutput();
    }


    // <ddvalue show="showText" sample="sampleText" picture="name">value</ddvalue>
Dieser Aufruf entspricht dem folgenden
    function ddIValue($input,$argv,&$paser) {
<nowiki>{{Kürzel/Organisation|sgc}} {{Kürze/Organisation|sga}}</nowiki>
        // if no show parameter is given use input also as showText
{{Klappbox|ende}}
        $show = isset($argv['show']) ? $argv['show'] : $input;
        // get sampleText if given
        $sample = isset($argv['sample']) ? $argv['sample'] : '';
        // add + to input if not set - need for javascript-split
        if(strpos($input,"+") === false) {
            $input .= "+";
        }
        // picture
        $iURL = '';
        if(isset($argv['picture'])) {
            $image = Image::newFromName($argv['picture']);
            if($image->exists()) {
                $iURL = $image->getURL();
                $iwidth = $image->getWidth();
                $iheight = $image->getHeight();
                if($iwidth > ($this->ddIBlock['pwidth']-5)) {
                    $this->ddIBlock['pwidth'] = $iwidth+5;
                }
                if($iheight > ($this->ddIBlock['pheight'])) {
                    $this->ddIBlock['pheight'] = $iheight;
                }
            }
        }
        // save parameter to global array
        $this->ddIBlock['values'][] = array('value'=>$input.'+'.$sample,'text'=>$show,'image'=>$iURL);
        return '';
    }


    // create option line
{{Anker|#tocmod}}{{Anker|tocmod}}{{Klappbox|TITEL=#tocmod|anfang}}
    function ddILine($text,$value,$image) {
<nowiki>{{#tocmod:<Parameter>|<Default>}}</nowiki>
        if($this->ddIBlock['pwidth'] > 0) {
Mit dieser Anweisung wird gesteuert ob und wie das Inhaltsverzeichnis angezeigt wird. Die Erweiterung entspricht den Original Wiki-Befehlen <code><nowiki>__TOC__</nowiki></code>, <code><nowiki>__NOTOC__</nowiki></code>, <code><nowiki>__FORCETOC__</nowiki></code> und ermöglich das Ein- bzw. Ausblenden des Inhaltsverzeichnisses. Die Ausgabe wird über die folgenden Parameter gesteuert. Sollen mehrere Parameter angegeben werden, müssen diese mit Komma getrennt angegeben werden. Wird der erste Parameter leer übergeben, so wird statt dessen der Defaultwert benutzt. Ist auch dieser nicht angegeben, wird als Parameter ''set'' benutzt.
            if(!empty($image)) {
* no
                $css = 'style="height: '.$this->ddIBlock['pheight'].'px; padding-left: '.$this->ddIBlock['pwidth'].'px; padding-right: 5px; background-repeat: no-repeat; background-image: url('.$image.');"';
:Kein Inhaltsverzeichnis, entspricht <code><nowiki>__NOTOC__</nowiki></code>
            } else {
* force
                $css = 'style="padding-left: '.$this->ddIBlock['pwidth'].'px; padding-right: 5px;"';
:Erzwingt das Inhaltsverzeichnis, entspricht <code><nowiki>__FORCETOC__</nowiki></code>
            }
* set
        } else {
:Setzt das Inhaltsverzeichnis an diese Stelle, entspricht <code><nowiki>__TOC__</nowiki></code>
            $css = '';
* hide
        }
:Das Inhaltsverzeichnis wird verdeckt ausgegeben, unabhängig von den Benutzereinstellungen.
        $output = '<option '.$css.' value="'.rawurlencode(html_entity_decode(htmlentities($value,ENT_NOQUOTES,'UTF-8'))).'">'.$text.'</option>'."\n";
* show
        return $output;
:Das Inhaltsverzeichnis wird aufgedeckt ausgegeben, unabhängig von den Benutzereinstellungen.
    }
}


/* ParserAdds */
;Beispiel
class SGP_ParserAdds {
* <code><nowiki>{{#tocmod:force,hide}}</nowiki></code>
    // trim
: Erzwingt das Inhaltsverzeichnis und verdeckt es.
    function trim( &$parser, $inStr='') {
* <code><nowiki>{{#tocmod:{{{Register|}}}|set,hide}}</nowiki></code>
        return array(trim($inStr),'isHTML'=>true,'noparse'=>true);   
: Benutzt entweder den Wert der Variable oder wenn diese nicht belegt ist den angegebenen Defaultwert. ''Bei der Variable ist der Trenner {{!}} (also <code><nowiki>{{{Register|}}}</nowiki></code> statt <code><nowiki>{{{Register}}}</nowiki></code>) wichtig, da nur so bei undefinierter Variable auch ein Leerstring übergeben wird.''
    }
{{Klappbox|ende}}


    //  
== AddWhosOnline ==
    function userinfo( &$parser, $inStr='name') {
Bei AddWhosOnline handelt es sich um Zusatzfunktionen der Erweiterung [http://www.mediawiki.org/wiki/Extension:WhosOnline WhosOnline]. Die AddWhosOnline erkennt wenn ein Benutzer sich abmeldet und setzt ihn entsprechend auf ''offline''. Außerdem wird ein Eintrag im Persönlichen Menü erzeugt der auf die WhosOnline Spezialseite verweist.
        global $wgUser;


        $back = '';
== IE9 Hack ==
        switch($inStr) {
;Das Problem
        case 'name' : $back = $wgUser->mName;
Die MediaWiki JavaScript-Funktion <code>insertTag</code> zeigt mit dem Internet Explorer 9 ein störendes Verhalten. Wird ein Text über die MediaWiki in den Editor eingefügt, so springt der Bildschirm an den Anfang der Seite. Diese Funktion wird von den Modulen NewArticle und DDInsert in SGPack benutzt.
            break;
;Die Lösung
        case 'id' : $back = $wgUser->mId;
Um dies zu umgehen, speichert sich der IE9 Hack die Bildschirmposition vor dem Einfügen und setzt sie danach wieder zurück. Somit kann der Benutzer normal weiterarbeiten.
            break;
;Probleme
        case 'realname' : $back = $wgUser->mRealName;
Mit dem Internet Explorer kann es dadurch zu einem kurzen Flackern der Darstellung kommen, in anderen Browsern geschieht dies normalerweise nicht.
            break;
;Hinweis
        case 'email' : $back = $wgUser->mEmail;
Die betroffene JavaScript-Funktion wird auch an anderer Stelle, z.B. im Editor, durch die MediaWiki Software benutzt. An diesen Stellen hilft der IE9 Hack nicht, da er nicht eingebunden wird.
            break;
        case 'home' : $back = '[[Benutzer:'.$wgUser->mName.']]';
            break;
        case 'talk' : $back = '[[Benutzer Diskussion:'.$wgUser->mName.']]';
            break;
        }
        return array($back,'noparse'=>true);
    }


    function recursiv( &$parser, $parstext = '', $calltemplate = '', $callparameter = '' ) {
== VideoPlayer ==
        # The parser function itself
VideoPlayer erlaubt das einbinden von externen Videoquellen in Mediawiki. Die Ausgabe der Videos erfolgt mit [http://www.jwplayer.com jwplayer]. Das Einbinden erfolgt durch folgende Parser Anweisung.
        # The input parameters are wikitext with templates expanded
<nowiki>{{#vplayer:video="VIDEO"}}</nowiki>
        # The output should be wikitext too
        if(empty($callparameter)) {
            $replace = '{{'.$calltemplate.'|\1|kl}}';
        } else {
            $replace = '{{'.$calltemplate.'|(\1)|'.$callparameter.',kl}}';
        }
        // $output = preg_replace("/\{\{\{\{(.*?)\}\}\}\}/", $replace , $parstext,-1,$count);
        $output = preg_replace("/\((.*?)\)/", $replace , $parstext,-1,$count);
        if($count == 0) {
            if(empty($callparameter)) {
                $output = '{{'.$calltemplate.'|'.$parstext.'}}';
            } else {
                $output = '{{'.$calltemplate.'|'.$parstext.'|'.$callparameter.'}}';
            }
        }
        return array($output,'noparse'=>false);
    }


}
Der einzige notwendige Parameter ist entweder <code>video</code> oder <code>playlist</code>. Ist keiner davon angegeben erfolgt eine Fehlermeldung. Text Parameter sollten mit " oder ' eingeschlossen angegeben werden.


/* Cache Array */
* <code>video</code>
class SGP_CacheArray {
: Angabe der Adresse des Videos. Es muss sich um eine vollständige Netzadresse handeln. Videos aus dem Wiki müssen also vorher umgewandelt werden. Dies kann durch die Mediawiki Funktion <nowiki>{{filepath:Datei}}</nowiki> erfolgen.
    private $Cache = array();
* <code>playlist</code>
    private $Key_Delimiter = '_';
: Erlaubt die Angabe mehrerer Videos, welche nacheinander abgespielt werden. Rechts vom Video erscheint eine Liste aller Videos aus der eines gewählt werden kann. Die einzelnen Videos werden durch Komma getrennt. ''Da es Netzadressen mit Komma geben kann ist es notwendig die Adressen in " einzuschließen!''.


    // combinate keys
;Zusätzliche Parameter
    function keys() {
* <code>width</code>, <code>height</code>
        // get the parser parameter
: Breite und Höhe des Videos. Default: <code>480,270</code>
        $param = func_get_args();
* <code>poster</code>{{Anmerkung|Diese Parameter enthalten bei einer Playliste Komma getrennte Listen der Werte für die einzelnen Videos.|name=Playlist1}}
        $parser = current($param);
: Erlaubt die Angabe eines Bildes aus dem Wiki das vor dem Start des Videos gezeigt wird. Die Angabe der Datei erfolgt direkt ohne <code><nowiki>[[Bild:...]]</nowiki></code>
        // get the parts for the key
:<code><nowiki>{{vplayer:video="VIDEO"|poster="SamPhoto.jpg"}}</nowiki></code>
        $key = '';
* <code>title</code>{{Anmerkung|name=Playlist1}}
        while($value = next($param)) {
: Titel des Videos. Wird im Playbutton oder auch in der Playliste angezeigt.
            // get key-modifier(s) m:key
* <code>description</code>{{Anmerkung|name=Playlist1}}
            list($mod,$mvalue) = explode(':',$value,2);
: Beschreibung der Videos in der Playliste. Wird in der Titelbar angezeigt
            // if mvalue is set means we also have modifier
* <code>autostart</code> ''Funktioniert nicht immer''
            if(isset($mvalue)) {
: Die Wiedergabe startet sofort.
                if(strpos($mod,'u')!==false) {  // uppercase
* <code>repeat</code>
                    $mvalue = strtoupper($mvalue);
: Das Video läuft in einer Endlosschleife
                }
* <code>mute</code>
                if(strpos($mod,'l')!==false) {  // lowercase
: Das Video wird ohne Ton abgespielt
                    $mvalue = strtolower($mvalue);
* <code>controls</code> ''Parameter ohne Funktion - Fehler im SGPack''
                }
: Es werden keine Bedienelemente angezeigt. Eine Sterung des Players ist dann nur noch über die [http://support.jwplayer.com/customer/portal/articles/1439411-example-a-chromeless-player Player API] möglich!
                $value = $mvalue;
* <code>displaytitle</code>
            }
: Unterdrückt die Ausgabe des Titels im Playbutton
            // keys always trim 
* <code>stretching</code> ''Funktioniert nicht für alle Videos''
            $value = trim($value);
: Einstellung wie das Video an den Bereich angepasst werden soll. Mögliche Werte: ''uniform'' (Vorgabe), ''fill'', ''exactfit'', ''none''
            // drop empty mw-variables
* <code>css</code>
            $value = preg_replace('/\{\{\{.*?\}\}\}/','',$value);
: Erlaubt die Angabe einer CSS-Klasse, welche im DIV-Container des Videos gesetzt wird.
            // if value is not empty add to key
            if(!empty($value)) {
                if(!empty($key)) {
                    $key .= $this->Key_Delimiter;
                }
                $key .= $value;
            }
        }
        return $key;
    }


    // carray main part
* <code>l.position</code>{{Anmerkung|Diese Parameter ist ohne Playliste ohne Funktion.|name=Playlist2}}
    function carray() {
: Position der Titelbar. Mögliche Werte: right (Vorgabe), bottom, none
        // minimum parser, cachenumber and action are needed   
* <code>l.size</code>{{Anmerkung|name=Playlist2}}
        if(func_num_args() < 3) {
: Größe der Titelbar. Vorgabe: 150
            return array('','noparse'=>true);
* <code>l.layout</code>{{Anmerkung|name=Playlist2}}
        }
: Darstellung der Titelbar. Mögliche Werte: basic, extended (Vorgabe) - extended ist mit Vorschau und Beschreibung, Basic eine reine Textliste mit dem Titel
        // get the parser parameter
:;Anmerkungen
        $param = func_get_args();
<references group="A" />
        $parser = current($param);
        // get the first two wiki-parameters (chachenumber, action)
        $cnumber = trim(next($param));
        $action = strtolower(trim(next($param)));
        // default output is empty
        $output = '';
        // action
        switch($action) {
        case 'f' :
        case 'file' :
        case 'fr' :
        case 'fileread' :
            // read array out of "file"
            $file = next($param);
            // if carray is already set do not read it again (cache!)
            if(!isset($this->Cache[$cnumber])) {
                $fh = new Article(Title::newFromText($file));
                $content = $fh->fetchContent();
                if($fh->mContentLoaded) {
                    $cont = explode('|',$content);
                    foreach($cont as $line) {
                        list($index,$value) = explode('=',$line,2);
                        $this->Cache[$cnumber][trim($index)] = trim($value);
                    }
                }
            }
            // leave switch (only if file)
            if(($action === 'f') or ($action === 'file')) {
                break;
            }
            // read key
            $key = trim(next($param));
            // read cache
            $value = $this->Cache[$cnumber][$key];
            // if no value, look for default
            if(isset($value)) {
                $output = $value;
            } else {
                if(isset($this->Cache[$cnumber]['#default'])) {
                    $output = $this->Cache[$cnumber]['#default'];
                }
            }      
            break;
        case 'w' : // only create new carray
        case 'write' :
        case 'rw' : // write new carray and read one value
        case 'readwrite' :
            // read key (only if readwrite)
            if(($action === 'rw') or ($action === 'readwrite')) {
                $key = trim(next($param));
            }
            // if carray is already set do not read it again (cache!)
            if(!isset($this->Cache[$cnumber])) {
                // read the keys and values and save in carray
                while($values = next($param)) {
                    list($index,$value) = explode('=',$values,2);
                    $this->Cache[$cnumber][trim($index)] = trim($value);
                }
            }
            // leave switch (only if write)
            if(($action === 'w') or ($action === 'write')) {
                break;
            }
        case 'r' : // read value out of carray
        case 'read' :
            // read key, if not already set by action readwrite
            if(!isset($key)) {
                $key = trim(next($param));
            }
            // read cache
            $value = $this->Cache[$cnumber][$key];
            // if no value, look for default
            if(isset($value)) {
                $output = $value;
            } else {
                if(isset($this->Cache[$cnumber]['#default'])) {
                    $output = $this->Cache[$cnumber]['#default'];
                }
            }   
            break;
        case 'd' :  // delete carray
        case 'delete' :
            unset($this->Cache[$cnumber]);
            break;
        case 'c' : // count elements in carray
        case 'count' :
            $output = count($this->Cache[$cnumber]);
            break;
        case 'u' : // test if cache is used
        case 'used' :
            // if carray is used give size
            if(isset($this->Cache[$cnumber])) {
                $output = count($this->Cache[$cnumber]);
            }
            break;
        }
        return array($output,'noparse'=>true);
    }
}
</nowiki></pre>
Download des Codes [http://www.stargate-wiki.de/download/SGPack.i18n.txt SGPack.i18n.php]
<pre><nowiki>
<?php
/**
* Internationalisation file for extension BlockSpammer.
*
*/


$messages = array();
;Beispiele
* <code><nowiki>{{#vplayer:video="http://s3.amazonaws.com/sgu-assets/assets/Video/1243990124/604/sg11001-0194ws.flv"|width="250"|height="187"|poster="SamPhoto.jpg"}}</nowiki></code>
* <code><nowiki>{{#vplayer:playlist="https://www.youtube.com/watch?v=6xJl1dGdddw","https://www.youtube.com/watch?v=jfNjgOIoo-c"|title="Video 1","Video 2"|description="text text","hallo video"|width="300"|height="300"|l.position="bottom"|l.size=100|l.layout="basic"}}</nowiki></code>
* Weitere Beispiele findet man auf der Seite [[Benutzer:Rene/SGPack Test]].


/**
;Hinweise
* English
Die Ausgabe erfolgt in einem <code><nowiki><div></nowiki></code>-Bereich. Der Bereich kann mit der CSS-Klasse <code>video_player</code> verändert werden, die in allen Bereichen immer gesetzt ist. Als weitere Möglichkeit kann zu jedem Bereich eine eigene Klasse angegeben werden. Jeder Bereich hat einen eigene ID (<code>video_player_NR</code>, wobei NR die laufende Nummer des Players ist, in der Reihenfolge ihrer Angabe im Artikel).
*/
$messages['en'] = array(
'block_spammer_error_page_title' => 'Spam suspicion',
'block_spammer_error-desc'      => 'IP User are not allowed to make external links',
'block_spammer_error'            => 'Sorry, your edit seems to be spam. You must register to make this edit.',
);


/** Message documentation (Message documentation)
;LocalSettings-Parameter
* @author Purodha
* <code>$wgSgpVideoPlayerCacheOff</code>
*/
:Wird der Parameter auf <code>true</code> gesetzt so wird der MW-Cache für die Seite mit Videoausgaben deaktiviert. In der Voreinstellung ist der Cache aktiv
$messages['qqq'] = array(
* <code>$wgSgpVideoPlayerEngine</code>
'block_spammer_error-desc' => 'Shown in [[Special:Version]]',
:Ermöglicht die Auswahl eines Videoplayers. Momentan ist nur der jwplayer installiert.
);


===Javascript Steuerung===
Der Player kann mit Hilfe von Javascript gesteuert werden. Eine Einführung findet man im jwplayer [http://support.jwplayer.com/customer/portal/articles/1439411-example-a-chromeless-player Portal]. Eine Liste der Funktionen in der [http://support.jwplayer.com/customer/portal/topics/564475-javascript-api/articles API Reference].


/** German (Deutsch)
Zur Ansteuerung eignen sich z.B. Javascript Button aus der SGPack Erweiterung. Die folgende Anweisung erzeugt einen Startknopf für das erste Video auf der Seite.
  */
  <nowiki><jsbutton click="jwplayer('video_player_1').play();">Start Video 1</jsbutton></nowiki>
$messages['de'] = array(
'block_spammer_error_page_title' => 'Spam Verdacht',
'block_spammer_error-desc' => 'Nicht angemeldete Benutzer dürfen keine externen Links anlegen.',
'block_spammer_error' => 'Die letzte Änderungen kann nicht gespeichert werden da der Verdacht auf Spam besteht. Änderungen dieser Art sind nur angemeldeten Benutzern erlaubt.',
);
</nowiki></pre>