<?xml version="1.0" encoding="ISO-8859-1"?>
<!DOCTYPE module [
  <!ELEMENT module (dtdversion,name,version,description*,help*,about*,requires*,file+)>
  <!ELEMENT dtdversion (#PCDATA)>
  <!ELEMENT name (#PCDATA)>
  <!ELEMENT version (#PCDATA)>
  <!ELEMENT mincmsversion (#PCDATA)>
  <!ELEMENT description (#PCDATA)>
  <!ELEMENT help (#PCDATA)>
  <!ELEMENT about (#PCDATA)>
  <!ELEMENT requires (requiredname,requiredversion)>
  <!ELEMENT requiredname (#PCDATA)>
  <!ELEMENT requiredversion (#PCDATA)>
  <!ELEMENT file (filename,isdir,data)>
  <!ELEMENT filename (#PCDATA)>
  <!ELEMENT isdir (#PCDATA)>
  <!ELEMENT data (#PCDATA)>
]>
<module>
	<dtdversion>1.3</dtdversion>
	<name>Guestbook</name>
	<version>1.3.2</version>
  <mincmsversion>0.13</mincmsversion>
	<help><![CDATA[<h3>Que fait ce module?</h3>
	<p>Le module Livre d&#039;Or fournit un nouveau type de contenu (contenttype) et peut aussi s&#039;utiliser sous forme de balise CMSMS.
Il permet aux visiteurs de laisser un message d&#039;appr&eacute;ciation de votre site web.</p>

<h3>Securit&eacute;</h3>
<p>L&#039;administrateur doit appartenir &agrave; un groupe qui a la permission &quot;Modify Guestbook Entries&quot; afin d&#039;ajouter, &eacute;diter et supprimer des messages dans le Livre d&#039;Or. L&#039;administrateur doit appartenir &agrave; un groupe qui a la permission &quot;Modify Guestbook Template&quot; afin de modifier le gabarit du Livre d&#039;Or. Tous les visiteurs de votre site peuvent poster des messages.</p>

<h3>Comment l&#039;utiliser ?</h3>
<p>Le meilleur moyen est de cr&eacute;er une nouvelle page de Contenu et de d&eacute;finir son Type de contenu &agrave; &quot;Livre d&#039;Or&quot;.<br />
Ensuite, vous pouvez s&eacute;lectionner les options que vous souhaitez utiliser dans le Livre d&#039;Or.<br />
Si vous voulez positionner le module apr&egrave;s du contenu autre (texte, images...),  vous devrez alors utiliser la deuxi&egrave;me m&eacute;thode, qui consiste &agrave; utiliser le module en conjonction avec la balise cms_module.<br />
Cel&agrave; vous permet d&#039;ins&eacute;rer le module dans votre gabarit ou page, &agrave; l&#039;endroit que vous souhaitez, afin d&#039;afficher les messages du Livre d&#039;Or.<br />
La syntaxe ressemble alors &agrave; ceci :<br />
      <code>{cms_module module=&quot;Guestbook&quot; number=5 shownow=0 smiley=0 mailnoti=you@example.com dateformat=&quot;%d-%m-%Y %H:%M&quot;}</code>
</p>

<h3>Quels sont les param&egrave;tres ?</h3>
<ul>
<li><em>(optionnel)</em> textleng=&quot;1000&quot; - S&eacute;lectionne combien de caract&egrave;res peuvent &ecirc;tre entr&eacute;s par message.
La valeur par d&eacute;fault est 1000 caract&egrave;res.  Ce param&egrave;tre affecte la saisie cot&eacute; visiteur et cot&eacute; administrateur.</li>
<li><em>(optionnel)</em> number=&quot;10&quot; - Le nombre maximum de messages sur une page.  Laiss&eacute; vide ne montrera que 10 messages</li>
<li><em>(optionnel)</em> mailnoti=&quot;votremail@votredomaine.tld&quot; - Notification par E-mail quand un messsage est ajout&eacute;. Le module CMSMailer est utilis&eacute; s&#039;il est install&eacute;. Sinon, la fonction php mail est utilis&eacute;e.</li>
<li><em>(optionnel)</em> sortasc=&quot;1&quot; - Trie les messages par ordre de date croissante (les nouveaux &agrave; la fin).</li>
<li><em>(optionnel)</em> dateformat=&quot;dateformat&quot; - Change le format d&#039;affichage de la date, suivant les codes de format mysql</li>
<li><em>(optionnel)</em> shownow=&quot;1&quot; - Affiche les messages imm&eacute;diatement apr&egrave;s leur insertion (pas de mod&eacute;ration par un administrateur).</li>
<li><em>(optionnel)</em> smiley=&quot;1&quot; - Remplace les smiley &eacute;crits en texte par des images.</li>
<li><em>(optional)</em> captcha=&quot;1&quot; - Autorise captcha dans le formulaire d&#039;entr&eacute;e des messages. Text_CAPTCHA, de PEAR est requis (voir la section sur Captcha plus bas)</li>
<li><em>(optionnel)</em> showaddform=&quot;1&quot; - Affiche directement le formulaire d&#039;ajout de message, donc remplace le bouton &quot;Ajouter un message&quot;.</li>
<li><em>(optionnel)</em> lang=&quot;fr_FR&quot; - Param&eacute;trage de la langue.</li>
</ul>

<h3>Quelles possibilit&eacute;s pour modifier l&#039;apparence du Livre d&#039;Or ?</h3>
<p>Le gabarit utilis&eacute; pour afficher le Livre d&#039;Or peut &ecirc;tre modifi&eacute; &agrave; partir du panneau d&#039;administration</p>
<p>
Un gabarit d&#039;affichage du Livre d&#039;Or est install&eacute; par d&eacute;faut avec le module.<br/>
Le gabarit par d&eacute;faut est supprim&eacute; quand le module Livre d&#039;Or est d&eacute;sinstall&eacute; et peut &ecirc;tre modifi&eacute; par une mise &agrave; jour du module. Donc faites une copie de ce que vous modifiez.<br/>
Attachez le gabarit au gabarit de la page utilis&eacute;e.
</p>

<p>
   Ces variables sont d&eacute;finies dans le gabarit par d&eacute;faut :
    <pre>
    date_title
    date
    time
    time_hour_title
    
    sender_title	
    sender
    
    country_title
    country
    
    e_mail_title
    e_mail		// l&#039;adresse E-mail
    e_mail_cloaked	// l&#039;E-mail avec . remplac&eacute; par &amp;lt;point&amp;gt; and @ by &amp;lt;at&amp;gt;
    
    homepage_title
    homepage
    
    message_title
    message
    </pre>
</p>

<strong>Administration</strong>
<p>
admin_entries_top.tpl -> Noms des colonnes et pagination dans la liste des messages.<br/>
admin_entries_entry.tpl -> Gabarit d&#039;un message du Livre d&#039;Or.<br/>
admin_entries_bottom.tpl -> La fin d&#039;un message sur le formulaire d&#039;admin.<br />
admin_entry.tpl-> Le formulaire utilis&eacute; pour ins&eacute;rer ou modifier un message.<br/>
admin_template_edit.tpl -> Utilis&eacute; pour modifier le gabarit par defaut de la base de donn&eacute;es.
</p>

<strong>Gabarits d&#039;affichage du contenu</strong>
<p>
smiley.tpl -> The smiley table, used when the smiley parameter is used and the Smileys module is not installed.<br/>
</p>

<p>
newguest.tpl -> Bouton pour &quot;ajouter un nouveau message&quot;<br/>
insertform.tpl -> Le formulaire d&#039;entr&eacute;e d&#039;un message<br />
smiley.tpl-> Gabarit du tableau des smileys<br/>
prevnext.tpl-> Les boutons Pr&eacute;c&eacute;dent et Suivant (ne s&#039;affiche que dans le cas de plusieurs pages)<br/>
success_message.tpl-> Le message qui s&#039;affiche &agrave; la place du formulaire apr&egrave;s un envoi de message r&eacute;ussi.
</p>

Dans le r&eacute;pertoire template se trouve un r&eacute;pertoire db dans lequel est stock&eacute; le gabarit par d&eacute;faut qui est copi&eacute; dans la base de donn&eacute;es &agrave; l&#039;installation du module.<br />
Par d&eacute;faut, le fichier guestbook_entry-default.tpl est utilis&eacute;, mais si une fichier (modifi&eacute;) guestbook_entry.tpl est pr&eacute;sent, il sera utilis&eacute; &agrave; la place.
</p>

<h3>Captcha</h3>
<p>
    A catpcha challenge-response test (see <a href="http://www.wikipedia.org/wiki/Captcha">http://www.wikipedia.org/wiki/Captcha</a>) can be used to prevent guestbook spam. The Guestbook module uses PEAR&#039;s Text_CAPTCHA, which will have to be installed on the server.<br />
    You must have GD installed with support for JPEGs, PNGs and TrueType fonts. For more information, see <a href="http://www.php.net/image/">PHP Image Functions</a>.<br />
    Text_CAPTCHA depends on two other PEAR packages, Image_Text and Text_Password. It uses Text_Password to generate the random phrase used in the CAPTCHA test and Image_Text to generate an image file with text in it.<br />
    The process for installing Text_CAPTCHA at the command line is:<br />
    <pre>
    $ pear install Text_Password
    $ pear install Image_Text
    $ pear install --alldeps Text_CAPTCHA
    </pre>
    The webserver process must have sufficient rights to (over)write the file images/captcha/captcha.jpg in the Guestbook module directory.
</p>

<h3>Importer des messages du Livre d&#039;Or</h3>
<p>
    Si vous avez une version ancienne du module Livre d&#039;Or et que vous souhaitez importer vos messages dans votre nouveau Livre d&#039;Or, un script est disponible.
    Faites pointer votre browser internet sur le script gastbuch-import.php qui se trouve dans le r&eacute;pertoire du module Livre d&#039;Or (par exemple: http://www.example.com/cms/modules/Guestbook/gastbuch-import.php) avant de d&eacute;sinstaller le vieux module.
</p><h3>Param&egrave;tres</h3><ul><li><em>(optional)</em> lang="en_US" - Param&egrave;tre utilis&eacute; pour sp&eacute;cifier dans quelle langue afficher le module dans la partie publique. Ce param&egrave;tre n&#039;est pas support&eacute; ou utile pour tous les modules.</li><li><em>(optional)</em> mode="guestbook" - &quot;guestbook&quot;, &quot;form&quot;, &quot;entrylist&quot; or &quot;entry&quot;</li><li><em>(optional)</em> show_entry="" - ID d&#039;une entr&eacute;e &agrave; afficher (mode=&quot;entry&quot; est n&eacute;cessaire)</li><li><em>(optional)</em> guestbook="1" - ID du Livre d&#039;Or</li><li><em>(optional)</em> shownow="0" - Afficher les messages d&egrave;s leur d&eacute;p&ocirc;t, sans validation par un administrateur.</li><li><em>(optional)</em> showaddform="0" - Afficher directement le formulaire de d&eacute;p&ocirc;t de message sur la premi&egrave;re page. Ceci remplace le bouton &quot;Ajouter un message&quot;.</li><li><em>(optional)</em> textleng="1000" - Configure le nombre maximum de caract&egrave;res autoris&eacute;s dans un message. Ce param&egrave;tre affecte &agrave; la fois la validation du message du c&ocirc;t&eacute; client mais aussi du c&ocirc;t&eacute; serveur &eacute;galement. La valeur par d&eacute;faut est 1000.</li><li><em>(optional)</em> number="10" - Nombre maximum de messages affich&eacute;s par page.</li><li><em>(optional)</em> timespan="0" - D&eacute;lai minimum entre deux envois de message (en secondes).</li><li><em>(optional)</em> sortasc="0" - Trier les messages dans un ordre croissant (les nouveaux messages seront &agrave; la fin).</li><li><em>(optional)</em> dateformat="%d-%m-%Y %H:%M" - Modifier le format d&#039;affichage de la date (sp&eacute;cifier au format PHP)</li><li><em>(optional)</em> smiley="0" - Traduire les &eacute;motic&ocirc;nes textuels vers leur correspondant imag&eacute; et afficher la table des &eacute;motic&ocirc;nes dans le formulaire de saisie de message. Ceci utilise le module Emotic&ocirc;nes (Smileys) s&#039;il est install&eacute;.</li><li><em>(optional)</em> captcha="0" - Active l&#039;utilisation de captcha dans le formulaire de saisie de message. Le module Captcha doit &ecirc;tre install&eacute; pour que ce param&egrave;tre fonctionne correctement.</li><li><em>(optional)</em> hide_insertbutton_after_post="0" - Quand le message est post&eacute;, le bouton d&#039;envoi est masqu&eacute;. </li><li><em>(optional)</em> mailnoti="" - L&#039;adresse e-mail vers laquelle envoyer une notification lorsqu&#039;un message a &eacute;t&eacute; d&eacute;pos&eacute;. Si install&eacute;, le module CMSMailer sera utilis&eacute; pour envoyer ce mail (sinon ce sera la fonction mail native de PHP).</li></ul>]]></help>
	<about><![CDATA[<br />Auteur&nbsp;: Krisztian Kishazi (original author: up to version 0.6)
			<p>Code contributors:
			<ul>
				<li>Victor Katolyk (version 0.7)</li>
				<li>Dick Ittmann (version 0.8 and on)</li>
				<li>Tobias Kretschmar (version 1.1.10)</li>
				<li>Andi Petzoldt (version 1.1.11 and on)</li>
                <li><a href="mailto:gabr.matias@gmail.com">Gabriel Matias</a> (version 1.3.0 and on)</li>                                
			</ul></p> &lt;<a href="support@expectmore.at">support@expectmore.at</a>&gt;<br /><br />Version : 1.3.2<br /><br />Historique des changements&nbsp;:<br /><ul>
	<li>
		<strong>Version 1.3.0</strong><br />
        <span style=&quot;color:#FF0000;font-style:italic;display:block;&quot;>You have to reset your Guestbook templates when upgrade to this version.</span>
		Fixes:
		<ul>
            <li><span style=&quot;font-weight: bold;&quot;>Content type is now USABLE</span></li>
			<li>Fixed page printing in random</li>
            <li>Fixed XSS security issue in next parameter (Pagination class)</li>
            <li>Fixed message list table who can be broken by HTML in message</li>
            <li><span style=&quot;font-style:italic;font-weight: bold;&quot;>Now fully compatible with CMSMS 1.8</span></li>
		</ul>
        Improvements:
        <ul>
            <li>Content type: More date format</li>
            <li>Prettier URL</li>
            <li>Some translation and admin display improvements</li>
            <li>Completely rewrited Pagination module (faster and more secure)</li>
        </ul>
        New Feature:
        <ul>
            <li>Smiley in Front Wysiwyg</li>
            <li>Front date format can be specified in GetDate() in <a href="http://php.net/manual/en/function.date.php">php format</a> (not english only)</li>
            <li>Front date format is now using smarty to get multilanguage capability - date format should be set as <a href="http://www.smarty.net/manual/en/language.modifier.date.format.php">smarty format</a></li>
            <li>Possibility to select all current entry</li>
            <li>Pagination rewrited to be more speed and usefull</li>
            <li>Managing in which guestbook is the entry</li>
            <li>Multiple destination for notification mail</li>
        </ul>
        Minor fixes:
        <ul>
            <li>W3 proof for Javascript</li>
            <li>Few PHP Notices and warnings</li>
        </ul>
	</li>
	<li>
		<strong>Version 1.1.12</strong><br />
		Fixes:
		<ul>
			<li>Fixed bug when posting a new entry with mod_rewrite on (Thanks to blast2007)</li>
			<li>Fixed incorrect stripping of quotes returned by GetTimestamp</li>
		</ul>
	</li>
	<li>
		<strong>Version 1.1.11</strong><br />
		Fixes:
		<ul>
			<li>Fixed module compatibility with latest CMS Made Simple versions (1.5+)</li>
			<li>Fixed pagination not using full table width</li>
			<li>Fixed some small bugs adding/editing an guestbook entry</li>
			<li>Fixed special characters in (translated) pre-uninstall message(s) not being shown correctly</li>
			<li>Fixed language setting from CMS Made Simple Global Settings not being applied</li>
		</ul>
		Improvements:
		<ul>
			<li>You can now edit a guestbook entry date in the backend</li>
			<li>The number of entries shown per page in the backend is now configurable</li>
		</ul>
	</li>
	<li>
		<strong>Version 1.1.10</strong>
		<ul>
			<li>FIX: Removed this warning from the admin panel: &quot;Warning: vsprintf() [function.vsprintf]: Too few arguments in /home/mywebsite/public_html/lib/translation.functions.php on line 62&quot;</li>
			<li>FIX: Insert of new entries failed, when none mandatory fields were removed from the form.</li>
			<li>FIX: Pagination created invalid XHTML (Text attribute removed)</li>
			<li>CHG: Smileys are now inserted on click via JavaScript. Plain text smileys moved into hint.</li>
			<li>FIX: Wrong encoding and HTML entities in notification emails.</li>
			<li>FIX: Enabled translation for pagination &quot;First&quot; and &quot;Last&quot;.</li>
			<li>CHG: Update SmartyPaginate from 1.5 to 1.6-dev</li>
			<li>FIX: Wrong language field &quot;e_mail&quot; in email notification.</li>
			<li>FIX: Module CMSMailer was not detected/used on PHP4</li>
		</ul>
	</li>
	<li>
		<strong>Version 1.1.9</strong>
		<ul>
			<li>Prevent an E-mail being sent to no address when the mailnoti parameter is not being used</li>
		</ul>
	</li>
	<li>
		<strong>Version 1.1.8</strong>
		<ul>
			<li>Fixed too short ip_address field</li>
			<li>Moved templates to a single tab in the admin</li>
		</ul>
	</li>
	<li>
		<strong>Version 1.1.7</strong>
		<ul>
			<li>Fixed references to old file locations</li>
			<li>Fixed Javascript warning when WYSIWYG is used</li>
		</ul>
	</li>
	<li>
		<strong>Version 1.1.6</strong>
		<ul>
			<li>Fixed character counter not working with FCKeditor</li>
			<li>Moved errormessage to lang file</li>
			<li>Deleted some redundant files</li>
		</ul>
	</li>
	<li>
		<strong>Version 1.1.5</strong>
		<ul>
			<li>Fixed ModuleIsInstalled method always returning false for admin modules/FCKEditorX</li>
			<li>Fixed character counter always starting at 1000</li> 
		</ul>
	</li>
	<li>
		<strong>Version 1.1.4</strong>
		<ul>
			<li>Fixes breaks in messages not showing in 1.1.3</li>
			<li>Added (optional) basic WYSIWYG on the Guestbook entry form</li>
			<li>Added logging of guestbook entry sender IP address</li>
			<li>Added &quot;Modify Guestbook Settings&quot; permission</li>
		</ul>
	</li>
	<li>
		<strong>Version 1.1.3</strong>
		<ul>
			<li>Improved pagination</li>
			<li>Rewrote front-end code to use Smarty for all output</li>
			<li>The front-end Smarty templates now use arrays</li>
			<li>Made most front-end templates editable from the admin</li>
			<li>Added events</li>
			<li>Added bad word filter</i>
		</ul>
	</li>
	<li>
		<strong>Version 1.1.2</strong>
		<ul>
			<li>Fixed a bug where the Next button would show when it shouldn&#039;t</li>
			<li>Any guestbook content is deleted on uninstall to prevent fatal errors in cmsmadesimple-1.x</li>
		</ul>
	</li>
	<li>
		<strong>Version 1.1.1</strong>
		<ul>
			<li>Compatiblity changes for cmsmadesimple-1.0 and a small bugfix</li>
		</ul>
	</li>
	<li>
		<strong>Version 1.1</strong>
		<ul>
			<li>Added Captcha support (in a seperate Captcha module)</li>
			<li>Added timespan parameter (minimal timespan between posts)</li>
			<li>Added location field (for State/Province/City/Town)</li>
			<li>Make use of the Smiley module if it is installed</li>
			<li>Made the module compatible with the cmsmadesimple-1.0 series</li>
			<li>Minimal required CMS version changed to 0.13</li>
		</ul>
	</li>
	<li>
		<strong>Version 1.0</strong>
		<ul>
			<li>Module renomm&eacute; (de gastbuch) en Guestbook pour repr&eacute;senter la langue naturelle et suivre leconventions de CMS Made Simple.</li>
			<li>Activ&eacute; la gestion (suppression, activation et d&eacute;sactivation) d&#039;entr&eacute;es multiples depuis le panneau d&#039;administration.</li>
			<li>Il y a deux permissions s&eacute;par&eacute;es &#039;Modify Guestbook Entries&#039; et &#039;Modify Guestbook Template&#039;.</li>
			<li>Une feuille de style par d&eacute;faut, d&#039;exemple est install&eacute;e (et d&eacute;sinstall&eacute;e) avec le module.</li>
			<li>Le gabarit par d&eacute;faut de la base de donn&eacute;e peut &ecirc;tre restaur&eacute; .</li>
			<li>Modifi&eacute; en navigation par onglets.</li>
			<li>Nettoyage et r&eacute;&eacute;criture du gabarit par d&eacute;faut de la base de donn&eacute;e et des variables utilis&eacute;es dans celui-ci.</li>
			<li>Traduction de multiples noms de variables et de commentaires de code.</li>
			<li>D&eacute;plac&eacute; des messages admin et log dans le fichier de langue.</li>
			<li>Re-format&eacute; le code source pour une meilleure lecture.</li>
			<li>Le module fonctionne maintenant aussi avec une base de donn&eacute;es PostgreSQL.</li>
			<li>Chang&eacute; le format d&#039;insertion par le param&egrave;tre de format de date du format MySQL au format PHP.</li>
			<li>Une nouvelle variable est assign&eacute;e au gabarit (base de donn&eacute;es) guestbookentry template: $e_mail_cloaked. C&#039;est l&#039;adresse email, avec @ remplac&eacute; par &amp;lt;at&amp;gt; et . par &amp;lt;dot&amp;gt;.</li>
			<li>&Eacute;tendu la notification email, il envoie maintnena tle nouveau message du Livre d&#039;Or dans l&#039;email de notification.</li>
			<li>Nouvelle traduction en finlandais, et mise &agrave; jour des traductions en n&eacute;erlandais et norv&eacute;gien, depuis le centre de traduction.</li>
		</ul>
    </li>
    <li>
		<strong>Version 0.9</strong>
		<ul>
			<li>La partie publique du Livre d&#039;Or utilise maintenant un gabarit disponible dans la base de donn&eacute;es (au lieu de gabarits .tpl) qui peut &ecirc;tre modifi&eacute; depuis le panneau d&#039;administration</li>
			<li>Le param&egrave;tre de format de date est maintenant appel&eacute; dateformat (&eacute;tait dateform). Note: cela signifie que vous devrez recr&eacute;er les pages de contenu Livre d&#039;Or ou &eacute;diter manuellement les tables cms_content et cms_content_props</li>
			<li>Nouvelle traduction fran&ccedil;aise et traductions mises &agrave; jour pour les autres langues depuis le centre de traduction</li>
		</ul>
    </li>
    <li>
		<strong>Version 0.8</strong>
		Fixed:
		<ul>
			<li>corrig&eacute;: les smiley ne fonctionnaient pas toujours dans le contenu du Livre d&#039;Or version 0.7</li>
		</ul>
		Nettoyage:
		<ul>
			<li>principalement suppression de r&eacute;f&eacute;rences inutiles au global $gCms</li>
			<li>renomm&eacute; le champtexte email en e_mail (&eacute;tait appel&eacute; betreff, probablement un vieux champ sujet)</li>
		</ul>
		Am&eacute;liorations:
		<ul>
			<li>la derni&egrave;re entr&eacute;e est affich&eacute;e dans la liste</li>
			<li>les accolades autour du pays de l&#039;utilisateur ne sont plus affich&eacute;es si le pays n&#039;est pas entr&eacute;</li>
			<li>traduction en n&eacute;erlandais (sauf pour l&#039;aide et le changelog)</li>
			<li>le module utilise maintenant les traductions entr&eacute;es dans le centre de traductions  translations.cmsmadesimple.org</li>
		</ul>
		Modifi&eacute;:
		<ul>
			<li>Le nom de la variable pour le pays dans le gabarit showmessage.tpl est maintenant appel&eacute; $country (&eacute;tait $countryshow dans les versions ant&eacute;rieures)</li>
		</ul>
    </li>
    <li>
		<strong>Version 0.7</strong>
		<ul>
			<li>Ajout de l&#039;attribut de langue pour le suppor de variables locales multiples</li>
			<li>Affiche le formulaire d&#039;insertion sur la premi&egrave;re page</li>
			<li>Corrig&eacute; un bug avec textlength le javascript ne fonctionnait pas</li>
			<li>Bugs mineurs corrig&eacute;s</li>
		</ul>
	</li>
	<li>
		<strong>Version 0.6</strong>
		<ul>
			<li>Modification du code source pour une meilleure lecture</li>
			<li>Ajout de l&#039;attribut lang pour g&eacute;rer plusieurs langues</li>
			<li>Ajout du param&egrave;tre showaddform</li>
			<li>Correction du bug avec textlength javascript ne marchant pas dans le cas d&#039;un contenu de type Content</li>
			<li>Fusion des gabarits vorzu et backzu</li>
			<li>Ajout du gabarit success_message.tpl</li>
			<li>Correction de bug mineurs causant des incoh&eacute;rences dans les noms de variables lang</li>
		</ul>
	</li>
	<li>
		<strong>Version 0.5</strong>
		<p>Le Livre d&#039;Or a &eacute;t&eacute; modifi&eacute; avec un meilleur design et de nouvelles fonctionalit&eacute;s, par exemple: 
		Contenu avec gabarit, protection anti-spam pour les mails affich&eacute;s etc...</p>
	</li>
	<li>
		<strong>Version 0.4</strong>
		<p>Le Livre d&#039;Or est maintenant un nouveau module</p>
	</li>
</ul>
<br />]]></about>
	<description><![CDATA[G&eacute;rer les messages du Livre d&#039;Or.]]></description>
	<file>
	  <filename>/</filename>
	  <isdir>1</isdir>
	</file>
	<file>
	  <filename>/action.admin_tab_entries.php</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[<?php

$access = $this->CheckPermission('Modify Guestbook Entries');
if (!$access)
{
	echo $this->ShowError($this->Lang('access_denied'));
	return;
}

// headers/column titles
$headers = array(
	'guestbook' => $this->GetFriendlyName(),
	'id'        => $this->Lang('id'),
	'sender'    => $this->Lang('sender'),
	'e_mail'    => $this->Lang('email'),
	'country'   => $this->Lang('country'),
	'location'  => $this->Lang('location'),
	'homepage'  => $this->Lang('homepage'),
	'message'   => $this->Lang('message'),
	'postdate'  => $this->Lang('postdate'),
	'active'    => $this->Lang('active'),
	'ip'   => $this->Lang('ip_addr')
);
$this->smarty->assign('headers'   , $headers);
$this->smarty->assign('entries_top_template', cms_join_path($this->GetModulePath(), 'templates', 'admin_entries_top.tpl'));

// guestbook entries

// determine selected guestbook
$selected_guestbook = (isset($params['selected_guestbook'])) ? (ctype_digit($params['selected_guestbook']) ? (int) $params['selected_guestbook'] : 'all') : 'all';

$dbhandler =& $this->GetDbHandler();

// show the guestbook selector form
{
	// get available guestbooks from the database
	$guestbooks =& $this->GetAllGuestbooks();
	
	// assign the smarty variables for the guestbook selector template
	$this->smarty->assign('selected_guestbook', $selected_guestbook);
	$this->smarty->assign('guestbooks', $guestbooks);
	$this->smarty->assign('formstart', $this->CreateFormStart($id, 'defaultadmin', $returnid));
	// drop down options
	$select_options = array('all'=> 'all');
	foreach($guestbooks as $guestbook_id => $guestbook)
	{
		$select_options[$guestbook->name] = $guestbook_id;
	}
	$this->smarty->assign('select_guestbook', $this->CreateInputDropdown($id, 'selected_guestbook', $select_options, '', $selected_guestbook));
	$this->smarty->assign('submit_guestbook_selector', $this->CreateInputSubmit($id, 'select_guestbook_submit', lang('submit')));
	$this->smarty->assign('formend', $this->CreateFormEnd());
	
	// assign the guestbook selector template
	$this->smarty->assign('guestbook_selector_template', cms_join_path($this->GetModulePath(), 'templates', 'admin_guestbook_selector.tpl'));
}
// pagination
{
    require_once(cms_join_path($this->getModulePath(), 'lib', 'classes', 'Pagination.class.php'));
	$pag_id = 'GB_id'.$selected_guestbook; // id used for pagination
    $number_of_entries = $this->GetNumberOfEntries(($selected_guestbook == 'all' ? NULL : $selected_guestbook), true);
    $pagination = new Pagination($pag_id, $number_of_entries, $this->GetPreference('admin_entries_per_page'), $pag_id);
	$pagination->setUrl($this->CreateLink($id, 'defaultadmin', $returnid, '', array('selected_guestbook' => $selected_guestbook), '', TRUE));
	$pagination->assignArray($this->smarty);
}
// entries
{	
	$entries =& $this->GetEntries($pagination, $selected_guestbook == 'all' ? NULL : $selected_guestbook, '', TRUE);

	// * create the table rows
	
	// images
	$themeObject  = (isset($gCms->variables['admintheme']) ? $gCms->variables['admintheme'] : '');
	$images = array();
	$images['true']   = $themeObject->DisplayImage('icons/system/true.gif'  , $this->Lang('deakti'), '', '', 'systemicon');
	$images['false']  = $themeObject->DisplayImage('icons/system/false.gif' , $this->Lang('ativi') , '', '', 'systemicon');
	$images['edit']   = $themeObject->DisplayImage('icons/system/edit.gif'  , lang('edit')         , '', '', 'systemicon');
	$images['delete'] = $themeObject->DisplayImage('icons/system/delete.gif', lang('delete')       , '', '', 'systemicon');

	// append rowdata to the entry objects
	foreach($entries as $entry)
	{
		$entry->rowdata = array();
		$entry->rowdata['edit_link'] = $this->CreateLink($id, 'entry-edit', $returnid, $images['edit'], array('entry_id' => $entry->entry_id, 'selected_guestbook' => $selected_guestbook));
		$delconf = lang('deleteconfirm', $entry->entry_id);
		$entry->rowdata['delete_link'] = $this->CreateLink($id, 'entry-delete', $returnid, $images['delete'], array('entry_id' => $entry->entry_id, 'selected_guestbook' => $selected_guestbook), $delconf);
		$entry->rowdata['select_entry_checkbox'] = $this->CreateInputCheckbox($id, 'multi_entry[]', $entry->entry_id, '');
		
		if ($entry->IsActive())
		{
			$entry->rowdata['de_activate_link'] = $this->CreateLink($id, 'entry-deactivate', $returnid, $images['true'] , array('entry_id' => $entry->entry_id, 'selected_guestbook' => $selected_guestbook), $this->Lang('deaktimes'));
		}
		else
		{
			$entry->rowdata['de_activate_link'] = $this->CreateLink($id, 'entry-activate'  , $returnid, $images['false'], array('entry_id' => $entry->entry_id, 'selected_guestbook' => $selected_guestbook), $this->Lang('ativimes'));
		}
		
	}
	$smarty->assign('entries', $entries);
	
	// assign template
	$this->smarty->assign('entry_template', cms_join_path($this->GetModulePath(), 'templates', 'admin_entries_entry.tpl'));
}

// table bottom
{ 
	// admin bottom (new entry link and multi-entry select and submit)

	// Image and link to add a new guestbook entry
	$guestbook = $selected_guestbook == 'all' ? $this->GetPreference('guestbook') : $selected_guestbook;
	$this->smarty->assign(
		'add_entry_link',
		$this->CreateLink(
			$id,
			'entry-add',
			$returnid,
			$gCms->variables['admintheme']->DisplayImage(
				'icons/system/newobject.gif', $this->Lang('addgait'), '', '', 'systemicon'
			),
			array('guestbook' => $guestbook, 'selected_guestbook' => $selected_guestbook),
			'',
			false,
			false,
			''
		) . ' ' . $this->CreateLink(
			$id,
			'entry-add', 
			$returnid,
			$this->Lang('addgait'),
			array('guestbook' => $guestbook, 'selected_guestbook' => $selected_guestbook),
			'', 
			false,
			false,
			'class="pageoptions"'
		)
	);
	
	// Multi select form start
	$this->smarty->assign('multi_formstart', $this->CreateFormStart($id, 'entry-multi', $returnid));
	// Multi select title
	$this->smarty->assign('selected_items_title', lang('selecteditems'));

	// Items for the multi-select action dropdown
	$items = array(
		$this->Lang('ativi')  => 'active',
		$this->Lang('deakti') => 'inactive',
		lang('delete')        => 'delete'
	);
	// Multi-select action dropdown
	$this->smarty->assign('action_dropdown', $this->CreateInputDropDown($id, 'multiaction', $items));

	// Multi-select submit button
	$this->smarty->assign('multi_submit', $this->CreateInputSubmit($id, 'submit', lang('submit')));
	
	$this->smarty->assign('entries_bottom_template', cms_join_path($this->GetModulePath(), 'templates', 'admin_entries_bottom.tpl'));
}
$this->smarty->assign('mod', $this);

// set the tab contents
$tab =& $this->admin->tabs['entries'];
$tpl = cms_join_path($this->GetModulePath(), 'templates', 'admin_tab_entries.tpl');
$tab->SetContent($smarty->fetch($tpl));

?>]]></data>
	</file>
	<file>
	  <filename>/action.admin_tab_guestbooks.php</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[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]]></data>
	</file>
	<file>
	  <filename>/action.admin_tab_settings.php</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[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]]></data>
	</file>
	<file>
	  <filename>/action.admin_tab_templates.php</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[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]]></data>
	</file>
	<file>
	  <filename>/action.admin_template.php</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[PD9waHAKCi8vIG5vIGRpcmVjdCBhY2Nlc3MKaWYgKCFpc3NldCgkZ0NtcykpIAp7CglleGl0KCk7IAp9CgovLyBjaGVjayBsb2dpbgpjaGVja19sb2dpbigpOwoKLy8gY2hlY2sgcGVybWlzc2lvbgppZiAoISR0aGlzLT5DaGVja1Blcm1pc3Npb24oJ01vZGlmeSBHdWVzdGJvb2sgVGVtcGxhdGUnKSkKewogICAgZWNobyAkdGhpcy0+U2hvd0Vycm9yKCR0aGlzLT5MYW5nKCdhY2Nlc3NfZGVuaWVkJykpOwp9CmVsc2UKewoJJGFkbWluID0mICR0aGlzLT5HZXRBZG1pbigkaWQsICRwYXJhbXMsICRyZXR1cm5pZCk7CgkKCSR0ZW1wbGF0ZV9pZCA9IDE7CgkKCS8vIHJlc3RvcmUgdGhlIGRlZmF1bHQgdGVtcGxhdGUgKGFuZCBhZGQgYW4gYWRtaW4gbG9nIG1lc3NhZ2UpCglpZiAoaXNzZXQoJHBhcmFtc1sncmVzdG9yZSddKSkKCXsKCQkkdGhpcy0+U2V0VGVtcGxhdGUoJHBhcmFtc1snZWRpdF90ZW1wbGF0ZSddLCAkdGhpcy0+R2V0R3Vlc3Rib29rSHRtbFRlbXBsYXRlKCRwYXJhbXNbJ2VkaXRfdGVtcGxhdGUnXSkpOwoJCSR0aGlzLT5BdWRpdCgkdGVtcGxhdGVfaWQsICR0aGlzLT5HZXROYW1lKCksICR0aGlzLT5MYW5nKCdhZG1pbl90ZW1wbGF0ZV9yZXN0b3JlZF9sb2dtZXNzYWdlJykpOwoJfQoJCgkvLyBzYXZlIGNoYW5nZXMgYW5kIGxvZyBhY3Rpb24gYWZ0ZXIgc3VibWl0IG9yIGFwcGx5CglpZiAoaXNzZXQoJHBhcmFtc1snc3VibWl0J10pIHx8IGlzc2V0KCRwYXJhbXNbJ2FwcGx5J10pKQoJewoJCSR0aGlzLT5TZXRUZW1wbGF0ZSgkcGFyYW1zWydlZGl0X3RlbXBsYXRlJ10sICRwYXJhbXNbJ3RlbXBsYXRlY29udGVudCddKTsKCQkkdGhpcy0+QXVkaXQoJHRlbXBsYXRlX2lkLCAkdGhpcy0+R2V0TmFtZSgpLCAkdGhpcy0+TGFuZygnYWRtaW5fdGVtcGxhdGVfbW9kaWZpZWRfbG9nbWVzc2FnZScpKTsKCX0KCQoJLy8gcmVkaXJlY3QgdG8gZGVmYXVsdGFkbWluIGFmdGVyIGNhbmNlbCBvciBzdWJtaXQKCWlmIChpc3NldCgkcGFyYW1zWydjYW5jZWwnXSkgfHwgaXNzZXQoJHBhcmFtc1snc3VibWl0J10pKQoJewoJCSR0aGlzLT5SZWRpcmVjdCgkaWQsICdkZWZhdWx0YWRtaW4nLCAkcmV0dXJuaWQsIGFycmF5KCdhY3RpdmVfdGFiJyA9PiAndGVtcGxhdGVzJykpOwoJfQoJLy8gb3RoZXJ3aXNlIChhZnRlciBhcHBseSBvciByZXN0b3JlKSByZWRpcmVjdCB0byBkZWZhdWx0YWRtaW4gd2l0aCBhZG1pbl90ZW1wbGF0ZSBhY3RpdmUgdGFiCgllbHNlCgl7CgkJJHBhcmFtc1snYWN0aXZlX3RhYiddID0gJHBhcmFtc1snYWN0aXZlX3RhYiddOwoJCSR0aGlzLT5SZWRpcmVjdCgkaWQsICdkZWZhdWx0YWRtaW4nLCAnJywgJHBhcmFtcyk7Cgl9CgkkYWRtaW4tPlNob3coJGlkLCAkcGFyYW1zLCAkcmV0dXJuaWQpOwp9Cgo/Pgo=]]></data>
	</file>
	<file>
	  <filename>/action.completeadd.php</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[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]]></data>
	</file>
	<file>
	  <filename>/action.completeedit.php</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[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]]></data>
	</file>
	<file>
	  <filename>/action.default.php</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[PD9waHAKcmVxdWlyZV9vbmNlKGNtc19qb2luX3BhdGgoJHRoaXMtPmdldE1vZHVsZVBhdGgoKSwgJ2xpYicsICdjbGFzc2VzJywgJ1BhZ2luYXRpb24uY2xhc3MucGhwJykpOwoKLy8gbm8gZGlyZWN0IGFjY2VzcwppZiAoIWlzc2V0KCRnQ21zKSkgCnsKCWV4aXQoKTsgCn0KCiRyZXR1cm5pZD0kZ0Ntcy0+dmFyaWFibGVzWydjb250ZW50X2lkJ107CgovLyBzZXQgbW9kdWxlIHBhcmFtZXRlcnMgdG8gcHJlZmVyZW5jZSB2YWx1ZXMgaWYgdGhleSdyZSBub3Qgc2V0Ci8vIFRPRE86IHJlbW92ZSB0aGlzIGFuZCBnZXQgcHJlZmVyZW5jZXMgd2hlcmUgbmVlZGVkCmZvcmVhY2goJHRoaXMtPkdldFBhcmFtZXRlcnMoKSBhcyAkcGFyYW0pCnsKCWlmICgkcGFyYW1bJ25hbWUnXSAhPSAnbGFuZycpCgl7CgkJJHBhcmFtc1skcGFyYW1bJ25hbWUnXV0gPSAhZW1wdHkoJHBhcmFtc1skcGFyYW1bJ25hbWUnXV0pID8gJHBhcmFtc1skcGFyYW1bJ25hbWUnXV0gOiAkdGhpcy0+Z2V0UHJlZmVyZW5jZSgkcGFyYW1bJ25hbWUnXSwkcGFyYW1bJ2RlZmF1bHQnXSk7Cgl9Cn0KCiR0bXA9Jyc7CmZvcmVhY2goJHBhcmFtcyBhcyAka2V5PT4kdmFsdWUpCiR0bXAgLj0gJGtleS4nPScuJHZhbHVlOwokaWQgPSAnbScuc3Vic3RyKG1kNSgkdG1wLiRpZCksNSw1KTsKZm9yZWFjaChHZXRNb2R1bGVQYXJhbWV0ZXJzKCRpZCkgYXMgJGtleSA9PiAkdmFsKXsKICAgIGlmKCFpc3NldCgkcGFyYW1zWyRrZXldKSB8fCAka2V5ID09ICdzaG93YWRkZm9ybScpewogICAgICAgICRwYXJhbXNbJGtleV0gPSAkdmFsOwogICAgfQp9CgovLyBnZXQgYSBmcm9udGVkIG9iamVjdAokZnJvbnRlbmQgPSYgJHRoaXMtPkdldEZyb250ZW5kKCRpZCwgJHBhcmFtcywgJHJldHVybmlkKTsKLy8gZW50cnkgc3VibWl0IHdhcyBjYW5jZWxsZWQKaWYgKGlzc2V0KCRwYXJhbXNbJ2NhbmNlbCddKSkgCnsKCSR0aGlzLT5SZWRpcmVjdENvbnRlbnQoJHJldHVybmlkKTsKfQoKLy8gcHJvY2VzcyBwb3N0IGlmIG5lZWRlZC9zdWJtaXR0ZWQKaWYgKGlzc2V0KCRwYXJhbXNbJ2VudHJ5X3N1Ym1pdHRlZCddKSkKewoJJGZyb250ZW5kLT5Qcm9jZXNzUG9zdCgkaWQsICRwYXJhbXMsICRyZXR1cm5pZCk7Cn0KCi8vIHNob3cgdGhlIGZyb250ZW5kCiRmcm9udGVuZC0+U2hvdygkaWQsICRwYXJhbXMsICRyZXR1cm5pZCk7Cj8+Cg==]]></data>
	</file>
	<file>
	  <filename>/action.defaultadmin.php</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[PD9waHAKCi8vIG5vIGRpcmVjdCBhY2Nlc3MKaWYgKCFpc3NldCgkZ0NtcykpIAp7CglleGl0KCk7IAp9Ci8vIGNoZWNrIGxvZ2luCmNoZWNrX2xvZ2luKCk7CgovLyBvbmx5IGxldCBwZW9wbGUgYWNjZXNzIG1vZHVsZSBwcmVmZXJlbmNlcyBpZiB0aGV5IGhhdmUgcGVybWlzc2lvbgppZiAoJHRoaXMtPlZpc2libGVUb0FkbWluVXNlcigpKQp7CgkkYWRtaW4gPSYgJHRoaXMtPkdldEFkbWluKCRpZCwgJHBhcmFtcywgJHJldHVybmlkKTsKCSRhZG1pbi0+U2hvdygkaWQsICRwYXJhbXMsICRyZXR1cm5pZCk7Cn0KZWxzZQp7CiAgICAkdGhpcy0+U2hvd0Vycm9yKCR0aGlzLT5MYW5nKCdhY2Nlc3NfZGVuaWVkJykpOwp9Cgo/Pg==]]></data>
	</file>
	<file>
	  <filename>/action.entry-activate.php</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[PD9waHAKCi8vIG5vIGRpcmVjdCBhY2Nlc3MKaWYgKCFpc3NldCgkZ0NtcykpIAp7CglleGl0KCk7IAp9Ci8vIGNoZWNrIGxvZ2luCmNoZWNrX2xvZ2luKCk7CgovLyBjaGVjayBwZXJtaXNzaW9uCgovLyB1c2VyIGRvZXNuJ3QgaGF2ZSBzdWZmaWNpZW50IHByaXZpbGVnZXMKaWYgKCEgJHRoaXMtPkNoZWNrUGVybWlzc2lvbignTW9kaWZ5IEd1ZXN0Ym9vayBFbnRyaWVzJykpCnsKICAgIC8vIHNob3cgYW4gZXJyb3IgbWVzc2FnZQogICAgZWNobyAkdGhpcy0+U2hvd0Vycm9yKCR0aGlzLT5MYW5nKCdhY2Nlc3NfZGVuaWVkJykpOwp9Ci8vIHVzZXIgaGFzIHN1ZmZpY2llbnQgcHJpdmlsZWdlcwplbHNlCnsKICAgIC8vIGFjdGl2YXRlIHRoZSBlbnRyeQogICAgJHRoaXMtPkFjdGl2YXRlRW50cnlCeUlkKCRwYXJhbXNbJ2VudHJ5X2lkJ10pOwoKICAgIC8vIGNyZWF0ZSBhbiBlbnRyeSBpbiB0aGUgQ01TTVMgQWRtaW4gTG9nCiAgICAkdGhpcy0+QXVkaXQoCiAgICAgICAgJHBhcmFtc1snZW50cnlfaWQnXSwgCiAgICAgICAgJHRoaXMtPkdldE5hbWUoKSwgCiAgICAgICAgJHRoaXMtPkxhbmcoJ2FkbWluX2VudHJ5X2FjdGl2YXRlZF9sb2dtZXNzYWdlJykKICAgICk7CgogICAgLy8gcmVkaXJlY3QgdGhlIHVzZXIgdG8gdGhlIGRlZmF1bHQgYWRtaW4gc2NyZWVuCiAgICAkdGhpcy0+UmVkaXJlY3QoJGlkLCAnZGVmYXVsdGFkbWluJywgJHJldHVybmlkKTsKfQoKPz4=]]></data>
	</file>
	<file>
	  <filename>/action.entry-add.php</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[PD9waHAKCi8vIG5vIGRpcmVjdCBhY2Nlc3MKaWYgKCFpc3NldCgkZ0NtcykpIAp7CglleGl0KCk7IAp9Ci8vIGNoZWNrIGxvZ2luCmNoZWNrX2xvZ2luKCk7CgppZiAoISAkdGhpcy0+Q2hlY2tQZXJtaXNzaW9uKCdNb2RpZnkgR3Vlc3Rib29rIEVudHJpZXMnKSkKewogICAgZWNobyAkdGhpcy0+U2hvd0Vycm9yKCR0aGlzLT5MYW5nKCdhY2Nlc3NfZGVuaWVkJykpOwp9CmVsc2UKewoJJGFkbWluID0mICR0aGlzLT5HZXRBZG1pbigkaWQsICRwYXJhbXMsICRyZXR1cm5pZCk7CiAgICAkYWRtaW4tPkFkbWluRm9ybSgkaWQsICdjb21wbGV0ZWFkZCcsICRwYXJhbXNbJ2d1ZXN0Ym9vayddKTsKfQoKPz4=]]></data>
	</file>
	<file>
	  <filename>/action.entry-deactivate.php</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[PD9waHAKCi8vIG5vIGRpcmVjdCBhY2Nlc3MKaWYgKCFpc3NldCgkZ0NtcykpIAp7CglleGl0KCk7IAp9Ci8vIGNoZWNrIGxvZ2luCmNoZWNrX2xvZ2luKCk7CgovLyBjaGVjayBwZXJtaXNzaW9uCgovLyB1c2VyIGRvZXNuJ3QgaGF2ZSBzdWZmaWNpZW50IHByaXZpbGVnZXMKaWYgKCEgJHRoaXMtPkNoZWNrUGVybWlzc2lvbignTW9kaWZ5IEd1ZXN0Ym9vayBFbnRyaWVzJykpCnsKICAgIC8vIHNob3cgYW4gZXJyb3IgbWVzc2FnZQogICAgZWNobyAkdGhpcy0+U2hvd0Vycm9yKCR0aGlzLT5MYW5nKCdhY2Nlc3NfZGVuaWVkJykpOwp9Ci8vIHVzZXIgaGFzIHN1ZmZpY2llbnQgcHJpdmlsZWdlcwplbHNlCnsKICAgIC8vIGRlYWN0aXZhdGUgdGhlIGVudHJ5CiAgICAkdGhpcy0+RGVhY3RpdmF0ZUVudHJ5QnlJZCgkcGFyYW1zWydlbnRyeV9pZCddKTsKCiAgICAvLyBjcmVhdGUgYW4gZW50cnkgaW4gdGhlIENNU01TIEFkbWluIExvZwogICAgJHRoaXMtPkF1ZGl0KAogICAgICAgICRwYXJhbXNbJ2VudHJ5X2lkJ10sIAogICAgICAgICR0aGlzLT5HZXROYW1lKCksIAogICAgICAgICR0aGlzLT5MYW5nKCdhZG1pbl9lbnRyeV9kZWFjdGl2YXRlZF9sb2dtZXNzYWdlJykKICAgICk7CgogICAgLy8gcmVkaXJlY3QgdGhlIHVzZXIgdG8gdGhlIGRlZmF1bHQgYWRtaW4gc2NyZWVuCiAgICAkdGhpcy0+UmVkaXJlY3QoJGlkLCAnZGVmYXVsdGFkbWluJywgJHJldHVybmlkKTsKfQoKPz4=]]></data>
	</file>
	<file>
	  <filename>/action.entry-delete.php</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[PD9waHAKCi8vIG5vIGRpcmVjdCBhY2Nlc3MKaWYgKCFpc3NldCgkZ0NtcykpIAp7CglleGl0KCk7IAp9Ci8vIGNoZWNrIGxvZ2luCmNoZWNrX2xvZ2luKCk7CgppZiAoISAkdGhpcy0+Q2hlY2tQZXJtaXNzaW9uKCdNb2RpZnkgR3Vlc3Rib29rIEVudHJpZXMnKSkKewoJZWNobyAkdGhpcy0+U2hvd0Vycm9yKCR0aGlzLT5MYW5nKCdhY2Nlc3NfZGVuaWVkJykpOwp9CmVsc2UKewoJJHRoaXMtPkRlbGV0ZUVudHJ5QnlJZCgkcGFyYW1zWydlbnRyeV9pZCddKTsKCSR0aGlzLT5BdWRpdCgKCQkkcGFyYW1zWydlbnRyeV9pZCddLAoJCSR0aGlzLT5HZXROYW1lKCksCgkJJHRoaXMtPkxhbmcoJ2FkbWluX2VudHJ5X2RlbGV0ZWRfbG9nbWVzc2FnZScpCgkpOwoJJHRoaXMtPlJlZGlyZWN0KCRpZCwgJ2RlZmF1bHRhZG1pbicsICRyZXR1cm5pZCk7Cn0KCj8+Cg==]]></data>
	</file>
	<file>
	  <filename>/action.entry-edit.php</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[PD9waHANCg0KLy8gbm8gZGlyZWN0IGFjY2Vzcw0KaWYgKCFpc3NldCgkZ0NtcykpIA0Kew0KCWV4aXQoKTsgDQp9DQovLyBjaGVjayBsb2dpbg0KY2hlY2tfbG9naW4oKTsNCg0KaWYgKCEgJHRoaXMtPkNoZWNrUGVybWlzc2lvbignTW9kaWZ5IEd1ZXN0Ym9vayBFbnRyaWVzJykpDQp7DQogICAgZWNobyAkdGhpcy0+U2hvd0Vycm9yKCR0aGlzLT5MYW5nKCdhY2Nlc3NfZGVuaWVkJykpOw0KfQ0KZWxzZQ0Kew0KCSRhZG1pbiA9JiAkdGhpcy0+R2V0QWRtaW4oJGlkLCAkcGFyYW1zLCAkcmV0dXJuaWQpOw0KICAgICRlbnRyeSA9ICR0aGlzLT5HZXRFbnRyeUJ5SWQoJHBhcmFtc1snZW50cnlfaWQnXSk7DQoNCiAgICBpZiAoJGVudHJ5KQ0KICAgIHsNCg0KICAgICAgICAkYWRtaW4tPkFkbWluRm9ybSgNCiAgICAgICAgICAgICRpZCwNCiAgICAgICAgICAgICdjb21wbGV0ZWVkaXQnLA0KICAgICAgICAgICAgJGVudHJ5LT5ndWVzdGJvb2tfaWQsDQogICAgICAgICAgICAnJywNCiAgICAgICAgICAgICRlbnRyeS0+c2VuZGVyLT5HZXROYW1lKCksDQogICAgICAgICAgICAkZW50cnktPnNlbmRlci0+R2V0RW1haWwoKSwNCiAgICAgICAgICAgICRlbnRyeS0+c2VuZGVyLT5HZXRIb21lcGFnZSgpLA0KICAgICAgICAgICAgJGVudHJ5LT5HZXRNZXNzYWdlKCksDQogICAgICAgICAgICAkZW50cnktPnNlbmRlci0+R2V0Q291bnRyeSgpLA0KICAgICAgICAgICAgJGVudHJ5LT5zZW5kZXItPkdldExvY2F0aW9uKCksDQogICAgICAgICAgICAkZW50cnktPmVudHJ5X2lkLA0KCQkJJGVudHJ5LT5HZXRUaW1lc3RhbXAoKQ0KICAgICAgICApOw0KICAgIH0NCn0NCg0KPz4=]]></data>
	</file>
	<file>
	  <filename>/action.entry-multi.php</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[PD9waHAKCi8vIG5vIGRpcmVjdCBhY2Nlc3MKaWYgKCFpc3NldCgkZ0NtcykpIAp7CglleGl0KCk7IAp9Ci8vIGNoZWNrIGxvZ2luCmNoZWNrX2xvZ2luKCk7CgovLyBjaGVjayBwZXJtaXNzaW9uCgovLyB1c2VyIGRvZXNuJ3QgaGF2ZSBzdWZmaWNpZW50IHByaXZpbGVnZXMKaWYgKCEgJHRoaXMtPkNoZWNrUGVybWlzc2lvbignTW9kaWZ5IEd1ZXN0Ym9vayBFbnRyaWVzJykpCnsKICAgIC8vIHNob3cgYW4gZXJyb3IgbWVzc2FnZQogICAgZWNobyAkdGhpcy0+U2hvd0Vycm9yKCR0aGlzLT5MYW5nKCdhY2Nlc3NfZGVuaWVkJykpOwp9Ci8vIHVzZXIgaGFzIHN1ZmZpY2llbnQgcHJpdmlsZWdlcwplbHNlCnsKCWlmIChpc3NldCgkcGFyYW1zWydtdWx0aV9lbnRyeSddKSkKCXsKCQlmb3JlYWNoICgkcGFyYW1zWydtdWx0aV9lbnRyeSddIGFzICRpbmRleCA9PiAkZW50cnlfaWQpCgkJewoJCQlzd2l0Y2ggKCRwYXJhbXNbJ211bHRpYWN0aW9uJ10pCgkJCXsKCQkJCWNhc2UgJ2RlbGV0ZSc6CgkJCQl7CgkJCQkJLy8gZGVsZXRlIHRoZSBlbnRyeQoJCQkJCSR0aGlzLT5EZWxldGVFbnRyeUJ5SWQoJGVudHJ5X2lkKTsKCQkJCQkKCQkJCQkvLyBjcmVhdGUgYW4gZW50cnkgaW4gdGhlIENNU01TIEFkbWluIExvZwoJCQkJCSR0aGlzLT5BdWRpdCgKCQkJCQkJJGVudHJ5X2lkLAoJCQkJCQkkdGhpcy0+R2V0TmFtZSgpLAoJCQkJCQkkdGhpcy0+TGFuZygnYWRtaW5fZW50cnlfZGVsZXRlZF9sb2dtZXNzYWdlJykKCQkJCQkpOwoJCQkJfQoJCQkJYnJlYWs7CgkJCQljYXNlICdhY3RpdmUnOgoJCQkJewoJCQkJCS8vIGFjdGl2YXRlIHRoZSBlbnRyeQoJCQkJCSR0aGlzLT5BY3RpdmF0ZUVudHJ5QnlpZCgkZW50cnlfaWQpOwoJCQkJCQoJCQkJCS8vIGNyZWF0ZSBhbiBlbnRyeSBpbiB0aGUgQ01TTVMgQWRtaW4gTG9nCgkJCQkJJHRoaXMtPkF1ZGl0KAoJCQkJCQkkZW50cnlfaWQsIAoJCQkJCQkkdGhpcy0+R2V0TmFtZSgpLCAKCQkJCQkJJHRoaXMtPkxhbmcoJ2FkbWluX2VudHJ5X2FjdGl2YXRlZF9sb2dtZXNzYWdlJykKCQkJCQkpOwoJCQkJfQoJCQkJYnJlYWs7CgkJCQljYXNlICdpbmFjdGl2ZSc6CgkJCQl7CgkJCQkJLy8gZGVhY3RpdmF0ZSB0aGUgZW50cnkKCQkJCQkkdGhpcy0+RGVhY3RpdmF0ZUVudHJ5QnlpZCgkZW50cnlfaWQpOwoJCQkJCQoJCQkJCS8vIGNyZWF0ZSBhbiBlbnRyeSBpbiB0aGUgQ01TTVMgQWRtaW4gTG9nCgkJCQkJJHRoaXMtPkF1ZGl0KAoJCQkJCQkkZW50cnlfaWQsCgkJCQkJCSR0aGlzLT5HZXROYW1lKCksCgkJCQkJCSR0aGlzLT5MYW5nKCdhZG1pbl9lbnRyeV9kZWFjdGl2YXRlZF9sb2dtZXNzYWdlJykKCQkJCQkpOwoJCQkJfQoJCQkJYnJlYWs7CgkJCX0KCQl9Cgl9CgoJLy8gcmVkaXJlY3QgdGhlIHVzZXIgdG8gdGhlIGRlZmF1bHQgYWRtaW4gc2NyZWVuCgkkdGhpcy0+UmVkaXJlY3QoJGlkLCAnZGVmYXVsdGFkbWluJywgJHJldHVybmlkKTsKfQoKPz4K]]></data>
	</file>
	<file>
	  <filename>/action.guestbook-activate.php</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[PD9waHAKCi8vIG5vIGRpcmVjdCBhY2Nlc3MKaWYgKCFpc3NldCgkZ0NtcykpIAp7CglleGl0KCk7IAp9Ci8vIGNoZWNrIGxvZ2luCmNoZWNrX2xvZ2luKCk7CgovLyBjaGVjayBwZXJtaXNzaW9uCgovLyB1c2VyIGRvZXNuJ3QgaGF2ZSBzdWZmaWNpZW50IHByaXZpbGVnZXMKaWYgKCEgJHRoaXMtPkNoZWNrUGVybWlzc2lvbignTW9kaWZ5IEd1ZXN0Ym9vayBFbnRyaWVzJykpCnsKICAgIC8vIHNob3cgYW4gZXJyb3IgbWVzc2FnZQogICAgZWNobyAkdGhpcy0+U2hvd0Vycm9yKCR0aGlzLT5MYW5nKCdhY2Nlc3NfZGVuaWVkJykpOwogICAgcmV0dXJuOwp9CgovLyBhY3RpdmF0ZSB0aGUgZ3Vlc3Rib29rCmlmIChpc3NldCgkcGFyYW1zWydndWVzdGJvb2tfaWQnXSkgJiYgJHBhcmFtc1snZ3Vlc3Rib29rX2lkJ10gIT0gJycpCnsKCSRkYmhhbmRsZXIgPSYgJHRoaXMtPkdldERiSGFuZGxlcigpOwoJJHJlc3VsdCA9ICRkYmhhbmRsZXItPkFjdGl2YXRlR3Vlc3Rib29rQnlJZCgkcGFyYW1zWydndWVzdGJvb2tfaWQnXSk7Cn0KCi8vIHJlZGlyZWN0IHRoZSB1c2VyIHRvIHRoZSBkZWZhdWx0IGFkbWluIHNjcmVlbgokdGhpcy0+UmVkaXJlY3QoJGlkLCAnZGVmYXVsdGFkbWluJywgJHJldHVybmlkLCBhcnJheSgnYWN0aXZlX3RhYicgPT4gJ2d1ZXN0Ym9va3MnKSk7Cgo/Pgo=]]></data>
	</file>
	<file>
	  <filename>/action.guestbook-add.php</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[PD9waHAKCi8vIG5vIGRpcmVjdCBhY2Nlc3MKaWYgKCFpc3NldCgkZ0NtcykpIAp7CglleGl0KCk7IAp9Ci8vIGNoZWNrIGxvZ2luCmNoZWNrX2xvZ2luKCk7CgovLyBjaGVjayBwZXJtaXNzaW9uCgovLyB1c2VyIGRvZXNuJ3QgaGF2ZSBzdWZmaWNpZW50IHByaXZpbGVnZXMKaWYgKCEgJHRoaXMtPkNoZWNrUGVybWlzc2lvbignTW9kaWZ5IEd1ZXN0Ym9vayBFbnRyaWVzJykpCnsKICAgIC8vIHNob3cgYW4gZXJyb3IgbWVzc2FnZQogICAgZWNobyAkdGhpcy0+U2hvd0Vycm9yKCR0aGlzLT5MYW5nKCdhY2Nlc3NfZGVuaWVkJykpOwogICAgcmV0dXJuOwp9CgokYWRtaW4gPSYgJHRoaXMtPkdldEFkbWluKCRpZCwgJHBhcmFtcywgJHJldHVybmlkKTsKJGFkbWluLT5TZXRBY3RpdmVUYWIoJ2d1ZXN0Ym9va3MnKTsKCmlmIChpc3NldCgkcGFyYW1zWydjYW5jZWxfZ3Vlc3Rib29rX2FkZCddKSkKewoJJGFkbWluLT5TaG93KCRpZCwgJHBhcmFtcywgJHJldHVybmlkKTsKCXJldHVybjsKfQoKaWYgKGlzc2V0KCRwYXJhbXNbJ3N1Ym1pdF9ndWVzdGJvb2tfYWRkJ10pKQp7CglyZXF1aXJlX29uY2UoY21zX2pvaW5fcGF0aCgkdGhpcy0+R2V0TW9kdWxlUGF0aCgpLCAnbGliJywgJ2NsYXNzZXMnLCAnbW9kdWxlJywgJ2NsYXNzLkd1ZXN0Ym9va0d1ZXN0Ym9vay5waHAnKSk7CgkkZ3Vlc3Rib29rID0gbmV3IEd1ZXN0Ym9va0d1ZXN0Ym9vaygkcGFyYW1zWydndWVzdGJvb2tfbmFtZSddLCAkcGFyYW1zWydndWVzdGJvb2tfZGVzY3JpcHRpb24nXSwgJHBhcmFtc1snZ3Vlc3Rib29rX2FjdGl2ZSddID09ICcxJyA/IHRydWUgOiBmYWxzZSk7CgkkcmVzdWx0ID0gJHRoaXMtPmRiaGFuZGxlci0+SW5zZXJ0R3Vlc3Rib29rKCRndWVzdGJvb2spOwoJaWYgKCRyZXN1bHQgJiYgJHJlc3VsdC0+UmVjb3JkQ291bnQoKSA+IDApCgl7CgkJJGFkbWluLT5BZGRNZXNzYWdlKCR0aGlzLT5MYW5nKCdndWVzdGJvb2tfYWRkZWQnKSk7Cgl9CgkkYWRtaW4tPlNob3coJGlkLCAkcGFyYW1zLCAkcmV0dXJuaWQpOwoJcmV0dXJuOwp9Cgokc21hcnR5LT5hc3NpZ24oJ2Zvcm1zdGFydCcsICR0aGlzLT5DcmVhdGVGb3JtU3RhcnQoJGlkLCAnZ3Vlc3Rib29rLWFkZCcpKTsKCiRzbWFydHktPmFzc2lnbigndGl0bGUnLCAkdGhpcy0+TGFuZygnYWRkaW5nX2d1ZXN0Ym9vaycpKTsKJHNtYXJ0eS0+YXNzaWduKCduYW1lX3RpdGxlJywgJHRoaXMtPkxhbmcoJ2luYW0nKSk7CiRzbWFydHktPmFzc2lnbignbmFtZScsICR0aGlzLT5DcmVhdGVJbnB1dFRleHQoJGlkLCAnZ3Vlc3Rib29rX25hbWUnLCAnJywgJzI0JywgJzI1NScsICcnKSk7CiRzbWFydHktPmFzc2lnbignZGVzY3JpcHRpb25fdGl0bGUnLCAkdGhpcy0+TGFuZygnZGVzY3JpcHRpb24nKSk7CiRzbWFydHktPmFzc2lnbignZGVzY3JpcHRpb24nLCAkdGhpcy0+Q3JlYXRlSW5wdXRUZXh0KCRpZCwgJ2d1ZXN0Ym9va19kZXNjcmlwdGlvbicsICcnLCAnNDgnLCAnMjU1JywgJycpKTsKJHNtYXJ0eS0+YXNzaWduKCdhY3RpdmVfdGl0bGUnLCBMYW5nKCdhY3RpdmUnKSk7CiRzbWFydHktPmFzc2lnbignYWN0aXZlJywgJHRoaXMtPkNyZWF0ZUlucHV0UmFkaW9Hcm91cCgkaWQsICdndWVzdGJvb2tfYWN0aXZlJywgYXJyYXkoTGFuZygndHJ1ZScpID0+IDEsIExhbmcoJ2ZhbHNlJykgPT4gMCksIDEsICcnLCAnJm5ic3A7JykpOwokc21hcnR5LT5hc3NpZ24oJ3N1Ym1pdCcsICR0aGlzLT5DcmVhdGVJbnB1dFN1Ym1pdCgkaWQsICdzdWJtaXRfZ3Vlc3Rib29rX2FkZCcsIGxhbmcoJ2FkZCcpKSk7CiRzbWFydHktPmFzc2lnbignY2FuY2VsJywgJHRoaXMtPkNyZWF0ZUlucHV0U3VibWl0KCRpZCwgJ2NhbmNlbF9ndWVzdGJvb2tfYWRkJywgbGFuZygnY2FuY2VsJykpKTsKCiRzbWFydHktPmFzc2lnbignZm9ybWVuZCcsICR0aGlzLT5DcmVhdGVGb3JtRW5kKCkpOwoKLy8gc2V0IHRoZSB0YWIgY29udGVudHMKJHRhYiA9JiAkYWRtaW4tPnRhYnNbJ2d1ZXN0Ym9va3MnXTsKCmluY2x1ZGUoY21zX2pvaW5fcGF0aCgkdGhpcy0+R2V0TW9kdWxlUGF0aCgpLCAnYWN0aW9uLmFkbWluX3RhYl9ndWVzdGJvb2tzLnBocCcpKTsKJHRhYi0+U2V0Q29udGVudCgkdGhpcy0+UHJvY2Vzc1RlbXBsYXRlKCdhZG1pbl9ndWVzdGJvb2tzX2FkZF9lZGl0LnRwbCcpLiR0YWItPmNvbnRlbnQpOwoKLy8gc2hvdyB0aGUgYWRtaW4KJGFkbWluLT5TaG93KCRpZCwgJHBhcmFtcywgJHJldHVybmlkKTsKCj8+Cg==]]></data>
	</file>
	<file>
	  <filename>/action.guestbook-deactivate.php</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[PD9waHAKCi8vIG5vIGRpcmVjdCBhY2Nlc3MKaWYgKCFpc3NldCgkZ0NtcykpIAp7CglleGl0KCk7IAp9Ci8vIGNoZWNrIGxvZ2luCmNoZWNrX2xvZ2luKCk7CgovLyBjaGVjayBwZXJtaXNzaW9uCgovLyB1c2VyIGRvZXNuJ3QgaGF2ZSBzdWZmaWNpZW50IHByaXZpbGVnZXMKaWYgKCEgJHRoaXMtPkNoZWNrUGVybWlzc2lvbignTW9kaWZ5IEd1ZXN0Ym9vayBFbnRyaWVzJykpCnsKICAgIC8vIHNob3cgYW4gZXJyb3IgbWVzc2FnZQogICAgZWNobyAkdGhpcy0+U2hvd0Vycm9yKCR0aGlzLT5MYW5nKCdhY2Nlc3NfZGVuaWVkJykpOwogICAgcmV0dXJuOwp9CgovLyBkZS1hY3RpdmF0ZSB0aGUgZ3Vlc3Rib29rCmlmIChpc3NldCgkcGFyYW1zWydndWVzdGJvb2tfaWQnXSkgJiYgJHBhcmFtc1snZ3Vlc3Rib29rX2lkJ10gIT0gJycpCnsKCSRkYmhhbmRsZXIgPSYgJHRoaXMtPkdldERiSGFuZGxlcigpOwoJJHJlc3VsdCA9ICRkYmhhbmRsZXItPkRlYWN0aXZhdGVHdWVzdGJvb2tCeUlkKCRwYXJhbXNbJ2d1ZXN0Ym9va19pZCddKTsKfQoKLy8gcmVkaXJlY3QgdGhlIHVzZXIgdG8gdGhlIGRlZmF1bHQgYWRtaW4gc2NyZWVuCiR0aGlzLT5SZWRpcmVjdCgkaWQsICdkZWZhdWx0YWRtaW4nLCAkcmV0dXJuaWQsIGFycmF5KCdhY3RpdmVfdGFiJyA9PiAnZ3Vlc3Rib29rcycpKTsKCj8+Cg==]]></data>
	</file>
	<file>
	  <filename>/action.guestbook-delete.php</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[PD9waHAKCi8vIG5vIGRpcmVjdCBhY2Nlc3MKaWYgKCFpc3NldCgkZ0NtcykpIAp7CglleGl0KCk7IAp9Ci8vIGNoZWNrIGxvZ2luCmNoZWNrX2xvZ2luKCk7CgovLyBjaGVjayBwZXJtaXNzaW9uCgovLyB1c2VyIGRvZXNuJ3QgaGF2ZSBzdWZmaWNpZW50IHByaXZpbGVnZXMKaWYgKCEgJHRoaXMtPkNoZWNrUGVybWlzc2lvbignTW9kaWZ5IEd1ZXN0Ym9vayBFbnRyaWVzJykpCnsKICAgIC8vIHNob3cgYW4gZXJyb3IgbWVzc2FnZQogICAgZWNobyAkdGhpcy0+U2hvd0Vycm9yKCR0aGlzLT5MYW5nKCdhY2Nlc3NfZGVuaWVkJykpOwogICAgcmV0dXJuOwp9CgovLyBkZWxldGUgdGhlIGd1ZXN0Ym9vawppZiAoaXNzZXQoJHBhcmFtc1snZ3Vlc3Rib29rX2lkJ10pICYmICRwYXJhbXNbJ2d1ZXN0Ym9va19pZCddICE9ICcnKQp7CgkkYWRtaW4gPSYgJHRoaXMtPkdldEFkbWluKCRpZCwgJHBhcmFtcywgJHJldHVybmlkKTsKCSRhZG1pbi0+RGVsZXRlR3Vlc3Rib29rQnlJZCgkcGFyYW1zWydndWVzdGJvb2tfaWQnXSk7Cn0KCi8vIHJlZGlyZWN0IHRoZSB1c2VyIHRvIHRoZSBkZWZhdWx0IGFkbWluIHNjcmVlbgokdGhpcy0+UmVkaXJlY3QoJGlkLCAnZGVmYXVsdGFkbWluJywgJHJldHVybmlkLCBhcnJheSgnYWN0aXZlX3RhYicgPT4gJ2d1ZXN0Ym9va3MnKSk7Cgo/Pgo=]]></data>
	</file>
	<file>
	  <filename>/action.guestbook-edit.php</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[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]]></data>
	</file>
	<file>
	  <filename>/action.guestbook-multi.php</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[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]]></data>
	</file>
	<file>
	  <filename>/action.guestbook-set-default.php</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[PD9waHAKCi8vIG5vIGRpcmVjdCBhY2Nlc3MKaWYgKCFpc3NldCgkZ0NtcykpIAp7CglleGl0KCk7IAp9Ci8vIGNoZWNrIGxvZ2luCmNoZWNrX2xvZ2luKCk7CgovLyBjaGVjayBwZXJtaXNzaW9uCgovLyB1c2VyIGRvZXNuJ3QgaGF2ZSBzdWZmaWNpZW50IHByaXZpbGVnZXMKaWYgKCEgJHRoaXMtPkNoZWNrUGVybWlzc2lvbignTW9kaWZ5IEd1ZXN0Ym9vayBFbnRyaWVzJykpCnsKICAgIC8vIHNob3cgYW4gZXJyb3IgbWVzc2FnZQogICAgZWNobyAkdGhpcy0+U2hvd0Vycm9yKCR0aGlzLT5MYW5nKCdhY2Nlc3NfZGVuaWVkJykpOwogICAgcmV0dXJuOwp9CgppZiAoaXNzZXQoJHBhcmFtc1snZ3Vlc3Rib29rX2lkJ10pICYmICRwYXJhbXNbJ2d1ZXN0Ym9va19pZCddICE9ICcnKQp7CgkkdGhpcy0+U2V0UHJlZmVyZW5jZSgnZ3Vlc3Rib29rJywgJHBhcmFtc1snZ3Vlc3Rib29rX2lkJ10pOwp9Ci8vIHJlZGlyZWN0IHRoZSB1c2VyIHRvIHRoZSBkZWZhdWx0IGFkbWluIHNjcmVlbgokdGhpcy0+UmVkaXJlY3QoJGlkLCAnZGVmYXVsdGFkbWluJywgJHJldHVybmlkLCBhcnJheSgnYWN0aXZlX3RhYicgPT4gJ2d1ZXN0Ym9va3MnKSk7CgoKPz4K]]></data>
	</file>
	<file>
	  <filename>/action.save_settings.php</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[PD9waHAKCi8vIG5vIGRpcmVjdCBhY2Nlc3MKaWYgKCFpc3NldCgkZ0NtcykpIAp7CglleGl0KCk7IAp9CgovLyBjaGVjayBsb2dpbgpjaGVja19sb2dpbigpOwoKJHRoaXMtPlNldFByZWZlcmVuY2UoJ3NlYXJjaHNtaWxleXMnLCBpc3NldCgkcGFyYW1zWydzZWFyY2hzbWlsZXlzJ10pID8gMSA6IDApOwokdGhpcy0+U2V0UHJlZmVyZW5jZSgnd3lzaXd5ZycsIGlzc2V0KCRwYXJhbXNbJ3d5c2l3eWcnXSkgPyAxIDogMCk7CgokdGhpcy0+U2V0UHJlZmVyZW5jZSgnYmFkd29yZHMnLCAkcGFyYW1zWydiYWR3b3JkcyddKTsKJHRoaXMtPlNldFByZWZlcmVuY2UoJ2JhZHdvcmRzX3JlcGxhY2VtZW50JywgaHRtbHNwZWNpYWxjaGFycygkcGFyYW1zWydiYWR3b3Jkc19yZXBsYWNlbWVudCddKSk7CiR0aGlzLT5TZXRQcmVmZXJlbmNlKCdhZG1pbl9lbnRyaWVzX3Blcl9wYWdlJywgJHBhcmFtc1snYWRtaW5fZW50cmllc19wZXJfcGFnZSddKTsKJHBhcmFtc1snYWN0aXZlX3RhYiddID0gJ3NldHRpbmdzJzsKCiRhZG1pbiA9JiAkdGhpcy0+R2V0QWRtaW4oJGlkLCAkcGFyYW1zLCAkcmV0dXJuaWQpOwokYWRtaW4tPmFkZE1lc3NhZ2UoJHRoaXMtPkxhbmcoJ3NldHRpbmdzX3NhdmVkJykpOwoKJGFkbWluLT5TaG93KCRpZCwgJHBhcmFtcywgJHJldHVybmlkKTsKCj8+]]></data>
	</file>
	<file>
	  <filename>/action.show-entry.php</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[PD9waHAKCi8vIG5vIGRpcmVjdCBhY2Nlc3MKaWYgKCFpc3NldCgkZ0NtcykpIAp7CglleGl0KCk7IAp9CgokZnJvbnRlbmQgPSYgJHRoaXMtPkdldEZyb250ZW5kKCRpZCwgJHBhcmFtcywgJHJldHVybmlkKTsKCmlmICghaXNzZXQoJHBhcmFtc1snc2hvd19lbnRyeSddKSkKewoJZWNobyAkdGhpcy0+TGFuZygnZXJyX25vX2VudHJ5X2lkJyk7CglyZXR1cm47Cn0KCiRlbnRyeSA9ICR0aGlzLT5HZXRFbnRyeUJ5SWQoJHBhcmFtc1snc2hvd19lbnRyeSddKTsKaWYgKCFpc3NldCgkZW50cnkpKQp7CgllY2hvICR0aGlzLT5MYW5nKCdlcnJfZW50cnlfbm90X2ZvdW5kJywgJHBhcmFtc1snc2hvd19lbnRyeSddKTsKCXJldHVybjsKfQoKJGRhdGVmb3JtYXQgPSBpc3NldCgkcGFyYW1zWydkYXRlZm9ybWF0J10pID8gJHBhcmFtc1snZGF0ZWZvcm1hdCddIDogJ2QtbS1ZJzsKJHVuaXhfdGltZSA9IHN0cnRvdGltZSgkZW50cnktPkdldFRpbWVzdGFtcCgpKTsKJGVudHJ5LT5kYXRlID0gZGF0ZSgkZGF0ZWZvcm1hdCwgJHVuaXhfdGltZSk7CiRlbnRyeS0+dGltZSA9IGRhdGUoIkg6aSIsICR1bml4X3RpbWUpOwokZW50cnktPnNlbmRlci0+ZV9tYWlsX2Nsb2FrZWQgPSBzdHJfcmVwbGFjZSgnLicsICcgPGRvdD4gJywgc3RyX3JlcGxhY2UoJ0AnLCAnIDxhdD4gJywgJGVudHJ5LT5zZW5kZXItPkdldEVtYWlsKCkpKTsKCmlmICgkZnJvbnRlbmQtPmdldFNob3dTbWlsZXlzKCkpCnsKCSRzbWlsZXlfaGFuZGxlciA9JiAkdGhpcy0+R2V0U21pbGV5SGFuZGxlcigpOwoJJGVudHJ5LT5TZXRNZXNzYWdlKCRzbWlsZXlfaGFuZGxlci0+SW5zZXJ0U21pbGV5cygkZW50cnktPkdldE1lc3NhZ2UoKSkpOwp9CgokZW50cnktPlNldE1lc3NhZ2UobmwyYnIoJGVudHJ5LT5HZXRNZXNzYWdlKCkpKTsKCiR0aGlzLT5zbWFydHktPmFzc2lnbignZW50cnknLCAkZW50cnkpOwoJCi8qIGFzc2lnbiB0aXRsZXMgKi8KJHRpdGxlc1snZGF0ZSddICAgICAgPSAkdGhpcy0+TGFuZygnc2RhdGUnKTsKJHRpdGxlc1sndGltZV9ob3VyJ10gPSAkdGhpcy0+TGFuZygndWhyJyk7CiR0aXRsZXNbJ3NlbmRlciddICAgID0gJHRoaXMtPkxhbmcoJ2luYW0nKTsKJHRpdGxlc1snY291bnRyeSddICAgPSAkdGhpcy0+TGFuZygnY291bnRyeScpOwokdGl0bGVzWydsb2NhdGlvbiddICA9ICR0aGlzLT5MYW5nKCdsb2NhdGlvbicpOwokdGl0bGVzWydlX21haWwnXSAgICA9ICR0aGlzLT5MYW5nKCdlbWFpbCcpOwokdGl0bGVzWydob21lcGFnZSddICA9ICR0aGlzLT5MYW5nKCdob21lcGFnZScpOwokdGl0bGVzWydtZXNzYWdlJ10gICA9ICR0aGlzLT5MYW5nKCdzbWVzc2FnZScpOwokdGl0bGVzWydiYWNrJ10gICAgICA9ICR0aGlzLT5MYW5nKCdtc2dfYmFjaycpOwokdGhpcy0+c21hcnR5LT5hc3NpZ24oJ3RpdGxlcycgICwgJHRpdGxlcyk7CgplY2hvICR0aGlzLT5Qcm9jZXNzVGVtcGxhdGVGcm9tRGF0YWJhc2UoJ2d1ZXN0Ym9vay1lbnRyeScpOwoKPz4K]]></data>
	</file>
	<file>
	  <filename>/css/</filename>
	  <isdir>1</isdir>
	</file>
	<file>
	  <filename>/css/index.html</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[]]></data>
	</file>
	<file>
	  <filename>/css/stylesheet.css</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[LyogU3R5bGUgcGFnaW5hdGlvbiAqLwoKLmNtcy1ndWVzdGJvb2stcGFnaW5hdGlvbl9oZWFkZXIgewoJbWFyZ2luOiAuNWVtIDA7Cn0KLmNtcy1ndWVzdGJvb2stcGFnaW5hdGlvbl9uYXYgewoJZm9udC13ZWlnaHQ6IGJvbGQ7CgltYXJnaW46IC41ZW0gMDsKfQouY21zLWd1ZXN0Ym9vay1wYWdpbmF0aW9uX25hdiBhIHsKICAgIGZvbnQtd2VpZ2h0OiBub3JtYWw7Cn0KCi8qIFN0eWxlIHRoZSBndWVzdGJvb2sgKi8KCi8qIFN0eWxlIGVhY2ggZW50cnkgKi8KLmNtcy1ndWVzdGJvb2stZW50cnkKewoJYm9yZGVyOiAxcHggc29saWQgIzA2OTsKCW1hcmdpbi1ib3R0b206IDFlbTsKfQoKLyogU3R5bGUgdGhlIG1lc3NhZ2UgaGVhZGVyICovCi5jbXMtZ3Vlc3Rib29rLWVudHJ5LWhlYWRlcgp7CgliYWNrZ3JvdW5kOiAjMzg1QzcyOwoJY29sb3I6IHdoaXRlOwoJYm9yZGVyOiAxcHggc29saWQgYmxhY2s7CgltYXJnaW46IDFweDsKfQoKLyogU3R5bGUgdGhlIGFjdHVhbCBtZXNzYWdlICovCi5jbXMtZ3Vlc3Rib29rLWVudHJ5LXRleHQgCnsKCWJhY2tncm91bmQ6ICNlZWU7CglwYWRkaW5nOiAuNWVtOwoJY29sb3I6IGJsYWNrOwp9CgovKiBTaG93IHRoZSBwb3N0ZGF0ZSBvbiB0aGUgcmlnaHQgKi8KLmNtcy1ndWVzdGJvb2stZW50cnktcG9zdGVkIAp7CglmbG9hdDogcmlnaHQ7Cglmb250LXNpemU6IHNtYWxsZXI7Cn0KCi8qIFN0eWxlIG1lc3NhZ2UgaGVhZGVyIGxpbmtzICovCi5jbXMtZ3Vlc3Rib29rLWVudHJ5LWhlYWRlciBhIHsKCWNvbG9yOiB3aGl0ZTsKfSAKLmNtcy1ndWVzdGJvb2stZW50cnktaGVhZGVyIGE6aG92ZXIgewoJY29sb3I6IGJsYWNrOwp9IAoJCSAgCi8qIFN0eWxlIHRoZSBzZW5kZXIgbmFtZSAqLwouY21zLWd1ZXN0Ym9vay1lbnRyeS1zZW5kZXJuYW1lCnsKCWZvbnQtd2VpZ2h0OiBib2xkOwp9CgovKiBTdHlsZSB0aGUgRS1tYWlsIGxpbmsgKi8KLmNtcy1ndWVzdGJvb2stZW50cnktZW1haWwgewoJZm9udC1zaXplOiBzbWFsbGVyOwp9CgkJICAgICAgCi8qIFN0eWxlIHRoZSBzZW5kZXJzIGhvbWVwYWdlIGxpbmsgKi8KLmNtcy1ndWVzdGJvb2stZW50cnktaG9tZXBhZ2UKewoJZm9udC1zaXplOiBzbWFsbGVyOwoJbWFyZ2luOiAycHg7CgltYXJnaW4tYm90dG9tOiAwOwp9CgovKiBTdHlsZSB0aGUgc21pbGV5cyBsaW5rcyAqLwouY21zLWd1ZXN0Ym9vay1zb21lc21pbGV5cyBhCnsKCW1hcmdpbi1yaWdodDogLjVlbTsKfQoKLyogU3R5bGUgdGhlIGVudHJ5IGZvcm0gKi8KLmNtcy1ndWVzdGJvb2stZGl2LWluc2VydCBsYWJlbAp7CglmbG9hdDogbGVmdDsKCXdpZHRoOiAxMmVtOwp9CgovKiBTdHlsZSB0aGUgZW50cnkgZm9ybSBmaWVsZHNldCAqLwouY21zLWd1ZXN0Ym9vay1kaXYtaW5zZXJ0IGZpZWxkc2V0IHsKICAgICAgIGJvcmRlcjogbm9uZTsKfQ==]]></data>
	</file>
	<file>
	  <filename>/fckconfig.js.php</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[LyoKICogRkNLZWRpdG9yIC0gVGhlIHRleHQgZWRpdG9yIGZvciBpbnRlcm5ldAogKiBDb3B5cmlnaHQgKEMpIDIwMDMtMjAwNiBGcmVkZXJpY28gQ2FsZGVpcmEgS25hYmJlbgogKiAKICogTGljZW5zZWQgdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBHTlUgTGVzc2VyIEdlbmVyYWwgUHVibGljIExpY2Vuc2U6CiAqIAkJaHR0cDovL3d3dy5vcGVuc291cmNlLm9yZy9saWNlbnNlcy9sZ3BsLWxpY2Vuc2UucGhwCiAqIAogKiBGb3IgZnVydGhlciBpbmZvcm1hdGlvbiB2aXNpdDoKICogCQlodHRwOi8vd3d3LmZja2VkaXRvci5uZXQvCiAqIAogKiAiU3VwcG9ydCBPcGVuIFNvdXJjZSBzb2Z0d2FyZS4gV2hhdCBhYm91dCBhIGRvbmF0aW9uIHRvZGF5PyIKICogCiAqIEZpbGUgTmFtZTogZmNrY29uZmlnLmpzCiAqIAlFZGl0b3IgY29uZmlndXJhdGlvbiBzZXR0aW5ncy4KICogCQogKiAJRm9sbG93IHRoaXMgbGluayBmb3IgbW9yZSBpbmZvcm1hdGlvbjoKICogCWh0dHA6Ly93aWtpLmZja2VkaXRvci5uZXQvRGV2ZWxvcGVyJTI3c19HdWlkZS9Db25maWd1cmF0aW9uL0NvbmZpZ3VyYXRpb25zX1NldHRpbmdzCiAqIAogKiBGaWxlIEF1dGhvcnM6CiAqIAkJRnJlZGVyaWNvIENhbGRlaXJhIEtuYWJiZW4gKGZyZWRja0BmY2tlZGl0b3IubmV0KQogKi8KCgovKgpGQ0tDb25maWcuVG9vbGJhclNldHNbIkRlZmF1bHQiXSA9IFsKCVsnU291cmNlJywnRG9jUHJvcHMnLCctJywnU2F2ZScsJ05ld1BhZ2UnLCdQcmV2aWV3JywnLScsJ1RlbXBsYXRlcyddLAoJWydDdXQnLCdDb3B5JywnUGFzdGUnLCdQYXN0ZVRleHQnLCdQYXN0ZVdvcmQnLCctJywnUHJpbnQnLCdTcGVsbENoZWNrJ10sCglbJ1VuZG8nLCdSZWRvJywnLScsJ0ZpbmQnLCdSZXBsYWNlJywnLScsJ1NlbGVjdEFsbCcsJ1JlbW92ZUZvcm1hdCddLAoJWydGb3JtJywnQ2hlY2tib3gnLCdSYWRpbycsJ1RleHRGaWVsZCcsJ1RleHRhcmVhJywnU2VsZWN0JywnQnV0dG9uJywnSW1hZ2VCdXR0b24nLCdIaWRkZW5GaWVsZCddLAoJJy8nLAoJWydCb2xkJywnSXRhbGljJywnVW5kZXJsaW5lJywnU3RyaWtlVGhyb3VnaCcsJy0nLCdTdWJzY3JpcHQnLCdTdXBlcnNjcmlwdCddLAoJWydPcmRlcmVkTGlzdCcsJ1Vub3JkZXJlZExpc3QnLCctJywnT3V0ZGVudCcsJ0luZGVudCddLAoJWydKdXN0aWZ5TGVmdCcsJ0p1c3RpZnlDZW50ZXInLCdKdXN0aWZ5UmlnaHQnLCdKdXN0aWZ5RnVsbCddLAoJWydMaW5rJywnVW5saW5rJywnQW5jaG9yJ10sCglbJ0ltYWdlJywnRmxhc2gnLCdUYWJsZScsJ1J1bGUnLCdTbWlsZXknLCdTcGVjaWFsQ2hhcicsJ1BhZ2VCcmVhaycsJ1VuaXZlcnNhbEtleSddLAoJJy8nLAoJWydTdHlsZScsJ0ZvbnRGb3JtYXQnLCdGb250TmFtZScsJ0ZvbnRTaXplJ10sCglbJ1RleHRDb2xvcicsJ0JHQ29sb3InXSwKCVsnRml0V2luZG93JywnLScsJ0Fib3V0J10KXSA7CiovCgovLyBmb3IgZXZlcnkgYnV0dG9uIGFkZGVkIGhlcmUgdGhlIEhUTUwgdGFnIG11c3QgYmUgZXhwbGljaXRseSBhbGxvd2VkIGluIGxpYi9jbGFzc2VzL21vZHVsZS9jbGFzcy5HdWVzdGJvb2tGcm9udGVuZC5waHAgYXQgbGluZSAzMjUKLy8gY3VycmVudGx5OiAkYWxsb3dlZCA9ICc8c3Ryb25nPiw8ZW0+LDx1Piw8Zm9udD4sPHNwYW4+JzsKRkNLQ29uZmlnLlRvb2xiYXJTZXRzWyJHdWVzdGJvb2siXSA9IFsKCVsnQm9sZCcsJ0l0YWxpYycsJ1VuZGVybGluZScsJy0nLCdUZXh0Q29sb3InLCdCR0NvbG9yJzw/cGhwIGlmKGlzc2V0KCRfR0VUWydzbWlsZXknXSkpIGVjaG8gJywiU21pbGV5Iic7ID8+XQpdIDsKCkZDS0NvbmZpZy5Db250ZXh0TWVudSA9IFtdIDsKCkZDS0NvbmZpZy5Gb250Q29sb3JzID0gJzAwMDAwMCw5OTMzMDAsMzMzMzAwLDAwMzMwMCwwMDMzNjYsMDAwMDgwLDMzMzM5OSwzMzMzMzMsODAwMDAwLEZGNjYwMCw4MDgwMDAsODA4MDgwLDAwODA4MCwwMDAwRkYsNjY2Njk5LDgwODA4MCxGRjAwMDAsRkY5OTAwLDk5Q0MwMCwzMzk5NjYsMzNDQ0NDLDMzNjZGRiw4MDAwODAsOTk5OTk5LEZGMDBGRixGRkNDMDAsRkZGRjAwLDAwRkYwMCwwMEZGRkYsMDBDQ0ZGLDk5MzM2NixDMEMwQzAsRkY5OUNDLEZGQ0M5OSxGRkZGOTksQ0NGRkNDLENDRkZGRiw5OUNDRkYsQ0M5OUZGLEZGRkZGRicgOwoKRkNLQ29uZmlnLkZvbnRTaXplcyA9ICczL3NtYWxsOzQvbWVkaXVtOzUvbGFyZ2UnOwoKRkNLQ29uZmlnLkRpc2FibGVPYmplY3RSZXNpemluZyA9IHRydWUgOwpGQ0tDb25maWcuRGlzYWJsZUZGVGFibGVIYW5kbGVzID0gdHJ1ZSA7CgpGQ0tDb25maWcuTGlua0RsZ0hpZGVUYXJnZXQJCT0gdHJ1ZSA7CkZDS0NvbmZpZy5MaW5rRGxnSGlkZUFkdmFuY2VkCT0gdHJ1ZSA7CgpGQ0tDb25maWcuSW1hZ2VEbGdIaWRlTGluawkJPSB0cnVlIDsKRkNLQ29uZmlnLkltYWdlRGxnSGlkZUFkdmFuY2VkCT0gdHJ1ZSA7Cjw/cGhwIGVjaG8gKCFlbXB0eSgkX0dFVFsnU21pbGV5TGlzdCddKSk/J0ZDS0NvbmZpZy5TbWlsZXlJbWFnZXMgPSBbJy4kX0dFVFsnU21pbGV5TGlzdCddLiddOyc6Jyc7ID8+CkZDS0NvbmZpZy5MaW5rQnJvd3NlciA9IGZhbHNlIDsKRkNLQ29uZmlnLkltYWdlQnJvd3NlciA9IGZhbHNlIDsKRkNLQ29uZmlnLkZsYXNoQnJvd3NlciA9IGZhbHNlIDsKRkNLQ29uZmlnLkxpbmtVcGxvYWQgPSBmYWxzZSA7CkZDS0NvbmZpZy5JbWFnZVVwbG9hZCA9IGZhbHNlIDsKRkNLQ29uZmlnLkZsYXNoVXBsb2FkID0gZmFsc2UgOwo=]]></data>
	</file>
	<file>
	  <filename>/Guestbook.module.php</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[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]]></data>
	</file>
	<file>
	  <filename>/images/</filename>
	  <isdir>1</isdir>
	</file>
	<file>
	  <filename>/images/icon.gif</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[R0lGODlhIQAhAMQZAL2QSeuQcMKAKpRiSffHoIVXUzklh9GKHykbkuCUFXZNXvCeClc5ckgvfaNsPmZDaNi9k9XS0ujbCfGZU/zn2P+uIP+iAGdhVv+oAP///wAAAAAAAAAAAAAAAAAAAAAAACH5BAEAABkALAAAAAAhACEAAAX/YCaOZGmeaCperIqy11tdGOyOV6DH5mXRmKBNlQtICDzcLMhkDk+XiuSYzPiAzeyTFJ0iV0tMIUuuQaVU669mSAjL5rM3ClQYCoICotySTScsQQgHDwMMCnwVFSldEoAYBwYYCwsNLA5NPhRVPRZ/FwdACXsCA6ZCExQzjD6fTmMYBgdumqqcXCyejlgYpQxOqYCsMLqPQQICThYUtowAMK27fMG3OBAXAM+5rpnLzS/P2dnbxsAUwjJY4s8WE+W1qy9rTeIs79SMMxZw40Dw1St+WNgHJxO+YQQLCvEWT94PGAovHEwxI4LFgRC1MATIpYLFjxgDoTrHsUSUgR8vJz78dwMHiwooU/5ghq4lrpMWZH6z2eNlzAgleVrx2Ueoiy1Gk5YIAQA7]]></data>
	</file>
	<file>
	  <filename>/images/index.html</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[]]></data>
	</file>
	<file>
	  <filename>/images/smileys/</filename>
	  <isdir>1</isdir>
	</file>
	<file>
	  <filename>/images/smileys/default/</filename>
	  <isdir>1</isdir>
	</file>
	<file>
	  <filename>/images/smileys/default/angel.png</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[iVBORw0KGgoAAAANSUhEUgAAACoAAAAXCAMAAABK+S0aAAAAKlBMVEXAwMAAAAAdHR2wsLAeHh7GxsbR0dH+8wD7ygD4nAD////u7u7c3NyRkZF3uPX+AAAAAXRSTlMAQObYZgAAANpJREFUeF690t2qhDAMhdHsnaT/vv/rnlTreGYEL+ZiPhAxLFqolV+U33uUt8/vV/0+zJ4A9ybMuZQyMY/uUlISEjmatmIfJeVNem+tC/NR0EqJURvGu1wUCApMumafssd8WP5Hq6UepbdlKd1ttJau/UtQKsaACi9LS26WxnCWJU+qCUj+sqQnM5F4WM7qQaHBu/A6JjUN6R4US2LSaYFxngJD0TRkF2K3dZcgdTNXSJeTGttGbi4kpor2tyBSJd0X3Yjo/K/1DK/7QG6LTnGFAwNvMzzdrB/1B/y0COxMa3/lAAAAAElFTkSuQmCC]]></data>
	</file>
	<file>
	  <filename>/images/smileys/default/angry.png</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[iVBORw0KGgoAAAANSUhEUgAAABUAAAAVCAMAAACeyVWkAAAAP1BMVEUEAgRkGhSsNiTsbkT8elTsOiTMWjykVlT0Wiz0jmS0TjTM2vSshoQkPoT8/vzk4vysjqTchmxMQpS8vvy0qqSa2cbJAAAAAXRSTlMAQObYZgAAALBJREFUeF590NeSwlAMA1DkdksKbPn/b0XXJuzsC3rTGcXJ5PYpe3OXuf8372qmAbwdmN3GGApo93bxZKWCc9OL987ZyHEY13XEFVp4gtqlpmxfVNyp8RqHrrr0+weqUS90Y009DpjmiVTWvItOKxVjVWPUcupLZ18yRjqXdffhllEAsVTyg0VNwgLb9ovU16/RALCd54maZpqzOBivq2++IomVXTz3Uo//eRORRvuUJ2BwBwaxB4EQAAAAAElFTkSuQmCC]]></data>
	</file>
	<file>
	  <filename>/images/smileys/default/beer.png</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[iVBORw0KGgoAAAANSUhEUgAAABUAAAAVCAMAAACeyVWkAAAAWlBMVEUEAgTUnlSsvqyEgoTE3sSkoqTUvqz8vlT83qzUXlT8+vT8/vz8nlTU3vysnqz83vysfqx8XlR8fqysflSsnlTMzvysXlTU3qzUfgR8flTUflTUvvxUXlTUXgS3ll+kAAAAAXRSTlMAQObYZgAAALpJREFUeF59kMduwzAQBbWNvajLdpL//80sAUumLh7eBg8DYocvsBQRwXyTWHMjIN+WHBqbkW6NwigKIh2d3WJm3jhmko81xcUYNSFEhFd3TSa4w8hMGjnTsoC18NrHmcwP8dlVm+DhF93mm7XgdxqfGK5vlBWShcffeG6vrgNfSW3trbNw7NolktPSCsGC81qYD7O97bwklxL7VuDrEiKt4Jo1/SVJntP0O7VoBxspggVV9uSgL9fhK/+a2wiSUYCgfgAAAABJRU5ErkJggg==]]></data>
	</file>
	<file>
	  <filename>/images/smileys/default/bigeyes.png</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[iVBORw0KGgoAAAANSUhEUgAAABUAAAAVCAMAAACeyVWkAAAAYFBMVEUEAgT87lScdiT83kT8zjSUekTcqixkGhS8rpTsuiz89mSsllzEsnS0qqS8tqy8pmSchkzkyjTEpky8jiz8/vzM2vS8vrzkxkzMmjTUtkysmoSslnz8/vTMiiTcxnR0alQjAnUXAAAAAXRSTlMAQObYZgAAANVJREFUeF59kNduxCAQRZlGd29bk///y8yQxH7bgyU0x5crhPvIHus8xL0L4ft0fQkhzEAcinP/OlK453vIAJS+3CmzAvYNUp5/x1VCFamalfVV+mYraFLWVfSnbcXkThku273E92erxFUAAEMnyZprNmxsNmAa1c5gvTaqTYiezQ5m4UA8CICYuWUjgY4NOibiyVtvz78GYEK8afbWOWVgoBbEbZMpWYGFEzWWTe/MvGjUiIlJF6od+f04n8ezolbKovJ6X5/SgriM7fjlH2Ucn+o+8APU/Qq5CoyuPgAAAABJRU5ErkJggg==]]></data>
	</file>
	<file>
	  <filename>/images/smileys/default/biggrin7.png</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[iVBORw0KGgoAAAANSUhEUgAAABUAAAAVBAMAAABbObilAAAALVBMVEUAAACwig3ZsBLqxRf53B/kuhTwzhrMzMz+5SLKmwyZmWb///+jmX7/5iKZZgAFWBQ6AAAAAXRSTlMAQObYZgAAAL5JREFUeF5djyELwlAUhV8TZMm8MlAElZXHK2LaRFYMIjZ/hEH/gtyyFZNtQRCHRY0rIgNBZl95xYcgDPYbvPeNlR1u+Licc7iX1dRIo2eFiZ9tjyUnUvrg3gkNX0qZwYh4DQXgOCvkdwA/HDfE5BS0Jl20Q6nxkqKFlhoy1pSfOI/z65cYSlY99HiK+KYG2OMFfWSbm9h/INNFiRB549lYs5vRQUbbsfYtYTLSg8/5Qq8xfeoI61w984pSVtMfw2ZVNQ7E0SQAAAAASUVORK5CYII=]]></data>
	</file>
	<file>
	  <filename>/images/smileys/default/blush.png</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[iVBORw0KGgoAAAANSUhEUgAAABUAAAAVCAMAAACeyVWkAAAAV1BMVEUEAgT83kT87lT8zjTcqizsuiy8rpS8pmTcuhzMmjT85iy8tqy8jizMiiSchkzkyjSsmoT0ohSUekTEsnScdiSsNiT8/vxkGhT89mTEpkyslly8vry0qqTL0mlGAAAAAXRSTlMAQObYZgAAAMpJREFUeF59jFdywzAQQ72NXV1yzf3PGSwde5wfP1HC6A2I01dq2G4x1P9uE2ImmuKHD8KAoMXCW6J3ZacQvXQVjuu6wSOi6HNkY17P55Wph9j9r3rtlp926uVAxPvFbQ+RZfaB4r+XnYk8xGyEvaE07fvEXBAqqduIBfYDioiaug1CBY8fAcnUdx+C0qGGr7XDzNrPCURohU6Wj8FswQCoCWvD4QzZEqqdoNDacm4KidWXNtzHmxbIN/WeNdmibfTrH34ex3GG+8IvQs8KkJYJ+ogAAAAASUVORK5CYII=]]></data>
	</file>
	<file>
	  <filename>/images/smileys/default/cool.png</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[iVBORw0KGgoAAAANSUhEUgAAABMAAAATCAMAAABFjsb+AAAApVBMVEUAAAAMCgz85kz83kT0zjzstiT86lTUpiy8nmScdiS8rjT81jzcrizswjT8yjS8iizktjR8foQsLizsuiz87lRUUlSEXixEQkTE3vT8/vzs1pT0wjT05rTUvjRcTiTcxpT0zhxkZmT84ozEqnzk3tTEmiz08uzsymTs4tTkwmSUmpyskkz89uzMpmT88lz06sTk1qz07tz83mz04qzculzk0kyUbjwGC4C4AAAAAXRSTlMAQObYZgAAAAlwSFlzAAALEwAACxMBAJqcGAAAANxJREFUeF5Ny1V2AzEMQFGB2R6GcFJmpv0vrfJ0cpqnH/keGea2RV1/PsFJW8VkKBbrf7qg3vSGiGJ9pI8Xqe+JKXL9nuUcMHyb4BFbf61Kmw2HFhBxsRgQZWkfhZoGcReweRha9MVZ1d4A5tmZ6QZHVW72b7CX9YeMh6xCWl9CNeIYiMKIiCFuik47uGU2lIvMqix1lxy8KqZpmKN87bS9AijY/6VU1J3WFQCsS7/MeTkSsg6k++SXq5W3+SjJ2dSX9T6TWKYZ5ZFBW6FjB2uTTrZycNrds3OHef8FuRwN3ssWrFQAAAAASUVORK5CYII=]]></data>
	</file>
	<file>
	  <filename>/images/smileys/default/cry.gif</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[R0lGODlhEwATAOf+APzzaeTbyf3zV+KyLtO3Vt+lOpVuZPbpzfzpTk03jcWoaldGkvzQOv3+//3eQv3tUv/iRfTWev79+f7jTunBOM69mfbjs/70ZfXONtXQ5vPdqJOIt9rGnPz69fnZPv7kT7eXedSlKPbTPfDBLdm5a6iGOPzvVe/jy/bhq/nGMvr16ebVdvzmSreeaXlrqPzwXdmsTbuiafDPePvKNf389vraQfjy4NvCiujUVLqRKvbPOPzpWfz47fnVRtzKfOa6Nf3cRvnXP+W0Mf/hS/zmU9u+dv3uWrKXXe69Keu+Ru7MdvzpVItmavnu0f3zYMOmOpl4J+GsJ/3sWHRhluTHaO26KHJXjOm0JvvoVGAvH+mzIv7+/IFlh/7kUerJcfzvXPXCMPHDLv7sWfr49NTN4Z8/H4d6tPLRTPzTPP3eSPbDMOzDVcGXLfvaRP70YPXw5vXTQtmqLvn4/PXx6tWnLf/gQ2NVnPTOOrGNPP3kSf3yXvzqVby01fzpVvvbRXRVfv30YLWLKO+7MW1eo/nv1ejQT/zVPtmULvbXRunVqvPRQciFNLOVT/vmTPK+Me3Kd+24J/30X/3xXsyiOvfEMv3rUKxZPvzNN/3lS+K2QPHt4vviRvjaSb2hYf7kSamNS/DIO/zqV/THMu/Zpu/FROLRq9XHpsmfOoh1j+i6ReK1Pu3Um9/Kmsfd8+rY0v3tWvTBMPrw1/70Y/n38timJt/Vvf/jR/TDNPnVO/ziUfHGOfrJM6N/KdqqKc+gJ+SwJv7mSvznS+fPTtyuL6qCUvrubP7+/tqZMfzyaP7lWffgXN68P9e/i6ySYfHaac69rsmsX/zmUcKoPPbKNPvcS8yyQdK5RsGrfu/q3PHRgeu2JejOTNG3k/vdRfHDMf3ON8+fKezYq/z8/v7mUv3gTvzwW/Xr0ffQOKOAKvfJOfvuVubJR/7mUeu7L+myJPC/K+q0JPvLNv30Y+DBep+BjuTQouTPomtVj5d8hPjTOsi0jNKpaLuNWaqOS////////yH/C05FVFNDQVBFMi4wAwEAAAAh+QQFFAD/ACwAAAAAEwATAAAI/gD/CRxoQUYSIakeWRjIcCAKUne6YUIAQYS3TKMaCsx2J4vHBwgQsLDlMUvDbCKyCFiZBSSLLA48DDApEMUdEyZWCjDh0pYDHTro1BNIKo8JdSsfqAOJIM9PDO0m/bNw5wHOlUsrhXSKQUcYX6Vk1HhgtZ/ZfgiCBTvbb0QvBUlsIahUiYVdBI3ybAriQZQoJL/wCPEULGQjuyz08g0SJkwVeLxS1bAFjEWwxJ5s1anhQYeod5CilHh0p46t07Yg1HFQI8g5USMe+2phwZGD26dve8DFGwkSbVpymPqX6Q7f2w7KKFeuBZIWWiUEjhrQFWiZc2HeVdFSRouWQBUGOc4bFsZb7O1VtmuBl6NFwyIhriCpAkkbvO20ArnXaO8UOFq/uBOFLzmUEJ5GA5WiAB7olNDCcA0FBAAh+QQFFAD/ACwAAAAAEwATAAAI/gD/CRwYC4WMNUo0EBrIcGATaFByfXGyhxMoLwcaCrSgyAgUaTicuHkhhtoPZp8YWkAEABkOKFCeFHohBcsyKMwcKgLAEwAOazC/iHkCBciwEwIjvOKZACaUajOlOIVC4l8sOBdWLECF7MIFWSNrTvDzj84/FOS0TkFVzCsgSa/2EBkyTeAzGX0WbBi0wAdYJ1+kLOmShuEaZ/fsLEiwwomkL5AHt0EzUAkVVAvsJID86tWSJWkMGfo2UMMZEAnwFTEipc+XRWXKFGAwA8a/I4RAEUmmbEkfItFgt2plaQYlMMQC/PPSw8O/Lh8mDPnXyp+lQynUMMz47wwQP35qRRyLfQgMGFj/rg2s+g+NewYMspsHw+ZIw6q34u1KkYKSGlhC5NCMcgzZcMMkdAzgCCyCxMFGJ7VoxNAJHCjASAwVEMhQQAAh+QQJFAD/ACwAAAUAEwAOAAAIkgD/CRQoYKDBgwZNmCiI8B+5BAcfPFjY8J+CBAloCdyBoFIlFiwa7kvgYtDAYAgQNGIBSOCiMmUK/Etgx8xAW8BYBBv4slUrSwy4kBxYx5ZRKQLL+PRn6d+uPzb/6Wqo1J+/gWoM4gNRkSlCA1YQVrV06GCGKVZAjDB4DGbZgxvMJGBSseGgBQvo1UWYIeregwEBACH5BAkUAP8ALAAAAAATABMAAAj+AP8JHBgLhYw1SjQQGshwYBNoUHJ9cbKHEygvBxoKtKDICBRpOJy4eSGG2g9mnxhaQAQAGQ4oUJ4UeiEFyzIozBwqAsATAA5rML+IeQIFyLATAiO84ikAJpRqM6U4hULiXyw4F0yYEIDswgVZI2tO8BOGTikU5B482FrMKyBJr/YQGTJtRK9nMnYgqFSJBQuwTr5IWdIljSgkv/CscRYMAYJGLN5+mUy4DZoq8HgpoWILGItgk1+9WrIkjSFD3yBFKaHhTB1bsKVI6fNlUZkyBRjMgOHrCCFdRJIpW9KHSDTbrVpZmkEJDLEA/7z08OChy4cJQ8q08mfpUAo1tEpcCDwwAIMOIH781Dh2+xAYMLD4/RlIYlgYNPgZMPj+HgwbAwvwQV8It8SzSwopUKIGLELk0AwTg5jB0A2T0DGAI7AIEgcbndTyzwYJCNjQCRwowEgMFUA3EBn/BAQAIfkEBRQA/wAsAAAAABMAEwAACP4A/wkcGAuFjDVKNBAayHBgE2hQcn1xsocTKC8HGgq0oMgIFGk4nLh5IYbaD2afGFpABAAZDihQnhR6IQXLMijMHCoCwBMADmswv4h5AgXIsBMCI7zimQAmlGozpTiFQuJfLDgXVixAhezCBVkja07wE4ZOKRTktE5BVcwrIEmv9hAZMm1Er2cy+izYMGiBD7BOvkhZ0iWNKCS/8Kxxds/OggQrnEj6sqhMmQJt0FSBx0sJFVQL7CT48uVV5VatLBn6BilKCQ1nQCTAV8SIlD5lUPuzxGAGDF9HCIEikkzZkj5EouX2t3sGJTDEAvzz0sODhy4fJgxZvjuFGlolBE8eGIBBBxA/fmost3QIDKxA1waSGBYGjX0Gxyy3B8PmSEMSIdwSzy4ppECJGrAIkUMz0jV0wyR0DOAILILEwUYntWjE0AkcKMBIDBU0yFBAACH5BAkUAP8ALAAABQATAA4AAAiWAP8JFChgoMGDBk2YKIjwH7kEBx88WNjwn4IECWgJ3IGgUiUWLBruS+Bi0MBgCBA0YgFI4JcvS7r8S2DHzEBbwFgEG/hqyZI0hhhwITmwjq2jUlwuKlOmwL9df2z+09VwaatWA9UYxAeioqVDCA1YQXiM6SEwBzNMsQJihEEGKdSgPbjBTAImFRsOWrCAXl6EGaT+PRgQACH5BAUZAP8ALAAAAAATABMAAAj+AP8JHBgLhYw1SjQQGshwYBNoUHJ9cbKHEygvBxoKtKDICBRpOJy4eSGG2g9mnxhaQAQAGQ4oUJ4UeiEFyzIozBwqAsATAA5rML+IeQIFyLATAiO84pkAJpRqM6U4hULiXyw4F1YsQIXswgVZI2tO8BOGTikU5LROQVXMKyBJr/YQGTJtRK9nMvos2DBogQ+wTr5IWdIljSgkv/CscXbPzoIEK5xI+rKoTJkCbdBUgcdLCRVUC+wk+PLlVeVWrSwZ+gYpSgkNZ0AkwFfEiJQ+ZVD7s8RgBgxfRwiBIpJM2ZI+RKLl9rd7BiUwxAL889LDg4cuHyYMWb47hRpaJQRPHhiAQQcQP35qLLd0CAysQNcGkhgWBo19BscstwfD5khDEiHcEs8uKaRAiRqwCJFDM9I1dMMkdAzgCCyCxMFGJ7VoxNAJHCjASAwVNMhQQAAh+QQFFAD/ACwAAAUADgAOAAAIeAD/CRQoYKBBgyZMFDxo8MEDhQwH7kBQqRILFhEFBkOAoBELQAK/fFnSRaAtYCyCDXy1ZEkaQwLr2JopJeSiMmUK/NMV8WarVgPxgcho6dA/A1YYHsN5CEyGKVZAjDDIIIUaMP82mEnAJKPAQQsW0PP6L4MZsgIDAgAh+QQJFAD/ACwAAAAAEwATAAAI/gD/CRxoQUYSIakeWRjIcCAKUne6YUIAQYS3TKMaCsx2J4vHBwgQsLDlMUvDbCKyCFiZBSSLLA48DDApEMUdEyZWCjDh0pYDHTro1BNIKo8Jdf8EPFAHEkGenxjaTfpn4c6DgQKYVgr5FIOOf75KyagxsJ/ZfgiCBTvbT6CCJLYaskDQKM+mIB5EMRTiSS4Lu3iDhAkzMBXZgX892apTw4MOUe8GPrrD0BaEOg5qBDknakQVeP9a/HPkoLQtnzFxqUaCRJuWHKb+ZboT5F9pB2X+ldmtBZIWhqMG/AOqo8y5MO+qaCmj5XeFgfOGhfHmWXkV5Vrg5RDNsMi/K0iqIkDSBk85rUDcG9o7BY7WL3dRfOUo8VzjwFIK8KAr0SJ2w4AAIfkEBRQA/wAsAAAAABMAEwAACP4A/wkcGAuFjDVKNBAayHBgkwhwcn2JtIcTKC8HGgrkkKUjgQtu9BDomIVbQwtZCAAYeUGekywwsMDIksihIgDIAOhsCejFKyxd/Aw7ITDCKxz9kuLguS1pPwrpSPyLpehCP1f+XH26IMvN1az90NA5gYKcrH7+svjrd8GJJLRq+zEQwkFGKEBftQJy8iVvv3gjFKwxokeYU2GSvkhZ5/THDDCMlLB79eKFpBflXknpQ2QCEEOXUgiKoQHRHiliXonZjGXcByBBGOxSE6cCIV1EsPRZgoXIuC5DYDOIRwkMmwD/vPSY8KH5hCFp2hgangKMkE4CD/zwAwRIme/gy0BUh5Wj1sBwQtCoR8Pg24wUxWGxqdAwUZxb8d6nUKMGzIAc9Gl0Agl0DCAILILEwUYn5mk00AkcKMBIDBUg11BAACH5BAUUAP8ALAAAAAATABMAAAj+AP8JHKhBSRIhqbxoGMiQIKk73TAhgCDCW6ZVDQUqyZLFhIkHCBCwsMWRREMZWQQI4PgRAUcHHrKYFKjhjkeVAlqOdKBDBx1WAknlMaGun9EHII3204Gh3aR/KO48MNFPwNFKCIzW6IchjC9WSmogNSEAKchgwTbVmDZtRC8FSWwhqFSJhV0EjfJsCuJBlCgkv/AI8RQsZCO7LPTyDRImTBV4vFLVsAWMRbDEZTLX8KBD1DtIUUp4uVPHlmlbZeo4qFHmnKgRj30d0eDIgW3Utj3gwlUGCRJtWnJU+KfqDl/bDvLla4sEEiQttEoIXDUAQ08d586FeVdFi3ctgfQ7DSwyLIw32N2rdNcCL0eLhiRCXEFSBZI2eN1pBTqS8R+rU+DQ8os7UfiSQwni9ScQKwrggU4JRwzXUEAAOw==]]></data>
	</file>
	<file>
	  <filename>/images/smileys/default/frown.png</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[iVBORw0KGgoAAAANSUhEUgAAABUAAAAVCAMAAACeyVWkAAAAUVBMVEUEAgT8zjT83kSchkzcqizsuiz87lRkGhScdiTcuhysNiS8pmSsllz8/vzEpky8jiy8rpSsmoT82mzUtkzkyjT8/vTMmjTkxkzEsnTMiiQ8OjSPoQZUAAAAAXRSTlMAQObYZgAAAMJJREFUeF59jFdqA0EQBfd1mrQ5SfL9D+ruxVqEP1QMNNQ8qvvO/Bzb/M89QWQEbZ87mK3mEGS+JYWMR0S3Bj1yfpDZlvMG+WuS5ZSyrRQH2l8Wq/FPYs9ySgzIu8rH4Zb4GBi7LFeAjIchhx0Ohiq7HcmoMTejOCOkhG2+DcgBoCph553eANiLetcpIbap1noKRHXqgubjM5R/vEoELgSoExx5VS0xDWYJpYHLpbu1Fr2ehLzpTxEVmaL5ydIz++4bv3JbCCg+hMyfAAAAAElFTkSuQmCC]]></data>
	</file>
	<file>
	  <filename>/images/smileys/default/index.html</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[]]></data>
	</file>
	<file>
	  <filename>/images/smileys/default/moon.png</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[iVBORw0KGgoAAAANSUhEUgAAABUAAAAVCAMAAACeyVWkAAAA6lBMVEX8/vy8vvzk4vzc3vy0srTM2vR8fpycmpy8wtSsrrTM1vSUlpzk5vzc4vycnvSUkpRsamykoqSsttScnuzM2vyMmrS0utSUmuTs7vTs6uyEksx0dqScoqy0vtx0dox8hpSkpvSEioycqsx0cnyEhoTExvycnrS8wvycrtT07vS0suycmrSMlsykqrxkapykrsysrqykpqyMeoRscpycovScpsR8fnyEipzU1vzU1uR8iryMltScltyUnrRsbpysutSkvsSMioyMmqx0doSstuT08vSsssSkttx0cqR0cnS8vsSMkryEjpyUmtx+gsiZAAAAAXRSTlMAQObYZgAAAM1JREFUeF59z9VuxTAMgOHYoTJzDzOMmZnh/V9n0VRtSi/Of+dPjqyQzXVvXxhrWWZ0Fe+3MDPomcECDaPMKayn4F3D7ch5pouOZkqxOLdSX8frxRJ3phespS7SOqk/dD5GRE65HDJNqUsTDvg60Y5x5BwA7vq/o9/sAs4PgQ3He2pgX82LcJRYq7fTshyfTPpHN2Gj4e4UVgcPfprHcRWYpGFzC+Aq/449r3qUf/fMzmzgqS4/e/fkv9kgXQsheraU2lcUhratrJ0QZHM/K6MSbMMURLAAAAAASUVORK5CYII=]]></data>
	</file>
	<file>
	  <filename>/images/smileys/default/no.png</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[iVBORw0KGgoAAAANSUhEUgAAABUAAAAVCAMAAACeyVWkAAAAPFBMVEUEAgTUnlT8vlT83lSsflTUvlSsnlT8nlTUvqysfgT8vqz83qzU3qykoqSsvqzUngSsnqzUnqz8ngTUfgSNN1NjAAAAAXRSTlMAQObYZgAAAI5JREFUeF6VjskKxDAMQyPZztJttv//14lJqAs9DPNwcngWwukXG8zsrrgIUFNg2GQRaSyYphoqV1lFFrLhNXNklxT2UWo+bXceJjw8bPasbxylRgNlvNZnWJDmzr9oqBkAJ5qf57lHhhttqnu6sA8/rg0qFO/Scpizv+BTQ0zwKIjeaOmkGwbP3jnSv3wBdEIDUqB7m5IAAAAASUVORK5CYII=]]></data>
	</file>
	<file>
	  <filename>/images/smileys/default/plane.gif</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[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]]></data>
	</file>
	<file>
	  <filename>/images/smileys/default/rain.png</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[iVBORw0KGgoAAAANSUhEUgAAABQAAAATCAMAAACnUt2HAAABfVBMVEX///9rhrjw9/v2+vv+///+/v9AXLGex+Q/WZvCy+h8hcubpdidxeWItt3g6++rw+fc6u+0xOXj7/Www+Rcg7I6YKHJ4Ojf6e+Hl9NRcqyKrNno8/ZnlseBm8q7yOhCYbA4WZc/Xaz5/P10gclzlc79/v7z+Pppe8dOos3G4u7k8PNXmcqcrs9EYqzb5Ox+kdFij7W0wtuu0+iq0OHS4fNdhreltN+rw+VnZLE8Yalnfb1TaKBTVZVTS4mHp9V5jsvc7fS5xubP3+17is230edufsP5+/xXW5j+/v73+Pv1+ftXc6X///9gmsWgstJNb6r4+fuYscbI0fHL0+g6W5ufpsSbpNzw7/eruuGrzeTJ0u6ituRchMU9VZZlq9f4+/24xed6hc7z+Pv9+deDmtJvfsCxvdzJ2PGWp9CSmdXi5vJrjMWIpM5edMFQWImRtdyuyNyInsa+zevT5/FzicGvueFznMjByuasxOamyd+ovufL3eqcr9M5XqCKrMlc5/U3AAAAAXRSTlMAQObYZgAAAAFiS0dEfj+4QXMAAADFSURBVHjaY2CAAdb4Yk0mVgYE8PFg0hKvK5PRNmJmYUAGdXV1NTxxxtIwPouaE39FfmAor6BwJbsqUMCN2UtJyLyUu0jOOUfW3rHc1wEoqFctFimVEhbFaRIhYZedmmCgAdIbwOeiYpUZlG5WFa3v7W5hWgA1UyAmV12ZK9HVOs/WRiQJKOCZFZyWUWIpz6aoW6vAERsi6i/JwGDoV8hYCwGMOuEMtUiOTGYAcSEIAmoxRBhQuLUonsSusBabMmyAaIWoAADwhS53Mxb84QAAAABJRU5ErkJggg==]]></data>
	</file>
	<file>
	  <filename>/images/smileys/default/srcstic.png</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[iVBORw0KGgoAAAANSUhEUgAAABUAAAAVCAMAAACeyVWkAAAAaVBMVEUEAgT87lScdiT83kT8zjTsuiz0ggy8rpSchkz0WizMWjzcqiyUekTEsnS8tqzkyjSslly8pmRkGhS0TjSsmoS0qqSslnzkxkz0jmT89mT8/vykVlTEpkysNiT8sozUtkzMmjS8jiz0kiwTOtweAAAAAXRSTlMAQObYZgAAANJJREFUeF59keeKAzEMhKPmbm/f9Fx5/4c8acNCwkHGPwY+RiNsHz6q+XobfHtnlUBFPLxwT3DeBCT+P1TtuPWlVEVVDYjys6SWy6Vo0sy6+y1KZd6oGexhTzguRs2IiGVVOgCOIyo1A6UclN7giHjUbR3iFxAbtSyc9agIrKATo55g1zbP2Xobg3IylhG54+/lYBWM2GlMe9MknMPzbkKCmCeMD5eS/GjU5IVs2MXfk5twNmRasi25T+4U4/XlfXthYbxHl8rbu899COGa1g//9Qc58wwUF/TycwAAAABJRU5ErkJggg==]]></data>
	</file>
	<file>
	  <filename>/images/smileys/default/star.png</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[iVBORw0KGgoAAAANSUhEUgAAABUAAAAUCAMAAABVlYYBAAAAaVBMVEUEAgT81gz88oycdiR8aizczqR0alSUhmyUekSkpqS8jiz83kTcxnT85iz89mT87lT87gyMcmyckoSMjoz82mzMiiSMlpTcuhz8zjTsuizEsnS8rpSEhoScmpy0qqSchkz8+ryslnzkxkz+VtygAAAAAXRSTlMAQObYZgAAAKFJREFUeF6VjteuwkAMRDP29poe+i3//5GUABsUJMR5sXU0sqf6gGb9xhritTwZz8d1NMRBrCwHTEvLMz3AM7PtScogPRAuoye2V2vZEOUIRKJUK1bjfKPhTQ0gU/IsOvusJbZATPR/DRban4icyKnupRehpt8Mtgtp9h4TS8LARWpNcKIRO4IyJfrnnTjYyyQnimVubm9aw6YqWPtYxupLzuGPBhD+ouYFAAAAAElFTkSuQmCC]]></data>
	</file>
	<file>
	  <filename>/images/smileys/default/sun.png</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[iVBORw0KGgoAAAANSUhEUgAAABUAAAAVCAMAAACeyVWkAAAAq1BMVEUAAADsEiT03hy8rqyUhnTkxiSsUlz03iTMpiT04hy8jjycekzkyiS8kjz04iTUlmykaiTsyiS8bnTsJiScjnyUjoykloS0hnTsOiycWlycflTsHiTEqqycfny0mpycdkysfnSUdkykbnSsenysjpTsLiz84iS8ZlTsLiSsdnycaiSsoqTkFiSchoy8kpSsRkysnoykoqS8urSkZmz0RjTMpiy8emykiny0ZlxhoU6DAAAAAXRSTlMAQObYZgAAALpJREFUeF6tj+eKBDEIgDU90/vM9t7r9Xv/J7tJCIGD/bXsJyh+iCg8B07/t9TkAoUpY3SWdodvuA+zsHqHYn8Cx+ozDRQnkYrTkfB7aBvnWvbB458LeBpFpCYJ0YpRL5dhTrRMes1nwmlEzKS2s1uSjcoNWKZiFpFEGhmFt8kbOCqlSR9SfzHjHG2QW82DXePltbP3chWkmw9v96t5zRbHBat/B7h28mzfWeLA7FyjaTxjnMADSgqv4w/mHguL1Wg2MAAAAABJRU5ErkJggg==]]></data>
	</file>
	<file>
	  <filename>/images/smileys/default/wink2.gif</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[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]]></data>
	</file>
	<file>
	  <filename>/images/smileys/default/yes.png</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[iVBORw0KGgoAAAANSUhEUgAAABUAAAAVCAMAAACeyVWkAAAANlBMVEUEAgT8vlTUnlSsnlSsfgSsflT83lT8nlSkoqT83qzUvqzUvlTU3qzUnqzUflTUfgSsnqysvqxMMr1VAAAAAXRSTlMAQObYZgAAAINJREFUeF6tz8kOwjAMRdG85yFTy/D/P4spRlC17LhKNkeyJZffLRwnSsgJs88THgDactDZHcfdghEsex9UCp7+jYLu6ABIzpFYPdARLwJfat0NaR9V1218br+m0hwMylKLITyr862KxAnTKqmrwTa7mLS2lowaaNew3XU0Nbm1e/lbD8TKAx6lXXPpAAAAAElFTkSuQmCC]]></data>
	</file>
	<file>
	  <filename>/images/smileys/index.html</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[]]></data>
	</file>
	<file>
	  <filename>/include.php</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[PD9waHAKCmlmICghZnVuY3Rpb25fZXhpc3RzKCdjbXNfam9pbl9wYXRoJykpCnsKCWZ1bmN0aW9uIGNtc19qb2luX3BhdGgoKQoJewoJCSRudW1fYXJncyA9IGZ1bmNfbnVtX2FyZ3MoKTsKCQkkYXJncyA9IGZ1bmNfZ2V0X2FyZ3MoKTsKCQkkcGF0aCA9ICRhcmdzWzBdOwoJCQoJCWlmKCAkbnVtX2FyZ3MgPiAxICkKCQl7CgkJCWZvciAoJGkgPSAxOyAkaSA8ICRudW1fYXJnczsgJGkrKykKCQkJewoJCQkJJHBhdGggLj0gRElSRUNUT1JZX1NFUEFSQVRPUiAuICRhcmdzWyRpXTsKCQkJfQoJCX0KCQlyZXR1cm4gJHBhdGg7Cgl9Cn0KCj8+]]></data>
	</file>
	<file>
	  <filename>/index.html</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[]]></data>
	</file>
	<file>
	  <filename>/lang/</filename>
	  <isdir>1</isdir>
	</file>
	<file>
	  <filename>/lang/en_US.php</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[<?php

/**
*------------------------------------------------------
* General begin
*------------------------------------------------------
*/
$lang['module_friendlyname'] = 'Guestbook';
$lang['default_guestbook_name'] = 'default';
$lang['default_guestbook_descr'] = 'The first/default guestbook';
$lang['module_example_stylesheet'] = 'Guestbook (default/example stylesheet)';
$lang['module_example_stylesheet_intro'] = 'Default/example stylesheet for the CMSMS Guestbook module.
This may be overwritten when the module is upgraded and it will be deleted when 
the module is uninstalled, so make a copy if you want to modify it.';
$lang['captcha'] = 'Captcha';
$lang['captcha_title'] = 'Please enter the text in the image below';
$lang['captcha_failure_message'] = 'The text from the image was not entered correctly';
$lang['timespan'] = 'Minimal timespan between posts';
$lang['err_invalid_mode'] = "Error: an invalid mode parameter was specified. Valid modes are: %s.";
$lang['err_no_entry_id'] = "Error: no entry_id parameter given. With mode=entry a entry_id parameter should also be specified.";
$lang['err_entry_not_found'] = "Error: there is no guestbook entry with entry_id %s";
$lang['error_template_filenotfound'] = "Error: template file %s could not be found!";

/**
*------------------------------------------------------
* General end
*------------------------------------------------------
*/

/**
*------------------------------------------------------
* Guestbook begin
*------------------------------------------------------
*/
$lang['default']  = 'Default';
$lang['add_guestbook'] = 'Create a new guestbook';
$lang['adding_guestbook'] = 'Add a new guestbook';
$lang['editing_guestbook'] = 'Edit existing guestbook';
$lang['set_as_default'] = 'Set as default';
$lang['confirm_set_as_default'] = 'Set this guestbook as the default?';
$lang['confirm_delete_guestbook'] = 'Delete the guestbook with ID %s? The %s entries inside will be deleted as well!';
/**
*------------------------------------------------------
* Guestbook entry begin
*------------------------------------------------------
*/
$lang['id']       = 'Id';
$lang['date']     = 'Date';
$lang['sender']   = 'Sender';
$lang['email']    = 'E-mail';
$lang['country']  = 'Country';
$lang['location'] = 'Location';
$lang['homepage'] = 'Homepage';
$lang['message']  = 'Message';
$lang['posted']   = 'Posted';
$lang['ip_addr']  = 'IP Address';

$lang['alength']  = 'Remaining chars';
$lang['active']   = 'Active';
/**
*------------------------------------------------------
* Guestbook entry end
*------------------------------------------------------
*/

/**
*------------------------------------------------------
* Admin related begin
*------------------------------------------------------
*/

$lang['access_denied'] = 'Access Denied';

$lang['restore_to_defaults'] = 'Restore to default';
$lang['restore_to_defaults_warning'] = 'This operation will restore the template contents to the system default. This will overwrite any changes made to the template. Are you sure you want to procede?';

$lang['addgait']  = 'Add Guestbook Entry';
$lang['postdate'] = 'Postdate';

$lang['ativi']    = 'Activate';
$lang['deakti']   = 'Deactivate';

// admin navigation
$lang['title_mod_admin']    = 'Manage Guestbook Entries';
$lang['tabname_guestbooks'] = 'Guestbooks';
$lang['tabname_entries'] = 'Entries';
$lang['title_mod_templates'] = 'Templates';
$lang['tabname_settings'] = 'Module Preferences';
$lang['title_tab_admin_templates'] = 'Guestbook Templates';
$lang['title_tab_admin_template'] = 'Guestbook Template';
$lang['title_tab_admin_entrylist_template'] = 'Entry List Template';
$lang['title_tab_admin_entry_template'] = 'Entry Template';
$lang['title_tab_admin_form_template']      = 'Form Template';
$lang['title_tab_admin_email_template']      = 'E-mail Template';
$lang['title_tab_admin_showform_button_template'] = 'Show Form Template';
// end admin navigation

$lang['templatecontent'] = 'Template Content';
$lang['admin_template_modified_logmessage'] = 'Modified Guestbook Template';
$lang['admin_template_restored_logmessage'] = 'Restored Guestbook Template To Default';

$lang['admin_entry_added_logmessage']       = 'Added Guestbook Entry';
$lang['admin_entry_modified_logmessage']    = 'Modified Guestbook Entry';
$lang['admin_entry_deleted_logmessage']     = 'Deleted Guestbook Entry';
$lang['admin_entry_activated_logmessage']   = 'Activated Guestbook Entry';
$lang['admin_entry_deactivated_logmessage'] = 'Deactivated Guestbook Entry';

$lang['admin_entry_message_nosender'] = 'Please enter a sender name';
$lang['wrong_date_format'] = 'Date format should have the format: YYYY-MM-DD HH:MM:SS';
$lang['fieldnames'] = 'Field Names';

$lang['captcha_module_installed'] = 'The Captcha module is installed';
$lang['captcha_module_not_installed'] = 'The Captcha module is not installed';

$lang['smileys_module_installed'] = 'The Smileys module is installed';
$lang['smileys_module_not_installed'] = 'The Smileys module is not installed';

$lang['preferences_title'] = 'Guestbook Preferences';
//$lang['cap'] = ;
$lang['admin_wysiwyg_title'] = 'Use WYSIWYG on the  guestbook entry form';
$lang['searchsmileys_title'] = 'Use smileys in search results';
$lang['save_settings'] = 'Save Settings';
$lang['settings_saved'] = 'The settings were successfully updated.';
$lang['badwords_title'] = 'Words that are not allowed';
$lang['badwords_replacement_title'] = 'Replace bad words with';
$lang['admin_entries_per_page_title'] = 'Entries per page (admin)';

$lang['description'] = 'Description';

/**
*------------------------------------------------------
*Admin related end
*------------------------------------------------------
*/

/**
*------------------------------------------------------
*Contenttype related begin
*------------------------------------------------------
*/
$lang['nummer'] = 'Number of messages per page';
$lang['postchar'] = 'Maximum message size';
$lang['emailnot'] = 'Notification email';
$lang['sortasc'] = 'Sort ascending (ASC)';
$lang['smile'] = 'Smiley';
$lang['shmenow'] = 'Show message immediately';
$lang['datefora'] = 'Date format';
$lang['lang'] = 'Locale (e.g. en_US)';
$lang['showaddform'] = 'Show insert form immediately';
/**
*------------------------------------------------------
*Contenttype related end
*------------------------------------------------------
*/

/**
*------------------------------------------------------
*Visitor related begin
*------------------------------------------------------
*/
$lang['fabsend'] = "Please insert your name"; // used after empty name submit
$lang['fmessag'] = "Please insert a message"; // used after empty message submit
$lang['femail'] = "Please insert a valid E-Mail address";
$lang['tolong'] = "Too many characters. Please make the message shorter.";
$lang['toosoon'] = "Your last post was only %s seconds ago. The minimal timespan between posts is %s seconds";
$lang['fui'] = "Your message was already sent";
$lang['badwords_message'] = "These words are not allowed: %s";
$lang['showitnow'] = "Your message was inserted. Thank you!";
$lang['showitlater'] = "Thank you! The message will appear after it's validated by administrator.";
$lang['msg_back'] = 'back';
	
$lang['inam'] = "Name";
$lang['imessag'] = "Your Message";
$lang['smessage'] = "Message";
$lang['sdate'] = "Date";
$lang['ginsert'] = "Insert";
$lang['cancel'] = "Cancel";
$lang['uhr'] = "hour";
$lang['e_mailnotibetr'] = "New Entry in your Guestbook";
$lang['e_mailnotimessage'] = "There's a new entry in your guestbook.";
	
$lang['neuein'] = "New Guestbook entry";
$lang['einerseit'] = "one Page";
$lang['eintragauf'] = "Posts on";
$lang['seitpage'] = "Pages";
$lang['backzu'] = "&lt;&lt; Back";
$lang['nextwei'] = "Next &gt;&gt;";

// Pagination
$lang['first_text'] = "&iota;&lsaquo;";
$lang['prev_text'] = "&lt; prev";
$lang['next_text'] = "next &gt;";
$lang['last_text'] = "&rsaquo;&iota;";
$lang['pagination_of'] = "of";
	
$lang['title_table_smileys'] = "Smileys";
/**
*------------------------------------------------------
*Visitor related end
*------------------------------------------------------
*/

/**
*------------------------------------------------------
*Confirmmessage begin
*------------------------------------------------------
*/
$lang['ativimes']= 'Activate this message?';
$lang['deaktimes']= 'Deactivate this message?';
/**
*------------------------------------------------------
*Confirmmessage end
*------------------------------------------------------
*/

/**
*------------------------------------------------------
*Events begin
*------------------------------------------------------
*/
$lang['event_info_GuestbookEntryPosted']='Event triggered when a new Guestbook entry is added';
$lang['event_help_GuestbookEntryPosted']='<p>Event triggered when a new Guestbook entry is added.</p>
  	 <h4>Parameters</h4>
  	 <ul>
		<li><em>entry_id</em> - The entry id (int)</li>
		<li><em>entry_sender</em> - The name the sender entered (string)</li>
		<li><em>entry_email</em> - The E-mail address entered (string)</li>
		<li><em>entry_homepage</em> - The homepage entered (string)</li>
		<li><em>entry_message</em> - The message entered (string)</li>
		<li><em>entry_country</em> - The country entered (string)</li>
		<li><em>entry_location</em> - The location entered (string)</li>
		<li><em>entry_date</em> - The post date (string)</li>
		<li><em>entry_approved</em> - Whether the entry is activated at once, 1 if it is, -1 if not (int)</li>
  	 </ul>
';
$lang['event_info_GuestbookEntryDeleted'] = 'Event triggered when a Guestbook entry is deleted';
$lang['event_help_GuestbookEntryDeleted'] = 'Event triggered when a Guestbook entry is deleted
  	 <h4>Parameters</h4>
  	 <ul>
	  	 <li><em>entry_id</em> - The entry id (int)</li>
  	 </ul>
';
$lang['event_info_GuestbookEntryActivated'] = 'Event triggered when a Guestbook entry is activated';
$lang['event_help_GuestbookEntryActivated'] = 'Event triggered when a Guestbook entry is activated
  	 <h4>Parameters</h4>
  	 <ul>
  	 <li><em>entry_id</em> - The entry id (int)</li>
  	 </ul>
';
$lang['event_info_GuestbookEntryDeactivated'] = 'Event triggered when a Guestbook entry is de-activated';
$lang['event_help_GuestbookEntryDeactivated'] = 'Event triggered when a Guestbook entry is de-activated
  	 <h4>Parameters</h4>
  	 <ul>
  	 <li><em>entry_id</em> - The entry id (int)</li>
  	 </ul>
';

/**
*------------------------------------------------------
*Events end
*------------------------------------------------------
*/


/**
*------------------------------------------------------
*Install & Uninstall & Help & Changelog begin
*------------------------------------------------------
*/
$lang['inposmes']       = 'Make sure to set the "Modify Guestbook Entries" permission for users who will be administering Guestbook items and "Modify Guestbook Template" permission for users who should be able to modify the guestbook template.<br />Attach the Stylesheet named "%s" to the template used to style the guestbook.';
$lang['moddescription'] = 'Manage the guestbook entries and template.';
$lang['uninstall_pre_message'] = 'The %s entries in your guestbook will be permanently deleted!';
$lang['uninstall_pre_message_single'] = 'There is 1 entry in your guestbook that will be permanently deleted!';
$lang['postuninstall']  = 'Guestbook successfully uninstalled.';

/**
* Module parameters begin
*/
$lang['help_mode'] = '"guestbook", "form", "entrylist" or "entry"';
$lang['help_show_entry'] = 'ID of an entry to show (mode="entry" is assumed)';
$lang['help_guestbook'] = 'Guestbook ID';
$lang['help_textleng'] = 'Sets how many characters can be entered. The default is 1000 characters. This parameter affects both server-side and client-side validation.';
$lang['help_number'] = 'Maximum number of entries shown on a page.';
$lang['help_timespan'] = 'Minimal timespan between posts (in seconds).';
$lang['hide_insertbutton_after_post'] = 'When post is done, insert button will not be displayed.';
$lang['help_mailnoti'] = 'E-mail address to send a notification to if a message was submitted. The CMSMailer module will be used for sending the E-mail if it is installed (otherwise PHP\'s mail function is used).';
$lang['help_sortasc'] = 'Sort guestbook items in ascending date order (new posts will go to the end).';
$lang['help_dateformat'] = 'Change the way the Date will display, it takes the PHP format codes';
$lang['help_shownow'] = 'Shows messages right after submission, without approval by an admin.';
$lang['help_smiley'] = 'Translate text-based smileys to image smileys and shows the smiley table on the entry submit form. Uses the Smiley module if it is installed.';
$lang['help_captcha'] = 'This will enable captcha on the guestbook entry form. The Captcha module must be installed for this parameter to work.';
$lang['help_showaddform'] = 'Shows the insert form on the first page.  Replaces the "New Guestbook Entry" button.';
/**
* Module parameters end
*/

$lang['help'] = <<<EOF

<h3>What does it do?</h3>
<p>
    The guestbook module is a content module and a CMSMS tagmodule.
    It gives visitors the ability to leave a message, for example about how they like the website.
</p>

<h3>Security</h3>
<p>
    The user must belong to a group with the 'Modify Guestbook Entries' permission in order to add, edit, or delete guestbook entries.<br />
    In order to be able to modify the guestbook entry template, 'Modify Guestbook Template' permission is required.
</p>

<h3>How do I use it?</h3>
<p>
    The easiest way is to create a new page and change the "Content Type" to Guestbook. This way you will be able to set the guestbook options as page properties.<br />
    If you want to add the module after some other content you can insert it using the cms_module tag. This will insert the guestbook into your template/page anywhere you wish.<br /> 
    The code would look something like: <code>{cms_module module="Guestbook" number=5 shownow=0 smiley=0 mailnoti=you@example.com dateformat="%d-%m-%Y %H:%M"}</code>
</p>

<h3>What Design potentials are there?</h3>

<p>
    An example stylesheet for the default database template is installed with the module.<br />
    The default stylesheet is deleted when the module is uninstalled and may be overwitten by an upgrade, so you might want to use a copy if you modify it.<br />
    Attach the stylesheet to the page template used.
</p>

<p>
    Most templates used on the module front-end are stored in the database and can be edited from the admin panel.
</p>
<p>
    In the module directory there's a directory called templates where all other templates are stored. You can modify these to fit your needs:
</p>

<strong>Administration</strong>
<p>
admin_entries_top.tpl -> The paganition and row names for the entry list.<br/>
admin_entries_entry.tpl -> The template for an entry in the list of guestbook entries.<br/>
admin_entries_bottom.tpl -> The bottom of the guestbook entries admin form.<br />
admin_entry.tpl-> The form used to insert or edit guestbook entries.<br/>
admin_template_edit.tpl -> Used for editing the guestbook entry database template.
</p>

<strong>Front End</strong>
<p>
smiley.tpl -> The smiley table, used when the smiley parameter is used and the Smileys module is not installed.<br/>
</p>

<p>
    Inside the template directory there's a directory called db. This stores the guestbook database templates, which can be edited from the Guestbook admin area.
	The contents of these files is copied to the database during module installation and when a template is restored to default from the admin panel.<br />
	By default the files that come with the module (names ending with -default.tpl) are used, but if a (custom) file is present where -default is left out in the name, this file will be used instead.
</p>

EOF
;

$lang['changelog']='
<ul>
	<li>
		<strong>Version 1.3.0</strong><br />
        <span style="color:#FF0000;font-style:italic;display:block;">You have to reset your Guestbook templates when upgrade to this version.</span>
		Fixes:
		<ul>
            <li><span style="font-weight: bold;">Content type is now USABLE</span></li>
			<li>Fixed page printing in random</li>
            <li>Fixed XSS security issue in next parameter (Pagination class)</li>
            <li>Fixed message list table who can be broken by HTML in message</li>
            <li><span style="font-style:italic;font-weight: bold;">Now fully compatible with CMSMS 1.8</span></li>
		</ul>
        Improvements:
        <ul>
            <li>Content type: More date format</li>
            <li>Prettier URL</li>
            <li>Some translation and admin display improvements</li>
            <li>Completely rewrited Pagination module (faster and more secure)</li>
        </ul>
        New Feature:
        <ul>
            <li>Smiley in Front Wysiwyg</li>
            <li>Front date format can be specified in GetDate() in <a href="http://php.net/manual/en/function.date.php">php format</a> (not english only)</li>
            <li>Front date format is now using smarty to get multilanguage capability - date format should be set as <a href="http://www.smarty.net/manual/en/language.modifier.date.format.php">smarty format</a></li>
            <li>Possibility to select all current entry</li>
            <li>Pagination rewrited to be more speed and usefull</li>
            <li>Managing in which guestbook is the entry</li>
            <li>Multiple destination for notification mail</li>
        </ul>
        Minor fixes:
        <ul>
            <li>W3 proof for Javascript</li>
            <li>Few PHP Notices and warnings</li>
        </ul>
	</li>
	<li>
		<strong>Version 1.1.12</strong><br />
		Fixes:
		<ul>
			<li>Fixed bug when posting a new entry with mod_rewrite on (Thanks to blast2007)</li>
			<li>Fixed incorrect stripping of quotes returned by GetTimestamp</li>
		</ul>
	</li>
	<li>
		<strong>Version 1.1.11</strong><br />
		Fixes:
		<ul>
			<li>Fixed module compatibility with latest CMS Made Simple versions (1.5+)</li>
			<li>Fixed pagination not using full table width</li>
			<li>Fixed some small bugs adding/editing an guestbook entry</li>
			<li>Fixed special characters in (translated) pre-uninstall message(s) not being shown correctly</li>
			<li>Fixed language setting from CMS Made Simple Global Settings not being applied</li>
		</ul>
		Improvements:
		<ul>
			<li>You can now edit a guestbook entry date in the backend</li>
			<li>The number of entries shown per page in the backend is now configurable</li>
		</ul>
	</li>
	<li>
		<strong>Version 1.1.10</strong>
		<ul>
			<li>FIX: Removed this warning from the admin panel: "Warning: vsprintf() [function.vsprintf]: Too few arguments in /home/mywebsite/public_html/lib/translation.functions.php on line 62"</li>
			<li>FIX: Insert of new entries failed, when none mandatory fields were removed from the form.</li>
			<li>FIX: Pagination created invalid XHTML (Text attribute removed)</li>
			<li>CHG: Smileys are now inserted on click via JavaScript. Plain text smileys moved into hint.</li>
			<li>FIX: Wrong encoding and HTML entities in notification emails.</li>
			<li>FIX: Enabled translation for pagination "First" and "Last".</li>
			<li>CHG: Update SmartyPaginate from 1.5 to 1.6-dev</li>
			<li>FIX: Wrong language field "e_mail" in email notification.</li>
			<li>FIX: Module CMSMailer was not detected/used on PHP4</li>
		</ul>
	</li>
	<li>
		<strong>Version 1.1.9</strong>
		<ul>
			<li>Prevent an E-mail being sent to no address when the mailnoti parameter is not being used</li>
		</ul>
	</li>
	<li>
		<strong>Version 1.1.8</strong>
		<ul>
			<li>Fixed too short ip_address field</li>
			<li>Moved templates to a single tab in the admin</li>
		</ul>
	</li>
	<li>
		<strong>Version 1.1.7</strong>
		<ul>
			<li>Fixed references to old file locations</li>
			<li>Fixed Javascript warning when WYSIWYG is used</li>
		</ul>
	</li>
	<li>
		<strong>Version 1.1.6</strong>
		<ul>
			<li>Fixed character counter not working with FCKeditor</li>
			<li>Moved errormessage to lang file</li>
			<li>Deleted some redundant files</li>
		</ul>
	</li>
	<li>
		<strong>Version 1.1.5</strong>
		<ul>
			<li>Fixed ModuleIsInstalled method always returning false for admin modules/FCKEditorX</li>
			<li>Fixed character counter always starting at 1000</li> 
		</ul>
	</li>
	<li>
		<strong>Version 1.1.4</strong>
		<ul>
			<li>Fixes breaks in messages not showing in 1.1.3</li>
			<li>Added (optional) basic WYSIWYG on the Guestbook entry form</li>
			<li>Added logging of guestbook entry sender IP address</li>
			<li>Added "Modify Guestbook Settings" permission</li>
		</ul>
	</li>
	<li>
		<strong>Version 1.1.3</strong>
		<ul>
			<li>Improved pagination</li>
			<li>Rewrote front-end code to use Smarty for all output</li>
			<li>The front-end Smarty templates now use arrays</li>
			<li>Made most front-end templates editable from the admin</li>
			<li>Added events</li>
			<li>Added bad word filter</i>
		</ul>
	</li>
	<li>
		<strong>Version 1.1.2</strong>
		<ul>
			<li>Fixed a bug where the Next button would show when it shouldn\'t</li>
			<li>Any guestbook content is deleted on uninstall to prevent fatal errors in cmsmadesimple-1.x</li>
		</ul>
	</li>
	<li>
		<strong>Version 1.1.1</strong>
		<ul>
			<li>Compatiblity changes for cmsmadesimple-1.0 and a small bugfix</li>
		</ul>
	</li>
	<li>
		<strong>Version 1.1</strong>
		<ul>
			<li>Added Captcha support (in a seperate Captcha module)</li>
			<li>Added timespan parameter (minimal timespan between posts)</li>
			<li>Added location field (for State/Province/City/Town)</li>
			<li>Make use of the Smiley module if it is installed</li>
			<li>Made the module compatible with the cmsmadesimple-1.0 series</li>
			<li>Minimal required CMS version changed to 0.13</li>
		</ul>
	</li>
	<li>
		<strong>Version 1.0</strong>
		<ul>
			<li>Renamed module (from gastbuch) to Guestbook to represent the projects natural language and follow CMS Made Simple module naming conventions.</li>
			<li>Enabled handling (deleting, activating and deactivating) of multiple guestbook entries from the admin panel.</li>
			<li>There are now seperate \'Modify Guestbook Entries\' and \'Modify Guestbook Template\' permissions.</li>
			<li>A default/example stylesheet is installed (and uninstalled) with the module.</li>
			<li>The database template can be restored to default.</li>
			<li>Changed to tabbed navigation.</li>
			<li>Cleanup/rewrite of the guestbook(item) database template and the variables used in it.</li>
			<li>Translated many variable names and code comments to english.</li>
			<li>Moved some admin and log messages to the language file.</li>
			<li>Re-formatted source code for better readability.</li>
			<li>The module now also works in combination with a PostgreSQL database.</li>
			<li>Changed the input format for the dateformat parameter from MySQL format to PHP format.</li>
			<li>A new variable is assigned to the (database) guestbookentry template: $e_mail_cloaked. This is the E-mail address, with @ replaced by &lt;at&gt; and . by &lt;dot&gt;.</li>
			<li>Extended the notification E-mail, it now sends the new guestbook entry in the notification message.</li>
			<li>New finnish translation and updated dutch and norwegian translations from the translation center.</li>
		</ul>
	</li>
	<li>
		<strong>Version 0.9</strong>
		<ul>
			<li>The guestbook frontend now uses a database template (in stead of the showmessage*.tpl files) that can be modified from the admin panel</li>
			<li>The dateformat parameter is now called dateformat (was dateform). Note: this means you will have to recreate any guestbook content pages or manually edit the tables cms_content and cms_content_props</li>
			<li>New french translation and modified translations for other languages from the translation center</li>
		</ul>
	</li>
	<li>
		<strong>Version 0.8</strong><br />
		Fixed:
		<ul>
			<li>not working smileys on gastbuch Content page in version 0.7</li>
		</ul>
		Cleanup:
		<ul>
			<li>mainly removal of unneccary references to the global $gCms</li>
			<li>renamed email textfield to e_mail (it was called betreff, probably an old subject field)</li>
		</ul>
		Improvements:
		<ul>
			<li>newly submitted newsentry is shown in the list</li>
			<li>brackets around submitter country are no longer shown if a country wasn\'t entered</li>
			<li>translated the lang file to dutch (except for help and changelog)</li>
			<li>the gastbuch module now makes use of translations entered in the translation center translations.cmsmadesimple.org</li>
		</ul>
		Changed:
		<ul>
			<li>The template variable name for the country in showmessage.tpl is now called $country (was $countryshow in previous versions)</li>
		</ul>
	</li>
	<li>
		<strong>Version 0.7</strong>
		<ul>
			<li>Added lang attribute to support multiple locales</li>
			<li>Show insert form on the first page</li>
			<li>Fixed bug with textlength javascript not working</li>
			<li>Fixed a few minor bugs</li>
		</ul>
	</li>
	<li>
		<strong>Version 0.6</strong>
		<ul>
			<li>Redesigned source code for better readability</li>
			<li>Added lang attribute to support multiple locales</li>
			<li>Added showaddform parameter</li>
			<li>Fixed bug with textlength javascript not working in case of "Content" content type</li>
			<li>Merged vorzu and backzu templates into one</li>
			<li>Added template success_message.tpl</li>
			<li>Fixed a few minor bugs caused by mismatches in lang variable names</li>
		</ul>
	</li>
	<li>
		<strong>Version 0.5</strong>
		<ul>
			<li>The guestbook was modified with better design and functions, for example: Template based Content, Spam protection for inserted e-mails, etc.</li>
		</ul>
	</li>
	<li>
		<strong>Version 0.4</strong>
		<ul>
			<li>The gastbuch module is now a new module</li>
		</ul>
	</li>
</ul>
';
/**
*------------------------------------------------------
*Install & Uninstall & Help & Changelog end
*------------------------------------------------------
*/
?>
]]></data>
	</file>
	<file>
	  <filename>/lang/ext/</filename>
	  <isdir>1</isdir>
	</file>
	<file>
	  <filename>/lang/ext/cs_CZ.php</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[<?php
$lang['module_friendlyname'] = 'Kniha n&aacute;v&scaron;těv (Guestbook)';
$lang['default_guestbook_name'] = 'v&yacute;choz&iacute;';
$lang['default_guestbook_descr'] = 'Prvn&iacute; / v&yacute;choz&iacute; kniha n&aacute;v&scaron;těv';
$lang['module_example_stylesheet'] = 'Kniha n&aacute;v&scaron;těv (&uacute;vodn&iacute; styl - př&iacute;klad)';
$lang['module_example_stylesheet_intro'] = 'V&yacute;choz&iacute; kask&aacute;dov&yacute; styl pro CMSMS modul Guestbook. Může b&yacute;t přeps&aacute;n v př&iacute;padě upgrade mudulu a bude vymaz&aacute;n při odinstalov&aacute;n&iacute; modulu, proto si pros&iacute;m vždy vytvořte kopii, pokud jej chcete modifikovat.';
$lang['captcha'] = 'Captcha';
$lang['captcha_title'] = 'Pros&iacute;m vložte text z obr&aacute;zku dole:';
$lang['captcha_failure_message'] = 'Text z obr&aacute;zku nebyl ops&aacute;n spr&aacute;vně';
$lang['timespan'] = 'Minim&aacute;ln&iacute; přest&aacute;vka mezi př&iacute;spěvky.';
$lang['err_invalid_mode'] = 'Chyba: byl vložen neplatn&yacute; parametr m&oacute;du. Platn&eacute; m&oacute;dy jsou: %s.';
$lang['err_no_entry_id'] = 'Chyba: parametr entry_id nebyl zad&aacute;n. V m&oacute;du mode=entry mus&iacute; b&yacute;t parametr entry_id zad&aacute;n.';
$lang['err_entry_not_found'] = 'Chyba: ž&aacute;dn&aacute; kniha n&aacute;v&scaron;těv (guestbook) nem&aacute; entry_id %s';
$lang['error_template_filenotfound'] = 'Chyba: soubor &scaron;ablon %s nebyl nalezen!';
$lang['default'] = 'V&yacute;choz&iacute;';
$lang['add_guestbook'] = 'Vytvořit novou knihu n&aacute;v&scaron;těv';
$lang['adding_guestbook'] = 'Přidat novou knihu n&aacute;v&scaron;těv';
$lang['editing_guestbook'] = 'Upravit existuj&iacute;c&iacute; knihu n&aacute;v&scaron;těv';
$lang['set_as_default'] = 'Nastavit jako v&yacute;choz&iacute;';
$lang['confirm_set_as_default'] = 'Nastavit tuto knihu n&aacute;v&scaron;těv jako v&yacute;choz&iacute;?';
$lang['confirm_delete_guestbook'] = 'Smazat knihu n&aacute;v&scaron;těv s ID %s? Vymaz&aacute;ny budou tak&eacute; v&scaron;echny vzkazy v t&eacute;to knize!';
$lang['id'] = 'Id';
$lang['date'] = 'Datum';
$lang['sender'] = 'Odes&iacute;latel';
$lang['email'] = 'E-mail';
$lang['country'] = 'St&aacute;t';
$lang['location'] = 'M&iacute;sto';
$lang['homepage'] = 'WWW str&aacute;nka';
$lang['message'] = 'Zpr&aacute;va';
$lang['posted'] = 'Odesl&aacute;no';
$lang['ip_addr'] = 'IP Addresa';
$lang['alength'] = 'Zb&yacute;vaj&iacute;c&iacute; znaky';
$lang['active'] = 'Aktivn&iacute;';
$lang['access_denied'] = 'Př&iacute;stup zak&aacute;z&aacute;n';
$lang['restore_to_defaults'] = 'Obnovit původn&iacute; hodnoty';
$lang['restore_to_defaults_warning'] = 'Tato operace obnov&iacute; obsah datab&aacute;ze do původn&iacute; podoby, v&scaron;echny Va&scaron;e změny  budou smaz&aacute;ny. Jste si jisti, že chcete pokračovat?';
$lang['addgait'] = 'Přidat vzkaz';
$lang['postdate'] = 'Datum odesl&aacute;n&iacute;';
$lang['ativi'] = 'Aktivovat';
$lang['deakti'] = 'Deaktivovat';
$lang['title_mod_admin'] = 'Spravovat vzkazy Knihy n&aacute;v&scaron;těv';
$lang['tabname_guestbooks'] = 'Knihy n&aacute;v&scaron;těv';
$lang['tabname_entries'] = 'Vzkazy';
$lang['title_mod_templates'] = '&Scaron;ablony';
$lang['tabname_settings'] = 'Nastaven&iacute; modulu';
$lang['title_tab_admin_templates'] = '&Scaron;ablony knihy n&aacute;v&scaron;těv';
$lang['title_tab_admin_template'] = '&Scaron;ablona knihy n&aacute;v&scaron;těv';
$lang['title_tab_admin_entrylist_template'] = '&Scaron;ablona seznamu př&iacute;spěvků';
$lang['title_tab_admin_entry_template'] = '&Scaron;ablona vložen&iacute; př&iacute;spěvku';
$lang['title_tab_admin_form_template'] = '&Scaron;ablona formul&aacute;ře';
$lang['title_tab_admin_email_template'] = '&Scaron;ablona e-mailu';
$lang['title_tab_admin_showform_button_template'] = 'Uk&aacute;zat &scaron;ablonu formul&aacute;ře';
$lang['templatecontent'] = 'Obsah &scaron;ablony';
$lang['admin_template_modified_logmessage'] = 'Upraven&aacute; &scaron;ablona Knihy n&aacute;v&scaron;těv.';
$lang['admin_template_restored_logmessage'] = '&Scaron;ablony Knihy n&aacute;v&scaron;těv byla obnovena do původn&iacute;ho stavu';
$lang['admin_entry_added_logmessage'] = 'Přid&aacute;n vzkaz';
$lang['admin_entry_modified_logmessage'] = 'Upraven vzkaz';
$lang['admin_entry_deleted_logmessage'] = 'Smaz&aacute;n vzkaz';
$lang['admin_entry_activated_logmessage'] = 'Aktivov&aacute;n vzkaz';
$lang['admin_entry_deactivated_logmessage'] = 'Deaktivov&aacute;n vzkaz';
$lang['admin_entry_message_nosender'] = 'Pros&iacute;m vložte sv&eacute; jm&eacute;no';
$lang['wrong_date_format'] = 'Datum by mělo b&yacute;t ve form&aacute;tu: YYYY-MM-DD HH:MM:SS';
$lang['fieldnames'] = 'Jm&eacute;na pol&iacute;';
$lang['captcha_module_installed'] = 'Modul Captcha je nainstalov&aacute;n';
$lang['captcha_module_not_installed'] = 'Modul Captcha nen&iacute; nainstalov&aacute;n';
$lang['smileys_module_installed'] = 'Modul Smileys je nainstalov&aacute;n';
$lang['smileys_module_not_installed'] = 'Modul Smileys nen&iacute; nainstalov&aacute;n';
$lang['preferences_title'] = 'Nastaven&iacute; knihy n&aacute;v&scaron;těv';
$lang['admin_wysiwyg_title'] = 'Použ&iacute;t WYSIWYG při editaci knihy';
$lang['searchsmileys_title'] = 'Použ&iacute;t smajl&iacute;ky ve v&yacute;sledc&iacute;ch vyhled&aacute;v&aacute;n&iacute;';
$lang['save_settings'] = 'Uložit nastaven&iacute;';
$lang['settings_saved'] = 'Nastaven&iacute; byla &uacute;spě&scaron;ně upravena.';
$lang['badwords_title'] = 'Slova, kter&aacute; nejsou povolena';
$lang['badwords_replacement_title'] = 'Nahradit nepovolen&aacute; slova:';
$lang['admin_entries_per_page_title'] = 'Př&iacute;spěvků na str&aacute;nku (administračn&iacute; rozhran&iacute;)';
$lang['description'] = 'Popis';
$lang['nummer'] = 'Počet vzkazů na str&aacute;nku';
$lang['postchar'] = 'Maxim&aacute;ln&iacute; d&eacute;lka zpr&aacute;vy';
$lang['emailnot'] = 'Upozorňuj&iacute;c&iacute; e-mail';
$lang['sortasc'] = 'Seřadit vzestupně (ASC)';
$lang['smile'] = 'Smajl&iacute;k';
$lang['shmenow'] = 'Uk&aacute;zat zpr&aacute;vu hned';
$lang['datefora'] = 'Form&aacute;t data';
$lang['lang'] = 'Locale (např. en_US)';
$lang['showaddform'] = 'Zobrazit formul&aacute;ř pro zad&aacute;n&iacute; vzkazu př&iacute;mo pod vzkazy';
$lang['fabsend'] = 'Pros&iacute;m vložte sv&eacute; jm&eacute;no';
$lang['fmessag'] = 'Pros&iacute;m vložte zpr&aacute;vu';
$lang['femail'] = 'Pros&iacute;m vložte platnou e-mailovou adresu';
$lang['tolong'] = 'Př&iacute;li&scaron; mnoho znaků. Pokuste se pros&iacute;m vzkaz zkr&aacute;tit.';
$lang['toosoon'] = 'Posledn&iacute; vzkaz jste poslali jen před %s vteřinami. Minim&aacute;ln&iacute; přest&aacute;vka mezi vzkazy je %s vteřin';
$lang['fui'] = 'Va&scaron;e zpr&aacute;va byla pr&aacute;vě odesl&aacute;na.';
$lang['badwords_message'] = 'Tato slova nejsou povolena: %s';
$lang['showitnow'] = 'Va&scaron;e zpr&aacute;va byla vložena';
$lang['showitlater'] = 'Děkujeme za vzkaz! Zpr&aacute;va se objev&iacute; po prověřen&iacute; spr&aacute;vcem.';
$lang['msg_back'] = 'Zpět do knihy';
$lang['inam'] = 'Jm&eacute;no';
$lang['imessag'] = 'Va&scaron;e zpr&aacute;va';
$lang['smessage'] = 'Zpr&aacute;va';
$lang['sdate'] = 'Datum';
$lang['ginsert'] = 'Vložit';
$lang['cancel'] = 'Zru&scaron;it';
$lang['uhr'] = 'hodin';
$lang['e_mailnotibetr'] = 'Nov&yacute; vzkaz do knihy';
$lang['e_mailnotimessage'] = 'Do knihy přibyl nov&yacute; vzkaz';
$lang['neuein'] = 'Nov&yacute; vzkaz';
$lang['einerseit'] = 'jedna Str&aacute;nka';
$lang['eintragauf'] = 'Vzkazy na';
$lang['seitpage'] = 'Str&aacute;nk&aacute;ch';
$lang['backzu'] = '&amp;lt;&amp;lt; Zpět';
$lang['nextwei'] = 'Dal&scaron;&iacute; &amp;gt;&amp;gt;';
$lang['first_text'] = '<<';
$lang['prev_text'] = '< předchoz&iacute;';
$lang['next_text'] = 'dal&scaron;&iacute; >';
$lang['last_text'] = '>>';
$lang['pagination_of'] = 'z';
$lang['title_table_smileys'] = 'Smajl&iacute;ky';
$lang['ativimes'] = 'Aktivovat tento vzkaz?';
$lang['deaktimes'] = 'Deaktivovat tento vzkaz?';
$lang['event_info_GuestbookEntryPosted'] = 'Ud&aacute;lost spu&scaron;těna, když byla přid&aacute;na nov&aacute; položka Knihy n&aacute;v&scaron;těv.';
$lang['event_help_GuestbookEntryPosted'] = '<p>Event triggered when a new Guestbook entry is added.</p>
  	 <h4>Parameters</h4>
  	 <ul>
		<li><em>entry_id</em> - The entry id (int)</li>
		<li><em>entry_sender</em> - The name the sender entered (string)</li>
		<li><em>entry_email</em> - The E-mail address entered (string)</li>
		<li><em>entry_homepage</em> - The homepage entered (string)</li>
		<li><em>entry_message</em> - The message entered (string)</li>
		<li><em>entry_country</em> - The country entered (string)</li>
		<li><em>entry_location</em> - The location entered (string)</li>
		<li><em>entry_date</em> - The post date (string)</li>
		<li><em>entry_approved</em> - Whether the entry is activated at once, 1 if it is, -1 if not (int)</li>
  	 </ul>
';
$lang['event_info_GuestbookEntryDeleted'] = 'Ud&aacute;lost spu&scaron;těna, když položka Knihy n&aacute;v&scaron;těv byla maz&aacute;na';
$lang['event_help_GuestbookEntryDeleted'] = 'Ud&aacute;lost spu&scaron;těna, když položka Knihy n&aacute;v&scaron;těv byla maz&aacute;na
  	 <h4>Parametry</h4>
  	 <ul>
	  	 <li><em>entry_id</em> - The entry id (int)</li>
  	 </ul>
';
$lang['event_info_GuestbookEntryActivated'] = 'Ud&aacute;lost spu&scaron;těna, když položka Knihy n&aacute;v&scaron;těv byla aktivov&aacute;na';
$lang['event_help_GuestbookEntryActivated'] = 'Ud&aacute;lost spu&scaron;těna, když položka Knihy n&aacute;v&scaron;těv byla aktivov&aacute;na
  	 <h4>Parametry</h4>
  	 <ul>
  	 <li><em>entry_id</em> - The entry id (int)</li>
  	 </ul>
';
$lang['event_info_GuestbookEntryDeactivated'] = 'Ud&aacute;lost spu&scaron;těna, když položka Knihy n&aacute;v&scaron;těv byla deaktivov&aacute;na';
$lang['event_help_GuestbookEntryDeactivated'] = 'Ud&aacute;lost spu&scaron;těna, když položka Knihy n&aacute;v&scaron;těv byla aktivov&aacute;na
  	 <h4>Parametry</h4>
  	 <ul>
  	 <li><em>entry_id</em> - The entry id (int)</li>
  	 </ul>
';
$lang['inposmes'] = 'Make sure to set the &quot;Modify Guestbook Entries&quot; permission for users who will be administering Guestbook items and &quot;Modify Guestbook Template&quot; permission for users who should be able to modify the guestbook template.<br />Attach the Stylesheet named &quot;%s&quot; to the template used to style the guestbook.';
$lang['moddescription'] = 'Spravovat vzkazy knihy a &scaron;ablonu.';
$lang['uninstall_pre_message'] = '%s vzkazů bude trvale vymaz&aacute;no!';
$lang['uninstall_pre_message_single'] = '1 vzkaz bude z knihy trvale vymaz&aacute;n!';
$lang['postuninstall'] = 'Kniha n&aacute;v&scaron;těv ( Guestbook) byla &uacute;spě&scaron;ně odinstalov&aacute;na.';
$lang['help_mode'] = '&quot;guestbook&quot;, &quot;form&quot;, &quot;entrylist&quot; or &quot;entry&quot;';
$lang['help_show_entry'] = 'ID of an entry to show (mode=&quot;entry&quot; is assumed)';
$lang['help_guestbook'] = 'ID knihy n&aacute;v&scaron;těv';
$lang['help_textleng'] = 'Nastavuje množstv&iacute; znaků, kter&eacute; je maxim&aacute;lně povoleno vložit. Přednastaven&aacute; hodnota je 1000 znaků. Tento parametr ovlivňuje jak prověřov&aacute;n&iacute; na straně serveru, tak klienta.';
$lang['help_number'] = 'Maxim&aacute;ln&iacute; počet vzkazů na str&aacute;nku.';
$lang['help_timespan'] = 'Minim&aacute;ln&iacute; přest&aacute;vka mezi př&iacute;spěvky (v sekund&aacute;ch)';
$lang['hide_insertbutton_after_post'] = 'Při přisp&iacute;v&aacute;n&iacute; nebude zobrazeno tlač&iacute;tko pro vložen&iacute;.';
$lang['help_mailnoti'] = 'E-mailov&aacute; adresa pro zasl&aacute;n&iacute; upozorněn&iacute; na přidan&yacute; př&iacute;spěvek. Pro odesl&aacute;n&iacute; bude v př&iacute;padě, že je nainstalov&aacute;n použit modul CMSMailer, jinak funkce mail v PHP.';
$lang['help_sortasc'] = 'Tř&iacute;dit př&iacute;spěvky ve vzestupn&eacute;m pořad&iacute; (nov&eacute; př&iacute;spěvky na konec)';
$lang['help_dateformat'] = 'Změnit způsob, jak&yacute;m je zobrazov&aacute;no datum, zobrazovat podle form&aacute;tovac&iacute;ho k&oacute;du PHP';
$lang['help_shownow'] = 'Uk&aacute;zat př&iacute;spěvky ihned po odesl&aacute;n&iacute;, i bez schv&aacute;len&iacute; administr&aacute;torem.';
$lang['help_smiley'] = 'Překl&aacute;dat textov&eacute; smajl&iacute;ky na grafick&eacute; a uk&aacute;zat tabulku smajl&iacute;ků ve formul&aacute;ři pro vložen&iacute; př&iacute;spěvku. Použ&iacute;v&aacute; modul Smajl&iacute;ci, pokud je tento nainstalov&aacute;n';
$lang['help_captcha'] = 'Umožnit použit&iacute; Captcha ve vstupn&iacute;m formul&aacute;ři knihy. Modul Captcha mus&iacute; b&yacute;t nainstalov&aacute;n, aby tento parametr fungoval.';
$lang['help_showaddform'] = 'Uk&aacute;že formul&aacute;ř pro vložen&iacute; vzkazu na prvn&iacute; str&aacute;nce. Nahrazuje tlač&iacute;tko &quot;Nov&yacute; vzkaz&quot;';
$lang['help'] = '<h3>Co tento modul děl&aacute;?</h3>
<p>
    Modul Knihy n&aacute;v&scaron;těv umožňuje n&aacute;v&scaron;těvn&iacute;kům webu zanechat zpr&aacute;vu, např. o tom, jak se jim str&aacute;nky l&iacute;b&iacute;.
</p>

<h3>Bezpečnost</h3>
<p>
    Uživatel mus&iacute; patřit do skupiny s opr&aacute;vněn&iacute;m &quot;Měnit pložky knihy n&aacute;v&scaron;těv&quot;, aby mohl přid&aacute;vat, měnit, nebo mazat položky knihy n&aacute;v&scaron;těv.<br />
Pro změnu &scaron;ablony knihy n&aacute;v&scaron;těv je podobně třeba opr&aacute;vněn&iacute; &quot;Měnit &scaron;ablonu knihy n&aacute;v&scaron;těv&quot;.
</p>
--- zbytek n&aacute;povědy je prozat&iacute;m v angličtině. Překlad bude dokončen v nejbliž&scaron;&iacute;m možn&eacute;m term&iacute;nu. ---
<h3>How do I use it?</h3>
<p>
    The easiest way is to create a new page and change the &quot;Content Type&quot; to Guestbook. This way you will be able to set the guestbook options as page properties.<br />
    If you want to add the module after some other content you can insert it using the cms_module tag. This will insert the guestbook into your template/page anywhere you wish.<br /> 
    The code would look something like: <code>{cms_module module=&quot;Guestbook&quot; number=&quot;5&quot; shownow=&quot;1&quot; smiley=&quot;1&quot;}</code>
</p>

<h3>What Parameters Exist?</h3>
<ul>
<li><em>(optional)</em> textleng=&quot;1000&quot; - Sets how many characters can be entered. The default is 1000 characters. This parameter affects both server-side and client-side validation.</li>
<li><em>(optional)</em> number=&quot;10&quot; - Maximum number of entries on a page.  Leaving it empty will show 10 entries</li>
<li><em>(optional)</em> timespan=&quot;600&quot; - Minimal timespan between posts (in seconds).  Leaving it empty will set timespan=&quot;0&quot;</li>
<li><em>(optional)</em> mailnoti=&quot;youremail@example.com&quot; - E-mail address to send a notification to if a message was submitted. The CMSMailer module will be used for sending the E-mail if it is installed (otherwise PHP&#039;s mail function is used).</li>
<li><em>(optional)</em> sortasc=&quot;1&quot; - Sort guestbook items in ascending date order (new posts will go to the end).</li>
<li><em>(optional)</em> dateformat=&quot;dateformat&quot; - Change the way the Date will display, it takes the PHP format codes</li>
<li><em>(optional)</em> shownow=&quot;1&quot; - Shows messages right after submission, without approval by an admin.</li>
<li><em>(optional)</em> smiley=&quot;1&quot; - Translate text-based smileys to image smileys and shows the smiley table on the entry submit form. Uses the Smiley module if it is installed</li>
<li><em>(optional)</em> captcha=&quot;1&quot; - This will enable captcha on the guestbook entry form. The Captcha module must be installed for this parameter to work.</li>
<li><em>(optional)</em> showaddform=&quot;1&quot; - Shows the insert form on the first page.  Replaces the &quot;New Guestbook Entry&quot; button.</li>
<li><em>(optional)</em> lang=&quot;xx_XX&quot; - Custom locale. For example lang=&quot;de_DE&quot;.</li>
</ul>

<h3>What Design potentials are there?</h3>
<p>
    The database template that is used to show a guestbook entry can be edited from the admin panel.
</p>
<p>
    An example stylesheet for the default database template is installed with the module.<br />
    The default stylesheet is deleted when the module is uninstalled and may be overwitten by an upgrade, so you might want to use a copy if you modify it.<br />
    Attach the stylesheet to the page template used.
</p>
<p>
    These variables are assigned in the guestbook entry template:
    <pre>
    date_title
    date
    time
    time_hour_title
    
    sender_title	
    sender
    
    country_title
    country
    
    location_title
    location
    
    e_mail_title
    e_mail		// the E-mail address
    e_mail_cloaked	// the E-mail address with . replaced by <dot> and @ by <at>
    
    homepage_title
    homepage
    
    message_title
    message
    </pre>
</p>
<p>
    In the module directory there&#039;s a directory called templates where all other templates are stored. You can modify these to fit your needs:
</p>

<strong>Administration</strong>
<p>
admin_entries_top.tpl -> The paganition and row names for the entry list.<br/>
admin_entries_entry.tpl -> The template for an entry in the list of guestbook entries.<br/>
admin_entries_bottom.tpl -> The bottom of the guestbook entries admin form.<br />
admin_entry.tpl-> The form used to insert or edit guestbook entries.<br/>
admin_template_edit.tpl -> Used for editing the guestbook entry database template.
</p>

<strong>Front End</strong>
<p>
newguest.tpl -> Button to go to the entry form<br/>
insertform.tpl -> The guestbook entry form<br />
smiley.tpl -> The smiley table<br/>
prevnext.tpl -> The buttons to go to the previous and next pages (will show only if entries do not fit on one page)<br/>
success_message.tpl-> The message that will show in place of the insert form after successful post submission.
</p>

<p>
    Inside the template directory there&#039;s a directory called db. This stores the guestbook entry template that is copied to the database during module installation and when the template is restored to default from the admin panel.<br />
    By default the file guestbook_entry-default.tpl is used, but if a (custom) file guestbook_entry.tpl is present, this file will be used instead.
</p>

<h3>Importing gastbuch messages</h3>
<p>
    If you have one of the beta &quot;gastbuch&quot; module versions (older than Guestbook-1.0-rc1) installed and want to import your guestbook messages into the Guestbook module, a script is available to do so.
    Simply point your browser to the file gastbuch-import.php in the module folder (for example: http://www.example.com/cms/modules/Guestbook/gastbuch-import.php) before uninstalling the old gastbuch module.
</p>';
$lang['changelog'] = '<ul>
	<li>
		<p><b>Version 1.1.9</b></p>
		<ul>
			<li>Prevent an E-mail being sent to no address when the mailnoti parameter is not being used</li>
		</ul>
	</li>
	<li>
		<p><b>Version 1.1.8</b></p>
		<ul>
			<li>Fixed too short ip_address field</li>
			<li>Moved templates to a single tab in the admin</li>
		</ul>
	</li>
	<li>
		<p><b>Version 1.1.7</b></p>
		<ul>
			<li>Fixed references to old file locations</li>
			<li>Fixed Javascript warning when WYSIWYG is used</li>
		</ul>
	</li>
	<li>
		<p><b>Version 1.1.6</b></p>
		<ul>
			<li>Fixed character counter not working with FCKeditor</li>
			<li>Moved errormessage to lang file</li>
			<li>Deleted some redundant files</li>;
		</ul>
	</li>
	<li>
		<p><b>Version 1.1.5</b></p>
		<ul>
			<li>Fixed ModuleIsInstalled method always returning false for admin modules/FCKEditorX</li>;
			<li>Fixed character counter always starting at 1000</li>; 
		</ul>
	</li>
	<li>
		<p><b>Version 1.1.4</b></p>
		<ul>
			<li>Fixes breaks in messages not showing in 1.1.3</li>
			<li>Added (optional) basic WYSIWYG on the Guestbook entry form</li>
			<li>Added logging of guestbook entry sender IP address</li>
			<li>Added &quot;Modify Guestbook Settings&quot; permission</li>
		</ul>
	</li>
	<li>
		<p><b>Version 1.1.3</b></p>
		<ul>
			<li>Improved pagination</li>
			<li>Rewrote front-end code to use Smarty for all output</li>
			<li>The front-end Smarty templates now use arrays</li>
			<li>Made most front-end templates editable from the admin</li>
			<li>Added events</li>
			<li>Added bad word filter</i>
		</ul>
	</li>
	<li>
		<p><b>Version 1.1.2</b></p>
		<ul>
			<li>Fixed a bug where the Next button would show when it shouldn&#039;t</li>
			<li>Any guestbook content is deleted on uninstall to prevent fatal errors in cmsmadesimple-1.x</li>
		</ul>
	</li>
	<li>
		<p><b>Version 1.1.1</b></p>
		<ul>
			<li>Compatiblity changes for cmsmadesimple-1.0 and a small bugfix</li>
		</ul>
	</li>
    <li>
        <p><b>Version 1.1</b></p>
        <ul>
            <li>Added Captcha support (in a seperate Captcha module)</li>
            <li>Added timespan parameter (minimal timespan between posts)</li>
            <li>Added location field (for State/Province/City/Town)</li>
            <li>Make use of the Smiley module if it is installed</li>
            <li>Made the module compatible with the cmsmadesimple-1.0 series</li>
            <li>Minimal required CMS version changed to 0.13</li>
        </ul>
    </li>
								    
    <li>
	<p><b>Version 1.0</b></p>
	<ul>
	    <li>Renamed module (from gastbuch) to Guestbook to represent the projects natural language and follow CMS Made Simple module naming conventions.</li>
	    <li>Enabled handling (deleting, activating and deactivating) of multiple guestbook entries from the admin panel.</li>
	    <li>There are now seperate &#039;Modify Guestbook Entries&#039; and &#039;Modify Guestbook Template&#039; permissions.</li>
	    <li>A default/example stylesheet is installed (and uninstalled) with the module.</li>
	    <li>The database template can be restored to default.</li>
	    <li>Changed to tabbed navigation.</li>
	    <li>Cleanup/rewrite of the guestbook(item) database template and the variables used in it.</li>
	    <li>Translated many variable names and code comments to english.</li>
	    <li>Moved some admin and log messages to the language file.</li>
	    <li>Re-formatted source code for better readability.</li>
	    <li>The module now also works in combination with a PostgreSQL database.</li>
	    <li>Changed the input format for the dateformat parameter from MySQL format to PHP format.</li>
	    <li>A new variable is assigned to the (database) guestbookentry template: $e_mail_cloaked. This is the E-mail address, with @ replaced by &amp;lt;at&amp;gt; and . by &amp;lt;dot&amp;gt;.</li>
	    <li>Extended the notification E-mail, it now sends the new guestbook entry in the notification message.</li>
	    <li>New finnish translation and updated dutch and norwegian translations from the translation center.</li>
	</ul>
    </li>
    <li>
	<p><b>Version 0.9</b></p>
	<ul>
	    <li>The guestbook frontend now uses a database template (in stead of the showmessage*.tpl files) that can be modified from the admin panel</li>
	    <li>The dateformat parameter is now called dateformat (was dateform). Note: this means you will have to recreate any guestbook content pages or manually edit the tables cms_content and cms_content_props</li>
	    <li>New french translation and modified translations for other languages from the translation center</li>
	</ul>
    </li>
    <li>
	<p><b>Version 0.8</b></p>
	Fixed:
	<ul>
	    <li>not working smileys on gastbuch Content page in version 0.7</li>
	</ul>
	Cleanup:
	<ul>
	    <li>mainly removal of unneccary references to the global $gCms</li>
	    <li>renamed email textfield to e_mail (it was called betreff, probably an old subject field)</li>
	</ul>
	Improvements:
	<ul>
	    <li>newly submitted newsentry is shown in the list</li>
	    <li>brackets around submitter country are no longer shown if a country wasn&#039;t entered</li>
	    <li>translated the lang file to dutch (except for help and changelog)</li>
	    <li>the gastbuch module now makes use of translations entered in the translation center translations.cmsmadesimple.org</li>
	</ul>
	Changed:
	<ul>
	    <li>The template variable name for the country in showmessage.tpl is now called $country (was $countryshow in previous versions)</li>
	</ul>
    </li>
    <li>
	<p><b>Version 0.7</b></p>
	<ul>
	    <li>Added lang attribute to support multiple locales</li>
	    <li>Show insert form on the first page</li>
	    <li>Fixed bug with textlength javascript not working</li>
	    <li>Fixed a few minor bugs</li>
	</ul>
    <li>
	<p><b>Version 0.6</b></p>
	<ul>
	    <li>Redesigned source code for better readability</li>
	    <li>Added lang attribute to support multiple locales</li>
	    <li>Added showaddform parameter</li>
	    <li>Fixed bug with textlength javascript not working in case of &quot;Content&quot; content type</li>
	    <li>Merged vorzu and backzu templates into one</li>
	    <li>Added template success_message.tpl</li>
	    <li>Fixed a few minor bugs caused by mismatches in lang variable names</li>
	</ul>
    </li>
    <li>
	<p><b>Version 0.5</b></p>
	<p>
	    The guestbook was modified with better design and functions, for example: 
	    Template based Content, Spam protection for inserted e-mails, etc.
	</p>
    </li>
    <li>
	<p><b>Version 0.4</b></p>
	<p>The gastbuch module is now a new module</p>
    </li>
</ul>';
$lang['qca'] = 'P0-390133276-1275213321958';
$lang['utma'] = '156861353.71659362.1275223702.1283272682.1283283063.17';
$lang['utmz'] = '156861353.1283272682.16.13.utmccn=(referral)|utmcsr=forum.cmsmadesimple.org|utmcct=/index.php/topic,20346.0.html|utmcmd=referral';
$lang['utmc'] = '156861353';
$lang['utmb'] = '156861353';
?>]]></data>
	</file>
	<file>
	  <filename>/lang/ext/da_DK.php</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[<?php
$lang['module_friendlyname'] = 'G&aelig;stebog';
$lang['module_example_stylesheet'] = 'G&aelig;stebog (Standard/eksempel stylesheet)';
$lang['module_example_stylesheet_intro'] = 'Standard/eksempel stylesheet til CMSMS G&aelig;stebogs modulet.
Denne kan blive overskrevet hvis modulet bliver opgraderet og det vil blive slettet n&aring;r modulet bliver afinstalleret, s&aring; opret en kopi hvis du vil &aelig;ndre den.';
$lang['captcha'] = 'Captcha';
$lang['captcha_title'] = 'Indtast teksten i billedet herunder';
$lang['captcha_failure_message'] = 'Teksten blev ikke indtastet korrekt';
$lang['timespan'] = 'Minimum tidsrum mellem indl&aelig;g';
$lang['err_invalid_mode'] = 'Fejl: et ugyldigt mode parameter blev specificeret. Gyldige modes er: %s.';
$lang['err_no_entry_id'] = 'Fejl: der er ikke angivet noget indl&aelig;g_id parameter. Med mode=entry skal et parameter for indl&aelig;g_id specificeres.';
$lang['err_entry_not_found'] = 'Fejl: der er ikke noget g&aelig;stebogsindl&aelig;g med indl&aelig;g_id %s';
$lang['error_template_filenotfound'] = 'Fejl: skabelon filen %s kunne ikke findes!';
$lang['id'] = 'Id';
$lang['sender'] = 'Afsender';
$lang['email'] = 'Email';
$lang['country'] = 'Land';
$lang['location'] = 'Lokation';
$lang['homepage'] = 'Hjemmeside';
$lang['message'] = 'Besked';
$lang['posted'] = 'Sendt';
$lang['ip_addr'] = 'IP adresse';
$lang['alength'] = 'Karakterer tilbage';
$lang['active'] = 'Aktiv';
$lang['access_denied'] = 'Adgang n&aelig;gtet';
$lang['restore_to_defaults'] = 'Gendan standard';
$lang['restore_to_defaults_warning'] = 'Denne aktion vil genetablere standardskabelonen. Det vil overskrive alle &aelig;ndringer foretaget p&aring; skabelonen. Er du sikker p&aring; at du vil forts&aelig;tte?';
$lang['addgait'] = 'Tilf&oslash;j G&aelig;stebog besked';
$lang['postdate'] = 'Sendt dato';
$lang['ativi'] = 'Aktiver';
$lang['deakti'] = 'Deaktiver';
$lang['title_mod_admin'] = 'Administre G&aelig;stebog beskeder';
$lang['title_mod_settings'] = 'G&aelig;stebogs ops&aelig;tning';
$lang['title_tab_admin_templates'] = 'G&aelig;stebogsskabeloner';
$lang['title_tab_admin_template'] = 'G&aelig;stebogskabelon';
$lang['title_tab_admin_entrylist_template'] = 'Skabelon for oversigt over indl&aelig;g';
$lang['title_tab_admin_entry_template'] = 'Skabelon for indl&aelig;g';
$lang['title_tab_admin_form_template'] = 'Formularskabelon';
$lang['title_tab_admin_email_template'] = 'Email skabelon';
$lang['title_tab_admin_showform_button_template'] = 'Vis formularskabelon';
$lang['templatecontent'] = 'Skabelon indhold';
$lang['admin_template_modified_logmessage'] = 'G&aelig;stebogsskabelon &aelig;ndret';
$lang['admin_template_restored_logmessage'] = 'Standard G&aelig;stebogskabelon genetableret';
$lang['admin_entry_added_logmessage'] = 'Besked tilf&oslash;jet';
$lang['admin_entry_modified_logmessage'] = 'Besked &aelig;ndret';
$lang['admin_entry_deleted_logmessage'] = 'Besked slettet';
$lang['admin_entry_activated_logmessage'] = 'Besked aktiveret';
$lang['admin_entry_deactivated_logmessage'] = 'Besked deaktiveret';
$lang['admin_entry_message_nosender'] = 'Indtast venligst navn';
$lang['fieldnames'] = 'Felt navn';
$lang['captcha_module_installed'] = 'Captcha modulet er installeret';
$lang['captcha_module_not_installed'] = 'Captcha modulet er ikke installeret';
$lang['smileys_module_installed'] = 'Smiley modulet er installeret';
$lang['smileys_module_not_installed'] = 'Smiley modulet er ikke installeret';
$lang['admin_wysiwyg_title'] = 'Brug WYSIWYG p&aring; g&aelig;stebogs indl&aelig;gsformularen';
$lang['searchsmileys_title'] = 'Brug smileys i s&oslash;geresultatet';
$lang['save_settings'] = 'Gem indstillinger';
$lang['badwords_title'] = 'Ord, der ikke er tilladt';
$lang['badwords_replacement_title'] = 'Udskift ikke tilladte ord med';
$lang['nummer'] = 'Antal beskeder pr. side';
$lang['postchar'] = 'Maksimum besked st&oslash;rrelse';
$lang['emailnot'] = 'email ved oprettelse af besked';
$lang['sortasc'] = 'Sorter stigende (ASC)';
$lang['smile'] = 'Smiley';
$lang['shmenow'] = 'Vis beskeder med det samme';
$lang['datefora'] = 'Dato format';
$lang['lang'] = 'Sprog (e.g. da_DK)';
$lang['showaddform'] = 'Vis inds&aelig;t form under beskeder';
$lang['fabsend'] = 'Indtast venligst dit navn';
$lang['fmessag'] = 'Indtast venligst en besked';
$lang['femail'] = 'Indtast en gyldig E-mail adresse';
$lang['tolong'] = 'For mange karakterer.';
$lang['toosoon'] = 'Din sidste besked var for % sekunder siden. Minimum ventetid er % sekunder.';
$lang['fui'] = 'Din besked er allerede sendt';
$lang['badwords_message'] = 'Disse ord er ikke tilladt: %s';
$lang['showitnow'] = 'Din besked er sendt';
$lang['showitlater'] = 'Tak! Din besked vil blive vist s&aring; snart den er godkendt af administrator';
$lang['msg_back'] = 'Tilbage til g&aelig;stebog';
$lang['inam'] = 'Navn';
$lang['imessag'] = 'Din besked';
$lang['smessage'] = 'Besked';
$lang['sdate'] = 'Dato';
$lang['ginsert'] = 'Inds&aelig;t';
$lang['cancel'] = 'Annuller';
$lang['uhr'] = 'Time';
$lang['e_mailnotibetr'] = 'Ny besked i din g&aelig;stebog';
$lang['e_mailnotimessage'] = 'Der er en ny besked i din g&aelig;stebog';
$lang['neuein'] = 'Ny g&aelig;stebogs besked';
$lang['einerseit'] = 'en side';
$lang['eintragauf'] = 'Vist den';
$lang['seitpage'] = 'sider';
$lang['backzu'] = '<< Tilbage';
$lang['nextwei'] = 'Frem >>';
$lang['first_text'] = '<<';
$lang['prev_text'] = '< forrige';
$lang['next_text'] = 'n&aelig;ste >';
$lang['last_text'] = '>>';
$lang['pagination_of'] = 'af';
$lang['title_table_smileys'] = 'Smileys';
$lang['ativimes'] = 'Aktiver denne besked?';
$lang['deaktimes'] = 'Deaktiver denne besked?';
$lang['event_info_GuestbookEntryPosted'] = 'Handling der sker n&aring;r et nyt g&aelig;stebogs indl&aelig;g er tilf&oslash;jet';
$lang['event_help_GuestbookEntryPosted'] = '<p>Event triggered when a new Guestbook entry is added.</p>
  	 <h4>Parameters</h4>
  	 <ul>
		<li><em>entry_id</em> - The entry id (int)</li>
		<li><em>entry_sender</em> - The name the sender entered (string)</li>
		<li><em>entry_email</em> - The E-mail address entered (string)</li>
		<li><em>entry_homepage</em> - The homepage entered (string)</li>
		<li><em>entry_message</em> - The message entered (string)</li>
		<li><em>entry_country</em> - The country entered (string)</li>
		<li><em>entry_location</em> - The location entered (string)</li>
		<li><em>entry_date</em> - The post date (string)</li>
		<li><em>entry_approved</em> - Whether the entry is activated at once, 1 if it is, -1 if not (int)</li>
  	 </ul>
';
$lang['event_info_GuestbookEntryDeleted'] = 'Handling der sker n&aring;r et g&aelig;stebogs indl&aelig;g bliver slettet';
$lang['event_help_GuestbookEntryDeleted'] = 'Event triggered when a Guestbook entry is deleted
  	 <h4>Parameters</h4>
  	 <ul>
	  	 <li><em>entry_id</em> - The entry id (int)</li>
  	 </ul>
';
$lang['event_info_GuestbookEntryActivated'] = 'Event triggered when a Guestbook entry is activated';
$lang['event_help_GuestbookEntryActivated'] = 'Event triggered when a Guestbook entry is activated
  	 <h4>Parameters</h4>
  	 <ul>
  	 <li><em>entry_id</em> - The entry id (int)</li>
  	 </ul>
';
$lang['event_info_GuestbookEntryDeactivated'] = 'Event triggered when a Guestbook entry is de-activated';
$lang['event_help_GuestbookEntryDeactivated'] = 'Event triggered when a Guestbook entry is de-activated
  	 <h4>Parameters</h4>
  	 <ul>
  	 <li><em>entry_id</em> - The entry id (int)</li>
  	 </ul>
';
$lang['inposmes'] = 'Make sure to set the &quot;Modify Guestbook Entries&quot; permission for users who will be administering Guestbook items and &quot;Modify Guestbook Template&quot; permission for users who should be able to modify the guestbook template.<br />Attach the Stylesheet named &quot;%s&quot; to the template used to style the guestbook.';
$lang['moddescription'] = '&AElig;ndre g&aelig;stebogs beskeder og skabeloner.';
$lang['uninstall_pre_message'] = 'Der er %s beskeder i din g&aelig;stebog der vil blive slettet';
$lang['uninstall_pre_message_single'] = 'Der er 1 besked i din g&aelig;stebog der vil blive slettet permanent';
$lang['postuninstall'] = 'G&aelig;stebog er afinstalleret';
$lang['help_textleng'] = 'Bestemmer hvor mange tegn der kan skrives. Standarden er 1000 tegn. Dette parameter p&aring;virker b&aring;de server-side and client-side validation.';
$lang['help_number'] = 'Det maksimale antal indl&aelig;g der skal vises p&aring; en side.';
$lang['help_timespan'] = 'Det mindste interval mellem indl&aelig;g (i sekunder).';
$lang['help_mailnoti'] = 'E-mail address to send a notification to if a message was submitted. The CMSMailer module will be used for sending the E-mail if it is installed (otherwise PHP&#039;s mail function is used).';
$lang['help_sortasc'] = 'Sort&eacute;r g&aelig;stebogs indl&aelig;g i stigende dato orden (nyeste indl&aelig;g vil komme sidst)';
$lang['help_dateformat'] = 'Angiv m&aring;de som en dato skal vises p&aring;, dette angives i PHP format koder';
$lang['help_shownow'] = 'Vis indl&aelig;g lige efter indsendelse, uden godkendelse fra en administrator';
$lang['help_smiley'] = 'Overs&aelig;t tekst-baserede smileys til grafiske og vis smiley oversigten p&aring;  g&aelig;stebogs siden. Benytter Smiley-modulet hvis det er installeret.';
$lang['help_captcha'] = 'Dette vil sl&aring; captche til p&aring; g&aelig;stebogssiden. Captcha modules skal v&aelig;re installeret for at dette parameter virker.';
$lang['help_showaddform'] = 'Shows the insert form on the first page.  Replaces the &quot;New Guestbook Entry&quot; button.';
$lang['help'] = '<h3>What does it do?</h3>
<p>
    The guestbook module is a content module and a CMSMS tagmodule.
    It gives visitors the ability to leave a message, for example about how they like the website.
</p>

<h3>Security</h3>
<p>
    The user must belong to a group with the &#039;Modify Guestbook Entries&#039; permission in order to add, edit, or delete guestbook entries.<br />
    In order to be able to modify the guestbook entry template, &#039;Modify Guestbook Template&#039; permission is required.
</p>

<h3>How do I use it?</h3>
<p>
    The easiest way is to create a new page and change the &quot;Content Type&quot; to Guestbook. This way you will be able to set the guestbook options as page properties.<br />
    If you want to add the module after some other content you can insert it using the cms_module tag. This will insert the guestbook into your template/page anywhere you wish.<br /> 
    The code would look something like: <code>{cms_module module=&quot;Guestbook&quot; number=&quot;5&quot; shownow=&quot;1&quot; smiley=&quot;1&quot;}</code>
</p>

<h3>What Parameters Exist?</h3>
<ul>
<li><em>(optional)</em> textleng=&quot;1000&quot; - Sets how many characters can be entered. The default is 1000 characters. This parameter affects both server-side and client-side validation.</li>
<li><em>(optional)</em> number=&quot;10&quot; - Maximum number of entries on a page.  Leaving it empty will show 10 entries</li>
<li><em>(optional)</em> timespan=&quot;600&quot; - Minimal timespan between posts (in seconds).  Leaving it empty will set timespan=&quot;0&quot;</li>
<li><em>(optional)</em> mailnoti=&quot;youremail@example.com&quot; - E-mail address to send a notification to if a message was submitted. The CMSMailer module will be used for sending the E-mail if it is installed (otherwise PHP&#039;s mail function is used).</li>
<li><em>(optional)</em> sortasc=&quot;1&quot; - Sort guestbook items in ascending date order (new posts will go to the end).</li>
<li><em>(optional)</em> dateformat=&quot;dateformat&quot; - Change the way the Date will display, it takes the PHP format codes</li>
<li><em>(optional)</em> shownow=&quot;1&quot; - Shows messages right after submission, without approval by an admin.</li>
<li><em>(optional)</em> smiley=&quot;1&quot; - Translate text-based smileys to image smileys and shows the smiley table on the entry submit form. Uses the Smiley module if it is installed</li>
<li><em>(optional)</em> captcha=&quot;1&quot; - This will enable captcha on the guestbook entry form. The Captcha module must be installed for this parameter to work.</li>
<li><em>(optional)</em> showaddform=&quot;1&quot; - Shows the insert form on the first page.  Replaces the &quot;New Guestbook Entry&quot; button.</li>
<li><em>(optional)</em> lang=&quot;xx_XX&quot; - Custom locale. For example lang=&quot;de_DE&quot;.</li>
</ul>

<h3>What Design potentials are there?</h3>
<p>
    The database template that is used to show a guestbook entry can be edited from the admin panel.
</p>
<p>
    An example stylesheet for the default database template is installed with the module.<br />
    The default stylesheet is deleted when the module is uninstalled and may be overwitten by an upgrade, so you might want to use a copy if you modify it.<br />
    Attach the stylesheet to the page template used.
</p>
<p>
    These variables are assigned in the guestbook entry template:
    <pre>
    date_title
    date
    time
    time_hour_title
    
    sender_title	
    sender
    
    country_title
    country
    
    location_title
    location
    
    e_mail_title
    e_mail		// the E-mail address
    e_mail_cloaked	// the E-mail address with . replaced by <dot> and @ by <at>
    
    homepage_title
    homepage
    
    message_title
    message
    </pre>
</p>
<p>
    In the module directory there&#039;s a directory called templates where all other templates are stored. You can modify these to fit your needs:
</p>

<strong>Administration</strong>
<p>
admin_entries_top.tpl -> The paganition and row names for the entry list.<br/>
admin_entries_entry.tpl -> The template for an entry in the list of guestbook entries.<br/>
admin_entries_bottom.tpl -> The bottom of the guestbook entries admin form.<br />
admin_entry.tpl-> The form used to insert or edit guestbook entries.<br/>
admin_template_edit.tpl -> Used for editing the guestbook entry database template.
</p>

<strong>Front End</strong>
<p>
newguest.tpl -> Button to go to the entry form<br/>
insertform.tpl -> The guestbook entry form<br />
smiley.tpl -> The smiley table<br/>
prevnext.tpl -> The buttons to go to the previous and next pages (will show only if entries do not fit on one page)<br/>
success_message.tpl-> The message that will show in place of the insert form after successful post submission.
</p>

<p>
    Inside the template directory there&#039;s a directory called db. This stores the guestbook entry template that is copied to the database during module installation and when the template is restored to default from the admin panel.<br />
    By default the file guestbook_entry-default.tpl is used, but if a (custom) file guestbook_entry.tpl is present, this file will be used instead.
</p>

<h3>Importing gastbuch messages</h3>
<p>
    If you have one of the beta &quot;gastbuch&quot; module versions (older than Guestbook-1.0-rc1) installed and want to import your guestbook messages into the Guestbook module, a script is available to do so.
    Simply point your browser to the file gastbuch-import.php in the module folder (for example: http://www.example.com/cms/modules/Guestbook/gastbuch-import.php) before uninstalling the old gastbuch module.
</p>';
$lang['changelog'] = '
<ul>
	<li>
		<p><b>Version 1.1.9</b></p>
		<ul>
			<li>Prevent an E-mail being sent to no address when the mailnoti parameter is not being used</li>
		</ul>
	</li>
	<li>
		<p><b>Version 1.1.8</b></p>
		<ul>
			<li>Fixed too short ip_address field</li>
			<li>Moved templates to a single tab in the admin</li>
		</ul>
	</li>
	<li>
		<p><b>Version 1.1.7</b></p>
		<ul>
			<li>Fixed references to old file locations</li>
			<li>Fixed Javascript warning when WYSIWYG is used</li>
		</ul>
	</li>
	<li>
		<p><b>Version 1.1.6</b></p>
		<ul>
			<li>Fixed character counter not working with FCKeditor</li>
			<li>Moved errormessage to lang file</li>
			<li>Deleted some redundant files</li>;
		</ul>
	</li>
	<li>
		<p><b>Version 1.1.5</b></p>
		<ul>
			<li>Fixed ModuleIsInstalled method always returning false for admin modules/FCKEditorX</li>;
			<li>Fixed character counter always starting at 1000</li>; 
		</ul>
	</li>
	<li>
		<p><b>Version 1.1.4</b></p>
		<ul>
			<li>Fixes breaks in messages not showing in 1.1.3</li>
			<li>Added (optional) basic WYSIWYG on the Guestbook entry form</li>
			<li>Added logging of guestbook entry sender IP address</li>
			<li>Added &quot;Modify Guestbook Settings&quot; permission</li>
		</ul>
	</li>
	<li>
		<p><b>Version 1.1.3</b></p>
		<ul>
			<li>Improved pagination</li>
			<li>Rewrote front-end code to use Smarty for all output</li>
			<li>The front-end Smarty templates now use arrays</li>
			<li>Made most front-end templates editable from the admin</li>
			<li>Added events</li>
			<li>Added bad word filter</i>
		</ul>
	</li>
	<li>
		<p><b>Version 1.1.2</b></p>
		<ul>
			<li>Fixed a bug where the Next button would show when it shouldn&#039;t</li>
			<li>Any guestbook content is deleted on uninstall to prevent fatal errors in cmsmadesimple-1.x</li>
		</ul>
	</li>
	<li>
		<p><b>Version 1.1.1</b></p>
		<ul>
			<li>Compatiblity changes for cmsmadesimple-1.0 and a small bugfix</li>
		</ul>
	</li>
    <li>
        <p><b>Version 1.1</b></p>
        <ul>
            <li>Added Captcha support (in a seperate Captcha module)</li>
            <li>Added timespan parameter (minimal timespan between posts)</li>
            <li>Added location field (for State/Province/City/Town)</li>
            <li>Make use of the Smiley module if it is installed</li>
            <li>Made the module compatible with the cmsmadesimple-1.0 series</li>
            <li>Minimal required CMS version changed to 0.13</li>
        </ul>
    </li>
								    
    <li>
	<p><b>Version 1.0</b></p>
	<ul>
	    <li>Renamed module (from gastbuch) to Guestbook to represent the projects natural language and follow CMS Made Simple module naming conventions.</li>
	    <li>Enabled handling (deleting, activating and deactivating) of multiple guestbook entries from the admin panel.</li>
	    <li>There are now seperate &#039;Modify Guestbook Entries&#039; and &#039;Modify Guestbook Template&#039; permissions.</li>
	    <li>A default/example stylesheet is installed (and uninstalled) with the module.</li>
	    <li>The database template can be restored to default.</li>
	    <li>Changed to tabbed navigation.</li>
	    <li>Cleanup/rewrite of the guestbook(item) database template and the variables used in it.</li>
	    <li>Translated many variable names and code comments to english.</li>
	    <li>Moved some admin and log messages to the language file.</li>
	    <li>Re-formatted source code for better readability.</li>
	    <li>The module now also works in combination with a PostgreSQL database.</li>
	    <li>Changed the input format for the dateformat parameter from MySQL format to PHP format.</li>
	    <li>A new variable is assigned to the (database) guestbookentry template: $e_mail_cloaked. This is the E-mail address, with @ replaced by &amp;lt;at&amp;gt; and . by &amp;lt;dot&amp;gt;.</li>
	    <li>Extended the notification E-mail, it now sends the new guestbook entry in the notification message.</li>
	    <li>New finnish translation and updated dutch and norwegian translations from the translation center.</li>
	</ul>
    </li>
    <li>
	<p><b>Version 0.9</b></p>
	<ul>
	    <li>The guestbook frontend now uses a database template (in stead of the showmessage*.tpl files) that can be modified from the admin panel</li>
	    <li>The dateformat parameter is now called dateformat (was dateform). Note: this means you will have to recreate any guestbook content pages or manually edit the tables cms_content and cms_content_props</li>
	    <li>New french translation and modified translations for other languages from the translation center</li>
	</ul>
    </li>
    <li>
	<p><b>Version 0.8</b></p>
	Fixed:
	<ul>
	    <li>not working smileys on gastbuch Content page in version 0.7</li>
	</ul>
	Cleanup:
	<ul>
	    <li>mainly removal of unneccary references to the global $gCms</li>
	    <li>renamed email textfield to e_mail (it was called betreff, probably an old subject field)</li>
	</ul>
	Improvements:
	<ul>
	    <li>newly submitted newsentry is shown in the list</li>
	    <li>brackets around submitter country are no longer shown if a country wasn&#039;t entered</li>
	    <li>translated the lang file to dutch (except for help and changelog)</li>
	    <li>the gastbuch module now makes use of translations entered in the translation center translations.cmsmadesimple.org</li>
	</ul>
	Changed:
	<ul>
	    <li>The template variable name for the country in showmessage.tpl is now called $country (was $countryshow in previous versions)</li>
	</ul>
    </li>
    <li>
	<p><b>Version 0.7</b></p>
	<ul>
	    <li>Added lang attribute to support multiple locales</li>
	    <li>Show insert form on the first page</li>
	    <li>Fixed bug with textlength javascript not working</li>
	    <li>Fixed a few minor bugs</li>
	</ul>
    <li>
	<p><b>Version 0.6</b></p>
	<ul>
	    <li>Redesigned source code for better readability</li>
	    <li>Added lang attribute to support multiple locales</li>
	    <li>Added showaddform parameter</li>
	    <li>Fixed bug with textlength javascript not working in case of &quot;Content&quot; content type</li>
	    <li>Merged vorzu and backzu templates into one</li>
	    <li>Added template success_message.tpl</li>
	    <li>Fixed a few minor bugs caused by mismatches in lang variable names</li>
	</ul>
    </li>
    <li>
	<p><b>Version 0.5</b></p>
	<p>
	    The guestbook was modified with better design and functions, for example: 
	    Template based Content, Spam protection for inserted e-mails, etc.
	</p>
    </li>
    <li>
	<p><b>Version 0.4</b></p>
	<p>The gastbuch module is now a new module</p>
    </li>
</ul>';
$lang['utma'] = '156861353.463971195.1189750298.1189760754.1189763417.3';
$lang['utmc'] = '156861353';
$lang['utmz'] = '156861353.1189750298.1.1.utmccn=(direct)|utmcsr=(direct)|utmcmd=(none)';
$lang['utmb'] = '156861353';
?>]]></data>
	</file>
	<file>
	  <filename>/lang/ext/de_DE.php</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[<?php
$lang['module_friendlyname'] = 'G&auml;stebuch';
$lang['default_guestbook_name'] = 'Voreingestellt';
$lang['default_guestbook_descr'] = 'Das erste/voreingestellte G&auml;stebuch';
$lang['module_example_stylesheet'] = 'G&auml;stebuch (Standard-/Beispiel-Stylesheet)';
$lang['module_example_stylesheet_intro'] = 'Standard-/Beispiel-Stylesheet f&uuml;r das CMSms-G&auml;stebuch-Modul.
Es wird &uuml;berschrieben, wenn das Modul aktualisiert wird und gel&ouml;scht, wenn das Modul deinstalliert wird. Wenn Sie das Template modifiziert haben, sollten Sie sich zuvor eine Kopie anfertigen.';
$lang['captcha'] = 'CAPTCHA';
$lang['captcha_title'] = 'Bitte geben Sie den Text aus dem unten stehenden Bild ein.';
$lang['captcha_failure_message'] = 'Der Text aus dem Bild wurde nicht korrekt eingegeben.';
$lang['timespan'] = 'Minimale Zeitspanne zwischen Eintr&auml;gen';
$lang['err_invalid_mode'] = 'Fehler: Es wurde ein ung&uuml;ltiger Modus-Parameter angegeben. G&uuml;ltige Modi sind: %s.';
$lang['err_no_entry_id'] = 'Fehler: Es wurde kein ID-Parameter angegeben. F&uuml;r den Modus mode=entry muss der Parameter entry_id jedoch festgelegt werden.';
$lang['err_entry_not_found'] = 'Fehler: Es gibt keinen G&auml;stebucheintrag mit der ID %s';
$lang['error_template_filenotfound'] = 'Fehler: Die Template-Datei %s konnte nicht gefunden werden!';
$lang['default'] = 'Voreingestellt';
$lang['add_guestbook'] = 'Ein neues G&auml;stebuch erstellen';
$lang['adding_guestbook'] = 'Ein neues G&auml;stebuch hinzuf&uuml;gen';
$lang['editing_guestbook'] = 'Ein existierendes G&auml;stebuch bearbeiten';
$lang['set_as_default'] = 'Als Voreinstellung festlegen';
$lang['confirm_set_as_default'] = 'Wollen Sie wirklich dieses G&auml;stebuch als Voreinstellung festlegen?';
$lang['confirm_delete_guestbook'] = 'Wollen Sie wirklich das G&auml;stebuch mit der ID %s l&ouml;schen? Alle %s Eintr&auml;ge werden unwiederbringlich gel&ouml;scht!';
$lang['id'] = 'ID';
$lang['date'] = 'Datum';
$lang['sender'] = 'Absender';
$lang['email'] = 'Email';
$lang['country'] = 'Staat';
$lang['location'] = 'Ort';
$lang['homepage'] = 'Webseite';
$lang['message'] = 'Nachricht';
$lang['posted'] = 'Abgesendet';
$lang['ip_addr'] = 'IP-Adresse';
$lang['alength'] = 'Verbleibende Zeichen';
$lang['active'] = 'Aktiv';
$lang['access_denied'] = 'Zugriff verweigert';
$lang['restore_to_defaults'] = 'Auf die Voreinstellungen zur&uuml;cksetzen';
$lang['restore_to_defaults_warning'] = 'Mit dieser Funktion wird das Template auf die programmseitigen Voreinstellungen zur&uuml;ckgesetzt. Dabei werden alle bisherigen &Auml;nderungen &uuml;berschrieben. Wollen Sie dies wirklich?';
$lang['addgait'] = 'Neuen G&auml;stebucheintrag hinzuf&uuml;gen';
$lang['postdate'] = 'Sendedatum';
$lang['ativi'] = 'Aktivieren';
$lang['deakti'] = 'Deaktivieren';
$lang['title_mod_admin'] = 'G&auml;stebuch-Eintr&auml;ge verwalten';
$lang['tabname_guestbooks'] = 'G&auml;steb&uuml;cher';
$lang['tabname_entries'] = 'Eintr&auml;ge';
$lang['title_mod_templates'] = 'Templates ';
$lang['tabname_settings'] = 'Modul-Einstellungen';
$lang['title_tab_admin_templates'] = 'G&auml;stebuch-Templates';
$lang['title_tab_admin_template'] = 'G&auml;stebuch-Template';
$lang['title_tab_admin_entrylist_template'] = 'Template f&uuml;r die Auflistung';
$lang['title_tab_admin_entry_template'] = 'Template f&uuml;r den Eintrag';
$lang['title_tab_admin_form_template'] = 'Formular-Template';
$lang['title_tab_admin_email_template'] = 'Template f&uuml;r die Email';
$lang['title_tab_admin_showform_button_template'] = 'Template f&uuml;r die Formular-Anzeige';
$lang['templatecontent'] = 'Template-Inhalt';
$lang['admin_template_modified_logmessage'] = 'Die G&auml;stebuch-Template wurde ge&auml;ndert.';
$lang['admin_template_restored_logmessage'] = 'Die G&auml;stebuch-Templates wurde auf den Systemstandard zur&uuml;ckgesetzt.';
$lang['admin_entry_added_logmessage'] = 'Der G&auml;stebuch-Eintrag wurde hinzugef&uuml;gt.';
$lang['admin_entry_modified_logmessage'] = 'Der G&auml;stebuch-Eintrag wurde ge&auml;ndert.';
$lang['admin_entry_deleted_logmessage'] = 'Der G&auml;stebuch-Eintrag wurde gel&ouml;scht.';
$lang['admin_entry_activated_logmessage'] = 'Der G&auml;stebuch-Eintrag wurde aktiviert.';
$lang['admin_entry_deactivated_logmessage'] = 'Der G&auml;stebuch-Eintrag wurde deaktiviert.';
$lang['admin_entry_message_nosender'] = 'Bitte geben Sie einen Absender-Namen ein!';
$lang['wrong_date_format'] = 'Das Datum muss folgendes Format haben: YYYY-MM-DD HH:MM:SS';
$lang['fieldnames'] = 'Feldnamen';
$lang['captcha_module_installed'] = 'Das CAPTCHA-Modul ist installiert.';
$lang['captcha_module_not_installed'] = 'Das CAPTCHA-Modul ist nicht installiert.';
$lang['smileys_module_installed'] = 'Das Smileys-Modul ist installiert.';
$lang['smileys_module_not_installed'] = 'Das Smileys-Modul ist nicht installiert.';
$lang['preferences_title'] = 'G&auml;stebuch-Einstellungen';
$lang['admin_wysiwyg_title'] = 'WYSIWYG f&uuml;r G&auml;stebucheintr&auml;ge verwenden';
$lang['searchsmileys_title'] = 'Smileys in den Suchergebnissen verwenden';
$lang['save_settings'] = 'Einstellungen speichern';
$lang['settings_saved'] = 'Die Einstellungen wurden aktualisiert.';
$lang['badwords_title'] = 'Nicht erlaubte W&ouml;rter';
$lang['badwords_replacement_title'] = 'Nicht erlaubte W&ouml;rter ersetzen durch';
$lang['admin_entries_per_page_title'] = 'Eintr&auml;ge pro Seite (in der Administration)';
$lang['description'] = 'Beschreibung';
$lang['nummer'] = 'Anzahl der Nachrichten pro Seite';
$lang['postchar'] = 'Maximale Nachrichtengr&ouml;&szlig;e';
$lang['emailnot'] = 'Email-Benachrichtigung';
$lang['sortasc'] = 'Aufsteigend sortieren';
$lang['smile'] = 'Smiley ';
$lang['shmenow'] = 'Die G&auml;stebucheintr&auml;ge sofort zeigen';
$lang['datefora'] = 'Datumsformat';
$lang['lang'] = 'Lokalisierung (z. B. &bdquo;de_DE&ldquo;)';
$lang['showaddform'] = 'Eingabeformular unter den Eintr&auml;gen anzeigen';
$lang['fabsend'] = 'Bitte geben Sie Ihren Namen ein.';
$lang['fmessag'] = 'Bitte geben Sie eine Nachricht ein.';
$lang['femail'] = 'Bitte geben Sie eine g&uuml;ltige Email-Adresse ein.';
$lang['tolong'] = 'Zu viele Zeichen. Bitte formulieren Sie Ihren Eintrag k&uuml;rzer.';
$lang['toosoon'] = 'Ihr letzter Eintrag liegt erst %s Sekunden zur&uuml;ck. Die minimale Zeitspanne zwischen den Eintr&auml;gen ist %s Sekunden.';
$lang['fui'] = 'Ihre Nachricht wurde bereits versandt.';
$lang['badwords_message'] = 'Diese W&ouml;rter sind nicht erlaubt: %s';
$lang['showitnow'] = 'Ihre Nachricht wurde eingetragen. Vielen Dank!';
$lang['showitlater'] = 'Vielen Dank! Ihr Eintrag wird nach &Uuml;berpr&uuml;fung durch den Administrator im G&auml;stebuch angezeigt.';
$lang['msg_back'] = 'Zur&uuml;ck zum G&auml;stebuch';
$lang['inam'] = 'Name ';
$lang['imessag'] = 'Ihre Nachricht';
$lang['smessage'] = 'Eintrag';
$lang['sdate'] = 'Datum';
$lang['ginsert'] = 'Eintragen';
$lang['cancel'] = 'Abbrechen';
$lang['uhr'] = 'Uhr';
$lang['e_mailnotibetr'] = 'Neuer Eintrag in Ihrem G&auml;stebuch';
$lang['e_mailnotimessage'] = 'Es liegt ein neuer Eintrag in Ihrem G&auml;stebuch vor.';
$lang['neuein'] = 'Neuer G&auml;stebuch-Eintrag';
$lang['einerseit'] = 'einer Seite';
$lang['eintragauf'] = 'Eintr&auml;ge auf';
$lang['seitpage'] = 'Seiten';
$lang['backzu'] = '< zur&uuml;ck';
$lang['nextwei'] = 'weiter >';
$lang['first_text'] = '<<';
$lang['prev_text'] = '<';
$lang['next_text'] = '>';
$lang['last_text'] = '>>';
$lang['pagination_of'] = 'von';
$lang['title_table_smileys'] = 'Smileys ';
$lang['ativimes'] = 'Wollen Sie diesen Eintrag aktivieren?';
$lang['deaktimes'] = 'Wollen Sie diesen Eintrag deaktivieren?';
$lang['event_info_GuestbookEntryPosted'] = 'Ausf&uuml;hren, wenn ein neuer G&auml;stebuch-Eintrag hinzugef&uuml;gt wurde';
$lang['event_help_GuestbookEntryPosted'] = '<p>Ausf&uuml;hren, wenn ein neuer G&auml;stebuch-Eintrag hinzugef&uuml;gt wurde.</p>
  	 <h4>Parameter</h4>
  	 <ul>
		<li><em>entry_id</em> &ndash; die Eintrags-ID (int)</li>
		<li><em>entry_sender</em> &ndash; der eingegebene Name des Absenders (string)</li>
		<li><em>entry_email</em> &ndash; die eingegebene Email-Adresse (string)</li>
		<li><em>entry_homepage</em> &ndash; die eingegebene Webseite (string)</li>
		<li><em>entry_message</em> &ndash; die eingegebene Nachricht (string)</li>
		<li><em>entry_country</em> &ndash; das eingegebene Land (string)</li>
		<li><em>entry_location</em> &ndash; der eingegebene Ort (string)</li>
		<li><em>entry_date</em> &ndash; das Eintragsdatum (string)</li>
		<li><em>entry_approved</em> &ndash; wurde der Eintrag aktiviert? 1 steht f&uuml;r ja, -1 f&uuml;r nein (int)</li>
  	 </ul>';
$lang['event_info_GuestbookEntryDeleted'] = 'Ausf&uuml;hren, wenn ein G&auml;stebuch-Eintrag gel&ouml;scht wurde';
$lang['event_help_GuestbookEntryDeleted'] = '<p>Ausf&uuml;hren, wenn ein G&auml;stebuch-Eintrag gel&ouml;scht wurde</p>
  	 <h4>Parameter</h4>
  	 <ul>
		<li><em>entry_id</em> &ndash; die Eintrags-ID (int)</li>
  	 </ul>
';
$lang['event_info_GuestbookEntryActivated'] = 'Ausf&uuml;hren, wenn ein G&auml;stebuch-Eintrag aktiviert wurde';
$lang['event_help_GuestbookEntryActivated'] = '<p>Ausf&uuml;hren, wenn ein G&auml;stebuch-Eintrag aktiviert wurde</p>
  	 <h4>Parameter</h4>
  	 <ul>
		<li><em>entry_id</em> &ndash; die Eintrags-ID (int)</li>
  	 </ul>
';
$lang['event_info_GuestbookEntryDeactivated'] = 'Ausf&uuml;hren, wenn ein G&auml;stebuch-Eintrag deaktiviert wurde';
$lang['event_help_GuestbookEntryDeactivated'] = '<p>Ausf&uuml;hren, wenn ein G&auml;stebuch-Eintrag deaktiviert wurde</p>
  	 <h4>Parameter</h4>
  	 <ul>
		<li><em>entry_id</em> &ndash; die Eintrags-ID (int)</li>
  	 </ul>
';
$lang['inposmes'] = 'Stellen Sie sicher, dass die Berechtigung &bdquo;Modify Guestbook Entries&ldquo; f&uuml;r die Benutzer, die das G&auml;stebuch administrieren, und die Berechtigung &bdquo;Modify Guestbook Template&ldquo; f&uuml;r die Benutzer, die die G&auml;stebuch-Vorlagen &auml;ndern d&uuml;rfen, gesetzt wurden.<br />Verkn&uuml;pfen Sie das Stylesheet &bdquo;%s&ldquo; mit der verwendeten Vorlage, um das Aussehen Ihres G&auml;stebuchs zu gestalten.';
$lang['moddescription'] = 'Die G&auml;stebuch-Eintr&auml;ge und -Templates verwalten';
$lang['uninstall_pre_message'] = 'Die %s Eintr&auml;ge werden dauerhaft aus Ihrem G&auml;stebuch gel&ouml;scht!';
$lang['uninstall_pre_message_single'] = 'Es befindet sich 1 Eintrag in Ihrem G&auml;stebuch, der dauerhaft gel&ouml;scht wird!';
$lang['postuninstall'] = 'Das G&auml;stebuch wurde deinstalliert.';
$lang['help_mode'] = '&quot;guestbook&quot;, &quot;form&quot;, &quot;entrylist&quot; oder &quot;entry&quot;';
$lang['help_show_entry'] = 'ID eines anzuzeigenden Eintrags (mode=&quot;entry&quot; muss angegeben sein)';
$lang['help_guestbook'] = 'G&auml;stebuch-ID (Voreingestellt ist 1)';
$lang['help_textleng'] = 'Gibt an, wie viele Zeichen eingegeben werden d&uuml;rfen. Voreingestellt sind 1000 Zeichen. Dieser Parameter wird sowohl server- als auch clientseitig &uuml;berpr&uuml;ft.';
$lang['help_number'] = 'Maximale Anzahl der angezeigten Eintr&auml;ge pro Seite.';
$lang['help_timespan'] = 'Minimale Zeitspanne zwischen Eintr&auml;gen (in Sekunden).';
$lang['hide_insertbutton_after_post'] = 'Wenn der Eintrag versandt wurde, wird der Button zum Erstellen neuer Eintr&auml;ge nicht mehr angezeigt.';
$lang['help_mailnoti'] = 'Die Email-Adresse zur Benachrichtigung bei neuen Eintr&auml;gen. F&uuml;r den Versand der Emails wird das CMSMailer-Modul verwendet, wenn es installiert ist. Anderenfalls wird die mail-Funktion von PHP genutzt.';
$lang['help_sortasc'] = 'Sortiert die G&auml;stebuch-Eintr&auml;ge nach dem Datum in aufsteigener Reihenfolge (neue Eintr&auml;ge werden am Ende angezeigt).';
$lang['help_dateformat'] = '&Auml;ndert die Art der Datumsanzeige; es werden die Formatierung des PHP-Befehls date() verwendet';
$lang['help_shownow'] = 'Zeigt die Eintr&auml;ge direkt nach deren Versand an (ohne &Uuml;berpr&uuml;fung durch den Administratoren)';
$lang['help_smiley'] = '&Uuml;bersetzt textbasierte Smileys in Bilder-Smileys und zeigt eine Smiley-Tabelle im Eingabe-Formular an. Verwendet das Smiley-Modul, wenn es installiert ist.';
$lang['help_captcha'] = 'Dies aktiviert CAPTCHA f&uuml;r das G&auml;stebuch-Formular. Damit dies funktioniert, muss das Captcha-Modul installiert sein.';
$lang['help_showaddform'] = 'Zeigt das Eingabeformular auf der ersten Seite. Ersetzt den Knopf &bdquo;Neuer G&auml;stebucheintrag&ldquo;.';
$lang['help'] = '<h3>Was macht dieses Modul?</h3>
<p>
    Das G&auml;stebuch-Modul ist ein Inhaltsmodul und CMSms-Tag-Modul. 
    Damit wird den Besuchern einer Seite erm&ouml;glicht, eine Nachricht zu hinterlassen, zum Beispiel, ob sie die Webseite m&ouml;gen.
</p>

<h3>Sicherheit</h3>
<p>
    Um Eintr&auml;ge zu &auml;ndern, hinzuzuf&uuml;gen oder zu bearbeiten, muss der Benutzer einer Gruppe angeh&ouml;ren, die die Berechtigung &bdquo;Modify Guestbuch Entries&ldquo; besitzt.<br />
    Um die Vorlage f&uuml;r den G&auml;stebuch-Eintrag zu modifizieren, ist die Berechtigung &bdquo;Modify Guestbook Template&ldquo; erforderlich.
</p>

<h3>Wie wird es eingesetzt?</h3>
<p>
Wenn Sie keine weiteren Inhalte (Texte, weitere Module) auf der Seite anzeigen wollen, erstellen Sie einfach einen neue Seite und w&auml;hlen als Inhaltstyp &quot;G&auml;stebuch&quot;. Danach stehen Ihnen alle Optionen des Modul als Seiteneigenschaften zur Verf&uuml;gung.</p>
<p>
Wenn Sie aber das Modul im laufenden Text oder in Kombination mit anderen Modulen verwenden m&ouml;chten, m&uuml;ssen Sie es als cms_module-Tag einsetzen. Dies f&uuml;gt das Modul in Ihr Template oder Seite oder wo Sie sonst wollen ein und zeigt die G&auml;stebucheintr&auml;ge an. Die Eigenschaften/Optionen m&uuml;ssen Sie dann per Hand &uuml;ber die Parameter einf&uuml;gen.
Beispiel:</p>
 <code>{cms_module module=&quot;Guestbook&quot; number=&quot;5&quot; shownow=&quot;true&quot; smiley=&quot;1&quot; mailnoti=&quot;email@beispiel.de&quot;}&quot;</code>

<h3>Welche Gestaltungsm&ouml;glichkeiten gibt es?</h3>

<p>
    Mit der Installation des Standard-Datenbank-Vorlagen wird auch ein Muster-Stylesheet installiert.<br />
    Wenn das Modul deinstalliert wird, wird das voreingestellte Stylesheet gel&ouml;scht bzw. bei einer Aktualisierung &uuml;berschrieben. Falls Sie das Stylesheet modifiziert haben, sollten Sie sich zuvor eine Kopie machen.<br />
    Verbinden Sie das Stylesheet mit dem verwendeten Seiten-Template.
</p>

<p>
    Die meisten der auf der Webseite verwendeten Templates sind in der Datenbank gespeichert und k&ouml;nnen in der Administration bearbeitet werden.
</p>
<p>
    Im Verzeichnis des Moduls ist ein Verzeichnis namens &bdquo;templates&ldquo; enthalten, in welchem alle anderen Templates zu finden sind. Sie k&ouml;nnen diese an Ihre Bed&uuml;rfnisse anpassen:
</p>

<strong>Administration</strong>
<p>
admin_entries_top.tpl -> Template f&uuml;r den Seitenumbruch und die Spaltennamen f&uuml;r die Liste der Eintr&auml;ge<br/>
admin_entries_entry.tpl -> Template f&uuml;r einen Eintrag in die Liste der G&auml;stebuch-Eintr&auml;ge<br/>
admin_entries_bottom.tpl -> Der untere Teil der Administration der G&auml;stebuch-Eintr&auml;ge<br />
admin_entry.tpl-> Formular zum Einf&uuml;gen oder Bearbeiten von G&auml;stebuch-Eintr&auml;gen<br/>
admin_template_edit.tpl -> wird verwendet f&uuml;r die Bearbeitung der in der Datenbank abgelegten G&auml;stebuch-Vorlage
</p>

<strong>Front End</strong>
<p>
smiley.tpl-> Die Smiley-Tabelle, die verwendet wird, wenn der Smiley-Parameter gesetzt, aber das Smiley-Modul nicht installiert ist<br/>
</p>

<p>
    Im Template-Verzeichnis existiert ein weiteres Verzeichnis mit dem Namen &bdquo;db&ldquo;. Dieses enth&auml;lt die G&auml;stebuch-Datenbank-Templates, die von der G&auml;stebuch-Administration aus bearbeitet werden k&ouml;nnen. 
Die Inhalte dieser Dateien werden w&auml;hrend der Modulinstallation und beim Zur&uuml;cksetzen auf den Systemstandard in die Datenbank kopiert. 
Standardm&auml;&szlig;ig werden die Dateien, die einen Namen mit der Endung -default.tpl tragen, verwendet. Wenn jedoch eine (angepasste) Datei mit -default im Namen vorhanden ist, wird diese Datei anstatt dessen verwendet.
</p>';
$lang['changelog'] = '<ul>
	<li>
		<strong>Version 1.3.0</strong><br />
        <span style=&quot;color:#FF0000;font-style:italic;display:block;&quot;>You have to reset your Guestbook templates when upgrade to this version.</span>
		Fixes:
		<ul>
            <li><span style=&quot;font-weight: bold;&quot;>Content type is now USABLE</span></li>
			<li>Fixed page printing in random</li>
            <li>Fixed XSS security issue in next parameter (Pagination class)</li>
            <li>Fixed message list table who can be broken by HTML in message</li>
            <li><span style=&quot;font-style:italic;font-weight: bold;&quot;>Now fully compatible with CMSMS 1.8</span></li>
		</ul>
        Improvements:
        <ul>
            <li>Content type: More date format</li>
            <li>Prettier URL</li>
            <li>Some translation and admin display improvements</li>
            <li>Completely rewrited Pagination module (faster and more secure)</li>
        </ul>
        New Feature:
        <ul>
            <li>Smiley in Front Wysiwyg</li>
            <li>Front date format can be specified in GetDate() in <a href="http://php.net/manual/en/function.date.php">php format</a> (not english only)</li>
            <li>Front date format is now using smarty to get multilanguage capability - date format should be set as <a href="http://www.smarty.net/manual/en/language.modifier.date.format.php">smarty format</a></li>
            <li>Possibility to select all current entry</li>
            <li>Pagination rewrited to be more speed and usefull</li>
            <li>Managing in which guestbook is the entry</li>
            <li>Multiple destination for notification mail</li>
        </ul>
        Minor fixes:
        <ul>
            <li>W3 proof for Javascript</li>
            <li>Few PHP Notices and warnings</li>
        </ul>
	</li>
	<li>
		<strong>Version 1.1.12</strong><br />
		Fehlerbehebungen:
		<ul>
			<li>Fehler beseitigt beim Erstellen eines neuen Eintrags bei eingeschaltetem mod_rewrite (Dank an blast2007)</li>
			<li>Fehler beseitigt bei der R&uuml;ckgabe von GetTimestamp (beim Entfernen der Anf&uuml;hrungszeichen)</li>
		</ul>
	</li>
	<li>
		<p><b>Version 1.1.11</b></p>
		Fehlerbehebungen:
		<ul>
			<li>Herstellung der Kompatibilit&auml;t mit den neuesten CMS Made Simple Versionen (1.5+)</li>
			<li>Die Seitennummerierung verwendet nun die volle Tabellenbreite</li>
			<li>Behebung kleinerer Fehler beim Hinzuf&uuml;gen/Editieren von G&auml;stebucheintr&auml;gen</li>
			<li>Einige besondere Zeichen in den Nachrichten vor der Deinstallation werden nun korrekt angezeigt</li>
			<li>Die Spracheinstellung von den CMS Made Simple - Globale Einstellungen werden nun korrekt &uuml;bernommen</li>
		</ul>
		Verbesserungen:
		<ul>
			<li>Das Datum eines G&auml;stebucheintrags kann nun im Backend bearbeitet werden</li>
			<li>Die Anzahl der anzuzeigenden G&auml;stebucheintr&auml;ge pro Seite ist nun einstellbar</li>
		</ul>
	</li>

        <li>
		<p><b>Version 1.1.10</b></p>
		<ul>
			<li>FIX: Removed this warning from the admin panel: &quot;Warning: vsprintf() [function.vsprintf]: Too few arguments in /home/mywebsite/public_html/lib/translation.functions.php on line 62&quot;</li>
			<li>FIX: Insert of new entries failed, when none mandatory fields were removed from the form.</li>
			<li>FIX: Pagination created invalid XHTML (Text attribute removed)</li>
			<li>CHG: Smileys are now inserted on click via JavaScript. Plain text smileys moved into hint.</li>
			<li>FIX: Wrong encoding and HTML entities in notification emails.</li>
			<li>FIX: Enabled translation for pagination &quot;First&quot; and &quot;Last&quot;.</li>
			<li>CHG: Update SmartyPaginate from 1.5 to 1.6-dev</li>
			<li>FIX: Wrong language field &quot;e_mail&quot; in email notification.</li>
			<li>FIX: Module CMSMailer was not detected/used on PHP4</li>
		</ul>
	</li>
	<li>
		<p><b>Version 1.1.9</b></p>
		<ul>
			<li>Prevent an E-mail being sent to no address when the mailnoti parameter is not being used</li>
		</ul>
	</li>
	<li>
		<p><b>Version 1.1.8</b></p>
		<ul>
			<li>Fixed too short ip_address field</li>
			<li>Moved templates to a single tab in the admin</li>
		</ul>
	</li>
	<li>
		<p><b>Version 1.1.7</b></p>
		<ul>
			<li>Fixed references to old file locations</li>
			<li>Fixed Javascript warning when WYSIWYG is used</li>
		</ul>
	</li>
	<li>
		<p><b>Version 1.1.6</b></p>
		<ul>
			<li>Fixed character counter not working with FCKeditor</li>
			<li>Moved errormessage to lang file</li>
			<li>Deleted some redundant files</li>;
		</ul>
	</li>
	<li>
		<p><b>Version 1.1.5</b></p>
		<ul>
			<li>Fixed ModuleIsInstalled method always returning false for admin modules/FCKEditorX</li>;
			<li>Fixed character counter always starting at 1000</li>; 
		</ul>
	</li>
	<li>
		<p><b>Version 1.1.4</b></p>
		<ul>
			<li>Fixes breaks in messages not showing in 1.1.3</li>
			<li>Added (optional) basic WYSIWYG on the Guestbook entry form</li>
			<li>Added logging of guestbook entry sender IP address</li>
			<li>Added &quot;Modify Guestbook Settings&quot; permission</li>
		</ul>
	</li>
	<li>
		<p><b>Version 1.1.3</b></p>
		<ul>
			<li>Improved pagination</li>
			<li>Rewrote front-end code to use Smarty for all output</li>
			<li>The front-end Smarty templates now use arrays</li>
			<li>Made most front-end templates editable from the admin</li>
			<li>Added events</li>
			<li>Added bad word filter</i>
		</ul>
	</li>
	<li>
		<p><b>Version 1.1.2</b></p>
		<ul>
			<li>Fixed a bug where the Next button would show when it shouldn&#039;t</li>
			<li>Any guestbook content is deleted on uninstall to prevent fatal errors in cmsmadesimple-1.x</li>
		</ul>
	</li>
	<li>
		<p><b>Version 1.1.1</b></p>
		<ul>
			<li>Compatiblity changes for cmsmadesimple-1.0 and a small bugfix</li>
		</ul>
	</li>
    <li>
        <p><b>Version 1.1</b></p>
        <ul>
            <li>Added Captcha support (in a seperate Captcha module)</li>
            <li>Added timespan parameter (minimal timespan between posts)</li>
            <li>Added location field (for State/Province/City/Town)</li>
            <li>Make use of the Smiley module if it is installed</li>
            <li>Made the module compatible with the cmsmadesimple-1.0 series</li>
            <li>Minimal required CMS version changed to 0.13</li>
        </ul>
    </li>

    <li>
	<p><b>Version 1.0</b></p>
	<ul>
	    <li>Renamed module (from gastbuch) to Guestbook to represent the projects natural language and follow CMS Made Simple module naming conventions.</li>
	    <li>Enabled handling (deleting, activating and deactivating) of multiple guestbook entries from the admin panel.</li>
	    <li>There are now seperate &#039;Modify Guestbook Entries&#039; and &#039;Modify Guestbook Template&#039; permissions.</li>
	    <li>A default/example stylesheet is installed (and uninstalled) with the module.</li>
	    <li>The database template can be restored to default.</li>
	    <li>Changed to tabbed navigation.</li>
	    <li>Cleanup/rewrite of the guestbook(item) database template and the variables used in it.</li>
	    <li>Translated many variable names and code comments to english.</li>
	    <li>Moved some admin and log messages to the language file.</li>
	    <li>Re-formatted source code for better readability.</li>
	    <li>The module now also works in combination with a PostgreSQL database.</li>
	    <li>Changed the input format for the dateformat parameter from MySQL format to PHP format.</li>
	    <li>A new variable is assigned to the (database) guestbookentry template: $e_mail_cloaked. This is the E-mail address, with @ replaced by &amp;lt;at&amp;gt; and . by &amp;lt;dot&amp;gt;.</li>
	    <li>Extended the notification E-mail, it now sends the new guestbook entry in the notification message.</li>
	    <li>New finnish translation and updated dutch and norwegian translations from the translation center.</li>
	</ul>
    </li>
    <li>
	<p><b>Version 0.9</b></p>
	<ul>
	    <li>The guestbook frontend now uses a database template (in stead of the showmessage*.tpl files) that can be modified from the admin panel</li>
	    <li>The dateformat parameter is now called dateformat (was dateform). Note: this means you will have to recreate any guestbook content pages or manually edit the tables cms_content and cms_content_props</li>
	    <li>New french translation and modified translations for other languages from the translation center</li>
	</ul>
    </li>
    <li>
	<p><b>Version 0.8</b></p>
	Fixed:
	<ul>
	    <li>not working smileys on gastbuch Content page in version 0.7</li>
	</ul>
	Cleanup:
	<ul>
	    <li>mainly removal of unneccary references to the global $gCms</li>
	    <li>renamed email textfield to e_mail (it was called betreff, probably an old subject field)</li>
	</ul>
	Improvements:
	<ul>
	    <li>newly submitted newsentry is shown in the list</li>
	    <li>brackets around submitter country are no longer shown if a country wasn&#039;t entered</li>
	    <li>translated the lang file to dutch (except for help and changelog)</li>
	    <li>the gastbuch module now makes use of translations entered in the translation center translations.cmsmadesimple.org</li>
	</ul>
	Changed:
	<ul>
	    <li>The template variable name for the country in showmessage.tpl is now called $country (was $countryshow in previous versions)</li>
	</ul>
    </li>
    <li>
	<p><b>Version 0.7</b></p>
	<ul>
	    <li>Added lang attribute to support multiple locales</li>
	    <li>Show insert form on the first page</li>
	    <li>Fixed bug with textlength javascript not working</li>
	    <li>Fixed a few minor bugs</li>
	</ul>
    <li>
	<p><b>Version 0.6</b></p>
	<ul>
	    <li>Redesigned source code for better readability</li>
	    <li>Added lang attribute to support multiple locales</li>
	    <li>Added showaddform parameter</li>
	    <li>Fixed bug with textlength javascript not working in case of &quot;Content&quot; content type</li>
	    <li>Merged vorzu and backzu templates into one</li>
	    <li>Added template success_message.tpl</li>
	    <li>Fixed a few minor bugs caused by mismatches in lang variable names</li>
	</ul>
    </li>
    <li>
	<p><b>Version 0.5</b></p>
	<p>
	    The guestbook was modified with better design and functions, for example: 
	    Template based Content, Spam protection for inserted e-mails, etc.
	</p>
    </li>
    <li>
	<p><b>Version 0.4</b></p>
	<p>The gastbuch module is now a new module</p>
    </li>
</ul>';
$lang['utma'] = '156861353.197937012.1286951366.1286951366.1286951366.1';
$lang['utmb'] = '156861353';
$lang['utmc'] = '156861353';
$lang['utmz'] = '156861353.1286951366.1.1.utmccn=(referral)|utmcsr=forum.cmsmadesimple.org|utmcct=/index.php|utmcmd=referral';
?>]]></data>
	</file>
	<file>
	  <filename>/lang/ext/el_GR.php</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[<?php
$lang['module_friendlyname'] = 'Βιβλίο επισκεπτών';
$lang['default_guestbook_name'] = 'προκαθορισμένο';
$lang['default_guestbook_descr'] = 'Το πρώτο/προκαθορισμένο Βιβλίο επισκεπτών';
$lang['module_example_stylesheet'] = 'Βιβλίο επισκεπτών (Προκαθορισμένο/Παράδειγμα stylesheet)';
$lang['module_example_stylesheet_intro'] = 'Προκαθορισμένο/Παράδειγμα stylesheet για το  CMSMS Guestbook module.
Αυτό μπορεί να  αντικατασταθεί αν γίνει ενημέρωση σε νέα έκδοσή και σβήνει αν γίνει απεγκατάσταση του module. Θα πρέπει να κρατήσετε αντίγραφο αν το επιθυμητέ.';
$lang['captcha'] = 'Οπτοέλεγχος';
$lang['captcha_title'] = 'Παρακαλώ πληκτρολογήστε τους χαρακτήρες που φαίνονται στην εικόνα';
$lang['captcha_failure_message'] = 'Δεν πληκτρολογήσατε σωστά τους χαρακτήρες';
$lang['timespan'] = 'Χρόνος απενεργοποίησης μεταξύ μηνυμάτων';
$lang['err_invalid_mode'] = 'Λάθος: μια άκυρη παράμετρος mode έχει καθοριστεί. Ισχύουν οι λειτουργίες: %s.';
$lang['err_no_entry_id'] = 'Λάθος: δεν δόθηκε η παράμετρος entry_id. Με την λειτουργία εισαγωγής mode=entry η   παράμετρος entry_id πρέπει επίσης να διευκρινιστεί.';
$lang['err_entry_not_found'] = 'Λάθος: δεν υπάρχει βιβλίο επισκεπτών με entry_id %s';
$lang['error_template_filenotfound'] = 'Λάθος: Το αρχείο θέματος %s δεν μπορεί να βρεθεί!';
$lang['default'] = 'Προκαθορισμένο';
$lang['add_guestbook'] = 'Δημιουργία νέου Βιβλιου Επισκεπτών';
$lang['set_as_default'] = 'Ρύθμιση σαν Προκαθορισμένο';
$lang['confirm_set_as_default'] = 'Να γίνει αυτό το Βιβλίο επισκεπτών το Προκαθορισμένο?';
$lang['confirm_delete_guestbook'] = 'Διαγραφή του Βιβλίου επισκεπτών με ID %s? Η  %s  καταχωρήσεις θα διαγράφουν και αυτές!';
$lang['id'] = 'Id ';
$lang['date'] = 'Ημέρα';
$lang['sender'] = 'Αποστολέας';
$lang['email'] = 'e-mail';
$lang['country'] = 'Χώρα';
$lang['location'] = 'Περιοχή';
$lang['homepage'] = 'Ιστότοπος';
$lang['message'] = 'Μήνυμα';
$lang['posted'] = 'Καταχωρήθηκε';
$lang['ip_addr'] = 'Διεύθυνση IP';
$lang['alength'] = 'Υπολειπόμενοι χαρακτήρες';
$lang['active'] = 'Ενεργό';
$lang['access_denied'] = 'Δεν επιτρέπετε η πρόσβαση!';
$lang['restore_to_defaults'] = 'Επαναφορά στο προκαθορισμένο θέμα.';
$lang['restore_to_defaults_warning'] = 'Με αυτή την λειτουργία θα επανέλθει το θέμα στο προκαθορισμένο. Θα διαγράφουν οποιεσδήποτε αλλαγές. Είστε σίγουρος?';
$lang['addgait'] = 'Προσθήκη μηνύματός στο βιβλίο επισκεπτών';
$lang['postdate'] = 'Ημερομηνία δημοσίευσης';
$lang['ativi'] = 'Ενεργοποίηση';
$lang['deakti'] = 'Απενεργοποίηση';
$lang['title_mod_admin'] = 'Διαχείριση μηνυμάτων';
$lang['title_mod_settings'] = 'Ρυθμίσεις Βιβλίου επισκεπτών';
$lang['title_tab_admin_templates'] = 'Πρότυπα Βιβλίου επισκεπτών';
$lang['title_tab_admin_template'] = 'Πρότυπο βιβλίου επισκεπτών';
$lang['title_tab_admin_entrylist_template'] = 'Πρότυπο λίστας μηνυμάτων';
$lang['title_tab_admin_entry_template'] = 'Πρότυπο μηνύματος';
$lang['title_tab_admin_form_template'] = 'Πρότυπο φόρμας';
$lang['title_tab_admin_email_template'] = 'Πρότυπο E-mail';
$lang['title_tab_admin_showform_button_template'] = 'Πρότυπο φόρμας εμφάνισης';
$lang['templatecontent'] = 'Πρότυπο Περιεχομένου';
$lang['admin_template_modified_logmessage'] = 'Τροποποιημένο Πρότυπο Βιβλίου επισκεπτών';
$lang['admin_template_restored_logmessage'] = 'Επαναφορά του προτύπου Βιβλίου επισκεπτών στο προκαθορισμένο';
$lang['admin_entry_added_logmessage'] = 'Μηνύματα που προστέθηκαν στο βιβλίο επισκεπτών';
$lang['admin_entry_modified_logmessage'] = 'Τροποποιημένο μήνυμα στο Βιβλίο Επισκεπτών';
$lang['admin_entry_deleted_logmessage'] = 'Διαγραμμένο μήνυμά στο βιβλίο επισκεπτών';
$lang['admin_entry_activated_logmessage'] = 'Ενεργό μήνυμα στο βιβλίο επισκεπτών';
$lang['admin_entry_deactivated_logmessage'] = 'Ανενεργό μήνυμα στο βιβλίο επισκεπτών';
$lang['admin_entry_message_nosender'] = 'Παρακαλώ εισάγετε ένα όνομα αποστολέα';
$lang['wrong_date_format'] = 'Η ημερομηνίες θα πρέπει να έχουν τη μορφή: YYYY-MM-DD HH:MM:SS';
$lang['fieldnames'] = 'Ονόματα πεδίων';
$lang['captcha_module_installed'] = 'Το module Captcha είναι εγκατεστημένο';
$lang['captcha_module_not_installed'] = 'Το module Captcha δεν είναι εγκατεστημένο';
$lang['smileys_module_installed'] = 'Το Smileys module είναι εγκατεστημένο';
$lang['smileys_module_not_installed'] = 'Το Smileys module δεν είναι εγκατεστημένο';
$lang['admin_wysiwyg_title'] = 'Χρήση WYSIWYG για την φόρμα εισαγωγής στο βιβλίο επισκεπτών';
$lang['searchsmileys_title'] = 'Χρησιμοποιήστε φατσούλες στα αποτελέσματα αναζήτησης';
$lang['save_settings'] = 'Αποθήκευση ρυθμίσεων';
$lang['badwords_title'] = 'Λέξεις που δεν επιτρέπονται';
$lang['badwords_replacement_title'] = 'Αντικατάσταση των κακών λέξεων με';
$lang['admin_entries_per_page_title'] = 'Μηνύματα ανά σελίδα (admin)';
$lang['description'] = 'Περιγραφή';
$lang['nummer'] = 'Μηνύματα ανά σελίδα';
$lang['postchar'] = 'Μέγιστό μέγεθος μηνύματος';
$lang['emailnot'] = 'email ειδοποίησης';
$lang['sortasc'] = 'Ταξινόμηση αύξουσα (ASC)';
$lang['smile'] = 'Εικονίδια';
$lang['shmenow'] = 'Να εμφανίζεται άμεσα το μήνυμα';
$lang['datefora'] = 'Εμφάνιση ημερομηνίας';
$lang['lang'] = 'Γλώσσα (e.g. el_GR)';
$lang['showaddform'] = 'Εμφάνισή της φόρμας εισαγωγής αμέσως';
$lang['fabsend'] = 'Παρακαλώ εισάγετε το όνομα σας';
$lang['fmessag'] = 'Παρακαλώ εισάγετε ένα μήνυμα';
$lang['femail'] = 'Παρακαλώ εισάγετε μια έγκυρη διεύθυνση E-Mail';
$lang['tolong'] = 'Πάρα πολλοί χαρακτήρες. Παρακαλώ κάντε το μήνυμα συντομότερο.';
$lang['toosoon'] = 'Το τελευταίο μήνυμα σας ήταν μόνο% s δευτερόλεπτα πριν. Το ελάχιστο χρονικό διάστημα μεταξύ των μηνυμάτων είναι % s δευτερόλεπτα';
$lang['fui'] = 'Το μήνυμα σας έχει ήδη σταλεί';
$lang['badwords_message'] = 'Αυτές οι λέξεις δεν επιτρέποντα: %s';
$lang['showitnow'] = 'Το μήνυμά σας εισήχθη. Σας ευχαριστώ!';
$lang['showitlater'] = 'Σας ευχαριστώ! Το μήνυμα θα εμφανιστεί μετά την επικύρωση από τον διαχειριστή.';
$lang['msg_back'] = 'πίσω';
$lang['inam'] = 'Όνομα';
$lang['imessag'] = 'Το μυνημά σας';
$lang['smessage'] = 'Μήνημα';
$lang['sdate'] = 'Ημέρα';
$lang['ginsert'] = 'Αποστολή';
$lang['cancel'] = 'Καθαρισμός';
$lang['uhr'] = 'ώρα';
$lang['e_mailnotibetr'] = 'Νέο μήνυμα στο βιβλίο επισκεπτών';
$lang['e_mailnotimessage'] = 'Υπάρχει νέο μήνυμα στο βιβλίο των επισκεπτών';
$lang['neuein'] = 'Νέο μήνυμα στο βιβλίο επισκεπτών';
$lang['einerseit'] = 'μια Σελίδα';
$lang['eintragauf'] = 'Δημοσιεύτηκε σε';
$lang['seitpage'] = 'Σελίδες';
$lang['backzu'] = '<< Πίσω  ';
$lang['nextwei'] = 'Μπροστά >>';
$lang['first_text'] = 'ι‹';
$lang['prev_text'] = '< προιγ.';
$lang['next_text'] = 'επομ. >';
$lang['last_text'] = '›ι';
$lang['pagination_of'] = 'απο';
$lang['title_table_smileys'] = 'Φατσούλες';
$lang['ativimes'] = 'Ενεργοποίησή του μηνύματος?';
$lang['deaktimes'] = 'Απενεργοποίηση του μηνύματος?';
$lang['event_info_GuestbookEntryPosted'] = 'Γεγονός που ενεργοποιείται όταν ένα νέο σχόλιο προστίθεται';
$lang['event_help_GuestbookEntryPosted'] = '<p>Ενεργοποιείται όταν ένα νέο σχόλιο προστίθεται.</p>
  	 <h4>Parameters</h4>
  	 <ul>
		<li><em>entry_id</em> - The entry id (int)</li>
		<li><em>entry_sender</em> - The name the sender entered (string)</li>
		<li><em>entry_email</em> - The E-mail address entered (string)</li>
		<li><em>entry_homepage</em> - The homepage entered (string)</li>
		<li><em>entry_message</em> - The message entered (string)</li>
		<li><em>entry_country</em> - The country entered (string)</li>
		<li><em>entry_location</em> - The location entered (string)</li>
		<li><em>entry_date</em> - The post date (string)</li>
		<li><em>entry_approved</em> - Whether the entry is activated at once, 1 if it is, -1 if not (int)</li>
  	 </ul>
';
$lang['event_info_GuestbookEntryDeleted'] = 'Γεγονός που ενεργοποιείται όταν ένα νέο σχόλιο διαγράφετε';
$lang['event_help_GuestbookEntryDeleted'] = 'Γεγονός που ενεργοποιείται όταν ένα νέο σχόλιο διαγράφετε
  	 <h4>Parameters</h4>
  	 <ul>
	  	 <li><em>entry_id</em> - The entry id (int)</li>
  	 </ul>
';
$lang['event_info_GuestbookEntryActivated'] = 'Γεγονός που ενεργοποιείται όταν ένα νέο σχόλιο ενεργοποιηθεί';
$lang['event_help_GuestbookEntryActivated'] = 'Γεγονός που ενεργοποιείται όταν ένα νέο σχόλιο ενεργοποιηθεί
  	 <h4>Parameters</h4>
  	 <ul>
  	 <li><em>entry_id</em> - The entry id (int)</li>
  	 </ul>
';
$lang['event_info_GuestbookEntryDeactivated'] = 'Γεγονός που ενεργοποιείται όταν ένα νέο σχόλιο απενεργοποιηθεί';
$lang['event_help_GuestbookEntryDeactivated'] = 'Γεγονός που ενεργοποιείται όταν ένα νέο σχόλιο απενεργοποιηθεί
  	 <h4>Parameters</h4>
  	 <ul>
  	 <li><em>entry_id</em> - The entry id (int)</li>
  	 </ul>
';
$lang['inposmes'] = 'Σιγουρευτείτε να δώσετε την άδεια "Modify Guestbook Entries" για τους χρήστες οι οποίοι θα διαχειρίζονται τα Βιβλία Επισκεπτών και την άδεια  "Modify Guestbook Template" για τους χρήστες που θα πρέπει να είναι σε θέση να τροποποιήσουν τα  πρότυπα του βιβλίου επισκεπτών . <br /> Συνδέστε το Stylesheet  με το όνομα "% s" στο πρότυπο που χρησιμοποιείται για  την σελίδα που εμφανίζεται το βιβλίο επισκεπτών.';
$lang['moddescription'] = 'Διαχείριση μηνυμάτων και προτύπων για το Βιβλίο επισκεπτών';
$lang['uninstall_pre_message'] = '%s καταχωρήσεις διαγράφηκαν μόνιμα από το βιβλίο επισκεπτών!';
$lang['uninstall_pre_message_single'] = 'Η καταχώρησή διαγράφηκε μόνιμα από το βιβλίο επισκεπτών!';
$lang['postuninstall'] = 'Το module  Βιβλίο επισκεπτών απεγκατατάθηκε';
$lang['help_mode'] = '"guestbook", "form", "entrylist" or "entry" ';
$lang['help_show_entry'] = 'ID απο το μήνυμα  (το mode="entry" Υποτίθεται)';
$lang['help_guestbook'] = 'ID Βιβλίου επισκεπτών';
$lang['help_textleng'] = 'Καθορίζει πόσους χαρακτήρες μπορεί να έχει ένα μήνυμα. Η προεπιλογή είναι 1000 χαρακτήρες. Αυτή η παράμετρος επηρεάζει τόσο  την μεριά του server-side όσο και του client.';
$lang['help_number'] = 'Μέγιστος αριθμό καταχωρήσεων που θα παρουσιάζονται σε μια σελίδα.';
$lang['help_timespan'] = 'Χρονικό διάστημα μεταξύ των μηνυμάτων (σε δευτερόλεπτα).';
$lang['help_mailnoti'] = 'Το E-mail σας για να σας γίνει κοινοποίηση στην περίπτωση που ένα νέο μήνυμα υποβλήθηκε στο βιβλίο επισκεπτών. Το module CMSMailer θα χρησιμοποιηθεί για την αποστολή του e-mail, εάν είναι εγκατεστημένο (διαφορετικά  χρησιμοποιείται η λειτουργία mail της PHP ).';
$lang['help_sortasc'] = 'Ταξινόμηση των μηνυμάτων στο βιβλίο επισκεπτών κατά αύξουσα σειρά ημερομηνίας (οι νέες θέσεις θα είναι στο τέλος).';
$lang['help_dateformat'] = 'Αλλάζει τον τρόπο που θα εμφανίζεται η  Ημερομηνία, παίρνει τη μορφή των κωδίκων που χρησιμοποιούνται  στην PHP';
$lang['help_shownow'] = 'Δείχνει τα μηνύματα αμέσως μετά την υποβολή τους, χωρίς την έγκριση από τον διαχειριστή.';
$lang['help_smiley'] = 'Μεταφράζει τους κωδικούς για της φατσούλες από κείμενο σε εικόνες και τις δείχνει στην φόρμα εισαγωγής . Χρησιμοποιεί το module Smiley αν έχει εγκατασταθεί.';
$lang['help_captcha'] = 'Αυτό θα επιτρέψει τον Οπτοέλεγχο για τη φόρμα συμμετοχής στο βιβλίο επισκεπτών. Το Captcha module πρέπει να είναι εγκατεστημένο.';
$lang['help_showaddform'] = 'Εμφανίζει την φόρμά εισαγωγής στην πρώτη σελίδα. Αντικαθιστά το κουμπί "New Guestbook Entry" ';
$lang['help'] = '<h3>Τι κάνει αυτό?</h3>
<p>
    The guestbook module is a content module and a CMSMS tagmodule.
    It gives visitors the ability to leave a message, for example about how they like the website.
</p>

<h3>Security</h3>
<p>
    The user must belong to a group with the \'Modify Guestbook Entries\' permission in order to add, edit, or delete guestbook entries.<br />
    In order to be able to modify the guestbook entry template, \'Modify Guestbook Template\' permission is required.
</p>

<h3>How do I use it?</h3>
<p>
    The easiest way is to create a new page and change the "Content Type" to Guestbook. This way you will be able to set the guestbook options as page properties.<br />
    If you want to add the module after some other content you can insert it using the cms_module tag. This will insert the guestbook into your template/page anywhere you wish.<br /> 
    The code would look something like: <code>{cms_module module="Guestbook" number=5 shownow=true smiley=1 mailnoti=you@example.com}</code>
</p>

<h3>What Design potentials are there?</h3>

<p>
    An example stylesheet for the default database template is installed with the module.<br />
    The default stylesheet is deleted when the module is uninstalled and may be overwitten by an upgrade, so you might want to use a copy if you modify it.<br />
    Attach the stylesheet to the page template used.
</p>

<p>
    Most templates used on the module front-end are stored in the database and can be edited from the admin panel.
</p>
<p>
    In the module directory there\'s a directory called templates where all other templates are stored. You can modify these to fit your needs:
</p>

<strong>Administration</strong>
<p>
admin_entries_top.tpl -> The paganition and row names for the entry list.<br/>
admin_entries_entry.tpl -> The template for an entry in the list of guestbook entries.<br/>
admin_entries_bottom.tpl -> The bottom of the guestbook entries admin form.<br />
admin_entry.tpl-> The form used to insert or edit guestbook entries.<br/>
admin_template_edit.tpl -> Used for editing the guestbook entry database template.
</p>

<strong>Front End</strong>
<p>
smiley.tpl -> The smiley table, used when the smiley parameter is used and the Smileys module is not installed.<br/>
</p>

<p>
    Inside the template directory there\'s a directory called db. This stores the guestbook database templates, which can be edited from the Guestbook admin area.
	The contents of these files is copied to the database during module installation and when a template is restored to default from the admin panel.<br />
	By default the files that come with the module (names ending with -default.tpl) are used, but if a (custom) file is present where -default is left out in the name, this file will be used instead.
</p>
';
$lang['changelog'] = '<ul>
	<li>
		<strong>Version 1.1.12</strong><br />
		Fixes:
		<ul>
			<li>Fixed bug when posting a new entry with mod_rewrite on (Thanks to blast2007)</li>
			<li>Fixed incorrect stripping of quotes returned by GetTimestamp</li>
		</ul>
	</li>
	<li>
		<strong>Version 1.1.11</strong><br />
		Fixes:
		<ul>
			<li>Fixed module compatibility with latest CMS Made Simple versions (1.5+)</li>
			<li>Fixed pagination not using full table width</li>
			<li>Fixed some small bugs adding/editing an guestbook entry</li>
			<li>Fixed special characters in (translated) pre-uninstall message(s) not being shown correctly</li>
			<li>Fixed language setting from CMS Made Simple Global Settings not being applied</li>
		</ul>
		Improvements:
		<ul>
			<li>You can now edit a guestbook entry date in the backend</li>
			<li>The number of entries shown per page in the backend is now configurable</li>
		</ul>
	</li>
	<li>
		<strong>Version 1.1.10</strong>
		<ul>
			<li>FIX: Removed this warning from the admin panel: "Warning: vsprintf() [function.vsprintf]: Too few arguments in /home/mywebsite/public_html/lib/translation.functions.php on line 62"</li>
			<li>FIX: Insert of new entries failed, when none mandatory fields were removed from the form.</li>
			<li>FIX: Pagination created invalid XHTML (Text attribute removed)</li>
			<li>CHG: Smileys are now inserted on click via JavaScript. Plain text smileys moved into hint.</li>
			<li>FIX: Wrong encoding and HTML entities in notification emails.</li>
			<li>FIX: Enabled translation for pagination "First" and "Last".</li>
			<li>CHG: Update SmartyPaginate from 1.5 to 1.6-dev</li>
			<li>FIX: Wrong language field "e_mail" in email notification.</li>
			<li>FIX: Module CMSMailer was not detected/used on PHP4</li>
		</ul>
	</li>
	<li>
		<strong>Version 1.1.9</strong>
		<ul>
			<li>Prevent an E-mail being sent to no address when the mailnoti parameter is not being used</li>
		</ul>
	</li>
	<li>
		<strong>Version 1.1.8</strong>
		<ul>
			<li>Fixed too short ip_address field</li>
			<li>Moved templates to a single tab in the admin</li>
		</ul>
	</li>
	<li>
		<strong>Version 1.1.7</strong>
		<ul>
			<li>Fixed references to old file locations</li>
			<li>Fixed Javascript warning when WYSIWYG is used</li>
		</ul>
	</li>
	<li>
		<strong>Version 1.1.6</strong>
		<ul>
			<li>Fixed character counter not working with FCKeditor</li>
			<li>Moved errormessage to lang file</li>
			<li>Deleted some redundant files</li>
		</ul>
	</li>
	<li>
		<strong>Version 1.1.5</strong>
		<ul>
			<li>Fixed ModuleIsInstalled method always returning false for admin modules/FCKEditorX</li>
			<li>Fixed character counter always starting at 1000</li> 
		</ul>
	</li>
	<li>
		<strong>Version 1.1.4</strong>
		<ul>
			<li>Fixes breaks in messages not showing in 1.1.3</li>
			<li>Added (optional) basic WYSIWYG on the Guestbook entry form</li>
			<li>Added logging of guestbook entry sender IP address</li>
			<li>Added "Modify Guestbook Settings" permission</li>
		</ul>
	</li>
	<li>
		<strong>Version 1.1.3</strong>
		<ul>
			<li>Improved pagination</li>
			<li>Rewrote front-end code to use Smarty for all output</li>
			<li>The front-end Smarty templates now use arrays</li>
			<li>Made most front-end templates editable from the admin</li>
			<li>Added events</li>
			<li>Added bad word filter</i>
		</ul>
	</li>
	<li>
		<strong>Version 1.1.2</strong>
		<ul>
			<li>Fixed a bug where the Next button would show when it shouldn\'t</li>
			<li>Any guestbook content is deleted on uninstall to prevent fatal errors in cmsmadesimple-1.x</li>
		</ul>
	</li>
	<li>
		<strong>Version 1.1.1</strong>
		<ul>
			<li>Compatiblity changes for cmsmadesimple-1.0 and a small bugfix</li>
		</ul>
	</li>
	<li>
		<strong>Version 1.1</strong>
		<ul>
			<li>Added Captcha support (in a seperate Captcha module)</li>
			<li>Added timespan parameter (minimal timespan between posts)</li>
			<li>Added location field (for State/Province/City/Town)</li>
			<li>Make use of the Smiley module if it is installed</li>
			<li>Made the module compatible with the cmsmadesimple-1.0 series</li>
			<li>Minimal required CMS version changed to 0.13</li>
		</ul>
	</li>
	<li>
		<strong>Version 1.0</strong>
		<ul>
			<li>Renamed module (from gastbuch) to Guestbook to represent the projects natural language and follow CMS Made Simple module naming conventions.</li>
			<li>Enabled handling (deleting, activating and deactivating) of multiple guestbook entries from the admin panel.</li>
			<li>There are now seperate \'Modify Guestbook Entries\' and \'Modify Guestbook Template\' permissions.</li>
			<li>A default/example stylesheet is installed (and uninstalled) with the module.</li>
			<li>The database template can be restored to default.</li>
			<li>Changed to tabbed navigation.</li>
			<li>Cleanup/rewrite of the guestbook(item) database template and the variables used in it.</li>
			<li>Translated many variable names and code comments to english.</li>
			<li>Moved some admin and log messages to the language file.</li>
			<li>Re-formatted source code for better readability.</li>
			<li>The module now also works in combination with a PostgreSQL database.</li>
			<li>Changed the input format for the dateformat parameter from MySQL format to PHP format.</li>
			<li>A new variable is assigned to the (database) guestbookentry template: $e_mail_cloaked. This is the E-mail address, with @ replaced by <at> and . by <dot>.</li>
			<li>Extended the notification E-mail, it now sends the new guestbook entry in the notification message.</li>
			<li>New finnish translation and updated dutch and norwegian translations from the translation center.</li>
		</ul>
	</li>
	<li>
		<strong>Version 0.9</strong>
		<ul>
			<li>The guestbook frontend now uses a database template (in stead of the showmessage*.tpl files) that can be modified from the admin panel</li>
			<li>The dateformat parameter is now called dateformat (was dateform). Note: this means you will have to recreate any guestbook content pages or manually edit the tables cms_content and cms_content_props</li>
			<li>New french translation and modified translations for other languages from the translation center</li>
		</ul>
	</li>
	<li>
		<strong>Version 0.8</strong><br />
		Fixed:
		<ul>
			<li>not working smileys on gastbuch Content page in version 0.7</li>
		</ul>
		Cleanup:
		<ul>
			<li>mainly removal of unneccary references to the global $gCms</li>
			<li>renamed email textfield to e_mail (it was called betreff, probably an old subject field)</li>
		</ul>
		Improvements:
		<ul>
			<li>newly submitted newsentry is shown in the list</li>
			<li>brackets around submitter country are no longer shown if a country wasn\'t entered</li>
			<li>translated the lang file to dutch (except for help and changelog)</li>
			<li>the gastbuch module now makes use of translations entered in the translation center translations.cmsmadesimple.org</li>
		</ul>
		Changed:
		<ul>
			<li>The template variable name for the country in showmessage.tpl is now called $country (was $countryshow in previous versions)</li>
		</ul>
	</li>
	<li>
		<strong>Version 0.7</strong>
		<ul>
			<li>Added lang attribute to support multiple locales</li>
			<li>Show insert form on the first page</li>
			<li>Fixed bug with textlength javascript not working</li>
			<li>Fixed a few minor bugs</li>
		</ul>
	</li>
	<li>
		<strong>Version 0.6</strong>
		<ul>
			<li>Redesigned source code for better readability</li>
			<li>Added lang attribute to support multiple locales</li>
			<li>Added showaddform parameter</li>
			<li>Fixed bug with textlength javascript not working in case of "Content" content type</li>
			<li>Merged vorzu and backzu templates into one</li>
			<li>Added template success_message.tpl</li>
			<li>Fixed a few minor bugs caused by mismatches in lang variable names</li>
		</ul>
	</li>
	<li>
		<strong>Version 0.5</strong>
		<ul>
			<li>The guestbook was modified with better design and functions, for example: Template based Content, Spam protection for inserted e-mails, etc.</li>
		</ul>
	</li>
	<li>
		<strong>Version 0.4</strong>
		<ul>
			<li>The gastbuch module is now a new module</li>
		</ul>
	</li>
</ul>
';
$lang['qca'] = 'P0-1966352329-1275231321191';
$lang['utmz'] = '156861353.1275232337.1.2.utmcsr=google|utmccn=(organic)|utmcmd=organic|utmctr=cmsms download module translate';
$lang['utma'] = '156861353.1311637510.1275231321.1275231321.1275231321.1';
$lang['utmc'] = '156861353';
$lang['utmb'] = '156861353.3.10.1275231321';
?>]]></data>
	</file>
	<file>
	  <filename>/lang/ext/es_ES.php</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[<?php
$lang['module_friendlyname'] = 'Libro de Visitas';
$lang['module_example_stylesheet'] = 'Libro de Visitas (hoja de estilo por defecto/ejemplo)';
$lang['module_example_stylesheet_intro'] = 'Hoja de estilo por defecto/ejemplo para el m&oacute;dulo Libro de Visitas de CMSMS.
Esto puede ser sobreescrito cuando el m&oacute;dulo es actualizado y ser&aacute; eliminado cuando el m&oacute;dulo sea desinstalado, por lo tanto haga una copia si desea modificarlo.';
$lang['captcha'] = 'Captcha';
$lang['captcha_title'] = 'Por favor ingrese el texto de la imagen abajo';
$lang['captcha_failure_message'] = 'El texto de la imagen no fue ingresado correctamente';
$lang['timespan'] = 'Lapso m&iacute;nimo entre ingreso de mensajes';
$lang['err_invalid_mode'] = 'Error: se especifico un modo inv&aacute;lido para par&aacute;metro. Los modos v&aacute;lidos son: %s.';
$lang['err_no_entry_id'] = 'Error: no se a dado el par&aacute;metro entry_id. Con mode=entry se debe especificar adem&aacute;s un par&aacute;metro entry_id.';
$lang['err_entry_not_found'] = 'Error: no hay ninguna entrada en el libro de visitas con entry_id %s';
$lang['error_template_filenotfound'] = 'Error: &iexcl;el archivo de plantilla %s no se pudo hallar!';
$lang['id'] = 'Id';
$lang['sender'] = 'Remitente';
$lang['email'] = 'Correo Electr&oacute;nico';
$lang['country'] = 'Pa&iacute;s';
$lang['location'] = 'Localidad';
$lang['homepage'] = 'Sitio Web';
$lang['message'] = 'Mensaje';
$lang['posted'] = 'Ingresado';
$lang['ip_addr'] = 'Direcci&oacute;n IP';
$lang['alength'] = 'Caracteres remanentes';
$lang['active'] = 'Activo';
$lang['access_denied'] = 'Acceso Negado';
$lang['restore_to_defaults'] = 'Restaurar a por defecto';
$lang['restore_to_defaults_warning'] = 'Esta operaci&oacute;n restaurar&aacute; el contenido de la plantilla a los valores por defecto del sistema. Va a sobreescribir cualquier cambio hecho en la plantilla. &iquest;Est&aacute; seguro que quiere hacerlo?';
$lang['addgait'] = 'Agregar Entrada al Libro de Visitas';
$lang['postdate'] = 'Fecha de Ingreso';
$lang['ativi'] = 'Activar';
$lang['deakti'] = 'Desactivar';
$lang['title_mod_admin'] = 'Gestionar Entadas al Libro de Visitas';
$lang['title_mod_settings'] = 'Configurar Libro de Visitas';
$lang['title_tab_admin_templates'] = 'Plantillas de Libro de Visitas';
$lang['title_tab_admin_template'] = 'Plantilla de Libro de Visitas';
$lang['title_tab_admin_entrylist_template'] = 'Plantilla de Lista de Entradas';
$lang['title_tab_admin_entry_template'] = 'Plantilla de Entrada';
$lang['title_tab_admin_form_template'] = 'Plantilla de Formulario';
$lang['title_tab_admin_email_template'] = 'Plantilla de E-mail';
$lang['title_tab_admin_showform_button_template'] = 'Mostrar Plantilla de Formulario';
$lang['templatecontent'] = 'Contenido de Plantilla';
$lang['admin_template_modified_logmessage'] = 'Modificar Plantilla de Libro de Visitas';
$lang['admin_template_restored_logmessage'] = 'Reponer Plantilla de Libro de Visitas a por Defecto';
$lang['admin_entry_added_logmessage'] = 'Se Agreg&oacute; Entrada de Libro de Visitas';
$lang['admin_entry_modified_logmessage'] = 'Se Modific&oacute; Entrada de Libro de Visitas';
$lang['admin_entry_deleted_logmessage'] = 'Se Elimin&oacute; Entrada de Libro de Visitas';
$lang['admin_entry_activated_logmessage'] = 'Se Activ&oacute; Entrada de Libro de Visitas';
$lang['admin_entry_deactivated_logmessage'] = 'Se Desactiv&oacute; Entrada de Libro de Visitas';
$lang['admin_entry_message_nosender'] = 'Por favor indique un nombre de remitente';
$lang['fieldnames'] = 'Nombres de Campos';
$lang['captcha_module_installed'] = 'El m&oacute;dulo Captcha est&aacute; instalado';
$lang['captcha_module_not_installed'] = 'El m&oacute;dulo Captcha no est&aacute; instalado';
$lang['smileys_module_installed'] = 'El m&oacute;dulo Smileys est&aacute; instalado';
$lang['smileys_module_not_installed'] = 'El m&oacute;dulo Smileys no est&aacute; instalado';
$lang['admin_wysiwyg_title'] = 'Usar WYSIWYG en el formulario de entrada del Libro de Visitas';
$lang['searchsmileys_title'] = 'Usar smileys en el resultado de b&uacute;squedas';
$lang['save_settings'] = 'Guardar Configuraciones';
$lang['badwords_title'] = 'Palabras que no son admitidas';
$lang['badwords_replacement_title'] = 'Reemplazar malas palabras con';
$lang['nummer'] = 'N&uacute;mero de mensajes por p&aacute;gina';
$lang['postchar'] = 'Tama&ntilde;o m&aacute;ximo del mansaje';
$lang['emailnot'] = 'Email de notificaci&oacute;n';
$lang['sortasc'] = 'Ordenar en forma ascendente (ASC)';
$lang['smile'] = 'Smiley';
$lang['shmenow'] = 'Mostrar mensajes inmediatamente';
$lang['datefora'] = 'Formato de fecha';
$lang['lang'] = 'C&oacute;digo Local (p.ej. es_ES)';
$lang['showaddform'] = 'Mostrar formulario insertado de inmediato';
$lang['fabsend'] = 'Por favor incluya su nombre';
$lang['fmessag'] = 'Por favor incluya un mensaje';
$lang['femail'] = 'Por favor incluya una direcci&oacute;n E-Mail v&aacute;lida';
$lang['tolong'] = 'Demasiados caracteres. Por favor haga el mensaje m&aacute;s corto.';
$lang['toosoon'] = 'Su &uacute;ltimo ingreso fue solo hace %s segundos. El tiempo m&iacute;nimo a transcurrir entre entradas es de %s segundos';
$lang['fui'] = 'Su mensaje ya fue entregado';
$lang['badwords_message'] = 'Estas palabras no son permitidas: %s';
$lang['showitnow'] = 'Su mensaje ha sido insertado. &iexcl;Muchas Gracias!';
$lang['showitlater'] = '&iexcl;Muchas Gracias! El mensaje ser&aacute; insertado luego de ser aprobado por el administrador.';
$lang['msg_back'] = 'volver';
$lang['inam'] = 'Nombre';
$lang['imessag'] = 'Su mensaje';
$lang['smessage'] = 'Mensaje';
$lang['sdate'] = 'Fecha';
$lang['ginsert'] = 'Insertar';
$lang['cancel'] = 'Cancelar';
$lang['uhr'] = 'hora';
$lang['e_mailnotibetr'] = 'Ingresar Nueva Entrada';
$lang['e_mailnotimessage'] = 'Hay una nueva entrada en su Libro de Visitas.';
$lang['neuein'] = 'Ingresar Nueva Entrada';
$lang['einerseit'] = 'una P&aacute;gina';
$lang['eintragauf'] = 'Ingresos en';
$lang['seitpage'] = 'P&aacute;ginas';
$lang['backzu'] = '<< Volver';
$lang['nextwei'] = 'Siguiente >>';
$lang['first_text'] = '<<';
$lang['prev_text'] = '<';
$lang['next_text'] = '>';
$lang['last_text'] = '>>';
$lang['pagination_of'] = 'de';
$lang['title_table_smileys'] = 'Smileys';
$lang['ativimes'] = '&iquest;Activar este mensaje?';
$lang['deaktimes'] = '&iquest;Desactivar este mensaje?';
$lang['event_info_GuestbookEntryPosted'] = 'Evento que ocurre cuando una nueva entrada es agregada en el Libro de Visitas';
$lang['event_help_GuestbookEntryPosted'] = '<p>Evento que ocurre cuando una nueva entrada es agregada en el Libro de Visitas.</p>
  	 <h4>Par&aacute;metros</h4>
  	 <ul>
		<li><em>entry_id</em> - La id de la entrada (int)</li>
		<li><em>entry_sender</em> - El nombre ingresado por el remitente (string)</li>
		<li><em>entry_email</em> - La direcci&oacute;n E-mail ingresada (string)</li>
		<li><em>entry_homepage</em> - La p&aacute;gina web ingresada (string)</li>
		<li><em>entry_message</em> - El mensaje ingresado (string)</li>
		<li><em>entry_country</em> - El pa&iacute;s ingresado (string)</li>
		<li><em>entry_location</em> - La localidad ingresada (string)</li>
		<li><em>entry_date</em> - Fecha del ingreso (string)</li>
		<li><em>entry_approved</em> - Indica si la entrada es activada de inmediato, 1 si lo es, -1 si no lo es (int)</li>
  	 </ul>
';
$lang['event_info_GuestbookEntryDeleted'] = 'Evento que ocurre cuando una entrada es eliminada en el Libro de Visitas';
$lang['event_help_GuestbookEntryDeleted'] = 'Evento que ocurre cuando una entrada es eliminada en el Libro de Visitas
  	 <h4>Par&aacute;metros</h4>
  	 <ul>
	  	 <li><em>entry_id</em> - La id de la entrada (int)</li>
  	 </ul>
';
$lang['event_info_GuestbookEntryActivated'] = 'Evento que ocurre cuando una entrada es activada en el Libro de Visitas';
$lang['event_help_GuestbookEntryActivated'] = 'Evento que ocurre cuando una entrada es activada en el Libro de Visitas
  	 <h4>Par&aacute;metros</h4>
  	 <ul>
  	 <li><em>entry_id</em> - La id de la entrada (int)</li>
  	 </ul>
';
$lang['event_info_GuestbookEntryDeactivated'] = 'Evento que ocurre cuando una entrada es desactivada en el Libro de Visitas';
$lang['event_help_GuestbookEntryDeactivated'] = 'Evento que ocurre cuando una entrada es desactivada en el Libro de Visitas
  	 <h4>Par&aacute;metros</h4>
  	 <ul>
  	 <li><em>entry_id</em> - La id de la entrada (int)</li>
  	 </ul>
';
$lang['inposmes'] = 'Aseg&uacute;rese de configurar los permisos de &quot;Modificar Entradas del Libro de Visitas&quot; para los usuarios que administrar&aacute;n los items del Libro de Visitas, y los permisos de &quot;Modificar Plantilla de Libro de Visitas&quot; para aquellos usuarios que podr&aacute;n modificar la plantilla del Libro de Visitas.<br />Adjuntar la Hoja de Estilo con el nombre &quot;%s&quot; a la plantilla usada para dar estilo al Libro de Visitas.';
$lang['moddescription'] = 'Gestionar las entradas y la plantilla del Libro de Visitas.';
$lang['uninstall_pre_message'] = '&iexcl;Las %s entradas de su Libro de Visitas ser&aacute;n eliminadas en forma permanente!';
$lang['uninstall_pre_message_single'] = '&iexcl;Una entrada de su Libro de Visitas ser&aacute; eliminada en forma permanente!';
$lang['postuninstall'] = 'Se desinstal&oacute; con &eacute;xito el Libro de Visitas.';
$lang['help_textleng'] = 'Establece cuantos caracteres se pueden ingresar. Por defecto son 1000 caracteres. Este par&aacute;metro afecta la validaci&oacute;n de ambos lados, servidor y cliente.';
$lang['help_number'] = 'M&aacute;ximo n&uacute;mero de entradas a mostrar en una p&aacute;gina.';
$lang['help_timespan'] = 'Tiempo m&iacute;nimo a transcurrir entre ingresos (en segundos).';
$lang['help_mailnoti'] = 'Direcci&oacute;n e-mail para enviar un mensaje de notificaci&oacute;n cuando se present&oacute; un mensaje en el Libro. Si est&aacute; instalado ser&aacute; usado el m&oacute;dulo CMSMailer para enviar el E-mail (de no ser as&iacute; se usar&aacute; la funci&oacute;n PHP de mail).';
$lang['help_sortasc'] = 'Ordenar los items del Libro de Visitas con fechas en orden ascendente (los ingresos nuevos ir&aacute;n al final).';
$lang['help_dateformat'] = 'Cambiar el orden en el cual se mostrar&aacute;n las Fechas, lo hace utilizando los c&oacute;digos de formatos PHP';
$lang['help_shownow'] = 'Muestra los mensajes inmediatamente despu&eacute;s de enviados, sin aprobar por un admin.';
$lang['help_smiley'] = 'Traduce los smileys basados en texto y muestra la tabla de smiley en el formulario de entradas. Usa el m&oacute;dulo de Smiley si est&aacute; instalado.';
$lang['help_captcha'] = 'Esto va a habilitar Captcha en el formulario de entradas del Libro de Visitas. Claro que el m&oacute;dulo Captcha debe estar instalado para que estos par&aacute;metros trabajen.';
$lang['help_showaddform'] = 'Muestra el formulario insertado en la primera p&aacute;gina.  Remplaza al bot&oacute;n &quot;Ingresar Nueva Entrada&quot;.';
$lang['help'] = '<h3>&iquest;Qu&eacute; hace esto?</h3>
<p>
    El Libro de Visitas es un m&oacute;dulo de contenido y un m&oacute;dulo tag de  CMSMS.
    Permite que las visitas a su sitio web puedan dejar un mensaje, como por ejemplo si a ellos les gusta el sitio.
</p>

<h3>Seguridad</h3>
<p>
     El usuario deber&aacute; pertenecer a un grupo con el permiso de &#039;Modificar las Entradas del Libro de Visitas&#039; con el fin de agregar, editar, o eliminar entradas del Libro de Visitas.<br />
    Con el fin de poder modificar la plantilla del Libro de Visitas se requiere tener el permiso de &#039;Modificar Plantilla de Libro de Visitas&#039;.
</p>

<h3>&iquest;C&oacute;mo lo puedo usar?</h3>
<p>
    La forma m&aacute;s sencilla de hacerlo es en una nueva p&aacute;gina y cambiar el &quot;Tipo de Contenido&quot; a Libro de Visitas. De esta forma a usted le ser&aacute; posible configurar las opciones del Libro de Visitas como propiedades de la p&aacute;gina.<br />
    Si a usted le interesa agregar al m&oacute;dulo antes o despu&eacute;s de otro contenido lo puede hacer insert&aacute;ndolo con el uso del tag cms_module. Esto insertar&aacute; el Libro de Visitas en cualquier lugar que usted desee de su plantilla/p&aacute;gina.<br /> 
    El c&oacute;digo se va a ver aproximadamente as&iacute;: <code>{cms_module module=&quot;Guestbook&quot; number=5 shownow=true smiley=1 lang=es_ES mailnoti=usted@ejemplo.com}</code>
</p>


<h3>&iquest;Qu&eacute; potencial de dise&ntilde;o existe?</h3>

<p>
    Un ejemplo de hoja de estilo para la plantilla por defecto de la base de datos se instala con el m&oacute;dulo.<br />
    La hoja de estilo por defecto es anulada cuando se desinstala el m&oacute;dulo y puede ser sobreescrita por una actualizaci&oacute;n, por lo que es probable que a usted le interese usar una copia si la va a modificar.<br />
    Adjuntar la hoja de estilo a la plantilla de la p&aacute;gina usada.
</p>

<p>
    La mayor&iacute;a de las plantillas usadas por el m&oacute;dulo en el portal se guardan en la base de datos y pueden ser editadas desde el panel de administraci&oacute;n.
</p>
<p>
    En el directorio del m&oacute;dulo hay un sub-directorio llamado templates donde las dem&aacute;s plantillas son guardadas. Esto puede modificarse para adaptarse a sus necesidades:
</p>

<strong>Administraci&oacute;n</strong>
<p>
admin_entries_top.tpl -> La paginaci&oacute;n y nombre de filas para la lista de entradas.<br/>
admin_entries_entry.tpl -> La plantilla para una entrada en la lista de entradas del Libro de Visitas.<br/>
admin_entries_bottom.tpl -> El fondo del formulario de administraci&oacute;n para entradas en el Libro de Visitas.<br />
admin_entry.tpl-> El formulario para insertar o editar las entradas del Libro de Visitas.<br/>
admin_template_edit.tpl -> Usado para editar la plantillas de entradas del Libro de Visitas en la base de datos.
</p>

<strong>Portal</strong>
<p>
smiley.tpl -> La tabla de smiley, usada cuando se usa el par&aacute;metro smiley y el m&oacute;dulo Smileys no est&aacute; instalado.<br/>
</p>

<p>
    Dentro del directorio de plantillas hay un sub-directorio llamado db. Aqu&iacute; se guardan las plantillas de la base de datos pertenecientes al Libro de Visitas, las cuales pueden ser editadas desde el &aacute;rea de administraci&oacute;n.
	El contenido de estos archivos es copiado a la base de datos durante la instalaci&oacute;n del m&oacute;dulo y cuando la plantilla se la pasa a ser la plantilla por defecto desde el panel de administraci&oacute;n.<br />
	Por defecto son usados los archivos que acompa&ntilde;an al m&oacute;dulo (aquellos terminados con -default.tpl), pero si un archivo (a medida) est&aacute; presente donde -default no est&aacute; incluido en su nombre, este ser&aacute; el archivo usado.
</p>
		
<h3>Importando mensajes desde gastbuch</h3>
<p>
    Si usted est&aacute; usando una de las viejas versiones del m&oacute;dulo &quot;gastbuch&quot; (m&aacute;s viejas que Guestbook-1.0-rc1) y desea importar sus mensajes de ese Libro de Visitas al m&oacute;dulo Libro de Visitas, hay un script disponible para hacerlo.
    Simplemente dirija a su explorador de internet al archivo gastbuch-import.php en la carpeta del m&oacute;dulo (por ejemplo: http://www.example.com/cms/modules/Guestbook/gastbuch-import.php) antes de desinstalar el viejo m&oacute;dulo gastbuch.
</p>';
$lang['changelog'] = '<ul>
	<li>
		<p><b>Version 1.1.9</b></p>
		<ul>
			<li>Prevent an E-mail being sent to no address when the mailnoti parameter is not being used</li>
		</ul>
	</li>
	<li>
		<p><b>Version 1.1.8</b></p>
		<ul>
			<li>Fixed too short ip_address field</li>
			<li>Moved templates to a single tab in the admin</li>
		</ul>
	</li>
	<li>
		<p><b>Version 1.1.7</b></p>
		<ul>
			<li>Fixed references to old file locations</li>
			<li>Fixed Javascript warning when WYSIWYG is used</li>
		</ul>
	</li>
	<li>
		<p><b>Version 1.1.6</b></p>
		<ul>
			<li>Fixed character counter not working with FCKeditor</li>
			<li>Moved errormessage to lang file</li>
			<li>Deleted some redundant files</li>;
		</ul>
	</li>
	<li>
		<p><b>Version 1.1.5</b></p>
		<ul>
			<li>Fixed ModuleIsInstalled method always returning false for admin modules/FCKEditorX</li>;
			<li>Fixed character counter always starting at 1000</li>; 
		</ul>
	</li>
	<li>
		<p><b>Version 1.1.4</b></p>
		<ul>
			<li>Fixes breaks in messages not showing in 1.1.3</li>
			<li>Added (optional) basic WYSIWYG on the Guestbook entry form</li>
			<li>Added logging of guestbook entry sender IP address</li>
			<li>Added &quot;Modify Guestbook Settings&quot; permission</li>
		</ul>
	</li>
	<li>
		<p><b>Version 1.1.3</b></p>
		<ul>
			<li>Improved pagination</li>
			<li>Rewrote front-end code to use Smarty for all output</li>
			<li>The front-end Smarty templates now use arrays</li>
			<li>Made most front-end templates editable from the admin</li>
			<li>Added events</li>
			<li>Added bad word filter</i>
		</ul>
	</li>
	<li>
		<p><b>Version 1.1.2</b></p>
		<ul>
			<li>Fixed a bug where the Next button would show when it shouldn&#039;t</li>
			<li>Any guestbook content is deleted on uninstall to prevent fatal errors in cmsmadesimple-1.x</li>
		</ul>
	</li>
	<li>
		<p><b>Version 1.1.1</b></p>
		<ul>
			<li>Compatiblity changes for cmsmadesimple-1.0 and a small bugfix</li>
		</ul>
	</li>
    <li>
        <p><b>Version 1.1</b></p>
        <ul>
            <li>Added Captcha support (in a seperate Captcha module)</li>
            <li>Added timespan parameter (minimal timespan between posts)</li>
            <li>Added location field (for State/Province/City/Town)</li>
            <li>Make use of the Smiley module if it is installed</li>
            <li>Made the module compatible with the cmsmadesimple-1.0 series</li>
            <li>Minimal required CMS version changed to 0.13</li>
        </ul>
    </li>
								    
    <li>
	<p><b>Version 1.0</b></p>
	<ul>
	    <li>Renamed module (from gastbuch) to Guestbook to represent the projects natural language and follow CMS Made Simple module naming conventions.</li>
	    <li>Enabled handling (deleting, activating and deactivating) of multiple guestbook entries from the admin panel.</li>
	    <li>There are now seperate &#039;Modify Guestbook Entries&#039; and &#039;Modify Guestbook Template&#039; permissions.</li>
	    <li>A default/example stylesheet is installed (and uninstalled) with the module.</li>
	    <li>The database template can be restored to default.</li>
	    <li>Changed to tabbed navigation.</li>
	    <li>Cleanup/rewrite of the guestbook(item) database template and the variables used in it.</li>
	    <li>Translated many variable names and code comments to english.</li>
	    <li>Moved some admin and log messages to the language file.</li>
	    <li>Re-formatted source code for better readability.</li>
	    <li>The module now also works in combination with a PostgreSQL database.</li>
	    <li>Changed the input format for the dateformat parameter from MySQL format to PHP format.</li>
	    <li>A new variable is assigned to the (database) guestbookentry template: $e_mail_cloaked. This is the E-mail address, with @ replaced by <at> and . by <dot>.</li>
	    <li>Extended the notification E-mail, it now sends the new guestbook entry in the notification message.</li>
	    <li>New finnish translation and updated dutch and norwegian translations from the translation center.</li>
	</ul>
    </li>
    <li>
	<p><b>Version 0.9</b></p>
	<ul>
	    <li>The guestbook frontend now uses a database template (in stead of the showmessage*.tpl files) that can be modified from the admin panel</li>
	    <li>The dateformat parameter is now called dateformat (was dateform). Note: this means you will have to recreate any guestbook content pages or manually edit the tables cms_content and cms_content_props</li>
	    <li>New french translation and modified translations for other languages from the translation center</li>
	</ul>
    </li>
    <li>
	<p><b>Version 0.8</b></p>
	Fixed:
	<ul>
	    <li>not working smileys on gastbuch Content page in version 0.7</li>
	</ul>
	Cleanup:
	<ul>
	    <li>mainly removal of unneccary references to the global $gCms</li>
	    <li>renamed email textfield to e_mail (it was called betreff, probably an old subject field)</li>
	</ul>
	Improvements:
	<ul>
	    <li>newly submitted newsentry is shown in the list</li>
	    <li>brackets around submitter country are no longer shown if a country wasn&#039;t entered</li>
	    <li>translated the lang file to dutch (except for help and changelog)</li>
	    <li>the gastbuch module now makes use of translations entered in the translation center translations.cmsmadesimple.org</li>
	</ul>
	Changed:
	<ul>
	    <li>The template variable name for the country in showmessage.tpl is now called $country (was $countryshow in previous versions)</li>
	</ul>
    </li>
    <li>
	<p><b>Version 0.7</b></p>
	<ul>
	    <li>Added lang attribute to support multiple locales</li>
	    <li>Show insert form on the first page</li>
	    <li>Fixed bug with textlength javascript not working</li>
	    <li>Fixed a few minor bugs</li>
	</ul>
    <li>
	<p><b>Version 0.6</b></p>
	<ul>
	    <li>Redesigned source code for better readability</li>
	    <li>Added lang attribute to support multiple locales</li>
	    <li>Added showaddform parameter</li>
	    <li>Fixed bug with textlength javascript not working in case of &quot;Content&quot; content type</li>
	    <li>Merged vorzu and backzu templates into one</li>
	    <li>Added template success_message.tpl</li>
	    <li>Fixed a few minor bugs caused by mismatches in lang variable names</li>
	</ul>
    </li>
    <li>
	<p><b>Version 0.5</b></p>
	<p>
	    The guestbook was modified with better design and functions, for example: 
	    Template based Content, Spam protection for inserted e-mails, etc.
	</p>
    </li>
    <li>
	<p><b>Version 0.4</b></p>
	<p>The gastbuch module is now a new module</p>
    </li>
</ul>
';
$lang['utma'] = '156861353.602294786.1221783771.1223334577.1223337923.44';
$lang['utmz'] = '156861353.1223334577.43.32.utmccn=(referral)|utmcsr=dev.cmsmadesimple.org|utmcct=/tracker/|utmcmd=referral';
$lang['utmc'] = '156861353';
$lang['utmb'] = '156861353';
?>]]></data>
	</file>
	<file>
	  <filename>/lang/ext/et_EE.php</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[<?php
$lang['module_friendlyname'] = 'K&uuml;lalisteraamat';
$lang['module_example_stylesheet'] = 'Guestbook (default/example stylesheet)';
$lang['module_example_stylesheet_intro'] = 'Vaikmisi/n&auml;idis stiilileht CMSMS k&uuml;lalisteraamatu moodulile. 
Kui moodulit uuendatakse v&otilde;idakse see &uuml;le kirjutada ning kustutatakse kui moodul on eemaldatud, seega tee sellest koopia kui sa tahad seda muuta. ';
$lang['captcha'] = 'Captcha';
$lang['captcha_title'] = 'Palun sisesta tekst pildi alla';
$lang['captcha_failure_message'] = 'Pildile lisatud tekst pole sisestatud korrektselt';
$lang['timespan'] = 'Minimaalne ajavahe postitustel';
$lang['err_invalid_mode'] = 'Error: an invalid mode parameter was specified. Valid modes are: %s.';
$lang['err_no_entry_id'] = 'Error: no entry_id parameter given. With mode=entry a entry_id parameter should also be specified.';
$lang['err_entry_not_found'] = 'Error: there is no guestbook entry with entry_id %s';
$lang['error_template_filenotfound'] = 'Error: template file %s could not be found!';
$lang['id'] = 'Id';
$lang['date'] = 'Kuup&auml;ev';
$lang['sender'] = 'Saatja';
$lang['email'] = 'E-mail';
$lang['country'] = 'Riik';
$lang['location'] = 'Asukoht';
$lang['homepage'] = 'Koduleht';
$lang['message'] = 'Sissekanne';
$lang['posted'] = 'Postitatud';
$lang['ip_addr'] = 'IP aadress';
$lang['alength'] = 'Kasutatavaid t&auml;hem&auml;rke';
$lang['active'] = 'Aktiivne';
$lang['access_denied'] = 'Juurdep&auml;&auml;s keelatud';
$lang['restore_to_defaults'] = 'Taasta algseaded';
$lang['restore_to_defaults_warning'] = 'See muudatus taastab malli s&uuml;steemi algs&auml;tted. See kirjutab &uuml;le igasugused muudatused mis on mallile tehtud. Soovid j&auml;tkata?';
$lang['addgait'] = 'Lisa k&uuml;lalisteraamatusse sissekanne';
$lang['postdate'] = 'Postitamise kuup&auml;ev';
$lang['ativi'] = 'Aktiveeri';
$lang['deakti'] = 'Deaktiveeri';
$lang['title_mod_admin'] = 'Halda k&uuml;lalisteraamatu sissekandeid';
$lang['title_mod_settings'] = 'K&uuml;lalisteraamatu seaded';
$lang['title_tab_admin_templates'] = 'K&uuml;lalisteraamatu mallid';
$lang['title_tab_admin_template'] = 'K&uuml;lalisteraamatu mall';
$lang['title_tab_admin_entrylist_template'] = 'Entry List Template';
$lang['title_tab_admin_entry_template'] = 'Entry Template';
$lang['title_tab_admin_form_template'] = 'Vormi mall';
$lang['title_tab_admin_email_template'] = 'E-maili mall';
$lang['title_tab_admin_showform_button_template'] = 'N&auml;ita vormi mall';
$lang['templatecontent'] = 'Malli sisu';
$lang['admin_template_modified_logmessage'] = 'Muudetud k&uuml;lalisteraamatu mall';
$lang['admin_template_restored_logmessage'] = 'Restored Guestbook Template To Default';
$lang['admin_entry_added_logmessage'] = 'Added Guestbook Entry';
$lang['admin_entry_modified_logmessage'] = 'Modified Guestbook Entry';
$lang['admin_entry_deleted_logmessage'] = 'Deleted Guestbook Entry';
$lang['admin_entry_activated_logmessage'] = 'Activated Guestbook Entry';
$lang['admin_entry_deactivated_logmessage'] = 'Deactivated Guestbook Entry';
$lang['admin_entry_message_nosender'] = 'Palun sisesta saatja nimi';
$lang['wrong_date_format'] = 'Kuup&auml;ev peab olema kujul:  YYYY-MM-DD HH:MM:SS';
$lang['fieldnames'] = 'V&auml;ljade nimed';
$lang['captcha_module_installed'] = 'Captcha moodul on installeeritud';
$lang['captcha_module_not_installed'] = 'Captcha moodul ei ole installeeritud';
$lang['smileys_module_installed'] = 'Smileys moodul on lisatud';
$lang['smileys_module_not_installed'] = 'Smileys moodul ei ole lisatud';
$lang['admin_wysiwyg_title'] = 'Kasuta WYSIWYG k&uuml;lalisteraamatu sisestamisvormis';
$lang['searchsmileys_title'] = 'Kasuta smilesid otsinguvormis';
$lang['save_settings'] = 'Salvesta seadistused';
$lang['badwords_title'] = 'S&otilde;nad pole lubatud';
$lang['badwords_replacement_title'] = 'Asenda keelatud s&otilde;nad';
$lang['admin_entries_per_page_title'] = 'Sissekandeid lehe kohta (admin)';
$lang['nummer'] = 'Number sissekandeid lehe kohta';
$lang['postchar'] = 'Maksimaalse sissekande suurus';
$lang['emailnot'] = 'Teavitav e-mail';
$lang['sortasc'] = 'Sordi kahanevalt (ASC)';
$lang['smile'] = 'Smiley';
$lang['shmenow'] = 'N&auml;ita sissekannet koheselt';
$lang['datefora'] = 'Ajavorm';
$lang['lang'] = 'Kohalik (e.g. en_US)';
$lang['showaddform'] = 'N&auml;ita lisa vormi koheselt';
$lang['fabsend'] = 'Palun sisesta enda nimi';
$lang['fmessag'] = 'Palun sisesta oma sissekanne';
$lang['femail'] = 'Palun sisesta korrektne e-maili aadress';
$lang['tolong'] = 'Liiga palju t&auml;hem&auml;rke. L&uuml;henda oma sissekannet';
$lang['toosoon'] = 'Sinu viimane sissekanne postitati k&otilde;igest %s sekundit tagasi. Minimaalne ajavahe kahe sissekande vahel on %s sekundit';
$lang['fui'] = 'Sinu sissekanne on juba edastatud';
$lang['badwords_message'] = 'Need s&otilde;nad pole lubatud: %s';
$lang['showitnow'] = 'Sinu sissekanne on edastatud. T&auml;name!';
$lang['showitlater'] = 'T&auml;name! Sinu sissekanne ilmub koheselt, kui see on saanud heakskiidu s&uuml;steemi-administraatorilt. ';
$lang['msg_back'] = 'tagasi';
$lang['inam'] = 'Nimi';
$lang['imessag'] = 'Sinu sissekanne';
$lang['smessage'] = 'Sissekanne';
$lang['sdate'] = 'Kuup&auml;ev';
$lang['ginsert'] = 'Lisa';
$lang['cancel'] = 'Katkesta';
$lang['uhr'] = 'tund';
$lang['e_mailnotibetr'] = 'Uus sissekanne sinu k&uuml;lalisteraamatus';
$lang['e_mailnotimessage'] = 'Sinu k&uuml;lalisteraamatus on uus sissekanne';
$lang['neuein'] = 'Lisa k&uuml;lalisteraamatusse sissekanne';
$lang['einerseit'] = 'yks leht';
$lang['eintragauf'] = 'Sissekanded';
$lang['seitpage'] = 'Lehed';
$lang['backzu'] = '<< Tagasi';
$lang['nextwei'] = 'Edasi >>';
$lang['first_text'] = '&iota;&lsaquo;';
$lang['prev_text'] = '< eelmine';
$lang['next_text'] = 'j&auml;rgmine >';
$lang['last_text'] = '&rsaquo;&iota;';
$lang['pagination_of'] = 'of';
$lang['title_table_smileys'] = 'Smileys';
$lang['ativimes'] = 'Aktiveeri see sissekanne?';
$lang['deaktimes'] = 'Deaktiveeri see sissekanne?';
$lang['event_info_GuestbookEntryPosted'] = 'Event triggered when a new Guestbook entry is added';
$lang['event_help_GuestbookEntryPosted'] = '<p>Event triggered when a new Guestbook entry is added.</p>
  	 <h4>Parameters</h4>
  	 <ul>
		<li><em>entry_id</em> - The entry id (int)</li>
		<li><em>entry_sender</em> - The name the sender entered (string)</li>
		<li><em>entry_email</em> - The E-mail address entered (string)</li>
		<li><em>entry_homepage</em> - The homepage entered (string)</li>
		<li><em>entry_message</em> - The message entered (string)</li>
		<li><em>entry_country</em> - The country entered (string)</li>
		<li><em>entry_location</em> - The location entered (string)</li>
		<li><em>entry_date</em> - The post date (string)</li>
		<li><em>entry_approved</em> - Whether the entry is activated at once, 1 if it is, -1 if not (int)</li>
  	 </ul>
';
$lang['event_info_GuestbookEntryDeleted'] = 'Event triggered when a Guestbook entry is deleted';
$lang['event_help_GuestbookEntryDeleted'] = 'Event triggered when a Guestbook entry is deleted
  	 <h4>Parameters</h4>
  	 <ul>
	  	 <li><em>entry_id</em> - The entry id (int)</li>
  	 </ul>
';
$lang['event_info_GuestbookEntryActivated'] = 'Event triggered when a Guestbook entry is activated';
$lang['event_help_GuestbookEntryActivated'] = 'Event triggered when a Guestbook entry is activated
  	 <h4>Parameters</h4>
  	 <ul>
  	 <li><em>entry_id</em> - The entry id (int)</li>
  	 </ul>
';
$lang['event_info_GuestbookEntryDeactivated'] = 'Event triggered when a Guestbook entry is de-activated';
$lang['event_help_GuestbookEntryDeactivated'] = 'Event triggered when a Guestbook entry is de-activated
  	 <h4>Parameters</h4>
  	 <ul>
  	 <li><em>entry_id</em> - The entry id (int)</li>
  	 </ul>
';
$lang['inposmes'] = 'Make sure to set the &quot;Modify Guestbook Entries&quot; permission for users who will be administering Guestbook items and &quot;Modify Guestbook Template&quot; permission for users who should be able to modify the guestbook template.<br />Attach the Stylesheet named &quot;%s&quot; to the template used to style the guestbook.';
$lang['moddescription'] = 'Halda k&uuml;lalisteraamatu sissekandeid ja malle';
$lang['uninstall_pre_message'] = '%s sissekannet sinu k&uuml;lalisteraamatust on kustutatud!';
$lang['uninstall_pre_message_single'] = '1 sissekanne kustutatakse su k&uuml;lalisteraamatust j&auml;&auml;davalt!';
$lang['postuninstall'] = 'K&uuml;lalisteraamat on edukalt eemaldatud.';
$lang['help_textleng'] = 'Seab kui palju t&auml;hem&auml;rke v&otilde;ib sisestada. Vaikimisi on m&auml;&auml;ratud 1000 t&auml;hem&auml;rki. This parameter affects both server-side and client-side validation.';
$lang['help_number'] = 'Maksimaalne arv sissekandeid on n&auml;idatud lehel. ';
$lang['help_timespan'] = 'Minimaalne ajavahe postitustel  (sekundites).';
$lang['help_mailnoti'] = 'E-mail address to send a notification to if a message was submitted. The CMSMailer module will be used for sending the E-mail if it is installed (otherwise PHP&#039;s mail function is used).';
$lang['help_sortasc'] = 'Sort guestbook items in ascending date order (new posts will go to the end).';
$lang['help_dateformat'] = 'Change the way the Date will display, it takes the PHP format codes';
$lang['help_shownow'] = 'Shows messages right after submission, without approval by an admin.';
$lang['help_smiley'] = 'Translate text-based smileys to image smileys and shows the smiley table on the entry submit form. Uses the Smiley module if it is installed.';
$lang['help_captcha'] = 'This will enable captcha on the guestbook entry form. The Captcha module must be installed for this parameter to work.';
$lang['help_showaddform'] = 'Shows the insert form on the first page.  Replaces the &quot;New Guestbook Entry&quot; button.';
$lang['help'] = '<h3>What does it do?</h3>
<p>
    The guestbook module is a content module and a CMSMS tagmodule.
    It gives visitors the ability to leave a message, for example about how they like the website.
</p>

<h3>Security</h3>
<p>
    The user must belong to a group with the &#039;Modify Guestbook Entries&#039; permission in order to add, edit, or delete guestbook entries.<br />
    In order to be able to modify the guestbook entry template, &#039;Modify Guestbook Template&#039; permission is required.
</p>

<h3>How do I use it?</h3>
<p>
    The easiest way is to create a new page and change the &quot;Content Type&quot; to Guestbook. This way you will be able to set the guestbook options as page properties.<br />
    If you want to add the module after some other content you can insert it using the cms_module tag. This will insert the guestbook into your template/page anywhere you wish.<br /> 
    The code would look something like: <code>{cms_module module=&quot;Guestbook&quot; number=5 shownow=true smiley=1 mailnoti=you@example.com}</code>
</p>


<h3>What Design potentials are there?</h3>

<p>
    An example stylesheet for the default database template is installed with the module.<br />
    The default stylesheet is deleted when the module is uninstalled and may be overwitten by an upgrade, so you might want to use a copy if you modify it.<br />
    Attach the stylesheet to the page template used.
</p>

<p>
    Most templates used on the module front-end are stored in the database and can be edited from the admin panel.
</p>
<p>
    In the module directory there&#039;s a directory called templates where all other templates are stored. You can modify these to fit your needs:
</p>

<strong>Administration</strong>
<p>
admin_entries_top.tpl -> The paganition and row names for the entry list.<br/>
admin_entries_entry.tpl -> The template for an entry in the list of guestbook entries.<br/>
admin_entries_bottom.tpl -> The bottom of the guestbook entries admin form.<br />
admin_entry.tpl-> The form used to insert or edit guestbook entries.<br/>
admin_template_edit.tpl -> Used for editing the guestbook entry database template.
</p>

<strong>Front End</strong>
<p>
smiley.tpl -> The smiley table, used when the smiley parameter is used and the Smileys module is not installed.<br/>
</p>

<p>
    Inside the template directory there&#039;s a directory called db. This stores the guestbook database templates, which can be edited from the Guestbook admin area.
	The contents of these files is copied to the database during module installation and when a template is restored to default from the admin panel.<br />
	By default the files that come with the module (names ending with -default.tpl) are used, but if a (custom) file is present where -default is left out in the name, this file will be used instead.
</p>
		
<h3>Importing gastbuch messages</h3>
<p>
    If you are using one of the old &quot;gastbuch&quot; module versions (older than Guestbook-1.0-rc1) and want to import your guestbook messages into the Guestbook module, a script is available to do so.
    Simply point your browser to the file gastbuch-import.php in the module folder (for example: http://www.example.com/cms/modules/Guestbook/gastbuch-import.php) before uninstalling the old gastbuch module.
</p>';
$lang['changelog'] = '<ul>
	<li>
		<p><b>Version 1.1.11</b></p>
		Fixes:
		<ul>
			<li>Fixed module compatibility with latest CMS Made Simple versions (1.5+)</li>
			<li>Fixed pagination not using full table width</li>
			<li>Fixed some small bugs adding/editing an guestbook entry</li>
			<li>Fixed special characters in (translated) pre-uninstall message(s) not being shown correctly</li>
			<li>Fixed language setting from CMS Made Simple Global Settings not being applied</li>
		</ul>
		Improvements:
		<ul>
			<li>You can now edit a guestbook entry date in the backend</li>
			<li>The number of entries shown per page in the backend is now configurable</li>
		</ul>
	</li>
	<li>
		<p><b>Version 1.1.10</b></p>
		<ul>
			<li>FIX: Removed this warning from the admin panel: &quot;Warning: vsprintf() [function.vsprintf]: Too few arguments in /home/mywebsite/public_html/lib/translation.functions.php on line 62&quot;</li>
			<li>FIX: Insert of new entries failed, when none mandatory fields were removed from the form.</li>
			<li>FIX: Pagination created invalid XHTML (Text attribute removed)</li>
			<li>CHG: Smileys are now inserted on click via JavaScript. Plain text smileys moved into hint.</li>
			<li>FIX: Wrong encoding and HTML entities in notification emails.</li>
			<li>FIX: Enabled translation for pagination &quot;First&quot; and &quot;Last&quot;.</li>
			<li>CHG: Update SmartyPaginate from 1.5 to 1.6-dev</li>
			<li>FIX: Wrong language field &quot;e_mail&quot; in email notification.</li>
			<li>FIX: Module CMSMailer was not detected/used on PHP4</li>
		</ul>
	</li>
	<li>
		<p><b>Version 1.1.9</b></p>
		<ul>
			<li>Prevent an E-mail being sent to no address when the mailnoti parameter is not being used</li>
		</ul>
	</li>
	<li>
		<p><b>Version 1.1.8</b></p>
		<ul>
			<li>Fixed too short ip_address field</li>
			<li>Moved templates to a single tab in the admin</li>
		</ul>
	</li>
	<li>
		<p><b>Version 1.1.7</b></p>
		<ul>
			<li>Fixed references to old file locations</li>
			<li>Fixed Javascript warning when WYSIWYG is used</li>
		</ul>
	</li>
	<li>
		<p><b>Version 1.1.6</b></p>
		<ul>
			<li>Fixed character counter not working with FCKeditor</li>
			<li>Moved errormessage to lang file</li>
			<li>Deleted some redundant files</li>
		</ul>
	</li>
	<li>
		<p><b>Version 1.1.5</b></p>
		<ul>
			<li>Fixed ModuleIsInstalled method always returning false for admin modules/FCKEditorX</li>
			<li>Fixed character counter always starting at 1000</li> 
		</ul>
	</li>
	<li>
		<p><b>Version 1.1.4</b></p>
		<ul>
			<li>Fixes breaks in messages not showing in 1.1.3</li>
			<li>Added (optional) basic WYSIWYG on the Guestbook entry form</li>
			<li>Added logging of guestbook entry sender IP address</li>
			<li>Added &quot;Modify Guestbook Settings&quot; permission</li>
		</ul>
	</li>
	<li>
		<p><b>Version 1.1.3</b></p>
		<ul>
			<li>Improved pagination</li>
			<li>Rewrote front-end code to use Smarty for all output</li>
			<li>The front-end Smarty templates now use arrays</li>
			<li>Made most front-end templates editable from the admin</li>
			<li>Added events</li>
			<li>Added bad word filter</i>
		</ul>
	</li>
	<li>
		<p><b>Version 1.1.2</b></p>
		<ul>
			<li>Fixed a bug where the Next button would show when it shouldn&#039;t</li>
			<li>Any guestbook content is deleted on uninstall to prevent fatal errors in cmsmadesimple-1.x</li>
		</ul>
	</li>
	<li>
		<p><b>Version 1.1.1</b></p>
		<ul>
			<li>Compatiblity changes for cmsmadesimple-1.0 and a small bugfix</li>
		</ul>
	</li>
    <li>
        <p><b>Version 1.1</b></p>
        <ul>
            <li>Added Captcha support (in a seperate Captcha module)</li>
            <li>Added timespan parameter (minimal timespan between posts)</li>
            <li>Added location field (for State/Province/City/Town)</li>
            <li>Make use of the Smiley module if it is installed</li>
            <li>Made the module compatible with the cmsmadesimple-1.0 series</li>
            <li>Minimal required CMS version changed to 0.13</li>
        </ul>
    </li>
								    
    <li>
	<p><b>Version 1.0</b></p>
	<ul>
	    <li>Renamed module (from gastbuch) to Guestbook to represent the projects natural language and follow CMS Made Simple module naming conventions.</li>
	    <li>Enabled handling (deleting, activating and deactivating) of multiple guestbook entries from the admin panel.</li>
	    <li>There are now seperate &#039;Modify Guestbook Entries&#039; and &#039;Modify Guestbook Template&#039; permissions.</li>
	    <li>A default/example stylesheet is installed (and uninstalled) with the module.</li>
	    <li>The database template can be restored to default.</li>
	    <li>Changed to tabbed navigation.</li>
	    <li>Cleanup/rewrite of the guestbook(item) database template and the variables used in it.</li>
	    <li>Translated many variable names and code comments to english.</li>
	    <li>Moved some admin and log messages to the language file.</li>
	    <li>Re-formatted source code for better readability.</li>
	    <li>The module now also works in combination with a PostgreSQL database.</li>
	    <li>Changed the input format for the dateformat parameter from MySQL format to PHP format.</li>
	    <li>A new variable is assigned to the (database) guestbookentry template: $e_mail_cloaked. This is the E-mail address, with @ replaced by <at> and . by <dot>.</li>
	    <li>Extended the notification E-mail, it now sends the new guestbook entry in the notification message.</li>
	    <li>New finnish translation and updated dutch and norwegian translations from the translation center.</li>
	</ul>
    </li>
    <li>
	<p><b>Version 0.9</b></p>
	<ul>
	    <li>The guestbook frontend now uses a database template (in stead of the showmessage*.tpl files) that can be modified from the admin panel</li>
	    <li>The dateformat parameter is now called dateformat (was dateform). Note: this means you will have to recreate any guestbook content pages or manually edit the tables cms_content and cms_content_props</li>
	    <li>New french translation and modified translations for other languages from the translation center</li>
	</ul>
    </li>
    <li>
	<p><b>Version 0.8</b></p>
	Fixed:
	<ul>
	    <li>not working smileys on gastbuch Content page in version 0.7</li>
	</ul>
	Cleanup:
	<ul>
	    <li>mainly removal of unneccary references to the global $gCms</li>
	    <li>renamed email textfield to e_mail (it was called betreff, probably an old subject field)</li>
	</ul>
	Improvements:
	<ul>
	    <li>newly submitted newsentry is shown in the list</li>
	    <li>brackets around submitter country are no longer shown if a country wasn&#039;t entered</li>
	    <li>translated the lang file to dutch (except for help and changelog)</li>
	    <li>the gastbuch module now makes use of translations entered in the translation center translations.cmsmadesimple.org</li>
	</ul>
	Changed:
	<ul>
	    <li>The template variable name for the country in showmessage.tpl is now called $country (was $countryshow in previous versions)</li>
	</ul>
    </li>
    <li>
	<p><b>Version 0.7</b></p>
	<ul>
	    <li>Added lang attribute to support multiple locales</li>
	    <li>Show insert form on the first page</li>
	    <li>Fixed bug with textlength javascript not working</li>
	    <li>Fixed a few minor bugs</li>
	</ul>
    <li>
	<p><b>Version 0.6</b></p>
	<ul>
	    <li>Redesigned source code for better readability</li>
	    <li>Added lang attribute to support multiple locales</li>
	    <li>Added showaddform parameter</li>
	    <li>Fixed bug with textlength javascript not working in case of &quot;Content&quot; content type</li>
	    <li>Merged vorzu and backzu templates into one</li>
	    <li>Added template success_message.tpl</li>
	    <li>Fixed a few minor bugs caused by mismatches in lang variable names</li>
	</ul>
    </li>
    <li>
	<p><b>Version 0.5</b></p>
	<p>
	    The guestbook was modified with better design and functions, for example: 
	    Template based Content, Spam protection for inserted e-mails, etc.
	</p>
    </li>
    <li>
	<p><b>Version 0.4</b></p>
	<p>The gastbuch module is now a new module</p>
    </li>
</ul>
';
$lang['utmz'] = '156861353.1247264578.6.5.utmccn=(referral)|utmcsr=tervis.polvamaa.ee|utmcct=/uus2/admin/moduleinterface.php|utmcmd=referral';
$lang['utma'] = '156861353.221034764.1247238404.1247264578.1247267055.7';
$lang['utmc'] = '156861353';
$lang['utmb'] = '156861353';
?>]]></data>
	</file>
	<file>
	  <filename>/lang/ext/fi_FI.php</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[<?php
$lang['module_friendlyname'] = 'Vieraskirja';
$lang['module_example_stylesheet'] = 'Vieraskirja (oletus tyyli)';
$lang['module_example_stylesheet_intro'] = 'Oletus / esimerkki tyyli vieraskirja moduulia varten.
Moduli kirjoittaa taman p&auml;&auml;lle p&auml;ivityksen yhteydessa ja se tullaan poistamaan modulin poiston yhteydess&auml;.
Tee kopio jos haluat muuttaa
';
$lang['captcha'] = 'Captcha';
$lang['captcha_title'] = 'Sy&ouml;t&auml; kuvassa n&auml;kyv&auml; teksti';
$lang['captcha_failure_message'] = 'Virhe captcha tekstiss&auml;';
$lang['timespan'] = 'Minimi aikav&auml;li merkint&ouml;jen v&auml;lill&auml; (flood esto)';
$lang['id'] = 'Id';
$lang['sender'] = 'L&auml;hett&auml;j&auml;';
$lang['email'] = 'E-mail';
$lang['country'] = 'Maa';
$lang['location'] = 'Sijainti';
$lang['homepage'] = 'Kotisivu';
$lang['message'] = 'Viesti';
$lang['posted'] = 'Kirjoitettu';
$lang['alength'] = 'Merkkej&auml; j&auml;ljell&auml;';
$lang['active'] = 'Aktiivinen';
$lang['access_denied'] = 'P&auml;&auml;sy kielletty';
$lang['restore_to_defaults'] = 'Palauta oletukset';
$lang['restore_to_defaults_warning'] = 'T&auml;m&auml; toiminto palauttaa templaten modulin oletukseksi. Kaikki muutokset h&auml;vi&auml;v&auml;t. Oletko varma?
';
$lang['addgait'] = 'Lis&auml;&auml; vieraskirja merkint&auml;';
$lang['postdate'] = 'P&auml;iv&auml;m&auml;&auml;r&auml;';
$lang['ativi'] = 'Aktivoi';
$lang['deakti'] = 'Passivoi';
$lang['title_mod_admin'] = 'Hallitse vieraskirjan merkint&ouml;j&auml;';
$lang['title_mod_template'] = 'Muokkaa sy&ouml;tt&ouml; pohjaa';
$lang['title_mod_settings'] = 'Vieraskirjan asetukset';
$lang['templatecontent'] = 'Pohjan sis&auml;lt&ouml;';
$lang['admin_template_modified_logmessage'] = 'Muokkaa vieraskirjan pohjaa';
$lang['admin_template_restored_logmessage'] = 'Vieraskirjan pohja palautettu oletusarvoonsa';
$lang['admin_entry_added_logmessage'] = 'Vieraskirjaan lis&auml;tty merkint&auml;';
$lang['admin_entry_modified_logmessage'] = 'Vieraskirjan merkint&auml;&auml; muokattu';
$lang['admin_entry_deleted_logmessage'] = 'Vieraskirjan merkint&auml; poistettu';
$lang['admin_entry_activated_logmessage'] = 'Vieraskirjan merkint&auml; aktivoitu';
$lang['admin_entry_deactivated_logmessage'] = 'Vieraskirjan merkint&auml; passivoitu';
$lang['admin_entry_message_nosender'] = 'Ole hyv&auml; ja t&auml;yt&auml; l&auml;hett&auml;j&auml;n nimi';
$lang['fieldnames'] = 'Kenttien nimet';
$lang['nummer'] = 'Numero';
$lang['postchar'] = 'Viestin maksimi pituus';
$lang['emailnot'] = 'Email ilmoitus';
$lang['sortasc'] = 'J&auml;rjest&auml; laskevaan j&auml;rjestykseen';
$lang['smile'] = 'Hymi&ouml;';
$lang['shmenow'] = 'N&auml;yt&auml; viesti v&auml;litt&ouml;m&auml;sti';
$lang['datefora'] = 'P&auml;iv&auml;yksen muoto';
$lang['lang'] = 'Lokalisaatio (esim. fi_FI)';
$lang['showaddform'] = 'N&auml;yt&auml; lis&auml;ys kaavake viestien alapuolella';
$lang['fabsend'] = 'Ole hyv&auml; ja t&auml;yt&auml; nimi';
$lang['fmessag'] = 'Ole hyv&auml; ja t&auml;yt&auml; viesti';
$lang['femail'] = 'Ole hyv&auml; ja t&auml;yt&auml; email osoite';
$lang['tolong'] = 'Viestin maksimi pituus ylitetty, ole hyv&auml; ja lyhenn&auml; viesti&auml;si';
$lang['toosoon'] = 'Kirjoitit viestin %s sekuntia sitten. Viestien kirjoituksen v&auml;li tulee olla %s sekuntia. Ole hyv&auml; ja odota hetki ja yrit&auml; uudelleen.';
$lang['fui'] = 'Viestisi on jo l&auml;hetetty';
$lang['showitnow'] = 'Viestisi on lis&auml;tty';
$lang['showitlater'] = 'Kiitos, viestisi tulee n&auml;kyville yll&auml;pit&auml;j&auml;n hyv&auml;ksytty&auml; sen';
$lang['inam'] = 'Nimi';
$lang['imessag'] = 'Viestisi';
$lang['smessage'] = 'Viesti';
$lang['sdate'] = 'P&auml;iv&auml;ys';
$lang['ginsert'] = 'Lis&auml;&auml;';
$lang['uhr'] = 'Tunti';
$lang['e_mailnotibetr'] = 'Uusi merkint&auml; vieraskirjassa';
$lang['e_mailnotimessage'] = 'Vieraskirjassasi on uusi merkint&auml;';
$lang['neuein'] = 'Uusi vieraskirjan merkint&auml;';
$lang['einerseit'] = 'Yksi sivu';
$lang['eintragauf'] = 'Viesti&auml;';
$lang['seitpage'] = 'Sivulla';
$lang['backzu'] = '<< Edellinen';
$lang['nextwei'] = 'Seuraava >>';
$lang['title_table_smileys'] = 'Hymi&ouml;t';
$lang['ativimes'] = 'Aktivoi t&auml;m&auml; viesti';
$lang['deaktimes'] = 'Passivoi t&auml;m&auml; viesti';
$lang['inposmes'] = 'Make sure to set the &quot;Modify Guestbook Entries&quot; permission for users who will be administering Guestbook items and &quot;Modify Guestbook Template&quot; permission for users who should be able to modify the guestbook template.<br />Attach the Stylesheet named &quot;%s&quot; to the template used to style the guestbook.';
$lang['moddescription'] = 'Hallitse vieraskirjan merkint&ouml;j&auml; ja pohjia';
$lang['uninstall_pre_message'] = '%s merkint&auml;&auml; poistetaan. Toimintoa ei voi perua!';
$lang['uninstall_pre_message_single'] = '1 merkint&auml; poistetaan. Toimintaa ei voi perua!';
$lang['postuninstall'] = 'Vieraskirja poistettu';
$lang['help'] = '<h3>What does it do?</h3>
<p>
    The guestbook module is a content module and a CMSMS tagmodule.
    It gives visitors the ability to leave a message, for example about how they like the website.
</p>

<h3>Security</h3>
<p>
    The user must belong to a group with the &#039;Modify Guestbook Entries&#039; permission in order to add, edit, or delete guestbook entries.<br />
    In order to be able to modify the guestbook entry template, &#039;Modify Guestbook Template&#039; permission is required.
</p>

<h3>How do I use it?</h3>
<p>
    The easiest way is to create a new page and change the &quot;Content Type&quot; to Guestbook. This way you will be able to set the guestbook options as page properties.<br />
    If you want to add the module after some other content you can insert it using the cms_module tag. This will insert the guestbook into your template/page anywhere you wish.<br /> 
    The code would look something like: <code>{cms_module module=&quot;Guestbook&quot; number=&quot;5&quot; shownow=&quot;1&quot; smiley=&quot;1&quot;}</code>
</p>

<h3>What Parameters Exist?</h3>
<ul>
<li><em>(optional)</em> textleng=&quot;1000&quot; - Sets how many characters can be entered. The default is 1000 characters. This parameter affects both server-side and client-side validation.</li>
<li><em>(optional)</em> number=&quot;10&quot; - Maximum number of entries on a page.  Leaving it empty will show 10 entries</li>
<li><em>(optional)</em> mailnoti=&quot;youremail@example.com&quot; - E-mail address to send a notification to if a message was submitted</li>
<li><em>(optional)</em> sortasc=&quot;1&quot; - Sort guestbook items in ascending date order (new posts will go to the end).</li>
<li><em>(optional)</em> dateformat=&quot;dateformat&quot; - Change the way the Date will display, it takes the MySQL format codes</li>
<li><em>(optional)</em> shownow=&quot;1&quot; - Shows messages right after submission, without approval by an admin.</li>
<li><em>(optional)</em> smiley=&quot;1&quot; - Translate text-based smileys to image smileys and shows the smiley table on the entry submit form.</li>
<li><em>(optional)</em> showaddform=&quot;1&quot; - Shows the insert form on the first page.  Replaces the &quot;New Guestbook Entry&quot; button.</li>
<li><em>(optional)</em> lang=&quot;xx_XX&quot; - Custom locale. For example lang=&quot;de_DE&quot;.</li>
</ul>

<h3>What Design potentials are there?</h3>
<p>
    The database template that is used to show a guestbook entry can be edited from the admin panel.
</p>
<p>
    An example stylesheet for the default database template is installed with the module.<br />
    The default stylesheet is deleted when the module is uninstalled and may be overwitten by an upgrade, so you might want to use a copy if you modify it.<br />
    Attach the stylesheet to the page template used.
</p>
<p>
    These variables are assigned in the guestbook entry template:
    <pre>
    date_title
    date
    time
    time_hour_title
    
    sender_title
    sender
    
    country
    
    e_mail_title
    e_mail
    
    homepage_title
    homepage
    
    message_title
    message
    </pre>
</p>
<p>
    In the module directory there&#039;s a directory called templates where all other templates are stored. You can modify these to fit your needs:
</p>

<strong>Administration</strong>
<p>
admin_entries_top.tpl -> The paganition and row names for the entry list<br/>
admin_entries_entry.tpl -> The list of guestbook entries<br/>
admin_entries_bottom.tpl -> The bottom of the guestbook entries admin form<br />
admin_entry.tpl-> The form used to insert or edit guestbook entries<br/>
admin_template_edit.tpl -> Used for editing the guestbook entry database template
</p>

<strong>Front End</strong>
<p>
newguest.tpl -> Button to go to the entry form<br/>
insertform.tpl -> The guestbook entry form<br />
smiley.tpl -> The smiley table<br/>
prevnext.tpl -> The buttons to go to the previous and next pages (will show only if entries do not fit on one page)<br/>
success_message.tpl-> The message that will show in place of the insert form after successful post submission.
</p>

<p>
    Inside the template directory there&#039;s a directory called db. This stores the guestbook entry template that is copied to the database during module installation and when the template is restored to default from the admin panel.<br />
    By default the file guestbook_entry-default.tpl is used, but if a (custom) file guestbook_entry.tpl is present, this file will be used instead.
</p>
<h3>Importing gastbuch messages</h3>
<p>
    If you have one of the beta &quot;gastbuch&quot; module versions installed and want to import your guestbook messages into the Guestbook module, a script is available to do so.
    Simply point your browser to the file gastbuch-import.php in the module folder (for example: http://www.example.com/cms/modules/Guestbook/gastbuch-import.php) before uninstalling the old gastbuch module.
</p>';
$lang['changelog'] = '<ul>
    <li>
	<p><b>Version 1.0</b></p>
	<ul>
	    <li>Renamed module (from gastbuch) to Guestbook to represent the projects natural language and follow CMS Made Simple module naming conventions.</li>
	    <li>Enabled handling (deleting, activating and deactivating) of multiple guestbook entries from the admin panel.</li>
	    <li>There are now seperate &#039;Modify Guestbook Entries&#039; and &#039;Modify Guestbook Template&#039; permissions.</li>
	    <li>A default/example stylesheet is installed (and uninstalled) with the module</li>
	    <li>The database template can be restored to default</li>
	    <li>Changed to tabbed navigation</li>
	    <li>Cleanup/rewrite of the guestbook(item) database template and the variables used in it.</li>
	    <li>Translated many variable names and code comments to english.
	    <li>Moved some admin and log messages to the language file.</li>
	    <li>Re-formatted source code for better readability.</li>
	</ul>
    </li>
    <li>
	<p><b>Version 0.9</b></p>
	<ul>
	    <li>The guestbook frontend now uses a database template (in stead of the showmessage*.tpl files) that can be modified from the admin panel</li>
	    <li>The dateformat parameter is now called dateformat (was dateform). Note: this means you will have to recreate any guestbook content pages or manually edit the tables cms_content and cms_content_props</li>
	    <li>New french translation and modified translations for other languages from the translation center</li>
	</ul>
    </li>
    <li>
	<p><b>Version 0.8</b></p>
	Fixed:
	<ul>
	    <li>not working smileys on gastbuch Content page in version 0.7</li>
	</ul>
	Cleanup:
	<ul>
	    <li>mainly removal of unneccary references to the global $gCms</li>
	    <li>renamed email textfield to e_mail (it was called betreff, probably an old subject field)</li>
	</ul>
	Improvements:
	<ul>
	    <li>newly submitted newsentry is shown in the list</li>
	    <li>brackets around submitter country are no longer shown if a country wasn&#039;t entered</li>
	    <li>translated the lang file to dutch (except for help and changelog)</li>
	    <li>the gastbuch module now makes use of translations entered in the translation center translations.cmsmadesimple.org</li>
	</ul>
	Changed:
	<ul>
	    <li>The template variable name for the country in showmessage.tpl is now called $country (was $countryshow in previous versions)</li>
	</ul>
    </li>
    <li>
	<p><b>Version 0.7</b></p>
	<ul>
	    <li>Added lang attribute to support multiple locales</li>
	    <li>Show insert form on the first page</li>
	    <li>Fixed bug with textlength javascript not working</li>
	    <li>Fixed a few minor bugs</li>
	</ul>
    <li>
	<p><b>Version 0.6</b></p>
	<ul>
	    <li>Redesigned source code for better readability</li>
	    <li>Added lang attribute to support multiple locales</li>
	    <li>Added showaddform parameter</li>
	    <li>Fixed bug with textlength javascript not working in case of &quot;Content&quot; content type</li>
	    <li>Merged vorzu and backzu templates into one</li>
	    <li>Added template success_message.tpl</li>
	    <li>Fixed a few minor bugs caused by mismatches in lang variable names</li>
	</ul>
    </li>
    <li>
	<p><b>Version 0.5</b></p>
	<p>
	    The guestbook was modified with better design and functions, for example: 
	    Template based Content, Spam protection for inserted e-mails, etc.
	</p>
    </li>
    <li>
	<p><b>Version 0.4</b></p>
	<p>The gastbuch module is now a new module</p>
    </li>
</ul>
';
$lang['utma'] = '156861353.1775561005.1147781292.1154025475.1154032229.17';
$lang['utmz'] = '156861353.1150026931.12.6.utmccn=(referral)|utmcsr=tsw.backspace.fi|utmcct=/svn2/index.php|utmcmd=referral';
?>]]></data>
	</file>
	<file>
	  <filename>/lang/ext/fr_FR.php</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[<?php
$lang['module_friendlyname'] = 'Livre d&#039;Or';
$lang['default_guestbook_name'] = 'd&eacute;faut';
$lang['default_guestbook_descr'] = 'Le premier livre d&#039;or';
$lang['module_example_stylesheet'] = 'Livre d&#039;Or (gabarit par d&eacute;faut)';
$lang['module_example_stylesheet_intro'] = 'Gabarit par d&eacute;faut pour le module Livre d&#039;Or.
Peut &ecirc;tre remplac&eacute; quand le module est mis &agrave; jour et sera effac&eacute; lors de la d&eacute;sinstallation du module. Donc, faites une copie de ce contenu si vous le modifiez.';
$lang['captcha'] = 'Captcha ';
$lang['captcha_title'] = 'Merci de taper le texte contenu dans l&#039;image ci-dessous';
$lang['captcha_failure_message'] = 'Le texte que vous avez tap&eacute; est incorrect';
$lang['timespan'] = 'D&eacute;lai minimum entre deux d&eacute;pots de messages';
$lang['err_invalid_mode'] = 'Erreur : param&egrave;tre de mode invalide. Les modes valides sont : %s.';
$lang['err_no_entry_id'] = 'Erreur : param&egrave;tre entry_id non sp&eacute;cifi&eacute;. Avec le mode mode=entry, le param&egrave;tre entry_id doit &ecirc;tre sp&eacute;cifi&eacute;.';
$lang['err_entry_not_found'] = 'Erreur : il n&#039;y a pas d&#039;entr&eacute;e dans le Livre d&#039;Or avec l&#039;entry_id %s';
$lang['error_template_filenotfound'] = 'Erreur : impossible de trouver le fichier de gabarit %s !';
$lang['default'] = 'D&eacute;faut';
$lang['add_guestbook'] = 'Cr&eacute;er un nouveau Livre d&#039;Or';
$lang['adding_guestbook'] = 'Ajouter un nouveau livre d&#039;or';
$lang['editing_guestbook'] = 'Modifier un livre d&#039;or';
$lang['set_as_default'] = 'D&eacute;finir par d&eacute;faut';
$lang['confirm_set_as_default'] = 'D&eacute;finir ce Livre d&#039;Or comme d&eacute;faut ?';
$lang['confirm_delete_guestbook'] = 'Effacer le livre d&#039;or ayant pour ID : %s ? Les %s entr&eacute;es seront effac&eacute;es !';
$lang['id'] = 'Identifiant';
$lang['date'] = 'Date ';
$lang['sender'] = 'Exp&eacute;diteur';
$lang['email'] = 'Courriel';
$lang['country'] = 'Pays';
$lang['location'] = 'Lieu/ville';
$lang['homepage'] = 'Site web';
$lang['message'] = 'Message ';
$lang['posted'] = 'Envoy&eacute;';
$lang['ip_addr'] = 'Adresse IP';
$lang['alength'] = 'Caract&egrave;res restants';
$lang['active'] = 'Actif';
$lang['access_denied'] = 'Acc&egrave;s refus&eacute;';
$lang['restore_to_defaults'] = 'Restaurer la configuration par d&eacute;faut';
$lang['restore_to_defaults_warning'] = 'Cette op&eacute;ration va restaurer le gabarit par d&eacute;faut et va par cons&eacute;quent effacer les modifications effectu&eacute;es sur celui-ci. &Ecirc;tes-vous s&ucirc;r de vouloir effectuer cette op&eacute;ration&nbsp;?';
$lang['addgait'] = 'Ajouter un message';
$lang['postdate'] = 'Date d&#039;envoi';
$lang['ativi'] = 'Activer';
$lang['deakti'] = 'D&eacute;sactiver';
$lang['title_mod_admin'] = 'G&eacute;rer les messages du Livre d&#039;Or';
$lang['tabname_guestbooks'] = 'Livres d&#039;Or';
$lang['tabname_entries'] = 'Entr&eacute;es';
$lang['title_mod_templates'] = 'Gabarits';
$lang['tabname_settings'] = 'Pr&eacute;f&eacute;rences du module';
$lang['title_tab_admin_templates'] = 'Gabarits du Livre d&#039;Or';
$lang['title_tab_admin_template'] = 'Gabarit du Livre d&#039;Or';
$lang['title_tab_admin_entrylist_template'] = 'Gabarit de liste de messages';
$lang['title_tab_admin_entry_template'] = 'Gabarit de message d&eacute;taill&eacute;';
$lang['title_tab_admin_form_template'] = 'Gabarit du formulaire';
$lang['title_tab_admin_email_template'] = 'Gabarit du courriel';
$lang['title_tab_admin_showform_button_template'] = 'Afficher le gabarit du formulaire';
$lang['templatecontent'] = 'Contenu du gabarit';
$lang['admin_template_modified_logmessage'] = 'Gabarit modifi&eacute; du Livre d&#039;Or';
$lang['admin_template_restored_logmessage'] = 'Le gabarit par d&eacute;faut a &eacute;t&eacute; restaur&eacute;.';
$lang['admin_entry_added_logmessage'] = 'Le message a &eacute;t&eacute; ajout&eacute; au Livre d&#039;Or';
$lang['admin_entry_modified_logmessage'] = 'Message modifi&eacute; dans le Livre d&#039;Or';
$lang['admin_entry_deleted_logmessage'] = 'Message supprim&eacute; du Livre d&#039;Or';
$lang['admin_entry_activated_logmessage'] = 'Message activ&eacute; dans le Livre d&#039;Or';
$lang['admin_entry_deactivated_logmessage'] = 'Message d&eacute;sactiv&eacute; dans le Livre d&#039;Or';
$lang['admin_entry_message_nosender'] = 'Merci d&#039;entrer un exp&eacute;diteur';
$lang['wrong_date_format'] = 'Le format de la date doit avoir comme format : AAAA-MM-JJ HH:MM:SS';
$lang['fieldnames'] = 'Noms des champs';
$lang['captcha_module_installed'] = 'Le module Captcha est install&eacute;';
$lang['captcha_module_not_installed'] = 'Le module Captcha n&#039;est pas install&eacute;';
$lang['smileys_module_installed'] = 'Le module Smileys est install&eacute;';
$lang['smileys_module_not_installed'] = 'Le module Simleys n&#039;est pas install&eacute;';
$lang['preferences_title'] = 'Pr&eacute;f&eacute;rences du livre d&#039;or';
$lang['admin_wysiwyg_title'] = 'Utiliser l&#039;&eacute;diteur WYSIWYG dans le formulaire d&#039;entr&eacute;e du Livre d&#039;Or';
$lang['searchsmileys_title'] = 'Utilisez des &eacute;motic&ocirc;nes dans les r&eacute;sultats de recherche';
$lang['save_settings'] = 'Enregistrer les param&egrave;tres';
$lang['settings_saved'] = 'Les param&egrave;tres on &eacute;t&eacute; mis &agrave; jour avec succ&egrave;s.';
$lang['badwords_title'] = 'Mots interdits';
$lang['badwords_replacement_title'] = 'Remplacer les gros mots par';
$lang['admin_entries_per_page_title'] = 'Entr&eacute;es par page (admin)';
$lang['description'] = 'Description&nbsp;';
$lang['nummer'] = 'Nombre de messages par page';
$lang['postchar'] = 'Taille maximum du message';
$lang['emailnot'] = 'Email de notification';
$lang['sortasc'] = 'Tri ascendant';
$lang['smile'] = '&Eacute;motic&ocirc;nes';
$lang['shmenow'] = 'Montrer le message immediatement';
$lang['datefora'] = 'Format de date';
$lang['lang'] = 'Langue (ex: fr_FR)';
$lang['showaddform'] = 'Montrer le formulaire sous les messages';
$lang['fabsend'] = 'Veuillez entrer votre nom <br />';
$lang['fmessag'] = 'Veuiller entrer votre message <br />';
$lang['femail'] = 'Veuillez entrer un e-mail valide <br />';
$lang['tolong'] = 'Trop de caract&egrave;res. Merci de r&eacute;duire la taille du message.';
$lang['toosoon'] = 'Votre dernier message date juste de %s secondes. Le d&eacute;lai minimum entre deux messages est de %s secondes.';
$lang['fui'] = 'Votre message a d&eacute;j&agrave; &eacute;t&eacute; envoy&eacute;';
$lang['badwords_message'] = 'Ces mots ne sont pas autoris&eacute;s : %s';
$lang['showitnow'] = 'Votre message a &eacute;t&eacute; ins&eacute;r&eacute;.';
$lang['showitlater'] = 'Merci ! Votre message appara&icirc;tra apr&egrave;s validation par un administrateur.';
$lang['msg_back'] = 'retour';
$lang['inam'] = 'Nom';
$lang['imessag'] = 'Votre message';
$lang['smessage'] = 'Message ';
$lang['sdate'] = 'Date ';
$lang['ginsert'] = 'Ins&eacute;rer';
$lang['cancel'] = 'Annuler';
$lang['uhr'] = 'heure';
$lang['e_mailnotibetr'] = 'Nouveau message dans le Livre d&#039;Or';
$lang['e_mailnotimessage'] = 'Un nouveau message a &eacute;t&eacute; entr&eacute; dans le Livre d&#039;Or';
$lang['neuein'] = 'Ajouter un message';
$lang['einerseit'] = 'une page';
$lang['eintragauf'] = 'Messages du';
$lang['seitpage'] = 'Pages ';
$lang['backzu'] = '< Pr&eacute;c&eacute;dent';
$lang['nextwei'] = 'Suivant >';
$lang['first_text'] = '&laquo;';
$lang['prev_text'] = '<';
$lang['next_text'] = '>';
$lang['last_text'] = '&raquo;';
$lang['pagination_of'] = 'sur';
$lang['title_table_smileys'] = '&Eacute;motic&ocirc;nes';
$lang['ativimes'] = 'Activer ce message&nbsp;?';
$lang['deaktimes'] = 'D&eacute;sactiver ce message&nbsp;?';
$lang['event_info_GuestbookEntryPosted'] = '&Eacute;v&eacute;nement d&eacute;clench&eacute; &agrave; l&#039;ajout d&#039;une nouvelle entr&eacute;e';
$lang['event_help_GuestbookEntryPosted'] = '<p>&Eacute;v&eacute;nement d&eacute;clench&eacute; &agrave; l&#039;ajout d&#039;une nouvelle entr&eacute;e.</p>
  	 <h4>Param&egrave;tres</h4>
  	 <ul>
		<li><em>entry_id</em> - L&#039;identifiant de l&#039;entr&eacute;e (int)</li>
		<li><em>entry_sender</em> - Le nom entr&eacute; par l&#039;utilisateur (string)</li>
		<li><em>entry_email</em> - L&#039;adresse e-mail entr&eacute;e par l&#039;utilisateur (string)</li>
		<li><em>entry_homepage</em> - L&#039;URL du site web de l&#039;utilisateur (string)</li>
		<li><em>entry_message</em> - Le contenu du message de l&#039;utilisateur (string)</li>
		<li><em>entry_country</em> - Le pays entr&eacute; par l&#039;utilisateur (string)</li>
		<li><em>entry_location</em> - La ville entr&eacute;e par l&#039;utilisateur (string)</li>
		<li><em>entry_date</em> - La date de d&eacute;p&ocirc;t du message (string)</li>
		<li><em>entry_approved</em> - Indique si le message a &eacute;t&eacute; activ&eacute; au moins une fois : 1 si oui, -1 si non (int)</li>
  	 </ul>
';
$lang['event_info_GuestbookEntryDeleted'] = '&Eacute;v&eacute;nement d&eacute;clench&eacute; lors d&#039;une suppresion d&#039;une entr&eacute;e';
$lang['event_help_GuestbookEntryDeleted'] = '&Eacute;v&eacute;nement d&eacute;clench&eacute; lors d&#039;une suppresion d&#039;une entr&eacute;e
  	 <h4>Param&egrave;tres</h4>
  	 <ul>
	  	 <li><em>entry_id</em> - L&#039;identifiant de l&#039;entr&eacute;e (int)</li>
  	 </ul>
';
$lang['event_info_GuestbookEntryActivated'] = '&Eacute;v&eacute;nement d&eacute;clench&eacute; &agrave; l&#039;activation d&#039;une nouvelle entr&eacute;e';
$lang['event_help_GuestbookEntryActivated'] = '&Eacute;v&eacute;nement d&eacute;clench&eacute; &agrave; l&#039;activation d&#039;une nouvelle entr&eacute;e
  	 <h4>Param&egrave;tres</h4>
  	 <ul>
  	 <li><em>entry_id</em> - L&#039;identifiant de l&#039;entr&eacute;e (int)</li>
  	 </ul>
';
$lang['event_info_GuestbookEntryDeactivated'] = '&Eacute;v&eacute;nement d&eacute;clench&eacute; &agrave; la d&eacute;sactivation d&#039;une entr&eacute;e';
$lang['event_help_GuestbookEntryDeactivated'] = '&Eacute;v&eacute;nement d&eacute;clench&eacute; &agrave; la d&eacute;sactivation d&#039;une entr&eacute;e
  	 <h4>Param&egrave;tres</h4>
  	 <ul>
  	 <li><em>entry_id</em> - L&#039;identifiant de l&#039;entr&eacute;e (int)</li>
  	 </ul>
';
$lang['inposmes'] = 'Assurez vous d&#039;ajouter la permission &quot;Modify Guestbook Entries&quot; pour les utilisateurs administrateurs des messages du Livre d&#039;Or et la permission &quot;Modify Guestbook Template&quot; pour les utilisateurs administrateurs du gabarit du Livre d&#039;Or.';
$lang['moddescription'] = 'G&eacute;rer les messages du Livre d&#039;Or.';
$lang['uninstall_pre_message'] = 'Les %s messages de votre Livre d&#039;Or seront d&eacute;finitivement supprim&eacute;s&nbsp;!';
$lang['uninstall_pre_message_single'] = 'Un message de votre Livre d&#039;Or sera d&eacute;finitivement supprim&eacute;&nbsp;!';
$lang['postuninstall'] = 'Le module Livre d&#039;Or a &eacute;t&eacute; d&eacute;sinstall&eacute; avec succ&egrave;s.';
$lang['help_mode'] = '&quot;guestbook&quot;, &quot;form&quot;, &quot;entrylist&quot; or &quot;entry&quot;';
$lang['help_show_entry'] = 'ID d&#039;une entr&eacute;e &agrave; afficher (mode=&quot;entry&quot; est n&eacute;cessaire)';
$lang['help_guestbook'] = 'ID du Livre d&#039;Or';
$lang['help_textleng'] = 'Configure le nombre maximum de caract&egrave;res autoris&eacute;s dans un message. Ce param&egrave;tre affecte &agrave; la fois la validation du message du c&ocirc;t&eacute; client mais aussi du c&ocirc;t&eacute; serveur &eacute;galement. La valeur par d&eacute;faut est 1000.';
$lang['help_number'] = 'Nombre maximum de messages affich&eacute;s par page.';
$lang['help_timespan'] = 'D&eacute;lai minimum entre deux envois de message (en secondes).';
$lang['hide_insertbutton_after_post'] = 'Quand le message est post&eacute;, le bouton d&#039;envoi est masqu&eacute;. ';
$lang['help_mailnoti'] = 'L&#039;adresse e-mail vers laquelle envoyer une notification lorsqu&#039;un message a &eacute;t&eacute; d&eacute;pos&eacute;. Si install&eacute;, le module CMSMailer sera utilis&eacute; pour envoyer ce mail (sinon ce sera la fonction mail native de PHP).';
$lang['help_sortasc'] = 'Trier les messages dans un ordre croissant (les nouveaux messages seront &agrave; la fin).';
$lang['help_dateformat'] = 'Modifier le format d&#039;affichage de la date (sp&eacute;cifier au format PHP)';
$lang['help_shownow'] = 'Afficher les messages d&egrave;s leur d&eacute;p&ocirc;t, sans validation par un administrateur.';
$lang['help_smiley'] = 'Traduire les &eacute;motic&ocirc;nes textuels vers leur correspondant imag&eacute; et afficher la table des &eacute;motic&ocirc;nes dans le formulaire de saisie de message. Ceci utilise le module Emotic&ocirc;nes (Smileys) s&#039;il est install&eacute;.';
$lang['help_captcha'] = 'Active l&#039;utilisation de captcha dans le formulaire de saisie de message. Le module Captcha doit &ecirc;tre install&eacute; pour que ce param&egrave;tre fonctionne correctement.';
$lang['help_showaddform'] = 'Afficher directement le formulaire de d&eacute;p&ocirc;t de message sur la premi&egrave;re page. Ceci remplace le bouton &quot;Ajouter un message&quot;.';
$lang['help'] = '<h3>Que fait ce module?</h3>
	<p>Le module Livre d&#039;Or fournit un nouveau type de contenu (contenttype) et peut aussi s&#039;utiliser sous forme de balise CMSMS.
Il permet aux visiteurs de laisser un message d&#039;appr&eacute;ciation de votre site web.</p>

<h3>Securit&eacute;</h3>
<p>L&#039;administrateur doit appartenir &agrave; un groupe qui a la permission &quot;Modify Guestbook Entries&quot; afin d&#039;ajouter, &eacute;diter et supprimer des messages dans le Livre d&#039;Or. L&#039;administrateur doit appartenir &agrave; un groupe qui a la permission &quot;Modify Guestbook Template&quot; afin de modifier le gabarit du Livre d&#039;Or. Tous les visiteurs de votre site peuvent poster des messages.</p>

<h3>Comment l&#039;utiliser ?</h3>
<p>Le meilleur moyen est de cr&eacute;er une nouvelle page de Contenu et de d&eacute;finir son Type de contenu &agrave; &quot;Livre d&#039;Or&quot;.<br />
Ensuite, vous pouvez s&eacute;lectionner les options que vous souhaitez utiliser dans le Livre d&#039;Or.<br />
Si vous voulez positionner le module apr&egrave;s du contenu autre (texte, images...),  vous devrez alors utiliser la deuxi&egrave;me m&eacute;thode, qui consiste &agrave; utiliser le module en conjonction avec la balise cms_module.<br />
Cel&agrave; vous permet d&#039;ins&eacute;rer le module dans votre gabarit ou page, &agrave; l&#039;endroit que vous souhaitez, afin d&#039;afficher les messages du Livre d&#039;Or.<br />
La syntaxe ressemble alors &agrave; ceci :<br />
      <code>{cms_module module=&quot;Guestbook&quot; number=5 shownow=0 smiley=0 mailnoti=you@example.com dateformat=&quot;%d-%m-%Y %H:%M&quot;}</code>
</p>

<h3>Quels sont les param&egrave;tres ?</h3>
<ul>
<li><em>(optionnel)</em> textleng=&quot;1000&quot; - S&eacute;lectionne combien de caract&egrave;res peuvent &ecirc;tre entr&eacute;s par message.
La valeur par d&eacute;fault est 1000 caract&egrave;res.  Ce param&egrave;tre affecte la saisie cot&eacute; visiteur et cot&eacute; administrateur.</li>
<li><em>(optionnel)</em> number=&quot;10&quot; - Le nombre maximum de messages sur une page.  Laiss&eacute; vide ne montrera que 10 messages</li>
<li><em>(optionnel)</em> mailnoti=&quot;votremail@votredomaine.tld&quot; - Notification par E-mail quand un messsage est ajout&eacute;. Le module CMSMailer est utilis&eacute; s&#039;il est install&eacute;. Sinon, la fonction php mail est utilis&eacute;e.</li>
<li><em>(optionnel)</em> sortasc=&quot;1&quot; - Trie les messages par ordre de date croissante (les nouveaux &agrave; la fin).</li>
<li><em>(optionnel)</em> dateformat=&quot;dateformat&quot; - Change le format d&#039;affichage de la date, suivant les codes de format mysql</li>
<li><em>(optionnel)</em> shownow=&quot;1&quot; - Affiche les messages imm&eacute;diatement apr&egrave;s leur insertion (pas de mod&eacute;ration par un administrateur).</li>
<li><em>(optionnel)</em> smiley=&quot;1&quot; - Remplace les smiley &eacute;crits en texte par des images.</li>
<li><em>(optional)</em> captcha=&quot;1&quot; - Autorise captcha dans le formulaire d&#039;entr&eacute;e des messages. Text_CAPTCHA, de PEAR est requis (voir la section sur Captcha plus bas)</li>
<li><em>(optionnel)</em> showaddform=&quot;1&quot; - Affiche directement le formulaire d&#039;ajout de message, donc remplace le bouton &quot;Ajouter un message&quot;.</li>
<li><em>(optionnel)</em> lang=&quot;fr_FR&quot; - Param&eacute;trage de la langue.</li>
</ul>

<h3>Quelles possibilit&eacute;s pour modifier l&#039;apparence du Livre d&#039;Or ?</h3>
<p>Le gabarit utilis&eacute; pour afficher le Livre d&#039;Or peut &ecirc;tre modifi&eacute; &agrave; partir du panneau d&#039;administration</p>
<p>
Un gabarit d&#039;affichage du Livre d&#039;Or est install&eacute; par d&eacute;faut avec le module.<br/>
Le gabarit par d&eacute;faut est supprim&eacute; quand le module Livre d&#039;Or est d&eacute;sinstall&eacute; et peut &ecirc;tre modifi&eacute; par une mise &agrave; jour du module. Donc faites une copie de ce que vous modifiez.<br/>
Attachez le gabarit au gabarit de la page utilis&eacute;e.
</p>

<p>
   Ces variables sont d&eacute;finies dans le gabarit par d&eacute;faut :
    <pre>
    date_title
    date
    time
    time_hour_title
    
    sender_title	
    sender
    
    country_title
    country
    
    e_mail_title
    e_mail		// l&#039;adresse E-mail
    e_mail_cloaked	// l&#039;E-mail avec . remplac&eacute; par &amp;lt;point&amp;gt; and @ by &amp;lt;at&amp;gt;
    
    homepage_title
    homepage
    
    message_title
    message
    </pre>
</p>

<strong>Administration</strong>
<p>
admin_entries_top.tpl -> Noms des colonnes et pagination dans la liste des messages.<br/>
admin_entries_entry.tpl -> Gabarit d&#039;un message du Livre d&#039;Or.<br/>
admin_entries_bottom.tpl -> La fin d&#039;un message sur le formulaire d&#039;admin.<br />
admin_entry.tpl-> Le formulaire utilis&eacute; pour ins&eacute;rer ou modifier un message.<br/>
admin_template_edit.tpl -> Utilis&eacute; pour modifier le gabarit par defaut de la base de donn&eacute;es.
</p>

<strong>Gabarits d&#039;affichage du contenu</strong>
<p>
smiley.tpl -> The smiley table, used when the smiley parameter is used and the Smileys module is not installed.<br/>
</p>

<p>
newguest.tpl -> Bouton pour &quot;ajouter un nouveau message&quot;<br/>
insertform.tpl -> Le formulaire d&#039;entr&eacute;e d&#039;un message<br />
smiley.tpl-> Gabarit du tableau des smileys<br/>
prevnext.tpl-> Les boutons Pr&eacute;c&eacute;dent et Suivant (ne s&#039;affiche que dans le cas de plusieurs pages)<br/>
success_message.tpl-> Le message qui s&#039;affiche &agrave; la place du formulaire apr&egrave;s un envoi de message r&eacute;ussi.
</p>

Dans le r&eacute;pertoire template se trouve un r&eacute;pertoire db dans lequel est stock&eacute; le gabarit par d&eacute;faut qui est copi&eacute; dans la base de donn&eacute;es &agrave; l&#039;installation du module.<br />
Par d&eacute;faut, le fichier guestbook_entry-default.tpl est utilis&eacute;, mais si une fichier (modifi&eacute;) guestbook_entry.tpl est pr&eacute;sent, il sera utilis&eacute; &agrave; la place.
</p>

<h3>Captcha</h3>
<p>
    A catpcha challenge-response test (see <a href="http://www.wikipedia.org/wiki/Captcha">http://www.wikipedia.org/wiki/Captcha</a>) can be used to prevent guestbook spam. The Guestbook module uses PEAR&#039;s Text_CAPTCHA, which will have to be installed on the server.<br />
    You must have GD installed with support for JPEGs, PNGs and TrueType fonts. For more information, see <a href="http://www.php.net/image/">PHP Image Functions</a>.<br />
    Text_CAPTCHA depends on two other PEAR packages, Image_Text and Text_Password. It uses Text_Password to generate the random phrase used in the CAPTCHA test and Image_Text to generate an image file with text in it.<br />
    The process for installing Text_CAPTCHA at the command line is:<br />
    <pre>
    $ pear install Text_Password
    $ pear install Image_Text
    $ pear install --alldeps Text_CAPTCHA
    </pre>
    The webserver process must have sufficient rights to (over)write the file images/captcha/captcha.jpg in the Guestbook module directory.
</p>

<h3>Importer des messages du Livre d&#039;Or</h3>
<p>
    Si vous avez une version ancienne du module Livre d&#039;Or et que vous souhaitez importer vos messages dans votre nouveau Livre d&#039;Or, un script est disponible.
    Faites pointer votre browser internet sur le script gastbuch-import.php qui se trouve dans le r&eacute;pertoire du module Livre d&#039;Or (par exemple: http://www.example.com/cms/modules/Guestbook/gastbuch-import.php) avant de d&eacute;sinstaller le vieux module.
</p>';
$lang['changelog'] = '<ul>
	<li>
		<strong>Version 1.3.0</strong><br />
        <span style=&quot;color:#FF0000;font-style:italic;display:block;&quot;>You have to reset your Guestbook templates when upgrade to this version.</span>
		Fixes:
		<ul>
            <li><span style=&quot;font-weight: bold;&quot;>Content type is now USABLE</span></li>
			<li>Fixed page printing in random</li>
            <li>Fixed XSS security issue in next parameter (Pagination class)</li>
            <li>Fixed message list table who can be broken by HTML in message</li>
            <li><span style=&quot;font-style:italic;font-weight: bold;&quot;>Now fully compatible with CMSMS 1.8</span></li>
		</ul>
        Improvements:
        <ul>
            <li>Content type: More date format</li>
            <li>Prettier URL</li>
            <li>Some translation and admin display improvements</li>
            <li>Completely rewrited Pagination module (faster and more secure)</li>
        </ul>
        New Feature:
        <ul>
            <li>Smiley in Front Wysiwyg</li>
            <li>Front date format can be specified in GetDate() in <a href="http://php.net/manual/en/function.date.php">php format</a> (not english only)</li>
            <li>Front date format is now using smarty to get multilanguage capability - date format should be set as <a href="http://www.smarty.net/manual/en/language.modifier.date.format.php">smarty format</a></li>
            <li>Possibility to select all current entry</li>
            <li>Pagination rewrited to be more speed and usefull</li>
            <li>Managing in which guestbook is the entry</li>
            <li>Multiple destination for notification mail</li>
        </ul>
        Minor fixes:
        <ul>
            <li>W3 proof for Javascript</li>
            <li>Few PHP Notices and warnings</li>
        </ul>
	</li>
	<li>
		<strong>Version 1.1.12</strong><br />
		Fixes:
		<ul>
			<li>Fixed bug when posting a new entry with mod_rewrite on (Thanks to blast2007)</li>
			<li>Fixed incorrect stripping of quotes returned by GetTimestamp</li>
		</ul>
	</li>
	<li>
		<strong>Version 1.1.11</strong><br />
		Fixes:
		<ul>
			<li>Fixed module compatibility with latest CMS Made Simple versions (1.5+)</li>
			<li>Fixed pagination not using full table width</li>
			<li>Fixed some small bugs adding/editing an guestbook entry</li>
			<li>Fixed special characters in (translated) pre-uninstall message(s) not being shown correctly</li>
			<li>Fixed language setting from CMS Made Simple Global Settings not being applied</li>
		</ul>
		Improvements:
		<ul>
			<li>You can now edit a guestbook entry date in the backend</li>
			<li>The number of entries shown per page in the backend is now configurable</li>
		</ul>
	</li>
	<li>
		<strong>Version 1.1.10</strong>
		<ul>
			<li>FIX: Removed this warning from the admin panel: &quot;Warning: vsprintf() [function.vsprintf]: Too few arguments in /home/mywebsite/public_html/lib/translation.functions.php on line 62&quot;</li>
			<li>FIX: Insert of new entries failed, when none mandatory fields were removed from the form.</li>
			<li>FIX: Pagination created invalid XHTML (Text attribute removed)</li>
			<li>CHG: Smileys are now inserted on click via JavaScript. Plain text smileys moved into hint.</li>
			<li>FIX: Wrong encoding and HTML entities in notification emails.</li>
			<li>FIX: Enabled translation for pagination &quot;First&quot; and &quot;Last&quot;.</li>
			<li>CHG: Update SmartyPaginate from 1.5 to 1.6-dev</li>
			<li>FIX: Wrong language field &quot;e_mail&quot; in email notification.</li>
			<li>FIX: Module CMSMailer was not detected/used on PHP4</li>
		</ul>
	</li>
	<li>
		<strong>Version 1.1.9</strong>
		<ul>
			<li>Prevent an E-mail being sent to no address when the mailnoti parameter is not being used</li>
		</ul>
	</li>
	<li>
		<strong>Version 1.1.8</strong>
		<ul>
			<li>Fixed too short ip_address field</li>
			<li>Moved templates to a single tab in the admin</li>
		</ul>
	</li>
	<li>
		<strong>Version 1.1.7</strong>
		<ul>
			<li>Fixed references to old file locations</li>
			<li>Fixed Javascript warning when WYSIWYG is used</li>
		</ul>
	</li>
	<li>
		<strong>Version 1.1.6</strong>
		<ul>
			<li>Fixed character counter not working with FCKeditor</li>
			<li>Moved errormessage to lang file</li>
			<li>Deleted some redundant files</li>
		</ul>
	</li>
	<li>
		<strong>Version 1.1.5</strong>
		<ul>
			<li>Fixed ModuleIsInstalled method always returning false for admin modules/FCKEditorX</li>
			<li>Fixed character counter always starting at 1000</li> 
		</ul>
	</li>
	<li>
		<strong>Version 1.1.4</strong>
		<ul>
			<li>Fixes breaks in messages not showing in 1.1.3</li>
			<li>Added (optional) basic WYSIWYG on the Guestbook entry form</li>
			<li>Added logging of guestbook entry sender IP address</li>
			<li>Added &quot;Modify Guestbook Settings&quot; permission</li>
		</ul>
	</li>
	<li>
		<strong>Version 1.1.3</strong>
		<ul>
			<li>Improved pagination</li>
			<li>Rewrote front-end code to use Smarty for all output</li>
			<li>The front-end Smarty templates now use arrays</li>
			<li>Made most front-end templates editable from the admin</li>
			<li>Added events</li>
			<li>Added bad word filter</i>
		</ul>
	</li>
	<li>
		<strong>Version 1.1.2</strong>
		<ul>
			<li>Fixed a bug where the Next button would show when it shouldn&#039;t</li>
			<li>Any guestbook content is deleted on uninstall to prevent fatal errors in cmsmadesimple-1.x</li>
		</ul>
	</li>
	<li>
		<strong>Version 1.1.1</strong>
		<ul>
			<li>Compatiblity changes for cmsmadesimple-1.0 and a small bugfix</li>
		</ul>
	</li>
	<li>
		<strong>Version 1.1</strong>
		<ul>
			<li>Added Captcha support (in a seperate Captcha module)</li>
			<li>Added timespan parameter (minimal timespan between posts)</li>
			<li>Added location field (for State/Province/City/Town)</li>
			<li>Make use of the Smiley module if it is installed</li>
			<li>Made the module compatible with the cmsmadesimple-1.0 series</li>
			<li>Minimal required CMS version changed to 0.13</li>
		</ul>
	</li>
	<li>
		<strong>Version 1.0</strong>
		<ul>
			<li>Module renomm&eacute; (de gastbuch) en Guestbook pour repr&eacute;senter la langue naturelle et suivre leconventions de CMS Made Simple.</li>
			<li>Activ&eacute; la gestion (suppression, activation et d&eacute;sactivation) d&#039;entr&eacute;es multiples depuis le panneau d&#039;administration.</li>
			<li>Il y a deux permissions s&eacute;par&eacute;es &#039;Modify Guestbook Entries&#039; et &#039;Modify Guestbook Template&#039;.</li>
			<li>Une feuille de style par d&eacute;faut, d&#039;exemple est install&eacute;e (et d&eacute;sinstall&eacute;e) avec le module.</li>
			<li>Le gabarit par d&eacute;faut de la base de donn&eacute;e peut &ecirc;tre restaur&eacute; .</li>
			<li>Modifi&eacute; en navigation par onglets.</li>
			<li>Nettoyage et r&eacute;&eacute;criture du gabarit par d&eacute;faut de la base de donn&eacute;e et des variables utilis&eacute;es dans celui-ci.</li>
			<li>Traduction de multiples noms de variables et de commentaires de code.</li>
			<li>D&eacute;plac&eacute; des messages admin et log dans le fichier de langue.</li>
			<li>Re-format&eacute; le code source pour une meilleure lecture.</li>
			<li>Le module fonctionne maintenant aussi avec une base de donn&eacute;es PostgreSQL.</li>
			<li>Chang&eacute; le format d&#039;insertion par le param&egrave;tre de format de date du format MySQL au format PHP.</li>
			<li>Une nouvelle variable est assign&eacute;e au gabarit (base de donn&eacute;es) guestbookentry template: $e_mail_cloaked. C&#039;est l&#039;adresse email, avec @ remplac&eacute; par &amp;lt;at&amp;gt; et . par &amp;lt;dot&amp;gt;.</li>
			<li>&Eacute;tendu la notification email, il envoie maintnena tle nouveau message du Livre d&#039;Or dans l&#039;email de notification.</li>
			<li>Nouvelle traduction en finlandais, et mise &agrave; jour des traductions en n&eacute;erlandais et norv&eacute;gien, depuis le centre de traduction.</li>
		</ul>
    </li>
    <li>
		<strong>Version 0.9</strong>
		<ul>
			<li>La partie publique du Livre d&#039;Or utilise maintenant un gabarit disponible dans la base de donn&eacute;es (au lieu de gabarits .tpl) qui peut &ecirc;tre modifi&eacute; depuis le panneau d&#039;administration</li>
			<li>Le param&egrave;tre de format de date est maintenant appel&eacute; dateformat (&eacute;tait dateform). Note: cela signifie que vous devrez recr&eacute;er les pages de contenu Livre d&#039;Or ou &eacute;diter manuellement les tables cms_content et cms_content_props</li>
			<li>Nouvelle traduction fran&ccedil;aise et traductions mises &agrave; jour pour les autres langues depuis le centre de traduction</li>
		</ul>
    </li>
    <li>
		<strong>Version 0.8</strong>
		Fixed:
		<ul>
			<li>corrig&eacute;: les smiley ne fonctionnaient pas toujours dans le contenu du Livre d&#039;Or version 0.7</li>
		</ul>
		Nettoyage:
		<ul>
			<li>principalement suppression de r&eacute;f&eacute;rences inutiles au global $gCms</li>
			<li>renomm&eacute; le champtexte email en e_mail (&eacute;tait appel&eacute; betreff, probablement un vieux champ sujet)</li>
		</ul>
		Am&eacute;liorations:
		<ul>
			<li>la derni&egrave;re entr&eacute;e est affich&eacute;e dans la liste</li>
			<li>les accolades autour du pays de l&#039;utilisateur ne sont plus affich&eacute;es si le pays n&#039;est pas entr&eacute;</li>
			<li>traduction en n&eacute;erlandais (sauf pour l&#039;aide et le changelog)</li>
			<li>le module utilise maintenant les traductions entr&eacute;es dans le centre de traductions  translations.cmsmadesimple.org</li>
		</ul>
		Modifi&eacute;:
		<ul>
			<li>Le nom de la variable pour le pays dans le gabarit showmessage.tpl est maintenant appel&eacute; $country (&eacute;tait $countryshow dans les versions ant&eacute;rieures)</li>
		</ul>
    </li>
    <li>
		<strong>Version 0.7</strong>
		<ul>
			<li>Ajout de l&#039;attribut de langue pour le suppor de variables locales multiples</li>
			<li>Affiche le formulaire d&#039;insertion sur la premi&egrave;re page</li>
			<li>Corrig&eacute; un bug avec textlength le javascript ne fonctionnait pas</li>
			<li>Bugs mineurs corrig&eacute;s</li>
		</ul>
	</li>
	<li>
		<strong>Version 0.6</strong>
		<ul>
			<li>Modification du code source pour une meilleure lecture</li>
			<li>Ajout de l&#039;attribut lang pour g&eacute;rer plusieurs langues</li>
			<li>Ajout du param&egrave;tre showaddform</li>
			<li>Correction du bug avec textlength javascript ne marchant pas dans le cas d&#039;un contenu de type Content</li>
			<li>Fusion des gabarits vorzu et backzu</li>
			<li>Ajout du gabarit success_message.tpl</li>
			<li>Correction de bug mineurs causant des incoh&eacute;rences dans les noms de variables lang</li>
		</ul>
	</li>
	<li>
		<strong>Version 0.5</strong>
		<p>Le Livre d&#039;Or a &eacute;t&eacute; modifi&eacute; avec un meilleur design et de nouvelles fonctionalit&eacute;s, par exemple: 
		Contenu avec gabarit, protection anti-spam pour les mails affich&eacute;s etc...</p>
	</li>
	<li>
		<strong>Version 0.4</strong>
		<p>Le Livre d&#039;Or est maintenant un nouveau module</p>
	</li>
</ul>
';
$lang['utma'] = '156861353.679159969.1290339870.1290906220.1291474017.3';
$lang['utmz'] = '156861353.1291474017.3.3.utmccn=(referral)|utmcsr=dev.cmsmadesimple.org|utmcct=/project/code/68|utmcmd=referral';
$lang['qca'] = 'P0-1983909440-1290339870124';
$lang['utmb'] = '156861353';
$lang['utmc'] = '156861353';
?>]]></data>
	</file>
	<file>
	  <filename>/lang/ext/hu_HU.php</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[<?php
$lang['module_friendlyname'] = 'Vend&eacute;gk&ouml;nyv';
$lang['default_guestbook_name'] = 'default';
$lang['default_guestbook_descr'] = 'The first/default guestbook';
$lang['module_example_stylesheet'] = 'Vend&eacute;gk&ouml;nyv (alap&eacute;rtelmezett/p&eacute;lda st&iacute;luslap)';
$lang['module_example_stylesheet_intro'] = 'Alap&eacute;rtelmezett/p&eacute;lda st&iacute;luslap a CMSMS Vend&eacute;gk&ouml;nyv modulj&aacute;hoz. Ez a k&eacute;sőbbiekben fel&uuml;l&iacute;r&oacute;dhat, amikor a modult friss&iacute;ted &eacute;s t&ouml;rl&eacute;sre ker&uuml;l, amikor a modult elt&aacute;vol&iacute;tod. Sz&oacute;val csin&aacute;lj r&oacute;la egy m&aacute;solatot, ha m&oacute;dos&iacute;tod.';
$lang['captcha'] = 'Captcha';
$lang['captcha_title'] = 'K&eacute;rlek add meg a sz&ouml;veget, amit a lenti k&eacute;pen l&aacute;tsz';
$lang['captcha_failure_message'] = 'A sz&ouml;veget nem helyesen adtad meg';
$lang['timespan'] = 'Hozz&aacute;sz&oacute;l&aacute;sok k&ouml;zti minim&aacute;lis idő';
$lang['err_invalid_mode'] = 'Hiba: egy &eacute;rv&eacute;nytelen param&eacute;tert adt&aacute;l meg. &Eacute;rv&eacute;nyes m&oacute;dok: %s.';
$lang['err_no_entry_id'] = 'Hiba: az entry_id param&eacute;ter nincs megadva. A &#039;mode=entry&#039;-vel az entry_id param&eacute;tert is meg kell adni.';
$lang['err_entry_not_found'] = 'Hiba: nincs ilyen entry_id-jű bejegyz&eacute;s: %s';
$lang['error_template_filenotfound'] = 'Hiba: a(z) %s sablon file nem tal&aacute;lhat&oacute;!';
$lang['default'] = 'Default';
$lang['add_guestbook'] = 'Create a new guestbook';
$lang['set_as_default'] = 'Set as default';
$lang['confirm_set_as_default'] = 'Set this guestbook as the default?';
$lang['confirm_delete_guestbook'] = 'Delete the guestbook with ID %s? The %s entries inside will be deleted as well!';
$lang['id'] = 'Azonos&iacute;t&oacute;';
$lang['date'] = 'Date';
$lang['sender'] = 'Felad&oacute;';
$lang['email'] = 'E-mail';
$lang['country'] = 'Orsz&aacute;g';
$lang['location'] = 'Tart&oacute;zkod&aacute;si hely';
$lang['homepage'] = 'Honlap';
$lang['message'] = '&Uuml;zenet';
$lang['posted'] = 'Feladva';
$lang['ip_addr'] = 'IP c&iacute;m';
$lang['alength'] = 'Marad&eacute;k karakterek';
$lang['active'] = 'Akt&iacute;v';
$lang['access_denied'] = 'Hozz&aacute;f&eacute;r&eacute;s megtagadva';
$lang['restore_to_defaults'] = 'Alap&eacute;rtelemz&eacute;s vissza&aacute;ll&iacute;t&aacute;sa';
$lang['restore_to_defaults_warning'] = 'Ez a művelet vissza fogja &aacute;ll&iacute;tani a vend&eacute;gk&ouml;nyv sablon tartalm&aacute;t az alap&eacute;rtelmezettre. Ezzel a sablonon v&eacute;gzett m&oacute;dos&iacute;t&aacute;sok elvesznek. Egyet&eacute;rtesz ezzel?';
$lang['addgait'] = 'Vend&eacute;gk&ouml;nyv bejegyz&eacute;s felv&eacute;tele';
$lang['postdate'] = 'Hozz&aacute;sz&oacute;l&aacute;s ideje';
$lang['ativi'] = 'Aktiv&aacute;l';
$lang['deakti'] = 'Inaktiv&aacute;l';
$lang['title_mod_admin'] = 'Vend&eacute;gk&ouml;nyv bejegyz&eacute;sek kezel&eacute;se';
$lang['title_mod_settings'] = 'Vend&eacute;gk&ouml;nyv be&aacute;ll&iacute;t&aacute;sok';
$lang['title_tab_admin_templates'] = 'Vend&eacute;gk&ouml;nyv sablonok';
$lang['title_tab_admin_template'] = 'Vend&eacute;gk&ouml;nyv sablon';
$lang['title_tab_admin_entrylist_template'] = 'Lista elem sablon';
$lang['title_tab_admin_entry_template'] = 'Bejegyz&eacute;s sablon';
$lang['title_tab_admin_form_template'] = 'Form sablon';
$lang['title_tab_admin_email_template'] = 'E-mail sablon';
$lang['title_tab_admin_showform_button_template'] = 'Form sablon megmutat&aacute;sa';
$lang['templatecontent'] = 'Tartalom sablon';
$lang['admin_template_modified_logmessage'] = 'M&oacute;dos&iacute;tott vend&eacute;gk&ouml;nyv sablon';
$lang['admin_template_restored_logmessage'] = 'Az alap&eacute;rtelmezett vend&eacute;gk&ouml;nyv sablont vissza&aacute;ll&iacute;tottuk';
$lang['admin_entry_added_logmessage'] = 'A vend&eacute;gk&ouml;nyv bejegyz&eacute;st felvett&uuml;k';
$lang['admin_entry_modified_logmessage'] = 'A vend&eacute;gk&ouml;nyv bejegyz&eacute;st m&oacute;do&iacute;tottuk';
$lang['admin_entry_deleted_logmessage'] = 'A vend&eacute;gk&ouml;nyv bejegyz&eacute;st t&ouml;r&ouml;lt&uuml;k';
$lang['admin_entry_activated_logmessage'] = 'A vend&eacute;gk&ouml;nyv bejegyz&eacute;st aktiv&aacute;ltuk';
$lang['admin_entry_deactivated_logmessage'] = 'A vend&eacute;gk&ouml;nyv bejegyz&eacute;st inaktiv&aacute;ltuk';
$lang['admin_entry_message_nosender'] = 'K&eacute;rem adjon meg felad&oacute; nevet';
$lang['wrong_date_format'] = 'Date format should have the format: YYYY-MM-DD HH:MM:SS';
$lang['fieldnames'] = 'Mező nevek';
$lang['captcha_module_installed'] = 'A Captcha modul install&aacute;lva van';
$lang['captcha_module_not_installed'] = 'A Captcha modul nincs install&aacute;lva';
$lang['smileys_module_installed'] = 'A Smileys modul install&aacute;lva van';
$lang['smileys_module_not_installed'] = 'A Smileys modul nincs install&aacute;lva';
$lang['admin_wysiwyg_title'] = 'WYSIWYG haszn&aacute;lata a vend&eacute;gk&ouml;nyv bejegyz&eacute;s &uuml;rlapon';
$lang['searchsmileys_title'] = 'Smiley-k haszn&aacute;lata a tal&aacute;latok k&ouml;z&ouml;tt';
$lang['save_settings'] = 'Be&aacute;ll&iacute;t&aacute;sok ment&eacute;se';
$lang['badwords_title'] = 'Tiltott szavak';
$lang['badwords_replacement_title'] = 'Tiltott szavak helyettes&iacute;t&eacute;se ezzel';
$lang['admin_entries_per_page_title'] = 'Entries per page (admin)';
$lang['description'] = 'Description';
$lang['nummer'] = 'Egy lapon megjelen&iacute;tendő bejegyz&eacute;sek sz&aacute;ma';
$lang['postchar'] = 'Maxim&aacute;lis &uuml;zenet hossz';
$lang['emailnot'] = '&Eacute;rtes&iacute;tő email';
$lang['sortasc'] = 'Cs&ouml;kkenő rendez&eacute;s (ASC)';
$lang['smile'] = 'Smiley';
$lang['shmenow'] = '&Uuml;zenet azonnali megjelen&iacute;t&eacute;se';
$lang['datefora'] = 'D&aacute;tum form&aacute;tum';
$lang['lang'] = 'Locale (pl. hu_HU)';
$lang['showaddform'] = 'A hozz&aacute;sz&oacute;l&aacute;sok alatt a beviteli form is legyen kirakva';
$lang['fabsend'] = 'K&eacute;rlek add meg a nevedet';
$lang['fmessag'] = 'K&eacute;rlek t&ouml;ltsd ki az &uuml;zenetet';
$lang['femail'] = 'K&eacute;rlek, &eacute;rv&eacute;nyes e-mail c&iacute;met adj meg';
$lang['tolong'] = 'T&uacute;l sok karaktert tartalmaz a hozz&aacute;sz&oacute;l&aacute;sod. K&eacute;rlek, cs&ouml;kkentsd a hossz&aacute;t.';
$lang['toosoon'] = 'Csak %s m&aacute;sodperccel ezelőtt &iacute;rt&aacute;l. Viszont sajnos minimum %s m&aacute;sodpercnek el kell telnie k&eacute;t hozz&aacute;sz&oacute;l&aacute;s k&ouml;z&ouml;tt.';
$lang['fui'] = 'Az &uuml;zenetedet m&aacute;r elk&uuml;ldt&uuml;k';
$lang['badwords_message'] = 'Az al&aacute;bbi szavak tiltottak: %s';
$lang['showitnow'] = 'Az &uuml;zenetedet beillesztett&uuml;k';
$lang['showitlater'] = 'K&ouml;sz&ouml;nj&uuml;k! Az &uuml;zenet adminisztr&aacute;tori j&oacute;v&aacute;hagy&aacute;s ut&aacute;n fog megjelenni.';
$lang['msg_back'] = 'vissza';
$lang['inam'] = 'N&eacute;v';
$lang['imessag'] = 'Hozz&aacute;sz&oacute;l&aacute;sod';
$lang['smessage'] = 'Hozz&aacute;sz&oacute;l&aacute;s';
$lang['sdate'] = 'D&aacute;tum';
$lang['ginsert'] = 'Beilleszt&eacute;s';
$lang['cancel'] = 'M&eacute;gse';
$lang['uhr'] = '&oacute;ra';
$lang['e_mailnotibetr'] = '&Uacute;j bejegyz&eacute;s a vend&eacute;gk&ouml;nyvben';
$lang['e_mailnotimessage'] = '&Uacute;j bejegyz&eacute;s ker&uuml;lt a vend&eacute;gk&ouml;nyvbe';
$lang['neuein'] = '&Uacute;j vend&eacute;gk&ouml;nyv bejegyz&eacute;s';
$lang['einerseit'] = 'egy Oldalon';
$lang['eintragauf'] = 'Hozz&aacute;sz&oacute;l&aacute;sok';
$lang['seitpage'] = 'Oldalak';
$lang['backzu'] = '<< Megelőző';
$lang['nextwei'] = 'K&ouml;vetkező >>';
$lang['first_text'] = '&iota;&lsaquo;';
$lang['prev_text'] = '< prev';
$lang['next_text'] = 'next >';
$lang['last_text'] = '&rsaquo;&iota;';
$lang['pagination_of'] = 'b&oacute;l/ből';
$lang['title_table_smileys'] = 'Smiley-k';
$lang['ativimes'] = 'Aktiv&aacute;ljuk ezt az &uuml;zenetet?';
$lang['deaktimes'] = 'Deaktiv&aacute;ljuk ezt az &uuml;zenetet?';
$lang['event_info_GuestbookEntryPosted'] = 'A kiv&aacute;ltand&oacute; esem&eacute;ny amikor &uacute;j vend&eacute;gk&ouml;nyv bejegyz&eacute;s &eacute;rkezik';
$lang['event_help_GuestbookEntryPosted'] = '<p>Event triggered when a new Guestbook entry is added.</p>
  	 <h4>Parameters</h4>
  	 <ul>
		<li><em>entry_id</em> - The entry id (int)</li>
		<li><em>entry_sender</em> - The name the sender entered (string)</li>
		<li><em>entry_email</em> - The E-mail address entered (string)</li>
		<li><em>entry_homepage</em> - The homepage entered (string)</li>
		<li><em>entry_message</em> - The message entered (string)</li>
		<li><em>entry_country</em> - The country entered (string)</li>
		<li><em>entry_location</em> - The location entered (string)</li>
		<li><em>entry_date</em> - The post date (string)</li>
		<li><em>entry_approved</em> - Whether the entry is activated at once, 1 if it is, -1 if not (int)</li>
  	 </ul>
';
$lang['event_info_GuestbookEntryDeleted'] = 'A kiv&aacute;ltand&oacute; esem&eacute;ny amikor t&ouml;rl&eacute;sre ker&uuml;l egy vend&eacute;gk&ouml;nyv bejegyz&eacute;s ';
$lang['event_help_GuestbookEntryDeleted'] = 'Event triggered when a Guestbook entry is deleted
  	 <h4>Parameters</h4>
  	 <ul>
	  	 <li><em>entry_id</em> - The entry id (int)</li>
  	 </ul>
';
$lang['event_info_GuestbookEntryActivated'] = 'A kiv&aacute;ltand&oacute; esem&eacute;ny amikor egy vend&eacute;gk&ouml;nyv bejegyz&eacute;s lesz aktiv&aacute;lva';
$lang['event_help_GuestbookEntryActivated'] = 'Event triggered when a Guestbook entry is activated
  	 <h4>Parameters</h4>
  	 <ul>
  	 <li><em>entry_id</em> - The entry id (int)</li>
  	 </ul>
';
$lang['event_info_GuestbookEntryDeactivated'] = 'A kiv&aacute;ltand&oacute; esem&eacute;ny amikor egy vend&eacute;gk&ouml;nyv bejegyz&eacute;s lesz deaktiv&aacute;lva';
$lang['event_help_GuestbookEntryDeactivated'] = 'Event triggered when a Guestbook entry is de-activated
  	 <h4>Parameters</h4>
  	 <ul>
  	 <li><em>entry_id</em> - The entry id (int)</li>
  	 </ul>
';
$lang['inposmes'] = 'Bizonyosodj meg r&oacute;la, hogy a &quot;Vend&eacute;gk&ouml;nyv Bejegyz&eacute;sek M&oacute;dos&iacute;t&aacute;sa&quot; jogosults&aacute;got minden olyan felhaszn&aacute;l&oacute; megkapta, aki bejegyz&eacute;seket kell, hogy kezeljen. Hasonl&oacute; k&eacute;ppen j&aacute;rj el a &quot;Vend&eacute;gk&ouml;nyv Sablon M&oacute;dos&iacute;t&aacute;sa&quot; jogosults&aacute;ggal is.<br/>Csatold a &quot;%s&quot; nevű st&iacute;luslapot a sablonhoz, ami a Vend&eacute;gk&ouml;nyv megjelen&eacute;s&eacute;&eacute;rt felel.';
$lang['moddescription'] = 'Vend&eacute;gk&ouml;nyv bejegyz&eacute;sek &eacute;s sablon kezel&eacute;se.';
$lang['uninstall_pre_message'] = '%s bejegyz&eacute;s t&ouml;rlődni fog a vend&eacute;gk&ouml;nyvből!';
$lang['uninstall_pre_message_single'] = 'A bejegyz&eacute;s v&eacute;gleg t&ouml;rlődni fog a vend&eacute;gk&ouml;nyvből!';
$lang['postuninstall'] = 'A Vend&eacute;gk&ouml;nyv modult sikeresen elt&aacute;vol&iacute;tottuk.';
$lang['help_mode'] = '&quot;guestbook&quot;, &quot;form&quot;, &quot;entrylist&quot; or &quot;entry&quot;';
$lang['help_show_entry'] = 'ID of an entry to show (mode=&quot;entry&quot; is assumed)';
$lang['help_guestbook'] = 'Guestbook ID';
$lang['help_textleng'] = 'A be&iacute;rhat&oacute; karakterek sz&aacute;m&aacute;t mutatja. Az alap&eacute;rtelmez&eacute;s 1000. Ez a  param&eacute;ter a szerver &eacute;s kliens oldali valid&aacute;l&aacute;sra is hat&aacute;ssal van.';
$lang['help_number'] = 'Az egy oldalon megjelen&iacute;thető elemek maxim&aacute;lis sz&aacute;ma.';
$lang['help_timespan'] = 'K&eacute;t hozz&aacute;sz&oacute;l&aacute;s k&ouml;zti minim&aacute;lis idő (m&aacute;sodpercben megadva).';
$lang['help_mailnoti'] = 'E-mail address to send a notification to if a message was submitted. The CMSMailer module will be used for sending the E-mail if it is installed (otherwise PHP&#039;s mail function is used).';
$lang['help_sortasc'] = 'A hozz&aacute;sz&oacute;l&aacute;sok kronologikus sorrendben (az &uacute;jabbak a v&eacute;g&eacute;n).';
$lang['help_dateformat'] = 'D&aacute;tum megjelen&iacute;t&eacute;si form&aacute;tum megv&aacute;ltoztat&aacute;sa. PHP form&aacute;tim k&oacute;dokat &eacute;rt.';
$lang['help_shownow'] = 'A hozz&aacute;sz&oacute;l&aacute;sok azonnali megjelen&iacute;t&eacute;se, adminisztr&aacute;tori enged&eacute;lyez&eacute;s (cenz&uacute;ra) n&eacute;lk&uuml;l';
$lang['help_smiley'] = 'A sz&ouml;vegesen megadott smiley-k k&eacute;pp&eacute; form&aacute;z&aacute;sa &eacute;s egy smiley t&aacute;bl&aacute;zat mutat&aacute;sa a hozz&aacute;sz&oacute;l&aacute;s form alatt. A Smiley modult haszn&aacute;lja, ha telep&iacute;tve van.';
$lang['help_captcha'] = 'A Captcha modul enged&eacute;lyez&eacute;se a hozz&aacute;sz&oacute;l&aacute;s formra. A Captcha modul telep&iacute;t&eacute;se sz&uuml;ks&eacute;ges ehhez a műk&ouml;d&eacute;shez.';
$lang['help_showaddform'] = 'Shows the insert form on the first page.  Replaces the &quot;New Guestbook Entry&quot; button.';
$lang['help'] = '<h3>What does it do?</h3>
<p>
    The guestbook module is a content module and a CMSMS tagmodule.
    It gives visitors the ability to leave a message, for example about how they like the website.
</p>

<h3>Security</h3>
<p>
    The user must belong to a group with the &#039;Modify Guestbook Entries&#039; permission in order to add, edit, or delete guestbook entries.<br />
    In order to be able to modify the guestbook entry template, &#039;Modify Guestbook Template&#039; permission is required.
</p>

<h3>How do I use it?</h3>
<p>
    The easiest way is to create a new page and change the &quot;Content Type&quot; to Guestbook. This way you will be able to set the guestbook options as page properties.<br />
    If you want to add the module after some other content you can insert it using the cms_module tag. This will insert the guestbook into your template/page anywhere you wish.<br /> 
    The code would look something like: <code>{cms_module module=&quot;Guestbook&quot; number=&quot;5&quot; shownow=&quot;1&quot; smiley=&quot;1&quot;}</code>
</p>

<h3>What Parameters Exist?</h3>
<ul>
<li><em>(optional)</em> textleng=&quot;1000&quot; - Sets how many characters can be entered. The default is 1000 characters. This parameter affects both server-side and client-side validation.</li>
<li><em>(optional)</em> number=&quot;10&quot; - Maximum number of entries on a page.  Leaving it empty will show 10 entries</li>
<li><em>(optional)</em> timespan=&quot;600&quot; - Minimal timespan between posts (in seconds).  Leaving it empty will set timespan=&quot;0&quot;</li>
<li><em>(optional)</em> mailnoti=&quot;youremail@example.com&quot; - E-mail address to send a notification to if a message was submitted. The CMSMailer module will be used for sending the E-mail if it is installed (otherwise PHP&#039;s mail function is used).</li>
<li><em>(optional)</em> sortasc=&quot;1&quot; - Sort guestbook items in ascending date order (new posts will go to the end).</li>
<li><em>(optional)</em> dateformat=&quot;dateformat&quot; - Change the way the Date will display, it takes the PHP format codes</li>
<li><em>(optional)</em> shownow=&quot;1&quot; - Shows messages right after submission, without approval by an admin.</li>
<li><em>(optional)</em> smiley=&quot;1&quot; - Translate text-based smileys to image smileys and shows the smiley table on the entry submit form.</li>
<li><em>(optional)</em> captcha=&quot;1&quot; - This will enable captcha on the guestbook entry form. The Captcha module must be installed for this parameter to work.</li>
<li><em>(optional)</em> showaddform=&quot;1&quot; - Shows the insert form on the first page.  Replaces the &quot;New Guestbook Entry&quot; button.</li>
<li><em>(optional)</em> lang=&quot;xx_XX&quot; - Custom locale. For example lang=&quot;de_DE&quot;.</li>
</ul>

<h3>What Design potentials are there?</h3>
<p>
    The database template that is used to show a guestbook entry can be edited from the admin panel.
</p>
<p>
    An example stylesheet for the default database template is installed with the module.<br />
    The default stylesheet is deleted when the module is uninstalled and may be overwitten by an upgrade, so you might want to use a copy if you modify it.<br />
    Attach the stylesheet to the page template used.
</p>
<p>
    These variables are assigned in the guestbook entry template:
    <pre>
    date_title
    date
    time
    time_hour_title
    
    sender_title	
    sender
    
    country_title
    country
    
    e_mail_title
    e_mail		// the E-mail address
    e_mail_cloaked	// the E-mail address with . replaced by <dot> and @ by <at>
    
    homepage_title
    homepage
    
    message_title
    message
    </pre>
</p>
<p>
    In the module directory there&#039;s a directory called templates where all other templates are stored. You can modify these to fit your needs:
</p>

<strong>Administration</strong>
<p>
admin_entries_top.tpl -> The paganition and row names for the entry list.<br/>
admin_entries_entry.tpl -> The template for an entry in the list of guestbook entries.<br/>
admin_entries_bottom.tpl -> The bottom of the guestbook entries admin form.<br />
admin_entry.tpl-> The form used to insert or edit guestbook entries.<br/>
admin_template_edit.tpl -> Used for editing the guestbook entry database template.
</p>

<strong>Front End</strong>
<p>
newguest.tpl -> Button to go to the entry form<br/>
insertform.tpl -> The guestbook entry form<br />
smiley.tpl -> The smiley table<br/>
prevnext.tpl -> The buttons to go to the previous and next pages (will show only if entries do not fit on one page)<br/>
success_message.tpl-> The message that will show in place of the insert form after successful post submission.
</p>

<p>
    Inside the template directory there&#039;s a directory called db. This stores the guestbook entry template that is copied to the database during module installation and when the template is restored to default from the admin panel.<br />
    By default the file guestbook_entry-default.tpl is used, but if a (custom) file guestbook_entry.tpl is present, this file will be used instead.
</p>

<h3>Importing gastbuch messages</h3>
<p>
    If you have one of the beta &quot;gastbuch&quot; module versions installed and want to import your guestbook messages into the Guestbook module, a script is available to do so.
    Simply point your browser to the file gastbuch-import.php in the module folder (for example: http://www.example.com/cms/modules/Guestbook/gastbuch-import.php) before uninstalling the old gastbuch module.
</p>';
$lang['changelog'] = '<ul>
    <li>
        <p><b>Version 1.1</b></p>
        <ul>
            <li>Added Captcha support (in a seperate Captcha module)</li>
            <li>Added timespan parameter (minimal timespan between posts)</li>
            <li>Added location field (for State/Province/City/Town)</li>
        </ul>
    </li>
								    
    <li>
	<p><b>Version 1.0</b></p>
	<ul>
	    <li>Renamed module (from gastbuch) to Guestbook to represent the projects natural language and follow CMS Made Simple module naming conventions.</li>
	    <li>Enabled handling (deleting, activating and deactivating) of multiple guestbook entries from the admin panel.</li>
	    <li>There are now seperate &#039;Modify Guestbook Entries&#039; and &#039;Modify Guestbook Template&#039; permissions.</li>
	    <li>A default/example stylesheet is installed (and uninstalled) with the module.</li>
	    <li>The database template can be restored to default.</li>
	    <li>Changed to tabbed navigation.</li>
	    <li>Cleanup/rewrite of the guestbook(item) database template and the variables used in it.</li>
	    <li>Translated many variable names and code comments to english.</li>
	    <li>Moved some admin and log messages to the language file.</li>
	    <li>Re-formatted source code for better readability.</li>
	    <li>The module now also works in combination with a PostgreSQL database.</li>
	    <li>Changed the input format for the dateformat parameter from MySQL format to PHP format.</li>
	    <li>A new variable is assigned to the (database) guestbookentry template: $e_mail_cloaked. This is the E-mail address, with @ replaced by <at> and . by <dot>.</li>
	    <li>Extended the notification E-mail, it now sends the new guestbook entry in the notification message.</li>
	    <li>New finnish translation and updated dutch and norwegian translations from the translation center.</li>
	</ul>
    </li>
    <li>
	<p><b>Version 0.9</b></p>
	<ul>
	    <li>The guestbook frontend now uses a database template (in stead of the showmessage*.tpl files) that can be modified from the admin panel</li>
	    <li>The dateformat parameter is now called dateformat (was dateform). Note: this means you will have to recreate any guestbook content pages or manually edit the tables cms_content and cms_content_props</li>
	    <li>New french translation and modified translations for other languages from the translation center</li>
	</ul>
    </li>
    <li>
	<p><b>Version 0.8</b></p>
	Fixed:
	<ul>
	    <li>not working smileys on gastbuch Content page in version 0.7</li>
	</ul>
	Cleanup:
	<ul>
	    <li>mainly removal of unneccary references to the global $gCms</li>
	    <li>renamed email textfield to e_mail (it was called betreff, probably an old subject field)</li>
	</ul>
	Improvements:
	<ul>
	    <li>newly submitted newsentry is shown in the list</li>
	    <li>brackets around submitter country are no longer shown if a country wasn&#039;t entered</li>
	    <li>translated the lang file to dutch (except for help and changelog)</li>
	    <li>the gastbuch module now makes use of translations entered in the translation center translations.cmsmadesimple.org</li>
	</ul>
	Changed:
	<ul>
	    <li>The template variable name for the country in showmessage.tpl is now called $country (was $countryshow in previous versions)</li>
	</ul>
    </li>
    <li>
	<p><b>Version 0.7</b></p>
	<ul>
	    <li>Added lang attribute to support multiple locales</li>
	    <li>Show insert form on the first page</li>
	    <li>Fixed bug with textlength javascript not working</li>
	    <li>Fixed a few minor bugs</li>
	</ul>
    <li>
	<p><b>Version 0.6</b></p>
	<ul>
	    <li>Redesigned source code for better readability</li>
	    <li>Added lang attribute to support multiple locales</li>
	    <li>Added showaddform parameter</li>
	    <li>Fixed bug with textlength javascript not working in case of &quot;Content&quot; content type</li>
	    <li>Merged vorzu and backzu templates into one</li>
	    <li>Added template success_message.tpl</li>
	    <li>Fixed a few minor bugs caused by mismatches in lang variable names</li>
	</ul>
    </li>
    <li>
	<p><b>Version 0.5</b></p>
	<p>
	    The guestbook was modified with better design and functions, for example: 
	    Template based Content, Spam protection for inserted e-mails, etc.
	</p>
    </li>
    <li>
	<p><b>Version 0.4</b></p>
	<p>The gastbuch module is now a new module</p>
    </li>
</ul>
';
$lang['utma'] = '156861353.1540689137.1263375773.1264530718.1264963723.6';
$lang['utmz'] = '156861353.1264530718.5.2.utmcsr=users.atw.hu|utmccn=(referral)|utmcmd=referral|utmcct=/lisolinux/admin/moduleinterface.php';
$lang['qca'] = 'P0-1970219776-1263375773882';
$lang['utmb'] = '156861353.1.10.1264963723';
$lang['utmc'] = '156861353';
?>]]></data>
	</file>
	<file>
	  <filename>/lang/ext/it_IT.php</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[<?php
$lang['module_friendlyname'] = 'Guestbook';
$lang['module_example_stylesheet'] = 'Guestbook (foglio di stile predefinito/di esempio)';
$lang['module_example_stylesheet_intro'] = 'Foglio di stile predefinito/di esempio peril modulo CMSMS Guestbook.
Questo potrebbe essere sovrascritto quando il modulo viene aggiornato e viene eliminato quando il modulo viene disinstallato, quindi fate una copia se volete modificarlo.';
$lang['captcha'] = 'Captcha';
$lang['captcha_title'] = 'Inserite il testo contenuto nell&#039;imagine seguente.';
$lang['captcha_failure_message'] = 'Il testo dell&#039;immagine non &egrave; stato inserito correttamente.';
$lang['timespan'] = 'Tempo minimo tra un inserimento ed il successivo';
$lang['err_invalid_mode'] = 'Errore: &egrave; stato in specificato un parametro di modalit&agrave; errato. Le modalit&agrave; valide sono: %s.';
$lang['err_no_entry_id'] = 'Errore: nessun parametro entry_id specificato. Usando mode=entry deve essere specificato anche un parametro entry_id.';
$lang['err_entry_not_found'] = 'Errore: nessun Guestbook con entry_id %s esistente';
$lang['error_template_filenotfound'] = 'Errore: non &egrave; possibile trovare il file del modello %s !';
$lang['id'] = 'ID';
$lang['sender'] = 'Mittente';
$lang['email'] = 'Email';
$lang['country'] = 'Nazione';
$lang['location'] = 'Localit&agrave;';
$lang['homepage'] = 'Homepage';
$lang['message'] = 'Messaggio';
$lang['posted'] = 'Inserito';
$lang['ip_addr'] = 'Indirizzo IP';
$lang['alength'] = 'Caratteri rimanenti';
$lang['active'] = 'Attivo';
$lang['access_denied'] = 'Accesso Negato';
$lang['restore_to_defaults'] = 'Reimposta a default';
$lang['restore_to_defaults_warning'] = 'Questa operazione reimposta il contenuto del template al suo default. Questo sovrascriver&agrave;  ogni cambiamento fatto al template. Siete sicuri di voler continuare?';
$lang['addgait'] = 'Aggiungi messaggio al Guestbook';
$lang['postdate'] = 'Data Inserimento';
$lang['ativi'] = 'Attivare';
$lang['deakti'] = 'Disattivare';
$lang['title_mod_admin'] = 'Gestione messaggi del Guestbook';
$lang['title_mod_settings'] = 'Impostazione Guestbook';
$lang['title_tab_admin_templates'] = 'Modelli del Guestbook';
$lang['title_tab_admin_template'] = 'Modello del Guestbook';
$lang['title_tab_admin_entrylist_template'] = 'Modello Lista Messaggi';
$lang['title_tab_admin_entry_template'] = 'Modello Messaggio';
$lang['title_tab_admin_form_template'] = 'Modello del Modulo';
$lang['title_tab_admin_email_template'] = 'Modello di E-mail';
$lang['title_tab_admin_showform_button_template'] = 'Modello Mostra Modulo';
$lang['templatecontent'] = 'Contenuto del Modello';
$lang['admin_template_modified_logmessage'] = 'Modello Guestbook Modidicato';
$lang['admin_template_restored_logmessage'] = 'Modello Guestbook Ripristinato ai valori predefiniti';
$lang['admin_entry_added_logmessage'] = 'Messaggio Aggiunto al Guestbook';
$lang['admin_entry_modified_logmessage'] = 'Messaggio Guestbook Modificato';
$lang['admin_entry_deleted_logmessage'] = 'Messaggio Guestbook Eliminato';
$lang['admin_entry_activated_logmessage'] = 'Mesasggio Guestbook Attivato';
$lang['admin_entry_deactivated_logmessage'] = 'Messaggio Guestbook Disattivato';
$lang['admin_entry_message_nosender'] = 'Inserite il nome dell&#039;autore';
$lang['fieldnames'] = 'Nomi dei campi';
$lang['captcha_module_installed'] = 'Il modulo Captcha &egrave; installato';
$lang['captcha_module_not_installed'] = 'Il modulo Captcha non &egrave; installato';
$lang['smileys_module_installed'] = 'Il modulo Smileys &egrave; installato';
$lang['smileys_module_not_installed'] = 'Il modulo Smileys non &egrave; installato';
$lang['admin_wysiwyg_title'] = 'Usa WYSIWYG nel modulo di composizione messaggio del guestbook';
$lang['searchsmileys_title'] = 'Usa gli smile nei risultati della ricerca';
$lang['save_settings'] = 'Salva le impostazioni';
$lang['badwords_title'] = 'Parole che non sono consentite';
$lang['badwords_replacement_title'] = 'Sostituisci parole non consentite con';
$lang['nummer'] = 'Numero di messaggi per pagina';
$lang['postchar'] = 'Dimensione massima del messaggio';
$lang['emailnot'] = 'Email di notifica';
$lang['sortasc'] = 'Ordinamento ascendente (ASC)';
$lang['smile'] = 'Smiley';
$lang['shmenow'] = 'Mostra il messaggio immediatamente';
$lang['datefora'] = 'Formato della data';
$lang['lang'] = 'Locale (es. it_IT)';
$lang['showaddform'] = 'Mostra il modulo di inserimento subito';
$lang['fabsend'] = 'Inserite il vostro nome';
$lang['fmessag'] = 'Inserite un messaggio';
$lang['femail'] = 'Inserite un indirizzo email valido';
$lang['tolong'] = 'Troppi caratteri. Scrivete un messaggio pi&ugrave; corto.';
$lang['toosoon'] = 'Il vostro ultimo inserimento &egrave; stato %s secondi fa. Il tempo minimo tra un inserimento ed il successivo &egrave; di %s secondi.';
$lang['fui'] = 'Il vostro messaggio &egrave; stato gi&agrave; inviato';
$lang['badwords_message'] = 'Queste parole non sono consentite: %s';
$lang['showitnow'] = 'Il vostro messaggio &egrave; stato inserito. Grazie!';
$lang['showitlater'] = 'Grazie! Il messaggio apparir&agrave; quando sar&agrave; validato da un moderatore.';
$lang['msg_back'] = 'indietro';
$lang['inam'] = 'Nome';
$lang['imessag'] = 'Il vostro Messaggio';
$lang['smessage'] = 'Messaggio';
$lang['sdate'] = 'Data';
$lang['ginsert'] = 'Inserisci';
$lang['cancel'] = 'Annulla';
$lang['uhr'] = 'ora';
$lang['e_mailnotibetr'] = 'Nuovo messaggio nel vostro Guestbook';
$lang['e_mailnotimessage'] = 'C&#039;&egrave; un nuovo messaggio nel guestbook';
$lang['neuein'] = 'Nuovo messaggio del Guestbook';
$lang['einerseit'] = 'una Pagina';
$lang['eintragauf'] = 'Inserito il';
$lang['seitpage'] = 'Pagine';
$lang['backzu'] = '<< Indietro';
$lang['nextwei'] = 'Avanti >>';
$lang['first_text'] = '<<';
$lang['prev_text'] = '<';
$lang['next_text'] = '>';
$lang['last_text'] = '>>';
$lang['pagination_of'] = 'di';
$lang['title_table_smileys'] = 'Smiley';
$lang['ativimes'] = 'Attiva questo messaggio?';
$lang['deaktimes'] = 'Disattiva questo messaggio?';
$lang['event_info_GuestbookEntryPosted'] = 'Evento attivato quando viene aggiunto un nuovo messaggio del Guestbook';
$lang['event_help_GuestbookEntryPosted'] = '<p>Event triggered when a new Guestbook entry is added.</p>
  	 <h4>Parameters</h4>
  	 <ul>
		<li><em>entry_id</em> - The entry id (int)</li>
		<li><em>entry_sender</em> - The name the sender entered (string)</li>
		<li><em>entry_email</em> - The E-mail address entered (string)</li>
		<li><em>entry_homepage</em> - The homepage entered (string)</li>
		<li><em>entry_message</em> - The message entered (string)</li>
		<li><em>entry_country</em> - The country entered (string)</li>
		<li><em>entry_location</em> - The location entered (string)</li>
		<li><em>entry_date</em> - The post date (string)</li>
		<li><em>entry_approved</em> - Whether the entry is activated at once, 1 if it is, -1 if not (int)</li>
  	 </ul>
';
$lang['event_info_GuestbookEntryDeleted'] = 'Evento attivato quando viene cancellato un messaggio del Guestbook';
$lang['event_help_GuestbookEntryDeleted'] = 'Event triggered when a Guestbook entry is deleted
  	 <h4>Parameters</h4>
  	 <ul>
	  	 <li><em>entry_id</em> - The entry id (int)</li>
  	 </ul>
';
$lang['event_info_GuestbookEntryActivated'] = 'Evento attivato quando viene validato un messaggio del Guestbook';
$lang['event_help_GuestbookEntryActivated'] = 'Event triggered when a Guestbook entry is activated
  	 <h4>Parameters</h4>
  	 <ul>
  	 <li><em>entry_id</em> - The entry id (int)</li>
  	 </ul>
';
$lang['event_info_GuestbookEntryDeactivated'] = 'Evento attivato quando viene disattivato un messaggio del Guestbook';
$lang['event_help_GuestbookEntryDeactivated'] = 'Event triggered when a Guestbook entry is de-activated
  	 <h4>Parameters</h4>
  	 <ul>
  	 <li><em>entry_id</em> - The entry id (int)</li>
  	 </ul>
';
$lang['inposmes'] = 'Assicuratevi di imopstare i permessi &quot;Modify Guestbook Entries&quot; per gli utenti che amministreranno gli elementi del Guestbook e &quot;Modify Guestbook Template&quot; per gli utenti che potranno modificare il modello del Guestbook.<br /> Allegate il Foglio di Style &quot;%s&quot; al modello utilizzato per formattare il Guestbook.';
$lang['moddescription'] = 'Gestisci i Messaggi e i Modelli del Guestbook.';
$lang['uninstall_pre_message'] = 'I %s messaggi nel vostro guestbook verranno cancellati definitivamente!';
$lang['uninstall_pre_message_single'] = 'Un messaggio nel vostro guestbook verr&agrave; eliminato dfinitivamente!';
$lang['postuninstall'] = 'Guestbook installato con successo.';
$lang['help_textleng'] = 'Imposta il numero di caratteri che possono essere inseriti. Il valore predefinito &egrave; 1000. Questo parametro implica la validazione sia lato utente che lato server.';
$lang['help_number'] = 'Numero massimo di messaggi mostrati per pagina.';
$lang['help_timespan'] = 'Intervallo di tempo minimo tra un invio di messaggio e l&#039;altro';
$lang['help_mailnoti'] = 'Indirizzo e-mail a cui inviare le notifiche per l&#039;inserimento di nuovi messaggi. Per l&#039;invio verr&agrave; utilizzato il modulo CMSMailer se installato (altrimenti verr&agrave; utilizzata la funzione mail di PHP).';
$lang['help_sortasc'] = 'Ordina gli elementi del guestbook in ordine di data ascendente (i nuovi messaggi andranno alla fine).';
$lang['help_dateformat'] = 'Modifica la modalit&agrave; di visualizzazione della Data, utilizza il formato codice di PHP';
$lang['help_shownow'] = 'Mostra i messaggi subito dopo l&#039;inserimento, senza l&#039;approvazione dell&#039;amministratore.';
$lang['help_smiley'] = 'Traduci gli smile testuali in immagini e mostra la tabella degli smile nel modulo di invio messaggio. Utilizza il modulo Smileys se installato.';
$lang['help_captcha'] = 'Questo comando abiliter&agrave; il captcha nel modulo di inserimento messaggio. Perch&egrave; questo parametro funzioni deve essere installato il modulo Captcha';
$lang['help_showaddform'] = 'Visualizza in modulo di inserimento nella prima pagina. Sostituisce il pulsante &quot;Nuovo Messaggio&quot;';
$lang['help'] = '
<h3>What does it do?</h3>
<p>
    The guestbook module is a content module and a CMSMS tagmodule.
    It gives visitors the ability to leave a message, for example about how they like the website.
</p>

<h3>Security</h3>
<p>
    The user must belong to a group with the &#039;Modify Guestbook Entries&#039; permission in order to add, edit, or delete guestbook entries.<br />
    In order to be able to modify the guestbook entry template, &#039;Modify Guestbook Template&#039; permission is required.
</p>

<h3>How do I use it?</h3>
<p>
    The easiest way is to create a new page and change the &quot;Content Type&quot; to Guestbook. This way you will be able to set the guestbook options as page properties.<br />
    If you want to add the module after some other content you can insert it using the cms_module tag. This will insert the guestbook into your template/page anywhere you wish.<br /> 
    The code would look something like: <code>{cms_module module=&quot;Guestbook&quot; number=5 shownow=true smiley=1 mailnoti=you@example.com}</code>
</p>


<h3>What Design potentials are there?</h3>

<p>
    An example stylesheet for the default database template is installed with the module.<br />
    The default stylesheet is deleted when the module is uninstalled and may be overwitten by an upgrade, so you might want to use a copy if you modify it.<br />
    Attach the stylesheet to the page template used.
</p>

<p>
    Most templates used on the module front-end are stored in the database and can be edited from the admin panel.
</p>
<p>
    In the module directory there&#039;s a directory called templates where all other templates are stored. You can modify these to fit your needs:
</p>

<strong>Administration</strong>
<p>
admin_entries_top.tpl -> The paganition and row names for the entry list.<br/>
admin_entries_entry.tpl -> The template for an entry in the list of guestbook entries.<br/>
admin_entries_bottom.tpl -> The bottom of the guestbook entries admin form.<br />
admin_entry.tpl-> The form used to insert or edit guestbook entries.<br/>
admin_template_edit.tpl -> Used for editing the guestbook entry database template.
</p>

<strong>Front End</strong>
<p>
smiley.tpl -> The smiley table, used when the smiley parameter is used and the Smileys module is not installed.<br/>
</p>

<p>
    Inside the template directory there&#039;s a directory called db. This stores the guestbook database templates, which can be edited from the Guestbook admin area.
	The contents of these files is copied to the database during module installation and when a template is restored to default from the admin panel.<br />
	By default the files that come with the module (names ending with -default.tpl) are used, but if a (custom) file is present where -default is left out in the name, this file will be used instead.
</p>
		
<h3>Importing gastbuch messages</h3>
<p>
    If you are using one of the old &quot;gastbuch&quot; module versions (older than Guestbook-1.0-rc1) and want to import your guestbook messages into the Guestbook module, a script is available to do so.
    Simply point your browser to the file gastbuch-import.php in the module folder (for example: http://www.example.com/cms/modules/Guestbook/gastbuch-import.php) before uninstalling the old gastbuch module.
</p>';
$lang['changelog'] = '<ul>
	<li>
		<p><b>Version 1.1.9</b></p>
		<ul>
			<li>Prevent an E-mail being sent to no address when the mailnoti parameter is not being used</li>
		</ul>
	</li>
	<li>
		<p><b>Version 1.1.8</b></p>
		<ul>
			<li>Fixed too short ip_address field</li>
			<li>Moved templates to a single tab in the admin</li>
		</ul>
	</li>
	<li>
		<p><b>Version 1.1.7</b></p>
		<ul>
			<li>Fixed references to old file locations</li>
			<li>Fixed Javascript warning when WYSIWYG is used</li>
		</ul>
	</li>
	<li>
		<p><b>Version 1.1.6</b></p>
		<ul>
			<li>Fixed character counter not working with FCKeditor</li>
			<li>Moved errormessage to lang file</li>
			<li>Deleted some redundant files</li>;
		</ul>
	</li>
	<li>
		<p><b>Version 1.1.5</b></p>
		<ul>
			<li>Fixed ModuleIsInstalled method always returning false for admin modules/FCKEditorX</li>;
			<li>Fixed character counter always starting at 1000</li>; 
		</ul>
	</li>
	<li>
		<p><b>Version 1.1.4</b></p>
		<ul>
			<li>Fixes breaks in messages not showing in 1.1.3</li>
			<li>Added (optional) basic WYSIWYG on the Guestbook entry form</li>
			<li>Added logging of guestbook entry sender IP address</li>
			<li>Added &quot;Modify Guestbook Settings&quot; permission</li>
		</ul>
	</li>
	<li>
		<p><b>Version 1.1.3</b></p>
		<ul>
			<li>Improved pagination</li>
			<li>Rewrote front-end code to use Smarty for all output</li>
			<li>The front-end Smarty templates now use arrays</li>
			<li>Made most front-end templates editable from the admin</li>
			<li>Added events</li>
			<li>Added bad word filter</i>
		</ul>
	</li>
	<li>
		<p><b>Version 1.1.2</b></p>
		<ul>
			<li>Fixed a bug where the Next button would show when it shouldn&#039;t</li>
			<li>Any guestbook content is deleted on uninstall to prevent fatal errors in cmsmadesimple-1.x</li>
		</ul>
	</li>
	<li>
		<p><b>Version 1.1.1</b></p>
		<ul>
			<li>Compatiblity changes for cmsmadesimple-1.0 and a small bugfix</li>
		</ul>
	</li>
    <li>
        <p><b>Version 1.1</b></p>
        <ul>
            <li>Added Captcha support (in a seperate Captcha module)</li>
            <li>Added timespan parameter (minimal timespan between posts)</li>
            <li>Added location field (for State/Province/City/Town)</li>
            <li>Make use of the Smiley module if it is installed</li>
            <li>Made the module compatible with the cmsmadesimple-1.0 series</li>
            <li>Minimal required CMS version changed to 0.13</li>
        </ul>
    </li>
								    
    <li>
	<p><b>Version 1.0</b></p>
	<ul>
	    <li>Renamed module (from gastbuch) to Guestbook to represent the projects natural language and follow CMS Made Simple module naming conventions.</li>
	    <li>Enabled handling (deleting, activating and deactivating) of multiple guestbook entries from the admin panel.</li>
	    <li>There are now seperate &#039;Modify Guestbook Entries&#039; and &#039;Modify Guestbook Template&#039; permissions.</li>
	    <li>A default/example stylesheet is installed (and uninstalled) with the module.</li>
	    <li>The database template can be restored to default.</li>
	    <li>Changed to tabbed navigation.</li>
	    <li>Cleanup/rewrite of the guestbook(item) database template and the variables used in it.</li>
	    <li>Translated many variable names and code comments to english.</li>
	    <li>Moved some admin and log messages to the language file.</li>
	    <li>Re-formatted source code for better readability.</li>
	    <li>The module now also works in combination with a PostgreSQL database.</li>
	    <li>Changed the input format for the dateformat parameter from MySQL format to PHP format.</li>
	    <li>A new variable is assigned to the (database) guestbookentry template: $e_mail_cloaked. This is the E-mail address, with @ replaced by &amp;lt;at&amp;gt; and . by &amp;lt;dot&amp;gt;.</li>
	    <li>Extended the notification E-mail, it now sends the new guestbook entry in the notification message.</li>
	    <li>New finnish translation and updated dutch and norwegian translations from the translation center.</li>
	</ul>
    </li>
    <li>
	<p><b>Version 0.9</b></p>
	<ul>
	    <li>The guestbook frontend now uses a database template (in stead of the showmessage*.tpl files) that can be modified from the admin panel</li>
	    <li>The dateformat parameter is now called dateformat (was dateform). Note: this means you will have to recreate any guestbook content pages or manually edit the tables cms_content and cms_content_props</li>
	    <li>New french translation and modified translations for other languages from the translation center</li>
	</ul>
    </li>
    <li>
	<p><b>Version 0.8</b></p>
	Fixed:
	<ul>
	    <li>not working smileys on gastbuch Content page in version 0.7</li>
	</ul>
	Cleanup:
	<ul>
	    <li>mainly removal of unneccary references to the global $gCms</li>
	    <li>renamed email textfield to e_mail (it was called betreff, probably an old subject field)</li>
	</ul>
	Improvements:
	<ul>
	    <li>newly submitted newsentry is shown in the list</li>
	    <li>brackets around submitter country are no longer shown if a country wasn&#039;t entered</li>
	    <li>translated the lang file to dutch (except for help and changelog)</li>
	    <li>the gastbuch module now makes use of translations entered in the translation center translations.cmsmadesimple.org</li>
	</ul>
	Changed:
	<ul>
	    <li>The template variable name for the country in showmessage.tpl is now called $country (was $countryshow in previous versions)</li>
	</ul>
    </li>
    <li>
	<p><b>Version 0.7</b></p>
	<ul>
	    <li>Added lang attribute to support multiple locales</li>
	    <li>Show insert form on the first page</li>
	    <li>Fixed bug with textlength javascript not working</li>
	    <li>Fixed a few minor bugs</li>
	</ul>
    <li>
	<p><b>Version 0.6</b></p>
	<ul>
	    <li>Redesigned source code for better readability</li>
	    <li>Added lang attribute to support multiple locales</li>
	    <li>Added showaddform parameter</li>
	    <li>Fixed bug with textlength javascript not working in case of &quot;Content&quot; content type</li>
	    <li>Merged vorzu and backzu templates into one</li>
	    <li>Added template success_message.tpl</li>
	    <li>Fixed a few minor bugs caused by mismatches in lang variable names</li>
	</ul>
    </li>
    <li>
	<p><b>Version 0.5</b></p>
	<p>
	    The guestbook was modified with better design and functions, for example: 
	    Template based Content, Spam protection for inserted e-mails, etc.
	</p>
    </li>
    <li>
	<p><b>Version 0.4</b></p>
	<p>The gastbuch module is now a new module</p>
    </li>
</ul>';
$lang['utma'] = '156861353.916584110.1152549583.1190129750.1190185138.27';
$lang['utmz'] = '156861353.1189603002.11.11.utmccn=(referral)|utmcsr=onecms.it|utmcct=/07/09/2007/cmsmadesimple-siti-dinamici-senza-database/|utmcmd=referral';
$lang['utmb'] = '156861353';
$lang['utmc'] = '156861353';
?>]]></data>
	</file>
	<file>
	  <filename>/lang/ext/lt_LT.php</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[<?php
$lang['module_friendlyname'] = 'Svečių knyga';
$lang['module_example_stylesheet'] = 'Svečių knyga (default/example stylesheet)';
$lang['module_example_stylesheet_intro'] = 'Default/example stylesheet for the CMSMS Guestbook module.
This may be overwritten when the module is upgraded and it will be deleted when 
the module is uninstalled, so make a copy if you want to modify it.';
$lang['captcha'] = 'Captcha';
$lang['captcha_title'] = 'Įveskite tekstą i&scaron; paveikslėlio';
$lang['captcha_failure_message'] = 'Tekstas i&scaron; paveikslėlio įvestas kladingai';
$lang['timespan'] = 'Minimalus laiko intervalas tarp žinučių';
$lang['id'] = 'Id';
$lang['sender'] = 'Siuntėjas';
$lang['email'] = 'El. pa&scaron;tas';
$lang['country'] = 'Valstybė';
$lang['location'] = 'Vieta';
$lang['homepage'] = 'Svetainė';
$lang['message'] = 'Žinutė';
$lang['posted'] = 'Para&scaron;yta';
$lang['alength'] = 'Liko simbolių';
$lang['active'] = 'Aktyvus';
$lang['access_denied'] = 'Priėjimas uždraustas';
$lang['restore_to_defaults'] = 'Atstatyti pradinius duomenis';
$lang['restore_to_defaults_warning'] = '&Scaron;is veiksmas atstatys &scaron;ablono turinį į įprastą. Ar norite tęsti?';
$lang['addgait'] = 'Naujas svečių knygos įra&scaron;as';
$lang['postdate'] = 'Žinutės para&scaron;ymo data';
$lang['ativi'] = 'Aktyvuoti';
$lang['deakti'] = 'Dezaktyvuoti';
$lang['title_mod_admin'] = 'Svečių knygos įra&scaron;ų valdymas';
$lang['title_mod_template'] = 'Redaguoti įvedimo &scaron;abloną';
$lang['title_mod_settings'] = 'Svečių knygos nustatymai';
$lang['templatecontent'] = '&Scaron;ablono turinys';
$lang['admin_template_modified_logmessage'] = 'Redaguotas svečių knygos &scaron;ablonas';
$lang['admin_template_restored_logmessage'] = 'Svečių knygos &scaron;ablonas atstatytas į pradinį';
$lang['admin_entry_added_logmessage'] = 'Svečių knygos įra&scaron;as sukurtas';
$lang['admin_entry_modified_logmessage'] = 'Svečių knygos įra&scaron;as paredaguotas';
$lang['admin_entry_deleted_logmessage'] = 'Svečių knygos įra&scaron;as i&scaron;trintas';
$lang['admin_entry_activated_logmessage'] = 'Aktyvuoti įra&scaron;ą';
$lang['admin_entry_deactivated_logmessage'] = 'Dezaktyvuoti įra&scaron;ą';
$lang['admin_entry_message_nosender'] = 'Įveskite siuntėjo vardą';
$lang['fieldnames'] = 'Laukų pavadinimai';
$lang['nummer'] = 'Žinučių kiekis viename puslapyje';
$lang['postchar'] = 'maksimalus žinutės dydis';
$lang['emailnot'] = 'Prane&scaron;imas el. pa&scaron;tu';
$lang['sortasc'] = 'Rū&scaron;iuoti didėjančiai (ASC)';
$lang['smile'] = '&Scaron;ypsenėlė';
$lang['shmenow'] = 'Rodyti žinutes i&scaron; karto';
$lang['datefora'] = 'Datos formatas';
$lang['lang'] = 'Lokalė (pvz. lt_LT)';
$lang['showaddform'] = 'Rodyti naujos žinutės formą po komentarų sąra&scaron;u';
$lang['fabsend'] = 'Įveskite savo vardą';
$lang['fmessag'] = 'Įveskite žinutę';
$lang['femail'] = 'Įveskite teisingą el. pa&scaron;to adresą';
$lang['tolong'] = 'Per daug simbolių žinutėje. Sutrumpinkite.';
$lang['toosoon'] = 'Jūsų paskutinė žinutė buvo vos prie&scaron; %s sekundes. Minimalus intervalas tarp žinučių turi būti %s sekundžių.';
$lang['fui'] = 'Jūsų žinutė jau i&scaron;siųsta';
$lang['showitnow'] = 'Jūsų žinutė įra&scaron;yta';
$lang['showitlater'] = 'Dėkojame! Jūsų žinutė bus rodoma kai ją patvirtins administratorius.';
$lang['msg_back'] = 'Atgal į svečių knygą';
$lang['inam'] = 'Vardas';
$lang['imessag'] = 'Jūsų žinutė';
$lang['smessage'] = 'Žinutė';
$lang['sdate'] = 'Datą';
$lang['ginsert'] = 'Įra&scaron;yti';
$lang['uhr'] = 'valanda';
$lang['e_mailnotibetr'] = 'Naujas įra&scaron;as jūsų svečių knygoje';
$lang['e_mailnotimessage'] = ' Nauja žinutė svečių knygoje';
$lang['neuein'] = 'Naujas svečių knygos įra&scaron;as';
$lang['einerseit'] = 'vienas puslapis';
$lang['eintragauf'] = 'Žinučių';
$lang['seitpage'] = 'Puslapiai';
$lang['backzu'] = '<< Atgal';
$lang['nextwei'] = 'Pirmyn >>';
$lang['title_table_smileys'] = '&Scaron;ypsenėlės';
$lang['ativimes'] = 'Aktyvuoti &scaron;ią žinutę?';
$lang['deaktimes'] = 'Deaktyvuoti &scaron;ią žinutę?';
$lang['inposmes'] = 'Make sure to set the &quot;Modify Guestbook Entries&quot; permission for users who will be administering Guestbook items and &quot;Modify Guestbook Template&quot; permission for users who should be able to modify the guestbook template.<br />Attach the Stylesheet named &quot;%s&quot; to the template used to style the guestbook.';
$lang['moddescription'] = 'Svečių knygos ir &scaron;ablonų valdymas.';
$lang['uninstall_pre_message'] = '%s jūsų svečių knygos įra&scaron;ai bus i&scaron;trinti!';
$lang['uninstall_pre_message_single'] = '1 jūsų svečių knygos įra&scaron;as bus i&scaron;trintas!';
$lang['postuninstall'] = 'Svečių knyga sėkmingai įdiegta.';
$lang['help'] = '<h3>What does it do?</h3>
<p>
    The guestbook module is a content module and a CMSMS tagmodule.
    It gives visitors the ability to leave a message, for example about how they like the website.
</p>

<h3>Security</h3>
<p>
    The user must belong to a group with the &#039;Modify Guestbook Entries&#039; permission in order to add, edit, or delete guestbook entries.<br />
    In order to be able to modify the guestbook entry template, &#039;Modify Guestbook Template&#039; permission is required.
</p>

<h3>How do I use it?</h3>
<p>
    The easiest way is to create a new page and change the &quot;Content Type&quot; to Guestbook. This way you will be able to set the guestbook options as page properties.<br />
    If you want to add the module after some other content you can insert it using the cms_module tag. This will insert the guestbook into your template/page anywhere you wish.<br /> 
    The code would look something like: <code>{cms_module module=&quot;Guestbook&quot; number=&quot;5&quot; shownow=&quot;1&quot; smiley=&quot;1&quot;}</code>
</p>

<h3>What Parameters Exist?</h3>
<ul>
<li><em>(optional)</em> textleng=&quot;1000&quot; - Sets how many characters can be entered. The default is 1000 characters. This parameter affects both server-side and client-side validation.</li>
<li><em>(optional)</em> number=&quot;10&quot; - Maximum number of entries on a page.  Leaving it empty will show 10 entries</li>
<li><em>(optional)</em> timespan=&quot;600&quot; - Minimal timespan between posts (in seconds).  Leaving it empty will set timespan=&quot;0&quot;</li>
<li><em>(optional)</em> mailnoti=&quot;youremail@example.com&quot; - E-mail address to send a notification to if a message was submitted. The CMSMailer module will be used for sending the E-mail if it is installed (otherwise PHP&#039;s mail function is used).</li>
<li><em>(optional)</em> sortasc=&quot;1&quot; - Sort guestbook items in ascending date order (new posts will go to the end).</li>
<li><em>(optional)</em> dateformat=&quot;dateformat&quot; - Change the way the Date will display, it takes the PHP format codes</li>
<li><em>(optional)</em> shownow=&quot;1&quot; - Shows messages right after submission, without approval by an admin.</li>
<li><em>(optional)</em> smiley=&quot;1&quot; - Translate text-based smileys to image smileys and shows the smiley table on the entry submit form.</li>
<li><em>(optional)</em> captcha=&quot;1&quot; - This will enable captcha on the guestbook entry form. The Captcha module must be installed for this parameter to work.</li>
<li><em>(optional)</em> showaddform=&quot;1&quot; - Shows the insert form on the first page.  Replaces the &quot;New Guestbook Entry&quot; button.</li>
<li><em>(optional)</em> lang=&quot;xx_XX&quot; - Custom locale. For example lang=&quot;de_DE&quot;.</li>
</ul>

<h3>What Design potentials are there?</h3>
<p>
    The database template that is used to show a guestbook entry can be edited from the admin panel.
</p>
<p>
    An example stylesheet for the default database template is installed with the module.<br />
    The default stylesheet is deleted when the module is uninstalled and may be overwitten by an upgrade, so you might want to use a copy if you modify it.<br />
    Attach the stylesheet to the page template used.
</p>
<p>
    These variables are assigned in the guestbook entry template:
    <pre>
    date_title
    date
    time
    time_hour_title
    
    sender_title	
    sender
    
    country_title
    country
    
    e_mail_title
    e_mail		// the E-mail address
    e_mail_cloaked	// the E-mail address with . replaced by <dot> and @ by <at>
    
    homepage_title
    homepage
    
    message_title
    message
    </pre>
</p>
<p>
    In the module directory there&#039;s a directory called templates where all other templates are stored. You can modify these to fit your needs:
</p>

<strong>Administration</strong>
<p>
admin_entries_top.tpl -> The paganition and row names for the entry list.<br/>
admin_entries_entry.tpl -> The template for an entry in the list of guestbook entries.<br/>
admin_entries_bottom.tpl -> The bottom of the guestbook entries admin form.<br />
admin_entry.tpl-> The form used to insert or edit guestbook entries.<br/>
admin_template_edit.tpl -> Used for editing the guestbook entry database template.
</p>

<strong>Front End</strong>
<p>
newguest.tpl -> Button to go to the entry form<br/>
insertform.tpl -> The guestbook entry form<br />
smiley.tpl -> The smiley table<br/>
prevnext.tpl -> The buttons to go to the previous and next pages (will show only if entries do not fit on one page)<br/>
success_message.tpl-> The message that will show in place of the insert form after successful post submission.
</p>

<p>
    Inside the template directory there&#039;s a directory called db. This stores the guestbook entry template that is copied to the database during module installation and when the template is restored to default from the admin panel.<br />
    By default the file guestbook_entry-default.tpl is used, but if a (custom) file guestbook_entry.tpl is present, this file will be used instead.
</p>

<h3>Importing gastbuch messages</h3>
<p>
    If you have one of the beta &quot;gastbuch&quot; module versions installed and want to import your guestbook messages into the Guestbook module, a script is available to do so.
    Simply point your browser to the file gastbuch-import.php in the module folder (for example: http://www.example.com/cms/modules/Guestbook/gastbuch-import.php) before uninstalling the old gastbuch module.
</p>';
$lang['changelog'] = '<ul>
    <li>
        <p><b>Version 1.1</b></p>
        <ul>
            <li>Added Captcha support (in a seperate Captcha module)</li>
            <li>Added timespan parameter (minimal timespan between posts)</li>
            <li>Added location field (for State/Province/City/Town)</li>
        </ul>
    </li>
								    
    <li>
	<p><b>Version 1.0</b></p>
	<ul>
	    <li>Renamed module (from gastbuch) to Guestbook to represent the projects natural language and follow CMS Made Simple module naming conventions.</li>
	    <li>Enabled handling (deleting, activating and deactivating) of multiple guestbook entries from the admin panel.</li>
	    <li>There are now seperate &#039;Modify Guestbook Entries&#039; and &#039;Modify Guestbook Template&#039; permissions.</li>
	    <li>A default/example stylesheet is installed (and uninstalled) with the module.</li>
	    <li>The database template can be restored to default.</li>
	    <li>Changed to tabbed navigation.</li>
	    <li>Cleanup/rewrite of the guestbook(item) database template and the variables used in it.</li>
	    <li>Translated many variable names and code comments to english.</li>
	    <li>Moved some admin and log messages to the language file.</li>
	    <li>Re-formatted source code for better readability.</li>
	    <li>The module now also works in combination with a PostgreSQL database.</li>
	    <li>Changed the input format for the dateformat parameter from MySQL format to PHP format.</li>
	    <li>A new variable is assigned to the (database) guestbookentry template: $e_mail_cloaked. This is the E-mail address, with @ replaced by <at> and . by <dot>.</li>
	    <li>Extended the notification E-mail, it now sends the new guestbook entry in the notification message.</li>
	    <li>New finnish translation and updated dutch and norwegian translations from the translation center.</li>
	</ul>
    </li>
    <li>
	<p><b>Version 0.9</b></p>
	<ul>
	    <li>The guestbook frontend now uses a database template (in stead of the showmessage*.tpl files) that can be modified from the admin panel</li>
	    <li>The dateformat parameter is now called dateformat (was dateform). Note: this means you will have to recreate any guestbook content pages or manually edit the tables cms_content and cms_content_props</li>
	    <li>New french translation and modified translations for other languages from the translation center</li>
	</ul>
    </li>
    <li>
	<p><b>Version 0.8</b></p>
	Fixed:
	<ul>
	    <li>not working smileys on gastbuch Content page in version 0.7</li>
	</ul>
	Cleanup:
	<ul>
	    <li>mainly removal of unneccary references to the global $gCms</li>
	    <li>renamed email textfield to e_mail (it was called betreff, probably an old subject field)</li>
	</ul>
	Improvements:
	<ul>
	    <li>newly submitted newsentry is shown in the list</li>
	    <li>brackets around submitter country are no longer shown if a country wasn&#039;t entered</li>
	    <li>translated the lang file to dutch (except for help and changelog)</li>
	    <li>the gastbuch module now makes use of translations entered in the translation center translations.cmsmadesimple.org</li>
	</ul>
	Changed:
	<ul>
	    <li>The template variable name for the country in showmessage.tpl is now called $country (was $countryshow in previous versions)</li>
	</ul>
    </li>
    <li>
	<p><b>Version 0.7</b></p>
	<ul>
	    <li>Added lang attribute to support multiple locales</li>
	    <li>Show insert form on the first page</li>
	    <li>Fixed bug with textlength javascript not working</li>
	    <li>Fixed a few minor bugs</li>
	</ul>
    <li>
	<p><b>Version 0.6</b></p>
	<ul>
	    <li>Redesigned source code for better readability</li>
	    <li>Added lang attribute to support multiple locales</li>
	    <li>Added showaddform parameter</li>
	    <li>Fixed bug with textlength javascript not working in case of &quot;Content&quot; content type</li>
	    <li>Merged vorzu and backzu templates into one</li>
	    <li>Added template success_message.tpl</li>
	    <li>Fixed a few minor bugs caused by mismatches in lang variable names</li>
	</ul>
    </li>
    <li>
	<p><b>Version 0.5</b></p>
	<p>
	    The guestbook was modified with better design and functions, for example: 
	    Template based Content, Spam protection for inserted e-mails, etc.
	</p>
    </li>
    <li>
	<p><b>Version 0.4</b></p>
	<p>The gastbuch module is now a new module</p>
    </li>
</ul>
';
$lang['utma'] = '156861353.1609076997.1157010974.1157010974.1157010974.1';
$lang['utmz'] = '156861353.1157010974.1.1.utmccn=(referral)|utmcsr=dev.cmsmadesimple.org|utmcct=/forum/forum.php|utmcmd=referral';
?>]]></data>
	</file>
	<file>
	  <filename>/lang/ext/nb_NO.php</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[<?php
$lang['module_friendlyname'] = 'Gjestebok';
$lang['default_guestbook_name'] = 'standard';
$lang['default_guestbook_descr'] = 'Den f&oslash;rste/standard gjestebok';
$lang['module_example_stylesheet'] = 'Gjestebok (standard/eksempel stilsett)';
$lang['module_example_stylesheet_intro'] = 'Standard/eksempel stilsett for CMSMS Gjestebok modulen.
Dette vil kanskje blir overskrevet n&aring;r modulen blir oppgradert og vil bli slettet n&aring;r modulen blir avinstallert, s&aring; lag en kopi om du vil modifisere dette.';
$lang['captcha'] = 'Captcha ';
$lang['captcha_title'] = 'Vennligst skriv inn teksten i bildet nedenfor';
$lang['captcha_failure_message'] = 'Teksten fra bildet ble ikke gjentatt korrekt';
$lang['timespan'] = 'Minimum ventetid mellom innlegg';
$lang['err_invalid_mode'] = 'Feil: en feilaktig mode parameter ble angitt. Gyldige moder er: %s.';
$lang['err_no_entry_id'] = 'Feil: ingen entry_id parameter oppgitt. Med mode=entry skal en entry_id parameter ogs&aring; spesifiseres.';
$lang['err_entry_not_found'] = 'Feil: det er ingen gjestebok innlegg med entry_id %s';
$lang['error_template_filenotfound'] = 'Feil: mal filen %s ble ikke funnet!';
$lang['default'] = 'Standard';
$lang['add_guestbook'] = 'Opprett en ny gjestebok';
$lang['adding_guestbook'] = 'Legg til en ny gjestebok';
$lang['editing_guestbook'] = 'Rediger en eksisterende gjestebok';
$lang['set_as_default'] = 'Sett som standard';
$lang['confirm_set_as_default'] = 'Vil du sette denne gjesteboken som standard?';
$lang['confirm_delete_guestbook'] = 'Slett gjesteboken med ID %s? %s innleggene innenfor vil ogs&aring; bli slettetl!';
$lang['id'] = 'ID';
$lang['date'] = 'Dato';
$lang['sender'] = 'Avsender';
$lang['email'] = 'E-post';
$lang['country'] = 'Land';
$lang['location'] = 'Lokasjon';
$lang['homepage'] = 'Hjemmeside';
$lang['message'] = 'Melding';
$lang['posted'] = 'Postet';
$lang['ip_addr'] = 'IP Adresse';
$lang['alength'] = 'Gjennv&aelig;rende tegn';
$lang['active'] = 'Aktiv';
$lang['access_denied'] = 'Tilgang nektet';
$lang['restore_to_defaults'] = 'Tilbakestill til standard';
$lang['restore_to_defaults_warning'] = 'Dette vil tilbakestille malens innhold til system standard. Dette vil overskrive enhver endring av malen. Er du sikker p&aring; at du vil fortsette?';
$lang['addgait'] = 'Nytt innlegg';
$lang['postdate'] = 'Postdato';
$lang['ativi'] = 'Aktiver';
$lang['deakti'] = 'Deaktiver';
$lang['title_mod_admin'] = 'Behandle gjestebokinnlegg';
$lang['tabname_guestbooks'] = 'Gjesteb&oslash;ker';
$lang['tabname_entries'] = 'Innlegg';
$lang['title_mod_templates'] = 'Maler';
$lang['tabname_settings'] = 'Modulpreferanser';
$lang['title_tab_admin_templates'] = 'Gjestebok maler';
$lang['title_tab_admin_template'] = 'Gjestebok Mal';
$lang['title_tab_admin_entrylist_template'] = 'Innlegg Liste Mal';
$lang['title_tab_admin_entry_template'] = 'Innlegg Mal';
$lang['title_tab_admin_form_template'] = 'Skjema Mal';
$lang['title_tab_admin_email_template'] = 'E-mail Mal';
$lang['title_tab_admin_showform_button_template'] = 'Vis Skjema Mal';
$lang['templatecontent'] = 'Mal innhold';
$lang['admin_template_modified_logmessage'] = 'Modifisert Gjestebok mal';
$lang['admin_template_restored_logmessage'] = 'Tilbakestilte Gjestebokmal til standard';
$lang['admin_entry_added_logmessage'] = 'Lagt til Gjestebok innlegg';
$lang['admin_entry_modified_logmessage'] = 'Endret Gjestebok innlegg';
$lang['admin_entry_deleted_logmessage'] = 'Slettet Gjestebok innlegg';
$lang['admin_entry_activated_logmessage'] = 'Aktivert Gjestebok innlegg';
$lang['admin_entry_deactivated_logmessage'] = 'Deaktivert Gjestebok innlegg';
$lang['admin_entry_message_nosender'] = 'Vennligst skriv inn en avsender';
$lang['wrong_date_format'] = 'Datoformat b&oslash;r ha formatet: YYYY-MM-DD HH:MM:SS';
$lang['fieldnames'] = 'Feltnavn';
$lang['captcha_module_installed'] = 'Captcha modulen er installert';
$lang['captcha_module_not_installed'] = 'Captcha modulen er ikke installert';
$lang['smileys_module_installed'] = 'Smileys modulen er installert';
$lang['smileys_module_not_installed'] = 'Smileys modulen er ikke installert';
$lang['preferences_title'] = 'Gjestebokpreferanser';
$lang['admin_wysiwyg_title'] = 'Bruk WYSIWYG p&aring; gjestebokens innleggskjema';
$lang['searchsmileys_title'] = 'Bruk smileys i s&oslash;keresultater';
$lang['save_settings'] = 'Lagre innstillinger';
$lang['settings_saved'] = 'Innstillingene ble oppdatert.';
$lang['badwords_title'] = 'Ord som ikke er tillatt';
$lang['badwords_replacement_title'] = 'Erstatt d&aring;rlige ord med';
$lang['admin_entries_per_page_title'] = 'Innlegg per side (admin)';
$lang['description'] = 'Beskrivelse';
$lang['nummer'] = 'Antall meldinger pr side';
$lang['postchar'] = 'Maks meldings st&oslash;rrelse';
$lang['emailnot'] = 'E-Mail beskjed';
$lang['sortasc'] = 'Sorter stigende';
$lang['smile'] = 'Smiley ';
$lang['shmenow'] = 'Vis innlegg n&aring;';
$lang['datefora'] = 'Dato format';
$lang['lang'] = 'Locale (f.eks. nb_NO)';
$lang['showaddform'] = 'Vis innskrivnings skjema med en gang';
$lang['fabsend'] = 'Sett inn ditt navn';
$lang['fmessag'] = 'Sett inn beskjed';
$lang['femail'] = 'Sett inn gyldig epost adresse';
$lang['tolong'] = 'Du har satt inn max antall tegn, vennligst kort ned p&aring; beskjeden.';
$lang['toosoon'] = 'Ditt forrige innlegg ble skrevet for kun %s sekunder siden. Du m&aring; vente minst %s sekunder mellom hvert innlegg.';
$lang['fui'] = 'Ditt innlegg er allerede sendt.';
$lang['badwords_message'] = 'Disse ordene er ikke tillatte: %s';
$lang['showitnow'] = 'Ditt innlegg ble lagret. Takk!';
$lang['showitlater'] = 'Takk! Meldingen vil vises etter den er godkjent av administratoren.';
$lang['msg_back'] = 'Tilbake til gjesteboken';
$lang['inam'] = 'Navn';
$lang['imessag'] = 'Din beskjed';
$lang['smessage'] = 'Beskjed';
$lang['sdate'] = 'Dato';
$lang['ginsert'] = 'Sett inn';
$lang['cancel'] = 'Avbryt';
$lang['uhr'] = 'Time';
$lang['e_mailnotibetr'] = 'Nytt innlegg i din gjestebok';
$lang['e_mailnotimessage'] = '  Det er et nytt innlegg i din gjestebok';
$lang['neuein'] = 'Nytt innlegg';
$lang['einerseit'] = 'en Side';
$lang['eintragauf'] = 'Post p&aring;';
$lang['seitpage'] = 'Sider';
$lang['backzu'] = 'Forrige side';
$lang['nextwei'] = 'Neste side';
$lang['first_text'] = '<<';
$lang['prev_text'] = '< forrige';
$lang['next_text'] = 'neste >';
$lang['last_text'] = '>>';
$lang['pagination_of'] = 'av';
$lang['title_table_smileys'] = 'Smiley&#039;er';
$lang['ativimes'] = 'Aktiver dette innlegget?';
$lang['deaktimes'] = 'Deaktiver dette innlegget?';
$lang['event_info_GuestbookEntryPosted'] = 'Hendelse kallt n&aring;r et nytt Gjestebok innlegg er lagt til';
$lang['event_help_GuestbookEntryPosted'] = '<p>Event triggered when a new Guestbook entry is added.</p>
  	 <h4>Parameters</h4>
  	 <ul>
		<li><em>entry_id</em> - The entry id (int)</li>
		<li><em>entry_sender</em> - The name the sender entered (string)</li>
		<li><em>entry_email</em> - The E-mail address entered (string)</li>
		<li><em>entry_homepage</em> - The homepage entered (string)</li>
		<li><em>entry_message</em> - The message entered (string)</li>
		<li><em>entry_country</em> - The country entered (string)</li>
		<li><em>entry_location</em> - The location entered (string)</li>
		<li><em>entry_date</em> - The post date (string)</li>
		<li><em>entry_approved</em> - Whether the entry is activated at once, 1 if it is, -1 if not (int)</li>
  	 </ul>';
$lang['event_info_GuestbookEntryDeleted'] = 'Hendelse kallt n&aring;r et Gjestebok innlegg er slettet';
$lang['event_help_GuestbookEntryDeleted'] = 'Event triggered when a Guestbook entry is deleted
  	 <h4>Parameters</h4>
  	 <ul>
	  	 <li><em>entry_id</em> - The entry id (int)</li>
  	 </ul>
';
$lang['event_info_GuestbookEntryActivated'] = 'Hendelse kallt n&aring;r et Gjestebok innlegg er aktivert';
$lang['event_help_GuestbookEntryActivated'] = 'Event triggered when a Guestbook entry is activated
  	 <h4>Parameters</h4>
  	 <ul>
  	 <li><em>entry_id</em> - The entry id (int)</li>
  	 </ul>
';
$lang['event_info_GuestbookEntryDeactivated'] = 'Hendelse kallt n&aring;r et Gjestebok innlegg er de-aktivert';
$lang['event_help_GuestbookEntryDeactivated'] = 'Event triggered when a Guestbook entry is de-activated
  	 <h4>Parameters</h4>
  	 <ul>
  	 <li><em>entry_id</em> - The entry id (int)</li>
  	 </ul>
';
$lang['inposmes'] = 'Vennligst sett &quot;Modify Guestbook Entries&quot; tillatelse for de brukerene som skal administrere gjesteboken. Og &quot;Modify Guestbook Template&quot; tillatelse for de brukerne som skal kunne endre Gjestebok malen.<br />Koble til stilarket som heter &quot;%s&quot; til malen som benyttes for &aring; sette stil p&aring; gjesteboken.';
$lang['moddescription'] = 'Behandle Gjestebok innlegg og mal.';
$lang['uninstall_pre_message'] = 'Det %. innlegget i gjesteboken vil bli slettet!';
$lang['uninstall_pre_message_single'] = 'Det er 1. innlegg i din gjestebok som vil bli permanent slettet!';
$lang['postuninstall'] = 'Gjestebok avinstallasjon vellykket.';
$lang['help_mode'] = '&quot;guestbook&quot;, &quot;form&quot;, &quot;entrylist&quot; eller &quot;entry&quot;';
$lang['help_show_entry'] = 'ID for innlegg som skal vises (mode=&quot;entry&quot; er antatt)';
$lang['help_guestbook'] = 'Gjestebok ID';
$lang['help_textleng'] = 'Angir hvor mange tegn som kan skrives inn. Standard er 1000 tegn. Denne parameter har betydning b&aring;de for server- og klient-side validering.';
$lang['help_number'] = 'Maksimalt antall innlegg p&aring; en side.';
$lang['help_timespan'] = 'Minimum tid g&aring;tt mellom innlegg (i sekunder).';
$lang['hide_insertbutton_after_post'] = 'N&aring;r innlegget er ferdig, vil ikke sett inn knappen vises.';
$lang['help_mailnoti'] = 'E-mail adresse &aring; sende en melding til om en melding ble lagt til. CMSMailer modulen vil bli brukt for sending om den er installert (ellers s&aring; benyttes PHP&#039;s mail funksjon).';
$lang['help_sortasc'] = 'Sorter Gjestebok innlegg i stigende datorekkef&oslash;lge (nye innlegg vil havne nederst).';
$lang['help_dateformat'] = 'Endre m&aring;ten dato vil vises, dette benytter PHP format kodene';
$lang['help_shownow'] = 'Vis meldinger rette etter sending, uten godkjenning av admin.';
$lang['help_smiley'] = 'Oversett tekstbaserte smileys til bilde smileys og viser smiley tabellen p&aring; innlegg skriving skjemaet. Benytter Smiley modulen om den er installert.';
$lang['help_captcha'] = 'Dette vil sl&aring; p&aring; captcha p&aring; gjestebok innlegg skjemaet. Captcha modulen m&aring; v&aelig;re installert for at denne parameteren skal fungere.';
$lang['help_showaddform'] = 'Viser innskriving skjemaet p&aring; forside.  Erstattter knappen &quot;Nytt Innlegg&quot;.';
$lang['help'] = '
<h3>Hva gj&oslash;r denne modulen?</h3>
<p>
    Gjestebok modulen er en innholsmodul og en CMSMS tagmodul.
    Den gir bes&oslash;kende mulighet til &aring; legge igjen enmelding, 
    for eksempel om hvordan de liker nettstedet.
</p>

<h3>Sikkerhet</h3>
<p>
    Brukeren m&aring; tilh&oslash;re en gruppe med tillatelse &#039;Modifiser Gjestebok Oppf&oslash;ringer&#039; for &aring; kunner to legge til, redigere, eller slette gjestebok oppf&oslash;ringer.<br />
    For &aring; kunne endre malen for Gjestebok oppf&oslash;ringer, m&aring; man ha tillatelsen &#039;Modifiser Gjestebok Mal&#039;,  
</p>

<h3>Hvordan bruker man modulen?</h3>
<p>
    Den ekleste m&aring;ten, er &aring; opprette en ny side og endre &quot;Innholdstype&quot; til Gjestebok. P&aring; den m&aring;ten vil du bli istand til &aring; sette gjestebok alternativer som egenskaper for siden.<br />
    Dersom du &oslash;nsker &aring; legge til modulen etter annet innhold, kan du sette den inn ved &aring; bruke cms_module taggen. Du kan da sette inn gjesteboken i din sidamal/side hvor du m&aring;tte &oslash;nske.<br /> 
    Koden vil se ut noe slikt som: <code>{cms_module module=&quot;Guestbook&quot; number=5 shownow=true smiley=1 mailnoti=you@example.com}</code>
</p>

<h3>Hvilke designmuligheter finnes?</h3>

<p>
    Et eksempel stilark for standard databasemal er installert sammen med modulen.<br />
    Standard stilarket slettes n&aring;r modulen avinstalleres og kan bli overskrevet ved oppgraderinger. Du vil derfor kunne &oslash;nske &aring; bruke en kopi dersom du &oslash;nsker &aring; modifisere den.<br />
    Legg stilarket til sidemalen du bruker.
</p>

<p>
    De fleste maler som brukes for module-front-end  lagres i databasen og kan redigeres fra Administrasjonspanelet.
</p>
<p>
    I modulmappen er det en folder som heter &quot;templates&quot; hvor alle andre maler er lagret. Du kan modifisere disse for &aring; passe dine behov:
</p>

<strong>Administrasjon</strong>
<p>
admin_entries_top.tpl -> Inndeling og radnavn for oppf&oslash;ringslisten.<br/>
admin_entries_entry.tpl -> Mal for oppf&oslash;ringer i gjesteboken.<br/>
admin_entries_bottom.tpl -> Slutten av gjestebokoppf&oslash;ring admin skjemaet.<br />
admin_entry.tpl-> Skjema for &aring; sette inn eller redigere gjesetbok oppf&oslash;ringer.<br/>
admin_template_edit.tpl -> Brukes for &aring; redigere gjestebokoppf&oslash;ring database-malen.
</p>

<strong>Front End</strong>
<p>
smiley.tpl -> Smiley tabellen, brukes n&aring;r smiley parametre brukes og Smileys modulen ikke er installert.<br/>
</p>

<p>
    Inne i  template mappen er det en mappe som heter db. Der lagres gjestebokens database maler, som kan redigeres fra Gjestebokens administrasjonsomr&aring;de.<br />
	Innholdet i disse filene kopieres til databasen under modul installasjonen og n&aring;r en mal gjenopprettes til standard fra administrasjonspanelet.<br />
	Som standard brukes filene som kommer med modulen (navn som slutter med -default.tpl), men hvis en (tilpasset) fil er tilstede hvor -default er utelatt i navnet, s&aring; vil denne filen brukes i stedenfor.
</p>';
$lang['changelog'] = '<ul>
	<li>
		<strong>Version 1.1.12</strong><br />
		Fixes:
		<ul>
			<li>Fixed bug when posting a new entry with mod_rewrite on (Thanks to blast2007)</li>
			<li>Fixed incorrect stripping of quotes returned by GetTimestamp</li>
		</ul>
	</li>
	<li>
		<strong>Version 1.1.11</strong><br />
		Fixes:
		<ul>
			<li>Fixed module compatibility with latest CMS Made Simple versions (1.5+)</li>
			<li>Fixed pagination not using full table width</li>
			<li>Fixed some small bugs adding/editing an guestbook entry</li>
			<li>Fixed special characters in (translated) pre-uninstall message(s) not being shown correctly</li>
			<li>Fixed language setting from CMS Made Simple Global Settings not being applied</li>
		</ul>
		Improvements:
		<ul>
			<li>You can now edit a guestbook entry date in the backend</li>
			<li>The number of entries shown per page in the backend is now configurable</li>
		</ul>
	</li>
	<li>
		<strong>Version 1.1.10</strong>
		<ul>
			<li>FIX: Removed this warning from the admin panel: &quot;Warning: vsprintf() [function.vsprintf]: Too few arguments in /home/mywebsite/public_html/lib/translation.functions.php on line 62&quot;</li>
			<li>FIX: Insert of new entries failed, when none mandatory fields were removed from the form.</li>
			<li>FIX: Pagination created invalid XHTML (Text attribute removed)</li>
			<li>CHG: Smileys are now inserted on click via JavaScript. Plain text smileys moved into hint.</li>
			<li>FIX: Wrong encoding and HTML entities in notification emails.</li>
			<li>FIX: Enabled translation for pagination &quot;First&quot; and &quot;Last&quot;.</li>
			<li>CHG: Update SmartyPaginate from 1.5 to 1.6-dev</li>
			<li>FIX: Wrong language field &quot;e_mail&quot; in email notification.</li>
			<li>FIX: Module CMSMailer was not detected/used on PHP4</li>
		</ul>
	</li>
	<li>
		<strong>Version 1.1.9</strong>
		<ul>
			<li>Prevent an E-mail being sent to no address when the mailnoti parameter is not being used</li>
		</ul>
	</li>
	<li>
		<strong>Version 1.1.8</strong>
		<ul>
			<li>Fixed too short ip_address field</li>
			<li>Moved templates to a single tab in the admin</li>
		</ul>
	</li>
	<li>
		<strong>Version 1.1.7</strong>
		<ul>
			<li>Fixed references to old file locations</li>
			<li>Fixed Javascript warning when WYSIWYG is used</li>
		</ul>
	</li>
	<li>
		<strong>Version 1.1.6</strong>
		<ul>
			<li>Fixed character counter not working with FCKeditor</li>
			<li>Moved errormessage to lang file</li>
			<li>Deleted some redundant files</li>
		</ul>
	</li>
	<li>
		<strong>Version 1.1.5</strong>
		<ul>
			<li>Fixed ModuleIsInstalled method always returning false for admin modules/FCKEditorX</li>
			<li>Fixed character counter always starting at 1000</li> 
		</ul>
	</li>
	<li>
		<strong>Version 1.1.4</strong>
		<ul>
			<li>Fixes breaks in messages not showing in 1.1.3</li>
			<li>Added (optional) basic WYSIWYG on the Guestbook entry form</li>
			<li>Added logging of guestbook entry sender IP address</li>
			<li>Added &quot;Modify Guestbook Settings&quot; permission</li>
		</ul>
	</li>
	<li>
		<strong>Version 1.1.3</strong>
		<ul>
			<li>Improved pagination</li>
			<li>Rewrote front-end code to use Smarty for all output</li>
			<li>The front-end Smarty templates now use arrays</li>
			<li>Made most front-end templates editable from the admin</li>
			<li>Added events</li>
			<li>Added bad word filter</i>
		</ul>
	</li>
	<li>
		<strong>Version 1.1.2</strong>
		<ul>
			<li>Fixed a bug where the Next button would show when it shouldn&#039;t</li>
			<li>Any guestbook content is deleted on uninstall to prevent fatal errors in cmsmadesimple-1.x</li>
		</ul>
	</li>
	<li>
		<strong>Version 1.1.1</strong>
		<ul>
			<li>Compatiblity changes for cmsmadesimple-1.0 and a small bugfix</li>
		</ul>
	</li>
	<li>
		<strong>Version 1.1</strong>
		<ul>
			<li>Added Captcha support (in a seperate Captcha module)</li>
			<li>Added timespan parameter (minimal timespan between posts)</li>
			<li>Added location field (for State/Province/City/Town)</li>
			<li>Make use of the Smiley module if it is installed</li>
			<li>Made the module compatible with the cmsmadesimple-1.0 series</li>
			<li>Minimal required CMS version changed to 0.13</li>
		</ul>
	</li>
	<li>
		<strong>Version 1.0</strong>
		<ul>
			<li>Renamed module (from gastbuch) to Guestbook to represent the projects natural language and follow CMS Made Simple module naming conventions.</li>
			<li>Enabled handling (deleting, activating and deactivating) of multiple guestbook entries from the admin panel.</li>
			<li>There are now seperate &#039;Modify Guestbook Entries&#039; and &#039;Modify Guestbook Template&#039; permissions.</li>
			<li>A default/example stylesheet is installed (and uninstalled) with the module.</li>
			<li>The database template can be restored to default.</li>
			<li>Changed to tabbed navigation.</li>
			<li>Cleanup/rewrite of the guestbook(item) database template and the variables used in it.</li>
			<li>Translated many variable names and code comments to english.</li>
			<li>Moved some admin and log messages to the language file.</li>
			<li>Re-formatted source code for better readability.</li>
			<li>The module now also works in combination with a PostgreSQL database.</li>
			<li>Changed the input format for the dateformat parameter from MySQL format to PHP format.</li>
			<li>A new variable is assigned to the (database) guestbookentry template: $e_mail_cloaked. This is the E-mail address, with @ replaced by &amp;lt;at&amp;gt; and . by &amp;lt;dot&amp;gt;.</li>
			<li>Extended the notification E-mail, it now sends the new guestbook entry in the notification message.</li>
			<li>New finnish translation and updated dutch and norwegian translations from the translation center.</li>
		</ul>
	</li>
	<li>
		<strong>Version 0.9</strong>
		<ul>
			<li>The guestbook frontend now uses a database template (in stead of the showmessage*.tpl files) that can be modified from the admin panel</li>
			<li>The dateformat parameter is now called dateformat (was dateform). Note: this means you will have to recreate any guestbook content pages or manually edit the tables cms_content and cms_content_props</li>
			<li>New french translation and modified translations for other languages from the translation center</li>
		</ul>
	</li>
	<li>
		<strong>Version 0.8</strong><br />
		Fixed:
		<ul>
			<li>not working smileys on gastbuch Content page in version 0.7</li>
		</ul>
		Cleanup:
		<ul>
			<li>mainly removal of unneccary references to the global $gCms</li>
			<li>renamed email textfield to e_mail (it was called betreff, probably an old subject field)</li>
		</ul>
		Improvements:
		<ul>
			<li>newly submitted newsentry is shown in the list</li>
			<li>brackets around submitter country are no longer shown if a country wasn&#039;t entered</li>
			<li>translated the lang file to dutch (except for help and changelog)</li>
			<li>the gastbuch module now makes use of translations entered in the translation center translations.cmsmadesimple.org</li>
		</ul>
		Changed:
		<ul>
			<li>The template variable name for the country in showmessage.tpl is now called $country (was $countryshow in previous versions)</li>
		</ul>
	</li>
	<li>
		<strong>Version 0.7</strong>
		<ul>
			<li>Added lang attribute to support multiple locales</li>
			<li>Show insert form on the first page</li>
			<li>Fixed bug with textlength javascript not working</li>
			<li>Fixed a few minor bugs</li>
		</ul>
	</li>
	<li>
		<strong>Version 0.6</strong>
		<ul>
			<li>Redesigned source code for better readability</li>
			<li>Added lang attribute to support multiple locales</li>
			<li>Added showaddform parameter</li>
			<li>Fixed bug with textlength javascript not working in case of &quot;Content&quot; content type</li>
			<li>Merged vorzu and backzu templates into one</li>
			<li>Added template success_message.tpl</li>
			<li>Fixed a few minor bugs caused by mismatches in lang variable names</li>
		</ul>
	</li>
	<li>
		<strong>Version 0.5</strong>
		<ul>
			<li>The guestbook was modified with better design and functions, for example: Template based Content, Spam protection for inserted e-mails, etc.</li>
		</ul>
	</li>
	<li>
		<strong>Version 0.4</strong>
		<ul>
			<li>The gastbuch module is now a new module</li>
		</ul>
	</li>
</ul>';
$lang['utmz'] = '156861353.1279922282.3039.70.utmcsr=forum.cmsmadesimple.org|utmccn=(referral)|utmcmd=referral|utmcct=/index.php';
$lang['utma'] = '156861353.179052623084110100.1210423577.1280699407.1280761916.3086';
$lang['qca'] = '1210971690-27308073-81952832';
$lang['utmb'] = '156861353.1.10.1280761916';
$lang['utmc'] = '156861353';
?>]]></data>
	</file>
	<file>
	  <filename>/lang/ext/nl_NL.php</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[<?php
$lang['module_friendlyname'] = 'Gastenboek ';
$lang['default_guestbook_name'] = 'Standaard';
$lang['default_guestbook_descr'] = 'Het eerste [standaard] gastenboek';
$lang['module_example_stylesheet'] = 'Gastenboek (standaard voorbeeld stylesheet)';
$lang['module_example_stylesheet_intro'] = 'Standaard/voorbeeld stylesheet voor de CMSMS Guestbook-module.
Deze kan overschreven worden bij een module upgrade en wordt verwijderd als de module gede&iuml;nstalleerd wordt; maak dus een kopie bij eventuele aanpassingen.';
$lang['captcha'] = 'Captcha ';
$lang['captcha_title'] = 'De tekst uit de afbeelding invoeren';
$lang['captcha_failure_message'] = 'De tekst uit de afbeelding is niet goed overgenomen ';
$lang['timespan'] = 'Minimale tijdsspanne tussen bijdragen';
$lang['err_invalid_mode'] = 'Fout: ongeldige mode parameter. Geldige waarden zijn: %s.';
$lang['err_no_entry_id'] = 'Fout: geen entry_id parameter. Bij mode=entry moet ook een entry_id parameter worden opgegeven.';
$lang['err_entry_not_found'] = 'Fout: er is geen gastenboekbericht met entry_id %s';
$lang['error_template_filenotfound'] = 'Fout: sjabloonbestand %s niet gevonden!';
$lang['default'] = 'Standaard';
$lang['add_guestbook'] = 'Nieuw gastenboek aanmaken';
$lang['adding_guestbook'] = 'Een nieuw gastenboek toevoegen';
$lang['editing_guestbook'] = 'Wijzig een bestaand gastenboek';
$lang['set_as_default'] = 'Instellen als standaard';
$lang['confirm_set_as_default'] = 'Dit gastenboek als standaard instellen?';
$lang['confirm_delete_guestbook'] = 'Wilt u het gastenboek met ID %s verwijderen? De %s reacties die het gastenboek bevat zullen dan ook worden verwijderd!!';
$lang['id'] = 'ID';
$lang['date'] = 'Datum';
$lang['sender'] = 'Afzender';
$lang['email'] = 'E-mail ';
$lang['country'] = 'Land';
$lang['location'] = 'Woonplaats';
$lang['homepage'] = 'Website';
$lang['message'] = 'Bericht';
$lang['posted'] = 'Gepost';
$lang['ip_addr'] = 'IP-adres';
$lang['alength'] = 'Overgebleven tekens';
$lang['active'] = 'Actief';
$lang['access_denied'] = 'Toegang geweigerd';
$lang['restore_to_defaults'] = 'Terug naar standaard';
$lang['restore_to_defaults_warning'] = 'Hiermee wordt de sjabloon inhoud teruggezet naar de standaard. Aangebrachte wijzigingen worden overschreven. Wilt u doorgaan?';
$lang['addgait'] = 'Voeg bericht toe';
$lang['postdate'] = 'Plaatsingsdatum';
$lang['ativi'] = 'Activeer';
$lang['deakti'] = 'Deactiveer';
$lang['title_mod_admin'] = 'Beheer berichten';
$lang['tabname_guestbooks'] = 'Gastenboeken';
$lang['tabname_entries'] = 'Berichten';
$lang['title_mod_templates'] = 'Sjablonen';
$lang['tabname_settings'] = 'Module Voorkeuren';
$lang['title_tab_admin_templates'] = 'Gastenboek sjablonen';
$lang['title_tab_admin_template'] = 'Gastenboek sjabloon';
$lang['title_tab_admin_entrylist_template'] = 'Berichtenlijstsjabloon';
$lang['title_tab_admin_entry_template'] = 'Berichtsjabloon';
$lang['title_tab_admin_form_template'] = 'Formuliersjabloon';
$lang['title_tab_admin_email_template'] = 'E-mailsjabloon';
$lang['title_tab_admin_showform_button_template'] = 'Formuliersjabloon tonen';
$lang['templatecontent'] = 'Sjablooninhoud';
$lang['admin_template_modified_logmessage'] = 'Gastenboek-sjabloon aangepast';
$lang['admin_template_restored_logmessage'] = 'Gastenboek-sjabloon teruggezet';
$lang['admin_entry_added_logmessage'] = 'Gastenboek-bericht toegevoegd';
$lang['admin_entry_modified_logmessage'] = 'Gastenboek-bericht aangepast';
$lang['admin_entry_deleted_logmessage'] = 'Gastenboek-bericht verwijderd';
$lang['admin_entry_activated_logmessage'] = 'Gastenboek-bericht geactiveerd';
$lang['admin_entry_deactivated_logmessage'] = 'Gastenboek-bericht gedeactiveerd';
$lang['admin_entry_message_nosender'] = 'Een afzendernaam invoeren';
$lang['wrong_date_format'] = 'De datum moet de volgende opbouw hebben: JJJJ-MM-DD UU:MM:SS';
$lang['fieldnames'] = 'Veldnamen';
$lang['captcha_module_installed'] = 'De Captcha-module is ge&iuml;nstalleerd';
$lang['captcha_module_not_installed'] = 'De Captcha-module is niet ge&iuml;nstalleerd';
$lang['smileys_module_installed'] = 'De Smileys-module is ge&iuml;nstalleerd';
$lang['smileys_module_not_installed'] = 'De Smileys-module is niet ge&iuml;nstalleerd';
$lang['preferences_title'] = 'Gastenboek Instellingen';
$lang['admin_wysiwyg_title'] = 'Gebruik WYSIWYG editor voor het Gastenboek formulier';
$lang['searchsmileys_title'] = 'Gebruik smileys in zoekresultaten';
$lang['save_settings'] = 'Instellingen opslaan';
$lang['settings_saved'] = 'De instellingen zijn opgeslagen.';
$lang['badwords_title'] = 'Niet-toegestane woorden';
$lang['badwords_replacement_title'] = 'Vervang niet-toegestane woorden door';
$lang['admin_entries_per_page_title'] = 'Berichten per pagina (admin)';
$lang['description'] = 'Omschrijving';
$lang['nummer'] = 'Aantal berichten per pagina';
$lang['postchar'] = 'Maximum berichtgrootte';
$lang['emailnot'] = 'E-mail notificatie';
$lang['sortasc'] = 'Sorteer oplopend';
$lang['smile'] = 'Smiley ';
$lang['shmenow'] = 'Toon bericht direct';
$lang['datefora'] = 'Datumopmaak';
$lang['lang'] = 'Taal (bijvoorbeeld nl_NL)';
$lang['showaddform'] = 'Nieuw berichtformulier direct tonen';
$lang['fabsend'] = 'Voer uw naam in';
$lang['fmessag'] = 'Voer uw bericht in';
$lang['femail'] = 'Voer een geldig e-mailadres in';
$lang['tolong'] = 'Het bericht is langer dan toegestaan. Verkort uw bericht.';
$lang['toosoon'] = 'Uw laatste bijdrage was slechts %s seconden geleden. De minimale tijdspanne tussen bijdragen is %s seconden';
$lang['fui'] = 'Uw bericht is al verstuurd';
$lang['badwords_message'] = 'Deze woorden zijn niet toegestaan: %s';
$lang['showitnow'] = 'Uw bericht is geplaatst.';
$lang['showitlater'] = 'Dank u wel. Uw bericht wordt pas na een inhoudelijke controle door de websitebeheerder zichtbaar!';
$lang['msg_back'] = 'Terug';
$lang['inam'] = 'Naam';
$lang['imessag'] = 'Uw bericht';
$lang['smessage'] = 'Bericht';
$lang['sdate'] = 'Datum';
$lang['ginsert'] = 'Toevoegen';
$lang['cancel'] = 'Annuleer';
$lang['uhr'] = 'uur';
$lang['e_mailnotibetr'] = 'Nieuw bericht in uw Gastenboek';
$lang['e_mailnotimessage'] = 'Er is een nieuw bericht in uw Gastenboek';
$lang['neuein'] = 'Nieuw Bericht';
$lang['einerseit'] = '&eacute;&eacute;n pagina';
$lang['eintragauf'] = 'Bijdragen op';
$lang['seitpage'] = 'pagina&#039;s';
$lang['backzu'] = '<< Terug';
$lang['nextwei'] = 'Volgende >>';
$lang['first_text'] = '<<';
$lang['prev_text'] = '< vorige';
$lang['next_text'] = 'volgende >';
$lang['last_text'] = '>>';
$lang['pagination_of'] = 'van';
$lang['title_table_smileys'] = 'Smiley&#039;s';
$lang['ativimes'] = 'Activeer dit bericht?';
$lang['deaktimes'] = 'Deactiveer dit bericht?';
$lang['event_info_GuestbookEntryPosted'] = 'Een tag die wordt aangeroepen als een Gastenboek-bericht is toegevoegd';
$lang['event_help_GuestbookEntryPosted'] = '<p>Een tag die wordt aangeroepen als een Gastenboek-bericht is toegevoegd.</p>
  	 <h4>Parameters</h4>
  	 <ul>
		<li><em>entry_id</em> - Het berichten id (int)</li>
		<li><em>entry_sender</em> - De opgegeven naam (string)</li>
		<li><em>entry_email</em> - Het opgegeven emailadres (string)</li>
		<li><em>entry_homepage</em> - De opgegeven startpagina (string)</li>
		<li><em>entry_message</em> - Het opgegeven bericht (string)</li>
		<li><em>entry_country</em> - Het opgegeven land (string)</li>
		<li><em>entry_location</em> - De opgegeven lokatie (string)</li>
		<li><em>entry_date</em> - De verzenddatum (string)</li>
		<li><em>entry_approved</em> - Of het bericht direct geactiveerd is, 1 als dit zo is, -1 als het niet zo is (int)</li>
  	 </ul>
';
$lang['event_info_GuestbookEntryDeleted'] = 'Een tag die wordt aangeroepen als een Gastenboek-bericht wordt verwijderd';
$lang['event_help_GuestbookEntryDeleted'] = 'Een tag die wordt aangeroepen als een Gastenboek-bericht wordt verwijderd
  	 <h4>Parameters</h4>
  	 <ul>
	  	 <li><em>entry_id</em> - Het berichten-id (int)</li>
  	 </ul>
';
$lang['event_info_GuestbookEntryActivated'] = 'Een tag die wordt aangeroepen als een Gastenboek-bericht wordt geactiveerd';
$lang['event_help_GuestbookEntryActivated'] = 'Een tag die wordt aangeroepen als een Gastenboek-bericht wordt geactiveerd
  	 <h4>Parameters</h4>
  	 <ul>
  	 <li><em>entry_id</em> - Het berichten id (int)</li>
  	 </ul>
';
$lang['event_info_GuestbookEntryDeactivated'] = 'Een tag die wordt aangeroepen als een Gastenboek-bericht wordt gedeactiveerd';
$lang['event_help_GuestbookEntryDeactivated'] = 'Een tag die wordt aangeroepen als een Gastenboek-bericht wordt gedeactiveerd
  	 <h4>Parameters</h4>
  	 <ul>
  	 <li><em>entry_id</em> - Het berichten id (int)</li>
  	 </ul>
';
$lang['inposmes'] = 'Zorg ervoor dat beheerders van Gastenboek-bijdragen de &quot;Modify Guestbook entries&quot; rechten hebben. Gebruikers die het Gastenboek-berichtsjabloon moeten kunnen aanpassen hebben &quot;Modify Guestbook Template&quot; rechten nodig. Koppel de stylesheet met de naam &quot;%s&quot; aan het gebruikte sjabloon om het Gastenboek vorm te geven.';
$lang['moddescription'] = 'Beheer van het Gastenboek-sjabloon en de berichten';
$lang['uninstall_pre_message'] = 'De %s berichten in uw Gastenboek worden permanent verwijderd!';
$lang['uninstall_pre_message_single'] = 'Er is &eacute;&eacute;n bericht in uw Gastenboek dat permanent verwijderd wordt!';
$lang['postuninstall'] = 'De Gastenboek module is gede&iuml;nstalleerd.';
$lang['help_mode'] = '&quot;guestbook&quot;, &quot;form&quot;, &quot;entrylist&quot; of &quot;entry&quot;';
$lang['help_show_entry'] = 'Id of een entry om te tonen (mode=&quot;entry&quot; is standaard)';
$lang['help_guestbook'] = 'Gastenboek Id';
$lang['help_textleng'] = 'Aantal tekens dat kan worden ingevoerd. Standaard is 1000 tekens. Deze parameter be&iuml;nvloed zowel de controle op de server als in de browser.';
$lang['help_number'] = 'Maximaal aantal berichten dat getoond wordt op een pagina.';
$lang['help_timespan'] = 'Minimale tijd tussen bijdragen (in seconden).';
$lang['hide_insertbutton_after_post'] = 'Wanneer een bericht is geplaatst, dan zal de Bericht plaatsen-toets niet worden getoond.';
$lang['help_mailnoti'] = 'E-mailadres om een notificatie naar te verzenden als een bericht verstuurd is. De CMSMailer-module wordt gebruikt voor het versturen van de e-mail als deze is ge&iuml;nstalleerd (anders wordt PHP&#039;s mail-functie gebruikt).';
$lang['help_sortasc'] = 'Gastenboek-berichten weergeven met oplopende datum (nieuwe berichten gaan naar het eind).';
$lang['help_dateformat'] = 'Datumweergave aanpassen, gebruikt PHP opmaakcodes, zie http://www.php.net/nl/date';
$lang['help_shownow'] = 'Toont berichten direct na verzending, zonder goedkeuring door een beheerder.';
$lang['help_smiley'] = 'Vervang text-smiley&#039;s in de tekst door plaatjes (smiley&#039;s) en toon de smiley-tabel op het berichtenformulier.  Gebruikt de Smileys-module als deze ge&iuml;nstalleerd is.';
$lang['help_captcha'] = 'Captcha gebruiken op het invoerformulier. Deze parameter werkt niet als de Captcha-module niet ge&iuml;nstalleerd is.';
$lang['help_showaddform'] = 'Toon het invoerformulier op de eerste pagina. Dit vervangt de &quot;Nieuw Gastenboek bericht&quot; knop.';
$lang['help'] = '<h3>Wat doet het?</h3>
<p>De Gastenboek-module is een inhoudmodule en een CMSMS tagmodule.
Het geeft bezoekers de mogelijkheid een bericht achter te laten, bijvoorbeeld over wat ze van uw website vinden.</p>

<h3>Beveiliging</h3>
<p>
De gebruiker moet lid zijn van een groep met de &quot;Modify Guestbook Entries&quot; rechten om berichten te kunnen toevoegen, wijzigen en verwijderen.<br />
Om het berichtsjabloon aan te kunnen passen zijn &quot;Modify Guestbook Template&quot; rechten nodig.
</p>

<h3>Hoe gebruikt u het?</h3>
<p>
De gemakkelijkste manier is het aanmaken van een nieuwe pagina en daarbij het &quot;Inhoudstype&quot; in te stellen op Gastenboek (i.p.v. bijvoorbeeld content). Op deze manier kunnen de Gastenboek-opties als paginaeigenschappen worden ingesteld.<br />
Als het Gastenboek na andere inhoud moet worden geplaatst, kan dit door gebruik te maken van de cms_module tag. Hiermee kan het Gastenboek op iedere plaats binnen het sjabloon of de pagina neergezet worden.<br />
De code ziet er dan bijvoorbeeld als volgt uit: <code>{cms_module module=&quot;Guestbook&quot; number=&quot;5&quot; shownow=&quot;1&quot; smiley=&quot;1&quot;}</code>
</p>

<h3>Welke ontwerpmogelijkheden zijn er?</h3>

<p>
    Een voorbeeld stylesheet voor de standaard database-sjabloon is ge&iuml;nstalleerd, samen met de module.<br />
    De standaard stylesheet is verwijderd als de module gedeinstalleerd wordt, dus u kunt het beste een kopie maken als u het aanpast.<br />
    Koppel de stylesheet aan het gebruikte paginasjabloon.
</p>

<p>
    De meeste sjablonen die gebruikt worden in de front-end module, worden opgeslagen in de database en kunnen via het beheerpaneel worden bewerkt.
</p>
<p>
    In de modulemap staat een map genaamd &#039;templates&#039; waar alle andere sjablonen worden opgeslagen. U kunt deze aanpassen naar uw wensen:
</p>

<strong>Beheer</strong>
<p>
admin_entries_top.tpl -> De paginering en rijnamen<br/>
admin_entries_entry.tpl -> De lijst met Guestbook-berichten
admin_entries_bottom.tpl -> De onderkant van het Guestbook-berichten beheerpaneel<br />
admin_entry.tpl-> Het beheerscherm waarmee berichten worden toegevoegd en aangepast<br/>
admin_template_edit.tpl-> Gebruikt voor het aanpassen van het berichtensjabloon in de database<br/>
</p>
<strong>Frontend</strong>
<p>
newguest.tpl -> Knop om naar het Nieuw-berichtformulier te gaan<br/>
insertform.tpl -> Het berichtinvoerformulier
smiley.tpl-> Het sjabloon voor de smiley-tabel<br/>
prevnext.tpl-> De knoppen om naar de vorige of volgende pagina te gaan (alleen zichtbaar als niet alle berichten op een pagina passen)<br/>
success_message.tpl -> Het bericht dat getoond wordt als een bericht is toegevoegd.
<br/>
</p>
<p>
In de sjabloonmap bevindt zich een map met de naam db. Hierin is het berichtensjabloon opgeslagen dat naar de database wordt gekopieerd als de module wordt ge&iuml;nstalleerd, of als een beheerder &quot;Terugzetten naar standaard&quot; selecteert vanuit het beheerpaneel.<br />
Standaard wordt het bestand guestbook_entry-default.tpl gebruikt, maar als een (aangepast) bestand guestbook_entry.tpl aanwezig is wordt dit in plaats ervan gebruikt.
</p>';
$lang['changelog'] = '<ul>
	<li>
		<strong>Version 1.3.0</strong><br />
        <span style=&quot;color:#FF0000;font-style:italic;display:block;&quot;>You have to reset your Guestbook templates when upgrade to this version.</span>
		Fixes:
		<ul>
            <li><span style=&quot;font-weight: bold;&quot;>Content type is now USABLE</span></li>
			<li>Fixed page printing in random</li>
            <li>Fixed XSS security issue in next parameter (Pagination class)</li>
            <li>Fixed message list table who can be broken by HTML in message</li>
            <li><span style=&quot;font-style:italic;font-weight: bold;&quot;>Now fully compatible with CMSMS 1.8</span></li>
		</ul>
        Improvements:
        <ul>
            <li>Content type: More date format</li>
            <li>Prettier URL</li>
            <li>Some translation and admin display improvements</li>
            <li>Completely rewrited Pagination module (faster and more secure)</li>
        </ul>
        New Feature:
        <ul>
            <li>Smiley in Front Wysiwyg</li>
            <li>Front date format can be specified in GetDate() in <a href="http://php.net/manual/en/function.date.php">php format</a> (not english only)</li>
            <li>Front date format is now using smarty to get multilanguage capability - date format should be set as <a href="http://www.smarty.net/manual/en/language.modifier.date.format.php">smarty format</a></li>
            <li>Possibility to select all current entry</li>
            <li>Pagination rewrited to be more speed and usefull</li>
            <li>Managing in which guestbook is the entry</li>
            <li>Multiple destination for notification mail</li>
        </ul>
        Minor fixes:
        <ul>
            <li>W3 proof for Javascript</li>
            <li>Few PHP Notices and warnings</li>
        </ul>
	</li>

	<li>
		<strong>Version 1.1.12</strong><br />
		Fixes:
		<ul>
			<li>Fixed bug when posting a new entry with mod_rewrite on (Thanks to blast2007)</li>
			<li>Fixed incorrect stripping of quotes returned by GetTimestamp</li>
		</ul>
	</li>
	<li>
		<strong>Version 1.1.11</strong><br />
		Fixes:
		<ul>
			<li>Fixed module compatibility with latest CMS Made Simple versions (1.5+)</li>
			<li>Fixed pagination not using full table width</li>
			<li>Fixed some small bugs adding/editing an guestbook entry</li>
			<li>Fixed special characters in (translated) pre-uninstall message(s) not being shown correctly</li>
			<li>Fixed language setting from CMS Made Simple Global Settings not being applied</li>
		</ul>
		Improvements:
		<ul>
			<li>You can now edit a guestbook entry date in the backend</li>
			<li>The number of entries shown per page in the backend is now configurable</li>
		</ul>
	</li>
	<li>
		<strong>Version 1.1.10</strong>
		<ul>
			<li>FIX: Removed this warning from the admin panel: &quot;Warning: vsprintf() [function.vsprintf]: Too few arguments in /home/mywebsite/public_html/lib/translation.functions.php on line 62&quot;</li>
			<li>FIX: Insert of new entries failed, when none mandatory fields were removed from the form.</li>
			<li>FIX: Pagination created invalid XHTML (Text attribute removed)</li>
			<li>CHG: Smileys are now inserted on click via JavaScript. Plain text smileys moved into hint.</li>
			<li>FIX: Wrong encoding and HTML entities in notification emails.</li>
			<li>FIX: Enabled translation for pagination &quot;First&quot; and &quot;Last&quot;.</li>
			<li>CHG: Update SmartyPaginate from 1.5 to 1.6-dev</li>
			<li>FIX: Wrong language field &quot;e_mail&quot; in email notification.</li>
			<li>FIX: Module CMSMailer was not detected/used on PHP4</li>
		</ul>
	</li>
	<li>
		<strong>Version 1.1.9</strong>
		<ul>
			<li>Prevent an E-mail being sent to no address when the mailnoti parameter is not being used</li>
		</ul>
	</li>
	<li>
		<strong>Version 1.1.8</strong>
		<ul>
			<li>Fixed too short ip_address field</li>
			<li>Moved templates to a single tab in the admin</li>
		</ul>
	</li>
	<li>
		<strong>Version 1.1.7</strong>
		<ul>
			<li>Fixed references to old file locations</li>
			<li>Fixed Javascript warning when WYSIWYG is used</li>
		</ul>
	</li>
	<li>
		<strong>Version 1.1.6</strong>
		<ul>
			<li>Fixed character counter not working with FCKeditor</li>
			<li>Moved errormessage to lang file</li>
			<li>Deleted some redundant files</li>
		</ul>
	</li>
	<li>
		<strong>Version 1.1.5</strong>
		<ul>
			<li>Fixed ModuleIsInstalled method always returning false for admin modules/FCKEditorX</li>
			<li>Fixed character counter always starting at 1000</li> 
		</ul>
	</li>
	<li>
		<strong>Version 1.1.4</strong>
		<ul>
			<li>Fixes breaks in messages not showing in 1.1.3</li>
			<li>Added (optional) basic WYSIWYG on the Guestbook entry form</li>
			<li>Added logging of guestbook entry sender IP address</li>
			<li>Added &quot;Modify Guestbook Settings&quot; permission</li>
		</ul>
	</li>
	<li>
		<strong>Version 1.1.3</strong>
		<ul>
			<li>Improved pagination</li>
			<li>Rewrote front-end code to use Smarty for all output</li>
			<li>The front-end Smarty templates now use arrays</li>
			<li>Made most front-end templates editable from the admin</li>
			<li>Added events</li>
			<li>Added bad word filter</i>
		</ul>
	</li>
	<li>
		<strong>Version 1.1.2</strong>
		<ul>
			<li>Fixed a bug where the Next button would show when it shouldn&#039;t</li>
			<li>Any guestbook content is deleted on uninstall to prevent fatal errors in cmsmadesimple-1.x</li>
		</ul>
	</li>
	<li>
		<strong>Version 1.1.1</strong>
		<ul>
			<li>Compatiblity changes for cmsmadesimple-1.0 and a small bugfix</li>
		</ul>
	</li>
	<li>
		<strong>Version 1.1</strong>
		<ul>
			<li>Added Captcha support (in a seperate Captcha module)</li>
			<li>Added timespan parameter (minimal timespan between posts)</li>
			<li>Added location field (for State/Province/City/Town)</li>
			<li>Make use of the Smiley module if it is installed</li>
			<li>Made the module compatible with the cmsmadesimple-1.0 series</li>
			<li>Minimal required CMS version changed to 0.13</li>
		</ul>
	</li>
	<li>
		<strong>Version 1.0</strong>
		<ul>
			<li>Renamed module (from gastbuch) to Guestbook to represent the projects natural language and follow CMS Made Simple module naming conventions.</li>
			<li>Enabled handling (deleting, activating and deactivating) of multiple guestbook entries from the admin panel.</li>
			<li>There are now seperate &#039;Modify Guestbook Entries&#039; and &#039;Modify Guestbook Template&#039; permissions.</li>
			<li>A default/example stylesheet is installed (and uninstalled) with the module.</li>
			<li>The database template can be restored to default.</li>
			<li>Changed to tabbed navigation.</li>
			<li>Cleanup/rewrite of the guestbook(item) database template and the variables used in it.</li>
			<li>Translated many variable names and code comments to english.</li>
			<li>Moved some admin and log messages to the language file.</li>
			<li>Re-formatted source code for better readability.</li>
			<li>The module now also works in combination with a PostgreSQL database.</li>
			<li>Changed the input format for the dateformat parameter from MySQL format to PHP format.</li>
			<li>A new variable is assigned to the (database) guestbookentry template: $e_mail_cloaked. This is the E-mail address, with @ replaced by &amp;lt;at&amp;gt; and . by &amp;lt;dot&amp;gt;.</li>
			<li>Extended the notification E-mail, it now sends the new guestbook entry in the notification message.</li>
			<li>New finnish translation and updated dutch and norwegian translations from the translation center.</li>
		</ul>
	</li>
	<li>
		<strong>Version 0.9</strong>
		<ul>
			<li>The guestbook frontend now uses a database template (in stead of the showmessage*.tpl files) that can be modified from the admin panel</li>
			<li>The dateformat parameter is now called dateformat (was dateform). Note: this means you will have to recreate any guestbook content pages or manually edit the tables cms_content and cms_content_props</li>
			<li>New french translation and modified translations for other languages from the translation center</li>
		</ul>
	</li>
	<li>
		<strong>Version 0.8</strong><br />
		Fixed:
		<ul>
			<li>not working smileys on gastbuch Content page in version 0.7</li>
		</ul>
		Cleanup:
		<ul>
			<li>mainly removal of unneccary references to the global $gCms</li>
			<li>renamed email textfield to e_mail (it was called betreff, probably an old subject field)</li>
		</ul>
		Improvements:
		<ul>
			<li>newly submitted newsentry is shown in the list</li>
			<li>brackets around submitter country are no longer shown if a country wasn&#039;t entered</li>
			<li>translated the lang file to dutch (except for help and changelog)</li>
			<li>the gastbuch module now makes use of translations entered in the translation center translations.cmsmadesimple.org</li>
		</ul>
		Changed:
		<ul>
			<li>The template variable name for the country in showmessage.tpl is now called $country (was $countryshow in previous versions)</li>
		</ul>
	</li>
	<li>
		<strong>Version 0.7</strong>
		<ul>
			<li>Added lang attribute to support multiple locales</li>
			<li>Show insert form on the first page</li>
			<li>Fixed bug with textlength javascript not working</li>
			<li>Fixed a few minor bugs</li>
		</ul>
	</li>
	<li>
		<strong>Version 0.6</strong>
		<ul>
			<li>Redesigned source code for better readability</li>
			<li>Added lang attribute to support multiple locales</li>
			<li>Added showaddform parameter</li>
			<li>Fixed bug with textlength javascript not working in case of &quot;Content&quot; content type</li>
			<li>Merged vorzu and backzu templates into one</li>
			<li>Added template success_message.tpl</li>
			<li>Fixed a few minor bugs caused by mismatches in lang variable names</li>
		</ul>
	</li>
	<li>
		<strong>Version 0.5</strong>
		<ul>
			<li>The guestbook was modified with better design and functions, for example: Template based Content, Spam protection for inserted e-mails, etc.</li>
		</ul>
	</li>
	<li>
		<strong>Version 0.4</strong>
		<ul>
			<li>The gastbuch module is now a new module</li>
		</ul>
	</li>
</ul>
';
$lang['utma'] = '156861353.1335698708.1284586217.1284905221.1284916927.38';
$lang['utmz'] = '156861353.1284905221.37.8.utmcsr=forum.cmsmadesimple.org|utmccn=(referral)|utmcmd=referral|utmcct=/index.php/topic,47466.new.html';
$lang['qca'] = 'P0-1551306179-1284586216711';
$lang['utmb'] = '156861353.1.10.1284916927';
$lang['utmc'] = '156861353';
?>]]></data>
	</file>
	<file>
	  <filename>/lang/ext/pl_PL.php</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[<?php
$lang['module_friendlyname'] = 'Księga gości';
$lang['module_example_stylesheet'] = 'Księga gości (domyślny arkusz styl&oacute;w)';
$lang['module_example_stylesheet_intro'] = 'Domyślny arkusz styl&oacute;w dla modułu CMSMS Księga Gości.
Moze zostać zmieniony po zainstalowaniu modułu, zostanie usunięty w momencie odinstalowania modułu, jeśli zamierzasz go zmienić zr&oacute;b kopię zapasową.';
$lang['captcha'] = 'Captcha';
$lang['captcha_title'] = 'Wprowadź tekst z obrazka';
$lang['captcha_failure_message'] = 'Błędny tekst. Wprowadź ponownie';
$lang['timespan'] = 'Minimalny czas pomiędzy wpisami';
$lang['err_invalid_mode'] = 'Błąd: został użyty niewłaściwy parametr. Poprawny to: %s.';
$lang['err_no_entry_id'] = 'Błąd: nie podano parametru entry_id. Razem z  mode=entry parametr entry_id r&oacute;wnież musi być użyty.';
$lang['err_entry_not_found'] = 'Błąd: nie ma wpis&oacute;w w księdze gości z entry_id %s';
$lang['error_template_filenotfound'] = 'Błąd: plik tymczasowy %s nie znaleziony!';
$lang['id'] = 'Id ';
$lang['sender'] = 'Autor';
$lang['email'] = 'e-mail';
$lang['country'] = 'Państwo';
$lang['location'] = 'Miasto';
$lang['homepage'] = 'www';
$lang['message'] = 'Treść';
$lang['posted'] = 'Dodano';
$lang['ip_addr'] = 'Adres IP';
$lang['alength'] = 'Pozostało znak&oacute;w';
$lang['active'] = 'Aktywuj';
$lang['access_denied'] = 'Brak dostępu';
$lang['restore_to_defaults'] = 'Przywr&oacute;c domyślne';
$lang['restore_to_defaults_warning'] = 'Ta operacja przywr&oacute;ci domyślny wygląd szablonu wpisu. Przywr&oacute;cić domyślny?';
$lang['addgait'] = 'Dodaj wpis';
$lang['postdate'] = 'Data wpisu';
$lang['ativi'] = 'Aktywuj';
$lang['deakti'] = 'Deaktywuj';
$lang['title_mod_admin'] = 'Zarządzanie wpisami';
$lang['title_mod_settings'] = 'Ustawienia';
$lang['title_tab_admin_templates'] = 'Szablony Księgi Gości';
$lang['title_tab_admin_template'] = 'Szablon Księgi Gości';
$lang['title_tab_admin_entrylist_template'] = 'Szablon Listy Wpis&oacute;w';
$lang['title_tab_admin_entry_template'] = 'Szablon Wpisu';
$lang['title_tab_admin_form_template'] = 'Szablon Formularza';
$lang['title_tab_admin_email_template'] = 'Szablon E-mail';
$lang['title_tab_admin_showform_button_template'] = 'Pokaż szablon formularza';
$lang['templatecontent'] = 'Szablon';
$lang['admin_template_modified_logmessage'] = 'Modyfikacja szblonu';
$lang['admin_template_restored_logmessage'] = 'Przywr&oacute;ć domyślny';
$lang['admin_entry_added_logmessage'] = 'Dodawanie wpis&oacute;w';
$lang['admin_entry_modified_logmessage'] = 'Modyfikowanie wpis&oacute;w';
$lang['admin_entry_deleted_logmessage'] = 'Usuwanie wpis&oacute;w';
$lang['admin_entry_activated_logmessage'] = 'Aktywowanie wpis&oacute;w';
$lang['admin_entry_deactivated_logmessage'] = 'Deaktywowanie wpis&oacute;w';
$lang['admin_entry_message_nosender'] = 'Proszę wpisać imię';
$lang['fieldnames'] = 'Nazwa';
$lang['captcha_module_installed'] = 'Moduł Captcha jest zainstalowany';
$lang['captcha_module_not_installed'] = 'Moduł Captcha nie jest zainstalowany';
$lang['smileys_module_installed'] = 'Moduł Smileys jest zainstalowany';
$lang['smileys_module_not_installed'] = 'Moduł Smileys nie jest zainstalowany';
$lang['admin_wysiwyg_title'] = 'Użyj WYSIWYG w formularzu Księgi Gości';
$lang['searchsmileys_title'] = 'Użyj Smileys w wynikach szukania';
$lang['save_settings'] = 'Zapisz ustawienia';
$lang['badwords_title'] = 'Słowa, kt&oacute;re nie są dozwolone';
$lang['badwords_replacement_title'] = 'Zastąp niedozwolone słowa';
$lang['nummer'] = 'Ilość wiadomości na stronie';
$lang['postchar'] = 'Rozmiar wpisu (ilość znak&oacute;w)';
$lang['emailnot'] = 'Powiadomienie email';
$lang['sortasc'] = 'Sortowanie wg daty wpisu (ASC)';
$lang['smile'] = 'Emotikony';
$lang['shmenow'] = 'Pokaż wiadomość natychmiast';
$lang['datefora'] = 'Format daty';
$lang['lang'] = 'Lokalizacja (np. en_US lub pl_PL)';
$lang['showaddform'] = 'Pokaż formularz pod wpisami';
$lang['fabsend'] = 'Proszę podać imię';
$lang['fmessag'] = 'Proszę wpisać tekst wiadomości';
$lang['femail'] = 'Prosze wpisać poprawny e-mail';
$lang['tolong'] = 'Za dużo znak&oacute;w - proszę poprawić wiadomość';
$lang['toosoon'] = 'Tw&oacute;j ostatni wpis był wykonany %s sekund temu. Minimalny czas między wpisami wynosi %s sekund';
$lang['fui'] = 'Wiadomość została wysłana';
$lang['badwords_message'] = 'Te słowa nie są dozwolone: %s';
$lang['showitnow'] = 'Wiadomość została dodana';
$lang['showitlater'] = 'Dziękujemy! Po zatwierdzeniu przez administratora wiadomość zostanie dodana';
$lang['msg_back'] = 'Wr&oacute;ć do księgi gości';
$lang['inam'] = 'Imię';
$lang['imessag'] = 'Twoja wiadomość';
$lang['smessage'] = 'Treść';
$lang['sdate'] = 'Data';
$lang['ginsert'] = 'Dodaj';
$lang['cancel'] = 'Wyczyść';
$lang['uhr'] = 'h';
$lang['e_mailnotibetr'] = 'Nowy wpis w księdze gości';
$lang['e_mailnotimessage'] = 'Dodano nowy wpis do księgi';
$lang['neuein'] = 'Nowy wpis';
$lang['einerseit'] = 'jedna strona';
$lang['eintragauf'] = 'Zapisano';
$lang['seitpage'] = 'Strony';
$lang['backzu'] = '<< Poprzedni';
$lang['nextwei'] = 'Następny >>';
$lang['first_text'] = '<<';
$lang['prev_text'] = '< poprzedni';
$lang['next_text'] = 'następny >';
$lang['last_text'] = '>>';
$lang['pagination_of'] = 'z';
$lang['title_table_smileys'] = 'Emotikonki';
$lang['ativimes'] = 'Aktywować wiadomość?';
$lang['deaktimes'] = 'Deaktywować wiadomość?';
$lang['event_info_GuestbookEntryPosted'] = 'Zdarzenie wywoływane kiedy nowy wpis do Księgi Gości jest dodawany';
$lang['event_help_GuestbookEntryPosted'] = '<p>Zdarzenie wywołane kiedy nowy wpis do Księgi Gości jest dodawany.</p>
  	 <h4>Parametry</h4>
  	 <ul>
		<li><em>entry_id</em> - id (int) wpisu</li>
		<li><em>entry_sender</em> - The name the sender entered (string)</li>
		<li><em>entry_email</em> - The E-mail address entered (string)</li>
		<li><em>entry_homepage</em> - The homepage entered (string)</li>
		<li><em>entry_message</em> - The message entered (string)</li>
		<li><em>entry_country</em> - The country entered (string)</li>
		<li><em>entry_location</em> - The location entered (string)</li>
		<li><em>entry_date</em> - The post date (string)</li>
		<li><em>entry_approved</em> - Whether the entry is activated at once, 1 if it is, -1 if not (int)</li>
  	 </ul>
';
$lang['event_info_GuestbookEntryDeleted'] = 'Zdarzenie wywoływane kiedy wpis do Księgi Gości jest usuwany';
$lang['event_help_GuestbookEntryDeleted'] = 'Event triggered when a Guestbook entry is deleted
  	 <h4>Parameters</h4>
  	 <ul>
	  	 <li><em>entry_id</em> - The entry id (int)</li>
  	 </ul>
';
$lang['event_info_GuestbookEntryActivated'] = 'Event triggered when a Guestbook entry is activated';
$lang['event_help_GuestbookEntryActivated'] = 'Event triggered when a Guestbook entry is activated
  	 <h4>Parameters</h4>
  	 <ul>
  	 <li><em>entry_id</em> - The entry id (int)</li>
  	 </ul>
';
$lang['event_info_GuestbookEntryDeactivated'] = 'Event triggered when a Guestbook entry is de-activated';
$lang['event_help_GuestbookEntryDeactivated'] = 'Event triggered when a Guestbook entry is de-activated
  	 <h4>Parameters</h4>
  	 <ul>
  	 <li><em>entry_id</em> - The entry id (int)</li>
  	 </ul>
';
$lang['inposmes'] = 'Ustaw prawa \&quot;Modyfikacja wpis&oacute;w Księgi Gości\&quot; dla użytkownik&oacute;w kt&oacute;rzy będą administrować wpisami w Księdze Gości i \&quot;Modyfikacja Szablon&oacute;w Księgi Gości\&quot; dla użytkownik&oacute;w kt&oacute;rzy mogą modyfikować szablony Księgi Gości.<br />Przyłącz arkusz styl&oacute;w \&quot;%s\&quot; do szablonu księgi gości.';
$lang['moddescription'] = 'Zarządzanie wpiszami i szablonami Księgi Gości.';
$lang['uninstall_pre_message'] = '%s wpis&oacute;w w twojej Księdze Gości zostanie całkowicie usuniętych!';
$lang['uninstall_pre_message_single'] = 'Jeden wpis w twojej księdze gości zostanie całkowicie usunięty!';
$lang['postuninstall'] = 'Księga Gości poprawnie odinstalowana.';
$lang['help_textleng'] = 'Ustawienie ilości znak&oacute;w kt&oacute;re mogą być wprowadzone. Domyślnie to  1000 znak&oacute;w. Ten parametr powoduje sprawdzanie po obu stronach serwera i klienta.';
$lang['help_number'] = 'Maksymalna liczba wpis&oacute;w wyświetlana na stronie.';
$lang['help_timespan'] = 'Minimalny odstęp czasu pomiędzy wpisami (w sekundach).';
$lang['help_mailnoti'] = 'Adres E-mail do wysłania powiadomienia jeśli wiadomość została dodana. Moduł CMSMailer będzie użyty do wysłania maila jeśli jest zainstalowany (inaczej zostanie użyta funkcja mail PHP).';
$lang['help_sortasc'] = 'Sortowanie spis&oacute;w w księdze gości w kolejności rosnącej po dacie (nowy post będzie dodany na końcu).';
$lang['help_dateformat'] = 'Zmień spos&oacute;b wyświetlania daty, zawiera kody formatowania PHP';
$lang['help_shownow'] = 'Pokaż wpis zaraz po zatwierdzeniu, bez aprobowania przez administratora.';
$lang['help_smiley'] = 'Zamienia j tekstowe emotikonki na emotikonki obrazkowe i pokaż tabęlę emotikonek po wejściu do formularza. Używa modułu Smiley jeśli jest zainstalowany.';
$lang['help_captcha'] = 'To odblokowuje używanie captcha w formularzu księgi gości. Moduł  Captcha musi być zainstalowany aby ten parametr działał.';
$lang['help_showaddform'] = 'Pokazuje formularz wprowadzania na pierwszej stronie.  Zamienia przycisk nowy wpis.';
$lang['help'] = '<h3>What does it do?</h3>
<p>
    The guestbook module is a content module and a CMSMS tagmodule.
    It gives visitors the ability to leave a message, for example about how they like the website.
</p>

<h3>Security</h3>
<p>
    The user must belong to a group with the \&#039;Modify Guestbook Entries\&#039; permission in order to add, edit, or delete guestbook entries.<br />
    In order to be able to modify the guestbook entry template, \&#039;Modify Guestbook Template\&#039; permission is required.
</p>

<h3>How do I use it?</h3>
<p>
    The easiest way is to create a new page and change the \&quot;Content Type\&quot; to Guestbook. This way you will be able to set the guestbook options as page properties.<br />
    If you want to add the module after some other content you can insert it using the cms_module tag. This will insert the guestbook into your template/page anywhere you wish.<br /> 
    The code would look something like: <code>{cms_module module=\&quot;Guestbook\&quot; number=\&quot;5\&quot; shownow=\&quot;1\&quot; smiley=\&quot;1\&quot;}</code>
</p>

<h3>What Parameters Exist?</h3>
<ul>
<li><em>(optional)</em> textleng=\&quot;1000\&quot; - Sets how many characters can be entered. The default is 1000 characters. This parameter affects both server-side and client-side validation.</li>
<li><em>(optional)</em> number=\&quot;10\&quot; - Maximum number of entries on a page.  Leaving it empty will show 10 entries</li>
<li><em>(optional)</em> timespan=\&quot;600\&quot; - Minimal timespan between posts (in seconds).  Leaving it empty will set timespan=\&quot;0\&quot;</li>
<li><em>(optional)</em> mailnoti=\&quot;youremail@example.com\&quot; - E-mail address to send a notification to if a message was submitted. The CMSMailer module will be used for sending the E-mail if it is installed (otherwise PHP\&#039;s mail function is used).</li>
<li><em>(optional)</em> sortasc=\&quot;1\&quot; - Sort guestbook items in ascending date order (new posts will go to the end).</li>
<li><em>(optional)</em> dateformat=\&quot;dateformat\&quot; - Change the way the Date will display, it takes the PHP format codes</li>
<li><em>(optional)</em> shownow=\&quot;1\&quot; - Shows messages right after submission, without approval by an admin.</li>
<li><em>(optional)</em> smiley=\&quot;1\&quot; - Translate text-based smileys to image smileys and shows the smiley table on the entry submit form. Uses the Smiley module if it is installed</li>
<li><em>(optional)</em> captcha=\&quot;1\&quot; - This will enable captcha on the guestbook entry form. The Captcha module must be installed for this parameter to work.</li>
<li><em>(optional)</em> showaddform=\&quot;1\&quot; - Shows the insert form on the first page.  Replaces the \&quot;New Guestbook Entry\&quot; button.</li>
<li><em>(optional)</em> lang=\&quot;xx_XX\&quot; - Custom locale. For example lang=\&quot;de_DE\&quot;.</li>
</ul>

<h3>What Design potentials are there?</h3>
<p>
    The database template that is used to show a guestbook entry can be edited from the admin panel.
</p>
<p>
    An example stylesheet for the default database template is installed with the module.<br />
    The default stylesheet is deleted when the module is uninstalled and may be overwitten by an upgrade, so you might want to use a copy if you modify it.<br />
    Attach the stylesheet to the page template used.
</p>
<p>
    These variables are assigned in the guestbook entry template:
    <pre>
    date_title
    date
    time
    time_hour_title
    
    sender_title	
    sender
    
    country_title
    country
    
    location_title
    location
    
    e_mail_title
    e_mail		// the E-mail address
    e_mail_cloaked	// the E-mail address with . replaced by <dot> and @ by <at>
    
    homepage_title
    homepage
    
    message_title
    message
    </pre>
</p>
<p>
    In the module directory there\&#039;s a directory called templates where all other templates are stored. You can modify these to fit your needs:
</p>

<strong>Administration</strong>
<p>
admin_entries_top.tpl -> The paganition and row names for the entry list.<br/>
admin_entries_entry.tpl -> The template for an entry in the list of guestbook entries.<br/>
admin_entries_bottom.tpl -> The bottom of the guestbook entries admin form.<br />
admin_entry.tpl-> The form used to insert or edit guestbook entries.<br/>
admin_template_edit.tpl -> Used for editing the guestbook entry database template.
</p>

<strong>Front End</strong>
<p>
newguest.tpl -> Button to go to the entry form<br/>
insertform.tpl -> The guestbook entry form<br />
smiley.tpl -> The smiley table<br/>
prevnext.tpl -> The buttons to go to the previous and next pages (will show only if entries do not fit on one page)<br/>
success_message.tpl-> The message that will show in place of the insert form after successful post submission.
</p>

<p>
    Inside the template directory there\&#039;s a directory called db. This stores the guestbook entry template that is copied to the database during module installation and when the template is restored to default from the admin panel.<br />
    By default the file guestbook_entry-default.tpl is used, but if a (custom) file guestbook_entry.tpl is present, this file will be used instead.
</p>

<h3>Importing gastbuch messages</h3>
<p>
    If you have one of the beta \&quot;gastbuch\&quot; module versions (older than Guestbook-1.0-rc1) installed and want to import your guestbook messages into the Guestbook module, a script is available to do so.
    Simply point your browser to the file gastbuch-import.php in the module folder (for example: http://www.example.com/cms/modules/Guestbook/gastbuch-import.php) before uninstalling the old gastbuch module.
</p>';
$lang['changelog'] = '<ul>
    <li>
        <p><b>Version 1.1</b></p>
        <ul>
            <li>Added Captcha support (in a seperate Captcha module)</li>
            <li>Added timespan parameter (minimal timespan between posts)</li>
            <li>Added location field (for State/Province/City/Town)</li>
            <li>Make use of the Smiley module if it is installed</li>
            <li>Made the module compatible with the cmsmadesimple-1.0 series</li>
            <li>Minimal required CMS version changed to 0.13</li>
        </ul>
    </li>
								    
    <li>
	<p><b>Version 1.0</b></p>
	<ul>
	    <li>Renamed module (from gastbuch) to Guestbook to represent the projects natural language and follow CMS Made Simple module naming conventions.</li>
	    <li>Enabled handling (deleting, activating and deactivating) of multiple guestbook entries from the admin panel.</li>
	    <li>There are now seperate \&#039;Modify Guestbook Entries\&#039; and \&#039;Modify Guestbook Template\&#039; permissions.</li>
	    <li>A default/example stylesheet is installed (and uninstalled) with the module.</li>
	    <li>The database template can be restored to default.</li>
	    <li>Changed to tabbed navigation.</li>
	    <li>Cleanup/rewrite of the guestbook(item) database template and the variables used in it.</li>
	    <li>Translated many variable names and code comments to english.</li>
	    <li>Moved some admin and log messages to the language file.</li>
	    <li>Re-formatted source code for better readability.</li>
	    <li>The module now also works in combination with a PostgreSQL database.</li>
	    <li>Changed the input format for the dateformat parameter from MySQL format to PHP format.</li>
	    <li>A new variable is assigned to the (database) guestbookentry template: $e_mail_cloaked. This is the E-mail address, with @ replaced by <at> and . by <dot>.</li>
	    <li>Extended the notification E-mail, it now sends the new guestbook entry in the notification message.</li>
	    <li>New finnish translation and updated dutch and norwegian translations from the translation center.</li>
	</ul>
    </li>
    <li>
	<p><b>Version 0.9</b></p>
	<ul>
	    <li>The guestbook frontend now uses a database template (in stead of the showmessage*.tpl files) that can be modified from the admin panel</li>
	    <li>The dateformat parameter is now called dateformat (was dateform). Note: this means you will have to recreate any guestbook content pages or manually edit the tables cms_content and cms_content_props</li>
	    <li>New french translation and modified translations for other languages from the translation center</li>
	</ul>
    </li>
    <li>
	<p><b>Version 0.8</b></p>
	Fixed:
	<ul>
	    <li>not working smileys on gastbuch Content page in version 0.7</li>
	</ul>
	Cleanup:
	<ul>
	    <li>mainly removal of unneccary references to the global $gCms</li>
	    <li>renamed email textfield to e_mail (it was called betreff, probably an old subject field)</li>
	</ul>
	Improvements:
	<ul>
	    <li>newly submitted newsentry is shown in the list</li>
	    <li>brackets around submitter country are no longer shown if a country wasn\&#039;t entered</li>
	    <li>translated the lang file to dutch (except for help and changelog)</li>
	    <li>the gastbuch module now makes use of translations entered in the translation center translations.cmsmadesimple.org</li>
	</ul>
	Changed:
	<ul>
	    <li>The template variable name for the country in showmessage.tpl is now called $country (was $countryshow in previous versions)</li>
	</ul>
    </li>
    <li>
	<p><b>Version 0.7</b></p>
	<ul>
	    <li>Added lang attribute to support multiple locales</li>
	    <li>Show insert form on the first page</li>
	    <li>Fixed bug with textlength javascript not working</li>
	    <li>Fixed a few minor bugs</li>
	</ul>
    <li>
	<p><b>Version 0.6</b></p>
	<ul>
	    <li>Redesigned source code for better readability</li>
	    <li>Added lang attribute to support multiple locales</li>
	    <li>Added showaddform parameter</li>
	    <li>Fixed bug with textlength javascript not working in case of \&quot;Content\&quot; content type</li>
	    <li>Merged vorzu and backzu templates into one</li>
	    <li>Added template success_message.tpl</li>
	    <li>Fixed a few minor bugs caused by mismatches in lang variable names</li>
	</ul>
    </li>
    <li>
	<p><b>Version 0.5</b></p>
	<p>
	    The guestbook was modified with better design and functions, for example: 
	    Template based Content, Spam protection for inserted e-mails, etc.
	</p>
    </li>
    <li>
	<p><b>Version 0.4</b></p>
	<p>The gastbuch module is now a new module</p>
    </li>
</ul>
';
$lang['utmz'] = '156861353.1194597526.3.2.utmccn=(referral)|utmcsr=gwiazdasportu.pl|utmcct=/admin/listmodules.php|utmcmd=referral';
$lang['utma'] = '156861353.548217676.1194388561.1195129591.1195205657.7';
$lang['utmb'] = '156861353';
$lang['utmc'] = '156861353';
?>]]></data>
	</file>
	<file>
	  <filename>/lang/ext/pt_PT.php</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[<?php
$lang['module_friendlyname'] = 'Livro de Visitas';
$lang['module_example_stylesheet'] = 'Livro de Visitas (folha de estilo exemplo/defeito)';
$lang['module_example_stylesheet_intro'] = 'Folha de Estilo exemplo/defeito para o m&oacute;dulo Livro de Visitas do CMSMS.
Este poder&aacute; ser substitu&iacute;do quando o m&oacute;dulo for actualizado e ser&aacute; apagado quando
o m&oacute;dulo for removido, sendo assim, fa&ccedil;a uma c&oacute;pia caso o queira modificar.';
$lang['captcha'] = 'Captcha';
$lang['captcha_title'] = 'Por favor introduza o texto na imagem abaixo';
$lang['captcha_failure_message'] = 'O texto da imagem n&atilde;o foi introduzido correctamente';
$lang['timespan'] = 'Tempo m&iacute;nimo entre submiss&otilde;es';
$lang['err_invalid_mode'] = 'Erro: um par&acirc;metro de modo invalido foi especificado. Modos v&aacute;lidos s&atilde;o: %s';
$lang['err_no_entry_id'] = 'Erro: n&atilde;o foi especificado o par&acirc;metro entry_id. Ao utilizar mode=entry o par&acirc;metro entry_id dever&aacute; tamb&eacute;m ser especificado. ';
$lang['err_entry_not_found'] = 'Erro: n&atilde;o existe nenhum livro de visitas com entry_id %s';
$lang['error_template_filenotfound'] = 'Erro: o template %s n&atilde;o foi encontrado!';
$lang['id'] = 'ID';
$lang['sender'] = 'Enviado por';
$lang['email'] = 'Email';
$lang['country'] = 'Pa&iacute;s';
$lang['location'] = 'Localiza&ccedil;&atilde;o';
$lang['homepage'] = 'Homepage ';
$lang['message'] = 'Mensagem';
$lang['posted'] = 'Submetido';
$lang['ip_addr'] = 'Endere&ccedil;o IP';
$lang['alength'] = 'Caracteres dispon&iacute;veis';
$lang['active'] = 'Activo';
$lang['access_denied'] = 'Accesso Negado';
$lang['restore_to_defaults'] = 'Restaurar para defeito';
$lang['restore_to_defaults_warning'] = 'Esta opera&ccedil;&atilde;o ir&aacute; restaurar o conte&uacute;do do template defeito. Todas as altera&ccedil;&otilde;es efectuadas ser&atilde;o perdidas. Tem a certeza que deseja continuar?';
$lang['addgait'] = 'Adicionar mensagem ao livro de visitas';
$lang['postdate'] = 'Data de envio';
$lang['ativi'] = 'Activar';
$lang['deakti'] = 'Desactivar';
$lang['title_mod_admin'] = 'Gerir Mensagems do Livro de Visitas';
$lang['title_mod_settings'] = 'Configura&ccedil;&otilde;es do Livro de Visitas';
$lang['title_tab_admin_templates'] = 'Templates do Livro de Visitas';
$lang['title_tab_admin_template'] = 'Template Livro de Visita';
$lang['title_tab_admin_entrylist_template'] = 'Template Listagem de Mensagens';
$lang['title_tab_admin_entry_template'] = 'Template Mensagem';
$lang['title_tab_admin_form_template'] = 'Template Formul&aacute;rio';
$lang['title_tab_admin_email_template'] = 'Template E-mail';
$lang['title_tab_admin_showform_button_template'] = 'Visualizar Template Formul&aacute;rio';
$lang['templatecontent'] = 'Template de Conte&uacute;do';
$lang['admin_template_modified_logmessage'] = 'Template Livro de Visitas Alterado';
$lang['admin_template_restored_logmessage'] = 'Template Livro de Visitas Restaurado para Default';
$lang['admin_entry_added_logmessage'] = 'Mensagem Livro de Visitas Adicionada';
$lang['admin_entry_modified_logmessage'] = 'Mensagem Livro de Visitas Alterada';
$lang['admin_entry_deleted_logmessage'] = 'Mensagem Livro de Visitas Removida';
$lang['admin_entry_activated_logmessage'] = 'Mensagem Livro de Visitas Activada';
$lang['admin_entry_deactivated_logmessage'] = 'Mensagem Livro de Visitas Desactivida';
$lang['admin_entry_message_nosender'] = 'Por favor introduza nome de autor';
$lang['fieldnames'] = 'Nome de Campos';
$lang['captcha_module_installed'] = 'O m&oacute;dulo Captcha est&aacute; instalado';
$lang['captcha_module_not_installed'] = 'O m&oacute;dulo Captcha n&atilde;o est&aacute; instalado';
$lang['smileys_module_installed'] = 'O m&oacute;dulo Smileys est&aacute; instalado';
$lang['smileys_module_not_installed'] = 'O m&oacute;dulo Smileys n&atilde;o est&aacute; instalado';
$lang['admin_wysiwyg_title'] = 'Utilizar editor WYSIWYG no formul&aacute;rio do gestbook';
$lang['searchsmileys_title'] = 'Utilizar smileys nos resultados de pesquisa';
$lang['save_settings'] = 'Guardar Configura&ccedil;&otilde;es';
$lang['badwords_title'] = 'Palavras que n&atilde;o s&atilde;o autorizadas';
$lang['badwords_replacement_title'] = 'Substituir palavras n&atilde;o autorizadas com';
$lang['nummer'] = 'N&uacute;mero de mensagens por p&aacute;gina';
$lang['postchar'] = 'Tamanho m&aacute;ximo de mensagem';
$lang['emailnot'] = 'E-mail de notifica&ccedil;&atilde;o';
$lang['sortasc'] = 'Ordena&ccedil;&atilde;o crescente';
$lang['smile'] = 'Smiley';
$lang['shmenow'] = 'Mostrar mensagem imediatamente';
$lang['datefora'] = 'Formato da data';
$lang['lang'] = 'Locale (ex. pt_PT)';
$lang['showaddform'] = 'Mostrar formul&aacute;rio de inser&ccedil;&atilde;o imediatamente';
$lang['fabsend'] = 'Por favor introduza o seu nome';
$lang['fmessag'] = 'Por favor introduza uma mensagem';
$lang['femail'] = 'Por favor introduza um endre&ccedil;o de e-mail v&aacute;lido';
$lang['tolong'] = 'Ultrapassou o limite de caracteres, por favor reduza a sua mensagem.';
$lang['toosoon'] = 'O sua &uacute;ltima mensagem foi &agrave; menos de %s segundos. O tempo m&iacute;nimo entre submiss&otilde;es &eacute; de %s segundos';
$lang['fui'] = 'A sua mensagem j&aacute; foi enviada';
$lang['badwords_message'] = 'Estas palavras n&atilde;o s&atilde;o autorizadas: %s';
$lang['showitnow'] = 'A sua mensagem foi inserida. Obrigado!';
$lang['showitlater'] = 'Obrigado! A sua mensagem ser&aacute; incluida uma vez aprovada pelo administrador.';
$lang['msg_back'] = 'voltar';
$lang['inam'] = 'Nome';
$lang['imessag'] = 'A sua mensagem';
$lang['smessage'] = 'Mensagem';
$lang['sdate'] = 'Data';
$lang['ginsert'] = 'Inserir';
$lang['cancel'] = 'Cancelar';
$lang['uhr'] = 'hora';
$lang['e_mailnotibetr'] = 'Nova mensagem no seu Livro de Visitas';
$lang['e_mailnotimessage'] = 'Tem uma nova mensagem no seu Livro de Visitas.';
$lang['neuein'] = 'Nova mensagem no Livro de Visitas';
$lang['einerseit'] = 'uma P&aacute;gina';
$lang['eintragauf'] = 'Submiss&otilde;es em';
$lang['seitpage'] = 'P&aacute;ginas';
$lang['backzu'] = '<< Voltar';
$lang['nextwei'] = 'Seguinte >>';
$lang['prev_text'] = '< ant';
$lang['next_text'] = 'seg >';
$lang['pagination_of'] = 'de';
$lang['title_table_smileys'] = 'Smiley&#039;s';
$lang['ativimes'] = 'Activar esta mensagem?';
$lang['deaktimes'] = 'Desactivar esta mensagem?';
$lang['event_info_GuestbookEntryPosted'] = 'Evento accionado quando for inserida uma nova mensagem';
$lang['event_help_GuestbookEntryPosted'] = '<p>Evento accionado quando for inserida uma nova mensagem.</p>
  	 <h4>Par&acirc;metros</h4>
  	 <ul>
		<li><em>entry_id</em> - O entry id (int)</li>
		<li><em>entry_sender</em> - O nome introduzido pelo autor (string)</li>
		<li><em>entry_email</em> - O endre&ccedil;o e-mail introduzido (string)</li>
		<li><em>entry_homepage</em> - A homepage introduzida (string)</li>
		<li><em>entry_message</em> - A mensagem introduzida (string)</li>
		<li><em>entry_country</em> - O pa&iacute;s introduzido (string)</li>
		<li><em>entry_location</em> - A localiza&ccedil;&atilde;o introduzida (string)</li>
		<li><em>entry_date</em> - A data de submiss&atilde;o (string)</li>
		<li><em>entry_approved</em> - Caso a submiss&atilde;o seja activada de imediato, 1 sim, -1 n&atilde;o (int)</li>
  	 </ul>
';
$lang['event_info_GuestbookEntryDeleted'] = 'Evento accionado quando uma mensagem do Livro de Visitas for removida';
$lang['event_help_GuestbookEntryDeleted'] = 'Evento accionado quando uma mensagem do Livro de Visitas for removida
  	 <h4>Par&acirc;metros</h4>
  	 <ul>
	  	 <li><em>entry_id</em> - O entry id (int)</li>
  	 </ul>
';
$lang['event_info_GuestbookEntryActivated'] = 'Evento accionado quando uma mensagem do Livro de Visitas for activada';
$lang['event_help_GuestbookEntryActivated'] = 'Evento accionado quando uma mensagem do Livro de Visitas for activada
  	 <h4>Par&acirc;metros</h4>
  	 <ul>
  	 <li><em>entry_id</em> - O entry id (int)</li>
  	 </ul>
';
$lang['event_info_GuestbookEntryDeactivated'] = 'Evento accionado quando uma mensagem do Livro de Visitas for desactivada';
$lang['event_help_GuestbookEntryDeactivated'] = 'Evento accionado quando uma mensagem do Livro de Visitas for desactivada
  	 <h4>Par&acirc;metros</h4>
  	 <ul>
  	 <li><em>entry_id</em> - O entry id (int)</li>
  	 </ul>
';
$lang['inposmes'] = 'Certifique-se que a permiss&atilde;o &quot;Modify Guestbook Entries&quot; est&aacute; activada para os utilizadores que ir&atilde;o administrar o Livro de visitas e que a permiss&atilde;o &quot;Modify Guestbook Template&quot; esteja activada para o utilizadores que poder&atilde;o alterar o template do Livro de Visitas.<br/> Anexe tamb&ecirc;m o stylesheet &quot;%s&quot; ao template utilizado para visualizar o Livro de Visitas.';
$lang['moddescription'] = 'Gerir as mensagens e templates do Livro de Visitas.';
$lang['uninstall_pre_message'] = 'As %s mensagens ir&atilde;o ser permanentemente apagadas!';
$lang['uninstall_pre_message_single'] = 'Existe uma mensagem no seu Livro de Visitas que ir&aacute; ser permanentemente apagada!';
$lang['postuninstall'] = 'Livro de Visitas removido.';
$lang['help_textleng'] = 'Define quando caracteres poder&atilde;o ser introduzidos. Por defeito s&atilde;o 1000. Este par&acirc;metro afecta a valida&ccedil;&atilde;o server-side e client-side.';
$lang['help_number'] = 'N&uacute;mero m&aacute;ximo de mensagens por p&aacute;gina.';
$lang['help_timespan'] = 'Tempo m&iacute;nimo entre submiss&otilde;es (segundos).';
$lang['help_mailnoti'] = 'Endere&ccedil;o de e-mail onde receber&aacute; notifica&ccedil;&otilde;es de novas entradas. Caso o m&oacute;dulo CMSMailer esteja instalado este ser&aacute; utilizado para o envio caso contr&aacute;rio as fun&ccedil;&otilde;es mail PHP ser&atilde;o utilizadas.';
$lang['help_sortasc'] = 'Ordenar mensagens do livro de visitas por data crescente (novas submis&otilde;es estar&atilde;o no fim)';
$lang['help_dateformat'] = 'Alterar o formato da data por meio de c&oacute;digos PHP';
$lang['help_shownow'] = 'Inserir mensagens logo ap&oacute;s submiss&atilde;o sem aprova&ccedil;&atilde;o por parte de um administrador';
$lang['help_smiley'] = 'Converter smileys textuais para imagens de smileys e mostrar table de simleys no formul&aacute;rio de submiss&atilde;o. Utiliza o m&oacute;dulo Smiley caso este esteja instalado.';
$lang['help_captcha'] = 'isto ir&aacute; activar captcha no formul&aacute;rio de submiss&atilde;o do Livro de Visitas. Para este par&acirc;metro funcionar o m&oacute;dulo Captach dever&aacute; estar instalado.';
$lang['help_showaddform'] = 'Mostra o formul&aacute;rio de inser&ccedil;&atilde;o na primeira p&aacute;gina. Substitui o bot&atilde;o &quot;Inserir nova mensagem&quot;.';
$lang['help'] = '<h3>What does it do?</h3>
<p>
    The guestbook module is a content module and a CMSMS tagmodule.
    It gives visitors the ability to leave a message, for example about how they like the website.
</p>

<h3>Security</h3>
<p>
    The user must belong to a group with the &#039;Modify Guestbook Entries&#039; permission in order to add, edit, or delete guestbook entries.<br />
    In order to be able to modify the guestbook entry template, &#039;Modify Guestbook Template&#039; permission is required.
</p>

<h3>How do I use it?</h3>
<p>
    The easiest way is to create a new page and change the &quot;Content Type&quot; to Guestbook. This way you will be able to set the guestbook options as page properties.<br />
    If you want to add the module after some other content you can insert it using the cms_module tag. This will insert the guestbook into your template/page anywhere you wish.<br /> 
    The code would look something like: <code>{cms_module module=&quot;Guestbook&quot; number=5 shownow=true smiley=1 mailnoti=you@example.com}</code>
</p>


<h3>What Design potentials are there?</h3>

<p>
    An example stylesheet for the default database template is installed with the module.<br />
    The default stylesheet is deleted when the module is uninstalled and may be overwitten by an upgrade, so you might want to use a copy if you modify it.<br />
    Attach the stylesheet to the page template used.
</p>

<p>
    Most templates used on the module front-end are stored in the database and can be edited from the admin panel.
</p>
<p>
    In the module directory there&#039;s a directory called templates where all other templates are stored. You can modify these to fit your needs:
</p>

<strong>Administration</strong>
<p>
admin_entries_top.tpl -> The paganition and row names for the entry list.<br/>
admin_entries_entry.tpl -> The template for an entry in the list of guestbook entries.<br/>
admin_entries_bottom.tpl -> The bottom of the guestbook entries admin form.<br />
admin_entry.tpl-> The form used to insert or edit guestbook entries.<br/>
admin_template_edit.tpl -> Used for editing the guestbook entry database template.
</p>

<strong>Front End</strong>
<p>
smiley.tpl -> The smiley table, used when the smiley parameter is used and the Smileys module is not installed.<br/>
</p>

<p>
    Inside the template directory there&#039;s a directory called db. This stores the guestbook database templates, which can be edited from the Guestbook admin area.
	The contents of these files is copied to the database during module installation and when a template is restored to default from the admin panel.<br />
	By default the files that come with the module (names ending with -default.tpl) are used, but if a (custom) file is present where -default is left out in the name, this file will be used instead.
</p>
		
<h3>Importing gastbuch messages</h3>
<p>
    If you are using one of the old &quot;gastbuch&quot; module versions (older than Guestbook-1.0-rc1) and want to import your guestbook messages into the Guestbook module, a script is available to do so.
    Simply point your browser to the file gastbuch-import.php in the module folder (for example: http://www.example.com/cms/modules/Guestbook/gastbuch-import.php) before uninstalling the old gastbuch module.
</p>';
$lang['changelog'] = '<ul>
	<li>
		<p><b>Version 1.1.9</b></p>
		<ul>
			<li>Prevent an E-mail being sent to no address when the mailnoti parameter is not being used</li>
		</ul>
	</li>
	<li>
		<p><b>Version 1.1.8</b></p>
		<ul>
			<li>Fixed too short ip_address field</li>
			<li>Moved templates to a single tab in the admin</li>
		</ul>
	</li>
	<li>
		<p><b>Version 1.1.7</b></p>
		<ul>
			<li>Fixed references to old file locations</li>
			<li>Fixed Javascript warning when WYSIWYG is used</li>
		</ul>
	</li>
	<li>
		<p><b>Version 1.1.6</b></p>
		<ul>
			<li>Fixed character counter not working with FCKeditor</li>
			<li>Moved errormessage to lang file</li>
			<li>Deleted some redundant files</li>;
		</ul>
	</li>
	<li>
		<p><b>Version 1.1.5</b></p>
		<ul>
			<li>Fixed ModuleIsInstalled method always returning false for admin modules/FCKEditorX</li>;
			<li>Fixed character counter always starting at 1000</li>; 
		</ul>
	</li>
	<li>
		<p><b>Version 1.1.4</b></p>
		<ul>
			<li>Fixes breaks in messages not showing in 1.1.3</li>
			<li>Added (optional) basic WYSIWYG on the Guestbook entry form</li>
			<li>Added logging of guestbook entry sender IP address</li>
			<li>Added &quot;Modify Guestbook Settings&quot; permission</li>
		</ul>
	</li>
	<li>
		<p><b>Version 1.1.3</b></p>
		<ul>
			<li>Improved pagination</li>
			<li>Rewrote front-end code to use Smarty for all output</li>
			<li>The front-end Smarty templates now use arrays</li>
			<li>Made most front-end templates editable from the admin</li>
			<li>Added events</li>
			<li>Added bad word filter</i>
		</ul>
	</li>
	<li>
		<p><b>Version 1.1.2</b></p>
		<ul>
			<li>Fixed a bug where the Next button would show when it shouldn&#039;t</li>
			<li>Any guestbook content is deleted on uninstall to prevent fatal errors in cmsmadesimple-1.x</li>
		</ul>
	</li>
	<li>
		<p><b>Version 1.1.1</b></p>
		<ul>
			<li>Compatiblity changes for cmsmadesimple-1.0 and a small bugfix</li>
		</ul>
	</li>
    <li>
        <p><b>Version 1.1</b></p>
        <ul>
            <li>Added Captcha support (in a seperate Captcha module)</li>
            <li>Added timespan parameter (minimal timespan between posts)</li>
            <li>Added location field (for State/Province/City/Town)</li>
            <li>Make use of the Smiley module if it is installed</li>
            <li>Made the module compatible with the cmsmadesimple-1.0 series</li>
            <li>Minimal required CMS version changed to 0.13</li>
        </ul>
    </li>
								    
    <li>
	<p><b>Version 1.0</b></p>
	<ul>
	    <li>Renamed module (from gastbuch) to Guestbook to represent the projects natural language and follow CMS Made Simple module naming conventions.</li>
	    <li>Enabled handling (deleting, activating and deactivating) of multiple guestbook entries from the admin panel.</li>
	    <li>There are now seperate &#039;Modify Guestbook Entries&#039; and &#039;Modify Guestbook Template&#039; permissions.</li>
	    <li>A default/example stylesheet is installed (and uninstalled) with the module.</li>
	    <li>The database template can be restored to default.</li>
	    <li>Changed to tabbed navigation.</li>
	    <li>Cleanup/rewrite of the guestbook(item) database template and the variables used in it.</li>
	    <li>Translated many variable names and code comments to english.</li>
	    <li>Moved some admin and log messages to the language file.</li>
	    <li>Re-formatted source code for better readability.</li>
	    <li>The module now also works in combination with a PostgreSQL database.</li>
	    <li>Changed the input format for the dateformat parameter from MySQL format to PHP format.</li>
	    <li>A new variable is assigned to the (database) guestbookentry template: $e_mail_cloaked. This is the E-mail address, with @ replaced by <at> and . by <dot>.</li>
	    <li>Extended the notification E-mail, it now sends the new guestbook entry in the notification message.</li>
	    <li>New finnish translation and updated dutch and norwegian translations from the translation center.</li>
	</ul>
    </li>
    <li>
	<p><b>Version 0.9</b></p>
	<ul>
	    <li>The guestbook frontend now uses a database template (in stead of the showmessage*.tpl files) that can be modified from the admin panel</li>
	    <li>The dateformat parameter is now called dateformat (was dateform). Note: this means you will have to recreate any guestbook content pages or manually edit the tables cms_content and cms_content_props</li>
	    <li>New french translation and modified translations for other languages from the translation center</li>
	</ul>
    </li>
    <li>
	<p><b>Version 0.8</b></p>
	Fixed:
	<ul>
	    <li>not working smileys on gastbuch Content page in version 0.7</li>
	</ul>
	Cleanup:
	<ul>
	    <li>mainly removal of unneccary references to the global $gCms</li>
	    <li>renamed email textfield to e_mail (it was called betreff, probably an old subject field)</li>
	</ul>
	Improvements:
	<ul>
	    <li>newly submitted newsentry is shown in the list</li>
	    <li>brackets around submitter country are no longer shown if a country wasn&#039;t entered</li>
	    <li>translated the lang file to dutch (except for help and changelog)</li>
	    <li>the gastbuch module now makes use of translations entered in the translation center translations.cmsmadesimple.org</li>
	</ul>
	Changed:
	<ul>
	    <li>The template variable name for the country in showmessage.tpl is now called $country (was $countryshow in previous versions)</li>
	</ul>
    </li>
    <li>
	<p><b>Version 0.7</b></p>
	<ul>
	    <li>Added lang attribute to support multiple locales</li>
	    <li>Show insert form on the first page</li>
	    <li>Fixed bug with textlength javascript not working</li>
	    <li>Fixed a few minor bugs</li>
	</ul>
    <li>
	<p><b>Version 0.6</b></p>
	<ul>
	    <li>Redesigned source code for better readability</li>
	    <li>Added lang attribute to support multiple locales</li>
	    <li>Added showaddform parameter</li>
	    <li>Fixed bug with textlength javascript not working in case of &quot;Content&quot; content type</li>
	    <li>Merged vorzu and backzu templates into one</li>
	    <li>Added template success_message.tpl</li>
	    <li>Fixed a few minor bugs caused by mismatches in lang variable names</li>
	</ul>
    </li>
    <li>
	<p><b>Version 0.5</b></p>
	<p>
	    The guestbook was modified with better design and functions, for example: 
	    Template based Content, Spam protection for inserted e-mails, etc.
	</p>
    </li>
    <li>
	<p><b>Version 0.4</b></p>
	<p>The gastbuch module is now a new module</p>
    </li>
</ul>
';
$lang['utma'] = '156861353.215197743.1174495322.1176911824.1176977357.13';
$lang['utmz'] = '156861353.1176301086.6.2.utmccn=(referral)|utmcsr=cerebellum:82|utmcct=/index.php/Server|utmcmd=referral';
$lang['utmc'] = '156861353';
?>]]></data>
	</file>
	<file>
	  <filename>/lang/ext/ru_RU.php</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[<?php
$lang['module_friendlyname'] = 'Гостевая книга';
$lang['default_guestbook_name'] = 'по умолчанию';
$lang['default_guestbook_descr'] = 'Первая/по умолчанию гостевая книга';
$lang['module_example_stylesheet'] = 'Гостевая книга (по-умолчанию/пример таблицы стилей) ';
$lang['module_example_stylesheet_intro'] = 'Таблица стилей  для модуля Гостевая книга CMSMS. 
Может быть перезаписана в случае обновления модуля а также удалена при деинсталляции, поэтому сделайте резервную копию если вы модифицировали её. ';
$lang['captcha'] = 'Каптча';
$lang['captcha_title'] = 'Пожалуйста введите текст изображенный на картинке';
$lang['captcha_failure_message'] = 'Текст изображенный на картинке был введен неверно.';
$lang['timespan'] = 'Минимальный отрезок времени между двумя сообщениями';
$lang['err_invalid_mode'] = 'Ошибка: был указан неверный параметр. Правильные режимы: %s.';
$lang['err_no_entry_id'] = 'Ошибка: не задан enrty_id. В случае mode=entry, entry_id должен быть тоже указан.';
$lang['err_entry_not_found'] = 'Ошибка: не существует запись гостевой книги с entry_id %s';
$lang['error_template_filenotfound'] = 'Ошибка: файл шаблона %s не был найден!';
$lang['default'] = 'По умолчанию';
$lang['add_guestbook'] = 'Создать новую гостевую книгу';
$lang['adding_guestbook'] = 'Добавить новую гостевую книгу';
$lang['editing_guestbook'] = 'Изменить существующую гостевую книгу';
$lang['set_as_default'] = 'Установить по умолчанию';
$lang['confirm_set_as_default'] = 'Установить эту гостевую книгу, как по умолчанию?';
$lang['confirm_delete_guestbook'] = 'Удалить гостевую книгу с  ID %s? %s записи внутри будут удалены!';
$lang['id'] = 'ID';
$lang['date'] = 'Дата';
$lang['sender'] = 'Отправитель';
$lang['email'] = 'Email';
$lang['country'] = 'Страна';
$lang['location'] = 'Местоположение';
$lang['homepage'] = 'Домашняя страница';
$lang['message'] = 'Сообщение';
$lang['posted'] = 'Опубликовано';
$lang['ip_addr'] = 'IP адрес';
$lang['alength'] = 'Осталось символов';
$lang['active'] = 'Активный';
$lang['access_denied'] = 'Доступ запрещён';
$lang['restore_to_defaults'] = 'Восстановить шаблоны по-умолчанию';
$lang['restore_to_defaults_warning'] = 'Эта операция вернет содержание всех шаблонов к значениям по-умолчанию. Все сделанные вами изменения в шаблонах будут безвозвратно потеряны. Вы уверены, что хотите продолжить?';
$lang['addgait'] = 'Добавить запись';
$lang['postdate'] = 'Дата';
$lang['ativi'] = 'Активировать';
$lang['deakti'] = 'Деактивировать';
$lang['title_mod_admin'] = 'Управление записями книги';
$lang['tabname_guestbooks'] = 'Гостевые книги';
$lang['tabname_entries'] = 'Записи';
$lang['title_mod_templates'] = 'Шаблоны';
$lang['tabname_settings'] = 'Настройки модуля';
$lang['title_tab_admin_templates'] = 'Шаблоны Гостевой книги';
$lang['title_tab_admin_template'] = 'Шаблон Гостевой книги';
$lang['title_tab_admin_entrylist_template'] = 'Шаблон списка записей';
$lang['title_tab_admin_entry_template'] = 'Шаблон записи';
$lang['title_tab_admin_form_template'] = 'Шаблон формы новой записи';
$lang['title_tab_admin_email_template'] = 'Шаблон E-mail';
$lang['title_tab_admin_showform_button_template'] = 'Шаблон формы перехода к записи';
$lang['templatecontent'] = 'Содержимое шаблона';
$lang['admin_template_modified_logmessage'] = 'Модифицированный шаблон гостевой книги';
$lang['admin_template_restored_logmessage'] = 'Восстановленный стандартный шаблон';
$lang['admin_entry_added_logmessage'] = 'Добавленная запись';
$lang['admin_entry_modified_logmessage'] = 'Модифицированная запись';
$lang['admin_entry_deleted_logmessage'] = 'Удаленная запись';
$lang['admin_entry_activated_logmessage'] = 'Активированная запись';
$lang['admin_entry_deactivated_logmessage'] = 'Деактивированная запись';
$lang['admin_entry_message_nosender'] = 'Пожалуйста, введите имя отправителя';
$lang['wrong_date_format'] = 'Формат даты должен иметь следующий вид: YYYY-MM-DD HH:MM:SS';
$lang['fieldnames'] = 'Наименования полей';
$lang['captcha_module_installed'] = 'Модуль Captcha установлен';
$lang['captcha_module_not_installed'] = 'Модуль Captcha не установлен';
$lang['smileys_module_installed'] = 'Модуль Smileys установлен';
$lang['smileys_module_not_installed'] = 'Модуль Smileys не установлен';
$lang['preferences_title'] = 'Настройки гостевой книги';
$lang['admin_wysiwyg_title'] = 'Использовать WYSIWYG при добавлении записей';
$lang['searchsmileys_title'] = 'Использовать смайлы в результатах поиска';
$lang['save_settings'] = 'Сохранить изменения';
$lang['settings_saved'] = 'Настройки были успешно обновлены.';
$lang['badwords_title'] = 'Запрещенные слова';
$lang['badwords_replacement_title'] = 'Заместить запрещенные слова на';
$lang['admin_entries_per_page_title'] = 'Количество сообщений на странице (в панели управления)';
$lang['description'] = 'Описание';
$lang['nummer'] = 'Количество сообщений на странице';
$lang['postchar'] = 'Максимально разрешенная длина сообщения';
$lang['emailnot'] = 'Email для уведомлений';
$lang['sortasc'] = 'Сортировать по-возрастанию';
$lang['smile'] = 'Смайлы';
$lang['shmenow'] = 'Показать сообщение немедленно (без премодерации)';
$lang['datefora'] = 'Формат даты';
$lang['lang'] = 'Локализация (например en_US)';
$lang['showaddform'] = 'По-умолчанию показать форму добавления записи';
$lang['fabsend'] = 'Пожалуйста, укажите Ваше имя';
$lang['fmessag'] = 'Пожалуйста, введите текст сообщения';
$lang['femail'] = 'Пожалуйста, укажите корректный E-Mail адрес';
$lang['tolong'] = 'Слишком много символов. Пожалуйста, сделайте сообщение короче.';
$lang['toosoon'] = 'Вы отправили Ваше предыдущее сообщение всего %s секунд назад. Вы можете отправлять сообщения не чаще %s секунд.';
$lang['fui'] = 'Ваше сообщение уже отослано';
$lang['badwords_message'] = 'Эти слова запрещены: %s';
$lang['showitnow'] = 'Ваше сообщение добавлено. Спасибо!';
$lang['showitlater'] = 'Спасибо! Сообщение появится, как только пройдёт проверку модератора.';
$lang['msg_back'] = 'назад';
$lang['inam'] = 'Имя';
$lang['imessag'] = 'Ваше сообщение';
$lang['smessage'] = 'Сообщение';
$lang['sdate'] = 'Дата';
$lang['ginsert'] = 'Добавить';
$lang['cancel'] = 'Отменить';
$lang['uhr'] = 'час';
$lang['e_mailnotibetr'] = 'Новая запись в Вашей гостевой книге';
$lang['e_mailnotimessage'] = 'В Вашей гостевой книге есть новое сообщение.';
$lang['neuein'] = 'Новая запись гостевой книги';
$lang['einerseit'] = 'одна страница';
$lang['eintragauf'] = 'всего';
$lang['seitpage'] = 'страниц';
$lang['backzu'] = '<< назад';
$lang['nextwei'] = 'вперед >>';
$lang['first_text'] = '<<';
$lang['prev_text'] = '<';
$lang['next_text'] = '>';
$lang['last_text'] = '>>';
$lang['pagination_of'] = 'из';
$lang['title_table_smileys'] = 'Смайлы';
$lang['ativimes'] = 'Активировать это сообщение?';
$lang['deaktimes'] = 'Деактивировать это сообщение?';
$lang['event_info_GuestbookEntryPosted'] = 'Событие срабатывает при добавлении новой записи в гостевую книгу';
$lang['event_help_GuestbookEntryPosted'] = '<p>Событие вызывается при добавлении новой записи в гостевую книгу.</p>
	<h4>Параметры:</h4>
	<ul>
		<li><em>entry_id</em> – Идентификатор (Id) записи (целое)</li>
		<li><em>entry_sender</em> – Указанное имя отправителя (строка)</li>
		<li><em>entry_email</em> – Указанный e-mail адресс (строка)</li>
		<li><em>entry_homepage</em> – Указанная домашняя страница (строка)</li>
		<li><em>entry_message</em> – Текст сообщения (строка)</li>
		<li><em>entry_country</em> – Указанная страна (строка)</li>
		<li><em>entry_location</em> – Указанное местоположение (строка)</li>
		<li><em>entry_date</em> – Дата добавления записи (строка)</li>
		<li><em>entry_approved</em> – Запись активирована: 1 = да, -1 = нет (целое)</li>
  	 </ul>
';
$lang['event_info_GuestbookEntryDeleted'] = 'Событие срабатывает при удалении записи аз гостевой книги';
$lang['event_help_GuestbookEntryDeleted'] = '<p>Событие срабатывает при удалении записи аз гостевой книги.</p>
	<h4>Параметры:</h4>
	<ul>
		<li><em>entry_id</em> – Идентификатор (Id) записи (целое)</li>
	</ul>
';
$lang['event_info_GuestbookEntryActivated'] = 'Событие срабатывает при активации записи гостевой книги';
$lang['event_help_GuestbookEntryActivated'] = '<p>Событие срабатывает при активации записи гостевой книги.</p>
	<h4>Параметры:</h4>
	<ul>
		<li><em>entry_id</em> – Идентификатор (Id) записи (целое)</li>
	</ul>
';
$lang['event_info_GuestbookEntryDeactivated'] = 'Событие срабатывает при деактивации записи гостевой книги';
$lang['event_help_GuestbookEntryDeactivated'] = '<p>Событие срабатывает при деактивации записи гостевой книги.</p>
	<h4>Параметры:</h4>
	<ul>
		<li><em>entry_id</em> – Идентификатор (Id) записи (целое)</li>
	</ul>
';
$lang['inposmes'] = 'Для управления записями Гостевой Книги необходимо наличие права "Modify Guestbook Entries". Для изменения шаблонов Гостевой Книги необходимо наличие права "Modify Guestbook Template". Не забудьте назначить соответствующие права ответственным пользователям.<br />
Необходимо присоединить стить "%s" к шаблону, используемому при отображении страниц Гостевой Книги.';
$lang['moddescription'] = 'Управление записями и шаблонами Гостевой Книги.';
$lang['uninstall_pre_message'] = '%s записей Гостевой Книги будут безвозвратно удалены!';
$lang['uninstall_pre_message_single'] = '1 запись Гостевой Книги будет безвозвратно удалена!';
$lang['postuninstall'] = 'Гостевая успешно удалена.';
$lang['help_mode'] = '"guestbook", "form", "entrylist" или "entry"';
$lang['help_show_entry'] = 'ID записи для показа (mode="entry" is assumed)';
$lang['help_guestbook'] = 'ID Гостевой книги';
$lang['help_textleng'] = 'Устанавливает, сколько символов могут быть введены. По умолчанию составляет 1000 символов. Этот параметр влияет как на серверную, так и клиентскую проверку.';
$lang['help_number'] = 'Максимальное число записей, отображаемых на странице.';
$lang['help_timespan'] = 'Минимальный отрезок времени между сообщениями (в секундах).';
$lang['hide_insertbutton_after_post'] = 'Когда сообщение будет опубликовано, кнопка вставки не будет отображаться.';
$lang['help_mailnoti'] = 'Адрес электронной почты, чтобы отправить уведомление, если сообщение было отправлено. Модуль CMSMailer будет использоваться для отправки электронной почты, если она установлена (в противном случае будет использоваться функция PHP Mail).
';
$lang['help_sortasc'] = 'Сортировать элементы гостевой книги по возрастанию даты добавления(новые сообщениями будут идти к концу).';
$lang['help_dateformat'] = 'Изменения способа отображения даты, принимаются коды в формате PHP';
$lang['help_shownow'] = 'Показывает сообщения сразу после отправки, без одобрения администратора.';
$lang['help_smiley'] = 'Переводит текстовые смайлы в графические и показывает таблицу смайлов на форме отправки записи. Работает, если модуль Smiley установлен.';
$lang['help_captcha'] = 'Позволяет использовать каптчу для формы гостевой книги. Модуль Captcha должен быть установлен, чтобы этот параметр работал.';
$lang['help_showaddform'] = 'Показывает форму на первой странице.  Замещает кнопку \\"Новые записи гостевой книги\\".';
$lang['help'] = '<h3>What does it do?</h3>
<p>
    The guestbook module is a content module and a CMSMS tagmodule.
    It gives visitors the ability to leave a message, for example about how they like the website.
</p>

<h3>Security</h3>
<p>
    The user must belong to a group with the \'Modify Guestbook Entries\' permission in order to add, edit, or delete guestbook entries.<br />
    In order to be able to modify the guestbook entry template, \'Modify Guestbook Template\' permission is required.
</p>

<h3>How do I use it?</h3>
<p>
    The easiest way is to create a new page and change the \\"Content Type\\" to Guestbook. This way you will be able to set the guestbook options as page properties.<br />
    If you want to add the module after some other content you can insert it using the cms_module tag. This will insert the guestbook into your template/page anywhere you wish.<br /> 
    The code would look something like: <code>{cms_module module=\\"Guestbook\\" number=5 shownow=true smiley=1 mailnoti=you@example.com}</code>
</p>


<h3>What Design potentials are there?</h3>

<p>
    An example stylesheet for the default database template is installed with the module.<br />
    The default stylesheet is deleted when the module is uninstalled and may be overwitten by an upgrade, so you might want to use a copy if you modify it.<br />
    Attach the stylesheet to the page template used.
</p>

<p>
    Most templates used on the module front-end are stored in the database and can be edited from the admin panel.
</p>
<p>
    In the module directory there\'s a directory called templates where all other templates are stored. You can modify these to fit your needs:
</p>

<strong>Administration</strong>
<p>
admin_entries_top.tpl -> The paganition and row names for the entry list.<br/>
admin_entries_entry.tpl -> The template for an entry in the list of guestbook entries.<br/>
admin_entries_bottom.tpl -> The bottom of the guestbook entries admin form.<br />
admin_entry.tpl-> The form used to insert or edit guestbook entries.<br/>
admin_template_edit.tpl -> Used for editing the guestbook entry database template.
</p>

<strong>Front End</strong>
<p>
smiley.tpl -> The smiley table, used when the smiley parameter is used and the Smileys module is not installed.<br/>
</p>

<p>
    Inside the template directory there\'s a directory called db. This stores the guestbook database templates, which can be edited from the Guestbook admin area.
	The contents of these files is copied to the database during module installation and when a template is restored to default from the admin panel.<br />
	By default the files that come with the module (names ending with -default.tpl) are used, but if a (custom) file is present where -default is left out in the name, this file will be used instead.
</p>
		
<h3>Importing gastbuch messages</h3>
<p>
    If you are using one of the old \\"gastbuch\\" module versions (older than Guestbook-1.0-rc1) and want to import your guestbook messages into the Guestbook module, a script is available to do so.
    Simply point your browser to the file gastbuch-import.php in the module folder (for example: http://www.example.com/cms/modules/Guestbook/gastbuch-import.php) before uninstalling the old gastbuch module.
</p>';
$lang['changelog'] = '<ul>
	<li>
		<p><b>Version 1.1.9</b></p>
		<ul>
			<li>Prevent an E-mail being sent to no address when the mailnoti parameter is not being used</li>
		</ul>
	</li>
	<li>
		<p><b>Version 1.1.8</b></p>
		<ul>
			<li>Fixed too short ip_address field</li>
			<li>Moved templates to a single tab in the admin</li>
		</ul>
	</li>
	<li>
		<p><b>Version 1.1.7</b></p>
		<ul>
			<li>Fixed references to old file locations</li>
			<li>Fixed Javascript warning when WYSIWYG is used</li>
		</ul>
	</li>
	<li>
		<p><b>Version 1.1.6</b></p>
		<ul>
			<li>Fixed character counter not working with FCKeditor</li>
			<li>Moved errormessage to lang file</li>
			<li>Deleted some redundant files</li>;
		</ul>
	</li>
	<li>
		<p><b>Version 1.1.5</b></p>
		<ul>
			<li>Fixed ModuleIsInstalled method always returning false for admin modules/FCKEditorX</li>;
			<li>Fixed character counter always starting at 1000</li>; 
		</ul>
	</li>
	<li>
		<p><b>Version 1.1.4</b></p>
		<ul>
			<li>Fixes breaks in messages not showing in 1.1.3</li>
			<li>Added (optional) basic WYSIWYG on the Guestbook entry form</li>
			<li>Added logging of guestbook entry sender IP address</li>
			<li>Added \\"Modify Guestbook Settings\\" permission</li>
		</ul>
	</li>
	<li>
		<p><b>Version 1.1.3</b></p>
		<ul>
			<li>Improved pagination</li>
			<li>Rewrote front-end code to use Smarty for all output</li>
			<li>The front-end Smarty templates now use arrays</li>
			<li>Made most front-end templates editable from the admin</li>
			<li>Added events</li>
			<li>Added bad word filter</i>
		</ul>
	</li>
	<li>
		<p><b>Version 1.1.2</b></p>
		<ul>
			<li>Fixed a bug where the Next button would show when it shouldn\'t</li>
			<li>Any guestbook content is deleted on uninstall to prevent fatal errors in cmsmadesimple-1.x</li>
		</ul>
	</li>
	<li>
		<p><b>Version 1.1.1</b></p>
		<ul>
			<li>Compatiblity changes for cmsmadesimple-1.0 and a small bugfix</li>
		</ul>
	</li>
    <li>
        <p><b>Version 1.1</b></p>
        <ul>
            <li>Added Captcha support (in a seperate Captcha module)</li>
            <li>Added timespan parameter (minimal timespan between posts)</li>
            <li>Added location field (for State/Province/City/Town)</li>
            <li>Make use of the Smiley module if it is installed</li>
            <li>Made the module compatible with the cmsmadesimple-1.0 series</li>
            <li>Minimal required CMS version changed to 0.13</li>
        </ul>
    </li>
								    
    <li>
	<p><b>Version 1.0</b></p>
	<ul>
	    <li>Renamed module (from gastbuch) to Guestbook to represent the projects natural language and follow CMS Made Simple module naming conventions.</li>
	    <li>Enabled handling (deleting, activating and deactivating) of multiple guestbook entries from the admin panel.</li>
	    <li>There are now seperate \'Modify Guestbook Entries\' and \'Modify Guestbook Template\' permissions.</li>
	    <li>A default/example stylesheet is installed (and uninstalled) with the module.</li>
	    <li>The database template can be restored to default.</li>
	    <li>Changed to tabbed navigation.</li>
	    <li>Cleanup/rewrite of the guestbook(item) database template and the variables used in it.</li>
	    <li>Translated many variable names and code comments to english.</li>
	    <li>Moved some admin and log messages to the language file.</li>
	    <li>Re-formatted source code for better readability.</li>
	    <li>The module now also works in combination with a PostgreSQL database.</li>
	    <li>Changed the input format for the dateformat parameter from MySQL format to PHP format.</li>
	    <li>A new variable is assigned to the (database) guestbookentry template: $e_mail_cloaked. This is the E-mail address, with @ replaced by <at> and . by <dot>.</li>
	    <li>Extended the notification E-mail, it now sends the new guestbook entry in the notification message.</li>
	    <li>New finnish translation and updated dutch and norwegian translations from the translation center.</li>
	</ul>
    </li>
    <li>
	<p><b>Version 0.9</b></p>
	<ul>
	    <li>The guestbook frontend now uses a database template (in stead of the showmessage*.tpl files) that can be modified from the admin panel</li>
	    <li>The dateformat parameter is now called dateformat (was dateform). Note: this means you will have to recreate any guestbook content pages or manually edit the tables cms_content and cms_content_props</li>
	    <li>New french translation and modified translations for other languages from the translation center</li>
	</ul>
    </li>
    <li>
	<p><b>Version 0.8</b></p>
	Fixed:
	<ul>
	    <li>not working smileys on gastbuch Content page in version 0.7</li>
	</ul>
	Cleanup:
	<ul>
	    <li>mainly removal of unneccary references to the global $gCms</li>
	    <li>renamed email textfield to e_mail (it was called betreff, probably an old subject field)</li>
	</ul>
	Improvements:
	<ul>
	    <li>newly submitted newsentry is shown in the list</li>
	    <li>brackets around submitter country are no longer shown if a country wasn\'t entered</li>
	    <li>translated the lang file to dutch (except for help and changelog)</li>
	    <li>the gastbuch module now makes use of translations entered in the translation center translations.cmsmadesimple.org</li>
	</ul>
	Changed:
	<ul>
	    <li>The template variable name for the country in showmessage.tpl is now called $country (was $countryshow in previous versions)</li>
	</ul>
    </li>
    <li>
	<p><b>Version 0.7</b></p>
	<ul>
	    <li>Added lang attribute to support multiple locales</li>
	    <li>Show insert form on the first page</li>
	    <li>Fixed bug with textlength javascript not working</li>
	    <li>Fixed a few minor bugs</li>
	</ul>
    <li>
	<p><b>Version 0.6</b></p>
	<ul>
	    <li>Redesigned source code for better readability</li>
	    <li>Added lang attribute to support multiple locales</li>
	    <li>Added showaddform parameter</li>
	    <li>Fixed bug with textlength javascript not working in case of \\"Content\\" content type</li>
	    <li>Merged vorzu and backzu templates into one</li>
	    <li>Added template success_message.tpl</li>
	    <li>Fixed a few minor bugs caused by mismatches in lang variable names</li>
	</ul>
    </li>
    <li>
	<p><b>Version 0.5</b></p>
	<p>
	    The guestbook was modified with better design and functions, for example: 
	    Template based Content, Spam protection for inserted e-mails, etc.
	</p>
    </li>
    <li>
	<p><b>Version 0.4</b></p>
	<p>The gastbuch module is now a new module</p>
    </li>
</ul>
';
$lang['qca'] = 'P0-636611758-1290773054030';
$lang['utmz'] = '156861353.1293134170.11.6.utmcsr=dev.cmsmadesimple.org|utmccn=(referral)|utmcmd=referral|utmcct=/bug/view/5775';
$lang['utma'] = '156861353.581103809.1290773047.1293121076.1293134170.11';
$lang['utmc'] = '156861353';
$lang['utmb'] = '156861353.2.10.1293134170';
?>]]></data>
	</file>
	<file>
	  <filename>/lang/ext/sk_SK.php</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[<?php
$lang['module_friendlyname'] = 'Kniha n&aacute;v&scaron;tev';
$lang['default_guestbook_name'] = 'prednastaven&eacute;';
$lang['default_guestbook_descr'] = 'Prv&aacute;/prednastaven&aacute; kniha n&aacute;v&scaron;tev';
$lang['module_example_stylesheet'] = 'Knih&aacute; n&aacute;v&scaron;tev (prednastaven&eacute; CSS)';
$lang['module_example_stylesheet_intro'] = 'Prednastaven&eacute; CSS pre modul Knihy n&aacute;v&scaron;tev. V pr&iacute;pade aktualiz&aacute;cie  modulu m&ocirc;že byť prep&iacute;san&yacute;, v pr&iacute;pade odin&scaron;talovania modulu bude odstr&aacute;nen&yacute;. Vytvorte si jeho k&oacute;piu.';
$lang['captcha'] = 'Captcha';
$lang['captcha_title'] = 'Pros&iacute;m, op&iacute;&scaron;te text z obr&aacute;zka';
$lang['captcha_failure_message'] = 'Text z obr&aacute;zka nebol op&iacute;san&yacute; spr&aacute;vne';
$lang['timespan'] = 'Minim&aacute;lny časov&yacute; limit medzi dvoma odoslan&yacute;mi pr&iacute;spevkami';
$lang['err_invalid_mode'] = 'Chyba: bol zadan&yacute; nespr&aacute;vny parameter mode. Povolen&eacute; s&uacute;: %s.';
$lang['err_no_entry_id'] = 'Chyba: nebol zadan&yacute; parameter entry_id. S parametrom mode=entry je nutn&eacute; definovať aj parameter entry_id .';
$lang['err_entry_not_found'] = 'Chyba: nie je žiadn&yacute; pr&iacute;spevok s entry_id %s';
$lang['error_template_filenotfound'] = 'Chyba: s&uacute;bor &scaron;abl&oacute;ny %s nebol n&aacute;jden&yacute;!';
$lang['default'] = 'Prednastaven&eacute;';
$lang['add_guestbook'] = 'Vytvoriť nov&uacute; knihu n&aacute;v&scaron;tev ';
$lang['adding_guestbook'] = 'Pridať nov&uacute; knihu n&aacute;v&scaron;tev ';
$lang['editing_guestbook'] = 'Upraviť knihu n&aacute;v&scaron;tev ';
$lang['set_as_default'] = 'Nastaviť ako prednastaven&uacute;';
$lang['confirm_set_as_default'] = 'Nastaviť knihu ako prednastaven&uacute;';
$lang['confirm_delete_guestbook'] = 'Odstr&aacute;niť knihu s ID %s? %s položiek bude odstr&aacute;nen&yacute;ch';
$lang['id'] = 'Id';
$lang['date'] = 'D&aacute;tum';
$lang['sender'] = 'Odosielateľ';
$lang['email'] = 'E-mail';
$lang['country'] = 'Krajina';
$lang['location'] = 'Mesto';
$lang['homepage'] = 'Web';
$lang['message'] = 'Spr&aacute;va';
$lang['posted'] = 'Odoslan&eacute;';
$lang['ip_addr'] = 'Ip adresa';
$lang['alength'] = 'Počet zost&aacute;vaj&uacute;cich znakov';
$lang['active'] = 'Akt&iacute;vny';
$lang['access_denied'] = 'Pr&iacute;stup zamietnut&yacute;';
$lang['restore_to_defaults'] = 'Vr&aacute;tiť na prednastaven&eacute; hodnoty';
$lang['restore_to_defaults_warning'] = 'T&aacute;to oper&aacute;cie obnov&iacute; obsah &scaron;abl&oacute;ny z prednastaven&eacute;ho obsahu &scaron;abl&oacute;ny.  To znamen&aacute;, že pr&iacute;dete o v&Scaron;etky doteraj&scaron;ie zmeny. Ste si ist&yacute;, že chcete pokračovať?';
$lang['addgait'] = 'Pridať pr&iacute;spevok';
$lang['postdate'] = 'D&aacute;tum odoslania';
$lang['ativi'] = 'Aktivovať';
$lang['deakti'] = 'Deaktivovať';
$lang['title_mod_admin'] = 'Spr&aacute;va pr&iacute;spevkov knihy n&aacute;v&scaron;tev';
$lang['tabname_guestbooks'] = 'Knihy n&aacute;v&scaron;tev';
$lang['tabname_entries'] = 'Pr&iacute;spevky';
$lang['title_mod_templates'] = '&Scaron;abl&oacute;ny';
$lang['tabname_settings'] = 'Nastavenia';
$lang['title_tab_admin_templates'] = '&Scaron;abl&oacute;ny knihy';
$lang['title_tab_admin_template'] = '&Scaron;abl&oacute;na pre knihy';
$lang['title_tab_admin_entrylist_template'] = '&Scaron;alb&oacute;na pre zoznam pr&iacute;spevkov';
$lang['title_tab_admin_entry_template'] = '&Scaron;abl&oacute;na pr&iacute;spevku';
$lang['title_tab_admin_form_template'] = '&Scaron;abl&oacute;na formul&aacute;ra';
$lang['title_tab_admin_email_template'] = '&Scaron;abl&oacute;na e-mailu';
$lang['title_tab_admin_showform_button_template'] = 'Uk&aacute;ž &scaron;abl&oacute;nu formul&aacute;ra';
$lang['templatecontent'] = 'Obsah &Scaron;abl&oacute;ny';
$lang['admin_template_modified_logmessage'] = 'Upraven&aacute; &scaron;abl&oacute;na';
$lang['admin_template_restored_logmessage'] = 'Obnoviť &scaron;abl&oacute;nu na prednastaven&uacute;';
$lang['admin_entry_added_logmessage'] = 'Pridať';
$lang['admin_entry_modified_logmessage'] = 'Upraviť';
$lang['admin_entry_deleted_logmessage'] = 'Odstr&aacute;niť';
$lang['admin_entry_activated_logmessage'] = 'Aktivovať';
$lang['admin_entry_deactivated_logmessage'] = 'Deaktivovať';
$lang['admin_entry_message_nosender'] = 'Pros&iacute;m, vložte odosielateľa';
$lang['wrong_date_format'] = 'Form&aacute;t d&aacute;tumu : YYYY-MM-DD HH:MM:SS';
$lang['fieldnames'] = 'Pole men&aacute;';
$lang['captcha_module_installed'] = 'Captcha modul je nain&scaron;talovan=y';
$lang['captcha_module_not_installed'] = 'Captcha modul nie je nain&scaron;talovan&yacute;';
$lang['smileys_module_installed'] = 'Modul so smajl&iacute;kami je naintalovan&yacute;';
$lang['smileys_module_not_installed'] = 'Modul so smajl&iacute;kami nie je naˇin&scaron;talovan&yacute;';
$lang['preferences_title'] = 'Nastavenia';
$lang['admin_wysiwyg_title'] = 'Použiť  WYSIWYG editor pre prid&aacute;vanie pr&iacute;spevkov';
$lang['searchsmileys_title'] = 'Použiť smajl&iacute;kov vo vyhľad&aacute;van&iacute;';
$lang['save_settings'] = 'Uložiť nastavenia';
$lang['settings_saved'] = 'Nastavenia aktualizovan&eacute;';
$lang['badwords_title'] = 'Slov&aacute;, ktor&eacute; s&uacute; cenz&uacute;rovan&eacute;';
$lang['badwords_replacement_title'] = 'Nahradiť cenz&uacute;rovan&eacute; slov&aacute; s:';
$lang['admin_entries_per_page_title'] = 'Pr&iacute;spevkov na stranu (admin)';
$lang['description'] = 'Popis';
$lang['nummer'] = 'Počet pr&iacute;spevkov na str&aacute;nku';
$lang['postchar'] = 'Maxim&aacute;lna veľkosť spr&aacute;vy';
$lang['emailnot'] = 'Notifikačn&yacute; e-mail';
$lang['sortasc'] = 'Triediť vzostupne';
$lang['smile'] = 'Smejko';
$lang['shmenow'] = 'Zobraziť pr&iacute;spevok ihneď';
$lang['datefora'] = 'Form&aacute;t d&aacute;tumu';
$lang['lang'] = 'Locale (napr. sk_SK)';
$lang['showaddform'] = 'ZObraziť formul&aacute;r pre pridanie ihneď';
$lang['fabsend'] = 'Pros&iacute;m, vložte svoje meni';
$lang['fmessag'] = 'Pros&iacute;m, vložte spr&aacute;vu';
$lang['femail'] = 'Pros&iacute;m, vložte e-mail v spr&aacute;vnom tvae';
$lang['tolong'] = 'Pr&iacute;li&scaron; mnoho znakov. Pros&iacute;m skr&aacute;ťte spr&aacute;vu';
$lang['toosoon'] = 'V&aacute;&scaron; posledn&yacute; pr&iacute;spevok ste posielali pred %s  sekundami. Minim&aacute;lny časov&yacute; limit medz dvoma pr&iacute;spevkami je %s sek&uacute;nd';
$lang['fui'] = 'V&aacute;&scaron; pr&iacute;spevok bolo odoslan&yacute;';
$lang['badwords_message'] = 'Tieto slov&aacute; s&uacute; cenz&uacute;rovan&eacute;: %s';
$lang['showitnow'] = 'V&aacute;&scaron; pr&iacute;spevok bol vložen&yacute;';
$lang['showitlater'] = 'Vďaka! Pr&iacute;spevok bol odoslan&yacute; na schv&aacute;lenie administr&aacute;torovi';
$lang['msg_back'] = 'sp&auml;ť';
$lang['inam'] = 'Meno';
$lang['imessag'] = 'Va&scaron;a spr&aacute;va';
$lang['smessage'] = 'Spr&aacute;va';
$lang['sdate'] = 'D&aacute;tum';
$lang['ginsert'] = 'Vložiť';
$lang['cancel'] = 'Zru&scaron;iť';
$lang['uhr'] = 'hodina';
$lang['e_mailnotibetr'] = 'Nov&yacute; pr&iacute;spevok v knihe';
$lang['e_mailnotimessage'] = 'Nie s&uacute; žiadne pr&iacute;spevky v knihe';
$lang['neuein'] = 'Nov&yacute; pr&iacute;spevok';
$lang['einerseit'] = 'jedna strana';
$lang['eintragauf'] = 'Pr&iacute;spevky na';
$lang['seitpage'] = 'Str&aacute;nky';
$lang['backzu'] = '&amp;lt;&amp;lt; Predch&aacute;dzaj&uacute;ce';
$lang['nextwei'] = 'Ďal&scaron;ie &amp;gt;&amp;gt;';
$lang['first_text'] = '&iota;&lsaquo;';
$lang['prev_text'] = '&laquo;';
$lang['next_text'] = '&raquo;';
$lang['last_text'] = '&rsaquo;&iota;';
$lang['pagination_of'] = 'z';
$lang['title_table_smileys'] = 'Smejkovia';
$lang['ativimes'] = 'Aktivovať tento pr&iacute;spevok?';
$lang['deaktimes'] = 'Deaktivovať tento pr&iacute;spevok?';
$lang['event_info_GuestbookEntryPosted'] = 'Udalosť, ak je pridan&yacute; pr&iacute;spevok';
$lang['event_help_GuestbookEntryPosted'] = '<p>Event triggered when a new Guestbook entry is added.</p>
  	 <h4>Parameters</h4>
  	 <ul>
		<li><em>entry_id</em> - The entry id (int)</li>
		<li><em>entry_sender</em> - The name the sender entered (string)</li>
		<li><em>entry_email</em> - The E-mail address entered (string)</li>
		<li><em>entry_homepage</em> - The homepage entered (string)</li>
		<li><em>entry_message</em> - The message entered (string)</li>
		<li><em>entry_country</em> - The country entered (string)</li>
		<li><em>entry_location</em> - The location entered (string)</li>
		<li><em>entry_date</em> - The post date (string)</li>
		<li><em>entry_approved</em> - Whether the entry is activated at once, 1 if it is, -1 if not (int)</li>
  	 </ul>
';
$lang['event_info_GuestbookEntryDeleted'] = 'Udalosť, keď je pr&iacute;spevok odstr&aacute;nen&yacute;';
$lang['event_help_GuestbookEntryDeleted'] = 'Event triggered when a Guestbook entry is deleted
  	 <h4>Parameters</h4>
  	 <ul>
	  	 <li><em>entry_id</em> - The entry id (int)</li>
  	 </ul>
';
$lang['event_info_GuestbookEntryActivated'] = 'Udalosť, kedy je pr&iacute;spevok aktivovan&yacute;';
$lang['event_help_GuestbookEntryActivated'] = 'Event triggered when a Guestbook entry is activated
  	 <h4>Parameters</h4>
  	 <ul>
  	 <li><em>entry_id</em> - The entry id (int)</li>
  	 </ul>
';
$lang['event_info_GuestbookEntryDeactivated'] = 'Udalosť, kedy je pr&iacute;spevok neakualizovan&yacute;';
$lang['event_help_GuestbookEntryDeactivated'] = 'Event triggered when a Guestbook entry is de-activated
  	 <h4>Parameters</h4>
  	 <ul>
  	 <li><em>entry_id</em> - The entry id (int)</li>
  	 </ul>
';
$lang['inposmes'] = 'Make sure to set the &quot;Modify Guestbook Entries&quot; permission for users who will be administering Guestbook items and &quot;Modify Guestbook Template&quot; permission for users who should be able to modify the guestbook template.<br />Attach the Stylesheet named &quot;%s&quot; to the template used to style the guestbook.';
$lang['moddescription'] = 'Spr&aacute;va pr&iacute;spevkov a &scaron;abl&oacute;ny';
$lang['uninstall_pre_message'] = '%s pr&iacute;spevky bud&uacute; natrvalo odstr&aacute;nen&eacute;!';
$lang['uninstall_pre_message_single'] = 'Jeden pr&iacute;spevok bude odstr&aacute;nen&yacute; z va&scaron;ej knihy!';
$lang['postuninstall'] = 'Kniha &uacute;spe&scaron;ne odin&scaron;talovan&aacute;.';
$lang['help_mode'] = '&quot;guestbook&quot;, &quot;form&quot;, &quot;entrylist&quot; or &quot;entry&quot;';
$lang['help_show_entry'] = 'ID pr&iacute;spevku (za predpokladu mode=&quot;entry&quot; )';
$lang['help_guestbook'] = 'ID knihy';
$lang['help_textleng'] = 'Nastavte počet znakov. Prednastaven&aacute; hodnota je 1000 znakov. Tento parameter je kontrolovan&yacute; nas strane servera (php) a aj nas trane klienta (javascript)';
$lang['help_number'] = 'Maxim&aacute;lny počet pr&iacute;spevkov na str&aacute;nku.';
$lang['help_timespan'] = 'Minim&aacute;lny časov&yacute; limit medzi dvoma pr&iacute;spevkami (v sekund&aacute;ch).';
$lang['hide_insertbutton_after_post'] = 'Ked je pr&iacute;spevok odoslan&yacute;, tlač&iacute;tko pre vloženie sa nebude zobrazovať';
$lang['help_mailnoti'] = 'E-mailov&aacute; adresa na odoslanie notifik&aacute;cie o novom pr&iacute;spevku. Pre odoslanie bude použit&yacute; CMSmailer moduly, v pr&iacute;pade, že nie jen nain&scaron;talovan&yacute;, použije sa funkcia mail() z PHP.';
$lang['help_sortasc'] = 'Triedenie pr&iacute;spevkov vzdostupne podľa d&aacute;tumu (nov&eacute; pr&iacute;spevky bud&uacute; na konci).';
$lang['help_dateformat'] = 'Zmeniť sp&ocirc;sob, ak&yacute;m sa bude zobrazovať d&aacute;tum. Syntax je z PHP';
$lang['help_shownow'] = 'Zobraziť pr&iacute;spevok po odoslan&iacute;, bez schvaľovania administr&aacute;torom';
$lang['help_smiley'] = 'Nahrad&iacute; smejkov v texte obr&aacute;zkov&yacute;mi a zobraz&iacute; tabuľku z možn&yacute;mi smajl&iacute;kami pri  formul&aacute;ri. Modul smejkovia mus&iacute; byť nain&scaron;talovan&yacute;.';
$lang['help_captcha'] = 'Zapnutie kontroly opisovania textu z obr&aacute;zka (Captcha). Captcha modul mus&iacute; byť nain&scaron;talovan&yacute; pre použitie tohto parametra..';
$lang['help_showaddform'] = 'Uk&aacute;zať formul&aacute;r pre pridanie na prvej strane.  Nahrad&iacute; tlač&iacute;tko &quot;Nov&yacute; pr&iacute;spevok&quot;.';
$lang['help'] = '<h3>What does it do?</h3>
<p>
    The guestbook module is a content module and a CMSMS tagmodule.
    It gives visitors the ability to leave a message, for example about how they like the website.
</p>

<h3>Security</h3>
<p>
    The user must belong to a group with the &#039;Modify Guestbook Entries&#039; permission in order to add, edit, or delete guestbook entries.<br />
    In order to be able to modify the guestbook entry template, &#039;Modify Guestbook Template&#039; permission is required.
</p>

<h3>How do I use it?</h3>
<p>
    The easiest way is to create a new page and change the &quot;Content Type&quot; to Guestbook. This way you will be able to set the guestbook options as page properties.<br />
    If you want to add the module after some other content you can insert it using the cms_module tag. This will insert the guestbook into your template/page anywhere you wish.<br /> 
    The code would look something like: <code>{cms_module module=&quot;Guestbook&quot; number=5 shownow=true smiley=1 mailnoti=you@example.com}</code>
</p>


<h3>What Design potentials are there?</h3>

<p>
    An example stylesheet for the default database template is installed with the module.<br />
    The default stylesheet is deleted when the module is uninstalled and may be overwitten by an upgrade, so you might want to use a copy if you modify it.<br />
    Attach the stylesheet to the page template used.
</p>

<p>
    Most templates used on the module front-end are stored in the database and can be edited from the admin panel.
</p>
<p>
    In the module directory there&#039;s a directory called templates where all other templates are stored. You can modify these to fit your needs:
</p>

<strong>Administration</strong>
<p>
admin_entries_top.tpl -> The paganition and row names for the entry list.<br/>
admin_entries_entry.tpl -> The template for an entry in the list of guestbook entries.<br/>
admin_entries_bottom.tpl -> The bottom of the guestbook entries admin form.<br />
admin_entry.tpl-> The form used to insert or edit guestbook entries.<br/>
admin_template_edit.tpl -> Used for editing the guestbook entry database template.
</p>

<strong>Front End</strong>
<p>
smiley.tpl -> The smiley table, used when the smiley parameter is used and the Smileys module is not installed.<br/>
</p>

<p>
    Inside the template directory there&#039;s a directory called db. This stores the guestbook database templates, which can be edited from the Guestbook admin area.
	The contents of these files is copied to the database during module installation and when a template is restored to default from the admin panel.<br />
	By default the files that come with the module (names ending with -default.tpl) are used, but if a (custom) file is present where -default is left out in the name, this file will be used instead.
</p>
		
<h3>Importing gastbuch messages</h3>
<p>
    If you are using one of the old &quot;gastbuch&quot; module versions (older than Guestbook-1.0-rc1) and want to import your guestbook messages into the Guestbook module, a script is available to do so.
    Simply point your browser to the file gastbuch-import.php in the module folder (for example: http://www.example.com/cms/modules/Guestbook/gastbuch-import.php) before uninstalling the old gastbuch module.
</p>';
$lang['changelog'] = '<ul>
	<li>
		<strong>Version 1.3.0</strong><br />
        <span style=&quot;color:#FF0000;font-style:italic;display:block;&quot;>You have to reset your Guestbook templates when upgrade to this version.</span>
		Fixes:
		<ul>
            <li><span style=&quot;font-weight: bold;&quot;>Content type is now USABLE</span></li>
			<li>Fixed page printing in random</li>
            <li>Fixed XSS security issue in next parameter (Pagination class)</li>
            <li>Fixed message list table who can be broken by HTML in message</li>
            <li><span style=&quot;font-style:italic;font-weight: bold;&quot;>Now fully compatible with CMSMS 1.8</span></li>
		</ul>
        Improvements:
        <ul>
            <li>Content type: More date format</li>
            <li>Prettier URL</li>
            <li>Some translation and admin display improvements</li>
            <li>Completely rewrited Pagination module (faster and more secure)</li>
        </ul>
        New Feature:
        <ul>
            <li>Smiley in Front Wysiwyg</li>
            <li>Front date format can be specified in GetDate() in <a href="http://php.net/manual/en/function.date.php">php format</a> (not english only)</li>
            <li>Front date format is now using smarty to get multilanguage capability - date format should be set as <a href="http://www.smarty.net/manual/en/language.modifier.date.format.php">smarty format</a></li>
            <li>Possibility to select all current entry</li>
            <li>Pagination rewrited to be more speed and usefull</li>
            <li>Managing in which guestbook is the entry</li>
            <li>Multiple destination for notification mail</li>
        </ul>
        Minor fixes:
        <ul>
            <li>W3 proof for Javascript</li>
            <li>Few PHP Notices and warnings</li>
        </ul>
	</li>
	<li>
		<strong>Version 1.1.12</strong><br />
		Fixes:
		<ul>
			<li>Fixed bug when posting a new entry with mod_rewrite on (Thanks to blast2007)</li>
			<li>Fixed incorrect stripping of quotes returned by GetTimestamp</li>
		</ul>
	</li>
	<li>
		<strong>Version 1.1.11</strong><br />
		Fixes:
		<ul>
			<li>Fixed module compatibility with latest CMS Made Simple versions (1.5+)</li>
			<li>Fixed pagination not using full table width</li>
			<li>Fixed some small bugs adding/editing an guestbook entry</li>
			<li>Fixed special characters in (translated) pre-uninstall message(s) not being shown correctly</li>
			<li>Fixed language setting from CMS Made Simple Global Settings not being applied</li>
		</ul>
		Improvements:
		<ul>
			<li>You can now edit a guestbook entry date in the backend</li>
			<li>The number of entries shown per page in the backend is now configurable</li>
		</ul>
	</li>
	<li>
		<strong>Version 1.1.10</strong>
		<ul>
			<li>FIX: Removed this warning from the admin panel: &quot;Warning: vsprintf() [function.vsprintf]: Too few arguments in /home/mywebsite/public_html/lib/translation.functions.php on line 62&quot;</li>
			<li>FIX: Insert of new entries failed, when none mandatory fields were removed from the form.</li>
			<li>FIX: Pagination created invalid XHTML (Text attribute removed)</li>
			<li>CHG: Smileys are now inserted on click via JavaScript. Plain text smileys moved into hint.</li>
			<li>FIX: Wrong encoding and HTML entities in notification emails.</li>
			<li>FIX: Enabled translation for pagination &quot;First&quot; and &quot;Last&quot;.</li>
			<li>CHG: Update SmartyPaginate from 1.5 to 1.6-dev</li>
			<li>FIX: Wrong language field &quot;e_mail&quot; in email notification.</li>
			<li>FIX: Module CMSMailer was not detected/used on PHP4</li>
		</ul>
	</li>
	<li>
		<strong>Version 1.1.9</strong>
		<ul>
			<li>Prevent an E-mail being sent to no address when the mailnoti parameter is not being used</li>
		</ul>
	</li>
	<li>
		<strong>Version 1.1.8</strong>
		<ul>
			<li>Fixed too short ip_address field</li>
			<li>Moved templates to a single tab in the admin</li>
		</ul>
	</li>
	<li>
		<strong>Version 1.1.7</strong>
		<ul>
			<li>Fixed references to old file locations</li>
			<li>Fixed Javascript warning when WYSIWYG is used</li>
		</ul>
	</li>
	<li>
		<strong>Version 1.1.6</strong>
		<ul>
			<li>Fixed character counter not working with FCKeditor</li>
			<li>Moved errormessage to lang file</li>
			<li>Deleted some redundant files</li>
		</ul>
	</li>
	<li>
		<strong>Version 1.1.5</strong>
		<ul>
			<li>Fixed ModuleIsInstalled method always returning false for admin modules/FCKEditorX</li>
			<li>Fixed character counter always starting at 1000</li> 
		</ul>
	</li>
	<li>
		<strong>Version 1.1.4</strong>
		<ul>
			<li>Fixes breaks in messages not showing in 1.1.3</li>
			<li>Added (optional) basic WYSIWYG on the Guestbook entry form</li>
			<li>Added logging of guestbook entry sender IP address</li>
			<li>Added &quot;Modify Guestbook Settings&quot; permission</li>
		</ul>
	</li>
	<li>
		<strong>Version 1.1.3</strong>
		<ul>
			<li>Improved pagination</li>
			<li>Rewrote front-end code to use Smarty for all output</li>
			<li>The front-end Smarty templates now use arrays</li>
			<li>Made most front-end templates editable from the admin</li>
			<li>Added events</li>
			<li>Added bad word filter</i>
		</ul>
	</li>
	<li>
		<strong>Version 1.1.2</strong>
		<ul>
			<li>Fixed a bug where the Next button would show when it shouldn&#039;t</li>
			<li>Any guestbook content is deleted on uninstall to prevent fatal errors in cmsmadesimple-1.x</li>
		</ul>
	</li>
	<li>
		<strong>Version 1.1.1</strong>
		<ul>
			<li>Compatiblity changes for cmsmadesimple-1.0 and a small bugfix</li>
		</ul>
	</li>
	<li>
		<strong>Version 1.1</strong>
		<ul>
			<li>Added Captcha support (in a seperate Captcha module)</li>
			<li>Added timespan parameter (minimal timespan between posts)</li>
			<li>Added location field (for State/Province/City/Town)</li>
			<li>Make use of the Smiley module if it is installed</li>
			<li>Made the module compatible with the cmsmadesimple-1.0 series</li>
			<li>Minimal required CMS version changed to 0.13</li>
		</ul>
	</li>
	<li>
		<strong>Version 1.0</strong>
		<ul>
			<li>Renamed module (from gastbuch) to Guestbook to represent the projects natural language and follow CMS Made Simple module naming conventions.</li>
			<li>Enabled handling (deleting, activating and deactivating) of multiple guestbook entries from the admin panel.</li>
			<li>There are now seperate &#039;Modify Guestbook Entries&#039; and &#039;Modify Guestbook Template&#039; permissions.</li>
			<li>A default/example stylesheet is installed (and uninstalled) with the module.</li>
			<li>The database template can be restored to default.</li>
			<li>Changed to tabbed navigation.</li>
			<li>Cleanup/rewrite of the guestbook(item) database template and the variables used in it.</li>
			<li>Translated many variable names and code comments to english.</li>
			<li>Moved some admin and log messages to the language file.</li>
			<li>Re-formatted source code for better readability.</li>
			<li>The module now also works in combination with a PostgreSQL database.</li>
			<li>Changed the input format for the dateformat parameter from MySQL format to PHP format.</li>
			<li>A new variable is assigned to the (database) guestbookentry template: $e_mail_cloaked. This is the E-mail address, with @ replaced by &amp;lt;at&amp;gt; and . by &amp;lt;dot&amp;gt;.</li>
			<li>Extended the notification E-mail, it now sends the new guestbook entry in the notification message.</li>
			<li>New finnish translation and updated dutch and norwegian translations from the translation center.</li>
		</ul>
	</li>
	<li>
		<strong>Version 0.9</strong>
		<ul>
			<li>The guestbook frontend now uses a database template (in stead of the showmessage*.tpl files) that can be modified from the admin panel</li>
			<li>The dateformat parameter is now called dateformat (was dateform). Note: this means you will have to recreate any guestbook content pages or manually edit the tables cms_content and cms_content_props</li>
			<li>New french translation and modified translations for other languages from the translation center</li>
		</ul>
	</li>
	<li>
		<strong>Version 0.8</strong><br />
		Fixed:
		<ul>
			<li>not working smileys on gastbuch Content page in version 0.7</li>
		</ul>
		Cleanup:
		<ul>
			<li>mainly removal of unneccary references to the global $gCms</li>
			<li>renamed email textfield to e_mail (it was called betreff, probably an old subject field)</li>
		</ul>
		Improvements:
		<ul>
			<li>newly submitted newsentry is shown in the list</li>
			<li>brackets around submitter country are no longer shown if a country wasn&#039;t entered</li>
			<li>translated the lang file to dutch (except for help and changelog)</li>
			<li>the gastbuch module now makes use of translations entered in the translation center translations.cmsmadesimple.org</li>
		</ul>
		Changed:
		<ul>
			<li>The template variable name for the country in showmessage.tpl is now called $country (was $countryshow in previous versions)</li>
		</ul>
	</li>
	<li>
		<strong>Version 0.7</strong>
		<ul>
			<li>Added lang attribute to support multiple locales</li>
			<li>Show insert form on the first page</li>
			<li>Fixed bug with textlength javascript not working</li>
			<li>Fixed a few minor bugs</li>
		</ul>
	</li>
	<li>
		<strong>Version 0.6</strong>
		<ul>
			<li>Redesigned source code for better readability</li>
			<li>Added lang attribute to support multiple locales</li>
			<li>Added showaddform parameter</li>
			<li>Fixed bug with textlength javascript not working in case of &quot;Content&quot; content type</li>
			<li>Merged vorzu and backzu templates into one</li>
			<li>Added template success_message.tpl</li>
			<li>Fixed a few minor bugs caused by mismatches in lang variable names</li>
		</ul>
	</li>
	<li>
		<strong>Version 0.5</strong>
		<ul>
			<li>The guestbook was modified with better design and functions, for example: Template based Content, Spam protection for inserted e-mails, etc.</li>
		</ul>
	</li>
	<li>
		<strong>Version 0.4</strong>
		<ul>
			<li>The gastbuch module is now a new module</li>
		</ul>
	</li>
</ul>
';
$lang['utma'] = '156861353.1423109725.1280259016.1284932365.1284936206.43';
$lang['utmz'] = '156861353.1284932365.42.44.utmcsr=dev.cmsmadesimple.org|utmccn=(referral)|utmcmd=referral|utmcct=/';
$lang['qca'] = 'P0-748439131-1280259017524';
$lang['utmc'] = '156861353';
$lang['utmb'] = '156861353';
?>]]></data>
	</file>
	<file>
	  <filename>/lang/ext/sl_SI.php</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[<?php
$lang['module_friendlyname'] = 'Knjiga gostov';
$lang['module_example_stylesheet'] = 'Knjiga gostov (primarna/demo stilska predloga)';
$lang['module_example_stylesheet_intro'] = 'Default/example stylesheet for the CMSMS Guestbook module.
This may be overwritten when the module is upgraded and it will be deleted when 
the module is uninstalled, so make a copy if you want to modify it.';
$lang['captcha'] = 'Varnostna koda';
$lang['captcha_title'] = 'Prepi&scaron;ite besedilo s slike';
$lang['captcha_failure_message'] = 'Niste pravilno prepisali besedila s slike';
$lang['timespan'] = 'Najmanj&scaron;i časovni razmik med vpisi';
$lang['err_invalid_mode'] = 'Napaka: določen je bil napačen parameter. Pravilni parametri so: %s.';
$lang['err_no_entry_id'] = 'Napaka: entry_id parameter ni bil podan. Pri mode=entry, entry_id parameter bi moral biti določen.';
$lang['err_entry_not_found'] = 'Napaka: vnos entry_id %s ne obstaja';
$lang['error_template_filenotfound'] = 'Napaka: datoteka predloge %s ne obstaja';
$lang['id'] = 'Id';
$lang['sender'] = 'Po&scaron;iljatelj';
$lang['email'] = 'E-naslov';
$lang['country'] = 'Država';
$lang['location'] = 'Lokacija';
$lang['homepage'] = 'Spletna stran';
$lang['message'] = 'Sporočilo';
$lang['posted'] = 'Vne&scaron;eno';
$lang['ip_addr'] = 'IP Naslov';
$lang['alength'] = 'Preostale črke';
$lang['active'] = 'Aktivno';
$lang['access_denied'] = 'Dostop zavrnjen';
$lang['restore_to_defaults'] = 'Vrni na osnovno stanje';
$lang['restore_to_defaults_warning'] = 'Operacija bo vrnila nastavitve predloge na osnovno stanje. S tem boste povozili vse vne&scaron;ene spremembe. Ste prepričani, da želite nadaljevati?';
$lang['addgait'] = 'Dodaj vnos';
$lang['postdate'] = 'Datum vnosa';
$lang['ativi'] = 'Aktiviraj';
$lang['deakti'] = 'Deaktiviraj';
$lang['title_mod_admin'] = 'Upravljaj z vnosi';
$lang['title_mod_settings'] = 'Nastavitve knjige gostov';
$lang['title_tab_admin_templates'] = 'Predloge knjige gostov';
$lang['title_tab_admin_template'] = 'Predloga knjige gostov';
$lang['title_tab_admin_entrylist_template'] = 'Predloga seznama vnosov';
$lang['title_tab_admin_entry_template'] = 'Predloga vnosov';
$lang['title_tab_admin_form_template'] = 'Predloga obrazca';
$lang['title_tab_admin_email_template'] = 'Predloga e-naslova';
$lang['title_tab_admin_showform_button_template'] = 'Prikaži predlogo obrazca';
$lang['templatecontent'] = 'Predloga vsebine';
$lang['admin_template_modified_logmessage'] = 'Spremenjena predloga knjige gostov';
$lang['admin_template_restored_logmessage'] = 'Predloga knjige gostov je bila obnovljena v osnovno stanje';
$lang['admin_entry_added_logmessage'] = 'Vpis dodan';
$lang['admin_entry_modified_logmessage'] = 'Vpis spremenjen';
$lang['admin_entry_deleted_logmessage'] = 'Vpis izbrisan';
$lang['admin_entry_activated_logmessage'] = 'Vpis aktiviran';
$lang['admin_entry_deactivated_logmessage'] = 'Vpis deaktiviran';
$lang['admin_entry_message_nosender'] = 'Prosimo vpi&scaron;ite ime po&scaron;iljatelja';
$lang['fieldnames'] = 'Imena polj';
$lang['captcha_module_installed'] = 'Modul varnostne kode in&scaron;taliran';
$lang['captcha_module_not_installed'] = 'Modul varnostne kode ni in&scaron;taliran';
$lang['smileys_module_installed'] = 'Modul nasme&scaron;kov in&scaron;taliran';
$lang['smileys_module_not_installed'] = 'Modul nasme&scaron;kov ni in&scaron;taliran';
$lang['admin_wysiwyg_title'] = 'Uporabi WYSIWYG na predlogi vpisov';
$lang['searchsmileys_title'] = 'Uporabi nasme&scaron;ke v rezultatih iskanja';
$lang['save_settings'] = 'Shrani nastavitve';
$lang['badwords_title'] = 'Nedovoljene besede';
$lang['badwords_replacement_title'] = 'Zamenjaj neprimerne besede z';
$lang['nummer'] = '&Scaron;tevilo vpisov na stran';
$lang['postchar'] = 'Maksimalna velikost sporočila';
$lang['emailnot'] = 'Enaslov obvestil';
$lang['sortasc'] = 'Razvrsti nara&scaron;čujoče (ASC)';
$lang['smile'] = 'Nasme&scaron;ek';
$lang['shmenow'] = 'Prikaži sporočilo takoj';
$lang['datefora'] = 'Format datuma';
$lang['lang'] = 'Lokalizacija (npr. sl_SI)';
$lang['showaddform'] = 'Prikaže vstavni obrazec takoj';
$lang['fabsend'] = 'Prosimo vpi&scaron;ite svoje ime';
$lang['fmessag'] = 'Prosimo vpi&scaron;ite sporočilo';
$lang['femail'] = 'Prosimo vnesite pravilen e-naslov';
$lang['tolong'] = 'Preveč znakov. Prosimo skraj&scaron;ajte sporočilo.';
$lang['toosoon'] = 'Va&scaron; zadnji vpis je bil pred %s sekundami. Najmanj&scaron;i časovni razmik med vpisi je  %s sekund';
$lang['fui'] = 'Va&scaron;e sporočilo je bilo že poslano';
$lang['badwords_message'] = 'Naslednje besede niso dovoljene: %s';
$lang['showitnow'] = 'Va&scaron;e sporočilo je bilo vpisano. Hvala!';
$lang['showitlater'] = 'Hvala! Sporočilo bo prikazano takoj po odobritvi administratorja';
$lang['msg_back'] = 'nazaj';
$lang['inam'] = 'Ime';
$lang['imessag'] = 'Va&scaron;e sporočilo';
$lang['smessage'] = 'Sporočilo';
$lang['sdate'] = 'Datum';
$lang['ginsert'] = 'Vpi&scaron;i';
$lang['cancel'] = 'Prekliči';
$lang['uhr'] = 'ura';
$lang['e_mailnotibetr'] = 'Nov vpis v knjigi gostov';
$lang['e_mailnotimessage'] = 'Imate nov vpis v knjigi gostov';
$lang['neuein'] = 'Nov vpis v knjigi gostov';
$lang['einerseit'] = 'ena Stran';
$lang['eintragauf'] = 'Vpisov na';
$lang['seitpage'] = 'Strani';
$lang['backzu'] = '&amp;lt;&amp;lt; Nazaj';
$lang['nextwei'] = 'Naprej &amp;amp;gt;&amp;amp;gt;';
$lang['first_text'] = '&iota;&lsaquo;';
$lang['prev_text'] = '&laquo;';
$lang['next_text'] = '&raquo;';
$lang['last_text'] = '&rsaquo;&iota;';
$lang['pagination_of'] = 'od';
$lang['title_table_smileys'] = 'Nasme&scaron;ki';
$lang['ativimes'] = 'Aktiviraj sporočilo?';
$lang['deaktimes'] = 'Deaktiviraj sporočilo?';
$lang['event_info_GuestbookEntryPosted'] = 'Dogodek sprožen ob novem vpisu v knjigo gostov';
$lang['event_help_GuestbookEntryPosted'] = '<p>Event triggered when a new Guestbook entry is added.</p>
  	 <h4>Parameters</h4>
  	 <ul>
		<li><em>entry_id</em> - The entry id (int)</li>
		<li><em>entry_sender</em> - The name the sender entered (string)</li>
		<li><em>entry_email</em> - The E-mail address entered (string)</li>
		<li><em>entry_homepage</em> - The homepage entered (string)</li>
		<li><em>entry_message</em> - The message entered (string)</li>
		<li><em>entry_country</em> - The country entered (string)</li>
		<li><em>entry_location</em> - The location entered (string)</li>
		<li><em>entry_date</em> - The post date (string)</li>
		<li><em>entry_approved</em> - Whether the entry is activated at once, 1 if it is, -1 if not (int)</li>
  	 </ul>
';
$lang['event_info_GuestbookEntryDeleted'] = 'Event triggered when a Guestbook entry is deleted';
$lang['event_help_GuestbookEntryDeleted'] = 'Event triggered when a Guestbook entry is deleted
  	 <h4>Parameters</h4>
  	 <ul>
	  	 <li><em>entry_id</em> - The entry id (int)</li>
  	 </ul>
';
$lang['event_info_GuestbookEntryActivated'] = 'Event triggered when a Guestbook entry is activated';
$lang['event_help_GuestbookEntryActivated'] = 'Event triggered when a Guestbook entry is activated
  	 <h4>Parameters</h4>
  	 <ul>
  	 <li><em>entry_id</em> - The entry id (int)</li>
  	 </ul>
';
$lang['event_info_GuestbookEntryDeactivated'] = 'Event triggered when a Guestbook entry is de-activated';
$lang['event_help_GuestbookEntryDeactivated'] = 'Event triggered when a Guestbook entry is de-activated
  	 <h4>Parameters</h4>
  	 <ul>
  	 <li><em>entry_id</em> - The entry id (int)</li>
  	 </ul>
';
$lang['inposmes'] = 'Make sure to set the &quot;Modify Guestbook Entries&quot; permission for users who will be administering Guestbook items and &quot;Modify Guestbook Template&quot; permission for users who should be able to modify the guestbook template.<br />Attach the Stylesheet named &quot;%s&quot; to the template used to style the guestbook.';
$lang['moddescription'] = 'Upravljaj z vpisi in predlogo';
$lang['uninstall_pre_message'] = '%s vpisov v va&scaron;i knjigi gostov bo izbrisanih!';
$lang['uninstall_pre_message_single'] = '1 vpis bo permanentno izbrisan!';
$lang['postuninstall'] = 'Knjiga gostov odstranjena';
$lang['help_textleng'] = 'Določite &scaron;tevilo znakov za vpis. Privzeto &scaron;tevilo znakov je 1000. &Scaron;tevilo vpliva na server-side kot tudi client-side validacijo';
$lang['help_number'] = '&Scaron;tevilo vpisov prikazanih na stran';
$lang['help_timespan'] = 'Najmanj&scaron;i časovni razmik med vpisi (v sekundah).';
$lang['help_mailnoti'] = 'E-naslov za po&scaron;iljanje obvestila o vpisu. Za po&scaron;iljanje bo uporabljen CMSMailer modul, v primeru da le ta ni in&scaron;taliran bo za po&scaron;iljanje uporabljena mail funkcija PHP-ja.';
$lang['help_sortasc'] = 'Razvrsti vpise po datumu nara&scaron;čujoče';
$lang['help_dateformat'] = 'Spremenite način prikaza datuma.';
$lang['help_shownow'] = 'Vpise prikaže takoj po vpisu brez odobritve administratorja';
$lang['help_smiley'] = 'Translate text-based smileys to image smileys and shows the smiley table on the entry submit form. Uses the Smiley module if it is installed.';
$lang['help_captcha'] = 'Omogoči varnostno kodo pri obrazcu za vpis v knjigo gostov. Za pravilno delovanje morate imeti in&scaron;taliran Captcha modul.';
$lang['help_showaddform'] = 'Prikaže obrazec za vpis na prvi strani. Zamenja gumb &quot;nov vpis&quot;.';
$lang['help'] = '<h3>What does it do?</h3>
<p>
    The guestbook module is a content module and a CMSMS tagmodule.
    It gives visitors the ability to leave a message, for example about how they like the website.
</p>

<h3>Security</h3>
<p>
    The user must belong to a group with the &#039;Modify Guestbook Entries&#039; permission in order to add, edit, or delete guestbook entries.<br />
    In order to be able to modify the guestbook entry template, &#039;Modify Guestbook Template&#039; permission is required.
</p>

<h3>How do I use it?</h3>
<p>
    The easiest way is to create a new page and change the &quot;Content Type&quot; to Guestbook. This way you will be able to set the guestbook options as page properties.<br />
    If you want to add the module after some other content you can insert it using the cms_module tag. This will insert the guestbook into your template/page anywhere you wish.<br /> 
    The code would look something like: <code>{cms_module module=&quot;Guestbook&quot; number=5 shownow=true smiley=1 mailnoti=you@example.com}</code>
</p>


<h3>What Design potentials are there?</h3>

<p>
    An example stylesheet for the default database template is installed with the module.<br />
    The default stylesheet is deleted when the module is uninstalled and may be overwitten by an upgrade, so you might want to use a copy if you modify it.<br />
    Attach the stylesheet to the page template used.
</p>

<p>
    Most templates used on the module front-end are stored in the database and can be edited from the admin panel.
</p>
<p>
    In the module directory there&#039;s a directory called templates where all other templates are stored. You can modify these to fit your needs:
</p>

<strong>Administration</strong>
<p>
admin_entries_top.tpl -> The paganition and row names for the entry list.<br/>
admin_entries_entry.tpl -> The template for an entry in the list of guestbook entries.<br/>
admin_entries_bottom.tpl -> The bottom of the guestbook entries admin form.<br />
admin_entry.tpl-> The form used to insert or edit guestbook entries.<br/>
admin_template_edit.tpl -> Used for editing the guestbook entry database template.
</p>

<strong>Front End</strong>
<p>
smiley.tpl -> The smiley table, used when the smiley parameter is used and the Smileys module is not installed.<br/>
</p>

<p>
    Inside the template directory there&#039;s a directory called db. This stores the guestbook database templates, which can be edited from the Guestbook admin area.
	The contents of these files is copied to the database during module installation and when a template is restored to default from the admin panel.<br />
	By default the files that come with the module (names ending with -default.tpl) are used, but if a (custom) file is present where -default is left out in the name, this file will be used instead.
</p>
		
<h3>Importing gastbuch messages</h3>
<p>
    If you are using one of the old &quot;gastbuch&quot; module versions (older than Guestbook-1.0-rc1) and want to import your guestbook messages into the Guestbook module, a script is available to do so.
    Simply point your browser to the file gastbuch-import.php in the module folder (for example: http://www.example.com/cms/modules/Guestbook/gastbuch-import.php) before uninstalling the old gastbuch module.
</p>';
$lang['changelog'] = '<ul>
	<li>
		<p><b>Version 1.1.10</b></p>
		<ul>
			<li>FIX: Removed this warning from the admin panel: &quot;Warning: vsprintf() [function.vsprintf]: Too few arguments in /home/mywebsite/public_html/lib/translation.functions.php on line 62&quot;</li>
			<li>FIX: Insert of new entries failed, when none mandatory fields were removed from the form.</li>
			<li>FIX: Pagination created invalid XHTML (Text attribute removed)</li>
			<li>CHG: Smileys are now inserted on click via JavaScript. Plain text smileys moved into hint.</li>
			<li>FIX: Wrong encoding and HTML entities in notification emails.</li>
			<li>FIX: Enabled translation for pagination &quot;First&quot; and &quot;Last&quot;.</li>
			<li>CHG: Update SmartyPaginate from 1.5 to 1.6-dev</li>
			<li>FIX: Wrong language field &quot;e_mail&quot; in email notification.</li>
			<li>FIX: Module CMSMailer was not detected/used on PHP4</li>
		</ul>
	</li>
	<li>
		<p><b>Version 1.1.9</b></p>
		<ul>
			<li>Prevent an E-mail being sent to no address when the mailnoti parameter is not being used</li>
		</ul>
	</li>
	<li>
		<p><b>Version 1.1.8</b></p>
		<ul>
			<li>Fixed too short ip_address field</li>
			<li>Moved templates to a single tab in the admin</li>
		</ul>
	</li>
	<li>
		<p><b>Version 1.1.7</b></p>
		<ul>
			<li>Fixed references to old file locations</li>
			<li>Fixed Javascript warning when WYSIWYG is used</li>
		</ul>
	</li>
	<li>
		<p><b>Version 1.1.6</b></p>
		<ul>
			<li>Fixed character counter not working with FCKeditor</li>
			<li>Moved errormessage to lang file</li>
			<li>Deleted some redundant files</li>;
		</ul>
	</li>
	<li>
		<p><b>Version 1.1.5</b></p>
		<ul>
			<li>Fixed ModuleIsInstalled method always returning false for admin modules/FCKEditorX</li>;
			<li>Fixed character counter always starting at 1000</li>; 
		</ul>
	</li>
	<li>
		<p><b>Version 1.1.4</b></p>
		<ul>
			<li>Fixes breaks in messages not showing in 1.1.3</li>
			<li>Added (optional) basic WYSIWYG on the Guestbook entry form</li>
			<li>Added logging of guestbook entry sender IP address</li>
			<li>Added &quot;Modify Guestbook Settings&quot; permission</li>
		</ul>
	</li>
	<li>
		<p><b>Version 1.1.3</b></p>
		<ul>
			<li>Improved pagination</li>
			<li>Rewrote front-end code to use Smarty for all output</li>
			<li>The front-end Smarty templates now use arrays</li>
			<li>Made most front-end templates editable from the admin</li>
			<li>Added events</li>
			<li>Added bad word filter</i>
		</ul>
	</li>
	<li>
		<p><b>Version 1.1.2</b></p>
		<ul>
			<li>Fixed a bug where the Next button would show when it shouldn&#039;t</li>
			<li>Any guestbook content is deleted on uninstall to prevent fatal errors in cmsmadesimple-1.x</li>
		</ul>
	</li>
	<li>
		<p><b>Version 1.1.1</b></p>
		<ul>
			<li>Compatiblity changes for cmsmadesimple-1.0 and a small bugfix</li>
		</ul>
	</li>
    <li>
        <p><b>Version 1.1</b></p>
        <ul>
            <li>Added Captcha support (in a seperate Captcha module)</li>
            <li>Added timespan parameter (minimal timespan between posts)</li>
            <li>Added location field (for State/Province/City/Town)</li>
            <li>Make use of the Smiley module if it is installed</li>
            <li>Made the module compatible with the cmsmadesimple-1.0 series</li>
            <li>Minimal required CMS version changed to 0.13</li>
        </ul>
    </li>
								    
    <li>
	<p><b>Version 1.0</b></p>
	<ul>
	    <li>Renamed module (from gastbuch) to Guestbook to represent the projects natural language and follow CMS Made Simple module naming conventions.</li>
	    <li>Enabled handling (deleting, activating and deactivating) of multiple guestbook entries from the admin panel.</li>
	    <li>There are now seperate &#039;Modify Guestbook Entries&#039; and &#039;Modify Guestbook Template&#039; permissions.</li>
	    <li>A default/example stylesheet is installed (and uninstalled) with the module.</li>
	    <li>The database template can be restored to default.</li>
	    <li>Changed to tabbed navigation.</li>
	    <li>Cleanup/rewrite of the guestbook(item) database template and the variables used in it.</li>
	    <li>Translated many variable names and code comments to english.</li>
	    <li>Moved some admin and log messages to the language file.</li>
	    <li>Re-formatted source code for better readability.</li>
	    <li>The module now also works in combination with a PostgreSQL database.</li>
	    <li>Changed the input format for the dateformat parameter from MySQL format to PHP format.</li>
	    <li>A new variable is assigned to the (database) guestbookentry template: $e_mail_cloaked. This is the E-mail address, with @ replaced by <at> and . by <dot>.</li>
	    <li>Extended the notification E-mail, it now sends the new guestbook entry in the notification message.</li>
	    <li>New finnish translation and updated dutch and norwegian translations from the translation center.</li>
	</ul>
    </li>
    <li>
	<p><b>Version 0.9</b></p>
	<ul>
	    <li>The guestbook frontend now uses a database template (in stead of the showmessage*.tpl files) that can be modified from the admin panel</li>
	    <li>The dateformat parameter is now called dateformat (was dateform). Note: this means you will have to recreate any guestbook content pages or manually edit the tables cms_content and cms_content_props</li>
	    <li>New french translation and modified translations for other languages from the translation center</li>
	</ul>
    </li>
    <li>
	<p><b>Version 0.8</b></p>
	Fixed:
	<ul>
	    <li>not working smileys on gastbuch Content page in version 0.7</li>
	</ul>
	Cleanup:
	<ul>
	    <li>mainly removal of unneccary references to the global $gCms</li>
	    <li>renamed email textfield to e_mail (it was called betreff, probably an old subject field)</li>
	</ul>
	Improvements:
	<ul>
	    <li>newly submitted newsentry is shown in the list</li>
	    <li>brackets around submitter country are no longer shown if a country wasn&#039;t entered</li>
	    <li>translated the lang file to dutch (except for help and changelog)</li>
	    <li>the gastbuch module now makes use of translations entered in the translation center translations.cmsmadesimple.org</li>
	</ul>
	Changed:
	<ul>
	    <li>The template variable name for the country in showmessage.tpl is now called $country (was $countryshow in previous versions)</li>
	</ul>
    </li>
    <li>
	<p><b>Version 0.7</b></p>
	<ul>
	    <li>Added lang attribute to support multiple locales</li>
	    <li>Show insert form on the first page</li>
	    <li>Fixed bug with textlength javascript not working</li>
	    <li>Fixed a few minor bugs</li>
	</ul>
    <li>
	<p><b>Version 0.6</b></p>
	<ul>
	    <li>Redesigned source code for better readability</li>
	    <li>Added lang attribute to support multiple locales</li>
	    <li>Added showaddform parameter</li>
	    <li>Fixed bug with textlength javascript not working in case of &quot;Content&quot; content type</li>
	    <li>Merged vorzu and backzu templates into one</li>
	    <li>Added template success_message.tpl</li>
	    <li>Fixed a few minor bugs caused by mismatches in lang variable names</li>
	</ul>
    </li>
    <li>
	<p><b>Version 0.5</b></p>
	<p>
	    The guestbook was modified with better design and functions, for example: 
	    Template based Content, Spam protection for inserted e-mails, etc.
	</p>
    </li>
    <li>
	<p><b>Version 0.4</b></p>
	<p>The gastbuch module is now a new module</p>
    </li>
</ul>
';
$lang['utma'] = '156861353.908992439.1234459012.1234459012.1236414745.2';
$lang['utmz'] = '156861353.1234459566.1.2.utmccn=(organic)|utmcsr=google|utmctr=smarty dump|utmcmd=organic';
$lang['utmb'] = '156861353';
$lang['utmc'] = '156861353';
?>]]></data>
	</file>
	<file>
	  <filename>/lang/ext/sv_SE.php</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[<?php
$lang['module_friendlyname'] = 'G&auml;stbok';
$lang['default_guestbook_name'] = 'standard';
$lang['default_guestbook_descr'] = 'Den f&ouml;rsta/standard g&auml;stboken';
$lang['module_example_stylesheet'] = 'G&auml;stbok (standard-/exempelmall)';
$lang['module_example_stylesheet_intro'] = 'Standard-/exempelmall f&ouml;r G&auml;stboksmodulen. Denna kan komma att skrivas &ouml;vern&auml;r modulen uppgraderas och den kommer att tas bort n&auml;r modulen avinstallerad, s&aring; g&ouml;r en kopia om du vill &auml;ndra den.';
$lang['captcha'] = 'CAPTCHA';
$lang['captcha_title'] = 'V&auml;nligen skriv in texten fr&aring;n bilden nedan';
$lang['captcha_failure_message'] = 'Texten fr&aring;n bilden skrevs inte in korrekt';
$lang['timespan'] = 'Minimalt tidsspann mellan inl&auml;ggen';
$lang['err_invalid_mode'] = 'Fel: en ogiltig mode parameter angavs. Giltiga modes &auml;r: %s.';
$lang['err_no_entry_id'] = 'Error: ingen entry_id-parameter angiven. Med mode=entry borde ocks&aring; en entry_id-parameter vara angiven.';
$lang['err_entry_not_found'] = 'Error: det finns inget g&auml;stboksinl&auml;gg med entry_id %s';
$lang['error_template_filenotfound'] = 'Error: mall-filen %s kunde inte hittas!';
$lang['default'] = 'Standard';
$lang['add_guestbook'] = 'Skapa en ny g&auml;stbok';
$lang['set_as_default'] = 'S&auml;tt som standard';
$lang['confirm_set_as_default'] = 'S&auml;tt den h&auml;r g&auml;stboken som standard?';
$lang['confirm_delete_guestbook'] = 'Radera g&auml;stboken med ID %s? %s inl&auml;ggen inuti kommer ocks&aring; raderas!';
$lang['id'] = 'ID-nummer';
$lang['date'] = 'Datum';
$lang['sender'] = 'Avs&auml;ndare';
$lang['email'] = 'E-post';
$lang['country'] = 'Land';
$lang['location'] = 'Ort';
$lang['homepage'] = 'Hemsida';
$lang['message'] = 'Meddelande';
$lang['posted'] = 'Postat den';
$lang['ip_addr'] = 'IP-adress';
$lang['alength'] = '&Aring;terst&aring;ende tecken';
$lang['active'] = 'Aktiv';
$lang['access_denied'] = '&Aring;tkomst nekad';
$lang['restore_to_defaults'] = '&Aring;terst&auml;ll till standardinst&auml;llningen';
$lang['restore_to_defaults_warning'] = 'Detta kommer att &aring;terst&auml;lla mallens inneh&aring;ll till systemstandardinst&auml;llningen. Det skriver &ouml;ver alla &auml;ndringar som har gjorts i mallen. &Auml;r du s&auml;ker p&aring; att du vill forts&auml;tta?';
$lang['addgait'] = 'L&auml;gg till meddelande i g&auml;stboken';
$lang['postdate'] = 'Datum f&ouml;r inl&auml;gg';
$lang['ativi'] = 'aktivera';
$lang['deakti'] = 'avaktivera';
$lang['title_mod_admin'] = 'Hantera g&auml;stboksinl&auml;gg';
$lang['title_mod_settings'] = 'G&auml;stboksinst&auml;llningar';
$lang['title_tab_admin_templates'] = 'G&auml;stboksmallar';
$lang['title_tab_admin_template'] = 'G&auml;stboksmall';
$lang['title_tab_admin_entrylist_template'] = 'Inl&auml;ggslistamall';
$lang['title_tab_admin_entry_template'] = 'Inl&auml;ggsmall';
$lang['title_tab_admin_form_template'] = 'Formul&auml;rmall';
$lang['title_tab_admin_email_template'] = 'E-postmall';
$lang['title_tab_admin_showform_button_template'] = 'Visa formul&auml;r-mall';
$lang['templatecontent'] = 'Mallinneh&aring;ll';
$lang['admin_template_modified_logmessage'] = 'G&auml;stboksmallen &auml;ndrad';
$lang['admin_template_restored_logmessage'] = 'G&auml;stboksmallen &aring;terst&auml;lld till standardinst&auml;llningarna';
$lang['admin_entry_added_logmessage'] = 'G&auml;stboksinl&auml;gg tillagt';
$lang['admin_entry_modified_logmessage'] = 'G&auml;stboksinl&auml;gg &auml;ndrat';
$lang['admin_entry_deleted_logmessage'] = 'G&auml;stboksinl&auml;gg borttaget';
$lang['admin_entry_activated_logmessage'] = 'G&auml;rsboksinl&auml;gg aktiverat';
$lang['admin_entry_deactivated_logmessage'] = 'G&auml;stboksinl&auml;gg avaktiverat';
$lang['admin_entry_message_nosender'] = 'Ange ett namn p&aring; avs&auml;ndaren';
$lang['wrong_date_format'] = 'Datum format ska ha formatet: YYYY-MM-DD HH:MM:SS';
$lang['fieldnames'] = 'F&auml;ltnamn';
$lang['captcha_module_installed'] = 'Captcha-modulen &auml;r installerad';
$lang['captcha_module_not_installed'] = 'Captcha-modulen &auml;r inte istallerad';
$lang['smileys_module_installed'] = 'Smiley-modulen &auml;r installerad';
$lang['smileys_module_not_installed'] = 'Smiley-modulen &auml;r inte installerad';
$lang['admin_wysiwyg_title'] = 'Anv&auml;nd WYSIWYG i g&auml;stboks-formul&auml;ret';
$lang['searchsmileys_title'] = 'Anv&auml;nd Smileys i s&ouml;kresultaten';
$lang['save_settings'] = 'Spara inst&auml;llningar';
$lang['badwords_title'] = 'Ord som inte &auml;r till&aring;tna';
$lang['badwords_replacement_title'] = 'Ers&auml;tt fula ord med';
$lang['admin_entries_per_page_title'] = 'Inl&auml;gg oer sida (admin)';
$lang['description'] = 'Beskrivning';
$lang['nummer'] = 'Antal inl&auml;gg per sida';
$lang['postchar'] = 'Maximalt storlek p&aring; meddelande';
$lang['emailnot'] = 'E-postnotifiering';
$lang['sortasc'] = 'Sortera stigande';
$lang['smile'] = 'Smiley (emoticon)';
$lang['shmenow'] = 'Visa meddelande direkt';
$lang['datefora'] = 'Datumformat';
$lang['lang'] = 'Locale (t.ex. sv_SE)';
$lang['showaddform'] = 'Visa formul&auml;r f&ouml;r nytt inl&auml;gg under inl&auml;ggen';
$lang['fabsend'] = 'Skriv ditt namn <br>';
$lang['fmessag'] = 'Skriv ditt meddelande <br>';
$lang['femail'] = 'Skriv en fungerande e-postadress <br>';
$lang['tolong'] = 'Du har skrivit det maximala antalet bokst&auml;ver, g&ouml;r ditt meddelande kortare.';
$lang['toosoon'] = 'Ditt senaste inl&auml;gg var bara f&ouml;r %s sekunder sedan. Minsta tid mellan inl&auml;gg &auml;r %s sekunder.';
$lang['fui'] = 'Ditt meddelande har redan skickats';
$lang['badwords_message'] = 'De h&auml;r orden &auml;r inte till&aring;tna: %s';
$lang['showitnow'] = 'Ditt meddelande &auml;r inlagt';
$lang['showitlater'] = 'Tack! N&auml;r ditt meddelande har godk&auml;nts kommer det att visas i g&auml;stboken';
$lang['msg_back'] = 'tillbaka';
$lang['inam'] = 'Namn';
$lang['imessag'] = 'Ditt Meddelande';
$lang['smessage'] = 'Meddelande';
$lang['sdate'] = 'Datum';
$lang['ginsert'] = 'Skicka';
$lang['cancel'] = '&Aring;ngra';
$lang['uhr'] = 'kl. ';
$lang['e_mailnotibetr'] = 'Nytt meddelande i din g&auml;stbok';
$lang['e_mailnotimessage'] = ' Det finns ett nytt meddelande i din g&auml;stbok';
$lang['neuein'] = 'Nytt g&auml;stboksmeddelande';
$lang['einerseit'] = 'en sida';
$lang['eintragauf'] = 'meddelanden p&aring;';
$lang['seitpage'] = 'sidor';
$lang['backzu'] = 'Tillbaka';
$lang['nextwei'] = 'N&auml;sta';
$lang['first_text'] = '&iota;&lsaquo;';
$lang['prev_text'] = '< f&ouml;reg&aring;ende';
$lang['next_text'] = 'n&auml;sta >';
$lang['last_text'] = '&rsaquo;&iota;';
$lang['pagination_of'] = 'av';
$lang['title_table_smileys'] = 'Smileys (emoticons)';
$lang['ativimes'] = '&Auml;r du s&auml;ker p&aring; att du vill aktivera det h&auml;r meddelandet?';
$lang['deaktimes'] = '&Auml;r du s&auml;ker p&aring; att du vill avaktivera det h&auml;r meddelandet?';
$lang['event_info_GuestbookEntryPosted'] = 'H&auml;ndelser n&auml;r ett nytt g&auml;stboksinl&auml;gg l&auml;ggs till';
$lang['event_help_GuestbookEntryPosted'] = '<p>Event triggered when a new Guestbook entry is added.</p>
  	 <h4>Parameters</h4>
  	 <ul>
		<li><em>entry_id</em> - The entry id (int)</li>
		<li><em>entry_sender</em> - The name the sender entered (string)</li>
		<li><em>entry_email</em> - The E-mail address entered (string)</li>
		<li><em>entry_homepage</em> - The homepage entered (string)</li>
		<li><em>entry_message</em> - The message entered (string)</li>
		<li><em>entry_country</em> - The country entered (string)</li>
		<li><em>entry_location</em> - The location entered (string)</li>
		<li><em>entry_date</em> - The post date (string)</li>
		<li><em>entry_approved</em> - Whether the entry is activated at once, 1 if it is, -1 if not (int)</li>
  	 </ul>
';
$lang['event_info_GuestbookEntryDeleted'] = 'H&auml;ndelser n&auml;r ett g&auml;stboksinl&auml;gg tas bort';
$lang['event_help_GuestbookEntryDeleted'] = 'Event triggered when a Guestbook entry is deleted
  	 <h4>Parameters</h4>
  	 <ul>
	  	 <li><em>entry_id</em> - The entry id (int)</li>
  	 </ul>
';
$lang['event_info_GuestbookEntryActivated'] = 'H&auml;ndelser n&auml;r ett g&auml;stboksinl&auml;gg aktiveras';
$lang['event_help_GuestbookEntryActivated'] = 'Event triggered when a Guestbook entry is activated
  	 <h4>Parameters</h4>
  	 <ul>
  	 <li><em>entry_id</em> - The entry id (int)</li>
  	 </ul>
';
$lang['event_info_GuestbookEntryDeactivated'] = 'H&auml;ndelser n&auml;r ett g&auml;stboksinl&auml;gg deaktiveras';
$lang['event_help_GuestbookEntryDeactivated'] = 'Event triggered when a Guestbook entry is de-activated
  	 <h4>Parameters</h4>
  	 <ul>
  	 <li><em>entry_id</em> - The entry id (int)</li>
  	 </ul>
';
$lang['inposmes'] = 'Se till att st&auml;lla in r&auml;ttighet f&ouml;r &quot;Modify gastbuch&quot; f&ouml;r anv&auml;ndare som kommer att administrera g&auml;stboken.';
$lang['moddescription'] = 'Hantera g&auml;stboksinl&auml;gg';
$lang['uninstall_pre_message'] = '%s inl&auml;gg i din g&auml;stbok kommer att raderas permanent!';
$lang['uninstall_pre_message_single'] = '1 inl&auml;gg i din g&auml;stbok kommer att raderas permanent!';
$lang['postuninstall'] = 'G&auml;stboken har installerats.';
$lang['help_mode'] = '&quot;guestbook&quot;, &quot;form&quot;, &quot;entrylist&quot; or &quot;entry&quot;';
$lang['help_show_entry'] = 'ID f&ouml;r ett inl&auml;gg som ska visas (f&ouml;ruts&auml;tter mode=&quot;entry&quot;)';
$lang['help_guestbook'] = 'G&auml;stbooks ID';
$lang['help_textleng'] = 'Anger hur m&aring;nga tecken som kan skrivas. Standard &auml;r 1000 tecken. Denna parameter p&aring;verkas b&aring;de serverns och klients validering.';
$lang['help_number'] = 'Max antal g&auml;stboksinl&auml;gg att visa per sida.';
$lang['help_timespan'] = 'Minsta till&aring;tna tid mellan inl&auml;gg. (i sekunder).';
$lang['help_mailnoti'] = 'E-postadress att skicka notifiering till n&auml;r nya inl&auml;gg skrivs. CMSMailer modulen kommer att anv&auml;ndas att skicka e-posten med om den &auml;r installerad (annars kommer PHP&#039;s e-post-funktion att anv&auml;ndas).';
$lang['help_sortasc'] = 'Sortera g&auml;stboksinl&auml;gg i stigande ordning efter datum (nya inl&auml;gg sist).';
$lang['help_dateformat'] = '&Auml;ndra s&auml;ttet datumet visas, PHP-format accepteras.';
$lang['help_shownow'] = 'Visar inl&auml;gg direkt efter att de skickas in, utan godk&auml;nnande av en administrat&ouml;r.';
$lang['help_smiley'] = '&Ouml;vers&auml;tt text-baserade smileys till bilder och visa alla smileys vid inl&auml;ggsformul&auml;ret. Anv&auml;nder Smiley-modulen om det &auml;r installerad.';
$lang['help_captcha'] = 'Detta kommer att aktivera captcha till g&auml;stboksformul&auml;ret. Captcha-modulen m&aring;ste vara installerad f&ouml;r att parametern ska fungera.';
$lang['help_showaddform'] = 'Visar g&auml;stboksformul&auml;ret p&aring; f&ouml;rsta sidan. Ers&auml;tter &quot;Nytt g&auml;stboksmeddelande&quot;-knappen.';
$lang['help'] = '   <h3>Vad kan du g&ouml;ra?</h3>
	<p>G&auml;stboksmodulen &auml;r en ineh&aring;llsmodul och en taggmodul. Den ger exempelvis bes&ouml;kare m&ouml;jlighet att l&auml;mna ett meddelande om vad de tycker om webbsidan i en g&auml;stbok.
</p>



<h3>S&auml;kerhet</h3>
<p>Anv&auml;ndaren m&aring;ste tillh&ouml;ra en grupp med r&auml;ttighet att &#039;Modify Gastbuch&#039; f&ouml;r att kunna l&auml;gga till, redigera eller ta bort g&auml;stboksinl&auml;gg.<br />
    In order to be able to modify the guestbook entry template, &#039;Modify Guestbook Template&#039; permission is required.
</p>


<h3>Hur anv&auml;nder jag modulen?</h3>
<p>
B&auml;sta s&auml;ttet &auml;r att anv&auml;nda g&auml;stboken som inneh&aring;llstyp. Du l&auml;gger d&aring; till en inneh&aring;llssida och v&auml;ljer Gastbuch som inneh&aring;llstyp. 
Efter detta kan du v&auml;lja de inst&auml;llningar som du vill ha f&ouml;r g&auml;stboken. <br />
Om du vill l&auml;gga till modulen efter annan text kan du ist&auml;llet anv&auml;nda den tillsammans med cms_module-taggen. Det l&auml;gger till modulen i din mall eller sida d&auml;r du vill ha den, och visar g&auml;stboksinl&auml;ggen.<br />
Koden kan d&aring; se ut s&aring; h&auml;r: <code>{cms_module module=&quot;gastbuch&quot; number=&quot;5&quot;}</code>
F&ouml;r b&aring;da varianterna finns de inst&auml;llningar som listas nedan.
</p>
<h3>Vilka inst&auml;llningar finns?</h3>
<p>
<ul>
<li><em>(valfri)</em> textleng=&quot;1000&quot; - st&auml;ller in hur m&aring;nga tecken som kan skrivas i ett inl&auml;gg, standard &auml;r 1000 tecken. De h&auml;r tecknen kontrolleras fr&aring;n anv&auml;ndarens sajt och fr&aring;n servern.</li>

<li><em>(valfri)</em> number=&quot;10&quot; - Maximalt antal inl&auml;gg som visas p&aring; en sida. Om tomt visas 10 inl&auml;gg.</li>
<li><em>(valfri)</em> mailnoti=&quot;dinepost@dindom&auml;n.se&quot; - Du f&aring;r ett e-postmeddelande om ett inl&auml;gg har gjorts. Modulen CMSMailer anv&auml;nds f&ouml;r att skicka e-post om den &auml;r installerad (annars anv&auml;nds mail-funktion i PHP</li>
<li><em>(valfri)</em> sortasc=&quot;1&quot; - Sortera inl&auml;ggen i stigande datumordning (nya inl&auml;gg kommer sist).</li>
<li><em>(valfri)</em> dateformat=&quot;dateformat&quot; - &Auml;ndrar p&aring; vilket s&auml;tt datumet visas, anv&auml;nd PHP&#039;s formatkoder</li>
<li><em>(valfri)</em> shownow=&quot;1&quot; - Visar inl&auml;gget s&aring; fort det &auml;r skickat, utan godk&auml;nnande fr&aring;n administrat&ouml;r.</li>
<li><em>(valfri)</em> smiley=&quot;1&quot; - Omvandlar text-baserade smileys till bildsmileys och visar smileytabellen i inl&auml;ggsformul&auml;ret.</li>
<li><em>(valfri)</em> captcha=&quot;1&quot; - Detta aktiverar captcha i g&auml;stbokens inl&auml;ggsformul&auml;r. PEAR&#039;s Text_CAPTCHA kr&auml;vs (se avsnittet om Captcha nedan)</li>
<li><em>(valfri)</em> showaddform=&quot;1&quot; - Visar inl&auml;ggsformul&auml;ret p&aring; f&ouml;rstasidan. Ers&auml;tter knappen &quot;Nytt G&auml;stboksinl&auml;gg&quot;.</li>
<li><em>(valfri)</em> lang=&quot;xx_XX&quot; - Anpassad locale. T.ex. lang=&quot;sv_SE&quot;.</li>
</ul>
</p>
<h3>Vilka design-m&ouml;jligheter finns?</h3>
<p>
Databas-mallen som anv&auml;nds f&ouml;r att visa ett g&auml;stboksinl&auml;gg kan &auml;ndras fr&aring;n adminitrationspanelen.
</p>
<p>
    An example stylesheet for the default database template is installed with the module.<br />
    The default stylesheet is deleted when the module is uninstalled and may be overwitten by an upgrade, so you might want to use a copy if you modify it.<br />
    Attach the stylesheet to the page template used.
</p>
<p>
    These variables are assigned in the guestbook entry template:
    <pre>
    date_title
    date
    time
    time_hour_title
    
    sender_title	
    sender
    
    country_title
    country
    
    e_mail_title
    e_mail		// the E-mail address
    e_mail_cloaked	// the E-mail address with . replaced by &amp;lt;dot&amp;gt; and @ by &amp;lt;at&amp;gt;
    
    homepage_title
    homepage
    
    message_title
    message
    </pre>
</p>
<p>
    In the module directory there&#039;s a directory called templates where all other templates are stored. You can modify these to fit your needs:
</p>

<strong>Administration</strong>
<p>
admin_entries_top.tpl -> The paganition and row names for the entry list.<br/>
admin_entries_entry.tpl -> The template for an entry in the list of guestbook entries.<br/>
admin_entries_bottom.tpl -> The bottom of the guestbook entries admin form.<br />
admin_entry.tpl-> The form used to insert or edit guestbook entries.<br/>
admin_template_edit.tpl -> Used for editing the guestbook entry database template.
</p>

<strong>Front End</strong>
<p>
newguest.tpl -> Button to go to the entry form<br/>
insertform.tpl -> The guestbook entry form<br />
smiley.tpl -> The smiley table<br/>
prevnext.tpl -> The buttons to go to the previous and next pages (will show only if entries do not fit on one page)<br/>
success_message.tpl-> The message that will show in place of the insert form after successful post submission.
</p>

<p>
    Inside the template directory there&#039;s a directory called db. This stores the guestbook entry template that is copied to the database during module installation and when the template is restored to default from the admin panel.<br />
    By default the file guestbook_entry-default.tpl is used, but if a (custom) file guestbook_entry.tpl is present, this file will be used instead.
</p>

<h3>Captcha</h3>
<p>
    A catpcha challenge-response test (see <a href="http://www.wikipedia.org/wiki/Captcha">http://www.wikipedia.org/wiki/Captcha</a>) can be used to prevent guestbook spam. The Guestbook module uses PEAR&#039;s Text_CAPTCHA, which will have to be installed on the server.<br />
    You must have GD installed with support for JPEGs, PNGs and TrueType fonts. For more information, see <a href="http://www.php.net/image/">PHP Image Functions</a>.<br />
    Text_CAPTCHA depends on two other PEAR packages, Image_Text and Text_Password. It uses Text_Password to generate the random phrase used in the CAPTCHA test and Image_Text to generate an image file with text in it.<br />
    The process for installing Text_CAPTCHA at the command line is:<br />
    <pre>
    $ pear install Text_Password
    $ pear install Image_Text
    $ pear install --alldeps Text_CAPTCHA
    </pre>
    The webserver process must have sufficient rights to (over)write the file images/captcha/captcha.jpg in the Guestbook module directory.
</p>

<h3>Importing gastbuch messages</h3>
<p>
    If you have one of the beta &quot;gastbuch&quot; module versions installed and want to import your guestbook messages into the Guestbook module, a script is available to do so.
    Simply point your browser to the file gastbuch-import.php in the module folder (for example: http://www.example.com/cms/modules/Guestbook/gastbuch-import.php) before uninstalling the old gastbuch module.
</p>';
$lang['changelog'] = '<ul>
    <li>
	<p><b>Version 1.0</b></p>
	<ul>
	    <li>Renamed module (from gastbuch) to Guestbook to represent the projects natural language and follow CMS Made Simple module naming conventions.</li>
	    <li>Enabled handling (deleting, activating and deactivating) of multiple guestbook entries from the admin panel.</li>
	    <li>There are now seperate &#039;Modify Guestbook Entries&#039; and &#039;Modify Guestbook Template&#039; permissions.</li>
	    <li>A default/example stylesheet is installed (and uninstalled) with the module.</li>
	    <li>The database template can be restored to default.</li>
	    <li>Changed to tabbed navigation.</li>
	    <li>Cleanup/rewrite of the guestbook(item) database template and the variables used in it.</li>
	    <li>Translated many variable names and code comments to english.</li>
	    <li>Moved some admin and log messages to the language file.</li>
	    <li>Re-formatted source code for better readability.</li>
	    <li>The module now also works in combination with a PostgreSQL database.</li>
	    <li>Changed the input format for the dateformat parameter from MySQL format to PHP format.</li>
	    <li>A new variable is assigned to the (database) guestbookentry template: $e_mail_cloaked. This is the E-mail address, with @ replaced by &amp;lt;at&amp;gt; and . by &amp;lt;dot&amp;gt;.</li>
	    <li>Extended the notification E-mail, it now sends the new guestbook entry in the notification message.</li>
	    <li>New finnish translation and updated dutch and norwegian translations from the translation center.</li>
	</ul>
    </li>
    <li>
	<p><b>Version 0.9</b></p>
	<ul>
	    <li>The guestbook frontend now uses a database template (in stead of the showmessage*.tpl files) that can be modified from the admin panel</li>
	    <li>The dateformat parameter is now called dateformat (was dateform). Note: this means you will have to recreate any guestbook content pages or manually edit the tables cms_content and cms_content_props</li>
	    <li>New french translation and modified translations for other languages from the translation center</li>
	</ul>
    </li>
    <li>
	<p><b>Version 0.8</b></p>
	Fixed:
	<ul>
	    <li>not working smileys on gastbuch Content page in version 0.7</li>
	</ul>
	Cleanup:
	<ul>
	    <li>mainly removal of unneccary references to the global $gCms</li>
	    <li>renamed email textfield to e_mail (it was called betreff, probably an old subject field)</li>
	</ul>
	Improvements:
	<ul>
	    <li>newly submitted newsentry is shown in the list</li>
	    <li>brackets around submitter country are no longer shown if a country wasn&#039;t entered</li>
	    <li>translated the lang file to dutch (except for help and changelog)</li>
	    <li>the gastbuch module now makes use of translations entered in the translation center translations.cmsmadesimple.org</li>
	</ul>
	Changed:
	<ul>
	    <li>The template variable name for the country in showmessage.tpl is now called $country (was $countryshow in previous versions)</li>
	</ul>
    </li>
    <li>
	<p><b>Version 0.7</b></p>
	<ul>
	    <li>Added lang attribute to support multiple locales</li>
	    <li>Show insert form on the first page</li>
	    <li>Fixed bug with textlength javascript not working</li>
	    <li>Fixed a few minor bugs</li>
	</ul>
    <li>
	<p><b>Version 0.6</b></p>
	<ul>
	    <li>Redesigned source code for better readability</li>
	    <li>Added lang attribute to support multiple locales</li>
	    <li>Added showaddform parameter</li>
	    <li>Fixed bug with textlength javascript not working in case of &quot;Content&quot; content type</li>
	    <li>Merged vorzu and backzu templates into one</li>
	    <li>Added template success_message.tpl</li>
	    <li>Fixed a few minor bugs caused by mismatches in lang variable names</li>
	</ul>
    </li>
    <li>
	<p><b>Version 0.5</b></p>
	<p>
	    The guestbook was modified with better design and functions, for example: 
	    Template based Content, Spam protection for inserted e-mails, etc.
	</p>
    </li>
    <li>
	<p><b>Version 0.4</b></p>
	<p>The gastbuch module is now a new module</p>
    </li>
</ul>';
$lang['utma'] = '156861353.906052642.1267835734.1280855260.1280862441.163';
$lang['utmz'] = '156861353.1280548859.155.12.utmcsr=wiki.cmsmadesimple.org|utmccn=(referral)|utmcmd=referral|utmcct=/index.php/User_Handbook/Admin_Panel/Content/Global_Content_Blocks';
$lang['qca'] = 'P0-1605183070-1267835733865';
$lang['utmc'] = '156861353';
$lang['utmb'] = '156861353.1.10.1280862441';
?>]]></data>
	</file>
	<file>
	  <filename>/lib/</filename>
	  <isdir>1</isdir>
	</file>
	<file>
	  <filename>/lib/classes/</filename>
	  <isdir>1</isdir>
	</file>
	<file>
	  <filename>/lib/classes/index.html</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[]]></data>
	</file>
	<file>
	  <filename>/lib/classes/module/</filename>
	  <isdir>1</isdir>
	</file>
	<file>
	  <filename>/lib/classes/module/class.Guestbook.php</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[<?php
#CMS - CMS Made Simple
#(c)2004 by Ted Kulp (wishy@users.sf.net)
#This project's homepage is: http://www.cmsmadesimple.org
#
#This program is free software; you can redistribute it and/or modify
#it under the terms of the GNU General Public License as published by
#the Free Software Foundation; either version 2 of the License, or
#(at your option) any later version.
#
#This program is distributed in the hope that it will be useful,
#but WITHOUT ANY WARRANTY; without even the implied warranty of
#MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
#GNU General Public License for more details.
#You should have received a copy of the GNU General Public License
#along with this program; if not, write to the Free Software
#Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
#
#$Id$

/**
 * Guestbook Module Description
 *
 * What does it do?<br/>
 * The guestbook module is a CMSMS content module and plugin module.<br/>
 * With the Guestbook module you give visitors the ability to leave a message,<br />
 * for example how they like the website.<br/>
 *
 * @package Guestbook
 *
 * @author Krisztian Kishyzi<support@expectmore.at> (original author)
 * @author Victor Katolyk
 * @author Dick Ittmann
 */
class Guestbook extends CMSModule
{
	/**
	 * @var object
	 */
	var $admin;
	/**
	 * @var object
	 */
	var $frontend;
	/**
	 * @var object
	 */
	var $dbhandler;
	/**
	 * @var object
	 */
	var $smiley_handler;
	/**
	 * @var array
	 */
	var $installed_modules;
	
	/**
	 * Module Class constructor
	 */
	function Guestbook() {
		// call the parent constructor
		$this->CMSModule();
		// add the module plugins dir to the CMS Smarty object
		$this->cms->smarty->plugins_dir[] = $this->getModulePath() . '/plugins';
		// set initial property values		
		$this->admin = NULL;
		$this->frontend = NULL;
		$this->dbhandler = NULL;
		$this->smileyhandler = NULL;
		$this->installed_modules = array();
		// register content type on CMSMS 1.6 and higher
		if ($GLOBALS['CMS_VERSION'] >= 1.6) {
			parent::CMSModule();
			$this->RegisterContentType('GuestbookContent', cms_join_path(dirname(__FILE__), 'class.GuestbookContent.php'), $this->GetFriendlyName());
		}
	}
	
	/**
	 * The module version number
	*/
	function GetVersion()
	{
		return '1.3.2';
	}
	
	/**
	 * Sets module parameters
	*/
	function SetParameters()
	{
		$this->RegisterModulePlugin();
		$this->RestrictUnknownParams();
		
		$this->CreateParameter('mode', 'guestbook', $this->Lang('help_mode'));
		$this->SetParameterType('mode', CLEAN_STRING);
		$this->CreateParameter('show_entry', '', $this->Lang('help_show_entry'));
		$this->SetParameterType('show_entry', CLEAN_INT);
		$this->CreateParameter('guestbook', $this->GetPreference('guestbook', '0'), $this->Lang('help_guestbook'));
		$this->SetParameterType('guestbook', CLEAN_INT);
		$this->CreateParameter('shownow', $this->GetPreference('shownow', '0'), $this->Lang('help_shownow'));
		$this->SetParameterType('shownow', CLEAN_STRING);
		$this->CreateParameter('showaddform', $this->GetPreference('showaddform', '0'), $this->Lang('help_showaddform'));
		$this->SetParameterType('showaddform', CLEAN_STRING);
		$this->CreateParameter('textleng', $this->GetPreference('textleng', '1000'), $this->Lang('help_textleng'));
		$this->SetParameterType('textleng', CLEAN_INT);
		$this->CreateParameter('number', $this->GetPreference('number', '10'), $this->Lang('help_number'));
		$this->SetParameterType('number', CLEAN_INT);
		$this->CreateParameter('timespan', $this->GetPreference('timespan', '0'), $this->Lang('help_timespan'));
		$this->SetParameterType('timespan', CLEAN_INT);
		$this->CreateParameter('sortasc', $this->GetPreference('sortasc', '0'), $this->Lang('help_sortasc'));
		$this->SetParameterType('sortasc', CLEAN_STRING);
		$this->CreateParameter('dateformat', $this->GetPreference('dateformat', '%d-%m-%Y %H:%M'), $this->Lang('help_dateformat'));
		$this->SetParameterType('dateformat', CLEAN_STRING);
		$this->CreateParameter('smiley', $this->GetPreference('smiley', '0'), $this->Lang('help_smiley'));
		$this->SetParameterType('smiley', CLEAN_STRING);
		$this->CreateParameter('captcha', $this->GetPreference('captcha', '0'), $this->Lang('help_captcha'));
		$this->SetParameterType('captcha', CLEAN_STRING);
		$this->CreateParameter('hide_insertbutton_after_post', $this->GetPreference('hide_insertbutton_after_post', '0'), $this->Lang('hide_insertbutton_after_post'));
		$this->SetParameterType('hide_insertbutton_after_post', CLEAN_INT);
		$this->CreateParameter('mailnoti', '', $this->Lang('help_mailnoti'));
		$this->SetParameterType('mailnoti', CLEAN_STRING);

		$this->SetParameterType('submit', CLEAN_STRING);
		$this->SetParameterType('entry_submitted', CLEAN_STRING);
		$this->SetParameterType('cancel', CLEAN_STRING);
		$this->SetParameterType('uid', CLEAN_STRING);
		$this->SetParameterType('sender_name', CLEAN_STRING);
		$this->SetParameterType('sender_email', CLEAN_STRING);
		$this->SetParameterType('sender_homepage', CLEAN_STRING);
		$this->SetParameterType('sender_country', CLEAN_STRING);
		$this->SetParameterType('sender_location', CLEAN_STRING);
		$this->SetParameterType('message', CLEAN_STRING);
		$this->SetParameterType('captcha_phrase', CLEAN_STRING);
		
		if ($GLOBALS['CMS_VERSION'] < 1.6) {
			if (method_exists($this, 'registercontenttype')) { $this->RegisterContentType('GuestbookContent',cms_join_path(dirname(__FILE__),'class.GuestbookContent.php'),$this->GetFriendlyName()); }
		}
	}
	
	/**
	 * Returns the name of the module.<br/><br/>
	*/
	function GetName()
	{
		return 'Guestbook';
	}
	
	/**
	 * The name that's shown in the  Admin Menus and section pages
	*/
	function GetFriendlyName()
	{
		return $this->Lang('module_friendlyname');
	}
	
	/**
	 * Alow users to add it in a Page using 'smarty' tag
	*/
	function IsPluginModule()
	{
		return true;
	}
	
	/**
	 * The module should be treated as a content module.
	*/
	function IsContentModule()
	{
		return true;
	}
	
	/**
	 * This module has an Adminarea
	*/
	function HasAdmin()
	{
		return true;
	}
	
	/**
	 * Show or not Show for User with no access to the Module
	*/
	function VisibleToAdminUser()
	{
		return (
				$this->CheckPermission('Modify Guestbook Entries') 
				|| $this->CheckPermission('Modify Guestbook Settings')
				|| $this->CheckPermission('Modify Guestbook Template')
			   ) ? true : false;
	}
	
	/**
	 * Specifies in which Admin Section the module shows
	*/
	function GetAdminSection()
	{
		return 'content';
	}
	
	/**
	 * Required minimal CMS version
	*/
	function MinimumCMSVersion()
	{
		return '0.13';
	}
	
	/**
	 * Description string that gets shown in the Admin Section page that contains the module.
	*/
	function GetAdminDescription()
	{
	return $this->Lang('moddescription');
	}
	
	/**
	 * Message after Module was Installed 
	*/
	function InstallPostMessage()
	{
		return $this->Lang('inposmes', $this->Lang('module_example_stylesheet'));
	}
	
	/**
	 * Message displayed before the Module is uninstalled
	 *
	*/	
	function UninstallPreMessage()
	{
		$encoding = 
			(isset($this->config['admin_encoding']) && $this->config['admin_encoding'] != '') 
			? $this->config['admin_encoding'] 
			: 'UTF-8';
		$msg = html_entity_decode(lang('uninstallconfirm'), ENT_COMPAT, $encoding);
		$msg .= ' ' . $this->getFriendlyName();
		$msg .= ". ";
		$num_entries = $this->GetNumberOfEntries();
		
		if ($num_entries > 0)
		{
			$msg .= 
				$num_entries == 1 
				? html_entity_decode($this->Lang('uninstall_pre_message_single'), ENT_COMPAT, $encoding) 
				: html_entity_decode($this->Lang('uninstall_pre_message', $num_entries), ENT_COMPAT, $encoding);
		}
		return $msg;
	}
	
	/**
	 * Message after Module was uninstalled
	*/
	function UninstallPostMessage()
	{
		return $this->Lang('postuninstall');
	}
	
	/**
	 * Gets an event description
	 * @param string The name of the event
	 * @return string
	*/
	function GetEventDescription($eventname)
	{
		return $this->Lang('event_info_' . $eventname);
	}
	
	/**
	 * Gets help on an event
	 * @param string The name of the event
	 * @return string
	*/
	function GetEventHelp($eventname)
	{
		return $this->Lang('event_help_' . $eventname);
	}
	
	/**
	 * This returns HTML information on the module.
	 *
	 * Typically, you'll want to include information on how to use the module.
	 * See the Language file at /lang/
	 * @param $lang
	 * @return string
	 */
	function GetHelp($lang='en_US')
	{
		return $this->Lang('help');
	}

	/**
	 * This returns a string that is presented in the Module Admin if you click on the "About" link.
	 * @return string
	 */
	function GetAuthor()
	{
		return 'Krisztian Kishazi (original author: up to version 0.6)
			<p>Code contributors:
			<ul>
				<li>Victor Katolyk (version 0.7)</li>
				<li>Dick Ittmann (version 0.8 and on)</li>
				<li>Tobias Kretschmar (version 1.1.10)</li>
				<li>Andi Petzoldt (version 1.1.11 and on)</li>
                <li><a href="mailto:gabr.matias@gmail.com">Gabriel Matias</a> (version 1.3.0 and on)</li>                                
			</ul></p>';
	}
	
	/**
	 * This returns a string that is presented in the Module Admin if you click on the "About" link.
	 * @return string
	 */
	function GetAuthorEmail()
	{
		return '<a href="support@expectmore.at">support@expectmore.at</a>';
	}

	/**
	 * Returns the module changelog.
	 * @return string
	 */
	function GetChangeLog()
	{
		return $this->Lang('changelog');
	}
	
	// End of CMSModule methods	
	
	/**
	 * Returns the (default) guestbook entry template
	 * @param $templatename
	 * @return string
	 */
	function GetGuestbookHtmlTemplate($templatename)
	{
		$tpl_base = cms_join_path($this->GetModulePath(), 'templates');
		$default_template = cms_join_path($tpl_base, 'db', $templatename . '-default.tpl');
		$custom_template  = cms_join_path($tpl_base, 'db', $templatename . '.tpl');
		if (is_file($custom_template)) {
			return file_get_contents($custom_template);
		}
		elseif (is_file($default_template)) {
			return file_get_contents($default_template);
		}
		else
		{
			return $this->Lang('error_filenotfound_defaulttemplate');
		}
	}
	
	/**
	 * ShowError to display error 
	 *
	 * @param string $error The Error to display
	 */
	function ShowError($error)
	{
		echo '<p class=\"pageerror\">' . $error . '</p>';
	}
	
	function InsertEntry($guestbook_id, $entry)
	{
		if ($entry->GetTimestamp() == '')
		{
			$timestamp = $this->GetTimestamp('');
			$timestamp = substr($timestamp, 1, strlen($timestamp)-2); // remove surrounding quotes
			$entry->SetTimestamp($timestamp);
		}
		$dbhandler = $this->getDbHandler();
		$result = $dbhandler->InsertEntry($guestbook_id, $entry);
		if ($result)
		{
			if (method_exists($this, 'SendEvent'))
			{
				// send event
				$parms = array(
					'guestbook_id'   => $entry->guestbook_id,
					'entry_id'       => $entry->entry_id,
					'entry_sender'   => $entry->sender->GetName(),
					'entry_email'    => $entry->sender->GetEmail(),
					'entry_homepage' => $entry->sender->GetHomepage(),
					'entry_message'  => $entry->GetMessage(),
					'entry_date'     => $entry->GetTimestamp(),
					'entry_approved' => $entry->IsActive(),
					'entry_country'  => $entry->sender->GetCountry(),
					'entry_location' => $entry->sender->GetLocation(),
					'entry_ip'       => $entry->sender->GetIp()
				);
				$this->SendEvent('GuestbookEntryPosted', $parms);
			}
		}
		
		// add entry to search index
		if ($entry->IsActive()) {
			if ($search = $this->GetModuleInstance('Search'))
			{
				$str = $entry->sender->GetName() . ' ' . $entry->sender->GetCountry() . ' ' . $entry->sender->GetLocation() . ' ' . $entry->GetMessage();
				$search->AddWords($this->GetName(), $entry->entry_id, 'guestbook', $str);
			}
		}
	}
	
	/**
	 * This function Deletes one Entry from the Database
	 *
	 * It's just used internallly for make a query,<br/>
	 * it Deletes a row from the Database.<br/>
	 *
	 * @param string $entry_id The entry_id of the row wich should be returned
	 */
	function DeleteEntryById($entry_id)
	{
		$dbhandler =& $this->GetDbHandler();
		$result = $dbhandler->DeleteEntryById($entry_id);
		if ($result && $dbhandler->db->Affected_Rows() == 1)
		{
			// send event
			if (method_exists($this, 'SendEvent'))
			{
				$this->SendEvent('GuestbookEntryDeleted', array('entry_id' => $entry_id));
			}
			// remove entry from search index
			if ($search = $this->GetModuleInstance('Search'))
			{
				$search->DeleteWords($this->GetName(), $entry_id, 'guestbook');
			}
		}
	}
	
	/**
	 * This function activates one entry in the database, sends an event and updates search
	 * it activates a row from the database to show the visitors.<br/>
	 *
	 * @param string $entry_id The entry_id of the row wich should be aktivated
	 */
	function ActivateEntryById($entry_id)
	{
		$dbhandler =& $this->GetDbHandler();
		$result = $dbhandler->ActivateEntryById($entry_id);
		if ($result && $dbhandler->db->Affected_Rows() == 1)
		{
			// send event
			if (method_exists($this, 'SendEvent'))
			{
				$this->SendEvent('GuestbookEntryActivated', array('entry_id' => $entry_id));
			}
			// add entry to search index
			$entry = $this->GetEntryById($entry_id);
			if ($search = $this->GetModuleInstance('Search'))
			{
				$str = $entry->sender->GetName() . ' ' . $entry->sender->GetCountry() . ' ' . $entry->sender->GetLocation() . ' ' . $entry->GetMessage();
				$search->AddWords($this->GetName(), $entry_id, 'guestbook', $str);
			}
		}
	}
	
	/**
	 * This function deactivates one entry in the database, sends an event and removes the entry from search
	 *
	 * @param string $entry_id The entry_id of the row wich should be aktivated
	 */
	function DeactivateEntryById($entry_id)
	{
		$dbhandler =& $this->GetDbHandler();
		$result = $dbhandler->DeactivateEntryById($entry_id);
		
		if ($result && $dbhandler->db->Affected_Rows() == 1)
		{
			if (method_exists($this, 'SendEvent'))
			{
				// send event
				$this->SendEvent('GuestbookEntryDeactivated', array('entry_id' => $entry_id));
			}
			
			// remove entry from search index
			if ($search = $this->GetModuleInstance('Search'))
			{
				$search->DeleteWords($this->GetName(), $entry_id, 'guestbook');
			}
		}
		
	}
	
	function GetEntryById($entry_id)
	{
		$dbhandler =& $this->GetDbHandler();
		$result = $dbhandler->GetEntryById($entry_id);
		if ($result)
		{
			$entry =& $this->GetEntryFromData($result->fields);
			return $entry;
		}
	}
	
	function & GetEntryFromData($data)
	{
		require_once cms_join_path(Guestbook::GetModulePath(), 'lib', 'classes', 'module', 'class.GuestbookEntry.php');
		require_once cms_join_path(Guestbook::GetModulePath(), 'lib', 'classes', 'module', 'class.GuestbookEntrySender.php');
		$sender = new GuestbookEntrySender($data['sender'], $data['e_mail'], $data['ip_address'], $data['country'], $data['location'], $data['homepage']);
		$entry = new GuestbookEntry($sender, $data['message'], $data['approved'] == '1' ? true : false, $data['date']);
		$entry->entry_id = $data['entry_id'];
		$entry->guestbook_id = $data['guestbook'];
        $entry->guestbook_name = $data['guestbook_name'];
		return $entry;
	}
	
	/**
	 * This function saves Entry changes to the database
	 *
	 * Used internally to make a query, updates a database row after an entry was changed from the module admin.<br/>
	 *
	 * @param string $id        The entry_id of the row which should be updated
	 * @param string $sender    The sender name
	 * @param string $e_mail    The E-mail address
	 * @param string $homepage  The homepage
	 * @param string $message   The message
	 * @param string $country   The country
	 * @param string $location  The location (state/province/city)
     * @param string $date      The entry date
	 */
	function UpdateEntry($entry_id, $sender, $e_mail='', $homepage='', $message, $country='', $location='', $date='')
	{
        $tmpdate = $date ? ', date = ?' : '';
        $db = $this->cms->db;
		$table = cms_db_prefix() . 'module_guestbook';
		$query  = "
			UPDATE 
				$table
			SET 
				sender   = ?, 
				e_mail   = ?,
				homepage = ?, 
				message  = ?, 
				country  = ?, 
				location = ?
                $tmpdate
			WHERE 
				entry_id = '$entry_id'
		";
		if ($date) { $db->Execute($query, array($sender, $e_mail, $homepage, $message, $country, $location, $date)); }
        else { $db->Execute($query, array($sender, $e_mail, $homepage, $message, $country, $location)); }
		
		// add entry to search index
		if ($search = $this->GetModuleInstance('Search'))
		{
			$str = $sender . ' ' . $country . ' ' . $location . ' ' . $message;
			$search->AddWords($this->GetName(), $entry_id, 'guestbook', $str);
		}
	}
	
	/**
	 * Reads the contents of the example stylesheet css file and writes it to the database
	 */
	function UpdateStylesheet(&$db) 
	{
		// update the stylesheet iserted on install
		# get the stylesheet id
		$query = "SELECT value FROM " . cms_db_prefix() . "module_guestbook_settings WHERE setting = 'template_id'";
		$result =& $db->Execute($query);
		$css_id = $result->Fields('value');
		# update the stylesheet
		$css_text =
		# create the css content
		# the intro from the language file
			"/*\n" . $this->Lang('module_example_stylesheet_intro') . "\n*/\n\n"
		# the contents of the css file
			. file_get_contents(cms_join_path($this->GetModulePath(), 'css', 'stylesheet.css'))
		;
		# update the stylesheet in the database
		$query = "UPDATE " . cms_db_prefix() . "css SET css_text = '" . $css_text . "' WHERE css_id = '$css_id'";
		$result =& $db->Execute($query);
	}
	
	/**
	 * @param string Name of the module
	 * @return bool Whether the specified module is installed
	*/
	function ModuleIsInstalled($modulename)
	{
		global $gCms;
		
		// non-admin modules are listed in $this->cms->modules
		if (isset($gCms->modules[$modulename]))
		{
			return true;
		}
		
		// the module is a module found before
		if (isset($this->installed_modules[$modulename]))
		{
			return true;
		}

		// find modules
		$query = "
			SELECT * FROM " . cms_db_prefix() . "modules 
			WHERE module_name = '$modulename' AND active = 1
		";
			
		$result = $gCms->db->Execute($query);
		if ($result && $result->RecordCount() > 0)
		{
			$this->installed_modules[$modulename] = 1;
			return true;
		}
			
		return false;
	}

	function SearchResult($returnid, $entry_id, $attr = '')
	{
		// require the GuestbookFrontend class file
		require_once cms_join_path($this->GetModulePath(), 'lib', 'classes', 'module', 'class.GuestbookFrontend.php');

		$db =& $this->GetDb();
		$result = array();

		if ($attr == 'guestbook')
		{
			$entry = $this->GetEntryById($entry_id);
			if (! $entry)
			{
				echo('error in Guestbook SearchResult');
				// todo, audit
				return;
			}
			if ($this->GetPreference('searchsmileys'))
			{
				$smiley_handler =& $this->GetSmileyHandler();
				$entry->SetMessage($smiley_handler->InsertSmileys($entry->GetMessage()));
			}
			$result[0] = 'Guestbook - ' . $entry->sender->GetName() . ' - ' . $entry->GetMessage();
			$result[1] = 'View Guestbook entry';
			$result[2] = $this->CreateLink(
				$entry_id, 
				'default', 
				$returnid, 
				'',
				array(
					'mode' => 'entry',
					'smiley' => $this->GetPreference('searchsmileys'),
					'show_entry' => $entry_id
				), 
				'', 
				true
			);
			return $result;
		}
	}
	
	function SearchReIndex(&$module)
	{
		$db =& $this->GetDb();
		$query = "
			SELECT 
				entry_id,
				sender,
				e_mail,
				homepage,
				country,
				location,
				message
			FROM " . cms_db_prefix() . "module_guestbook
			WHERE approved = '1'
		";
		$dbresult = $db->Execute( $query );
		if( !$dbresult )
		{
			die( $db->ErrorMsg() );
		}
		while( $row = $dbresult->FetchRow() )
		{
			$str = 
				$row['sender']   . ' ' .
//                $row['e_mail']   . ' ' .
//                $row['homepage'] . ' ' .
				$row['country']  . ' ' .
				$row['location'] . ' ' .
				$row['message']
			;
			$module->AddWords( $this->GetName(), $row['entry_id'], 'guestbook', $str );
		}
	}
	
	// GetModulePath doesn't work correctly on 0.13 during CMS install
	function GetModulePath() {
		global $gCms;
		$root_path = '';
		if(substr($gCms->config['root_path'], strlen($gCms->config['root_path'])-8, 8) == DIRECTORY_SEPARATOR . 'install')
		{
			$root_path = dirname(dirname(__FILE__));
		}
		else
		{
			$root_path = $gCms->config['root_path'];
		}
		return cms_join_path($root_path, 'modules', Guestbook::GetName());
	}
	
	function InsertStylesheet() {
		$db =& $this->GetDB();
		// Create the default/example stylesheet
		# get a unique ID for the CSS
		$new_css_id = $db->GenID(cms_db_prefix() . 'css_seq');
		# get a localized name for the Stylesheet
		$css_name = str_replace(array('\\','/', ':', '*', '?', '"', '<', '>', '|'), '_', $this->Lang('module_example_stylesheet')) ; // Fast fix for Windows FS
		# create the css text
		$css_text = '';
		$css_intro = $this->Lang('module_example_stylesheet_intro');
		$css_filelocation = cms_join_path($this->GetModulePath(), 'css', 'stylesheet.css');
		$css_filecontent = file_get_contents($css_filelocation);
		$css_text = "/*\n $css_intro\n*/\n\n $css_filecontent";
		# media type
		$media_type = 'handheld, screen, tv';
		# creation date
		$timestamp = $this->GetTimestamp();
		# create the query
		$css_table = cms_db_prefix() . 'css'; // the table that stores the CMSMS stylesheets
		$query = "
			INSERT INTO 
			`$css_table`
			(css_id, css_name, css_text, media_type, create_date, modified_date) 
			VALUES 
			('$new_css_id', '$css_name', '$css_text', '$media_type', $timestamp, $timestamp)
		";
		# execute the query: adds the stylesheet to the database
		$result = $db->Execute($query);
		if ($result) 
		{
			// save the inserted CSS ID in the module settings table so the stylesheet can be deleted on uninstall
			$settings_table = cms_db_prefix() . 'module_guestbook_settings'; // the table that stores the CMSMS stylesheets
			$query = "
				INSERT INTO 
				`$settings_table`
				(setting, value)
				VALUES 
				('template_id', $new_css_id)
			";
			$result = $db->Execute($query);
		}
	}
	
	function GetTimestamp($time = '')
	{
		$time = ($time == '') ? time() : $time;
		$timestamp = $this->cms->db->DBTimeStamp($time);
		if ($timestamp[0] != "'")
		{
			$timestamp = "'$timestamp'";
		}
		return $timestamp;
	}
	
	function & GetAdmin($id, $params, $returnid)
	{
		// require the GuestbookAdmin class file
		require_once cms_join_path($this->GetModulePath(), 'lib', 'classes', 'module', 'class.GuestbookAdmin.php');
		
		if ($this->admin == NULL)
		{
			$this->admin = new GuestbookAdmin($this->smarty, $this->GetDbHandler(), $this);
            
            if (isset($params['messages']) && !empty($params['messages']))
            {
                $this->admin->SetMessages($params['messages']);
            }
            
            if (isset($params['errors']) && !empty($params['errors']))
            {
                $this->admin->SetErrors($params['errors']);
            }
		}
		return $this->admin;
	}
	
	function & GetFrontend($id, $params, $returnid)
	{
		if ($this->frontend == NULL)
		{
		// require the GuestbookDbHandler class file
			require_once cms_join_path($this->GetModulePath(), 'lib', 'classes', 'module', 'class.GuestbookFrontend.php');
			
			$this->frontend = new GuestbookFrontend($this->GetDbHandler(), $this->cms->smarty);
			$this->frontend->InitMode($params);
			$this->frontend->InitCaptcha($params['captcha'] == 1 ? true : false);
		}
		return $this->frontend;
	}
	
	function & GetDbHandler()
	{
		// require the GuestbookDbHandler class file
		require_once cms_join_path(Guestbook::GetModulePath(), 'lib', 'classes', 'module', 'class.GuestbookDbHandler.php');
		
		if ($this->dbhandler == NULL)
		{
			$this->dbhandler = new GuestbookDbHandler($this->cms->db);
		}
		
		return $this->dbhandler;
	}
	
	function & GetSmileyHandler()
	{
		// require the GuestbookSmileyHandler class file
		require_once cms_join_path($this->GetModulePath(), 'lib', 'classes', 'module', 'class.GuestbookSmileyHandler.php');
		
		if ($this->smileyhandler == NULL)
		{
			$mi = $this->ModuleIsInstalled('Smileys') ? $this->getModuleInstance('Smileys') : NULL;
			$this->smileyhandler = new GuestbookSmileyHandler($mi);
			$this->smileyhandler->ImageBaseURL = $this->cms->config['root_url'] . '/modules/' . $this->GetName() . '/images/smileys/default';
		}
		return $this->smileyhandler;
	}
	
	function GetNumberOfEntries($guestbook_id=NULL, $get_inactive=false)
	{
		$dbhandler =& Guestbook::GetDbHandler();
		$result = $dbhandler->getNumberOfEntries((!isset($guestbook_id) ? NULL : (int) $guestbook_id), (bool) $get_inactive);
		if ($result) {
			return $result->fields['count'];
		}
	}
	
	function GetEntries(&$pagination, $guestbook_id=NULL, $order_by='', $get_inactive=false)
	{
		$entries = array();
		$limit = $pagination->getLimit();
		$index = $pagination->getIndex();
		
		$dbhandler =& Guestbook::GetDbHandler();
		$dbresult = $dbhandler->GetEntries($guestbook_id, $order_by, $get_inactive, $limit, $index);
		if ($dbresult && $dbresult->RecordCount())
		{
			while ($row = $dbresult->FetchRow())
			{
				$entries[$row['entry_id']] =& Guestbook::GetEntryFromData($row);
			}
		}
		return $entries;
	}
	
	function GetAllGuestbooks()
	{
		$dbhandler =& $this->GetDbHandler();
		$guestbooks = array();
		$dbresult = $dbhandler->GetGuestbooks();
		if ($dbresult)
		{
			require_once(cms_join_path($this->GetModulePath(), 'lib', 'classes', 'module', 'class.GuestbookGuestbook.php'));
			while ($row = $dbresult->FetchRow())
			{
				$guestbook = new GuestbookGuestbook($row['name'], $row['descr'], $row['active'] ? true : false);
				$guestbook->guestbook_id = $row['id'];
				$guestbooks[$row['id']] = $guestbook;
			}
		}
		
		return $guestbooks;
	}
	
		
	function GetGuestbookById($guestbook_id)
	{
		$dbhandler =& $this->GetDbHandler();
		$result = $dbhandler->GetGuestbookById($guestbook_id);
		if ($result && $result->RecordCount() > 0)
		{
			$guestbook =& $this->GetGuestbookFromData($result->fields);
			return $guestbook;
		}
		return NULL;
	}
	
	function & GetGuestbookFromData($data)
	{
		require_once cms_join_path(Guestbook::GetModulePath(), 'lib', 'classes', 'module', 'class.GuestbookGuestbook.php');
		$guestbook = new GuestbookGuestbook($data['name'], $data['descr'], $data['active'] == 1 ? true : false);
		$guestbook->guestbook_id = $data['id'];
		return $guestbook;
	}
	
	
} // end of class Guestbook

# vim:ts=4 sw=4 noet
?>
]]></data>
	</file>
	<file>
	  <filename>/lib/classes/module/class.GuestbookAdmin.php</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[<?php

require_once 'class.GuestbookDbHandler.php';
require_once 'class.GuestbookAdminTab.php';
require_once 'class.GuestbookAdminTabHeaders.php';

class GuestbookAdmin
{
	var $smarty;
	var $dbhandler;
	var $errors;
	var $messages;

	var $tabheaders;

	var $tabheaders_start;
	var $tabheaders_end;
	var $start_tab_content;
	var $tabs;
	var $end_tab_content;

	var $active_tab;

	function GuestbookAdmin(&$smarty, &$dbhandler, &$guestbook)
	{
		$this->SetDbHandler($dbhandler);
		$this->SetSmarty($smarty);
		$this->SetErrors(NULL);
		$this->SetMessages(array());

		$tabheaders = new GuestbookAdminTabHeaders;
		$this->SetTabHeaders($tabheaders);
        
		$this->SetTabHeadersStart('');
		$this->SetTabHeadersEnd('');
		$this->SetStartTabContent('');
		$this->SetTabs(array());
		$this->SetEndTabContent('');
		$this->SetActiveTab('');
		
		$this->tabs = array();
		if($guestbook->CheckPermission('Modify Guestbook Entries') || $guestbook->CheckPermission('Modify Guestbook Settings') || $guestbook->CheckPermission('Modify Guestbook Template'))
			$this->tabs['guestbooks'] = new GuestbookAdminTab('guestbooks', $guestbook->Lang('tabname_guestbooks'));
		if($guestbook->CheckPermission('Modify Guestbook Entries'))
			$this->tabs['entries'] = new GuestbookAdminTab('entries', $guestbook->lang('tabname_entries'));
		if($guestbook->CheckPermission('Modify Guestbook Template'))
			$this->tabs['templates'] = new GuestbookAdminTab('templates', $guestbook->lang('title_mod_templates'));
		if($guestbook->CheckPermission('Modify Guestbook Settings'))
			$this->tabs['settings'] = new GuestbookAdminTab('settings', $guestbook->lang('tabname_settings'));
			
		if($guestbook->CheckPermission('Modify Guestbook Entries')){
			$this->SetActiveTab('entries');
		}elseif($guestbook->CheckPermission('Modify Guestbook Template')){
			$this->SetActiveTab('templates');
		}elseif($guestbook->CheckPermission('Modify Guestbook Settings')){
			$this->SetActiveTab('settings');
		}
	}

	function SetSmarty(&$smarty)
	{
		$this->smarty =& $smarty;
	}

	function & GetSmarty()
	{
		$smarty =& $this->smarty;
		return $smarty;
	}

	function SetDbHandler(&$db_handler)
	{
		$this->dbhandler =& $db_handler;
	}

	function & GetDbHandler()
	{
		$dbhandler =& $this->dbhandler;
		return $dbhandler;
	}
	
	function SetErrors($errors)
	{
		$this->errors = $errors;
	}
	function GetErrors()
	{
		return $this->errors;
	}
	function AddError($error)
	{
		$this->errors[] = $error;
	}

	function SetMessages($messages)
	{
		$this->messages = $messages;
	}
	function GetMessages()
	{
		return $this->messages;
	}
	function AddMessage($message)
	{
		$this->messages[] = $message;
	}

	function SetTabHeadersStart($tabheaders_start)
	{
		$this->tabheaders_start = $tabheaders_start;
	}

	function GetTabHeadersStart()
	{
		return $this->tabheaders_start;
	}

	function SetTabHeaders($tabheaders)
	{
		$this->tabheaders = $tabheaders;
	}

	function GetTabHeaders()
	{
		return $this->tabheaders;
	}

	function SetTabHeadersEnd($tabheaders_end)
	{
		$this->tabheaders_end = $tabheaders_end;
	}

	function GetTabHeadersEnd()
	{
		return $this->tabheaders_end;
	}

	function SetStartTabContent($start_tab_content)
	{
		$this->start_tab_content = $start_tab_content;
	}

	function GetStartTabContent()
	{
		return $this->start_tab_content;
	}

	function SetTabs($tabs)
	{
		$this->tabs = &$tabs;
	}

	function &GetTabs()
	{
		$tabs =& $this->tabs;
		return $tabs;
	}

	function SetEndTabContent($end_tab_content)
	{
		$this->end_tab_content = $end_tab_content;
	}

	function GetEndTabContent()
	{
		return $this->end_tab_content;
	}

	function SetActivetab($tab_name)
	{
		$this->active_tab = $tab_name;
	}

	function GetActiveTab()
	{
		return $this->active_tab;
	}

	// End of Get/Set methods

	function SetTabContent($tab_id, $mod_id, $params)
	{
        global $gCms;
        $modobj =& $gCms->modules['Guestbook']['object'];
        $modobj->DoAction('admin_tab_' . $tab_id, $mod_id, $params);
	}

	function SetTabContents($mod_id, $params, $returnid)
	{
		foreach($this->tabs as $tab_id =>$tab)
		{
			if ($tab->content == '')
			{
				$this->SetTabContent($tab_id, $mod_id, $params);
			}
		}
	}

	/**
	 * AdminForm to generate or edit Guestbookentries
	 *
	 * @param string $id The ID of the module
	 * @param string $moduleaction
	 * @param string $error Gets the errormessages if something don't insert the Adminform
	 * @param string $sender Stores the Sendername
	 * @param string $e_mail Stores the e_mailadress
	 * @param string $homepage Stores the homepage
	 * @param string $message Stores the message
	 * @param string $country Stores the country
	 * @param string $location Stores the State/Province
	 * @param string $entry_id Stores the entry_id from the database if the message is being modified
	 * @param string $date Stores the entry date
	 */

	function AdminForm($id, $moduleaction, $guestbook, $error='', $sender='', $e_mail='', $homepage='', $message='' , $country='', $location='', $entry_id = '', $date = '')
	{
		global $gCms;
		$mod =& $gCms->modules['Guestbook']['object'];

		$this->smarty->assign('errormsg', $error);
		
		$this->smarty->assign('input_hidden_guestbook', $mod->CreateInputHidden($id, 'guestbook', $guestbook));

		$this->smarty->assign('formstart'     , $mod->CreateFormStart($id, $moduleaction));
        $guestbooks =& $mod->GetAllGuestbooks();
        $this->smarty->assign('guestbooks', $guestbooks);
    	foreach($guestbooks as $guestbook_id => $_guestbook)
        {
        	$select_options[$_guestbook->name] = $guestbook_id;
        }

        $this->smarty->assign('guestbook_title'  , $mod->Lang('module_friendlyname'));
        $this->smarty->assign('guestbook'        , $mod->CreateInputDropdown($id, 'guestbook', $select_options, '', $guestbook));
        
		$this->smarty->assign('sender_title'  , $mod->Lang('sender'));
		$this->smarty->assign('sender'        , $mod->CreateInputText($id, 'sender', $sender  , '', 255));

		$this->smarty->assign('e_mail_title'  , $mod->Lang('email'));
		$this->smarty->assign('e_mail'        , $mod->CreateInputText($id, 'e_mail'  , $e_mail  , '', 255));

		$this->smarty->assign('date_title'    , $mod->Lang('date'));
		$this->smarty->assign('date'          , $mod->CreateInputText($id, 'date'  , $date ? $date : date("Y-m-d H:i:s")  , '', 255));

		$this->smarty->assign('country_title' , $mod->Lang('country'));
		$this->smarty->assign('country'       , $mod->CreateInputText($id, 'country' , $country , '', 255));

		$this->smarty->assign('location_title', $mod->Lang('location'));
		$this->smarty->assign('location'	  , $mod->CreateInputText($id, 'location' , $location , '', 255));

		$this->smarty->assign('homepage_title', $mod->Lang('homepage'));
		$this->smarty->assign('homepage'      , $mod->CreateInputText($id, 'homepage', $homepage, '', 255));

		$this->smarty->assign('message_title' , $mod->Lang('message'));
		$this->smarty->assign('message'       , $mod->CreateTextarea(true, $id, $message, 'message', 'syntaxHighlight', 'message'));

		if ($entry_id != '')
		{
			$this->smarty->assign('entry_id'  , $mod->CreateInputHidden($id, 'entry_id', $entry_id, '', '', 'entry_id'));
		}

		$this->smarty->assign('submit'        , $mod->CreateInputSubmit($id, 'submit', Lang('submit')));
		$this->smarty->assign('cancel'        , $mod->CreateInputSubmit($id, 'cancelsubmit', Lang('cancel')));

		$this->smarty->assign('formend'       , $mod->CreateFormEnd());

		echo $mod->ProcessTemplate('admin_entry.tpl');
	}

    function Show($id, $params, $returnid)
    {
        global $smarty, $gCms;
        $mod =& $gCms->modules['Guestbook']['object'];

        if (isset($params['active_tab']))
        {
        	$this->SetActiveTab($params['active_tab']);
        }
        $this->tabheaders->SetStart($mod->StartTabHeaders());
        $this->tabheaders->SetEnd($mod->EndTabHeaders());
        $this->SetStartTabContent($mod->StartTabContent());
        foreach ($this->tabs as $tab)
        {
        	// set tab start and end
        	$tab->start = $mod->StartTab($tab->name);
        	$tab->end   = $mod->EndTab();
        	
        	// set tabheaders
        	$this->tabheaders->headers[] = $mod->SetTabHeader($tab->name, $tab->title, ($this->GetActiveTab() == $tab->name));
        }
        $this->SetTabContents($id, $params, $returnid);
        $this->SetEndTabContent($mod->EndTabContent());
        $messages = &$this->GetMessages();
        if (!empty($messages))
        {
            foreach ($messages as $index => $message)
            {
                $messages[$index] = $mod->ShowMessage($message);
            }
            $smarty->assign('messages', $messages);
        }else{
            $smarty->assign('messages', '');
        }
        
        $errors = &$this->GetErrors();
        if (!empty($errors))
        {
            $smarty->assign('errors', $mod->ShowErrors($errors));
        }else{
            $smarty->assign('errors', '');
        }
        
        $smarty->assign('tabheaders', $this->GetTabHeaders());
        $smarty->assign('start_tab_content', $this->start_tab_content);
        $smarty->assign('tabs', $this->tabs);
        $smarty->assign('end_tab_content', $this->end_tab_content);
        
        $tpl = cms_join_path($mod->GetModulePath(), 'templates', 'admin.tpl');
        $smarty->display($tpl);
    }
	
    function DeleteGuestbookById($guestbook_id)
    {
    	// delete any messages
    	$result = $this->dbhandler->DeleteEntriesByGuestbookId($guestbook_id);
    	// delete the guestbook
    	$result = $this->dbhandler->DeleteGuestbookById($guestbook_id);
    }
	
}

?>]]></data>
	</file>
	<file>
	  <filename>/lib/classes/module/class.GuestbookAdminTab.php</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[PD9waHAKCmNsYXNzIEd1ZXN0Ym9va0FkbWluVGFiCnsKCXZhciAkbmFtZTsKCQoJdmFyICR0aXRsZTsKCQoJdmFyICRzdGFydDsKCQoJdmFyICRjb250ZW50OwoJCgl2YXIgJGVuZDsKCQoJZnVuY3Rpb24gR3Vlc3Rib29rQWRtaW5UYWIoJG5hbWUsICR0aXRsZSwgJGNvbnRlbnQ9JycpCgl7CgkJJHRoaXMtPnNldE5hbWUoJG5hbWUpOwoJCSR0aGlzLT5zZXRUaXRsZSgkdGl0bGUpOwoJCSR0aGlzLT5zZXRDb250ZW50KCRjb250ZW50KTsKCQkkdGhpcy0+c3RhcnQgPSAnJzsKCQkkdGhpcy0+ZW5kID0gJyc7Cgl9CgkKCWZ1bmN0aW9uIHNldE5hbWUoJG5hbWUpCgl7CgkJJHRoaXMtPm5hbWUgPSAkbmFtZTsKCX0KCWZ1bmN0aW9uIGdldE5hbWUoKQoJewoJCXJldHVybiAkdGhpcy0+bmFtZTsKCX0KCQoJZnVuY3Rpb24gc2V0VGl0bGUoJHRpdGxlKQoJewoJCSR0aGlzLT50aXRsZSA9ICR0aXRsZTsKCX0KCWZ1bmN0aW9uIGdldFRpdGxlKCkKCXsKCQlyZXR1cm4gJHRoaXMtPnRpdGxlOwoJfQoJCglmdW5jdGlvbiBzZXRDb250ZW50KCRjb250ZW50KQoJewoJCSR0aGlzLT5jb250ZW50ID0gJGNvbnRlbnQ7Cgl9CglmdW5jdGlvbiBnZXRDb250ZW50KCkKCXsKCQlyZXR1cm4gJHRoaXMtPmNvbnRlbnQ7Cgl9Cn0KCj8+]]></data>
	</file>
	<file>
	  <filename>/lib/classes/module/class.GuestbookAdminTabHeaders.php</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[PD9waHAKCmNsYXNzIEd1ZXN0Ym9va0FkbWluVGFiSGVhZGVycwp7CgoJdmFyICRzdGFydDsKCXZhciAkaGVhZGVyczsKCXZhciAkZW5kOwoJCglmdW5jdGlvbiBHdWVzdGJvb2tBZG1pblRhYkhlYWRlcnMoJHN0YXJ0PScnLCAkaGVhZGVycz1hcnJheSgpLCAkZW5kPScnKQoJewoJCSR0aGlzLT5TZXRTdGFydCgkc3RhcnQpOwoJCSR0aGlzLT5TZXRIZWFkZXJzKCRoZWFkZXJzKTsKCQkkdGhpcy0+U2V0RW5kKCRlbmQpOwoJfQoJCglmdW5jdGlvbiBTZXRTdGFydCgkc3RhcnQpCgl7CgkJJHRoaXMtPnN0YXJ0ID0gJHN0YXJ0OwoJfQoJCglmdW5jdGlvbiBHZXRTdGFydCgpCgl7CgkJcmV0dXJuICR0aGlzLT5zdGFydDsKCX0KCQoJZnVuY3Rpb24gU2V0SGVhZGVycygmJGhlYWRlcnMpCgl7CgkJJHRoaXMtPmhlYWRlcnMgPSAmJGhlYWRlcnM7Cgl9CgkKCWZ1bmN0aW9uICZHZXRIZWFkZXJzKCkKCXsKCQlyZXR1cm4gJHRoaXMtPmhlYWRlcnM7Cgl9CgkKCWZ1bmN0aW9uIFNldEVuZCgkZW5kKQoJewoJCSR0aGlzLT5lbmQgPSAkZW5kOwoJfQoJCglmdW5jdGlvbiBHZXRFbmQoKQoJewoJCXJldHVybiAkdGhpcy0+ZW5kOwoJfQoKfQoKPz4=]]></data>
	</file>
	<file>
	  <filename>/lib/classes/module/class.GuestbookContent.php</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[<?php
#CMS - CMS Made Simple
#(c)2004 by Ted Kulp (wishy@users.sf.net)
#This project's homepage is: http://cmsmadesimple.sf.net
#
#This program is free software; you can redistribute it and/or modify
#it under the terms of the GNU General Public License as published by
#the Free Software Foundation; either version 2 of the License, or
#(at your option) any later version.
#
#This program is distributed in the hope that it will be useful,
#but WITHOUT ANY WARRANTY; without even the implied warranty of
#MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
#GNU General Public License for more details.
#You should have received a copy of the GNU General Public License
#along with this program; if not, write to the Free Software
#Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
#
#$Id$
  
/**
 * Guestbook Module Description
 *
 * What does it do?<br/>
 * The GuestbookModule Class extends the Contenttypes.<br/>
 * It would be created to allow easier access to the guestbook module settings.<br/>
 *
 * @package Guestbook
 * @subpackage CMSModuleContentType
 * @author Krisztian Kishyzi<support@expectmore.at>
 * @author Victor Katolyk
 * @author Dick Ittmann
*/
class GuestbookContent extends CMSModuleContentType
{
    protected $cms;
    protected $mod;
    
    function __construct(){
        $this->ContentBase();
        $this->init_set();
    }
    
    function __wakeup(){
        $this->init_set();
    }
    
    function init_set(){
        global $gCms;
		$this->cms =& $gCms;
        $this->mod =& $this->cms->modules['Guestbook']['object'];
    }

	function SetProperties()
	{
        $this->mProperties->Add('string', 'number'     , '');
		$this->mProperties->Add('string', 'textleng'   , '');
		$this->mProperties->Add('string', 'dateformat' , '');
		$this->mProperties->Add('string', 'mailnoti');
		$this->mProperties->Add('string', 'locale');
		$this->mProperties->Add('string', 'timespan'   , '0');
		$this->mProperties->Add('bool',   'smiley'     , false);
		$this->mProperties->Add('bool',   'captcha'    , false);
		$this->mProperties->Add('bool',   'sortasc'    , false);
		$this->mProperties->Add('bool',   'shownow'    , false);
		$this->mProperties->Add('bool',   'showaddform', false);
        $this->mProperties->Add('int',   'guestbook', 0);
		
		#Turn on preview
		$this->mPreview = true;
		
		#Turn off caching
		$this->mCachable = false;
	}

	function EditAsArray($adding=false, $tab=0, $showadmin=false)
	{               
		$config = $this->cms->config;
		
		$use_ops = method_exists($this->cms, 'getcontentoperations');
		if ($use_ops)
		{
			$content_ops  =& $this->cms->GetContentOperations();
			$template_ops =& $this->cms->GetTemplateOperations();
		}

        $ret = array();
		if($tab==0){
            $ret[] = array(lang('title')    . ':', '<input type="text" name="title"    value="' . $this->mName     . '">');
            $ret[] = array(lang('menutext') . ':', '<input type="text" name="menutext" value="' . $this->mMenuText . '">');
    		if (!($config['auto_alias_content'] == true && $adding))
    		{
    			$ret[] = array(lang('pagealias') . ':' , '<input type="text" name="alias" value="' . $this->mAlias . '" />');
    		}
            $ret[] = array('&nbsp;', '');
            
            $dropdown = $use_ops ? $template_ops->TemplateDropdown('template_id', $this->mTemplateId) : TemplateOperations::TemplateDropdown('template_id', $this->mTemplateId);
            $ret[] = array(lang('template')           . ':', $dropdown);
            $dropdown = $use_ops ? $content_ops->CreateHierarchyDropdown($this->mId, $this->mParentId) : ContentManager::CreateHierarchyDropdown($this->mId, $this->mParentId);
            $ret[] = array(lang('parent')             . ':', $dropdown);
            $ret[] = array('&nbsp;', '');
            
            // now do advanced attributes
            $ret[] = array(lang('active')             . ':', '<input type="checkbox" name="active"'       . ($this->mActive     ? ' checked="checked"' : '') . '>');
            $ret[] = array(lang('showinmenu')         . ':', '<input type="checkbox" name="showinmenu"'   . ($this->mShowInMenu ? ' checked="checked"' : '') . '>');
            
            if(!$adding && $showadmin){
                $userops = $this->cms->GetUserOperations();
                array_push($ret, array(lang('owner'),@$userops->GenerateDropdown($this->Owner())));
            }
        	if($adding || $showadmin){
                array_push($ret, $this->ShowAdditionalEditors());
            }
            
            // if adding, the last modified informations are not yet defined
            if(!$adding){
                $tmp = get_preference(get_userid(),'date_format_string','%x %X');
        	    if( empty($tmp) ) $tmp = '%x %X';
        	    $ret[]=array(lang('last_modified_at').':', strftime($tmp, strtotime($this->mModifiedDate) ) );
        	    $userops =& $this->cms->GetUserOperations();
        	    $modifiedbyuser = $userops->LoadUserByID($this->mLastModifiedBy);
        	    if($modifiedbyuser) $ret[]=array(lang('last_modified_by').':', $modifiedbyuser->username);
            }
        }
        if($tab==1){


            $selectedvalue = $this->GetPropertyValue('dateformat');
            $dropdownitems = array(
                'dd-mm-yyyy HH:MM' => '%d-%m-%Y %H:%M',
                'dd/mm/yyyy HH:MM' => '%d/%m/%Y %H:%M',
                'dd.mm.yyyy HH:MM' => '%d.%m.%Y %H:%M',
                'dd-mm-yyyy HH:MM:SS' => '%d-%m-%Y %H:%M:%S',
                'dd/mm/yyyy HH:MM:SS' => '%d/%m/%Y %H:%M:%S',
                'dd.mm.yyyy HH:MM:SS' => '%d.%m.%Y %H:%M:%S',
                'dd-mm-yyyy HHhMM' => '%d-%m-%Y %Hh%M',
                'dd/mm/yyyy HHhMM' => '%d/%m/%Y %Hh%M',
                'dd.mm.yyyy HHhMM' => '%d.%m.%Y %Hh%M',
                'd Month yyyy HH:MM' => '%e %B %Y %H:%M',
                'd Month yyyy HH:MM:SS' => '%e %B %Y %H:%M:%S',
                'd Month yyyy HHhMM' => '%e %B %Y %Hh%M',
            	'dd-mm-yyyy' => '%d-%m-%Y',
                'dd/mm/yyyy' => '%d/%m/%Y', 
            	'dd.mm.yyyy' => '%d.%m.%Y', 
            	'yyyy-mm-dd' => '%Y-%m-%d',
                'yyyy/mm/dd' => '%Y/%m/%d', 
            	'yyyy.mm.dd' => '%Y.%m.%d' 
            );
            


            $text = '<select name="dateformat">';
            

            $count = 0;
            foreach ($dropdownitems as $key => $value)
            {

            	$text .= '<option value="' . $value . '"';
            	if ((isset($selectedindex) && $selectedindex == $count) || $selectedvalue == $value)
            	{

            		$text .= ' ' . 'selected="selected"';
            	}

            	$text .= '>';
            	$text .= $key;
            	$text .= '</option>';
            	$count++;
            }
            


            $text .= '</select>' . "\n";
            
        	// get available guestbooks from the database
        	$guestbooks =& $this->mod->GetAllGuestbooks();
        	// drop down options
        	$select_options = array();
        	foreach($guestbooks as $guestbook_id => $guestbook)
        	{
        		$select_options[$guestbook->name] = $guestbook_id;
        	}
            
        	// assign the guestbook selector template
        	$ret[] = array($this->Lang('module_friendlyname')      . ':', $this->mod->CreateInputDropdown('', 'guestbook', $select_options, '', $this->GetPropertyValue('guestbook')));
            $ret[] = array($this->Lang('nummer')      . ':', '<input type="text" name="number" value="'   . $this->GetPropertyValue('number')   . '">');
            $ret[] = array($this->Lang('postchar')    . ':', '<input type="text" name="textleng" value="' . $this->GetPropertyValue('textleng') . '">');
            $ret[] = array($this->Lang('emailnot')    . ':', '<textarea name="mailnoti">' . $this->GetPropertyValue('mailnoti') . '</textarea>');
            $ret[] = array($this->Lang('lang')        . ':', '<input type="text" name="lang" value="'     . $this->GetPropertyValue('locale')   . '">');
            $ret[] = array($this->Lang('timespan')    . ':', '<input type="text" name="timespan" value="' . $this->GetPropertyValue('timespan') . '">');
            $ret[] = array($this->Lang('datefora')    . ':', $text);
            
            $ret[] = array($this->Lang('showaddform') . ':', '<input type="checkbox" name="showaddform" ' . ($this->GetPropertyValue('showaddform') == 1 ? ' checked="checked"' : '') . ' value="1">');
            $ret[] = array($this->Lang('sortasc')     . ':', '<input type="checkbox" name="sortasc" '     . ($this->GetPropertyValue('sortasc')     == 1 ? ' checked="checked"' : '') . ' value="1">');
            $ret[] = array($this->Lang('smile')       . ':', '<input type="checkbox" name="smiley" '      . ($this->GetPropertyValue('smiley')      == 1 ? ' checked="checked"' : '') . ' value="1">');
            
            if (isset($this->cms->modules['Captcha']))
            {

            	$ret[] = array($this->Lang('captcha')     . ':', '<input type="checkbox" name="captcha" '     . ($this->GetPropertyValue('captcha')     == 1 ? ' checked="checked"' : '') . ' value="1">');
            }
            $ret[] = array($this->Lang('shmenow')     . ':', '<input type="checkbox" name="shownow" '     . ($this->GetPropertyValue('shownow')     == 1 ? ' checked="checked"' : '') . ' value="1">');
        }
        
        return $ret;        
	}
	
	function ModuleName()
	{
		return 'Guestbook';
	}
	    
	function Edit($adding=false, $tab=0, $showadmin=false)
	{               
		$config = $this->cms->config;
		
		$use_ops = method_exists($this->cms, 'getcontentoperations');
		if ($use_ops)
		{
			$content_ops  =& $this->cms->GetContentOperations();
			$template_ops =& $this->cms->GetTemplateOperations();
		}

        $ret = array();
		if($tab==0){
            $ret .= '<tr><td>'.lang('title')    . ':</td><td>'.'<input type="text" name="title"    value="' . $this->mName     . '">'.'</td></tr>';
            $ret .= '<tr><td>'.lang('menutext') . ':</td><td>'.'<input type="text" name="menutext" value="' . $this->mMenuText . '">'.'</td></tr>';
    		if (!($config['auto_alias_content'] == true && $adding))
    		{
    			$ret .= '<tr><td>'.lang('pagealias') . ':' .'</td><td>'.'<input type="text" name="alias" value="' . $this->mAlias . '" />'.'</td></tr>';
    		}
            $ret .= '<tr><td>'.'&nbsp;'.'</td><td>'.''.'</td></tr>';
            
            $dropdown = $use_ops ? $template_ops->TemplateDropdown('template_id', $this->mTemplateId) : TemplateOperations::TemplateDropdown('template_id', $this->mTemplateId);
            $ret .= '<tr><td>'.lang('template')           . ':</td><td>'.$dropdown.'</td></tr>';
            $dropdown = $use_ops ? $content_ops->CreateHierarchyDropdown($this->mId, $this->mParentId) : ContentManager::CreateHierarchyDropdown($this->mId, $this->mParentId);
            $ret .= '<tr><td>'.lang('parent')             . ':</td><td>'.$dropdown.'</td></tr>';
            $ret .= '<tr><td>'.'&nbsp;'.'</td><td>'.''.'</td></tr>';
            
            // now do advanced attributes
            $ret .= '<tr><td>'.lang('active')             . ':</td><td>'.'<input type="checkbox" name="active"'       . ($this->mActive     ? ' checked="checked"' : '') . '>'.'</td></tr>';
            $ret .= '<tr><td>'.lang('showinmenu')         . ':</td><td>'.'<input type="checkbox" name="showinmenu"'   . ($this->mShowInMenu ? ' checked="checked"' : '') . '>'.'</td></tr>';
            
            if(!$adding && $showadmin){
                $userops = $this->cms->GetUserOperations();
                array_push($ret, array(lang('owner'),@$userops->GenerateDropdown($this->Owner())));
            }
        	if($adding || $showadmin){
                array_push($ret, $this->ShowAdditionalEditors());
            }
            
            // if adding, the last modified informations are not yet defined
            if(!$adding){
                $tmp = get_preference(get_userid(),'date_format_string','%x %X');
        	    if( empty($tmp) ) $tmp = '%x %X';
        	    $ret[]=array(lang('last_modified_at').':', strftime($tmp, strtotime($this->mModifiedDate) ) );
        	    $userops =& $this->cms->GetUserOperations();
        	    $modifiedbyuser = $userops->LoadUserByID($this->mLastModifiedBy);
        	    if($modifiedbyuser) $ret[]=array(lang('last_modified_by').':', $modifiedbyuser->username);
            }
        }
        if($tab==1){


            $selectedvalue = $this->GetPropertyValue('dateformat');
            $dropdownitems = array(
                'dd-mm-yyyy HH:MM' => '%d-%m-%Y %H:%M',
                'dd/mm/yyyy HH:MM' => '%d/%m/%Y %H:%M',
                'dd.mm.yyyy HH:MM' => '%d.%m.%Y %H:%M',
                'dd-mm-yyyy HH:MM:SS' => '%d-%m-%Y %H:%M:%S',
                'dd/mm/yyyy HH:MM:SS' => '%d/%m/%Y %H:%M:%S',
                'dd.mm.yyyy HH:MM:SS' => '%d.%m.%Y %H:%M:%S',
                'dd-mm-yyyy HHhMM' => '%d-%m-%Y %Hh%M',
                'dd/mm/yyyy HHhMM' => '%d/%m/%Y %Hh%M',
                'dd.mm.yyyy HHhMM' => '%d.%m.%Y %Hh%M',
                'd Month yyyy HH:MM' => '%e %B %Y %H:%M',
                'd Month yyyy HH:MM:SS' => '%e %B %Y %H:%M:%S',
                'd Month yyyy HHhMM' => '%e %B %Y %Hh%M',
            	'dd-mm-yyyy' => '%d-%m-%Y',
                'dd/mm/yyyy' => '%d/%m/%Y', 
            	'dd.mm.yyyy' => '%d.%m.%Y', 
            	'yyyy-mm-dd' => '%Y-%m-%d',
                'yyyy/mm/dd' => '%Y/%m/%d', 
            	'yyyy.mm.dd' => '%Y.%m.%d' 
            );
            


            $text = '<select name="dateformat">';
            

            $count = 0;
            foreach ($dropdownitems as $key => $value)
            {

            	$text .= '<option value="' . $value . '"';
            	if ((isset($selectedindex) && $selectedindex == $count) || $selectedvalue == $value)
            	{

            		$text .= ' ' . 'selected="selected"';
            	}

            	$text .= '>';
            	$text .= $key;
            	$text .= '</option>';
            	$count++;
            }
            


            $text .= '</select>' . "\n";
            
        	// get available guestbooks from the database
        	$guestbooks =& $this->mod->GetAllGuestbooks();
        	// drop down options
        	$select_options = array();
        	foreach($guestbooks as $guestbook_id => $guestbook)
        	{
        		$select_options[$guestbook->name] = $guestbook_id;
        	}
            
        	// assign the guestbook selector template
        	$ret .= '<tr><td>'.$this->Lang('module_friendlyname')      . ':</td><td>'.$this->mod->CreateInputDropdown('', 'guestbook', $select_options, '', $this->GetPropertyValue('guestbook')).'</td></tr>';
            $ret .= '<tr><td>'.$this->Lang('nummer')      . ':</td><td>'.'<input type="text" name="number" value="'   . $this->GetPropertyValue('number')   . '">'.'</td></tr>';
            $ret .= '<tr><td>'.$this->Lang('postchar')    . ':</td><td>'.'<input type="text" name="textleng" value="' . $this->GetPropertyValue('textleng') . '">'.'</td></tr>';
            $ret .= '<tr><td>'.$this->Lang('emailnot')    . ':</td><td>'.'<textarea name="mailnoti">' . $this->GetPropertyValue('mailnoti') . '</textarea>'.'</td></tr>';
            $ret .= '<tr><td>'.$this->Lang('lang')        . ':</td><td>'.'<input type="text" name="lang" value="'     . $this->GetPropertyValue('locale')   . '">'.'</td></tr>';
            $ret .= '<tr><td>'.$this->Lang('timespan')    . ':</td><td>'.'<input type="text" name="timespan" value="' . $this->GetPropertyValue('timespan') . '">'.'</td></tr>';
            $ret .= '<tr><td>'.$this->Lang('datefora')    . ':</td><td>'.$text.'</td></tr>';
            
            $ret .= '<tr><td>'.$this->Lang('showaddform') . ':</td><td>'.'<input type="checkbox" name="showaddform" ' . ($this->GetPropertyValue('showaddform') == 1 ? ' checked="checked"' : '') . ' value="1">'.'</td></tr>';
            $ret .= '<tr><td>'.$this->Lang('sortasc')     . ':</td><td>'.'<input type="checkbox" name="sortasc" '     . ($this->GetPropertyValue('sortasc')     == 1 ? ' checked="checked"' : '') . ' value="1">'.'</td></tr>';
            $ret .= '<tr><td>'.$this->Lang('smile')       . ':</td><td>'.'<input type="checkbox" name="smiley" '      . ($this->GetPropertyValue('smiley')      == 1 ? ' checked="checked"' : '') . ' value="1">'.'</td></tr>';
            
            if (isset($this->cms->modules['Captcha']))
            {

            	$ret .= '<tr><td>'.$this->Lang('captcha')     . ':</td><td>'.'<input type="checkbox" name="captcha" '     . ($this->GetPropertyValue('captcha')     == 1 ? ' checked="checked"' : '') . ' value="1">'.'</td></tr>';
            }
            $ret .= '<tr><td>'.$this->Lang('shmenow')     . ':</td><td>'.'<input type="checkbox" name="shownow" '     . ($this->GetPropertyValue('shownow')     == 1 ? ' checked="checked"' : '') . ' value="1">'.'</td></tr>';
        }
        
        return $ret;        
	}
	
	
	function Show()
	{
	    global $smarty;
		$params = array();
		$params['textleng']    = $this->GetPropertyValue('textleng');
		$params['number']      = $this->GetPropertyValue('number');
		$params['mailnoti']    = $this->GetPropertyValue('mailnoti');
		$params['lang']        = $this->GetPropertyValue('locale');
		$params['timespan']    = $this->GetPropertyValue('timespan');
		$params['showaddform'] = $this->GetPropertyValue('showaddform');
		$params['sortasc']     = $this->GetPropertyValue('sortasc');
		$params['smiley']      = $this->GetPropertyValue('smiley');
		$params['captcha']     = $this->GetPropertyValue('captcha');
		$params['shownow']     = $this->GetPropertyValue('shownow');
		$params['dateformat']  = $this->GetPropertyValue('dateformat');
		$params['guestbook']   = $this->GetPropertyValue('guestbook');
        $params['module']      = 'Guestbook';
        
        echo cms_module_plugin($params, $smarty);
	}
	
	
	function IsDefaultPossible()
	{
		return TRUE;
	}
	
	function FillParams(&$params)
	{
		$config = $this->cms->config;
		
		if (isset($params))
		{
			$parameters = array('number', 'sortasc', 'smiley', 'mailnoti', 'textleng', 'shownow', 'dateformat', 'lang', 'showaddform');
			foreach ($parameters as $oneparam)
			{
				if (isset($params[$oneparam]))
				{
					$this->SetPropertyValue($oneparam, $params[$oneparam]);
				}
			}
			
			if (isset($params['title']))
			{
				$this->mName = $params['title'];
			}
			
			if (isset($params['menutext']))
			{
				$this->mMenuText = $params['menutext'];
			}
			
			if (isset($params['template_id']))
			{
				$this->mTemplateId = $params['template_id'];
			}
			
			if (isset($params['alias']))
			{
				$this->SetAlias($params['alias']);
			}
			else
			{
				$this->SetAlias('');
			}
			
			if (isset($params['parent_id']))
			{
				if ($this->mParentId != $params['parent_id'])
				{
					$this->mHierarchy = '';
					$this->mItemOrder = -1;
				}
				$this->mParentId = $params['parent_id'];
			}
			
			if (isset($params['active']))
			{
				$this->mActive = true;
			} 
			else 
			{
				$this->mActive = false;
			}
			
			if (isset($params['showinmenu']))
			{
				$this->mShowInMenu = true;
			}
			else
			{
				$this->mShowInMenu = false;
			}
			
			if (isset($params['showaddform']) && $params['showaddform'] == 1)
			{
				$this->SetPropertyValue('showaddform', '1');
			}
			else
			{
				$this->SetPropertyValue('showaddform', '0');
			}
			
			if (isset($params['sortasc']) && $params['sortasc'] == 1)
			{
				$this->SetPropertyValue('sortasc', '1');
			} 
			else
			{
				$this->SetPropertyValue('sortasc', '0');
			}
			
			if (isset($params['shownow']) && $params['shownow'] == 1)
			{
				$this->SetPropertyValue('shownow', '1');
			}
			else
			{
				$this->SetPropertyValue('shownow', '0');
			}
			
			if (isset($params['smiley']) && $params['smiley'] == 1)
			{
				$this->SetPropertyValue('smiley', '1');
			}
			else
			{
				$this->SetPropertyValue('smiley', '0');
			}
			
			if (isset($params['captcha']) && $params['captcha'] == 1)
			{
				$this->SetPropertyValue('captcha', '1');
			}
			else
			{
				$this->SetPropertyValue('captcha', '0');
			}
			
			if (isset($params['lang']) && $params['lang'] != '')
			{
				$this->SetPropertyValue('locale', $params['lang']);
			}
			else
			{
				$this->SetPropertyValue('locale', '');
			}
			
			if (isset($params['timespan']) && $params['timespan'] != '')
			{
				$this->SetPropertyValue('timespan', $params['timespan']);
			}
			else
			{
				$this->SetPropertyValue('timespan', '0');
			}

            // get available guestbooks from the database
        	$guestbooks =& $this->mod->GetAllGuestbooks();
			if (isset($params['guestbook']) && isset($guestbooks[$params['guestbook']]))
			{
				$this->SetPropertyValue('guestbook', $params['guestbook']);
			}
			else
			{
				$this->SetPropertyValue('guestbook', $this->mod->GetPreference('guestbook', '0'));
			}
		}
	}
	
	function FriendlyName()
	{
		return $this->Lang('module_friendlyname');
	}
    
    function TabNames(){
        $res = array(lang('main'));
        if(check_permission(get_userid(),'Manage All Content')){
            $res[] = lang('parameters');
        }
        return $res;
    }
}


?>
]]></data>
	</file>
	<file>
	  <filename>/lib/classes/module/class.GuestbookDbHandler.php</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[<?php

class GuestbookDbHandler
{
	
	/**
	 * @var object pear_ADOConnection
	 */
	var $db;
	/**
	 * @var module table prefix
	 */
	var $table_prefix;
	/**
	 * @var string table holding the guestbook entries
	 */
	var $entry_table;
	/**
	 * @var string table holding the guestbooks
	 */
	var $guestbook_table;
	
	/**
	 * Class constructor 
	 * @param object pear_ADOConnection $db
	 */
	function GuestbookDbHandler(&$db)
	{
		$this->setDb($db);
		$this->setTablePrefix(cms_db_prefix() . 'module_guestbook_');
		$this->setEntryTable(cms_db_prefix() . 'module_guestbook');
		$this->setGuestbookTable($this->getTablePrefix() . 'guestbook');
	}
	
	/**
	 * @return object pear_ADOConnection
	 */
	function GetDb()
	{
		$db =& $this->db;
		return $db;
	}
	
	/**
	 * @param $db
	 * @return NULL
	 */
	function SetDb(&$db)
	{
		$this->db =& $db;
	}
	
	/**
	 * @return string
	 */
	function GetTablePrefix()
	{
		return $this->table_prefix;
	}
	
	/**
	 * @param string $prefix
	 * @return NULL
	 */
	function SetTablePrefix($prefix)
	{
		$this->table_prefix = $prefix;
	}
	
	/**
	 * @return string
	 */
	function GetEntryTable()
	{
		return $this->entry_table;
	}
	
	/**
	 * @param string $table
	 * @return NULL
	 */
	function SetEntryTable($table)
	{
		$this->entry_table = $table;
	}
	
	/**
	 * @return string
	 */
	function GetGuestbookTable()
	{
		return $this->guestbook_table;
	}
	
	/**
	 * @param string $table
	 * @return NULL
	 */
	function SetGuestbookTable($table)
	{
		$this->guestbook_table = $table;
	}
	
	/**
	 * @param object GuestbookGuestbook $guestbook
	 * @param $id string or int ID of the guestbook to be added
	 * @return object pear_ResultSet
	 */
	function InsertGuestbook($guestbook, $guestbook_id=NULL)
	{
		$seq_table = $this->guestbook_table . '_seq';
		if (! isset($guestbook_id)) 
		{
			// get an insert ID
			$insert_id = $this->db->GenID($seq_table);
			$guestbook_id = $insert_id;
		} else {
			// the new guestbook already has an ID, so it has messages in a guestbook that is not in the table yet
			// get the last insert_id from the sequence table
			$query = "
				SELECT id FROM $seq_table
			";
			$result = $this->db->Execute($query);

			if ($guestbook_id > $result->fields['id'])
			{
				// if the new ID is higher, update the sequence table
				$query = "
					UPDATE $seq_table
					SET id = $guestbook_id
				";
				$result = $this->db->Execute($query);
			}
		}
			
		// insert the guestbook
		if ($guestbook->GetName() == '')
		{
			$guestbook->SetName($guestbook_id);
		}
		$query = "
			INSERT INTO {$this->guestbook_table}
			(id, name, descr, active)
				VALUES
			(?, ?, ?, ?) 
		";
		$vars = array(
			$guestbook_id,
			$guestbook->GetName(),
			$guestbook->GetDescription(),
			$guestbook->IsActive() ? 1 : 0
		);
		$result = $this->db->Execute($query, $vars);
		return $result;
	}
	
	/**
	 * @return object pear_ResultSet
	 */
	function GetGuestbooks()
	{
		$table = $this->guestbook_table;
		$query = "
			SELECT id, name, descr, active
			FROM $table 
			ORDER BY id
		";
		$result = $this->db->Execute($query);
		return $result;
	}
	
	function GetMessageGuestbooks()
	{
		$table = $this->entry_table;
		$query = "
			SELECT DISTINCT guestbook 
			FROM $table 
			ORDER BY guestbook
		";
		$result = $this->db->Execute($query);
		return $result;		
	}
	
	function GetAllGuestbooks()
	{
		
	}
	
	/**
	 * @param mixed $guestbook_id NULL for all guestbooks otherwise a guestbook ID
	 * @param boolean $count_inactive Whether inactive messages should be counted 
	 * @return object pear_ResultSet
	 */
	function GetNumberOfEntries($guestbook_id=NULL, $count_inactive=false)
	{
		$values = array();
		$where_clause = array();
		$query = "
			SELECT 
				COUNT(1) AS count
			FROM {$this->entry_table}"
		;
		if ($count_inactive == false)
		{
			$where_clause[] = "approved = '1'";
		}
		if (isset($guestbook_id))
		{
			$where_clause[] = "guestbook = ?";
			$values[] = $guestbook_id;
		}
		foreach($where_clause as $index => $where_part)
		{
			$query .= ($index == 0) ? " WHERE $where_part" :" AND $where_part";
		}

		$result = $this->db->Execute($query, $values);
		return $result;
	}
	
	/**
	 * @param mixed $guestbook_id
	 * @param string $order_by ('DESC' or 'ASC')
	 * @param boolean $get_inactive
	 * @param mixed $limit
	 * @param mixed $offset
	 * @return object pear_ResultSet
	 */
	function GetEntries($guestbook_id=NULL, $order_by='', $get_inactive=false, $limit=NULL, $offset=NULL)
	{
		$values = array();
		$where_clause = array();
		$query = '
			SELECT entry_id, sender, e_mail, homepage, country, location, message, date, approved, ip_address, guestbook, '.$this->guestbook_table.'.name as guestbook_name
			FROM `'.$this->entry_table.'` LEFT JOIN `'.$this->guestbook_table.'` ON `'.$this->entry_table.'`.`guestbook` = '.$this->guestbook_table.'.`id`
		';
		if ($get_inactive == false)
		{
			$where_clause[] = 'approved = 1';
		}
		if (isset($guestbook_id))
		{
			$where_clause[] = 'guestbook = ?';
			$values[] = $guestbook_id;
		}
		foreach($where_clause as $index => $where_part)
		{
			if ($index == 0)
			{
				$query .= ' WHERE '.$where_part;
			}
			else
			{
				$query .= ' AND '.$where_part;
			}
		}
		$query .= ($order_by != 'ASC' ? ' ORDER BY date DESC, entry_id DESC' : ' ORDER BY date ASC, entry_id ASC');

		if (isset($limit))
		{
			$query .= ' LIMIT '.$limit;
		}
		if (isset($offset))
		{
			$query .= ' OFFSET '.$offset;
		}
		
		$result = $this->db->Execute($query, $values);
		return $result;
	}
	
	/**
	 * @param $guestbook_id
	 * @param $entry
	 * @param $errors
	 * @return object pear_ResultSet
	 */
	function InsertEntry($guestbook_id, &$entry)
	{
		$guestbook_id = (int) $guestbook_id;
		
		$new_id = $this->db->GenID($this->GetTablePrefix() . 'seq');
		$entry->timestamp = $this->db->DBTimeStamp(($entry->timestamp == '' ? time() : $entry->timestamp));
		$query = '
			INSERT INTO '.$this->entry_table.'
			(
				entry_id, 
				guestbook, 
				sender, 
				e_mail, 
				homepage, 
				message, 
				date, 
				approved, 
				country, 
				location, 
				ip_address
			)
            	VALUES 
            (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, "'.$_SERVER['REMOTE_ADDR'].'")
		';
        $values = array(
        	$new_id, 
        	$guestbook_id, 
        	$entry->sender->name, 
        	$entry->sender->email, 
        	$entry->sender->homepage, 
        	$entry->message, 
        	substr($entry->timestamp, 1, strlen($entry->timestamp)-2),
        	($entry->IsActive() ? '1' : '0'), 
        	$entry->sender->country, 
        	$entry->sender->location
        );

        $result = $this->db->Execute($query, $values);
        if ($result && $this->db->Affected_Rows() == 1)
        {
        	$entry->entry_id = $new_id;
        	$entry->guestbook_id = $guestbook_id;
        }
		return $result;
	}

	/**
	 * This function creates a UniqID
	 *
	 * @return int The inserted UniqID
	 */
	function CreateUniqID()
	{
		$new_id = $this->db->GenID($this->getTablePrefix() . 'post_seq');
		$uid = uniqid('');
		$query = '
			INSERT INTO '.$this->table_prefix.'post
			(id, idpost) VALUES ('.$new_id.', "'.$uid.'")
		';
		$this->db->Execute($query);
		return $uid;
	}
	
	function DeleteUniqID($id)
	{
		$query = '
			DELETE FROM '.$this->table_prefix.'post
			WHERE idpost = ?
		';
		$result = $this->db->Execute($query, array($id));
		return $result;
	}
	
	function CheckUniqID($id)
	{
		$query = '
			SELECT * FROM '.$this->table_prefix.'post
			WHERE idpost = ?
		';
		$result = $this->db->Execute($query, array($id));
		return $result;
	}
	
	function ActivateEntryById($entry_id)
	{
		$query = 'UPDATE '.$this->entry_table.' SET approved = 1 WHERE entry_id = ?';
		$result = $this->db->Execute($query, array($entry_id));
		return $result;
	}
	
	function DeactivateEntryById($entry_id)
	{
		$query = 'UPDATE '.$this->entry_table.' SET approved = -1 WHERE entry_id = ?';
		$result = $this->db->Execute($query, array($entry_id));
		return $result;
	}
	
	function GetEntryById($entry_id)
	{
		$query = 'SELECT entry_id, sender, e_mail, homepage, country, location, message, date, approved, ip_address, guestbook, '.$this->guestbook_table.'.name as guestbook_name
			FROM `'.$this->entry_table.'` LEFT JOIN `'.$this->guestbook_table.'` ON `'.$this->entry_table.'`.`guestbook` = '.$this->guestbook_table.'.`id` WHERE entry_id = '.$entry_id;
		$result = $this->db->Execute($query);
		return $result;
	}
	
	function DeleteEntryById($entry_id)
	{
		$query = 'DELETE FROM '.$this->entry_table.' WHERE entry_id = ?';
		$result = $this->db->Execute($query, array($entry_id));
		return $result;		
	}

	function DeleteEntriesByGuestbookId($guestbook_id)
	{
		$query = 'DELETE FROM '.$this->entry_table.' WHERE guestbook = ?';
		$result = $this->db->Execute($query, array($guestbook_id));
		return $result;
	}
	
	function GetGuestbookById($guestbook_id)
	{
		$query = 'SELECT * FROM '.$this->guestbook_table.' WHERE id = '.$guestbook_id;
		$result = $this->db->Execute($query);
		return $result;
	}
	
	function ActivateGuestbookById($guestbook_id)
	{
		$query = 'UPDATE '.$this->guestbook_table.' SET active = 1 WHERE id = ?';
		$result = $this->db->Execute($query, array($guestbook_id));
		return $result;
	}
	
	function DeactivateGuestbookById($guestbook_id)
	{
		$query = 'UPDATE '.$this->guestbook_table.' SET active = 0 WHERE id = ?';
		$result = $this->db->Execute($query, array($guestbook_id));
		return $result;
	}
	
	function DeleteGuestbookById($guestbook_id)
	{
		$query = 'DELETE FROM '.$this->guestbook_table.' WHERE id = ?';
		$result = $this->db->Execute($query, array($guestbook_id));
		return $result;
	}
	function UpdateGuestbook($guestbook)
	{
		$query = 'UPDATE '.$this->guestbook_table.' SET name = ?, descr = ?, active = ? WHERE id='.$guestbook->guestbook_id;
		$result = $this->db->Execute($query, array($guestbook->GetName(), $guestbook->GetDescription(), $guestbook->IsActive() ? 1 : 0));
		return $result;
	}
	
}

?>]]></data>
	</file>
	<file>
	  <filename>/lib/classes/module/class.GuestbookEmailhandler.php</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[PD9waHAKCgoKPz4=]]></data>
	</file>
	<file>
	  <filename>/lib/classes/module/class.GuestbookEntry.php</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[PD9waHAgCgpjbGFzcyBHdWVzdGJvb2tFbnRyeQp7Cgl2YXIgJHNlbmRlcjsKCXZhciAkbWVzc2FnZTsKCXZhciAkdGltZXN0YW1wOwoJdmFyICRhY3RpdmU7CgkKCWZ1bmN0aW9uIEd1ZXN0Ym9va0VudHJ5KCYkc2VuZGVyLCAkbWVzc2FnZT0nJywgJGFjdGl2ZT1mYWxzZSwgJHRpbWVzdGFtcD0nJykKCXsKCQkkdGhpcy0+U2V0U2VuZGVyKCRzZW5kZXIpOwoJCSR0aGlzLT5TZXRNZXNzYWdlKCRtZXNzYWdlKTsKCQkkdGhpcy0+U2V0VGltZXN0YW1wKCR0aW1lc3RhbXApOwoJCSR0aGlzLT5TZXRBY3RpdmUoJGFjdGl2ZSk7Cgl9CgkKCWZ1bmN0aW9uIEdldFNlbmRlcigpCgl7CgkJcmV0dXJuICR0aGlzLT5zZW5kZXI7Cgl9CgkKCWZ1bmN0aW9uIFNldFNlbmRlcigmJHNlbmRlcikKCXsKCQkkdGhpcy0+c2VuZGVyID0mICRzZW5kZXI7Cgl9CgkKCWZ1bmN0aW9uIEdldE1lc3NhZ2UoJHNob3J0ZW5fdG89TlVMTCkKCXsKCQlpZiAoaXNzZXQoJHNob3J0ZW5fdG8pKQoJCXsKICAgICAgICAgICAgJG1lc3NhZ2U9c3RyaXBfdGFncygkdGhpcy0+R2V0TWVzc2FnZSgpKTsJCSAgCgkJCXJldHVybiBzdHJsZW4oJG1lc3NhZ2UpID4gJHNob3J0ZW5fdG8gPyBzdWJzdHIoJG1lc3NhZ2UsIDAsICRzaG9ydGVuX3RvKSAuICcuLi4nIDogJG1lc3NhZ2U7CgkJfQoJCXJldHVybiAkdGhpcy0+bWVzc2FnZTsKCX0KCQoJZnVuY3Rpb24gU2V0TWVzc2FnZSgkbWVzc2FnZSkKCXsKCQkkdGhpcy0+bWVzc2FnZSA9ICRtZXNzYWdlOwoJfQoJCglmdW5jdGlvbiBHZXRUaW1lc3RhbXAoKQoJewoJCXJldHVybiAkdGhpcy0+dGltZXN0YW1wOwoJfQoJCglmdW5jdGlvbiBTZXRUaW1lc3RhbXAoJHRpbWVzdGFtcCkKCXsKCQkkdGhpcy0+dGltZXN0YW1wID0gJHRpbWVzdGFtcDsKCX0KCQoJZnVuY3Rpb24gR2V0QWN0aXZlKCkKCXsKCQlyZXR1cm4gJHRoaXMtPmFjdGl2ZTsKCX0KCQoJZnVuY3Rpb24gU2V0QWN0aXZlKCRhY3RpdmUpCgl7CgkJJHRoaXMtPmFjdGl2ZSA9ICRhY3RpdmU7Cgl9CgkKCWZ1bmN0aW9uIElzQWN0aXZlKCkKCXsKCQlyZXR1cm4gJHRoaXMtPkdldEFjdGl2ZSgpOwoJfQoJCglmdW5jdGlvbiBHZXREYXRlKCRkYXRlZm9ybWF0PSdZLW0tZCBIOmk6cycpCgl7CgkJcmV0dXJuIGRhdGUoJGRhdGVmb3JtYXQsIHN0cnRvdGltZSgkdGhpcy0+dGltZXN0YW1wKSk7Cgl9CQp9Cgo/Pg==]]></data>
	</file>
	<file>
	  <filename>/lib/classes/module/class.GuestbookEntrySender.php</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[PD9waHAKCmNsYXNzIEd1ZXN0Ym9va0VudHJ5U2VuZGVyCnsKCXZhciAkbmFtZTsKCXZhciAkZW1haWw7Cgl2YXIgJGlwOwoJdmFyICRjb3VudHJ5OwoJdmFyICRsb2NhdGlvbjsKCXZhciAkaG9tZXBhZ2U7CgkKCWZ1bmN0aW9uIEd1ZXN0Ym9va0VudHJ5U2VuZGVyKCRuYW1lPScnLCAkZW1haWw9JycsICRpcD0nJywgJGNvdW50cnk9JycsICRsb2NhdGlvbj0nJywgJGhvbWVwYWdlPScnKQoJewoJCSR0aGlzLT5zZXROYW1lKCRuYW1lKTsKCQkkdGhpcy0+c2V0RW1haWwoJGVtYWlsKTsKCQkkdGhpcy0+c2V0SXAoJGlwKTsKCQkkdGhpcy0+c2V0Q291bnRyeSgkY291bnRyeSk7CgkJJHRoaXMtPnNldExvY2F0aW9uKCRsb2NhdGlvbik7CgkJJHRoaXMtPnNldEhvbWVwYWdlKCRob21lcGFnZSk7Cgl9CgkKCWZ1bmN0aW9uIEdldE5hbWUoKQoJewoJCXJldHVybiAkdGhpcy0+bmFtZTsKCX0KCQoJZnVuY3Rpb24gU2V0TmFtZSgkbmFtZSkKCXsKCQkkdGhpcy0+bmFtZSA9ICRuYW1lOwoJfQoJCglmdW5jdGlvbiBHZXRFbWFpbCgpCgl7CgkJcmV0dXJuICR0aGlzLT5lbWFpbDsKCX0KCQoJZnVuY3Rpb24gU2V0RW1haWwoJGVtYWlsKQoJewoJCSR0aGlzLT5lbWFpbCA9ICRlbWFpbDsKCX0KCQoJZnVuY3Rpb24gR2V0SXAoKQoJewoJCXJldHVybiAkdGhpcy0+aXA7Cgl9CgkKCWZ1bmN0aW9uIFNldElwKCRpcCkKCXsKCQkkdGhpcy0+aXAgPSAkaXA7Cgl9CgkKCWZ1bmN0aW9uIEdldENvdW50cnkoKQoJewoJCXJldHVybiAkdGhpcy0+Y291bnRyeTsKCX0KCQoJZnVuY3Rpb24gU2V0Q291bnRyeSgkY291bnRyeSkKCXsKCQkkdGhpcy0+Y291bnRyeSA9ICRjb3VudHJ5OwoJfQoJCglmdW5jdGlvbiBHZXRMb2NhdGlvbigpCgl7CgkJcmV0dXJuICR0aGlzLT5sb2NhdGlvbjsKCX0KCQoJZnVuY3Rpb24gU2V0TG9jYXRpb24oJGxvY2F0aW9uKQoJewoJCSR0aGlzLT5sb2NhdGlvbiA9ICRsb2NhdGlvbjsKCX0KCQoJZnVuY3Rpb24gR2V0SG9tZXBhZ2UoKQoJewoJCXJldHVybiAkdGhpcy0+aG9tZXBhZ2U7Cgl9CgkKCWZ1bmN0aW9uIFNldEhvbWVwYWdlKCRob21lcGFnZSkKCXsKCQkkdGhpcy0+aG9tZXBhZ2UgPSAkaG9tZXBhZ2U7Cgl9CgkKCWZ1bmN0aW9uIEdldEVtYWlsQ2xvYWtlZCgpCgl7CgkJcmV0dXJuIHN0cl9yZXBsYWNlKCcuJywgJyA8ZG90PiAnLCBzdHJfcmVwbGFjZSgnQCcsICcgPGF0PiAnLCAkdGhpcy0+R2V0RW1haWwoKSkpOwoJfQoKfQoKPz4=]]></data>
	</file>
	<file>
	  <filename>/lib/classes/module/class.GuestbookFrontend.php</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[<?php

define('CMS_GB_ERROR_NOSENDER'     , 'CMS_GB_ERROR_NOSENDER');
define('CMS_GB_ERROR_NOMESSAGE'    , 'CMS_GB_ERROR_NOMESSAGE');
define('CMS_GB_ERROR_UNIQUE'       , 'CMS_GB_ERROR_UNIQUE');
define('CMS_GB_ERROR_TOOSOON'      , 'CMS_GB_ERROR_TOOSOON');
define('CMS_GB_ERROR_INVALID_EMAIL', 'CMS_GB_ERROR_INVALIDEMAIL');
define('CMS_GB_ERROR_TOOLONG'      , 'CMS_GB_ERROR_TOOLONG');
define('CMS_GB_ERROR_CAPTCHA'      , 'CMS_GB_ERROR_CAPTCHA');
define('CMS_GB_ERROR_BADWORDS'     , 'CMS_GB_ERROR_BADWORDS');

/**
 * Guestbook module frontend
 */
class GuestbookFrontend
{
	/**
	 * @var object Reference to the CMS ADOdb connection object
	*/
	var $dbhandler;
	
	/**
	 * @var object Reference to the global Smarty object
	*/
	var $smarty;
	
	/**
	 * @var string Current mode
	*/
	var $mode;
	
	/**
	 * @var array Valid modes Currently 'guestbook', 'entrylist', 'form' and 'entry'
	*/
	var $valid_modes;
	
	/**
	 * @var boolean show smileys (in the messages and on the submit form)
	*/
	var $show_smileys;
	
	/**
	 * @var boolean show a captcha on the submit form
	*/
	var $show_captcha;
	
	/**
	 * @var boolean show "Insert entry" button instead of the insert form
	*/
	var $show_insertbutton;
	
	/**
	 * @var boolean hides the "Insert entry" button after a successful post
	*/
	var $hide_insertbutton_after_post;
	
	/**
	 * Guestbook Frontend class constructor
	 * @param int $id
	 * @param mixed $returnid
	 * @param array $params
	 * @param object $dbhandler
	 * @param object $smarty
	 */
	function GuestbookFrontend(&$dbhandler, &$smarty)
	{
		$this->dbhandler =& $dbhandler;
		$this->smarty =& $smarty;
		
		// define valid modes
		$valid_modes = array(
			'guestbook',
			'form',
			'entrylist',
			'entry'
		);
		$this->SetValidModes($valid_modes);
		$this->SetMode('guestbook');

		$this->SetShowSmileys(false);
		$this->SetShowCaptcha(false);
		$this->SetShowInsertButton(true);
		$this->SetHideInsertButtonAfterPost(true);
	}
	
	/**
	 * Initializes (determins and sets) the Frontend mode
	 * @param $params
	 * @return unknown_type
	 */
	function InitMode($params)
	{
		$mode = 'guestbook';
	
		if (isset($params['mode']))
		{
			if (in_array($params['mode'], $this->GetValidModes()))
			{
				$mode = $params['mode'];
			}
		}

		// set mode to 'entry' if show_entry is used in the HTTP request
		if (isset($_REQUEST['show_entry']))
		{
			$mode = 'entry';
			$params['show_entry'] = (int) $_REQUEST['show_entry'];
		}
		
		// set mode to 'entry' if the parameter show_entry is set
		if ($params['show_entry'] != '')
		{
			$mode = 'entry';
		}
		
		// set the Frontend mode
		$this->SetMode($mode);
	}
	
	/**
	 * @return array
	 */
	function GetValidModes()
	{
		return $this->valid_modes;
	}
	/**
	 * @param array
	 */
	function SetValidModes($modes)
	{
		$this->valid_modes = $modes;
	}
	
	/**
	 * @return string
	 */
	function GetMode()
	{
		return $this->mode;
	}
	/**
	 * @param string
	 * @return boolean
	 */
	function SetMode($mode)
	{
		if (! in_array($mode, $this->GetValidModes()))
		{
			return FALSE;
		}
		else
		{
			$this->mode = $mode;
			return TRUE;
		}
	}
	
	/**
	 * @param boolean
	 */
	function SetShowInsertButton($show_insertbutton)
	{
		$this->show_insertbutton = $show_insertbutton;
	}
	/**
	 * @return boolean
	*/
	function GetShowInsertButton()
	{
		return $this->show_insertbutton;
	}
	
	/**
	 * @param boolean
	*/
	function SetHideInsertButtonAfterPost($hide_insertbutton_after_post)
	{
		$this->hide_insertbutton_after_post = $hide_insertbutton_after_post;
	}
	/**
	 * @return boolean
	*/
	function GetHideInsertButtonAfterPost()
	{
		return $this->hide_insertbutton_after_post;
	}
	/**
	 * @param boolean
	*/
	function SetShowSmileys($show_smileys)
	{
		$this->show_smileys = $show_smileys;
	}
	/**
	 * @return boolean
	*/
	function GetShowSmileys()
	{
		return $this->show_smileys;
	}
	
	/**
	 * @param boolean
	*/
	function SetShowCaptcha($show_captcha)
	{
		$this->show_captcha = $show_captcha;
	}
	/**
	 * @return boolean
	*/
	function GetShowCaptcha()
	{
		return $this->show_captcha;
	}
	
	/**
	 * @param array
	*/
	function InitCaptcha($captcha)
	{
		$show_captcha = FALSE;
		if ($captcha && Guestbook::ModuleIsInstalled('Captcha'))
		{
			$show_captcha = TRUE;
		}
		$this->SetShowCaptcha($show_captcha);
		
	}
	
	/**
	 * Process a submitted guestbook entry
	 */
	function ProcessPost($id, $params, $returnid)
	{
		global $gCms;
		$mod =& $gCms->modules['Guestbook']['object'];
        $allowed = '<strong>,<em>,<u>,<font>,<span>';
        if($mod->ModuleIsInstalled('FCKeditorX') && $mod->GetPreference('wysiwyg') == '1' && $this->getShowSmileys() && Guestbook::ModuleIsInstalled('Smileys'))
            $allowed .= ',<img>'; // TODO: Enhancement needed (for now, all image can be used)
		if (isset($params['entry_submitted']) && !isset($params['cancel'])) 
		{
			// Get a Captcha module instance if needed
			$captcha = NULL;
			if ($this->GetShowCaptcha()) 
			{
				$captcha =& $mod->getModuleInstance('Captcha');
			}
			
			// validate the entry
			$errors = $this->ValidatePost($params, $captcha);
		
			if (!empty($errors))
			{
				// show errors
				$gb_error_messages = array(
					CMS_GB_ERROR_NOSENDER      => 'fabsend',
					CMS_GB_ERROR_NOMESSAGE     => 'fmessag',
					CMS_GB_ERROR_UNIQUE        => 'fui',
					CMS_GB_ERROR_TOOSOON       => 'toosoon',
					CMS_GB_ERROR_INVALID_EMAIL => 'femail',
					CMS_GB_ERROR_TOOLONG       => 'tolong',
					CMS_GB_ERROR_CAPTCHA       => 'captcha_failure_message',
					CMS_GB_ERROR_BADWORDS      => 'badwords_message'
				);
				foreach($errors as $index => $gb_error)
				{
					switch (gettype($gb_error))
					{
						case 'string': 
							$errors[$index] = $mod->Lang($gb_error_messages[$gb_error]);
							break;
						case 'array':
							$errors[$index] = $mod->Lang($gb_error_messages[$gb_error[0]], $gb_error[1]);
							break;
					}
				}
				$this->Errors = $errors;
				if ($errors[0] == $mod->Lang($gb_error_messages[CMS_GB_ERROR_UNIQUE]))
				{
					$this->SetShowInsertButton(true);
				}
				else
				{
					$this->SetShowInsertButton(false);
				}
			}
			else
			{
				// set the badwords parameter
				$params['badwords'] = explode(',', str_replace("\n",',', $mod->GetPreference('badwords')));
				foreach ($params['badwords'] as $index => $word)
				{
					if (trim($word) == '') {
						unset($params['badwords'][$index]);
					}
					else
					{
						$params['badwords'][$index] = trim($word);
					}
				}
				// apply bad word filter
				if (!empty($params['badwords']))
				{
					$alt_chars = array
						(
							'/a/i' => '[a@]',
							'/b/i' => '[b3]',
							'/i/i' => '[i1!|]',
							'/s/i' => '[s\$5]',
							'/t/i' => '[t+]',
							'/z/i' => '[z2]'
						);
					$badwords = $params['badwords'];
					array_walk($badwords, array($this, 'MakeRegex'), $alt_chars);
					$params['message'] = preg_replace($badwords, $mod->GetPreference('badwords_replacement'), $params['message']);
				}
				
				{
					// strip HTML tags in these params var
                    $prms=array('sender_name' => '', 'sender_country' => '', 'sender_location' => '', 'sender_email' => '', 'sender_homepage' => '', 'message' => '');
					foreach ($params as $index => $value)
					{
						if ($index == 'message' && $mod->GetPreference('wysiwyg') == '1' && $mod->ModuleIsInstalled('FCKeditorX'))
						{
                            $params['message'] = strip_tags($value,$allowed);
						}elseif(isset($prms[$index])){
                            $params[$index] = strip_tags($value);
						}
					}
				}
				
				// prepare the entry for insertion
				require_once(cms_join_path($mod->getModulePath(), 'lib', 'classes', 'module', 'class.GuestbookEntry.php'));
				require_once(cms_join_path($mod->getModulePath(), 'lib', 'classes', 'module', 'class.GuestbookEntrySender.php'));
				$sender = new GuestbookEntrySender(
					$params['sender_name'],
					isset($params['sender_email']) ? $params['sender_email'] : '',
					$_SERVER['REMOTE_ADDR'],
					isset($params['sender_country'])  ? $params['sender_country'] : '',
					isset($params['sender_location']) ? $params['sender_location'] : '',
					isset($params['sender_homepage']) ? $params['sender_homepage'] : ''
				);
				$entry = new GuestbookEntry(
					$sender,
					$params['message'],
					$params['shownow'] == '1' ? true : false
				);
				// insert the entry
				$mod->InsertEntry($params['guestbook'], $entry);
				
				// set the lastpost session variable
				$_SESSION['CMSGuestbook']['lastpost'] = time();
				
				// delete the unique ID from the database
				$this->dbhandler->DeleteUniqID($_POST['uid']);
				
				// assign a message to the frontend
				$this->Messages[] = $mod->Lang($entry->IsActive() ? 'showitnow' : 'showitlater');
		
				
				/**
				* E-Mailnotification
				*/
				if (isset($params['mailnoti']) && trim($params['mailnoti']) != '')
				{
				    $params['mailnoti'] = trim($params['mailnoti']);
                    $this->SendNotificationEmail($params);
				}
			}
		}
	}	
	
	function SendNotificationEmail($params)
	{
		global $gCms;
		$mod =& $gCms->modules['Guestbook']['object'];
        
		if(strpos(str_replace("\n", ',', $params['mailnoti']), ',') !== FALSE){
		   $e_mailnoti_to = explode(',', $params['mailnoti']);
		}else{
		   $e_mailnoti_to = array($params['mailnoti']);
		}
        
		$e_mailnoti_subj = html_entity_decode($mod->Lang('e_mailnotibetr'), ENT_QUOTES, 'UTF-8');
		
		// create the notification E-mail message text
		$this->smarty->assign('notification_message', html_entity_decode($mod->Lang('e_mailnotimessage'),ENT_QUOTES,'UTF-8'));
	
		//  array: input field name => language field name; unfortunately email differs. 
		$fields = array(
			'sender_name' 	=> 'sender',
			'message' 	=> 'message',
			'sender_country' 	=> 'country',
			'sender_location' 	=> 'location',
			'sender_email'	=> 'email',
			'sender_homepage' 	=> 'homepage'); 
		
		foreach($fields as $field => $field_lang)
		{
			if ($params[$field] != '')
			{
				$titles[$field_lang] = html_entity_decode($mod->Lang($field_lang), ENT_QUOTES, 'UTF-8');
				$values[$field_lang] = $params[$field];
			}
		}

		$titles['module_link'] = html_entity_decode($mod->Lang('module_friendlyname'), ENT_QUOTES, 'UTF-8');
		$values['module_link'] = $mod->CreateLink($id, 'default', $returnid, '', array('guestbook' => $params['guestbook']), '', TRUE);
		
		$titles['admin_link'] = html_entity_decode($mod->Lang('title_mod_admin'), ENT_QUOTES, 'UTF-8');
		$values['admin_link'] = $gCms->config['root_url'].'/'.$gCms->config['admin_dir'].'/moduleinterface.php?module=Guestbook';
		
		$this->smarty->assign('titles', $titles);
		$this->smarty->assign('values', $values);
		$msg = $mod->ProcessTemplateFromDatabase('guestbook-email');
		
		// send the mail
		# see if the CMSMailer module is installed
		$cmsmailer_installed = FALSE;
		$cmsmailer = NULL;
		foreach($gCms->modules as $module) 
		{
			if (strtolower(get_class($module['object'])) == 'cmsmailer') 
			{ 
				$cmsmailer_installed = TRUE;
				$cmsmailer =& $module['object'];
			}
		}
		if ($cmsmailer_installed)
		{
            foreach($e_mailnoti_to as $one_email){
                if($one_email != ''){
                    $cmsmailer->SetCharSet('UTF-8');
                    $cmsmailer->AddAddress($one_email);
                    $cmsmailer->SetSubject($e_mailnoti_subj);
        			$cmsmailer->SetBody($msg);
        			$cmsmailer->Send();
        			$cmsmailer->reset();
                }
            }
		} else {
			$headers = "MIME-Version: 1.0\nContent-Transfer-Encoding: 8bit\nContent-Type: text/plain; charset=\"UTF-8\"";
			$encoded_subject = "=?UTF-8?B?".base64_encode($e_mailnoti_subj)."?=\n";
			mail(
				str_replace("\n", ',', $params['mailnoti']), 	// address to send the mail to
				$encoded_subject, 	// E-mail subject
				$msg,			// The E-mail message
				$headers		// Additional mail headers
			);
		}
		
	}
	
	/**
	 * @param array $params
	 * @param object $captcha
	 * @return array Error messages if validation fails; empty array if validation successful
	 */
	function ValidatePost($params, &$captcha)
	{
		$errors = array();
		$timespan  = $params['timespan'];
		
		// Trim empty space
		$params['sender_name']  = (isset($params['sender_name'])  ? trim($params['sender_name'])  : '');
		$params['message']      = (isset($params['message'])      ? trim($params['message'])      : '');
		
		// Prevent page reload double post
		if (isset($params['uid']))
		{
			if(!$this->CheckUniqID($params['uid']))
			{
				$errors[] = CMS_GB_ERROR_UNIQUE;
				return $errors;
			}
		}
		
		// Check minimal timespan
		if (isset($_SESSION['CMSGuestbook']['lastpost']))
		{
			$time_between = time() - $_SESSION['CMSGuestbook']['lastpost'];
			if ($time_between < $timespan)
			{
				$errors[] = array(CMS_GB_ERROR_TOOSOON, array($time_between, $timespan));
			}
		}
		
		// Validate E-mail address
		if ($params['sender_email'] != '')
		{
			$expr = "/^([\w\!\#$\%\&'\*\+\-\/\=\?\^\`{\|\}\~]+\.)*[\w\!\#$\%\&'\*\+\-\/\=\?\^\`{\|\}\~]+@((((([a-z0-9]{1}[a-z0-9\-]{0,62}[a-z0-9]{1})|[a-z])\.)+[a-z]{2,6})|(\d{1,3}\.){3}\d{1,3}(\:\d{1,5})?)$/i"; // By James Watts and Francisco Jose Martin Moreno
			if (preg_match($expr, $params['sender_email']))
			{
				$emaildress = $params['sender_email'];
			}
			else
			{
				$errors[] = CMS_GB_ERROR_INVALID_EMAIL;
			}
		}
		// Check if fields are filled in
		if (!$params['sender_name'])
		{
			$errors[] = CMS_GB_ERROR_NOSENDER;
		}
		if (!$params['message'])
		{
			$errors[] = CMS_GB_ERROR_NOMESSAGE;
		}
		
		// Check if the message is not too long
		$maxlength = $params['textleng'];
		if ($maxlength > 0)
		{
			$lengofmessage = mb_strlen($params['message']);
			if ($lengofmessage > $maxlength)
			{
				$errors[] = CMS_GB_ERROR_TOOLONG;
			}
		}
		
		// Captha check
		if ($captcha != NULL) 
		{
			if (! $captcha->CheckCaptcha($params['captcha_phrase']))
			{
				$errors[] = CMS_GB_ERROR_CAPTCHA;
			}
		}
		return $errors;
	}
	
	/**
	 * Checks if an unique ID exists
	 *
	 * @param string $id The Uniqid to check for
	 * @return bool
	 */
	function CheckUniqID($id)
	{
		$result = $this->dbhandler->CheckUniqID($id);
		return ($result && $result->RecordCount() > 0) ? true : false;
	}
	
	function MakeRegex(&$word, $key, $altChars)
	{
		$word = ('/'.preg_replace(array_keys($altChars), $altChars, $word).'/i');
	}
	
	/**
	 * Outputs the guestbook frontend HTML
	 */
	function Show($id, $params, $returnid)
	{
		$this->SetShowSmileys($params['smiley'] == '1' ? true : false);
		$this->SetShowInsertButton($params['showaddform'] == 1  ? false : true);
		$this->SetHideInsertButtonAfterPost($params['hide_insertbutton_after_post'] == '1' ? true : false);
		$this->InitMode($params);
		switch($this->GetMode())
		{
			case 'form':
			case 'entrylist':
			case 'entry':
				$this->{'Show' . ucfirst($this->GetMode())}($id, $params, $returnid);
				break;
			default:
				$this->ShowGuestbook($id, $params, $returnid);
		}
	}
	
	function ShowForm($id, $params, $returnid)
	{
		echo $this->GetFormHTML($id, $params, $returnid);
	}
	
	function GetFormHTML($id, $params, $returnid)
	{
		if ($this->GetShowInsertButton())
		{
			return $this->GetInsertButtonHTML($id, $params, $returnid);
		}
		else
		{
			return $this->GetEntryFormHTML($id, $params, $returnid);
		}
		return '';
	}
	
	function GetInsertButtonHTML($id, $params, $returnid)
	{
		global $gCms;
		$mod =& $gCms->modules['Guestbook']['object'];
		$this->smarty->assign('formstart', $mod->CreateFormStart($id, 'default', $returnid, 'post', '', TRUE, ''));
		$this->smarty->assign('hidden'   , $mod->CreateInputHidden($id, 'showaddform', '1'));
		$this->smarty->assign('submit'   , $mod->CreateInputSubmit($id, 'submit', $mod->Lang('neuein')));
		$this->smarty->assign('formend'  , $mod->CreateFormEnd());
		
		$this->smarty->assign('guestbook', $this);
		
		return $mod->ProcessTemplateFromDatabase('guestbook-showform-button');
	}
	
	function GetEntryFormHTML($id, $params, $returnid)
	{
		global $gCms;
		$mod =& $gCms->modules['Guestbook']['object'];
		
		{ // assign titles
			$titles = array(
				'sender'          => $mod->Lang('inam'),
				'country'         => $mod->Lang('country'),
				'location'        => $mod->Lang('location'),
				'email'           => $mod->Lang('email'),
				'homepage'        => $mod->Lang('homepage'),
				'message'         => $mod->Lang('smessage'),
				'chars_remaining' => $mod->Lang('alength'),
                'id'              => $id
			);
			if ($this->GetShowSmileys())
			{
				$titles['smileys'] = $mod->Lang('title_table_smileys');
			}
			if ($this->GetShowCaptcha())
			{
				$titles['captcha'] = $mod->Lang('captcha_title');
			}
			$this->smarty->assign('titles', $titles);
		}

		{ // assign formstart
			$uid = (isset($params['uid']) ? $params['uid'] : $this->dbhandler->CreateUniqID());
			
			$this->smarty->assign('formstart', $mod->CreateFormStart($id, 'default', $returnid, 'post', '', TRUE, '', array('showaddform'=>'1', 'uid'=>$uid)));
		}
		{ // assign the inputs
			$inputs = array();
			$inputs['sender']   = $mod->CreateInputText($id, 'sender_name'    , $params['sender_name']    , '24', '255', '');
			$inputs['email']    = $mod->CreateInputText($id, 'sender_email'   , $params['sender_email']   , '24', '255', '');
			$inputs['homepage'] = $mod->CreateInputText($id, 'sender_homepage', $params['sender_homepage'], '24', '255', '');
			$inputs['country']  = $mod->CreateInputText($id, 'sender_country' , $params['sender_country'] , '24', '255', '');
			$inputs['location'] = $mod->CreateInputText($id, 'sender_location', $params['sender_location'], '24', '255', '');
			$inputs['message']  = $mod->CreateTextarea(FALSE, $id, $params['message'], 'message', '', 'guestbook_message_input', '', '', '50', '5');
			$inputs['submit']   = $mod->CreateInputSubmit($id, 'entry_submitted', $mod->Lang('ginsert'));
    		if ($this->GetShowCaptcha())
    		{
                $inputs['captcha'] = $mod->CreateInputText($id, 'captcha_phrase', $params['captcha_phrase'], '24', '255', '');
    		}
			if ($this->Getmode() != 'form')
			{
				$inputs['cancel'] = $mod->CreateInputSubmit($id, 'cancel', $mod->Lang('cancel'));
			}
			
			$this->smarty->assign('inputs', $inputs);
		}

		// assign formend
		$this->smarty->assign('formend', $mod->CreateFormEnd());
	
		{ // assign values
			$values = array();
			foreach (array('guestbook', 'sender', 'country', 'location', 'e_mail', 'homepage', 'message') as $field)
			{
				$values[$field] = isset($params['entry_submitted']) && !isset($params['cancel']) ? $params[$field] : '';
			}
			$this->smarty->assign('values'  , $values);
		}
		// counter
		$this->smarty->assign('counter', (!isset($params['cancel']) && isset($_POST['counter'])) ? $_POST['counter'] : $params['textleng']);
		$this->smarty->assign('max_textleng', $params['textleng']);
		
		$this->smarty->assign('toolong', $mod->Lang('tolong'));
		
		
		$labels['insert'] = $mod->Lang('ginsert');
		$labels['cancel'] = $mod->Lang('cancel');
		$this->smarty->assign('labels', $labels);

		if ($mod->ModuleIsInstalled('FCKeditorX') && $mod->GetPreference('wysiwyg') == '1')
		{
			require_once(cms_join_path($gCms->config['root_path'], 'modules', 'FCKeditorX', 'FCKeditor', 'fckeditor.php'));
			$oFCKeditor = new FCKeditor($id.'message');
            $this->smarty->assign('id', $id);
			$oFCKeditor->BasePath = $gCms->config['root_url'].'/modules/FCKeditorX/FCKeditor/';
			$oFCKeditor->Config['CustomConfigurationsPath'] = $gCms->config['root_url'].'/modules/Guestbook/fckconfig.js.php'.(($this->getShowSmileys() && Guestbook::ModuleIsInstalled('Smileys'))?'?smiley&amp;SmileyList=':'');
            $oFCKeditor->Config['EnterMode'] = 'br';
			$oFCKeditor->Value = $values['message'];
			$oFCKeditor->ToolbarSet = 'Guestbook';
            
	       /* Found this to get smiley working. I think it's not very clean but it work at all ;) */
			if ($this->getShowSmileys() && $mod->ModuleIsInstalled('Smileys'))
			{
				$smiley_handler =& $mod->GetSmileyHandler();
                $list =& $smiley_handler->GetSmileyList();
				$oFCKeditor->Config['SmileyPath'] = $gCms->config['root_url'] . $smiley_handler->GetBaseUrl();
                $txt='';
                $cnt=mb_strlen($oFCKeditor->Config['CustomConfigurationsPath']);
                foreach ($list as $smiley=>$url) 
				{
				    $temp  = str_replace('"', '&quot;', '"'.$smiley.'",');
                    if((mb_strlen($temp) + $cnt)<=4000)
				        $txt  .= $temp; else break;
				}
                $oFCKeditor->Config['CustomConfigurationsPath'] .= mb_substr($txt,0,-1);
			}
			else
			{
				
			}
			$this->smarty->assign('wysiwyg', $oFCKeditor->CreateHtml());
		}
		
		if ($this->GetShowCaptcha())
		{
			$captcha =& $mod->getModuleInstance('Captcha');
			$this->smarty->assign('captcha_title', $mod->Lang('captcha_title'));
			$this->smarty->assign('captcha', $captcha->getCaptcha());
		}
		
		if ($this->GetShowSmileys() && !($mod->ModuleIsInstalled('FCKeditorX') && $mod->GetPreference('wysiwyg') == '1'))
		{
			$html = "
			<script language=\"JavaScript\" type=\"text/javascript\">
            <!--
				function emoticon(text)
				{
					var textarea = document.getElementById('guestbook_message_input');
					// Attempt to create a text range (IE).
					if ((textarea.caretPos != null) && (textarea.createTextRange != null))
					{
						var caretPos = textarea.caretPos;
					
						caretPos.text = caretPos.text.charAt(caretPos.text.length - 1) == ' ' ? text + ' ' : text;
						caretPos.select();
					}
					// Firefox text range replace.
					else if (textarea.selectionStart != null)
					{
	                    text = ' ' + text + ' ';
						var begin = textarea.value.substr(0, textarea.selectionStart);
						var end = textarea.value.substr(textarea.selectionEnd);
						var scrollPos = textarea.scrollTop;
						
						textarea.value = begin + text + end;
						
						if (textarea.setSelectionRange)
						{
							textarea.focus();
							textarea.setSelectionRange(begin.length + text.length, begin.length + text.length);
						}
						textarea.scrollTop = scrollPos;
					}
					// Just put it on the end.
					else
					{
						textarea.value += ' ' + text;
						textarea.focus(textarea.value.length - 1);
					}
				}
            -->
			</script>
			";
			if ($mod->ModuleIsInstalled('Smileys'))
			{
				$smiley_handler =& $mod->GetSmileyHandler();
				$list = $smiley_handler->SmileysModuleInstance->GetSomeSmileys();
				if (count($list) > 0)
				{
					$html .= "<span class=\"cms-guestbook-somesmileys\">";
					foreach ($list as $smiley=>$url) 
					{
					    $smiley  = str_replace('"', "&quot;", $smiley); // escape " for proper HTML
					    $jsparam = str_replace("'", "\'"    , $smiley); // escape ' for proper JS call
					    $html .= "<a href=\"javascript:emoticon('$jsparam')\" title=\"$smiley\">$url</a>\n";
					}
					$html .= "</span>";
					$html .= $smiley_handler->SmileysModuleInstance->GetPopupExampleLink('','default','emoticon');
					$this->smarty->assign('smileys', $html);
				}
			} 
			else 
			{
				$this->smarty->assign('smiley_table_title', $mod->Lang('title_table_smileys'));
				$this->smarty->assign('smiley_dir'        , $gCms->config['root_url'] . '/modules/' . $mod->GetName() . '/images/smileys/default');
				$this->smarty->assign('smileys', $html . $mod->ProcessTemplate('smiley.tpl'));
			}
		}
		$this->smarty->assign('guestbook', $this);
		return $mod->ProcessTemplateFromDatabase('guestbook-form');
	}
	
	function ShowEntrylist($id, $params, $returnid)
	{
		echo $this->GetEntrylistHTML($id, $params, $returnid);
	}
	
	function GetEntrylistHTML($id, $params, $returnid)
	{
		global $gCms;

		$mod =& $gCms->modules['Guestbook']['object'];
		
		// initialize session
		if (!isset($_SESSION))
		{
			session_start();
		}
	
		// initialize pagination
		{
            require_once(cms_join_path($mod->getModulePath(), 'lib', 'classes', 'Pagination.class.php'));
            $pag_id = $id . '_' . $returnid; // id used for pagination
            $limit = (isset($params['number']) && (int) $params['number'] > 0) ? (int) $params['number'] : 10;
            $pagination= new Pagination($pag_id, $mod->GetNumberOfEntries($params['guestbook']), $limit, $pag_id, ($params['sortasc'] == 'ASC' ? 0 : 1));
            $pagination->setUrl(($returnid!='__CMS_PREVIEW_PAGE__')?$gCms->GetContentOperations()->LoadContentFromAlias($returnid)->GetURL():'http'.((!empty($_SERVER['HTTPS']))?'s' : '') . '://'.$_SERVER['SERVER_NAME'].preg_replace('#\?(.+)$#','',$_SERVER['REQUEST_URI']));
            $pagination->assignArray($this->smarty);
		}
			
		// get the entries to be shown
		$order_by = ($params['sortasc'] == '1' ? 'ASC' : 'DESC');
		$entries = $mod->GetEntries($pagination, (int) $params['guestbook'], $order_by);
		
		$this->smarty->assign('dateformat', isset($params['dateformat']) ? $params['dateformat'] : $mod->GetPreference('dateformat'));
		foreach ($entries as $entry_id => $entry)
		{
			if ($this->getShowSmileys())
			{
				$smiley_handler =& $mod->GetSmileyHandler();
				$entry->message = $smiley_handler->InsertSmileys($entry->message);
			}
			$entry->message = nl2br($entry->message);
			$entries[$entry_id] = $entry;
		}
		$this->smarty->assign('entries', $entries);
		
		// assign titles
		$titles = array(
			'date'      => $mod->Lang('sdate'),
			'time_hour' => $mod->Lang('uhr'),
			'sender'    => $mod->Lang('inam'),
			'country'   => $mod->Lang('country'),
			'location'  => $mod->Lang('location'),
			'e_mail'    => $mod->Lang('email'),
			'homepage'  => $mod->Lang('homepage'),
			'message'   => $mod->Lang('smessage')
		);
		$this->smarty->assign('titles', $titles);
		
		// assign pagination labels
		$this->smarty->assign('first_text', $mod->Lang('first_text'));
		$this->smarty->assign('prev_text', $mod->Lang('prev_text'));
		$this->smarty->assign('next_text', $mod->Lang('next_text'));
		$this->smarty->assign('last_text', $mod->Lang('last_text'));
		$this->smarty->assign('pagination_message', $mod->Lang('message'));
		$this->smarty->assign('pagination_of', $mod->Lang('pagination_of'));

		$this->smarty->assign('pag_id', $pag_id);

		// process the template
		return $mod->ProcessTemplateFromDatabase('guestbook-entrylist');
	}
	
	function ShowEntry($id, $params, $returnid)
	{
		global $gCms;
		$mod =& $gCms->modules['Guestbook']['object'];
		$mod->DoAction('show-entry', $id, $params, $returnid);
	}

	function ShowGuestbook($id, $params, $returnid)
	{
		echo $this->GetGuestbookHTML($id, $params, $returnid);
	}
	
	function GetGuestbookHTML($id, $params, $returnid)
	{
		global $gCms;
		$mod =& $gCms->modules['Guestbook']['object'];
		
		$this->smarty->assign('form', $this->GetFormHTML($id, $params, $returnid));
		$this->smarty->assign('entrylist', $this->GetEntrylistHTML($id, $params, $returnid));
		
		return $mod->ProcessTemplateFromDatabase('guestbook');
	}
	
}

?>
]]></data>
	</file>
	<file>
	  <filename>/lib/classes/module/class.GuestbookGuestbook.php</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[PD9waHAKCmNsYXNzIEd1ZXN0Ym9va0d1ZXN0Ym9vawp7Cgl2YXIgJG5hbWU7Cgl2YXIgJGRlc2NyaXB0aW9uOwoJdmFyICRhY3RpdmU7CgkKCWZ1bmN0aW9uIEd1ZXN0Ym9va0d1ZXN0Ym9vaygkbmFtZT0nJywgJGRlc2NyaXB0aW9uPScnLCAkYWN0aXZlPXRydWUpCgl7CgkJJHRoaXMtPlNldE5hbWUoJG5hbWUpOwoJCSR0aGlzLT5TZXREZXNjcmlwdGlvbigkZGVzY3JpcHRpb24pOwoJCSR0aGlzLT5TZXRBY3RpdmUoJGFjdGl2ZSk7Cgl9CgkKCWZ1bmN0aW9uIFNldE5hbWUoJG5hbWUpCgl7CgkJJHRoaXMtPm5hbWUgPSAkbmFtZTsKCX0KCQoJZnVuY3Rpb24gR2V0TmFtZSgpCgl7CgkJcmV0dXJuICR0aGlzLT5uYW1lOwoJfQoJCglmdW5jdGlvbiBTZXREZXNjcmlwdGlvbigkZGVzY3JpcHRpb24pCgl7CgkJJHRoaXMtPmRlc2NyaXB0aW9uID0gJGRlc2NyaXB0aW9uOwoJfQoJCglmdW5jdGlvbiBHZXREZXNjcmlwdGlvbigpCgl7CgkJcmV0dXJuICR0aGlzLT5kZXNjcmlwdGlvbjsKCX0KCQoJZnVuY3Rpb24gU2V0QWN0aXZlKCRhY3RpdmUpCgl7CgkJJHRoaXMtPmFjdGl2ZSA9ICRhY3RpdmU7Cgl9CgkKCWZ1bmN0aW9uIEdldEFjdGl2ZSgpCgl7CgkJcmV0dXJuICR0aGlzLT5hY3RpdmU7Cgl9CgkKCWZ1bmN0aW9uIElzQWN0aXZlKCkKCXsKCQlyZXR1cm4gJHRoaXMtPkdldEFjdGl2ZSgpOwoJfQp9Cgo/Pg==]]></data>
	</file>
	<file>
	  <filename>/lib/classes/module/class.GuestbookSmileyHandler.php</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[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]]></data>
	</file>
	<file>
	  <filename>/lib/classes/module/index.html</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[]]></data>
	</file>
	<file>
	  <filename>/lib/classes/Pagination.class.php</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[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]]></data>
	</file>
	<file>
	  <filename>/lib/index.html</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[]]></data>
	</file>
	<file>
	  <filename>/method.install.php</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[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]]></data>
	</file>
	<file>
	  <filename>/method.uninstall.php</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[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]]></data>
	</file>
	<file>
	  <filename>/method.upgrade.php</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[<?php
#CMS - CMS Made Simple
#(c)2004 by Ted Kulp (wishy@users.sf.net)
#This project's homepage is: http://cmsmadesimple.sf.net
#
#This program is free software; you can redistribute it and/or modify
#it under the terms of the GNU General Public License as published by
#the Free Software Foundation; either version 2 of the License, or
#(at your option) any later version.
#
#This program is distributed in the hope that it will be useful,
#but WITHOUT ANY WARRANTY; without even the implied warranty of
#MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
#GNU General Public License for more details.
#You should have received a copy of the GNU General Public License
#along with this program; if not, write to the Free Software
#Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
#
#$Id$

/**
 * The Upgrade function
 *
 * If your module version number does not match the version<br/>
 * number of the installed module, the CMS Admin will give<br/>
 * you a chance to upgrade the module. This is the function<br/>
 * that actually handles the upgrade.<br/>
 * Ideally, this function should handle upgrades incrementally,<br/>
 * so you could upgrade from version 0.0.1 to 10.5.7 with<br/>
 * a single call. For a great example of this, see the News<br/>
 * module in the standard CMS install.<br/>
*/

// No direct access
if (!isset($gCms)) 
{
	exit();
}

// Get a reference to the CMS ADOConnection object
$db =& $this->cms->GetDb();

// Set the current_version variable
$current_version = $oldversion;

// Prevent the guestbook-form being set more than once
$form_template_is_installed = false;

// Upgrade the module
switch($current_version)
{
    case "1.0-rc1":
    {
        $dict = NewDataDictionary($db);
        
        # note: The last parameter I(INT) is not as documented but the only way I get ADOdb's RenameColumnSQL to return working sql 
        # (the parameter only influences MySQL)
        $sqlarray = $dict->RenameColumnSQL('`' . cms_db_prefix() . 'module_guestbook`', '`id`', '`entry_id`', 'I(INT)');
        $dict->ExecuteSQLArray($sqlarray);
	
        $sqlarray = $dict->AlterColumnSQL('`' . cms_db_prefix() . 'module_guestbook_post`', '`id` I');
        $dict->ExecuteSQLArray($sqlarray);

        $db->CreateSequence(cms_db_prefix() . "module_guestbook_post_seq");
        
        $this->UpdateStylesheet($db);

        $current_version = "1.0 RC2";
    }
    case '1.0 RC2':
    {
        $current_version = '1.0';
    }
    case '1.0':
    {
        $current_version = '1.0.1';
    }
    case '1.0.1':
    {
        $current_version = '1.0.2';
    }
    case '1.0.2':
    {
        $current_version = '1.0.3';
    }
    case '1.0.3':
    {
        $current_version = '1.0.4';
    }
    case '1.0.4':
    {
        $dict = NewDataDictionary($db);
        $flds = '
            location C(255) NOTNULL
        ';
        $taboptarray = array('mysql' => 'TYPE=MyISAM');
        $sqlarray = 
            $dict->AddColumnSQL(
                cms_db_prefix().'module_guestbook', 
                $flds, 
                $taboptarray
            );
        $dict->ExecuteSQLArray($sqlarray);

        $current_version = '1.1-beta1';
    }
    case '1.1-beta1':
    {
        $current_version = '1.1';
    }
    case '1.1':
    {
        $current_version = '1.1.1';
    }
    case '1.1.1':
    {
        $current_version = '1.1.2';
    }
	case '1.1.2':
		# set preferences
		$this->SetPreference('number', '10');
		$this->SetPreference('textleng', '1000');
		$this->SetPreference('timespan', '0');
		$this->SetPreference('sortasc', '0');
		$this->SetPreference('dateformat', 'd-m-Y');
		$this->SetPreference('shownow', '0');
		$this->SetPreference('smiley', '0');
		$this->SetPreference('searchsmileys', '0');
		$this->SetPreference('captcha', '0');
		$this->SetPreference('showaddform', '0');
		$this->SetPreference('badwords', '');
		$this->SetPreference('badwords_replacement', '####');
		
		# Setup the guestbook (frontend) templates
		foreach (array('guestbook', 'guestbook-entrylist', 'guestbook-form', 'guestbook-email', 'guestbook-showform-button') as $template)
		{
			$this->SetTemplate($template, $this->GetGuestbookHtmlTemplate($template));
		}
		$form_template_is_installed = true;
		
		// update the stylesheet iserted on install
		# get the stylesheet id
		$query = "
			SELECT value 
			FROM " . cms_db_prefix() . "module_guestbook_settings 
			WHERE setting = 'template_id'
		";
		$result =& $db->Execute($query);
		if ($result)
		{
			if ($result->RecordCount() == 0)
			{
				// value not set, stylesheet wasn't inserted
				$this->InsertStylesheet();
			}
			else
			{
				$css_id = $result->Fields('value');
				# update the stylesheet
				$css_text = 
					"/*\n" . 
					$this->Lang('module_example_stylesheet_intro') . 
					"\n*/\n\n" .
					file_get_contents(
						cms_join_path($this->GetModulePath(),'css','stylesheet.css'
						)
					);
				$query = "
					UPDATE " . cms_db_prefix() . "css 
					SET css_text = '$css_text' 
					WHERE css_id = '$css_id'
				";
				$result =& $db->Execute($query);
			}
		} else {
			// db error
		}
		
		# create events
		if (method_exists($this, 'CreateEvent'))
		{
			foreach (array('EntryPosted', 'EntryDeleted', 'EntryActivated', 'EntryDeactivated') as $event)
			{
				$this->CreateEvent('Guestbook' . $event);
			}
		}
		$current_version = '1.1.3';
	case '1.1.3':
		$dict = NewDataDictionary($db);
		$flds = '
			ip_address C(11) NOTNULL
		';
		$taboptarray = array('mysql' => 'TYPE=MyISAM');
		$sqlarray = 
			$dict->AddColumnSQL(
			cms_db_prefix().'module_guestbook', 
			$flds, 
			$taboptarray
		);
		$dict->ExecuteSQLArray($sqlarray);
		
		$this->CreatePermission('Modify Guestbook Settings' , 'Modify Guestbook Settings');
		$this->SetPreference('wysiwyg', '0');
		
		$current_version = '1.1.4';
	case '1.1.4':
		if (! $form_template_is_installed)
		{
			$this->SetTemplate('guestbook-form', $this->GetGuestbookHtmlTemplate('guestbook-form'));
			$form_template_is_installed = true;
		}
		$current_version = '1.1.5';
	case '1.1.5':
		if (! $form_template_is_installed)
		{
			$this->SetTemplate('guestbook-form', $this->GetGuestbookHtmlTemplate('guestbook-form'));
			$form_template_is_installed = true;
		}
		$current_version = '1.1.6';
	case '1.1.6':
		$current_version = '1.1.7';
	case '1.1.7':
		$dict = NewDataDictionary($db);
		$fields = 'ip_address C(15) NOTNULL';
		$sqlarray = $dict->AlterColumnSQL(cms_db_prefix() . 'module_guestbook', $fields);
		$dict->ExecuteSQLArray($sqlarray);
		
		$current_version = '1.1.8';
	case '1.1.8':
		$current_version = '1.1.9';
	case '1.1.9':
		$current_version = '1.1.10';
	case '1.1.10':
		$current_version = '1.1.11';
	case '1.1.11':
		$current_version = '1.1.12';
	case '1.1.12':
		// Create the guestbook table
		$dict = NewDataDictionary($db);
		$guestbook_table = cms_db_prefix() . 'module_guestbook_guestbook';
		$flds = '
			id I KEY NOTNULL,
			name C(255) NOTNULL,
			descr C(255) NOTNULL,
			active I1 DEFAULT 0 NOTNULL
		';
		$taboptarray = array('mysql' => 'TYPE=MyISAM');
		$sqlarray = $dict->CreateTableSQL($guestbook_table, $flds, $taboptarray);
		$dict->ExecuteSQLArray($sqlarray);
				
		// Insert the default Guestbook
		$guestbook_name = $this->Lang('default_guestbook_name');
		$guestbook_descr = $this->Lang('default_guestbook_descr');
		$default_guestbook_id = $db->GenID(cms_db_prefix() . 'module_guestbook_guestbook_seq');
		$sql = "
			INSERT INTO $guestbook_table 
			SET id = $default_guestbook_id, name = '$guestbook_name', descr = '$guestbook_descr'
		";
		$db->Execute($sql);
		
		// Insert the new column "guestbook" to the guestbook(entry) table
		$dict = NewDataDictionary($db);
		$sqlarray = $dict->AddColumnSQL(cms_db_prefix()."module_guestbook", "guestbook I(11)");
		$dict->ExecuteSQLArray($sqlarray);
		
		// Import older entries in default guestbook
		$entry_table = cms_db_prefix() . 'module_guestbook';
		$sql = 'UPDATE ' . $entry_table . ' SET `guestbook` = '.$default_guestbook_id.' WHERE ' . $entry_table . '.`guestbook` is NULL;';
		$db->Execute($sql);
		
		$this->SetPreference('guestbook', $default_guestbook_id);
		$this->SetPreference('internal_smileys', '0');
		$this->SetPreference('admin_entries_per_page', '20');
		
		$current_version = '1.2';
	case '1.2':
		$current_version = '1.3.0';
	case '1.3.0':
        $this->SetPreference('dateformat', '%d-%m-%Y %H:%M');
		$current_version = '1.3.1';
	case '1.3.1':
		$query = "
			SELECT value 
			FROM " . cms_db_prefix() . "module_guestbook_settings 
			WHERE setting = 'template_id'
		";
		$result =& $db->Execute($query);
		if ($result)
		{
			if ($result->RecordCount() == 0)
			{
				// value not set, stylesheet wasn't inserted
				$this->InsertStylesheet();
			}
			else
			{
				$css_id = $result->Fields('value');
				# update the stylesheet
				$query = "
					UPDATE " . cms_db_prefix() . "css 
					SET media_type = 'handheld, screen, tv' 
					WHERE css_id = '$css_id'
				";
				$result =& $db->Execute($query);
			}
		} else {
			// db error
		}
		$current_version = '1.3.2';
	default:
	{
	}
}

#vim:ts=4 sw=4 noet
?>
]]></data>
	</file>
	<file>
	  <filename>/plugins/</filename>
	  <isdir>1</isdir>
	</file>
	<file>
	  <filename>/plugins/function.paginate_first.php</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[PD9waHAKCi8qKgogKiBQcm9qZWN0OiAgICAgUGFnaW5hdGlvbidzIGNsYXNzOiBiYXNlZCBvbiBTbWFydHlQYWdpbmF0ZQogKiBGaWxlOiAgICAgICAgZnVuY3Rpb24ucGFnaW5hdGVfZmlyc3QucGhwCiAqIAogKiBAYXV0aG9yIEdhYnJpZWwgTUFUSUFTIDxnYWJyLm1hdGlhcyBbYXQgZ21haWxdIHNvbWV0aGluZ2FnYWluc3RzcGFtIFthbmQgdGxkOl0gY29tPiAKICogQGF1dGhvciBNb250ZSBPaHJ0IDxtb250ZSBhdCBuZXdkaWdpdGFsZ3JvdXAgZG90IGNvbT4KICogQHBhY2thZ2UgUGFnaW5hdGlvbidzIGNsYXNzCiAqLwoKZnVuY3Rpb24gc21hcnR5X2Z1bmN0aW9uX3BhZ2luYXRlX2ZpcnN0KCRwYXJhbXMsICYkc21hcnR5KSB7CgogICAgJF9pZCA9ICdkZWZhdWx0JzsKICAgICRfYXR0cnMgPSBhcnJheSgpOwogICAgCiAgICBmb3JlYWNoKCRwYXJhbXMgYXMgJF9rZXkgPT4gJF92YWwpIHsKICAgICAgICBzd2l0Y2goJF9rZXkpIHsKICAgICAgICAgICAgY2FzZSAnaW5zdGFuY2UnOgogICAgICAgICAgICAgICAgaWYgKCFQYWdpbmF0aW9uOjp2YWxpZEFycmF5KCRfdmFsKSkgewogICAgICAgICAgICAgICAgICAgICRzbWFydHktPnRyaWdnZXJfZXJyb3IoJ3BhZ2luYXRlX2ZpcnN0OiBiYWQgcGFnaW5hdGlvbiBpbnN0YW5jZScpOwogICAgICAgICAgICAgICAgICAgIHJldHVybjsKICAgICAgICAgICAgICAgIH0KICAgICAgICAgICAgICAgICRwYWdpbmF0ZSA9ICRfdmFsOwogICAgICAgICAgICAgICAgYnJlYWs7CiAgICAgICAgICAgIGNhc2UgJ3RleHQnOgogICAgICAgICAgICAgICAgYnJlYWs7CiAgICAgICAgICAgIGRlZmF1bHQ6CiAgICAgICAgICAgICAgICAkX2F0dHJzW10gPSAkX2tleSAuICc9IicgLiAkX3ZhbCAuICciJzsKICAgICAgICAgICAgICAgIGJyZWFrOyAgIAogICAgICAgIH0KICAgIH0KICAgIAogICAgCiAgICAkX3VybCA9ICRwYWdpbmF0ZVsndXJsJ107CiAgICAKICAgICRfYXR0cnMgPSAhZW1wdHkoJF9hdHRycykgPyAnICcgLiBpbXBsb2RlKCcgJywgJF9hdHRycykgOiAnJzsKICAgICAgICAKICAgICRwYWdlID0gKCgkcGFnaW5hdGVbJ3BhZ2VfY3VycmVudCddPjIpP3RydWU6ZmFsc2UpOwogICAgaWYoJHBhZ2UgIT09IGZhbHNlKXsKICAgICAgICAkX3RleHQgPSBpc3NldCgkcGFyYW1zWyd0ZXh0J10pID8gJHBhcmFtc1sndGV4dCddIDogJ2ZpcnN0JzsKICAgICAgICAkX3VybCAuPSAoc3RycG9zKCRfdXJsLCAnPycpID09PSBmYWxzZSkgPyAnPycgOiAnJic7CiAgICAgICAgJF91cmwgLj0gJHBhZ2luYXRlWyd1cmx2YXInXSAuICc9MSc7CiAgICB9CiAgICAKICAgIHJldHVybiAoJHBhZ2UpID8gJzxhIGhyZWY9IicgLiAkX3VybCAuICciJyAuICRfYXR0cnMgLiAnPicgLiAkX3RleHQgLiAnPC9hPicgOiAnJzsKfQoKPz4K]]></data>
	</file>
	<file>
	  <filename>/plugins/function.paginate_last.php</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[PD9waHAKCi8qKgogKiBQcm9qZWN0OiAgICAgUGFnaW5hdGlvbidzIGNsYXNzOiBiYXNlZCBvbiBTbWFydHlQYWdpbmF0ZQogKiBGaWxlOiAgICAgICAgZnVuY3Rpb24ucGFnaW5hdGVfbGFzdC5waHAKICogCiAqIEBhdXRob3IgR2FicmllbCBNQVRJQVMgPGdhYnIubWF0aWFzIFthdCBnbWFpbF0gc29tZXRoaW5nYWdhaW5zdHNwYW0gW2FuZCB0bGQ6XSBjb20+IAogKiBAYXV0aG9yIE1vbnRlIE9ocnQgPG1vbnRlIGF0IG5ld2RpZ2l0YWxncm91cCBkb3QgY29tPgogKiBAcGFja2FnZSBQYWdpbmF0aW9uJ3MgY2xhc3MKICovCgpmdW5jdGlvbiBzbWFydHlfZnVuY3Rpb25fcGFnaW5hdGVfbGFzdCgkcGFyYW1zLCAmJHNtYXJ0eSkgewoKICAgICRfaWQgPSAnZGVmYXVsdCc7CiAgICAkX2F0dHJzID0gYXJyYXkoKTsKICAgIAogICAgZm9yZWFjaCgkcGFyYW1zIGFzICRfa2V5ID0+ICRfdmFsKSB7CiAgICAgICAgc3dpdGNoKCRfa2V5KSB7CiAgICAgICAgICAgIGNhc2UgJ2luc3RhbmNlJzoKICAgICAgICAgICAgICAgIGlmICghUGFnaW5hdGlvbjo6dmFsaWRBcnJheSgkX3ZhbCkpIHsKICAgICAgICAgICAgICAgICAgICAkc21hcnR5LT50cmlnZ2VyX2Vycm9yKCdwYWdpbmF0ZV9sYXN0OiBiYWQgcGFnaW5hdGlvbiBpbnN0YW5jZScpOwogICAgICAgICAgICAgICAgICAgIHJldHVybjsKICAgICAgICAgICAgICAgIH0KICAgICAgICAgICAgICAgICRwYWdpbmF0ZSA9ICRfdmFsOwogICAgICAgICAgICAgICAgYnJlYWs7CiAgICAgICAgICAgIGNhc2UgJ3RleHQnOgogICAgICAgICAgICAgICAgYnJlYWs7CiAgICAgICAgICAgIGRlZmF1bHQ6CiAgICAgICAgICAgICAgICAkX2F0dHJzW10gPSAkX2tleSAuICc9IicgLiAkX3ZhbCAuICciJzsKICAgICAgICAgICAgICAgIGJyZWFrOyAgIAogICAgICAgIH0KICAgIH0KICAgIAogICAgaWYgKCRwYWdpbmF0ZVsndG90YWwnXSA9PT0gZmFsc2UpIHsKICAgICAgICAkc21hcnR5LT50cmlnZ2VyX2Vycm9yKCJwYWdpbmF0ZV9sYXN0OiB0b3RhbCB3YXMgbm90IHNldCIpOwogICAgICAgIHJldHVybjsgICAgICAgIAogICAgfQogICAgCiAgICAkX3VybCA9ICRwYWdpbmF0ZVsndXJsJ107CiAgICAKICAgICRfYXR0cnMgPSAhZW1wdHkoJF9hdHRycykgPyAnICcgLiBpbXBsb2RlKCcgJywgJF9hdHRycykgOiAnJzsKICAgIAogICAgJHBhZ2UgPSAoKCRwYWdpbmF0ZVsncGFnZV9jdXJyZW50J108KCRwYWdpbmF0ZVsncGFnZV90b3RhbCddLTEpKT8kcGFnaW5hdGVbJ3BhZ2VfdG90YWwnXTpmYWxzZSk7CiAgICAkX3RleHQgPSBpc3NldCgkcGFyYW1zWyd0ZXh0J10pID8gJHBhcmFtc1sndGV4dCddIDogJ2xhc3QnOwogICAgJF91cmwgLj0gKHN0cnBvcygkX3VybCwgJz8nKSA9PT0gZmFsc2UpID8gJz8nIDogJyYnOwogICAgJF91cmwgLj0gJHBhZ2luYXRlWyd1cmx2YXInXSAuICc9JyAuICRwYWdlOwogICAgCiAgICByZXR1cm4gKCRwYWdlKSA/ICc8YSBocmVmPSInIC4gJF91cmwgLiAnIicgLiAkX2F0dHJzIC4gJz4nIC4gJF90ZXh0IC4gJzwvYT4nIDogJyc7CiAgICAKfQoKPz4K]]></data>
	</file>
	<file>
	  <filename>/plugins/function.paginate_middle.php</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[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]]></data>
	</file>
	<file>
	  <filename>/plugins/function.paginate_next.php</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[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]]></data>
	</file>
	<file>
	  <filename>/plugins/function.paginate_prev.php</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[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]]></data>
	</file>
	<file>
	  <filename>/plugins/index.html</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[]]></data>
	</file>
	<file>
	  <filename>/templates/</filename>
	  <isdir>1</isdir>
	</file>
	<file>
	  <filename>/templates/admin.tpl</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[e2ZvcmVhY2ggZnJvbT0kbWVzc2FnZXMgaXRlbT1tZXNzYWdlfQp7JG1lc3NhZ2V9CnsvZm9yZWFjaH0Ke2ZvcmVhY2ggZnJvbT0kZXJyb3JzIGl0ZW09ZXJyb3J9CnskZXJyb3J9CnsvZm9yZWFjaH0KPGRpdiBjbGFzcz0iYWRtaW5mb3JtIj4KeyR0YWJoZWFkZXJzLT5zdGFydH0Ke2ZvcmVhY2ggZnJvbT0kdGFiaGVhZGVycy0+aGVhZGVycyBpdGVtPXRhYmhlYWRlcn0KeyR0YWJoZWFkZXJ9CnsvZm9yZWFjaH0KeyR0YWJoZWFkZXJzLT5lbmR9Cgp7JHN0YXJ0X3RhYl9jb250ZW50fQoKe2ZvcmVhY2ggZnJvbT0kdGFicyBpdGVtPXRhYn0KeyR0YWItPnN0YXJ0fQp7JHRhYi0+Y29udGVudH0KeyR0YWItPmVuZH0Key9mb3JlYWNofQoKeyRlbmRfdGFiX2NvbnRlbnR9CjwvZGl2Pgo=]]></data>
	</file>
	<file>
	  <filename>/templates/admin_entries_bottom.tpl</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[PCEtLSBUZW1wbGF0ZSBmb3IgdGhlIGJvdHRvbSAobmV3IGVudHJ5IGxpbmsgYW5kIG11bHRpLWVudHJ5IHNlbGVjdCBhbmQgc3VibWl0KSBvZiB0aGUgIk1hbmFnZSBHdWVzdGJvb2sgRW50cmllcyIgYXJlYSAvLy0tPgo8dHI+Cjx0ZCBjb2xzcGFuPSIxMiI+CjxkaXYgY2xhc3M9InBhZ2VvcHRpb25zIj4KICAgIDxwIGNsYXNzPSJwYWdlb3B0aW9ucyI+CiAgICAgICAgPHNwYW4gc3R5bGU9ImZsb2F0OiBsZWZ0OyI+CgkgICAgeyRhZGRfZW50cnlfbGlua30KCTwvc3Bhbj4KCntpZiAkZW50cmllc3xAY291bnQgPiAxfQoJPHNwYW4gc3R5bGU9Im1hcmdpbi1yaWdodDogMzBweDsgZmxvYXQ6IHJpZ2h0OyBhbGlnbjogcmlnaHQiPgoJICAgIHskc2VsZWN0ZWRfaXRlbXNfdGl0bGV9OiB7JGFjdGlvbl9kcm9wZG93bn0geyRtdWx0aV9zdWJtaXR9Cgk8L3NwYW4+CnsvaWZ9CiAgICA8L3A+CjwvZGl2Pgo8L3RkPgo8L3RyPgo8L3RhYmxlPgp7JGZvcm1lbmR9Cg==]]></data>
	</file>
	<file>
	  <filename>/templates/admin_entries_entry.tpl</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[PCEtLSBUZW1wbGF0ZSBmb3IgYW4gZW50cnkgcm93IGluIHRoZSAiTWFuYWdlIEd1ZXN0Ym9vayBFbnRyaWVzIiBhZG1pbiBhcmVhIC8vLS0+CntjeWNsZSB2YWx1ZXM9InJvdzEscm93MiIgYXNzaWduPSJyb3djbGFzcyJ9Cjx0ciBjbGFzcz0ieyRyb3djbGFzc30iPgogICAgPHRkPnskZW50cnktPmVudHJ5X2lkfTwvdGQ+Cgk8dGQ+eyokZW50cnktPmd1ZXN0Ym9va19pZC4nIC0gJyp9eyRlbnRyeS0+Z3Vlc3Rib29rX25hbWV9PC90ZD4KICAgIDx0ZD57JGVudHJ5LT5zZW5kZXItPkdldE5hbWUoKX08L3RkPgogICAgPHRkPnskZW50cnktPnNlbmRlci0+R2V0SXAoKX08L3RkPgogICAgPHRkPnskZW50cnktPnNlbmRlci0+R2V0RW1haWwoKX08L3RkPgogICAgPHRkPnskZW50cnktPnNlbmRlci0+R2V0Q291bnRyeSgpfTwvdGQ+CiAgICA8dGQ+eyRlbnRyeS0+c2VuZGVyLT5HZXRMb2NhdGlvbigpfTwvdGQ+CiAgICA8dGQ+eyRlbnRyeS0+c2VuZGVyLT5HZXRIb21lcGFnZSgpfTwvdGQ+CiAgICA8dGQ+eyRlbnRyeS0+R2V0TWVzc2FnZSg1MCl9PC90ZD4KICAgIDx0ZD57JGVudHJ5LT5HZXRUaW1lc3RhbXAoKX08L3RkPgogICAgPHRkPnskZW50cnktPnJvd2RhdGEuZGVfYWN0aXZhdGVfbGlua308L3RkPgogICAgPHRkPnskZW50cnktPnJvd2RhdGEuZWRpdF9saW5rfTwvdGQ+CiAgICA8dGQ+eyRlbnRyeS0+cm93ZGF0YS5kZWxldGVfbGlua308L3RkPgogICAgPHRkPntpZiAkZW50cmllc3xAY291bnQgPiAxfXskZW50cnktPnJvd2RhdGEuc2VsZWN0X2VudHJ5X2NoZWNrYm94fXtlbHNlfSZuYnNwO3svaWZ9PC90ZD4KPC90cj4K]]></data>
	</file>
	<file>
	  <filename>/templates/admin_entries_top.tpl</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[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]]></data>
	</file>
	<file>
	  <filename>/templates/admin_entry.tpl</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[PCEtLSBTdGFydCBUZW1wbGF0ZSBhZG1pbl9lbnRyeS50cGwgLy8tLT4Ke2lmICRlcnJvcm1zZ30KPHVsIGNsYXNzPSJlcnJvciI+CiAgICB7JGVycm9ybXNnfQo8L3VsPgp7L2lmfQo8ZGl2IGNsYXNzPSJhZG1pbmZvcm0iPgp7JGZvcm1zdGFydH0KeyRpbnB1dF9oaWRkZW5fZ3Vlc3Rib29rfQo8dGFibGUgY2xhc3M9ImFkbWludGFibGUiIHdpZHRoPSIxMDAlIj4KICAgIDx0cj4KICAgICAgICA8dGQ+eyRndWVzdGJvb2tfdGl0bGV9PC90ZD4KICAgICAgICA8dGQ+eyRndWVzdGJvb2t9PC90ZD4KICAgIDwvdHI+CiAgICA8dHI+CgkJPHRkPip7JHNlbmRlcl90aXRsZX06PC90ZD4KCQk8dGQ+eyRzZW5kZXJ9PC90ZD4KICAgIDwvdHI+CiAgICA8dHI+CiAgICAgICAgPHRkPnskZV9tYWlsX3RpdGxlfTo8L3RkPgogICAgICAgIDx0ZD57JGVfbWFpbH08L3RkPgogICAgPC90cj4KICAgIDx0cj4KICAgICAgICA8dGQ+eyRob21lcGFnZV90aXRsZX06PC90ZD4KICAgICAgICA8dGQ+aHR0cDovL3skaG9tZXBhZ2V9PC90ZD4KICAgIDwvdHI+CiAgICA8dHI+CiAgICAgICAgPHRkPnskbG9jYXRpb25fdGl0bGV9OjwvdGQ+CiAgICAgICAgPHRkPnskbG9jYXRpb259PC90ZD4KICAgIDwvdHI+CiAgICA8dHI+CiAgICAgICAgPHRkPnskY291bnRyeV90aXRsZX06PC90ZD4KICAgICAgICA8dGQ+eyRjb3VudHJ5fTwvdGQ+CiAgICA8L3RyPgoJPHRyPgogICAgICAgIDx0ZD57JGRhdGVfdGl0bGV9OjwvdGQ+CiAgICAgICAgPHRkPnskZGF0ZX08L3RkPgogICAgPC90cj4KICAgIDx0cj4KICAgICAgICA8dGQ+eyRtZXNzYWdlX3RpdGxlfTo8L3RkPgogICAgICAgIDx0ZD57JG1lc3NhZ2V9PC90ZD4KICAgIDwvdHI+CiAgICA8dHI+CiAgICAgICAgPHRkPnskZW50cnlfaWR9PC90ZD4KICAgIDwvdHI+CiAgICA8dHI+CiAgICAgICAgPHRkIGNvbHNwYW49IjIiPnskc3VibWl0fXskY2FuY2VsfTwvdGQ+CiAgICA8L3RyPgo8L3RhYmxlPgp7JGZvcm1lbmR9CjwvZGl2Pgo8IS0tIEVuZCBUZW1wbGF0ZSBhZG1pbl9lbnRyeS50cGwgLy8tLT4K]]></data>
	</file>
	<file>
	  <filename>/templates/admin_guestbooks_add_edit.tpl</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[PGRpdiBjbGFzcz0iYWRtaW5mb3JtIj4KeyRmb3Jtc3RhcnR9CjxoMz57JHRpdGxlfTwvaDM+CjxkaXYgY2xhc3M9InBhZ2VvdmVyZmxvdyI+PHAgY2xhc3M9InBhZ2V0ZXh0Ij48bGFiZWwgZm9yPSJ3eXNpd3lnIj57JG5hbWVfdGl0bGV9OjwvbGFiZWw+PC9wPjxwIGNsYXNzPSJwYWdlaW5wdXQiPnskbmFtZX08L3A+PC9kaXY+CjxkaXYgY2xhc3M9InBhZ2VvdmVyZmxvdyI+PHAgY2xhc3M9InBhZ2V0ZXh0Ij48bGFiZWwgZm9yPSJ3eXNpd3lnIj57JGRlc2NyaXB0aW9uX3RpdGxlfTo8L2xhYmVsPjwvcD48cCBjbGFzcz0icGFnZWlucHV0Ij57JGRlc2NyaXB0aW9ufTwvcD48L2Rpdj4KPGRpdiBjbGFzcz0icGFnZW92ZXJmbG93Ij48cCBjbGFzcz0icGFnZXRleHQiPjxsYWJlbCBmb3I9Ind5c2l3eWciPnskYWN0aXZlX3RpdGxlfTo8L2xhYmVsPjwvcD48cCBjbGFzcz0icGFnZWlucHV0Ij57JGFjdGl2ZX08L3A+PC9kaXY+CjxkaXYgY2xhc3M9InBhZ2VvdmVyZmxvdyI+PHAgY2xhc3M9InBhZ2V0ZXh0Ij57JHN1Ym1pdH0geyRjYW5jZWx9PC9wPjxwIGNsYXNzPSJwYWdlaW5wdXQiPiZuYnNwOzwvcD48L2Rpdj4KeyRmb3JtZW5kfQo8L2Rpdj4K]]></data>
	</file>
	<file>
	  <filename>/templates/admin_guestbook_selector.tpl</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[eyRmb3Jtc3RhcnR9Cgl7JHNlbGVjdF9ndWVzdGJvb2t9Cgl7JHN1Ym1pdF9ndWVzdGJvb2tfc2VsZWN0b3J9CnskZm9ybWVuZH0=]]></data>
	</file>
	<file>
	  <filename>/templates/admin_tab_entries.tpl</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[e2luY2x1ZGUgZmlsZT0kZ3Vlc3Rib29rX3NlbGVjdG9yX3RlbXBsYXRlfQp7aW5jbHVkZSBmaWxlPSRlbnRyaWVzX3RvcF90ZW1wbGF0ZX0Ke2ZvcmVhY2ggZnJvbT0kZW50cmllcyBpdGVtPWVudHJ5fQp7aW5jbHVkZSBmaWxlPSRlbnRyeV90ZW1wbGF0ZX0Key9mb3JlYWNofQp7aW5jbHVkZSBmaWxlPSRlbnRyaWVzX2JvdHRvbV90ZW1wbGF0ZX0K]]></data>
	</file>
	<file>
	  <filename>/templates/admin_tab_guestbooks.tpl</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[eyRtdWx0aV9mb3Jtc3RhcnR9Cjx0YWJsZSBjZWxsc3BhY2luZz0iMCIgY2xhc3M9InBhZ2V0YWJsZSIgd2lkdGg9IjEwMCUiPgogICAgPHRyPgoJICAgIDx0aCBjbGFzcz0icGFnZWljb24iPnskaGVhZGVycy5pZH08L3RoPgoJICAgIDx0aD57JGhlYWRlcnMubmFtZX08L3RoPgoJICAgIDx0aD57JGhlYWRlcnMuZGVzY3JpcHRpb259PC90aD4KCSAgICA8dGggY2xhc3M9InBhZ2VpY29uIj57JGhlYWRlcnMuZGVmYXVsdH08L3RoPgoJICAgIDx0aCBjbGFzcz0icGFnZWljb24iPnskaGVhZGVycy5hY3RpdmV9PC90aD4KCSAgICA8dGggY2xhc3M9InBhZ2VpY29uIj57JGhlYWRlcnMuZWRpdH08L3RoPgoJICAgIDx0aCBjbGFzcz0icGFnZWljb24iPnskaGVhZGVycy5kZWxldGV9PC90aD4KCSAgICA8dGggY2xhc3M9InBhZ2VpY29uIj4mbmJzcDs8L3RoPgoJPC90cj4Ke2ZvcmVhY2ggZnJvbT0kZ3Vlc3Rib29rcyBrZXk9aWQgaXRlbT1ndWVzdGJvb2t9Cgk8dHI+CgkJPHRkPgoJCQl7JGlkfQoJCTwvdGQ+CgkJPHRkPgoJCQl7JGd1ZXN0Ym9vay0+R2V0TmFtZSgpfQoJCTwvdGQ+CgkJPHRkPgoJCQl7JGd1ZXN0Ym9vay0+R2V0RGVzY3JpcHRpb24oKX0KCQk8L3RkPgoJCTx0ZD4KCQkJeyRndWVzdGJvb2stPnJvd2RhdGEuZGVmYXVsdF9saW5rfQoJCTwvdGQ+CgkJPHRkPgoJCQl7JGd1ZXN0Ym9vay0+cm93ZGF0YS5kZV9hY3RpdmF0ZV9saW5rfQoJCTwvdGQ+CgkJPHRkPgoJCQl7JGd1ZXN0Ym9vay0+cm93ZGF0YS5lZGl0X2xpbmt9CgkJPC90ZD4KCQk8dGQ+CgkJCXskZ3Vlc3Rib29rLT5yb3dkYXRhLmRlbGV0ZV9saW5rfQoJCTwvdGQ+CgkJPHRkPgoJCQl7aWYgJGd1ZXN0Ym9va3N8QGNvdW50ID4gMX17JGd1ZXN0Ym9vay0+cm93ZGF0YS5zZWxlY3RfY2hlY2tib3h9e2Vsc2V9Jm5ic3A7ey9pZn0KCQk8L3RkPgoJPC90cj4Key9mb3JlYWNofQo8L3RhYmxlPgo8cCBjbGFzcz0icGFnZW9wdGlvbnMiPgoJPHNwYW4gc3R5bGU9ImZsb2F0OiBsZWZ0OyI+CgkJeyRhZGRfZ3Vlc3Rib29rX2xpbmt9Cgk8L3NwYW4+CntpZiAkZ3Vlc3Rib29rc3xAY291bnQgPiAxfQoJPHNwYW4gc3R5bGU9Im1hcmdpbi1yaWdodDogMzBweDsgZmxvYXQ6IHJpZ2h0OyBhbGlnbjogcmlnaHQiPgoJICAgIHskc2VsZWN0ZWRfaXRlbXNfdGl0bGV9OiB7JGFjdGlvbl9kcm9wZG93bn0geyRtdWx0aV9zdWJtaXR9Cgk8L3NwYW4+CnsvaWZ9CjwvcD4KeyRmb3JtZW5kfQo=]]></data>
	</file>
	<file>
	  <filename>/templates/admin_tab_settings.tpl</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[PGRpdiBjbGFzcz0iYWRtaW5mb3JtIj4KCXskZm9ybXN0YXJ0fQoJCTxoMz57JHByZWZlcmVuY2VzX3RpdGxlfTwvaDM+CnsgaWYgaXNzZXQoJHd5c2l3eWdfY2hlY2tib3gpfQoJCTxkaXYgY2xhc3M9InBhZ2VvdmVyZmxvdyI+PHAgY2xhc3M9InBhZ2V0ZXh0Ij48bGFiZWwgZm9yPSJ7JGlkfXd5c2l3eWciPnskd3lzaXd5Z190aXRsZX06PC9sYWJlbD48L3A+PHAgY2xhc3M9InBhZ2VpbnB1dCI+eyR3eXNpd3lnX2NoZWNrYm94fTwvcD48L2Rpdj4Key9pZn0KCQk8ZGl2IGNsYXNzPSJwYWdlb3ZlcmZsb3ciPjxwIGNsYXNzPSJwYWdldGV4dCI+PGxhYmVsIGZvcj0ic2VhcmNoc21pbGV5cyI+eyRzZWFyY2hzbWlsZXlzX3RpdGxlfTo8L2xhYmVsPjwvcD48cCBjbGFzcz0icGFnZWlucHV0Ij57JHNlYXJjaHNtaWxleXNfY2hlY2tib3h9PC9wPjwvZGl2PgoJCTxkaXYgY2xhc3M9InBhZ2VvdmVyZmxvdyI+PHAgY2xhc3M9InBhZ2V0ZXh0Ij48bGFiZWwgZm9yPSJwYWdlc21hbGx0ZXh0YXJlYSI+eyRiYWR3b3Jkc190aXRsZX06PC9sYWJlbD48L3A+PHAgY2xhc3M9InBhZ2VpbnB1dCI+eyRiYWR3b3Jkc190ZXh0YXJlYX08L3A+PC9kaXY+CgkJPGRpdiBjbGFzcz0icGFnZW92ZXJmbG93Ij48cCBjbGFzcz0icGFnZXRleHQiPjxsYWJlbCBmb3I9InskaWR9YmFkd29yZHNfcmVwbGFjZW1lbnQiPnskYmFkd29yZHNfcmVwbGFjZW1lbnRfdGl0bGV9OjwvbGFiZWw+PC9wPjxwIGNsYXNzPSJwYWdlaW5wdXQiPnskYmFkd29yZHNfcmVwbGFjZW1lbnRfaW5wdXR9PC9wPjwvZGl2PgoJCTxkaXYgY2xhc3M9InBhZ2VvdmVyZmxvdyI+PHAgY2xhc3M9InBhZ2V0ZXh0Ij48bGFiZWwgZm9yPSJ7JGlkfWFkbWluX2VudHJpZXNfcGVyX3BhZ2UiPnskYWRtaW5fZW50cmllc19wZXJfcGFnZV90aXRsZX06PC9sYWJlbD48L3A+PHAgY2xhc3M9InBhZ2VpbnB1dCI+eyRhZG1pbl9lbnRyaWVzX3Blcl9wYWdlX2lucHV0fTwvcD48L2Rpdj4KCQk8YnIgLz4KCQl7JHN1Ym1pdH0KCXskZm9ybWVuZH0KCTxoMz5DYXB0Y2hhIE1vZHVsZTwvaDM+Cgl7JGNhcHRjaGF9CgkKCTxoMz5TbWlsZXlzIE1vZHVsZTwvaDM+Cgl7JHNtaWxleXN9CjwvZGl2Pg==]]></data>
	</file>
	<file>
	  <filename>/templates/admin_tab_templates.tpl</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[fCB7Zm9yZWFjaCBmcm9tPSRlZGl0X3RlbXBsYXRlX2xpbmtzIGl0ZW09ZWRpdF9saW5rfQoJeyRlZGl0X2xpbmt9IHwKey9mb3JlYWNofQo=]]></data>
	</file>
	<file>
	  <filename>/templates/admin_templates.tpl</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[fCB7Zm9yZWFjaCBmcm9tPSRlZGl0X3RlbXBsYXRlX2xpbmtzIGl0ZW09ZWRpdF9saW5rfQoJeyRlZGl0X2xpbmt9IHwKey9mb3JlYWNofQo=]]></data>
	</file>
	<file>
	  <filename>/templates/admin_template_edit.tpl</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[PCEtLSBGb3JtIGZvciBlZGl0aW5nIGEgZ3Vlc3Rib29rIGRhdGFiYXNlIHRlbXBsYXRlIC8vLS0+CntpZiAkZXJyb3Jtc2d9Cgk8ZGl2IGNsYXNzPSJwYWdlZXJyb3IiPnskZXJyb3Jtc2d9PC9kaXY+CnsvaWZ9Cnskc3RhcnRmb3JtfQoJPGRpdiBjbGFzcz0icGFnZW92ZXJmbG93Ij4KCQk8cCBjbGFzcz0icGFnZXRleHQiPip7JGNvbnRlbnR9OjwvcD4KCQk8cCBjbGFzcz0icGFnZWlucHV0Ij57JGlucHV0Y29udGVudH08L3A+Cgk8L2Rpdj4KCTxkaXYgY2xhc3M9InBhZ2VvdmVyZmxvdyI+CgkJPHAgY2xhc3M9InBhZ2V0ZXh0Ij4mbmJzcDs8L3A+CgkJPHAgY2xhc3M9InBhZ2VpbnB1dCI+eyRzdWJtaXR9eyRjYW5jZWx9eyRhcHBseX08L3A+Cgk8L2Rpdj4KCTxkaXYgY2xhc3M9InBhZ2VvdmVyZmxvdyI+CgkJPHAgY2xhc3M9InBhZ2VpbnB1dCI+eyRyZXN0b3JlfTwvcD4KCTwvZGl2Pgp7JGVuZGZvcm19Cg==]]></data>
	</file>
	<file>
	  <filename>/templates/db/</filename>
	  <isdir>1</isdir>
	</file>
	<file>
	  <filename>/templates/db/guestbook-default.tpl</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[eyogR3Vlc3Rib29rIEZyb250ZW5kIFRlbXBsYXRlICp9CjxkaXYgY2xhc3M9ImNtcy1ndWVzdGJvb2siPgp7JGZvcm19CnskZW50cnlsaXN0fQp7aWYgKCRndWVzdGJvb2stPkdldFNob3dJbnNlcnRidXR0b24oKSBhbmQgKCRwYWdpbmF0ZS5sYXN0IC0gJHBhZ2luYXRlLmZpcnN0ID4gNCkpfQp7JGZvcm19CnsvaWZ9CjwvZGl2Pgo=]]></data>
	</file>
	<file>
	  <filename>/templates/db/guestbook-email-default.tpl</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[eyRub3RpZmljYXRpb25fbWVzc2FnZX0KCnskdGl0bGVzLnNlbmRlcn0gOiB7JHZhbHVlcy5zZW5kZXJ9CntpZiAkdmFsdWVzLmNvdW50cnl9CnskdGl0bGVzLmNvdW50cnl9OiB7JHZhbHVlcy5jb3VudHJ5fQp7L2lmfQp7aWYgJHZhbHVlcy5sb2NhdGlvbn0KeyR0aXRsZXMubG9jYXRpb259OiB7JHZhbHVlcy5sb2NhdGlvbn0Key9pZn0Ke2lmICR2YWx1ZXMuZW1haWx9CnskdGl0bGVzLmVtYWlsfTogeyR2YWx1ZXMuZW1haWx9CnsvaWZ9CntpZiAkdmFsdWVzLmhvbWVwYWdlfQp7JHRpdGxlcy5ob21lcGFnZX06IHskdmFsdWVzLmhvbWVwYWdlfQp7L2lmfQoKeyR0aXRsZXMubWVzc2FnZX06CnskdmFsdWVzLm1lc3NhZ2V9Cgp7JHRpdGxlcy5tb2R1bGVfbGlua306CnskdmFsdWVzLm1vZHVsZV9saW5rfQp7JHRpdGxlcy5hZG1pbl9saW5rfToKeyR2YWx1ZXMuYWRtaW5fbGlua30K]]></data>
	</file>
	<file>
	  <filename>/templates/db/guestbook-entry-default.tpl</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[eyogVGhpcyB0ZW1wbGF0ZSBpcyB1c2VkIHRvIHNob3cgYSBzaW5nbGUgZ3Vlc3Rib29rIGVudHJ5LCBmcm9tIHNlYXJjaCByZXN1bHRzIGZvciBleGFtcGxlICp9CjxkaXYgY2xhc3M9ImNtcy1ndWVzdGJvb2stZW50cnkiPgoJPGRpdiBjbGFzcz0iY21zLWd1ZXN0Ym9vay1lbnRyeS1oZWFkZXIiPgoJCTxkaXYgY2xhc3M9ImNtcy1ndWVzdGJvb2stZW50cnktcG9zdGVkIj4KCQkJeyRlbnRyeS0+R2V0RGF0ZSgpfGRhdGVfZm9ybWF0OiRkYXRlZm9ybWF0fQoJCTwvZGl2PgoJCTxkaXYgY2xhc3M9ImNtcy1ndWVzdGJvb2stZW50cnktc2VuZGVyIj4KCQkJPHNwYW4gY2xhc3M9ImNtcy1ndWVzdGJvb2stZW50cnktc2VuZGVybmFtZSI+eyRlbnRyeS0+c2VuZGVyLT5HZXROYW1lKCl9PC9zcGFuPgp7aWYgJGVudHJ5LT5zZW5kZXItPmxvY2F0aW9uIG9yICRlbnRyeS0+c2VuZGVyLT5jb3VudHJ5fSh7L2lmfQp7aWYgJGVudHJ5LT5zZW5kZXItPmxvY2F0aW9ufQoJCQk8c3BhbiBjbGFzcz0iY21zLWd1ZXN0Ym9vay1lbnRyeS1sb2NhdGlvbiI+eyRlbnRyeS0+c2VuZGVyLT5sb2NhdGlvbn08L3NwYW4+CnsvaWZ9CntpZiAkZW50cnktPnNlbmRlci0+bG9jYXRpb24gYW5kICRlbnRyeS0+c2VuZGVyLT5jb3VudHJ5fSwgey9pZn0Ke2lmICRlbnRyeS0+c2VuZGVyLT5jb3VudHJ5fQoJCQk8c3BhbiBjbGFzcz0iY21zLWd1ZXN0Ym9vay1lbnRyeS1jb3VudHJ5Ij57JGVudHJ5LT5zZW5kZXItPmNvdW50cnl9PC9zcGFuPgp7L2lmfQp7aWYgJGVudHJ5LT5zZW5kZXItPmxvY2F0aW9uIG9yICRlbnRyeS0+c2VuZGVyLT5jb3VudHJ5fSl7L2lmfQp7aWYgJGVudHJ5LT5zZW5kZXItPmVtYWlsfQoJCQk8c3BhbiBjbGFzcz0iY21zLWd1ZXN0Ym9vay1lbnRyeS1lbWFpbCI+CnttYWlsdG8gYWRkcmVzcz0kZW50cnktPnNlbmRlci0+ZW1haWwgZW5jb2RlPSJoZXgiIHRleHQ9JGVudHJ5LT5zZW5kZXItPkdldEVtYWlsQ2xvYWtlZCgpIGV4dHJhPSJ0aXRsZT1cImAkdGl0bGVzLmVfbWFpbGAgYCRlbnRyeS0+c2VuZGVyLT5uYW1lYFwiIn0KCQkJPC9zcGFuPgp7L2lmfQoJCTwvZGl2Pgp7aWYgJGVudHJ5LT5zZW5kZXItPmhvbWVwYWdlfQoJCTxkaXYgY2xhc3M9ImNtcy1ndWVzdGJvb2stZW50cnktaG9tZXBhZ2UiPgoJCQl7JHRpdGxlcy5ob21lcGFnZX06IDxhIGhyZWY9Imh0dHA6Ly97JGVudHJ5LT5zZW5kZXItPmhvbWVwYWdlfSI+eyRlbnRyeS0+c2VuZGVyLT5ob21lcGFnZX08L2E+CgkJPC9kaXY+CnsvaWZ9Cgk8L2Rpdj4KCTxkaXYgY2xhc3M9ImNtcy1ndWVzdGJvb2stZW50cnktdGV4dCI+CgkJeyRlbnRyeS0+R2V0TWVzc2FnZSgpfQoJPC9kaXY+CjwvZGl2PgoK]]></data>
	</file>
	<file>
	  <filename>/templates/db/guestbook-entrylist-default.tpl</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[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]]></data>
	</file>
	<file>
	  <filename>/templates/db/guestbook-form-default.tpl</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[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]]></data>
	</file>
	<file>
	  <filename>/templates/db/guestbook-showform-button-default.tpl</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[PCEtLSBTaG93cyB0aGUgYnV0dG9uIHRvIGdvIHRvIHRoZSBlbnRyeSBmb3JtIC8vLS0+CntpZiAhZW1wdHkoJGd1ZXN0Ym9vay0+TWVzc2FnZXMpfQp7Zm9yZWFjaCBmcm9tPSRndWVzdGJvb2stPk1lc3NhZ2VzIGl0ZW09bXNnfQoJeyRtc2d9PGJyIC8+CnsvZm9yZWFjaH0Key9pZn0Ke2lmICFlbXB0eSgkZ3Vlc3Rib29rLT5FcnJvcnMpfQp7Zm9yZWFjaCBmcm9tPSRndWVzdGJvb2stPkVycm9ycyBpdGVtPWVycm9yfQoJPHN0cm9uZz57JGVycm9yfTwvc3Ryb25nPjxiciAvPgp7L2ZvcmVhY2h9CnsvaWZ9CjxkaXYgY2xhc3M9ImNtcy1ndWVzdGJvb2stc2hvd2Zvcm0tYnV0dG9uIj4KCXskZm9ybXN0YXJ0fQoJCXskaGlkZGVufQoJCXskc3VibWl0fQoJeyRmb3JtZW5kfQo8L2Rpdj4K]]></data>
	</file>
	<file>
	  <filename>/templates/db/index.html</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[]]></data>
	</file>
	<file>
	  <filename>/templates/index.html</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[]]></data>
	</file>
	<file>
	  <filename>/templates/smiley.tpl</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[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]]></data>
	</file>
</module>
