No OneTemporary
Actions

Size

138 KB

Referenced Files

None

Subscribers

None

View Options

	diff --git a/CHANGELOG b/CHANGELOG
	index 0e9ccfd51..efb8026e7 100644
	--- a/CHANGELOG
	+++ b/CHANGELOG
	@@ -1,470 +1,472 @@
	CHANGELOG RoundCube Webmail
	===========================

	+- Fix incorrect word wrapping in outgoing plaintext multibyte messages (#1485714)
	+- Fix double footer in HTML message with embedded images
	- Fix TNEF implementation bug (#1485773)
	- Fix incorrect row id parsing for LDAP contacts list (#1485784)
	- Fix 'mode' parameter in sqlite DSN (#1485772)

	RELEASE 0.2.1
	------------------
	- Use US-ASCII as failover when Unicode searching fails (#1485762)
	- Fix errors handling in IMAP command continuations (#1485762)
	- Fix FETCH result parsing for servers returning flags at the end of result (#1485763)
	- Fix datetime columns defaults in mysql's DDL (#1485641)
	- Fix attaching more than nine inline images (#1485759)
	- Support 'UNICODE-1-1-UTF-7' alias for UTF-7 encoding (#1485758)
	- Fix mime-type detection using a hard-coded map (#1485311)
	- Don't return empty string if charset conversion failed (#1485757)
	- Disable concurrent autocomplete query results display (#1485743)
	- Fix new lines stripped from message footer (#1485751)
	- Fix IE problem with mouse click autocomplete (#1485739)
	- Fix html body washing on reply/forward + fix attachments handling (#1485676)
	- Fix multiple recipients input parsing (#1485733)
	- Fix replying to message with html attachment (#1485676)
	- Use default_charset for messages without specified charset (#1485661, #1484961)
	- Support non-standard "GMT-XXXX" literal in date header (#1485729)
	- Added TNEF support to decode MS Outlook attachments (winmail.dat)
	- Fix "value continuation" MIME headers by adding required semicolon (#1485727)
	- Fix pressing select all/unread multiple times (#1485723)
	- Fix selecting all unread does not honor new messages (#1485724)
	- Fix some base64 encoded attachments handling (#1485725)
	- Support NGINX as IMAP backend: better BAD response handling (#1485720)
	- Performance fix: don't fetch attachment parts headers twice to parse filename
	- Fix checking for recent messages on various IMAP servers (#1485702)
	- Performance fix: Don't fetch quota and recent messages in "message view" mode
	- Fix displaying of alternative-inside-alternative messages (#1485713)
	- Fix MDNSent flag checking, use arbitrary keywords (asterisk) flag (#1485706)
	- Fix creation of folders with '&' sign in name
	- Fix parsing of email addresses without angle brackets (#1485693)
	- Save spellcheck corrections when switching from plain to html editor (and spellchecking is on)
	- Fix large search results on server without SORT capability (#1485668)
	- Get rid of preg_replace() with eval modifier and create_function usage (#1485686)
	- Bring back <base> and <link> tags in HTML messages
	- Fix XSS vulnerability through background attributes as reported by Julien Cayssol
	- Fix problems with backslash as IMAP hierarchy delimiter (#1484467)
	- Secure vcard export by getting rid of preg's 'e' modifier use (#1485689)
	- Fix authentication when submitting form with existing session (#1485679)
	- Allow absolute URLs to images in HTML messages/sigs (#1485666)
	- Fix message body which contains both inline attachments and emotions
	- Fix SQL query execution errors handling in rcube_mdb2 class (#1485509)
	- Fix address names with '@' sign handling (#1485654)
	- Improve messages display performance
	- Fix messages searching with 'to:' modifier

	RELEASE 0.2-STABLE
	------------------
	- Fix mark popup in IE 7 (#1485369)
	- Fix line-break issue when copy & paste in Firefox (#1485425)
	- Fix autocomplete "unknown server error" (#1485637)
	- Fix STARTTLS before AUTH in SMTP connection (#1484883)
	- Support multiple quota values in QUOTAROOT resonse (#1485626)
	- Only abbreviate file name for IE < 7 browsers (#1485063)
	- Performance: allow setting imap rootdir and delimiter before connect (#1485172)
	- Fix sorting of folders with more than 2 levels (#1485569)
	- Fix search results page jumps in LDAP addressbook (#1485253)
	- Fix empty line before the signature in IE (#1485351)
	- Fix horizontal scrollbar in preview pane on IE (#1484633)
	- Add Robots meta tag in login page and installer (#1484846)
	- Added 'show_images' option, removed 'addrbook_show_images' (#1485597)
	- Option to check for new mails in all folders (#1484374)
	- Don't set client busy when checking for new messages (#1485276)
	- Allow UTF-8 folder names in config (#1485579)
	- Add junk_mbox option configuration in installer (#1485579)
	- Do serverside addressbook queries for autocompletion (#1485531)
	- Allow setting attachment col position in 'list_cols' option
	- Allow override 'list_cols' via skin (#1485577)
	- Fix 'cache' table cleanup on session destroy (#1485516)
	- Increase speed of session destroy and garbage clean up
	- Fix session timeout when DB server got clock skew (#1485490)
	- Fix handling of some malformed messages (#1484438)
	- Speed up raw message body handling
	- Better HTML entities conversion in html2text (#1485519)
	- Fix big memory consumption and speed up searching on servers without SORT capability
	- Fix setting locale to tr_TR, ku and az_AZ (#1485470)
	- Use SORT for searching on servers with SORT capability
	- Added message status filter
	- Fix empty file sending (#1485389)
	- Improved searching with many criterias (calling one SEARCH command)
	- Fix HTML editor initialization on IE (#1485304)
	- Add warning when switching editor mode from html to plain (#1485488)
	- Make identities list scrollable (#1485538)
	- Fix problem with numeric folder names (#1485527)
	- Added BYE response simple support to prevent from endless loops in imap.inc (#1483956)
	- Fix unread message unintentionally marked as read if read_when_deleted=true (#1485409)
	- Remove port number from SERVER_NAME in smtp_helo_host (#1485518)
	- Don't send disposition notification receipts for messages marked as 'read' (#1485523)
	- Added 'keep_alive' and 'min_keep_alive' options (#1485360)
	- Added option 'identities_level', removed 'multiple_identities'
	- Allow deleting identities when multiple_identities=false (#1485435)
	- Added option focus_on_new_message (#1485374)
	- Fix html2text class autoloading on Windows (#1485505)
	- Fix html signature formatting when identity save error occured (#1485426)
	- Add feedback and set busy when moving folder (#1485497)
	- Fix 'Empty' link visibility for some languages e.g. Slovak (#1485489)
	- Fix messages count bar overlapping (#1485270)
	- Fix adding signature in drafts compose mode (#1485484)
	- Fix iil_C_Sort() to support very long and/or divided responses (#1485283)
	- Fix matching case sensitivity when setting identity on reply (#1485480)
	- Prefer default identity on reply
	- Fix imap searching on ISMail server (#1485466)
	- Add css class for flagged messages (#1485464)
	- Write username instead of id in sendmail log (#1485477)
	- Fix htmlspecialchars() use for PHP version < 5.2.3 (#1485475)
	- Fix js keywords escaping in json_serialize() for IE/Opera (#1485472)
	- Added bin/killcache.php script (#1485434)
	- Add support for SJIS, GB2312, BIG5 in rc_detect_encoding()
	- Fix vCard file encoding detection for non-UTF-8 strings (#1485410)
	- Add 'skip_deleted' option in User Preferences (#1485445)
	- Minimize "inline" javascript scripts use (#1485433)
	- Fix css class setting for folders with names matching defined classes names (#1485355)
	- Fix race conditions when changing mailbox
	- Fix spellchecking when switching to html editor (#1485362)
	- Fix compose window width/height (#1485396)
	- Allow calling msgimport.sh/msgexport.sh from any directory (#1485431)
	- Localized filesize units (#1485340)
	- Better handling of "no identity" and "no email in identity" situations (#1485117)
	- Added 'mime_param_folding' option with possibility to choose long/non-ascii attachment names encoding eg. to be readable in MS Outlook/OE (#1485320)
	- Added "advanced options" feature in User Preferences
	- Fix unread counter when displaying cached massage in preview panel (#1485290)
	- Fix htmleditor spellchecking on MS Windows (#1485397)
	- Fix problem with non-ascii attachment names in Mail_mime (#1485267, #1485096)
	- Fix language autodetection (#1485401)
	- Fix button label in folders management (#1485405)
	- Fix collapsed folder not indicating unread msgs count of all subfolders (#1485403)
	- Fix handling of apostrophes in filenames decoded according to rfc2231

	RELEASE 0.2-BETA
	----------------
	- Made config files location configurable (#1485215)
	- Reduced memory footprint when forwarding attachments (#1485345)
	- Allow and use spellcheck attribute for input/textarea fields (#1485060)
	- Added icons for forwarded/forwarded+replied messages (#1485257)
	- Added Reply-To to forwarded emails (#1485315)
	- Display progress message for folders create/delete/rename (#1485357)
	- Smart Tags and NOBR tag support in html messages (#1485363, #1485327)
	- Redesign of the identities settings (#1484042)
	- Add config option to disable creation/deletion of identities (#1484498)
	- Added 'sendmail_delay' option to restrict messages sending interval (#1484491)
	- Added vertical splitter for folders list resizing
	- Added possibility to view all headers in message view
	- Fixed splitter drag/resize on Opera (#1485170)
	- Fixed quota img height/width setting from template (#1484857)
	- Refactor drag & drop functionality. Don't rely on browser events anymore (#1484453)
	- Insert "virtual" folders in subscription list (#1484779)
	- Added link to open message in new window
	- Enable export of address book contacts as vCard
	- Add feature to import contacts from vcard files (#1326103)
	- Respect Content-Location headers in multipart/related messages according to RFC2110 (#1484946)
	- Allowed max. attachment size now indicated in compose screen (#1485030)
	- Also capture backspace key in list mode (#1484566)
	- Allow application/pgp parts to be displayed (#1484753)
	- Correctly handle options in mailto-links (#1485228)
	- Immediately save sort_col/sort_order in user prefs (#1485265)
	- Truncate very long (above 50 characters) attachment filenames when displaying
	- Allow to auto-detect client language if none set (#1484434)
	- Auto-detect the client timezone (user configurable)
	- Add RFC2231 header value continuations support for attachment filenames + hack for servers that not support that feature
	- Fix Reply-To header displaying (#1485314)
	- Mark form buttons that provide the most obvious operation (mainaction)
	- Added option 'quota_zero_as_unlimited' (#1484604)
	- Added PRE handling in html2text class (#1484740)
	- Added folder hierarchy collapsing
	- Added options to use syslog instead of log file (#1484850)
	- Added Logging & Debugging section in Installer
	- Fix In-Reply-To and References headers when composing saved draft message (#1485288)
	- Fix html message charset conversion for charsets with underline (#1485287)
	- Fix buttons status after contacts deletion (#1485233)
	- Fix escaping of To: and From: fields when building message body for reply or forward in the HTML editor (#1484904)
	- Use current mailbox name in template (#1485256)
	- Better fix for skipping untagged responses (#1485261)
	- Added pspell support patch by Kris Steinhoff (#1483960)
	- Enable spellchecker for HTML editor (#1485114)
	- Respect spellcheck_uri in tinyMCE spellchecker (#1484196)
	- Case insensitive contacts searching using PostgreSQL (#1485259)
	- Make default imap folders configurable for each user (#1485075)
	- Save outgoing mail to selectable folder (#1324581)
	- Fix hiding of mark menu when clicking th button again (#1484944)
	- Use long date format in print mode (#1485191)
	- Updated TinyMCE to version 3.1.0.1
	- Re-enable autocomplete attribute for login form (#1485211)
	- Check PERMANENTFLAGS before saving $MDNSent flag (#1484963, #1485163)
	- Added flag column on messages list (#1484623)
	- Patched Mail/MimePart.php (http://pear.php.net/bugs/bug.php?id=14232)
	- Allow trash/junk subfolders to be purged (#1485085)
	- Store compose parameters in session and redirect to a unique URL
	- Fixed CRAM-MD5 authentication (#1484819)
	- Fixed forwarding messages with one HTML attachment (#1484442)
	- Fixed encoding of message/rfc822 attachments and image/pjpeg handling (#1484914)
	- Added option to select skin in user preferences
	- Added option to configure displaying of attached images below the message body
	- Added option to display images in messages from known senders (#1484601)
	- User preferences grouped in more fieldsets
	- Fix corrupted MIME headers of messages in Sent folder (#1485111)
	- Fixed bug in MDB2 package: http://pear.php.net/bugs/bug.php?id=14124
	- Use keypress instead of keydown to select list's row (#1484816)
	- Don't call expunge and don't remove message row after message move if flag_for_deletion is set to true (#1485002)

	RELEASE 0.2-ALPHA
	-----------------
	- Added option to disable autocompletion from selected LDAP address books (#1484922)
	- TLS support in LDAP connections: 'use_tls' property (#1485104)
	- Fixed removing messages from search set after deleting them (#1485106)
	- imap.inc: Fixed iil_C_FetchStructureString() to handle many
	literal strings in response (#1484969)
	- Support for subfolders in default/protected folders (#1484665)
	- Disallowed delimiter in folder name (#1484803)
	- Support " and \ in folder names
	- Escape \ in login (#1484614)
	- Better HTML sanitization with the DOM-based washtml script (#1484701)
	- Fixed sorting of folders with non-ascii characters
	- Fixed Mysql DDL for default identities creation (#1485070)
	- In Preferences added possibility to configure 'read_when_deleted',
	'mdn_requests', 'flag_for_deletion' options
	- Made IMAP auth type configurable (#1483825)
	- Fixed empty values with FROM_UNIXTIME() in rcube_mdb2 (#1485055)
	- Fixed attachment list on IE 6/7 (#1484807)
	- Fixed JavaScript in compose.html that shows cc/bcc fields if populated
	- Make password input fields of type password in installer (#1484886)
	- Don't attempt to delete cache entries if enable_caching is FALSE (#1485051)
	- Optimized messages sorting on servers without sort capability (#1485049)
	- Corrected message headers decoding when charset isn't specified and improved
	support for native languages (#1485050, #1485048)
	- Expanded LDAP configuration options to support LDAP server writes.
	- Installer: encode special characters in DB username/password (#1485042)
	- Fixed management of folders with national characters in names (#1485036, #1485001)
	- Fixed identities saving when using MDB2 pgsql driver (#1485032)
	- Fixed BCC header reset (#1484997)
	- Improved messages list performance - patch from Justin Heesemann
	- Append skin_path to images location only when it starts with '/' sign (#1484859)
	- Fix IMAP response in message body when message has no body (#1484964)
	- Fixed non-RFC dates formatting (#1484901)
	- Fixed typo in set_charset() (#1484991)
	- Decode entities when inserting HTML signature to plain text message (#1484990)
	- HTML editing is now working with PHP5 updates and TinyMCE v3.0.6
	- Fixed signature loading on Windows (#1484545)
	- Added language support to HTML editing (#1484862)
	- Fixed remove signature when replying (#1333167)
	- Fixed problem with line with a space at the end (#1484916)
	- Fixed <!DOCTYPE> tag filtering (#1484391)
	- Fixed <?xml> tag filtering (#1484403)
	- Added sections (fieldset+label) in Settings interface
	- Mark as read in one action with message preview (#1484972)
	- Deleted redundant quota reads (#1484972)
	- Added options for empty trash and expunge inbox on logout (#1483863)
	- Removed lines wrapping when displaying message
	- Fixed month localization
	- Changed codebase to PHP5 with autoloader

	RELEASE 0.1.1
	-------------
	- Clear selection when selecting single item (#1484942)
	- Remove hard-coded image size in skin templates (#1484893)
	- Database schema improvements (dropped unnecessary indexes)
	- Fixed creating a new folder with a comma in its name (#1484681)
	- Fixed sorting of messages when default mailbox is empty (#1484317)
	- Improve message previewpane - less loading (#1484316)
	- Fixed login form autoompletion (#1484839)
	- Fixed virtuser_query option for mdb2 backend (#1484874)
	- Fixed attachment resoting from Drafts when message body was empty (#1484506)
	- Fixed usage of ob_gzhandler (#1484851)
	- Fixed message part window in IE6 (#1484610)
	- Fixed decoding of mime-encoded strings (#1484191)
	- Fixed some iconv/mb_string problems (#1484598)
	- Correctly quote mailbox name when using in URL (#1484313)
	- Fixed "headers already sent" errors (#1484860)

	RELEASE 0.1-STABLE
	------------------
	- Added interactive installer script
	- Fix folder adding/renaming inspired by #1484800
	- Localize folder name in page title (#1484785)
	- Fix code using wrong variable name (#1484018)
	- Allow to send mail with BCC recipients only
	- condense TinyMCE toolbar down to one line, removing table buttons (#1484747)
	- Add function to mark the selected messages as read/unread (#1457360)
	- Also do charset decoding as suggested in RFC 2231 (fix #1484321)
	- Show message count in folder list and hint when creating a subfolder
	- Distinguish ssl and tls for imap connections (#1484667)
	- Added some charset aliases to fix typical mis-labelling (#1484565)
	- Remember decision to display images for a certain message during session (#1484754)
	- Truncate attachment filenames to 55 characters due to an IE bug (#1484757)
	- Make sending of read receipts configurable
	- Respect config when localize folder names (#1484707)
	- Also respect receipt and priority settings when re-opening a draft message
	- Remember search results (closes #1483883), patch by the_glu
	- Add Received header on outgoing mail
	- Upgrade to TinyMCE 2.1.3
	- Allow inserting image attachments into HTML messages while composing (#1484557)
	- Implement Message-Disposition-Notification (Receipts)
	- Fix overriding of session vars when register_globals is on (#1484670)
	- Fix bug with case-sensitive folder names (#1484245)
	- Don't create default folders by default
	- Fixed some potential security risks (audited by Andris)
	- Only show new messages if they match the current search (#1484176)
	- Switch to/from when searcing in Sent folder (#1484555)
	- Correctly read the References header (#1484646)
	- Unset old cookie before sending a new value (#1484639)
	- Correctly decode attachments when downloading them (#1484645 and #1484642)
	- Suppress IE errors when clearing attachments form (#1484356)
	- Log error when login fails due to auto_create_user turned off
	- Filter linked/imported CSS files (closes #1484056)
	- Improve message compose screen (closes #1484383)
	- Select next row after removing one from list (#1484387)

	RELEASE 0.1-RC2
	---------------
	- Enable drag-&-dropping of folders to a new parent and allow to create subfolders (#1457344)
	- Suppress IE errors when clearing attachments form (#1484356)
	- Set preferences field in user table to NULL (#1484386)
	- Log error when login fails due to auto_create_user turned off
	- Filter linked/imported CSS files (closes #1484056)
	- Improve message compose screen (closes #1484383)
	- Select next row after removing one from list (#1484387)
	- Make smtp HELO/EHLO hostname configurable (#1484067)
	- IPv6 Compatability (#1484322), Patch #1484373
	- Unlock interface when message sending fails (#1484570)
	- Eval PHP code in template includes (if configured)
	- Show message when folder is empty. Mo more static text in table (#1484395)
	- Only display unread count in page title when new messages arrived
	- Fixed wrong delete button tooltip (#1483965)
	- Fixed charset encoding bug (#1484429)
	- Applied patch for LDAP version (#1484552)
	- Improved XHTML validation
	- Fix message list selection (#1484550)
	- Better fix lowercased usernames (#1484473)
	- Update pngbehavior Script as suggested in #1484490
	- Fixed moving/deleting messages when more than 1 is selected
	- Applied patch for LDAP contacts listing by Glen Ogilvie
	- Applied patch for more address fields in LDAP contacts (#1484402)
	- Add alternative for getallheaders() (fix #1484508)
	- Identify mailboxes case-sensitive
	- Sort mailbox list case-insensitive (closes #1484338)
	- Fix display of multipart messages from Apple Mail (closes #1484027)
	- Protect AJAX request from being fetched by a foreign site (XSS)
	- Make autocomplete for loginform configurable by the skin template
	- Fix compose function from address book (closes #1484426)
	- Added //IGNORE to iconv call (patch #1484420, closes #1484023)
	- Check if mbstring supports charset (#1484290 and #1484292)
	- Prefer iconv over mbstring (as suggested in #1484292)
	- Check filesize of template includes (#1484409)
	- Fixed bug with buttons not dimming/enabling properly after switching folders
	- Fixed compose window becoming unresponsive after saving a draft (#1484487)
	- Re-enabled "Back" button in compose window now that bug #1484487 is fixed
	- Fixed unresponsive interface issue when downloading attachments (#1484496)
	- Lowered status message time from 5 to 3 seconds to improve responsiveness
	- Raised .htaccess upload_max_filesize from 2M to 5M to differ from default php.ini
	- Increased "mailboxcontrols" mail.css width from 160 to 170px to fix non-english languages (#1484499)
	- Fix status message bug #1484464 with regard to #1484353
	- Fix address adding bug reported by David Koblas
	- Applied socket error patch by Thomas Mangin
	- Pass-by-reference workarround for PHP5 in sendmail.inc
	- Fixed buggy imap_root settings (closes #1484379)
	- Prevent default events on subject links (#1484399)
	- Use HTTP-POST requests for actions that change state

	RELEASE 0.1-RC1
	---------------
	- Use global filters and bind username/ for Ldap searches (#1484159)
	- Hide quota display if imap server does not support it
	- Hide address groups if no LDAP servers configured
	- Add link to message subjects (closes #1484257)
	- Better SQL query for contact listing/search (closes #1484369)
	- Fixed marking as read in preview pane (closes #1484364)
	- CSS hack to display attachments correctly in IE6
	- Wrap message body text (closes #1484148)
	- LDAP access is back in address book (closes #1484087)
	- Added search function for contacts
	- New Template parsing and output encoding
	- Fixed bugs #1484119 and #1483978
	- Fixed message moving procedure (closes #1484308)
	- Fixed display of multiple attachments (closes #1466563)
	- Fixed check for new messages (closes #1484310)
	- List attachments without filename
	- New session authentication: Change sessid cookie when login, authentication with sessauth cookie is now configurable.
	Should close bugs #1483951 and #1484299
	- Correctly translate mailbox names (closes #1484276)
	- Quote e-mail address links (closes #1484300)
	- Updated PEAR::Mail_mime package
	- Accept single quotes for HTML attributes when modifying message body (thanks Jason)
	- Sanitize input for new users/identities (thanks Colin Alston)
	- Don't download HTML message parts
	- Convert HTML parts to plaintext if 'prefer_html' is off
	- Correctly parse message/rfc822 parts (closes #1484045)
	- Also use user_id for unique key in messages table (closes #1484074)
	- Hide contacts drop down on blur (closes #1484203)
	- Make entries in contacts drop down clickable
	- Turn off browser autocompletion on login page
	- Quote <? in text/html message parts
	- Hide border around radio buttons
	- Applied patch for attachment download by crichardson (closes #1484198)
	- Fixed bug in Postgres DB handling (closes #1484068)
	- Fixed bug of invalid calls to fetchRow() in rcube_db.inc (closes #1484280)
	- Fixed array_merge bug (closes #1484281)
	- Fixed flag for deletion in list view (closes #1484264)
	- Finally support semicolons as recipient separator (closes ##1484251)
	- Fixed message headers (subject) encoding
	- check if safe mode is on or not (closes #1484269)
	- Show "no subject" in message list if subject is missing (closes #1484243)
	- Solved page caching of message preview (closes #1484153)
	- Only use gzip compression if configured (closes #1484236)
	- Fixed priority selector issue (#1484150)
	- Fixed some CSS issues in default skin (closes #1484210 and #1484161)
	- Prevent from double quoting of numeric HTML character references (closes #1484253)
	- Fixed display of HTML message attachments (closes #1484178)
	- Applied patch for preview caching (closes #1484186)
	- Added error handling for attachment uploads
	- Use multibyte safe string functions where necessary (closes #1483988)
	- Applied security patch to validate the submitted host value (by Kees Cook)
	- Applied security patch to validate input values when deleting contacts (by Kees Cook)
	- Applied security patch that sanitizes emoticon paths when attaching them (by Kees Cook)
	- Applied a patch to more aggressively sanitize a HTML message
	- Visualize blocked images in HTML messages
	- Fixed wrong message listing when showing search results (closes #1484131)
	- Show remote images when opening HTML message part as attachment
	- Improve memory usage when sending mail (closes #1484098)
	- Mark messages as read once the preview is loaded (closes #1484132)
	- Include smtp final response in log (closes #1484081)
	- Corrected date string in sent message header (closes #1484125)
	- Correclty choose "To" column in sent and draft mailboxes (closes #1483943)
	- Changed srong tooltips for message browse buttons (closes #1483930)
	- Fixed signature delimeter character to be standard (Bug #1484035)
	- Fixed XSS vulnerability (Bug #1484109)
	- Remove newlines from mail headers (Bug #1484031)
	- Selection issues when moving/deleting (Bug #1484044)
	- Applied patch of Clement Moulin for imap host auto-selection
	- ISO-encode IMAP password for plaintext login (Bugs #1483977 & #1483886)
	- Fixed folder name encoding in subscription list (Bug #1484113)
	- Fixed JS errors in identity list (Bug #1484120)
	- Translate foldernames in folder form (closes #1484113)
	- Added first and last buttons to message list, address book
	and message detail
	- Pressing Shift-Del bypasses Trash folder
	- Enable purge command for Junk folder
	- Fetch all aliases if virtuser_query is used instead
	- Re-enabled multi select of contacts (Bug #1484017)
	- Enable contact editing right after creation (Bug #1459641)
	- Correct UTF-7 to UTF-8 conversion if mbstring is not available
	- Fixed IMAP fetch of message body (Bug #1484019)
	- Fixed safe_mode problems (Bug #1418381)
	- Fixed wrong header encoding (Bug #1483976)
	- Made automatic draft saving configurable
	- Fixed JS bug when renaming folders (Bug #1483989)
	- Added quota display as image (by Brett Patterson)
	- Corrected creation of a message-id
	- New indentation for quoted message text
	- Improved HTML validity
	- Fixed URL character set (Ticket #1445501)
	- Fixed saving of contact into MySQL from LDAP query results (Ticket #1483820)
	- Fixed folder renaming: unsubscribe before rename (Bug #1483920)
	- Finalized new message parsing (+ chaching)
	- Fixed wrong usage of mbstring (Bug #1462439)
	- Set default spelling language (Ticket #1483938)
	- Added support for Nox Spell Server
	- Re-built message parsing (Bug #1327068)
	Now based on the message structure delivered by the IMAP server.
	- Fixed some XSS and SQL injection issues
	- Fixed charset problems with folder renaming




	diff --git a/program/include/rcube_shared.inc b/program/include/rcube_shared.inc
	index f1cbb19c3..a05815800 100644
	--- a/program/include/rcube_shared.inc
	+++ b/program/include/rcube_shared.inc
	@@ -1,638 +1,686 @@
	<?php

	/*
	+-----------------------------------------------------------------------+
	\| rcube_shared.inc \|
	\| \|
	\| This file is part of the RoundCube PHP suite \|
	\| Copyright (C) 2005-2007, RoundCube Dev. - Switzerland \|
	\| Licensed under the GNU GPL \|
	\| \|
	\| CONTENTS: \|
	\| Shared functions and classes used in PHP projects \|
	\| \|
	+-----------------------------------------------------------------------+
	\| Author: Thomas Bruederli <roundcube@gmail.com> \|
	+-----------------------------------------------------------------------+

	$Id$

	*/


	/**
	* RoundCube shared functions
	*
	* @package Core
	*/


	/**
	* Send HTTP headers to prevent caching this page
	*/
	function send_nocacheing_headers()
	{
	if (headers_sent())
	return;

	header("Expires: ".gmdate("D, d M Y H:i:s")." GMT");
	header("Last-Modified: ".gmdate("D, d M Y H:i:s")." GMT");
	header("Cache-Control: private, must-revalidate, post-check=0, pre-check=0");
	header("Pragma: no-cache");

	// We need to set the following headers to make downloads work using IE in HTTPS mode.
	if (isset($_SERVER['HTTPS'])) {
	header('Pragma: ');
	header('Cache-Control: ');
	}
	}


	/**
	* Send header with expire date 30 days in future
	*
	* @param int Expiration time in seconds
	*/
	function send_future_expire_header($offset=2600000)
	{
	if (headers_sent())
	return;

	header("Expires: ".gmdate("D, d M Y H:i:s", mktime()+$offset)." GMT");
	header("Cache-Control: max-age=$offset");
	header("Pragma: ");
	}


	/**
	* Check request for If-Modified-Since and send an according response.
	* This will terminate the current script if headers match the given values
	*
	* @param int Modified date as unix timestamp
	* @param string Etag value for caching
	*/
	function send_modified_header($mdate, $etag=null, $skip_check=false)
	{
	if (headers_sent())
	return;

	$iscached = false;
	$etag = $etag ? "\"$etag\"" : null;

	if (!$skip_check)
	{
	if ($_SERVER['HTTP_IF_MODIFIED_SINCE'] && strtotime($_SERVER['HTTP_IF_MODIFIED_SINCE']) >= $mdate)
	$iscached = true;

	if ($etag)
	$iscached = ($_SERVER['HTTP_IF_NONE_MATCH'] == $etag);
	}

	if ($iscached)
	header("HTTP/1.x 304 Not Modified");
	else
	header("Last-Modified: ".gmdate("D, d M Y H:i:s", $mdate)." GMT");

	header("Cache-Control: max-age=0");
	header("Expires: ");
	header("Pragma: ");

	if ($etag)
	header("Etag: $etag");

	if ($iscached)
	{
	ob_end_clean();
	exit;
	}
	}


	/**
	* Returns whether an $str is a reserved word for any of the version of Javascript or ECMAScript
	* @param str String to check
	* @return boolean True if $str is a reserver word, False if not
	*/
	function is_js_reserved_word($str)
	{
	return in_array($str, array(
	// ECMASript ver 4 reserved words
	'as','break','case','catch','class','const','continue',
	'default','delete','do','else','export','extends','false','finally','for','function',
	'if','import','in','instanceof','is','namespace','new','null','package','private',
	'public','return','super','switch','this','throw','true','try','typeof','use','var',
	'void','while','with',
	// ECMAScript ver 4 future reserved words
	'abstract','debugger','enum','goto','implements','interface','native','protected',
	'synchronized','throws','transient','volatile',
	// special meaning in some contexts
	'get','set',
	// were reserved in ECMAScript ver 3
	'boolean','byte','char','double','final','float','int','long','short','static'
	));
	}


	/**
	* Convert a variable into a javascript object notation
	*
	* @param mixed Input value
	* @return string Serialized JSON string
	*/
	function json_serialize($var)
	{
	if (is_object($var))
	$var = get_object_vars($var);

	if (is_array($var))
	{
	// empty array
	if (!sizeof($var))
	return '[]';
	else
	{
	$keys_arr = array_keys($var);
	$is_assoc = $have_numeric = 0;

	for ($i=0; $i<sizeof($keys_arr); ++$i)
	{
	if (is_numeric($keys_arr[$i]))
	$have_numeric = 1;
	if (!is_numeric($keys_arr[$i]) \|\| $keys_arr[$i] != $i)
	$is_assoc = 1;
	if ($is_assoc && $have_numeric)
	break;
	}

	$brackets = $is_assoc ? '{}' : '[]';
	$pairs = array();

	foreach ($var as $key => $value)
	{
	// enclose key with quotes if it is not variable-name conform
	if (!ereg("^[_a-zA-Z]{1}[_a-zA-Z0-9]*$", $key) \|\| is_js_reserved_word($key))
	$key = "'$key'";

	$pairs[] = sprintf("%s%s", $is_assoc ? "$key:" : '', json_serialize($value));
	}

	return $brackets{0} . implode(',', $pairs) . $brackets{1};
	}
	}
	else if (!is_string($var) && strval(intval($var)) === strval($var))
	return $var;
	else if (is_bool($var))
	return $var ? '1' : '0';
	else
	return "'".JQ($var)."'";

	}


	/**
	* Function to convert an array to a javascript array
	* Actually an alias function for json_serialize()
	* @deprecated
	*/
	function array2js($arr, $type='')
	{
	return json_serialize($arr);
	}


	/**
	* Similar function as in_array() but case-insensitive
	*
	* @param mixed Needle value
	* @param array Array to search in
	* @return boolean True if found, False if not
	*/
	function in_array_nocase($needle, $haystack)
	{
	$needle = rc_strtolower($needle);
	foreach ($haystack as $value)
	if ($needle===rc_strtolower($value))
	return true;

	return false;
	}


	/**
	* Find out if the string content means TRUE or FALSE
	*
	* @param string Input value
	* @return boolean Imagine what!
	*/
	function get_boolean($str)
	{
	$str = strtolower($str);
	if(in_array($str, array('false', '0', 'no', 'nein', ''), TRUE))
	return FALSE;
	else
	return TRUE;
	}


	/**
	* Parse a human readable string for a number of bytes
	*
	* @param string Input string
	* @return int Number of bytes
	*/
	function parse_bytes($str)
	{
	if (is_numeric($str))
	return intval($str);

	if (preg_match('/([0-9]+)([a-z])/i', $str, $regs))
	{
	$bytes = floatval($regs[1]);
	switch (strtolower($regs[2]))
	{
	case 'g':
	$bytes *= 1073741824;
	break;
	case 'm':
	$bytes *= 1048576;
	break;
	case 'k':
	$bytes *= 1024;
	break;
	}
	}

	return intval($bytes);
	}

	/**
	* Create a human readable string for a number of bytes
	*
	* @param int Number of bytes
	* @return string Byte string
	*/
	function show_bytes($bytes)
	{
	if ($bytes > 1073741824)
	{
	$gb = $bytes/1073741824;
	$str = sprintf($gb>=10 ? "%d " : "%.1f ", $gb) . rcube_label('GB');
	}
	else if ($bytes > 1048576)
	{
	$mb = $bytes/1048576;
	$str = sprintf($mb>=10 ? "%d " : "%.1f ", $mb) . rcube_label('MB');
	}
	else if ($bytes > 1024)
	$str = sprintf("%d ", round($bytes/1024)) . rcube_label('KB');
	else
	$str = sprintf('%d ', $bytes) . rcube_label('B');

	return $str;
	}


	/**
	* Convert paths like ../xxx to an absolute path using a base url
	*
	* @param string Relative path
	* @param string Base URL
	* @return string Absolute URL
	*/
	function make_absolute_url($path, $base_url)
	{
	$host_url = $base_url;
	$abs_path = $path;

	// check if path is an absolute URL
	if (preg_match('/^[fhtps]+:\/\//', $path))
	return $path;

	// cut base_url to the last directory
	if (strrpos($base_url, '/')>7)
	{
	$host_url = substr($base_url, 0, strpos($base_url, '/'));
	$base_url = substr($base_url, 0, strrpos($base_url, '/'));
	}

	// $path is absolute
	if ($path{0}=='/')
	$abs_path = $host_url.$path;
	else
	{
	// strip './' because its the same as ''
	$path = preg_replace('/^\.\//', '', $path);

	if (preg_match_all('/\.\.\//', $path, $matches, PREG_SET_ORDER))
	foreach ($matches as $a_match)
	{
	if (strrpos($base_url, '/'))
	$base_url = substr($base_url, 0, strrpos($base_url, '/'));

	$path = substr($path, 3);
	}

	$abs_path = $base_url.'/'.$path;
	}

	return $abs_path;
	}


	/**
	* Wrapper function for strlen
	*/
	function rc_strlen($str)
	{
	if (function_exists('mb_strlen'))
	return mb_strlen($str);
	else
	return strlen($str);
	}

	/**
	* Wrapper function for strtolower
	*/
	function rc_strtolower($str)
	{
	if (function_exists('mb_strtolower'))
	return mb_strtolower($str);
	else
	return strtolower($str);
	}

	/**
	* Wrapper function for strtoupper
	*/
	function rc_strtoupper($str)
	{
	if (function_exists('mb_strtoupper'))
	return mb_strtoupper($str);
	else
	return strtoupper($str);
	}

	/**
	* Wrapper function for substr
	*/
	function rc_substr($str, $start, $len=null)
	{
	if (function_exists('mb_substr'))
	return mb_substr($str, $start, $len);
	else
	return substr($str, $start, $len);
	}

	/**
	* Wrapper function for strpos
	*/
	function rc_strpos($haystack, $needle, $offset=0)
	{
	if (function_exists('mb_strpos'))
	return mb_strpos($haystack, $needle, $offset);
	else
	return strpos($haystack, $needle, $offset);
	}

	/**
	* Wrapper function for strrpos
	*/
	function rc_strrpos($haystack, $needle, $offset=0)
	{
	if (function_exists('mb_strrpos'))
	return mb_strrpos($haystack, $needle, $offset);
	else
	return strrpos($haystack, $needle, $offset);
	}

	+/**
	+ * Wrapper function for wordwrap
	+ */
	+function rc_wordwrap($string, $width=75, $break="\n", $cut=false)
	+{
	+ if (!function_exists('mb_substr') \|\| !function_exists('mb_strlen'))
	+ return wordwrap($string, $width, $break, $cut);
	+
	+ $para = explode($break, $string);
	+ $string = '';
	+ while (count($para)) {
	+ $list = explode(' ', array_shift($para));
	+ $len = 0;
	+ while (count($list)) {
	+ $line = array_shift($list);
	+ $l = mb_strlen($line);
	+ $newlen = $len + $l + ($len ? 1 : 0);
	+
	+ if ($newlen <= $width) {
	+ $string .= ($len ? ' ' : '').$line;
	+ $len += ($len ? 1 : 0) + $l;
	+ } else {
	+ if ($l > $width) {
	+ if ($cut) {
	+ $start = 0;
	+ while ($l) {
	+ $str = mb_substr($line, $start, $width);
	+ $strlen = mb_strlen($str);
	+ $string .= ($len ? $break : '').$str;
	+ $start += $strlen;
	+ $l -= $strlen;
	+ $len = $strlen;
	+ }
	+ } else {
	+ $string .= ($len ? $break : '').$line;
	+ if (count($list)) $string .= $break;
	+ $len = 0;
	+ }
	+ } else {
	+ $string .= $break.$line;
	+ $len = $l;
	+ }
	+ }
	+ }
	+ if (count($para)) $string .= $break;
	+ }
	+ return $string;
	+}

	/**
	* Read a specific HTTP request header
	*
	* @access static
	* @param string $name Header name
	* @return mixed Header value or null if not available
	*/
	function rc_request_header($name)
	{
	if (function_exists('getallheaders'))
	{
	$hdrs = array_change_key_case(getallheaders(), CASE_UPPER);
	$key = strtoupper($name);
	}
	else
	{
	$key = 'HTTP_' . strtoupper(strtr($name, '-', '_'));
	$hdrs = array_change_key_case($_SERVER, CASE_UPPER);
	}

	return $hdrs[$key];
	}


	/**
	* Replace the middle part of a string with ...
	* if it is longer than the allowed length
	*
	* @param string Input string
	* @param int Max. length
	* @param string Replace removed chars with this
	* @return string Abbreviated string
	*/
	function abbreviate_string($str, $maxlength, $place_holder='...')
	{
	$length = rc_strlen($str);
	$first_part_length = floor($maxlength/2) - rc_strlen($place_holder);

	if ($length > $maxlength)
	{
	$second_starting_location = $length - $maxlength + $first_part_length + 1;
	$str = rc_substr($str, 0, $first_part_length) . $place_holder . rc_substr($str, $second_starting_location, $length);
	}

	return $str;
	}


	/**
	* Make sure the string ends with a slash
	*/
	function slashify($str)
	{
	return unslashify($str).'/';
	}


	/**
	* Remove slash at the end of the string
	*/
	function unslashify($str)
	{
	return preg_replace('/\/$/', '', $str);
	}


	/**
	* Delete all files within a folder
	*
	* @param string Path to directory
	* @return boolean True on success, False if directory was not found
	*/
	function clear_directory($dir_path)
	{
	$dir = @opendir($dir_path);
	if(!$dir) return FALSE;

	while ($file = readdir($dir))
	if (strlen($file)>2)
	unlink("$dir_path/$file");

	closedir($dir);
	return TRUE;
	}


	/**
	* Create a unix timestamp with a specified offset from now
	*
	* @param string String representation of the offset (e.g. 20min, 5h, 2days)
	* @param int Factor to multiply with the offset
	* @return int Unix timestamp
	*/
	function get_offset_time($offset_str, $factor=1)
	{
	if (preg_match('/^([0-9]+)\s*([smhdw])/i', $offset_str, $regs))
	{
	$amount = (int)$regs[1];
	$unit = strtolower($regs[2]);
	}
	else
	{
	$amount = (int)$offset_str;
	$unit = 's';
	}

	$ts = mktime();
	switch ($unit)
	{
	case 'w':
	$amount *= 7;
	case 'd':
	$amount *= 24;
	case 'h':
	$amount *= 60;
	case 'm':
	$amount *= 60;
	case 's':
	$ts += $amount * $factor;
	}

	return $ts;
	}


	/**
	* A method to guess the mime_type of an attachment.
	*
	* @param string $path Path to the file.
	* @param string $name File name (with suffix)
	* @param string $failover Mime type supplied for failover.
	*
	* @return string
	* @author Till Klampaeckel <till@php.net>
	* @see http://de2.php.net/manual/en/ref.fileinfo.php
	* @see http://de2.php.net/mime_content_type
	*/
	function rc_mime_content_type($path, $name, $failover = 'application/octet-stream')
	{
	$mime_type = null;
	$mime_magic = rcmail::get_instance()->config->get('mime_magic');
	$mime_ext = @include(RCMAIL_CONFIG_DIR . '/mimetypes.php');
	$suffix = $name ? substr($name, strrpos($name, '.')+1) : '*';

	// use file name suffix with hard-coded mime-type map
	if (is_array($mime_ext)) {
	$mime_type = $mime_ext[$suffix];
	}
	// try fileinfo extension if available
	if (!$mime_type) {
	if (!extension_loaded('fileinfo')) {
	@dl('fileinfo.' . PHP_SHLIB_SUFFIX);
	}
	if (function_exists('finfo_open')) {
	if ($finfo = finfo_open(FILEINFO_MIME, $mime_magic)) {
	$mime_type = finfo_file($finfo, $path);
	finfo_close($finfo);
	}
	}
	}
	// try PHP's mime_content_type
	if (!$mime_type && function_exists('mime_content_type')) {
	$mime_type = mime_content_type($path);
	}
	// fall back to user-submitted string
	if (!$mime_type) {
	$mime_type = $failover;
	}

	return $mime_type;
	}


	/**
	* A method to guess encoding of a string.
	*
	* @param string $string String.
	* @param string $failover Default result for failover.
	*
	* @return string
	*/
	function rc_detect_encoding($string, $failover='')
	{
	if (!function_exists('mb_detect_encoding')) {
	return $failover;
	}

	// FIXME: the order is important, because sometimes
	// iso string is detected as euc-jp and etc.
	$enc = array(
	'UTF-8', 'SJIS', 'BIG5', 'GB2312',
	'ISO-8859-1', 'ISO-8859-2', 'ISO-8859-3', 'ISO-8859-4',
	'ISO-8859-5', 'ISO-8859-6', 'ISO-8859-7', 'ISO-8859-8', 'ISO-8859-9',
	'ISO-8859-10', 'ISO-8859-13', 'ISO-8859-14', 'ISO-8859-15', 'ISO-8859-16',
	'WINDOWS-1252', 'WINDOWS-1251', 'EUC-JP', 'EUC-TW', 'KOI8-R',
	'ISO-2022-KR', 'ISO-2022-JP'
	);

	$result = mb_detect_encoding($string, join(',', $enc));

	return $result ? $result : $failover;
	}


	/**
	* Explode quoted string
	*
	* @param string Delimiter expression string for preg_match()
	* @param string Input string
	*/
	function rcube_explode_quoted_string($delimiter, $string)
	{
	$result = array();
	$strlen = strlen($string);

	for ($q=$p=$i=0; $i < $strlen; $i++) {
	if ($string[$i] == "\"" && $string[$i-1] != "\\") {
	$q = $q ? false : true;
	}
	else if (!$q && preg_match("/$delimiter/", $string[$i])) {
	$result[] = substr($string, $p, $i - $p);
	$p = $i + 1;
	}
	}

	$result[] = substr($string, $p);
	return $result;
	}

	?>
	diff --git a/program/steps/mail/compose.inc b/program/steps/mail/compose.inc
	index ab25b1b8d..49c4c3011 100644
	--- a/program/steps/mail/compose.inc
	+++ b/program/steps/mail/compose.inc
	@@ -1,921 +1,921 @@
	<?php

	/*
	+-----------------------------------------------------------------------+
	\| program/steps/mail/compose.inc \|
	\| \|
	\| This file is part of the RoundCube Webmail client \|
	\| Copyright (C) 2005-2009, RoundCube Dev. - Switzerland \|
	\| Licensed under the GNU GPL \|
	\| \|
	\| PURPOSE: \|
	\| Compose a new mail message with all headers and attachments \|
	\| \|
	+-----------------------------------------------------------------------+
	\| Author: Thomas Bruederli <roundcube@gmail.com> \|
	+-----------------------------------------------------------------------+

	$Id$

	*/

	// define constants for message compose mode
	define('RCUBE_COMPOSE_REPLY', 0x0106);
	define('RCUBE_COMPOSE_FORWARD', 0x0107);
	define('RCUBE_COMPOSE_DRAFT', 0x0108);

	$MESSAGE_FORM = NULL;
	$MESSAGE = NULL;

	// Nothing below is called during message composition, only at "new/forward/reply/draft" initialization or
	// if a compose-ID is given (i.e. when the compose step is opened in a new window/tab).
	// Since there are many ways to leave the compose page improperly, it seems necessary to clean-up an old
	// compose when a "new/forward/reply/draft" is called - otherwise the old session attachments will appear

	if (!is_array($_SESSION['compose']) \|\| $_SESSION['compose']['id'] != get_input_value('_id', RCUBE_INPUT_GET))
	{
	rcmail_compose_cleanup();
	$_SESSION['compose'] = array('id' => uniqid(rand()), 'param' => array_map('strip_tags', $_GET));

	// process values like "mailto:foo@bar.com?subject=new+message&cc=another"
	if ($_SESSION['compose']['param']['_to']) {
	$mailto = explode('?', $_SESSION['compose']['param']['_to']);
	if (count($mailto) > 1) {
	$_SESSION['compose']['param']['_to'] = $mailto[0];
	parse_str($mailto[1], $query);
	foreach ($query as $f => $val)
	$_SESSION['compose']['param']["_$f"] = $val;
	}
	}

	// redirect to a unique URL with all parameters stored in session
	$OUTPUT->redirect(array('_action' => 'compose', '_id' => $_SESSION['compose']['id']));
	}

	// add some labels to client
	$OUTPUT->add_label('nosubject', 'nosenderwarning', 'norecipientwarning', 'nosubjectwarning',
	'nobodywarning', 'notsentwarning', 'savingmessage', 'sendingmessage', 'messagesaved',
	'converting', 'editorwarning', 'searching');

	// add config parameters to client script
	if (!empty($CONFIG['drafts_mbox'])) {
	$OUTPUT->set_env('drafts_mailbox', $CONFIG['drafts_mbox']);
	$OUTPUT->set_env('draft_autosave', $CONFIG['draft_autosave']);
	}
	// set current mailbox in client environment
	$OUTPUT->set_env('mailbox', $IMAP->get_mailbox_name());

	// get reference message and set compose mode
	if ($msg_uid = $_SESSION['compose']['param']['_reply_uid'])
	$compose_mode = RCUBE_COMPOSE_REPLY;
	else if ($msg_uid = $_SESSION['compose']['param']['_forward_uid'])
	$compose_mode = RCUBE_COMPOSE_FORWARD;
	else if ($msg_uid = $_SESSION['compose']['param']['_draft_uid']) {
	$RCMAIL->imap->set_mailbox($CONFIG['drafts_mbox']);
	$compose_mode = RCUBE_COMPOSE_DRAFT;
	}

	if (!empty($msg_uid))
	{
	// similar as in program/steps/mail/show.inc
	$MESSAGE = new rcube_message($msg_uid);

	if (!empty($MESSAGE->headers->charset))
	$IMAP->set_charset($MESSAGE->headers->charset);

	if ($compose_mode == RCUBE_COMPOSE_REPLY)
	{
	$_SESSION['compose']['reply_uid'] = $msg_uid;
	$_SESSION['compose']['reply_msgid'] = $MESSAGE->headers->messageID;
	$_SESSION['compose']['references'] = trim($MESSAGE->headers->references . " " . $MESSAGE->headers->messageID);

	if (!empty($_SESSION['compose']['param']['_all']))
	$MESSAGE->reply_all = 1;
	}
	else if ($compose_mode == RCUBE_COMPOSE_DRAFT)
	{
	if($MESSAGE->headers->in_reply_to)
	{
	// TODO: how to get reply_uid/forward_uid value, maybe we must set X-Reply-UID/X-Forward-UID
	// $_SESSION['compose']['reply_uid'] = ?
	// $_SESSION['compose']['forward_uid'] = ?
	$_SESSION['compose']['reply_msgid'] = '<'.$MESSAGE->headers->in_reply_to.'>';
	}
	$_SESSION['compose']['references'] = $MESSAGE->headers->references;
	}
	else if ($compose_mode == RCUBE_COMPOSE_FORWARD)
	{
	$_SESSION['compose']['forward_uid'] = $msg_uid;
	}
	}

	/**** compose mode functions ******/


	function rcmail_compose_headers($attrib)
	{
	global $IMAP, $MESSAGE, $DB, $compose_mode;
	static $sa_recipients = array();

	list($form_start, $form_end) = get_form_tags($attrib);

	$out = '';
	$part = strtolower($attrib['part']);

	switch ($part)
	{
	case 'from':
	return rcmail_compose_header_from($attrib);

	case 'to':
	$fname = '_to';
	$header = 'to';

	// we have a set of recipients stored is session
	if (($mailto_id = $_SESSION['compose']['param']['_mailto']) && $_SESSION['mailto'][$mailto_id])
	$fvalue = urldecode($_SESSION['mailto'][$mailto_id]);

	case 'cc':
	if (!$fname)
	{
	$fname = '_cc';
	$header = 'cc';
	}
	case 'bcc':
	if (!$fname)
	{
	$fname = '_bcc';
	$header = 'bcc';
	}

	$allow_attrib = array('id', 'class', 'style', 'cols', 'rows', 'tabindex');
	$field_type = 'html_textarea';
	break;

	case 'replyto':
	case 'reply-to':
	$fname = '_replyto';
	$allow_attrib = array('id', 'class', 'style', 'size', 'tabindex');
	$field_type = 'html_inputfield';
	break;
	}

	if ($fname && !empty($_POST[$fname]))
	$fvalue = get_input_value($fname, RCUBE_INPUT_POST, TRUE);
	else if ($fname && !$fvalue && !empty($_SESSION['compose']['param'][$fname]))
	$fvalue = $_SESSION['compose']['param'][$fname];

	else if ($header && $compose_mode == RCUBE_COMPOSE_REPLY)
	{
	// get recipent address(es) out of the message headers
	if ($header=='to' && !empty($MESSAGE->headers->replyto))
	$fvalue = $MESSAGE->headers->replyto;

	else if ($header=='to' && !empty($MESSAGE->headers->from))
	$fvalue = $MESSAGE->headers->from;

	// add recipent of original message if reply to all
	else if ($header=='cc' && !empty($MESSAGE->reply_all))
	{
	if ($v = $MESSAGE->headers->to)
	$fvalue .= $v;

	if ($v = $MESSAGE->headers->cc)
	$fvalue .= (!empty($fvalue) ? ', ' : '') . $v;
	}

	// split recipients and put them back together in a unique way
	if (!empty($fvalue))
	{
	$to_addresses = $IMAP->decode_address_list($fvalue);
	$fvalue = '';

	foreach ($to_addresses as $addr_part)
	{
	if (!empty($addr_part['mailto'])
	&& !in_array($addr_part['mailto'], $sa_recipients)
	&& (!$MESSAGE->compose_from
	\|\| !in_array_nocase($addr_part['mailto'], $MESSAGE->compose_from)
	\|\| (count($to_addresses)==1 && $header=='to'))) // allow reply to yourself
	{
	$fvalue .= (strlen($fvalue) ? ', ':'').$addr_part['string'];
	$sa_recipients[] = $addr_part['mailto'];
	}
	}
	}
	}
	else if ($header && $compose_mode == RCUBE_COMPOSE_DRAFT)
	{
	// get drafted headers
	if ($header=='to' && !empty($MESSAGE->headers->to))
	$fvalue = $MESSAGE->get_header('to');

	if ($header=='cc' && !empty($MESSAGE->headers->cc))
	$fvalue = $MESSAGE->get_header('cc');

	if ($header=='bcc' && !empty($MESSAGE->headers->bcc))
	$fvalue = $MESSAGE->get_header('bcc');
	}


	if ($fname && $field_type)
	{
	// pass the following attributes to the form class
	$field_attrib = array('name' => $fname, 'spellcheck' => 'false');
	foreach ($attrib as $attr => $value)
	if (in_array($attr, $allow_attrib))
	$field_attrib[$attr] = $value;

	// create teaxtarea object
	$input = new $field_type($field_attrib);
	$out = $input->show($fvalue);
	}

	if ($form_start)
	$out = $form_start.$out;

	return $out;
	}



	function rcmail_compose_header_from($attrib)
	{
	global $IMAP, $MESSAGE, $DB, $USER, $OUTPUT, $compose_mode;

	// pass the following attributes to the form class
	$field_attrib = array('name' => '_from');
	foreach ($attrib as $attr => $value)
	if (in_array($attr, array('id', 'class', 'style', 'size', 'tabindex')))
	$field_attrib[$attr] = $value;

	// extract all recipients of the reply-message
	$a_recipients = array();
	if ($compose_mode == RCUBE_COMPOSE_REPLY && is_object($MESSAGE->headers))
	{
	$MESSAGE->compose_from = array();

	$a_to = $IMAP->decode_address_list($MESSAGE->headers->to);
	foreach ($a_to as $addr)
	{
	if (!empty($addr['mailto']))
	$a_recipients[] = rc_strtolower($addr['mailto']);
	}

	if (!empty($MESSAGE->headers->cc))
	{
	$a_cc = $IMAP->decode_address_list($MESSAGE->headers->cc);
	foreach ($a_cc as $addr)
	{
	if (!empty($addr['mailto']))
	$a_recipients[] = rc_strtolower($addr['mailto']);
	}
	}
	}

	// get this user's identities
	$sql_result = $USER->list_identities();

	if ($DB->num_rows($sql_result))
	{
	$from_id = 0;
	$a_signatures = array();

	$field_attrib['onchange'] = JS_OBJECT_NAME.".change_identity(this)";
	$select_from = new html_select($field_attrib);

	while ($sql_arr = $DB->fetch_assoc($sql_result))
	{
	$identity_id = $sql_arr['identity_id'];
	$select_from->add(format_email_recipient($sql_arr['email'], $sql_arr['name']), $identity_id);

	// add signature to array
	if (!empty($sql_arr['signature']))
	{
	$a_signatures[$identity_id]['text'] = $sql_arr['signature'];
	$a_signatures[$identity_id]['is_html'] = ($sql_arr['html_signature'] == 1) ? true : false;
	if ($a_signatures[$identity_id]['is_html'])
	{
	$h2t = new html2text($a_signatures[$identity_id]['text'], false, false);
	$a_signatures[$identity_id]['plain_text'] = trim($h2t->get_text());
	}
	}

	if ($compose_mode == RCUBE_COMPOSE_REPLY && is_array($MESSAGE->compose_from))
	$MESSAGE->compose_from[] = $sql_arr['email'];

	if (empty($_POST['_from']))
	{
	// set draft's identity
	if ($compose_mode == RCUBE_COMPOSE_DRAFT && strstr($MESSAGE->headers->from, $sql_arr['email']))
	$from_id = $sql_arr['identity_id'];
	// set identity if it's one of the reply-message recipients (with prio for default identity)
	else if (in_array(rc_strtolower($sql_arr['email']), $a_recipients) && (empty($from_id) \|\| $sql_arr['standard']))
	$from_id = $sql_arr['identity_id'];
	}
	}

	// overwrite identity selection with post parameter
	if (!empty($_POST['_from']))
	$from_id = get_input_value('_from', RCUBE_INPUT_POST);

	$out = $select_from->show($from_id);

	// add signatures to client
	$OUTPUT->set_env('signatures', $a_signatures);
	}
	else
	{
	$input_from = new html_inputfield($field_attrib);
	$out = $input_from->show($_POST['_from']);
	}

	if ($form_start)
	$out = $form_start.$out;

	return $out;
	}


	function rcmail_compose_body($attrib)
	{
	global $RCMAIL, $CONFIG, $OUTPUT, $MESSAGE, $compose_mode;

	list($form_start, $form_end) = get_form_tags($attrib);
	unset($attrib['form']);

	if (empty($attrib['id']))
	$attrib['id'] = 'rcmComposeMessage';

	$attrib['name'] = '_message';

	if ($CONFIG['htmleditor'])
	$isHtml = true;
	else
	$isHtml = false;

	$body = '';

	// use posted message body
	if (!empty($_POST['_message']))
	{
	$body = get_input_value('_message', RCUBE_INPUT_POST, true);
	}
	else if ($compose_mode)
	{
	if ($isHtml && $MESSAGE->has_html_part())
	{
	$body = $MESSAGE->first_html_part();
	$isHtml = true;
	}
	else
	{
	$body = $MESSAGE->first_text_part();
	$isHtml = false;
	}

	// compose reply-body
	if ($compose_mode == RCUBE_COMPOSE_REPLY)
	$body = rcmail_create_reply_body($body, $isHtml);
	// forward message body inline
	else if ($compose_mode == RCUBE_COMPOSE_FORWARD)
	$body = rcmail_create_forward_body($body, $isHtml);
	// load draft message body
	else if ($compose_mode == RCUBE_COMPOSE_DRAFT)
	$body = rcmail_create_draft_body($body, $isHtml);
	}
	else if (!empty($_SESSION['compose']['param']['_body']))
	{
	$body = $_SESSION['compose']['param']['_body'];
	}

	$out = $form_start ? "$form_start\n" : '';

	$saveid = new html_hiddenfield(array('name' => '_draft_saveid', 'value' => $compose_mode==RCUBE_COMPOSE_DRAFT ? str_replace(array('<','>'), "", $MESSAGE->headers->messageID) : ''));
	$out .= $saveid->show();

	$drafttoggle = new html_hiddenfield(array('name' => '_draft', 'value' => 'yes'));
	$out .= $drafttoggle->show();

	$msgtype = new html_hiddenfield(array('name' => '_is_html', 'value' => ($isHtml?"1":"0")));
	$out .= $msgtype->show();

	// If desired, set this textarea to be editable by TinyMCE
	if ($isHtml) $attrib['class'] = 'mce_editor';
	$textarea = new html_textarea($attrib);
	$out .= $textarea->show($body);
	$out .= $form_end ? "\n$form_end" : '';

	// include HTML editor
	rcube_html_editor();

	// include GoogieSpell
	if (!empty($CONFIG['enable_spellcheck'])) {

	$lang = strtolower(substr($_SESSION['language'], 0, 2));

	$spellcheck_langs = (array)$RCMAIL->config->get('spellcheck_languages', array('da'=>'Dansk', 'de'=>'Deutsch', 'en' => 'English', 'es'=>'Español', 'fr'=>'Français', 'it'=>'Italiano', 'nl'=>'Nederlands', 'pl'=>'Polski', 'pt'=>'Português', 'fi'=>'Suomi', 'sv'=>'Svenska'));
	if (!$spellcheck_langs[$lang])
	$lang = 'en';

	$editor_lang_set = array();
	foreach ($spellcheck_langs as $key => $name) {
	$editor_lang_set[] = ($key == $lang ? '+' : '') . JQ($name).'='.JQ($key);
	}

	$OUTPUT->include_script('googiespell.js');
	$OUTPUT->add_script(sprintf(
	"var googie = new GoogieSpell('\$__skin_path/images/googiespell/','%s&_action=spell&lang=');\n".
	"googie.lang_chck_spell = \"%s\";\n".
	"googie.lang_rsm_edt = \"%s\";\n".
	"googie.lang_close = \"%s\";\n".
	"googie.lang_revert = \"%s\";\n".
	"googie.lang_no_error_found = \"%s\";\n".
	"googie.setLanguages(%s);\n".
	"googie.setCurrentLanguage('%s');\n".
	"googie.decorateTextarea('%s');\n".
	"%s.set_env('spellcheck', googie);",
	$RCMAIL->comm_path,
	JQ(Q(rcube_label('checkspelling'))),
	JQ(Q(rcube_label('resumeediting'))),
	JQ(Q(rcube_label('close'))),
	JQ(Q(rcube_label('revertto'))),
	JQ(Q(rcube_label('nospellerrors'))),
	json_serialize($spellcheck_langs),
	$lang,
	$attrib['id'],
	JS_OBJECT_NAME), 'foot');

	$OUTPUT->add_label('checking');
	$OUTPUT->set_env('spellcheck_langs', join(',', $editor_lang_set));
	}

	$out .= "\n".'<iframe name="savetarget" src="program/blank.gif" style="width:0;height:0;border:none;visibility:hidden;"></iframe>';

	return $out;
	}


	function rcmail_create_reply_body($body, $bodyIsHtml)
	{
	global $IMAP, $MESSAGE, $OUTPUT;

	if (! $bodyIsHtml)
	{
	// try to remove the signature
	if (($sp = strrpos($body, '-- ')) !== false && ($sp == 0 \|\| $body{$sp-1} == "\n"))
	{
	if ($body{$sp+3}==' ' \|\| $body{$sp+3}=="\n" \|\| $body{$sp+3}=="\r")
	$body = substr($body, 0, max(0, $sp-1));
	}

	// soft-wrap message first
	$body = rcmail_wrap_quoted($body, 75);

	$body = rtrim($body, "\r\n");

	if ($body) {
	// split body into single lines
	$a_lines = preg_split('/\r?\n/', $body);

	// add > to each line
	for($n=0; $n<sizeof($a_lines); $n++) {
	if (strpos($a_lines[$n], '>')===0)
	$a_lines[$n] = '>'.$a_lines[$n];
	else
	$a_lines[$n] = '> '.$a_lines[$n];
	}

	$body = join("\n", $a_lines);
	}

	// add title line(s)
	- $prefix = wordwrap(sprintf("On %s, %s wrote:\n",
	+ $prefix = rc_wordwrap(sprintf("On %s, %s wrote:\n",
	$MESSAGE->headers->date,
	$MESSAGE->get_header('from')), 76);

	$suffix = '';
	}
	else
	{
	// save inline images to files
	$cid_map = rcmail_write_inline_attachments($MESSAGE);
	// set is_safe flag (we need this for html body washing)
	rcmail_check_safe($MESSAGE);
	// clean up html tags
	$body = rcmail_wash_html($body, array('safe' => $MESSAGE->is_safe), $cid_map);

	// build reply (quote content)
	$prefix = sprintf("On %s, %s wrote:<br />\n",
	$MESSAGE->headers->date,
	htmlspecialchars(Q($MESSAGE->get_header('from'), 'replace'), ENT_COMPAT, $OUTPUT->get_charset()));
	$prefix .= '<blockquote type="cite" style="padding-left:5px; border-left:#1010ff 2px solid; margin-left:5px; width:100%">';
	$suffix = "</blockquote><p></p>";
	}

	return $prefix.$body.$suffix;
	}


	function rcmail_create_forward_body($body, $bodyIsHtml)
	{
	global $IMAP, $MESSAGE, $OUTPUT;

	// add attachments
	if (!isset($_SESSION['compose']['forward_attachments']) && is_array($MESSAGE->mime_parts))
	$cid_map = rcmail_write_compose_attachments($MESSAGE, $bodyIsHtml);

	if (!$bodyIsHtml)
	{
	$prefix = "\n\n\n-------- Original Message --------\n";
	$prefix .= 'Subject: ' . $MESSAGE->subject . "\n";
	$prefix .= 'Date: ' . $MESSAGE->headers->date . "\n";
	$prefix .= 'From: ' . $MESSAGE->get_header('from') . "\n";
	$prefix .= 'To: ' . $MESSAGE->get_header('to') . "\n";
	if ($MESSAGE->headers->replyto && $MESSAGE->headers->replyto != $MESSAGE->headers->from)
	$prefix .= 'Reply-To: ' . $MESSAGE->get_header('replyto') . "\n";
	$prefix .= "\n";
	}
	else
	{
	// set is_safe flag (we need this for html body washing)
	rcmail_check_safe($MESSAGE);
	// clean up html tags
	$body = rcmail_wash_html($body, array('safe' => $MESSAGE->is_safe), $cid_map);

	$prefix = sprintf(
	"<br><br>-------- Original Message --------" .
	"<table border=\"0\" cellpadding=\"0\" cellspacing=\"0\"><tbody>" .
	"<tr><th align=\"right\" nowrap=\"nowrap\" valign=\"baseline\">Subject: </th><td>%s</td></tr>" .
	"<tr><th align=\"right\" nowrap=\"nowrap\" valign=\"baseline\">Date: </th><td>%s</td></tr>" .
	"<tr><th align=\"right\" nowrap=\"nowrap\" valign=\"baseline\">From: </th><td>%s</td></tr>" .
	"<tr><th align=\"right\" nowrap=\"nowrap\" valign=\"baseline\">To: </th><td>%s</td></tr>",
	Q($MESSAGE->subject),
	Q($MESSAGE->headers->date),
	htmlspecialchars(Q($MESSAGE->get_header('from'), 'replace'), ENT_COMPAT, $OUTPUT->get_charset(), true),
	htmlspecialchars(Q($MESSAGE->get_header('to'), 'replace'), ENT_COMPAT, $OUTPUT->get_charset(), true));

	if ($MESSAGE->headers->replyto && $MESSAGE->headers->replyto != $MESSAGE->headers->from)
	$prefix .= sprintf("<tr><th align=\"right\" nowrap=\"nowrap\" valign=\"baseline\">Reply-To: </th><td>%s</td></tr>",
	htmlspecialchars(Q($MESSAGE->get_header('replyto'), 'replace'), ENT_COMPAT, $OUTPUT->get_charset(), true));

	$prefix .= "</tbody></table><br>";
	}

	return $prefix.$body;
	}


	function rcmail_create_draft_body($body, $bodyIsHtml)
	{
	global $MESSAGE, $OUTPUT;

	/**
	* add attachments
	* sizeof($MESSAGE->mime_parts can be 1 - e.g. attachment, but no text!
	*/
	if (!isset($_SESSION['compose']['forward_attachments'])
	&& is_array($MESSAGE->mime_parts)
	&& count($MESSAGE->mime_parts) > 0)
	{
	$cid_map = rcmail_write_compose_attachments($MESSAGE, $bodyIsHtml);

	// replace cid with href in inline images links
	if ($cid_map)
	$body = str_replace(array_keys($cid_map), array_values($cid_map), $body);
	}

	return $body;
	}


	function rcmail_write_compose_attachments(&$message, $bodyIsHtml)
	{
	global $OUTPUT;

	$cid_map = array();
	$id = 0;

	foreach ((array)$message->mime_parts as $pid => $part)
	{
	if (($part->ctype_primary != 'message' \|\| !$bodyIsHtml) &&
	($part->disposition=='attachment' \|\| $part->disposition=='inline' \|\| $part->headers['content-id']
	\|\| (empty($part->disposition) && $part->filename)))
	{
	if ($attachment = rcmail_save_attachment($message, $pid)) {
	$_SESSION['compose']['attachments'][$id] = $attachment;
	if ($bodyIsHtml && $part->filename && $part->content_id) {
	$cid_map['cid:'.$part->content_id] =
	$OUTPUT->app->comm_path.'&_action=display-attachment&_file=rcmfile'.$id;
	}
	$id++;
	}
	}
	}

	$_SESSION['compose']['forward_attachments'] = true;

	return $cid_map;
	}


	function rcmail_write_inline_attachments(&$message)
	{
	global $OUTPUT;

	$cid_map = array();
	$id = 0;

	foreach ((array)$message->mime_parts as $pid => $part) {
	if ($part->content_id && $part->filename) {
	if ($attachment = rcmail_save_attachment($message, $pid)) {
	$_SESSION['compose']['attachments'][$id] = $attachment;
	$cid_map['cid:'.$part->content_id] =
	$OUTPUT->app->comm_path.'&_action=display-attachment&_file=rcmfile'.$id;
	$id++;
	}
	}
	}

	return $cid_map;
	}

	function rcmail_save_attachment(&$message, $pid)
	{
	global $RCMAIL;

	$temp_dir = unslashify($RCMAIL->config->get('temp_dir'));
	$tmp_path = tempnam($temp_dir, 'rcmAttmnt');
	$part = $message->mime_parts[$pid];

	if ($fp = fopen($tmp_path, 'w'))
	{
	$message->get_part_content($pid, $fp);
	fclose($fp);

	return array(
	'mimetype' => $part->ctype_primary . '/' . $part->ctype_secondary,
	'name' => $part->filename,
	'path' => $tmp_path,
	'content_id' => $part->content_id
	);
	}
	}


	function rcmail_compose_subject($attrib)
	{
	global $MESSAGE, $compose_mode;

	list($form_start, $form_end) = get_form_tags($attrib);
	unset($attrib['form']);

	$attrib['name'] = '_subject';
	$attrib['spellcheck'] = 'true';
	$textfield = new html_inputfield($attrib);

	$subject = '';

	// use subject from post
	if (isset($_POST['_subject'])) {
	$subject = get_input_value('_subject', RCUBE_INPUT_POST, TRUE);
	}
	// create a reply-subject
	else if ($compose_mode == RCUBE_COMPOSE_REPLY) {
	if (eregi('^re:', $MESSAGE->subject))
	$subject = $MESSAGE->subject;
	else
	$subject = 'Re: '.$MESSAGE->subject;
	}
	// create a forward-subject
	else if ($compose_mode == RCUBE_COMPOSE_FORWARD) {
	if (eregi('^fwd:', $MESSAGE->subject))
	$subject = $MESSAGE->subject;
	else
	$subject = 'Fwd: '.$MESSAGE->subject;
	}
	// creeate a draft-subject
	else if ($compose_mode == RCUBE_COMPOSE_DRAFT) {
	$subject = $MESSAGE->subject;
	}
	else if (!empty($_SESSION['compose']['param']['_subject'])) {
	$subject = $_SESSION['compose']['param']['_subject'];
	}

	$out = $form_start ? "$form_start\n" : '';
	$out .= $textfield->show($subject);
	$out .= $form_end ? "\n$form_end" : '';

	return $out;
	}


	function rcmail_compose_attachment_list($attrib)
	{
	global $OUTPUT, $CONFIG;

	// add ID if not given
	if (!$attrib['id'])
	$attrib['id'] = 'rcmAttachmentList';

	$out = "\n";

	if (is_array($_SESSION['compose']['attachments']))
	{
	if ($attrib['deleteicon'])
	$button = html::img(array(
	'src' => $CONFIG['skin_path'] . $attrib['deleteicon'],
	'alt' => rcube_label('delete'),
	'style' => "padding-right:2px;vertical-align:middle"));
	else
	$button = Q(rcube_label('delete'));

	foreach ($_SESSION['compose']['attachments'] as $id => $a_prop)
	{
	if (empty($a_prop))
	continue;

	$out .= html::tag('li', array('id' => "rcmfile".$id),
	html::a(array(
	'href' => "#delete",
	'title' => rcube_label('delete'),
	'onclick' => sprintf("return %s.command('remove-attachment','rcmfile%d', this)", JS_OBJECT_NAME, $id)),
	$button) . Q($a_prop['name']));
	}
	}

	$OUTPUT->add_gui_object('attachmentlist', $attrib['id']);

	return html::tag('ul', $attrib, $out, html::$common_attrib);
	}


	function rcmail_compose_attachment_form($attrib)
	{
	global $OUTPUT;

	// add ID if not given
	if (!$attrib['id'])
	$attrib['id'] = 'rcmUploadbox';

	$button = new html_inputfield(array('type' => 'button', 'class' => 'button'));

	$out = html::div($attrib,
	$OUTPUT->form_tag(array('name' => 'form', 'method' => 'post', 'enctype' => 'multipart/form-data'),
	html::div(null, rcmail_compose_attachment_field(array())) .
	html::div('hint', rcube_label(array('name' => 'maxuploadsize', 'vars' => array('size' => show_bytes(parse_bytes(ini_get('upload_max_filesize'))))))) .
	html::div('buttons',
	$button->show(rcube_label('close'), array('onclick' => "document.getElementById('$attrib[id]').style.visibility='hidden'")) . ' ' .
	$button->show(rcube_label('upload'), array('onclick' => JS_OBJECT_NAME . ".command('send-attachment', this.form)"))
	)
	)
	);

	$OUTPUT->add_gui_object('uploadbox', $attrib['id']);
	return $out;
	}


	function rcmail_compose_attachment_field($attrib)
	{
	$attrib['type'] = 'file';
	$attrib['name'] = '_attachments[]';
	$field = new html_inputfield($attrib);
	return $field->show();
	}


	function rcmail_priority_selector($attrib)
	{
	global $MESSAGE;

	list($form_start, $form_end) = get_form_tags($attrib);
	unset($attrib['form']);

	$attrib['name'] = '_priority';
	$selector = new html_select($attrib);

	$selector->add(array(rcube_label('lowest'),
	rcube_label('low'),
	rcube_label('normal'),
	rcube_label('high'),
	rcube_label('highest')),
	array(5, 4, 0, 2, 1));

	$sel = isset($_POST['_priority']) ? $_POST['_priority'] : intval($MESSAGE->headers->priority);

	$out = $form_start ? "$form_start\n" : '';
	$out .= $selector->show($sel);
	$out .= $form_end ? "\n$form_end" : '';

	return $out;
	}


	function rcmail_receipt_checkbox($attrib)
	{
	global $MESSAGE, $compose_mode;

	list($form_start, $form_end) = get_form_tags($attrib);
	unset($attrib['form']);

	if (!isset($attrib['id']))
	$attrib['id'] = 'receipt';

	$attrib['name'] = '_receipt';
	$attrib['value'] = '1';
	$checkbox = new html_checkbox($attrib);

	$out = $form_start ? "$form_start\n" : '';
	$out .= $checkbox->show(
	$compose_mode == RCUBE_COMPOSE_DRAFT && $MESSAGE->headers->mdn_to ? 1 : 0);
	$out .= $form_end ? "\n$form_end" : '';

	return $out;
	}


	function rcmail_editor_selector($attrib)
	{
	global $CONFIG, $MESSAGE, $compose_mode;

	$choices = array(
	'html' => 'htmltoggle',
	'plain' => 'plaintoggle'
	);

	// determine whether HTML or plain text should be checked
	$useHtml = $CONFIG['htmleditor'] ? true : false;

	if ($compose_mode)
	$useHtml = ($useHtml && $MESSAGE->has_html_part());

	$editorid = empty($attrib['editorid']) ? 'rcmComposeMessage' : $attrib['editorid'];

	$selector = '';
	$chosenvalue = $useHtml ? 'html' : 'plain';
	$radio = new html_radiobutton(array('name' => '_editorSelect',
	'onclick' => "return rcmail_toggle_editor(this.value=='html', '$editorid', '_is_html')"));

	foreach ($choices as $value => $text)
	{
	$attrib['id'] = '_' . $value;
	$attrib['value'] = $value;
	$selector .= $radio->show($chosenvalue, $attrib) . html::label($attrib['id'], Q(rcube_label($text)));
	}

	return $selector;
	}


	function rcmail_store_target_selection($attrib)
	{
	$attrib['name'] = '_store_target';
	$select = rcmail_mailbox_select(array_merge($attrib, array('noselection' => '- '.rcube_label('dontsave').' -')));
	return $select->show(rcmail::get_instance()->config->get('sent_mbox'), $attrib);
	}


	function get_form_tags($attrib)
	{
	global $RCMAIL, $MESSAGE_FORM;

	$form_start = '';
	if (!strlen($MESSAGE_FORM))
	{
	$hiddenfields = new html_hiddenfield(array('name' => '_task', 'value' => $RCMAIL->task));
	$hiddenfields->add(array('name' => '_action', 'value' => 'send'));

	$form_start = empty($attrib['form']) ? $RCMAIL->output->form_tag(array('name' => "form", 'method' => "post")) : '';
	$form_start .= $hiddenfields->show();
	}

	$form_end = (strlen($MESSAGE_FORM) && !strlen($attrib['form'])) ? '</form>' : '';
	$form_name = !empty($attrib['form']) ? $attrib['form'] : 'form';

	if (!strlen($MESSAGE_FORM))
	$RCMAIL->output->add_gui_object('messageform', $form_name);

	$MESSAGE_FORM = $form_name;

	return array($form_start, $form_end);
	}


	// register UI objects
	$OUTPUT->add_handlers(array(
	'composeheaders' => 'rcmail_compose_headers',
	'composesubject' => 'rcmail_compose_subject',
	'composebody' => 'rcmail_compose_body',
	'composeattachmentlist' => 'rcmail_compose_attachment_list',
	'composeattachmentform' => 'rcmail_compose_attachment_form',
	'composeattachment' => 'rcmail_compose_attachment_field',
	'priorityselector' => 'rcmail_priority_selector',
	'editorselector' => 'rcmail_editor_selector',
	'receiptcheckbox' => 'rcmail_receipt_checkbox',
	'storetarget' => 'rcmail_store_target_selection',
	));

	$OUTPUT->send('compose');

	?>
	diff --git a/program/steps/mail/func.inc b/program/steps/mail/func.inc
	index 79e148d8a..a76532cb9 100644
	--- a/program/steps/mail/func.inc
	+++ b/program/steps/mail/func.inc
	@@ -1,1455 +1,1455 @@
	<?php

	/*
	+-----------------------------------------------------------------------+
	\| program/steps/mail/func.inc \|
	\| \|
	\| This file is part of the RoundCube Webmail client \|
	\| Copyright (C) 2005-2009, RoundCube Dev. - Switzerland \|
	\| Licensed under the GNU GPL \|
	\| \|
	\| PURPOSE: \|
	\| Provide webmail functionality and GUI objects \|
	\| \|
	+-----------------------------------------------------------------------+
	\| Author: Thomas Bruederli <roundcube@gmail.com> \|
	+-----------------------------------------------------------------------+

	$Id$

	*/

	require_once('include/rcube_smtp.inc');

	$EMAIL_ADDRESS_PATTERN = '([a-z0-9][a-z0-9\-\.\+\_]@[a-z0-9]([a-z0-9\-][.]?)[a-z0-9]\\.[a-z]{2,5})';

	// actions that do not require imap connection
	$NOIMAP_ACTIONS = array('spell', 'addcontact', 'autocomplete', 'upload', 'display-attachment', 'remove-attachment');


	// log in to imap server
	if (!in_array($RCMAIL->action, $NOIMAP_ACTIONS) && !$RCMAIL->imap_connect()) {
	$RCMAIL->kill_session();

	if ($OUTPUT->ajax_call)
	$OUTPUT->redirect(array(), 2000);

	$OUTPUT->set_env('task', 'login');
	$OUTPUT->send('login');
	}


	// set imap properties and session vars
	if ($mbox = get_input_value('_mbox', RCUBE_INPUT_GPC))
	$IMAP->set_mailbox(($_SESSION['mbox'] = $mbox));
	else
	$_SESSION['mbox'] = $IMAP->get_mailbox_name();

	if (!empty($_GET['_page']))
	$IMAP->set_page(($_SESSION['page'] = intval($_GET['_page'])));

	// set default sort col/order to session
	if (!isset($_SESSION['sort_col']))
	$_SESSION['sort_col'] = $CONFIG['message_sort_col'];
	if (!isset($_SESSION['sort_order']))
	$_SESSION['sort_order'] = $CONFIG['message_sort_order'];

	// set message set for search result
	if (!empty($_REQUEST['_search']) && isset($_SESSION['search'][$_REQUEST['_search']]))
	{
	$IMAP->set_search_set($_SESSION['search'][$_REQUEST['_search']]);
	$OUTPUT->set_env('search_request', $_REQUEST['_search']);
	$OUTPUT->set_env('search_text', $_SESSION['last_text_search']);
	}

	// set main env variables, labels and page title
	if (empty($RCMAIL->action) \|\| $RCMAIL->action == 'list')
	{
	$mbox_name = $IMAP->get_mailbox_name();

	if (empty($RCMAIL->action))
	{
	// initialize searching result if search_filter is used
	if ($_SESSION['search_filter'] && $_SESSION['search_filter'] != 'ALL')
	{
	$search_request = md5($mbox_name.$_SESSION['search_filter']);

	$IMAP->search($mbox_name, $_SESSION['search_filter'], RCMAIL_CHARSET, $_SESSION['sort_col']);
	$_SESSION['search'][$search_request] = $IMAP->get_search_set();
	$OUTPUT->set_env('search_request', $search_request);
	}

	// make sure the message count is refreshed (for default view)
	$IMAP->messagecount($mbox_name, 'ALL', true);
	}

	// set current mailbox in client environment
	$OUTPUT->set_env('mailbox', $mbox_name);
	$OUTPUT->set_env('quota', $IMAP->get_capability('quota'));
	$OUTPUT->set_env('delimiter', $IMAP->get_hierarchy_delimiter());

	if ($CONFIG['trash_mbox'])
	$OUTPUT->set_env('trash_mailbox', $CONFIG['trash_mbox']);
	if ($CONFIG['drafts_mbox'])
	$OUTPUT->set_env('drafts_mailbox', $CONFIG['drafts_mbox']);
	if ($CONFIG['junk_mbox'])
	$OUTPUT->set_env('junk_mailbox', $CONFIG['junk_mbox']);

	if (!$OUTPUT->ajax_call)
	$OUTPUT->add_label('checkingmail', 'deletemessage', 'movemessagetotrash', 'movingmessage');

	$OUTPUT->set_pagetitle(rcmail_localize_foldername($mbox_name));
	}


	/**
	* return the message list as HTML table
	*/
	function rcmail_message_list($attrib)
	{
	global $IMAP, $CONFIG, $COMM_PATH, $OUTPUT;

	$skin_path = $CONFIG['skin_path'];
	$image_tag = '<img src="%s%s" alt="%s" />';

	// check to see if we have some settings for sorting
	$sort_col = $_SESSION['sort_col'];
	$sort_order = $_SESSION['sort_order'];

	// add some labels to client
	$OUTPUT->add_label('from', 'to');

	// get message headers
	$a_headers = $IMAP->list_headers('', '', $sort_col, $sort_order);

	// add id to message list table if not specified
	if (!strlen($attrib['id']))
	$attrib['id'] = 'rcubemessagelist';

	// allow the following attributes to be added to the <table> tag
	$attrib_str = create_attrib_string($attrib, array('style', 'class', 'id', 'cellpadding', 'cellspacing', 'border', 'summary'));

	$out = '<table' . $attrib_str . ">\n";

	// define list of cols to be displayed based on parameter or config
	if (empty($attrib['columns']))
	$a_show_cols = is_array($CONFIG['list_cols']) ? $CONFIG['list_cols'] : array('subject');
	else
	$a_show_cols = preg_split('/[\s,;]+/', strip_quotes($attrib['columns']));

	// store column list in a session-variable
	$_SESSION['list_columns'] = $a_show_cols;

	// define sortable columns
	$a_sort_cols = array('subject', 'date', 'from', 'to', 'size');

	$mbox = $IMAP->get_mailbox_name();

	// show 'to' instead of from in sent messages
	if (($mbox==$CONFIG['sent_mbox'] \|\| $mbox==$CONFIG['drafts_mbox']) && ($f = array_search('from', $a_show_cols))
	&& !array_search('to', $a_show_cols))
	$a_show_cols[$f] = 'to';

	// add col definition
	$out .= '<colgroup>';
	$out .= '<col class="icon" />';

	foreach ($a_show_cols as $col)
	$out .= ($col!='attachment') ? sprintf('<col class="%s" />', $col) : '<col class="icon" />';

	$out .= "</colgroup>\n";

	// add table title
	$out .= "<thead><tr>\n<td class=\"icon\"> </td>\n";

	$javascript = '';
	foreach ($a_show_cols as $col)
	{
	// get column name
	switch ($col)
	{
	case 'flag':
	$col_name = sprintf($image_tag, $skin_path, $attrib['unflaggedicon'], '');
	break;
	case 'attachment':
	$col_name = sprintf($image_tag, $skin_path, $attrib['attachmenticon'], '');
	break;
	default:
	$col_name = Q(rcube_label($col));
	}

	// make sort links
	$sort = '';
	if (in_array($col, $a_sort_cols))
	{
	// have buttons configured
	if (!empty($attrib['sortdescbutton']) \|\| !empty($attrib['sortascbutton']))
	{
	$sort = '  ';

	// asc link
	if (!empty($attrib['sortascbutton']))
	{
	$sort .= $OUTPUT->button(array(
	'command' => 'sort',
	'prop' => $col.'_ASC',
	'image' => $attrib['sortascbutton'],
	'align' => 'absmiddle',
	'title' => 'sortasc'));
	}

	// desc link
	if (!empty($attrib['sortdescbutton']))
	{
	$sort .= $OUTPUT->button(array(
	'command' => 'sort',
	'prop' => $col.'_DESC',
	'image' => $attrib['sortdescbutton'],
	'align' => 'absmiddle',
	'title' => 'sortdesc'));
	}
	}
	// just add a link tag to the header
	else
	{
	$col_name = sprintf(
	'<a href="./#sort" onclick="return %s.command(\'sort\',\'%s\',this)" title="%s">%s</a>',
	JS_OBJECT_NAME,
	$col,
	rcube_label('sortby'),
	$col_name);
	}
	}

	$sort_class = $col==$sort_col ? " sorted$sort_order" : '';

	// put it all together
	if ($col!='attachment')
	$out .= '<td class="'.$col.$sort_class.'" id="rcm'.$col.'">' . "$col_name$sort</td>\n";
	else
	$out .= '<td class="icon" id="rcm'.$col.'">' . "$col_name$sort</td>\n";
	}

	$out .= "</tr></thead>\n<tbody>\n";

	// no messages in this mailbox
	if (!sizeof($a_headers))
	$OUTPUT->show_message('nomessagesfound', 'notice');


	$a_js_message_arr = array();

	// create row for each message
	foreach ($a_headers as $i => $header) //while (list($i, $header) = each($a_headers))
	{
	$message_icon = $attach_icon = $flagged_icon = '';
	$js_row_arr = array();
	$zebra_class = $i%2 ? ' even' : ' odd';

	// set messag attributes to javascript array
	if ($header->deleted)
	$js_row_arr['deleted'] = true;
	if (!$header->seen)
	$js_row_arr['unread'] = true;
	if ($header->answered)
	$js_row_arr['replied'] = true;
	if ($header->forwarded)
	$js_row_arr['forwarded'] = true;
	if ($header->flagged)
	$js_row_arr['flagged'] = true;

	// set message icon
	if ($attrib['deletedicon'] && $header->deleted)
	$message_icon = $attrib['deletedicon'];
	else if ($attrib['repliedicon'] && $header->answered)
	{
	if ($attrib['forwardedrepliedicon'] && $header->forwarded)
	$message_icon = $attrib['forwardedrepliedicon'];
	else
	$message_icon = $attrib['repliedicon'];
	}
	else if ($attrib['forwardedicon'] && $header->forwarded)
	$message_icon = $attrib['forwardedicon'];
	else if ($attrib['unreadicon'] && !$header->seen)
	$message_icon = $attrib['unreadicon'];
	else if ($attrib['messageicon'])
	$message_icon = $attrib['messageicon'];

	if ($attrib['flaggedicon'] && $header->flagged)
	$flagged_icon = $attrib['flaggedicon'];
	else if ($attrib['unflaggedicon'] && !$header->flagged)
	$flagged_icon = $attrib['unflaggedicon'];

	// set attachment icon
	if ($attrib['attachmenticon'] && preg_match("/multipart\/m/i", $header->ctype))
	$attach_icon = $attrib['attachmenticon'];

	$out .= sprintf('<tr id="rcmrow%d" class="message%s%s%s%s">'."\n",
	$header->uid,
	$header->seen ? '' : ' unread',
	$header->deleted ? ' deleted' : '',
	$header->flagged ? ' flagged' : '',
	$zebra_class);

	$out .= sprintf("<td class=\"icon\">%s</td>\n", $message_icon ? sprintf($image_tag, $skin_path, $message_icon, '') : '');


	$IMAP->set_charset(!empty($header->charset) ? $header->charset : $CONFIG['default_charset']);

	// format each col
	foreach ($a_show_cols as $col)
	{
	if ($col=='from' \|\| $col=='to')
	$cont = Q(rcmail_address_string($header->$col, 3, false, $attrib['addicon']), 'show');
	else if ($col=='subject')
	{
	$action = $mbox==$CONFIG['drafts_mbox'] ? 'compose' : 'show';
	$uid_param = $mbox==$CONFIG['drafts_mbox'] ? '_draft_uid' : '_uid';
	$cont = abbreviate_string(trim($IMAP->decode_header($header->$col)), 160);
	if (empty($cont)) $cont = rcube_label('nosubject');
	$cont = sprintf('<a href="%s" onclick="return rcube_event.cancel(event)">%s</a>', Q(rcmail_url($action, array($uid_param=>$header->uid, '_mbox'=>$mbox))), Q($cont));
	}
	else if ($col=='flag')
	$cont = $flagged_icon ? sprintf($image_tag, $skin_path, $flagged_icon, '') : '';
	else if ($col=='size')
	$cont = show_bytes($header->$col);
	else if ($col=='date')
	$cont = format_date($header->date);
	else
	$cont = Q($header->$col);

	if ($col!='attachment')
	$out .= '<td class="'.$col.'">' . $cont . "</td>\n";
	else
	$out .= sprintf("<td class=\"icon\">%s</td>\n", $attach_icon ? sprintf($image_tag, $skin_path, $attach_icon, '') : ' ');
	}

	$out .= "</tr>\n";

	if (sizeof($js_row_arr))
	$a_js_message_arr[$header->uid] = $js_row_arr;
	}

	// complete message table
	$out .= "</tbody></table>\n";

	$message_count = $IMAP->messagecount();

	// set client env
	$OUTPUT->add_gui_object('mailcontframe', 'mailcontframe');
	$OUTPUT->add_gui_object('messagelist', $attrib['id']);
	$OUTPUT->set_env('messagecount', $message_count);
	$OUTPUT->set_env('current_page', $IMAP->list_page);
	$OUTPUT->set_env('pagecount', ceil($message_count/$IMAP->page_size));
	$OUTPUT->set_env('sort_col', $sort_col);
	$OUTPUT->set_env('sort_order', $sort_order);

	if ($attrib['messageicon'])
	$OUTPUT->set_env('messageicon', $skin_path . $attrib['messageicon']);
	if ($attrib['deletedicon'])
	$OUTPUT->set_env('deletedicon', $skin_path . $attrib['deletedicon']);
	if ($attrib['unreadicon'])
	$OUTPUT->set_env('unreadicon', $skin_path . $attrib['unreadicon']);
	if ($attrib['repliedicon'])
	$OUTPUT->set_env('repliedicon', $skin_path . $attrib['repliedicon']);
	if ($attrib['forwardedicon'])
	$OUTPUT->set_env('forwardedicon', $skin_path . $attrib['forwardedicon']);
	if ($attrib['forwardedrepliedicon'])
	$OUTPUT->set_env('forwardedrepliedicon', $skin_path . $attrib['forwardedrepliedicon']);
	if ($attrib['attachmenticon'])
	$OUTPUT->set_env('attachmenticon', $skin_path . $attrib['attachmenticon']);
	if ($attrib['flaggedicon'])
	$OUTPUT->set_env('flaggedicon', $skin_path . $attrib['flaggedicon']);
	if ($attrib['unflaggedicon'])
	$OUTPUT->set_env('unflaggedicon', $skin_path . $attrib['unflaggedicon']);

	$OUTPUT->set_env('messages', $a_js_message_arr);
	$OUTPUT->set_env('coltypes', $a_show_cols);

	$OUTPUT->include_script('list.js');

	return $out;
	}


	/**
	* return javascript commands to add rows to the message list
	*/
	function rcmail_js_message_list($a_headers, $insert_top=FALSE)
	{
	global $CONFIG, $IMAP, $OUTPUT;

	if (empty($_SESSION['list_columns']))
	$a_show_cols = is_array($CONFIG['list_cols']) ? $CONFIG['list_cols'] : array('subject');
	else
	$a_show_cols = $_SESSION['list_columns'];

	$mbox = $IMAP->get_mailbox_name();

	// show 'to' instead of from in sent messages
	if (($mbox == $CONFIG['sent_mbox'] \|\| $mbox == $CONFIG['drafts_mbox'])
	&& (($f = array_search('from', $a_show_cols)) !== false) && array_search('to', $a_show_cols) === false)
	$a_show_cols[$f] = 'to';

	$OUTPUT->command('set_message_coltypes', $a_show_cols);

	// loop through message headers
	foreach ($a_headers as $n => $header)
	{
	$a_msg_cols = array();
	$a_msg_flags = array();

	if (empty($header))
	continue;

	$IMAP->set_charset(!empty($header->charset) ? $header->charset : $CONFIG['default_charset']);

	// remove 'attachment' and 'flag' columns, we don't need them here
	if(($key = array_search('attachment', $a_show_cols)) !== FALSE)
	unset($a_show_cols[$key]);
	if(($key = array_search('flag', $a_show_cols)) !== FALSE)
	unset($a_show_cols[$key]);

	// format each col; similar as in rcmail_message_list()
	foreach ($a_show_cols as $col)
	{
	if ($col=='from' \|\| $col=='to')
	$cont = Q(rcmail_address_string($header->$col, 3), 'show');
	else if ($col=='subject')
	{
	$action = $mbox==$CONFIG['drafts_mbox'] ? 'compose' : 'show';
	$uid_param = $mbox==$CONFIG['drafts_mbox'] ? '_draft_uid' : '_uid';
	$cont = abbreviate_string(trim($IMAP->decode_header($header->$col)), 160);
	if (!$cont) $cont = rcube_label('nosubject');
	$cont = sprintf('<a href="%s" onclick="return rcube_event.cancel(event)">%s</a>', Q(rcmail_url($action, array($uid_param=>$header->uid, '_mbox'=>$mbox))), Q($cont));
	}
	else if ($col=='size')
	$cont = show_bytes($header->$col);
	else if ($col=='date')
	$cont = format_date($header->date);
	else
	$cont = Q($header->$col);

	$a_msg_cols[$col] = $cont;
	}

	$a_msg_flags['deleted'] = $header->deleted ? 1 : 0;
	$a_msg_flags['unread'] = $header->seen ? 0 : 1;
	$a_msg_flags['replied'] = $header->answered ? 1 : 0;
	$a_msg_flags['forwarded'] = $header->forwarded ? 1 : 0;
	$a_msg_flags['flagged'] = $header->flagged ? 1 : 0;

	$OUTPUT->command('add_message_row',
	$header->uid,
	$a_msg_cols,
	$a_msg_flags,
	preg_match("/multipart\/m/i", $header->ctype),
	$insert_top);
	}
	}


	/**
	* return an HTML iframe for loading mail content
	*/
	function rcmail_messagecontent_frame($attrib)
	{
	global $OUTPUT;

	if (empty($attrib['id']))
	$attrib['id'] = 'rcmailcontentwindow';

	$attrib['name'] = $attrib['id'];

	$OUTPUT->set_env('contentframe', $attrib['id']);
	$OUTPUT->set_env('blankpage', $attrib['src'] ? $OUTPUT->abs_url($attrib['src']) : 'program/blank.gif');

	return html::iframe($attrib);
	}


	/**
	*
	*/
	function rcmail_messagecount_display($attrib)
	{
	global $IMAP, $OUTPUT;

	if (!$attrib['id'])
	$attrib['id'] = 'rcmcountdisplay';

	$OUTPUT->add_gui_object('countdisplay', $attrib['id']);

	return html::span($attrib, rcmail_get_messagecount_text());
	}


	/**
	*
	*/
	function rcmail_quota_display($attrib)
	{
	global $OUTPUT, $COMM_PATH;

	if (!$attrib['id'])
	$attrib['id'] = 'rcmquotadisplay';

	if(isset($attrib['display']))
	$_SESSION['quota_display'] = $attrib['display'];

	$OUTPUT->add_gui_object('quotadisplay', $attrib['id']);

	return html::span($attrib, rcmail_quota_content(NULL, $attrib));
	}


	/**
	*
	*/
	function rcmail_quota_content($quota=NULL, $attrib=NULL)
	{
	global $IMAP, $COMM_PATH, $RCMAIL;

	$display = isset($_SESSION['quota_display']) ? $_SESSION['quota_display'] : '';

	if (is_array($quota) && !empty($quota['used']) && !empty($quota['total']))
	{
	if (!isset($quota['percent']))
	$quota['percent'] = $quota['used'] / $quota['total'];
	}
	elseif (!$IMAP->get_capability('QUOTA'))
	return rcube_label('unknown');
	else
	$quota = $IMAP->get_quota();

	if ($quota && !($quota['total']==0 && $RCMAIL->config->get('quota_zero_as_unlimited')))
	{
	$quota_text = sprintf('%s / %s (%.0f%%)',
	show_bytes($quota['used'] * 1024),
	show_bytes($quota['total'] * 1024),
	$quota['percent']);

	// show quota as image (by Brett Patterson)
	if ($display == 'image' && function_exists('imagegif'))
	{
	if (!$attrib['width'])
	$attrib['width'] = isset($_SESSION['quota_width']) ? $_SESSION['quota_width'] : 100;
	else
	$_SESSION['quota_width'] = $attrib['width'];

	if (!$attrib['height'])
	$attrib['height'] = isset($_SESSION['quota_height']) ? $_SESSION['quota_height'] : 14;
	else
	$_SESSION['quota_height'] = $attrib['height'];

	$quota_text = sprintf('<img src="./bin/quotaimg.php?u=%s&q=%d&w=%d&h=%d" width="%d" height="%d" alt="%s" title="%s / %s" />',
	$quota['used'], $quota['total'],
	$attrib['width'], $attrib['height'],
	$attrib['width'], $attrib['height'],
	$quota_text,
	show_bytes($quota['used'] * 1024),
	show_bytes($quota['total'] * 1024));
	}
	}
	else
	$quota_text = rcube_label('unlimited');

	return $quota_text;
	}


	/**
	*
	*/
	function rcmail_get_messagecount_text($count=NULL, $page=NULL)
	{
	global $IMAP, $MESSAGE;

	if (isset($MESSAGE->index))
	{
	return rcube_label(array('name' => 'messagenrof',
	'vars' => array('nr' => $MESSAGE->index+1,
	'count' => $count!==NULL ? $count : $IMAP->messagecount())));
	}

	if ($page===NULL)
	$page = $IMAP->list_page;

	$start_msg = ($page-1) * $IMAP->page_size + 1;
	$max = $count!==NULL ? $count : $IMAP->messagecount();

	if ($max==0)
	$out = rcube_label('mailboxempty');
	else
	$out = rcube_label(array('name' => 'messagesfromto',
	'vars' => array('from' => $start_msg,
	'to' => min($max, $start_msg + $IMAP->page_size - 1),
	'count' => $max)));

	return Q($out);
	}

	/**
	*
	*/
	function rcmail_mailbox_name_display($attrib)
	{
	global $RCMAIL;

	if (!$attrib['id'])
	$attrib['id'] = 'rcmmailboxname';

	$RCMAIL->output->add_gui_object('mailboxname', $attrib['id']);

	return html::span($attrib, rcmail_get_mailbox_name_text());
	}

	function rcmail_get_mailbox_name_text()
	{
	global $RCMAIL;
	return rcmail_localize_foldername($RCMAIL->imap->get_mailbox_name());
	}

	/**
	* Sets message is_safe flag according to 'show_images' option value
	*
	* @param object rcube_message Message
	*/
	function rcmail_check_safe(&$message)
	{
	global $RCMAIL;

	$show_images = $RCMAIL->config->get('show_images');
	if (!$message->is_safe
	&& !empty($show_images)
	&& $message->has_html_part())
	{
	switch($show_images) {
	case '1': // known senders only
	$CONTACTS = new rcube_contacts($RCMAIL->db, $_SESSION['user_id']);
	if ($CONTACTS->search('email', $message->sender['mailto'], true, false)->count) {
	$message->set_safe(true);
	}
	break;
	case '2': // always
	$message->set_safe(true);
	break;
	}
	}
	}

	/**
	* Cleans up the given message HTML Body (for displaying)
	*
	* @param string HTML
	* @param array Display parameters
	* @param array CID map replaces (inline images)
	* @return string Clean HTML
	*/
	function rcmail_wash_html($html, $p = array(), $cid_replaces)
	{
	global $REMOTE_OBJECTS;

	$p += array('safe' => false, 'inline_html' => true);

	// special replacements (not properly handled by washtml class)
	$html_search = array(
	'/(<\/nobr>)(\s+)(<nobr>)/i', // space(s) between <NOBR>
	'/(<[\/]*st1:[^>]+>)/i', // Microsoft's Smart Tags <ST1>
	'/<\/?rte_text>/i', // Rich Text Editor tags (#1485647)
	'/<title>.*<\/title>/i', // PHP bug #32547 workaround: remove title tag
	'/<html[^>]*>/im', // malformed html: remove html tags (#1485139)
	'/<\/html>/i', // malformed html: remove html tags (#1485139)
	'/^[\xFE\xFF\xBB\xBF\x00]+((?:<\!doctype\|\<html))/im', // remove byte-order mark (only outlook?)
	);
	$html_replace = array(
	'\\1'.'   '.'\\3',
	'',
	'',
	'',
	'',
	'',
	'\\1',
	);
	$html = preg_replace($html_search, $html_replace, $html);

	// charset was converted to UTF-8 in rcube_imap::get_message_part() -> change charset specification in HTML accordingly
	$charset_pattern = '/(\s+content=[\'"]?\w+\/\w+;\s*charset)=([a-z0-9-_]+)/i';
	if (preg_match($charset_pattern, $html)) {
	$html = preg_replace($charset_pattern, '\\1='.RCMAIL_CHARSET, $html);
	}
	else {
	// add head for malformed messages, washtml cannot work without that
	if (!preg_match('/<head[^>]>(.)<\/head>/Uims', $html))
	$html = '<head></head>'. $html;
	$html = substr_replace($html, '<meta http-equiv="content-type" content="text/html; charset='.RCMAIL_CHARSET.'" />', intval(stripos($html, '<head>')+6), 0);
	}

	// turn relative into absolute urls
	$html = rcmail_resolve_base($html);

	// clean HTML with washhtml by Frederic Motte
	$wash_opts = array(
	'show_washed' => false,
	'allow_remote' => $p['safe'],
	'blocked_src' => "./program/blocked.gif",
	'charset' => RCMAIL_CHARSET,
	'cid_map' => $cid_replaces,
	'html_elements' => array('body'),
	);

	if (!$p['inline_html']) {
	$wash_opts['html_elements'] = array('html','head','title','body');
	}
	if ($p['safe']) {
	$wash_opts['html_elements'][] = 'link';
	$wash_opts['html_attribs'] = array('rel','type');
	}

	$washer = new washtml($wash_opts);
	$washer->add_callback('form', 'rcmail_washtml_callback');

	if ($p['safe']) { // allow CSS styles, will be sanitized by rcmail_washtml_callback()
	$washer->add_callback('style', 'rcmail_washtml_callback');
	}

	$html = $washer->wash($html);
	$REMOTE_OBJECTS = $washer->extlinks;

	return $html;
	}


	/**
	* Convert the given message part to proper HTML
	* which can be displayed the message view
	*
	* @param object rcube_message_part Message part
	* @param array Display parameters array
	* @return string Formatted HTML string
	*/
	function rcmail_print_body($part, $p = array())
	{
	$p += array('safe' => false, 'plain' => false, 'inline_html' => true);

	// convert html to text/plain
	if ($part->ctype_secondary == 'html' && $p['plain']) {
	$txt = new html2text($part->body, false, true);
	$body = $txt->get_text();
	$part->ctype_secondary = 'plain';
	}
	// text/html
	else if ($part->ctype_secondary == 'html') {
	return rcmail_wash_html($part->body, $p, $part->replaces);
	}
	// text/enriched
	else if ($part->ctype_secondary=='enriched') {
	$part->ctype_secondary = 'html';
	require_once('lib/enriched.inc');
	return Q(enriched_to_html($part->body), 'show');
	}
	else
	$body = $part->body;


	/** assert plaintext **/

	// make links and email-addresses clickable
	$replacements = new rcube_string_replacer;

	$url_chars = 'a-z0-9_\-\+\*\$\/&%=@#:;';
	$url_chars_within = '\?\.~,!';

	// search for patterns like links and e-mail addresses
	$body = preg_replace_callback("/([\w]+):\/\/([a-z0-9\-\.]+[a-z]{2,4}([$url_chars$url_chars_within]*[$url_chars])?)/i", array($replacements, 'link_callback'), $body);
	$body = preg_replace_callback("/([^\/:]\|\s)(www\.)([a-z0-9\-]{2,}[a-z]{2,4}([$url_chars$url_chars_within]*[$url_chars])?)/i", array($replacements, 'link_callback'), $body);
	$body = preg_replace_callback('/([a-z0-9][a-z0-9\-\.\+\_]@[a-z0-9]([a-z0-9\-][.]?)[a-z0-9]\\.[a-z]{2,5})/i', array($replacements, 'mailto_callback'), $body);

	// split body into single lines
	$a_lines = preg_split('/\r?\n/', $body);
	$quote_level = 0;

	// colorize quoted parts
	for ($n=0; $n < sizeof($a_lines); $n++) {
	$line = $a_lines[$n];
	$quotation = '';
	$q = 0;

	if (preg_match('/^(>+\s*)+/', $line, $regs)) {
	$q = strlen(preg_replace('/\s/', '', $regs[0]));
	$line = substr($line, strlen($regs[0]));

	if ($q > $quote_level)
	$quotation = str_repeat('<blockquote>', $q - $quote_level);
	else if ($q < $quote_level)
	$quotation = str_repeat("</blockquote>", $quote_level - $q);
	}
	else if ($quote_level > 0)
	$quotation = str_repeat("</blockquote>", $quote_level);

	$quote_level = $q;
	$a_lines[$n] = $quotation . Q($line, 'replace', false); // htmlquote plaintext
	}

	// insert the links for urls and mailtos
	$body = $replacements->resolve(join("\n", $a_lines));

	return html::tag('pre', array(), $body);
	}


	/**
	* add a string to the replacement array and return a replacement string
	*/
	function rcmail_str_replacement($str, &$rep)
	{
	static $count = 0;
	$rep[$count] = stripslashes($str);
	return "##string_replacement{".($count++)."}##";
	}


	/**
	* Callback function for washtml cleaning class
	*/
	function rcmail_washtml_callback($tagname, $attrib, $content)
	{
	switch ($tagname) {
	case 'form':
	$out = html::div('form', $content);
	break;

	case 'style':
	// decode all escaped entities and reduce to ascii strings
	$stripped = preg_replace('/[^a-zA-Z\(:]/', '', rcmail_xss_entitiy_decode($content));

	// now check for evil strings like expression, behavior or url()
	if (!preg_match('/expression\|behavior\|url\(\|import/', $stripped)) {
	$out = html::tag('style', array('type' => 'text/css'), $content);
	break;
	}

	default:
	$out = '';
	}

	return $out;
	}


	/**
	* return table with message headers
	*/
	function rcmail_message_headers($attrib, $headers=NULL)
	{
	global $IMAP, $OUTPUT, $MESSAGE, $PRINT_MODE, $CONFIG;
	static $sa_attrib;

	// keep header table attrib
	if (is_array($attrib) && !$sa_attrib)
	$sa_attrib = $attrib;
	else if (!is_array($attrib) && is_array($sa_attrib))
	$attrib = $sa_attrib;


	if (!isset($MESSAGE))
	return FALSE;

	// get associative array of headers object
	if (!$headers)
	$headers = is_object($MESSAGE->headers) ? get_object_vars($MESSAGE->headers) : $MESSAGE->headers;

	$header_count = 0;

	// allow the following attributes to be added to the <table> tag
	$attrib_str = create_attrib_string($attrib, array('style', 'class', 'id', 'cellpadding', 'cellspacing', 'border', 'summary'));
	$out = '<table' . $attrib_str . ">\n";

	// show these headers
	$standard_headers = array('subject', 'from', 'to', 'cc', 'bcc', 'replyto', 'date');

	foreach ($standard_headers as $hkey)
	{
	if (!$headers[$hkey])
	continue;

	if ($hkey == 'date')
	{
	if ($PRINT_MODE)
	$header_value = format_date($headers[$hkey], $CONFIG['date_long'] ? $CONFIG['date_long'] : 'x');
	else
	$header_value = format_date($headers[$hkey]);
	}
	else if ($hkey == 'replyto')
	{
	if ($headers['replyto'] != $headers['from'])
	$header_value = Q(rcmail_address_string($headers['replyto'], null, true, $attrib['addicon']), 'show');
	else
	continue;
	}
	else if (in_array($hkey, array('from', 'to', 'cc', 'bcc')))
	$header_value = Q(rcmail_address_string($headers[$hkey], null, true, $attrib['addicon']), 'show');
	else if ($hkey == 'subject' && empty($headers[$hkey]))
	$header_value = Q(rcube_label('nosubject'));
	else
	$header_value = Q(trim($IMAP->decode_header($headers[$hkey])));

	$out .= "\n<tr>\n";
	$out .= '<td class="header-title">'.Q(rcube_label($hkey)).": </td>\n";
	$out .= '<td class="'.$hkey.'" width="90%">'.$header_value."</td>\n</tr>";
	$header_count++;
	}

	// all headers division
	$out .= "\n".'<tr><td colspan="2" class="more-headers show-headers"
	onclick="return '.JS_OBJECT_NAME.'.command(\'load-headers\', \'\', this)"></td></tr>';
	$out .= "\n".'<tr id="all-headers"><td colspan="2" class="all"><div id="headers-source"></div></td></tr>';

	$OUTPUT->add_gui_object('all_headers_row', 'all-headers');
	$OUTPUT->add_gui_object('all_headers_box', 'headers-source');

	$out .= "\n</table>\n\n";

	return $header_count ? $out : '';
	}


	/**
	* Handler for the 'messagebody' GUI object
	*
	* @param array Named parameters
	* @return string HTML content showing the message body
	*/
	function rcmail_message_body($attrib)
	{
	global $CONFIG, $OUTPUT, $MESSAGE, $IMAP, $REMOTE_OBJECTS;

	if (!is_array($MESSAGE->parts) && empty($MESSAGE->body))
	return '';

	if (!$attrib['id'])
	$attrib['id'] = 'rcmailMsgBody';

	$safe_mode = $MESSAGE->is_safe \|\| intval($_GET['_safe']);
	$out = '';

	$header_attrib = array();
	foreach ($attrib as $attr => $value)
	if (preg_match('/^headertable([a-z]+)$/i', $attr, $regs))
	$header_attrib[$regs[1]] = $value;

	if (!empty($MESSAGE->parts))
	{
	foreach ($MESSAGE->parts as $i => $part)
	{
	if ($part->type == 'headers')
	$out .= rcmail_message_headers(sizeof($header_attrib) ? $header_attrib : NULL, $part->headers);
	else if ($part->type == 'content')
	{
	if (empty($part->ctype_parameters) \|\| empty($part->ctype_parameters['charset']))
	$part->ctype_parameters['charset'] = $MESSAGE->headers->charset;

	// fetch part if not available
	if (!isset($part->body))
	$part->body = $MESSAGE->get_part_content($part->mime_id);

	$body = rcmail_print_body($part, array('safe' => $safe_mode, 'plain' => !$CONFIG['prefer_html']));

	if ($part->ctype_secondary == 'html')
	$out .= html::div('message-htmlpart', rcmail_html4inline($body, $attrib['id']));
	else
	$out .= html::div('message-part', $body);
	}
	}
	}
	else
	$out .= html::div('message-part', html::tag('pre', array(), Q($MESSAGE->body)));


	$ctype_primary = strtolower($MESSAGE->structure->ctype_primary);
	$ctype_secondary = strtolower($MESSAGE->structure->ctype_secondary);

	// list images after mail body
	if ($CONFIG['inline_images']
	&& $ctype_primary == 'multipart'
	&& !empty($MESSAGE->attachments)
	&& !strstr($message_body, '<html'))
	{
	foreach ($MESSAGE->attachments as $attach_prop) {
	if (strpos($attach_prop->mimetype, 'image/') === 0) {
	$out .= html::tag('hr') . html::p(array('align' => "center"),
	html::img(array(
	'src' => $MESSAGE->get_part_url($attach_prop->mime_id),
	'title' => $attach_prop->filename,
	'alt' => $attach_prop->filename,
	)));
	}
	}
	}

	// tell client that there are blocked remote objects
	if ($REMOTE_OBJECTS && !$safe_mode)
	$OUTPUT->set_env('blockedobjects', true);

	return html::div($attrib, $out);
	}


	/**
	* Convert all relative URLs according to a <base> in HTML
	*/
	function rcmail_resolve_base($body)
	{
	// check for <base href=...>
	if (preg_match('!(<base.*href=["\']?)([hftps]{3,5}://[a-z0-9/.%-]+)!i', $body, $regs)) {
	$replacer = new rcube_base_replacer($regs[2]);

	// replace all relative paths
	$body = preg_replace_callback('/(src\|background\|href)=(["\']?)([\.\/]+[^"\'\s]+)(\2\|\s\|>)/Ui', array($replacer, 'callback'), $body);
	$body = preg_replace_callback('/(url\s*$)(["\']?)([\.\/]+[^"\'$\s]+)(\2)\)/Ui', array($replacer, 'callback'), $body);
	}

	return $body;
	}

	/**
	* modify a HTML message that it can be displayed inside a HTML page
	*/
	function rcmail_html4inline($body, $container_id)
	{
	$last_style_pos = 0;
	$body_lc = strtolower($body);

	// find STYLE tags
	while (($pos = strpos($body_lc, '<style', $last_style_pos)) && ($pos2 = strpos($body_lc, '</style>', $pos)))
	{
	$pos = strpos($body_lc, '>', $pos)+1;

	// replace all css definitions with #container [def]
	$styles = rcmail_mod_css_styles(substr($body, $pos, $pos2-$pos), $container_id);

	$body = substr($body, 0, $pos) . $styles . substr($body, $pos2);
	$body_lc = strtolower($body);
	$last_style_pos = $pos2;
	}

	// modify HTML links to open a new window if clicked
	$GLOBALS['rcmail_html_container_id'] = $container_id;
	$body = preg_replace_callback('/<(a\|link)\s+([^>]+)>/Ui', 'rcmail_alter_html_link', $body);
	unset($GLOBALS['rcmail_html_container_id']);

	// add comments arround html and other tags
	$out = preg_replace(array(
	'/(<!DOCTYPE[^>]*>)/i',
	'/(<\?xml[^>]*>)/i',
	'/(<\/?html[^>]*>)/i',
	'/(<\/?head[^>]*>)/i',
	'/(<title[^>]>.<\/title>)/Ui',
	'/(<\/?meta[^>]*>)/i'),
	'<!--\\1-->',
	$body);

	$out = preg_replace(
	array('/<body([^>]*)>/i', '/<\/body>/i'),
	array('<div class="rcmBody"\\1>', '</div>'),
	$out);

	// quote <? of php and xml files that are specified as text/html
	$out = preg_replace(array('/<\?/', '/\?>/'), array('<?', '?>'), $out);

	return $out;
	}


	/**
	* parse link attributes and set correct target
	*/
	function rcmail_alter_html_link($matches)
	{
	global $EMAIL_ADDRESS_PATTERN;

	$tag = $matches[1];
	$attrib = parse_attrib_string($matches[2]);
	$end = '>';

	if ($tag == 'link' && preg_match('/^https?:\/\//i', $attrib['href'])) {
	$attrib['href'] = "./bin/modcss.php?u=" . urlencode($attrib['href']) . "&c=" . urlencode($GLOBALS['rcmail_html_container_id']);
	$end = ' />';
	}
	else if (preg_match("/^mailto:$EMAIL_ADDRESS_PATTERN/i", $attrib['href'], $mailto)) {
	$attrib['href'] = $mailto[0];
	$attrib['onclick'] = sprintf(
	"return %s.command('compose','%s',this)",
	JS_OBJECT_NAME,
	JQ($mailto[1]));
	}
	else if (!empty($attrib['href']) && $attrib['href'][0] != '#') {
	$attrib['target'] = '_blank';
	}

	return "<$tag" . html::attrib_string($attrib, array('href','name','target','onclick','id','class','style','title','rel','type','media')) . $end;
	}


	/**
	* decode address string and re-format it as HTML links
	*/
	function rcmail_address_string($input, $max=null, $linked=false, $addicon=null)
	{
	global $IMAP, $PRINT_MODE, $CONFIG, $OUTPUT, $EMAIL_ADDRESS_PATTERN;

	$a_parts = $IMAP->decode_address_list($input);

	if (!sizeof($a_parts))
	return $input;

	$c = count($a_parts);
	$j = 0;
	$out = '';

	foreach ($a_parts as $part) {
	$j++;
	if ($PRINT_MODE) {
	$out .= sprintf('%s <%s>', Q($part['name']), $part['mailto']);
	}
	else if (preg_match("/$EMAIL_ADDRESS_PATTERN/i", $part['mailto'])) {
	if ($linked) {
	$out .= html::a(array(
	'href' => 'mailto:'.$part['mailto'],
	'onclick' => sprintf("return %s.command('compose','%s',this)", JS_OBJECT_NAME, JQ($part['mailto'])),
	'title' => $part['mailto'],
	'class' => "rcmContactAddress",
	),
	Q($part['name']));
	}
	else {
	$out .= html::span(array('title' => $part['mailto'], 'class' => "rcmContactAddress"), Q($part['name']));
	}

	if ($addicon) {
	$out .= ' ' . html::a(array(
	'href' => "#add",
	'onclick' => sprintf("return %s.command('add-contact','%s',this)", JS_OBJECT_NAME, urlencode($part['string'])),
	'title' => rcube_label('addtoaddressbook'),
	),
	html::img(array(
	'src' => $CONFIG['skin_path'] . $addicon,
	'alt' => "Add contact",
	)));
	}
	}
	else {
	if ($part['name'])
	$out .= Q($part['name']);
	if ($part['mailto'])
	$out .= (strlen($out) ? ' ' : '') . sprintf('<%s>', Q($part['mailto']));
	}

	if ($c>$j)
	$out .= ','.($max ? ' ' : ' ');

	if ($max && $j==$max && $c>$j) {
	$out .= '...';
	break;
	}
	}

	return $out;
	}


	/**
	* Wrap text to a given number of characters per line
	* but respect the mail quotation of replies messages (>)
	*
	* @param string Text to wrap
	* @param int The line width
	* @return string The wrapped text
	*/
	function rcmail_wrap_quoted($text, $max = 76)
	{
	// Rebuild the message body with a maximum of $max chars, while keeping quoted message.
	$lines = preg_split('/\r?\n/', trim($text));
	$out = '';

	foreach ($lines as $line) {
	if (strlen($line) > $max) {
	if (preg_match('/^([>\s]+)/', $line, $regs)) {
	$length = strlen($regs[0]);
	$prefix = substr($line, 0, $length);

	// Remove '> ' from the line, then wordwrap() the line
	- $line = wordwrap(substr($line, $length), $max - $length);
	+ $line = rc_wordwrap(substr($line, $length), $max - $length);

	// Rebuild the line with '> ' at the beginning of each 'subline'
	$newline = '';
	foreach (explode("\n", $line) as $l) {
	$newline .= $prefix . $l . "\n";
	}

	// Remove the righest newline char
	$line = rtrim($newline);
	}
	else {
	- $line = wordwrap($line, $max);
	+ $line = rc_wordwrap($line, $max);
	}
	}

	// Append the line
	$out .= $line . "\n";
	}

	return $out;
	}


	function rcmail_message_part_controls()
	{
	global $MESSAGE;

	$part = asciiwords(get_input_value('_part', RCUBE_INPUT_GPC));
	if (!is_object($MESSAGE) \|\| !is_array($MESSAGE->parts) \|\| !($_GET['_uid'] && $_GET['_part']) \|\| !$MESSAGE->mime_parts[$part])
	return '';

	$part = $MESSAGE->mime_parts[$part];
	$table = new html_table(array('cols' => 3));

	if (!empty($part->filename)) {
	$table->add('title', Q(rcube_label('filename')));
	$table->add(null, Q($part->filename));
	$table->add(null, '[' . html::a('?'.str_replace('_frame=', '_download=', $_SERVER['QUERY_STRING']), Q(rcube_label('download'))) . ']');
	}

	if (!empty($part->size)) {
	$table->add('title', Q(rcube_label('filesize')));
	$table->add(null, Q(show_bytes($part->size)));
	}

	return $table->show($attrib);
	}



	function rcmail_message_part_frame($attrib)
	{
	global $MESSAGE;

	$part = $MESSAGE->mime_parts[asciiwords(get_input_value('_part', RCUBE_INPUT_GPC))];
	$ctype_primary = strtolower($part->ctype_primary);

	$attrib['src'] = './?' . str_replace('_frame=', ($ctype_primary=='text' ? '_show=' : '_preload='), $_SERVER['QUERY_STRING']);

	return html::iframe($attrib);
	}


	/**
	* clear message composing settings
	*/
	function rcmail_compose_cleanup()
	{
	if (!isset($_SESSION['compose']))
	return;

	// remove attachment files from temp dir
	if (is_array($_SESSION['compose']['attachments']))
	foreach ($_SESSION['compose']['attachments'] as $attachment)
	@unlink($attachment['path']);

	unset($_SESSION['compose']);
	}


	/**
	* Send the given message compose object using the configured method
	*/
	function rcmail_deliver_message(&$message, $from, $mailto)
	{
	global $CONFIG, $RCMAIL;

	$msg_body = $message->get();
	$headers = $message->headers();

	// send thru SMTP server using custom SMTP library
	if ($CONFIG['smtp_server'])
	{
	// generate list of recipients
	$a_recipients = array($mailto);

	if (strlen($headers['Cc']))
	$a_recipients[] = $headers['Cc'];
	if (strlen($headers['Bcc']))
	$a_recipients[] = $headers['Bcc'];

	// clean Bcc from header for recipients
	$send_headers = $headers;
	unset($send_headers['Bcc']);
	// here too, it because txtHeaders() below use $message->_headers not only $send_headers
	unset($message->_headers['Bcc']);

	// send message
	$smtp_response = array();
	$sent = smtp_mail($from, $a_recipients, ($foo = $message->txtHeaders($send_headers, true)), $msg_body, $smtp_response);

	// log error
	if (!$sent)
	raise_error(array('code' => 800, 'type' => 'smtp', 'line' => __LINE__, 'file' => __FILE__,
	'message' => "SMTP error: ".join("\n", $smtp_response)), TRUE, FALSE);
	}

	// send mail using PHP's mail() function
	else
	{
	// unset some headers because they will be added by the mail() function
	$headers_enc = $message->headers($headers);
	$headers_php = $message->_headers;
	unset($headers_php['To'], $headers_php['Subject']);

	// reset stored headers and overwrite
	$message->_headers = array();
	$header_str = $message->txtHeaders($headers_php);

	if (ini_get('safe_mode'))
	$sent = mail($headers_enc['To'], $headers_enc['Subject'], $msg_body, $header_str);
	else
	$sent = mail($headers_enc['To'], $headers_enc['Subject'], $msg_body, $header_str, "-f$from");
	}

	if ($sent)
	{
	// remove MDN headers after sending
	unset($headers['Return-Receipt-To'], $headers['Disposition-Notification-To']);

	if ($CONFIG['smtp_log'])
	write_log('sendmail', sprintf("User %s [%s]; Message for %s; %s",
	$RCMAIL->user->get_username(),
	$_SERVER['REMOTE_ADDR'],
	$mailto,
	!empty($smtp_response) ? join('; ', $smtp_response) : ''));
	}

	$message->_headers = array();
	$message->headers($headers);

	return $sent;
	}


	function rcmail_send_mdn($uid)
	{
	global $RCMAIL, $IMAP;

	$message = new rcube_message($uid);

	if ($message->headers->mdn_to && !$message->headers->mdn_sent &&
	($IMAP->check_permflag('MDNSENT') \|\| $IMAP->check_permflag('*')))
	{
	$identity = $RCMAIL->user->get_identity();
	$sender = format_email_recipient($identity['email'], $identity['name']);
	$recipient = array_shift($IMAP->decode_address_list($message->headers->mdn_to));
	$mailto = $recipient['mailto'];

	$compose = new rcube_mail_mime($RCMAIL->config->header_delimiter());
	$compose->setParam(array(
	'text_encoding' => 'quoted-printable',
	'html_encoding' => 'quoted-printable',
	'head_encoding' => 'quoted-printable',
	'head_charset' => RCMAIL_CHARSET,
	'html_charset' => RCMAIL_CHARSET,
	'text_charset' => RCMAIL_CHARSET,
	));

	// compose headers array
	$headers = array(
	'Date' => date('r'),
	'From' => $sender,
	'To' => $message->headers->mdn_to,
	'Subject' => rcube_label('receiptread') . ': ' . $message->subject,
	'Message-ID' => sprintf('<%s@%s>', md5(uniqid('rcmail'.rand(),true)), $RCMAIL->config->mail_domain($_SESSION['imap_host'])),
	'X-Sender' => $identity['email'],
	'Content-Type' => 'multipart/report; report-type=disposition-notification',
	);

	if ($agent = $RCMAIL->config->get('useragent'))
	$headers['User-Agent'] = $agent;

	$body = rcube_label("yourmessage") . "\r\n\r\n" .
	"\t" . rcube_label("to") . ': ' . rcube_imap::decode_mime_string($message->headers->to, $message->headers->charset) . "\r\n" .
	"\t" . rcube_label("subject") . ': ' . $message->subject . "\r\n" .
	"\t" . rcube_label("sent") . ': ' . format_date($message->headers->date, $RCMAIL->config->get('date_long')) . "\r\n" .
	"\r\n" . rcube_label("receiptnote") . "\r\n";

	$ua = $RCMAIL->config->get('useragent', "RoundCube Webmail (Version ".RCMAIL_VERSION.")");
	$report = "Reporting-UA: $ua\r\n";

	if ($message->headers->to)
	$report .= "Original-Recipient: {$message->headers->to}\r\n";

	$report .= "Final-Recipient: rfc822; {$identity['email']}\r\n" .
	"Original-Message-ID: {$message->headers->messageID}\r\n" .
	"Disposition: manual-action/MDN-sent-manually; displayed\r\n";

	$compose->headers($headers);
	- $compose->setTXTBody(wordwrap($body, 75, "\r\n"));
	+ $compose->setTXTBody(rc_wordwrap($body, 75, "\r\n"));
	$compose->addAttachment($report, 'message/disposition-notification', 'MDNPart2.txt', false, '7bit', 'inline');

	$sent = rcmail_deliver_message($compose, $identity['email'], $mailto);

	if ($sent)
	{
	$IMAP->set_flag($message->uid, 'MDNSENT');
	return true;
	}
	}

	return false;
	}


	function rcmail_search_filter($attrib)
	{
	global $OUTPUT;

	if (!strlen($attrib['id']))
	$attrib['id'] = 'rcmlistfilter';

	$attrib['onchange'] = JS_OBJECT_NAME.'.filter_mailbox(this.value)';

	/*
	RFC3501 (6.4.4): 'ALL', 'RECENT',
	'ANSWERED', 'DELETED', 'FLAGGED', 'SEEN',
	'UNANSWERED', 'UNDELETED', 'UNFLAGGED', 'UNSEEN',
	'NEW', // = (RECENT UNSEEN)
	'OLD' // = NOT RECENT
	*/

	$select_filter = new html_select($attrib);
	$select_filter->add(rcube_label('all'), 'ALL');
	$select_filter->add(rcube_label('unread'), 'UNSEEN');
	$select_filter->add(rcube_label('flagged'), 'FLAGGED');
	$select_filter->add(rcube_label('unanswered'), 'UNANSWERED');

	$out = $select_filter->show($_SESSION['search_filter']);

	$OUTPUT->add_gui_object('search_filter', $attrib['id']);

	return $out;
	}

	// register UI objects
	$OUTPUT->add_handlers(array(
	'mailboxlist' => 'rcmail_mailbox_list',
	'messages' => 'rcmail_message_list',
	'messagecountdisplay' => 'rcmail_messagecount_display',
	'quotadisplay' => 'rcmail_quota_display',
	'mailboxname' => 'rcmail_mailbox_name_display',
	'messageheaders' => 'rcmail_message_headers',
	'messagebody' => 'rcmail_message_body',
	'messagecontentframe' => 'rcmail_messagecontent_frame',
	'messagepartframe' => 'rcmail_message_part_frame',
	'messagepartcontrols' => 'rcmail_message_part_controls',
	'searchfilter' => 'rcmail_search_filter',
	'searchform' => array($OUTPUT, 'search_form'),
	));

	?>
	diff --git a/program/steps/mail/sendmail.inc b/program/steps/mail/sendmail.inc
	index eb81fc9ad..9607619e9 100644
	--- a/program/steps/mail/sendmail.inc
	+++ b/program/steps/mail/sendmail.inc
	@@ -1,515 +1,515 @@
	<?php

	/*
	+-----------------------------------------------------------------------+
	\| program/steps/mail/sendmail.inc \|
	\| \|
	\| This file is part of the RoundCube Webmail client \|
	\| Copyright (C) 2005-2009, RoundCube Dev. - Switzerland \|
	\| Licensed under the GNU GPL \|
	\| \|
	\| PURPOSE: \|
	\| Compose a new mail message with all headers and attachments \|
	\| and send it using the PEAR::Net_SMTP class or with PHP mail() \|
	\| \|
	+-----------------------------------------------------------------------+
	\| Author: Thomas Bruederli <roundcube@gmail.com> \|
	+-----------------------------------------------------------------------+

	$Id$

	*/


	// remove all scripts and act as called in frame
	$OUTPUT->reset();
	$OUTPUT->framed = TRUE;

	$savedraft = !empty($_POST['_draft']) ? TRUE : FALSE;

	/**** checks ******/

	if (!isset($_SESSION['compose']['id'])) {
	raise_error(array('code' => 500, 'type' => 'smtp', 'file' => __FILE__, 'message' => "Invalid compose ID"), true, false);
	console("Sendmail error", $_SESSION['compose']);
	$OUTPUT->show_message("An internal error occured. Please try again.", 'error');
	$OUTPUT->send('iframe');
	}

	if (!$savedraft) {
	if (empty($_POST['_to']) && empty($_POST['_cc']) && empty($_POST['_bcc'])
	&& empty($_POST['_subject']) && $_POST['_message']) {
	$OUTPUT->show_message('sendingfailed', 'error');
	$OUTPUT->send('iframe');
	}

	if(!empty($CONFIG['sendmail_delay'])) {
	$wait_sec = time() - intval($CONFIG['sendmail_delay']) - intval($CONFIG['last_message_time']);
	if($wait_sec < 0) {
	$OUTPUT->show_message('senttooquickly', 'error', array('sec' => $wait_sec * -1));
	$OUTPUT->send('iframe');
	}
	}
	}


	/**** message sending functions ******/

	// get identity record
	function rcmail_get_identity($id)
	{
	global $USER, $OUTPUT;

	if ($sql_arr = $USER->get_identity($id))
	{
	$out = $sql_arr;
	$out['mailto'] = $sql_arr['email'];

	// Special chars as defined by RFC 822 need to in quoted string (or escaped).
	if (preg_match('/[\<\>\\\.\[\]@,;:"]/', $sql_arr['name']))
	$name = '"' . addcslashes($sql_arr['name'], '"') . '"';
	else
	$name = $sql_arr['name'];

	$out['string'] = rcube_charset_convert($name, RCMAIL_CHARSET, $OUTPUT->get_charset());
	if ($sql_arr['email'])
	$out['string'] .= ' <' . $sql_arr['email'] . '>';

	return $out;
	}

	return FALSE;
	}

	/**
	* go from this:
	* <img src=".../tiny_mce/plugins/emotions/images/smiley-cool.gif" border="0" alt="Cool" title="Cool" />
	*
	* to this:
	*
	* <IMG src="cid:smiley-cool.gif"/>
	* ...
	* ------part...
	* Content-Type: image/gif
	* Content-Transfer-Encoding: base64
	* Content-ID: <smiley-cool.gif>
	*/
	function rcmail_attach_emoticons(&$mime_message)
	{
	global $CONFIG;

	$body = $mime_message->getHtmlBody();

	// remove any null-byte characters before parsing
	$body = preg_replace('/\x00/', '', $body);

	$searchstr = 'program/js/tiny_mce/plugins/emotions/img/';
	$offset = 0;

	// keep track of added images, so they're only added once
	$included_images = array();

	if (preg_match_all('# src=[\'"]([^\'"]+)#', $body, $matches, PREG_OFFSET_CAPTURE)) {
	foreach ($matches[1] as $m) {
	// find emoticon image tags
	if (preg_match('#'.$searchstr.'(.*)$#', $m[0], $imatches)) {
	$image_name = $imatches[1];

	// sanitize image name so resulting attachment doesn't leave images dir
	$image_name = preg_replace('/[^a-zA-Z0-9_\.\-]/i', '', $image_name);
	$img_file = INSTALL_PATH . '/' . $searchstr . $image_name;

	if (! in_array($image_name, $included_images)) {
	// add the image to the MIME message
	if(! $mime_message->addHTMLImage($img_file, 'image/gif', '', true, $image_name))
	$OUTPUT->show_message("emoticonerror", 'error');
	array_push($included_images, $image_name);
	}

	$body = substr_replace($body, $img_file, $m[1] + $offset, strlen($m[0]));
	$offset += strlen($img_file) - strlen($m[0]);
	}
	}
	}

	$mime_message->setHTMLBody($body);

	return $body;
	}

	// parse email address input
	function rcmail_mailto_format($mailto)
	{
	$regexp = array('/[,;]\s[\r\n]+/', '/[\r\n]+/', '/[,;]\s$/m', '/;/', '/(\S{1})(<\S+@\S+>)/U');
	$replace = array(', ', ', ', '', ',', '\\1 \\2');

	// replace new lines and strip ending ', ', make address input more valid
	$mailto = trim(preg_replace($regexp, $replace, $mailto));

	$result = array();
	$items = rcube_explode_quoted_string(',', $mailto);

	foreach($items as $item) {
	$item = trim($item);
	// address in brackets without name (do nothing)
	if (preg_match('/^<\S+@\S+>$/', $item)) {
	$result[] = $item;
	// address without brackets and without name (add brackets)
	} else if (preg_match('/^\S+@\S+$/', $item)) {
	$result[] = '<'.$item.'>';
	// address with name (handle name)
	} else if (preg_match('/\S+@\S+>*$/', $item, $matches)) {
	$address = $matches[0];
	$name = str_replace($address, '', $item);
	$name = trim($name);
	if ($name && ($name[0] != '"' \|\| $name[strlen($name)-1] != '"')
	&& preg_match('/[\<\>\\\.\[\]@,;:"]/', $name)) {
	$name = '"'.addcslashes($name, '"').'"';
	}
	if (!preg_match('/^<\S+@\S+>$/', $address))
	$address = '<'.$address.'>';

	$result[] = $name.' '.$address;
	} else if (trim($item)) {
	// @TODO: handle errors
	}
	}

	return implode(', ', $result);
	}

	/**** compose message ******/

	if (strlen($_POST['_draft_saveid']) > 3)
	$olddraftmessageid = get_input_value('_draft_saveid', RCUBE_INPUT_POST);

	$message_id = sprintf('<%s@%s>', md5(uniqid('rcmail'.rand(),true)), $RCMAIL->config->mail_domain($_SESSION['imap_host']));

	// set default charset
	$input_charset = $OUTPUT->get_charset();
	$message_charset = isset($_POST['_charset']) ? $_POST['_charset'] : $input_charset;

	$mailto = rcmail_mailto_format(get_input_value('_to', RCUBE_INPUT_POST, TRUE, $message_charset));
	$mailcc = rcmail_mailto_format(get_input_value('_cc', RCUBE_INPUT_POST, TRUE, $message_charset));
	$mailbcc = rcmail_mailto_format(get_input_value('_bcc', RCUBE_INPUT_POST, TRUE, $message_charset));

	if (empty($mailto) && !empty($mailcc)) {
	$mailto = $mailcc;
	$mailcc = null;
	}
	else if (empty($mailto))
	$mailto = 'undisclosed-recipients:;';

	// get sender name and address
	$from = get_input_value('_from', RCUBE_INPUT_POST);
	$identity_arr = rcmail_get_identity($from);

	if ($identity_arr)
	$from = $identity_arr['mailto'];

	if (empty($identity_arr['string']))
	$identity_arr['string'] = $from;

	// compose headers array
	$headers = array('Date' => date('r'),
	'From' => rcube_charset_convert($identity_arr['string'], RCMAIL_CHARSET, $message_charset),
	'To' => $mailto);

	// additional recipients
	if (!empty($mailcc))
	$headers['Cc'] = $mailcc;

	if (!empty($mailbcc))
	$headers['Bcc'] = $mailbcc;

	if (!empty($identity_arr['bcc']))
	$headers['Bcc'] = ($headers['Bcc'] ? $headers['Bcc'].', ' : '') . $identity_arr['bcc'];

	// add subject
	$headers['Subject'] = trim(get_input_value('_subject', RCUBE_INPUT_POST, FALSE, $message_charset));

	if (!empty($identity_arr['organization']))
	$headers['Organization'] = $identity_arr['organization'];

	if (!empty($_POST['_replyto']))
	$headers['Reply-To'] = rcmail_mailto_format(get_input_value('_replyto', RCUBE_INPUT_POST, TRUE, $message_charset));
	else if (!empty($identity_arr['reply-to']))
	$headers['Reply-To'] = $identity_arr['reply-to'];

	if (!empty($_SESSION['compose']['reply_msgid']))
	$headers['In-Reply-To'] = $_SESSION['compose']['reply_msgid'];

	if (!empty($_SESSION['compose']['references']))
	$headers['References'] = $_SESSION['compose']['references'];

	if (!empty($_POST['_priority']))
	{
	$priority = intval($_POST['_priority']);
	$a_priorities = array(1=>'highest', 2=>'high', 4=>'low', 5=>'lowest');
	if ($str_priority = $a_priorities[$priority])
	$headers['X-Priority'] = sprintf("%d (%s)", $priority, ucfirst($str_priority));
	}

	if (!empty($_POST['_receipt']))
	{
	$headers['Return-Receipt-To'] = $identity_arr['string'];
	$headers['Disposition-Notification-To'] = $identity_arr['string'];
	}

	// additional headers
	if ($CONFIG['http_received_header'])
	{
	$nldlm = $RCMAIL->config->header_delimiter() . "\t";
	$headers['Received'] = wordwrap('from ' . (isset($_SERVER['HTTP_X_FORWARDED_FOR']) ?
	gethostbyaddr($_SERVER['HTTP_X_FORWARDED_FOR']).' ['.$_SERVER['HTTP_X_FORWARDED_FOR'].']'.$nldlm.' via ' : '') .
	gethostbyaddr($_SERVER['REMOTE_ADDR']).' ['.$_SERVER['REMOTE_ADDR'].']'.$nldlm.'with ' .
	$_SERVER['SERVER_PROTOCOL'].' ('.$_SERVER['REQUEST_METHOD'].'); ' . date('r'),
	69, $nldlm);
	}

	$headers['Message-ID'] = $message_id;
	$headers['X-Sender'] = $from;

	if (!empty($CONFIG['useragent']))
	$headers['User-Agent'] = $CONFIG['useragent'];

	$isHtmlVal = strtolower(get_input_value('_is_html', RCUBE_INPUT_POST));
	$isHtml = ($isHtmlVal == "1");

	// fetch message body
	$message_body = get_input_value('_message', RCUBE_INPUT_POST, TRUE, $message_charset);

	if (!$savedraft) {
	// remove signature's div ID
	if ($isHtml)
	$message_body = preg_replace('/\s*id="_rc_sig"/', '', $message_body);

	// generic footer for all messages
	if (!empty($CONFIG['generic_message_footer'])) {
	$footer = file_get_contents(realpath($CONFIG['generic_message_footer']));
	$footer = rcube_charset_convert($footer, 'UTF-8', $message_charset);
	}
	}

	// create extended PEAR::Mail_mime instance
	$MAIL_MIME = new rcube_mail_mime($RCMAIL->config->header_delimiter());

	// For HTML-formatted messages, construct the MIME message with both
	// the HTML part and the plain-text part

	if ($isHtml)
	{
	$MAIL_MIME->setHTMLBody($message_body . ($footer ? "\r\n<pre>".$footer.'</pre>' : ''));

	// add a plain text version of the e-mail as an alternative part.
	- $h2t = new html2text($message_body);
	- $plainTextPart = $h2t->get_text() . ($footer ? "\r\n".$footer : '');
	+ $h2t = new html2text($message_body, false, true, 0);
	+ $plainTextPart = rc_wordwrap($h2t->get_text(), 75, "\r\n"). ($footer ? "\r\n".$footer : '');
	$plainTextPart = wordwrap($plainTextPart, 998, "\r\n", true);
	- if (!strlen($plainTextPart))
	+ if (!strlen($plainTextPart))
	{
	// empty message body breaks attachment handling in drafts
	$plainTextPart = "\r\n";
	}
	$MAIL_MIME->setTXTBody($plainTextPart);

	// look for "emoticon" images from TinyMCE and copy into message as attachments
	$message_body = rcmail_attach_emoticons($MAIL_MIME);
	}
	else
	{
	- $message_body = wordwrap($message_body, 75, "\r\n");
	+ $message_body = rc_wordwrap($message_body, 75, "\r\n");
	if ($footer)
	$message_body .= "\r\n" . $footer;
	$message_body = wordwrap($message_body, 998, "\r\n", true);
	if (!strlen($message_body))
	{
	// empty message body breaks attachment handling in drafts
	$message_body = "\r\n";
	}
	$MAIL_MIME->setTXTBody($message_body, FALSE, TRUE);
	}

	// chose transfer encoding
	$charset_7bit = array('ASCII', 'ISO-2022-JP', 'ISO-8859-1', 'ISO-8859-2', 'ISO-8859-15');
	$transfer_encoding = in_array(strtoupper($message_charset), $charset_7bit) ? '7bit' : '8bit';

	// add stored attachments, if any
	if (is_array($_SESSION['compose']['attachments']))
	foreach ($_SESSION['compose']['attachments'] as $id => $attachment)
	{
	$dispurl = '/\ssrc\s=\s[\'"]\S+display-attachment\S+file=rcmfile' . $id . '[\s\'"]\s/';
	$match = preg_match($dispurl, $message_body, $matches);
	if ($isHtml && ($match > 0))
	{
	$message_body = preg_replace($dispurl, ' src="'.$attachment['name'].'" ', $message_body);
	- $MAIL_MIME->setHTMLBody($message_body. ($footer ? "\r\n<pre>".$footer.'</pre>' : ''));
	+ $MAIL_MIME->setHTMLBody($message_body);
	$MAIL_MIME->addHTMLImage($attachment['path'], $attachment['mimetype'], $attachment['name']);
	}
	else
	{
	$ctype = str_replace('image/pjpeg', 'image/jpeg', $attachment['mimetype']); // #1484914

	// .eml attachments send inline
	$MAIL_MIME->addAttachment($attachment['path'],
	$ctype,
	$attachment['name'], true,
	($ctype == 'message/rfc822' ? $transfer_encoding : 'base64'),
	($ctype == 'message/rfc822' ? 'inline' : 'attachment'),
	$message_charset, '', '',
	$CONFIG['mime_param_folding'] ? 'quoted-printable' : NULL,
	$CONFIG['mime_param_folding'] == 2 ? 'quoted-printable' : NULL
	);
	}
	}

	// add submitted attachments
	if (is_array($_FILES['_attachments']['tmp_name']))
	foreach ($_FILES['_attachments']['tmp_name'] as $i => $filepath)
	{
	$ctype = $files['type'][$i];
	$ctype = str_replace('image/pjpeg', 'image/jpeg', $ctype); // #1484914

	$MAIL_MIME->addAttachment($filepath, $ctype, $files['name'][$i], true,
	$ctype == 'message/rfc822' ? $transfer_encoding : 'base64',
	'attachment', $message_charset, '', '',
	$CONFIG['mime_param_folding'] ? 'quoted-printable' : NULL,
	$CONFIG['mime_param_folding'] == 2 ? 'quoted-printable' : NULL
	);
	}


	// encoding settings for mail composing
	$MAIL_MIME->setParam(array(
	'text_encoding' => $transfer_encoding,
	'html_encoding' => 'quoted-printable',
	'head_encoding' => 'quoted-printable',
	'head_charset' => $message_charset,
	'html_charset' => $message_charset,
	'text_charset' => $message_charset,
	));

	// encoding subject header with mb_encode provides better results with asian characters
	if (function_exists("mb_encode_mimeheader"))
	{
	mb_internal_encoding($message_charset);
	$headers['Subject'] = mb_encode_mimeheader($headers['Subject'], $message_charset, 'Q');
	mb_internal_encoding(RCMAIL_CHARSET);
	}

	// pass headers to message object
	$MAIL_MIME->headers($headers);

	// Begin SMTP Delivery Block
	if (!$savedraft)
	{
	// check for 'From' address (identity may be incomplete)
	if ($identity_arr && !$identity_arr['mailto']) {
	$OUTPUT->show_message('nofromaddress', 'error');
	$OUTPUT->send('iframe');
	}

	$sent = rcmail_deliver_message($MAIL_MIME, $from, $mailto);

	// return to compose page if sending failed
	if (!$sent)
	{
	$OUTPUT->show_message("sendingfailed", 'error');
	$OUTPUT->send('iframe');
	}

	// save message sent time
	if (!empty($CONFIG['sendmail_delay']))
	$RCMAIL->user->save_prefs(array('last_message_time' => time()));

	// set replied/forwarded flag
	if ($_SESSION['compose']['reply_uid'])
	$IMAP->set_flag($_SESSION['compose']['reply_uid'], 'ANSWERED');
	else if ($_SESSION['compose']['forward_uid'])
	$IMAP->set_flag($_SESSION['compose']['forward_uid'], 'FORWARDED');

	} // End of SMTP Delivery Block



	// Determine which folder to save message
	if ($savedraft)
	$store_target = $CONFIG['drafts_mbox'];
	else
	$store_target = isset($_POST['_store_target']) ? get_input_value('_store_target', RCUBE_INPUT_POST) : $CONFIG['sent_mbox'];

	if ($store_target)
	{
	// check if mailbox exists
	if (!in_array_nocase($store_target, $IMAP->list_mailboxes()))
	{
	// folder may be existing but not subscribed (#1485241)
	if (!in_array_nocase($store_target, $IMAP->list_unsubscribed()))
	$store_folder = $IMAP->create_mailbox($store_target, TRUE);
	else if ($IMAP->subscribe($store_target))
	$store_folder = TRUE;
	}
	else
	$store_folder = TRUE;

	// append message to sent box
	if ($store_folder)
	$saved = $IMAP->save_message($store_target, $MAIL_MIME->getMessage());

	// raise error if saving failed
	if (!$saved)
	{
	raise_error(array('code' => 800, 'type' => 'imap', 'file' => __FILE__,
	'message' => "Could not save message in $store_target"), TRUE, FALSE);

	if ($savedraft) {
	$OUTPUT->show_message('errorsaving', 'error');
	$OUTPUT->send('iframe');
	}
	}

	if ($olddraftmessageid)
	{
	// delete previous saved draft
	$a_deleteid = $IMAP->search($CONFIG['drafts_mbox'], 'HEADER Message-ID '.$olddraftmessageid);

	$deleted = $IMAP->delete_message($IMAP->get_uid($a_deleteid[0], $CONFIG['drafts_mbox']), $CONFIG['drafts_mbox']);

	// raise error if deletion of old draft failed
	if (!$deleted)
	raise_error(array('code' => 800, 'type' => 'imap', 'file' => __FILE__,
	'message' => "Could not delete message from ".$CONFIG['drafts_mbox']), TRUE, FALSE);
	}
	}

	if ($savedraft)
	{
	$msgid = strtr($message_id, array('>' => '', '<' => ''));

	// remember new draft-uid
	$draftids = $IMAP->search($CONFIG['drafts_mbox'], 'HEADER Message-ID '.$msgid);
	$_SESSION['compose']['param']['_draft_uid'] = $IMAP->get_uid($draftids[0], $CONFIG['drafts_mbox']);

	// display success
	$OUTPUT->show_message('messagesaved', 'confirmation');

	// update "_draft_saveid" and the "cmp_hash" to prevent "Unsaved changes" warning
	$OUTPUT->command('set_draft_id', $msgid);
	$OUTPUT->command('compose_field_hash', true);

	// start the auto-save timer again
	$OUTPUT->command('auto_save_start');

	$OUTPUT->send('iframe');
	}
	else
	{
	rcmail_compose_cleanup();

	if ($store_folder && !$saved)
	$OUTPUT->command('sent_successfully', 'error', rcube_label('errorsavingsent'));
	else
	$OUTPUT->command('sent_successfully', 'confirmation', rcube_label('messagesent'));
	$OUTPUT->send('iframe');
	}

	?>

File Metadata

Mime Type: text/x-diff
Expires: Sat, Mar 1, 1:11 PM (1 h, 45 m)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 167094
Default Alt Text: (138 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions