devextreme
Version:
HTML5 JavaScript Component Suite for Responsive Web Development
1,206 lines • 111 kB
JavaScript
/**
* DevExtreme (esm/__internal/scheduler/workspaces/m_work_space.js)
* Version: 23.2.6
* Build date: Wed May 01 2024
*
* Copyright (c) 2012 - 2024 Developer Express Inc. ALL RIGHTS RESERVED
* Read about DevExtreme licensing here: https://js.devexpress.com/Licensing/
*/
import _extends from "@babel/runtime/helpers/esm/extends";
import {
locate,
resetPosition
} from "../../../animation/translator";
import domAdapter from "../../../core/dom_adapter";
import {
getPublicElement
} from "../../../core/element";
import $ from "../../../core/renderer";
import {
noop
} from "../../../core/utils/common";
import {
compileGetter
} from "../../../core/utils/data";
import dateUtils from "../../../core/utils/date";
import {
extend
} from "../../../core/utils/extend";
import {
getBoundingRect
} from "../../../core/utils/position";
import {
getHeight,
getOuterHeight,
getOuterWidth,
getWidth,
setOuterHeight,
setWidth
} from "../../../core/utils/size";
import {
isDefined
} from "../../../core/utils/type";
import {
getWindow,
hasWindow
} from "../../../core/utils/window";
import {
name as clickEventName
} from "../../../events/click";
import {
name as contextMenuEventName
} from "../../../events/contextmenu";
import eventsEngine from "../../../events/core/events_engine";
import {
drop as dragEventDrop,
enter as dragEventEnter,
leave as dragEventLeave
} from "../../../events/drag";
import pointerEvents from "../../../events/pointer";
import {
addNamespace,
isMouseEvent
} from "../../../events/utils/index";
import messageLocalization from "../../../localization/message";
import Scrollable from "../../../ui/scroll_view/ui.scrollable";
import errors from "../../../ui/widget/ui.errors";
import {
getMemoizeScrollTo
} from "../../core/utils/scroll";
import {
AllDayPanelTitleComponent,
AllDayTableComponent,
DateTableComponent,
GroupPanelComponent,
HeaderPanelComponent,
TimePanelComponent
} from "../../scheduler/r1/components/index";
import {
calculateIsGroupedAllDayPanel,
calculateViewStartDate,
getCellDuration,
getGroupCount,
getStartViewDateTimeOffset,
getViewStartByOptions,
isDateAndTimeView
} from "../../scheduler/r1/utils/index";
import WidgetObserver from "../base/m_widget_observer";
import AppointmentDragBehavior from "../m_appointment_drag_behavior";
import {
DATE_TABLE_CLASS,
DATE_TABLE_ROW_CLASS,
FIXED_CONTAINER_CLASS,
GROUP_HEADER_CONTENT_CLASS,
GROUP_ROW_CLASS,
TIME_PANEL_CLASS,
VERTICAL_GROUP_COUNT_CLASSES,
VIRTUAL_CELL_CLASS
} from "../m_classes";
import {
APPOINTMENT_SETTINGS_KEY
} from "../m_constants";
import tableCreatorModule from "../m_table_creator";
import {
utils
} from "../m_utils";
import {
createResourcesTree,
getCellGroups,
getGroupsObjectFromGroupsArray
} from "../resources/m_utils";
import VerticalShader from "../shaders/m_current_time_shader_vertical";
import {
getAllDayHeight,
getCellHeight,
getCellWidth,
getMaxAllowedPosition,
PositionHelper
} from "./helpers/m_position_helper";
import {
Cache
} from "./m_cache";
import {
CellsSelectionController
} from "./m_cells_selection_controller";
import CellsSelectionState from "./m_cells_selection_state";
import {
VirtualScrollingDispatcher,
VirtualScrollingRenderer
} from "./m_virtual_scrolling";
import HorizontalGroupedStrategy from "./m_work_space_grouped_strategy_horizontal";
import VerticalGroupedStrategy from "./m_work_space_grouped_strategy_vertical";
import ViewDataProvider from "./view_model/m_view_data_provider";
var {
tableCreator: tableCreator
} = tableCreatorModule;
var DRAGGING_MOUSE_FAULT = 10;
var {
abstract: abstract
} = WidgetObserver;
var toMs = dateUtils.dateToMilliseconds;
var COMPONENT_CLASS = "dx-scheduler-work-space";
var GROUPED_WORKSPACE_CLASS = "dx-scheduler-work-space-grouped";
var VERTICAL_GROUPED_WORKSPACE_CLASS = "dx-scheduler-work-space-vertical-grouped";
var WORKSPACE_VERTICAL_GROUP_TABLE_CLASS = "dx-scheduler-work-space-vertical-group-table";
var WORKSPACE_WITH_BOTH_SCROLLS_CLASS = "dx-scheduler-work-space-both-scrollbar";
var WORKSPACE_WITH_COUNT_CLASS = "dx-scheduler-work-space-count";
var WORKSPACE_WITH_GROUP_BY_DATE_CLASS = "dx-scheduler-work-space-group-by-date";
var WORKSPACE_WITH_ODD_CELLS_CLASS = "dx-scheduler-work-space-odd-cells";
var TIME_PANEL_CELL_CLASS = "dx-scheduler-time-panel-cell";
var TIME_PANEL_ROW_CLASS = "dx-scheduler-time-panel-row";
var ALL_DAY_PANEL_CLASS = "dx-scheduler-all-day-panel";
var ALL_DAY_TABLE_CLASS = "dx-scheduler-all-day-table";
var ALL_DAY_CONTAINER_CLASS = "dx-scheduler-all-day-appointments";
var ALL_DAY_TITLE_CLASS = "dx-scheduler-all-day-title";
var ALL_DAY_TABLE_CELL_CLASS = "dx-scheduler-all-day-table-cell";
var ALL_DAY_TABLE_ROW_CLASS = "dx-scheduler-all-day-table-row";
var WORKSPACE_WITH_ALL_DAY_CLASS = "dx-scheduler-work-space-all-day";
var WORKSPACE_WITH_COLLAPSED_ALL_DAY_CLASS = "dx-scheduler-work-space-all-day-collapsed";
var WORKSPACE_WITH_MOUSE_SELECTION_CLASS = "dx-scheduler-work-space-mouse-selection";
var HORIZONTAL_SIZES_CLASS = "dx-scheduler-cell-sizes-horizontal";
var VERTICAL_SIZES_CLASS = "dx-scheduler-cell-sizes-vertical";
var HEADER_PANEL_CLASS = "dx-scheduler-header-panel";
var HEADER_PANEL_CELL_CLASS = "dx-scheduler-header-panel-cell";
var HEADER_ROW_CLASS = "dx-scheduler-header-row";
var GROUP_HEADER_CLASS = "dx-scheduler-group-header";
var DATE_TABLE_CELL_CLASS = "dx-scheduler-date-table-cell";
var DATE_TABLE_FOCUSED_CELL_CLASS = "dx-scheduler-focused-cell";
var VIRTUAL_ROW_CLASS = "dx-scheduler-virtual-row";
var DATE_TABLE_DROPPABLE_CELL_CLASS = "dx-scheduler-date-table-droppable-cell";
var SCHEDULER_HEADER_SCROLLABLE_CLASS = "dx-scheduler-header-scrollable";
var SCHEDULER_SIDEBAR_SCROLLABLE_CLASS = "dx-scheduler-sidebar-scrollable";
var SCHEDULER_DATE_TABLE_SCROLLABLE_CLASS = "dx-scheduler-date-table-scrollable";
var SCHEDULER_WORKSPACE_DXPOINTERDOWN_EVENT_NAME = addNamespace(pointerEvents.down, "dxSchedulerWorkSpace");
var DragEventNames = {
ENTER: addNamespace(dragEventEnter, "dxSchedulerDateTable"),
DROP: addNamespace(dragEventDrop, "dxSchedulerDateTable"),
LEAVE: addNamespace(dragEventLeave, "dxSchedulerDateTable")
};
var SCHEDULER_CELL_DXCLICK_EVENT_NAME = addNamespace(clickEventName, "dxSchedulerDateTable");
var SCHEDULER_CELL_DXPOINTERDOWN_EVENT_NAME = addNamespace(pointerEvents.down, "dxSchedulerDateTable");
var SCHEDULER_CELL_DXPOINTERUP_EVENT_NAME = addNamespace(pointerEvents.up, "dxSchedulerDateTable");
var SCHEDULER_CELL_DXPOINTERMOVE_EVENT_NAME = addNamespace(pointerEvents.move, "dxSchedulerDateTable");
var CELL_DATA = "dxCellData";
var DATE_TABLE_MIN_CELL_WIDTH = 75;
var DAY_MS = toMs("day");
var HOUR_MS = toMs("hour");
var DRAG_AND_DROP_SELECTOR = ".".concat(DATE_TABLE_CLASS, " td, .").concat(ALL_DAY_TABLE_CLASS, " td");
var CELL_SELECTOR = ".".concat(DATE_TABLE_CELL_CLASS, ", .").concat(ALL_DAY_TABLE_CELL_CLASS);
var CELL_INDEX_CALCULATION_EPSILON = .05;
var DEFAULT_WORKSPACE_RENDER_OPTIONS = {
renderComponents: {
header: true,
timePanel: true,
dateTable: true,
allDayPanel: true
},
generateNewData: true
};
class SchedulerWorkSpace extends WidgetObserver {
constructor() {
super(...arguments);
this.viewDirection = "vertical"
}
get type() {
return ""
}
get viewDataProvider() {
if (!this._viewDataProvider) {
this._viewDataProvider = new ViewDataProvider(this.type)
}
return this._viewDataProvider
}
get cache() {
if (!this._cache) {
this._cache = new Cache
}
return this._cache
}
get cellsSelectionState() {
if (!this._cellsSelectionState) {
this._cellsSelectionState = new CellsSelectionState(this.viewDataProvider);
var selectedCellsOption = this.option("selectedCellData");
if ((null === selectedCellsOption || void 0 === selectedCellsOption ? void 0 : selectedCellsOption.length) > 0) {
var validSelectedCells = selectedCellsOption.map(selectedCell => {
var {
groups: groups
} = selectedCell;
if (!groups || 0 === this._getGroupCount()) {
return _extends(_extends({}, selectedCell), {
groupIndex: 0
})
}
var groupIndex = this._getGroupIndexByResourceId(groups);
return _extends(_extends({}, selectedCell), {
groupIndex: groupIndex
})
});
this._cellsSelectionState.setSelectedCellsByData(validSelectedCells)
}
}
return this._cellsSelectionState
}
get cellsSelectionController() {
if (!this._cellsSelectionController) {
this._cellsSelectionController = new CellsSelectionController
}
return this._cellsSelectionController
}
get isAllDayPanelVisible() {
return this._isShowAllDayPanel() && this.supportAllDayRow()
}
get verticalGroupTableClass() {
return WORKSPACE_VERTICAL_GROUP_TABLE_CLASS
}
get renovatedHeaderPanelComponent() {
return HeaderPanelComponent
}
get timeZoneCalculator() {
return this.option("timeZoneCalculator")
}
get isDefaultDraggingMode() {
return "default" === this.option("draggingMode")
}
_supportedKeys() {
var clickHandler = function(e) {
e.preventDefault();
e.stopPropagation();
var selectedCells = this.cellsSelectionState.getSelectedCells();
if (null === selectedCells || void 0 === selectedCells ? void 0 : selectedCells.length) {
var selectedCellsElement = selectedCells.map(cellData => this._getCellByData(cellData)).filter(cell => !!cell);
e.target = selectedCellsElement;
this._showPopup = true;
this._cellClickAction({
event: e,
cellElement: $(selectedCellsElement),
cellData: selectedCells[0]
})
}
};
var onArrowPressed = (e, key) => {
var _a;
e.preventDefault();
e.stopPropagation();
var focusedCellData = null === (_a = this.cellsSelectionState.focusedCell) || void 0 === _a ? void 0 : _a.cellData;
if (focusedCellData) {
var isAllDayPanelCell = focusedCellData.allDay && !this._isVerticalGroupedWorkSpace();
var isMultiSelection = e.shiftKey;
var isMultiSelectionAllowed = this.option("allowMultipleCellSelection");
var isRTL = this._isRTL();
var groupCount = this._getGroupCount();
var isGroupedByDate = this.isGroupedByDate();
var isHorizontalGrouping = this._isHorizontalGroupedWorkSpace();
var focusedCellPosition = this.viewDataProvider.findCellPositionInMap(_extends(_extends({}, focusedCellData), {
isAllDay: focusedCellData.allDay
}));
var edgeIndices = isHorizontalGrouping && isMultiSelection && !isGroupedByDate ? this.viewDataProvider.getGroupEdgeIndices(focusedCellData.groupIndex, isAllDayPanelCell) : this.viewDataProvider.getViewEdgeIndices(isAllDayPanelCell);
var nextCellData = this.cellsSelectionController.handleArrowClick({
focusedCellPosition: focusedCellPosition,
edgeIndices: edgeIndices,
isRTL: isRTL,
isGroupedByDate: isGroupedByDate,
groupCount: groupCount,
isMultiSelection: isMultiSelection,
isMultiSelectionAllowed: isMultiSelectionAllowed,
viewType: this.type,
key: key,
getCellDataByPosition: this.viewDataProvider.getCellData.bind(this.viewDataProvider),
isAllDayPanelCell: isAllDayPanelCell,
focusedCellData: focusedCellData
});
this._processNextSelectedCell(nextCellData, focusedCellData, isMultiSelection && isMultiSelectionAllowed)
}
};
return extend(super._supportedKeys(), {
enter: clickHandler,
space: clickHandler,
downArrow: e => {
onArrowPressed(e, "down")
},
upArrow: e => {
onArrowPressed(e, "up")
},
rightArrow: e => {
onArrowPressed(e, "right")
},
leftArrow: e => {
onArrowPressed(e, "left")
}
})
}
_isRTL() {
return this.option("rtlEnabled")
}
_moveToCell($cell, isMultiSelection) {
if (!isDefined($cell) || !$cell.length) {
return
}
var isMultiSelectionAllowed = this.option("allowMultipleCellSelection");
var currentCellData = this._getFullCellData($cell);
var focusedCellData = this.cellsSelectionState.focusedCell.cellData;
var nextFocusedCellData = this.cellsSelectionController.moveToCell({
isMultiSelection: isMultiSelection,
isMultiSelectionAllowed: isMultiSelectionAllowed,
currentCellData: currentCellData,
focusedCellData: focusedCellData,
isVirtualCell: $cell.hasClass(VIRTUAL_CELL_CLASS)
});
this._processNextSelectedCell(nextFocusedCellData, focusedCellData, isMultiSelectionAllowed && isMultiSelection)
}
_processNextSelectedCell(nextCellData, focusedCellData, isMultiSelection) {
var nextCellPosition = this.viewDataProvider.findCellPositionInMap({
startDate: nextCellData.startDate,
groupIndex: nextCellData.groupIndex,
isAllDay: nextCellData.allDay,
index: nextCellData.index
});
if (!this.viewDataProvider.isSameCell(focusedCellData, nextCellData)) {
var $cell = nextCellData.allDay && !this._isVerticalGroupedWorkSpace() ? this._dom_getAllDayPanelCell(nextCellPosition.columnIndex) : this._dom_getDateCell(nextCellPosition);
var isNextCellAllDay = nextCellData.allDay;
this._setSelectedCellsStateAndUpdateSelection(isNextCellAllDay, nextCellPosition, isMultiSelection, $cell);
this._dateTableScrollable.scrollToElement($cell)
}
}
_setSelectedCellsStateAndUpdateSelection(isAllDay, cellPosition, isMultiSelection, $nextFocusedCell) {
var nextCellCoordinates = {
rowIndex: cellPosition.rowIndex,
columnIndex: cellPosition.columnIndex,
allDay: isAllDay
};
this.cellsSelectionState.setFocusedCell(nextCellCoordinates.rowIndex, nextCellCoordinates.columnIndex, isAllDay);
if (isMultiSelection) {
this.cellsSelectionState.setSelectedCells(nextCellCoordinates)
} else {
this.cellsSelectionState.setSelectedCells(nextCellCoordinates, nextCellCoordinates)
}
this.updateCellsSelection();
this._updateSelectedCellDataOption(this.cellsSelectionState.getSelectedCells(), $nextFocusedCell)
}
_hasAllDayClass($cell) {
return $cell.hasClass(ALL_DAY_TABLE_CELL_CLASS)
}
_focusInHandler(e) {
if ($(e.target).is(this._focusTarget()) && false !== this._isCellClick) {
delete this._isCellClick;
delete this._contextMenuHandled;
super._focusInHandler.apply(this, arguments);
this.cellsSelectionState.restoreSelectedAndFocusedCells();
if (!this.cellsSelectionState.focusedCell) {
var cellCoordinates = {
columnIndex: 0,
rowIndex: 0,
allDay: this._isVerticalGroupedWorkSpace() && this.isAllDayPanelVisible
};
this.cellsSelectionState.setFocusedCell(cellCoordinates.rowIndex, cellCoordinates.columnIndex, cellCoordinates.allDay);
this.cellsSelectionState.setSelectedCells(cellCoordinates, cellCoordinates)
}
this.updateCellsSelection();
this._updateSelectedCellDataOption(this.cellsSelectionState.getSelectedCells())
}
}
_focusOutHandler() {
super._focusOutHandler.apply(this, arguments);
if (!this._contextMenuHandled && !this._disposed) {
this.cellsSelectionState.releaseSelectedAndFocusedCells();
this.viewDataProvider.updateViewData(this.generateRenderOptions());
this.updateCellsSelection()
}
}
_focusTarget() {
return this.$element()
}
_isVerticalGroupedWorkSpace() {
var _a;
return !!(null === (_a = this.option("groups")) || void 0 === _a ? void 0 : _a.length) && "vertical" === this.option("groupOrientation")
}
_isHorizontalGroupedWorkSpace() {
var _a;
return !!(null === (_a = this.option("groups")) || void 0 === _a ? void 0 : _a.length) && "horizontal" === this.option("groupOrientation")
}
_isWorkSpaceWithCount() {
return this.option("intervalCount") > 1
}
_isWorkspaceWithOddCells() {
return .5 === this.option("hoursInterval") && !this.isVirtualScrolling()
}
_getRealGroupOrientation() {
return this._isVerticalGroupedWorkSpace() ? "vertical" : "horizontal"
}
createRAllDayPanelElements() {
this._$allDayPanel = $("<div>").addClass(ALL_DAY_PANEL_CLASS);
this._$allDayTitle = $("<div>").appendTo(this._$headerPanelEmptyCell)
}
_dateTableScrollableConfig() {
var config = {
useKeyboard: false,
bounceEnabled: false,
updateManually: true,
onScroll: () => {
var _a;
null === (_a = this._groupedStrategy.cache) || void 0 === _a ? void 0 : _a.clear()
}
};
if (this._needCreateCrossScrolling()) {
config = extend(config, this._createCrossScrollingConfig(config))
}
if (this.isVirtualScrolling() && (this.virtualScrollingDispatcher.horizontalScrollingAllowed || this.virtualScrollingDispatcher.height)) {
var currentOnScroll = config.onScroll;
config = _extends(_extends({}, config), {
onScroll: e => {
null === currentOnScroll || void 0 === currentOnScroll ? void 0 : currentOnScroll(e);
this.virtualScrollingDispatcher.handleOnScrollEvent(null === e || void 0 === e ? void 0 : e.scrollOffset)
}
})
}
return config
}
_createCrossScrollingConfig(_ref) {
var {
onScroll: _onScroll
} = _ref;
return {
direction: "both",
onScroll: event => {
null === _onScroll || void 0 === _onScroll ? void 0 : _onScroll();
this._scrollSync.sidebar({
top: event.scrollOffset.top
});
this._scrollSync.header({
left: event.scrollOffset.left
})
},
onEnd: () => {
this.option("onScrollEnd")()
}
}
}
_headerScrollableConfig() {
return {
useKeyboard: false,
showScrollbar: "never",
direction: "horizontal",
useNative: false,
updateManually: true,
bounceEnabled: false,
onScroll: event => {
this._scrollSync.dateTable({
left: event.scrollOffset.left
})
}
}
}
_visibilityChanged(visible) {
this.cache.clear();
if (visible) {
this._updateGroupTableHeight()
}
if (visible && this._needCreateCrossScrolling()) {
this._setTableSizes()
}
}
_setTableSizes() {
this.cache.clear();
this._attachTableClasses();
var cellWidth = this.getCellWidth();
if (cellWidth < this.getCellMinWidth()) {
cellWidth = this.getCellMinWidth()
}
var minWidth = this.getWorkSpaceMinWidth();
var groupCount = this._getGroupCount();
var totalCellCount = this._getTotalCellCount(groupCount);
var width = cellWidth * totalCellCount;
if (width < minWidth) {
width = minWidth
}
setWidth(this._$headerPanel, width);
setWidth(this._$dateTable, width);
if (this._$allDayTable) {
setWidth(this._$allDayTable, width)
}
this._attachHeaderTableClasses();
this._updateGroupTableHeight();
this._updateScrollable()
}
getWorkSpaceMinWidth() {
return this._groupedStrategy.getWorkSpaceMinWidth()
}
_dimensionChanged() {
if (!this._isVisible()) {
return
}
if (this.option("crossScrollingEnabled")) {
this._setTableSizes()
}
this.updateHeaderEmptyCellWidth();
this._updateScrollable();
this.cache.clear()
}
_needCreateCrossScrolling() {
return this.option("crossScrollingEnabled")
}
_getElementClass() {
return noop()
}
_getRowCount() {
return this.viewDataProvider.getRowCount({
intervalCount: this.option("intervalCount"),
currentDate: this.option("currentDate"),
viewType: this.type,
hoursInterval: this.option("hoursInterval"),
startDayHour: this.option("startDayHour"),
endDayHour: this.option("endDayHour")
})
}
_getCellCount() {
return this.viewDataProvider.getCellCount({
intervalCount: this.option("intervalCount"),
currentDate: this.option("currentDate"),
viewType: this.type,
hoursInterval: this.option("hoursInterval"),
startDayHour: this.option("startDayHour"),
endDayHour: this.option("endDayHour")
})
}
isRenovatedRender() {
return this.renovatedRenderSupported() && this.option("renovateRender")
}
_isVirtualModeOn() {
return "virtual" === this.option("scrolling.mode")
}
isVirtualScrolling() {
return this.isRenovatedRender() && this._isVirtualModeOn()
}
_initVirtualScrolling() {
if (this.virtualScrollingDispatcher) {
this.virtualScrollingDispatcher.dispose();
this.virtualScrollingDispatcher = null
}
this.virtualScrollingDispatcher = new VirtualScrollingDispatcher(this._getVirtualScrollingDispatcherOptions());
this.virtualScrollingDispatcher.attachScrollableEvents();
this.renderer = new VirtualScrollingRenderer(this)
}
onDataSourceChanged(argument) {}
isGroupedAllDayPanel() {
return calculateIsGroupedAllDayPanel(this.option("groups"), this.option("groupOrientation"), this.isAllDayPanelVisible)
}
generateRenderOptions(isProvideVirtualCellsWidth) {
var _a;
var groupCount = this._getGroupCount();
var groupOrientation = groupCount > 0 ? this.option("groupOrientation") : this._getDefaultGroupStrategy();
var options = _extends({
groupByDate: this.option("groupByDate"),
startRowIndex: 0,
startCellIndex: 0,
groupOrientation: groupOrientation,
today: null === (_a = this._getToday) || void 0 === _a ? void 0 : _a.call(this),
groups: this.option("groups"),
isProvideVirtualCellsWidth: isProvideVirtualCellsWidth,
isAllDayPanelVisible: this.isAllDayPanelVisible,
selectedCells: this.cellsSelectionState.getSelectedCells(),
focusedCell: this.cellsSelectionState.focusedCell,
headerCellTextFormat: this._getFormat(),
getDateForHeaderText: (_, date) => date,
viewOffset: this.option("viewOffset"),
startDayHour: this.option("startDayHour"),
endDayHour: this.option("endDayHour"),
cellDuration: this.getCellDuration(),
viewType: this.type,
intervalCount: this.option("intervalCount"),
hoursInterval: this.option("hoursInterval"),
currentDate: this.option("currentDate"),
startDate: this.option("startDate"),
firstDayOfWeek: this.option("firstDayOfWeek"),
showCurrentTimeIndicator: this.option("showCurrentTimeIndicator")
}, this.virtualScrollingDispatcher.getRenderState());
return options
}
renovatedRenderSupported() {
return true
}
_updateGroupTableHeight() {
if (this._isVerticalGroupedWorkSpace() && hasWindow()) {
this._setHorizontalGroupHeaderCellsHeight()
}
}
updateHeaderEmptyCellWidth() {
if (hasWindow() && this._isRenderHeaderPanelEmptyCell()) {
var timePanelWidth = this.getTimePanelWidth();
var groupPanelWidth = this.getGroupTableWidth();
this._$headerPanelEmptyCell.css("width", timePanelWidth + groupPanelWidth)
}
}
_isGroupsSpecified(resources) {
var _a;
return (null === (_a = this.option("groups")) || void 0 === _a ? void 0 : _a.length) && resources
}
_getGroupIndexByResourceId(id) {
var groups = this.option("groups");
var resourceTree = createResourcesTree(groups);
if (!resourceTree.length) {
return 0
}
return this._getGroupIndexRecursively(resourceTree, id)
}
_getGroupIndexRecursively(resourceTree, id) {
var currentKey = resourceTree[0].name;
var currentValue = id[currentKey];
return resourceTree.reduce((prevIndex, _ref2) => {
var {
leafIndex: leafIndex,
value: value,
children: children
} = _ref2;
var areValuesEqual = currentValue === value;
if (areValuesEqual && void 0 !== leafIndex) {
return leafIndex
}
if (areValuesEqual) {
return this._getGroupIndexRecursively(children, id)
}
return prevIndex
}, 0)
}
_getViewStartByOptions() {
return getViewStartByOptions(this.option("startDate"), this.option("currentDate"), this._getIntervalDuration(), this.option("startDate") ? this._calculateViewStartDate() : void 0)
}
_getIntervalDuration() {
return this.viewDataProvider.getIntervalDuration(this.option("intervalCount"))
}
_getHeaderDate() {
return this.getStartViewDate()
}
_calculateViewStartDate() {
return calculateViewStartDate(this.option("startDate"))
}
_firstDayOfWeek() {
return this.viewDataProvider.getFirstDayOfWeek(this.option("firstDayOfWeek"))
}
_attachEvents() {
this._createSelectionChangedAction();
this._attachClickEvent();
this._attachContextMenuEvent()
}
_attachClickEvent() {
var that = this;
var pointerDownAction = this._createAction(e => {
that._pointerDownHandler(e.event)
});
this._createCellClickAction();
var cellSelector = ".".concat(DATE_TABLE_CELL_CLASS, ",.").concat(ALL_DAY_TABLE_CELL_CLASS);
var $element = this.$element();
eventsEngine.off($element, SCHEDULER_WORKSPACE_DXPOINTERDOWN_EVENT_NAME);
eventsEngine.off($element, SCHEDULER_CELL_DXCLICK_EVENT_NAME);
eventsEngine.on($element, SCHEDULER_WORKSPACE_DXPOINTERDOWN_EVENT_NAME, e => {
if (isMouseEvent(e) && e.which > 1) {
e.preventDefault();
return
}
pointerDownAction({
event: e
})
});
eventsEngine.on($element, SCHEDULER_CELL_DXCLICK_EVENT_NAME, cellSelector, e => {
var $cell = $(e.target);
that._cellClickAction({
event: e,
cellElement: getPublicElement($cell),
cellData: that.getCellData($cell)
})
})
}
_createCellClickAction() {
this._cellClickAction = this._createActionByOption("onCellClick", {
afterExecute: e => this._cellClickHandler(e.args[0].event)
})
}
_createSelectionChangedAction() {
this._selectionChangedAction = this._createActionByOption("onSelectionChanged")
}
_cellClickHandler(argument) {
if (this._showPopup) {
delete this._showPopup;
this._handleSelectedCellsClick()
}
}
_pointerDownHandler(e) {
var $target = $(e.target);
if (!$target.hasClass(DATE_TABLE_CELL_CLASS) && !$target.hasClass(ALL_DAY_TABLE_CELL_CLASS)) {
this._isCellClick = false;
return
}
this._isCellClick = true;
if ($target.hasClass(DATE_TABLE_FOCUSED_CELL_CLASS)) {
this._showPopup = true
} else {
var cellCoordinates = this._getCoordinatesByCell($target);
var isAllDayCell = this._hasAllDayClass($target);
this._setSelectedCellsStateAndUpdateSelection(isAllDayCell, cellCoordinates, false, $target)
}
}
_handleSelectedCellsClick() {
var selectedCells = this.cellsSelectionState.getSelectedCells();
var firstCellData = selectedCells[0];
var lastCellData = selectedCells[selectedCells.length - 1];
var result = {
startDate: firstCellData.startDate,
endDate: lastCellData.endDate
};
if (void 0 !== lastCellData.allDay) {
result.allDay = lastCellData.allDay
}
this.option("onSelectedCellsClick")(result, lastCellData.groups)
}
_attachContextMenuEvent() {
this._createContextMenuAction();
var cellSelector = ".".concat(DATE_TABLE_CELL_CLASS, ",.").concat(ALL_DAY_TABLE_CELL_CLASS);
var $element = this.$element();
var eventName = addNamespace(contextMenuEventName, this.NAME);
eventsEngine.off($element, eventName, cellSelector);
eventsEngine.on($element, eventName, cellSelector, this._contextMenuHandler.bind(this))
}
_contextMenuHandler(e) {
var $cell = $(e.target);
this._contextMenuAction({
event: e,
cellElement: getPublicElement($cell),
cellData: this.getCellData($cell)
});
this._contextMenuHandled = true
}
_createContextMenuAction() {
this._contextMenuAction = this._createActionByOption("onCellContextMenu")
}
_getGroupHeaderContainer() {
if (this._isVerticalGroupedWorkSpace()) {
return this._$groupTable
}
return this._$thead
}
_getDateHeaderContainer() {
return this._$thead
}
_getCalculateHeaderCellRepeatCount() {
return this._groupedStrategy.calculateHeaderCellRepeatCount()
}
_updateScrollable() {
var _a, _b;
this._dateTableScrollable.update();
null === (_a = this._headerScrollable) || void 0 === _a ? void 0 : _a.update();
null === (_b = this._sidebarScrollable) || void 0 === _b ? void 0 : _b.update()
}
_getTimePanelRowCount() {
return this._getCellCountInDay()
}
_getCellCountInDay() {
var hoursInterval = this.option("hoursInterval");
var startDayHour = this.option("startDayHour");
var endDayHour = this.option("endDayHour");
return this.viewDataProvider.getCellCountInDay(startDayHour, endDayHour, hoursInterval)
}
_getTotalCellCount(groupCount) {
return this._groupedStrategy.getTotalCellCount(groupCount)
}
_getTotalRowCount(groupCount, includeAllDayPanelRows) {
var result = this._groupedStrategy.getTotalRowCount(groupCount);
if (includeAllDayPanelRows && this.isAllDayPanelVisible) {
result += groupCount
}
return result
}
_getGroupIndex(rowIndex, columnIndex) {
return this._groupedStrategy.getGroupIndex(rowIndex, columnIndex)
}
calculateEndDate(startDate) {
var {
viewDataGenerator: viewDataGenerator
} = this.viewDataProvider;
return viewDataGenerator.calculateEndDate(startDate, viewDataGenerator.getInterval(this.option("hoursInterval")), this.option("endDayHour"))
}
_getGroupCount() {
return getGroupCount(this.option("groups"))
}
_attachTablesEvents() {
var element = this.$element();
this._attachDragEvents(element);
this._attachPointerEvents(element)
}
_detachDragEvents(element) {
eventsEngine.off(element, DragEventNames.ENTER);
eventsEngine.off(element, DragEventNames.LEAVE);
eventsEngine.off(element, DragEventNames.DROP)
}
_attachDragEvents(element) {
this._detachDragEvents(element);
eventsEngine.on(element, DragEventNames.ENTER, DRAG_AND_DROP_SELECTOR, {
checkDropTarget: (target, event) => !this._isOutsideScrollable(target, event)
}, e => {
if (!this.preventDefaultDragging) {
this.removeDroppableCellClass();
$(e.target).addClass(DATE_TABLE_DROPPABLE_CELL_CLASS)
}
});
eventsEngine.on(element, DragEventNames.LEAVE, () => {
if (!this.preventDefaultDragging) {
this.removeDroppableCellClass()
}
});
eventsEngine.on(element, DragEventNames.DROP, DRAG_AND_DROP_SELECTOR, () => {
var _a, _b;
if (!this.dragBehavior) {
return
}
if (!(null === (_a = this.dragBehavior) || void 0 === _a ? void 0 : _a.dragBetweenComponentsPromise)) {
this.dragBehavior.removeDroppableClasses();
return
}
null === (_b = this.dragBehavior.dragBetweenComponentsPromise) || void 0 === _b ? void 0 : _b.then(() => {
this.dragBehavior.removeDroppableClasses()
})
})
}
_attachPointerEvents(element) {
var isPointerDown = false;
eventsEngine.off(element, SCHEDULER_CELL_DXPOINTERMOVE_EVENT_NAME);
eventsEngine.off(element, SCHEDULER_CELL_DXPOINTERDOWN_EVENT_NAME);
eventsEngine.on(element, SCHEDULER_CELL_DXPOINTERDOWN_EVENT_NAME, DRAG_AND_DROP_SELECTOR, e => {
if (isMouseEvent(e) && 1 === e.which) {
isPointerDown = true;
this.$element().addClass(WORKSPACE_WITH_MOUSE_SELECTION_CLASS);
eventsEngine.off(domAdapter.getDocument(), SCHEDULER_CELL_DXPOINTERUP_EVENT_NAME);
eventsEngine.on(domAdapter.getDocument(), SCHEDULER_CELL_DXPOINTERUP_EVENT_NAME, () => {
isPointerDown = false;
this.$element().removeClass(WORKSPACE_WITH_MOUSE_SELECTION_CLASS)
})
}
});
eventsEngine.on(element, SCHEDULER_CELL_DXPOINTERMOVE_EVENT_NAME, DRAG_AND_DROP_SELECTOR, e => {
if (isPointerDown && this._dateTableScrollable && !this._dateTableScrollable.option("scrollByContent")) {
e.preventDefault();
e.stopPropagation();
this._moveToCell($(e.target), true)
}
})
}
_getFormat() {
return abstract()
}
getWorkArea() {
return this._$dateTableContainer
}
getScrollable() {
return this._dateTableScrollable
}
getScrollableScrollTop() {
return this._dateTableScrollable.scrollTop()
}
getGroupedScrollableScrollTop(allDay) {
return this._groupedStrategy.getScrollableScrollTop(allDay)
}
getScrollableScrollLeft() {
return this._dateTableScrollable.scrollLeft()
}
getScrollableOuterWidth() {
return this._dateTableScrollable.scrollWidth()
}
getScrollableContainer() {
return $(this._dateTableScrollable.container())
}
getHeaderPanelHeight() {
return this._$headerPanel && getOuterHeight(this._$headerPanel, true)
}
getTimePanelWidth() {
return this._$timePanel && getBoundingRect(this._$timePanel.get(0)).width
}
getGroupTableWidth() {
return this._$groupTable ? getOuterWidth(this._$groupTable) : 0
}
getWorkSpaceLeftOffset() {
return this._groupedStrategy.getLeftOffset()
}
_getCellCoordinatesByIndex(index) {
var columnIndex = Math.floor(index / this._getRowCount());
var rowIndex = index - this._getRowCount() * columnIndex;
return {
columnIndex: columnIndex,
rowIndex: rowIndex
}
}
_getDateGenerationOptions() {
var _a;
return {
startDayHour: this.option("startDayHour"),
endDayHour: this.option("endDayHour"),
isWorkView: this.viewDataProvider.viewDataGenerator.isWorkView,
interval: null === (_a = this.viewDataProvider.viewDataGenerator) || void 0 === _a ? void 0 : _a.getInterval(this.option("hoursInterval")),
startViewDate: this.getStartViewDate(),
firstDayOfWeek: this._firstDayOfWeek()
}
}
_getIntervalBetween(currentDate, allDay) {
var firstViewDate = this.getStartViewDate();
var startDayTime = this.option("startDayHour") * HOUR_MS;
var timeZoneOffset = dateUtils.getTimezonesDifference(firstViewDate, currentDate);
var fullInterval = currentDate.getTime() - firstViewDate.getTime() - timeZoneOffset;
var days = this._getDaysOfInterval(fullInterval, startDayTime);
var weekendsCount = this._getWeekendsCount(days);
var result = (days - weekendsCount) * DAY_MS;
if (!allDay) {
var {
hiddenInterval: hiddenInterval
} = this.viewDataProvider;
var visibleDayDuration = this.getVisibleDayDuration();
result = fullInterval - days * hiddenInterval - weekendsCount * visibleDayDuration
}
return result
}
_getWeekendsCount(argument) {
return 0
}
_getDaysOfInterval(fullInterval, startDayTime) {
return Math.floor((fullInterval + startDayTime) / DAY_MS)
}
_updateIndex(index) {
return index * this._getRowCount()
}
_getDroppableCell() {
return this._getDateTables().find(".".concat(DATE_TABLE_DROPPABLE_CELL_CLASS))
}
_getWorkSpaceWidth() {
return this.cache.get("workspaceWidth", () => {
if (this._needCreateCrossScrolling()) {
return getBoundingRect(this._$dateTable.get(0)).width
}
var totalWidth = getBoundingRect(this.$element().get(0)).width;
var timePanelWidth = this.getTimePanelWidth();
var groupTableWidth = this.getGroupTableWidth();
return totalWidth - timePanelWidth - groupTableWidth
})
}
_getCellByCoordinates(cellCoordinates, groupIndex, inAllDayRow) {
var indexes = this._groupedStrategy.prepareCellIndexes(cellCoordinates, groupIndex, inAllDayRow);
return this._dom_getDateCell(indexes)
}
_dom_getDateCell(position) {
return this._$dateTable.find("tr:not(.".concat(VIRTUAL_ROW_CLASS, ")")).eq(position.rowIndex).find("td:not(.".concat(VIRTUAL_CELL_CLASS, ")")).eq(position.columnIndex)
}
_dom_getAllDayPanelCell(columnIndex) {
return this._$allDayPanel.find("tr").eq(0).find("td").eq(columnIndex)
}
_getCells(allDay, direction) {
var cellClass = allDay ? ALL_DAY_TABLE_CELL_CLASS : DATE_TABLE_CELL_CLASS;
if ("vertical" === direction) {
var result = [];
for (var i = 1;; i++) {
var cells = this.$element().find("tr .".concat(cellClass, ":nth-child(").concat(i, ")"));
if (!cells.length) {
break
}
result = result.concat(cells.toArray())
}
return $(result)
}
return this.$element().find(".".concat(cellClass))
}
_getFirstAndLastDataTableCell() {
var selector = this.isVirtualScrolling() ? ".".concat(DATE_TABLE_CELL_CLASS, ", .").concat(VIRTUAL_CELL_CLASS) : ".".concat(DATE_TABLE_CELL_CLASS);
var $cells = this.$element().find(selector);
return [$cells[0], $cells[$cells.length - 1]]
}
_getAllCells(allDay) {
if (this._isVerticalGroupedWorkSpace()) {
return this._$dateTable.find("td:not(.".concat(VIRTUAL_CELL_CLASS, ")"))
}
var cellClass = allDay && this.supportAllDayRow() ? ALL_DAY_TABLE_CELL_CLASS : DATE_TABLE_CELL_CLASS;
return this.$element().find(".".concat(cellClass))
}
_setHorizontalGroupHeaderCellsHeight() {
var {
height: height
} = getBoundingRect(this._$dateTable.get(0));
setOuterHeight(this._$groupTable, height)
}
_getGroupHeaderCells() {
return this.$element().find(".".concat(GROUP_HEADER_CLASS))
}
_getScrollCoordinates(hours, minutes, date, groupIndex, allDay) {
var currentDate = date || new Date(this.option("currentDate"));
var startDayHour = this.option("startDayHour");
var endDayHour = this.option("endDayHour");
if (hours < startDayHour) {
hours = startDayHour
}
if (hours >= endDayHour) {
hours = endDayHour - 1
}
currentDate.setHours(hours, minutes, 0, 0);
var cell = this.viewDataProvider.findGlobalCellPosition(currentDate, groupIndex, allDay);
var {
position: position,
cellData: cellData
} = cell;
return this.virtualScrollingDispatcher.calculateCoordinatesByDataAndPosition(cellData, position, currentDate, isDateAndTimeView(this.type), "vertical" === this.viewDirection)
}
_isOutsideScrollable(target, event) {
var $dateTableScrollableElement = this._dateTableScrollable.$element();
var scrollableSize = getBoundingRect($dateTableScrollableElement.get(0));
var window = getWindow();
var isTargetInAllDayPanel = !$(target).closest($dateTableScrollableElement).length;
var isOutsideHorizontalScrollable = event.pageX < scrollableSize.left || event.pageX > scrollableSize.left + scrollableSize.width + (window.scrollX || 0);
var isOutsideVerticalScrollable = event.pageY < scrollableSize.top || event.pageY > scrollableSize.top + scrollableSize.height + (window.scrollY || 0);
if (isTargetInAllDayPanel && !isOutsideHorizontalScrollable) {
return false
}
return isOutsideVerticalScrollable || isOutsideHorizontalScrollable
}
setCellDataCache(cellCoordinates, groupIndex, $cell) {
var key = JSON.stringify({
rowIndex: cellCoordinates.rowIndex,
columnIndex: cellCoordinates.columnIndex,
groupIndex: groupIndex
});
this.cache.set(key, this.getCellData($cell))
}
setCellDataCacheAlias(appointment, geometry) {
var key = JSON.stringify({
rowIndex: appointment.rowIndex,
columnIndex: appointment.columnIndex,
groupIndex: appointment.groupIndex
});
var aliasKey = JSON.stringify({
top: geometry.top,
left: geometry.left
});
this.cache.set(aliasKey, this.cache.get(key))
}
supportAllDayRow() {
return true
}
keepOriginalHours() {
return false
}
_filterCellDataFields(cellData) {
return extend(true, {}, {
startDate: cellData.startDate,
endDate: cellData.endDate,
groups: cellData.groups,
groupIndex: cellData.groupIndex,
allDay: cellData.allDay
})
}
getCellData($cell) {
var cellData = this._getFullCellData($cell) || {};
return this._filterCellDataFields(cellData)
}
_getFullCellData($cell) {
var currentCell = $cell[0];
if (currentCell) {
return this._getDataByCell($cell)
}
return
}
_getVirtualRowOffset() {
return this.virtualScrollingDispatcher.virtualRowOffset
}
_getVirtualCellOffset() {
return this.virtualScrollingDispatcher.virtualCellOffset
}
_getDataByCell($cell) {
var rowIndex = $cell.parent().index() - this.virtualScrollingDispatcher.topVirtualRowsCount;
var columnIndex = $cell.index() - this.virtualScrollingDispatcher.leftVirtualCellsCount;
var {
viewDataProvider: viewDataProvider
} = this;
var isAllDayCell = this._hasAllDayClass($cell);
var cellData = viewDataProvider.getCellData(rowIndex, columnIndex, isAllDayCell);
return cellData || void 0
}
isGroupedByDate() {
return this.option("groupByDate") && this._isHorizontalGroupedWorkSpace() && this._getGroupCount() > 0
}
getCellIndexByDate(date, inAllDayRow) {
var {
viewDataGenerator: viewDataGenerator
} = this.viewDataProvider;
var timeInterval = inAllDayRow ? 864e5 : viewDataGenerator.getInterval(this.option("hoursInterval"));
var startViewDateOffset = getStartViewDateTimeOffset(this.getStartViewDate(), this.option("startDayHour"));
var dateTimeStamp = this._getIntervalBetween(date, inAllDayRow) + startViewDateOffset;
var index = Math.floor(dateTimeStamp / timeInterval);
if (inAllDayRow) {
index = this._updateIndex(index)
}
if (index < 0) {
index = 0
}
return index
}
getDroppableCellIndex() {
var $droppableCell = this._getDroppableCell();
var $row = $droppableCell.parent();
var rowIndex = $row.index();
return rowIndex * $row.find("td").length + $droppableCell.index()
}
getDataByDroppableCell() {
var cellData = this.getCellData($(this._getDroppableCell()));
var {
allDay: allDay
} = cellData;
var {
startDate: startDate
} = cellData;
var {
endDate: endDate
} = cellData;
return {
startDate: startDate,
endDate: endDate,
allDay: allDay,
groups: cellData.groups
}
}
getDateRange() {
return [this.getStartViewDate(), this.getEndViewDateByEndDayHour()]
}
getCellMinWidth() {
return DATE_TABLE_MIN_CELL_WIDTH
}
getRoundedCellWidth(groupIndex, startIndex, cellCount) {
if (groupIndex < 0 || !hasWindow()) {
return 0
}
var $row = this.$element().find(".".concat(DATE_TABLE_ROW_CLASS)).eq(0);
var width = 0;
var $cells = $row.find(".".concat(DATE_TABLE_CELL_CLASS));
var totalCellCount = this._getCellCount() * groupIndex;
cellCount = cellCount || this._getCellCount();
if (!isDefined(startIndex)) {
startIndex = totalCellCount
}
for (var i = startIndex; i < totalCellCount + cellCount; i++) {
var element = $($cells).eq(i).get(0);
var elementWidth = element ? getBoundingRect(element).width : 0;
width += elementWidth
}
return width / (totalCellCount + cellCount - startIndex)
}
getCellWidth() {
return getCellWidth(this.getDOMElementsMetaData())
}
getCellHeight() {
return getCellHeight(this.getDOMElementsMetaData())
}
getAllDayHeight() {
return getAllDayHeight(this.option("showAllDayPanel"), this._isVerticalGroupedWorkSpace(), this.getDOMElementsMetaData())
}
getMaxAllowedPosition(groupIndex) {
return getMaxAllowedPosition(groupIndex, this.viewDataProvider, this.option("rtlEnabled"), this.getDOMElementsMetaData())
}
getAllDayOffset() {
return this._groupedStrategy.getAllDayOffset()
}
getCellIndexByCoordinates(coordinates, allDay) {
var _a, _b, _c;
var {
horizontalScrollingState: horizontalScrollingState,
verticalScrollingState: verticalScrollingState
} = this.virtualScrollingDispatcher;
var cellCount = null !== (_a = null === horizontalScrollingState || voi