in-portal
No OneTemporary
Actions

Subscribers

None

File Metadata

Created: Tue, Sep 23, 1:14 PM

in-portal
View Options

	Index: trunk/kernel/units/images/images_config.php
	===================================================================
	--- trunk/kernel/units/images/images_config.php (revision 4898)
	+++ trunk/kernel/units/images/images_config.php (revision 4899)
	@@ -1,160 +1,140 @@
	<?php

	$config = Array(
	'Prefix' => 'img',
	'Clones' => Array(
	'l-img' => Array('ParentPrefix' => 'l'),
	'n-img' => Array('ParentPrefix' => 'n'),
	'bb-img'=> Array('ParentPrefix' => 'bb'),
	/'p-img' => Array('ParentPrefix' => 'p'),/
	-
	- 'catimg' => Array(
	- 'ParentPrefix' => 'c',
	- 'AggregateTags' => Array(
	- Array(
	- 'AggregateTo' => 'c',
	- 'AggregatedTagName' => 'Image',
	- 'LocalTagName' => 'ItemImage',
	- ),
	- Array(
	- 'AggregateTo' => 'c',
	- 'AggregatedTagName' => 'ListImages',
	- 'LocalTagName' => 'PrintList2',
	- 'LocalSpecial' => 'list',
	- ),
	- Array(
	- 'AggregateTo' => 'c',
	- 'AggregatedTagName' => 'LargeImageExists',
	- 'LocalTagName' => 'LargeImageExists',
	- ),
	- ),
	- )
	- ),
	+ 'catimg' => Array('ParentPrefix' => 'c'),
	+ ),
	+
	'ItemClass' => Array('class'=>'kDBItem','file'=>'','build_event'=>'OnItemBuild'),
	'ListClass' => Array('class'=>'kDBList','file'=>'','build_event'=>'OnListBuild'),
	'EventHandlerClass' => Array('class'=>'ImageEventHandler','file'=>'image_event_handler.php','build_event'=>'OnBuild'),
	'TagProcessorClass' => Array('class'=>'ImageTagProcessor','file'=>'image_tag_processor.php','build_event'=>'OnBuild'),
	'AutoLoad' => true,
	- 'hooks' => Array(),
	+
	'AggregateTags' => Array(
	- Array(
	- 'AggregateTo' => 'p',
	- 'AggregatedTagName' => 'Image',
	- 'LocalTagName' => 'ItemImage',
	- ),
	- Array(
	- 'AggregateTo' => 'p',
	- 'AggregatedTagName' => 'ListImages',
	- 'LocalTagName' => 'PrintList2',
	- 'LocalSpecial' => 'list',
	- ),
	- Array(
	- 'AggregateTo' => 'p',
	- 'AggregatedTagName' => 'LargeImageExists',
	- 'LocalTagName' => 'LargeImageExists',
	- ),
	-
	- ),
	+ Array(
	+ 'AggregateTo' => '#PARENT#',
	+ 'AggregatedTagName' => 'Image',
	+ 'LocalTagName' => 'ItemImage',
	+ ),
	+ Array(
	+ 'AggregateTo' => '#PARENT#',
	+ 'AggregatedTagName' => 'ListImages',
	+ 'LocalTagName' => 'PrintList2',
	+ 'LocalSpecial' => 'list',
	+ ),
	+ Array(
	+ 'AggregateTo' => '#PARENT#',
	+ 'AggregatedTagName' => 'LargeImageExists',
	+ 'LocalTagName' => 'LargeImageExists',
	+ ),
	+ ),
	+
	'QueryString' => Array(
	1 => 'id',
	2 => 'page',
	3 => 'event',
	),
	'IDField' => 'ImageId',
	'StatusField' => Array('Enabled', 'DefaultImg'), // field, that is affected by Approve/Decline events
	'TitleField' => 'Name', // field, used in bluebar when editing existing item
	'TableName' => TABLE_PREFIX.'Images',
	'ParentTableKey'=> 'ResourceId', // linked field in master table
	'ForeignKey' => 'ResourceId', // linked field in subtable
	'ParentPrefix' => 'p',
	'AutoDelete' => true,
	'AutoClone' => true,

	'FilterMenu' => Array(
	'Groups' => Array(
	Array('mode' => 'AND', 'filters' => Array('show_active','show_disabled'), 'type' => WHERE_FILTER),
	),
	'Filters' => Array(
	'show_active' => Array('label' =>'la_Active', 'on_sql' => '', 'off_sql' => 'Enabled != 1' ),
	'show_disabled' => Array('label' => 'la_Disabled', 'on_sql' => '', 'off_sql' => 'Enabled != 0' ),
	)
	),

	'CalculatedFields' => Array(
	'' => Array(
	'Preview' => '0',
	),
	),

	'ListSQLs' => Array( ''=>'SELECT * FROM %s',
	), // key - special, value - list select sql
	'ItemSQLs' => Array( ''=>'SELECT * FROM %s',
	),
	'ListSortings' => Array(
	'' => Array(
	'ForcedSorting' => Array('Priority' => 'desc'),
	'Sorting' => Array('Name' => 'asc'),
	)
	),
	'Fields' => Array(
	'ImageId' => Array('type'=>'int'),
	'ResourceId' => Array('type'=>'int', 'not_null'=>1, 'default' => 0),
	'Url' => Array('max_len'=>255, 'default' => '', 'not_null'=>1),
	'Name' => Array('max_len'=>255, 'required'=>1, 'not_null'=>1, 'default' => ''),
	'AltName' => Array('max_len'=>255, 'required'=>1, 'not_null'=>1),
	'ImageIndex' => Array('type'=>'int', 'default' => 0, 'not_null'=>1),
	'LocalImage' => Array('type'=>'int', 'default' => 1, 'not_null'=>1),
	'LocalPath' => Array('formatter'=>'kPictureFormatter', 'skip_empty'=>1, 'max_len'=>240, 'default' => '', 'not_null' => 1, 'include_path' => 1,
	'allowed_types' => Array(
	0 => 'image/jpeg',
	1 => 'image/pjpeg',
	2 => 'image/png',
	3 => 'image/gif',
	4 => 'image/bmp'
	),
	'error_msgs' => Array( 'bad_file_format' => '!la_error_InvalidFileFormat!',
	'bad_file_size' => '!la_error_FileTooLarge!',
	'cant_save_file' => '!la_error_cant_save_file!'
	)
	),
	'Enabled' => Array('formatter'=>'kOptionsFormatter', 'use_phrases' => 1, 'options' => Array ( 1 => 'la_Enabled', 0 => 'la_Disabled' ), 'default' => 0, 'not_null'=>1),
	'DefaultImg' => Array('type'=>'int', 'default' => 0, 'not_null'=>1),
	'ThumbUrl' => Array('max_len' => 255),
	'Priority' => Array('type'=>'int', 'default' => 0, 'not_null'=>1),
	'ThumbPath' => Array( 'formatter'=>'kPictureFormatter', 'skip_empty'=>1, 'max_len' => 255,
	'allowed_types' => Array(
	0 => 'image/jpeg',
	1 => 'image/pjpeg',
	2 => 'image/png',
	3 => 'image/gif',
	4 => 'image/bmp'
	),
	'error_msgs' => Array( 'bad_file_format' => '!la_error_InvalidFileFormat!',
	'bad_file_size' => '!la_error_FileTooLarge!',
	'cant_save_file' => '!la_error_cant_save_file!'
	)
	),
	'LocalThumb' => Array('type'=>'int', 'default' => 1, 'not_null'=>1),
	'SameImages' => Array('type'=>'int', 'default' => 1, 'not_null'=>1),
	),
	'VirtualFields' => Array(
	'Preview' => Array(),
	'ImageUrl' => Array(),
	),

	'Grids' => Array(
	'Default' => Array(
	'Icons' => Array('default'=>'icon17_custom.gif','1_0'=>'icon16_image.gif','0_0'=>'icon16_image_disabled.gif','1_1'=>'icon16_image_primary.gif'),
	'Fields' => Array(
	'Name' => Array( 'title'=>'la_col_ImageName' , 'data_block' => 'image_caption_td'),
	'AltName' => Array( 'title'=>'la_col_AltName' ),
	'Url' => Array( 'title'=>'la_col_ImageUrl', 'data_block' => 'image_url_td' ),
	'Enabled' => Array( 'title'=>'la_col_ImageEnabled' ),
	'Preview' => Array( 'title'=>'la_col_Preview', 'data_block' => 'image_preview_td' ),
	),

	),
	),
	);

	?>
	\ No newline at end of file

	Property changes on: trunk/kernel/units/images/images_config.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/unit_config_reader.php
	===================================================================
	--- trunk/core/kernel/utility/unit_config_reader.php (revision 4898)
	+++ trunk/core/kernel/utility/unit_config_reader.php (revision 4899)
	@@ -1,621 +1,630 @@
	<?php

	class kUnitConfigReader extends kBase {

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

	var $CacheExpired = false;

	var $prefixFiles = array();

	var $ProcessAllConfigs = false;
	var $FinalStage = false;

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

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

	$config_vars = Array(
	'SessionTimeout',
	'SessionCookieName',
	'SessionReferrerCheck',
	'CookieSessions',
	'UseCronForRegularEvent',
	'User_GuestGroup',
	'User_LoggedInGroup',
	'SessionTimeout',
	'UseModRewrite',
	'AdminDirectory',
	);

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

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

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

	$conn =& $this->Application->GetADODBConnection();
	$conn->Query('REPLACE '.TABLE_PREFIX.'Cache (VarName, Data, Cached) VALUES ("configs_parsed", '.$conn->qstr(serialize($cache)).', '.adodb_mktime().')');
	}

	function RestoreParsedData()
	{
	$conn =& $this->Application->GetADODBConnection();
	$data = $conn->GetRow('SELECT Data, Cached FROM '.TABLE_PREFIX.'Cache WHERE VarName = "configs_parsed"');
	if ($data && $data['Cached'] > 0 ) {
	$cache = unserialize($data['Data']);
	$this->Application->Factory->Files = $cache['Factory.Files'];
	$this->Application->Factory->realClasses = $cache['Factory.realClasses'];
	$this->Application->Factory->Dependencies = $cache['Factory.Dependencies'];
	$this->prefixFiles = $cache['ConfigReader.prefixFiles'];

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

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

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

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

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

	return true;

	}
	else return false;
	}

	function ResetParsedData($include_sections = false)
	{
	$conn =& $this->Application->GetADODBConnection();
	$conn->Query('DELETE FROM '.TABLE_PREFIX.'Cache WHERE VarName = "configs_parsed"');

	if ($include_sections) {
	$conn->Query('DELETE FROM '.TABLE_PREFIX.'Cache WHERE VarName = "sections_parsed"');
	}
	}

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

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

	$this->ProcessAllConfigs = true;

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

	if ($cache) {
	$this->CacheParsedData();
	$conn =& $this->Application->GetADODBConnection();
	$conn->Query('REPLACE '.TABLE_PREFIX.'Cache (VarName, Data, Cached) VALUES ("config_files", '.$conn->qstr(serialize($this->configFiles)).', '.adodb_mktime().')');
	}

	unset($this->configFiles);
	}

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

	$fh = opendir(FULL_PATH.$folderPath);
	while (($sub_folder = readdir($fh))) {
	$full_path = FULL_PATH.$folderPath.'/'.$sub_folder;
	if ($this->isDir($full_path)) {
	if (file_exists(FULL_PATH.$this->getConfigName($folderPath.'/'.$sub_folder))) {
	$this->configFiles[] = $this->getConfigName($folderPath.'/'.$sub_folder);
	}
	$this->findConfigFiles($full_path);

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

	}
	}
	}

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

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

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

	/**
	* Process all read config files - called ONLY when there is no cache!
	*
	*/
	function ParseConfigs()
	{
	foreach ($this->configData as $prefix => $config) {
	$this->parseConfig($prefix);
	}

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

	function AfterConfigRead()
	{
	// if (!$this->ProcessAllConfigs) return ;
	$this->FinalStage = true;
	foreach ($this->configData as $prefix => $config) {
	$this->Application->HandleEvent( new kEvent($prefix.':OnAfterConfigRead') );
	}
	}

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

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

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

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

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

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

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

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

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

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

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

	if ( $this->Application->isDebugMode() && 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);
	}
	}

	}
	}
	}
	}
	}

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

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

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

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

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

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

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

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

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

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

	preg_match('/\/(.*)\//U', $filename, $rets);
	$config['ModuleFolder'] = $rets[1];
	$config['BasePath'] = dirname(FULL_PATH.$filename);
	$this->configData[$prefix] = $config;
	$this->prefixFiles[$prefix] = $filename;
	return $prefix;
	}
	elseif ($prefix = array_search($filename, $this->prefixFiles)) {
	// attempt is made to include config file twice or more, but include_once prevents that,
	// but file exists on hdd, then it is already saved to all required arrays, just return it's prefix
	return $prefix;
	}
	}
	return 'dummy';
	}

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

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

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

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

	}

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

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

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

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

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

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

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



	}


	?>
	\ No newline at end of file

	Property changes on: trunk/core/kernel/utility/unit_config_reader.php
	___________________________________________________________________
	Modified: cvs2svn:cvs-rev
	## -1 +1 ##
	-1.54
	\ No newline at end of property
	+1.55
	\ No newline at end of property
	Index: trunk/core/kernel/db/dblist.php
	===================================================================
	--- trunk/core/kernel/db/dblist.php (revision 4898)
	+++ trunk/core/kernel/db/dblist.php (revision 4899)
	@@ -1,792 +1,791 @@
	<?php

	/**
	* System Having/Where filter
	*
	*/
	define('FLT_SYSTEM', 1);

	/**
	* User Having/Where filter
	*
	*/
	define('FLT_NORMAL', 2);

	/**
	* User "Search" Having/Where filter
	*
	*/
	define('FLT_SEARCH', 3);

	/**
	* User "View Menu" Having/Where filter
	*
	*/
	define('FLT_VIEW', 4);

	/**
	* DBList
	*
	* Desciption
	* @package kernel4
	*/
	class kDBList extends kDBBase {


	/**
	* Holds totals for fields specified in config
	*
	* @var Array
	*/
	var $Totals = Array();

	/**
	* Description
	*
	* @var array
	* @access public
	*/
	var $OrderFields;

	/**
	* Holds counted total number of records in the query - without pagination (system+user filters)
	*
	* @var int
	* @access public
	*/
	var $RecordsCount;


	/**
	* Records count with system filters only applied
	*
	* @var int
	* @access private
	*/
	var $NoFilterCount = 0;

	/**
	* Record count selected to be
	* showed on current page
	*
	* @var int
	*/
	var $SelectedCount=0;

	/**
	* Array of records selected
	*
	* @var Array
	* @access private
	*/
	var $Records;

	var $CurrentIndex = 0;

	/**
	* List items per-page
	*
	* @var int
	* @access public
	*/
	var $PerPage;

	/**
	* Pages count in list based on PerPage & RecordsCount attributes
	*
	* @var int
	* @access public
	*/
	var $TotalPages;

	/**
	* Description
	*
	* @var int
	* @access public
	*/

	var $Direction;
	/**
	* Holds current page number - used when forming LIMIT clause of SELECT statement
	*
	* @var int
	* @access public
	*/
	var $Page;

	/**
	* Holds offset for LIMIT clause, calculated in {@link kDBList::PerPage()}
	*
	* @var int
	* @access private
	*/
	var $Offset;

	/**
	* Count SQL was already issued on query
	*
	* @var bool
	* @access private
	*/
	var $hasCounted = false;

	/**
	* Holds list WHERE filter object
	*
	* @var kMultipleFilter
	* @access private
	*/
	var $WhereFilter = Array(FLT_SYSTEM => null, FLT_NORMAL => null, FLT_SEARCH => null, FLT_VIEW => null);

	/**
	* Holds list HAVING filter object
	*
	* @var kMultipleFilter
	* @access private
	*/
	var $HavingFilter = Array(FLT_SYSTEM => null, FLT_NORMAL => null, FLT_SEARCH => null, FLT_VIEW => null);

	var $AggregateFilter = Array(FLT_SYSTEM => null, FLT_NORMAL => null);

	var $GroupByFields = Array();

	var $Queried = false;
	var $Counted = false;

	/**
	* Creates kDBList
	*
	* @return kDBList
	*/
	function kDBList()
	{
	parent::kDBBase();
	$this->OrderFields = Array();

	$this->WhereFilter[FLT_SYSTEM] =& $this->Application->makeClass('kMultipleFilter', FLT_TYPE_AND);
	$this->WhereFilter[FLT_NORMAL] =& $this->Application->makeClass('kMultipleFilter', FLT_TYPE_OR);

	$this->WhereFilter[FLT_SEARCH] =& $this->Application->makeClass('kMultipleFilter', FLT_TYPE_OR);
	$this->WhereFilter[FLT_VIEW] =& $this->Application->makeClass('kMultipleFilter', FLT_TYPE_AND);

	$this->HavingFilter[FLT_SYSTEM] =& $this->Application->makeClass('kMultipleFilter', FLT_TYPE_AND);
	$this->HavingFilter[FLT_NORMAL] =& $this->Application->makeClass('kMultipleFilter', FLT_TYPE_OR);

	$this->HavingFilter[FLT_SEARCH] =& $this->Application->makeClass('kMultipleFilter', FLT_TYPE_OR);
	$this->HavingFilter[FLT_VIEW] =& $this->Application->makeClass('kMultipleFilter', FLT_TYPE_AND);

	$this->AggregateFilter[FLT_SYSTEM] =& $this->Application->makeClass('kMultipleFilter', FLT_TYPE_AND);
	$this->AggregateFilter[FLT_NORMAL] =& $this->Application->makeClass('kMultipleFilter', FLT_TYPE_OR);

	$this->PerPage = -1;
	}

	/**
	* Adds new or replaces old filter with same name
	*
	* @param string $name filter name (for internal use)
	* @param string $clause where/having clause part (no OR/AND allowed)
	* @param int $filter_type is filter having filter or where filter
	* @param int $filter_scope filter subtype: FLT_NORMAL,FLT_SYSTEM,FLT_SEARCH,FLT_VIEW
	* @access public
	*/
	function addFilter($name, $clause, $filter_type = WHERE_FILTER, $filter_scope = FLT_SYSTEM)
	{
	$filter_source = Array( WHERE_FILTER => 'WhereFilter',
	HAVING_FILTER => 'HavingFilter',
	AGGREGATE_FILTER => 'AggregateFilter');
	$filter_name = $filter_source[$filter_type];

	$filter =& $this->$filter_name;
	$filter =& $filter[$filter_scope];
	$filter->addFilter($name,$clause);
	}

	/**
	* Removes specified filter from filters list
	*
	* @param string $name filter name (for internal use)
	* @param int $filter_type is filter having filter or where filter
	* @param int $filter_scope filter subtype: FLT_NORMAL,FLT_SYSTEM,FLT_SEARCH,FLT_VIEW
	* @access public
	*/
	function removeFilter($name, $filter_type = WHERE_FILTER, $filter_scope = FLT_SYSTEM)
	{
	$filter_source = Array( WHERE_FILTER => 'WhereFilter',
	HAVING_FILTER => 'HavingFilter',
	AGGREGATE_FILTER => 'AggregateFilter');
	$filter_name = $filter_source[$filter_type];

	$filter =& $this->$filter_name;
	$filter =& $filter[$filter_scope];
	$filter->removeFilter($name);
	}

	/**
	* Clear list filters
	*
	* @param bool $user clear user filters
	* @param bool $system clear system filters
	*/
	function clearFilters($user=true,$system=true,$search=true,$view=true)
	{
	if ($system) {
	$this->WhereFilter[FLT_SYSTEM]->clearFilters();
	$this->HavingFilter[FLT_SYSTEM]->clearFilters();
	$this->AggregateFilter[FLT_SYSTEM]->clearFilters();
	}

	if ($user) {
	$this->WhereFilter[FLT_NORMAL]->clearFilters();
	$this->HavingFilter[FLT_NORMAL]->clearFilters();
	$this->AggregateFilter[FLT_NORMAL]->clearFilters();
	}

	if ($search) {
	$this->WhereFilter[FLT_SEARCH]->clearFilters();
	$this->HavingFilter[FLT_SEARCH]->clearFilters();
	}

	if ($view) {
	$this->WhereFilter[FLT_VIEW]->clearFilters();
	$this->HavingFilter[FLT_VIEW]->clearFilters();
	}
	}

	/**
	* Counts the total number of records base on the query resulted from {@link kDBList::GetSelectSQL()}
	*
	* The method modifies the query to substitude SELECT part (fields listing) with COUNT(*).
	* Special care should be applied when working with lists based on grouped queries, all aggregate function fields
	* like SUM(), AVERAGE() etc. should be added to CountedSQL by using {@link kDBList::SetCountedSQL()}
	*
	* @access public
	* @param string
	* @return void
	*/
	function CountRecs()
	{
	$all_sql = $this->GetSelectSQL(true,false);
	$sql = $this->getCountSQL($all_sql);

	if( $this->GetGroupClause() )
	{
	$this->RecordsCount = count( $this->Conn->GetCol($sql) );
	}
	else
	{
	$this->RecordsCount = (int)$this->Conn->GetOne($sql);
	}

	$system_sql = $this->GetSelectSQL(true,true);
	if($system_sql == $all_sql) //no need to query the same again
	{
	$this->NoFilterCount = $this->RecordsCount;
	return;
	}

	$sql = $this->getCountSQL($system_sql);
	if( $this->GetGroupClause() )
	{
	$this->NoFilterCount = count( $this->Conn->GetCol($sql) );
	}
	else
	{
	$this->NoFilterCount = (int)$this->Conn->GetOne($sql);
	}

	$this->Counted = true;
	}

	function getCountSQL($sql)
	{
	if ( preg_match("/DISTINCT(.*?)FROM(?!_)/is",$sql,$regs ) )
	{
	return preg_replace("/^.SELECT DISTINCT(.?)FROM(?!_)/is", "SELECT COUNT(DISTINCT ".$regs[1].") AS count FROM", $sql);
	}
	else
	{
	return preg_replace("/^.SELECT(.?)FROM(?!_)/is", "SELECT COUNT(*) AS count FROM ", $sql);
	}
	}

	/**
	* Queries the database with SQL resulted from {@link kDBList::GetSelectSQL()} and stores result in {@link kDBList::SelectRS}
	*
	* All the sorting, pagination, filtration of the list should be set prior to calling Query().
	*
	* @access public
	* @param string
	* @return void
	*/
	function Query($force=false)
	{
	if (!$force && $this->Queried) return true;
	$q = $this->GetSelectSQL();

	//$rs = $this->Conn->SelectLimit($q, $this->PerPage, $this->Offset);

	//in case we have not counted records try to select one more item to find out if we have something more than perpage
	$limit = $this->Counted ? $this->PerPage : $this->PerPage+1;

	$sql = $q.' '.$this->Conn->getLimitClause($this->Offset,$limit);

	$this->Records = $this->Conn->Query($sql);
	$this->SelectedCount = count($this->Records);
	if (!$this->Counted) $this->RecordsCount = $this->SelectedCount;
	if (!$this->Counted && $this->SelectedCount > $this->PerPage && $this->PerPage != -1) $this->SelectedCount--;

	if ($this->Records === false) {
	//handle errors here
	return false;
	}
	$this->Queried = true;
	return true;
	}

	function CalculateTotals()
	{
	$this->Totals = Array();

	$fields = Array();
	foreach($this->Fields as $field_name => $field_options)
	{
	$totals = getArrayValue($field_options, 'totals');
	if(!$totals) continue;

	$calculated_field = isset($this->CalculatedFields[$field_name]) && isset($this->VirtualFields[$field_name]);
	$db_field = !isset($this->VirtualFields[$field_name]);

	if($calculated_field \|\| $db_field)
	{
	$field_expression = $calculated_field ? $this->CalculatedFields[$field_name] : '`'.$this->TableName.'`.`'.$field_name.'`';
	$fields[$field_name] = $totals.'('.$field_expression.') AS '.$field_name.'_'.$totals;
	}
	}

	if(!$fields) return false;

	$sql = $this->GetSelectSQL(true, false);
	$fields = implode(', ', $fields);

	if ( preg_match("/DISTINCT(.*?)FROM(?!_)/is",$sql,$regs ) )
	{
	$sql = preg_replace("/^.SELECT DISTINCT(.?)FROM(?!_)/is", 'SELECT '.$fields.' FROM', $sql);
	}
	else
	{
	$sql = preg_replace("/^.SELECT(.?)FROM(?!_)/is", 'SELECT '.$fields.' FROM ', $sql);
	}

	$totals = $this->Conn->Query($sql);

	foreach($totals as $totals_row)
	{
	foreach($totals_row as $total_field => $field_value)
	{
	if(!isset($this->Totals[$total_field])) $this->Totals[$total_field] = 0;
	$this->Totals[$total_field] += $field_value;
	}
	}
	}

	function getTotal($field, $total_function)
	{
	return $this->Totals[$field.'_'.$total_function];
	}

	/**
	* Builds full select query except for LIMIT clause
	*
	* @access public
	* @return string
	*/
	function GetSelectSQL($for_counting=false,$system_filters_only=false)
	{
	$q = parent::GetSelectSQL($this->SelectClause);
	$q = !$for_counting ? $this->addCalculatedFields($q, 0) : str_replace('%2$s', '', $q);

	$where = $this->GetWhereClause($for_counting,$system_filters_only);
	$having = $this->GetHavingClause($for_counting,$system_filters_only);
	$order = $this->GetOrderClause();
	$group = $this->GetGroupClause();

	if (!empty($where)) $q .= ' WHERE ' . $where;
	if (!empty($group)) $q .= ' GROUP BY ' . $group;
	if (!empty($having)) $q .= ' HAVING ' . $having;
	if ( !$for_counting && !empty($order) ) $q .= ' ORDER BY ' . $order;

	return str_replace('%1$s',$this->TableName,$q);
	}

	/**
	* Enter description here...
	*
	* @param string $clause where clause to extract calculated fields from
	* @param int $aggregated 0 - having + aggregated, 1 - having only, 2 - aggregated only
	* @return string
	*/
	function extractCalculatedFields($clause, $aggregated = 1)
	{
	$fields = $this->getCalculatedFields($aggregated);
	if (is_array($fields) && count($fields) > 0) {
	foreach ($fields as $field_name => $field_expression) {
	$clause = preg_replace('/[`]{0,1}'.$field_name.'[`]{0,1}/', $field_expression, $clause);
	}
	}
	return $clause;
	}

	/**
	* Returns WHERE clause of the query
	*
	* @access public
	* @param bool $for_counting merge where filters with having filters + replace field names for having fields with their values
	* @return string
	*/
	function GetWhereClause($for_counting=false,$system_filters_only=false)
	{
	$where =& $this->Application->makeClass('kMultipleFilter');

	$where->addFilter('system_where', $this->WhereFilter[FLT_SYSTEM] );

	if (!$system_filters_only) {
	$where->addFilter('view_where', $this->WhereFilter[FLT_VIEW] );
	$search_w = $this->WhereFilter[FLT_SEARCH]->getSQL();
	if( $search_w \|\| $for_counting ) // move search_having to search_where in case search_where isset or we are counting
	{
	$search_h = $this->extractCalculatedFields( $this->HavingFilter[FLT_SEARCH]->getSQL() );
	$search_w = ($search_w && $search_h) ? $search_w.' OR '.$search_h : $search_w.$search_h;
	$where->addFilter('search_where', $search_w );
	}
	}

	if( $for_counting ) // add system_having and view_having to where
	{
	$where->addFilter('system_having', $this->extractCalculatedFields($this->HavingFilter[FLT_SYSTEM]->getSQL()) );
	if (!$system_filters_only) $where->addFilter('view_having', $this->extractCalculatedFields( $this->HavingFilter[FLT_VIEW]->getSQL() ) );
	}

	return $where->getSQL();
	}

	/**
	* Depricated method
	*
	* @param string $clause
	* @todo REMOVE
	*/
	function SetWhereClause($clause)
	{
	if( $this->Application->isDebugMode() )
	{
	global $debugger;
	$debugger->appendTrace();
	}
	trigger_error('Depricated method <b>kDBList->SetWhereClause</b>. Use <b>kDBList->addFilter</b> instead.', E_USER_ERROR);
	}

	/**
	* Returns HAVING clause of the query
	*
	* @param bool $for_counting don't return having filter in case if this is counting sql
	* @param bool $system_filters_only return only system having filters
	* @param int $aggregated 0 - aggregated and having, 1 - having only, 2 - aggregated only
	* @return string
	* @access public
	*/
	function GetHavingClause($for_counting=false, $system_filters_only=false, $aggregated = 0)
	{
	if ($for_counting) {
	return $this->extractCalculatedFields($this->AggregateFilter[FLT_SYSTEM]->getSQL(), 2);
	}

	$having =& $this->Application->makeClass('kMultipleFilter');

	$having->addFilter('system_having', $this->HavingFilter[FLT_SYSTEM] );
	if ($aggregated == 0) {
	$having->addFilter('system_aggregated', $this->AggregateFilter[FLT_SYSTEM] );
	}

	if (!$system_filters_only) {
	$having->addFilter('view_having', $this->HavingFilter[FLT_VIEW] );
	$search_w = $this->WhereFilter[FLT_SEARCH]->getSQL();
	if (!$search_w) {
	$having->addFilter('search_having', $this->HavingFilter[FLT_SEARCH] );
	}
	}

	return $having->getSQL();
	}

	/**
	* Returns GROUP BY clause of the query
	*
	* @access public
	* @return string
	*/
	function GetGroupClause()
	{
	return $this->GroupByFields ? implode(',', $this->GroupByFields) : '';
	}

	function AddGroupByField($field)
	{
	$this->GroupByFields[$field] = $field;
	}

	function RemoveGroupByField($field)
	{
	unset($this->GroupByFields[$field]);
	}

	/**
	* Adds order field to ORDER BY clause
	*
	* @access public
	* @param string $field Field name
	* @param string $direction Direction of ordering (asc\|desc)
	* @return void
	*/
	function AddOrderField($field, $direction)
	{
	// original multilanguage field - convert to current lang field
	if (getArrayValue($this->Fields, $field, 'formatter') == 'kMultiLanguage' && !getArrayValue($this->Fields, $field, 'master_field')) {
	$lang = $this->Application->GetVar('m_lang');
	$field = 'l'.$lang.'_'.$field;
	}

	- if( !isset($this->Fields[$field]) )
	- {
	+ if (!isset($this->Fields[$field]) && ($field != 'RAND()')) {
	trigger_error('<span class="debug_error">Incorrect sorting</span> defined (field = <b>'.$field.'</b>; direction = <b>'.$direction.'</b>) in config for prefix <b>'.$this->Prefix.'</b>', E_USER_WARNING);
	}

	$this->OrderFields[] = Array($field, $direction);
	}

	/**
	* Removes all order fields
	*
	* @access public
	* @return void
	*/
	function ClearOrderFields()
	{
	$this->OrderFields = Array();
	}

	/**
	* Returns ORDER BY Clause of the query
	*
	* The method builds order by clause by iterating {@link kDBList::OrderFields} array and concatenating it.
	*
	* @access public
	* @return string
	*/
	function GetOrderClause()
	{
	$ret = '';
	foreach ($this->OrderFields as $field) {

	$name = $field[0];
	$ret .= isset($this->Fields[$name]) && !isset($this->VirtualFields[$name]) ? '`'.$this->TableName.'`.' : '';
	if ($field[0] == 'RAND()') {
	$ret .= $field[0].' '.$field[1].',';
	}
	else {
	$ret .= '`'.$field[0] . '` ' . $field[1] . ',';
	}
	}
	$ret = rtrim($ret, ',');
	return $ret;
	}

	function GetOrderField($pos=NULL)
	{
	if(!(isset($this->OrderFields[$pos]) && $this->OrderFields[$pos]) )
	{
	$pos = 0;
	}
	return isset($this->OrderFields[$pos][0]) ? $this->OrderFields[$pos][0] : '';
	}

	function GetOrderDirection($pos=NULL)
	{
	if( !getArrayValue($this->OrderFields, $pos) ) $pos = 0;
	return getArrayValue($this->OrderFields, $pos, 1);
	}

	/**
	* Return unformatted field value
	*
	* @param string
	* @return mixed
	* @access public
	*/
	function GetDBField($name)
	{
	$row =& $this->getCurrentRecord();
	return $row[$name];
	}

	function HasField($name)
	{
	$row =& $this->getCurrentRecord();
	return isset($row[$name]);
	}

	function GetFieldValues()
	{
	return $this->getCurrentRecord();
	}

	function &getCurrentRecord()
	{
	return $this->Records[$this->CurrentIndex];
	}

	/**
	* Description
	*
	* @access public
	* @param string
	* @return void
	*/
	function GoFirst()
	{
	$this->CurrentIndex = 0;
	}

	/**
	* Description
	*
	* @access public
	* @return void
	*/
	function GoNext()
	{
	$this->CurrentIndex++;
	}

	/**
	* Description
	*
	* @access public
	* @return void
	*/
	function GoPrev()
	{
	if ($this->CurrentIndex>0)
	$this->CurrentIndex--;
	}

	/**
	* Description
	*
	* @access public
	* @return bool
	*/
	function EOL()
	{
	return ($this->CurrentIndex >= $this->SelectedCount);
	}

	/**
	* Description
	*
	* @access public
	* @param string
	* @return void
	*/
	function GetTotalPages()
	{
	if (!$this->Counted) $this->CountRecs();
	if ($this->PerPage == -1) return 1;
	$this->TotalPages = (($this->RecordsCount - ($this->RecordsCount % $this->PerPage)) / $this->PerPage) // integer part of division
	+ (($this->RecordsCount % $this->PerPage) != 0); // adds 1 if there is a reminder
	return $this->TotalPages;
	}

	/**
	* Sets number of records to query per page
	*
	* @access public
	* @param int $per_page Number of records to display per page
	* @return void
	*/
	function SetPerPage($per_page)
	{
	$this->PerPage = $per_page;
	}

	function GetPerPage()
	{
	return $this->PerPage == -1 ? $this->RecordsCount : $this->PerPage;
	}

	/**
	* Description
	*
	* @access public
	* @param int $page
	* @return void
	*/
	function SetPage($page)
	{
	if ($this->PerPage == -1) {
	$this->Page = 1;
	return;
	}
	if ($page < 1) $page = 1;
	$this->Offset = ($page-1)*$this->PerPage;
	if ($this->Counted && $this->Offset > $this->RecordsCount) {
	$this->SetPage(1);
	}
	else {
	$this->Page = $page;
	}
	//$this->GoFirst();
	}

	/**
	* Sets current item field value
	* (doesn't apply formatting)
	*
	* @access public
	* @param string $name Name of the field
	* @param mixed $value Value to set the field to
	* @return void
	*/
	function SetDBField($name,$value)
	{
	$this->Records[$this->CurrentIndex][$name] = $value;
	}

	/**
	* Apply where clause, that links this object to it's parent item
	*
	* @param string $special
	* @access public
	*/
	function linkToParent($special)
	{
	$parent_prefix = $this->Application->getUnitOption($this->Prefix, 'ParentPrefix');
	if($parent_prefix)
	{
	$parent_table_key = $this->Application->getUnitOption($this->Prefix, 'ParentTableKey');
	if (is_array($parent_table_key)) $parent_table_key = getArrayValue($parent_table_key, $parent_prefix);
	$foreign_key_field = $this->Application->getUnitOption($this->Prefix, 'ForeignKey');
	if (is_array($foreign_key_field)) $foreign_key_field = getArrayValue($foreign_key_field, $parent_prefix);

	if (!$parent_table_key \|\| !$foreign_key_field) return ;

	$parent_object =& $this->Application->recallObject($parent_prefix.'.'.$special);
	$parent_id = $parent_object->GetDBField($parent_table_key);

	$this->addFilter('parent_filter', '`'.$this->TableName.'`.`'.$foreign_key_field.'` = '.$parent_id); // only for list in this case
	}
	}
	}

	?>
	\ No newline at end of file

	Property changes on: trunk/core/kernel/db/dblist.php
	___________________________________________________________________
	Modified: cvs2svn:cvs-rev
	## -1 +1 ##
	-1.16
	\ No newline at end of property
	+1.17
	\ No newline at end of property
	Index: trunk/core/units/images/images_config.php
	===================================================================
	--- trunk/core/units/images/images_config.php (revision 4898)
	+++ trunk/core/units/images/images_config.php (revision 4899)
	@@ -1,160 +1,140 @@
	<?php

	$config = Array(
	'Prefix' => 'img',
	'Clones' => Array(
	'l-img' => Array('ParentPrefix' => 'l'),
	'n-img' => Array('ParentPrefix' => 'n'),
	'bb-img'=> Array('ParentPrefix' => 'bb'),
	/'p-img' => Array('ParentPrefix' => 'p'),/
	-
	- 'catimg' => Array(
	- 'ParentPrefix' => 'c',
	- 'AggregateTags' => Array(
	- Array(
	- 'AggregateTo' => 'c',
	- 'AggregatedTagName' => 'Image',
	- 'LocalTagName' => 'ItemImage',
	- ),
	- Array(
	- 'AggregateTo' => 'c',
	- 'AggregatedTagName' => 'ListImages',
	- 'LocalTagName' => 'PrintList2',
	- 'LocalSpecial' => 'list',
	- ),
	- Array(
	- 'AggregateTo' => 'c',
	- 'AggregatedTagName' => 'LargeImageExists',
	- 'LocalTagName' => 'LargeImageExists',
	- ),
	- ),
	- )
	- ),
	+ 'catimg' => Array('ParentPrefix' => 'c'),
	+ ),
	+
	'ItemClass' => Array('class'=>'kDBItem','file'=>'','build_event'=>'OnItemBuild'),
	'ListClass' => Array('class'=>'kDBList','file'=>'','build_event'=>'OnListBuild'),
	'EventHandlerClass' => Array('class'=>'ImageEventHandler','file'=>'image_event_handler.php','build_event'=>'OnBuild'),
	'TagProcessorClass' => Array('class'=>'ImageTagProcessor','file'=>'image_tag_processor.php','build_event'=>'OnBuild'),
	'AutoLoad' => true,
	- 'hooks' => Array(),
	+
	'AggregateTags' => Array(
	- Array(
	- 'AggregateTo' => 'p',
	- 'AggregatedTagName' => 'Image',
	- 'LocalTagName' => 'ItemImage',
	- ),
	- Array(
	- 'AggregateTo' => 'p',
	- 'AggregatedTagName' => 'ListImages',
	- 'LocalTagName' => 'PrintList2',
	- 'LocalSpecial' => 'list',
	- ),
	- Array(
	- 'AggregateTo' => 'p',
	- 'AggregatedTagName' => 'LargeImageExists',
	- 'LocalTagName' => 'LargeImageExists',
	- ),
	-
	- ),
	+ Array(
	+ 'AggregateTo' => '#PARENT#',
	+ 'AggregatedTagName' => 'Image',
	+ 'LocalTagName' => 'ItemImage',
	+ ),
	+ Array(
	+ 'AggregateTo' => '#PARENT#',
	+ 'AggregatedTagName' => 'ListImages',
	+ 'LocalTagName' => 'PrintList2',
	+ 'LocalSpecial' => 'list',
	+ ),
	+ Array(
	+ 'AggregateTo' => '#PARENT#',
	+ 'AggregatedTagName' => 'LargeImageExists',
	+ 'LocalTagName' => 'LargeImageExists',
	+ ),
	+ ),
	+
	'QueryString' => Array(
	1 => 'id',
	2 => 'page',
	3 => 'event',
	),
	'IDField' => 'ImageId',
	'StatusField' => Array('Enabled', 'DefaultImg'), // field, that is affected by Approve/Decline events
	'TitleField' => 'Name', // field, used in bluebar when editing existing item
	'TableName' => TABLE_PREFIX.'Images',
	'ParentTableKey'=> 'ResourceId', // linked field in master table
	'ForeignKey' => 'ResourceId', // linked field in subtable
	'ParentPrefix' => 'p',
	'AutoDelete' => true,
	'AutoClone' => true,

	'FilterMenu' => Array(
	'Groups' => Array(
	Array('mode' => 'AND', 'filters' => Array('show_active','show_disabled'), 'type' => WHERE_FILTER),
	),
	'Filters' => Array(
	'show_active' => Array('label' =>'la_Active', 'on_sql' => '', 'off_sql' => 'Enabled != 1' ),
	'show_disabled' => Array('label' => 'la_Disabled', 'on_sql' => '', 'off_sql' => 'Enabled != 0' ),
	)
	),

	'CalculatedFields' => Array(
	'' => Array(
	'Preview' => '0',
	),
	),

	'ListSQLs' => Array( ''=>'SELECT * FROM %s',
	), // key - special, value - list select sql
	'ItemSQLs' => Array( ''=>'SELECT * FROM %s',
	),
	'ListSortings' => Array(
	'' => Array(
	'ForcedSorting' => Array('Priority' => 'desc'),
	'Sorting' => Array('Name' => 'asc'),
	)
	),
	'Fields' => Array(
	'ImageId' => Array('type'=>'int'),
	'ResourceId' => Array('type'=>'int', 'not_null'=>1, 'default' => 0),
	'Url' => Array('max_len'=>255, 'default' => '', 'not_null'=>1),
	'Name' => Array('max_len'=>255, 'required'=>1, 'not_null'=>1, 'default' => ''),
	'AltName' => Array('max_len'=>255, 'required'=>1, 'not_null'=>1),
	'ImageIndex' => Array('type'=>'int', 'default' => 0, 'not_null'=>1),
	'LocalImage' => Array('type'=>'int', 'default' => 1, 'not_null'=>1),
	'LocalPath' => Array('formatter'=>'kPictureFormatter', 'skip_empty'=>1, 'max_len'=>240, 'default' => '', 'not_null' => 1, 'include_path' => 1,
	'allowed_types' => Array(
	0 => 'image/jpeg',
	1 => 'image/pjpeg',
	2 => 'image/png',
	3 => 'image/gif',
	4 => 'image/bmp'
	),
	'error_msgs' => Array( 'bad_file_format' => '!la_error_InvalidFileFormat!',
	'bad_file_size' => '!la_error_FileTooLarge!',
	'cant_save_file' => '!la_error_cant_save_file!'
	)
	),
	'Enabled' => Array('formatter'=>'kOptionsFormatter', 'use_phrases' => 1, 'options' => Array ( 1 => 'la_Enabled', 0 => 'la_Disabled' ), 'default' => 0, 'not_null'=>1),
	'DefaultImg' => Array('type'=>'int', 'default' => 0, 'not_null'=>1),
	'ThumbUrl' => Array('max_len' => 255),
	'Priority' => Array('type'=>'int', 'default' => 0, 'not_null'=>1),
	'ThumbPath' => Array( 'formatter'=>'kPictureFormatter', 'skip_empty'=>1, 'max_len' => 255,
	'allowed_types' => Array(
	0 => 'image/jpeg',
	1 => 'image/pjpeg',
	2 => 'image/png',
	3 => 'image/gif',
	4 => 'image/bmp'
	),
	'error_msgs' => Array( 'bad_file_format' => '!la_error_InvalidFileFormat!',
	'bad_file_size' => '!la_error_FileTooLarge!',
	'cant_save_file' => '!la_error_cant_save_file!'
	)
	),
	'LocalThumb' => Array('type'=>'int', 'default' => 1, 'not_null'=>1),
	'SameImages' => Array('type'=>'int', 'default' => 1, 'not_null'=>1),
	),
	'VirtualFields' => Array(
	'Preview' => Array(),
	'ImageUrl' => Array(),
	),

	'Grids' => Array(
	'Default' => Array(
	'Icons' => Array('default'=>'icon17_custom.gif','1_0'=>'icon16_image.gif','0_0'=>'icon16_image_disabled.gif','1_1'=>'icon16_image_primary.gif'),
	'Fields' => Array(
	'Name' => Array( 'title'=>'la_col_ImageName' , 'data_block' => 'image_caption_td'),
	'AltName' => Array( 'title'=>'la_col_AltName' ),
	'Url' => Array( 'title'=>'la_col_ImageUrl', 'data_block' => 'image_url_td' ),
	'Enabled' => Array( 'title'=>'la_col_ImageEnabled' ),
	'Preview' => Array( 'title'=>'la_col_Preview', 'data_block' => 'image_preview_td' ),
	),

	),
	),
	);

	?>
	\ No newline at end of file

	Property changes on: trunk/core/units/images/images_config.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