自动折返按钮箱

public/drawIcon.svg

@@ -68,4 +68,11 @@
     <path d="M11.5 9V16.5" stroke="white"/>
     <path d="M11.5 25V32.5" stroke="white"/>
   </symbol>
+  <symbol id="icon-autoreturn-box" viewBox="0 0 57 57" fill="none">
+    <rect x="5.0" y="5.0" width="47" height="47" stroke="#FFFFFF" fill="none" />
+    <circle cx="28.5" cy="28.5" r="22" stroke="white"/>
+    <path d="M20 26.9998C20 12 39 12 39 26.9998" stroke="#FFFFFF"/>
+    <path d="M20 27H39" stroke="#FFFFFF"/>
+    <path d="M29 27V43" stroke="#FFFFFF"/>
+  </symbol>
 </svg>

src/components/draw-app/DrawProperties.vue

@@ -95,6 +95,9 @@
           <esb-button-property
             v-else-if="drawStore.selectedGraphicType === EsbButton.Type"
           ></esb-button-property>
+          <AutoReturnBoxProperty
+            v-else-if="drawStore.selectedGraphicType === AutoReturnBox.Type"
+          ></AutoReturnBoxProperty>
           <SlopeKiloMarkerProperty
             v-else-if="drawStore.selectedGraphicType === SlopeKiloMarker.Type"
           />
@@ -174,6 +177,8 @@ import GatedBoxProperty from './properties/GatedBoxProperty.vue';
 import { GatedBox } from 'src/graphics/gatedBox/GatedBox';
 import EsbButtonProperty from './properties/EsbButtonProperty.vue';
 import { EsbButton } from 'src/graphics/esbButton/EsbButton';
+import AutoReturnBoxProperty from './properties/AutoReturnBoxProperty.vue';
+import { AutoReturnBox } from 'src/graphics/autoReturnBox/AutoReturnBox';
 import SlopeKiloMarkerProperty from './properties/SlopeKiloMarkerProperty.vue';
 import CurvatureKiloMarkerProperty from './properties/CurvatureKiloMarkerProperty.vue';
 import { SlopeKiloMarker } from 'src/graphics/slopeKiloMarker/SlopeKiloMarker';

src/components/draw-app/properties/AutoReturnBoxProperty.vue

@@ -0,0 +1,63 @@
+<template>
+  <q-form>
+    <q-input
+      outlined
+      readonly
+      v-model="autoReturnBoxModel.id"
+      label="id"
+      hint=""
+    />
+    <q-input
+      outlined
+      v-model.number="autoReturnBoxModel.index"
+      type="number"
+      @blur="onUpdate"
+      label="索引"
+    />
+    <q-input
+      outlined
+      class="q-mt-sm"
+      v-model="autoReturnBoxModel.code"
+      @blur="onUpdate"
+      label="名称"
+    />
+    <q-select
+      outlined
+      style="margin-top: 10px"
+      v-model="autoReturnBoxModel.refStand"
+      :options="platformList"
+      :map-options="true"
+      :emit-value="true"
+      @update:model-value="onUpdate"
+      label="关联站台"
+    ></q-select>
+  </q-form>
+</template>
+
+<script setup lang="ts">
+import { AutoReturnBoxData } from 'src/drawApp/graphics/AutoReturnBoxInteraction';
+import { useFormData } from 'src/components/DrawAppFormUtils';
+import { useDrawStore } from 'src/stores/draw-store';
+import { onMounted, reactive } from 'vue';
+import { Platform } from 'src/graphics/platform/Platform';
+
+const drawStore = useDrawStore();
+const platformList: { label: string; value: string }[] = reactive([]);
+
+const { data: autoReturnBoxModel, onUpdate } = useFormData(
+  new AutoReturnBoxData(),
+  drawStore.getDrawApp()
+);
+
+onMounted(() => {
+  const platforms = drawStore
+    .getDrawApp()
+    .queryStore.queryByType<Platform>(Platform.Type);
+  platforms.forEach((p) => {
+    platformList.push({
+      value: p.id,
+      label: `${p.datas.code}[${p.datas.index}]`,
+    });
+  });
+});
+</script>

src/drawApp/graphics/AutoReturnBoxInteraction.ts

@@ -0,0 +1,199 @@
+import * as pb_1 from 'google-protobuf';
+import { DisplayObject, FederatedMouseEvent } from 'pixi.js';
+import {
+  IGraphicApp,
+  GraphicInteractionPlugin,
+  JlGraphic,
+  IGraphicScene,
+} from 'src/jl-graphic';
+import { ContextMenu } from 'src/jl-graphic/ui/ContextMenu';
+import { MenuItemOptions } from 'src/jl-graphic/ui/Menu';
+
+import { graphicData } from 'src/protos/stationLayoutGraphics';
+import { GraphicDataBase, GraphicStateBase } from './GraphicDataBase';
+import { useLineStore } from 'src/stores/line-store';
+import { state } from 'src/protos/device_state';
+import {
+  AutoReturnBox,
+  IAutoReturnBoxData,
+  IAutoReturnBoxState,
+} from 'src/graphics/autoReturnBox/AutoReturnBox';
+
+export class AutoReturnBoxData
+  extends GraphicDataBase
+  implements IAutoReturnBoxData
+{
+  constructor(data?: graphicData.AutoReturnBox) {
+    let autoReturnBox;
+    if (!data) {
+      autoReturnBox = new graphicData.AutoReturnBox({
+        common: GraphicDataBase.defaultCommonInfo(AutoReturnBox.Type),
+      });
+    } else {
+      autoReturnBox = data;
+    }
+    super(autoReturnBox);
+  }
+
+  public get data(): graphicData.AutoReturnBox {
+    return this.getData<graphicData.AutoReturnBox>();
+  }
+  get code(): string {
+    return this.data.code;
+  }
+  set code(v: string) {
+    this.data.code = v;
+  }
+  get flip(): boolean {
+    return this.data.flip;
+  }
+  set flip(v: boolean) {
+    this.data.flip = v;
+  }
+  get index(): number {
+    return this.data.index;
+  }
+  set index(v: number) {
+    this.data.index = v;
+  }
+  get refStand(): string {
+    return this.data.refStand;
+  }
+  set refStand(v: string) {
+    this.data.refStand = v;
+  }
+  clone(): AutoReturnBoxData {
+    return new AutoReturnBoxData(this.data.cloneMessage());
+  }
+  copyFrom(data: AutoReturnBoxData): void {
+    pb_1.Message.copyInto(data.data, this.data);
+  }
+  eq(other: AutoReturnBoxData): boolean {
+    return pb_1.Message.equals(this.data, other.data);
+  }
+}
+
+export class AutoReturnBoxState
+  extends GraphicStateBase
+  implements IAutoReturnBoxState
+{
+  constructor(data?: state.ButtonState) {
+    let ibpButtonState;
+    if (data) {
+      ibpButtonState = data;
+    } else {
+      ibpButtonState = new state.ButtonState();
+    }
+    super(ibpButtonState, AutoReturnBox.Type);
+  }
+  get states(): state.ButtonState {
+    return this.getState<state.ButtonState>();
+  }
+  get code(): string {
+    return this.states.id;
+  }
+  get id(): string {
+    return this.states.id;
+  }
+  set id(v: string) {
+    this.states.id = v;
+  }
+  get down(): boolean {
+    return this.states.down;
+  }
+  set down(v: boolean) {
+    this.states.down = v;
+  }
+  clone(): AutoReturnBoxState {
+    return new AutoReturnBoxState(this.states.cloneMessage());
+  }
+  copyFrom(data: GraphicStateBase): void {
+    pb_1.Message.copyInto(data._state, this._state);
+  }
+  eq(data: GraphicStateBase): boolean {
+    return pb_1.Message.equals(this._state, data._state);
+  }
+}
+
+const flipConfig: MenuItemOptions = {
+  name: '上下翻转',
+};
+const AutoReturnBoxEditMenu: ContextMenu = ContextMenu.init({
+  name: '自动折返按钮箱编辑菜单',
+  groups: [
+    {
+      items: [flipConfig],
+    },
+  ],
+});
+export class DrawAutoReturnBoxInteraction extends GraphicInteractionPlugin<AutoReturnBox> {
+  static Name = 'autoreturn_box_draw_right_menu';
+  constructor(app: IGraphicApp) {
+    super(DrawAutoReturnBoxInteraction.Name, app);
+    app.registerMenu(AutoReturnBoxEditMenu);
+  }
+  static init(app: IGraphicApp) {
+    return new DrawAutoReturnBoxInteraction(app);
+  }
+  filter(...grahpics: JlGraphic[]): AutoReturnBox[] | undefined {
+    return grahpics
+      .filter((g) => g.type === AutoReturnBox.Type)
+      .map((g) => g as AutoReturnBox);
+  }
+  bind(g: AutoReturnBox): void {
+    g.on('_rightclick', this.onContextMenu, this);
+  }
+
+  unbind(g: AutoReturnBox): void {
+    g.off('_rightclick', this.onContextMenu, this);
+  }
+
+  onContextMenu(e: FederatedMouseEvent) {
+    const target = e.target as DisplayObject;
+    const autoReturnBox = target.getGraphic() as AutoReturnBox;
+    this.app.updateSelected(autoReturnBox);
+    flipConfig.handler = () => {
+      autoReturnBox.datas.flip = !autoReturnBox.datas.flip;
+      console.log(autoReturnBox.datas, 'data');
+      autoReturnBox.repaint();
+    };
+    AutoReturnBoxEditMenu.open(e.global);
+  }
+}
+
+export class AutoReturnBoxOperationInteraction extends GraphicInteractionPlugin<AutoReturnBox> {
+  static Name = 'autoreturn_box_operation';
+  constructor(scene: IGraphicScene) {
+    super(AutoReturnBoxOperationInteraction.Name, scene);
+  }
+  static init(scene: IGraphicScene) {
+    return new AutoReturnBoxOperationInteraction(scene);
+  }
+  filter(...grahpics: JlGraphic[]): AutoReturnBox[] | undefined {
+    return grahpics.filter(
+      (g): g is AutoReturnBox => g.type === AutoReturnBox.Type
+    );
+  }
+  bind(g: AutoReturnBox): void {
+    g.eventMode = 'static';
+    g.cursor = 'pointer';
+    g.on('mousedown', this.onPress, this);
+  }
+  unbind(g: AutoReturnBox): void {
+    g.eventMode = 'none';
+    g.cursor = 'default';
+    g.off('mousedown', this.onPress, this);
+  }
+  onPress(e: FederatedMouseEvent) {
+    const g = e.target as AutoReturnBox;
+    g.on('mouseleave', this.onRelease, this);
+    g.on('mouseup', this.onRelease, this);
+    useLineStore().esbButtonOperation(true, g.datas.id);
+  }
+  onRelease(e: FederatedMouseEvent) {
+    const g = e.target as AutoReturnBox;
+    g.off('mouseleave', this.onRelease, this);
+    g.off('mouseup', this.onRelease, this);
+    useLineStore().esbButtonOperation(false, g.datas.id);
+  }
+}

src/drawApp/zdwxApp.ts

@@ -53,7 +53,16 @@ import {
 } from 'src/graphics/departureTimer/DepartureTimer';
 import { DepartureTimerData } from './graphics/DepartureTimerInteraction';
 import { DepartureTimerDraw } from 'src/graphics/departureTimer/DepartureTimerDrawAssistant';
-
+import { AutoReturnBoxDraw } from 'src/graphics/autoReturnBox/AutoReturnBoxDrawAssistant';
+import {
+  AutoReturnBox,
+  AutoReturnBoxTemplate,
+} from 'src/graphics/autoReturnBox/AutoReturnBox';
+import {
+  AutoReturnBoxData,
+  DrawAutoReturnBoxInteraction,
+  AutoReturnBoxState,
+} from './graphics/AutoReturnBoxInteraction';
 let zdwxDrawApp: IDrawApp | null = null;
 
 export function getZdwxDrawApp(): IDrawApp | null {
@@ -74,6 +83,7 @@ export const drawZdwxLayerList = [
   { label: '轨道逻辑区段', value: TrackLogicSection.Type, defaultShow: false },
   { label: '信标', value: Beacon.Type, defaultShow: true },
   { label: '发车计时器', value: DepartureTimer.Type, defaultShow: true },
+  { label: '自动折返按钮箱', value: AutoReturnBox.Type, defaultShow: true },
 ];
 
 function initZdwxShowLayer(app: IDrawApp) {
@@ -124,8 +134,13 @@ export function initZdwxDrawApp(): IDrawApp {
     app,
     new ZdwxEsbTemplate(new ZdwxEsbData(), new ZdwxEsbState())
   );
+  new AutoReturnBoxDraw(
+    app,
+    new AutoReturnBoxTemplate(new AutoReturnBoxData(), new AutoReturnBoxState())
+  );
   DrawBeaconInteraction.init(app);
   DrawZdwxEsbInteraction.init(app);
+  DrawAutoReturnBoxInteraction.init(app);
   app.addKeyboardListener(
     new KeyListener({
       value: 'KeyS',
@@ -169,6 +184,9 @@ export async function loadZdwxDrawDatas(): Promise<IGraphicStorage> {
     storage.departureTimers.forEach((departureTimer) => {
       datas.push(new DepartureTimerData(departureTimer));
     });
+    storage.autoReturnBoxs.forEach((autoReturnBox) => {
+      datas.push(new AutoReturnBoxData(autoReturnBox));
+    });
     refDevicesList = storage.stationRelateDeviceList;
     return Promise.resolve({
       canvasProperty: storage.canvas,
@@ -205,6 +223,11 @@ export function saveZdwxDrawDatas(app: IDrawApp) {
       storage.departureTimers.push(
         (departureTimerData as DepartureTimerData).data
       );
+    } else if (AutoReturnBox.Type === g.type) {
+      const autoReturnBoxData = (g as AutoReturnBox).saveData();
+      storage.autoReturnBoxs.push(
+        (autoReturnBoxData as AutoReturnBoxData).data
+      );
     }
   });
   const base64 = fromUint8Array(storage.serialize());

src/graphics/autoReturnBox/AutoReturnBox.ts

@@ -0,0 +1,137 @@
+import { Graphics } from 'pixi.js';
+import {
+  GraphicData,
+  GraphicState,
+  JlGraphic,
+  JlGraphicTemplate,
+  VectorText,
+} from 'src/jl-graphic';
+
+export interface IAutoReturnBoxData extends GraphicData {
+  get code(): string;
+  set code(v: string);
+  get flip(): boolean;
+  set flip(v: boolean);
+  get index(): number;
+  set index(v: number);
+  get refStand(): string;
+  set refStand(v: string);
+  clone(): IAutoReturnBoxData;
+  copyFrom(data: IAutoReturnBoxData): void;
+  eq(other: IAutoReturnBoxData): boolean;
+}
+
+export interface IAutoReturnBoxState extends GraphicState {
+  id: string;
+  get down(): boolean;
+  set down(v: boolean);
+}
+
+const autoReturnBoxConsts = {
+  codeFontSize: 12,
+  codeColor: 0xffffff,
+  bodyLineColor: 0x16db34,
+  lineWidth: 1,
+  TlineWidth: 4,
+  bodyRectWidth: 25,
+  bodyCircleRadius: 6,
+};
+export class AutoReturnBox extends JlGraphic {
+  static Type = 'autoReturnBox';
+  codeGraph: VectorText = new VectorText('');
+  circleBody: Graphics = new Graphics();
+
+  constructor() {
+    super(AutoReturnBox.Type);
+    this.addChild(this.codeGraph);
+    this.addChild(this.circleBody);
+    this.codeGraph.name = 'atb_code';
+  }
+  get datas(): IAutoReturnBoxData {
+    return this.getDatas<IAutoReturnBoxData>();
+  }
+  get state(): IAutoReturnBoxState {
+    return this.getStates<IAutoReturnBoxState>();
+  }
+  get code(): string {
+    return this.datas.index + '';
+  }
+  doRepaint(): void {
+    const codeGraph = this.codeGraph;
+    codeGraph.text = this.datas.code;
+    codeGraph.style.fill = autoReturnBoxConsts.codeColor;
+    codeGraph.setVectorFontSize(autoReturnBoxConsts.codeFontSize);
+    codeGraph.anchor.set(0.5);
+    const codeTransform = this.datas?.childTransforms?.find(
+      (item) => item.name === 'atb_code'
+    );
+    if (codeTransform) {
+      const position = codeTransform?.transform.position;
+      const rotation = codeTransform?.transform?.rotation;
+      codeGraph.position.set(position?.x, position?.y);
+      codeGraph.rotation = rotation || 0;
+    } else {
+      codeGraph.position.set(-30, 0);
+    }
+    this.circleBody.clear();
+    this.circleBody.lineStyle(
+      autoReturnBoxConsts.lineWidth,
+      autoReturnBoxConsts.bodyLineColor
+    );
+    this.circleBody.drawRect(
+      -autoReturnBoxConsts.bodyRectWidth / 2,
+      -autoReturnBoxConsts.bodyRectWidth / 2,
+      autoReturnBoxConsts.bodyRectWidth,
+      autoReturnBoxConsts.bodyRectWidth
+    );
+    this.circleBody.drawCircle(0, 0, autoReturnBoxConsts.bodyRectWidth / 2);
+    if (this.datas.flip) {
+      this.circleBody.arc(
+        0,
+        0,
+        autoReturnBoxConsts.bodyCircleRadius,
+        0,
+        Math.PI
+      );
+      this.circleBody.lineStyle(
+        autoReturnBoxConsts.TlineWidth,
+        autoReturnBoxConsts.bodyLineColor
+      );
+      this.circleBody.moveTo(0, 0);
+      this.circleBody.lineTo(0, -8);
+      this.circleBody.moveTo(-6, 0);
+      this.circleBody.lineTo(6, 0);
+    } else {
+      this.circleBody.arc(
+        0,
+        0,
+        autoReturnBoxConsts.bodyCircleRadius,
+        Math.PI,
+        0
+      );
+      this.circleBody.lineStyle(
+        autoReturnBoxConsts.TlineWidth,
+        autoReturnBoxConsts.bodyLineColor
+      );
+      this.circleBody.moveTo(0, 0);
+      this.circleBody.lineTo(0, 8);
+      this.circleBody.moveTo(-6, 0);
+      this.circleBody.lineTo(6, 0);
+    }
+  }
+}
+
+export class AutoReturnBoxTemplate extends JlGraphicTemplate<AutoReturnBox> {
+  constructor(
+    dataTemplate: IAutoReturnBoxData,
+    stateTemplate?: IAutoReturnBoxState
+  ) {
+    super(AutoReturnBox.Type, { dataTemplate, stateTemplate });
+  }
+  new(): AutoReturnBox {
+    const autoReturnBox = new AutoReturnBox();
+    autoReturnBox.loadData(this.datas);
+    autoReturnBox.loadState(this.states);
+    return autoReturnBox;
+  }
+}

src/graphics/autoReturnBox/AutoReturnBoxDrawAssistant.ts

@@ -0,0 +1,148 @@
+import { DisplayObject, FederatedMouseEvent, IHitArea, Point } from 'pixi.js';
+import {
+  AbsorbableLine,
+  AbsorbablePosition,
+  GraphicDrawAssistant,
+  GraphicInteractionPlugin,
+  GraphicTransformEvent,
+  IDrawApp,
+  JlGraphic,
+  pointBox,
+} from 'src/jl-graphic';
+import {
+  AutoReturnBox,
+  AutoReturnBoxTemplate,
+  IAutoReturnBoxData,
+} from './AutoReturnBox';
+
+export interface IEsbButtonDataDrawOptions {
+  newData: () => IAutoReturnBoxData;
+}
+export class AutoReturnBoxDraw extends GraphicDrawAssistant<
+  AutoReturnBoxTemplate,
+  IAutoReturnBoxData
+> {
+  _autoReturnBox: AutoReturnBox | null = null;
+  constructor(app: IDrawApp, template: AutoReturnBoxTemplate) {
+    super(
+      app,
+      template,
+      'svguse:../../drawIcon.svg#icon-autoreturn-box',
+      '自动折返按钮箱AutoReturnBox'
+    );
+    AutoReturnBoxInteraction.init(app);
+  }
+  public get autoReturnBox(): AutoReturnBox {
+    if (!this._autoReturnBox) {
+      this._autoReturnBox = this.graphicTemplate.new();
+      this._autoReturnBox.loadData(this.graphicTemplate.datas);
+      this.container.addChild(this._autoReturnBox);
+    }
+    return this._autoReturnBox;
+  }
+
+  onLeftUp(e: FederatedMouseEvent): void {
+    this.container.position.copyFrom(this.toCanvasCoordinates(e.global));
+    this.createAndStore(true);
+  }
+
+  redraw(p: Point): void {
+    this.autoReturnBox.repaint();
+    this.container.position.set(p.x, p.y);
+  }
+
+  prepareData(data: IAutoReturnBoxData): boolean {
+    data.transform = this.container.saveTransform();
+    data.code = 'ATB';
+    return true;
+  }
+}
+/**
+ * 构建吸附线
+ * @param autoReturnBox
+ */
+function buildAbsorbablePositions(
+  autoReturnBox: AutoReturnBox
+): AbsorbablePosition[] {
+  const aps: AbsorbablePosition[] = [];
+  const esbButtons = autoReturnBox.queryStore.queryByType<AutoReturnBox>(
+    AutoReturnBox.Type
+  );
+  const canvas = autoReturnBox.getCanvas();
+  esbButtons.forEach((item) => {
+    if (item.id === autoReturnBox.id) {
+      return;
+    }
+    const ala = new AbsorbableLine(
+      new Point(item.x, 0),
+      new Point(item.x, canvas.height)
+    );
+    const alb = new AbsorbableLine(
+      new Point(0, item.y),
+      new Point(canvas.width, item.y)
+    );
+    aps.push(ala);
+    aps.push(alb);
+  });
+  return aps;
+}
+
+export class AtbBodyHitArea implements IHitArea {
+  autoReturnBox: AutoReturnBox;
+  constructor(autoReturnBox: AutoReturnBox) {
+    this.autoReturnBox = autoReturnBox;
+  }
+  contains(x: number, y: number): boolean {
+    let contains = false;
+    const p = new Point(x, y);
+    const r = this.autoReturnBox.getLocalBounds();
+    contains = pointBox(p, r);
+    return contains;
+  }
+}
+
+export class AutoReturnBoxInteraction extends GraphicInteractionPlugin<AutoReturnBox> {
+  static Name = 'autoReturn_box_transform';
+  constructor(app: IDrawApp) {
+    super(AutoReturnBoxInteraction.Name, app);
+  }
+  static init(app: IDrawApp) {
+    return new AutoReturnBoxInteraction(app);
+  }
+  filter(...grahpics: JlGraphic[]): AutoReturnBox[] | undefined {
+    return grahpics
+      .filter((g) => g.type === AutoReturnBox.Type)
+      .map((g) => g as AutoReturnBox);
+  }
+  bind(g: AutoReturnBox): void {
+    g.eventMode = 'static';
+    g.cursor = 'pointer';
+    g.scalable = true;
+    g.rotatable = true;
+    g.codeGraph.draggable = true;
+    g.codeGraph.selectable = true;
+    g.codeGraph.rotatable = true;
+    g.codeGraph.transformSave = true;
+    g.codeGraph.eventMode = 'static';
+    g.circleBody.hitArea = new AtbBodyHitArea(g);
+    g.on('transformstart', this.transformstart, this);
+  }
+  unbind(g: AutoReturnBox): void {
+    g.eventMode = 'none';
+    g.scalable = false;
+    g.rotatable = false;
+    g.codeGraph.draggable = false;
+    g.codeGraph.selectable = false;
+    g.codeGraph.rotatable = false;
+    g.codeGraph.transformSave = false;
+    g.codeGraph.eventMode = 'none';
+    g.off('transformstart', this.transformstart, this);
+  }
+  transformstart(e: GraphicTransformEvent) {
+    const target = e.target as DisplayObject;
+    const autoReturnBox = target.getGraphic() as AutoReturnBox;
+    autoReturnBox.getGraphicApp().setOptions({
+      absorbablePositions: buildAbsorbablePositions(autoReturnBox),
+    });
+  }
+}

src/layouts/DrawLayout.vue

@@ -307,6 +307,7 @@ import AxleCountingConfig from 'src/components/draw-app/properties/AxleCountingC
 import { PictureType } from 'src/protos/picture';
 import { Beacon } from 'src/graphics/beacon/Beacon';
 import { DepartureTimer } from 'src/graphics/departureTimer/DepartureTimer';
+import { AutoReturnBox } from 'src/graphics/autoReturnBox/AutoReturnBox';
 
 const $q = useQuasar();
 const route = useRoute();
@@ -463,6 +464,7 @@ onMounted(() => {
     case CategoryType.ZDWX:
       drawAssistantsTypes.push(Beacon.Type);
       drawAssistantsTypes.push(DepartureTimer.Type);
+      drawAssistantsTypes.push(AutoReturnBox.Type);
       break;
   }
   drawAssistantsTypes.forEach((type) => {

src/protos/stationLayoutGraphics.ts

@@ -45,9 +45,10 @@ export namespace graphicData {
             beacons?: Beacon[];
             generateAxleCountingConfig?: GenerateAxleCountingConfig;
             departureTimers?: DepartureTimer[];
+            autoReturnBoxs?: AutoReturnBox[];
         }) {
             super();
-            pb_1.Message.initialize(this, Array.isArray(data) ? data : [], 0, -1, [4, 5, 8, 9, 10, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 32, 33, 34, 35, 37, 39], this.#one_of_decls);
+            pb_1.Message.initialize(this, Array.isArray(data) ? data : [], 0, -1, [4, 5, 8, 9, 10, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 32, 33, 34, 35, 37, 39, 40], this.#one_of_decls);
             if (!Array.isArray(data) && typeof data == "object") {
                 if ("canvas" in data && data.canvas != undefined) {
                     this.canvas = data.canvas;
@@ -148,6 +149,9 @@ export namespace graphicData {
                 if ("departureTimers" in data && data.departureTimers != undefined) {
                     this.departureTimers = data.departureTimers;
                 }
+                if ("autoReturnBoxs" in data && data.autoReturnBoxs != undefined) {
+                    this.autoReturnBoxs = data.autoReturnBoxs;
+                }
             }
         }
         get canvas() {
@@ -360,6 +364,12 @@ export namespace graphicData {
         set departureTimers(value: DepartureTimer[]) {
             pb_1.Message.setRepeatedWrapperField(this, 39, value);
         }
+        get autoReturnBoxs() {
+            return pb_1.Message.getRepeatedWrapperField(this, AutoReturnBox, 40) as AutoReturnBox[];
+        }
+        set autoReturnBoxs(value: AutoReturnBox[]) {
+            pb_1.Message.setRepeatedWrapperField(this, 40, value);
+        }
         static fromObject(data: {
             canvas?: ReturnType<typeof Canvas.prototype.toObject>;
             Platforms?: ReturnType<typeof Platform.prototype.toObject>[];
@@ -394,6 +404,7 @@ export namespace graphicData {
             beacons?: ReturnType<typeof Beacon.prototype.toObject>[];
             generateAxleCountingConfig?: ReturnType<typeof GenerateAxleCountingConfig.prototype.toObject>;
             departureTimers?: ReturnType<typeof DepartureTimer.prototype.toObject>[];
+            autoReturnBoxs?: ReturnType<typeof AutoReturnBox.prototype.toObject>[];
         }): RtssGraphicStorage {
             const message = new RtssGraphicStorage({});
             if (data.canvas != null) {
@@ -495,6 +506,9 @@ export namespace graphicData {
             if (data.departureTimers != null) {
                 message.departureTimers = data.departureTimers.map(item => DepartureTimer.fromObject(item));
             }
+            if (data.autoReturnBoxs != null) {
+                message.autoReturnBoxs = data.autoReturnBoxs.map(item => AutoReturnBox.fromObject(item));
+            }
             return message;
         }
         toObject() {
@@ -532,6 +546,7 @@ export namespace graphicData {
                 beacons?: ReturnType<typeof Beacon.prototype.toObject>[];
                 generateAxleCountingConfig?: ReturnType<typeof GenerateAxleCountingConfig.prototype.toObject>;
                 departureTimers?: ReturnType<typeof DepartureTimer.prototype.toObject>[];
+                autoReturnBoxs?: ReturnType<typeof AutoReturnBox.prototype.toObject>[];
             } = {};
             if (this.canvas != null) {
                 data.canvas = this.canvas.toObject();
@@ -632,6 +647,9 @@ export namespace graphicData {
             if (this.departureTimers != null) {
                 data.departureTimers = this.departureTimers.map((item: DepartureTimer) => item.toObject());
             }
+            if (this.autoReturnBoxs != null) {
+                data.autoReturnBoxs = this.autoReturnBoxs.map((item: AutoReturnBox) => item.toObject());
+            }
             return data;
         }
         serialize(): Uint8Array;
@@ -704,6 +722,8 @@ export namespace graphicData {
                 writer.writeMessage(38, this.generateAxleCountingConfig, () => this.generateAxleCountingConfig.serialize(writer));
             if (this.departureTimers.length)
                 writer.writeRepeatedMessage(39, this.departureTimers, (item: DepartureTimer) => item.serialize(writer));
+            if (this.autoReturnBoxs.length)
+                writer.writeRepeatedMessage(40, this.autoReturnBoxs, (item: AutoReturnBox) => item.serialize(writer));
             if (!w)
                 return writer.getResultBuffer();
         }
@@ -812,6 +832,9 @@ export namespace graphicData {
                     case 39:
                         reader.readMessage(message.departureTimers, () => pb_1.Message.addToRepeatedWrapperField(message, 39, DepartureTimer.deserialize(reader), DepartureTimer));
                         break;
+                    case 40:
+                        reader.readMessage(message.autoReturnBoxs, () => pb_1.Message.addToRepeatedWrapperField(message, 40, AutoReturnBox.deserialize(reader), AutoReturnBox));
+                        break;
                     default: reader.skipField();
                 }
             }
@@ -1921,6 +1944,8 @@ export namespace graphicData {
             index?: number;
             refIbpMapCode?: string;
             stationName?: string;
+            stationNameAcronym?: string;
+            depots?: boolean;
         }) {
             super();
             pb_1.Message.initialize(this, Array.isArray(data) ? data : [], 0, -1, [], this.#one_of_decls);
@@ -1946,6 +1971,12 @@ export namespace graphicData {
                 if ("stationName" in data && data.stationName != undefined) {
                     this.stationName = data.stationName;
                 }
+                if ("stationNameAcronym" in data && data.stationNameAcronym != undefined) {
+                    this.stationNameAcronym = data.stationNameAcronym;
+                }
+                if ("depots" in data && data.depots != undefined) {
+                    this.depots = data.depots;
+                }
             }
         }
         get common() {
@@ -1996,6 +2027,18 @@ export namespace graphicData {
         set stationName(value: string) {
             pb_1.Message.setField(this, 9, value);
         }
+        get stationNameAcronym() {
+            return pb_1.Message.getFieldWithDefault(this, 10, "") as string;
+        }
+        set stationNameAcronym(value: string) {
+            pb_1.Message.setField(this, 10, value);
+        }
+        get depots() {
+            return pb_1.Message.getFieldWithDefault(this, 11, false) as boolean;
+        }
+        set depots(value: boolean) {
+            pb_1.Message.setField(this, 11, value);
+        }
         static fromObject(data: {
             common?: ReturnType<typeof CommonInfo.prototype.toObject>;
             code?: string;
@@ -2004,6 +2047,8 @@ export namespace graphicData {
             index?: number;
             refIbpMapCode?: string;
             stationName?: string;
+            stationNameAcronym?: string;
+            depots?: boolean;
         }): Station {
             const message = new Station({});
             if (data.common != null) {
@@ -2027,6 +2072,12 @@ export namespace graphicData {
             if (data.stationName != null) {
                 message.stationName = data.stationName;
             }
+            if (data.stationNameAcronym != null) {
+                message.stationNameAcronym = data.stationNameAcronym;
+            }
+            if (data.depots != null) {
+                message.depots = data.depots;
+            }
             return message;
         }
         toObject() {
@@ -2038,6 +2089,8 @@ export namespace graphicData {
                 index?: number;
                 refIbpMapCode?: string;
                 stationName?: string;
+                stationNameAcronym?: string;
+                depots?: boolean;
             } = {};
             if (this.common != null) {
                 data.common = this.common.toObject();
@@ -2060,6 +2113,12 @@ export namespace graphicData {
             if (this.stationName != null) {
                 data.stationName = this.stationName;
             }
+            if (this.stationNameAcronym != null) {
+                data.stationNameAcronym = this.stationNameAcronym;
+            }
+            if (this.depots != null) {
+                data.depots = this.depots;
+            }
             return data;
         }
         serialize(): Uint8Array;
@@ -2080,6 +2139,10 @@ export namespace graphicData {
                 writer.writeString(8, this.refIbpMapCode);
             if (this.stationName.length)
                 writer.writeString(9, this.stationName);
+            if (this.stationNameAcronym.length)
+                writer.writeString(10, this.stationNameAcronym);
+            if (this.depots != false)
+                writer.writeBool(11, this.depots);
             if (!w)
                 return writer.getResultBuffer();
         }
@@ -2110,6 +2173,12 @@ export namespace graphicData {
                     case 9:
                         message.stationName = reader.readString();
                         break;
+                    case 10:
+                        message.stationNameAcronym = reader.readString();
+                        break;
+                    case 11:
+                        message.depots = reader.readBool();
+                        break;
                     default: reader.skipField();
                 }
             }
@@ -7216,6 +7285,168 @@ export namespace graphicData {
             return DepartureTimer.deserialize(bytes);
         }
     }
+    export class AutoReturnBox extends pb_1.Message {
+        #one_of_decls: number[][] = [];
+        constructor(data?: any[] | {
+            common?: CommonInfo;
+            code?: string;
+            flip?: boolean;
+            index?: number;
+            refStand?: string;
+        }) {
+            super();
+            pb_1.Message.initialize(this, Array.isArray(data) ? data : [], 0, -1, [], this.#one_of_decls);
+            if (!Array.isArray(data) && typeof data == "object") {
+                if ("common" in data && data.common != undefined) {
+                    this.common = data.common;
+                }
+                if ("code" in data && data.code != undefined) {
+                    this.code = data.code;
+                }
+                if ("flip" in data && data.flip != undefined) {
+                    this.flip = data.flip;
+                }
+                if ("index" in data && data.index != undefined) {
+                    this.index = data.index;
+                }
+                if ("refStand" in data && data.refStand != undefined) {
+                    this.refStand = data.refStand;
+                }
+            }
+        }
+        get common() {
+            return pb_1.Message.getWrapperField(this, CommonInfo, 1) as CommonInfo;
+        }
+        set common(value: CommonInfo) {
+            pb_1.Message.setWrapperField(this, 1, value);
+        }
+        get has_common() {
+            return pb_1.Message.getField(this, 1) != null;
+        }
+        get code() {
+            return pb_1.Message.getFieldWithDefault(this, 2, "") as string;
+        }
+        set code(value: string) {
+            pb_1.Message.setField(this, 2, value);
+        }
+        get flip() {
+            return pb_1.Message.getFieldWithDefault(this, 3, false) as boolean;
+        }
+        set flip(value: boolean) {
+            pb_1.Message.setField(this, 3, value);
+        }
+        get index() {
+            return pb_1.Message.getFieldWithDefault(this, 4, 0) as number;
+        }
+        set index(value: number) {
+            pb_1.Message.setField(this, 4, value);
+        }
+        get refStand() {
+            return pb_1.Message.getFieldWithDefault(this, 5, "") as string;
+        }
+        set refStand(value: string) {
+            pb_1.Message.setField(this, 5, value);
+        }
+        static fromObject(data: {
+            common?: ReturnType<typeof CommonInfo.prototype.toObject>;
+            code?: string;
+            flip?: boolean;
+            index?: number;
+            refStand?: string;
+        }): AutoReturnBox {
+            const message = new AutoReturnBox({});
+            if (data.common != null) {
+                message.common = CommonInfo.fromObject(data.common);
+            }
+            if (data.code != null) {
+                message.code = data.code;
+            }
+            if (data.flip != null) {
+                message.flip = data.flip;
+            }
+            if (data.index != null) {
+                message.index = data.index;
+            }
+            if (data.refStand != null) {
+                message.refStand = data.refStand;
+            }
+            return message;
+        }
+        toObject() {
+            const data: {
+                common?: ReturnType<typeof CommonInfo.prototype.toObject>;
+                code?: string;
+                flip?: boolean;
+                index?: number;
+                refStand?: string;
+            } = {};
+            if (this.common != null) {
+                data.common = this.common.toObject();
+            }
+            if (this.code != null) {
+                data.code = this.code;
+            }
+            if (this.flip != null) {
+                data.flip = this.flip;
+            }
+            if (this.index != null) {
+                data.index = this.index;
+            }
+            if (this.refStand != null) {
+                data.refStand = this.refStand;
+            }
+            return data;
+        }
+        serialize(): Uint8Array;
+        serialize(w: pb_1.BinaryWriter): void;
+        serialize(w?: pb_1.BinaryWriter): Uint8Array | void {
+            const writer = w || new pb_1.BinaryWriter();
+            if (this.has_common)
+                writer.writeMessage(1, this.common, () => this.common.serialize(writer));
+            if (this.code.length)
+                writer.writeString(2, this.code);
+            if (this.flip != false)
+                writer.writeBool(3, this.flip);
+            if (this.index != 0)
+                writer.writeInt32(4, this.index);
+            if (this.refStand.length)
+                writer.writeString(5, this.refStand);
+            if (!w)
+                return writer.getResultBuffer();
+        }
+        static deserialize(bytes: Uint8Array | pb_1.BinaryReader): AutoReturnBox {
+            const reader = bytes instanceof pb_1.BinaryReader ? bytes : new pb_1.BinaryReader(bytes), message = new AutoReturnBox();
+            while (reader.nextField()) {
+                if (reader.isEndGroup())
+                    break;
+                switch (reader.getFieldNumber()) {
+                    case 1:
+                        reader.readMessage(message.common, () => message.common = CommonInfo.deserialize(reader));
+                        break;
+                    case 2:
+                        message.code = reader.readString();
+                        break;
+                    case 3:
+                        message.flip = reader.readBool();
+                        break;
+                    case 4:
+                        message.index = reader.readInt32();
+                        break;
+                    case 5:
+                        message.refStand = reader.readString();
+                        break;
+                    default: reader.skipField();
+                }
+            }
+            return message;
+        }
+        serializeBinary(): Uint8Array {
+            return this.serialize();
+        }
+        static deserializeBinary(bytes: Uint8Array): AutoReturnBox {
+            return AutoReturnBox.deserialize(bytes);
+        }
+    }
     export class UniqueIdOfStationLayout extends pb_1.Message {
         #one_of_decls: number[][] = [];
         constructor(data?: any[] | {
@@ -7741,4 +7972,194 @@ export namespace graphicData {
             return SectionCodePoint.deserialize(bytes);
         }
     }
+    export class Train extends pb_1.Message {
+        #one_of_decls: number[][] = [];
+        constructor(data?: any[] | {
+            trainModel?: Train.TrainModel;
+            carriageLength?: number;
+            totalLength?: number;
+            minDiameter?: number;
+            maxDiameter?: number;
+            trainSets?: string;
+        }) {
+            super();
+            pb_1.Message.initialize(this, Array.isArray(data) ? data : [], 0, -1, [], this.#one_of_decls);
+            if (!Array.isArray(data) && typeof data == "object") {
+                if ("trainModel" in data && data.trainModel != undefined) {
+                    this.trainModel = data.trainModel;
+                }
+                if ("carriageLength" in data && data.carriageLength != undefined) {
+                    this.carriageLength = data.carriageLength;
+                }
+                if ("totalLength" in data && data.totalLength != undefined) {
+                    this.totalLength = data.totalLength;
+                }
+                if ("minDiameter" in data && data.minDiameter != undefined) {
+                    this.minDiameter = data.minDiameter;
+                }
+                if ("maxDiameter" in data && data.maxDiameter != undefined) {
+                    this.maxDiameter = data.maxDiameter;
+                }
+                if ("trainSets" in data && data.trainSets != undefined) {
+                    this.trainSets = data.trainSets;
+                }
+            }
+        }
+        get trainModel() {
+            return pb_1.Message.getFieldWithDefault(this, 1, Train.TrainModel.A) as Train.TrainModel;
+        }
+        set trainModel(value: Train.TrainModel) {
+            pb_1.Message.setField(this, 1, value);
+        }
+        get carriageLength() {
+            return pb_1.Message.getFieldWithDefault(this, 2, 0) as number;
+        }
+        set carriageLength(value: number) {
+            pb_1.Message.setField(this, 2, value);
+        }
+        get totalLength() {
+            return pb_1.Message.getFieldWithDefault(this, 3, 0) as number;
+        }
+        set totalLength(value: number) {
+            pb_1.Message.setField(this, 3, value);
+        }
+        get minDiameter() {
+            return pb_1.Message.getFieldWithDefault(this, 4, 0) as number;
+        }
+        set minDiameter(value: number) {
+            pb_1.Message.setField(this, 4, value);
+        }
+        get maxDiameter() {
+            return pb_1.Message.getFieldWithDefault(this, 5, 0) as number;
+        }
+        set maxDiameter(value: number) {
+            pb_1.Message.setField(this, 5, value);
+        }
+        get trainSets() {
+            return pb_1.Message.getFieldWithDefault(this, 6, "") as string;
+        }
+        set trainSets(value: string) {
+            pb_1.Message.setField(this, 6, value);
+        }
+        static fromObject(data: {
+            trainModel?: Train.TrainModel;
+            carriageLength?: number;
+            totalLength?: number;
+            minDiameter?: number;
+            maxDiameter?: number;
+            trainSets?: string;
+        }): Train {
+            const message = new Train({});
+            if (data.trainModel != null) {
+                message.trainModel = data.trainModel;
+            }
+            if (data.carriageLength != null) {
+                message.carriageLength = data.carriageLength;
+            }
+            if (data.totalLength != null) {
+                message.totalLength = data.totalLength;
+            }
+            if (data.minDiameter != null) {
+                message.minDiameter = data.minDiameter;
+            }
+            if (data.maxDiameter != null) {
+                message.maxDiameter = data.maxDiameter;
+            }
+            if (data.trainSets != null) {
+                message.trainSets = data.trainSets;
+            }
+            return message;
+        }
+        toObject() {
+            const data: {
+                trainModel?: Train.TrainModel;
+                carriageLength?: number;
+                totalLength?: number;
+                minDiameter?: number;
+                maxDiameter?: number;
+                trainSets?: string;
+            } = {};
+            if (this.trainModel != null) {
+                data.trainModel = this.trainModel;
+            }
+            if (this.carriageLength != null) {
+                data.carriageLength = this.carriageLength;
+            }
+            if (this.totalLength != null) {
+                data.totalLength = this.totalLength;
+            }
+            if (this.minDiameter != null) {
+                data.minDiameter = this.minDiameter;
+            }
+            if (this.maxDiameter != null) {
+                data.maxDiameter = this.maxDiameter;
+            }
+            if (this.trainSets != null) {
+                data.trainSets = this.trainSets;
+            }
+            return data;
+        }
+        serialize(): Uint8Array;
+        serialize(w: pb_1.BinaryWriter): void;
+        serialize(w?: pb_1.BinaryWriter): Uint8Array | void {
+            const writer = w || new pb_1.BinaryWriter();
+            if (this.trainModel != Train.TrainModel.A)
+                writer.writeEnum(1, this.trainModel);
+            if (this.carriageLength != 0)
+                writer.writeInt32(2, this.carriageLength);
+            if (this.totalLength != 0)
+                writer.writeInt32(3, this.totalLength);
+            if (this.minDiameter != 0)
+                writer.writeInt32(4, this.minDiameter);
+            if (this.maxDiameter != 0)
+                writer.writeInt32(5, this.maxDiameter);
+            if (this.trainSets.length)
+                writer.writeString(6, this.trainSets);
+            if (!w)
+                return writer.getResultBuffer();
+        }
+        static deserialize(bytes: Uint8Array | pb_1.BinaryReader): Train {
+            const reader = bytes instanceof pb_1.BinaryReader ? bytes : new pb_1.BinaryReader(bytes), message = new Train();
+            while (reader.nextField()) {
+                if (reader.isEndGroup())
+                    break;
+                switch (reader.getFieldNumber()) {
+                    case 1:
+                        message.trainModel = reader.readEnum();
+                        break;
+                    case 2:
+                        message.carriageLength = reader.readInt32();
+                        break;
+                    case 3:
+                        message.totalLength = reader.readInt32();
+                        break;
+                    case 4:
+                        message.minDiameter = reader.readInt32();
+                        break;
+                    case 5:
+                        message.maxDiameter = reader.readInt32();
+                        break;
+                    case 6:
+                        message.trainSets = reader.readString();
+                        break;
+                    default: reader.skipField();
+                }
+            }
+            return message;
+        }
+        serializeBinary(): Uint8Array {
+            return this.serialize();
+        }
+        static deserializeBinary(bytes: Uint8Array): Train {
+            return Train.deserialize(bytes);
+        }
+    }
+    export namespace Train {
+        export enum TrainModel {
+            A = 0,
+            B = 1,
+            C = 2,
+            D = 3
+        }
+    }
 }