diff --git a/plugins/libkolab/lib/kolab_format_task.php b/plugins/libkolab/lib/kolab_format_task.php
index 465ba901..b3c6a42e 100644
--- a/plugins/libkolab/lib/kolab_format_task.php
+++ b/plugins/libkolab/lib/kolab_format_task.php
@@ -1,130 +1,130 @@
 <?php
 
 /**
  * Kolab Task (ToDo) model class
  *
  * @version @package_version@
  * @author Thomas Bruederli <bruederli@kolabsys.com>
  *
  * Copyright (C) 2012, Kolab Systems AG <contact@kolabsys.com>
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU Affero General Public License as
  * published by the Free Software Foundation, either version 3 of the
  * License, or (at your option) any later version.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  * GNU Affero General Public License for more details.
  *
  * You should have received a copy of the GNU Affero General Public License
  * along with this program. If not, see <http://www.gnu.org/licenses/>.
  */
 
 class kolab_format_task extends kolab_format_xcal
 {
     public $CTYPEv2 = 'application/x-vnd.kolab.task';
 
     protected $objclass = 'Todo';
     protected $read_func = 'readTodo';
     protected $write_func = 'writeTodo';
 
 
     /**
      * Set properties to the kolabformat object
      *
      * @param array  Object data as hash array
      */
     public function set(&$object)
     {
         // set common xcal properties
         parent::set($object);
 
         $this->obj->setPercentComplete(intval($object['complete']));
 
         $status = kolabformat::StatusUndefined;
-        if ($object['complete'] == 100)
+        if ($object['complete'] == 100 && !array_key_exists('status', $object))
             $status = kolabformat::StatusCompleted;
         else if ($object['status'] && array_key_exists($object['status'], $this->status_map))
             $status = $this->status_map[$object['status']];
         $this->obj->setStatus($status);
 
         $this->obj->setStart(self::get_datetime($object['start'], null, $object['start']->_dateonly));
         $this->obj->setDue(self::get_datetime($object['due'], null, $object['due']->_dateonly));
 
         $related = new vectors;
         if (!empty($object['parent_id']))
             $related->push($object['parent_id']);
         $this->obj->setRelatedTo($related);
 
         // cache this data
         $this->data = $object;
         unset($this->data['_formatobj']);
     }
 
     /**
      *
      */
     public function is_valid()
     {
         return !$this->formaterror && ($this->data || (is_object($this->obj) && $this->obj->isValid()));
     }
 
     /**
      * Convert the Configuration object into a hash array data structure
      *
      * @param array Additional data for merge
      *
      * @return array  Config object data as hash array
      */
     public function to_array($data = array())
     {
         // return cached result
         if (!empty($this->data))
             return $this->data;
 
         // read common xcal props
         $object = parent::to_array($data);
 
         $object['complete'] = intval($this->obj->percentComplete());
 
         // if due date is set
         if ($due = $this->obj->due())
             $object['due'] = self::php_datetime($due);
 
         // related-to points to parent task; we only support one relation
         $related = self::vector2array($this->obj->relatedTo());
         if (count($related))
             $object['parent_id'] = $related[0];
 
         // TODO: map more properties
 
         $this->data = $object;
         return $this->data;
     }
 
     /**
      * Callback for kolab_storage_cache to get object specific tags to cache
      *
      * @return array List of tags to save in cache
      */
     public function get_tags()
     {
         $tags = array();
 
-        if ($this->data['status'] == 'COMPLETED' || $this->data['complete'] == 100)
+        if ($this->data['status'] == 'COMPLETED' || ($this->data['complete'] == 100 && empty($this->data['status'])))
             $tags[] = 'x-complete';
 
         if ($this->data['priority'] == 1)
             $tags[] = 'x-flagged';
 
         if (!empty($this->data['valarms']))
             $tags[] = 'x-has-alarms';
 
         if ($this->data['parent_id'])
             $tags[] = 'x-parent:' . $this->data['parent_id'];
 
         return $tags;
     }
 }
diff --git a/plugins/tasklist/drivers/database/SQL/mysql.initial.sql b/plugins/tasklist/drivers/database/SQL/mysql.initial.sql
index 2746ca4c..aae636da 100644
--- a/plugins/tasklist/drivers/database/SQL/mysql.initial.sql
+++ b/plugins/tasklist/drivers/database/SQL/mysql.initial.sql
@@ -1,51 +1,52 @@
 /**
  * Roundcube Tasklist plugin database
  *
  * @version @package_version@
  * @author Thomas Bruederli
  * @licence GNU AGPL
  * @copyright (C) 2012, Kolab Systems AG
  */
 
 CREATE TABLE IF NOT EXISTS `tasklists` (
   `tasklist_id` int(10) unsigned NOT NULL AUTO_INCREMENT,
   `user_id` int(10) unsigned NOT NULL,
   `name` varchar(255) NOT NULL,
   `color` varchar(8) NOT NULL,
   `showalarms` tinyint(2) unsigned NOT NULL DEFAULT '0',
   PRIMARY KEY (`tasklist_id`),
   KEY `user_id` (`user_id`),
   CONSTRAINT `fk_tasklist_user_id` FOREIGN KEY (`user_id`)
     REFERENCES `users`(`user_id`) ON DELETE CASCADE ON UPDATE CASCADE
 ) /*!40000 ENGINE=InnoDB CHARACTER SET utf8 COLLATE utf8_general_ci */;
 
 CREATE TABLE IF NOT EXISTS `tasks` (
   `task_id` int(10) unsigned NOT NULL AUTO_INCREMENT,
   `tasklist_id` int(10) unsigned NOT NULL,
   `parent_id` int(10) unsigned DEFAULT NULL,
   `uid` varchar(255) NOT NULL,
   `created` datetime NOT NULL,
   `changed` datetime NOT NULL,
   `del` tinyint(1) unsigned NOT NULL DEFAULT '0',
   `title` varchar(255) NOT NULL,
   `description` text,
   `tags` text,
   `date` varchar(10) DEFAULT NULL,
   `time` varchar(5) DEFAULT NULL,
   `startdate` varchar(10) DEFAULT NULL,
   `starttime` varchar(5) DEFAULT NULL,
   `flagged` tinyint(4) NOT NULL DEFAULT '0',
   `complete` float NOT NULL DEFAULT '0',
+  `status` enum('','NEEDS-ACTION','IN-PROCESS','COMPLETED','CANCELLED') NOT NULL DEFAULT '',
   `alarms` varchar(255) DEFAULT NULL,
   `recurrence` varchar(255) DEFAULT NULL,
   `organizer` varchar(255) DEFAULT NULL,
   `attendees` text,
   `notify` datetime DEFAULT NULL,
   PRIMARY KEY (`task_id`),
   KEY `tasklisting` (`tasklist_id`,`del`,`date`),
   KEY `uid` (`uid`),
   CONSTRAINT `fk_tasks_tasklist_id` FOREIGN KEY (`tasklist_id`)
     REFERENCES `tasklists`(`tasklist_id`) ON DELETE CASCADE ON UPDATE CASCADE
 ) /*!40000 ENGINE=InnoDB CHARACTER SET utf8 COLLATE utf8_general_ci */;
 
-REPLACE INTO `system` (`name`, `value`) VALUES ('tasklist-database-version', '2013011000');
+REPLACE INTO `system` (`name`, `value`) VALUES ('tasklist-database-version', '2014051900');
diff --git a/plugins/tasklist/drivers/database/SQL/mysql/2014051900.sql b/plugins/tasklist/drivers/database/SQL/mysql/2014051900.sql
new file mode 100644
index 00000000..e5f9a620
--- /dev/null
+++ b/plugins/tasklist/drivers/database/SQL/mysql/2014051900.sql
@@ -0,0 +1,3 @@
+ALTER TABLE `tasks` ADD `status` ENUM('','NEEDS-ACTION','IN-PROCESS','COMPLETED','CANCELLED') NOT NULL DEFAULT '' AFTER `complete`;
+
+UPDATE `tasks` SET status='COMPLETED' WHERE complete=1.0 AND status='';
diff --git a/plugins/tasklist/drivers/database/SQL/postgres.initial.sql b/plugins/tasklist/drivers/database/SQL/postgres.initial.sql
index 4a445128..e5665c2d 100644
--- a/plugins/tasklist/drivers/database/SQL/postgres.initial.sql
+++ b/plugins/tasklist/drivers/database/SQL/postgres.initial.sql
@@ -1,63 +1,64 @@
 /**
  * Roundcube Tasklist plugin database
  *
  * @version @package_version@
  * @author Thomas Bruederli
  * @licence GNU AGPL
  * @copyright (C) 2014, Kolab Systems AG
  */
 
 CREATE SEQUENCE tasklists_seq
     INCREMENT BY 1
     NO MAXVALUE
     NO MINVALUE
     CACHE 1;
 
 CREATE TABLE tasklists (
     tasklist_id integer DEFAULT nextval('tasklists_seq'::regclass) NOT NULL,
     user_id integer NOT NULL
         REFERENCES users (user_id) ON UPDATE CASCADE ON DELETE CASCADE,
     name varchar(255) NOT NULL,
     color varchar(8) NOT NULL,
     showalarms smallint NOT NULL DEFAULT 0,
     PRIMARY KEY (tasklist_id)
 );
 
 CREATE INDEX tasklists_user_id_idx ON tasklists (user_id, name);
 
 CREATE SEQUENCE tasks_seq
     INCREMENT BY 1
     NO MAXVALUE
     NO MINVALUE
     CACHE 1;
 
 CREATE TABLE tasks (
     task_id integer DEFAULT nextval('tasks_seq'::regclass) NOT NULL,
     tasklist_id integer NOT NULL
         REFERENCES tasklists (tasklist_id) ON UPDATE CASCADE ON DELETE CASCADE,
     parent_id integer DEFAULT NULL,
     uid varchar(255) NOT NULL,
     created timestamp without time zone DEFAULT now() NOT NULL,
     changed timestamp without time zone DEFAULT now() NOT NULL,
     del smallint NOT NULL DEFAULT '0',
     title varchar(255) NOT NULL,
     description text,
     tags text,
     date varchar(10) DEFAULT NULL,
     time varchar(5) DEFAULT NULL,
     startdate varchar(10) DEFAULT NULL,
     starttime varchar(5) DEFAULT NULL,
     flagged smallint NOT NULL DEFAULT 0,
     complete float NOT NULL DEFAULT 0,
+    status varchar(16) NOT NULL DEFAULT '',
     alarms varchar(255) DEFAULT NULL,
     recurrence varchar(255) DEFAULT NULL,
     organizer varchar(255) DEFAULT NULL,
     attendees text,
     notify timestamp without time zone DEFAULT NULL,
     PRIMARY KEY (task_id)
 );
 
 CREATE INDEX tasks_tasklisting_idx ON tasks (tasklist_id, del, date);
 CREATE INDEX tasks_uid_idx ON tasks (uid);
 
-INSERT INTO system (name, value) VALUES ('tasklist-database-version', '2013011000');
+INSERT INTO system (name, value) VALUES ('tasklist-database-version', '2014051900');
diff --git a/plugins/tasklist/drivers/database/tasklist_database_driver.php b/plugins/tasklist/drivers/database/tasklist_database_driver.php
index d9bf4145..6c1e0ea4 100644
--- a/plugins/tasklist/drivers/database/tasklist_database_driver.php
+++ b/plugins/tasklist/drivers/database/tasklist_database_driver.php
@@ -1,808 +1,811 @@
 <?php
 
 /**
  * Database driver for the Tasklist plugin
  *
  * @version @package_version@
  * @author Thomas Bruederli <bruederli@kolabsys.com>
  *
  * Copyright (C) 2012, Kolab Systems AG <contact@kolabsys.com>
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU Affero General Public License as
  * published by the Free Software Foundation, either version 3 of the
  * License, or (at your option) any later version.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  * GNU Affero General Public License for more details.
  *
  * You should have received a copy of the GNU Affero General Public License
  * along with this program. If not, see <http://www.gnu.org/licenses/>.
  */
 
 class tasklist_database_driver extends tasklist_driver
 {
+    const IS_COMPLETE_SQL = "(status='COMPLETED' OR (complete=1 AND status=''))";
+
     public $undelete = true; // yes, we can
     public $sortable = false;
     public $alarm_types = array('DISPLAY');
 
     private $rc;
     private $plugin;
     private $lists = array();
     private $list_ids = '';
 
     private $db_tasks = 'tasks';
     private $db_lists = 'tasklists';
 
 
     /**
      * Default constructor
      */
     public function __construct($plugin)
     {
         $this->rc = $plugin->rc;
         $this->plugin = $plugin;
 
         // read database config
         $db = $this->rc->get_dbh();
         $this->db_lists = $this->rc->config->get('db_table_lists', $db->table_name($this->db_lists));
         $this->db_tasks = $this->rc->config->get('db_table_tasks', $db->table_name($this->db_tasks));
 
         $this->_read_lists();
     }
 
     /**
      * Read available calendars for the current user and store them internally
      */
     private function _read_lists()
     {
       $hidden = array_filter(explode(',', $this->rc->config->get('hidden_tasklists', '')));
 
       if (!empty($this->rc->user->ID)) {
         $list_ids = array();
         $result = $this->rc->db->query(
           "SELECT *, tasklist_id AS id FROM " . $this->db_lists . "
            WHERE user_id=?
            ORDER BY CASE WHEN name='INBOX' THEN 0 ELSE 1 END, name",
            $this->rc->user->ID
         );
 
         while ($result && ($arr = $this->rc->db->fetch_assoc($result))) {
           $arr['showalarms'] = intval($arr['showalarms']);
           $arr['active'] = !in_array($arr['id'], $hidden);
           $arr['name'] = html::quote($arr['name']);
           $arr['listname'] = html::quote($arr['name']);
           $arr['editable'] = true;
           $this->lists[$arr['id']] = $arr;
           $list_ids[] = $this->rc->db->quote($arr['id']);
         }
         $this->list_ids = join(',', $list_ids);
       }
     }
 
     /**
      * Get a list of available tasks lists from this source
      */
     public function get_lists()
     {
       // attempt to create a default list for this user
       if (empty($this->lists)) {
         $prop = array('name' => 'Default', 'color' => '000000');
         if ($this->create_list($prop))
           $this->_read_lists();
       }
 
       return $this->lists;
     }
 
     /**
      * Create a new list assigned to the current user
      *
      * @param array Hash array with list properties
      * @return mixed ID of the new list on success, False on error
      * @see tasklist_driver::create_list()
      */
     public function create_list(&$prop)
     {
         $result = $this->rc->db->query(
             "INSERT INTO " . $this->db_lists . "
              (user_id, name, color, showalarms)
              VALUES (?, ?, ?, ?)",
             $this->rc->user->ID,
             strval($prop['name']),
             strval($prop['color']),
             $prop['showalarms']?1:0
         );
 
         if ($result)
             return $this->rc->db->insert_id($this->db_lists);
 
         return false;
     }
 
     /**
      * Update properties of an existing tasklist
      *
      * @param array Hash array with list properties
      * @return boolean True on success, Fales on failure
      * @see tasklist_driver::edit_list()
      */
     public function edit_list(&$prop)
     {
         $query = $this->rc->db->query(
             "UPDATE " . $this->db_lists . "
              SET   name=?, color=?, showalarms=?
              WHERE tasklist_id=?
              AND   user_id=?",
             $prop['name'],
             $prop['color'],
             $prop['showalarms']?1:0,
             $prop['id'],
             $this->rc->user->ID
         );
 
         return $this->rc->db->affected_rows($query);
     }
 
     /**
      * Set active/subscribed state of a list
      *
      * @param array Hash array with list properties
      * @return boolean True on success, Fales on failure
      * @see tasklist_driver::subscribe_list()
      */
     public function subscribe_list($prop)
     {
         $hidden = array_flip(explode(',', $this->rc->config->get('hidden_tasklists', '')));
 
         if ($prop['active'])
             unset($hidden[$prop['id']]);
         else
             $hidden[$prop['id']] = 1;
 
         return $this->rc->user->save_prefs(array('hidden_tasklists' => join(',', array_keys($hidden))));
     }
 
     /**
      * Delete the given list with all its contents
      *
      * @param array Hash array with list properties
      * @return boolean True on success, Fales on failure
      * @see tasklist_driver::remove_list()
      */
     public function remove_list($prop)
     {
         $list_id = $prop['id'];
 
         if ($this->lists[$list_id]) {
             // delete all tasks linked with this list
             $this->rc->db->query(
                 "DELETE FROM " . $this->db_tasks . "
                  WHERE tasklist_id=?",
                 $list_id
             );
 
             // delete list record
             $query = $this->rc->db->query(
                 "DELETE FROM " . $this->db_lists . "
                  WHERE tasklist_id=?
                  AND user_id=?",
                 $list_id,
                 $this->rc->user->ID
             );
 
             return $this->rc->db->affected_rows($query);
         }
 
         return false;
     }
 
     /**
      * Get number of tasks matching the given filter
      *
      * @param array List of lists to count tasks of
      * @return array Hash array with counts grouped by status (all|flagged|today|tomorrow|overdue|nodate)
      * @see tasklist_driver::count_tasks()
      */
     function count_tasks($lists = null)
     {
         if (empty($lists))
             $lists = array_keys($this->lists);
         else if (is_string($lists))
             $lists = explode(',', $lists);
 
         // only allow to select from lists of this user
         $list_ids = array_map(array($this->rc->db, 'quote'), array_intersect($lists, array_keys($this->lists)));
 
         $today_date = new DateTime('now', $this->plugin->timezone);
         $today = $today_date->format('Y-m-d');
         $tomorrow_date = new DateTime('now + 1 day', $this->plugin->timezone);
         $tomorrow = $tomorrow_date->format('Y-m-d');
 
         $result = $this->rc->db->query(sprintf(
             "SELECT task_id, flagged, date FROM " . $this->db_tasks . "
              WHERE tasklist_id IN (%s)
-             AND del=0 AND complete<1",
+             AND del=0 AND NOT " . self::IS_COMPLETE_SQL,
             join(',', $list_ids)
         ));
 
         $counts = array('all' => 0, 'flagged' => 0, 'today' => 0, 'tomorrow' => 0, 'overdue' => 0, 'nodate' => 0);
         while ($result && ($rec = $this->rc->db->fetch_assoc($result))) {
             $counts['all']++;
             if ($rec['flagged'])
                 $counts['flagged']++;
             if (empty($rec['date']))
                 $counts['nodate']++;
             else if ($rec['date'] == $today)
                 $counts['today']++;
             else if ($rec['date'] == $tomorrow)
                 $counts['tomorrow']++;
             else if ($rec['date'] < $today)
                 $counts['overdue']++;
         }
 
         return $counts;
     }
 
     /**
      * Get all taks records matching the given filter
      *
      * @param array Hash array wiht filter criterias
      * @param array List of lists to get tasks from
      * @return array List of tasks records matchin the criteria
      * @see tasklist_driver::list_tasks()
      */
     function list_tasks($filter, $lists = null)
     {
         if (empty($lists))
             $lists = array_keys($this->lists);
         else if (is_string($lists))
             $lists = explode(',', $lists);
 
         // only allow to select from lists of this user
         $list_ids = array_map(array($this->rc->db, 'quote'), array_intersect($lists, array_keys($this->lists)));
         $sql_add = '';
 
         // add filter criteria
         if ($filter['from'] || ($filter['mask'] & tasklist::FILTER_MASK_TODAY)) {
             $sql_add .= ' AND (date IS NULL OR date >= ?)';
             $datefrom = $filter['from'];
         }
         if ($filter['to']) {
             if ($filter['mask'] & tasklist::FILTER_MASK_OVERDUE)
                 $sql_add .= ' AND (date IS NOT NULL AND date <= ' . $this->rc->db->quote($filter['to']) . ')';
             else
                 $sql_add .= ' AND (date IS NULL OR date <= ' . $this->rc->db->quote($filter['to']) . ')';
         }
 
         // special case 'today': also show all events with date before today
         if ($filter['mask'] & tasklist::FILTER_MASK_TODAY) {
             $datefrom = date('Y-m-d', 0);
         }
 
         if ($filter['mask'] & tasklist::FILTER_MASK_NODATE)
             $sql_add = ' AND date IS NULL';
 
         if ($filter['mask'] & tasklist::FILTER_MASK_COMPLETE)
-            $sql_add .= ' AND complete=1';
+            $sql_add .= ' AND ' . self::IS_COMPLETE_SQL;
         else if (empty($filter['since']))  // don't show complete tasks by default
-            $sql_add .= ' AND complete<1';
+            $sql_add .= ' AND NOT ' . self::IS_COMPLETE_SQL;
 
         if ($filter['mask'] & tasklist::FILTER_MASK_FLAGGED)
             $sql_add .= ' AND flagged=1';
 
         // compose (slow) SQL query for searching
         // FIXME: improve searching using a dedicated col and normalized values
         if ($filter['search']) {
             $sql_query = array();
             foreach (array('title','description','organizer','attendees') as $col)
                 $sql_query[] = $this->rc->db->ilike($col, '%'.$filter['search'].'%');
             $sql_add = 'AND (' . join(' OR ', $sql_query) . ')';
         }
 
         if ($filter['since'] && is_numeric($filter['since'])) {
             $sql_add .= ' AND changed >= ' . $this->rc->db->quote(date('Y-m-d H:i:s', $filter['since']));
         }
 
         $tasks = array();
         if (!empty($list_ids)) {
             $result = $this->rc->db->query(sprintf(
                 "SELECT * FROM " . $this->db_tasks . "
                  WHERE tasklist_id IN (%s)
                  AND del=0
                  %s
                  ORDER BY parent_id, task_id ASC",
                  join(',', $list_ids),
                  $sql_add
                 ),
                 $datefrom
            );
 
             while ($result && ($rec = $this->rc->db->fetch_assoc($result))) {
                 $tasks[] = $this->_read_postprocess($rec);
             }
         }
 
         return $tasks;
     }
 
     /**
      * Return data of a specific task
      *
      * @param mixed  Hash array with task properties or task UID
      * @return array Hash array with task properties or false if not found
      */
     public function get_task($prop)
     {
         if (is_string($prop))
             $prop['uid'] = $prop;
 
         $query_col = $prop['id'] ? 'task_id' : 'uid';
 
         $result = $this->rc->db->query(sprintf(
              "SELECT * FROM " . $this->db_tasks . "
               WHERE tasklist_id IN (%s)
               AND %s=?
               AND del=0",
               $this->list_ids,
               $query_col
              ),
              $prop['id'] ? $prop['id'] : $prop['uid']
         );
 
         if ($result && ($rec = $this->rc->db->fetch_assoc($result))) {
              return $this->_read_postprocess($rec);
         }
 
         return false;
     }
 
     /**
      * Get all decendents of the given task record
      *
      * @param mixed  Hash array with task properties or task UID
      * @param boolean True if all childrens children should be fetched
      * @return array List of all child task IDs
      */
     public function get_childs($prop, $recursive = false)
     {
         // resolve UID first
         if (is_string($prop)) {
             $result = $this->rc->db->query(sprintf(
                 "SELECT task_id AS id, tasklist_id AS list FROM " . $this->db_tasks . "
                  WHERE tasklist_id IN (%s)
                  AND uid=?",
                  $this->list_ids
                 ),
                 $prop);
             $prop = $this->rc->db->fetch_assoc($result);
         }
 
         $childs = array();
         $task_ids = array($prop['id']);
 
         // query for childs (recursively)
         while (!empty($task_ids)) {
             $result = $this->rc->db->query(sprintf(
                 "SELECT task_id AS id FROM " . $this->db_tasks . "
                  WHERE tasklist_id IN (%s)
                  AND parent_id IN (%s)
                  AND del=0",
                 $this->list_ids,
                 join(',', array_map(array($this->rc->db, 'quote'), $task_ids))
             ));
 
             $task_ids = array();
             while ($result && ($rec = $this->rc->db->fetch_assoc($result))) {
                 $childs[] = $rec['id'];
                 $task_ids[] = $rec['id'];
             }
 
             if (!$recursive)
                 break;
         }
 
         return $childs;
     }
 
     /**
      * Get a list of pending alarms to be displayed to the user
      *
      * @param  integer Current time (unix timestamp)
      * @param  mixed   List of list IDs to show alarms for (either as array or comma-separated string)
      * @return array   A list of alarms, each encoded as hash array with task properties
      * @see tasklist_driver::pending_alarms()
      */
     public function pending_alarms($time, $lists = null)
     {
         if (empty($lists))
             $lists = array_keys($this->lists);
         else if (is_string($lists))
             $lists = explode(',', $lists);
 
         // only allow to select from calendars with activated alarms
         $list_ids = array();
         foreach ($lists as $lid) {
             if ($this->lists[$lid] && $this->lists[$lid]['showalarms'])
                 $list_ids[] = $lid;
         }
         $list_ids = array_map(array($this->rc->db, 'quote'), $list_ids);
 
         $alarms = array();
         if (!empty($list_ids)) {
             $result = $this->rc->db->query(sprintf(
                 "SELECT * FROM " . $this->db_tasks . "
                  WHERE tasklist_id IN (%s)
-                 AND notify <= %s AND complete < 1",
+                 AND notify <= %s AND NOT " . self::IS_COMPLETE_SQL,
                 join(',', $list_ids),
                 $this->rc->db->fromunixtime($time)
             ));
 
             while ($result && ($rec = $this->rc->db->fetch_assoc($result)))
                 $alarms[] = $this->_read_postprocess($rec);
         }
 
         return $alarms;
     }
 
     /**
      * Feedback after showing/sending an alarm notification
      *
      * @see tasklist_driver::dismiss_alarm()
      */
     public function dismiss_alarm($task_id, $snooze = 0)
     {
         // set new notifyat time or unset if not snoozed
         $notify_at = $snooze > 0 ? date('Y-m-d H:i:s', time() + $snooze) : null;
 
         $query = $this->rc->db->query(sprintf(
             "UPDATE " . $this->db_tasks . "
              SET   changed=%s, notify=?
              WHERE task_id=?
              AND tasklist_id IN (" . $this->list_ids . ")",
             $this->rc->db->now()),
             $notify_at,
             $task_id
         );
 
         return $this->rc->db->affected_rows($query);
     }
 
     /**
      * Remove alarm dismissal or snooze state
      *
      * @param  string  Task identifier
      */
     public function clear_alarms($id)
     {
         // Nothing to do here. Alarms are reset in edit_task()
     }
 
     /**
      * Map some internal database values to match the generic "API"
      */
     private function _read_postprocess($rec)
     {
         $rec['id'] = $rec['task_id'];
         $rec['list'] = $rec['tasklist_id'];
         $rec['changed'] = new DateTime($rec['changed']);
         $rec['tags'] = array_filter(explode(',', $rec['tags']));
 
         if (!$rec['parent_id'])
             unset($rec['parent_id']);
 
         // decode serialized alarms
         if ($rec['alarms']) {
             $rec['valarms'] = $this->unserialize_alarms($rec['alarms']);
             unset($rec['alarms']);
         }
 
         // decode serialze recurrence rules
         if ($rec['recurrence']) {
             $rec['recurrence'] = $this->unserialize_recurrence($rec['recurrence']);
         }
 
         unset($rec['task_id'], $rec['tasklist_id'], $rec['created']);
         return $rec;
     }
 
     /**
      * Add a single task to the database
      *
      * @param array Hash array with task properties (see header of this file)
      * @return mixed New event ID on success, False on error
      * @see tasklist_driver::create_task()
      */
     public function create_task($prop)
     {
         // check list permissions
         $list_id = $prop['list'] ? $prop['list'] : reset(array_keys($this->lists));
         if (!$this->lists[$list_id] || $this->lists[$list_id]['readonly'])
             return false;
 
         if (is_array($prop['valarms'])) {
             $prop['alarms'] = $this->serialize_alarms($prop['valarms']);
         }
         if (is_array($prop['recurrence'])) {
             $prop['recurrence'] = $this->serialize_recurrence($prop['recurrence']);
         }
 
-        foreach (array('parent_id', 'date', 'time', 'startdate', 'starttime', 'alarms', 'recurrence') as $col) {
+        foreach (array('parent_id', 'date', 'time', 'startdate', 'starttime', 'alarms', 'recurrence', 'status') as $col) {
             if (empty($prop[$col]))
                 $prop[$col] = null;
         }
 
         $notify_at = $this->_get_notification($prop);
         $result = $this->rc->db->query(sprintf(
             "INSERT INTO " . $this->db_tasks . "
-             (tasklist_id, uid, parent_id, created, changed, title, date, time, startdate, starttime, description, tags, flagged, complete, alarms, recurrence, notify)
-             VALUES (?, ?, ?, %s, %s, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)",
+             (tasklist_id, uid, parent_id, created, changed, title, date, time, startdate, starttime, description, tags, flagged, complete, status, alarms, recurrence, notify)
+             VALUES (?, ?, ?, %s, %s, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)",
              $this->rc->db->now(),
              $this->rc->db->now()
             ),
             $list_id,
             $prop['uid'],
             $prop['parent_id'],
             $prop['title'],
             $prop['date'],
             $prop['time'],
             $prop['startdate'],
             $prop['starttime'],
             strval($prop['description']),
             join(',', (array)$prop['tags']),
             $prop['flagged'] ? 1 : 0,
             intval($prop['complete']),
+            $prop['status'],
             $prop['alarms'],
             $prop['recurrence'],
             $notify_at
         );
 
         if ($result)
             return $this->rc->db->insert_id($this->db_tasks);
 
         return false;
     }
 
     /**
      * Update an task entry with the given data
      *
      * @param array Hash array with task properties
      * @return boolean True on success, False on error
      * @see tasklist_driver::edit_task()
      */
     public function edit_task($prop)
     {
         if (is_array($prop['valarms'])) {
             $prop['alarms'] = $this->serialize_alarms($prop['valarms']);
         }
         if (is_array($prop['recurrence'])) {
             $prop['recurrence'] = $this->serialize_recurrence($prop['recurrence']);
         }
 
         $sql_set = array();
         foreach (array('title', 'description', 'flagged', 'complete') as $col) {
             if (isset($prop[$col]))
                 $sql_set[] = $this->rc->db->quote_identifier($col) . '=' . $this->rc->db->quote($prop[$col]);
         }
-        foreach (array('parent_id', 'date', 'time', 'startdate', 'starttime', 'alarms', 'recurrence') as $col) {
+        foreach (array('parent_id', 'date', 'time', 'startdate', 'starttime', 'alarms', 'recurrence', 'status') as $col) {
             if (isset($prop[$col]))
                 $sql_set[] = $this->rc->db->quote_identifier($col) . '=' . (empty($prop[$col]) ? 'NULL' : $this->rc->db->quote($prop[$col]));
         }
         if (isset($prop['tags']))
             $sql_set[] = $this->rc->db->quote_identifier('tags') . '=' . $this->rc->db->quote(join(',', (array)$prop['tags']));
 
         if (isset($prop['date']) || isset($prop['time']) || isset($prop['alarms'])) {
             $notify_at = $this->_get_notification($prop);
             $sql_set[] = $this->rc->db->quote_identifier('notify') . '=' . (empty($notify_at) ? 'NULL' : $this->rc->db->quote($notify_at));
         }
 
         // moved from another list
         if ($prop['_fromlist'] && ($newlist = $prop['list'])) {
             $sql_set[] = 'tasklist_id=' . $this->rc->db->quote($newlist);
         }
 
         $query = $this->rc->db->query(sprintf(
             "UPDATE " . $this->db_tasks . "
              SET   changed=%s %s
              WHERE task_id=?
              AND   tasklist_id IN (%s)",
             $this->rc->db->now(),
             ($sql_set ? ', ' . join(', ', $sql_set) : ''),
             $this->list_ids
           ),
           $prop['id']
         );
 
         return $this->rc->db->affected_rows($query);
     }
 
     /**
      * Move a single task to another list
      *
      * @param array   Hash array with task properties:
      * @return boolean True on success, False on error
      * @see tasklist_driver::move_task()
      */
     public function move_task($prop)
     {
         return $this->edit_task($prop);
     }
 
     /**
      * Remove a single task from the database
      *
      * @param array   Hash array with task properties
      * @param boolean Remove record irreversible
      * @return boolean True on success, False on error
      * @see tasklist_driver::delete_task()
      */
     public function delete_task($prop, $force = true)
     {
         $task_id = $prop['id'];
 
         if ($task_id && $force) {
             $query = $this->rc->db->query(
                 "DELETE FROM " . $this->db_tasks . "
                  WHERE task_id=?
                  AND tasklist_id IN (" . $this->list_ids . ")",
                 $task_id
             );
         }
         else if ($task_id) {
             $query = $this->rc->db->query(sprintf(
                 "UPDATE " . $this->db_tasks . "
                  SET   changed=%s, del=1
                  WHERE task_id=?
                  AND   tasklist_id IN (%s)",
                 $this->rc->db->now(),
                 $this->list_ids
               ),
               $task_id
             );
         }
 
         return $this->rc->db->affected_rows($query);
     }
 
     /**
      * Restores a single deleted task (if supported)
      *
      * @param array Hash array with task properties
      * @return boolean True on success, False on error
      * @see tasklist_driver::undelete_task()
      */
     public function undelete_task($prop)
     {
         $query = $this->rc->db->query(sprintf(
             "UPDATE " . $this->db_tasks . "
              SET   changed=%s, del=0
              WHERE task_id=?
              AND   tasklist_id IN (%s)",
             $this->rc->db->now(),
             $this->list_ids
           ),
           $prop['id']
         );
 
         return $this->rc->db->affected_rows($query);
     }
 
     /**
      * Compute absolute time to notify the user
      */
     private function _get_notification($task)
     {
-        if ($task['valarms'] && $task['complete'] < 1) {
+        if ($task['valarms'] && !$this->is_complete($task)) {
             $alarm = libcalendaring::get_next_alarm($task, 'task');
 
         if ($alarm['time'] && in_array($alarm['action'], $this->alarm_types))
           return date('Y-m-d H:i:s', $alarm['time']);
       }
 
       return null;
     }
 
     /**
      * Helper method to serialize the list of alarms into a string
      */
     private function serialize_alarms($valarms)
     {
         foreach ((array)$valarms as $i => $alarm) {
             if ($alarm['trigger'] instanceof DateTime) {
                 $valarms[$i]['trigger'] = '@' . $alarm['trigger']->format('c');
             }
         }
 
         return $valarms ? json_encode($valarms) : null;
     }
 
     /**
      * Helper method to decode a serialized list of alarms
      */
     private function unserialize_alarms($alarms)
     {
         // decode json serialized alarms
         if ($alarms && $alarms[0] == '[') {
             $valarms = json_decode($alarms, true);
             foreach ($valarms as $i => $alarm) {
                 if ($alarm['trigger'][0] == '@') {
                     try {
                         $valarms[$i]['trigger'] = new DateTime(substr($alarm['trigger'], 1));
                     }
                     catch (Exception $e) {
                         unset($valarms[$i]);
                     }
                 }
             }
         }
         // convert legacy alarms data
         else if (strlen($alarms)) {
             list($trigger, $action) = explode(':', $alarms, 2);
             if ($trigger = libcalendaring::parse_alaram_value($trigger)) {
                 $valarms = array(array('action' => $action, 'trigger' => $trigger[3] ?: $trigger[0]));
             }
         }
 
         return $valarms;
     }
 
     /**
      * Helper method to serialize task recurrence properties
      */
     private function serialize_recurrence($recurrence)
     {
         foreach ((array)$recurrence as $k => $val) {
             if ($val instanceof DateTime) {
                 $recurrence[$k] = '@' . $val->format('c');
             }
         }
 
         return $recurrence ? json_encode($recurrence) : null;
     }
 
     /**
      * Helper method to decode a serialized task recurrence struct
      */
     private function unserialize_recurrence($ser)
     {
         if (strlen($ser)) {
             $recurrence = json_decode($ser, true);
             foreach ((array)$recurrence as $k => $val) {
                 if ($val[0] == '@') {
                     try {
                         $recurrence[$k] = new DateTime(substr($val, 1));
                     }
                     catch (Exception $e) {
                         unset($recurrence[$k]);
                     }
                 }
             }
         }
         else {
             $recurrence = '';
         }
 
         return $recurrence;
     }
 
     /**
      * Handler for user_delete plugin hook
      */
     public function user_delete($args)
     {
         $db = $this->rc->db;
         $list_ids = array();
         $lists = $db->query("SELECT tasklist_id FROM " . $this->db_lists . " WHERE user_id=?", $args['user']->ID);
         while ($row = $db->fetch_assoc($lists)) {
             $list_ids[] = $row['tasklist_id'];
         }
 
         if (!empty($list_ids)) {
             foreach (array($this->db_tasks, $this->db_lists) as $table) {
                 $db->query(sprintf("DELETE FROM $table WHERE tasklist_id IN (%s)", join(',', $list_ids)));
             }
         }
     }
 }
diff --git a/plugins/tasklist/drivers/kolab/tasklist_kolab_driver.php b/plugins/tasklist/drivers/kolab/tasklist_kolab_driver.php
index ad36777b..31185231 100644
--- a/plugins/tasklist/drivers/kolab/tasklist_kolab_driver.php
+++ b/plugins/tasklist/drivers/kolab/tasklist_kolab_driver.php
@@ -1,1033 +1,1034 @@
 <?php
 
 /**
  * Kolab Groupware driver for the Tasklist plugin
  *
  * @version @package_version@
  * @author Thomas Bruederli <bruederli@kolabsys.com>
  *
  * Copyright (C) 2012, Kolab Systems AG <contact@kolabsys.com>
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU Affero General Public License as
  * published by the Free Software Foundation, either version 3 of the
  * License, or (at your option) any later version.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  * GNU Affero General Public License for more details.
  *
  * You should have received a copy of the GNU Affero General Public License
  * along with this program. If not, see <http://www.gnu.org/licenses/>.
  */
 
 class tasklist_kolab_driver extends tasklist_driver
 {
     // features supported by the backend
     public $alarms = false;
     public $attachments = true;
     public $undelete = false; // task undelete action
     public $alarm_types = array('DISPLAY','AUDIO');
 
     private $rc;
     private $plugin;
     private $lists;
     private $folders = array();
     private $tasks = array();
 
 
     /**
      * Default constructor
      */
     public function __construct($plugin)
     {
         $this->rc = $plugin->rc;
         $this->plugin = $plugin;
 
         $this->_read_lists();
 
         if (kolab_storage::$version == '2.0') {
             $this->alarm_absolute = false;
         }
 
         $this->plugin->register_action('folder-acl', array($this, 'folder_acl'));
     }
 
     /**
      * Read available calendars for the current user and store them internally
      */
     private function _read_lists($force = false)
     {
         // already read sources
         if (isset($this->lists) && !$force)
             return $this->lists;
 
         // get all folders that have type "task"
         $folders = kolab_storage::sort_folders(kolab_storage::get_folders('task'));
         $this->lists = $this->folders = array();
 
         // find default folder
         $default_index = 0;
         foreach ($folders as $i => $folder) {
             if ($folder->default)
                 $default_index = $i;
         }
 
         // put default folder (aka INBOX) on top of the list
         if ($default_index > 0) {
             $default_folder = $folders[$default_index];
             unset($folders[$default_index]);
             array_unshift($folders, $default_folder);
         }
 
         $delim = $this->rc->get_storage()->get_hierarchy_delimiter();
         $prefs = $this->rc->config->get('kolab_tasklists', array());
         $listnames = array();
 
         // include virtual folders for a full folder tree
         if (!$this->rc->output->ajax_call && in_array($this->rc->action, array('index','')))
             $folders = kolab_storage::folder_hierarchy($folders);
 
         foreach ($folders as $folder) {
             $utf7name = $folder->name;
 
             $path_imap = explode($delim, $utf7name);
             $editname = rcube_charset::convert(array_pop($path_imap), 'UTF7-IMAP');  // pop off raw name part
             $path_imap = join($delim, $path_imap);
 
             $fullname = $folder->get_name();
             $listname = kolab_storage::folder_displayname($fullname, $listnames);
 
             // special handling for virtual folders
             if ($folder->virtual) {
                 $list_id = kolab_storage::folder_id($utf7name);
                 $this->lists[$list_id] = array(
                     'id' => $list_id,
                     'name' => $fullname,
                     'listname' => $listname,
                     'virtual' => true,
                     'editable' => false,
                 );
                 continue;
             }
 
             if ($folder->get_namespace() == 'personal') {
                 $norename = false;
                 $readonly = false;
                 $alarms = true;
             }
             else {
                 $alarms = false;
                 $readonly = true;
                 if (($rights = $folder->get_myrights()) && !PEAR::isError($rights)) {
                     if (strpos($rights, 'i') !== false)
                       $readonly = false;
                 }
                 $info = $folder->get_folder_info();
                 $norename = $readonly || $info['norename'] || $info['protected'];
             }
 
             $list_id = kolab_storage::folder_id($utf7name);
             $tasklist = array(
                 'id' => $list_id,
                 'name' => $fullname,
                 'listname' => $listname,
                 'editname' => $editname,
                 'color' => $folder->get_color('0000CC'),
                 'showalarms' => isset($prefs[$list_id]['showalarms']) ? $prefs[$list_id]['showalarms'] : $alarms,
                 'editable' => !$readionly,
                 'norename' => $norename,
                 'active' => $folder->is_active(),
                 'parentfolder' => $path_imap,
                 'default' => $folder->default,
                 'children' => true,  // TODO: determine if that folder indeed has child folders
                 'class_name' => trim($folder->get_namespace() . ($folder->default ? ' default' : '')),
             );
             $this->lists[$tasklist['id']] = $tasklist;
             $this->folders[$tasklist['id']] = $folder;
             $this->folders[$folder->name] = $folder;
         }
     }
 
     /**
      * Get a list of available task lists from this source
      */
     public function get_lists()
     {
         // attempt to create a default list for this user
         if (empty($this->lists)) {
             if ($this->create_list(array('name' => 'Tasks', 'color' => '0000CC', 'default' => true)))
                 $this->_read_lists(true);
         }
 
         return $this->lists;
     }
 
     /**
      * Create a new list assigned to the current user
      *
      * @param array Hash array with list properties
      *        name: List name
      *       color: The color of the list
      *  showalarms: True if alarms are enabled
      * @return mixed ID of the new list on success, False on error
      */
     public function create_list(&$prop)
     {
         $prop['type'] = 'task' . ($prop['default'] ? '.default' : '');
         $prop['active'] = true; // activate folder by default
         $prop['subscribed'] = true;
         $folder = kolab_storage::folder_update($prop);
 
         if ($folder === false) {
             $this->last_error = kolab_storage::$last_error;
             return false;
         }
 
         // create ID
         $id = kolab_storage::folder_id($folder);
 
         $prefs['kolab_tasklists'] = $this->rc->config->get('kolab_tasklists', array());
 
         if (isset($prop['showalarms']))
             $prefs['kolab_tasklists'][$id]['showalarms'] = $prop['showalarms'] ? true : false;
 
         if ($prefs['kolab_tasklists'][$id])
             $this->rc->user->save_prefs($prefs);
 
         // force page reload to properly render folder hierarchy
         if (!empty($prop['parent']))
             $prop['_reload'] = true;
 
         return $id;
     }
 
     /**
      * Update properties of an existing tasklist
      *
      * @param array Hash array with list properties
      *          id: List Identifier
      *        name: List name
      *       color: The color of the list
      *  showalarms: True if alarms are enabled (if supported)
      * @return boolean True on success, Fales on failure
      */
     public function edit_list(&$prop)
     {
         if ($prop['id'] && ($folder = $this->folders[$prop['id']])) {
             $prop['oldname'] = $folder->name;
             $prop['type'] = 'task';
             $newfolder = kolab_storage::folder_update($prop);
 
             if ($newfolder === false) {
                 $this->last_error = kolab_storage::$last_error;
                 return false;
             }
 
             // create ID
             $id = kolab_storage::folder_id($newfolder);
 
             // fallback to local prefs
             $prefs['kolab_tasklists'] = $this->rc->config->get('kolab_tasklists', array());
             unset($prefs['kolab_tasklists'][$prop['id']]);
 
             if (isset($prop['showalarms']))
                 $prefs['kolab_tasklists'][$id]['showalarms'] = $prop['showalarms'] ? true : false;
 
             if ($prefs['kolab_tasklists'][$id])
                 $this->rc->user->save_prefs($prefs);
 
             // force page reload if folder name/hierarchy changed
             if ($newfolder != $prop['oldname'])
                 $prop['_reload'] = true;
 
             return $id;
         }
 
         return false;
     }
 
     /**
      * Set active/subscribed state of a list
      *
      * @param array Hash array with list properties
      *          id: List Identifier
      *      active: True if list is active, false if not
      * @return boolean True on success, Fales on failure
      */
     public function subscribe_list($prop)
     {
         if ($prop['id'] && ($folder = $this->folders[$prop['id']])) {
             return $folder->activate($prop['active']);
         }
         return false;
     }
 
     /**
      * Delete the given list with all its contents
      *
      * @param array Hash array with list properties
      *      id: list Identifier
      * @return boolean True on success, Fales on failure
      */
     public function remove_list($prop)
     {
         if ($prop['id'] && ($folder = $this->folders[$prop['id']])) {
           if (kolab_storage::folder_delete($folder->name))
               return true;
           else
               $this->last_error = kolab_storage::$last_error;
         }
 
         return false;
     }
 
     /**
      * Get number of tasks matching the given filter
      *
      * @param array List of lists to count tasks of
      * @return array Hash array with counts grouped by status (all|flagged|completed|today|tomorrow|nodate)
      */
     public function count_tasks($lists = null)
     {
         if (empty($lists))
             $lists = array_keys($this->lists);
         else if (is_string($lists))
             $lists = explode(',', $lists);
 
         $today_date = new DateTime('now', $this->plugin->timezone);
         $today = $today_date->format('Y-m-d');
         $tomorrow_date = new DateTime('now + 1 day', $this->plugin->timezone);
         $tomorrow = $tomorrow_date->format('Y-m-d');
 
         $counts = array('all' => 0, 'flagged' => 0, 'today' => 0, 'tomorrow' => 0, 'overdue' => 0, 'nodate' => 0);
         foreach ($lists as $list_id) {
             $folder = $this->folders[$list_id];
             foreach ($folder->select(array(array('tags','!~','x-complete'))) as $record) {
                 $rec = $this->_to_rcube_task($record);
 
-                if ($rec['complete'] >= 1.0)  // don't count complete tasks
+                if ($this->is_complete($rec))  // don't count complete tasks
                     continue;
 
                 $counts['all']++;
                 if ($rec['flagged'])
                     $counts['flagged']++;
                 if (empty($rec['date']))
                     $counts['nodate']++;
                 else if ($rec['date'] == $today)
                     $counts['today']++;
                 else if ($rec['date'] == $tomorrow)
                     $counts['tomorrow']++;
                 else if ($rec['date'] < $today)
                     $counts['overdue']++;
             }
         }
 
         return $counts;
     }
 
     /**
      * Get all taks records matching the given filter
      *
      * @param array Hash array with filter criterias:
      *  - mask:  Bitmask representing the filter selection (check against tasklist::FILTER_MASK_* constants)
      *  - from:  Date range start as string (Y-m-d)
      *  - to:    Date range end as string (Y-m-d)
      *  - search: Search query string
      * @param array List of lists to get tasks from
      * @return array List of tasks records matchin the criteria
      */
     public function list_tasks($filter, $lists = null)
     {
         if (empty($lists))
             $lists = array_keys($this->lists);
         else if (is_string($lists))
             $lists = explode(',', $lists);
 
         $results = array();
 
         // query Kolab storage
         $query = array();
         if ($filter['mask'] & tasklist::FILTER_MASK_COMPLETE)
             $query[] = array('tags','~','x-complete');
         else if (empty($filter['since']))
             $query[] = array('tags','!~','x-complete');
 
         // full text search (only works with cache enabled)
         if ($filter['search']) {
             $search = mb_strtolower($filter['search']);
             foreach (rcube_utils::normalize_string($search, true) as $word) {
                 $query[] = array('words', '~', $word);
             }
         }
 
         if ($filter['since']) {
             $query[] = array('changed', '>=', $filter['since']);
         }
 
         foreach ($lists as $list_id) {
             $folder = $this->folders[$list_id];
             foreach ($folder->select($query) as $record) {
                 $task = $this->_to_rcube_task($record);
                 $task['list'] = $list_id;
 
                 // TODO: post-filter tasks returned from storage
 
                 $results[] = $task;
             }
         }
 
         return $results;
     }
 
     /**
      * Return data of a specific task
      *
      * @param mixed  Hash array with task properties or task UID
      * @return array Hash array with task properties or false if not found
      */
     public function get_task($prop)
     {
         $id = is_array($prop) ? ($prop['uid'] ?: $prop['id']) : $prop;
         $list_id = is_array($prop) ? $prop['list'] : null;
         $folders = $list_id ? array($list_id => $this->folders[$list_id]) : $this->folders;
 
         // find task in the available folders
         foreach ($folders as $list_id => $folder) {
             if (is_numeric($list_id))
                 continue;
             if (!$this->tasks[$id] && ($object = $folder->get_object($id))) {
                 $this->tasks[$id] = $this->_to_rcube_task($object);
                 $this->tasks[$id]['list'] = $list_id;
                 break;
             }
         }
 
         return $this->tasks[$id];
     }
 
     /**
      * Get all decendents of the given task record
      *
      * @param mixed  Hash array with task properties or task UID
      * @param boolean True if all childrens children should be fetched
      * @return array List of all child task IDs
      */
     public function get_childs($prop, $recursive = false)
     {
         if (is_string($prop)) {
             $task = $this->get_task($prop);
             $prop = array('id' => $task['id'], 'list' => $task['list']);
         }
 
         $childs = array();
         $list_id = $prop['list'];
         $task_ids = array($prop['id']);
         $folder = $this->folders[$list_id];
 
         // query for childs (recursively)
         while ($folder && !empty($task_ids)) {
             $query_ids = array();
             foreach ($task_ids as $task_id) {
                 $query = array(array('tags','=','x-parent:' . $task_id));
                 foreach ($folder->select($query) as $record) {
                     // don't rely on kolab_storage_folder filtering
                     if ($record['parent_id'] == $task_id) {
                         $childs[] = $record['uid'];
                         $query_ids[] = $record['uid'];
                     }
                 }
             }
 
             if (!$recursive)
                 break;
 
             $task_ids = $query_ids;
         }
 
         return $childs;
     }
 
     /**
      * Get a list of pending alarms to be displayed to the user
      *
      * @param  integer Current time (unix timestamp)
      * @param  mixed   List of list IDs to show alarms for (either as array or comma-separated string)
      * @return array   A list of alarms, each encoded as hash array with task properties
      * @see tasklist_driver::pending_alarms()
      */
     public function pending_alarms($time, $lists = null)
     {
         $interval = 300;
         $time -= $time % 60;
 
         $slot = $time;
         $slot -= $slot % $interval;
 
         $last = $time - max(60, $this->rc->config->get('refresh_interval', 0));
         $last -= $last % $interval;
 
         // only check for alerts once in 5 minutes
         if ($last == $slot)
             return array();
 
         if ($lists && is_string($lists))
             $lists = explode(',', $lists);
 
         $time = $slot + $interval;
 
         $candidates = array();
         $query = array(array('tags', '=', 'x-has-alarms'), array('tags', '!=', 'x-complete'));
         foreach ($this->lists as $lid => $list) {
             // skip lists with alarms disabled
             if (!$list['showalarms'] || ($lists && !in_array($lid, $lists)))
                 continue;
 
             $folder = $this->folders[$lid];
             foreach ($folder->select($query) as $record) {
                 if (!($record['valarms'] || $record['alarms']) || $record['status'] == 'COMPLETED' || $record['complete'] == 100)  // don't trust query :-)
                     continue;
 
                 $task = $this->_to_rcube_task($record);
 
                 // add to list if alarm is set
                 $alarm = libcalendaring::get_next_alarm($task, 'task');
                 if ($alarm && $alarm['time'] && $alarm['time'] <= $time && in_array($alarm['action'], $this->alarm_types)) {
                     $id = $alarm['id'];  // use alarm-id as primary identifier
                     $candidates[$id] = array(
                         'id'       => $id,
                         'title'    => $task['title'],
                         'date'     => $task['date'],
                         'time'     => $task['time'],
                         'notifyat' => $alarm['time'],
                         'action'   => $alarm['action'],
                     );
                 }
             }
         }
 
         // get alarm information stored in local database
         if (!empty($candidates)) {
             $alarm_ids = array_map(array($this->rc->db, 'quote'), array_keys($candidates));
             $result = $this->rc->db->query(sprintf(
                 "SELECT * FROM kolab_alarms
                  WHERE alarm_id IN (%s) AND user_id=?",
                  join(',', $alarm_ids),
                  $this->rc->db->now()
                 ),
                 $this->rc->user->ID
             );
 
             while ($result && ($rec = $this->rc->db->fetch_assoc($result))) {
                 $dbdata[$rec['alarm_id']] = $rec;
             }
         }
 
         $alarms = array();
         foreach ($candidates as $id => $task) {
           // skip dismissed
           if ($dbdata[$id]['dismissed'])
               continue;
 
           // snooze function may have shifted alarm time
           $notifyat = $dbdata[$id]['notifyat'] ? strtotime($dbdata[$id]['notifyat']) : $task['notifyat'];
           if ($notifyat <= $time)
               $alarms[] = $task;
         }
 
         return $alarms;
     }
 
     /**
      * (User) feedback after showing an alarm notification
      * This should mark the alarm as 'shown' or snooze it for the given amount of time
      *
      * @param  string  Task identifier
      * @param  integer Suspend the alarm for this number of seconds
      */
     public function dismiss_alarm($id, $snooze = 0)
     {
         // delete old alarm entry
         $this->rc->db->query(
             "DELETE FROM kolab_alarms
              WHERE alarm_id=? AND user_id=?",
             $id,
             $this->rc->user->ID
         );
 
         // set new notifyat time or unset if not snoozed
         $notifyat = $snooze > 0 ? date('Y-m-d H:i:s', time() + $snooze) : null;
 
         $query = $this->rc->db->query(
             "INSERT INTO kolab_alarms
              (alarm_id, user_id, dismissed, notifyat)
              VALUES(?, ?, ?, ?)",
             $id,
             $this->rc->user->ID,
             $snooze > 0 ? 0 : 1,
             $notifyat
         );
 
         return $this->rc->db->affected_rows($query);
     }
 
     /**
      * Remove alarm dismissal or snooze state
      *
      * @param  string  Task identifier
      */
     public function clear_alarms($id)
     {
         // delete alarm entry
         $this->rc->db->query(
             "DELETE FROM kolab_alarms
              WHERE alarm_id=? AND user_id=?",
             $id,
             $this->rc->user->ID
         );
 
         return true;
     }
 
     /**
      * Convert from Kolab_Format to internal representation
      */
     private function _to_rcube_task($record)
     {
         $task = array(
             'id' => $record['uid'],
             'uid' => $record['uid'],
             'title' => $record['title'],
 #            'location' => $record['location'],
             'description' => $record['description'],
             'tags' => array_filter((array)$record['categories']),
             'flagged' => $record['priority'] == 1,
-            'complete' => $record['status'] == 'COMPLETED' ? 1 : floatval($record['complete'] / 100),
+            'complete' => floatval($record['complete'] / 100),
+            'status' => $record['status'],
             'parent_id' => $record['parent_id'],
             'recurrence' => $record['recurrence'],
         );
 
         // convert from DateTime to internal date format
         if (is_a($record['due'], 'DateTime')) {
             $due = $this->plugin->lib->adjust_timezone($record['due']);
             $task['date'] = $due->format('Y-m-d');
             if (!$record['due']->_dateonly)
                 $task['time'] = $due->format('H:i');
         }
         // convert from DateTime to internal date format
         if (is_a($record['start'], 'DateTime')) {
             $start = $this->plugin->lib->adjust_timezone($record['start']);
             $task['startdate'] = $start->format('Y-m-d');
             if (!$record['start']->_dateonly)
                 $task['starttime'] = $start->format('H:i');
         }
         if (is_a($record['dtstamp'], 'DateTime')) {
             $task['changed'] = $record['dtstamp'];
         }
 
         if ($record['valarms']) {
             $task['valarms'] = $record['valarms'];
         }
         else if ($record['alarms']) {
             $task['alarms'] = $record['alarms'];
         }
 
         if (!empty($record['_attachments'])) {
             foreach ($record['_attachments'] as $key => $attachment) {
                 if ($attachment !== false) {
                     if (!$attachment['name'])
                         $attachment['name'] = $key;
                     $attachments[] = $attachment;
                 }
             }
 
             $task['attachments'] = $attachments;
         }
 
         return $task;
     }
 
     /**
     * Convert the given task record into a data structure that can be passed to kolab_storage backend for saving
     * (opposite of self::_to_rcube_event())
      */
     private function _from_rcube_task($task, $old = array())
     {
         $object = $task;
         $object['categories'] = (array)$task['tags'];
 
         if (!empty($task['date'])) {
             $object['due'] = new DateTime($task['date'].' '.$task['time'], $this->plugin->timezone);
             if (empty($task['time']))
                 $object['due']->_dateonly = true;
             unset($object['date']);
         }
 
         if (!empty($task['startdate'])) {
             $object['start'] = new DateTime($task['startdate'].' '.$task['starttime'], $this->plugin->timezone);
             if (empty($task['starttime']))
                 $object['start']->_dateonly = true;
             unset($object['startdate']);
         }
 
         $object['complete'] = $task['complete'] * 100;
-        if ($task['complete'] == 1.0)
+        if ($task['complete'] == 1.0 && empty($task['complete']))
             $object['status'] = 'COMPLETED';
 
         if ($task['flagged'])
             $object['priority'] = 1;
         else
             $object['priority'] = $old['priority'] > 1 ? $old['priority'] : 0;
 
         // copy meta data (starting with _) from old object
         foreach ((array)$old as $key => $val) {
             if (!isset($object[$key]) && $key[0] == '_')
                 $object[$key] = $val;
         }
 
         // copy recurrence rules if the client didn't submit it (#2713)
         if (!array_key_exists('recurrence', $object) && $old['recurrence']) {
             $object['recurrence'] = $old['recurrence'];
         }
 
         // delete existing attachment(s)
         if (!empty($task['deleted_attachments'])) {
             foreach ($task['deleted_attachments'] as $attachment) {
                 if (is_array($object['_attachments'])) {
                     foreach ($object['_attachments'] as $idx => $att) {
                         if ($att['id'] == $attachment)
                             $object['_attachments'][$idx] = false;
                     }
                 }
             }
             unset($task['deleted_attachments']);
         }
 
         // in kolab_storage attachments are indexed by content-id
         if (is_array($task['attachments'])) {
             foreach ($task['attachments'] as $idx => $attachment) {
                 $key = null;
                 // Roundcube ID has nothing to do with the storage ID, remove it
                 if ($attachment['content']) {
                     unset($attachment['id']);
                 }
                 else {
                     foreach ((array)$old['_attachments'] as $cid => $oldatt) {
                         if ($oldatt && $attachment['id'] == $oldatt['id'])
                             $key = $cid;
                     }
                 }
 
                 // replace existing entry
                 if ($key) {
                     $object['_attachments'][$key] = $attachment;
                 }
                 // append as new attachment
                 else {
                     $object['_attachments'][] = $attachment;
                 }
             }
 
             unset($object['attachments']);
         }
 
         unset($object['tempid'], $object['raw'], $object['list'], $object['flagged'], $object['tags']);
         return $object;
     }
 
     /**
      * Add a single task to the database
      *
      * @param array Hash array with task properties (see header of tasklist_driver.php)
      * @return mixed New task ID on success, False on error
      */
     public function create_task($task)
     {
         return $this->edit_task($task);
     }
 
     /**
      * Update an task entry with the given data
      *
      * @param array Hash array with task properties (see header of tasklist_driver.php)
      * @return boolean True on success, False on error
      */
     public function edit_task($task)
     {
         $list_id = $task['list'];
         if (!$list_id || !($folder = $this->folders[$list_id]))
             return false;
 
         // moved from another folder
         if ($task['_fromlist'] && ($fromfolder = $this->folders[$task['_fromlist']])) {
             if (!$fromfolder->move($task['id'], $folder->name))
                 return false;
 
             unset($task['_fromlist']);
         }
 
         // load previous version of this task to merge
         if ($task['id']) {
             $old = $folder->get_object($task['id']);
             if (!$old || PEAR::isError($old))
                 return false;
 
             // merge existing properties if the update isn't complete
             if (!isset($task['title']) || !isset($task['complete']))
                 $task += $this->_to_rcube_task($old);
         }
 
         // generate new task object from RC input
         $object = $this->_from_rcube_task($task, $old);
         $saved = $folder->save($object, 'task', $task['id']);
 
         if (!$saved) {
             raise_error(array(
                 'code' => 600, 'type' => 'php',
                 'file' => __FILE__, 'line' => __LINE__,
                 'message' => "Error saving task object to Kolab server"),
                 true, false);
             $saved = false;
         }
         else {
             $task = $this->_to_rcube_task($object);
             $task['list'] = $list_id;
             $this->tasks[$task['id']] = $task;
         }
 
         return $saved;
     }
 
     /**
      * Move a single task to another list
      *
      * @param array   Hash array with task properties:
      * @return boolean True on success, False on error
      * @see tasklist_driver::move_task()
      */
     public function move_task($task)
     {
         $list_id = $task['list'];
         if (!$list_id || !($folder = $this->folders[$list_id]))
             return false;
 
         // execute move command
         if ($task['_fromlist'] && ($fromfolder = $this->folders[$task['_fromlist']])) {
             return $fromfolder->move($task['id'], $folder->name);
         }
 
         return false;
     }
 
     /**
      * Remove a single task from the database
      *
      * @param array   Hash array with task properties:
      *      id: Task identifier
      * @param boolean Remove record irreversible (mark as deleted otherwise, if supported by the backend)
      * @return boolean True on success, False on error
      */
     public function delete_task($task, $force = true)
     {
         $list_id = $task['list'];
         if (!$list_id || !($folder = $this->folders[$list_id]))
             return false;
 
         return $folder->delete($task['id']);
     }
 
     /**
      * Restores a single deleted task (if supported)
      *
      * @param array Hash array with task properties:
      *      id: Task identifier
      * @return boolean True on success, False on error
      */
     public function undelete_task($prop)
     {
         // TODO: implement this
         return false;
     }
 
 
     /**
      * Get attachment properties
      *
      * @param string $id    Attachment identifier
      * @param array  $task  Hash array with event properties:
      *         id: Task identifier
      *       list: List identifier
      *
      * @return array Hash array with attachment properties:
      *         id: Attachment identifier
      *       name: Attachment name
      *   mimetype: MIME content type of the attachment
      *       size: Attachment size
      */
     public function get_attachment($id, $task)
     {
         $task['uid'] = $task['id'];
         $task = $this->get_task($task);
 
         if ($task && !empty($task['attachments'])) {
             foreach ($task['attachments'] as $att) {
                 if ($att['id'] == $id)
                     return $att;
             }
         }
 
         return null;
     }
 
     /**
      * Get attachment body
      *
      * @param string $id    Attachment identifier
      * @param array  $task  Hash array with event properties:
      *         id: Task identifier
      *       list: List identifier
      *
      * @return string Attachment body
      */
     public function get_attachment_body($id, $task)
     {
         if ($storage = $this->folders[$task['list']]) {
             return $storage->get_attachment($task['id'], $id);
         }
 
         return false;
     }
 
     /**
      * 
      */
     public function tasklist_edit_form($action, $list, $fieldprop)
     {
         if ($list['id'] && ($list = $this->lists[$list['id']])) {
             $folder_name = $this->folders[$list['id']]->name; // UTF7
         }
         else {
             $folder_name = '';
         }
 
         $storage = $this->rc->get_storage();
         $delim   = $storage->get_hierarchy_delimiter();
         $form    = array();
 
         if (strlen($folder_name)) {
             $path_imap = explode($delim, $folder_name);
             array_pop($path_imap);  // pop off name part
             $path_imap = implode($path_imap, $delim);
 
             $options = $storage->folder_info($folder_name);
         }
         else {
             $path_imap = '';
         }
 
         $hidden_fields[] = array('name' => 'oldname', 'value' => $folder_name);
 
         // folder name (default field)
         $input_name = new html_inputfield(array('name' => 'name', 'id' => 'taskedit-tasklistame', 'size' => 20));
         $fieldprop['name']['value'] = $input_name->show($list['editname'], array('disabled' => ($options['norename'] || $options['protected'])));
 
         // prevent user from moving folder
         if (!empty($options) && ($options['norename'] || $options['protected'])) {
             $hidden_fields[] = array('name' => 'parent', 'value' => $path_imap);
         }
         else {
             $select = kolab_storage::folder_selector('task', array('name' => 'parent', 'id' => 'taskedit-parentfolder'), $folder_name);
             $fieldprop['parent'] = array(
                 'id'    => 'taskedit-parentfolder',
                 'label' => $this->plugin->gettext('parentfolder'),
                 'value' => $select->show($path_imap),
             );
         }
 
         // General tab
         $form['properties'] = array(
             'name' => $this->rc->gettext('properties'),
             'fields' => array(),
         );
 
         foreach (array('name','parent','showalarms') as $f) {
             $form['properties']['fields'][$f] = $fieldprop[$f];
         }
 
         // add folder ACL tab
         if ($action != 'form-new') {
             $form['sharing'] = array(
                 'name'    => Q($this->plugin->gettext('tabsharing')),
                 'content' => html::tag('iframe', array(
                     'src' => $this->rc->url(array('_action' => 'folder-acl', '_folder' => $folder_name, 'framed' => 1)),
                     'width' => '100%',
                     'height' => 280,
                     'border' => 0,
                     'style' => 'border:0'),
                 '')
             );
         }
 
         $form_html = '';
         if (is_array($hidden_fields)) {
             foreach ($hidden_fields as $field) {
                 $hiddenfield = new html_hiddenfield($field);
                 $form_html .= $hiddenfield->show() . "\n";
             }
         }
 
         // create form output
         foreach ($form as $tab) {
             if (is_array($tab['fields']) && empty($tab['content'])) {
                 $table = new html_table(array('cols' => 2));
                 foreach ($tab['fields'] as $col => $colprop) {
                     $colprop['id'] = '_'.$col;
                     $label = !empty($colprop['label']) ? $colprop['label'] : $this->plugin->gettext($col);
 
                     $table->add('title', html::label($colprop['id'], Q($label)));
                     $table->add(null, $colprop['value']);
                 }
                 $content = $table->show();
             }
             else {
                 $content = $tab['content'];
             }
 
             if (!empty($content)) {
                 $form_html .= html::tag('fieldset', null, html::tag('legend', null, Q($tab['name'])) . $content) . "\n";
             }
         }
 
         return $form_html;
     }
 
     /**
      * Handler to render ACL form for a notes folder
      */
     public function folder_acl()
     {
         $this->plugin->require_plugin('acl');
         $this->rc->output->add_handler('folderacl', array($this, 'folder_acl_form'));
         $this->rc->output->send('tasklist.kolabacl');
     }
 
     /**
      * Handler for ACL form template object
      */
     public function folder_acl_form()
     {
         $folder = rcube_utils::get_input_value('_folder', RCUBE_INPUT_GPC);
 
         if (strlen($folder)) {
             $storage = $this->rc->get_storage();
             $options = $storage->folder_info($folder);
 
             // get sharing UI from acl plugin
             $acl = $this->rc->plugins->exec_hook('folder_form',
                 array('form' => array(), 'options' => $options, 'name' => $folder));
         }
 
         return $acl['form']['sharing']['content'] ?: html::div('hint', $this->plugin->gettext('aclnorights'));
     }
 }
diff --git a/plugins/tasklist/drivers/tasklist_driver.php b/plugins/tasklist/drivers/tasklist_driver.php
index 6c31fa7a..76480f55 100644
--- a/plugins/tasklist/drivers/tasklist_driver.php
+++ b/plugins/tasklist/drivers/tasklist_driver.php
@@ -1,315 +1,326 @@
 <?php
 
 /**
  * Driver interface for the Tasklist plugin
  *
  * @version @package_version@
  * @author Thomas Bruederli <bruederli@kolabsys.com>
  *
  * Copyright (C) 2012, Kolab Systems AG <contact@kolabsys.com>
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU Affero General Public License as
  * published by the Free Software Foundation, either version 3 of the
  * License, or (at your option) any later version.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  * GNU Affero General Public License for more details.
  *
  * You should have received a copy of the GNU Affero General Public License
  * along with this program. If not, see <http://www.gnu.org/licenses/>.
  */
 
  /**
   * Struct of an internal task object how it is passed from/to the driver classes:
   *
   *  $task = array(
   *            'id' => 'Task ID used for editing',  // must be unique for the current user
   *     'parent_id' => 'ID of parent task',  // null if top-level task
   *           'uid' => 'Unique identifier of this task',
   *          'list' => 'Task list identifier to add the task to or where the task is stored',
   *       'changed' => <DateTime>,  // Last modification date/time of the record
   *         'title' => 'Event title/summary',
   *   'description' => 'Event description',
   *          'tags' => array(),      // List of tags for this task
   *          'date' => 'Due date',   // as string of format YYYY-MM-DD or null if no date is set
   *          'time' => 'Due time',   // as string of format hh::ii or null if no due time is set
   *     'startdate' => 'Start date'  // Delay start of the task until that date
   *     'starttime' => 'Start time'  // ...and time
   *    'categories' => 'Task category',
   *       'flagged' => 'Boolean value whether this record is flagged',
   *      'complete' => 'Float value representing the completeness state (range 0..1)',
-  *   'sensitivity' => 0|1|2,   // Event sensitivity (0=public, 1=private, 2=confidential)
+  *      'status'   => 'Task status string according to (NEEDS-ACTION, IN-PROCESS, COMPLETED, CANCELLED) RFC 2445',
   *       'valarms' => array(           // List of reminders (new format), each represented as a hash array:
   *                array(
   *                   'trigger' => '-PT90M',     // ISO 8601 period string prefixed with '+' or '-', or DateTime object
   *                    'action' => 'DISPLAY|EMAIL|AUDIO',
   *                  'duration' => 'PT15M',      // ISO 8601 period string
   *                    'repeat' => 0,            // number of repetitions
   *               'description' => '',           // text to display for DISPLAY actions
   *                   'summary' => '',           // message text for EMAIL actions
   *                 'attendees' => array(),      // list of email addresses to receive alarm messages
   *                ),
   *    ),
   *    'recurrence' => array(   // Recurrence definition according to iCalendar (RFC 2445) specification as list of key-value pairs
   *              'FREQ' => 'DAILY|WEEKLY|MONTHLY|YEARLY',
   *          'INTERVAL' => 1...n,
   *             'UNTIL' => DateTime,
   *             'COUNT' => 1..n,     // number of times
   *             'RDATE' => array(),  // complete list of DateTime objects denoting individual repeat dates
   *     ),
   *     '_fromlist' => 'List identifier where the task was stored before',
   *  );
   */
 
 /**
  * Driver interface for the Tasklist plugin
  */
 abstract class tasklist_driver
 {
     // features supported by the backend
     public $alarms = false;
     public $attachments = false;
     public $undelete = false; // task undelete action
     public $sortable = false;
     public $alarm_types = array('DISPLAY');
     public $alarm_absolute = true;
     public $last_error;
 
     /**
      * Get a list of available task lists from this source
      */
     abstract function get_lists();
 
     /**
      * Create a new list assigned to the current user
      *
      * @param array Hash array with list properties
      *        name: List name
      *       color: The color of the list
      *  showalarms: True if alarms are enabled
      * @return mixed ID of the new list on success, False on error
      */
     abstract function create_list(&$prop);
 
     /**
      * Update properties of an existing tasklist
      *
      * @param array Hash array with list properties
      *          id: List Identifier
      *        name: List name
      *       color: The color of the list
      *  showalarms: True if alarms are enabled (if supported)
      * @return boolean True on success, Fales on failure
      */
     abstract function edit_list(&$prop);
 
     /**
      * Set active/subscribed state of a list
      *
      * @param array Hash array with list properties
      *          id: List Identifier
      *      active: True if list is active, false if not
      * @return boolean True on success, Fales on failure
      */
     abstract function subscribe_list($prop);
 
     /**
      * Delete the given list with all its contents
      *
      * @param array Hash array with list properties
      *      id: list Identifier
      * @return boolean True on success, Fales on failure
      */
     abstract function remove_list($prop);
 
     /**
      * Get number of tasks matching the given filter
      *
      * @param array List of lists to count tasks of
      * @return array Hash array with counts grouped by status (all|flagged|completed|today|tomorrow|nodate)
      */
     abstract function count_tasks($lists = null);
 
     /**
      * Get all taks records matching the given filter
      *
      * @param array Hash array with filter criterias:
      *  - mask:  Bitmask representing the filter selection (check against tasklist::FILTER_MASK_* constants)
      *  - from:  Date range start as string (Y-m-d)
      *  - to:    Date range end as string (Y-m-d)
      *  - search: Search query string
      * @param array List of lists to get tasks from
      * @return array List of tasks records matchin the criteria
      */
     abstract function list_tasks($filter, $lists = null);
 
     /**
      * Get a list of pending alarms to be displayed to the user
      *
      * @param  integer Current time (unix timestamp)
      * @param  mixed   List of list IDs to show alarms for (either as array or comma-separated string)
      * @return array   A list of alarms, each encoded as hash array with task properties
      *         id: Task identifier
      *        uid: Unique identifier of this task
      *       date: Task due date
      *       time: Task due time
      *      title: Task title/summary
      */
     abstract function pending_alarms($time, $lists = null);
 
     /**
      * (User) feedback after showing an alarm notification
      * This should mark the alarm as 'shown' or snooze it for the given amount of time
      *
      * @param  string  Task identifier
      * @param  integer Suspend the alarm for this number of seconds
      */
     abstract function dismiss_alarm($id, $snooze = 0);
 
     /**
      * Remove alarm dismissal or snooze state
      *
      * @param  string  Task identifier
      */
     abstract public function clear_alarms($id);
 
     /**
      * Return data of a specific task
      *
      * @param mixed  Hash array with task properties or task UID
      * @return array Hash array with task properties or false if not found
      */
     abstract public function get_task($prop);
 
     /**
      * Get decendents of the given task record
      *
      * @param mixed  Hash array with task properties or task UID
      * @param boolean True if all childrens children should be fetched
      * @return array List of all child task IDs
      */
     abstract public function get_childs($prop, $recursive = false);
 
     /**
      * Add a single task to the database
      *
      * @param array Hash array with task properties (see header of this file)
      * @return mixed New event ID on success, False on error
      */
     abstract function create_task($prop);
 
     /**
      * Update an task entry with the given data
      *
      * @param array Hash array with task properties (see header of this file)
      * @return boolean True on success, False on error
      */
     abstract function edit_task($prop);
 
     /**
      * Move a single task to another list
      *
      * @param array   Hash array with task properties:
      *      id: Task identifier
      *      list: New list identifier to move to
      *      _fromlist: Previous list identifier
      * @return boolean True on success, False on error
      */
     abstract function move_task($prop);
 
     /**
      * Remove a single task from the database
      *
      * @param array   Hash array with task properties:
      *      id: Task identifier
      * @param boolean Remove record irreversible (mark as deleted otherwise, if supported by the backend)
      * @return boolean True on success, False on error
      */
     abstract function delete_task($prop, $force = true);
 
     /**
      * Restores a single deleted task (if supported)
      *
      * @param array Hash array with task properties:
      *      id: Task identifier
      * @return boolean True on success, False on error
      */
     public function undelete_task($prop)
     {
         return false;
     }
 
     /**
      * Get attachment properties
      *
      * @param string $id    Attachment identifier
      * @param array  $task  Hash array with event properties:
      *         id: Task identifier
      *       list: List identifier
      *
      * @return array Hash array with attachment properties:
      *         id: Attachment identifier
      *       name: Attachment name
      *   mimetype: MIME content type of the attachment
      *       size: Attachment size
      */
     public function get_attachment($id, $task) { }
 
     /**
      * Get attachment body
      *
      * @param string $id    Attachment identifier
      * @param array  $task  Hash array with event properties:
      *         id: Task identifier
      *       list: List identifier
      *
      * @return string Attachment body
      */
     public function get_attachment_body($id, $task) { }
 
+    /**
+     * Helper method to determine whether the given task is considered "complete"
+     *
+     * @param array  $task  Hash array with event properties:
+     * @return boolean True if complete, False otherwiese
+     */
+    public function is_complete($task)
+    {
+        return ($task['complete'] >= 1.0 && empty($task['status'])) || $task['status'] === 'COMPLETED';
+    }
+
     /**
      * List availabale categories
      * The default implementation reads them from config/user prefs
      */
     public function list_categories()
     {
         $rcmail = rcube::get_instance();
         return $rcmail->config->get('tasklist_categories', array());
     }
 
     /**
      * Build the edit/create form for lists.
      * This gives the drivers the opportunity to add more list properties
      *
      * @param string  The action called this form
      * @param array   Tasklist properties
      * @param array   List with form fields to be rendered
      * @return string HTML content of the form
      */
     public function tasklist_edit_form($action, $list, $formfields)
     {
         $html = '';
         foreach ($formfields as $field) {
             $html .= html::div('form-section',
                 html::label($field['id'], $field['label']) .
                 $field['value']);
         }
 
         return $html;
     }
 
     /**
      * Handler for user_delete plugin hook
      *
      * @param array Hash array with hook arguments
      * @return array Return arguments for plugin hooks
      */
     public function user_delete($args)
     {
         // TO BE OVERRIDDEN
         return $args;
     }
 }
diff --git a/plugins/tasklist/localization/en_US.inc b/plugins/tasklist/localization/en_US.inc
index 18456fa6..714e79cd 100644
--- a/plugins/tasklist/localization/en_US.inc
+++ b/plugins/tasklist/localization/en_US.inc
@@ -1,73 +1,78 @@
 <?php
 
 $labels = array();
 $labels['navtitle'] = 'Tasks';
 $labels['lists'] = 'Tasklists';
 $labels['list'] = 'Tasklist';
 $labels['tags'] = 'Tags';
 
 $labels['newtask'] = 'New Task';
 $labels['createnewtask'] = 'Create new Task (e.g. Saturday, Mow the lawn)';
 $labels['createfrommail'] = 'Save as task';
 $labels['mark'] = 'Mark';
 $labels['unmark'] = 'Unmark';
 $labels['edit'] = 'Edit';
 $labels['delete'] = 'Delete';
 $labels['title'] = 'Title';
 $labels['description'] = 'Description';
 $labels['datetime'] = 'Due';
 $labels['start'] = 'Start';
 $labels['alarms'] = 'Reminder';
 $labels['repeat'] = 'Repeat';
+$labels['status'] = 'Status';
+$labels['status-needs-action'] = 'Needs action';
+$labels['status-in-process'] = 'In process';
+$labels['status-completed'] = 'Completed';
+$labels['status-cancelled'] = 'Cancelled';
 
 $labels['all'] = 'All';
 $labels['flagged'] = 'Flagged';
 $labels['complete'] = 'Complete';
 $labels['overdue'] = 'Overdue';
 $labels['today'] = 'Today';
 $labels['tomorrow'] = 'Tomorrow';
 $labels['next7days'] = 'Next 7 days';
 $labels['later'] = 'Later';
 $labels['nodate'] = 'no date';
 $labels['removetag'] = 'Remove';
 
 $labels['taskdetails'] = 'Details';
 $labels['newtask'] = 'New Task';
 $labels['edittask'] = 'Edit Task';
 $labels['save'] = 'Save';
 $labels['cancel'] = 'Cancel';
 $labels['addsubtask'] = 'Add subtask';
 $labels['deletetask'] = 'Delete task';
 $labels['deletethisonly'] = 'Delete this task only';
 $labels['deletewithchilds'] = 'Delete with all subtasks';
 
 $labels['tabsummary'] = 'Summary';
 $labels['tabrecurrence'] = 'Recurrence';
 $labels['tabattachments'] = 'Attachments';
 $labels['tabsharing'] = 'Sharing';
 
 $labels['editlist'] = 'Edit list';
 $labels['createlist'] = 'Add list';
 $labels['listactions'] = 'List options...';
 $labels['listname'] = 'Name';
 $labels['showalarms'] = 'Show reminders';
 $labels['import'] = 'Import';
 $labels['viewoptions'] = 'View options';
 $labels['focusview'] = 'View only this list';
 
 // date words
 $labels['on'] = 'on';
 $labels['at'] = 'at';
 $labels['this'] = 'this';
 $labels['next'] = 'next';
 
 // mesages
 $labels['savingdata'] = 'Saving data...';
 $labels['errorsaving'] = 'Failed to save data.';
 $labels['notasksfound'] = 'No tasks found for the given criteria';
 $labels['invalidstartduedates'] = 'Start date must not be greater than due date.';
 $labels['deletetasktconfirm'] = 'Do you really want to delete this task?';
 $labels['deleteparenttasktconfirm'] = 'Do you really want to delete this task and all its subtasks?';
 $labels['deletelistconfirm'] = 'Do you really want to delete this list with all its tasks?';
 $labels['deletelistconfirmrecursive'] = 'Do you really want to delete this list with all its sub-lists and tasks?';
 $labels['aclnorights'] = 'You do not have administrator rights on this task list.';
diff --git a/plugins/tasklist/skins/larry/templates/mainview.html b/plugins/tasklist/skins/larry/templates/mainview.html
index fe3f88bf..1761683b 100644
--- a/plugins/tasklist/skins/larry/templates/mainview.html
+++ b/plugins/tasklist/skins/larry/templates/mainview.html
@@ -1,179 +1,183 @@
 <roundcube:object name="doctype" value="html5" />
 <html>
 <head>
 <title><roundcube:object name="pagetitle" /></title>
 <roundcube:include file="/includes/links.html" />
 <!--[if lte IE 8]><link rel="stylesheet" type="text/css" href="/this/iehacks.css" /><![endif]-->
 </head>
 <body class="tasklistview noscroll">
 
 <roundcube:include file="/includes/header.html" />
 
 <div id="mainscreen">
 	<div id="sidebar">
 		<div id="taskstoolbar" class="toolbar">
 			<roundcube:button command="newtask" type="link" class="button newtask disabled" classAct="button newtask" classSel="button newtask pressed" label="tasklist.newtask" title="tasklist.newtask" />
 			<roundcube:container name="toolbar" id="taskstoolbar" />
 		</div>
 
 		<div id="tagsbox" class="uibox listbox">
 			<h2 class="boxtitle"><roundcube:label name="tasklist.tags" id="taglist" /></h2>
 			<div class="scroller">
 				<roundcube:object name="plugin.tagslist" id="tagslist" class="tagcloud" />
 			</div>
 		</div>
 
 		<div id="tasklistsbox" class="uibox listbox">
 			<h2 class="boxtitle"><roundcube:label name="tasklist.lists" /></h2>
 			<div class="scroller withfooter">
 			<roundcube:object name="plugin.tasklists" id="tasklists" class="listing" />
 			</div>
 			<div class="boxfooter">
 				<roundcube:button command="list-create" type="link" title="tasklist.createlist" class="listbutton add disabled" classAct="listbutton add" innerClass="inner" content="+" /><roundcube:button name="tasklistoptionslink" id="tasklistoptionsmenulink" type="link" title="tasklist.listactions" class="listbutton groupactions" onclick="UI.show_popup('tasklistoptionsmenu', undefined, { above:true });return false" innerClass="inner" content="&#9881;" />
 			</div>
 		</div>
 	</div>
 	
 	<div id="mainview-right">
 	
 	<div id="quickaddbox">
 		<roundcube:object name="plugin.quickaddform" />
 	</div>
 
 	<div id="quicksearchbar">
 		<roundcube:object name="plugin.searchform" id="quicksearchbox" />
 		<a id="searchmenulink" class="iconbutton searchoptions" > </a>
 		<roundcube:button command="reset-search" id="searchreset" class="iconbutton reset" title="resetsearch" content=" " />
 	</div>
 
 	<div id="tasksview" class="uibox">
 		<div class="boxtitle buttonbar">
 			<ul id="taskselector">
 				<li class="all selected"><a href="#all"><roundcube:label name="tasklist.all" /><span class="count"></span></a></li>
 				<li class="overdue inactive"><a href="#overdue"><roundcube:label name="tasklist.overdue" /><span class="count"></span></a></li>
 				<li class="flagged"><a href="#flagged"><roundcube:label name="tasklist.flagged" /><span class="count"></span></a></li>
 				<li class="today"><a href="#today"><roundcube:label name="tasklist.today" /><span class="count"></span></a></li>
 				<li class="tomorrow"><a href="#tomorrow"><roundcube:label name="tasklist.tomorrow" /><span class="count"></span></a></li>
 				<li class="week"><a href="#week"><roundcube:label name="tasklist.next7days" /></a></li>
 				<li class="later"><a href="#later"><roundcube:label name="tasklist.later" /></a></li>
 				<li class="nodate"><a href="#nodate"><roundcube:label name="tasklist.nodate" ucfirst="true" /></a></li>
 				<li class="complete"><a href="#complete"><roundcube:label name="tasklist.complete" /><span class="count"></span></a></li>
 			</ul>
 
 			<div class="buttonbar-right">
 				<roundcube:button name="taskviewmenulink" id="taskviewmenulink" type="link" title="tasklist.viewoptions" class="listmenu viewoptions" onclick="UI.show_popup('taskviewmenu');return false" innerClass="inner" content="&#9881;" />
 			</div>
 		</div>
 		
 		<div class="scroller">
 			<roundcube:object name="plugin.tasks" id="thelist" />
 			<div id="listmessagebox"></div>
 			<div id="rootdroppable"></div>
 		</div>
 	</div>
 	
 	</div>
 
 </div>
 
 <roundcube:object name="message" id="messagestack" />
 
 <div id="taskitemmenu" class="popupmenu">
 	<ul class="toolbarmenu iconized">
 		<li><roundcube:button name="edit" type="link" onclick="rctasks.edit_task(rctasks.selected_task.id, 'edit'); return false" label="edit" class="icon active" innerclass="icon edit" /></li>
 		<li><roundcube:button name="delete" type="link" onclick="rctasks.delete_task(rctasks.selected_task.id); return false" label="delete" class="icon active" innerclass="icon delete" /></li>
 		<li><roundcube:button name="addchild" type="link" onclick="rctasks.add_childtask(rctasks.selected_task.id); return false" label="tasklist.addsubtask" class="icon active" innerclass="icon add" /></li>
 	</ul>
 </div>
 
 <div id="tasklistoptionsmenu" class="popupmenu">
 	<ul class="toolbarmenu">
 		<li><roundcube:button command="list-edit" label="edit" classAct="active" /></li>
 		<li><roundcube:button command="list-remove" label="delete" classAct="active" /></li>
 		<!--<li><roundcube:button command="list-import" label="tasklist.import" classAct="active" /></li>-->
 		<roundcube:if condition="env:tasklist_driver == 'kolab'" />
 		<li><roundcube:button command="folders" task="settings" type="link" label="managefolders" classAct="active" /></li>
 		<roundcube:endif />
 	</ul>
 </div>
 
 <div id="taskviewmenu" class="popupmenu">
 	<ul class="toolbarmenu">
 		<li><roundcube:button command="expand-all" label="expand-all" class="icon" classAct="icon active" innerclass="icon expand" /></li>
 		<li><roundcube:button command="collapse-all" label="collapse-all" class="icon" classAct="icon active" innerclass="icon collapse" /></li>
 	</ul>
 </div>
 
 <div id="taskshow">
 	<div class="form-section" id="task-parent-title"></div>
 	<div class="form-section">
 		<h2 id="task-title"></h2>
 	</div>
 	<div id="task-description" class="form-section">
 	</div>
 	<div id="task-tags" class="form-section">
 		<label><roundcube:label name="tasklist.tags" /></label>
 		<span class="task-text tagedit"></span>
 	</div>
 	<div id="task-start" class="form-section">
 		<label><roundcube:label name="tasklist.start" /></label>
 		<span class="task-text"></span>
 		<span id="task-starttime"></span>
 	</div>
 	<div id="task-date" class="form-section">
 		<label><roundcube:label name="tasklist.datetime" /></label>
 		<span class="task-text"></span>
 		<span id="task-time"></span>
 	</div>
 	<div id="task-recurrence" class="form-section">
 		<label><roundcube:label name="tasklist.repeat" /></label>
 		<span class="task-text"></span>
 	</div>
 	<div id="task-alarm" class="form-section">
 		<label><roundcube:label name="tasklist.alarms" /></label>
 		<span class="task-text"></span>
 	</div>
 	<div id="task-list" class="form-section">
 		<label><roundcube:label name="tasklist.list" /></label>
 		<span class="task-text"></span>
 	</div>
 	<div id="task-completeness" class="form-section">
 		<label><roundcube:label name="tasklist.complete" /></label>
 		<span class="task-text"></span>
 	</div>
+	<div id="task-status" class="form-section">
+		<label><roundcube:label name="tasklist.status" /></label>
+		<span class="task-text"></span>
+	</div>
 	<div id="task-attachments" class="form-section">
 		<label><roundcube:label name="attachments" /></label>
 		<div class="task-text"></div>
 	</div>
 </div>
 
 <roundcube:include file="/templates/taskedit.html" />
 
 <div id="tasklistform" class="uidialog">
 	<roundcube:label name="loading" />
 	<roundcube:container name="tasklistform" id="tasklistform" />
 </div>
 
 <script type="text/javascript">
 
 // UI startup
 var UI = new rcube_mail_ui();
 
 $(document).ready(function(e){
 	UI.init();
 
 	rcmail.addEventListener('tasklist_editform_load', function(e){
 		if (rcmail.env.tasklist_driver == 'kolab')
 			UI.init_tabs($('#tasklistform > form').addClass('propform tabbed'));
 	});
 
 	new rcube_splitter({ id:'taskviewsplitter', p1:'#sidebar', p2:'#mainview-right',
 		orientation:'v', relative:true, start:240, min:180, size:12 }).init();
 	new rcube_splitter({ id:'taskviewsplitterv', p1:'#tagsbox', p2:'#tasklistsbox',
 		orientation:'h', relative:true, start:242, min:120, size:12, offset:4 }).init();
 });
 
 </script>
 
 </body>
 </html>
\ No newline at end of file
diff --git a/plugins/tasklist/skins/larry/templates/taskedit.html b/plugins/tasklist/skins/larry/templates/taskedit.html
index 31ee79c2..97f604db 100644
--- a/plugins/tasklist/skins/larry/templates/taskedit.html
+++ b/plugins/tasklist/skins/larry/templates/taskedit.html
@@ -1,89 +1,93 @@
 <div id="taskedit" class="uidialog uidialog-tabbed">
 	<form id="taskeditform" action="#" method="post" enctype="multipart/form-data">
 		<ul>
 			<li><a href="#taskedit-panel-main"><roundcube:label name="tasklist.tabsummary" /></a></li><li><a href="#taskedit-panel-recurrence"><roundcube:label name="tasklist.tabrecurrence" /></a></li><li id="taskedit-tab-attachments"><a href="#taskedit-panel-attachments"><roundcube:label name="tasklist.tabattachments" /></a></li>
 		</ul>
 		<!-- basic info -->
 		<div id="taskedit-panel-main">
 			<div class="form-section">
 				<label for="taskedit-title"><roundcube:label name="tasklist.title" /></label>
 				<br />
 				<input type="text" class="text" name="title" id="taskedit-title" size="60" tabindex="1" />
 			</div>
 			<div class="form-section">
 				<label for="taskedit-description"><roundcube:label name="tasklist.description" /></label>
 				<br />
 				<textarea name="description" id="taskedit-description" class="text" rows="5" cols="60" tabindex="2"></textarea>
 			</div>
 			<div class="form-section">
 				<label for="taskedit-tags"><roundcube:label name="tasklist.tags" /></label>
 				<roundcube:object name="plugin.tags_editline" id="taskedit-tagline" class="tagedit" tabindex="3" />
 			</div>
 			<div class="form-section">
 				<label for="taskedit-startdate"><roundcube:label name="tasklist.start" /></label>
 				<input type="text" name="startdate" size="10" id="taskedit-startdate" tabindex="23" /> &nbsp;
 				<input type="text" name="starttime" size="6" id="taskedit-starttime" tabindex="24" />
 				<a href="#nodate" style="margin-left:1em" class="edit-nodate" rel="#taskedit-startdate,#taskedit-starttime"><roundcube:label name="tasklist.nodate" /></a>
 			</div>
 			<div class="form-section">
 				<label for="taskedit-date"><roundcube:label name="tasklist.datetime" /></label>
 				<input type="text" name="date" size="10" id="taskedit-date" tabindex="20" /> &nbsp;
 				<input type="text" name="time" size="6" id="taskedit-time" tabindex="21" />
 				<a href="#nodate" style="margin-left:1em" class="edit-nodate" rel="#taskedit-date,#taskedit-time"><roundcube:label name="tasklist.nodate" /></a>
 			</div>
 			<div class="form-section" id="taskedit-alarms">
 				<div class="edit-alarm-item first">
 					<label><roundcube:label name="tasklist.alarms" /></label>
 					<roundcube:object name="plugin.alarm_select" />
 					<span class="edit-alarm-buttons">
 						<a href="#add" class="iconbutton add add-alarm">+</a>
 						<a href="#delete" class="iconbutton remove delete-alarm">-</a>
 					</span>
 				</div>
 			</div>
 			<div class="form-section">
 				<label for="taskedit-completeness"><roundcube:label name="tasklist.complete" /></label>
 				<input type="text" name="title" id="taskedit-completeness" size="3"  tabindex="25" />&nbsp;%
 				<div id="taskedit-completeness-slider"></div>
 			</div>
+			<div class="form-section">
+				<label for="taskedit-status"><roundcube:label name="tasklist.status" /></label>
+				<roundcube:object name="plugin.status_select" id="taskedit-status" tabindex="26" />
+			</div>
 			<div class="form-section" id="tasklist-select">
 				<label for="taskedit-tasklist"><roundcube:label name="tasklist.list" /></label>
 				<roundcube:object name="plugin.tasklist_select" id="taskedit-tasklist" tabindex="26" />
 			</div>
 		</div>
 		<!-- recurrence settings -->
 		<div id="taskedit-panel-recurrence">
 			<div class="form-section border-after">
 				<roundcube:object name="plugin.recurrence_form" part="frequency" />
 			</div>
 			<div class="recurrence-form border-after" id="recurrence-form-daily">
 				<roundcube:object name="plugin.recurrence_form" part="daily" class="form-section" />
 			</div>
 			<div class="recurrence-form border-after" id="recurrence-form-weekly">
 				<roundcube:object name="plugin.recurrence_form" part="weekly" class="form-section" />
 			</div>
 			<div class="recurrence-form border-after" id="recurrence-form-monthly">
 				<roundcube:object name="plugin.recurrence_form" part="monthly" class="form-section" />
 			</div>
 			<div class="recurrence-form border-after" id="recurrence-form-yearly">
 				<roundcube:object name="plugin.recurrence_form" part="yearly" class="form-section" />
 			</div>
 			<div class="recurrence-form" id="recurrence-form-until">
 				<roundcube:object name="plugin.recurrence_form" part="until" class="form-section" />
 			</div>
 			<div class="recurrence-form" id="recurrence-form-rdate">
 				<roundcube:object name="plugin.recurrence_form" part="rdate" class="form-section" />
 			</div>
 		</div>
 		<!-- attachments list (with upload form) -->
 		<div id="taskedit-panel-attachments">
 			<div id="taskedit-attachments">
 				<roundcube:object name="plugin.attachments_list" id="taskedit-attachment-list" class="attachmentslist" />
 			</div>
 			<div id="taskedit-attachments-form">
 				<roundcube:object name="plugin.attachments_form" id="taskedit-attachment-form" attachmentFieldSize="30" />
 			</div>
 			<roundcube:object name="plugin.filedroparea" id="taskedit-tab-2" />
 		</div>
 	</form>
 </div>
diff --git a/plugins/tasklist/tasklist.js b/plugins/tasklist/tasklist.js
index fcf43062..4bc82b0a 100644
--- a/plugins/tasklist/tasklist.js
+++ b/plugins/tasklist/tasklist.js
@@ -1,2079 +1,2089 @@
 /**
  * Client scripts for the Tasklist plugin
  *
  * @author Thomas Bruederli <bruederli@kolabsys.com>
  *
  * @licstart  The following is the entire license notice for the
  * JavaScript code in this file.
  *
  * Copyright (C) 2012, Kolab Systems AG <contact@kolabsys.com>
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU Affero General Public License as
  * published by the Free Software Foundation, either version 3 of the
  * License, or (at your option) any later version.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  * GNU Affero General Public License for more details.
  *
  * You should have received a copy of the GNU Affero General Public License
  * along with this program. If not, see <http://www.gnu.org/licenses/>.
  *
  * @licend  The above is the entire license notice
  * for the JavaScript code in this file.
  */
  
 function rcube_tasklist_ui(settings)
 {
     // extend base class
     rcube_libcalendaring.call(this, settings);
 
     /*  constants  */
     var FILTER_MASK_ALL = 0;
     var FILTER_MASK_TODAY = 1;
     var FILTER_MASK_TOMORROW = 2;
     var FILTER_MASK_WEEK = 4;
     var FILTER_MASK_LATER = 8;
     var FILTER_MASK_NODATE = 16;
     var FILTER_MASK_OVERDUE = 32;
     var FILTER_MASK_FLAGGED = 64;
     var FILTER_MASK_COMPLETE = 128;
 
     var filter_masks = {
         all:      FILTER_MASK_ALL,
         today:    FILTER_MASK_TODAY,
         tomorrow: FILTER_MASK_TOMORROW,
         week:     FILTER_MASK_WEEK,
         later:    FILTER_MASK_LATER,
         nodate:   FILTER_MASK_NODATE,
         overdue:  FILTER_MASK_OVERDUE,
         flagged:  FILTER_MASK_FLAGGED,
         complete: FILTER_MASK_COMPLETE
     };
 
     /*  private vars  */
     var selector = 'all';
     var tagsfilter = [];
     var filtermask = FILTER_MASK_ALL;
     var loadstate = { filter:-1, lists:'', search:null };
     var idcount = 0;
     var focusview;
     var saving_lock;
     var ui_loading;
     var taskcounts = {};
     var listindex = [];
     var listdata = {};
     var tags = [];
     var draghelper;
     var search_request;
     var search_query;
     var completeness_slider;
     var task_draghelper;
     var tag_draghelper;
     var task_drag_active = false;
     var list_scroll_top = 0;
     var scroll_delay = 400;
     var scroll_step = 5;
     var scroll_speed = 20;
     var scroll_sensitivity = 40;
     var scroll_timer;
     var me = this;
 
     // general datepicker settings
     var datepicker_settings = {
       // translate from PHP format to datepicker format
       dateFormat: settings['date_format'].replace(/M/g, 'm').replace(/mmmmm/, 'MM').replace(/mmm/, 'M').replace(/dddd/, 'DD').replace(/ddd/, 'D').replace(/yy/g, 'y'),
       firstDay : settings['first_day'],
 //      dayNamesMin: settings['days_short'],
 //      monthNames: settings['months'],
 //      monthNamesShort: settings['months'],
       changeMonth: false,
       showOtherMonths: true,
       selectOtherMonths: true
     };
     var extended_datepicker_settings;
 
     /*  public members  */
     this.tasklists = rcmail.env.tasklists;
     this.selected_task;
     this.selected_list;
 
     /*  public methods  */
     this.init = init;
     this.edit_task = task_edit_dialog;
     this.delete_task = delete_task;
     this.add_childtask = add_childtask;
     this.quicksearch = quicksearch;
     this.reset_search = reset_search;
     this.expand_collapse = expand_collapse;
     this.list_remove = list_remove;
     this.list_edit_dialog = list_edit_dialog;
     this.unlock_saving = unlock_saving;
 
     /* imports */
     var Q = this.quote_html;
     var text2html = this.text2html;
     var event_date_text = this.event_date_text;
     var parse_datetime = this.parse_datetime;
     var date2unixtime = this.date2unixtime;
     var fromunixtime = this.fromunixtime;
 
     /**
      * initialize the tasks UI
      */
     function init()
     {
         // initialize task list selectors
         for (var id in me.tasklists) {
             if ((li = rcmail.get_folder_li(id, 'rcmlitasklist'))) {
                 init_tasklist_li(li, id);
             }
 
             if (me.tasklists[id].editable && (!me.selected_list || (me.tasklists[id].active && !me.tasklists[me.selected_list].active))) {
                 me.selected_list = id;
             }
         }
 
         if (me.selected_list) {
             rcmail.enable_command('addtask', true);
             $(rcmail.get_folder_li(me.selected_list, 'rcmlitasklist')).click();
         }
 
         // register server callbacks
         rcmail.addEventListener('plugin.data_ready', data_ready);
         rcmail.addEventListener('plugin.update_task', update_taskitem);
         rcmail.addEventListener('plugin.refresh_tasks', function(p) { update_taskitem(p, true); });
         rcmail.addEventListener('plugin.update_counts', update_counts);
         rcmail.addEventListener('plugin.insert_tasklist', insert_list);
         rcmail.addEventListener('plugin.update_tasklist', update_list);
         rcmail.addEventListener('plugin.destroy_tasklist', destroy_list);
         rcmail.addEventListener('plugin.unlock_saving', unlock_saving);
         rcmail.addEventListener('requestrefresh', before_refresh);
         rcmail.addEventListener('plugin.reload_data', function(){
             list_tasks(null, true);
             setTimeout(fetch_counts, 200);
         });
 
         // start loading tasks
         fetch_counts();
         list_tasks();
 
         // register event handlers for UI elements
         $('#taskselector a').click(function(e){
             if (!$(this).parent().hasClass('inactive'))
                 list_tasks(this.href.replace(/^.*#/, ''));
             return false;
         });
 
         // quick-add a task
         $(rcmail.gui_objects.quickaddform).submit(function(e){
             var tasktext = this.elements.text.value,
                 rec = { id:-(++idcount), title:tasktext, readonly:true, mask:0, complete:0 };
 
             if (tasktext && tasktext.length) {
                 save_task({ tempid:rec.id, raw:tasktext, list:me.selected_list }, 'new');
                 render_task(rec);
 
                 $('#listmessagebox').hide();
             }
 
             // clear form
             this.reset();
             return false;
         }).find('input[type=text]').placeholder(rcmail.gettext('createnewtask','tasklist'));
 
         // click-handler on tags list
         $(rcmail.gui_objects.tagslist).click(function(e){
             var item = e.target.nodeName == 'LI' ? $(e.target) : $(e.target).closest('li'),
                 tag = item.data('value');
 
             if (!tag)
                 return false;
 
             // reset selection on regular clicks
             var index = $.inArray(tag, tagsfilter);
             var shift = e.shiftKey || e.ctrlKey || e.metaKey;
 
             if (!shift) {
                 if (tagsfilter.length > 1)
                     index = -1;
 
                 $('li', this).removeClass('selected');
                 tagsfilter = [];
             }
 
             // add tag to filter
             if (index < 0) {
                 item.addClass('selected');
                 tagsfilter.push(tag);
             }
             else if (shift) {
                 item.removeClass('selected');
                 var a = tagsfilter.slice(0,index);
                 tagsfilter = a.concat(tagsfilter.slice(index+1));
             }
 
             list_tasks();
 
             // clear text selection in IE after shift+click
             if (shift && document.selection)
               document.selection.empty();
 
             e.preventDefault();
             return false;
         })
         .mousedown(function(e){
             // disable content selection with the mouse
             e.preventDefault();
             return false;
         });
 
         // click-handler on task list items (delegate)
         $(rcmail.gui_objects.resultlist).click(function(e){
             var item = $(e.target);
             var className = e.target.className;
 
             if (item.hasClass('childtoggle')) {
                 item = item.parent().find('.taskhead');
                 className = 'childtoggle';
             }
             else if (!item.hasClass('taskhead'))
                 item = item.closest('div.taskhead');
 
             // ignore
             if (!item.length)
                 return false;
 
             var id = item.data('id'),
                 li = item.parent(),
                 rec = listdata[id];
             
             switch (className) {
                 case 'childtoggle':
                     rec.collapsed = !rec.collapsed;
                     li.children('.childtasks:first').toggle();
                     $(e.target).toggleClass('collapsed').html(rec.collapsed ? '&#9654;' : '&#9660;');
                     rcmail.http_post('tasks/task', { action:'collapse', t:{ id:rec.id, list:rec.list }, collapsed:rec.collapsed?1:0 });
                     if (e.shiftKey)  // expand/collapse all childs
                         li.children('.childtasks:first .childtoggle.'+(rec.collapsed?'expanded':'collapsed')).click();
                     break;
 
                 case 'complete':
                     if (rcmail.busy)
                         return false;
 
-                    rec.complete = e.target.checked ? 1 : 0;
+                    rec.status = e.target.checked ? 'COMPLETED' : (rec.complete == 1 ? 'NEEDS-ACTION' : '');
                     li.toggleClass('complete');
                     save_task(rec, 'edit');
                     return true;
                 
                 case 'flagged':
                     if (rcmail.busy)
                         return false;
 
                     rec.flagged = rec.flagged ? 0 : 1;
                     li.toggleClass('flagged');
                     save_task(rec, 'edit');
                     break;
                 
                 case 'date':
                     if (rcmail.busy)
                         return false;
 
                     var link = $(e.target).html(''),
                         input = $('<input type="text" size="10" />').appendTo(link).val(rec.date || '')
 
                     input.datepicker($.extend({
                         onClose: function(dateText, inst) {
                             if (dateText != (rec.date || '')) {
                                 rec.date = dateText;
                                 save_task(rec, 'edit');
                             }
                             input.datepicker('destroy').remove();
                             link.html(dateText || rcmail.gettext('nodate','tasklist'));
                         }
                       }, extended_datepicker_settings)
                     )
                     .datepicker('setDate', rec.date)
                     .datepicker('show');
                     break;
                 
                 case 'delete':
                     delete_task(id);
                     break;
 
                 case 'actions':
                     var pos, ref = $(e.target),
                         menu = $('#taskitemmenu');
                     if (menu.is(':visible') && menu.data('refid') == id) {
                         menu.hide();
                     }
                     else {
                         pos = ref.offset();
                         pos.left += ref.width() - menu.outerWidth();
                         pos.top += (pos.top + ref.outerHeight() + menu.height() > $(window).height() ? -menu.height() : ref.outerHeight());
                         menu.css({ top:pos.top+'px', left:pos.left+'px' }).show();
                         menu.data('refid', id);
                         me.selected_task = rec;
                     }
                     e.bubble = false;
                     break;
 
                 case 'extlink':
                     return true;
 
                 default:
                     if (e.target.nodeName != 'INPUT')
                         task_show_dialog(id);
                     break;
             }
 
             return false;
         })
         .dblclick(function(e){
             var id, rec, item = $(e.target);
             if (!item.hasClass('taskhead'))
                 item = item.closest('div.taskhead');
 
             if (!rcmail.busy && item.length && (id = item.data('id')) && (rec = listdata[id])) {
                 var list = rec.list && me.tasklists[rec.list] ? me.tasklists[rec.list] : {};
                 if (rec.readonly || !list.editable)
                     task_show_dialog(id);
                 else
                     task_edit_dialog(id, 'edit');
                 clearSelection();
             }
         });
 
         // handle global document clicks: close popup menus
         $(document.body).click(clear_popups);
 
         // extended datepicker settings
         var extended_datepicker_settings = $.extend({
             showButtonPanel: true,
             beforeShow: function(input, inst) {
                 setTimeout(function(){
                     $(input).datepicker('widget').find('button.ui-datepicker-close')
                         .html(rcmail.gettext('nodate','tasklist'))
                         .attr('onclick', '')
                         .unbind('click')
                         .bind('click', function(e){
                             $(input).datepicker('setDate', null).datepicker('hide');
                         });
                 }, 1);
             }
         }, datepicker_settings);
     }
 
     /**
      * initialize task edit form elements
      */
     function init_taskedit()
     {
         $('#taskedit').tabs();
 
         var completeness_slider_change = function(e, ui){
           var v = completeness_slider.slider('value');
           if (v >= 98) v = 100;
           if (v <= 2)  v = 0;
           $('#taskedit-completeness').val(v);
         };
         completeness_slider = $('#taskedit-completeness-slider').slider({
             range: 'min',
             animate: 'fast',
             slide: completeness_slider_change,
             change: completeness_slider_change
         });
         $('#taskedit-completeness').change(function(e){
             completeness_slider.slider('value', parseInt(this.value))
         });
 
         // register events on alarms and recurrence fields
         me.init_alarms_edit('#taskedit-alarms');
         me.init_recurrence_edit('#eventedit');
 
         $('#taskedit-date, #taskedit-startdate').datepicker(datepicker_settings);
 
         $('a.edit-nodate').click(function(){
             var sel = $(this).attr('rel');
             if (sel) $(sel).val('');
             return false;
         });
     }
 
     /**
      * Request counts from the server
      */
     function fetch_counts()
     {
         var active = active_lists();
         if (active.length)
             rcmail.http_request('counts', { lists:active.join(',') });
         else
             update_counts({});
     }
 
     /**
      * List tasks matching the given selector
      */
     function list_tasks(sel, force)
     {
         if (rcmail.busy)
             return;
 
         if (sel && filter_masks[sel] !== undefined) {
             filtermask = filter_masks[sel];
             selector = sel;
         }
 
         var active = active_lists(),
             basefilter = filtermask == FILTER_MASK_COMPLETE ? FILTER_MASK_COMPLETE : FILTER_MASK_ALL,
             reload = force || active.join(',') != loadstate.lists || basefilter != loadstate.filter || loadstate.search != search_query;
 
         if (active.length && reload) {
             ui_loading = rcmail.set_busy(true, 'loading');
             rcmail.http_request('fetch', { filter:basefilter, lists:active.join(','), q:search_query }, true);
         }
         else if (reload)
             data_ready({ data:[], lists:'', filter:basefilter, search:search_query });
         else
             render_tasklist();
 
         $('#taskselector li.selected').removeClass('selected');
         $('#taskselector li.'+selector).addClass('selected');
     }
 
     /**
      * Remove all tasks of the given list from the UI
      */
     function remove_tasks(list_id)
     {
         // remove all tasks of the given list from index
         var newindex = $.grep(listindex, function(id, i){
             return listdata[id] && listdata[id].list != list_id;
         });
 
         listindex = newindex;
         render_tasklist();
 
         // avoid reloading
         me.tasklists[list_id].active = false;
         loadstate.lists = active_lists();
     }
 
     /**
      * Modify query parameters for refresh requests
      */
     function before_refresh(query)
     {
         query.filter = filtermask == FILTER_MASK_COMPLETE ? FILTER_MASK_COMPLETE : FILTER_MASK_ALL;
         query.lists = active_lists().join(',');
         if (search_query)
             query.q = search_query;
 
         return query;
     }
 
     /**
      * Callback if task data from server is ready
      */
     function data_ready(response)
     {
         listdata = {};
         listindex = [];
         loadstate.lists = response.lists;
         loadstate.filter = response.filter;
         loadstate.search = response.search;
 
         for (var id, i=0; i < response.data.length; i++) {
             id = response.data[i].id;
             listindex.push(id);
             listdata[id] = response.data[i];
             listdata[id].children = [];
             // register a forward-pointer to child tasks
             if (listdata[id].parent_id && listdata[listdata[id].parent_id])
                 listdata[listdata[id].parent_id].children.push(id);
         }
 
         append_tags(response.tags || []);
         render_tasklist();
 
         rcmail.set_busy(false, 'loading', ui_loading);
     }
 
     /**
      *
      */
     function render_tasklist()
     {
         // clear display
         var id, rec,
             count = 0,
             cache = {},
             activetags = {},
             msgbox = $('#listmessagebox').hide(),
             list = $(rcmail.gui_objects.resultlist).html('');
 
         for (var i=0; i < listindex.length; i++) {
             id = listindex[i];
             rec = listdata[id];
             if (match_filter(rec, cache)) {
                 render_task(rec);
                 count++;
 
                 // keep a list of tags from all visible tasks
                 for (var t, j=0; rec.tags && j < rec.tags.length; j++) {
                     t = rec.tags[j];
                     if (typeof activetags[t] == 'undefined')
                         activetags[t] = 0;
                     activetags[t]++;
                 }
             }
         }
 
         fix_tree_toggles();
         update_tagcloud(activetags);
 
         if (!count)
             msgbox.html(rcmail.gettext('notasksfound','tasklist')).show();
     }
 
     /**
      * Show/hide child toggle buttons on all visible task items
      */
     function fix_tree_toggles()
     {
         $('.taskitem', rcmail.gui_objects.resultlist).each(function(i,elem){
             var li = $(elem),
                 rec = listdata[li.attr('rel')],
                 childs = $('.childtasks li', li);
 
             $('.childtoggle', li)[(childs.length ? 'show' : 'hide')]();
         })
     }
 
     /**
      * Expand/collapse all task items with childs
      */
     function expand_collapse(expand)
     {
         var collapsed = !expand;
 
         $('.taskitem .childtasks')[(collapsed ? 'hide' : 'show')]();
         $('.taskitem .childtoggle')
             .removeClass(collapsed ? 'expanded' : 'collapsed')
             .addClass(collapsed ? 'collapsed' : 'expanded')
             .html(collapsed ? '&#9654;' : '&#9660;');
 
         // store new toggle collapse states
         var ids = [];
         for (var id in listdata) {
             if (listdata[id].children && listdata[id].children.length)
                 ids.push(id);
         }
         if (ids.length) {
             rcmail.http_post('tasks/task', { action:'collapse', t:{ id:ids.join(',') }, collapsed:collapsed?1:0 });
         }
     }
 
     /**
      *
      */
     function append_tags(taglist)
     {
         // find new tags
         var newtags = [];
         for (var i=0; i < taglist.length; i++) {
             if ($.inArray(taglist[i], tags) < 0)
                 newtags.push(taglist[i]);
         }
         tags = tags.concat(newtags);
 
         // append new tags to tag cloud
         $.each(newtags, function(i, tag){
             $('<li>').attr('rel', tag).data('value', tag)
                 .html(Q(tag) + '<span class="count"></span>')
                 .appendTo(rcmail.gui_objects.tagslist)
                 .draggable({
                     addClasses: false,
                     revert: 'invalid',
                     revertDuration: 300,
                     helper: tag_draggable_helper,
                     start: tag_draggable_start,
                     appendTo: 'body',
                     cursor: 'pointer'
                 });
             });
 
         // re-sort tags list
         $(rcmail.gui_objects.tagslist).children('li').sortElements(function(a,b){
             return $.text([a]).toLowerCase() > $.text([b]).toLowerCase() ? 1 : -1;
         });
     }
 
     /**
      * Display the given counts to each tag and set those inactive which don't
      * have any matching tasks in the current view.
      */
     function update_tagcloud(counts)
     {
         // compute counts first by iterating over all visible task items
         if (typeof counts == 'undefined') {
             counts = {};
             $('li.taskitem', rcmail.gui_objects.resultlist).each(function(i,li){
                 var t, id = $(li).attr('rel'),
                     rec = listdata[id];
                 for (var j=0; rec && rec.tags && j < rec.tags.length; j++) {
                     t = rec.tags[j];
                     if (typeof counts[t] == 'undefined')
                         counts[t] = 0;
                     counts[t]++;
                 }
             });
         }
 
         $(rcmail.gui_objects.tagslist).children('li').each(function(i,li){
             var elem = $(li), tag = elem.attr('rel'),
                 count = counts[tag] || 0;
 
             elem.children('.count').html(count+'');
             if (count == 0) elem.addClass('inactive');
             else            elem.removeClass('inactive');
         });
     }
 
     /*  Helper functions for drag & drop functionality of tags  */
     
     function tag_draggable_helper()
     {
         if (!tag_draghelper)
             tag_draghelper = $('<div class="tag-draghelper"></div>');
         else
             tag_draghelper.html('');
 
         $(this).clone().addClass('tag').appendTo(tag_draghelper);
         return tag_draghelper;
     }
 
     function tag_draggable_start(event, ui)
     {
         $('.taskhead').droppable({
             hoverClass: 'droptarget',
             accept: tag_droppable_accept,
             drop: tag_draggable_dropped,
             addClasses: false
         });
     }
 
     function tag_droppable_accept(draggable)
     {
         if (rcmail.busy)
             return false;
 
         var tag = draggable.data('value'),
             drop_id = $(this).data('id'),
             drop_rec = listdata[drop_id];
 
         // target already has this tag assigned
         if (!drop_rec || (drop_rec.tags && $.inArray(tag, drop_rec.tags) >= 0)) {
             return false;
         }
 
         return true;
     }
 
     function tag_draggable_dropped(event, ui)
     {
         var drop_id = $(this).data('id'),
             tag = ui.draggable.data('value'),
             rec = listdata[drop_id];
 
         if (rec && rec.id) {
             if (!rec.tags) rec.tags = [];
             rec.tags.push(tag);
             save_task(rec, 'edit');
         }
     }
 
     /**
      *
      */
     function update_counts(counts)
     {
         // got new data
         if (counts)
             taskcounts = counts;
 
         // iterate over all selector links and update counts
         $('#taskselector a').each(function(i, elem){
             var link = $(elem),
                 f = link.parent().attr('class').replace(/\s\w+/, '');
             if (f != 'all')
                 link.children('span').html(taskcounts[f] || '')[(taskcounts[f] ? 'show' : 'hide')]();
         });
 
         // spacial case: overdue
         $('#taskselector li.overdue')[(taskcounts.overdue ? 'removeClass' : 'addClass')]('inactive');
     }
 
     /**
      * Callback from server to update a single task item
      */
     function update_taskitem(rec, filter)
     {
         // handle a list of task records
         if ($.isArray(rec)) {
             $.each(rec, function(i,r){ update_taskitem(r, filter); });
             return;
         }
 
         var id = rec.id,
             oldid = rec.tempid || id,
             oldrec = listdata[oldid],
             oldindex = $.inArray(oldid, listindex),
             oldparent = oldrec ? (oldrec._old_parent_id || oldrec.parent_id) : null,
             list = me.tasklists[rec.list];
 
         if (oldindex >= 0)
             listindex[oldindex] = id;
         else
             listindex.push(id);
 
         listdata[id] = rec;
 
         // remove child-pointer from old parent
         if (oldparent && listdata[oldparent] && oldparent != rec.parent_id) {
             var oldchilds = listdata[oldparent].children,
                 i = $.inArray(oldid, oldchilds);
             if (i >= 0) {
                 listdata[oldparent].children = oldchilds.slice(0,i).concat(oldchilds.slice(i+1));
             }
         }
 
         // register a forward-pointer to child tasks
         if (rec.parent_id && listdata[rec.parent_id] && listdata[rec.parent_id].children && $.inArray(id, listdata[rec.parent_id].children) < 0)
             listdata[rec.parent_id].children.push(id);
 
         // restore pointers to my children
         if (!listdata[id].children) {
             listdata[id].children = [];
             for (var pid in listdata) {
                 if (listdata[pid].parent_id == id)
                     listdata[id].children.push(pid);
             }
         }
 
         if (list.active || rec.tempid) {
             if (!filter || match_filter(rec, {}))
                 render_task(rec, oldid);
         }
         else {
             $('li[rel="'+id+'"]', rcmail.gui_objects.resultlist).remove();
         }
 
         append_tags(rec.tags || []);
         update_tagcloud();
         fix_tree_toggles();
     }
 
     /**
      * Submit the given (changed) task record to the server
      */
     function save_task(rec, action)
     {
         if (!rcmail.busy) {
             saving_lock = rcmail.set_busy(true, 'tasklist.savingdata');
             rcmail.http_post('tasks/task', { action:action, t:rec, filter:filtermask });
             $('button.ui-button:ui-button').button('option', 'disabled', rcmail.busy);
             return true;
         }
         
         return false;
     }
 
     /**
      * Remove saving lock and free the UI for new input
      */
     function unlock_saving()
     {
         if (saving_lock) {
             rcmail.set_busy(false, null, saving_lock);
             $('button.ui-button:ui-button').button('option', 'disabled', false);
         }
     }
 
     /**
      * Render the given task into the tasks list
      */
     function render_task(rec, replace)
     {
         var tags_html = '';
         for (var j=0; rec.tags && j < rec.tags.length; j++)
             tags_html += '<span class="tag">' + Q(rec.tags[j]) + '</span>';
 
         var div = $('<div>').addClass('taskhead').html(
             '<div class="progressbar"><div class="progressvalue" style="width:' + (rec.complete * 100) + '%"></div></div>' +
-            '<input type="checkbox" name="completed[]" value="1" class="complete" ' + (rec.complete == 1.0 ? 'checked="checked" ' : '') + '/>' + 
+            '<input type="checkbox" name="completed[]" value="1" class="complete" ' + (is_complete(rec) ? 'checked="checked" ' : '') + '/>' + 
             '<span class="flagged"></span>' +
             '<span class="title">' + text2html(Q(rec.title)) + '</span>' +
             '<span class="tags">' + tags_html + '</span>' +
             '<span class="date">' + Q(rec.date || rcmail.gettext('nodate','tasklist')) + '</span>' +
             '<a href="#" class="actions">V</a>'
             )
             .data('id', rec.id)
             .draggable({
                 revert: 'invalid',
                 addClasses: false,
                 cursorAt: { left:-10, top:12 },
                 helper: task_draggable_helper,
                 appendTo: 'body',
                 start: task_draggable_start,
                 stop: task_draggable_stop,
                 drag: task_draggable_move,
                 revertDuration: 300
             });
 
-        if (rec.complete == 1.0)
+        if (is_complete(rec))
             div.addClass('complete');
         if (rec.flagged)
             div.addClass('flagged');
         if (!rec.date)
             div.addClass('nodate');
         if ((rec.mask & FILTER_MASK_OVERDUE))
             div.addClass('overdue');
 
         var li, inplace = false, parent = rec.parent_id ? $('li[rel="'+rec.parent_id+'"] > ul.childtasks', rcmail.gui_objects.resultlist) : null;
         if (replace && (li = $('li[rel="'+replace+'"]', rcmail.gui_objects.resultlist)) && li.length) {
             li.children('div.taskhead').first().replaceWith(div);
             li.attr('rel', rec.id);
             inplace = true;
         }
         else {
             li = $('<li>')
                 .attr('rel', rec.id)
                 .addClass('taskitem')
                 .append((rec.collapsed ? '<span class="childtoggle collapsed">&#9654;' : '<span class="childtoggle expanded">&#9660;') + '</span>')
                 .append(div)
                 .append('<ul class="childtasks" style="' + (rec.collapsed ? 'display:none' : '') + '"></ul>');
 
             if (!parent || !parent.length)
                 li.appendTo(rcmail.gui_objects.resultlist);
         }
 
         if (!inplace && parent && parent.length)
             li.appendTo(parent);
 
         if (replace) {
             resort_task(rec, li, true);
             // TODO: remove the item after a while if it doesn't match the current filter anymore
         }
     }
 
     /**
      * Move the given task item to the right place in the list
      */
     function resort_task(rec, li, animated)
     {
         var dir = 0, index, slice, cmp, next_li, next_id, next_rec, insert_after, past_myself;
 
         // animated moving
         var insert_animated = function(li, before, after) {
             if (before && li.next().get(0) == before.get(0))
                 return; // nothing to do
             else if (after && li.prev().get(0) == after.get(0))
                 return; // nothing to do
             
             var speed = 300;
             li.slideUp(speed, function(){
                 if (before)     li.insertBefore(before);
                 else if (after) li.insertAfter(after);
                 li.slideDown(speed);
             });
         }
 
         // remove from list index
         var oldlist = listindex.join('%%%');
         var oldindex = $.inArray(rec.id, listindex);
         if (oldindex >= 0) {
             slice = listindex.slice(0,oldindex);
             listindex = slice.concat(listindex.slice(oldindex+1));
         }
 
         // find the right place to insert the task item
         li.parent().children('.taskitem').each(function(i, elem){
             next_li = $(elem);
             next_id = next_li.attr('rel');
             next_rec = listdata[next_id];
 
             if (next_id == rec.id) {
                 past_myself = true;
                 return 1; // continue
             }
 
             cmp = next_rec ? task_cmp(rec, next_rec) : 0;
 
             if (cmp > 0 || (cmp == 0 && !past_myself)) {
                 insert_after = next_li;
                 return 1; // continue;
             }
             else if (next_li && cmp < 0) {
                 if (animated) insert_animated(li, next_li);
                 else          li.insertBefore(next_li);
                 index = $.inArray(next_id, listindex);
                 return false; // break
             }
         });
 
         if (insert_after) {
             if (animated) insert_animated(li, null, insert_after);
             else          li.insertAfter(insert_after);
 
             next_id = insert_after.attr('rel');
             index = $.inArray(next_id, listindex);
         }
 
         // insert into list index
         if (next_id && index >= 0) {
             slice = listindex.slice(0,index);
             slice.push(rec.id);
             listindex = slice.concat(listindex.slice(index));
         }
         else {  // restore old list index
             listindex = oldlist.split('%%%');
         }
     }
 
     /**
      * Compare function of two task records.
      * (used for sorting)
      */
     function task_cmp(a, b)
     {
-        var d = Math.floor(a.complete) - Math.floor(b.complete);
+        var d = is_complete(a) - is_complete(b);
         if (!d) d = (b._hasdate-0) - (a._hasdate-0);
         if (!d) d = (a.datetime||99999999999) - (b.datetime||99999999999);
         return d;
     }
 
+    /**
+     * Determine whether the given task should be displayed as "complete"
+     */
+    function is_complete(rec)
+    {
+        return ((rec.complete == 1.0 && !rec.status) || rec.status === 'COMPLETED') ? 1 : 0;
+    }
+
     /**
      *
      */
     function get_all_childs(id)
     {
         var cid, childs = [];
         for (var i=0; listdata[id].children && i < listdata[id].children.length; i++) {
             cid = listdata[id].children[i];
             childs.push(cid);
             childs = childs.concat(get_all_childs(cid));
         }
 
         return childs;
     }
 
 
     /*  Helper functions for drag & drop functionality  */
     
     function task_draggable_helper()
     {
         if (!task_draghelper)
             task_draghelper = $('<div class="taskitem-draghelper">&#x2714;</div>');
 
         return task_draghelper;
     }
 
     function task_draggable_start(event, ui)
     {
         $('.taskhead, #rootdroppable, #'+rcmail.gui_objects.folderlist.id+' li').droppable({
             hoverClass: 'droptarget',
             accept: task_droppable_accept,
             drop: task_draggable_dropped,
             addClasses: false
         });
 
         $(this).parent().addClass('dragging');
         $('#rootdroppable').show();
 
         // enable auto-scrolling of list container
         var container = $(rcmail.gui_objects.resultlist);
         if (container.height() > container.parent().height()) {
             task_drag_active = true;
             list_scroll_top = container.parent().scrollTop();
         }
     }
 
     function task_draggable_move(event, ui)
     {
         var scroll = 0,
             mouse = rcube_event.get_mouse_pos(event),
             container = $(rcmail.gui_objects.resultlist);
 
         mouse.y -= container.parent().offset().top;
 
         if (mouse.y < scroll_sensitivity && list_scroll_top > 0) {
             scroll = -1; // up
         }
         else if (mouse.y > container.parent().height() - scroll_sensitivity) {
             scroll = 1; // down
         }
 
         if (task_drag_active && scroll != 0) {
             if (!scroll_timer)
                 scroll_timer = window.setTimeout(function(){ tasklist_drag_scroll(container, scroll); }, scroll_delay);
         }
         else if (scroll_timer) {
             window.clearTimeout(scroll_timer);
             scroll_timer = null;
         }
     }
 
     function task_draggable_stop(event, ui)
     {
         $(this).parent().removeClass('dragging');
         $('#rootdroppable').hide();
         task_drag_active = false;
     }
 
     function task_droppable_accept(draggable)
     {
         if (rcmail.busy)
             return false;
 
         var drag_id = draggable.data('id'),
             drop_id = $(this).data('id'),
             drag_rec = listdata[drag_id] || {},
             drop_rec = listdata[drop_id];
 
         // drop target is another list
         if (drag_rec && $(this).data('type') == 'tasklist') {
             var  drop_list = me.tasklists[drop_id],
                from_list = me.tasklists[drag_rec.list];
             return !drag_rec.parent_id && drop_id != drag_rec.list && drop_list && drop_list.editable && from_list && from_list.editable;
         }
 
         if (drop_rec && drop_rec.list != drag_rec.list)
             return false;
 
         if (drop_id == drag_rec.parent_id)
             return false;
 
         while (drop_rec && drop_rec.parent_id) {
             if (drop_rec.parent_id == drag_id)
                 return false;
             drop_rec = listdata[drop_rec.parent_id];
         }
 
         return true;
     }
 
     function task_draggable_dropped(event, ui)
     {
         var drop_id = $(this).data('id'),
             task_id = ui.draggable.data('id'),
             rec = listdata[task_id],
             parent, li;
 
         // dropped on another list -> move
         if ($(this).data('type') == 'tasklist') {
             if (rec) {
                 save_task({ id:rec.id, list:drop_id, _fromlist:rec.list }, 'move');
                 rec.list = drop_id;
             }
         }
         // dropped on a new parent task or root
         else {
             parent = drop_id ? $('li[rel="'+drop_id+'"] > ul.childtasks', rcmail.gui_objects.resultlist) : $(rcmail.gui_objects.resultlist)
 
             if (rec && parent.length) {
                 // submit changes to server
                 rec._old_parent_id = rec.parent_id;
                 rec.parent_id = drop_id || 0;
                 save_task(rec, 'edit');
 
                 li = ui.draggable.parent();
                 li.slideUp(300, function(){
                     li.appendTo(parent);
                     resort_task(rec, li);
                     li.slideDown(300);
                     fix_tree_toggles();
                 });
             }
         }
     }
 
     /**
      * Scroll list container in the given direction
      */
     function tasklist_drag_scroll(container, dir)
     {
         if (!task_drag_active)
             return;
 
         var old_top = list_scroll_top;
         container.parent().get(0).scrollTop += scroll_step * dir;
         list_scroll_top = container.parent().scrollTop();
         scroll_timer = null;
 
         if (list_scroll_top != old_top)
             scroll_timer = window.setTimeout(function(){ tasklist_drag_scroll(container, dir); }, scroll_speed);
     }
 
     /**
      * Show task details in a dialog
      */
     function task_show_dialog(id)
     {
         var $dialog = $('#taskshow'), rec;
 
         if ($dialog.is(':ui-dialog'))
           $dialog.dialog('close');
 
         if (!(rec = listdata[id]) || clear_popups({}))
             return;
 
         me.selected_task = rec;
 
         // fill dialog data
         $('#task-parent-title').html(Q(rec.parent_title || '')+' &raquo;').css('display', rec.parent_title ? 'block' : 'none');
         $('#task-title').html(text2html(Q(rec.title || '')));
         $('#task-description').html(text2html(rec.description || '', 300, 6))[(rec.description ? 'show' : 'hide')]();
         $('#task-date')[(rec.date ? 'show' : 'hide')]().children('.task-text').html(Q(rec.date || rcmail.gettext('nodate','tasklist')));
         $('#task-time').html(Q(rec.time || ''));
         $('#task-start')[(rec.startdate ? 'show' : 'hide')]().children('.task-text').html(Q(rec.startdate || ''));
         $('#task-starttime').html(Q(rec.starttime || ''));
         $('#task-alarm')[(rec.alarms_text ? 'show' : 'hide')]().children('.task-text').html(Q(rec.alarms_text));
         $('#task-completeness .task-text').html(((rec.complete || 0) * 100) + '%');
+        $('#task-status')[(rec.status ? 'show' : 'hide')]().children('.task-text').html(rcmail.gettext('status-'+String(rec.status).toLowerCase(),'tasklist'));
         $('#task-list .task-text').html(Q(me.tasklists[rec.list] ? me.tasklists[rec.list].name : ''));
 
         var itags = get_inherited_tags(rec);
         var taglist = $('#task-tags')[(rec.tags && rec.tags.length || itags.length ? 'show' : 'hide')]().children('.task-text').empty();
         if (rec.tags && rec.tags.length) {
             $.each(rec.tags, function(i,val){
                 $('<span>').addClass('tag-element').html(Q(val)).appendTo(taglist);
             });
         }
 
         // append inherited tags
         if (itags.length) {
             $.each(itags, function(i,val){
                 if (!rec.tags || $.inArray(val, rec.tags) < 0)
                     $('<span>').addClass('tag-element inherit').html(Q(val)).appendTo(taglist);
             });
             // re-sort tags list
             $(taglist).children().sortElements(function(a,b){
                 return $.text([a]).toLowerCase() > $.text([b]).toLowerCase() ? 1 : -1;
             });
         }
 
         if (rec.recurrence && rec.recurrence_text) {
             $('#task-recurrence').show().children('.task-text').html(Q(rec.recurrence_text));
         }
         else {
             $('#task-recurrence').hide();
         }
 
         // build attachments list
         $('#task-attachments').hide();
         if ($.isArray(rec.attachments)) {
             task_show_attachments(rec.attachments || [], $('#task-attachments').children('.task-text'), rec);
             if (rec.attachments.length > 0) {
                 $('#task-attachments').show();
             }
         }
 
         // define dialog buttons
         var buttons = [];
         buttons.push({
             text: rcmail.gettext('edit','tasklist'),
             click: function() {
                 task_edit_dialog(me.selected_task.id, 'edit');
             },
             disabled: rcmail.busy
         });
 
         buttons.push({
             text: rcmail.gettext('delete','tasklist'),
             click: function() {
                 if (delete_task(me.selected_task.id))
                     $dialog.dialog('close');
             },
             disabled: rcmail.busy
         });
 
         // open jquery UI dialog
         $dialog.dialog({
           modal: false,
           resizable: true,
           closeOnEscape: true,
           title: rcmail.gettext('taskdetails', 'tasklist'),
           open: function() {
             $dialog.parent().find('.ui-button').first().focus();
           },
           close: function() {
               $dialog.dialog('destroy').appendTo(document.body);
           },
           buttons: buttons,
           minWidth: 500,
           width: 580
         }).show();
 
         // set dialog size according to content
         me.dialog_resize($dialog.get(0), $dialog.height(), 580);
     }
 
     /**
      * Opens the dialog to edit a task
      */
     function task_edit_dialog(id, action, presets)
     {
         $('#taskshow:ui-dialog').dialog('close');
 
         var rec = listdata[id] || presets,
             $dialog = $('<div>'),
             editform = $('#taskedit'),
             list = rec.list && me.tasklists[rec.list] ? me.tasklists[rec.list] :
                 (me.selected_list ? me.tasklists[me.selected_list] : { editable: action=='new' });
 
         if (rcmail.busy || !list.editable || (action == 'edit' && (!rec || rec.readonly)))
             return false;
 
         me.selected_task = $.extend({ valarms:[] }, rec);  // clone task object
         rec =  me.selected_task;
 
         // assign temporary id
         if (!me.selected_task.id)
             me.selected_task.id = -(++idcount);
 
         // reset dialog first
         $('#taskeditform').get(0).reset();
 
         // fill form data
         var title = $('#taskedit-title').val(rec.title || '');
         var description = $('#taskedit-description').val(rec.description || '');
         var recdate = $('#taskedit-date').val(rec.date || '');
         var rectime = $('#taskedit-time').val(rec.time || '');
         var recstartdate = $('#taskedit-startdate').val(rec.startdate || '');
         var recstarttime = $('#taskedit-starttime').val(rec.starttime || '');
         var complete = $('#taskedit-completeness').val((rec.complete || 0) * 100);
         completeness_slider.slider('value', complete.val());
+        var taskstatus = $('#taskedit-status').val(rec.status || '');
         var tasklist = $('#taskedit-tasklist').val(rec.list || me.selected_list).prop('disabled', rec.parent_id ? true : false);
 
         // tag-edit line
         var tagline = $(rcmail.gui_objects.edittagline).empty();
         $.each(typeof rec.tags == 'object' && rec.tags.length ? rec.tags : [''], function(i,val){
             $('<input>')
                 .attr('name', 'tags[]')
                 .attr('tabindex', '3')
                 .addClass('tag')
                 .val(val)
                 .appendTo(tagline);
         });
 
         $('input.tag', rcmail.gui_objects.edittagline).tagedit({
             animSpeed: 100,
             allowEdit: false,
             checkNewEntriesCaseSensitive: false,
             autocompleteOptions: { source: tags, minLength: 0, noCheck: true },
             texts: { removeLinkTitle: rcmail.gettext('removetag', 'tasklist') }
         });
 
         // set alarm(s)
         me.set_alarms_edit('#taskedit-alarms', action != 'new' && rec.valarms ? rec.valarms : []);
 
         // set recurrence
         me.set_recurrence_edit(rec);
 
         // attachments
         rcmail.enable_command('remove-attachment', list.editable);
         me.selected_task.deleted_attachments = [];
         // we're sharing some code for uploads handling with app.js
         rcmail.env.attachments = [];
         rcmail.env.compose_id = me.selected_task.id; // for rcmail.async_upload_form()
 
         if ($.isArray(rec.attachments)) {
             task_show_attachments(rec.attachments, $('#taskedit-attachments'), rec, true);
         }
         else {
             $('#taskedit-attachments > ul').empty();
         }
 
         // show/hide tabs according to calendar's feature support
         $('#taskedit-tab-attachments')[(list.attachments||rec.attachments?'show':'hide')]();
 
         // activate the first tab
         $('#taskedit').tabs('select', 0);
 
         // define dialog buttons
         var buttons = {};
         buttons[rcmail.gettext('save', 'tasklist')] = function() {
             // copy form field contents into task object to save
-            $.each({ title:title, description:description, date:recdate, time:rectime, startdate:recstartdate, starttime:recstarttime, list:tasklist }, function(key,input){
+            $.each({ title:title, description:description, date:recdate, time:rectime, startdate:recstartdate, starttime:recstarttime, status:taskstatus, list:tasklist }, function(key,input){
                 me.selected_task[key] = input.val();
             });
             me.selected_task.tags = [];
             me.selected_task.attachments = [];
             me.selected_task.valarms = me.serialize_alarms('#taskedit-alarms');
             me.selected_task.recurrence = me.serialize_recurrence(rectime.val());
 
             // do some basic input validation
             if (!me.selected_task.title || !me.selected_task.title.length) {
                 title.focus();
                 return false;
             }
             else if (me.selected_task.startdate && me.selected_task.date) {
                 var startdate = $.datepicker.parseDate(datepicker_settings.dateFormat, me.selected_task.startdate, datepicker_settings);
                 var duedate = $.datepicker.parseDate(datepicker_settings.dateFormat, me.selected_task.date, datepicker_settings);
                 if (startdate > duedate) {
                     alert(rcmail.gettext('invalidstartduedates', 'tasklist'));
                     return false;
                 }
             }
 
             // collect tags
             $('input[type="hidden"]', rcmail.gui_objects.edittagline).each(function(i,elem){
                 if (elem.value)
                     me.selected_task.tags.push(elem.value);
             });
             // including the "pending" one in the text box
             var newtag = $('#tagedit-input').val();
             if (newtag != '') {
                 me.selected_task.tags.push(newtag);
             }
 
             // uploaded attachments list
             for (var i in rcmail.env.attachments) {
                 if (i.match(/^rcmfile(.+)/))
                     me.selected_task.attachments.push(RegExp.$1);
             }
 
             // task assigned to a new list
             if (me.selected_task.list && listdata[id] && me.selected_task.list != listdata[id].list) {
                 me.selected_task._fromlist = list.id;
             }
 
             me.selected_task.complete = complete.val() / 100;
             if (isNaN(me.selected_task.complete))
                 me.selected_task.complete = null;
 
             if (!me.selected_task.list && list.id)
                 me.selected_task.list = list.id;
 
             if (!me.selected_task.tags.length)
                 me.selected_task.tags = '';
 
             if (save_task(me.selected_task, action))
                 $dialog.dialog('close');
         };
 
         if (action != 'new') {
             buttons[rcmail.gettext('delete', 'tasklist')] = function() {
                 if (delete_task(rec.id))
                     $dialog.dialog('close');
             };
         }
 
         buttons[rcmail.gettext('cancel', 'tasklist')] = function() {
             $dialog.dialog('close');
         };
 
         // open jquery UI dialog
         $dialog.dialog({
           modal: true,
           resizable: (!bw.ie6 && !bw.ie7),  // disable for performance reasons
           closeOnEscape: false,
           title: rcmail.gettext((action == 'edit' ? 'edittask' : 'newtask'), 'tasklist'),
           close: function() {
               editform.hide().appendTo(document.body);
               $dialog.dialog('destroy').remove();
           },
           buttons: buttons,
           minHeight: 460,
           minWidth: 500,
           width: 580
         }).append(editform.show());  // adding form content AFTERWARDS massively speeds up opening on IE
 
         title.select();
 
         // set dialog size according to content
         me.dialog_resize($dialog.get(0), $dialog.height(), 580);
     }
 
 
     /**
      * Open a task attachment either in a browser window for inline view or download it
      */
     function load_attachment(rec, att)
     {
         // can't open temp attachments
         if (!rec.id || rec.id < 0)
             return false;
 
         var qstring = '_id='+urlencode(att.id)+'&_t='+urlencode(rec.recurrence_id||rec.id)+'&_list='+urlencode(rec.list);
 
         // open attachment in frame if it's of a supported mimetype
         // similar as in app.js and calendar_ui.js
         if (att.id && att.mimetype && $.inArray(att.mimetype, settings.mimetypes)>=0) {
             if (rcmail.open_window(rcmail.env.comm_path+'&_action=get-attachment&'+qstring+'&_frame=1', true, true)) {
                 return;
             }
         }
 
         rcmail.goto_url('get-attachment', qstring+'&_download=1', false);
     };
 
     /**
      * Build task attachments list
      */
     function task_show_attachments(list, container, rec, edit)
     {
         var i, id, len, content, li, elem,
             ul = $('<ul>').addClass('attachmentslist');
 
         for (i=0, len=list.length; i<len; i++) {
             elem = list[i];
             li = $('<li>').addClass(elem.classname);
 
             if (edit) {
                 rcmail.env.attachments[elem.id] = elem;
                 // delete icon
                 content = $('<a>')
                     .attr('href', '#delete')
                     .attr('title', rcmail.gettext('delete'))
                     .addClass('delete')
                     .click({ id:elem.id }, function(e) {
                         remove_attachment(this, e.data.id);
                         return false;
                     });
 
                 if (!rcmail.env.deleteicon) {
                     content.html(rcmail.gettext('delete'));
                 }
                 else {
                     $('<img>').attr('src', rcmail.env.deleteicon).attr('alt', rcmail.gettext('delete')).appendTo(content);
                 }
 
                 li.append(content);
             }
 
             // name/link
             $('<a>')
                 .attr('href', '#load')
                 .addClass('file')
                 .html(elem.name).click({ task:rec, att:elem }, function(e) {
                     load_attachment(e.data.task, e.data.att);
                     return false;
                 }).appendTo(li);
 
             ul.append(li);
         }
 
         if (edit && rcmail.gui_objects.attachmentlist) {
             ul.id = rcmail.gui_objects.attachmentlist.id;
             rcmail.gui_objects.attachmentlist = ul.get(0);
         }
 
         container.empty().append(ul);
     };
 
     /**
      *
      */
     var remove_attachment = function(elem, id)
     {
         $(elem.parentNode).hide();
         me.selected_task.deleted_attachments.push(id);
         delete rcmail.env.attachments[id];
     };
 
     /**
      *
      */
     function add_childtask(id)
     {
         if (rcmail.busy)
             return false;
 
         var rec = listdata[id];
         task_edit_dialog(null, 'new', { parent_id:id, list:rec.list });
     }
 
     /**
      * Delete the given task
      */
     function delete_task(id)
     {
         var rec = listdata[id];
         if (!rec || rec.readonly || rcmail.busy)
             return false;
 
         var html, buttons = [];
 
         if (rec.children && rec.children.length) {
             html = rcmail.gettext('deleteparenttasktconfirm','tasklist');
             buttons.push({
                 text: rcmail.gettext('deletethisonly','tasklist'),
                 click: function() {
                     _delete_task(id, 0);
                     $(this).dialog('close');
                 }
             });
             buttons.push({
                 text: rcmail.gettext('deletewithchilds','tasklist'),
                 click: function() {
                     _delete_task(id, 1);
                     $(this).dialog('close');
                 }
             });
         }
         else {
             html = rcmail.gettext('deletetasktconfirm','tasklist');
             buttons.push({
                 text: rcmail.gettext('delete','tasklist'),
                 click: function() {
                     _delete_task(id, 0);
                     $(this).dialog('close');
                 }
             });
         }
 
         buttons.push({
             text: rcmail.gettext('cancel', 'tasklist'),
             click: function() {
                 $(this).dialog('close');
             }
         });
 
         var $dialog = $('<div>').html(html);
         $dialog.dialog({
           modal: true,
           width: 520,
           dialogClass: 'warning',
           title: rcmail.gettext('deletetask', 'tasklist'),
           buttons: buttons,
           close: function(){
               $dialog.dialog('destroy').hide();
           }
         }).addClass('tasklist-confirm').show();
 
         return true;
     }
 
     /**
      * Subfunction to submit the delete command after confirm
      */
     function _delete_task(id, mode)
     {
         var rec = listdata[id],
             li = $('li[rel="'+id+'"]', rcmail.gui_objects.resultlist).hide();
 
         saving_lock = rcmail.set_busy(true, 'tasklist.savingdata');
         rcmail.http_post('task', { action:'delete', t:{ id:rec.id, list:rec.list }, mode:mode, filter:filtermask });
 
         // move childs to parent/root
         if (mode != 1 && rec.children !== undefined) {
             var parent_node = rec.parent_id ? $('li[rel="'+rec.parent_id+'"] > .childtasks', rcmail.gui_objects.resultlist) : null;
             if (!parent_node || !parent_node.length)
                 parent_node = rcmail.gui_objects.resultlist;
 
             $.each(rec.children, function(i,cid) {
                 var child = listdata[cid];
                 child.parent_id = rec.parent_id;
                 resort_task(child, $('li[rel="'+cid+'"]').appendTo(parent_node), true);
             });
         }
 
         li.remove();
         delete listdata[id];
     }
 
     /**
      * Check if the given task matches the current filtermask and tag selection
      */
     function match_filter(rec, cache, recursive)
     {
         // return cached result
         if (typeof cache[rec.id] != 'undefined' && recursive != 2) {
             return cache[rec.id];
         }
 
         var match = !filtermask || (filtermask & rec.mask) > 0;
 
         // in focusview mode, only tasks from the selected list are allowed
         if (focusview && rec.list != focusview)
             match = false;
 
         if (match && tagsfilter.length) {
             match = rec.tags && rec.tags.length;
             var alltags = get_inherited_tags(rec).concat(rec.tags || []);
             for (var i=0; match && i < tagsfilter.length; i++) {
                 if ($.inArray(tagsfilter[i], alltags) < 0)
                     match = false;
             }
         }
 
         // check if a child task matches the tags
         if (!match && (recursive||0) < 2 && rec.children && rec.children.length) {
             for (var j=0; !match && j < rec.children.length; j++) {
                 match = match_filter(listdata[rec.children[j]], cache, 1);
             }
         }
 
         // walk up the task tree and check if a parent task matches
         var parent_id;
         if (!match && !recursive && (parent_id = rec.parent_id)) {
             while (!match && parent_id && listdata[parent_id]) {
                 match = match_filter(listdata[parent_id], cache, 2);
                 parent_id = listdata[parent_id].parent_id;
             }
         }
 
         if (recursive != 1) {
             cache[rec.id] = match;
         }
         return match;
     }
 
     /**
      *
      */
     function get_inherited_tags(rec)
     {
         var parent_id, itags = [];
 
         if ((parent_id = rec.parent_id)) {
             while (parent_id && listdata[parent_id]) {
                 itags = itags.concat(listdata[parent_id].tags || []);
                 parent_id = listdata[parent_id].parent_id;
             }
         }
 
         return $.unqiqueStrings(itags);
     }
 
     /**
      *
      */
     function list_edit_dialog(id)
     {
         var list = me.tasklists[id],
             $dialog = $(rcmail.gui_containers.tasklistform);
 
         if ($dialog.is(':ui-dialog'))
             $dialog.dialog('close');
 
         if (!list)
             list = { name:'', editable:true, showalarms:true };
 
         var editform, name, alarms;
 
         $dialog.html(rcmail.get_label('loading'));
         $.ajax({
             type: 'GET',
             dataType: 'html',
             url: rcmail.url('tasklist'),
             data: { action:(list.id ? 'form-edit' : 'form-new'), l:{ id:list.id } },
             success: function(data) {
                 $dialog.html(data);
                 rcmail.triggerEvent('tasklist_editform_load', list);
 
                 // resize and reposition dialog window
                 editform = $('#tasklisteditform');
                 me.dialog_resize(rcmail.gui_containers.tasklistform, editform.height(), editform.width());
 
                 name = $('#taskedit-tasklistame').prop('disabled', list.norename||false).val(list.editname || list.name);
                 alarms = $('#taskedit-showalarms').prop('checked', list.showalarms).get(0);
                 name.select();
             }
         });
 
         // dialog buttons
         var buttons = {};
 
         buttons[rcmail.gettext('save','tasklist')] = function() {
             // do some input validation
             if (!name.val() || name.val().length < 2) {
                 alert(rcmail.gettext('invalidlistproperties', 'tasklist'));
                 name.select();
                 return;
             }
 
             // post data to server
             var data = editform.serializeJSON();
             if (list.id)
                 data.id = list.id;
             if (alarms)
                 data.showalarms = alarms.checked ? 1 : 0;
 
             saving_lock = rcmail.set_busy(true, 'tasklist.savingdata');
             rcmail.http_post('tasklist', { action:(list.id ? 'edit' : 'new'), l:data });
             $dialog.dialog('close');
         };
 
         buttons[rcmail.gettext('cancel','tasklist')] = function() {
             $dialog.dialog('close');
         };
 
         // open jquery UI dialog
         $dialog.dialog({
             modal: true,
             resizable: true,
             closeOnEscape: false,
             title: rcmail.gettext((list.id ? 'editlist' : 'createlist'), 'tasklist'),
             open: function() {
                 $dialog.parent().find('.ui-dialog-buttonset .ui-button').first().addClass('mainaction');
             },
             close: function() {
                 $dialog.dialog('destroy').hide();
             },
             buttons: buttons,
             minWidth: 400,
             width: 420
         }).show();
     }
 
     /**
      *
      */
     function list_remove(id)
     {
         var list = me.tasklists[id];
         if (list && !list.norename && confirm(rcmail.gettext(list.children ? 'deletelistconfirmrecursive' : 'deletelistconfirm', 'tasklist'))) {
             saving_lock = rcmail.set_busy(true, 'tasklist.savingdata');
             rcmail.http_post('tasklist', { action:'remove', l:{ id:list.id } });
             return true;
         }
         return false;
     }
 
     /**
      * Callback from server to finally remove the given list
      */
     function destroy_list(prop)
     {
         var li, delete_ids = [],
             list = me.tasklists[prop.id];
 
         // find sub-lists
         if (list && list.children) {
             for (var child_id in me.tasklists) {
                 if (String(child_id).indexOf(prop.id) == 0)
                     delete_ids.push(child_id);
             }
         }
         else {
             delete_ids.push(prop.id);
         }
 
         // delete all calendars in the list
         for (var i=0; i < delete_ids.length; i++) {
             id = delete_ids[i];
             list = me.tasklists[id];
             li = rcmail.get_folder_li(id, 'rcmlitasklist');
 
             if (li) {
                 $(li).remove();
             }
             if (list) {
                 list.active = false;
                 // delete me.tasklists[prop.id];
                 unlock_saving();
                 remove_tasks(list.id);
             }
             $("#taskedit-tasklist option[value='"+id+"']").remove();
         }
     }
 
     /**
      *
      */
     function insert_list(prop)
     {
         if (prop._reload) {
             rcmail.redirect(rcmail.url(''));
             return;
         }
 
         var li = $('<li>').attr('id', 'rcmlitasklist'+prop.id)
             .append('<input type="checkbox" name="_list[]" value="'+prop.id+'" checked="checked" />')
             .append('<span class="handle">&nbsp;</span>')
             .append('<span class="listname">'+Q(prop.name)+'</span>');
         $(rcmail.gui_objects.folderlist).append(li);
         me.tasklists[prop.id] = prop;
         init_tasklist_li(li.get(0), prop.id);
 
         // append to list selector in task edit dialog, too (#2985)
         $('<option>').attr('value', prop.id).html(Q(prop.name)).appendTo('#taskedit-tasklist');
     }
 
     /**
      *
      */
     function update_list(prop)
     {
         var id = prop.oldid || prop.id,
             li = rcmail.get_folder_li(id, 'rcmlitasklist');
 
         if (prop._reload) {
             rcmail.redirect(rcmail.url(''));
             return;
         }
 
         if (me.tasklists[id] && li) {
             delete me.tasklists[id];
             me.tasklists[prop.id] = prop;
             $(li).data('id', prop.id)
                 .attr('id', 'rcmlitasklist'+prop.id)
                 .find('input').data('id', prop.id);
             $('.listname', li).html(Q(prop.name));
         }
     }
 
     /**
      * Execute search
      */
     function quicksearch()
     {
         var q;
         if (rcmail.gui_objects.qsearchbox && (q = rcmail.gui_objects.qsearchbox.value)) {
             var id = 'search-'+q;
             var resources = [];
 
             for (var rid in me.tasklists) {
                 if (me.tasklists[rid].active) {
                     resources.push(rid);
                 }
             }
             id += '@'+resources.join(',');
 
             // ignore if query didn't change
             if (search_request == id)
                 return;
 
             search_request = id;
             search_query = q;
 
             list_tasks();
         }
         else  // empty search input equals reset
             this.reset_search();
     }
 
     /**
      * Reset search and get back to normal listing
      */
     function reset_search()
     {
         $(rcmail.gui_objects.qsearchbox).val('');
 
         if (search_request) {
             search_request = search_query = null;
             list_tasks();
         }
     }
 
 
     /**** Utility functions ****/
 
     /**
      * Clear any text selection
      * (text is probably selected when double-clicking somewhere)
      */
     function clearSelection()
     {
         if (document.selection && document.selection.empty) {
             document.selection.empty() ;
         }
         else if (window.getSelection) {
             var sel = window.getSelection();
             if (sel && sel.removeAllRanges)
                 sel.removeAllRanges();
         }
     }
 
     /**
      * Hide all open popup menus
      */
     function clear_popups(e)
     {
         var count = 0, target = e.target;
         if (target && target.className == 'inner')
             target = e.target.parentNode;
 
         $('.popupmenu:visible').each(function(i, elem){
             var menu = $(elem), id = elem.id;
             if (id && target.id != id+'link' && (!menu.data('sticky') || !target_overlaps(e.target, elem))) {
                 menu.hide();
                 count++;
             }
         });
         return count;
     }
 
     /**
      * Check whether the event target is a descentand of the given element
      */
     function target_overlaps(target, elem)
     {
         while (target.parentNode) {
             if (target.parentNode == elem)
                 return true;
             target = target.parentNode;
         }
         return false;
     }
 
     /**
      *
      */
     function active_lists()
     {
         var active = [];
         for (var id in me.tasklists) {
             if (me.tasklists[id].active)
                 active.push(id);
         }
         return active;
     }
 
     // resize and reposition (center) the dialog window
     this.dialog_resize = function(id, height, width)
     {
         var win = $(window), w = win.width(), h = win.height();
             $(id).dialog('option', { height: Math.min(h-20, height+130), width: Math.min(w-20, width+50) })
                 .dialog('option', 'position', ['center', 'center']);  // only works in a separate call (!?)
     };
 
     /**
      * Register event handlers on a tasklist (folder) item
      */
     function init_tasklist_li(li, id)
     {
         $('#'+li.id+' input').click(function(e){
             var id = $(this).data('id');
             if (me.tasklists[id]) {  // add or remove event source on click
                 me.tasklists[id].active = this.checked;
                 fetch_counts();
                 if (!this.checked) remove_tasks(id);
                 else               list_tasks(null);
                 rcmail.http_post('tasklist', { action:'subscribe', l:{ id:id, active:me.tasklists[id].active?1:0 } });
 
                 // disable focusview
                 if (!this.checked && focusview == id) {
                     set_focusview(null);
                 }
             }
         }).data('id', id).get(0).checked = me.tasklists[id].active || false;
 
         $(li).click(function(e){
             var id = $(this).data('id');
             rcmail.select_folder(id, 'rcmlitasklist');
             rcmail.enable_command('list-edit', 'list-remove', 'list-import', me.tasklists[id].editable);
             me.selected_list = id;
 
             // click on handle icon toggles focusview
             if (e.target.className == 'handle') {
                 set_focusview(focusview == id ? null : id)
             }
             // disable focusview when selecting another list
             else if (focusview && id != focusview) {
                 set_focusview(null);
             }
         })
         .dblclick(function(e){
             list_edit_dialog($(this).data('id'));
         })
         .data('id', id)
         .data('type', 'tasklist')
         .addClass(me.tasklists[id].editable ? null : 'readonly');
     }
 
     /**
      * Enable/disable focusview mode for the given list
      */
     function set_focusview(id)
     {
         if (focusview && focusview != id)
             $(rcmail.get_folder_li(focusview, 'rcmlitasklist')).removeClass('focusview');
 
         focusview = id;
 
         // activate list if necessary
         if (focusview && !me.tasklists[id].active) {
             $('input', rcmail.get_folder_li(id, 'rcmlitasklist')).get(0).checked = true;
             me.tasklists[id].active = true;
             fetch_counts();
         }
 
         // update list
         list_tasks(null);
 
         if (focusview) {
             $(rcmail.get_folder_li(focusview, 'rcmlitasklist')).addClass('focusview');
         }
     }
 
 
     // init dialog by default
     init_taskedit();
 }
 
 
 // extend jQuery
 // from http://james.padolsey.com/javascript/sorting-elements-with-jquery/
 jQuery.fn.sortElements = (function(){
     var sort = [].sort;
 
     return function(comparator, getSortable) {
         getSortable = getSortable || function(){ return this };
 
         var last = null;
         return sort.call(this, comparator).each(function(i){
             // at this point the array is sorted, so we can just detach each one from wherever it is, and add it after the last
             var node = $(getSortable.call(this));
             var parent = node.parent();
             if (last) last.after(node);
             else      parent.prepend(node);
             last = node;
         });
     };
 })();
 
 // equivalent to $.unique() but working on arrays of strings
 jQuery.unqiqueStrings = (function() {
     return function(arr) {
         var hash = {}, out = [];
 
         for (var i = 0; i < arr.length; i++) {
             hash[arr[i]] = 0;
         }
         for (var val in hash) {
             out.push(val);
         }
 
         return out;
     };
 })();
 
 
 /* tasklist plugin UI initialization */
 var rctasks;
 window.rcmail && rcmail.addEventListener('init', function(evt) {
 
   rctasks = new rcube_tasklist_ui(rcmail.env.libcal_settings);
 
   // register button commands
   rcmail.register_command('newtask', function(){ rctasks.edit_task(null, 'new', {}); }, true);
   //rcmail.register_command('print', function(){ rctasks.print_list(); }, true);
 
   rcmail.register_command('list-create', function(){ rctasks.list_edit_dialog(null); }, true);
   rcmail.register_command('list-edit', function(){ rctasks.list_edit_dialog(rctasks.selected_list); }, false);
   rcmail.register_command('list-remove', function(){ rctasks.list_remove(rctasks.selected_list); }, false);
 
   rcmail.register_command('search', function(){ rctasks.quicksearch(); }, true);
   rcmail.register_command('reset-search', function(){ rctasks.reset_search(); }, true);
   rcmail.register_command('expand-all', function(){ rctasks.expand_collapse(true); }, true);
   rcmail.register_command('collapse-all', function(){ rctasks.expand_collapse(false); }, true);
 
   rctasks.init();
 });
diff --git a/plugins/tasklist/tasklist.php b/plugins/tasklist/tasklist.php
index 65376d7c..d8ba4d04 100644
--- a/plugins/tasklist/tasklist.php
+++ b/plugins/tasklist/tasklist.php
@@ -1,1097 +1,1098 @@
 <?php
 
 /**
  * Tasks plugin for Roundcube webmail
  *
  * @version @package_version@
  * @author Thomas Bruederli <bruederli@kolabsys.com>
  *
  * Copyright (C) 2012, Kolab Systems AG <contact@kolabsys.com>
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU Affero General Public License as
  * published by the Free Software Foundation, either version 3 of the
  * License, or (at your option) any later version.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  * GNU Affero General Public License for more details.
  *
  * You should have received a copy of the GNU Affero General Public License
  * along with this program. If not, see <http://www.gnu.org/licenses/>.
  */
 
 class tasklist extends rcube_plugin
 {
     const FILTER_MASK_TODAY = 1;
     const FILTER_MASK_TOMORROW = 2;
     const FILTER_MASK_WEEK = 4;
     const FILTER_MASK_LATER = 8;
     const FILTER_MASK_NODATE = 16;
     const FILTER_MASK_OVERDUE = 32;
     const FILTER_MASK_FLAGGED = 64;
     const FILTER_MASK_COMPLETE = 128;
 
     const SESSION_KEY = 'tasklist_temp';
 
     public static $filter_masks = array(
         'today'    => self::FILTER_MASK_TODAY,
         'tomorrow' => self::FILTER_MASK_TOMORROW,
         'week'     => self::FILTER_MASK_WEEK,
         'later'    => self::FILTER_MASK_LATER,
         'nodate'   => self::FILTER_MASK_NODATE,
         'overdue'  => self::FILTER_MASK_OVERDUE,
         'flagged'  => self::FILTER_MASK_FLAGGED,
         'complete' => self::FILTER_MASK_COMPLETE,
     );
 
     public $task = '?(?!login|logout).*';
     public $rc;
     public $lib;
     public $driver;
     public $timezone;
     public $ui;
 
     private $collapsed_tasks = array();
 
 
     /**
      * Plugin initialization.
      */
     function init()
     {
         $this->require_plugin('libcalendaring');
 
         $this->rc = rcube::get_instance();
         $this->lib = libcalendaring::get_instance();
 
         $this->register_task('tasks', 'tasklist');
 
         // load plugin configuration
         $this->load_config();
 
         $this->timezone = $this->lib->timezone;
 
         // proceed initialization in startup hook
         $this->add_hook('startup', array($this, 'startup'));
 
         $this->add_hook('user_delete', array($this, 'user_delete'));
     }
 
     /**
      * Startup hook
      */
     public function startup($args)
     {
         // the tasks module can be enabled/disabled by the kolab_auth plugin
         if ($this->rc->config->get('tasklist_disabled', false) || !$this->rc->config->get('tasklist_enabled', true))
             return;
 
         // load localizations
         $this->add_texts('localization/', $args['task'] == 'tasks' && (!$args['action'] || $args['action'] == 'print'));
         $this->rc->load_language($_SESSION['language'], array('tasks.tasks' => $this->gettext('navtitle')));  // add label for task title
 
         if ($args['task'] == 'tasks' && $args['action'] != 'save-pref') {
             $this->load_driver();
 
             // register calendar actions
             $this->register_action('index', array($this, 'tasklist_view'));
             $this->register_action('task', array($this, 'task_action'));
             $this->register_action('tasklist', array($this, 'tasklist_action'));
             $this->register_action('counts', array($this, 'fetch_counts'));
             $this->register_action('fetch', array($this, 'fetch_tasks'));
             $this->register_action('inlineui', array($this, 'get_inline_ui'));
             $this->register_action('mail2task', array($this, 'mail_message2task'));
             $this->register_action('get-attachment', array($this, 'attachment_get'));
             $this->register_action('upload', array($this, 'attachment_upload'));
             $this->add_hook('refresh', array($this, 'refresh'));
 
             $this->collapsed_tasks = array_filter(explode(',', $this->rc->config->get('tasklist_collapsed_tasks', '')));
         }
         else if ($args['task'] == 'mail') {
             // TODO: register hooks to catch ical/vtodo email attachments
             if ($args['action'] == 'show' || $args['action'] == 'preview') {
                 // $this->add_hook('message_load', array($this, 'mail_message_load'));
                 // $this->add_hook('template_object_messagebody', array($this, 'mail_messagebody_html'));
             }
 
             // add 'Create event' item to message menu
             if ($this->api->output->type == 'html') {
                 $this->api->add_content(html::tag('li', null, 
                     $this->api->output->button(array(
                         'command'  => 'tasklist-create-from-mail',
                         'label'    => 'tasklist.createfrommail',
                         'type'     => 'link',
                         'classact' => 'icon taskaddlink active',
                         'class'    => 'icon taskaddlink',
                         'innerclass' => 'icon taskadd',
                     ))),
                 'messagemenu');
 
                 $this->api->output->add_label('tasklist.createfrommail');
             }
         }
 
         if (!$this->rc->output->ajax_call && !$this->rc->output->env['framed']) {
             require_once($this->home . '/tasklist_ui.php');
             $this->ui = new tasklist_ui($this);
             $this->ui->init();
         }
 
         // add hooks for alarms handling
         $this->add_hook('pending_alarms', array($this, 'pending_alarms'));
         $this->add_hook('dismiss_alarms', array($this, 'dismiss_alarms'));
     }
 
 
     /**
      * Helper method to load the backend driver according to local config
      */
     private function load_driver()
     {
         if (is_object($this->driver))
             return;
 
         $driver_name = $this->rc->config->get('tasklist_driver', 'database');
         $driver_class = 'tasklist_' . $driver_name . '_driver';
 
         require_once($this->home . '/drivers/tasklist_driver.php');
         require_once($this->home . '/drivers/' . $driver_name . '/' . $driver_class . '.php');
 
         switch ($driver_name) {
         case "kolab":
             $this->require_plugin('libkolab');
         default:
             $this->driver = new $driver_class($this);
             break;
         }
 
         $this->rc->output->set_env('tasklist_driver', $driver_name);
     }
 
 
     /**
      * Dispatcher for task-related actions initiated by the client
      */
     public function task_action()
     {
         $filter = intval(get_input_value('filter', RCUBE_INPUT_GPC));
         $action = get_input_value('action', RCUBE_INPUT_GPC);
         $rec  = get_input_value('t', RCUBE_INPUT_POST, true);
         $oldrec = $rec;
         $success = $refresh = false;
 
         switch ($action) {
         case 'new':
             $oldrec = null;
             $rec = $this->prepare_task($rec);
             $rec['uid'] = $this->generate_uid();
             $temp_id = $rec['tempid'];
             if ($success = $this->driver->create_task($rec)) {
                 $refresh = $this->driver->get_task($rec);
                 if ($temp_id) $refresh['tempid'] = $temp_id;
                 $this->cleanup_task($rec);
             }
             break;
 
         case 'edit':
             $rec = $this->prepare_task($rec);
             $clone = $this->handle_recurrence($rec, $this->driver->get_task($rec));
             if ($success = $this->driver->edit_task($rec)) {
                 $refresh[] = $this->driver->get_task($rec);
                 $this->cleanup_task($rec);
 
                 // add clone from recurring task
                 if ($clone && $this->driver->create_task($clone)) {
                     $refresh[] = $this->driver->get_task($clone);
                     $this->driver->clear_alarms($rec['id']);
                 }
 
                 // move all childs if list assignment was changed
                 if (!empty($rec['_fromlist']) && !empty($rec['list']) && $rec['_fromlist'] != $rec['list']) {
                     foreach ($this->driver->get_childs(array('id' => $rec['id'], 'list' => $rec['_fromlist']), true) as $cid) {
                         $child = array('id' => $cid, 'list' => $rec['list'], '_fromlist' => $rec['_fromlist']);
                         if ($this->driver->move_task($child)) {
                             $r = $this->driver->get_task($child);
-                            if ((bool)($filter & self::FILTER_MASK_COMPLETE) == ($r['complete'] == 1.0)) {
+                            if ((bool)($filter & self::FILTER_MASK_COMPLETE) == $this->driver->is_complete($r)) {
                                 $refresh[] = $r;
                             }
                         }
                     }
                 }
             }
             break;
 
           case 'move':
               foreach ((array)$rec['id'] as $id) {
                   $r = $rec;
                   $r['id'] = $id;
                   if ($this->driver->move_task($r)) {
                       $refresh[] = $this->driver->get_task($r);
                       $success = true;
 
                       // move all childs, too
                       foreach ($this->driver->get_childs(array('id' => $rec['id'], 'list' => $rec['_fromlist']), true) as $cid) {
                           $child = $rec;
                           $child['id'] = $cid;
                           if ($this->driver->move_task($child)) {
                               $r = $this->driver->get_task($child);
-                              if ((bool)($filter & self::FILTER_MASK_COMPLETE) == ($r['complete'] == 1.0)) {
+                              if ((bool)($filter & self::FILTER_MASK_COMPLETE) == $this->driver->is_complete($r)) {
                                   $refresh[] = $r;
                               }
                           }
                       }
                   }
               }
               break;
 
         case 'delete':
             $mode  = intval(get_input_value('mode', RCUBE_INPUT_POST));
             $oldrec = $this->driver->get_task($rec);
             if ($success = $this->driver->delete_task($rec, false)) {
                 // delete/modify all childs
                 foreach ($this->driver->get_childs($rec, $mode) as $cid) {
                     $child = array('id' => $cid, 'list' => $rec['list']);
 
                     if ($mode == 1) {  // delete all childs
                         if ($this->driver->delete_task($child, false)) {
                             if ($this->driver->undelete)
                                 $_SESSION['tasklist_undelete'][$rec['id']][] = $cid;
                         }
                         else
                             $success = false;
                     }
                     else {
                         $child['parent_id'] = strval($oldrec['parent_id']);
                         $this->driver->edit_task($child);
                     }
                 }
                 // update parent task to adjust list of children
                 if (!empty($oldrec['parent_id'])) {
                     $refresh[] = $this->driver->get_task(array('id' => $oldrec['parent_id'], 'list' => $rec['list']));
                 }
             }
 
             if (!$success)
                 $this->rc->output->command('plugin.reload_data');
             break;
 
         case 'undelete':
             if ($success = $this->driver->undelete_task($rec)) {
                 $refresh[] = $this->driver->get_task($rec);
                 foreach ((array)$_SESSION['tasklist_undelete'][$rec['id']] as $cid) {
                     if ($this->driver->undelete_task($rec)) {
                         $refresh[] = $this->driver->get_task($rec);
                     }
                 }
             }
             break;
 
         case 'collapse':
             foreach (explode(',', $rec['id']) as $rec_id) {
                 if (intval(get_input_value('collapsed', RCUBE_INPUT_GPC))) {
                     $this->collapsed_tasks[] = $rec_id;
                 }
                 else {
                     $i = array_search($rec_id, $this->collapsed_tasks);
                     if ($i !== false)
                         unset($this->collapsed_tasks[$i]);
                 }
             }
 
             $this->rc->user->save_prefs(array('tasklist_collapsed_tasks' => join(',', array_unique($this->collapsed_tasks))));
             return;  // avoid further actions
         }
 
         if ($success) {
             $this->rc->output->show_message('successfullysaved', 'confirmation');
             $this->update_counts($oldrec, $refresh);
         }
         else
             $this->rc->output->show_message('tasklist.errorsaving', 'error');
 
         // unlock client
         $this->rc->output->command('plugin.unlock_saving');
 
         if ($refresh) {
             if ($refresh['id']) {
                 $this->encode_task($refresh);
             }
             else if (is_array($refresh)) {
                 foreach ($refresh as $i => $r)
                     $this->encode_task($refresh[$i]);
             }
             $this->rc->output->command('plugin.update_task', $refresh);
         }
     }
 
     /**
      * repares new/edited task properties before save
      */
     private function prepare_task($rec)
     {
         // try to be smart and extract date from raw input
         if ($rec['raw']) {
             foreach (array('today','tomorrow','sunday','monday','tuesday','wednesday','thursday','friday','saturday','sun','mon','tue','wed','thu','fri','sat') as $word) {
                 $locwords[] = '/^' . preg_quote(mb_strtolower($this->gettext($word))) . '\b/i';
                 $normwords[] = $word;
                 $datewords[] = $word;
             }
             foreach (array('jan','feb','mar','apr','may','jun','jul','aug','sep','oct','now','dec') as $month) {
                 $locwords[] = '/(' . preg_quote(mb_strtolower($this->gettext('long'.$month))) . '|' . preg_quote(mb_strtolower($this->gettext($month))) . ')\b/i';
                 $normwords[] = $month;
                 $datewords[] = $month;
             }
             foreach (array('on','this','next','at') as $word) {
                 $fillwords[] = preg_quote(mb_strtolower($this->gettext($word)));
                 $fillwords[] = $word;
             }
 
             $raw = trim($rec['raw']);
             $date_str = '';
 
             // translate localized keywords
             $raw = preg_replace('/^(' . join('|', $fillwords) . ')\s*/i', '', $raw);
             $raw = preg_replace($locwords, $normwords, $raw);
 
             // find date pattern
             $date_pattern = '!^(\d+[./-]\s*)?((?:\d+[./-])|' . join('|', $datewords) . ')\.?(\s+\d{4})?[:;,]?\s+!i';
             if (preg_match($date_pattern, $raw, $m)) {
                 $date_str .= $m[1] . $m[2] . $m[3];
                 $raw = preg_replace(array($date_pattern, '/^(' . join('|', $fillwords) . ')\s*/i'), '', $raw);
                 // add year to date string
                 if ($m[1] && !$m[3])
                     $date_str .= date('Y');
             }
 
             // find time pattern
             $time_pattern = '/^(\d+([:.]\d+)?(\s*[hapm.]+)?),?\s+/i';
             if (preg_match($time_pattern, $raw, $m)) {
                 $has_time = true;
                 $date_str .= ($date_str ? ' ' : 'today ') . $m[1];
                 $raw = preg_replace($time_pattern, '', $raw);
             }
 
             // yes, raw input matched a (valid) date
             if (strlen($date_str) && strtotime($date_str) && ($date = new DateTime($date_str, $this->timezone))) {
                 $rec['date'] = $date->format('Y-m-d');
                 if ($has_time)
                     $rec['time'] = $date->format('H:i');
                 $rec['title'] = $raw;
             }
             else
                 $rec['title'] = $rec['raw'];
         }
 
         // normalize input from client
         if (isset($rec['complete'])) {
             $rec['complete'] = floatval($rec['complete']);
             if ($rec['complete'] > 1)
                 $rec['complete'] /= 100;
         }
         if (isset($rec['flagged']))
             $rec['flagged'] = intval($rec['flagged']);
 
         // fix for garbage input
         if ($rec['description'] == 'null')
             $rec['description'] = '';
 
         foreach ($rec as $key => $val) {
             if ($val === 'null')
                 $rec[$key] = null;
         }
 
         if (!empty($rec['date'])) {
             $this->normalize_dates($rec, 'date', 'time');
         }
 
         if (!empty($rec['startdate'])) {
             $this->normalize_dates($rec, 'startdate', 'starttime');
         }
 
         // convert tags to array, filter out empty entries
         if (isset($rec['tags']) && !is_array($rec['tags'])) {
             $rec['tags'] = array_filter((array)$rec['tags']);
         }
 
         // convert the submitted alarm values
         if ($rec['valarms']) {
             $valarms = array();
             foreach (libcalendaring::from_client_alarms($rec['valarms']) as $alarm) {
                 // alarms can only work with a date (either task start, due or absolute alarm date)
                 if (is_a($alarm['trigger'], 'DateTime') || $rec['date'] || $rec['startdate'])
                     $valarms[] = $alarm;
             }
             $rec['valarms'] = $valarms;
         }
 
         // convert the submitted recurrence settings
         if (is_array($rec['recurrence'])) {
             $refdate = null;
             if (!empty($rec['date'])) {
                 $refdate = new DateTime($rec['date'] . ' ' . $rec['time'], $this->timezone);
             }
             else if (!empty($rec['startdate'])) {
                 $refdate = new DateTime($rec['startdate'] . ' ' . $rec['starttime'], $this->timezone);
             }
 
             if ($refdate) {
                 $rec['recurrence'] = $this->lib->from_client_recurrence($rec['recurrence'], $refdate);
 
                 // translate count into an absolute end date.
                 // why? because when shifting completed tasks to the next recurrence,
                 // the initial start date to count from gets lost.
                 if ($rec['recurrence']['COUNT']) {
                     $engine = libcalendaring::get_recurrence();
                     $engine->init($rec['recurrence'], $refdate);
                     if ($until = $engine->end()) {
                         $rec['recurrence']['UNTIL'] = $until;
                         unset($rec['recurrence']['COUNT']);
                     }
                 }
             }
             else {  // recurrence requires a reference date
                 $rec['recurrence'] = '';
             }
         }
 
         $attachments = array();
         $taskid = $rec['id'];
         if (is_array($_SESSION[self::SESSION_KEY]) && $_SESSION[self::SESSION_KEY]['id'] == $taskid) {
             if (!empty($_SESSION[self::SESSION_KEY]['attachments'])) {
                 foreach ($_SESSION[self::SESSION_KEY]['attachments'] as $id => $attachment) {
                     if (is_array($rec['attachments']) && in_array($id, $rec['attachments'])) {
                         $attachments[$id] = $this->rc->plugins->exec_hook('attachment_get', $attachment);
                         unset($attachments[$id]['abort'], $attachments[$id]['group']);
                     }
                 }
             }
         }
 
         $rec['attachments'] = $attachments;
 
         if (is_numeric($rec['id']) && $rec['id'] < 0)
             unset($rec['id']);
 
         return $rec;
     }
 
     /**
      * Utility method to convert a tasks date/time values into a normalized format
      */
     private function normalize_dates(&$rec, $date_key, $time_key)
     {
         try {
             // parse date from user format (#2801)
             $date_format = $this->rc->config->get(empty($rec[$time_key]) ? 'date_format' : 'date_long', 'Y-m-d');
             $date = DateTime::createFromFormat($date_format, trim($rec[$date_key] . ' ' . $rec[$time_key]), $this->timezone);
 
             // fall back to default strtotime logic
             if (empty($date)) {
                 $date = new DateTime($rec[$date_key] . ' ' . $rec[$time_key], $this->timezone);
             }
 
             $rec[$date_key] = $date->format('Y-m-d');
             if (!empty($rec[$time_key]))
                 $rec[$time_key] = $date->format('H:i');
 
             return true;
         }
         catch (Exception $e) {
             $rec[$date_key] = $rec[$time_key] = null;
         }
 
         return false;
     }
 
     /**
      * Releases some resources after successful save
      */
     private function cleanup_task(&$rec)
     {
         // remove temp. attachment files
         if (!empty($_SESSION[self::SESSION_KEY]) && ($taskid = $_SESSION[self::SESSION_KEY]['id'])) {
             $this->rc->plugins->exec_hook('attachments_cleanup', array('group' => $taskid));
             $this->rc->session->remove(self::SESSION_KEY);
         }
     }
 
     /**
      * When flagging a recurring task as complete,
      * clone it and shift dates to the next occurrence
      */
     private function handle_recurrence(&$rec, $old)
     {
         $clone = null;
-        if ($rec['complete'] == 1.0 && $old && $old['complete'] < 1.0 && is_array($rec['recurrence'])) {
+        if ($this->driver->is_complete($rec) && $old && $this->driver->is_complete($old) && is_array($rec['recurrence'])) {
             $engine = libcalendaring::get_recurrence();
             $rrule = $rec['recurrence'];
             $updates = array();
 
             // compute the next occurrence of date attributes
             foreach (array('date'=>'time', 'startdate'=>'starttime') as $date_key => $time_key) {
                 if (empty($rec[$date_key]))
                     continue;
 
                 $date = new DateTime($rec[$date_key] . ' ' . $rec[$time_key], $this->timezone);
                 $engine->init($rrule, $date);
                 if ($next = $engine->next()) {
                     $updates[$date_key] = $next->format('Y-m-d');
                     if (!empty($rec[$time_key]))
                         $updates[$time_key] = $next->format('H:i');
                 }
             }
 
             // shift absolute alarm dates
             if (!empty($updates) && is_array($rec['valarms'])) {
                 $updates['valarms'] = array();
                 unset($rrule['UNTIL'], $rrule['COUNT']);  // make recurrence rule unlimited
 
                 foreach ($rec['valarms'] as $i => $alarm) {
                     if ($alarm['trigger'] instanceof DateTime) {
                         $engine->init($rrule, $alarm['trigger']);
                         if ($next = $engine->next()) {
                             $alarm['trigger'] = $next;
                         }
                     }
                     $updates['valarms'][$i] = $alarm;
                 }
             }
 
             if (!empty($updates)) {
                 // clone task to save a completed copy
                 $clone = $rec;
                 $clone['uid'] = $this->generate_uid();
                 $clone['parent_id'] = $rec['id'];
                 unset($clone['id'], $clone['recurrence'], $clone['attachments']);
 
                 // update the task but unset completed flag
                 $rec = array_merge($rec, $updates);
                 $rec['complete'] = $old['complete'];
+                $rec['satus'] = $old['satus'];
             }
         }
 
         return $clone;
     }
 
     /**
      * Dispatcher for tasklist actions initiated by the client
      */
     public function tasklist_action()
     {
         $action = get_input_value('action', RCUBE_INPUT_GPC);
         $list  = get_input_value('l', RCUBE_INPUT_GPC, true);
         $success = false;
 
         if (isset($list['showalarms']))
           $list['showalarms'] = intval($list['showalarms']);
 
         switch ($action) {
         case 'form-new':
         case 'form-edit':
             echo $this->ui->tasklist_editform($action, $list);
             exit;
 
         case 'new':
             $list += array('showalarms' => true, 'active' => true, 'editable' => true);
             if ($insert_id = $this->driver->create_list($list)) {
                 $list['id'] = $insert_id;
                 $this->rc->output->command('plugin.insert_tasklist', $list);
                 $success = true;
             }
             break;
 
         case 'edit':
             if ($newid = $this->driver->edit_list($list)) {
                 $list['oldid'] = $list['id'];
                 $list['id'] = $newid;
                 $this->rc->output->command('plugin.update_tasklist', $list);
                 $success = true;
             }
             break;
 
         case 'subscribe':
             $success = $this->driver->subscribe_list($list);
             break;
 
         case 'remove':
             if (($success = $this->driver->remove_list($list)))
                 $this->rc->output->command('plugin.destroy_tasklist', $list);
             break;
         }
 
         if ($success)
             $this->rc->output->show_message('successfullysaved', 'confirmation');
         else
             $this->rc->output->show_message('tasklist.errorsaving', 'error');
 
         $this->rc->output->command('plugin.unlock_saving');
     }
 
     /**
      * Get counts for active tasks divided into different selectors
      */
     public function fetch_counts()
     {
         if (isset($_REQUEST['lists'])) {
             $lists = get_input_value('lists', RCUBE_INPUT_GPC);
         }
         else {
             foreach ($this->driver->get_lists() as $list) {
                 if ($list['active'])
                     $lists[] = $list['id'];
             }
         }
         $counts = $this->driver->count_tasks($lists);
         $this->rc->output->command('plugin.update_counts', $counts);
     }
 
     /**
      * Adjust the cached counts after changing a task
      */
     public function update_counts($oldrec, $newrec)
     {
         // rebuild counts until this function is finally implemented
         $this->fetch_counts();
 
         // $this->rc->output->command('plugin.update_counts', $counts);
     }
 
     /**
      *
      */
     public function fetch_tasks()
     {
         $f = intval(get_input_value('filter', RCUBE_INPUT_GPC));
         $search = get_input_value('q', RCUBE_INPUT_GPC);
         $filter = array('mask' => $f, 'search' => $search);
         $lists = get_input_value('lists', RCUBE_INPUT_GPC);;
 /*
         // convert magic date filters into a real date range
         switch ($f) {
         case self::FILTER_MASK_TODAY:
             $today = new DateTime('now', $this->timezone);
             $filter['from'] = $filter['to'] = $today->format('Y-m-d');
             break;
 
         case self::FILTER_MASK_TOMORROW:
             $tomorrow = new DateTime('now + 1 day', $this->timezone);
             $filter['from'] = $filter['to'] = $tomorrow->format('Y-m-d');
             break;
 
         case self::FILTER_MASK_OVERDUE:
             $yesterday = new DateTime('yesterday', $this->timezone);
             $filter['to'] = $yesterday->format('Y-m-d');
             break;
 
         case self::FILTER_MASK_WEEK:
             $today = new DateTime('now', $this->timezone);
             $filter['from'] = $today->format('Y-m-d');
             $weekend = new DateTime('now + 7 days', $this->timezone);
             $filter['to'] = $weekend->format('Y-m-d');
             break;
 
         case self::FILTER_MASK_LATER:
             $date = new DateTime('now + 8 days', $this->timezone);
             $filter['from'] = $date->format('Y-m-d');
             break;
 
         }
 */
         $data = $this->tasks_data($this->driver->list_tasks($filter, $lists), $f, $tags);
         $this->rc->output->command('plugin.data_ready', array('filter' => $f, 'lists' => $lists, 'search' => $search, 'data' => $data, 'tags' => array_values(array_unique($tags))));
     }
 
     /**
      * Prepare and sort the given task records to be sent to the client
      */
     private function tasks_data($records, $f, &$tags)
     {
         $data = $tags = $this->task_tree = $this->task_titles = array();
         foreach ($records as $rec) {
             if ($rec['parent_id']) {
                 $this->task_tree[$rec['id']] = $rec['parent_id'];
             }
             $this->encode_task($rec);
             if (!empty($rec['tags']))
                 $tags = array_merge($tags, (array)$rec['tags']);
 
             // apply filter; don't trust the driver on this :-)
-            if ((!$f && $rec['complete'] < 1.0) || ($rec['mask'] & $f))
+            if ((!$f && !$this->driver->is_complete($rec)) || ($rec['mask'] & $f))
                 $data[] = $rec;
         }
 
         // sort tasks according to their hierarchy level and due date
         array_walk($data, array($this, 'task_walk_tree'));
         usort($data, array($this, 'task_sort_cmp'));
 
         return $data;
     }
 
     /**
      * Prepare the given task record before sending it to the client
      */
     private function encode_task(&$rec)
     {
         $rec['mask'] = $this->filter_mask($rec);
         $rec['flagged'] = intval($rec['flagged']);
         $rec['complete'] = floatval($rec['complete']);
         $rec['changed'] = is_object($rec['changed']) ? $rec['changed']->format('U') : null;
 
         if ($rec['date']) {
             try {
                 $date = new DateTime($rec['date'] . ' ' . $rec['time'], $this->timezone);
                 $rec['datetime'] = intval($date->format('U'));
                 $rec['date'] = $date->format($this->rc->config->get('date_format', 'Y-m-d'));
                 $rec['_hasdate'] = 1;
             }
             catch (Exception $e) {
                 $rec['date'] = $rec['datetime'] = null;
             }
         }
         else {
             $rec['date'] = $rec['datetime'] = null;
             $rec['_hasdate'] = 0;
         }
 
         if ($rec['startdate']) {
             try {
                 $date = new DateTime($rec['startdate'] . ' ' . $rec['starttime'], $this->timezone);
                 $rec['startdatetime'] = intval($date->format('U'));
                 $rec['startdate'] = $date->format($this->rc->config->get('date_format', 'Y-m-d'));
             }
             catch (Exception $e) {
                 $rec['startdate'] = $rec['startdatetime'] = null;
             }
         }
 
         if ($rec['valarms']) {
             $rec['alarms_text'] = libcalendaring::alarms_text($rec['valarms']);
             $rec['valarms'] = libcalendaring::to_client_alarms($rec['valarms']);
         }
 
         if ($rec['recurrence']) {
             $rec['recurrence_text'] = $this->lib->recurrence_text($rec['recurrence']);
             $rec['recurrence'] = $this->lib->to_client_recurrence($rec['recurrence'], $rec['time'] || $rec['starttime']);
         }
 
         foreach ((array)$rec['attachments'] as $k => $attachment) {
             $rec['attachments'][$k]['classname'] = rcube_utils::file2class($attachment['mimetype'], $attachment['name']);
         }
 
         if (!is_array($rec['tags']))
             $rec['tags'] = (array)$rec['tags'];
         sort($rec['tags'], SORT_LOCALE_STRING);
 
         if (in_array($rec['id'], $this->collapsed_tasks))
           $rec['collapsed'] = true;
 
         if (empty($rec['parent_id']))
             $rec['parent_id'] = null;
 
         $this->task_titles[$rec['id']] = $rec['title'];
     }
 
     /**
      * Callback function for array_walk over all tasks.
      * Sets tree depth and parent titles
      */
     private function task_walk_tree(&$rec)
     {
         $rec['_depth'] = 0;
         $parent_id = $this->task_tree[$rec['id']];
         while ($parent_id) {
             $rec['_depth']++;
             $rec['parent_title'] = $this->task_titles[$parent_id];
             $parent_id = $this->task_tree[$parent_id];
         }
     }
 
     /**
      * Compare function for task list sorting.
      * Nested tasks need to be sorted to the end.
      */
     private function task_sort_cmp($a, $b)
     {
         $d = $a['_depth'] - $b['_depth'];
         if (!$d) $d = $b['_hasdate'] - $a['_hasdate'];
         if (!$d) $d = $a['datetime'] - $b['datetime'];
         return $d;
     }
 
     /**
      * Compute the filter mask of the given task
      *
      * @param array Hash array with Task record properties
      * @return int Filter mask
      */
     public function filter_mask($rec)
     {
         static $today, $tomorrow, $weeklimit;
 
         if (!$today) {
             $today_date = new DateTime('now', $this->timezone);
             $today = $today_date->format('Y-m-d');
             $tomorrow_date = new DateTime('now + 1 day', $this->timezone);
             $tomorrow = $tomorrow_date->format('Y-m-d');
             $week_date = new DateTime('now + 7 days', $this->timezone);
             $weeklimit = $week_date->format('Y-m-d');
         }
 
         $mask = 0;
         $start = $rec['startdate'] ?: '1900-00-00';
         $duedate = $rec['date'] ?: '3000-00-00';
 
         if ($rec['flagged'])
             $mask |= self::FILTER_MASK_FLAGGED;
-        if ($rec['complete'] == 1.0)
+        if ($this->driver->is_complete($rec))
             $mask |= self::FILTER_MASK_COMPLETE;
 
         if (empty($rec['date']))
             $mask |= self::FILTER_MASK_NODATE;
         else if ($rec['date'] < $today)
             $mask |= self::FILTER_MASK_OVERDUE;
 
         if ($duedate <= $today || ($rec['startdate'] && $start <= $today))
             $mask |= self::FILTER_MASK_TODAY;
         if ($duedate <= $tomorrow || ($rec['startdate'] && $start <= $tomorrow))
             $mask |= self::FILTER_MASK_TOMORROW;
         if (($start > $tomorrow && $start <= $weeklimit) || ($duedate > $tomorrow && $duedate <= $weeklimit))
             $mask |= self::FILTER_MASK_WEEK;
         else if ($start > $weeklimit || ($rec['date'] && $duedate > $weeklimit))
             $mask |= self::FILTER_MASK_LATER;
 
         return $mask;
     }
 
 
     /*******  UI functions  ********/
 
     /**
      * Render main view of the tasklist task
      */
     public function tasklist_view()
     {
         $this->ui->init();
         $this->ui->init_templates();
         $this->rc->output->set_pagetitle($this->gettext('navtitle'));
         $this->rc->output->send('tasklist.mainview');
     }
 
 
     /**
      *
      */
     public function get_inline_ui()
     {
         foreach (array('save','cancel','savingdata') as $label)
             $texts['tasklist.'.$label] = $this->gettext($label);
 
         $texts['tasklist.newtask'] = $this->gettext('createfrommail');
 
         $this->ui->init_templates();
         echo $this->api->output->parse('tasklist.taskedit', false, false);
         echo html::tag('link', array('rel' => 'stylesheet', 'type' => 'text/css', 'href' => $this->url($this->local_skin_path() . '/tagedit.css'), 'nl' => true));
         echo html::tag('script', array('type' => 'text/javascript'),
             "rcmail.set_env('tasklists', " . json_encode($this->api->output->env['tasklists']) . ");\n".
             "rcmail.add_label(" . json_encode($texts) . ");\n"
         );
         exit;
     }
 
     /**
      * Handler for keep-alive requests
      * This will check for updated data in active lists and sync them to the client
      */
     public function refresh($attr)
     {
         // refresh the entire list every 10th time to also sync deleted items
         if (rand(0,10) == 10) {
             $this->rc->output->command('plugin.reload_data');
             return;
         }
 
         $filter = array(
             'since'  => $attr['last'],
             'search' => get_input_value('q', RCUBE_INPUT_GPC),
             'mask'   => intval(get_input_value('filter', RCUBE_INPUT_GPC)) & self::FILTER_MASK_COMPLETE,
         );
         $lists = get_input_value('lists', RCUBE_INPUT_GPC);;
 
         $updates = $this->driver->list_tasks($filter, $lists);
         if (!empty($updates)) {
             $this->rc->output->command('plugin.refresh_tasks', $this->tasks_data($updates, 255, $tags), true);
 
             // update counts
             $counts = $this->driver->count_tasks($lists);
             $this->rc->output->command('plugin.update_counts', $counts);
         }
     }
 
     /**
      * Handler for pending_alarms plugin hook triggered by the calendar module on keep-alive requests.
      * This will check for pending notifications and pass them to the client
      */
     public function pending_alarms($p)
     {
         $this->load_driver();
         if ($alarms = $this->driver->pending_alarms($p['time'] ?: time())) {
             foreach ($alarms as $alarm) {
                 // encode alarm object to suit the expectations of the calendaring code
                 if ($alarm['date'])
                     $alarm['start'] = new DateTime($alarm['date'].' '.$alarm['time'], $this->timezone);
 
                 $alarm['id'] = 'task:' . $alarm['id'];  // prefix ID with task:
                 $alarm['allday'] = empty($alarm['time']) ? 1 : 0;
                 $p['alarms'][] = $alarm;
             }
         }
 
         return $p;
     }
 
     /**
      * Handler for alarm dismiss hook triggered by the calendar module
      */
     public function dismiss_alarms($p)
     {
         $this->load_driver();
         foreach ((array)$p['ids'] as $id) {
             if (strpos($id, 'task:') === 0)
                 $p['success'] |= $this->driver->dismiss_alarm(substr($id, 5), $p['snooze']);
         }
 
         return $p;
     }
 
 
     /******* Attachment handling  *******/
 
     /**
      * Handler for attachments upload
     */
     public function attachment_upload()
     {
         $this->lib->attachment_upload(self::SESSION_KEY);
     }
 
     /**
      * Handler for attachments download/displaying
      */
     public function attachment_get()
     {
         // show loading page
         if (!empty($_GET['_preload'])) {
             return $this->lib->attachment_loading_page();
         }
 
         $task = get_input_value('_t', RCUBE_INPUT_GPC);
         $list = get_input_value('_list', RCUBE_INPUT_GPC);
         $id   = get_input_value('_id', RCUBE_INPUT_GPC);
 
         $task = array('id' => $task, 'list' => $list);
         $attachment = $this->driver->get_attachment($id, $task);
 
         // show part page
         if (!empty($_GET['_frame'])) {
             $this->lib->attachment = $attachment;
             $this->register_handler('plugin.attachmentframe', array($this->lib, 'attachment_frame'));
             $this->register_handler('plugin.attachmentcontrols', array($this->lib, 'attachment_header'));
             $this->rc->output->send('tasklist.attachment');
         }
         // deliver attachment content
         else if ($attachment) {
             $attachment['body'] = $this->driver->get_attachment_body($id, $task);
             $this->lib->attachment_get($attachment);
         }
 
         // if we arrive here, the requested part was not found
         header('HTTP/1.1 404 Not Found');
         exit;
     }
 
 
     /*******  Email related function *******/
 
     public function mail_message2task()
     {
         $uid = get_input_value('_uid', RCUBE_INPUT_POST);
         $mbox = get_input_value('_mbox', RCUBE_INPUT_POST);
         $task = array();
 
         // establish imap connection
         $imap = $this->rc->get_storage();
         $imap->set_mailbox($mbox);
         $message = new rcube_message($uid);
 
         if ($message->headers) {
             $task['title'] = trim($message->subject);
             $task['description'] = trim($message->first_text_part());
             $task['id'] = -$uid;
 
             $this->load_driver();
 
             // copy mail attachments to task
             if ($message->attachments && $this->driver->attachments) {
                 if (!is_array($_SESSION[self::SESSION_KEY]) || $_SESSION[self::SESSION_KEY]['id'] != $task['id']) {
                     $_SESSION[self::SESSION_KEY] = array();
                     $_SESSION[self::SESSION_KEY]['id'] = $task['id'];
                     $_SESSION[self::SESSION_KEY]['attachments'] = array();
                 }
 
                 foreach ((array)$message->attachments as $part) {
                     $attachment = array(
                         'data' => $imap->get_message_part($uid, $part->mime_id, $part),
                         'size' => $part->size,
                         'name' => $part->filename,
                         'mimetype' => $part->mimetype,
                         'group' => $task['id'],
                     );
 
                     $attachment = $this->rc->plugins->exec_hook('attachment_save', $attachment);
 
                     if ($attachment['status'] && !$attachment['abort']) {
                         $id = $attachment['id'];
                         $attachment['classname'] = rcube_utils::file2class($attachment['mimetype'], $attachment['name']);
 
                         // store new attachment in session
                         unset($attachment['status'], $attachment['abort'], $attachment['data']);
                         $_SESSION[self::SESSION_KEY]['attachments'][$id] = $attachment;
 
                         $attachment['id'] = 'rcmfile' . $attachment['id'];  // add prefix to consider it 'new'
                         $task['attachments'][] = $attachment;
                     }
                 }
             }
 
             $this->rc->output->command('plugin.mail2taskdialog', $task);
         }
         else {
             $this->rc->output->command('display_message', $this->gettext('messageopenerror'), 'error');
         }
 
         $this->rc->output->send();
     }
 
 
     /*******  Utility functions  *******/
 
     /**
      * Generate a unique identifier for an event
      */
     public function generate_uid()
     {
       return strtoupper(md5(time() . uniqid(rand())) . '-' . substr(md5($this->rc->user->get_username()), 0, 16));
     }
 
     /**
      * Handler for user_delete plugin hook
      */
     public function user_delete($args)
     {
        $this->load_driver();
        return $this->driver->user_delete($args);
     }
 }
 
diff --git a/plugins/tasklist/tasklist_ui.php b/plugins/tasklist/tasklist_ui.php
index 6988a618..f6d4b3ad 100644
--- a/plugins/tasklist/tasklist_ui.php
+++ b/plugins/tasklist/tasklist_ui.php
@@ -1,289 +1,304 @@
 <?php
 /**
  * User Interface class for the Tasklist plugin
  *
  * @version @package_version@
  * @author Thomas Bruederli <bruederli@kolabsys.com>
  *
  * Copyright (C) 2012, Kolab Systems AG <contact@kolabsys.com>
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU Affero General Public License as
  * published by the Free Software Foundation, either version 3 of the
  * License, or (at your option) any later version.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  * GNU Affero General Public License for more details.
  *
  * You should have received a copy of the GNU Affero General Public License
  * along with this program. If not, see <http://www.gnu.org/licenses/>.
  */
 
 
 class tasklist_ui
 {
     private $rc;
     private $plugin;
     private $ready = false;
 
     function __construct($plugin)
     {
         $this->plugin = $plugin;
         $this->rc = $plugin->rc;
     }
 
     /**
     * Calendar UI initialization and requests handlers
     */
     public function init()
     {
         if ($this->ready)  // already done
             return;
 
         // add taskbar button
         $this->plugin->add_button(array(
             'command' => 'tasks',
             'class'   => 'button-tasklist',
             'classsel' => 'button-tasklist button-selected',
             'innerclass' => 'button-inner',
             'label'   => 'tasklist.navtitle',
         ), 'taskbar');
 
         $this->plugin->include_stylesheet($this->plugin->local_skin_path() . '/tasklist.css');
         $this->plugin->include_script('tasklist_base.js');
 
         // copy config to client
         // $this->rc->output->set_env('tasklist_settings', $settings);
 
         $this->ready = true;
   }
 
     /**
     * Register handler methods for the template engine
     */
     public function init_templates()
     {
         $this->plugin->register_handler('plugin.tasklists', array($this, 'tasklists'));
         $this->plugin->register_handler('plugin.tasklist_select', array($this, 'tasklist_select'));
-        $this->plugin->register_handler('plugin.category_select', array($this, 'category_select'));
+        $this->plugin->register_handler('plugin.status_select', array($this, 'status_select'));
         $this->plugin->register_handler('plugin.searchform', array($this->rc->output, 'search_form'));
         $this->plugin->register_handler('plugin.quickaddform', array($this, 'quickadd_form'));
         $this->plugin->register_handler('plugin.tasks', array($this, 'tasks_resultview'));
         $this->plugin->register_handler('plugin.tagslist', array($this, 'tagslist'));
         $this->plugin->register_handler('plugin.tags_editline', array($this, 'tags_editline'));
         $this->plugin->register_handler('plugin.alarm_select', array($this, 'alarm_select'));
         $this->plugin->register_handler('plugin.recurrence_form', array($this->plugin->lib, 'recurrence_form'));
         $this->plugin->register_handler('plugin.attachments_form', array($this, 'attachments_form'));
         $this->plugin->register_handler('plugin.attachments_list', array($this, 'attachments_list'));
         $this->plugin->register_handler('plugin.filedroparea', array($this, 'file_drop_area'));
 
         $this->plugin->include_script('jquery.tagedit.js');
         $this->plugin->include_script('tasklist.js');
 
         $this->plugin->include_stylesheet($this->plugin->local_skin_path() . '/tagedit.css');
     }
 
     /**
      *
      */
     function tasklists($attrib = array())
     {
         $lists = $this->plugin->driver->get_lists();
 
         $li = '';
         foreach ((array)$lists as $id => $prop) {
             if ($attrib['activeonly'] && !$prop['active'])
               continue;
 
             unset($prop['user_id']);
             $prop['alarms'] = $this->plugin->driver->alarms;
             $prop['undelete'] = $this->plugin->driver->undelete;
             $prop['sortable'] = $this->plugin->driver->sortable;
             $prop['attachments'] = $this->plugin->driver->attachments;
 
             if (!$prop['virtual'])
                 $jsenv[$id] = $prop;
 
             $html_id = html_identifier($id);
             $class = 'tasks-'  . asciiwords($id, true);
             $title = $prop['name'] != $prop['listname'] ? html_entity_decode($prop['name'], ENT_COMPAT, RCMAIL_CHARSET) : '';
 
             if ($prop['virtual'])
                 $class .= ' virtual';
             else if (!$prop['editable'])
                 $class .= ' readonly';
             if ($prop['class_name'])
                 $class .= ' '.$prop['class_name'];
 
             $li .= html::tag('li', array('id' => 'rcmlitasklist' . $html_id, 'class' => $class),
                 ($prop['virtual'] ? '' : html::tag('input', array('type' => 'checkbox', 'name' => '_list[]', 'value' => $id, 'checked' => $prop['active']))) .
                 html::span(array('class' => 'handle', 'title' => $this->plugin->gettext('focusview')), '&nbsp;') .
                 html::span(array('class' => 'listname', 'title' => $title), $prop['listname']));
         }
 
         $this->rc->output->set_env('tasklists', $jsenv);
         $this->rc->output->add_gui_object('folderlist', $attrib['id']);
 
         return html::tag('ul', $attrib, $li, html::$common_attrib);
     }
 
+    /**
+     * Render HTML form for task status selector
+     */
+    function status_select($attrib = array())
+    {
+        $attrib['name'] = 'status';
+        $select = new html_select($attrib);
+        $select->add('---', '');
+        $select->add($this->plugin->gettext('status-needs-action'), 'NEEDS-ACTION');
+        $select->add($this->plugin->gettext('status-in-process'),   'IN-PROCESS');
+        $select->add($this->plugin->gettext('status-completed'),    'COMPLETED');
+        $select->add($this->plugin->gettext('status-cancelled'),    'CANCELLED');
+
+        return $select->show(null);
+    }
 
     /**
      * Render a HTML select box for list selection
      */
     function tasklist_select($attrib = array())
     {
         $attrib['name']       = 'list';
         $attrib['is_escaped'] = true;
         $select = new html_select($attrib);
 
         foreach ((array)$this->plugin->driver->get_lists() as $id => $prop) {
             if ($prop['editable'])
                 $select->add($prop['name'], $id);
         }
 
         return $select->show(null);
     }
 
 
     function tasklist_editform($action, $list = array())
     {
         $fields = array(
             'name' => array(
                 'id' => 'taskedit-tasklistame',
                 'label' => $this->plugin->gettext('listname'),
                 'value' => html::tag('input', array('id' => 'taskedit-tasklistame', 'name' => 'name', 'type' => 'text', 'class' => 'text', 'size' => 40)),
             ),
 /*
             'color' => array(
                 'id' => 'taskedit-color',
                 'label' => $this->plugin->gettext('color'),
                 'value' => html::tag('input', array('id' => 'taskedit-color', 'name' => 'color', 'type' => 'text', 'class' => 'text colorpicker', 'size' => 6)),
             ),
 */
             'showalarms' => array(
                 'id' => 'taskedit-showalarms',
                 'label' => $this->plugin->gettext('showalarms'),
                 'value' => html::tag('input', array('id' => 'taskedit-showalarms', 'name' => 'color', 'type' => 'checkbox')),
             ),
         );
 
         return html::tag('form', array('action' => "#", 'method' => "post", 'id' => 'tasklisteditform'),
             $this->plugin->driver->tasklist_edit_form($action, $list, $fields)
         );
     }
 
     /**
      * Render HTML form for alarm configuration
      */
     function alarm_select($attrib = array())
     {
         return $this->plugin->lib->alarm_select($attrib, $this->plugin->driver->alarm_types, $this->plugin->driver->alarm_absolute);
     }
 
     /**
      *
      */
     function quickadd_form($attrib)
     {
         $attrib += array('action' => $this->rc->url('add'), 'method' => 'post', 'id' => 'quickaddform');
 
         $input = new html_inputfield(array('name' => 'text', 'id' => 'quickaddinput'));
         $button = html::tag('input', array('type' => 'submit', 'value' => '+', 'class' => 'button mainaction'));
 
         $this->rc->output->add_gui_object('quickaddform', $attrib['id']);
         return html::tag('form', $attrib, $input->show() . $button);
     }
 
     /**
      * The result view
      */
     function tasks_resultview($attrib)
     {
         $attrib += array('id' => 'rcmtaskslist');
 
         $this->rc->output->add_gui_object('resultlist', $attrib['id']);
 
         unset($attrib['name']);
         return html::tag('ul', $attrib, '');
     }
 
     /**
      * Container for a tags cloud
      */
     function tagslist($attrib)
     {
         $attrib += array('id' => 'rcmtasktagslist');
         unset($attrib['name']);
 
         $this->rc->output->add_gui_object('tagslist', $attrib['id']);
         return html::tag('ul', $attrib, '');
     }
 
     /**
      * Interactive UI element to add/remove tags
      */
     function tags_editline($attrib)
     {
         $attrib += array('id' => 'rcmtasktagsedit');
         $this->rc->output->add_gui_object('edittagline', $attrib['id']);
 
         $input = new html_inputfield(array('name' => 'tags[]', 'class' => 'tag', 'size' => $attrib['size'], 'tabindex' => $attrib['tabindex']));
         return html::div($attrib, $input->show(''));
     }
 
     /**
      * Generate HTML element for attachments list
      */
     function attachments_list($attrib = array())
     {
         if (!$attrib['id'])
             $attrib['id'] = 'rcmtaskattachmentlist';
 
         $this->rc->output->add_gui_object('attachmentlist', $attrib['id']);
 
         return html::tag('ul', $attrib, '', html::$common_attrib);
     }
 
     /**
      * Generate the form for event attachments upload
      */
     function attachments_form($attrib = array())
     {
         // add ID if not given
         if (!$attrib['id'])
             $attrib['id'] = 'rcmtaskuploadform';
 
         // Get max filesize, enable upload progress bar
         $max_filesize = rcube_upload_init();
 
         $button = new html_inputfield(array('type' => 'button'));
         $input = new html_inputfield(array(
             'type' => 'file',
             'name' => '_attachments[]',
             'multiple' => 'multiple',
             'size' => $attrib['attachmentfieldsize'],
         ));
 
         return html::div($attrib,
             html::div(null, $input->show()) .
             html::div('formbuttons', $button->show(rcube_label('upload'), array('class' => 'button mainaction',
                 'onclick' => JS_OBJECT_NAME . ".upload_file(this.form)"))) .
             html::div('hint', rcube_label(array('name' => 'maxuploadsize', 'vars' => array('size' => $max_filesize))))
         );
     }
 
     /**
      * Register UI object for HTML5 drag & drop file upload
      */
     function file_drop_area($attrib = array())
     {
         if ($attrib['id']) {
             $this->rc->output->add_gui_object('filedrop', $attrib['id']);
             $this->rc->output->set_env('filedrop', array('action' => 'upload', 'fieldname' => '_attachments'));
         }
     }
 
 }