, so we rather don't
		//$_html = str_replace("\r\n",' ',$_html);
		//$_html = str_replace("\t",' ',$_html);
		//error_log($_html);
		//repair doubleencoded ampersands, and some stuff htmLawed stumbles upon with balancing switched on
		$_html = str_replace(array('&','

',"
 
",'
 
','','
',''),array('&','
','
','
','','',''),$_html);
		//$_html = str_replace(array('&'),array('&'),$_html);
		if (stripos($_html,'style')!==false) self::replaceTagsCompletley($_html,'style'); // clean out empty or pagewide style definitions / left over tags
		if (stripos($_html,'head')!==false) self::replaceTagsCompletley($_html,'head'); // Strip out stuff in head
		//if (stripos($_html,'![if')!==false && stripos($_html,'')!==false) self::replaceTagsCompletley($_html,'!\[if','',false); // Strip out stuff in ifs
		if (stripos($_html,'!--[if')!==false && stripos($_html,'')!==false) self::replaceTagsCompletley($_html,'!--\[if','',false); // Strip out stuff in ifs
		//error_log($_html);
		// force the use of kses, as it is still have the edge over purifier with some stuff
		$usepurify = true;
		if ($usepurify)
		{
			// we need a customized config, as we may allow external images, $GLOBALS['egw_info']['user']['preferences']['felamimail']['allowExternalIMGs']
			if (get_magic_quotes_gpc() === 1) $_html = stripslashes($_html);
			// Strip out doctype in head, as htmlLawed cannot handle it TODO: Consider extracting it and adding it afterwards
			if (stripos($_html,'!doctype')!==false) self::replaceTagsCompletley($_html,'!doctype');
			if (stripos($_html,'?xml:namespace')!==false) self::replaceTagsCompletley($_html,'\?xml:namespace','/>',false);
			if (stripos($_html,'?xml version')!==false) self::replaceTagsCompletley($_html,'\?xml version','\?>',false);
			if (strpos($_html,'!CURSOR')!==false) self::replaceTagsCompletley($_html,'!CURSOR');
			// htmLawed filter only the 'body'
			//preg_match('`(]*>)(.+?)(.*?)`ims', $_html, $matches);
			//if ($matches[2])
			//{
			//	$hasOther = true;
			//	$_html = $matches[2];
			//}
			// purify got switched to htmLawed
			// some testcode to test purifying / htmlawed
			//$_html = "
hi 
 there 
 kram 
 
".$_html;
			$_html = html::purify($_html,self::$htmLawed_config,array(),true);
			//if ($hasOther) $_html = $matches[1]. $_html. $matches[3];
			// clean out comments , should not be needed as purify should do the job.
			$search = array(
				'@url\(http:\/\/[^\)].*?\)@si',  // url calls e.g. in style definitions
				'@@',         // Strip multi-line comments including CDATA
			);
			$_html = preg_replace($search,"",$_html);
			// remove non printable chars
            $_html = preg_replace('/([\000-\012])/','',$_html);
			//error_log($_html);
		}
		// using purify above should have tidied the tags already sufficiently
		if ($usepurify == false && $cleanTags==true)
		{
			if (extension_loaded('tidy'))
			{
				$tidy = new tidy();
				$cleaned = $tidy->repairString($_html, self::$tidy_config,'utf8');
				// Found errors. Strip it all so there's some output
				if($tidy->getStatus() == 2)
				{
					error_log(__METHOD__.__LINE__.' ->'.$tidy->errorBuffer);
				}
				else
				{
					$_html = $cleaned;
				}
			}
			else
			{
				//$to = ini_get('max_execution_time');
				//@set_time_limit(10);
				$htmLawed = new egw_htmLawed();
				$_html = $htmLawed->egw_htmLawed($_html);
				//error_log(__METHOD__.__LINE__.$_html);
				//@set_time_limit($to);
			}
		}
	}

	/**
	* replace emailaddresses enclosed in <> (eg.: ) with the emailaddress only (e.g: me@you.de)
	* always returns 1
	*/
	static function replaceEmailAdresses(&$text)
	{
		return translation::replaceEmailAdresses($text);
	}

	static function convertHTMLToText($_html,$stripcrl=false,$stripalltags=true)
	{
		return translation::convertHTMLToText($_html,self::$displayCharset,$stripcrl,$stripalltags);
	}

	/**
	 * retrieve a attachment
	 *
	 * @param int _uid the uid of the message
	 * @param string _partID the id of the part, which holds the attachment
	 * @param int _winmail_nr winmail.dat attachment nr.
	 *
	 * @return array
	 */
	function getAttachment($_uid, $_partID, $_winmail_nr=0)
	{
		// parse message structure
		$structure = $this->_getStructure($_uid, true);
		if($_partID != '') {
			$structure = $this->_getSubStructure($structure, $_partID);
		}
		$filename = $this->getFileNameFromStructure($structure, $_uid, $structure->partID);
		$attachment = $this->icServer->getBodyPart($_uid, $_partID, true, true);
		if (PEAR::isError($attachment))
		{
			error_log(__METHOD__.__LINE__.' failed:'.$attachment->message);
			return array('type' => 'text/plain',
						 'filename' => 'error.txt',
						 'attachment' =>__METHOD__.' failed:'.$attachment->message
					);
		}

		if (PEAR::isError($attachment))
		{
			error_log(__METHOD__.__LINE__.' failed:'.$attachment->message);
			return array('type' => 'text/plain',
						 'filename' => 'error.txt',
						 'attachment' =>__METHOD__.' failed:'.$attachment->message
					);
		}
		switch ($structure->encoding) {
			case 'BASE64':
				// use imap_base64 to decode
				$attachment = imap_base64($attachment);
				break;
			case 'QUOTED-PRINTABLE':
				// use imap_qprint to decode
				#$attachment = imap_qprint($attachment);
				$attachment = quoted_printable_decode($attachment);
				break;
			default:
				// it is either not encoded or we don't know about it
		}
		if ($structure->type === 'TEXT' && isset($structure->parameters['CHARSET']) && stripos('UTF-16',$structure->parameters['CHARSET'])!==false)
		{
			$attachment = translation::convert($attachment,$structure->parameters['CHARSET'],self::$displayCharset);
		}

		$attachmentData = array(
			'type'		=> $structure->type .'/'. $structure->subType,
			'filename'	=> $filename,
			'attachment'	=> $attachment
			);
		// try guessing the mimetype, if we get the application/octet-stream
		if (strtolower($attachmentData['type']) == 'application/octet-stream') $attachmentData['type'] = mime_magic::filename2mime($attachmentData['filename']);
		# if the attachment holds a winmail number and is a winmail.dat then we have to handle that.
		if ( $filename == 'winmail.dat' && $_winmail_nr > 0 &&
			( $wmattach = $this->decode_winmail( $_uid, $_partID, $_winmail_nr ) ) )
		{
			$attachmentData = array(
				'type'       => $wmattach['type'],
				'filename'   => $wmattach['name'],
				'attachment' => $wmattach['attachment'],
			);
		}
		return $attachmentData;
	}

	/**
	 * Fetch a specific attachment from a message by it's cid
	 *
	 * this function is based on a on "Building A PHP-Based Mail Client"
	 * http://www.devshed.com
	 *
	 * @param string|int $_uid
	 * @param string $_cid
	 * @param string $_part
	 * @return array with values for keys 'type', 'filename' and 'attachment'
	 */
	function getAttachmentByCID($_uid, $_cid, $_part)
	{
		// some static variables to avoid fetching the same mail multiple times
		static $uid,$part,$attachments,$structure;
		//error_log("getAttachmentByCID:$_uid, $_cid, $_part");

		if(empty($_cid)) return false;

		if ($_uid != $uid || $_part != $part)
		{
			$attachments = $this->getMessageAttachments($uid=$_uid, $part=$_part);
			$structure = null;
		}
		$partID = false;
		foreach($attachments as $attachment)
		{
			//error_log(print_r($attachment,true));
			if(isset($attachment['cid']) && (strpos($attachment['cid'], $_cid) !== false || strpos($_cid, $attachment['cid']) !== false))
			{
				$partID = $attachment['partID'];
				break;
			}
		}
		if ($partID == false)
		{
			foreach($attachments as $attachment)
			{
				// if the former did not match try matching the cid to the name of the attachment
				if(isset($attachment['cid']) && isset($attachment['name']) && (strpos($attachment['name'], $_cid) !== false || strpos($_cid, $attachment['name']) !== false))
				{
					$partID = $attachment['partID'];
					break;
				}
			}
		}
		if ($partID == false)
		{
			foreach($attachments as $attachment)
			{
				// if the former did not match try matching the cid to the name of the attachment, AND there is no mathing attachment with cid
				if(isset($attachment['name']) && (strpos($attachment['name'], $_cid) !== false || strpos($_cid, $attachment['name']) !== false))
				{
					$partID = $attachment['partID'];
					break;
				}
			}
		}
		//error_log( "Cid:$_cid PARTID:$partID
"); #exit;

		if($partID == false) {
			return false;
		}

		// parse message structure
		if (is_null($structure))
		{
			$structure = $this->_getStructure($_uid, true);
		}
		$part_structure = $this->_getSubStructure($structure, $partID);
		$filename = $this->getFileNameFromStructure($part_structure, $_uid, $_uid, $part_structure->partID);
		$attachment = $this->icServer->getBodyPart($_uid, $partID, true);
		if (PEAR::isError($attachment))
		{
			error_log(__METHOD__.__LINE__.' failed:'.$attachment->message);
			return array('type' => 'text/plain',
						 'filename' => 'error.txt',
						 'attachment' =>__METHOD__.' failed:'.$attachment->message
					);
		}

		if (PEAR::isError($attachment))
		{
			error_log(__METHOD__.__LINE__.' failed:'.$attachment->message);
			return array('type' => 'text/plain',
						 'filename' => 'error.txt',
						 'attachment' =>__METHOD__.' failed:'.$attachment->message
					);
		}

		switch ($part_structure->encoding) {
			case 'BASE64':
				// use imap_base64 to decode
				$attachment = imap_base64($attachment);
				break;
			case 'QUOTED-PRINTABLE':
				// use imap_qprint to decode
				#$attachment = imap_qprint($attachment);
				$attachment = quoted_printable_decode($attachment);
				break;
			default:
				// it is either not encoded or we don't know about it
		}

		$attachmentData = array(
			'type'		=> $part_structure->type .'/'. $part_structure->subType,
			'filename'	=> $filename,
			'attachment'	=> $attachment
		);
		// try guessing the mimetype, if we get the application/octet-stream
		if (strtolower($attachmentData['type']) == 'application/octet-stream') $attachmentData['type'] = mime_magic::filename2mime($attachmentData['filename']);

		return $attachmentData;
	}

	/**
	 * getIdentitiesWithAccounts
	 *
	 * @param array reference to pass all identities back
	 * @return the default Identity (active) or 0
	 */
	function getIdentitiesWithAccounts(&$identities)
	{
		// account select box
		$selectedID = $this->profileID;
		if($this->mailPreferences->userDefinedAccounts) $allAccountData = $this->bopreferences->getAllAccountData($this->mailPreferences);

		if ($allAccountData) {
			foreach ($allAccountData as $tmpkey => $accountData)
			{
				$identity =& $accountData['identity'];
				$icServer =& $accountData['icServer'];
				//_debug_array($identity);
				//_debug_array($icServer);
				if (empty($icServer->host)) continue;
				$identities[$identity->id]=$identity->realName.' '.$identity->organization.' <'.$identity->emailAddress.'>';
				if (!empty($identity->default)) $selectedID = $identity->id;
			}
		}

		return $selectedID;
	}

	function getEMailProfile()
	{
		$config = CreateObject('phpgwapi.config','felamimail');
		$config->read_repository();
		$felamimailConfig = $config->config_data;

		#_debug_array($felamimailConfig);

		if(!isset($felamimailConfig['profileID'])){
			return -1;
		} else {
			return intval($felamimailConfig['profileID']);
		}
	}

	function getErrorMessage()
	{
		$rv =$this->icServer->_connectionErrorObject->message;
		if (empty($rv)) $rv =$this->errorMessage;
		return $rv;
	}

	/**
	* get IMAP folder status
	*
	* returns an array information about the imap folder
	*
	* @param _folderName string the foldername
	*
	* @return array
	*/
	function getFolderStatus($_folderName,$ignoreStatusCache=false)
	{
		if (self::$debug) error_log(__METHOD__." called with:".$_folderName);
		if (!is_string($_folderName) || empty($_folderName)) // something is wrong. Do not proceed
		{
			return false;
		}
		$retValue = array();
		$retValue['subscribed'] = false;
		if(!$icServer = $this->mailPreferences->getIncomingServer($this->profileID)) {
			if (self::$debug) error_log(__METHOD__." no Server found for Folder:".$_folderName);
			return false;
		}

		// does the folder exist???
		$folderInfo = $this->icServer->getMailboxes('', $_folderName, true);

		if(($folderInfo instanceof PEAR_Error) || !is_array($folderInfo[0])) {
			if (self::$debug||$folderInfo instanceof PEAR_Error) error_log(__METHOD__." returned Info for folder $_folderName:".print_r($folderInfo->message,true));
			if ( ($folderInfo instanceof PEAR_Error) || PEAR::isError($r = $this->_getStatus($_folderName)) || $r == 0) return false;
			if (!is_array($folderInfo[0]))
			{
				// no folder info, but there is a status returned for the folder: something is wrong, try to cope with it
				$folderInfo = array(0 => array('HIERACHY_DELIMITER'=>$this->getHierarchyDelimiter(),
					'ATTRIBUTES' => ''));
			}
		}
		#if(!is_array($folderInfo[0])) {
		#	return false;
		#}

		$subscribedFolders = $this->icServer->listsubscribedMailboxes('', $_folderName);
		if(is_array($subscribedFolders) && count($subscribedFolders) == 1) {
			$retValue['subscribed'] = true;
		}

		$retValue['delimiter']		= $folderInfo[0]['HIERACHY_DELIMITER'];
		$retValue['attributes']		= $folderInfo[0]['ATTRIBUTES'];
		$shortNameParts			= explode($retValue['delimiter'], $_folderName);
		$retValue['shortName']		= array_pop($shortNameParts);
		$retValue['displayName']	= $this->encodeFolderName($_folderName);
		$retValue['shortDisplayName']	= $this->encodeFolderName($retValue['shortName']);
		if(strtoupper($retValue['shortName']) == 'INBOX') {
			$retValue['displayName']	= lang('INBOX');
			$retValue['shortDisplayName']	= lang('INBOX');
		}
		// translate the automatic Folders (Sent, Drafts, ...) like the INBOX
		elseif (in_array($retValue['shortName'],self::$autoFolders))
		{
			$retValue['displayName'] = $retValue['shortDisplayName'] = lang($retValue['shortName']);
		}

		if ( PEAR::isError($folderStatus = $this->_getStatus($_folderName,$ignoreStatusCache)) ) {
			if (self::$debug) error_log(__METHOD__." returned folderStatus for Folder $_folderName:".print_r($folderStatus->message,true));
		} else {
			$nameSpace = $this->_getNameSpaces();
			if (isset($nameSpace['personal'])) unset($nameSpace['personal']);
			$prefix = $this->getFolderPrefixFromNamespace($nameSpace, $_folderName);
			$retValue['messages']		= $folderStatus['MESSAGES'];
			$retValue['recent']		= $folderStatus['RECENT'];
			$retValue['uidnext']		= $folderStatus['UIDNEXT'];
			$retValue['uidvalidity']	= $folderStatus['UIDVALIDITY'];
			$retValue['unseen']		= $folderStatus['UNSEEN'];
			if (//$retValue['unseen']==0 &&
				(isset($this->mailPreferences->preferences['trustServersUnseenInfo']) && // some servers dont serve the UNSEEN information
				$this->mailPreferences->preferences['trustServersUnseenInfo']==false) ||
				(isset($this->mailPreferences->preferences['trustServersUnseenInfo']) &&
				$this->mailPreferences->preferences['trustServersUnseenInfo']==2 &&
				$prefix != '' && stripos($_folderName,$prefix) !== false)
			)
			{
				//error_log(__METHOD__." returned folderStatus for Folder $_folderName:".print_r($prefix,true).' TS:'.$this->mailPreferences->preferences['trustServersUnseenInfo']);
				// we filter for the combined status of unseen and undeleted, as this is what we show in list
				$sortResult = $this->getSortedList($_folderName, $_sort=0, $_reverse=1, $_filter=array('status'=>array('UNSEEN','UNDELETED')),$byUid=true,false);
				$retValue['unseen'] = count($sortResult);
			}
		}

		return $retValue;
	}

	static function resetConnectionErrorCache($_ImapServerId=null)
	{
		//error_log(__METHOD__.__LINE__.' for Profile:'.array2string($_ImapServerId) .' for user:'.trim($GLOBALS['egw_info']['user']['account_id']));
		$account_id = $GLOBALS['egw_info']['user']['account_id'];
		if (is_array($_ImapServerId))
		{
			// called via hook
			$account_id = $_ImapServerId['account_id'];
			unset($_ImapServerId);
			$_ImapServerId = null;
		}
		if (is_null($_ImapServerId))
		{
			$buff = array();
			$isConError = array();
			$waitOnFailure = array();
		}
		else
		{
			$buff = egw_cache::getCache(egw_cache::INSTANCE,'email','icServerIMAP_connectionError'.trim($account_id));
			if (isset($buff[$_ImapServerId]))
			{
				unset($buff[$_ImapServerId]);
			}
			$isConError = egw_cache::getCache(egw_cache::INSTANCE,'email','icServerSIEVE_connectionError'.trim($account_id));
			if (isset($isConError[$_ImapServerId]))
			{
				unset($isConError[$_ImapServerId]);
			}
			$waitOnFailure = egw_cache::getCache(egw_cache::INSTANCE,'email','ActiveSyncWaitOnFailure'.trim($GLOBALS['egw_info']['user']['account_id']),$callback=null,$callback_params=array(),$expiration=60*60*2);
			if (isset($waitOnFailure[$_ImapServerId]))
			{
				unset($waitOnFailure[$_ImapServerId]);
			}
		}
		egw_cache::setCache(egw_cache::INSTANCE,'email','icServerIMAP_connectionError'.trim($account_id),$buff,$expiration=60*15);
		egw_cache::setCache(egw_cache::INSTANCE,'email','icServerSIEVE_connectionError'.trim($account_id),$isConError,$expiration=60*15);
		egw_cache::setCache(egw_cache::INSTANCE,'email','ActiveSyncWaitOnFailure'.trim($GLOBALS['egw_info']['user']['account_id']),$waitOnFailure,$expiration=60*60*2);
	}

	static function resetFolderObjectCache($_ImapServerId=null)
	{
		//error_log(__METHOD__.__LINE__.' called for Profile:'.$_ImapServerId.'->'.function_backtrace());
		if (is_null($_ImapServerId))
		{
			$folders2return = array();
			$folderInfo = array();
		}
		else
		{
			$folders2return = egw_cache::getCache(egw_cache::INSTANCE,'email','folderObjects'.trim($GLOBALS['egw_info']['user']['account_id']),$callback=null,$callback_params=array(),$expiration=60*60*1);
			if (isset($folders2return[$_ImapServerId]))
			{
				unset($folders2return[$_ImapServerId]);
			}
			$folderInfo = egw_cache::getCache(egw_cache::INSTANCE,'email','icServerFolderExistsInfo'.trim($GLOBALS['egw_info']['user']['account_id']),null,array(),$expiration=60*5);
			if (isset($folderInfo[$_ImapServerId]))
			{
				unset($folderInfo[$_ImapServerId]);
			}
		}
		egw_cache::setCache(egw_cache::INSTANCE,'email','folderObjects'.trim($GLOBALS['egw_info']['user']['account_id']),$folders2return, $expiration=60*60*1);
		egw_cache::setCache(egw_cache::INSTANCE,'email','icServerFolderExistsInfo'.trim($GLOBALS['egw_info']['user']['account_id']),$folderInfo,$expiration=60*5);
	}

	/**
	* get IMAP folder objects
	*
	* returns an array of IMAP folder objects. Put INBOX folder in first
	* position. Preserves the folder seperator for later use. The returned
	* array is indexed using the foldername. Use cachedObjects when retrieving subscribedFolders
	*
	* @param _subscribedOnly boolean get subscribed or all folders
	* @param _getCounters    boolean get get messages counters
	* @param _alwaysGetDefaultFolders boolean this triggers to ignore the possible notavailableautofolders - preference
	*			as activeSync needs all folders like sent, trash, drafts, templates and outbox - if not present devices may crash
	*
	* @return array with folder objects. eg.: INBOX => {inbox object}
	*/
	function getFolderObjects($_subscribedOnly=false, $_getCounters=false, $_alwaysGetDefaultFolders=false)
	{
		if (self::$debug) error_log(__METHOD__.__LINE__.' '."subscribedOnly:$_subscribedOnly, getCounters:$_getCounters, alwaysGetDefaultFolders:$_alwaysGetDefaultFolders");
		static $folders2return;
		if ($_subscribedOnly && $_getCounters===false)
		{
			if (is_null($folders2return)) $folders2return = egw_cache::getCache(egw_cache::INSTANCE,'email','folderObjects'.trim($GLOBALS['egw_info']['user']['account_id']),$callback=null,$callback_params=array(),$expiration=60*60*1);
			if (isset($folders2return[$this->icServer->ImapServerId]) && !empty($folders2return[$this->icServer->ImapServerId]))
			{
				//error_log(__METHOD__.__LINE__.' using Cached folderObjects');
				return $folders2return[$this->icServer->ImapServerId];
			}
		}
		$isUWIMAP = false;

		$delimiter = $this->getHierarchyDelimiter();

		$inboxData = new stdClass;
		$inboxData->name 		= 'INBOX';
		$inboxData->folderName		= 'INBOX';
		$inboxData->displayName		= lang('INBOX');
		$inboxData->delimiter 		= $delimiter;
		$inboxData->shortFolderName	= 'INBOX';
		$inboxData->shortDisplayName	= lang('INBOX');
		$inboxData->subscribed = true;
		if($_getCounters == true) {
			$inboxData->counter = self::getMailBoxCounters('INBOX');
		}
		// force unsubscribed by preference showAllFoldersInFolderPane
		if ($_subscribedOnly == true &&
			isset($this->mailPreferences->preferences['showAllFoldersInFolderPane']) &&
			$this->mailPreferences->preferences['showAllFoldersInFolderPane']==1)
		{
			$_subscribedOnly = false;
		}
		#$inboxData->attributes = 64;
		$inboxFolderObject = array('INBOX' => $inboxData);
		#_debug_array($folders);

		//$nameSpace = $this->icServer->getNameSpaces();
		$nameSpace = $this->_getNameSpaces();
		//_debug_array($nameSpace);
		//_debug_array($delimiter);
		if(isset($nameSpace['#mh/'])) {
			// removed the uwimap code
			// but we need to reintroduce him later
			// uw imap does not return the attribute of a folder, when requesting subscribed folders only
			// dovecot has the same problem too
		} else {
			if (is_array($nameSpace)) {
			  foreach($nameSpace as $type => $singleNameSpace) {
				$prefix_present = $nameSpace[$type]['prefix_present'];
				$foldersNameSpace[$type] = $nameSpace[$type];

				if(is_array($singleNameSpace)) {
					// fetch and sort the subscribed folders
					$subscribedMailboxes = $this->icServer->listsubscribedMailboxes($foldersNameSpace[$type]['prefix']);
					if (empty($subscribedMailboxes) && $type == 'shared')
					{
						$subscribedMailboxes = $this->icServer->listsubscribedMailboxes('',0);
					}
					else
					{
						if ($prefix_present=='forced' && $type=='personal') // you cannot trust dovecots assumed prefix
						{
							$subscribedMailboxesAll = $this->icServer->listsubscribedMailboxes('',0);
							if( PEAR::isError($subscribedMailboxesAll) ) continue;
							foreach ($subscribedMailboxesAll as $ksMA => $sMA) if (!in_array($sMA,$subscribedMailboxes)) $subscribedMailboxes[] = $sMA;
						}
					}

					//echo "subscribedMailboxes";_debug_array($subscribedMailboxes);
					if( PEAR::isError($subscribedMailboxes) ) {
						continue;
					}
					$foldersNameSpace[$type]['subscribed'] = $subscribedMailboxes;
					if (is_array($foldersNameSpace[$type]['subscribed'])) sort($foldersNameSpace[$type]['subscribed']);
					//_debug_array($foldersNameSpace);
					if ($_subscribedOnly == true) {
						$foldersNameSpace[$type]['all'] = (is_array($foldersNameSpace[$type]['subscribed']) ? $foldersNameSpace[$type]['subscribed'] :array());
						continue;
					}
					// only check for Folder in FolderMaintenance for Performance Reasons
					if(!$_subscribedOnly) {
						foreach ((array)$foldersNameSpace[$type]['subscribed'] as $folderName)
						{
							if ($foldersNameSpace[$type]['prefix'] == $folderName || $foldersNameSpace[$type]['prefix'] == $folderName.$foldersNameSpace[$type]['delimiter']) continue;
							//echo __METHOD__."Checking $folderName for existence
";
							if (!self::folderExists($folderName,true)) {
								echo("eMail Folder $folderName failed to exist; should be unsubscribed; Trying ...");
								error_log(__METHOD__."-> $folderName failed to be here; should be unsubscribed");
								if (self::subscribe($folderName, false))
								{
									echo " success."."
" ;
								} else {
									echo " failed."."
";
								}
							}
						}
					}

					// fetch and sort all folders
					//echo $type.'->'.$foldersNameSpace[$type]['prefix'].'->'.($type=='shared'?0:2)."
";
					$allMailboxesExt = $this->icServer->getMailboxes($foldersNameSpace[$type]['prefix'],2,true);
					if( PEAR::isError($allMailboxesExt) )
					{
						error_log(__METHOD__.__LINE__.' Failed to retrieve all Boxes:'.$allMailboxesExt->message);
						$allMailboxesExt = array();
					}
					if (empty($allMailboxesExt) && $type == 'shared')
					{
						$allMailboxesExt = $this->icServer->getMailboxes('',0,true);
					}
					else
					{
						if ($prefix_present=='forced' && $type=='personal') // you cannot trust dovecots assumed prefix
						{
							$allMailboxesExtAll = $this->icServer->getMailboxes('',0,true);
							foreach ($allMailboxesExtAll as $kaMEA => $aMEA)
							{
								if( PEAR::isError($aMEA) ) continue;
								if (!in_array($aMEA,$allMailboxesExt)) $allMailboxesExt[] = $aMEA;
							}
						}
					}
					if( PEAR::isError($allMailboxesExt) ) {
						#echo __METHOD__;_debug_array($allMailboxesExt);
						continue;
					}
					$allMailBoxesExtSorted = array();
					foreach ((array)$allMailboxesExt as $mbx) {
						//echo __METHOD__;_debug_array($mbx);
						//error_log(__METHOD__.__LINE__.array2string($mbx));
						if (isset($allMailBoxesExtSorted[$mbx['MAILBOX']])||
							isset($allMailBoxesExtSorted[$mbx['MAILBOX'].$foldersNameSpace[$type]['delimiter']])||
							(substr($mbx['MAILBOX'],-1)==$foldersNameSpace[$type]['delimiter'] && isset($allMailBoxesExtSorted[substr($mbx['MAILBOX'],0,-1)]))
						) continue;

						//echo '#'.$mbx['MAILBOX'].':'.array2string($mbx)."#
";
						$allMailBoxesExtSorted[$mbx['MAILBOX']] = $mbx;
					}
					if (is_array($allMailBoxesExtSorted)) ksort($allMailBoxesExtSorted);
					//_debug_array($allMailBoxesExtSorted);
					$allMailboxes = array();
					foreach ((array)$allMailBoxesExtSorted as $mbx) {
						//echo $mbx['MAILBOX']."
";
						if (in_array('\HasChildren',$mbx["ATTRIBUTES"]) || in_array('\Haschildren',$mbx["ATTRIBUTES"])) {
							unset($buff);
							//$buff = $this->icServer->getMailboxes($mbx['MAILBOX'].$delimiter,0,false);
							if (!in_array($mbx['MAILBOX'],$allMailboxes)) $buff = self::getMailBoxesRecursive($mbx['MAILBOX'],$delimiter,$foldersNameSpace[$type]['prefix'],1);
							if( PEAR::isError($buff) ) {
								continue;
							}
							#_debug_array($buff);
							if (is_array($buff)) $allMailboxes = array_merge($allMailboxes,$buff);
						}
						if (!in_array($mbx['MAILBOX'],$allMailboxes)) $allMailboxes[] = $mbx['MAILBOX'];
						//echo "Result:";_debug_array($allMailboxes);
					}
					$foldersNameSpace[$type]['all'] = $allMailboxes;
					if (is_array($foldersNameSpace[$type]['all'])) sort($foldersNameSpace[$type]['all']);
				}
			  }
			}
			// check for autocreated folders
			if(isset($foldersNameSpace['personal']['prefix'])) {
				$personalPrefix = $foldersNameSpace['personal']['prefix'];
				$personalDelimiter = $foldersNameSpace['personal']['delimiter'];
				if(!empty($personalPrefix)) {
					if(substr($personalPrefix, -1) != $personalDelimiter) {
						$folderPrefix = $personalPrefix . $personalDelimiter;
					} else {
						$folderPrefix = $personalPrefix;
					}
				}
				else
				{
					if(substr($personalPrefix, -1) != $personalDelimiter) {
						$folderPrefixAsInbox = 'INBOX' . $personalDelimiter;
					} else {
						$folderPrefixAsInbox = 'INBOX';
					}
				}
				if (!$_alwaysGetDefaultFolders && $this->mailPreferences->preferences['notavailableautofolders'] && !empty($this->mailPreferences->preferences['notavailableautofolders']))
				{
					$foldersToCheck = array_diff(self::$autoFolders,explode(',',$this->mailPreferences->preferences['notavailableautofolders']));
				} else {
					$foldersToCheck = self::$autoFolders;
				}
				//error_log(__METHOD__.__LINE__." foldersToCheck:".array2string($foldersToCheck));
				//error_log(__METHOD__.__LINE__." foldersToCheck:".array2string( $this->mailPreferences->preferences['sentFolder']));
				foreach($foldersToCheck as $personalFolderName) {
					$folderName = (!empty($personalPrefix) ? $folderPrefix.$personalFolderName : $personalFolderName);
					//error_log(__METHOD__.__LINE__." foldersToCheck: $personalFolderName / $folderName");
					if(!is_array($foldersNameSpace['personal']['all']) || !in_array($folderName, $foldersNameSpace['personal']['all'])) {
						$createfolder = true;
						switch($personalFolderName)
						{
							case 'Drafts': // => Entwürfe
								if ($this->mailPreferences->preferences['draftFolder'] && $this->mailPreferences->preferences['draftFolder']=='none')
									$createfolder=false;
								break;
							case 'Junk': //] => Spammails
								if ($this->mailPreferences->preferences['junkFolder'] && $this->mailPreferences->preferences['junkFolder']=='none')
									$createfolder=false;
								break;
							case 'Sent': //] => Gesendet
								// ToDo: we may need more sophistcated checking here
								if ($this->mailPreferences->preferences['sentFolder'] && $this->mailPreferences->preferences['sentFolder']=='none')
									$createfolder=false;
								break;
							case 'Trash': //] => Papierkorb
								if ($this->mailPreferences->preferences['trashFolder'] && $this->mailPreferences->preferences['trashFolder']=='none')
									$createfolder=false;
								break;
							case 'Templates': //] => Vorlagen
								if ($this->mailPreferences->preferences['templateFolder'] && $this->mailPreferences->preferences['templateFolder']=='none')
									$createfolder=false;
								break;
							case 'Outbox': // Nokia Outbox for activesync
								//if ($this->mailPreferences->preferences['outboxFolder'] && $this->mailPreferences->preferences['outboxFolder']=='none')
									$createfolder=false;
								if ($GLOBALS['egw_info']['user']['apps']['activesync']) $createfolder = true;
								break;
						}
						// check for the foldername as constructed with prefix (or not)
						if ($createfolder && self::folderExists($folderName))
						{
							$createfolder = false;
						}
						// check for the folder as it comes (no prefix)
						if ($createfolder && $personalFolderName != $folderName && self::folderExists($personalFolderName))
						{
							$createfolder = false;
							$folderName = $personalFolderName;
						}
						// check for the folder as it comes with INBOX prefixed
						$folderWithInboxPrefixed = $folderPrefixAsInbox.$personalFolderName;
						if ($createfolder && $folderWithInboxPrefixed != $folderName && self::folderExists($folderWithInboxPrefixed))
						{
							$createfolder = false;
							$folderName = $folderWithInboxPrefixed;
						}
						// now proceed with the folderName that may be altered in the progress of testing for existence
						if ($createfolder === false && $_alwaysGetDefaultFolders)
						{
							if (!in_array($folderName,$foldersNameSpace['personal']['all'])) $foldersNameSpace['personal']['all'][] = $folderName;
							if (!in_array($folderName,$foldersNameSpace['personal']['subscribed'])) $foldersNameSpace['personal']['subscribed'][] = $folderName;
						}

						if($createfolder === true && $this->createFolder('', $folderName, true)) {
							$foldersNameSpace['personal']['all'][] = $folderName;
							$foldersNameSpace['personal']['subscribed'][] = $folderName;
						} else {
							#print "FOLDERNAME failed: $folderName
";
						}
					}
				}
			}
		}
		//echo "
FolderNameSpace To Process:";_debug_array($foldersNameSpace);
		$autoFolderObjects = array();
		foreach( array('personal', 'others', 'shared') as $type) {
			if(isset($foldersNameSpace[$type])) {
				if($_subscribedOnly) {
					if( !PEAR::isError($foldersNameSpace[$type]['subscribed']) ) $listOfFolders = $foldersNameSpace[$type]['subscribed'];
				} else {
					if( !PEAR::isError($foldersNameSpace[$type]['all'])) $listOfFolders = $foldersNameSpace[$type]['all'];
				}
				foreach((array)$listOfFolders as $folderName) {
					//echo "
FolderToCheck:$folderName
";
					if($_subscribedOnly && !(in_array($folderName, $foldersNameSpace[$type]['all'])||in_array($folderName.$foldersNameSpace[$type]['delimiter'], $foldersNameSpace[$type]['all']))) {
						#echo "$folderName failed to be here 
";
						continue;
					}
					$folderParts = explode($delimiter, $folderName);
					$shortName = array_pop($folderParts);

					$folderObject = new stdClass;
					$folderObject->delimiter	= $delimiter;
					$folderObject->folderName	= $folderName;
					$folderObject->shortFolderName	= $shortName;
					if(!$_subscribedOnly) {
						#echo $folderName."->".$type."
";
						#_debug_array($foldersNameSpace[$type]['subscribed']);
						$folderObject->subscribed = in_array($folderName, $foldersNameSpace[$type]['subscribed']);
					}

					if($_getCounters == true) {
						$folderObject->counter = $this->bofelamimail->getMailBoxCounters($folderName);
					}
					if(strtoupper($folderName) == 'INBOX') {
						$folderName = 'INBOX';
						$folderObject->folderName	= 'INBOX';
						$folderObject->shortFolderName	= 'INBOX';
						$folderObject->displayName	= lang('INBOX');
						$folderObject->shortDisplayName = lang('INBOX');
						$folderObject->subscribed	= true;
					// translate the automatic Folders (Sent, Drafts, ...) like the INBOX
					} elseif (in_array($shortName,self::$autoFolders)) {
						$tmpfolderparts = explode($delimiter,$folderObject->folderName);
						array_pop($tmpfolderparts);
						$folderObject->displayName = implode($delimiter,$tmpfolderparts).$delimiter.lang($shortName);
						$folderObject->shortDisplayName = lang($shortName);
						unset($tmpfolderparts);
					} else {
						$folderObject->displayName = $this->encodeFolderName($folderObject->folderName);
						$folderObject->shortDisplayName = $this->encodeFolderName($shortName);
					}
					//$folderName = $folderName;
					if (in_array($shortName,self::$autoFolders)&&self::searchValueInFolderObjects($shortName,$autoFolderObjects)===false) {
						$autoFolderObjects[$folderName] = $folderObject;
					} else {
						$folders[$folderName] = $folderObject;
					}
				}
			}
		}
		if (is_array($autoFolderObjects) && !empty($autoFolderObjects)) {
			uasort($autoFolderObjects,array($this,"sortByAutoFolderPos"));
		}
		if (is_array($folders)) uasort($folders,array($this,"sortByDisplayName"));
		//$folders2return = array_merge($autoFolderObjects,$folders);
		//_debug_array($folders2return); #exit;
		$folders2return[$this->icServer->ImapServerId] = array_merge($inboxFolderObject,$autoFolderObjects,(array)$folders);
		if ($_subscribedOnly && $_getCounters===false) egw_cache::setCache(egw_cache::INSTANCE,'email','folderObjects'.trim($GLOBALS['egw_info']['user']['account_id']),$folders2return,$expiration=60*60*1);
		return $folders2return[$this->icServer->ImapServerId];
	}

	static function searchValueInFolderObjects($needle, $haystack)
	{
		$rv = false;
		foreach ($haystack as $k => $v)
		{
			foreach($v as $sk => $sv) if (trim($sv)==trim($needle)) return $k;
		}
		return $rv;
	}

	function sortByDisplayName($a,$b)
	{
		// 0, 1 und -1
		return strcasecmp($a->displayName,$b->displayName);
	}

	function sortByAutoFolderPos($a,$b)
	{
		// 0, 1 und -1
		$pos1 = array_search(trim($a->shortFolderName),self::$autoFolders);
		$pos2 = array_search(trim($b->shortFolderName),self::$autoFolders);
		if ($pos1 == $pos2) return 0;
		return ($pos1 < $pos2) ? -1 : 1;
	}

	function getMailBoxCounters($folderName)
	{
		$folderStatus = $this->_getStatus($folderName);
		//error_log(__METHOD__.__LINE__." FolderStatus:".array2string($folderStatus));
		if ( PEAR::isError($folderStatus)) {
			if (self::$debug) error_log(__METHOD__." returned FolderStatus for Folder $folderName:".print_r($folderStatus->message,true));
			return false;
		}
		if(is_array($folderStatus)) {
			$status =  new stdClass;
			$status->messages   = $folderStatus['MESSAGES'];
			$status->unseen     = $folderStatus['UNSEEN'];
			$status->recent     = $folderStatus['RECENT'];
			$status->uidnext        = $folderStatus['UIDNEXT'];
			$status->uidvalidity    = $folderStatus['UIDVALIDITY'];

			return $status;
		}
		return false;
	}

	function getMailBoxesRecursive($_mailbox, $delimiter, $prefix, $reclevel=0)
	{
		#echo __METHOD__." retrieve SubFolders for $_mailbox$delimiter 
";
		$maxreclevel=25;
		if ($reclevel > $maxreclevel) {
			error_log( __METHOD__." Recursion Level Exeeded ($reclevel) while looking up $_mailbox$delimiter ");
			return array();
		}
		$reclevel++;
		// clean up double delimiters
		$_mailbox = preg_replace('~'.($delimiter == '.' ? "\\".$delimiter:$delimiter).'+~s',$delimiter,$_mailbox);
		//get that mailbox in question
		$mbx = $this->icServer->getMailboxes($_mailbox,1,true);
		#_debug_array($mbx);
		if (is_array($mbx[0]["ATTRIBUTES"]) && (in_array('\HasChildren',$mbx[0]["ATTRIBUTES"]) || in_array('\Haschildren',$mbx[0]["ATTRIBUTES"]))) {
			// if there are children fetch them
			//echo $mbx[0]['MAILBOX']."
";
			unset($buff);
			$buff = $this->icServer->getMailboxes($mbx[0]['MAILBOX'].($mbx[0]['MAILBOX'] == $prefix ? '':$delimiter),2,false);
			//$buff = $this->icServer->getMailboxes($mbx[0]['MAILBOX'],2,false);
			//_debug_array($buff);
			if( PEAR::isError($buff) ) {
				if (self::$debug) error_log(__METHOD__." Error while retrieving Mailboxes for:".$mbx[0]['MAILBOX'].$delimiter.".");
				return array();
			} else {
				$allMailboxes = array();
				foreach ($buff as $mbxname) {
					$mbxname = preg_replace('~'.($delimiter == '.' ? "\\".$delimiter:$delimiter).'+~s',$delimiter,$mbxname);
					#echo "About to recur in level $reclevel:".$mbxname."
";
					if ( $mbxname != $mbx[0]['MAILBOX'] && $mbxname != $prefix  && $mbxname != $mbx[0]['MAILBOX'].$delimiter) $allMailboxes = array_merge($allMailboxes, self::getMailBoxesRecursive($mbxname, $delimiter, $prefix, $reclevel));
				}
				if (!(in_array('\NoSelect',$mbx[0]["ATTRIBUTES"]) || in_array('\Noselect',$mbx[0]["ATTRIBUTES"]))) $allMailboxes[] = $mbx[0]['MAILBOX'];
				return $allMailboxes;
			}
		} else {
			return array($_mailbox);
		}
	}

	/**
	 * getMimePartCharset - fetches the charset mimepart if it exists
	 * @param $_mimePartObject structure object
	 * @return mixed mimepart or false if no CHARSET is found, the missing charset has to be handled somewhere else,
	 *		as we cannot safely assume any charset as we did earlier
	 */
	function getMimePartCharset($_mimePartObject)
	{
		//$charSet = 'iso-8859-1';//self::$displayCharset; //'iso-8859-1'; // self::displayCharset seems to be asmarter fallback than iso-8859-1
		$CharsetFound=false;
		//echo "#".$_mimePartObject->encoding.'#
';
		if(is_array($_mimePartObject->parameters)) {
			if(isset($_mimePartObject->parameters['CHARSET'])) {
				$charSet = $_mimePartObject->parameters['CHARSET'];
				$CharsetFound=true;
			}
		}
		// this one is dirty, but until I find something that does the trick of detecting the encoding, ....
		//if ($CharsetFound == false && $_mimePartObject->encoding == "QUOTED-PRINTABLE") $charSet = 'iso-8859-1'; //assume quoted-printable to be ISO
		//if ($CharsetFound == false && $_mimePartObject->encoding == "BASE64") $charSet = 'utf-8'; // assume BASE64 to be UTF8
		return ($CharsetFound ? $charSet : $CharsetFound);
	}

	function getMultipartAlternative($_uid, $_structure, $_htmlMode, $_preserveSeen = false)
	{
		// a multipart/alternative has exactly 2 parts (text and html  OR  text and something else)
		// sometimes there are 3 parts, when there is an ics/ical attached/included-> we want to show that
		// as attachment AND as abstracted ical information (we use our notification style here).
		$partText = false;
		$partHTML = false;
		if (self::$debug) _debug_array(array("METHOD"=>__METHOD__,"LINE"=>__LINE__,"STRUCTURE"=>$_structure));
		foreach($_structure as $mimePart) {
			if($mimePart->type == 'TEXT' && ($mimePart->subType == 'PLAIN' || $mimePart->subType == 'CALENDAR') && $mimePart->bytes > 0) {
				if ($mimePart->subType == 'CALENDAR' && $partText === false) $partText = $mimePart; // only if there is no partText set already
				if ($mimePart->subType == 'PLAIN') $partText = $mimePart;
			} elseif($mimePart->type == 'TEXT' && $mimePart->subType == 'HTML' && $mimePart->bytes > 0) {
				$partHTML = $mimePart;
			} elseif ($mimePart->type == 'MULTIPART' && $mimePart->subType == 'RELATED' && is_array($mimePart->subParts)) {
				// in a multipart alternative we treat the multipart/related as html part
				#$partHTML = array($mimePart);
				if (self::$debug) error_log(__METHOD__." process MULTIPART/RELATED with array as subparts");
				$partHTML = $mimePart;
			} elseif ($mimePart->type == 'MULTIPART' && $mimePart->subType == 'ALTERNATIVE' && is_array($mimePart->subParts)) {
				//cascading multipartAlternative structure, assuming only the first one is to be used
				return $this->getMultipartAlternative($_uid,$mimePart->subParts,$_htmlMode, $_preserveSeen);
			}
		}
		//error_log(__METHOD__.__LINE__.$_htmlMode);
		switch($_htmlMode) {
			case 'html_only':
			case 'always_display':
				if(is_object($partHTML)) {
					if($partHTML->subType == 'RELATED') {
						return $this->getMultipartRelated($_uid, $partHTML, $_htmlMode, $_preserveSeen);
					} else {
						return $this->getTextPart($_uid, $partHTML, $_htmlMode, $_preserveSeen);
					}
				} elseif(is_object($partText) && $_htmlMode=='always_display') {
					return $this->getTextPart($_uid, $partText, $_htmlMode, $_preserveSeen);
				}

				break;
			case 'only_if_no_text':
				if(is_object($partText)) {
					return $this->getTextPart($_uid, $partText, $_htmlMode, $_preserveSeen);
				} elseif(is_object($partHTML)) {
					if($partHTML->type) {
						return $this->getMultipartRelated($_uid, $partHTML, $_htmlMode, $_preserveSeen);
					} else {
						return $this->getTextPart($_uid, $partHTML, 'always_display', $_preserveSeen);
					}
				}

				break;

			default:
				if(is_object($partText)) {
					return $this->getTextPart($_uid, $partText, $_htmlMode, $_preserveSeen);
				} else {
					$bodyPart = array(
						'body'		=> lang("no plain text part found"),
						'mimeType'	=> 'text/plain',
						'charSet'	=> self::$displayCharset,
					);
				}

				break;
		}

		return $bodyPart;
	}

	function getMultipartMixed($_uid, $_structure, $_htmlMode, $_preserveSeen = false)
	{
		if (self::$debug) echo __METHOD__."$_uid, $_htmlMode
";
		$bodyPart = array();
		if (self::$debug) _debug_array($_structure);
		if (!is_array($_structure)) $_structure = array($_structure);
		foreach($_structure as $part) {
			if (self::$debug) echo $part->type."/".$part->subType."
";
			switch($part->type) {
				case 'MULTIPART':
					switch($part->subType) {
						case 'ALTERNATIVE':
							$bodyPart[] = $this->getMultipartAlternative($_uid, $part->subParts, $_htmlMode, $_preserveSeen);
							break;

						case 'MIXED':
						case 'SIGNED':
							$bodyPart = array_merge($bodyPart, $this->getMultipartMixed($_uid, $part->subParts, $_htmlMode, $_preserveSeen));
							break;

						case 'RELATED':
							$bodyPart = array_merge($bodyPart, $this->getMultipartRelated($_uid, $part->subParts, $_htmlMode, $_preserveSeen));
							break;
					}
					break;

				case 'TEXT':
					switch($part->subType) {
						case 'PLAIN':
						case 'HTML':
						case 'CALENDAR': // inline ics/ical files
							if($part->disposition != 'ATTACHMENT') {
								$bodyPart[] = $this->getTextPart($_uid, $part, $_htmlMode, $_preserveSeen);
							}
							//error_log(__METHOD__.__LINE__.' ->'.$part->type."/".$part->subType.' -> BodyPart:'.array2string($bodyPart[count($bodyPart)-1]));
							break;
					}
					break;

				case 'MESSAGE':
					if($part->subType == 'delivery-status') {
						$bodyPart[] = $this->getTextPart($_uid, $part, $_htmlMode, $_preserveSeen);
					}
					break;

				default:
					// do nothing
					// the part is a attachment
					#$bodyPart[] = $this->getMessageBody($_uid, $_htmlMode, $part->partID, $part);
					#if (!($part->type == 'TEXT' && ($part->subType == 'PLAIN' || $part->subType == 'HTML'))) {
					#	$bodyPart[] = $this->getMessageAttachments($_uid, $part->partID, $part);
					#}
			}
		}

		return $bodyPart;
	}

	function getMultipartRelated($_uid, $_structure, $_htmlMode, $_preserveSeen = false)
	{
		return $this->getMultipartMixed($_uid, $_structure, $_htmlMode, $_preserveSeen);
	}

	function getTextPart($_uid, $_structure, $_htmlMode = '', $_preserveSeen = false)
	{
		//error_log(__METHOD__.__LINE__.'->'.$_uid.':'.array2string($_structure).' '.function_backtrace());
		$bodyPart = array();
		if (self::$debug) _debug_array(array($_structure,function_backtrace()));
		$partID = $_structure->partID;
		$mimePartBody = $this->icServer->getBodyPart($_uid, $partID, true, $_preserveSeen);
		if (PEAR::isError($mimePartBody))
		{
			error_log(__METHOD__.__LINE__.' failed:'.$mimePartBody->message);
			return false;
		}
		//_debug_array($mimePartBody);
		//error_log(__METHOD__.__LINE__.' UID:'.$_uid.' PartID:'.$partID.' HTMLMode:'.$_htmlMode.' ->'.array2string($_structure).array2string($mimePartBody));
		if (empty($mimePartBody)) return array(
				'body'		=> '',
				'mimeType'  => ($_structure->type == 'TEXT' && $_structure->subType == 'HTML') ? 'text/html' : 'text/plain',
				'charSet'   => self::$displayCharset,
			);
		//_debug_array(preg_replace('/PropertyFile___$/','',$this->decodeMimePart($mimePartBody, $_structure->encoding)));
		if($_structure->subType == 'HTML' && $_htmlMode!= 'html_only' && $_htmlMode != 'always_display'  && $_htmlMode != 'only_if_no_text') {
			$bodyPart = array(
				'error'		=> 1,
				'body'		=> lang("displaying html messages is disabled"),
				'mimeType'	=> 'text/html',
				'charSet'	=> self::$displayCharset,
			);
		} elseif ($_structure->subType == 'PLAIN' && $_htmlMode == 'html_only') {
			$bodyPart = array(
				'error'		=> 1,
				'body'      => lang("displaying plain messages is disabled"),
				'mimeType'  => 'text/plain', // make sure we do not return mimeType text/html
				'charSet'   => self::$displayCharset,
			);
		} else {
			// some Servers append PropertyFile___ ; strip that here for display
			$bodyPart = array(
				'body'		=> preg_replace('/PropertyFile___$/','',$this->decodeMimePart($mimePartBody, $_structure->encoding, $this->getMimePartCharset($_structure))),
				'mimeType'	=> ($_structure->type == 'TEXT' && $_structure->subType == 'HTML') ? 'text/html' : 'text/plain',
				'charSet'	=> $this->getMimePartCharset($_structure),
			);
			if ($_structure->subType == 'CALENDAR')
			{
				// we get an inline CALENDAR ical/ics, we display it using the calendar notification style
				$calobj = new calendar_ical;
				$calboupdate = new calendar_boupdate;
				// timezone stuff
				$tz_diff = $GLOBALS['egw_info']['user']['preferences']['common']['tz_offset'] - $this->common_prefs['tz_offset'];
				// form an event out of ical
				$event = $calobj->icaltoegw($bodyPart['body']);
				$event= $event[0];
				// preset the olddate
				$olddate = $calboupdate->format_date($event['start']+$tz_diff);
				// search egw, if we can find it
				$eventid = $calobj->find_event(array('uid'=>$event['uid']));
				if ((int)$eventid[0]>0)
				{
					// we found an event, we use the first one
					$oldevent = $calobj->read($eventid);
					// we set the olddate, to comply with the possible merge params for the notification message
					if($oldevent != False && $oldevent[$eventid[0]]['start']!=$event[$eventid[0]]['start']) {
						$olddate = $calboupdate->format_date($oldevent[$eventid[0]]['start']+$tz_diff);
					}
					// we merge the changes and the original event
					$event = array_merge($oldevent[$eventid[0]],$event);
					// for some strange reason, the title of the old event is not replaced with the new title
					// if you klick on the ics and import it into egw, so we dont show the title here.
					// so if it is a mere reply, we dont use the new title (more detailed info/work needed here)
					if ($_structure->parameters['METHOD']=='REPLY') $event['title'] = $oldevent[$eventid[0]]['title'];
				}
				// we prepare the message
				$details = $calboupdate->_get_event_details($event,$action,$event_arr);
				$details['olddate']=$olddate;
				//_debug_array($_structure);
				list($subject,$info) = $calboupdate->get_update_message($event,($_structure->parameters['METHOD']=='REPLY'?false:true));
				$info = $GLOBALS['egw']->preferences->parse_notify($info,$details);
				// we set the bodyPart, we only show the event, we dont actually do anything, as we expect the user to
				// click on the attached ics to update his own eventstore
				$bodyPart['body'] = $subject;
				$bodyPart['body'] .= "\n".$info;
				$bodyPart['body'] .= "\n\n".lang('Event Details follow').":\n";
				foreach($event_arr as $key => $val)
				{
					if(strlen($details[$key])) {
						switch($key){
					 		case 'access':
							case 'priority':
							case 'link':
								break;
							default:
								$bodyPart['body'] .= sprintf("%-20s %s\n",$val['field'].':',$details[$key]);
								break;
					 	}
					}
				}
			}
		}
		//_debug_array($bodyPart);
		return $bodyPart;
	}

	function getHierarchyDelimiter()
	{
		static $HierarchyDelimiter;
		if (is_null($HierarchyDelimiter)) $HierarchyDelimiter =& egw_cache::getSession('felamimail','HierarchyDelimiter');
		if (isset($HierarchyDelimiter[$this->icServer->ImapServerId])&&!empty($HierarchyDelimiter[$this->icServer->ImapServerId]))
		{
			$this->icServer->mailboxDelimiter = $HierarchyDelimiter[$this->icServer->ImapServerId];
			return $HierarchyDelimiter[$this->icServer->ImapServerId];
		}
		$HierarchyDelimiter[$this->icServer->ImapServerId] = '/';
		if(($this->icServer instanceof defaultimap))
		{
			$HierarchyDelimiter[$this->icServer->ImapServerId] = $this->icServer->getHierarchyDelimiter();
			if (PEAR::isError($HierarchyDelimiter[$this->icServer->ImapServerId])) $HierarchyDelimiter[$this->icServer->ImapServerId] = '/';
		}
		$this->icServer->mailboxDelimiter = $HierarchyDelimiter[$this->icServer->ImapServerId];
		return $HierarchyDelimiter[$this->icServer->ImapServerId];
	}


	function getSpecialUseFolders()
	{
		static $specialUseFolders;
		if (is_null($specialUseFolders)) $specialUseFolders = egw_cache::getCache(egw_cache::INSTANCE,'email','specialUseFolders'.trim($GLOBALS['egw_info']['user']['account_id']),$callback=null,$callback_params=array(),$expiration=60*60*24*5);
		if (isset($specialUseFolders[$this->icServer->ImapServerId]))
		{
			return $specialUseFolders[$this->icServer->ImapServerId];
		}
		if(($this->icServer instanceof defaultimap))
		{
			if(($this->hasCapability('SPECIAL-USE')))
			{
				$ret = $this->icServer->getSpecialUseFolders();
				if (PEAR::isError($ret))
				{
					$specialUseFolders[$this->icServer->ImapServerId]=array();
				}
				else
				{
					foreach ($ret as $k => $f)
					{
						if (isset($f['ATTRIBUTES']) && !empty($f['ATTRIBUTES']) &&
							!in_array('\\NonExistent',$f['ATTRIBUTES']))
						{
							foreach (self::$autoFolders as $i => $n) // array('Drafts', 'Templates', 'Sent', 'Trash', 'Junk', 'Outbox');
							{
								if (in_array('\\'.$n,$f['ATTRIBUTES'])) $specialUseFolders[$this->icServer->ImapServerId][$f['MAILBOX']] = $n;
							}
						}
					}
				}
				egw_cache::setCache(egw_cache::INSTANCE,'email','specialUseFolders'.trim($GLOBALS['egw_info']['user']['account_id']),$specialUseFolders, $expiration=60*60*24*5);
			}
		}
		return $specialUseFolders[$this->icServer->ImapServerId];
	}

	/**
	* fetches a sorted list of messages from the imap server
	* private function
	*
	* @todo implement sort based on Net_IMAP
	* @param string $_folderName the name of the folder in which the messages get searched
	* @param integer $_sort the primary sort key
	* @param bool $_reverse sort the messages ascending or descending
	* @param array $_filter the search filter
	* @param bool $resultByUid if set to true, the result is to be returned by uid, if the server does not reply
	* 			on a query for uids, the result may be returned by IDs only, this will be indicated by this param
	* @param bool $setSession if set to true the session will be populated with the result of the query
	* @return bool
	*/
	function getSortedList($_folderName, $_sort, &$_reverse, $_filter, &$resultByUid=true, $setSession=true)
	{
		//ToDo: FilterSpecific Cache
		if(PEAR::isError($folderStatus = $this->icServer->examineMailbox($_folderName))) {
			return false;
		}
		//error_log(__METHOD__.__LINE__.array2string($folderStatus));
		//error_log(__METHOD__.__LINE__.' Filter:'.array2string($_filter));
		$try2useCache = true;
		static $eMailListContainsDeletedMessages;
		if (is_null($eMailListContainsDeletedMessages)) $eMailListContainsDeletedMessages = egw_cache::getCache(egw_cache::INSTANCE,'email','eMailListContainsDeletedMessages'.trim($GLOBALS['egw_info']['user']['account_id']),$callback=null,$callback_params=array(),$expiration=60*60*1);
		// this indicates, that there is no Filter set, and the returned set/subset should not contain DELETED Messages, nor filtered for UNDELETED
		if ($setSession==true && ((strpos(array2string($_filter), 'UNDELETED') === false && strpos(array2string($_filter), 'DELETED') === false)))
		{
			//$starttime = microtime(true);
			//$deletedMessages = $this->getSortedList($_folderName, $_sort=0, $_reverse=1, $_filter=array('status'=>array('DELETED')),$byUid=true,false);
			$deletedMessages = $this->getSortedList($_folderName, 0, $three=1, array('status'=>array('DELETED')),$five=true,false);
			//error_log(__METHOD__.__LINE__.array2string($deletedMessages));
			$eMailListContainsDeletedMessages[$this->profileID][$_folderName] = count($deletedMessages);
			egw_cache::setCache(egw_cache::INSTANCE,'email','eMailListContainsDeletedMessages'.trim($GLOBALS['egw_info']['user']['account_id']),$eMailListContainsDeletedMessages, $expiration=60*60*1);
			//$endtime = microtime(true);
			//$r = ($endtime-$starttime);
			//error_log(__METHOD__.__LINE__.' Profile:'.$this->profileID.' Folder:'.$_folderName.' -> EXISTS/SessStat:'.array2string($folderStatus['EXISTS']).'/'.$this->sessionData['folderStatus'][$this->profileID][$_folderName]['messages'].' ListContDelMsg/SessDeleted:'.$eMailListContainsDeletedMessages[$this->profileID][$_folderName].'/'.$this->sessionData['folderStatus'][$this->profileID][$_folderName]['deleted']);
			//error_log(__METHOD__.__LINE__.' Took:'.$r.'(s) setting eMailListContainsDeletedMessages for Profile:'.$this->profileID.' Folder:'.$_folderName.' to '.$eMailListContainsDeletedMessages[$this->profileID][$_folderName]);
		}
		if (self::$debug)
		{
			error_log(__METHOD__.__LINE__.' Profile:'.$this->profileID.' Folder:'.$_folderName.' -> EXISTS/SessStat:'.array2string($folderStatus['EXISTS']).'/'.$this->sessionData['folderStatus'][$this->profileID][$_folderName]['messages'].' ListContDelMsg/SessDeleted:'.$eMailListContainsDeletedMessages[$this->profileID][$_folderName].'/'.$this->sessionData['folderStatus'][$this->profileID][$_folderName]['deleted']);
			error_log(__METHOD__.__LINE__.' CachedFolderStatus:'.array2string($this->sessionData['folderStatus'][$this->profileID][$_folderName]));
		}
		if($try2useCache && (is_array($this->sessionData['folderStatus'][$this->profileID][$_folderName]) &&
			$this->sessionData['folderStatus'][$this->profileID][$_folderName]['uidValidity']	=== $folderStatus['UIDVALIDITY'] &&
			$this->sessionData['folderStatus'][$this->profileID][$_folderName]['messages']	== $folderStatus['EXISTS'] &&
			$this->sessionData['folderStatus'][$this->profileID][$_folderName]['deleted']	== $eMailListContainsDeletedMessages[$this->profileID][$_folderName] &&
			$this->sessionData['folderStatus'][$this->profileID][$_folderName]['uidnext']	=== $folderStatus['UIDNEXT'] &&
			$this->sessionData['folderStatus'][$this->profileID][$_folderName]['filter']	=== $_filter &&
			$this->sessionData['folderStatus'][$this->profileID][$_folderName]['sort']	=== $_sort &&
			//$this->sessionData['folderStatus'][0][$_folderName]['reverse'] === $_reverse &&
			!empty($this->sessionData['folderStatus'][$this->profileID][$_folderName]['sortResult']))
		) {
			if (self::$debug) error_log(__METHOD__." USE CACHE for Profile:". $this->profileID." Folder:".$_folderName.'->'.($setSession?'setSession':'checkrun').' Filter:'.array2string($_filter).function_backtrace());
			$sortResult = $this->sessionData['folderStatus'][$this->profileID][$_folderName]['sortResult'];

		} else {
			$try2useCache = false;
			//error_log(__METHOD__." USE NO CACHE for Profile:". $this->profileID." Folder:".$_folderName.'->'.($setSession?'setSession':'checkrun'));
			if (self::$debug) error_log(__METHOD__." USE NO CACHE for Profile:". $this->profileID." Folder:".$_folderName." Filter:".array2string($_filter).function_backtrace());
			$filter = $this->createIMAPFilter($_folderName, $_filter);
			//_debug_array($filter);

			if($this->icServer->hasCapability('SORT')) {
				if (self::$debug) error_log(__METHOD__." Mailserver has SORT Capability, SortBy: $_sort Reverse: $_reverse");
				$sortOrder = $this->_getSortString($_sort, $_reverse);
				if ($_reverse && strpos($sortOrder,'REVERSE')!==false) $_reverse=false; // as we reversed the result already
				if (self::$debug) error_log(__METHOD__." Mailserver runs SORT: SortBy: $sortOrder Filter: $filter");
				if (!empty(self::$displayCharset)) {
					$sortResult = $this->icServer->sort($sortOrder, strtoupper( self::$displayCharset ), $filter, $resultByUid);
				}
				if (PEAR::isError($sortResult) || empty(self::$displayCharset)) {
					$sortResult = $this->icServer->sort($sortOrder, 'US-ASCII', $filter, $resultByUid);
					// if there is an PEAR Error, we assume that the server is not capable of sorting
					if (PEAR::isError($sortResult)) {
						$advFilter = 'CHARSET '. strtoupper(self::$displayCharset) .' '.$filter;
						if (PEAR::isError($sortResult))
						{
							$resultByUid = false;
							$sortResult = $this->icServer->search($filter, $resultByUid);
							if (PEAR::isError($sortResult))
							{
								$sortResult = $this->sessionData['folderStatus'][$this->profileID][$_folderName]['sortResult'];
							}
						}
					}
				}
				if (self::$debug) error_log(__METHOD__.print_r($sortResult,true));
			} else {
				if (self::$debug) error_log(__METHOD__." Mailserver has NO SORT Capability");
				$advFilter = 'CHARSET '. strtoupper(self::$displayCharset) .' '.$filter;
				$sortResult = $this->icServer->search($advFilter, $resultByUid);
				if (PEAR::isError($sortResult))
				{
					$sortResult = $this->icServer->search($filter, $resultByUid);
					if (PEAR::isError($sortResult))
					{
						// some servers are not replying on a search for uids, so try this one
						$resultByUid = false;
						$sortResult = $this->icServer->search('*', $resultByUid);
						if (PEAR::isError($sortResult))
						{
							error_log(__METHOD__.__LINE__.' PEAR_Error:'.array2string($sortResult->message));
							$sortResult = null;
						}
					}
				}
				if(is_array($sortResult)) {
						sort($sortResult, SORT_NUMERIC);
				}
				if (self::$debug) error_log(__METHOD__." using Filter:".print_r($filter,true)." ->".print_r($sortResult,true));
			}
			if ($setSession)
			{
				$this->sessionData['folderStatus'][$this->profileID][$_folderName]['uidValidity'] = $folderStatus['UIDVALIDITY'];
				$this->sessionData['folderStatus'][$this->profileID][$_folderName]['messages']	= $folderStatus['EXISTS'];
				$this->sessionData['folderStatus'][$this->profileID][$_folderName]['uidnext']	= $folderStatus['UIDNEXT'];
				$this->sessionData['folderStatus'][$this->profileID][$_folderName]['filter']	= $_filter;
				$this->sessionData['folderStatus'][$this->profileID][$_folderName]['sortResult'] = $sortResult;
				$this->sessionData['folderStatus'][$this->profileID][$_folderName]['sort']	= $_sort;
			}
		}
		if ($setSession)
		{
			// this indicates, that there should be no UNDELETED Messages in the returned set/subset
			if (((strpos(array2string($_filter), 'UNDELETED') === false && strpos(array2string($_filter), 'DELETED') === false)))
			{
				if ($try2useCache == false) $this->sessionData['folderStatus'][$this->profileID][$_folderName]['deleted'] = $eMailListContainsDeletedMessages[$this->profileID][$_folderName];
			}
			$this->sessionData['folderStatus'][$this->profileID][$_folderName]['reverse'] 	= $_reverse;
			$this->saveSessionData();
		}
		return $sortResult;
	}

	function getMessageEnvelope($_uid, $_partID = '',$decode=false)
	{
		if($_partID == '') {
			if( PEAR::isError($envelope = $this->icServer->getEnvelope('', $_uid, true)) ) {
				return false;
			}
			//if ($decode) _debug_array($envelope[0]);
			return ($decode ? self::decode_header($envelope[0]): $envelope[0]);
		} else {
			if( PEAR::isError($headers = $this->icServer->getParsedHeaders($_uid, true, $_partID, true)) ) {
				return false;
			}
			//_debug_array($headers);
			$newData = array(
				'DATE'		=> $headers['DATE'],
				'SUBJECT'	=> ($decode ? self::decode_header($headers['SUBJECT']):$headers['SUBJECT']),
				'MESSAGE_ID'	=> $headers['MESSAGE-ID']
			);
			//_debug_array($newData);
			$recepientList = array('FROM', 'TO', 'CC', 'BCC', 'SENDER', 'REPLY_TO');
			foreach($recepientList as $recepientType) {
				if(isset($headers[$recepientType])) {
					if ($decode) $headers[$recepientType] =  self::decode_header($headers[$recepientType]);
					$addresses = imap_rfc822_parse_adrlist($headers[$recepientType], '');
					foreach($addresses as $singleAddress) {
						$addressData = array(
							'PERSONAL_NAME'		=> $singleAddress->personal ? $singleAddress->personal : 'NIL',
							'AT_DOMAIN_LIST'	=> $singleAddress->adl ? $singleAddress->adl : 'NIL',
							'MAILBOX_NAME'		=> $singleAddress->mailbox ? $singleAddress->mailbox : 'NIL',
							'HOST_NAME'		=> $singleAddress->host ? $singleAddress->host : 'NIL',
							'EMAIL'			=> $singleAddress->host ? $singleAddress->mailbox.'@'.$singleAddress->host : $singleAddress->mailbox,
						);
						if($addressData['PERSONAL_NAME'] != 'NIL') {
							$addressData['RFC822_EMAIL'] = imap_rfc822_write_address($singleAddress->mailbox, $singleAddress->host, $singleAddress->personal);
						} else {
							$addressData['RFC822_EMAIL'] = 'NIL';
						}
						$newData[$recepientType][] = $addressData;
					}
				} else {
					if($recepientType == 'SENDER' || $recepientType == 'REPLY_TO') {
						$newData[$recepientType] = $newData['FROM'];
					} else {
						$newData[$recepientType] = array();
					}
				}
			}
			//if ($decode) _debug_array($newData);

			return $newData;
		}
	}

	function getHeaders($_folderName, $_startMessage, $_numberOfMessages, $_sort, $_reverse, $_filter, $_thisUIDOnly=null, $_cacheResult=true)
	{
		//self::$debug=true;
		if (self::$debug) error_log(__METHOD__.__LINE__.function_backtrace());
		if (self::$debug) error_log(__METHOD__.__LINE__."$_folderName,$_startMessage, $_numberOfMessages, $_sort, $reverse, ".array2string($_filter).", $_thisUIDOnly");
		$reverse = (bool)$_reverse;
		// get the list of messages to fetch
		if (self::$debug) $starttime = microtime (true);
		$this->reopen($_folderName);
		if (self::$debug)
		{
			$endtime = microtime(true) - $starttime;
			error_log(__METHOD__. " time used for reopen: ".$endtime.' for Folder:'.$_folderName);
		}
		//$this->icServer->selectMailbox($_folderName);
		$rByUid = true; // try searching by uid. this var will be passed by reference to getSortedList, and may be set to false, if UID retrieval fails
		#print "
";
		#$this->icServer->setDebug(true);
		if ($_thisUIDOnly === null)
		{
			if (($_startMessage || $_numberOfMessages) && !isset($_filter['range']))
			{
				// this will not work we must calculate the range we want to retieve as e.g.: 0:20 retirieves the first 20 mails and sorts them
				// if sort capability is applied to the range fetched, not sort first and fetch the range afterwards
				$start = $_startMessage-1;
				$end = $_startMessage-1+$_numberOfMessages;
				//$_filter['range'] ="$start:$end";
				//$_filter['range'] ="$_startMessage:*";
			}
			if (self::$debug) error_log(__METHOD__.__LINE__."$_folderName, $_sort, $reverse, ".array2string($_filter).", $rByUid");
			if (self::$debug) $starttime = microtime (true);
			$sortResult = $this->getSortedList($_folderName, $_sort, $reverse, $_filter, $rByUid, $_cacheResult);
			if (self::$debug)
			{
				$endtime = microtime(true) - $starttime;
				error_log(__METHOD__. " time used for getSortedList: ".$endtime.' for Folder:'.$_folderName.' Filter:'.array2string($_filter).' Ids:'.array2string($_thisUIDOnly));
			}
			if (self::$debug) error_log(__METHOD__.__LINE__.array2string($sortResult));
			#$this->icServer->setDebug(false);
			#print "
";
			// nothing found
			if(!is_array($sortResult) || empty($sortResult)) {
				$retValue = array();
				$retValue['info']['total']	= 0;
				$retValue['info']['first']	= 0;
				$retValue['info']['last']	= 0;
				return $retValue;
			}

			$total = count($sortResult);
			#_debug_array($sortResult);
			#_debug_array(array_slice($sortResult, -5, -2));
			//error_log("REVERSE: $reverse");
			if($reverse === true) {
				if  ($_startMessage<=$total)
				{
					$startMessage = $_startMessage-1;
				}
				else
				{
//error_log(__METHOD__.__LINE__.' Start:'.$_startMessage.' NumberOfMessages:'.$_numberOfMessages.' Total:'.$total);
					if ($_startMessage+$_numberOfMessages>$total)
					{
						$numberOfMessages = $total%$_numberOfMessages;
						//$numberOfMessages = abs($_startMessage-$total-1);
						if ($numberOfMessages>0 && $numberOfMessages<=$_numberOfMessages) $_numberOfMessages = $numberOfMessages;
//error_log(__METHOD__.__LINE__.' Start:'.$_startMessage.' NumberOfMessages:'.$_numberOfMessages.' Total:'.$total);
					}
					$startMessage=($total-$_numberOfMessages)-1;
					//$retValue['info']['first'] = $startMessage;
					//$retValue['info']['last'] = $total;

				}
				if ($startMessage+$_numberOfMessages>$total)
				{
					$_numberOfMessages = $_numberOfMessages-($total-($startMessage+$_numberOfMessages));
					//$retValue['info']['first'] = $startMessage;
					//$retValue['info']['last'] = $total;
				}
				if($startMessage > 0) {
					if (self::$debug) error_log(__METHOD__.__LINE__.' StartMessage:'.(-($_numberOfMessages+$startMessage)).', '.-$startMessage.' Number of Messages:'.count($sortResult));
					$sortResult = array_slice($sortResult, -($_numberOfMessages+$startMessage), -$startMessage);
				} else {
					if (self::$debug) error_log(__METHOD__.__LINE__.' StartMessage:'.(-($_numberOfMessages+($_startMessage-1))).', AllTheRest, Number of Messages:'.count($sortResult));
					$sortResult = array_slice($sortResult, -($_numberOfMessages+($_startMessage-1)));
				}
				$sortResult = array_reverse($sortResult);
			} else {
				if (self::$debug) error_log(__METHOD__.__LINE__.' StartMessage:'.($_startMessage-1).', '.$_numberOfMessages.' Number of Messages:'.count($sortResult));
				$sortResult = array_slice($sortResult, $_startMessage-1, $_numberOfMessages);
			}
			if (self::$debug) error_log(__METHOD__.__LINE__.array2string($sortResult));
		}
		else
		{
			$sortResult = (is_array($_thisUIDOnly) ? $_thisUIDOnly:(array)$_thisUIDOnly);
		}

		$queryString = implode(',', $sortResult);
		// fetch the data for the selected messages
		if (self::$debug) $starttime = microtime(true);
		$headersNew = $this->icServer->getSummary($queryString, $rByUid);
		if (PEAR::isError($headersNew) && empty($queryString))
		{
			$headersNew = array();
			$sortResult = array();
		}
		if ($headersNew == null && empty($_thisUIDOnly)) // -> if we request uids, do not try to look for messages with ids
		{
			if (self::$debug) error_log(__METHOD__.__LINE__."Uid->$queryString, ByUID? $rByUid");
			// message retrieval via uid failed try one by one via message number
			$rByUid = false;
			foreach($sortResult as $k => $v)
			{
				if (self::$debug) error_log(__METHOD__.__LINE__.' Query:'.$v.':*');
				$rv = $this->icServer->getSummary($v.':*', $rByUid);
				$headersNew[] = $rv[0];
			}
		}
		if (self::$debug)
		{
			$endtime = microtime(true) - $starttime;
			error_log(__METHOD__. " time used for getSummary: ".$endtime.' for Folder:'.$_folderName.' Filter:'.array2string($_filter));
			error_log(__METHOD__.__LINE__.' Query:'.$queryString.' Result:'.array2string($headersNew));
		}

		$count = 0;

		foreach((array)$sortResult as $uid) {
			$sortOrder[$uid] = $count++;
		}

		$count = 0;
		if (is_array($headersNew)) {
			if (self::$debug) $starttime = microtime(true);
			foreach((array)$headersNew as $headerObject) {
				//if($count == 0) error_log(__METHOD__.array2string($headerObject));
				if (empty($headerObject['UID'])) continue;
				$uid = ($rByUid ? $headerObject['UID'] : $headerObject['MSG_NUM']);
				// make dates like "Mon, 23 Apr 2007 10:11:06 UT" working with strtotime
				if(substr($headerObject['DATE'],-2) === 'UT') {
					$headerObject['DATE'] .= 'C';
				}
				if(substr($headerObject['INTERNALDATE'],-2) === 'UT') {
					$headerObject['INTERNALDATE'] .= 'C';
				}
				//error_log(__METHOD__.__LINE__.' '.$headerObject['SUBJECT'].'->'.$headerObject['DATE']);
				//error_log(__METHOD__.__LINE__.' '.$this->decode_subject($headerObject['SUBJECT']).'->'.$headerObject['DATE']);
				$retValue['header'][$sortOrder[$uid]]['subject']	= $this->decode_subject($headerObject['SUBJECT']);
				$retValue['header'][$sortOrder[$uid]]['size'] 		= $headerObject['SIZE'];
				$retValue['header'][$sortOrder[$uid]]['date']		= self::_strtotime(($headerObject['DATE']&&!($headerObject['DATE']=='NIL')?$headerObject['DATE']:$headerObject['INTERNALDATE']),'ts',true);
				$retValue['header'][$sortOrder[$uid]]['internaldate']= self::_strtotime($headerObject['INTERNALDATE'],'ts',true);
				$retValue['header'][$sortOrder[$uid]]['mimetype']	= $headerObject['MIMETYPE'];
				$retValue['header'][$sortOrder[$uid]]['id']		= $headerObject['MSG_NUM'];
				$retValue['header'][$sortOrder[$uid]]['uid']		= $headerObject['UID'];
				$retValue['header'][$sortOrder[$uid]]['priority']		= ($headerObject['PRIORITY']?$headerObject['PRIORITY']:3);
				if (is_array($headerObject['FLAGS'])) {
					$retValue['header'][$sortOrder[$uid]]['recent']		= in_array('\\Recent', $headerObject['FLAGS']);
					$retValue['header'][$sortOrder[$uid]]['flagged']	= in_array('\\Flagged', $headerObject['FLAGS']);
					$retValue['header'][$sortOrder[$uid]]['answered']	= in_array('\\Answered', $headerObject['FLAGS']);
					$retValue['header'][$sortOrder[$uid]]['forwarded']   = in_array('$Forwarded', $headerObject['FLAGS']);
					$retValue['header'][$sortOrder[$uid]]['deleted']	= in_array('\\Deleted', $headerObject['FLAGS']);
					$retValue['header'][$sortOrder[$uid]]['seen']		= in_array('\\Seen', $headerObject['FLAGS']);
					$retValue['header'][$sortOrder[$uid]]['draft']		= in_array('\\Draft', $headerObject['FLAGS']);
					$retValue['header'][$sortOrder[$uid]]['mdnsent']	= in_array('MDNSent', $headerObject['FLAGS']);
					$retValue['header'][$sortOrder[$uid]]['mdnnotsent']	= in_array('MDNnotSent', $headerObject['FLAGS']);
					if (is_array($headerObject['FLAGS'])) $headerFlags = array_map('strtolower',$headerObject['FLAGS']);
					if (!empty($headerFlags))
					{
						$retValue['header'][$sortOrder[$uid]]['label1']   = in_array('$label1', $headerFlags);
						$retValue['header'][$sortOrder[$uid]]['label2']   = in_array('$label2', $headerFlags);
						$retValue['header'][$sortOrder[$uid]]['label3']   = in_array('$label3', $headerFlags);
						$retValue['header'][$sortOrder[$uid]]['label4']   = in_array('$label4', $headerFlags);
						$retValue['header'][$sortOrder[$uid]]['label5']   = in_array('$label5', $headerFlags);
					}
				}
				if(is_array($headerObject['FROM']) && is_array($headerObject['FROM'][0])) {
					if($headerObject['FROM'][0]['HOST_NAME'] != 'NIL') {
						$retValue['header'][$sortOrder[$uid]]['sender_address'] = self::decode_header($headerObject['FROM'][0]['EMAIL']);
					} else {
						$retValue['header'][$sortOrder[$uid]]['sender_address'] = self::decode_header($headerObject['FROM'][0]['MAILBOX_NAME']);
					}
					if($headerObject['FROM'][0]['PERSONAL_NAME'] != 'NIL') {
						$retValue['header'][$sortOrder[$uid]]['sender_name'] = self::decode_header($headerObject['FROM'][0]['PERSONAL_NAME']);
					}

				}

				if(is_array($headerObject['TO']) && is_array($headerObject['TO'][0])) {
					if($headerObject['TO'][0]['HOST_NAME'] != 'NIL') {
						$retValue['header'][$sortOrder[$uid]]['to_address'] = self::decode_header($headerObject['TO'][0]['EMAIL']);
					} else {
						$retValue['header'][$sortOrder[$uid]]['to_address'] = self::decode_header($headerObject['TO'][0]['MAILBOX_NAME']);
					}
					if($headerObject['TO'][0]['PERSONAL_NAME'] != 'NIL') {
						$retValue['header'][$sortOrder[$uid]]['to_name'] = self::decode_header($headerObject['TO'][0]['PERSONAL_NAME']);
					}
					if (count($headerObject['TO'])>1)
					{
						$ki=0;
						foreach($headerObject['TO'] as $k => $add)
						{
							if ($k==0) continue;
							//error_log(__METHOD__.__LINE__."-> $k:".array2string($add));
							if($add['HOST_NAME'] != 'NIL')
							{
								$retValue['header'][$sortOrder[$uid]]['additional_to_addresses'][$ki]['address'] = self::decode_header($add['EMAIL']);
							}
							else
							{
								$retValue['header'][$sortOrder[$uid]]['additional_to_addresses'][$ki]['address'] = self::decode_header($add['MAILBOX_NAME']);
							}
							if($headerObject['TO'][$k]['PERSONAL_NAME'] != 'NIL')
							{
								$retValue['header'][$sortOrder[$uid]]['additional_to_addresses'][$ki]['name'] = self::decode_header($add['PERSONAL_NAME']);
							}
							//error_log(__METHOD__.__LINE__.array2string($retValue['header'][$sortOrder[$uid]]['additional_to_addresses'][$ki]));
							$ki++;
						}
					}
				}

				$count++;
			}
			if (self::$debug)
			{
				$endtime = microtime(true) - $starttime;
				error_log(__METHOD__. " time used for the rest: ".$endtime.' for Folder:'.$_folderName);
			}
			//self::$debug=false;
			// sort the messages to the requested displayorder
			if(is_array($retValue['header'])) {
				$countMessages = $total;
				if (isset($_filter['range'])) $countMessages = $this->sessionData['folderStatus'][$this->profileID][$_folderName]['messages'];
				ksort($retValue['header']);
				$retValue['info']['total']	= $total;
				//if ($_startMessage>$total) $_startMessage = $total-($count-1);
				$retValue['info']['first']	= $_startMessage;
				$retValue['info']['last']	= $_startMessage + $count - 1 ;
				return $retValue;
			} else {
				$retValue = array();
				$retValue['info']['total']	= 0;
				$retValue['info']['first']	= 0;
				$retValue['info']['last']	= 0;
				return $retValue;
			}
		} else {
			if ($headersNew == null && empty($_thisUIDOnly)) error_log(__METHOD__." -> retrieval of Message Details to Query $queryString failed: ".print_r($headersNew,TRUE));
			$retValue = array();
			$retValue['info']['total']  = 0;
			$retValue['info']['first']  = 0;
			$retValue['info']['last']   = 0;
			return $retValue;
		}
	}

	function getNextMessage($_foldername, $_id)
	{
		if (empty($this->sessionData['folderStatus'])) $this->restoreSessionData();
		#_debug_array($this->sessionData['folderStatus'][$this->profileID][$_foldername]['sortResult']);
		#_debug_array($this->sessionData['folderStatus'][$this->profileID]);
		#print "ID: $_id
";
		$position=false;
		if (is_array($this->sessionData['folderStatus'][$this->profileID][$_foldername]['sortResult'])) {
			$position = array_search($_id, $this->sessionData['folderStatus'][$this->profileID][$_foldername]['sortResult']);
		}
		#print "POS: $position
";

		if($position !== false) {
			$retValue = array();

			if($this->sessionData['folderStatus'][$this->profileID][$_foldername]['reverse'] == true) {
				#print "is reverse
";
				if(isset($this->sessionData['folderStatus'][$this->profileID][$_foldername]['sortResult'][$position-1])) {
					$retValue['next'] = $this->sessionData['folderStatus'][$this->profileID][$_foldername]['sortResult'][$position-1];
				}
				if(isset($this->sessionData['folderStatus'][$this->profileID][$_foldername]['sortResult'][$position+1])) {
					$retValue['previous'] = $this->sessionData['folderStatus'][$this->profileID][$_foldername]['sortResult'][$position+1];
				}
			} else {
				#print "is not reverse";
				if(isset($this->sessionData['folderStatus'][$this->profileID][$_foldername]['sortResult'][$position-1])) {
					$retValue['previous'] = $this->sessionData['folderStatus'][$this->profileID][$_foldername]['sortResult'][$position-1];
				}
				if(isset($this->sessionData['folderStatus'][$this->profileID][$_foldername]['sortResult'][$position+1])) {
					$retValue['next'] = $this->sessionData['folderStatus'][$this->profileID][$_foldername]['sortResult'][$position+1];
				}
			}

			return $retValue;
		}

		return false;
	}

	function getIMAPACL($_folderName, $user='')
	{
		if(($this->hasCapability('ACL'))) {
			if ( PEAR::isError($acl = $this->icServer->getACL($_folderName)) ) {
				return false;
			}

			if ($user=='') {
				return $acl;
			}

			foreach ($acl as $i => $userACL) {
				if ($userACL['USER'] == $user) {
					return $userACL['RIGHTS'];
				}
			}

			return '';
		}

		return false;
	}

	/**
	* checks if the imap server supports a given capability
	*
	* @param string $_capability the name of the capability to check for
	* @return bool
	*/
	function hasCapability($_capability)
	{
		return $this->icServer->hasCapability(strtoupper($_capability));
	}

	function getMailPreferences()
	{
		return $this->mailPreferences;
	}

	function getMessageAttachments($_uid, $_partID='', $_structure='', $fetchEmbeddedImages=true, $fetchTextCalendar=false, $resolveTNEF=true)
	{
		if (self::$debug) echo __METHOD__."$_uid, $_partID
";

		if(is_object($_structure)) {
			$structure = $_structure;
		} else {
			$structure = $this->_getStructure($_uid, true);

			if($_partID != '' && $_partID !=0) {
				$structure = $this->_getSubStructure($structure, $_partID);
			}
		}
		if (self::$debug) _debug_array($structure);
		$attachments = array();
		// this kind of messages contain only the attachment and no body
		if($structure->type == 'APPLICATION' || $structure->type == 'AUDIO' || $structure->type == 'VIDEO' || $structure->type == 'IMAGE' || ($structure->type == 'TEXT' && $structure->disposition == 'ATTACHMENT') )
		{
			$newAttachment = array();
			$newAttachment['name']		= $this->getFileNameFromStructure($structure,$_uid,$structure->partID);
			$newAttachment['size']		= $structure->bytes;
			$newAttachment['mimeType']	= $structure->type .'/'. $structure->subType;
			$newAttachment['partID']	= $structure->partID;
			$newAttachment['encoding']      = $structure->encoding;
			// try guessing the mimetype, if we get the application/octet-stream
			if (strtolower($newAttachment['mimeType']) == 'application/octet-stream') $newAttachment['mimeType'] = mime_magic::filename2mime($newAttachment['name']);

			if(isset($structure->cid)) {
				$newAttachment['cid']	= $structure->cid;
			}
			# if the new attachment is a winmail.dat, we have to decode that first
			if ( $resolveTNEF && $newAttachment['name'] == 'winmail.dat' &&
				( $wmattachments = $this->decode_winmail( $_uid, $newAttachment['partID'] ) ) )
			{
				$attachments = array_merge( $attachments, $wmattachments );
			}
			elseif ( $resolveTNEF===false && $newAttachment['name'] == 'winmail.dat' )
			{
				$attachments[] = $newAttachment;
			} else {
				$fetchit = $fetchEmbeddedImages;
				if ($fetchEmbeddedImages === false && (!in_array(strtoupper($structure->subtype),array('JPG','JPEG','GIF','PNG')))) $fetchit = true;
				if ( ($fetchit && isset($newAttachment['cid']) && strlen($newAttachment['cid'])>0) ||
					!isset($newAttachment['cid']) ||
					empty($newAttachment['cid'])) $attachments[] = $newAttachment;
			}
			//$attachments[] = $newAttachment;

			#return $attachments;
		}
		// outlook sometimes sends a TEXT/CALENDAR;REQUEST as plain ics, nothing more.
		if ($structure->type == 'TEXT' && $structure->subType == 'CALENDAR' &&
			isset($structure->parameters['METHOD'] ) && strtoupper($structure->parameters['METHOD']) == 'REQUEST')
		{
			$newAttachment = array();
			$newAttachment['name']      = 'event.ics';
			$newAttachment['size']      = $structure->bytes;
			$newAttachment['mimeType']  = $structure->type .'/'. $structure->subType;//.';'.$structure->parameters['METHOD'];
			$newAttachment['partID']    = $structure->partID;
			$newAttachment['encoding']  = $structure->encoding;
			$newAttachment['method']    = $structure->parameters['METHOD'];
			$newAttachment['charset']   = $structure->parameters['CHARSET'];
			$attachments[] = $newAttachment;
		}
		// this kind of message can have no attachments
		if(($structure->type == 'TEXT' && !($structure->disposition == 'INLINE' && $structure->dparameters['FILENAME'])) ||
		   ($structure->type == 'MULTIPART' && $structure->subType == 'ALTERNATIVE' && !is_array($structure->subParts)) ||
		   !is_array($structure->subParts))
		{
			if (count($attachments) == 0) return array();
		}

		#$attachments = array();

		foreach((array)$structure->subParts as $subPart) {
			// skip all non attachment parts
			if(($subPart->type == 'TEXT' && ($subPart->subType == 'PLAIN' || $subPart->subType == 'HTML') && ($subPart->disposition != 'ATTACHMENT' &&
				!($subPart->disposition == 'INLINE' && $subPart->dparameters['FILENAME']))) ||
				($subPart->type == 'MULTIPART' && $subPart->subType == 'ALTERNATIVE') ||
				($subPart->type == 'MULTIPART' && $subPart->subType == 'APPLEFILE') ||
				($subPart->type == 'MESSAGE' && $subPart->subType == 'delivery-status'))
			{
				if ($subPart->type == 'MULTIPART' && $subPart->subType == 'ALTERNATIVE')
				{
					$attachments = array_merge($this->getMessageAttachments($_uid, '', $subPart, $fetchEmbeddedImages, $fetchTextCalendar, $resolveTNEF), $attachments);
				}
				if (!($subPart->type=='TEXT' && $subPart->disposition =='INLINE' && $subPart->filename)) continue;
			}

		   	// fetch the subparts for this part
			if($subPart->type == 'MULTIPART' &&
			   ($subPart->subType == 'RELATED' ||
				$subPart->subType == 'MIXED' ||
				$subPart->subType == 'SIGNED' ||
				$subPart->subType == 'APPLEDOUBLE'))
			{
			   	$attachments = array_merge($this->getMessageAttachments($_uid, '', $subPart, $fetchEmbeddedImages,$fetchTextCalendar, $resolveTNEF), $attachments);
			} else {
				if (!$fetchTextCalendar && $subPart->type == 'TEXT' &&
					$subPart->subType == 'CALENDAR' &&
					$subPart->parameters['METHOD'] &&
					$subPart->disposition !='ATTACHMENT') continue;
				$newAttachment = array();
				$newAttachment['name']		= $this->getFileNameFromStructure($subPart,$_uid,$subPart->partID);
				$newAttachment['size']		= $subPart->bytes;
				$newAttachment['mimeType']	= $subPart->type .'/'. $subPart->subType;
				$newAttachment['partID']	= $subPart->partID;
				$newAttachment['encoding']	= $subPart->encoding;
				$newAttachment['method']    = $subPart->parameters['METHOD'];
				$newAttachment['charset']   = $subPart->parameters['CHARSET'];
				if (isset($subPart->disposition) && !empty($subPart->disposition)) $newAttachment['disposition'] = $subPart->disposition;
				// try guessing the mimetype, if we get the application/octet-stream
				if (strtolower($newAttachment['mimeType']) == 'application/octet-stream') $newAttachment['mimeType'] = mime_magic::filename2mime($newAttachment['name']);

				if(isset($subPart->cid)) {
					$newAttachment['cid']	= $subPart->cid;
				}

				# if the new attachment is a winmail.dat, we have to decode that first
				if ( $resolveTNEF && $newAttachment['name'] == 'winmail.dat' &&
					( $wmattachments = $this->decode_winmail( $_uid, $newAttachment['partID'] ) ) )
				{
					$attachments = array_merge( $attachments, $wmattachments );
				}
				elseif ( $resolveTNEF===false && $newAttachment['name'] == 'winmail.dat' )
				{
					$attachments[] = $newAttachment;
				} else {
					$fetchit = $fetchEmbeddedImages;
					if ($fetchEmbeddedImages === false && (!in_array(strtoupper($structure->subtype),array('JPG','JPEG','GIF','PNG')))) $fetchit = true;
					if ( ($fetchit && isset($newAttachment['cid']) && strlen($newAttachment['cid'])>0) ||
						!isset($newAttachment['cid']) ||
						empty($newAttachment['cid']) || $newAttachment['cid'] == 'NIL')
					{
						$attachments[] = $newAttachment;
					}
					else
					{
						// embedded images should be INLINE, so we check this too, 'cause we want to show/list non embedded images
						if ($fetchEmbeddedImages==false &&
							isset($newAttachment['mimeType']) &&
							!empty($newAttachment['mimeType']) &&
							stripos($newAttachment['mimeType'],'IMAGE') !== false &&
							isset($newAttachment['disposition']) &&
							!empty($newAttachment['disposition']) &&
							trim(strtoupper($newAttachment['disposition']))!='INLINE') $attachments[] = $newAttachment;
					}
				}
				//$attachments[] = $newAttachment;
			}
		}

	   	//_debug_array($attachments); exit;
		return $attachments;

	}

	function getFileNameFromStructure(&$structure, $_uid = false, $partID = false)
	{
		static $namecounter;
		if (is_null($namecounter)) $namecounter = 0;

		//if ( $_uid && $partID) error_log(__METHOD__.__LINE__.array2string($structure).' Uid:'.$_uid.' PartID:'.$partID.' -> '.array2string($this->icServer->getParsedHeaders($_uid, true, $partID, true)));
		if(isset($structure->parameters['NAME'])) {
			if (is_array($structure->parameters['NAME'])) $structure->parameters['NAME'] = implode(' ',$structure->parameters['NAME']);
			return rawurldecode(self::decode_header($structure->parameters['NAME']));
		} elseif(isset($structure->dparameters['FILENAME'])) {
			return rawurldecode(self::decode_header($structure->dparameters['FILENAME']));
		} elseif(isset($structure->dparameters['FILENAME*'])) {
			return rawurldecode(self::decode_header($structure->dparameters['FILENAME*']));
		} elseif ( isset($structure->filename) && !empty($structure->filename) && $structure->filename != 'NIL') {
			return rawurldecode(self::decode_header($structure->filename));
		} else {
			if ( $_uid && $partID)
			{
				$headers = $this->icServer->getParsedHeaders($_uid, true, $partID, true);
				if ($headers)
				{
					if (!PEAR::isError($headers))
					{
						// simple parsing of the headers array for a usable name
						//error_log( __METHOD__.__LINE__.array2string($headers));
						foreach(array('CONTENT-TYPE','CONTENT-DISPOSITION') as $k => $v)
						{
							$headers[$v] = rawurldecode(self::decode_header($headers[$v]));
							foreach(array('filename','name') as $sk => $n)
							{
								if (stripos($headers[$v],$n)!== false)
								{
									$buff = explode($n,$headers[$v]);
									//error_log(__METHOD__.__LINE__.array2string($buff));
									$namepart = array_pop($buff);
									//error_log(__METHOD__.__LINE__.$namepart);
									$fp = strpos($namepart,'"');
									//error_log(__METHOD__.__LINE__.' Start:'.$fp);
									if ($fp !== false)
									{
										$np = strpos($namepart,'"', $fp+1);
										//error_log(__METHOD__.__LINE__.' End:'.$np);
										if ($np !== false)
										{
											$name = trim(substr($namepart,$fp+1,$np-$fp-1));
											if (!empty($name)) return $name;
										}
									}
								}
							}
						}
					}
				}
			}
			$namecounter++;
			return lang("unknown").$namecounter.($structure->subType ? ".".$structure->subType : "");
		}
	}

	function getMessageBody($_uid, $_htmlOptions='', $_partID='', $_structure = '', $_preserveSeen = false, $_folder = '')
	{
		if (self::$debug) echo __METHOD__."$_uid, $_htmlOptions, $_partID
";
		if($_htmlOptions != '') {
			$this->htmlOptions = $_htmlOptions;
		}
		if(is_object($_structure)) {
			$structure = $_structure;
		} else {
			$this->icServer->_cmd_counter = rand($this->icServer->_cmd_counter+1,$this->icServer->_cmd_counter+100);
			$structure = $this->_getStructure($_uid, true, false, $_folder);
			if($_partID != '') {
				$structure = $this->_getSubStructure($structure, $_partID);
			}
		}
		if (self::$debug) _debug_array($structure);

		switch($structure->type) {
			case 'APPLICATION':
				return array(
					array(
						'body'		=> '',
						'mimeType'	=> 'text/plain',
						'charSet'	=> 'iso-8859-1',
					)
				);
				break;
			case 'MULTIPART':
				switch($structure->subType) {
					case 'ALTERNATIVE':
						$bodyParts = array($this->getMultipartAlternative($_uid, $structure->subParts, $this->htmlOptions, $_preserveSeen));

						break;

					case 'MIXED':
					case 'REPORT':
					case 'SIGNED':
						$bodyParts = $this->getMultipartMixed($_uid, $structure->subParts, $this->htmlOptions, $_preserveSeen);
						break;

					case 'RELATED':
						$bodyParts = $this->getMultipartRelated($_uid, $structure->subParts, $this->htmlOptions, $_preserveSeen);
						break;
				}
				return self::normalizeBodyParts($bodyParts);
				break;
			case 'VIDEO':
			case 'AUDIO': // some servers send audiofiles and imagesfiles directly, without any stuff surround it
			case 'IMAGE': // they are displayed as Attachment NOT INLINE
				return array(
					array(
						'body'      => '',
						'mimeType'  => $structure->subType,
					),
				);
				break;
			case 'TEXT':
				$bodyPart = array();
				if ( $structure->disposition != 'ATTACHMENT') {
					switch($structure->subType) {
						case 'CALENDAR':
							// this is handeled in getTextPart
						case 'HTML':
						case 'PLAIN':
						default:
							$bodyPart = array($this->getTextPart($_uid, $structure, $this->htmlOptions, $_preserveSeen));
					}
				} else {
					// what if the structure->disposition is attachment ,...
				}
				return self::normalizeBodyParts($bodyPart);
				break;
			case 'ATTACHMENT':
			case 'MESSAGE':
				switch($structure->subType) {
					case 'RFC822':
						$newStructure = array_shift($structure->subParts);
						if (self::$debug) {echo __METHOD__." Message -> RFC -> NewStructure:"; _debug_array($newStructure);}
						return self::normalizeBodyParts($this->getMessageBody($_uid, $_htmlOptions, $newStructure->partID, $newStructure));
						break;
				}
				break;
			default:
				if (self::$debug) _debug_array($structure);
				return array(
					array(
						'body'		=> lang('The mimeparser can not parse this message.'),
						'mimeType'	=> 'text/plain',
						'charSet'	=> 'iso-8859-1',
					)
				);
				break;
		}
	}

	/**
	 * normalizeBodyParts - function to gather and normalize all body Information
	 * @param _bodyParts - Body Array
	 * @return array - a normalized Bodyarray
	 */
	static function normalizeBodyParts($_bodyParts)
	{
		if (is_array($_bodyParts))
		{
			foreach($_bodyParts as $singleBodyPart)
			{
				if (!isset($singleBodyPart['body'])) {
					$buff = self::normalizeBodyParts($singleBodyPart);
					foreach ((array)$buff as $val)	$body2return[] = $val;
					continue;
				}
				$body2return[] = $singleBodyPart;
			}
		}
		else
		{
			$body2return = $_bodyParts;
		}
		return $body2return;
	}

	function getMessageHeader($_uid, $_partID = '',$decode=false)
	{
		$retValue = $this->icServer->getParsedHeaders($_uid, true, $_partID, true);
		if (PEAR::isError($retValue))
		{
			error_log(__METHOD__.__LINE__.array2string($retValue->message));
			$retValue = null;
		}
		return ($decode ? self::decode_header($retValue):$retValue);
	}

	function getMessageRawBody($_uid, $_partID = '')
	{
		//TODO: caching einbauen static!
		static $rawBody;
		$_folder = ($this->sessionData['mailbox']? $this->sessionData['mailbox'] : $this->icServer->getCurrentMailbox());
		if (isset($rawBody[$_folder][$_uid][($_partID==''?'NIL':$_partID)]))
		{
			error_log(__METHOD__.__LINE__." Using Cache for raw Body $_uid, $_partID in Folder $_folder");
			return $rawBody[$this->icServer->ImapServerId][$_folder][$_uid][($_partID==''?'NIL':$_partID)];
		}
		if($_partID != '') {
			$body = $this->icServer->getBody($_uid, true);
		} else {
			$body = $this->icServer->getBodyPart($_uid, $_partID, true);
		}
		if (PEAR::isError($body))
		{
			error_log(__METHOD__.__LINE__.' failed:'.$body->message);
			return false;
		}
		$rawBody[$this->icServer->ImapServerId][$_folder][$_uid][($_partID==''?'NIL':$_partID)] = $body;
		return $body;
	}

	function getMessageRawHeader($_uid, $_partID = '')
	{
		static $rawHeaders;
		$_folder = ($this->sessionData['mailbox']? $this->sessionData['mailbox'] : $this->icServer->getCurrentMailbox());
		//error_log(__METHOD__.__LINE__." Try Using Cache for raw Header $_uid, $_partID in Folder $_folder");

		if (is_null($rawHeaders)) $rawHeaders = egw_cache::getCache(egw_cache::INSTANCE,'email','rawHeadersCache'.trim($GLOBALS['egw_info']['user']['account_id']),$callback=null,$callback_params=array(),$expiration=60*60*1);
		if (isset($rawHeaders[$this->icServer->ImapServerId][$_folder][$_uid][($_partID==''?'NIL':$_partID)]))
		{
			//error_log(__METHOD__.__LINE__." Using Cache for raw Header $_uid, $_partID in Folder $_folder");
			return $rawHeaders[$this->icServer->ImapServerId][$_folder][$_uid][($_partID==''?'NIL':$_partID)];
		}

		$retValue = $this->icServer->getRawHeaders($_uid, $_partID, true);
		if (PEAR::isError($retValue))
		{
			error_log(__METHOD__.__LINE__.array2string($retValue->message));
			$retValue = "Could not retrieve RawHeaders in ".__METHOD__.__LINE__." PEAR::Error:".array2string($retValue->message);
		}
		$rawHeaders[$this->icServer->ImapServerId][$_folder][$_uid][($_partID==''?'NIL':$_partID)]=$retValue;
		egw_cache::setCache(egw_cache::INSTANCE,'email','rawHeadersCache'.trim($GLOBALS['egw_info']['user']['account_id']),$rawHeaders,$expiration=60*60*1);
		return $retValue;
	}

	// return the qouta of the users INBOX
	function getQuotaRoot()
	{
		static $quota;
		if (isset($quota)) return $quota;
		if(!$this->icServer->hasCapability('QUOTA')) {
			$quota = false;
			return false;
		}
		$quota = $this->icServer->getStorageQuotaRoot('INBOX');
		//error_log(__METHOD__.__LINE__.array2string($quota));
		if(is_array($quota)) {
			$quota = array(
				'usage'	=> $quota['USED'],
				'limit'	=> $quota['QMAX'],
			);
		} else {
			$quota = false;
		}
		return $quota;
	}

	function getDraftFolder($_checkexistance=TRUE)
	{
		if(empty($this->mailPreferences->preferences['draftFolder'])) {
			return false;
		}
		$_folderName = $this->mailPreferences->preferences['draftFolder'];
		// does the folder exist???
		if ($_checkexistance && !self::folderExists($_folderName)) {
			return false;
		}
		return $_folderName;
	}

	function getTemplateFolder($_checkexistance=TRUE)
	{
		if(empty($this->mailPreferences->preferences['templateFolder'])) {
			return false;
		}
		$_folderName = $this->mailPreferences->preferences['templateFolder'];
		// does the folder exist???
		if ($_checkexistance && !self::folderExists($_folderName)) {
			return false;
		}
		return $_folderName;
	}

	function getTrashFolder($_checkexistance=TRUE)
	{
		if(empty($this->mailPreferences->preferences['trashFolder'])) {
			return false;
		}
		$_folderName = $this->mailPreferences->preferences['trashFolder'];
		// does the folder exist???
		if ($_checkexistance && !self::folderExists($_folderName)) {
			return false;
		}
		return $_folderName;
	}

	function getSentFolder($_checkexistance=TRUE)
	{
		if(empty($this->mailPreferences->preferences['sentFolder'])) {
			return false;
		}
		$_folderName = $this->mailPreferences->preferences['sentFolder'];
		// does the folder exist???
		if ($_checkexistance && !self::folderExists($_folderName)) {
			return false;
		}
		return $_folderName;
	}

	function isSentFolder($_folderName, $_checkexistance=TRUE)
	{
		if(empty($this->mailPreferences->preferences['sentFolder'])) {
			return false;
		}
		// does the folder exist???
		if ($_checkexistance && !self::folderExists($_folderName)) {
			return false;
		}

		if(false !== stripos($_folderName, $this->mailPreferences->preferences['sentFolder'])) {
			return true;
		} else {
			return false;
		}
	}

	/**
	 * checks if the Outbox folder exists and is port of the foldername to be checked
	 */
	function isOutbox($_folderName, $_checkexistance=TRUE)
	{
		if (stripos($_folderName, 'Outbox')===false) {
			return false;
		}
		// does the folder exist???
		if ($_checkexistance && !self::folderExists($_folderName)) {
			return false;
		}
		return true;
	}

	function isDraftFolder($_folderName, $_checkexistance=TRUE)
	{
		if(empty($this->mailPreferences->preferences['draftFolder'])) {
			return false;
		}
		// does the folder exist???
		if ($_checkexistance && !self::folderExists($_folderName)) {
			return false;
		}

		if(false !== stripos($_folderName, $this->mailPreferences->preferences['draftFolder'])) {
			return true;
		} else {
			return false;
		}
	}

	function isTrashFolder($_folderName, $_checkexistance=TRUE)
	{
		if(empty($this->mailPreferences->preferences['trashFolder'])) {
			return false;
		}
		// does the folder exist???
		if ($_checkexistance && !self::folderExists($_folderName)) {
			return false;
		}

		if(false !== stripos($_folderName, $this->mailPreferences->preferences['trashFolder'])) {
			return true;
		} else {
			return false;
		}
	}

	function isTemplateFolder($_folderName, $_checkexistance=TRUE)
	{
		if(empty($this->mailPreferences->preferences['templateFolder'])) {
			return false;
		}
		// does the folder exist???
		if ($_checkexistance && !self::folderExists($_folderName)) {
			return false;
		}

		if(false !== stripos($_folderName, $this->mailPreferences->preferences['templateFolder'])) {
			return true;
		} else {
			return false;
		}
	}

	function folderExists($_folder, $_forceCheck=false)
	{
		static $folderInfo;
		$forceCheck = $_forceCheck;
		if (empty($_folder))
		{
			error_log(__METHOD__.__LINE__.' Called with empty Folder:'.$_folder.function_backtrace());
			return false;
		}
		// reduce traffic within the Instance per User; Expire every 5 Minutes
		//error_log(__METHOD__.__LINE__.' Called with Folder:'.$_folder.function_backtrace());
		if (is_null($folderInfo)) $folderInfo = egw_cache::getCache(egw_cache::INSTANCE,'email','icServerFolderExistsInfo'.trim($GLOBALS['egw_info']['user']['account_id']),null,array(),$expiration=60*5);
		//error_log(__METHOD__.__LINE__.'Cached Info on Folder:'.$_folder.' for Profile:'.$this->profileID.($forceCheck?'(forcedCheck)':'').':'.array2string($folderInfo));
		if (!empty($folderInfo) && isset($folderInfo[$this->profileID]) && isset($folderInfo[$this->profileID][$_folder]) && $forceCheck===false)
		{
			//error_log(__METHOD__.__LINE__.' Using cached Info on Folder:'.$_folder.' for Profile:'.$this->profileID);
			return $folderInfo[$this->profileID][$_folder];
		}
		else
		{
			if ($forceCheck === false)
			{
				//error_log(__METHOD__.__LINE__.' No cached Info on Folder:'.$_folder.' for Profile:'.$this->profileID.' FolderExistsInfoCache:'.array2string($folderInfo[$this->profileID]));
				$forceCheck = true; // try to force the check, in case there is no connection, we may need that
			}
		}

		// does the folder exist???
		//error_log(__METHOD__."->Connected?".$this->icServer->_connected.", ".$_folder.", ".($forceCheck?' forceCheck activated':'dont check on server'));
		if ((!($this->icServer->_connected == 1)) && $forceCheck || empty($folderInfo) || !isset($folderInfo[$this->profileID]) || !isset($folderInfo[$this->profileID][$_folder])) {
			//error_log(__METHOD__."->NotConnected and forceCheck with profile:".$this->profileID);
			//return false;
			//try to connect
			if (!$this->icServer->_connected) $this->openConnection($this->profileID,false);
		}
		if(($this->icServer instanceof defaultimap))
		{
			$folderInfo[$this->profileID][$_folder] = $this->icServer->mailboxExist($_folder); //LIST Command, may return OK, but no attributes
			if ($folderInfo[$this->profileID][$_folder]==false)
			{
				// some servers dont serve the LIST command in certain cases; this is a ServerBUG and
				// we try to work around it here.
				if ((isset($this->mailPreferences->preferences['trustServersUnseenInfo']) &&
					$this->mailPreferences->preferences['trustServersUnseenInfo']==false) ||
					(isset($this->mailPreferences->preferences['trustServersUnseenInfo']) &&
					$this->mailPreferences->preferences['trustServersUnseenInfo']==2)
				)
				{
					$nameSpace = $this->_getNameSpaces();
					if (isset($nameSpace['personal'])) unset($nameSpace['personal']);
					$prefix = $this->getFolderPrefixFromNamespace($nameSpace, $_folder);
					if ($prefix != '' && stripos($_folder,$prefix) !== false)
					{
						if(!PEAR::isError($r = $this->_getStatus($_folder)) && is_array($r)) $folderInfo[$this->profileID][$_folder] = true;
					}
				}
			}
		}
		//error_log(__METHOD__.__LINE__.' Folder Exists:'.$folderInfo[$this->profileID][$_folder].function_backtrace());

		if(!empty($folderInfo) && isset($folderInfo[$this->profileID][$_folder]) &&
			($folderInfo[$this->profileID][$_folder] instanceof PEAR_Error) || $folderInfo[$this->profileID][$_folder] !== true)
		{
			$folderInfo[$this->profileID][$_folder] = false; // set to false, whatever it was (to have a valid returnvalue for the static return)
		}
		egw_cache::setCache(egw_cache::INSTANCE,'email','icServerFolderExistsInfo'.trim($GLOBALS['egw_info']['user']['account_id']),$folderInfo,$expiration=60*5);
		return (!empty($folderInfo) && isset($folderInfo[$this->profileID][$_folder]) ? $folderInfo[$this->profileID][$_folder] : false);
	}

	/**
	 * getFolderType - checks and returns the foldertype for a given nfolder
	 * @param string $mailbox
	 * @return int the folder Type 0 for Standard, 1 for Sent, 2 for draft, 3 for template
	 */
	function getFolderType($mailbox)
	{
		$sentFolderFlag =$this->isSentFolder($mailbox);
		$folderType = 0;
		if($sentFolderFlag ||
			false !== in_array($mailbox,explode(',',$GLOBALS['egw_info']['user']['preferences']['felamimail']['messages_showassent_0'])))
		{
			$folderType = 1;
			$sentFolderFlag=1;
		} elseif($this->isDraftFolder($mailbox)) {
			$folderType = 2;
		} elseif($this->isTemplateFolder($mailbox)) {
			$folderType = 3;
		}
		return $folderType;
	}

	function moveMessages($_foldername, $_messageUID, $deleteAfterMove=true, $currentFolder = Null, $returnUIDs = false)
	{
		$msglist = '';

		$deleteOptions  = $GLOBALS['egw_info']["user"]["preferences"]["felamimail"]["deleteOptions"];
		$retUid = $this->icServer->copyMessages($_foldername, $_messageUID, (!empty($currentFolder)?$currentFolder: $this->sessionData['mailbox']), true, $returnUIDs);
		if ( PEAR::isError($retUid) ) {
			error_log(__METHOD__.__LINE__."Copying to Folder $_foldername failed! PEAR::Error:".array2string($retUid->message));
			throw new egw_exception("Copying to Folder $_foldername failed! PEAR::Error:".array2string($retUid->message));
			return false;
		}
		if ($deleteAfterMove === true)
		{
			$retValue = $this->icServer->deleteMessages($_messageUID, true);
			if ( PEAR::isError($retValue))
			{
				error_log(__METHOD__.__LINE__."Delete After Move PEAR::Error:".array2string($retValue->message));
				throw new egw_exception("Delete After Move PEAR::Error:".array2string($retValue->message));
				return false;
			}

			if($deleteOptions != "mark_as_deleted")
			{
				$structure = egw_cache::getCache(egw_cache::INSTANCE,'email','structureCache'.trim($GLOBALS['egw_info']['user']['account_id']),$callback=null,$callback_params=array(),$expiration=60*60*1);
				$cachemodified = false;
				foreach ((array)$_messageUID as $k => $_uid)
				{
					if (isset($structure[$this->icServer->ImapServerId][(!empty($currentFolder)?$currentFolder: $this->sessionData['mailbox'])][$_uid]))
					{
						$cachemodified = true;
						unset($structure[$this->icServer->ImapServerId][(!empty($currentFolder)?$currentFolder: $this->sessionData['mailbox'])][$_uid]);
					}
				}
				if ($cachemodified) egw_cache::setCache(egw_cache::INSTANCE,'email','structureCache'.trim($GLOBALS['egw_info']['user']['account_id']),$structure,$expiration=60*60*1);

				// delete the messages finaly
				$this->icServer->expunge();
			}
		}
		//error_log(__METHOD__.__LINE__.array2string($retUid));
		return ($returnUIDs ? $retUid : true);
	}

	function openConnection($_icServerID=0, $_adminConnection=false)
	{
		static $isError;
		//error_log(__METHOD__.__LINE__.'->'.$_icServerID.' called from '.function_backtrace());
		if (is_null($isError)) $isError = egw_cache::getCache(egw_cache::INSTANCE,'email','icServerIMAP_connectionError'.trim($GLOBALS['egw_info']['user']['account_id']),null,array(),$expiration=60*5);
		if ( isset($isError[$_icServerID]) || (($this->icServer instanceof defaultimap) && PEAR::isError($this->icServer->_connectionErrorObject)))
		{
			if (trim($isError[$_icServerID])==',' || trim($this->icServer->_connectionErrorObject->message) == ',')
			{
				//error_log(__METHOD__.__LINE__.' Connection seemed to have failed in the past, no real reason given, try to recover on our own.');
				emailadmin_bo::unsetCachedObjects($_icServerID);
			}
			else
			{
				//error_log(__METHOD__.__LINE__.' failed for Reason:'.$isError[$_icServerID]);
				$this->errorMessage = ($isError[$_icServerID]?$isError[$_icServerID]:$this->icServer->_connectionErrorObject->message);
				return false;
			}
		}
		if (!is_object($this->mailPreferences))
		{
			if (self::$debug) error_log(__METHOD__." No Object for MailPreferences found.". function_backtrace());
			$this->errorMessage .= lang('No valid data to create MailProfile!!');
			$isError[$_icServerID] = (($this->icServer instanceof defaultimap)?new PEAR_Error($this->errorMessage):$this->errorMessage);
			egw_cache::setCache(egw_cache::INSTANCE,'email','icServerIMAP_connectionError'.trim($GLOBALS['egw_info']['user']['account_id']),$isError,$expiration=60*15);
			return false;
		}
		if(!$this->icServer = $this->mailPreferences->getIncomingServer((int)$_icServerID)) {
			$this->errorMessage .= lang('No active IMAP server found!!');
			$isError[$_icServerID] = $this->errorMessage;
			egw_cache::setCache(egw_cache::INSTANCE,'email','icServerIMAP_connectionError'.trim($GLOBALS['egw_info']['user']['account_id']),$isError,$expiration=60*15);
			return false;
		}
		//error_log(__METHOD__.__LINE__.'->'.array2string($this->icServer->ImapServerId));
		if ($this->icServer && empty($this->icServer->host)) {
			$errormessage = lang('No IMAP server host configured!!');
			if ($GLOBALS['egw_info']['user']['apps']['emailadmin']) {
				$errormessage .= "
".lang("Configure a valid IMAP Server in emailadmin for the profile you are using.");
			} else {
				$errormessage .= "
".lang('Please ask the administrator to correct the emailadmin IMAP Server Settings for you.');
			}
			$this->icServer->_connectionErrorObject->message .= $this->errorMessage .= $errormessage;
			$isError[$_icServerID] = $this->errorMessage;
			egw_cache::setCache(egw_cache::INSTANCE,'email','icServerIMAP_connectionError'.trim($GLOBALS['egw_info']['user']['account_id']),$isError,$expiration=60*15);
			return false;
		}
		//error_log( "-------------------------->open connection ".function_backtrace());
		//error_log(__METHOD__.__LINE__.' ->'.array2string($this->icServer));
		if ($this->icServer->_connected == 1) {
			$tretval = $this->icServer->selectMailbox($this->icServer->currentMailbox);
			if ( PEAR::isError($tretval) ) $isError[$_icServerID] = $tretval->message;
			//error_log(__METHOD__." using existing Connection ProfileID:".$_icServerID.' Status:'.print_r($this->icServer->_connected,true));
		} else {
			//error_log( "-------------------------->open connection for Server with profileID:".$_icServerID.function_backtrace());
			$timeout = felamimail_bo::getTimeOut();
			$tretval = $this->icServer->openConnection($_adminConnection,$timeout);
			if ( PEAR::isError($tretval) || $tretval===false)
			{
				$isError[$_icServerID] = ($tretval?$tretval->message:$this->icServer->_connectionErrorObject->message);
				if (self::$debug)
				{
					error_log(__METHOD__.__LINE__." # failed to open new Connection ProfileID:".$_icServerID.' Status:'.print_r($this->icServer->_connected,true).' Message:'.$isError[$_icServerID].' called from '.function_backtrace());
					error_log(__METHOD__.__LINE__.' # Instance='.$GLOBALS['egw_info']['user']['domain'].', User='.$GLOBALS['egw_info']['user']['account_lid']);
				}
			}
		}
		if ( PEAR::isError($tretval) ) egw_cache::setCache(egw_cache::INSTANCE,'email','icServerIMAP_connectionError'.trim($GLOBALS['egw_info']['user']['account_id']),$isError,$expiration=60*15);
		//error_log(print_r($this->icServer->_connected,true));
		$hD = $this->getHierarchyDelimiter();
		$sUF = $this->getSpecialUseFolders();
		//error_log(__METHOD__.__LINE__.array2string($sUF));

		return $tretval;
	}

	/**
	 * getTimeOut
	 *
	 * @param string _use decide if the use is for IMAP or SIEVE, by now only the default differs
	 *
	 * @return int - timeout (either set or default 20/10)
	 */
	static function getTimeOut($_use='IMAP')
	{
		$timeout = $GLOBALS['egw_info']['user']['preferences']['felamimail']['connectionTimeout'];
		if (empty($timeout)) $timeout = ($_use=='SIEVE'?10:20); // this is the default value
		return $timeout;
	}

	/**
	 * rename a folder
	 *
	 * @param string _oldFolderName the old foldername
	 * @param string _parent the parent foldername
	 * @param string _folderName the new foldername
	 *
	 * @return mixed name of the newly created folder or false on error
	 */
	function renameFolder($_oldFolderName, $_parent, $_folderName)
	{
		$oldFolderName	= $this->_encodeFolderName($_oldFolderName);
		$parent		= $this->_encodeFolderName($_parent);
		$folderName	= $this->_encodeFolderName($_folderName);

		if(empty($parent)) {
			$newFolderName = $folderName;
		} else {
			$HierarchyDelimiter = $this->getHierarchyDelimiter();
			$newFolderName = $parent . $HierarchyDelimiter . $folderName;
		}
		if (self::$debug) error_log("create folder: $newFolderName");
		$rv = $this->icServer->renameMailbox($oldFolderName, $newFolderName);
		if ( PEAR::isError($rv) ) {
			if (self::$debug) error_log(__METHOD__." failed for $oldFolderName, $newFolderName with error: ".print_r($rv->message,true));
			return false;
		}

		return $newFolderName;

	}

	function reopen($_foldername)
	{
		// TODO: trying to reduce traffic to the IMAP Server here, introduces problems with fetching the bodies of
		// eMails when not in "current-Folder" (folder that is selected by UI)
		static $folderOpened;
		//if (empty($folderOpened) || $folderOpened!=$_foldername)
		//{
			//error_log( "------------------------reopen- $_foldername 
");
			//error_log(__METHOD__.__LINE__.' Connected with icServer for Profile:'.$this->profileID.'?'.print_r($this->icServer->_connected,true));
			if ($this->icServer->_connected == 1) {
				$tretval = $this->icServer->selectMailbox($_foldername);
			} else {
				$tretval = $this->openConnection($this->profileID,false);
				$tretval = $this->icServer->selectMailbox($_foldername);
			}
			$folderOpened = $_foldername;
		//}
	}

	function restoreSessionData()
	{
		$GLOBALS['egw_info']['flags']['autoload'] = array(__CLASS__,'autoload');

		$this->sessionData = $GLOBALS['egw']->session->appsession('session_data','felamimail');
		$this->sessionData['folderStatus'] = egw_cache::getCache(egw_cache::INSTANCE,'email','folderStatus'.trim($GLOBALS['egw_info']['user']['account_id']),$callback=null,$callback_params=array(),$expiration=60*60*1);
	}

	function saveSessionData()
	{
		if (isset($this->sessionData['folderStatus']) && is_array($this->sessionData['folderStatus']))
		{
			egw_cache::setCache(egw_cache::INSTANCE,'email','folderStatus'.trim($GLOBALS['egw_info']['user']['account_id']),$this->sessionData['folderStatus'], $expiration=60*60*1);
			unset($this->sessionData['folderStatus']);
		}
		$GLOBALS['egw']->session->appsession('session_data','felamimail',$this->sessionData);
	}

	function saveFilter($_formData)
	{
		if(!empty($_formData['from']))
			$data['from']	= $_formData['from'];
		if(!empty($_formData['to']))
			$data['to']	= $_formData['to'];
		if(!empty($_formData['subject']))
			$data['subject']= $_formData['subject'];
		if($_formData['filterActive'] == "true")
		{
			$data['filterActive']= "true";
		}

		$this->sessionData['filter'] = $data;
		$this->saveSessionData();
	}

	function setEMailProfile($_profileID)
	{
		$config = CreateObject('phpgwapi.config','felamimail');
		$config->read_repository();
		$config->value('profileID',$_profileID);
		$config->save_repository();
	}

	function subscribe($_folderName, $_status)
	{
		if (self::$debug) error_log("felamimail_bo::".($_status?"":"un")."subscribe:".$_folderName);
		if($_status === true) {
			$rv = $this->icServer->subscribeMailbox($_folderName);
			if ( PEAR::isError($rv)) {
				error_log("felamimail_bo::".($_status?"":"un")."subscribe:".$_folderName." failed:".$rv->message);
				return false;
			}
		} else {
			$rv = $this->icServer->unsubscribeMailbox($_folderName);
			if ( PEAR::isError($rv)) {
				error_log("felamimail_bo::".($_status?"":"un")."subscribe:".$_folderName." failed:".$rv->message);
				return false;
			}
		}

		return true;
	}

	function toggleFilter()
	{
		if($this->sessionData['filter']['filterActive'] == 'true') {
			$this->sessionData['filter']['filterActive'] = 'false';
		} else {
			$this->sessionData['filter']['filterActive'] = 'true';
		}
		$this->saveSessionData();
	}

	function updateAccount($_hookValues)
	{
		if (is_object($this->mailPreferences)) $icServer = $this->mailPreferences->getIncomingServer(0);
		if(($icServer instanceof defaultimap)) {
			$icServer->updateAccount($_hookValues);
		}

		if (is_object($this->mailPreferences)) $ogServer = $this->mailPreferences->getOutgoingServer(0);
		if(($ogServer instanceof defaultsmtp)) {
			$ogServer->updateAccount($_hookValues);
		}
	}

	function updateSingleACL($_folderName, $_accountName, $_aclType, $_aclStatus,$_recursive=false)
	{
		//error_log(__METHOD__.__LINE__." $_folderName, $_accountName, $_aclType, $_aclStatus,$_recursive");
		$userACL = $this->getIMAPACL($_folderName, $_accountName);

		if($_aclStatus == 'true' || $_aclStatus == 1) {
			if(strpos($userACL, $_aclType) === false) {
				$userACL .= $_aclType;
				$this->setACL($_folderName, $_accountName, $userACL, $_recursive);
			}
		} elseif($_aclStatus == 'false' || empty($_aclStatus)) {
			if(strpos($userACL, $_aclType) !== false) {
				$userACL = str_replace($_aclType,'',$userACL);
				$this->setACL($_folderName, $_accountName, $userACL, $_recursive);
			}
		}

		return $userACL;
	}

	static function wordwrap($str, $cols, $cut, $dontbreaklinesstartingwith=false)
	{
		$lines = explode("\n", $str);
		$newStr = '';
		foreach($lines as $line)
		{
			// replace tabs by 8 space chars, or any tab only counts one char
			//$line = str_replace("\t","        ",$line);
			//$newStr .= wordwrap($line, $cols, $cut);
			$allowedLength = $cols-strlen($cut);
			if (strlen($line) > $allowedLength &&
				($dontbreaklinesstartingwith==false ||
				 ($dontbreaklinesstartingwith &&
				  strlen($dontbreaklinesstartingwith)>=1 &&
				  substr($line,0,strlen($dontbreaklinesstartingwith)) != $dontbreaklinesstartingwith
				 )
				)
			   )
			{
				$s=explode(" ", $line);
				$line = "";
				$linecnt = 0;
				foreach ($s as $k=>$v) {
					$cnt = strlen($v);
					// only break long words within the wordboundaries,
					// but it may destroy links, so we check for href and dont do it if we find one
					// we check for any html within the word, because we do not want to break html by accident
					if($cnt > $allowedLength && stripos($v,'href=')===false && stripos($v,'onclick=')===false && $cnt == strlen(html_entity_decode($v)))
					{
						$v=wordwrap($v, $allowedLength, $cut, true);
					}
					// the rest should be broken at the start of the new word that exceeds the limit
					if ($linecnt+$cnt > $allowedLength) {
						$v=$cut.$v;
						#$linecnt = 0;
						$linecnt =strlen($v)-strlen($cut);
					} else {
						$linecnt += $cnt;
					}
					if (strlen($v)) $line .= (strlen($line) ? " " : "").$v;
				}
			}
			$newStr .= $line . "\n";
		}
		return $newStr;
	}

	/**
	* convert the foldername from display charset to UTF-7
	*
	* @param string _parent the parent foldername
	* @return ISO-8859-1 / UTF7-IMAP encoded string
	*/
	function _encodeFolderName($_folderName) {
		return translation::convert($_folderName, self::$displayCharset, 'ISO-8859-1');
		#return translation::convert($_folderName, self::$displayCharset, 'UTF7-IMAP');
	}

	/**
	* convert the foldername from UTF-7 to display charset
	*
	* @param string _parent the parent foldername
	* @return ISO-8859-1 / self::$displayCharset encoded string
	*/
	function _decodeFolderName($_folderName) {
		return translation::convert($_folderName, self::$displayCharset, 'ISO-8859-1');
		#return translation::convert($_folderName, 'UTF7-IMAP', self::$displayCharset);
	}

	/**
	* convert the sort value from the gui(integer) into a string
	*
	* @param mixed _sort the integer sort order / or a valid and handeled SORTSTRING (right now: UID/ARRIVAL/INTERNALDATE (->ARRIVAL))
	* @param bool _reverse wether to add REVERSE to the Sort String or not
	* @return the ascii sort string
	*/
	function _getSortString($_sort, $_reverse=false)
	{
		$_reverse=false;
		if (is_numeric($_sort))
		{
			switch($_sort) {
				case 2:
					$retValue = 'FROM';
					break;
				case 4:
					$retValue = 'TO';
					break;
				case 3:
					$retValue = 'SUBJECT';
					break;
				case 6:
					$retValue = 'SIZE';
					break;
				case 0:
				default:
					$retValue = 'DATE';
					//$retValue = 'ARRIVAL';
					break;
			}
		}
		else
		{
			switch($_sort) {
				case 'UID': // should be equivalent to INTERNALDATE, which is ARRIVAL, which should be highest (latest) uid should be newest date
				case 'ARRIVAL':
				case 'INTERNALDATE':
					$retValue = 'ARRIVAL';
					break;
				default:
					$retValue = 'DATE';
					break;
			}
		}
		//error_log(__METHOD__.__LINE__.' '.($_reverse?'REVERSE ':'').$_sort.'->'.$retValue);
		return ($_reverse?'REVERSE ':'').$retValue;
	}

	function sendMDN($uid)
	{
		$identities = $this->mailPreferences->getIdentity();
		$headers = $this->getMessageHeader($uid);
		$send = CreateObject('phpgwapi.send');
		$send->ClearAddresses();
		$send->ClearAttachments();
		$send->IsHTML(False);
		$send->IsSMTP();

		$array_to = explode(",",$headers['TO']);
		foreach($identities as  $identity) {
			if ( preg_match('/\b'.$identity->emailAddress.'\b/',$headers['TO']) ) {
				$send->From = $identity->emailAddress;
				$send->FromName = $identity->realName;
				error_log(__METHOD__.__LINE__.' using identity for send from:'.$send->From.' to match header information:'.$headers['TO'].' ProfileID:'.$this->profileID.' Folder:'.$this->sessionData['mailbox']);
				break;
			}
			if($identity->default) {
				$send->From = $identity->emailAddress;
				$send->FromName = $identity->realName;
			}
		}

		if (isset($headers['DISPOSITION-NOTIFICATION-TO'])) {
			$toAddr = $headers['DISPOSITION-NOTIFICATION-TO'];
		} else if ( isset($headers['RETURN-RECEIPT-TO']) ) {
			$toAddr = $headers['RETURN-RECEIPT-TO'];
		} else if ( isset($headers['X-CONFIRM-READING-TO']) ) {
			$toAddr = $headers['X-CONFIRM-READING-TO'];
		} else return false;
		$singleAddress = imap_rfc822_parse_adrlist($toAddr,'');
		if (self::$debug) error_log(__METHOD__.__LINE__.' To Address:'.$singleAddress[0]->mailbox."@".$singleAddress[0]->host.", ".$singleAddress[0]->personal);
		$send->AddAddress($singleAddress[0]->mailbox."@".$singleAddress[0]->host, $singleAddress[0]->personal);
		$send->AddCustomHeader('References: '.$headers['MESSAGE-ID']);
		$send->Subject = $send->encode_subject( lang('Read')." : ".$headers['SUBJECT'] );

		$sep = "-----------mdn".$uniq_id = md5(uniqid(time()));

		$body = "--".$sep."\r\n".
			"Content-Type: text/plain; charset=ISO-8859-1\r\n".
			"Content-Transfer-Encoding: 7bit\r\n\r\n".
			$send->EncodeString(lang("Your message to %1 was displayed." ,$send->From),"7bit").
			"\r\n";

		$body .= "--".$sep."\r\n".
			"Content-Type: message/disposition-notification; name=\"MDNPart2.txt\"\r\n" .
			"Content-Disposition: inline\r\n".
			"Content-Transfer-Encoding: 7bit\r\n\r\n";
		$body.= $send->EncodeString("Reporting-UA: eGroupWare\r\n" .
					   "Final-Recipient: rfc822;".$send->From."\r\n" .
					   "Original-Message-ID: ".$headers['MESSAGE-ID']."\r\n".
					   "Disposition: manual-action/MDN-sent-manually; displayed",'7bit')."\r\n";

		$body .= "--".$sep."\r\n".
			"Content-Type: text/rfc822-headers; name=\"MDNPart3.txt\"\r\n" .
			"Content-Transfer-Encoding: 7bit\r\n" .
			"Content-Disposition: inline\r\n\r\n";
		$body .= $send->EncodeString($this->getMessageRawHeader($uid),'7bit')."\r\n";
		$body .= "--".$sep."--";


		$header = rtrim($send->CreateHeader())."\r\n"."Content-Type: multipart/report; report-type=disposition-notification;\r\n".
			"\tboundary=\"".$sep."\"\r\n\r\n";
		//error_log(__METHOD__.array2string($send));
		$rv = $send->SmtpSend($header,$body);
		//error_log(__METHOD__.'#'.array2string($rv).'#');
		return $rv;
	}

	/**
	 * Merges a given content with contact data
	 *
	 * @param string $content
	 * @param array $ids array with contact id(s)
	 * @param string &$err error-message on error
	 * @return string/boolean merged content or false on error
	 */
	function merge($content,$ids,$mimetype='')
	{
		$contacts = new addressbook_bo();
		$mergeobj = new addressbook_merge();

		if (empty($mimetype)) $mimetype = (strlen(strip_tags($content)) == strlen($content) ?'text/plain':'text/html');
		$rv = $mergeobj->merge_string($content,$ids,$err,$mimetype, array(), self::$displayCharset);
		if (empty($rv) && !empty($content) && !empty($err)) $rv = $content;
		if (!empty($err) && !empty($content) && !empty($ids)) error_log(__METHOD__.__LINE__.' Merge failed for Ids:'.array2string($ids).' ContentType:'.$mimetype.' Content:'.$content.' Reason:'.array2string($err));
		return $rv;
	}

	/**
	 * Tests if string contains 8bit symbols.
	 *
	 * If charset is not set, function defaults to default_charset.
	 * $default_charset global must be set correctly if $charset is
	 * not used.
	 * @param string $string tested string
	 * @param string $charset charset used in a string
	 * @return bool true if 8bit symbols are detected
	 */
	static function is8bit(&$string,$charset='') {

	    if ($charset=='') $charset= self::$displayCharset;

		/**
		* Don't use \240 in ranges. Sometimes RH 7.2 doesn't like it.
		* Don't use \200-\237 for iso-8859-x charsets. This ranges
		* stores control symbols in those charsets.
		* Use preg_match instead of ereg in order to avoid problems
		* with mbstring overloading
		*/
		if (preg_match("/^iso-8859/i",$charset)) {
			$needle='/\240|[\241-\377]/';
		} else {
			$needle='/[\200-\237]|\240|[\241-\377]/';
		}
		return preg_match("$needle",$string);
	}

	/**
	 * htmlspecialchars
	 * helperfunction to cope with wrong encoding in strings
	 * @param string $_string  input to be converted
	 * @param mixed $charset false or string -> Target charset, if false bofelamimail displayCharset will be used
	 * @return string
	 */
	static function htmlspecialchars($_string, $_charset=false)
	{
		//setting the charset (if not given)
		if ($_charset===false) $_charset = self::$displayCharset;
		$_stringORG = $_string;
		$_string = @htmlspecialchars($_string,ENT_QUOTES,$_charset, false);
		if (empty($_string) && !empty($_stringORG)) $_string = @htmlspecialchars(translation::convert($_stringORG,self::detect_encoding($_stringORG),$_charset),ENT_QUOTES | ENT_IGNORE,$_charset, false);
		return $_string;
	}

	/**
	 * htmlentities
	 * helperfunction to cope with wrong encoding in strings
	 * @param string $_string  input to be converted
	 * @param mixed $charset false or string -> Target charset, if false bofelamimail displayCharset will be used
	 * @return string
	 */
	static function htmlentities($_string, $_charset=false)
	{
		//setting the charset (if not given)
		if ($_charset===false) $_charset = self::$displayCharset;
		$_stringORG = $_string;
		$_string = @htmlentities($_string,ENT_QUOTES,$_charset, false);
		if (empty($_string) && !empty($_stringORG)) $_string = @htmlentities(translation::convert($_stringORG,self::detect_encoding($_stringORG),$_charset),ENT_QUOTES | ENT_IGNORE,$_charset, false);
		return $_string;
	}

	/**
	 * detect_encoding - try to detect the encoding
	 *    only to be used if the string in question has no structure that determines his encoding
	 * @param string - to be evaluated
	 * @return string - encoding (iso-8859-1 as default)
	 */
	static function detect_encoding($string) {
		return translation::detect_encoding($string);
	}

	static function detect_qp(&$sting) {
		$needle = '/(=[0-9][A-F])|(=[A-F][0-9])|(=[A-F][A-F])|(=[0-9][0-9])/';
		return preg_match("$needle",$string);
	}
	/**
	 * Helper function to handle wrong or unrecognized timezones
	 * returns the date as it is parseable by strtotime, or current timestamp if everything failes
	 * @param string date to be parsed/formatted
	 * @param string format string, if none is passed, use the users common dateformat supplemented by the time hour:minute:second
	 * @return string returns the date as it is parseable by strtotime, or current timestamp if everything failes
	 */
	static function _strtotime($date='',$format=NULL,$convert2usertime=false)
	{
		if ($format==NULL) $format = $GLOBALS['egw_info']['user']['preferences']['common']['dateformat'].' '.($GLOBALS['egw_info']['user']['preferences']['common']['timeformat']==12?'h:i:s a':'H:i:s');
		$date2return = ($convert2usertime ? egw_time::server2user($date,$format) : egw_time::to($date,$format));
		if ($date2return==null)
		{
			$dtarr = explode(' ',$date);
			$test = null;
			while ($test===null && count($dtarr)>=1)
			{
				array_pop($dtarr);
				$test= ($convert2usertime ? egw_time::server2user(implode(' ',$dtarr),$format): egw_time::to(implode(' ',$dtarr),$format));
				if ($test) $date2return = $test;
			}
			if ($test===null) $date2return = egw_time::to('now',$format);
		}
		return $date2return;
	}

	/**
	 * checkFileBasics
	 *	check if formdata meets basic restrictions (in tmp dir, or vfs, mimetype, etc.)
	 *
	 * @param array $_formData passed by reference Array with information of name, type, file and size, mimetype may be adapted
	 * @param string $IDtoAddToFileName id to enrich the returned tmpfilename
	 * @param string $reqMimeType /(default message/rfc822, if set to false, mimetype check will not be performed
	 * @return mixed $fullPathtoFile or exception
	 */
	static function checkFileBasics(&$_formData, $IDtoAddToFileName='', $reqMimeType='message/rfc822')
	{
		//error_log(__METHOD__.__FILE__.array2string($_formData).' Id:'.$IDtoAddToFileName.' ReqMimeType:'.$reqMimeType);
		$importfailed = $tmpFileName = false;
		if ($_formData['size'] != 0 && (is_uploaded_file($_formData['file']) ||
			realpath(dirname($_formData['file'])) == realpath($GLOBALS['egw_info']['server']['temp_dir']) ||
			parse_url($_formData['file'],PHP_URL_SCHEME) == 'vfs'))
		{
			// ensure existance of eGW temp dir
			// note: this is different from apache temp dir,
			// and different from any other temp file location set in php.ini
			if (!file_exists($GLOBALS['egw_info']['server']['temp_dir']))
			{
				@mkdir($GLOBALS['egw_info']['server']['temp_dir'],0700);
			}

			// if we were NOT able to create this temp directory, then make an ERROR report
			if (!file_exists($GLOBALS['egw_info']['server']['temp_dir']))
			{
				$alert_msg .= 'Error:'.'
'
					.'Server is unable to access phpgw tmp directory'.'
'
					.$GLOBALS['egw_info']['server']['temp_dir'].'
'
					.'Please check your configuration'.'
'
					.'
';
			}

			// sometimes PHP is very clue-less about MIME types, and gives NO file_type
			// rfc default for unknown MIME type is:
			if ($reqMimeType == 'message/rfc822')
			{
				$mime_type_default = 'message/rfc';
			}
			else
			{
				$mime_type_default = $reqMimeType;
			}
			// check the mimetype by extension. as browsers seem to report crap
			// maybe its application/octet-stream -> this may mean that we could not determine the type
			// so we check for the suffix too
			// trust vfs mime-types, trust the mimetype if it contains a method
			if ((substr($_formData['file'],0,6) !== 'vfs://' || $_formData['type'] == 'application/octet-stream') && stripos($_formData['type'],'method=')===false)
			{
				$buff = explode('.',$_formData['name']);
				$suffix = '';
				if (is_array($buff)) $suffix = array_pop($buff); // take the last extension to check with ext2mime
				if (!empty($suffix)) $sfxMimeType = mime_magic::ext2mime($suffix);
				if (!empty($suffix) && !empty($sfxMimeType) &&
					(strlen(trim($_formData['type']))==0 || (strtolower(trim($_formData['type'])) != $sfxMimeType)))
				{
					error_log(__METHOD__.__LINE__.' Data:'.array2string($_formData));
					error_log(__METHOD__.__LINE__.' Form reported Mimetype:'.$_formData['type'].' but seems to be:'.$sfxMimeType);
					$_formData['type'] = $sfxMimeType;
				}
			}
			if (trim($_formData['type']) == '')
			{
				$_formData['type'] = 'application/octet-stream';
			}
			// if reqMimeType is set to false do not test for that
			if ($reqMimeType)
			{
				// so if PHP did not pass any file_type info, then substitute the rfc default value
				if (substr(strtolower(trim($_formData['type'])),0,strlen($mime_type_default)) != $mime_type_default)
				{
					if (!(strtolower(trim($_formData['type'])) == "application/octet-stream" && $sfxMimeType == $reqMimeType))
					{
						//error_log("Message rejected, no message/rfc. Is:".$_formData['type']);
						$importfailed = true;
						$alert_msg .= lang("File rejected, no %2. Is:%1",$_formData['type'],$reqMimeType);
					}
					if ((strtolower(trim($_formData['type'])) != $reqMimeType && $sfxMimeType == $reqMimeType))
					{
						$_formData['type'] = mime_magic::ext2mime($suffix);
					}
				}
			}
			// as FreeBSD seems to have problems with the generated temp names we append some more random stuff
			$randomString = chr(rand(65,90)).chr(rand(48,57)).chr(rand(65,90)).chr(rand(48,57)).chr(rand(65,90));
			$tmpFileName = $GLOBALS['egw_info']['server']['temp_dir'].
				SEP.
				$GLOBALS['egw_info']['user']['account_id'].
				trim($IDtoAddToFileName).basename($_formData['file']).'_'.$randomString;

			if (parse_url($_formData['file'],PHP_URL_SCHEME) == 'vfs')
			{
				$tmpFileName = $_formData['file'];	// no need to store it somewhere
			}
			elseif (is_uploaded_file($_formData['file']))
			{
				move_uploaded_file($_formData['file'],$tmpFileName);	// requirement for safe_mode!
			}
			else
			{
				rename($_formData['file'],$tmpFileName);
			}
		} else {
			//error_log("Import of message ".$_formData['file']." failes to meet basic restrictions");
			$importfailed = true;
			$alert_msg .= lang("Processing of file %1 failed. Failed to meet basic restrictions.",$_formData['name']);
		}
		if ($importfailed == true)
		{
			throw new egw_exception_wrong_userinput($alert_msg);
		}
		else
		{
			if (parse_url($tmpFileName,PHP_URL_SCHEME) == 'vfs')
			{
				egw_vfs::load_wrapper('vfs');
			}
			return $tmpFileName;
		}
	}

	/**
	 * getRandomString - function to be used to fetch a random string and md5 encode that one
	 * @param none
	 * @return string - a random number which is md5 encoded
	 */
	static function getRandomString() {
		mt_srand((float) microtime() * 1000000);
		return md5(mt_rand (100000, 999999));
	}

	/**
	 * functions to allow access to mails through other apps to fetch content
	 * used in infolog, tracker
	 */

	/**
	 * get_mailcontent - fetches the actual mailcontent, and returns it as well defined array
	 * @param object bofelamimail the bofelamimailobject to be used
	 * @param uid the uid of the email to be processed
	 * @param partid the partid of the email
	 * @param mailbox the mailbox, that holds the message
	 * @param preserveHTML flag to pass through to getdisplayableBody
	 * @return array with 'mailaddress'=>$mailaddress,
	 *				'subject'=>$subject,
	 *				'message'=>$message,
	 *				'attachments'=>$attachments,
	 *				'headers'=>$headers,
	 */
	static function get_mailcontent(&$bofelamimail,$uid,$partid='',$mailbox='', $preserveHTML = false)
	{
			//echo __METHOD__." called for $uid,$partid 
";
			$headers = $bofelamimail->getMessageHeader($uid,$partid,true);
			// dont force retrieval of the textpart, let felamimail preferences decide
			$bodyParts = $bofelamimail->getMessageBody($uid,($preserveHTML?'always_display':'only_if_no_text'),$partid);
			//error_log(array2string($bodyParts));
			$attachments = $bofelamimail->getMessageAttachments($uid,$partid);

			if ($bofelamimail->isSentFolder($mailbox)) $mailaddress = $headers['TO'];
			elseif (isset($headers['FROM'])) $mailaddress = $headers['FROM'];
			elseif (isset($headers['SENDER'])) $mailaddress = $headers['SENDER'];
			if (isset($headers['CC'])) $mailaddress .= ','.$headers['CC'];
			//_debug_array($headers);
			$subject = $headers['SUBJECT'];

			$message = self::getdisplayableBody($bofelamimail, $bodyParts, $preserveHTML);
			if ($preserveHTML && $bofelamimail->activeMimeType == 'text/plain') $message = '
'.$message.'
';
			$headdata = self::createHeaderInfoSection($headers, '',$preserveHTML);
			$message = $headdata.$message;
			//echo __METHOD__.'
';
			//_debug_array($attachments);
			if (is_array($attachments))
			{
				foreach ($attachments as $num => $attachment)
				{
					if ($attachment['mimeType'] == 'MESSAGE/RFC822')
					{
						//_debug_array($bofelamimail->getMessageHeader($uid, $attachment['partID']));
						//_debug_array($bofelamimail->getMessageBody($uid,'', $attachment['partID']));
						//_debug_array($bofelamimail->getMessageAttachments($uid, $attachment['partID']));
						$mailcontent = self::get_mailcontent($bofelamimail,$uid,$attachment['partID']);
						$headdata ='';
						if ($mailcontent['headers'])
						{
							$headdata = self::createHeaderInfoSection($mailcontent['headers'],'',$preserveHTML);
						}
						if ($mailcontent['message'])
						{
							$tempname =tempnam($GLOBALS['egw_info']['server']['temp_dir'],$GLOBALS['egw_info']['flags']['currentapp']."_");
							$attachedMessages[] = array(
								'type' => 'TEXT/PLAIN',
								'name' => $mailcontent['subject'].'.txt',
								'tmp_name' => $tempname,
							);
							$tmpfile = fopen($tempname,'w');
							fwrite($tmpfile,$headdata.$mailcontent['message']);
							fclose($tmpfile);
						}
						foreach($mailcontent['attachments'] as $tmpattach => $tmpval)
						{
							$attachedMessages[] = $tmpval;
						}
						unset($attachments[$num]);
					}
					else
					{
						$attachments[$num] = array_merge($attachments[$num],$bofelamimail->getAttachment($uid, $attachment['partID']));
						if (isset($attachments[$num]['charset'])) {
							if ($attachments[$num]['charset']===false) $attachments[$num]['charset'] = self::detect_encoding($attachments[$num]['attachment']);
							translation::convert($attachments[$num]['attachment'],$attachments[$num]['charset']);
						}
						$attachments[$num]['type'] = $attachments[$num]['mimeType'];
						$attachments[$num]['tmp_name'] = tempnam($GLOBALS['egw_info']['server']['temp_dir'],$GLOBALS['egw_info']['flags']['currentapp']."_");
						$tmpfile = fopen($attachments[$num]['tmp_name'],'w');
						fwrite($tmpfile,$attachments[$num]['attachment']);
						fclose($tmpfile);
						unset($attachments[$num]['attachment']);
					}
				}
				if (is_array($attachedMessages)) $attachments = array_merge($attachments,$attachedMessages);
			}
			return array(
					'mailaddress'=>$mailaddress,
					'subject'=>$subject,
					'message'=>$message,
					'attachments'=>$attachments,
					'headers'=>$headers,
					);
	}

	/**
	 * createHeaderInfoSection - creates a textual headersection from headerobject
	 * @param array header headerarray may contain SUBJECT,FROM,SENDER,TO,CC,BCC,DATE,PRIORITY,IMPORTANCE
	 * @param string headline Text tom use for headline
	 * @param bool createHTML do it with HTML breaks
	 * @return string a preformatted string with the information of the header worked into it
	 */
	static function createHeaderInfoSection($header,$headline='', $createHTML = false)
	{
		$headdata = null;
		if ($header['SUBJECT']) $headdata = lang('subject').': '.$header['SUBJECT'].($createHTML?"
":"\n");
		if ($header['FROM']) $headdata .= lang('from').': '.self::convertAddressArrayToString($header['FROM'], $createHTML).($createHTML?"
":"\n");
		if ($header['SENDER']) $headdata .= lang('sender').': '.self::convertAddressArrayToString($header['SENDER'], $createHTML).($createHTML?"
":"\n");
		if ($header['TO']) $headdata .= lang('to').': '.self::convertAddressArrayToString($header['TO'], $createHTML).($createHTML?"
":"\n");
		if ($header['CC']) $headdata .= lang('cc').': '.self::convertAddressArrayToString($header['CC'], $createHTML).($createHTML?"
":"\n");
		if ($header['BCC']) $headdata .= lang('bcc').': '.self::convertAddressArrayToString($header['BCC'], $createHTML).($createHTML?"
":"\n");
		if ($header['DATE']) $headdata .= lang('date').': '.$header['DATE'].($createHTML?"
":"\n");
		if ($header['PRIORITY'] && $header['PRIORITY'] != 'normal') $headdata .= lang('priority').': '.$header['PRIORITY'].($createHTML?"
":"\n");
		if ($header['IMPORTANCE'] && $header['IMPORTANCE'] !='normal') $headdata .= lang('importance').': '.$header['IMPORTANCE'].($createHTML?"
":"\n");
		//if ($mailcontent['headers']['ORGANIZATION']) $headdata .= lang('organization').': '.$mailcontent['headers']['ORGANIZATION']."\
		if (!empty($headdata))
		{
			if (!empty($headline)) $headdata = "---------------------------- $headline ----------------------------".($createHTML?"
":"\n").$headdata;
			if (empty($headline)) $headdata = "--------------------------------------------------------".($createHTML?"
":"\n").$headdata;
			$headdata .= "--------------------------------------------------------".($createHTML?"
":"\n");
		}
		else
		{
			$headdata = "--------------------------------------------------------".($createHTML?"
":"\n");
		}
		return $headdata;
	}

	/**
	 * convertAddressArrayToString - converts an felamimail envelope Address Array To String
	 * @param array $rfcAddressArray  an addressarray as provided by felamimail retieved via egw_pear....
	 * @return string a comma separated string with the mailaddress(es) converted to text
	 */
	static function convertAddressArrayToString($rfcAddressArray, $createHTML = false)
	{
		//error_log(__METHOD__.__LINE__.array2string($rfcAddressArray));
		$returnAddr ='';
		if (is_array($rfcAddressArray))
		{
			foreach((array)$rfcAddressArray as $addressData) {
				//error_log(__METHOD__.__LINE__.array2string($addressData));
				if($addressData['MAILBOX_NAME'] == 'NIL') {
					continue;
				}
				if(strtolower($addressData['MAILBOX_NAME']) == 'undisclosed-recipients') {
					continue;
				}
				if ($addressData['RFC822_EMAIL'])
				{
					$addressObjectA = imap_rfc822_parse_adrlist((get_magic_quotes_gpc()?stripslashes($addressData['RFC822_EMAIL']):$addressData['RFC822_EMAIL']),'');
				}
				else
				{
					$emailaddress = ($addressData['PERSONAL_NAME']?$addressData['PERSONAL_NAME'].' <'.$addressData['EMAIL'].'>':$addressData['EMAIL']);
					$addressObjectA = imap_rfc822_parse_adrlist((get_magic_quotes_gpc()?stripslashes($emailaddress):$emailaddress),'');
				}
				$addressObject = $addressObjectA[0];
				//error_log(__METHOD__.__LINE__.array2string($addressObject));
				if ($addressObject->host == '.SYNTAX-ERROR.') continue;
				//$mb =(string)$addressObject->mailbox;
				//$h = (string)$addressObject->host;
				//$p = (string)$addressObject->personal;
				$returnAddr .= (strlen($returnAddr)>0?',':'');
				//error_log(__METHOD__.__LINE__.$p.' <'.$mb.'@'.$h.'>');
				$buff = imap_rfc822_write_address($addressObject->mailbox, $addressObject->host, $addressObject->personal);
				$buff = str_replace(array('<','>'),array('[',']'),$buff);
				if ($createHTML) $buff = felamimail_bo::htmlspecialchars($buff);
				//error_log(__METHOD__.__LINE__.' Address: '.$returnAddr);
				$returnAddr .= $buff;
			}
		}
		else
		{
			// do not mess with strings, return them untouched /* ToDo: validate string as Address */
			$rfcAddressArray = str_replace(array('<','>'),array('[',']'),$rfcAddressArray);
			if (is_string($rfcAddressArray)) return ($createHTML ? felamimail_bo::htmlspecialchars($rfcAddressArray) : $rfcAddressArray);
		}
		return $returnAddr;
	}

	/**
	 * getStyles - extracts the styles from the given bodyparts
	 * @param array $bodyParts  with the bodyparts
	 * @return string a preformatted string with the mails converted to text
	 */
	static function &getStyles($_bodyParts)
	{
		$style = '';
		if (empty($_bodyParts)) return "";
		foreach((array)$_bodyParts as $singleBodyPart) {
			if (!isset($singleBodyPart['body'])) {
				$singleBodyPart['body'] = self::getStyles($singleBodyPart);
				$style .= $singleBodyPart['body'];
				continue;
			}
			if ($singleBodyPart['charSet']===false) $singleBodyPart['charSet'] = felamimail_bo::detect_encoding($singleBodyPart['body']);
			$singleBodyPart['body'] = translation::convert(
				$singleBodyPart['body'],
				strtolower($singleBodyPart['charSet'])
			);
			$ct = 0;
			if (stripos($singleBodyPart['body'],'(.+)#isU', $singleBodyPart['body'], $newStyle);
			if ($ct>0)
			{
				//error_log(__METHOD__.__LINE__.array2string($newStyle[0]));
				$style2buffer = implode('',$newStyle[0]);
			}
			if ($style2buffer && strtoupper(self::$displayCharset) == 'UTF-8')
			{
				//error_log(__METHOD__.__LINE__.array2string($style2buffer));
				$test = json_encode($style2buffer);
				//error_log(__METHOD__.__LINE__.'#'.$test.'# ->'.strlen($style2buffer).' Error:'.json_last_error());
				//if (json_last_error() != JSON_ERROR_NONE && strlen($style2buffer)>0)
				if ($test=="null" && strlen($style2buffer)>0)
				{
					// this should not be needed, unless something fails with charset detection/ wrong charset passed
					error_log(__METHOD__.__LINE__.' Found Invalid sequence for utf-8 in CSS:'.$style2buffer.' Charset Reported:'.$singleBodyPart['charSet'].' Carset Detected:'.felamimail_bo::detect_encoding($style2buffer));
					$style2buffer = utf8_encode($style2buffer);
				}
			}
			$style .= $style2buffer;
		}
	    // clean out comments and stuff
		$search = array(
			'@url\(http:\/\/[^\)].*?\)@si',  // url calls e.g. in style definitions
//			'@@',   // Strip multi-line comments including CDATA
//			'@