<?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>CustomContent</name>
	<version>1.4.10</version>
  <mincmsversion>1.2</mincmsversion>
	<help><h3>What Does This Do?</h3>
<p>This module, in conjunction with the UserID module allows you to create a page that will look different depending upon the person that looks at it.  You can specify different content for certain users, or members of a certain group.</p>
<p><b>Note 1:</b> When putting custom smarty logic into any page, you should ensure that that page will not be cached.  This is accomplished by ensuring that the &quote;cachable&quote; tag is cleared on the page before submitting or applying</p>
<p><b>Note 2:</b> If the smarty logic is in your template, you need to ensure that each page that uses that template is not cachable</p>
<h3>How Do I Use It</h3>
<h4>Method 1 : smarty</h4>
<pre>
{if $customcontent_loggedin}
  Welcome &lt;b&gt;{$customcontent_loginname}&lt;/b&gt;&lt;br/&gt;
{else}
  &lt;h1&gt;You are not authorized to view this data&lt;/h1&gt;
{/if}
</pre>
<p>Or you can use the $ccuser variable for more advanced, and easier to read testing</p>
<pre>
{if $ccuser->loggedin() && $ccuser->memberof('members') && $ccuser->ipmatches('192.168.0.0/24')}
Welcome logged in local member
{elseif $ccuser->loggedin() && $ccuser->memberof('members')}
Welcome logged in member
{elseif $ccuser->loggedin()}
Welcome user from some other group
{else}
Anonymous user
{/if}
</pre>
<p>Any smarty compatible expressions or logic can be used with the available variables.  Using this syntax, expressions may be nested, or complex logic used.</p>
<h4>Available variables:</h4>
<ul>
<li><p><em>ccuser</em> - An object with convenience functions for testing.</p>
<p>This object contains some convenience methods for performing more advanced customcontent logic, or for making your template look a little bit better. The available methods are:</p>
  <ul>
<li><em>$ccuser->get_parent_alias($alias = '')</em> - outputs the page alias of the parent page, or empty if the specified page does not have a parent (is at the top).  This function will accept a page alias as an argument, if no page alias is specified, the current page is assumed.</li>
<li><em>$ccuser->get_root_alias($alias = '')</em> - outputs the page alias of the topmost parent page, or empty if the specified page does not have a parent (is at the top).  This function will accept a page alias as an argument, if no page alias is specified, the current page is assumed.</li>
<li><em>$ccuser->get_page_title($alias = '')</em> - outputs the title of the page matching the supplied alias.  This function will accept a page alias as an argument, if no page alias is specified, the current page is assumed.</li>
<li><em>$ccuser->has_children($alias = '')</em> - outputs a boolean indicating if the specified page has child pages or not.  This function will accept a page alias as an argument, if no page alias is specified, the current page is assumed.</li>
<li><em>$ccuser->groups()</em> - outputs a list of the users member groups</li>
<li><em>$ccuser->memberof('group')</em> - outputs a boolean if the user is indeed a member of this group.  This function will also accept a comma separated list of group names.</li>
<li><em>$ccuser->loggedin()</em> - outputs a boolean if the user is loggedin</li>
<li><em>$ccuser->property('propertyname')</em> - outputs the value of the property for the currently logged in user.</li>
<li><em>$ccuser->module_installed('modulename')</em> - outputs a boolean if the specified module is installed and available.</li>
<li><em>$ccuser->ipmatches($ranges)</em> - outputs a boolean if the users ip address matches one of the comma separated ip ranges.  Accepts ranges like ###.###.###.###/## i.e: 192.168.0.0/24</li>
  </ul>
<br/>
</li>
<li><p><em>customcontent_ip</em> - The remote IP address</p></li>
<li><p><em>customcontent_loggedin</em> - A boolean indicating wether the user is logged in or not</p></li>
<li><p><em>customcontent_loginname</em> - The name of the currently logged in user</p></li>
<li><p><em>customcontent_groupcount</em> - A count of the number of groups this user is a member of</p></li>
<li><p><em>customcontent_groups</em> - A string containing the group names of all member groups</p></li>
<li><p><em>customcontent_memberof_*</em> - A series of boolean variables indicating group membership.  i.e.: customcontent_memberof_staff, customcontent_memberof_users, etc.  No variables are defined for groups that this user is not a member of.</p></li>
<li><p><em>customcontent_dayzeros</em> - Day of the month, 2 digits with leading zeros</p></li> 
<li><p><em>customcontent_day3text</em> - A textual representation of a day, three letters</p></li>
<li><p><em>customcontent_day</em> - Day of the month without leading zeros</p></li> 
<li><p><em>customcontent_weekday</em> - A full textual representation of the day of the week</p></li> 
<li><p><em>customcontent_dayordsuffix</em> - English ordinal suffix for the day of the month, 2 characters</p></li> 
<li><p><em>customcontent_dayofweek</em> - Numeric representation of the week</p></li> 
<li><p><em>customcontent_dayofyear</em> - The day of the year (starting from 0)</p></li> 
<li><p><em>customcontent_weeknum</em> - ISO-8601 week number of year, weeks starting on Monday</p></li> 
<li><p><em>customcontent_monthfulltext</em> - A full textual representation of a month, such as January or March</p></li> 
<li><p><em>customcontent_monthnumzeros</em> - Numeric representation of a month, with leading zeros</p></li> 
<li><p><em>customcontent_monthshorttext</em> - A short textual representation of a month, three letters</p></li> 
<li><p><em>customcontent_monthnum</em> - Numeric representation of a month, without leading zeros</p></li> 
<li><p><em>customcontent_monthnumdays</em> - Number of days in the current month</p></li> 
<li><p><em>customcontent_leapyear</em> - Wether it's a leap year</p></li> 
<li><p><em>customcontent_4digityear</em> - A full numeric representation of a year, 4 digits</p></li> 
<li><p><em>customcontent_2digityear</em> - A two digit representation of a year</p></li> 
<li><p><em>customcontent_lowerampm</em> - Lowercase Ante meridiem and Post meridiem</p></li> 
<li><p><em>customcontent_upperampm</em> - Uppercase Ante meridiem and Post meridiem</p></li>
<li><p><em>customcontent_inettime</em> - Swatch Internet time</p></li>
<li><p><em>customcontent_12hour</em> - 12-hour format of an hour without leading zeros</p></li>
<li><p><em>customcontent_24hour</em> - 24-hour format of an hour without leading zeros</p></li>
<li><p><em>customcontent_12hourzeros</em> - 12-hour format of an hour with leading zeros</p></li>
<li><p><em>customcontent_24hourzeros</em> - 24-hour format of an hour with leading zeros</p></li>
<li><p><em>customcontent_minutes</em> - Minutes with leading zeros</p></li>
<li><p><em>customcontent_seconds</em> - Seconds, with leading zeros</p></li>
<li><p><em>customcontent_timezone</em> - Timezone setting of this machine</p></li>
<li><p><em>customcontent_date</em> - RFC 2822 formatted date</p></li>
<li><p><em>customcontent_epochseconds</em> - Seconds since the Unix Epoch (January 1 1970 00:00:00 GMT)</p></li>
</ul>
<h4>Method 2: comment tags <em>(deprecated)</em></h3>
<p>To use it you place the tag {cms_module module=CustomContent} into your page or template, and then below that you place the content you want isolated to specific users in groups in one of two ways, either using specially formatted comment tags, or using smarty syntax.</p>
<pre>
{cms_module module=CustomContent}
&lt;!--customContent: startif group=testers,admins --&gt;
&lt;H1&gt;This content is only available to logged in testers and and admins&lt;/H1&gt;
&lt;!--customContent: else --&gt;
&lt;H1&gt;This content is available to everybody else&lt;/H1&gt;
&lt;!--customContent: endif --&gt;
&lt;!--customContent: startif group=users --&gt;
&lt;H1&gt;This content is only available to logged in users &lt;/H1&gt;
&lt;!--customContent: endif --&gt;
</pre>
<p><b>Available parameters</b></p> 
<ul>
<li><p><em>ip</em> - test if remote ip matches a network or supplied ip address.  Valid formats are xxx.xxx.xxx.xxx (exact), xxx.xxx.xxx.[yyy-zzz] (range) and xxx.xxx.xxx/nn (nn = # bits, i.e.  192.168.1.0/24)</p></li>
<li><p><em>group</em> - test if the currently logged in user is a member of any of the supplied groups</p></li>
<li><p><em>user<em> - test if the currently logged in username matches any of the supplied ones</p></li>
<li><p><em>loggedin<em> - test if the current user is logged in or not./p></li>
</ul>
<p>Tests are evaluated in a logical OR fashion in order as follows ip address, group, and user.  The first successfull test will result in the expression evaluationg to true</p>
<h3>Copyright and License</h3>
<p>Copyright &copy; 2005, Robert Campbell <a href="mailto:rob@techcom.dyndns.org">&lt;rob@techcom.dyndns.org&gt;</a>. All Rights Are Reserved.</p>
<p>This module has been released under the <a href="http://www.gnu.org/licenses/licenses.html#GPL">GNU Public License</a>. You must agree to this license before using the module.</p>
<h3>Dependencies</h3><ul><li>FrontEndUsers =&gt; 1.3</li></ul></help>
	<about>PGJyIC8+QXV0aG9yOiBjYWxndXkxMDAwICZsdDtyb2JAdGVjaGNvbS5keW5kbnMub3JnJmd0OzxiciAvPjxiciAvPlZlcnNpb246IDEuNC4xMDxiciAvPjxiciAvPkNoYW5nZSBIaXN0b3J5OjxiciAvPjx1bD48bGk+VmVyc2lvbiAxLjAuIDE0IFNlcHRlbWJlciAyMDA1LiBJbml0aWFsIFJlbGVhc2UuPC9saT48L3VsPgo8dWw+CjxsaT5WZXJzaW9uIDEuMS4gIC0gU2VwdGVtYmVyIDIwMDUuIEFkZGVkIHN0YXJ0aWYvZWxzZS9lbmRpZiwgYW5kIHNlYXJjaCB0aHJvdWdoIG11bHRpcGxlIGdyb3VwcyBhbmQgdXNlcnMuPC9saT4KPGxpPlZlcnNpb24gMS4yLiAgLSBTZXB0ZW1iZXIgMjAwNS4gQWRkZWQgbG9nZ2VkaW4gb3B0aW9uYWwgcGFyYW1ldGVyPC9saT4KPGxpPlZlcnNpb24gMS4zICAgLSBPY3RvYmVyICAgMjAwNS4gQ2hhbmdlZCB0byB1c2UgRnJvbnRFbmRVc2VycyBpbnN0ZWFkIG9mIFVzZXJJRDwvbGk+CjxsaT5WZXJzaW9uIDEuMy4xIC0gTm92ZW1iZXIgMjAwNS4gVmVyeSBtaW5vciBidWdmaXggdG8gdGhlIHBhcmFtZXRlciBwYXJzaW5nPC9saT4KPGxpPlZlcnNpb24gMS40LjAgLSBKYW51YXJ5LCAyMDA2Lgo8cD5BZGRlZCBzbWFydHkgY29tcGF0aWJsZSB2YXJpYWJsZXM8L3A+PC9saT4KPGxpPlZlcnNpb24gMS40LjEgLSBNYXksIDIwMDYuCjxwPlNtYXJ0eSB2YXJpYWJsZXMgbm93IHdvcmsgaW4gMC4xM2IyPC9wPgo8cD5Ob3cgcmVxdWlyZSBDTVMgMC4xM2IyIGFzIGEgbWluaW11bTwvcD4KPHA+VXBkYXRlZCB0aGUgaGVscDwvcD4KPC9saT4KPGxpPlZlcnNpb24gMS40LjMgLSBKdW5lLCAyMDA2Lgo8cD5BZGRlZCBzZWFyY2ggbW9kdWxlIGNvbXBhdGliaWxpdHk8L3A+CjxwPkFkZGVkIGRhdGUgYW5kIHRpbWUgc21hcnR5IHZhcmlhYmxlczwvcD4KPC9saT4KPGxpPlZlcnNpb24gMS40LjQgLSBEZWMsIDIwMDYuCjxwPkFkZGVkIFRlbXBsYXRlUHJlY29tcGlsZSBjYWxsYmFjazwvcD4KPGxpPlZlcnNpb24gMS40LjUgLSBNYXIsIDIwMDcuCjxwPlJlbW92ZWQgdGhlIFNlYXJjaEl0ZW1BZGRlZCBjYWxsYmFjay4uLjwvcD4KPGxpPlZlcnNpb24gMS40LjYgLSBBcHIsIDIwMDcuCjxwPkFkZGVkIHRoZSBjY3VzZXIgb2JqZWN0IGZvciBlYXNpZXIgZXhwcmVzc2lvbnMuPC9wPgo8bGk+VmVyc2lvbiAxLjQuNyAtIFNlcCwgMjAwNy4KPHA+QWRqdXN0ZWQgdGhlIGhlbHAsIHRoZSBjb21tZW50IHN5bnRheCBpcyBub3cgZGVwcmVjYXRlZDwvcD4KPHA+QWRkZWQgYSBwcm9wZXJ0eSBtZXRob2QgdG8gdGhlIGNjdXNlciBvYmplY3Q8L3A+CjwvbGk+CjxsaT5WZXJzaW9uIDEuNC44IC0gU2VwLCAyMDA3Lgo8cD5BZGRlZCB0aGUgbW9kdWxlX2V4aXN0cyBtZXRob2QgdG8gdGhlIGNjdXNlciBvYmplY3Q8L3A+CjwvbGk+CjxsaT5WZXJzaW9uIDEuNC45IC0gT2N0LiAyMDA3Lgo8cD5Tb21lIG1pbm9yIGZpeGVzIHRoYXQgc2VlbSB0byBmaXggcHJvYmxlbXMgd2hlcmUgRkVVIHdvdWxkIGdldCBpbnN0YW50aWF0ZWQgdHdpY2U8L3A+CjxwPkZpeGVzIGFuIGlzc3VlIGluIHRoZSBtZW1iZXJvZigpIG1ldGhvZCBvZiBjY3VzZXIgd2hlbiBub3QgbG9nZ2VkIGluPC9wPgo8L2xpPgo8bGk+VmVyc2lvbiAxLjQuMTAgLSBOb3YuIDIwMDcuCjxwPk1pbmltdW0gQ01TIFZlcnNpb24gaXMgbm93IDEuMjwvcD4KPHA+QWRkcyBuZXcgZnVuY3Rpb25zIHRvIHRoZSBjY3VzZXIgb2JqZWN0OiBnZXRfcGFyZW50X2FsaWFzKCksIGdldF9yb290X2FsaWFzKCksIGdldF9wYWdlX3RpdGxlKCksIGhhc19jaGlsZHJlbigpPC9wPgo8L2xpPgo8L3VsPjxiciAvPg==</about>
	<description>This module provides the ability to specify different content by group or user name</description>
	<requires>
	  <requiredname>FrontEndUsers</requiredname>
	  <requiredversion>1.3</requiredversion>
	</requires>
	<file>
	  <filename>/</filename>
	  <isdir>1</isdir>
	</file>
	<file>
	  <filename>/CustomContent.module.php</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[<?php
/*
#-------------------------------------------------------------------------
# Module: CustomContent
# Version: 1.4.10, Robert Campbell <rob@techcom.dyndns.org>
#
#-------------------------------------------------------------------------
# CMS - CMS Made Simple is (c) 2005 by Ted Kulp (wishy@cmsmadesimple.org)
# 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
# Or read it online: http://www.gnu.org/licenses/licenses.html#GPL
#
#-------------------------------------------------------------------------
*/

class ccUser
{
  var $_groups;
  var $_uid;
  var $_module;

  function ccUser(&$module)
  {
    $this->_groups = array();
    $this->_uid = -1;
    $this->_module =& $module;
  }


  function ipmatches($ranges)
  {
    function _testip($range,$ip) 
    {
      $result = 1;

# IP Pattern Matcher
# J.Adams <jna@retina.net>
      #
# Matches:
      #
# xxx.xxx.xxx.xxx        (exact)
# xxx.xxx.xxx.[yyy-zzz]  (range)
# xxx.xxx.xxx.xxx/nn    (nn = # bits, cisco style -- i.e. /24 = class C)
      #
# Does not match:
# xxx.xxx.xxx.xx[yyy-zzz]  (range, partial octets not supported)

      if (ereg("([0-9]+)\.([0-9]+)\.([0-9]+)\.([0-9]+)/([0-9]+)",$range,$regs)) {

# perform a mask match
	$ipl = ip2long($ip);
	$rangel = ip2long($regs[1] . "." . $regs[2] . "." . $regs[3] . "." . $regs[4]);
      
	$maskl = 0;
      
	for ($i = 0; $i< 31; $i++) {
	  if ($i < $regs[5]-1) {
	    $maskl = $maskl + pow(2,(30-$i));
	  }
	}
      
	if (($maskl & $rangel) == ($maskl & $ipl)) {
	  return 1;
	} else {
	  return 0;
	}
      } else {
      
# range based
	$maskocts = split("\.",$range);
	$ipocts = split("\.",$ip);
      
# perform a range match
	for ($i=0; $i<4; $i++) {
	  if (ereg("\[([0-9]+)\-([0-9]+)\]",$maskocts[$i],$regs)) {
	    if ( ($ipocts[$i] > $regs[2]) || ($ipocts[$i] < $regs[1])) {
	      $result = 0;
	    }
	  }
	  else
	    {
	      if ($maskocts[$i] <> $ipocts[$i]) {
		$result = 0;
	      }
	    }
	}
      }
      return $result;
    }

    $ip = getenv('REMOTE_ADDR');
    $arr_ranges = explode(',',$ranges);
    $myresult = 0;
    foreach( $arr_ranges as $onerange )
      {
	$myresult = _testip($onerange,$ip);
	if( $myresult == 1 ) return $myresult;
      }
    return $myresult;
  }


  function loggedin()
  {
    if( $this->_uid == -1 )
      {
	$module =& $this->_module->GetModuleInstance('FrontEndUsers');
	if( !$module ) return 0;
	$this->_uid = $module->LoggedInId();
      }
    return $this->_uid;
  }


  function property($propname)
  {
    $txt = false;
    if( $this->_uid != -1 )
      {
	$module =& $this->_module->GetModuleInstance('FrontEndUsers');
	if( !$module ) return false;
	$txt = $module->GetUserPropertyFull($propname,$this->_uid);
      }
    return $txt;
  }

  function groups()
  {
    if( count($this->_groups) == 0 )
      {
	$module =& $this->_module->GetModuleInstance('FrontEndUsers');
	if( !$module ) return '';
	$uid = $module->LoggedInId();
	$groups = $module->GetMemberGroupsArray( $module->LoggedInId() );
	$gns = array();
	if( $groups !== false )
	  {
	    foreach( $groups as $gid )
	      {
		$gns[] = $module->GetGroupName($gid['groupid']);
	      }
	  }
	$this->_groups = $gns;
      }
    return $this->_groups;
  }


  function memberof($groups)
  {
    if( count($this->_groups) == 0 )
      {
	$this->groups();
      }
    $arr = explode(',',$groups);
    foreach( $arr as $one )
      {
	if( array_search($one,$this->_groups) !== FALSE )
	  return 1;
      }
    return 0;
  }


  function module_installed($module)
  {
    if( $module == '' ) return 0;
    $module =& $this->_module->GetModuleInstance($module);
    if( is_object( $module ) ) return 1;
    return 0;
  }

  
  function get_parent_alias($alias = '')
  {
    global $gCms;
    $contentops =& $gCms->GetContentOperations();

    if( $alias == '' )
      {
	$smarty =& $gCms->GetSmarty();
	$alias = $smarty->get_template_vars('page_alias');
      }
    $content =& $contentops->LoadContentFromAlias($alias);
    if( !is_object($content) ) return '';

    $parentid = $content->ParentId();
    if( $parentid <= 0 ) return '';
    $alias = $contentops->GetPageAliasFromId($parentid);
    return $alias;
  }

  
  function get_root_alias($alias = '')
  {
    global $gCms;
    $contentops =& $gCms->GetContentOperations();

    if( $alias == '' )
      {
	$smarty =& $gCms->GetSmarty();
	$alias = $smarty->get_template_vars('page_alias');
      }
    $id = $contentops->GetPageIDFromAlias($alias);
    
    while( $id > 0 )
      {
	$content =& $contentops->LoadContentFromId($id);
	if( !is_object( $content ) ) return '';
	$alias = $content->Alias();
	$id = $content->ParentId();
      }
    
    return $alias;
  }


  function get_page_title($alias = '')
  {
    global $gCms;
    $contentops =& $gCms->GetContentOperations();

    if( $alias == '' )
      {
	$smarty =& $gCms->GetSmarty();
	$alias = $smarty->get_template_vars('page_alias');
      }
    $content =& $contentops->LoadContentFromAlias($alias);
    if( !is_object($content) ) return '';

    return $content->Name();
  }

  
  function has_children($alias = '')
  {
    global $gCms;
    $contentops =& $gCms->GetContentOperations();

    if( $alias == '' )
      {
	$smarty =& $gCms->GetSmarty();
	$alias = $smarty->get_template_vars('page_alias');
      }

    $content =& $contentops->LoadContentFromAlias($alias);
    if( !is_object($content) ) return false;
    
    return $content->HasChildren();
  }

};

#-------------------------------------------------------------------------
/* Your initial Class declaration. This file's name must
   be "[class's name].module.php", or, in this case,
   Skeleton.module.php
*/ 
class CustomContent extends CMSModule
{
  var $start_marker="<!--customContent:";
  var $end_marker="-->";
  var $substitute_content = false;

  function CustomContent()
  {
    //todo call the parent constructor

    // hopefully stop this page from caching all together.
    global $gCms; 
    $pageinfo =& $gCms->variables['pageinfo'];  
    $pageinfo->cachable = false;

    $obj = new ccUser($this);
    $smarty =& $gCms->GetSmarty();
    $smarty->assign('ccuser',$obj);

    // register some functions
    $smarty->register_function('module_installed','module_installed');
    $smarty->register_function('module_version','module_version');
  }

  /*---------------------------------------------------------
   DoAction($action, $id, $params, $return_id)
   ---------------------------------------------------------*/
  function DoAction($action, $id, $params, $return_id=-1)
  {
    switch ($action)
      {
      case 'default':
	{
	  // this is the plug-in side, i.e., non-Admin
	  $this->substitute_content = true;
	  break;
	}
      }
  }


  /*---------------------------------------------------------
   DoEvent($action, $id, $params, $return_id)
   ---------------------------------------------------------*/
  function DoEvent( $originator, $eventname, &$params )
  {
    if( $originator != 'Search' || $eventname != 'SearchItemAdded' )
      {
	return;
      }

    // okay, now handle this funky thing.
    // eseentially, we're being passed a page
    // that we must process.
//      if( $params[2] == 'template' )
//        {
// 	 die("re-index template");
//        }
    
    // this will handle the <!-- customContent: --> stuff
    $origcontent = $params[3];
    $content = &$params[3];
    $this->ContentPostRender( $content );

    // now pass it through smarty
    $content = $this->ProcessTemplateFromData( $content );

    $params[3] =& $content;
  }


  /*---------------------------------------------------------
   DisplayErrorPage($id, $params, $return_id, $message)
   NOT PART OF THE MODULE API
   ---------------------------------------------------------*/
  function DisplayErrorPage($id, &$params, $returnid, $message='')
  {
    $this->smarty->assign_by_ref('title_error', $this->Lang('error'));
    if ($message != '')
      {
	$this->smarty->assign_by_ref('message', $message);
      }
      
    // Display the populated template
    echo $this->ProcessTemplate('error.tpl');
  }


  /*---------------------------------------------------------
   GetName()
   must return the exact class name of the module.
   If these do not match, bad things happen.
   
   Tso his is the name that's shown in the main Modules
   page in the Admin.
   
   If you want to be safe, you can just replace the body
   of this function with:
   return get_class($this); 
   ---------------------------------------------------------*/
  function GetName()
  {
    return 'CustomContent';
  }
  
  /*---------------------------------------------------------
   GetFriendlyName()
   This can return any string, preferably a localized name
   of the module. This is the name that's shown in the
   Admin Menus and section pages (if the module has an admin
   component).
	   
   See the note on localization at the top of this file.
   ---------------------------------------------------------*/
  function GetFriendlyName()
  {
    return $this->Lang('friendlyname');
  }
  
  
  /*---------------------------------------------------------
   GetVersion()
   This can return any string, preferably a number or
   something that makes sense for designating a version.
   The CMS will use this to identify whether or not
   the installed version of the module is current, and
   the module will use it to figure out how to upgrade
   itself if requested.	   
   ---------------------------------------------------------*/
  function GetVersion()
  {
    return '1.4.10';
  }
  
  /*---------------------------------------------------------
   MinimumCMSVersion()
   Return the minimum version of CMS that this module requires.
   ---------------------------------------------------------*/
  function MinimumCMSVersion()
  {
    return '1.2';
  }

  /*---------------------------------------------------------
   GetHelp()
   This returns HTML information on the module.
   Typically, you'll want to include information on how to
   use the module.
   
   See the note on localization at the top of this file.
   ---------------------------------------------------------*/
  function GetHelp()
  {
    return $this->Lang('help');
  }
  

  /*---------------------------------------------------------
   GetAuthor()
   This returns a string that is presented in the Module
   Admin if you click on the "About" link.
   ---------------------------------------------------------*/
  function GetAuthor()
  {
    return 'calguy1000';
  }
  

  /*---------------------------------------------------------
   GetAuthorEmail()
   This returns a string that is presented in the Module
   Admin if you click on the "About" link. It helps users
   of your module get in touch with you to send bug reports,
   questions, cases of beer, and/or large sums of money.
   ---------------------------------------------------------*/
  function GetAuthorEmail()
  {
    return 'rob@techcom.dyndns.org';
  }
  

  /*---------------------------------------------------------
   GetChangeLog()
   This returns a string that is presented in the module
   Admin if you click on the About link. It helps users
   figure out what's changed between releases.
   See the note on localization at the top of this file.
   ---------------------------------------------------------*/
  function GetChangeLog()
  {
    return $this->Lang('changelog');
  }


  /*---------------------------------------------------------
   IsPluginModule()
   This function returns true or false, depending upon
   whether users can include the module in a page or
   template using a smarty tag of the form
   {cms_module module='CustomContent' param1=val param2=val...}
	   
   If your module does not get included in pages or
   templates, return "false" here.
   ---------------------------------------------------------*/
  function IsPluginModule()
  {
    return true;
  }


  /*---------------------------------------------------------
   GetAdminDescription()
   If your module does have an Admin Panel, you
   can have it return a description string that gets shown
   in the Admin Section page that contains the module.
   
   See the note on localization at the top of this file.
   ---------------------------------------------------------*/
  function GetAdminDescription()
  {
    return $this->Lang('moddescription');
  }
  

  /*---------------------------------------------------------
   GetDependencies()
   Your module may need another module to already be installed
   before you can install it.
   This method returns a list of those dependencies and
   minimum version numbers that this module requires.
   
   It should return an hash, eg.
   return array('somemodule'=>'1.0', 'othermodule'=>'1.1');
   ---------------------------------------------------------*/
  function GetDependencies()
  {
    return array('FrontEndUsers'=>'1.3');
  }
  

  /*---------------------------------------------------------
   HasAdmin()
   This function returns a boolean value, depending on
   whether your module adds anything to the Admin area of
   the site. For the rest of these comments, I'll be calling
   the admin part of your module the "Admin Panel" for
   want of a better term.
   ---------------------------------------------------------*/
  function HasAdmin()
  {
    return false;
  }
  

  /*---------------------------------------------------------
   HandlesEvents()
   ---------------------------------------------------------*/
  function HandlesEvents ()
  {
    return true;
  }

  /*---------------------------------------------------------
   Install()
   When your module is installed, you may need to do some
   setup. Typical things that happen here are the creation
   and prepopulation of database tables, database sequences,
   permissions, preferences, etc.
   
   This example creates a Skeleton database table and
   sequence, it creates the "Use Skeleton" permission,
   and sets the "Sing Loudly" preference.
   
   The database is not actually used in this example;
   check any one of the other modules if you want to see
   method code that uses the database.
   
   For information on the creation of database tables,
   check out the ADODB Data Dictionary page at
   http://phplens.com/lens/adodb/docs-datadict.htm
   
   This function can return a "false" in case of any error,
   and CMS will not consider the module installed.
   ---------------------------------------------------------*/
  function Install()
  {
    //$this->AddEventHandler( 'Search', 'SearchItemAdded', false );
  }

  
  /*---------------------------------------------------------
   InstallPostMessage()
   After installation, there may be things you want to
   communicate to your admin. This function returns a
   string which will be displayed.
   
   See the note on localization at the top of this file.
   ---------------------------------------------------------*/
  function InstallPostMessage()
  {
    return $this->Lang('postinstall');
  }

  
  /*---------------------------------------------------------
   UninstallPostMessage()
   After removing a module, there may be things you want to
   communicate to your admin. This function returns a
   string which will be displayed.
   
   See the note on localization at the top of this file.
   ---------------------------------------------------------*/
  function UninstallPostMessage()
  {
    return $this->Lang('postuninstall');
  }
  

  /*---------------------------------------------------------
   Upgrade()
   If your module version number does not match the version
   number of the installed module, the CMS Admin will give
   you a chance to upgrade the module. This is the function
   that actually handles the upgrade.
   Ideally, this function should handle upgrades incrementally,
   so you could upgrade from version 0.0.1 to 10.5.7 with
   a single call. For a great example of this, see the News
   module in the standard CMS install.
   ---------------------------------------------------------*/
  function Upgrade($oldversion, $newversion)
  {
    $current_version = $oldversion;
    switch( $oldversion )
      {
      default: // this'll have to be changed for the next version
	{
	  $this->RemoveEventHandler( 'Search', 'SearchItemAdded' );
	}
      }
  }
  
	
  /*---------------------------------------------------------
   Uninstall()
   Sometimes, an exceptionally unenlightened or ignorant
   admin will wish to uninstall your module. While it
   would be best to lay into these idiots with a cluestick,
   we will do the magnanimous thing and remove the module
   and clean up the database, permissions, and preferences
   that are specific to it.
   This is the method where we do this.
   ---------------------------------------------------------*/
  function Uninstall()
  {
    $this->RemoveEventHandler( 'Search', 'SearchItemAdded' );
  }


       
  /*---------------------------------------------------------
   _testip($range,$ip)
   NOT PART OF THE MODULE API

   This is a function to match an IP address against an 
   address range specification.
   ---------------------------------------------------------*/
  function _testip($range,$ip) 
  {
    $result = 1;

    # IP Pattern Matcher
    # J.Adams <jna@retina.net>
    #
    # Matches:
    #
    # xxx.xxx.xxx.xxx        (exact)
    # xxx.xxx.xxx.[yyy-zzz]  (range)
    # xxx.xxx.xxx.xxx/nn    (nn = # bits, cisco style -- i.e. /24 = class C)
    #
    # Does not match:
    # xxx.xxx.xxx.xx[yyy-zzz]  (range, partial octets not supported)

    if (ereg("([0-9]+)\.([0-9]+)\.([0-9]+)\.([0-9]+)/([0-9]+)",$range,$regs)) {

      # perform a mask match
      $ipl = ip2long($ip);
      $rangel = ip2long($regs[1] . "." . $regs[2] . "." . $regs[3] . "." . $regs[4]);
      
      $maskl = 0;
      
      for ($i = 0; $i< 31; $i++) {
	if ($i < $regs[5]-1) {
	  $maskl = $maskl + pow(2,(30-$i));
	}
      }
      
      if (($maskl & $rangel) == ($maskl & $ipl)) {
	return 1;
      } else {
	return 0;
      }
    } else {
      
      # range based
      $maskocts = split("\.",$range);
      $ipocts = split("\.",$ip);
      
      # perform a range match
      for ($i=0; $i<4; $i++) {
	if (ereg("\[([0-9]+)\-([0-9]+)\]",$maskocts[$i],$regs)) {
	  if ( ($ipocts[$i] > $regs[2]) || ($ipocts[$i] < $regs[1])) {
	    $result = 0;
	  }
	}
	else
	  {
	    if ($maskocts[$i] <> $ipocts[$i]) {
	      $result = 0;
	    }
	  }
      }
    }
    return $result;
  }


  /*---------------------------------------------------------
   A function to add an association to an array
   NOT PART OF THE MODULE API
   ---------------------------------------------------------*/
  function _addArray(&$array, $key, $val)
  {
    $tmp = array($key => $val);
    $array = array_merge($array,$tmp);
  }


  /*---------------------------------------------------------
   A function to evaluate parameters against current user settings
   NOT PART OF THE MODULE API
   ---------------------------------------------------------*/
  function _evaluate(&$parms)
  {
    $module =& $this->GetModuleInstance('FrontEndUsers');
    if( !$module ) return FALSE;

    // here we check the permissions, etc.
    $valid = 0;
    $uid = $module->LoggedInId();
    if( isset( $parms['ip'] ) )
      {
	foreach( $parms['ip'] as $ip )
	{
	  if( $this->_testip( $ip, getenv("REMOTE_ADDR" ) ) )
	    {
	      // valid ip
	      $valid = 1;
	      break;
	    }
	}
      }
    if( $module->LoggedIn() )
      {
	if( $valid == 0 && isset( $parms['group'] ) )
	  {
	    foreach( $parms['group'] as $g ) 
	    {
	      $gid = $module->GetGroupID($g);
	      if( $module->MemberOfGroup($uid, $gid) )
		{
		  // yep... he's valid
		  $valid = 1;
		  break;
		}
	    }
	  }
	if( $valid == 0 && isset( $parms['user'] ) )
	  {
	    foreach( $parms['user'] as $u )
	    {
	      if( strcasecmp($u,$module->LoggedInName()) == 0 )
		{
		  // yep... he's valid
		  $valid = 1;
		  break;
		}
	    }
	  }
	if( $valid == 0 && isset( $parms['loggedin'] ) )
	  {
	    $valid = 1;
	  }
      }

    if( $valid == 0 ) return FALSE;
    return TRUE;
  }

  
  /*---------------------------------------------------------
   Edit the content before rendering
   ---------------------------------------------------------*/
  function TemplatePreCompile(&$template)
  {
    $dummy = false;
    $this->ContentPreCompile($dummy);
  }

  /*---------------------------------------------------------
   Edit the content before rendering
   ---------------------------------------------------------*/
  function ContentPreCompile(&$content)
  {
    $module =& $this->GetModuleInstance('FrontEndUsers');
    if( !$module )
      {
	echo $this->Lang('error_nofeusers');
	return;
      }

    global $gCms;
    $smarty =& $gCms->getSmarty();
    $loggedin = 0;
    $loginname = 'nobody';

    $smarty->assign('customcontent',1);
    $smarty->assign('customcontent_loggedin',$module->LoggedInId());
    $smarty->assign('customcontent_ip', getenv('REMOTE_ADDR') );
    if( $module->LoggedInId() > 0 )
      {
	$loginname = $module->LoggedInName();
      }
    $smarty->assign('customcontent_loginname',$loginname);
    $groups = $module->GetMemberGroupsArray( $module->LoggedInId() );
    $txt = '';
    if( is_array( $groups ) )
      {
      foreach( $groups as $grp )
        {
 	  $gn = $module->GetGroupName($grp['groupid']);
  	  $txt .= $gn.",";
 	  $smarty->assign('customcontent_memberof_'.$gn,1);
        }
      }
    if( $module->LoggedInId() > 0 )
      {
	$smarty->assign('customcontent_loginname',$module->LoggedInName());
	$groups = $module->GetMemberGroupsArray( $module->LoggedInId() );
	if( is_array( $groups ) )
	  {
	    $names = array();
	    foreach( $groups as $grp )
	      {
		$gn = $module->GetGroupName($grp['groupid']);
		$names[] = $gn;
		$smarty->assign('customcontent_memberof_'.$gn,1);
	      }
	    $smarty->assign('customcontent_groups',implode(',',$names));
	  }
	$smarty->assign('customcontent_groupcount',count($groups));
      }

    // and date and time stuff too, for good measure
    $vars = array(
		  'customcontent_dayzeros' => 'd',
		  'customcontent_day3text' => 'D',
		  'customcontent_day' => 'j',
		  'customcontent_weekday' => 'l',
		  'customcontent_dayordsuffix' => 'S',
		  'customcontent_dayofweek' => 'w',
		  'customcontent_dayofyear' => 'z',
		  'customcontent_weeknum' => 'W',
		  'customcontent_monthfulltext' => 'F',
		  'customcontent_monthnumzeros' => 'm',
		  'customcontent_monthshorttext' => 'M',
		  'customcontent_monthnum' => 'n',
		  'customcontent_monthnumdays' => 't',
		  'customcontent_leapyear' => 'L',
		  'customcontent_4digityear' => 'Y',
		  'customcontent_2digityear' => 'y',
		  'customcontent_lowerampm' => 'a',
		  'customcontent_upperampm' => 'A',
		  'custoncontent_inettime' => 'B',
		  'customcontent_12hour' => 'g',
		  'customcontent_24hour' => 'G',
		  'customcontent_12hourzeros' => 'h',
		  'customcontent_24hourzeros' => 'H',
		  'customcontent_minutes' => 'i',
		  'customcontent_seconds' => 's',
		  'customcontent_timezone' => 'T',
		  'customcontent_date' => 'r',
		  'customcontent_epochseconds' => 'U'
		  );
    $time = time();
    foreach( $vars as $key => $value )
      {
	$smarty->assign($key,date($value,$time));
      }
    
  }


  /*---------------------------------------------------------
   Edit the content after rendering
   ---------------------------------------------------------*/
  function ContentPostRender(&$content)
  {
    global $gCms;
    $this->smarty =& $gCms->getSmarty();
    $module =& $this->GetModuleInstance('FrontEndUsers');
    if( !$module )
      {
	// couldn't get a userid instance, do nothing
	echo $this->Lang('error_nofeusers');
	return;
      }

    if( $this->substitute_content != true )
      {
	// we can leave the page as is for now I guess
// 	$content=preg_replace($this->start_marker_regexp,"",$content);
// 	$content=preg_replace($this->end_marker,"",$content);
	return;
      }

    // start processing tags
    $beforetag = -1;
    $aftertag  = -1;
    $expect = 0;
    $loop = 0;
    $include_start = -1;
    $include_end = -1;
    $pos = 0;
    while( $loop < 150 ) 
      {
	// increment a loop counter (avoid endless loops)
	$loop++;

	// find the start of the tag
	$tag_startpos = strpos($content, $this->start_marker,$pos);
	if( $tag_startpos == false ) return;

	// now have to find the end of the marker
	$tag_endpos = strpos($content,$this->end_marker,$tag_startpos);
	$tag_endpos += strlen($this->end_marker);

	// and get the entire tag
	$tag = trim(substr($content,$tag_startpos,$tag_endpos-$tag_startpos));

	// remove the start tag and end tag
	$str = substr($tag,strlen($this->start_marker));
	$str = trim(substr($str,0,strlen($str)-strlen($this->end_marker)));
	$data = preg_split('/\\s+/',$str);
	if( count($data) == 0 )
	  {
	    // an error occurred here
	    return;
	  }

	// parse the command into commnd and parameters
	$cmd = array_shift($data);
	$parms = array();
	foreach( $data as $d )
	  {
	    $opts = split(";",$d);
	    foreach( $opts as $opt ) {
	      $p = strpos($opt,'=');
	      if( $p != 0 )
		{
		  $k = substr($opt,0,$p);
		  $v = substr($opt,$p+1);
		  $vals = split(",",$v);
		  $parms[$k] = $vals;
		}
	      else
		$parms[$opt] = 1;
	    }
	  }
	
	// and now handle the command
	switch( $cmd )
	  {
	  case 'startif':
	  case 'start':
	    {
	      if( $expect != 0 )
		{
		  // error here, we're expecting someting
		  return;
		}
	      // evaluate the parameters, to see if we matchem
	      if( $this->_evaluate( $parms ) ) 
		{
		  // conditions passed, now we have to include everything till the next
		  // tag which is either an endif or an else
		  $include_start = $tag_endpos;
		}
	      // get ready to continue
	      $beforetag = $tag_startpos;
	      $expect = 2;
	      break;
	    }
	  case 'elseif':
	    {
	      if( $expect != 1 && $expect != 2 )
		{
		  // error here, we're expecting a certain something
		  return;
		}
	      // evaluate the parameters, to see if we matchem
	      if( $this->_evaluate( $parms ) ) 
		{
		  // conditions passed, now we have to include everything till the next
		  // tag which is either an endif or an else
		  $include_start = $tag_endpos;
		}
	      // get ready to continue
	      $beforetag = $tag_startpos;
	      $expect = 2;
	      break;
	    }
	  case 'else':
	    {
	      if( $expect != 1 && $expect != 2 )
		{
		  // error here, we're expecting a certain something
		  return;
		}
	      if( $include_start == -1 ) 
		{
		  // we failed the last condition 
		  $include_start = $tag_endpos;
		}
	      else 
		{
		  // we passed the last condition so record and end position
		  $include_end = $tag_startpos;
		}

	      // get ready to continue
	      $expect = 2;
	      break;
	    }
	  case 'end':
	  case 'endif':
	    {
	      if( $expect != 1 && $expect != 2 )
		{
		  // error here, we're expecting a certain something
		  return;
		}

	      if( $include_end == -1 && $include_start != -1 )
		{
		  // now catch the end position of what we have to include
		  $include_end = $tag_startpos;
		}
	      $aftertag = $tag_endpos;

	      // get ready to continue
	      $expect = 0;
	      break;
	    }
	  default:
	    {
	      // unknown command
	      return;
	    }
	  }

	if( $beforetag != -1 && $aftertag != -1 )
	  {
	    // we have a whole section (hopefully)
	    $newstart = substr($content,0,$beforetag);
	    $include  = substr($content,$include_start,$include_end-$include_start);
	    $newend   = substr($content,$aftertag);
	    $content = $newstart.$include.$newend;
	    $include_start = -1;
	    $include_end = -1;
	    $beforetag = -1;
	    $aftertag = -1;
	    $pos = 0;
	  }
	else
	  {
	    $pos = $tag_endpos;
	  }
      }
  }

  /*---------------------------------------------------------
   Test if a module is installeed (smarty function)
   ---------------------------------------------------------*/
  function module_installed($params, &$smarty)
  {
    if( isset( $params['module'] ) )
      {
	$name = trim($params['module']);
	global $gCms;
	if( isset( $gCms->modules[$name] ) )
	  {
	    return true;
	  }
      }
    return false;
  }

  /*---------------------------------------------------------
   Return a module's version
   ---------------------------------------------------------*/
  function module_version($params, &$smarty)
  {
    if( isset( $params['module'] ) )
      {
	$name = trim($params['module']);
	global $gCms;
	if( isset( $gCms->modules[$name] ) )
	  {
	    $obj =& $gCms->modules[$name]['object'];
	    return $obj->GetVersion();
	  }
      }
    return '';
  }


}

?>
]]></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
$lang['error_nofeusers'] = 'Error: Could not find the FrontEndUsers module';
$lang['friendlyname'] = 'Custom Content Module';
$lang['postinstall'] = '';
$lang['postuninstall'] = '';
$lang['uninstalled'] = 'Module Uninstalled.';
$lang['installed'] = 'Module version %s installed.';
$lang['accessdenied'] = 'Access Denied. Please check your permissions.';
$lang['error'] = 'Error!';
$lang['upgraded'] = 'Module upgraded to version %s.';
$lang['moddescription'] = 'This module provides the ability to specify different content by group or user name';
$lang['changelog'] = '<ul><li>Version 1.0. 14 September 2005. Initial Release.</li></ul>
<ul>
<li>Version 1.1.  - September 2005. Added startif/else/endif, and search through multiple groups and users.</li>
<li>Version 1.2.  - September 2005. Added loggedin optional parameter</li>
<li>Version 1.3   - October   2005. Changed to use FrontEndUsers instead of UserID</li>
<li>Version 1.3.1 - November 2005. Very minor bugfix to the parameter parsing</li>
<li>Version 1.4.0 - January, 2006.
<p>Added smarty compatible variables</p></li>
<li>Version 1.4.1 - May, 2006.
<p>Smarty variables now work in 0.13b2</p>
<p>Now require CMS 0.13b2 as a minimum</p>
<p>Updated the help</p>
</li>
<li>Version 1.4.3 - June, 2006.
<p>Added search module compatibility</p>
<p>Added date and time smarty variables</p>
</li>
<li>Version 1.4.4 - Dec, 2006.
<p>Added TemplatePrecompile callback</p>
<li>Version 1.4.5 - Mar, 2007.
<p>Removed the SearchItemAdded callback...</p>
<li>Version 1.4.6 - Apr, 2007.
<p>Added the ccuser object for easier expressions.</p>
<li>Version 1.4.7 - Sep, 2007.
<p>Adjusted the help, the comment syntax is now deprecated</p>
<p>Added a property method to the ccuser object</p>
</li>
<li>Version 1.4.8 - Sep, 2007.
<p>Added the module_exists method to the ccuser object</p>
</li>
<li>Version 1.4.9 - Oct. 2007.
<p>Some minor fixes that seem to fix problems where FEU would get instantiated twice</p>
<p>Fixes an issue in the memberof() method of ccuser when not logged in</p>
</li>
<li>Version 1.4.10 - Nov. 2007.
<p>Minimum CMS Version is now 1.2</p>
<p>Adds new functions to the ccuser object: get_parent_alias(), get_root_alias(), get_page_title(), has_children()</p>
</li>
</ul>';
$lang['help'] = '<h3>What Does This Do?</h3>
<p>This module, in conjunction with the UserID module allows you to create a page that will look different depending upon the person that looks at it.  You can specify different content for certain users, or members of a certain group.</p>
<p><b>Note 1:</b> When putting custom smarty logic into any page, you should ensure that that page will not be cached.  This is accomplished by ensuring that the &quote;cachable&quote; tag is cleared on the page before submitting or applying</p>
<p><b>Note 2:</b> If the smarty logic is in your template, you need to ensure that each page that uses that template is not cachable</p>
<h3>How Do I Use It</h3>
<h4>Method 1 : smarty</h4>
<pre>
{if $customcontent_loggedin}
  Welcome &lt;b&gt;{$customcontent_loginname}&lt;/b&gt;&lt;br/&gt;
{else}
  &lt;h1&gt;You are not authorized to view this data&lt;/h1&gt;
{/if}
</pre>
<p>Or you can use the $ccuser variable for more advanced, and easier to read testing</p>
<pre>
{if $ccuser->loggedin() && $ccuser->memberof(\'members\') && $ccuser->ipmatches(\'192.168.0.0/24\')}
Welcome logged in local member
{elseif $ccuser->loggedin() && $ccuser->memberof(\'members\')}
Welcome logged in member
{elseif $ccuser->loggedin()}
Welcome user from some other group
{else}
Anonymous user
{/if}
</pre>
<p>Any smarty compatible expressions or logic can be used with the available variables.  Using this syntax, expressions may be nested, or complex logic used.</p>
<h4>Available variables:</h4>
<ul>
<li><p><em>ccuser</em> - An object with convenience functions for testing.</p>
<p>This object contains some convenience methods for performing more advanced customcontent logic, or for making your template look a little bit better. The available methods are:</p>
  <ul>
<li><em>$ccuser->get_parent_alias($alias = \'\')</em> - outputs the page alias of the parent page, or empty if the specified page does not have a parent (is at the top).  This function will accept a page alias as an argument, if no page alias is specified, the current page is assumed.</li>
<li><em>$ccuser->get_root_alias($alias = \'\')</em> - outputs the page alias of the topmost parent page, or empty if the specified page does not have a parent (is at the top).  This function will accept a page alias as an argument, if no page alias is specified, the current page is assumed.</li>
<li><em>$ccuser->get_page_title($alias = \'\')</em> - outputs the title of the page matching the supplied alias.  This function will accept a page alias as an argument, if no page alias is specified, the current page is assumed.</li>
<li><em>$ccuser->has_children($alias = \'\')</em> - outputs a boolean indicating if the specified page has child pages or not.  This function will accept a page alias as an argument, if no page alias is specified, the current page is assumed.</li>
<li><em>$ccuser->groups()</em> - outputs a list of the users member groups</li>
<li><em>$ccuser->memberof(\'group\')</em> - outputs a boolean if the user is indeed a member of this group.  This function will also accept a comma separated list of group names.</li>
<li><em>$ccuser->loggedin()</em> - outputs a boolean if the user is loggedin</li>
<li><em>$ccuser->property(\'propertyname\')</em> - outputs the value of the property for the currently logged in user.</li>
<li><em>$ccuser->module_installed(\'modulename\')</em> - outputs a boolean if the specified module is installed and available.</li>
<li><em>$ccuser->ipmatches($ranges)</em> - outputs a boolean if the users ip address matches one of the comma separated ip ranges.  Accepts ranges like ###.###.###.###/## i.e: 192.168.0.0/24</li>
  </ul>
<br/>
</li>
<li><p><em>customcontent_ip</em> - The remote IP address</p></li>
<li><p><em>customcontent_loggedin</em> - A boolean indicating wether the user is logged in or not</p></li>
<li><p><em>customcontent_loginname</em> - The name of the currently logged in user</p></li>
<li><p><em>customcontent_groupcount</em> - A count of the number of groups this user is a member of</p></li>
<li><p><em>customcontent_groups</em> - A string containing the group names of all member groups</p></li>
<li><p><em>customcontent_memberof_*</em> - A series of boolean variables indicating group membership.  i.e.: customcontent_memberof_staff, customcontent_memberof_users, etc.  No variables are defined for groups that this user is not a member of.</p></li>
<li><p><em>customcontent_dayzeros</em> - Day of the month, 2 digits with leading zeros</p></li> 
<li><p><em>customcontent_day3text</em> - A textual representation of a day, three letters</p></li>
<li><p><em>customcontent_day</em> - Day of the month without leading zeros</p></li> 
<li><p><em>customcontent_weekday</em> - A full textual representation of the day of the week</p></li> 
<li><p><em>customcontent_dayordsuffix</em> - English ordinal suffix for the day of the month, 2 characters</p></li> 
<li><p><em>customcontent_dayofweek</em> - Numeric representation of the week</p></li> 
<li><p><em>customcontent_dayofyear</em> - The day of the year (starting from 0)</p></li> 
<li><p><em>customcontent_weeknum</em> - ISO-8601 week number of year, weeks starting on Monday</p></li> 
<li><p><em>customcontent_monthfulltext</em> - A full textual representation of a month, such as January or March</p></li> 
<li><p><em>customcontent_monthnumzeros</em> - Numeric representation of a month, with leading zeros</p></li> 
<li><p><em>customcontent_monthshorttext</em> - A short textual representation of a month, three letters</p></li> 
<li><p><em>customcontent_monthnum</em> - Numeric representation of a month, without leading zeros</p></li> 
<li><p><em>customcontent_monthnumdays</em> - Number of days in the current month</p></li> 
<li><p><em>customcontent_leapyear</em> - Wether it\'s a leap year</p></li> 
<li><p><em>customcontent_4digityear</em> - A full numeric representation of a year, 4 digits</p></li> 
<li><p><em>customcontent_2digityear</em> - A two digit representation of a year</p></li> 
<li><p><em>customcontent_lowerampm</em> - Lowercase Ante meridiem and Post meridiem</p></li> 
<li><p><em>customcontent_upperampm</em> - Uppercase Ante meridiem and Post meridiem</p></li>
<li><p><em>customcontent_inettime</em> - Swatch Internet time</p></li>
<li><p><em>customcontent_12hour</em> - 12-hour format of an hour without leading zeros</p></li>
<li><p><em>customcontent_24hour</em> - 24-hour format of an hour without leading zeros</p></li>
<li><p><em>customcontent_12hourzeros</em> - 12-hour format of an hour with leading zeros</p></li>
<li><p><em>customcontent_24hourzeros</em> - 24-hour format of an hour with leading zeros</p></li>
<li><p><em>customcontent_minutes</em> - Minutes with leading zeros</p></li>
<li><p><em>customcontent_seconds</em> - Seconds, with leading zeros</p></li>
<li><p><em>customcontent_timezone</em> - Timezone setting of this machine</p></li>
<li><p><em>customcontent_date</em> - RFC 2822 formatted date</p></li>
<li><p><em>customcontent_epochseconds</em> - Seconds since the Unix Epoch (January 1 1970 00:00:00 GMT)</p></li>
</ul>
<h4>Method 2: comment tags <em>(deprecated)</em></h3>
<p>To use it you place the tag {cms_module module=CustomContent} into your page or template, and then below that you place the content you want isolated to specific users in groups in one of two ways, either using specially formatted comment tags, or using smarty syntax.</p>
<pre>
{cms_module module=CustomContent}
&lt;!--customContent: startif group=testers,admins --&gt;
&lt;H1&gt;This content is only available to logged in testers and and admins&lt;/H1&gt;
&lt;!--customContent: else --&gt;
&lt;H1&gt;This content is available to everybody else&lt;/H1&gt;
&lt;!--customContent: endif --&gt;
&lt;!--customContent: startif group=users --&gt;
&lt;H1&gt;This content is only available to logged in users &lt;/H1&gt;
&lt;!--customContent: endif --&gt;
</pre>
<p><b>Available parameters</b></p> 
<ul>
<li><p><em>ip</em> - test if remote ip matches a network or supplied ip address.  Valid formats are xxx.xxx.xxx.xxx (exact), xxx.xxx.xxx.[yyy-zzz] (range) and xxx.xxx.xxx/nn (nn = # bits, i.e.  192.168.1.0/24)</p></li>
<li><p><em>group</em> - test if the currently logged in user is a member of any of the supplied groups</p></li>
<li><p><em>user<em> - test if the currently logged in username matches any of the supplied ones</p></li>
<li><p><em>loggedin<em> - test if the current user is logged in or not./p></li>
</ul>
<p>Tests are evaluated in a logical OR fashion in order as follows ip address, group, and user.  The first successfull test will result in the expression evaluationg to true</p>
<h3>Copyright and License</h3>
<p>Copyright &copy; 2005, Robert Campbell <a href="mailto:rob@techcom.dyndns.org">&lt;rob@techcom.dyndns.org&gt;</a>. All Rights Are Reserved.</p>
<p>This module has been released under the <a href="http://www.gnu.org/licenses/licenses.html#GPL">GNU Public License</a>. You must agree to this license before using the module.</p>
';
?>
]]></data>
	</file>
	<file>
	  <filename>/lang/ext/</filename>
	  <isdir>1</isdir>
	</file>
	<file>
	  <filename>/lang/ext/cs_CZ.php</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[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]]></data>
	</file>
	<file>
	  <filename>/lang/ext/da_DK.php</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[<?php
$lang['error_nofeusers'] = 'Fejl: Kunne ikke finde FrontEndUsers modules';
$lang['friendlyname'] = 'Specielt Indhold modules';
$lang['postinstall'] = '';
$lang['postuninstall'] = '';
$lang['uninstalled'] = 'Modul afinstalleret.';
$lang['installed'] = 'Modul version %s installeret.';
$lang['accessdenied'] = 'Adgang n&aelig;gtet! Tjek dine rettigheder.';
$lang['error'] = 'Fejl!';
$lang['upgraded'] = 'Modul upgraderet til version %s.';
$lang['moddescription'] = 'Dette module giver mulighed for at angive specielt indhold for grupper eller brugernavne';
$lang['changelog'] = '<ul><li>Version 1.0. 14 September 2005. Initial Release.</li></ul>
<ul>
<li>Version 1.1.  - September 2005. Added startif/else/endif, and search through multiple groups and users.</li>
<li>Version 1.2.  - September 2005. Added loggedin optional parameter</li>
<li>Version 1.3   - October   2005. Changed to use FrontEndUsers instead of UserID</li>
<li>Version 1.3.1 - November 2005. Very minor bugfix to the parameter parsing</li>
<li>Version 1.4.0 - January, 2006.
<p>Added smarty compatible variables</p></li>
<li>Version 1.4.1 - May, 2006.
<p>Smarty variables now work in 0.13b2</p>
<p>Now require CMS 0.13b2 as a minimum</p>
<p>Updated the help</p>
</li>
</ul>';
$lang['help'] = '<h3>What Does This Do?</h3>
<p>This module, in conjunction with the UserID module allows you to create a page that will look different depending upon the person that looks at it.  You can specify different content for certain users, or members of a certain group.</p>
<p><b>Note 1:</b> When putting custom smarty logic into any page, you should ensure that that page will not be cached.  This is accomplished by ensuring that the &amp;quote;cachable&amp;quote; tag is cleared on the page before submitting or applying</p>
<p><b>Note 2:</b> If the smarty logic is in your template, you need to ensure that each page that uses that template is not cachable</p>
<h3>How Do I Use It (method 1: comment tags)</h3>
<p>To use it you place the tag {cms_module module=CustomContent} into your page or template, and then below that you place the content you want isolated to specific users in groups in one of two ways, either using specially formatted comment tags, or using smarty syntax.</p>
<h4>Method 1: comment tags</h4>
<pre>
{cms_module module=CustomContent}
&amp;lt;!--customContent: startif group=testers,admins --&amp;gt;
&amp;lt;H1&amp;gt;This content is only available to logged in testers and and admins&amp;lt;/H1&amp;gt;
&amp;lt;!--customContent: else --&amp;gt;
&amp;lt;H1&amp;gt;This content is available to everybody else&amp;lt;/H1&amp;gt;
&amp;lt;!--customContent: endif --&amp;gt;
&amp;lt;!--customContent: startif group=users --&amp;gt;
&amp;lt;H1&amp;gt;This content is only available to logged in users &amp;lt;/H1&amp;gt;
&amp;lt;!--customContent: endif --&amp;gt;
</pre>
<p><b>Available parameters</b></p> 
<ul>
<li><p><em>ip</em> - test if remote ip matches a network or supplied ip address.  Valid formats are xxx.xxx.xxx.xxx (exact), xxx.xxx.xxx.[yyy-zzz] (range) and xxx.xxx.xxx/nn (nn = # bits, i.e.  192.168.1.0/24)</p></li>
<li><p><em>group</em> - test if the currently logged in user is a member of any of the supplied groups</p></li>
<li><p><em>user<em> - test if the currently logged in username matches any of the supplied ones</p></li>
<li><p><em>loggedin<em> - test if the current user is logged in or not./p></li>
</ul>
<p>Tests are evaluated in a logical OR fashion in order as follows ip address, group, and user.  The first successfull test will result in the expression evaluationg to true</p>
<h3>How Do I Use It (method 2 : smarty)</h3>
<pre>
{cms_module module=CustomContent}
{if $customcontent_loggedin}
  Welcome &amp;lt;b&amp;gt;{$customcontent_loginname}&amp;lt;/b&amp;gt;&amp;lt;br/&amp;gt;
{else}
  &amp;lt;h1&amp;gt;You are not authorized to view this data&amp;lt;/h1&amp;gt;
{/if}
</pre>
<p>Any smarty compatible expressions or logic can be used with the available variables.  Using this syntax, expressions may be nested, or complex logic used.</p>
<h4>Available variables:</h4>
<ul>
<li><p><em>customcontent_ip</em> - The remote IP address</p></li>
<li><p><em>customcontent_loggedin</em> - A boolean indicating wether the user is logged in or not</p></li>
<li><p><em>customcontent_loginname</em> - The name of the currently logged in user</p></li>
<li><p><em>customcontent_groupcount</em> - A count of the number of groups this user is a member of</p></li>
<li><p><em>customcontent_groups</em> - A string containing the group names of all member groups</p></li>
<li><p><em>customcontent_memberof_*</em> - A series of boolean variables indicating group membership.  i.e.: customcontent_memberof_staff, customcontent_memberof_users, etc.  No variables are defined for groups that this user is not a member of.</p></li>
<li><p><em>customcontent_dayzeros</em> - Day of the month, 2 digits with leading zeros</p></li> 
<li><p><em>customcontent_day3text</em> - A textual representation of a day, three letters</p></li>
<li><p><em>customcontent_day</em> - Day of the month without leading zeros</p></li> 
<li><p><em>customcontent_weekday</em> - A full textual representation of the day of the week</p></li> 
<li><p><em>customcontent_dayordsuffix</em> - English ordinal suffix for the day of the month, 2 characters</p></li> 
<li><p><em>customcontent_dayofweek</em> - Numeric representation of the week</p></li> 
<li><p><em>customcontent_dayofyear</em> - The day of the year (starting from 0)</p></li> 
<li><p><em>customcontent_weeknum</em> - ISO-8601 week number of year, weeks starting on Monday</p></li> 
<li><p><em>customcontent_monthfulltext</em> - A full textual representation of a month, such as January or March</p></li> 
<li><p><em>customcontent_monthnumzeros</em> - Numeric representation of a month, with leading zeros</p></li> 
<li><p><em>customcontent_monthshorttext</em> - A short textual representation of a month, three letters</p></li> 
<li><p><em>customcontent_monthnum</em> - Numeric representation of a month, without leading zeros</p></li> 
<li><p><em>customcontent_monthnumdays</em> - Number of days in the current month</p></li> 
<li><p><em>customcontent_leapyear</em> - Wether it&#039;s a leap year</p></li> 
<li><p><em>customcontent_4digityear</em> - A full numeric representation of a year, 4 digits</p></li> 
<li><p><em>customcontent_2digityear</em> - A two digit representation of a year</p></li> 
<li><p><em>customcontent_lowerampm</em> - Lowercase Ante meridiem and Post meridiem</p></li> 
<li><p><em>customcontent_upperampm</em> - Uppercase Ante meridiem and Post meridiem</p></li>
<li><p><em>customcontent_inettime</em> - Swatch Internet time</p></li>
<li><p><em>customcontent_12hour</em> - 12-hour format of an hour without leading zeros</p></li>
<li><p><em>customcontent_24hour</em> - 24-hour format of an hour without leading zeros</p></li>
<li><p><em>customcontent_12hourzeros</em> - 12-hour format of an hour with leading zeros</p></li>
<li><p><em>customcontent_24hourzeros</em> - 24-hour format of an hour with leading zeros</p></li>
<li><p><em>customcontent_minutes</em> - Minutes with leading zeros</p></li>
<li><p><em>customcontent_seconds</em> - Seconds, with leading zeros</p></li>
<li><p><em>customcontent_timezone</em> - Timezone setting of this machine</p></li>
<li><p><em>customcontent_date</em> - RFC 2822 formatted date</p></li>
<li><p><em>customcontent_epochseconds</em> - Seconds since the Unix Epoch (January 1 1970 00:00:00 GMT)</p></li>
</ul>
<h3>Copyright and License</h3>
<p>Copyright &amp;copy; 2005, Robert Campbell <a href=&quot;mailto:rob@techcom.dyndns.org&quot;>&amp;lt;rob@techcom.dyndns.org&amp;gt;</a>. All Rights Are Reserved.</p>
<p>This module has been released under the <a href=&quot;http://www.gnu.org/licenses/licenses.html#GPL&quot;>GNU Public License</a>. You must agree to this license before using the module.</p>';
?>]]></data>
	</file>
	<file>
	  <filename>/lang/ext/de_DE.php</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[<?php
$lang['error_nofeusers'] = 'Fehler: Konnte keine Installation des FrontEndUsers-Moduls finden';
$lang['friendlyname'] = 'CustomContent-Modul';
$lang['postinstall'] = '';
$lang['postuninstall'] = '';
$lang['uninstalled'] = 'Modul deinstalliert.';
$lang['installed'] = 'Modulversion %s installiert.';
$lang['accessdenied'] = 'Zugriff verweigert. Bitte pr&uuml;fen Sie Ihre Berechtigungen.';
$lang['error'] = 'Fehler!';
$lang['upgraded'] = 'Modul auf Version %s aktualisiert.';
$lang['moddescription'] = 'Mit diesem Modul k&ouml;nnen Sie in Abh&auml;ngigkeit der Gruppenzugeh&ouml;rigkeit oder des Benutzernamens verschiedene Inhalte auf Ihrer Homepage anzeigen lassen.';
$lang['changelog'] = '<ul><li>Version 1.0. 14 September 2005. Initial Release.</li></ul>
<ul>
<li>Version 1.1.  - September 2005. Added startif/else/endif, and search through multiple groups and users.</li>
<li>Version 1.2.  - September 2005. Added loggedin optional parameter</li>
<li>Version 1.3   - October   2005. Changed to use FrontEndUsers instead of UserID</li>
<li>Version 1.3.1 - November 2005. Very minor bugfix to the parameter parsing</li>
<li>Version 1.4.0 - January, 2006.
<p>Added smarty compatible variables</p>
<li>Version 1.4.1 - May, 2006.
<p>Smarty variables now work in 0.13b2</p>
<p>Now require CMS 0.13b2 as a minimum</p>
<p>Updated the help</p>
</li>
<li>Version 1.4.3 - June, 2006.
<p>Added search module compatibility</p>
<p>Added date and time smarty variables</p>
</li>
<li>Version 1.4.4 - Dec, 2006.
<p>Added TemplatePrecompile callback</p>
<li>Version 1.4.5 - Mar, 2007.
<p>Removed the SearchItemAdded callback...</p>
<li>Version 1.4.6 - Apr, 2007.
<p>Added the ccuser object for easier expressions.</p>
</li>
<li>Version 1.4.7 - Sep, 2007.
<p>Adjusted the help, the comment syntax is now deprecated</p>
<p>Added a property method to the ccuser object</p>
</li>
<li>Version 1.4.8 - Sep, 2007.
<p>Added the module_exists method to the ccuser object</p>
</li>
<li>Version 1.4.9 - Oct. 2007.
<p>Some minor fixes that seem to fix problems where FEU would get instantiated twice</p>
<p>Fixes an issue in the memberof() method of ccuser when not logged in</p>
</li>
</ul>';
$lang['help'] = '<h3>Was macht dieses Modul?</h3>
<p>Dieses Modul erm&ouml;glicht es, in Verbindung mit dem FrontendUsers-Modul eine Seite zu erstellen, deren Inhalt von der Person abh&auml;ngig ist, die sie betrachtet. So k&ouml;nnen Sie f&uuml;r bestimmte Benutzer oder Mitglieder bestimmter Gruppen unterschiedliche Inhalte festlegen.</p>
<p><b>Hinweis 1:</b> Wenn Sie die Smarty-Logik im Inhalt einer Seite einf&uuml;gen, sollten Sie darauf achten, dass beim Speichern dieser Seite der Parameter &quot;Zwischenspeichern&quot; (Reiter Optionen) nicht aktiviert ist.</p>
<p><b>Hinweis 2:</b> Wenn Sie die Smarty-Logik in Ihrem Template einsetzen, sollten Sie darauf achten, dass f&uuml;r jede Seite, die dieses Template verwendet, der Parameter &quot;Zwischenspeichern&quot; deaktiviert ist.</p>
<h3>Wie wird es eingesetzt?</h3>
<p>Rufen Sie den Tag {cms_module module=CustomContent} in einer Seite oder einem Template auf. Unterhalb des Tags plazieren Sie den Inhalt, der nur bestimmten Usern oder Gruppen angezeigt werden soll. Das ist auf zwei unterschiedlichen Wegen m&ouml;glich, entweder &uuml;ber speziell formatierte Kommentar-Tags oder durch Verwendung von Smarty-Syntax.</p>
<h4>Methode 1: Kommentar-Tags</h4>
<pre>
{cms_module module=CustomContent}
<!--customContent: startif group=testers,admins -->
<h1>Dieser Inhalt ist nur f&uuml;r eingeloggte Besucher der Gruppen testers und admins sichtbar</h1>
<!--customContent: else -->
<h1>Dieser Inhalt ist f&uuml;r jedermann sichtbar</h1>
<!--customContent: endif -->
<!--customContent: startif group=users -->
<h1>Dieser Inhalt ist nur f&uuml;r eingeloggte User sichtbar </h1>
<!--customContent: endif -->
</pre>
<p><b>Verf&uuml;gbare Parameter</b></p> 
<ul>
<li><p><em>ip</em> - pr&uuml;ft, ob die Remote-IP mit einer benannten IP-Adresse &uuml;bereinstimmt.  G&uuml;ltige Formate sind xxx.xxx.xxx.xxx (exakt), xxx.xxx.xxx.[yyy-zzz] (Bereich) und xxx.xxx.xxx/nn (nn = # bits, z. Bsp.  192.168.1.0/24)</p></li>
<li><p><em>group</em> - pr&uuml;ft, ob der aktuell angemeldete Benutzer Mitglied einer der benannten Gruppen ist</p></li>
<li><p><em>user</em> - pr&uuml;ft, ob der Name des aktuell angemeldeten Benutzers mit einem der benannten &uuml;bereinstimmt</p></li>
<li><p><em>loggedin</em> - pr&uuml;ft, ob der aktuelle Benutzer angemeldet ist oder nicht./p></li>
</ul>
<p>Die Tests werden mit einem logischen ODER in der Reihenfolge IP-Adresse, Gruppe und Benutzer ausgewertet. Der erste erfolgreiche Test setzt den Wert der Abfrage auf wahr (true).</p>
<h4>Methode 2: Smarty-Syntax</h4>
<pre>
{cms_module module=CustomContent}
{if $customcontent_loggedin}
  Willkommen <b>{$customcontent_loginname}</b><br/>
{/else}
  <h1>Sie sind nicht authorisiert, diese Daten zu sehen.</h>
{/if}
</pre>
<p>Oder Sie verwenden die $ccuser-Variable f&uuml;r erweiterte und einfacher zu lesende Abfragen:</p>
<pre>
{if $ccuser->loggedin() &amp;&amp; $ccuser->memberof(&#039;members&#039;) &amp;&amp; $ccuser->ipmatches(&#039;192.168.0.0/24&#039;)}
   Willkommen, angemeldetes, lokales Mitglied
{elseif $ccuser->loggedin() &amp;&amp; $ccuser->memberof(&#039;members&#039;)}
   Willkommen, angemeldetes Mitglied
{elseif $ccuser->loggedin()}
   Willkommen, Benutzer einer anderen Gruppe
{else}
   Anonymer Benutzer
{/if}
</pre>
<p>Die verf&uuml;gbaren Variablen k&ouml;nnen mit jedem beliebigen Smarty-kompatiblen Ausdruck einer ODER-Logik verwendet werden. Wenn Sie Smarty-Syntax einsetzen, k&ouml;nnen die Ausdr&uuml;cke verschachtelt sein oder eine komplexe Logik verwenden.</p>
<p><b>Verf&uuml;gbare Variablen:</b></p>
<ul>
<li><p><em>ccuser</em> - Ein Object mit komfortablen Funktionen zum Testen.</p>
<p>Dieses Objekt enth&auml;lt einige komfortable Methoden, um eine erweiterte CustomContent-Logik zu verwenden oder Ihr Template etwas besser aussehen zu lassen. Die verf&uuml;gbaren Methoden sind folgende:</p>
  <ul>
<li><em>$ccuser->groups()</em> - gibt eine Liste der Benutzer aller Gruppenmitglieder aus</li>
<li><em>$ccuser->memberof(&#039;group&#039;)</em> - gibt eine Variable vom Typ Boolean aus, wenn der Benutzer Mitglied dieser Gruppe ist. Diese Funktion akzeptiert auch eine mit Kommata getrennte Liste von Gruppennamen.</li>
<li><em>$ccuser->loggedin()</em> - gibt eine Variable vom Typ Boolean aus, wenn der Benutzer angemeldet ist</li>
<li><em>$ccuser->ipmatches($ranges)</em> - gibt eine Variable vom Typ Boolean aus, wenn die IP des Benutzers mit einem Wert der vorgegebenen (durch Kommata zu trennenden) IP-Liste &uuml;bereinstimmt.  Es werden Werte im Format ###.###.###.###/## akzeptiert, z. Bsp: 192.168.0.0/24</li>
  </ul>
<br/>
<li><p><em>customcontent_ip</em> - die Remote-IP-Adresse</p></li>
<li><p><em>customcontent_loggedin</em> - eine Variable vom Typ Boolean, die bestimmt, ob ein Benutzer angemeldet ist oder nicht</p></li>
<li><p><em>customcontent_loginname</em> - der Name des aktuell angemeldeten Benutzers</p></li>
<li><p><em>customcontent_groupcount</em> - ein Z&auml;hler f&uuml;r die Anzahl der Gruppen, in denen dieser Benutzer Mitglied ist</p></li>
<li><p><em>customcontent_groups</em> - ein String, der die Gruppennamen aller Gruppen enth&auml;lt</p></li>
<li><p><em>customcontent_memberof_*</em> - eine Reihe von Variablen vom Typ Boolean, die eine Gruppenmitgliedschaft festlegt.  z. Bsp.: customcontent_memberof_personal, customcontent_memberof_user, usw.  Wenn keine Variablen f&uuml;r die Gruppen definiert wurden, bedeutet das, dass der Benutzer kein Mitglied einer der Gruppen ist.</p></li>
<li><p><em>customcontent_dayzeros</em> - Tag des Monats, 2 Zeichen mit f&uuml;hrenden Nullen</p></li> 
<li><p><em>customcontent_day3text</em> - Abk&uuml;rzung des Namens des Tages mit drei Buchstaben</p></li>
<li><p><em>customcontent_day</em> - Tag des Monats ohne f&uuml;hrende Nullen</p></li> 
<li><p><em>customcontent_weekday</em> - vollst&auml;ndige Anzeige des Wochentages</p></li> 
<li><p><em>customcontent_dayordsuffix</em> - Englisches Suffix f&uuml;r den Tag des Monats, 2 Zeichen</p></li> 
<li><p><em>customcontent_dayofweek</em> - Numerische Anzeige der Woche</p></li> 
<li><p><em>customcontent_dayofyear</em> - Tag des Jahres (beginnend mit 0)</p></li> 
<li><p><em>customcontent_weeknum</em> - Wochennummer des Jahres nach ISO-8601, Wochen beginnen mit Montag</p></li> 
<li><p><em>customcontent_monthfulltext</em> - vollst&auml;ndige Anzeige des Monatsnamens wie zum Beispiel Januar oder M&auml;rz</p></li> 
<li><p><em>customcontent_monthnumzeros</em> - Numerische Darstellung eines Monats, mit f&uuml;hrenden Nullen</p></li> 
<li><p><em>customcontent_monthshorttext</em> - Abk&uuml;rzung eines Monats, drei Buchstaben</p></li> 
<li><p><em>customcontent_monthnum</em> - Numerische Darstellung eines Monats, ohne f&uuml;hrenden Nullen</p></li> 
<li><p><em>customcontent_monthnumdays</em> - Anzahl der Tage im aktuellen Monat</p></li> 
<li><p><em>customcontent_leapyear</em> - Wenn es ein Schaltjahr ist</p></li> 
<li><p><em>customcontent_4digityear</em> - vollst&auml;ndige numerische Darstellung eines Jahres, 4 Zeichen</p></li> 
<li><p><em>customcontent_2digityear</em> - numerische Darstellung eines Jahres mit zwei Zeichen</p></li> 
<li><p><em>customcontent_lowerampm</em> - Ante meridiem und Post meridiem klein geschrieben</p></li> 
<li><p><em>customcontent_upperampm</em> - Ante meridiem und Post meridiem gross geschrieben</p></li>
<li><p><em>customcontent_inettime</em> - Swatch Internet Zeit</p></li>
<li><p><em>customcontent_12hour</em> - 12-Stunden-Format ohne f&uuml;hrende Nullen</p></li>
<li><p><em>customcontent_24hour</em> - 24-Stunden-Format ohne f&uuml;hrende Nullen</p></li>
<li><p><em>customcontent_12hourzeros</em> - 12-Stunden-Format mit f&uuml;hrenden Nullen</p></li>
<li><p><em>customcontent_24hourzeros</em> - 24-Stunden-Format mit f&uuml;hrenden Nullen</p></li>
<li><p><em>customcontent_minutes</em> - Minuten mit f&uuml;hrenden Nullen</p></li>
<li><p><em>customcontent_seconds</em> - Sekunden, mit f&uuml;hrenden Nullen</p></li>
<li><p><em>customcontent_timezone</em> - Zeitzone dieses Systems</p></li>
<li><p><em>customcontent_date</em> - nach RFC 2822 formatiertes Datum</p></li>
<li><p><em>customcontent_epochseconds</em> - Sekunden seit Beginn der Unix-Epoche (1. Januar 1970 00:00:00 GMT)</p></li>

</ul>
<h3>Copyright und Lizenz</h3>
<p>Copyright &copy; 2005, Robert Campbell <a href=&quot;mailto:rob@techcom.dyndns.org&quot;>rob@techcom.dyndns.org</a>. Alle Rechte vorbehalten.</p>
<p>Dieses Modul wurde unter der <a href=&quot;http://www.gnu.org/licenses/licenses.html#GPL&quot;>GNU Public License</a> ver&ouml;ffentlicht. Sie m&uuml;ssen dieser Lizenz zustimmen, bevor sie das Modul verwenden.</p>';
$lang['utmz'] = '156861353.1189002384.179.113.utmccn=(referral)|utmcsr=blog.cmsmadesimple.org|utmcct=/|utmcmd=referral';
$lang['utma'] = '156861353.717462736.1147511856.1193112636.1193180408.240';
?>]]></data>
	</file>
	<file>
	  <filename>/lang/ext/el_GR.php</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[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]]></data>
	</file>
	<file>
	  <filename>/lang/ext/es_ES.php</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[<?php
$lang['error_nofeusers'] = 'Error: No se pudo encontrar el modulo FrontEndUsers';
$lang['friendlyname'] = 'Modulo Custom Content';
$lang['postinstall'] = '';
$lang['postuninstall'] = '';
$lang['uninstalled'] = 'Modulo Desinstalado.';
$lang['installed'] = 'Versi&oacute;n %s del M&oacute;dulo Instalada.';
$lang['accessdenied'] = 'Acceso Denegado. Por favor, compruebe sus permisos.';
$lang['error'] = 'Error!';
$lang['upgraded'] = 'Modulo actualizado a la versi&oacute;n %s.';
$lang['moddescription'] = 'Este m&oacute;dulo provee la habilidad de especificar diferentes tipos de contenido dependiendo del grupo o usuario logueado.';
$lang['changelog'] = '<ul><li>Version 1.0. 14 September 2005. Initial Release.</li></ul>
<ul>
<li>Version 1.1.  - September 2005. Added startif/else/endif, and search through multiple groups and users.</li>
<li>Version 1.2.  - September 2005. Added loggedin optional parameter</li>
<li>Version 1.3   - October   2005. Changed to use FrontEndUsers instead of UserID</li>
<li>Version 1.3.1 - November 2005. Very minor bugfix to the parameter parsing</li>
<li>Version 1.4.0 - January, 2006.
<p>Added smarty compatible variables</p></li>
<li>Version 1.4.1 - May, 2006.
<p>Smarty variables now work in 0.13b2</p>
<p>Now require CMS 0.13b2 as a minimum</p>
<p>Updated the help</p>
</li>
<li>Version 1.4.3 - June, 2006.
<p>Added search module compatibility</p>
<p>Added date and time smarty variables</p>
</li>
<li>Version 1.4.4 - Dec, 2006.
<p>Added TemplatePrecompile callback</p>
<li>Version 1.4.5 - Mar, 2007.
<p>Removed the SearchItemAdded callback...</p>
<li>Version 1.4.6 - Apr, 2007.
<p>Added the ccuser object for easier expressions.</p>
</li>
</ul>';
$lang['help'] = '<h3>What Does This Do?</h3>
<p>This module, in conjunction with the UserID module allows you to create a page that will look different depending upon the person that looks at it.  You can specify different content for certain users, or members of a certain group.</p>
<p><b>Note 1:</b> When putting custom smarty logic into any page, you should ensure that that page will not be cached.  This is accomplished by ensuring that the &amp;quote;cachable&amp;quote; tag is cleared on the page before submitting or applying</p>
<p><b>Note 2:</b> If the smarty logic is in your template, you need to ensure that each page that uses that template is not cachable</p>
<h3>How Do I Use It (method 1: comment tags)</h3>
<p>To use it you place the tag {cms_module module=CustomContent} into your page or template, and then below that you place the content you want isolated to specific users in groups in one of two ways, either using specially formatted comment tags, or using smarty syntax.</p>
<h4>Method 1: comment tags</h4>
<pre>
{cms_module module=CustomContent}
<!--customContent: startif group=testers,admins -->
<H1>This content is only available to logged in testers and and admins</H1>
<!--customContent: else -->
<H1>This content is available to everybody else</H1>
<!--customContent: endif -->
<!--customContent: startif group=users -->
<H1>This content is only available to logged in users </H1>
<!--customContent: endif -->
</pre>
<p><b>Available parameters</b></p> 
<ul>
<li><p><em>ip</em> - test if remote ip matches a network or supplied ip address.  Valid formats are xxx.xxx.xxx.xxx (exact), xxx.xxx.xxx.[yyy-zzz] (range) and xxx.xxx.xxx/nn (nn = # bits, i.e.  192.168.1.0/24)</p></li>
<li><p><em>group</em> - test if the currently logged in user is a member of any of the supplied groups</p></li>
<li><p><em>user<em> - test if the currently logged in username matches any of the supplied ones</p></li>
<li><p><em>loggedin<em> - test if the current user is logged in or not./p></li>
</ul>
<p>Tests are evaluated in a logical OR fashion in order as follows ip address, group, and user.  The first successfull test will result in the expression evaluationg to true</p>
<h3>How Do I Use It (method 2 : smarty)</h3>
<pre>
{if $customcontent_loggedin}
  Welcome <b>{$customcontent_loginname}</b><br/>
{else}
  <h1>You are not authorized to view this data</h1>
{/if}
</pre>
<p>Or you can use the $ccuser variable for more advanced, and easier to read testing</p>
<pre>
{if $ccuser->loggedin() &amp;&amp; $ccuser->memberof(&#039;members&#039;) &amp;&amp; $ccuser->ipmatches(&#039;192.168.0.0/24&#039;)}
Welcome logged in local member
{elseif $ccuser->loggedin() &amp;&amp; $ccuser->memberof(&#039;members&#039;)}
Welcome logged in member
{elseif $ccuser->loggedin()}
Welcome user from some other group
{else}
Anonymous user
{/if}
</pre>
<p>Any smarty compatible expressions or logic can be used with the available variables.  Using this syntax, expressions may be nested, or complex logic used.</p>
<h4>Available variables:</h4>
<ul>
<li><p><em>ccuser</em> - An object with convenience functions for testing.</p>
<p>This object contains some convenience methods for performing more advanced customcontent logic, or for making your template look a little bit better. The available methods are:</p>
  <ul>
<li><em>$ccuser->groups()</em> - outputs a list of the users member groups</li>
<li><em>$ccuser->memberof(&#039;group&#039;)</em> - outputs a boolean if the user is indeed a member of this group.  This function will also accept a comma separated list of group names.</li>
<li><em>$ccuser->loggedin()</em> - outputs a boolean if the user is loggedin</li>
<li><em>$ccuser->ipmatches($ranges)</em> - outputs a boolean if the users ip address matches one of the comma separated ip ranges.  Accepts ranges like ###.###.###.###/## i.e: 192.168.0.0/24</li>
  </ul>
<br/>
</li>
<li><p><em>customcontent_ip</em> - The remote IP address</p></li>
<li><p><em>customcontent_loggedin</em> - A boolean indicating wether the user is logged in or not</p></li>
<li><p><em>customcontent_loginname</em> - The name of the currently logged in user</p></li>
<li><p><em>customcontent_groupcount</em> - A count of the number of groups this user is a member of</p></li>
<li><p><em>customcontent_groups</em> - A string containing the group names of all member groups</p></li>
<li><p><em>customcontent_memberof_*</em> - A series of boolean variables indicating group membership.  i.e.: customcontent_memberof_staff, customcontent_memberof_users, etc.  No variables are defined for groups that this user is not a member of.</p></li>
<li><p><em>customcontent_dayzeros</em> - Day of the month, 2 digits with leading zeros</p></li> 
<li><p><em>customcontent_day3text</em> - A textual representation of a day, three letters</p></li>
<li><p><em>customcontent_day</em> - Day of the month without leading zeros</p></li> 
<li><p><em>customcontent_weekday</em> - A full textual representation of the day of the week</p></li> 
<li><p><em>customcontent_dayordsuffix</em> - English ordinal suffix for the day of the month, 2 characters</p></li> 
<li><p><em>customcontent_dayofweek</em> - Numeric representation of the week</p></li> 
<li><p><em>customcontent_dayofyear</em> - The day of the year (starting from 0)</p></li> 
<li><p><em>customcontent_weeknum</em> - ISO-8601 week number of year, weeks starting on Monday</p></li> 
<li><p><em>customcontent_monthfulltext</em> - A full textual representation of a month, such as January or March</p></li> 
<li><p><em>customcontent_monthnumzeros</em> - Numeric representation of a month, with leading zeros</p></li> 
<li><p><em>customcontent_monthshorttext</em> - A short textual representation of a month, three letters</p></li> 
<li><p><em>customcontent_monthnum</em> - Numeric representation of a month, without leading zeros</p></li> 
<li><p><em>customcontent_monthnumdays</em> - Number of days in the current month</p></li> 
<li><p><em>customcontent_leapyear</em> - Wether it&#039;s a leap year</p></li> 
<li><p><em>customcontent_4digityear</em> - A full numeric representation of a year, 4 digits</p></li> 
<li><p><em>customcontent_2digityear</em> - A two digit representation of a year</p></li> 
<li><p><em>customcontent_lowerampm</em> - Lowercase Ante meridiem and Post meridiem</p></li> 
<li><p><em>customcontent_upperampm</em> - Uppercase Ante meridiem and Post meridiem</p></li>
<li><p><em>customcontent_inettime</em> - Swatch Internet time</p></li>
<li><p><em>customcontent_12hour</em> - 12-hour format of an hour without leading zeros</p></li>
<li><p><em>customcontent_24hour</em> - 24-hour format of an hour without leading zeros</p></li>
<li><p><em>customcontent_12hourzeros</em> - 12-hour format of an hour with leading zeros</p></li>
<li><p><em>customcontent_24hourzeros</em> - 24-hour format of an hour with leading zeros</p></li>
<li><p><em>customcontent_minutes</em> - Minutes with leading zeros</p></li>
<li><p><em>customcontent_seconds</em> - Seconds, with leading zeros</p></li>
<li><p><em>customcontent_timezone</em> - Timezone setting of this machine</p></li>
<li><p><em>customcontent_date</em> - RFC 2822 formatted date</p></li>
<li><p><em>customcontent_epochseconds</em> - Seconds since the Unix Epoch (January 1 1970 00:00:00 GMT)</p></li>
</ul>
<h3>Copyright and License</h3>
<p>Copyright &copy; 2005, Robert Campbell <a href=&quot;mailto:rob@techcom.dyndns.org&quot;><rob@techcom.dyndns.org></a>. All Rights Are Reserved.</p>
<p>This module has been released under the <a href=&quot;http://www.gnu.org/licenses/licenses.html#GPL&quot;>GNU Public License</a>. You must agree to this license before using the module.</p>
';
$lang['utmz'] = '156861353.1186483816.1.1.utmccn=(direct)|utmcsr=(direct)|utmcmd=(none)';
$lang['utma'] = '156861353.797627484.1186483816.1187000005.1187694850.5';
?>]]></data>
	</file>
	<file>
	  <filename>/lang/ext/fi_FI.php</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[<?php
$lang['error_nofeusers'] = 'Virhe: FrontEndUsers modulia ei l&ouml;ytynyt';
$lang['friendlyname'] = 'Custom Content moduli';
$lang['postinstall'] = '';
$lang['postuninstall'] = '';
$lang['uninstalled'] = 'Modulin asennus poistettu';
$lang['installed'] = 'Modulin versio %s asennettu.';
$lang['accessdenied'] = 'P&auml;&auml;sy kielletty. Tarkista oikeudet.';
$lang['error'] = 'Virhe!';
$lang['upgraded'] = 'Moduli p&auml;ivitetty versioon %s';
$lang['moddescription'] = 'This module provides the ability to specify different content by group or user name';
$lang['changelog'] = '<ul><li>Version 1.0. 14 September 2005. Initial Release.</li></ul>
<ul>
<li>Version 1.1.  - September 2005. Added startif/else/endif, and search through multiple groups and users.</li>
<li>Version 1.2.  - September 2005. Added loggedin optional parameter</li>
<li>Version 1.3   - October   2005. Changed to use FrontEndUsers instead of UserID</li>
<li>Version 1.3.1 - November 2005. Very minor bugfix to the parameter parsing</li>
<li>Version 1.4.0 - January, 2006.
<p>Added smarty compatible variables</p></li>
<li>Version 1.4.1 - May, 2006.
<p>Smarty variables now work in 0.13b2</p>
<p>Now require CMS 0.13b2 as a minimum</p>
<p>Updated the help</p>
</li>
<li>Version 1.4.3 - June, 2006.
<p>Added search module compatibility</p>
<p>Added date and time smarty variables</p>
</li>
<li>Version 1.4.4 - Dec, 2006.
<p>Added TemplatePrecompile callback</p>
<li>Version 1.4.5 - Mar, 2007.
<p>Removed the SearchItemAdded callback...</p>
<li>Version 1.4.6 - Apr, 2007.
<p>Added the ccuser object for easier expressions.</p>
</li>
</ul>';
$lang['help'] = '<h3>What Does This Do?</h3>
<p>This module, in conjunction with the UserID module allows you to create a page that will look different depending upon the person that looks at it.  You can specify different content for certain users, or members of a certain group.</p>
<p><b>Note 1:</b> When putting custom smarty logic into any page, you should ensure that that page will not be cached.  This is accomplished by ensuring that the &amp;quote;cachable&amp;quote; tag is cleared on the page before submitting or applying</p>
<p><b>Note 2:</b> If the smarty logic is in your template, you need to ensure that each page that uses that template is not cachable</p>
<h3>How Do I Use It (method 1: comment tags)</h3>
<p>To use it you place the tag {cms_module module=CustomContent} into your page or template, and then below that you place the content you want isolated to specific users in groups in one of two ways, either using specially formatted comment tags, or using smarty syntax.</p>
<h4>Method 1: comment tags</h4>
<pre>
{cms_module module=CustomContent}
<!--customContent: startif group=testers,admins -->
<H1>This content is only available to logged in testers and and admins</H1>
<!--customContent: else -->
<H1>This content is available to everybody else</H1>
<!--customContent: endif -->
<!--customContent: startif group=users -->
<H1>This content is only available to logged in users </H1>
<!--customContent: endif -->
</pre>
<p><b>Available parameters</b></p> 
<ul>
<li><p><em>ip</em> - test if remote ip matches a network or supplied ip address.  Valid formats are xxx.xxx.xxx.xxx (exact), xxx.xxx.xxx.[yyy-zzz] (range) and xxx.xxx.xxx/nn (nn = # bits, i.e.  192.168.1.0/24)</p></li>
<li><p><em>group</em> - test if the currently logged in user is a member of any of the supplied groups</p></li>
<li><p><em>user<em> - test if the currently logged in username matches any of the supplied ones</p></li>
<li><p><em>loggedin<em> - test if the current user is logged in or not./p></li>
</ul>
<p>Tests are evaluated in a logical OR fashion in order as follows ip address, group, and user.  The first successfull test will result in the expression evaluationg to true</p>
<h3>How Do I Use It (method 2 : smarty)</h3>
<pre>
{if $customcontent_loggedin}
  Welcome <b>{$customcontent_loginname}</b><br/>
{else}
  <h1>You are not authorized to view this data</h1>
{/if}
</pre>
<p>Or you can use the $ccuser variable for more advanced, and easier to read testing</p>
<pre>
{if $ccuser->loggedin() &amp;&amp; $ccuser->memberof(&#039;members&#039;) &amp;&amp; $ccuser->ipmatches(&#039;192.168.0.0/24&#039;)}
Welcome logged in local member
{elseif $ccuser->loggedin() &amp;&amp; $ccuser->memberof(&#039;members&#039;)}
Welcome logged in member
{elseif $ccuser->loggedin()}
Welcome user from some other group
{else}
Anonymous user
{/if}
</pre>
<p>Any smarty compatible expressions or logic can be used with the available variables.  Using this syntax, expressions may be nested, or complex logic used.</p>
<h4>Available variables:</h4>
<ul>
<li><p><em>ccuser</em> - An object with convenience functions for testing.</p>
<p>This object contains some convenience methods for performing more advanced customcontent logic, or for making your template look a little bit better. The available methods are:</p>
  <ul>
<li><em>$ccuser->groups()</em> - outputs a list of the users member groups</li>
<li><em>$ccuser->memberof(&#039;group&#039;)</em> - outputs a boolean if the user is indeed a member of this group.  This function will also accept a comma separated list of group names.</li>
<li><em>$ccuser->loggedin()</em> - outputs a boolean if the user is loggedin</li>
<li><em>$ccuser->ipmatches($ranges)</em> - outputs a boolean if the users ip address matches one of the comma separated ip ranges.  Accepts ranges like ###.###.###.###/## i.e: 192.168.0.0/24</li>
  </ul>
<br/>
</li>
<li><p><em>customcontent_ip</em> - The remote IP address</p></li>
<li><p><em>customcontent_loggedin</em> - A boolean indicating wether the user is logged in or not</p></li>
<li><p><em>customcontent_loginname</em> - The name of the currently logged in user</p></li>
<li><p><em>customcontent_groupcount</em> - A count of the number of groups this user is a member of</p></li>
<li><p><em>customcontent_groups</em> - A string containing the group names of all member groups</p></li>
<li><p><em>customcontent_memberof_*</em> - A series of boolean variables indicating group membership.  i.e.: customcontent_memberof_staff, customcontent_memberof_users, etc.  No variables are defined for groups that this user is not a member of.</p></li>
<li><p><em>customcontent_dayzeros</em> - Day of the month, 2 digits with leading zeros</p></li> 
<li><p><em>customcontent_day3text</em> - A textual representation of a day, three letters</p></li>
<li><p><em>customcontent_day</em> - Day of the month without leading zeros</p></li> 
<li><p><em>customcontent_weekday</em> - A full textual representation of the day of the week</p></li> 
<li><p><em>customcontent_dayordsuffix</em> - English ordinal suffix for the day of the month, 2 characters</p></li> 
<li><p><em>customcontent_dayofweek</em> - Numeric representation of the week</p></li> 
<li><p><em>customcontent_dayofyear</em> - The day of the year (starting from 0)</p></li> 
<li><p><em>customcontent_weeknum</em> - ISO-8601 week number of year, weeks starting on Monday</p></li> 
<li><p><em>customcontent_monthfulltext</em> - A full textual representation of a month, such as January or March</p></li> 
<li><p><em>customcontent_monthnumzeros</em> - Numeric representation of a month, with leading zeros</p></li> 
<li><p><em>customcontent_monthshorttext</em> - A short textual representation of a month, three letters</p></li> 
<li><p><em>customcontent_monthnum</em> - Numeric representation of a month, without leading zeros</p></li> 
<li><p><em>customcontent_monthnumdays</em> - Number of days in the current month</p></li> 
<li><p><em>customcontent_leapyear</em> - Wether it&#039;s a leap year</p></li> 
<li><p><em>customcontent_4digityear</em> - A full numeric representation of a year, 4 digits</p></li> 
<li><p><em>customcontent_2digityear</em> - A two digit representation of a year</p></li> 
<li><p><em>customcontent_lowerampm</em> - Lowercase Ante meridiem and Post meridiem</p></li> 
<li><p><em>customcontent_upperampm</em> - Uppercase Ante meridiem and Post meridiem</p></li>
<li><p><em>customcontent_inettime</em> - Swatch Internet time</p></li>
<li><p><em>customcontent_12hour</em> - 12-hour format of an hour without leading zeros</p></li>
<li><p><em>customcontent_24hour</em> - 24-hour format of an hour without leading zeros</p></li>
<li><p><em>customcontent_12hourzeros</em> - 12-hour format of an hour with leading zeros</p></li>
<li><p><em>customcontent_24hourzeros</em> - 24-hour format of an hour with leading zeros</p></li>
<li><p><em>customcontent_minutes</em> - Minutes with leading zeros</p></li>
<li><p><em>customcontent_seconds</em> - Seconds, with leading zeros</p></li>
<li><p><em>customcontent_timezone</em> - Timezone setting of this machine</p></li>
<li><p><em>customcontent_date</em> - RFC 2822 formatted date</p></li>
<li><p><em>customcontent_epochseconds</em> - Seconds since the Unix Epoch (January 1 1970 00:00:00 GMT)</p></li>
</ul>
<h3>Copyright and License</h3>
<p>Copyright &copy; 2005, Robert Campbell <a href=&quot;mailto:rob@techcom.dyndns.org&quot;><rob@techcom.dyndns.org></a>. All Rights Are Reserved.</p>
<p>This module has been released under the <a href=&quot;http://www.gnu.org/licenses/licenses.html#GPL&quot;>GNU Public License</a>. You must agree to this license before using the module.</p>
';
$lang['utma'] = '156861353.831998732.1171795981.1178537951.1178617317.5';
$lang['utmz'] = '156861353.1171795981.1.1.utmccn=(referral)|utmcsr=forum.cmsmadesimple.org|utmcct=/index.php|utmcmd=referral';
?>]]></data>
	</file>
	<file>
	  <filename>/lang/ext/fr_FR.php</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[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]]></data>
	</file>
	<file>
	  <filename>/lang/ext/hu_HU.php</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[<?php
$lang['error_nofeusers'] = 'Hiba: nem tal&aacute;lom a FrontEndUsers modult';
$lang['friendlyname'] = 'Egy&eacute;ni tartalom modul';
$lang['postinstall'] = '';
$lang['postuninstall'] = '';
$lang['uninstalled'] = 'A modult elt&aacute;vol&iacute;tottuk.';
$lang['installed'] = 'A(z) %s verzi&oacute;j&uacute; modul van install&aacute;lva.';
$lang['accessdenied'] = 'A hozz&aacute;f&eacute;r&eacute;s megtagadva. K&eacute;rem, ellenőrizze a jogosults&aacute;gokat.';
$lang['error'] = 'Hiba!';
$lang['upgraded'] = 'A modult friss&iacute;tett&uuml;k a(z) %s verzi&oacute;ra.';
$lang['moddescription'] = 'Ez a modul lehetőv&eacute; teszi, hogy k&uuml;l&ouml;nb&ouml;ző tartalmakat jelen&iacute;ts&uuml;nk meg k&uuml;l&ouml;nb&ouml;ző csoportoknak vagy felhaszn&aacute;l&oacute;knak';
$lang['changelog'] = '<ul><li>Version 1.0. 14 September 2005. Initial Release.</li></ul>
<ul>
<li>Version 1.1.  - September 2005. Added startif/else/endif, and search through multiple groups and users.</li>
<li>Version 1.2.  - September 2005. Added loggedin optional parameter</li>
<li>Version 1.3   - October   2005. Changed to use FrontEndUsers instead of UserID</li>
<li>Version 1.3.1 - November 2005. Very minor bugfix to the parameter parsing</li>
<li>Version 1.4.0 - January, 2006.
<p>Added smarty compatible variables</p></li>
<li>Version 1.4.1 - May, 2006.
<p>Smarty variables now work in 0.13b2</p>
<p>Now require CMS 0.13b2 as a minimum</p>
<p>Updated the help</p>
</li>
<li>Version 1.4.3 - June, 2006.
<p>Added search module compatibility</p>
<p>Added date and time smarty variables</p>
</li>
</ul>';
$lang['help'] = '<h3>What Does This Do?</h3>
<p>This module, in conjunction with the UserID module allows you to create a page that will look different depending upon the person that looks at it.  You can specify different content for certain users, or members of a certain group.</p>
<h3>How Do I Use It (method 1: comment tags)</h3>
<p>To use it you place the tag {cms_module module=CustomContent} into your page or template, and then below that you place the content you want isolated to specific users in groups in one of two ways, either using specially formatted comment tags, or using smarty syntax.</p>
<h4>Method 1: comment tags</h4>
<pre>
{cms_module module=CustomContent}
<!--customContent: startif group=testers,admins -->
<H1>This content is only available to logged in testers and and admins</H1>
<!--customContent: else -->
<H1>This content is available to everybody else</H1>
<!--customContent: endif -->
<!--customContent: startif group=users -->
<H1>This content is only available to logged in users </H1>
<!--customContent: endif -->
</pre>
<p><b>Available parameters</b></p> 
<ul>
<li><p><em>ip</em> - test if remote ip matches a network or supplied ip address.  Valid formats are xxx.xxx.xxx.xxx (exact), xxx.xxx.xxx.[yyy-zzz] (range) and xxx.xxx.xxx/nn (nn = # bits, i.e.  192.168.1.0/24)</p></li>
<li><p><em>group</em> - test if the currently logged in user is a member of any of the supplied groups</p></li>
<li><p><em>user<em> - test if the currently logged in username matches any of the supplied ones</p></li>
<li><p><em>loggedin<em> - test if the current user is logged in or not./p></li>
</ul>
<p>Tests are evaluated in a logical OR fashion in order as follows ip address, group, and user.  The first successfull test will result in the expression evaluationg to true</p>
<h3>How Do I Use It (method 2 : smarty)</h3>
<pre>
{cms_module module=CustomContent}
{if $customcontent_loggedin}
  Welcome <b>{$customcontent_loginname}</b><br/>
{/else}
  <h1>You are not authorized to view this data</h1>
{/if}
</pre>
<p>Any smarty compatible expressions or logic can be used with the available variables.  Using this syntax, expressions may be nested, or complex logic used.</p>
<h4>Available variables:</h4>
<ul>
<li><p><em>customcontent_ip</em> - The remote IP address</p></li>
<li><p><em>customcontent_loggedin</em> - A boolean indicating wether the user is logged in or not</p></li>
<li><p><em>customcontent_loginname</em> - The name of the currently logged in user</p></li>
<li><p><em>customcontent_groupcount</em> - A count of the number of groups this user is a member of</p></li>
<li><p><em>customcontent_groups</em> - A string containing the group names of all member groups</p></li>
<li><p><em>customcontent_memberof_*</em> - A series of boolean variables indicating group membership.  i.e.: customcontent_memberof_staff, customcontent_memberof_users, etc.  No variables are defined for groups that this user is not a member of.</p></li>
<li><p><em>customcontent_dayzeros</em> - Day of the month, 2 digits with leading zeros</p></li> 
<li><p><em>customcontent_day3text</em> - A textual representation of a day, three letters</p></li>
<li><p><em>customcontent_day</em> - Day of the month without leading zeros</p></li> 
<li><p><em>customcontent_weekday</em> - A full textual representation of the day of the week</p></li> 
<li><p><em>customcontent_dayordsuffix</em> - English ordinal suffix for the day of the month, 2 characters</p></li> 
<li><p><em>customcontent_dayofweek</em> - Numeric representation of the week</p></li> 
<li><p><em>customcontent_dayofyear</em> - The day of the year (starting from 0)</p></li> 
<li><p><em>customcontent_weeknum</em> - ISO-8601 week number of year, weeks starting on Monday</p></li> 
<li><p><em>customcontent_monthfulltext</em> - A full textual representation of a month, such as January or March</p></li> 
<li><p><em>customcontent_monthnumzeros</em> - Numeric representation of a month, with leading zeros</p></li> 
<li><p><em>customcontent_monthshorttext</em> - A short textual representation of a month, three letters</p></li> 
<li><p><em>customcontent_monthnum</em> - Numeric representation of a month, without leading zeros</p></li> 
<li><p><em>customcontent_monthnumdays</em> - Number of days in the current month</p></li> 
<li><p><em>customcontent_leapyear</em> - Wether it&#039;s a leap year</p></li> 
<li><p><em>customcontent_4digityear</em> - A full numeric representation of a year, 4 digits</p></li> 
<li><p><em>customcontent_2digityear</em> - A two digit representation of a year</p></li> 
<li><p><em>customcontent_lowerampm</em> - Lowercase Ante meridiem and Post meridiem</p></li> 
<li><p><em>customcontent_upperampm</em> - Uppercase Ante meridiem and Post meridiem</p></li>
<li><p><em>customcontent_inettime</em> - Swatch Internet time</p></li>
<li><p><em>customcontent_12hour</em> - 12-hour format of an hour without leading zeros</p></li>
<li><p><em>customcontent_24hour</em> - 24-hour format of an hour without leading zeros</p></li>
<li><p><em>customcontent_12hourzeros</em> - 12-hour format of an hour with leading zeros</p></li>
<li><p><em>customcontent_24hourzeros</em> - 24-hour format of an hour with leading zeros</p></li>
<li><p><em>customcontent_minutes</em> - Minutes with leading zeros</p></li>
<li><p><em>customcontent_seconds</em> - Seconds, with leading zeros</p></li>
<li><p><em>customcontent_timezone</em> - Timezone setting of this machine</p></li>
<li><p><em>customcontent_date</em> - RFC 2822 formatted date</p></li>
<li><p><em>customcontent_epochseconds</em> - Seconds since the Unix Epoch (January 1 1970 00:00:00 GMT)</p></li>
</ul>
<h3>Copyright and License</h3>
<p>Copyright &copy; 2005, Robert Campbell <a href=&quot;mailto:rob@techcom.dyndns.org&quot;><rob@techcom.dyndns.org></a>. All Rights Are Reserved.</p>
<p>This module has been released under the <a href=&quot;http://www.gnu.org/licenses/licenses.html#GPL&quot;>GNU Public License</a>. You must agree to this license before using the module.</p>
';
$lang['utma'] = '156861353.1745742775.1167462096.1181363092.1181753758.26';
$lang['utmz'] = '156861353.1176323191.18.2.utmccn=(referral)|utmcsr=forum.cmsmadesimple.org|utmcct=/index.php/topic,7004.0.html|utmcmd=referral';
$lang['utmc'] = '156861353';
?>]]></data>
	</file>
	<file>
	  <filename>/lang/ext/id_ID.php</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[<?php
$lang['friendlyname'] = 'Modul kustomisasi isi';
$lang['postinstall'] = '';
$lang['postuninstall'] = '';
$lang['uninstalled'] = 'Modul dihilangkan.';
$lang['installed'] = 'Modul versi %s terpasang.';
$lang['accessdenied'] = 'Akses ditolah. Silahkan periksa wewenang Anda.';
$lang['error'] = 'Salah!';
$lang['upgraded'] = 'Modul ditingkatkan ke versi %s.';
$lang['moddescription'] = 'Modul ini mendukung kemampuan menentukan isi yang berbeda berdasarkan grup atau nama pengguna';
$lang['changelog'] = '<ul><li>Version 1.0. 14 September 2005. Initial Release.</li></ul>
<ul>
<li>Version 1.1.  - September 2005. Added startif/else/endif, and search through multiple groups and users.</li>
<li>Version 1.2.  - September 2005. Added loggedin optional parameter</li>
<li>Version 1.3   - October   2005. Changed to use FrontEndUsers instead of UserID</li>
<li>Version 1.3.1 - November 2005. Very minor bugfix to the parameter parsing</li>
<li>Version 1.4.0 - January, 2006.
<p>Added smarty compatible variables</p></li>
<li>Version 1.4.1 - May, 2006.
<p>Smarty variables now work in 0.13b2</p>
<p>Now require CMS 0.13b2 as a minimum</p>
<p>Updated the help</p>
</li>
<li>Version 1.4.3 - June, 2006.
<p>Added search module compatibility</p>
<p>Added date and time smarty variables</p>
</li>
</ul>';
$lang['help'] = '<h3>What Does This Do?</h3>
<p>This module, in conjunction with the UserID module allows you to create a page that will look different depending upon the person that looks at it.  You can specify different content for certain users, or members of a certain group.</p>
<h3>How Do I Use It (method 1: comment tags)</h3>
<p>To use it you place the tag {cms_module module=CustomContent} into your page or template, and then below that you place the content you want isolated to specific users in groups in one of two ways, either using specially formatted comment tags, or using smarty syntax.</p>
<h4>Method 1: comment tags</h4>
<pre>
{cms_module module=CustomContent}
<!--customContent: startif group=testers,admins -->
<H1>This content is only available to logged in testers and and admins</H1>
<!--customContent: else -->
<H1>This content is available to everybody else</H1>
<!--customContent: endif -->
<!--customContent: startif group=users -->
<H1>This content is only available to logged in users </H1>
<!--customContent: endif -->
</pre>
<p><b>Available parameters</b></p> 
<ul>
<li><p><em>ip</em> - test if remote ip matches a network or supplied ip address.  Valid formats are xxx.xxx.xxx.xxx (exact), xxx.xxx.xxx.[yyy-zzz] (range) and xxx.xxx.xxx/nn (nn = # bits, i.e.  192.168.1.0/24)</p></li>
<li><p><em>group</em> - test if the currently logged in user is a member of any of the supplied groups</p></li>
<li><p><em>user<em> - test if the currently logged in username matches any of the supplied ones</p></li>
<li><p><em>loggedin<em> - test if the current user is logged in or not./p></li>
</ul>
<p>Tests are evaluated in a logical OR fashion in order as follows ip address, group, and user.  The first successfull test will result in the expression evaluationg to true</p>
<h3>How Do I Use It (method 2 : smarty)</h3>
<pre>
{cms_module module=CustomContent}
{if $customcontent_loggedin}
  Welcome <b>{$customcontent_loginname}</b><br/>
{/else}
  <h1>You are not authorized to view this data</h1>
{/if}
</pre>
<p>Any smarty compatible expressions or logic can be used with the available variables.  Using this syntax, expressions may be nested, or complex logic used.</p>
<h4>Available variables:</h4>
<ul>
<li><p><em>customcontent_ip</em> - The remote IP address</p></li>
<li><p><em>customcontent_loggedin</em> - A boolean indicating wether the user is logged in or not</p></li>
<li><p><em>customcontent_loginname</em> - The name of the currently logged in user</p></li>
<li><p><em>customcontent_groupcount</em> - A count of the number of groups this user is a member of</p></li>
<li><p><em>customcontent_groups</em> - A string containing the group names of all member groups</p></li>
<li><p><em>customcontent_memberof_*</em> - A series of boolean variables indicating group membership.  i.e.: customcontent_memberof_staff, customcontent_memberof_users, etc.  No variables are defined for groups that this user is not a member of.</p></li>
<li><p><em>customcontent_dayzeros</em> - Day of the month, 2 digits with leading zeros</p></li> 
<li><p><em>customcontent_day3text</em> - A textual representation of a day, three letters</p></li>
<li><p><em>customcontent_day</em> - Day of the month without leading zeros</p></li> 
<li><p><em>customcontent_weekday</em> - A full textual representation of the day of the week</p></li> 
<li><p><em>customcontent_dayordsuffix</em> - English ordinal suffix for the day of the month, 2 characters</p></li> 
<li><p><em>customcontent_dayofweek</em> - Numeric representation of the week</p></li> 
<li><p><em>customcontent_dayofyear</em> - The day of the year (starting from 0)</p></li> 
<li><p><em>customcontent_weeknum</em> - ISO-8601 week number of year, weeks starting on Monday</p></li> 
<li><p><em>customcontent_monthfulltext</em> - A full textual representation of a month, such as January or March</p></li> 
<li><p><em>customcontent_monthnumzeros</em> - Numeric representation of a month, with leading zeros</p></li> 
<li><p><em>customcontent_monthshorttext</em> - A short textual representation of a month, three letters</p></li> 
<li><p><em>customcontent_monthnum</em> - Numeric representation of a month, without leading zeros</p></li> 
<li><p><em>customcontent_monthnumdays</em> - Number of days in the current month</p></li> 
<li><p><em>customcontent_leapyear</em> - Wether it&#039;s a leap year</p></li> 
<li><p><em>customcontent_4digityear</em> - A full numeric representation of a year, 4 digits</p></li> 
<li><p><em>customcontent_2digityear</em> - A two digit representation of a year</p></li> 
<li><p><em>customcontent_lowerampm</em> - Lowercase Ante meridiem and Post meridiem</p></li> 
<li><p><em>customcontent_upperampm</em> - Uppercase Ante meridiem and Post meridiem</p></li>
<li><p><em>customcontent_inettime</em> - Swatch Internet time</p></li>
<li><p><em>customcontent_12hour</em> - 12-hour format of an hour without leading zeros</p></li>
<li><p><em>customcontent_24hour</em> - 24-hour format of an hour without leading zeros</p></li>
<li><p><em>customcontent_12hourzeros</em> - 12-hour format of an hour with leading zeros</p></li>
<li><p><em>customcontent_24hourzeros</em> - 24-hour format of an hour with leading zeros</p></li>
<li><p><em>customcontent_minutes</em> - Minutes with leading zeros</p></li>
<li><p><em>customcontent_seconds</em> - Seconds, with leading zeros</p></li>
<li><p><em>customcontent_timezone</em> - Timezone setting of this machine</p></li>
<li><p><em>customcontent_date</em> - RFC 2822 formatted date</p></li>
<li><p><em>customcontent_epochseconds</em> - Seconds since the Unix Epoch (January 1 1970 00:00:00 GMT)</p></li>
</ul>
<h3>Copyright and License</h3>
<p>Copyright &copy; 2005, Robert Campbell <a href=&quot;mailto:rob@techcom.dyndns.org&quot;><rob@techcom.dyndns.org></a>. All Rights Are Reserved.</p>
<p>This module has been released under the <a href=&quot;http://www.gnu.org/licenses/licenses.html#GPL&quot;>GNU Public License</a>. You must agree to this license before using the module.</p>
';
$lang['utma'] = '156861353.352737611.1150885584.1154340251.1154414077.7';
$lang['utmz'] = '156861353.1154340251.6.6.utmccn=(referral)|utmcsr=dev.cmsmadesimple.org|utmcct=/my/diary.php|utmcmd=referral';
$lang['utmc'] = '156861353';
?>]]></data>
	</file>
	<file>
	  <filename>/lang/ext/it_IT.php</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[<?php
$lang['error_nofeusers'] = 'Errore: Non trovo il modulo FrontEndUsers';
$lang['friendlyname'] = 'Modulo Custom Content';
$lang['postinstall'] = '';
$lang['postuninstall'] = '';
$lang['uninstalled'] = 'Modulo disinstallato.';
$lang['installed'] = 'Versione del modulo %s installata.';
$lang['accessdenied'] = 'Accesso negato. Si prega di controllare i permessi.';
$lang['error'] = 'Errore!';
$lang['upgraded'] = 'Modulo aggiornato alla versione %s.';
$lang['moddescription'] = 'Questo modulo provvede l&#039;abilit&agrave; di specificare contenuto differente per gruppo o nome utente';
$lang['changelog'] = '<ul><li>Version 1.0. 14 September 2005. Initial Release.</li></ul>
<ul>
<li>Version 1.1.  - September 2005. Added startif/else/endif, and search through multiple groups and users.</li>
<li>Version 1.2.  - September 2005. Added loggedin optional parameter</li>
<li>Version 1.3   - October   2005. Changed to use FrontEndUsers instead of UserID</li>
<li>Version 1.3.1 - November 2005. Very minor bugfix to the parameter parsing</li>
<li>Version 1.4.0 - January, 2006.
<p>Added smarty compatible variables</p></li>
<li>Version 1.4.1 - May, 2006.
<p>Smarty variables now work in 0.13b2</p>
<p>Now require CMS 0.13b2 as a minimum</p>
<p>Updated the help</p>
</li>
<li>Version 1.4.3 - June, 2006.
<p>Added search module compatibility</p>
<p>Added date and time smarty variables</p>
</li>
<li>Version 1.4.4 - Dec, 2006.
<p>Added TemplatePrecompile callback</p>
<li>Version 1.4.5 - Mar, 2007.
<p>Removed the SearchItemAdded callback...</p>
<li>Version 1.4.6 - Apr, 2007.
<p>Added the ccuser object for easier expressions.</p>
<li>Version 1.4.7 - Sep, 2007.
<p>Adjusted the help, the comment syntax is now deprecated</p>
<p>Added a property method to the ccuser object</p>
</li>
<li>Version 1.4.8 - Sep, 2007.
<p>Added the module_exists method to the ccuser object</p>
</li>
</ul>';
$lang['help'] = '<h3>Che cosa fa?</h3>
<p>Questo modulo assieme al modulo UserID permette di creare una pagina che viene visualizzata differentemente a seconda della persona. Potete specificare un differente contenuto per utente o per membri di un certo gruppo.</p>
<p><b>Nota 1:</b> Quando mettete la sintassi smarty in ogni pagina, dovreste assicurarvi che le pagine non siano cached. Questo &egrave; effettuato assicurandosi che il campo &quot;cachable&quot; &egrave; vuoto</p>
<p><b>Note 2:</b>Se la sintassi smarty &egrave; nel Modello, dovete assicurarvi che ciascuna pagina che usa il Modello non &egrave; cachable</p>
<h3>Come usarlo</h3>
<h4>Metodo 1: sintassi smarty</h4>
<pre>
{if $customcontent_loggedin}
  Benvenuto <b>{$customcontent_loginname}</b><br />
{else}
  <h1>Non siete autorizzato a visualizzare questi dati</h1>
{/if}
</pre>
<p>O potete utilizzare la variabile $ccuser per un uso pi&ugrave; avanzato e di pi&ugrave; facile lettura e testing</p>
<pre>
{if $ccuser->loggedin() &amp;&amp; $ccuser->memberof(&#039;members&#039;) &amp;&amp; $ccuser->ipmatches(&#039;192.168.0.0/24&#039;)}
Benvenuto nei membri locali
{elseif $ccuser->loggedin() &amp;&amp; $ccuser->memberof(&#039;members&#039;)}
Benvenuto nei membri
{elseif $ccuser->loggedin()}
Benvenuto utente di altri gruppi
{else}
Utente anonimo
{/if}
</pre>
<p>Qualsiasi espressione o logica di smarty pu&ograve; essere usata con le variabili utilizzabili. Usando questa sintassi, si useranno espressioni inserite uno dentro l&#039;altra o si user&agrave; una logica complessa.</p>
<p><b>Variabili utilizzabili:</b></p>
<ul>
<li><p><em>ccuser</em> - An object with convenience functions for testing.</p>
<p>This object contains some convenience methods for performing more advanced customcontent logic, or for making your template look a little bit better. The available methods are:</p>
  <ul>
<li><em>$ccuser->groups()</em> - outputs a list of the users member groups</li>
<li><em>$ccuser->memberof(&#039;group&#039;)</em> - outputs a boolean if the user is indeed a member of this group.  This function will also accept a comma separated list of group names.</li>
<li><em>$ccuser->loggedin()</em> - outputs a boolean if the user is loggedin</li>
<li><em>$ccuser->property(&#039;propertyname&#039;)</em> - outputs the value of the property for the currently logged in user.</li>
<li><em>$ccuser->module_installed(&#039;modulename&#039;)</em> - outputs a boolean if the specified module is installed and available.</li>
<li><em>$ccuser->ipmatches($ranges)</em> - outputs a boolean if the users ip address matches one of the comma separated ip ranges.  Accepts ranges like ###.###.###.###/## i.e: 192.168.0.0/24</li>
  </ul>
<br/>
</li>
<li><p><em>customcontent_ip</em> - L&#039;indirizzo IP remoto</p></li>
<li><p><em>customcontent_loggedin</em> - Un valore booleano (true/false) che indica se l&#039;utente &egrave; autenticato o meno</p></li>
<li><p><em>customcontent_loginname</em> - Il nome del corrente utente autenticato</p></li>
<li><p><em>customcontent_groupcount</em> - Un contatore del numero di gruppi a cui appartiene questo utente</p></li>
<li><p><em>customcontent_groups</em> - Una stringa contenente il nome di tutti i gruppi</p></li>
<li><p><em>customcontent_memberof_*</em> - Una serie di valori booleani indicanti l&#039;appartenenza al gruppo. p.e.: customcontent_memberof_staff, customcontent_memberof_users, etc. Nessuna variabile &egrave; definita per i gruppi a cui non appartiene l&#039;utente.</p></li>
<li><p><em>customcontent_dayzeros</em> - Day of the month, 2 digits with leading zeros</p></li>
<li><p><em>customcontent_day3text</em> - A textual representation of a day, three letters</p></li>
<li><p><em>customcontent_day</em> - Day of the month without leading zeros</p></li>
<li><p><em>customcontent_weekday</em> - A full textual representation of the day of the week</p></li>
<li><p><em>customcontent_dayordsuffix</em> - English ordinal suffix for the day of the month, 2 characters</p></li>
<li><p><em>customcontent_dayofweek</em> - Numeric representation of the week</p></li>
<li><p><em>customcontent_dayofyear</em> - The day of the year (starting from 0)</p></li>
<li><p><em>customcontent_weeknum</em> - ISO-8601 week number of year, weeks starting on Monday</p></li>
<li><p><em>customcontent_monthfulltext</em> - A full textual representation of a month, such as January or March</p></li>
<li><p><em>customcontent_monthnumzeros</em> - Numeric representation of a month, with leading zeros</p></li>
<li><p><em>customcontent_monthshorttext</em> - A short textual representation of a month, three letters</p></li>
<li><p><em>customcontent_monthnum</em> - Numeric representation of a month, without leading zeros</p></li>
<li><p><em>customcontent_monthnumdays</em> - Number of days in the current month</p></li>
<li><p><em>customcontent_leapyear</em> - Wether it&#039;s a leap year</p></li>
<li><p><em>customcontent_4digityear</em> - A full numeric representation of a year, 4 digits</p></li>
<li><p><em>customcontent_2digityear</em> - A two digit representation of a year</p></li>
<li><p><em>customcontent_lowerampm</em> - Lowercase Ante meridiem and Post meridiem</p></li>
<li><p><em>customcontent_upperampm</em> - Uppercase Ante meridiem and Post meridiem</p></li>
<li><p><em>customcontent_inettime</em> - Swatch Internet time</p></li>
<li><p><em>customcontent_12hour</em> - 12-hour format of an hour without leading zeros</p></li>
<li><p><em>customcontent_24hour</em> - 24-hour format of an hour without leading zeros</p></li>
<li><p><em>customcontent_12hourzeros</em> - 12-hour format of an hour with leading zeros</p></li>
<li><p><em>customcontent_24hourzeros</em> - 24-hour format of an hour with leading zeros</p></li>
<li><p><em>customcontent_minutes</em> - Minutes with leading zeros</p></li>
<li><p><em>customcontent_seconds</em> - Seconds, with leading zeros</p></li>
<li><p><em>customcontent_timezone</em> - Timezone setting of this machine</p></li>
<li><p><em>customcontent_date</em> - RFC 2822 formatted date</p></li>
<li><p><em>customcontent_epochseconds</em> - Seconds since the Unix Epoch (January 1 1970 00:00:00 GMT)</p></li>
</ul>
<h4>Metodo 2: tag commento <em>(deprecato)</em></h4>
<pre>
{cms_module module=CustomContent}
<!--customContent: startif group=testers,admins -->
<H1>Questo contenuto &egrave; utilizzabile solo dagli utenti connessi come facenti parte del gruppo testers o admins</H1>
<!--customContent: else -->
<H1>Questo contenuto &egrave; utilizzabile da chiunque altro</H1>
<!--customContent: endif -->
<!--customContent: startif group=users -->
<H1>Questo contenuto &egrave; utilizzabile solo dagli utenti del gruppo users</H1>
<!--customContent: endif -->
</pre>
<p><b>Parametri utilizzabili</b></p>
<ul>
<li><p><em>ip</em> - testa se l&#039;IP remoto &egrave; abbinato al network o all&#039;IP fornito. Formati validi sono xxx.xxx.xxx.xxx (esatto), xxx.xxx.xxx.[yyy-zzz](intervallo) e xxx.xxx.xxx/nn (nn = # bits, p.e. 192.168.1.0/24)</p></li>
<li><p><em>group</em> - testa se il corrente utente autenticato &egrave; un membro del/dei gruppi forniti</p></li>
<li><p><em>user<em> - testa se il corrente utente autenticato &egrave; abbinato a/ai utenti forniti</p></li>
<li><p><em>loggedin<em> - testa se il corrente utente &egrave; autenticato o meno./p></li>
</ul>
<p>I test sono valutati in una logica di tipo OR nel seguente ordine: indirizzo ip, gruppo e utente. Il primo test che ha successo verr&agrave; eseguito</p>
<h3>Copyright e licenza</h3>
<p>Copyright &copy; 2005, Robert Campbell <a href=&quot;mailto:calguy1000@hotmail.com&quot;><calguy1000@hotmail.com></a>. Tutti i diritti sono riservati.</p>
<p>Questo modulo &egrave; stato rilasciato sotto la <a href=&quot;http://www.gnu.org/licenses/licenses.html#GPL&quot;>GNU Public License</a>. Devi aderire a questa licenza prima di usare il modulo.</p>';
$lang['utmz'] = '156861353.1189603002.11.11.utmccn=(referral)|utmcsr=onecms.it|utmcct=/07/09/2007/cmsmadesimple-siti-dinamici-senza-database/|utmcmd=referral';
$lang['utma'] = '156861353.916584110.1152549583.1191339025.1191396648.66';
$lang['utmb'] = '156861353';
$lang['utmc'] = '156861353';
?>]]></data>
	</file>
	<file>
	  <filename>/lang/ext/lt_LT.php</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[<?php
$lang['friendlyname'] = 'Custom Content Module';
$lang['postinstall'] = '';
$lang['postuninstall'] = '';
$lang['uninstalled'] = 'Modulis pa&scaron;alintas.';
$lang['installed'] = 'Įdiegta modulio %s versija.';
$lang['accessdenied'] = 'Priėjimas uždraustas. Patikrinkite leidimus.';
$lang['error'] = 'Klaida!';
$lang['upgraded'] = 'Modulis atnaujintas į versiją %s.';
$lang['moddescription'] = '&Scaron;is modulis leidžia pateikti skirtingą turinį priklausomai nuo vartotojo grupės ar prisijungimo vardo.';
$lang['changelog'] = '<ul><li>Version 1.0. 14 September 2005. Initial Release.</li></ul>
<ul>
<li>Version 1.1.  - September 2005. Added startif/else/endif, and search through multiple groups and users.</li>
<li>Version 1.2.  - September 2005. Added loggedin optional parameter</li>
<li>Version 1.3   - October   2005. Changed to use FrontEndUsers instead of UserID</li>
<li>Version 1.3.1 - November 2005. Very minor bugfix to the parameter parsing</li>
<li>Version 1.4.0 - January, 2006.
<p>Added smarty compatible variables</p></li>
<li>Version 1.4.1 - May, 2006.
<p>Smarty variables now work in 0.13b2</p>
<p>Now require CMS 0.13b2 as a minimum</p>
<p>Updated the help</p>
</li>
<li>Version 1.4.3 - June, 2006.
<p>Added search module compatibility</p>
<p>Added date and time smarty variables</p>
</li>
</ul>';
$lang['help'] = '<h3>What Does This Do?</h3>
<p>This module, in conjunction with the UserID module allows you to create a page that will look different depending upon the person that looks at it.  You can specify different content for certain users, or members of a certain group.</p>
<h3>How Do I Use It (method 1: comment tags)</h3>
<p>To use it you place the tag {cms_module module=CustomContent} into your page or template, and then below that you place the content you want isolated to specific users in groups in one of two ways, either using specially formatted comment tags, or using smarty syntax.</p>
<h4>Method 1: comment tags</h4>
<pre>
{cms_module module=CustomContent}
<!--customContent: startif group=testers,admins -->
<H1>This content is only available to logged in testers and and admins</H1>
<!--customContent: else -->
<H1>This content is available to everybody else</H1>
<!--customContent: endif -->
<!--customContent: startif group=users -->
<H1>This content is only available to logged in users </H1>
<!--customContent: endif -->
</pre>
<p><b>Available parameters</b></p> 
<ul>
<li><p><em>ip</em> - test if remote ip matches a network or supplied ip address.  Valid formats are xxx.xxx.xxx.xxx (exact), xxx.xxx.xxx.[yyy-zzz] (range) and xxx.xxx.xxx/nn (nn = # bits, i.e.  192.168.1.0/24)</p></li>
<li><p><em>group</em> - test if the currently logged in user is a member of any of the supplied groups</p></li>
<li><p><em>user<em> - test if the currently logged in username matches any of the supplied ones</p></li>
<li><p><em>loggedin<em> - test if the current user is logged in or not./p></li>
</ul>
<p>Tests are evaluated in a logical OR fashion in order as follows ip address, group, and user.  The first successfull test will result in the expression evaluationg to true</p>
<h3>How Do I Use It (method 2 : smarty)</h3>
<pre>
{cms_module module=CustomContent}
{if $customcontent_loggedin}
  Welcome <b>{$customcontent_loginname}</b><br/>
{/else}
  <h1>You are not authorized to view this data</h1>
{/if}
</pre>
<p>Any smarty compatible expressions or logic can be used with the available variables.  Using this syntax, expressions may be nested, or complex logic used.</p>
<h4>Available variables:</h4>
<ul>
<li><p><em>customcontent_ip</em> - The remote IP address</p></li>
<li><p><em>customcontent_loggedin</em> - A boolean indicating wether the user is logged in or not</p></li>
<li><p><em>customcontent_loginname</em> - The name of the currently logged in user</p></li>
<li><p><em>customcontent_groupcount</em> - A count of the number of groups this user is a member of</p></li>
<li><p><em>customcontent_groups</em> - A string containing the group names of all member groups</p></li>
<li><p><em>customcontent_memberof_*</em> - A series of boolean variables indicating group membership.  i.e.: customcontent_memberof_staff, customcontent_memberof_users, etc.  No variables are defined for groups that this user is not a member of.</p></li>
<li><p><em>customcontent_dayzeros</em> - Day of the month, 2 digits with leading zeros</p></li> 
<li><p><em>customcontent_day3text</em> - A textual representation of a day, three letters</p></li>
<li><p><em>customcontent_day</em> - Day of the month without leading zeros</p></li> 
<li><p><em>customcontent_weekday</em> - A full textual representation of the day of the week</p></li> 
<li><p><em>customcontent_dayordsuffix</em> - English ordinal suffix for the day of the month, 2 characters</p></li> 
<li><p><em>customcontent_dayofweek</em> - Numeric representation of the week</p></li> 
<li><p><em>customcontent_dayofyear</em> - The day of the year (starting from 0)</p></li> 
<li><p><em>customcontent_weeknum</em> - ISO-8601 week number of year, weeks starting on Monday</p></li> 
<li><p><em>customcontent_monthfulltext</em> - A full textual representation of a month, such as January or March</p></li> 
<li><p><em>customcontent_monthnumzeros</em> - Numeric representation of a month, with leading zeros</p></li> 
<li><p><em>customcontent_monthshorttext</em> - A short textual representation of a month, three letters</p></li> 
<li><p><em>customcontent_monthnum</em> - Numeric representation of a month, without leading zeros</p></li> 
<li><p><em>customcontent_monthnumdays</em> - Number of days in the current month</p></li> 
<li><p><em>customcontent_leapyear</em> - Wether it&#039;s a leap year</p></li> 
<li><p><em>customcontent_4digityear</em> - A full numeric representation of a year, 4 digits</p></li> 
<li><p><em>customcontent_2digityear</em> - A two digit representation of a year</p></li> 
<li><p><em>customcontent_lowerampm</em> - Lowercase Ante meridiem and Post meridiem</p></li> 
<li><p><em>customcontent_upperampm</em> - Uppercase Ante meridiem and Post meridiem</p></li>
<li><p><em>customcontent_inettime</em> - Swatch Internet time</p></li>
<li><p><em>customcontent_12hour</em> - 12-hour format of an hour without leading zeros</p></li>
<li><p><em>customcontent_24hour</em> - 24-hour format of an hour without leading zeros</p></li>
<li><p><em>customcontent_12hourzeros</em> - 12-hour format of an hour with leading zeros</p></li>
<li><p><em>customcontent_24hourzeros</em> - 24-hour format of an hour with leading zeros</p></li>
<li><p><em>customcontent_minutes</em> - Minutes with leading zeros</p></li>
<li><p><em>customcontent_seconds</em> - Seconds, with leading zeros</p></li>
<li><p><em>customcontent_timezone</em> - Timezone setting of this machine</p></li>
<li><p><em>customcontent_date</em> - RFC 2822 formatted date</p></li>
<li><p><em>customcontent_epochseconds</em> - Seconds since the Unix Epoch (January 1 1970 00:00:00 GMT)</p></li>
</ul>
<h3>Copyright and License</h3>
<p>Copyright &copy; 2005, Robert Campbell <a href=&amp;quot;mailto:rob@techcom.dyndns.org&amp;quot;><rob@techcom.dyndns.org></a>. All Rights Are Reserved.</p>
<p>This module has been released under the <a href=&amp;quot;http://www.gnu.org/licenses/licenses.html#GPL&amp;quot;>GNU Public License</a>. You must agree to this license before using the module.</p>
';
$lang['utma'] = '156861353.1667578347.1160465531.1160725442.1160733132.9';
$lang['utmz'] = '156861353.1160465531.1.1.utmccn=(direct)|utmcsr=(direct)|utmcmd=(none)';
$lang['utmb'] = '156861353';
$lang['utmc'] = '156861353';
?>]]></data>
	</file>
	<file>
	  <filename>/lang/ext/nb_NO.php</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[<?php
$lang['error_nofeusers'] = 'Feil: Kunne ikke finne FrontEndUser modulen';
$lang['friendlyname'] = 'Custom Content Modul';
$lang['postinstall'] = ' ';
$lang['postuninstall'] = ' ';
$lang['uninstalled'] = 'Modulen er ikke installert.';
$lang['installed'] = 'Modul versjon %s er installert.';
$lang['accessdenied'] = 'Tilgang avsl&aring;tt. Sjekk din status for tilgang.';
$lang['error'] = 'Feil!';
$lang['upgraded'] = 'Modulen er oppgradert til versjon %s.';
$lang['moddescription'] = 'Denne modulen gir mulighet for &aring; vise forskjellig innhold til forskjellige brukergrupper eller brukernavn.';
$lang['changelog'] = '<ul><li>Version 1.0. 14 September 2005. Initial Release.</li></ul>
<ul>
<li>Version 1.1.  - September 2005. Added startif/else/endif, and search through multiple groups and users.</li>
<li>Version 1.2.  - September 2005. Added loggedin optional parameter</li>
<li>Version 1.3   - October   2005. Changed to use FrontEndUsers instead of UserID</li>
<li>Version 1.3.1 - November 2005. Very minor bugfix to the parameter parsing</li>
<li>Version 1.4.0 - January, 2006.
<p>Added smarty compatible variables</p></li>
<li>Version 1.4.1 - May, 2006.
<p>Smarty variables now work in 0.13b2</p>
<p>Now require CMS 0.13b2 as a minimum</p>
<p>Updated the help</p>
</li>
<li>Version 1.4.3 - June, 2006.
<p>Added search module compatibility</p>
<p>Added date and time smarty variables</p>
</li>
<li>Version 1.4.4 - Dec, 2006.
<p>Added TemplatePrecompile callback</p>
<li>Version 1.4.5 - Mar, 2007.
<p>Removed the SearchItemAdded callback...</p>
<li>Version 1.4.6 - Apr, 2007.
<p>Added the ccuser object for easier expressions.</p>
<li>Version 1.4.7 - Sep, 2007.
<p>Adjusted the help, the comment syntax is now deprecated</p>
<p>Added a property method to the ccuser object</p>
</li>
<li>Version 1.4.8 - Sep, 2007.
<p>Added the module_exists method to the ccuser object</p>
</li>
<li>Version 1.4.9 - Oct. 2007.
<p>Some minor fixes that seem to fix problems where FEU would get instantiated twice</p>
<p>Fixes an issue in the memberof() method of ccuser when not logged in</p>
</li>
</ul>';
$lang['help'] = '<h3>What Does This Do?</h3>
<p>This module, in conjunction with the UserID module allows you to create a page that will look different depending upon the person that looks at it.  You can specify different content for certain users, or members of a certain group.</p>
<p><b>Note 1:</b> When putting custom smarty logic into any page, you should ensure that that page will not be cached.  This is accomplished by ensuring that the &amp;quote;cachable&amp;quote; tag is cleared on the page before submitting or applying</p>
<p><b>Note 2:</b> If the smarty logic is in your template, you need to ensure that each page that uses that template is not cachable</p>
<h3>How Do I Use It</h3>
<h4>Method 1 : smarty</h4>
<pre>
{if $customcontent_loggedin}
  Welcome &amp;lt;b&amp;gt;{$customcontent_loginname}&amp;lt;/b&amp;gt;&amp;lt;br/&amp;gt;
{else}
  &amp;lt;h1&amp;gt;You are not authorized to view this data&amp;lt;/h1&amp;gt;
{/if}
</pre>
<p>Or you can use the $ccuser variable for more advanced, and easier to read testing</p>
<pre>
{if $ccuser->loggedin() &amp;&amp; $ccuser->memberof(&#039;members&#039;) &amp;&amp; $ccuser->ipmatches(&#039;192.168.0.0/24&#039;)}
Welcome logged in local member
{elseif $ccuser->loggedin() &amp;&amp; $ccuser->memberof(&#039;members&#039;)}
Welcome logged in member
{elseif $ccuser->loggedin()}
Welcome user from some other group
{else}
Anonymous user
{/if}
</pre>
<p>Any smarty compatible expressions or logic can be used with the available variables.  Using this syntax, expressions may be nested, or complex logic used.</p>
<h4>Available variables:</h4>
<ul>
<li><p><em>ccuser</em> - An object with convenience functions for testing.</p>
<p>This object contains some convenience methods for performing more advanced customcontent logic, or for making your template look a little bit better. The available methods are:</p>
  <ul>
<li><em>$ccuser->groups()</em> - outputs a list of the users member groups</li>
<li><em>$ccuser->memberof(&#039;group&#039;)</em> - outputs a boolean if the user is indeed a member of this group.  This function will also accept a comma separated list of group names.</li>
<li><em>$ccuser->loggedin()</em> - outputs a boolean if the user is loggedin</li>
<li><em>$ccuser->property(&#039;propertyname&#039;)</em> - outputs the value of the property for the currently logged in user.</li>
<li><em>$ccuser->module_installed(&#039;modulename&#039;)</em> - outputs a boolean if the specified module is installed and available.</li>
<li><em>$ccuser->ipmatches($ranges)</em> - outputs a boolean if the users ip address matches one of the comma separated ip ranges.  Accepts ranges like ###.###.###.###/## i.e: 192.168.0.0/24</li>
  </ul>
<br/>
</li>
<li><p><em>customcontent_ip</em> - The remote IP address</p></li>
<li><p><em>customcontent_loggedin</em> - A boolean indicating wether the user is logged in or not</p></li>
<li><p><em>customcontent_loginname</em> - The name of the currently logged in user</p></li>
<li><p><em>customcontent_groupcount</em> - A count of the number of groups this user is a member of</p></li>
<li><p><em>customcontent_groups</em> - A string containing the group names of all member groups</p></li>
<li><p><em>customcontent_memberof_*</em> - A series of boolean variables indicating group membership.  i.e.: customcontent_memberof_staff, customcontent_memberof_users, etc.  No variables are defined for groups that this user is not a member of.</p></li>
<li><p><em>customcontent_dayzeros</em> - Day of the month, 2 digits with leading zeros</p></li> 
<li><p><em>customcontent_day3text</em> - A textual representation of a day, three letters</p></li>
<li><p><em>customcontent_day</em> - Day of the month without leading zeros</p></li> 
<li><p><em>customcontent_weekday</em> - A full textual representation of the day of the week</p></li> 
<li><p><em>customcontent_dayordsuffix</em> - English ordinal suffix for the day of the month, 2 characters</p></li> 
<li><p><em>customcontent_dayofweek</em> - Numeric representation of the week</p></li> 
<li><p><em>customcontent_dayofyear</em> - The day of the year (starting from 0)</p></li> 
<li><p><em>customcontent_weeknum</em> - ISO-8601 week number of year, weeks starting on Monday</p></li> 
<li><p><em>customcontent_monthfulltext</em> - A full textual representation of a month, such as January or March</p></li> 
<li><p><em>customcontent_monthnumzeros</em> - Numeric representation of a month, with leading zeros</p></li> 
<li><p><em>customcontent_monthshorttext</em> - A short textual representation of a month, three letters</p></li> 
<li><p><em>customcontent_monthnum</em> - Numeric representation of a month, without leading zeros</p></li> 
<li><p><em>customcontent_monthnumdays</em> - Number of days in the current month</p></li> 
<li><p><em>customcontent_leapyear</em> - Wether it&#039;s a leap year</p></li> 
<li><p><em>customcontent_4digityear</em> - A full numeric representation of a year, 4 digits</p></li> 
<li><p><em>customcontent_2digityear</em> - A two digit representation of a year</p></li> 
<li><p><em>customcontent_lowerampm</em> - Lowercase Ante meridiem and Post meridiem</p></li> 
<li><p><em>customcontent_upperampm</em> - Uppercase Ante meridiem and Post meridiem</p></li>
<li><p><em>customcontent_inettime</em> - Swatch Internet time</p></li>
<li><p><em>customcontent_12hour</em> - 12-hour format of an hour without leading zeros</p></li>
<li><p><em>customcontent_24hour</em> - 24-hour format of an hour without leading zeros</p></li>
<li><p><em>customcontent_12hourzeros</em> - 12-hour format of an hour with leading zeros</p></li>
<li><p><em>customcontent_24hourzeros</em> - 24-hour format of an hour with leading zeros</p></li>
<li><p><em>customcontent_minutes</em> - Minutes with leading zeros</p></li>
<li><p><em>customcontent_seconds</em> - Seconds, with leading zeros</p></li>
<li><p><em>customcontent_timezone</em> - Timezone setting of this machine</p></li>
<li><p><em>customcontent_date</em> - RFC 2822 formatted date</p></li>
<li><p><em>customcontent_epochseconds</em> - Seconds since the Unix Epoch (January 1 1970 00:00:00 GMT)</p></li>
</ul>
<h4>Method 2: comment tags <em>(deprecated)</em></h3>
<p>To use it you place the tag {cms_module module=CustomContent} into your page or template, and then below that you place the content you want isolated to specific users in groups in one of two ways, either using specially formatted comment tags, or using smarty syntax.</p>
<pre>
{cms_module module=CustomContent}
&amp;lt;!--customContent: startif group=testers,admins --&amp;gt;
&amp;lt;H1&amp;gt;This content is only available to logged in testers and and admins&amp;lt;/H1&amp;gt;
&amp;lt;!--customContent: else --&amp;gt;
&amp;lt;H1&amp;gt;This content is available to everybody else&amp;lt;/H1&amp;gt;
&amp;lt;!--customContent: endif --&amp;gt;
&amp;lt;!--customContent: startif group=users --&amp;gt;
&amp;lt;H1&amp;gt;This content is only available to logged in users &amp;lt;/H1&amp;gt;
&amp;lt;!--customContent: endif --&amp;gt;
</pre>
<p><b>Available parameters</b></p> 
<ul>
<li><p><em>ip</em> - test if remote ip matches a network or supplied ip address.  Valid formats are xxx.xxx.xxx.xxx (exact), xxx.xxx.xxx.[yyy-zzz] (range) and xxx.xxx.xxx/nn (nn = # bits, i.e.  192.168.1.0/24)</p></li>
<li><p><em>group</em> - test if the currently logged in user is a member of any of the supplied groups</p></li>
<li><p><em>user<em> - test if the currently logged in username matches any of the supplied ones</p></li>
<li><p><em>loggedin<em> - test if the current user is logged in or not./p></li>
</ul>
<p>Tests are evaluated in a logical OR fashion in order as follows ip address, group, and user.  The first successfull test will result in the expression evaluationg to true</p>
<h3>Copyright and License</h3>
<p>Copyright &amp;copy; 2005, Robert Campbell <a href=&quot;mailto:rob@techcom.dyndns.org&quot;>&amp;lt;rob@techcom.dyndns.org&amp;gt;</a>. All Rights Are Reserved.</p>
<p>This module has been released under the <a href=&quot;http://www.gnu.org/licenses/licenses.html#GPL&quot;>GNU Public License</a>. You must agree to this license before using the module.</p>';
$lang['utmz'] = '156861353.1192042748.132.7.utmccn=(referral)|utmcsr=cms1.helminikon.no|utmcct=/admin/listtags.php|utmcmd=referral';
$lang['utma'] = '156861353.525406812.1188077417.1192231353.1192274548.142';
$lang['utmc'] = '156861353';
$lang['utmb'] = '156861353';
?>]]></data>
	</file>
	<file>
	  <filename>/lang/ext/nl_NL.php</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[<?php
$lang['error_nofeusers'] = 'Fout: Kan de FrontEndUsers module niet vinden';
$lang['friendlyname'] = 'Custom Content Module';
$lang['postinstall'] = '';
$lang['postuninstall'] = '';
$lang['uninstalled'] = 'Module verwijderd.';
$lang['installed'] = 'Module versie %s ge&iuml;nstalleerd.';
$lang['accessdenied'] = 'Toegang geweigerd. Controleer je rechten.';
$lang['error'] = 'Fout!';
$lang['upgraded'] = 'Module geupgrade naar versie %s.';
$lang['moddescription'] = 'Deze module geeft de mogelijkheid om verschillende content aan groepen of gebruikers te tonen.';
$lang['changelog'] = '<ul><li>Version 1.0. 14 September 2005. Initial Release.</li></ul>
<ul>
<li>Version 1.1.  - September 2005. Added startif/else/endif, and search through multiple groups and users.</li>
<li>Version 1.2.  - September 2005. Added loggedin optional parameter</li>
<li>Version 1.3   - October   2005. Changed to use FrontEndUsers instead of UserID</li>
<li>Version 1.3.1 - November 2005. Very minor bugfix to the parameter parsing</li>
<li>Version 1.4.0 - January, 2006.
<p>Added smarty compatible variables</p></li>
<li>Version 1.4.1 - May, 2006.
<p>Smarty variables now work in 0.13b2</p>
<p>Now require CMS 0.13b2 as a minimum</p>
<p>Updated the help</p>
</li>
<li>Version 1.4.3 - June, 2006.
<p>Added search module compatibility</p>
<p>Added date and time smarty variables</p>
</li>
<li>Version 1.4.4 - Dec, 2006.
<p>Added TemplatePrecompile callback</p>
<li>Version 1.4.5 - Mar, 2007.
<p>Removed the SearchItemAdded callback...</p>
<li>Version 1.4.6 - Apr, 2007.
<p>Added the ccuser object for easier expressions.</p>
<li>Version 1.4.7 - Sep, 2007.
<p>Adjusted the help, the comment syntax is now deprecated</p>
<p>Added a property method to the ccuser object</p>
</li>
<li>Version 1.4.8 - Sep, 2007.
<p>Added the module_exists method to the ccuser object</p>
</li>
<li>Version 1.4.9 - Oct. 2007.
<p>Some minor fixes that seem to fix problems where FEU would get instantiated twice</p>
<p>Fixes an issue in the memberof() method of ccuser when not logged in</p>
</li>
</ul>';
$lang['help'] = '<h3>Wat doet het?</h3>
<p>Deze module laat, samen met de FrontEndUser module, u pagina&#039;s cre&euml;ren die zijn afgestemd op de persoon die ze opvraagt. U kunt verschillende inhoud specificeren voor specifieke gebruikers of leden van een specifieke.</p>
<p><b>Opmerking 1:</b> Als u custom smarty logic in een pagina plaats vergewist u er dan van dat de pagina niet gecached wordt.  Dit wordt voorkomen door op de pagina &quot;Kan in buffer opgenomen worden&quot; uit te vinken (zie Pagina&#039;s menu).</p>
<p><b>Opmerking 2:</b> Als smarty logic is het sjabloon is verwerkt moet mag geen van de pagina&#039;s die deze sjabloon gebruikt opgeslagen wordt in de buffer (not cachable)</p>
<h3>Hoe gebruikt u het?</h3>
<p>Om de functionaliteit te gebruiken plaatst u de tag {cms_module  module=CustomContent} in de pagina of het sjabloon met daaronder de inhoud die u wilt beperken tot specifieke gebruikers in groepen. Dit kan door de volgende smarty syntax te gebruiken.</p>
<h4>Methode 1: smarty tags</h4>
<pre>
{if $customcontent_loggedin}
  Welkom <b>{$customcontent_loginname}</b>
{else}
  U bent niet bevoegd om deze gegevens te bekijken
{/if}
</pre>
<p>Of u kunt de $ccuser variabele gebruiken waarmee beter getest kan worden en wat beter leesbaar is.</p>
<pre>
{if $ccuser->loggedin() &amp;&amp; $ccuser->memberof(&#039;members&#039;) &amp;&amp; $ccuser->ipmatches(&#039;192.168.0.0/24&#039;)}
Welkom ingelogde lokaal lid
{elseif $ccuser->loggedin() &amp;&amp; $ccuser->memberof(&#039;members&#039;)}
Welkom ingelogd lidr
{elseif $ccuser->loggedin()}
Welkom gebruiker van een andere groep
{else}
Anonieme gebruiker
{/if}
</pre>
<p>Iedere smarty-compatible expressie of logica kan worden gebruikt met de beschikbare variabelen.  Expressies mogen genest zijn en kan er samengestelde logica worden gebruikt.</p>
<h4>Beschikbare parameters</h4> 
<ul>
<li><p><em>ccuser</em> - Een object om testen van functies te vergemakkelijken.</p>
<p>Dit object bevat enkele methode waarmee uitgebreidere customcontent logica uitgevoerd kan worden of om het sjabloon er wat beter uit te laten zien. De beschikbare methoden zijn:</p>
  <ul>
<li><em>$ccuser->groups()</em> - toont een lijst met gebruikerslidgroepen</li>
<li><em>$ccuser->memberof(&#039;group&#039;)</em> - geeft een boolean als de gebruiker inderdaad lid is van deze groep. Deze functie accepteert ook een lijst met kommagescheiden groepsnamen.</li>
<li><em>$ccuser->loggedin()</em> - geeft een boolean als de gebruiker ingelogd is</li>
<li><em>$ccuser->property(&#039;propertyname&#039;)</em> - geeft de waarde van de eigenschap van de huidig, ingelogde gebruiker.</li>
<li><em>$ccuser->module_installed(&#039;modulename&#039;)</em> - geeft een boolean als de opgegeven module ge&iuml;nstalleerd en beschikbaar is.</li>
<li><em>$ccuser->ipmatches($ranges)</em> - geeft een boolean als het ip-adres van de gebruiker overeenkomt met een van de adressen in de koamagescheiden ip-bereiken. Accepteert bereiken zoals ###.###.###.###/##, dus b.v.: 192.168.0.0/24</li>
  </ul>
<br/>
</li>
<li><p><em>customcontent_ip</em> - Het remote IP-adres</p></li>
<li><p><em>customcontent_loggedin</em> - Een boolean die aangeeft of een gebruiker is ingelogd of niet</p></li>
<li><p><em>customcontent_loginname</em> - De naam van de huidige, ingelogde gebruiker</p></li>
<li><p><em>customcontent_groupcount</em> - Een telling van het aantal groepen waar deze gebruiker lid van is</p></li>
<li><p><em>customcontent_groups</em> - Een string met alle groepsnamen van alle lidgroepen</p></li>
<li><p><em>customcontent_memberof_*</em> - Een serie booleaanse variabelen die groepslidmaatschap aangeven, bijvoorbeeld: customcontent_memberof_staff, customcontent_memberof_users, etc.  Er worden geen variabelen gedefinieerd voor groepen waar deze gebruiker geen lid van is</p></li>
<li><p><em>customcontent_dayzeros</em> - Dag van de maand, twee karakters met voorloopnullen</p></li> 
<li><p><em>customcontent_day3text</em> - Een tekstuele weergave van een dag, drie letters</p></li>
<li><p><em>customcontent_day</em> - Dag van de maand, zonder voorloopnullen</p></li> 
<li><p><em>customcontent_weekday</em> - Een lange, tekstuele weergave van een dag van de week</p></li> 
<li><p><em>customcontent_dayordsuffix</em> - Engelsche &#039;ordinal suffix&#039; van de dag van de maand, 2 karakters (1st, 2nd)</p></li> 
<li><p><em>customcontent_dayofweek</em> - Numerieke weergave van de week</p></li> 
<li><p><em>customcontent_dayofyear</em> - De dag van het jaar (beginnend met 0)</p></li> 
<li><p><em>customcontent_weeknum</em> - ISO-8601 weeknummer van het jaar, weken starten op maandag</p></li> 
<li><p><em>customcontent_monthfulltext</em> - Een lange, tekstuele weergave van een maand, zoals januari of maart</p></li> 
<li><p><em>customcontent_monthnumzeros</em> - Numerieke weergave van een maand, met voorloopnullen</p></li> 
<li><p><em>customcontent_monthshorttext</em> - Een korte, tekstuele weergave van een maand, drie letters</p></li> 
<li><p><em>customcontent_monthnum</em> - Numerieke weergave van een maand, zonder voorloopnullen</p></li> 
<li><p><em>customcontent_monthnumdays</em> - Aantal dagen in de huidige maand</p></li> 
<li><p><em>customcontent_leapyear</em> - Waar als het een schrikkeljaar betreft</p></li> 
<li><p><em>customcontent_4digityear</em> - Een lange, numerieke weergave van het jaar, vier karakters</p></li> 
<li><p><em>customcontent_2digityear</em> - Een korte, numerieke weergave van het jaar, twee karakters</p></li> 
<li><p><em>customcontent_lowerampm</em> - Onderkast Ante meridiem (am) en Post meridiem (pm)</p></li> 
<li><p><em>customcontent_upperampm</em> - Bovenkast Ante meridiem (AM) en Post meridiem (PM)</p></li>
<li><p><em>customcontent_inettime</em> - Swatch Internettijd</p></li>
<li><p><em>customcontent_12hour</em> - 12-uurs weergave van een uur zonder voorloopnullen</p></li>
<li><p><em>customcontent_24hour</em> - 24-uurs weergave van een uur zonder voorloopnullen</p></li>
<li><p><em>customcontent_12hourzeros</em> - 12-uurs weergave van een uur met voorloopnullen</p></li>
<li><p><em>customcontent_24hourzeros</em> - 24-uurs weergave van een uur met voorloopnullen</p></li>
<li><p><em>customcontent_minutes</em> - Minuten met voorloopnullen</p></li>
<li><p><em>customcontent_seconds</em> - Seconden met voorloopnullen</p></li>
<li><p><em>customcontent_timezone</em> - Tijdzone instellingen van deze computer</p></li>
<li><p><em>customcontent_date</em> - RFC 2822 geformateerde datum</p></li>
<li><p><em>customcontent_epochseconds</em> - Seconden sinds de Unix Epoch (January 1 1970 00:00:00 GMT)</p></li>
</ul>
<h4>Methode 2: commentaar tags <em>(vervallen vanaf versie 1.5)</em></h3>
<p>To use it you place the tag {cms_module module=CustomContent} into your page or template, and then below that you place the content you want isolated to specific users in groups in one of two ways, either using specially formatted comment tags, or using smarty syntax.</p>
<pre>
{cms_module module=CustomContent}
cms_module module=CustomContent}
&amp;lt;!--customContent: startif group=testers,admins --&amp;gt;
&amp;lt;H1&amp;gt;This content is only available to logged in testers and and admins&amp;lt;/H1&amp;gt;
&amp;lt;!--customContent: else --&amp;gt;
&amp;lt;H1&amp;gt;This content is available to everybody else&amp;lt;/H1&amp;gt;
&amp;lt;!--customContent: endif --&amp;gt;
&amp;lt;!--customContent: startif group=users --&amp;gt;
&amp;lt;H1&amp;gt;This content is only available to logged in users &amp;lt;/H1&amp;gt;
&amp;lt;!--customContent: endif --&amp;gt;
</pre>
<h4>Beschikbare variabelen:</h4>
<ul>
<li><p><em>ip</em> - evalueert of de remote-ip overeenkomt met een netwerk of opgegevens ip-adres. Geldige formaten zijn xxx.xxx.xxx.xxx (exact), xxx.xxx.xxx.[yyy-zzz] (bereik) en xxx.xxx.xxx/nn (nn = # bits, bijvoorbeeld  192.168.1.0/24)</p></li>
<li><p><em>group</em> - evalueert of de huidige, ingelogde gebruiker lid is van een van de opgegeven groepen</p></li>
<li><p><em>user</em> - evalueert of de huidige, ingelogde username overeenkomt met &eacute;&eacute;n van de opgegeven namen</p></li>
<li><p><em>loggedin</em> - evalueert of de huidige gebruiker ingelogd is of niet.</p></li>
</ul>
<p>Er wordt ge&euml;valueerd met de logische OR methode in de volgende rangorde: ip-adres, groep en gebruiker.  De eerste, goede overeenkomst zal een &quot;waar&quot; van de ge&euml;valueerde expressie opleveren<p>

<h3>Copyright and Licentie</h3>
<p>Copyright &copy; 2005, Robert Campbell <a href=&quot;mailto:rob@techcom.dyndns.org&quot;><rob@techcom.dyndns.org></a>. Alle rechten zijn voorbehouden.</p>
<p>Deze module is vrijgegeven onder de <a href=&quot;http://www.gnu.org/licenses/licenses.html#GPL&quot;>GNU Public License</a>. Je moet toestemmen met deze licentie v&oacute;&oacute;r het gebruik van deze module.</p>
';
$lang['utma'] = '156861353.1581043522.1185108659.1192269665.1192287405.166';
$lang['utmz'] = '156861353.1192013018.155.6.utmccn=(referral)|utmcsr=dev.cmsmadesimple.org|utmcct=/|utmcmd=referral';
$lang['utmb'] = '156861353';
$lang['utmc'] = '156861353';
?>]]></data>
	</file>
</module>
