in-portal
No OneTemporary
Actions

Subscribers

None

File Metadata

Created: Sun, Jul 20, 1:44 AM

in-portal
View Options

	Index: trunk/kernel/units/general/xml_helper.php
	===================================================================
	--- trunk/kernel/units/general/xml_helper.php (revision 4417)
	+++ trunk/kernel/units/general/xml_helper.php (revision 4418)
	@@ -1,136 +1,199 @@
	<?php

	class kXMLHelper extends kHelper {
	var $RootElement = null;

	/**
	* Enter description here...
	*
	* @var kXMLNode
	*/
	var $CurrentElement = null;

	+ /**
	+ * Parses XML data specified and returns root node
	+ *
	+ * @param string $xml
	+ * @return kXMLNode
	+ */
	function &Parse($xml = null)
	{
	$xml_parser = xml_parser_create();
	xml_set_element_handler( $xml_parser, Array(&$this, 'startElement'), Array(&$this, 'endElement') );
	xml_set_character_data_handler( $xml_parser, Array(&$this, 'characterData') );
	if (!xml_parse($xml_parser, $xml, 1)) {
	trigger_error(sprintf('XML error: %s at line %d'),
	xml_error_string(xml_get_error_code($xml_parser)),
	xml_get_current_line_number($xml_parser), E_USER_WARNING);
	}
	xml_parser_free($xml_parser);
	return $this->RootElement;
	}

	function startElement(&$Parser, &$Elem, $Attrs)
	{
	$parent =& $this->CurrentElement;
	$this->CurrentElement =& new kXMLNode($Elem, $Attrs);
	if (is_null($this->RootElement)) {
	$this->RootElement =& $this->CurrentElement;
	}
	if (!is_null($parent)) {
	$parent->AddChild($this->CurrentElement);
	}
	}

	function characterData($Parser, $Line)
	{
	$this->CurrentElement->AppendData($Line);
	}

	function endElement($Parser, $Elem)
	{
	if ($this->CurrentElement->Parent != null) {
	$this->CurrentElement =& $this->CurrentElement->Parent;
	}
	}

	function Clear()
	{
	$this->RootElement = null;
	$this->CurrentElement = null;
	}
	}

	class kXMLNode {
	var $Name = null;
	var $Attributes = array();
	var $Children = array();
	var $Data = null;
	+
	+ var $firstChild = null;
	+ var $lastChild = null;
	+ /**
	+ * Parent node
	+ *
	+ * @var kXMLNode
	+ */
	var $Parent = null;
	-
	+ /**
	+ * Node position relative to other nodes of it's parent
	+ *
	+ * @var int
	+ */
	+ var $Position = 0;
	+
	function kXMLNode($name, $attrs = array())
	{
	$this->Name = $name;
	$this->Attributes = $attrs;
	}

	function SetParent(&$elem)
	{
	$this->Parent =& $elem;
	}

	+ /**
	+ * Adds new child to current node
	+ *
	+ * @param kXMLNode $a_child
	+ */
	function AddChild(&$a_child)
	{
	+ $node_count = count($this->Children);
	+ $a_child->Position = $node_count;
	+
	+ if ($node_count == 0) {
	+ $this->firstChild =& $a_child;
	+ $this->lastChild =& $a_child;
	+ }
	+ else {
	+ $this->lastChild =& $a_child;
	+ }
	+
	$this->Children[] =& $a_child;
	$a_child->SetParent($this);
	}

	function AppendData($data)
	{
	$this->Data .= $data;
	}

	function &GetChild($path)
	{
	$entries = explode('/', strtoupper($path));
	$cur = array_shift($entries);
	if ($cur == $this->Name) $cur = array_shift($entries);
	if (!$cur) return $this;
	if (!isset($this->Children[$cur])) return false;
	$left = implode('/', $entries);
	if (!$left) return $this->Children[$cur];
	return $this->Children[$cur]->GetChild($left);
	}

	function GetChildValue($path)
	{
	$child =& $this->GetChild($path);
	if ($child !== false) {
	return $child->Data;
	}
	}

	+ function &GetChildByPosition($position)
	+ {
	+ if ($position < count($this->Children) ) {
	+ return $this->Children[$position];
	+ }
	+ else {
	+ $false = false;
	+ return $false;
	+ }
	+ }
	+
	function &FindChild($name)
	{
	$name = strtoupper($name);
	if ($this->Name == $name) return $this;
	// if (isset($this->Children[$name])) return $this->Children[$name];
	// $children = array_keys($this->Children);
	foreach ($this->Children as $elem)
	{
	$child =& $elem->FindChild($name);
	if ($child !== false)
	{
	return $child;
	}
	}
	return false;
	}

	function FindChildValue($name, $attr=null)
	{
	$child =& $this->FindChild($name);
	if ($child !== false) {
	if (isset($attr)) {
	return $child->Attributes[strtoupper($attr)];
	}
	return $child->Data;
	}
	}
	+
	+ /**
	+ * Returns next node to this, false in case of end list
	+ *
	+ * @return kXMLNode
	+ */
	+ function &NextSibling()
	+ {
	+ if (!is_null($this->Parent)) {
	+ return $this->Parent->GetChildByPosition($this->Position + 1);
	+ }
	+ else {
	+ $false = false;
	+ return $false;
	+ }
	+ }
	}

	?>
	\ No newline at end of file

	Property changes on: trunk/kernel/units/general/xml_helper.php
	___________________________________________________________________
	Modified: cvs2svn:cvs-rev
	## -1 +1 ##
	-1.2
	\ No newline at end of property
	+1.3
	\ No newline at end of property
	Index: trunk/admin/category/category_items.php
	===================================================================
	--- trunk/admin/category/category_items.php (revision 4417)
	+++ trunk/admin/category/category_items.php (revision 4418)
	@@ -1,51 +1,53 @@
	<?php
	require_once (FULL_PATH.'/admin/include/elements.php');
	require_once (FULL_PATH.'/kernel/admin/include/navmenu.php');
	require_once(FULL_PATH.'/admin/toolbar.php');
	require_once(FULL_PATH.'/admin/listview/listview.php');

	$objEditItems = new clsCatList();
	$objEditItems->SourceTable = $objSession->GetEditTable("Category");

	$application->SetVar('c_mode', 't');

	// Multiedit init
	$en = (int)$_GET['en'];
	$objEditItems->Query_Item("SELECT * FROM ".$objEditItems->SourceTable);

	$itemcount=$objEditItems->NumItems();
	$c = $objEditItems->GetItemByIndex($en);

	if ($itemcount > 1) {
	$en_next = ($en + 1 == $itemcount) ? -1 : $en + 1;
	$en_prev = ($en == 0) ? -1 : $en - 1;
	}

	$TitleVerb = prompt_language('la_Text_Editing');

	$envar = 'env='.BuildEnv().'&en='.$en;
	$section = 'in-portal:editcategory_items';

	$editing_category_title = $c->Get('Name') ? "'".$c->Get('Name')."'" : '';
	$title = $TitleVerb.' '.prompt_language('la_Text_Category').' '.$editing_category_title.' - '.prompt_language('la_tab_General');

	//$saveURL = $admin."/browse.php";
	$saveURL = $admin.'/category/category_maint.php';
	$cancelURL = $admin.'/'.$objSession->GetVariable('ReturnScript');

	//Display header
	$sec = $objSections->GetSection($section);

	+ $additional_env = '&t=category/category_items&prefix=c';
	+
	$objCatToolBar = new clsToolBar();
	- $objCatToolBar->Add("img_save", "la_Save","#","swap('img_save','toolbar/tool_select_f2.gif');", "swap('img_save', 'toolbar/tool_select.gif');","edit_submit('category','CatEditStatus','$saveURL',1,'');","tool_select.gif");
	- $objCatToolBar->Add("img_cancel", "la_Cancel","#","swap('img_cancel','toolbar/tool_cancel_f2.gif');", "swap('img_cancel', 'toolbar/tool_cancel.gif');","edit_submit('category','CatEditStatus','$cancelURL',2,'');","tool_cancel.gif");
	+ $objCatToolBar->Add("img_save", "la_Save","#","swap('img_save','toolbar/tool_select_f2.gif');", "swap('img_save', 'toolbar/tool_select.gif');","edit_submit('category','CatEditStatus','$saveURL',1,'$additional_env');","tool_select.gif");
	+ $objCatToolBar->Add("img_cancel", "la_Cancel","#","swap('img_cancel','toolbar/tool_cancel_f2.gif');", "swap('img_cancel', 'toolbar/tool_cancel.gif');","edit_submit('category','CatEditStatus','$cancelURL',2,'$additional_env');","tool_cancel.gif");

	if (isset($en_prev) \|\| isset($en_next)) {
	$url = 'admin/index4_direct.php';
	$StatusField = 'CatEditStatus';
	$form = 'category';
	- MultiEditButtons($objCatToolBar,$en_next,$en_prev,$form,$StatusField,$url,$sec->Get("OnClick"),'&t=category/category_items&prefix=c','la_PrevCategory','la_NextCategory');
	+ MultiEditButtons($objCatToolBar,$en_next,$en_prev,$form,$StatusField,$url,$sec->Get("OnClick"), $additional_env,'la_PrevCategory','la_NextCategory');
	}

	int_header($objCatToolBar,NULL,$title);
	?>
	\ No newline at end of file

	Property changes on: trunk/admin/category/category_items.php
	___________________________________________________________________
	Modified: cvs2svn:cvs-rev
	## -1 +1 ##
	-1.2
	\ No newline at end of property
	+1.3
	\ No newline at end of property
	Index: trunk/core/kernel/utility/event.php
	===================================================================
	--- trunk/core/kernel/utility/event.php (revision 4417)
	+++ trunk/core/kernel/utility/event.php (revision 4418)
	@@ -1,294 +1,296 @@
	<?php
	/**
	* Event finished working succsessfully
	*
	*/
	define('erSUCCESS',0);

	/**
	* Event finished working, but result is unsuccsessfull
	*
	*/
	define('erFAIL',-1);
	/**
	* Event experienced FATAL error - no hooks should continue!
	*
	*/
	define('erFATAL',-2);

	class kEvent extends kBase {

	/**
	* Event reference, that
	* created this event
	*
	* @var kEvent
	* @access public
	*/
	var $MasterEvent;

	/**
	* Event name
	*
	* @var string
	* @access public
	*/
	var $Name;

	/**
	* Pseudo class name
	*
	* @var string
	* @access public
	*/
	//var $Prefix;

	/**
	* Special, that is recognized
	* by class with pseudo class
	* equals to $Prefix attrbute.
	*
	* @var string
	* @access public
	*/
	//var $Special;

	/**
	* Joined prefix and special,
	* usually taken directly from
	* tag beeing processes, to use
	* in recallObject method
	*
	* @var string
	*/
	var $Prefix_Special;

	/**
	* Do not execute Before hooks
	* while processing main event
	*
	* @var bool
	* @access public
	*/
	var $SkipBeforeHooks = false;

	/**
	* Do not execute After hooks
	* while processing main event
	*
	* @var bool
	* @access public
	*/
	var $SkipAfterHooks = false;

	/**
	* Redirect is allowed after
	* this event
	*
	* @var bool
	* @access public
	*/
	var $redirect = true;

	/**
	* Params passed to redirect on succsessfull event
	*
	* @var bool
	* @access public
	*/
	var $redirect_params = null;

	/**
	* php file to redirect to
	*
	* @var string
	* @access public
	*/
	var $redirect_script = null;

	/**
	* Event processing result
	*
	* @var int
	* @access public
	*/
	var $status = erSUCCESS;

	/**
	* Each event specific only params,
	* that they use for communication
	*
	* @var Array
	* @access public
	*/
	var $specificParams = Array();

	/**
	* Pseudo class used to create object,
	* in case if one is not already created
	*
	* @var string
	* @access public
	*/
	var $pseudoClass = '';

	/**
	* Create event based on params passed
	*
	* @param Array $params
	* @return kEvent
	* @access public
	*/
	function kEvent($params=Array(), $specificParams=null)
	{
	parent::kBase();
	if($params && is_array($params))
	{
	$prefix = getArrayValue($params,'prefix');
	$special = getArrayValue($params,'special');
	if($prefix) $this->Init($prefix,$special);
	$this->Name = getArrayValue($params,'name');
	}
	elseif ($params && is_string($params)) {
	if (preg_match('/([^.:])[.]{0,1}([^:]):(.*)/', $params, $regs)) {
	$prefix = $regs[1];
	$special = $regs[2];
	if($prefix) $this->Init($prefix,$special);
	$this->Name = $regs[3];
	}
	else {
	trigger_error('Invalid event string '.$params.' should be prefix[.special]:OnEvent ', E_USER_ERROR);
	}
	}
	if (isset($specificParams)) $this->specificParams = $specificParams;
	}

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

	function getEventParam($name)
	{
	- return getArrayValue($this->specificParams, $name);
	+ $args = func_get_args();
	+ array_unshift($args, $this->specificParams);
	+ return call_user_func_array('getArrayValue', $args); // getArrayValue($this->specificParams, $name);
	}

	function getPrefixSpecial($from_submit=false)
	{
	$separator=!$from_submit?'.':'_';
	$ret=$this->Prefix.$separator.$this->Special;
	return rtrim($ret,$separator);
	}

	/**
	* Set's pseudo class that differs from
	* the one specified in $Prefix
	*
	* @param string $appendix
	* @access public
	*/
	function setPseudoClass($appendix)
	{
	- $this->pseudoClass=$this->Prefix.$appendix;
	+ $this->pseudoClass = $this->Prefix.$appendix;
	}

	function Init($prefix, $special = '')
	{
	$this->Prefix = $prefix;
	$this->pseudoClass = $prefix; // default value
	$this->Special = $special;
	$this->Prefix_Special = rtrim($this->Prefix.'.'.$this->Special,'.');
	}

	/**
	* Returns object used in event
	*
	* @access public
	* @return kDBBase
	*/
	function &getObject($params = Array())
	{
	$object =& $this->Application->recallObject($this->Prefix_Special, $this->pseudoClass, $params);
	return $object;
	}

	/**
	* Calls passed event by name in current prefix/special environment
	* Called event gets this event as MasterEvent,
	* but its results (status and redirect* properties are copied back to current event)
	*
	* @param string $name EventName to call
	*/
	function CallSubEvent($name)
	{
	$child_event = new kEvent();
	$child_event->MasterEvent =& $this;
	$child_event->Prefix = $this->Prefix;
	$child_event->Special = $this->Special;
	$child_event->Prefix_Special = $this->Prefix_Special;
	$child_event->redirect = $this->redirect;
	$child_event->redirect_params = $this->redirect_params;
	$child_event->redirect_script = $this->redirect_script;
	$child_event->Name = $name;

	$this->Application->HandleEvent( $child_event );

	$this->status = $child_event->status;
	$this->redirect = $child_event->redirect;
	$this->redirect_params = $child_event->redirect_params;
	$this->redirect_script = $child_event->redirect_script;
	}

	/**
	* Set's redirect param for event
	*
	* @param string $name
	* @param string $value
	* @access public
	*/
	function SetRedirectParam($name, $value)
	{
	$this->redirect_params[$name] = $value;
	}

	/**
	* Allows to merge passed redirect params hash with existing ones
	*
	* @param Array $params
	* @access public
	*/
	function setRedirectParams($params)
	{
	$this->redirect_params = array_merge_recursive2($this->redirect_params, $params);
	}

	/**
	* Returns Master event name if any
	*
	* @return mixed
	* @access public
	*/
	function hasMasterEvent()
	{
	return is_object($this->MasterEvent) ? $this->MasterEvent->Name : false;
	}

	/**
	* Allows to tell if this event was called some how (e.g. subevent, hook) from event requested
	*
	* @param string $event_key event key in format [prefix[.special]:]event_name
	* @return unknown
	*/
	function hasAncestor($event_key)
	{
	$event_manager =& $this->Application->recallObject('EventManager');
	if (strpos($event_key, ':') === false) {
	$event_key = $this->getPrefixSpecial().':'.$event_key;
	}

	return $event_manager->eventRunning($event_key);
	}

	}

	?>
	\ No newline at end of file

	Property changes on: trunk/core/kernel/utility/event.php
	___________________________________________________________________
	Modified: cvs2svn:cvs-rev
	## -1 +1 ##
	-1.8
	\ No newline at end of property
	+1.9
	\ No newline at end of property
	Index: trunk/core/kernel/utility/http_query.php
	===================================================================
	--- trunk/core/kernel/utility/http_query.php (revision 4417)
	+++ trunk/core/kernel/utility/http_query.php (revision 4418)
	@@ -1,757 +1,775 @@
	<?php

	class kHTTPQuery extends Params {
	/**
	* $_POST vars
	*
	* @var Array
	* @access private
	*/
	var $Post;

	/**
	* $_GET vars
	*
	* @var Array
	* @access private
	*/
	var $Get;
	/**
	* $_COOKIE vars
	*
	* @var Array
	* @access private
	*/
	var $Cookie;

	/**
	* $_SERVER vars
	*
	* @var Array
	* @access private
	*/
	var $Server;

	/**
	* $_ENV vars
	*
	* @var Array
	* @access private
	*/
	var $Env;

	/**
	* Order in what write
	* all vars together in
	* the same array
	*
	* @var string
	*/
	var $Order;

	/**
	* Uploaded files info
	*
	* @var Array
	* @access private
	*/
	var $Files;

	var $specialsToRemove = Array();

	var $Admin = false;

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

	/**
	* Loads info from $_POST, $_GET and
	* related arrays into common place
	*
	* @param string $order
	* @return HTTPQuery
	* @access public
	*/
	function kHTTPQuery($order = 'CGPF')
	{
	parent::Params();
	$this->Conn =& $this->Application->GetADODBConnection();

	$this->Order = $order;
	$this->Admin = $this->Application->IsAdmin(); // better cache this value, not to calculate it each time in foreach
	}

	function Init($prefix, $special)
	{
	$this->AddAllVars();

	$this->specialsToRemove = $this->Get('remove_specials');
	if($this->specialsToRemove)
	{
	$this->_Params = $this->removeSpecials($this->_Params);
	}
	ini_set('magic_quotes_gpc', 0);
	}

	function removeSpecials($array)
	{
	$ret = Array();
	$removed = false;
	foreach($this->specialsToRemove as $prefix_special => $flag)
	{
	if($flag)
	{
	$removed = true;
	list($prefix,$special) = explode('.',$prefix_special, 2);
	foreach ($array as $key => $val) {
	$new_key = preg_match("/^".$prefix."[._]{1}".$special."(.*)/", $key, $regs) ? $prefix.$regs[1] : $key;
	$ret[$new_key] = is_array($val) ? $this->removeSpecials($val) : $val;
	}
	}
	}
	return $removed ? $ret : $array;
	}

	/**
	* All all requested vars to
	* common storage place
	*
	* @access private
	*/
	function AddAllVars()
	{
	for ($i=0; $i < strlen($this->Order); $i++)
	{
	$current = $this->Order[$i];
	switch ($current) {
	case 'G':
	$this->Get = $this->AddVars($_GET);
	$this->processQueryString();
	break;

	case 'P':
	$this->Post = $this->AddVars($_POST);
	$this->convertPostEvents();
	break;

	case 'C':
	$this->Cookie = $this->AddVars($_COOKIE);
	break;

	case 'E';
	$this->Env = $this->AddVars($_ENV);
	break;

	case 'S';
	$this->Server = $this->AddVars($_SERVER);
	break;

	case 'F';
	$this->convertFiles();
	$this->Files = $this->MergeVars($_FILES, false); //do not strip slashes!
	break;
	}
	}

	if( $this->Application->RewriteURLs() )
	{
	if( $this->Application->isDebugMode() )
	{
	$this->Application->Debugger->profileStart('url_parsing');
	$this->processRewriteURL();
	$description = 'Parsing <b>MOD_REWRITE</b> url (template: <b>'.$this->Get('t').'</b>)';
	$this->Application->Debugger->profileFinish('url_parsing', $description);
	}
	else
	{
	$this->processRewriteURL();
	}

	}
	}

	function convertFiles()
	{
	if (!$_FILES)
	{
	return false;
	}

	$file_keys = Array('error','name','size','tmp_name','type');

	$tmp = Array();
	foreach($_FILES as $file_name => $file_info)
	{
	if( is_array($file_info['error']) )
	{
	$tmp[$file_name] = $this->getArrayLevel( $file_info['error'], $file_name );
	}
	else
	{
	$normal_files[$file_name] = $file_info;
	}
	}

	if(!$tmp) return false;

	$files = $_FILES;
	$_FILES = Array();

	foreach($tmp as $prefix => $prefix_files)
	{
	$anchor =& $_FILES;
	foreach($prefix_files['keys'] as $key)
	{
	$anchor =& $anchor[$key];
	}
	foreach($prefix_files['value'] as $field_name)
	{
	unset($inner_anchor);
	unset($copy);
	$work_copy = $prefix_files['keys'];
	foreach($file_keys as $file_key)
	{
	$inner_anchor =& $files[$prefix][$file_key];
	if (isset($copy))
	{
	$work_copy = $copy;
	}
	else
	{
	$copy = $work_copy;
	}
	array_shift($work_copy);
	foreach($work_copy as $prefix_file_key)
	{
	$inner_anchor =& $inner_anchor[$prefix_file_key];
	}
	$anchor[$field_name][$file_key] = $inner_anchor[$field_name];
	}
	}
	}

	// keys: img_temp, 0, values: LocalPath, ThumbPath
	}

	function getArrayLevel(&$level, $prefix='')
	{
	$ret['keys'] = $prefix ? Array($prefix) : Array();
	$ret['value'] = Array();

	foreach($level as $level_key => $level_value)
	{
	if( is_array($level_value) )
	{
	$ret['keys'][] = $level_key;
	$tmp = $this->getArrayLevel($level_value);

	$ret['keys'] = array_merge($ret['keys'], $tmp['keys']);
	$ret['value'] = array_merge($ret['value'], $tmp['value']);
	}
	else
	{
	$ret['value'][] = $level_key;
	}
	}

	return $ret;
	}

	/**
	* Owerwrites GET events with POST events in case if they are set and not empty
	*
	*/
	function convertPostEvents()
	{
	$events = $this->Get('events');
	if( is_array($events) )
	{
	foreach ($events as $prefix_special => $event_name)
	{
	if($event_name) $this->Set($prefix_special.'_event', $event_name);
	}
	}
	}

	function finalizeParsing($passed = Array(), $module_params = Array() )
	{
	if ($passed) {
	$event_manger =& $this->Application->recallObject('EventManager');
	foreach ($passed as $passed_prefix) {
	$event_manger->setQueryMap($passed_prefix);
	}
	}

	// get joined version (env var + mod rewrite parsed)
	$passed = $this->Application->GetVar('passed');
	$env = $this->Application->BuildEnv( $this->Get('t'), $module_params, $passed, false, false );
	$this->Set(ENV_VAR_NAME, $env);
	$_REQUEST['env'] = $_GET['env'] = $env; // for capability with old in-portal code
	}

	function processRewriteURL()
	{
	// directory_1_2_3/sc1/inlink/detail/3/l1_ka_asd.html

	$url = $this->Get('_mod_rw_url_');
	if( substr($url, -5) == '.html' ) $url = substr($url, 0, strlen($url) - 5 );

	$url_parts = $url ? explode('/', $url) : Array();

	+ $process_module = true;
	if($this->Get('rewrite') == 'on' \|\| !$url_parts)
	{
	// set default values
	$defaults = Array('m_cat_id' => 0, 'm_cat_page' => 1, 'm_opener' => 's');
	foreach ($defaults as $default_key => $default_value)
	{
	if ($this->Get($default_key) == null) {
	$this->Set($default_key, $default_value);
	}
	}
	}

	if(!$url_parts)
	{
	$this->Application->Phrases = new PhrasesCache();
	$this->Application->VerifyLanguageId();
	$this->Application->Phrases->Init('phrases');
	$this->Application->VerifyThemeId();

	$this->Set('t', $this->getDefaultTemplate('') );
	$this->finalizeParsing(Array('m'));
	return false;
	}
	else
	{
	$this->Set('t', '');
	}

	$url_part = array_shift($url_parts);

	// match language
	$sql = 'SELECT LanguageId FROM '.TABLE_PREFIX.'Language WHERE LOWER(PackName) = '.$this->Conn->qstr($url_part).' AND Enabled = 1';
	$language_id = $this->Conn->GetOne($sql);
	$this->Application->Phrases = new PhrasesCache();
	if($language_id)
	{
	$this->Set('m_lang', $language_id);
	$url_part = $url_parts ? array_shift($url_parts) : ''; // prepare next url part for parsing
	}

	$this->Application->VerifyLanguageId();

	// $this->Get('m_lang') );

	// match theme
	if($url_part)
	{
	$sql = 'SELECT ThemeId FROM '.TABLE_PREFIX.'Theme WHERE LOWER(Name) = '.$this->Conn->qstr($url_part).' AND Enabled = 1';
	$theme_id = $this->Conn->GetOne($sql);
	if($theme_id)
	{
	$this->Set('m_theme', $theme_id);
	$url_part = $url_parts ? array_shift($url_parts) : ''; // prepare next url part for parsing
	}
	}
	$this->Application->VerifyThemeId(); // verify anyway - will set default if not found!!!

	// match category
	$category_id = 0;
	if($url_part)
	{
	$category_stack = Array();
	$category_found = false;
	$category_path = '';
	$rets = Array(); // just in case someone has used this variable before
	do
	{
	$category_path = trim($category_path.'/'.$url_part, '/');

	if( preg_match('/(.*)_([\d]+)$/', $category_path, $rets) )
	{
	$category_path = $rets[1];
	$this->Set('m_cat_page', $rets[2]);
	}

	$sql = 'SELECT CategoryId
	FROM '.TABLE_PREFIX.'Category
	WHERE NamedParentPath = '.$this->Conn->qstr($category_path);
	array_push($category_stack, $this->Conn->GetOne($sql) );
	$category_found = end($category_stack);
	if($category_found) $url_part = array_shift($url_parts);

	}while ($category_found && $url_part);

	if (count($category_stack)) {
	$category_id = array_pop($category_stack); // remove last not found category
	if($category_id === false)
	{
	$category_id = array_pop($category_stack);
	}
	if($category_id)
	{
	$this->Set('m_cat_id', $category_id);
	}
	}
	elseif (!$category_found && getArrayValue($rets, 2)) {
	$url_part = array_shift($url_parts);
	}
	}


	if (!$url_part) {
	// no more parts left in url
	+ $process_module = false;
	$sql = 'SELECT CachedCategoryTemplate
	FROM '.TABLE_PREFIX.'Category
	WHERE CategoryId = '.$category_id;
	$category_template = $this->Conn->GetOne($sql);
	if ($category_template) {
	$category_template = explode('/', $category_template);
	$url_part = array_shift($category_template);
	$url_parts = $category_template;
	}
	else {
	$url_part = 'index';
	}
	}
	- elseif ($url_part && count($url_parts) == 0 && $category_id) {
	+ elseif ($url_part && count($url_parts) <= 1 && $category_id) {
	// only filename left, no other parts
	- $sql = 'SELECT ParentPath, CachedItemTemplate
	+ $process_module = false;
	+ $sql = 'SELECT ParentPath, CachedItemTemplate, CachedCategoryTemplate
	FROM '.TABLE_PREFIX.'Category
	WHERE CategoryId = '.$category_id;
	$category_data = $this->Conn->GetRow($sql);

	$root_category_id = array_shift( explode('\|', substr($category_data['ParentPath'], 1, -1)) );
	$module_info = $this->Application->findModule('RootCat', $root_category_id);
	if ($module_info) {
	$module_prefix = $module_info['Var'];
	- $module_event = new kEvent($module_prefix.':ParseEnv', Array('url_parts' => Array($url_part)) );
	+ $module_event = new kEvent($module_prefix.':ParseEnv', Array('url_parts' => array_merge(Array($url_part), $url_parts)) );
	$this->Application->HandleEvent($module_event);
	-
	- if ($module_event->status == erSUCCESS) {
	+
	+ if ($module_event->status == erSUCCESS && $this->Get($module_prefix.'_id')) {
	$item_template = $category_data['CachedItemTemplate'];
	if ($item_template) {
	$url_parts = explode('/', $item_template);
	array_push($url_parts, $url_part); // save item's filename as not processed
	$url_part = array_shift($url_parts);
	}
	}
	+ elseif (!$module_event->getEventParam('url_parts')) {
	+ // parseEnv has processed that param
	+ $url_part = '';
	+ $category_template = $category_data['CachedCategoryTemplate'];
	+ if ($category_template) {
	+ $category_template = explode('/', $category_template);
	+ $url_part = array_shift($category_template);
	+ $url_parts = $category_template;
	+ }
	+ else {
	+ $url_part = 'index';
	+ }
	+ }
	}
	}

	// match module
	$next_template = $this->Get('next_template');
	if($url_part \|\| $next_template)
	{
	if($next_template)
	{
	$next_template_parts = explode('/', $next_template);
	$module_folder = array_shift($next_template_parts);
	}
	else
	{
	$module_folder = $url_part;
	}

	foreach ($this->Application->ModuleInfo as $module_name => $module_data)
	{
	if( trim($module_data['TemplatePath'], '/') == $module_folder )
	{
	$module_prefix = $module_data['Var'];
	break;
	}
	}
	}

	// match template
	$template_path = '';
	$template_found = false;
	if($url_part)
	{
	// search for template in real template records
	array_unshift($url_parts, $url_part);
	$template_parts = $url_parts;
	$url_parts = Array();
	do
	{
	$template_path = implode('/', $template_parts);

	$t_parts['path'] = dirname($template_path) == '.' ? '' : '/'.dirname($template_path);
	$t_parts['file'] = basename($template_path);

	$sql = 'SELECT FileId
	FROM '.TABLE_PREFIX.'ThemeFiles
	WHERE (FilePath = '.$this->Conn->qstr($t_parts['path']).') AND (FileName = '.$this->Conn->qstr($t_parts['file'].'.tpl').')';

	// $sql = 'SELECT FileId FROM '.TABLE_PREFIX.'ThemeFiles WHERE CONCAT(FilePath, "/", FileName) = '.$this->Conn->qstr('/'.$template_path.'.tpl');
	$template_found = $this->Conn->GetOne($sql);
	if(!$template_found)
	{
	array_unshift( $url_parts, array_pop($template_parts) );
	}

	}while (!$template_found && $template_parts);

	// try to find template in virtual templates in case if such ability exists
	if (constOn('CMS') && !$template_found) {

	$template_parts = $url_parts;
	$url_parts = Array();
	do
	{
	$template_path = implode('/', $template_parts);

	$sql = 'SELECT PageId FROM '.TABLE_PREFIX.'Pages WHERE Path = '.$this->Conn->qstr($template_path);
	$template_found = $this->Conn->GetOne($sql);
	if(!$template_found)
	{
	array_unshift( $url_parts, array_pop($template_parts) );
	}

	}while (!$template_found && $template_parts);
	}
	}

	// guess template if no existing template found
	if(!$template_found && isset($module_folder) && $module_folder)
	{
	// 1. try index template of module
	$sql = 'SELECT FileId FROM '.TABLE_PREFIX.'ThemeFiles WHERE CONCAT(FilePath, "/", FileName) = '.$this->Conn->qstr('/'.$module_folder.'/index.tpl');
	$template_found = $this->Conn->GetOne($sql);
	if($template_found)
	{
	$template_path = $module_folder.'/index';
	array_shift($url_parts);
	}
	else
	{
	// 2. return error template then
	$template_found = true;
	$template_path = $this->Application->ConfigValue('ErrorTemplate');
	if(!$template_path) $template_path = 'error_notfound';

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

	$this->Set('t', $this->getDefaultTemplate($template_found ? $template_path : '') );

	// pass params left to module

	$this->Application->Phrases->Init('phrases');
	$passed = Array('m');
	$module_params = Array();
	if ( isset($module_prefix) ) {
	$passed[] = $module_prefix;
	$module_event = new kEvent($module_prefix.':ParseEnv', Array('url_parts' => $url_parts) );
	- $this->Application->HandleEvent($module_event);
	+ if ($process_module) {
	+ $this->Application->HandleEvent($module_event);
	+ }
	$item_id = $this->Get($module_prefix.'_id');
	$module_params = Array($module_prefix.'_id' => $item_id ? $item_id : '0' );

	if ($module_event->status == erFAIL) {
	$not_found = $this->Application->ConfigValue('ErrorTemplate');
	$this->Set('t', $not_found ? $not_found : 'error_notfound' );
	}
	}

	$this->finalizeParsing($passed, $module_params);
	}

	function getDefaultTemplate($t)
	{
	$t = $this->getTemplateName( trim($t, '/') );
	if (!$t) $t = 'index';
	return trim($t, '/');
	}

	function extractSIDAndTemplate(&$parts)
	{
	if ( defined('INPORTAL_ENV') && INPORTAL_ENV ) // SID-TEMPLATE
	{
	$sub_parts = array_shift($parts);
	list($sid, $t) = explode('-', $sub_parts, 2);

	// Save Session ID
	if($sid)
	{
	$this->Set('sid', $sid);
	$this->Get['sid'] = $sid;
	}

	// Save Template Name
	$this->Set('t', $this->getDefaultTemplate($t) );
	}
	else // SID:TEMPLATE
	{
	// Save Session ID
	$sid = array_shift($parts);
	if ($sid) $this->Set('sid', $sid);

	// Save Template Name
	$t = array_shift($parts);
	$this->Set('t', $this->getDefaultTemplate($t) );
	}
	}

	/**
	* Process QueryString only, create
	* events, ids, based on config
	* set template name and sid in
	* desired application variables.
	*
	* @access private
	*/
	function processQueryString()
	{
	// env=SID:TEMPLATE:m-1-1-1-1:l0-0-0:n-0-0-0:bb-0-0-1-1-1-0

	$env_var = $this->Get(ENV_VAR_NAME);
	if($env_var)
	{
	$env_var = str_replace('\:','_&+$$+&_', $env_var); // replace escaped "=" with spec-chars :)
	$parts = explode(':', $env_var);

	if( !$this->Application->RewriteURLs() \|\| ($this->Application->RewriteURLs() && $this->Get('rewrite') != 'on') )
	{
	$this->extractSIDAndTemplate($parts);
	}

	if($parts)
	{
	$query_maps = Array();
	$event_manger =& $this->Application->recallObject('EventManager');

	$passed = Array();

	foreach($parts as $mixed_part)
	{
	//In-portal old style env conversion - adds '-' between prefix and first var
	$mixed_part = str_replace('_&+$$+&_',':',$mixed_part);
	$mixed_part = preg_replace("/^([a-zA-Z]+)([0-9]+)-(.*)/", "$1-$2-$3", $mixed_part);

	$escaped_part = str_replace('\-', '_&+$$+&_', $mixed_part);
	$escaped_part = explode('-', $escaped_part);

	$mixed_part = array();
	foreach ($escaped_part as $escaped_val) {
	$mixed_part[] = str_replace('_&+$$+&_', '-', $escaped_val);
	}

	$prefix_special = array_shift($mixed_part); // l.pick, l
	$query_map = $event_manger->setQueryMap($prefix_special);

	// if config is not defined for prefix in QueryString, then don't process it
	if ($query_map) {
	foreach($query_map as $index => $var_name)
	{
	// l_id, l_page, l_bla-bla-bla
	$val = $mixed_part[$index - 1];
	if ($val == '') $val = false;
	$this->Set($prefix_special.'_'.$var_name, $val);
	}
	}
	}
	}
	}
	else
	{
	$t=$this->getTemplateName('index');
	$this->Set('t', $t);
	}
	}

	/**
	* Decides what template name to
	* use from $_GET or from $_POST
	*
	* @param string $querystring_template
	* @return string
	* @access private
	*/
	function getTemplateName($querystring_template)
	{
	$t_from_post = $this->Get('t');
	$t = $t_from_post ? $t_from_post : $querystring_template;

	if ( is_numeric($t) )
	{
	$t = $this->Conn->GetOne(' SELECT CONCAT(FilePath, \'/\', FileName)
	FROM '.TABLE_PREFIX.'ThemeFiles
	WHERE FileId = '.$t);
	}
	$t = preg_replace('/\.tpl$/', '', $t);

	return $t;
	}

	/**
	* Saves variables from array specified
	* into common variable storage place
	*
	* @param Array $array
	* @return Array
	* @access private
	*/
	function AddVars($array)
	{
	$array = $this->StripSlashes($array);
	foreach($array as $key => $value)
	{
	$this->Set($key,$value);
	}
	return $array;
	}

	function MergeVars($array, $strip_slashes=true)
	{
	if ($strip_slashes) $array = $this->StripSlashes($array);
	foreach($array as $key => $value)
	{
	$this->_Params = array_merge_recursive2($this->_Params, Array($key=>$value));
	}
	return $array;
	}

	function StripSlashes($array)
	{
	//if( !get_magic_quotes_gpc() ) return $array;
	foreach($array as $key=>$value)
	{
	if( is_array($value) )
	{
	$array[$key] = $this->StripSlashes($value);
	}
	else
	{
	if( get_magic_quotes_gpc() ) $value = stripslashes($value);
	if(!$this->Admin) $value = htmlspecialchars($value);
	$array[$key] = $value;
	}
	//$array[$key]=is_array($value)?$this->StripSlashes($value):stripslashes($value);
	}
	return $array;
	}

	/**
	* Returns all $_GET array excluding system parameters, that are not allowed to be passed through generated urls
	*
	* @return Array
	*/
	function getRedirectParams()
	{
	$unset_vars = Array(ENV_VAR_NAME, 'rewrite', '_mod_rw_url_', 'Action');
	$ret = $this->Get;
	foreach ($unset_vars as $var_name)
	{
	if( isset($ret[$var_name]) ) unset( $ret[$var_name] );
	}
	return $ret;
	}
	}

	?>
	\ No newline at end of file

	Property changes on: trunk/core/kernel/utility/http_query.php
	___________________________________________________________________
	Modified: cvs2svn:cvs-rev
	## -1 +1 ##
	-1.42
	\ No newline at end of property
	+1.43
	\ No newline at end of property
	Index: trunk/core/kernel/utility/unit_config_reader.php
	===================================================================
	--- trunk/core/kernel/utility/unit_config_reader.php (revision 4417)
	+++ trunk/core/kernel/utility/unit_config_reader.php (revision 4418)
	@@ -1,491 +1,491 @@
	<?php

	class kUnitConfigReader extends kBase {

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

	var $CacheExpired = false;

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

	/**
	* Checks if config file is allowed for includion (if module of config is installed)
	*
	* @param string $config_path relative path from in-portal directory
	*/
	function configAllowed($config_path)
	{
	$module_found = false;
	if (!$this->Application->ModuleInfo) return false;

	foreach($this->Application->ModuleInfo as $module_name => $module_info)
	{
	$module_path = '/'.$module_info['Path'];
	if( substr($config_path, 0, strlen($module_path)) == $module_path )
	{
	$module_found = true;
	break;
	}
	}
	return $module_found;
	}

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

	/**
	* Read configs from all directories
	* on path specified
	*
	* @param string $folderPath
	* @access public
	*/
	function processFolder($folderPath, $cached)
	{
	$fh=opendir($folderPath);
	while(($sub_folder=readdir($fh)))
	{
	$full_path=$folderPath.'/'.$sub_folder;
	if( $this->isDir($full_path) && file_exists($this->getConfigName($full_path)) )
	{
	if (filemtime($full_path) > $cached) {
	$this->CacheExpired = true;

	$file = $this->getConfigName($full_path);
	if ( $this->Application->isDebugMode() && constOn('DBG_PROFILE_INCLUDES') )
	{

	if ( in_array($file, get_required_files()) ) return;
	global $debugger;
	$debugger->IncludeLevel++;
	$before_time = getmicrotime();
	$before_mem = memory_get_usage();
	include_once(FULL_PATH.$file);
	$used_time = getmicrotime() - $before_time;
	$used_mem = memory_get_usage() - $before_mem;
	$debugger->IncludeLevel--;
	$debugger->IncludesData['file'][] = str_replace(FULL_PATH, '', $file);
	$debugger->IncludesData['mem'][] = $used_mem;
	$debugger->IncludesData['time'][] = $used_time;
	$debugger->IncludesData['level'][] = -1;
	}
	else {
	include_once($file);
	}

	if ( !isset($config) \|\| !$config ) continue;
	$prefix = $config['Prefix'];
	$config['BasePath'] = $full_path;
	$this->configData[$prefix] = $config;
	}
	}
	}
	}

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

	foreach ($sub_configs as $sub_prefix => $sub_config) {
	$sub_config['Prefix'] = $sub_prefix;
	$this->configData[$sub_prefix] = array_merge_recursive2($this->configData[$$dst_prefix_var], $sub_config);

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

	$this->postProcessConfig($sub_prefix, $config_key, $dst_prefix_var);
	}

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

	function ParseConfigs()
	{
	foreach ($this->configData as $prefix => $config) {
	$this->parseConfig($prefix);
	}

	$this->Application->HandleEvent( new kEvent('m:OnAfterConfigRead') );
	}

	function findConfigFiles($folderPath)
	{
	$folderPath = str_replace(FULL_PATH, '', $folderPath); // this make sense, since $folderPath may NOT contain FULL_PATH
	$fh=opendir(FULL_PATH.$folderPath);
	while(($sub_folder=readdir($fh)))
	{
	$full_path = FULL_PATH.$folderPath.'/'.$sub_folder;
	if( $this->isDir($full_path))
	{
	if ( file_exists(FULL_PATH.$this->getConfigName($folderPath.'/'.$sub_folder)) ) {
	$this->configFiles[] = $this->getConfigName($folderPath.'/'.$sub_folder);
	}
	$this->findConfigFiles($full_path);

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

	}
	}
	}

	function includeConfigFiles()
	{
	$db =& $this->Application->GetADODBConnection();

	foreach ($this->configFiles as $filename)
	{
	$config_found = file_exists(FULL_PATH.$filename) && $this->configAllowed($filename);
	if( $this->Application->isDebugMode() && constOn('DBG_PROFILE_INCLUDES') )
	{
	if ( in_array($filename, get_required_files()) ) return;
	global $debugger;
	$debugger->IncludeLevel++;
	$before_time = getmicrotime();
	$before_mem = memory_get_usage();
	if($config_found) include_once(FULL_PATH.$filename);
	$used_time = getmicrotime() - $before_time;
	$used_mem = memory_get_usage() - $before_mem;
	$debugger->IncludeLevel--;
	$debugger->IncludesData['file'][] = str_replace(FULL_PATH, '', $filename);
	$debugger->IncludesData['mem'][] = $used_mem;
	$debugger->IncludesData['time'][] = $used_time;
	$debugger->IncludesData['level'][] = -1;
	}
	else
	{
	if($config_found) include_once(FULL_PATH.$filename);
	}

	if($config_found && isset($config) && $config)
	{
	$prefix = isset($config['Prefix']) ? $config['Prefix'] : '';

	preg_match('/\/(.*)\//U', $filename, $rets);
	$config['ModuleFolder'] = $rets[1];
	$config['BasePath'] = dirname(FULL_PATH.$filename);
	$this->configData[$prefix] = $config;

	$this->postProcessConfig($prefix, 'AggregateConfigs', 'sub_prefix');
	$this->postProcessConfig($prefix, 'Clones', 'prefix');
	}
	}
	}

	function scanModules($folderPath)
	{
	global $debugger;

	if (defined('CACHE_CONFIGS_FILES')) {
	$conn =& $this->Application->GetADODBConnection();
	$data = $conn->GetRow('SELECT Data, Cached FROM '.TABLE_PREFIX.'Cache WHERE VarName = "config_files"');
	// if ($data && $data['Cached'] > (adodb_mktime() - 3600) ) {
	if ($data && $data['Cached'] > 0 ) {
	$this->configFiles = unserialize($data['Data']);
	$files_cached = $data['Cached'];
	}
	else {
	$files_cached = 0;
	}
	}
	else {
	$files_cached = 0;
	}

	if (defined('CACHE_CONFIGS_DATA') && CACHE_CONFIGS_DATA) {
	$conn =& $this->Application->GetADODBConnection();
	$data = $conn->GetRow('SELECT Data, Cached FROM '.TABLE_PREFIX.'Cache WHERE VarName = "config_data"');
	if ($data && $data['Cached'] > (adodb_mktime() - 3600) ) {
	$this->configData = unserialize($data['Data']);
	$data_cached = $data['Cached'];
	}
	else {
	$data_cached = 0;
	}
	}
	else {
	$data_cached = 0;
	}

	if ( !defined('CACHE_CONFIGS_FILES') \|\| $files_cached == 0 ) {
	$this->findConfigFiles($folderPath);
	}

	if ( !defined('CACHE_CONFIGS_DATA') \|\| $data_cached == 0) {
	$this->includeConfigFiles();
	}

	/*// && (adodb_mktime() - $cached) > 600) - to skip checking files modified dates
	if ( !defined('CACHE_CONFIGS') ) {
	$fh=opendir($folderPath);
	while(($sub_folder=readdir($fh)))
	{
	$full_path=$folderPath.'/'.$sub_folder.'/units';
	if( $this->isDir($full_path) )
	{
	$this->processFolder($full_path, $cached);
	}
	}
	}*/

	if (defined('CACHE_CONFIGS_DATA') && $data_cached == 0) {
	$conn->Query('REPLACE '.TABLE_PREFIX.'Cache (VarName, Data, Cached) VALUES ("config_data", '.$conn->qstr(serialize($this->configData)).', '.adodb_mktime().')');
	}

	$this->ParseConfigs();

	if (defined('CACHE_CONFIGS_FILES') && $files_cached == 0) {
	$conn->Query('REPLACE '.TABLE_PREFIX.'Cache (VarName, Data, Cached) VALUES ("config_files", '.$conn->qstr(serialize($this->configFiles)).', '.adodb_mktime().')');
	}

	unset($this->configFiles);
	// unset($this->configData);

	}

	/**
	* Register nessasary classes
	*
	* @param string $prefix
	* @access private
	*/
	function parseConfig($prefix)
	{
	$config =& $this->configData[$prefix];
	$event_manager =& $this->Application->recallObject('EventManager');

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

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

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

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

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

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

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

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

	if ( is_array(getArrayValue($config, 'AggregateTags')) ) {
	foreach ($config['AggregateTags'] as $aggregate_tag) {
	$aggregate_tag['LocalPrefix'] = $config['Prefix'];
	$this->Application->registerAggregateTag($aggregate_tag);
	}
	}

	if ( $this->Application->isDebugMode() && dbg_ConstOn('DBG_VALIDATE_CONFIGS') && isset($config['TableName']) )
	{
	global $debugger;
	$tablename = $config['TableName'];

	$conn =& $this->Application->GetADODBConnection();
	$res = $conn->Query("DESCRIBE $tablename");

	foreach ($res as $field) {
	$f_name = $field['Field'];
	if (getArrayValue($config, 'Fields')) {
	if ( !array_key_exists ($f_name, $config['Fields']) ) {
	$debugger->appendHTML("<b class='debug_error'>Config Warning: </b>Field $f_name exists in the database, but is not defined in config file for prefix <b>".$config['Prefix']."</b>!");
	safeDefine('DBG_RAISE_ON_WARNINGS', 1);
	}
	else {
	$options = $config['Fields'][$f_name];
	if ($field['Null'] == '') {
	if ( $f_name != $config['IDField'] && !isset($options['not_null']) && !isset($options['required']) ) {
	$debugger->appendHTML("<b class='debug_error'>Config Error: </b>Field $f_name in config for prefix <b>".$config['Prefix']."</b> is NOT NULL in the database, but is not configured as not_null or required!");
	safeDefine('DBG_RAISE_ON_WARNINGS', 1);
	}
	if ( isset($options['not_null']) && !isset($options['default']) ) {
	$debugger->appendHTML("<b class='debug_error'>Config Error: </b>Field $f_name in config for prefix <b>".$config['Prefix']."</b> is described as NOT NULL, but does not have DEFAULT value!");
	safeDefine('DBG_RAISE_ON_WARNINGS', 1);
	}
	}

	}
	}
	}
	}
	}

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

	/**
	* Read all unit with $prefix options
	*
	* @param string $prefix
	* @return Array
	* @access public
	*/
	function getUnitOptions($prefix)
	{
	return $this->prefixRegistred($prefix) ? $this->configData[$prefix] : false;
	}

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

	}

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

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

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


	}


	?>
	\ No newline at end of file

	Property changes on: trunk/core/kernel/utility/unit_config_reader.php
	___________________________________________________________________
	Modified: cvs2svn:cvs-rev
	## -1 +1 ##
	-1.29
	\ No newline at end of property
	+1.30
	\ No newline at end of property
	Index: trunk/core/kernel/event_handler.php
	===================================================================
	--- trunk/core/kernel/event_handler.php (revision 4417)
	+++ trunk/core/kernel/event_handler.php (revision 4418)
	@@ -1,281 +1,289 @@
	<?php

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


	/**
	* Default event handler. Mostly abstract class
	*
	*/
	class kEventHandler extends kBase {

	/**
	* In case if event should be handled with mehod,
	* which name differs from event name, then it
	* should be specified here.
	* key - event name, value - event method
	*
	* @var Array
	* @access protected
	*/
	var $eventMethods=Array();

	/**
	* Define alternative event processing method names
	*
	* @see $eventMethods
	* @access protected
	*/
	function mapEvents()
	{

	}

	function getPrefixSpecial()
	{
	trigger_error('Usage of getPrefixSpecial() this method is forbidden in kEventHandler class children. Use $event->getPrefixSpecial(true); instead', E_USER_ERROR);
	}

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

	/**
	* Process Event
	*
	* @param kEvent $event
	* @access public
	*/
	function processEvent(&$event)
	{
	$event_name=$event->Name;
	if( isset($this->eventMethods[$event_name]) ) $event_name=$this->eventMethods[$event_name];

	if( method_exists($this,$event_name) )
	{
	$this->$event_name($event);
	}
	else
	{
	trigger_error('event <b>'.$event->Name.'</b> not implemented in class <b>'.get_class($this).'</b>', E_USER_ERROR);
	}
	}

	/**
	* Sample dummy event
	*
	* @param kEvent $event
	* @access protected
	*/
	function OnBuild(&$event)
	{
	/*echo 'building: <br>';
	print_pre($event);*/
	}

	/**
	* Returns to previous template in opener stack
	*
	* @param kEvent $event
	*/
	function OnGoBack(&$event)
	{
	$event->SetRedirectParam('opener', 'u');
	}

	/**
	* Apply some special processing to
	* object beeing recalled before using
	* it in other events that call prepareObject
	*
	* @param Object $object
	* @param kEvent $event
	* @access protected
	*/
	function prepareObject(&$object, &$event)
	{
	// processing here
	}

	/**
	* Creates new event as child of
	* event passed as $event param
	*
	* @param kEvent $event
	* @access protected
	*/
	function &inheritEvent(&$event, $name=null)
	{
	$child_event = new kEvent();
	$child_event->MasterEvent =& $event;
	$child_event->Prefix=$event->Prefix;
	$child_event->Special=$event->Special;
	$child_event->Prefix_Special=$event->Prefix_Special;
	$child_event->Name = $name;
	return $child_event;
	}

	/**
	* Created url part for this module
	*
	* @param kEvent $event
	*/
	function BuildEnv(&$event)
	{
	$prefix_special = $event->getPrefixSpecial();
	$url_params = $event->getEventParam('url_params');
	$pass_events = $event->getEventParam('pass_events');

	$query_vars = $this->Application->getUnitOption($event->Prefix, 'QueryString');

	$event_key = array_search('event', $query_vars);
	if ($event_key) {
	// pass through event of this prefix
	unset($query_vars[$event_key]);
	}

	if (!getArrayValue($url_params, $prefix_special.'_event')) {
	// if empty event, then remove it from url
	unset( $url_params[$prefix_special.'_event'] );
	}

	//if pass events is off and event is not implicity passed
	if ( !$pass_events && !isset($url_params[$prefix_special.'_event']) )
	{
	unset($url_params[$prefix_special.'_event']); // remove event from url if requested
	//otherwise it will use value from get_var
	}

	if(!$query_vars) return true;

	$processed_params = Array();
	foreach($query_vars as $index => $var_name)
	{
	//if value passed in params use it, otherwise use current from application
	$var_name = $prefix_special.'_'.$var_name;
	$processed_params[$var_name] = isset( $url_params[$var_name] ) ? $url_params[$var_name] : $this->Application->GetVar($var_name);
	if ( isset($url_params[$var_name]) ) unset( $url_params[$var_name] );
	}

	$ret = '';

	if($processed_params[$prefix_special.'_Page'] > 1)
	{
	$ret .= $processed_params[$prefix_special.'_Page'].'/';
	}

	if ($processed_params[$prefix_special.'_id']) {

	// this allows to fill 3 cache records with one query (see this method for details)
	$category_id = isset($url_params['m_cat_id']) ? $url_params['m_cat_id'] : $this->Application->GetVar('m_cat_id');
	$category_filename = $this->Application->getFilename('c', $category_id);

	// if template is also item template of category, then remove template
	$template = getArrayValue($url_params, 't');
	$item_template = $this->Application->getCache('item_templates', $category_id);
	if ($template == $item_template \|\| strtolower($template) == '__default__') {
	unset($url_params['t']);
	}

	// get item's filename
	$filename = $this->Application->getFilename($event->Prefix, $processed_params[$prefix_special.'_id'] );
	if($filename !== false) $ret .= $filename.'/';
	}

	if( getArrayValue($processed_params, $prefix_special.'_Reviews_Page') > 1)
	{
	if($processed_params[$prefix_special.'_id']) $ret = rtrim($ret, '/');
	$ret .= '_'.$processed_params[$prefix_special.'_Reviews_Page'].'/';
	}

	$event->setEventParam('url_params', $url_params);
	$event->setEventParam('env_string', strtolower($ret) );
	}

	/**
	* Process mod_rewrite url part left after previous parser
	*
	* @param kEvent $event
	*/
	function ParseEnv(&$event)
	{
	// <module_page>/<item_filename>_<reviews_page>

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

	$defaults = Array('id' => 0, 'Page' => 1, 'Reviews_Page' => 1);
	foreach ($defaults as $var_name => $var_value)
	{
	$this->Application->SetVar($event->getPrefixSpecial().'_'.$var_name, $var_value);
	}
	- if (!$url_parts) return false;
	+ if (!$url_parts) {
	+// $event->status = erFAIL;
	+ return false;
	+ }

	$ret = '';
	$url_part = array_shift($url_parts);

	// match module page
	if( is_numeric($url_part) )
	{
	$this->Application->SetVar( $event->getPrefixSpecial().'_Page', $url_part);
	$url_part = $url_parts ? array_shift($url_parts) : '';
	}

	- if(!$url_part) return true;
	+ if (!$url_part) {
	+ $event->setEventParam('url_parts', $url_parts);
	+// $event->status = erFAIL;
	+ return true;
	+ }

	// match module reviews page
	if( preg_match('/(.*)_([\d]+)$/', $url_part, $rets) )
	{
	$url_part = $rets[1];
	$this->Application->SetVar( $event->getPrefixSpecial().'_Reviews_Page', $rets[2]);
	}

	// match item's filename
	$db =& $this->Application->GetADODBConnection();
	$id_field = $this->Application->getUnitOption($event->Prefix, 'IDField');
	$table = $this->Application->getUnitOption($event->Prefix, 'TableName');
	$sql = 'SELECT item_table.'.$id_field.'
	FROM '.$table.' item_table
	LEFT JOIN '.TABLE_PREFIX.'CategoryItems cat_items ON item_table.ResourceId = cat_items.ItemResourceId
	WHERE (item_table.Filename = '.$db->qstr($url_part).') AND (cat_items.CategoryId = '.$this->Application->GetVar('m_cat_id').')';
	$item_id = $db->GetOne($sql);
	if($item_id !== false)
	{
	$this->Application->SetVar($event->getPrefixSpecial().'_id', $item_id);
	}
	else
	{
	array_unshift($url_parts, $url_part);
	$event->status = erFAIL;
	}
	+
	$event->setEventParam('url_parts', $url_parts);
	}
	}


	?>
	\ No newline at end of file

	Property changes on: trunk/core/kernel/event_handler.php
	___________________________________________________________________
	Modified: cvs2svn:cvs-rev
	## -1 +1 ##
	-1.22
	\ No newline at end of property
	+1.23
	\ No newline at end of property
	Index: trunk/core/kernel/globals.php
	===================================================================
	--- trunk/core/kernel/globals.php (revision 4417)
	+++ trunk/core/kernel/globals.php (revision 4418)
	@@ -1,483 +1,487 @@
	<?php
	if( !function_exists('array_merge_recursive2') )
	{
	/**
	* array_merge_recursive2()
	*
	* Similar to array_merge_recursive but keyed-valued are always overwritten.
	* Priority goes to the 2nd array.
	*
	* @static yes
	* @param $paArray1 array
	* @param $paArray2 array
	* @return array
	* @access public
	*/
	function array_merge_recursive2($paArray1, $paArray2)
	{
	if (!is_array($paArray1) or !is_array($paArray2)) { return $paArray2; }
	foreach ($paArray2 AS $sKey2 => $sValue2)
	{
	$paArray1[$sKey2] = array_merge_recursive2( getArrayValue($paArray1,$sKey2), $sValue2);
	}
	return $paArray1;
	}
	}

	/**
	* @return int
	* @param $array array
	* @param $value mixed
	* @desc Prepend a reference to an element to the beginning of an array. Renumbers numeric keys, so $value is always inserted to $array[0]
	*/
	function array_unshift_ref(&$array, &$value)
	{
	$return = array_unshift($array,'');
	$array[0] =& $value;
	return $return;
	}

	/**
	* Same as print_r, budet designed for viewing in web page
	*
	* @param Array $data
	* @param string $label
	*/
	function print_pre($data, $label='')
	{
	$is_debug = false;
	if (class_exists('kApplication')) {
	$application =& kApplication::Instance();
	$is_debug = $application->isDebugMode();
	}

	if ($is_debug) {
	if ($label) $application->Debugger->appendHTML('<b>'.$label.'</b>');
	$application->Debugger->dumpVars($data);
	}
	else
	{
	if ($label) echo '<b>', $label, '</b><br>';
	echo '<pre>', print_r($data, true), '</pre>';
	}
	}

	/**
	* Returns array value if key exists
	*
	* @param Array $array searchable array
	* @param int $key array key
	* @return string
	* @access public
	*/
	//
	function getArrayValue(&$array, $key)
	{
	$ret = isset($array[$key]) ? $array[$key] : false;
	if ($ret && func_num_args() > 2) {
	for ($i = 2; $i < func_num_args(); $i++) {
	$cur_key = func_get_arg($i);
	$ret = getArrayValue( $ret, $cur_key );
	if ($ret === false) break;
	}
	}
	return $ret;
	}

	/**
	* Rename key in associative array, maintaining keys order
	*
	* @param Array $array Associative Array
	* @param mixed $old Old key name
	* @param mixed $new New key name
	* @access public
	*/
	function array_rename_key(&$array, $old, $new)
	{
	foreach ($array as $key => $val)
	{
	$new_array[ $key == $old ? $new : $key] = $val;
	}
	$array = $new_array;
	}

	/**
	* Define constant if it was not already defined before
	*
	* @param string $const_name
	* @param string $const_value
	* @access public
	*/
	function safeDefine($const_name, $const_value)
	{
	if(!defined($const_name)) define($const_name,$const_value);
	}

	if( !function_exists('parse_portal_ini') )
	{
	function parse_portal_ini($file, $parse_section = false)
	{
	if (!file_exists($file)) return false;

	if( file_exists($file) && !is_readable($file) ) die('Could Not Open Ini File');

	$contents = file($file);

	$retval = Array();
	$section = '';
	$ln = 1;
	$resave = false;
	foreach($contents as $line) {
	if ($ln == 1 && $line != '<'.'?'.'php die() ?'.">\n") {
	$resave = true;
	}
	$ln++;
	$line = trim($line);
	$line = eregi_replace(';[.]*','',$line);
	if(strlen($line) > 0) {
	//echo $line . " - ";
	if(eregi('^[[a-z]+]$',str_replace(' ', '', $line))) {
	//echo 'section';
	$section = substr($line,1,(strlen($line)-2));
	if ($parse_section) {
	$retval[$section] = array();
	}
	continue;
	} elseif(eregi('=',$line)) {
	//echo 'main element';
	list($key,$val) = explode(' = ',$line);
	if (!$parse_section) {
	$retval[trim($key)] = str_replace('"', '', $val);
	}
	else {
	$retval[$section][trim($key)] = str_replace('"', '', $val);
	}
	} //end if
	//echo '<br />';
	} //end if
	} //end foreach
	if($resave)
	{
	$fp = fopen($file, 'w');
	reset($contents);
	fwrite($fp,'<'.'?'.'php die() ?'.">\n\n");
	foreach($contents as $line) fwrite($fp,"$line");
	fclose($fp);
	}

	return $retval;
	}
	}


	if( !function_exists('getmicrotime') )
	{
	function getmicrotime()
	{
	list($usec, $sec) = explode(" ",microtime());
	return ((float)$usec + (float)$sec);
	}
	}

	if( !function_exists('k4_include_once') )
	{
	function k4_include_once($file)
	{
	if ( constOn('DEBUG_MODE') && isset($debugger) && constOn('DBG_PROFILE_INCLUDES') )
	{

	if ( in_array($file, get_required_files()) ) return;
	global $debugger;

	$debugger->IncludeLevel++;
	$before_time = getmicrotime();
	$before_mem = memory_get_usage();
	include_once($file);
	$used_time = getmicrotime() - $before_time;
	$used_mem = memory_get_usage() - $before_mem;

	$debugger->IncludeLevel--;
	$debugger->IncludesData['file'][] = str_replace(FULL_PATH, '', $file);
	$debugger->IncludesData['mem'][] = $used_mem;
	$debugger->IncludesData['time'][] = $used_time;
	$debugger->IncludesData['level'][] = $debugger->IncludeLevel;


	}
	else
	{
	include_once($file);
	}
	}
	}

	/**
	* Checks if string passed is serialized array
	*
	* @param string $string
	* @return bool
	*/
	function IsSerialized($string)
	{
	if( is_array($string) ) return false;
	return preg_match('/a:([\d]+):{/', $string);
	}

	if (!function_exists('makepassword4')){

	function makepassword4($length=10)
	{
	$pass_length=$length;

	$p1=array('b','c','d','f','g','h','j','k','l','m','n','p','q','r','s','t','v','w','x','y','z');
	$p2=array('a','e','i','o','u');
	$p3=array('1','2','3','4','5','6','7','8','9');
	$p4=array('(','&',')',';','%'); // if you need real strong stuff

	// how much elements in the array
	// can be done with a array count but counting once here is faster

	$s1=21;// this is the count of $p1
	$s2=5; // this is the count of $p2
	$s3=9; // this is the count of $p3
	$s4=5; // this is the count of $p4

	// possible readable combinations

	$c1='121'; // will be like 'bab'
	$c2='212'; // will be like 'aba'
	$c3='12'; // will be like 'ab'
	$c4='3'; // will be just a number '1 to 9' if you dont like number delete the 3
	// $c5='4'; // uncomment to active the strong stuff

	$comb='4'; // the amount of combinations you made above (and did not comment out)



	for ($p=0;$p<$pass_length;)
	{
	mt_srand((double)microtime()*1000000);
	$strpart=mt_rand(1,$comb);
	// checking if the stringpart is not the same as the previous one
	if($strpart<>$previous)
	{
	$pass_structure.=${'c'.$strpart};

	// shortcutting the loop a bit
	$p=$p+strlen(${'c'.$strpart});
	}
	$previous=$strpart;
	}


	// generating the password from the structure defined in $pass_structure
	for ($g=0;$g<strlen($pass_structure);$g++)
	{
	mt_srand((double)microtime()*1000000);
	$sel=substr($pass_structure,$g,1);
	$pass.=${'p'.$sel}[mt_rand(0,-1+${'s'.$sel})];

	}
	return $pass;
	}
	}

	if( !function_exists('unhtmlentities') )
	{
	function unhtmlentities($string)
	{
	$trans_tbl = get_html_translation_table(HTML_ENTITIES);
	$trans_tbl = array_flip ($trans_tbl);
	return strtr($string, $trans_tbl);
	}
	}

	if( !function_exists('curl_post') )
	{
	/**
	* submits $url with $post as POST
	*
	* @param string $url
	* @param unknown_type $post
	* @return unknown
	*/
	- function curl_post($url, $post, $headers=null)
	+ function curl_post($url, $post, $headers=null, $request_type = 'POST')
	{
	if( is_array($post) )
	{
	$params_str = '';
	foreach($post as $key => $value) $params_str .= $key.'='.urlencode($value).'&';
	$post = $params_str;
	}

	$ch = curl_init($url);

	$dbg = false;
	if (defined('DEBUG_MODE') && DEBUG_MODE && dbg_ConstOn('DBG_CURL')) {
	$dbg = true;
	safeDefine('DBG_CURL_LOGFILE', '/curl.log');
	$log = fopen(FULL_PATH.DBG_CURL_LOGFILE, 'a');

	curl_setopt($ch, CURLOPT_FILE, $log);
	curl_setopt($ch, CURLOPT_VERBOSE, TRUE);
	curl_setopt($ch, CURLOPT_STDERR, $log);
	//curl_setopt($ch, CURLOPT_WRITEHEADER, $log);
	}

	if (!is_null($headers)) {
	curl_setopt($ch, CURLOPT_HTTPHEADER, $headers);
	}

	- curl_setopt($ch, CURLOPT_POST, 1);
	- curl_setopt($ch, CURLOPT_POSTFIELDS, $post);
	+ // if we have post data, then POST else use GET method instead
	+ if ($request_type == 'POST') {
	+ curl_setopt($ch, CURLOPT_POST, 1);
	+ curl_setopt($ch, CURLOPT_POSTFIELDS, $post);
	+ }
	+
	curl_setopt($ch, CURLOPT_RETURNTRANSFER, 1);

	curl_setopt($ch,CURLOPT_REFERER, PROTOCOL.SERVER_NAME);
	curl_setopt($ch,CURLOPT_USERAGENT,$_SERVER['HTTP_USER_AGENT']);
	curl_setopt($ch,CURLOPT_FOLLOWLOCATION, 0);
	curl_setopt($ch, CURLOPT_TIMEOUT, 90);

	$ret = curl_exec($ch);
	curl_close($ch);

	if ($dbg) {
	fwrite($log, "\n".$ret);
	fclose($log);
	}

	return $ret;
	}
	}

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

	function &ref_call_user_func_array($callable, $args)
	{
	if( is_scalar($callable) )
	{
	// $callable is the name of a function
	$call = $callable;
	}
	else
	{
	if( is_object($callable[0]) )
	{
	// $callable is an object and a method name
	$call = "\$callable[0]->{$callable[1]}";
	}
	else
	{
	// $callable is a class name and a static method
	$call = "{$callable[0]}::{$callable[1]}";
	}
	}

	// Note because the keys in $args might be strings
	// we do this in a slightly round about way.
	$argumentString = Array();
	$argumentKeys = array_keys($args);
	foreach($argumentKeys as $argK)
	{
	$argumentString[] = "\$args[$argumentKeys[$argK]]";
	}
	$argumentString = implode($argumentString, ', ');
	// Note also that eval doesn't return references, so we
	// work around it in this way...
	eval("\$result =& {$call}({$argumentString});");
	return $result;
	}

	/**
	* Checks if constant is defined and has positive value
	*
	* @param string $const_name
	* @return bool
	*/
	function constOn($const_name)
	{
	return defined($const_name) && constant($const_name);
	}

	function Kg2Pounds($kg)
	{
	$major = floor( round($kg / POUND_TO_KG, 3) );
	$minor = abs(round(($kg - $major * POUND_TO_KG) / POUND_TO_KG * 16, 2));
	return array($major, $minor);
	}

	function Pounds2Kg($pounds, $ounces=0)
	{
	return round(($pounds + ($ounces / 16)) * POUND_TO_KG, 5);
	}

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

	/**
	* Enter description here...
	*
	* @param resource $filePointer the file resource to write to
	* @param Array $data the data to write out
	* @param string $delimiter the field separator
	* @param string $enclosure symbol to enclose field data to
	* @param string $recordSeparator symbols to separate records with
	*/
	function fputcsv2($filePointer, $data, $delimiter = ',', $enclosure = '"', $recordSeparator = "\r\n")
	{
	foreach($data as $field_index => $field_value) {
	// replaces an enclosure with two enclosures
	$data[$field_index] = str_replace($enclosure, $enclosure.$enclosure, $field_value);
	}

	$line = $enclosure.implode($enclosure.$delimiter.$enclosure, $data).$enclosure.$recordSeparator;
	fwrite($filePointer, $line);
	}

	/**
	* Allows to replace #section# within any string with current section
	*
	* @param string $string
	* @return string
	*/
	function replaceModuleSection($string)
	{
	$application =& kApplication::Instance();
	$module_section = $application->RecallVar('section');
	if ($module_section) {
	// substitute section instead of #section# parameter in title preset name
	$module_section = explode(':', $module_section);
	$string = str_replace('#section#', strtolower($module_section[1]), $string);
	}
	return $string;
	}

	?>
	\ No newline at end of file

	Property changes on: trunk/core/kernel/globals.php
	___________________________________________________________________
	Modified: cvs2svn:cvs-rev
	## -1 +1 ##
	-1.23
	\ No newline at end of property
	+1.24
	\ No newline at end of property
	Index: trunk/core/units/general/xml_helper.php
	===================================================================
	--- trunk/core/units/general/xml_helper.php (revision 4417)
	+++ trunk/core/units/general/xml_helper.php (revision 4418)
	@@ -1,136 +1,199 @@
	<?php

	class kXMLHelper extends kHelper {
	var $RootElement = null;

	/**
	* Enter description here...
	*
	* @var kXMLNode
	*/
	var $CurrentElement = null;

	+ /**
	+ * Parses XML data specified and returns root node
	+ *
	+ * @param string $xml
	+ * @return kXMLNode
	+ */
	function &Parse($xml = null)
	{
	$xml_parser = xml_parser_create();
	xml_set_element_handler( $xml_parser, Array(&$this, 'startElement'), Array(&$this, 'endElement') );
	xml_set_character_data_handler( $xml_parser, Array(&$this, 'characterData') );
	if (!xml_parse($xml_parser, $xml, 1)) {
	trigger_error(sprintf('XML error: %s at line %d'),
	xml_error_string(xml_get_error_code($xml_parser)),
	xml_get_current_line_number($xml_parser), E_USER_WARNING);
	}
	xml_parser_free($xml_parser);
	return $this->RootElement;
	}

	function startElement(&$Parser, &$Elem, $Attrs)
	{
	$parent =& $this->CurrentElement;
	$this->CurrentElement =& new kXMLNode($Elem, $Attrs);
	if (is_null($this->RootElement)) {
	$this->RootElement =& $this->CurrentElement;
	}
	if (!is_null($parent)) {
	$parent->AddChild($this->CurrentElement);
	}
	}

	function characterData($Parser, $Line)
	{
	$this->CurrentElement->AppendData($Line);
	}

	function endElement($Parser, $Elem)
	{
	if ($this->CurrentElement->Parent != null) {
	$this->CurrentElement =& $this->CurrentElement->Parent;
	}
	}

	function Clear()
	{
	$this->RootElement = null;
	$this->CurrentElement = null;
	}
	}

	class kXMLNode {
	var $Name = null;
	var $Attributes = array();
	var $Children = array();
	var $Data = null;
	+
	+ var $firstChild = null;
	+ var $lastChild = null;
	+ /**
	+ * Parent node
	+ *
	+ * @var kXMLNode
	+ */
	var $Parent = null;
	-
	+ /**
	+ * Node position relative to other nodes of it's parent
	+ *
	+ * @var int
	+ */
	+ var $Position = 0;
	+
	function kXMLNode($name, $attrs = array())
	{
	$this->Name = $name;
	$this->Attributes = $attrs;
	}

	function SetParent(&$elem)
	{
	$this->Parent =& $elem;
	}

	+ /**
	+ * Adds new child to current node
	+ *
	+ * @param kXMLNode $a_child
	+ */
	function AddChild(&$a_child)
	{
	+ $node_count = count($this->Children);
	+ $a_child->Position = $node_count;
	+
	+ if ($node_count == 0) {
	+ $this->firstChild =& $a_child;
	+ $this->lastChild =& $a_child;
	+ }
	+ else {
	+ $this->lastChild =& $a_child;
	+ }
	+
	$this->Children[] =& $a_child;
	$a_child->SetParent($this);
	}

	function AppendData($data)
	{
	$this->Data .= $data;
	}

	function &GetChild($path)
	{
	$entries = explode('/', strtoupper($path));
	$cur = array_shift($entries);
	if ($cur == $this->Name) $cur = array_shift($entries);
	if (!$cur) return $this;
	if (!isset($this->Children[$cur])) return false;
	$left = implode('/', $entries);
	if (!$left) return $this->Children[$cur];
	return $this->Children[$cur]->GetChild($left);
	}

	function GetChildValue($path)
	{
	$child =& $this->GetChild($path);
	if ($child !== false) {
	return $child->Data;
	}
	}

	+ function &GetChildByPosition($position)
	+ {
	+ if ($position < count($this->Children) ) {
	+ return $this->Children[$position];
	+ }
	+ else {
	+ $false = false;
	+ return $false;
	+ }
	+ }
	+
	function &FindChild($name)
	{
	$name = strtoupper($name);
	if ($this->Name == $name) return $this;
	// if (isset($this->Children[$name])) return $this->Children[$name];
	// $children = array_keys($this->Children);
	foreach ($this->Children as $elem)
	{
	$child =& $elem->FindChild($name);
	if ($child !== false)
	{
	return $child;
	}
	}
	return false;
	}

	function FindChildValue($name, $attr=null)
	{
	$child =& $this->FindChild($name);
	if ($child !== false) {
	if (isset($attr)) {
	return $child->Attributes[strtoupper($attr)];
	}
	return $child->Data;
	}
	}
	+
	+ /**
	+ * Returns next node to this, false in case of end list
	+ *
	+ * @return kXMLNode
	+ */
	+ function &NextSibling()
	+ {
	+ if (!is_null($this->Parent)) {
	+ return $this->Parent->GetChildByPosition($this->Position + 1);
	+ }
	+ else {
	+ $false = false;
	+ return $false;
	+ }
	+ }
	}

	?>
	\ No newline at end of file

	Property changes on: trunk/core/units/general/xml_helper.php
	___________________________________________________________________
	Modified: cvs2svn:cvs-rev
	## -1 +1 ##
	-1.2
	\ No newline at end of property
	+1.3
	\ No newline at end of property

in-portalNo OneTemporaryActions

File Metadata

in-portalView Options

Event Timeline

in-portal
No OneTemporary
Actions

in-portal
View Options