devexpress-reporting
Version:
DevExpress Reporting provides the capability to develop a reporting application to create and customize reports.
223 lines (222 loc) • 10.6 kB
JavaScript
/**
* DevExpress HTML/JS Reporting (viewer\parameters\parameterPanelItemBase.js)
* Version: 25.2.3
* Build date: Dec 15, 2025
* Copyright (c) 2012 - 2025 Developer Express Inc. ALL RIGHTS RESERVED
* License: https://www.devexpress.com/Support/EULAs/universal.xml
*/
var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
return c > 3 && r && Object.defineProperty(target, key, r), r;
};
import { floatValueConverter, getUniqueName, integerValueConverter } from '@devexpress/analytics-core/analytics-internal-native';
import { viewerEditorTemplates } from '../widgets/editorTemplates';
import { PreviewParameter } from './previewParameter';
import { PreviewParameterHelper } from './previewParameterHelper';
import { mutable, subscribableProperty, BaseEmptyModel, updateViewModel, BaseRenderingModel, nativeMultiPlatformEngine } from '@devexpress/analytics-core/analytics-serializer-native';
import { Locker } from '../../common/utils/_locker';
export class ParameterPanelItemBase extends BaseRenderingModel {
deferredUpdateViewModel() { return false; }
onPropertyChanged(args) {
if (args.propertyName === '_getInfo') {
const newArgs = {
...args,
propertyName: 'getInfo'
};
updateViewModel(this, args);
this['events'] && this['events'].call('propertyChanged', newArgs);
}
}
constructor(parameterHelper, _layoutInfo, _root) {
super();
this.parameterHelper = parameterHelper;
this._layoutInfo = _layoutInfo;
this._root = _root;
this._parameters = [];
this._separatorNames = [];
this._groupLayoutItems = [];
this.getInfo = () => this._getInfo;
this.parameterHelper = parameterHelper || new PreviewParameterHelper();
}
_fixGroupPropertyName(name) {
return getUniqueName(Object.keys(this), name.toLocaleLowerCase().replace(/\s/g, '_'));
}
_getParameterByPath(path) {
return this._parameters.filter(parameter => PreviewParameterHelper.getPrivatePropertyName(parameter.path) === path)[0];
}
_proceedLayoutInfo(layoutInfo, previewParameters) {
this._getInfo = [];
this._groupLayoutItems = [];
layoutInfo.layoutItems.forEach(itemInfo => {
if (itemInfo.type === 'Group') {
const groupItemInfo = itemInfo;
const name = this._fixGroupPropertyName(groupItemInfo.title);
const info = {
propertyName: name,
displayName: groupItemInfo.title,
editor: viewerEditorTemplates.groupEditor,
editorOptions: {
expanded: groupItemInfo.expanded,
titleVisible: groupItemInfo.titleVisible,
showExpandButton: groupItemInfo.showExpandButton,
borderVisible: itemInfo.borderVisible,
orientation: groupItemInfo.orientation
}
};
const item = new ParameterPanelItemBase(this.parameterHelper, groupItemInfo, this._root || this);
this[name] = item;
this._groupLayoutItems.push(item);
const newinfo = this._getInfo.concat(info);
this._getInfo = newinfo;
}
else if (itemInfo.type === 'Parameter') {
const parameterLayoutInfo = itemInfo;
const previewParameter = previewParameters.filter(x => x.path === parameterLayoutInfo.path)[0];
previewParameter && this._add(previewParameter, parameterLayoutInfo);
}
else if (itemInfo.type === 'Separator') {
const generatedName = this._fixGroupPropertyName('Separator');
this[generatedName] = new BaseEmptyModel();
this[generatedName].assignProperty('name', generatedName);
const info = {
propertyName: generatedName,
editor: viewerEditorTemplates.separatorEditor
};
const newinfo = this._getInfo.concat(info);
this._getInfo = newinfo;
this._separatorNames.push(generatedName);
}
});
}
_add(parameter, parameterInfo) {
if (this._parameters.indexOf(parameter) === -1) {
this._parameters.push(parameter);
}
if (!parameter.visible && !parameter.hasVisibleExpression) {
return parameter;
}
parameter.hasVerticalLabel = parameterInfo.labelOrientation === 'Vertical';
const privatePropertyName = PreviewParameterHelper.getPrivatePropertyName(parameter.path);
if (Array.isArray(parameter.value)) {
this.assignArrayProperty(privatePropertyName, parameter.value);
}
else {
this.assignProperty(privatePropertyName, parameter.value);
}
const locker = new Locker();
parameter.addDisposable(this.events.on(`${privatePropertyName}Changed`, (e) => {
locker.lock(() => parameter.value = this[privatePropertyName]);
}));
parameter.addDisposable(parameter.events.on('valueChanged', () => {
locker.lock(() => this[privatePropertyName] = parameter.value);
}));
const parameterPropertyName = PreviewParameterHelper.fixPropertyName(parameter.path);
if (parameter.isMultiValue || !parameter.isTypesCurrentType(parameter.intTypes.concat(parameter.floatTypes), parameter.type)) {
parameter.addDisposable(nativeMultiPlatformEngine.createComputedProperty(this, parameterPropertyName, {
read: () => parameter.value,
write: (newVal) => {
parameter.value = newVal;
}
}, [
subscribableProperty(parameter, ['value'])
]));
}
else {
parameter.addDisposable(nativeMultiPlatformEngine.createComputedProperty(this, parameterPropertyName, {
read: () => {
let parseValue = parameter.value;
if (parseValue === null || parseValue === undefined) {
return parseValue;
}
if (parameter.isTypesCurrentType(parameter.intTypes, parameter.type)) {
parseValue = parseInt(parseValue);
}
else if (parameter.isTypesCurrentType(parameter.floatTypes, parameter.type)) {
parseValue = parseFloat(parseValue);
}
return parseValue;
},
write: (newVal) => {
let expandValue = newVal;
if (parameter.allowNull && (expandValue === '' || expandValue === undefined)) {
expandValue = null;
}
else if (parameter.isTypesCurrentType(parameter.intTypes, parameter.type)) {
expandValue = integerValueConverter(expandValue, '0');
}
else if (parameter.isTypesCurrentType(parameter.floatTypes, parameter.type)) {
expandValue = floatValueConverter(expandValue, '0');
}
parameter.value = expandValue;
}
}, [
subscribableProperty(parameter, ['value'])
]));
}
const newinfo = this._getInfo.concat(parameter.valueInfo);
this._getInfo = newinfo;
return parameter;
}
get groupLayoutItems() {
return this._groupLayoutItems;
}
isPropertyDisabled(name) {
const parameter = this._getParameterByPath(name);
return parameter && !parameter.enabled;
}
isPropertyVisible(name) {
const parameter = this._getParameterByPath(name);
return !parameter || parameter.visible;
}
getPropertyDependencies(name, status) {
const parameter = this._getParameterByPath(name);
if (!parameter && status === 'visible') {
return (this._root || this)._parameters.map(parameter => subscribableProperty(parameter, [status]));
}
if (status === 'visible')
return [subscribableProperty(parameter, ['visible'])];
if (status === 'disabled')
return [subscribableProperty(parameter, ['enabled'])];
return [];
}
initialize(originalParametersInfo, parameters) {
this._parameters.forEach((usedParameter) => {
delete this[PreviewParameterHelper.fixPropertyName(usedParameter.path)];
delete this[PreviewParameterHelper.getPrivatePropertyName(usedParameter.path)];
usedParameter.dispose();
});
this._parameters = [];
if (!originalParametersInfo) {
this.isEmpty = true;
this._getInfo = [];
return;
}
parameters = parameters || (originalParametersInfo.parameters || []).map((parameter) => {
const previewParameter = new PreviewParameter(parameter, this.parameterHelper);
this._parameters.push(previewParameter);
return previewParameter;
});
const layoutInfo = originalParametersInfo.parameterPanelLayout || this._layoutInfo;
layoutInfo && this._proceedLayoutInfo(layoutInfo, parameters);
this._groupLayoutItems.forEach(item => item.initialize({}, parameters));
}
setParameterValueByPath(parameterPath, value) {
if (this[parameterPath] !== undefined) {
this[parameterPath].value ? this[parameterPath].value = value
: this[parameterPath] = value;
}
else {
this.groupLayoutItems?.forEach(groupLayoutItem => {
groupLayoutItem.setParameterValueByPath(parameterPath, value);
});
}
}
}
__decorate([
mutable(true)
], ParameterPanelItemBase.prototype, "isEmpty", void 0);
__decorate([
mutable(() => [])
], ParameterPanelItemBase.prototype, "_getInfo", void 0);