rt-sim-training-client/src/jmap/painter.js

import * as zrUtil from 'zrender/src/core/util';
import * as vector from 'zrender/src/core/vector';
import Group from 'zrender/src/container/Group';
import deviceType from './constant/deviceType';
import shapefactory from './shape/factory';
import TransformHandle from './transformHandle';

class Painter {
	constructor(jmap) {
		// 父级实例
		this.$jmap = jmap;
		this.$zr = jmap.getZr();

		// 图层数据
		this.mapInstanceLevel = {};

		// 初始图层
		this.initLevels();

		// 视图控制器
		this.$transformHandle = new TransformHandle(this);
	}

	/**
     * 初始绘图实例
     * @param {*} dom
     * @param {*} config
     */
	initLevels() {
		// 图层分级策略
		this.layerBranch = {};
		this.layerBranch['01'] = (type) => { return type == deviceType.Link; };	// 逻辑图层级
		this.layerBranch['02'] = (type) => { return type != deviceType.Link; };	// 物理图层级
		this.layerBranch['03'] = (type) => { return true; };					// 混合图层级

		// 添加父级图层
		this.parentLevel = new Group({ name: '__parent__' });
		this.$zr.add(this.parentLevel);

		// 添加子级图层
		zrUtil.each(Object.values(deviceType), (type) => {
			const level = new Group({ name: `__${type}__` });
			this.mapInstanceLevel[type] = level;
			this.parentLevel.add(level);
		});

		// 设置默认显示图级
		this.setLayerVisible('02');
	}

	/**
     * 重绘视图
     * @param {*} mapDevice
     */
	repaint(mapDevice) {
		// 清空视图
		this.clear();

		// 创建视图
		Object.values(mapDevice).forEach(device => {
			this.add(device);
		});
	}

	/**
     * 添加视图
     * @param {*} device
     */
	add(device) {
		try {
			const instance = shapefactory(device, this.$jmap);
			if (instance) {
				device.instance = instance;
				this.$transformHandle.transformView(instance);
				this.mapInstanceLevel[device._type].add(instance);
			}
		} catch (err) {
			console.error(err);
		}
	}

	/**
     * 删除视图
     * @param {*} device
     */
	delete(device) {
		const instance = device.instance;
		if (instance) {
			this.mapInstanceLevel[device._type].remove(instance);
		}
	}

	checkIntersect(device) {
		var intersect = false;
		var befor = device.instance;
		var train = shapefactory(device, this.$jmap);

		this.mapInstanceLevel[deviceType.Train].eachChild(elem => {
			if (elem !== befor && elem.getBoundingRect().intersect(train.getBoundingRect())) {
				intersect = true;
				return;
			}
		});

		return intersect;
	}

	/**
	 * 更新列车
	 * @param {*} device
	 */
	updateTrain(device) {
		var oldTrainWindowModel = null;
		var instance = device.instance;
		var curModel = device;

		if (instance) {
			oldTrainWindowModel = device.trainWindowModel;
		}

		if (curModel.sectionCode) {
			curModel.sectionModel = this.$jmap.getDeviceByCode(curModel.sectionCode);
		}

		if (curModel.trainWindowCode) {
			curModel.trainWindowModel = this.$jmap.getDeviceByCode(curModel.trainWindowCode);
		}

		if (instance && oldTrainWindowModel && this.checkIntersect(device)) {
			device.trainWindowModel = oldTrainWindowModel;
		}

		instance && this.mapInstanceLevel[deviceType.Train].remove(instance);
		this.add(device);
	}

	/**
     * 更新视图
     * @param {*} device
     */
	update(device) {
		if (device) {
			try {
				if (device._dispose) {
					this.delete(device);
				} else if (deviceType.Train == device._type) {
					this.updateTrain(device);
				} else {
					const instance = device.instance;
					if (instance) {
						instance.setState(device);
					}
				}
			} catch (err) {
				console.error(err);
			}
		}
	}

	/**
     * 更新transform变化
     * @param {*} opt
     */
	updateTransform(opt) {
		this.$transformHandle.updateTransform(opt);
	}

	/**
	 * 更新zrender尺寸
	 * @param {*} opt
	 */
	updateZrSize(opt) {
		this.$transformHandle.updateZrSize(opt);
	}

	/**
	 * 过去坐标提示位置
	 * @param {*} opts
	 */
	getShapeTipPoint(instance, opts) {
		if (instance) {
			var point = instance.getShapeTipPoint(opts);
			if (point) {
				// 矩阵变换
				var transform = this.$transformHandle.transform;
				var transPoint = vector.applyTransform([], [point.x, point.y], transform);
				return {
					x: transPoint[0],
					y: transPoint[1]
				};
			}

		}
	}

	/**
	 * 设置逻辑和物理图层
	 * @param {*} layer
	 */
	setLayerVisible(layer) {
		zrUtil.each(Object.values(deviceType), type => {
			const level = this.mapInstanceLevel[type];
			if (this.layerBranch[layer](type)) {
				level.show();
			} else {
				level.hide();
			}
		}, this);
	}

	/**
	 * 设置图层可见
	 * @param {*} code
	 */
	setLevelVisible(list) {
		zrUtil.each(Object.values(deviceType), type => {
			const level = this.mapInstanceLevel[type];
			if (list.includes(type)) {
				level.show();
			} else {
				level.hide();
			}
		}, this);
	}

	/**
     * 刷新图层
     */
	refresh() {
		this.$zr.refresh();
	}

	/**
	 * 清除图层
	 */
	clearLevel(type) {
		const level = this.mapInstanceLevel[type];
		if (level) {
			level.removeAll();
		}
	}

	/**
     * 清除canvas
     */
	clear() {
		zrUtil.each(Object.values(this.mapInstanceLevel), (level) => {
			level && level.removeAll();
		}, this);

		this.refresh();
	}

	/**
     * 销毁图层
     */
	dispose() {
		this.mapInstanceLevel = {};
		this.parentLevel = null;
	}

	/**
     * 父级图层
     */
	getParentLevel() {
		return this.parentLevel;
	}

}

export default Painter;