";
		#$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);
			//see this example below for a 12 week datefilter (since)
			//$_filter = array('status'=>array('UNDELETED'),'type'=>"SINCE",'string'=> date("d-M-Y", $starttime-(3600*24*7*12)));
			$_sortResult = $this->getSortedList($_folderName, $_sort, $reverse, $_filter, $rByUid, $_cacheResult);
			$sortResult = $_sortResult['match']->ids;
			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 "

, 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) translation::replaceTagsCompletley($_html,'style'); // clean out empty or pagewide style definitions / left over tags
		if (stripos($_html,'head')!==false) translation::replaceTagsCompletley($_html,'head'); // Strip out stuff in head
		//if (stripos($_html,'![if')!==false && stripos($_html,'')!==false) translation::replaceTagsCompletley($_html,'!\[if','',false); // Strip out stuff in ifs
		//if (stripos($_html,'!--[if')!==false && stripos($_html,'')!==false) translation::replaceTagsCompletley($_html,'!--\[if','',false); // Strip out stuff in ifs
		//error_log(__METHOD__.__LINE__.$_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']['mail']['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) translation::replaceTagsCompletley($_html,'!doctype');
			if (stripos($_html,'?xml:namespace')!==false) translation::replaceTagsCompletley($_html,'\?xml:namespace','/>',false);
			if (stripos($_html,'?xml version')!==false) translation::replaceTagsCompletley($_html,'\?xml version','\?>',false);
			if (strpos($_html,'!CURSOR')!==false) translation::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(__METHOD__.':'.__LINE__.':'.$_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);
			}
		}
	}

	/**
	 * Header and Bodystructure stuff
	 */

	/**
	 * _getStructure
	 * fetch the structure of a mail, represented by uid
	 * @param string/int $_uid the messageuid,
	 * @param boolean $byUid=true, is the messageuid given by UID or ID
	 * @param boolean $_ignoreCache=false, use or disregard cache, when fetching
	 * @param string $_folder='', if given search within that folder for the given $_uid, else use sessionData['mailbox'], or servers getCurrentMailbox
	 * @return array  an structured array of information about the mail
	 */
	function _getStructure($_uid, $byUid=true, $_ignoreCache=false, $_folder = '')
	{
		static $structure;
		if (empty($_folder)) $_folder = ($this->sessionData['mailbox']? $this->sessionData['mailbox'] : $this->icServer->getCurrentMailbox());
		//error_log(__METHOD__.__LINE__.'User:'.trim($GLOBALS['egw_info']['user']['account_id'])." UID: $_uid, ".$this->icServer->ImapServerId.','.$_folder);
		if (is_null($structure)) $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);
		//error_log(__METHOD__.__LINE__." UID: $_uid, ".$this->icServer->ImapServerId.','.$_folder.'->'.array2string(array_keys($structure)));
		if (isset($structure[$this->icServer->ImapServerId]) && !empty($structure[$this->icServer->ImapServerId]) &&
			isset($structure[$this->icServer->ImapServerId][$_folder]) && !empty($structure[$this->icServer->ImapServerId][$_folder]) &&
			isset($structure[$this->icServer->ImapServerId][$_folder][$_uid]) && !empty($structure[$this->icServer->ImapServerId][$_folder][$_uid]))
		{
			if ($_ignoreCache===false)
			{
				//error_log(__METHOD__.__LINE__.' Using cache for structure on Server:'.$this->icServer->ImapServerId.' for uid:'.$_uid." in Folder:".$_folder.'->'.array2string($structure[$this->icServer->ImapServerId][$_folder][$_uid]));
				return $structure[$this->icServer->ImapServerId][$_folder][$_uid];
			}
		}
		$structure[$this->icServer->ImapServerId][$_folder][$_uid] = $this->icServer->getStructure($_uid, $byUid);
		egw_cache::setCache(egw_cache::INSTANCE,'email','structureCache'.trim($GLOBALS['egw_info']['user']['account_id']),$structure,$expiration=60*60*1);
		//error_log(__METHOD__.__LINE__.' Using query for structure on Server:'.$this->icServer->ImapServerId.' for uid:'.$_uid." in Folder:".$_folder.'->'.array2string($structure[$this->icServer->ImapServerId][$_folder][$_uid]));
		return $structure[$this->icServer->ImapServerId][$_folder][$_uid];
	}

	/**
	 * _getSummary
	 * fetch the summary for the mails, requested by queryString
	 * @param string/int $queryString the messageuid(s),
	 * @param boolean $byUid=true, is the messageuid given by UID or ID
	 * @param boolean $_ignoreCache=false, use or disregard cache, when fetching
	 * @param string $_folder='', if given search within that folder for the given $queryString, else use sessionData['mailbox'], or servers getCurrentMailbox()
	 * @return array  an array with the mail headers requested
	 */
	function _getSummary($queryString, $byUid=true, $_ignoreCache=false, $_folder = '')
	{
		static $summary;
		if (empty($_folder)) $_folder = ($this->sessionData['mailbox']? $this->sessionData['mailbox'] : $this->icServer->getCurrentMailbox());
		//error_log(__METHOD__.__LINE__.'User:'.trim($GLOBALS['egw_info']['user']['account_id'])." UID: $_uid, ".$this->icServer->ImapServerId.','.$_folder);
		if (is_null($summary)) $summary = egw_cache::getCache(egw_cache::INSTANCE,'email','summaryCache'.trim($GLOBALS['egw_info']['user']['account_id']),$callback=null,$callback_params=array(),$expiration=60*60*1);
		$_uids = explode(',', $queryString);
		$uidsCached = (is_array($summary[$this->icServer->ImapServerId][$_folder])?array_keys($summary[$this->icServer->ImapServerId][$_folder]):array());
		$toFetch = array_diff($_uids,(array)$uidsCached);
		$saveNeeded = false;
		if (!empty($toFetch))
		{
			//error_log(__METHOD__.__LINE__.':'.$GLOBALS['egw_info']['user']['account_id'].'::'.$this->icServer->ImapServerId.'::'. $_folder.':QS:'.$queryString.'->'.array2string(array_keys((array)$summary[$this->icServer->ImapServerId][$_folder])));
			error_log(__METHOD__.__LINE__.':UserID:'.$GLOBALS['egw_info']['user']['account_id'].':ServerID:'.$this->icServer->ImapServerId.'::'.' fetch Summary for Headers in Folder:'.$_folder.' with:'.implode(',',$toFetch));
			if (!isset($summary[$this->icServer->ImapServerId])) $summary[$this->icServer->ImapServerId]=array();
			if (!isset($summary[$this->icServer->ImapServerId][$_folder])) $summary[$this->icServer->ImapServerId][$_folder]=array();
			$result = $this->icServer->getSummary(implode(',',$toFetch), $byUid);
			foreach ($result as $sum)
			{
				//error_log(__METHOD__.__LINE__.'::'.$sum['UID'].':'.$sum['SUBJECT']);
				$summary[$this->icServer->ImapServerId][$_folder][$sum['UID']]=$sum;
			}
			$saveNeeded = true;
		}
		foreach ($_uids as $_uid)
		{
			$fetched=false;
			//error_log(__METHOD__.__LINE__." UID: $_uid, ".$this->icServer->ImapServerId.','.$_folder.'->'.array2string($summary[$this->icServer->ImapServerId][$_folder][$_uid]));
			if (isset($summary[$this->icServer->ImapServerId]) && !empty($summary[$this->icServer->ImapServerId]) &&
				isset($summary[$this->icServer->ImapServerId][$_folder]) && !empty($summary[$this->icServer->ImapServerId][$_folder]) &&
				isset($summary[$this->icServer->ImapServerId][$_folder][$_uid]) && !empty($summary[$this->icServer->ImapServerId][$_folder][$_uid]))
			{
				if ($_ignoreCache===false)
				{
					//error_log(__METHOD__.__LINE__.' Using cache for structure on Server:'.$this->icServer->ImapServerId.' for uid:'.$_uid." in Folder:".$_folder.'->'.array2string($structure[$this->icServer->ImapServerId][$_folder][$_uid]));
					$rv[] = $summary[$this->icServer->ImapServerId][$_folder][$_uid];
					$fetched=true;
				}
			}
			if ($fetched==false)
			{
				error_log(__METHOD__.__LINE__.':UserID:'.$GLOBALS['egw_info']['user']['account_id'].':ServerID:'.$this->icServer->ImapServerId.'::'.' fetch Summary for Header in Folder:'.$_folder.' with:'.$_uid);
				$result = $this->icServer->getSummary($_uid, $byUid);
				$summary[$this->icServer->ImapServerId][$_folder][$_uid] = $result[0];
				$rv[] = $summary[$this->icServer->ImapServerId][$_folder][$_uid];
				$saveNeeded = true;
			}
		}
		if ( $saveNeeded ) egw_cache::setCache(egw_cache::INSTANCE,'email','summaryCache'.trim($GLOBALS['egw_info']['user']['account_id']),$summary,$expiration=60*60*1);
		//error_log(__METHOD__.__LINE__.' Using query for summary on Server:'.$this->icServer->ImapServerId.' for uid:'.$_uid." in Folder:".$_folder.'->'.array2string($structure[$this->icServer->ImapServerId][$_folder][$_uid]));
		return $rv;
	}

	/**
	 * _getSubStructure
	 * fetch the substructure of a mail, by given structure and partid
	 * @param array $_structure='', if given use structure for parsing
	 * @param string/int $_partID the partid,
	 * @return array  an structured array of information about the mail
	 */
	function _getSubStructure($_structure, $_partID)
	{
		$tempID = '';
		$structure = $_structure;
		if (empty($_partID)) $_partID=1;
		$imapPartIDs = explode('.',$_partID);
		#error_log(print_r($structure,true));
		#error_log(print_r($_partID,true));

		if($_partID != 1) {
			foreach($imapPartIDs as $imapPartID) {
				if(!empty($tempID)) {
					$tempID .= '.';
				}
				$tempID .= $imapPartID;
				#error_log(print_r( "TEMPID: $tempID
",true));
				//_debug_array($structure);
				if($structure->subParts[$tempID]->type == 'MESSAGE' && $structure->subParts[$tempID]->subType == 'RFC822' &&
				   count($structure->subParts[$tempID]->subParts) == 1 &&
				   $structure->subParts[$tempID]->subParts[$tempID]->type == 'MULTIPART' &&
				   ($structure->subParts[$tempID]->subParts[$tempID]->subType == 'MIXED' ||
				    $structure->subParts[$tempID]->subParts[$tempID]->subType == 'ALTERNATIVE' ||
				    $structure->subParts[$tempID]->subParts[$tempID]->subType == 'RELATED' ||
				    $structure->subParts[$tempID]->subParts[$tempID]->subType == 'REPORT'))
				{
					$structure = $structure->subParts[$tempID]->subParts[$tempID];
				} else {
					$structure = $structure->subParts[$tempID];
				}
			}
		}

		if($structure->partID != $_partID) {
			foreach($imapPartIDs as $imapPartID) {
				if(!empty($tempID)) {
					$tempID .= '.';
				}
				$tempID .= $imapPartID;
				//print "TEMPID: $tempID
";
				//_debug_array($structure);
				if($structure->subParts[$tempID]->type == 'MESSAGE' && $structure->subParts[$tempID]->subType == 'RFC822' &&
				   count($structure->subParts[$tempID]->subParts) == 1 &&
				   $structure->subParts[$tempID]->subParts[$tempID]->type == 'MULTIPART' &&
				   ($structure->subParts[$tempID]->subParts[$tempID]->subType == 'MIXED' ||
				    $structure->subParts[$tempID]->subParts[$tempID]->subType == 'ALTERNATIVE' ||
				    $structure->subParts[$tempID]->subParts[$tempID]->subType == 'RELATED' ||
				    $structure->subParts[$tempID]->subParts[$tempID]->subType == 'REPORT')) {
					$structure = $structure->subParts[$tempID]->subParts[$tempID];
				} else {
					$structure = $structure->subParts[$tempID];
				}
			}
			if($structure->partID != $_partID) {
				error_log(__METHOD__."(". __LINE__ .") partID's don't match");
				return false;
			}
		}

		return $structure;
	}

	/**
	 * 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);
	}

	/**
	 * decodeMimePart - fetches the charset mimepart if it exists
	 * @param string $_mimeMessage - the message to be decoded
	 * @param string $_encoding - the encoding used BASE64 and QUOTED-PRINTABLE is supported
	 * @param string $_charset - not used
	 * @return string decoded mimePart
	 */
	function decodeMimePart($_mimeMessage, $_encoding, $_charset = '')
	{
		// decode the part
		if (self::$debug) error_log(__METHOD__."() with $_encoding and $_charset:".print_r($_mimeMessage,true));
		switch (strtoupper($_encoding))
		{
			case 'BASE64':
				// use imap_base64 to decode, not any longer, as it is strict, and fails if it encounters invalid chars
				return base64_decode($_mimeMessage); //imap_base64($_mimeMessage);
				break;
			case 'QUOTED-PRINTABLE':
				// use imap_qprint to decode
				return quoted_printable_decode($_mimeMessage);
				break;
			default:
				// it is either not encoded or we don't know about it
				return $_mimeMessage;
				break;
		}
	}

	/**
	 * getMultipartAlternative
	 * get part of the message, if its stucture is indicating its of multipart alternative style
	 * a wrapper for multipartmixed
	 * @param string/int $_uid the messageuid,
	 * @param Horde_Mime_Part $_structure structure for parsing
	 * @param string $_htmlMode, how to display a message, html, plain text, ...
	 * @param boolean $_preserveSeen flag to preserve the seenflag by using body.peek
	 * @return array containing the desired part
	 */
	function getMultipartAlternative($_uid, Horde_Mime_Part $_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 = $partHTML = null;
		if (self::$debug) _debug_array(array("METHOD"=>__METHOD__,"LINE"=>__LINE__,"STRUCTURE"=>$_structure));

		$ignore_first_part = true;
		foreach($_structure->contentTypeMap() as $mime_id => $mime_type)
		{
			//error_log(__METHOD__."($_uid, ".$_structure->getMimeId().") $mime_id: $mime_type");
			if (self::$debug) echo __METHOD__."($_uid, partID=".$_structure->getMimeId().") $mime_id: $mime_type
";

			if ($ignore_first_part)
			{
				$ignore_first_part = false;
				continue;	// ignore multipart/alternative itself
			}

			$mimePart = $_structure->getPart($mime_id);

			switch($mimePart->getPrimaryType())
			{
				case 'text':
					switch($mimePart->getSubType())
					{
						case 'calendar':	// only if there is no partText set already
							if ($partText) break;
							// fall throught
						case 'plain':
							if ($mimePart->getBytes() > 0) $partText = $mimePart;
							break;

						case 'html':
							if ($mimePart->getBytes() > 0)  $partHTML = $mimePart;
							break;
					}
					break;

				case 'multipart':
					switch($mimePart->getSubType())
					{
						case 'related':
						case 'mixed':
							if (count($mimePart->getParts()) > 1)
							{
								// in a multipart alternative we treat the multipart/related as html part
								if (self::$debug) error_log(__METHOD__." process MULTIPART/RELATED with array as subparts");
								$partHTML = $mimePart;
							}
							break;

						case 'alternative':
							if (count($mimePart->getParts()) > 1)
							{
								//cascading multipartAlternative structure, assuming only the first one is to be used
								return $this->getMultipartAlternative($_uid, $mimePart, $_htmlMode, $_preserveSeen);
							}
					}
			}
		}

		switch($_htmlMode)
		{
			case 'html_only':
			case 'always_display':
				if ($partHTML)
				{
					switch($partHTML->getSubType())
					{
						case 'related':
							return $this->getMultipartRelated($_uid, $partHTML, $_htmlMode, $_preserveSeen);

						case 'mixed':
							return $this->getMultipartMixed($_uid, $partHTML, $_htmlMode, $_preserveSeen);

						default:
							return $this->getTextPart($_uid, $partHTML, $_htmlMode, $_preserveSeen);
					}
				}
				elseif ($partText && $_htmlMode=='always_display')
				{
					return $this->getTextPart($_uid, $partText, $_htmlMode, $_preserveSeen);
				}
				break;

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

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

	/**
	 * Get part of the message, if its stucture is indicating its of multipart mixed style
	 *
	 * @param int $_uid the messageuid,
	 * @param Horde_Mime_Part $_structure='', if given use structure for parsing
	 * @param string $_htmlMode, how to display a message, html, plain text, ...
	 * @param boolean $_preserveSeen flag to preserve the seenflag by using body.peek
	 * @return array containing the desired part
	 */
	function getMultipartMixed($_uid, Horde_Mime_Part $_structure, $_htmlMode, $_preserveSeen = false)
	{
		if (self::$debug) echo __METHOD__."$_uid, $_htmlMode
";
		$bodyPart = array();
		if (self::$debug) _debug_array($_structure);

		$ignore_first_part = true;
		foreach($_structure->contentTypeMap() as $mime_id => $mime_type)
		{
			//error_log(__METHOD__."($_uid, ".$_structure->getMimeId().") $mime_id: $mime_type");
			if (self::$debug) echo __METHOD__."($_uid, partID=".$_structure->getMimeId().") $mime_id: $mime_type
";

			if ($ignore_first_part)
			{
				$ignore_first_part = false;
				continue;	// ignore multipart/mixed itself
			}

			$part = $_structure->getPart($mime_id);

			switch($part->getPrimaryType())
			{
				case 'multipart':
					switch($part->getSubType())
					{
						case 'alternative':
							return array($this->getMultipartAlternative($_uid, $part, $_htmlMode, $_preserveSeen));

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

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

				case 'text':
					switch($part->getSubType())
					{
						case 'plain':
						case 'html':
						case 'calendar': // inline ics/ical files
							if($part->getDisposition() != '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->getSubType() == 'delivery-status')
					{
						$bodyPart[] = $this->getTextPart($_uid, $part, $_htmlMode, $_preserveSeen);
					}
					break;

				default:
					// do nothing
					// the part is a attachment
			}
		}

		return $bodyPart;
	}

	/**
	 * getMultipartRelated
	 * get part of the message, if its stucture is indicating its of multipart related style
	 * a wrapper for multipartmixed
	 * @param string/int $_uid the messageuid,
	 * @param Horde_Mime_Part $_structure, if given use structure for parsing
	 * @param string $_htmlMode, how to display a message, html, plain text, ...
	 * @param boolean $_preserveSeen flag to preserve the seenflag by using body.peek
	 * @return array containing the desired part
	 */
	function getMultipartRelated($_uid, Horde_Mime_Part $_structure, $_htmlMode, $_preserveSeen = false)
	{
		return $this->getMultipartMixed($_uid, $_structure, $_htmlMode, $_preserveSeen);
	}

	/**
	 * Fetch a body part
	 *
	 * @param int $_uid
	 * @param string $_partID=null
	 * @param string $_folder=null
	 * @param boolean $_preserveSeen=false
	 * @param boolean $_stream=false true return a stream, false return string
	 * @param string &$_encoding=null on return: transfer encoding of returned part
	 * @return string|resource
	 */
	function getBodyPart($_uid, $_partID=null, $_folder=null, $_preserveSeen=false, $_stream=false, &$_encoding=null)
	{
		if (self::$debug) error_log( __METHOD__."($_uid, $_partID, $_folder, $_preserveSeen)");

		if (empty($_folder))
		{
			$_folder = ($this->sessionData['mailbox']? $this->sessionData['mailbox'] : $this->icServer->getCurrentMailbox());
		}
		//error_log(__METHOD__.__LINE__.array2string($_folder).'/'.$this->icServer->getCurrentMailbox().'/'. $this->sessionData['mailbox']);
		// querying contents of body part
		$uidsToFetch = new Horde_Imap_Client_Ids();
		$uidsToFetch->add((array)$_uid);

		$fquery = new Horde_Imap_Client_Fetch_Query();
		$fquery->bodyPart($_partID, array(
			'peek' => $_preserveSeen,
			'decode' => true,	// try decode on server, does NOT neccessary work
		));

		$part = $this->icServer->fetch($_folder, $fquery, array(
			'ids' => $uidsToFetch,
		))->first();

		if (!$part) return null;

		$_encoding = $part->getBodyPartDecode($_partID);

		return $part->getBodyPart($_partID, $_stream);
	}

	/**
	 * Get Body from message
	 *
	 * @param int $_uid the messageuid
	 * @param Horde_Mime_Part $_structure=null, if given use structure for parsing
	 * @param string $_htmlMode how to display a message: 'html_only', 'always_display', 'only_if_no_text' or ''
	 * @param boolean $_preserveSeen flag to preserve the seenflag by using body.peek
	 * @param boolean $_stream=false true return a stream, false return string
	 * @return array containing the desired text part, mimeType and charset
	 */
	function getTextPart($_uid, Horde_Mime_Part $_structure, $_htmlMode='', $_preserveSeen=false, $_stream=false)
	{
		//error_log(__METHOD__.__LINE__.'->'.$_uid.':'.array2string($_structure).' '.function_backtrace());
		$bodyPart = array();
		if (self::$debug) _debug_array(array($_structure,function_backtrace()));

		if($_structure->getSubType() == 'html' && !in_array($_htmlMode, array('html_only', 'always_display', 'only_if_no_text')))
		{
			$bodyPart = array(
				'error'		=> 1,
				'body'		=> lang("displaying html messages is disabled"),
				'mimeType'	=> 'text/html',
				'charSet'	=> self::$displayCharset,
			);
		}
		elseif ($_structure->getSubType() == '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
			// RB: not sure what this is: preg_replace('/PropertyFile___$/','',$this->decodeMimePart($mimePartBody, $_structure->encoding, $this->getMimePartCharset($_structure))),
			$this->fetchPartContents($_uid, $_structure, $_stream, $_preserveSeen);

			$bodyPart = array(
				'body'		=> $_structure->getContents(array(
					'stream' => $_stream,
				)),
				'mimeType'  => $_structure->getType() == 'text/html' ? 'text/html' : 'text/plain',
				'charSet'	=> $_structure->getCharset(),
			);
/* RB: not sure this is still necessary
			if ($_structure->type == 'TEXT' && $_structure->subType == 'PLAIN' &&
				is_array($_structure->parameters) && isset($_structure->parameters['FORMAT']) &&
				trim(strtolower($_structure->parameters['FORMAT']))=='flowed'
			)
			{
				if (self::$debug) error_log(__METHOD__.__LINE__." detected TEXT/PLAIN Format:flowed -> removing leading blank ('\r\n ') per line");
				$bodyPart['body'] = str_replace("\r\n ","\r\n", $bodyPart['body']);
			}
*/
			if ($_structure->getSubType() == 'calendar')
			{
				$bodyPart['body'] = $this->getEvent($_structure->getContents(), $_structure->getContentTypeParameter('METHOD'));
			}
		}
		return $bodyPart;
	}

	/**
	 * Return inline ical as html
	 *
	 * @param string $ical iCal data
	 * @param string $method iTip method eg. 'REPLY'
	 * @return string text to display instead
	 */
	function getEvent($ical, $method=null)
	{
		// 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
		$events = $calobj->icaltoegw($ical);
		$event =& $events[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 ($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, $method !='REPLY');
		$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
		$text = $subject;
		$text .= "\n".$info;
		$text .= "\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:
						$text .= sprintf("%-20s %s\n",$val['field'].':',$details[$key]);
						break;
				}
			}
		}
		return $text;
	}

	/**
	 * Get Body of message
	 *
	 * @param int $_uid the messageuid,
	 * @param string $_htmlOptions, how to display a message, html, plain text, ...
	 * @param string $_partID=null , the partID, may be omitted
	 * @param Horde_Mime_Part $_structure=null if given use structure for parsing
	 * @param boolean $_preserveSeen flag to preserve the seenflag by using body.peek
	 * @return array containing the message body, mimeType and charset
	 */
	function getMessageBody($_uid, $_htmlOptions='', $_partID=null, Horde_Mime_Part $_structure=null, $_preserveSeen = false, $_folder = '')
	{
		if (self::$debug) echo __METHOD__."$_uid, $_htmlOptions, $_partID
";
		if($_htmlOptions != '') {
			$this->htmlOptions = $_htmlOptions;
		}
		if (empty($_folder))
		{
			$_folder = $this->sessionData['mailbox'];
		}
		if (!isset($_structure))
		{
			$_structure = $this->getStructure($_uid, $_partID, $_folder, $_preserveSeen);
		}

/*
		if ($_preserveSeen==false)
		{
			$summary = egw_cache::getCache(egw_cache::INSTANCE,'email','summaryCache'.trim($GLOBALS['egw_info']['user']['account_id']),$callback=null,$callback_params=array(),$expiration=60*60*1);
			$cachemodified = false;
			if (isset($summary[$this->icServer->ImapServerId][$_folder][$_uid]))
			{
				$cachemodified = true;
				unset($summary[$this->icServer->ImapServerId][$_folder][$_uid]);
			}
			if ($cachemodified)
			{
				egw_cache::setCache(egw_cache::INSTANCE,'email','summaryCache'.trim($GLOBALS['egw_info']['user']['account_id']),$summary,$expiration=60*60*1);
			}
		}
 */
		switch($_structure->getPrimaryType())
		{
			case 'application':
				return array(
					array(
						'body'		=> '',
						'mimeType'	=> 'text/plain',
						'charSet'	=> 'iso-8859-1',
					)
				);

			case 'multipart':
				switch($_structure->getSubType())
				{
					case 'alternative':
						$bodyParts = array($this->getMultipartAlternative($_uid, $_structure, $this->htmlOptions, $_preserveSeen));
						break;

					case 'nil': // multipart with no Alternative
					case 'mixed':
					case 'report':
					case 'signed':
						$bodyParts = $this->getMultipartMixed($_uid, $_structure, $this->htmlOptions, $_preserveSeen);
						break;

					case 'related':
						$bodyParts = $this->getMultipartRelated($_uid, $_structure, $this->htmlOptions, $_preserveSeen);
						break;
				}
				return self::normalizeBodyParts($bodyParts);

			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,
					),
				);

			case 'text':
				$bodyPart = array();
				if ($_structure->getDisposition() != 'attachment')
				{
					switch($_structure->getSubType())
					{
						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);

			case 'attachment':
			case 'message':
				switch($_structure->getSubType())
				{
					case 'rfc822':
						$newStructure = $_structure->getParts();
						if (self::$debug) {echo __METHOD__." Message -> RFC -> NewStructure:"; _debug_array($newStructure);}
						return self::normalizeBodyParts($this->getMessageBody($_uid, $_htmlOptions, $newStructure->getMimeId(), $newStructure, $_preserveSeen, $_folder));
				}
				break;

			default:
				if (self::$debug) _debug_array($_structure);
				return array(
					array(
						'body'		=> lang('The mimeparser can not parse this message.').$_structure->getType(),
						'mimeType'	=> 'text/plain',
						'charSet'	=> self::$displayCharset,
					)
				);
		}
	}

	/**
	 * normalizeBodyParts - function to gather and normalize all body Information
	 * @param _bodyParts - Body Array
	 * @return array - a normalized Bodyarray
	 */
	static function normalizeBodyParts($_bodyParts)
	{
		// RB: dont think this is still necessary
		return $_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;
	}

	/**
	 * getdisplayableBody - creates the bodypart of the email as textual representation
	 * @param object $mailClass the mailClass object to be used
	 * @param array $bodyParts  with the bodyparts
	 * @return string a preformatted string with the mails converted to text
	 */
	static function &getdisplayableBody(&$mailClass, $bodyParts, $preserveHTML = false)
	{
		for($i=0; $i'.$bodyParts[$i]['body']);
			$newBody  = translation::convert($bodyParts[$i]['body'], $bodyParts[$i]['charSet']);
			//error_log(__METHOD__.__LINE__.' MimeType:'.$bodyParts[$i]['mimeType'].'->'.$newBody);
			/*
			// in a way, this tests if we are having real utf-8 (the displayCharset) by now; we should if charsets reported (or detected) are correct
			if (strtoupper(self::$displayCharset) == 'UTF-8')
			{
				$test = json_encode($newBody);
				//error_log(__METHOD__.__LINE__.'#'.$test.'# ->'.strlen($newBody).' Error:'.json_last_error());
				if (json_last_error() != JSON_ERROR_NONE && strlen($newBody)>0)
				{
					// this should not be needed, unless something fails with charset detection/ wrong charset passed
					error_log(__METHOD__.__LINE__.' Charset Reported:'.$bodyParts[$i]['charSet'].' Carset Detected:'.translation::detect_encoding($bodyParts[$i]['body']));
					$newBody = utf8_encode($newBody);
				}
			}
			*/
			//error_log(__METHOD__.__LINE__.' before purify:'.$newBody);
			$mailClass->activeMimeType = 'text/plain';
			if ($bodyParts[$i]['mimeType'] == 'text/html') {
				$mailClass->activeMimeType = $bodyParts[$i]['mimeType'];
				// as translation::convert reduces \r\n to \n and purifier eats \n -> peplace it with a single space
				$newBody = str_replace("\n"," ",$newBody);
				// convert HTML to text, as we dont want HTML in infologs
				if (extension_loaded('tidy'))
				{
					$tidy = new tidy();
					$cleaned = $tidy->repairString($newBody, 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
					{
						$newBody = $cleaned;
					}
					if (!$preserveHTML)
					{
						// filter only the 'body', as we only want that part, if we throw away the html
						preg_match('`(]*>)(.+?)(.*?)`ims', $newBody, $matches);
						if ($matches[2])
						{
							$hasOther = true;
							$newBody = $matches[2];
						}
					}
				}
				else
				{
					// htmLawed filter only the 'body'
					preg_match('`(]*>)(.+?)(.*?)`ims', $newBody, $matches);
					if ($matches[2])
					{
						$hasOther = true;
						$newBody = $matches[2];
					}
					$htmLawed = new egw_htmLawed();
					// the next line should not be needed, but produces better results on HTML 2 Text conversion,
					// as we switched off HTMLaweds tidy functionality
					$newBody = str_replace(array('&','

',"
 
",'
 
'),array('&','
','
','
'),$newBody);
					$newBody = $htmLawed->egw_htmLawed($newBody);
					if ($hasOther && $preserveHTML) $newBody = $matches[1]. $newBody. $matches[3];
				}
				//error_log(__METHOD__.__LINE__.' after purify:'.$newBody);
				if ($preserveHTML==false) $newBody = translation::convertHTMLToText($newBody,self::$displayCharset,true,$stripalltags=true);
				//error_log(__METHOD__.__LINE__.' after convertHTMLToText:'.$newBody);
				if ($preserveHTML==false) $newBody = nl2br($newBody); // we need this, as htmLawed removes \r\n
				$mailClass->getCleanHTML($newBody,false,$preserveHTML); // remove stuff we regard as unwanted
				if ($preserveHTML==false) $newBody = str_replace("
","\r\n",$newBody);
				//error_log(__METHOD__.__LINE__.' after getClean:'.$newBody);
				$message .= $newBody;
				continue;
			}
			$newBody =self::htmlspecialchars($newBody);
			//error_log(__METHOD__.__LINE__.' Body(after specialchars):'.$newBody);
			$newBody = strip_tags($newBody); //we need to fix broken tags (or just stuff like "<800 USD/p" )
			//error_log(__METHOD__.__LINE__.' Body(after strip tags):'.$newBody);
			$newBody = htmlspecialchars_decode($newBody,ENT_QUOTES);
			//error_log(__METHOD__.__LINE__.' Body (after hmlspc_decode):'.$newBody);
			$message .= $newBody;
			//continue;
		}
		return $message;
	}

	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;
	}

	/**
	 * getMessageEnvelope
	 * get parsed headers from message
	 * @param string/int $_uid the messageuid,
	 * @param string/int $_partID='' , the partID, may be omitted
	 * @param boolean $decode flag to do the decoding on the fly
	 * @return array the message header
	 */
	function getMessageEnvelope($_uid, $_partID = '',$decode=false)
	{
		if($_partID == '') {
			$_folder = ($this->sessionData['mailbox']? $this->sessionData['mailbox'] : $this->icServer->getCurrentMailbox());
			$uidsToFetch = new Horde_Imap_Client_Ids();
			$uidsToFetch->add((array)$_uid);

			$fquery = new Horde_Imap_Client_Fetch_Query();
			$envFields = new Horde_Mime_Headers();
			$fquery->envelope();
			$headersNew = $this->icServer->fetch($_folder, $fquery, array(
				'ids' => $uidsToFetch,
			));
			if (is_object($headersNew)) {
				foreach($headersNew as $id=>$_headerObject) {
					$env = $_headerObject->getEnvelope();
					//_debug_array($envFields->singleFields());
					foreach ($envFields->singleFields() as $e => $v)
					{
						switch ($v)
						{
							case 'to':
							case 'from':
							case 'cc':
							case 'bcc':
							case 'sender':
								$envelope[$v]=$env->$v->addresses;
								break;
							case 'date':
								$envelope[$v]=egw_time::to($env->$v);
								break;
							default:
								$envelope[$v]=$env->$v;
						}
					}
				}
			}
			$envelope = array_change_key_case($envelope,CASE_UPPER);
			//if ($decode) _debug_array($envelope);
			//error_log(__METHOD__.__LINE__.array2string($envelope));
			return ($decode ? self::decode_header($envelope,true): $envelope);
		} else {
			$headers = $this->getMessageHeader($_uid, $_partID, true,true);
			//error_log(__METHOD__.__LINE__.array2string($headers));
			//_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],true);
					$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;
		}
	}

	/**
	 * getMessageHeader
	 * get parsed headers from message
	 * @param string/int $_uid the messageuid,
	 * @param string/int $_partID='' , the partID, may be omitted
	 * @param boolean $decode flag to do the decoding on the fly
	 * @param boolean $preserveUnSeen flag to preserve the seen flag where applicable
	 * @return array the message header
	 */
	function getMessageHeader($_uid, $_partID = '',$decode=false, $preserveUnSeen=false)
	{
		$_folder = ($this->sessionData['mailbox']? $this->sessionData['mailbox'] : $this->icServer->getCurrentMailbox());
		$uidsToFetch = new Horde_Imap_Client_Ids();
		$uidsToFetch->add((array)$_uid);

		$fquery = new Horde_Imap_Client_Fetch_Query();
		$fquery->headerText(array('peek'=>$preserveUnSeen));
		if ($_partID != '') $fquery->structure();
		$headersNew = $this->icServer->fetch($_folder, $fquery, array(
			'ids' => $uidsToFetch,
		));
		if (is_object($headersNew)) {
			foreach($headersNew as $id=>$_headerObject) {
				$retValue = $_headerObject->getHeaderText(0,Horde_Imap_Client_Data_Fetch::HEADER_PARSE)->toArray();
				if ($_partID != '')
				{
					$mailStructureObject = $_headerObject->getStructure();
					foreach ($mailStructureObject->contentTypeMap() as $mime_id => $mime_type)
					{
						if ($mime_id==$_partID)
						{
							$retValue = $_headerObject->getHeaderText($mime_id,Horde_Imap_Client_Data_Fetch::HEADER_PARSE)->toArray();
						}
					}
				}
			}
		}
		$retValue = array_change_key_case($retValue,CASE_UPPER);
		// if SUBJECT is an array, use thelast one, as we assume something with the unfolding for the subject did not work
		if (is_array($retValue['SUBJECT']))
		{
			$retValue['SUBJECT'] = $retValue['SUBJECT'][count($retValue['SUBJECT'])-1];
		}
		return ($decode ? self::decode_header($retValue,true):$retValue);
	}

	/**
	 * getMessageRawHeader
	 * get messages raw header data
	 * @param string/int $_uid the messageuid,
	 * @param string/int $_partID='' , the partID, may be omitted
	 * @return string the message header
	 */
	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)];
		}
		$uidsToFetch = new Horde_Imap_Client_Ids();
		$uidsToFetch->add((array)$_uid);

		$fquery = new Horde_Imap_Client_Fetch_Query();
		$fquery->headerText();
		if ($_partID != '') $fquery->structure();
		$headersNew = $this->icServer->fetch($_folder, $fquery, array(
			'ids' => $uidsToFetch,
		));
		if (is_object($headersNew)) {
			foreach($headersNew as $id=>$_headerObject) {
				$retValue = $_headerObject->getHeaderText();
				if ($_partID != '')
				{
					$mailStructureObject = $_headerObject->getStructure();
					foreach ($mailStructureObject->contentTypeMap() as $mime_id => $mime_type)
					{
						if ($mime_id==$_partID)
						{
							$retValue = $_headerObject->getHeaderText($mime_id);
						}
					}
				}
			}
		}
		$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;
	}

	/**
	 * 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'] = translation::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:'.translation::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
//			'@ in stylesheet are outdated, and ck-editor does not understand it, we remove it
		$css = str_replace(array(':',''),array(': ','',''),$css);
		//error_log(__METHOD__.__LINE__.$css);
		// TODO: we may have to strip urls and maybe comments and ifs
		return $css;
	}

	/**
	 * getMessageRawBody
	 * get the message raw body
	 * @param string/int $_uid the messageuid,
	 * @param string/int $_partID='' , the partID, may be omitted
	 * @return string the message body
	 */
	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)];
		}

		$uidsToFetch = new Horde_Imap_Client_Ids();
		$uidsToFetch->add((array)$_uid);

		$fquery = new Horde_Imap_Client_Fetch_Query();
		$fquery->fullText();
		if ($_partID != '')
		{
			$fquery->structure();
			$fquery->bodyPart($_partID);
		}
		$headersNew = $this->icServer->fetch($_folder, $fquery, array(
			'ids' => $uidsToFetch,
		));
		if (is_object($headersNew)) {
			foreach($headersNew as $id=>$_headerObject) {
				$body = $_headerObject->getFullMsg();
				if ($_partID != '')
				{
					$mailStructureObject = $_headerObject->getStructure();
					//_debug_array($mailStructureObject->contentTypeMap());
					foreach ($mailStructureObject->contentTypeMap() as $mime_id => $mime_type)
					{
						if ($mime_id==$_partID)
						{
							$body = $_headerObject->getBodyPart($mime_id);
						}
					}
				}
			}
		}

		$rawBody[$this->icServer->ImapServerId][$_folder][$_uid][($_partID==''?'NIL':$_partID)] = $body;
		return $body;
	}

	/**
	 * Get structure of a mail or part of a mail
	 *
	 * @param int $_uid
	 * @param string $_partID=null
	 * @param string $_folder=null
	 * @param boolean $_preserveSeen=false flag to preserve the seenflag by using body.peek
	 * @param Horde_Imap_Client_Fetch_Query $fquery=null default query just structure
	 * @return Horde_Mime_Part
	 */
	function getStructure($_uid, $_partID=null, $_folder=null, $_preserveSeen=false)
	{
		if (self::$debug) error_log( __METHOD__.__LINE__.":$_uid, $_partID");

		if (empty($_folder))
		{
			$_folder = ($this->sessionData['mailbox']? $this->sessionData['mailbox'] : $this->icServer->getCurrentMailbox());
		}
		$uidsToFetch = new Horde_Imap_Client_Ids();
		$uidsToFetch->add((array)$_uid);

		$_fquery = new Horde_Imap_Client_Fetch_Query();
// not sure why Klaus add these, seem not necessary
//		$fquery->envelope();
//		$fquery->size();
		$_fquery->structure();
		if ($_partID) $_fquery->bodyPart($_partID, array('peek' => $_preserveSeen));

		$mail = $this->icServer->fetch($_folder, $_fquery, array(
			'ids' => $uidsToFetch,
		))->first();

		return $mail->getStructure();
	}

	/**
	 * Parse the structure for attachments
	 *
	 * Returns not the attachments itself, but an array of information about the attachment
	 *
	 * @param int $_uid the messageuid,
	 * @param string $_partID=null , the partID, may be omitted
	 * @param Horde_Mime_Part $_structure=null if given use structure for parsing
	 * @param boolean $fetchEmbeddedImages=true,
	 * @param boolean $fetchTextCalendar=false,
	 * @param boolean $resolveTNEF=true
	 * @return array  an array of information about the attachment: array of array(name, size, mimeType, partID, encoding)
	 */
	function getMessageAttachments($_uid, $_partID=null, Horde_Mime_Part $_structure=null, $fetchEmbeddedImages=true, $fetchTextCalendar=false, $resolveTNEF=true)
	{
		if (self::$debug) error_log( __METHOD__.":$_uid, $_partID");

		if (!isset($_structure))
		{
			$_structure = $this->getStructure($_uid, $_partID);
		}

		foreach($_structure->contentTypeMap() as $mime_id => $mime_type)
		{
			$part = $_structure->getPart($mime_id);

			if ($part->getDisposition() == 'attachment' ||
				$fetchEmbeddedImages && $part->getDisposition() == 'inline' &&
					$part->getPrimaryType() == 'image')
			{
				$attachment = $part->getAllDispositionParameters();
				$attachment['mimeType'] = $mime_type;
				$attachment['uid'] = $_uid;
				$attachment['partID'] = $mime_id;
				if (!isset($attachment['name'])) $attachment['name'] = $part->getName();
				$attachment['size'] = $part->getBytes();
				if (($cid = $part->getContentId())) $attachment['cid'] = $cid;

				$attachments[] = $attachment;
			}
		}
		return $attachments;
	}

	/**
	 * getFileNameFromStructure
	 * parse the structure for the filename of an attachment
	 * @param array $_structure='', structure used for parsing
	 * @param string/int $_uid the messageuid,
	 * @param string/int $_partID='', the partID, may be omitted
	 * @return string a string representing the filename of an attachment
	 */
	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->getMessageHeader($_uid, $partID, true)));
		if(isset($structure->parameters['NAME'])) {
			//error_log(__METHOD__.__LINE__.array2string(substr($structure->parameters['NAME'],0,strlen('data:'))));
			if (!is_array($structure->parameters['NAME']) && substr($structure->parameters['NAME'],0,strlen('data:'))==='data:') {
				$namecounter++;
				$ext = mime_magic::mime2ext($structure->Type.'/'.$structure->subType);
				return lang("unknown").$namecounter.($ext?$ext:($structure->subType ? ".".$structure->subType : ""));
			}
			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->getMessageHeader($_uid, $partID, true, 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++;
			$ext = mime_magic::mime2ext($structure->Type.'/'.$structure->subType);
			return lang("unknown").$namecounter.($ext?$ext:($structure->subType ? ".".$structure->subType : ""));
		}
	}

	/**
	 * getMethodFromStructure
	 * parse the structure for the METHOD of an ics event (attachment)
	 * @param array $_structure='', structure used for parsing
	 * @param string/int $_uid the messageuid,
	 * @param string/int $_partID='', the partID, may be omitted
	 * @return string a string representing the filename of an attachment
	 */
	function getMethodFromStructure(&$structure, $_uid = false, $partID = false)
	{
		//if ( $_uid && $partID) error_log(__METHOD__.__LINE__.array2string($structure).' Uid:'.$_uid.' PartID:'.$partID.' -> '.array2string($this->icServer->getParsedHeaders($_uid, true, $partID, true)));
		if(isset($subPart->parameters['METHOD'])) {
			return $subPart->parameters['METHOD'];
		}
		else
		{
			if ( $_uid && $partID && $structure->type=='TEXT' && $structure->subType=='CALENDAR' &&  $structure->filename=='NIL')
			{
				$attachment = $this->getAttachment($_uid, $partID);
				if ($attachment['attachment'])
				{
					if (!PEAR::isError($attachment['attachment']))
					{
						// simple parsing of the attachment for a usable method
						//error_log( __METHOD__.__LINE__.array2string($attachment['attachment']));
						foreach(explode("\r\n",$attachment['attachment']) as $k => $v)
						{
							if (strpos($v,':') !== false)
							{
								list($first,$rest) = explode(':',$v,2);
								$first = trim($first);
								if ($first=='METHOD')
								{
									return trim($rest);
								}
							}
						}
					}
				}
			}
		}
	}

	/**
	 * 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.
	 * @param boolean _returnPart flag to indicate if the attachment is to be returned as horde mime part object
	 * @param boolean _stream flag to indicate if the attachment is to be fetched or returned as filepointer
	 *
	 * @return array
	 */
	function getAttachment($_uid, $_partID, $_winmail_nr=0, $_returnPart=true, $_stream=false)
	{
		$_folder = ($this->sessionData['mailbox']? $this->sessionData['mailbox'] : $this->icServer->getCurrentMailbox());

		$uidsToFetch = new Horde_Imap_Client_Ids();
		$uidsToFetch->add((array)$_uid);

		$fquery = new Horde_Imap_Client_Fetch_Query();
		$fquery->structure();
		$fquery->bodyPart($_partID);
		$headersNew = $this->icServer->fetch($_folder, $fquery, array(
			'ids' => $uidsToFetch,
		));
		if (is_object($headersNew)) {
			foreach($headersNew as $id=>$_headerObject) {
				$body = $_headerObject->getFullMsg();
				if ($_partID != '')
				{
					$mailStructureObject = $_headerObject->getStructure();
					$mailStructureObject->contentTypeMap();
					$part = $mailStructureObject->getPart($_partID);
					if ($part->getDisposition()=='attachment')
					{
						$headerObject['ATTACHMENTS'][$mime_id]=$part->getAllDispositionParameters();
						
						$structure_bytes = $part->getBytes();
						$structure_mime=$mime_type;
						$structure_partID=$mime_id;
						$filename=$part->getName();
						$this->fetchPartContents($_uid, $part, $_stream, $_preserveSeen=false);
						if ($_returnPart) return $part;
					}
				}
			}
		}
		$ext = mime_magic::mime2ext($structure->type .'/'. $structure->subType);
		if ($ext && stripos($filename,'.')===false && stripos($filename,$ext)===false) $filename = trim($filename).'.'.$ext;
		$attachmentData = array(
			'type'		=> $structure_mime,
			'filename'	=> $filename,
			'attachment'	=> $part->getContents(array('stream'=>$_stream))
			);
/*
		// 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 ) ) )
		{
			$ext = mime_magic::mime2ext($wmattach['type']);
			if ($ext && stripos($wmattach['name'],'.')===false && stripos($wmattach['name'],$ext)===false) $wmattach['name'] = trim($wmattach['name']).'.'.$ext;
			$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
	 * @param boolean $_stream=null null do NOT fetch content, use fetchPartContents later
	 *	true:
	 * @return Horde_Mime_Part
	 */
	function getAttachmentByCID($_uid, $_cid, $_part, $_stream=null)
	{
		// some static variables to avoid fetching the same mail multiple times
		static $uid=null, $part=null, $structure=null;
		//error_log(__METHOD__.__LINE__.":$_uid, $_cid, $_part");

		if(empty($_cid)) return false;

		if ($_uid != $uid || $_part != $part)
		{
			$structure = $this->getStructure($uid=$_uid, $part=$_part);
		}
		/** @var Horde_Mime_Part */
		$attachment = null;
		foreach($structure->contentTypeMap() as $mime_id => $mime_type)
		{
			$part = $structure->getPart($mime_id);

			if ($part->getPrimaryType() == 'image' &&
				(($cid = $part->getContentId()) &&
				// RB: seem a bit fague to search for inclusion in both ways
				(strpos($cid, $_cid) !== false || strpos($_cid, $cid) !== false)) ||
				(($name = $part->getName()) &&
				(strpos($name, $_cid) !== false || strpos($_cid, $name) !== false)))
			{
				// if we have a direct match, dont search any further
				if ($cid == $_cid)
				{
					$attachment = $part;
					break;
				}
				// everything else we only consider after we checked all
				if (!isset($attachment)) $attachment = $part;
			}
		}
		// do we want content fetched, can be done later, if not needed
		if (isset($_stream))
		{
			$this->fetchPartContents($_uid, $attachment, $_stream);
		}
		// set name as filename, if not set
		if (!$attachment->getDispositionParameter('filename'))
		{
			$attachment->setDispositionParameter('filename', $attachment->getName());
		}
		// guess type, if not set
		if ($attachment->getType() == 'application/octet-stream')
		{
			$attachment->setType(mime_magic::filename2mime($attachment->getDispositionParameter('filename')));
		}
		//error_log(__METHOD__."($_uid, '$_cid', '$_part') returning ".array2string($attachment));
		return $attachment;
	}

	/**
	 * Fetch and add contents to a part
	 *
	 * To get contents you use $part->getContents();
	 *
	 * @param int $_uid
	 * @param Horde_Mime_Part $part
	 * @param boolean $_stream=false true return a stream, false a string
	 * @param boolean $_preserveSeen flag to preserve the seenflag by using body.peek
	 * @return Horde_Mime_Part
	 */
	public function fetchPartContents($_uid, Horde_Mime_Part $part, $_stream=false, $_preserveSeen=false)
	{
		$encoding = null;
		// we need to set content on structure to decode transfer encoding
		$part->setContents(
			$this->getBodyPart($_uid, $part->getMimeId(), null, $_preserveSeen, $_stream, $encoding),
			array('encoding' => $encoding));

		return $part;
	}

	/**
	 * save a message in folder
	 *	throws exception on failure
	 * @todo set flags again
	 *
	 * @param string _folderName the foldername
	 * @param string _header the header of the message
	 * @param string _body the body of the message
	 * @param string _flags the imap flags to set for the saved message
	 *
	 * @return the id of the message appended or exception
	 */
	function appendMessage($_folderName, $_header, $_body, $_flags)
	{
		//error_log(__METHOD__.__LINE__."$_folderName, $_header, $_body, $_flags");
		$header = ltrim(str_replace("\n","\r\n",$_header));
		$body   = str_replace("\n","\r\n",$_body);
		if (!is_array($_flags) && stripos($_flags,',')!==false) $_flags=explode(',',$_flags);
		if (!is_array($_flags)) $_flags = (array) $_flags;
		try
		{
			$dataNflags = array();
			$dataNflags[] = array('data'=>array(array('t'=>'text','v'=>"$header"."$body")), 'flags'=>array($_flags));
			$messageid = $this->icServer->append($_folderName,$dataNflags);
		}
		catch (Exception $e)
		{
			if (self::$debug) error_log("Could not append Message:".$e->getMessage());
			throw new egw_exception_wrong_userinput(lang("Could not append Message:".$e->getMessage));
			//return false;
		}
		//error_log(__METHOD__.__LINE__.' appended UID:'.$messageid);
		//$messageid = true; // for debug reasons only
		if ($messageid === true) // try to figure out the message uid
		{
			$list = $this->getHeaders($_folderName, $_startMessage=1, $_numberOfMessages=1, $_sort='INTERNALDATE', $_reverse=true, $_filter=array(),$_thisUIDOnly=null, $_cacheResult=false);
			if ($list)
			{
				if (self::$debug) error_log(__METHOD__.__LINE__.' MessageUid:'.$messageid.' but found:'.array2string($list));
				$messageid = $list['header'][0]['uid'];
			}
		}
		return $messageid;
	}

	/**
	 * 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 mailClass the mailClassobject 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
	 * @param addHeaderSection flag to be able to supress headersection
	 * @return array/bool with 'mailaddress'=>$mailaddress,
	 *				'subject'=>$subject,
	 *				'message'=>$message,
	 *				'attachments'=>$attachments,
	 *				'headers'=>$headers,; boolean false on failure
	 */
	static function get_mailcontent(&$mailClass,$uid,$partid='',$mailbox='', $preserveHTML = false, $addHeaderSection=true)
	{
			//echo __METHOD__." called for $uid,$partid 
";
			$headers = $mailClass->getMessageHeader($uid,$partid,true);
			if (empty($headers)) return false;
			// dont force retrieval of the textpart, let mailClass preferences decide
			$bodyParts = $mailClass->getMessageBody($uid,($preserveHTML?'always_display':'only_if_no_text'),$partid);
			// if we do not want HTML but there is no TextRepresentation with the message itself, try converting
			if ( !$preserveHTML && $bodyParts[0]['mimeType']=='text/html')
			{
				foreach($bodyParts as $i => $part)
				{
					if ($bodyParts[$i]['mimeType']=='text/html')
					{
						$bodyParts[$i]['body'] = translation::convertHTMLToText($bodyParts[$i]['body'],$bodyParts[$i]['charSet'],true,$stripalltags=true);
						$bodyParts[$i]['mimeType']='text/plain';
					}
				}
			}
			//error_log(array2string($bodyParts));
			$attachments = $mailClass->getMessageAttachments($uid,$partid);

			if ($mailClass->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($mailClass, $bodyParts, $preserveHTML);
			if ($preserveHTML && $mailClass->activeMimeType == 'text/plain') $message = '
'.$message.'
';
			$headdata = ($addHeaderSection ? 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($mailClass->getMessageHeader($uid, $attachment['partID']));
						//_debug_array($mailClass->getMessageBody($uid,'', $attachment['partID']));
						//_debug_array($mailClass->getMessageAttachments($uid, $attachment['partID']));
						$mailcontent = self::get_mailcontent($mailClass,$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],$mailClass->getAttachment($uid, $attachment['partID'],0,false,false));
						if (isset($attachments[$num]['charset'])) {
							if ($attachments[$num]['charset']===false) $attachments[$num]['charset'] = translation::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, if SUPPRESS, supress headline and footerline
	 * @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;
		//error_log(__METHOD__.__LINE__.array2string($header).function_backtrace());
		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) && $headline != 'SUPPRESS') $headdata = "---------------------------- $headline ----------------------------".($createHTML?"
":"\n").$headdata;
			if (empty($headline)) $headdata = ($headline != 'SUPPRESS'?"--------------------------------------------------------".($createHTML?"
":"\n"):'').$headdata;
			$headdata .= ($headline != 'SUPPRESS'?"--------------------------------------------------------".($createHTML?"
":"\n"):'');
		}
		else
		{
			$headdata = ($headline != 'SUPPRESS'?"--------------------------------------------------------".($createHTML?"
":"\n"):'');
		}
		return $headdata;
	}

	/**
	 * adaptSubjectForImport - strips subject from unwanted Characters, and does some normalization
	 * to meet expectations
	 * @param string $subject string to process
	 * @return string
	 */
	static function adaptSubjectForImport($subject)
	{
		$subject = str_replace('$$','__',($subject?$subject:lang('(no subject)')));
		$subject = str_ireplace(array('[FWD]','[',']','{','}','<','>'),array('Fwd:',' ',' ',' ',' ',' ',' '),trim($subject));
		return $subject;
	}

	/**
	 * convertAddressArrayToString - converts an mail envelope Address Array To String
	 * @param array $rfcAddressArray  an addressarray as provided by mail 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, self::$idna2->decode($addressObject->host), $addressObject->personal);
				$buff = str_replace(array('<','>'),array('[',']'),$buff);
				if ($createHTML) $buff = mail_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 = self::decode_header($rfcAddressArray,true);
			$rfcAddressArray = str_replace(array('<','>'),array('[',']'),$rfcAddressArray);
			if (is_string($rfcAddressArray)) return ($createHTML ? mail_bo::htmlspecialchars($rfcAddressArray) : $rfcAddressArray);
		}
		return $returnAddr;
	}

	/**
	 * 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;
	}

	/**
	 * Returns a string showing the size of the message/attachment
	 *
	 * @param integer $bytes
	 * @return string formatted string
	 */
	static function show_readable_size($bytes)
	{
		$bytes /= 1024;
		$type = 'k';

		if ($bytes / 1024 > 1)
		{
			$bytes /= 1024;
			$type = 'M';

			if ($bytes / 1024 > 1)
			{
				$bytes *= 10;
				settype($bytes, 'integer');
				$bytes /= 10;
				$bytes /= 1024;
				$type = 'G';
			}

		}

		if ($bytes < 10)
		{
			$bytes *= 10;
			settype($bytes, 'integer');
			$bytes /= 10;
		}
		else
			settype($bytes, 'integer');

		return $bytes . ' ' . $type ;
	}

	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);
	}

	/**
	 * 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;
		}
	}

	/**
	 * processURL2InlineImages - parses a html text for images, and adds them as inline attachment
	 * we do not use the functionality of the phpmailer here, as phpmailers functionality requires
	 * files to be present within the filesystem, which we do not require as we make this happen
	 * (we load the file, and store it temporarily for the use of attaching it to the file send
	 * @param object $_mailObject instance of the egw_mailer/phpmailer Object to be used
	 * @param string $_html2parse the html to parse and to be altered, if conditions meet
	 * @return void
	 */
	static function processURL2InlineImages(&$_mailObject, &$_html2parse)
	{
		$imageC = 0;
		preg_match_all("/(src|background)=\"(.*)\"/Ui", $_html2parse, $images);
		if(isset($images[2])) {
			foreach($images[2] as $i => $url) {
				//$isData = false;
				$basedir = '';
				$needTempFile = true;
				//error_log(__METHOD__.__LINE__.$url);
				//error_log(__METHOD__.__LINE__.$GLOBALS['egw_info']['server']['webserver_url']);
				//error_log(__METHOD__.__LINE__.array2string($GLOBALS['egw_info']['user']));
				// do not change urls for absolute images (thanks to corvuscorax)
				if (!(substr($url,0,strlen('data:'))=='data:')) {
					//error_log(__METHOD__.__LINE__.' -> '.$i.': '.array2string($images[$i]));
					$filename = basename($url);
					$directory = dirname($url);
					($directory == '.')?$directory='':'';
					$cid = 'cid:' . md5($filename);
					$ext = pathinfo($filename, PATHINFO_EXTENSION);
					$mimeType  = $_mailObject->_mime_types($ext);
					if ( strlen($directory) > 1 && substr($directory,-1) != '/') { $directory .= '/'; }
					$myUrl = $directory.$filename;
					if ($myUrl[0]=='/') // local path -> we only allow path's that are available via http/https (or vfs)
					{
						$basedir = ($_SERVER['HTTPS']?'https://':'http://'.$_SERVER['HTTP_HOST']);
					}
					// use vfs instead of url containing webdav.php
					// ToDo: we should test if the webdav url is of our own scope, as we cannot handle foreign
					// webdav.php urls as vfs
					if (strpos($myUrl,'webdav.php') !== false) // we have a webdav link, so we build a vfs/sqlfs link of it.
					{
						egw_vfs::load_wrapper('vfs');
						list($garbage,$vfspart) = explode('webdav.php',$myUrl,2);
						$myUrl = $vfspart;
						$basedir = 'vfs://default';
						$needTempFile = false;
					}
					if ( strlen($basedir) > 1 && substr($basedir,-1) != '/' && $myUrl[0]!='/') { $basedir .= '/'; }
					//error_log(__METHOD__.__LINE__.$basedir.$myUrl);
					if ($needTempFile) $data = file_get_contents($basedir.urldecode($myUrl));
				}
				if (substr($url,0,strlen('data:'))=='data:')
				{
					//error_log(__METHOD__.__LINE__.' -> '.$i.': '.array2string($images[$i]));
					// we only support base64 encoded data
					$tmp = substr($url,strlen('data:'));
					list($mimeType,$data) = explode(';base64,',$tmp);
					list($what,$exactly) = explode('/',$mimeType);
					$needTempFile = true;
					$filename = ($what?$what:'data').$imageC++.'.'.$exactly;
					$cid = 'cid:' . md5($filename);
					$data = base64_decode($data);
					//$isData = true;
				}
				if ($data || $needTempFile === false)
				{
					if ($needTempFile)
					{
						$attachment_file =tempnam($GLOBALS['egw_info']['server']['temp_dir'],$GLOBALS['egw_info']['flags']['currentapp']."_");
						$tmpfile = fopen($attachment_file,'w');
						fwrite($tmpfile,$data);
						fclose($tmpfile);
					}
					else
					{
						$attachment_file = $basedir.urldecode($myUrl);
					}
					//error_log(__METHOD__.__LINE__.' '.$url.' -> '.$basedir.$myUrl. ' TmpFile:'.$tmpfile);
					//error_log(__METHOD__.__LINE__.' '.$url.' -> '.$mimeType. ' TmpFile:'.$attachment_file);
					if ( $_mailObject->AddEmbeddedImage($attachment_file, md5($filename), $filename, 'base64',$mimeType) )
					{
						//$_html2parse = preg_replace("/".$images[1][$i]."=\"".preg_quote($url, '/')."\"/Ui", $images[1][$i]."=\"".$cid."\"", $_html2parse);
						$_html2parse = str_replace($images[1][$i]."=\"".$url."\"", $images[1][$i]."=\"".$cid."\"", $_html2parse);
					}
				}
			}
		}
	}

	/**
	 * importMessageToMergeAndSend
	 *
	 * @param object &bo_merge bo_merge object
	 * @param string $document the full filename
	 * @param array $SendAndMergeTocontacts array of contact ids
	 * @param string $_folder (passed by reference) will set the folder used. must be set with a folder, but will hold modifications if
	 *					folder is modified
	 * @param string $importID ID for the imported message, used by attachments to identify them unambiguously
	 * @return mixed array of messages with success and failed messages or exception
	 */
	function importMessageToMergeAndSend(bo_merge $bo_merge, $document, $SendAndMergeTocontacts, &$_folder, $importID='')
	{
		$importfailed = false;
		$processStats = array('success'=>array(),'failed'=>array());
		if (empty($SendAndMergeTocontacts))
		{
			$importfailed = true;
			$alert_msg .= lang("Import of message %1 failed. No Contacts to merge and send to specified.",$_formData['name']);
		}

		// check if formdata meets basic restrictions (in tmp dir, or vfs, mimetype, etc.)
		/* as the file is provided by bo_merge, we do not check
		try
		{
			$tmpFileName = mail_bo::checkFileBasics($_formData,$importID);
		}
		catch (egw_exception_wrong_userinput $e)
		{
			$importfailed = true;
			$alert_msg .= $e->getMessage();
		}
		*/
		$tmpFileName = $document;
		// -----------------------------------------------------------------------
		if ($importfailed === false)
		{
			$mailObject = new egw_mailer();
			try
			{
				$this->parseFileIntoMailObject($mailObject,$tmpFileName,$Header,$Body);
			}
			catch (egw_exception_assertion_failed $e)
			{
				$importfailed = true;
				$alert_msg .= $e->getMessage();
			}

			//_debug_array($Body);
			$this->openConnection();
			if (empty($_folder))
			{
				$_folder = $this->getSentFolder();
			}
			$delimiter = $this->getHierarchyDelimiter();
			if($_folder=='INBOX'.$delimiter) $_folder='INBOX';
			if ($importfailed === false)
			{
				$Subject = $mailObject->Subject;
				//error_log(__METHOD__.__LINE__.' Subject:'.$Subject);
				$Body = $mailObject->Body;
				//error_log(__METHOD__.__LINE__.' Body:'.$Body);
				//error_log(__METHOD__.__LINE__.' BodyContentType:'.$mailObject->BodyContentType);
				$AltBody = $mailObject->AltBody;
				//error_log(__METHOD__.__LINE__.' AltBody:'.$AltBody);
				//error_log(__METHOD__.__LINE__.array2string($mailObject->GetReplyTo()));
				// Fetch ReplyTo - Address if existing to check if we are to replace it
				$replyTo = $mailObject->GetReplyTo();
				if (isset($replyTo['replace@import.action']))
				{
					$mailObject->ClearReplyTos();
					$activeMailProfile = $this->mailPreferences->getIdentity($this->profileID, true);
					$mailObject->AddReplyTo(self::$idna2->encode($activeMailProfile->emailAddress),$activeMailProfile->realName);
				}
				foreach ($SendAndMergeTocontacts as $k => $val)
				{
					$mailObject->ErrorInfo = $errorInfo = '';
					//$mailObject->SMTPDebug = 5;
					$mailObject->set('error_count',0);
					$sendOK = $openComposeWindow = $openAsDraft = null;
					//error_log(__METHOD__.__LINE__.' Id To Merge:'.$val);
					if ($GLOBALS['egw_info']['flags']['currentapp'] == 'addressbook' &&
						count($SendAndMergeTocontacts) > 1 &&
						is_numeric($val) || $GLOBALS['egw']->accounts->name2id($val)) // do the merge
					{

						//error_log(__METHOD__.__LINE__.array2string($mailObject));
						$contact = $bo_merge->contacts->read($val);
						//error_log(__METHOD__.__LINE__.' ID:'.$val.' Data:'.array2string($contact));
						$email = ($contact['email'] ? $contact['email'] : $contact['email_home']);
						$nfn = ($contact['n_fn'] ? $contact['n_fn'] : $contact['n_given'].' '.$contact['n_family']);
						$activeMailProfile = $this->mailPreferences->getIdentity($this->profileID, true);
						//error_log(__METHOD__.__LINE__.array2string($activeMailProfile));
						$mailObject->From = $activeMailProfile->emailAddress;
						//$mailObject->From  = $_identity->emailAddress;
						$mailObject->FromName = $mailObject->EncodeHeader(self::generateIdentityString($activeMailProfile,false));

						$mailObject->MessageID = '';
						$mailObject->ClearAllRecipients();
						$mailObject->ClearCustomHeaders();
						$mailObject->AddAddress(self::$idna2->encode($email),$mailObject->EncodeHeader($nfn));
						$mailObject->Subject = $bo_merge->merge_string($Subject, $val, $e, 'text/plain', array(), self::$displayCharset);
						if (!empty($AltBody))
						{
							$mailObject->IsHTML(true);
						}
						elseif (empty($AltBody) && $mailObject->BodyContentType=='text/html')
						{
							$mailObject->IsHTML(true);
							$AltBody = translation::convertHTMLToText($Body,self::$displayCharset,false,$stripalltags=true);
						}
						else
						{
							$mailObject->IsHTML(false);
						}
						//error_log(__METHOD__.__LINE__.' ContentType:'.$mailObject->BodyContentType);
						if (!empty($Body)) $mailObject->Body = $bo_merge->merge_string($Body, $val, $e, $mailObject->BodyContentType, array(), self::$displayCharset);
						//error_log(__METHOD__.__LINE__.' Result:'.$mailObject->Body.' error:'.array2string($e));
						if (!empty($AltBody)) $mailObject->AltBody = $bo_merge->merge_string($AltBody, $val, $e, $mailObject->AltBodyContentType, array(), self::$displayCharset);

						$ogServer = $this->mailPreferences->getOutgoingServer($this->profileID);
						#_debug_array($ogServer);
						$mailObject->Host     = $ogServer->host;
						$mailObject->Port = $ogServer->port;
						// SMTP Auth??
						if($ogServer->smtpAuth) {
							$mailObject->SMTPAuth = true;
							// check if username contains a ; -> then a sender is specified (and probably needed)
							list($username,$senderadress) = explode(';', $ogServer->username,2);
							if (isset($senderadress) && !empty($senderadress)) $mailObject->Sender = $senderadress;
							$mailObject->Username = $username;
							$mailObject->Password = $ogServer->password;
						}
						//error_log(__METHOD__.__LINE__.array2string($mailObject));
						// set a higher timeout for big messages
						@set_time_limit(120);
						$sendOK = true;
						try {
							$mailObject->Send();
						}
						catch(phpmailerException $e) {
							$sendOK = false;
							$errorInfo = $e->getMessage();
							if ($mailObject->ErrorInfo) // use the complete mailer ErrorInfo, for full Information
							{
								if (stripos($mailObject->ErrorInfo, $errorInfo)===false)
								{
									$errorInfo = 'Send Failed for '.$mailObject->Subject.' to '.$nfn.'<'.$email.'> Error:'.$mailObject->ErrorInfo.'
'.$errorInfo;
								}
								else
								{
									$errorInfo = $mailObject->ErrorInfo;
								}
							}
							//error_log(__METHOD__.__LINE__.array2string($errorInfo));
						}
					}
					elseif (!$k)	// 1. entry, further entries will fail for apps other then addressbook
					{
						$openAsDraft = true;
						$mailObject->MessageID = '';
						$mailObject->ClearAllRecipients();
						$mailObject->ClearCustomHeaders();
						if ($GLOBALS['egw_info']['flags']['currentapp'] == 'addressbook' &&
							is_numeric($val) || $GLOBALS['egw']->accounts->name2id($val)) // do the merge
						{
							$contact = $bo_merge->contacts->read($val);
							//error_log(__METHOD__.__LINE__.array2string($contact));
							$email = ($contact['email'] ? $contact['email'] : $contact['email_home']);
							$nfn = ($contact['n_fn'] ? $contact['n_fn'] : $contact['n_given'].' '.$contact['n_family']);
							$mailObject->AddAddress(self::$idna2->encode($email),$mailObject->EncodeHeader($nfn));
						}
						$mailObject->Subject = $bo_merge->merge_string($Subject, $val, $e, 'text/plain', array(), self::$displayCharset);
						if (!empty($AltBody))
						{
							$mailObject->IsHTML(true);
						}
						elseif (empty($AltBody) && $mailObject->BodyContentType=='text/html')
						{
							$mailObject->IsHTML(true);
							$AltBody = translation::convertHTMLToText($Body,self::$displayCharset,false,$stripalltags=true);
						}
						else
						{
							$mailObject->IsHTML(false);
						}
						//error_log(__METHOD__.__LINE__.' ContentType:'.$mailObject->BodyContentType);
						if (!empty($Body)) $mailObject->Body = $bo_merge->merge_string($Body, $val, $e, $mailObject->BodyContentType, array(), self::$displayCharset);
						//error_log(__METHOD__.__LINE__.' Result:'.$mailObject->Body.' error:'.array2string($e));
						if (!empty($AltBody)) $mailObject->AltBody = $bo_merge->merge_string($AltBody, $val, $e, $mailObject->AltBodyContentType, array(), self::$displayCharset);
						$_folder = $this->getDraftFolder();
					}
					if ($sendOK || $openAsDraft)
					{
						$BCCmail = '';
						if ($this->folderExists($_folder,true))
						{
						    if($this->isSentFolder($_folder))
							{
						        $flags = '\\Seen';
						    } elseif($this->isDraftFolder($_folder)) {
						        $flags = '\\Draft';
						    } else {
						        $flags = '';
						    }
							unset($mailObject->sentHeader);
							unset($mailObject->sentBody);
							$savefailed = false;
							try
							{
								$messageUid =$this->appendMessage($_folder,
									$BCCmail.$mailObject->getMessageHeader(),
									$mailObject->getMessageBody(),
									$flags);
							}
							catch (egw_exception_wrong_userinput $e)
							{
								$savefailed = true;
								$alert_msg .= lang("Save of message %1 failed. Could not save message to folder %2 due to: %3",$Subject,$_folder,$e->getMessage());
							}
							// no send, save successful, and message_uid present
							if ($savefailed===false && $messageUid && is_null($sendOK))
							{
								$openComposeWindow = true;
								list($fm_width,$fm_height) = explode('x',egw_link::get_registry('felamimail','view_popup'));
								$linkData = array
								(
									'menuaction'    => 'felamimail.uicompose.composeFromDraft',
									'uid'		=> $messageUid,
									'folder'    => base64_encode($_folder),
									'icServer'	=> $this->profileID,
									'method'	=> 'importMessageToMergeAndSend',
								);
								$composeUrl = egw::link('/index.php',$linkData);
								//error_log(__METHOD__.__LINE__.' ComposeURL:'.$composeUrl);
								$GLOBALS['egw_info']['flags']['java_script_thirst'] .= '";
								$processStats['success'][] = lang("Saving of message %1 succeeded. Check Folder %2.",$Subject,$_folder);
							}
						}
						else
						{
							$savefailed = true;
							$alert_msg .= lang("Saving of message %1 failed. Destination Folder %2 does not exist.",$Subject,$_folder);
						}
						if ($sendOK)
						{
							$processStats['success'][$val] = 'Send succeeded to '.$nfn.'<'.$email.'>'.($savefailed?' but failed to store to Folder:'.$_folder:'');
						}
						else
						{
							if (!$openComposeWindow) $processStats['failed'][$val] = $errorInfo?$errorInfo:'Send failed to '.$nfn.'<'.$email.'> See error_log for details';
						}
					}
					if (!is_null($sendOK) && $sendOK===false && is_null($openComposeWindow))
					{
						$processStats['failed'][$val] = $errorInfo?$errorInfo:'Send failed to '.$nfn.'<'.$email.'> See error_log for details';
					}
				}
			}
			unset($mailObject);
		}
		// set the url to open when refreshing
		if ($importfailed == true)
		{
			throw new egw_exception_wrong_userinput($alert_msg);
		}
		else
		{
			//error_log(__METHOD__.__LINE__.array2string($processStats));
			return $processStats;
		}
	}

	/**
	 * functions to allow the parsing of message/rfc files
	 * used in felamimail to import mails, or parsev a message from file enrich it with addressdata (merge) and send it right away.
	 */

	/**
	 * parseFileIntoMailObject - parses a message/rfc mail from file to the mailobject and returns the header and body via reference
	 *   throws egw_exception_assertion_failed when the required Pear Class is not found/loadable
	 * @param object $mailObject instance of the SMTP Mailer Object
	 * @param string $tmpFileName string that points/leads to the file to be imported
	 * @param string &$Header  reference used to return the imported Mailheader
	 * @param string &$Body reference to return the imported Body
	 * @return void Mailheader and body is returned via Reference in $Header $Body
	 */
	function parseFileIntoMailObject($mailObject,$tmpFileName,&$Header,&$Body)
	{
			$message = file_get_contents($tmpFileName);
			try
			{
				return $this->parseRawMessageIntoMailObject($mailObject,$message,$Header,$Body);
			}
			catch (egw_exception_assertion_failed $e)
			{	// not sure that this is needed to pass on exeptions
				throw new egw_exception_assertion_failed($e->getMessage());
			}
	}

	/**
	 * parseRawMessageIntoMailObject - parses a message/rfc mail from file to the mailobject and returns the header and body via reference
	 *   throws egw_exception_assertion_failed when the required Pear Class is not found/loadable
	 * @param object $mailObject instance of the SMTP Mailer Object
	 * @param string $message string containing the RawMessage
	 * @param string &$Header  reference used to return the imported Mailheader
	 * @param string &$Body reference to return the imported Body
	 * @return void Mailheader and body is returned via Reference in $Header $Body
	 */
	function parseRawMessageIntoMailObject($mailObject,$message,&$Header,&$Body)
	{
			/**
			 * pear/Mail_mimeDecode requires package "pear/Mail_Mime" (version >= 1.4.0, excluded versions: 1.4.0)
			 * ./pear upgrade Mail_Mime
			 * ./pear install Mail_mimeDecode
			 */
			//echo '
'.$message.'
';
			//error_log(__METHOD__.__LINE__.$message);
			if (class_exists('Mail_mimeDecode',false)==false && (@include_once 'Mail/mimeDecode.php') === false) throw new egw_exception_assertion_failed(lang('Required PEAR class Mail/mimeDecode.php not found.'));
			$mailDecode = new Mail_mimeDecode($message);
			$structure = $mailDecode->decode(array('include_bodies'=>true,'decode_bodies'=>true,'decode_headers'=>true));
			//error_log(__METHOD__.__LINE__.array2string($structure));
			//_debug_array($structure);
			//exit;
			// now create a message to view, save it in Drafts and open it
			$mailObject->PluginDir = EGW_SERVER_ROOT."/phpgwapi/inc/";
			$mailObject->IsSMTP();
			$mailObject->CharSet = self::$displayCharset; // some default, may be altered by BodyImport
			if (isset($structure->ctype_parameters['charset'])) $mailObject->CharSet = trim($structure->ctype_parameters['charset']);
			$mailObject->Encoding = 'quoted-printable'; // some default, may be altered by BodyImport
/*
			$mailObject->AddAddress($emailAddress, $addressObject->personal);
			$mailObject->AddCC($emailAddress, $addressObject->personal);
			$mailObject->AddBCC($emailAddress, $addressObject->personal);
			$mailObject->AddReplyto($emailAddress, $addressObject->personal);
*/
			$result ='';
			$contenttypecalendar = '';
			$myReplyTo = '';
			foreach((array)$structure->headers as $key => $val)
			{
				//error_log(__METHOD__.__LINE__.$key.'->'.$val);
				foreach((array)$val as $i => $v)
				{
					if ($key!='content-type' && $key !='content-transfer-encoding' &&
						$key != 'message-id'  &&
						$key != 'subject' &&
						$key != 'from' &&
						$key != 'to' &&
						$key != 'cc' &&
						$key != 'bcc' &&
						$key != 'reply-to' &&
						$key != 'x-priority') // the omitted values to that will be set at the end
					{
						$Header .= $mailObject->HeaderLine($key, trim($v));
					}
				}
				switch ($key)
				{
					case 'x-priority':
						$mailObject->Priority = $val;
						break;
					case 'message-id':
						$mailObject->MessageID  = $val; // ToDo: maybe we want to regenerate the message id all the time
						break;
					case 'sender':
						$mailObject->Sender  = $val;
						break;
					case 'to':
					case 'cc':
					case 'bcc':
					case 'from':
					case 'reply-to':
						$address_array  = imap_rfc822_parse_adrlist((get_magic_quotes_gpc()?stripslashes($val):$val),'');
						$i = 0;
						foreach((array)$address_array as $addressObject)
						{
							$mb = $addressObject->mailbox. (!empty($addressObject->host) ? '@'.$addressObject->host : '');
							$pName = $addressObject->personal;
							if ($key=='from')
							{
								$mailObject->From = $mb;
								$mailObject->FromName = $pName;
							}
							${$key}[$i] = array($mb,$pName);
							$i++;
						}
						if ($key=='reply-to')
						{
							$myReplyTo = ${$key};
							//break; // break early as we add that later
						}
						$Header .= $mailObject->TextLine(trim($mailObject->AddrAppend(ucfirst($key),${$key})));
						break;
					case 'content-transfer-encoding':
						$mailObject->Encoding = $val;
						break;
					case 'content-type':
						//error_log(__METHOD__.__LINE__.' '.$key.'->'.$val);
						if (stripos($val,'calendar')) $contenttypecalendar = $val;
						break;
					case 'subject':
						$mailObject->Subject = $mailObject->EncodeHeader($mailObject->SecureHeader($val));
						$Header .= $mailObject->HeaderLine('Subject',$mailObject->Subject);
						break;
					default:
						// stuff like X- ...
						//$mailObject->AddCustomHeader('X-Mailer: FeLaMiMail');
						if (!strtolower(substr($key,0,2))=='x-') break;
					//case 'priority': // priority is a cusom header field
					//	$mailObject->Priority = $val;
					//	break;
					case 'disposition-notification-To':
					case 'organization':
						foreach((array)$val as $i => $v) $mailObject->AddCustomHeader($key.': '. $v);
						break;
				}
			}
			// handle reply-to, wich may be set, set the first one found
			if (!empty($myReplyTo))
			{
				$mailObject->ClearReplyTos();
				$mailObject->AddReplyTo($myReplyTo[0][0],$myReplyTo[0][1]);
			}

			$seemsToBePlainMessage = false;
			if (strtolower($structure->ctype_primary)=='text' && $structure->body)
			{
				$mailObject->IsHTML(strtolower($structure->ctype_secondary)=='html'?true:false);
				if (strtolower($structure->ctype_primary) == 'text' && strtolower($structure->ctype_secondary) == 'plain' &&
					is_array($structure->ctype_parameters) && isset($structure->ctype_parameters['format']) &&
					trim(strtolower($structure->ctype_parameters['format']))=='flowed'
				)
				{
					if (self::$debug) error_log(__METHOD__.__LINE__." detected TEXT/PLAIN Format:flowed -> removing leading blank ('\r\n ') per line");
					$structure->body = str_replace("\r\n ","\r\n", $structure->body);
				}
				$mailObject->Body = $structure->body;
				$seemsToBePlainMessage = true;
			}
			$this->createBodyFromStructure($mailObject, $structure, $parenttype=null);
			$mailObject->SetMessageType();
			$mailObject->CreateHeader(); // this sets the boundary stufff
			//echo "Boundary:".$mailObject->FetchBoundary(1).'
';
			//$boundary ='';
			//if (isset($structure->ctype_parameters['boundary'])) $boundary = ' boundary="'.$mailObject->FetchBoundary(1).'";';
			if ($seemsToBePlainMessage && !empty($contenttypecalendar) && strtolower($mailObject->ContentType)=='text/plain')
			{
				$Header .= $mailObject->HeaderLine('Content-Transfer-Encoding', $mailObject->Encoding);
				$Header .= $mailObject->HeaderLine('Content-type', $contenttypecalendar);
			}
			else
			{
				$Header .= $mailObject->GetMailMIME();
			}
			$Body = $mailObject->getMessageBody(); // this is a method of the egw_mailer/phpmailer class
			//_debug_array($Header);
			//_debug_array($Body);
			//_debug_array($mailObject);
			//exit;
	}

	/**
	 * createBodyFromStructure - fetches/creates the bodypart of the email as textual representation
	 *   is called recursively to be able to fetch the stuctureparts of the mail parsed from Mail/mimeDecode
	 * @param object $mailObject instance of the SMTP Mailer Object
	 * @param array $structure array that represents structure and content of a mail parsed from Mail/mimeDecode
	 * @param string $parenttype type of the parent node
	 * @return void Parsed Information is passed to the mailObject to be processed there
	 */
	function createBodyFromStructure($mailObject, $structure, $parenttype=null, $decode=false)
	{
		static $attachmentnumber;
		static $isHTML;
		static $alternatebodyneeded;
		if (is_null($isHTML)) $isHTML = strtolower($structure->ctype_secondary)=='html'?true:false;
		if (is_null($attachmentnumber)) $attachmentnumber = 0;
		if ($structure->parts && strtolower($structure->ctype_primary)=='multipart')
		{
			if (is_null($alternatebodyneeded)) $alternatebodyneeded = false;
			foreach($structure->parts as $part)
			{
				//error_log(__METHOD__.__LINE__.' Structure Content Type:'.$structure->ctype_primary.'/'.$structure->ctype_secondary.' Decoding:'.($decode?'on':'off'));
				//error_log(__METHOD__.__LINE__.' '.$structure->ctype_primary.'/'.$structure->ctype_secondary.' => '.$part->ctype_primary.'/'.$part->ctype_secondary);
				//error_log(__METHOD__.__LINE__.' Part:'.array2string($part));
				$partFetched = false;
				//echo __METHOD__.__LINE__.$structure->ctype_primary.'/'.$structure->ctype_secondary.'
';
				if ($part->headers['content-transfer-encoding']) $mailObject->Encoding = $part->headers['content-transfer-encoding'];
				//$mailObject->IsHTML($part->ctype_secondary=='html'?true:false); // we do not set this here, as the default is text/plain
				if (isset($part->ctype_parameters['charset'])) $mailObject->CharSet = trim($part->ctype_parameters['charset']);
				if ((strtolower($structure->ctype_secondary)=='alternative'||
					 strtolower($structure->ctype_secondary)=='mixed' ||
					// strtolower($structure->ctype_secondary)=='related' || // may hold text/plain directly ?? I doubt it ??
					 strtolower($structure->ctype_secondary)=='signed') && strtolower($part->ctype_primary)=='text' && strtolower($part->ctype_secondary)=='plain' && $part->body)
				{
					//echo __METHOD__.__LINE__.$part->ctype_primary.'/'.$part->ctype_secondary.'
';
					//error_log(__METHOD__.__LINE__.$part->ctype_primary.'/'.$part->ctype_secondary.' already fetched Content is HTML='.$isHTML.' Body:'.$part->body);
					$bodyPart = $part->body;
					if ($decode) $bodyPart = $this->decodeMimePart($part->body,($part->headers['content-transfer-encoding']?$part->headers['content-transfer-encoding']:'base64'));
/*
					if (strtolower($part->ctype_primary) == 'text' && strtolower($part->ctype_secondary) == 'plain' &&
						is_array($part->ctype_parameters) && isset($part->ctype_parameters['format']) &&
						trim(strtolower($part->ctype_parameters['format']))=='flowed'
					)
					{
						if (self::$debug) error_log(__METHOD__.__LINE__." detected TEXT/PLAIN Format:flowed -> removing leading blank ('\r\n ') per line");
						$bodyPart = str_replace("\r\n ","\r\n", $bodyPart);
					}
*/
					$mailObject->Body = ($isHTML==false?$mailObject->Body:'').$bodyPart;
					$mailObject->AltBody .= $bodyPart;
					$partFetched = true;
				}
				if ((strtolower($structure->ctype_secondary)=='alternative'||
					 strtolower($structure->ctype_secondary)=='mixed' ||
					 strtolower($structure->ctype_secondary)=='related' || // may hold text/html directly
					 strtolower($structure->ctype_secondary)=='signed' ) &&
					strtolower($part->ctype_primary)=='text' && strtolower($part->ctype_secondary)=='html' && $part->body)
				{
					//echo __METHOD__.__LINE__.$part->ctype_primary.'/'.$part->ctype_secondary.'
';
					//error_log(__METHOD__.__LINE__.$part->ctype_primary.'/'.$part->ctype_secondary.' already fetched Content is HTML='.$isHTML.' Body:'.$part->body);
					$bodyPart = $part->body;
					if ($decode) $bodyPart = $this->decodeMimePart($part->body,($part->headers['content-transfer-encoding']?$part->headers['content-transfer-encoding']:'base64'));
					$mailObject->IsHTML(true); // we need/want that here, because looping through all message parts may mess up the message body mimetype
					$mailObject->Body = ($isHTML?$mailObject->Body:'').$bodyPart;
					$alternatebodyneeded = true;
					$isHTML=true;
					$partFetched = true;
				}
				if ((strtolower($structure->ctype_secondary)=='alternative'||
					 strtolower($structure->ctype_secondary)=='mixed' ||
					 strtolower($structure->ctype_secondary)=='signed' ) &&
					strtolower($part->ctype_primary)=='text' && strtolower($part->ctype_secondary)=='calendar' && $part->body)
				{
					//error_log(__METHOD__.__LINE__.$part->ctype_primary.'/'.$part->ctype_secondary.' BodyPart:'.array2string($part));
					$bodyPart = $part->body;
					if ($decode) $bodyPart = $this->decodeMimePart($part->body,($part->headers['content-transfer-encoding']?$part->headers['content-transfer-encoding']:'base64'));
					$mailObject->AltExtended = $bodyPart;
					// "text/calendar; charset=utf-8; name=meeting.ics; method=REQUEST"
					// [ctype_parameters] => Array([charset] => utf-8[name] => meeting.ics[method] => REQUEST)
					$mailObject->AltExtendedContentType = $part->ctype_primary.'/'.$part->ctype_secondary.';'.
						($part->ctype_parameters['name']?' name='.$part->ctype_parameters['name'].';':'').
						($part->ctype_parameters['method']?' method='.$part->ctype_parameters['method'].'':'');
					$partFetched = true;
				}
				if ((strtolower($structure->ctype_secondary)=='mixed' ||
					 strtolower($structure->ctype_secondary)=='related' ||
					 strtolower($structure->ctype_secondary)=='alternative' ||
					 strtolower($structure->ctype_secondary)=='signed') && strtolower($part->ctype_primary)=='multipart')
				{
					//error_log( __METHOD__.__LINE__." Recursion to fetch subparts:".$part->ctype_primary.'/'.$part->ctype_secondary);
					$this->createBodyFromStructure($mailObject, $part, $parenttype=null, $decode);
				}
				//error_log(__METHOD__.__LINE__.$structure->ctype_primary.'/'.$structure->ctype_secondary.' => '.$part->ctype_primary.'/'.$part->ctype_secondary.' Part:'.array2string($part));
				if ($part->body && ((strtolower($structure->ctype_secondary)=='mixed' && strtolower($part->ctype_primary)!='multipart') ||
					trim(strtolower($part->disposition)) == 'attachment' ||
					trim(strtolower($part->disposition)) == 'inline' ||
					isset($part->headers['content-id'])))
				{
					//error_log(__METHOD__.__LINE__.$structure->ctype_secondary.'=>'.$part->ctype_primary.'/'.$part->ctype_secondary.'->'.array2string($part));
					$attachmentnumber++;
					$filename = trim(($part->ctype_parameters['name']?$part->ctype_parameters['name']:$part->d_parameters['filename']));
					if (strlen($filename)==0)
					{
						//error_log(__METHOD__.__LINE__.$structure->ctype_secondary.'=>'.$part->ctype_primary.'/'.$part->ctype_secondary.'->'.array2string($part));
						foreach(array('content-type','content-disposition') as $k => $v)
						{
							foreach(array('filename','name') as $sk => $n)
							{
								if (stripos($part->headers[$v],$n)!== false)
								{
									$buff = explode($n,$part->headers[$v]);
									//error_log(__METHOD__.__LINE__.array2string($buff));
									$namepart = array_pop($buff);
									//$disposition = 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)
										{
											$filename = trim(substr($namepart,$fp+1,$np-$fp-1));
											$filename = $mailObject->EncodeHeader($filename);
											if (!empty($filename))
											{
												if (strpos($part->disposition,';')!==false)
												{
													//chance is, disposition is broken too
													$dbuff = explode(';',$part->disposition);
													$part->disposition = trim($dbuff[0]);
												}
												break 2;
											}
										}
									}
								}
							}
						}
					}
					if (strlen($filename)==0) $filename = 'noname_'.$attachmentnumber;
					//error_log(__METHOD__.__LINE__.' '.$filename);
					//echo $part->headers['content-transfer-encoding'].'#
';
					if ($decode) $part->body = $this->decodeMimePart($part->body,($part->headers['content-transfer-encoding']?$part->headers['content-transfer-encoding']:'base64'));
					if ((trim(strtolower($part->disposition))=='attachment' || trim(strtolower($part->disposition)) == 'inline' || isset($part->headers['content-id'])) && $partFetched==false)
					{
						if (trim(strtolower($part->disposition)) == 'inline' || $part->headers['content-id'])
						{
							$part->headers['content-id'] = str_replace(array('<','>'),'',$part->headers['content-id']);
							$dirname = $this->accountid.'_'.$this->profileID.'_'.$this->sessionData['mailbox'].$part->headers['content-id'];
							if (self::$debug) error_log(__METHOD__.__LINE__.' Dirname:'.$dirname);
							$dirname = md5($dirname);
							$dir = $GLOBALS['egw_info']['server']['temp_dir']."/fmail_import/$dirname";
							if (self::$debug) error_log(__METHOD__.__LINE__.' Dir to save attachment to:'.$dir);
							if ( !file_exists( "$dir") )
							{
								@mkdir( $dir, 0700, true );
							}
							$rp = mail_bo::getRandomString();
							file_put_contents( "$dir/$rp$filename", $part->body);

							$path = "$dir/$rp$filename";
							$mailObject->AddEmbeddedImage($path, $part->headers['content-id'], $filename, ($part->headers['content-transfer-encoding']?$part->headers['content-transfer-encoding']:'base64'), $part->ctype_primary.'/'.$part->ctype_secondary);
						}
						else
						{
							//error_log(__METHOD__.__LINE__.' Add String '.($part->disposition=='attachment'?'Attachment':'Part').' of type:'.$part->ctype_primary.'/'.$part->ctype_secondary);
							$mailObject->AddStringAttachment($part->body, //($part->headers['content-transfer-encoding']?base64_decode($part->body):$part->body),
													 $filename,
													 ($part->headers['content-transfer-encoding']?$part->headers['content-transfer-encoding']:'base64'),
													 $part->ctype_primary.'/'.$part->ctype_secondary
													);
						}
					}
					if (!(trim(strtolower($part->disposition))=='attachment' || trim(strtolower($part->disposition)) == 'inline' || isset($part->headers['content-id'])) && $partFetched==false)
					{
						//error_log(__METHOD__.__LINE__.' Add String '.($part->disposition=='attachment'?'Attachment':'Part').' of type:'.$part->ctype_primary.'/'.$part->ctype_secondary.' Body:'.$part->body);
						$mailObject->AddStringPart($part->body, //($part->headers['content-transfer-encoding']?base64_decode($part->body):$part->body),
													 $filename,
													 ($part->headers['content-transfer-encoding']?$part->headers['content-transfer-encoding']:'base64'),
													 $part->ctype_primary.'/'.$part->ctype_secondary
													);
					}
				}
			}
			if ($alternatebodyneeded == false) $mailObject->AltBody = '';
		}
	}


	/**
	 * Hook stuff
	 */

	/**
	 * hook to add account
	 *
	 * this function is a wrapper function for emailadmin
	 *
	 * @param _hookValues contains the hook values as array
	 * @return nothing
	 */
	function addAccount($_hookValues)
	{
		if ($this->mailPreferences) {
			$icServer = $this->mailPreferences->getIncomingServer($this->profileID);
			if(($icServer instanceof defaultimap)) {
				// if not connected, try opening an admin connection
				if (!$icServer->_connected) $this->openConnection($this->profileID,true);
				$icServer->addAccount($_hookValues);
				if ($icServer->_connected) $this->closeConnection(); // close connection afterwards
			}

			$ogServer = $this->mailPreferences->getOutgoingServer($this->profileID);
			if(($ogServer instanceof emailadmin_smtp)) {
				$ogServer->addAccount($_hookValues);
			}
		}
	}

	/**
	 * hook to delete account
	 *
	 * this function is a wrapper function for emailadmin
	 *
	 * @param _hookValues contains the hook values as array
	 * @return nothing
	 */
	function deleteAccount($_hookValues)
	{
		if ($this->mailPreferences) {
			$icServer = $this->mailPreferences->getIncomingServer($this->profileID);
			if(($icServer instanceof defaultimap)) {
				//try to connect with admin rights, when not connected
				if (!$icServer->_connected) $this->openConnection($this->profileID,true);
				$icServer->deleteAccount($_hookValues);
				if ($icServer->_connected) $this->closeConnection(); // close connection
			}

			$ogServer = $this->mailPreferences->getOutgoingServer($this->profileID);
			if(($ogServer instanceof emailadmin_smtp)) {
				$ogServer->deleteAccount($_hookValues);
			}
		}
	}

	/**
	 * hook to update account
	 *
	 * this function is a wrapper function for emailadmin
	 *
	 * @param _hookValues contains the hook values as array
	 * @return nothing
	 */
	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 emailadmin_smtp)) {
			$ogServer->updateAccount($_hookValues);
		}
	}
}