rt-sim-training-client/src/jmapNew/shape/Train/index.js

import Group from 'zrender/src/container/Group';
import TrainHead from './TrainHead';
import TrainBody from './TrainBody';
import BoundingRect from 'zrender/src/core/BoundingRect';
import Rect from 'zrender/src/graphic/shape/Rect';

/** 列车 */
export default class Train extends Group {
    constructor(model, style) {
        super();
        this._code = model.code;
        this._type = model._type;
        this.zlevel = model.zlevel;
        this.model = model;
        this.style = style;
        this.z = 40;
        this.size = 0;
        this.section = null;
        this.fontSize = style.Train.common.useSelfText ? style.Train.common.nameFontSize || style.Train.common.trainTextFontSize : model.nameFontSize || style.Train.common.nameFontSize || style.Train.common.trainTextFontSize;
        this.newScale = this.fontSize / style.Train.common.trainTextFontSize;
        this.nameFormat = style.Train.common.useSelfFormat ? style.Train.trainBody.trainNameFormat : model.nameFormat || style.Train.trainBody.trainNameFormat;
        if ( style.Train.trainBody.specialTrainType.length > 0) {
            style.Train.trainBody.specialTrainType.some((item) =>{
                if (model.type === item.type) {
                    this.nameFormat = item.nameFormat;
                    model.serviceNumber = item.serviceNumber ? item.serviceNumber : model.serviceNumber;
                    return true;
                }
            });
        }
        this.create();
        this.setState(model);
    }

    _computed() {
        const model = this.model;
        const style = this.style;
        if (model.trainWindowModel) {
            this.point = {
                x: model.trainWindowModel.point.x,
                y: model.trainWindowModel.point.y
            };
            switch (model.directionType) {
            case '01':	// 未知方向
                this.point.x = this.point.x + model.trainWindowModel.width / 2 + Math.abs((style.Train.common.trainWidth - model.trainWindowModel.width) / 2);
                break;
            case '02':	// 从左向右
                this.point.x = this.point.x + model.trainWindowModel.width / 2 - style.Train.trainHead.trainConntWidth * this.newScale - style.Train.common.trainWidth;
                break;
            case '03':	// 从右向左
                this.point.x = this.point.x - model.trainWindowModel.width / 2 + style.Train.trainHead.trainConntWidth * this.newScale;
                break;
            }
        } else {
            this.point = model.position;
            this.traingle = null;
        }
    }
    create() {
        this._computed();
        this.isChangeTrainWidth(this.model, this.style);
        const model = this.model;
        const style = this.style;
        if (this.point) {
            this.trainB = new TrainBody({
                zlevel: this.zlevel,
                z: this.z,
                style: style,
                point: this.point,
                destinationStatus: model.destinationStatus,
                serviceNumber: model.serviceNumber,
                tripNumber: model.tripNumber,
                targetCode: model.targetCode,
                groupNumber: model.groupNumber,
                directionType: model.directionType,
                directionCode: model.directionCode,
                sectionModel: model.sectionModel,
                runControlStatus: model.runControlStatus,
                runStatus: model.runStatus,
                fontSize: this.fontSize,
                nameFormat: this.nameFormat,
                type: model.type,
                speed: model.speed,
                maLen: model.maLen,
                model: model
            });
            this.trainL = new TrainHead({
                style: style,
                zlevel: this.zlevel,
                z: this.z,
                point: {
                    x: this.point.x - style.Train.common.trainHeadDistance,
                    y: this.point.y
                },
                drect: -1,
                scale: this.newScale
            });

            this.trainR = new TrainHead({
                style: style,
                zlevel: this.zlevel,
                z: this.z,
                point: {
                    x: this.point.x + style.Train.common.trainWidth + style.Train.common.trainHeadDistance,
                    y: this.point.y
                },
                drect: 1,
                scale: this.newScale
            });

            this.add(this.trainB);
            this.add(this.trainL);
            this.add(this.trainR);
        }
        if (style.Train.common.haveTrainBorder) {
            this.createTrainBorder();
        }
    }

    // 获取设备提示坐标
    getShapeTipPoint() {
    }

    // 恢复颜色状态
    recover() {
        this.trainB && this.trainB.setHShow(false);
        this.trainB && this.trainB.setSShow(false);
        this.trainB && this.trainB.setDShow(false);
        this.trainB && this.trainB.setAShow(false);

        this.trainL && this.trainL.setLineShow(false);
        this.trainR && this.trainR.setLineShow(false);
        this.trainL && this.trainL.setArrowShow(false);
        this.trainR && this.trainR.setArrowShow(false);
    }

    // 设置服务号状态类型
    setServerNoType(type) {
        if (this.style.Train.trainStatusStyle.serverNoType.length > 0) {
            const flag = this.style.Train.trainStatusStyle.serverNoType.some((item) =>{
                if (type === item.type) {
                    this.trainB && this.trainB.setTextTrainServerColor(item.showColor);
                    return true;
                }
            });
            if (this.style.Train.trainStatusStyle.defaultServerNoColor && !flag) {
                this.trainB && this.trainB.setTextTrainServerColor(this.style.Train.trainStatusStyle.defaultServerNoColor);
            }
        }
    }

    // 设置目的地状态
    setDestinationStatus(status) {
        if (this.style.Train.trainStatusStyle.destinationStatus.length > 0) {
            const flag = this.style.Train.trainStatusStyle.destinationStatus.some((item) =>{
                if (status === item.status) {
                    switch (this.style.Train.trainStatusStyle.destinationStatusSetText) {
                    case 'trainTarget':
                        this.trainB && this.trainB.setTextTrainTargetColor(item.showColor);
                        break;
                    case 'trainServer':
                        this.trainB && this.trainB.setTextTrainServerColor(item.showColor);
                        break;
                    case 'trainWindowBorder':
                        this.trainB && this.trainB.setBodyBoxShape('stroke', item.showColor);
                        break;
                    default:
                        this.trainB && this.trainB.setTextTrainTargetColor(item.showColor);
                    }
                    return true;
                }
            });
            if (this.style.Train.trainStatusStyle.defaultDestinationColor && !flag) {
                switch (this.style.Train.trainStatusStyle.destinationStatusSetText) {
                case 'trainTarget':
                    this.trainB && this.trainB.setTextTrainTargetColor(this.style.Train.trainStatusStyle.defaultDestinationColor);
                    break;
                case 'trainServer':
                    this.trainB && this.trainB.setTextTrainServerColor(this.style.Train.trainStatusStyle.defaultDestinationColor);
                    break;
                case 'trainWindowBorder':
                    this.trainB && this.trainB.setBodyBoxShape('stroke', this.style.Train.trainStatusStyle.defaultDestinationColor);
                    break;
                default:
                    this.trainB && this.trainB.setTextTrainTargetColor(this.style.Train.trainStatusStyle.defaultDestinationColor);
                }
            }
        }
    }

    // 设置运行方向状态类型
    setDirectionType(type, flag) {
        if (this.style.Train.trainStatusStyle.directionType.length > 0) {
            this.style.Train.trainStatusStyle.directionType.forEach((item) => {
                if (type === item.type) {
                    let lineLShow = item.lineLShow;
                    let arrowLShow = item.arrowLShow;
                    let lineRShow = item.lineRShow;
                    let arrowRShow = item.arrowRShow;
                    if (flag) {
                        lineLShow = !item.lineLShow;
                        arrowLShow = !item.arrowLShow;
                        lineRShow = !item.lineRShow;
                        arrowRShow = !item.arrowRShow;
                    }
                    this.trainL && this.trainL.setLineShow(lineLShow);
                    this.trainL && this.trainL.setArrowShow(arrowLShow);
                    this.trainR && this.trainR.setLineShow(lineRShow);
                    this.trainR && this.trainR.setArrowShow(arrowRShow);
                    return true;
                }
            });
        }
    }
    // 设置列车停止方向类型
    setDirectionStopType(type) {
        if (this.style.Train.trainStatusStyle.directionStopType.length > 0) {
            this.style.Train.trainStatusStyle.directionStopType.forEach((item) => {
                if (type === item.type) {
                    this.trainL && this.trainL.setLineShow(item.lineLShow);
                    this.trainR && this.trainR.setLineShow(item.lineRShow);
                    return true;
                }
            });
        }
    }
    // 设置运行状态
    setRunStatus(status, flag) {
        switch (status) {
        case '01':	// 停止
            this.setDirectionStopType(this.model.directionType); // 设置运行方向状态类型
            break;
        case '02': // 运行
            this.setDirectionType(this.model.directionType, flag);	// 设置运行方向状态类型
            break;
        }

    }
    // 设置运行模式
    setRunMode(status) {
        if (this.style.Train.trainStatusStyle.runModeStatus.length > 0) {
            this.style.Train.trainStatusStyle.runModeStatus.some((item) => {
                if (status === item.status) {
                    this.trainL && this.trainL.setColor(item.trainLColor);
                    this.trainR && this.trainR.setColor(item.trainRColor);
                    return true;
                }
            });
        }
    }
    // 设置运行控制状态类型
    setRunControlStatus(status) {
        if (this.style.Train.trainStatusStyle.runControlStatus.length > 0) {
            this.style.Train.trainStatusStyle.runControlStatus.some((item) => {
                if (status === item.status) {
                    this.trainB && this.trainB.setHShow(item.hShow);
                    this.trainB && this.trainB.setSShow(item.sShow);
                    return true;
                }
            });
        }
    }
    // 设置车门状态类型
    setDoorStatus(status) {
        if (this.style.Train.trainStatusStyle.doorStatus.length > 0) {
            this.style.Train.trainStatusStyle.doorStatus.some((item) => {
                if (status === item.status) {
                    this.trainB && this.trainB.setDShow(item.dShow);
                    return true;
                }
            });
        }
    }
    // 设置通信状态类型
    setCommunicationStatus() {
        if (this.style.Train.trainStatusStyle.communicationStatus.length > 0) {
            this.style.Train.trainStatusStyle.communicationStatus.some((item) => {
                if (status === item.status) {
                    this.trainB && this.trainB.setTrainColor(item.trainColor);
                    return true;
                }
            });
        }
    }
    // 设置报警状态
    setAlarmStatus(status) {
        if (this.style.Train.trainStatusStyle.alarmStatus.length > 0) {
            this.style.Train.trainStatusStyle.alarmStatus.some((item) => {
                if (status === item.status) {
                    this.trainB && this.trainB.setAShow(item.aShow);
                    return true;
                }
            });
        }
    }
    setTrainTypeStatus(type) {
        if (this.style.Train.trainStatusStyle.trainTypeStatus) {
            this.style.Train.trainStatusStyle.trainTypeStatus.some((item) => {
                if ( type === item.type) {
                    item.serviceNumberColor && this.trainB && this.trainB.setTextTrainServerColor(item.serviceNumberColor);
                    item.trainNumberColor && this.trainB && this.trainB.setTextTrainNumberColor(item.trainNumberColor);
                    item.trainTargetColor && this.trainB && this.trainB.setTextTrainTargetColor(item.trainTargetColor);
                    item.groupNumberColor && this.trainB && this.trainB.setTextTrainTargetNumberColor(item.groupNumberColor);
                }
            });
        }
    }
    // 设置状态
    setState(model) {
        this.model = model;
        // let points = [];
        // const flag = model.trainWindowModel.reversal;
        // if (model) {
        //     this.recover();
        //     this.setServerNoType(model.serverNoType); 				// 设置服务号状态类型
        //     this.setDestinationStatus(model.destinationStatus);		// 设置目的地状态
        //     this.setRunStatus(model.runStatus, flag); // 设置运行状态
        //     this.setRunMode(model.runMode); 						// 设置运行模式
        //     this.setRunControlStatus(model.runControlStatus); 		// 设置运行控制状态类型
        //     this.setDoorStatus(model.doorStatus); 					// 设置车门状态类型
        //     this.setCommunicationStatus(model.communicationStatus); // 设置通信状态类型
        //     this.setAlarmStatus(model.alarmStatus); 				// 设置报警状态
        //     this.setTrainTypeStatus(model.type); // 根据列车类型设置列车识别号样式
        // }
    }
    // 是否根据车身上车组号、服务号、车次号、目的地码显示情况改变列车长度
    isChangeTrainWidth(model, style) {
        if (!style.Train.trainBody.changeTrainWidth) { return; }
        if (this.nameFormat) {
            const arr = this.nameFormat.split(':');
            arr.forEach(ele => {
                switch (ele) {
                case 'targetCode': {
                    this.size += (style.Train.trainNumber.targetCodePrefix || '').length;
                    break;
                }
                case 'serviceNumber': {
                    this.size += (style.Train.trainServer.serviceNumberPrefix || '').length;
                    break;
                }
                case 'tripNumber': {
                    this.size += (style.Train.trainTarget.tripNumberPrefix || '').length;
                    break;
                }
                case 'groupNumber': {
                    this.size += (style.Train.trainTargetNumber.groupNumberPrefix || '').length;
                    break;
                }
                }
            });
        } else {
            this.size = 9;
        }
        this.style.Train.common.trainWidth = this.size * this.fontSize * this.style.Train.common.aspectRatio + this.style.Train.common.trainWidthMoreText;
    }
    removeTrainDetail() {
        this.trainB && this.trainB.removeTrainDetail();
    }

    getBoundingRect() {
        const list = [this.trainB, this.trainL, this.trainR];
        let rect = null;

        list.forEach(elem => {
            if (elem) {
                const tempRect = elem.getBoundingRect();
                if (tempRect.x && tempRect.y && tempRect.width && tempRect.height) {
                    if (rect) {
                        rect.union(tempRect);
                    } else {
                        rect = tempRect;
                    }
                }
            }
        });

        return rect || new BoundingRect(0, 0, 0, 0);
    }
    createTrainBorder() {
        const rect = Object.assign({}, this.getBoundingRect());
        rect.x -= this.style.Train.common.trainWidth / 2;
        rect.y -= 5;
        rect.width += this.style.Train.common.trainWidth;
        rect.height += 10;

        this.trainBorder = new Rect({
            zlevel: this.zlevel,
            z: this.z,
            silent: true,
            shape: rect,
            style: {
                lineDash: [3, 3],
                stroke: this.style.borderColor,
                fill: this.style.transparentColor
            }
        });

        this.add(this.trainBorder);
    }
}