<?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.5</version>
  <mincmsversion>1.2</mincmsversion>
	<help><h3>What Does This Do?</h3>
<p>This module, in conjunction with the FrontEndUsers 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>
<pre>
{if $customcontent_loggedin > 0}
  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>Another example: (getting the root page alias)</p>
<pre>
{capture assign='rootalias'}{$ccuser->get_root_alias()}{/capture}
</pre>
<p>Alternatively:</p>
{$ccuser->get_root_alias('','assign')}
<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,$assign)</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 or it is empty, the current page is assumed. If the assign parameter is not empty the results will be assigned to a smarty variable matching the supplied name.</li>
<li><em>$ccuser->get_root_alias($alias,$assign)</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 or is empty, the current page is assumed. If the assign parameter is not empty the results will be assigned to a smarty variable matching the supplied name.</li>
<li><em>$ccuser->get_page_title($alias,$assign)</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 or it is empty, the current page is assumed. If the assign parameter is not empty the results will be assigned to a smarty variable matching the supplied name.</li>
<li><em>$ccuser->has_children($alias,$assign)</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 or it is empty, the current page is assumed. If the assign parameter is not empty the results will be assigned to a smarty variable matching the supplied name.</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> - An integer indicating the userid if the current logged in user.  This variable may exist, but have no value if the user is not logged in.</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>
<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>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</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 setup()
  {
    if( !$this->_module->_initialized )
      {
	$this->_module->_SetVariables();
      }
  }


  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;
  }

};

#-------------------------------------------------------------------------
/* 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 $_initialized = false;
  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);
  }


  /*---------------------------------------------------------
   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()
   ---------------------------------------------------------*/
  function GetName()
  {
    return 'CustomContent';
  }

  
  /*---------------------------------------------------------
   GetFriendlyName()
   ---------------------------------------------------------*/
  function GetFriendlyName()
  {
    return $this->Lang('friendlyname');
  }
  
  
  /*---------------------------------------------------------
   GetVersion()
   ---------------------------------------------------------*/
  function GetVersion()
  {
    return '1.5';
  }

  
  /*---------------------------------------------------------
   MinimumCMSVersion()
   Return the minimum version of CMS that this module requires.
   ---------------------------------------------------------*/
  function MinimumCMSVersion()
  {
    return '1.2';
  }

  /*---------------------------------------------------------
   GetHelp()
   ---------------------------------------------------------*/
  function GetHelp()
  {
    return $this->Lang('help');
  }
  

  /*---------------------------------------------------------
   GetAuthor()
   ---------------------------------------------------------*/
  function GetAuthor()
  {
    return 'calguy1000';
  }
  

  /*---------------------------------------------------------
   GetAuthorEmail()
   ---------------------------------------------------------*/
  function GetAuthorEmail()
  {
    return 'rob@techcom.dyndns.org';
  }
  

  /*---------------------------------------------------------
   GetChangeLog()
   ---------------------------------------------------------*/
  function GetChangeLog()
  {
    return $this->Lang('changelog');
  }


  /*---------------------------------------------------------
   IsPluginModule()
   ---------------------------------------------------------*/
  function IsPluginModule()
  {
    return false;
  }


  /*---------------------------------------------------------
   GetAdminDescription()
   ---------------------------------------------------------*/
  function GetAdminDescription()
  {
    return $this->Lang('moddescription');
  }
  

  /*---------------------------------------------------------
   GetDependencies()
   ---------------------------------------------------------*/
  function GetDependencies()
  {
    return array('FrontEndUsers'=>'1.3');
  }
  

  /*---------------------------------------------------------
   HasAdmin()
   ---------------------------------------------------------*/
  function HasAdmin()
  {
    return false;
  }
  

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


  /*---------------------------------------------------------
   Install()
   ---------------------------------------------------------*/
  function Install()
  {
    //$this->AddEventHandler( 'Search', 'SearchItemAdded', false );
  }

  
  /*---------------------------------------------------------
   InstallPostMessage()
   ---------------------------------------------------------*/
  function InstallPostMessage()
  {
    return $this->Lang('postinstall');
  }

  
  /*---------------------------------------------------------
   UninstallPostMessage()
   ---------------------------------------------------------*/
  function UninstallPostMessage()
  {
    return $this->Lang('postuninstall');
  }
  

  /*---------------------------------------------------------
   Upgrade()
   ---------------------------------------------------------*/
  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()
   ---------------------------------------------------------*/
  function Uninstall()
  {
    $this->RemoveEventHandler( 'Search', 'SearchItemAdded' );
  }


  /*---------------------------------------------------------
   ContentPreCompile()
   ---------------------------------------------------------*/
  function ContentPreCompile()
  {
    if( !$this->_initialized )
      {
	$this->_SetVariables();
      }
  }

       
  /*---------------------------------------------------------
   TemplatePreCompile()
   ---------------------------------------------------------*/
  function TemplatePreCompile()
  {
    if( !$this->_initialized )
      {
	$this->_SetVariables();
      }
  }

       
  /*---------------------------------------------------------
   _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);
  }


  /*---------------------------------------------------------
   Set Our Funky Variables
   ---------------------------------------------------------*/
  function _SetVariables()
  {
    $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));
      }

    $this->_initialized = true;
  }

}

?>
]]></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>
<li>Version 1.4.11 - Dec. 2007.
<p>Adds the ability to assign the output of some functions in the ccuser object to smarty variables without having to use the capture smarty tag.</p>
<li>Version 1.5 - Feb, 2008.
<p>Removes the comment style syntax once and for all... and sets all of the variables ion the object constructor.</p>
<p>Adds the {$ccuser->setup()} method to ensure that the smarty variables are setup</p>
<p>Removes the redundant functions from ccuser that are now in CGSimpleSmarty</p>
</ul>
</ul>';
$lang['help'] = <<<EOT
<h3>What Does This Do?</h3>
<p>This module, in conjunction with the FrontEndUsers 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>
<pre>
{if \$customcontent_loggedin > 0}
  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>Another example: (getting the root page alias)</p>
<pre>
{capture assign='rootalias'}{\$ccuser->get_root_alias()}{/capture}
</pre>
<p>Alternatively:</p>
{\$ccuser->get_root_alias('','assign')}
<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,\$assign)</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 or it is empty, the current page is assumed. If the assign parameter is not empty the results will be assigned to a smarty variable matching the supplied name.</li>
<li><em>\$ccuser->get_root_alias(\$alias,\$assign)</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 or is empty, the current page is assumed. If the assign parameter is not empty the results will be assigned to a smarty variable matching the supplied name.</li>
<li><em>\$ccuser->get_page_title(\$alias,\$assign)</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 or it is empty, the current page is assumed. If the assign parameter is not empty the results will be assigned to a smarty variable matching the supplied name.</li>
<li><em>\$ccuser->has_children(\$alias,\$assign)</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 or it is empty, the current page is assumed. If the assign parameter is not empty the results will be assigned to a smarty variable matching the supplied name.</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> - An integer indicating the userid if the current logged in user.  This variable may exist, but have no value if the user is not logged in.</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>
<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>
EOT;
?>
]]></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>
<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>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['utma'] = '156861353.717462736.1147511856.1195301519.1195381282.253';
$lang['utmz'] = '156861353.1194284715.245.114.utmccn=(referral)|utmcsr=google.de|utmcct=/ig|utmcmd=referral';
?>]]></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 m&oacute;dulo FrontEndUsers';
$lang['friendlyname'] = 'Modulo Custom Content';
$lang['postinstall'] = '';
$lang['postuninstall'] = '';
$lang['uninstalled'] = 'M&oacute;dulo 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'] = 'M&oacute;dulo 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['utma'] = '156861353.1283190177.1192572809.1195863308.1195873912.158';
$lang['utmz'] = '156861353.1195855672.156.31.utmccn=(organic)|utmcsr=google|utmctr=cmsms php debug mode|utmcmd=organic';
$lang['utmc'] = '156861353';
$lang['utmb'] = '156861353';
?>]]></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>
<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>
<li>Version 1.4.11 - Dec. 2007.
<p>Adds the ability to assign the output of some functions in the ccuser object to smarty variables without having to use the capture smarty tag.</p>
</ul>
</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>Altro esempio: (prendere l&#039;alias della pagina root)</p>
<pre>
{capture assign=&#039;rootalias&#039;}{$ccuser->get_root_alias()}{/capture}
</pre>
<p>Alternativamente:</p>
{$ccuser->get_root_alias(&#039;&#039;,&#039;assign&#039;)}
<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->get_parent_alias($alias,$assign)</em> - outputs l&#039;alias della pagina parent, o vuoto se la pagina specificata non ha un parent (&egrave; il top). Quest funzione accetta un alias di pagina come argomento, se nessun alias &egrave; specificato o &egrave; vuoto, &egrave; assunta la pagina corrente. Se il parametro assign non &egrave; vuoto il risultato sar&agrave; assegnato a una variabile smarty che coincide con il nome dato.</li>
<li><em>$ccuser->get_root_alias($alias,$assign)</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 or is empty, the current page is assumed. If the assign parameter is not empty the results will be assigned to a smarty variable matching the supplied name.</li>
<li><em>$ccuser->get_page_title($alias,$assign)</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 or it is empty, the current page is assumed. If the assign parameter is not empty the results will be assigned to a smarty variable matching the supplied name.</li>
<li><em>$ccuser->has_children($alias,$assign)</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 or it is empty, the current page is assumed. If the assign parameter is not empty the results will be assigned to a smarty variable matching the supplied name.</li>
<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.1198364756.426.10.utmccn=(referral)|utmcsr=forum.cmsmadesimple.org|utmcct=/index.php/topic,15318.0.html|utmcmd=referral';
$lang['utma'] = '156861353.1807151640.1182960456.1198364756.1199540378.427';
$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>
<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>
<li>Version 1.4.11 - Dec. 2007.
<p>Adds the ability to assign the output of some functions in the ccuser object to smarty variables without having to use the capture smarty tag.</p>
</ul>
</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 > 0}
  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>Another example: (getting the root page alias)</p>
<pre>
{capture assign=&#039;rootalias&#039;}{$ccuser->get_root_alias()}{/capture}
</pre>
<p>Alternatively:</p>
{$ccuser->get_root_alias(&#039;&#039;,&#039;assign&#039;)}
<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,$assign)</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 or it is empty, the current page is assumed. If the assign parameter is not empty the results will be assigned to a smarty variable matching the supplied name.</li>
<li><em>$ccuser->get_root_alias($alias,$assign)</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 or is empty, the current page is assumed. If the assign parameter is not empty the results will be assigned to a smarty variable matching the supplied name.</li>
<li><em>$ccuser->get_page_title($alias,$assign)</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 or it is empty, the current page is assumed. If the assign parameter is not empty the results will be assigned to a smarty variable matching the supplied name.</li>
<li><em>$ccuser->has_children($alias,$assign)</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 or it is empty, the current page is assumed. If the assign parameter is not empty the results will be assigned to a smarty variable matching the supplied name.</li>
<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> - An integer indicating the userid if the current logged in user.  This variable may exist, but have no value if the user is not logged in.</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['utma'] = '156861353.525406812.1188077417.1197755088.1197837516.322';
$lang['utmz'] = '156861353.1197728674.320.16.utmccn=(referral)|utmcsr=cmsmadesimple.org|utmcct=/|utmcmd=referral';
$lang['utmb'] = '156861353';
$lang['utmc'] = '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>
