in-portal
No OneTemporary
Actions

Subscribers

None

File Metadata

Created: Thu, Feb 6, 6:49 PM

in-portal
View Options

	Index: branches/RC/core/kernel/session/session.php
	===================================================================
	--- branches/RC/core/kernel/session/session.php (revision 9642)
	+++ branches/RC/core/kernel/session/session.php (revision 9643)
	@@ -1,970 +1,970 @@
	<?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 = 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) {
	$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 = KERNEL_PATH.'/../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 ();
	}
	}

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

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

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

	$sql = 'SELECT VariableValue
	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');
	}
	}

	function RecallPersistentVar(&$session, $var_name, $default = false)
	{
	if (isset($this->PersistentVars[$var_name])) {
	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);
	if ($value !== false) {
	$this->PersistentVars[$var_name] = $value;
	$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 = $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();
	+ $this->Data = new Params();

	$tmp_sid = $this->GetPassedSIDValue();

	$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
	*
	* @return int
	*/
	function GetSessionCookie()
	{
	return isset($this->Application->HttpQuery->Cookie[$this->CookieName]) ? $this->Application->HttpQuery->Cookie[$this->CookieName] : false;
	}

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

	/**
	* Refreshes session expiration time
	*
	* @access private
	*/
	function Refresh()
	{
	if ($this->CookiesEnabled) $this->SetSessionCookie(); //we need to refresh the cookie
	$this->Storage->UpdateSession($this);
	}

	function Destroy()
	{
	$this->Storage->DeleteSession($this);
	- $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
	}

	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']).'\|'.substr($last_env, 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']).'\|'.substr($last_env, 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', substr($last_env, 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.3
	\ No newline at end of property
	+1.59.2.4
	\ No newline at end of property
	Index: branches/RC/core/kernel/utility/temp_handler.php
	===================================================================
	--- branches/RC/core/kernel/utility/temp_handler.php (revision 9642)
	+++ branches/RC/core/kernel/utility/temp_handler.php (revision 9643)
	@@ -1,787 +1,790 @@
	<?php

	class kTempTablesHandler extends kBase {
	var $Tables = Array();

	/**
	* Master table name for temp handler
	*
	* @var string
	* @access private
	*/
	var $MasterTable = '';

	/**
	* IDs from master table
	*
	* @var Array
	* @access private
	*/
	var $MasterIDs = Array();

	var $AlreadyProcessed = Array();

	var $DroppedTables = Array();

	var $FinalRefs = Array();

	var $CopiedTables = Array();


	/**
	* IDs of newly cloned items (key - prefix.special, value - array of ids)
	*
	* @var Array
	*/
	var $savedIDs = Array();

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


	/**
	* Window ID of current window
	*
	* @var mixed
	*/
	var $WindowID = '';

	function kTempTablesHandler()
	{
	parent::kBase();
	$this->Conn =& $this->Application->GetADODBConnection();
	}

	function SetTables($tables)
	{
	// set tablename as key for tables array
	$ret = Array();
	$this->Tables = $tables;
	$this->MasterTable = $tables['TableName'];
	}

	function saveID($prefix, $special = '', $id = null)
	{
	if (!isset($this->savedIDs[$prefix.($special ? '.' : '').$special])) {
	$this->savedIDs[$prefix.($special ? '.' : '').$special] = array();
	}
	if (is_array($id)) {
	foreach ($id as $tmp_id => $live_id) {
	$this->savedIDs[$prefix.($special ? '.' : '').$special][$tmp_id] = $live_id;
	}
	}
	else {
	- $this->savedIDs[$prefix.($special ? '.' : '').$special][] = $id;
	- }
	+ $this->savedIDs[$prefix.($special ? '.' : '').$special][] = $id;
	+ }
	}

	/**
	* Get temp table name
	*
	* @param string $table
	* @return string
	*/
	function GetTempName($table)
	{
	return $this->Application->GetTempName($table, $this->WindowID);
	}

	function GetTempTablePrefix()
	{
	return $this->Application->GetTempTablePrefix($this->WindowID);
	}

	/**
	* Return live table name based on temp table name
	*
	* @param string $temp_table
	* @return string
	*/
	function GetLiveName($temp_table)
	{
	return $this->Application->GetLiveName($temp_table);
	}

	function IsTempTable($table)
	{
	return $this->Application->IsTempTable($table);
	}

	/**
	* Return temporary table name for master table
	*
	* @return string
	* @access public
	*/
	function GetMasterTempName()
	{
	return $this->GetTempName($this->MasterTable);
	}

	function CreateTempTable($table)
	{
	$query = sprintf("CREATE TABLE %s SELECT * FROM %s WHERE 0",
	$this->GetTempName($table),
	$table);

	$this->Conn->Query($query);
	}

	function BuildTables($prefix, $ids)
	{
	$this->WindowID = $this->Application->GetVar('m_wid');

	$this->TableIdCounter = 0;
	$tables = Array(
	'TableName' => $this->Application->getUnitOption($prefix, 'TableName'),
	'IdField' => $this->Application->getUnitOption($prefix, 'IDField'),
	'IDs' => $ids,
	'Prefix' => $prefix,
	'TableId' => $this->TableIdCounter++,
	);

	/*$parent_prefix = $this->Application->getUnitOption($prefix, 'ParentPrefix');
	if ($parent_prefix) {
	$tables['ForeignKey'] = $this->Application->getUnitOption($prefix, 'ForeignKey');
	$tables['ParentPrefix'] = $parent_prefix;
	$tables['ParentTableKey'] = $this->Application->getUnitOption($prefix, 'ParentTableKey');
	}*/

	$this->FinalRefs[ $tables['TableName'] ] = $tables['TableId']; // don't forget to add main table to FinalRefs too

	$SubItems = $this->Application->getUnitOption($prefix,'SubItems');
	if (is_array($SubItems)) {
	foreach ($SubItems as $prefix) {
	$this->AddTables($prefix, $tables);
	}
	}
	$this->SetTables($tables);
	}

	/**
	* Searches through TempHandler tables info for required prefix
	*
	* @param string $prefix
	* @param Array $master
	* @return mixed
	*/
	function SearchTable($prefix, $master = null)
	{
	if (is_null($master)) {
	$master = $this->Tables;
	}

	if ($master['Prefix'] == $prefix) {
	return $master;
	}

	if (isset($master['SubTables'])) {
	foreach ($master['SubTables'] as $sub_table) {
	$found = $this->SearchTable($prefix, $sub_table);
	if ($found !== false) {
	return $found;
	}
	}
	}

	return false;
	}

	function AddTables($prefix, &$tables)
	{
	if (!$this->Application->prefixRegistred($prefix)) {
	// allows to skip subitem processing if subitem module not enabled/installed
	return ;
	}

	$tmp = Array(
	'TableName' => $this->Application->getUnitOption($prefix,'TableName'),
	'IdField' => $this->Application->getUnitOption($prefix,'IDField'),
	'ForeignKey' => $this->Application->getUnitOption($prefix,'ForeignKey'),
	'ParentPrefix' => $this->Application->getUnitOption($prefix, 'ParentPrefix'),
	'ParentTableKey' => $this->Application->getUnitOption($prefix,'ParentTableKey'),
	'Prefix' => $prefix,
	'AutoClone' => $this->Application->getUnitOption($prefix,'AutoClone'),
	'AutoDelete' => $this->Application->getUnitOption($prefix,'AutoDelete'),
	'TableId' => $this->TableIdCounter++,
	);

	$this->FinalRefs[ $tmp['TableName'] ] = $tmp['TableId'];

	$constrain = $this->Application->getUnitOption($prefix,'Constrain');
	if ($constrain)
	{
	$tmp['Constrain'] = $constrain;
	$this->FinalRefs[ $tmp['TableName'].$tmp['Constrain'] ] = $tmp['TableId'];
	}

	$SubItems = $this->Application->getUnitOption($prefix,'SubItems');
	$same_sub_counter = 1;
	if( is_array($SubItems) )
	{
	foreach($SubItems as $prefix)
	{
	$this->AddTables($prefix, $tmp);
	}
	}

	if ( !is_array(getArrayValue($tables, 'SubTables')) ) {
	$tables['SubTables'] = array();
	}

	$tables['SubTables'][] = $tmp;
	}

	function CloneItems($prefix, $special, $ids, $master = null, $foreign_key = null, $parent_prefix = null, $skip_filenames = false)
	{
	if (!isset($master)) $master = $this->Tables;

	// recalling by different name, because we may get kDBList, if we recall just by prefix
	if (!preg_match('/(.*)-item$/', $special)) {
	$special .= '-item';
	}
	-
	+
	$object =& $this->Application->recallObject($prefix.'.'.$special, $prefix, Array('skip_autoload' => true));
	$object->PopulateMultiLangFields();

	foreach ($ids as $id) {
	$mode = 'create';
	if ( $cloned_ids = getArrayValue($this->AlreadyProcessed, $master['TableName']) ) {
	// if we have already cloned the id, replace it with cloned id and set mode to update
	// update mode is needed to update second ForeignKey for items cloned by first ForeignKey
	if ( getArrayValue($cloned_ids, $id) ) {
	$id = $cloned_ids[$id];
	$mode = 'update';
	}
	}

	$object->Load($id);
	$original_values = $object->FieldValues;

	if (!$skip_filenames) {
	$object->NameCopy($master, $foreign_key);
	}
	elseif ($master['TableName'] == $this->MasterTable) {
	// kCatDBItem class only has this attribute
	$object->useFilenames = false;
	}

	if (isset($foreign_key)) {
	$master_foreign_key_field = is_array($master['ForeignKey']) ? $master['ForeignKey'][$parent_prefix] : $master['ForeignKey'];
	$object->SetDBField($master_foreign_key_field, $foreign_key);
	}

	if ($mode == 'create') {
	$this->RaiseEvent('OnBeforeClone', $master['Prefix'], $special, Array($object->GetId()), $foreign_key);
	}

	$res = $mode == 'update' ? $object->Update() : $object->Create();

	if ($res)
	{
	if ( $mode == 'create' && is_array( getArrayValue($master, 'ForeignKey')) ) {
	// remember original => clone mapping for dual ForeignKey updating
	$this->AlreadyProcessed[$master['TableName']][$id] = $object->GetId();
	}
	if ($object->mode == 't') {
	$object->setTempID();
	}
	if ($mode == 'create') {
	$this->RaiseEvent('OnAfterClone', $master['Prefix'], $special, Array($object->GetId()), $foreign_key, array('original_id' => $id) );
	$this->saveID($master['Prefix'], $special, $object->GetID());
	}

	if ( is_array(getArrayValue($master, 'SubTables')) ) {
	foreach($master['SubTables'] as $sub_table) {
	if (!getArrayValue($sub_table, 'AutoClone')) continue;
	$sub_TableName = ($object->mode == 't') ? $this->GetTempName($sub_table['TableName']) : $sub_table['TableName'];

	$foreign_key_field = is_array($sub_table['ForeignKey']) ? $sub_table['ForeignKey'][$master['Prefix']] : $sub_table['ForeignKey'];
	$parent_key_field = is_array($sub_table['ParentTableKey']) ? $sub_table['ParentTableKey'][$master['Prefix']] : $sub_table['ParentTableKey'];

	$query = 'SELECT '.$sub_table['IdField'].' FROM '.$sub_TableName.'
	WHERE '.$foreign_key_field.' = '.$original_values[$parent_key_field];
	if (isset($sub_table['Constrain'])) $query .= ' AND '.$sub_table['Constrain'];

	$sub_ids = $this->Conn->GetCol($query);

	if ( is_array(getArrayValue($sub_table, 'ForeignKey')) ) {
	// $sub_ids could containt newly cloned items, we need to remove it here
	// to escape double cloning

	$cloned_ids = getArrayValue($this->AlreadyProcessed, $sub_table['TableName']);
	if ( !$cloned_ids ) $cloned_ids = Array();
	$new_ids = array_values($cloned_ids);
	$sub_ids = array_diff($sub_ids, $new_ids);
	}

	$parent_key = $object->GetDBField($parent_key_field);

	$this->CloneItems($sub_table['Prefix'], $special, $sub_ids, $sub_table, $parent_key, $master['Prefix']);
	}
	}
	}
	}

	if (!$ids) {
	$this->savedIDs[$prefix.($special ? '.' : '').$special] = Array();
	}

	return $this->savedIDs[$prefix.($special ? '.' : '').$special];
	}

	function DeleteItems($prefix, $special, $ids, $master=null, $foreign_key=null)
	{
	if (!isset($master)) $master = $this->Tables;
	if( strpos($prefix,'.') !== false ) list($prefix,$special) = explode('.', $prefix, 2);

	$prefix_special = rtrim($prefix.'.'.$special, '.');

	//recalling by different name, because we may get kDBList, if we recall just by prefix
	$recall_prefix = $prefix_special.($special ? '' : '.').'-item';
	$object =& $this->Application->recallObject($recall_prefix, $prefix, Array('skip_autoload' => true));

	foreach ($ids as $id)
	{
	$object->Load($id);
	$original_values = $object->FieldValues;
	if( !$object->Delete($id) ) continue;

	if ( is_array(getArrayValue($master, 'SubTables')) ) {
	foreach($master['SubTables'] as $sub_table) {
	if (!getArrayValue($sub_table, 'AutoDelete')) continue;
	$sub_TableName = ($object->mode == 't') ? $this->GetTempName($sub_table['TableName']) : $sub_table['TableName'];

	$foreign_key_field = is_array($sub_table['ForeignKey']) ? getArrayValue($sub_table, 'ForeignKey', $master['Prefix']) : $sub_table['ForeignKey'];
	$parent_key_field = is_array($sub_table['ParentTableKey']) ? getArrayValue($sub_table, 'ParentTableKey', $master['Prefix']) : $sub_table['ParentTableKey'];

	if (!$foreign_key_field \|\| !$parent_key_field) continue;

	$query = 'SELECT '.$sub_table['IdField'].' FROM '.$sub_TableName.'
	WHERE '.$foreign_key_field.' = '.$original_values[$parent_key_field];

	$sub_ids = $this->Conn->GetCol($query);

	$parent_key = $object->GetDBField(is_array($sub_table['ParentTableKey']) ? $sub_table['ParentTableKey'][$prefix] : $sub_table['ParentTableKey']);

	$this->DeleteItems($sub_table['Prefix'], '', $sub_ids, $sub_table, $parent_key);
	}
	}

	}
	}

	function DoCopyLiveToTemp($master, $ids, $parent_prefix=null)
	{
	// when two tables refers the same table as sub-sub-table, and ForeignKey and ParentTableKey are arrays
	// the table will be first copied by first sub-table, then dropped and copied over by last ForeignKey in the array
	// this should not do any problems :)
	if ( !preg_match("/.*\.[0-9]+/", $master['Prefix']) ) {
	if( $this->DropTempTable($master['TableName']) )
	{
	$this->CreateTempTable($master['TableName']);
	}
	}

	if (is_array($ids)) {
	$ids = join(',', $ids);
	}

	$table_sig = $master['TableName'].(isset($master['Constrain']) ? $master['Constrain'] : '');

	if ($ids != '' && !in_array($table_sig, $this->CopiedTables)) {
	if ( getArrayValue($master, 'ForeignKey') ) {
	if ( is_array($master['ForeignKey']) ) {
	$key_field = $master['ForeignKey'][$parent_prefix];
	}
	else {
	$key_field = $master['ForeignKey'];
	}
	}
	else {
	$key_field = $master['IdField'];
	}

	$query = 'INSERT INTO '.$this->GetTempName($master['TableName']).'
	SELECT * FROM '.$master['TableName'].'
	WHERE '.$key_field.' IN ('.$ids.')';
	if (isset($master['Constrain'])) $query .= ' AND '.$master['Constrain'];
	$this->Conn->Query($query);

	$this->CopiedTables[] = $table_sig;

	$query = 'SELECT '.$master['IdField'].' FROM '.$master['TableName'].'
	WHERE '.$key_field.' IN ('.$ids.')';
	if (isset($master['Constrain'])) $query .= ' AND '.$master['Constrain'];
	$this->RaiseEvent( 'OnAfterCopyToTemp', $master['Prefix'], '', $this->Conn->GetCol($query) );
	}

	if ( getArrayValue($master, 'SubTables') ) {
	foreach ($master['SubTables'] as $sub_table) {

	$parent_key = is_array($sub_table['ParentTableKey']) ? $sub_table['ParentTableKey'][$master['Prefix']] : $sub_table['ParentTableKey'];
	if (!$parent_key) continue;

	if ( $ids != '' && $parent_key != $key_field ) {
	$query = 'SELECT '.$parent_key.' FROM '.$master['TableName'].'
	WHERE '.$key_field.' IN ('.$ids.')';
	$sub_foreign_keys = join(',', $this->Conn->GetCol($query));
	}
	else {
	$sub_foreign_keys = $ids;
	}
	$this->DoCopyLiveToTemp($sub_table, $sub_foreign_keys, $master['Prefix']);
	}
	}
	}

	function GetForeignKeys($master, $sub_table, $live_id, $temp_id=null)
	{
	$mode = 1; //multi
	if (!is_array($live_id)) {
	$live_id = Array($live_id);
	$mode = 2; //single
	}
	if (isset($temp_id) && !is_array($temp_id)) $temp_id = Array($temp_id);

	if ( isset($sub_table['ParentTableKey']) ) {
	if ( is_array($sub_table['ParentTableKey']) ) {
	$parent_key_field = $sub_table['ParentTableKey'][$master['Prefix']];
	}
	else {
	$parent_key_field = $sub_table['ParentTableKey'];
	}
	}
	else {
	$parent_key_field = $master['IdField'];
	}

	if ( $cached = getArrayValue($this->FKeysCache, $master['TableName'].'.'.$parent_key_field) ) {
	if ( array_key_exists(serialize($live_id), $cached) ) {
	list($live_foreign_key, $temp_foreign_key) = $cached[serialize($live_id)];
	if ($mode == 1) {
	return $live_foreign_key;
	}
	else {
	return Array($live_foreign_key[0], $temp_foreign_key[0]);
	}
	}
	}

	if ($parent_key_field != $master['IdField']) {
	$query = 'SELECT '.$parent_key_field.' FROM '.$master['TableName'].'
	WHERE '.$master['IdField'].' IN ('.join(',', $live_id).')';
	$live_foreign_key = $this->Conn->GetCol($query);

	if (isset($temp_id)) {
	// because DoCopyTempToOriginal resets negative IDs to 0 in temp table (one by one) before copying to live
	$temp_key = $temp_id < 0 ? 0 : $temp_id;
	$query = 'SELECT '.$parent_key_field.' FROM '.$this->GetTempName($master['TableName']).'
	WHERE '.$master['IdField'].' IN ('.join(',', $temp_key).')';
	$temp_foreign_key = $this->Conn->GetCol($query);
	}
	else {
	$temp_foreign_key = Array();
	}
	}
	else {
	$live_foreign_key = $live_id;
	$temp_foreign_key = $temp_id;
	}

	$this->FKeysCache[$master['TableName'].'.'.$parent_key_field][serialize($live_id)] = Array($live_foreign_key, $temp_foreign_key);

	if ($mode == 1) {
	return $live_foreign_key;
	}
	else {
	return Array($live_foreign_key[0], $temp_foreign_key[0]);
	}
	}

	function DoCopyTempToOriginal($master, $parent_prefix = null, $current_ids = Array())
	{
	if (!$current_ids) {
	$query = 'SELECT '.$master['IdField'].' FROM '.$this->GetTempName($master['TableName']);
	if (isset($master['Constrain'])) $query .= ' WHERE '.$master['Constrain'];
	$current_ids = $this->Conn->GetCol($query);
	}

	$table_sig = $master['TableName'].(isset($master['Constrain']) ? $master['Constrain'] : '');

	if ($current_ids) {
	// delete all ids from live table - for MasterTable ONLY!
	// because items from Sub Tables get deteleted in CopySubTablesToLive !BY ForeignKey!
	if ($master['TableName'] == $this->MasterTable) {
	$this->RaiseEvent( 'OnBeforeDeleteFromLive', $master['Prefix'], '', $current_ids );

	$query = 'DELETE FROM '.$master['TableName'].' WHERE '.$master['IdField'].' IN ('.join(',', $current_ids).')';
	$this->Conn->Query($query);
	}

	if ( getArrayValue($master, 'SubTables') ) {
	if( in_array($table_sig, $this->CopiedTables) \|\| $this->FinalRefs[$table_sig] != $master['TableId'] ) return;

	foreach($current_ids AS $id)
	{
	$this->RaiseEvent( 'OnBeforeCopyToLive', $master['Prefix'], '', Array($id) );

	//reset negative ids to 0, so autoincrement in live table works fine
	if($id < 0)
	{
	$query = 'UPDATE '.$this->GetTempName($master['TableName']).'
	SET '.$master['IdField'].' = 0
	WHERE '.$master['IdField'].' = '.$id;
	if (isset($master['Constrain'])) $query .= ' AND '.$master['Constrain'];
	$this->Conn->Query($query);
	$id_to_copy = 0;
	}
	else
	{
	$id_to_copy = $id;
	}

	//copy current id_to_copy (0 for new or real id) to live table
	$query = 'INSERT INTO '.$master['TableName'].'
	SELECT * FROM '.$this->GetTempName($master['TableName']).'
	WHERE '.$master['IdField'].' = '.$id_to_copy;
	$this->Conn->Query($query);
	$insert_id = $id_to_copy == 0 ? $this->Conn->getInsertID() : $id_to_copy;

	$this->saveID($master['Prefix'], '', array($id => $insert_id));
	$this->RaiseEvent( 'OnAfterCopyToLive', $master['Prefix'], '', Array($insert_id), null, array('temp_id' => $id) );

	$this->UpdateForeignKeys($master, $insert_id, $id);

	//delete already copied record from master temp table
	$query = 'DELETE FROM '.$this->GetTempName($master['TableName']).'
	WHERE '.$master['IdField'].' = '.$id_to_copy;
	if (isset($master['Constrain'])) $query .= ' AND '.$master['Constrain'];
	$this->Conn->Query($query);
	}

	$this->CopiedTables[] = $table_sig;

	// when all of ids in current master has been processed, copy all sub-tables data
	$this->CopySubTablesToLive($master, $current_ids);
	}
	elseif( !in_array($table_sig, $this->CopiedTables) && ($this->FinalRefs[$table_sig] == $master['TableId']) ) { //If current master doesn't have sub-tables - we could use mass operations
	// We don't need to delete items from live here, as it get deleted in the beggining of the method for MasterTable
	// or in parent table processing for sub-tables
	$this->RaiseEvent('OnBeforeCopyToLive', $master['Prefix'], '', $current_ids);

	$live_ids = array();
	foreach ($current_ids as $an_id) {
	if ($an_id > 0) {
	$live_ids[$an_id] = $an_id;
	// positive (already live) IDs will be copied in on query all togather below,
	// so we just store it here
	continue;
	}
	else { // zero or negaitve ids should be copied one by one to get their InsertId
	// reseting to 0 so it get inserted into live table with autoincrement
	- $query = 'UPDATE '.$this->GetTempName($master['TableName']).'
	+ $query = 'UPDATE '.$this->GetTempName($master['TableName']).'
	SET '.$master['IdField'].' = 0
	WHERE '.$master['IdField'].' = '.$an_id;
	// constrain is not needed here because ID is already unique
	- $this->Conn->Query($query);
	+ $this->Conn->Query($query);
	+
	// copying
	$query = 'INSERT INTO '.$master['TableName'].'
	SELECT * FROM '.$this->GetTempName($master['TableName']).'
	WHERE '.$master['IdField'].' = 0';
	$this->Conn->Query($query);
	$live_ids[$an_id] = $this->Conn->getInsertID(); //storing newly created live id
	+
	//delete already copied record from master temp table
	$query = 'DELETE FROM '.$this->GetTempName($master['TableName']).'
	WHERE '.$master['IdField'].' = 0';
	$this->Conn->Query($query);
	}
	}

	// copy ALL records to live table
	$query = 'INSERT INTO '.$master['TableName'].'
	SELECT * FROM '.$this->GetTempName($master['TableName']);
	if (isset($master['Constrain'])) $query .= ' WHERE '.$master['Constrain'];
	$this->Conn->Query($query);

	$this->CopiedTables[] = $table_sig;
	$this->RaiseEvent('OnAfterCopyToLive', $master['Prefix'], '', $live_ids);

	$this->saveID($master['Prefix'], '', $live_ids);

	-
	-
	// no need to clear temp table - it will be dropped by next statement
	}
	}

	if ($this->FinalRefs[ $master['TableName'] ] != $master['TableId']) return;

	/*if ( is_array(getArrayValue($master, 'ForeignKey')) ) { //if multiple ForeignKeys
	if ( $master['ForeignKey'][$parent_prefix] != end($master['ForeignKey']) ) {
	return; // Do not delete temp table if not all ForeignKeys have been processed (current is not the last)
	}
	}*/
	$this->DropTempTable($master['TableName']);
	$this->Application->resetCounters($master['TableName']);

	if (!isset($this->savedIDs[ $master['Prefix'] ])) {
	$this->savedIDs[ $master['Prefix'] ] = Array();
	}

	return $this->savedIDs[ $master['Prefix'] ];
	}

	function UpdateForeignKeys($master, $live_id, $temp_id) {
	foreach ($master['SubTables'] as $sub_table) {
	$foreign_key_field = is_array($sub_table['ForeignKey']) ? getArrayValue($sub_table, 'ForeignKey', $master['Prefix']) : $sub_table['ForeignKey'];
	if (!$foreign_key_field) return;

	list ($live_foreign_key, $temp_foreign_key) = $this->GetForeignKeys($master, $sub_table, $live_id, $temp_id);

	//Update ForeignKey in sub TEMP table
	if ($live_foreign_key != $temp_foreign_key) {
	$query = 'UPDATE '.$this->GetTempName($sub_table['TableName']).'
	SET '.$foreign_key_field.' = '.$live_foreign_key.'
	WHERE '.$foreign_key_field.' = '.$temp_foreign_key;
	if (isset($sub_table['Constrain'])) $query .= ' AND '.$sub_table['Constrain'];
	$this->Conn->Query($query);
	}
	}
	}

	function CopySubTablesToLive($master, $current_ids) {
	foreach ($master['SubTables'] as $sub_table) {

	$table_sig = $sub_table['TableName'].(isset($sub_table['Constrain']) ? $sub_table['Constrain'] : '');

	// delete records from live table by foreign key, so that records deleted from temp table
	// get deleted from live
	if (count($current_ids) > 0 && !in_array($table_sig, $this->CopiedTables) ) {
	$foreign_key_field = is_array($sub_table['ForeignKey']) ? getArrayValue($sub_table, 'ForeignKey', $master['Prefix']) : $sub_table['ForeignKey'];
	if (!$foreign_key_field) continue;
	$foreign_keys = $this->GetForeignKeys($master, $sub_table, $current_ids);
	if (count($foreign_keys) > 0) {
	$query = 'SELECT '.$sub_table['IdField'].' FROM '.$sub_table['TableName'].'
	WHERE '.$foreign_key_field.' IN ('.join(',', $foreign_keys).')';
	if (isset($sub_table['Constrain'])) $query .= ' AND '.$sub_table['Constrain'];

	if ( $this->RaiseEvent( 'OnBeforeDeleteFromLive', $sub_table['Prefix'], '', $this->Conn->GetCol($query), $foreign_keys ) ){
	$query = 'DELETE FROM '.$sub_table['TableName'].'
	WHERE '.$foreign_key_field.' IN ('.join(',', $foreign_keys).')';
	if (isset($sub_table['Constrain'])) $query .= ' AND '.$sub_table['Constrain'];
	$this->Conn->Query($query);
	}
	}
	}
	//sub_table passed here becomes master in the method, and recursively updated and copy its sub tables
	$this->DoCopyTempToOriginal($sub_table, $master['Prefix']);
	}
	}

	function RaiseEvent($name, $prefix, $special, $ids, $foreign_key = null, $add_params = null)
	{
	if ( !is_array($ids) ) return ;

	$event_key = $prefix.($special ? '.' : '').$special.':'.$name;
	$event = new kEvent($event_key);
	if (isset($foreign_key)) {
	$event->setEventParam('foreign_key', $foreign_key);
	}

	foreach($ids as $id)
	{
	$event->setEventParam('id', $id);
	if (is_array($add_params)) {
	foreach ($add_params as $name => $val) {
	$event->setEventParam($name, $val);
	}
	}
	$this->Application->HandleEvent($event);
	}
	return $event->status == erSUCCESS;
	}

	function DropTempTable($table)
	{
	if( in_array($table, $this->DroppedTables) ) return false;
	$query = sprintf("DROP TABLE IF EXISTS %s",
	$this->GetTempName($table)
	);
	array_push($this->DroppedTables, $table);
	$this->DroppedTables = array_unique($this->DroppedTables);
	$this->Conn->Query($query);
	-
	+
	return true;
	}

	function PrepareEdit()
	{
	$this->DoCopyLiveToTemp($this->Tables, $this->Tables['IDs']);
	if ($this->Application->getUnitOption($this->Tables['Prefix'],'CheckSimulatniousEdit')) {
	$this->CheckSimultaniousEdit();
	}
	}

	function SaveEdit($master_ids = Array())
	{
	return $this->DoCopyTempToOriginal($this->Tables, null, $master_ids);
	}

	function CancelEdit($master=null)
	{
	if (!isset($master)) $master = $this->Tables;
	$this->DropTempTable($master['TableName']);
	if ( getArrayValue($master, 'SubTables') ) {
	foreach ($master['SubTables'] as $sub_table) {
	$this->CancelEdit($sub_table);
	}
	}
	}
	+
	function CheckSimultaniousEdit()
	{
	$tables = $this->Conn->GetCol('SHOW TABLES');
	$mask_edit_table = '/'.TABLE_PREFIX.'ses_(.*)_edit_'.$this->MasterTable.'$/';
	+
	$sql='SELECT COUNT(*) FROM '.$this->TableName.' WHERE '.$this->IDField.' = \'%s\'';
	$my_sid = $this->Application->GetSID();
	$ids = join(',',$this->Tables['IDs']);
	$sids = array();
	if (!$ids) return ;
	foreach($tables as $table)
	{
	if( preg_match($mask_edit_table,$table,$rets) )
	{
	$sid = preg_replace('/(.)_(.)/', '\\1', $rets[1]); // remove popup's wid from sid
	if ($sid == $my_sid) continue;
	$found = $this->Conn->GetOne("SELECT COUNT({$this->Tables['IdField']}) FROM $table WHERE {$this->Tables['IdField']} IN ($ids)");
	if (!$found \|\| in_array($sid, $sids)) continue;
	+
	$sids[] = $sid;
	}
	}
	if ($sids) {
	//detect who is it
	$users = $this->Conn->GetCol(
	' SELECT
	CONCAT(IF (s.PortalUserId = -1, \'root\',
	IF (s.PortalUserId = -2, \'Guest\',
	CONCAT(FirstName, \' \', LastName, \' (\', Login, \')\')
	)
	), \' IP: \', s.IpAddress, \'\') FROM '.TABLE_PREFIX.'UserSession AS s
	LEFT JOIN '.TABLE_PREFIX.'PortalUser AS u
	ON u.PortalUserId = s.PortalUserId
	WHERE s.SessionKey IN ('.join(',',$sids).')');
	if ($users) {
	$this->Application->SetVar('_simultanious_edit_message',
	sprintf($this->Application->Phrase('la_record_being_edited_by'), join(",\n", $users))
	);
	}
	}
	}
	}

	?>
	\ No newline at end of file

	Property changes on: branches/RC/core/kernel/utility/temp_handler.php
	___________________________________________________________________
	Modified: cvs2svn:cvs-rev
	## -1 +1 ##
	-1.30.2.1
	\ No newline at end of property
	+1.30.2.2
	\ No newline at end of property
	Index: branches/RC/core/kernel/db/db_tag_processor.php
	===================================================================
	--- branches/RC/core/kernel/db/db_tag_processor.php (revision 9642)
	+++ branches/RC/core/kernel/db/db_tag_processor.php (revision 9643)
	@@ -1,2077 +1,2079 @@
	<?php

	class kDBTagProcessor extends TagProcessor {

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

	function kDBTagProcessor()
	{
	parent::kBase();
	$this->Conn =& $this->Application->GetADODBConnection();
	}


	/**
	* Returns true if "new" button was pressed in toolbar
	*
	* @param Array $params
	* @return bool
	*/
	function IsNewMode($params)
	{
	$object =& $this->getObject($params);
	return $object->GetID() <= 0;
	}

	/**
	* Returns view menu name for current prefix
	*
	* @param Array $params
	* @return string
	*/
	function GetItemName($params)
	{
	$item_name = $this->Application->getUnitOption($this->Prefix, 'ViewMenuPhrase');
	return $this->Application->Phrase($item_name);
	}

	function ViewMenu($params)
	{
	$block_params = $params;
	unset($block_params['block']);
	$block_params['name'] = $params['block'];

	$list =& $this->GetList($params);
	$block_params['PrefixSpecial'] = $list->getPrefixSpecial();
	return $this->Application->ParseBlock($block_params);
	}

	function SearchKeyword($params)
	{
	$list =& $this->GetList($params);
	return $this->Application->RecallVar($list->getPrefixSpecial().'_search_keyword');
	}

	/**
	* Draw filter menu content (for ViewMenu) based on filters defined in config
	*
	* @param Array $params
	* @return string
	*/
	function DrawFilterMenu($params)
	{
	$block_params = $this->prepareTagParams($params);
	$block_params['name'] = $params['spearator_block'];
	$separator = $this->Application->ParseBlock($block_params);
	$filter_menu = $this->Application->getUnitOption($this->Prefix,'FilterMenu');
	if(!$filter_menu)
	{
	trigger_error('<span class="debug_error">no filters defined</span> for prefix <b>'.$this->Prefix.'</b>, but <b>DrawFilterMenu</b> tag used', E_USER_WARNING);
	return '';
	}

	// Params: label, filter_action, filter_status
	$block_params['name'] = $params['item_block'];

	$view_filter = $this->Application->RecallVar($this->getPrefixSpecial().'_view_filter');
	if($view_filter === false)
	{
	$event_params = Array('prefix'=>$this->Prefix,'special'=>$this->Special,'name'=>'OnRemoveFilters');
	$this->Application->HandleEvent( new kEvent($event_params) );
	$view_filter = $this->Application->RecallVar($this->getPrefixSpecial().'_view_filter');
	}
	$view_filter = unserialize($view_filter);

	$filters = Array();
	$prefix_special = $this->getPrefixSpecial();

	foreach ($filter_menu['Filters'] as $filter_key => $filter_params) {
	$group_params = isset($filter_params['group_id']) ? $filter_menu['Groups'][ $filter_params['group_id'] ] : Array();
	if (!isset($group_params['element_type'])) {
	$group_params['element_type'] = 'checkbox';
	}

	if (!$filter_params) {
	$filters[] = $separator;
	continue;
	}

	$block_params['label'] = addslashes( $this->Application->Phrase($filter_params['label']) );
	if (getArrayValue($view_filter,$filter_key)) {
	$submit = 0;
	if (isset($params['old_style'])) {
	$status = $group_params['element_type'] == 'checkbox' ? 1 : 2;
	}
	else {
	$status = $group_params['element_type'] == 'checkbox' ? '[\'img/check_on.gif\']' : '[\'img/menu_dot.gif\']';
	}
	}
	else {
	$submit = 1;
	$status = 'null';
	}
	$block_params['filter_action'] = 'set_filter("'.$prefix_special.'","'.$filter_key.'","'.$submit.'",'.$params['ajax'].');';
	$block_params['filter_status'] = $status; // 1 - checkbox, 2 - radio, 0 - no image
	$filters[] = $this->Application->ParseBlock($block_params);
	}


	return implode('', $filters);
	}

	function IterateGridFields($params)
	{
	$mode = $params['mode'];
	$def_block = isset($params['block']) ? $params['block'] : '';
	$force_block = isset($params['force_block']) ? $params['force_block'] : false;

	$grids = $this->Application->getUnitOption($this->Prefix,'Grids');
	$grid_config = $grids[$params['grid']]['Fields'];

	$picker_helper =& $this->Application->RecallObject('ColumnPickerHelper');
	/* @var $picker_helper kColumnPickerHelper */
	$picker_helper->ApplyPicker($this->getPrefixSpecial(), $grid_config, $params['grid']);

	$std_params['pass_params']='true';
	$std_params['PrefixSpecial']=$this->getPrefixSpecial();

	$o = '';
	$i = 0;
	foreach ($grid_config as $field => $options) {
	$i++;
	$block_params = Array();
	$block_params['name'] = $force_block ? $force_block : (isset($options[$mode.'_block']) ? $options[$mode.'_block'] : $def_block);
	$block_params['field'] = $field;
	$block_params['sort_field'] = isset($options['sort_field']) ? $options['sort_field'] : $field;
	$block_params['filter_field'] = isset($options['filter_field']) ? $options['filter_field'] : $field;

	$w = $picker_helper->GetWidth($field);
	if ($w) $options['width'] = $w;

	if (isset($options['filter_width'])) {
	$block_params['filter_width'] = $options['filter_width'];
	}
	elseif (isset($options['width'])) {
	if (isset($options['filter_block']) && preg_match('/range/', $options['filter_block'])) {
	if ($options['width'] < 60) {
	$options['width'] = 60;
	$block_params['filter_width'] = 20;
	}
	else {
	$block_params['filter_width'] = $options['width'] - 40;
	}
	}
	else {
	$block_params['filter_width'] = max($options['width']-10, 20);
	}
	}
	if (isset($block_params['filter_width'])) $block_params['filter_width'] .= 'px';

	$field_options = $this->Application->getUnitOption($this->Prefix.'.'.$field, 'Fields');
	if (isset($field_options['use_phrases'])) {
	$block_params['use_phrases'] = $field_options['use_phrases'];
	}

	$block_params['is_last'] = ($i == count($grid_config));
	$block_params = array_merge($std_params, $options, $block_params);
	$o.= $this->Application->ParseBlock($block_params, 1);
	}
	return $o;
	}

	function PickerCRC($params)
	{
	/* @var $picker_helper kColumnPickerHelper */
	$picker_helper =& $this->Application->RecallObject('ColumnPickerHelper');
	$picker_helper->SetGridName($params['grid']);
	$data = $picker_helper->LoadColumns($this->getPrefixSpecial());
	return $data['crc'];
	}

	function FreezerPosition($params)
	{
	/* @var $picker_helper kColumnPickerHelper */
	$picker_helper =& $this->Application->RecallObject('ColumnPickerHelper');
	$picker_helper->SetGridName($params['grid']);
	$data = $picker_helper->LoadColumns($this->getPrefixSpecial());
	$freezer_pos = array_search('__FREEZER__', $data['order']);
	return $freezer_pos === false \|\| in_array('__FREEZER__', $data['hidden_fields']) ? 1 : ++$freezer_pos;
	}

	function GridFieldsCount($params)
	{
	$grids = $this->Application->getUnitOption($this->Prefix, 'Grids');
	$grid_config = $grids[$params['grid']]['Fields'];

	return count($grid_config);
	}

	/**
	* Prints list content using block specified
	*
	* @param Array $params
	* @return string
	* @access public
	*/
	function PrintList($params)
	{
	$params['no_table'] = 1;
	return $this->PrintList2($params);
	}

	function InitList($params)
	{
	$list_name = isset($params['list_name']) ? $params['list_name'] : '';

	$names_mapping = $this->Application->GetVar('NamesToSpecialMapping');

	if( !getArrayValue($names_mapping, $this->Prefix, $list_name) )
	{
	$list =& $this->GetList($params);
	}
	}

	function BuildListSpecial($params)
	{
	return $this->Special;
	}

	/**
	* Returns key, that identifies each list on template (used internally, not tag)
	*
	* @param Array $params
	* @return string
	*/
	function getUniqueListKey($params)
	{
	$types = $this->SelectParam($params, 'types');
	$except = $this->SelectParam($params, 'except');
	$list_name = $this->SelectParam($params, 'list_name');
	if (!$list_name) {
	$list_name = $this->Application->Parser->GetParam('list_name');
	}

	return $types.$except.$list_name;
	}

	/**
	* Enter description here...
	*
	* @param Array $params
	* @return kDBList
	*/
	function &GetList($params)
	{
	$list_name = $this->SelectParam($params, 'list_name,name');
	if (!$list_name) {
	$list_name = $this->Application->Parser->GetParam('list_name');
	}

	$requery = isset($params['requery']) && $params['requery'];
	if ($list_name && !$requery){
	$names_mapping = $this->Application->GetVar('NamesToSpecialMapping');

	$special = is_array($names_mapping) && isset($names_mapping[$this->Prefix]) && isset($names_mapping[$this->Prefix][$list_name]) ? $names_mapping[$this->Prefix][$list_name] : false;
	// $special = getArrayValue($names_mapping, $this->Prefix, $list_name);
	if(!$special)
	{
	$special = $this->BuildListSpecial($params);
	}
	}
	else
	{
	$special = $this->BuildListSpecial($params);
	}

	$prefix_special = rtrim($this->Prefix.'.'.$special, '.');
	$params['skip_counting'] = true;
	$list =& $this->Application->recallObject( $prefix_special, $this->Prefix.'_List', $params);
	if ($requery) {
	$this->Application->HandleEvent($an_event, $prefix_special.':OnListBuild', $params);
	}
	$list->Query($requery);
	$this->Special = $special;

	if ($list_name) {
	$names_mapping[$this->Prefix][$list_name] = $special;
	$this->Application->SetVar('NamesToSpecialMapping', $names_mapping);
	}

	return $list;
	}

	function ListMarker($params)
	{
	$list =& $this->GetList($params);
	$ret = $list->getPrefixSpecial();
	if( getArrayValue($params, 'as_preg') ) $ret = preg_quote($ret, '/');
	return $ret;
	}

	/**
	* Prepares name for field with event in it (used only on front-end)
	*
	* @param Array $params
	* @return string
	*/
	function SubmitName($params)
	{
	$list =& $this->GetList($params);

	$prefix_special = $list->getPrefixSpecial();

	return 'events['.$prefix_special.']['.$params['event'].']';
	}

	/**
	* Prints list content using block specified
	*
	* @param Array $params
	* @return string
	* @access public
	*/
	function PrintList2($params)
	{
	$per_page = $this->SelectParam($params, 'per_page,max_items');
	if ($per_page !== false) $params['per_page'] = $per_page;

	$list =& $this->GetList($params);
	$o = '';

	$direction = (isset($params['direction']) && $params['direction']=="H")?"H":"V";
	$columns = (isset($params['columns'])) ? $params['columns'] : 1;

	$id_field = (isset($params['id_field'])) ? $params['id_field'] : $this->Application->getUnitOption($this->Prefix, 'IDField');

	if ($columns>1 && $direction=="V") {
	$list->Records = $this->LinearToVertical($list->Records, $columns, $list->GetPerPage());
	$list->SelectedCount=count($list->Records);
	ksort($list->Records); // this is issued twice, maybe need to be removed
	}

	$list->GoFirst();

	$block_params=$this->prepareTagParams($params);
	$block_params['name']=$this->SelectParam($params, 'render_as,block');
	$block_params['pass_params']='true';
	$block_params['column_width'] = 100 / $columns;
	$block_start_row_params = $this->prepareTagParams($params);
	$block_start_row_params['name'] = $this->SelectParam($params, 'row_start_render_as,block_row_start,row_start_block');

	$block_end_row_params=$this->prepareTagParams($params);
	$block_end_row_params['name'] = $this->SelectParam($params, 'row_end_render_as,block_row_end,row_end_block');

	$block_empty_cell_params = $this->prepareTagParams($params);
	$block_empty_cell_params['name'] = $this->SelectParam($params, 'empty_cell_render_as,block_empty_cell,empty_cell_block');

	$i=0;

	$backup_id=$this->Application->GetVar($this->Prefix."_id");
	$displayed = array();
	$column_number = 1;

	$cache_mod_rw = $this->Application->getUnitOption($this->Prefix, 'CacheModRewrite') && $this->Application->RewriteURLs();

	while (!$list->EOL())
	{
	$this->Application->SetVar( $this->getPrefixSpecial().'_id', $list->GetDBField($id_field) ); // for edit/delete links using GET
	$this->Application->SetVar( $this->Prefix.'_id', $list->GetDBField($id_field) );
	$block_params['is_last'] = ($i == $list->SelectedCount - 1);
	$block_params['not_last'] = !$block_params['is_last']; // for front-end

	if ($cache_mod_rw) {
	$this->Application->setCache('filenames', $this->Prefix.'_'.$list->GetDBField($id_field), $list->GetDBField('Filename'));
	$this->Application->setCache('filenames', 'c_'.$list->GetDBField('CategoryId'), $list->GetDBField('CategoryFilename'));
	}

	if ($i % $columns == 0) {
	// record in this iteration is first in row, then open row
	$column_number = 1;
	$o.= $block_start_row_params['name'] ?
	$this->Application->ParseBlock($block_start_row_params, 1) :
	(!isset($params['no_table']) ? '<tr>' : '');
	}
	else {
	$column_number++;
	}

	$block_params['first_col'] = $column_number == 1 ? 1 : 0;
	$block_params['last_col'] = $column_number == $columns ? 1 : 0;

	$block_params['column_number'] = $column_number;

	$this->PrepareListElementParams($list, $block_params); // new, no need to rewrite PrintList
	$o.= $this->Application->ParseBlock($block_params, 1);
	array_push($displayed, $list->GetDBField($id_field));

	if (($i+1) % $columns == 0) {
	// record in next iteration is first in row too, then close this row
	$o.= $block_end_row_params['name'] ?
	$this->Application->ParseBlock($block_end_row_params, 1) :
	(!isset($params['no_table']) ? '</tr>' : '');
	}

	$list->GoNext();
	$i++;
	}

	// append empty cells in place of missing cells in last row
	while ($i % $columns != 0) {
	// until next cell will be in new row append empty cells
	$o .= $block_empty_cell_params['name'] ? $this->Application->ParseBlock($block_empty_cell_params, 1) : '<td> </td>';

	if (($i+1) % $columns == 0) {
	// record in next iteration is first in row too, then close this row
	$o .= $block_end_row_params['name'] ? $this->Application->ParseBlock($block_end_row_params, 1) : '</tr>';
	}
	$i++;
	}

	$cur_displayed = $this->Application->GetVar($this->Prefix.'_displayed_ids');
	if (!$cur_displayed) {
	$cur_displayed = Array();
	}
	else {
	$cur_displayed = explode(',', $cur_displayed);
	}

	$displayed = array_unique(array_merge($displayed, $cur_displayed));
	$this->Application->SetVar($this->Prefix.'_displayed_ids', implode(',',$displayed));

	$this->Application->SetVar( $this->Prefix.'_id', $backup_id);
	$this->Application->SetVar( $this->getPrefixSpecial().'_id', '');

	if (isset($params['more_link_render_as'])) {
	$block_params = $params;
	$params['render_as'] = $params['more_link_render_as'];
	$o .= $this->MoreLink($params);
	}

	return $o;
	}

	/**
	* Allows to modify block params & current list record before PrintList parses record
	*
	* @param kDBList $object
	* @param Array $block_params
	*/
	function PrepareListElementParams(&$object, &$block_params)
	{
	// $fields_hash =& $object->Records[$this->CurrentIndex];
	//
	// $object->Records[$this->CurrentIndex] =& $fields_hash;
	}

	function MoreLink($params)
	{
	$per_page = $this->SelectParam($params, 'per_page,max_items');
	if ($per_page !== false) $params['per_page'] = $per_page;
	$list =& $this->GetList($params);
	if ($list->PerPage < $list->RecordsCount) {
	$block_params = array();
	$block_params['name'] = $this->SelectParam($params, 'render_as,block');
	return $this->Application->ParseBlock($block_params, 1);
	}
	}

	function NotLastItem($params)
	{
	$object =& $this->getList($params); // maybe we should use $this->GetList($params) instead
	return ($object->CurrentIndex < min($object->PerPage == -1 ? $object->RecordsCount : $object->PerPage, $object->RecordsCount) - 1);
	}

	function PageLink($params)
	{
	$t = isset($params['template']) ? $params['template'] : '';
	unset($params['template']);

	if (!$t) $t = $this->Application->GetVar('t');

	if (isset($params['page'])) {
	$this->Application->SetVar($this->getPrefixSpecial().'_Page', $params['page']);
	unset($params['page']);
	}

	if (!isset($params['pass'])) {
	$params['pass'] = 'm,'.$this->getPrefixSpecial();
	}

	return $this->Application->HREF($t, '', $params);
	}

	function ColumnWidth($params)
	{
	$columns = $this->Application->Parser->GetParam('columns');
	return round(100/$columns).'%';
	}

	/**
	* Append prefix and special to tag
	* params (get them from tagname) like
	* they were really passed as params
	*
	* @param Array $tag_params
	* @return Array
	* @access protected
	*/
	function prepareTagParams($tag_params = Array())
	{
	/*if (isset($tag_params['list_name'])) {
	$list =& $this->GetList($tag_params);
	$this->Init($list->Prefix, $list->Special);
	}*/

	$ret = $tag_params;
	$ret['Prefix'] = $this->Prefix;
	$ret['Special'] = $this->Special;
	$ret['PrefixSpecial'] = $this->getPrefixSpecial();
	return $ret;
	}

	function GetISO($currency)
	{
	if ($currency == 'selected') {
	$iso = $this->Application->RecallVar('curr_iso');
	}
	elseif ($currency == 'primary' \|\| $currency == '') {
	$iso = $this->Application->GetPrimaryCurrency();
	}
	else { //explicit currency
	$iso = $currency;
	}
	return $iso;
	}

	function ConvertCurrency($value, $iso)
	{
	$converter =& $this->Application->recallObject('kCurrencyRates');
	// convery primary currency to selected (if they are the same, converter will just return)
	$value = $converter->Convert($value, 'PRIMARY', $iso);
	return $value;
	}

	function AddCurrencySymbol($value, $iso)
	{
	$currency =& $this->Application->recallObject('curr.-'.$iso, null, Array('skip_autoload' => true));
	if( !$currency->isLoaded() ) $currency->Load($iso, 'ISO');

	$symbol = $currency->GetDBField('Symbol');
	if (!$symbol) $symbol = $currency->GetDBField('ISO').' ';
	if ($currency->GetDBField('SymbolPosition') == 0) {
	$value = $symbol.$value;
	}
	if ($currency->GetDBField('SymbolPosition') == 1) {
	$value = $value.$symbol;
	}
	return $value;
	}

	/**
	* Get's requested field value
	*
	* @param Array $params
	* @return string
	* @access public
	*/
	function Field($params)
	{
	$field = $this->SelectParam($params, 'name,field');

	if( !$this->Application->IsAdmin() ) $params['no_special'] = 'no_special';

	$object =& $this->getObject($params);

	if ( $this->HasParam($params, 'db') )
	{
	$value = $object->GetDBField($field);
	}
	else
	{
	if( $this->HasParam($params, 'currency') )
	{
	$iso = $this->GetISO($params['currency']);
	$original = $object->GetDBField($field);
	$value = $this->ConvertCurrency($original, $iso);
	$object->SetDBField($field, $value);
	$object->Fields[$field]['converted'] = true;
	}

	$format = getArrayValue($params, 'format');
	if( !$format \|\| $format == '$format' )
	{
	$format = null;
	}
	else
	{
	if(preg_match("/_regional_(.*)/", $format, $regs))
	{
	$lang =& $this->Application->recallObject('lang.current');
	$format = $lang->GetDBField($regs[1]);
	}
	}
	$value = $object->GetField($field, $format);

	if( $this->SelectParam($params, 'negative') )
	{
	if(strpos($value, '-') === 0)
	{
	$value = substr($value, 1);
	}
	else
	{
	$value = '-'.$value;
	}
	}

	if( $this->HasParam($params, 'currency') )
	{
	$value = $this->AddCurrencySymbol($value, $iso);
	$params['no_special'] = 1;
	}
	}

	if( !$this->HasParam($params, 'no_special') ) $value = htmlspecialchars($value);
	if( getArrayValue($params,'checked' ) ) $value = ($value == ( isset($params['value']) ? $params['value'] : 1)) ? 'checked' : '';
	if( isset($params['plus_or_as_label']) ) {
	$value = substr($value, 0,1) == '+' ? substr($value, 1) : $this->Application->Phrase($value);
	}
	elseif( isset($params['as_label']) && $params['as_label'] ) $value = $this->Application->Phrase($value);

	$first_chars = $this->SelectParam($params,'first_chars,cut_first');
	if($first_chars)
	{
	$needs_cut = strlen($value) > $first_chars;
	$value = extension_loaded('mbstring') ? mb_substr($value,0,$first_chars) : substr($value,0,$first_chars);
	if($needs_cut) $value .= ' ...';
	}
	if( getArrayValue($params,'nl2br' ) ) $value = nl2br($value);

	if ($value != '') $this->Application->Parser->DataExists = true;

	if( $this->HasParam($params, 'currency') )
	{
	//restoring value in original currency, for other Field tags to work properly
	$object->SetDBField($field, $original);
	}

	return $value;
	}

	function SetField($params)
	{
	// <inp2:SetField field="Value" src=p:cust_{$custom_name}"/>

	$object =& $this->getObject($params);
	$dst_field = $this->SelectParam($params, 'name,field');

	list($prefix_special, $src_field) = explode(':', $params['src']);
	$src_object =& $this->Application->recallObject($prefix_special);
	$object->SetDBField($dst_field, $src_object->GetDBField($src_field));
	}

	/**
	* Checks if parameter is passed
	* Note: works like Tag and line simple method too
	*
	* @param Array $params
	* @param string $param_name
	* @return bool
	*/
	function HasParam($params, $param_name = null)
	{
	if( !isset($param_name) )
	{
	$param_name = $this->SelectParam($params, 'name');
	$params = $this->Application->Parser->Params;
	}
	$value = isset($params[$param_name]) ? $params[$param_name] : false;
	return $value && ($value != '$'.$param_name);
	}

	function PhraseField($params)
	{
	$field_label = $this->Field($params);
	$translation = $this->Application->Phrase( $field_label );
	return $translation;
	}

	function Error($params)
	{
	$field = $this->SelectParam($params, 'name,field');
	$object =& $this->getObject($params);
	$msg = $object->GetErrorMsg($field, false);
	return $msg;
	}

	function HasError($params)
	{
	if ($params['field'] == 'any')
	{
	$object =& $this->getObject($params);

	$skip_fields = getArrayValue($params, 'except');
	$skip_fields = $skip_fields ? explode(',', $skip_fields) : Array();

	return $object->HasErrors($skip_fields);
	}
	else
	{
	$fields = $this->SelectParam($params, 'field,fields');
	$fields = explode(',', $fields);
	$res = false;
	foreach($fields as $field)
	{
	$params['field'] = $field;
	$res = $res \|\| ($this->Error($params) != '');
	}
	return $res;
	}
	}

	function ErrorWarning($params)
	{
	if (!isset($params['field'])) {
	$params['field'] = 'any';
	}
	if ($this->HasError($params)) {
	$params['prefix'] = $this->getPrefixSpecial();
	return $this->Application->ParseBlock($params);
	}
	}

	function IsRequired($params)
	{
	$field = $params['field'];
	$object =& $this->getObject($params);;

	$formatter_class = getArrayValue($object->Fields, $field, 'formatter');
	if ($formatter_class == 'kMultiLanguage')
	{
	$formatter =& $this->Application->recallObject($formatter_class);
	$field = $formatter->LangFieldName($field);
	}

	$options = $object->GetFieldOptions($field);
	return getArrayValue($options,'required');
	}

	function FieldOption($params)
	{
	$object =& $this->getObject($params);;
	$options = $object->GetFieldOptions($params['field']);
	$ret = isset($options[$params['option']]) ? $options[$params['option']] : '';
	if (isset($params['as_label']) && $params['as_label']) $ret = $this->Application->ReplaceLanguageTags($ret);
	return $ret;
	}

	function PredefinedOptions($params)
	{
	$field = $params['field'];
	$object =& $this->getObject($params);

	$value = $object->GetDBField($field);
	$options = $object->GetFieldOptions($field);
	if( $this->HasParam($params,'has_empty') )
	{
	$empty_value = getArrayValue($params, 'empty_value');
	if($empty_value === false) $empty_value = '';
	$options['options'] = array_merge_recursive2( Array($empty_value => ''), $options['options'] );
	}

	$block_params = $this->prepareTagParams($params);

	$block_params['name'] = $this->SelectParam($params, 'render_as,block');
	$block_params['field'] = $params['field'];
	$block_params['pass_params'] = 'true';
	$block_params['field_name'] = $this->InputName($params);
	$block_params['PrefixSpecial'] = $this->getPrefixSpecial();

	$selected_param_name = getArrayValue($params,'selected_param');
	if(!$selected_param_name) $selected_param_name = $params['selected'];
	$selected = $params['selected'];

	$o = '';
	if( $this->HasParam($params,'no_empty') && !getArrayValue($options['options'],'') ) array_shift($options['options']);

	if( strpos($value, '\|') !== false )
	{
	// multiple selection checkboxes
	$value = explode('\|', substr($value, 1, -1) );
	foreach ($options['options'] as $key => $val)
	{
	$block_params['key'] = $key;
	$block_params['option'] = $val;
	$block_params[$selected_param_name] = ( in_array($key, $value) ? ' '.$selected : '');
	$o .= $this->Application->ParseBlock($block_params, 1);
	}
	}
	else
	{
	// single selection radio or checkboxes
	if (!isset($options['options']) \|\| !is_array($options['options'])) {
	trigger_error("Options not defined for {$object->Prefix} field $field", E_USER_WARNING);
	}
	foreach ($options['options'] as $key => $val)
	{
	$block_params['key'] = $key;
	$block_params['option'] = $val;
	$block_params[$selected_param_name] = (strlen($key) == strlen($value) && ($key == $value) ? ' '.$selected : '');
	$o .= $this->Application->ParseBlock($block_params, 1);
	}
	}
	return $o;
	}

	function PredefinedSearchOptions($params)
	{
	$object =& $this->getObject($params);
	/* @var $object kDBList */

	$field = $params['field'];
	$saved_value = $object->Queried ? $object->GetDBField($field) : null;

	$object->SetDBField($field, $this->SearchField($params));
	$view_name = $this->Application->RecallVar($this->getPrefixSpecial().'_current_view');
	$custom_filter = $this->Application->RecallPersistentVar($this->getPrefixSpecial().'_custom_filter.'.$view_name, ALLOW_DEFAULT_SETTINGS);

	$ret = $this->PredefinedOptions($params);
	$object->SetDBField($field, $saved_value);
	return $ret;
	}

	function Format($params)
	{
	$field = $this->SelectParam($params, 'name,field');
	$object =& $this->getObject($params);

	$options = $object->GetFieldOptions($field);

	$format = $options[ $this->SelectParam($params, 'input_format') ? 'input_format' : 'format' ];

	$formatter_class = getArrayValue($options,'formatter');
	if ($formatter_class) {
	$formatter =& $this->Application->recallObject($formatter_class);
	$human_format = getArrayValue($params,'human');
	$edit_size = getArrayValue($params,'edit_size');
	$sample = getArrayValue($params,'sample');
	if($sample)
	{
	return $formatter->GetSample($field, $options, $object);
	}
	elseif($human_format \|\| $edit_size)
	{
	$format = $formatter->HumanFormat($format);
	return $edit_size ? strlen($format) : $format;
	}
	}

	return $format;
	}

	/**
	* Returns grid padination information
	* Can return links to pages
	*
	* @param Array $params
	* @return mixed
	*/
	function PageInfo($params)
	{
	$object =& $this->GetList($params);
	/* @var $object kDBList */

	$type = $params['type'];
	unset($params['type']); // remove parameters used only by current tag

	$ret = '';
	switch ($type) {
	case 'current':
	$ret = $object->Page;
	break;

	case 'total':
	$ret = $object->GetTotalPages();
	break;

	case 'prev':
	$ret = $object->Page > 1 ? $object->Page - 1 : false;
	break;

	case 'next':
	$ret = $object->Page < $object->GetTotalPages() ? $object->Page + 1 : false;
	break;
	}

	if ($ret && isset($params['as_link']) && $params['as_link']) {
	unset($params['as_link']); // remove parameters used only by current tag
	$params['page'] = $ret;
	$current_page = $object->Page; // backup current page
	$ret = $this->PageLink($params);
	$this->Application->SetVar($object->getPrefixSpecial().'_Page', $current_page); // restore page
	}

	return $ret;
	}

	/**
	* Print grid pagination using
	* block names specified
	*
	* @param Array $params
	* @return string
	* @access public
	*/
	function PrintPages($params)
	{
	$list =& $this->GetList($params);
	$prefix_special = $list->getPrefixSpecial();
	$total_pages = $list->GetTotalPages();

	if ($total_pages > 1) $this->Application->Parser->DataExists = true;

	if($total_pages == 0) $total_pages = 1; // display 1st page as selected in case if we have no pages at all
	$o = '';

	// what are these 2 lines for?
	$this->Application->SetVar($prefix_special.'_event','');
	$this->Application->SetVar($prefix_special.'_id','');

	$current_page = $list->Page; // $this->Application->RecallVar($prefix_special.'_Page');

	$block_params = $this->prepareTagParams($params);

	$split = ( isset($params['split'] ) ? $params['split'] : 10 );

	$split_start = $current_page - ceil($split/2);
	if ($split_start < 1){
	$split_start = 1;
	}
	$split_end = $split_start + $split-1;

	if ($split_end > $total_pages) {
	$split_end = $total_pages;
	$split_start = max($split_end - $split + 1, 1);
	}

	if ($current_page > 1){
	$prev_block_params = $this->prepareTagParams();

	if ($total_pages > $split){
	$prev_block_params['page'] = max($current_page-$split, 1);
	$prev_block_params['name'] = $this->SelectParam($params, 'prev_page_split_render_as,prev_page_split_block');
	if ($prev_block_params['name']){
	$o .= $this->Application->ParseBlock($prev_block_params, 1);
	}
	}

	$prev_block_params['name'] = 'page';
	$prev_block_params['page'] = $current_page-1;
	$prev_block_params['name'] = $this->SelectParam($params, 'prev_page_render_as,block_prev_page,prev_page_block');
	if ($prev_block_params['name']) {
	$this->Application->SetVar($this->getPrefixSpecial().'_Page', $current_page-1);
	$o .= $this->Application->ParseBlock($prev_block_params, 1);
	}
	}
	else {
	if ( $no_prev_page_block = $this->SelectParam($params, 'no_prev_page_render_as,block_no_prev_page') ) {
	$block_params['name'] = $no_prev_page_block;
	$o .= $this->Application->ParseBlock($block_params, 1);
	}
	}

	$separator_params['name'] = $this->SelectParam($params, 'separator_render_as,block_separator');
	for ($i = $split_start; $i <= $split_end; $i++)
	{
	if ($i == $current_page) {
	$block = $this->SelectParam($params, 'current_render_as,active_render_as,block_current,active_block');
	}
	else {
	$block = $this->SelectParam($params, 'link_render_as,inactive_render_as,block_link,inactive_block');
	}

	$block_params['name'] = $block;
	$block_params['page'] = $i;
	$this->Application->SetVar($this->getPrefixSpecial().'_Page', $i);
	$o .= $this->Application->ParseBlock($block_params, 1);

	if ($this->SelectParam($params, 'separator_render_as,block_separator')
	&& $i < $split_end)
	{
	$o .= $this->Application->ParseBlock($separator_params, 1);
	}
	}

	if ($current_page < $total_pages){
	$next_block_params = $this->prepareTagParams();
	$next_block_params['page']=$current_page+1;
	$next_block_params['name'] = $this->SelectParam($params, 'next_page_render_as,block_next_page,next_page_block');
	if ($next_block_params['name']){
	$this->Application->SetVar($this->getPrefixSpecial().'_Page', $current_page+1);
	$o .= $this->Application->ParseBlock($next_block_params, 1);
	}
	if ($total_pages > $split){
	$next_block_params['page']=min($current_page+$split, $total_pages);
	$next_block_params['name'] = $this->SelectParam($params, 'next_page_split_render_as,next_page_split_block');
	if ($next_block_params['name']){
	$o .= $this->Application->ParseBlock($next_block_params, 1);
	}
	}
	}

	$this->Application->SetVar($this->getPrefixSpecial().'_Page', $current_page);
	return $o;
	}

	/**
	* Print grid pagination using
	* block names specified
	*
	* @param Array $params
	* @return string
	* @access public
	*/
	function PaginationBar($params)
	{
	return $this->PrintPages($params);
	}


	/**
	* Returns field name (processed by kMultiLanguage formatter
	* if required) and item's id from it's IDField or field required
	*
	* @param Array $params
	* @return Array (id,field)
	* @access private
	*/
	function prepareInputName($params)
	{
	$field = $this->SelectParam($params, 'name,field');
	$object =& $this->getObject($params);

	$formatter_class = getArrayValue($object->Fields, $field, 'formatter');
	if ($formatter_class == 'kMultiLanguage')
	{
	$formatter =& $this->Application->recallObject($formatter_class);
	/* @var $formatter kMultiLanguage */

	$force_primary = isset($object->Fields[$field]['force_primary']) && $object->Fields[$field]['force_primary'];
	$field = $formatter->LangFieldName($field, $force_primary);
	}

	$id_field = getArrayValue($params, 'IdField');
	$id = $id_field ? $object->GetDBField($id_field) : $object->GetID();

	return Array($id, $field);
	}


	/**
	* Returns input field name to
	* be placed on form (for correct
	* event processing)
	*
	* @param Array $params
	* @return string
	* @access public
	*/
	function InputName($params)
	{
	list($id, $field) = $this->prepareInputName($params);

	$ret = $this->getPrefixSpecial().'['.$id.']['.$field.']';
	if( getArrayValue($params, 'as_preg') ) $ret = preg_quote($ret, '/');
	return $ret;
	}

	/**
	* Allows to override various field options through hidden fields with specific names in submit.
	* This tag generates this special names
	*
	* @param Array $params
	* @return string
	* @author Alex
	*/
	function FieldModifier($params)
	{
	list($id, $field) = $this->prepareInputName($params);

	$ret = 'field_modifiers['.$this->getPrefixSpecial().']['.$field.']['.$params['type'].']';
	if( getArrayValue($params, 'as_preg') ) $ret = preg_quote($ret, '/');

	if (isset($params['value'])) {
	$object =& $this->getObject($params);
	$field_modifiers[$field][$params['type']] = $params['value'];
	$object->ApplyFieldModifiers($field_modifiers);
	}

	return $ret;
	}

	/**
	* Returns index where 1st changable sorting field begins
	*
	* @return int
	* @access private
	*/
	function getUserSortIndex()
	{
	$list_sortings = $this->Application->getUnitOption($this->Prefix, 'ListSortings');
	$sorting_prefix = getArrayValue($list_sortings, $this->Special) ? $this->Special : '';

	$user_sorting_start = 0;
	if ( $forced_sorting = getArrayValue($list_sortings, $sorting_prefix, 'ForcedSorting') ) {
	$user_sorting_start = count($forced_sorting);
	}
	return $user_sorting_start;
	}

	/**
	* Returns order direction for given field
	*
	*
	*
	* @param Array $params
	* @return string
	* @access public
	*/
	function Order($params)
	{
	$field = $params['field'];
	$user_sorting_start = $this->getUserSortIndex();

	$list =& $this->GetList($params);

	if ($list->GetOrderField($user_sorting_start) == $field)
	{
	return strtolower($list->GetOrderDirection($user_sorting_start));
	}
	elseif($list->GetOrderField($user_sorting_start+1) == $field)
	{
	return '2_'.strtolower($list->GetOrderDirection($user_sorting_start+1));
	}
	else
	{
	return 'no';
	}
	}

	/**
	* Get's information of sorting field at "pos" position,
	* like sorting field name (type="field") or sorting direction (type="direction")
	*
	* @param Array $params
	* @return mixed
	*/
	function OrderInfo($params)
	{
	$user_sorting_start = $this->getUserSortIndex() + --$params['pos'];
	$list =& $this->GetList($params);
	// $object =& $this->Application->recallObject( $this->getPrefixSpecial() );

	if($params['type'] == 'field') return $list->GetOrderField($user_sorting_start);
	if($params['type'] == 'direction') return $list->GetOrderDirection($user_sorting_start);
	}

	/**
	* Checks if sorting field/direction matches passed field/direction parameter
	*
	* @param Array $params
	* @return bool
	*/
	function IsOrder($params)
	{
	$params['type'] = isset($params['field']) ? 'field' : 'direction';
	$value = $this->OrderInfo($params);

	if( isset($params['field']) ) return $params['field'] == $value;
	if( isset($params['direction']) ) return $params['direction'] == $value;
	}

	/**
	* Returns list perpage
	*
	* @param Array $params
	* @return int
	*/
	function PerPage($params)
	{
	$object =& $this->getObject($params);
	return $object->PerPage;
	}

	/**
	* Checks if list perpage matches value specified
	*
	* @param Array $params
	* @return bool
	*/
	function PerPageEquals($params)
	{
	$object =& $this->getObject($params);
	return $object->PerPage == $params['value'];
	}

	function SaveEvent($params)
	{
	// SaveEvent is set during OnItemBuild, but we may need it before any other tag calls OnItemBuild
	$object =& $this->getObject($params);
	return $this->Application->GetVar($this->getPrefixSpecial().'_SaveEvent');
	}

	function NextId($params)
	{
	$object =& $this->getObject($params);

	$wid = $this->Application->GetTopmostWid($this->Prefix);
	$session_name = rtrim($this->getPrefixSpecial().'_selected_ids_'.$wid, '_');
	$ids = explode(',', $this->Application->RecallVar($session_name));

	$cur_id = $object->GetID();

	$i = array_search($cur_id, $ids);
	if ($i !== false) {
	return $i < count($ids) - 1 ? $ids[$i + 1] : '';
	}
	return '';
	}

	function PrevId($params)
	{
	$object =& $this->getObject($params);

	$wid = $this->Application->GetTopmostWid($this->Prefix);
	$session_name = rtrim($this->getPrefixSpecial().'_selected_ids_'.$wid, '_');
	$ids = explode(',', $this->Application->RecallVar($session_name));

	$cur_id = $object->GetID();

	$i = array_search($cur_id, $ids);
	if ($i !== false) {
	return $i > 0 ? $ids[$i - 1] : '';
	}
	return '';
	}

	function IsSingle($params)
	{
	return ($this->NextId($params) === '' && $this->PrevId($params) === '');
	}

	function IsLast($params)
	{
	return ($this->NextId($params) === '');
	}

	function IsFirst($params)
	{
	return ($this->PrevId($params) === '');
	}

	/**
	* Checks if field value is equal to proposed one
	*
	* @param Array $params
	* @return bool
	*/
	function FieldEquals($params)
	{
	$object =& $this->getObject($params);
	$ret = $object->GetDBField($this->SelectParam($params, 'name,field')) == $params['value'];
	// if( getArrayValue($params,'inverse') ) $ret = !$ret;
	return $ret;
	}

	function ItemIcon($params)
	{
	$object =& $this->getObject($params);

	$grids = $this->Application->getUnitOption($this->Prefix,'Grids');
	$icons =& $grids[ $params['grid'] ]['Icons'];

	$key = '';
	$status_fields = $this->Application->getUnitOption($this->Prefix,'StatusField');
	if(!$status_fields) return $icons['default'];

	foreach($status_fields as $status_field)
	{
	$key .= $object->GetDBField($status_field).'_';
	}
	$key = rtrim($key,'_');
	$value = ($key !== false) ? $key : 'default';

	return isset($icons[$value]) ? $icons[$value] : $icons['default'];
	}

	/**
	* Generates bluebar title + initializes prefixes used on page
	*
	* @param Array $params
	* @return string
	*/
	function SectionTitle($params)
	{
	$preset_name = replaceModuleSection($params['title_preset']);
	$title_presets = $this->Application->getUnitOption($this->Prefix,'TitlePresets');
	$title_info = getArrayValue($title_presets, $preset_name);
	if ($title_info === false) {
	$title = str_replace('#preset_name#', $preset_name, $params['title']);
	if ($this->Application->ConfigValue('UseSmallHeader') && isset($params['group_title']) && $params['group_title']) {
	$title .= ' - '.$params['group_title'];
	}
	return $title;
	}

	if (getArrayValue($title_presets,'default')) {
	// use default labels + custom labels specified in preset used
	$title_info = array_merge_recursive2($title_presets['default'], $title_info);
	}

	$title = $title_info['format'];

	// 1. get objects in use for title construction
	$objects = Array();
	$object_status = Array();
	$status_labels = Array();

	$prefixes = getArrayValue($title_info,'prefixes');
	$all_tag_params = getArrayValue($title_info,'tag_params');
	if ($prefixes) {
	// extract tag_perams passed directly to SectionTitle tag for specific prefix
	foreach ($params as $tp_name => $tp_value) {
	if (preg_match('/(.)\[(.)\]/', $tp_name, $regs)) {
	$all_tag_params[ $regs[1] ][ $regs[2] ] = $tp_value;
	unset($params[$tp_name]);
	}
	}

	$tag_params = Array();
	foreach ($prefixes as $prefix_special) {
	$prefix_data = $this->Application->processPrefix($prefix_special);
	$prefix_data['prefix_special'] = rtrim($prefix_data['prefix_special'],'.');

	if ($all_tag_params) {
	$tag_params = getArrayValue($all_tag_params, $prefix_data['prefix_special']);
	if (!$tag_params) $tag_params = Array();
	}

	$tag_params = array_merge_recursive2($params, $tag_params);
	$objects[ $prefix_data['prefix_special'] ] =& $this->Application->recallObject($prefix_data['prefix_special'], $prefix_data['prefix'], $tag_params);
	$object_status[ $prefix_data['prefix_special'] ] = $objects[ $prefix_data['prefix_special'] ]->IsNewItem() ? 'new' : 'edit';

	// a. set object's status field (adding item/editing item) for each object in title
	if (getArrayValue($title_info[ $object_status[ $prefix_data['prefix_special'] ].'_status_labels' ],$prefix_data['prefix_special'])) {
	$status_labels[ $prefix_data['prefix_special'] ] = $title_info[ $object_status[ $prefix_data['prefix_special'] ].'_status_labels' ][ $prefix_data['prefix_special'] ];
	$title = str_replace('#'.$prefix_data['prefix_special'].'_status#', $status_labels[ $prefix_data['prefix_special'] ], $title);
	}

	// b. setting object's titlefield value (in titlebar ONLY) to default in case if object beeing created with no titlefield filled in
	if ($object_status[ $prefix_data['prefix_special'] ] == 'new') {
	$new_value = $this->getInfo( $objects[ $prefix_data['prefix_special'] ], 'titlefield' );
	if(!$new_value && getArrayValue($title_info['new_titlefield'],$prefix_data['prefix_special']) ) $new_value = $this->Application->Phrase($title_info['new_titlefield'][ $prefix_data['prefix_special'] ]);
	$title = str_replace('#'.$prefix_data['prefix_special'].'_titlefield#', $new_value, $title);
	}
	}
	}

	// 2. replace phrases if any found in format string
	$title = $this->Application->ReplaceLanguageTags($title,false);

	// 3. find and replace any replacement vars
	preg_match_all('/#(._.)#/Uis',$title,$rets);
	if ($rets[1]) {
	$replacement_vars = array_keys( array_flip($rets[1]) );
	foreach ($replacement_vars as $replacement_var) {
	$var_info = explode('_',$replacement_var,2);
	$object =& $objects[ $var_info[0] ];
	$new_value = $this->getInfo($object,$var_info[1]);
	$title = str_replace('#'.$replacement_var.'#', $new_value, $title);
	}
	}

	// replace trailing spaces inside title preset + '' occurences into single space
	$title = preg_replace('/[ ]\'\'[ ]/', ' ', $title);

	if ($this->Application->ConfigValue('UseSmallHeader') && isset($params['group_title']) && $params['group_title']) {
	$title .= ' - '.$params['group_title'];
	}

	$cut_first = getArrayValue($params, 'cut_first');
	if ($cut_first && strlen($title) > $cut_first) {
	if (!preg_match('/<a href="(.)">(.)<\/a>/',$title)) {
	$title = substr($title, 0, $cut_first).' ...';
	}
	}

	return $title;
	}

	function getInfo(&$object, $info_type)
	{
	switch ($info_type)
	{
	case 'titlefield':
	$field = $this->Application->getUnitOption($object->Prefix,'TitleField');
	return $field !== false ? $object->GetField($field) : 'TitleField Missing';
	break;

	case 'recordcount':
	$of_phrase = $this->Application->Phrase('la_of');
	return $object->NoFilterCount != $object->RecordsCount ? $object->RecordsCount.' '.$of_phrase.' '.$object->NoFilterCount : $object->RecordsCount;
	break;

	default:
	return $object->GetField($info_type);
	break;
	}
	}

	function GridInfo($params)
	{
	$object =& $this->GetList($params);
	/* @var $object kDBList */

	switch ($params['type']) {
	case 'filtered':
	return $object->GetRecordsCount();
	case 'total':
	return $object->GetNoFilterCount();
	case 'from':
	return $object->RecordsCount ? $object->Offset+1 : 0; //0-based
	case 'to':
	return min($object->Offset + $object->PerPage, $object->RecordsCount);
	case 'total_pages':
	return $object->GetTotalPages();
	case 'needs_pagination':
	return ($object->RecordsCount > $object->PerPage) \|\| ($object->Page > 1);
	}
	}

	/**
	* Parses block depending on its element type.
	* For radio and select elements values are taken from 'value_list_field' in key1=value1,key2=value2
	* format. key=value can be substituted by <SQL>SELECT f1 AS OptionName, f2 AS OptionValue... FROM <PREFIX>TableName </SQL>
	* where prefix is TABLE_PREFIX
	*
	* @param Array $params
	* @return string
	*/
	function ConfigFormElement($params)
	{
	$object =& $this->getObject($params);
	$field = $params['field'];

	$helper =& $this->Application->recallObject('InpCustomFieldsHelper');

	$element_type = $object->GetDBField($params['element_type_field']);

	if($element_type == 'label') $element_type = 'text';
	$params['name'] = $params['blocks_prefix'].$element_type;

	switch ($element_type) {
	case 'select':
	case 'multiselect':
	case 'radio':
	$field_options = $object->GetFieldOptions($field, 'options');

	if ($object->GetDBField('DirectOptions')) {
	// used for custom fields
	$field_options['options'] = $object->GetDBField('DirectOptions');
	}
	else {
	// used for configuration
	$field_options['options'] = $helper->GetValuesHash( $object->GetDBField($params['value_list_field']) );
	}

	$object->SetFieldOptions($field, $field_options);
	break;

	case 'text':
	case 'textarea':
	$params['field_params'] = $helper->ParseConfigSQL($object->GetDBField($params['value_list_field']));
	break;

	case 'password':
	case 'checkbox':
	default:
	break;
	}
	return $this->Application->ParseBlock($params, 1);
	}

	/**
	* Get's requested custom field value
	*
	* @param Array $params
	* @return string
	* @access public
	*/
	function CustomField($params)
	{
	$params['name'] = 'cust_'.$this->SelectParam($params, 'name,field');
	return $this->Field($params);
	}

	function CustomFieldLabel($params)
	{
	$object =& $this->getObject($params);

	$field = $this->SelectParam($params, 'name,field');

	$sql = 'SELECT FieldLabel
	FROM '.$this->Application->getUnitOption('cf', 'TableName').'
	WHERE FieldName = '.$this->Conn->qstr($field);
	return $this->Application->Phrase($this->Conn->GetOne($sql));
	}

	/**
	* transposes 1-dimensional array elements for vertical alignment according to given columns and per_page parameters
	*
	* @param array $arr
	* @param int $columns
	* @param int $per_page
	* @return array
	*/
	function LinearToVertical(&$arr, $columns, $per_page)
	{
	$rows = $columns;
	// in case if after applying per_page limit record count less then
	// can fill requrested column count, then fill as much as we can
	$cols = min(ceil($per_page / $columns), ceil(count($arr) / $columns));
	$imatrix = array();
	for ($row = 0; $row < $rows; $row++) {
	for ($col = 0; $col < $cols; $col++) {
	$source_index = $row * $cols + $col;
	if (!isset($arr[$source_index])) {
	// in case if source array element count is less then element count in one row
	continue;
	}
	$imatrix[$col * $rows + $row] = $arr[$source_index];
	}
	}

	return array_values($imatrix);
	}

	/**
	* If data was modfied & is in TempTables mode, then parse block with name passed;
	* remove modification mark if not in TempTables mode
	*
	* @param Array $params
	* @return string
	* @access public
	* @author Alexey
	*/
	function SaveWarning($params)
	{
	$main_prefix = getArrayValue($params, 'main_prefix');
	if ($main_prefix && $main_prefix != '$main_prefix') {
	$top_prefix = $main_prefix;
	}
	else {
	$top_prefix = $this->Application->GetTopmostPrefix($this->Prefix);
	}

	$temp_tables = substr($this->Application->GetVar($top_prefix.'_mode'), 0, 1) == 't';
	$modified = $this->Application->RecallVar($top_prefix.'_modified');

	if ($temp_tables && $modified) {
	$block_params = $this->prepareTagParams($params);
	$block_params['name'] = $this->SelectParam($params, 'render_as,name');
	$block_params['edit_mode'] = $temp_tables ? 1 : 0;
	return $this->Application->ParseBlock($block_params);
	}
	$this->Application->RemoveVar($top_prefix.'_modified');
	return '';
	}

	/**
	* Returns list record count queries (on all pages)
	*
	* @param Array $params
	* @return int
	*/
	function TotalRecords($params)
	{
	$list =& $this->GetList($params);
	if (!$list->Counted) $list->CountRecs();
	return $list->RecordsCount;
	}

	/**
	* Range filter field name
	*
	* @param Array $params
	* @return string
	*/
	function SearchInputName($params)
	{
	$field = $this->SelectParam($params, 'field,name');

	$ret = 'custom_filters['.$this->getPrefixSpecial().']['.$params['grid'].']['.$field.']['.$params['filter_type'].']';

	if (isset($params['type'])) {
	$ret .= '['.$params['type'].']';
	}

	return $ret;
	}

	/**
	* Return range filter field value
	*
	* @param Array $params
	* @return string
	*/
	function SearchField($params) // RangeValue
	{
	$field = $this->SelectParam($params, 'field,name');

	$view_name = $this->Application->RecallVar($this->getPrefixSpecial().'_current_view');
	$custom_filter = $this->Application->RecallPersistentVar($this->getPrefixSpecial().'_custom_filter.'.$view_name, ALLOW_DEFAULT_SETTINGS);
	$custom_filter = $custom_filter ? unserialize($custom_filter) : Array();

	if (isset($custom_filter[ $params['grid'] ][$field])) {
	$ret = $custom_filter[ $params['grid'] ][$field][ $params['filter_type'] ]['submit_value'];
	if (isset($params['type'])) {
	$ret = $ret[ $params['type'] ];
	}

	if( !$this->HasParam($params, 'no_special') ) $ret = htmlspecialchars($ret);
	return $ret;
	}

	return '';
	}

	function SearchFormat($params)
	{
	$field = $params['field'];
	$object =& $this->GetList($params);

	$options = $object->GetFieldOptions($field);

	$format = $options[ $this->SelectParam($params, 'input_format') ? 'input_format' : 'format' ];

	$formatter_class = getArrayValue($options,'formatter');
	if($formatter_class)
	{
	$formatter =& $this->Application->recallObject($formatter_class);
	$human_format = getArrayValue($params,'human');
	$edit_size = getArrayValue($params,'edit_size');
	$sample = getArrayValue($params,'sample');
	if($sample)
	{
	return $formatter->GetSample($field, $options, $object);
	}
	elseif($human_format \|\| $edit_size)
	{
	$format = $formatter->HumanFormat($format);
	return $edit_size ? strlen($format) : $format;
	}
	}

	return $format;
	}

	/**
	* Returns error of range field
	*
	* @param unknown_type $params
	* @return unknown
	*/
	function SearchError($params)
	{
	$field = $this->SelectParam($params, 'field,name');

	$error_var_name = $this->getPrefixSpecial().'_'.$field.'_error';
	$pseudo = $this->Application->RecallVar($error_var_name);
	if ($pseudo) {
	$this->Application->RemoveVar($error_var_name);
	}

	$object =& $this->Application->recallObject($this->Prefix.'.'.$this->Special.'-item', null, Array('skip_autoload' => true));
	/* @var $object kDBItem */

	$object->SetError($field, $pseudo);
	return $object->GetErrorMsg($field, false);
	}

	/**
	* Returns templates path for module, which is gathered from prefix module
	*
	* @param Array $params
	* @return string
	* @author Alex
	*/
	function ModulePath($params)
	{
	$force_module = getArrayValue($params, 'module');
	if ($force_module) {
	if ($force_module == '#session#') {
	$force_module = preg_replace('/([^:]):./', '\1', $this->Application->RecallVar('module'));
	if (!$force_module) $force_module = 'core';
	}
	else {
	$force_module = strtolower($force_module);
	}

	if ($force_module == 'core') {
	$module_folder = 'core';
	}
	else {
	$module_folder = trim( $this->Application->findModule('Name', $force_module, 'Path'), '/');
	}
	}
	else {
	$module_folder = $this->Application->getUnitOption($this->Prefix, 'ModuleFolder');
	}
	return '../../'.$module_folder.'/admin_templates/';
	}

	/**
	* Returns object used in tag processor
	*
	* @access public
	* @return kDBBase
	*/
	function &getObject($params = Array())
	{
	$object =& $this->Application->recallObject($this->getPrefixSpecial(), $this->Prefix, $params);
	if (isset($params['requery']) && $params['requery']) {
	$this->Application->HandleEvent($q_event, $this->getPrefixSpecial().':LoadItem');
	}
	return $object;
	}

	/**
	* Checks if object propery value matches value passed
	*
	* @param Array $params
	* @return bool
	*/
	function PropertyEquals($params)
	{
	$object =& $this->getObject($params);
	$property_name = $this->SelectParam($params, 'name,var,property');
	return $object->$property_name == $params['value'];
	}

	/**
	* Group list records by header, saves internal order in group
	*
	* @param Array $records
	* @param string $heading_field
	*/
	function groupRecords(&$records, $heading_field)
	{
	$sorted = Array();
	$i = 0; $record_count = count($records);
	while ($i < $record_count) {
	$sorted[ $records[$i][$heading_field] ][] = $records[$i];
	$i++;
	}

	$records = Array();
	foreach ($sorted as $heading => $heading_records) {
	$records = array_merge_recursive($records, $heading_records);
	}
	}

	function DisplayOriginal($params)
	{
	return false;
	}

	function MultipleEditing($params)
	{
	$wid = $this->Application->GetTopmostWid($this->Prefix);
	$session_name = rtrim($this->getPrefixSpecial().'_selected_ids_'.$wid, '_');
	$selected_ids = explode(',', $this->Application->RecallVar($session_name));

	$ret = '';
	if ($selected_ids) {
	$selected_ids = explode(',', $selected_ids);
	$object =& $this->getObject( array_merge_recursive2($params, Array('skip_autoload' => true)) );
	$params['name'] = $params['render_as'];
	foreach ($selected_ids as $id) {
	$object->Load($id);
	$ret .= $this->Application->ParseBlock($params);
	}
	}

	return $ret;
	}

	function ExportStatus($params)
	{
	$export_object =& $this->Application->recallObject('CatItemExportHelper');

	$event = new kEvent($this->getPrefixSpecial().':OnDummy');

	$action_method = 'perform'.ucfirst($this->Special);
	$field_values = $export_object->$action_method($event);

	// finish code is done from JS now
	if ($field_values['start_from'] >= $field_values['total_records'])
	{
	if ($this->Special == 'import') {
	$this->Application->StoreVar('PermCache_UpdateRequired', 1);
	$this->Application->Redirect('in-portal/categories/cache_updater', Array('m_opener' => 'r', 'pass' => 'm', 'continue' => 1, 'no_amp' => 1));
	}
	elseif ($this->Special == 'export') {
	$finish_t = $this->Application->RecallVar('export_finish_t');
	$this->Application->Redirect($finish_t, Array('pass' => 'all'));
	$this->Application->RemoveVar('export_finish_t');
	}
	}

	$export_options = $export_object->loadOptions($event);
	return $export_options['start_from'] * 100 / $export_options['total_records'];
	}

	/**
	* Returns path where exported category items should be saved
	*
	* @param Array $params
	*/
	function ExportPath($params)
	{
	$ret = EXPORT_PATH.'/';

	if( getArrayValue($params, 'as_url') )
	{
	$ret = str_replace( FULL_PATH.'/', $this->Application->BaseURL(), $ret);
	}

	$export_options = unserialize($this->Application->RecallVar($this->getPrefixSpecial().'_options'));
	$ret .= $export_options['ExportFilename'].'.'.($export_options['ExportFormat'] == 1 ? 'csv' : 'xml');

	return $ret;
	}

	function FieldTotal($params)
	{
	$list =& $this->GetList($params);

	return $list->GetFormattedTotal($this->SelectParam($params, 'field,name'), $params['function']);
	}

	function FCKEditor($params) {
	$params['no_special'] = 1;
	$value = $this->Field($params);
	$name = $this->InputName($params);

	$theme_path = $this->Application->BaseURL().substr($this->Application->GetFrontThemePath(), 1);

	$bgcolor = isset($params['bgcolor']) ? $params['bgcolor'] : $this->Application->GetVar('bgcolor');
	if (!$bgcolor) $bgcolor = '#ffffff';

	include_once(FULL_PATH.'/core/cmseditor/fckeditor.php');
	$oFCKeditor = new FCKeditor($name);
	$oFCKeditor->BasePath = BASE_PATH.'/core/cmseditor/';
	$oFCKeditor->Width = $params['width'] ;
	$oFCKeditor->Height = $params['height'] ;
	$oFCKeditor->ToolbarSet = 'Advanced' ;
	$oFCKeditor->Value = $value ;
	$oFCKeditor->Config = Array(
	//'UserFilesPath' => $pathtoroot.'kernel/user_files',
	'ProjectPath' => BASE_PATH.'/',
	'CustomConfigurationsPath' => $this->Application->BaseURL().'core/admin_templates/js/inp_fckconfig.js',
	'StylesXmlPath' => $theme_path.'/inc/styles.xml',
	'EditorAreaCSS' => $theme_path.'/inc/style.css',
	'DefaultClass' => 'Default Text',
	// 'Debug' => 1,
	'Admin' => 1,
	'K4' => 1,
	'newBgColor' => $bgcolor,
	);
	return $oFCKeditor->CreateHtml();
	}

	function IsNewItem($params)
	{
	$object =& $this->getObject($params);
	return $object->IsNewItem();
	}

	/**
	* Creates link to an item including only it's id
	*
	* @param Array $params
	* @return string
	*/
	function ItemLink($params)
	{
	$object =& $this->getObject($params);

	if (!isset($params['pass'])) {
	$params['pass'] = 'm';
	}

	$params[$object->getPrefixSpecial().'_id'] = $object->GetID();

	$m =& $this->Application->recallObject('m_TagProcessor');
	return $m->t($params);
	}

	function PresetFormFields($params)
	{
	$prefix = $this->getPrefixSpecial();
	if (!$this->Application->GetVar($prefix.'_event')) {
	$this->Application->HandleEvent(new kEvent($prefix.':OnNew'));
	}
	}

	function PrintSerializedFields($params)
	{
	$object =& $this->getObject();
	$field = $this->SelectParam($params, 'field');
	$data = unserialize($object->GetDBField($field));
	$o = '';
	$std_params['name'] = $params['render_as'];
	$std_params['field'] = $params['field'];
	$std_params['pass_params'] = true;
	foreach ($data as $key => $row) {
	$block_params = array_merge($std_params, $row, array('key'=>$key));
	$o .= $this->Application->ParseBlock($block_params);
	}
	return $o;
	}
	/**
	* Checks if current prefix is main item
	*
	* @param Array $params
	* @return bool
	*/
	function IsTopmostPrefix($params)
	{
	return $this->Prefix == $this->Application->GetTopmostPrefix($this->Prefix);
	}

	function PermSection($params)
	{
	$section = $this->SelectParam($params, 'section,name');
	$perm_sections = $this->Application->getUnitOption($this->Prefix, 'PermSection');
	return isset($perm_sections[$section]) ? $perm_sections[$section] : '';
	}

	function PerPageSelected($params)
	{
	$list =& $this->GetList($params);
	return $list->PerPage == $params['per_page'] ? $params['selected'] : '';
	}

	/**
	* Returns prefix + generated sepcial + any word
	*
	* @param Array $params
	* @return string
	*/
	function VarName($params)
	{
	$list =& $this->GetList($params);

	return $list->getPrefixSpecial().'_'.$params['type'];
	}

	/**
	* Returns edit tabs by specified preset name or false in case of error
	*
	* @param string $preset_name
	* @return mixed
	*/
	function getEditTabs($preset_name)
	{
	$presets = $this->Application->getUnitOption($this->Prefix, 'EditTabPresets');

	if (!$presets \|\| !isset($presets[$preset_name]) \|\| count($presets[$preset_name]) == 0) {
	return false;
	}

	return $presets[$preset_name];
	}

	/**
	* Detects if specified preset has tabs in it
	*
	* @param Array $params
	* @return bool
	*/
	function HasEditTabs($params)
	{
	return $this->getEditTabs($params['preset_name']) ? true : false;
	}

	/**
	* Sorts edit tabs based on their priority
	*
	* @param Array $tab_a
	* @param Array $tab_b
	* @return int
	*/
	function sortEditTabs($tab_a, $tab_b)
	{
	if ($tab_a['priority'] == $tab_b['priority']) {
	return 0;
	}

	return $tab_a['priority'] < $tab_b['priority'] ? -1 : 1;
	}

	/**
	* Prints edit tabs based on preset name specified
	*
	* @param Array $params
	* @return string
	*/
	function PrintEditTabs($params)
	{
	$edit_tabs = $this->getEditTabs($params['preset_name']);
	if (!$edit_tabs) {
	return ;
	}
	usort($edit_tabs, Array (&$this, 'sortEditTabs'));

	$ret = '';
	$block_params = $this->prepareTagParams($params);
	$block_params['name'] = $params['render_as'];

	foreach ($edit_tabs as $tab_info) {
	$block_params['title'] = $tab_info['title'];
	$block_params['template'] = $tab_info['t'];
	$ret .= $this->Application->ParseBlock($block_params);
	}

	return $ret;
	}

	/**
	* Performs image resize to required dimensions and returns resulting url (cached resized image)
	+ * Do not uncomment this method, because kCatDBTagProcessor uses same method,
	+ * but it is invoked via aggregated tag, which brokes down, when this method is uncommented
	*
	* @param Array $params
	* @return string
	*/
	- function ImageSrc($params)
	+ /*function ImageSrc($params)
	{
	$max_width = isset($params['MaxWidth']) ? $params['MaxWidth'] : false;
	$max_height = isset($params['MaxHeight']) ? $params['MaxHeight'] : false;

	$logo_filename = isset($params['LogoFilename']) ? $params['LogoFilename'] : false;
	$logo_h_margin = isset($params['LogoHMargin']) ? $params['LogoHMargin'] : false;
	$logo_v_margin = isset($params['LogoVMargin']) ? $params['LogoVMargin'] : false;
	$object =& $this->getObject($params);

	$field = $this->SelectParam($params, 'name,field');
	return $object->GetField($field, 'resize:'.$max_width.'x'.$max_height.';wm:'.$logo_filename.'\|'.$logo_h_margin.'\|'.$logo_v_margin);
	- }
	+ }*/
	}

	?>
	\ No newline at end of file

	Property changes on: branches/RC/core/kernel/db/db_tag_processor.php
	___________________________________________________________________
	Modified: cvs2svn:cvs-rev
	## -1 +1 ##
	-1.97.2.9
	\ No newline at end of property
	+1.97.2.10
	\ 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 9642)
	+++ branches/RC/core/units/admin/admin_events_handler.php (revision 9643)
	@@ -1,450 +1,451 @@
	<?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);
	}

	function OnResetModRwCache(&$event)
	{
	$this->Conn->Query('DELETE FROM '.TABLE_PREFIX.'Cache WHERE VarName LIKE "mod_rw%"');
	}

	function OnResetCMSMenuCache(&$event)
	{
	$this->Conn->Query('DELETE FROM '.TABLE_PREFIX.'Cache WHERE VarName = "cms_menu"');
	}

	function OnResetSections(&$event)
	{
	$this->Conn->Query('DELETE FROM '.TABLE_PREFIX.'Cache WHERE VarName = "sections_parsed"');
	}

	function OnResetConfigsCache(&$event)
	{
	$this->Conn->Query('DELETE FROM '.TABLE_PREFIX.'Cache WHERE VarName = "config_files" OR VarName = "configs_parsed" OR VarName = "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)
	{
	$themes_helper =& $this->Application->recallObject('ThemesHelper');
	/* @var $themes_helper kThemesHelper */

	$themes_helper->refreshThemes();
	}

	function OnSaveColumns(&$event) {
	/* @var $picker_helper kColumnPickerHelper */
	$picker_helper =& $this->Application->RecallObject('ColumnPickerHelper');
	$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;
	}

	function OnCheckPrefixConfig(&$event)
	{
	$prefix = $this->Application->GetVar('config_prefix');
	$cfg =& $this->Application->recallObject('kConfigReflection');
	/* @var $cfg kConfigReflection */
	$cfg->LoadConfig($prefix);
	$event->redirect = false;
	}

	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.7
	\ No newline at end of property
	+1.8.2.8
	\ No newline at end of property
	Index: branches/RC/core/units/admin/admin_tag_processor.php
	===================================================================
	--- branches/RC/core/units/admin/admin_tag_processor.php (revision 9642)
	+++ branches/RC/core/units/admin/admin_tag_processor.php (revision 9643)
	@@ -1,907 +1,914 @@
	<?php

	class AdminTagProcessor extends kDBTagProcessor {

	function SetConst($params)
	{
	$name = $this->SelectParam($params, 'name,const');
	safeDefine($name, $params['value']);
	}

	/**
	* Allows to execute js script after the page is fully loaded
	*
	* @param Array $params
	* @return string
	*/
	function AfterScript($params)
	{
	$after_script = $this->Application->GetVar('after_script');
	if ($after_script) {
	return '<script type="text/javascript">'.$after_script.'</script>';
	}
	return '';
	}

	/**
	* Returns section title with #section# keyword replaced with current section
	*
	* @param Array $params
	* @return string
	*/
	function GetSectionTitle($params)
	{
	$params['name'] = replaceModuleSection($params['phrase']);
	$m =& $this->Application->recallObject('m_TagProcessor');
	return $m->Phrase($params);
	}

	/**
	* Returns section icon with #section# keyword replaced with current section
	*
	* @param Array $params
	* @return string
	*/
	function GetSectionIcon($params)
	{
	return replaceModuleSection($params['icon']);
	}

	/**
	* Allows to detect if current template is one of listed ones
	*
	* @param Array $params
	* @return int
	*/
	function TemplateMatches($params)
	{
	$templates = explode(',' ,$params['templates']);
	$t = $this->Application->GetVar('t');
	return in_array($t, $templates) ? 1 : 0;
	}

	/**
	* Save return script in cases, when old sections are opened from new sections
	*
	* @param Array $params
	*/
	function SaveReturnScript($params)
	{
	// admin/save_redirect.php?do=
	$m =& $this->Application->recallObject('m_TagProcessor');
	$url = str_replace($this->Application->BaseURL(), '', $m->Link($params) );
	$url = explode('?', $url, 2);
	$url = 'save_redirect.php?'.$url[1].'&do='.$url[0];

	$this->Application->StoreVar('ReturnScript', $url);
	}

	/**
	* Redirects to correct next import step template based on import script data
	*
	* @param Array $params
	*/
	function ImportRedirect($params)
	{
	$import_id = $this->Application->GetVar('import_id');
	if ($import_id) {
	// redirect forward to step3 (import parameters coosing)
	$this->Application->StoreVar('ImportScriptID', $import_id);

	$sql = 'SELECT *
	FROM '.TABLE_PREFIX.'ImportScripts
	WHERE is_id = '.$import_id;

	$db =& $this->Application->GetADODBConnection();
	$is_params = $db->GetRow($sql);

	if ($is_params['is_type'] == 'db') {
	$this->Application->Redirect('', null, '', 'import/step3.php');
	}
	elseif ($is_params['is_type'] == 'csv') {
	$module = strtolower($is_params['is_Module']);
	$template = $module.'/import';
	$module_info = $this->Application->findModule('Name', $module);

	$item_prefix = $module_info['Var'];
	$pass_params = Array('m_opener' => 'd', $item_prefix.'.import_id' => 0, $item_prefix.'.import_event' => 'OnNew', 'pass' => 'm,'.$item_prefix.'.import', 'm_cat_id' => $module_info['RootCat']);

	$this->Application->Redirect($template, $pass_params);
	}
	}
	else {
	// redirect back to step2 (import type choosing)
	$this->Application->Redirect('', null, '', 'import/step2.php');
	}
	}

	/**
	* Returns version of module by name
	*
	* @param Array $params
	* @return string
	*/
	function ModuleVersion($params)
	{
	return $this->Application->findModule('Name', $params['module'], 'Version');
	}

	/**
	* Used in table form section drawing
	*
	* @param Array $params
	* @return string
	*/
	function DrawTree($params)
	{
	static $deep_level = 0;

	// when processings, then sort children by priority (key of children array)
	$ret = '';
	$section_name = $params['section_name'];
	$params['name'] = $this->SelectParam($params, 'name,render_as,block');
	$sections_helper =& $this->Application->recallObject('SectionsHelper');
	$section_data =& $sections_helper->getSectionData($section_name);

	$params['children_count'] = isset($section_data['children']) ? count($section_data['children']) : 0;
	$params['deep_level'] = $deep_level++;
	$template = $section_data['url']['t'];
	unset($section_data['url']['t']);
	$section_data['section_url'] = $this->Application->HREF($template, '', $section_data['url']);
	$ret .= $this->Application->ParseBlock( array_merge_recursive2($params, $section_data) );
	if (!isset($section_data['children'])) {
	return $ret;
	}

	$debug_mode = $this->Application->isDebugMode();
	$super_admin_mode = $this->Application->RecallVar('super_admin');

	ksort($section_data['children'], SORT_NUMERIC);
	foreach ($section_data['children'] as $section_name) {
	$section_data =& $sections_helper->getSectionData($section_name);

	if (isset($section_data['show_mode']) && is_numeric($section_data['show_mode'])) {
	$show_mode = $section_data['show_mode'];
	// if super admin section -> show in super admin mode & debug mode
	$show_section = (($show_mode & smSUPER_ADMIN) == smSUPER_ADMIN) && ($super_admin_mode \|\| $debug_mode);
	if (!$show_section) {
	// if section is in debug mode only && debug mode -> show
	$show_section = (($show_mode & smDEBUG) == smDEBUG) && $debug_mode;
	}
	if (!$show_section) {
	continue;
	}
	}

	$params['section_name'] = $section_name;
	$ret .= $this->DrawTree($params);
	$deep_level--;
	}


	return $ret;
	}


	function SectionInfo($params)
	{
	$section = $params['section'];
	if ($section == '#session#') {
	$section = $this->Application->RecallVar('section');
	}

	$sections_helper =& $this->Application->recallObject('SectionsHelper');
	/* @var $sections_helper kSectionsHelper */

	$section_data =& $sections_helper->getSectionData($section);

	if (isset($params['parent']) && $params['parent']) {
	do {
	$section_data =& $sections_helper->getSectionData($section_data['parent']);
	} while (isset($section_data['use_parent_header']) && $section_data['use_parent_header']);
	}

	$info = $params['info'];
	switch ($info) {
	case 'module_path':
	if (isset($params['module']) && $params['module']) {
	$module = $params['module'];
	}
	elseif (isset($section_data['icon_module'])) {
	$module = $section_data['icon_module'];
	}
	else {
	$module = '#session#';
	}
	$res = $this->ModulePath(array('module' => $module));
	break;

	case 'perm_section':
	$res = $sections_helper->getPermSection($section);
	break;

	default:
	$res = $section_data[$info];
	}

	if ($info == 'label' \|\| isset($params['as_label'])) {
	$res = $this->Application->Phrase($res);
	}
	return $res;
	}


	function PrintSection($params)
	{
	$section_name = $params['section_name'];
	if ($section_name == '#session#') {
	$section_name = $this->Application->RecallVar('section');
	}

	$sections_helper =& $this->Application->recallObject('SectionsHelper');
	/* @var $sections_helper kSectionsHelper */

	if (isset($params['use_first_child']) && $params['use_first_child']) {
	$section_name = $sections_helper->getFirstChild($section_name, true);
	}

	$section_data =& $sections_helper->getSectionData($section_name);

	$params['name'] = $this->SelectParam($params, 'name,render_as,block');
	$params['section_name'] = $section_name;

	$template = $section_data['url']['t'];
	unset($section_data['url']['t']);

	$section_data['section_url'] = $this->Application->HREF($template, '', $section_data['url']);
	$ret = $this->Application->ParseBlock( array_merge_recursive2($params, $section_data) );

	return $ret;
	}

	/**
	* Used in XML drawing for tree
	*
	* @param Array $params
	* @return string
	*/
	function PrintSections($params)
	{
	// when processings, then sort children by priority (key of children array)
	$ret = '';
	$section_name = $params['section_name'];
	if ($section_name == '#session#') {
	$section_name = $this->Application->RecallVar('section');
	}

	$sections_helper =& $this->Application->recallObject('SectionsHelper');
	/* @var $sections_helper kSectionsHelper */

	$section_data =& $sections_helper->getSectionData($section_name);

	$params['name'] = $this->SelectParam($params, 'name,render_as,block');
	if (!isset($section_data['children'])) {
	return '';
	}

	$debug_mode = $this->Application->isDebugMode();
	$super_admin_mode = $this->Application->RecallVar('super_admin');

	ksort($section_data['children'], SORT_NUMERIC);
	foreach ($section_data['children'] as $section_name) {
	$params['section_name'] = $section_name;
	$section_data =& $sections_helper->getSectionData($section_name);

	if (isset($section_data['show_mode']) && is_numeric($section_data['show_mode'])) {
	$show_mode = $section_data['show_mode'];
	// if super admin section -> show in super admin mode & debug mode
	$show_section = (($show_mode & smSUPER_ADMIN) == smSUPER_ADMIN) && ($super_admin_mode \|\| $debug_mode);
	if (!$show_section) {
	// if section is in debug mode only && debug mode -> show
	$show_section = (($show_mode & smDEBUG) == smDEBUG) && $debug_mode;
	}
	if (!$show_section) {
	continue;
	}
	}

	if (isset($section_data['tabs_only']) && $section_data['tabs_only']) {
	$perm_status = false;
	$folder_label = $section_data['label'];
	ksort($section_data['children'], SORT_NUMERIC);
	foreach ($section_data['children'] as $priority => $section_name) {
	// if only tabs in this section & none of them have permission, then skip section too

	$section_name = $sections_helper->getPermSection($section_name);
	$perm_status = $this->Application->CheckPermission($section_name.'.view', 1);
	if ($perm_status) {
	break;
	}
	}
	if (!$perm_status) {
	// no permission for all tabs -> don't display tree node either
	continue;
	}

	$params['section_name'] = $section_name;
	$section_data =& $sections_helper->getSectionData($section_name);
	$section_data['label'] = $folder_label; // use folder label in tree
	$section_data['is_tab'] = 1;
	}
	else {
	$section_name = $sections_helper->getPermSection($section_name);
	if (!$this->Application->CheckPermission($section_name.'.view', 1)) continue;
	}

	$params['children_count'] = isset($section_data['children']) ? count($section_data['children']) : 0;

	$template = $section_data['url']['t'];
	unset($section_data['url']['t']);

	$section_data['section_url'] = $this->Application->HREF($template, '', $section_data['url']);

	$late_load = getArrayValue($section_data, 'late_load');
	if ($late_load) {
	$t = $late_load['t'];
	unset($late_load['t']);
	$section_data['late_load'] = $this->Application->HREF($t, '', $late_load);
	$params['children_count'] = 99;
	}
	else {
	$section_data['late_load'] = '';
	}

	$ret .= $this->Application->ParseBlock( array_merge_recursive2($params, $section_data) );
	$params['section_name'] = $section_name;
	}

	return preg_replace("/\r\n\|\n/", '', $ret);
	}

	function ListSectionPermissions($params)
	{
	$section_name = isset($params['section_name']) ? $params['section_name'] : $this->Application->GetVar('section_name');
	$sections_helper =& $this->Application->recallObject('SectionsHelper');
	$section_data =& $sections_helper->getSectionData($section_name);

	$block_params = array_merge_recursive2($section_data, Array('name' => $params['render_as'], 'section_name' => $section_name));

	$ret = '';
	foreach ($section_data['permissions'] as $perm_name) {
	if (preg_match('/^advanced:(.*)/', $perm_name) != $params['type']) continue;
	$block_params['perm_name'] = $perm_name;
	$ret .= $this->Application->ParseBlock($block_params);
	}
	return $ret;
	}

	function ModuleInclude($params)
	{
	foreach ($params as $param_name => $param_value) {
	$params[$param_name] = replaceModuleSection($param_value);
	}

	$m =& $this->Application->recallObject('m_TagProcessor');
	return $m->ModuleInclude($params);
	}

	function TodayDate($params)
	{
	return date($params['format']);
	}

	function TreeEditWarrning($params)
	{
	$ret = $this->Application->Phrase($params['label']);
	$ret = str_replace(Array('<', '>', 'br/', 'br /', "\n", "\r"), Array('<', '>', 'br', 'br', '', ''), $ret);
	if (getArrayValue($params, 'escape')) {
	$ret = addslashes($ret);
	}
	$ret = str_replace('<br>', '\n', $ret);
	return $ret;
	}

	/**
	* Draws section tabs using block name passed
	*
	* @param Array $params
	*/
	function ListTabs($params)
	{
	$sections_helper =& $this->Application->recallObject('SectionsHelper');
	$section_data =& $sections_helper->getSectionData($params['section_name']);

	$ret = '';
	$block_params = Array('name' => $params['render_as']);
	ksort($section_data['children'], SORT_NUMERIC);
	foreach ($section_data['children'] as $priority => $section_name) {
	if (!$this->Application->CheckPermission($section_name.'.view', 1)) continue;

	$tab_data =& $sections_helper->getSectionData($section_name);
	$block_params['t'] = $tab_data['url']['t'];
	$block_params['title'] = $tab_data['label'];
	$block_params['main_prefix'] = $section_data['SectionPrefix'];
	$ret .= $this->Application->ParseBlock($block_params);
	}


	return $ret;
	}

	/**
	* Returns list of module item tabs that have view permission in current category
	*
	* @param Array $params
	*/
	function ListCatalogTabs($params)
	{
	$ret = '';
	$special = isset($params['special']) ? $params['special'] : '';
	$replace_main = isset($params['replace_m']) && $params['replace_m'];
	$skip_prefixes = isset($params['skip_prefixes']) ? explode(',', $params['skip_prefixes']) : Array();
	$block_params = Array('name' => $params['render_as']);
	foreach ($this->Application->ModuleInfo as $module_name => $module_info) {
	$prefix = $module_info['Var'];

	if (in_array($prefix, $skip_prefixes) \|\| !$this->Application->prefixRegistred($prefix) \|\| !$this->Application->getUnitOption($prefix, 'CatalogItem')) continue;
	if ($prefix == 'm' && $replace_main) $prefix = 'c';
	$label = $this->Application->getUnitOption($prefix, $params['title_property']);
	$block_params['title'] = $label;
	$block_params['prefix'] = $prefix;
	$ret .= $this->Application->ParseBlock($block_params);
	}
	return $ret;
	}

	function FCKEditor($params)
	{
	if (file_exists(FULL_PATH.'/core/cmseditor/fckeditor.php')) {
	$editor_path = 'core/cmseditor/';
	}
	else {
	$editor_path = 'admin/editor/cmseditor/';
	}
	include_once(FULL_PATH.'/'.$editor_path.'/fckeditor.php');
	$oFCKeditor = new FCKeditor($params['name']);
	$oFCKeditor->BasePath = BASE_PATH.'/'.$editor_path;
	$oFCKeditor->Width = $params['width'] ;
	$oFCKeditor->Height = $params['height'] ;
	$oFCKeditor->ToolbarSet = 'Advanced' ;
	$oFCKeditor->Value = '' ;

	if ($this->Application->isModuleEnabled('In-Portal')) {
	$config_path = $this->Application->BaseURL().'kernel/admin_templates/incs/inp_fckconfig.js';
	}
	else {
	$config_path = $this->Application->BaseURL().'core/admin_templates/js/inp_fckconfig.js';
	}

	$oFCKeditor->Config = Array(
	// 'UserFilesPath' => FULL_PATH.'/kernel/user_files',
	'ProjectPath' => BASE_PATH.'/',
	'CustomConfigurationsPath' => $config_path,
	// 'EditorAreaCSS' => $this->Application->BaseURL().'/themes/inportal_site/inc/inportal.css', //GetThemeCSS(),
	//'StylesXmlPath' => '../../inp_styles.xml',
	// 'Debug' => 1,
	'Admin' => 1,
	'K4' => 1,
	);
	return $oFCKeditor->CreateHtml();

	}

	/**
	* Allows to construct link for opening any type of catalog item selector
	*
	* @param Array $params
	* @return string
	*/
	function SelectorLink($params)
	{
	$mode = 'catalog';
	if (isset($params['mode'])) { // {catalog, advanced_view}
	$mode = $params['mode'];
	unset($params['mode']);
	}

	$params['t'] = 'in-portal/item_selector/item_selector_'.$mode;

	$default_params = Array('no_amp' => 1, 'pass' => 'all,'.$params['prefix']);
	unset($params['prefix']);

	$pass_through = Array();
	if (isset($params['tabs_dependant'])) { // {yes, no}
	$pass_through['td'] = $params['tabs_dependant'];
	unset($params['tabs_dependant']);
	}

	if (isset($params['selection_mode'])) { // {single, multi}
	$pass_through['tm'] = $params['selection_mode'];
	unset($params['selection_mode']);
	}

	if (isset($params['tab_prefixes'])) { // {all, none, <comma separated prefix list}
	$pass_through['tp'] = $params['tab_prefixes'];
	unset($params['tab_prefixes']);
	}

	if ($pass_through) {
	// add pass_through to selector url if any
	$params['pass_through'] = implode(',', array_keys($pass_through));
	$params = array_merge_recursive2($params, $pass_through);
	}

	// user can override default parameters (except pass_through of course)
	$params = array_merge_recursive2($default_params, $params);

	$main_processor =& $this->Application->recallObject('m_TagProcessor');
	return $main_processor->T($params);
	}

	function TimeFrame($params)
	{
	$w = adodb_date('w');
	$m = adodb_date('m');
	$y = adodb_date('Y');
	//FirstDayOfWeek is 0 for Sunday and 1 for Monday
	$fdow = $this->Application->ConfigValue('FirstDayOfWeek');
	if ($fdow && $w == 0) $w = 7;
	$today_start = adodb_mktime(0,0,0,adodb_date('m'),adodb_date('d'),$y);
	$first_day_of_this_week = $today_start - ($w - $fdow)*86400;
	$first_day_of_this_month = adodb_mktime(0,0,0,$m,1,$y);
	$this_quater = ceil($m/3);
	$this_quater_start = adodb_mktime(0,0,0,$this_quater*3-2,1,$y);

	switch ($params['type']) {
	case 'last_week_start':
	$timestamp = $first_day_of_this_week - 86400*7;
	break;
	case 'last_week_end':
	$timestamp = $first_day_of_this_week - 1;
	break;

	case 'last_month_start':
	$timestamp = $m == 1 ? adodb_mktime(0,0,0,12,1,$y-1) : adodb_mktime(0,0,0,$m-1,1,$y);
	break;
	case 'last_month_end':
	$timestamp = $first_day_of_this_month = adodb_mktime(0,0,0,$m,1,$y) - 1;
	break;

	case 'last_quater_start':
	$timestamp = $this_quater == 1 ? adodb_mktime(0,0,0,10,1,$y-1) : adodb_mktime(0,0,0,($this_quater-1)*3-2,1,$y);
	break;
	case 'last_quater_end':
	$timestamp = $this_quater_start - 1;
	break;

	case 'last_6_months_start':
	$timestamp = $m <= 6 ? adodb_mktime(0,0,0,$m+6,1,$y-1) : adodb_mktime(0,0,0,$m-6,1,$y);
	break;

	case 'last_year_start':
	$timestamp = adodb_mktime(0,0,0,1,1,$y-1);
	break;
	case 'last_year_end':
	$timestamp = adodb_mktime(23,59,59,12,31,$y-1);
	break;
	}


	if (isset($params['format'])) {
	$format = $params['format'];
	if(preg_match("/_regional_(.*)/", $format, $regs))
	{
	$lang =& $this->Application->recallObject('lang.current');
	$format = $lang->GetDBField($regs[1]);
	}
	return adodb_date($format, $timestamp);
	}

	return $timestamp;

	}
	function CheckPermCache($params)
	{
	if ($this->Conn->GetOne('SELECT Data FROM '.TABLE_PREFIX.'Cache WHERE VarName = \'ForcePermCacheUpdate\'')) {
	$this->Application->Redirect($params['cache_update_t'], array('continue' => 1));
	}
	}
	/**
	* Checks if current protocol is SSL
	*
	* @param Array $params
	* @return int
	*/
	function IsSSL($params)
	{
	return (PROTOCOL == 'https://')? 1 : 0;
	}

	function PrintColumns($params)
	{
	$picker_helper =& $this->Application->RecallObject('ColumnPickerHelper');
	$picker_helper->SetGridName($this->Application->GetLinkedVar('grid_name'));
	/* @var $picker_helper kColumnPickerHelper */

	$main_prefix = $this->Application->RecallVar('main_prefix');
	$cols = $picker_helper->LoadColumns($main_prefix);

	$this->Application->Phrases->AddCachedPhrase('__FREEZER__', '-------------');

	$o = '';
	if (isset($params['hidden']) && $params['hidden']) {
	foreach ($cols['hidden_fields'] as $col) {
	$title = $this->Application->Phrase($cols['titles'][$col]);
	$o .= "<option value='$col'>".$title;
	}
	}
	else {
	foreach ($cols['order'] as $col) {
	if (in_array($col, $cols['hidden_fields'])) continue;
	$title = $this->Application->Phrase($cols['titles'][$col]);
	$o .= "<option value='$col'>".$title;
	}
	}
	return $o;
	}

	/**
	* Allows to set popup size (key - current template name)
	*
	* @param Array $params
	*/
	function SetPopupSize($params)
	{
	if (!$this->UsePopups($params)) return ;

	$width = $params['width'];
	$height = $params['height'];

	if ($this->Application->GetVar('ajax') == 'yes') {
	// during AJAX request just output size
	die($width.'x'.$height);
	}

	$t = $this->Application->GetVar('t');
	$sql = 'SELECT *
	FROM '.TABLE_PREFIX.'PopupSizes
	WHERE TemplateName = '.$this->Conn->qstr($t);
	$popup_info = $this->Conn->GetRow($sql);
	if (!$popup_info) {
	// create new popup size record
	$fields_hash = Array (
	'TemplateName' => $t,
	'PopupWidth' => $width,
	'PopupHeight' => $height,
	);
	$this->Conn->doInsert($fields_hash, TABLE_PREFIX.'PopupSizes');
	}
	elseif ($popup_info['PopupWidth'] != $width \|\| $popup_info['PopupHeight'] != $height) {
	// popup found and size in tag differs from one in db -> update in db
	$fields_hash = Array (
	'PopupWidth' => $width,
	'PopupHeight' => $height,
	);
	$this->Conn->doUpdate($fields_hash, TABLE_PREFIX.'PopupSizes', 'PopupId = '.$popup_info['PopupId']);
	}
	}

	/**
	* Returns popup size (by template), if not cached, then parse template to get value
	*
	* @param Array $params
	* @return string
	*/
	function GetPopupSize($params)
	{
	$t = $this->Application->GetVar('template_name');
	$sql = 'SELECT *
	FROM '.TABLE_PREFIX.'PopupSizes
	WHERE TemplateName = '.$this->Conn->qstr($t);
	$popup_info = $this->Conn->GetRow($sql);
	if (!$popup_info) {
	$this->Application->InitParser();
	$this->Application->ParseBlock(array('name' => $t)); // dies when SetPopupSize tag found & in ajax requrest
	return '750x400'; // tag SetPopupSize not found in template -> use default size
	}
	return $popup_info['PopupWidth'].'x'.$popup_info['PopupHeight'];
	}

	function UsePopups($params)
	{
	return (int)$this->Application->ConfigValue('UsePopups');
	}

	function UseToolbarLabels($params)
	{
	return (int)$this->Application->ConfigValue('UseToolbarLabels');
	}

	/**
	* Checks if debug mode enabled (optionally) and specified constant is on
	*
	* @param Array $params
	* @return bool
	*/
	function ConstOn($params)
	{
	$constant_name = $this->SelectParam($params, 'name,const');
	$debug_mode = isset($params['debug_mode']) && $params['debug_mode'] ? $this->Application->isDebugMode() : true;
	return $debug_mode && constOn($constant_name);
	}

	/**
	* Builds link to last template in main frame of admin
	*
	* @param Array $params
	* @return string
	*/
	function MainFrameLink($params)
	{
	$persistent = isset($params['persistent']) && $params['persistent'];
	if ($persistent) {
	// check last_template in persistent session
	$last_template = $this->Application->RecallPersistentVar('last_template_popup');
	}
	else {
	// check last_template in session
	$last_template = $this->Application->RecallVar('last_template_popup'); // because of m_opener=s there
	}

	if (!$last_template) {
	$params['persistent'] = 1;
	return $persistent ? false : $this->MainFrameLink($params);
	}

	list($index_file, $env) = explode('\|', $last_template);
	$vars = $this->Application->HttpQuery->processQueryString($env, 'pass');
	$recursion_templates = Array ('login', 'index', 'no_permission');

	if (isset($vars['admin']) && $vars['admin'] == 1) {
	// index template doesn't begin recursion on front-end (in admin frame)
	$vars['m_theme'] = '';

	if (isset($params['m_opener']) && $params['m_opener'] == 'r') {
	// front-end link for highlighting purposes
	$vars['t'] = 'index';
	$vars['m_cat_id'] = $this->Application->findModule('Name', 'Proj-CMS', 'RootCat');
	}

	unset($recursion_templates[ array_search('index', $recursion_templates)]);
	}

	if (in_array($vars['t'], $recursion_templates)) {
	// prevents redirect recursion OR old in-portal pages
	$params['persistent'] = 1;
	return $persistent ? false : $this->MainFrameLink($params);
	}

	$vars = array_merge_recursive2($vars, $params);
	$t = $vars['t'];
	unset($vars['t'], $vars['persistent']);

	return $this->Application->HREF($t, '', $vars, $index_file);
	}

	+ /**
	+ * Returns menu frame width or 200 in case, when invalid width specified in config
	+ *
	+ * @param Array $params
	+ * @return string
	+ */
	function MenuFrameWidth($params)
	{
	- $w = $this->Application->ConfigValue('MenuFrameWidth');
	- if (!$w) $w = 200;
	- return $w;
	+ $width = (int)$this->Application->ConfigValue('MenuFrameWidth');
	+
	+ return $width > 0 ? $width : 200;
	}
	+
	function AdminSkin($params)
	{
	static $style;
	if (!isset($style)) {
	$style = $this->Conn->GetRow('SELECT * FROM '.TABLE_PREFIX.'Skins WHERE IsPrimary = 1');
	}

	$css_path = (defined('WRITEABLE') ? WRITEABLE : FULL_PATH.'/kernel').'/user_files';
	$css_url = $this->Application->BaseURL(defined('WRITEBALE_BASE') ? WRITEBALE_BASE : '/kernel').'user_files/';

	if (isset($params['type']) && $params['type'] == 'logo') {
	return $style['Logo'] ? $css_url.$style['Logo'] : '';
	}

	$last_compiled = $style['LastCompiled'];

	$style_name = strtolower( $style['Name'] );

	if( file_exists($css_path.'/'.'admin-'.$style_name.'-'.$last_compiled.'.css') )
	{
	$ret = $css_url.'admin-'.$style_name.'-'.$last_compiled.'.css';

	}
	else
	{
	// search for previously compiled stylesheet
	$last_compiled = 0;
	if( $dh = opendir($css_path) )
	{
	while( ($file = readdir($dh)) !== false )
	{
	if( preg_match('/admin-(.*)-([\d]+).css/', $file, $rets) )
	{
	if( $rets[1] == $style_name && $rets[2] > $last_compiled ) $last_compiled = $rets[2];
	}
	}
	closedir($dh);
	}
	if ($last_compiled) {
	// found
	$ret = $css_url.'admin-'.$style_name.'-'.$last_compiled.'.css';
	}
	else {
	// not found (try to compile on the fly)
	$object =& $this->Application->recallObject('skin.-item', null, Array ('skip_autoload' => true));
	/* @var $object kDBItem */

	$skin_eh =& $this->Application->recallObject('skin_EventHandler');
	/* @var $skin_eh SkinEventHandler */

	$object->Load(1, 'IsPrimary');
	$skin_eh->Compile($object);
	$ret = $css_url.'admin-'.$style_name.'-'.adodb_mktime().'.css';
	}
	}

	if (isset($params['file_only'])) return $ret;

	return '<link rel="stylesheet" rev="stylesheet" href="'.$ret.'" type="text/css" media="screen" />';
	}

	function PrintCompileErrors($params)
	{
	$errors = unserialize($this->Application->RecallVar('compile_errors'));
	$o = '<table style="width: 100%;" border="1"><tr><td><b>File</b></td><td><b>Line</b></td><td><b>Message</b></td></tr>';
	foreach ($errors as $an_error) {
	$f = str_replace(FULL_PATH, '', $an_error['file']);
	$o .= "<tr><td>{$f}</td><td>{$an_error['line']}</td><td>{$an_error['msg']}</td></tr>";
	}
	$o .= '</table>';
	$this->Application->RemoveVar('compile_errors');
	return $o;
	}
	-
	+
	function ExportData($params)
	{
	$export_helper =& $this->Application->recallObject('CSVHelper');
	/* @var $export_helper kCSVHelper */
	$result = $export_helper->ExportData( $this->SelectParam($params, 'var,name,field') );
	return ($result === false) ? '' : $result;
	}

	function ImportData($params)
	{
	$import_helper =& $this->Application->recallObject('CSVHelper');
	/* @var $import_helper kCSVHelper */
	$result = $import_helper->ImportData( $this->SelectParam($params, 'var,name,field') );
	return ($result === false) ? '' : $result;
	}

	function PrintCSVNotImportedLines($params)
	{
	$import_helper =& $this->Application->recallObject('CSVHelper');
	/* @var $import_helper kCSVHelper */
	return $import_helper->GetNotImportedLines();
	}

	/**
	* Returns input field name to
	* be placed on form (for correct
	* event processing)
	*
	* @param Array $params
	* @return string
	* @access public
	*/
	function InputName($params)
	{
	list($id, $field) = $this->prepareInputName($params);

	$ret = $this->getPrefixSpecial().'[0]['.$field.']'; // 0 always, as has no idfield
	if( getArrayValue($params, 'as_preg') ) $ret = preg_quote($ret, '/');
	return $ret;
	}
	}
	?>
	\ No newline at end of file

	Property changes on: branches/RC/core/units/admin/admin_tag_processor.php
	___________________________________________________________________
	Modified: cvs2svn:cvs-rev
	## -1 +1 ##
	-1.43.2.5
	\ No newline at end of property
	+1.43.2.6
	\ No newline at end of property
	Index: branches/RC/core/units/general/helpers/search_helper.php
	===================================================================
	--- branches/RC/core/units/general/helpers/search_helper.php (revision 9642)
	+++ branches/RC/core/units/general/helpers/search_helper.php (revision 9643)
	@@ -1,568 +1,568 @@
	<?php

	class kSearchHelper extends kHelper {


	/**
	* Splits search phrase into keyword using quotes,plus and minus sings and spaces as split criteria
	*
	* @param string $keyword
	* @return string
	*/
	function splitKeyword($keyword)
	{
	$quotes_re = '/([+\-]?)"(.*?)"/';
	$no_quotes_re = '/([+\-]?)([^ ]+)/';

	$quoted_kw = preg_match_all($quotes_re, $keyword, $res);
	foreach ($res[2] as $index => $kw) $final[$kw] = $res[1][$index];
	$keyword = preg_replace($quotes_re, '', $keyword);
	$not_quoted_kw = preg_match_all($no_quotes_re, $keyword, $res);
	foreach ($res[2] as $index => $kw) $final[$kw] = $res[1][$index];

	return $final;
	}

	function getPositiveKeywords($keyword)
	{
	$keywords = $this->splitKeyword($keyword);

	$ret = Array();
	foreach ($keywords as $keyword => $sign) {
	if ($sign == '+' \|\| $sign == '') {
	$ret[] = $keyword;
	}
	}
	return $ret;
	}

	function buildWhereClause($keyword, $fields)
	{
	$keywords = $this->splitKeyword($keyword);

	$normal_conditions = Array();
	$plus_conditions = Array();
	$minus_conditions = Array();

	foreach ($keywords as $keyword => $sign) {
	switch ($sign) {
	case '+':
	$plus_conditions[] = implode(' LIKE "%'.$keyword.'%" OR ', $fields).' LIKE "%'.$keyword.'%"';
	break;

	case '-':
	foreach ($fields as $field) {
	$condition[] = $field.' NOT LIKE "%'.$keyword.'%" OR '.$field.' IS NULL';
	}
	$minus_conditions[] = '('.implode(') AND (', $condition).')';
	break;

	case '':
	$keyword = str_replace('"', '\"', $keyword);
	$normal_conditions[] = implode(' LIKE "%'.$keyword.'%" OR ', $fields).' LIKE "%'.$keyword.'%"';
	break;
	}
	}

	// building where clause
	if ($normal_conditions) {
	$where_clause = '('.implode(') OR (', $normal_conditions).')';
	}
	else {
	$where_clause = '1';
	}

	if ($plus_conditions) {
	$where_clause = '('.$where_clause.') AND ('.implode(') AND (', $plus_conditions).')';
	}

	if ($minus_conditions) {
	$where_clause = '('.$where_clause.') AND ('.implode(') AND (', $minus_conditions).')';
	}

	return $where_clause;
	}

	/**
	* Returns additional information about search field
	*
	* @param kDBList $object
	* @param string $field_name
	* @return Array
	*/
	function getFieldInformation(&$object, $field_name)
	{
	$sql_filter_type = isset($object->VirtualFields[$field_name]) ? 'having' : 'where';
	$field_type = isset($object->Fields[$field_name]['type']) ? $object->Fields[$field_name]['type'] : 'string';

	if (preg_match('/(.)\.(.)/', $field_name, $regs)) {
	$table_name = '`'.$regs[1].'`.'; // field from external table
	$field_name = $regs[2];
	}
	elseif ($sql_filter_type == 'where') {
	$table_name = '`'.$object->TableName.'`.'; // field from local table
	}

	$table_name = ($sql_filter_type == 'where') ? $table_name : '';

	// replace wid inside table name to WID_MARK constant value
	$is_temp_table = preg_match('/(.)'.TABLE_PREFIX.'ses_'.$this->Application->GetSID().'(_[\d]+){0,1}_edit_(.)/', $table_name, $regs);
	if ($is_temp_table) {
	$table_name = $regs[1].TABLE_PREFIX.'ses_'.EDIT_MARK.'_edit_'.$regs[3]; // edit_mark will be replaced with sid[_main_wid] in AddFilters
	}

	return Array ('field_name' => $field_name, 'field_type' => $field_type, 'table_name' => $table_name, 'sql_filter_type' => $sql_filter_type);
	}

	/**
	* Enter description here...
	*
	* @param kEvent $event
	*/
	function performSearch(&$event)
	{
	$object =& $event->getObject();

	// process search keyword
	$search_keyword = $this->Application->GetVar( $event->getPrefixSpecial(true).'_search_keyword');
	$this->Application->StoreVar( $event->getPrefixSpecial().'_search_keyword', $search_keyword);
	$search_keyword = str_replace('*', '%', $search_keyword);

	$custom_filter = $this->processCustomFilters($event);

	if(!$search_keyword && $custom_filter === false) {
	$this->resetSearch($event);
	return true;
	}

	if ($search_keyword) {
	$this->processAutomaticFilters($event, $search_keyword, $custom_filter);
	}
	}


	function processAutomaticFilters(&$event, $search_keyword, $custom_filter)
	{
	$grid_name = $this->Application->GetVar('grid_name');
	$grids = $this->Application->getUnitOption($event->Prefix, 'Grids');
	$search_fields = array_keys($grids[$grid_name]['Fields']);

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

	foreach ($search_fields as $search_field) {
	$custom_search = isset($custom_filter[$search_field]);

	$filter_data = $this->getSearchClause($object, $search_field, $search_keyword, $custom_search);

	if ($filter_data) {
	$search_filter[$search_field] = $filter_data;
	}
	else {
	unset($search_filter[$search_field]);
	}
	}
	$this->Application->StoreVar($event->getPrefixSpecial().'_search_filter', serialize($search_filter) );
	}

	/**
	* Returns search clause for any particular field
	*
	* @param kDBList $object
	* @param string $search_field
	* @param string $search_keyword what we are searching (false, when building custom filter clause)
	* @param string $custom_search already found using custom filter
	* @return Array
	*/
	function getSearchClause(&$object, $field_name, $search_keyword, $custom_search)
	{
	$search_keywords = $this->splitKeyword($search_keyword);

	extract( $this->getFieldInformation($object, $field_name) ); // see getFieldInformation for more details

	$filter_value = '';

	// get field clause by formatter name and/or parameters
	$formatter = getArrayValue($object->Fields[$field_name], 'formatter');
	switch ($formatter) {
	case 'kOptionsFormatter':
	$search_keys = Array();

	if ($custom_search === false) {
	// if keywords passed through simple search filter (on each grid)
	$use_phrases = getArrayValue($object->Fields[$field_name], 'use_phrases');
	$field_options = $object->GetFieldOptions($field_name);
	foreach ($field_options['options'] as $key => $val) {
	foreach ($search_keywords as $keyword => $sign) {
	$pattern = '#'.$keyword.'#i';
	if (!preg_match($pattern, $use_phrases ? $this->Application->Phrase($val) : $val)) {
	if ($sign == '+') {
	$filter_value = $table_name.'`'.$field_name.'` = NULL';
	break;
	}
	else {
	continue;
	}
	}

	if ($sign == '+' \|\| $sign == '') {
	$search_keys[$key] = $this->Conn->qstr($key);
	}
	elseif($sign == '-') {
	// if same value if found as exclusive too, then remove from search result
	unset($search_keys[$key]);
	}
	}
	}
	}

	if ($search_keys) {
	$filter_value = $table_name.'`'.$field_name.'` IN ('.implode(',', $search_keys).')';
	}

	$field_processed = true;
	break;

	case 'kDateFormatter':
	// if date is searched using direct filter, then do nothing here, otherwise search using LIKE clause
	$field_processed = ($custom_search !== false) ? true : false;
	break;

	default:
	$field_processed = false;
	break;
	}

	// if not already processed by formatter, then get clause by field type
	if (!$field_processed && $search_keywords) {
	switch($field_type)
	{
	case 'int':
	case 'integer':
	case 'numeric':
	$search_keys = Array();
	foreach ($search_keywords as $keyword => $sign) {
	if (!is_numeric($keyword) \|\| ($sign == '-')) continue;
	$search_keys[] = $this->Conn->qstr($keyword);
	}

	if ($search_keys) {
	$filter_value = $table_name.'`'.$field_name.'` IN ('.implode(',', $search_keys).')';
	}
	break;

	case 'double':
	case 'float':
	case 'real':
	$search_keys = Array();
	foreach ($search_keywords as $keyword => $sign) {
	$keyword = str_replace(',', '.', $keyword);
	if (!is_numeric($keyword) \|\| ($sign == '-')) continue;
	$search_keys[] = 'ABS('.$table_name.'`'.$field_name.'` - '.$this->Conn->qstr($keyword).') <= 0.0001';
	}

	if ($search_keys) {
	$filter_value = '('.implode(') OR (', $search_keys).')';
	}
	break;

	case 'string':
	$filter_value = $this->buildWhereClause($search_keyword, Array($table_name.'`'.$field_name.'`'));
	break;
	}
	}

	if ($filter_value) {
	return Array('type' => $sql_filter_type, 'value' => $filter_value);
	}

	return false;
	}

	/**
	* Processes custom filters from submit
	*
	* @param KEvent $event
	* @return bool
	*/
	function processCustomFilters(&$event)
	{
	$grid_name = $this->Application->GetVar('grid_name');

	// update "custom filter" with values from submit: begin
	$view_name = $this->Application->RecallVar($event->getPrefixSpecial().'_current_view');
	$custom_filters = $this->Application->RecallPersistentVar($event->getPrefixSpecial().'_custom_filter.'.$view_name, ALLOW_DEFAULT_SETTINGS);
	if ($custom_filters) {
	$custom_filters = unserialize($custom_filters);
	$custom_filter = isset($custom_filters[$grid_name]) ? $custom_filters[$grid_name] : Array ();
	}
	else {
	$custom_filter = Array ();
	}

	// submit format custom_filters[prefix_special][field]
	$submit_filters = $this->Application->GetVar('custom_filters');
	if ($submit_filters) {
	$submit_filters = getArrayValue($submit_filters, $event->getPrefixSpecial(), $grid_name);
	if ($submit_filters) {
	foreach ($submit_filters as $field_name => $field_options) {
	list ($filter_type, $field_value) = each($field_options);
	$is_empty = strlen(is_array($field_value) ? implode('', $field_value) : $field_value) == 0;
	if ($is_empty) {
	if (isset($custom_filter[$field_name])) {
	// use isset, because non-existing key will cause "php notice"!
	unset($custom_filter[$field_name][$filter_type]); // remove filter

	if (!$custom_filter[$field_name]) {
	// if no filters left for field, then delete record at all
	unset($custom_filter[$field_name]);
	}
	}
	}
	else {
	$custom_filter[$field_name][$filter_type]['submit_value'] = $field_value;
	}
	}
	}
	}

	if ($custom_filter) {
	$custom_filters[$grid_name] = $custom_filter;
	}
	else {
	unset($custom_filters[$grid_name]);
	}
	// update "custom filter" with values from submit: end

	if (!$custom_filter) {
	// in case when no filters specified, there are nothing to process
	$this->Application->StorePersistentVar($event->getPrefixSpecial().'_custom_filter.'.$view_name, serialize($custom_filters) );
	return false;
	}

	$object =& $event->getObject(); // don't recall it each time in getCustomFilterSearchClause
	$grid_info = $this->Application->getUnitOption($event->Prefix.'.'.$grid_name, 'Grids');
	foreach ($custom_filter as $field_name => $field_options) {
	list ($filter_type, $field_options) = each($field_options);
	$field_options['grid_options'] = $grid_info['Fields'][$field_name];
	$field_options = $this->getCustomFilterSearchClause($object, $field_name, $filter_type, $field_options);
	if ($field_options['value']) {
	unset($field_options['grid_options']);
	$custom_filter[$field_name][$filter_type] = $field_options;
	}
	}

	$custom_filters[$grid_name] = $custom_filter;
	$this->Application->StorePersistentVar($event->getPrefixSpecial().'_custom_filter.'.$view_name, serialize($custom_filters) );
	return $custom_filter;
	}

	/**
	* Return numeric range filter value + checking that it's number
	*
	* @param Array $value array containing range filter value
	* @return unknown
	*/
	function getRangeValue($value)
	{
	return strlen($value) && is_numeric($value) ? $this->Conn->qstr($value) : false;
	}

	function getCustomFilterSearchClause(&$object, $field_name, $filter_type, $field_options)
	{
	// this is usually used for mutlilingual fields and date fields
	if (isset($field_options['grid_options']['sort_field'])) {
	$field_name = $field_options['grid_options']['sort_field'];
	}
	extract( $this->getFieldInformation($object, $field_name) ); // see getFieldInformation for more details

	$filter_value = '';

	switch ($filter_type) {
	case 'range':
	$from = $this->getRangeValue($field_options['submit_value']['from']);
	$to = $this->getRangeValue($field_options['submit_value']['to']);

	if ($from !== false && $to !== false) {
	// add range filter
	$filter_value = $table_name.'`'.$field_name.'` >= '.$from.' AND '.$table_name.'`'.$field_name.'` <= '.$to;
	}
	elseif ($from !== false) {
	// add equals filter on $from
	$filter_value = $table_name.'`'.$field_name.'` = '.$from;
	}
	elseif ($to !== false) {
	// add equals filter on $to
	$filter_value = $table_name.'`'.$field_name.'` = '.$to;
	}
	break;

	case 'float_range':
	// MySQL can't compare values in "float" type columns using "=" operator
	$from = $this->getRangeValue($field_options['submit_value']['from']);
	$to = $this->getRangeValue($field_options['submit_value']['to']);

	if ($from !== false && $to !== false) {
	// add range filter
	$filter_value = $table_name.'`'.$field_name.'` >= '.$from.' AND '.$table_name.'`'.$field_name.'` <= '.$to;
	}
	elseif ($from !== false) {
	// add equals filter on $from
	$filter_value = 'ABS('.$table_name.'`'.$field_name.'` - '.$from.') <= 0.0001';
	}
	elseif ($to !== false) {
	// add equals filter on $to
	$filter_value = 'ABS('.$table_name.'`'.$field_name.'` - '.$to.') <= 0.0001';
	}
	break;

	case 'date_range':
	$from = $this->processRangeField($object, $field_name, $field_options['submit_value'], 'from');
	$to = $this->processRangeField($object, $field_name, $field_options['submit_value'], 'to');

	$day_seconds = 23 * 60 * 60 + 59 * 60 + 59;
	if ($from !== false && $to === false) {
	$from = strtotime(date('Y-m-d', $from).' 00:00:00', $from); // reset to morning
	$to = $from + $day_seconds;
	}
	elseif ($from === false && $to !== false) {
	$to = strtotime(date('Y-m-d', $to).' 23:59:59', $to); // reset to evening
	$from = $to - $day_seconds;
	}

	if ($from !== false && $to !== false) {
	$filter_value = $table_name.'`'.$field_name.'` >= '.$from.' AND '.$table_name.'`'.$field_name.'` <= '.$to;
	}
	break;

	case 'equals':
	case 'options':
	$field_value = strlen($field_options['submit_value']) ? $this->Conn->qstr($field_options['submit_value']) : false;
	if ($field_value) {
	$filter_value = $table_name.'`'.$field_name.'` = '.$field_value;
	}
	break;

	case 'like':
	$filter_value = $this->buildWhereClause($field_options['submit_value'], Array($table_name.'`'.$field_name.'`'));
	break;

	default:
	break;
	}

	$field_options['sql_filter_type'] = $sql_filter_type;
	$field_options['value'] = $filter_value;

	return $field_options;
	}

	/**
	* Enter description here...
	*
	* @param kdbItem $object
	* @param string $search_field
	* @param string $value
	* @param string $type
	*/
	function processRangeField(&$object, $search_field, $value, $type)
	{
	if (!strlen($value[$type])) {
	return false;
	}

	$lang_current =& $this->Application->recallObject('lang.current');
	$options = $object->GetFieldOptions($search_field);
	$dt_separator = isset($options['date_time_separator']) ? $options['date_time_separator'] : ' ';

	$tmp_value = explode($dt_separator, $value[$type], 2);
	if (count($tmp_value) == 1) {
	// time is missing, then guess it and add to date
	$time = ($type == 'from') ? adodb_mktime(0, 0, 0) : adodb_mktime(23, 59, 59);
	$time = adodb_date($lang_current->GetDBField('InputTimeFormat'), $time);
	$value[$type] .= $dt_separator.$time;
	}

	$formatter =& $this->Application->recallObject($object->Fields[$search_field]['formatter']);

	$value_ts = $formatter->Parse($value[$type], $search_field, $object);
	$pseudo = getArrayValue($object->FieldErrors, $search_field, 'pseudo');
	if ($pseudo) {
	unset($object->FieldErrors[$search_field]); // remove error!
	// invalid format -> ignore this date in search
	return false;
	}
	return $value_ts;
	}

	/**
	* Resets current search
	*
	* @param kEvent $event
	*/
	function resetSearch(&$event)
	{
	$this->Application->RemoveVar($event->getPrefixSpecial().'_search_filter');
	$this->Application->RemoveVar($event->getPrefixSpecial().'_search_keyword');

	$view_name = $this->Application->RecallVar($event->getPrefixSpecial().'_current_view');
	$this->Application->RemovePersistentVar($event->getPrefixSpecial().'_custom_filter.'.$view_name);
	}

	/**
	* Creates filters based on "types" & "except" parameters from PrintList
	*
	* @param kEvent $event
	* @param Array $type_clauses
	* @param string $types
	* @param string $except_types
	*/
	function SetComplexFilter(&$event, &$type_clauses, $types, $except_types)
	{
	$includes_or_filter =& $this->Application->makeClass('kMultipleFilter', FLT_TYPE_OR);
	$excepts_and_filter =& $this->Application->makeClass('kMultipleFilter', FLT_TYPE_AND);
	-
	+
	$includes_or_filter_h =& $this->Application->makeClass('kMultipleFilter', FLT_TYPE_OR);
	$excepts_and_filter_h =& $this->Application->makeClass('kMultipleFilter', FLT_TYPE_AND);
	-
	+
	if ($types) {
	$types = explode(',', $types);
	foreach ($types as $type) {
	$type = trim($type);
	-
	+
	if (isset($type_clauses[$type])) {
	if ($type_clauses[$type]['having_filter']) {
	$includes_or_filter_h->addFilter('filter_'.$type, $type_clauses[$type]['include']);
	} else {
	$includes_or_filter->addFilter('filter_'.$type, $type_clauses[$type]['include']);
	}
	}
	}
	}
	-
	+
	if ($except_types) {
	$except_types = explode(',', $except_types);
	foreach ($except_types as $type) {
	$type = trim($type);
	-
	+
	if (isset($type_clauses[$type])) {
	if ($type_clauses[$type]['having_filter']) {
	$excepts_and_filter_h->addFilter('filter_'.$type, $type_clauses[$type]['except']);
	} else {
	$excepts_and_filter->addFilter('filter_'.$type, $type_clauses[$type]['except']);
	}
	}
	}
	}
	-
	+
	$object =& $event->getObject();
	-
	+
	$object->addFilter('includes_filter', $includes_or_filter);
	$object->addFilter('excepts_filter', $excepts_and_filter);
	-
	+
	$object->addFilter('includes_filter_h', $includes_or_filter_h, HAVING_FILTER);
	$object->addFilter('excepts_filter_h', $excepts_and_filter_h, HAVING_FILTER);
	}
	}

	?>
	\ No newline at end of file

	Property changes on: branches/RC/core/units/general/helpers/search_helper.php
	___________________________________________________________________
	Modified: cvs2svn:cvs-rev
	## -1 +1 ##
	-1.10.2.1
	\ No newline at end of property
	+1.10.2.2
	\ No newline at end of property
	Index: branches/RC/core/admin_templates/js/ajax.js
	===================================================================
	--- branches/RC/core/admin_templates/js/ajax.js (revision 9642)
	+++ branches/RC/core/admin_templates/js/ajax.js (revision 9643)
	@@ -1,443 +1,455 @@
	function preg_print_pre(obj, reg)
	{
	if (!reg) reg = /.*/;
	var p = ''
	for (var prop in obj) {
	if (prop.match(reg) ) {
	p += prop + ': '+obj[prop] + '\n'
	}
	}
	alert(p)
	}


	// Main AJAX classs
	function Request() {}

	Request.timeout = 60000; //60 seconds
	Request.method = 'GET';
	Request.headers = new Array();
	Request.params = null;

	Request.makeRequest = function(p_url, p_busyReq, p_progId, p_successCallBack, p_errorCallBack, p_pass, p_object) {
	//p_url: the web service url
	//p_busyReq: is a request for this object currently in progress?
	//p_progId: element id where progress HTML should be shown
	//p_successCallBack: callback function for successful response
	//p_errorCallBack: callback function for erroneous response
	//p_pass: string of params to pass to callback functions
	//p_object: object of params to pass to callback functions

	if (p_busyReq) return;
	var req = Request.getRequest();
	if (req != null) {
	p_busyReq = true;
	Request.showProgress(p_progId);
	req.onreadystatechange = function() {
	if (req.readyState == 4) {
	p_busyReq = false;
	window.clearTimeout(toId);
	try {
	if (req.status == 200) {
	// preg_print_pre(req)
	p_successCallBack(req, p_pass, p_object);
	} else {
	p_errorCallBack(req, p_pass, p_object);
	}
	Request.hideProgress(p_progId);
	}
	catch (e) {
	// alert('AJAX error')
	}
	}
	}
	var $ajax_mark = (p_url.indexOf('?') ? '&' : '?') + 'ajax=yes';
	req.open(Request.method, p_url + $ajax_mark, true);

	if (Request.method == 'POST') {
	Request.headers['Content-type'] = 'application/x-www-form-urlencoded';
	Request.headers['referer'] = p_url;
	}
	else {
	Request.headers['If-Modified-Since'] = 'Sat, 1 Jan 2000 00:00:00 GMT';
	}

	Request.sendHeaders(req);
	if (Request.method == 'POST') {
	req.send(Request.params);
	Request.method = 'GET'; // restore method back to GET
	}
	else {
	req.send(null);
	}

	var toId = window.setTimeout( function() {if (p_busyReq) req.abort();}, Request.timeout );
	}
	}

	Request.processRedirect = function($request) {
	var $match_redirect = new RegExp('^#redirect#(.*)').exec($request.responseText);
	if ($match_redirect != null) {
	// redirect to external template requested
	window.location.href = $match_redirect[1];
	return true;
	}
	return false;
	}
	Request.sendHeaders = function($request) {
	for (var $header_name in Request.headers) {
	if (typeof Request.headers[$header_name] == 'function') {
	continue;
	}
	$request.setRequestHeader($header_name, Request.headers[$header_name]);
	}
	Request.headers = new Array(); // reset header afterwards
	}

	Request.getRequest = function() {
	var xmlHttp;
	try { xmlHttp = new ActiveXObject('MSXML2.XMLHTTP'); return xmlHttp; } catch (e) {}
	try { xmlHttp = new ActiveXObject('Microsoft.XMLHTTP'); return xmlHttp; } catch (e) {}
	try { xmlHttp = new XMLHttpRequest(); return xmlHttp; } catch(e) {}
	return null;
	}

	Request.showProgress = function(p_id) {
	if (p_id != '') {
	Request.setOpacity(20, p_id);

	if (!document.getElementById(p_id + '_progress')) {
	document.body.appendChild(Request.getProgressObject(p_id));
	}
	else {
	var $progress_div = document.getElementById(p_id + '_progress');
	$progress_div.style.top = getRealTop(p_id) + 'px';
	$progress_div.style.height = document.getElementById(p_id).clientHeight;
	$progress_div.style.display = 'block';
	}
	// document.getElementById(p_id).innerHTML = Request.getProgressHtml();
	}
	}

	Request.hideProgress = function(p_id) {
	if (p_id != '') {
	document.getElementById(p_id + '_progress').style.display = 'none';
	Request.setOpacity(100, p_id);
	}
	}

	Request.setOpacity = function (opacity, id) {
	var elem = typeof(id)=='string' ? document.getElementById(id) : id;
	var object = elem.style;
	object.opacity = (opacity / 100);
	object.MozOpacity = (opacity / 100);
	object.KhtmlOpacity = (opacity / 100);
	object.filter = "alpha(opacity=" + opacity + ")";
	}

	Request.getProgressHtml = function() {
	return "<p class='progress'>" + Request.progressText + "<br /><img src='img/ajax_progress.gif' align='absmiddle' width='100' height='7' alt='" + Request.progressText + "'/></p>";
	}

	Request.getProgressObject = function($id) {
	var $div = document.createElement('DIV');
	var $parent_div = document.getElementById($id);

	$div.id = $id + '_progress';

	$div.style.width = $parent_div.clientWidth + 'px';
	$div.style.height = '150px'; // default height if div is empty (first ajax request for div)
	$div.style.left = getRealLeft($parent_div) + 'px';
	$div.style.top = getRealTop($parent_div) + 'px';
	$div.style.position = 'absolute';

	/*$div.style.border = '1px solid green';
	$div.style.backgroundColor = '#FF0000';*/

	$div.innerHTML = '<table style="width: 100%; height: 100%;"><tr><td style="text-align: center;">'+Request.progressText+'<br /><img src="img/ajax_progress.gif" align="absmiddle" width="100" height="7" alt="'+escape(Request.progressText)+'" /></td></tr></table>';
	return $div;
	}

	Request.getErrorHtml = function(p_req) {
	//TODO: implement accepted way to handle request error
	return '[status: ' + p_req.status + '; status_text: ' + p_req.statusText + '; responce_text: ' + p_req.responseText + ']';
	}

	Request.serializeForm = function(theform) {
	if (typeof(theform) == 'string') {
	theform = document.getElementById(theform);
	}

	var els = theform.elements;
	var len = els.length;
	var queryString = '';

	Request.addField = function(name, value) {
	if (queryString.length > 0) queryString += '&';
	queryString += encodeURIComponent(name) + '=' + encodeURIComponent(value);
	};

	for (var i = 0; i<len; i++) {
	var el = els[i];
	if (el.disabled) continue;

	switch(el.type) {
	case 'text':
	case 'password':
	case 'hidden':
	case 'textarea':
	Request.addField(el.name, el.value);
	break;

	case 'select-one':
	if (el.selectedIndex >= 0) {
	Request.addField(el.name, el.options[el.selectedIndex].value);
	}
	break;

	case 'select-multiple':
	for (var j = 0; j < el.options.length; j++) {
	if (!el.options[j].selected) continue;
	Request.addField(el.name, el.options[j].value);
	}
	break;

	case 'checkbox':
	case 'radio':
	if (!el.checked) continue;
	Request.addField(el.name,el.value);
	break;
	}
	}
	return queryString;
	};

	// AJAX ProgressBar class
	function AjaxProgressBar($url) {
	this.WindowTitle = this.GetWindow().document.title;
	this.URL = $url;
	this.BusyRequest = false;
	this.LastResponceTime = this.GetMicroTime();
	this.ProgressPercent = 0; // progress percent
	this.ProgressTime = new Array();
	this.Query();
	}

	AjaxProgressBar.prototype.GetWindow = function() {
	return window.parent ? window.parent : window;
	}

	AjaxProgressBar.prototype.GetMicroTime = function() {
	var $now = new Date();
	return Math.round($now.getTime() / 1000); // because miliseconds are returned too
	}

	AjaxProgressBar.prototype.Query = function() {
	// prompt('requestinng', this.URL);
	Request.makeRequest(this.URL, this.BusyRequest, '', this.successCallback, this.errorCallback, '', this);
	}

	// return time needed for progress to finish
	AjaxProgressBar.prototype.GetEstimatedTime = function() {
	return Math.ceil((100 - this.ProgressPercent) * Math.sum(this.ProgressTime) / this.ProgressPercent);
	}

	AjaxProgressBar.prototype.successCallback = function($request, $params, $object) {
	var $responce = $request.responseText;
	var $match_redirect = new RegExp('^#redirect#(.*)').exec($responce);
	if ($match_redirect != null) {
	$object.showProgress(100);
	// redirect to external template requested
	window.location.href = $match_redirect[1];
	return false;
	}

	if ($object.showProgress($responce)) {
	$object.Query();
	}
	}

	AjaxProgressBar.prototype.errorCallback = function($request, $params, $object) {
	alert('AJAX Error; class: AjaxProgressBar; ' + Request.getErrorHtml($request));
	}

	AjaxProgressBar.prototype.FormatTime = function ($seconds) {
	$seconds = parseInt($seconds);

	var $minutes = Math.floor($seconds / 60);
	if ($minutes < 10) $minutes = '0' + $minutes;
	$seconds = $seconds % 60;
	if ($seconds < 10) $seconds = '0' + $seconds;

	return $minutes + ':' + $seconds;
	}

	AjaxProgressBar.prototype.showProgress = function ($percent) {
	this.ProgressPercent = $percent;
	var $now = this.GetMicroTime();
	this.ProgressTime[this.ProgressTime.length] = $now - this.LastResponceTime;
	this.LastResponceTime = $now;

	var $display_progress = parseInt(this.ProgressPercent);
	this.GetWindow().document.title = $display_progress + '% - ' + this.WindowTitle;
	document.getElementById('progress_display[percents_completed]').innerHTML = $display_progress + '%';
	document.getElementById('progress_display[elapsed_time]').innerHTML = this.FormatTime( Math.sum(this.ProgressTime) );
	document.getElementById('progress_display[Estimated_time]').innerHTML = this.FormatTime( this.GetEstimatedTime() );

	document.getElementById('progress_bar[done]').style.width = $display_progress + '%';
	document.getElementById('progress_bar[left]').style.width = (100 - $display_progress) + '%';
	return $percent < 100 ? true : false;
	}

	// AJAX PopupManager class
	function AjaxPopupManager($url) {
	this.URL = $url;
	this.ResponceFunction = null;
	this.PopupSizes = new Array();
	}

	AjaxPopupManager.prototype.GetSize = function ($template) {
	if (this.ResponceFunction == null) {
	alert ('Please define responce function first (type: '+typeof(this.ResponceFunction)+')');
	}

	if (!isset(this.PopupSizes[$template])) {
	var $url = this.URL + '&type=GetPopupSize&template_name=' + $template;
	// alert('from ajax: '+$url);
	Request.makeRequest($url, this.BusyRequest, '', this.successCallback, this.errorCallback, ['GetSize', $template], this);
	}
	else {
	// alert('from cache');
	this.ResponceFunction(this.PopupSizes[$template]);
	}
	}

	AjaxPopupManager.prototype.successCallback = function($request, $params, $object) {
	var $responce = $request.responseText;
	var $match_redirect = new RegExp('^#redirect#(.*)').exec($responce);
	if ($match_redirect != null) {
	// redirect to external template requested
	window.location.href = $match_redirect[1];
	return false;
	}

	switch ($params[0]) {
	case 'GetSize':
	// store responce to cache for future use
	$object.PopupSizes[ $params[1] ] = $responce;
	break;
	}

	$object.ResponceFunction($responce);
	$object.ResponceFunction = null; // reset responce function
	}

	AjaxPopupManager.prototype.errorCallback = function($request, $params, $object) {
	alert('AJAX Error; class: AjaxPopupManager; ' + Request.getErrorHtml($request));
	}
	+
	// AJAX DropdownPreloader class
	function AjaxDropdownPreloader($url, $input_mask, $filter_field, $dependend_field, value) {
	this.URL = $url;
	this.InputMask = $input_mask;
	this.FilterField = $filter_field;
	this.DependendField = $dependend_field;
	this.Titles = this.prepareTitles();
	this.Value = value;
	this.BusyRequest = false;
	}
	+
	AjaxDropdownPreloader.prototype.prepareURL = function()
	{
	return this.URL.replace('#DEPENDEND#', this.Dependend).replace('#FILTER_VALUE#', this.getValue(this.FilterField));
	}
	+
	AjaxDropdownPreloader.prototype.prepareTitles = function() {
	var $control = this.getControl(this.DependendField);
	var $i = 0;
	var $ret = new Array ();
	while ($i < $control.options.length) {
	$ret[$control.options[$i].value] = $control.options[$i].innerHTML;
	$i++;
	}
	return $ret;
	}
	+
	AjaxDropdownPreloader.prototype.getValue = function($field_name) {
	var $control = this.getControl($field_name);
	if ($control.tagName == 'INPUT') return $control.value;
	return $control.selectedIndex > 0 ? $control.options[$control.selectedIndex].value : '';
	}
	+
	AjaxDropdownPreloader.prototype.Query = function () {
	var $url = this.prepareURL();
	var $selected_value = this.Value \|\| this.getValue(this.DependendField);
	// remove all existing options
	this.removeOptions();
	Request.makeRequest($url, this.BusyRequest, '', this.successCallback, this.errorCallback, $selected_value, this);
	}
	+
	AjaxDropdownPreloader.prototype.getControl = function($field) {
	var $id = this.InputMask.replace('#FIELD#', $field);
	return document.getElementById($id);
	}
	+
	AjaxDropdownPreloader.prototype.successCallback = function($request, $params, $object) {
	if (Request.processRedirect($request) === true) {
	return ;
	}
	var control = $object.getControl($object.DependendField)
	$object.ProcessXMLNode($request.responseXML, control, $params);
	runOnChange(control);
	$object.AfterProcess();
	}
	+
	AjaxDropdownPreloader.prototype.ProcessXMLNode = function($node, $dst_field, $selected_value) {
	for (var i = 0; i < $node.childNodes.length; i++) {
	var $child = $node.childNodes.item(i);
	switch ($child.tagName) {
	case 'option':
	var opt_value = $child.getAttribute('value');
	var title;
	if (opt_value) { // value is passed explicically
	title = $child.firstChild.nodeValue
	}
	else {
	opt_value = $child.firstChild.nodeValue;
	title = this.Titles[$child.firstChild.nodeValue];
	}
	this.addOption($dst_field, opt_value, title, $child.attributes);
	if (opt_value == $selected_value) {
	$dst_field.options[$dst_field.options.length - 1].selected = true;
	}
	break;
	case 'field_options':
	this.addOption($dst_field, '', '');
	// add new states
	this.ProcessXMLNode($child, $dst_field, $selected_value);
	if ($dst_field.options.length == 0 \|\| $dst_field.options.length == 2) {
	$dst_field.value = $dst_field.options[$dst_field.options.length - 1].value;
	}
	break;
	}
	}
	}
	-AjaxDropdownPreloader.prototype.AfterProcess = function()
	-{
	+
	+AjaxDropdownPreloader.prototype.AfterProcess = function() {
	+
	}
	+
	AjaxDropdownPreloader.prototype.removeOptions = function($object) {
	if (!$object) $object = this.getControl(this.DependendField);
	if ($object.options.length > 0) {
	while ($object.options.length > 0) {
	$object.remove(0);
	}
	}
	}
	+
	AjaxDropdownPreloader.prototype.addOption = function($object, $value, $title, attributes) {
	var $option = document.createElement('OPTION');
	$object.options.add($option, $object.options.length);
	$option.innerText = $title;
	$option.innerHTML = $title;
	$option.value = $value;
	if (attributes) {
	for (var i=0; i<attributes.length; i++) {
	if (attributes[i].nodeName == 'value') continue;
	$option.setAttribute(attributes[i].nodeName, attributes[i].nodeValue);
	}
	}
	}
	+
	AjaxDropdownPreloader.prototype.errorCallback = function($request, $params, $object) {
	alert('AJAX Error; class: AjaxDropdownPreloader; ' + Request.getErrorHtml($request));
	}
	\ No newline at end of file

	Property changes on: branches/RC/core/admin_templates/js/ajax.js
	___________________________________________________________________
	Modified: cvs2svn:cvs-rev
	## -1 +1 ##
	-1.6.2.3
	\ No newline at end of property
	+1.6.2.4
	\ No newline at end of property
	Index: branches/RC/core/admin_templates/incs/header.tpl
	===================================================================
	--- branches/RC/core/admin_templates/incs/header.tpl (revision 9642)
	+++ branches/RC/core/admin_templates/incs/header.tpl (revision 9643)
	@@ -1,59 +1,60 @@
	<inp2:m_DefaultParam body_properties=""/>
	<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
	<html>
	<head>
	<title><inp2:m_GetConfig var="Site_Name"/> - <inp2:m_Phrase label="la_AdministrativeConsole"/></title>

	<meta http-equiv="content-type" content="text/html; charset=<inp2:lang_GetCharset/>">
	<meta name="keywords" content="...">
	<meta name="description" content="...">
	<meta name="robots" content="all">
	<meta name="copyright" content="Copyright ® 2006 Test, Inc">
	<meta name="author" content="Intechnic Inc.">

	<inp2:m_base_ref/>

	<link rel="icon" href="img/favicon.ico" type="image/x-icon" />
	<link rel="shortcut icon" href="img/favicon.ico" type="image/x-icon" />
	<link rel="stylesheet" rev="stylesheet" href="incs/style.css" type="text/css" />

	<script type="text/javascript" src="js/is.js"></script>
	<script type="text/javascript" src="js/ajax.js"></script>
	+<script language="javascript" src="js/application.js"></script>
	<script type="text/javascript" src="js/script.js"></script>
	<script type="text/javascript" src="js/in-portal.js"></script>
	<script type="text/javascript" src="js/toolbar.js"></script>
	<script type="text/javascript" src="js/grid.js"></script>
	<script type="text/javascript" src="js/forms.js"></script>
	<script type="text/javascript" src="js/calendar.js"></script>
	<script language="javascript">
	var t = '<inp2:m_get param="t"/>';
	var popups = '1';
	var multiple_windows = '1';
	var main_title = '<inp2:m_GetConfig var="Site_Name" escape="1"/>';
	var tpl_changed = 0;
	var base_url = '<inp2:m_BaseURL/>';
	var $base_path = '<inp2:m_GetConst name="BASE_PATH"/>';
	var img_path = '<inp2:m_TemplatesBase module="#MODULE#"/>/img/';

	NumberFormatter.ThousandsSep = '<inp2:lang.current_Field name="ThousandSep" js_escape="1"/>';
	NumberFormatter.DecimalSep = '<inp2:lang.current_Field name="DecimalPoint" js_escape="1"/>';

	<inp2:m_if check="m_GetEquals" name="m_wid" value="" inverse="inverse">
	window.name += '_<inp2:m_get name="m_wid"/>';
	</inp2:m_if>

	var $use_popups = <inp2:m_if check="adm_UsePopups">true<inp2:m_else/>false</inp2:m_if>;
	var $use_toolbarlabels = <inp2:m_if check="adm_UseToolbarLabels">true<inp2:m_else/>false</inp2:m_if>;
	</script>
	</head>

	<inp2:m_include t="incs/blocks"/>
	<inp2:m_include t="incs/in-portal"/>

	<inp2:m_if check="m_ParamEquals" name="nobody" value="yes" inverse="inverse">
	<body <inp2:m_param name="body_properties"/>>
	</inp2:m_if>

	<inp2:m_if check="m_ParamEquals" name="noform" value="yes" inverse="inverse">
	<inp2:m_RenderElement name="kernel_form"/>
	</inp2:m_if>
	\ No newline at end of file

	Property changes on: branches/RC/core/admin_templates/incs/header.tpl
	___________________________________________________________________
	Modified: cvs2svn:cvs-rev
	## -1 +1 ##
	-1.5
	\ No newline at end of property
	+1.5.2.1
	\ No newline at end of property
	Index: branches/RC/core/admin_templates/index.tpl
	===================================================================
	--- branches/RC/core/admin_templates/index.tpl (revision 9642)
	+++ branches/RC/core/admin_templates/index.tpl (revision 9643)
	@@ -1,47 +1,47 @@
	<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
	<inp2:m_CheckSSL mode="required" condition="Require_AdminSSL" />
	<inp2:m_CheckSSL/>
	<inp2:m_RequireLogin login_template="login"/>
	<inp2:m_Set skip_last_template="1"/>
	<inp2:m_NoDebug/>
	<html>
	<head>
	<meta http-equiv="content-type" content="text/html; charset=<inp2:lang_GetCharset/>">
	<title><inp2:m_GetConfig var="Site_Name"/> - <inp2:m_Phrase label="la_AdministrativeConsole"/></title>
	<inp2:m_base_ref/>

	<link rel="icon" href="img/favicon.ico" type="image/x-icon" />
	<link rel="shortcut icon" href="img/favicon.ico" type="image/x-icon" />
	<link rel="stylesheet" rev="stylesheet" href="incs/style.css" type="text/css" />

	<script type="text/javascript">
	window.name = 'main_frame';

	var $top_height = 94;
	if (navigator.appName == 'Netscape') {
	$top_height = navigator.appVersion.substring(0, 1) != '5' ? 96 : 95;
	}

	<inp2:m_if check="m_RecallEquals" name="ShowAdminMenu" value="0" persistent="1">
	document.write('<frameset id="top_frameset" rows="' + $top_height + ',*" framespacing="0" scrolling="no" frameborder="0">');
	<inp2:m_else/>
	document.write('<frameset id="top_frameset" rows="25,*" framespacing="0" scrolling="no" frameborder="0">');
	</inp2:m_if>
	</script>
	</head>

	<frame src="<inp2:m_t t="head" pass="m" m_cat_id="0" m_opener="s" no_pass_through="1"/>" name="head" scrolling="no" noresize="noresize">
	- <frameset id="sub_frameset" cols="<inp2:m_if check="m_RecallEquals" name="ShowAdminMenu" value="0" persistent="1"><inp2:adm_MenuFrameWidth/>,<inp2:m_else/>0</inp2:m_if>,*" border="0">
	+ <frameset id="sub_frameset" cols="<inp2:m_if check="m_RecallEquals" name="ShowAdminMenu" value="0" persistent="1"><inp2:adm_MenuFrameWidth/><inp2:m_else/>0</inp2:m_if>,*" border="0">
	<frame src="<inp2:m_t t="tree" pass="m" m_cat_id="0" m_opener="s" no_pass_through="1"/>" name="menu" target="main" noresize scrolling="auto" marginwidth="0" marginheight="0">
	<inp2:m_DefineElement name="root_node">
	<frame src="<inp2:m_if check="adm_MainFrameLink"><inp2:adm_MainFrameLink/><inp2:m_else/><inp2:m_param name="section_url"/></inp2:m_if>" name="main" marginwidth="0" marginheight="0" frameborder="no" noresize scrolling="auto">
	</inp2:m_DefineElement>
	<inp2:adm_PrintSection render_as="root_node" section_name="in-portal:root"/>
	</frameset>
	</frameset>
	<noframes>
	<body bgcolor="#FFFFFF">
	<p></p>
	</body>
	</noframes>
	</html>
	\ No newline at end of file

	Property changes on: branches/RC/core/admin_templates/index.tpl
	___________________________________________________________________
	Modified: cvs2svn:cvs-rev
	## -1 +1 ##
	-1.7.2.3
	\ No newline at end of property
	+1.7.2.4
	\ 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