in-portal
No OneTemporary
Actions

Subscribers

None

File Metadata

Created: Sun, Jan 5, 7:31 PM

in-portal
View Options

This file is larger than 256 KB, so syntax highlighting was skipped.

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

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

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

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


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

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

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

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

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

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

	return parent::CheckPermission($event);
	}

	/**
	* Allows to override standard permission mapping
	*
	* @return void
	* @access protected
	* @see kEventHandler::$permMapping
	*/
	protected function mapPermissions()
	{
	parent::mapPermissions();

	$permissions = Array (
	'OnLoad' => Array ('self' => 'view', 'subitem' => 'view'),
	'OnItemBuild' => Array ('self' => 'view', 'subitem' => 'view'),
	'OnSuggestValues' => Array ('self' => 'view', 'subitem' => 'view'),

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

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

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

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

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

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

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


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

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

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

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

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

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

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

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

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

	'OnValidateMInputFields' => Array ('self' => 'view'),
	'OnValidateField' => Array ('self' => true, 'subitem' => true),
	);

	$this->permMapping = array_merge($this->permMapping, $permissions);
	}

	/**
	* Define alternative event processing method names
	*
	* @return void
	* @see kEventHandler::$eventMethods
	* @access protected
	*/
	protected function mapEvents()
	{
	$events_map = Array (
	'OnRemoveFilters' => 'FilterAction',
	'OnApplyFilters' => 'FilterAction',
	'OnMassApprove' => 'iterateItems',
	'OnMassDecline' => 'iterateItems',
	'OnMassMoveUp' => 'iterateItems',
	'OnMassMoveDown' => 'iterateItems',
	);

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

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

	if ( $event->Special == 'previous' \|\| $event->Special == 'next' ) {
	$object = $this->Application->recallObject($event->getEventParam('item'));
	/* @var $object kDBItem */

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

	$select_clause = $this->Application->getUnitOption($object->Prefix, 'NavigationSelectClause', null);

	return $list_helper->getNavigationResource($object, $event->getEventParam('list'), $event->Special == 'next', $select_clause);
	}
	elseif ( $event->Special == 'filter' ) {
	// temporary object, used to print filter options only
	return 0;
	}

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

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

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

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

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

	return $ret;
	}

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

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

	return $resulting_ids;
	}

	return Array ();
	}

	$ret = Array ();

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

	$ids = Array ();

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

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

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

	// This is critical - otherwise getPassedID will return last ID stored in session! (not exactly true)
	// this smells... needs to be refactored
	$first_id = getArrayValue($ret, 0);
	if ( ($first_id === false) && ($event->getEventParam('raise_warnings') == 1) ) {
	if ( $this->Application->isDebugMode() ) {
	$this->Application->Debugger->appendTrace();
	}

	trigger_error('Requested ID for prefix <strong>' . $event->getPrefixSpecial() . '</strong> <span class="debug_error">not passed</span>', E_USER_NOTICE);
	}

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

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

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

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

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

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

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

	return $field_values;
	}

	/**
	* Returns fields, that are not allowed to be changed from request
	*
	* @param Array $hash
	* @return Array
	* @access protected
	*/
	protected function getRequestProtectedFields($hash)
	{
	// by default don't allow changing ID or foreign key from request
	$fields = Array ();
	$fields[] = $this->Application->getUnitOption($this->Prefix, 'IDField');

	$parent_prefix = $this->Application->getUnitOption($this->Prefix, 'ParentPrefix');

	if ( $parent_prefix && !$this->Application->isAdmin ) {
	$foreign_key = $this->Application->getUnitOption($this->Prefix, 'ForeignKey');
	$fields[] = is_array($foreign_key) ? $foreign_key[$parent_prefix] : $foreign_key;
	}

	return $fields;
	}

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

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

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

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

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

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

	if ( $event->getEventParam('form_name') !== false ) {
	$form_name = $event->getEventParam('form_name');
	}
	else {
	$request_forms = $this->Application->GetVar('forms', Array ());
	$form_name = (string)getArrayValue($request_forms, $object->getPrefixSpecial());
	}

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

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

	if ( is_object($parent_event) ) {
	$object->setParentEvent($parent_event);
	}

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

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

	$this->Application->setEvent($event->getPrefixSpecial(), '');

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

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

	$status_field = array_shift($status_fields);

	if ( $status_field == 'Status' \|\| $status_field == 'Enabled' ) {
	$object = $event->getObject();
	/* @var $object kDBItem */

	if ( !$object->isLoaded() ) {
	return true;
	}

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

	return true;
	}

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

	if ( $this->Application->isDebugMode() ) {
	$this->Application->Debugger->appendTrace();
	}

	trigger_error('ItemLoad Permission Failed for prefix [' . $event->getPrefixSpecial() . '] in <strong>checkItemStatus</strong>, leading to "404 Not Found"', E_USER_NOTICE);

	$vars = $this->Application->UrlManager->prepare404();

	foreach ($vars as $var_name => $var_value) {
	$this->Application->SetVar($var_name, $var_value);
	}

	// in case if missing item is recalled first from event (not from template)
	$this->Application->QuickRun();
	$this->Application->Done();
	exit;
	}

	/**
	* Builds item (loads if needed)
	*
	* Pattern: Prototype Manager
	*
	* @param kEvent $event
	* @access protected
	*/
	protected function OnItemBuild(kEvent $event)
	{
	$object = $event->getObject();
	/* @var $object kDBItem */

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

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

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

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

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

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

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

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

	if ( $this->Application->GetVar('t') != $template ) {
	// don't perform "no_permission" redirect if already on a "no_permission" template
	if ( MOD_REWRITE ) {
	$redirect_params = Array (
	'm_cat_id' => 0,
	'next_template' => urlencode('external:' . $_SERVER['REQUEST_URI']),
	);
	}
	else {
	$redirect_params = Array (
	'next_template' => $this->Application->GetVar('t'),
	);
	}

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

	$actions = $this->Application->recallObject('kActions');
	/* @var $actions Params */

	$actions->Set($event->getPrefixSpecial() . '_GoTab', '');
	$actions->Set($event->getPrefixSpecial() . '_GoId', '');
	$actions->Set('forms[' . $event->getPrefixSpecial() . ']', $object->getFormName());
	}

	/**
	* Build sub-tables array from configs
	*
	* @param kEvent $event
	* @return void
	* @access protected
	*/
	protected function OnTempHandlerBuild(kEvent $event)
	{
	$object = $this->Application->recallObject($event->getPrefixSpecial() . '_TempHandler', 'kTempTablesHandler');
	/* @var $object kTempTablesHandler */

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

	if ( is_object($parent_event) ) {
	$object->setParentEvent($parent_event);
	}

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

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

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

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

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

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

	if ( $object->Load($id) ) {
	$actions = $this->Application->recallObject('kActions');
	/* @var $actions Params */

	$actions->Set($event->getPrefixSpecial() . '_id', $object->GetID());
	}
	else {
	$object->setID( is_array($id) ? false : $id );
	}
	}

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

	/*if ( $this->Application->isDebugMode() ) {
	$event_params = http_build_query($event->getEventParams());
	$this->Application->Debugger->appendHTML('InitList "<strong>' . $event->getPrefixSpecial() . '</strong>" (' . $event_params . ')');
	}*/

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

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

	$object->becameMain();
	}

	$object->setGridName($event->getEventParam('grid'));

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

	$object->reset();

	if ( $event->getEventParam('skip_parent_filter') === false ) {
	$object->linkToParent($this->getMainSpecial($event));
	}

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

	$actions = $this->Application->recallObject('kActions');
	/* @var $actions Params */

	$actions->Set('remove_specials[' . $event->getPrefixSpecial() . ']', '0');
	$actions->Set($event->getPrefixSpecial() . '_GoTab', '');
	}

	/**
	* Returns special of main item for linking with sub-item
	*
	* @param kEvent $event
	* @return string
	* @access protected
	*/
	protected function getMainSpecial(kEvent $event)
	{
	$main_special = $event->getEventParam('main_special');

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

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

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

	return $main_special;
	}

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

	}

	/**
	* Set's new per-page for grid
	*
	* @param kEvent $event
	* @return void
	* @access protected
	*/
	protected function OnSetPerPage(kEvent $event)
	{
	$per_page = $this->Application->GetVar($event->getPrefixSpecial(true) . '_PerPage');
	$event->SetRedirectParam($event->getPrefixSpecial() . '_PerPage', $per_page);
	$event->SetRedirectParam('pass', 'all,' . $event->getPrefixSpecial());

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

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

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

	if ( !$this->Application->isAdminUser ) {
	$this->_passListParams($event, 'page');
	}
	}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

	$object->SetPage($page);
	}

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

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

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

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

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

	return $per_page;
	}

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

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

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

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

	if ( $per_page ) {
	// per-page found in request -> store in session and persistent session
	$this->setListSetting($event, 'PerPage', $per_page);
	}
	else {
	// per-page not found in request -> get from pesistent session (or session)
	$per_page = $this->getListSetting($event, 'PerPage');
	}
	}

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

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

	if ( !is_numeric($default_per_page) ) {
	$default_per_page = $this->Application->ConfigValue('DefaultGridPerPage');
	}

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

	return $per_page;
	}

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

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

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

	if ( $sort_by ) {
	list ($cur_sort1, $cur_sort1_dir) = explode(',', $sort_by);
	}
	}
	else {
	$sorting_settings = $this->getListSetting($event, 'Sortings');

	$cur_sort1 = getArrayValue($sorting_settings, 'Sort1');
	$cur_sort1_dir = getArrayValue($sorting_settings, 'Sort1_Dir');
	$cur_sort2 = getArrayValue($sorting_settings, 'Sort2');
	$cur_sort2_dir = getArrayValue($sorting_settings, 'Sort2_Dir');
	}

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

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

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

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

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

	// TODO: lowercase configuration variable values in db, instead of here
	$list_sortings[$sorting_prefix]['Sorting'] = array_map('strtolower', $list_sortings[$sorting_prefix]['Sorting']);
	}

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

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

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

	// always add forced sorting before any user sorting fields
	$forced_sorting = getArrayValue($list_sortings, $sorting_prefix, 'ForcedSorting');
	/* @var $forced_sorting Array */

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

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

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

	/**
	* Gets list setting by name (persistent or real session)
	*
	* @param kEvent $event
	* @param string $variable_name
	* @return string\|Array
	* @access protected
	*/
	protected function getListSetting(kEvent $event, $variable_name)
	{
	$view_name = $this->Application->RecallVar($event->getPrefixSpecial() . '_current_view');
	$storage_prefix = $event->getEventParam('same_special') ? $event->Prefix : $event->getPrefixSpecial();

	// get sorting from persistent session
	$variable_value = $this->Application->RecallPersistentVar($storage_prefix . '_' . $variable_name . '.' . $view_name, ALLOW_DEFAULT_SETTINGS);

	/*if ( !$variable_value ) {
	// get sorting from session
	$variable_value = $this->Application->RecallVar($storage_prefix . '_' . $variable_name);
	}*/

	if ( kUtil::IsSerialized($variable_value) ) {
	$variable_value = unserialize($variable_value);
	}

	return $variable_value;
	}

	/**
	* Sets list setting by name (persistent and real session)
	*
	* @param kEvent $event
	* @param string $variable_name
	* @param string\|Array $variable_value
	* @return void
	* @access protected
	*/
	protected function setListSetting(kEvent $event, $variable_name, $variable_value = null)
	{
	$view_name = $this->Application->RecallVar($event->getPrefixSpecial() . '_current_view');
	// $this->Application->StoreVar($event->getPrefixSpecial() . '_' . $variable_name, $variable_value, true); //true for optional

	if ( isset($variable_value) ) {
	if ( is_array($variable_value) ) {
	$variable_value = serialize($variable_value);
	}

	$this->Application->StorePersistentVar($event->getPrefixSpecial() . '_' . $variable_name . '.' . $view_name, $variable_value, true); //true for optional
	}
	else {
	$this->Application->RemovePersistentVar($event->getPrefixSpecial() . '_' . $variable_name . '.' . $view_name);
	}
	}

	/**
	* Add filters found in session
	*
	* @param kEvent $event
	* @return void
	* @access protected
	*/
	protected function AddFilters(kEvent $event)
	{
	$object = $event->getObject();
	/* @var $object kDBList */

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

	// add search filter
	$filter_data = $this->Application->RecallVar($event->getPrefixSpecial() . '_search_filter');

	if ( $filter_data ) {
	$filter_data = unserialize($filter_data);

	foreach ($filter_data as $filter_field => $filter_params) {
	$filter_type = ($filter_params['type'] == 'having') ? kDBList::HAVING_FILTER : kDBList::WHERE_FILTER;
	$filter_value = str_replace(EDIT_MARK, $edit_mark, $filter_params['value']);
	$object->addFilter($filter_field, $filter_value, $filter_type, kDBList::FLT_SEARCH);
	}
	}

	// add custom filter
	$view_name = $this->Application->RecallVar($event->getPrefixSpecial() . '_current_view');
	$custom_filters = $this->Application->RecallPersistentVar($event->getPrefixSpecial() . '_custom_filter.' . $view_name);

	if ( $custom_filters ) {
	$grid_name = $event->getEventParam('grid');
	$custom_filters = unserialize($custom_filters);

	if ( isset($custom_filters[$grid_name]) ) {
	foreach ($custom_filters[$grid_name] as $field_name => $field_options) {
	list ($filter_type, $field_options) = each($field_options);

	if ( isset($field_options['value']) && $field_options['value'] ) {
	$filter_type = ($field_options['sql_filter_type'] == 'having') ? kDBList::HAVING_FILTER : kDBList::WHERE_FILTER;
	$filter_value = str_replace(EDIT_MARK, $edit_mark, $field_options['value']);
	$object->addFilter($field_name, $filter_value, $filter_type, kDBList::FLT_CUSTOM);
	}
	}
	}
	}

	// add view filter
	$view_filter = $this->Application->RecallVar($event->getPrefixSpecial() . '_view_filter');

	if ( $view_filter ) {
	$view_filter = unserialize($view_filter);

	$temp_filter = $this->Application->makeClass('kMultipleFilter');
	/* @var $temp_filter kMultipleFilter */

	$filter_menu = $this->Application->getUnitOption($event->Prefix, 'FilterMenu');

	$group_key = 0;
	$group_count = count($filter_menu['Groups']);

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

	$temp_filter->setType(constant('kDBList::FLT_TYPE_' . $group_info['mode']));
	$temp_filter->clearFilters();

	foreach ($group_info['filters'] as $flt_id) {
	$sql_key = getArrayValue($view_filter, $flt_id) ? 'on_sql' : 'off_sql';

	if ( $filter_menu['Filters'][$flt_id][$sql_key] != '' ) {
	$temp_filter->addFilter('view_filter_' . $flt_id, $filter_menu['Filters'][$flt_id][$sql_key]);
	}
	}

	$object->addFilter('view_group_' . $group_key, $temp_filter, $group_info['type'], kDBList::FLT_VIEW);
	$group_key++;
	}
	}

	// add item filter
	if ( $object->isMainList() ) {
	$this->applyItemFilters($event);
	}
	}

	/**
	* Applies item filters
	*
	* @param kEvent $event
	* @return void
	* @access protected
	*/
	protected function applyItemFilters($event)
	{
	$filter_values = $this->Application->GetVar('filters', Array ());

	if ( !$filter_values ) {
	return;
	}

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

	$where_clause = Array (
	'ItemPrefix = ' . $this->Conn->qstr($object->Prefix),
	'FilterField IN (' . implode(',', $this->Conn->qstrArray(array_keys($filter_values))) . ')',
	'Enabled = 1',
	);

	$sql = 'SELECT *
	FROM ' . $this->Application->getUnitOption('item-filter', 'TableName') . '
	WHERE (' . implode(') AND (', $where_clause) . ')';
	$filters = $this->Conn->Query($sql, 'FilterField');

	foreach ($filters as $filter_field => $filter_data) {
	$filter_value = $filter_values[$filter_field];

	if ( "$filter_value" === '' ) {
	// ListManager don't pass empty values, but check here just in case
	continue;
	}

	$table_name = $object->isVirtualField($filter_field) ? '' : '%1$s.';

	switch ($filter_data['FilterType']) {
	case 'radio':
	$filter_value = $table_name . '`' . $filter_field . '` = ' . $this->Conn->qstr($filter_value);
	break;

	case 'checkbox':
	$filter_value = explode('\|', substr($filter_value, 1, -1));
	$filter_value = $this->Conn->qstrArray($filter_value, 'escape');

	if ( $object->GetFieldOption($filter_field, 'multiple') ) {
	$filter_value = $table_name . '`' . $filter_field . '` LIKE "%\|' . implode('\|%" OR ' . $table_name . '`' . $filter_field . '` LIKE "%\|', $filter_value) . '\|%"';
	}
	else {
	$filter_value = $table_name . '`' . $filter_field . '` IN (' . implode(',', $filter_value) . ')';
	}
	break;

	case 'range':
	$filter_value = $this->Conn->qstrArray(explode('-', $filter_value));
	$filter_value = $table_name . '`' . $filter_field . '` BETWEEN ' . $filter_value[0] . ' AND ' . $filter_value[1];
	break;
	}

	$object->addFilter('item_filter_' . $filter_field, $filter_value, $object->isVirtualField($filter_field) ? kDBList::HAVING_FILTER : kDBList::WHERE_FILTER);
	}
	}

	/**
	* Set's new sorting for list
	*
	* @param kEvent $event
	* @return void
	* @access protected
	*/
	protected function OnSetSorting(kEvent $event)
	{
	$sorting_settings = $this->getListSetting($event, 'Sortings');
	$cur_sort1 = getArrayValue($sorting_settings, 'Sort1');
	$cur_sort1_dir = getArrayValue($sorting_settings, 'Sort1_Dir');

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

	if ( $use_double_sorting ) {
	$cur_sort2 = getArrayValue($sorting_settings, 'Sort2');
	$cur_sort2_dir = getArrayValue($sorting_settings, 'Sort2_Dir');
	}

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

	$cur_sort1 = $passed_sort1;
	$cur_sort1_dir = 'asc';
	}

	$sorting_settings = Array ('Sort1' => $cur_sort1, 'Sort1_Dir' => $cur_sort1_dir);

	if ( $use_double_sorting ) {
	$sorting_settings['Sort2'] = $cur_sort2;
	$sorting_settings['Sort2_Dir'] = $cur_sort2_dir;
	}

	$this->setListSetting($event, 'Sortings', $sorting_settings);
	}

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

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

	if ( $this->Application->isAdmin \|\| !$this->Application->GetVar('main_list') ) {
	$this->setListSetting($event, 'Sortings', Array ('Sort1' => $field, 'Sort1_Dir' => $dir));
	}
	else {
	$event->setPseudoClass('_List');
	$this->Application->SetVar('sort_by', $field . ',' . $dir);

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

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

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

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

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

	return;
	}

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

	/**
	* Reset grid sorting to default (from config)
	*
	* @param kEvent $event
	* @return void
	* @access protected
	*/
	protected function OnResetSorting(kEvent $event)
	{
	$this->setListSetting($event, 'Sortings');
	}

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

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

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

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

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

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

	/**
	* Creates needed sql query to load item,
	* if no query is defined in config for
	* special requested, then use list query
	*
	* @param kEvent $event
	* @return string
	* @access protected
	*/
	protected function ItemPrepareQuery(kEvent $event)
	{
	$object = $event->getObject();
	/* @var $object kDBItem */

	$sqls = $object->getFormOption('ItemSQLs', Array ());
	$special = isset($sqls[$event->Special]) ? $event->Special : '';

	// preferred special not found in ItemSQLs -> use analog from ListSQLs

	return isset($sqls[$special]) ? $sqls[$special] : $this->ListPrepareQuery($event);
	}

	/**
	* Creates needed sql query to load list,
	* if no query is defined in config for
	* special requested, then use default
	* query
	*
	* @param kEvent $event
	* @return string
	* @access protected
	*/
	protected function ListPrepareQuery(kEvent $event)
	{
	$object = $event->getObject();
	/* @var $object kDBItem */

	$sqls = $object->getFormOption('ListSQLs', Array ());

	return $sqls[array_key_exists($event->Special, $sqls) ? $event->Special : ''];
	}

	/**
	* Apply custom processing to item
	*
	* @param kEvent $event
	* @param string $type
	* @return void
	* @access protected
	*/
	protected function customProcessing(kEvent $event, $type)
	{

	}

	/* Edit Events mostly used in Admin */

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

	$items_info = $this->Application->GetVar($event->getPrefixSpecial(true));

	if ( !$items_info ) {
	return;
	}

	list($id, $field_values) = each($items_info);
	$object->SetFieldsFromHash($field_values, $this->getRequestProtectedFields($field_values));

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

	// look at kDBItem' Create for ForceCreateId description, it's rarely used and is NOT set by default
	if ( $object->Create($event->getEventParam('ForceCreateId')) ) {
	$this->customProcessing($event, 'after');
	$event->SetRedirectParam('opener', 'u');
	return;
	}

	$event->redirect = false;
	$event->status = kEvent::erFAIL;
	$this->Application->SetVar($event->getPrefixSpecial() . '_SaveEvent', 'OnCreate');
	$object->setID($id);
	}

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

	$this->_update($event);

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

	/**
	* Updates data in database based on request
	*
	* @param kEvent $event
	* @return void
	* @access protected
	*/
	protected function _update(kEvent $event)
	{
	$object = $event->getObject(Array ('skip_autoload' => true));
	/* @var $object kDBItem */

	$items_info = $this->Application->GetVar( $event->getPrefixSpecial(true) );

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

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

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

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

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

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

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

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

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

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

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

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

	$event->redirect = false;
	}

	/**
	* Cancels kDBItem Editing/Creation
	*
	* @param kEvent $event
	* @return void
	* @access protected
	*/
	protected function OnCancel(kEvent $event)
	{
	$object = $event->getObject(Array ('skip_autoload' => true));
	/* @var $object kDBItem */

	$items_info = $this->Application->GetVar($event->getPrefixSpecial(true));

	if ( $items_info ) {
	$delete_ids = Array ();

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

	foreach ($items_info as $id => $field_values) {
	$object->Load($id);
	// record created for using with selector (e.g. Reviews->Select User), and not validated => Delete it
	if ( $object->isLoaded() && !$object->Validate() && ($id <= 0) ) {
	$delete_ids[] = $id;
	}
	}

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

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

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

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

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

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

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

	$this->clearSelectedIDs($event);
	}

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

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

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

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

	$this->Application->RemoveVar($this->_getPendingActionVariableName($event));

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

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

	$temp_handler->PrepareEdit();

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

	/**
	* Saves content of temp table into live and
	* redirects to event' default redirect (normally grid template)
	*
	* @param kEvent $event
	* @return void
	* @access protected
	*/
	protected function OnSave(kEvent $event)
	{
	$event->CallSubEvent('OnPreSave');

	if ( $event->status != kEvent::erSUCCESS ) {
	return;
	}

	$skip_master = false;
	$temp_handler = $this->Application->recallObject($event->getPrefixSpecial() . '_TempHandler', 'kTempTablesHandler', Array ('parent_event' => $event));
	/* @var $temp_handler kTempTablesHandler */

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

	if ( !$this->Application->CheckPermission('SYSTEM_ACCESS.READONLY', 1) ) {
	$live_ids = $temp_handler->SaveEdit($event->getEventParam('master_ids') ? $event->getEventParam('master_ids') : Array ());

	if ( $live_ids === false ) {
	// coping from table failed, because we have another coping process to same table, that wasn't finished
	$event->status = kEvent::erFAIL;
	return;
	}

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

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

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

	$this->clearSelectedIDs($event);

	$event->SetRedirectParam('opener', 'u');
	$this->Application->RemoveVar($event->getPrefixSpecial() . '_modified');

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

	/**
	* Saves changes made in temporary table to log
	*
	* @param string $changes_var_name
	* @param bool $save
	* @return void
	* @access public
	*/
	public function SaveLoggedChanges($changes_var_name, $save = true)
	{
	// 1. get changes, that were made
	$changes = $this->Application->RecallVar($changes_var_name);
	$changes = $changes ? unserialize($changes) : Array ();
	$this->Application->RemoveVar($changes_var_name);

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

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

	$to_increment = Array ();

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

	/**
	* Cancels edit
	* Removes all temp tables and clears selected ids
	*
	* @param kEvent $event
	* @return void
	* @access protected
	*/
	protected function OnCancelEdit(kEvent $event)
	{
	$temp_handler = $this->Application->recallObject($event->getPrefixSpecial() . '_TempHandler', 'kTempTablesHandler', Array ('parent_event' => $event));
	/* @var $temp_handler kTempTablesHandler */

	$temp_handler->CancelEdit();
	$this->clearSelectedIDs($event);

	$this->Application->RemoveVar($event->getPrefixSpecial() . '_modified');

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

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

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

	return !$object->isLoaded();
	}

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

	if ( $this->isNewItemCreate($event) ) {
	$event->CallSubEvent('OnPreSaveCreated');

	if ( is_object($event->MasterEvent) ) {
	$event->MasterEvent->setEventParam('IsNew', true);
	}

	return ;
	}

	// don't just call OnUpdate event here, since it maybe overwritten to Front-End specific behavior
	$this->_update($event);
	}

	/**
	* [HOOK] Saves sub-item
	*
	* @param kEvent $event
	* @return void
	* @access protected
	*/
	protected function OnPreSaveSubItem(kEvent $event)
	{
	$not_created = $this->isNewItemCreate($event);

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

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

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

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

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

	/**
	* Saves edited item in temp table and goes
	* to passed tabs, by redirecting to it with OnPreSave event
	*
	* @param kEvent $event
	* @return void
	* @access protected
	*/
	protected function OnPreSaveAndGoToTab(kEvent $event)
	{
	$event->CallSubEvent('OnPreSave');

	if ( $event->status == kEvent::erSUCCESS ) {
	$event->redirect = $this->Application->GetVar($event->getPrefixSpecial(true) . '_GoTab');
	}
	}

	/**
	* Saves editable list and goes to passed tab,
	* by redirecting to it with empty event
	*
	* @param kEvent $event
	* @return void
	* @access protected
	*/
	protected function OnUpdateAndGoToTab(kEvent $event)
	{
	$event->setPseudoClass('_List');
	$event->CallSubEvent('OnUpdate');

	if ( $event->status == kEvent::erSUCCESS ) {
	$event->redirect = $this->Application->GetVar($event->getPrefixSpecial(true) . '_GoTab');
	}
	}

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

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

	$temp_handler = $this->Application->recallObject($event->Prefix . '_TempHandler', 'kTempTablesHandler', Array ('parent_event' => $event));
	/* @var $temp_handler kTempTablesHandler */

	$temp_handler->PrepareEdit();

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

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

	$event->redirect = false;
	}

	/**
	* Creates a new item in temp table and
	* stores item id in App vars and Session on success
	*
	* @param kEvent $event
	* @return void
	* @access protected
	*/
	protected function OnPreSaveCreated(kEvent $event)
	{
	$object = $event->getObject( Array('skip_autoload' => true) );
	/* @var $object kDBItem */

	$field_values = $this->getSubmittedFields($event);
	$object->SetFieldsFromHash($field_values, $this->getRequestProtectedFields($field_values));

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

	if ( $object->Create() ) {
	$this->customProcessing($event, 'after');
	$event->SetRedirectParam($event->getPrefixSpecial(true) . '_id', $object->GetID());
	}
	else {
	$event->status = kEvent::erFAIL;
	$event->redirect = false;
	$object->setID(0);
	}
	}

	/**
	* Reloads form to loose all changes made during item editing
	*
	* @param kEvent $event
	* @return void
	* @access protected
	*/
	protected function OnReset(kEvent $event)
	{
	//do nothing - should reset :)
	if ( $this->isNewItemCreate($event) ) {
	// just reset id to 0 in case it was create
	$object = $event->getObject( Array ('skip_autoload' => true) );
	/* @var $object kDBItem */

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

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

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

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

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

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

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

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

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

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

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

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

	$this->clearSelectedIDs($event);
	}

	/**
	* Clones selected items in list
	*
	* @param kEvent $event
	* @return void
	* @access protected
	*/
	protected function OnMassClone(kEvent $event)
	{
	if ( $this->Application->CheckPermission('SYSTEM_ACCESS.READONLY', 1) ) {
	$event->status = kEvent::erFAIL;
	return;
	}

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

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

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

	$this->clearSelectedIDs($event);
	}

	/**
	* Checks if given value is present in given array
	*
	* @param Array $records
	* @param string $field
	* @param mixed $value
	* @return bool
	* @access protected
	*/
	protected function check_array($records, $field, $value)
	{
	foreach ($records as $record) {
	if ($record[$field] == $value) {
	return true;
	}
	}

	return false;
	}

	/**
	* Saves data from editing form to database without checking required fields
	*
	* @param kEvent $event
	* @return void
	* @access protected
	*/
	protected function OnPreSavePopup(kEvent $event)
	{
	$object = $event->getObject();
	/* @var $object kDBItem */

	$this->RemoveRequiredFields($object);
	$event->CallSubEvent('OnPreSave');

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


	/* End of Edit events */

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

	/**
	* Occurs before loading item, 'id' parameter
	* allows to get id of item being loaded
	*
	* @param kEvent $event
	* @return void
	* @access protected
	*/
	protected function OnBeforeItemLoad(kEvent $event)
	{

	}

	/**
	* Occurs after loading item, 'id' parameter
	* allows to get id of item that was loaded
	*
	* @param kEvent $event
	* @return void
	* @access protected
	*/
	protected function OnAfterItemLoad(kEvent $event)
	{

	}

	/**
	* Occurs before creating item
	*
	* @param kEvent $event
	* @return void
	* @access protected
	*/
	protected function OnBeforeItemCreate(kEvent $event)
	{

	}

	/**
	* Occurs after creating item
	*
	* @param kEvent $event
	* @return void
	* @access protected
	*/
	protected function OnAfterItemCreate(kEvent $event)
	{
	$object = $event->getObject();
	/* @var $object kDBItem */

	if ( !$object->IsTempTable() ) {
	$this->_proccessPendingActions($event);
	}
	}

	/**
	* Occurs before updating item
	*
	* @param kEvent $event
	* @return void
	* @access protected
	*/
	protected function OnBeforeItemUpdate(kEvent $event)
	{

	}

	/**
	* Occurs after updating item
	*
	* @param kEvent $event
	* @return void
	* @access protected
	*/
	protected function OnAfterItemUpdate(kEvent $event)
	{
	$object = $event->getObject();
	/* @var $object kDBItem */

	if ( !$object->IsTempTable() ) {
	$this->_proccessPendingActions($event);
	}
	}

	/**
	* Occurs before deleting item, id of item being
	* deleted is stored as 'id' event param
	*
	* @param kEvent $event
	* @return void
	* @access protected
	*/
	protected function OnBeforeItemDelete(kEvent $event)
	{

	}

	/**
	* Occurs after deleting item, id of deleted item
	* is stored as 'id' param of event
	*
	* @param kEvent $event
	* @return void
	* @access protected
	*/
	protected function OnAfterItemDelete(kEvent $event)
	{

	}

	/**
	* Occurs before validation attempt
	*
	* @param kEvent $event
	* @return void
	* @access protected
	*/
	protected function OnBeforeItemValidate(kEvent $event)
	{

	}

	/**
	* Occurs after successful item validation
	*
	* @param kEvent $event
	* @return void
	* @access protected
	*/
	protected function OnAfterItemValidate(kEvent $event)
	{

	}

	/**
	* Occurs after an item has been copied to temp
	* Id of copied item is passed as event' 'id' param
	*
	* @param kEvent $event
	* @return void
	* @access protected
	*/
	protected function OnAfterCopyToTemp(kEvent $event)
	{

	}

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

	}

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

	}

	/**
	* Occurs after an item has been copied to live table
	* Id of copied item is passed as event' 'id' param
	*
	* @param kEvent $event
	* @return void
	* @access protected
	*/
	protected function OnAfterCopyToLive(kEvent $event)
	{
	$this->_proccessPendingActions($event);
	}

	/**
	* Processing file pending actions (e.g. delete scheduled files)
	*
	* @param kEvent $event
	* @return void
	* @access protected
	*/
	protected function _proccessPendingActions(kEvent $event)
	{
	$var_name = $this->_getPendingActionVariableName($event);
	$schedule = $this->Application->RecallVar($var_name);

	if ( $schedule ) {
	$schedule = unserialize($schedule);

	foreach ($schedule as $data) {
	if ( $data['action'] == 'delete' ) {
	unlink($data['file']);
	}
	}

	$this->Application->RemoveVar($var_name);
	}
	}

	/**
	* Returns variable name, used to store pending file actions
	*
	* @param kEvent $event
	* @return string
	* @access protected
	*/
	protected function _getPendingActionVariableName(kEvent $event)
	{
	$window_id = $this->Application->GetTopmostWid($event->Prefix);

	return $event->Prefix . '_file_pending_actions' . $window_id;
	}

	/**
	* Occurs before an item has been cloned
	* Id of newly created item is passed as event' 'id' param
	*
	* @param kEvent $event
	* @return void
	* @access protected
	*/
	protected function OnBeforeClone(kEvent $event)
	{

	}

	/**
	* Occurs after an item has been cloned
	* Id of newly created item is passed as event' 'id' param
	*
	* @param kEvent $event
	* @return void
	* @access protected
	*/
	protected function OnAfterClone(kEvent $event)
	{

	}

	/**
	* Occurs after list is queried
	*
	* @param kEvent $event
	* @return void
	* @access protected
	*/
	protected function OnAfterListQuery(kEvent $event)
	{

	}

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

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

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

	$search_helper->performSearch($event);
	}

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

	$search_helper->resetSearch($event);
	}

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

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

	$view_filter[$filter_id] = $filter_value;

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

	/**
	* Sets view filter based on request
	*
	* @param kEvent $event
	* @return void
	* @access protected
	*/
	protected function OnSetFilterPattern(kEvent $event)
	{
	$filters = $this->Application->GetVar($event->getPrefixSpecial(true) . '_filters');
	if ( !$filters ) {
	return;
	}

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

	$filters = explode(',', $filters);

	foreach ($filters as $a_filter) {
	list($id, $value) = explode('=', $a_filter);
	$view_filter[$id] = $value;
	}

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

	/**
	* Add/Remove all filters applied to list from "View" menu
	*
	* @param kEvent $event
	* @return void
	* @access protected
	*/
	protected function FilterAction(kEvent $event)
	{
	$view_filter = Array ();
	$filter_menu = $this->Application->getUnitOption($event->Prefix, 'FilterMenu');

	switch ($event->Name) {
	case 'OnRemoveFilters':
	$filter_value = 1;
	break;

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

	default:
	$filter_value = 0;
	break;
	}

	foreach ($filter_menu['Filters'] as $filter_key => $filter_params) {
	if ( !$filter_params ) {
	continue;
	}

	$view_filter[$filter_key] = $filter_value;
	}

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

	/**
	* Enter description here...
	*
	* @param kEvent $event
	* @access protected
	*/
	protected function OnPreSaveAndOpenTranslator(kEvent $event)
	{
	$this->Application->SetVar('allow_translation', true);

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

	$this->RemoveRequiredFields($object);
	$event->CallSubEvent('OnPreSave');

	if ( $event->status == kEvent::erSUCCESS ) {
	$resource_id = $this->Application->GetVar('translator_resource_id');

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

	$cdata = $this->Application->recallObject($t_prefixes[1], null, Array ('skip_autoload' => true));
	/* @var $cdata kDBItem */

	$cdata->Load($resource_id, 'ResourceId');

	if ( !$cdata->isLoaded() ) {
	$cdata->SetDBField('ResourceId', $resource_id);
	$cdata->Create();
	}

	$this->Application->SetVar($cdata->getPrefixSpecial() . '_id', $cdata->GetID());
	}

	$event->redirect = $this->Application->GetVar('translator_t');

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

	$event->setRedirectParams($redirect_params);

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

	/**
	* Makes all fields non-required
	*
	* @param kDBItem $object
	* @return void
	* @access protected
	*/
	protected function RemoveRequiredFields(&$object)
	{
	// making all field non-required to achieve successful presave
	$fields = array_keys( $object->getFields() );

	foreach ($fields as $field) {
	if ( $object->isRequired($field) ) {
	$object->setRequired($field, false);
	}
	}
	}

	/**
	* Saves selected user in needed field
	*
	* @param kEvent $event
	* @return void
	* @access protected
	*/
	protected function OnSelectUser(kEvent $event)
	{
	$object = $event->getObject();
	/* @var $object kDBItem */

	$items_info = $this->Application->GetVar('u');

	if ( $items_info ) {
	$user_id = array_shift(array_keys($items_info));

	$this->RemoveRequiredFields($object);

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

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

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

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

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


	/ EXPORT RELATED /

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

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

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

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

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

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

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

	$event->setRedirectParams($redirect_params);
	}

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

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

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

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

	$export_helper->OnExportBegin($event);
	}

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

	/**
	* Allows configuring export options
	*
	* @param kEvent $event
	* @return void
	* @access protected
	*/
	protected function OnBeforeExportBegin(kEvent $event)
	{

	}

	/**
	* Deletes export preset
	*
	* @param kEvent $event
	* @return void
	* @access protected
	*/
	protected function OnDeleteExportPreset(kEvent $event)
	{
	$field_values = $this->getSubmittedFields($event);

	if ( !$field_values ) {
	return ;
	}

	$preset_key = $field_values['ExportPresets'];
	$export_settings = $this->Application->RecallPersistentVar('export_settings');

	if ( !$export_settings ) {
	return ;
	}

	$export_settings = unserialize($export_settings);

	if ( !isset($export_settings[$event->Prefix]) ) {
	return ;
	}

	$to_delete = '';

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

	if ( $to_delete ) {
	unset($export_settings[$event->Prefix][$to_delete]);
	$this->Application->StorePersistentVar('export_settings', serialize($export_settings));
	}
	}

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

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

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

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

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

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

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

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

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

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

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

	$field_name = $this->Application->GetVar('field');
	$fields = $this->Application->getUnitOption($event->Prefix, 'Fields');
	$virtual_fields = $this->Application->getUnitOption($event->Prefix, 'VirtualFields');
	$field_options = array_key_exists($field_name, $fields) ? $fields[$field_name] : $virtual_fields[$field_name];

	$upload_dir = $field_options['upload_dir'];
	$storage_format = array_key_exists('storage_format', $field_options) ? $field_options['storage_format'] : false;

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

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

	$fname = $file_helper->ensureUniqueFilename($tmp_path, $fname);

	if ( $storage_format ) {
	$image_helper = $this->Application->recallObject('ImageHelper');
	/* @var $image_helper ImageHelper */

	move_uploaded_file($value['tmp_name'], $value['tmp_name'] . '.jpg'); // add extension, so ResizeImage can work
	$url = $image_helper->ResizeImage($value['tmp_name'] . '.jpg', $storage_format);
	$tmp_name = preg_replace('/^' . preg_quote($this->Application->BaseURL(), '/') . '/', '/', $url);
	rename($tmp_name, $tmp_path . $fname);
	}
	else {
	move_uploaded_file($value['tmp_name'], $tmp_path . $fname);
	}

	echo preg_replace('/^' . preg_quote($id, '/') . '_/', '', $fname);

	$this->deleteTempFiles($tmp_path);
	}

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

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

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

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

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

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

	// copy some data from given session to current session
	$backup_user_id = $this->Application->RecallVar('user_id');
	$this->Application->StoreVar('user_id', $admin_ses->RecallVar('user_id'));

	$backup_user_groups = $this->Application->RecallVar('UserGroups');
	$this->Application->StoreVar('UserGroups', $admin_ses->RecallVar('UserGroups'));

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

	// restore changed data, so nothing gets saved to database
	$this->Application->StoreVar('user_id', $backup_user_id);
	$this->Application->StoreVar('UserGroups', $backup_user_groups);

	return $allowed_to_upload;
	}

	/**
	* Remembers, that file should be deleted on item's save from temp table
	*
	* @param kEvent $event
	* @return void
	* @access protected
	*/
	protected function OnDeleteFile(kEvent $event)
	{
	$event->status = kEvent::erSTOP;

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

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

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

	/**
	* Returns url for viewing uploaded file
	*
	* @param kEvent $event
	* @return void
	* @access protected
	*/
	protected function OnViewFile(kEvent $event)
	{
	$event->status = kEvent::erSTOP;

	$file = $this->Application->GetVar('file');
	if ( (strpos($file, '../') !== false) \|\| (trim($file) !== $file) ) {
	// when relative paths or special chars are found template names from url, then it's hacking attempt
	return;
	}

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

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

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

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

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

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

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

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

	header('Content-Length: ' . filesize($path));
	- header('Content-Type: ' . kUtil::mimeContentType($path));
	+ $this->Application->setContentType(kUtil::mimeContentType($path), false);
	header('Content-Disposition: inline; filename="' . $file . '"');

	readfile($path);
	}

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

	$minput_helper->OnValidateMInputFields($event);
	}

	/**
	* Validates individual object field and returns the result
	*
	* @param kEvent $event
	* @return void
	* @access protected
	*/
	protected function OnValidateField(kEvent $event)
	{
	$event->status = kEvent::erSTOP;
	$field = $this->Application->GetVar('field');

	if ( ($this->Application->GetVar('ajax') != 'yes') \|\| !$field ) {
	return;
	}

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

	$items_info = $this->Application->GetVar($event->getPrefixSpecial(true));

	if ( !$items_info ) {
	return;
	}

	list ($id, $field_values) = each($items_info);
	$object->Load($id);
	$object->SetFieldsFromHash($field_values, $this->getRequestProtectedFields($field_values));
	$object->setID($id);

	$response = Array ('status' => 'OK');

	$event->CallSubEvent($object->isLoaded() ? 'OnBeforeItemUpdate' : 'OnBeforeItemCreate');

	// validate all fields, since "Password_plain" field sets error to "Password" field, which is passed here
	$error_field = $object->GetFieldOption($field, 'error_field', false, $field);

	if ( !$object->Validate() && $object->GetErrorPseudo($error_field) ) {
	$response['status'] = $object->GetErrorMsg($error_field);
	}

	$ajax_form_helper = $this->Application->recallObject('AjaxFormHelper');
	/* @var $ajax_form_helper AjaxFormHelper */

	$response['other_errors'] = $ajax_form_helper->getErrorMessages($object);

	$event->status = kEvent::erSTOP; // since event's OnBefore... events can change this event status
	echo json_encode($response);
	}

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

	$event->status = kEvent::erSTOP;

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

	$object = $event->getObject();

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

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

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

	$this->Application->XMLHeader();

	echo '<suggestions>';

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

	echo '</suggestions>';
	}

	/**
	* Enter description here...
	*
	* @param kEvent $event
	* @return void
	* @access protected
	*/
	protected function OnSaveWidths(kEvent $event)
	{
	$event->status = kEvent::erSTOP;

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

	$picker_helper = $this->Application->recallObject('ColumnPickerHelper');
	/* @var $picker_helper kColumnPickerHelper */

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

	echo 'OK';
	}

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

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

	$subitem_prefix = $event->Prefix . '-' . preg_replace('/^#/', '', $event->MasterEvent->Prefix);
	$clones[$subitem_prefix] = Array ('ParentPrefix' => $event->Prefix);
	$this->Application->setUnitOption($event->MasterEvent->Prefix, 'Clones', $clones);
	}

	/**
	* Returns constrain for priority calculations
	*
	* @param kEvent $event
	* @return void
	* @see PriorityEventHandler
	* @access protected
	*/
	protected function OnGetConstrainInfo(kEvent $event)
	{
	$event->setEventParam('constrain_info', Array ('', ''));
	}
	}
	\ No newline at end of file
	Index: branches/5.2.x/core/kernel/application.php
	===================================================================
	--- branches/5.2.x/core/kernel/application.php (revision 15172)
	+++ branches/5.2.x/core/kernel/application.php (revision 15173)
	@@ -1,3132 +1,3161 @@
	<?php
	/**
	* @version $Id$
	* @package In-Portal
	* @copyright Copyright (C) 1997 - 2009 Intechnic. All rights reserved.
	* @license GNU/GPL
	* In-Portal is Open Source software.
	* This means that this software may have been modified pursuant
	* the GNU General Public License, and as distributed it includes
	* or is derivative of works licensed under the GNU General Public License
	* or other free or open source software licenses.
	* See http://www.in-portal.org/license for copyright notices and details.
	*/

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

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

	/**
	* Location of module helper class (used in installator too)
	*/
	const MODULE_HELPER_PATH = '/../units/helpers/modules_helper.php';

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

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

	/**
	* Holds parser output buffer
	*
	* @var string
	* @access protected
	*/
	protected $HTML = '';

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

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

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

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

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

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

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

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

	/**
	* Maintains list of user-defined exception handlers
	*
	* @var Array
	* @access public
	*/
	public $exceptionHandlers = Array ();

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

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

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

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

	/**
	* Holds a ref to kUrlManager
	*
	* @var kUrlManager
	* @access public
	*/
	public $UrlManager = null;

	/**
	* Ref for TemplatesCache
	*
	* @var TemplatesCache
	* @access public
	*/
	public $TemplatesCache = null;

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

	/**
	* Object of unit caching class
	*
	* @var kCacheManager
	* @access public
	*/
	public $cacheManager = null;

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

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

	/**
	* Instance of site domain object
	*
	* @var kDBItem
	* @access public
	* @todo move away into separate module
	*/
	public $siteDomain = null;

	/**
	* Prevent kApplication class to be created directly, only via Instance method
	*
	* @access private
	*/
	private function __construct()
	{

	}

	final private function __clone() {}

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

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

	return $instance;
	}

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

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

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

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

	if ( !$this->isDebugMode() && !kUtil::constOn('DBG_ZEND_PRESENT') ) {
	error_reporting(0);
	ini_set('display_errors', 0);
	}

	if ( !kUtil::constOn('DBG_ZEND_PRESENT') ) {
	$error_handler = set_error_handler(Array (&$this, 'handleError'));
	if ( $error_handler ) {
	// wrap around previous error handler, if any was set
	$this->errorHandlers[] = $error_handler;
	}

	$exception_handler = set_exception_handler(Array (&$this, 'handleException'));
	if ( $exception_handler ) {
	// wrap around previous exception handler, if any was set
	$this->exceptionHandlers[] = $exception_handler;
	}
	}

	$this->Factory = new $factory_class();
	$this->registerDefaultClasses();

	$vars = kUtil::parseConfig(true);
	$db_class = isset($vars['Databases']) ? 'kDBLoadBalancer' : 'kDBConnection';
	$this->Conn = $this->Factory->makeClass($db_class, Array (SQL_TYPE, Array (&$this, 'handleSQLError')));
	$this->Conn->setup($vars);

	$this->cacheManager = $this->makeClass('kCacheManager');
	$this->cacheManager->InitCache();

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

	// init config reader and all managers
	$this->UnitConfigReader = $this->makeClass('kUnitConfigReader');
	$this->UnitConfigReader->scanModules(MODULES_PATH); // will also set RewriteListeners when existing cache is read

	$this->registerModuleConstants();

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

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

	// start processing request
	$this->HttpQuery = $this->recallObject('HTTPQuery');
	$this->HttpQuery->process();

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

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

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

	$this->UrlManager->LoadStructureTemplateMapping();

	$this->Session->ValidateExpired(); // needs mod_rewrite url already parsed to keep user at proper template after session expiration

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

	$this->cacheManager->LoadApplicationCache();

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

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

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

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

	$this->UnitConfigReader->AfterConfigRead(); // will set RewriteListeners when missing cache is built first time

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

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

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

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

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

	$language = $this->recallObject('lang.current', null, Array ('live_table' => true));
	/* @var $language LanguagesItem */

	if ( preg_match('/utf-8/', $language->GetDBField('Charset')) ) {
	setlocale(LC_ALL, 'en_US.UTF-8');
	mb_internal_encoding('UTF-8');
	}

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

	$this->InitDone = true;

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

	return true;
	}

	/**
	* Performs initialization of manager classes, that can be overridden from unit configs
	*
	* @return void
	* @access public
	* @throws Exception
	*/
	public function InitManagers()
	{
	if ( $this->InitDone ) {
	throw new Exception('Duplicate call of ' . __METHOD__, E_USER_ERROR);
	return;
	}

	$this->UrlManager = $this->makeClass('kUrlManager');
	$this->EventManager = $this->makeClass('EventManager');
	$this->Phrases = $this->makeClass('kPhraseCache');

	$this->RegisterDefaultBuildEvents();
	}

	/**
	* Returns module information. Searches module by requested field
	*
	* @param string $field
	* @param mixed $value
	* @param string $return_field field value to returns, if not specified, then return all fields
	* @return Array
	*/
	public function findModule($field, $value, $return_field = null)
	{
	$found = $module_info = false;

	foreach ($this->ModuleInfo as $module_info) {
	if ( strtolower($module_info[$field]) == strtolower($value) ) {
	$found = true;
	break;
	}
	}

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

	return false;
	}

	/**
	* Refreshes information about loaded modules
	*
	* @return void
	* @access public
	*/
	public function refreshModuleInfo()
	{
	if ( defined('IS_INSTALL') && IS_INSTALL && !$this->TableFound('Modules', true) ) {
	$this->registerModuleConstants();
	return;
	}

	// use makeClass over recallObject, since used before kApplication initialization during installation
	$modules_helper = $this->makeClass('ModulesHelper');
	/* @var $modules_helper kModulesHelper */

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

	$this->registerModuleConstants();
	}

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

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

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

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

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

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

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

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

	return;
	}

	$path = $this->GetFrontThemePath();

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

	kUtil::safeDefine('THEMES_PATH', $path);
	}

	/**
	* Returns relative path to current front-end theme
	*
	* @param bool $force
	* @return string
	* @access public
	*/
	public function GetFrontThemePath($force = false)
	{
	static $path = null;

	if ( !$force && isset($path) ) {
	return $path;
	}

	$theme_id = $this->GetVar('m_theme');
	if ( !$theme_id ) {
	$theme_id = 'default'; // $this->GetDefaultThemeId(1); // 1 to force front-end mode!
	}

	$this->SetVar('m_theme', $theme_id);
	$this->SetVar('theme.current_id', $theme_id); // KOSTJA: this is to fool theme' getPassedID

	$theme = $this->recallObject('theme.current');
	/* @var $theme ThemeItem */

	if ( !$theme->isLoaded() \|\| !$theme->GetDBField('Enabled') ) {
	return false;
	}

	// assign & then return, since it's static variable
	$path = '/themes/' . $theme->GetDBField('Name');

	return $path;
	}

	/**
	* Returns primary front/admin language id
	*
	* @param bool $init
	* @return int
	* @access public
	*/
	public function GetDefaultLanguageId($init = false)
	{
	$cache_key = 'primary_language_info[%LangSerial%]';
	$language_info = $this->getCache($cache_key);

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

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

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

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

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

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

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

	return $language_id;
	}

	/**
	* Returns front-end primary theme id (even, when called from admin console)
	*
	* @param bool $force_front
	* @return int
	* @access public
	*/
	public function GetDefaultThemeId($force_front = false)
	{
	static $theme_id = 0;

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

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

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

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

	return $theme_id;
	}

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

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

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

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

	return $currency_iso;
	}

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

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

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

	return false;
	}

	/**
	* Registers default classes such as kDBEventHandler, kUrlManager
	*
	* Called automatically while initializing kApplication
	*
	* @return void
	* @access public
	*/
	public function RegisterDefaultClasses()
	{
	$this->registerClass('kHelper', KERNEL_PATH . '/kbase.php');
	$this->registerClass('kMultipleFilter', KERNEL_PATH . '/utility/filters.php');
	$this->registerClass('kiCacheable', KERNEL_PATH . '/interfaces/cacheable.php');

	$this->registerClass('kEventManager', KERNEL_PATH . '/event_manager.php', 'EventManager');
	$this->registerClass('kHookManager', KERNEL_PATH . '/managers/hook_manager.php');
	$this->registerClass('kScheduledTaskManager', KERNEL_PATH . '/managers/scheduled_task_manager.php');
	$this->registerClass('kRequestManager', KERNEL_PATH . '/managers/request_manager.php');

	$this->registerClass('kUrlManager', KERNEL_PATH . '/managers/url_manager.php');
	$this->registerClass('kUrlProcessor', KERNEL_PATH . '/managers/url_processor.php');
	$this->registerClass('kPlainUrlProcessor', KERNEL_PATH . '/managers/plain_url_processor.php');
	$this->registerClass('kRewriteUrlProcessor', KERNEL_PATH . '/managers/rewrite_url_processor.php');

	$this->registerClass('kCacheManager', KERNEL_PATH . '/managers/cache_manager.php');
	$this->registerClass('PhrasesCache', KERNEL_PATH . '/languages/phrases_cache.php', 'kPhraseCache');
	$this->registerClass('kTempTablesHandler', KERNEL_PATH . '/utility/temp_handler.php');
	$this->registerClass('kValidator', KERNEL_PATH . '/utility/validator.php');
	$this->registerClass('kOpenerStack', KERNEL_PATH . '/utility/opener_stack.php');

	$this->registerClass('kUnitConfigReader', KERNEL_PATH . '/utility/unit_config_reader.php');

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

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

	// template parser
	$this->registerClass('kTagProcessor', KERNEL_PATH . '/processors/tag_processor.php');
	$this->registerClass('kMainTagProcessor', KERNEL_PATH . '/processors/main_processor.php', 'm_TagProcessor');
	$this->registerClass('kDBTagProcessor', KERNEL_PATH . '/db/db_tag_processor.php');
	$this->registerClass('kCatDBTagProcessor', KERNEL_PATH . '/db/cat_tag_processor.php');
	$this->registerClass('NParser', KERNEL_PATH . '/nparser/nparser.php');
	$this->registerClass('TemplatesCache', KERNEL_PATH . '/nparser/template_cache.php');

	// database
	$this->registerClass('kDBConnection', KERNEL_PATH . '/db/db_connection.php');
	$this->registerClass('kDBLoadBalancer', KERNEL_PATH . '/db/db_load_balancer.php');
	$this->registerClass('kDBItem', KERNEL_PATH . '/db/dbitem.php');
	$this->registerClass('kCatDBItem', KERNEL_PATH . '/db/cat_dbitem.php');
	$this->registerClass('kDBList', KERNEL_PATH . '/db/dblist.php');
	$this->registerClass('kCatDBList', KERNEL_PATH . '/db/cat_dblist.php');
	$this->registerClass('kDBEventHandler', KERNEL_PATH . '/db/db_event_handler.php');
	$this->registerClass('kCatDBEventHandler', KERNEL_PATH . '/db/cat_event_handler.php');

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

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

	/**
	* Registers default build events
	*
	* @return void
	* @access protected
	*/
	protected function RegisterDefaultBuildEvents()
	{
	$this->EventManager->registerBuildEvent('kTempTablesHandler', 'OnTempHandlerBuild');
	}

	/**
	* Returns cached category information by given cache name. All given category
	* information is recached, when at least one of 4 caches is missing.
	*
	* @param int $category_id
	* @param string $name cache name = {filenames, category_designs, category_tree}
	* @return string
	* @access public
	*/
	public function getCategoryCache($category_id, $name)
	{
	return $this->cacheManager->getCategoryCache($category_id, $name);
	}

	/**
	* Returns caching type (none, memory, temporary)
	*
	* @param int $caching_type
	* @return bool
	* @access public
	*/
	public function isCachingType($caching_type)
	{
	return $this->cacheManager->isCachingType($caching_type);
	}

	/**
	* Increments serial based on prefix and it's ID (optional)
	*
	* @param string $prefix
	* @param int $id ID (value of IDField) or ForeignKeyField:ID
	* @param bool $increment
	* @return string
	* @access public
	*/
	public function incrementCacheSerial($prefix, $id = null, $increment = true)
	{
	return $this->cacheManager->incrementCacheSerial($prefix, $id, $increment);
	}

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

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

	/**
	* Sets rebuilding mode for given cache
	*
	* @param string $name
	* @param int $mode
	* @param int $max_rebuilding_time
	* @return void
	* @access public
	*/
	public function rebuildCache($name, $mode = null, $max_rebuilding_time = 0)
	{
	$this->cacheManager->rebuildCache($name, $mode, $max_rebuilding_time);
	}

	/**
	* Deletes key from cache
	*
	* @param string $key
	* @return void
	* @access public
	*/
	public function deleteCache($key)
	{
	$this->cacheManager->deleteCache($key);
	}

	/**
	* Reset's all memory cache at once
	*
	* @return void
	* @access public
	*/
	public function resetCache()
	{
	$this->cacheManager->resetCache();
	}

	/**
	* Returns value from database cache
	*
	* @param string $name key name
	* @param int $max_rebuild_seconds
	* @return mixed
	* @access public
	*/
	public function getDBCache($name, $max_rebuild_seconds = 0)
	{
	return $this->cacheManager->getDBCache($name, $max_rebuild_seconds);
	}

	/**
	* Sets value to database cache
	*
	* @param string $name
	* @param mixed $value
	* @param int\|bool $expiration
	* @return void
	* @access public
	*/
	public function setDBCache($name, $value, $expiration = false)
	{
	$this->cacheManager->setDBCache($name, $value, $expiration);
	}

	/**
	* Sets rebuilding mode for given cache
	*
	* @param string $name
	* @param int $mode
	* @param int $max_rebuilding_time
	* @return void
	* @access public
	*/
	public function rebuildDBCache($name, $mode = null, $max_rebuilding_time = 0)
	{
	$this->cacheManager->rebuildDBCache($name, $mode, $max_rebuilding_time);
	}

	/**
	* Deletes key from database cache
	*
	* @param string $name
	* @return void
	* @access public
	*/
	public function deleteDBCache($name)
	{
	$this->cacheManager->deleteDBCache($name);
	}

	/**
	* Registers each module specific constants if any found
	*
	* @return bool
	* @access protected
	*/
	protected function registerModuleConstants()
	{
	if ( file_exists(KERNEL_PATH . '/constants.php') ) {
	kUtil::includeOnce(KERNEL_PATH . '/constants.php');
	}

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

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

	if ( file_exists($constants_file) ) {
	kUtil::includeOnce($constants_file);
	}
	}

	return true;
	}

	/**
	* Performs redirect to hard maintenance template
	*
	* @return void
	* @access public
	*/
	public function redirectToMaintenance()
	{
	$maintenance_page = WRITEBALE_BASE . '/maintenance.html';
	$query_string = ''; // $this->isAdmin ? '' : '?next_template=' . urlencode($_SERVER['REQUEST_URI']);

	if ( file_exists(FULL_PATH . $maintenance_page) ) {
	header('Location: ' . BASE_PATH . $maintenance_page . $query_string);
	exit;
	}
	}

	/**
	* Actually runs the parser against current template and stores parsing result
	*
	* This method gets 't' variable passed to the script, loads the template given in 't' variable and
	* parses it. The result is store in {@link $this->HTML} property.
	*
	* @return void
	* @access public
	*/
	public function Run()
	{
	// process maintenance mode redirect: begin
	$maintenance_mode = $this->getMaintenanceMode();

	if ( $maintenance_mode == MaintenanceMode::HARD ) {
	$this->redirectToMaintenance();
	}
	elseif ( $maintenance_mode == MaintenanceMode::SOFT ) {
	$maintenance_template = $this->isAdmin ? 'login' : $this->ConfigValue('SoftMaintenanceTemplate');

	if ( $this->GetVar('t') != $maintenance_template ) {
	$redirect_params = Array ();

	if ( !$this->isAdmin ) {
	$redirect_params['next_template'] = urlencode($_SERVER['REQUEST_URI']);
	}

	$this->Redirect($maintenance_template, $redirect_params);
	}
	}
	// process maintenance mode redirect: end

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

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

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

	if ( $this->GetVar('ajax') == 'yes' && !$this->GetVar('debug_ajax') ) {
	// hide debug output from ajax requests automatically
	kUtil::safeDefine('DBG_SKIP_REPORTING', 1); // safeDefine, because debugger also defines it
	}
	}
	elseif ( $this->GetVar('admin') ) {
	$admin_session = $this->recallObject('Session.admin');
	/* @var $admin_session Session */

	// store Admin Console User's ID to Front-End's session for cross-session permission checks
	$this->StoreVar('admin_user_id', (int)$admin_session->RecallVar('user_id'));

	if ( $this->CheckAdminPermission('CATEGORY.MODIFY', 0, $this->getBaseCategory()) ) {
	// user can edit cms blocks (when viewing front-end through admin's frame)
	$editing_mode = $this->GetVar('editing_mode');
	define('EDITING_MODE', $editing_mode ? $editing_mode : EDITING_MODE_BROWSE);
	}
	}

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

	$this->EventManager->ProcessRequest();

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

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

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

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

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

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

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

	/**
	* Only renders template
	*
	* @see kDBEventHandler::_errorNotFound()
	*/
	public function QuickRun()
	{
	$this->InitParser();
	$this->HTML = $this->ParseBlock(Array ('name' => $this->GetVar('t')));
	}

	/**
	* Performs template parser/cache initialization
	*
	* @param bool\|string $theme_name
	* @return void
	* @access public
	*/
	public function InitParser($theme_name = false)
	{
	if ( !is_object($this->Parser) ) {
	$this->Parser = $this->recallObject('NParser');
	$this->TemplatesCache = $this->recallObject('TemplatesCache');
	}

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

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

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

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

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

	if ( kUtil::constOn('DBG_CACHE') ) {
	$this->cacheManager->printStatistics();
	}

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

	$this->HTML = ob_get_clean() . $this->HTML;
	}

	- $language = $this->recallObject('lang.current');
	- /* @var $language LanguagesItem */
	-
	- // don't replace header if some tag (e.g. XMLTemplate) already set it to something else
	- header('Content-type: text/html; charset=' . $language->GetDBField('Charset'), false);
	+ $this->setContentType();

	if ( $this->UseOutputCompression() ) {
	$compression_level = $this->ConfigValue('OutputCompressionLevel');

	if ( !$compression_level \|\| $compression_level < 0 \|\| $compression_level > 9 ) {
	$compression_level = 7;
	}

	header('Content-Encoding: gzip');
	echo gzencode($this->HTML, $compression_level);
	}
	else {
	echo $this->HTML;
	}

	$this->cacheManager->UpdateApplicationCache();
	flush();

	if ( !$debug_mode ) {
	$this->EventManager->runScheduledTasks();
	$this->Session->SaveData();
	}

	if ( defined('DBG_CAPTURE_STATISTICS') && DBG_CAPTURE_STATISTICS && !$this->isAdmin ) {
	$this->_storeStatistics();
	}
	}

	/**
	* Stores script execution statistics to database
	*
	* @return void
	* @access protected
	*/
	protected function _storeStatistics()
	{
	global $start;

	$script_time = microtime(true) - $start;
	$query_statistics = $this->Conn->getQueryStatistics(); // time & count

	$sql = 'SELECT *
	FROM ' . TABLE_PREFIX . 'StatisticsCapture
	WHERE TemplateName = ' . $this->Conn->qstr($this->GetVar('t'));
	$data = $this->Conn->GetRow($sql);

	if ( $data ) {
	$this->_updateAverageStatistics($data, 'ScriptTime', $script_time);
	$this->_updateAverageStatistics($data, 'SqlTime', $query_statistics['time']);
	$this->_updateAverageStatistics($data, 'SqlCount', $query_statistics['count']);

	$data['Hits']++;
	$data['LastHit'] = adodb_mktime();

	$this->Conn->doUpdate($data, TABLE_PREFIX . 'StatisticsCapture', 'StatisticsId = ' . $data['StatisticsId']);
	}
	else {
	$data['ScriptTimeMin'] = $data['ScriptTimeAvg'] = $data['ScriptTimeMax'] = $script_time;
	$data['SqlTimeMin'] = $data['SqlTimeAvg'] = $data['SqlTimeMax'] = $query_statistics['time'];
	$data['SqlCountMin'] = $data['SqlCountAvg'] = $data['SqlCountMax'] = $query_statistics['count'];
	$data['TemplateName'] = $this->GetVar('t');
	$data['Hits'] = 1;
	$data['LastHit'] = adodb_mktime();
	$this->Conn->doInsert($data, TABLE_PREFIX . 'StatisticsCapture');
	}
	}

	/**
	* Calculates average time for statistics
	*
	* @param Array $data
	* @param string $field_prefix
	* @param float $current_value
	* @return void
	* @access protected
	*/
	protected function _updateAverageStatistics(&$data, $field_prefix, $current_value)
	{
	$data[$field_prefix . 'Avg'] = (($data['Hits'] * $data[$field_prefix . 'Avg']) + $current_value) / ($data['Hits'] + 1);

	if ( $current_value < $data[$field_prefix . 'Min'] ) {
	$data[$field_prefix . 'Min'] = $current_value;
	}

	if ( $current_value > $data[$field_prefix . 'Max'] ) {
	$data[$field_prefix . 'Max'] = $current_value;
	}
	}

	/**
	* Remembers slow query SQL and execution time into log
	*
	* @param string $slow_sql
	* @param int $time
	* @return void
	* @access public
	*/
	public function logSlowQuery($slow_sql, $time)
	{
	$query_crc = crc32($slow_sql);

	$sql = 'SELECT *
	FROM ' . TABLE_PREFIX . 'SlowSqlCapture
	WHERE QueryCrc = ' . $query_crc;
	$data = $this->Conn->Query($sql, null, true);

	if ( $data ) {
	$this->_updateAverageStatistics($data, 'Time', $time);

	$template_names = explode(',', $data['TemplateNames']);
	array_push($template_names, $this->GetVar('t'));
	$data['TemplateNames'] = implode(',', array_unique($template_names));

	$data['Hits']++;
	$data['LastHit'] = adodb_mktime();

	$this->Conn->doUpdate($data, TABLE_PREFIX . 'SlowSqlCapture', 'CaptureId = ' . $data['CaptureId']);
	}
	else {
	$data['TimeMin'] = $data['TimeAvg'] = $data['TimeMax'] = $time;
	$data['SqlQuery'] = $slow_sql;
	$data['QueryCrc'] = $query_crc;
	$data['TemplateNames'] = $this->GetVar('t');
	$data['Hits'] = 1;
	$data['LastHit'] = adodb_mktime();

	$this->Conn->doInsert($data, TABLE_PREFIX . 'SlowSqlCapture');
	}
	}

	/**
	* Checks if output compression options is available
	*
	* @return bool
	* @access protected
	*/
	protected function UseOutputCompression()
	{
	if ( kUtil::constOn('IS_INSTALL') \|\| kUtil::constOn('DBG_ZEND_PRESENT') \|\| kUtil::constOn('SKIP_OUT_COMPRESSION') ) {
	return false;
	}

	return $this->ConfigValue('UseOutputCompression') && function_exists('gzencode') && strstr($_SERVER['HTTP_ACCEPT_ENCODING'], 'gzip');
	}

	// Facade

	/**
	* Returns current session id (SID)
	*
	* @return int
	* @access public
	*/
	public function GetSID()
	{
	$session = $this->recallObject('Session');
	/* @var $session Session */

	return $session->GetID();
	}

	/**
	* Destroys current session
	*
	* @return void
	* @access public
	* @see UserHelper::logoutUser()
	*/
	public function DestroySession()
	{
	$session = $this->recallObject('Session');
	/* @var $session Session */

	$session->Destroy();
	}

	/**
	* Returns variable passed to the script as GET/POST/COOKIE
	*
	* @param string $name Name of variable to retrieve
	* @param mixed $default default value returned in case if variable not present
	* @return mixed
	* @access public
	*/
	public function GetVar($name, $default = false)
	{
	return isset($this->HttpQuery->_Params[$name]) ? $this->HttpQuery->_Params[$name] : $default;
	}

	/**
	* Returns variable passed to the script as $type
	*
	* @param string $name Name of variable to retrieve
	* @param string $type Get/Post/Cookie
	* @param mixed $default default value returned in case if variable not present
	* @return mixed
	* @access public
	*/
	public function GetVarDirect($name, $type, $default = false)
	{
	// $type = ucfirst($type);
	$array = $this->HttpQuery->$type;

	return isset($array[$name]) ? $array[$name] : $default;
	}

	/**
	* Returns ALL variables passed to the script as GET/POST/COOKIE
	*
	* @return Array
	* @access public
	* @deprecated
	*/
	public function GetVars()
	{
	return $this->HttpQuery->GetParams();
	}

	/**
	* Set the variable 'as it was passed to the script through GET/POST/COOKIE'
	*
	* This could be useful to set the variable when you know that
	* other objects would relay on variable passed from GET/POST/COOKIE
	* or you could use SetVar() / GetVar() pairs to pass the values between different objects.<br>
	*
	* @param string $var Variable name to set
	* @param mixed $val Variable value
	* @return void
	* @access public
	*/
	public function SetVar($var,$val)
	{
	$this->HttpQuery->Set($var, $val);
	}

	/**
	* Deletes kHTTPQuery variable
	*
	* @param string $var
	* @return void
	* @todo Think about method name
	*/
	public function DeleteVar($var)
	{
	$this->HttpQuery->Remove($var);
	}

	/**
	* Deletes Session variable
	*
	* @param string $var
	* @return void
	* @access public
	*/
	public function RemoveVar($var)
	{
	$this->Session->RemoveVar($var);
	}

	/**
	* Removes variable from persistent session
	*
	* @param string $var
	* @return void
	* @access public
	*/
	public function RemovePersistentVar($var)
	{
	$this->Session->RemovePersistentVar($var);
	}

	/**
	* Restores Session variable to it's db version
	*
	* @param string $var
	* @return void
	* @access public
	*/
	public function RestoreVar($var)
	{
	$this->Session->RestoreVar($var);
	}

	/**
	* Returns session variable value
	*
	* Return value of $var variable stored in Session. An optional default value could be passed as second parameter.
	*
	* @param string $var Variable name
	* @param mixed $default Default value to return if no $var variable found in session
	* @return mixed
	* @access public
	* @see Session::RecallVar()
	*/
	public function RecallVar($var,$default=false)
	{
	return $this->Session->RecallVar($var,$default);
	}

	/**
	* Returns variable value from persistent session
	*
	* @param string $var
	* @param mixed $default
	* @return mixed
	* @access public
	* @see Session::RecallPersistentVar()
	*/
	public function RecallPersistentVar($var, $default = false)
	{
	return $this->Session->RecallPersistentVar($var, $default);
	}

	/**
	* Stores variable $val in session under name $var
	*
	* Use this method to store variable in session. Later this variable could be recalled.
	*
	* @param string $var Variable name
	* @param mixed $val Variable value
	* @param bool $optional
	* @return void
	* @access public
	* @see kApplication::RecallVar()
	*/
	public function StoreVar($var, $val, $optional = false)
	{
	$session = $this->recallObject('Session');
	/* @var $session Session */

	$this->Session->StoreVar($var, $val, $optional);
	}

	/**
	* Stores variable to persistent session
	*
	* @param string $var
	* @param mixed $val
	* @param bool $optional
	* @return void
	* @access public
	*/
	public function StorePersistentVar($var, $val, $optional = false)
	{
	$this->Session->StorePersistentVar($var, $val, $optional);
	}

	/**
	* Stores default value for session variable
	*
	* @param string $var
	* @param string $val
	* @param bool $optional
	* @return void
	* @access public
	* @see Session::RecallVar()
	* @see Session::StoreVar()
	*/
	public function StoreVarDefault($var, $val, $optional = false)
	{
	$session = $this->recallObject('Session');
	/* @var $session Session */

	$this->Session->StoreVarDefault($var, $val, $optional);
	}

	/**
	* Links HTTP Query variable with session variable
	*
	* If variable $var is passed in HTTP Query it is stored in session for later use. If it's not passed it's recalled from session.
	* This method could be used for making sure that GetVar will return query or session value for given
	* variable, when query variable should overwrite session (and be stored there for later use).<br>
	* This could be used for passing item's ID into popup with multiple tab -
	* in popup script you just need to call LinkVar('id', 'current_id') before first use of GetVar('id').
	* After that you can be sure that GetVar('id') will return passed id or id passed earlier and stored in session
	*
	* @param string $var HTTP Query (GPC) variable name
	* @param mixed $ses_var Session variable name
	* @param mixed $default Default variable value
	* @param bool $optional
	* @return void
	* @access public
	*/
	public function LinkVar($var, $ses_var = null, $default = '', $optional = false)
	{
	if ( !isset($ses_var) ) {
	$ses_var = $var;
	}

	if ( $this->GetVar($var) !== false ) {
	$this->StoreVar($ses_var, $this->GetVar($var), $optional);
	}
	else {
	$this->SetVar($var, $this->RecallVar($ses_var, $default));
	}
	}

	/**
	* Returns variable from HTTP Query, or from session if not passed in HTTP Query
	*
	* The same as LinkVar, but also returns the variable value taken from HTTP Query if passed, or from session if not passed.
	* Returns the default value if variable does not exist in session and was not passed in HTTP Query
	*
	* @param string $var HTTP Query (GPC) variable name
	* @param mixed $ses_var Session variable name
	* @param mixed $default Default variable value
	* @return mixed
	* @access public
	* @see LinkVar
	*/
	public function GetLinkedVar($var, $ses_var = null, $default = '')
	{
	$this->LinkVar($var, $ses_var, $default);

	return $this->GetVar($var);
	}

	/**
	* Renders given tag and returns it's output
	*
	* @param string $prefix
	* @param string $tag
	* @param Array $params
	* @return mixed
	* @access public
	* @see kApplication::InitParser()
	*/
	public function ProcessParsedTag($prefix, $tag, $params)
	{
	$processor = $this->Parser->GetProcessor($prefix);
	/* @var $processor kDBTagProcessor */

	return $processor->ProcessParsedTag($tag, $params, $prefix);
	}

	/**
	* Return ADODB Connection object
	*
	* Returns ADODB Connection object already connected to the project database, configurable in config.php
	*
	* @return kDBConnection
	* @access public
	*/
	public function &GetADODBConnection()
	{
	return $this->Conn;
	}

	/**
	* Allows to parse given block name or include template
	*
	* @param Array $params Parameters to pass to block. Reserved parameter "name" used to specify block name.
	* @param bool $pass_params Forces to pass current parser params to this block/template. Use with caution, because you can accidentally pass "block_no_data" parameter.
	* @param bool $as_template
	* @return string
	* @access public
	*/
	public function ParseBlock($params, $pass_params = false, $as_template = false)
	{
	if ( substr($params['name'], 0, 5) == 'html:' ) {
	return substr($params['name'], 5);
	}

	return $this->Parser->ParseBlock($params, $pass_params, $as_template);
	}

	/**
	* Checks, that we have given block defined
	*
	* @param string $name
	* @return bool
	* @access public
	*/
	public function ParserBlockFound($name)
	{
	return $this->Parser->blockFound($name);
	}

	/**
	* Allows to include template with a given name and given parameters
	*
	* @param Array $params Parameters to pass to template. Reserved parameter "name" used to specify template name.
	* @return string
	* @access public
	*/
	public function IncludeTemplate($params)
	{
	return $this->Parser->IncludeTemplate($params, isset($params['is_silent']) ? 1 : 0);
	}

	/**
	* Return href for template
	*
	* @param string $t Template path
	* @param string $prefix index.php prefix - could be blank, 'admin'
	* @param Array $params
	* @param string $index_file
	* @return string
	*/
	public function HREF($t, $prefix = '', $params = Array (), $index_file = null)
	{
	return $this->UrlManager->HREF($t, $prefix, $params, $index_file);
	}

	/**
	* Returns theme template filename and it's corresponding page_id based on given seo template
	*
	* @param string $seo_template
	* @return string
	* @access public
	*/
	public function getPhysicalTemplate($seo_template)
	{
	return $this->UrlManager->getPhysicalTemplate($seo_template);
	}

	/**
	* Returns template name, that corresponds with given virtual (not physical) page id
	*
	* @param int $page_id
	* @return string\|bool
	* @access public
	*/
	public function getVirtualPageTemplate($page_id)
	{
	return $this->UrlManager->getVirtualPageTemplate($page_id);
	}

	/**
	* Returns variables with values that should be passed through with this link + variable list
	*
	* @param Array $params
	* @return Array
	* @access public
	*/
	public function getPassThroughVariables(&$params)
	{
	return $this->UrlManager->getPassThroughVariables($params);
	}

	/**
	* Builds url
	*
	* @param string $t
	* @param Array $params
	* @param string $pass
	* @param bool $pass_events
	* @param bool $env_var
	* @return string
	* @access public
	*/
	public function BuildEnv($t, $params, $pass = 'all', $pass_events = false, $env_var = true)
	{
	return $this->UrlManager->plain->build($t, $params, $pass, $pass_events, $env_var);
	}

	/**
	* Process QueryString only, create
	* events, ids, based on config
	* set template name and sid in
	* desired application variables.
	*
	* @param string $env_var environment string value
	* @param string $pass_name
	* @return Array
	* @access public
	*/
	public function processQueryString($env_var, $pass_name = 'passed')
	{
	return $this->UrlManager->plain->parse($env_var, $pass_name);
	}

	/**
	* Returns base part of all urls, build on website
	*
	* @param string $prefix
	* @param bool $ssl
	* @param bool $add_port
	* @return string
	* @access public
	*/
	public function BaseURL($prefix = '', $ssl = null, $add_port = true)
	{
	if ( $ssl === null ) {
	// stay on same encryption level
	return PROTOCOL . SERVER_NAME . ($add_port && defined('PORT') ? ':' . PORT : '') . BASE_PATH . $prefix . '/';
	}

	if ( $ssl ) {
	// going from http:// to https://
	$base_url = $this->isAdmin ? $this->ConfigValue('AdminSSL_URL') : false;

	if ( !$base_url ) {
	$ssl_url = $this->siteDomainField('SSLUrl');
	$base_url = $ssl_url !== false ? $ssl_url : $this->ConfigValue('SSL_URL');
	}

	return rtrim($base_url, '/') . $prefix . '/';
	}

	// going from https:// to http://
	$domain = $this->siteDomainField('DomainName');

	if ( $domain === false ) {
	$domain = DOMAIN;
	}

	return 'http://' . $domain . ($add_port && defined('PORT') ? ':' . PORT : '') . BASE_PATH . $prefix . '/';
	}

	/**
	* Redirects user to url, that's build based on given parameters
	*
	* @param string $t
	* @param Array $params
	* @param string $prefix
	* @param string $index_file
	* @return void
	* @access public
	*/
	public function Redirect($t = '', $params = Array(), $prefix = '', $index_file = null)
	{
	$js_redirect = getArrayValue($params, 'js_redirect');

	if ( $t == '' \|\| $t === true ) {
	$t = $this->GetVar('t');
	}

	// pass prefixes and special from previous url
	if ( array_key_exists('js_redirect', $params) ) {
	unset($params['js_redirect']);
	}

	// allows to send custom responce code along with redirect header
	if ( array_key_exists('response_code', $params) ) {
	$response_code = (int)$params['response_code'];
	unset($params['response_code']);
	}
	else {
	$response_code = 302; // Found
	}

	if ( !array_key_exists('pass', $params) ) {
	$params['pass'] = 'all';
	}

	if ( $this->GetVar('ajax') == 'yes' && $t == $this->GetVar('t') ) {
	// redirects to the same template as current
	$params['ajax'] = 'yes';
	}

	$params['__URLENCODE__'] = 1;
	$location = $this->HREF($t, $prefix, $params, $index_file);

	if ( $this->isDebugMode() && (kUtil::constOn('DBG_REDIRECT') \|\| (kUtil::constOn('DBG_RAISE_ON_WARNINGS') && $this->Debugger->WarningCount)) ) {
	$this->Debugger->appendTrace();
	echo '<strong>Debug output above !!!</strong><br/>' . "\n";

	if ( array_key_exists('HTTP_REFERER', $_SERVER) ) {
	echo 'Referer: <strong>' . $_SERVER['HTTP_REFERER'] . '</strong><br/>' . "\n";
	}

	echo "Proceed to redirect: <a href=\"{$location}\">{$location}</a><br/>\n";
	}
	else {
	if ( $js_redirect ) {
	// show "redirect" template instead of redirecting,
	// because "Set-Cookie" header won't work, when "Location"
	// header is used later
	$this->SetVar('t', 'redirect');
	$this->SetVar('redirect_to', $location);

	// make all additional parameters available on "redirect" template too
	foreach ($params as $name => $value) {
	$this->SetVar($name, $value);
	}

	return;
	}
	else {
	if ( $this->GetVar('ajax') == 'yes' && $t != $this->GetVar('t') ) {
	// redirection to other then current template during ajax request
	kUtil::safeDefine('DBG_SKIP_REPORTING', 1);
	echo '#redirect#' . $location;
	}
	elseif ( headers_sent() != '' ) {
	// some output occurred -> redirect using javascript
	echo '<script type="text/javascript">window.location.href = \'' . $location . '\';</script>';
	}
	else {
	// no output before -> redirect using HTTP header

	// header('HTTP/1.1 302 Found');
	header('Location: ' . $location, true, $response_code);
	}
	}
	}

	// session expiration is called from session initialization,
	// that's why $this->Session may be not defined here
	$session = $this->recallObject('Session');
	/* @var $session Session */

	$this->HandleEvent(new kEvent('adm:OnBeforeShutdown'));
	$session->SaveData();

	ob_end_flush();
	exit;
	}

	/**
	* Returns translation of given label
	*
	* @param string $label
	* @param bool $allow_editing return translation link, when translation is missing on current language
	* @param bool $use_admin use current Admin Console language to translate phrase
	* @return string
	* @access public
	*/
	public function Phrase($label, $allow_editing = true, $use_admin = false)
	{
	return $this->Phrases->GetPhrase($label, $allow_editing, $use_admin);
	}

	/**
	* Replace language tags in exclamation marks found in text
	*
	* @param string $text
	* @param bool $force_escape force escaping, not escaping of resulting string
	* @return string
	* @access public
	*/
	public function ReplaceLanguageTags($text, $force_escape = null)
	{
	return $this->Phrases->ReplaceLanguageTags($text, $force_escape);
	}

	/**
	* Checks if user is logged in, and creates
	* user object if so. User object can be recalled
	* later using "u.current" prefix_special. Also you may
	* get user id by getting "u.current_id" variable.
	*
	* @return void
	* @access protected
	*/
	protected function ValidateLogin()
	{
	$session = $this->recallObject('Session');
	/* @var $session Session */

	$user_id = $session->GetField('PortalUserId');

	if ( !$user_id && $user_id != USER_ROOT ) {
	$user_id = USER_GUEST;
	}

	$this->SetVar('u.current_id', $user_id);

	if ( !$this->isAdmin ) {
	// needed for "profile edit", "registration" forms ON FRONT ONLY
	$this->SetVar('u_id', $user_id);
	}

	$this->StoreVar('user_id', $user_id, $user_id == USER_GUEST); // storing Guest user_id (-2) is optional

	$this->isAdminUser = $this->isAdmin && $this->LoggedIn();

	if ( $this->GetVar('expired') == 1 ) {
	// this parameter is set only from admin
	$user = $this->recallObject('u.login-admin', null, Array ('form_name' => 'login'));
	/* @var $user UsersItem */

	$user->SetError('UserLogin', 'session_expired', 'la_text_sess_expired');
	}

	if ( ($user_id != USER_GUEST) && defined('DBG_REQUREST_LOG') && DBG_REQUREST_LOG ) {
	$this->HttpQuery->writeRequestLog(DBG_REQUREST_LOG);
	}

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

	$user_timezone = $this->Session->GetField('TimeZone');

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

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

	/**
	* Returns configuration option value by name
	*
	* @param string $name
	* @return string
	* @access public
	*/
	public function ConfigValue($name)
	{
	return $this->cacheManager->ConfigValue($name);
	}

	/**
	* Changes value of individual configuration variable (+resets cache, when needed)
	*
	* @param string $name
	* @param string $value
	* @param bool $local_cache_only
	* @return string
	* @access public
	*/
	public function SetConfigValue($name, $value, $local_cache_only = false)
	{
	return $this->cacheManager->SetConfigValue($name, $value, $local_cache_only);
	}

	/**
	* Allows to process any type of event
	*
	* @param kEvent $event
	* @param Array $params
	* @param Array $specific_params
	* @access public
	*/
	public function HandleEvent($event, $params = null, $specific_params = null)
	{
	if ( isset($params) ) {
	$event = new kEvent($params, $specific_params);
	}

	$this->EventManager->HandleEvent($event);
	}

	/**
	* Registers new class in the factory
	*
	* @param string $real_class Real name of class as in class declaration
	* @param string $file Filename in what $real_class is declared
	* @param string $pseudo_class Name under this class object will be accessed using getObject method
	* @return void
	* @access public
	*/
	public function registerClass($real_class, $file, $pseudo_class = null)
	{
	$this->Factory->registerClass($real_class, $file, $pseudo_class);
	}

	/**
	* Unregisters existing class from factory
	*
	* @param string $real_class Real name of class as in class declaration
	* @param string $pseudo_class Name under this class object is accessed using getObject method
	* @return void
	* @access public
	*/
	public function unregisterClass($real_class, $pseudo_class = null)
	{
	$this->Factory->unregisterClass($real_class, $pseudo_class);
	}

	/**
	* Add new scheduled task
	*
	* @param string $short_name name to be used to store last maintenance run info
	* @param string $event_string
	* @param int $run_interval run interval in seconds
	* @param int $status
	* @access public
	*/
	public function registerScheduledTask($short_name, $event_string, $run_interval, $status = STATUS_ACTIVE)
	{
	$this->EventManager->registerScheduledTask($short_name, $event_string, $run_interval, $status);
	}

	/**
	* Registers Hook from subprefix event to master prefix event
	*
	* Pattern: Observer
	*
	* @param string $hook_event
	* @param string $do_event
	* @param int $mode
	* @param bool $conditional
	* @access public
	*/
	public function registerHook($hook_event, $do_event, $mode = hAFTER, $conditional = false)
	{
	$this->EventManager->registerHook($hook_event, $do_event, $mode, $conditional);
	}

	/**
	* Registers build event for given pseudo class
	*
	* @param string $pseudo_class
	* @param string $event_name
	* @access public
	*/
	public function registerBuildEvent($pseudo_class, $event_name)
	{
	$this->EventManager->registerBuildEvent($pseudo_class, $event_name);
	}

	/**
	* Allows one TagProcessor tag act as other TagProcessor tag
	*
	* @param Array $tag_info
	* @return void
	* @access public
	*/
	public function registerAggregateTag($tag_info)
	{
	$aggregator = $this->recallObject('TagsAggregator', 'kArray');
	/* @var $aggregator kArray */

	$tag_data = Array (
	$tag_info['LocalPrefix'],
	$tag_info['LocalTagName'],
	getArrayValue($tag_info, 'LocalSpecial')
	);

	$aggregator->SetArrayValue($tag_info['AggregateTo'], $tag_info['AggregatedTagName'], $tag_data);
	}

	/**
	* Returns object using params specified, creates it if is required
	*
	* @param string $name
	* @param string $pseudo_class
	* @param Array $event_params
	* @param Array $arguments
	* @return kBase
	*/
	public function recallObject($name, $pseudo_class = null, $event_params = Array(), $arguments = Array ())
	{
	/*if ( !$this->hasObject($name) && $this->isDebugMode() && ($name == '_prefix_here_') ) {
	// first time, when object with "_prefix_here_" prefix is accessed
	$this->Debugger->appendTrace();
	}*/

	return $this->Factory->getObject($name, $pseudo_class, $event_params, $arguments);
	}

	/**
	* Returns tag processor for prefix specified
	*
	* @param string $prefix
	* @return kDBTagProcessor
	* @access public
	*/
	public function recallTagProcessor($prefix)
	{
	$this->InitParser(); // because kDBTagProcesor is in NParser dependencies

	return $this->recallObject($prefix . '_TagProcessor');
	}

	/**
	* Checks if object with prefix passes was already created in factory
	*
	* @param string $name object pseudo_class, prefix
	* @return bool
	* @access public
	*/
	public function hasObject($name)
	{
	return $this->Factory->hasObject($name);
	}

	/**
	* Removes object from storage by given name
	*
	* @param string $name Object's name in the Storage
	* @return void
	* @access public
	*/
	public function removeObject($name)
	{
	$this->Factory->DestroyObject($name);
	}

	/**
	* Get's real class name for pseudo class, includes class file and creates class instance
	*
	* Pattern: Factory Method
	*
	* @param string $pseudo_class
	* @param Array $arguments
	* @return kBase
	* @access public
	*/
	public function makeClass($pseudo_class, $arguments = Array ())
	{
	return $this->Factory->makeClass($pseudo_class, $arguments);
	}

	/**
	* Checks if application is in debug mode
	*
	* @param bool $check_debugger check if kApplication debugger is initialized too, not only for defined DEBUG_MODE constant
	* @return bool
	* @author Alex
	* @access public
	*/
	public function isDebugMode($check_debugger = true)
	{
	$debug_mode = defined('DEBUG_MODE') && DEBUG_MODE;
	if ($check_debugger) {
	$debug_mode = $debug_mode && is_object($this->Debugger);
	}
	return $debug_mode;
	}

	/**
	* Apply url rewriting used by mod_rewrite or not
	*
	* @param bool\|null $ssl Force ssl link to be build
	* @return bool
	* @access public
	*/
	public function RewriteURLs($ssl = false)
	{
	// case #1,#4:
	// we want to create https link from http mode
	// we want to create https link from https mode
	// conditions: ($ssl \|\| PROTOCOL == 'https://') && $this->ConfigValue('UseModRewriteWithSSL')

	// case #2,#3:
	// we want to create http link from https mode
	// we want to create http link from http mode
	// conditions: !$ssl && (PROTOCOL == 'https://' \|\| PROTOCOL == 'http://')

	$allow_rewriting =
	(!$ssl && (PROTOCOL == 'https://' \|\| PROTOCOL == 'http://')) // always allow mod_rewrite for http
	\|\| // or allow rewriting for redirect TO httpS or when already in httpS
	(($ssl \|\| PROTOCOL == 'https://') && $this->ConfigValue('UseModRewriteWithSSL')); // but only if it's allowed in config!

	return kUtil::constOn('MOD_REWRITE') && $allow_rewriting;
	}

	/**
	* Reads unit (specified by $prefix)
	* option specified by $option
	*
	* @param string $prefix
	* @param string $option
	* @param mixed $default
	* @return string
	* @access public
	*/
	public function getUnitOption($prefix, $option, $default = false)
	{
	return $this->UnitConfigReader->getUnitOption($prefix, $option, $default);
	}

	/**
	* Set's new unit option value
	*
	* @param string $prefix
	* @param string $option
	* @param string $value
	* @access public
	*/
	public function setUnitOption($prefix, $option, $value)
	{
	$this->UnitConfigReader->setUnitOption($prefix,$option,$value);
	}

	/**
	* Read all unit with $prefix options
	*
	* @param string $prefix
	* @return Array
	* @access public
	*/
	public function getUnitOptions($prefix)
	{
	return $this->UnitConfigReader->getUnitOptions($prefix);
	}

	/**
	* Returns true if config exists and is allowed for reading
	*
	* @param string $prefix
	* @return bool
	*/
	public function prefixRegistred($prefix)
	{
	return $this->UnitConfigReader->prefixRegistred($prefix);
	}

	/**
	* Splits any mixing of prefix and
	* special into correct ones
	*
	* @param string $prefix_special
	* @return Array
	* @access public
	*/
	public function processPrefix($prefix_special)
	{
	return $this->Factory->processPrefix($prefix_special);
	}

	/**
	* Set's new event for $prefix_special
	* passed
	*
	* @param string $prefix_special
	* @param string $event_name
	* @return void
	* @access public
	*/
	public function setEvent($prefix_special, $event_name)
	{
	$this->EventManager->setEvent($prefix_special, $event_name);
	}

	/**
	* SQL Error Handler
	*
	* @param int $code
	* @param string $msg
	* @param string $sql
	* @return bool
	* @access public
	*/
	public function handleSQLError($code, $msg, $sql)
	{
	if ( isset($this->Debugger) ) {
	$long_error_msg = '<span class="debug_error">' . $msg . ' (' . $code . ')</span><br/><a href="javascript:$Debugger.SetClipboard(\'' . htmlspecialchars($sql) . '\');"><strong>SQL</strong></a>: ' . $this->Debugger->formatSQL($sql);
	$long_id = $this->Debugger->mapLongError($long_error_msg);
	$error_msg = mb_substr($msg . ' (' . $code . ') [' . $sql . ']', 0, 1000) . ' #' . $long_id;

	if ( kUtil::constOn('DBG_SQL_FAILURE') && !defined('IS_INSTALL') ) {
	throw new Exception($error_msg);
	}
	else {
	$this->Debugger->appendTrace();
	}
	}
	else {
	// when not debug mode, then fatal database query won't break anything
	$error_msg = '<strong>SQL Error</strong> in sql: ' . $sql . ', code <strong>' . $code . '</strong> (' . $msg . ')';
	}

	trigger_error($error_msg, E_USER_WARNING);

	return true;
	}

	/**
	* Default error handler
	*
	* @param int $errno
	* @param string $errstr
	* @param string $errfile
	* @param int $errline
	* @param Array $errcontext
	* @return bool
	* @access public
	*/
	public function handleError($errno, $errstr, $errfile = null, $errline = null, $errcontext = Array ())
	{
	$this->errorLogSilent($errno, $errstr, $errfile, $errline);

	$debug_mode = defined('DEBUG_MODE') && DEBUG_MODE;
	$skip_reporting = defined('DBG_SKIP_REPORTING') && DBG_SKIP_REPORTING;

	if ( !$this->errorHandlers \|\| ($debug_mode && $skip_reporting) ) {
	// when debugger absent OR it's present, but we actually can't see it's error report (e.g. during ajax request)
	if ( $errno == E_USER_ERROR ) {
	$this->errorDisplayFatal('<strong>Fatal Error: </strong>' . "{$errstr} in {$errfile} on line {$errline}");
	}

	if ( !$this->errorHandlers ) {
	return true;
	}
	}

	$res = false;
	/* @var $handler Closure */

	foreach ($this->errorHandlers as $handler) {
	if ( is_array($handler) ) {
	$object =& $handler[0];
	$method = $handler[1];
	$res = $object->$method($errno, $errstr, $errfile, $errline, $errcontext);
	}
	else {
	$res = $handler($errno, $errstr, $errfile, $errline, $errcontext);
	}
	}

	return $res;
	}

	/**
	* Handles exception
	*
	* @param Exception $exception
	* @return bool
	* @access public
	*/
	public function handleException($exception)
	{
	// transform exception to regular error (no need to rewrite existing error handlers)
	$errno = $exception->getCode();
	$errstr = $exception->getMessage();
	$errfile = $exception->getFile();
	$errline = $exception->getLine();

	$this->errorLogSilent($errno, $errstr, $errfile, $errline);

	$debug_mode = defined('DEBUG_MODE') && DEBUG_MODE;
	$skip_reporting = defined('DBG_SKIP_REPORTING') && DBG_SKIP_REPORTING;

	if ( !$this->exceptionHandlers \|\| ($debug_mode && $skip_reporting) ) {
	// when debugger absent OR it's present, but we actually can't see it's error report (e.g. during ajax request)
	$this->errorDisplayFatal('<strong>' . get_class($exception) . ': </strong>' . "{$errstr} in {$errfile} on line {$errline}");

	if ( !$this->exceptionHandlers ) {
	return true;
	}
	}

	$res = false;
	/* @var $handler Closure */

	foreach ($this->exceptionHandlers as $handler) {
	if ( is_array($handler) ) {
	$object =& $handler[0];
	$method = $handler[1];
	$res = $object->$method($exception);
	}
	else {
	$res = $handler($exception);
	}
	}

	return $res;
	}

	/**
	* Silently saves each given error message to "silent_log.txt" file, when silent log mode is enabled
	* @param int $errno
	* @param string $errstr
	* @param string $errfile
	* @param int $errline
	* @return void
	* @access protected
	*/
	protected function errorLogSilent($errno, $errstr = '', $errfile = '', $errline = null)
	{
	if ( !defined('SILENT_LOG') \|\| !SILENT_LOG ) {
	return;
	}

	if ( !(defined('DBG_IGNORE_STRICT_ERRORS') && DBG_IGNORE_STRICT_ERRORS && defined('E_STRICT') && ($errno == E_STRICT)) ) {
	$time = adodb_date('d/m/Y H:i:s');

	$fp = fopen((defined('RESTRICTED') ? RESTRICTED : FULL_PATH) . '/silent_log.txt', 'a');
	fwrite($fp, '[' . $time . '] #' . $errno . ': ' . strip_tags($errstr) . ' in [' . $errfile . '] on line ' . $errline . "\n");
	fclose($fp);
	}
	}

	/**
	* Displays div with given error message
	*
	* @param string $msg
	* @return void
	* @access protected
	*/
	protected function errorDisplayFatal($msg)
	{
	$margin = $this->isAdmin ? '8px' : 'auto';
	echo '<div style="background-color: #FEFFBF; margin: ' . $margin . '; padding: 10px; border: 2px solid red; text-align: center">' . $msg . '</div>';
	exit;
	}

	/**
	* Prints trace, when debug mode is not available
	*
	* @param bool $return_result
	* @param int $skip_levels
	* @return string
	* @access public
	*/
	public function printTrace($return_result = false, $skip_levels = 1)
	{
	$ret = Array ();
	$trace = debug_backtrace(false);

	for ($i = 0; $i < $skip_levels; $i++) {
	array_shift($trace);
	}

	foreach ($trace as $level => $trace_info) {
	if ( isset($trace_info['class']) ) {
	$object = $trace_info['class'];
	}
	elseif ( isset($trace_info['object']) ) {
	$object = get_class($trace_info['object']);
	}
	else {
	$object = '';
	}

	$args = '';
	$type = isset($trace_info['type']) ? $trace_info['type'] : '';

	if ( isset($trace_info['args']) ) {
	foreach ($trace_info['args'] as $argument) {
	if ( is_object($argument) ) {
	$args .= get_class($argument) . ' instance, ';
	}
	else {
	$args .= is_array($argument) ? 'Array' : substr($argument, 0, 10) . ' ..., ';
	}
	}

	$args = substr($args, 0, -2);
	}

	$ret[] = '#' . $level . ' ' . $object . $type . $trace_info['function'] . '(' . $args . ') called at [' . $trace_info['file'] . ':' . $trace_info['line'] . ']';
	}

	if ( $return_result ) {
	return implode("\n", $ret);
	}

	echo implode("\n", $ret);

	return '';
	}

	/**
	* Returns & blocks next ResourceId available in system
	*
	* @return int
	* @access public
	*/
	public function NextResourceId()
	{
	$table_name = TABLE_PREFIX . 'IdGenerator';

	$this->Conn->Query('LOCK TABLES ' . $table_name . ' WRITE');
	$this->Conn->Query('UPDATE ' . $table_name . ' SET lastid = lastid + 1');
	$id = $this->Conn->GetOne('SELECT lastid FROM ' . $table_name);

	if ( $id === false ) {
	$this->Conn->Query('INSERT INTO ' . $table_name . ' (lastid) VALUES (2)');
	$id = 2;
	}

	$this->Conn->Query('UNLOCK TABLES');

	return $id - 1;
	}

	/**
	* Returns genealogical main prefix for sub-table prefix passes
	* OR prefix, that has been found in REQUEST and some how is parent of passed sub-table prefix
	*
	* @param string $current_prefix
	* @param bool $real_top if set to true will return real topmost prefix, regardless of its id is passed or not
	* @return string
	* @access public
	*/
	public function GetTopmostPrefix($current_prefix, $real_top = false)
	{
	// 1. get genealogical tree of $current_prefix
	$prefixes = Array ($current_prefix);
	while ($parent_prefix = $this->getUnitOption($current_prefix, 'ParentPrefix')) {
	if ( !$this->prefixRegistred($parent_prefix) ) {
	// stop searching, when parent prefix is not registered
	break;
	}

	$current_prefix = $parent_prefix;
	array_unshift($prefixes, $current_prefix);
	}

	if ( $real_top ) {
	return $current_prefix;
	}

	// 2. find what if parent is passed
	$passed = explode(',', $this->GetVar('all_passed'));
	foreach ($prefixes as $a_prefix) {
	if ( in_array($a_prefix, $passed) ) {
	return $a_prefix;
	}
	}

	return $current_prefix;
	}

	/**
	* Triggers email event of type Admin
	*
	* @param string $email_event_name
	* @param int $to_user_id
	* @param array $send_params associative array of direct send params, possible keys: to_email, to_name, from_email, from_name, message, message_text
	* @return kEvent
	* @access public
	*/
	public function &EmailEventAdmin($email_event_name, $to_user_id = null, $send_params = Array ())
	{
	$event =& $this->EmailEvent($email_event_name, EmailEvent::EVENT_TYPE_ADMIN, $to_user_id, $send_params);

	return $event;
	}

	/**
	* Triggers email event of type User
	*
	* @param string $email_event_name
	* @param int $to_user_id
	* @param array $send_params associative array of direct send params, possible keys: to_email, to_name, from_email, from_name, message, message_text
	* @return kEvent
	* @access public
	*/
	public function &EmailEventUser($email_event_name, $to_user_id = null, $send_params = Array ())
	{
	$event =& $this->EmailEvent($email_event_name, EmailEvent::EVENT_TYPE_FRONTEND, $to_user_id, $send_params);

	return $event;
	}

	/**
	* Triggers general email event
	*
	* @param string $email_event_name
	* @param int $email_event_type (0 for User, 1 for Admin)
	* @param int $to_user_id
	* @param array $send_params associative array of direct send params,
	* possible keys: to_email, to_name, from_email, from_name, message, message_text
	* @return kEvent
	* @access protected
	*/
	protected function &EmailEvent($email_event_name, $email_event_type, $to_user_id = null, $send_params = Array ())
	{
	$params = Array (
	'EmailEventName' => $email_event_name,
	'EmailEventToUserId' => $to_user_id,
	'EmailEventType' => $email_event_type,
	'DirectSendParams' => $send_params,
	);

	if ( array_key_exists('use_special', $send_params) ) {
	$event_str = 'emailevents.' . $send_params['use_special'] . ':OnEmailEvent';
	}
	else {
	$event_str = 'emailevents:OnEmailEvent';
	}

	$event = new kEvent($event_str, $params);
	$this->HandleEvent($event);

	return $event;
	}

	/**
	* Allows to check if user in this session is logged in or not
	*
	* @return bool
	* @access public
	*/
	public function LoggedIn()
	{
	// no session during expiration process
	return is_null($this->Session) ? false : $this->Session->LoggedIn();
	}

	/**
	* Check current user permissions based on it's group permissions in specified category
	*
	* @param string $name permission name
	* @param int $cat_id category id, current used if not specified
	* @param int $type permission type {1 - system, 0 - per category}
	* @return int
	* @access public
	*/
	public function CheckPermission($name, $type = 1, $cat_id = null)
	{
	$perm_helper = $this->recallObject('PermissionsHelper');
	/* @var $perm_helper kPermissionsHelper */

	return $perm_helper->CheckPermission($name, $type, $cat_id);
	}

	/**
	* Check current admin permissions based on it's group permissions in specified category
	*
	* @param string $name permission name
	* @param int $cat_id category id, current used if not specified
	* @param int $type permission type {1 - system, 0 - per category}
	* @return int
	* @access public
	*/
	public function CheckAdminPermission($name, $type = 1, $cat_id = null)
	{
	$perm_helper = $this->recallObject('PermissionsHelper');
	/* @var $perm_helper kPermissionsHelper */

	return $perm_helper->CheckAdminPermission($name, $type, $cat_id);
	}

	/**
	* Set's any field of current visit
	*
	* @param string $field
	* @param mixed $value
	* @return void
	* @access public
	* @todo move to separate module
	*/
	public function setVisitField($field, $value)
	{
	if ( $this->isAdmin \|\| !$this->ConfigValue('UseVisitorTracking') ) {
	// admin logins are not registered in visits list
	return;
	}

	$visit = $this->recallObject('visits', null, Array ('raise_warnings' => 0));
	/* @var $visit kDBItem */

	if ( $visit->isLoaded() ) {
	$visit->SetDBField($field, $value);
	$visit->Update();
	}
	}

	/**
	* Allows to check if in-portal is installed
	*
	* @return bool
	* @access public
	*/
	public function isInstalled()
	{
	return $this->InitDone && (count($this->ModuleInfo) > 0);
	}

	/**
	* Allows to determine if module is installed & enabled
	*
	* @param string $module_name
	* @return bool
	* @access public
	*/
	public function isModuleEnabled($module_name)
	{
	return $this->findModule('Name', $module_name) !== false;
	}

	/**
	* Returns Window ID of passed prefix main prefix (in edit mode)
	*
	* @param string $prefix
	* @return int
	* @access public
	*/
	public function GetTopmostWid($prefix)
	{
	$top_prefix = $this->GetTopmostPrefix($prefix);
	$mode = $this->GetVar($top_prefix . '_mode');

	return $mode != '' ? substr($mode, 1) : '';
	}

	/**
	* Get temp table name
	*
	* @param string $table
	* @param mixed $wid
	* @return string
	* @access public
	*/
	public function GetTempName($table, $wid = '')
	{
	return $this->GetTempTablePrefix($wid) . $table;
	}

	/**
	* Builds temporary table prefix based on given window id
	*
	* @param string $wid
	* @return string
	* @access public
	*/
	public function GetTempTablePrefix($wid = '')
	{
	if ( preg_match('/prefix:(.*)/', $wid, $regs) ) {
	$wid = $this->GetTopmostWid($regs[1]);
	}

	return TABLE_PREFIX . 'ses_' . $this->GetSID() . ($wid ? '_' . $wid : '') . '_edit_';
	}

	/**
	* Checks if given table is a temporary table
	*
	* @param string $table
	* @return bool
	* @access public
	*/
	public function IsTempTable($table)
	{
	static $cache = Array ();

	if ( !array_key_exists($table, $cache) ) {
	$cache[$table] = preg_match('/' . TABLE_PREFIX . 'ses_' . $this->GetSID() . '(_[\d]+){0,1}_edit_(.*)/', $table);
	}

	return (bool)$cache[$table];
	}

	/**
	* Checks, that given prefix is in temp mode
	*
	* @param string $prefix
	* @param string $special
	* @return bool
	* @access public
	*/
	public function IsTempMode($prefix, $special = '')
	{
	$top_prefix = $this->GetTopmostPrefix($prefix);

	$var_names = Array (
	$top_prefix,
	rtrim($top_prefix . '_' . $special, '_'), // from post
	rtrim($top_prefix . '.' . $special, '.'), // assembled locally
	);

	$var_names = array_unique($var_names);

	$temp_mode = false;
	foreach ($var_names as $var_name) {
	$value = $this->GetVar($var_name . '_mode');

	if ( $value && (substr($value, 0, 1) == 't') ) {
	$temp_mode = true;
	break;
	}
	}

	return $temp_mode;
	}

	/**
	* Return live table name based on temp table name
	*
	* @param string $temp_table
	* @return string
	*/
	public function GetLiveName($temp_table)
	{
	if ( preg_match('/' . TABLE_PREFIX . 'ses_' . $this->GetSID() . '(_[\d]+){0,1}_edit_(.*)/', $temp_table, $rets) ) {
	// cut wid from table end if any
	return $rets[2];
	}
	else {
	return $temp_table;
	}
	}

	/**
	* Stops processing of user request and displays given message
	*
	* @param string $message
	* @access public
	*/
	public function ApplicationDie($message = '')
	{
	$message = ob_get_clean() . $message;

	if ( $this->isDebugMode() ) {
	$message .= $this->Debugger->printReport(true);
	}

	echo $this->UseOutputCompression() ? gzencode($message, DBG_COMPRESSION_LEVEL) : $message;
	exit;
	}

	/**
	* Returns comma-separated list of groups from given user
	*
	* @param int $user_id
	* @return string
	*/
	public function getUserGroups($user_id)
	{
	switch ($user_id) {
	case USER_ROOT:
	$user_groups = $this->ConfigValue('User_LoggedInGroup');
	break;

	case USER_GUEST:
	$user_groups = $this->ConfigValue('User_LoggedInGroup') . ',' . $this->ConfigValue('User_GuestGroup');
	break;

	default:
	$sql = 'SELECT GroupId
	FROM ' . TABLE_PREFIX . 'UserGroupRelations
	WHERE PortalUserId = ' . (int)$user_id;
	$res = $this->Conn->GetCol($sql);

	$user_groups = Array ($this->ConfigValue('User_LoggedInGroup'));
	if ( $res ) {
	$user_groups = array_merge($user_groups, $res);
	}

	$user_groups = implode(',', $user_groups);
	}

	return $user_groups;
	}


	/**
	* Allows to detect if page is browsed by spider (293 scheduled_tasks supported)
	*
	* @return bool
	* @access public
	*/
	/*public function IsSpider()
	{
	static $is_spider = null;

	if ( !isset($is_spider) ) {
	$user_agent = trim($_SERVER['HTTP_USER_AGENT']);
	$robots = file(FULL_PATH . '/core/robots_list.txt');
	foreach ($robots as $robot_info) {
	$robot_info = explode("\t", $robot_info, 3);
	if ( $user_agent == trim($robot_info[2]) ) {
	$is_spider = true;
	break;
	}
	}
	}

	return $is_spider;
	}*/

	/**
	* Allows to detect table's presence in database
	*
	* @param string $table_name
	* @param bool $force
	* @return bool
	* @access public
	*/
	public function TableFound($table_name, $force = false)
	{
	return $this->Conn->TableFound($table_name, $force);
	}

	/**
	* Returns counter value
	*
	* @param string $name counter name
	* @param Array $params counter parameters
	* @param string $query_name specify query name directly (don't generate from parameters)
	* @param bool $multiple_results
	* @return mixed
	* @access public
	*/
	public function getCounter($name, $params = Array (), $query_name = null, $multiple_results = false)
	{
	$count_helper = $this->recallObject('CountHelper');
	/* @var $count_helper kCountHelper */

	return $count_helper->getCounter($name, $params, $query_name, $multiple_results);
	}

	/**
	* Resets counter, which are affected by one of specified tables
	*
	* @param string $tables comma separated tables list used in counting sqls
	* @return void
	* @access public
	*/
	public function resetCounters($tables)
	{
	if ( kUtil::constOn('IS_INSTALL') ) {
	return;
	}

	$count_helper = $this->recallObject('CountHelper');
	/* @var $count_helper kCountHelper */

	$count_helper->resetCounters($tables);
	}

	/**
	* Sends XML header + optionally displays xml heading
	*
	* @param string\|bool $xml_version
	* @return string
	* @access public
	* @author Alex
	*/
	public function XMLHeader($xml_version = false)
	{
	$lang = $this->recallObject('lang.current');
	/* @var $lang LanguagesItem */

	- header('Content-type: text/xml; charset=' . $lang->GetDBField('Charset'));
	+ $this->setContentType('text/xml');

	return $xml_version ? '<?xml version="' . $xml_version . '" encoding="' . $lang->GetDBField('Charset') . '"?>' : '';
	}

	/**
	* Returns category tree
	*
	* @param int $category_id
	* @return Array
	* @access public
	*/
	public function getTreeIndex($category_id)
	{
	$tree_index = $this->getCategoryCache($category_id, 'category_tree');

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

	return $ret;
	}

	return false;
	}

	/**
	* Base category of all categories
	* Usually replaced category, with ID = 0 in category-related operations.
	*
	* @return int
	* @access public
	*/
	public function getBaseCategory()
	{
	// same, what $this->findModule('Name', 'Core', 'RootCat') does
	// don't cache while IS_INSTALL, because of kInstallToolkit::createModuleCategory and upgrade

	return $this->ModuleInfo['Core']['RootCat'];
	}

	/**
	* Deletes all data, that was cached during unit config parsing (excluding unit config locations)
	*
	* @param Array $config_variables
	* @access public
	*/
	public function DeleteUnitCache($config_variables = null)
	{
	$this->cacheManager->DeleteUnitCache($config_variables);
	}

	/**
	* Deletes cached section tree, used during permission checking and admin console tree display
	*
	* @return void
	* @access public
	*/
	public function DeleteSectionCache()
	{
	$this->cacheManager->DeleteSectionCache();
	}

	/**
	* Sets data from cache to object
	*
	* @param Array $data
	* @access public
	*/
	public function setFromCache(&$data)
	{
	$this->Factory->setFromCache($data);
	$this->UnitConfigReader->setFromCache($data);
	$this->EventManager->setFromCache($data);

	$this->ReplacementTemplates = $data['Application.ReplacementTemplates'];
	$this->RewriteListeners = $data['Application.RewriteListeners'];
	$this->ModuleInfo = $data['Application.ModuleInfo'];
	}

	/**
	* Gets object data for caching
	* The following caches should be reset based on admin interaction (adjusting config, enabling modules etc)
	*
	* @access public
	* @return Array
	*/
	public function getToCache()
	{
	return array_merge(
	$this->Factory->getToCache(),
	$this->UnitConfigReader->getToCache(),
	$this->EventManager->getToCache(),
	Array (
	'Application.ReplacementTemplates' => $this->ReplacementTemplates,
	'Application.RewriteListeners' => $this->RewriteListeners,
	'Application.ModuleInfo' => $this->ModuleInfo,
	)
	);
	}

	public function delayUnitProcessing($method, $params)
	{
	$this->cacheManager->delayUnitProcessing($method, $params);
	}

	/**
	* Returns current maintenance mode state
	*
	* @param bool $check_ips
	* @return int
	* @access public
	*/
	public function getMaintenanceMode($check_ips = true)
	{
	$exception_ips = defined('MAINTENANCE_MODE_IPS') ? MAINTENANCE_MODE_IPS : '';
	$setting_name = $this->isAdmin ? 'MAINTENANCE_MODE_ADMIN' : 'MAINTENANCE_MODE_FRONT';

	if ( defined($setting_name) && constant($setting_name) > MaintenanceMode::NONE ) {
	$exception_ip = $check_ips ? kUtil::ipMatch($exception_ips) : false;

	if ( !$exception_ip ) {
	return constant($setting_name);
	}
	}

	return MaintenanceMode::NONE;
	}
	+
	+ /**
	+ * Sets content type of the page
	+ *
	+ * @param string $content_type
	+ * @param bool $include_charset
	+ * @return void
	+ * @access public
	+ */
	+ public function setContentType($content_type = 'text/html', $include_charset = null)
	+ {
	+ static $aleady_set = false;
	+
	+ if ( $aleady_set ) {
	+ return;
	+ }
	+
	+ $header = 'Content-type: ' . $content_type;
	+
	+ if ( !isset($include_charset) ) {
	+ $include_charset = $content_type = 'text/html' \|\| $content_type = 'text/xml';
	+ }
	+
	+ if ( $include_charset ) {
	+ $language = $this->recallObject('lang.current');
	+ /* @var $language LanguagesItem */
	+
	+ $header .= '; charset=' . $language->GetDBField('Charset');
	+ }
	+
	+ $aleady_set = true;
	+ header($header);
	+ }
	}
	\ No newline at end of file
	Index: branches/5.2.x/core/kernel/processors/main_processor.php
	===================================================================
	--- branches/5.2.x/core/kernel/processors/main_processor.php (revision 15172)
	+++ branches/5.2.x/core/kernel/processors/main_processor.php (revision 15173)
	@@ -1,1289 +1,1284 @@
	<?php
	/**
	* @version $Id$
	* @package In-Portal
	* @copyright Copyright (C) 1997 - 2009 Intechnic. All rights reserved.
	* @license GNU/GPL
	* In-Portal is Open Source software.
	* This means that this software may have been modified pursuant
	* the GNU General Public License, and as distributed it includes
	* or is derivative of works licensed under the GNU General Public License
	* or other free or open source software licenses.
	* See http://www.in-portal.org/license for copyright notices and details.
	*/

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

	class kMainTagProcessor extends kTagProcessor {

	public function __construct()
	{
	parent::__construct();

	$actions = $this->Application->recallObject('kActions');
	/* @var $actions Params */

	$actions->Set('t', $this->Application->GetVar('t'));
	$actions->Set('sid', $this->Application->GetSID());
	$actions->Set('m_opener', $this->Application->GetVar('m_opener') );
	}

	/**
	* Base folder for all template includes
	*
	* @param Array $params
	* @return string
	*/
	function TemplatesBase($params)
	{
	static $cached = Array ();

	$cache_key = crc32( serialize($params) );

	if (!array_key_exists($cache_key, $cached)) {
	$module = array_key_exists('module', $params) ? $params['module'] : 'core';

	if ($this->Application->isAdmin) {
	if ($module == 'in-portal') {
	$module = 'kernel';
	}

	// remove leading slash + substitute module
	$module_path = $this->Application->findModule('Name', $module, 'Path');

	if ($module_path !== false) {
	$path = $module_path . 'admin_templates';
	}
	else {
	// remove leading slash + substitute module
	$path = preg_replace('/\/(.?)\/(.)/', $module . '/\\2', THEMES_PATH);
	}
	}
	else {
	$path = mb_substr(THEMES_PATH, 1);

	if (mb_strtolower($module) == 'in-portal') {
	$module_folder = 'platform';
	}
	else {
	$module_folder = $this->Application->findModule('Name', $module, 'TemplatePath');
	}

	$path .= rtrim('/' . trim($module_folder, '/'), '/') . '/';
	}

	$cached[$cache_key] = $this->Application->BaseURL() . $path;
	}

	return $cached[$cache_key];
	}

	/**
	* Creates <base href ..> HTML tag for all templates
	* affects future css, js files and href params of links
	*
	* @param Array $params
	* @return string
	* @access protected
	*/
	protected function Base_Ref($params)
	{
	return '<base href="' . $this->TemplatesBase($params) . '/" />';
	}

	/**
	* Returns base url for web-site
	*
	* @return string
	* @access public
	*/
	function BaseURL()
	{
	return $this->Application->BaseURL();
	}

	//for compatability with K3 tags
	function Base($params)
	{
	return $this->TemplatesBase($params).'/';
	}

	function ProjectBase($params)
	{
	return $this->Application->BaseURL();
	}

	/*function Base($params)
	{
	return $this->Application->BaseURL().$params['add'];
	}*/

	/**
	* Used to create link to any template.
	* use "pass" paramter if "t" tag to specify
	* prefix & special of object to be represented
	* in resulting url
	*
	* @param Array $params
	* @return string
	* @access public
	*/
	function T($params)
	{
	// by default link to current template
	$template = $this->SelectParam($params, 't,template');
	$prefix = array_key_exists('prefix', $params) ? $params['prefix'] : '';

	unset($params['t'], $params['template'], $params['prefix']);

	return $this->Application->HREF($template, $prefix, $params);
	}

	function Link($params)
	{
	// pass "m" prefix, instead of "all", that is by default on Front-End
	if (!array_key_exists('pass', $params)) {
	$params['pass'] = 'm';
	}

	return $this->T($params);
	}

	/**
	* Performs redirect to provided template/url
	*
	* @param Array $params
	* @return string
	*/
	function Redirect($params)
	{
	$this->Application->Redirect('external:' . $this->Link($params));

	return '';
	}

	/*function Env($params)
	{
	$t = $params['template'];
	unset($params['template']);
	return $this->Application->BuildEnv($t, $params, 'm', false, false);
	}*/

	function FormAction($params)
	{
	if (!array_key_exists('pass', $params)) {
	$params['pass'] = 'all,m';
	}

	$params['pass_category'] = 1;

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

	/*// NEEDS TEST
	function Config($params)
	{
	return $this->Application->ConfigOption($params['var']);
	}

	function Object($params)
	{
	$name = $params['name'];
	$method = $params['method'];

	$tmp = $this->Application->recallObject($name);
	if ($tmp != null) {
	if (method_exists($tmp, $method))
	return $tmp->$method($params);
	else
	echo "Method $method does not exist in object ".get_class($tmp)." named $name<br>";
	}
	else
	echo "Object $name does not exist in the appliaction<br>";
	}*/

	/**
	* Tag, that always returns true.
	* For parser testing purposes
	*
	* @param Array $params
	* @return bool
	* @access public
	*/
	function True($params)
	{
	return true;
	}

	/**
	* Tag, that always returns false.
	* For parser testing purposes
	*
	* @param Array $params
	* @return bool
	* @access public
	*/
	function False($params)
	{
	return false;
	}

	/**
	* Returns block parameter by name (used only as "check" parameter value for "m_if" tag!)
	*
	* @param Array $params
	* @return stirng
	* @access public
	*/
	function Param($params)
	{
	$name = $params['name'];

	if (array_key_exists($name, $this->Application->Parser->Captures)) {
	$capture_params = $params;
	$capture_params['name'] = '__capture_' . $name;

	$this->Application->Parser->SetParam($name, $this->Application->ParseBlock($capture_params));
	}

	$res = $this->Application->Parser->GetParam($name);

	if ($res === false) {
	$res = '';
	}

	if (array_key_exists('plus', $params)) {
	$res += $params['plus'];
	}

	return $res;
	}

	/**
	* Compares block parameter with value specified
	*
	* @param Array $params
	* @return bool
	* @access public
	*/
	function ParamEquals($params)
	{
	$name = $this->SelectParam($params, 'name,var,param');
	$value = $params['value'];

	return ($this->Application->Parser->GetParam($name) == $value);
	}

	/*function PHP_Self($params)
	{
	return $HTTP_SERVER_VARS['PHP_SELF'];
	}
	*/

	/**
	* Returns session variable value by name
	*
	* @param Array $params
	* @return string
	* @access public
	*/
	function Recall($params)
	{
	$var_name = $this->SelectParam($params,'name,var,param');

	if (isset($params['persistent']) && $params['persistent']) {
	$ret = $this->Application->RecallPersistentVar($var_name);
	}
	else {
	$ret = $this->Application->RecallVar($var_name);
	}

	$ret = ($ret === false && isset($params['no_null'])) ? '' : $ret;
	if (getArrayValue($params, 'special') \|\| getArrayValue($params, 'htmlchars')) {
	$ret = htmlspecialchars($ret);
	}

	if (getArrayValue($params, 'urlencode')) {
	$ret = urlencode($ret);
	}

	return $ret;
	}

	function RemoveVar($params)
	{
	$this->Application->RemoveVar( $this->SelectParam($params,'name,var,param') );
	}

	// bad style to store something from template to session !!! (by Alex)
	// Used here only to test how session works, nothing more
	function Store($params)
	{
	//echo"Store $params[name]<br>";
	$name = $params['name'];
	$value = $params['value'];
	$this->Application->StoreVar($name,$value);
	}

	/**
	* Links variable from request with variable from session
	*
	* @param Array $params
	* @return string
	* @access protected
	*/
	protected function LinkVar($params)
	{
	$var_name = $params['name'];
	$session_var_name = isset($params['session_name']) ? $params['session_name'] : $var_name;
	$default_value = isset($params['default']) ? $params['default'] : '';

	$this->Application->LinkVar($var_name, $session_var_name, $default_value);

	return '';
	}

	/**
	* Links variable from request with variable from session and returns it's value
	*
	* @param Array $params
	* @return string
	* @access protected
	*/
	protected function GetLinkedVar($params)
	{
	$this->LinkVar($params);

	return $this->Application->GetVar( $params['name'] );
	}

	/**
	* Sets application variable value(-s)
	*
	* @param Array $params
	* @access public
	*/
	function Set($params)
	{
	foreach ($params as $param => $value) {
	$this->Application->SetVar($param, $value);
	}
	}

	/**
	* Increment application variable
	* specified by number specified
	*
	* @param Array $params
	* @access public
	*/
	function Inc($params)
	{
	$this->Application->SetVar($params['param'], $this->Application->GetVar($params['param']) + $params['by']);
	}

	/**
	* Retrieves application variable
	* value by name
	*
	* @param Array $params
	* @return string
	* @access public
	*/
	function Get($params)
	{
	$name = $this->SelectParam($params, 'name,var,param');

	if ( strpos($name, '[') !== false ) {
	preg_match('/([^\[\]]+)\[(.*)\]/', $name, $regs);

	$function_params = explode('][', $regs[2]);
	$ret = $this->Application->GetVar($regs[1], Array ());
	array_unshift_ref($function_params, $ret);

	return call_user_func_array('getArrayValue', $function_params);
	}
	else {
	$ret = $this->Application->GetVar($name, '');
	}

	if (array_key_exists('no_html_escape', $params) && $params['no_html_escape']) {
	return kUtil::unhtmlentities($ret);
	}

	return $ret;
	}

	/**
	* Retrieves application constant
	* value by name
	*
	* @param Array $params
	* @return string
	* @access public
	*/
	function GetConst($params)
	{
	$constant_name = $this->SelectParam($params, 'name,const');

	return defined($constant_name) ? constant($constant_name) : '';
	}

	/**
	* Retrieves configuration variable value by name
	*
	* @param Array $params
	* @return string
	* @access public
	*/
	function GetConfig($params)
	{
	$config_name = $this->SelectParam($params, 'name,var');
	$ret = $this->Application->ConfigValue($config_name);

	if ( isset($params['formatted']) && $params['formatted'] ) {
	$sql = 'SELECT ValueList
	FROM ' . TABLE_PREFIX . 'SystemSettings
	WHERE VariableName = ' . $this->Conn->qstr($config_name) . ' AND ElementType IN ("select", "radio")';
	$value_list = $this->Conn->GetOne($sql);

	if ( $value_list ) {
	$helper = $this->Application->recallObject('InpCustomFieldsHelper');
	/* @var $helper InpCustomFieldsHelper */

	$options = $helper->GetValuesHash($value_list);
	$ret = isset($options[$ret]) ? $options[$ret] : $ret;
	}
	}

	if ( isset($params['as_label']) && $params['as_label'] ) {
	$ret = $this->Application->Phrase($ret);
	}

	return $ret;
	}

	/**
	* Compares configuration variable to a given value
	*
	* @param Array $params
	* @return bool
	* @deprecated
	* @access protected
	*/
	protected function ConfigEquals($params)
	{
	$option = $this->SelectParam($params, 'name,option,var');

	return $this->Application->ConfigValue($option) == $params['value'];
	}

	/**
	* Creates all hidden fields
	* needed for kernel_form
	*
	* @param Array $params
	* @return string
	* @access protected
	*/
	protected function DumpSystemInfo($params)
	{
	$actions = $this->Application->recallObject('kActions');
	/* @var $actions Params */

	$actions->Set('t', $this->Application->GetVar('t'));

	$o = '';
	$params = $actions->GetParams();

	foreach ($params AS $name => $val) {
	$o .= "<input type='hidden' name='$name' id='$name' value='$val'>\n";
	}

	return $o;
	}

	/**
	* Used for search sidebox on front-end only
	*
	* @param Array $params
	* @return string
	* @access protected
	*/
	protected function GetFormHiddens($params)
	{
	$t = $this->SelectParam($params, 'template,t');
	unset($params['template']);

	$form_fields = Array ();
	if ( $this->Application->RewriteURLs() ) {
	$session = $this->Application->recallObject('Session');
	/* @var $session Session */

	if ( $session->NeedQueryString() ) {
	$form_fields['sid'] = $this->Application->GetSID();
	}
	}
	else {
	$form_fields['env'] = $this->Application->BuildEnv($t, $params, 'm', false, false);
	}

	if ( $this->Application->GetVar('admin') == 1 ) {
	$form_fields['admin'] = 1;
	}

	$ret = '';
	$field_tpl = '<input type="hidden" name="%1$s" id="%1$s" value="%2$s"/>' . "\n";
	foreach ($form_fields as $form_field => $field_value) {
	$ret .= sprintf($field_tpl, $form_field, $field_value);
	}

	return $ret;
	}

	function Odd_Even($params)
	{
	$odd = $params['odd'];
	$even = $params['even'];
	if (!isset($params['var'])) {
	$var = 'odd_even';
	}
	else {
	$var = $params['var'];
	}

	if ($this->Application->GetVar($var) == 'even') {
	if (!isset($params['readonly']) \|\| !$params['readonly']) {
	$this->Application->SetVar($var, 'odd');
	}
	return $even;
	}
	else {
	if (!isset($params['readonly']) \|\| !$params['readonly']) {
	$this->Application->SetVar($var, 'even');
	}
	return $odd;
	}
	}

	/**
	* Returns phrase translation by name
	*
	* @param Array $params
	* @return string
	* @access public
	*/
	function Phrase($params)
	{
	$phrase_name = $this->SelectParam($params, 'label,name,title');
	$default_translation = $this->SelectParam($params, 'default');

	$no_editing = isset($params['no_editing']) && $params['no_editing'];
	$translation = $this->Application->Phrase($phrase_name, !$no_editing);

	$phrase_key = mb_strtoupper($phrase_name);

	if ( $default_translation && strpos($translation, '!' . $phrase_key . '!') !== false ) {
	$phrase = $this->Application->recallObject('phrases.autocreate', null, Array ('skip_autoload' => true));
	/* @var $phrase kDBItem */

	if ( !$phrase->Load($phrase_key, 'PhraseKey') ) {
	$phrase->SetDBField('Phrase', $phrase_name);

	$ml_helper = $this->Application->recallObject('kMultiLanguageHelper');
	/* @var $ml_helper kMultiLanguageHelper */

	$languages = $ml_helper->getLanguages();

	foreach ($languages AS $language_id) {
	$phrase->SetDBField('l' . $language_id . '_Translation', $default_translation);
	}

	if ( $phrase->Create() ) {
	$translation = $default_translation;
	}
	}
	}

	if ( isset($params['escape']) && $params['escape'] ) {
	$translation = htmlspecialchars($translation, ENT_QUOTES);
	$translation = addslashes($translation);
	}

	return $translation;
	}

	// for tabs
	function is_active($params)
	{
	$test_templ = $this->SelectParam($params, 'templ,template,t');
	if ( !getArrayValue($params,'allow_empty') )
	{
	$if_true=getArrayValue($params,'true') ? $params['true'] : 1;
	$if_false=getArrayValue($params,'false') ? $params['false'] : 0;
	}
	else
	{
	$if_true=$params['true'];
	$if_false=$params['false'];
	}

	if ( preg_match("/^".str_replace('/', '\/', $test_templ)."/i", $this->Application->GetVar('t'))) {
	return $if_true;
	}
	else {
	return $if_false;
	}
	}

	function IsNotActive($params)
	{
	return !$this->is_active($params);
	}

	function IsActive($params)
	{
	return $this->is_active($params);
	}

	function is_t_active($params)
	{
	return $this->is_active($params);
	}

	function CurrentTemplate($params)
	{
	return $this->is_active($params);
	}

	/**
	* Checks if session variable
	* specified by name value match
	* value passed as parameter
	*
	* @param Array $params
	* @return string
	* @access public
	*/
	function RecallEquals($params)
	{
	$name = $this->SelectParam($params, 'name,var');
	$value = $params['value'];

	if (isset($params['persistent']) && $params['persistent']) {
	return $this->Application->RecallPersistentVar($name) == $value;
	}

	return ($this->Application->RecallVar($name) == $value);
	}

	/**
	* Checks if application variable specified by name value match value passed as parameter
	*
	* @param Array $params
	* @return bool
	* @access protected
	* @deprecated
	*/
	protected function GetEquals($params)
	{
	$name = $this->SelectParam($params, 'var,name,param');

	return $this->Application->GetVar($name) == $params['value'];
	}

	function ModuleInclude($params)
	{
	$ret = '';
	$included = Array ();
	$block_params = array_merge($params, Array('is_silent' => 2)); // don't make fatal errors in case if template is missing
	$current_template = $this->Application->GetVar('t');

	$replace_main = isset($params['replace_m']) && $params['replace_m'];
	$skip_prefixes = isset($params['skip_prefixes']) ? explode(',', $params['skip_prefixes']) : Array();
	$cms_mode = $this->Application->GetVar('admin');

	foreach ($this->Application->ModuleInfo as $module_name => $module_data) {
	$module_key = mb_strtolower($module_name);

	if ($module_name == 'In-Portal') {
	if (!$cms_mode && $this->Application->isAdmin) {
	// don't process In-Portal templates in admin
	continue;
	}

	// Front-End still relies on In-Portal module
	$module_prefix = $module_data['TemplatePath'];
	}
	elseif ($this->Application->isAdmin) {
	$module_prefix = $module_key . '/'; // was $module_data['Path'];
	}
	else {
	$module_prefix = $module_data['TemplatePath']; // always have trailing "/"
	}

	if (in_array($module_prefix, $included)) {
	// template by this path was already included by other module (e.g. in-portal used core's template)
	continue;
	}

	$block_params['t'] = $module_prefix.$this->SelectParam($params, $module_key.'_template,'.$module_key.'_t,template,t');

	$check_prefix = $module_data['Var'];

	if ($check_prefix == 'adm' && $replace_main) {
	$check_prefix = 'c';
	}

	if ($block_params['t'] == $current_template \|\| in_array($check_prefix, $skip_prefixes)) {
	continue;
	}

	$no_data = $this->SelectParam($params, $module_key.'_block_no_data,block_no_data');
	if ($no_data) {
	$block_params['block_no_data'] = $module_prefix.'/'.$no_data;
	}

	$ret .= $this->Application->IncludeTemplate($block_params);
	$included[] = $module_prefix;
	}

	return $ret;
	}

	function ModuleEnabled($params)
	{
	return $this->Application->isModuleEnabled( $params['module'] );
	}

	/**
	* Checks if debug mode is on
	*
	* @param Array $params
	* @return bool
	* @access public
	*/
	function IsDebugMode($params)
	{
	return defined('DEBUG_MODE') && $this->Application->isDebugMode();
	}

	/*function MassParse($params)
	{
	$qty = $params['qty'];
	$block = $params['block'];
	$mode = $params['mode'];

	$o = '';
	if ($mode == 'func') {
	$func = create_function('$params', '
	$o = \'<tr>\';
	$o.= \'<td>a\'.$params[\'param1\'].\'</td>\';
	$o.= \'<td>a\'.$params[\'param2\'].\'</td>\';
	$o.= \'<td>a\'.$params[\'param3\'].\'</td>\';
	$o.= \'<td>a\'.$params[\'param4\'].\'</td>\';
	$o.= \'</tr>\';
	return $o;
	');
	for ($i=1; $i<$qty; $i++) {
	$block_params['param1'] = rand(1, 10000);
	$block_params['param2'] = rand(1, 10000);
	$block_params['param3'] = rand(1, 10000);
	$block_params['param4'] = rand(1, 10000);
	$o .= $func($block_params);
	}
	return $o;
	}

	$block_params['name'] = $block;

	for ($i=0; $i<$qty; $i++) {
	$block_params['param1'] = rand(1, 10000);
	$block_params['param2'] = rand(1, 10000);
	$block_params['param3'] = rand(1, 10000);
	$block_params['param4'] = rand(1, 10000);
	$block_params['passed'] = $params['passed'];
	$block_params['prefix'] = 'm';

	$o.= $this->Application->ParseBlock($block_params);
	}
	return $o;
	}*/

	function LoggedIn($params)
	{
	return $this->Application->LoggedIn();
	}

	/**
	* Allows to check if permission exists directly in template and perform additional actions if required
	*
	* @param Array $params
	* @return bool
	*/
	function CheckPermission($params)
	{
	$perm_helper = $this->Application->recallObject('PermissionsHelper');
	/* @var $perm_helper kPermissionsHelper */

	return $perm_helper->TagPermissionCheck($params);
	}

	/**
	* Checks if user is logged in and if not redirects it to template passed
	*
	* @param Array $params
	*/
	function RequireLogin($params)
	{
	$t = $this->Application->GetVar('t');
	$next_t = getArrayValue($params, 'next_template');

	if ( $next_t ) {
	$t = $next_t;
	}

	// check by permissions: begin
	if ((isset($params['perm_event']) && $params['perm_event']) \|\|
	(isset($params['perm_prefix']) && $params['perm_prefix']) \|\|
	(isset($params['permissions']) && $params['permissions'])) {

	$perm_helper = $this->Application->recallObject('PermissionsHelper');
	/* @var $perm_helper kPermissionsHelper */

	$perm_status = $perm_helper->TagPermissionCheck($params);
	if (!$perm_status) {
	list($redirect_template, $redirect_params) = $perm_helper->getPermissionTemplate($params);
	$this->Application->Redirect($redirect_template, $redirect_params);
	}
	else {
	return ;
	}
	}
	// check by permissions: end

	// check by configuration value: begin
	$condition = getArrayValue($params, 'condition');
	if (!$condition) {
	$condition = true;
	}
	else {
	if (substr($condition, 0, 1) == '!') {
	$condition = !$this->Application->ConfigValue(substr($condition, 1));
	}
	else {
	$condition = $this->Application->ConfigValue($condition);
	}
	}
	// check by configuration value: end

	// check by belonging to group: begin
	$group = $this->SelectParam($params, 'group');
	$group_access = true;
	if ($group) {
	$sql = 'SELECT GroupId
	FROM '.TABLE_PREFIX.'UserGroups
	WHERE Name = '.$this->Conn->qstr($group);
	$group_id = $this->Conn->GetOne($sql);

	if ($group_id) {
	$groups = explode(',', $this->Application->RecallVar('UserGroups'));
	$group_access = in_array($group_id, $groups);
	}
	}
	// check by belonging to group: end

	if ((!$this->Application->LoggedIn() \|\| !$group_access) && $condition) {
	$redirect_params = $this->Application->HttpQuery->getRedirectParams(true);

	if (array_key_exists('pass_category', $params)) {
	$redirect_params['pass_category'] = $params['pass_category'];
	}

	if (MOD_REWRITE) {
	// TODO: $next_t variable is ignored !!! (is anyone using m_RequireLogin tag with "next_template" parameter?)
	$redirect_params = Array (
	'm_cat_id' => 0,
	'next_template' => urlencode('external:' . $_SERVER['REQUEST_URI']),
	);
	}
	else {
	$redirect_params['next_template'] = $t;
	}

	if ( $this->Application->LoggedIn() && !$group_access) {
	$this->Application->Redirect($params['no_group_perm_template'], $redirect_params);
	}

	$this->Application->Redirect($params['login_template'], $redirect_params);
	}
	}

	/**
	* Checks, that user belongs to a group with a given name
	*
	* @param Array $params
	* @return bool
	*/
	protected function IsMember($params)
	{
	$sql = 'SELECT GroupId
	FROM ' . TABLE_PREFIX . 'UserGroups
	WHERE Name = ' . $this->Conn->qstr($params['group']);
	$group_id = $this->Conn->GetOne($sql);

	if ( $group_id ) {
	$groups = explode(',', $this->Application->RecallVar('UserGroups'));

	return in_array($group_id, $groups);
	}

	return false;
	}

	/**
	* Checks if SSL is on and redirects to SSL URL if needed
	* If SSL_URL is not defined in config - the tag does not do anything
	* If for_logged_in_only="1" exits if user is not logged in.
	* If called without params forces https right away. If called with by_config="1" checks the
	* Require SSL setting from General Config and if it is ON forces https
	*
	* @param Array $params
	*/
	protected function CheckSSL($params)
	{
	$ssl = $this->Application->isAdmin ? $this->Application->ConfigValue('AdminSSL_URL') : false;

	if ( !$ssl ) {
	// not in admin or admin ssl url is empty
	$ssl_url = $this->Application->siteDomainField('SSLUrl');
	$ssl = $ssl_url !== false ? $ssl_url : $this->Application->ConfigValue('SSL_URL');
	}

	if ( !$ssl \|\| ($this->Application->TemplatesCache->forceThemeName !== false) ) {
	// SSL URL is not set - no way to require SSL
	// internal parsing (e.g. "TemplateParser::_parseTemplate") -> don't redirect
	return;
	}

	$require = false;

	if ( isset($params['mode']) && $params['mode'] == 'required' ) {
	$require = true;
	if ( isset($params['for_logged_in_only']) && $params['for_logged_in_only'] && !$this->Application->LoggedIn() ) {
	$require = false;
	}

	if ( isset($params['condition']) ) {
	if ( !$this->Application->ConfigValue($params['condition']) ) {
	$require = false;
	}
	}
	}

	if ( EDITING_MODE ) {
	// match SSL mode on front-end to one in administrative console, when browse modes are used
	$require = $this->Application->ConfigValue('Require_AdminSSL');
	}

	$http_query = $this->Application->recallObject('HTTPQuery');
	/* @var $http_query kHTTPQuery */

	$pass = $http_query->getRedirectParams();
	$pass['pass_events'] = 1; // to make sure all events are passed when redirect happens

	if ( $require ) {
	if ( PROTOCOL == 'https://' ) {
	$this->Application->SetVar('__KEEP_SSL__', 1);
	return;
	}

	$pass['__SSL__'] = 1;
	$this->Application->Redirect('', $pass);
	}
	else {
	if ( PROTOCOL == 'https://' && $this->Application->ConfigValue('Force_HTTP_When_SSL_Not_Required') ) {
	if ( $this->Application->GetVar('__KEEP_SSL__') ) {
	return;
	}

	// $pass_more = Array ('pass' => 'm', 'm_cat_id' => 0, '__SSL__' => 0);
	$pass['__SSL__'] = 0;
	$this->Application->Redirect('', $pass); // $pass_more
	}
	}
	}

	function ConstOn($params)
	{
	$name = $this->SelectParam($params,'name,const');
	return kUtil::constOn($name);
	}

	function SetDefaultCategory($params)
	{
	$category_id = $this->Application->findModule('Name', $params['module'], 'RootCat');
	$this->Application->SetVar('m_cat_id', $category_id);
	}

	function XMLTemplate($params)
	{
	$this->NoDebug($params);

	if ( isset($params['cache']) && $params['cache'] ) {
	$nextyear = intval(date('Y') + 1);

	$format = "D, d M Y H:i:s";
	$expiration = gmdate($format, mktime() + $params['cache']) . ' GMT';
	$last_modified = mktime();

	header('Cache-Control: public, cache, max-age=' . $params['cache']);
	header("Expires: $expiration");
	header('Pragma: public');

	// Getting headers sent by the client.
	$headers = $this->_requestHeaders();

	// Checking if the client is validating his cache and if it is current.
	if ( isset($headers['If-Modified-Since']) && (strtotime($headers['If-Modified-Since']) > $last_modified - $params['cache']) ) {
	// Client's cache IS current, so we just respond '304 Not Modified'.
	header('Last-Modified: ' . date($format, strtotime($headers['If-Modified-Since'])) . ' GMT', true, 304);
	exit;
	}
	else {
	// Image not cached or cache outdated, we respond '200 OK' and output the image.
	header('Last-Modified: ' . gmdate($format, $last_modified) . ' GMT', true, 200);
	}
	}

	// xml documents are usually long
	set_time_limit(0);
	ini_set('memory_limit', -1);

	if ( !$this->Application->GetVar('debug') ) {
	return $this->Application->XMLHeader(getArrayValue($params, 'xml_version'));
	}

	- $lang = $this->Application->recallObject('lang.current');
	- /* @var $lang LanguagesItem */
	-
	- header('Content-type: text/html; charset=' . $lang->GetDBField('Charset'));
	-
	return '';
	}

	protected function _requestHeaders()
	{
	if ( function_exists('apache_request_headers') ) {
	// If apache_request_headers() exists...
	$headers = apache_request_headers();

	if ($headers) {
	return $headers; // And works... Use it
	}
	}

	$headers = Array ();

	foreach (array_keys($_SERVER) as $skey) {
	if (substr($skey, 0, 5) == 'HTTP_') {
	$headername = str_replace(' ', '-', ucwords(strtolower(str_replace('_', ' ', substr($skey, 0, 5)))));
	$headers[$headername] = $_SERVER[$skey];
	}
	}

	return $headers;
	}

	function Header($params)
	{
	header($params['data']);
	}

	function NoDebug($params)
	{
	if ( !$this->Application->GetVar('debug') ) {
	kUtil::safeDefine('DBG_SKIP_REPORTING', 1);
	}
	}

	/**
	* Returns Home category name
	*
	* @param Array $params
	* @return string
	* @deprecated
	*/
	function RootCategoryName($params)
	{
	$no_editing = array_key_exists('no_editing', $params) && $params['no_editing'];

	return $this->Application->Phrase('la_rootcategory_name', !$no_editing);
	}

	/**
	* Allows to attach file directly from email event template
	*
	* @param Array $params
	*/
	function AttachFile($params)
	{
	$path = FULL_PATH . '/' . $params['path'];
	$pseudo = isset($params['special']) ? 'EmailSender.' . $params['special'] : 'EmailSender';

	$esender = $this->Application->recallObject($pseudo);
	/* @var $esender kEmailSendingHelper */

	if ( file_exists($path) ) {
	$esender->AddAttachment($path);
	}
	}

	function CaptchaImage($params)
	{
	$this->NoDebug($params);
	$this->Application->SetVar('skip_last_template', 1);

	$captcha_helper = $this->Application->recallObject('CaptchaHelper');
	/* @var $captcha_helper kCaptchaHelper */

	// generate captcha code
	$code = $captcha_helper->prepareCode( $this->Application->GetVar('var') );

	$captcha_helper->GenerateCaptchaImage($code, $this->Application->GetVar('w'), $this->Application->GetVar('h'), true);
	}

	function SID($params)
	{
	return $this->Application->GetSID();
	}

	function ModuleInfo($params)
	{
	return $this->Application->findModule($params['key'], $params['value'], $params['return']);
	}

	function Random($params)
	{
	return rand(1, 100000000);
	}

	/**
	* Prints parser params, available at current deep level
	*
	* @param Array $params
	* @return string
	*/
	function PrintCurrentParams($params)
	{
	$current_params = $this->Application->Parser->Params;

	foreach ($current_params as $param_name => $param_value) {
	$current_params[$param_name] = $param_name . ' = "' . $param_value . '"';
	}

	return '<pre>' . implode("\n", $current_params) . '</pre>';
	}

	/**
	* Gets previously defined counter result
	*
	* @param Array $params
	* @return int
	*/
	function GetCounter($params)
	{
	return $this->Application->getCounter($params['name'], $params);
	}

	/**
	* Increments PageHit counter
	*
	* @param Array $params
	* @return int
	*/
	function RegisterPageHit($params)
	{
	if ($this->Application->ConfigValue('UsePageHitCounter')) {
	// get current counte
	$sql = 'SELECT VariableValue
	FROM '.TABLE_PREFIX.'SystemSettings
	WHERE VariableName = "PageHitCounter"';
	$page_counter = (int)$this->Conn->GetOne($sql);

	$sql = 'UPDATE LOW_PRIORITY '.TABLE_PREFIX.'SystemSettings
	SET VariableValue = '.($page_counter + 1).'
	WHERE VariableName = "PageHitCounter"';
	$this->Conn->Query($sql);
	}
	}

	function Timestamp($params)
	{
	$format = isset($params['format']) ? $params['format'] : 'd.m.Y H:i:s';
	return adodb_date($format);
	}

	function GetUrlHiddenFileds($params)
	{
	$vars = Array ('page', 'per_page', 'sort_by');
	$ret = '<input type="hidden" name="main_list" value="1"/>';

	if (array_key_exists('skip', $params)) {
	$vars = array_diff($vars, $params['skip']);
	}

	foreach ($vars as $var_name) {
	$var_value = $this->Application->GetVar($var_name);

	if ($var_value) {
	$ret .= '<input type="hidden" name="' . $var_name . '" value="' . $var_value . '"/>';
	}
	}

	return $ret;
	}

	/**
	* Returns current Page URL (without re-assembling it).
	* "skip_query" param is optional and will remove the ?QUERY part from the result.
	*
	* @param Array $params
	* @return string
	* @access protected
	*/
	protected function CurrentPageLink($params)
	{
	if ( isset($params['skip_query']) && $params['skip_query'] ) {
	return preg_replace('/\?' . preg_quote($_SERVER['QUERY_STRING'], '/') . '$/', '', $_SERVER['REQUEST_URI']);
	}

	return $_SERVER['REQUEST_URI'];
	}

	/**
	* Returns current maintenance mode state
	*
	* @param Array $params
	* @return int
	* @access protected
	*/
	protected function MaintenanceMode($params)
	{
	$check_ips = isset($params['check_ips']) ? $params['check_ips'] : true;

	return $this->Application->getMaintenanceMode($check_ips);
	}

	/**
	* Checks if element with given name is defined
	*
	* @param Array $params
	* @return int
	* @access protected
	*/
	protected function ElementDefined($params)
	{
	return $this->Application->Parser->blockFound($params['name']);
	}
	}
	Index: branches/5.2.x/core/units/helpers/file_helper.php
	===================================================================
	--- branches/5.2.x/core/units/helpers/file_helper.php (revision 15172)
	+++ branches/5.2.x/core/units/helpers/file_helper.php (revision 15173)
	@@ -1,462 +1,462 @@
	<?php
	/**
	* @version $Id$
	* @package In-Portal
	* @copyright Copyright (C) 1997 - 2009 Intechnic. All rights reserved.
	* @license GNU/GPL
	* In-Portal is Open Source software.
	* This means that this software may have been modified pursuant
	* the GNU General Public License, and as distributed it includes
	* or is derivative of works licensed under the GNU General Public License
	* or other free or open source software licenses.
	* See http://www.in-portal.org/license for copyright notices and details.
	*/

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

	class FileHelper extends kHelper {

	/**
	* Puts existing item images (from sub-item) to virtual fields (in main item)
	*
	* @param kCatDBItem $object
	* @return void
	* @access public
	*/
	public function LoadItemFiles(&$object)
	{
	$max_file_count = $this->Application->ConfigValue($object->Prefix.'_MaxImageCount'); // file count equals to image count (temporary measure)

	$sql = 'SELECT *
	FROM '.TABLE_PREFIX.'CatalogFiles
	WHERE ResourceId = '.$object->GetDBField('ResourceId').'
	ORDER BY FileId ASC
	LIMIT 0, '.(int)$max_file_count;
	$item_files = $this->Conn->Query($sql);

	$file_counter = 1;
	foreach ($item_files as $item_file) {
	$file_path = $item_file['FilePath'];
	$object->SetDBField('File'.$file_counter, $file_path);
	$object->SetOriginalField('File'.$file_counter, $file_path);
	$object->SetFieldOption('File'.$file_counter, 'original_field', $item_file['FileName']);
	$file_counter++;
	}
	}

	/**
	* Saves newly uploaded images to external image table
	*
	* @param kCatDBItem $object
	* @return void
	* @access public
	*/
	public function SaveItemFiles(&$object)
	{
	$table_name = $this->Application->getUnitOption('#file', 'TableName');
	$max_file_count = $this->Application->getUnitOption($object->Prefix, 'FileCount'); // $this->Application->ConfigValue($object->Prefix.'_MaxImageCount');

	$this->CheckFolder(FULL_PATH . ITEM_FILES_PATH);

	$i = 0;
	while ($i < $max_file_count) {
	$field = 'File'.($i + 1);
	$field_options = $object->GetFieldOptions($field);

	$file_path = $object->GetDBField($field);
	if ($file_path) {
	if (isset($field_options['original_field'])) {
	$key_clause = 'FileName = '.$this->Conn->qstr($field_options['original_field']).' AND ResourceId = '.$object->GetDBField('ResourceId');

	if ($object->GetDBField('Delete'.$field)) {
	// if item was cloned, then new filename is in db (not in $image_src)
	$sql = 'SELECT FilePath
	FROM '.$table_name.'
	WHERE '.$key_clause;
	$file_path = $this->Conn->GetOne($sql);
	if (@unlink(FULL_PATH.ITEM_FILES_PATH.$file_path)) {
	$sql = 'DELETE FROM '.$table_name.'
	WHERE '.$key_clause;
	$this->Conn->Query($sql);
	}
	}
	else {
	// image record found -> update
	$fields_hash = Array (
	'FilePath' => $file_path,
	);

	$this->Conn->doUpdate($fields_hash, $table_name, $key_clause);
	}
	}
	else {
	// record not found -> create
	$fields_hash = Array (
	'ResourceId' => $object->GetDBField('ResourceId'),
	'FileName' => $field,
	'Status' => STATUS_ACTIVE,
	'FilePath' => $file_path,
	);

	$this->Conn->doInsert($fields_hash, $table_name);
	$field_options['original_field'] = $field;
	$object->SetFieldOptions($field, $field_options);
	}
	}
	$i++;
	}
	}

	/**
	* Preserves cloned item images/files to be rewritten with original item images/files
	*
	* @param Array $field_values
	* @return void
	* @access public
	*/
	public function PreserveItemFiles(&$field_values)
	{
	foreach ($field_values as $field_name => $field_value) {
	if ( !is_array($field_value) ) {
	continue;
	}

	if ( isset($field_value['upload']) && ($field_value['error'] == UPLOAD_ERR_NO_FILE) ) {
	// this is upload field, but nothing was uploaded this time
	unset($field_values[$field_name]);
	}
	}
	}

	/**
	* Determines what image/file fields should be created (from post or just dummy fields for 1st upload)
	*
	* @param string $prefix
	* @param bool $is_image
	* @return void
	* @access public
	*/
	public function createItemFiles($prefix, $is_image = false)
	{
	$items_info = $this->Application->GetVar($prefix);
	if ($items_info) {
	list (, $fields_values) = each($items_info);
	$this->createUploadFields($prefix, $fields_values, $is_image);
	}
	else {
	$this->createUploadFields($prefix, Array(), $is_image);
	}
	}

	/**
	* Dynamically creates virtual fields for item for each image/file field in submit
	*
	* @param string $prefix
	* @param Array $fields_values
	* @param bool $is_image
	* @return void
	* @access public
	*/
	public function createUploadFields($prefix, $fields_values, $is_image = false)
	{
	$field_options = Array (
	'type' => 'string',
	'max_len' => 240,
	'default' => '',
	);

	if ($is_image) {
	$field_options['formatter'] = 'kPictureFormatter';
	$field_options['include_path'] = 1;
	$field_options['allowed_types'] = Array ('image/jpeg', 'image/pjpeg', 'image/png', 'image/x-png', 'image/gif', 'image/bmp');
	$field_prefix = 'Image';
	}
	else {
	$field_options['formatter'] = 'kUploadFormatter';
	$field_options['upload_dir'] = ITEM_FILES_PATH;
	$field_options['allowed_types'] = Array ('application/pdf', 'application/msexcel', 'application/msword', 'application/mspowerpoint');
	$field_prefix = 'File';
	}

	$fields = $this->Application->getUnitOption($prefix, 'Fields');
	$virtual_fields = $this->Application->getUnitOption($prefix, 'VirtualFields');

	$image_count = 0;
	foreach ($fields_values as $field_name => $field_value) {
	if (preg_match('/^('.$field_prefix.'[\d]+\|Primary'.$field_prefix.')$/', $field_name)) {
	$fields[$field_name] = $field_options;
	$virtual_fields[$field_name] = $field_options;
	$this->_createCustomFields($prefix, $field_name, $virtual_fields, $is_image);

	$image_count++;
	}
	}

	if (!$image_count) {
	// no images found in POST -> create default image fields
	$image_count = $this->Application->ConfigValue($prefix.'_MaxImageCount');

	if ($is_image) {
	$created_count = 1;
	$image_names = Array ('Primary' . $field_prefix => '');

	while ($created_count < $image_count) {
	$image_names[$field_prefix . $created_count] = '';
	$created_count++;
	}
	}
	else {
	$created_count = 0;
	$image_names = Array ();

	while ($created_count < $image_count) {
	$image_names[$field_prefix . ($created_count + 1)] = '';
	$created_count++;
	}
	}

	if ($created_count) {
	$this->createUploadFields($prefix, $image_names, $is_image);
	}

	return ;
	}

	$this->Application->setUnitOption($prefix, $field_prefix.'Count', $image_count);
	$this->Application->setUnitOption($prefix, 'Fields', $fields);
	$this->Application->setUnitOption($prefix, 'VirtualFields', $virtual_fields);
	}

	/**
	* Adds ability to create more virtual fields associated with main image/file
	*
	* @param string $prefix
	* @param string $field_name
	* @param Array $virtual_fields
	* @param bool $is_image
	* @return void
	* @access protected
	*/
	protected function _createCustomFields($prefix, $field_name, &$virtual_fields, $is_image = false)
	{
	$virtual_fields['Delete' . $field_name] = Array ('type' => 'int', 'default' => 0);

	if ( $is_image ) {
	$virtual_fields[$field_name . 'Alt'] = Array ('type' => 'string', 'default' => '');
	}
	}

	/**
	* Downloads file to user
	*
	* @param string $filename
	* @return void
	* @access public
	*/
	public function DownloadFile($filename)
	{
	- header('Content-type: ' . kUtil::mimeContentType($filename));
	+ $this->Application->setContentType(kUtil::mimeContentType($filename), false);
	header('Content-Disposition: attachment; filename="' . basename($filename) . '"');
	header('Content-Length: ' . filesize($filename));
	readfile($filename);
	flush();
	}

	/**
	* Creates folder with given $path
	*
	* @param string $path
	* @return bool
	* @access public
	*/
	public function CheckFolder($path)
	{
	$result = true;

	if (!file_exists($path) \|\| !is_dir($path)) {
	$parent_path = preg_replace('#(/\|\\\)[^/\\\]+(/\|\\\)?$#', '', $path);
	$result = $this->CheckFolder($parent_path);

	if ($result) {
	$result = mkdir($path);

	if ($result) {
	chmod($path, 0777);

	// don't commit any files from created folder
	if (file_exists(FULL_PATH . '/CVS')) {
	$cvsignore = fopen($path . '/.cvsignore', 'w');
	fwrite($cvsignore, '.');
	fclose($cvsignore);
	chmod($path . '/.cvsignore', 0777);
	}
	}
	else {
	trigger_error('Cannot create directory "<strong>' . $path . '</strong>"', E_USER_WARNING);
	return false;
	}
	}
	}

	return $result;
	}

	/**
	* Copies all files and directories from $source to $destination directory. Create destination directory, when missing.
	*
	* @param string $source
	* @param string $destination
	* @return bool
	* @access public
	*/
	public function copyFolderRecursive($source, $destination)
	{
	if ( substr($source, -1) == DIRECTORY_SEPARATOR ) {
	$source = substr($source, 0, -1);
	$destination .= DIRECTORY_SEPARATOR . basename($source);
	}

	$iterator = new DirectoryIterator($source);
	/* @var $file_info DirectoryIterator */

	$result = $this->CheckFolder($destination);

	foreach ($iterator as $file_info) {
	if ( $file_info->isDot() ) {
	continue;
	}

	$file = $file_info->getFilename();

	if ( $file_info->isDir() ) {
	$result = $this->copyFolderRecursive($file_info->getPathname(), $destination . DIRECTORY_SEPARATOR . $file);
	}
	else {
	$result = copy($file_info->getPathname(), $destination . DIRECTORY_SEPARATOR . $file);
	}

	if (!$result) {
	trigger_error('Cannot create file/directory "<strong>' . $destination . DIRECTORY_SEPARATOR . $file . '</strong>"', E_USER_WARNING);
	break;
	}
	}

	return $result;
	}

	/**
	* Copies all files from $source to $destination directory. Create destination directory, when missing.
	*
	* @param string $source
	* @param string $destination
	* @return bool
	* @access public
	*/
	public function copyFolder($source, $destination)
	{
	if ( substr($source, -1) == DIRECTORY_SEPARATOR ) {
	$source = substr($source, 0, -1);
	$destination .= DIRECTORY_SEPARATOR . basename($source);
	}

	$iterator = new DirectoryIterator($source);
	/* @var $file_info DirectoryIterator */

	$result = $this->CheckFolder($destination);

	foreach ($iterator as $file_info) {
	if ( $file_info->isDot() \|\| !$file_info->isFile() ) {
	continue;
	}

	$file = $file_info->getFilename();

	$result = copy($file_info->getPathname(), $destination . DIRECTORY_SEPARATOR . $file);

	if ( !$result ) {
	trigger_error('Cannot create file "<strong>' . $destination . DIRECTORY_SEPARATOR . $file . '</strong>"', E_USER_WARNING);
	break;
	}
	}

	return $result;
	}

	/**
	* Transforms given path to file into it's url, where each each component is encoded (excluding domain and protocol)
	*
	* @param string $url
	* @return string
	* @access public
	*/
	public function pathToUrl($url)
	{
	$url = str_replace(DIRECTORY_SEPARATOR, '/', preg_replace('/^' . preg_quote(FULL_PATH, '/') . '(.*)/', '\\1', $url, 1));
	$url = implode('/', array_map('rawurlencode', explode('/', $url)));

	return rtrim($this->Application->BaseURL(), '/') . $url;
	}

	/**
	* Transforms given url to path to it
	*
	* @param string $url
	* @return string
	* @access public
	*/
	public function urlToPath($url)
	{
	$base_url = rtrim($this->Application->BaseURL(), '/');

	// escape replacement patterns, like "\<number>"
	$full_path = preg_replace('/(\\\[\d]+)/', '\\\\\1', FULL_PATH);
	$path = preg_replace('/^' . preg_quote($base_url, '/') . '(.*)/', $full_path . '\\1', $url, 1);

	return str_replace('/', DIRECTORY_SEPARATOR, rawurldecode($path));
	}

	/**
	* Ensures, that new file will not overwrite any of previously created files with same name
	*
	* @param string $path
	* @param string $name
	* @param Array $forbidden_names
	* @return string
	*/
	public function ensureUniqueFilename($path, $name, $forbidden_names = Array())
	{
	$parts = pathinfo($name);
	$ext = '.' . $parts['extension'];
	$filename = $parts['filename'];
	$path = rtrim($path, '/');

	$original_checked = false;
	$new_name = $filename . $ext;

	if ( $parts['dirname'] != '.' ) {
	$path .= '/' . ltrim($parts['dirname'], '/');
	}

	// make sure target folder always exists, especially for cases,
	// when storage engine folder is supplied as a part of $name
	$this->CheckFolder($path);

	do {
	if ( preg_match('/(.)_([0-9])(' . preg_quote($ext, '/') . ')/', $new_name, $regs) ) {
	$new_name = $regs[1] . '_' . ((int)$regs[2] + 1) . $regs[3];
	}
	elseif ( $original_checked ) {
	$new_name = $filename . '_1' . $ext;
	}

	$original_checked = true;
	$res = file_exists($path . '/' . $new_name) \|\| in_array($path . '/' . $new_name, $forbidden_names);
	} while ($res !== false);

	if ( $parts['dirname'] != '.' ) {
	$new_name = $parts['dirname'] . '/' . $new_name;
	}

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

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

	kUtil::safeDefine('EXPORT_STEP', 100); // export by 100 items
	kUtil::safeDefine('IMPORT_STEP', 10);

	class kCSVHelper extends kHelper {

	var $PrefixSpecial;
	var $grid;

	var $delimiter_mapping = Array(0 => "\t", 1 => ',', 2 => ';', 3 => ' ', 4 => ':');
	var $enclosure_mapping = Array(0 => '"', 1 => "'");
	var $separator_mapping = Array(0 => "\n", 1 => "\r\n");

	function ExportStep()
	{
	$export_data = $this->Application->RecallVar('export_data');
	$export_rand = $this->Application->RecallVar('export_rand');
	$get_rand = $this->Application->GetVar('export_rand');

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

	if ( $export_data && $export_rand == $get_rand ) {
	$export_data = unserialize($export_data);
	$first_step = false;
	}
	else {
	// first step
	$export_data = Array ();
	$export_data['prefix'] = $this->PrefixSpecial;
	$export_data['grid'] = $this->grid;
	$export_data['file_name'] = EXPORT_PATH . '/' . $file_helper->ensureUniqueFilename(EXPORT_PATH, 'export_' . $export_data['prefix'] . '.csv');
	$export_data['step'] = EXPORT_STEP;
	$export_data['delimiter'] = $this->delimiter_mapping[(int)$this->Application->ConfigValue('CSVExportDelimiter')];
	$export_data['enclosure'] = $this->enclosure_mapping[(int)$this->Application->ConfigValue('CSVExportEnclosure')];
	$export_data['record_separator'] = $this->separator_mapping[(int)$this->Application->ConfigValue('CSVExportSeparator')];
	$export_data['page'] = 1;

	$lang_object = $this->Application->recallObject('lang.current');
	/* @var $lang_object LanguagesItem */

	$export_data['source_encoding'] = strtoupper($lang_object->GetDBField('Charset'));
	$export_data['encoding'] = $this->Application->ConfigValue('CSVExportEncoding') ? false : 'UTF-16LE';

	$this->Application->StoreVar('export_rand', $get_rand);

	$first_step = true;
	}

	$file = fopen($export_data['file_name'], $first_step ? 'w' : 'a');

	$prefix_elems = preg_split('/\.\|_/', $export_data['prefix'], 2);
	$grids = $this->Application->getUnitOption($prefix_elems[0], 'Grids');
	$grid_config = $grids[$export_data['grid']]['Fields'];

	$list_params = Array ('per_page' => $export_data['step'], 'grid' => $export_data['grid']);
	$list = $this->Application->recallObject(rtrim(implode('.', $prefix_elems), '.'), $prefix_elems[0] . '_List', $list_params);
	/* @var $list kDBList */

	$list->SetPage($export_data['page']);
	$list->Query();
	$list->GoFirst();

	$picker_helper = $this->Application->recallObject('ColumnPickerHelper');
	/* @var $picker_helper kColumnPickerHelper */

	$picker_helper->ApplyPicker(rtrim(implode('.', $prefix_elems), '.'), $grid_config, $export_data['grid']);

	if ( $first_step ) {
	// if UTF-16, write Unicode marker
	if ( $export_data['encoding'] == 'UTF-16LE' ) {
	fwrite($file, chr(0xFF) . chr(0xFE));
	}

	// inserting header line
	$headers = Array ();
	foreach ($grid_config as $field_name => $field_data) {
	$use_phrases = array_key_exists('use_phrases', $field_data) ? $field_data['use_phrases'] : true;
	$field_title = isset($field_data['title']) ? $field_data['title'] : 'column:la_fld_' . $field_name;
	$header = $use_phrases ? $this->Application->Phrase($field_title) : $field_title;
	array_push($headers, $header);
	}

	$csv_line = kUtil::getcsvline($headers, $export_data['delimiter'], $export_data['enclosure'], $export_data['record_separator']);
	if ( $export_data['encoding'] ) {
	$csv_line = mb_convert_encoding($csv_line, $export_data['encoding'], $export_data['source_encoding']);
	}
	fwrite($file, $csv_line);
	}

	while (!$list->EOL()) {
	$data = Array ();
	foreach ($grid_config as $field_name => $field_data) {
	if ( isset($field_data['export_field']) ) {
	$field_name = $field_data['export_field'];
	}
	$value = $list->GetField($field_name, isset($field_data['format']) ? $field_data['format'] : null);
	$value = str_replace("\r\n", "\n", $value);
	$value = str_replace("\r", "\n", $value);
	array_push($data, $value);
	}

	if ( $export_data['encoding'] == 'UTF-16LE' ) {
	fwrite($file, chr(0xFF) . chr(0xFE));
	}

	$csv_line = kUtil::getcsvline($data, $export_data['delimiter'], $export_data['enclosure'], $export_data['record_separator']);
	if ( $export_data['encoding'] ) {
	$csv_line = mb_convert_encoding($csv_line, $export_data['encoding'], $export_data['source_encoding']);
	}
	fwrite($file, $csv_line);

	$list->GoNext();
	}

	$records_processed = $export_data['page'] * $export_data['step'];
	$percent_complete = min($records_processed / $list->GetRecordsCount() * 100, 100);

	fclose($file);

	if ( $records_processed >= $list->GetRecordsCount() ) {
	$this->Application->StoreVar('export_data', serialize($export_data));
	$this->Application->Redirect($this->Application->GetVar('finish_template'));
	}

	echo $percent_complete;

	$export_data['page']++;
	$this->Application->StoreVar('export_data', serialize($export_data));
	}

	function ExportData($name)
	{
	$export_data = unserialize($this->Application->RecallVar('export_data'));
	return isset($export_data[$name]) ? $export_data[$name] : false;
	}

	/**
	* Returns prefix from request or from stored import/export data
	*
	* @param bool $is_import
	* @return string
	*/
	public function getPrefix($is_import = false)
	{
	$prefix = $this->Application->GetVar('PrefixSpecial');

	if ( !$prefix ) {
	return $is_import ? $this->ImportData('prefix') : $this->ExportData('prefix');
	}

	return $prefix;
	}

	function GetCSV()
	{
	kUtil::safeDefine('DBG_SKIP_REPORTING', 1);

	$export_data = unserialize($this->Application->RecallVar('export_data'));
	$filename = preg_replace('/(.*)\.csv$/', '\1', basename($export_data['file_name'])) . '.csv';

	- header('Content-type: text/csv');
	+ $this->Application->setContentType('text/csv');
	header('Content-Disposition: attachment; filename="' . $filename . '"');
	readfile($export_data['file_name']);
	die();
	}

	function ImportStart($filename)
	{
	if(!file_exists($filename) \|\| !is_file($filename)) return 'cant_open_file';

	$import_data = Array();

	$lang_object = $this->Application->recallObject('lang.current');
	/* @var $lang_object LanguagesItem */
	$import_data['source_encoding'] = strtoupper( $lang_object->GetDBField('Charset') );
	$import_data['encoding'] = $this->Application->ConfigValue('CSVExportEncoding') ? false : 'UTF-16LE';
	$import_data['errors'] = '';

	// convert file in case of UTF-16LE
	if($import_data['source_encoding'] != $import_data['encoding']) {
	copy($filename, $filename.'.orginal');
	$file_content = file_get_contents($filename);
	$file = fopen($filename, 'w');
	fwrite($file, mb_convert_encoding(str_replace(chr(0xFF).chr(0xFE), '', $file_content), $import_data['source_encoding'], $import_data['encoding']));
	fclose($file);

	}

	$import_data['prefix'] = $this->PrefixSpecial;
	$import_data['grid'] = $this->grid;
	$import_data['file'] = $filename;
	$import_data['total_lines'] = count(file($filename));
	if(!$import_data['total_lines']) $import_data['total_lines'] = 1;
	unset($file_content);
	$import_data['lines_processed'] = 0;
	$import_data['delimiter'] = $this->delimiter_mapping[(int)$this->Application->ConfigValue('CSVExportDelimiter')];
	$import_data['enclosure'] = $this->enclosure_mapping[(int)$this->Application->ConfigValue('CSVExportEnclosure')];
	$import_data['step'] = IMPORT_STEP;
	$import_data['not_imported_lines'] = '';
	$import_data['added'] = 0;
	$import_data['updated'] = 0;

	$file = fopen($filename, 'r');
	// getting first line for headers
	$headers = fgetcsv($file, 8192, $import_data['delimiter'], $import_data['enclosure']);
	fclose($file);

	$prefix_elems = preg_split('/\.\|_/', $import_data['prefix'], 2);
	$grids = $this->Application->getUnitOption($prefix_elems[0], 'Grids');
	$grid_config = $grids[ $import_data['grid'] ]['Fields'];

	$field_list = Array();
	foreach($grid_config as $field_name => $field_data) {
	if(isset($field_data['export_field'])) {
	$field_name = $field_data['export_field'];
	}
	$field_title = isset($field_data['title']) ? $field_data['title'] : 'column:la_fld_' . $field_name;
	$field_label = $this->Application->Phrase($field_title);
	$field_pos = array_search($field_label, $headers);
	if($field_pos !== false) {
	$field_list[$field_pos] = $field_name;
	}
	}

	if(!count($field_list)) return 'no_matching_columns';
	$import_data['field_list'] = $field_list;

	// getting key list
	$field_positions = Array();
	$config_key_list = $this->Application->getUnitOption($prefix_elems[0], 'ImportKeys');
	if(!$config_key_list) $config_key_list = Array();
	array_unshift($config_key_list, Array($this->Application->getUnitOption($prefix_elems[0], 'IDField')));

	$key_list = Array();
	foreach($config_key_list as $arr_key => $import_key) {
	$key_list[$arr_key] = is_array($import_key) ? $import_key : Array($import_key);

	foreach($key_list[$arr_key] as $key_field) {
	$field_positions[$key_field] = array_search($key_field, $import_data['field_list']);
	if($field_positions[$key_field] === false) {
	// no such key field combination in imported file
	unset($key_list[$arr_key]);
	break;
	}
	}
	}
	$import_data['key_list'] = $key_list;
	$import_data['field_positions'] = $field_positions;

	$this->Application->StoreVar('import_data', serialize($import_data));
	return true;
	}

	function ImportStep()
	{
	$import_data = unserialize($this->Application->RecallVar('import_data'));
	$prefix_elems = preg_split('/\.\|_/', $import_data['prefix'], 2);

	$object = $this->Application->recallObject($prefix_elems[0].'.-csvimport', $prefix_elems[0], Array('skip_autoload' => true, 'populate_ml_fields' => true));
	/* @var $object kDBItem */

	$file = fopen($import_data['file'], 'r');
	$eof = false;
	// skipping lines that has been already imported
	for($i = 0; $i < $import_data['lines_processed'] + 1; $i++) {
	if(feof($file)) break;
	fgets($file, 8192);
	}

	$import_event = new kEvent($prefix_elems[0].'.-csvimport:OnBeforeCSVLineImport');

	for($i = 0; $i < $import_data['step']; $i++) {
	if(feof($file)) break;
	$data = fgetcsv($file, 8192, $import_data['delimiter'], $import_data['enclosure']);
	if(!$data) continue;

	$object->Clear();
	$action = 'Create';

	// 1. trying to load object by keys
	foreach($import_data['key_list'] as $key) {
	$fail = false;
	$key_array = Array();
	foreach($key as $key_field) {
	if(!isset($data[ $import_data['field_positions'][$key_field] ])) {
	$fail = true;
	break;
	}
	$key_array[$key_field] = $data[ $import_data['field_positions'][$key_field] ];
	}
	if($fail) continue;
	if($object->Load($key_array)) {
	$action = 'Update';
	break;
	}
	}

	// 2. set object fields
	foreach($import_data['field_list'] as $position => $field_name) {
	if(isset($data[$position])) {
	$object->SetField($field_name, $data[$position]);
	}
	}

	// 3. validate item and run event
	$status = $object->Validate();
	$import_event->status = $status ? kEvent::erSUCCESS : kEvent::erFAIL;
	$this->Application->HandleEvent($import_event);

	if($import_event->status == kEvent::erSUCCESS && $object->$action()) {
	$import_data[ ($action == 'Create') ? 'added' : 'updated' ]++;
	}
	else {
	$msg = '';
	$errors = $object->GetFieldErrors();

	foreach ($errors as $field => $info) {
	if (!$info['pseudo']) continue;
	$msg .= "$field: {$info['pseudo']} ";
	}

	$import_data['errors'] .= ($i + $import_data['lines_processed'] + 1).": $msg\n";
	$import_data['not_imported_lines'] .= ','.($i + $import_data['lines_processed'] + 1);
	}
	}

	$import_data['lines_processed'] += $import_data['step'];

	$import_data['not_imported_lines'] = ltrim($import_data['not_imported_lines'], ',');
	$this->Application->StoreVar('import_data', serialize($import_data));

	$feof = feof($file);
	fclose($file);

	if($feof) {
	$this->Application->Redirect($this->Application->GetVar('finish_template'));
	}
	else {
	$percent_complete = floor($import_data['lines_processed'] / $import_data['total_lines'] * 100);
	if($percent_complete > 99) $percent_complete = 99;
	echo $percent_complete;
	}
	}

	function ImportData($name)
	{
	$import_data = unserialize($this->Application->RecallVar('import_data'));
	return isset($import_data[$name]) ? $import_data[$name] : false;
	}

	function GetNotImportedLines()
	{
	$import_data = unserialize($this->Application->RecallVar('import_data'));

	if(!$import_data['not_imported_lines']) return false;
	$line_numbers = explode(',', $import_data['not_imported_lines']);
	$line_numbers[] = 0; // include header row in output

	$file = fopen($import_data['file'], 'r');
	$eof = false;
	$result = '';
	for($i = 0; $i <= max($line_numbers); $i++) {
	if(feof($file)) break;
	$line = fgets($file, 8192);
	if(in_array($i, $line_numbers)) {
	$result .= $i.':'.$line;
	}
	}
	return $result."\n\n".$import_data['errors'];
	}
	}
	\ No newline at end of file
	Index: branches/5.2.x/core/units/fck/fck_eh.php
	===================================================================
	--- branches/5.2.x/core/units/fck/fck_eh.php (revision 15172)
	+++ branches/5.2.x/core/units/fck/fck_eh.php (revision 15173)
	@@ -1,253 +1,254 @@
	<?php
	/**
	* @version $Id$
	* @package In-Portal
	* @copyright Copyright (C) 1997 - 2009 Intechnic. All rights reserved.
	* @license GNU/GPL
	* In-Portal is Open Source software.
	* This means that this software may have been modified pursuant
	* the GNU General Public License, and as distributed it includes
	* or is derivative of works licensed under the GNU General Public License
	* or other free or open source software licenses.
	* See http://www.in-portal.org/license for copyright notices and details.
	*/

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

	class FckEventHandler extends kDBEventHandler {

	/**
	* Allows to override standard permission mapping
	*
	* @return void
	* @access protected
	* @see kEventHandler::$permMapping
	*/
	protected function mapPermissions()
	{
	parent::mapPermissions();

	$permissions = Array (
	'OnGetsEditorStyles' => Array ('self' => true),
	);

	$this->permMapping = array_merge($this->permMapping, $permissions);
	}

	/**
	* Checks user permission to execute given $event
	*
	* @param kEvent $event
	* @return bool
	* @access public
	*/
	public function CheckPermission(kEvent $event)
	{
	if ( $this->Application->isAdminUser \|\| $event->Name == 'OnGetsEditorStyles' ) {
	// this limits all event execution only to logged-in users in admin
	return true;
	}

	return parent::CheckPermission($event);
	}

	function CreateXmlHeader()
	{
	ob_end_clean() ;
	// Prevent the browser from caching the result.
	// Date in the past
	header('Expires: Mon, 26 Jul 1997 05:00:00 GMT') ;
	// always modified
	header('Last-Modified: ' . gmdate('D, d M Y H:i:s') . ' GMT') ;
	// HTTP/1.1
	header('Cache-Control: no-store, no-cache, must-revalidate') ;
	header('Cache-Control: post-check=0, pre-check=0', false) ;
	// HTTP/1.0
	header('Pragma: no-cache') ;
	// Set the response format.
	- header( 'Content-Type: text/xml; charset=utf-8' ) ;
	+
	+ $this->Application->setContentType('text/xml');
	// Create the XML document header.
	}

	function OnLoadCmsTree($event)
	{
	$event->status = kEvent::erSTOP;

	$category_helper = $this->Application->recallObject('CategoryHelper');
	/* @var $category_helper CategoryHelper */

	$pages = $category_helper->getStructureTreeAsOptions();

	$sql = 'SELECT NamedParentPath, CategoryId
	FROM ' . TABLE_PREFIX . 'Categories
	WHERE CategoryId IN (' . implode(',', array_keys($pages)) . ')';
	$templates = $this->Conn->GetCol($sql, 'CategoryId');

	$templates[$this->Application->getBaseCategory()] .= '/Index'; // "Content" category will act as "Home Page"

	$res = '<?xml version="1.0" encoding="utf-8" ?>' . "\n";
	$res .= '<CmsPages>' . "\n";

	foreach ($pages as $id => $title) {
	$template = $templates[$id];
	$page_path = preg_replace('/^Content\//i', '', strtolower($template).'.html');

	$title = $title . ' (' . $page_path . ')';
	$real_url = $this->Application->HREF($template, '_FRONT_END_', array('pass' => 'm'), 'index.php');

	$res .= '<CmsPage real_url="' . $real_url . '" path="@@' . $id . '@@" title="' . htmlspecialchars($title, ENT_QUOTES) . '" st_id="' . $id . '" serverpath="" />' . "\n";
	}

	$res.= "</CmsPages>";

	$this->CreateXmlHeader();
	echo $res;
	}

	function OnRenameFile($event)
	{
	$event->status = kEvent::erSTOP;

	if ($this->Application->CheckPermission('SYSTEM_ACCESS.READONLY', 1)) {
	return;
	}

	$old_name = $this->Application->GetVar('old_name');
	$new_name = $this->Application->GetVar('new_name');
	$folder = $this->Application->GetVar('folder');
	$sServerDir = WRITEABLE . '/user_files/' . $folder . '/';

	if (!file_exists($sServerDir.$old_name) \|\| !is_file($sServerDir.$old_name)) {
	echo 204;
	return;
	}

	$fck_helper = $this->Application->recallObject('FCKHelper');
	/* @var $fck_helper fckFCKHelper*/

	if ( !$fck_helper->IsAllowedExtension($folder, $new_name) ) {
	echo 203;
	return;
	}

	if ( !rename($sServerDir . $old_name, $sServerDir . $new_name) ) {
	// echo $sServerDir.$old_name.' -> '.$sServerDir.$new_name;
	echo 205;
	return;
	}

	echo '0';
	}


	function OnDeleteFiles($event)
	{
	$event->status = kEvent::erSTOP;

	if ($this->Application->CheckPermission('SYSTEM_ACCESS.READONLY', 1)) {
	return;
	}

	$files = trim($this->Application->GetVar('files'),'\|');
	// echo $files;
	$a_files = explode('\|', $files);
	$folder = $this->Application->GetVar('folder');
	$sServerDir = WRITEABLE . '/user_files/' . $folder . '/';

	foreach ($a_files AS $file) {
	@unlink($sServerDir.$file);
	}

	// print_r($a_files);
	}

	function OnGetFoldersFilesList($event)
	{
	$this->CreateXmlHeader();

	$fck_helper = $this->Application->recallObject('FCKHelper');
	/* @var $fck_helper fckFCKHelper */

	$ret = '<?xml version="1.0" encoding="utf-8" ?>'."\n" ;
	$ret .= "<content>"."\n";
	$ret .= $fck_helper->PrintFolders();
	$ret .= $fck_helper->PrintFiles();
	$ret .= "</content>"."\n";
	echo $ret;
	exit;
	}


	function OnCreateFolder($event)
	{
	$event->status = kEvent::erSTOP;

	if ($this->Application->CheckPermission('SYSTEM_ACCESS.READONLY', 1)) {
	return;
	}

	$new_folder = $this->Application->GetVar('new_folder');
	$current_folder = $this->Application->GetVar('current_folder');
	$folderPath = WRITEABLE . '/user_files' . '/' . $current_folder . "/" . $new_folder;
	if ( file_exists( $folderPath ) && is_dir($folderPath)) {
	echo "101";
	}

	if ( !file_exists( $folderPath ) )
	{
	// Turn off all error reporting.
	error_reporting( 0 ) ;
	// Enable error tracking to catch the error.
	ini_set( 'track_errors', '1' ) ;
	// To create the folder with 0777 permissions, we need to set umask to zero.
	$oldumask = umask(0) ;
	mkdir( $folderPath, 0777 ) ;
	umask( $oldumask ) ;
	$sErrorMsg = $php_errormsg ;
	// Restore the configurations.
	ini_restore( 'track_errors' ) ;
	ini_restore( 'error_reporting' ) ;
	if ($sErrorMsg)
	echo $sErrorMsg ;
	else
	echo '0';
	}
	}

	/**
	* Uploads a file from FCK file browser
	*
	* @param kEvent $event
	* @return void
	* @access protected
	*/
	protected function OnUploadFile(kEvent $event)
	{
	$event->status = kEvent::erSTOP;

	if ( $this->Application->CheckPermission('SYSTEM_ACCESS.READONLY', 1) ) {
	return;
	}

	$fck_helper = $this->Application->recallObject('FCKHelper');
	/* @var $fck_helper fckFCKHelper*/

	$fck_helper->UploadFile();
	}

	/**
	* Returns compressed CSS file
	*
	* @param kEvent $event
	*/
	function OnGetsEditorStyles($event)
	{
	$minify_helper = $this->Application->recallObject('MinifyHelper');
	/* @var $minify_helper MinifyHelper */

	$this->Application->InitParser();
	$styles_css = $minify_helper->CompressScriptTag( Array ('files' => 'inc/style.css') );

	$event->redirect = 'external:' . $styles_css;
	}
	}
	\ No newline at end of file
	Index: branches/5.2.x/core/admin_templates/tree.tpl
	===================================================================
	--- branches/5.2.x/core/admin_templates/tree.tpl (revision 15172)
	+++ branches/5.2.x/core/admin_templates/tree.tpl (revision 15173)
	@@ -1,195 +1,195 @@
	<inp2:m_Set skip_last_template="1"/>
	<inp2:m_include t="incs/header" nobody="yes" noform="yes"/>
	<inp2:m_NoDebug/>

	<body class="tree-body" onresize="onTreeFrameResize();">

	<script type="text/javascript">
	var $save_timer = null,
	$last_width = parseInt('<inp2:m_GetConfig name="MenuFrameWidth"/>');

	function credits(url) {
	openwin(url, 'credits', 280, 520);
	}

	function onTreeFrameResize() {
	var $frameset = $('#sub_frameset', window.parent.document);
	if (!$frameset.length) {
	return ;
	}

	var $width = $frameset.attr('cols').split(',')[0];
	if (($width <= 0) \|\| ($width == $last_width)) {
	// don't save zero width
	return ;
	}

	clearTimeout($save_timer);
	$save_timer = setTimeout( function() {saveFrameWidth($width);}, 2000);
	}

	function saveFrameWidth($width) {
	getFrame('head').$FrameResizer.OpenWidth = $width;

	$.get(
	'<inp2:m_Link template="index" adm_event="OnSaveMenuFrameWidth" pass="m,adm" js_escape="1" no_amp="1"/>',
	{width: $width}
	);

	$last_width = $width;
	}
	</script>

	-<script src="js/tree.js"></script>
	+<script type="text/javascript" src="<inp2:m_Compress files='js/tree.js'/>"></script>

	<table style="height: 100%; width: 100%; border-right: 1px solid #777; border-bottom: 1px solid #777;">
	<tr>
	<td colspan="2" style="vertical-align: top; padding: 5px;">
	<inp2:m_DefineElement name="xml_node" icon_module="">
	<inp2:m_if check="m_ParamEquals" param="children_count" value="0">
	<item href="<inp2:m_param name="section_url" js_escape="1"/>" priority="<inp2:m_param name="priority"/>" onclick="<inp2:m_param name="onclick" js_escape="1"/>" icon="<inp2:$SectionPrefix_ModulePath module="$icon_module"/>img/icons/icon24_<inp2:m_param name="icon"/>.png"<inp2:m_if check="m_Param" name="debug_only"> debug_only="1"</inp2:m_if>><inp2:m_phrase name="$label" escape="1"/></item>
	<inp2:m_else/>
	<folder href="<inp2:m_param name="section_url" js_escape="1"/>" priority="<inp2:m_param name="priority"/>" container="<inp2:m_param name="container"/>" onclick="<inp2:m_param name="onclick" js_escape="1"/>" name="<inp2:m_phrase name="$label" escape="1"/>" icon="<inp2:$SectionPrefix_ModulePath module="$icon_module"/>img/icons/icon24_<inp2:m_param name="icon"/>.png" load_url="<inp2:m_param name="late_load" js_escape="1"/>"<inp2:m_if check="m_Param" name="debug_only"> debug_only="1"</inp2:m_if>><inp2:adm_PrintSections render_as="xml_node" section_name="$section_name"/></folder>
	</inp2:m_if>
	</inp2:m_DefineElement>

	<table class="tree">
	<tbody id="tree">
	</tbody>
	</table>
	<script type="text/javascript">
	var TREE_ICONS_PATH = 'img/tree';
	var TREE_SHOW_PRIORITY = <inp2:m_if check="adm_ConstOn" name="DBG_SHOW_TREE_PRIORITY" debug_mode="1">1<inp2:m_else/>0</inp2:m_if>;
	var TREE_LOADING_NODE = {
	text: '<inp2:m_Phrase name="la_title_Loading" no_editing="1"/>',
	icon: '<inp2:adm_ModulePath module="core"/>img/icons/icon24_loading.gif'
	};

	<inp2:m_DefineElement name="root_node">
	var the_tree = new TreeFolder('tree', '<inp2:m_param name="label"/>', '<inp2:m_param name="section_url"/>', '<inp2:$SectionPrefix_ModulePath module="$icon_module"/>img/icons/icon24_<inp2:m_param name="icon"/>.png', null, null, '<inp2:m_param name="priority"/>', '<inp2:m_param name="container"/>');
	</inp2:m_DefineElement>
	<inp2:adm_PrintSection render_as="root_node" section_name="in-portal:root"/>

	the_tree.AddFromXML('<tree><inp2:adm_PrintSections render_as="xml_node" section_name="in-portal:root"/></tree>');

	<inp2:m_if check="adm_MainFrameLink">
	var fld = the_tree.locateItemByURL('<inp2:adm_MainFrameLink m_opener="r" no_amp="1"/>');
	if (fld) {
	fld.highLight();
	}
	else {
	the_tree.highLight();
	}
	<inp2:m_else/>
	the_tree.highLight();
	</inp2:m_if>
	</script>
	</td>
	</tr>
	</table>

	<script type="text/javascript">
	function checkCatalog($cat_id) {
	var $ret = checkEditMode(false);
	var $right_frame = getFrame('main');

	if ($ret && $right_frame.$is_catalog) {
	$right_frame.$Catalog.go_to_cat($cat_id);
	return 1; // this opens folder, but disables click
	}

	return $ret;
	}

	function setCatalogTab($prefix) {
	var $ret = checkEditMode(false);

	if ($ret) {
	var $right_frame = getFrame('main');
	var $catalog_type = (typeof $right_frame.$Catalog != 'undefined') ? $right_frame.$Catalog.type : '';

	// highlight "Structure & Data" node, when one of it's shortcut nodes are clicked
	<inp2:m_DefineElement name="section_url_element"><inp2:m_param name="section_url"/></inp2:m_DefineElement>
	var $structure_node = the_tree.locateItemByURL('<inp2:adm_PrintSection render_as="section_url_element" section_name="in-portal:browse"/>');

	if ($catalog_type == 'AdvancedView') {
	$right_frame.$Catalog.switchTab($prefix);
	return $structure_node; // this opens folder, but disables click
	}

	// this disabled click and causes other node to be highlighted
	return $structure_node;
	}

	return $ret;
	}

	function checkEditMode($reset_toolbar)
	{
	if (!isset($reset_toolbar)) {
	$reset_toolbar = true;
	}

	if ($reset_toolbar) {
	getFrame('head').$('#extra_toolbar').html('');
	}

	var $phrase = "<inp2:adm_TreeEditWarrning label='la_EditingInProgress' escape='1'/>";
	if (getFrame('main').$edit_mode) {
	return confirm($phrase) ? true : false;
	}

	return true;
	}

	function ReloadFolder(url, with_late_load)
	{
	if (!with_late_load) with_late_load = false;

	var fld = the_tree.locateItemByURL(url.replace(/&/g, '&'), with_late_load);
	if (fld) {
	fld.reload();
	}
	}

	function ShowStructure($url, $visible)
	{
	var fld = the_tree.locateItemByURL($url, true);
	if (fld) {
	if ($visible) {
	fld.expand();
	}
	else {
	fld.collapse();
	}

	}
	}

	function SyncActive(url) {
	var fld = the_tree.locateItemByURL(url);
	if (fld) {
	fld.highLight();
	}
	}

	<inp2:m_DefineElement name="container_node">
	var $container_node = the_tree.locateItemByURL('<inp2:m_param name="section_url" js_escape="1"/>');
	$container_node.Container = true;
	</inp2:m_DefineElement>

	<inp2:m_DefineElement name="container_node_fix">
	<inp2:m_if check="m_GetConfig" name="$config_var">
	<inp2:m_ifnot check="m_IsDebugMode">
	<inp2:adm_PrintSection render_as="container_node" section_name="$section"/>
	</inp2:m_ifnot>
	</inp2:m_if>
	</inp2:m_DefineElement>

	<inp2:m_RenderElement name="container_node_fix" config_var="DebugOnlyFormConfigurator" section="in-portal:forms"/>
	<inp2:m_RenderElement name="container_node_fix" config_var="DebugOnlyPromoBlockGroupConfigurator" section="in-portal:promo_block_groups"/>
	</script>

	<!--## when form is on top, then 100% height is broken ##-->
	<inp2:m_RenderElement name="kernel_form"/>
	<inp2:m_include t="incs/footer"/>
	\ No newline at end of file

in-portalNo OneTemporaryActions

File Metadata

in-portalView Options

Event Timeline

in-portal
No OneTemporary
Actions

in-portal
View Options