in-portal
No OneTemporary
Actions

Subscribers

None

File Metadata

Created: Thu, Feb 6, 9:41 PM

in-portal
View Options

	Index: branches/5.1.x/core/kernel/session/session.php
	===================================================================
	--- branches/5.1.x/core/kernel/session/session.php (revision 13781)
	+++ branches/5.1.x/core/kernel/session/session.php (revision 13782)
	@@ -1,1407 +1,1408 @@
	<?php
	/**
	* @version $Id$
	* @package In-Portal
	* @copyright Copyright (C) 1997 - 2009 Intechnic. All rights reserved.
	* @license GNU/GPL
	* In-Portal is Open Source software.
	* This means that this software may have been modified pursuant
	* the GNU General Public License, and as distributed it includes
	* or is derivative of works licensed under the GNU General Public License
	* or other free or open source software licenses.
	* See http://www.in-portal.org/license for copyright notices and details.
	*/

	defined('FULL_PATH') or die('restricted access!');

	/*
	The session works the following way:

	1. When a visitor loads a page from the site the script checks if cookies_on varibale has been passed to it as a cookie.
	2. If it has been passed, the script tries to get Session ID (SID) from the request:
	3. Depending on session mode the script is getting SID differently.

	The following modes are available:
	- AUTO
	Automatic mode: if cookies are on at the client side, the script relays only on cookies and
	ignore all other methods of passing SID. If cookies are off at the client side, the script relays on SID
	passed through query string and referal passed by the client. THIS METHOD IS NOT 100% SECURE, as long as
	attacker may get SID and substitude referal to gain access to user' session. One of the faults of this method
	is that the session is only created when the visitor clicks the first link on the site, so there
	is NO session at the first load of the page. (Actually there is a session, but it gets lost after
	the first click because we do not use SID in query string while we are not sure if we need it)

	- smCOOKIES_ONLY
	Cookies only: in this mode the script relays solely on cookies passed from the browser and ignores
	all other methods. In this mode there is no way to use sessions for clients without cookies support
	or cookies support disabled. The cookies are stored with the full domain name and path to base-directory
	of script installation.

	- smGET_ONLY
	GET only: the script will not set any cookies and will use only SID passed in query string using GET,
	it will also check referal. The script will set SID at the first load of the page

	- smCOOKIES_AND_GET
	Combined mode: the script will use both cookies and GET right from the start. If client has cookies enabled,
	the script will check SID stored in cookie and passed in query string, and will use this SID only if both
	cookie and query string matches. However if cookies are disabled on the client side, the script will work
	the same way as in GET_ONLY mode.

	4. After the script has the SID it tries to load it from the Storage (default is database)

	5. If such SID is found in the database, the script checks its expiration time. If session is not expired,
	it updates its expiration, and resend the cookie (if applicable to session mode)

	6. Then the script loads all the data (session variables) pertaining to the SID.


	Usage:

	$session = new Session(smAUTO); //smAUTO is default, you could just leave the brackets empty, or provide another mode

	$session->SetCookieDomain('my.domain.com');
	$session->SetCookiePath('/myscript');
	$session->SetCookieName('my_sid_cookie');
	$session->SetGETName('sid');
	$session->InitSession();
	...

	//link output:

	echo "<a href='index.php?'". ( $session->NeedQueryString() ? 'sid='.$session->SID : '' ) .">My Link</a>";

	*/


	/**
	* Implements Session Store in the Database
	*
	*/
	class SessionStorage extends kDBBase {

	var $Expiration;
	var $SessionTimeout=0;

	var $DirectVars = Array();
	var $ChangedDirectVars = Array();

	var $PersistentVars = Array ();

	var $OriginalData=Array();

	var $TimestampField;
	var $SessionDataTable;
	var $DataValueField;
	var $DataVarField;

	function Init($prefix,$special)
	{
	parent::Init($prefix,$special);
	$this->setTableName('sessions');
	$this->setIDField('sid');
	$this->TimestampField = 'expire';
	$this->SessionDataTable = 'SessionData';
	$this->DataValueField = 'value';
	$this->DataVarField = 'var';
	}

	function setSessionTimeout($new_timeout)
	{
	$this->SessionTimeout = $new_timeout;
	}

	/**
	* Calculates browser signature
	*
	* @return string
	*/
	function _getBrowserSignature()
	{
	$signature_parts = Array(
	'HTTP_USER_AGENT', 'SERVER_PROTOCOL',
	'HTTP_ACCEPT_CHARSET', 'HTTP_ACCEPT_ENCODING', 'HTTP_ACCEPT_LANGUAGE'
	);

	$ret = '';

	foreach ($signature_parts as $signature_part) {
	if (array_key_exists($signature_part, $_SERVER)) {
	$ret .= '&\|&' . $_SERVER[$signature_part];
	}
	}

	return md5( substr($ret, 3) );
	}

	function StoreSession(&$session, $additional_fields = Array())
	{
	if (defined('IS_INSTALL') && IS_INSTALL && !$this->Application->TableFound($this->TableName)) {
	return false;
	}

	$fields_hash = Array (
	$this->IDField => $session->SID,
	$this->TimestampField => $session->Expiration,
	);

	if (!defined('IS_INSTALL') \|\| !IS_INSTALL) {
	// this column was added only in 5.0.1 version,
	// so accessing it while database is not upgraded
	// will result in admin's inability to login inside
	// installator
	$fields_hash['BrowserSignature'] = $this->_getBrowserSignature();
	}

	// default values + additional values + values set during this script run
	$additional_fields = array_merge($additional_fields, $this->DirectVars); // used 2 times later
	$fields_hash = array_merge($fields_hash, $additional_fields);

	$this->Conn->doInsert($fields_hash, $this->TableName);

	foreach ($additional_fields as $field_name => $field_value) {
	$this->SetField($session, $field_name, $field_value);
	}
	}

	function DeleteSession(&$session)
	{
	$query = ' DELETE FROM '.$this->TableName.' WHERE '.$this->IDField.' = '.$this->Conn->qstr($session->SID);
	$this->Conn->Query($query);

	$query = ' DELETE FROM '.$this->SessionDataTable.' WHERE '.$this->IDField.' = '.$this->Conn->qstr($session->SID);
	$this->Conn->Query($query);

	$this->DirectVars = $this->ChangedDirectVars = $this->OriginalData = Array();
	}

	function UpdateSession(&$session, $timeout=0)
	{
	$this->SetField($session, $this->TimestampField, $session->Expiration);
	$query = ' UPDATE '.$this->TableName.' SET '.$this->TimestampField.' = '.$session->Expiration.' WHERE '.$this->IDField.' = '.$this->Conn->qstr($session->SID);
	$this->Conn->Query($query);
	}

	function LocateSession($sid)
	{
	$sql = 'SELECT *
	FROM ' . $this->TableName . '
	WHERE ' . $this->IDField . ' = ' . $this->Conn->qstr($sid);
	$result = $this->Conn->GetRow($sql);

	if ($result === false) {
	return false;
	}

	// perform security checks to ensure, that session is used by it's creator
	if ($this->Application->ConfigValue('SessionBrowserSignatureCheck') && ($result['BrowserSignature'] != $this->_getBrowserSignature())) {
	return false;
	}

	if ($this->Application->ConfigValue('SessionIPAddressCheck') && ($result['IpAddress'] != $_SERVER['REMOTE_ADDR'])) {
	// most secure, except for cases where NAT (Network Address Translation)
	// is used and two or more computers can have same IP address
	return false;
	}

	$this->DirectVars = $result;
	$this->Expiration = $result[$this->TimestampField];

	return true;
	}

	function GetExpiration()
	{
	return $this->Expiration;
	}

	function LoadData(&$session)
	{
	$query = 'SELECT '.$this->DataValueField.','.$this->DataVarField.' FROM '.$this->SessionDataTable.' WHERE '.$this->IDField.' = '.$this->Conn->qstr($session->SID);

	$this->OriginalData = $this->Conn->GetCol($query, $this->DataVarField);
	return $this->OriginalData;
	}

	/**
	* Enter description here...
	*
	* @param Session $session
	* @param string $var_name
	* @param mixed $default
	*/
	function GetField(&$session, $var_name, $default = false)
	{
	return isset($this->DirectVars[$var_name]) ? $this->DirectVars[$var_name] : $default;
	//return $this->Conn->GetOne('SELECT '.$var_name.' FROM '.$this->TableName.' WHERE `'.$this->IDField.'` = '.$this->Conn->qstr($session->GetID()) );
	}

	function SetField(&$session, $var_name, $value)
	{
	$value_changed = !isset($this->DirectVars[$var_name]) \|\| ($this->DirectVars[$var_name] != $value);
	if ($value_changed) {
	$this->DirectVars[$var_name] = $value;
	$this->ChangedDirectVars[] = $var_name;
	$this->ChangedDirectVars = array_unique($this->ChangedDirectVars);
	}
	//return $this->Conn->Query('UPDATE '.$this->TableName.' SET '.$var_name.' = '.$this->Conn->qstr($value).' WHERE '.$this->IDField.' = '.$this->Conn->qstr($session->GetID()) );
	}

	function SaveData(&$session)
	{
	if(!$session->SID) return false; // can't save without sid

	$ses_data = $session->Data->GetParams();

	$replace = '';
	foreach ($ses_data as $key => $value)
	{
	if ( isset($this->OriginalData[$key]) && $this->OriginalData[$key] == $value)
	{
	continue; //skip unchanged session data
	}
	else
	{
	$replace .= sprintf("(%s, %s, %s),",
	$this->Conn->qstr($session->SID),
	$this->Conn->qstr($key),
	$this->Conn->qstr($value));
	}
	}
	$replace = rtrim($replace, ',');
	if ($replace != '') {
	$query = ' REPLACE INTO '.$this->SessionDataTable. ' ('.$this->IDField.', '.$this->DataVarField.', '.$this->DataValueField.') VALUES '.$replace;
	$this->Conn->Query($query);
	}

	if ($this->ChangedDirectVars) {
	$changes = array();
	foreach ($this->ChangedDirectVars as $var) {
	$changes[] = $var.' = '.$this->Conn->qstr($this->DirectVars[$var]);
	}
	$query = 'UPDATE '.$this->TableName.' SET '.implode(',', $changes).' WHERE '.$this->IDField.' = '.$this->Conn->qstr($session->GetID());
	$this->Conn->Query($query);
	}
	}

	function RemoveFromData(&$session, $var)
	{
	$query = 'DELETE FROM '.$this->SessionDataTable.' WHERE '.$this->IDField.' = '.$this->Conn->qstr($session->SID).
	' AND '.$this->DataVarField.' = '.$this->Conn->qstr($var);
	$this->Conn->Query($query);
	unset($this->OriginalData[$var]);
	}

	function GetFromData(&$session, $var, $default = false)
	{
	return array_key_exists($var, $this->OriginalData) ? $this->OriginalData[$var] : $default;
	}

	function GetExpiredSIDs()
	{
	$sql = 'SELECT ' . $this->IDField . '
	FROM ' . $this->TableName . '
	WHERE ' . $this->TimestampField . ' > ' . adodb_mktime();

	return $this->Conn->GetCol($sql);
	}

	function DeleteExpired()
	{
	$expired_sids = $this->GetExpiredSIDs();

	$this->DeleteSessions($expired_sids);

	return $expired_sids;
	}

	function DeleteSessions($session_ids, $delete_reason = SESSION_LOG_EXPIRED)
	{
	if (!$session_ids) {
	return ;
	}

	$log_table = $this->Application->getUnitOption('session-log', 'TableName');

	if ($log_table) {
	// mark session with proper status
	$sub_sql = 'SELECT ' . $this->TimestampField . ' - ' . $this->SessionTimeout . '
	FROM ' . $this->TableName . '
	WHERE ' . $this->IDField . ' = ' . $log_table . '.SessionId';

	$sql = 'UPDATE ' . $log_table . '
	SET Status = ' . $delete_reason . ', SessionEnd = (' . $sub_sql . ')
	WHERE Status = ' . SESSION_LOG_ACTIVE . ' AND SessionId IN (' . implode(',', $session_ids) . ')';
	$this->Conn->Query($sql);
	}

	$where_clause = ' WHERE ' . $this->IDField . ' IN (' . implode(',', $session_ids) . ')';
	$sql = 'DELETE FROM ' . $this->SessionDataTable . $where_clause;
	$this->Conn->Query($sql);

	$sql = 'DELETE FROM ' . $this->TableName . $where_clause;
	$this->Conn->Query($sql);

	// delete debugger ouputs left of deleted sessions
	foreach ($session_ids as $session_id) {
	$debug_file = WRITEABLE . '/cache/debug_@' . $session_id . '@.txt';
	if (file_exists($debug_file)) {
	@unlink($debug_file);
	}
	}
	}

	function LoadPersistentVars(&$session)
	{
	$user_id = $session->RecallVar('user_id');
	if ($user_id != USER_GUEST) {
	// root & normal users
	$sql = 'SELECT VariableValue, VariableName
	FROM '.TABLE_PREFIX.'PersistantSessionData
	WHERE PortalUserId = '.$user_id;
	$this->PersistentVars = $this->Conn->GetCol($sql, 'VariableName');
	}
	else {
	$this->PersistentVars = Array ();
	}
	}

	/**
	* Stores variable to persistent session
	*
	* @param Session $session
	* @param string $var_name
	* @param mixed $var_value
	+ * @param bool $optional
	*/
	- function StorePersistentVar(&$session, $var_name, $var_value)
	+ function StorePersistentVar(&$session, $var_name, $var_value, $optional = false)
	{
	$user_id = $session->RecallVar('user_id');
	if ($user_id == USER_GUEST \|\| $user_id === false) {
	// -2 (when not logged in), false (when after u:OnLogout event)
	- $session->StoreVar($var_name, $var_value);
	+ $session->StoreVar($var_name, $var_value, $optional);
	return ;
	}

	$this->PersistentVars[$var_name] = $var_value;

	$key_clause = 'PortalUserId = '.$user_id.' AND VariableName = '.$this->Conn->qstr($var_name);

	$sql = 'SELECT VariableName
	FROM '.TABLE_PREFIX.'PersistantSessionData
	WHERE '.$key_clause;
	$record_found = $this->Conn->GetOne($sql);

	$fields_hash = Array (
	'PortalUserId' => $user_id,
	'VariableName' => $var_name,
	'VariableValue' => $var_value,
	);

	if ($record_found) {
	$this->Conn->doUpdate($fields_hash, TABLE_PREFIX.'PersistantSessionData', $key_clause);
	}
	else {
	$this->Conn->doInsert($fields_hash, TABLE_PREFIX.'PersistantSessionData');
	}
	}

	/**
	* Gets persistent variable
	*
	* @param Session $session
	* @param string $var_name
	* @param mixed $default
	* @return mixed
	*/
	function RecallPersistentVar(&$session, $var_name, $default = false)
	{
	if ($session->RecallVar('user_id') == USER_GUEST) {
	if ($default == ALLOW_DEFAULT_SETTINGS) {
	$default = null;
	}
	return $session->RecallVar($var_name, $default);
	}

	if (array_key_exists($var_name, $this->PersistentVars)) {
	return $this->PersistentVars[$var_name];
	}
	elseif ($default == ALLOW_DEFAULT_SETTINGS) {
	$default_user_id = $this->Application->ConfigValue('DefaultSettingsUserId');
	if (!$default_user_id) {
	$default_user_id = USER_ROOT;
	}
	$sql = 'SELECT VariableValue, VariableName
	FROM '.TABLE_PREFIX.'PersistantSessionData
	WHERE VariableName = '.$this->Conn->qstr($var_name).' AND PortalUserId = '.$default_user_id;
	$value = $this->Conn->GetOne($sql);
	$this->PersistentVars[$var_name] = $value;
	if ($value !== false) {
	$this->StorePersistentVar($session, $var_name, $value); //storing it, so next time we don't load default user setting
	}
	return $value;
	}
	else {
	return $default;
	}
	}

	function RemovePersistentVar(&$session, $var_name)
	{
	unset($this->PersistentVars[$var_name]);

	$user_id = $session->RecallVar('user_id');

	if ($user_id != USER_GUEST) {
	$sql = 'DELETE FROM '.TABLE_PREFIX.'PersistantSessionData
	WHERE PortalUserId = '.$user_id.' AND VariableName = '.$this->Conn->qstr($var_name);
	$this->Conn->Query($sql);
	}
	}
	}

	define('smAUTO', 1);
	define('smCOOKIES_ONLY', 2);
	define('smGET_ONLY', 3);
	define('smCOOKIES_AND_GET', 4);


	class Session extends kBase {
	var $Checkers;

	var $Mode;
	var $OriginalMode = null;
	var $GETName = 'sid';

	var $CookiesEnabled = true;
	var $CookieName = 'sid';
	var $CookieDomain;
	var $CookiePath;
	var $CookieSecure = 0;

	var $SessionTimeout = 3600;
	var $Expiration;

	var $SID;

	var $CachedSID;

	var $SessionSet = false;

	/**
	* Session ID is used from GET
	*
	* @var bool
	*/
	var $_fromGet = false;

	/**
	* Enter description here...
	*
	* @var SessionStorage
	*/
	var $Storage;

	var $CachedNeedQueryString = null;

	/**
	* Session Data array
	*
	* @var Params
	*/
	var $Data;

	/**
	* Names of optional session keys with their optional values (which does not need to be always stored)
	*
	* @var Array
	*/
	var $OptionalData = Array ();

	/**
	* Session expiration mark
	*
	* @var bool
	*/
	var $expired = false;

	function Session($mode = smAUTO)
	{
	parent::kBase();

	$this->SetMode($mode);
	}

	function SetMode($mode)
	{
	$this->Mode = $mode;
	$this->CachedNeedQueryString = null;
	$this->CachedSID = null;
	}

	function SetCookiePath($path)
	{
	$this->CookiePath = str_replace(' ', '%20', $path);
	}

	/**
	* Setting cookie domain. Set false for local domains, because they don't contain dots in their names.
	*
	* @param string $domain
	*/
	function SetCookieDomain($domain)
	{
	// 1. localhost or other like it without "." in domain name
	if (!substr_count($domain, '.')) {
	// don't use cookie domain at all
	$this->CookieDomain = false;
	return ;
	}

	// 2. match using predefined cookie domains from configuration
	$cookie_domains = $this->Application->ConfigValue('SessionCookieDomains');

	if ($cookie_domains) {
	$cookie_domains = array_map('trim', explode("\n", $cookie_domains));

	foreach ($cookie_domains as $cookie_domain) {
	if (ltrim($cookie_domain, '.') == $domain) {
	$this->CookieDomain = $cookie_domain; // as defined in configuration
	return ;
	}
	}
	}

	// 3. only will execute, when none of domains were matched at previous step
	$this->CookieDomain = $this->_autoGuessDomain($domain);
	}

	/**
	* Auto-guess cookie domain based on $_SERVER['HTTP_HOST']
	*
	* @param $domain
	* @return string
	*/
	function _autoGuessDomain($domain)
	{
	static $cache = Array ();

	if (!array_key_exists($domain, $cache)) {
	switch ( substr_count($domain, '.') ) {
	case 2:
	// 3rd level domain (3 parts)
	$cache[$domain] = substr($domain, strpos($domain, '.')); // with leading "."
	break;

	case 1:
	// 2rd level domain (2 parts)
	$cache[$domain] = '.' . $domain; // with leading "."
	break;

	default:
	// more then 3rd level
	$cache[$domain] = ltrim($domain, '.'); // without leading "."
	break;
	}
	}

	return $cache[$domain];
	}

	function SetGETName($get_name)
	{
	$this->GETName = $get_name;
	}

	function SetCookieName($cookie_name)
	{
	$this->CookieName = $cookie_name;
	}

	function InitStorage($special)
	{
	$this->Storage =& $this->Application->recallObject('SessionStorage.'.$special);
	$this->Storage->setSessionTimeout($this->SessionTimeout);
	}

	function Init($prefix,$special)
	{
	parent::Init($prefix,$special);

	$this->CheckIfCookiesAreOn();
	if ($this->CookiesEnabled) $_COOKIE['cookies_on'] = 1;

	$this->Checkers = Array();
	$this->InitStorage($special);
	$this->Data = new Params();

	$tmp_sid = $this->GetPassedSIDValue();

	$check = $this->Check();

	if ($this->Application->isAdmin) {
	// 1. Front-End session may not be created (SID is present, but no data in database).
	// Check expiration LATER from kApplication::Init, because template, used in session
	// expiration redirect should be retrieved from mod-rewrite url first.

	// 2. Admin sessions are always created, so case when SID is present,
	// but session in database isn't is 100% session expired. Check expiration
	// HERE because Session::SetSession will create missing session in database
	// and when Session::ValidateExpired will be called later from kApplication::Init
	// it won't consider such session as expired !!!
	$this->ValidateExpired();
	}

	if ($check) {
	$this->SID = $this->GetPassedSIDValue();
	$this->Refresh();
	$this->LoadData();
	}
	else {
	$this->SetSession();
	}

	if (!is_null($this->OriginalMode)) $this->SetMode($this->OriginalMode);
	}

	function ValidateExpired()
	{
	if (defined('IS_INSTALL') && IS_INSTALL) {
	return ;
	}

	// $this->DeleteExpired(); // called from u:OnDeleteExpiredSessions agent now

	if ($this->expired \|\| ($this->CachedSID && !$this->_fromGet && !$this->SessionSet)) {
	$this->RemoveSessionCookie();
	// true was here to force new session creation, but I (kostja) used
	// RemoveCookie a line above, to avoid redirect loop with expired sid
	// not being removed setSession with true was used before, to set NEW
	// session cookie
	$this->SetSession();

	// case #1: I've OR other site visitor expired my session
	// case #2: I have no session in database, but SID is present
	$this->expired = false;
	$expire_event = new kEvent('u:OnSessionExpire');
	$this->Application->HandleEvent($expire_event);
	}
	}

	/**
	* This is redirect from https to http or via versa
	*
	* @return bool
	*/
	function IsHTTPSRedirect()
	{
	$http_referer = array_key_exists('HTTP_REFERER', $_SERVER) ? $_SERVER['HTTP_REFERER'] : false;

	return (
	( PROTOCOL == 'https://' && preg_match('#http:\/\/#', $http_referer) )
	\|\|
	( PROTOCOL == 'http://' && preg_match('#https:\/\/#', $http_referer) )
	);
	}

	/**
	* Helper method for detecting cookie availability
	*
	* @return bool
	*/
	function _checkCookieReferer()
	{
	// removing /admin for compatability with in-portal (in-link/admin/add_link.php)
	$path = preg_replace('/admin[\/]{0,1}$/', '', $this->CookiePath);
	$reg = '#^'.preg_quote(PROTOCOL.ltrim($this->CookieDomain, '.').$path).'#';

	return preg_match($reg, getArrayValue($_SERVER, 'HTTP_REFERER') );
	}

	function CheckIfCookiesAreOn()
	{
	if ($this->Mode == smGET_ONLY) {
	//we don't need to bother checking if we would not use it
	$this->CookiesEnabled = false;
	return;
	}

	$http_query =& $this->Application->recallObject('HTTPQuery');
	$cookies_on = array_key_exists('cookies_on', $http_query->Cookie); // not good here

	$get_sid = getArrayValue($http_query->Get, $this->GETName);

	if ($this->IsHTTPSRedirect() && $get_sid) { // Redirect from http to https on different domain
	$this->OriginalMode = $this->Mode;
	$this->SetMode(smGET_ONLY);
	}

	if (!$cookies_on \|\| $this->IsHTTPSRedirect()) {
	//If referer is our server, but we don't have our cookies_on, it's definetly off
	$is_install = defined('IS_INSTALL') && IS_INSTALL;
	if (!$is_install && $this->_checkCookieReferer() && !$this->Application->GetVar('admin') && !$this->IsHTTPSRedirect()) {
	$this->CookiesEnabled = false;
	}
	else {
	//Otherwise we still suppose cookies are on, because may be it's the first time user visits the site
	//So we send cookies on to get it next time (when referal will tell us if they are realy off
	$this->SetCookie('cookies_on', 1, adodb_mktime() + 31104000); //one year should be enough
	}
	}
	else {
	$this->CookiesEnabled = true;
	}

	return $this->CookiesEnabled;
	}

	/**
	* Sets cookie for current site using path and domain
	*
	* @param string $name
	* @param mixed $value
	* @param int $expires
	*/
	function SetCookie($name, $value, $expires = null)
	{
	if (isset($expires) && $expires < adodb_mktime()) {
	unset($this->Application->HttpQuery->Cookie[$name]);
	}
	else {
	$this->Application->HttpQuery->Cookie[$name] = $value;
	}

	$old_style_domains = Array (
	// domain like in pre 5.1.0 versions
	'.' . SERVER_NAME,

	// auto-guessed domain (when user specified other domain in configuration variable)
	$this->_autoGuessDomain(SERVER_NAME)
	);

	foreach ($old_style_domains as $old_style_domain) {
	if ($this->CookieDomain != $old_style_domain) {
	// new style cookie domain -> delete old style cookie to prevent infinite redirect
	setcookie($name, $value, adodb_mktime() - 3600, $this->CookiePath, $old_style_domain, $this->CookieSecure);
	}
	}

	setcookie($name, $value, $expires, $this->CookiePath, $this->CookieDomain, $this->CookieSecure);
	}

	function Check()
	{
	// don't check referer here, because it doesn't provide any security option and can be easily falsified

	$sid = $this->GetPassedSIDValue();

	if (empty($sid)) {
	return false;
	}

	//try to load session by sid, if everything is fine
	$result = $this->LoadSession($sid);

	$this->SessionSet = $result; // fake front-end session will given "false" here

	return $result;
	}

	function LoadSession($sid)
	{
	if( $this->Storage->LocateSession($sid) ) {
	// if we have session with such SID - get its expiration
	$this->Expiration = $this->Storage->GetExpiration();

	// If session has expired
	if ($this->Expiration < adodb_mktime()) {
	// when expired session is loaded, then SID is
	// not assigned, but used in Destroy method
	$this->SID = $sid;
	$this->Destroy();

	$this->expired = true;

	// when Destory methods calls SetSession inside and new session get created
	return $this->SessionSet;
	}

	// Otherwise it's ok
	return true;
	}
	else {
	// fake or deleted due to expiration SID
	if (!$this->_fromGet) {
	$this->expired = true;
	}

	return false;
	}
	}

	function GetPassedSIDValue($use_cache = 1)
	{
	if (!empty($this->CachedSID) && $use_cache) {
	return $this->CachedSID;
	}

	$http_query =& $this->Application->recallObject('HTTPQuery');
	$get_sid = getArrayValue($http_query->Get, $this->GETName);
	$sid_from_get = $get_sid ? true : false;

	if ($this->Application->GetVar('admin') == 1 && $get_sid) {
	$sid = $get_sid;
	}
	else {
	switch ($this->Mode) {
	case smAUTO:
	//Cookies has the priority - we ignore everything else
	$sid = $this->CookiesEnabled ? $this->GetSessionCookie() : $get_sid;

	if ($this->CookiesEnabled) {
	$sid_from_get = false;
	}
	break;

	case smCOOKIES_ONLY:
	$sid = $this->GetSessionCookie();
	break;

	case smGET_ONLY:
	$sid = $get_sid;
	break;

	case smCOOKIES_AND_GET:
	$cookie_sid = $this->GetSessionCookie();
	//both sids should match if cookies are enabled
	if (!$this->CookiesEnabled \|\| ($cookie_sid == $get_sid)) {
	$sid = $get_sid; //we use get here just in case cookies are disabled
	}
	else {
	$sid = '';
	$sid_from_get = false;
	}
	break;
	}
	}

	$this->CachedSID = $sid;
	$this->_fromGet = $sid_from_get;

	return $this->CachedSID;
	}

	/**
	* Returns session id
	*
	* @return int
	* @access public
	*/
	function GetID()
	{
	return $this->SID;
	}

	/**
	* Generates new session id
	*
	* @return int
	* @access private
	*/
	function GenerateSID()
	{
	list ($usec, $sec) = explode(' ', microtime());

	$sid_part_1 = substr($usec, 4, 4);
	$sid_part_2 = mt_rand(1, 9);
	$sid_part_3 = substr($sec, 6, 4);
	$digit_one = substr($sid_part_1, 0, 1);

	if ($digit_one == 0) {
	$digit_one = mt_rand(1, 9);
	$sid_part_1 = preg_replace('/^0/', '', $sid_part_1);
	$sid_part_1 = $digit_one . $sid_part_1;
	}

	$this->setSID($sid_part_1 . $sid_part_2 . $sid_part_3);

	return $this->SID;
	}

	/**
	* Set's new session id
	*
	* @param int $new_sid
	* @access private
	*/
	function setSID($new_sid)
	{
	$this->SID /= $this->CachedSID/ = $new_sid; // don't set cached sid here
	$this->Application->SetVar($this->GETName,$new_sid);
	}

	function NeedSession()
	{
	$data = $this->Data->GetParams();

	$data_keys = array_keys($data);
	$optional_keys = array_keys($this->OptionalData);
	$real_keys = array_diff($data_keys, $optional_keys);

	return $real_keys ? true : false;
	}

	function SetSession($force = false)
	{
	if ($this->SessionSet && !$force) {
	return true;
	}

	if (!$force && !($this->Application->isAdmin \|\| $this->Application->GetVar('admin')) && !$this->NeedSession()) {
	// don't create session (in db) on Front-End, when sid is present (GPC), but data in db isn't
	if ($this->_fromGet) {
	// set sid, that was given in GET
	$this->setSID( $this->GetPassedSIDValue() );
	} else {
	// re-generate sid only, when cookies are used
	$this->GenerateSID();
	}
	return false;
	}

	if (!$this->SID \|\| $force) {
	$this->GenerateSID();
	}

	$this->Expiration = adodb_mktime() + $this->SessionTimeout;

	switch ($this->Mode) {
	case smAUTO:
	if ($this->CookiesEnabled) {
	$this->SetSessionCookie();
	}
	break;

	case smGET_ONLY:
	break;

	case smCOOKIES_ONLY:
	case smCOOKIES_AND_GET:
	$this->SetSessionCookie();
	break;
	}

	$this->Storage->StoreSession($this);

	if ($this->Application->isAdmin \|\| $this->Special == 'admin') {
	$this->StoreVar('admin', 1);
	}

	$this->SessionSet = true; // should be called before SaveData, because SaveData will try to SetSession again
	if ($this->Special != '') {
	// front-session called from admin or otherwise, then save it's data
	$this->SaveData();
	}

	$this->Application->resetCounters('UserSession');
	return true;
	}

	/**
	* Returns SID from cookie.
	*
	* Use 2 cookies to have 2 expiration:
	* - 1. for normal expiration when browser is not closed (30 minutes by default), configurable
	* - 2. for advanced expiration when browser is closed
	*
	* @return int
	*/
	function GetSessionCookie()
	{
	$keep_session_on_browser_close = $this->Application->ConfigValue('KeepSessionOnBrowserClose');
	if (isset($this->Application->HttpQuery->Cookie[$this->CookieName]) &&
	( $keep_session_on_browser_close \|\|
	(
	!$keep_session_on_browser_close &&
	isset($this->Application->HttpQuery->Cookie[$this->CookieName.'_live'])
	&&
	$this->Application->HttpQuery->Cookie[$this->CookieName] == $this->Application->HttpQuery->Cookie[$this->CookieName.'_live']
	)
	)
	) {
	return $this->Application->HttpQuery->Cookie[$this->CookieName];
	}
	return false;
	}

	/**
	* Updates SID in cookie with new value
	*
	*/
	function SetSessionCookie()
	{
	$this->SetCookie($this->CookieName, $this->SID, $this->Expiration);
	$this->SetCookie($this->CookieName.'_live', $this->SID);
	$_COOKIE[$this->CookieName] = $this->SID; // for compatibility with in-portal
	}

	function RemoveSessionCookie()
	{
	$this->SetCookie($this->CookieName, '');
	$this->SetCookie($this->CookieName.'_live', '');
	$_COOKIE[$this->CookieName] = null; // for compatibility with in-portal
	}

	/**
	* Refreshes session expiration time
	*
	* @access private
	*/
	function Refresh()
	{
	if ($this->Application->GetVar('skip_session_refresh')) {
	return ;
	}

	if ($this->CookiesEnabled) {
	// we need to refresh the cookie
	$this->SetSessionCookie();
	}
	$this->Storage->UpdateSession($this);
	}

	function Destroy()
	{
	$this->Storage->DeleteSession($this);
	$this->Data = new Params();
	$this->SID = $this->CachedSID = '';
	$this->SessionSet = false;

	if ($this->CookiesEnabled) {
	$this->SetSessionCookie(); //will remove the cookie due to value (sid) is empty
	}

	$this->SetSession(true); //will create a new session, true to force
	}

	function NeedQueryString($use_cache = 1)
	{
	if ($this->CachedNeedQueryString != null && $use_cache) {
	return $this->CachedNeedQueryString;
	}

	$result = false;
	switch ($this->Mode) {
	case smAUTO:
	if (!$this->CookiesEnabled) {
	$result = true;
	}
	break;

	/*case smCOOKIES_ONLY:
	break;*/

	case smGET_ONLY:
	case smCOOKIES_AND_GET:
	$result = true;
	break;
	}

	$this->CachedNeedQueryString = $result;

	return $result;
	}

	function LoadData()
	{
	$this->Data->AddParams($this->Storage->LoadData($this));
	}

	function PrintSession($comment = '')
	{
	if (defined('DEBUG_MODE') && $this->Application->isDebugMode() && constOn('DBG_SHOW_SESSIONDATA')) {
	// dump session data
	$this->Application->Debugger->appendHTML('SessionStorage [' . ($this->RecallVar('admin') == 1 ? 'Admin' : 'Front-End') . '] ('.$comment.'):');
	$session_data = $this->Data->GetParams();
	ksort($session_data);
	foreach ($session_data as $session_key => $session_value) {
	if (IsSerialized($session_value)) {
	$session_data[$session_key] = unserialize($session_value);
	}
	}
	$this->Application->Debugger->dumpVars($session_data);

	if (!$this->RecallVar('admin')) {
	// dump real keys (only for front-end)
	$data_keys = array_keys($session_data);
	$optional_keys = array_keys($this->OptionalData);
	$real_keys = array_diff($data_keys, $optional_keys);

	if ($real_keys) {
	$ret = '';
	foreach ($real_keys as $real_key) {
	$ret .= '[' . $real_key . '] = [' . $session_data[$real_key] . ']<br/>';
	}

	$this->Application->Debugger->appendHTML('Real Keys:<br/> ' . $ret);
	}
	}
	}

	if (defined('DEBUG_MODE') && $this->Application->isDebugMode() && constOn('DBG_SHOW_PERSISTENTDATA')) {
	// dump persistent session data
	if ($this->Storage->PersistentVars) {
	$this->Application->Debugger->appendHTML('Persistant Session:');
	$session_data = $this->Storage->PersistentVars;
	ksort($session_data);
	foreach ($session_data as $session_key => $session_value) {
	if (IsSerialized($session_value)) {
	$session_data[$session_key] = unserialize($session_value);
	}
	}
	$this->Application->Debugger->dumpVars($session_data);
	}
	}
	}

	function SaveData($params = Array ())
	{
	if (!$this->SetSession()) { // call it here - it may be not set before, because there was no need; if there is a need, it will be set here
	return;
	}

	if (!$this->Application->GetVar('skip_last_template') && $this->Application->GetVar('ajax') != 'yes') {
	$this->SaveLastTemplate( $this->Application->GetVar('t'), $params );
	}

	$this->PrintSession('after save');
	$this->Storage->SaveData($this);
	}

	/**
	* Save last template
	*
	* @param string $t
	* @param Array $params
	*/
	function SaveLastTemplate($t, $params = Array ())
	{
	$wid = $this->Application->GetVar('m_wid');

	$last_env = $this->getLastTemplateENV($t, Array('m_opener' => 'u'));
	$last_template = basename($_SERVER['PHP_SELF']).'\|'.mb_substr($last_env, mb_strlen(ENV_VAR_NAME) + 1);
	$this->StoreVar(rtrim('last_template_'.$wid, '_'), $last_template);

	// prepare last_template for opener stack, module & session could be added later
	$last_env = $this->getLastTemplateENV($t, null, false);
	$last_template = basename($_SERVER['PHP_SELF']).'\|'.mb_substr($last_env, mb_strlen(ENV_VAR_NAME) + 1);

	// save last_template in persistant session
	if (!$wid) {
	if ($this->Application->isAdmin) {
	// only for main window, not popups, not login template, not temp mode (used in adm:MainFrameLink tag)
	$temp_mode = false;
	$passed = explode(',', $this->Application->GetVar('passed'));
	foreach ($passed as $passed_prefix) {
	if ($this->Application->GetVar($passed_prefix.'_mode')) {
	$temp_mode = true;
	break;
	}
	}

	if (!$temp_mode) {
	if (isset($this->Application->HttpQuery->Get['section'])) {
	// check directly in GET, bacause LinkVar (session -> request) used on these vars
	$last_template .= '&section='.$this->Application->GetVar('section').'&module='.$this->Application->GetVar('module');
	}

	$this->StorePersistentVar('last_template_popup', $last_template);
	}
	}
	elseif ($this->Application->GetVar('admin')) {
	// admin checking by session data to prevent recursive session save
	static $admin_saved = null;

	if (!$this->RecallVar('admin') && !isset($admin_saved)) {
	// bug: we get recursion in this place, when cookies are disabled in browser and we are browsing
	// front-end in admin's frame (front-end session is initialized using admin's sid and they are
	// mixed together)

	$admin_saved = true;

	$admin_session =& $this->Application->recallObject('Session.admin');
	/* @var $admin_session Session */

	// save to admin last_template too, because when F5 is pressed in frameset Front-End frame should reload as well

	$admin_session->StoreVar('last_template_popup', '../' . $last_template);
	$admin_session->StorePersistentVar('last_template_popup', '../' . $last_template);
	$admin_session->SaveData( Array ('save_last_template' => false) );
	}
	else {
	// don't allow admin=1 & editing_mode=* to get in admin last_template
	$last_template = preg_replace('/&(admin\|editing_mode)=[\d]/', '', $last_template);
	}
	}
	}

	// save other last... variables for mistical purposes (customizations may be)
	$this->StoreVar('last_url', $_SERVER['REQUEST_URI']); // needed by ord:StoreContinueShoppingLink
	$this->StoreVar('last_env', mb_substr($last_env, mb_strlen(ENV_VAR_NAME)+1));

	$save_last_template = array_key_exists('save_last_template', $params) ? $params['save_last_template'] : true;

	if ($save_last_template) {
	// save last template here, becase section & module could be added before
	$this->StoreVar(rtrim('last_template_popup_'.$wid, '_'), $last_template);
	}
	}

	function getLastTemplateENV($t, $params = null, $encode = true)
	{
	if (!isset($params)) {
	$params = Array ();
	}

	$params['__URLENCODE__'] = 1; // uses "&" instead of "&" for url part concatenation + replaces "\" to "%5C" (works in HTML)


	if ($this->Application->GetVar('admin') && !array_key_exists('admin', $params) && !defined('EDITING_MODE')) {
	$params['editing_mode'] = ''; // used in kApplication::Run
	}

	$params = array_merge($this->Application->getPassThroughVariables($params), $params);
	$ret = $this->Application->BuildEnv($t, $params, 'all');

	if (!$encode) {
	// cancels 2nd part of replacements, that URLENCODE does
	$ret = str_replace('%5C', '\\', $ret);
	}
	return $ret;
	}

	function StoreVar($name, $value, $optional = false)
	{
	$this->Data->Set($name, $value);

	if ($optional) {
	// make variable optional, also remember optional value
	$this->OptionalData[$name] = $value;
	}
	elseif (!$optional && array_key_exists($name, $this->OptionalData)) {
	if ($this->OptionalData[$name] == $value) {
	// same value as optional -> don't remove optional mark
	return ;
	}

	// make variable non-optional
	unset($this->OptionalData[$name]);
	}
	}

	- function StorePersistentVar($name, $value)
	+ function StorePersistentVar($name, $value, $optional = false)
	{
	- $this->Storage->StorePersistentVar($this, $name, $value);
	+ $this->Storage->StorePersistentVar($this, $name, $value, $optional);
	}

	function LoadPersistentVars()
	{
	$this->Storage->LoadPersistentVars($this);
	}

	function StoreVarDefault($name, $value, $optional=false)
	{
	$tmp = $this->RecallVar($name);
	if($tmp === false \|\| $tmp == '')
	{
	$this->StoreVar($name, $value, $optional);
	}
	}

	function RecallVar($name, $default = false)
	{
	$ret = $this->Data->Get($name);
	return ($ret === false) ? $default : $ret;
	}

	function RecallPersistentVar($name, $default = false)
	{
	return $this->Storage->RecallPersistentVar($this, $name, $default);
	}


	function RemoveVar($name)
	{
	$this->Storage->RemoveFromData($this, $name);
	$this->Data->Remove($name);
	}

	function RemovePersistentVar($name)
	{
	return $this->Storage->RemovePersistentVar($this, $name);
	}

	/**
	* Ignores session varible value set before
	*
	* @param string $name
	*/
	function RestoreVar($name)
	{
	$value = $this->Storage->GetFromData($this, $name, '__missing__');

	if ($value === '__missing__') {
	// there is nothing to restore (maybe session was not saved), look in optional variable values
	$value = array_key_exists($name, $this->OptionalData) ? $this->OptionalData[$name] : false;
	}

	return $this->StoreVar($name, $value);
	}

	function GetField($var_name, $default = false)
	{
	return $this->Storage->GetField($this, $var_name, $default);
	}

	function SetField($var_name, $value)
	{
	$this->Storage->SetField($this, $var_name, $value);
	}

	/**
	* Deletes expired sessions
	*
	* @return Array expired sids if any
	* @access private
	*/
	function DeleteExpired()
	{
	return $this->Storage->DeleteExpired();
	}

	/**
	* Deletes given sessions
	*
	* @return Array
	* @access private
	*/
	function DeleteSessions($session_ids, $delete_reason = SESSION_LOG_EXPIRED)
	{
	return $this->Storage->DeleteSessions($session_ids, $delete_reason);
	}

	/**
	* Allows to check if user in this session is logged in or not
	*
	* @return bool
	*/
	function LoggedIn()
	{
	$user_id = $this->RecallVar('user_id');

	$ret = $user_id > 0;
	if (($this->RecallVar('admin') == 1 \|\| defined('ADMIN')) && ($user_id == USER_ROOT)) {
	$ret = true;
	}
	return $ret;
	}

	}
	\ No newline at end of file
	Index: branches/5.1.x/core/kernel/db/db_event_handler.php
	===================================================================
	--- branches/5.1.x/core/kernel/db/db_event_handler.php (revision 13781)
	+++ branches/5.1.x/core/kernel/db/db_event_handler.php (revision 13782)
	@@ -1,2891 +1,2920 @@
	<?php
	/**
	* @version $Id$
	* @package In-Portal
	* @copyright Copyright (C) 1997 - 2009 Intechnic. All rights reserved.
	* @license GNU/GPL
	* In-Portal is Open Source software.
	* This means that this software may have been modified pursuant
	* the GNU General Public License, and as distributed it includes
	* or is derivative of works licensed under the GNU General Public License
	* or other free or open source software licenses.
	* See http://www.in-portal.org/license for copyright notices and details.
	*/

	defined('FULL_PATH') or die('restricted access!');

	define('EH_CUSTOM_PROCESSING_BEFORE',1);
	define('EH_CUSTOM_PROCESSING_AFTER',2);

	/**
	* Note:
	* 1. When adressing variables from submit containing
	* Prefix_Special as part of their name use
	* $event->getPrefixSpecial(true) instead of
	* $event->Prefix_Special as usual. This is due PHP
	* is converting "." symbols in variable names during
	* submit info "_". $event->getPrefixSpecial optional
	* 1st parameter returns correct corrent Prefix_Special
	* for variables beeing submitted such way (e.g. variable
	* name that will be converted by PHP: "users.read_only_id"
	* will be submitted as "users_read_only_id".
	*
	* 2. When using $this->Application-LinkVar on variables submitted
	* from form which contain $Prefix_Special then note 1st item. Example:
	* LinkVar($event->getPrefixSpecial(true).'_varname',$event->Prefix_Special.'_varname')
	*
	*/


	/**
	* EventHandler that is used to process
	* any database related events
	*
	*/
	class kDBEventHandler extends kEventHandler {

	/**
	* Description
	*
	* @var kDBConnection
	* @access public
	*/
	var $Conn;

	/**
	* Adds ability to address db connection
	*
	* @return kDBEventHandler
	* @access public
	*/
	function kDBEventHandler()
	{
	parent::kBase();
	$this->Conn =& $this->Application->GetADODBConnection();
	}

	/**
	* Checks permissions of user
	*
	* @param kEvent $event
	*/
	function CheckPermission(&$event)
	{
	$section = $event->getSection();

	if (!$this->Application->isAdmin) {
	$allow_events = Array('OnSearch', 'OnSearchReset', 'OnNew');
	if (in_array($event->Name, $allow_events)) {
	// allow search on front
	return true;
	}
	}
	elseif (($event->Name == 'OnPreSaveAndChangeLanguage') && !$this->UseTempTables($event)) {
	// allow changing language in grids, when not in editing mode
	return $this->Application->CheckPermission($section . '.view', 1);
	}

	if (!preg_match('/^CATEGORY:(.*)/', $section)) {
	// only if not category item events
	if ((substr($event->Name, 0, 9) == 'OnPreSave') \|\| ($event->Name == 'OnSave')) {
	if ($this->isNewItemCreate($event)) {
	return $this->Application->CheckPermission($section.'.add', 1);
	}
	else {
	return $this->Application->CheckPermission($section.'.add', 1) \|\| $this->Application->CheckPermission($section.'.edit', 1);
	}
	}
	}

	if ($event->Name == 'OnPreCreate') {
	// save category_id before item create (for item category selector not to destroy permission checking category)
	$this->Application->LinkVar('m_cat_id');
	}

	if ($event->Name == 'OnSaveWidths') {
	return $this->Application->isAdminUser;
	}

	return parent::CheckPermission($event);
	}

	/**
	* Allows to override standart permission mapping
	*
	*/
	function mapPermissions()
	{
	parent::mapPermissions();
	$permissions = Array(
	'OnLoad' => Array('self' => 'view', 'subitem' => 'view'),
	'OnItemBuild' => Array('self' => 'view', 'subitem' => 'view'),
	'OnSuggestValues' => Array('self' => 'view', 'subitem' => 'view'),

	'OnBuild' => Array('self' => true),

	'OnNew' => Array('self' => 'add', 'subitem' => 'add\|edit'),
	'OnCreate' => Array('self' => 'add', 'subitem' => 'add\|edit'),
	'OnUpdate' => Array('self' => 'edit', 'subitem' => 'add\|edit'),
	'OnSetPrimary' => Array('self' => 'add\|edit', 'subitem' => 'add\|edit'),
	'OnDelete' => Array('self' => 'delete', 'subitem' => 'add\|edit'),
	'OnDeleteAll' => Array('self' => 'delete', 'subitem' => 'add\|edit'),
	'OnMassDelete' => Array('self' => 'delete', 'subitem' => 'add\|edit'),
	'OnMassClone' => Array('self' => 'add', 'subitem' => 'add\|edit'),

	'OnCut' => array('self'=>'edit', 'subitem' => 'edit'),
	'OnCopy' => array('self'=>'edit', 'subitem' => 'edit'),
	'OnPaste' => array('self'=>'edit', 'subitem' => 'edit'),

	'OnSelectItems' => Array('self' => 'add\|edit', 'subitem' => 'add\|edit'),
	'OnProcessSelected' => Array('self' => 'add\|edit', 'subitem' => 'add\|edit'),
	'OnStoreSelected' => Array('self' => 'add\|edit', 'subitem' => 'add\|edit'),
	'OnSelectUser' => Array('self' => 'add\|edit', 'subitem' => 'add\|edit'),

	'OnMassApprove' => Array('self' => 'advanced:approve\|edit', 'subitem' => 'advanced:approve\|add\|edit'),
	'OnMassDecline' => Array('self' => 'advanced:decline\|edit', 'subitem' => 'advanced:decline\|add\|edit'),
	'OnMassMoveUp' => Array('self' => 'advanced:move_up\|edit', 'subitem' => 'advanced:move_up\|add\|edit'),
	'OnMassMoveDown' => Array('self' => 'advanced:move_down\|edit', 'subitem' => 'advanced:move_down\|add\|edit'),

	'OnPreCreate' => Array('self' => 'add\|add.pending', 'subitem' => 'edit\|edit.pending'),
	'OnEdit' => Array('self' => 'edit\|edit.pending', 'subitem' => 'edit\|edit.pending'),

	'OnExport' => Array('self' => 'view\|advanced:export'),
	'OnExportBegin' => Array('self' => 'view\|advanced:export'),
	'OnExportProgress' => Array('self' => 'view\|advanced:export'),


	'OnSetAutoRefreshInterval' => Array ('self' => true, 'subitem' => true),
	'OnAutoRefreshToggle' => Array ('self' => true, 'subitem' => true),

	// theese event do not harm, but just in case check them too :)
	'OnCancelEdit' => Array('self' => true, 'subitem' => true),
	'OnCancel' => Array('self' => true, 'subitem' => true),
	'OnReset' => Array('self' => true, 'subitem' => true),

	'OnSetSorting' => Array('self' => true, 'subitem' => true),
	'OnSetSortingDirect' => Array('self' => true, 'subitem' => true),
	'OnResetSorting' => Array('self' => true, 'subitem' => true),

	'OnSetFilter' => Array('self' => true, 'subitem' => true),
	'OnApplyFilters' => Array('self' => true, 'subitem' => true),
	'OnRemoveFilters' => Array('self' => true, 'subitem' => true),
	'OnSetFilterPattern' => Array('self' => true, 'subitem' => true),

	'OnSetPerPage' => Array('self' => true, 'subitem' => true),
	'OnSetPage' => Array('self' => true, 'subitem' => true),

	'OnSearch' => Array('self' => true, 'subitem' => true),
	'OnSearchReset' => Array('self' => true, 'subitem' => true),

	'OnGoBack' => Array('self' => true, 'subitem' => true),

	// it checks permission itself since flash uploader does not send cookies
	'OnUploadFile' => Array ('self' => true, 'subitem' => true),
	'OnDeleteFile' => Array ('self' => true, 'subitem' => true),

	'OnViewFile' => Array ('self' => true, 'subitem' => true),
	'OnSaveWidths' => Array ('self' => true, 'subitem' => true),

	'OnValidateMInputFields' => Array ('self' => 'view'),
	);
	$this->permMapping = array_merge($this->permMapping, $permissions);
	}

	function mapEvents()
	{
	$events_map = Array(
	'OnRemoveFilters' => 'FilterAction',
	'OnApplyFilters' => 'FilterAction',
	'OnMassApprove'=>'iterateItems',
	'OnMassDecline'=>'iterateItems',
	'OnMassMoveUp'=>'iterateItems',
	'OnMassMoveDown'=>'iterateItems',
	);

	$this->eventMethods = array_merge($this->eventMethods, $events_map);
	}

	/**
	* Returns ID of current item to be edited
	* by checking ID passed in get/post as prefix_id
	* or by looking at first from selected ids, stored.
	* Returned id is also stored in Session in case
	* it was explicitly passed as get/post
	*
	* @param kEvent $event
	* @return int
	*/
	function getPassedID(&$event)
	{
	if ($event->getEventParam('raise_warnings') === false) {
	$event->setEventParam('raise_warnings', 1);
	}

	if (preg_match('/^auto-(.*)/', $event->Special, $regs) && $this->Application->prefixRegistred($regs[1])) {
	// <inp2:lang.auto-phrase_Field name="DateFormat"/> - returns field DateFormat value from language (LanguageId is extracted from current phrase object)
	$main_object =& $this->Application->recallObject($regs[1]);
	/* @var $main_object kDBItem */

	$id_field = $this->Application->getUnitOption($event->Prefix, 'IDField');
	return $main_object->GetDBField($id_field);
	}

	// 1. get id from post (used in admin)
	$ret = $this->Application->GetVar($event->getPrefixSpecial(true).'_id');
	if (($ret !== false) && ($ret != '')) {
	return $ret;
	}

	// 2. get id from env (used in front)
	$ret = $this->Application->GetVar($event->getPrefixSpecial().'_id');
	if (($ret !== false) && ($ret != '')) {
	return $ret;
	}

	// recall selected ids array and use the first one
	$ids = $this->Application->GetVar($event->getPrefixSpecial().'_selected_ids');
	if ($ids != '') {
	$ids = explode(',',$ids);
	if ($ids) {
	$ret = array_shift($ids);
	}
	}
	else { // if selected ids are not yet stored
	$this->StoreSelectedIDs($event);
	return $this->Application->GetVar($event->getPrefixSpecial().'_id'); // StoreSelectedIDs sets this variable
	}

	return $ret;
	}

	/**
	* Prepares and stores selected_ids string
	* in Session and Application Variables
	* by getting all checked ids from grid plus
	* id passed in get/post as prefix_id
	*
	* @param kEvent $event
	* @param Array $direct_ids
	*
	* @return Array ids stored
	*/
	function StoreSelectedIDs(&$event, $direct_ids = null)
	{
	$wid = $this->Application->GetTopmostWid($event->Prefix);
	$session_name = rtrim($event->getPrefixSpecial().'_selected_ids_'.$wid, '_');

	$ids = $event->getEventParam('ids');
	if (isset($direct_ids) \|\| ($ids !== false)) {
	// save ids directly if they given + reset array indexes
	$resulting_ids = $direct_ids ? array_values($direct_ids) : ($ids ? array_values($ids) : false);
	if ($resulting_ids) {
	$this->Application->SetVar($event->getPrefixSpecial() . '_selected_ids', implode(',', $resulting_ids));
	$this->Application->LinkVar($event->getPrefixSpecial() . '_selected_ids', $session_name, '', true);
	$this->Application->SetVar($event->getPrefixSpecial() . '_id', $resulting_ids[0]);

	return $resulting_ids;
	}

	return Array ();
	}

	$ret = Array();

	// May be we don't need this part: ?
	$passed = $this->Application->GetVar($event->getPrefixSpecial(true).'_id');
	if($passed !== false && $passed != '')
	{
	array_push($ret, $passed);
	}

	$ids = Array();

	// get selected ids from post & save them to session
	$items_info = $this->Application->GetVar( $event->getPrefixSpecial(true) );
	if($items_info)
	{
	$id_field = $this->Application->getUnitOption($event->Prefix,'IDField');
	foreach($items_info as $id => $field_values)
	{
	if( getArrayValue($field_values,$id_field) ) array_push($ids,$id);
	}
	//$ids=array_keys($items_info);
	}

	$ret = array_unique(array_merge($ret, $ids));

	$this->Application->SetVar($event->getPrefixSpecial().'_selected_ids', implode(',',$ret));
	$this->Application->LinkVar($event->getPrefixSpecial().'_selected_ids', $session_name, '', !$ret); // optional when IDs are missing

	// This is critical - otherwise getPassedID will return last ID stored in session! (not exactly true)
	// this smells... needs to be refactored
	$first_id = getArrayValue($ret,0);
	if (($first_id === false) && ($event->getEventParam('raise_warnings') == 1)) {
	if ($this->Application->isDebugMode()) {
	$this->Application->Debugger->appendTrace();
	}
	trigger_error('Requested ID for prefix <b>'.$event->getPrefixSpecial().'</b> <span class="debug_error">not passed</span>',E_USER_NOTICE);
	}

	$this->Application->SetVar($event->getPrefixSpecial() . '_id', $first_id);
	return $ret;
	}

	/**
	* Returns stored selected ids as an array
	*
	* @param kEvent $event
	* @param bool $from_session return ids from session (written, when editing was started)
	* @return array
	*/
	function getSelectedIDs(&$event, $from_session = false)
	{
	if ($from_session) {
	$wid = $this->Application->GetTopmostWid($event->Prefix);
	$var_name = rtrim($event->getPrefixSpecial().'_selected_ids_'.$wid, '_');
	$ret = $this->Application->RecallVar($var_name);
	}
	else {
	$ret = $this->Application->GetVar($event->getPrefixSpecial().'_selected_ids');
	}

	return explode(',', $ret);
	}

	/**
	* Stores IDs, selected in grid in session
	*
	* @param kEvent $event
	*/
	function OnStoreSelected(&$event)
	{
	$this->StoreSelectedIDs($event);

	$id = $this->Application->GetVar($event->getPrefixSpecial() . '_id');

	if ($id !== false) {
	$event->SetRedirectParam($event->getPrefixSpecial() . '_id', $id);
	$event->SetRedirectParam('pass', 'all,' . $event->getPrefixSpecial());
	}
	}

	/**
	* Returs associative array of submitted fields for current item
	* Could be used while creating/editing single item -
	* meaning on any edit form, except grid edit
	*
	* @param kEvent $event
	*/
	function getSubmittedFields(&$event)
	{
	$items_info = $this->Application->GetVar( $event->getPrefixSpecial(true) );
	$field_values = $items_info ? array_shift($items_info) : Array();
	return $field_values;
	}

	/**
	* Removes any information about current/selected ids
	* from Application variables and Session
	*
	* @param kEvent $event
	*/
	function clearSelectedIDs(&$event)
	{
	$prefix_special = $event->getPrefixSpecial();

	$ids = implode(',', $this->getSelectedIDs($event, true));
	$event->setEventParam('ids', $ids);

	$wid = $this->Application->GetTopmostWid($event->Prefix);
	$session_name = rtrim($prefix_special.'_selected_ids_'.$wid, '_');

	$this->Application->RemoveVar($session_name);
	$this->Application->SetVar($prefix_special.'_selected_ids', '');

	$this->Application->SetVar($prefix_special.'_id', ''); // $event->getPrefixSpecial(true).'_id' too may be
	}

	/*function SetSaveEvent(&$event)
	{
	$this->Application->SetVar($event->Prefix_Special.'_SaveEvent','OnUpdate');
	$this->Application->LinkVar($event->Prefix_Special.'_SaveEvent');
	}*/

	/**
	* Common builder part for Item & List
	*
	* @param kDBBase $object
	* @param kEvent $event
	* @access private
	*/
	function dbBuild(&$object, &$event)
	{
	// for permission checking inside item/list build events
	$event->setEventParam('top_prefix', $this->Application->GetTopmostPrefix($event->Prefix, true));

	$object->Configure( $event->getEventParam('populate_ml_fields') \|\| $this->Application->getUnitOption($event->Prefix, 'PopulateMlFields') );
	$this->PrepareObject($object, $event);

	// force live table if specified or is original item
	$live_table = $event->getEventParam('live_table') \|\| $event->Special == 'original';

	if( $this->UseTempTables($event) && !$live_table )
	{
	$object->SwitchToTemp();
	}

	// This strange constuction creates hidden field for storing event name in form submit
	// It pass SaveEvent to next screen, otherwise after unsuccsefull create it will try to update rather than create
	$current_event = $this->Application->GetVar($event->Prefix_Special.'_event');
	// $this->Application->setEvent($event->Prefix_Special, $current_event);
	$this->Application->setEvent($event->Prefix_Special, '');

	$save_event = $this->UseTempTables($event) && $this->Application->GetTopmostPrefix($event->Prefix) == $event->Prefix ? 'OnSave' : 'OnUpdate';
	$this->Application->SetVar($event->Prefix_Special.'_SaveEvent',$save_event);
	}

	/**
	* Checks, that currently loaded item is allowed for viewing (non permission-based)
	*
	* @param kEvent $event
	* @return bool
	*/
	function checkItemStatus(&$event)
	{
	$status_fields = $this->Application->getUnitOption($event->Prefix,'StatusField');
	if (!$status_fields) {
	return true;
	}

	$status_field = array_shift($status_fields);
	if ($status_field == 'Status' \|\| $status_field == 'Enabled') {
	$object =& $event->getObject();
	if (!$object->isLoaded()) {
	return true;
	}

	return $object->GetDBField($status_field) == STATUS_ACTIVE;
	}
	return true;
	}

	/**
	* Shows not found template content
	*
	* @param kEvent $event
	*
	*/
	function _errorNotFound(&$event)
	{
	if ($event->getEventParam('raise_warnings') === 0) {
	// when it's possible, that autoload fails do nothing
	return ;
	}

	if ($this->Application->isDebugMode()) {
	$this->Application->Debugger->appendTrace();
	}
	trigger_error('ItemLoad Permission Failed for prefix [' . $event->getPrefixSpecial() . '] in <strong>checkItemStatus</strong>, leading to "404 Not Found"', E_USER_NOTICE);

	header('HTTP/1.0 404 Not Found');

	while (ob_get_level()) {
	ob_end_clean();
	}

	// object is used inside template parsing, so break out any parsing and return error document
	$error_template = $this->Application->ConfigValue('ErrorTemplate');

	$themes_helper =& $this->Application->recallObject('ThemesHelper');
	/* @var $themes_helper kThemesHelper */

	$this->Application->SetVar('t', $error_template);
	$this->Application->SetVar('m_cat_id', $themes_helper->getPageByTemplate($error_template));

	// in case if missing item is recalled first from event (not from template)
	$this->Application->InitParser();
	$this->Application->HTML = $this->Application->ParseBlock( Array ('name' => $error_template) );
	$this->Application->Done();
	exit;
	}

	/**
	* Builds item (loads if needed)
	*
	* @param kEvent $event
	* @access protected
	*/
	function OnItemBuild(&$event)
	{
	$object =& $event->getObject();
	$this->dbBuild($object,$event);

	$sql = $this->ItemPrepareQuery($event);
	$sql = $this->Application->ReplaceLanguageTags($sql);
	$object->setSelectSQL($sql);

	// 2. loads if allowed
	$auto_load = $this->Application->getUnitOption($event->Prefix,'AutoLoad');
	$skip_autload = $event->getEventParam('skip_autoload');

	if ($auto_load && !$skip_autload) {
	$perm_status = true;
	$user_id = $this->Application->RecallVar('user_id');
	$event->setEventParam('top_prefix', $this->Application->GetTopmostPrefix($event->Prefix, true));
	$status_checked = false;
	if ($user_id == USER_ROOT \|\| $this->CheckPermission($event)) {
	// don't autoload item, when user doesn't have view permission
	$this->LoadItem($event);

	$status_checked = true;
	$editing_mode = defined('EDITING_MODE') ? EDITING_MODE : false;

	if ($user_id != USER_ROOT && !$this->Application->isAdmin && !($editing_mode \|\| $this->checkItemStatus($event))) {
	// non-root user AND on front-end AND (not editing mode \|\| incorrect status)
	$perm_status = false;
	}
	}
	else {
	$perm_status = false;
	}

	if (!$perm_status) {
	// when no permission to view item -> redirect to no pemrission template
	if ($this->Application->isDebugMode()) {
	$this->Application->Debugger->appendTrace();
	}

	trigger_error('ItemLoad Permission Failed for prefix ['.$event->getPrefixSpecial().'] in <strong>'.($status_checked ? 'checkItemStatus' : 'CheckPermission').'</strong>', E_USER_NOTICE);
	$template = $this->Application->isAdmin ? 'no_permission' : $this->Application->ConfigValue('NoPermissionTemplate');

	if (MOD_REWRITE) {
	$redirect_params = Array (
	'm_cat_id' => 0,
	'next_template' => urlencode('external:' . $_SERVER['REQUEST_URI']),
	);
	}
	else {
	$redirect_params = Array (
	'next_template' => $this->Application->GetVar('t'),
	);
	}

	$this->Application->Redirect($template, $redirect_params);
	}
	}

	$actions =& $this->Application->recallObject('kActions');
	$actions->Set($event->Prefix_Special.'_GoTab', '');

	$actions->Set($event->Prefix_Special.'_GoId', '');
	}

	/**
	* Build subtables array from configs
	*
	* @param kEvent $event
	*/
	function OnTempHandlerBuild(&$event)
	{
	$object =& $this->Application->recallObject($event->getPrefixSpecial().'_TempHandler', 'kTempTablesHandler');
	/* @var $object kTempTablesHandler */

	$object->BuildTables( $event->Prefix, $this->getSelectedIDs($event) );
	}

	/**
	* Checks, that object used in event should use temp tables
	*
	* @param kEvent $event
	* @return bool
	*/
	function UseTempTables(&$event)
	{
	$top_prefix = $this->Application->GetTopmostPrefix($event->Prefix); // passed parent, not always actual
	$special = ($top_prefix == $event->Prefix) ? $event->Special : $this->getMainSpecial($event);

	return $this->Application->IsTempMode($event->Prefix, $special);
	}

	/**
	* Returns table prefix from event (temp or live)
	*
	* @param kEvent $event
	* @return string
	* @todo Needed? Should be refactored (by Alex)
	*/
	function TablePrefix(&$event)
	{
	return $this->UseTempTables($event) ? $this->Application->GetTempTablePrefix('prefix:'.$event->Prefix).TABLE_PREFIX : TABLE_PREFIX;
	}

	/**
	* Load item if id is available
	*
	* @param kEvent $event
	*/
	function LoadItem(&$event)
	{
	$object =& $event->getObject();
	/* @var $object kDBItem */

	$id = $this->getPassedID($event);

	if ($object->isLoaded() && !is_array($id) && ($object->GetID() == $id)) {
	// object is already loaded by same id
	return ;
	}

	if ($object->Load($id)) {
	$actions =& $this->Application->recallObject('kActions');
	$actions->Set($event->Prefix_Special.'_id', $object->GetID() );
	}
	else {
	$object->setID($id);
	}
	}

	/**
	* Builds list
	*
	* @param kEvent $event
	* @access protected
	*/
	function OnListBuild(&$event)
	{
	$object =& $event->getObject();
	/* @var $object kDBList */

	$this->dbBuild($object,$event);

	if (!$object->mainList && $event->getEventParam('main_list')) {
	// once list is set to main, then even "requery" parameter can't remove that
	/*$passed = $this->Application->GetVar('passed');
	$this->Application->SetVar('passed', $passed . ',' . $event->Prefix);*/

	$object->mainList = true;
	}

	$sql = $this->ListPrepareQuery($event);
	$sql = $this->Application->ReplaceLanguageTags($sql);
	$object->setSelectSQL($sql);

	$object->Counted = false; // when requery="1" should re-count records too!
	$object->ClearOrderFields(); // prevents duplicate order fields, when using requery="1"

	$object->linkToParent( $this->getMainSpecial($event) );

	$this->AddFilters($event);
	$this->SetCustomQuery($event); // new!, use this for dynamic queries based on specials for ex.
	$this->SetPagination($event);
	$this->SetSorting($event);

	// $object->CalculateTotals(); // Now called in getTotals to avoid extra query

	$actions =& $this->Application->recallObject('kActions');
	$actions->Set('remove_specials['.$event->Prefix_Special.']', '0');
	$actions->Set($event->Prefix_Special.'_GoTab', '');
	}


	/**
	* Get's special of main item for linking with subitem
	*
	* @param kEvent $event
	* @return string
	*/
	function getMainSpecial(&$event)
	{
	$main_special = $event->getEventParam('main_special');

	if ($main_special === false) {
	// main item's special not passed

	if (substr($event->Special, -5) == '-item') {
	// temp handler added "-item" to given special -> process that here
	return substr($event->Special, 0, -5);
	}

	// by default subitem's special is used for main item searching
	return $event->Special;
	}

	return $main_special;
	}

	/**
	* Apply any custom changes to list's sql query
	*
	* @param kEvent $event
	* @access protected
	* @see OnListBuild
	*/
	function SetCustomQuery(&$event)
	{

	}

	/**
	* Set's new perpage for grid
	*
	* @param kEvent $event
	*/
	function OnSetPerPage(&$event)
	{
	$per_page = $this->Application->GetVar($event->getPrefixSpecial(true) . '_PerPage');
	$event->SetRedirectParam($event->getPrefixSpecial() . '_PerPage', $per_page);
	$event->SetRedirectParam('pass', 'm,' . $event->getPrefixSpecial());

	if (!$this->Application->isAdminUser) {
	$list_helper =& $this->Application->recallObject('ListHelper');
	/* @var $list_helper ListHelper */

	$this->_passListParams($event, 'per_page');

	/*if ($per_page != $list_helper->getDefaultPerPage($event->Prefix)) {
	$event->SetRedirectParam('per_page', $per_page);
	}*/
	}
	}

	/**
	* Occurs when page is changed (only for hooking)
	*
	* @param kEvent $event
	*/
	function OnSetPage(&$event)
	{
	$page = $this->Application->GetVar($event->getPrefixSpecial(true) . '_Page');
	$event->SetRedirectParam($event->getPrefixSpecial() . '_Page', $page);
	$event->SetRedirectParam('pass', 'm,' . $event->getPrefixSpecial());

	if (!$this->Application->isAdminUser) {
	/*if ($page > 1) {
	$event->SetRedirectParam('page', $page);
	}*/

	$this->_passListParams($event, 'page');
	}
	}

	/**
	* Passes through main list pagination and sorting
	*
	* @param kEvent $event
	* @param string $skip_var
	*/
	function _passListParams(&$event, $skip_var)
	{
	$param_names = array_diff(Array ('page', 'per_page', 'sort_by'), Array ($skip_var));

	$list_helper =& $this->Application->recallObject('ListHelper');
	/* @var $list_helper ListHelper */

	foreach ($param_names as $param_name) {
	$value = $this->Application->GetVar($param_name);

	switch ($param_name) {
	case 'page':
	if ($value > 1) {
	$event->SetRedirectParam('page', $value);
	}
	break;

	case 'per_page':
	if ($value > 0) {
	if ($value != $list_helper->getDefaultPerPage($event->Prefix)) {
	$event->SetRedirectParam('per_page', $value);
	}
	}
	break;

	case 'sort_by':
	$event->setPseudoClass('_List');
	$object =& $event->getObject( Array ('main_list' => 1) );
	/* @var $object kDBList */

	if ($list_helper->hasUserSorting($object)) {
	$event->SetRedirectParam('sort_by', $value);
	}
	break;
	}
	}
	}

	/**
	* Set's correct page for list
	* based on data provided with event
	*
	* @param kEvent $event
	* @access private
	* @see OnListBuild
	*/
	function SetPagination(&$event)
	{
	$object =& $event->getObject();
	/* @var $object kDBList */

	// get PerPage (forced -> session -> config -> 10)
	$object->SetPerPage( $this->getPerPage($event) );

	// main lists on Front-End have special get parameter for page
	$page = $object->mainList ? $this->Application->GetVar('page') : false;

	if (!$page) {
	// page is given in "env" variable for given prefix
	$page = $this->Application->GetVar($event->getPrefixSpecial() . '_Page');
	}

	if (!$page && $event->Special) {
	// when not part of env, then variables like "prefix.special_Page" are
	// replaced (by PHP) with "prefix_special_Page", so check for that too
	$page = $this->Application->GetVar($event->getPrefixSpecial(true) . '_Page');
	}

	if (!$object->mainList) {
	// main lists doesn't use session for page storing
	$this->Application->StoreVarDefault($event->getPrefixSpecial() . '_Page', 1, true); // true for optional

	if ($page) {
	// page found in request -> store in session
	$this->Application->StoreVar($event->getPrefixSpecial() . '_Page', $page, true); //true for optional
	}
	else {
	// page not found in request -> get from session
	$page = $this->Application->RecallVar($event->getPrefixSpecial() . '_Page');
	}

	if ( !$event->getEventParam('skip_counting') ) {
	// when stored page is larger, then maximal list page number
	// (such case is also processed in kDBList::Query method)
	$pages = $object->GetTotalPages();

	if ($page > $pages) {
	$page = 1;
	$this->Application->StoreVar($event->getPrefixSpecial() . '_Page', 1, true);
	}
	}
	}

	$object->SetPage($page);
	}

	/**
	* Returns current per-page setting for list
	*
	* @param kEvent $event
	* @return int
	*/
	function getPerPage(&$event)
	{
	$object =& $event->getObject();
	/* @var $object kDBList */

	$per_page = $event->getEventParam('per_page');

	if ($per_page) {
	// per-page is passed as tag parameter to PrintList, InitList, etc.
	$config_mapping = $this->Application->getUnitOption($event->Prefix, 'ConfigMapping');

	// 2. per-page setting is stored in configuration variable
	if ($config_mapping) {
	// such pseudo per-pages are only defined in templates directly
	switch ($per_page) {
	case 'short_list':
	$per_page = $this->Application->ConfigValue($config_mapping['ShortListPerPage']);
	break;

	case 'default':
	$per_page = $this->Application->ConfigValue($config_mapping['PerPage']);
	break;
	}
	}

	return $per_page;
	}

	if (!$per_page && $object->mainList) {
	// main lists on Front-End have special get parameter for per-page
	$per_page = $this->Application->GetVar('per_page');
	}

	if (!$per_page) {
	// per-page is given in "env" variable for given prefix
	$per_page = $this->Application->GetVar($event->getPrefixSpecial() . '_PerPage');
	}

	if (!$per_page && $event->Special) {
	// when not part of env, then variables like "prefix.special_PerPage" are
	// replaced (by PHP) with "prefix_special_PerPage", so check for that too
	$per_page = $this->Application->GetVar($event->getPrefixSpecial(true) . '_PerPage');
	}

	if (!$object->mainList) {
	// per-page given in env and not in main list
	$view_name = $this->Application->RecallVar($event->getPrefixSpecial() . '_current_view');

	if ($per_page) {
	// per-page found in request -> store in session and persistent session
	- $this->Application->StoreVar($event->getPrefixSpecial() . '_PerPage', $per_page, true); //true for optional
	- $this->Application->StorePersistentVar($event->getPrefixSpecial() . '_PerPage.' . $view_name, $per_page);
	+ $this->setListSetting($event, 'PerPage', $per_page);
	}
	else {
	// per-page not found in request -> get from pesistent session (or session)
	- $storage_prefix = $event->getEventParam('same_special') ? $event->Prefix : $event->getPrefixSpecial();
	- $per_page = $this->Application->RecallPersistentVar($storage_prefix . '_PerPage.' . $view_name, ALLOW_DEFAULT_SETTINGS);
	-
	- if (!$per_page) {
	- // per-page is stored to current session
	- $per_page = $this->Application->RecallVar($storage_prefix . '_PerPage');
	- }
	+ $per_page = $this->getListSetting($event, 'PerPage');
	}
	}

	if (!$per_page) {
	// per page wan't found in request/session/persistent session
	$list_helper =& $this->Application->recallObject('ListHelper');
	/* @var $list_helper ListHelper */

	// allow to override default per-page value from tag
	$default_per_page = $event->getEventParam('default_per_page');

	if (!is_numeric($default_per_page)) {
	$default_per_page = 10;
	}

	$per_page = $list_helper->getDefaultPerPage($event->Prefix, $default_per_page);
	}

	return $per_page;
	}

	/**
	* Set's correct sorting for list
	* based on data provided with event
	*
	* @param kEvent $event
	* @access private
	* @see OnListBuild
	*/
	function SetSorting(&$event)
	{
	$event->setPseudoClass('_List');

	$object =& $event->getObject();
	/* @var $object kDBList */

	if ($object->mainList) {
	$sort_by = $this->Application->GetVar('sort_by');
	$cur_sort1 = $cur_sort1_dir = $cur_sort2 = $cur_sort2_dir = false;

	if ($sort_by) {
	list ($cur_sort1, $cur_sort1_dir) = explode(',', $sort_by);
	}
	}
	else {
	- $storage_prefix = $event->getEventParam('same_special') ? $event->Prefix : $event->Prefix_Special;
	- $cur_sort1 = $this->Application->RecallVar($storage_prefix . '_Sort1');
	- $cur_sort1_dir = $this->Application->RecallVar($storage_prefix . '_Sort1_Dir');
	- $cur_sort2 = $this->Application->RecallVar($storage_prefix . '_Sort2');
	- $cur_sort2_dir = $this->Application->RecallVar($storage_prefix . '_Sort2_Dir');
	+ $cur_sort1 = $this->getListSetting($event, 'Sort1');
	+ $cur_sort1_dir = $this->getListSetting($event, 'Sort1_Dir');
	+ $cur_sort2 = $this->getListSetting($event, 'Sort2');
	+ $cur_sort2_dir = $this->getListSetting($event, 'Sort2_Dir');
	}

	$tag_sort_by = $event->getEventParam('sort_by');

	if ($tag_sort_by) {
	if ($tag_sort_by == 'random') {
	$object->AddOrderField('RAND()', '');
	}
	else {
	// multiple sortings could be specified at once
	$tag_sort_by = explode('\|', $tag_sort_by);

	foreach ($tag_sort_by as $sorting_element) {
	list ($by, $dir) = explode(',', $sorting_element);
	$object->AddOrderField($by, $dir);
	}
	}
	}

	$list_sortings = $this->Application->getUnitOption($event->Prefix, 'ListSortings');
	$sorting_prefix = array_key_exists($event->Special, $list_sortings) ? $event->Special : '';
	$sorting_configs = $this->Application->getUnitOption($event->Prefix, 'ConfigMapping');

	if ($sorting_configs && array_key_exists('DefaultSorting1Field', $sorting_configs)) {
	// sorting defined in configuration variables overrides one from unit config
	$list_sortings[$sorting_prefix]['Sorting'] = Array (
	$this->Application->ConfigValue($sorting_configs['DefaultSorting1Field']) => $this->Application->ConfigValue($sorting_configs['DefaultSorting1Dir']),
	$this->Application->ConfigValue($sorting_configs['DefaultSorting2Field']) => $this->Application->ConfigValue($sorting_configs['DefaultSorting2Dir']),
	);
	}

	// use default if not specified in session
	if (!$cur_sort1 \|\| !$cur_sort1_dir) {
	$sorting = getArrayValue($list_sortings, $sorting_prefix, 'Sorting');

	if ($sorting) {
	reset($sorting);
	$cur_sort1 = key($sorting);
	$cur_sort1_dir = current($sorting);

	if (next($sorting)) {
	$cur_sort2 = key($sorting);
	$cur_sort2_dir = current($sorting);
	}
	}
	}

	// always add forced sorting before any user sortings
	$forced_sorting = getArrayValue($list_sortings, $sorting_prefix, 'ForcedSorting');

	if ($forced_sorting) {
	foreach ($forced_sorting as $field => $dir) {
	$object->AddOrderField($field, $dir);
	}
	}

	// add user sortings
	if ($cur_sort1 != '' && $cur_sort1_dir != '') {
	$object->AddOrderField($cur_sort1, $cur_sort1_dir);
	}

	if ($cur_sort2 != '' && $cur_sort2_dir != '') {
	$object->AddOrderField($cur_sort2, $cur_sort2_dir);
	}
	}

	/**
	+ * Gets list setting by name (persistent or real session)
	+ *
	+ * @param kEvent $event
	+ * @param string $variable_name
	+ * @return string
	+ */
	+ function getListSetting(&$event, $variable_name)
	+ {
	+ $view_name = $this->Application->RecallVar($event->getPrefixSpecial() . '_current_view');
	+ $storage_prefix = $event->getEventParam('same_special') ? $event->Prefix : $event->getPrefixSpecial();
	+
	+ // get sorting from pesistent session
	+ $variable_value = $this->Application->RecallPersistentVar($storage_prefix . '_' . $variable_name . '.' . $view_name, ALLOW_DEFAULT_SETTINGS);
	+
	+ /*if (!$variable_value) {
	+ // get sorting from session
	+ $variable_value = $this->Application->RecallVar($storage_prefix . '_' . $variable_name);
	+ }*/
	+
	+ return $variable_value;
	+ }
	+
	+ /**
	+ * Sets list setting by name (persistent and real session)
	+ *
	+ * @param kEvent $event
	+ * @param string $variable_name
	+ * @param string $variable_value
	+ */
	+ function setListSetting(&$event, $variable_name, $variable_value)
	+ {
	+ $view_name = $this->Application->RecallVar($event->getPrefixSpecial() . '_current_view');
	+// $this->Application->StoreVar($event->getPrefixSpecial() . '_' . $variable_name, $variable_value, true); //true for optional
	+ $this->Application->StorePersistentVar($event->getPrefixSpecial() . '_' . $variable_name . '.' . $view_name, $variable_value, true); //true for optional
	+ }
	+
	+ /**
	* Add filters found in session
	*
	* @param kEvent $event
	*/
	function AddFilters(&$event)
	{
	$object =& $event->getObject();

	$edit_mark = rtrim($this->Application->GetSID().'_'.$this->Application->GetTopmostWid($event->Prefix), '_');

	// add search filter
	$filter_data = $this->Application->RecallVar($event->getPrefixSpecial().'_search_filter');
	if ($filter_data) {
	$filter_data = unserialize($filter_data);
	foreach ($filter_data as $filter_field => $filter_params) {
	$filter_type = ($filter_params['type'] == 'having') ? HAVING_FILTER : WHERE_FILTER;
	$filter_value = str_replace(EDIT_MARK, $edit_mark, $filter_params['value']);
	$object->addFilter($filter_field, $filter_value, $filter_type, FLT_SEARCH);
	}
	}

	// add custom filter
	$view_name = $this->Application->RecallVar($event->getPrefixSpecial().'_current_view');
	$custom_filters = $this->Application->RecallPersistentVar($event->getPrefixSpecial().'_custom_filter.'.$view_name);
	if ($custom_filters) {
	$grid_name = $event->getEventParam('grid');
	$custom_filters = unserialize($custom_filters);
	if (isset($custom_filters[$grid_name])) {
	foreach ($custom_filters[$grid_name] as $field_name => $field_options) {
	list ($filter_type, $field_options) = each($field_options);
	if (isset($field_options['value']) && $field_options['value']) {
	$filter_type = ($field_options['sql_filter_type'] == 'having') ? HAVING_FILTER : WHERE_FILTER;
	$filter_value = str_replace(EDIT_MARK, $edit_mark, $field_options['value']);
	$object->addFilter($field_name, $filter_value, $filter_type, FLT_CUSTOM);
	}
	}
	}
	}

	$view_filter = $this->Application->RecallVar($event->getPrefixSpecial().'_view_filter');
	if($view_filter)
	{
	$view_filter = unserialize($view_filter);
	$temp_filter =& $this->Application->makeClass('kMultipleFilter');
	$filter_menu = $this->Application->getUnitOption($event->Prefix,'FilterMenu');

	$group_key = 0; $group_count = count($filter_menu['Groups']);
	while($group_key < $group_count)
	{
	$group_info = $filter_menu['Groups'][$group_key];

	$temp_filter->setType( constant('FLT_TYPE_'.$group_info['mode']) );
	$temp_filter->clearFilters();
	foreach ($group_info['filters'] as $flt_id)
	{
	$sql_key = getArrayValue($view_filter,$flt_id) ? 'on_sql' : 'off_sql';
	if ($filter_menu['Filters'][$flt_id][$sql_key] != '')
	{
	$temp_filter->addFilter('view_filter_'.$flt_id, $filter_menu['Filters'][$flt_id][$sql_key]);
	}
	}
	$object->addFilter('view_group_'.$group_key, $temp_filter, $group_info['type'] , FLT_VIEW);
	$group_key++;
	}
	}
	}

	/**
	* Set's new sorting for list
	*
	* @param kEvent $event
	* @access protected
	*/
	function OnSetSorting(&$event)
	{
	- $cur_sort1 = $this->Application->RecallVar($event->Prefix_Special.'_Sort1');
	- $cur_sort1_dir = $this->Application->RecallVar($event->Prefix_Special.'_Sort1_Dir');
	+ $cur_sort1 = $this->getListSetting($event, 'Sort1');
	+ $cur_sort1_dir = $this->getListSetting($event, 'Sort1_Dir');

	$use_double_sorting = $this->Application->ConfigValue('UseDoubleSorting');

	if ($use_double_sorting) {
	- $cur_sort2 = $this->Application->RecallVar($event->Prefix_Special.'_Sort2');
	- $cur_sort2_dir = $this->Application->RecallVar($event->Prefix_Special.'_Sort2_Dir');
	+ $cur_sort2 = $this->getListSetting($event, 'Sort2');
	+ $cur_sort2_dir = $this->getListSetting($event, 'Sort2_Dir');
	}

	- $passed_sort1 = $this->Application->GetVar($event->getPrefixSpecial(true).'_Sort1');
	+ $passed_sort1 = $this->Application->GetVar($event->getPrefixSpecial(true) . '_Sort1');
	if ($cur_sort1 == $passed_sort1) {
	$cur_sort1_dir = $cur_sort1_dir == 'asc' ? 'desc' : 'asc';
	}
	else {
	if ($use_double_sorting) {
	$cur_sort2 = $cur_sort1;
	$cur_sort2_dir = $cur_sort1_dir;
	}
	$cur_sort1 = $passed_sort1;
	$cur_sort1_dir = 'asc';
	}

	- $this->Application->StoreVar($event->Prefix_Special.'_Sort1', $cur_sort1);
	- $this->Application->StoreVar($event->Prefix_Special.'_Sort1_Dir', $cur_sort1_dir);
	+ $this->setListSetting($event, 'Sort1', $cur_sort1);
	+ $this->setListSetting($event, 'Sort1_Dir', $cur_sort1_dir);

	if ($use_double_sorting) {
	- $this->Application->StoreVar($event->Prefix_Special.'_Sort2', $cur_sort2);
	- $this->Application->StoreVar($event->Prefix_Special.'_Sort2_Dir', $cur_sort2_dir);
	+ $this->setListSetting($event, 'Sort2', $cur_sort2);
	+ $this->setListSetting($event, 'Sort2_Dir', $cur_sort2_dir);
	}
	}

	/**
	* Set sorting directly to session (used for category item sorting (front-end), grid sorting (admin, view menu)
	*
	* @param kEvent $event
	*/
	function OnSetSortingDirect(&$event)
	{
	// used on Front-End in category item lists
	$prefix_special = $event->getPrefixSpecial();
	$combined = $this->Application->GetVar($event->getPrefixSpecial(true) . '_CombinedSorting');

	if ($combined) {
	list ($field, $dir) = explode('\|', $combined);

	if ($this->Application->isAdmin \|\| !$this->Application->GetVar('main_list')) {
	- $this->Application->StoreVar($prefix_special . '_Sort1', $field);
	- $this->Application->StoreVar($prefix_special . '_Sort1_Dir', $dir);
	+ $this->setListSetting($event, 'Sort1', $field);
	+ $this->setListSetting($event, 'Sort1_Dir', $dir);
	}
	else {
	$event->setPseudoClass('_List');
	$this->Application->SetVar('sort_by', $field . ',' . $dir);

	$object =& $event->getObject( Array ('main_list' => 1) );
	/* @var $object kDBList */

	$list_helper =& $this->Application->recallObject('ListHelper');
	/* @var $list_helper ListHelper */

	$this->_passListParams($event, 'sort_by');

	if ($list_helper->hasUserSorting($object)) {
	$event->SetRedirectParam('sort_by', $field . ',' . strtolower($dir));
	}

	$event->SetRedirectParam('pass', 'm');
	}

	return ;
	}

	// used in "View Menu -> Sort" menu in administrative console
	$field_pos = $this->Application->GetVar($event->getPrefixSpecial(true) . '_SortPos');
	$this->Application->LinkVar($event->getPrefixSpecial(true) . '_Sort' . $field_pos, $prefix_special . '_Sort' . $field_pos);
	$this->Application->LinkVar($event->getPrefixSpecial(true) . '_Sort' . $field_pos . '_Dir', $prefix_special . '_Sort' . $field_pos . '_Dir');
	}

	/**
	* Reset grid sorting to default (from config)
	*
	* @param kEvent $event
	*/
	function OnResetSorting(&$event)
	{
	$this->Application->RemoveVar($event->Prefix_Special.'_Sort1');
	$this->Application->RemoveVar($event->Prefix_Special.'_Sort1_Dir');
	$this->Application->RemoveVar($event->Prefix_Special.'_Sort2');
	$this->Application->RemoveVar($event->Prefix_Special.'_Sort2_Dir');
	}

	/**
	* Sets grid refresh interval
	*
	* @param kEvent $event
	*/
	function OnSetAutoRefreshInterval(&$event)
	{
	$refresh_interval = $this->Application->GetVar('refresh_interval');

	$view_name = $this->Application->RecallVar($event->getPrefixSpecial().'_current_view');
	$this->Application->StorePersistentVar($event->getPrefixSpecial().'_refresh_interval.'.$view_name, $refresh_interval);
	}

	/**
	* Changes auto-refresh state for grid
	*
	* @param kEvent $event
	*/
	function OnAutoRefreshToggle(&$event)
	{
	$refresh_intervals = $this->Application->ConfigValue('AutoRefreshIntervals');
	if (!$refresh_intervals) {
	return ;
	}

	$view_name = $this->Application->RecallVar($event->getPrefixSpecial().'_current_view');
	$auto_refresh = $this->Application->RecallPersistentVar($event->getPrefixSpecial().'_auto_refresh.'.$view_name);

	if ($auto_refresh === false) {
	$refresh_intervals = explode(',', $refresh_intervals);
	$this->Application->StorePersistentVar($event->getPrefixSpecial().'_refresh_interval.'.$view_name, $refresh_intervals[0]);
	}

	$this->Application->StorePersistentVar($event->getPrefixSpecial().'_auto_refresh.'.$view_name, $auto_refresh ? 0 : 1);
	}

	/**
	* Creates needed sql query to load item,
	* if no query is defined in config for
	* special requested, then use default
	* query
	*
	* @param kEvent $event
	* @access protected
	*/
	function ItemPrepareQuery(&$event)
	{
	$sqls = $this->Application->getUnitOption($event->Prefix, 'ItemSQLs', Array ());
	$special = array_key_exists($event->Special, $sqls) ? $event->Special : '';

	if (!array_key_exists($special, $sqls)) {
	// preferred special not found in ItemSQLs -> use analog from ListSQLs
	return $this->ListPrepareQuery($event);
	}

	return $sqls[$special];
	}

	/**
	* Creates needed sql query to load list,
	* if no query is defined in config for
	* special requested, then use default
	* query
	*
	* @param kEvent $event
	* @access protected
	*/
	function ListPrepareQuery(&$event)
	{
	$sqls = $this->Application->getUnitOption($event->Prefix, 'ListSQLs', Array ());
	return $sqls[ array_key_exists($event->Special, $sqls) ? $event->Special : '' ];
	}

	/**
	* Apply custom processing to item
	*
	* @param kEvent $event
	*/
	function customProcessing(&$event, $type)
	{

	}

	/* Edit Events mostly used in Admin */

	/**
	* Creates new kDBItem
	*
	* @param kEvent $event
	* @access protected
	*/
	function OnCreate(&$event)
	{
	$object =& $event->getObject( Array('skip_autoload' => true) );
	/* @var $object kDBItem */

	$items_info = $this->Application->GetVar( $event->getPrefixSpecial(true) );
	if ($items_info) {
	list($id,$field_values) = each($items_info);
	$object->SetFieldsFromHash($field_values);
	}

	$this->customProcessing($event,'before');

	//look at kDBItem' Create for ForceCreateId description, it's rarely used and is NOT set by default
	if ( $object->Create($event->getEventParam('ForceCreateId')) ) {
	$this->customProcessing($event,'after');
	$event->status=erSUCCESS;
	$event->redirect_params = Array('opener'=>'u');
	}
	else {
	$event->status = erFAIL;
	$event->redirect = false;
	$this->Application->SetVar($event->Prefix_Special.'_SaveEvent','OnCreate');
	$object->setID($id);
	}
	}

	/**
	* Updates kDBItem
	*
	* @param kEvent $event
	* @access protected
	*/
	function OnUpdate(&$event)
	{
	if ($this->Application->CheckPermission('SYSTEM_ACCESS.READONLY', 1)) {
	$event->status = erFAIL;
	return;
	}

	$object =& $event->getObject( Array('skip_autoload' => true) );

	$items_info = $this->Application->GetVar( $event->getPrefixSpecial(true) );
	if ($items_info) {
	foreach ($items_info as $id => $field_values) {
	$object->Load($id);
	$object->SetFieldsFromHash($field_values);
	$this->customProcessing($event, 'before');

	if ( $object->Update($id) ) {
	$this->customProcessing($event, 'after');
	$event->status = erSUCCESS;
	}
	else {
	$event->status = erFAIL;
	$event->redirect = false;
	break;
	}
	}
	}

	$event->SetRedirectParam('opener', 'u');
	}

	/**
	* Delete's kDBItem object
	*
	* @param kEvent $event
	* @access protected
	*/
	function OnDelete(&$event)
	{
	if ($this->Application->CheckPermission('SYSTEM_ACCESS.READONLY', 1)) {
	$event->status = erFAIL;
	return;
	}

	$temp =& $this->Application->recallObject($event->getPrefixSpecial().'_TempHandler', 'kTempTablesHandler');
	/* @var $temp kTempTablesHandler */

	$temp->DeleteItems($event->Prefix, $event->Special, Array($this->getPassedID($event)));
	}

	/**
	* Deletes all records from table
	*
	* @param kEvent $event
	*/
	function OnDeleteAll(&$event)
	{
	$sql = 'SELECT ' . $this->Application->getUnitOption($event->Prefix, 'IDField') . '
	FROM ' . $this->Application->getUnitOption($event->Prefix, 'TableName');
	$ids = $this->Conn->GetCol($sql);

	if ($ids) {
	$temp_handler =& $this->Application->recallObject($event->getPrefixSpecial() . '_TempHandler', 'kTempTablesHandler');
	/* @var $temp_handler kTempTablesHandler */

	$temp_handler->DeleteItems($event->Prefix, $event->Special, $ids);
	}
	}

	/**
	* Prepares new kDBItem object
	*
	* @param kEvent $event
	* @access protected
	*/
	function OnNew(&$event)
	{
	$object =& $event->getObject( Array('skip_autoload' => true) );
	/* @var $object kDBItem */

	$object->Clear(0);
	$this->Application->SetVar($event->Prefix_Special.'_SaveEvent', 'OnCreate');

	if ($event->getEventParam('top_prefix') != $event->Prefix) {
	// this is subitem prefix, so use main item special
	$table_info = $object->getLinkedInfo( $this->getMainSpecial($event) );
	}
	else {
	$table_info = $object->getLinkedInfo();
	}

	$object->SetDBField($table_info['ForeignKey'], $table_info['ParentId']);

	$event->redirect = false;
	}

	/**
	* Cancel's kDBItem Editing/Creation
	*
	* @param kEvent $event
	* @access protected
	*/
	function OnCancel(&$event)
	{
	$object =& $event->getObject(Array('skip_autoload' => true));

	$items_info = $this->Application->GetVar($event->getPrefixSpecial(true));
	if ($items_info) {
	$delete_ids = Array();
	$temp =& $this->Application->recallObject($event->getPrefixSpecial().'_TempHandler', 'kTempTablesHandler');
	foreach ($items_info as $id => $field_values) {
	$object->Load($id);
	// record created for using with selector (e.g. Reviews->Select User), and not validated => Delete it
	if ($object->isLoaded() && !$object->Validate() && ($id <= 0) ) {
	$delete_ids[] = $id;
	}
	}

	if ($delete_ids) {
	$temp->DeleteItems($event->Prefix, $event->Special, $delete_ids);
	}
	}

	$event->redirect_params = Array('opener'=>'u');
	}


	/**
	* Deletes all selected items.
	* Automatically recurse into sub-items using temp handler, and deletes sub-items
	* by calling its Delete method if sub-item has AutoDelete set to true in its config file
	*
	* @param kEvent $event
	*/
	function OnMassDelete(&$event)
	{
	if ($this->Application->CheckPermission('SYSTEM_ACCESS.READONLY', 1)) {
	$event->status = erFAIL;
	return;
	}

	$event->status=erSUCCESS;

	$temp =& $this->Application->recallObject($event->getPrefixSpecial().'_TempHandler', 'kTempTablesHandler');

	$ids = $this->StoreSelectedIDs($event);

	$event->setEventParam('ids', $ids);
	$this->customProcessing($event, 'before');
	$ids = $event->getEventParam('ids');

	if($ids)
	{
	$temp->DeleteItems($event->Prefix, $event->Special, $ids);
	}
	$this->clearSelectedIDs($event);
	}

	/**
	* Sets window id (of first opened edit window) to temp mark in uls
	*
	* @param kEvent $event
	*/
	function setTempWindowID(&$event)
	{
	$prefixes = Array ($event->Prefix, $event->getPrefixSpecial(true));

	foreach ($prefixes as $prefix) {
	$mode = $this->Application->GetVar($prefix . '_mode');

	if ($mode == 't') {
	$wid = $this->Application->GetVar('m_wid');
	$this->Application->SetVar(str_replace('_', '.', $prefix) . '_mode', 't' . $wid);
	break;
	}
	}
	}

	/**
	* Prepare temp tables and populate it
	* with items selected in the grid
	*
	* @param kEvent $event
	*/
	function OnEdit(&$event)
	{
	$this->setTempWindowID($event);
	$ids = $this->StoreSelectedIDs($event);

	$var_name = $event->getPrefixSpecial().'_file_pending_actions'.$this->Application->GetVar('m_wid');
	$this->Application->RemoveVar($var_name);

	$changes_var_name = $this->Prefix . '_changes_' . $this->Application->GetTopmostWid($this->Prefix);
	$this->Application->RemoveVar($changes_var_name);

	$temp =& $this->Application->recallObject($event->getPrefixSpecial().'_TempHandler', 'kTempTablesHandler');
	/* @var $temp kTempTablesHandler */

	$temp->PrepareEdit();

	$event->SetRedirectParam('m_lang', $this->Application->GetDefaultLanguageId());
	$event->SetRedirectParam($event->getPrefixSpecial() . '_id', array_shift($ids));
	$event->SetRedirectParam('pass', 'all,' . $event->getPrefixSpecial());
	}

	/**
	* Saves content of temp table into live and
	* redirects to event' default redirect (normally grid template)
	*
	* @param kEvent $event
	*/
	function OnSave(&$event)
	{
	$event->CallSubEvent('OnPreSave');
	if ($event->status == erSUCCESS) {
	$skip_master = false;
	$temp =& $this->Application->recallObject($event->getPrefixSpecial().'_TempHandler', 'kTempTablesHandler');

	$changes_var_name = $this->Prefix.'_changes_'.$this->Application->GetTopmostWid($this->Prefix);

	if (!$this->Application->CheckPermission('SYSTEM_ACCESS.READONLY', 1)) {
	$live_ids = $temp->SaveEdit($event->getEventParam('master_ids') ? $event->getEventParam('master_ids') : Array());
	if ($live_ids === false) {
	// coping from table failed, because we have another coping process to same table, that wasn't finished
	$event->status = erFAIL;
	return ;
	}

	// Deleteing files scheduled for delete
	$var_name = $event->getPrefixSpecial().'_file_pending_actions'.$this->Application->GetVar('m_wid');
	$schedule = $this->Application->RecallVar($var_name);
	$schedule = $schedule ? unserialize($schedule) : array();
	foreach ($schedule as $data) {
	if ($data['action'] == 'delete') {
	unlink($data['file']);
	}
	}

	if ($live_ids) {
	// ensure, that newly created item ids are avalable as if they were selected from grid
	// NOTE: only works if main item has subitems !!!
	$this->StoreSelectedIDs($event, $live_ids);
	}

	$object =& $event->getObject();
	/* @var $object kDBItem */

	$this->SaveLoggedChanges($changes_var_name, $object->ShouldLogChanges());
	}
	else {
	$event->status = erFAIL;
	}

	$this->clearSelectedIDs($event);

	$event->redirect_params = Array('opener' => 'u');
	$this->Application->RemoveVar($event->getPrefixSpecial().'_modified');

	// all temp tables are deleted here => all after hooks should think, that it's live mode now
	$this->Application->SetVar($event->Prefix.'_mode', '');
	}
	}

	function SaveLoggedChanges($changes_var_name, $save = true)
	{
	// 1. get changes, that were made
	$changes = $this->Application->RecallVar($changes_var_name);
	$changes = $changes ? unserialize($changes) : Array ();
	$this->Application->RemoveVar($changes_var_name);

	if (!$changes) {
	// no changes, skip processing
	return ;
	}

	// TODO: 2. optimize change log records (replace multiple changes to same record with one change record)

	$to_increment = Array ();

	// 3. collect serials to reset based on foreign keys
	foreach ($changes as $index => $rec) {
	if (array_key_exists('DependentFields', $rec)) {

	foreach ($rec['DependentFields'] as $field_name => $field_value) {
	// will be "ci\|ItemResourceId:345"
	$to_increment[] = $rec['Prefix'] . '\|' . $field_name . ':' . $field_value;

	// also reset sub-item prefix general serial
	$to_increment[] = $rec['Prefix'];
	}

	unset($changes[$index]['DependentFields']);
	}

	unset($changes[$index]['ParentId'], $changes[$index]['ParentPrefix']);
	}

	// 4. collect serials to reset based on changed ids
	foreach ($changes as $change) {
	$to_increment[] = $change['MasterPrefix'] . '\|' . $change['MasterId'];

	if ($change['MasterPrefix'] != $change['Prefix']) {
	// also reset sub-item prefix general serial
	$to_increment[] = $change['Prefix'];

	// will be "ci\|ItemResourceId"
	$to_increment[] = $change['Prefix'] . '\|' . $change['ItemId'];
	}
	}

	// 5. reset serials collected before
	$to_increment = array_unique($to_increment);
	$this->Application->incrementCacheSerial($this->Prefix);

	foreach ($to_increment as $to_increment_mixed) {
	if (strpos($to_increment_mixed, '\|') !== false) {
	list ($to_increment_prefix, $to_increment_id) = explode('\|', $to_increment_mixed, 2);
	$this->Application->incrementCacheSerial($to_increment_prefix, $to_increment_id);
	}
	else {
	$this->Application->incrementCacheSerial($to_increment_mixed);
	}
	}

	// save changes to database
	$sesion_log_id = $this->Application->RecallVar('_SessionLogId_');

	if (!$save \|\| !$sesion_log_id) {
	// saving changes to database disabled OR related session log missing
	return ;
	}

	$add_fields = Array (
	'PortalUserId' => $this->Application->RecallVar('user_id'),
	'SessionLogId' => $sesion_log_id,
	);

	$change_log_table = $this->Application->getUnitOption('change-log', 'TableName');

	foreach ($changes as $rec) {
	$this->Conn->doInsert(array_merge($rec, $add_fields), $change_log_table);
	}

	$this->Application->incrementCacheSerial('change-log');

	$sql = 'UPDATE ' . $this->Application->getUnitOption('session-log', 'TableName') . '
	SET AffectedItems = AffectedItems + ' . count($changes) . '
	WHERE SessionLogId = ' . $sesion_log_id;
	$this->Conn->Query($sql);

	$this->Application->incrementCacheSerial('session-log');
	}

	/**
	* Cancels edit
	* Removes all temp tables and clears selected ids
	*
	* @param kEvent $event
	*/
	function OnCancelEdit(&$event)
	{
	$temp =& $this->Application->recallObject($event->getPrefixSpecial().'_TempHandler', 'kTempTablesHandler');
	$temp->CancelEdit();

	$this->clearSelectedIDs($event);
	$event->redirect_params = Array('opener'=>'u');
	$this->Application->RemoveVar($event->getPrefixSpecial().'_modified');

	$changes_var_name = $this->Prefix . '_changes_' . $this->Application->GetTopmostWid($this->Prefix);
	$this->Application->RemoveVar($changes_var_name);
	}


	/**
	* Allows to determine if we are creating new item or editing already created item
	*
	* @param kEvent $event
	* @return bool
	*/
	function isNewItemCreate(&$event)
	{
	$object =& $event->getObject( Array ('raise_warnings' => 0) );
	return !$object->IsLoaded();

	// $item_id = $this->getPassedID($event);
	// return ($item_id == '') ? true : false;
	}

	/**
	* Saves edited item into temp table
	* If there is no id, new item is created in temp table
	*
	* @param kEvent $event
	*/
	function OnPreSave(&$event)
	{
	//$event->redirect = false;
	// if there is no id - it means we need to create an item
	if (is_object($event->MasterEvent)) {
	$event->MasterEvent->setEventParam('IsNew',false);
	}

	if ($this->isNewItemCreate($event)) {
	$event->CallSubEvent('OnPreSaveCreated');
	if (is_object($event->MasterEvent)) {
	$event->MasterEvent->setEventParam('IsNew',true);
	}
	return;
	}

	$object =& $event->getObject( Array('skip_autoload' => true) );

	$items_info = $this->Application->GetVar( $event->getPrefixSpecial(true) );
	if ($items_info) {
	foreach ($items_info as $id => $field_values) {
	$object->SetDefaultValues();
	$object->Load($id);
	$object->SetFieldsFromHash($field_values);
	$this->customProcessing($event, 'before');
	if( $object->Update($id) )
	{
	$this->customProcessing($event, 'after');
	$event->status=erSUCCESS;
	}
	else {
	$event->status = erFAIL;
	$event->redirect = false;
	break;
	}
	}
	}
	}

	/**
	* [HOOK] Saves subitem
	*
	* @param kEvent $event
	*/
	function OnPreSaveSubItem(&$event)
	{
	$not_created = $this->isNewItemCreate($event);

	$event->CallSubEvent($not_created ? 'OnCreate' : 'OnUpdate');
	if ($event->status == erSUCCESS) {
	$object =& $event->getObject();
	/* @var $object kDBItem */

	$this->Application->SetVar($event->getPrefixSpecial() . '_id', $object->GetID());
	}
	else {
	$event->MasterEvent->status = $event->status;
	}

	$event->SetRedirectParam('opener', 's');
	}

	/**
	* Saves edited item in temp table and loads
	* item with passed id in current template
	* Used in Prev/Next buttons
	*
	* @param kEvent $event
	*/
	function OnPreSaveAndGo(&$event)
	{
	$event->CallSubEvent('OnPreSave');

	if ($event->status == erSUCCESS) {
	$id = $this->Application->GetVar($event->getPrefixSpecial(true) . '_GoId');
	$event->SetRedirectParam($event->getPrefixSpecial() . '_id', $id);
	}
	}

	/**
	* Saves edited item in temp table and goes
	* to passed tabs, by redirecting to it with OnPreSave event
	*
	* @param kEvent $event
	*/
	function OnPreSaveAndGoToTab(&$event)
	{
	$event->CallSubEvent('OnPreSave');
	if ($event->status==erSUCCESS) {
	$event->redirect=$this->Application->GetVar($event->getPrefixSpecial(true).'_GoTab');
	}
	}

	/**
	* Saves editable list and goes to passed tab,
	* by redirecting to it with empty event
	*
	* @param kEvent $event
	*/
	function OnUpdateAndGoToTab(&$event)
	{
	$event->setPseudoClass('_List');
	$event->CallSubEvent('OnUpdate');
	if ($event->status==erSUCCESS) {
	$event->redirect=$this->Application->GetVar($event->getPrefixSpecial(true).'_GoTab');
	}
	}

	/**
	* Prepare temp tables for creating new item
	* but does not create it. Actual create is
	* done in OnPreSaveCreated
	*
	* @param kEvent $event
	*/
	function OnPreCreate(&$event)
	{
	$this->setTempWindowID($event);
	$this->clearSelectedIDs($event);
	$this->Application->SetVar('m_lang', $this->Application->GetDefaultLanguageId());

	$object =& $event->getObject( Array('skip_autoload' => true) );

	$temp =& $this->Application->recallObject($event->Prefix.'_TempHandler', 'kTempTablesHandler');
	$temp->PrepareEdit();

	$object->setID(0);
	$this->Application->SetVar($event->getPrefixSpecial().'_id', 0);
	$this->Application->SetVar($event->getPrefixSpecial().'_PreCreate', 1);

	$changes_var_name = $this->Prefix . '_changes_' . $this->Application->GetTopmostWid($this->Prefix);
	$this->Application->RemoveVar($changes_var_name);

	$event->redirect = false;
	}

	/**
	* Creates a new item in temp table and
	* stores item id in App vars and Session on succsess
	*
	* @param kEvent $event
	*/
	function OnPreSaveCreated(&$event)
	{
	$items_info = $this->Application->GetVar( $event->getPrefixSpecial(true) );
	if($items_info) $field_values = array_shift($items_info);

	$object =& $event->getObject( Array('skip_autoload' => true) );
	$object->SetFieldsFromHash($field_values);

	$this->customProcessing($event, 'before');

	if( $object->Create() )
	{
	$this->customProcessing($event, 'after');
	$event->redirect_params[$event->getPrefixSpecial(true).'_id'] = $object->GetId();
	$event->status=erSUCCESS;
	}
	else
	{
	$event->status=erFAIL;
	$event->redirect=false;
	$object->setID(0);
	}

	}

	function OnReset(&$event)
	{
	//do nothing - should reset :)
	if ($this->isNewItemCreate($event)) {
	// just reset id to 0 in case it was create
	$object =& $event->getObject( Array('skip_autoload' => true) );
	$object->setID(0);
	$this->Application->SetVar($event->getPrefixSpecial().'_id',0);
	}
	}

	/**
	* Apply same processing to each item beeing selected in grid
	*
	* @param kEvent $event
	* @access private
	*/
	function iterateItems(&$event)
	{
	if ($this->Application->CheckPermission('SYSTEM_ACCESS.READONLY', 1)) {
	$event->status = erFAIL;
	return;
	}

	$object =& $event->getObject( Array('skip_autoload' => true) );
	$ids = $this->StoreSelectedIDs($event);

	if ($ids) {
	$status_field = array_shift( $this->Application->getUnitOption($event->Prefix,'StatusField') );
	$order_field = $this->Application->getUnitOption($event->Prefix,'OrderField');

	if (!$order_field) {
	$order_field = 'Priority';
	}

	foreach ($ids as $id) {
	$object->Load($id);

	switch ($event->Name) {
	case 'OnMassApprove':
	$object->SetDBField($status_field, 1);
	break;

	case 'OnMassDecline':
	$object->SetDBField($status_field, 0);
	break;

	case 'OnMassMoveUp':
	$object->SetDBField($order_field, $object->GetDBField($order_field) + 1);
	break;

	case 'OnMassMoveDown':
	$object->SetDBField($order_field, $object->GetDBField($order_field) - 1);
	break;
	}

	if ($object->Update()) {
	$event->status = erSUCCESS;
	}
	else {
	$event->status = erFAIL;
	$event->redirect = false;
	break;
	}
	}
	}

	$this->clearSelectedIDs($event);
	}

	/**
	* Enter description here...
	*
	* @param kEvent $event
	*/
	function OnMassClone(&$event)
	{
	if ($this->Application->CheckPermission('SYSTEM_ACCESS.READONLY', 1)) {
	$event->status = erFAIL;
	return;
	}

	$event->status = erSUCCESS;

	$temp =& $this->Application->recallObject($event->getPrefixSpecial().'_TempHandler', 'kTempTablesHandler');

	$ids = $this->StoreSelectedIDs($event);

	if ($ids) {
	$temp->CloneItems($event->Prefix, $event->Special, $ids);
	}

	$this->clearSelectedIDs($event);
	}

	function check_array($records, $field, $value)
	{
	foreach ($records as $record) {
	if ($record[$field] == $value) {
	return true;
	}
	}
	return false;
	}

	function OnPreSavePopup(&$event)
	{
	$object =& $event->getObject();
	$this->RemoveRequiredFields($object);
	$event->CallSubEvent('OnPreSave');

	$this->finalizePopup($event);
	}


	/* End of Edit events */

	// III. Events that allow to put some code before and after Update,Load,Create and Delete methods of item

	/**
	* Occurse before loading item, 'id' parameter
	* allows to get id of item beeing loaded
	*
	* @param kEvent $event
	* @access public
	*/
	function OnBeforeItemLoad(&$event)
	{

	}

	/**
	* Occurse after loading item, 'id' parameter
	* allows to get id of item that was loaded
	*
	* @param kEvent $event
	* @access public
	*/
	function OnAfterItemLoad(&$event)
	{

	}

	/**
	* Occurse before creating item
	*
	* @param kEvent $event
	* @access public
	*/
	function OnBeforeItemCreate(&$event)
	{

	}

	/**
	* Occurse after creating item
	*
	* @param kEvent $event
	* @access public
	*/
	function OnAfterItemCreate(&$event)
	{

	}

	/**
	* Occurse before updating item
	*
	* @param kEvent $event
	* @access public
	*/
	function OnBeforeItemUpdate(&$event)
	{

	}

	/**
	* Occurse after updating item
	*
	* @param kEvent $event
	* @access public
	*/
	function OnAfterItemUpdate(&$event)
	{

	}

	/**
	* Occurse before deleting item, id of item beeing
	* deleted is stored as 'id' event param
	*
	* @param kEvent $event
	* @access public
	*/
	function OnBeforeItemDelete(&$event)
	{

	}

	/**
	* Occurse after deleting item, id of deleted item
	* is stored as 'id' param of event
	*
	* @param kEvent $event
	* @access public
	*/
	function OnAfterItemDelete(&$event)
	{

	}

	/**
	* Occurs before validation attempt
	*
	* @param kEvent $event
	*/
	function OnBeforeItemValidate(&$event)
	{

	}

	/**
	* Occurs after successful item validation
	*
	* @param kEvent $event
	*/
	function OnAfterItemValidate(&$event)
	{

	}

	/**
	* Occures after an item has been copied to temp
	* Id of copied item is passed as event' 'id' param
	*
	* @param kEvent $event
	*/
	function OnAfterCopyToTemp(&$event)
	{

	}

	/**
	* Occures before an item is deleted from live table when copying from temp
	* (temp handler deleted all items from live and then copy over all items from temp)
	* Id of item being deleted is passed as event' 'id' param
	*
	* @param kEvent $event
	*/
	function OnBeforeDeleteFromLive(&$event)
	{

	}

	/**
	* Occures before an item is copied to live table (after all foreign keys have been updated)
	* Id of item being copied is passed as event' 'id' param
	*
	* @param kEvent $event
	*/
	function OnBeforeCopyToLive(&$event)
	{

	}

	/**
	* !!! NOT FULLY IMPLEMENTED - SEE TEMP HANDLER COMMENTS (search by event name)!!!
	* Occures after an item has been copied to live table
	* Id of copied item is passed as event' 'id' param
	*
	* @param kEvent $event
	*/
	function OnAfterCopyToLive(&$event)
	{

	}

	/**
	* Occures before an item is cloneded
	* Id of ORIGINAL item is passed as event' 'id' param
	* Do not call object' Update method in this event, just set needed fields!
	*
	* @param kEvent $event
	*/
	function OnBeforeClone(&$event)
	{

	}

	/**
	* Occures after an item has been cloned
	* Id of newly created item is passed as event' 'id' param
	*
	* @param kEvent $event
	*/
	function OnAfterClone(&$event)
	{

	}

	/**
	* Occures after list is queried
	*
	* @param kEvent $event
	*/
	function OnAfterListQuery(&$event)
	{

	}

	/**
	* Ensures that popup will be closed automatically
	* and parent window will be refreshed with template
	* passed
	*
	* @param kEvent $event
	* @access public
	*/
	function finalizePopup(&$event)
	{
	$event->SetRedirectParam('opener', 'u');
	}

	/**
	* Create search filters based on search query
	*
	* @param kEvent $event
	* @access protected
	*/
	function OnSearch(&$event)
	{
	$event->setPseudoClass('_List');

	$search_helper =& $this->Application->recallObject('SearchHelper');
	/* @var $search_helper kSearchHelper */

	$search_helper->performSearch($event);
	}

	/**
	* Clear search keywords
	*
	* @param kEvent $event
	* @access protected
	*/
	function OnSearchReset(&$event)
	{
	$search_helper =& $this->Application->recallObject('SearchHelper');
	/* @var $search_helper kSearchHelper */

	$search_helper->resetSearch($event);
	}

	/**
	* Set's new filter value (filter_id meaning from config)
	*
	* @param kEvent $event
	*/
	function OnSetFilter(&$event)
	{
	$filter_id = $this->Application->GetVar('filter_id');
	$filter_value = $this->Application->GetVar('filter_value');

	$view_filter = $this->Application->RecallVar($event->getPrefixSpecial().'_view_filter');
	$view_filter = $view_filter ? unserialize($view_filter) : Array();

	$view_filter[$filter_id] = $filter_value;

	$this->Application->StoreVar( $event->getPrefixSpecial().'_view_filter', serialize($view_filter) );
	}

	function OnSetFilterPattern(&$event)
	{
	$filters = $this->Application->GetVar($event->getPrefixSpecial(true).'_filters');
	if (!$filters) return ;

	$view_filter = $this->Application->RecallVar($event->getPrefixSpecial().'_view_filter');
	$view_filter = $view_filter ? unserialize($view_filter) : Array();

	$filters = explode(',', $filters);
	foreach ($filters as $a_filter) {
	list($id, $value) = explode('=', $a_filter);
	$view_filter[$id] = $value;
	}
	$this->Application->StoreVar( $event->getPrefixSpecial().'_view_filter', serialize($view_filter) );
	$event->redirect = false;
	}

	/**
	* Add/Remove all filters applied to list from "View" menu
	*
	* @param kEvent $event
	*/
	function FilterAction(&$event)
	{
	$view_filter = Array();
	$filter_menu = $this->Application->getUnitOption($event->Prefix,'FilterMenu');
	switch ($event->Name)
	{
	case 'OnRemoveFilters':
	$filter_value = 1;
	break;

	case 'OnApplyFilters':
	$filter_value = 0;
	break;
	}

	foreach($filter_menu['Filters'] as $filter_key => $filter_params)
	{
	if(!$filter_params) continue;
	$view_filter[$filter_key] = $filter_value;
	}
	$this->Application->StoreVar( $event->getPrefixSpecial().'_view_filter', serialize($view_filter) );
	}

	/**
	* Enter description here...
	*
	* @param kEvent $event
	*/
	function OnPreSaveAndOpenTranslator(&$event)
	{
	$this->Application->SetVar('allow_translation', true);
	$object =& $event->getObject();
	$this->RemoveRequiredFields($object);
	$event->CallSubEvent('OnPreSave');

	if ($event->status == erSUCCESS) {

	$resource_id = $this->Application->GetVar('translator_resource_id');
	if ($resource_id) {
	$t_prefixes = explode(',', $this->Application->GetVar('translator_prefixes'));

	$cdata =& $this->Application->recallObject($t_prefixes[1], null, Array('skip_autoload' => true));
	$cdata->Load($resource_id, 'ResourceId');
	if (!$cdata->isLoaded()) {
	$cdata->SetDBField('ResourceId', $resource_id);
	$cdata->Create();
	}
	$this->Application->SetVar($cdata->getPrefixSpecial().'_id', $cdata->GetID());
	}

	$event->redirect = $this->Application->GetVar('translator_t');
	$event->redirect_params = Array (
	'pass' => 'all,trans,' . $this->Application->GetVar('translator_prefixes'),
	'opener' => 's',
	$event->getPrefixSpecial(true) . '_id' => $object->GetID(),
	'trans_event' => 'OnLoad',
	'trans_prefix' => $this->Application->GetVar('translator_prefixes'),
	'trans_field' => $this->Application->GetVar('translator_field'),
	'trans_multi_line' => $this->Application->GetVar('translator_multi_line'),
	);

	// 1. SAVE LAST TEMPLATE TO SESSION (really needed here, because of tweaky redirect)
	$last_template = $this->Application->RecallVar('last_template');
	preg_match('/index4\.php\\|'.$this->Application->GetSID().'-(.*):/U', $last_template, $rets);
	$this->Application->StoreVar('return_template', $this->Application->GetVar('t'));
	}
	}

	function RemoveRequiredFields(&$object)
	{
	// making all field non-required to achieve successful presave
	foreach($object->Fields as $field => $options)
	{
	if(isset($options['required']))
	{
	unset($object->Fields[$field]['required']);
	}
	}
	}

	/**
	* Saves selected user in needed field
	*
	* @param kEvent $event
	*/
	function OnSelectUser(&$event)
	{
	$items_info = $this->Application->GetVar('u');
	if ($items_info) {
	$user_id = array_shift( array_keys($items_info) );

	$object =& $event->getObject();
	$this->RemoveRequiredFields($object);

	$is_new = !$object->isLoaded();
	$is_main = substr($this->Application->GetVar($event->Prefix.'_mode'), 0, 1) == 't';

	if ($is_new) {
	$new_event = $is_main ? 'OnPreCreate' : 'OnNew';
	$event->CallSubEvent($new_event);
	$event->redirect = true;
	}

	$object->SetDBField($this->Application->RecallVar('dst_field'), $user_id);

	if ($is_new) {
	$object->Create();
	}
	else {
	$object->Update();
	}
	}

	$event->SetRedirectParam($event->getPrefixSpecial().'_id', $object->GetID());
	$this->finalizePopup($event);
	}


	/ EXPORT RELATED /

	/**
	* Shows export dialog
	*
	* @param kEvent $event
	*/
	function OnExport(&$event)
	{
	$selected_ids = $this->StoreSelectedIDs($event);

	if (implode(',', $selected_ids) == '') {
	// K4 fix when no ids found bad selected ids array is formed
	$selected_ids = false;
	}

	$this->Application->StoreVar($event->Prefix.'_export_ids', $selected_ids ? implode(',', $selected_ids) : '' );

	$this->Application->LinkVar('export_finish_t');
	$this->Application->LinkVar('export_progress_t');
	$this->Application->StoreVar('export_oroginal_special', $event->Special);

	$export_helper =& $this->Application->recallObject('CatItemExportHelper');

	/*list ($index_file, $env) = explode('\|', $this->Application->RecallVar('last_template'));
	$finish_url = $this->Application->BaseURL('/admin').$index_file.'?'.ENV_VAR_NAME.'='.$env;
	$this->Application->StoreVar('export_finish_url', $finish_url);*/

	$redirect_params = Array (
	$this->Prefix . '.export_event' => 'OnNew',
	'pass' => 'all,' . $this->Prefix . '.export'
	);

	$event->setRedirectParams($redirect_params);
	}

	/**
	* Apply some special processing to
	* object beeing recalled before using
	* it in other events that call prepareObject
	*
	* @param Object $object
	* @param kEvent $event
	* @access protected
	*/
	function prepareObject(&$object, &$event)
	{
	if ($event->Special == 'export' \|\| $event->Special == 'import')
	{
	$export_helper =& $this->Application->recallObject('CatItemExportHelper');
	/* @var $export_helper kCatDBItemExportHelper */

	$export_helper->prepareExportColumns($event);
	}
	}

	/**
	* Returns specific to each item type columns only
	*
	* @param kEvent $event
	* @return Array
	*/
	function getCustomExportColumns(&$event)
	{
	return Array();
	}

	/**
	* Export form validation & processing
	*
	* @param kEvent $event
	*/
	function OnExportBegin(&$event)
	{
	$export_helper =& $this->Application->recallObject('CatItemExportHelper');
	/* @var $export_helper kCatDBItemExportHelper */
	$export_helper->OnExportBegin($event);
	}

	/**
	* Enter description here...
	*
	* @param kEvent $event
	*/
	function OnExportCancel(&$event)
	{
	$this->OnGoBack($event);
	}

	/**
	* Allows configuring export options
	*
	* @param kEvent $event
	*/
	function OnBeforeExportBegin(&$event)
	{

	}

	function OnDeleteExportPreset(&$event)
	{
	$object =& $event->GetObject();

	$items_info = $this->Application->GetVar( $event->getPrefixSpecial(true) );
	if($items_info)
	{
	list($id,$field_values) = each($items_info);
	$preset_key = $field_values['ExportPresets'];

	$export_settings = $this->Application->RecallPersistentVar('export_settings');
	if (!$export_settings) return ;
	$export_settings = unserialize($export_settings);
	if (!isset($export_settings[$event->Prefix])) return ;

	$to_delete = '';
	$export_presets = array(''=>'');
	foreach ($export_settings[$event->Prefix] as $key => $val) {
	if (implode('\|', $val['ExportColumns']) == $preset_key) {
	$to_delete = $key;
	break;
	}
	}
	if ($to_delete) {
	unset($export_settings[$event->Prefix][$to_delete]);
	$this->Application->StorePersistentVar('export_settings', serialize($export_settings));
	}
	}
	}

	/**
	* Saves changes & changes language
	*
	* @param kEvent $event
	*/
	function OnPreSaveAndChangeLanguage(&$event)
	{
	if ($this->UseTempTables($event)) {
	$event->CallSubEvent('OnPreSave');
	}

	if ($event->status == erSUCCESS) {
	$this->Application->SetVar('m_lang', $this->Application->GetVar('language'));

	$data = $this->Application->GetVar('st_id');

	if ($data) {
	$event->SetRedirectParam('st_id', $data);
	}
	}
	}

	/**
	* Used to save files uploaded via swfuploader
	*
	* @param kEvent $event
	*/
	function OnUploadFile(&$event)
	{
	$event->status = erSTOP;
	// define('DBG_SKIP_REPORTING', 0);
	$default_msg = "Flash requires that we output something or it won't fire the uploadSuccess event";

	if (!$this->Application->HttpQuery->Post) {
	// Variables {field, id, flashsid} are always submitted through POST!
	// When file size is larger, then "upload_max_filesize" (in php.ini),
	// then theese variables also are not submitted -> handle such case.
	header('HTTP/1.0 413 File size exceeds allowed limit');
	echo $default_msg;
	return ;
	}

	if (!$this->_checkFlashUploaderPermission($event)) {
	// 403 Forbidden
	header('HTTP/1.0 403 You don\'t have permissions to upload');
	echo $default_msg;
	return ;
	}

	$value = $this->Application->GetVar('Filedata');

	if (!$value \|\| ($value['error'] != UPLOAD_ERR_OK)) {
	// 413 Request Entity Too Large (file uploads disabled OR uploaded file was
	// to large for web server to accept, see "upload_max_filesize" in php.ini)
	header('HTTP/1.0 413 File size exceeds allowed limit');
	echo $default_msg;
	return ;
	}

	$tmp_path = WRITEABLE . '/tmp/';
	$fname = $value['name'];
	$id = $this->Application->GetVar('id');

	if ($id) {
	$fname = $id . '_' . $fname;
	}

	$field_name = $this->Application->GetVar('field');
	$fields = $this->Application->getUnitOption($event->Prefix, 'Fields');

	if (array_key_exists($field_name, $fields)) {
	$upload_dir = $fields[$field_name]['upload_dir'];
	}
	else {
	$virtual_fields = $this->Application->getUnitOption($event->Prefix, 'VirtualFields');
	$upload_dir = $virtual_fields[$field_name]['upload_dir'];
	}

	if (!is_writable($tmp_path)) {
	// 500 Internal Server Error
	// check both temp and live upload directory
	header('HTTP/1.0 500 Write permissions not set on the server');
	echo $default_msg;
	return ;
	}

	$upload_formatter =& $this->Application->recallObject('kUploadFormatter');
	/* @var $upload_formatter kUploadFormatter */

	$fname = $upload_formatter->_ensureUniqueFilename($tmp_path, $fname);

	move_uploaded_file($value['tmp_name'], $tmp_path.$fname);
	echo preg_replace('/^' . preg_quote($id, '/') . '_/', '', $fname);

	$this->deleteTempFiles($tmp_path);
	}

	/**
	* Delete temporary files, that won't be used for sure
	*
	* @param string $path
	*/
	function deleteTempFiles($path)
	{
	$files = glob($path . '.');
	$max_file_date = strtotime('-1 day');

	foreach ($files as $file) {
	if (filemtime($file) < $max_file_date) {
	unlink($file);
	}
	}
	}

	/**
	* Checks, that flash uploader is allowed to perform upload
	*
	* @param kEvent $event
	* @return bool
	*/
	function _checkFlashUploaderPermission(&$event)
	{
	// Flash uploader does NOT send correct cookies, so we need to make our own check
	$cookie_name = 'adm_' . $this->Application->ConfigValue('SessionCookieName');
	$this->Application->HttpQuery->Cookie['cookies_on'] = 1;
	$this->Application->HttpQuery->Cookie[$cookie_name] = $this->Application->GetVar('flashsid');

	// this prevents session from auto-expiring when KeepSessionOnBrowserClose & FireFox is used
	$this->Application->HttpQuery->Cookie[$cookie_name . '_live'] = $this->Application->GetVar('flashsid');

	$admin_ses =& $this->Application->recallObject('Session.admin');
	/* @var $admin_ses Session */

	if ($admin_ses->RecallVar('user_id') == USER_ROOT) {
	return true;
	}

	$backup_user_id = $this->Application->RecallVar('user_id'); // 1. backup user
	$this->Application->StoreVar('user_id', $admin_ses->RecallVar('user_id')); // 2. fake user_id

	$check_event = new kEvent($event->getPrefixSpecial() . ':OnProcessSelected'); // 3. event, that have "add\|edit" rule
	$check_event->setEventParam('top_prefix', $this->Application->GetTopmostPrefix($event->Prefix, true));

	$allowed_to_upload = $this->CheckPermission($check_event); // 4. check permission

	$this->Application->StoreVar('user_id', $backup_user_id); // 5. restore user id

	return $allowed_to_upload;
	}

	/**
	* Enter description here...
	*
	* @param kEvent $event
	*/
	function OnDeleteFile(&$event)
	{
	$event->status = erSTOP;

	if (strpos($this->Application->GetVar('file'), '../') !== false) {
	return ;
	}

	$object =& $event->getObject( Array ('skip_autoload' => true) );
	$options = $object->GetFieldOptions( $this->Application->GetVar('field') );

	$var_name = $event->getPrefixSpecial() . '_file_pending_actions' . $this->Application->GetVar('m_wid');
	$schedule = $this->Application->RecallVar($var_name);
	$schedule = $schedule ? unserialize($schedule) : Array ();
	$schedule[] = Array ('action' => 'delete', 'file' => $path = FULL_PATH . $options['upload_dir'] . $this->Application->GetVar('file'));
	$this->Application->StoreVar($var_name, serialize($schedule));
	}

	/**
	* Enter description here...
	*
	* @param kEvent $event
	*/
	function OnViewFile(&$event)
	{
	$file = $this->Application->GetVar('file');
	if ((strpos($file, '../') !== false) \|\| (trim($file) !== $file)) {
	// when relative paths or special chars are found template names from url, then it's hacking attempt
	return ;
	}

	$object =& $event->getObject( Array ('skip_autoload' => true));
	/* @var $object kDBItem */

	$field = $this->Application->GetVar('field');
	$options = $object->GetFieldOptions($field);

	// set current uploaded file
	if ($this->Application->GetVar('tmp')) {
	$options['upload_dir'] = WRITEBALE_BASE . '/tmp/';
	unset($options['include_path']);
	$object->SetFieldOptions($field, $options);

	$object->SetDBField($field, $this->Application->GetVar('id') . '_' . $file);
	}
	else {
	$object->SetDBField($field, $file);
	}

	// get url to uploaded file
	if ($this->Application->GetVar('thumb')) {
	$url = $object->GetField($field, $options['thumb_format']);
	}
	else {
	$url = $object->GetField($field, 'full_url'); // don't use "file_urls" format to prevent recursion
	}

	$file_helper =& $this->Application->recallObject('FileHelper');
	/* @var $file_helper FileHelper */

	$path = $file_helper->urlToPath($url);

	if (!file_exists($path)) {
	exit;
	}

	$type = mime_content_type($path);

	header('Content-Length: ' . filesize($path));
	header('Content-Type: ' . $type);
	header('Content-Disposition: inline; filename="' . $file . '"');

	safeDefine('DBG_SKIP_REPORTING', 1);

	readfile($path);
	exit;
	}

	/**
	* Validates MInput control fields
	*
	* @param kEvent $event
	*/
	function OnValidateMInputFields(&$event)
	{
	$minput_helper =& $this->Application->recallObject('MInputHelper');
	/* @var $minput_helper MInputHelper */

	$minput_helper->OnValidateMInputFields($event);
	}

	/**
	* Returns auto-complete values for ajax-dropdown
	*
	* @param kEvent $event
	*/
	function OnSuggestValues(&$event)
	{
	if (!$this->Application->isAdminUser) {
	// very careful here, because this event allows to
	// view every object field -> limit only to logged-in admins
	return ;
	}

	$event->status = erSTOP;

	$field = $this->Application->GetVar('field');
	$cur_value = $this->Application->GetVar('cur_value');

	$object =& $event->getObject();

	if (!$field \|\| !$cur_value \|\| !array_key_exists($field, $object->Fields)) {
	return ;
	}

	$limit = $this->Application->GetVar('limit');
	if (!$limit) {
	$limit = 20;
	}

	$sql = 'SELECT DISTINCT '.$field.'
	FROM '.$object->TableName.'
	WHERE '.$field.' LIKE '.$this->Conn->qstr($cur_value.'%').'
	ORDER BY '.$field.'
	LIMIT 0,' . $limit;
	$data = $this->Conn->GetCol($sql);

	$this->Application->XMLHeader();

	echo '<suggestions>';

	foreach ($data as $item) {
	echo '<item>' . htmlspecialchars($item) . '</item>';
	}

	echo '</suggestions>';
	}

	/**
	* Enter description here...
	*
	* @param kEvent $event
	*/
	function OnSaveWidths(&$event)
	{
	$event->status = erSTOP;

	$lang =& $this->Application->recallObject('lang.current');
	// header('Content-type: text/xml; charset='.$lang->GetDBField('Charset'));

	$picker_helper =& $this->Application->RecallObject('ColumnPickerHelper');
	/* @var $picker_helper kColumnPickerHelper */
	$picker_helper->PreparePicker($event->getPrefixSpecial(), $this->Application->GetVar('grid_name'));

	$picker_helper->SaveWidths($event->getPrefixSpecial(), $this->Application->GetVar('widths'));

	echo 'OK';
	}

	/**
	* Called from CSV import script after item fields
	* are set and validated, but before actual item create/update.
	* If event status is erSUCCESS, line will be imported,
	* else it will not be imported but added to skipped lines
	* and displayed in the end of import.
	* Event status is preset from import script.
	*
	* @param kEvent $event
	*/
	function OnBeforeCSVLineImport(&$event)
	{
	// abstract, for hooking
	}

	/**
	* [HOOK] Allows to add cloned subitem to given prefix
	*
	* @param kEvent $event
	*/
	function OnCloneSubItem(&$event)
	{
	$clones = $this->Application->getUnitOption($event->MasterEvent->Prefix, 'Clones');

	$subitem_prefix = $event->Prefix . '-' . preg_replace('/^#/', '', $event->MasterEvent->Prefix);
	$clones[$subitem_prefix] = Array ('ParentPrefix' => $event->Prefix);
	$this->Application->setUnitOption($event->MasterEvent->Prefix, 'Clones', $clones);
	}
	}
	\ No newline at end of file
	Index: branches/5.1.x/core/kernel/application.php
	===================================================================
	--- branches/5.1.x/core/kernel/application.php (revision 13781)
	+++ branches/5.1.x/core/kernel/application.php (revision 13782)
	@@ -1,3231 +1,3231 @@
	<?php
	/**
	* @version $Id$
	* @package In-Portal
	* @copyright Copyright (C) 1997 - 2009 Intechnic. All rights reserved.
	* @license GNU/GPL
	* In-Portal is Open Source software.
	* This means that this software may have been modified pursuant
	* the GNU General Public License, and as distributed it includes
	* or is derivative of works licensed under the GNU General Public License
	* or other free or open source software licenses.
	* See http://www.in-portal.org/license for copyright notices and details.
	*/

	/**
	* Basic class for Kernel4-based Application
	*
	* This class is a Facade for any other class which needs to deal with Kernel4 framework.<br>
	* The class incapsulates the main run-cycle of the script, provide access to all other objects in the framework.<br>
	* <br>
	* The class is a singleton, which means that there could be only one instance of kApplication in the script.<br>
	* This could be guranteed by NOT calling the class constuctor directly, but rather calling kApplication::Instance() method,
	* which returns an instance of the application. The method gurantees that it will return exactly the same instance for any call.<br>
	* See singleton pattern by GOF.
	* @package kernel4
	*/

	defined('FULL_PATH') or die('restricted access!');

	class kApplication {

	/**
	* Is true, when Init method was called already, prevents double initialization
	*
	* @var bool
	*/
	var $InitDone = false;

	/**
	* Holds internal NParser object
	* @access private
	* @var NParser
	*/
	var $Parser;

	/**
	* Holds parser output buffer
	* @access private
	* @var string
	*/
	var $HTML;

	/**
	* Prevents request from beeing proceeded twice in case if application init is called mere then one time
	*
	* @var bool
	* @todo This is not good anyway (by Alex)
	*/
	var $RequestProcessed = false;

	/**
	* The main Factory used to create
	* almost any class of kernel and
	* modules
	*
	* @access private
	* @var kFactory
	*/
	var $Factory;

	/**
	* All ConfigurationValues table content (hash) here
	*
	* @var Array
	* @access private
	*/
	var $ConfigHash = Array();

	/**
	* Ids of config variables used in current run (for caching)
	*
	* @var Array
	* @access private
	*/
	var $ConfigCacheIds = array();

	/**
	* Template names, that will be used instead of regular templates
	*
	* @var Array
	*/
	var $ReplacementTemplates = Array ();

	/**
	* Mod-Rewrite listeners used during url building and parsing
	*
	* @var Array
	*/
	var $RewriteListeners = Array ();

	/**
	* Reference to debugger
	*
	* @var Debugger
	*/
	var $Debugger = null;

	/**
	* Holds all phrases used
	* in code and template
	*
	* @var PhrasesCache
	*/
	var $Phrases;

	/**
	* Modules table content, key - module name
	*
	* @var Array
	*/
	var $ModuleInfo = Array();

	/**
	* Holds DBConnection
	*
	* @var kDBConnection
	*/
	var $Conn = null;

	/**
	* Maintains list of user-defined error handlers
	*
	* @var Array
	*/
	var $errorHandlers = Array();


	// performance needs:
	/**
	* Holds a refererence to httpquery
	*
	* @var kHttpQuery
	*/
	var $HttpQuery = null;

	/**
	* Holds a reference to UnitConfigReader
	*
	* @var kUnitConfigReader
	*/
	var $UnitConfigReader = null;

	/**
	* Holds a reference to Session
	*
	* @var Session
	*/
	var $Session = null;

	/**
	* Holds a ref to kEventManager
	*
	* @var kEventManager
	*/
	var $EventManager = null;

	/**
	* Ref to itself, needed because everybody used to write $this->Application, even inside kApplication
	*
	* @var kApplication
	*/
	var $Application = null;

	/**
	* Ref for TemplatesChache
	*
	* @var TemplatesCache
	*/
	var $TemplatesCache = null;

	/**
	* Physical template name mapping to their template names based on structure
	*
	* @var Array
	*/
	var $structureTemplateMapping = Array ();

	var $CompilationCache = array(); //used when compiling templates
	var $CachedProcessors = array(); //used when running compiled templates

	var $LambdaElements = 1; // for autonumbering unnamed RenderElements [any better place for this prop? KT]

	/**
	* Holds current NParser tag while parsing, can be used in error messages to display template file and line
	*
	* @var _BlockTag
	*/
	var $CurrentNTag = null;

	/**
	* Object of memory caching class
	*
	* @var kCache
	*/
	var $memoryCache = null;

	/**
	* Tells, that administrator has authentificated in administrative console
	* Should be used to manipulate data change OR data restrictioning!
	*
	* @var bool
	*/
	var $isAdminUser = false;

	/**
	* Tells, that admin version of "index.php" was used, nothing more!
	* Should be used to manipulate data display!
	*
	* @var bool
	*/
	var $isAdmin = false;

	/**
	* Instance of site domain object
	*
	* @var kDBItem
	*/
	var $siteDomain = null;

	/**
	* Returns kApplication instance anywhere in the script.
	*
	* This method should be used to get single kApplication object instance anywhere in the
	* Kernel-based application. The method is guranteed to return the SAME instance of kApplication.
	* Anywhere in the script you could write:
	* <code>
	* $application =& kApplication::Instance();
	* </code>
	* or in an object:
	* <code>
	* $this->Application =& kApplication::Instance();
	* </code>
	* to get the instance of kApplication. Note that we call the Instance method as STATIC - directly from the class.
	* To use descendand of standard kApplication class in your project you would need to define APPLICATION_CLASS constant
	* BEFORE calling kApplication::Instance() for the first time. If APPLICATION_CLASS is not defined the method would
	* create and return default KernelApplication instance.
	* @static
	* @access public
	* @return kApplication
	*/
	function &Instance()
	{
	static $instance = false;

	if (!$instance) {
	$class = defined('APPLICATION_CLASS') ? APPLICATION_CLASS : 'kApplication';
	$instance = new $class();
	$instance->Application =& $instance;
	}

	return $instance;
	}

	/**
	* Initializes the Application
	*
	* @access public
	* @see kHTTPQuery
	* @see Session
	* @see TemplatesCache
	* @return bool Was Init actually made now or before
	*/
	function Init()
	{
	if($this->InitDone) {
	return false;
	}

	$this->isAdmin = constOn('ADMIN');

	if (!constOn('SKIP_OUT_COMPRESSION')) {
	ob_start(); // collect any output from method (other then tags) into buffer
	}

	if (defined('DEBUG_MODE') && $this->isDebugMode() && constOn('DBG_PROFILE_MEMORY')) {
	$this->Debugger->appendMemoryUsage('Application before Init:');
	}
	if (!$this->isDebugMode() && !constOn('DBG_ZEND_PRESENT')) {
	error_reporting(0);
	ini_set('display_errors', 0);
	}
	if (!constOn('DBG_ZEND_PRESENT')) {
	$error_handler = set_error_handler( Array (&$this, 'handleError') );
	if ($error_handler) {
	// wrap around previous error handler, if any was set
	$this->errorHandlers[] = $error_handler;
	}
	}

	$this->Conn = new kDBConnection(SQL_TYPE, Array(&$this, 'handleSQLError') );
	$this->Conn->debugMode = $this->isDebugMode();
	$this->Conn->Connect(SQL_SERVER, SQL_USER, SQL_PASS, SQL_DB);

	$this->Factory = new kFactory();
	$this->registerDefaultClasses();
	$this->Phrases = new PhrasesCache();
	$this->memoryCache =& $this->Factory->makeClass('Cache');
	$this->EventManager =& $this->Factory->makeClass('EventManager');
	$this->Factory->Storage['EventManager'] =& $this->EventManager;
	$this->RegisterDefaultBuildEvents();
	$this->SetDefaultConstants();

	if (defined('DEBUG_MODE') && $this->isDebugMode()) {
	$this->Debugger->appendTimestamp('Before UnitConfigReader');
	}

	$this->UnitConfigReader =& $this->recallObject('kUnitConfigReader');
	$this->UnitConfigReader->scanModules(MODULES_PATH);
	$this->registerModuleConstants();

	if (defined('DEBUG_MODE') && $this->isDebugMode()) {
	$this->Debugger->appendTimestamp('After UnitConfigReader');
	}

	define('MOD_REWRITE', $this->ConfigValue('UseModRewrite') && !$this->isAdmin ? 1 : 0);

	$this->HttpQuery =& $this->recallObject('HTTPQuery');

	if (defined('DEBUG_MODE') && $this->isDebugMode()) {
	$this->Debugger->appendTimestamp('Processed HTTPQuery initial');
	}

	$this->Session =& $this->recallObject('Session');

	if (defined('DEBUG_MODE') && $this->isDebugMode()) {
	$this->Debugger->appendTimestamp('Processed Session');
	}

	if (!$this->RecallVar('UserGroups')) {
	$user_groups = trim($this->Session->GetField('GroupList'), ',');
	if (!$user_groups) {
	$user_groups = $this->ConfigValue('User_GuestGroup');
	}

	$this->Session->SetField('GroupList', $user_groups);
	$this->StoreVar('UserGroups', $user_groups, true); // true for optional
	}

	$this->LoadStructureTemplateMapping();
	$this->HttpQuery->AfterInit();

	$this->Session->ValidateExpired();

	if (defined('DEBUG_MODE') && $this->isDebugMode()) {
	$this->Debugger->appendTimestamp('Processed HTTPQuery AfterInit');
	}

	$this->LoadCache();
	$this->InitConfig();

	$site_timezone = $this->ConfigValue('Config_Site_Time');

	if ($site_timezone) {
	putenv('TZ=' . $site_timezone);
	}

	if (defined('DEBUG_MODE') && $this->isDebugMode()) {
	$this->Debugger->appendTimestamp('Loaded cache and phrases');
	}

	$this->ValidateLogin(); // must be called before AfterConfigRead, because current user should be available there

	$this->UnitConfigReader->AfterConfigRead();

	if (defined('DEBUG_MODE') && $this->isDebugMode()) {
	$this->Debugger->appendTimestamp('Processed AfterConfigRead');
	}

	if ($this->GetVar('m_cat_id') === false) {
	$this->SetVar('m_cat_id', 0);
	}

	if (!$this->RecallVar('curr_iso')) {
	$this->StoreVar('curr_iso', $this->GetPrimaryCurrency(), true); // true for optional
	}

	$visit_id = $this->RecallVar('visit_id');

	if ($visit_id !== false) {
	$this->SetVar('visits_id', $visit_id);
	}

	$language =& $this->recallObject( 'lang.current', null, Array('live_table' => true) );
	if (preg_match('/utf-8/', $language->GetDBField('Charset'))) {
	setlocale(LC_ALL, 'en_US.UTF-8');
	mb_internal_encoding('UTF-8');
	}

	if (defined('DEBUG_MODE') && $this->isDebugMode()) {
	$this->Debugger->profileFinish('kernel4_startup');
	}

	$this->InitDone = true;

	$this->HandleEvent( new kEvent('adm:OnStartup') );

	return true;
	}

	/**
	* Returns module information. Searches module by requested field
	*
	* @param string $field
	* @param mixed $value
	* @param string field value to returns, if not specified, then return all fields
	* @param string field to return
	* @return Array
	*/
	function findModule($field, $value, $return_field = null)
	{
	$found = false;
	foreach ($this->ModuleInfo as $module_name => $module_info) {
	if (strtolower($module_info[$field]) == strtolower($value)) {
	$found = true;
	break;
	}
	}

	if ($found) {
	return isset($return_field) ? $module_info[$return_field] : $module_info;
	}

	return false;
	}

	function refreshModuleInfo()
	{
	if (defined('IS_INSTALL') && IS_INSTALL && !$this->TableFound('Modules')) {
	$this->registerModuleConstants();
	return false;
	}

	$modules_helper =& $this->recallObject('ModulesHelper');
	/* @var $modules_helper kModulesHelper */

	$sql = 'SELECT *
	FROM ' . TABLE_PREFIX . 'Modules
	WHERE Loaded = 1
	ORDER BY LoadOrder';
	$this->ModuleInfo = $this->Conn->Query($sql, 'Name');

	$sql = 'SELECT *
	FROM '.TABLE_PREFIX.'Modules
	WHERE '.$modules_helper->getWhereClause().'
	ORDER BY LoadOrder';
	$this->ModuleInfo = $this->Conn->Query($sql, 'Name');

	$this->registerModuleConstants();
	}

	/**
	* Checks if passed language id if valid and sets it to primary otherwise
	*
	*/
	function VerifyLanguageId()
	{
	$language_id = $this->GetVar('m_lang');

	if (!$language_id) {
	$language_id = 'default';
	}

	$this->SetVar('lang.current_id', $language_id);
	$this->SetVar('m_lang', $language_id);

	$lang_mode = $this->GetVar('lang_mode');
	$this->SetVar('lang_mode', '');

	$lang =& $this->recallObject('lang.current');
	/* @var $lang kDBItem */

	if (!$lang->isLoaded() \|\| (!$this->isAdmin && !$lang->GetDBField('Enabled'))) {
	if (!defined('IS_INSTALL')) {
	$this->ApplicationDie('Unknown or disabled language');
	}
	}

	$this->SetVar('lang_mode',$lang_mode);
	}

	/**
	* Checks if passed theme id if valid and sets it to primary otherwise
	*
	*/
	function VerifyThemeId()
	{
	if ($this->isAdmin) {
	safeDefine('THEMES_PATH', '/core/admin_templates');
	return;
	}

	$path = $this->GetFrontThemePath();
	if ($path === false) {
	$this->ApplicationDie('No Primary Theme Selected or Current Theme is Unknown or Disabled');
	}
	safeDefine('THEMES_PATH', $path);

	/*$theme_id = $this->GetVar('m_theme');
	if (!$theme_id) {
	$theme_id = $this->GetDefaultThemeId();
	if (!$theme_id) {
	if (!defined('IS_INSTALL')) $this->ApplicationDie('No Primary Theme Selected');
	}
	}
	$this->SetVar('m_theme', $theme_id);
	$this->SetVar('theme.current_id', $theme_id ); // KOSTJA: this is to fool theme' getPassedId
	$theme =& $this->recallObject('theme.current');
	if (!$theme->IsLoaded() \|\| !$theme->GetDBField('Enabled')) {
	if (!defined('IS_INSTALL')) $this->ApplicationDie('Unknown or disabled theme');
	}
	safeDefine('THEMES_PATH', '/themes/'.$theme->GetDBField('Name'));*/
	}

	function GetFrontThemePath($force=0)
	{
	static $path=null;
	if (!$force && isset($path)) return $path;

	$theme_id = $this->GetVar('m_theme');
	if (!$theme_id) {
	// $theme_id = $this->GetDefaultThemeId(1); //1 to force front-end mode!
	$theme_id = 'default';
	}
	$this->SetVar('m_theme', $theme_id);
	$this->SetVar('theme.current_id', $theme_id ); // KOSTJA: this is to fool theme' getPassedId
	$theme =& $this->recallObject('theme.current');
	if (!$theme->IsLoaded() \|\| !$theme->GetDBField('Enabled')) {
	return false;
	}
	$path = '/themes/'.$theme->GetDBField('Name');
	return $path;
	}

	function GetDefaultLanguageId($init = false)
	{
	$cache_key = 'primary_language_info[%LangSerial%]';
	$language_info = $this->getCache($cache_key);

	if ($language_info === false) {
	// cache primary language info first
	$table = $this->getUnitOption('lang', 'TableName');
	$id_field = $this->getUnitOption('lang', 'IDField');

	$this->Conn->nextQueryCachable = true;
	$sql = 'SELECT ' . $id_field . ', IF(AdminInterfaceLang, "Admin", "Front") AS LanguageKey
	FROM ' . $table . '
	WHERE (AdminInterfaceLang = 1 OR PrimaryLang = 1) AND (Enabled = 1)';
	$language_info = $this->Conn->GetCol($sql, 'LanguageKey');

	if ($language_info !== false) {
	$this->setCache($cache_key, $language_info);
	}
	}

	$language_key = ($this->isAdmin && $init) \|\| count($language_info) == 1 ? 'Admin' : 'Front';

	if (array_key_exists($language_key, $language_info) && $language_info[$language_key] > 0) {
	// get from cache
	return $language_info[$language_key];
	}

	$language_id = $language_info && array_key_exists($language_key, $language_info) ? $language_info[$language_key] : false;

	if (!$language_id && defined('IS_INSTALL') && IS_INSTALL) {
	$language_id = 1;
	}

	return $language_id;
	}

	function GetDefaultThemeId($force_front=0)
	{
	static $theme_id = 0;

	if ($theme_id > 0) {
	return $theme_id;
	}

	if (constOn('DBG_FORCE_THEME')) {
	$theme_id = DBG_FORCE_THEME;
	}
	elseif (!$force_front && $this->isAdmin) {
	$theme_id = 999;
	}
	else {
	$cache_key = 'primary_theme[%ThemeSerial%]';
	$theme_id = $this->getCache($cache_key);

	if ($theme_id === false) {
	$this->Conn->nextQueryCachable = true;
	$sql = 'SELECT ' . $this->getUnitOption('theme', 'IDField') . '
	FROM ' . $this->getUnitOption('theme', 'TableName') . '
	WHERE (PrimaryTheme = 1) AND (Enabled = 1)';
	$theme_id = $this->Conn->GetOne($sql);

	if ($theme_id !== false) {
	$this->setCache($cache_key, $theme_id);
	}
	}
	}

	return $theme_id;
	}

	/**
	* Returns site primary currency ISO code
	*
	* @return string
	*/
	function GetPrimaryCurrency()
	{
	$cache_key = 'primary_currency[%CurrSerial%][%SiteDomainSerial%]:' . $this->siteDomainField('DomainId');
	$currency_iso = $this->getCache($cache_key);

	if ($currency_iso === false) {
	if ($this->isModuleEnabled('In-Commerce')) {
	$this->Conn->nextQueryCachable = true;
	$currency_id = $this->siteDomainField('PrimaryCurrencyId');

	$sql = 'SELECT ISO
	FROM ' . $this->getUnitOption('curr', 'TableName') . '
	WHERE ' . ($currency_id > 0 ? 'CurrencyId = ' . $currency_id : 'IsPrimary = 1');
	$currency_iso = $this->Conn->GetOne($sql);
	}
	else {
	$currency_iso = 'USD';
	}

	$this->setCache($cache_key, $currency_iso);
	}

	return $currency_iso;
	}

	/**
	* Returns site domain field. When none of site domains are found false is returned.
	*
	* @param string $field
	* @param bool $formatted
	* @param string $format
	*/
	function siteDomainField($field, $formatted = false, $format = null)
	{
	if ($this->isAdmin) {
	// don't apply any filtering in administrative console
	return false;
	}

	if (!$this->siteDomain) {
	$this->siteDomain =& $this->recallObject('site-domain.current');
	/* @var $site_domain kDBItem */
	}

	if ($this->siteDomain->isLoaded()) {
	return $formatted ? $this->siteDomain->GetField($field, $format) : $this->siteDomain->GetDBField($field);
	}

	return false;
	}

	/**
	* Registers default classes such as ItemController, GridController and LoginController
	*
	* Called automatically while initializing Application
	* @access private
	* @return void
	*/
	function RegisterDefaultClasses()
	{
	$this->registerClass('kTempTablesHandler', KERNEL_PATH . '/utility/temp_handler.php');
	$this->registerClass('kEventManager', KERNEL_PATH . '/event_manager.php', 'EventManager');
	$this->registerClass('kUnitConfigReader', KERNEL_PATH . '/utility/unit_config_reader.php');

	$this->registerClass('kArray', KERNEL_PATH . '/utility/params.php');
	$this->registerClass('Params', KERNEL_PATH . '/utility/params.php');
	$this->registerClass('Params', KERNEL_PATH . '/utility/params.php', 'kActions');
	$this->registerClass('kCache', KERNEL_PATH . '/utility/cache.php', 'Cache', 'Params');
	$this->registerClass('kHTTPQuery', KERNEL_PATH . '/utility/http_query.php', 'HTTPQuery', 'Params');

	$this->registerClass('kHelper', KERNEL_PATH . '/kbase.php');
	$this->registerClass('kMultipleFilter', KERNEL_PATH . '/utility/filters.php');

	$this->registerClass('Session', KERNEL_PATH . '/session/session.php');
	$this->registerClass('SessionStorage', KERNEL_PATH . '/session/session.php');
	$this->registerClass('InpSession', KERNEL_PATH . '/session/inp_session.php', 'Session');
	$this->registerClass('InpSessionStorage', KERNEL_PATH . '/session/inp_session.php', 'SessionStorage');

	$this->registerClass('kTagProcessor', KERNEL_PATH . '/processors/tag_processor.php');
	$this->registerClass('kMainTagProcessor', KERNEL_PATH . '/processors/main_processor.php','m_TagProcessor', 'kTagProcessor');

	$this->registerClass('kDBList', KERNEL_PATH . '/db/dblist.php');
	$this->registerClass('kDBItem', KERNEL_PATH . '/db/dbitem.php');
	$this->registerClass('kDBEventHandler', KERNEL_PATH . '/db/db_event_handler.php');
	$this->registerClass('kDBTagProcessor', KERNEL_PATH . '/db/db_tag_processor.php', null, 'kTagProcessor');
	$this->registerClass('kCatDBItem', KERNEL_PATH . '/db/cat_dbitem.php');
	$this->registerClass('kCatDBList', KERNEL_PATH . '/db/cat_dblist.php');
	$this->registerClass('kCatDBEventHandler', KERNEL_PATH . '/db/cat_event_handler.php');
	$this->registerClass('kCatDBTagProcessor', KERNEL_PATH . '/db/cat_tag_processor.php');

	$this->registerClass('NParser', KERNEL_PATH . '/nparser/nparser.php');
	$this->registerClass('TemplatesCache', KERNEL_PATH . '/nparser/template_cache.php', null, Array ('kHelper', 'kDBTagProcessor'));

	$this->registerClass('kEmailSendingHelper', KERNEL_PATH . '/utility/email_send.php', 'EmailSender', 'kHelper');
	$this->registerClass('kSocket', KERNEL_PATH . '/utility/socket.php', 'Socket');

	if (file_exists(MODULES_PATH . '/in-commerce/units/currencies/currency_rates.php')) {
	$this->registerClass('kCurrencyRates', MODULES_PATH . '/in-commerce/units/currencies/currency_rates.php');
	}

	// do not move to config - this helper is used before configs are read
	$this->registerClass('kModulesHelper', KERNEL_PATH . '/../units/helpers/modules_helper.php', 'ModulesHelper');
	}

	function RegisterDefaultBuildEvents()
	{
	$event_manager =& $this->recallObject('EventManager');
	$event_manager->registerBuildEvent('kTempTablesHandler', 'OnTempHandlerBuild');
	}

	/**
	* Returns cached category informaton by given cache name. All given category
	* information is recached, when at least one of 4 caches is missing.
	*
	* @param int $category_id
	* @param string $name cache name = {filenames, category_designs, category_tree}
	* @return string
	*/
	function getCategoryCache($category_id, $name)
	{
	$serial_name = '[%CIDSerial:' . $category_id . '%]';
	$cache_key = $name . $serial_name;
	$ret = $this->getCache($cache_key);

	if ($ret === false) {
	if (!$category_id) {
	// don't query database for "Home" category (ID = 0), because it doesn't exist in database
	return false;
	}

	// this allows to save 2 sql queries for each category
	$this->Conn->nextQueryCachable = true;
	$sql = 'SELECT NamedParentPath, CachedTemplate, TreeLeft, TreeRight
	FROM ' . TABLE_PREFIX . 'Category
	WHERE CategoryId = ' . (int)$category_id;
	$category_data = $this->Conn->GetRow($sql);

	if ($category_data !== false) {
	// only direct links to category pages work (symlinks, container pages and so on won't work)
	$this->setCache('filenames' . $serial_name, $category_data['NamedParentPath']);
	$this->setCache('category_designs' . $serial_name, ltrim($category_data['CachedTemplate'], '/'));
	$this->setCache('category_tree' . $serial_name, $category_data['TreeLeft'] . ';' . $category_data['TreeRight']);
	}
	}

	return $this->getCache($cache_key);
	}

	/**
	* Returns item's filename that corresponds id passed. If possible, then get it from cache
	*
	* @param string $prefix
	* @param int $id
	* @param int $category_id
	* @return string
	*/
	function getFilename($prefix, $id, $category_id = null)
	{
	if ($prefix == 'c') {
	trigger_error('Method "<strong>' . __FUNCTION__ . '</strong>" no longer work with "<strong>c</strong>" prefix. Please use "<strong>getCategoryCache</strong>" method instead.', E_USER_ERROR);
	return false;
	}

	$category_id = isset($category_id) ? $category_id : $this->GetVar('m_cat_id');

	$cache_key = 'filenames[%' . $this->incrementCacheSerial($prefix, $id, false) . '%]:' . (int)$category_id;
	$filename = $this->getCache($cache_key);

	if ($filename === false) {
	$this->Conn->nextQueryCachable = true;
	$sql = 'SELECT ResourceId
	FROM ' . $this->getUnitOption($prefix, 'TableName') . '
	WHERE ' . $this->getUnitOption($prefix, 'IDField') . ' = ' . $this->Conn->qstr($id);
	$resource_id = $this->Conn->GetOne($sql);

	$this->Conn->nextQueryCachable = true;
	$sql = 'SELECT Filename
	FROM ' . TABLE_PREFIX . 'CategoryItems
	WHERE (ItemResourceId = ' . $resource_id . ') AND (CategoryId = ' . (int)$category_id . ')';
	$filename = $this->Conn->GetOne($sql);

	if ($filename !== false) {
	$this->setCache($cache_key, $filename);
	}
	}

	return $filename;
	}

	/**
	* Returns caching type (none, memory, temporary)
	*
	* @return int
	*/
	function isCachingType($caching_type)
	{
	return $this->memoryCache->getCachingType() == $caching_type;
	}

	/**
	* Increments serial based on prefix and it's ID (optional)
	*
	* @param string $prefix
	* @param int $id ID (value of IDField) or ForeignKeyField:ID
	* @param bool $increment
	*/
	function incrementCacheSerial($prefix, $id = null, $increment = true)
	{
	$pascal_case_prefix = implode('', array_map('ucfirst', explode('-', $prefix)));
	$serial_name = $pascal_case_prefix . (isset($id) ? 'IDSerial:' . $id : 'Serial');

	if ($increment) {
	if ($this->isCachingType(CACHING_TYPE_MEMORY)) {
	if (defined('DEBUG_MODE') && DEBUG_MODE && $this->isDebugMode()) {
	$this->Application->Debugger->appendHTML('Incrementing serial: <strong>' . $serial_name . '</strong>.');
	}

	$this->setCache($serial_name, (int)$this->getCache($serial_name) + 1);
	}

	if (!defined('IS_INSTALL') \|\| !IS_INSTALL) {
	// delete cached mod-rewrite urls related to given prefix and id
	$delete_clause = isset($id) ? $prefix . ':' . $id : $prefix;

	$sql = 'DELETE FROM ' . TABLE_PREFIX . 'CachedUrls
	WHERE Prefixes LIKE ' . $this->Conn->qstr('%\|' . $delete_clause . '\|%');
	$this->Conn->Query($sql);
	}
	}

	return $serial_name;
	}

	/**
	* Adds new value to cache $cache_name and identified by key $key
	*
	* @param int $key key name to add to cache
	* @param mixed $value value of chached record
	* @param int $expiration when value expires (0 - doesn't expire)
	*/
	function setCache($key, $value, $expiration = 0)
	{
	return $this->memoryCache->setCache($key, $value, $expiration);
	}

	/**
	* Sets value to database cache
	*
	* @param string $name
	* @param mixed $value
	* @param int $expiration
	*/
	function setDBCache($name, &$value, $expiration = false)
	{
	if ((int)$expiration <= 0) {
	$expiration = -1;
	}

	$fields_hash = Array (
	'VarName' => $name,
	'Data' => &$value,
	'Cached' => adodb_mktime(),
	'LifeTime' => (int)$expiration,
	);

	$this->Conn->nextQueryCachable = true;
	$this->Conn->doInsert($fields_hash, TABLE_PREFIX . 'Cache', 'REPLACE');
	}

	/**
	* Returns cached $key value from cache named $cache_name
	*
	* @param int $key key name from cache
	* @param bool $store_locally store data locally after retrieved
	* @return mixed
	*/
	function getCache($key, $store_locally = true)
	{
	return $this->memoryCache->getCache($key, $store_locally);
	}

	/**
	* Returns value from database cache
	*
	* @param string $name key name
	* @return mixed
	*/
	function getDBCache($name)
	{
	$this->Conn->nextQueryCachable = true;

	$sql = 'SELECT Data, Cached, LifeTime
	FROM ' . TABLE_PREFIX . 'Cache
	WHERE VarName = ' . $this->Conn->qstr($name);
	$data = $this->Conn->GetRow($sql);

	if ($data) {
	$lifetime = (int)$data['LifeTime']; // in seconds
	if (($lifetime > 0) && ($data['Cached'] + $lifetime < adodb_mktime())) {
	// delete expired
	$this->Conn->nextQueryCachable = true;

	$sql = 'DELETE FROM ' . TABLE_PREFIX . 'Cache
	WHERE VarName = ' . $this->Conn->qstr($name);
	$this->Conn->Query($sql);

	return false;
	}

	return $data['Data'];
	}

	return false;
	}

	/**
	* Deletes key from cache
	*
	* @param string $key
	*/
	function deleteCache($key)
	{
	$this->memoryCache->delete($key);
	}

	/**
	* Deletes key from database cache
	*
	* @param string $name
	*/
	function deleteDBCache($name)
	{
	$sql = 'DELETE FROM ' . TABLE_PREFIX . 'Cache
	WHERE VarName = ' . $this->Conn->qstr($name);
	$this->Conn->Query($sql);
	}

	/**
	* Defines default constants if it's not defined before - in config.php
	*
	* @access private
	*/
	function SetDefaultConstants() // it's defined in startup.php - can be removed??
	{
	safeDefine('SERVER_NAME', $_SERVER['HTTP_HOST']);
	}

	/**
	* Registers each module specific constants if any found
	*
	*/
	function registerModuleConstants()
	{
	if (file_exists(KERNEL_PATH.'/constants.php')) {
	k4_include_once(KERNEL_PATH.'/constants.php');
	}

	if (!$this->ModuleInfo) {
	return false;
	}

	foreach ($this->ModuleInfo as $module_name => $module_info) {
	$contants_file = FULL_PATH . '/' . $module_info['Path'] . 'constants.php';

	if (file_exists($contants_file)) {
	k4_include_once($contants_file);
	}
	}

	return true;
	}

	function ProcessRequest()
	{
	$event_manager =& $this->recallObject('EventManager');
	/* @var $event_manager kEventManager */

	if (defined('DEBUG_MODE') && $this->isDebugMode() && constOn('DBG_SHOW_HTTPQUERY')) {
	$this->Debugger->appendHTML('HTTPQuery:');
	$this->Debugger->dumpVars($this->HttpQuery->_Params);
	}

	$event_manager->ProcessRequest();
	$event_manager->RunRegularEvents(reBEFORE);
	$this->RequestProcessed = true;
	}

	/**
	* Actually runs the parser against current template and stores parsing result
	*
	* This method gets t variable passed to the script, loads the template given in t variable and
	* parses it. The result is store in {@link $this->HTML} property.
	* @access public
	* @return void
	*/
	function Run()
	{
	if (defined('DEBUG_MODE') && $this->isDebugMode() && constOn('DBG_PROFILE_MEMORY')) {
	$this->Debugger->appendMemoryUsage('Application before Run:');
	}

	if ($this->isAdminUser) {
	// for permission checking in events & templates
	$this->LinkVar('module'); // for common configuration templates
	$this->LinkVar('module_key'); // for common search templates
	$this->LinkVar('section'); // for common configuration templates

	if ($this->GetVar('m_opener') == 'p') {
	$this->LinkVar('main_prefix'); // window prefix, that opened selector
	$this->LinkVar('dst_field'); // field to set value choosed in selector
	}

	if ($this->GetVar('ajax') == 'yes' && !$this->GetVar('debug_ajax')) {
	// hide debug output from ajax requests automatically
	define('DBG_SKIP_REPORTING', 1);
	}
	}
	elseif ($this->GetVar('admin')) {
	// viewing front-end through admin's frame
	$admin_session =& $this->Application->recallObject('Session.admin');
	$user = (int)$admin_session->RecallVar('user_id'); // in case, when no valid admin session found
	$perm_helper =& $this->recallObject('PermissionsHelper');
	/* @var $perm_helper kPermissionsHelper */

	if ($perm_helper->CheckUserPermission($user, 'CATEGORY.MODIFY', 0, $this->ModuleInfo['Core']['RootCat'])) {
	// user can edit cms blocks
	$editing_mode = $this->GetVar('editing_mode');
	define('EDITING_MODE', $editing_mode ? $editing_mode : EDITING_MODE_BROWSE);
	}
	}

	safeDefine('EDITING_MODE', ''); // user can't edit anything
	$this->Phrases->setPhraseEditing();

	if (!$this->RequestProcessed) $this->ProcessRequest();

	$this->InitParser();
	$t = $this->GetVar('t');

	if (!$this->TemplatesCache->TemplateExists($t) && !$this->isAdmin) {
	$cms_handler =& $this->recallObject('st_EventHandler');
	/* @var $cms_handler CategoriesEventHandler */

	$t = ltrim($cms_handler->GetDesignTemplate(), '/');

	if (defined('DEBUG_MODE') && $this->isDebugMode()) {
	$this->Debugger->appendHTML('<strong>Design Template</strong>: ' . $t . '; <strong>CategoryID</strong>: ' . $this->GetVar('m_cat_id'));
	}
	}
	/*else {
	$cms_handler->SetCatByTemplate();
	}*/

	if (defined('DEBUG_MODE') && $this->isDebugMode() && constOn('DBG_PROFILE_MEMORY')) {
	$this->Debugger->appendMemoryUsage('Application before Parsing:');
	}

	$this->HTML = $this->Parser->Run($t);

	if (defined('DEBUG_MODE') && $this->isDebugMode() && constOn('DBG_PROFILE_MEMORY')) {
	$this->Debugger->appendMemoryUsage('Application after Parsing:');
	}
	}

	function InitParser($theme_name = false)
	{
	if( !is_object($this->Parser) ) {
	$this->Parser =& $this->recallObject('NParser');
	$this->TemplatesCache =& $this->recallObject('TemplatesCache');
	}

	$this->TemplatesCache->forceThemeName = $theme_name;
	}

	/**
	* Send the parser results to browser
	*
	* Actually send everything stored in {@link $this->HTML}, to the browser by echoing it.
	* @access public
	* @return void
	*/
	function Done()
	{
	$this->HandleEvent( new kEvent('adm:OnBeforeShutdown') );

	$debug_mode = defined('DEBUG_MODE') && $this->isDebugMode();

	if ($debug_mode && constOn('DBG_PROFILE_MEMORY')) {
	$this->Debugger->appendMemoryUsage('Application before Done:');
	}

	if ($debug_mode) {
	$this->EventManager->RunRegularEvents(reAFTER);
	$this->Session->SaveData();

	if (constOn('DBG_CACHE')) {
	$this->memoryCache->printStatistics();
	}

	$this->HTML = ob_get_clean() . $this->HTML . $this->Debugger->printReport(true);
	}
	else {
	// send "Set-Cookie" header before any output is made
	$this->Session->SetSession();

	$this->HTML = ob_get_clean() . $this->HTML;
	}

	if ($this->UseOutputCompression()) {
	$compression_level = $this->ConfigValue('OutputCompressionLevel');
	if ($compression_level < 0 \|\| $compression_level > 9) {
	$compression_level = 7;
	}

	header('Content-Encoding: gzip');
	echo gzencode($this->HTML, $compression_level);
	}
	else {
	echo $this->HTML;
	}

	$this->UpdateCache();
	flush();

	if (!$debug_mode) {
	$this->EventManager->RunRegularEvents(reAFTER);
	$this->Session->SaveData();
	}

	if (defined('DBG_CAPTURE_STATISTICS') && DBG_CAPTURE_STATISTICS && !$this->isAdmin) {
	$this->_storeStatistics();
	}
	}

	/**
	* Stores script execution statistics to database
	*
	*/
	function _storeStatistics()
	{
	global $start;

	$script_time = getmicrotime() - $start;
	$query_statistics = $this->Conn->getQueryStatistics(); // time & count

	$sql = 'SELECT *
	FROM ' . TABLE_PREFIX . 'StatisticsCapture
	WHERE TemplateName = ' . $this->Conn->qstr( $this->GetVar('t') );
	$data = $this->Conn->GetRow($sql);

	if ($data) {
	$this->_updateAverageStatistics($data, 'ScriptTime', $script_time);
	$this->_updateAverageStatistics($data, 'SqlTime', $query_statistics['time']);
	$this->_updateAverageStatistics($data, 'SqlCount', $query_statistics['count']);

	$data['Hits']++;
	$data['LastHit'] = adodb_mktime();

	$this->Conn->doUpdate($data, TABLE_PREFIX . 'StatisticsCapture', 'StatisticsId = ' . $data['StatisticsId']);
	}
	else {
	$data['ScriptTimeMin'] = $data['ScriptTimeAvg'] = $data['ScriptTimeMax'] = $script_time;
	$data['SqlTimeMin'] = $data['SqlTimeAvg'] = $data['SqlTimeMax'] = $query_statistics['time'];
	$data['SqlCountMin'] = $data['SqlCountAvg'] = $data['SqlCountMax'] = $query_statistics['count'];
	$data['TemplateName'] = $this->GetVar('t');
	$data['Hits'] = 1;
	$data['LastHit'] = adodb_mktime();
	$this->Conn->doInsert($data, TABLE_PREFIX . 'StatisticsCapture');
	}
	}

	/**
	* Calculates average time for statistics
	*
	* @param Array $data
	* @param string $field_prefix
	* @param float $current_value
	*/
	function _updateAverageStatistics(&$data, $field_prefix, $current_value)
	{
	$data[$field_prefix . 'Avg'] = (($data['Hits'] * $data[$field_prefix . 'Avg']) + $current_value) / ($data['Hits'] + 1);

	if ($current_value < $data[$field_prefix . 'Min']) {
	$data[$field_prefix . 'Min'] = $current_value;
	}

	if ($current_value > $data[$field_prefix . 'Max']) {
	$data[$field_prefix . 'Max'] = $current_value;
	}
	}

	function logSlowQuery($slow_sql, $time)
	{
	$query_crc = crc32($slow_sql);

	$sql = 'SELECT *
	FROM ' . TABLE_PREFIX . 'SlowSqlCapture
	WHERE QueryCrc = ' . $query_crc;
	$data = $this->Conn->Query($sql, null, true);

	if ($data) {
	$this->_updateAverageStatistics($data, 'Time', $time);

	$template_names = explode(',', $data['TemplateNames']);
	array_push($template_names, $this->GetVar('t'));
	$data['TemplateNames'] = implode(',', array_unique($template_names));

	$data['Hits']++;
	$data['LastHit'] = adodb_mktime();

	$this->Conn->doUpdate($data, TABLE_PREFIX . 'SlowSqlCapture', 'CaptureId = ' . $data['CaptureId']);
	}
	else {
	$data['TimeMin'] = $data['TimeAvg'] = $data['TimeMax'] = $time;
	$data['SqlQuery'] = $slow_sql;
	$data['QueryCrc'] = $query_crc;
	$data['TemplateNames'] = $this->GetVar('t');
	$data['Hits'] = 1;
	$data['LastHit'] = adodb_mktime();

	$this->Conn->doInsert($data, TABLE_PREFIX . 'SlowSqlCapture');
	}
	}

	/**
	* Checks if output compression options is available
	*
	* @return string
	*/
	function UseOutputCompression()
	{
	if (constOn('IS_INSTALL') \|\| constOn('DBG_ZEND_PRESENT') \|\| constOn('SKIP_OUT_COMPRESSION')) return false;
	return $this->ConfigValue('UseOutputCompression') && function_exists('gzencode') && strstr($_SERVER['HTTP_ACCEPT_ENCODING'], 'gzip');
	}

	// Facade

	/**
	* Returns current session id (SID)
	* @access public
	* @return longint
	*/
	function GetSID()
	{
	$session =& $this->recallObject('Session');
	return $session->GetID();
	}

	function DestroySession()
	{
	$session =& $this->recallObject('Session');
	$session->Destroy();
	}

	/**
	* Returns variable passed to the script as GET/POST/COOKIE
	*
	* @access public
	* @param string $name Name of variable to retrieve
	* @param int $default default value returned in case if varible not present
	* @return mixed
	*/
	function GetVar($name, $default = false)
	{
	return isset($this->HttpQuery->_Params[$name]) ? $this->HttpQuery->_Params[$name] : $default;
	}

	/**
	* Returns ALL variables passed to the script as GET/POST/COOKIE
	*
	* @access public
	* @return array
	*/
	function GetVars()
	{
	return $this->HttpQuery->GetParams();
	}

	/**
	* Set the variable 'as it was passed to the script through GET/POST/COOKIE'
	*
	* This could be useful to set the variable when you know that
	* other objects would relay on variable passed from GET/POST/COOKIE
	* or you could use SetVar() / GetVar() pairs to pass the values between different objects.<br>
	*
	* This method is formerly known as $this->Session->SetProperty.
	* @param string $var Variable name to set
	* @param mixed $val Variable value
	* @access public
	* @return void
	*/
	function SetVar($var,$val)
	{
	return $this->HttpQuery->Set($var, $val);
	}

	/**
	* Deletes kHTTPQuery variable
	*
	* @param string $var
	* @todo think about method name
	*/
	function DeleteVar($var)
	{
	return $this->HttpQuery->Remove($var);
	}

	/**
	* Deletes Session variable
	*
	* @param string $var
	*/
	function RemoveVar($var)
	{
	return $this->Session->RemoveVar($var);
	}

	function RemovePersistentVar($var)
	{
	return $this->Session->RemovePersistentVar($var);
	}

	/**
	* Restores Session variable to it's db version
	*
	* @param string $var
	*/
	function RestoreVar($var)
	{
	return $this->Session->RestoreVar($var);
	}

	/**
	* Returns session variable value
	*
	* Return value of $var variable stored in Session. An optional default value could be passed as second parameter.
	*
	* @see SimpleSession
	* @access public
	* @param string $var Variable name
	* @param mixed $default Default value to return if no $var variable found in session
	* @return mixed
	*/
	function RecallVar($var,$default=false)
	{
	return $this->Session->RecallVar($var,$default);
	}

	function RecallPersistentVar($var, $default = false)
	{
	return $this->Session->RecallPersistentVar($var, $default);
	}

	/**
	* Stores variable $val in session under name $var
	*
	* Use this method to store variable in session. Later this variable could be recalled.
	* @see RecallVar
	* @access public
	* @param string $var Variable name
	* @param mixed $val Variable value
	*/
	function StoreVar($var, $val, $optional = false)
	{
	$session =& $this->recallObject('Session');
	$this->Session->StoreVar($var, $val, $optional);
	}

	- function StorePersistentVar($var, $val)
	+ function StorePersistentVar($var, $val, $optional = false)
	{
	- $this->Session->StorePersistentVar($var, $val);
	+ $this->Session->StorePersistentVar($var, $val, $optional);
	}

	function StoreVarDefault($var, $val, $optional=false)
	{
	$session =& $this->recallObject('Session');
	$this->Session->StoreVarDefault($var, $val, $optional);
	}

	/**
	* Links HTTP Query variable with session variable
	*
	* If variable $var is passed in HTTP Query it is stored in session for later use. If it's not passed it's recalled from session.
	* This method could be used for making sure that GetVar will return query or session value for given
	* variable, when query variable should overwrite session (and be stored there for later use).<br>
	* This could be used for passing item's ID into popup with multiple tab -
	* in popup script you just need to call LinkVar('id', 'current_id') before first use of GetVar('id').
	* After that you can be sure that GetVar('id') will return passed id or id passed earlier and stored in session
	* @access public
	* @param string $var HTTP Query (GPC) variable name
	* @param mixed $ses_var Session variable name
	* @param mixed $default Default variable value
	*/
	function LinkVar($var, $ses_var = null, $default = '', $optional = false)
	{
	if (!isset($ses_var)) $ses_var = $var;
	if ($this->GetVar($var) !== false) {
	$this->StoreVar($ses_var, $this->GetVar($var), $optional);
	}
	else {
	$this->SetVar($var, $this->RecallVar($ses_var, $default));
	}
	}

	/**
	* Returns variable from HTTP Query, or from session if not passed in HTTP Query
	*
	* The same as LinkVar, but also returns the variable value taken from HTTP Query if passed, or from session if not passed.
	* Returns the default value if variable does not exist in session and was not passed in HTTP Query
	*
	* @see LinkVar
	* @access public
	* @param string $var HTTP Query (GPC) variable name
	* @param mixed $ses_var Session variable name
	* @param mixed $default Default variable value
	* @return mixed
	*/
	function GetLinkedVar($var, $ses_var = null, $default = '')
	{
	$this->LinkVar($var, $ses_var, $default);
	return $this->GetVar($var);
	}

	function AddBlock($name, $tpl)
	{
	$this->cache[$name] = $tpl;
	}

	function ProcessParsedTag($prefix, $tag, $params)
	{
	$processor = $this->Parser->GetProcessor($prefix);

	return $processor->ProcessParsedTag($tag, $params, $prefix);
	}

	/**
	* Return ADODB Connection object
	*
	* Returns ADODB Connection object already connected to the project database, configurable in config.php
	* @access public
	* @return kDBConnection
	*/
	function &GetADODBConnection()
	{
	return $this->Conn;
	}

	/**
	* Allows to parse given block name or include template
	*
	* @param Array $params Parameters to pass to block. Reserved parameter "name" used to specify block name.
	* @param Array $pass_params Forces to pass current parser params to this block/template. Use with cauntion, because you can accidently pass "block_no_data" parameter.
	* @param bool $as_template
	* @return string
	*/
	function ParseBlock($params, $pass_params = 0, $as_template = false)
	{
	if (substr($params['name'], 0, 5) == 'html:') {
	return substr($params['name'], 6);
	}

	return $this->Parser->ParseBlock($params, $pass_params, $as_template);
	}

	/**
	* Checks, that we have given block defined
	*
	* @param string $name
	* @return bool
	*/
	function ParserBlockFound($name)
	{
	return $this->Parser->blockFound($name);
	}

	/**
	* Allows to include template with a given name and given parameters
	*
	* @param Array $params Parameters to pass to template. Reserved parameter "name" used to specify template name.
	* @return string
	*/
	function IncludeTemplate($params)
	{
	return $this->Parser->IncludeTemplate($params, isset($params['is_silent']) ? 1 : 0);
	}

	/**
	* Returns index file, that could be passed as parameter to method, as parameter to tag and as constant or not passed at all
	*
	* @param string $prefix
	* @param string $index_file
	* @param Array $params
	* @return string
	*/
	function getIndexFile($prefix, $index_file, &$params)
	{
	if (isset($params['index_file'])) {
	$index_file = $params['index_file'];
	unset($params['index_file']);
	return $index_file;
	}

	if (isset($index_file)) {
	return $index_file;
	}

	if (defined('INDEX_FILE')) {
	return INDEX_FILE;
	}

	$cut_prefix = trim(BASE_PATH, '/').'/'.trim($prefix, '/');
	return trim(preg_replace('/'.preg_quote($cut_prefix, '/').'(.*)/', '\\1', $_SERVER['PHP_SELF']), '/');
	}

	/**
	* Return href for template
	*
	* @access public
	* @param string $t Template path
	* @var string $prefix index.php prefix - could be blank, 'admin'
	*/
	function HREF($t, $prefix = '', $params = null, $index_file = null)
	{
	static $theme_id = null;

	if (!isset($theme_id)) {
	$theme_id = $this->GetVar('m_theme');
	}

	if (!$t) {
	// when template not specified, use current
	$t = $this->GetVar('t');
	}

	$t = preg_replace('/^Content\//i', '', $t);

	if (substr($t, -4) == '.tpl') {
	// cut template extension (deprecated link format)
	$t = substr($t, 0, strlen($t) - 4);
	}

	if (substr($t, 0, 3) == 'id:') {
	// link to structure page using it's id
	$params['m_cat_id'] = substr($t, 3);
	$t = $this->structureTemplateMapping[$t];
	}

	if (array_key_exists('use_section', $params)) {
	$use_section = $params['use_section'];
	unset($params['use_section']);
	}

	if (isset($use_section) && $use_section && array_key_exists($t . ':' . $theme_id, $this->structureTemplateMapping)) {
	// structure template corresponding to given physical template
	$t = $this->structureTemplateMapping[$t . ':' . $theme_id];
	unset($params['use_section']);
	}

	if (preg_match('/external:(.*)/', $t, $rets)) {
	// external url
	return $rets[1];
	}

	if ($this->isAdmin && $prefix == '') $prefix = ADMIN_DIRECTORY;
	if ($this->isAdmin && $prefix == '_FRONT_END_') $prefix = '';

	$index_file = $this->getIndexFile($prefix, $index_file, $params);

	if (isset($params['_auto_prefix_'])) {
	unset($params['_auto_prefix_']); // this is parser-related param, do not need to pass it here
	}

	$ssl = isset($params['__SSL__']) ? $params['__SSL__'] : null;
	if ($ssl !== null) {
	$session =& $this->recallObject('Session');
	/* @var $session Session */

	$target_url = rtrim($this->BaseURL('', $ssl, false), '/');
	$cookie_url = trim($session->CookieDomain . $session->CookiePath, '/.');

	// set session to GET_ONLY, to pass sid only if sid is REAL AND session is set
	if (!preg_match('#' . preg_quote($cookie_url) . '#', $target_url) && $session->SessionSet) {
	// when SSL<->NON-SSL redirect to different domain pass SID in url
	$session->SetMode(smGET_ONLY);
	}
	}

	if (isset($params['opener']) && $params['opener'] == 'u') {
	$wid = $this->Application->GetVar('m_wid');
	$stack_name = rtrim('opener_stack_'.$wid, '_');
	$opener_stack = $this->RecallVar($stack_name);

	if ($opener_stack && $opener_stack != serialize(Array())) {
	$opener_stack = unserialize($opener_stack);
	list($index_file, $env) = explode('\|', $opener_stack[count($opener_stack) - 1]);
	$ret = $this->BaseURL($prefix, $ssl).$index_file.'?'.ENV_VAR_NAME.'='.$env;
	if ( getArrayValue($params,'escape') ) $ret = addslashes($ret);

	if (isset($params['m_opener']) && $params['m_opener'] == 'u') {
	array_pop($opener_stack);
	if (!$opener_stack) {
	$this->RemoveVar($stack_name);
	// remove popups last templates, because popup is closing now
	$this->RemoveVar('last_template_'.$wid);
	$this->RemoveVar('last_template_popup_'.$wid);

	// don't save popups last templates again :)
	$this->SetVar('skip_last_template', 1);
	}
	else {
	$this->StoreVar($stack_name, serialize($opener_stack));
	}

	/*// store window relations
	$window_relations = $this->Application->RecallVar('window_relations');
	$window_relations = $window_relations ? unserialize($window_relations) : Array ();
	if (array_key_exists($wid, $window_relations)) {
	unset($window_relations[$wid]);
	$this->Application->StoreVar('window_relations', serialize($window_relations));
	}*/
	}
	return $ret;
	}
	else {
	//define('DBG_REDIRECT', 1);
	$t = $this->GetVar('t');
	}
	}

	$pass = isset($params['pass']) ? $params['pass'] : '';

	// pass events with url
	$pass_events = false;
	if( isset($params['pass_events']) )
	{
	$pass_events = $params['pass_events'];
	unset($params['pass_events']);
	}

	$map_link = '';
	if( isset($params['anchor']) )
	{
	$map_link = '#'.$params['anchor'];
	unset($params['anchor']);
	}

	if ( isset($params['no_amp']) )
	{
	$params['__URLENCODE__'] = $params['no_amp'];
	unset($params['no_amp']);
	}

	$no_rewrite = false;
	if( isset($params['__NO_REWRITE__']) )
	{
	$no_rewrite = true;
	unset($params['__NO_REWRITE__']);
	}

	$force_rewrite = false;
	if( isset($params['__MOD_REWRITE__']) )
	{
	$force_rewrite = true;
	unset($params['__MOD_REWRITE__']);
	}

	$force_no_sid = false;
	if( isset($params['__NO_SID__']) )
	{
	$force_no_sid = true;
	unset($params['__NO_SID__']);
	}

	// append pass through variables to each link to be build
	// $params = array_merge_recursive2($this->getPassThroughVariables($params), $params);
	$params = array_merge($this->getPassThroughVariables($params), $params);

	if ($force_rewrite \|\| ($this->RewriteURLs($ssl) && !$no_rewrite)) {
	static $rewrite_listeners_done = false;

	if (!$rewrite_listeners_done) {
	$mod_rewrite_helper =& $this->recallObject('ModRewriteHelper');
	/* @var $mod_rewrite_helper kModRewriteHelper */

	$mod_rewrite_helper->initRewriteListeners();

	$rewrite_listeners_done = true;
	}

	$session =& $this->recallObject('Session');

	if ($session->NeedQueryString() && !$force_no_sid) {
	$params['sid'] = $this->GetSID();
	}

	$url = $this->BuildEnv_NEW($t, $params, $pass, $pass_events);
	$ret = $this->BaseURL($prefix, $ssl).$url.$map_link;
	}
	else {
	unset($params['pass_category']); // we don't need to pass it when mod_rewrite is off
	$env = $this->BuildEnv($t, $params, $pass, $pass_events);
	$ret = $this->BaseURL($prefix, $ssl).$index_file.'?'.$env.$map_link;
	}

	return $ret;
	}

	/**
	* Returns variables with values that should be passed throught with this link + variable list
	*
	* @param Array $params
	* @return Array
	*/
	function getPassThroughVariables(&$params)
	{
	static $cached_pass_through = null;

	if (isset($params['no_pass_through']) && $params['no_pass_through']) {
	unset($params['no_pass_through']);
	return Array();
	}

	// because pass through is not changed during script run, then we can cache it
	if (is_null($cached_pass_through)) {

	$cached_pass_through = Array();
	$pass_through = $this->Application->GetVar('pass_through');

	if ($pass_through) {
	// names of variables to pass to each link
	$cached_pass_through['pass_through'] = $pass_through;
	$pass_through = explode(',', $pass_through);
	foreach ($pass_through as $pass_through_var) {
	$cached_pass_through[$pass_through_var] = $this->Application->GetVar($pass_through_var);
	}
	}

	}

	return $cached_pass_through;
	}


	/**
	* Returns sorted array of passed prefixes (to build url from)
	*
	* @param string $pass
	* @return Array
	*/
	function getPassInfo($pass = 'all')
	{
	if (!$pass) $pass = 'all';
	$pass = trim(
	preg_replace(
	'/(?<=,\|\\A)all(?=,\|\\z)/',
	trim($this->GetVar('passed'), ','),
	trim($pass, ',')
	),
	',');

	if (!$pass) {
	return Array();
	}

	$pass_info = array_unique( explode(',', $pass) ); // array( prefix[.special], prefix[.special] ...

	// we need to keep that sorting despite the sorting below, because this sorts prefixes with same priority by name
	sort($pass_info, SORT_STRING); // to be prefix1,prefix1.special1,prefix1.special2,prefix3.specialX

	foreach ($pass_info as $prefix) {
	list ($prefix_only, ) = explode('.', $prefix, 2);
	$sorted[$prefix] = $this->getUnitOption($prefix_only, 'RewritePriority', 0);
	}

	asort($sorted, SORT_NUMERIC);
	$pass_info = array_keys($sorted);

	// ensure that "m" prefix is at the beginning
	$main_index = array_search('m', $pass_info);
	if ($main_index !== false) {
	unset($pass_info[$main_index]);
	array_unshift($pass_info, 'm');
	}
	return $pass_info;
	}

	function BuildEnv_NEW($t, $params, $pass='all', $pass_events = false)
	{
	if ($this->GetVar('admin') \|\| (array_key_exists('admin', $params) && $params['admin'])) {
	$params['admin'] = 1;

	if (!array_key_exists('editing_mode', $params)) {
	$params['editing_mode'] = EDITING_MODE;
	}
	}

	$ret = '';
	$env = '';

	$encode = false;

	if (isset($params['__URLENCODE__'])) {
	$encode = $params['__URLENCODE__'];
	unset($params['__URLENCODE__']);
	}

	if (isset($params['__SSL__'])) {
	unset($params['__SSL__']);
	}

	$catalog_item_found = false;
	$pass_info = $this->getPassInfo($pass);

	if ($pass_info) {
	if ($pass_info[0] == 'm') {
	array_shift($pass_info);
	}

	$inject_parts = Array (); // url parts for beginning of url
	$params['t'] = $t; // make template available for rewrite listeners
	$params['pass_template'] = true; // by default we keep given template in resulting url

	if (!array_key_exists('pass_category', $params)) {
	$params['pass_category'] = false; // by default we don't keep categories in url
	}

	foreach ($pass_info as $pass_index => $pass_element) {
	list ($prefix) = explode('.', $pass_element);
	$catalog_item = $this->findModule('Var', $prefix) && $this->getUnitOption($prefix, 'CatalogItem');

	if (array_key_exists($prefix, $this->RewriteListeners)) {
	// if next prefix is same as current, but with special => exclude current prefix from url
	$next_prefix = array_key_exists($pass_index + 1, $pass_info) ? $pass_info[$pass_index + 1] : false;
	if ($next_prefix) {
	$next_prefix = substr($next_prefix, 0, strlen($prefix) + 1);
	if ($prefix . '.' == $next_prefix) {
	continue;
	}
	}

	// rewrited url part
	$url_part = $this->BuildModuleEnv_NEW($pass_element, $params, $pass_events);

	if (is_string($url_part) && $url_part) {
	$ret .= $url_part . '/';

	if ($catalog_item) {
	// pass category later only for catalog items
	$catalog_item_found = true;
	}
	}
	elseif (is_array($url_part)) {
	// rewrite listener want to insert something at the beginning of url too
	if ($url_part[0]) {
	$inject_parts[] = $url_part[0];
	}

	if ($url_part[1]) {
	$ret .= $url_part[1] . '/';
	}

	if ($catalog_item) {
	// pass category later only for catalog items
	$catalog_item_found = true;
	}
	} elseif ($url_part === false) {
	// rewrite listener decided not to rewrite given $pass_element
	$env .= ':' . $this->BuildModuleEnv($pass_element, $params, $pass_events);
	}
	}
	else {
	$env .= ':' . $this->BuildModuleEnv($pass_element, $params, $pass_events);
	}
	}

	if ($catalog_item_found \|\| preg_match('/c\.[-\d]*/', implode(',', $pass_info))) {
	// "c" prefix is present -> keep category
	$params['pass_category'] = true;
	}

	$params['inject_parts'] = $inject_parts;

	$ret = $this->BuildModuleEnv_NEW('m', $params, $pass_events) . '/' . $ret;
	$cat_processed = array_key_exists('category_processed', $params) && $params['category_processed'];

	// remove tempporary parameters used by listeners
	unset($params['t'], $params['inject_parts'], $params['pass_template'], $params['pass_category'], $params['category_processed']);

	if (array_key_exists('url_ending', $params)) {
	$ret = trim($ret, '/') . $params['url_ending'];
	unset($params['url_ending']);
	}
	else {
	$ret = trim($ret, '/') . MOD_REWRITE_URL_ENDING;
	}

	if ($env) {
	$params[ENV_VAR_NAME] = ltrim($env, ':');
	}
	}

	unset($params['pass'], $params['opener'], $params['m_event']);

	if (array_key_exists('escape', $params) && $params['escape']) {
	$ret = addslashes($ret);
	unset($params['escape']);
	}

	$ret = str_replace('%2F', '/', urlencode($ret));

	$params_str = '';
	$join_string = $encode ? '&' : '&';

	foreach ($params as $param => $value) {
	$params_str .= $join_string . $param . '=' . $value;
	}

	if ($params_str) {
	$ret .= '?' . substr($params_str, strlen($join_string));
	}

	if ($encode) {
	$ret = str_replace('\\', '%5C', $ret);
	}

	return $ret;
	}

	function BuildModuleEnv_NEW($prefix_special, &$params, $keep_events = false)
	{
	list ($prefix) = explode('.', $prefix_special);

	$url_parts = Array ();
	$listener = $this->RewriteListeners[$prefix][0];

	$ret = $listener[0]->$listener[1](REWRITE_MODE_BUILD, $prefix_special, $params, $url_parts, $keep_events);

	return $ret;
	}

	/**
	* Builds env part that corresponds prefix passed
	*
	* @param string $prefix_special item's prefix & [special]
	* @param Array $params url params
	* @param bool $pass_events
	*/
	function BuildModuleEnv($prefix_special, &$params, $pass_events = false)
	{
	list($prefix) = explode('.', $prefix_special);
	$query_vars = $this->getUnitOption($prefix, 'QueryString');

	//if pass events is off and event is not implicity passed
	if( !$pass_events && !isset($params[$prefix_special.'_event']) ) {
	$params[$prefix_special.'_event'] = ''; // remove event from url if requested
	//otherwise it will use value from get_var
	}

	if(!$query_vars) return '';

	$tmp_string = Array(0 => $prefix_special);
	foreach($query_vars as $index => $var_name)
	{
	//if value passed in params use it, otherwise use current from application
	$var_name = $prefix_special.'_'.$var_name;
	$tmp_string[$index] = isset( $params[$var_name] ) ? $params[$var_name] : $this->GetVar($var_name);
	if ( isset($params[$var_name]) ) unset( $params[$var_name] );
	}

	$escaped = array();
	foreach ($tmp_string as $tmp_val) {
	$escaped[] = str_replace(Array('-',':'), Array('\-','\:'), $tmp_val);
	}

	$ret = implode('-', $escaped);
	if ($this->getUnitOption($prefix, 'PortalStyleEnv') == true)
	{
	$ret = preg_replace('/^([a-zA-Z]+)-([0-9]+)-(.*)/','\\1\\2-\\3', $ret);
	}
	return $ret;
	}

	function BuildEnv($t, $params, $pass='all', $pass_events = false, $env_var = true)
	{
	if ($this->GetVar('admin') \|\| (array_key_exists('admin', $params) && $params['admin'])) {
	$params['admin'] = 1;

	if (!array_key_exists('editing_mode', $params)) {
	$params['editing_mode'] = EDITING_MODE;
	}
	}

	$session =& $this->recallObject('Session');
	$ssl = isset($params['__SSL__']) ? $params['__SSL__'] : 0;
	$sid = $session->NeedQueryString() && !$this->RewriteURLs($ssl) ? $this->GetSID() : '';
	// if (getArrayValue($params,'admin') == 1) $sid = $this->GetSID();

	$ret = '';
	if ($env_var) {
	$ret = ENV_VAR_NAME.'=';
	}

	$ret .= $sid . '-'; // SID-TEMPLATE

	$encode = false;
	if (isset($params['__URLENCODE__'])) {
	$encode = $params['__URLENCODE__'];
	unset($params['__URLENCODE__']);
	}

	if (isset($params['__SSL__'])) {
	unset($params['__SSL__']);
	}

	$env_string = '';
	$category_id = isset($params['m_cat_id']) ? $params['m_cat_id'] : $this->GetVar('m_cat_id');

	$item_id = false;
	$pass_info = $this->getPassInfo($pass);
	if ($pass_info) {
	if ($pass_info[0] == 'm') array_shift($pass_info);
	foreach ($pass_info as $pass_element) {
	list($prefix) = explode('.', $pass_element);
	$require_rewrite = $this->findModule('Var', $prefix);
	if ($require_rewrite) {
	$item_id = isset($params[$pass_element.'_id']) ? $params[$pass_element.'_id'] : $this->GetVar($pass_element.'_id');
	}
	$env_string .= ':'.$this->BuildModuleEnv($pass_element, $params, $pass_events);
	}
	}

	if (strtolower($t) == '__default__') {
	if (is_numeric($item_id)) {
	$mod_rw_helper =& $this->Application->recallObject('ModRewriteHelper');
	/* @var $mod_rw_helper kModRewriteHelper */

	$t = $mod_rw_helper->GetItemTemplate($category_id, $pass_element); // $pass_element should be the last processed element
	// $t = $this->getCategoryCache($category_id, 'item_templates');
	}
	elseif ($category_id) {
	$t = strtolower(preg_replace('/^Content\//i', '', $this->getCategoryCache($category_id, 'filenames') ));
	}
	else {
	$t = 'index';
	}
	}

	$ret .= $t.':'.$this->BuildModuleEnv('m', $params, $pass_events).$env_string;

	unset($params['pass'], $params['opener'], $params['m_event']);

	if (array_key_exists('escape', $params) && $params['escape']) {
	$ret = addslashes($ret);
	unset($params['escape']);
	}

	$join_string = $encode ? '&' : '&';
	$params_str = '';
	foreach ($params as $param => $value)
	{
	$params_str .= $join_string.$param.'='.$value;
	}
	$ret .= $params_str;

	if ($encode) {
	$ret = str_replace('\\', '%5C', $ret);
	}
	return $ret;
	}

	function BaseURL($prefix = '', $ssl = null, $add_port = true)
	{
	if ($ssl === null) {
	// stay on same encryption level
	return PROTOCOL . SERVER_NAME . ($add_port && defined('PORT') ? ':' . PORT : '') . rtrim(BASE_PATH, '/') . $prefix . '/';
	}

	if ($ssl) {
	// going from http:// to https://
	$base_url = $this->isAdmin ? $this->ConfigValue('AdminSSL_URL') : false;

	if (!$base_url) {
	$ssl_url = $this->siteDomainField('SSLUrl');
	$base_url = $ssl_url !== false ? $ssl_url : $this->ConfigValue('SSL_URL');
	}

	return rtrim($base_url, '/') . $prefix . '/';
	}

	// going from https:// to http://
	$domain = $this->siteDomainField('DomainName');

	if ($domain === false) {
	$domain = DOMAIN;
	}

	return 'http://' . $domain . ($add_port && defined('PORT') ? ':' . PORT : '') . rtrim($this->ConfigValue('Site_Path'), '/') . $prefix . '/';
	}

	function Redirect($t = '', $params = Array(), $prefix = '', $index_file = null)
	{
	$js_redirect = getArrayValue($params, 'js_redirect');

	if ($t == '' \|\| $t === true) {
	$t = $this->GetVar('t');
	}

	// pass prefixes and special from previous url
	if (array_key_exists('js_redirect', $params)) {
	unset($params['js_redirect']);
	}

	// allows to send custom responce code along with redirect header
	if (array_key_exists('response_code', $params)) {
	$response_code = (int)$params['response_code'];
	unset($params['response_code']);
	}
	else {
	$response_code = 302; // Found
	}

	if (!array_key_exists('pass', $params)) {
	$params['pass'] = 'all';
	}

	if ($this->GetVar('ajax') == 'yes' && $t == $this->GetVar('t')) {
	// redirects to the same template as current
	$params['ajax'] = 'yes';
	}

	$params['__URLENCODE__'] = 1;
	$location = $this->HREF($t, $prefix, $params, $index_file);

	if ($this->isDebugMode() && (constOn('DBG_REDIRECT') \|\| (constOn('DBG_RAISE_ON_WARNINGS') && $this->Application->Debugger->WarningCount))) {
	$this->Debugger->appendTrace();
	echo "<b>Debug output above!!!</b> Proceed to redirect: <a href=\"$location\">$location</a><br>";
	}
	else {
	if ($js_redirect) {
	// show "redirect" template instead of redirecting,
	// because "Set-Cookie" header won't work, when "Location"
	// header is used later
	$this->SetVar('t', 'redirect');
	$this->SetVar('redirect_to', $location);

	// make all additional parameters available on "redirect" template too
	foreach ($params as $name => $value) {
	$this->SetVar($name, $value);
	}

	return true;
	}
	else {
	if ($this->GetVar('ajax') == 'yes' && $t != $this->GetVar('t')) {
	// redirection to other then current template during ajax request
	echo '#redirect#' . $location;
	}
	elseif (headers_sent() != '') {
	// some output occured -> redirect using javascript
	echo '<script type="text/javascript">window.location.href = \'' . $location . '\';</script>';
	}
	else {
	// no output before -> redirect using HTTP header

	// header('HTTP/1.1 302 Found');
	header('Location: ' . $location, true, $response_code);
	}
	}
	}

	ob_end_flush();
	// session expiration is called from session initialization,
	// that's why $this->Session may be not defined here
	$session =& $this->Application->recallObject('Session');
	/* @var $session Session */

	$this->HandleEvent( new kEvent('adm:OnBeforeShutdown') );
	$session->SaveData();
	exit;
	}

	function Phrase($label, $allow_editing = true, $use_admin = false)
	{
	return $this->Phrases->GetPhrase($label, $allow_editing, $use_admin);
	}

	/**
	* Replace language tags in exclamation marks found in text
	*
	* @param string $text
	* @param bool $force_escape force escaping, not escaping of resulting string
	* @return string
	* @access public
	*/
	function ReplaceLanguageTags($text, $force_escape=null)
	{
	// !!!!!!!!
	// if( !is_object($this->Phrases) ) $this->Debugger->appendTrace();
	return $this->Phrases->ReplaceLanguageTags($text,$force_escape);
	}

	/**
	* Checks if user is logged in, and creates
	* user object if so. User object can be recalled
	* later using "u.current" prefix_special. Also you may
	* get user id by getting "u.current_id" variable.
	*
	* @access private
	*/
	function ValidateLogin()
	{
	$session =& $this->recallObject('Session');
	$user_id = $session->GetField('PortalUserId');

	if (!$user_id && $user_id != USER_ROOT) {
	$user_id = USER_GUEST;
	}

	$this->SetVar('u.current_id', $user_id);

	if (!$this->isAdmin) {
	// needed for "profile edit", "registration" forms ON FRONT ONLY
	$this->SetVar('u_id', $user_id);
	}

	$this->StoreVar('user_id', $user_id, $user_id == USER_GUEST); // storing Guest user_id (-2) is optional

	$this->isAdminUser = $this->isAdmin && $this->LoggedIn();

	if ($this->GetVar('expired') == 1) {
	// this parameter is set only from admin
	$user =& $this->recallObject('u.current');
	$user->SetError('ValidateLogin', 'session_expired', 'la_text_sess_expired');
	}

	if (($user_id != USER_GUEST) && constOn('DBG_REQUREST_LOG') ) {
	$http_query =& $this->recallObject('HTTPQuery');
	$http_query->writeRequestLog(DBG_REQUREST_LOG);
	}

	if ($user_id != USER_GUEST) {
	// normal users + root
	$this->LoadPersistentVars();
	}
	}

	/**
	* Loads current user persistent session data
	*
	*/
	function LoadPersistentVars()
	{
	$this->Session->LoadPersistentVars();
	}

	function LoadCache()
	{
	// TODO: maybe language part isn't required, since same phrase from different languages have one ID now
	$cache_key = $this->GetVar('t') . $this->GetVar('m_theme') . $this->GetVar('m_lang') . $this->isAdmin;

	$sql = 'SELECT PhraseList, ConfigVariables
	FROM ' . TABLE_PREFIX . 'PhraseCache
	WHERE Template = ' . $this->Conn->qstr( md5($cache_key) );
	$res = $this->Conn->GetRow($sql);

	if ($res) {
	$this->Caches['PhraseList'] = $res['PhraseList'] ? explode(',', $res['PhraseList']) : Array ();
	$config_ids = $res['ConfigVariables'] ? explode(',', $res['ConfigVariables']) : Array ();

	if (isset($this->Caches['ConfigVariables'])) {
	$config_ids = array_diff($config_ids, $this->Caches['ConfigVariables']);
	}
	}
	else {
	$config_ids = Array ();
	}

	$this->Phrases->Init('phrases');
	$this->Caches['ConfigVariables'] = $config_ids;
	$this->ConfigCacheIds = $config_ids;
	}

	/**
	* Loads template mapping for Front-End
	*
	*/
	function LoadStructureTemplateMapping()
	{
	if (!$this->isAdmin) {
	$category_helper =& $this->Application->recallObject('CategoryHelper');
	/* @var $category_helper CategoryHelper */

	$this->structureTemplateMapping = $category_helper->getTemplateMapping();
	}
	}

	function UpdateCache()
	{
	$update = false;
	//something changed
	$update = $update \|\| $this->Phrases->NeedsCacheUpdate();
	$update = $update \|\| (count($this->ConfigCacheIds) && $this->ConfigCacheIds != $this->Caches['ConfigVariables']);

	if ($update) {
	$cache_key = $this->GetVar('t').$this->GetVar('m_theme').$this->GetVar('m_lang').$this->isAdmin;
	$query = sprintf("REPLACE %s (PhraseList, CacheDate, Template, ConfigVariables)
	VALUES (%s, %s, %s, %s)",
	TABLE_PREFIX.'PhraseCache',
	$this->Conn->qstr(join(',', $this->Phrases->Ids)),
	adodb_mktime(),
	$this->Conn->qstr(md5($cache_key)),
	$this->Conn->qstr(implode(',', array_unique($this->ConfigCacheIds))));
	$this->Conn->Query($query);
	}
	}

	function InitConfig()
	{
	if (isset($this->Caches['ConfigVariables']) && count($this->Caches['ConfigVariables']) > 0) {
	$sql = 'SELECT VariableValue, VariableName
	FROM ' . TABLE_PREFIX . 'ConfigurationValues
	WHERE VariableId IN (' . implode(',', $this->Caches['ConfigVariables']) . ')';
	$this->ConfigHash = array_merge($this->ConfigHash, $this->Conn->GetCol($sql, 'VariableName'));
	}
	}

	/**
	* Returns configuration option value by name
	*
	* @param string $name
	* @return string
	*/
	function ConfigValue($name)
	{
	if ($name == 'Smtp_AdminMailFrom') {
	$res = $this->siteDomainField('AdminEmail');

	if ($res) {
	return $res;
	}
	}

	$res = array_key_exists($name, $this->ConfigHash) ? $this->ConfigHash[$name] : false;
	if ($res !== false) {
	return $res;
	}

	if (defined('IS_INSTALL') && IS_INSTALL && !$this->TableFound('ConfigurationValues')) {
	return false;
	}

	$sql = 'SELECT VariableId, VariableValue
	FROM '.TABLE_PREFIX.'ConfigurationValues
	WHERE VariableName = '.$this->Conn->qstr($name);
	$res = $this->Conn->GetRow($sql);

	if ($res !== false) {
	$this->ConfigHash[$name] = $res['VariableValue'];
	$this->ConfigCacheIds[] = $res['VariableId'];
	return $res['VariableValue'];
	}

	return false;
	}

	function UpdateConfigCache()
	{
	if ($this->ConfigCacheIds) {

	}
	}

	/**
	* Allows to process any type of event
	*
	* @param kEvent $event
	* @access public
	* @author Alex
	*/
	function HandleEvent(&$event, $params=null, $specificParams=null)
	{
	if ( isset($params) ) {
	$event = new kEvent( $params, $specificParams );
	}

	if (!isset($this->EventManager)) {
	$this->EventManager =& $this->recallObject('EventManager');
	}

	$this->EventManager->HandleEvent($event);
	}

	/**
	* Registers new class in the factory
	*
	* @param string $real_class Real name of class as in class declaration
	* @param string $file Filename in what $real_class is declared
	* @param string $pseudo_class Name under this class object will be accessed using getObject method
	* @param Array $dependecies List of classes required for this class functioning
	* @access public
	* @author Alex
	*/
	function registerClass($real_class, $file, $pseudo_class = null, $dependecies = Array() )
	{
	$this->Factory->registerClass($real_class, $file, $pseudo_class, $dependecies);
	}

	/**
	* Add $class_name to required classes list for $depended_class class.
	* All required class files are included before $depended_class file is included
	*
	* @param string $depended_class
	* @param string $class_name
	* @author Alex
	*/
	function registerDependency($depended_class, $class_name)
	{
	$this->Factory->registerDependency($depended_class, $class_name);
	}

	/**
	* Registers Hook from subprefix event to master prefix event
	*
	* @param string $hookto_prefix
	* @param string $hookto_special
	* @param string $hookto_event
	* @param string $mode
	* @param string $do_prefix
	* @param string $do_special
	* @param string $do_event
	* @param string $conditional
	* @access public
	* @todo take care of a lot parameters passed
	* @author Kostja
	*/
	function registerHook($hookto_prefix, $hookto_special, $hookto_event, $mode, $do_prefix, $do_special, $do_event, $conditional)
	{
	$event_manager =& $this->recallObject('EventManager');
	$event_manager->registerHook($hookto_prefix, $hookto_special, $hookto_event, $mode, $do_prefix, $do_special, $do_event, $conditional);
	}

	/**
	* Allows one TagProcessor tag act as other TagProcessor tag
	*
	* @param Array $tag_info
	* @author Kostja
	*/
	function registerAggregateTag($tag_info)
	{
	$aggregator =& $this->recallObject('TagsAggregator', 'kArray');
	$aggregator->SetArrayValue($tag_info['AggregateTo'], $tag_info['AggregatedTagName'], Array($tag_info['LocalPrefix'], $tag_info['LocalTagName'], getArrayValue($tag_info, 'LocalSpecial')));
	}

	/**
	* Returns object using params specified,
	* creates it if is required
	*
	* @param string $name
	* @param string $pseudo_class
	* @param Array $event_params
	* @return Object
	* @author Alex
	*/
	function &recallObject($name,$pseudo_class=null,$event_params=Array())
	{
	$result =& $this->Factory->getObject($name, $pseudo_class, $event_params);
	return $result;
	}

	/**
	* Returns object using Variable number of params,
	* all params starting with 4th are passed to object consturctor
	*
	* @param string $name
	* @param string $pseudo_class
	* @param Array $event_params
	* @return Object
	* @author Alex
	*/
	function &recallObjectP($name,$pseudo_class=null,$event_params=Array())
	{
	$func_args = func_get_args();
	$result =& ref_call_user_func_array( Array(&$this->Factory, 'getObjectP'), $func_args );
	return $result;
	}

	/**
	* Returns tag processor for prefix specified
	*
	* @param string $prefix
	* @return kDBTagProcessor
	*/
	function &recallTagProcessor($prefix)
	{
	$this->InitParser(); // because kDBTagProcesor is in NParser dependencies
	$result =& $this->recallObject($prefix . '_TagProcessor');

	return $result;
	}

	/**
	* Checks if object with prefix passes was already created in factory
	*
	* @param string $name object presudo_class, prefix
	* @return bool
	* @author Kostja
	*/
	function hasObject($name)
	{
	return isset($this->Factory->Storage[$name]);
	}

	/**
	* Removes object from storage by given name
	*
	* @param string $name Object's name in the Storage
	* @author Kostja
	*/
	function removeObject($name)
	{
	$this->Factory->DestroyObject($name);
	}

	/**
	* Get's real class name for pseudo class,
	* includes class file and creates class
	* instance
	*
	* @param string $pseudo_class
	* @return Object
	* @access public
	* @author Alex
	*/
	function &makeClass($pseudo_class)
	{
	$func_args = func_get_args();
	$result =& ref_call_user_func_array( Array(&$this->Factory, 'makeClass'), $func_args);

	return $result;
	}

	/**
	* Checks if application is in debug mode
	*
	* @param bool $check_debugger check if kApplication debugger is initialized too, not only for defined DEBUG_MODE constant
	* @return bool
	* @author Alex
	* @access public
	*/
	function isDebugMode($check_debugger = true)
	{
	$debug_mode = defined('DEBUG_MODE') && DEBUG_MODE;
	if ($check_debugger) {
	$debug_mode = $debug_mode && is_object($this->Debugger);
	}
	return $debug_mode;
	}

	/**
	* Apply url rewriting used by mod_rewrite or not
	*
	* @param bool $ssl Force ssl link to be build
	* @return bool
	*/
	function RewriteURLs($ssl = false)
	{
	// case #1,#4:
	// we want to create https link from http mode
	// we want to create https link from https mode
	// conditions: ($ssl \|\| PROTOCOL == 'https://') && $this->ConfigValue('UseModRewriteWithSSL')

	// case #2,#3:
	// we want to create http link from https mode
	// we want to create http link from http mode
	// conditions: !$ssl && (PROTOCOL == 'https://' \|\| PROTOCOL == 'http://')

	$allow_rewriting =
	(!$ssl && (PROTOCOL == 'https://' \|\| PROTOCOL == 'http://')) // always allow mod_rewrite for http
	\|\| // or allow rewriting for redirect TO httpS or when already in httpS
	(($ssl \|\| PROTOCOL == 'https://') && $this->ConfigValue('UseModRewriteWithSSL')); // but only if it's allowed in config!
	return constOn('MOD_REWRITE') && $allow_rewriting;
	}

	/**
	* Reads unit (specified by $prefix)
	* option specified by $option
	*
	* @param string $prefix
	* @param string $option
	* @param mixed $default
	* @return string
	* @access public
	* @author Alex
	*/
	function getUnitOption($prefix, $option, $default = false)
	{
	/*if (!isset($this->UnitConfigReader)) {
	$this->UnitConfigReader =& $this->recallObject('kUnitConfigReader');
	}*/
	return $this->UnitConfigReader->getUnitOption($prefix, $option, $default);
	}

	/**
	* Set's new unit option value
	*
	* @param string $prefix
	* @param string $name
	* @param string $value
	* @author Alex
	* @access public
	*/
	function setUnitOption($prefix, $option, $value)
	{
	// $unit_config_reader =& $this->recallObject('kUnitConfigReader');
	return $this->UnitConfigReader->setUnitOption($prefix,$option,$value);
	}

	/**
	* Read all unit with $prefix options
	*
	* @param string $prefix
	* @return Array
	* @access public
	* @author Alex
	*/
	function getUnitOptions($prefix)
	{
	// $unit_config_reader =& $this->recallObject('kUnitConfigReader');
	return $this->UnitConfigReader->getUnitOptions($prefix);
	}

	/**
	* Returns true if config exists and is allowed for reading
	*
	* @param string $prefix
	* @return bool
	*/
	function prefixRegistred($prefix)
	{
	/*if (!isset($this->UnitConfigReader)) {
	$this->UnitConfigReader =& $this->recallObject('kUnitConfigReader');
	}*/
	return $this->UnitConfigReader->prefixRegistred($prefix);
	}

	/**
	* Splits any mixing of prefix and
	* special into correct ones
	*
	* @param string $prefix_special
	* @return Array
	* @access public
	* @author Alex
	*/
	function processPrefix($prefix_special)
	{
	return $this->Factory->processPrefix($prefix_special);
	}

	/**
	* Set's new event for $prefix_special
	* passed
	*
	* @param string $prefix_special
	* @param string $event_name
	* @access public
	*/
	function setEvent($prefix_special,$event_name)
	{
	$event_manager =& $this->recallObject('EventManager');
	$event_manager->setEvent($prefix_special,$event_name);
	}


	/**
	* SQL Error Handler
	*
	* @param int $code
	* @param string $msg
	* @param string $sql
	* @return bool
	* @access private
	* @author Alex
	*/
	function handleSQLError($code, $msg, $sql)
	{
	if ( isset($this->Debugger) )
	{
	$errorLevel = constOn('DBG_SQL_FAILURE') && !defined('IS_INSTALL') ? E_USER_ERROR : E_USER_WARNING;
	$this->Debugger->appendTrace();

	$error_msg = '<span class="debug_error">'.$msg.' ('.$code.')</span><br><a href="javascript:$Debugger.SetClipboard(\''.htmlspecialchars($sql).'\');"><b>SQL</b></a>: '.$this->Debugger->formatSQL($sql);
	$long_id = $this->Debugger->mapLongError($error_msg);
	trigger_error( mb_substr($msg.' ('.$code.') ['.$sql.']',0,1000).' #'.$long_id, $errorLevel);
	return true;
	}
	else
	{
	//$errorLevel = constOn('IS_INSTALL') ? E_USER_WARNING : E_USER_ERROR;
	$errorLevel = E_USER_WARNING;
	trigger_error('<b>SQL Error</b> in sql: '.$sql.', code <b>'.$code.'</b> ('.$msg.')', $errorLevel);
	/*echo '<b>xProcessing SQL</b>: '.$sql.'<br>';
	echo '<b>Error ('.$code.'):</b> '.$msg.'<br>';*/
	return $errorLevel == E_USER_ERROR ? false : true;
	}
	}

	/**
	* Default error handler
	*
	* @param int $errno
	* @param string $errstr
	* @param string $errfile
	* @param int $errline
	* @param Array $errcontext
	*/
	function handleError($errno, $errstr, $errfile = '', $errline = '', $errcontext = '')
	{
	if (defined('SILENT_LOG') && SILENT_LOG) {
	if ( !(defined('DBG_IGNORE_STRICT_ERRORS') && DBG_IGNORE_STRICT_ERRORS && defined('E_STRICT') && ($errno == E_STRICT)) ) {
	$fp = fopen(FULL_PATH.'/silent_log.txt','a');
	$time = adodb_date('d/m/Y H:i:s');
	fwrite($fp, '['.$time.'] #'.$errno.': '.strip_tags($errstr).' in ['.$errfile.'] on line '.$errline."\n");
	fclose($fp);
	}
	}

	$debug_mode = defined('DEBUG_MODE') && DEBUG_MODE;
	$skip_reporting = defined('DBG_SKIP_REPORTING') && DBG_SKIP_REPORTING;

	if (!$this->errorHandlers \|\| ($debug_mode && $skip_reporting)) {
	// when debugger absent OR it's present, but we actually can't see it's error report (e.g. during ajax request)
	$ignore_fatal_errors = defined('DBG_IGNORE_FATAL_ERRORS') && DBG_IGNORE_FATAL_ERRORS;

	if (($errno == E_USER_ERROR) && !$ignore_fatal_errors) {
	echo (' <div style="background-color: #FEFFBF; margin: auto; padding: 10px; border: 2px solid red; text-align: center">
	<strong>Fatal Error: </strong>'."$errstr in $errfile on line $errline".'
	</div>');
	exit;
	}

	if (!$this->errorHandlers) {
	return true;
	}
	}

	$res = false;
	$i = 0; // while (not foreach) because it is array of references in some cases
	$eh_count = count($this->errorHandlers);
	while ($i < $eh_count) {
	if ( is_array($this->errorHandlers[$i]) ) {
	$object =& $this->errorHandlers[$i][0];
	$method = $this->errorHandlers[$i][1];
	$res = $object->$method($errno, $errstr, $errfile, $errline, $errcontext);
	}
	else {
	$function = $this->errorHandlers[$i];
	$res = $function($errno, $errstr, $errfile, $errline, $errcontext);
	}
	$i++;
	}
	return $res;
	}

	/**
	* Returns & blocks next ResourceId available in system
	*
	* @return int
	* @access public
	* @author Alex
	*/
	function NextResourceId()
	{
	$table_name = TABLE_PREFIX.'IdGenerator';

	$this->Conn->Query('LOCK TABLES '.$table_name.' WRITE');
	$this->Conn->Query('UPDATE '.$table_name.' SET lastid = lastid + 1');
	$id = $this->Conn->GetOne('SELECT lastid FROM '.$table_name);
	if($id === false)
	{
	$this->Conn->Query('INSERT INTO '.$table_name.' (lastid) VALUES (2)');
	$id = 2;
	}
	$this->Conn->Query('UNLOCK TABLES');
	return $id - 1;
	}

	/**
	* Returns genealogical main prefix for subtable prefix passes
	* OR prefix, that has been found in REQUEST and some how is parent of passed subtable prefix
	*
	* @param string $current_prefix
	* @param string $real_top if set to true will return real topmost prefix, regardless of its id is passed or not
	* @return string
	* @access public
	* @author Kostja / Alex
	*/
	function GetTopmostPrefix($current_prefix, $real_top = false)
	{
	// 1. get genealogical tree of $current_prefix
	$prefixes = Array ($current_prefix);
	while ( $parent_prefix = $this->getUnitOption($current_prefix, 'ParentPrefix') ) {
	if (!$this->prefixRegistred($parent_prefix)) {
	// stop searching, when parent prefix is not registered
	break;
	}

	$current_prefix = $parent_prefix;
	array_unshift($prefixes, $current_prefix);
	}

	if ($real_top) {
	return $current_prefix;
	}

	// 2. find what if parent is passed
	$passed = explode(',', $this->GetVar('all_passed'));
	foreach ($prefixes as $a_prefix) {
	if (in_array($a_prefix, $passed)) {
	return $a_prefix;
	}
	}

	return $current_prefix;
	}

	/**
	* Triggers email event of type Admin
	*
	* @param string $email_event_name
	* @param int $to_user_id
	* @param array $send_params associative array of direct send params, possible keys: to_email, to_name, from_email, from_name, message, message_text
	* @return kEvent
	*/
	function &EmailEventAdmin($email_event_name, $to_user_id = null, $send_params = Array ())
	{
	$event =& $this->EmailEvent($email_event_name, EVENT_TYPE_ADMIN, $to_user_id, $send_params);

	return $event;
	}

	/**
	* Triggers email event of type User
	*
	* @param string $email_event_name
	* @param int $to_user_id
	* @param array $send_params associative array of direct send params, possible keys: to_email, to_name, from_email, from_name, message, message_text
	* @return kEvent
	*/
	function &EmailEventUser($email_event_name, $to_user_id = null, $send_params = Array ())
	{
	$event =& $this->EmailEvent($email_event_name, EVENT_TYPE_FRONTEND, $to_user_id, $send_params);

	return $event;
	}

	/**
	* Triggers general email event
	*
	* @param string $email_event_name
	* @param int $email_event_type (0 for User, 1 for Admin)
	* @param int $to_user_id
	* @param array $send_params associative array of direct send params,
	* possible keys: to_email, to_name, from_email, from_name, message, message_text
	* @return kEvent
	*/
	function &EmailEvent($email_event_name, $email_event_type, $to_user_id = null, $send_params = Array ())
	{
	$params = Array (
	'EmailEventName' => $email_event_name,
	'EmailEventToUserId' => $to_user_id,
	'EmailEventType' => $email_event_type,
	'DirectSendParams' => $send_params,
	);

	if (array_key_exists('use_special', $send_params)) {
	$event_str = 'emailevents.' . $send_params['use_special'] . ':OnEmailEvent';
	}
	else {
	$event_str = 'emailevents:OnEmailEvent';
	}

	$this->HandleEvent($event, $event_str, $params);

	return $event;
	}

	/**
	* Allows to check if user in this session is logged in or not
	*
	* @return bool
	*/
	function LoggedIn()
	{
	// no session during expiration process
	return is_null($this->Session) ? false : $this->Session->LoggedIn();
	}

	/**
	* Check current user permissions based on it's group permissions in specified category
	*
	* @param string $name permission name
	* @param int $cat_id category id, current used if not specified
	* @param int $type permission type {1 - system, 0 - per category}
	* @return int
	*/
	function CheckPermission($name, $type = 1, $cat_id = null)
	{
	$perm_helper =& $this->recallObject('PermissionsHelper');
	return $perm_helper->CheckPermission($name, $type, $cat_id);
	}

	/**
	* Set's any field of current visit
	*
	* @param string $field
	* @param mixed $value
	*/
	function setVisitField($field, $value)
	{
	if ($this->isAdmin \|\| !$this->ConfigValue('UseVisitorTracking')) {
	// admin logins are not registred in visits list
	return ;
	}

	$visit =& $this->recallObject('visits', null, Array ('raise_warnings' => 0));
	/* @var $visit kDBItem */

	if ($visit->isLoaded()) {
	$visit->SetDBField($field, $value);
	$visit->Update();
	}
	}

	/**
	* Allows to check if in-portal is installed
	*
	* @return bool
	*/
	function isInstalled()
	{
	return $this->InitDone && (count($this->ModuleInfo) > 0);
	}

	/**
	* Allows to determine if module is installed & enabled
	*
	* @param string $module_name
	* @return bool
	*/
	function isModuleEnabled($module_name)
	{
	return $this->findModule('Name', $module_name) !== false;

	}

	function reportError($class, $method)
	{
	$this->Debugger->appendTrace();
	trigger_error('depricated method <b>'.$class.'->'.$method.'(...)</b>', E_USER_ERROR);
	}

	/**
	* Returns Window ID of passed prefix main prefix (in edit mode)
	*
	* @param string $prefix
	* @return mixed
	*/
	function GetTopmostWid($prefix)
	{
	$top_prefix = $this->GetTopmostPrefix($prefix);
	$mode = $this->GetVar($top_prefix.'_mode');
	return $mode != '' ? substr($mode, 1) : '';
	}

	/**
	* Get temp table name
	*
	* @param string $table
	* @param mixed $wid
	* @return string
	*/
	function GetTempName($table, $wid = '')
	{
	if (preg_match('/prefix:(.*)/', $wid, $regs)) {
	$wid = $this->GetTopmostWid($regs[1]);
	}

	return TABLE_PREFIX.'ses_'.$this->GetSID().($wid ? '_'.$wid : '').'_edit_'.$table;
	}

	function GetTempTablePrefix($wid = '')
	{
	if (preg_match('/prefix:(.*)/', $wid, $regs)) {
	$wid = $this->GetTopmostWid($regs[1]);
	}

	return TABLE_PREFIX.'ses_'.$this->GetSID().($wid ? '_'.$wid : '').'_edit_';
	}

	function IsTempTable($table)
	{
	return preg_match('/'.TABLE_PREFIX.'ses_'.$this->GetSID().'(_[\d]+){0,1}_edit_(.*)/',$table);
	}

	/**
	* Checks, that given prefix is in temp mode
	*
	* @param string $prefix
	* @return bool
	*/
	function IsTempMode($prefix, $special = '')
	{
	$top_prefix = $this->Application->GetTopmostPrefix($prefix);

	$var_names = Array (
	$top_prefix,
	rtrim($top_prefix . '_' . $special, '_'), // from post
	rtrim($top_prefix . '.' . $special, '.'), // assembled locally
	);

	$var_names = array_unique($var_names);

	$temp_mode = false;
	foreach ($var_names as $var_name) {
	$value = $this->Application->GetVar($var_name . '_mode');
	if ($value && (substr($value, 0, 1) == 't')) {
	$temp_mode = true;
	break;
	}
	}

	return $temp_mode;
	}

	/**
	* Return live table name based on temp table name
	*
	* @param string $temp_table
	* @return string
	*/
	function GetLiveName($temp_table)
	{
	if( preg_match('/'.TABLE_PREFIX.'ses_'.$this->GetSID().'(_[\d]+){0,1}_edit_(.*)/',$temp_table, $rets) )
	{
	// cut wid from table end if any
	return $rets[2];
	}
	else
	{
	return $temp_table;
	}
	}

	function CheckProcessors($processors)
	{
	foreach ($processors as $a_processor)
	{
	if (!isset($this->CachedProcessors[$a_processor])) {
	$this->CachedProcessors[$a_processor] =& $this->recallObject($a_processor.'_TagProcessor');
	}
	}
	}

	function ApplicationDie($message = '')
	{
	$message = ob_get_clean().$message;
	if ($this->isDebugMode()) {
	$message .= $this->Debugger->printReport(true);
	}

	echo $this->UseOutputCompression() ? gzencode($message, DBG_COMPRESSION_LEVEL) : $message;
	exit;
	}


	/* moved from MyApplication */

	function getUserGroups($user_id)
	{
	switch ($user_id) {
	case USER_ROOT:
	$user_groups = $this->ConfigValue('User_LoggedInGroup');
	break;

	case USER_GUEST:
	$user_groups = $this->ConfigValue('User_LoggedInGroup') . ',' . $this->ConfigValue('User_GuestGroup');
	break;

	default:
	$sql = 'SELECT GroupId
	FROM ' . TABLE_PREFIX . 'UserGroup
	WHERE PortalUserId = ' . (int)$user_id;
	$res = $this->Conn->GetCol($sql);

	$user_groups = Array( $this->ConfigValue('User_LoggedInGroup') );
	if ($res) {
	$user_groups = array_merge($user_groups, $res);
	}

	$user_groups = implode(',', $user_groups);
	}

	return $user_groups;
	}


	/**
	* Allows to detect if page is browsed by spider (293 agents supported)
	*
	* @return bool
	*/
	function IsSpider()
	{
	static $is_spider = null;

	if (!isset($is_spider)) {
	$user_agent = trim($_SERVER['HTTP_USER_AGENT']);
	$robots = file(FULL_PATH.'/core/robots_list.txt');
	foreach ($robots as $robot_info) {
	$robot_info = explode("\t", $robot_info, 3);
	if ($user_agent == trim($robot_info[2])) {
	$is_spider = true;
	break;
	}
	}
	}

	return $is_spider;
	}

	/**
	* Allows to detect table's presense in database
	*
	* @param string $table_name
	* @return bool
	*/
	function TableFound($table_name)
	{
	return $this->Conn->TableFound($table_name);
	}

	/**
	* Returns counter value
	*
	* @param string $name counter name
	* @param Array $params counter parameters
	* @param string $query_name specify query name directly (don't generate from parmeters)
	* @param bool $multiple_results
	* @return mixed
	*/
	function getCounter($name, $params = Array (), $query_name = null, $multiple_results = false)
	{
	$count_helper =& $this->Application->recallObject('CountHelper');
	/* @var $count_helper kCountHelper */

	return $count_helper->getCounter($name, $params, $query_name, $multiple_results);
	}

	/**
	* Resets counter, whitch are affected by one of specified tables
	*
	* @param string $tables comma separated tables list used in counting sqls
	*/
	function resetCounters($tables)
	{
	if (constOn('IS_INSTALL')) {
	return ;
	}

	$count_helper =& $this->Application->recallObject('CountHelper');
	/* @var $count_helper kCountHelper */

	return $count_helper->resetCounters($tables);
	}

	/**
	* Sends XML header + optionally displays xml heading
	*
	* @param string $xml_version
	* @return string
	* @author Alex
	*/
	function XMLHeader($xml_version = false)
	{
	$lang =& $this->recallObject('lang.current');
	header('Content-type: text/xml; charset='.$lang->GetDBField('Charset'));

	return $xml_version ? '<?xml version="'.$xml_version.'" encoding="'.$lang->GetDBField('Charset').'"?>' : '';
	}

	/**
	* Returns category tree
	*
	* @param int $category_id
	* @return Array
	*/
	function getTreeIndex($category_id)
	{
	$tree_index = $this->getCategoryCache($category_id, 'category_tree');

	if ($tree_index) {
	$ret = Array ();
	list ($ret['TreeLeft'], $ret['TreeRight']) = explode(';', $tree_index);

	return $ret;
	}

	return false;
	}

	}
	\ No newline at end of file

in-portalNo OneTemporaryActions

File Metadata

in-portalView Options

Event Timeline

in-portal
No OneTemporary
Actions

in-portal
View Options