5679       var task = { callback: callback, args: args };  class in AnonymousFunctioncdb5859f0100.AnonymousFunctioncdb5859f5100.setImmediate
5680       tasksByHandle[nextHandle] = task;
5689     function run(task) {  argument
5690         var callback = task.callback;
5691         var args = task.args;
5719             var task = tasksByHandle[handle];
5720             if (task) {
5723                     run(task);
6449             task: "task",  property in module.exports.result.types
7341                 var task = _this._gantt.getTaskByWBSCode(wbs);
7342                 if (task) {
7343                     return task.id;
7562 			progress_text: function (start, end, task) {  argument
7569 			task_text: function (start, end, task) {  argument
7570 				return task.text;
7572 			task_class: function (start, end, task) {  argument
7578 			grid_row_class: function (start, end, task) {  argument
7581 			task_row_class: function (start, end, task) {  argument
7625 			task_unscheduled_time: function (task) {  argument
7690 	gantt.isUnscheduledTask = function (task) {  argument
7691 …gantt.assert(task && task instanceof Object, "Invalid argument <b>task</b>="+task+" of gantt.isUns…
7692 		return (!!task.unscheduled || !task.start_date);
7695 	gantt._isAllowedUnscheduledTask = function (task) {  argument
7696 		return !!(task.unscheduled && gantt.config.show_unscheduled);
7699 	gantt._isTaskInTimelineLimits = function(task) {  argument
7700 		var taskStart = task.start_date ? task.start_date.valueOf() : null;
7701 		var taskEnd = task.end_date ? task.end_date.valueOf() : null;
7709 		var task = this.getTask(id);
7710 		if (!(this._isAllowedUnscheduledTask(task) || this._isTaskInTimelineLimits(task))) {
7757 					task:item
7767 				task:item
7774 				task:item
7781 	gantt._set_default_task_timing = function (task) {  argument
7782 		task.start_date = task.start_date || gantt._defaultTaskDate(task, gantt.getParent(task));
7783 		task.duration = task.duration || gantt.config.duration_step;
7784 		task.end_date = task.end_date || gantt.calculateEndDate(task);
7859 	gantt._get_task_timing_mode = function (task, force) {  argument
7860 		var task_type = this.getTaskType(task.type);
7868 		if (!force && task_type == task.$rendered_type) {
7869 			state.$no_start = task.$no_start;
7870 			state.$no_end = task.$no_end;
7879 			state.$no_end = !(task.end_date || task.duration);
7880 			state.$no_start = !task.start_date;
7882 			if (this._isAllowedUnscheduledTask(task)) {
7890 	gantt._init_task_timing = function (task) {  argument
7891 		var task_mode = gantt._get_task_timing_mode(task, true);
7893 		var dirty = task.$rendered_type != task_mode.type;
7898 			task.$no_start = task_mode.$no_start;
7899 			task.$no_end = task_mode.$no_end;
7900 			task.$rendered_type = task_mode.type;
7906 				this._set_default_task_timing(task);
7911 			task.end_date = task.start_date;
7913 		if (task.start_date && task.end_date) {
7914 			task.duration = this.calculateDuration(task);
7917 		if (!task.end_date) {
7918 			task.end_date = task.start_date;
7921 		task.duration = task.duration || 0;
7924 	gantt.isSummaryTask = function (task) {  argument
7925 …gantt.assert(task && task instanceof Object, "Invalid argument <b>task</b>="+task+" of gantt.isSum…
7927 		var mode = gantt._get_task_timing_mode(task);
7933 	gantt.resetProjectDates = function (task) {  argument
7934 		var taskMode = this._get_task_timing_mode(task);
7936 			var dates = this.getSubtaskDates(task.id);
7937 			this._assign_project_dates(task, dates.start_date, dates.end_date);
7976 	gantt._assign_project_dates = function (task, from, to) {  argument
7977 		var taskTiming = this._get_task_timing_mode(task);
7980 				task.start_date = new Date(from);
7982 				task.start_date = this._defaultTaskDate(task, this.getParent(task));
7988 				task.end_date = new Date(to);
7990 				task.end_date = this.calculateEndDate({
7991 					start_date: task.start_date,
7993 					task: task
7998 			this._init_task_timing(task);
8006 		var task = this.getTask(taskId);
8007 		var pid = this.getParent(task);
8009 		var taskTiming = this._get_task_timing_mode(task);
8014 			var oldStart = task.start_date.valueOf(),
8015 				oldEnd = task.end_date.valueOf();
8017 			gantt.resetProjectDates(task);
8020 			if (oldStart == task.start_date.valueOf() && oldEnd == task.end_date.valueOf()) {
8025 				this.refreshTask(task.id, true);
8101 	gantt.correctTaskWorkTime = function (task) {  argument
8103 			if (!this.isWorkTime(task.start_date, undefined, task)) {
8104 				task.start_date = this.getClosestWorkTime({date: task.start_date, dir: 'future', task: task});
8105 				task.end_date = this.calculateEndDate(task);
8106 			} else if (!this.isWorkTime(new Date(+task.end_date - 1), undefined, task)) {
8107 				task.end_date = this.calculateEndDate(task);
8112 	gantt.attachEvent("onBeforeTaskUpdate", function (id, task) {  argument
8113 		gantt._init_task_timing(task);
8116 	gantt.attachEvent("onBeforeTaskAdd", function (id, task) {  argument
8117 		gantt._init_task_timing(task);
9190         function getTaskLinks(task) {  argument
9192             if (task.$source) {
9193                 _links = _links.concat(task.$source);
9195             if (task.$target) {
9196                 _links = _links.concat(task.$target);
9380 …te = gantt.calculateEndDate({ start_date: objData.start_date, duration: property, task: objData });
9460         var task = gantt.getTask(rowId);
9461         task.$dataprocessor_class = classname;
9954 	tasksStore.attachEvent("onFilterItem", function(id, task) {  argument
9960 			if (gantt._isAllowedUnscheduledTask(task)) return true;
9964 			if (+task.start_date > max || +task.end_date < +min)
9980 		var task = tasksStore.getItem(id);
9981 		for (var i = 0; i < task.$source.length; i++) {
9982 			linksStore.refresh(task.$source[i]);
9984 		for (var i = 0; i < task.$target.length; i++) {
9985 			linksStore.refresh(task.$target[i]);
10188 		var task = null;
10192 			task = tasks[i];
10193 			task.$source = [];
10194 			task.$target = [];
10217 	function _init_task(task) {  argument
10218 		if (!this.defined(task.id))
10219 			task.id = this.uid();
10221 		if (task.start_date)
10222 			task.start_date = gantt.date.parseDate(task.start_date, "parse_date");
10223 		if (task.end_date)
10224 			task.end_date = gantt.date.parseDate(task.end_date, "parse_date");
10228 		if (task.duration || task.duration === 0) {
10229 			task.duration = duration = task.duration * 1;
10233 			if (task.start_date && !task.end_date) {
10234 				task.end_date = this.calculateEndDate(task);
10235 			} else if (!task.start_date && task.end_date) {
10236 				task.start_date = this.calculateEndDate({
10237 					start_date: task.end_date,
10238 					duration: -task.duration,
10239 					task: task
10244 		task.progress = Number(task.progress) || 0;
10246 		if (this._isAllowedUnscheduledTask(task)) {
10247 			this._set_default_task_timing(task);
10249 		this._init_task_timing(task);
10250 		if (task.start_date && task.end_date)
10251 			this.correctTaskWorkTime(task);
10253 		task.$source = [];
10254 		task.$target = [];
10256 		var originalTask = this.$data.tasksStore.getItem(task.id);
10257 		if (originalTask && !utils.defined(task.open)) {
10260 			task.$open = originalTask.$open;
10263 		if (task.parent === undefined) {
10264 			task.parent = this.config.root_id;
10266 		return task;
11223 		var task = this.getTask(taskId);
11224 		if (task && this.isTaskVisible(taskId)) {
11230 			for (var i = 0; i < task.$source.length; i++) {
11231 				this.refreshLink(task.$source[i]);
11233 			for (var i = 0; i < task.$target.length; i++) {
11234 				this.refreshLink(task.$target[i]);
11374 		var task = this.$data.tasksStore.getItem(id);
11375 		this.assert(task, "Task not found id=" + id);
11376 		return task;
11389 				var task = p[t];
11390 				if (+task.start_date < to && +task.end_date > from)
11391 					res.push(task);
11442 		var task = this.$data.tasksStore.getItem(newid);
11446 		if (task.$source) {
11447 			links = links.concat(task.$source);
11449 		if (task.$target) {
11450 			links = links.concat(task.$target);
11475 	setParent: function (task, new_pid, silent) {
11476 		return this.$data.tasksStore.setParent(task, new_pid, silent);
11630 		getTaskPosition: function(task, start_date, end_date) {
11631 			var res = tryCall.call(this, getTimeline, "getItemPosition", [task, start_date, end_date]);
11634 				var top = this.getTaskTop(task.id);
11827 		isWorkTime: function (date, unit, task) {
11828 			return timeCalculator.isWorkTime(date, unit, task);
11835 		calculateDuration: function (start_date, end_date, task) {
11836 			return timeCalculator.calculateDuration(start_date, end_date, task);
11838 		_hasDuration: function (start_date, end_date, task) {
11839 			return timeCalculator.hasDuration(start_date, end_date, task);
11842 		calculateEndDate: function (start, duration, unit, task) {
11843 			return timeCalculator.calculateEndDate(start, duration, unit, task);
12177 				var task = gantt.getTask(id);
12178 				if (gantt.isReadonly(task)) {
12190 					if(task.$new){
12342 	gantt.isSplitTask = function(task){  argument
12343 …gantt.assert(task && task instanceof Object, "Invalid argument <b>task</b>="+task+" of gantt.isSpl…
12344 		return this.$data.tasksStore._isSplitItem(task);
12645 	ConstraintControl.prototype.set_value = function (node, value, task, config) {  argument
12659 		var constraintDate = task[mapping.constraint_date] || new Date();
12662 		var constraintType = task[mapping.constraint_type] || gantt.getConstraintType(task);
12667 	ConstraintControl.prototype.get_value = function (node, task, config) {  argument
12753 			var end_date = gantt.calculateEndDate({start_date: start_date, duration: duration, task: ev});
12809 			task: ev
12814 			task: ev
12826 		var endDate = gantt.calculateEndDate({start_date: startDate, duration: duration, task: ev});
12949 			var task = options[i];
12950 			if (task.id == item_id || gantt.isChildOf(task.id, item_id) || filter(task.id, task) === false) {
13216 				end_date = gantt.calculateEndDate({ start_date: start_date, duration: 1, task: ev });
13232 			task: ev
13311 		var task = this.getTask(id);
13313 		var box = this.getLightbox(this.getTaskType(task.type));
13613 		var task = this.getLightboxValues();
13614 		this.callEvent("onLightboxCancel", [this._lightbox_id, task.$new]);
13615 		if (gantt.isTaskExists(task.id) && task.$new) {
13617 				gantt.$data.tasksStore.removeItem(task.id);
13618 				gantt._update_flags(task.id, null);
13627 		var task = this.getLightboxValues();
13628 		if (!this.callEvent("onLightboxSave", [this._lightbox_id, task, !!task.$new]))
13631 		if (task.$new) {
13632 			delete task.$new;
13633 			this.addTask(task, task.parent, this.getTaskIndex(task.id));
13634 		} else if (this.isTaskExists(task.id)) {
13635 			this.mixin(this.getTask(task.id), task, true);
13636 			this.refreshTask(task.id);
13637 			this.updateTask(task.id);
13664 		var task = {};
13667 			task = this.mixin({}, this.getTask(this._lightbox_id));
13676 			var res = block.get_value.call(this, node, task, sns[i]);
13679 				task[map_to] = res;
13683 						task[map_to[property]] = res[property];
13687 		return task;
13714 		var task = data;
13719 			lightboxHeader.push(gantt.templates.lightbox_header(task.start_date, task.end_date, task));
13721 			s[2].innerHTML = gantt.templates.lightbox_header(task.start_date, task.end_date, task);
13723 			lightboxHeader.push(this.templates.task_time(task.start_date, task.end_date, task));
13724 …lightboxHeader.push(String(this.templates.task_text(task.start_date, task.end_date, task) || "").s…
13725 			s[1].innerHTML = this.templates.task_time(task.start_date, task.end_date, task);
13726 …s[2].innerHTML = String(this.templates.task_text(task.start_date, task.end_date, task) || "").subs…
13745 			var value = this.defined(task[map_to]) ? task[map_to] : section.default_value;
13746 			block.set_value.call(gantt, node, value, task, section);
13755 		var task = this.getTask(id);
13756 		this._set_lightbox_values(task, box);
13997 				task = this.copy(this.getTask(taskId));
14001 			var updTask = this.mixin(task, formData, true);
14165 			set_value: function (node, value, task, section) {  argument
14167 …if (!task[mapping.start_date] || (mapping.start_date == "start_date" && this._isAllowedUnscheduled…
14173 						val[mapping[i]] = task[i];
14179 					return duration.set_value.call(gantt, node, value, task, section);
14182 			get_value: function (node, task, section) {  argument
14186 					return duration.get_value.call(gantt, node, task, section);
14376 	gantt.attachEvent("onBeforeTaskDisplay", function (id, task) {  argument
14377 		return !task.$ignore;
14414 		serializeTask: function (task) {  argument
14415 			return this._copyObject(task);
15046 		var task = gantt.getTask(id);
15047 		var targetType = getTaskTypeToUpdate(task);
15050 			updateTaskType(task, targetType);
15054 	function updateTaskType(task, targetType) {  argument
15056 			task.type = targetType;
15057 			gantt.updateTask(task.id);
15061 	function getTaskTypeToUpdate(task) {  argument
15063 		var hasChildren = gantt.hasChild(task.id);
15064 		var taskType = gantt.getTaskType(task.type);
15066 		if (hasChildren && taskType === allTypes.task) {
15071 			return allTypes.task;
15083 			gantt.eachTask(function(task) {  argument
15084 				var targetType = getTaskTypeToUpdate(task);
15086 					updateTaskType(task, targetType);
15112 	gantt.attachEvent("onBeforeTaskDelete", callIfEnabled(function(id, task) {  argument
15117 	gantt.attachEvent("onAfterTaskDelete", callIfEnabled(function(id, task) {  argument
15426 			"resetProjectDates":function(task){  argument
15427 				resetProjects[task.id] = task;
15734 				newTask.type = gantt.config.types.task;
15754 		gantt.attachEvent("onAfterTaskAdd", callIfEnabled(function(id, task){  argument
15755 			if(task.type != gantt.config.types.placeholder){
15771 			var task = gantt.getTask(taskId);
15772 			if(task.type == gantt.config.types.placeholder){
15844 		gantt.eachTask(function (task) {  argument
15845 			if (filter(task)) {
15846 				res.push(task);
15870 			gantt.eachTask(function (task) {  argument
15871 				if (task.type == gantt.config.types.project) return;
15872 				if (property in task) {
15874 					if (!helpers.isArray(task[property])) {
15875 						resourceValue = [task[property]];
15877 						resourceValue = task[property];
15881 							res.push(task);
15919 			var task = tasks[i];
15921 			var currDate = gantt.date[scaleUnit + "_start"](new Date(task.start_date));
15923 			while (currDate < task.end_date) {
15928 				if (!gantt.isWorkTime({date: date, task: task, unit: scaleUnit})) {
15937 				timegrid[timestamp].push(task);
16307 			var task = gantt.getTask(taskId);
16308 			owners = task[property] || [];
16316 				result.push({task_id: task.id, resource_id:owners[i].resource_id, value:owners[i].value});
16331 			tasks.forEach(function(task){  argument
16332 				selectAssignments(resourceId, task.id, assignments);
16697 	_getWBSCode: function(task) {
16698 		if(!task) return "";
16704 		if(task.$virtual) return "";
16705 		if(this._isGroupSort()) return task.$wbs || "";
16707 		if(!task.$wbs) {
16711 		return task.$wbs;
16713 	_setWBSCode: function(task, value) {
16714 		task.$wbs = value;
16716 	getWBSCode: function(task) {
16717 		return this._getWBSCode(task);
16768 	gantt.getWBSCode = function getWBSCode(task) {  argument
16769 		return wbs.getWBSCode(task);
17150 			var task = gantt.getTask(taskId);
17151 			if (task && gantt.isTaskVisible(taskId)) {
17153 					task = renders[i].rendered[taskId];
17154 …if (task && task.getAttribute(gantt.config.task_attribute) && task.getAttribute(gantt.config.task_…
17155 						var copy = task.cloneNode(true);
17156 						current_target = task;
17158 						task.style.display = "none";
17160 						task.parentNode.appendChild(copy);
17762 					var task = this.moveRow(1);
17765 						this.startEdit(task, cell);
17778 					var task = this.moveRow(-1);
17781 						this.startEdit(task, cell);
18114 	function formatPredecessors(task, config, gantt) {  argument
18115 		var links = task.$target;
18142 	function getLinksDiff(task, predecessorCodes, config) {  argument
18143 		var selectedLinks = getSelectedLinks(task.id, predecessorCodes, config);
18145 		task.$target.forEach(function (linkId) {
18185 			var task = gantt.getTask(id);
18187 			var linksDiff = getLinksDiff(task, this.get_value(id, column, node), column.editor);
18696 				task: item
19440 						var task = this.getTask(id);
19442 							this.showDate(task.start_date);
19579 		var task = datastore.getItem(id);
19581 		if (gantt.isReadonly(task))
19584 		dnd.config.initial_open_state = task.$open;
19603 		var task = store.getItem(dnd.config.id);
19605 		dnd.config.parent = task.parent;
19606 		task.$open = false;
19607 		task.$transparent = true;
19767 		var task = store.getItem(dnd.config.id);
19768 		task.$transparent = false;
19769 		task.$open = dnd.config.initial_open_state;
19773 			task.$drop_target = null;
19775 			this.callEvent("onRowDragEnd", [dnd.config.id, task.$drop_target]);
19826 		var task = datastore.getItem(id);
19828 		if (gantt.isReadonly(task))
19831 		dnd.config.initial_open_state = task.$open;
19853 		var task = store.getItem(dnd.config.id);
19854 		dnd.config.level = store.calculateItemLevel(task);
19856 			targetParent: store.getParent(task.id),
19857 			targetIndex: store.getBranchIndex(task.id),
19858 			targetId: task.id,
19862 		task.$open = false;
19863 		task.$transparent = true;
19927 		var task = store.getItem(dnd.config.id);
19931 		task.$transparent = false;
19932 		task.$open = dnd.config.initial_open_state;
19936 			task.$drop_target = null;
19941 		store.refresh(task.id);
23347 function getMilestonePosition(task, view){  argument
23349 	var pos = view.getItemPosition(task);
23350 	if(gantt.getTaskType(task.type) == config.types.milestone){
23617 	function _render_task_element(task, view) {  argument
23620 		var renderer = painters[gantt.getTaskType(task.type)],
23624 			return defaultRenderer.call(gantt, task, view);
23626 …return renderer.call(gantt, task, function(task){ return defaultRenderer.call(gantt, task, view);}…  argument
23630 	function _task_default_render(task, view) {  argument
23631 		if (gantt._isAllowedUnscheduledTask(task))
23634 		if (!gantt._isTaskInTimelineLimits(task)) {
23638 		var pos = view.getItemPosition(task);
23644 		var taskType = gantt.getTaskType(task.type);
23662 			div.setAttribute(view.$config.item_attribute, task.id);
23666 			_render_task_progress(task, div, width, cfg, templates);
23670 		var content = _render_task_content(task, width, templates);
23671 		if (task.textColor) {
23672 			content.style.color = task.textColor;
23677 			templates.task_class(task.start_date, task.end_date, task),
23678 			task.id,
23680 		if (task.color || task.progressColor || task.textColor) {
23692 		if (task.color) {
23693 			styles.push("background-color:" + task.color);
23695 		if (task.textColor) {
23696 			styles.push("color:" + task.textColor);
23700 		var side = _render_leftside_content(task, cfg, templates);
23703 		side = _render_rightside_content(task, cfg, templates);
23706 		gantt._waiAria.setTaskBarAttr(task, div);
23710 		if (!gantt.isReadonly(task)) {
23711 			if (cfg.drag_resize && !gantt.isSummaryTask(task) && taskType != cfg.types.milestone) {
23712 				_render_pair(div, "gantt_task_drag", task, function (css) {
23719 				_render_pair(div, "gantt_link_control", task, function (css) {
23743 	function _render_side_content(task, template, cssClass) {  argument
23746 		var text = template(task.start_date, task.end_date, task);
23754 	function _render_leftside_content(task, cfg, templates) {  argument
23755 		var css = "gantt_left " + _get_link_crossing_css(!cfg.rtl ? true : false, task, cfg);
23756 		return _render_side_content(task, templates.leftside_text, css);
23759 	function _render_rightside_content(task, cfg, templates) {  argument
23760 		var css = "gantt_right " + _get_link_crossing_css(!cfg.rtl ? false : true, task, cfg);
23761 		return _render_side_content(task, templates.rightside_text, css);
23764 	function _get_link_crossing_css(left, task) {  argument
23768 			var links = task[i];
23783 	function _render_task_content(task, width, templates) {  argument
23785 		if (gantt.getTaskType(task.type) != gantt.config.types.milestone)
23786 			content.innerHTML = templates.task_text(task.start_date, task.end_date, task);
23792 	function _render_task_progress(task, element, maxWidth, cfg, templates) {  argument
23793 		var done = task.progress * 1 || 0;
23800 		if (task.progressColor) {
23801 			pr.style.backgroundColor = task.progressColor;
23806 		pr.innerHTML = templates.progress_text(task.start_date, task.end_date, task);
23818 		if (gantt.config.drag_progress && !gantt.isReadonly(task)) {
23865 		var task = gantt.getTask(itemId);
23867 		if (gantt.getTaskType(task.type) == cfg.types.milestone) {
23869 		}else if (gantt.getTaskType(task.type) == cfg.types.project) {
23873 		css.push("gantt_bar_" + gantt.getTaskType(task.type));
23876 		if (gantt.isSummaryTask(task))
23879 		if (gantt.isSplitTask(task) && ((cfg.open_split_tasks && !task.$open) || !cfg.open_split_tasks)) {
23902 			if (gantt.isCriticalTask(task))
23933 	function _render_pair(parent, css, task, content, config) {  argument
23936 		if (+task.start_date >= +state.min_date) {
23943 		if (+task.end_date <= +state.max_date){
24346 	function renderSplitTask(task, timeline) {  argument
24347 …if (gantt.isSplitTask(task) && ((gantt.config.open_split_tasks && !task.$open) || !gantt.config.op…
24349 				sizes = gantt.getTaskPosition(task);
24351 			var sub_tasks = gantt.getChildren(task.id);
24600 	function isMilestone(task) {  argument
24601 		return gantt.getTaskType(task.type) == gantt.config.types.milestone;
24663 	function getLinePos(task, to_start, shift, cfg, isStart){  argument
24664 …var taskPos = getMilestonePosition(task, function(task){ return gantt.getTaskPosition(task);}, cfg…  argument
24674 		var offset = isMilestone(task) && isStart ? 2 : 0;
24684 	function getMilestonePosition(task, getTaskPosition, cfg){  argument
24685 		var pos = getTaskPosition(task);
24702 		if(gantt.getTaskType(task.type) == gantt.config.types.milestone){
25117 						task = this.getTask(id);
25122 							link = task.$target[0];
25124 							link = task.$source[0];
25657 		_resize: function(task, shift, drag) {
25659 			var coords_x = this._drag_task_coords(task, drag);
25661 				task.start_date = gantt.dateFromPos(coords_x.start + shift);
25662 				if (!task.start_date) {
25663 					task.start_date = new Date(gantt.getState().min_date);
25666 				task.end_date = gantt.dateFromPos(coords_x.end + shift);
25667 				if (!task.end_date) {
25668 					task.end_date = new Date(gantt.getState().max_date);
25673 			if (task.end_date - task.start_date < cfg.min_duration) {
25675 …task.start_date = gantt.calculateEndDate(task.end_date, -minDurationInUnits, cfg.duration_unit, ta…
25677 …task.end_date = gantt.calculateEndDate(task.start_date, minDurationInUnits, cfg.duration_unit, tas…
25679 			gantt._init_task_timing(task);
25692 		_resize_progress: function(task, shift, drag) {
25693 			var coords_x = this._drag_task_coords(task, drag);
25699 			task.progress = Math.min(1, diff / Math.abs(coords_x.end - coords_x.start));
25705 				var task = gantt.getTask(drag.id);
25707 				var coords_x = this._drag_task_coords(task, drag);
25725 		_move: function(task, shift, drag) {
25726 			var coords_x = this._drag_task_coords(task, drag);
25730 				task.start_date = new Date(gantt.getState().min_date);
25731 …task.end_date = gantt.dateFromPos(gantt.posFromDate(task.start_date) + (coords_x.end - coords_x.st…
25733 				task.end_date = new Date(gantt.getState().max_date);
25734 …task.start_date = gantt.dateFromPos(gantt.posFromDate(task.end_date) - (coords_x.end - coords_x.st…
25736 				task.start_date = new_start;
25737 				task.end_date = new_end;
25785 			var task = gantt.getTask(id);
25786 			var original = gantt.mixin({}, task);
25787 			var copy = gantt.mixin({}, task);
25789 			gantt.mixin(task, copy, true);
25791 			gantt.callEvent("onTaskDrag", [task.id, mode, copy, original, e]);
25792 			gantt.mixin(task, copy, true);
25812 				var task = gantt.getTask(drag.id);
25823 						if (gantt.isSummaryTask(task) && gantt.config.drag_project) {
25856 			var task = null;
25858 				task = gantt.getTask(id);
25861 			if (gantt.isReadonly(task) || this.drag.mode) return;
25886 					task = gantt.copy(gantt.getTask(id) || {});
25888 					if (gantt.isReadonly(task)) {
25893 …if ((gantt.isSummaryTask(task) && !config.drag_project) && drag.mode != config.drag_mode.progress)…
25903 					drag.obj = task;
25911 		_fix_dnd_scale_time: function(task, drag) {
25920 			function fixStart(task) {  argument
25924 				if (!gantt.isWorkTime(task.start_date, undefined, task))
25925 					task.start_date = gantt.calculateEndDate({
25926 						start_date: task.start_date,
25929 						task: task
25933 			function fixEnd(task) {  argument
25937 				if (!gantt.isWorkTime(new Date(task.end_date - 1), undefined, task))
25938 					task.end_date = gantt.calculateEndDate({
25939 						start_date: task.end_date,
25942 						task: task
25948 					task.start_date = gantt.roundDate({date: task.start_date, unit: unit, step: step});
25949 					fixStart(task);
25951 					task.end_date = gantt.roundDate({date: task.end_date, unit: unit, step: step});
25952 					fixEnd(task);
25955 				task.start_date = gantt.roundDate({date: task.start_date, unit: unit, step: step});
25956 				fixStart(task);
25957 				task.end_date = gantt.calculateEndDate(task);
25960 		_fix_working_times: function(task, drag) {
25966 					task.start_date = gantt.getClosestWorkTime({date: task.start_date, dir: 'future', task: task});
25968 					task.end_date = gantt.getClosestWorkTime({date: task.end_date, dir: 'past', task: task});
25971 				gantt.correctTaskWorkTime(task);
25976 			var task = gantt.getTask(taskId);
25979 				this._fix_working_times(task, drag);
25982 			this._fix_dnd_scale_time(task, drag);
25989 					gantt.mixin(task, drag.obj, true);
25993 				gantt.refreshTask(task.id);
25997 				gantt._init_task_timing(task);
26000 				gantt.updateTask(task.id);
26012 				var task = gantt.getTask(drag.id);
26016 					if ((gantt.isSummaryTask(task) && config.drag_project) || (this._isMultiselect())) {
26074 				var task = gantt.getTask(id);
26075 				if (gantt.isReadonly(task)){
26096 				if (gantt.isSummaryTask(task) && gantt.config.drag_project && drag.mode == cfg.drag_mode.move) {
26097 					this._addSubtasksToDragMultiple(task.id);
26118 		round_task_dates: function(task) {
26124 			this._fix_dnd_scale_time(task, drag_state);
26147 			timeline.roundTaskDates = function(task) {  argument
26148 				_tasks_dnd.round_task_dates(task);
26800 	getItemPosition:function (task, start_date, end_date) {
26803 			xRight = this.posFromDate(start_date || task.start_date);
26804 			xLeft = this.posFromDate(end_date || task.end_date);
26806 			xLeft = this.posFromDate(start_date || task.start_date);
26807 			xRight = this.posFromDate(end_date || task.end_date);
26811 		var y = this.getItemTop(task.id);
27118 		_taskCommonAttr: function(task, div){  argument
27120 			if(!(task.start_date && task.end_date))
27123 …e("aria-label", stripHTMLLite(gantt.templates.tooltip_text(task.start_date, task.end_date, task)));
27125 			if(task.$dataprocessor_class){
27129 			div.setAttribute("aria-selected", gantt.isSelectedTask(task.id) ? "true" : "false");
27132 		setTaskBarAttr: function(task, div){  argument
27133 			this._taskCommonAttr(task, div);
27135 			if(!gantt.isReadonly(task) && gantt.config.drag_move){
27136 				if(task.id != gantt.getState().drag_id){
27144 		taskRowAttr: function(task, div){  argument
27146 			this._taskCommonAttr(task, div);
27148 			if(!gantt.isReadonly(task) && gantt.config.order_branch){
27154 			div.setAttribute("aria-level", task.$level);
27156 			if(gantt.hasChild(task.id)){
27157 				div.setAttribute("aria-expanded", task.$open ? "true" : "false");
27266 		gridCellAttrString: function(column, textValue, task){  argument
27268 			if(!column.editor || gantt.isReadonly(task)){
27357 function IsWorkTimeArgument(date, unit, task, id, calendar){  argument
27360 	this.task = task;
27366 function ClosestWorkTimeArgument(date, dir, unit, task, id, calendar){  argument
27370 	this.task = task;
27376 function CalculateEndDateArgument(start_date, duration, unit, step, task, id, calendar){  argument
27381 	this.task = task;
27387 function GetDurationArgument(start, end, task, calendar) {  argument
27390 	this.task = task;
27433 …processedConfig = new IsWorkTimeArgument(config.date, config.unit, config.task, null, config.calen…
27459 					config.task,
27466 				processedConfig.task = config;
27487 				config = new argumentType(param.start_date, param.end_date, param.task);
27489 					config.task = param;
27542 					config.task,
27548 				processedConfig.task = config;
27705 	_getOwnCalendar: function(task){  argument
27707 		if (task[config.calendar_property]) {
27708 			return this.getCalendar(task[config.calendar_property]);
27714 				if (task[field]) {
27715 					var calendarId = resource[task[field]];
27725 	getTaskCalendar: function (task) {  argument
27726 		if (!task) {
27730 		var calendar = this._getOwnCalendar(task);
27732 		if (!calendar && gantt.config.inherit_calendar && gantt.isTaskExists(task.parent)){
27742 			}, task.id, this);
28659 			if (config.task) {
28660 				calendar = manager.getTaskCalendar(config.task);
28696 	isWorkTime: function (date, unit, task, calendar) {  argument
29943 function copyLinkIds(gantt, task, targetHash){  argument
29944 	copyLinkIdsArray(gantt, task.$source, targetHash);
29945 	copyLinkIdsArray(gantt, task.$target, targetHash);