diff --git a/src/components/draw-app/TccDrawProperties.vue b/src/components/draw-app/TccDrawProperties.vue index 5a7eb45..d9d601d 100644 --- a/src/components/draw-app/TccDrawProperties.vue +++ b/src/components/draw-app/TccDrawProperties.vue @@ -17,10 +17,16 @@ + /> + /> + + @@ -34,6 +40,10 @@ import { TccButton } from 'src/graphics/tccButton/TccButton'; import TccButtonProperty from './properties/TccButtonProperty.vue'; import { TextContent } from 'src/graphics/textContent/TextContent'; import TccTextProperty from './properties/TccTextProperty.vue'; +import { TccKey } from 'src/graphics/tccKey/TccKey'; +import TccKeyProperty from './properties/TccKeyProperty.vue'; +import { TccHandle } from 'src/graphics/tccHandle/TccHandle'; +import TccHandleProperty from './properties/TccHandleProperty.vue'; const tccDrawStore = useTccDrawStore(); diff --git a/src/components/draw-app/properties/TccButtonProperty.vue b/src/components/draw-app/properties/TccButtonProperty.vue index 1d2a699..742074f 100644 --- a/src/components/draw-app/properties/TccButtonProperty.vue +++ b/src/components/draw-app/properties/TccButtonProperty.vue @@ -8,15 +8,6 @@ label="紧急制动按钮" lazy-rules /> - import { TccButtonData } from 'src/drawApp/graphics/TccButtonInteraction'; -import { tccGraphicData } from 'src/protos/tccGraphics'; import { useFormData } from 'src/components/DrawAppFormUtils'; import { useTccDrawStore } from 'src/stores/tcc-draw-store'; @@ -35,9 +25,4 @@ const { data: tccButtonModel, onUpdate } = useFormData( new TccButtonData(), useTccDrawStore().getDrawApp() ); - -const optionsButtonColor = [ - { label: '绿色', value: tccGraphicData.TccElementColor.green }, - { label: '红色', value: tccGraphicData.TccElementColor.red }, -]; diff --git a/src/components/draw-app/properties/TccHandleProperty.vue b/src/components/draw-app/properties/TccHandleProperty.vue new file mode 100644 index 0000000..00c6320 --- /dev/null +++ b/src/components/draw-app/properties/TccHandleProperty.vue @@ -0,0 +1,24 @@ + + + diff --git a/src/components/draw-app/properties/TccKeyProperty.vue b/src/components/draw-app/properties/TccKeyProperty.vue new file mode 100644 index 0000000..476a3e0 --- /dev/null +++ b/src/components/draw-app/properties/TccKeyProperty.vue @@ -0,0 +1,44 @@ + + + diff --git a/src/drawApp/graphics/TccButtonInteraction.ts b/src/drawApp/graphics/TccButtonInteraction.ts index 1dc75b6..5c74744 100644 --- a/src/drawApp/graphics/TccButtonInteraction.ts +++ b/src/drawApp/graphics/TccButtonInteraction.ts @@ -31,12 +31,6 @@ export class TccButtonData extends GraphicDataBase implements ITccButtonData { set code(v: string) { this.data.code = v; } - get buttonColor(): tccGraphicData.TccElementColor { - return this.data.buttonColor; - } - set buttonColor(v: tccGraphicData.TccElementColor) { - this.data.buttonColor = v; - } get isSelfReset(): boolean { return this.data.isSelfReset; } diff --git a/src/drawApp/graphics/TccHandleInteraction.ts b/src/drawApp/graphics/TccHandleInteraction.ts new file mode 100644 index 0000000..ef4e8e6 --- /dev/null +++ b/src/drawApp/graphics/TccHandleInteraction.ts @@ -0,0 +1,132 @@ +import * as pb_1 from 'google-protobuf'; +import { + ITccHandleData, + ITccHandleState, + TccHandle, +} from 'src/graphics/tccHandle/TccHandle'; +import { tccGraphicData } from 'src/protos/tccGraphics'; +import { GraphicDataBase, GraphicStateBase } from './GraphicDataBase'; +import { state } from 'src/protos/device_state'; +import { GraphicInteractionPlugin, IGraphicScene, JlGraphic } from 'jl-graphic'; +import { type FederatedMouseEvent } from 'pixi.js'; +import { useTccStore } from 'src/stores/tcc-store'; + +export class TccHandleData extends GraphicDataBase implements ITccHandleData { + constructor(data?: tccGraphicData.TccHandle) { + let tccHandle; + if (data) { + tccHandle = data; + } else { + tccHandle = new tccGraphicData.TccHandle({ + common: GraphicDataBase.defaultCommonInfo(TccHandle.Type), + }); + } + super(tccHandle); + } + + public get data(): tccGraphicData.TccHandle { + return this.getData(); + } + + get code(): string { + return this.data.code; + } + set code(v: string) { + this.data.code = v; + } + clone(): TccHandleData { + return new TccHandleData(this.data.cloneMessage()); + } + copyFrom(data: TccHandleData): void { + pb_1.Message.copyInto(data.data, this.data); + } + eq(other: TccHandleData): boolean { + return pb_1.Message.equals(this.data, other.data); + } +} + +export class TccHandleState + extends GraphicStateBase + implements ITccHandleState +{ + constructor(data?: state.KeyState) { + let tccHandleState; + if (data) { + tccHandleState = data; + } else { + tccHandleState = new state.KeyState(); + } + super(tccHandleState, TccHandle.Type); + } + get code(): string { + return this.states.id + ''; + } + get states(): state.KeyState { + return this.getState(); + } + get gear(): number { + return this.states.gear; + } + set gear(v: number) { + this.states.gear = v; + } + clone(): TccHandleState { + return new TccHandleState(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); + } +} + +export class TccHandleInteraction extends GraphicInteractionPlugin { + static Name = 'TccHandleInteraction'; + isMouseDown = false; + mouseDownBeginPos = 0; + mouseDownTccHandleBeginPos = 0; + constructor(app: IGraphicScene) { + super(TccHandleInteraction.Name, app); + } + static init(app: IGraphicScene) { + return new TccHandleInteraction(app); + } + filter(...grahpics: JlGraphic[]): TccHandle[] | undefined { + return grahpics.filter((g): g is TccHandle => g instanceof TccHandle); + } + bind(g: TccHandle): void { + g.eventMode = 'static'; + g.cursor = 'pointer'; + g._tccHandle.eventMode = 'static'; + g._tccHandle.cursor = 'pointer'; + g._tccHandle.on('mousedown', this.onMouseDown); + g._tccHandle.on('mouseup', this.onMouseUp); + g.onmousemove = (e) => { + this.onMouseOver(e); + }; + } + unbind(g: TccHandle): void { + g.eventMode = 'none'; + g._tccHandle.eventMode = 'none'; + g._tccHandle.off('mousedown', this.onMouseDown); + g._tccHandle.off('mouseup', this.onMouseUp); + g.onmousemove = null; + } + onMouseDown(e: FederatedMouseEvent) { + const tccHandle = e.target as TccHandle; + this.isMouseDown = true; + this.mouseDownBeginPos = e.clientY; + this.mouseDownTccHandleBeginPos = tccHandle._tccHandle.y; + } + onMouseUp() { + this.isMouseDown = false; + } + onMouseOver(e: FederatedMouseEvent) { + const tccHandle = e.target as TccHandle; + if (this.isMouseDown) { + tccHandle._tccHandle.y = + this.mouseDownTccHandleBeginPos + e.clientY - this.mouseDownBeginPos; + } + } +} diff --git a/src/drawApp/graphics/TccKeyInteraction.ts b/src/drawApp/graphics/TccKeyInteraction.ts new file mode 100644 index 0000000..0b45ffb --- /dev/null +++ b/src/drawApp/graphics/TccKeyInteraction.ts @@ -0,0 +1,108 @@ +import * as pb_1 from 'google-protobuf'; +import { ITccKeyData, ITccKeyState, TccKey } from 'src/graphics/tccKey/TccKey'; +import { tccGraphicData } from 'src/protos/tccGraphics'; +import { GraphicDataBase, GraphicStateBase } from './GraphicDataBase'; +import { state } from 'src/protos/device_state'; +import { GraphicInteractionPlugin, IGraphicScene, JlGraphic } from 'jl-graphic'; +import { type FederatedMouseEvent } from 'pixi.js'; +import { useTccStore } from 'src/stores/tcc-store'; + +export class TccKeyData extends GraphicDataBase implements ITccKeyData { + constructor(data?: tccGraphicData.TccKey) { + let tccKey; + if (data) { + tccKey = data; + } else { + tccKey = new tccGraphicData.TccKey({ + common: GraphicDataBase.defaultCommonInfo(TccKey.Type), + }); + } + super(tccKey); + } + + public get data(): tccGraphicData.TccKey { + return this.getData(); + } + + get code(): string { + return this.data.code; + } + set code(v: string) { + this.data.code = v; + } + get type(): tccGraphicData.TccKey.TccKeyType { + return this.data.type; + } + set type(v: tccGraphicData.TccKey.TccKeyType) { + this.data.type = v; + } + clone(): TccKeyData { + return new TccKeyData(this.data.cloneMessage()); + } + copyFrom(data: TccKeyData): void { + pb_1.Message.copyInto(data.data, this.data); + } + eq(other: TccKeyData): boolean { + return pb_1.Message.equals(this.data, other.data); + } +} + +export class TccKeyState extends GraphicStateBase implements ITccKeyState { + constructor(data?: state.KeyState) { + let tccKeyState; + if (data) { + tccKeyState = data; + } else { + tccKeyState = new state.KeyState(); + } + super(tccKeyState, TccKey.Type); + } + get code(): string { + return this.states.id + ''; + } + get states(): state.KeyState { + return this.getState(); + } + get gear(): number { + return this.states.gear; + } + set gear(v: number) { + this.states.gear = v; + } + clone(): TccKeyState { + return new TccKeyState(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); + } +} + +export class TccKeyInteraction extends GraphicInteractionPlugin { + static Name = 'TccKeyInteraction'; + constructor(app: IGraphicScene) { + super(TccKeyInteraction.Name, app); + } + static init(app: IGraphicScene) { + return new TccKeyInteraction(app); + } + filter(...grahpics: JlGraphic[]): TccKey[] | undefined { + return grahpics.filter((g): g is TccKey => g instanceof TccKey); + } + bind(g: TccKey): void { + g.eventMode = 'static'; + g.cursor = 'pointer'; + g.on('_leftclick', this.onClick); + } + unbind(g: TccKey): void { + g.eventMode = 'none'; + g.off('_leftclick', this.onClick); + } + onClick(e: FederatedMouseEvent): void { + const g = e.target as TccKey; + /* const changeState = useTccStore().tccKeyOperation; + changeState(g.datas.id, g.state.gear === 0 ? 1 : 0); */ + } +} diff --git a/src/drawApp/tccApp.ts b/src/drawApp/tccApp.ts index 42876bb..f3be4a0 100644 --- a/src/drawApp/tccApp.ts +++ b/src/drawApp/tccApp.ts @@ -26,6 +26,16 @@ import { } from 'src/graphics/textContent/TextContent'; import { TccTextData } from './graphics/TccTextContentInteraction'; import { TextContentDraw } from 'src/graphics/textContent/TextContentDrawAssistant'; +import { TccKeyDraw } from 'src/graphics/tccKey/TccKeyDrawAssistant'; +import { TccKey, TccKeyTemplate } from 'src/graphics/tccKey/TccKey'; +import { TccKeyData, TccKeyState } from './graphics/TccKeyInteraction'; +import { TccHandleDraw } from 'src/graphics/tccHandle/TccHandleDrawAssistant'; +import { TccHandle, TccHandleTemplate } from 'src/graphics/tccHandle/TccHandle'; +import { + TccHandleData, + TccHandleInteraction, + TccHandleState, +} from './graphics/TccHandleInteraction'; const UndoOptions: MenuItemOptions = { name: '撤销', @@ -73,6 +83,15 @@ export function initTccDrawApp(): IDrawApp { new TccButtonTemplate(new TccButtonData(), new TccButtonState()) ); new TextContentDraw(app, new TextContentTemplate(new TccTextData())); + new TccKeyDraw( + drawApp, + new TccKeyTemplate(new TccKeyData(), new TccKeyState()) + ); + new TccHandleDraw( + drawApp, + new TccHandleTemplate(new TccHandleData(), new TccHandleState()) + ); + TccHandleInteraction.init(app); // 画布右键菜单 app.registerMenu(DefaultCanvasMenu); @@ -159,12 +178,14 @@ export function saveTccDrawDatas(app: IDrawApp) { }); const graphics = app.queryStore.getAllGraphics(); graphics.forEach((g) => { - if (TccButton.Type === g.type) { - const tccButtonData = (g as TccButton).saveData(); - storage.tccButtons.push((tccButtonData as TccButtonData).data); - } else if (TextContent.Type === g.type) { - const tccTextData = (g as TextContent).saveData(); - storage.tccTexts.push((tccTextData as TccTextData).data); + if (g instanceof TccButton) { + storage.tccButtons.push(g.saveData().data); + } else if (g instanceof TextContent) { + storage.tccTexts.push(g.saveData().data); + } else if (g instanceof TccKey) { + storage.tccKeys.push(g.saveData().data); + } else if (g instanceof TccHandle) { + storage.tccHandles.push(g.saveData().data); } }); const base64 = fromUint8Array(storage.serialize()); @@ -189,6 +210,12 @@ export async function loadTccDrawDatas(): Promise { storage.tccButtons.forEach((tccButton) => { datas.push(new TccButtonData(tccButton)); }); + storage.tccKeys.forEach((tccKey) => { + datas.push(new TccKeyData(tccKey)); + }); + storage.tccHandles.forEach((tccHandle) => { + datas.push(new TccHandleData(tccHandle)); + }); storage.tccTexts.forEach((tccText) => { datas.push(new TccTextData(tccText)); }); diff --git a/src/drawApp/tccScene.ts b/src/drawApp/tccScene.ts index 7a7b3f1..0b41a4e 100644 --- a/src/drawApp/tccScene.ts +++ b/src/drawApp/tccScene.ts @@ -10,10 +10,27 @@ import { useTccStore } from 'src/stores/tcc-store'; import { toUint8Array } from 'js-base64'; import { useLineStore } from 'src/stores/line-store'; import { state } from 'src/protos/device_state'; -import { TccButtonData, TccButtonOperateInteraction, TccButtonState } from './graphics/TccButtonInteraction'; +import { + TccButtonData, + TccButtonOperateInteraction, + TccButtonState, +} from './graphics/TccButtonInteraction'; import { tccGraphicData } from 'src/protos/tccGraphics'; import { TccButtonTemplate } from 'src/graphics/tccButton/TccButton'; - +import { TextContentTemplate } from 'src/graphics/textContent/TextContent'; +import { TccTextData } from './graphics/TccTextContentInteraction'; +import { TccKeyTemplate } from 'src/graphics/tccKey/TccKey'; +import { + TccKeyData, + TccKeyInteraction, + TccKeyState, +} from './graphics/TccKeyInteraction'; +import { TccHandleTemplate } from 'src/graphics/tccHandle/TccHandle'; +import { + TccHandleData, + TccHandleInteraction, + TccHandleState, +} from './graphics/TccHandleInteraction'; export function initTccScene(lineApp: IGraphicApp, sceneName: string) { const tccScene = lineApp.initScene(sceneName, { @@ -26,8 +43,13 @@ export function initTccScene(lineApp: IGraphicApp, sceneName: string) { }); const graphicTemplate = [ new TccButtonTemplate(new TccButtonData(), new TccButtonState()), + new TextContentTemplate(new TccTextData()), + new TccKeyTemplate(new TccKeyData(), new TccKeyState()), + new TccHandleTemplate(new TccHandleData(), new TccHandleState()), ]; TccButtonOperateInteraction.init(tccScene); + TccKeyInteraction.init(tccScene); + TccHandleInteraction.init(tccScene); tccScene.registerGraphicTemplates(...graphicTemplate); tccScene.on('postdataloaded', () => { handleSubscribe(tccScene); @@ -82,6 +104,15 @@ async function loadTccDatas(): Promise { storage.tccButtons.forEach((tccButton) => { datas.push(new TccButtonData(tccButton)); }); + storage.tccKeys.forEach((tccKey) => { + datas.push(new TccKeyData(tccKey)); + }); + storage.tccHandles.forEach((tccHandle) => { + datas.push(new TccHandleData(tccHandle)); + }); + storage.tccTexts.forEach((tccText) => { + datas.push(new TccTextData(tccText)); + }); return Promise.resolve({ canvasProperty: storage.canvas, datas: datas, diff --git a/src/graphics/tccButton/TccButton.ts b/src/graphics/tccButton/TccButton.ts index 6c5d93b..9bb23c0 100644 --- a/src/graphics/tccButton/TccButton.ts +++ b/src/graphics/tccButton/TccButton.ts @@ -13,15 +13,11 @@ import { tccGraphicData } from 'src/protos/tccGraphics'; interface TccButtonTextures { redBtn: Texture; greenBtn: Texture; - redBtnPress: Texture; - greenBtnPress: Texture; } export interface ITccButtonData extends GraphicData { get code(): string; set code(v: string); - get buttonColor(): tccGraphicData.TccElementColor; - set buttonColor(v: tccGraphicData.TccElementColor); get isSelfReset(): boolean; set isSelfReset(v: boolean); } @@ -58,18 +54,10 @@ export class TccButton extends JlGraphic { } doRepaint(): void { this._tccButton.rotation = 0; - if (this.datas.buttonColor === tccGraphicData.TccElementColor.green) { - if (this.states.down) { - this._tccButton.texture = this.tccButtonTextures.greenBtnPress; - } else { - this._tccButton.texture = this.tccButtonTextures.greenBtn; - } + if (this.states.down) { + this._tccButton.texture = this.tccButtonTextures.redBtn; } else { - if (this.states.down) { - this._tccButton.texture = this.tccButtonTextures.redBtnPress; - } else { - this._tccButton.texture = this.tccButtonTextures.redBtn; - } + this._tccButton.texture = this.tccButtonTextures.greenBtn; } } } @@ -96,8 +84,6 @@ export class TccButtonTemplate extends JlGraphicTemplate { this.tccButtonTextures = { redBtn: result['red-btn.png'], greenBtn: result['green-btn.png'], - redBtnPress: result['red-btn-press.png'], - greenBtnPress: result['green-btn-press.png'], }; return this.tccButtonTextures as TccButtonTextures; } diff --git a/src/graphics/tccHandle/TccHandle.ts b/src/graphics/tccHandle/TccHandle.ts new file mode 100644 index 0000000..258d0fc --- /dev/null +++ b/src/graphics/tccHandle/TccHandle.ts @@ -0,0 +1,87 @@ +import { + GraphicData, + GraphicState, + JlGraphic, + JlGraphicTemplate, +} from 'jl-graphic'; +import Tcc_Handle_Assets from './tcc-handle-spritesheet.png'; +import Tcc_Handle_JSON from './tcc-handle-data.json'; + +import { Assets, Sprite, Spritesheet, Texture } from 'pixi.js'; + +interface TccHandleTextures { + tccHandle: Texture; + handleBackground: Texture; +} + +export interface ITccHandleData extends GraphicData { + get code(): string; + set code(v: string); +} + +export interface ITccHandleState extends GraphicState { + get gear(): number; + set gear(v: number); +} + +export class TccHandle extends JlGraphic { + static Type = 'TccHandle'; + _tccHandle: Sprite; + _tccHandleBackground: Sprite; + tccHandleTextures: TccHandleTextures; + __state = 0; + + constructor(tccHandleTextures: TccHandleTextures) { + super(TccHandle.Type); + this.tccHandleTextures = tccHandleTextures; + this._tccHandle = new Sprite(); + this._tccHandle.texture = this.tccHandleTextures.tccHandle; + this._tccHandle.anchor.set(0.5); + this._tccHandleBackground = new Sprite(); + this._tccHandleBackground.texture = this.tccHandleTextures.handleBackground; + this._tccHandleBackground.anchor.set(0.5); + this._tccHandleBackground.position.x = -20; + this.addChild(this._tccHandleBackground); + this.addChild(this._tccHandle); + } + get code(): string { + return this.datas.code; + } + get datas() { + return this.getDatas(); + } + get state() { + return this.getStates(); + } + doRepaint(): void { + this._tccHandle.rotation = (-Math.PI / 2) * this.state.gear; + this._tccHandle.texture = this.tccHandleTextures.tccHandle; + } +} + +export class TccHandleTemplate extends JlGraphicTemplate { + tccHandleTextures?: TccHandleTextures; + constructor(dataTemplate: ITccHandleData, stateTemplate?: ITccHandleState) { + super(TccHandle.Type, { dataTemplate, stateTemplate }); + this.loadAssets(); + } + new(): TccHandle { + if (this.tccHandleTextures) { + const g = new TccHandle(this.tccHandleTextures); + g.loadData(this.datas); + g.loadState(this.states); + return g; + } + throw new Error('资源未加载/加载失败'); + } + async loadAssets(): Promise { + const texture = await Assets.load(Tcc_Handle_Assets); + const tccHandleSheet = new Spritesheet(texture, Tcc_Handle_JSON); + const result = await tccHandleSheet.parse(); + this.tccHandleTextures = { + tccHandle: result['handle.png'], + handleBackground: result['handleBackground.png'], + }; + return this.tccHandleTextures as TccHandleTextures; + } +} diff --git a/src/graphics/tccHandle/TccHandleDrawAssistant.ts b/src/graphics/tccHandle/TccHandleDrawAssistant.ts new file mode 100644 index 0000000..519a467 --- /dev/null +++ b/src/graphics/tccHandle/TccHandleDrawAssistant.ts @@ -0,0 +1,116 @@ +import { DisplayObject, FederatedMouseEvent, Point } from 'pixi.js'; +import { + AbsorbableLine, + AbsorbablePosition, + GraphicDrawAssistant, + GraphicInteractionPlugin, + GraphicTransformEvent, + IDrawApp, + JlGraphic, +} from 'jl-graphic'; +import { ITccHandleData, TccHandle, TccHandleTemplate } from './TccHandle'; + +export class TccHandleDraw extends GraphicDrawAssistant< + TccHandleTemplate, + ITccHandleData +> { + _tccHandle: TccHandle | null = null; + constructor(app: IDrawApp, template: TccHandleTemplate) { + super(app, template, 'drag_handle', 'Tcc手柄'); + TccHandleInteraction.init(app); + } + + bind(): void { + super.bind(); + if (!this._tccHandle) { + this._tccHandle = this.graphicTemplate.new(); + this.container.addChild(this._tccHandle); + } + } + + public get tccHandle(): TccHandle { + if (!this._tccHandle) { + this._tccHandle = this.graphicTemplate.new(); + this.container.addChild(this._tccHandle); + } + return this._tccHandle; + } + + redraw(cp: Point): void { + this.tccHandle.position.copyFrom(cp); + } + onLeftUp(e: FederatedMouseEvent): void { + this.tccHandle.position.copyFrom(this.toCanvasCoordinates(e.global)); + this.createAndStore(true); + } + prepareData(data: ITccHandleData): boolean { + data.transform = this.tccHandle.saveTransform(); + return true; + } + onEsc(): void { + this.finish(); + } +} + +/** + * 构建吸附线 + * @param tccHandle + */ +function buildAbsorbablePositions(tccHandle: TccHandle): AbsorbablePosition[] { + const aps: AbsorbablePosition[] = []; + const tccHandles = tccHandle.queryStore.queryByType( + TccHandle.Type + ); + const canvas = tccHandle.getCanvas(); + tccHandles.forEach((item) => { + if (item.id === tccHandle.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 TccHandleInteraction extends GraphicInteractionPlugin { + static Name = 'tcc_handle_transform'; + constructor(app: IDrawApp) { + super(TccHandleInteraction.Name, app); + } + static init(app: IDrawApp) { + return new TccHandleInteraction(app); + } + filter(...grahpics: JlGraphic[]): TccHandle[] | undefined { + return grahpics + .filter((g) => g.type === TccHandle.Type) + .map((g) => g as TccHandle); + } + bind(g: TccHandle): void { + g.eventMode = 'static'; + g.cursor = 'pointer'; + g.scalable = true; + g.rotatable = true; + g.on('transformstart', this.transformstart, this); + } + unbind(g: TccHandle): void { + g.eventMode = 'none'; + g.scalable = false; + g.rotatable = false; + g.off('transformstart', this.transformstart, this); + } + transformstart(e: GraphicTransformEvent) { + const target = e.target as DisplayObject; + const tccHandle = target.getGraphic() as TccHandle; + tccHandle.getGraphicApp().setOptions({ + absorbablePositions: buildAbsorbablePositions(tccHandle), + }); + } +} diff --git a/src/graphics/tccHandle/tcc-handle-data.json b/src/graphics/tccHandle/tcc-handle-data.json new file mode 100644 index 0000000..2d74d98 --- /dev/null +++ b/src/graphics/tccHandle/tcc-handle-data.json @@ -0,0 +1,28 @@ +{"frames": { + +"handle.png": +{ + "frame": {"x":0,"y":0,"w":64,"h":14}, + "rotated": false, + "trimmed": false, + "spriteSourceSize": {"x":0,"y":0,"w":64,"h":14}, + "sourceSize": {"w":64,"h":14} +}, +"handleBackground.png": +{ + "frame": {"x":0,"y":14,"w":120,"h":300}, + "rotated": false, + "trimmed": false, + "spriteSourceSize": {"x":0,"y":0,"w":120,"h":300}, + "sourceSize": {"w":120,"h":300} +}}, +"meta": { + "app": "https://www.codeandweb.com/texturepacker", + "version": "1.1", + "image": "tcc-handle-data.png", + "format": "RGBA8888", + "size": {"w":120,"h":314}, + "scale": "1", + "smartupdate": "$TexturePacker:SmartUpdate:35ec8faa530fc86d3b0740464eb2648e:0a63968fd7e862029434ae414b4e8d7b:5c8a7a2b19e5dc1773dcba416f4dca6e$" +} +} diff --git a/src/graphics/tccHandle/tcc-handle-spritesheet.png b/src/graphics/tccHandle/tcc-handle-spritesheet.png new file mode 100644 index 0000000..62c1ca4 Binary files /dev/null and b/src/graphics/tccHandle/tcc-handle-spritesheet.png differ diff --git a/src/graphics/tccKey/TccKey.ts b/src/graphics/tccKey/TccKey.ts new file mode 100644 index 0000000..2595e7d --- /dev/null +++ b/src/graphics/tccKey/TccKey.ts @@ -0,0 +1,101 @@ +import { + GraphicData, + GraphicState, + JlGraphic, + JlGraphicTemplate, +} from 'jl-graphic'; +import Tcc_Key_Assets from './tcc-key-spritesheet.png'; +import Tcc_Key_JSON from './tcc-key-data.json'; + +import { Assets, Sprite, Spritesheet, Texture } from 'pixi.js'; +import { tccGraphicData } from 'src/protos/tccGraphics'; + +interface TccKeyTextures { + tccKey: Texture; + tccKeyBackground: Texture; + tccKnob: Texture; +} + +export interface ITccKeyData extends GraphicData { + get code(): string; + set code(v: string); + get type(): tccGraphicData.TccKey.TccKeyType; + set type(v: tccGraphicData.TccKey.TccKeyType); +} + +export interface ITccKeyState extends GraphicState { + get gear(): number; + set gear(v: number); +} + +export class TccKey extends JlGraphic { + static Type = 'TccKey'; + _tccKey: Sprite; + _tccBackground: Sprite; + tccKeyTextures: TccKeyTextures; + __state = 0; + + constructor(tccKeyTextures: TccKeyTextures) { + super(TccKey.Type); + this.tccKeyTextures = tccKeyTextures; + this._tccKey = new Sprite(); + this._tccKey.texture = this.tccKeyTextures.tccKey; + this._tccKey.scale.set(0.125); + this._tccKey.anchor.set(0.5); + this._tccBackground = new Sprite(); + this._tccBackground.texture = this.tccKeyTextures.tccKeyBackground; + this._tccBackground.anchor.set(0.5); + this.addChild(this._tccBackground); + this.addChild(this._tccKey); + } + get code(): string { + return this.datas.code; + } + get datas() { + return this.getDatas(); + } + get state() { + return this.getStates(); + } + doRepaint(): void { + //this._tccKey.rotation = (-Math.PI / 2) * this.state.gear; + if ( + this.datas.type == + tccGraphicData.TccKey.TccKeyType.driverControllerActivationClint + ) { + this._tccKey.texture = this.tccKeyTextures.tccKey; + this._tccKey.rotation = Math.PI / 4; + } else { + this._tccKey.texture = this.tccKeyTextures.tccKnob; + this._tccKey.scale.set(0.6); + } + } +} + +export class TccKeyTemplate extends JlGraphicTemplate { + tccKeyTextures?: TccKeyTextures; + constructor(dataTemplate: ITccKeyData, stateTemplate?: ITccKeyState) { + super(TccKey.Type, { dataTemplate, stateTemplate }); + this.loadAssets(); + } + new(): TccKey { + if (this.tccKeyTextures) { + const g = new TccKey(this.tccKeyTextures); + g.loadData(this.datas); + g.loadState(this.states); + return g; + } + throw new Error('资源未加载/加载失败'); + } + async loadAssets(): Promise { + const texture = await Assets.load(Tcc_Key_Assets); + const tccKeySheet = new Spritesheet(texture, Tcc_Key_JSON); + const result = await tccKeySheet.parse(); + this.tccKeyTextures = { + tccKey: result['key.png'], + tccKeyBackground: result['background.png'], + tccKnob: result['knob.png'], + }; + return this.tccKeyTextures as TccKeyTextures; + } +} diff --git a/src/graphics/tccKey/TccKeyDrawAssistant.ts b/src/graphics/tccKey/TccKeyDrawAssistant.ts new file mode 100644 index 0000000..b05f1ab --- /dev/null +++ b/src/graphics/tccKey/TccKeyDrawAssistant.ts @@ -0,0 +1,114 @@ +import { DisplayObject, FederatedMouseEvent, Point } from 'pixi.js'; +import { + AbsorbableLine, + AbsorbablePosition, + GraphicDrawAssistant, + GraphicInteractionPlugin, + GraphicTransformEvent, + IDrawApp, + JlGraphic, +} from 'jl-graphic'; +import { ITccKeyData, TccKey, TccKeyTemplate } from './TccKey'; + +export class TccKeyDraw extends GraphicDrawAssistant< + TccKeyTemplate, + ITccKeyData +> { + _tccKey: TccKey | null = null; + constructor(app: IDrawApp, template: TccKeyTemplate) { + super(app, template, 'svguse:../drawIcon.svg#icon-psl-key', 'Tcc钥匙'); + TccKeyInteraction.init(app); + } + + bind(): void { + super.bind(); + if (!this._tccKey) { + this._tccKey = this.graphicTemplate.new(); + this.container.addChild(this._tccKey); + } + } + + public get tccKey(): TccKey { + if (!this._tccKey) { + this._tccKey = this.graphicTemplate.new(); + this.container.addChild(this._tccKey); + } + return this._tccKey; + } + + redraw(cp: Point): void { + this.tccKey.position.copyFrom(cp); + } + onLeftUp(e: FederatedMouseEvent): void { + this.tccKey.position.copyFrom(this.toCanvasCoordinates(e.global)); + this.createAndStore(true); + } + prepareData(data: ITccKeyData): boolean { + data.transform = this.tccKey.saveTransform(); + return true; + } + onEsc(): void { + this.finish(); + } +} + +/** + * 构建吸附线 + * @param tccKey + */ +function buildAbsorbablePositions(tccKey: TccKey): AbsorbablePosition[] { + const aps: AbsorbablePosition[] = []; + const tccKeys = tccKey.queryStore.queryByType(TccKey.Type); + const canvas = tccKey.getCanvas(); + tccKeys.forEach((item) => { + if (item.id === tccKey.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 TccKeyInteraction extends GraphicInteractionPlugin { + static Name = 'tcc_key_transform'; + constructor(app: IDrawApp) { + super(TccKeyInteraction.Name, app); + } + static init(app: IDrawApp) { + return new TccKeyInteraction(app); + } + filter(...grahpics: JlGraphic[]): TccKey[] | undefined { + return grahpics + .filter((g) => g.type === TccKey.Type) + .map((g) => g as TccKey); + } + bind(g: TccKey): void { + g.eventMode = 'static'; + g.cursor = 'pointer'; + g.scalable = true; + g.rotatable = true; + g.on('transformstart', this.transformstart, this); + } + unbind(g: TccKey): void { + g.eventMode = 'none'; + g.scalable = false; + g.rotatable = false; + g.off('transformstart', this.transformstart, this); + } + transformstart(e: GraphicTransformEvent) { + const target = e.target as DisplayObject; + const tccKey = target.getGraphic() as TccKey; + tccKey.getGraphicApp().setOptions({ + absorbablePositions: buildAbsorbablePositions(tccKey), + }); + } +} diff --git a/src/graphics/tccKey/tcc-key-data.json b/src/graphics/tccKey/tcc-key-data.json new file mode 100644 index 0000000..ce29fd4 --- /dev/null +++ b/src/graphics/tccKey/tcc-key-data.json @@ -0,0 +1,39 @@ +{"frames": { + +"background.png": +{ + "frame": {"x":0,"y":0,"w":128,"h":128}, + "rotated": false, + "trimmed": false, + "spriteSourceSize": {"x":0,"y":0,"w":128,"h":128}, + "sourceSize": {"w":128,"h":128}, + "anchor": {"x":0.5,"y":0.5} +}, +"key.png": +{ + "frame": {"x":0,"y":128,"w":378,"h":393}, + "rotated": false, + "trimmed": false, + "spriteSourceSize": {"x":0,"y":0,"w":378,"h":393}, + "sourceSize": {"w":378,"h":393}, + "anchor": {"x":0.5,"y":0.5} +}, +"knob.png": +{ + "frame": {"x":128,"y":0,"w":128,"h":128}, + "rotated": false, + "trimmed": false, + "spriteSourceSize": {"x":0,"y":0,"w":128,"h":128}, + "sourceSize": {"w":128,"h":128}, + "anchor": {"x":0.5,"y":0.5} +}}, +"meta": { + "app": "https://www.codeandweb.com/texturepacker", + "version": "1.1", + "image": "tcc-key-data.png", + "format": "RGBA8888", + "size": {"w":378,"h":521}, + "scale": "1", + "smartupdate": "$TexturePacker:SmartUpdate:323ae655a9099ea9ee5548018c8bb2dc:86d9df42807e3cd9d3abb5eaf5f7db62:90c3bb9fceb7f742c704ab999fd08093$" +} +} diff --git a/src/graphics/tccKey/tcc-key-spritesheet.png b/src/graphics/tccKey/tcc-key-spritesheet.png new file mode 100644 index 0000000..a4af9c4 Binary files /dev/null and b/src/graphics/tccKey/tcc-key-spritesheet.png differ diff --git a/src/layouts/TrainControlCabDrawLayout.vue b/src/layouts/TrainControlCabDrawLayout.vue index c74cdd7..95e7225 100644 --- a/src/layouts/TrainControlCabDrawLayout.vue +++ b/src/layouts/TrainControlCabDrawLayout.vue @@ -123,6 +123,8 @@ import { ApiError } from 'src/boot/axios'; import { useQuasar } from 'quasar'; import { TccButton } from 'src/graphics/tccButton/TccButton'; import { TextContent } from 'src/graphics/textContent/TextContent'; +import { TccKey } from 'src/graphics/tccKey/TccKey'; +import { TccHandle } from 'src/graphics/tccHandle/TccHandle'; const $q = useQuasar(); const route = useRoute(); @@ -203,7 +205,12 @@ onMounted(() => { tccDrawStore.setDraftId(null); } - const drawAssistantsTypes = [TccButton.Type, TextContent.Type]; + const drawAssistantsTypes = [ + TccButton.Type, + TextContent.Type, + TccKey.Type, + TccHandle.Type, + ]; drawAssistantsTypes.forEach((type) => { const drawAssistant = getTccDrawApp()?.getDrawAssistant(type); if (drawAssistant) { diff --git a/src/protos/tccGraphics.ts b/src/protos/tccGraphics.ts index ba656d6..db13d88 100644 --- a/src/protos/tccGraphics.ts +++ b/src/protos/tccGraphics.ts @@ -6,19 +6,17 @@ import * as dependency_1 from "./stationLayoutGraphics"; import * as pb_1 from "google-protobuf"; export namespace tccGraphicData { - export enum TccElementColor { - green = 0, - red = 1 - } export class TccGraphicStorage extends pb_1.Message { #one_of_decls: number[][] = []; constructor(data?: any[] | { canvas?: dependency_1.graphicData.Canvas; tccButtons?: TccButton[]; tccTexts?: TccText[]; + tccKeys?: TccKey[]; + tccHandles?: TccHandle[]; }) { super(); - pb_1.Message.initialize(this, Array.isArray(data) ? data : [], 0, -1, [2, 3], this.#one_of_decls); + pb_1.Message.initialize(this, Array.isArray(data) ? data : [], 0, -1, [2, 3, 4, 5], this.#one_of_decls); if (!Array.isArray(data) && typeof data == "object") { if ("canvas" in data && data.canvas != undefined) { this.canvas = data.canvas; @@ -29,6 +27,12 @@ export namespace tccGraphicData { if ("tccTexts" in data && data.tccTexts != undefined) { this.tccTexts = data.tccTexts; } + if ("tccKeys" in data && data.tccKeys != undefined) { + this.tccKeys = data.tccKeys; + } + if ("tccHandles" in data && data.tccHandles != undefined) { + this.tccHandles = data.tccHandles; + } } } get canvas() { @@ -52,10 +56,24 @@ export namespace tccGraphicData { set tccTexts(value: TccText[]) { pb_1.Message.setRepeatedWrapperField(this, 3, value); } + get tccKeys() { + return pb_1.Message.getRepeatedWrapperField(this, TccKey, 4) as TccKey[]; + } + set tccKeys(value: TccKey[]) { + pb_1.Message.setRepeatedWrapperField(this, 4, value); + } + get tccHandles() { + return pb_1.Message.getRepeatedWrapperField(this, TccHandle, 5) as TccHandle[]; + } + set tccHandles(value: TccHandle[]) { + pb_1.Message.setRepeatedWrapperField(this, 5, value); + } static fromObject(data: { canvas?: ReturnType; tccButtons?: ReturnType[]; tccTexts?: ReturnType[]; + tccKeys?: ReturnType[]; + tccHandles?: ReturnType[]; }): TccGraphicStorage { const message = new TccGraphicStorage({}); if (data.canvas != null) { @@ -67,6 +85,12 @@ export namespace tccGraphicData { if (data.tccTexts != null) { message.tccTexts = data.tccTexts.map(item => TccText.fromObject(item)); } + if (data.tccKeys != null) { + message.tccKeys = data.tccKeys.map(item => TccKey.fromObject(item)); + } + if (data.tccHandles != null) { + message.tccHandles = data.tccHandles.map(item => TccHandle.fromObject(item)); + } return message; } toObject() { @@ -74,6 +98,8 @@ export namespace tccGraphicData { canvas?: ReturnType; tccButtons?: ReturnType[]; tccTexts?: ReturnType[]; + tccKeys?: ReturnType[]; + tccHandles?: ReturnType[]; } = {}; if (this.canvas != null) { data.canvas = this.canvas.toObject(); @@ -84,6 +110,12 @@ export namespace tccGraphicData { if (this.tccTexts != null) { data.tccTexts = this.tccTexts.map((item: TccText) => item.toObject()); } + if (this.tccKeys != null) { + data.tccKeys = this.tccKeys.map((item: TccKey) => item.toObject()); + } + if (this.tccHandles != null) { + data.tccHandles = this.tccHandles.map((item: TccHandle) => item.toObject()); + } return data; } serialize(): Uint8Array; @@ -96,6 +128,10 @@ export namespace tccGraphicData { writer.writeRepeatedMessage(2, this.tccButtons, (item: TccButton) => item.serialize(writer)); if (this.tccTexts.length) writer.writeRepeatedMessage(3, this.tccTexts, (item: TccText) => item.serialize(writer)); + if (this.tccKeys.length) + writer.writeRepeatedMessage(4, this.tccKeys, (item: TccKey) => item.serialize(writer)); + if (this.tccHandles.length) + writer.writeRepeatedMessage(5, this.tccHandles, (item: TccHandle) => item.serialize(writer)); if (!w) return writer.getResultBuffer(); } @@ -114,6 +150,12 @@ export namespace tccGraphicData { case 3: reader.readMessage(message.tccTexts, () => pb_1.Message.addToRepeatedWrapperField(message, 3, TccText.deserialize(reader), TccText)); break; + case 4: + reader.readMessage(message.tccKeys, () => pb_1.Message.addToRepeatedWrapperField(message, 4, TccKey.deserialize(reader), TccKey)); + break; + case 5: + reader.readMessage(message.tccHandles, () => pb_1.Message.addToRepeatedWrapperField(message, 5, TccHandle.deserialize(reader), TccHandle)); + break; default: reader.skipField(); } } @@ -131,7 +173,6 @@ export namespace tccGraphicData { constructor(data?: any[] | { common?: dependency_1.graphicData.CommonInfo; code?: string; - buttonColor?: TccElementColor; isSelfReset?: boolean; }) { super(); @@ -143,9 +184,6 @@ export namespace tccGraphicData { if ("code" in data && data.code != undefined) { this.code = data.code; } - if ("buttonColor" in data && data.buttonColor != undefined) { - this.buttonColor = data.buttonColor; - } if ("isSelfReset" in data && data.isSelfReset != undefined) { this.isSelfReset = data.isSelfReset; } @@ -166,22 +204,15 @@ export namespace tccGraphicData { set code(value: string) { pb_1.Message.setField(this, 2, value); } - get buttonColor() { - return pb_1.Message.getFieldWithDefault(this, 3, TccElementColor.green) as TccElementColor; - } - set buttonColor(value: TccElementColor) { - pb_1.Message.setField(this, 3, value); - } get isSelfReset() { - return pb_1.Message.getFieldWithDefault(this, 4, false) as boolean; + return pb_1.Message.getFieldWithDefault(this, 3, false) as boolean; } set isSelfReset(value: boolean) { - pb_1.Message.setField(this, 4, value); + pb_1.Message.setField(this, 3, value); } static fromObject(data: { common?: ReturnType; code?: string; - buttonColor?: TccElementColor; isSelfReset?: boolean; }): TccButton { const message = new TccButton({}); @@ -191,9 +222,6 @@ export namespace tccGraphicData { if (data.code != null) { message.code = data.code; } - if (data.buttonColor != null) { - message.buttonColor = data.buttonColor; - } if (data.isSelfReset != null) { message.isSelfReset = data.isSelfReset; } @@ -203,7 +231,6 @@ export namespace tccGraphicData { const data: { common?: ReturnType; code?: string; - buttonColor?: TccElementColor; isSelfReset?: boolean; } = {}; if (this.common != null) { @@ -212,9 +239,6 @@ export namespace tccGraphicData { if (this.code != null) { data.code = this.code; } - if (this.buttonColor != null) { - data.buttonColor = this.buttonColor; - } if (this.isSelfReset != null) { data.isSelfReset = this.isSelfReset; } @@ -228,10 +252,8 @@ export namespace tccGraphicData { writer.writeMessage(1, this.common, () => this.common.serialize(writer)); if (this.code.length) writer.writeString(2, this.code); - if (this.buttonColor != TccElementColor.green) - writer.writeEnum(3, this.buttonColor); if (this.isSelfReset != false) - writer.writeBool(4, this.isSelfReset); + writer.writeBool(3, this.isSelfReset); if (!w) return writer.getResultBuffer(); } @@ -248,9 +270,6 @@ export namespace tccGraphicData { message.code = reader.readString(); break; case 3: - message.buttonColor = reader.readEnum(); - break; - case 4: message.isSelfReset = reader.readBool(); break; default: reader.skipField(); @@ -427,4 +446,219 @@ export namespace tccGraphicData { return TccText.deserialize(bytes); } } + export class TccKey extends pb_1.Message { + #one_of_decls: number[][] = []; + constructor(data?: any[] | { + common?: dependency_1.graphicData.CommonInfo; + code?: string; + type?: TccKey.TccKeyType; + }) { + 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 ("type" in data && data.type != undefined) { + this.type = data.type; + } + } + } + get common() { + return pb_1.Message.getWrapperField(this, dependency_1.graphicData.CommonInfo, 1) as dependency_1.graphicData.CommonInfo; + } + set common(value: dependency_1.graphicData.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 type() { + return pb_1.Message.getFieldWithDefault(this, 3, TccKey.TccKeyType.driverControllerActivationClint) as TccKey.TccKeyType; + } + set type(value: TccKey.TccKeyType) { + pb_1.Message.setField(this, 3, value); + } + static fromObject(data: { + common?: ReturnType; + code?: string; + type?: TccKey.TccKeyType; + }): TccKey { + const message = new TccKey({}); + if (data.common != null) { + message.common = dependency_1.graphicData.CommonInfo.fromObject(data.common); + } + if (data.code != null) { + message.code = data.code; + } + if (data.type != null) { + message.type = data.type; + } + return message; + } + toObject() { + const data: { + common?: ReturnType; + code?: string; + type?: TccKey.TccKeyType; + } = {}; + if (this.common != null) { + data.common = this.common.toObject(); + } + if (this.code != null) { + data.code = this.code; + } + if (this.type != null) { + data.type = this.type; + } + 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.type != TccKey.TccKeyType.driverControllerActivationClint) + writer.writeEnum(3, this.type); + if (!w) + return writer.getResultBuffer(); + } + static deserialize(bytes: Uint8Array | pb_1.BinaryReader): TccKey { + const reader = bytes instanceof pb_1.BinaryReader ? bytes : new pb_1.BinaryReader(bytes), message = new TccKey(); + while (reader.nextField()) { + if (reader.isEndGroup()) + break; + switch (reader.getFieldNumber()) { + case 1: + reader.readMessage(message.common, () => message.common = dependency_1.graphicData.CommonInfo.deserialize(reader)); + break; + case 2: + message.code = reader.readString(); + break; + case 3: + message.type = reader.readEnum(); + break; + default: reader.skipField(); + } + } + return message; + } + serializeBinary(): Uint8Array { + return this.serialize(); + } + static deserializeBinary(bytes: Uint8Array): TccKey { + return TccKey.deserialize(bytes); + } + } + export namespace TccKey { + export enum TccKeyType { + driverControllerActivationClint = 0, + frontAndRearDirectionalControl = 1 + } + } + export class TccHandle extends pb_1.Message { + #one_of_decls: number[][] = []; + constructor(data?: any[] | { + common?: dependency_1.graphicData.CommonInfo; + code?: 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; + } + } + } + get common() { + return pb_1.Message.getWrapperField(this, dependency_1.graphicData.CommonInfo, 1) as dependency_1.graphicData.CommonInfo; + } + set common(value: dependency_1.graphicData.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); + } + static fromObject(data: { + common?: ReturnType; + code?: string; + }): TccHandle { + const message = new TccHandle({}); + if (data.common != null) { + message.common = dependency_1.graphicData.CommonInfo.fromObject(data.common); + } + if (data.code != null) { + message.code = data.code; + } + return message; + } + toObject() { + const data: { + common?: ReturnType; + code?: string; + } = {}; + if (this.common != null) { + data.common = this.common.toObject(); + } + if (this.code != null) { + data.code = this.code; + } + 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 (!w) + return writer.getResultBuffer(); + } + static deserialize(bytes: Uint8Array | pb_1.BinaryReader): TccHandle { + const reader = bytes instanceof pb_1.BinaryReader ? bytes : new pb_1.BinaryReader(bytes), message = new TccHandle(); + while (reader.nextField()) { + if (reader.isEndGroup()) + break; + switch (reader.getFieldNumber()) { + case 1: + reader.readMessage(message.common, () => message.common = dependency_1.graphicData.CommonInfo.deserialize(reader)); + break; + case 2: + message.code = reader.readString(); + break; + default: reader.skipField(); + } + } + return message; + } + serializeBinary(): Uint8Array { + return this.serialize(); + } + static deserializeBinary(bytes: Uint8Array): TccHandle { + return TccHandle.deserialize(bytes); + } + } }