@duoduo-oba/ng-devui
Version:
DevUI components based on Angular
295 lines • 23 kB
JavaScript
/**
* @fileoverview added by tsickle
* Generated from: splitter.service.ts
* @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
*/
import { Injectable } from '@angular/core';
var SplitterService = /** @class */ (function () {
function SplitterService() {
this.paneCount = 0;
}
// 配置pane信息，panes列表，方向，容器大小，方便后续计算使用
// 配置pane信息，panes列表，方向，容器大小，方便后续计算使用
/**
* @param {?} __0
* @return {?}
*/
SplitterService.prototype.configPane =
// 配置pane信息，panes列表，方向，容器大小，方便后续计算使用
/**
* @param {?} __0
* @return {?}
*/
function (_a) {
var panes = _a.panes, orientation = _a.orientation, containerSize = _a.containerSize;
this.panes = panes;
this.panes.forEach((/**
* @param {?} pane
* @param {?} index
* @return {?}
*/
function (pane, index) {
pane.order = index * 2;
pane.orientation = orientation;
}));
this.paneCount = this.panes.length;
this.containerSize = containerSize;
};
// 按下的时候计算pane的size信息
// 按下的时候计算pane的size信息
/**
* @param {?} splitbarIndex
* @return {?}
*/
SplitterService.prototype.dragState =
// 按下的时候计算pane的size信息
/**
* @param {?} splitbarIndex
* @return {?}
*/
function (splitbarIndex) {
/** @type {?} */
var prev = this.getPane(splitbarIndex);
/** @type {?} */
var next = this.getPane(splitbarIndex + 1);
/** @type {?} */
var total = prev.computedSize + next.computedSize;
return {
prev: {
index: splitbarIndex,
initialSize: prev.computedSize,
// 设置有最小值，直接取值，如果没有设置就用两个pane总和减去相邻pane的最大值，都没设置（NAN）在取0
minSize: this.toPixels(prev.minSize) || total - this.toPixels(next.maxSize) || 0,
// 设置有最大值，直接取值，如果没有设置就用两个pane总和减去相邻pane的最小值，都没设置（NAN）在取两个pane总和
maxSize: this.toPixels(prev.maxSize) || total - this.toPixels(next.minSize) || total
},
next: {
index: splitbarIndex + 1,
initialSize: next.computedSize,
minSize: this.toPixels(next.minSize) || total - this.toPixels(prev.maxSize) || 0,
maxSize: this.toPixels(next.maxSize) || total - this.toPixels(prev.minSize) || total
}
};
};
// 设置pane大小
// 设置pane大小
/**
* @param {?} state
* @param {?} distance
* @return {?}
*/
SplitterService.prototype.setSize =
// 设置pane大小
/**
* @param {?} state
* @param {?} distance
* @return {?}
*/
function (state, distance) {
/** @type {?} */
var prev = this.getPane(state.prev.index);
/** @type {?} */
var next = this.getPane(state.next.index);
if (prev.size && next.size) {
// 相邻的两个pane都指定了size，需要同时修改size
this.resize(state.prev, distance);
this.resize(state.next, -distance);
}
else if (next.size) {
// 如果 next pane，指定了size就修改next pane
this.resize(state.next, -distance);
}
else {
// 最后不管pre pane，有没有指定，都修改 pre pane
this.resize(state.prev, distance);
}
};
// 大小限制函数，（max）小于最小值时取最小值， （min）大于最大值时取最大值
// 大小限制函数，（max）小于最小值时取最小值， （min）大于最大值时取最大值
/**
* @param {?} minSize
* @param {?} maxSize
* @param {?} initialSize
* @return {?}
*/
SplitterService.prototype.clamp =
// 大小限制函数，（max）小于最小值时取最小值， （min）大于最大值时取最大值
/**
* @param {?} minSize
* @param {?} maxSize
* @param {?} initialSize
* @return {?}
*/
function (minSize, maxSize, initialSize) {
return Math.min(maxSize, Math.max(minSize, initialSize));
};
// resize pane的大小
// resize pane的大小
/**
* @param {?} paneState
* @param {?} moveSize
* @return {?}
*/
SplitterService.prototype.resize =
// resize pane的大小
/**
* @param {?} paneState
* @param {?} moveSize
* @return {?}
*/
function (paneState, moveSize) {
/** @type {?} */
var pane = this.getPane(paneState.index);
/** @type {?} */
var splitterSize = this.containerSize();
/** @type {?} */
var newSize = this.clamp(paneState.minSize, paneState.maxSize, paneState.initialSize + moveSize);
/** @type {?} */
var size = '';
if (this.isPercent(pane.size)) {
size = (100 * newSize / splitterSize) + '%';
}
else {
size = newSize + 'px';
}
pane.size = size;
pane.sizeChange.emit(size);
};
// 判断pane是否可以调整大小，只要有一边设置了不可调整或者收起，相邻pane调整就失效
// 判断pane是否可以调整大小，只要有一边设置了不可调整或者收起，相邻pane调整就失效
/**
* @param {?} splitBarIndex
* @return {?}
*/
SplitterService.prototype.isResizable =
// 判断pane是否可以调整大小，只要有一边设置了不可调整或者收起，相邻pane调整就失效
/**
* @param {?} splitBarIndex
* @return {?}
*/
function (splitBarIndex) {
/** @type {?} */
var prevPane = this.getPane(splitBarIndex);
/** @type {?} */
var nextPane = this.getPane(splitBarIndex + 1);
/** @type {?} */
var paneCollapsed = prevPane.collapsed || nextPane.collapsed;
return prevPane.resizable && nextPane.resizable && !paneCollapsed;
};
// 判断分割条是否是固定的，只要有一边不能调整, 就是禁用状态固定bar
// 判断分割条是否是固定的，只要有一边不能调整, 就是禁用状态固定bar
/**
* @param {?} splitBarIndex
* @return {?}
*/
SplitterService.prototype.isStaticBar =
// 判断分割条是否是固定的，只要有一边不能调整, 就是禁用状态固定bar
/**
* @param {?} splitBarIndex
* @return {?}
*/
function (splitBarIndex) {
/** @type {?} */
var prevPane = this.getPane(splitBarIndex);
/** @type {?} */
var nextPane = this.getPane(splitBarIndex + 1);
return !(prevPane.resizable && nextPane.resizable);
};
// 获取pane，防止没有初始化的时候调用内部方法取值
// 获取pane，防止没有初始化的时候调用内部方法取值
/**
* @param {?} index
* @return {?}
*/
SplitterService.prototype.getPane =
// 获取pane，防止没有初始化的时候调用内部方法取值
/**
* @param {?} index
* @return {?}
*/
function (index) {
if (!this.panes || index < 0 || index >= this.panes.length) {
throw new Error('no pane can return.');
}
return this.panes[index];
};
// 判断是不是百分比设置宽度
// 判断是不是百分比设置宽度
/**
* @param {?} size
* @return {?}
*/
SplitterService.prototype.isPercent =
// 判断是不是百分比设置宽度
/**
* @param {?} size
* @return {?}
*/
function (size) {
return /%$/.test(size);
};
// 计算时把百分比转换为像素
// 计算时把百分比转换为像素
/**
* @param {?} size
* @return {?}
*/
SplitterService.prototype.toPixels =
// 计算时把百分比转换为像素
/**
* @param {?} size
* @return {?}
*/
function (size) {
// 值不满足转换时，result为NAN，方便计算最小、最大宽度判断
/** @type {?} */
var result = parseFloat(size);
if (this.isPercent(size)) {
result = (this.containerSize() * result / 100);
}
return result;
};
// 切换pane展开，收起
// 切换pane展开，收起
/**
* @param {?} paneIndex
* @param {?} nearPaneIndex
* @return {?}
*/
SplitterService.prototype.togglePane =
// 切换pane展开，收起
/**
* @param {?} paneIndex
* @param {?} nearPaneIndex
* @return {?}
*/
function (paneIndex, nearPaneIndex) {
/** @type {?} */
var pane = this.getPane(paneIndex);
/** @type {?} */
var nearPane = this.getPane(nearPaneIndex);
if (pane.collapsible) {
pane.collapsed = !pane.collapsed;
pane.toggleCollapseClass();
nearPane.toggleNearPaneFlexGrow();
pane.collapsedChange.emit(pane.collapsed);
}
};
SplitterService.decorators = [
{ type: Injectable }
];
return SplitterService;
}());
export { SplitterService };
if (false) {
/** @type {?} */
SplitterService.prototype.panes;
/**
* @type {?}
* @private
*/
SplitterService.prototype.containerSize;
/** @type {?} */
SplitterService.prototype.paneCount;
}
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"splitter.service.js","sourceRoot":"ng://ng-devui/splitter/","sources":["splitter.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable } from '@angular/core';\r\nimport { SplitterPaneComponent } from './splitter-pane.component';\r\n\r\n@Injectable()\r\nexport class SplitterService {\r\n  panes: Array<SplitterPaneComponent>;\r\n  private containerSize: Function;\r\n  paneCount = 0;\r\n\r\n  // 配置pane信息，panes列表，方向，容器大小，方便后续计算使用\r\n  configPane({panes, orientation, containerSize}) {\r\n    this.panes = panes;\r\n    this.panes.forEach((pane, index) => {\r\n      pane.order = index * 2;\r\n      pane.orientation = orientation;\r\n    });\r\n    this.paneCount = this.panes.length;\r\n    this.containerSize = containerSize;\r\n  }\r\n\r\n  // 按下的时候计算pane的size信息\r\n  dragState(splitbarIndex) {\r\n    const prev = this.getPane(splitbarIndex);\r\n    const next = this.getPane(splitbarIndex + 1);\r\n    const total = prev.computedSize + next.computedSize;\r\n    return {\r\n        prev: {\r\n            index: splitbarIndex,\r\n            initialSize: prev.computedSize,\r\n            // 设置有最小值，直接取值，如果没有设置就用两个pane总和减去相邻pane的最大值，都没设置（NAN）在取0\r\n            minSize: this.toPixels(prev.minSize) || total - this.toPixels(next.maxSize) || 0,\r\n            // 设置有最大值，直接取值，如果没有设置就用两个pane总和减去相邻pane的最小值，都没设置（NAN）在取两个pane总和\r\n            maxSize: this.toPixels(prev.maxSize) || total - this.toPixels(next.minSize) || total\r\n        },\r\n        next: {\r\n            index: splitbarIndex + 1,\r\n            initialSize: next.computedSize,\r\n            minSize: this.toPixels(next.minSize) || total - this.toPixels(prev.maxSize) || 0,\r\n            maxSize: this.toPixels(next.maxSize) || total - this.toPixels(prev.minSize) || total\r\n        }\r\n    };\r\n  }\r\n\r\n  // 设置pane大小\r\n  setSize(state, distance) {\r\n    const prev = this.getPane(state.prev.index);\r\n    const next = this.getPane(state.next.index);\r\n    if (prev.size && next.size) {\r\n      // 相邻的两个pane都指定了size，需要同时修改size\r\n      this.resize(state.prev, distance);\r\n      this.resize(state.next, -distance);\r\n    } else if (next.size) {\r\n      // 如果 next pane，指定了size就修改next pane\r\n      this.resize(state.next, -distance);\r\n    } else {\r\n      // 最后不管pre pane，有没有指定，都修改 pre pane\r\n      this.resize(state.prev, distance);\r\n    }\r\n  }\r\n\r\n  // 大小限制函数，（max）小于最小值时取最小值， （min）大于最大值时取最大值\r\n  clamp(minSize, maxSize, initialSize) {\r\n    return Math.min(maxSize, Math.max(minSize, initialSize));\r\n  }\r\n\r\n  // resize pane的大小\r\n  resize(paneState, moveSize) {\r\n      const pane = this.getPane(paneState.index);\r\n      const splitterSize = this.containerSize();\r\n      const newSize = this.clamp(paneState.minSize, paneState.maxSize, paneState.initialSize + moveSize);\r\n      let size = '';\r\n      if (this.isPercent(pane.size)) {\r\n          size = (100 * newSize / splitterSize) + '%';\r\n      } else {\r\n          size = newSize + 'px';\r\n      }\r\n      pane.size = size;\r\n      pane.sizeChange.emit(size);\r\n  }\r\n\r\n  // 判断pane是否可以调整大小，只要有一边设置了不可调整或者收起，相邻pane调整就失效\r\n  isResizable(splitBarIndex) {\r\n    const prevPane = this.getPane(splitBarIndex);\r\n    const nextPane = this.getPane(splitBarIndex + 1);\r\n    const paneCollapsed = prevPane.collapsed || nextPane.collapsed;\r\n    return prevPane.resizable && nextPane.resizable && !paneCollapsed;\r\n  }\r\n\r\n  // 判断分割条是否是固定的，只要有一边不能调整, 就是禁用状态固定bar\r\n  isStaticBar(splitBarIndex) {\r\n    const prevPane = this.getPane(splitBarIndex);\r\n    const nextPane = this.getPane(splitBarIndex + 1);\r\n    return !(prevPane.resizable && nextPane.resizable);\r\n  }\r\n\r\n  // 获取pane，防止没有初始化的时候调用内部方法取值\r\n  getPane(index) {\r\n    if (!this.panes || index < 0 || index >= this.panes.length) {\r\n      throw new Error('no pane can return.');\r\n    }\r\n    return this.panes[index];\r\n  }\r\n\r\n  // 判断是不是百分比设置宽度\r\n  isPercent(size) {\r\n    return /%$/.test(size);\r\n  }\r\n\r\n  // 计算时把百分比转换为像素\r\n  toPixels(size) {\r\n    // 值不满足转换时，result为NAN，方便计算最小、最大宽度判断\r\n    let result = parseFloat(size);\r\n    if (this.isPercent(size)) {\r\n      result = (this.containerSize() * result / 100);\r\n    }\r\n    return result;\r\n  }\r\n\r\n  // 切换pane展开，收起\r\n  togglePane(paneIndex, nearPaneIndex) {\r\n    const pane = this.getPane(paneIndex);\r\n    const nearPane = this.getPane(nearPaneIndex);\r\n    if (pane.collapsible) {\r\n        pane.collapsed = !pane.collapsed;\r\n        pane.toggleCollapseClass();\r\n        nearPane.toggleNearPaneFlexGrow();\r\n        pane.collapsedChange.emit(pane.collapsed);\r\n    }\r\n  }\r\n}\r\n"]}