(function webpackUniversalModuleDefinition(root, factory) {
	if(typeof exports === 'object' && typeof module === 'object')
		module.exports = factory();
	else if(typeof define === 'function' && define.amd)
		define([], factory);
	else {
		var a = factory();
		for(var i in a) (typeof exports === 'object' ? exports : root)[i] = a[i];
	}
})(this, function() {
return /******/ (function(modules) { // webpackBootstrap
/******/ 	// The module cache
/******/ 	var installedModules = {};
/******/
/******/ 	// The require function
/******/ 	function __webpack_require__(moduleId) {
/******/
/******/ 		// Check if module is in cache
/******/ 		if(installedModules[moduleId])
/******/ 			return installedModules[moduleId].exports;
/******/
/******/ 		// Create a new module (and put it into the cache)
/******/ 		var module = installedModules[moduleId] = {
/******/ 			exports: {},
/******/ 			id: moduleId,
/******/ 			loaded: false
/******/ 		};
/******/
/******/ 		// Execute the module function
/******/ 		modules[moduleId].call(module.exports, module, module.exports, __webpack_require__);
/******/
/******/ 		// Flag the module as loaded
/******/ 		module.loaded = true;
/******/
/******/ 		// Return the exports of the module
/******/ 		return module.exports;
/******/ 	}
/******/
/******/
/******/ 	// expose the modules object (__webpack_modules__)
/******/ 	__webpack_require__.m = modules;
/******/
/******/ 	// expose the module cache
/******/ 	__webpack_require__.c = installedModules;
/******/
/******/ 	// __webpack_public_path__
/******/ 	__webpack_require__.p = "/";
/******/
/******/ 	// Load entry module and return exports
/******/ 	return __webpack_require__(0);
/******/ })
/************************************************************************/
/******/ ({

/***/ 0:
/***/ function(module, exports, __webpack_require__) {

	__webpack_require__(498);
	__webpack_require__(501);
	__webpack_require__(500);
	__webpack_require__(499);
	__webpack_require__(497);
	__webpack_require__(669);


/***/ },

/***/ 1:
/***/ function(module, exports) {

	/*
		MIT License http://www.opensource.org/licenses/mit-license.php
		Author Tobias Koppers @sokra
	*/
	// css base code, injected by the css-loader
	module.exports = function() {
		var list = [];
	
		// return the list of modules as css string
		list.toString = function toString() {
			var result = [];
			for(var i = 0; i < this.length; i++) {
				var item = this[i];
				if(item[2]) {
					result.push("@media " + item[2] + "{" + item[1] + "}");
				} else {
					result.push(item[1]);
				}
			}
			return result.join("");
		};
	
		// import a list of modules into the list
		list.i = function(modules, mediaQuery) {
			if(typeof modules === "string")
				modules = [[null, modules, ""]];
			var alreadyImportedModules = {};
			for(var i = 0; i < this.length; i++) {
				var id = this[i][0];
				if(typeof id === "number")
					alreadyImportedModules[id] = true;
			}
			for(i = 0; i < modules.length; i++) {
				var item = modules[i];
				// skip already imported module
				// this implementation is not 100% perfect for weird media query combinations
				//  when a module is imported multiple times with different media queries.
				//  I hope this will never occur (Hey this way we have smaller bundles)
				if(typeof item[0] !== "number" || !alreadyImportedModules[item[0]]) {
					if(mediaQuery && !item[2]) {
						item[2] = mediaQuery;
					} else if(mediaQuery) {
						item[2] = "(" + item[2] + ") and (" + mediaQuery + ")";
					}
					list.push(item);
				}
			}
		};
		return list;
	};


/***/ },

/***/ 2:
/***/ function(module, exports, __webpack_require__) {

	/*
		MIT License http://www.opensource.org/licenses/mit-license.php
		Author Tobias Koppers @sokra
	*/
	var stylesInDom = {},
		memoize = function(fn) {
			var memo;
			return function () {
				if (typeof memo === "undefined") memo = fn.apply(this, arguments);
				return memo;
			};
		},
		isOldIE = memoize(function() {
			return /msie [6-9]\b/.test(self.navigator.userAgent.toLowerCase());
		}),
		getHeadElement = memoize(function () {
			return document.head || document.getElementsByTagName("head")[0];
		}),
		singletonElement = null,
		singletonCounter = 0,
		styleElementsInsertedAtTop = [];
	
	module.exports = function(list, options) {
		if(false) {
			if(typeof document !== "object") throw new Error("The style-loader cannot be used in a non-browser environment");
		}
	
		options = options || {};
		// Force single-tag solution on IE6-9, which has a hard limit on the # of <style>
		// tags it will allow on a page
		if (typeof options.singleton === "undefined") options.singleton = isOldIE();
	
		// By default, add <style> tags to the bottom of <head>.
		if (typeof options.insertAt === "undefined") options.insertAt = "bottom";
	
		var styles = listToStyles(list);
		addStylesToDom(styles, options);
	
		return function update(newList) {
			var mayRemove = [];
			for(var i = 0; i < styles.length; i++) {
				var item = styles[i];
				var domStyle = stylesInDom[item.id];
				domStyle.refs--;
				mayRemove.push(domStyle);
			}
			if(newList) {
				var newStyles = listToStyles(newList);
				addStylesToDom(newStyles, options);
			}
			for(var i = 0; i < mayRemove.length; i++) {
				var domStyle = mayRemove[i];
				if(domStyle.refs === 0) {
					for(var j = 0; j < domStyle.parts.length; j++)
						domStyle.parts[j]();
					delete stylesInDom[domStyle.id];
				}
			}
		};
	}
	
	function addStylesToDom(styles, options) {
		for(var i = 0; i < styles.length; i++) {
			var item = styles[i];
			var domStyle = stylesInDom[item.id];
			if(domStyle) {
				domStyle.refs++;
				for(var j = 0; j < domStyle.parts.length; j++) {
					domStyle.parts[j](item.parts[j]);
				}
				for(; j < item.parts.length; j++) {
					domStyle.parts.push(addStyle(item.parts[j], options));
				}
			} else {
				var parts = [];
				for(var j = 0; j < item.parts.length; j++) {
					parts.push(addStyle(item.parts[j], options));
				}
				stylesInDom[item.id] = {id: item.id, refs: 1, parts: parts};
			}
		}
	}
	
	function listToStyles(list) {
		var styles = [];
		var newStyles = {};
		for(var i = 0; i < list.length; i++) {
			var item = list[i];
			var id = item[0];
			var css = item[1];
			var media = item[2];
			var sourceMap = item[3];
			var part = {css: css, media: media, sourceMap: sourceMap};
			if(!newStyles[id])
				styles.push(newStyles[id] = {id: id, parts: [part]});
			else
				newStyles[id].parts.push(part);
		}
		return styles;
	}
	
	function insertStyleElement(options, styleElement) {
		var head = getHeadElement();
		var lastStyleElementInsertedAtTop = styleElementsInsertedAtTop[styleElementsInsertedAtTop.length - 1];
		if (options.insertAt === "top") {
			if(!lastStyleElementInsertedAtTop) {
				head.insertBefore(styleElement, head.firstChild);
			} else if(lastStyleElementInsertedAtTop.nextSibling) {
				head.insertBefore(styleElement, lastStyleElementInsertedAtTop.nextSibling);
			} else {
				head.appendChild(styleElement);
			}
			styleElementsInsertedAtTop.push(styleElement);
		} else if (options.insertAt === "bottom") {
			head.appendChild(styleElement);
		} else {
			throw new Error("Invalid value for parameter 'insertAt'. Must be 'top' or 'bottom'.");
		}
	}
	
	function removeStyleElement(styleElement) {
		styleElement.parentNode.removeChild(styleElement);
		var idx = styleElementsInsertedAtTop.indexOf(styleElement);
		if(idx >= 0) {
			styleElementsInsertedAtTop.splice(idx, 1);
		}
	}
	
	function createStyleElement(options) {
		var styleElement = document.createElement("style");
		styleElement.type = "text/css";
		insertStyleElement(options, styleElement);
		return styleElement;
	}
	
	function createLinkElement(options) {
		var linkElement = document.createElement("link");
		linkElement.rel = "stylesheet";
		insertStyleElement(options, linkElement);
		return linkElement;
	}
	
	function addStyle(obj, options) {
		var styleElement, update, remove;
	
		if (options.singleton) {
			var styleIndex = singletonCounter++;
			styleElement = singletonElement || (singletonElement = createStyleElement(options));
			update = applyToSingletonTag.bind(null, styleElement, styleIndex, false);
			remove = applyToSingletonTag.bind(null, styleElement, styleIndex, true);
		} else if(obj.sourceMap &&
			typeof URL === "function" &&
			typeof URL.createObjectURL === "function" &&
			typeof URL.revokeObjectURL === "function" &&
			typeof Blob === "function" &&
			typeof btoa === "function") {
			styleElement = createLinkElement(options);
			update = updateLink.bind(null, styleElement);
			remove = function() {
				removeStyleElement(styleElement);
				if(styleElement.href)
					URL.revokeObjectURL(styleElement.href);
			};
		} else {
			styleElement = createStyleElement(options);
			update = applyToTag.bind(null, styleElement);
			remove = function() {
				removeStyleElement(styleElement);
			};
		}
	
		update(obj);
	
		return function updateStyle(newObj) {
			if(newObj) {
				if(newObj.css === obj.css && newObj.media === obj.media && newObj.sourceMap === obj.sourceMap)
					return;
				update(obj = newObj);
			} else {
				remove();
			}
		};
	}
	
	var replaceText = (function () {
		var textStore = [];
	
		return function (index, replacement) {
			textStore[index] = replacement;
			return textStore.filter(Boolean).join('\n');
		};
	})();
	
	function applyToSingletonTag(styleElement, index, remove, obj) {
		var css = remove ? "" : obj.css;
	
		if (styleElement.styleSheet) {
			styleElement.styleSheet.cssText = replaceText(index, css);
		} else {
			var cssNode = document.createTextNode(css);
			var childNodes = styleElement.childNodes;
			if (childNodes[index]) styleElement.removeChild(childNodes[index]);
			if (childNodes.length) {
				styleElement.insertBefore(cssNode, childNodes[index]);
			} else {
				styleElement.appendChild(cssNode);
			}
		}
	}
	
	function applyToTag(styleElement, obj) {
		var css = obj.css;
		var media = obj.media;
	
		if(media) {
			styleElement.setAttribute("media", media)
		}
	
		if(styleElement.styleSheet) {
			styleElement.styleSheet.cssText = css;
		} else {
			while(styleElement.firstChild) {
				styleElement.removeChild(styleElement.firstChild);
			}
			styleElement.appendChild(document.createTextNode(css));
		}
	}
	
	function updateLink(linkElement, obj) {
		var css = obj.css;
		var sourceMap = obj.sourceMap;
	
		if(sourceMap) {
			// http://stackoverflow.com/a/26603875
			css += "\n/*# sourceMappingURL=data:application/json;base64," + btoa(unescape(encodeURIComponent(JSON.stringify(sourceMap)))) + " */";
		}
	
		var blob = new Blob([css], { type: "text/css" });
	
		var oldSrc = linkElement.href;
	
		linkElement.href = URL.createObjectURL(blob);
	
		if(oldSrc)
			URL.revokeObjectURL(oldSrc);
	}


/***/ },

/***/ 59:
/***/ function(module, exports) {

	module.exports = "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAABuwAAAbsBOuzj4gAAABl0RVh0U29mdHdhcmUAd3d3Lmlua3NjYXBlLm9yZ5vuPBoAAAJXSURBVDiNfZBNSFRxFMV/781T05maUqkmtA/Saim0MtM0gxBrUUSQENi00oXLWrgpaVEWtmkRBAblwtoYQl8uFERJcqKiDEb6QJgGmnTEnJk3M+//3m1hb8DRPHDh/M+993DuXxMRBgcHA6ZpRgF0XU+3t7d7yUN/f7/t8mAw6BERB0Cjlq7ybeXnZgdm6wGS6aSqPF85kW8QH443urz0dOkYOk9lXO5r1DF69kprU6210jcMD2bVT8p8W/EXeUGDP+kUS6GinFnIP8lw7+uR1EjqpAHwZT7M0OJz/MWbKPOVUB72smOLj+2bfQDElhP80hLMJ5IsJFLst6oxDEMDMNDQHEcQAeU4WLZD2lIspzMrifQCLld383XxG7tK9vLi+ys+L34CHX3FAFBKods6tg1pyyaVtdHJYGYUANemrpLIWiyZJstmhgNlVSDuQQU0K6UcpZRsVJaycty2banYV9EiIuhYKBFho7Idm+YH9XQ8C+Y03dYVsHLHxsuKxodHGP89RXGRN6e7MFyD9eCIzfGBBt4lPtB1uJPbJ+6umdVdIiJMRSa5N92HiKAci5bBJn6oMJ2HOuht7luVbE0CEeHOdA9zdpiUlWIiOkq8cI6LOy/Rc+zWeillzR88ah1it7GHydQTxB/jVPkFrjfczPXj8TgzMzNEIhFJJpOOayDuQKFeyOOWl5RmKzhafIbuuhurYkejUWpqagiFQu8XFhbeAGhAg2maYyKi52fMRyQSkVAo9LGtra1eRBKuwd5AIHDQ4/Fo/97/g2SzWTsWi70VkSVX/Av566CQaS3obgAAAABJRU5ErkJggg=="

/***/ },

/***/ 80:
/***/ function(module, exports) {

	module.exports = "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABYAAAAWCAYAAADEtGw7AAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAADdgAAA3YBfdWCzAAAABl0RVh0U29mdHdhcmUAd3d3Lmlua3NjYXBlLm9yZ5vuPBoAAANBSURBVDiNnZRNaFxVFMd/972ZeTOTialJSmpSW0QFEbowpKkVUhobMdJF6lSR0SIo6r4gdlXEjUs3unLRhQtDBSNVN0OiaZBQKUTQTQySxMZ0iGmndvIx8+a9e+9xMZ10ZjINSQ/cxTsfv3fu/53zlIjQaKOjowEQBfA8b386nb7dmDM9Pd2+tLSUv/cYZjKZWG1cVcFqQJ1DGAYoT5Yz0UjUAeh+tfvblTsrQSP4QPuBWO673FmAUIfWO+VdxmJxGZMpGYtsZQrvMsKgCmB8cpyYW2ng+NtHzj51eJjOln20xpMArPlFfp/9i4nJCRDQVjvuaSfjxlyCsTAJ1IAVCgMqoXjjtzQtKkZrMkZnTwvFWzfYtxmnLZEAhELJ527C56PFdyhtaNZsiY62R8gX1yoc4D640jUiAi2g4uDEFYExlEPNZjnA2opspTAk0IYPBz7GiqLgr5OKtPFe9oMt1HawBW0NgTb4oSbiODgotLVsumHlSxkDNkrCTbFQWOCx5EH+WbsJNXNwH2wpxoihrUYbQRvQRhEah0CrCtytpBqj8HWRi79e4L/iOoERCsUNohLFWFOsnwqlTllrJ5qN325NKYXjOEMi8lOdFCLCXsC+KRJ3k01jzm4h1ZdWT770L0e/PML58ffr/FV7qI7zpVWOXzrKYiEHC1OUjY/nxuty9gzOl1Y59lUfS8EKT+4/xOS5aWKOh4iglGoOrsIfCPVvMfD1MfJyh6dbDzH15jUe9dq3amprH6hx9u/vee3HlwltsAV98ZsX8KPrHE70cDVzjXavY5v2TcHVYEmX+OT6BW6U/+TMlZe4ubHM6bETRFNlutwuxl//hY54x46SNQV7jsenz39Bq9OCTq7y1vgQbZ2QMu1cGfm5rlNrLVprgmDrByhNpagWDPSc5OJzn5OQOAe7UkSKrVx+JUtHvP762WyW2dlZ5ufnyeVyd4HbO2oMcOLxk5x/5jM2VuNcGvphG1RE6O7upre3F2NM2NfXd0ZE/oCGlfZ9f8IYs6N2jTY3N0cYhuV0Oj28vLx8teqvHTe5t+t7AhcKhZXBwcEREble66/t+In+/v5n9wI1xsjMzMyiiMw2xtRuVvhh7H/sbdgpbF0eJwAAAABJRU5ErkJggg=="

/***/ },

/***/ 98:
/***/ function(module, exports) {

	module.exports = "data:image/png;base64,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"

/***/ },

/***/ 497:
/***/ function(module, exports) {

	/*
	 * Tine 2.0
	 * 
	 * @license     http://www.gnu.org/licenses/agpl.html AGPL Version 3
	 * @author      Cornelius Weiss <c.weiss@metaways.de>
	 * @copyright   Copyright (c) 2011-2014 Metaways Infosystems GmbH (http://www.metaways.de)
	 */
	Ext.ns('Tine.Tasks');
	
	/**
	 * render the CalDAV Url into property panel of containers
	 * 
	 * @class   Tine.Calendar.CalDAVContainerPropertiesHookField
	 * @extends Tine.widgets.container.CalDAVContainerPropertiesHookField
	 */
	Tine.Tasks.CalDAVContainerPropertiesHookField = Ext.extend(Tine.widgets.container.CalDAVContainerPropertiesHookField, {
	    appName: 'Tasks'
	});
	
	Ext.ux.ItemRegistry.registerItem('Tine.widgets.container.PropertiesDialog.FormItems.Properties', Tine.Tasks.CalDAVContainerPropertiesHookField, 100);

/***/ },

/***/ 498:
/***/ function(module, exports) {

	/**
	 * Tine 2.0
	 *
	 * @package     Tasks
	 * @license     http://www.gnu.org/licenses/agpl.html AGPL Version 3
	 * @author      Cornelius Weiss <c.weiss@metaways.de>
	 * @copyright   Copyright (c) 2007-2011 Metaways Infosystems GmbH (http://www.metaways.de)
	 *
	 */
	
	Ext.ns('Tine.Tasks.Model');
	
	// Task model
	Tine.Tasks.Model.TaskArray = Tine.Tinebase.Model.genericFields.concat([
	    { name: 'id' },
	    { name: 'uid' },
	    { name: 'percent', header: 'Percent' },
	    { name: 'completed', type: 'date', dateFormat: Date.patterns.ISO8601Long },
	    { name: 'due', type: 'date', dateFormat: Date.patterns.ISO8601Long },
	    // ical common fields
	    { name: 'class' },
	    { name: 'description' },
	    { name: 'geo' },
	    { name: 'location' },
	    { name: 'organizer' },
	    { name: 'originator_tz' },
	    { name: 'priority' },
	    { name: 'status' },
	    { name: 'summary' },
	    { name: 'url' },
	    // ical common fields with multiple appearance
	    { name: 'attach' },
	    { name: 'attendee' },
	    { name: 'tags' },
	    { name: 'comment' },
	    { name: 'contact' },
	    { name: 'related' },
	    { name: 'resources' },
	    { name: 'rstatus' },
	    // scheduleable interface fields
	    { name: 'dtstart', type: 'date', dateFormat: Date.patterns.ISO8601Long },
	    { name: 'duration', type: 'date', dateFormat: Date.patterns.ISO8601Long },
	    { name: 'recurid' },
	    // scheduleable interface fields with multiple appearance
	    { name: 'exdate' },
	    { name: 'exrule' },
	    { name: 'rdate' },
	    { name: 'rrule' },
	    // tine 2.0 notes field
	    { name: 'notes'},
	    // tine 2.0 alarms field
	    { name: 'alarms'},
	    // relations with other objects
	    { name: 'relations'},
	    { name: 'attachments'}
	]);
	
	/**
	 * Task record definition
	 */
	Tine.Tasks.Model.Task = Tine.Tinebase.data.Record.create(Tine.Tasks.Model.TaskArray, {
	    appName: 'Tasks',
	    modelName: 'Task',
	    idProperty: 'id',
	    titleProperty: 'summary',
	    // ngettext('Task', 'Tasks', n); gettext('Tasks');
	    recordName: 'Task',
	    recordsName: 'Tasks',
	    containerProperty: 'container_id',
	    // ngettext('to do list', 'to do lists', n); gettext('to do lists');
	    containerName: 'to do list',
	    containersName: 'to do lists'
	});
	
	/**
	 * returns default account data
	 *
	 * @namespace Tine.Tasks.Model.Task
	 * @static
	 * @return {Object} default data
	 */
	Tine.Tasks.Model.Task.getDefaultData = function() {
	    var app = Tine.Tinebase.appMgr.get('Tasks');
	
	    return {
	        'class': 'PUBLIC',
	        percent: 0,
	        organizer: Tine.Tinebase.registry.get('currentAccount'),
	        container_id: app.getMainScreen().getWestPanel().getContainerTreePanel().getDefaultContainer()
	    };
	};
	
	/**
	 * @namespace Tine.Tasks.Model.Task
	 *
	 * get task filter
	 *
	 * @return {Array} filter objects
	 * @static
	 */
	Tine.Tasks.Model.Task.getFilterModel = function() {
	    var app = Tine.Tinebase.appMgr.get('Tasks');
	
	    return [
	        {label: i18n._('Quick Search'),                  field: 'query',    operators: ['contains']},
	        {filtertype: 'tine.widget.container.filtermodel', app: app, recordClass: Tine.Tasks.Model.Task},
	        {label: app.i18n._('Summary'),         field: 'summary' },
	        {label: app.i18n._('Due Date'),        field: 'due', valueType: 'date', operators: ['within', 'before', 'after']},
	        {
	            label: app.i18n._('Status'),
	            field: 'status',
	            filtertype: 'tine.widget.keyfield.filter',
	            app: app,
	            defaultValue: Tine.Tasks.Model.Task.getClosedStatus(),
	            keyfieldName: 'taskStatus',
	            defaultOperator: 'notin'
	        },
	        {label: app.i18n._('Responsible'),     field: 'organizer', valueType: 'user'},
	        {filtertype: 'tinebase.tag', app: app},
	        {label: i18n._('Last Modified Time'),                                                field: 'last_modified_time', valueType: 'date'},
	        {label: i18n._('Last Modified By'),                                                  field: 'last_modified_by',   valueType: 'user'},
	        {label: i18n._('Creation Time'),                                                     field: 'creation_time',      valueType: 'date'},
	        {label: i18n._('Created By'),                                                        field: 'created_by',         valueType: 'user'}
	    ];
	};
	
	/**
	 * @namespace Tine.Tasks.Model.Task
	 *
	 * get closed status ids
	 *
	 * @return {Array} status ids objects
	 * @static
	 */
	Tine.Tasks.Model.Task.getClosedStatus = function() {
	    var reqStatus = [];
	
	    Tine.Tinebase.widgets.keyfield.StoreMgr.get('Tasks', 'taskStatus').each(function(status) {
	        if (! status.get('is_open')) {
	            reqStatus.push(status.get('id'));
	        }
	    }, this);
	
	    return reqStatus;
	};
	
	/**
	 * default tasks backend
	 */
	Tine.Tasks.JsonBackend = new Tine.Tinebase.data.RecordProxy({
	    appName: 'Tasks',
	    modelName: 'Task',
	    recordClass: Tine.Tasks.Model.Task
	});
	
	Tine.Tasks.Model.Status = Tine.Tinebase.data.Record.create([
	    { name: 'id' },
	    { name: 'value' },
	    { name: 'icon' },
	    { name: 'system' },
	    { name: 'is_open' },
	    { name: 'i18nValue' }
	], {
	    appName: 'Tasks',
	    modelName: 'Status',
	    idProperty: 'id',
	    titleProperty: 'i18nValue',
	    // ngettext('Status', 'Status', n); gettext('Status');
	    recordName: 'Status',
	    recordsName: 'Status'
	});

/***/ },

/***/ 499:
/***/ function(module, exports) {

	/*
	 * Tine 2.0
	 * 
	 * @package     Tasks
	 * @license     http://www.gnu.org/licenses/agpl.html AGPL Version 3
	 * @author      Cornelius Weiss <c.weiss@metaways.de>
	 * @copyright   Copyright (c) 2007-2009 Metaways Infosystems GmbH (http://www.metaways.de)
	 *
	 */
	 
	Ext.namespace('Tine.Tasks');
	
	/**
	 * @namespace   Tine.Tasks
	 * @class       Tine.Tasks.TaskEditDialog
	 * @extends     Tine.widgets.dialog.EditDialog
	 * 
	 * <p>Tasks Edit Dialog</p>
	 * <p>
	 * TODO         refactor this: remove initRecord/containerId/relatedApp, 
	 *              adopt to normal edit dialog flow and add getDefaultData to task model
	 * </p>
	 * 
	 * @license     http://www.gnu.org/licenses/agpl.html AGPL Version 3
	 * @author      Cornelius Weiss <c.weiss@metaways.de>
	 * @copyright   Copyright (c) 2007-2009 Metaways Infosystems GmbH (http://www.metaways.de)
	 * 
	 * @param       {Object} config
	 * @constructor
	 * Create a new Tine.Tasks.TaskEditDialog
	 */
	 Tine.Tasks.TaskEditDialog = Ext.extend(Tine.widgets.dialog.EditDialog, {
	    /**
	     * @cfg {Number} containerId
	     */
	    containerId: -1,
	    
	    /**
	     * @cfg {String} relatedApp
	     */
	    relatedApp: '',
	    
	    /**
	     * @private
	     */
	    labelAlign: 'side',
	    
	    /**
	     * @private
	     */
	    windowNamePrefix: 'TasksEditWindow_',
	    appName: 'Tasks',
	    recordClass: Tine.Tasks.Model.Task,
	    recordProxy: Tine.Tasks.JsonBackend,
	    showContainerSelector: true,
	    displayNotes: true,
	
	    /**
	     * @private
	     */
	    initComponent: function() {
	        
	        if(!this.record) {
	            this.record = new this.recordClass(this.recordClass.getDefaultData(), 0);
	        }
	        
	        this.alarmPanel = new Tine.widgets.dialog.AlarmPanel({});
	        Tine.Tasks.TaskEditDialog.superclass.initComponent.call(this);
	    },
	    
	    /**
	     * executed when record is loaded
	     * @private
	     */
	    onRecordLoad: function() {
	        // interrupt process flow until dialog is rendered
	        if (! this.rendered) {
	            this.onRecordLoad.defer(250, this);
	            return;
	        }
	        
	        Tine.Tasks.TaskEditDialog.superclass.onRecordLoad.apply(this, arguments);
	        this.handleCompletedDate();
	        
	        // update tabpanels
	        this.alarmPanel.onRecordLoad(this.record);
	        
	        if (! this.copyRecord && ! this.record.id) {
	            this.window.setTitle(this.app.i18n._('Add New Task'));
	        }
	    },
	    
	    /**
	     * executed when record is updated
	     * @private
	     */
	    onRecordUpdate: function() {
	        Tine.Tasks.TaskEditDialog.superclass.onRecordUpdate.apply(this, arguments);
	        this.alarmPanel.onRecordUpdate(this.record);
	    },
	    
	    /**
	     * handling for the completed field
	     * @private
	     */
	    handleCompletedDate: function() {
	        
	        var statusStore = Tine.Tinebase.widgets.keyfield.StoreMgr.get('Tasks', 'taskStatus'),
	            status = this.getForm().findField('status').getValue(),
	            statusRecord = statusStore.getById(status),
	            completedField = this.getForm().findField('completed');
	        
	        if (statusRecord) {
	            if (statusRecord.get('is_open') !== 0) {
	                completedField.setValue(null);
	                completedField.setDisabled(true);
	            } else {
	                if (! Ext.isDate(completedField.getValue())){
	                    completedField.setValue(new Date());
	                }
	                completedField.setDisabled(false);
	            }
	        }
	        
	    },
	    
	    /**
	     * checks if form data is valid
	     * 
	     * @return {Boolean}
	     */
	    isValid: function() {
	        var isValid = true;
	        
	        var dueField = this.getForm().findField('due'),
	            dueDate = dueField.getValue(),
	            alarms = this.alarmPanel.alarmGrid.getFromStoreAsArray();
	            
	        if (! Ext.isEmpty(alarms) && ! Ext.isDate(dueDate)) {
	            dueField.markInvalid(this.app.i18n._('You have to supply a due date, because an alarm ist set!'));
	            
	            isValid = false;
	        }
	        
	        return isValid && Tine.Tasks.TaskEditDialog.superclass.isValid.apply(this, arguments);
	    },
	    
	    /**
	     * returns dialog
	     * 
	     * NOTE: when this method gets called, all initalisation is done.
	     * @private
	     */
	    getFormItems: function() {
	        return {
	            xtype: 'tabpanel',
	            border: false,
	            plain:true,
	            activeTab: 0,
	            border: false,
	            plugins: [{
	                ptype : 'ux.tabpanelkeyplugin'
	            }],
	            defaults: {
	                hideMode: 'offsets'
	            },
	            items:[{
	                title: this.app.i18n.n_('Task', 'Tasks', 1),
	                autoScroll: true,
	                border: false,
	                frame: true,
	                layout: 'border',
	                items: [{
	                    region: 'center',
	                    xtype: 'columnform',
	                    labelAlign: 'top',
	                    formDefaults: {
	                        xtype:'textfield',
	                        anchor: '100%',
	                        labelSeparator: '',
	                        columnWidth: .333
	                    },
	                    items: [[{
	                        columnWidth: 1,
	                        fieldLabel: this.app.i18n._('Summary'),
	                        name: 'summary',
	                        listeners: {render: function(field){field.focus(false, 250);}},
	                        allowBlank: false
	                    }], [new Ext.ux.form.DateTimeField({
	                            allowBlank: true,
	                            defaultTime: '12:00',
	                            fieldLabel: this.app.i18n._('Due date'),
	                            name: 'due'
	                        }), 
	                        new Tine.Tinebase.widgets.keyfield.ComboBox({
	                            fieldLabel: this.app.i18n._('Priority'),
	                            name: 'priority',
	                            app: 'Tasks',
	                            keyFieldName: 'taskPriority',
	                            value: 'NORMAL'
	                        }),
	                        Tine.widgets.form.RecordPickerManager.get('Addressbook', 'Contact', {
	                            userOnly: true,
	                            fieldLabel: this.app.i18n._('Organizer'),
	                            emptyText: i18n._('Add Responsible ...'),
	                            useAccountRecord: true,
	                            name: 'organizer',
	                            allowEmpty: true
	                        })
	                    ], [{
	                        columnWidth: 1,
	                        fieldLabel: this.app.i18n._('Notes'),
	                        emptyText: this.app.i18n._('Enter description...'),
	                        name: 'description',
	                        xtype: 'textarea',
	                        height: 200
	                    }], [
	                        new Ext.ux.PercentCombo({
	                            fieldLabel: this.app.i18n._('Percentage'),
	                            editable: false,
	                            name: 'percent'
	                        }), 
	                        new Tine.Tinebase.widgets.keyfield.ComboBox({
	                            app: 'Tasks',
	                            keyFieldName: 'taskStatus',
	                            fieldLabel: this.app.i18n._('Status'),
	                            name: 'status',
	                            value: 'NEEDS-ACTION',
	                            allowBlank: false,
	                            listeners: {scope: this, 'change': this.handleCompletedDate}
	                        }), 
	                        new Ext.ux.form.DateTimeField({
	                            allowBlank: true,
	                            defaultTime: '12:00',
	                            fieldLabel: this.app.i18n._('Completed'),
	                            name: 'completed'
	                        })
	                    ]]
	                }, {
	                    // activities and tags
	                    layout: 'accordion',
	                    animate: true,
	                    region: 'east',
	                    width: 210,
	                    split: true,
	                    collapsible: true,
	                    collapseMode: 'mini',
	                    header: false,
	                    margins: '0 5 0 5',
	                    border: true,
	                    items: [
	                        new Tine.widgets.tags.TagPanel({
	                            app: 'Tasks',
	                            border: false,
	                            bodyStyle: 'border:1px solid #B5B8C8;'
	                        })
	                    ]
	                }]
	            }, new Tine.widgets.activities.ActivitiesTabPanel({
	                app: this.appName,
	                record_id: (this.record) ? this.record.id : '',
	                record_model: this.appName + '_Model_' + this.recordClass.getMeta('modelName')
	            }), this.alarmPanel
	            ]
	        };
	    }
	});
	
	/**
	 * Tasks Edit Popup
	 * 
	 * @param   {Object} config
	 * @return  {Ext.ux.Window}
	 */
	Tine.Tasks.TaskEditDialog.openWindow = function (config) {
	    var id = (config.record && config.record.id) ? config.record.id : 0;
	    var window = Tine.WindowFactory.getWindow({
	        width: 900,
	        height: 490,
	        name: Tine.Tasks.TaskEditDialog.prototype.windowNamePrefix + id,
	        contentPanelConstructor: 'Tine.Tasks.TaskEditDialog',
	        contentPanelConstructorConfig: config
	    });
	    return window;
	};


/***/ },

/***/ 500:
/***/ function(module, exports) {

	/*
	 * Tine 2.0
	 * 
	 * @package     Tasks
	 * @license     http://www.gnu.org/licenses/agpl.html AGPL Version 3
	 * @author      Cornelius Weiss <c.weiss@metaways.de>
	 * @copyright   Copyright (c) 2007-2011 Metaways Infosystems GmbH (http://www.metaways.de)
	 *
	 */
	
	Ext.namespace('Tine.Tasks');
	
	/**
	 * Tasks grid panel
	 * 
	 * @namespace   Tine.Tasks
	 * @class       Tine.Tasks.TaskGridPanel
	 * @extends     Tine.widgets.grid.GridPanel
	 * 
	 * <p>Tasks Grid Panel</p>
	 * <p><pre>
	 * </pre></p>
	 * 
	 * @license     http://www.gnu.org/licenses/agpl.html AGPL Version 3
	 * @author      Cornelius Weiss <c.weiss@metaways.de>
	 * @copyright   Copyright (c) 2007-2008 Metaways Infosystems GmbH (http://www.metaways.de)
	 * 
	 * @param       {Object} config
	 * @constructor
	 * Create a new Tine.Tasks.TaskGridPanel
	 */
	Tine.Tasks.TaskGridPanel = Ext.extend(Tine.widgets.grid.GridPanel, {
	    /**
	     * record class
	     * @cfg {Tine.Tasks.Model.Task} recordClass
	     */
	    recordClass: Tine.Tasks.Model.Task,
	    
	    /**
	     * @private grid cfg
	     */
	    defaultSortInfo: {field: 'due', dir: 'ASC'},
	    gridConfig: {
	        clicksToEdit: 'auto',
	        quickaddMandatory: 'summary',
	        resetAllOnNew: false,
	        autoExpandColumn: 'summary',
	        // drag n drop
	        enableDragDrop: true,
	        ddGroup: 'containerDDGroup'
	    },
	    
	    // specialised translations
	    // ngettext('Do you really want to delete the selected task?', 'Do you really want to delete the selected tasks?', n);
	    i18nDeleteQuestion: ['Do you really want to delete the selected task?', 'Do you really want to delete the selected tasks?'],
	    
	    /**
	     * @private
	     */
	    initComponent: function() {
	        this.recordProxy = Tine.Tasks.JsonBackend;
	        this.gridConfig.cm = this.getColumnModel();
	        
	        this.defaultFilters = [
	            {field: 'container_id', operator: 'equals', value: {path: Tine.Tinebase.container.getMyNodePath()}}
	        ];
	        Tine.Tasks.TaskGridPanel.superclass.initComponent.call(this);
	        
	        // the editGrids onEditComplete calls the focusCell after a edit operation
	        // this leads to a 'flicker' effect we dont want!
	        // mhh! but disabling this, breaks keynav 
	        //this.grid.view.focusCell = Ext.emptyFn;
	    },
	    
	    /**
	     * returns cm
	     * @return Ext.grid.ColumnModel
	     * @private
	     */
	    getColumnModel: function(){
	        
	        var columns = [{id: 'tags', header: this.app.i18n._('Tags'), width: 40,  dataIndex: 'tags', sortable: false, renderer: Tine.Tinebase.common.tagsRenderer}];
	        
	        if (Tine.hasOwnProperty('Crm') && Tine.Tinebase.common.hasRight('run', 'Crm')) {
	            columns.push({
	                id: 'lead',
	                header: this.app.i18n._('Lead name'),
	                width: 150,
	                dataIndex: 'relations',
	                renderer: Tine.widgets.grid.RendererManager.get('Tasks', 'Task', 'lead'),
	                sortable: false
	            });
	        }
	        
	        columns = columns.concat([{
	            id: 'summary',
	            header: this.app.i18n._("Summary"),
	            width: 400,
	            dataIndex: 'summary',
	            quickaddField: new Ext.form.TextField({
	                emptyText: this.app.i18n._('Add a task...')
	            })
	        }, {
	            id: 'due',
	            header: this.app.i18n._("Due Date"),
	            width: 145,
	            dataIndex: 'due',
	            renderer: Tine.Tinebase.common.dateTimeRenderer,
	            editor: new Ext.ux.form.DateTimeField({
	                defaultTime: '12:00',
	                allowBlank: true
	            }),
	            quickaddField: new Ext.ux.form.DateTimeField({
	                defaultTime: '12:00',
	                allowBlank: true
	            })
	        }, {
	            id: 'priority',
	            header: this.app.i18n._("Priority"),
	            width: 65,
	            dataIndex: 'priority',
	            renderer: Tine.Tinebase.widgets.keyfield.Renderer.get('Tasks', 'taskPriority'),
	            editor: {
	                xtype: 'widget-keyfieldcombo',
	                app: 'Tasks',
	                keyFieldName: 'taskPriority'
	            },
	            quickaddField: new Tine.Tinebase.widgets.keyfield.ComboBox({
	                app: 'Tasks',
	                keyFieldName: 'taskPriority',
	                value: 'NORMAL'
	            })
	        }, {
	            id: 'percent',
	            header: this.app.i18n._("Percent"),
	            width: 50,
	            dataIndex: 'percent',
	            renderer: Ext.ux.PercentRenderer,
	            editor: new Ext.ux.PercentCombo({
	                autoExpand: true,
	                blurOnSelect: true
	            }),
	            quickaddField: new Ext.ux.PercentCombo({
	                autoExpand: true
	            })
	        }, {
	            id: 'status',
	            header: this.app.i18n._("Status"),
	            width: 85,
	            dataIndex: 'status',
	            renderer: Tine.Tinebase.widgets.keyfield.Renderer.get('Tasks', 'taskStatus'),
	            editor: {
	                xtype: 'widget-keyfieldcombo',
	                app: 'Tasks',
	                keyFieldName: 'taskStatus'
	            },
	            quickaddField: new Tine.Tinebase.widgets.keyfield.ComboBox({
	                app: 'Tasks',
	                keyFieldName: 'taskStatus',
	                value: 'NEEDS-ACTION'
	            })
	        }, {
	            id: 'completed',
	            header: this.app.i18n._("Completed"),
	            hidden: true,
	            width: 70,
	            dataIndex: 'completed',
	            renderer: Tine.Tinebase.common.dateTimeRenderer
	        }, {
	            id: 'organizer',
	            header: this.app.i18n._('Responsible'),
	            width: 200,
	            dataIndex: 'organizer',
	            renderer: Tine.Tinebase.common.accountRenderer,
	            quickaddField: Tine.widgets.form.RecordPickerManager.get('Addressbook', 'Contact', {
	                userOnly: true,
	                useAccountRecord: true,
	                blurOnSelect: true,
	                selectOnFocus: true,
	                allowEmpty: true,
	                value: Tine.Tinebase.registry.get('currentAccount')
	            })
	        }].concat(this.getModlogColumns().concat(this.getCustomfieldColumns())));
	        
	        return new Ext.grid.ColumnModel({
	            defaults: {
	                sortable: true,
	                resizable: true
	            },
	            columns: columns
	        });
	    },
	
	    /**
	     * Return CSS class to apply to rows depending upon due status
	     * 
	     * @param {Tine.Tasks.Model.Task} record
	     * @param {Integer} index
	     * @return {String}
	     */
	    getViewRowClass: function(record, index) {
	        var due = record.get('due');
	         
	        var className = '';
	        
	        if(record.get('status') == 'COMPLETED') {
	            className += 'tasks-grid-completed';
	        } else  if (due) {
	            var dueDay = due.format('Y-m-d');
	            var today = new Date().format('Y-m-d');
	
	            if (dueDay == today) {
	                className += 'tasks-grid-duetoday';
	            } else if (dueDay < today) {
	                className += 'tasks-grid-overdue';
	            }
	            
	        }
	        return className;
	    }
	});


/***/ },

/***/ 501:
/***/ function(module, exports) {

	/**
	 * Tine 2.0
	 * 
	 * @package     Tasks
	 * @license     http://www.gnu.org/licenses/agpl.html AGPL Version 3
	 * @author      Cornelius Weiss <c.weiss@metaways.de>
	 * @copyright   Copyright (c) 2007-2011 Metaways Infosystems GmbH (http://www.metaways.de)
	 *
	 */
	
	Ext.ns('Tine', 'Tine.Tasks');
	
	
	
	Tine.Tasks.CrmLeadRenderer = new Tine.widgets.relation.GridRenderer({
	    appName: 'Tasks', type: 'TASK', foreignApp: 'Crm', foreignModel: 'Lead'
	});
	
	Tine.widgets.grid.RendererManager.register(
	    'Tasks',
	    'Task',
	    'lead',
	    Tine.Tasks.CrmLeadRenderer.render,
	    null,
	    Tine.Tasks.CrmLeadRenderer
	);
	
	/**
	 * @namespace   Tine.Tasks
	 * @class       Tine.Tasks.Application
	 * @extends     Tine.Tinebase.Application
	 * Tasks Application Object <br>
	 * 
	 * @author      Cornelius Weiss <c.weiss@metaways.de>
	 */
	Tine.Tasks.Application = Ext.extend(Tine.Tinebase.Application, {
	    
	    /**
	     * auto hook text i18n._('New Task')
	     */
	    addButtonText: 'New Task'
	});
	
	// default mainscreen
	Tine.Tasks.MainScreen = Ext.extend(Tine.widgets.MainScreen, {
	    activeContentType: 'Task'
	});
	
	Tine.Tasks.TaskTreePanel = function(config) {
	    Ext.apply(this, config);
	    
	    this.id = 'TasksTreePanel';
	    this.recordClass = Tine.Tasks.Model.Task;
	    
	    this.filterMode = 'filterToolbar';
	    Tine.Tasks.TaskTreePanel.superclass.constructor.call(this);
	};
	Ext.extend(Tine.Tasks.TaskTreePanel, Tine.widgets.container.TreePanel, {
	    afterRender: function() {
	        this.supr().afterRender.apply(this, arguments);
	    }
	});
	
	Tine.Tasks.TaskFilterPanel = function(config) {
	    Ext.apply(this, config);
	    Tine.Tasks.TaskFilterPanel.superclass.constructor.call(this);
	};
	Ext.extend(Tine.Tasks.TaskFilterPanel, Tine.widgets.persistentfilter.PickerPanel, {
	    filter: [{field: 'model', operator: 'equals', value: 'Tasks_Model_TaskFilter'}]
	});


/***/ },

/***/ 582:
/***/ function(module, exports, __webpack_require__) {

	exports = module.exports = __webpack_require__(1)();
	// imports
	
	
	// module
	exports.push([module.id, ".TasksIconCls,.TasksTask{background-image:url(" + __webpack_require__(59) + ")!important}.x-btn-medium .TasksIconCls{background-image:url(" + __webpack_require__(80) + ")!important}.x-btn-large .TasksIconCls{background-image:url(" + __webpack_require__(98) + ")!important}.TasksMainGridStatus{width:12px;height:12px}.tasks-grid-overdue{color:#a00}.tasks-grid-duetoday{color:#0a0}.tasks-grid-completed{color:#777}", ""]);
	
	// exports


/***/ },

/***/ 669:
/***/ function(module, exports, __webpack_require__) {

	// style-loader: Adds some css to the DOM by adding a <style> tag
	
	// load the styles
	var content = __webpack_require__(582);
	if(typeof content === 'string') content = [[module.id, content, '']];
	// add the styles to the DOM
	var update = __webpack_require__(2)(content, {});
	if(content.locals) module.exports = content.locals;
	// Hot Module Replacement
	if(false) {
		// When the styles change, update the <style> tags
		if(!content.locals) {
			module.hot.accept("!!../../Tinebase/js/node_modules/css-loader/index.js!./Tasks.css", function() {
				var newContent = require("!!../../Tinebase/js/node_modules/css-loader/index.js!./Tasks.css");
				if(typeof newContent === 'string') newContent = [[module.id, newContent, '']];
				update(newContent);
			});
		}
		// When the module is disposed, remove the <style> tags
		module.hot.dispose(function() { update(); });
	}

/***/ }

/******/ })
});
;