in-portal
No OneTemporary
Actions

Subscribers

None

File Metadata

Created: Thu, Jun 19, 10:21 AM

in-portal
View Options

	Index: branches/unlabeled/unlabeled-1.28.2/core/units/languages/languages_event_handler.php
	===================================================================
	--- branches/unlabeled/unlabeled-1.28.2/core/units/languages/languages_event_handler.php (revision 7466)
	+++ branches/unlabeled/unlabeled-1.28.2/core/units/languages/languages_event_handler.php (revision 7467)
	@@ -1,459 +1,460 @@
	<?php

	class LanguagesEventHandler extends kDBEventHandler
	{
	/**
	* Allows to override standart permission mapping
	*
	*/
	function mapPermissions()
	{
	parent::mapPermissions();
	$permissions = Array(
	'OnChangeLanguage' => Array('self' => true),
	'OnSetPrimary' => Array('self' => 'advanced:set_primary\|add\|edit'),
	'OnImportLanguage' => Array('self' => 'advanced:import'),
	'OnImportProgress' => Array('self' => 'advanced:import'),
	'OnExportLanguage' => Array('self' => 'advanced:export'),
	'OnExportProgress' => Array('self' => 'advanced:export'),

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

	/**
	* Updates table structure on new language adding/removing language
	*
	* @param kEvent $event
	*/
	function OnReflectMultiLingualFields($event)
	{
	$ml_helper =& $this->Application->recallObject('kMultiLanguageHelper');

	$this->Application->UnitConfigReader->includeConfigFiles(MODULES_PATH); //make sure to re-read all configs
	+ $this->Application->UnitConfigReader->AfterConfigRead();
	foreach ($this->Application->UnitConfigReader->configData as $prefix => $config_data) {
	$ml_helper->createFields($prefix);
	}
	}

	/**
	* Allows to set selected language as primary
	*
	* @param kEvent $event
	*/
	function OnSetPrimary(&$event)
	{
	if ($this->Application->CheckPermission('SYSTEM_ACCESS.READONLY', 1)) {
	return;
	}

	$this->StoreSelectedIDs($event);
	$ids = $this->getSelectedIDs($event);
	if ($ids) {
	$id = array_shift($ids);
	$object =& $event->getObject( Array('skip_autoload' => true) );
	$object->Load($id);
	$object->setPrimary();
	}
	}

	/**
	* [HOOK] Reset primary status of other languages if we are saving primary language
	*
	* @param kEvent $event
	*/
	function OnUpdatePrimary(&$event)
	{
	$object =& $event->getObject( Array('skip_autoload' => true) );
	$object->SwitchToLive();

	// set primary for each languages, that have this checkbox checked
	$ids = explode(',', $event->MasterEvent->getEventParam('ids'));
	foreach ($ids as $id) {
	$object->Load($id);
	if ($object->GetDBField('PrimaryLang')) {
	$object->setPrimary();
	}

	}

	// if no primary language left, then set primary last language (not to load again) from edited list
	$sql = 'SELECT '.$object->IDField.'
	FROM '.$object->TableName.'
	WHERE PrimaryLang = 1';
	$primary_language = $this->Conn->GetOne($sql);

	if (!$primary_language) {
	$object->setPrimary(false);
	}
	}


	/**
	* Occurse before updating item
	*
	* @param kEvent $event
	* @access public
	*/
	function OnBeforeItemUpdate(&$event)
	{
	$object =& $event->getObject();
	$status_field = array_shift( $this->Application->getUnitOption($event->Prefix, 'StatusField') );

	if ($object->GetDBField('PrimaryLang') == 1 && $object->GetDBField($status_field) == 0) {
	$object->SetDBField($status_field, 1);
	}
	}

	/**
	* Shows only enabled languages on front
	*
	* @param kEvent $event
	*/
	function SetCustomQuery(&$event)
	{
	if($event->Special == 'enabled')
	{
	$object =& $event->getObject();
	$object->addFilter('enabled_filter', '%1$s.Enabled = 1');
	}
	}

	/**
	* Copy labels from another language
	*
	* @param kEvent $event
	*/
	function OnCopyLabels(&$event)
	{
	$object =& $event->getObject();
	$from_lang_id = $object->GetDBField('CopyFromLanguage');

	if( ($event->MasterEvent->status == erSUCCESS) && $object->GetDBField('CopyLabels') == 1 && ($from_lang_id > 0) )
	{
	$lang_id = $object->GetID();

	// 1. phrases import
	$phrases_live = $this->Application->getUnitOption('phrases','TableName');
	$phrases_temp = $this->Application->GetTempName($phrases_live, 'prefix:phrases');
	$sql = 'INSERT INTO '.$phrases_temp.'
	SELECT Phrase, Translation, PhraseType, 0-PhraseId, '.$lang_id.', '.adodb_mktime().', "", Module
	FROM '.$phrases_live.'
	WHERE LanguageId='.$from_lang_id;
	$this->Conn->Query($sql);

	// 2. events import
	$em_table_live = $this->Application->getUnitOption('emailmessages','TableName');
	$em_table_temp = $this->Application->GetTempName($em_table_live, 'prefix:emailmessages');

	$sql = 'SELECT * FROM '.$em_table_live.' WHERE LanguageId = '.$from_lang_id;
	$email_messages = $this->Conn->Query($sql);
	if($email_messages)
	{
	$id = $this->Conn->GetOne('SELECT MIN(EmailMessageId) FROM '.$em_table_live);
	if($id > 0) $id = 0;
	$id--;

	$sqls = Array();
	foreach($email_messages as $email_message)
	{
	$sqls[] = $id.','.$this->Conn->qstr($email_message['Template']).','.$this->Conn->qstr($email_message['MessageType']).','.$lang_id.','.$email_message['EventId'];
	$id--;
	}
	$sql = 'INSERT INTO '.$em_table_temp.'(EmailMessageId,Template,MessageType,LanguageId,EventId) VALUES ('.implode('),(',$sqls).')';
	$this->Conn->Query($sql);
	}

	$object->SetDBField('CopyLabels', 0);
	}
	}

	/**
	* Prepare temp tables for creating new item
	* but does not create it. Actual create is
	* done in OnPreSaveCreated
	*
	* @param kEvent $event
	*/
	function OnPreCreate(&$event)
	{
	parent::OnPreCreate($event);

	$object =& $event->getObject();
	$object->SetDBField('CopyLabels', 1);

	$live_table = $this->Application->getUnitOption($event->Prefix, 'TableName');
	$primary_lang_id = $this->Conn->GetOne('SELECT '.$object->IDField.' FROM '.$live_table.' WHERE PrimaryLang = 1');

	$object->SetDBField('CopyFromLanguage', $primary_lang_id);
	}


	function OnChangeLanguage(&$event)
	{
	$this->Application->SetVar('m_lang', $this->Application->GetVar('language'));

	//$this->Application->LinkVar('language', 'm_lang');
	}

	/**
	* Parse language XML file into temp tables and redirect to progress bar screen
	*
	* @param kEvent $event
	*/
	function OnImportLanguage(&$event)
	{
	if ($this->Application->CheckPermission('SYSTEM_ACCESS.READONLY', 1)) {
	return;
	}

	$items_info = $this->Application->GetVar('phrases_import');
	if($items_info)
	{
	list($id,$field_values) = each($items_info);
	$object =& $this->Application->recallObject('phrases.import', 'phrases', Array('skip_autoload' => true) );
	$object->SetFieldsFromHash($field_values);

	$filename = getArrayValue($field_values, 'LangFile', 'tmp_name');
	if( filesize($filename) )
	{
	$modules = getArrayValue($field_values,'Module');
	$lang_xml =& $this->Application->recallObject('LangXML');
	$lang_xml->Parse($filename, $field_values['PhraseType'], $modules, $field_values['ImportOverwrite']);

	$event->redirect = true;
	$event->SetRedirectParams( Array('lang_event' => 'OnImportProgress', 'pass' => 'all,lang', 'mode'=>$field_values['ImportOverwrite']) );
	}
	else
	{
	$object =& $this->Application->recallObject('phrases.import');
	$object->SetError('LangFile', 'la_empty_file', 'la_EmptyFile');
	$event->redirect = false;
	}
	}
	}

	/**
	* Copies imported from xml file from temp table to live table
	*
	* @param kEvent $event
	*/
	function OnImportProgress(&$event)
	{
	define('IMPORT_BY', 300); // import this much records per step
	$template_name = 'regional/languages_import_step2';

	$import_mode = (int)$this->Application->GetVar('mode'); // 1 - overwrite existing phrases, 0 - don't overwrite existing phrases
	$import_source = (int)$this->Application->GetVar('source');
	$import_steps = Array(0 => 'lang', 1 => 'phrases', 2 => 'emailmessages', 3 => 'finish');

	$key_fields = Array(0 => 'PackName', 1 => 'Phrase', 2 => 'EventId'); // by what field should we search record match

	$import_titles = Array(0 => 'la_ImportingLanguages', 1 => 'la_ImportingPhrases', 2 => 'la_ImportingEmailEvents', 3 => 'la_Done');

	// --- BEFORE ---
	$import_prefix = $import_steps[$import_source];
	$import_start = (int)$this->Application->GetVar('start');
	$id_field = $this->Application->getUnitOption($import_prefix,'IDField');
	$dst_table = $this->Application->getUnitOption($import_prefix,'TableName');
	$src_table = $this->Application->GetTempName($dst_table);

	$import_total = $this->Application->GetVar('total');
	if(!$import_total) $import_total = $this->Conn->GetOne('SELECT COUNT(*) FROM '.$src_table);
	// --- AFTER ---

	if($import_start == $import_total)
	{
	$import_source++;
	$import_prefix = $import_steps[$import_source];
	if($import_prefix == 'finish')
	{
	$event->SetRedirectParam('opener','u');
	return true;
	}

	$import_start = 0;
	$id_field = $this->Application->getUnitOption($import_prefix,'IDField');
	$dst_table = $this->Application->getUnitOption($import_prefix,'TableName');
	$src_table = $this->Application->GetTempName($dst_table);
	$import_total = $this->Conn->GetOne('SELECT COUNT(*) FROM '.$src_table);
	}

	if($import_total > 0)
	{
	$done_percent = ($import_start * 100) / $import_total;
	}
	else
	{
	$done_percent = 100;
	}

	$block_params = Array( 'name' => $template_name,
	'title' => $import_titles[$import_source],
	'percent_done' => $done_percent,
	'percent_left' => 100 - $done_percent);

	$this->Application->InitParser();
	$this->Application->setUnitOption('phrases','AutoLoad',false);
	echo $this->Application->ParseBlock($block_params);

	//break out of buffering
	$buffer_content = Array();
	while (ob_get_level()) {
	$buffer_content[] = ob_get_clean();
	}
	$ret = implode('', array_reverse($buffer_content));
	echo $ret;
	flush();


	$sql = 'SELECT * FROM %s LIMIT %s,%s';
	$rows = $this->Conn->Query( sprintf($sql,$src_table,$import_start,IMPORT_BY) );

	$values_sql = '';

	// if found and mode = 1 (overwrite)
	$search_sql = 'SELECT '.$id_field.' FROM '.$dst_table.' WHERE '.$key_fields[$import_source].' = %s AND LanguageId = %s';
	$update_sql = 'UPDATE '.$dst_table.' SET %s WHERE '.$id_field.' = %s';

	foreach($rows as $row)
	{
	$tmp_sql = sprintf($search_sql, $this->Conn->qstr($row[ $key_fields[$import_source] ]), $row['LanguageId'] );
	$tmp_id = $this->Conn->GetOne($tmp_sql);
	if($tmp_id > 0 && $import_mode == 1)
	{
	// update
	$update_fields = '';
	foreach($row as $field_name => $field_value)
	{
	if($field_name == $id_field) continue;
	$update_fields .= '`'.$field_name.'` = '.$this->Conn->qstr($field_value).',';
	}
	$update_fields = preg_replace('/(.*),$/', '\\1', $update_fields);
	$this->Conn->Query( sprintf($update_sql, $update_fields, $tmp_id) );
	}
	elseif(!$tmp_id)
	{
	$values_sql .= '(';
	foreach($row as $field_value)
	{
	$values_sql .= $this->Conn->qstr($field_value).',';
	}
	$values_sql = preg_replace('/(.*),$/', '\\1', $values_sql).'),';
	}
	}

	if($values_sql)
	{
	$fields_sql = '';
	$fields = array_keys( $this->Application->getUnitOption($import_prefix,'Fields') );
	foreach($fields as $field_name)
	{
	$fields_sql .= '`'.$field_name.'`,';
	}
	$fields_sql = preg_replace('/(.*),$/', '\\1', $fields_sql);

	$values_sql = preg_replace('/(.*),$/', '\\1', $values_sql);
	$sql = sprintf('INSERT INTO %s (%s) VALUES %s', $dst_table, $fields_sql, $values_sql);
	$this->Conn->Query($sql);
	}
	$event->setRedirectParams( Array('lang_event' => 'OnImportProgress', 'pass' => 'all,lang', 'start' => $import_start += count($rows), 'total' => $import_total, 'source' => $import_source, 'mode' => $import_mode) );
	}

	/**
	* Stores ids of selected languages and redirects to export language step 1
	*
	* @param kEvent $event
	*/
	function OnExportLanguage(&$event)
	{
	if ($this->Application->CheckPermission('SYSTEM_ACCESS.READONLY', 1)) {
	return;
	}

	$this->Application->setUnitOption('phrases','AutoLoad',false);

	$this->StoreSelectedIDs($event);
	$this->Application->StoreVar('export_language_ids', implode(',', $this->getSelectedIDs($event)) );

	$event->setRedirectParams( Array('m_opener'=>'d','phrases.export_event'=>'OnNew','pass'=>'all,phrases.export') );
	$event->redirect = 'regional/languages_export';
	}

	/**
	* Saves selected languages to xml file passed
	*
	* @param kEvent $event
	*/
	function OnExportProgress(&$event)
	{
	$items_info = $this->Application->GetVar('phrases_export');
	if($items_info)
	{
	list($id,$field_values) = each($items_info);
	$object =& $this->Application->recallObject('phrases.export', 'phrases', Array('skip_autoload' => true) );
	$object->SetFieldsFromHash($field_values);

	$lang_ids = explode(',', $this->Application->RecallVar('export_language_ids') );

	if( !getArrayValue($field_values,'LangFile') )
	{
	$object->SetError('LangFile', 'required');
	$event->redirect = false;
	return false;
	}
	if( !is_writable(EXPORT_PATH) )
	{
	$object->SetError('LangFile', 'write_error', 'la_ExportFolderNotWritable');
	$event->redirect = false;
	return false;
	}
	if( substr($field_values['LangFile'], -5) != '.lang' ) $field_values['LangFile'] .= '.lang';
	$filename = EXPORT_PATH.'/'.$field_values['LangFile'];

	$lang_xml =& $this->Application->recallObject('LangXML');
	if ($object->GetDBField('DoNotEncode')) {
	$lang_xml->SetEncoding('plain');
	}
	$lang_xml->Create($filename, $field_values['PhraseType'], $lang_ids, $field_values['Module']);

	}

	$event->redirect = 'regional/languages_export_step2';
	$event->SetRedirectParam('export_file', $field_values['LangFile']);
	}

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

	function OnScheduleTopFrameReload(&$event)
	{
	$this->Application->StoreVar('RefreshTopFrame',1);
	}

	/**
	* Do now allow deleting current language
	*
	* @param kEvent $event
	*/
	function OnBeforeItemDelete(&$event)
	{
	$del_id = $event->getEventParam('id');
	$object =& $event->getObject(array('skip_autload' => true));
	$object->Load($del_id);

	if ($object->GetDBField('PrimaryLang') \|\| $del_id == $this->Application->GetVar('m_lang')) {
	$event->status = erFAIL;
	}
	}

	}

	?>
	\ No newline at end of file

	Property changes on: branches/unlabeled/unlabeled-1.28.2/core/units/languages/languages_event_handler.php
	___________________________________________________________________
	Modified: cvs2svn:cvs-rev
	## -1 +1 ##
	-1.28.2.2
	\ No newline at end of property
	+1.28.2.3
	\ No newline at end of property
	Index: branches/unlabeled/unlabeled-1.8.2/core/units/general/helpers/multilanguage.php
	===================================================================
	--- branches/unlabeled/unlabeled-1.8.2/core/units/general/helpers/multilanguage.php (revision 7466)
	+++ branches/unlabeled/unlabeled-1.8.2/core/units/general/helpers/multilanguage.php (revision 7467)
	@@ -1,242 +1,254 @@
	<?php

	/**
	* Performs action on multilingual fields
	*
	*/
	class kMultiLanguageHelper extends kHelper {

	var $languageCount = 0;

	/**
	* Structure of table, that is currently processed
	*
	* @var Array
	*/
	var $curStructure = Array();

	/**
	* Field, to get structure information from
	*
	* @var string
	*/
	var $curSourceField = false;

	/**
	* Indexes used in table of 32
	*
	* @var int
	*/
	var $curIndexCount = 0;

	/**
	* Fields from config, that are currently used
	*
	* @var Array
	*/
	var $curFields = Array();

	function kMultiLanguageHelper()
	{
	parent::kHelper();
	$this->languageCount = $this->getLanguageCount();
	}

	/**
	* Returns language count in system (always is divisible by 5)
	*
	*/
	function getLanguageCount()
	{
	$table_name = $this->Application->getUnitOption('lang', 'TableName');
	$languages_count = $this->Conn->GetOne('SELECT COUNT(*) FROM '.$table_name);
	if (!$languages_count) {
	// during installation we have not languages, but we need to created custom field columns
	$languages_count = 1;
	}
	return $languages_count + 5 - ( $languages_count % 5 ? ($languages_count % 5) : 5 );
	}


	function scanTable($mask)
	{
	$i = 0;
	$fields_found = 0;
	$fields = array_keys($this->curStructure);

	foreach ($fields as $field_name) {
	if (preg_match($mask, $field_name)) {
	$fields_found++;
	}
	}
	return $fields_found;
	}

	function readTableStructure($table_name, $refresh = false)
	{
	// if ($refresh \|\| !getArrayValue($structure_status, $prefix.'.'.$table_name)) {
	$this->curStructure = $this->Conn->Query('DESCRIBE '.$table_name, 'Field');
	$this->curIndexCount = count($this->Conn->Query('SHOW INDEXES FROM '.$table_name));
	// }
	}
	+
	+ /**
	+ * Checks if table exists in database
	+ *
	+ * @param string $table_name
	+ * @return bool
	+ */
	+ function tableExists($table_name)
	+ {
	+ $sql = 'SHOW TABLES LIKE "'.$table_name.'"';
	+ return $this->Conn->Query($sql) ? true : false;
	+ }

	/**
	* Creates missing multilanguage fields in table by specified prefix
	*
	* @param string $prefix
	* @param bool $refresh Forces config field structure to be re-read from database
	*/
	function createFields($prefix, $refresh = false)
	{
	if ($refresh) {
	$this->Application->HandleEvent( new kEvent($prefix.':OnCreateCustomFields') );
	}

	$table_name = $this->Application->getUnitOption($prefix, 'TableName');
	$this->curFields = $this->Application->getUnitOption($prefix, 'Fields');

	- if (!($table_name && $this->curFields) ) {
	+ if (!($table_name && $this->curFields) \|\| ($table_name && !$this->tableExists($table_name))) {
	// invalid config found or prefix not found
	return true;
	}

	$sqls = Array();
	$this->readTableStructure($table_name, $refresh);

	foreach($this->curFields as $field_name => $field_options)
	{
	if (getArrayValue($field_options, 'formatter') == 'kMultiLanguage') {
	if (isset($field_options['master_field'])) {
	unset($this->curFields[$field_name]);
	continue;
	}

	$created_count = $this->getCreatedCount($field_name);
	$create_count = $this->languageCount - $created_count;
	if ($create_count > 0) {
	// `l77_Name` VARCHAR( 255 ) NULL DEFAULT '0';
	$field_mask = Array();
	$field_mask['name'] = 'l%s_'.$field_name;
	$field_mask['null'] = getArrayValue($field_options, 'not_null') ? 'NOT NULL' : 'NULL';

	if ($this->curSourceField) {
	$default_value = $this->getFieldParam('Default') != 'NULL' ? $this->Conn->qstr($this->getFieldParam('Default')) : $this->getFieldParam('Default');
	$field_mask['type'] = $this->getFieldParam('Type');
	}
	else {
	$default_value = is_null($field_options['default']) ? 'NULL' : $this->Conn->qstr($field_options['default']);
	$field_mask['type'] = $field_options['db_type'];
	}
	$field_mask['default'] = 'DEFAULT '.$default_value;
	$field_mask = $field_mask['name'].' '.$field_mask['type'].' '.$field_mask['null'].' '.$field_mask['default'];

	$sqls[] = 'ALTER TABLE '.$table_name.( $this->generateAlterSQL($field_mask, $created_count + 1, $create_count) );
	}
	}
	}

	foreach ($sqls as $sql_query) {
	$this->Conn->Query($sql_query);
	}
	}

	function deleteField($prefix, $custom_id)
	{
	$table_name = $this->Application->getUnitOption($prefix, 'TableName');
	$sql = 'DESCRIBE '.$table_name.' "l%_cust_'.$custom_id.'"';
	$fields = $this->Conn->GetCol($sql);

	$sql = 'ALTER TABLE '.$table_name.' ';
	$sql_template = 'DROP COLUMN %s, ';
	foreach ($fields as $field_name) {
	$sql .= sprintf($sql_template, $field_name);
	}
	$sql = preg_replace('/(.*), $/', '\\1', $sql);
	$this->Conn->Query($sql);
	}

	/**
	* Returns parameter requested of current source field
	*
	* @param string $param_name
	* @return string
	*/
	function getFieldParam($param_name)
	{
	return $this->curStructure[$this->curSourceField][$param_name];
	}

	function getCreatedCount($field_name)
	{
	$ret = $this->scanTable('/^l[\d]+_'.preg_quote($field_name, '/').'/');
	if (!$ret) {
	// no multilingual fields at all (but we have such field without language prefix)
	$original_found = $this->scanTable('/'.preg_quote($field_name, '/').'/');
	$this->curSourceField = $original_found ? $field_name : false;
	}
	else {
	$this->curSourceField = 'l1_'.$field_name;
	}
	return $ret;
	}
	/**
	* Returns ALTER statement part for adding required fields to table
	*
	* @param string $field_mask sql mask for creating field with correct definition (type & size)
	* @param int $start_index add new fields starting from this index
	* @param int $create_count create this much new multilingual field translations
	* @return string
	*/
	function generateAlterSQL($field_mask, $start_index, $create_count)
	{
	static $single_lang = null;
	if (!isset($single_lang)) {
	// if single language mode, then create indexes only on primary columns
	$table_name = $this->Application->getUnitOption('lang', 'TableName');
	$sql = 'SELECT COUNT(*)
	FROM '.$table_name.'
	WHERE Enabled = 1';
	// if language count = 0, then assume it's multi language mode
	$single_lang = $this->Conn->GetOne($sql) == 1;
	}

	$ret = ' ';
	$ml_field = preg_replace('/l(.)_(.?) (.*)/', '\\2', $field_mask);

	$i_count = $start_index + $create_count;
	while ($start_index < $i_count) {
	list($prev_field,$type) = explode(' ', sprintf($field_mask, $start_index - 1) );
	if (substr($prev_field, 0, 3) == 'l0_') {
	$prev_field = substr($prev_field, 3, strlen($prev_field));
	if (!$this->curSourceField) {
	// get field name before this one
	$fields = array_keys($this->curFields);
	// $prev_field = key(end($this->curStructure));
	$prev_field = $fields[array_search($prev_field, $fields) - 1];
	if (getArrayValue($this->curFields[$prev_field], 'formatter') == 'kMultiLanguage') {
	$prev_field = 'l'.$this->languageCount.'_'.$prev_field;
	}
	}
	}

	$field_expression = sprintf($field_mask, $start_index);
	$ret .= 'ADD COLUMN '.$field_expression.' AFTER `'.$prev_field.'`, ';

	if ($this->curIndexCount < 32 && ($start_index == $this->Application->GetDefaultLanguageId() \|\| !$single_lang)) {
	// create index for primary language column + for all others (if multiple languages installed)
	list($field_name, $field_params) = explode(' ', $field_expression, 2);

	$index_type = isset($this->curFields[$ml_field]['index_type']) ? $this->curFields[$prev_field]['index_type'] : 'string';

	$ret .= $index_type == 'string' ? 'ADD INDEX (`'.$field_name.'` (5) ), ' : 'ADD INDEX (`'.$field_name.'`), ';
	$this->curIndexCount++;
	}

	$start_index++;
	}
	return preg_replace('/, $/',';',$ret);
	}
	}


	?>
	\ No newline at end of file

	Property changes on: branches/unlabeled/unlabeled-1.8.2/core/units/general/helpers/multilanguage.php
	___________________________________________________________________
	Modified: cvs2svn:cvs-rev
	## -1 +1 ##
	-1.8.2.2
	\ No newline at end of property
	+1.8.2.3
	\ No newline at end of property

in-portalNo OneTemporaryActions

File Metadata

in-portalView Options

Event Timeline

in-portal
No OneTemporary
Actions

in-portal
View Options