1509 lines
52 KiB
JavaScript
1509 lines
52 KiB
JavaScript
/* Copyright 2005 - 2015 Annpoint, s.r.o.
|
|
Use of this software is subject to license terms.
|
|
http://www.daypilot.org/
|
|
*/
|
|
|
|
if (typeof DayPilot === 'undefined') {
|
|
var DayPilot = {};
|
|
}
|
|
|
|
if (typeof DayPilot.Global === 'undefined') {
|
|
DayPilot.Global = {};
|
|
}
|
|
|
|
(function() {
|
|
|
|
|
|
if (typeof DayPilot.Gantt !== 'undefined') {
|
|
return;
|
|
}
|
|
|
|
var doNothing = function() { };
|
|
|
|
DayPilot.Gantt = function(id, options) {
|
|
this.v = '1658';
|
|
|
|
var calendar = this;
|
|
this.id = id; // referenced
|
|
this.isGantt = true;
|
|
|
|
var scheduler = new DayPilot.Scheduler(id);
|
|
this.scheduler = scheduler;
|
|
|
|
// scheduler setup
|
|
scheduler.viewType = "Resources";
|
|
//scheduler.taskMoveHandling = "Update";
|
|
//scheduler.linksEnabled = true;
|
|
|
|
scheduler.onCallBackHeader = function(args) {
|
|
args.header.taskGroupMode = calendar.taskGroupMode;
|
|
args.header.rowHeaderColumns = calendar.columns;
|
|
args.header.clientState = calendar.clientState;
|
|
};
|
|
|
|
scheduler.onGetNodeState = function(args) {
|
|
|
|
var getTags = function(task) {
|
|
var result = {};
|
|
if (task.tags) {
|
|
for (var name in task.tags) {
|
|
result[name] = "" + task.tags[name];
|
|
}
|
|
}
|
|
return result;
|
|
};
|
|
|
|
|
|
var getNode = function(row) {
|
|
var task = row.task;
|
|
|
|
var result = {};
|
|
result.start = task.start;
|
|
result.end = task.end;
|
|
result.id = task.id;
|
|
result.complete = task.complete;
|
|
result.text = task.text;
|
|
result.type = task.type;
|
|
result.expanded = row.expanded;
|
|
result.loaded = row.loaded;
|
|
result.tags = getTags(task);
|
|
|
|
result.children = scheduler.internal.getNodeChildren(row.children);
|
|
|
|
return result;
|
|
};
|
|
|
|
args.result = getNode(args.row);
|
|
args.preventDefault();
|
|
};
|
|
|
|
|
|
scheduler.onCallBackResult = function(args) {
|
|
var result = args.result;
|
|
args.preventDefault();
|
|
|
|
if (result.updateType === "None") {
|
|
return;
|
|
}
|
|
|
|
var update = function(list) {
|
|
for (var i = 0; i < list.length; i++) {
|
|
var name = list[i];
|
|
if (typeof result[name] !== "undefined") {
|
|
calendar[name] = result[name];
|
|
}
|
|
}
|
|
};
|
|
|
|
// data
|
|
calendar.links.list = result.links;
|
|
calendar.tasks.list = result.tasks;
|
|
|
|
// callback-changeable properties
|
|
calendar.startDate = new DayPilot.Date(result.startDate);
|
|
update(['days', 'cellDuration', 'cellGroupBy', 'cellWidth', 'cellWidthSpec', 'cornerHtml', 'separators', 'rowMinHeight', 'rowMarginBottom', 'taskGroupMode']);
|
|
|
|
// server-generated properties
|
|
update(['cellProperties', 'cellConfig', 'timeHeader', 'timeHeaders', 'timeline', 'columns']);
|
|
/*
|
|
calendar.cellProperties = result.cellProperties;
|
|
calendar.cellConfig = result.cellConfig;
|
|
calendar.timeHeader = result.timeHeader;
|
|
calendar.timeHeaders = result.timeHeaders;
|
|
calendar.timeline = result.timeline;
|
|
*/
|
|
|
|
wrap.translate();
|
|
wrap._loadTasks();
|
|
wrap._loadLinks();
|
|
scheduler.update();
|
|
scheduler.show();
|
|
};
|
|
|
|
// default properties
|
|
this.taskGroupMode = "Auto"; // behavior of task groups/parent nodes
|
|
|
|
// translated scheduler properties
|
|
this.autoRefreshCommand = "refresh";
|
|
this.autoRefreshEnabled = false;
|
|
this.autoRefreshInterval = 60;
|
|
this.autoRefreshMaxCount = 20;
|
|
this.autoScroll = "Drag";
|
|
this.bubbleTask = null;
|
|
this.bubbleCell = null;
|
|
this.bubbleRow = null;
|
|
this.cellDuration = 1440;
|
|
this.cellGroupBy = "Month";
|
|
this.cellWidth = 40;
|
|
this.cellWidthSpec = "Fixed";
|
|
this.completeBarVisible = true;
|
|
this.completeBarHeight = 3;
|
|
this.contextMenuTask = null;
|
|
this.contextMenuRow = null;
|
|
this.contextMenuLink = null;
|
|
this.cornerHtml = '';
|
|
this.crosshairColor = 'Gray';
|
|
this.crosshairOpacity = 20;
|
|
this.crosshairType = 'Header';
|
|
this.doubleClickTimeout = 300;
|
|
this.progressiveTaskRendering = 'Progressive';
|
|
this.progressiveTaskRenderingMargin = 500;
|
|
this.progressiveTaskRenderingCacheSweeping = false;
|
|
this.progressiveTaskRenderingCacheSize = 200;
|
|
this.floatingTasks = true;
|
|
this.floatingTimeHeaders = true;
|
|
this.headerHeight = 20;
|
|
this.height = 300;
|
|
this.heightSpec = "Max";
|
|
this.hideUntilInit = false;
|
|
this.linkBottomMargin = 10;
|
|
this.loadingLabelVisible = true;
|
|
this.loadingLabelText = "Loading...";
|
|
this.locale = "en-us";
|
|
this.messageBarPosition = "Top";
|
|
this.messageHideAfter = 5000;
|
|
this.numberFormat = "0.00";
|
|
this.progressiveRowRendering = true;
|
|
this.progressiveRowRenderingPreload = 25;
|
|
this.rowHeaderScrolling = false;
|
|
this.rowHeaderSplitterWidth = 3;
|
|
this.rowHeaderHideIconEnabled = true;
|
|
this.rowHeaderWidth = 80;
|
|
this.rowHeaderWidthAutoFit = true;
|
|
this.rowMarginBottom = 4;
|
|
this.rowMinHeight = 0;
|
|
this.scrollDelayTasks = 200;
|
|
this.scrollDelayCells = 20;
|
|
this.scrollDelayFloats = 0;
|
|
this.scale = "Day";
|
|
this.snapToGrid = true;
|
|
this.syncTasks = true;
|
|
this.syncLinks = true;
|
|
this.tapAndHoldTimeout = 500;
|
|
this.taskHeight = 24;
|
|
this.taskResizeMargin = 5;
|
|
this.taskMovingStartEndEnabled = false;
|
|
this.taskMovingStartEndFormat = "MMMM d, yyyy";
|
|
this.taskResizingStartEndEnabled = false;
|
|
this.taskResizingStartEndFormat = "MMMM d, yyyy";
|
|
this.theme = "gantt_default";
|
|
this.treeAutoExpand = true;
|
|
this.treeIndent = 20;
|
|
this.treeImageMarginLeft = 5;
|
|
this.treeImageMarginTop = 5;
|
|
//this.timeHeaders = [ { "groupBy": "Default" }, {"groupBy": "Cell" }];
|
|
this.timeline = null;
|
|
this.timeHeaders = [ { "groupBy": "Month", "format": "MMMM yyyy"}, { "groupBy": "Day", "format": "d"}];
|
|
this.useEventBoxes = "Never";
|
|
this.visible = true;
|
|
|
|
// event handling
|
|
this.taskMoveHandling = "Update";
|
|
this.taskClickHandling = "Enabled";
|
|
this.taskResizeHandling = "Update";
|
|
this.linkCreateHandling = "Update";
|
|
this.taskRightClickHandling = "ContextMenu";
|
|
this.taskDoubleClickHandling = "Disabled";
|
|
//this.taskDeleteHandling = "Update";
|
|
this.rowCreateHandling = "Disabled";
|
|
this.rowMoveHandling = "Update";
|
|
this.rowClickHandling = "Disabled";
|
|
this.rowDoubleClickHandling = "Disabled";
|
|
this.rowEditHandling = "Update";
|
|
this.rowSelectHandling = "Update";
|
|
|
|
this.separators = [];
|
|
|
|
this.members = {};
|
|
this.members.obsolete = [];
|
|
this.members.ignore = [
|
|
"members",
|
|
"scheduler",
|
|
"internal",
|
|
"cellProperties"
|
|
];
|
|
this.members.noCssOnly = [];
|
|
|
|
this.links = {};
|
|
this.links.list = [];
|
|
this.links.add = function(link) {
|
|
if (!link) {
|
|
return;
|
|
}
|
|
var data = link.isLink ? link.data : link;
|
|
calendar.links.list.push(data);
|
|
|
|
if (calendar._initialized) {
|
|
wrap._loadLinks();
|
|
scheduler.update();
|
|
}
|
|
|
|
calendar._angular.notify();
|
|
|
|
};
|
|
|
|
this.links.remove = function(link) {
|
|
if (!link) {
|
|
return;
|
|
}
|
|
|
|
var data;
|
|
if (link.isLink) {
|
|
data = link.data;
|
|
}
|
|
else {
|
|
data = link;
|
|
}
|
|
|
|
var index = DayPilot.indexOf(calendar.links.list, data);
|
|
|
|
if (index === -1) {
|
|
return;
|
|
}
|
|
|
|
calendar.links.list.splice(index, 1);
|
|
if (calendar._initialized) {
|
|
wrap._loadLinks();
|
|
scheduler.update();
|
|
}
|
|
|
|
calendar._angular.notify();
|
|
};
|
|
|
|
this.links.find = function(id) {
|
|
if (!DayPilot.isArray(calendar.links.list)) {
|
|
return null;
|
|
}
|
|
for (var i = 0; i < calendar.links.list.length; i++) {
|
|
var link = calendar.links.list[i];
|
|
if (link.id === id) {
|
|
return new DayPilot.Link(link, calendar);
|
|
}
|
|
}
|
|
return null;
|
|
};
|
|
|
|
this.links.findFromTo = function(from, to) {
|
|
if (!DayPilot.isArray(calendar.links.list)) {
|
|
return null;
|
|
}
|
|
for (var i = 0; i < calendar.links.list.length; i++) {
|
|
var link = calendar.links.list[i];
|
|
if (link.from === from && link.to === to) {
|
|
return new DayPilot.Link(link, calendar);
|
|
}
|
|
}
|
|
return null;
|
|
};
|
|
|
|
this._refresh = {};
|
|
var refresh = this._refresh;
|
|
|
|
refresh.timeout = null;
|
|
refresh.update = function() {
|
|
if (!calendar._initialized) {
|
|
return;
|
|
}
|
|
|
|
window.clearTimeout(refresh.timeout);
|
|
|
|
refresh.timeout = setTimeout(function() {
|
|
wrap._loadTasks();
|
|
scheduler.update();
|
|
}, 0);
|
|
};
|
|
|
|
this.tasks = {};
|
|
this.tasks.list = [];
|
|
this.tasks.add = function(task) {
|
|
if (!task) {
|
|
return;
|
|
}
|
|
if (task instanceof DayPilot.Event) {
|
|
throw "DayPilot.Task object required. You have supplied DayPilot.Event.";
|
|
}
|
|
var data = task.isTask ? task.data : task;
|
|
calendar.tasks.list.push(data);
|
|
|
|
refresh.update();
|
|
|
|
calendar._angular.notify();
|
|
};
|
|
|
|
this.tasks.find = function(id) {
|
|
var data = tasktools.findInCache(id);
|
|
if (!data) {
|
|
return null;
|
|
}
|
|
return new DayPilot.Task(data, calendar);
|
|
};
|
|
|
|
this.tasks.update = function(task) {
|
|
// commit
|
|
if (!task) {
|
|
return;
|
|
}
|
|
if (!task.isTask) {
|
|
throw "DayPilot.Task object expected";
|
|
}
|
|
|
|
task.commit();
|
|
|
|
refresh.update();
|
|
|
|
calendar._angular.notify();
|
|
|
|
};
|
|
|
|
|
|
/**
|
|
* Removes a task, including children.
|
|
* @param task
|
|
*/
|
|
this.tasks.remove = function(task) {
|
|
if (!task) {
|
|
return;
|
|
}
|
|
if (!task.isTask) {
|
|
throw "DayPilot.Task object expected";
|
|
}
|
|
var parentArray = tasktools.findParentArray(task.data);
|
|
if (!parentArray) {
|
|
return;
|
|
}
|
|
|
|
var sourceIndex = DayPilot.indexOf(parentArray, task.data);
|
|
parentArray.splice(sourceIndex, 1);
|
|
|
|
refresh.update();
|
|
|
|
calendar._angular.notify();
|
|
};
|
|
|
|
this.visibleStart = function() {
|
|
return scheduler.visibleStart();
|
|
};
|
|
|
|
this.visibleEnd = function() {
|
|
return scheduler.visibleEnd();
|
|
};
|
|
|
|
// events
|
|
this.onAfterRender = null;
|
|
this.onBeforeRowHeaderRender = null;
|
|
this.onBeforeTaskRender = null;
|
|
this.onBeforeTimeHeaderRender = null;
|
|
this.onBeforeCellRender = null;
|
|
this.onTaskClick = null;
|
|
this.onTaskClicked = null;
|
|
this.onTaskDoubleClick = null;
|
|
this.onTaskDoubleClicked = null;
|
|
this.onTaskRightClick = null;
|
|
this.onTaskRightClicked = null;
|
|
this.onRowCreate = null;
|
|
this.onRowCreated = null;
|
|
this.onRowMove = null;
|
|
this.onRowMoved = null;
|
|
this.onRowMoving = null;
|
|
this.onRowClick = null;
|
|
this.onRowClicked = null;
|
|
this.onRowDoubleClick = null;
|
|
this.onRowDoubleClicked = null;
|
|
this.onRowEdit = null;
|
|
this.onRowEdited = null;
|
|
this.onRowSelect = null;
|
|
this.onRowSelected = null;
|
|
this.onTaskMove = null;
|
|
this.onTaskMoved = null;
|
|
this.onTaskMoving = null;
|
|
this.onTaskResize = null;
|
|
this.onTaskResized = null;
|
|
this.onTaskResizing = null;
|
|
this.onLinkCreate = null;
|
|
this.onLinkCreated = null;
|
|
|
|
this._serverBased = function() {
|
|
if (this.backendUrl) { // ASP.NET MVC, Java
|
|
return true;
|
|
}
|
|
if (typeof WebForm_DoCallback === 'function' && this.uniqueID) { // ASP.NET WebForms
|
|
return true;
|
|
}
|
|
return false;
|
|
};
|
|
|
|
this._setStartDate = function() {
|
|
if (typeof calendar.startDate === "string") {
|
|
calendar.startDate = new DayPilot.Date(calendar.startDate);
|
|
}
|
|
|
|
if (calendar.startDate && calendar.days) {
|
|
return;
|
|
}
|
|
|
|
var startTicks = null;
|
|
var endTicks = null;
|
|
for (var i = 0; i < calendar.tasks.list.length; i++) {
|
|
var e = calendar.tasks.list[i];
|
|
var start = new DayPilot.Date(e.start);
|
|
var end = new DayPilot.Date(e.end);
|
|
if (startTicks === null || start.getTime() < startTicks) {
|
|
startTicks = start.getTime();
|
|
}
|
|
if (endTicks === null || end.getTime() > endTicks) {
|
|
endTicks = end.getTime();
|
|
}
|
|
}
|
|
|
|
if (startTicks && endTicks) {
|
|
var start = new DayPilot.Date(startTicks).getDatePart();
|
|
var end = new DayPilot.Date(endTicks).getDatePart().addDays(1);
|
|
|
|
scheduler.startDate = calendar.startDate || start;
|
|
scheduler.days = calendar.days || DayPilot.Date.daysDiff(start, end);
|
|
}
|
|
else {
|
|
scheduler.startDate = calendar.startDate;
|
|
scheduler.days = calendar.days;
|
|
}
|
|
};
|
|
|
|
this.commandCallBack = function(command, data) {
|
|
wrap.translate();
|
|
scheduler.commandCallBack(command, data);
|
|
};
|
|
|
|
this.message = function(html, delay, foreColor, backColor) {
|
|
scheduler.message(html, delay, foreColor, backColor);
|
|
};
|
|
|
|
this.setHeight = function(pixels) {
|
|
scheduler.setHeight(pixels);
|
|
};
|
|
|
|
this._isShortInit = function() {
|
|
// make sure it has a place to ask
|
|
if (this.backendUrl) {
|
|
return !DayPilot.isArray(calendar.tasks.list) || calendar.tasks.list.length == 0;
|
|
}
|
|
else {
|
|
return false;
|
|
}
|
|
};
|
|
|
|
|
|
this.init = function() {
|
|
wrap.translate();
|
|
wrap._loadTasks();
|
|
wrap._loadLinks();
|
|
this._setStartDate();
|
|
|
|
scheduler.init();
|
|
this._initialized = true;
|
|
|
|
this._postInit();
|
|
|
|
if (this._isShortInit()) {
|
|
scheduler.internal.callback('Init');
|
|
}
|
|
};
|
|
|
|
this.update = function() {
|
|
wrap.translate();
|
|
wrap._loadTasks();
|
|
wrap._loadLinks();
|
|
calendar._setStartDate();
|
|
scheduler.update();
|
|
};
|
|
|
|
this.scrollTo = function(target) {
|
|
scheduler.scrollTo(target);
|
|
};
|
|
|
|
this._tasktools = {};
|
|
var tasktools = this._tasktools;
|
|
|
|
tasktools.cache = {};
|
|
|
|
tasktools.clearCache = function() {
|
|
tasktools.cache = {};
|
|
};
|
|
|
|
tasktools.addToCache = function(data, parent) {
|
|
// cache
|
|
var key = data.id;
|
|
|
|
if (!key) {
|
|
return;
|
|
}
|
|
|
|
var wrapper = {};
|
|
wrapper.isTaskWrapper = true;
|
|
wrapper.data = data;
|
|
wrapper.parent = parent;
|
|
|
|
if (tasktools.cache[key]) {
|
|
throw "Duplicate task id detected";
|
|
}
|
|
|
|
tasktools.cache[key] = wrapper;
|
|
|
|
};
|
|
|
|
tasktools.findInCache = function(id) {
|
|
if (!id) {
|
|
return null;
|
|
}
|
|
return tasktools.cache[id.toString()];
|
|
};
|
|
|
|
tasktools.getProperty = function(task, name) {
|
|
if (task.tags && task.tags[name]) {
|
|
return task.tags[name];
|
|
}
|
|
return task[name];
|
|
};
|
|
|
|
tasktools.findParentArray = function(res) {
|
|
return tasktools.findInArray(calendar.tasks.list, res);
|
|
};
|
|
|
|
tasktools.findInArray = function(array, res) {
|
|
if (DayPilot.indexOf(array, res) !== -1) {
|
|
return array;
|
|
}
|
|
for(var i = 0; i < array.length; i++) {
|
|
var r = array[i];
|
|
if (r.children && r.children.length > 0) {
|
|
var parent = tasktools.findInArray(r.children, res);
|
|
if (parent) {
|
|
return parent;
|
|
}
|
|
}
|
|
}
|
|
return null;
|
|
};
|
|
|
|
this._wrap = {};
|
|
var wrap = this._wrap;
|
|
|
|
var coalesce = function(p, val) {
|
|
if (typeof p !== "undefined") {
|
|
return p;
|
|
}
|
|
return val;
|
|
};
|
|
|
|
wrap.translate = function() {
|
|
|
|
// settings
|
|
// fixed
|
|
scheduler.durationBarMode = "PercentComplete";
|
|
scheduler.timeRangeSelectedHandling = "Disabled";
|
|
scheduler.treeEnabled = true;
|
|
|
|
// variable
|
|
scheduler.autoRefreshCommand = calendar.autoRefreshCommand;
|
|
scheduler.autoRefreshEnabled = calendar.autoRefreshEnabled;
|
|
scheduler.autoRefreshInterval = calendar.autoRefreshInterval;
|
|
scheduler.autoRefreshMaxCount = calendar.autoRefreshMaxCount;
|
|
scheduler.autoScroll = calendar.autoScroll;
|
|
scheduler.backendUrl = calendar.backendUrl;
|
|
scheduler.crosshairColor = calendar.crosshairColor;
|
|
scheduler.crosshairOpacity = calendar.crosshairOpacity;
|
|
scheduler.crosshairType = calendar.crosshairType;
|
|
scheduler.doubleClickTimeout = calendar.doubleClickTimeout;
|
|
scheduler.durationBarVisible = calendar.completeBarVisible;
|
|
scheduler.durationBarHeight = calendar.completeBarHeight;
|
|
scheduler.dynamicEventRendering = calendar.progressiveTaskRendering ? "Progressive" : "Disabled";
|
|
scheduler.dynamicEventRenderingMargin = calendar.progressiveTaskRenderingMargin;
|
|
scheduler.dynamicEventRenderingCacheSweeping = calendar.progressiveTaskRenderingCacheSweeping;
|
|
scheduler.dynamicEventRenderingCacheSize = calendar.progressiveTaskRenderingCacheSize;
|
|
scheduler.startDate = new DayPilot.Date(calendar.startDate);
|
|
scheduler.days = calendar.days;
|
|
scheduler.cellDuration = calendar.cellDuration;
|
|
scheduler.cellGroupBy = calendar.cellGroupBy;
|
|
scheduler.cellWidth = calendar.cellWidth;
|
|
scheduler.cellWidthSpec = calendar.cellWidthSpec;
|
|
scheduler.cornerHtml = calendar.cornerHtml;
|
|
scheduler.eventHeight = calendar.taskHeight;
|
|
scheduler.eventResizeMargin = calendar.taskResizeMargin;
|
|
scheduler.floatingEvents = calendar.floatingTasks;
|
|
scheduler.floatingTimeHeaders = calendar.floatingTimeHeaders;
|
|
scheduler.headerHeight = calendar.headerHeight;
|
|
scheduler.heightSpec = calendar.heightSpec;
|
|
scheduler.height = calendar.height;
|
|
scheduler.linkBottomMargin = calendar.linkBottomMargin;
|
|
scheduler.loadingLabelVisible = calendar.loadingLabelVisible;
|
|
scheduler.loadingLabelText = calendar.loadingLabelText;
|
|
scheduler.locale = calendar.locale;
|
|
scheduler.messageBarPosition = calendar.messageBarPosition;
|
|
scheduler.messageHideAfter = calendar.messageHideAfter;
|
|
//scheduler.milestoneWidth = calendar.milestoneWidth;
|
|
scheduler.rowCreateHandling = calendar.rowCreateHandling;
|
|
scheduler.numberFormat = calendar.numberFormat;
|
|
scheduler.progressiveRowRendering = calendar.progressiveRowRendering;
|
|
scheduler.progressiveRowRenderingPreload = calendar.progressiveRowRenderingPreload;
|
|
scheduler.scale = calendar.scale;
|
|
scheduler.scrollDelayEvents = calendar.scrollDelayTasks;
|
|
scheduler.scrollDelayCells = calendar.scrollDelayCells;
|
|
scheduler.scrollDelayFloats = calendar.scrollDelayFloats;
|
|
scheduler.separators = calendar.separators;
|
|
scheduler.tapAndHoldTimeout = calendar.tapAndHoldTimeout;
|
|
scheduler.eventMovingStartEndEnabled = calendar.taskMovingStartEndEnabled;
|
|
scheduler.eventMovingStartEndFormat = calendar.taskMovingStartEndFormat;
|
|
scheduler.eventResizingStartEndEnabled = calendar.taskResizingStartEndEnabled;
|
|
scheduler.eventResizingStartEndFormat = calendar.taskResizingStartEndFormat;
|
|
scheduler.hideUntilInit = calendar.hideUntilInit;
|
|
scheduler.treeIndent = calendar.treeIndent;
|
|
scheduler.treeAutoExpand = calendar.treeAutoExpand;
|
|
scheduler.treeImageMarginLeft = calendar.treeImageMarginLeft;
|
|
scheduler.treeImageMarginTop = calendar.treeImageMarginTop;
|
|
scheduler.timeHeaders = calendar.timeHeaders;
|
|
scheduler.rowHeaderHideIconEnabled = calendar.rowHeaderHideIconEnabled;
|
|
scheduler.rowHeaderScrolling = calendar.rowHeaderScrolling;
|
|
scheduler.rowHeaderSplitterWidth = calendar.rowHeaderSplitterWidth;
|
|
scheduler.rowHeaderWidth = calendar.rowHeaderWidth;
|
|
scheduler.rowHeaderWidthAutoFit = calendar.rowHeaderWidthAutoFit;
|
|
scheduler.rowMarginBottom = calendar.rowMarginBottom;
|
|
scheduler.rowMinHeight = calendar.rowMinHeight;
|
|
scheduler.theme = calendar.theme;
|
|
scheduler.useEventBoxes = calendar.useEventBoxes;
|
|
scheduler.snapToGrid = calendar.snapToGrid;
|
|
scheduler.uniqueID = calendar.uniqueID;
|
|
scheduler.bubble = calendar.bubbleTask;
|
|
scheduler.cellBubble = calendar.bubbleCell;
|
|
scheduler.resourceBubble = calendar.bubbleRow;
|
|
scheduler.contextMenu = calendar.contextMenuTask;
|
|
scheduler.contextMenuResource = calendar.contextMenuRow;
|
|
scheduler.contextMenuLink = calendar.contextMenuLink;
|
|
scheduler.syncResourceTree = calendar.syncTasks;
|
|
scheduler.syncLinks = calendar.syncLinks;
|
|
scheduler.timeline = calendar.timeline;
|
|
scheduler.visible = calendar.visible;
|
|
|
|
scheduler.eventMoveHandling = calendar.taskMoveHandling;
|
|
scheduler.eventClickHandling = calendar.taskClickHandling;
|
|
scheduler.eventResizeHandling = calendar.taskResizeHandling;
|
|
scheduler.linkCreateHandling = calendar.linkCreateHandling;
|
|
scheduler.eventRightClickHandling = calendar.taskRightClickHandling;
|
|
scheduler.eventDoubleClickHandling = calendar.taskDoubleClickHandling;
|
|
scheduler.rowMoveHandling = calendar.rowMoveHandling;
|
|
scheduler.rowClickHandling = calendar.rowClickHandling;
|
|
scheduler.rowDoubleClickHandling = calendar.rowDoubleClickHandling;
|
|
scheduler.rowEditHandling = calendar.rowEditHandling;
|
|
scheduler.rowSelectHandling = calendar.rowSelectHandling;
|
|
|
|
// temporarily disabled - will require a different mapping
|
|
// scheduler.eventDeleteHandling = calendar.taskDeleteHandling;
|
|
|
|
if (DayPilot.isArray(calendar.columns)) {
|
|
scheduler.rowHeaderColumns = [];
|
|
for (var i = 0; i < calendar.columns.length; i++) {
|
|
var c = calendar.columns[i];
|
|
var rhc = {};
|
|
DayPilot.Util.copyProps(c, rhc, ['title', 'width']);
|
|
//rhc.title = c.title;
|
|
//rhc.width = c.width;
|
|
scheduler.rowHeaderColumns.push(rhc);
|
|
}
|
|
}
|
|
|
|
// server-based data
|
|
if (calendar._serverBased()) {
|
|
scheduler.timeHeader = calendar.timeHeader;
|
|
|
|
scheduler.cellProperties = calendar.cellProperties;
|
|
scheduler.cellConfig = calendar.cellConfig;
|
|
}
|
|
|
|
// event mapping
|
|
|
|
scheduler.onRowCreate = function(args) {
|
|
if (typeof calendar.onRowCreate === "function") {
|
|
calendar.onRowCreate(args);
|
|
}
|
|
};
|
|
|
|
scheduler.onRowCreated = function(args) {
|
|
if (typeof calendar.onRowCreated === "function") {
|
|
calendar.onRowCreated(args);
|
|
}
|
|
};
|
|
|
|
scheduler.onAfterRender = function(args) {
|
|
if (typeof calendar.onAfterRender === "function") {
|
|
calendar.onAfterRender(args);
|
|
}
|
|
};
|
|
|
|
scheduler.onRowHeaderResized = function(args) {
|
|
calendar.rowHeaderWidth = scheduler.rowHeaderWidth;
|
|
};
|
|
|
|
scheduler.onAjaxError = function(args) {
|
|
if (typeof calendar.onAjaxError === "function") {
|
|
calendar.onAjaxError(args);
|
|
}
|
|
};
|
|
|
|
scheduler.onRowHeaderColumnResized = function(args) {
|
|
var column = args.column;
|
|
var index = DayPilot.indexOf(scheduler.rowHeaderColumns, column);
|
|
|
|
for (var i = 0; i < calendar.columns.length; i++) {
|
|
var rhc = scheduler.rowHeaderColumns[i];
|
|
var c = calendar.columns[i];
|
|
c.width = rhc.width;
|
|
}
|
|
|
|
if (typeof calendar.onColumnResized === "function") {
|
|
var cargs = {};
|
|
cargs.column = calendar.columns[index];
|
|
calendar.onColumnResized(cargs);
|
|
}
|
|
|
|
};
|
|
|
|
scheduler.onBeforeRowHeaderRender = function(args) {
|
|
args.task = new DayPilot.Task(args.row.$.row.task, calendar);
|
|
|
|
var columns = [];
|
|
if (DayPilot.isArray(calendar.columns)) {
|
|
for (var i = 0; i < calendar.columns.length; i++) {
|
|
var column = calendar.columns[i];
|
|
var property = column.property;
|
|
|
|
var colargs = {};
|
|
colargs.value = tasktools.getProperty(args.task.data, property);
|
|
|
|
if (args.task.data.row && args.task.data.row.columns && args.task.data.row.columns[i]) {
|
|
colargs.html = args.task.data.row.columns[i].html;
|
|
}
|
|
else {
|
|
colargs.html = colargs.value;
|
|
}
|
|
columns.push(colargs);
|
|
}
|
|
}
|
|
|
|
args.row.columns = columns;
|
|
|
|
if (typeof calendar.onBeforeRowHeaderRender === "function") {
|
|
calendar.onBeforeRowHeaderRender(args);
|
|
}
|
|
|
|
if (DayPilot.isArray(calendar.columns)) {
|
|
for (var i = 0; i < calendar.columns.length; i++) {
|
|
var html = columns[i].html;
|
|
if (i === 0) {
|
|
args.row.html = html;
|
|
}
|
|
else {
|
|
args.row.columns[i - 1].html = html;
|
|
}
|
|
}
|
|
}
|
|
|
|
};
|
|
|
|
scheduler.onBeforeCellRender = function(args) {
|
|
args.task = calendar.tasks.find(args.cell.resource);
|
|
|
|
delete args.cell.resource;
|
|
if (typeof calendar.onBeforeCellRender === "function") {
|
|
calendar.onBeforeCellRender(args);
|
|
}
|
|
};
|
|
|
|
scheduler.onBeforeTimeHeaderRender = function(args) {
|
|
if (typeof calendar.onBeforeTimeHeaderRender === "function") {
|
|
calendar.onBeforeTimeHeaderRender(args);
|
|
}
|
|
};
|
|
|
|
scheduler.onEventClick = function(args) {
|
|
args.task = new DayPilot.Task(args.e, calendar);
|
|
if (typeof calendar.onTaskClick === "function") {
|
|
calendar.onTaskClick(args);
|
|
}
|
|
};
|
|
|
|
scheduler.onEventClicked = function(args) {
|
|
if (typeof calendar.onTaskClicked === "function") {
|
|
calendar.onTaskClicked(args);
|
|
}
|
|
};
|
|
|
|
scheduler.onEventDelete = function(args) {
|
|
if (typeof calendar.onTaskDelete === "function") {
|
|
calendar.onTaskDelete(args);
|
|
}
|
|
};
|
|
|
|
scheduler.onEventDeleted = function(args) {
|
|
if (typeof calendar.onTaskDeleted === "function") {
|
|
calendar.onTaskDeleted(args);
|
|
}
|
|
};
|
|
|
|
scheduler.onEventDoubleClick = function(args) {
|
|
args.task = new DayPilot.Task(args.e, calendar);
|
|
if (typeof calendar.onTaskDoubleClick === "function") {
|
|
calendar.onTaskDoubleClick(args);
|
|
}
|
|
};
|
|
|
|
scheduler.onEventDoubleClicked = function(args) {
|
|
if (typeof calendar.onTaskDoubleClicked === "function") {
|
|
calendar.onTaskDoubleClicked(args);
|
|
}
|
|
};
|
|
|
|
scheduler.onEventRightClick = function(args) {
|
|
args.task = new DayPilot.Task(args.e, calendar);
|
|
if (typeof calendar.onTaskRightClick === "function") {
|
|
calendar.onTaskRightClick(args);
|
|
}
|
|
};
|
|
|
|
scheduler.onEventRightClicked = function(args) {
|
|
if (typeof calendar.onTaskRightClicked === "function") {
|
|
calendar.onTaskRightClicked(args);
|
|
}
|
|
};
|
|
|
|
scheduler.onRowMoving = function(args) {
|
|
args._source = args.source;
|
|
args._target = args.target;
|
|
args.source = new DayPilot.Task(args._source.$.row.task, calendar);
|
|
args.target = new DayPilot.Task(args._target.$.row.task, calendar);
|
|
|
|
if (typeof calendar.onRowMoving === "function") {
|
|
calendar.onRowMoving(args);
|
|
}
|
|
};
|
|
|
|
scheduler.onRowMove = function(args) {
|
|
args._source = args.source;
|
|
args._target = args.target;
|
|
args.source = new DayPilot.Task(args._source.$.row.task, calendar);
|
|
args.target = new DayPilot.Task(args._target.$.row.task, calendar);
|
|
if (typeof calendar.onRowMove === "function") {
|
|
calendar.onRowMove(args);
|
|
}
|
|
args.source = args._source;
|
|
args.target = args._target;
|
|
};
|
|
|
|
scheduler.onRowMoved = function(args) {
|
|
|
|
var updateNow = calendar.rowMoveHandling === "Update" || calendar.rowMoveHandling === "Notify";
|
|
|
|
if (updateNow) {
|
|
// update parents
|
|
var source = args._source.$.row.task;
|
|
var target = args._target.$.row.task;
|
|
var position = args.position;
|
|
|
|
// *******************
|
|
|
|
if (position === "forbidden") {
|
|
return;
|
|
}
|
|
|
|
// remove from source
|
|
var sourceParent = tasktools.findParentArray(source);
|
|
if (!sourceParent) {
|
|
throw "Cannot find source node parent";
|
|
}
|
|
var sourceIndex = DayPilot.indexOf(sourceParent, source);
|
|
sourceParent.splice(sourceIndex, 1);
|
|
|
|
// move to target
|
|
var targetParent = tasktools.findParentArray(target);
|
|
if (!targetParent) {
|
|
throw "Cannot find target node parent";
|
|
}
|
|
var targetIndex = DayPilot.indexOf(targetParent, target);
|
|
|
|
switch (position) {
|
|
case "before":
|
|
targetParent.splice(targetIndex, 0, source);
|
|
break;
|
|
case "after":
|
|
targetParent.splice(targetIndex + 1, 0, source);
|
|
break;
|
|
case "child":
|
|
if (!target.children) {
|
|
target.children = [];
|
|
target.expanded = true;
|
|
}
|
|
target.children.push(source);
|
|
break;
|
|
}
|
|
|
|
//wrap._loadTasks();
|
|
calendar._angular.notify();
|
|
|
|
calendar.update();
|
|
|
|
// *******************
|
|
}
|
|
|
|
args.source = new DayPilot.Task(args._source.$.row.task, calendar);
|
|
args.target = new DayPilot.Task(args._target.$.row.task, calendar);
|
|
|
|
if (typeof calendar.onRowMoved === "function") {
|
|
calendar.onRowMoved(args);
|
|
}
|
|
};
|
|
|
|
scheduler.onRowClick = function(args) {
|
|
args.task = new DayPilot.Task(args.resource.$.row.task, calendar);
|
|
if (typeof calendar.onRowClick === "function") {
|
|
calendar.onRowClick(args);
|
|
}
|
|
};
|
|
|
|
scheduler.onRowClicked = function(args) {
|
|
if (typeof calendar.onRowClicked === "function") {
|
|
calendar.onRowClicked(args);
|
|
}
|
|
};
|
|
|
|
scheduler.onRowDoubleClick = function(args) {
|
|
args.task = new DayPilot.Task(args.resource.$.row.task, calendar);
|
|
if (typeof calendar.onRowDoubleClick === "function") {
|
|
calendar.onRowDoubleClick(args);
|
|
}
|
|
};
|
|
|
|
scheduler.onRowDoubleClicked = function(args) {
|
|
if (typeof calendar.onRowDoubleClicked === "function") {
|
|
calendar.onRowDoubleClicked(args);
|
|
}
|
|
};
|
|
|
|
scheduler.onRowEdit = function(args) {
|
|
args.task = new DayPilot.Task(args.resource.$.row.task, calendar);
|
|
if (typeof calendar.onRowEdit === "function") {
|
|
calendar.onRowEdit(args);
|
|
}
|
|
};
|
|
|
|
scheduler.onRowEdited = function(args) {
|
|
if (typeof calendar.onRowEdited === "function") {
|
|
calendar.onRowEdited(args);
|
|
}
|
|
};
|
|
|
|
scheduler.onRowSelect = function(args) {
|
|
args.task = new DayPilot.Task(args.row.$.row.task, calendar);
|
|
if (typeof calendar.onRowSelect === "function") {
|
|
calendar.onRowSelect(args);
|
|
}
|
|
};
|
|
|
|
scheduler.onRowSelected = function(args) {
|
|
if (typeof calendar.onRowSelected === "function") {
|
|
calendar.onRowSelected(args);
|
|
}
|
|
};
|
|
|
|
scheduler.onEventMove = function(args) {
|
|
args._e = args.e;
|
|
args.task = new DayPilot.Task(args.e, calendar);
|
|
//delete args.e;
|
|
//delete args.position;
|
|
//delete args.newResource;
|
|
if (typeof calendar.onTaskMove === "function") {
|
|
calendar.onTaskMove(args);
|
|
}
|
|
};
|
|
|
|
scheduler.onEventMoved = function(args) {
|
|
|
|
/*
|
|
var updateParent = function(parent) {
|
|
if (!parent) {
|
|
return;
|
|
}
|
|
|
|
var pe = scheduler.events.find(parent.id);
|
|
var children = wrap.childrenStartEnd(parent);
|
|
pe.start(children.start);
|
|
pe.end(children.end);
|
|
scheduler.events.update(pe);
|
|
updateParent(pe.data.parent);
|
|
};
|
|
*/
|
|
|
|
if (calendar.taskGroupMode === "Auto") {
|
|
var e = args._e;
|
|
|
|
// update source
|
|
var task = e.data.task;
|
|
task.start = e.start();
|
|
task.end = e.end();
|
|
|
|
//updateParent(args.e.data.parent);
|
|
|
|
while (e.data.parent) {
|
|
var parent = scheduler.events.find(e.data.parent.id);
|
|
var children = wrap.childrenStartEnd(e.data.parent);
|
|
parent.start(children.start);
|
|
parent.end(children.end);
|
|
scheduler.events.update(parent);
|
|
e = parent;
|
|
}
|
|
|
|
}
|
|
|
|
calendar._angular.notify();
|
|
|
|
if (typeof calendar.onTaskMoved === "function") {
|
|
calendar.onTaskMoved(args);
|
|
}
|
|
};
|
|
|
|
scheduler.onEventMoving = function(args) {
|
|
args.task = new DayPilot.Task(args.e, calendar);
|
|
args._e = args.e;
|
|
|
|
delete args.position;
|
|
delete args.overlapping;
|
|
delete args.resource;
|
|
|
|
if (typeof calendar.onTaskMoving === "function") {
|
|
calendar.onTaskMoving(args);
|
|
}
|
|
};
|
|
|
|
scheduler.onEventResize = function(args) {
|
|
args._e = args.e;
|
|
args.task = new DayPilot.Task(args.e, calendar);
|
|
if (typeof calendar.onTaskResize === "function") {
|
|
calendar.onTaskResize(args);
|
|
}
|
|
};
|
|
|
|
scheduler.onEventResized = function(args) {
|
|
if (calendar.taskGroupMode === "Auto") {
|
|
|
|
var e = args._e;
|
|
|
|
// update source
|
|
var task = e.data.task;
|
|
task.start = e.start();
|
|
task.end = e.end();
|
|
|
|
while (e.data.parent) {
|
|
var parent = scheduler.events.find(e.data.parent.id);
|
|
var children = wrap.childrenStartEnd(e.data.parent);
|
|
parent.start(children.start);
|
|
parent.end(children.end);
|
|
scheduler.events.update(parent);
|
|
e = parent;
|
|
}
|
|
}
|
|
calendar._angular.notify();
|
|
|
|
if (typeof calendar.onTaskResized === "function") {
|
|
calendar.onTaskResized(args);
|
|
}
|
|
};
|
|
|
|
scheduler.onEventResizing = function(args) {
|
|
args.task = new DayPilot.Task(args.e, calendar);
|
|
args._e = args.e;
|
|
|
|
if (typeof calendar.onTaskResizing === "function") {
|
|
calendar.onTaskResizing(args);
|
|
}
|
|
};
|
|
|
|
scheduler.onLinkCreate = function(args) {
|
|
args.source = calendar.tasks.find(args.from);
|
|
args.target = calendar.tasks.find(args.to);
|
|
if (typeof calendar.onLinkCreate === "function") {
|
|
calendar.onLinkCreate(args);
|
|
}
|
|
};
|
|
|
|
scheduler.onLinkCreated = function(args) {
|
|
if (typeof calendar.onLinkCreated === "function") {
|
|
calendar.onLinkCreated(args);
|
|
}
|
|
};
|
|
|
|
scheduler.onResourceExpand = function(args) {
|
|
var task = args.resource.$.row.task;
|
|
if (!task.row) {
|
|
task.row = {};
|
|
}
|
|
task.row.collapsed = false;
|
|
};
|
|
|
|
scheduler.onResourceCollapse = function(args) {
|
|
var task = args.resource.$.row.task;
|
|
if (!task.row) {
|
|
task.row = {};
|
|
}
|
|
task.row.collapsed = true;
|
|
};
|
|
|
|
};
|
|
|
|
wrap._rowObjectForTaskData = function(data) {
|
|
for (var i = 0; i < scheduler.rowlist.length; i++) {
|
|
var row = scheduler.rowlist[i];
|
|
if (row.task === data) {
|
|
return scheduler.internal.createRowObject(row);
|
|
}
|
|
}
|
|
return null;
|
|
};
|
|
|
|
wrap._loadLinks = function() {
|
|
scheduler.links.list = calendar.links.list ? calendar.links.list : [];
|
|
};
|
|
|
|
wrap._loadTasks = function() {
|
|
scheduler.resources = [];
|
|
scheduler.events.list = [];
|
|
|
|
tasktools.clearCache();
|
|
|
|
wrap._loadChildren(calendar.tasks.list, scheduler.resources, null);
|
|
};
|
|
|
|
wrap._doBeforeTaskRender = function(task) {
|
|
|
|
var type = task.type || "Task";
|
|
if (task.children && task.children.length) {
|
|
type = "Group";
|
|
}
|
|
|
|
/*
|
|
if (typeof calendar.onBeforeTaskRender !== "function") {
|
|
return {
|
|
"data": task,
|
|
"type": type
|
|
};
|
|
}
|
|
*/
|
|
|
|
var data = {};
|
|
|
|
// make a copy
|
|
for (var name in task) {
|
|
if (name === "children") {
|
|
continue;
|
|
}
|
|
data[name] = task[name];
|
|
}
|
|
|
|
var args = {};
|
|
args.data = data;
|
|
args.type = type;
|
|
|
|
if (!data.box) {
|
|
data.box = {};
|
|
}
|
|
|
|
if (typeof data.box.html === "undefined") {
|
|
if (args.type === "Task") {
|
|
var complete = data.complete || 0;
|
|
data.box.html = complete + "%";
|
|
}
|
|
else {
|
|
data.box.html = "";
|
|
}
|
|
}
|
|
|
|
if (typeof data.box.htmlRight === "undefined") {
|
|
data.box.htmlRight = data.text;
|
|
}
|
|
|
|
if (typeof calendar.onBeforeTaskRender === "function") {
|
|
calendar.onBeforeTaskRender(args);
|
|
}
|
|
|
|
// read-only, override the
|
|
args.type = type;
|
|
|
|
return args;
|
|
};
|
|
|
|
|
|
wrap._loadChildren = function(source, target, parent) {
|
|
if (!DayPilot.isArray(source)) {
|
|
return;
|
|
}
|
|
for (var i = 0; i < source.length; i++) {
|
|
var original = source[i];
|
|
tasktools.addToCache(original, parent);
|
|
var args = wrap._doBeforeTaskRender(original);
|
|
var task = args.data;
|
|
var type = args.type;
|
|
|
|
var event = {};
|
|
DayPilot.Util.copyProps(task, event, ['id', 'start', 'end', 'text', 'complete', 'tags']);
|
|
DayPilot.Util.copyProps(task.box, event);
|
|
event.parent = parent;
|
|
event.task = original;
|
|
event.resource = task.id;
|
|
|
|
if (type == "Group") {
|
|
event.type = "Group";
|
|
event.html = "";
|
|
//event.html = task.html;
|
|
//event.barHidden = true;
|
|
delete event.backColor;
|
|
if (calendar.taskGroupMode === "Auto") {
|
|
var children = wrap.childrenStartEnd(original);
|
|
event.start = children.start;
|
|
event.end = children.end;
|
|
event.resizeDisabled = true;
|
|
event.moveDisabled = true;
|
|
}
|
|
}
|
|
else if (type === "Milestone") {
|
|
// TODO modifying the original object (remove?)
|
|
original.end = original.start;
|
|
|
|
task.end = task.start;
|
|
|
|
event.end = task.start;
|
|
//event.html = task.html;
|
|
event.barHidden = true;
|
|
event.resizeDisabled = true;
|
|
event.type = "Milestone";
|
|
event.width = calendar.taskHeight;
|
|
delete event.backColor;
|
|
}
|
|
else if (type === "Task" ){
|
|
//event.html = task.box.html;
|
|
doNothing();
|
|
}
|
|
|
|
event.moveVDisabled = true;
|
|
|
|
event.htmlRight = task.box.htmlRight;
|
|
event.htmlLeft = task.box.htmlLeft;
|
|
|
|
scheduler.events.list.push(event);
|
|
|
|
var r = {};
|
|
|
|
// source
|
|
r.task = original;
|
|
|
|
// server-based only
|
|
DayPilot.Util.copyProps(task.row, r);
|
|
|
|
r.name = task.text;
|
|
r.id = task.id;
|
|
r.children = [];
|
|
r.expanded = !task.row || !task.row.collapsed;
|
|
|
|
if (original.children && original.children.length) {
|
|
wrap._loadChildren(original.children, r.children, original);
|
|
}
|
|
|
|
target.push(r);
|
|
|
|
}
|
|
};
|
|
|
|
wrap.childrenStartEnd = function(task) {
|
|
if (!task.children || !task.children.length) {
|
|
var start = task.start;
|
|
var end = task.end;
|
|
if (task.type === "Milestone") {
|
|
end = start;
|
|
}
|
|
return { "start": new DayPilot.Date(start), "end": new DayPilot.Date(end) };
|
|
}
|
|
var start = null;
|
|
var end = null;
|
|
for (var i = 0; i < task.children.length; i++) {
|
|
var children = wrap.childrenStartEnd(task.children[i]);
|
|
if (!start || children.start.getTime() < start.getTime()) {
|
|
start = children.start;
|
|
}
|
|
if (!end || children.end.getTime() > end.getTime()) {
|
|
end = children.end;
|
|
}
|
|
}
|
|
return { "start": start, "end": end};
|
|
};
|
|
|
|
this.rows = {};
|
|
|
|
this.rows.expand = function(levels) {
|
|
scheduler.rows.expand(levels);
|
|
};
|
|
|
|
this.rows.expandAll = function() {
|
|
scheduler.rows.expandAll();
|
|
};
|
|
|
|
this.internal = {};
|
|
this.internal.initialized = function() {
|
|
return calendar._initialized;
|
|
};
|
|
// DayPilot.Task
|
|
this.internal.rowObjectForTaskData = wrap._rowObjectForTaskData;
|
|
|
|
this._angular = {};
|
|
this._angular.scope = null;
|
|
this._angular.notify = function() {
|
|
if (calendar._angular.scope) {
|
|
calendar._angular.scope["$apply"]();
|
|
}
|
|
};
|
|
|
|
|
|
this._specialHandling = null;
|
|
this._loadOptions = function(options) {
|
|
var specialHandling = {
|
|
"tasks": {
|
|
"preInit": function() {
|
|
var tasks = this.data;
|
|
if (!tasks) {
|
|
return;
|
|
}
|
|
if (DayPilot.isArray(tasks.list)) {
|
|
calendar.tasks.list = tasks.list;
|
|
}
|
|
else {
|
|
calendar.tasks.list = tasks;
|
|
}
|
|
}
|
|
},
|
|
"links": {
|
|
"preInit": function() {
|
|
|
|
var links = this.data;
|
|
if (!links) {
|
|
return;
|
|
}
|
|
if (DayPilot.isArray(links.list)) {
|
|
calendar.links.list = links.list;
|
|
}
|
|
else {
|
|
calendar.links.list = links;
|
|
}
|
|
}
|
|
},
|
|
"scrollTo": {
|
|
"postInit": function() {
|
|
if (this.data) {
|
|
calendar.scrollTo(this.data);
|
|
}
|
|
}
|
|
}
|
|
};
|
|
this._specialHandling = specialHandling;
|
|
|
|
for (var name in options) {
|
|
if (specialHandling[name]) {
|
|
var item = specialHandling[name];
|
|
item.data = options[name];
|
|
if (item.preInit) {
|
|
item.preInit();
|
|
}
|
|
}
|
|
else {
|
|
calendar[name] = options[name];
|
|
}
|
|
}
|
|
|
|
};
|
|
|
|
this._postInit = function() {
|
|
var specialHandling = this._specialHandling;
|
|
for (var name in specialHandling) {
|
|
var item = specialHandling[name];
|
|
if (item.postInit) {
|
|
item.postInit();
|
|
}
|
|
}
|
|
};
|
|
|
|
this._loadOptions(options);
|
|
};
|
|
|
|
// experimental jQuery bindings
|
|
if (typeof jQuery !== 'undefined') {
|
|
(function($) {
|
|
$.fn.daypilotGantt = function(options) {
|
|
var first = null;
|
|
var j = this.each(function() {
|
|
if (this.daypilot) { // already initialized
|
|
return;
|
|
};
|
|
|
|
var daypilot = new DayPilot.Gantt(this.id, options);
|
|
daypilot.init();
|
|
|
|
this.daypilot = daypilot;
|
|
|
|
if (!first) {
|
|
first = daypilot;
|
|
}
|
|
});
|
|
if (this.length === 1) {
|
|
return first;
|
|
}
|
|
else {
|
|
return j;
|
|
}
|
|
};
|
|
})(jQuery);
|
|
}
|
|
|
|
(function registerAngularModule() {
|
|
var app = DayPilot.am();
|
|
|
|
if (!app) {
|
|
return;
|
|
}
|
|
|
|
app.directive("daypilotGantt", function() {
|
|
return {
|
|
"restrict": "E",
|
|
"template": "<div id='{{id}}'></div>",
|
|
"compile": function compile(element, attrs) {
|
|
element.replaceWith(this["template"].replace("{{id}}", attrs["id"]));
|
|
|
|
return function link(scope, element, attrs) {
|
|
var calendar = new DayPilot.Gantt(element[0]);
|
|
calendar._angular.scope = scope;
|
|
calendar.init();
|
|
|
|
var oattr = attrs["id"];
|
|
if (oattr) {
|
|
scope[oattr] = calendar;
|
|
}
|
|
|
|
var watch = scope["$watch"];
|
|
|
|
watch.call(scope, attrs["daypilotConfig"], function (value) {
|
|
calendar._loadOptions(value);
|
|
calendar.update();
|
|
}, true);
|
|
|
|
};
|
|
}
|
|
};
|
|
});
|
|
})();
|
|
|
|
if (typeof Sys !== 'undefined' && Sys.Application && Sys.Application.notifyScriptLoaded) {
|
|
Sys.Application.notifyScriptLoaded();
|
|
}
|
|
|
|
})(); |