in-portal
No OneTemporary
Actions

Subscribers

None

File Metadata

Created: Mon, Jan 6, 2:12 AM

in-portal
View Options

	Index: branches/RC/core/kernel/session/session.php
	===================================================================
	--- branches/RC/core/kernel/session/session.php (revision 10579)
	+++ branches/RC/core/kernel/session/session.php (revision 10580)
	@@ -1,1033 +1,1034 @@
	<?php

	/*

	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:

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

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

	$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->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)
	{
	$query = ' SELECT * FROM '.$this->TableName.' WHERE '.$this->IDField.' = '.$this->Conn->qstr($sid);
	$result = $this->Conn->GetRow($query);

	if($result===false) 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)
	{
	return getArrayValue($this->OriginalData, $var);
	}

	function GetExpiredSIDs()
	{
	$query = ' SELECT '.$this->IDField.' FROM '.$this->TableName.' WHERE '.$this->TimestampField.' > '.adodb_mktime();
	return $this->Conn->GetCol($query);
	}

	function DeleteExpired()
	{
	$expired_sids = $this->GetExpiredSIDs();
	if ($expired_sids) {
	$sessionlog_table = $this->Application->getUnitOption('session-log', 'TableName');
	$session_log_sql =
	' UPDATE '.$sessionlog_table.'
	SET Status = 2, SessionEnd =
	( SELECT '.$this->TimestampField.' - '.$this->SessionTimeout.'
	FROM '.$this->TableName.'
	WHERE '.$this->IDField.' = '.$sessionlog_table.'.SessionId
	)
	WHERE Status = 0 AND SessionId IN ('.join(',', $expired_sids).')';
	$this->Conn->Query($session_log_sql);

	$where_clause = ' WHERE '.$this->IDField.' IN ("'.implode('","',$expired_sids).'")';
	$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 expired sessions
	foreach ($expired_sids as $expired_sid) {
	$debug_file = (defined('WRITEABLE') ? WRITEABLE : FULL_PATH.'/kernel').'/cache/debug_@'.$expired_sid.'@.txt';
	if (file_exists($debug_file)) {
	@unlink($debug_file);
	}
	}
	}
	return $expired_sids;
	}

	function LoadPersistentVars(&$session)
	{
	$user_id = $session->RecallVar('user_id');
	if ($user_id != -2) {
	// 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
	*/
	function StorePersistentVar(&$session, $var_name, $var_value)
	{
	$user_id = $session->RecallVar('user_id');
	if ($user_id == -2 \|\| $user_id === false) {
	// -2 (when not logged in), false (when after u:OnLogout event)
	$session->StoreVar($var_name, $var_value);
	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') == -2) {
	if ($default == '_USE_DEFAULT_USER_DATA_') {
	$default = null;
	}
	return $session->RecallVar($var_name, $default);
	}

	if (array_key_exists($var_name, $this->PersistentVars)) {
	return $this->PersistentVars[$var_name];
	}
	elseif ($default == '_USE_DEFAULT_USER_DATA_') {
	$default_user_id = $this->Application->ConfigValue('DefaultSettingsUserId');
	if (!$default_user_id) {
	$default_user_id = -1;
	}
	$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 != -2) {
	$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;

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

	var $CachedNeedQueryString = null;

	var $Data;


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

	function SetCookieDomain($domain)
	{
	$this->CookieDomain = '.'.ltrim($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();
	+// if (!$tmp_sid) return;

	$check = $this->Check();
	if( !(defined('IS_INSTALL') && IS_INSTALL) )
	{
	$expired_sids = $this->DeleteExpired();
	if ( ( $expired_sids && in_array($tmp_sid,$expired_sids) ) \|\| ( $tmp_sid && !$check ) ) {
	$this->SetSession();
	$this->Application->HandleEvent($event, 'u:OnSessionExpire');
	return ;
	}
	}

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

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

	function IsHTTPSRedirect()
	{
	$http_referer = getArrayValue($_SERVER, 'HTTP_REFERER');
	return (
	( PROTOCOL == 'https://' && preg_match('#http:\/\/#', $http_referer) )
	\|\|
	( PROTOCOL == 'http://' && preg_match('#https:\/\/#', $http_referer) )
	);
	}

	function CheckReferer($for_cookies=0)
	{
	if (!$for_cookies) {
	if ( !$this->Application->ConfigValue('SessionReferrerCheck') \|\| $_SERVER['REQUEST_METHOD'] != 'POST') {
	return true;
	}
	}
	$path = preg_replace('/admin[\/]{0,1}$/', '', $this->CookiePath); // removing /admin for compatability with in-portal (in-link/admin/add_link.php)
	$reg = '#^'.preg_quote(PROTOCOL.ltrim($this->CookieDomain, '.').$path).'#';
	return preg_match($reg, getArrayValue($_SERVER, 'HTTP_REFERER') ) \|\| (defined('IS_POPUP') && IS_POPUP);
	}

	/*function CheckDuplicateCookies()
	{
	if (isset($_SERVER['HTTP_COOKIE'])) {
	$cookie_str = $_SERVER['HTTP_COOKIE'];
	$cookies = explode('; ', $cookie_str);
	$all_cookies = array();
	foreach ($cookies as $cookie) {
	list($name, $value) = explode('=', $cookie);
	if (isset($all_cookies[$name])) {
	//double cookie name!!!
	$this->RemoveCookie($name);
	}
	else $all_cookies[$name] = $value;
	}
	}
	}

	function RemoveCookie($name)
	{
	$path = $_SERVER['PHP_SELF'];
	$path_parts = explode('/', $path);
	$cur_path = '';
	setcookie($name, false, null, $cur_path);
	foreach ($path_parts as $part) {
	$cur_path .= $part;
	setcookie($name, false, null, $cur_path);
	$cur_path .= '/';
	setcookie($name, false, null, $cur_path);
	}
	}*/

	function CheckIfCookiesAreOn()
	{
	// $this->CheckDuplicateCookies();
	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 = isset($http_query->Cookie['cookies_on']); // 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->CheckReferer(1) && !$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)
	{
	setcookie($name, $value, $expires, $this->CookiePath, $this->CookieDomain, $this->CookieSecure);
	}

	function Check()
	{
	// we should check referer if cookies are disabled, and in combined mode
	// auto mode would detect cookies, get only mode would turn it off - so we would get here
	// and we don't care about referal in cookies only mode

	if ( $this->Mode != smCOOKIES_ONLY && (!$this->CookiesEnabled \|\| $this->Mode == smCOOKIES_AND_GET) ) {
	if (!$this->CheckReferer())
	return false;
	}

	$sid = $this->GetPassedSIDValue();

	if (empty($sid)) return false;

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

	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()) return false;

	//Otherwise it's ok
	return true;
	}
	else //fake or deleted due to expiration SID
	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);

	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;
	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 = '';
	}
	break;
	}
	}


	$this->CachedSID = $sid;
	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 = ereg_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=$new_sid;
	$this->Application->SetVar($this->GETName,$new_sid);
	}

	function SetSession()
	{
	$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);
	}

	if ($this->Special != '') {
	// front-session called from admin or otherwise, then save it's data
	$this->SaveData();
	}

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

	/**
	* 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
	}

	/**
	* 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 = '';
	if ($this->CookiesEnabled) $this->SetSessionCookie(); //will remove the cookie due to value (sid) is empty
	$this->SetSession(); //will create a new session
	}

	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($this->Application->isDebugMode() && constOn('DBG_SHOW_SESSIONDATA')) {
	// dump session data
	$this->Application->Debugger->appendHTML('SessionStorage ('.$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->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()
	{
	if (!$this->Application->GetVar('skip_last_template') && $this->Application->GetVar('ajax') != 'yes') {
	$this->SaveLastTemplate( $this->Application->GetVar('t') );
	}

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

	function SaveLastTemplate($t)
	{
	// save last_template
	$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);

	$last_env = $this->getLastTemplateENV($t, null, false);

	$last_template = basename($_SERVER['PHP_SELF']).'\|'.mb_substr($last_env, mb_strlen(ENV_VAR_NAME) + 1);
	$this->StoreVar(rtrim('last_template_popup_'.$wid, '_'), $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 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') == 1) {
	$admin_session =& $this->Application->recallObject('Session.admin');
	/* @var $admin_ses Session */

	$admin_session->StorePersistentVar('last_template_popup', '../'.$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)
	$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)
	{
	$this->Data->Set($name, $value);
	}

	function StorePersistentVar($name, $value)
	{
	$this->Storage->StorePersistentVar($this, $name, $value);
	}

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

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

	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)
	{
	return $this->StoreVar($name, $this->Storage->GetFromData($this, $name));
	}

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

	/**
	* 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 && ($user_id == -1)) {
	$ret = true;
	}
	return $ret;
	}

	}

	?>
	\ No newline at end of file

	Property changes on: branches/RC/core/kernel/session/session.php
	___________________________________________________________________
	Modified: cvs2svn:cvs-rev
	## -1 +1 ##
	-1.59.2.12
	\ No newline at end of property
	+1.59.2.13
	\ No newline at end of property
	Index: branches/RC/core/kernel/utility/cache.php
	===================================================================
	--- branches/RC/core/kernel/utility/cache.php (revision 10579)
	+++ branches/RC/core/kernel/utility/cache.php (revision 10580)
	@@ -1,277 +1,277 @@
	<?php

	class kCache extends kBase {

	/**
	* Object, that represents cache storage
	*
	* @var CacheStorage
	*/
	var $_storage = null;

	var $statistics = Array ();
	var $debugCache = false;

	function kCache() {
	parent::kBase();

	$this->debugCache = $this->Application->isDebugMode() && constOn('DBG_CACHE');

	$memcached_servers = 'localhost:11211'; // $this->Application->ConfigValue('MemcachedServers');

	if ($memcached_servers && class_exists('Memcache')) {
	$this->_storage = new MemcacheCacheStorage($memcached_servers);
	}
	else if (false \|\| $this->Application->ConfigValue('UseFileCache')) {
	$this->_storage = new FileCacheStorage('file_cache.tmp');
	}
	else {
	$this->_storage = new CacheStorage();
	}

	if (!$this->_storage->isWorking()) {
	// when one of above cache storages fails to initialize fallback to memory cache
	$this->_storage = new CacheStorage();
	}
	}

	/**
	* Adds new value to cache $cache_name and identified by key $key
	*
	* @param string $cache_name cache name
	* @param int $key key name to add to cache
	* @param mixed $value value of chached record
	*/
	function setCache($cache_name, $key, $value, $expires = 3600)
	{
	- $this->_storage->set($cache_name, $key, $value, $expires);
	+ return $this->_storage->set($cache_name, $key, $value, $expires);
	}

	/**
	* Returns cached $key value from cache named $cache_name
	*
	* @param string $cache_name cache name
	* @param int $key key name from cache
	* @return mixed
	*/
	function getCache($cache_name, $key)
	{
	$ret = $this->_storage->get($cache_name, $key);

	$this->setStatistics($cache_name, $key, $ret);

	return $ret;
	}

	function setStatistics($cache_name, $key, $found)
	{
	if (!$this->debugCache) {
	return true;
	}

	if (!array_key_exists($cache_name, $this->statistics)) {
	$this->statistics[$cache_name] = Array ();
	}

	if (!array_key_exists($key, $this->statistics[$cache_name])) {
	$this->statistics[$cache_name][$key] = Array ();
	}

	$status_key = $found ? 'found' : 'not_found';
	if (!isset($this->statistics[$cache_name][$key][$status_key])) {
	$this->statistics[$cache_name][$key][$status_key] = 0;
	}

	$this->statistics[$cache_name][$key][$status_key]++;
	}

	function printStatistics()
	{
	$cache_size = strlen(serialize($this->_storage));

	$this->Application->Debugger->appendHTML('<strong>Cache Size:</strong> ' . formatSize($cache_size) . ' (' . $cache_size . ')');

	foreach ($this->statistics as $cache_name => $cache_data) {
	foreach ($cache_data as $key => $value) {
	if (!array_key_exists('found', $value) \|\| $value['found'] == 1) {
	// remove cached records, that were used only 1 or 2 times
	unset($this->statistics[$cache_name][$key]);
	}
	}
	}

	print_pre($this->statistics, 'Cache Statistics:');
	}
	}

	class CacheStorage extends Params {

	/**
	* Determines, that cache storage is working fine
	*
	* @return bool
	*/
	function isWorking()
	{
	return true;
	}

	/**
	* Stores value to cache
	*
	* @param string $cache_name
	* @param string $key
	* @param mixed $value
	* @param int $expires cache record expiration time in seconds
	*/
	function set($cache_name, $key, $value, $expires)
	{
	$cache = parent::Get($cache_name, Array());
	$cache[$key] = $value;

	parent::Set($cache_name, $cache);
	}

	/**
	* Returns value from cache
	*
	* @param string $cache_name
	* @param string $key
	* @return mixed
	*/
	function get($cache_name, $key)
	{
	$cache = parent::Get($cache_name, Array());
	$ret = array_key_exists($key, $cache) ? $cache[$key] : false;

	return $ret;
	}
	}

	class MemcacheCacheStorage {

	/**
	* Memcache connection
	*
	* @var Memcache
	*/
	var $_handler = null;

	function MemcacheCacheStorage($servers)
	{
	$this->_handler = new Memcache;

	$servers = explode(';', $servers);
	foreach ($servers as $server) {
	list ($server, $port) = strpos($server, ':') !== false ? explode(':', $server, 2) : Array ($server, 11211);
	$this->_handler->addServer($server, $port);
	}
	}

	/**
	* Determines, that cache storage is working fine
	*
	* @return bool
	*/
	function isWorking()
	{
	return $this->_handler->getVersion() !== false;
	}

	/**
	* Stores value to cache
	*
	* @param string $cache_name
	* @param string $key
	* @param mixed $value
	* @param int $expires cache record expiration time in seconds
	*/
	function set($cache_name, $key, $value, $expires)
	{
	- $this->_handler->set($cache_name . '-' . $key, $value, false, $expires); // false could be MEMCACHE_COMPRESSED to compress values in memory
	+ return $this->_handler->set($cache_name . '-' . $key, $value, false, $expires); // false could be MEMCACHE_COMPRESSED to compress values in memory
	}

	/**
	* Returns value from cache
	*
	* @param string $cache_name
	* @param string $key
	* @return mixed
	*/
	function get($cache_name, $key)
	{
	return $this->_handler->get($cache_name . '-' . $key);
	}
	}

	class FileCacheStorage extends Params {

	/**
	* Expiration time for each variable in cache
	*
	* @var resource
	*/
	var $_expiration = Array ();

	/**
	* Filename for storing cache
	*
	* @var string
	*/
	var $_filename = '';

	function FileCacheStorage($filename = '')
	{
	$this->_filename = (defined('WRITEABLE') ? WRITEABLE.'/cache' : FULL_PATH.'/kernel/cache') . '/' . $filename;

	if (file_exists($this->_filename)) {
	$cache_data = unserialize(file_get_contents($this->_filename));
	}
	else {
	$cache_data = Array ();
	}
	}

	/**
	* Determines, that cache storage is working fine
	*
	* @return bool
	*/
	function isWorking()
	{
	return false;
	}

	/**
	* Stores value to cache
	*
	* @param string $cache_name
	* @param string $key
	* @param mixed $value
	* @param int $expires cache record expiration time in seconds
	*/
	function set($cache_name, $key, $value, $expires)
	{
	$cache = parent::Get($cache_name, Array());
	$cache[$key] = $value;

	parent::Set($cache_name, $cache);
	}

	/**
	* Returns value from cache
	*
	* @param string $cache_name
	* @param string $key
	* @return mixed
	*/
	function get($cache_name, $key)
	{
	$cache = parent::Get($cache_name, Array());
	$ret = array_key_exists($key, $cache) ? $cache[$key] : false;

	return $ret;
	}
	}

	?>
	\ No newline at end of file

	Property changes on: branches/RC/core/kernel/utility/cache.php
	___________________________________________________________________
	Modified: cvs2svn:cvs-rev
	## -1 +1 ##
	-1.3.30.3
	\ No newline at end of property
	+1.3.30.4
	\ No newline at end of property
	Index: branches/RC/core/kernel/utility/debugger.php
	===================================================================
	--- branches/RC/core/kernel/utility/debugger.php (revision 10579)
	+++ branches/RC/core/kernel/utility/debugger.php (revision 10580)
	@@ -1,1411 +1,1431 @@
	<?php

	if( !class_exists('Debugger') ) {
	class Debugger {

	/**
	* Holds reference to global KernelApplication instance
	*
	* @access public
	* @var kApplication
	*/
	var $Application = null;

	/**
	* Set to true if fatal error occured
	*
	* @var bool
	*/
	var $IsFatalError = false;

	/**
	* Debugger data for building report
	*
	* @var Array
	*/
	var $Data = Array();

	var $ProfilerData = Array();
	var $ProfilerTotals = Array();
	var $ProfilerTotalCount = Array();

	var $ProfilePoints = Array();

	/**
	* Prevent recursion when processing debug_backtrace() function results
	*
	* @var Array
	*/
	var $RecursionStack = Array();

	var $scrollbarWidth = 0;

	/**
	* Long errors are saved here, because trigger_error doesn't support error messages over 1KB in size
	*
	* @var Array
	*/
	var $longErrors = Array();

	var $IncludesData = Array();
	var $IncludeLevel = 0;

	var $reportDone = false;

	/**
	* Transparent spacer image used in case of none spacer image defined via SPACER_URL contant.
	* Used while drawing progress bars (memory usage, time usage, etc.)
	*
	* @var string
	*/
	var $dummyImage = '';

	/**
	* Temporary files created by debugger will be stored here
	*
	* @var string
	*/
	var $tempFolder = '';

	/**
	* Debug rows will be separated using this string before writing to debug file
	*
	* @var string
	*/
	var $rowSeparator = '@@';

	/**
	* Base URL for debugger includes
	*
	* @var string
	*/
	var $baseURL = '';
	+
	+
	+ /**
	+ * Holds last recorded timestamp (for appendTimestamp)
	+ *
	+ * @var int
	+ */
	+ var $LastMoment;

	function Debugger()
	{
	global $start, $dbg_options;
	// check if user haven't defined DEBUG_MODE contant directly
	if (defined('DEBUG_MODE') && DEBUG_MODE) {
	die('error: contant DEBUG_MODE defined directly, please use <strong>$dbg_options</strong> array instead');
	}

	// check IP before enabling debug mode
	$ip_match = $this->ipMatch(isset($dbg_options['DBG_IP']) ? $dbg_options['DBG_IP'] : '');

	if (!$ip_match) {
	define('DEBUG_MODE', 0);
	return ;
	}

	// debug is allowed for user, continue initialization
	$this->InitDebugger();
	$this->profileStart('kernel4_startup', 'Startup and Initialization of kernel4', $start);
	$this->profileStart('script_runtime', 'Script runtime', $start);
	+ $this->LastMoment = $start;

	error_reporting(E_ALL);
	ini_set('display_errors', $this->constOn('DBG_ZEND_PRESENT') ? 0 : 1); // show errors on screen in case if not in Zend Studio debugging

	$this->scrollbarWidth = $this->isGecko() ? 22 : 25; // vertical scrollbar width differs in Firefox and other browsers
	$this->appendRequest();
	}

	/**
	* Checks, that user IP address is within allowed range
	*
	* @param string $ip_list semi-column (by default) separated ip address list
	* @param string $separator ip address separator (default ";")
	*
	* @return bool
	*/
	function ipMatch($ip_list, $separator = ';')
	{
	$ip_match = false;
	$ip_addresses = $ip_list ? explode($separator, $ip_list) : Array ();
	foreach ($ip_addresses as $ip_address) {
	if ($this->netMatch($ip_address, $_SERVER['REMOTE_ADDR'])) {
	$ip_match = true;
	break;
	}
	}

	return $ip_match;
	}

	/**
	* Set's default values to constants debugger uses
	*
	*/
	function InitDebugger()
	{
	global $dbg_options;

	unset($_REQUEST['debug_host'], $_REQUEST['debug_fastfile'], $dbg_options['DBG_IP']); // this var messed up whole detection stuff :(

	// Detect fact, that this session beeing debugged by Zend Studio
	foreach ($_REQUEST as $rq_name => $rq_value) {
	if (substr($rq_name, 0, 6) == 'debug_') {
	$this->safeDefine('DBG_ZEND_PRESENT', 1);
	break;
	}
	}

	$this->safeDefine('DBG_ZEND_PRESENT', 0); // set this constant value to 0 (zero) to debug debugger using Zend Studio

	// set default values for debugger constants
	$dbg_constMap = Array(
	'DBG_USE_HIGHLIGHT' => 1, // highlight output same as php code using "highlight_string" function
	'DBG_WINDOW_WIDTH' => 700, // set width of debugger window (in pixels) for better viewing large amount of debug data
	'DBG_USE_SHUTDOWN_FUNC' => DBG_ZEND_PRESENT ? 0 : 1, // use shutdown function to include debugger code into output
	'DBG_HANDLE_ERRORS' => DBG_ZEND_PRESENT ? 0 : 1, // handle all allowed by php (see php manual) errors instead of default handler
	'DBG_IGNORE_STRICT_ERRORS' => 1, // ignore PHP5 errors about private/public view modified missing in class declarations
	'DBG_DOMVIEWER' => '/temp/domviewer.html', // path to DOMViewer on website
	'DOC_ROOT' => str_replace('\\', '/', realpath($_SERVER['DOCUMENT_ROOT']) ), // windows hack
	'DBG_LOCAL_BASE_PATH' => 'w:', // replace DOC_ROOT in filenames (in errors) using this path
	);

	// only for IE, in case if no windows php script editor defined
	if (!defined('DBG_EDITOR')) {
	// $dbg_constMap['DBG_EDITOR'] = 'c:\Program Files\UltraEdit\uedit32.exe %F/%L';
	$dbg_constMap['DBG_EDITOR'] = 'c:\Program Files\Zend\ZendStudio-5.2.0\bin\ZDE.exe %F';
	}

	if (isset($_REQUEST['ajax']) && $_REQUEST['ajax'] && constOn('DBG_SKIP_AJAX')) {
	$this->safeDefine('DBG_SKIP_REPORTING', 1);
	}

	// user defined options override debugger defaults
	$dbg_constMap = $this->array_merge_recursive2($dbg_constMap, $dbg_options);

	// when validation configs, don't show sqls for better validation error displaying
	if (array_key_exists('DBG_VALIDATE_CONFIGS', $dbg_constMap) && $dbg_constMap['DBG_VALIDATE_CONFIGS']) {
	$dbg_constMap['DBG_SQL_PROFILE'] = 0;
	}

	// when showing explain make shure, that debugger window is large enough
	if (array_key_exists('DBG_SQL_EXPLAIN', $dbg_constMap) && $dbg_constMap['DBG_SQL_EXPLAIN']) {
	$dbg_constMap['DBG_WINDOW_WIDTH'] = 1000;
	}

	foreach ($dbg_constMap as $dbg_constName => $dbg_constValue) {
	$this->safeDefine($dbg_constName, $dbg_constValue);
	}
	}

	function constOn($const_name)
	{
	return defined($const_name) && constant($const_name);
	}

	function safeDefine($const_name, $const_value) {
	if (!defined($const_name)) {
	define($const_name, $const_value);
	}
	}

	function array_merge_recursive2($paArray1, $paArray2)
	{
	if (!is_array($paArray1) or !is_array($paArray2)) {
	return $paArray2;
	}

	foreach ($paArray2 AS $sKey2 => $sValue2) {
	$paArray1[$sKey2] = isset($paArray1[$sKey2]) ? array_merge_recursive2($paArray1[$sKey2], $sValue2) : $sValue2;
	}

	return $paArray1;
	}

	function netMatch($network, $ip) {

	$network = trim($network);
	$ip = trim($ip);

	if ($network == $ip) {
	// comparing 2 ip addresses directly
	return true;
	}

	$d = strpos($network, '-');
	if ($d === false) {
	// sigle subnet specified
	$ip_arr = explode('/', $network);

	if (!preg_match("@\d\.\d\.\d\.\d@", $ip_arr[0], $matches)) {
	$ip_arr[0] .= '.0'; // Alternate form 194.1.4/24
	}

	$network_long = ip2long($ip_arr[0]);
	$x = ip2long($ip_arr[1]);

	$mask = long2ip($x) == $ip_arr[1] ? $x : (0xffffffff << (32 - $ip_arr[1]));
	$ip_long = ip2long($ip);

	return ($ip_long & $mask) == ($network_long & $mask);
	}
	else {
	// ip address range specified
	$from = ip2long(trim(substr($network, 0, $d)));
	$to = ip2long(trim(substr($network, $d + 1)));

	$ip = ip2long($ip);
	return ($ip >= $from && $ip <= $to);
	}
	}

	function InitReport()
	{
	if (!class_exists('kApplication')) return false;

	$application =& kApplication::Instance();

	// string used to separate debugger records while in file (used in debugger dump filename too)
	$this->rowSeparator = '@'.(is_object($application->Factory) ? $application->GetSID() : 0).'@';
	+// $this->rowSeparator = '@'.rand(0,100000).'@';

	// include debugger files from this url
	$reg_exp = '/^'.preg_quote(FULL_PATH, '/').'/';
	$kernel_path = preg_replace($reg_exp, '', KERNEL_PATH, 1);
	$this->baseURL = PROTOCOL.SERVER_NAME.rtrim(BASE_PATH, '/').$kernel_path.'/utility/debugger';

	// save debug output in this folder
	$this->tempFolder = defined('WRITEABLE') ? WRITEABLE.'/cache' : FULL_PATH.'/kernel/cache';
	}

	function mapLongError($msg)
	{
	$key = $this->generateID();
	$this->longErrors[$key] = $msg;
	return $key;
	}

	/**
	* Appends all passed variable values (wihout variable names) to debug output
	*
	*/
	function dumpVars()
	{
	$dump_mode = 'var_dump';
	$dumpVars = func_get_args();

	if ($dumpVars[count($dumpVars) - 1] === 'STRICT') {
	$dump_mode = 'strict_var_dump';
	array_pop($dumpVars);
	}

	foreach ($dumpVars as $varValue) {
	$this->Data[] = Array('value' => $varValue, 'debug_type' => $dump_mode);
	}

	}

	function prepareHTML($dataIndex)
	{
	$Data =& $this->Data[$dataIndex];
	if ($Data['debug_type'] == 'html') {
	return $Data['html'];
	}

	switch ($Data['debug_type']) {
	case 'error':
	$fileLink = $this->getFileLink($Data['file'], $Data['line']);
	$ret = '<b class="debug_error">'.$this->getErrorNameByCode($Data['no']).'</b>: '.$Data['str'];
	$ret .= ' in <b>'.$fileLink.'</b> on line <b>'.$Data['line'].'</b>';
	return $ret;
	break;

	case 'var_dump':
	return $this->highlightString( $this->print_r($Data['value'], true) );
	break;

	case 'strict_var_dump':
	return $this->highlightString( var_export($Data['value'], true) );
	break;

	case 'trace':
	ini_set('memory_limit', '500M');
	$trace =& $Data['trace'];

	$i = 0; $traceCount = count($trace);
	$ret = '';
	while ($i < $traceCount) {
	$traceRec =& $trace[$i];
	$argsID = 'trace_args_'.$dataIndex.'_'.$i;

	$has_args = isset($traceRec['args']);

	if (isset($traceRec['file'])) {
	$func_name = isset($traceRec['class']) ? $traceRec['class'].$traceRec['type'].$traceRec['function'] : $traceRec['function'];
	$args_link = $has_args ? '<a href="javascript:$Debugger.ToggleTraceArgs(\''.$argsID.'\');" title="Show/Hide Function Arguments"><b>Function</b></a>' : '<b>Function</b>';

	$ret .= $args_link.': '.$this->getFileLink($traceRec['file'], $traceRec['line'], $func_name);
	$ret .= ' in <b>'.basename($traceRec['file']).'</b> on line <b>'.$traceRec['line'].'</b><br>';
	}
	else {
	$ret .= 'no file information available';
	}

	if ($has_args) {
	// if parameter value is longer then 200 symbols, then leave only first 50
	$args = $this->highlightString($this->print_r($traceRec['args'], true));
	$ret .= '<div id="'.$argsID.'" style="display: none;">'.$args.'</div>';
	}
	$i++;
	}
	return $ret;
	break;

	case 'profiler':
	$profileKey = $Data['profile_key'];
	$Data =& $this->ProfilerData[$profileKey];
	$runtime = ($Data['ends'] - $Data['begins']); // in seconds

	$totals_key = getArrayValue($Data, 'totalsKey');
	if ($totals_key) {
	$total_before = $Data['totalsBefore'];
	$total = $this->ProfilerTotals[$totals_key];

	$div_width = Array();
	$total_width = ($this->getWindowWidth() - 10);
	$div_width['before'] = round(($total_before / $total) * $total_width);
	$div_width['current'] = round(($runtime / $total) * $total_width);
	$div_width['left'] = round((($total - $total_before - $runtime) / $total) * $total_width);

	$ret = '<b>Name</b>: '.$Data['description'].'<br />';

	$additional = isset($Data['additional']) ? $Data['additional'] : Array ();
	if (isset($Data['file'])) {
	array_unshift($additional, Array('name' => 'File', 'value' => $this->getFileLink($Data['file'], $Data['line'], basename($Data['file']).':'.$Data['line'])));
	}
	array_unshift($additional, Array('name' => 'Runtime', 'value' => $runtime.'s'));

	foreach ($additional as $mixed_param) {
	$ret .= '[<strong>'.$mixed_param['name'].'</strong>: '.$mixed_param['value'].'] ';
	}

	/*if (isset($Data['file'])) {
	$ret .= '[<b>Runtime</b>: '.$runtime.'s] [<b>File</b>: '.$this->getFileLink($Data['file'], $Data['line'], basename($Data['file']).':'.$Data['line']).']<br />';
	}
	else {
	$ret .= '<b>Runtime</b>: '.$runtime.'s<br />';
	}*/

	$ret .= '<div class="dbg_profiler" style="width: '.$div_width['before'].'px; border-right: 0px; background-color: #298DDF;"><img src="'.$this->dummyImage.'" width="1" height="1"/></div>';
	$ret .= '<div class="dbg_profiler" style="width: '.$div_width['current'].'px; border-left: 0px; border-right: 0px; background-color: #EF4A4A;"><img src="'.$this->dummyImage.'" width="1" height="1"/></div>';
	$ret .= '<div class="dbg_profiler" style="width: '.$div_width['left'].'px; border-left: 0px; background-color: #DFDFDF;"><img src="'.$this->dummyImage.'" width="1" height="1"/></div>';

	return $ret;
	}
	else {
	return '<b>Name</b>: '.$Data['description'].'<br><b>Runtime</b>: '.$runtime.'s';
	}
	break;

	default:
	return 'incorrect debug data';
	break;
	}
	}

	function getWindowWidth()
	{
	return DBG_WINDOW_WIDTH - $this->scrollbarWidth - 8;
	}

	/**
	* Tells debugger to skip objects that are heavy in plan of memory usage while printing debug_backtrace results
	*
	* @param Object $object
	* @return bool
	*/
	function IsBigObject(&$object)
	{
	$skip_classes = Array(
	defined('APPLICATION_CLASS') ? APPLICATION_CLASS : 'kApplication',
	'kFactory',
	'kUnitConfigReader',
	'TemplateParser',
	);

	foreach ($skip_classes as $class_name) {
	if (strtolower(get_class($object)) == strtolower($class_name)) {
	return true;
	}
	}

	return false;
	}

	/**
	* Advanced version of print_r (for debugger only). Don't print objects recursively
	*
	* @param Array $array
	* @param bool $return_output return output or print it out
	* @param int $tab_count offset in tabs
	* @return string
	*/
	function print_r(&$array, $return_output = false, $tab_count = -1)
	{
	static $first_line = true;

	// not an array at all
	if (!is_array($array)) {
	switch (gettype($array)) {
	case 'NULL':
	return 'NULL'."\n";
	break;

	case 'object':
	return $this->processObject($array, $tab_count);
	break;

	default:
	// number or string
	if (strlen($array) > 200) {
	$array = substr($array, 0, 50).' ...';
	}
	return $array."\n";
	break;
	}
	}

	$output = '';

	$tab_count++;
	$output .= "Array\n".str_repeat(' ', $tab_count)."(\n";

	$tab_count++;
	$tabsign = $tab_count ? str_repeat(' ', $tab_count) : '';

	$array_keys = array_keys($array);

	foreach ($array_keys as $key) {
	switch (gettype($array[$key])) {
	case 'array':
	$output .= $tabsign.'['.$key.'] = '.$this->print_r($array[$key], true, $tab_count);
	break;

	case 'boolean':
	$output .= $tabsign.'['.$key.'] = '.($array[$key] ? 'true' : 'false')."\n";
	break;

	case 'integer':
	case 'double':
	case 'string':
	if (strlen($array[$key]) > 200) {
	$array[$key] = substr($array[$key], 0, 50).' ...';
	}
	$output .= $tabsign.'['.$key.'] = '.$array[$key]."\n";
	break;

	case 'NULL':
	$output .= $tabsign.'['.$key."] = NULL\n";
	break;

	case 'object':
	$output .= $tabsign.'['.$key."] = ";
	$output .= "Object (".get_class($array[$key]).") = \n".str_repeat(' ', $tab_count + 1)."(\n";
	$output .= $this->processObject($array[$key], $tab_count + 2);
	$output .= str_repeat(' ', $tab_count + 1).")\n";
	break;

	default:
	$output .= $tabsign.'['.$key.'] unknown = '.gettype($array[$key])."\n";
	break;
	}
	}

	$tab_count--;
	$output .= str_repeat(' ', $tab_count).")\n";

	if ($first_line) {
	$first_line = false;
	$output .= "\n";
	}

	$tab_count--;

	if ($return_output) {
	return $output;
	}
	else {
	echo $output;
	}

	return true;
	}

	function processObject(&$object, $tab_count)
	{
	$object_class = get_class($object);
	if (!in_array($object_class, $this->RecursionStack)) {
	if ($this->IsBigObject($object)) {
	return 'SKIPPED (class: '.$object_class.")\n";
	}

	$attribute_names = get_class_vars($object_class);
	if (!$attribute_names) {
	return "NO_ATTRIBUTES\n";
	}
	else {
	$output = '';
	array_push($this->RecursionStack, $object_class);

	$tabsign = $tab_count ? str_repeat(' ', $tab_count) : '';
	foreach ($attribute_names as $attribute_name => $attribute_value) {
	if (is_object($object->$attribute_name)) {
	// it is object
	$output .= $tabsign.'['.$attribute_name.'] = '.$this->processObject($object->$attribute_name, $tab_count + 1);
	}
	else {
	$output .= $tabsign.'['.$attribute_name.'] = '.$this->print_r($object->$attribute_name, true, $tab_count);
	}
	}
	array_pop($this->RecursionStack);
	return $output;
	}
	}
	else {
	// object [in recursion stack]
	return '* RECURSION * (class: '.$object_class.")\n";
	}
	}

	/**
	* Format SQL Query using predefined formatting
	* and highlighting techniques
	*
	* @param string $sql
	* @return string
	*/
	function formatSQL($sql)
	{
	$sql = trim( preg_replace('/(\n\|\t\| )+/is', ' ', $sql) );

	$formatted_sql = preg_replace('/\s(CREATE TABLE\|DROP TABLE\|SELECT\|UPDATE\|SET\|REPLACE\|INSERT\|DELETE\|VALUES\|FROM\|LEFT JOIN\|INNER JOIN\|LIMIT\|WHERE\|HAVING\|GROUP BY\|ORDER BY)\s/is', "\n\t$1 ", ' ' . $sql);
	$formatted_sql = $this->highlightString($formatted_sql);

	if (defined('DBG_SQL_EXPLAIN') && DBG_SQL_EXPLAIN) {
	if (substr($sql, 0, 6) == 'SELECT') {
	$formatted_sql .= '<br/>' . '<strong>Explain</strong>:<br /><br />';
	$explain_result = $this->Application->Conn->Query('EXPLAIN ' . $sql, null, true);

	$explain_table = '';
	foreach ($explain_result as $explain_row) {
	if (!$explain_table) {
	// first row -> draw header
	$explain_table .= '<tr class="explain_header"><td>' . implode('</td><td>', array_keys($explain_row)) . '</td></tr>';
	}
	$explain_table .= '<tr><td>' . implode('</td><td>', $explain_row) . '</td></tr>';
	}

	$formatted_sql .= '<table class="dbg_explain_table">' . $explain_table . '</table>';
	}
	}

	return $formatted_sql;
	}

	function highlightString($string)
	{
	if (!(defined('DBG_USE_HIGHLIGHT') && DBG_USE_HIGHLIGHT)) {
	return $string;
	}

	$string = str_replace( Array('\\', '/') , Array('_no_match_string_', '_n_m_s_'), $string);
	$string = highlight_string('<?php'.$string.'?>', true);
	$string = str_replace( Array('_no_match_string_', '_n_m_s_'), Array('\\', '/'), $string);
	return preg_replace('/<\?(.)php(.)\?>/Us', '\\2', $string);
	}

	/**
	* Determine by php type of browser used to show debugger
	*
	* @return bool
	*/
	function isGecko()
	{
	// we need isset because we may run scripts from shell with no user_agent at all
	return isset($_SERVER['HTTP_USER_AGENT']) && strpos(strtolower($_SERVER['HTTP_USER_AGENT']), 'firefox') !== false;
	}

	/**
	* Returns link for editing php file (from error) in external editor
	*
	* @param string $file filename with path from root folder
	* @param int $lineno line number in file where error is found
	* @param string $title text to show on file edit link
	* @return string
	*/
	function getFileLink($file, $lineno = 1, $title = '')
	{
	if (!$title) {
	$title = str_replace('/', '\\', $this->getLocalFile($file));
	}

	if ($this->isGecko()) {
	return '<a href="file://'.$this->getLocalFile($file).'">'.$title.'</a>';
	}
	else {
	return '<a href="javascript:$Debugger.editFile(\''.$this->getLocalFile($file).'\', '.$lineno.');" title="'.$file.'">'.$title.'</a>';
	}

	}

	/**
	* Converts filepath on server to filepath in mapped DocumentRoot on developer pc
	*
	* @param string $remoteFile
	* @return string
	*/
	function getLocalFile($remoteFile)
	{
	return preg_replace('/^'.preg_quote(DOC_ROOT, '/').'/', DBG_LOCAL_BASE_PATH, $remoteFile, 1);
	}

	/**
	* Appends call trace till this method call
	*
	*/
	function appendTrace()
	{
	$trace = debug_backtrace();
	array_shift($trace);

	$this->Data[] = Array('trace' => $trace, 'debug_type' => 'trace');
	}

	function appendMemoryUsage($msg, $used = null)
	{
	if (!isset($used)) {
	$used = round(memory_get_usage() / 1024);
	}
	$this->appendHTML('<b>Memory usage</b> '.$msg.' '.$used.'Kb');
	}

	/**
	* Appends HTML code whithout transformations
	*
	* @param string $html
	*/
	function appendHTML($html)
	{
	$this->Data[] = Array('html' => $html, 'debug_type' => 'html');
	}

	/**
	* Change debugger info that was already generated before.
	* Returns true if html was set.
	*
	* @param int $index
	* @param string $html
	* @param string $type = {'append','prepend','replace'}
	* @return bool
	*/
	function setHTMLByIndex($index, $html, $type = 'append')
	{
	if (!isset($this->Data[$index]) \|\| $this->Data[$index]['debug_type'] != 'html') {
	return false;
	}

	switch ($type) {
	case 'append':
	$this->Data[$index]['html'] .= '<br>'.$html;
	break;

	case 'prepend':
	$this->Data[$index]['html'] = $this->Data[$index]['html'].'<br>'.$html;
	break;

	case 'replace':
	$this->Data[$index]['html'] = $html;
	break;
	}
	return true;
	}

	/**
	* Move $debugLineCount lines of input from debug output
	* end to beginning.
	*
	* @param int $debugLineCount
	*/
	function moveToBegin($debugLineCount)
	{
	$lines = array_splice($this->Data,count($this->Data)-$debugLineCount,$debugLineCount);
	$this->Data = array_merge($lines,$this->Data);
	}

	function moveAfterRow($new_row, $debugLineCount)
	{
	$lines = array_splice($this->Data,count($this->Data)-$debugLineCount,$debugLineCount);
	$rows_before = array_splice($this->Data,0,$new_row,$lines);
	$this->Data = array_merge($rows_before,$this->Data);
	}

	function appendRequest()
	{
	if (isset($_SERVER['SCRIPT_FILENAME'])) {
	$script = $_SERVER['SCRIPT_FILENAME'];
	}
	else {
	$script = $_SERVER['DOCUMENT_ROOT'].$_SERVER['PHP_SELF'];
	}

	$this->appendHTML('ScriptName: <b>'.$this->getFileLink($script, 1, basename($script)).'</b> (<b>'.dirname($script).'</b>)');
	if (isset($_REQUEST['ajax']) && $_REQUEST['ajax'] == 'yes') {
	$this->appendHTML('RequestURI: '.$_SERVER['REQUEST_URI'].' (QS Length:'.strlen($_SERVER['QUERY_STRING']).')');
	}

	$tools_html = ' <table style="width: ' . $this->getWindowWidth() . 'px;">
	<tr>
	<td>' . $this->_getDomViewerHTML() . '</td>
	<td>' . $this->_getToolsHTML() . '</td>
	</tr>
	</table>';
	$this->appendHTML($tools_html);

	ob_start();
	?>
	<table border="0" cellspacing="0" cellpadding="0" class="dbg_flat_table" style="width: <?php echo $this->getWindowWidth(); ?>px;">
	<thead style="font-weight: bold;">
	<td width="20">Src</td><td>Name</td><td>Value</td>
	</thead>
	<?php
	foreach ($_REQUEST as $key => $value) {
	if(!is_array($value) && trim($value) == '') {
	$value = '<b class="debug_error">no value</b>';
	}
	else {
	$value = htmlspecialchars($this->print_r($value, true));
	}

	$in_cookie = isset($_COOKIE[$key]);
	$src = isset($_GET[$key]) && !$in_cookie ? 'GE' : (isset($_POST[$key]) && !$in_cookie ? 'PO' : ($in_cookie ? 'CO' : '?') );
	echo '<tr><td>'.$src.'</td><td>'.$key.'</td><td>'.$value.'</td></tr>';
	}
	?>
	</table>
	<?php
	$this->appendHTML(ob_get_contents());
	ob_end_clean();
	}

	/**
	* Appends php session content to debugger output
	*
	*/
	function appendSession()
	{
	if (isset($_SESSION) && $_SESSION) {
	$this->appendHTML('PHP Session: [<b>'.ini_get('session.name').'</b>]');
	$this->dumpVars($_SESSION);
	$this->moveToBegin(2);
	}
	}

	function profileStart($key, $description = null, $timeStamp = null)
	{
	if (!isset($timeStamp)) {
	$timeStamp = $this->getMoment();
	}
	$this->ProfilerData[$key] = Array('begins' => $timeStamp, 'ends' => 5000, 'debuggerRowID' => count($this->Data));
	if (isset($description)) {
	$this->ProfilerData[$key]['description'] = $description;
	}

	if (substr($key, 0, 4) == 'sql_') {
	// append place from what was called
	$trace_results = debug_backtrace();
	$trace_count = count($trace_results);
	$i = 0;
	while ($i < $trace_count) {
	$trace_file = basename($trace_results[$i]['file']);
	if ($trace_file != 'db_connection.php' && $trace_file != 'adodb.inc.php') {
	break;
	}
	$i++;
	}
	$this->ProfilerData[$key]['file'] = $trace_results[$i]['file'];
	$this->ProfilerData[$key]['line'] = $trace_results[$i]['line'];
	unset($trace_results);
	}

	$this->Data[] = Array('profile_key' => $key, 'debug_type' => 'profiler');
	}

	function profileFinish($key, $description = null, $timeStamp = null)
	{
	if (!isset($timeStamp)) {
	$timeStamp = $this->getMoment();
	}
	$this->ProfilerData[$key]['ends'] = $timeStamp;

	if (isset($description)) {
	$this->ProfilerData[$key]['description'] = $description;
	}

	if (substr($key, 0, 4) == 'sql_') {
	$func_arguments = func_get_args();
	$rows_affected = $func_arguments[3];

	$additional = Array ();

	if ($rows_affected > 0) {
	$additional[] = Array ('name' => 'Affected Rows', 'value' => $rows_affected);

	if (isset($func_arguments[4])) {
	$additional[] = Array ('name' => 'Result', 'value' => $func_arguments[4]);
	}
	}

	$additional[] = Array ('name' => 'Query Number', 'value' => $func_arguments[5]);
	$this->ProfilerData[$key]['additional'] =& $additional;
	}
	}

	function profilerAddTotal($total_key, $key = null, $value = null)
	{
	if (!isset($this->ProfilerTotals[$total_key])) {
	$this->ProfilerTotals[$total_key] = 0;
	$this->ProfilerTotalCount[$total_key] = 0;
	}

	if (!isset($value)) {
	$value = $this->ProfilerData[$key]['ends'] - $this->ProfilerData[$key]['begins'];
	}

	if (isset($key)) {
	$this->ProfilerData[$key]['totalsKey'] = $total_key;
	$this->ProfilerData[$key]['totalsBefore'] = $this->ProfilerTotals[$total_key];
	}

	$this->ProfilerTotals[$total_key] += $value;
	$this->ProfilerTotalCount[$total_key]++;
	}

	function getMoment()
	{
	list($usec, $sec) = explode(' ', microtime());
	return ((float)$usec + (float)$sec);
	}
	+
	+ function appendTimestamp($message)
	+ {
	+ global $start;
	+ $time = $this->getMoment();
	+ $from_last = $time - $this->LastMoment;
	+ $from_start = $time - $start;
	+ $this->appendHTML(sprintf("<b>%s</b> %.5f from last %.5f from start", $message, $from_last, $from_start));
	+ $this->LastMoment = $time;
	+ }

	function generateID()
	{
	list($usec, $sec) = explode(' ', microtime());

	$id_part_1 = substr($usec, 4, 4);
	$id_part_2 = mt_rand(1,9);
	$id_part_3 = substr($sec, 6, 4);
	$digit_one = substr($id_part_1, 0, 1);
	if ($digit_one == 0) {
	$digit_one = mt_rand(1,9);
	$id_part_1 = ereg_replace("^0",'',$id_part_1);
	$id_part_1=$digit_one.$id_part_1;
	}
	return $id_part_1.$id_part_2.$id_part_3;
	}


	function getErrorNameByCode($error_code)
	{
	$error_map = Array(
	'Fatal Error' => Array(E_USER_ERROR),
	'Warning' => Array(E_WARNING, E_USER_WARNING),
	'Notice' => Array(E_NOTICE, E_USER_NOTICE),
	);

	if (defined('E_STRICT')) {
	$error_map['PHP5 Strict'] = Array(E_STRICT);
	}

	if (defined('E_RECOVERABLE_ERROR')) {
	$error_map['Fatal Error (recoverable)'] = Array(E_RECOVERABLE_ERROR);
	}

	foreach ($error_map as $error_name => $error_codes) {
	if (in_array($error_code, $error_codes)) {
	return $error_name;
	}
	}

	return '';
	}

	/**
	* Returns profile total key (check against unexisting key too)
	*
	* @param string $key
	* @return int
	*/
	function getProfilerTotal($key)
	{
	if (isset($this->ProfilerTotalCount[$key])) {
	return (int)$this->ProfilerTotalCount[$key];
	}
	return 0;
	}

	function ProfilePoint($title, $level=1)
	{
	$trace_results = debug_backtrace();
	$level = min($level,count($trace_results)-1);

	do {
	$point = $trace_results[$level];
	$location = $point['file'].':'.$point['line'];
	$level++;
	$has_more = isset($trace_results[$level]);
	} while ($has_more && $point['function'] == $trace_results[$level]['function'] );

	if ($location == ':') {
	echo '';
	}

	if (!isset($this->ProfilePoints[$title])) {
	$this->ProfilePoints[$title] = array();
	}
	if (!isset($this->ProfilePoints[$title][$location])) {
	$this->ProfilePoints[$title][$location] = 0;
	}
	$this->ProfilePoints[$title][$location]++;
	}

	/**
	* Generates report
	*
	*/
	function printReport($returnResult = false, $clean_output_buffer = true)
	{
	if ($this->reportDone) {
	// don't print same report twice (in case if shutdown function used + compression + fatal error)
	return '';
	}

	$this->profileFinish('script_runtime');
	$this->breakOutofBuffering();

	$debugger_start = memory_get_usage();

	if (defined('SPACER_URL')) {
	$this->dummyImage = SPACER_URL;
	}

	$this->InitReport(); // set parameters required by AJAX

	// defined here, because user can define this contant while script is running, not event before debugger is started
	$this->safeDefine('DBG_RAISE_ON_WARNINGS', 0);
	$this->safeDefine('DBG_TOOLBAR_BUTTONS', 1);

	$this->appendSession(); // show php session if any

	// ensure, that 1st line of debug output always is this one:
	$top_line = '<table cellspacing="0" cellpadding="0" style="width: '.$this->getWindowWidth().'px; margin: 0px;"><tr><td align="left" width="50%">[<a href="javascript:window.location.reload();">Reload Frame</a>] [<a href="javascript:$Debugger.Toggle(27);">Hide Debugger</a>]</td><td align="right" width="50%">[Current Time: <b>'.date('H:i:s').'</b>] [File Size: <b>#DBG_FILESIZE#</b>]</td></tr></table>';

	$this->appendHTML($top_line);
	$this->moveToBegin(1);

	if (count($this->ProfilePoints)>0) {
	foreach($this->ProfilePoints as $point => $locations) {
	arsort($this->ProfilePoints[$point]);
	}

	$this->appendHTML($this->highlightString($this->print_r($this->ProfilePoints, true)));
	/*foreach ($this->ProfilePoints as $point => $locations) {
	foreach ($locations as $location => $occurences) {


	}
	}*/
	}

	if ($this->constOn('DBG_SQL_PROFILE') && isset($this->ProfilerTotals['sql'])) {
	// sql query profiling was enabled -> show totals
	$this->appendHTML('<b>SQL Total time:</b> '.$this->ProfilerTotals['sql'].' <b>Number of queries</b>: '.$this->ProfilerTotalCount['sql']);
	}

	if ($this->constOn('DBG_PROFILE_INCLUDES') && isset($this->ProfilerTotals['includes'])) {
	// included file profiling was enabled -> show totals
	$this->appendHTML('<b>Included Files Total time:</b> '.$this->ProfilerTotals['includes'].' Number of includes: '.$this->ProfilerTotalCount['includes']);
	}

	if ($this->constOn('DBG_PROFILE_MEMORY')) {
	// detailed memory usage reporting by objects was enabled -> show totals
	$this->appendHTML('<b>Memory used by Objects:</b> '.round($this->ProfilerTotals['objects'] / 1024, 2).'Kb');
	}

	if ($this->constOn('DBG_INCLUDED_FILES')) {
	$files = get_included_files();
	$this->appendHTML('<b>Included files:</b>');
	foreach ($files as $file) {
	$this->appendHTML($this->getFileLink($this->getLocalFile($file)).' ('.round(filesize($file) / 1024, 2).'Kb)');
	}
	}

	- /*if ($this->constOn('DBG_PROFILE_INCLUDES')) {
	+ if ($this->constOn('DBG_PROFILE_INCLUDES')) {
	$this->appendHTML('<b>Included files statistics:</b>'.( $this->constOn('DBG_SORT_INCLUDES_MEM') ? ' (sorted by memory usage)':''));
	$totals = Array( 'mem' => 0, 'time' => 0);
	$totals_configs = Array( 'mem' => 0, 'time' => 0);
	if (is_array($this->IncludesData['mem'])) {
	if ( $this->constOn('DBG_SORT_INCLUDES_MEM') ) {
	array_multisort($this->IncludesData['mem'], SORT_DESC, $this->IncludesData['file'], $this->IncludesData['time'], $this->IncludesData['level']);
	}
	foreach ($this->IncludesData['file'] as $key => $file_name) {
	$this->appendHTML( str_repeat(' -> ', ($this->IncludesData['level'][$key] >= 0 ? $this->IncludesData['level'][$key] : 0)).$file_name.' Mem: '.sprintf("%.4f Kb", $this->IncludesData['mem'][$key]/1024).' Time: '.sprintf("%.4f", $this->IncludesData['time'][$key]));
	if ($this->IncludesData['level'][$key] == 0) {
	$totals['mem'] += $this->IncludesData['mem'][$key];
	$totals['time'] += $this->IncludesData['time'][$key];
	}
	else if ($this->IncludesData['level'][$key] == -1) {
	$totals_configs['mem'] += $this->IncludesData['mem'][$key];
	$totals_configs['time'] += $this->IncludesData['time'][$key];
	}
	}
	$this->appendHTML('<b>Sub-Total classes:</b> '.' Mem: '.sprintf("%.4f Kb", $totals['mem']/1024).' Time: '.sprintf("%.4f", $totals['time']));
	$this->appendHTML('<b>Sub-Total configs:</b> '.' Mem: '.sprintf("%.4f Kb", $totals_configs['mem']/1024).' Time: '.sprintf("%.4f", $totals_configs['time']));
	$this->appendHTML('<span class="error"><b>Grand Total:</b></span> '.' Mem: '.sprintf("%.4f Kb", ($totals['mem']+$totals_configs['mem'])/1024).' Time: '.sprintf("%.4f", $totals['time']+$totals_configs['time']));
	}
	- }*/
	+ }

	$is_ajax = isset($_GET['ajax']) && $_GET['ajax'] == 'yes';
	$skip_reporting = $this->constOn('DBG_SKIP_REPORTING') \|\| $this->constOn('DBG_ZEND_PRESENT');

	if (($is_ajax && !constOn('DBG_SKIP_AJAX')) \|\| !$skip_reporting) {
	$debug_file = $this->tempFolder.'/debug_'.$this->rowSeparator.'.txt';
	if (file_exists($debug_file)) unlink($debug_file);

	$i = 0;
	$fp = fopen($debug_file, 'a');
	$lineCount = count($this->Data);
	while ($i < $lineCount) {
	fwrite($fp, $this->prepareHTML($i).$this->rowSeparator);
	$i++;
	}
	fclose($fp);
	}

	if ($skip_reporting) {
	// let debugger write report and then don't output anything
	$this->reportDone = true;
	return '';
	}

	$application =& kApplication::Instance();
	$dbg_path = str_replace(FULL_PATH, '', $this->tempFolder);

	ob_start();
	// the <script .. /script> and hidden div helps browser to break out of script tag or attribute esacped
	// with " or ' in case fatal error (or user-error) occurs inside it in compiled template,
	// otherwise it has no effect
	?>
	<div style="display: none" x='nothing'><script></script></div><html><body></body></html>
	<script type="text/javascript" src="<?php echo $this->baseURL; ?>/debugger.js"></script>
	<link rel="stylesheet" rev="stylesheet" href="<?php echo $this->baseURL; ?>/debugger.css" type="text/css" media="screen" />
	<div id="debug_layer" class="debug_layer_container" style="display: none; width: <?php echo DBG_WINDOW_WIDTH; ?>px;">
	<div class="debug_layer" style="width: <?php echo $this->getWindowWidth(); ?>px;">
	<table width="100%" cellpadding="0" cellspacing="1" border="0" class="debug_layer_table" style="width: <?php echo $this->getWindowWidth(); ?>px;" align="left">
	<tbody id="debug_table"></tbody>
	</table>
	</div>
	</div>

	<script type="text/javascript">
	var $Debugger = new Debugger(<?php echo "'".$this->rowSeparator."', ".$this->getProfilerTotal('error_handling').', '.($this->IsFatalError ? 'true' : 'false').', '.$this->getProfilerTotal('sql'); ?>);
	$Debugger.DOMViewerURL = '<?php echo constant('DBG_DOMVIEWER'); ?>';
	$Debugger.EditorPath = '<?php echo defined('DBG_EDITOR') ? addslashes(DBG_EDITOR) : '' ?>';
	$Debugger.DebugURL = '<?php echo $this->baseURL.'/debugger_responce.php?sid='.$this->rowSeparator.'&path='.urlencode($dbg_path); ?>';
	$Debugger.EventURL = '<?php echo $application->HREF('dummy', '', Array ('pass' => 'm')); ?>';
	<?php
	if ($this->IsFatalError \|\| DBG_RAISE_ON_WARNINGS) {
	echo '$Debugger.Toggle();';
	}
	if (DBG_TOOLBAR_BUTTONS) {
	echo '$Debugger.AddToolbar("$Debugger");';
	}
	?>
	window.focus();
	</script>
	<?php
	if (!isset($this->ProfilerTotals['error_handling'])) {
	$memory_used = $debugger_start;
	$this->ProfilerTotalCount['error_handling'] = 0;
	}
	else {
	$memory_used = $debugger_start - $this->ProfilerTotals['error_handling'];
	}

	if ($returnResult) {
	$ret = ob_get_contents();
	if ($clean_output_buffer) {
	ob_end_clean();
	}
	$ret .= $this->getShortReport($memory_used);

	$this->reportDone = true;
	return $ret;
	}
	else {
	if (!$this->constOn('DBG_HIDE_FULL_REPORT')) {
	$this->breakOutofBuffering();
	}
	elseif ($clean_output_buffer) {
	ob_clean();
	}
	echo $this->getShortReport($memory_used);

	$this->reportDone = true;
	}
	}

	/**
	* Format's memory usage report by debugger
	*
	* @return string
	* @access private
	*/
	function getShortReport($memory_used)
	{
	if ($this->constOn('DBG_TOOLBAR_BUTTONS')) {
	// we have sql & error count in toolbar, don't duplicate here
	$info = Array(
	'Script Runtime' => 'PROFILE:script_runtime',
	'SQL\'s Runtime' => 'PROFILE_T:sql',
	);
	}
	else {
	// toolbar not visible, then show sql & error count too
	$info = Array (
	'Script Runtime' => 'PROFILE:script_runtime',
	'SQL\'s Runtime' => 'PROFILE_T:sql',
	'-' => 'SEP:-',
	'Notice / Warning' => 'PROFILE_TC:error_handling',
	'SQLs Count' => 'PROFILE_TC:sql',
	);
	}

	$ret = '<tr><td>Application:</td><td><b>'.$this->formatSize($memory_used).'</b> ('.$memory_used.')</td></tr>';
	foreach ($info as $title => $value_key) {
	list ($record_type, $record_data) = explode(':', $value_key, 2);
	switch ($record_type) {
	case 'PROFILE': // profiler totals value
	$Data =& $this->ProfilerData[$record_data];
	$profile_time = ($Data['ends'] - $Data['begins']); // in seconds
	$ret .= '<tr><td>'.$title.':</td><td><b>'.sprintf('%.5f', $profile_time).' s</b></td></tr>';
	break;

	case 'PROFILE_TC': // profile totals record count
	$record_cell = '<td>';
	if ($record_data == 'error_handling' && $this->ProfilerTotalCount[$record_data] > 0) {
	$record_cell = '<td class="debug_error">';
	}
	$ret .= '<tr>'.$record_cell.$title.':</td>'.$record_cell.'<b>'.$this->ProfilerTotalCount[$record_data].'</b></td></tr>';
	break;

	case 'PROFILE_T': // profile total
	$record_cell = '<td>';
	$total = array_key_exists($record_data, $this->ProfilerTotals) ? $this->ProfilerTotals[$record_data] : 0;
	$ret .= '<tr>'.$record_cell.$title.':</td>'.$record_cell.'<b>'.sprintf('%.5f', $total).' s</b></td></tr>';
	break;

	case 'SEP':
	$ret .= '<tr><td colspan="2" style="height: 1px; background-color: #000000; padding: 0px;"><img src="'.$this->dummyImage.'" height="1" alt=""/></td></tr>';
	break;
	}
	}

	return '<br /><table class="dbg_stats_table"><tr><td style="border-color: #FFFFFF;"><table class="dbg_stats_table" align="left">'.$ret.'</table></td></tr></table>';
	}

	/**
	* User-defined error handler
	*
	* @param int $errno
	* @param string $errstr
	* @param string $errfile
	* @param int $errline
	* @param array $errcontext
	*/
	function saveError($errno, $errstr, $errfile = '', $errline = '', $errcontext = '')
	{
	$this->ProfilerData['error_handling']['begins'] = memory_get_usage();

	$errorType = $this->getErrorNameByCode($errno);
	if (!$errorType) {
	trigger_error('Unknown error type ['.$errno.']', E_USER_ERROR);
	return false;
	}

	if ($this->constOn('DBG_IGNORE_STRICT_ERRORS') && defined('E_STRICT') && ($errno == E_STRICT)) return;

	if (preg_match('/(.*)#([\d]+)$/', $errstr, $rets) ) {
	// replace short message with long one (due triger_error limitations on message size)
	$long_id = $rets[2];
	$errstr = $this->longErrors[$long_id];
	unset($this->longErrors[$long_id]);
	}

	if (strpos($errfile,'eval()\'d code') !== false) {
	$errstr = '[<b>EVAL</b>, line <b>'.$errline.'</b>]: '.$errstr;
	$tmpStr = $errfile;
	$pos = strpos($tmpStr,'(');
	$errfile = substr($tmpStr, 0, $pos);
	$pos++;
	$errline = substr($tmpStr,$pos,strpos($tmpStr,')',$pos)-$pos);
	}

	$this->Data[] = Array('no' => $errno, 'str' => $errstr, 'file' => $errfile, 'line' => $errline, 'context' => $errcontext, 'debug_type' => 'error');
	$this->ProfilerData['error_handling']['ends'] = memory_get_usage();
	$this->profilerAddTotal('error_handling', 'error_handling');
	if (substr($errorType, 0, 5) == 'Fatal') {
	$this->IsFatalError = true;
	// append debugger report to data in buffer & clean buffer afterwards
	die( $this->breakOutofBuffering(false) . $this->printReport(true) );
	}
	}

	function breakOutofBuffering($flush = true)
	{
	$buffer_content = Array();
	while (ob_get_level()) {
	$buffer_content[] = ob_get_clean();
	}
	$ret = implode('', array_reverse($buffer_content));
	if ($flush) {
	echo $ret;
	flush();
	}
	return $ret;
	}

	function saveToFile($msg)
	{
	$fp = fopen($_SERVER['DOCUMENT_ROOT'].'/vb_debug.txt', 'a');
	fwrite($fp, $msg."\n");
	fclose($fp);
	}

	/**
	* Formats file/memory size in nice way
	*
	* @param int $bytes
	* @return string
	* @access public
	*/
	function formatSize($bytes)
	{
	if ($bytes >= 1099511627776) {
	$return = round($bytes / 1024 / 1024 / 1024 / 1024, 2);
	$suffix = "TB";
	} elseif ($bytes >= 1073741824) {
	$return = round($bytes / 1024 / 1024 / 1024, 2);
	$suffix = "GB";
	} elseif ($bytes >= 1048576) {
	$return = round($bytes / 1024 / 1024, 2);
	$suffix = "MB";
	} elseif ($bytes >= 1024) {
	$return = round($bytes / 1024, 2);
	$suffix = "KB";
	} else {
	$return = $bytes;
	$suffix = "Byte";
	}
	$return .= ' '.$suffix;
	return $return;
	}

	function printConstants($constants)
	{
	if (!is_array($constants)) {
	$constants = explode(',', $constants);
	}
	$contant_tpl = '<tr><td>%s</td><td><b>%s</b></td></tr>';
	$ret = '<table class="dbg_flat_table" style="width: '.$this->getWindowWidth().'px;">';
	foreach ($constants as $constant_name) {
	$ret .= sprintf($contant_tpl, $constant_name, constant($constant_name));
	}
	$ret .= '</table>';
	$this->appendHTML($ret);
	}

	function AttachToApplication() {
	if (!$this->constOn('DBG_HANDLE_ERRORS')) {
	return true;
	}

	if (class_exists('kApplication')) {
	restore_error_handler();
	$this->Application =& kApplication::Instance();
	$this->Application->Debugger =& $this;
	$this->Application->errorHandlers[] = Array(&$this, 'saveError');
	}
	else {
	set_error_handler(Array(&$this, 'saveError'));
	}
	}

	/**
	* Returns HTML for tools section
	*
	* @return string
	*/
	function _getToolsHTML()
	{
	$html = '<table>
	<tr>
	<td>System Tools:</td>
	<td>
	<select id="reset_cache" style="border: 1px solid #000000;">
	<option value=""></option>
	<option value="events[adm][OnResetModRwCache]">Reset mod_rewrite Cache</option>
	<option value="events[adm][OnResetCMSMenuCache]">Reset SMS Menu Cache</option>
	<option value="events[adm][OnResetSections]">Reset Sections Cache</option>
	<option value="events[adm][OnResetConfigsCache]">Reset Configs Cache</option>
	<option value="events[adm][OnRebuildThemes]">Re-build Themes Files</option>
	<option value="events[lang][OnReflectMultiLingualFields]">Re-build Multilanguage Fields</option>
	</select>
	</td>
	<td>
	<input type="button" class="button" onclick="$Debugger.resetCache(\'reset_cache\');" value="Go"/>
	</td>
	</tr>
	</table>';

	return $html;
	}

	/**
	* Returns HTML for dom viewer section
	*
	* @return string
	*/
	function _getDomViewerHTML()
	{
	$html = '<table>
	<tr>
	<td>
	<a href="http://www.brainjar.com/dhtml/domviewer/" target="_blank">DomViewer</a>:
	</td>
	<td>
	<input id="dbg_domviewer" type="text" value="window" style="border: 1px solid #000000;"/>
	</td>
	<td>
	<button class="button" onclick="return $Debugger.OpenDOMViewer();">Show</button>
	</td>
	</tr>
	</table>';

	return $html;
	}
	}

	if (!function_exists('memory_get_usage')) {
	function memory_get_usage(){ return -1; }
	}

	if (!Debugger::constOn('DBG_ZEND_PRESENT')) {
	$debugger = new Debugger();
	}

	if (Debugger::constOn('DBG_USE_SHUTDOWN_FUNC')) {
	register_shutdown_function( Array(&$debugger, 'printReport') );
	}
	}
	?>
	\ No newline at end of file

	Property changes on: branches/RC/core/kernel/utility/debugger.php
	___________________________________________________________________
	Modified: cvs2svn:cvs-rev
	## -1 +1 ##
	-1.76.2.6
	\ No newline at end of property
	+1.76.2.7
	\ No newline at end of property
	Index: branches/RC/core/kernel/utility/unit_config_reader.php
	===================================================================
	--- branches/RC/core/kernel/utility/unit_config_reader.php (revision 10579)
	+++ branches/RC/core/kernel/utility/unit_config_reader.php (revision 10580)
	@@ -1,833 +1,851 @@
	<?php

	class kUnitConfigReader extends kBase {

	/**
	* Configs readed
	*
	* @var Array
	* @access private
	*/
	var $configData = Array();
	var $configFiles = Array();

	var $CacheExpired = false;

	var $prefixFiles = array();

	var $ProcessAllConfigs = false;
	var $FinalStage = false;
	var $StoreCache = false;
	var $AfterConfigProcessed = array();

	/**
	* Scan kernel and user classes
	* for available configs
	*
	* @access protected
	*/
	function Init($prefix,$special)
	{
	parent::Init($prefix,$special);
	}

	function CacheParsedData()
	{
	$event_manager =& $this->Application->recallObject('EventManager');
	$aggregator =& $this->Application->recallObject('TagsAggregator', 'kArray');

	$config_vars = Array (
	'SessionTimeout',
	'SessionCookieName',
	'SessionReferrerCheck',
	'CookieSessions',
	'UseCronForRegularEvent',
	'User_GuestGroup',
	'User_LoggedInGroup',
	'SessionTimeout',
	'UseModRewrite',
	'UseOutputCompression',
	'OutputCompressionLevel',
	'KeepSessionOnBrowserClose',
	+ 'Config_Server_Time',
	+ 'Config_Site_Time',
	+ 'UseChangeLog',
	);

	foreach ($config_vars as $var) {
	$this->Application->ConfigValue($var);
	}

	$cache = Array(
	'Factory.Files' => $this->Application->Factory->Files,
	'Factory.realClasses' => $this->Application->Factory->realClasses,
	'Factory.Dependencies' => $this->Application->Factory->Dependencies,
	'ConfigReader.prefixFiles' => $this->prefixFiles,
	'EventManager.buildEvents' => $event_manager->buildEvents,
	'EventManager.beforeRegularEvents' => $event_manager->beforeRegularEvents,
	'EventManager.afterRegularEvents' => $event_manager->afterRegularEvents,
	'EventManager.beforeHooks' => $event_manager->beforeHooks,
	'EventManager.afterHooks' => $event_manager->afterHooks,
	'TagsAggregator.data' => $aggregator->_Array,

	// the following caches should be reset based on admin interaction (adjusting config, enabling modules etc)
	'Application.Caches.ConfigVariables' => $this->Application->Caches['ConfigVariables'],
	'Application.ConfigCacheIds' => $this->Application->ConfigCacheIds,
	'Application.ConfigHash' => $this->Application->ConfigHash,
	'Application.ReplacementTemplates' => $this->Application->ReplacementTemplates,
	'Application.ModuleInfo' => $this->Application->ModuleInfo,
	);

	$conn =& $this->Application->GetADODBConnection();
	- $conn->Query('REPLACE '.TABLE_PREFIX.'Cache (VarName, Data, Cached) VALUES ("configs_parsed", '.$conn->qstr(serialize($cache)).', '.adodb_mktime().')');
	- $conn->Query('REPLACE '.TABLE_PREFIX.'Cache (VarName, Data, Cached) VALUES ("config_files", '.$conn->qstr(serialize($this->configFiles)).', '.adodb_mktime().')');
	+ if (isset($this->Application->Memcached)) {
	+ $this->Application->Memcached->set('master:configs_parsed', serialize($cache));
	+ $this->Application->Memcached->set('master:config_files', serialize($this->configFiles));
	+ }
	+ else {
	+ $conn->Query('REPLACE '.TABLE_PREFIX.'Cache (VarName, Data, Cached) VALUES ("configs_parsed", '.$conn->qstr(serialize($cache)).', '.adodb_mktime().')');
	+ $conn->Query('REPLACE '.TABLE_PREFIX.'Cache (VarName, Data, Cached) VALUES ("config_files", '.$conn->qstr(serialize($this->configFiles)).', '.adodb_mktime().')');
	+ }
	unset($this->configFiles);
	}

	function RestoreParsedData()
	{
	$conn =& $this->Application->GetADODBConnection();
	- $data = $conn->GetRow('SELECT Data, Cached FROM '.TABLE_PREFIX.'Cache WHERE VarName = "configs_parsed"');
	- if ($data && $data['Cached'] > 0 ) {
	- $cache = unserialize($data['Data']);
	+ if (!isset($this->Application->Memcached) \|\| !($data = $this->Application->Memcached->get('master:configs_parsed'))) {
	+ $data = $conn->GetOne('SELECT Data FROM '.TABLE_PREFIX.'Cache WHERE VarName = "configs_parsed"');
	+ }
	+ if ($data) {
	+ $cache = unserialize($data);
	$this->Application->Factory->Files = $cache['Factory.Files'];
	$this->Application->Factory->realClasses = $cache['Factory.realClasses'];
	$this->Application->Factory->Dependencies = $cache['Factory.Dependencies'];
	$this->prefixFiles = $cache['ConfigReader.prefixFiles'];

	$event_manager =& $this->Application->recallObject('EventManager');
	$event_manager->buildEvents = $cache['EventManager.buildEvents'];
	$event_manager->beforeRegularEvents = $cache['EventManager.beforeRegularEvents'];
	$event_manager->afterRegularEvents = $cache['EventManager.afterRegularEvents'];
	$event_manager->beforeHooks = $cache['EventManager.beforeHooks'];
	$event_manager->afterHooks = $cache['EventManager.afterHooks'];

	$aggregator =& $this->Application->recallObject('TagsAggregator', 'kArray');
	$aggregator->_Array = $cache['TagsAggregator.data'];

	$this->Application->ConfigHash = $cache['Application.ConfigHash'];

	$this->Application->Caches['ConfigVariables'] = $cache['Application.ConfigCacheIds'];
	$this->Application->ConfigCacheIds = $cache['Application.ConfigCacheIds'];

	$this->Application->ReplacementTemplates = $cache['Application.ReplacementTemplates'];

	$this->Application->ModuleInfo = $cache['Application.ModuleInfo'];

	return true;

	}
	else return false;
	}

	function ResetParsedData($include_sections = false)
	{
	$conn =& $this->Application->GetADODBConnection();
	$conn->Query('DELETE FROM '.TABLE_PREFIX.'Cache WHERE VarName = "configs_parsed"');
	+ if (isset($this->Application->Memcached)) {
	+ $this->Application->Memcached->delete('master:configs_parsed');
	+ }

	if ($include_sections) {
	$conn->Query('DELETE FROM '.TABLE_PREFIX.'Cache WHERE VarName = "sections_parsed"');
	+ if (isset($this->Application->Memcached)) {
	+ $this->Application->Memcached->delete('master:sections_parsed');
	+ }
	}
	}

	function scanModules($folderPath, $cache = true)
	{
	if (defined('IS_INSTALL') && IS_INSTALL && !defined('FORCE_CONFIG_CACHE')) {
	// disable config caching during installation
	$cache = false;
	}

	if ($cache) {
	$restored = $this->RestoreParsedData();
	if ($restored) return;
	}

	$this->ProcessAllConfigs = true;

	$this->includeConfigFiles($folderPath, $cache);
	$this->ParseConfigs();

	// tell AfterConfigRead to store cache if neede
	// can't store it here beacuse AfterConfigRead needs ability to change config data
	$this->StoreCache = $cache;
	}

	function findConfigFiles($folderPath)
	{
	// if FULL_PATH = "/" ensure, that all "/" in $folderPath are not deleted
	$reg_exp = '/^'.preg_quote(FULL_PATH, '/').'/';
	$folderPath = preg_replace($reg_exp, '', $folderPath, 1); // this make sense, since $folderPath may NOT contain FULL_PATH

	$fh = opendir(FULL_PATH.$folderPath);
	while (($sub_folder = readdir($fh))) {
	$full_path = FULL_PATH.$folderPath.'/'.$sub_folder;
	if ($this->isDir($full_path)) {
	//the following is to exclude OLD, not removed files when upgrading to 'core'
	if (preg_match('/^\/kernel\/kernel4\//', $folderPath) \|\| ($folderPath == '/kernel/units' && file_exists(FULL_PATH.$this->getConfigName('/core/units/'.$sub_folder)))) {
	continue;
	}
	if (file_exists(FULL_PATH.$this->getConfigName($folderPath.'/'.$sub_folder))) {
	$this->configFiles[] = $this->getConfigName($folderPath.'/'.$sub_folder);
	}
	$this->findConfigFiles($full_path);

	// if (filemtime($full_path) > $cached) { }

	}
	}
	}

	function includeConfigFiles($folderPath, $cache = true)
	{
	$this->Application->refreshModuleInfo();

	$conn =& $this->Application->GetADODBConnection();
	- $data = $conn->GetRow('SELECT Data, Cached FROM '.TABLE_PREFIX.'Cache WHERE VarName = "config_files"');
	+ if (!isset($this->Application->Memcached) \|\| !($data = $this->Application->Memcached->get('master:config_files'))) {
	+ $data = $conn->GetOne('SELECT Data FROM '.TABLE_PREFIX.'Cache WHERE VarName = "config_files"');
	+ }
	if ($cache && $data) {
	- $this->configFiles = unserialize($data['Data']);
	+ $this->configFiles = unserialize($data);
	shuffle($this->configFiles);
	- $files_cached = $data['Cached'];
	}
	else {
	$this->findConfigFiles($folderPath); // search from base directory
	}

	foreach ($this->configFiles as $filename)
	{
	$prefix = $this->PreloadConfigFile($filename);
	if (!$prefix) {
	trigger_error('Prefix not defined in config file '.$filename, E_USER_ERROR);
	}
	}
	}

	/**
	* Process all read config files - called ONLY when there is no cache!
	*
	*/
	function ParseConfigs()
	{
	// 1. process normal configs and their dependencies
	$prioritized_configs = array();
	foreach ($this->configData as $prefix => $config) {
	if (isset($config['ConfigPriority'])) {
	$prioritized_configs[$prefix] = $config['ConfigPriority'];
	continue;
	}
	$this->parseConfig($prefix);
	}

	foreach ($this->configData as $prefix => $config) {
	$this->ProcessDependencies($prefix);
	$this->postProcessConfig($prefix, 'AggregateConfigs', 'sub_prefix');
	$clones = $this->postProcessConfig($prefix, 'Clones', 'prefix');
	}

	// 2. process prioritized configs and their dependencies
	asort($prioritized_configs);
	foreach ($prioritized_configs as $prefix => $priority) {
	$this->parseConfig($prefix);
	}

	foreach ($prioritized_configs as $prefix => $priority) {
	$this->ProcessDependencies($prefix);
	}
	}

	function AfterConfigRead($store_cache = null)
	{
	// if (!$this->ProcessAllConfigs) return ;
	$this->FinalStage = true;
	foreach ($this->configData as $prefix => $config) {
	if (in_array($prefix, $this->AfterConfigProcessed)) {
	continue;
	}

	$this->Application->HandleEvent( new kEvent($prefix.':OnAfterConfigRead') );
	$this->AfterConfigProcessed[] = $prefix;
	}

	if (!isset($store_cache)) {
	// store cache not overrided -> use global setting
	$store_cache = $this->StoreCache;
	}

	if ($store_cache \|\| (defined('IS_INSTALL') && IS_INSTALL)) {
	// cache is not stored during install, but dynamic clones should be processed in any case
	$this->processDynamicClones();
	}

	if ($store_cache) {
	$this->CacheParsedData();

	if ($this->Application->isDebugMode(false) && constOn('DBG_VALIDATE_CONFIGS')) {
	// validate configs here to have changes from OnAfterConfigRead hooks to prefixes
	foreach ($this->configData as $prefix => $config) {
	if (!isset($config['TableName'])) continue;
	$this->ValidateConfig($prefix);
	}
	}
	}
	}

	/**
	* Re-reads all configs
	*
	*/
	function ReReadConfigs()
	{
	// clear restored cache (not in db)
	$this->Application->Factory->Files = Array ();
	$this->Application->Factory->realClasses = Array ();
	$this->Application->Factory->Dependencies = Array ();

	$this->Application->EventManager->beforeRegularEvents = Array ();
	$this->Application->EventManager->afterRegularEvents = Array ();
	$this->Application->EventManager->beforeHooks = Array ();
	$this->Application->EventManager->afterHooks = Array ();

	// otherwise ModulesHelper indirectly used from includeConfigFiles won't work
	$this->Application->RegisterDefaultClasses();

	// parse all configs
	$this->ProcessAllConfigs = true;
	$this->includeConfigFiles(MODULES_PATH, false);
	$this->ParseConfigs();
	$this->AfterConfigRead(false);
	$this->processDynamicClones();
	}

	/**
	* Process clones, that were defined via OnAfterConfigRead event
	*
	*/
	function processDynamicClones()
	{
	$new_clones = Array();
	foreach ($this->configData as $prefix => $config) {
	$clones = $this->postProcessConfig($prefix, 'Clones', 'prefix');
	if ($clones) {
	$new_clones = array_merge($new_clones, $clones);
	}
	}

	// call OnAfterConfigRead for cloned configs
	$new_clones = array_unique($new_clones);
	foreach ($new_clones as $prefix) {
	if (in_array($prefix, $this->AfterConfigProcessed)) {
	continue;
	}

	$this->Application->HandleEvent( new kEvent($prefix.':OnAfterConfigRead') );
	$this->AfterConfigProcessed[] = $prefix;
	}
	}

	/**
	* Register nessasary classes
	* This method should only process the data which is cached!
	*
	* @param string $prefix
	* @access private
	*/
	function parseConfig($prefix)
	{
	$config =& $this->configData[$prefix];
	$event_manager =& $this->Application->recallObject('EventManager');

	$register_classes = getArrayValue($config,'RegisterClasses');
	if (!$register_classes) $register_classes = Array();
	$class_params=Array('ItemClass','ListClass','EventHandlerClass','TagProcessorClass');
	foreach($class_params as $param_name)
	{
	if ( !(isset($config[$param_name]) ) ) continue;
	$config[$param_name]['pseudo'] = $this->getPrefixByParamName($param_name,$prefix);
	$register_classes[] = $config[$param_name];
	}

	foreach($register_classes as $class_info)
	{
	$require_classes = getArrayValue($class_info, 'require_classes');
	if ($require_classes) {
	if (!is_array($require_classes)) {
	$require_classes = array($require_classes);
	}
	if (!isset($config['_Dependencies'][$class_info['class']])) {
	$config['_Dependencies'][$class_info['class']] = array();
	}
	$config['_Dependencies'][$class_info['class']] = array_merge($config['_Dependencies'][$class_info['class']], $require_classes);
	}
	$this->Application->registerClass(
	$class_info['class'],
	$config['BasePath'].'/'.$class_info['file'],
	$class_info['pseudo']/*,
	getArrayValue($class_info, 'require_classes')*/
	);
	if (getArrayValue($class_info, 'build_event')) {
	$event_manager->registerBuildEvent($class_info['pseudo'],$class_info['build_event']);
	}
	}

	$regular_events = getArrayValue($config, 'RegularEvents');
	if($regular_events)
	{
	foreach($regular_events as $short_name => $regular_event_info)
	{
	$event_manager->registerRegularEvent( $short_name, $config['Prefix'].':'.$regular_event_info['EventName'], $regular_event_info['RunInterval'], $regular_event_info['Type'] );
	}
	}

	$hooks = getArrayValue($config, 'Hooks');
	if (is_array($hooks) && count($hooks) > 0) {
	foreach ($hooks as $hook) {
	if (isset($config['ParentPrefix']) && $hook['HookToPrefix'] == $config['ParentPrefix']) {
	trigger_error('Depricated Hook Usage [prefix: <b>'.$config['Prefix'].'</b>; do_prefix: <b>'.$hook['DoPrefix'].'</b>] use <b>#PARENT#</b> as <b>HookToPrefix</b> value, where HookToPrefix is same as ParentPrefix', E_USER_NOTICE);
	}

	if ($hook['HookToPrefix'] == '') {
	$hook['HookToPrefix'] = $config['Prefix']; // new: set hooktoprefix to current prefix if not set
	}

	if (isset($config['ParentPrefix'])) {
	// new: allow to set hook to parent prefix what ever it is
	if ($hook['HookToPrefix'] == '#PARENT#') {
	$hook['HookToPrefix'] = $config['ParentPrefix'];
	}

	if ($hook['DoPrefix'] == '#PARENT#') {
	$hook['DoPrefix'] = $config['ParentPrefix'];
	}
	}
	elseif ($hook['HookToPrefix'] == '#PARENT#' \|\| $hook['DoPrefix'] == '#PARENT#') {
	continue; // we need parent prefix but it's not set !
	}

	$do_prefix = $hook['DoPrefix'] == '' ? $config['Prefix'] : $hook['DoPrefix'];

	if ( !is_array($hook['HookToEvent']) ) {
	$hook_events = Array( $hook['HookToEvent'] );
	}
	else {
	$hook_events = $hook['HookToEvent'];
	}
	foreach ($hook_events as $hook_event) {
	$this->Application->registerHook($hook['HookToPrefix'], $hook['HookToSpecial'], $hook_event, $hook['Mode'], $do_prefix, $hook['DoSpecial'], $hook['DoEvent'], $hook['Conditional']);
	}
	}
	}

	if ( is_array(getArrayValue($config, 'AggregateTags')) ) {
	foreach ($config['AggregateTags'] as $aggregate_tag) {
	if (isset($config['ParentPrefix'])) {
	if ($aggregate_tag['AggregateTo'] == $config['ParentPrefix']) {
	trigger_error('Depricated Aggregate Tag Usage [prefix: <b>'.$config['Prefix'].'</b>; AggregateTo: <b>'.$aggregate_tag['AggregateTo'].'</b>] use <b>#PARENT#</b> as <b>AggregateTo</b> value, where AggregateTo is same as ParentPrefix', E_USER_NOTICE);
	}

	if ($aggregate_tag['AggregateTo'] == '#PARENT#') {
	$aggregate_tag['AggregateTo'] = $config['ParentPrefix'];
	}
	}
	$aggregate_tag['LocalPrefix'] = $config['Prefix'];
	$this->Application->registerAggregateTag($aggregate_tag);
	}
	}

	if (isset($config['ReplacementTemplates']) && $config['ReplacementTemplates']) {
	// replacement templates defined in this config
	$this->Application->ReplacementTemplates = array_merge_recursive2($this->Application->ReplacementTemplates, $config['ReplacementTemplates']);
	}
	}

	function ValidateConfig($prefix)
	{
	global $debugger;

	$config =& $this->configData[$prefix];

	$tablename = $config['TableName'];
	$float_types = Array ('float', 'double', 'numeric');
	$conn =& $this->Application->GetADODBConnection();

	$table_found = $conn->Query('SHOW TABLES LIKE "'.$tablename.'"');
	if (!$table_found) {
	// config present, but table missing, strange
	$debugger->appendHTML("<b class='debug_error'>Config Warning: </b>Table <strong>$tablename</strong> missing, but prefix <b>".$config['Prefix']."</b> requires it!");
	safeDefine('DBG_RAISE_ON_WARNINGS', 1);
	return ;
	}

	$res = $conn->Query('DESCRIBE '.$tablename);
	$config_link = $debugger->getFileLink(FULL_PATH.$this->prefixFiles[$config['Prefix']], 1, $config['Prefix']);

	$error_messages = Array (
	'field_not_found' => 'Field <strong>%s</strong> exists in the database, but <strong>is not defined</strong> in config',
	'default_missing' => 'Default value for field <strong>%s</strong> not set in config',
	'not_null_error1' => 'Field <strong>%s</strong> is NOT NULL in the database, but is not configured as not_null', // or required',
	'not_null_error2' => 'Field <strong>%s</strong> is described as NOT NULL in config, but <strong>does not have DEFAULT value</strong>',
	'not_null_error3' => 'Field <strong>%s</strong> is described as <strong>NOT NULL in config</strong>, but is <strong>NULL in db</strong>',
	'invalid_default' => '<strong>Default value</strong> for field %s<strong>%s</strong> not sync. to db (in config = %s, in db = %s)',
	'type_missing' => '<strong>Type definition</strong> for field <strong>%s</strong> missing in config',
	);

	$config_errors = Array ();
	$tablename = preg_replace('/^'.preg_quote(TABLE_PREFIX, '/').'(.*)/', '\\1', $tablename); // remove table prefix

	foreach ($res as $field) {
	$f_name = $field['Field'];

	if (getArrayValue($config, 'Fields')) {
	if (preg_match('/l[\d]+_[\w]/', $f_name)) {
	// skip multilingual fields
	continue;
	}

	if (!array_key_exists ($f_name, $config['Fields'])) {
	$config_errors[] = sprintf($error_messages['field_not_found'], $f_name);
	}
	else {
	if (is_numeric($field['Default'])) {
	$field['Default'] = preg_match('/[\.,]/', $field['Default']) ? (float)$field['Default'] : (int)$field['Default'];
	}

	$options = $config['Fields'][$f_name];
	$default_missing = false;
	if (!array_key_exists('default', $options)) {
	$config_errors[] = sprintf($error_messages['default_missing'], $f_name);
	$default_missing = true;
	}

	if ($field['Null'] != 'YES') {
	// field is NOT NULL in database (MySQL5 for null returns "NO", but MySQL4 returns "")
	if ( $f_name != $config['IDField'] && !isset($options['not_null']) /&& !isset($options['required'])/ ) {
	$config_errors[] = sprintf($error_messages['not_null_error1'], $f_name);
	}
	if (isset($options['not_null']) && $options['not_null'] && !isset($options['default']) ) {
	$config_errors[] = sprintf($error_messages['not_null_error2'], $f_name);
	}
	}
	else {
	if (isset($options['not_null']) && $options['not_null']) {
	$config_errors[] = sprintf($error_messages['not_null_error3'], $f_name);
	}
	}

	if (!array_key_exists('type', $options)) {
	$config_errors[] = sprintf($error_messages['type_missing'], $f_name);
	}

	if (!$default_missing) {
	if ($f_name == $config['IDField'] && $options['type'] != 'string' && $options['default'] !== 0) {
	$config_errors[] = sprintf($error_messages['invalid_default'], '<span class="debug_error">IDField</span> ', $f_name, $this->varDump($options['default']), $this->varDump($field['Default']));
	}
	else if ($options['default'] != '#NOW#' && $field['Default'] !== $options['default'] && !in_array($options['type'], $float_types)) {
	$config_errors[] = sprintf($error_messages['invalid_default'], '', $f_name, $this->varDump($options['default']), $this->varDump($field['Default']));
	}
	}
	}
	}
	}

	if ($config_errors) {
	$error_prefix = '<strong class="debug_error">Config Error'.(count($config_errors) > 1 ? 's' : '').': </strong> for prefix <strong>'.$config_link.'</strong> ('.$tablename.') in unit config:<br />';
	$config_errors = $error_prefix.'   '.implode('<br />   ', $config_errors);

	$debugger->appendHTML($config_errors);
	safeDefine('DBG_RAISE_ON_WARNINGS', 1);
	}
	}

	function varDump($value)
	{
	return '<strong>'.var_export($value, true).'</strong> of '.gettype($value);
	}

	function ProcessDependencies($prefix)
	{
	$config =& $this->configData[$prefix];
	$deps = getArrayValue($config, '_Dependencies');
	if (!$deps) return ;

	foreach ($deps as $real_class => $requires) {
	foreach ($requires as $class) {
	$this->Application->registerDependency($real_class, $class);
	}
	}
	unset($config['_Dependencies']);
	}

	function postProcessConfig($prefix, $config_key, $dst_prefix_var)
	{
	$main_config =& $this->configData[$prefix];
	$sub_configs = isset($main_config[$config_key]) && $main_config[$config_key] ? $main_config[$config_key] : false; // getArrayValue($main_config, $config_key);
	if (!$sub_configs) {
	return array();
	}
	unset($main_config[$config_key]);

	$processed = array();
	foreach ($sub_configs as $sub_prefix => $sub_config) {
	if ($config_key == 'AggregateConfigs' && !isset($this->configData[$sub_prefix])) {
	$this->loadConfig($sub_prefix);
	}
	$sub_config['Prefix'] = $sub_prefix;
	$this->configData[$sub_prefix] = array_merge_recursive2($this->configData[$$dst_prefix_var], $sub_config);

	// when merging empty array to non-empty results non-empty array, but empty is required
	foreach ($sub_config as $sub_key => $sub_value) {
	if (!$sub_value) {
	unset($this->configData[$sub_prefix][$sub_key]);
	}
	}
	if ($config_key == 'Clones') {
	$this->prefixFiles[$sub_prefix] = $this->prefixFiles[$prefix];
	}

	$this->postProcessConfig($sub_prefix, $config_key, $dst_prefix_var);
	if ($config_key == 'AggregateConfigs') {
	$processed = array_merge($this->postProcessConfig($sub_prefix, 'Clones', 'prefix'), $processed);
	}
	elseif ($this->ProcessAllConfigs) {
	$this->parseConfig($sub_prefix);
	}
	array_push($processed, $sub_prefix);
	}

	if (!$prefix) {
	// configs, that used only for cloning & not used ifself
	unset($this->configData[$prefix]);
	}
	return array_unique($processed);
	}

	function PreloadConfigFile($filename)
	{
	$config_found = file_exists(FULL_PATH.$filename) && $this->configAllowed($filename);

	if( defined('DEBUG_MODE') && DEBUG_MODE && constOn('DBG_PROFILE_INCLUDES') )
	{
	if ( in_array($filename, get_required_files()) ) return;
	global $debugger;
	if($config_found) {
	$file = FULL_PATH.$filename;
	$debugger->ProfileStart('inc_'.crc32($file), $file);
	include_once($file);
	$debugger->ProfileFinish('inc_'.crc32($file));
	$debugger->profilerAddTotal('includes', 'inc_'.crc32($file));
	}
	}
	else
	{
	if ($config_found) include_once(FULL_PATH.$filename);
	}

	if ($config_found) {
	if (isset($config) && $config) {
	// config file is included for 1st time -> save it's content for future processing
	$prefix = isset($config['Prefix']) ? $config['Prefix'] : '';

	preg_match('/\/(.*)\//U', $filename, $rets);
	$config['ModuleFolder'] = $rets[1];
	$config['BasePath'] = dirname(FULL_PATH.$filename);
	if (isset($config['AdminTemplatePath'])) {
	// append template base folder for admin templates path of this prefix
	$module_templates = $rets[1] == 'core' ? 'in-portal/' : $rets[1].'/';
	$config['AdminTemplatePath'] = $module_templates.$config['AdminTemplatePath'];
	}
	$this->configData[$prefix] = $config;
	$this->prefixFiles[$prefix] = $filename;
	return $prefix;
	}
	elseif ($prefix = array_search($filename, $this->prefixFiles)) {
	// attempt is made to include config file twice or more, but include_once prevents that,
	// but file exists on hdd, then it is already saved to all required arrays, just return it's prefix
	return $prefix;
	}
	}
	return 'dummy';
	}

	function loadConfig($prefix)
	{
	if (!isset($this->prefixFiles[$prefix])) {
	if ($this->Application->isDebugMode()) $this->Application->Debugger->appendTrace();
	trigger_error('Configuration file for prefix <b>'.$prefix.'</b> is unknown', E_USER_ERROR);
	return ;
	}
	$file = $this->prefixFiles[$prefix];
	$prefix = $this->PreloadConfigFile($file);

	$clones = $this->postProcessConfig($prefix, 'AggregateConfigs', 'sub_prefix');
	$clones = array_merge($this->postProcessConfig($prefix, 'Clones', 'prefix'), $clones);

	if ($this->FinalStage) {
	array_unshift($clones, $prefix);
	$clones = array_unique($clones);
	foreach ($clones as $a_prefix) {
	$this->Application->HandleEvent( new kEvent($a_prefix.':OnAfterConfigRead') );
	}
	}
	}

	/**
	* Reads unit (specified by $prefix)
	* option specified by $option
	*
	* @param string $prefix
	* @param string $name
	* @param mixed $default
	* @return string
	* @access public
	*/
	function getUnitOption($prefix, $name, $default = false)
	{
	if (preg_match('/(.)\.(.)/', $prefix, $rets)) {
	if (!isset($this->configData[$rets[1]])) {
	$this->loadConfig($rets[1]);
	}
	$ret = isset($this->configData[$rets[1]][$name][$rets[2]]) ? $this->configData[$rets[1]][$name][$rets[2]] : false;
	// $ret = getArrayValue($this->configData, $rets[1], $name, $rets[2]);
	}
	else {
	if (!isset($this->configData[$prefix])) {
	$this->loadConfig($prefix);
	}
	$ret = isset($this->configData[$prefix][$name]) ? $this->configData[$prefix][$name] : false;
	// $ret = getArrayValue($this->configData, $prefix, $name);
	}
	return $ret === false ? $default : $ret;
	}

	/**
	* Read all unit with $prefix options
	*
	* @param string $prefix
	* @return Array
	* @access public
	*/
	function getUnitOptions($prefix)
	{
	if (!isset($this->configData[$prefix])) {
	$this->loadConfig($prefix);
	}

	return $this->configData[$prefix];
	}

	/**
	* Set's new unit option value
	*
	* @param string $prefix
	* @param string $name
	* @param string $value
	* @access public
	*/
	function setUnitOption($prefix, $name, $value)
	{
	if (preg_match('/(.)\.(.)/', $prefix, $rets)) {
	if (!isset($this->configData[$rets[1]])) {
	$this->loadConfig($rets[1]);
	}
	$this->configData[$rets[1]][$name][$rets[2]] = $value;
	}
	else {
	if (!isset($this->configData[$prefix])) {
	$this->loadConfig($prefix);
	}
	$this->configData[$prefix][$name] = $value;
	}

	}

	function getPrefixByParamName($paramName,$prefix)
	{
	$pseudo_class_map=Array(
	'ItemClass'=>'%s',
	'ListClass'=>'%s_List',
	'EventHandlerClass'=>'%s_EventHandler',
	'TagProcessorClass'=>'%s_TagProcessor'
	);
	return sprintf($pseudo_class_map[$paramName],$prefix);
	}

	/**
	* Get's config file name based
	* on folder name supplied
	*
	* @param string $folderPath
	* @return string
	* @access private
	*/
	function getConfigName($folderPath)
	{
	return $folderPath.'/'.basename($folderPath).'_config.php';
	}

	/**
	* is_dir ajustment to work with
	* directory listings too
	*
	* @param string $folderPath
	* @return bool
	* @access private
	*/
	function isDir($folderPath)
	{
	$base_name = basename($folderPath);
	$ret = !( $base_name == '.' \|\| $base_name == '..' );
	return $ret && is_dir($folderPath);
	}

	/**
	* Checks if config file is allowed for includion (if module of config is installed)
	*
	* @param string $config_path relative path from in-portal directory
	*/
	function configAllowed($config_path)
	{
	if (defined('IS_INSTALL') && IS_INSTALL) {
	// at installation start no modules in db and kernel configs could not be read
	return true;
	}

	if (preg_match('#/plugins/\|/core#', $config_path)) {
	return true;
	}

	$module_found = false;
	if (!$this->Application->ModuleInfo) return false;

	foreach($this->Application->ModuleInfo as $module_name => $module_info)
	{
	$module_path = '/'.$module_info['Path'];
	if (preg_match('/^'.preg_quote($module_path, '/').'/', $config_path)) {
	// if (mb_substr($config_path, 0, mb_strlen($module_path)) == $module_path) {
	// config file path starts with module folder path
	$module_found = true;
	break;
	}
	}
	return $module_found;
	}

	/**
	* Returns true if config exists and is allowed for reading
	*
	* @param string $prefix
	* @return bool
	*/
	function prefixRegistred($prefix)
	{
	return isset($this->prefixFiles[$prefix]) ? true : false;
	}

	function iterateConfigs($callback_function, $params)
	{
	$this->includeConfigFiles(MODULES_PATH); //make sure to re-read all configs
	$this->AfterConfigRead();

	foreach ($this->configData as $prefix => $config_data) {
	$callback_function[0]->$callback_function[1]($prefix, $config_data, $params);
	}
	}

	}


	?>
	\ No newline at end of file

	Property changes on: branches/RC/core/kernel/utility/unit_config_reader.php
	___________________________________________________________________
	Modified: cvs2svn:cvs-rev
	## -1 +1 ##
	-1.78.2.8
	\ No newline at end of property
	+1.78.2.9
	\ No newline at end of property
	Index: branches/RC/core/kernel/languages/phrases_cache.php
	===================================================================
	--- branches/RC/core/kernel/languages/phrases_cache.php (revision 10579)
	+++ branches/RC/core/kernel/languages/phrases_cache.php (revision 10580)
	@@ -1,249 +1,253 @@
	<?php

	class PhrasesCache extends kBase {

	/**
	* Connection to database
	*
	* @var kDBConnection
	* @access public
	*/
	var $Conn;

	var $Phrases = Array();
	var $Ids = Array();
	var $OriginalIds = Array(); //for comparing cache

	var $LanguageId = null;

	var $fromTag = false;
	-
	+
	function PhrasesCache()
	{
	parent::kBase();
	$this->Conn =& $this->Application->GetADODBConnection();
	}

	function Init($prefix, $special = '')
	{
	if (constOn('IS_INSTALL')) {
	$this->LanguageId = 1;
	}
	else {
	if ($this->Application->IsAdmin()) {
	$id_field = $this->Application->getUnitOption('lang', 'IDField');
	$table_name = $this->Application->getUnitOption('lang', 'TableName');
	$sql = 'SELECT '.$id_field.'
	FROM '.$table_name.'
	WHERE AdminInterfaceLang = 1';
	$this->LanguageId = $this->Conn->GetOne($sql);
	}
	else {
	$this->LanguageId = $this->Application->GetVar('m_lang');
	}
	}

	if (isset($this->Application->Caches['PhraseList'])) {
	$this->LoadPhrases( $this->Application->Caches['PhraseList'] );
	}
	}

	function GetCachedIds()
	{
	$query = sprintf("SELECT PhraseList, ConfigVariables FROM %s WHERE Template = %s",
	TABLE_PREFIX.'PhraseCache',
	$this->Conn->Qstr(md5($this->Application->GetVar('t').$this->Application->GetVar('m_theme').$this->Application->GetVar('m_lang'))));
	$res = $this->Conn->GetRow($query);

	if ($res && $res['ConfigVariables']) {
	$this->Application->OriginalConfigCacheIds = explode(',', $res['ConfigVariables']);
	$this->Application->ConfigCacheIds = $this->Application->OriginalConfigCacheIds;
	}

	return ($res === false) ? Array() : explode(',', $res['PhraseList']);
	}

	function LoadPhrases($ids)
	{
	if ( !is_array($ids) \|\| !implode('', $ids) ) return;
	$query = sprintf("SELECT Translation,UPPER(Phrase) AS Phrase FROM %s WHERE LanguageId = %s AND PhraseId IN (%s)",
	TABLE_PREFIX.'Phrase',
	$this->LanguageId,
	join(',', $ids));
	$this->Phrases = $this->Conn->GetCol($query,'Phrase');
	/*foreach($phrases as $phrase => $tanslation)
	{
	$this->AddCachedPhrase(mb_strtoupper($phrase), $tanslation);
	}*/
	$this->Ids = $ids;
	$this->OriginalIds = $ids;
	}

	function AddCachedPhrase($label, $value)
	{
	$label = mb_strtoupper($label);
	$this->Phrases[$label] = $value;
	}

	function NeedsCacheUpdate()
	{
	return is_array($this->Ids) && count($this->Ids) > 0 && $this->Ids != $this->OriginalIds;
	}

	/**
	* Copy from Application->UpdateCache method
	*
	* @deprecated
	*/
	function UpdateCache()
	{
	$update = false;
	//something changed
	$update = $update \|\| (is_array($this->Ids) && count($this->Ids) > 0 && $this->Ids != $this->OriginalIds);
	$update = $update \|\| (count($this->Application->ConfigCacheIds) && $this->Application->ConfigCacheIds != $this->Application->OriginalConfigCacheIds);
	if ($update) {
	$query = sprintf("REPLACE %s (PhraseList, CacheDate, Template, ConfigVariables)
	VALUES (%s, %s, %s, %s)",
	TABLE_PREFIX.'PhraseCache',
	$this->Conn->Qstr(join(',', $this->Ids)),
	adodb_mktime(),
	$this->Conn->Qstr(md5($this->Application->GetVar('t').$this->Application->GetVar('m_theme').$this->Application->GetVar('m_lang'))),
	$this->Conn->qstr(implode(',', array_unique($this->Application->ConfigCacheIds))));
	$this->Conn->Query($query);
	}
	}

	function GetPhrase($label)
	{
	+ if (!isset($this->LanguageId)) return 'impossible case';
	+ //actually possible when custom field contains references to language labels and its being rebuilt in OnAfterConfigRead
	+ //which is triggered by Sections rebuild, which in turn read all the configs and all of that happens BEFORE seeting the language...
	+
	if (ereg("^!.+!$", $label) > 0)
	{
	$label = substr($label, 1, -1); //cut exclamation marks
	}

	if( strlen($label) == 0 ) return '';

	$original_label = $label;
	$label = mb_strtoupper($label);
	if(isset($this->Phrases[$label])) {
	$translated_label = $this->Phrases[$label];
	// debug mode is checked directly to improve performance
	if (defined('DEBUG_MODE') && DEBUG_MODE && constOn('DBG_PHRASES_HIGHLIGHT')) {
	if (!$this->Application->isDebugMode()) return $translated_label;

	if ($this->Application->IsAdmin()) {
	$sql = 'SELECT Module
	FROM '.TABLE_PREFIX.'Phrase
	WHERE (LanguageId = '.$this->LanguageId.') AND (Phrase = '.$this->Conn->qstr($label).')';
	$this->Application->Debugger->appendHTML('Phrase: <b>'.$label.'</b>; Module: <b>'.$this->Conn->GetOne($sql).'</b>');
	// $translated_label = $translated_label.' [m: '.$this->Conn->GetOne($sql).'; l: '.$label.']';
	}
	else {
	// highlight text created via translated phrase (used to detect if text on screen is phrase or not)
	$translated_label = '<span style="border: 1px solid #999999; background-color: #cccccc; color: #999999; ">'.$translated_label.'</span></a> <span style="color: red; background-color:#ffffcc">'.$original_label.'</span>';
	}

	}
	return $translated_label;
	}

	$this->LoadPhraseByLabel($label, $original_label);
	return $this->GetPhrase($label);
	}

	function LoadPhraseByLabel($label, $original_label)
	{
	$query = sprintf("SELECT PhraseId, Translation FROM %s WHERE LanguageId = %s AND UPPER(Phrase) = UPPER(%s)",
	TABLE_PREFIX.'Phrase',
	$this->LanguageId,
	$this->Conn->qstr($label));
	$res = $this->Conn->GetRow($query);
	if ($res === false \|\| count($res) == 0)
	{
	$translation = '!'.$label.'!';
	if($this->Application->isDebugMode() && constOn('DBG_PHRASES')) {
	list($edit_tpl, $index_file) = $this->Application->IsAdmin() ? Array('regional/phrases_edit', 'index.php') : Array('phrases_edit', 'index.php');

	if ($this->Application->IsAdmin() && $this->Application->ConfigValue('UsePopups')) {
	// link to popup when using popups (only in admin)
	$edit_url = 'javascript:translate_phrase(\''.addslashes($original_label).'\', \''.$edit_tpl.'\');';
	}
	else {
	// direct link, when not using popups OR on frontend
	$edit_url = $this->Application->HREF($edit_tpl,'',Array('m_opener'=>'d','phrases_label'=>$original_label,'phrases_event'=>'OnNew', 'pass'=>'all,phrases'), $index_file );
	}

	$translation = '<a href="'.$edit_url.'">!'.$label.'!</a>';
	if($this->fromTag) $translation = $this->escapeTagReserved($translation);
	}
	$this->AddCachedPhrase($label, $translation); //add it as already cached, as long as we dont need to cache not found phrase
	return false;
	}

	$this->Phrases[$label] = $res['Translation'];
	array_push($this->Ids, $res['PhraseId']);
	$this->Ids = array_unique($this->Ids); //just to make sure
	return true;
	}

	/**
	* Sort params by name and then by length
	*
	* @param string $a
	* @param string $b
	* @return int
	* @access private
	*/
	function CmpParams($a, $b)
	{
	$a_len = mb_strlen($a);
	$b_len = mb_strlen($b);
	if ($a_len == $b_len) return 0;
	return $a_len > $b_len ? -1 : 1;
	}

	/**
	* 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,$forse_escaping=null)
	{
	$this->fromTag = true;
	if( isset($forse_escaping) ) $this->fromTag = $forse_escaping;
	preg_match_all("(!(la\|lu)[^!]+!)", $text, $res, PREG_PATTERN_ORDER);
	$language_tags = $res[0];
	uasort($language_tags, Array(&$this, 'CmpParams') );

	$values = Array();
	$i = 0;
	foreach ($language_tags as $label) {
	array_push($values, $this->GetPhrase($label) );
	//array_push($values, $this->Application->Phrase($label) );
	$language_tags[$i] = '/' . $language_tags[$i] . '/';
	$i++;
	}
	$this->fromTag = false;
	return preg_replace($language_tags, $values, $text);
	}

	/**
	* Escape chars in phrase translation, that could harm parser to process tag
	*
	* @param string $text
	* @return string
	* @access private
	*/
	function escapeTagReserved($text)
	{
	$reserved = Array('"',"'"); // =
	$replacement = Array('\"',"\'"); // \=
	return str_replace($reserved,$replacement,$text);
	}

	}


	?>
	\ No newline at end of file

	Property changes on: branches/RC/core/kernel/languages/phrases_cache.php
	___________________________________________________________________
	Modified: cvs2svn:cvs-rev
	## -1 +1 ##
	-1.19.2.2
	\ No newline at end of property
	+1.19.2.3
	\ No newline at end of property
	Index: branches/RC/core/kernel/application.php
	===================================================================
	--- branches/RC/core/kernel/application.php (revision 10579)
	+++ branches/RC/core/kernel/application.php (revision 10580)
	@@ -1,2714 +1,2764 @@
	<?php

	/**
	* Basic class for Kernel3-based Application
	*
	* This class is a Facade for any other class which needs to deal with Kernel3 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 KernelApplication in the script.<br>
	* This could be guranteed by NOT calling the class constuctor directly, but rather calling KernelApplication::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
	*/

	class kApplication {

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

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


	/**
	* New Parser (Experimental)
	*
	* @var NParser
	*/
	var $NParser;

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

	/**
	* 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;

	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 unknown_type
	*/
	var $CurrentNTag = null;
	+
	+ /**
	+ * Memcache object pointer
	+ *
	+ * @var Memcache
	+ */
	+ var $Memcached = 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)
	{
	safeDefine('APPLICATION_CLASS', 'kApplication');
	$class = APPLICATION_CLASS;
	$instance = new $class();
	$instance->Application =& $instance;
	}
	return $instance;
	}
	+
	+ function InitMemcached()
	+ {
	+ $memcached_servers = 'localhost:11211'; // $this->Application->ConfigValue('MemcachedServers');
	+
	+ if ($memcached_servers && class_exists('Memcache')) {
	+ $this->Memcached = new Memcache();
	+ $servers = explode(';', $memcached_servers);
	+ foreach ($servers as $server) {
	+ list ($server, $port) = strpos($server, ':') !== false ? explode(':', $server, 2) : Array ($server, 11211);
	+ $this->Memcached->addServer($server, $port);
	+ }
	+ }
	+ }

	/**
	* 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->InitMemcached();
	+
	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) $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->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');
	+ }
	+
	$rewrite_on = $this->ConfigValue('UseModRewrite');
	// admin=1 - when front is browsed using admin session
	$admin_on = getArrayValue($_REQUEST, 'admin') \|\| $this->IsAdmin();
	define('MOD_REWRITE', $rewrite_on && !$admin_on ? 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');
	+ }

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

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

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

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


	/*// Module items are recalled during url parsing & PhrasesCache is needed already there,
	// because it's used in their build events. That's why phrases cache initialization is
	// called from kHTTPQuery in case when mod_rewrite is used
	if (!$this->RewriteURLs()) {
	$this->Phrases = new PhrasesCache();
	}*/

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

	if ($this->GetVar('m_cat_id') === false) $this->SetVar('m_cat_id', 0);
	if( !$this->RecallVar('curr_iso') ) $this->StoreVar('curr_iso', $this->GetPrimaryCurrency() );

	$this->SetVar('visits_id', $this->RecallVar('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');
	}

	$this->ValidateLogin();

	- if($this->isDebugMode()) {
	+ 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');
	$this->ModuleInfo = $this->Conn->Query('SELECT * FROM '.TABLE_PREFIX.'Modules WHERE Loaded = 1 ORDER BY LoadOrder', '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');
	if ( !$lang->IsLoaded() \|\| (!$this->Application->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->Application->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!
	- if (!$theme_id) {
	- return false;
	- }
	+// $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()
	{
	static $language_id = 0;

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

	$table = $this->getUnitOption('lang', 'TableName');
	$id_field = $this->getUnitOption('lang', 'IDField');

	$sql = 'SELECT '.$id_field.'
	FROM '.$table.'
	WHERE (PrimaryLang = 1) AND (Enabled = 1)';
	$language_id = $this->Conn->GetOne($sql);

	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 {
	$table = $this->getUnitOption('theme','TableName');
	$id_field = $this->getUnitOption('theme','IDField');
	$sql = 'SELECT '.$id_field.'
	FROM '.$table.'
	WHERE (PrimaryTheme = 1) AND (Enabled = 1)';
	$theme_id = $this->Conn->GetOne($sql);
	}
	return $theme_id;
	}

	function GetPrimaryCurrency()
	{
	if ($this->isModuleEnabled('In-Commerce')) {
	$table = $this->getUnitOption('curr', 'TableName');
	return $this->Conn->GetOne('SELECT ISO FROM '.$table.' WHERE IsPrimary = 1');
	}
	else {
	return 'USD';
	}
	}

	/**
	* 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('kHelper', KERNEL_PATH.'/kbase.php');

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

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



	$this->registerClass('Params', KERNEL_PATH.'/utility/params.php', 'kActions');

	$this->registerClass('kMultipleFilter', KERNEL_PATH.'/utility/filters.php');
	$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('kTagProcessor', KERNEL_PATH.'/processors/tag_processor.php');
	$this->registerClass('kMainTagProcessor', KERNEL_PATH.'/processors/main_processor.php','m_TagProcessor', 'kTagProcessor');
	$this->registerClass('kDBTagProcessor', KERNEL_PATH.'/db/db_tag_processor.php', null, 'kTagProcessor');

	$this->registerClass('TemplatesCache', KERNEL_PATH.'/parser/template.php',null, 'kDBTagProcessor');
	$this->registerClass('Template', KERNEL_PATH.'/parser/template.php');
	$this->registerClass('TemplateParser', KERNEL_PATH.'/parser/template_parser.php',null, 'kDBTagProcessor');

	if (defined('NPARSER') && 'NPARSER') {
	$this->registerClass('NParser', KERNEL_PATH.'/nparser/nparser.php');
	}

	$this->registerClass('kEmailSendingHelper', KERNEL_PATH.'/utility/email_send.php', 'EmailSender', Array('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');
	}

	$this->registerClass('FCKeditor', FULL_PATH.'/admin/editor/cmseditor/fckeditor.php'); // need this?

	/* Moved from MyApplication */

	$this->registerClass('Inp1Parser',KERNEL_PATH.'/../units/general/inp1_parser.php','Inp1Parser');

	$this->registerClass('InpSession',KERNEL_PATH.'/../units/general/inp_ses_storage.php','Session');
	$this->registerClass('InpSessionStorage',KERNEL_PATH.'/../units/general/inp_ses_storage.php','SessionStorage');

	$this->registerClass('kCatDBItem',KERNEL_PATH.'/../units/general/cat_dbitem.php');
	$this->registerClass('kCatDBItemExportHelper',KERNEL_PATH.'/../units/general/cat_dbitem_export.php', 'CatItemExportHelper');
	$this->registerClass('kCatDBList',KERNEL_PATH.'/../units/general/cat_dblist.php');
	$this->registerClass('kCatDBEventHandler',KERNEL_PATH.'/../units/general/cat_event_handler.php');
	$this->registerClass('kCatDBTagProcessor',KERNEL_PATH.'/../units/general/cat_tag_processor.php');

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

	/* End moved */

	}

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

	/**
	* Returns item's filename that corresponds id passed. If possible, then get it from cache
	*
	* @param string $prefix
	* @param int $id
	* @return string
	*/
	function getFilename($prefix, $id, $category_id=null)
	{
	$filename = $this->getCache('filenames', $prefix.'_'.$id);
	if ($filename === false) {
	$table = $this->getUnitOption($prefix, 'TableName');
	$id_field = $this->getUnitOption($prefix, 'IDField');

	if ($prefix == 'c') {
	if(!$id) {
	$this->setCache('filenames', $prefix.'_'.$id, '');
	return '';
	}

	// this allows to save 2 sql queries for each category
	$sql = 'SELECT NamedParentPath, CachedCategoryTemplate, TreeLeft, TreeRight
	FROM '.$table.'
	WHERE '.$id_field.' = '.$this->Conn->qstr($id);
	$category_data = $this->Conn->GetRow($sql);
	$filename = $category_data['NamedParentPath'];
	$this->setCache('category_templates', $id, $category_data['CachedCategoryTemplate']);
	$this->setCache('category_tree', $id, $category_data['TreeLeft'] . ';' . $category_data['TreeRight']);

	// $this->setCache('item_templates', $id, $category_data['CachedItemTemplate']);
	}
	else {
	$resource_id = $this->Conn->GetOne('SELECT ResourceId FROM '.$table.' WHERE '.$id_field.' = '.$this->Conn->qstr($id));
	if (is_null($category_id)) $category_id = $this->GetVar('m_cat_id');
	$sql = 'SELECT Filename FROM '.TABLE_PREFIX.'CategoryItems WHERE ItemResourceId = '.$resource_id.' AND CategoryId = '.$category_id;
	$filename = $this->Conn->GetOne($sql);

	/*if (!$filename) {
	$sql = 'SELECT Filename FROM '.TABLE_PREFIX.'CategoryItems WHERE ItemResourceId = '.$resource_id.' AND PrimaryCat = 1';
	$filename = $this->Conn->GetOne($sql);
	}*/

	/*$sql = 'SELECT Filename
	FROM '.$table.'
	WHERE '.$id_field.' = '.$this->Conn->qstr($id);
	$filename = $this->Conn->GetOne($sql);*/
	}
	$this->setCache('filenames', $prefix.'_'.$id, $filename);
	}
	return $filename;
	}


	/**
	* Adds new value to cache $cache_name and identified by key $key
	*
	* @param string $cache_name cache name
	* @param int $key key name to add to cache
	* @param mixed $value value of chached record
	*/
	- function setCache($cache_name, $key, $value)
	+ function setCache($cache_name, $key, $value, $expiration=3600)
	{
	$cache =& $this->recallObject('Cache');
	/* @var $cache kCache */

	- $cache->setCache($cache_name, $key, $value);
	+ return $cache->setCache($cache_name, $key, $value, $expiration);
	}

	/**
	* Returns cached $key value from cache named $cache_name
	*
	* @param string $cache_name cache name
	* @param int $key key name from cache
	* @return mixed
	*/
	function getCache($cache_name, $key)
	{
	$cache =& $this->recallObject('Cache');
	return $cache->getCache($cache_name, $key);
	}

	/**
	* 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)
	{
	$module_path = '/'.$module_info['Path'];
	$contants_file = FULL_PATH.$module_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($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($this->isDebugMode() && constOn('DBG_PROFILE_MEMORY')) {
	$this->Debugger->appendMemoryUsage('Application before Run:');
	}

	if ($this->IsAdmin()) {
	// for permission checking in events & templates
	$this->LinkVar('module'); // for common configuration 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
	// $this->LinkVar('return_template'); // template to go, when something was coosen from popup (from finalizePopup)
	// $this->LinkVar('return_m'); // main env part to restore after popup will be closed (from finalizePopup)
	}

	if ($this->GetVar('ajax') == 'yes' && !$this->GetVar('debug_ajax')) {
	// hide debug output from ajax requests automatically
	define('DBG_SKIP_REPORTING', 1);
	}
	}

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

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

	if ($this->isModuleEnabled('In-Edit')) {
	$cms_handler =& $this->recallObject('cms_EventHandler');
	if (!$this->TemplatesCache->TemplateExists($t) && !$this->IsAdmin()) {
	$t = $cms_handler->GetDesignTemplate();
	}
	/*else {
	$cms_handler->SetCatByTemplate();
	}*/
	}

	if ($this->isModuleEnabled('Proj-CMS')) {
	$cms_handler =& $this->recallObject('st_EventHandler');
	if (!$this->TemplatesCache->TemplateExists($t) && !$this->IsAdmin()) {
	$t = $cms_handler->GetDesignTemplate();
	}
	}


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

	if (defined('NPARSER') && 'NPARSER') {
	$this->HTML = $this->NParser->Run( $t );
	}
	else {
	$this->HTML = $this->Parser->ParseTemplate( $t );
	}

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

	function InitParser()
	{
	if (defined('NPARSER') && 'NPARSER') {
	if( !is_object($this->NParser) ) {
	$this->NParser =& $this->recallObject('NParser');
	$this->TemplatesCache =& $this->recallObject('TemplatesCache');

	// can be removed in future
	// $this->Parser =& $this->recallObject('TemplateParser');
	$this->Parser =& $this->NParser;
	}
	}
	else {
	if( !is_object($this->Parser) ) {
	$this->Parser =& $this->recallObject('TemplateParser');
	$this->TemplatesCache =& $this->recallObject('TemplatesCache');
	}
	}
	}

	/**
	* 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') );
	if ($this->isDebugMode() && constOn('DBG_PROFILE_MEMORY')) {
	$this->Debugger->appendMemoryUsage('Application before Done:');
	}

	if ($this->GetVar('admin')) {
	$reg = '/('.preg_quote(BASE_PATH, '/').'.\.html)(#.){0,1}(")/sU';
	$this->HTML = preg_replace($reg, "$1?admin=1$2$3", $this->HTML);
	}

	//eval("?".">".$this->HTML);

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

	if (constOn('DBG_CACHE')) {
	$cache =& $this->recallObject('Cache');
	$cache->printStatistics();
	}

	$this->HTML = ob_get_clean() . $this->HTML . $this->Debugger->printReport(true);
	}
	else {
	$this->HTML = ob_get_clean().$this->HTML;
	}

	if ($this->UseOutputCompression()) {
	header('Content-Encoding: gzip');
	$compression_level = $this->ConfigValue('OutputCompressionLevel');
	if ($compression_level < 0 \|\| $compression_level > 9) $compression_level = 7;
	echo gzencode($this->HTML, $compression_level);
	}
	else {
	echo $this->HTML;
	}

	$this->UpdateCache();

	flush();

	$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->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)
	{
	// $http_query =& $this->recallObject('HTTPQuery');
	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)
	{
	// $http_query =& $this->recallObject('HTTPQuery');
	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)
	{
	$session =& $this->recallObject('Session');
	$this->Session->StoreVar($var, $val);
	}

	function StorePersistentVar($var, $val)
	{
	$this->Session->StorePersistentVar($var, $val);
	}

	function StoreVarDefault($var, $val)
	{
	$session =& $this->recallObject('Session');
	$this->Session->StoreVarDefault($var, $val);
	}

	/**
	* 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 = '')
	{
	if (!isset($ses_var)) $ses_var = $var;
	if ($this->GetVar($var) !== false) {
	$this->StoreVar($ses_var, $this->GetVar($var));
	}
	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;
	}

	/* Seems to be not used anywhere... /Kostja

	function SetTemplateBody($title,$body)
	{
	$templates_cache =& $this->recallObject('TemplatesCache');
	$templates_cache->SetTemplateBody($title,$body);
	}*/

	function ProcessTag($tag_data)
	{
	$a_tag = new Tag($tag_data,$this->Parser);
	return $a_tag->DoProcessTag();
	}

	function ProcessParsedTag($prefix, $tag, $params)
	{
	if (defined('NPARSER') && NPARSER) {
	$p = $this->Parser->GetProcessor($prefix);
	return $p->ProcessParsedTag($tag, $params, $prefix);
	}

	$a_tag = new Tag('',$this->Parser);
	$a_tag->Tag = $tag;
	$tmp=$this->Application->processPrefix($prefix);
	$a_tag->Processor = $tmp['prefix'];
	$a_tag->Special = $tmp['special'];
	$a_tag->NamedParams = $params;
	return $a_tag->DoProcessTag();
	}

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

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

	/**
	* 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)
	{
	if(!$t) $t = $this->GetVar('t'); // moved from kMainTagProcessor->T()

	if ($this->isModuleEnabled('Proj-CMS')) {
	$t = preg_replace('/^Content\//', '', $t);
	}

	/*if ($this->GetVar('skip_last_template')) {
	$params['opener'] = 'p';
	$this->SetVar('m_opener', 'p');
	}

	if ($t == 'incs/close_popup') {
	// because this template closes the popup and we don't need popup mark here anymore
	$params['m_opener'] = 's';
	}*/

	if( substr($t, -4) == '.tpl' ) $t = substr($t, 0, strlen($t) - 4 );

	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');
	$cookie_url = trim($session->CookieDomain.$session->CookiePath, '/.');
	if ($ssl) {
	$target_url = $this->ConfigValue('SSL_URL');
	}
	else {
	$target_url = 'http://'.DOMAIN.$this->ConfigValue('Site_Path');
	}

	if (!preg_match('#'.preg_quote($cookie_url).'#', $target_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));
	}
	}
	return $ret;
	}
	else {
	//define('DBG_REDIRECT', 1);
	$t = $this->GetVar('t');
	}
	}

	$pass = isset($params['pass']) ? $params['pass'] : '';
	$pass_events = isset($params['pass_events']) ? $params['pass_events'] : false; // pass events with url

	$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))
	{
	$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] ...
	sort($pass_info, SORT_STRING); // to be prefix1,prefix1.special1,prefix1.special2,prefix3.specialX

	// 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)
	{
	// $session =& $this->recallObject('Session');
	$force_admin = getArrayValue($params,'admin') \|\| $this->GetVar('admin');

	// if($force_admin) $sid = $this->GetSID();

	$ret = '';
	$env = '';

	$encode = false;
	if (isset($params['__URLENCODE__']))
	{
	$encode = $params['__URLENCODE__'];
	unset($params['__URLENCODE__']);
	}

	if (isset($params['__SSL__'])) {
	unset($params['__SSL__']);
	}

	$m_only = true;
	$pass_info = $this->getPassInfo($pass);
	if ($pass_info) {
	if ($pass_info[0] == 'm') array_shift($pass_info);
	$params['t'] = $t;
	foreach($pass_info as $pass_index => $pass_element)
	{
	list($prefix) = explode('.', $pass_element);
	$require_rewrite = $this->findModule('Var', $prefix) && $this->getUnitOption($prefix, 'CatalogItem');
	if ($require_rewrite) {
	// if next prefix is same as current, but with special => exclude current prefix from url
	$next_prefix = getArrayValue($pass_info, $pass_index + 1);
	if ($next_prefix) {
	$next_prefix = substr($next_prefix, 0, strlen($prefix) + 1);
	if ($prefix.'.' == $next_prefix) continue;
	}
	$a = $this->BuildModuleEnv_NEW($pass_element, $params, $pass_events);
	if ($a) {
	$ret .= '/'.$a;
	$m_only = false;
	}
	}
	else
	{
	$env .= ':'.$this->BuildModuleEnv($pass_element, $params, $pass_events);
	}
	}

	if (!$m_only \|\| preg_match('/c\.[-\d]*/', implode(',', $pass_info))) {
	$params['pass_category'] = 1;
	}
	$ret = $this->BuildModuleEnv_NEW('m', $params, $pass_events).$ret;
	$cat_processed = isset($params['category_processed']) && $params['category_processed'];
	if ($cat_processed) {
	unset($params['category_processed']);
	}

	if (!$m_only \|\| !$cat_processed \|\| !defined('EXP_DIR_URLS')) {
	$ret = trim($ret, '/').'.html';
	}
	else {
	$ret .= '/';
	}

	// $ret = trim($ret, '/').'/';
	if($env) $params[ENV_VAR_NAME] = ltrim($env, ':');
	}

	unset($params['pass'], $params['opener'], $params['m_event']);
	if ($force_admin) $params['admin'] = 1;

	if( getArrayValue($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;
	}
	$ret .= preg_replace('/^'.$join_string.'(.*)/', '?\\1', $params_str);

	if ($encode) {
	$ret = str_replace('\\', '%5C', $ret);
	}
	return $ret;
	}


	function BuildModuleEnv_NEW($prefix_special, &$params, $pass_events = false)
	{
	$event_params = Array('pass_events' => $pass_events, 'url_params' => $params);
	$event = new kEvent($prefix_special.':BuildEnv', $event_params);
	$this->HandleEvent($event);
	$params = $event->getEventParam('url_params'); // save back unprocessed parameters

	$ret = '';
	if ($event->getEventParam('env_string')) {
	$ret = trim( $event->getEventParam('env_string'), '/');
	}
	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)
	{
	$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.(constOn('INPORTAL_ENV') ? '-' : ':');

	$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 = 0;
	$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__') {
	// to put category & item templates into cache
	$filename = $this->getFilename('c', $category_id);
	if ($item_id) {
	$mod_rw_helper =& $this->Application->recallObject('ModRewriteHelper');
	$t = $mod_rw_helper->GetItemTemplate($category_id, $pass_element); // $pass_element should be the last processed element
	// $t = $this->getCache('item_templates', $category_id);
	}
	elseif ($category_id) {
	$t = $this->getCache('category_templates', $category_id);
	}
	else {
	$t = 'index';
	}
	}

	$ret .= $t.':'.$this->BuildModuleEnv('m', $params, $pass_events).$env_string;

	unset($params['pass'], $params['opener'], $params['m_event']);

	if ($this->GetVar('admin') && !isset($params['admin'])) {
	$params['admin'] = 1;
	}

	if( isset($params['escape']) && $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)
	{
	if ($ssl === null) {
	return PROTOCOL.SERVER_NAME.(defined('PORT')?':'.PORT : '').rtrim(BASE_PATH, '/').$prefix.'/';
	}
	else {
	if ($ssl) {
	return rtrim( $this->ConfigValue('SSL_URL'), '/').$prefix.'/';
	}
	else {
	return 'http://'.DOMAIN.(defined('PORT')?':'.PORT : '').rtrim( $this->ConfigValue('Site_Path'), '/').$prefix.'/';
	}
	}
	}

	function Redirect($t='', $params=null, $prefix='', $index_file=null)
	{
	$js_redirect = getArrayValue($params, 'js_redirect');
	if (preg_match("/external:(.*)/", $t, $rets)) {
	$location = $rets[1];
	}
	else {
	if ($t == '' \|\| $t === true) $t = $this->GetVar('t');

	// pass prefixes and special from previous url
	if( isset($params['js_redirect']) ) unset($params['js_redirect']);

	if (!isset($params['pass'])) $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);
	//echo " location : $location <br>";
	}

	$a_location = $location;
	$location = "Location: $location";


	if ($this->isDebugMode() && constOn('DBG_REDIRECT')) {
	$this->Debugger->appendTrace();
	echo "<b>Debug output above!!!</b> Proceed to redirect: <a href=\"$a_location\">$a_location</a><br>";
	}
	else {
	if ($js_redirect) {
	$this->SetVar('t', 'redirect');
	$this->SetVar('redirect_to_js', addslashes($a_location) );
	$this->SetVar('redirect_to', $a_location);
	return true;
	}
	else {
	if ($this->GetVar('ajax') == 'yes' && $t != $this->GetVar('t')) {
	// redirection to other then current template during ajax request
	echo '#redirect#'.$a_location;
	}
	elseif (headers_sent() != '') {
	// some output occured -> redirect using javascript
	echo '<script type="text/javascript">window.location.href = \''.$a_location.'\';</script>';
	}
	else {
	// no output before -> redirect using HTTP header

	// header('HTTP/1.1 302 Found');
	header("$location");
	}
	}
	}

	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)
	{
	return $this->Phrases->GetPhrase($label);
	}

	/**
	* 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 != -1) $user_id = -2;
	$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);

	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 != -2) && constOn('DBG_REQUREST_LOG') ) {
	$http_query =& $this->recallObject('HTTPQuery');
	$http_query->writeRequestLog(DBG_REQUREST_LOG);
	}

	if ($user_id != -2) {
	// normal users + root
	$this->LoadPersistentVars();
	}
	}

	/**
	* Loads current user persistent session data
	*
	*/
	function LoadPersistentVars()
	{
	$this->Session->LoadPersistentVars();
	}

	function LoadCache() {
	$cache_key = $this->GetVar('t').$this->GetVar('m_theme').$this->GetVar('m_lang').$this->IsAdmin();
	$query = sprintf("SELECT PhraseList, ConfigVariables FROM %s WHERE Template = %s",
	TABLE_PREFIX.'PhraseCache',
	$this->Conn->Qstr(md5($cache_key)));
	$res = $this->Conn->GetRow($query);

	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->Caches['ConfigVariables'] = $config_ids;
	$this->ConfigCacheIds = $config_ids;
	}

	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) {
	$this->ConfigHash = array_merge($this->ConfigHash, $this->Conn->GetCol(
	'SELECT VariableValue, VariableName FROM '.TABLE_PREFIX.'ConfigurationValues
	WHERE VariableId IN ('.implode(',', $this->Caches['ConfigVariables']).')', 'VariableName'));
	}
	}

	/**
	* Returns configuration option value by name
	*
	* @param string $name
	* @return string
	*/
	function ConfigValue($name)
	{
	$res = isset($this->ConfigHash[$name]) ? $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 TemplateParser 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;
	}

	/**
	* Checks if it is admin
	*
	* @return bool
	* @author Alex
	*/
	function IsAdmin()
	{
	return constOn('ADMIN');
	}

	/**
	* 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( constOn('SILENT_LOG') )
	{
	$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);
	}

	if( !$this->errorHandlers ) {
	if ($errno == E_USER_ERROR) {
	header('HTTP/1.0 500 Script Fatal Error');
	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;
	}
	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];
	$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 unknown
	*/
	function &EmailEventAdmin($email_event_name, $to_user_id = -1, $send_params = false)
	{
	$event =& $this->EmailEvent($email_event_name, 1, $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 unknown
	*/
	function &EmailEventUser($email_event_name, $to_user_id = -1, $send_params = false)
	{
	$event =& $this->EmailEvent($email_event_name, 0, $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 unknown
	*/
	function &EmailEvent($email_event_name, $email_event_type, $to_user_id = -1, $send_params = false)
	{
	$params = array(
	'EmailEventName' => $email_event_name,
	'EmailEventToUserId' => $to_user_id,
	'EmailEventType' => $email_event_type,
	);
	if ($send_params) {
	$params['DirectSendParams'] = $send_params;
	}
	$event_str = isset($send_params['use_special']) ? 'emailevents.'.$send_params['use_special'].':OnEmailEvent' : '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)
	{
	$visit =& $this->recallObject('visits');
	$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);
	}

	/**
	* 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 TimeZoneAdjustment($time_zone = null)
	{
	if ($time_zone == 'GMT') {
	return (-1) * adodb_date('Z');
	}
	$target_zone = isset($time_zone) ? $time_zone : $this->ConfigValue('Config_Site_Time');
	return 3600 * ($target_zone - $this->ConfigValue('Config_Server_Time'));
	}

	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 -1:
	$user_groups = $this->ConfigValue('User_LoggedInGroup');
	break;
	case -2:
	$user_groups = $this->ConfigValue('User_LoggedInGroup');
	$user_groups .= ','.$this->ConfigValue('User_GuestGroup');
	break;
	default:
	$sql = 'SELECT GroupId FROM '.TABLE_PREFIX.'UserGroup WHERE PortalUserId = '.$user_id;
	$res = $this->Conn->GetCol($sql);
	$user_groups = Array( $this->ConfigValue('User_LoggedInGroup') );
	if(is_array($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)
	{
	$category_template = $this->getFilename('c', $category_id); // to rebuild "category_tree" cache

	$tree_index = $this->getCache('category_tree', $category_id);

	if ($tree_index) {
	$ret = Array ();
	list ($ret['TreeLeft'], $ret['TreeRight']) = explode(';', $tree_index);

	return $ret;
	}

	return false;
	}
	}

	?>
	\ No newline at end of file

	Property changes on: branches/RC/core/kernel/application.php
	___________________________________________________________________
	Modified: cvs2svn:cvs-rev
	## -1 +1 ##
	-1.186.2.12
	\ No newline at end of property
	+1.186.2.13
	\ No newline at end of property
	Index: branches/RC/core/kernel/nparser/nparser.php
	===================================================================
	--- branches/RC/core/kernel/nparser/nparser.php (revision 10579)
	+++ branches/RC/core/kernel/nparser/nparser.php (revision 10580)
	@@ -1,378 +1,399 @@
	<?php

	include_once(KERNEL_PATH.'/nparser/ntags.php');

	class NParser extends kBase {

	var $Stack = array();
	var $Level = 0;

	var $Buffers = array();
	var $InsideComment = false;

	var $Params = array();
	var $ParamsStack = array();
	var $ParamsLevel = 0;

	var $Elements = array(); // holds dynamic elements to function names mapping during execution
	var $DataExists = false;


	function NParser()
	{
	parent::kBase();
	}

	function Compile($pre_parsed)
	{
	$data = file_get_contents($pre_parsed['tname']);

	+ $this->CompileRaw($data, $pre_parsed['tname']);
	+
	+ // saving compiled version
	+ $compiled = fopen($pre_parsed['fname'], 'w');
	+ if (!fwrite($compiled, $this->Buffers[0])) {
	+ trigger_error('Saving compiled template failed', E_USER_ERROR);
	+ }
	+ fclose($compiled);
	+ return true;
	+ }
	+
	+ function Parse($raw_template, $name=null)
	+ {
	+ $this->CompileRaw($raw_template, $name);
	+ ob_start();
	+ $_parser =& $this;
	+ eval('?'.'>'.$this->Buffers[0]);
	+ $output = ob_get_contents();
	+ ob_end_clean();
	+ return $output;
	+ }
	+
	+ function CompileRaw($data, $t_name)
	+ {
	$code = "extract (\$_parser->Params);\n";
	$this->Buffers[0] = '<?'."php $code ?>\n";

	// finding all the tags
	$reg = '(.?)(<[\\/]?)inp2:([^>]?)([\\/]?>)(\r\n){0,1}';
	preg_match_all('/'.$reg.'/s', $data, $results, PREG_SET_ORDER + PREG_OFFSET_CAPTURE);

	$this->InsideComment = false;
	foreach ($results as $tag_data) {
	$tag = array(
	'opening' => $tag_data[2][0],
	'tag' => $tag_data[3][0],
	'closing' => $tag_data[4][0],
	'line' => substr_count(substr($data, 0, $tag_data[2][1]), "\n")+1,
	- 'file' => $pre_parsed['tname'],
	+ 'file' => $t_name,
	);

	// the idea is to count number of comment openings and closings before current tag
	// if the numbers do not match we inverse the status of InsideComment
	if (substr_count($tag_data[1][0], '<!--') != substr_count($tag_data[1][0], '-->')) {
	$this->InsideComment = !$this->InsideComment;
	}

	// appending any text/html data found before tag
	$this->Buffers[$this->Level] .= $tag_data[1][0];
	if (!$this->InsideComment) {
	$tmp_tag = $this->Application->CurrentNTag;
	$this->Application->CurrentNTag = $tag;
	if ($this->ProcessTag($tag) === false) {
	$this->Application->CurrentNTag = $tmp_tag;
	return false;
	}
	$this->Application->CurrentNTag = $tmp_tag;
	}
	else {
	$this->Buffers[$this->Level] .= $tag_data[2][0].$tag_data[3][0].$tag_data[4][0];
	}
	}

	if ($this->Level > 0) {
	$this->Application->handleError(E_USER_ERROR, 'Unclosed tag opened by '.$this->TagInfo($this->Stack[$this->Level]->Tag), $this->Stack[$this->Level]->Tag['file'], $this->Stack[$this->Level]->Tag['line']);
	return false;
	}

	// appending text data after last tag (after its closing pos),
	// if no tag was found at all ($tag_data is not set) - append the whole $data
	$this->Buffers[$this->Level] .= isset($tag_data) ? substr($data, $tag_data[4][1]+strlen($tag_data[4][0])) : $data;
	-
	- // saving compiled version
	- $compiled = fopen($pre_parsed['fname'], 'w');
	- if (!fwrite($compiled, $this->Buffers[0])) {
	- trigger_error('Saving compiled template failed', E_USER_ERROR);
	- }
	- fclose($compiled);
	- return true;
	+ $this->Buffers[$this->Level] = preg_replace('/<!--##(.*?)##-->/s', '', $this->Buffers[$this->Level]); // remove hidden comments IB#23065
	}

	function SplitParamsStr($params_str)
	{
	preg_match_all('/([\${}a-zA-Z0-9_.\\-\\\\#\\[\\]]+)=(["\']{1,1})(.*?)(?<!\\\)\\2/s', $params_str, $rets, PREG_SET_ORDER);

	$values = Array();

	// we need to replace all occurences of any current param $key with {$key} for correct variable substitution
	foreach ($rets AS $key => $val){
	$values[$val[1]] = str_replace('\\' . $val[2], $val[2], $val[3]);
	}
	return $values;
	}

	function SplitTag($tag)
	{
	if (!preg_match('/([^_ \t\n])[_]?([^ \t\n])[ \t\n](.)$$/s', $tag['tag'], $parts)) {
	// this is virtually impossible, but just in case
	$this->Application->handleError(E_USER_ERROR, 'Incorrect tag format: '.$tag['tag'], $tag['file'], $tag['line']);
	return false;
	}

	$splited['prefix'] = $parts[2] ? $parts[1] : '__auto__';
	$splited['name'] = $parts[2] ? $parts[2] : $parts[1];
	$splited['attrs'] = $parts[3];
	return $splited;
	}

	function ProcessTag($tag)
	{
	$splited = $this->SplitTag($tag);
	if ($splited === false) return false;
	$tag = array_merge($tag, $splited);
	$tag['processed'] = false;
	$tag['NP'] = $this->SplitParamsStr($tag['attrs']);

	$o = '';
	$tag['is_closing'] = $tag['opening'] == '</' \|\| $tag['closing'] == '/>';
	if (class_exists('_Tag_'.$tag['name'])) { // block tags should have special handling class
	if ($tag['opening'] == '<') {
	$class = '_Tag_'.$tag['name'];
	$instance = new $class($tag);
	$instance->Parser =& $this;
	/* @var $instance _BlockTag */
	$this->Stack[++$this->Level] =& $instance;
	$this->Buffers[$this->Level] = '';
	$open_code = $instance->Open($tag);
	if ($open_code === false) return false;
	$o .= $open_code;
	}

	if ($tag['is_closing']) { // not ELSE here, because tag may be <empty/> and still has a handler-class
	if ($this->Level == 0) {
	$dump = array();
	foreach ($this->Stack as $instance) {
	$dump[] = $instance->Tag;
	}
	print_pre($dump);
	$this->Application->handleError(E_USER_ERROR, 'Closing tag without an opening: '.$this->TagInfo($tag).' <b> - probably opening tag was removed or nested tags error</b>', $tag['file'], $tag['line']);
	return false;
	}
	if ($this->Stack[$this->Level]->Tag['name'] != $tag['name']) {
	$opening_tag = $this->Stack[$this->Level]->Tag;
	$this->Application->handleError(E_USER_ERROR,
	'Closing tag '.$this->TagInfo($tag).' does not match
	opening tag at current nesting level ('.$this->TagInfo($opening_tag).'
	opened at line '.$opening_tag['line'].')', $tag['file'], $tag['line']);
	return false;
	}
	$o .= $this->Stack[$this->Level]->Close($tag); // DO NOT use $this->Level-- here because it's used inside Close
	$this->Level--;
	}
	}
	else { // regular tags - just compile
	if (!$tag['is_closing']) {
	$this->Application->handleError(E_USER_ERROR, 'Tag without a handler: '.$this->TagInfo($tag).' <b> - probably missing <empty <span style="color: red">/</span>> tag closing</b>', $tag['file'], $tag['line']);
	return false;
	}

	if ($this->Level > 0) $o .= $this->Stack[$this->Level]->PassThrough($tag);
	if (!$tag['processed']) {
	$compiled = $this->CompileTag($tag);
	if ($compiled === false) return false;
	$o .= '<?'.'php '.$compiled." ?>\n";
	}
	}
	$this->Buffers[$this->Level] .= $o;
	return true;
	}

	function TagInfo($tag, $with_params=false)
	{
	return "<b>{$tag['prefix']}_{$tag['name']}".($with_params ? ' '.$tag['attrs'] : '')."</b>";
	}

	function CompileParamsArray($arr)
	{
	$to_pass = 'Array(';
	foreach ($arr as $name => $val) {
	$to_pass .= '"'.$name.'" => "'.str_replace('"', '\"', $val).'",';
	}
	$to_pass .= ')';
	return $to_pass;
	}

	function CompileTag($tag)
	{
	$to_pass = $this->CompileParamsArray($tag['NP']);

	$code = '';
	if ($tag['prefix'] == '__auto__') {
	$prefix = $this->GetParam('PrefixSpecial');
	$code .= '$_p_ =& $_parser->GetProcessor($PrefixSpecial);'."\n";
	$code .= 'echo $_p_->ProcessParsedTag(\''.$tag['name'].'\', '.$to_pass.', "$PrefixSpecial", \''.$tag['file'].'\', '.$tag['line'].');'."\n";
	}
	else {
	$prefix = $tag['prefix'];
	$code .= '$_p_ =& $_parser->GetProcessor("'.$tag['prefix'].'");'."\n";
	$code .= 'echo $_p_->ProcessParsedTag(\''.$tag['name'].'\', '.$to_pass.', "'.$tag['prefix'].'", \''.$tag['file'].'\', '.$tag['line'].');'."\n";
	}
	if (isset($tag['NP']['result_to_var'])) {
	$code .= "\$params['{$tag['NP']['result_to_var']}'] = \$_parser->GetParam('{$tag['NP']['result_to_var']}');\n";
	$code .= "\${$tag['NP']['result_to_var']} = \$params['{$tag['NP']['result_to_var']}'];\n";
	}
	if ($prefix && strpos($prefix, '$') === false) {
	$p =& $this->GetProcessor($prefix);
	if (!is_object($p) \|\| !$p->CheckTag($tag['name'], $tag['prefix'])) {
	$this->Application->handleError(E_USER_ERROR, 'Unknown tag: '.$this->TagInfo($tag).' <b> - incorrect tag name or prefix </b>', $tag['file'], $tag['line']);
	return false;
	}
	}
	return $code;
	}

	function CheckTemplate($t, $silent=null)
	{
	$pre_parsed = $this->Application->TemplatesCache->GetPreParsed($t);
	if (!$pre_parsed) {
	if (!$silent) {
	if ($this->Application->isDebugMode()) $this->Application->Debugger->appendTrace();
	trigger_error("Cannot include $t - file does not exist", E_USER_ERROR);
	}
	return false;
	}
	if (!$pre_parsed \|\| !$pre_parsed['active'] \|\| defined('DBG_NPARSER_FORCE_COMPILE') && DBG_NPARSER_FORCE_COMPILE) {
	$inc_parser = new NParser();
	if (!$inc_parser->Compile($pre_parsed)) return false;
	}
	return $pre_parsed;
	}

	function Run($t, $silent=null)
	{
	$pre_parsed = $this->CheckTemplate($t, $silent);
	if (!$pre_parsed) return false;

	ob_start();
	$_parser =& $this;
	if ($pre_parsed['mode'] == 'file') {
	+ if (false && $result = $this->Application->getCache('nparser', $pre_parsed['fname'])) {
	+ return $result;
	+ }
	include($pre_parsed['fname']);
	}
	else {
	eval('?'.'>'.$pre_parsed['content']);
	}
	$output = ob_get_contents();
	+ // $this->Application->setCache('nparser', $pre_parsed['fname'], $output);
	ob_end_clean();

	return $output;
	}

	function &GetProcessor($prefix)
	{
	static $Processors = array();
	if (!isset($Processors[$prefix])) {
	$Processors[$prefix] = $this->Application->recallObject($prefix.'_TagProcessor');
	}

	return $Processors[$prefix];
	}

	function SelectParam($params, $possible_names)
	{
	if (!is_array($params)) return;
	if (!is_array($possible_names))

	$possible_names = explode(',', $possible_names);
	foreach ($possible_names as $name)
	{
	if( isset($params[$name]) ) return $params[$name];
	}
	return false;
	}

	function SetParams($params)
	{
	$this->Params = $params;
	$keys = array_keys($this->Params);
	}

	function GetParam($name)
	{
	return isset($this->Params[$name]) ? $this->Params[$name] : false;
	}

	function SetParam($name, $value)
	{
	$this->Params[$name] = $value;
	}

	function PushParams($params)
	{
	$this->ParamsStack[$this->ParamsLevel++] = $this->Params;
	$this->Params = $params;
	}

	function PopParams()
	{
	$this->Params = $this->ParamsStack[--$this->ParamsLevel];
	}

	function ParseBlock($params, $pass_params=false)
	{
	if ($pass_params \|\| isset($params['pass_params'])) $params = array_merge($this->Params, $params);
	$this->PushParams($params);
	$data_exists_bak = $this->DataExists;

	// if we are parsing design block and we have block_no_data - we need to wrap block_no_data into design,
	// so we should set DataExists to true manually, otherwise the design block will be skipped because of data_exists in params
	//
	// keep_data_exists is used by block RenderElement (always added in ntags.php), to keep the DataExists value
	// from inside-content block, otherwise when parsing the design block DataExists will be reset to false resulting missing design block
	$this->DataExists = isset($params['keep_data_exists']) && $this->DataExists \|\| (isset($params['design']) && isset($params['block_no_data']) && $params['name'] == $params['design']);

	if (!isset($this->Elements[$params['name']])) {
	$pre_parsed = $this->Application->TemplatesCache->GetPreParsed($params['name']);
	if ($pre_parsed) {
	return $this->IncludeTemplate($params);
	}

	if ($this->Application->isDebugMode()) {
	$this->Application->Debugger->appendTrace();
	}
	$trace_results = debug_backtrace();
	$this->Application->handleError(E_USER_ERROR, '<b>Rendering of undefined element '.$params['name'].'</b>', $trace_results[0]['file'], $trace_results[0]['line']);
	}

	$m_processor =& $this->GetProcessor('m');
	$flag_values = $m_processor->PreparePostProcess($params);

	$f_name = $this->Elements[$params['name']];
	$ret = $f_name($this, $params);
	$ret = $m_processor->PostProcess($ret, $flag_values);
	$this->PopParams();

	$this->CheckNoData($ret, $params);

	$this->DataExists = $data_exists_bak \|\| $this->DataExists;
	return $ret;
	}

	function IncludeTemplate($params, $silent=null)
	{
	$t = is_array($params) ? $this->SelectParam($params, 't,template,block,name') : $params;
	$t = eregi_replace("\.tpl$", '', $t);
	$data_exists_bak = $this->DataExists;
	$this->DataExists = false;

	if ($t == 'platform/elements/content_boxes/sub_categories') {
	echo '';
	}

	$this->PushParams($params);
	$ret = $this->Run($t, $silent);
	$this->PopParams();

	$this->CheckNoData($ret, $params);
	$this->DataExists = $data_exists_bak \|\| $this->DataExists;
	return $ret;
	}

	function CheckNoData(&$ret, $params)
	{
	if (isset($params['data_exists']) && !$this->DataExists) {
	$block_no_data = isset($params['BlockNoData']) ? $params['BlockNoData'] : (isset($params['block_no_data']) ? $params['block_no_data'] : false);
	if ($block_no_data) {
	$ret = $this->ParseBlock(array('name'=>$block_no_data));
	}
	else {
	$ret = '';
	}
	}
	}
	}
	\ No newline at end of file

	Property changes on: branches/RC/core/kernel/nparser/nparser.php
	___________________________________________________________________
	Modified: cvs2svn:cvs-rev
	## -1 +1 ##
	-1.1.2.5
	\ No newline at end of property
	+1.1.2.6
	\ No newline at end of property
	Index: branches/RC/core/units/themes/themes_config.php
	===================================================================
	--- branches/RC/core/units/themes/themes_config.php (revision 10579)
	+++ branches/RC/core/units/themes/themes_config.php (revision 10580)
	@@ -1,104 +1,104 @@
	<?php

	$config = Array(
	'Prefix' => 'theme',
	- 'ItemClass' => Array('class'=>'kDBItem','file'=>'','build_event'=>'OnItemBuild'),
	+ 'ItemClass' => Array('class'=>'ThemeItem','file'=>'theme_item.php','build_event'=>'OnItemBuild'),
	'ListClass' => Array('class'=>'kDBList','file'=>'','build_event'=>'OnListBuild'),
	'EventHandlerClass' => Array('class'=>'ThemesEventHandler','file'=>'themes_eh.php','build_event'=>'OnBuild'),
	'TagProcessorClass' => Array('class'=>'ThemesTagProcessor','file'=>'themes_tag_processor.php','build_event'=>'OnBuild'),
	'AutoLoad' => true,
	'Hooks' => Array(),
	'QueryString' => Array(
	1 => 'id',
	2 => 'page',
	3 => 'event',
	4 => 'mode',
	),

	'IDField' => 'ThemeId',
	'StatusField' => Array('Enabled', 'PrimaryTheme'),

	'PermSection' => Array('main' => 'in-portal:configure_themes'),

	'TitleField' => 'Name',

	'TitlePresets' => Array (
	'default' => Array (
	'new_status_labels' => Array('theme' => '!la_title_Adding_Theme!'),
	'edit_status_labels' => Array('theme' => '!la_title_Editing_Theme!'),
	'new_titlefield' => Array('theme' => ''),
	),

	'themes_list' => Array('prefixes' => Array('theme_List'), 'format' => "!la_title_Configuration! - !la_title_Themes! (#theme_recordcount#)"),
	'themes_edit_general' => Array('prefixes' => Array('theme'), 'format' => "#theme_status# '#theme_titlefield#' - !la_title_General!"),
	'themes_edit_files' => Array('prefixes' => Array('theme', 'theme-file_List'), 'format' => "#theme_status# '#theme_titlefield#' - !la_title_ThemeFiles! (#theme-file_recordcount#)"),
	),

	'TableName' => TABLE_PREFIX.'Theme',
	'SubItems' => Array('theme-file'),

	'FilterMenu' => Array(
	'Groups' => Array(
	Array('mode' => 'AND', 'filters' => Array(0,1), 'type' => WHERE_FILTER),
	),

	'Filters' => Array(
	0 => Array('label' =>'la_Enabled', 'on_sql' => '', 'off_sql' => '%1$s.Enabled != 1' ),
	1 => Array('label' => 'la_Disabled', 'on_sql' => '', 'off_sql' => '%1$s.Enabled != 0' ),
	)
	),

	'AutoDelete' => true,
	'AutoClone' => true,

	'ListSQLs' => Array ('' => ' SELECT %1$s.* %2$s
	FROM %s
	LEFT JOIN '.TABLE_PREFIX.'Stylesheets st ON st.StylesheetId = %1$s.StylesheetId'),
	'ItemSQLs' => Array ( '' => ' SELECT %1$s.* %2$s
	FROM %s
	LEFT JOIN '.TABLE_PREFIX.'Stylesheets st ON st.StylesheetId = %1$s.StylesheetId'),

	'ListSortings' => Array (
	'' => Array(
	'Sorting' => Array('Name' => 'asc'),
	)
	),

	'CalculatedFields' => Array (
	'' => Array (
	'StyleName' => 'st.Name',
	'LastCompiled' => 'st.LastCompiled',
	),
	),

	'Fields' => Array(
	'ThemeId' => Array('type' => 'int', 'not_null' => 1, 'default' => 0),
	'Name' => Array('type' => 'string','not_null' => 1, 'required' => 1, 'default' => ''),
	'Enabled' => Array('type' => 'int', 'formatter' => 'kOptionsFormatter', 'options' => Array(1=>'la_Enabled', 0=>'la_Disabled'), 'use_phrases'=>1, 'not_null' => 1, 'default' => 1),
	'Description' => Array('type' => 'string','default' => null),
	'PrimaryTheme' => Array('type' => 'int', 'formatter' => 'kOptionsFormatter', 'options' => Array (1 => 'la_Yes', 0 => 'la_No'), 'use_phrases' => 1, 'not_null' => 1, 'default' => 0),
	'CacheTimeout' => Array('type' => 'int', 'not_null' => 1, 'default' => 0),
	'StylesheetId' => Array('type' => 'int', 'formatter' => 'kOptionsFormatter', 'options_sql' => 'SELECT %s FROM '.TABLE_PREFIX.'Stylesheets', 'option_key_field' => 'StylesheetId', 'option_title_field' => 'Name', 'not_null' => 1, 'default' => 0),
	),

	'VirtualFields' => Array (
	'StyleName' => Array ('type' => 'string', 'default' => ''),
	'LastCompiled' => Array ('type' => 'int', 'default' => null),
	),

	'Grids' => Array(
	'Default' => Array(
	'Icons' => Array('default'=>'icon16_custom.gif', '1_1' => 'icon16_theme_primary.gif', '1_0' => 'icon16_theme.gif', '0_0' => 'icon16_theme_disabled.gif'),
	'Fields' => Array(
	'ThemeId' => Array ('title' => 'la_col_Id', 'data_block' => 'grid_checkbox_td', 'filter_block' => 'grid_range_filter'),
	'Name' => Array( 'title'=>'la_col_Name',),
	'Description' => Array( 'title'=>'la_col_Description', ),
	'Enabled' => Array( 'title'=>'la_col_Status', 'filter_block' => 'grid_options_filter'),
	// 'PrimaryTheme' => Array( 'title'=>'la_col_Primary', 'filter_block' => 'grid_options_filter'),
	),

	),
	),
	);

	?>
	\ No newline at end of file

	Property changes on: branches/RC/core/units/themes/themes_config.php
	___________________________________________________________________
	Modified: cvs2svn:cvs-rev
	## -1 +1 ##
	-1.17.2.1
	\ No newline at end of property
	+1.17.2.2
	\ No newline at end of property
	Index: branches/RC/core/units/admin/admin_events_handler.php
	===================================================================
	--- branches/RC/core/units/admin/admin_events_handler.php (revision 10579)
	+++ branches/RC/core/units/admin/admin_events_handler.php (revision 10580)
	@@ -1,514 +1,522 @@
	<?php

	class AdminEventsHandler extends kDBEventHandler {

	function mapPermissions()
	{
	parent::mapPermissions();
	$permissions = Array(
	'OnSaveColumns' => array('self' => true),
	'OnClosePopup' => array('self' => true),
	'OnSaveSetting' => array('self' => true),
	// export/import permissions is checked within events
	'OnExportCSV' => Array('self' => true),
	'OnGetCSV' => Array('self' => true),
	'OnCSVImportBegin' => Array('self' => true),
	'OnCSVImportStep' => Array('self' => true),
	'OnDropTempTablesByWID' => array('self' => true),
	);
	$this->permMapping = array_merge($this->permMapping, $permissions);
	}

	/**
	* Checks permissions of user
	*
	* @param kEvent $event
	*/
	function CheckPermission(&$event)
	{
	$system_events = Array (
	'OnResetModRwCache', 'OnResetCMSMenuCache', 'OnResetSections',
	'OnResetConfigsCache', 'OnCompileTemplates', 'OnGenerateTableStructure',
	'OnRebuildThemes', 'OnCheckPrefixConfig',
	);

	if ($this->Application->isDebugMode(false) && in_array($event->Name, $system_events)) {
	return true;
	}

	return parent::CheckPermission($event);
	}

	/**
	* Enter description here...
	*
	* @param kEvent $event
	*/
	function OnResetModRwCache(&$event)
	{
	if ($this->Application->GetVar('ajax') == 'yes') {
	$event->status = erSTOP;
	}
	$this->Conn->Query('DELETE FROM '.TABLE_PREFIX.'Cache WHERE VarName LIKE "mod_rw%"');
	}

	function OnResetCMSMenuCache(&$event)
	{
	if ($this->Application->GetVar('ajax') == 'yes') {
	$event->status = erSTOP;
	}
	$this->Conn->Query('DELETE FROM '.TABLE_PREFIX.'Cache WHERE VarName = "cms_menu"');
	}

	function OnResetSections(&$event)
	{
	if ($this->Application->GetVar('ajax') == 'yes') {
	$event->status = erSTOP;
	}
	$this->Conn->Query('DELETE FROM '.TABLE_PREFIX.'Cache WHERE VarName = "sections_parsed"');
	+ if (isset($this->Application->Memcached)) {
	+ $this->Application->Memcached->delete('master:sections_parsed');
	+ }
	}

	function OnResetConfigsCache(&$event)
	{
	if ($this->Application->GetVar('ajax') == 'yes') {
	$event->status = erSTOP;
	}
	$this->Conn->Query('DELETE FROM '.TABLE_PREFIX.'Cache WHERE VarName = "config_files" OR VarName = "configs_parsed" OR VarName = "sections_parsed"');
	+ if (isset($this->Application->Memcached)) {
	+ $this->Application->Memcached->delete('master:config_files');
	+ $this->Application->Memcached->delete('master:configs_parsed');
	+ $this->Application->Memcached->delete('master:sections_parsed');
	+ }
	}

	function OnCompileTemplates(&$event)
	{
	$compiler =& $this->Application->recallObject('NParserCompiler');
	/* @var $compiler NParserCompiler */
	$compiler->CompileTemplatesStep();
	$event->status = erSTOP;
	}

	/**
	* Generates sturcture for specified table
	*
	* @param kEvent $event
	* @author Alex
	*/
	function OnGenerateTableStructure(&$event)
	{
	$types_hash = Array(
	'string' => 'varchar\|text\|mediumtext\|longtext\|date\|datetime\|time\|timestamp\|char\|year\|enum\|set',
	'int' => 'smallint\|mediumint\|int\|bigint\|tinyint',
	'float' => 'float\|double\|decimal',
	);

	$table_name = $this->Application->GetVar('table_name');
	if (!$table_name) {
	echo 'error: no table name specified';
	return ;
	}

	if (TABLE_PREFIX && !preg_match('/^'.preg_quote(TABLE_PREFIX, '/').'(.*)/', $table_name)) {
	// table name without prefix, then add it
	$table_name = TABLE_PREFIX.$table_name;
	}

	if (!$this->Conn->TableFound($table_name)) {
	// table with prefix doesn't exist, assume that just config prefix passed -> resolve table name from it
	$table_name = $this->Application->getUnitOption(substr($table_name, strlen(TABLE_PREFIX)), 'TableName');
	}

	$table_info = $this->Conn->Query('DESCRIBE '.$table_name);

	// 1. prepare config keys
	$id_field = '';
	$fields = Array();
	$float_types = Array ('float', 'double', 'numeric');
	foreach ($table_info as $field_info) {
	if (preg_match('/l[\d]+_.*/', $field_info['Field'])) {
	// don't put multilingual fields in config
	continue;
	}

	$field_options = Array ();

	// 1. get php field type by mysql field type
	foreach ($types_hash as $php_type => $db_types) {
	if (preg_match('/'.$db_types.'/', $field_info['Type'])) {
	$field_options['type'] = $php_type;
	break;
	}
	}

	$default_value = $field_info['Default'];
	if (in_array($php_type, $float_types)) {
	// this is float number
	if (preg_match('/'.$db_types.'$[\d]+,([\d]+)$/i', $field_info['Type'], $regs)) {
	// size is described in structure -> add formatter
	$field_options['formatter'] = 'kFormatter';
	$field_options['format'] = '%01.'.$regs[1].'f';
	if ($field_info['Null'] != 'YES') {
	// null fields, will most likely have NULL as default value
	$default_value = 0;
	}
	}
	else {
	// no size information, just convert to float
	if ($field_info['Null'] != 'YES') {
	// null fields, will most likely have NULL as default value
	$default_value = (float)$default_value;
	}
	}
	}

	if (preg_match('/varchar$([\d]+)$/i', $field_info['Type'], $regs)) {
	$field_options['max_len'] = (int)$regs[1];
	}

	if ($field_info['Null'] != 'YES') {
	$field_options['not_null'] = 1;
	}

	if ($field_info['Key'] == 'PRI') {
	$default_value = 0;
	$id_field = $field_info['Field'];
	}

	if ($php_type == 'int' && ($field_info['Null'] != 'YES' \|\| is_numeric($default_value))) {
	// is integer field AND not null
	$field_options['default'] = (int)$default_value;
	}
	else {
	$field_options['default'] = $default_value;
	}

	$fields[ $field_info['Field'] ] = $this->transformDump($field_options);
	}

	$ret = stripslashes(var_export($fields, true));
	$ret = preg_replace("/'(.?)' => 'Array $(.?), $',/", "'\\1' => Array (\\2),", $ret);
	$ret = preg_replace("/\n '/", "\n\t'", $ret);
	$ret = "'IDField' => '".$id_field."',\n'Fields' => A".substr($ret, 1).',';

	ob_start();
	?>
	<html>
	<head>
	<title>Table "<?php echo $table_name; ?>" Structure</title>
	</head>
	<body bgcolor="#E7E7E7">
	<a href="javascript:window.close();">Close Window</a><br />
	<?php echo $GLOBALS['debugger']->highlightString($ret); ?>
	<br /><a href="javascript:window.close();">Close Window</a><br />
	</body>
	</html>
	<?php
	echo ob_get_clean();
	$event->status = erSTOP;
	}

	function transformDump($dump)
	{
	if (is_array($dump)) {
	$dump = var_export($dump, true);
	}

	$dump = preg_replace("/,\n[ ]*/", ', ', $dump);
	$dump = preg_replace("/array \(\n[ ]*/", 'Array (', $dump); // replace array start
	$dump = preg_replace("/,\n[ ]*\),/", "),", $dump); // replace array end

	return $dump;
	}

	/**
	* Refreshes ThemeFiles & Theme tables by actual content on HDD
	*
	* @param kEvent $event
	*/
	function OnRebuildThemes(&$event)
	{
	if ($this->Application->GetVar('ajax') == 'yes') {
	$event->status = erSTOP;
	}

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

	$themes_helper->refreshThemes();
	}

	function OnSaveColumns(&$event)
	{
	$picker_helper =& $this->Application->recallObject('ColumnPickerHelper');
	/* @var $picker_helper kColumnPickerHelper */

	$picker_helper->SetGridName($this->Application->GetLinkedVar('grid_name'));

	$picked = trim($this->Application->GetVar('picked_str'), '\|');
	$hidden = trim($this->Application->GetVar('hidden_str'), '\|');

	$main_prefix = $this->Application->GetVar('main_prefix');

	$picker_helper->SaveColumns($main_prefix, $picked, $hidden);
	$this->finalizePopup($event);
	}

	/**
	* Saves various admin settings via ajax
	*
	* @param kEvent $event
	*/
	function OnSaveSetting(&$event)
	{
	if ($this->Application->GetVar('ajax') != 'yes') {
	return ;
	}

	$var_name = $this->Application->GetVar('var_name');
	$var_value = $this->Application->GetVar('var_value');

	$this->Application->StorePersistentVar($var_name, $var_value);

	$event->status = erSTOP;
	}

	/**
	* Just closes popup & deletes last_template & opener_stack if popup, that is closing
	*
	* @param kEvent $event
	*/
	function OnClosePopup(&$event)
	{
	$event->SetRedirectParam('opener', 'u');
	}

	/**
	* Occurs right after initialization of the kernel, used mainly as hook-to event
	*
	* @param kEvent $event
	*/
	function OnStartup(&$event)
	{

	}

	/**
	* Occurs right before echoing the output, in Done method of application, used mainly as hook-to event
	*
	* @param kEvent $event
	*/
	function OnBeforeShutdown(&$event)
	{
	}

	/**
	* Is called after tree was build (when not from cache)
	*
	* @param kEvent $event
	*/
	function OnAfterBuildTree(&$event)
	{

	}

	/**
	* Called by AJAX to perform CSV export
	*
	* @param kEvent $event
	*/
	function OnExportCSV(&$event)
	{
	$export_helper =& $this->Application->recallObject('CSVHelper');
	/* @var $export_helper kCSVHelper */

	$prefix_special = $this->Application->GetVar('PrefixSpecial');
	if(!$prefix_special) {
	$prefix_special = $export_helper->ExportData('prefix');
	}
	$prefix_elems = split('\.\|_', $prefix_special, 2);
	$perm_sections = $this->Application->getUnitOption($prefix_elems[0], 'PermSection');
	if(!$this->Application->CheckPermission($perm_sections['main'].'.view')) {
	$this->Application->Redirect('no_permission');
	}

	$export_helper->PrefixSpecial = $prefix_special;
	$export_helper->grid = $this->Application->GetVar('grid');
	$export_helper->ExportStep();
	$event->status = erSTOP;
	}

	/**
	* Returning created by AJAX CSV file
	*
	* @param kEvent $event
	*/
	function OnGetCSV(&$event)
	{
	$export_helper =& $this->Application->recallObject('CSVHelper');
	/* @var $export_helper kCSVHelper */

	$prefix_special = $export_helper->ExportData('prefix');
	$prefix_elems = split('\.\|_', $prefix_special, 2);
	$perm_sections = $this->Application->getUnitOption($prefix_elems[0], 'PermSection');

	if(!$this->Application->CheckPermission($perm_sections['main'].'.view')) {
	$this->Application->Redirect('no_permission');
	}

	$export_helper->GetCSV();
	}

	/**
	* Enter description here...
	*
	* @param kEvent $event
	*/
	function OnCSVImportBegin(&$event)
	{
	$prefix_special = $this->Application->GetVar('PrefixSpecial');
	$prefix_elems = split('\.\|_', $prefix_special, 2);
	$perm_sections = $this->Application->getUnitOption($prefix_elems[0], 'PermSection');

	if(!$this->Application->CheckPermission($perm_sections['main'].'.add') && !$this->Application->CheckPermission($perm_sections['main'].'.edit')) {
	$this->Application->Redirect('no_permission');
	}

	$object =& $event->getObject( Array('skip_autoload' => true) );
	/* @var $object kDBItem */
	$items_info = $this->Application->GetVar( $event->getPrefixSpecial(true) );
	$field_values = array_shift($items_info);
	$object->SetFieldsFromHash($field_values);

	$event->redirect = false;
	$result = 'required';
	if($object->GetDBField('ImportFile')) {
	$import_helper =& $this->Application->recallObject('CSVHelper');
	/* @var $import_helper kCSVHelper */
	$import_helper->PrefixSpecial = $this->Application->GetVar('PrefixSpecial');
	$import_helper->grid = $this->Application->GetVar('grid');
	$result = $import_helper->ImportStart( $object->GetField('ImportFile', 'file_paths') );
	if($result === true) {
	$event->redirect = $this->Application->GetVar('next_template');
	$event->SetRedirectParam('PrefixSpecial', $this->Application->GetVar('PrefixSpecial'));
	$event->SetRedirectParam('grid', $this->Application->GetVar('grid'));
	}
	}

	if($event->redirect === false) {
	$object->SetError('ImportFile', $result);
	$event->status = erFAIL;
	}
	}

	/**
	* Enter description here...
	*
	* @param kEvent $event
	*/
	function OnCSVImportStep(&$event)
	{
	$import_helper =& $this->Application->recallObject('CSVHelper');
	/* @var $export_helper kCSVHelper */

	$prefix_special = $import_helper->ImportData('prefix');
	$prefix_elems = split('\.\|_', $prefix_special, 2);
	$perm_sections = $this->Application->getUnitOption($prefix_elems[0], 'PermSection');
	if(!$this->Application->CheckPermission($perm_sections['main'].'.add') && !$this->Application->CheckPermission($perm_sections['main'].'.edit')) {
	$this->Application->Redirect('no_permission');
	}

	$import_helper->ImportStep();
	$event->status = erSTOP;
	}

	/**
	* Shows unit config filename, where requested prefix is defined
	*
	* @param kEvent $event
	*/
	function OnCheckPrefixConfig(&$event)
	{
	$prefix = $this->Application->GetVar('config_prefix');
	$config_file = $this->Application->UnitConfigReader->prefixFiles[$prefix];

	ob_start();
	?>
	<html>
	<head>
	<title>Unit Config of "<?php echo $prefix; ?>" prefix</title>
	</head>
	<body bgcolor="#E7E7E7">
	<a href="javascript:window.close();">Close Window</a><br /><br />
	<strong>Prefix:</strong> <?php echo $prefix; ?><br />
	<strong>Unit Config:</strong> <?php echo $GLOBALS['debugger']->highlightString($config_file); ?><br />
	<br /><a href="javascript:window.close();">Close Window</a><br />
	</body>
	</html>
	<?php
	echo ob_get_clean();

	$event->status = erSTOP;
	}

	function OnUploadFile(&$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');

	$admin_ses =& $this->Application->recallObject('Session.admin');
	/* @var $admin_ses Session */
	$user = $admin_ses->RecallVar('user_id');
	$perm_helper =& $this->Application->recallObject('PermissionsHelper');
	/* @var $perm_helper kPermissionsHelper */

	/*if() {
	$prefix_special = $this->Application->GetVar('PrefixSpecial');
	$prefix_elems = split('\.\|_', $prefix_special, 2);
	$perm_sections = $this->Application->getUnitOption($prefix_elems[0], 'PermSection');
	$section = $perm_sections['main'];
	}
	else {*/
	$section = $event->getSection();
	/}/

	if ($this->Application->GetVar('t') != 'import/import_start' && !$perm_helper->CheckUserPermission($user, $section.'.add') && !$perm_helper->CheckUserPermission($user, $section.'.edit')) {
	$event->status = erPERM_FAIL;
	header('HTTP/1.0 403 You don\'t have permissions to upload');
	exit;
	return;
	}

	if (!$cookie_name) $cookie_name = 'sid';

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

	if (!is_writable($tmp_path)) {
	header('HTTP/1.0 500 Write permissions not set on the server');
	exit;
	}

	move_uploaded_file($value['tmp_name'], $tmp_path.$fname);
	exit;
	}

	function OnDropTempTablesByWID(&$event)
	{
	$sid = $this->Application->GetSID();
	$wid = $this->Application->GetVar('m_wid');
	$tables = $this->Conn->GetCol('SHOW TABLES');
	$mask_edit_table = '/'.TABLE_PREFIX.'ses_'.$sid.'_'.$wid.'_edit_(.*)$/';
	foreach($tables as $table)
	{
	if( preg_match($mask_edit_table,$table,$rets) )
	{
	$this->Conn->Query('DROP TABLE IF EXISTS '.$table);
	}
	}
	echo 'OK';
	$event->status = erSTOP;
	return ;
	}
	}
	\ No newline at end of file

	Property changes on: branches/RC/core/units/admin/admin_events_handler.php
	___________________________________________________________________
	Modified: cvs2svn:cvs-rev
	## -1 +1 ##
	-1.8.2.13
	\ No newline at end of property
	+1.8.2.14
	\ No newline at end of property
	Index: branches/RC/core/units/general/helpers/sections_helper.php
	===================================================================
	--- branches/RC/core/units/general/helpers/sections_helper.php (revision 10579)
	+++ branches/RC/core/units/general/helpers/sections_helper.php (revision 10580)
	@@ -1,216 +1,223 @@
	<?php

	/**
	* Porcesses sections information from configs
	*
	*/
	class kSectionsHelper extends kHelper {

	/**
	* Holds information about all sections
	*
	* @var Array
	*/
	var $Tree = Array();

	/**
	* Set's prefix and special
	*
	* @param string $prefix
	* @param string $special
	* @access public
	*/
	function Init($prefix, $special, $event_params = null)
	{
	parent::Init($prefix, $special, $event_params);
	$this->BuildTree();
	}

	/**
	* Builds xml for tree in left frame in admin
	*
	* @param Array $params
	*/
	function BuildTree()
	{
	- $data = $this->Conn->GetRow('SELECT Data, Cached FROM '.TABLE_PREFIX.'Cache WHERE VarName = "sections_parsed"');
	+ if (!isset($this->Application->Memcached) \|\| !($data = $this->Application->Memcached->get('master:sections_parsed'))) {
	+ $data = $this->Conn->GetOne('SELECT Data FROM '.TABLE_PREFIX.'Cache WHERE VarName = "sections_parsed"');
	+ }
	if ($data) {
	- $this->Tree = unserialize($data['Data']);
	+ $this->Tree = unserialize($data);
	return ;
	}

	$this->Application->UnitConfigReader->ReReadConfigs();

	$this->Tree = Array();

	// 1. build base tree (don't update parent with children list yet)
	$prefixes = array_keys($this->Application->UnitConfigReader->configData);
	foreach ($prefixes as $prefix) {
	$config =& $this->Application->UnitConfigReader->configData[$prefix];
	$sections = getArrayValue($config, 'Sections');
	if (!$sections) continue;

	// echo 'Prefix: ['.$prefix.'] has ['.count($sections).'] sections<br />';

	foreach ($sections as $section_name => $section_params) {
	// we could also skip not allowed sections here in future
	if ( isset($section_params['SectionPrefix']) ) {
	$section_prefix = $section_params['SectionPrefix'];
	}
	elseif ( $this->Application->getUnitOption($prefix, 'SectionPrefix') ) {
	$section_prefix = $this->Application->getUnitOption($prefix, 'SectionPrefix');
	}
	else {
	$section_prefix = $prefix;
	}
	$section_params['SectionPrefix'] = $section_prefix;
	$section_params['url']['m_opener'] = 'r';
	$section_params['url']['no_pass_through'] = 1;
	$pass_section = getArrayValue($section_params, 'url', 'pass_section');

	if ($pass_section) {
	unset($section_params['url']['pass_section']);
	$section_params['url']['section'] = $section_name;
	if (!isset($section_params['url']['module'])) {
	$module_name = $this->Application->findModule('Path', $config['ModuleFolder'].'/', 'Name');
	$section_params['url']['module'] = $module_name;
	}
	}

	if (!isset($section_params['url']['t'])) {
	$section_params['url']['t'] = 'index';
	}

	if (!isset($section_params['onclick'])) {
	$section_params['onclick'] = 'checkEditMode()';
	}

	if (!isset($section_params['container'])) {
	$section_params['container'] = 0; // for js tree printing to xml
	}

	$current_data = isset($this->Tree[$section_name]) ? $this->Tree[$section_name] : Array();
	$this->Tree[$section_name] = array_merge_recursive2($current_data, $section_params);
	}
	}

	// 2. apply section ajustments
	foreach ($prefixes as $prefix) {
	$config =& $this->Application->UnitConfigReader->configData[$prefix];
	$section_ajustments = getArrayValue($config, 'SectionAdjustments');
	if (!$section_ajustments) continue;

	foreach ($section_ajustments as $section_name => $ajustment_params) {
	if (is_array($ajustment_params)) {
	$this->Tree[$section_name] = array_merge_recursive2($this->Tree[$section_name], $ajustment_params);
	}
	else {
	// then remove section
	unset($this->Tree[$section_name]);
	}
	}
	}

	// 3.
	foreach ($this->Tree as $section_name => $section_params) {
	// 3.1. update parent -> children references
	$this->Tree[ $section_params['parent'] ]['children'][ "{$section_params['priority']}" ] = $section_name;

	if ($section_params['type'] == stTAB) {
	// if this is tab, then mark parent section as TabOnly
	$this->Tree[ $section_params['parent'] ]['tabs_only'] = true;
	}

	// 3.2. process icons here, because they also can be ajusted
	if (isset($section_params['icon']) && preg_match('/([^:]+):(.*)/', $section_params['icon'], $regs)) {
	$this->Tree[$section_name]['icon'] = $regs[2];
	$this->Tree[$section_name]['icon_module'] = $regs[1];
	$module_folder = trim( $this->Application->findModule('Name', $regs[1], 'Path'), '/');
	if ($module_folder == '') $module_folder = 'core';
	}
	else {
	$module_folder = $this->Application->getUnitOption($section_params['SectionPrefix'], 'ModuleFolder');
	}

	// this is to display HELP icon instead of missing one.. can be replaced with some other icon to draw attention
	$icon_file = $module_folder.'/admin_templates/img/icons/icon24_'.$this->Tree[$section_name]['icon'];
	if (!file_exists(FULL_PATH.'/'.$icon_file.'.gif')) {
	$this->Tree[$section_name]['icon'] = 'help';
	$this->Tree[$section_name]['icon_module'] = 'core';
	}
	}
	$this->Application->HandleEvent( new kEvent('adm:OnAfterBuildTree') );

	+ if (isset($this->Application->Memcached)) {
	+ $this->Application->Memcached->set('master:sections_parsed',serialize($this->Tree), 0, 0);
	+ return;
	+ }
	+
	$this->Conn->Query('REPLACE '.TABLE_PREFIX.'Cache (VarName, Data, Cached) VALUES ("sections_parsed", '.$this->Conn->qstr(serialize($this->Tree)).', '.adodb_mktime().')');
	}

	/**
	* Returns details information about section
	*
	* @param string $section_name
	* @return Array
	*/
	function &getSectionData($section_name)
	{
	if (isset($this->Tree[$section_name])) {
	$ret =& $this->Tree[$section_name];
	}
	else {
	$ret = Array();
	}
	return $ret;
	}

	/**
	* Returns first child, that is not a folder
	*
	* @param string $section_name
	* @param Array $tree
	* @return stirng
	*/
	function getFirstChild($section_name, $check_permission = false)
	{
	$section_data =& $this->getSectionData($section_name);

	$children = isset($section_data['children']) && $section_data['children'] ? $section_data['children'] : false;
	if ($children) {
	// get 1st child
	ksort($children, SORT_NUMERIC);
	foreach ($children as $child_priority => $child_section) {
	$section_data =& $this->getSectionData($child_section);

	$perm_section = $this->getPermSection($child_section);
	$perm_status = $check_permission ? $this->Application->CheckPermission($perm_section.'.view') : true;
	if ((isset($section_data['show_mode']) && $section_data['show_mode']) \|\| !$perm_status) {
	continue;
	}

	break;
	}

	return $this->getFirstChild($child_section, $check_permission);
	}

	return $section_name;
	}

	/**
	* Returns section for permission checking based on given section
	*
	* @param string $section_name
	* @return string
	*/
	function getPermSection($section_name)
	{
	$ret = $section_name;
	$section_data =& $this->getSectionData($section_name);

	if ($section_data && isset($section_data['perm_prefix'])) {
	// this section uses other section permissions
	$ret = $this->Application->getUnitOption($section_data['perm_prefix'].'.main', 'PermSection');
	}
	return $ret;
	}
	}

	?>
	\ No newline at end of file

	Property changes on: branches/RC/core/units/general/helpers/sections_helper.php
	___________________________________________________________________
	Modified: cvs2svn:cvs-rev
	## -1 +1 ##
	-1.12.2.3
	\ No newline at end of property
	+1.12.2.4
	\ No newline at end of property
	Index: branches/RC/core/units/general/inp_ses_storage.php
	===================================================================
	--- branches/RC/core/units/general/inp_ses_storage.php (revision 10579)
	+++ branches/RC/core/units/general/inp_ses_storage.php (revision 10580)
	@@ -1,134 +1,134 @@
	<?php

	class InpSession extends Session
	{
	function Init($prefix,$special)
	{
	$this->SessionTimeout = $this->Application->ConfigValue('SessionTimeout');

	$path = (BASE_PATH == '') ? '/' : BASE_PATH;
	// if ( $this->Application->IsAdmin() ) $path = rtrim($path, '/').'/admin';
	$this->SetCookiePath($path);

	$cookie_name = $this->Application->ConfigValue('SessionCookieName');
	if (!$cookie_name) $cookie_name = 'sid';
	if (($this->Application->IsAdmin() && $special !== 'front') \|\| $special == 'admin' ) { // \|\| $this->Application->GetVar('admin') == 1
	$cookie_name = 'adm_'.$cookie_name;
	}
	$this->SetCookieName($cookie_name);

	$this->SetCookieDomain(SERVER_NAME);

	if( $this->Application->IsAdmin()) { // && $this->Application->GetVar('admin') != 1
	$mode = smAUTO;
	}
	elseif (constOn('IS_INSTALL')) {
	$mode = smCOOKIES_ONLY;
	}
	else {
	$ses_mode = $this->Application->ConfigValue('CookieSessions');
	if ($ses_mode == 2) $mode = smAUTO;
	if ($ses_mode == 1) $mode = smCOOKIES_ONLY;
	if ($ses_mode == 0) $mode = smGET_ONLY;
	}
	$this->SetMode($mode);

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

	if( !$this->Application->IsAdmin() && $this->GetField('PortalUserId') <= 0 )
	{
	$group_list = $this->Application->ConfigValue('User_GuestGroup').','.$this->Application->ConfigValue('User_LoggedInGroup');
	$this->SetField('GroupId', $this->Application->ConfigValue('User_GuestGroup'));
	$this->SetField('GroupList', $group_list);
	}
	}

	function Destroy()
	{
	$this->Storage->DeleteSession($this);
	$this->Storage->DeleteEditTables();
	- $this->Data =& new Params();
	+ $this->Data = new Params();
	$this->SID = '';
	if ($this->CookiesEnabled) $this->SetSessionCookie(); //will remove the cookie due to value (sid) is empty
	$this->SetSession(); //will create a new session
	}

	}

	class InpSessionStorage extends SessionStorage {

	function Init($prefix,$special)
	{
	parent::Init($prefix,$special);
	$this->setTableName(TABLE_PREFIX.'UserSession');
	$this->SessionDataTable = TABLE_PREFIX.'SessionData';
	$this->setIDField('SessionKey');
	$this->TimestampField = 'LastAccessed';
	$this->DataValueField = 'VariableValue';
	$this->DataVarField = 'VariableName';
	}

	function LocateSession($sid)
	{
	$res = parent::LocateSession($sid);
	if ($res) {
	$this->Expiration += $this->SessionTimeout;
	}
	return $res;
	}

	function UpdateSession(&$session)
	{
	$time = adodb_mktime();
	// Update LastAccessed only if it's newer than 1/10 of session timeout - perfomance optimization to eliminate needless updates on every click
	// if ($time - $this->DirectVars['LastAccessed'] > $this->SessionTimeout/10) {
	$this->SetField($session, $this->TimestampField, $time + $this->SessionTimeout);
	// }
	}


	function StoreSession(&$session, $additional_fields = Array())
	{
	$fields_hash = Array( 'PortalUserId' => $this->Application->IsAdmin() ? 0 : -2, // Guest
	'Language' => $this->Application->GetDefaultLanguageId(),
	'Theme' => $this->Application->GetDefaultThemeId(),
	'IpAddress' => $_SERVER['REMOTE_ADDR'],
	'GroupId' => $this->Application->ConfigValue('User_GuestGroup'),
	'GroupList' => $this->Application->ConfigValue('User_GuestGroup'),
	'CurrentTempKey'=> $session->SID,
	);

	parent::StoreSession($session, $fields_hash);
	}

	function GetExpiredSIDs()
	{
	$query = ' SELECT '.$this->IDField.' FROM '.$this->TableName.' WHERE '.$this->TimestampField.' < '.(adodb_mktime());
	$ret = $this->Conn->GetCol($query);
	if($ret) {
	$this->DeleteEditTables();
	}
	return $ret;

	}

	function DeleteEditTables()
	{
	$tables = $this->Conn->GetCol('SHOW TABLES');
	$mask_edit_table = '/'.TABLE_PREFIX.'ses_(.)_edit_(.)/';
	$mask_search_table = '/'.TABLE_PREFIX.'ses_(.?)_(.)/';

	$sql='SELECT COUNT(*) FROM '.$this->TableName.' WHERE '.$this->IDField.' = \'%s\'';
	foreach($tables as $table)
	{
	if( preg_match($mask_edit_table,$table,$rets) \|\| preg_match($mask_search_table,$table,$rets) )
	{
	$sid = preg_replace('/(.)_(.)/', '\\1', $rets[1]); // remove popup's wid from sid
	$is_alive = $this->Conn->GetOne( sprintf($sql,$sid) );
	if(!$is_alive) $this->Conn->Query('DROP TABLE IF EXISTS '.$table);
	}
	}
	}
	}

	?>
	\ No newline at end of file

	Property changes on: branches/RC/core/units/general/inp_ses_storage.php
	___________________________________________________________________
	Modified: cvs2svn:cvs-rev
	## -1 +1 ##
	-1.23.2.2
	\ No newline at end of property
	+1.23.2.3
	\ No newline at end of property

in-portalNo OneTemporaryActions

File Metadata

in-portalView Options

Event Timeline

in-portal
No OneTemporary
Actions

in-portal
View Options