platfrom presentation

ant-design-pro-vue3/src/views/front/platfrom/presentation/FocusCheck/Adorner/FocusAdorner.ts

@@ -0,0 +1,130 @@
+// 模拟依赖属性和相关类型
+class DependencyProperty {
+    static Register(name: string, type: any, ownerType: any, metadata: any) {
+        return new DependencyProperty();
+    }
+}
+
+class FrameworkPropertyMetadata {
+    constructor(defaultValue: any) { }
+}
+
+class Brush { }
+class SolidColorBrush extends Brush { }
+class Pen {
+    constructor(brush: Brush, thickness: number) { }
+}
+class Colors {
+    static get Red() { return new SolidColorBrush(); }
+}
+
+class UIElement {
+    IsVisible: boolean = true;
+}
+
+class FrameworkElement extends UIElement {
+    RenderSize = { width: 0, height: 0 };
+}
+
+class DrawingContext {
+    constructor(private canvasContext: CanvasRenderingContext2D) { }
+
+    DrawLine(pen: Pen, startPoint: { x: number, y: number }, endPoint: { x: number, y: number }) {
+        this.canvasContext.beginPath();
+        this.canvasContext.moveTo(startPoint.x, startPoint.y);
+        this.canvasContext.lineTo(endPoint.x, endPoint.y);
+        this.canvasContext.stroke();
+    }
+}
+
+class Rect {
+    constructor(public size: { width: number, height: number }) { }//TODO 将height由0改为number
+
+    get TopLeft() { return { x: 0, y: 0 }; }
+    get TopRight() { return { x: this.size.width, y: 0 }; }
+    get BottomLeft() { return { x: 0, y: this.size.height }; }
+    get BottomRight() { return { x: this.size.width, y: this.size.height }; }
+}
+
+class Point {
+    constructor(public x: number, public y: number) { }
+}
+
+class Application {
+    static get Current() {
+        return {
+            TryFindResource(name: string) {
+                return null;
+            }
+        };
+    }
+}
+
+class Adorner {
+    constructor(public AdornedElement: FrameworkElement) { }
+    InvalidateVisual() { }
+}
+
+class FocusAdorner extends Adorner {
+    static FocusAdornerPen: Pen;
+
+    static BorderBrushProperty = DependencyProperty.Register("BorderBrush", Brush, FocusAdorner, new FrameworkPropertyMetadata(new SolidColorBrush()));
+    static BorderThicknessProperty = DependencyProperty.Register("BorderThickness", Number, FocusAdorner, new FrameworkPropertyMetadata(2));
+
+    get BorderBrush() { return null; }
+    set BorderBrush(value: Brush) { }
+
+    get BorderThickness() { return 2; }
+    set BorderThickness(value: number) { }
+
+    private _close: () => void;
+
+    constructor(adornedElement: FrameworkElement, private canvasContext: CanvasRenderingContext2D) {
+        super(adornedElement);
+        const dpd = {
+            AddValueChanged: (element: UIElement, handler: () => void) => { },
+            RemoveValueChanged: (element: UIElement, handler: () => void) => { }
+        };
+        const handler = () => {
+            this.InvalidateVisual();
+        };
+        dpd.AddValueChanged(adornedElement, handler);
+        this._close = () => {
+            dpd.RemoveValueChanged(adornedElement, handler);
+        };
+    }
+
+    static {
+        FocusAdorner.FocusAdornerPen = Application.Current.TryFindResource("FocusAdorner_Normal_Pen") as Pen;
+        if (!FocusAdorner.FocusAdornerPen) {
+            FocusAdorner.FocusAdornerPen = new Pen(new SolidColorBrush(), 1.0);
+        }
+    }
+
+    Close() {
+        this._close();
+    }
+
+    InvalidateVisual() {
+        const drawingContext = new DrawingContext(this.canvasContext);
+        this.OnRender(drawingContext);
+    }
+
+    protected OnRender(drawingContext: DrawingContext) {
+        if (!this.AdornedElement || !this.AdornedElement.IsVisible) return;
+
+        const adornedElementRect = new Rect(this.AdornedElement.RenderSize);
+
+        drawingContext.DrawLine(FocusAdorner.FocusAdornerPen, new Point(adornedElementRect.TopLeft.x - 3, adornedElementRect.TopLeft.y - 3), new Point(adornedElementRect.TopLeft.x + 5, adornedElementRect.TopLeft.y - 3));
+        drawingContext.DrawLine(FocusAdorner.FocusAdornerPen, new Point(adornedElementRect.TopLeft.x - 3, adornedElementRect.TopLeft.y - 3), new Point(adornedElementRect.TopLeft.x - 3, adornedElementRect.TopLeft.y + 5));
+
+        drawingContext.DrawLine(FocusAdorner.FocusAdornerPen, new Point(adornedElementRect.TopRight.x + 3, adornedElementRect.TopRight.y - 3), new Point(adornedElementRect.TopRight.x - 5, adornedElementRect.TopRight.y - 3));
+        drawingContext.DrawLine(FocusAdorner.FocusAdornerPen, new Point(adornedElementRect.TopRight.x + 3, adornedElementRect.TopRight.y - 3), new Point(adornedElementRect.TopRight.x + 3, adornedElementRect.TopRight.y + 5));
+
+        drawingContext.DrawLine(FocusAdorner.FocusAdornerPen, new Point(adornedElementRect.BottomLeft.x - 3, adornedElementRect.BottomLeft.y + 3), new Point(adornedElementRect.BottomLeft.x + 5, adornedElementRect.BottomLeft.y + 3));
+        drawingContext.DrawLine(FocusAdorner.FocusAdornerPen, new Point(adornedElementRect.BottomLeft.x - 3, adornedElementRect.BottomLeft.y + 3), new Point(adornedElementRect.BottomLeft.x - 3, adornedElementRect.BottomLeft.y - 5));
+
+        drawingContext.DrawLine(FocusAdorner.FocusAdornerPen, new Point(adornedElementRect.BottomRight.x + 3, adornedElementRect.BottomRight.y + 3), new Point(adornedElementRect.BottomRight.x - 5, adornedElementRect.BottomRight.y + 3));
+        drawingContext.DrawLine(FocusAdorner.FocusAdornerPen, new Point(adornedElementRect.BottomRight.x + 3, adornedElementRect.BottomRight.y + 3), new Point(adornedElementRect.BottomRight.x + 3, adornedElementRect.BottomRight.y - 5));
+    }
+}

ant-design-pro-vue3/src/views/front/platfrom/presentation/FocusCheck/Adorner/TipAdorner.ts

@@ -0,0 +1,71 @@
+// 定义枚举
+export enum TipAdornerPlacement {
+    Bottom,
+    Right,
+}
+
+// 定义 TipAdorner 类
+export class TipAdorner {
+    private messageHost: HTMLElement;
+    private adornedElement: HTMLElement;
+    private adornerLayer: HTMLElement;
+    private message: string;
+    private messageTemplate: string | null = null;
+    private placement: TipAdornerPlacement = TipAdornerPlacement.Bottom;
+
+    constructor(adornedElement: HTMLElement, adornerLayer: HTMLElement) {
+        this.adornedElement = adornedElement;
+        this.adornerLayer = adornerLayer;
+        this.messageHost = document.createElement('div');
+        this.adornerLayer.appendChild(this.messageHost);
+    }
+
+    public set Message(value: string) {
+        this.message = value;
+        this.messageHost.textContent = value;
+    }
+
+    public get Message(): string {
+        return this.message;
+    }
+
+    public set MessageTemplate(value: string | null) {
+        this.messageTemplate = value;
+        if (value) {
+            this.messageHost.innerHTML = value;
+        }
+    }
+
+    public get MessageTemplate(): string | null {
+        return this.messageTemplate;
+    }
+
+    public set Placement(value: TipAdornerPlacement) {
+        this.placement = value;
+        this.arrange();
+    }
+
+    public get Placement(): TipAdornerPlacement {
+        return this.placement;
+    }
+
+    private arrange() {
+        const adornedRect = this.adornedElement.getBoundingClientRect();
+        const messageHostRect = this.messageHost.getBoundingClientRect();
+
+        let x = 0;
+        let y = 0;
+
+        if (this.placement === TipAdornerPlacement.Right) {
+            x = adornedRect.right;
+            y = adornedRect.top;
+        } else {
+            x = adornedRect.left;
+            y = adornedRect.bottom;
+        }
+
+        this.messageHost.style.position = 'absolute';
+        this.messageHost.style.left = `${x}px`;
+        this.messageHost.style.top = `${y}px`;
+    }
+}

ant-design-pro-vue3/src/views/front/platfrom/presentation/FocusCheck/FieldPolicy/FieldPolicyCollection.ts

@@ -0,0 +1,24 @@
+// 假设 IFieldPolicy 接口的基本结构
+export interface IFieldPolicy {
+    // 这里可以根据实际情况添加更多属性和方法
+}
+
+// 实现 FieldPolicyCollection 类
+export class FieldPolicyCollection {
+    private items: IFieldPolicy[] = [];
+
+    // 添加元素到集合
+    add(item: IFieldPolicy): void {
+        this.items.push(item);
+    }
+
+    // 获取集合中元素的数量
+    get count(): number {
+        return this.items.length;
+    }
+
+    // 根据索引获取元素
+    getItem(index: number): IFieldPolicy | undefined {
+        return this.items[index];
+    }
+}

ant-design-pro-vue3/src/views/front/platfrom/presentation/FocusCheck/FieldPolicy/IFieldPolicy.ts

@@ -0,0 +1,17 @@
+// 模拟 ICloneable 接口
+interface ICloneable {
+    clone(): any;
+}
+
+// 定义一个通用的对象类型，模拟 DependencyObject
+type DependencyObject = Record<string, any>;
+
+// 定义 IFieldPolicy 接口
+export interface IFieldPolicy extends ICloneable {
+    /**
+     * 执行校验策略
+     * @param sender 触发操作的对象
+     * @param content 与校验相关的内容
+     */
+    Run(sender: DependencyObject, content: any): void;
+}

ant-design-pro-vue3/src/views/front/platfrom/presentation/FocusCheck/FieldPolicy/ShowTipPolicy.ts

@@ -0,0 +1,93 @@
+// 模拟 IFieldPolicy 接口
+interface IFieldPolicy {
+    Run(sender: HTMLElement, content: any): void;
+    Clone(): any;
+}
+
+// 模拟 TipAdornerPlacement 类型
+type TipAdornerPlacement = string;
+
+// 模拟 TipAdorner 类
+class TipAdorner {
+    Placement: TipAdornerPlacement;
+    Message: string;
+    element: HTMLElement;
+
+    constructor(element: HTMLElement, _adornerLayer: any) {
+        this.element = element;
+    }
+}
+
+// 模拟 AdornerLayer 类
+class AdornerLayer {
+    private adorners: any[] = [];
+
+    static GetAdornerLayer(element: HTMLElement): AdornerLayer {
+        return new AdornerLayer();
+    }
+
+    GetAdorners(element: HTMLElement): any[] {
+        return this.adorners.filter(ad => ad.element === element);
+    }
+
+    Add(adorner: any) {
+        this.adorners.push(adorner);
+    }
+
+    Remove(adorner: any) {
+        const index = this.adorners.indexOf(adorner);
+        if (index !== -1) {
+            this.adorners.splice(index, 1);
+        }
+    }
+}
+
+export class ShowTipPolicy implements IFieldPolicy {
+    private _adorner: TipAdorner | null = null;
+    Placement: TipAdornerPlacement;
+
+    Run(sender: HTMLElement, content: any): void {
+        const element = sender;
+        if (!element) return;
+
+        const adornerLayer = AdornerLayer.GetAdornerLayer(element);
+        if (adornerLayer) {
+            const adorners = adornerLayer.GetAdorners(element);
+            if (adorners) {
+                adorners.forEach(ad => {
+                    if (ad instanceof TipAdorner) {
+                        adornerLayer.Remove(ad);
+                    }
+                });
+            }
+
+            this._adorner = new TipAdorner(element, adornerLayer);
+            this._adorner.Placement = this.Placement;
+            this._adorner.Message = content === null ? "输入错误" : content.toString();
+            adornerLayer.Add(this._adorner);
+
+            element.addEventListener('blur', this.OnLostFocus.bind(this));
+
+            if (element.tagName === 'INPUT') {// && element.type === 'text' TODO报错暂时注掉
+                (element as HTMLInputElement).select();
+            }
+        }
+    }
+
+    private OnLostFocus(e: Event) {
+        const element = e.target as HTMLElement;
+        if (!element) return;
+
+        element.removeEventListener('blur', this.OnLostFocus.bind(this));
+
+        const adornerLayer = AdornerLayer.GetAdornerLayer(element);
+        if (!adornerLayer || !this._adorner) return;
+
+        adornerLayer.Remove(this._adorner);
+        this._adorner = null;
+    }
+
+    Clone(): any {
+        throw new Error('方法未实现');
+    }
+}

ant-design-pro-vue3/src/views/front/platfrom/presentation/FocusManagers/FocusList.ts

@@ -0,0 +1,183 @@
+// 模拟 WPF 相关类
+class FrameworkElement {
+    visibility: 'Visible' | 'Hidden' | 'Collapsed' = 'Visible';
+    actualHeight: number = 0;
+    actualWidth: number = 0;
+    tabIndex: number = 0;
+
+    constructor(public x: number, public y: number) { }
+
+    translatePoint(point: { x: number, y: number }, root: FrameworkElement): { x: number, y: number } {
+        return { x: this.x + point.x, y: this.y + point.y };
+    }
+}
+
+class ScrollViewer extends FrameworkElement { }
+
+// 模拟 Platform.Common 中的方法
+class VisualTreeHelper {
+    static getChildrenCount(element: FrameworkElement): number {
+        // 模拟实现，实际需要根据具体情况实现
+        return 0;
+    }
+
+    static getChild(element: FrameworkElement, index: number): FrameworkElement | null {
+        // 模拟实现，实际需要根据具体情况实现
+        return null;
+    }
+}
+
+class FocusManager {
+    static getOnlyMouseControlHandled(element: FrameworkElement): any | null {
+        // 模拟实现，实际需要根据具体情况实现
+        return null;
+    }
+
+    static getIsInternalKeyboardControlling(element: FrameworkElement): boolean {
+        // 模拟实现，实际需要根据具体情况实现
+        return true;
+    }
+}
+
+// 扩展 FrameworkElement 类以模拟 FindVisualTreeAncestor 方法
+interface FrameworkElement {
+    findVisualTreeAncestor(handle: (element: any) => boolean): any | null;
+}
+
+FrameworkElement.prototype.findVisualTreeAncestor = function (handle: (element: any) => boolean): any | null {
+    let current: any = this;
+    while (current) {
+        if (handle(current)) {
+            return current;
+        }
+        // 模拟父元素，实际需要根据具体情况实现
+        current = null;
+    }
+    return null;
+};
+
+export default class FocusList implements Iterable<FrameworkElement> {
+    private _internalList: FrameworkElement[] = [];
+    private _rootElement: FrameworkElement;
+    private stackOperatorVisible: FrameworkElement[] = [];
+
+    private constructor(rootElement: FrameworkElement) {
+        this._rootElement = rootElement;
+        this.refresh();
+    }
+
+    static create(rootElement: FrameworkElement): FocusList {
+        return new FocusList(rootElement);
+    }
+
+    private compareByLocation(targetElement: FrameworkElement, currentElement: FrameworkElement): boolean {
+        const handle = (x: any) => x instanceof ScrollViewer;
+        const targetScrollViewer = targetElement.findVisualTreeAncestor(handle) as ScrollViewer | null;
+        const currentScrollViewer = currentElement.findVisualTreeAncestor(handle) as ScrollViewer | null;
+
+        if (targetScrollViewer && currentScrollViewer && targetScrollViewer !== currentScrollViewer) {
+            if (true) {//TODD焦点的控制涉及到FrameworkElement targetScrollViewer.isAncestorOf(currentScrollViewer) 缺少方法isAncestorOf
+                currentElement = currentScrollViewer;
+            } else {
+                targetElement = targetScrollViewer;
+            }
+        } else if (!targetScrollViewer || !currentScrollViewer || targetScrollViewer !== currentScrollViewer) {
+            if (targetScrollViewer) targetElement = targetScrollViewer;
+            if (currentScrollViewer) currentElement = currentScrollViewer;
+        }
+
+        const locationPoint = { x: 0, y: 0 };
+        const targetElementOffset = targetElement.translatePoint(locationPoint, this._rootElement);
+        const currentElementOffset = currentElement.translatePoint(locationPoint, this._rootElement);
+
+        if (targetElementOffset.y + targetElement.actualHeight <= currentElementOffset.y + currentElement.actualHeight / 2) {
+            return true;
+        }
+
+        return targetElementOffset.x <= currentElementOffset.x &&
+            targetElementOffset.y <= currentElementOffset.y + currentElement.actualHeight / 2;
+    }
+
+    private getFocusChildren(rootElement: FrameworkElement) {
+        if (!rootElement) return;
+
+        if (rootElement.visibility === 'Collapsed') {
+            this.stackOperatorVisible.push(rootElement);
+            rootElement.visibility = 'Hidden';
+            // 模拟 UpdateLayout 方法
+            // rootElement.updateLayout();
+        }
+
+        const childrenCount = VisualTreeHelper.getChildrenCount(rootElement);
+        for (let i = 0; i < childrenCount; i++) {
+            const child = VisualTreeHelper.getChild(rootElement, i) as FrameworkElement | null;
+            if (!child) continue;
+
+            if (FocusManager.getOnlyMouseControlHandled(child) !== null) continue;
+
+            if (!FocusManager.getIsInternalKeyboardControlling(child)) {
+                this.getFocusChildren(child);
+            } else {
+                if (child.visibility === 'Collapsed') {
+                    this.stackOperatorVisible.push(child);
+                    child.visibility = 'Visible';
+                    // 模拟 UpdateLayout 方法
+                    // rootElement.updateLayout();
+                }
+
+                const insertIndex = this.getInsertIndex(child);
+                this._internalList.splice(insertIndex, 0, child);
+            }
+        }
+    }
+
+    private getInsertIndex(targetElement: FrameworkElement): number {
+        let currentIndex = this._internalList.length - 1;
+
+        while (currentIndex > -1) {
+            const currentElement = this._internalList[currentIndex];
+            if (targetElement.tabIndex === currentElement.tabIndex) {
+                if (!this.compareByLocation(targetElement, currentElement)) {
+                    return currentIndex + 1;
+                }
+            } else if (targetElement.tabIndex > currentElement.tabIndex) {
+                return currentIndex + 1;
+            } else if (!this.compareByLocation(targetElement, currentElement)) {
+                return currentIndex + 1;
+            }
+            currentIndex--;
+        }
+        return currentIndex > -1 ? currentIndex : 0;
+    }
+
+    refresh() {
+        // 模拟 IsVisible 和 IsLoaded 属性
+        if (true) {
+            this._internalList = [];
+            this.stackOperatorVisible = [];
+            this.getFocusChildren(this._rootElement);
+
+            this.stackOperatorVisible.forEach((current) => {
+                current.visibility = 'Collapsed';
+            });
+        }
+    }
+
+    get count(): number {
+        return this._internalList.length;
+    }
+
+    get(index: number): FrameworkElement {
+        return this._internalList[index];
+    }
+
+    indexOf(element: FrameworkElement): number {
+        return this._internalList.indexOf(element);
+    }
+
+    [Symbol.iterator](): Iterator<FrameworkElement> {
+        return this._internalList[Symbol.iterator]();
+    }
+}
+
+export { FocusList, FrameworkElement };

ant-design-pro-vue3/src/views/front/platfrom/presentation/FocusManagers/FocusManager.ts

@@ -0,0 +1,575 @@
+
+import FocusList from "./FocusList";
+
+// 模拟 WPF 部分类型
+interface DependencyObject {
+    // 可根据实际情况添加更多属性和方法
+}
+//微软系统框架 需要重新实现TODO
+interface FrameworkElement extends DependencyObject {
+    // Focus(): boolean;
+    // IsEnabled: boolean;
+    // IsVisible: boolean;
+    // Focusable: boolean;
+    // 可根据实际情况添加更多属性和方法
+}
+
+interface RoutedEventArgs {
+    Handled: boolean;
+    Source: any;
+    OriginalSource: any;
+}
+
+interface KeyEventArgs extends RoutedEventArgs {
+    Key: string;
+}
+
+interface MouseEventArgs extends RoutedEventArgs {
+    // 可根据实际情况添加更多属性和方法
+}
+
+// 模拟自定义类型
+
+
+interface FocusAdorner {
+    Close(): void;
+}
+
+interface AdornerLayer {
+    Remove(adorner: FocusAdorner): void;
+    Add(adorner: FocusAdorner): void;
+}
+
+interface TradePage extends FrameworkElement {
+    Ready: (sender: any, e: any) => void;
+}
+
+
+enum FocusNavigation {
+    Top,
+    Backward,
+    Forward
+}
+
+enum FocusHandledResult {
+    Self,
+    Forward,
+    Backward,
+    System
+}
+
+// 模拟附加属性存储
+const attachedProperties = new WeakMap<DependencyObject, { [key: string]: any }>();
+
+function getAttachedProperty(obj: DependencyObject, propertyName: string): any {
+    const props = attachedProperties.get(obj);
+    return props ? props[propertyName] : undefined;
+}
+
+function setAttachedProperty(obj: DependencyObject, propertyName: string, value: any) {
+    let props = attachedProperties.get(obj);
+    if (!props) {
+        props = {};
+        attachedProperties.set(obj, props);
+    }
+    props[propertyName] = value;
+}
+
+export default class FocusManager {
+    private _preAdorder: FocusAdorner | null = null;
+    private _focusAdornerLayer: AdornerLayer | null = null;
+    public IsFocusContinue: boolean = false;
+    private readonly _target: FrameworkElement;
+    public _focusList: FocusList | null = null;
+    private _currentFocusedElement: FrameworkElement | null = null;
+    private static readonly DEFAULT_BUTTON_CLICK_TICK_OUT = -1;
+    private _canAcceptUserInput = true;
+    private _isOperator = false;
+
+    get CurrentFocusedElement(): FrameworkElement | null {
+        return this._currentFocusedElement;
+    }
+
+    private set CurrentFocusedElement(value: FrameworkElement | null) {
+        if (value) {
+            if (!this._focusAdornerLayer) {
+                // 模拟获取装饰器层
+                this._focusAdornerLayer = {} as AdornerLayer;
+            }
+
+            if (this._preAdorder) {
+                this._focusAdornerLayer.Remove(this._preAdorder);
+                this._preAdorder.Close();
+            }
+
+            if (getAttachedProperty(value, "IsFocusAdorner")) {
+                this._preAdorder = {} as FocusAdorner;
+                this._focusAdornerLayer.Add(this._preAdorder);
+            }
+        }
+        if (this._currentFocusedElement !== value) {
+            this._currentFocusedElement = value;
+        }
+    }
+
+    get CanAcceptUserInput(): boolean {
+        return this._canAcceptUserInput;
+    }
+
+    set CanAcceptUserInput(value: boolean) {
+        this._canAcceptUserInput = value;
+    }
+
+    set CanFocusAdjustly(value: boolean) {
+        // 模拟移除和添加事件处理程序
+        if (!value) {
+            // 移除 LayoutUpdated 事件处理程序
+        } else {
+            // 添加 LayoutUpdated 事件处理程序
+        }
+    }
+
+    private constructor(target: FrameworkElement) {
+        this._target = target;
+        // 模拟 IsVisibleChanged 事件
+        // target.IsVisibleChanged += (sender, e) => { ... };
+    }
+
+    get IsOperator(): boolean {
+        if (this._isOperator) return this._isOperator;
+
+        if (FocusList && this._currentFocusedElement) {
+            // const ind = this._focusList.indexOf(this._currentFocusedElement | null);//FrameworkElement内容需要改
+            // if (ind === 0 && this._currentFocusedElement instanceof TextBox) {
+            //     const txt = this._currentFocusedElement as TextBox;
+            //     this._isOperator = txt.Text.length !== 0;
+            // }
+        }
+
+        return this._isOperator;
+    }
+
+    // 附加属性相关方法
+    static GetCanSkipPreviousFocus(d: DependencyObject): boolean {
+        return getAttachedProperty(d, "CanSkipPreviousFocus") || false;
+    }
+
+    static SetCanSkipPreviousFocus(d: DependencyObject, value: boolean) {
+        setAttachedProperty(d, "CanSkipPreviousFocus", value);
+    }
+
+    // 其他附加属性方法类似实现...
+
+    private Registe() {
+        const tmp = this._target as TradePage;
+        if (tmp) {
+            // tmp.Ready += this._target_Ready.bind(this);
+        }
+
+        // 模拟注册事件
+        // this._target.PreviewKeyDown += this.OnPreviewKeyDown.bind(this);
+        // this._target.PreviewMouseDown += this.OnPreviewMouseDown.bind(this);
+        // this._target.LayoutUpdated += this._target_LayoutUpdated.bind(this);
+    }
+
+    private _target_Ready(sender: any, e: any) {
+        const tmp = this._target as TradePage;
+        if (tmp) {
+            // tmp.Ready -= this._target_Ready.bind(this);
+        }
+
+        // this._focusList = FocusList.create(this._target);//TODO FrameworkElement 焦点控制先注释
+
+        if (!this._focusAdornerLayer) {
+            this._focusAdornerLayer = {} as AdornerLayer;
+        }
+
+        if (this._focusList) {
+            // for (let i = 0; i < this._focusList.Count; i++) {
+            //     const item = this._focusList[i];
+            //     // FocusManager.SetManagerInstance(item, this);
+            // }
+        }
+
+        this.ReSetFocus();
+    }
+
+    private _target_LayoutUpdated(sender: any, e: any) {
+        // 模拟获取窗口
+        const win = null;
+        if (!win || !win.IsActive) return;
+
+        if (this._currentFocusedElement && (getAttachedProperty(this._target, "AutoFocus"))) {
+            this.CurrentFocusedElement = this._currentFocusedElement;
+        }
+        //TODO  || this._target.IsMouseOver) &&!this._target.IsKeyboardFocusWithin && this._currentFocusedElement.Focus() //TODO 没有FrameworkElement IsMouseOver方法
+        // if (this._currentFocusedElement &&
+        //     this._currentFocusedElement.IsFocused &&
+        //     !this.IsEnableFocus(this._currentFocusedElement) &&
+        //     !this._currentFocusedElement.IsEnabled &&
+        //     this._currentFocusedElement.IsVisible) {
+        //     this.CurrentFocusedElement = this._currentFocusedElement;
+        //     this.MoveFocusHost(FocusNavigation.Forward);
+        // }
+    }
+
+    private UnRegiste() {
+        // 模拟移除事件处理程序
+        // this._target.PreviewKeyDown -= this.OnPreviewKeyDown.bind(this);
+        // this._target.PreviewMouseDown -= this.OnPreviewMouseDown.bind(this);
+        // this._target.LayoutUpdated -= this._target_LayoutUpdated.bind(this);
+
+        // FocusManager.SetManagerInstance(this._target, null);
+    }
+
+    public ReSetFocus() {
+        this.MoveFocusHost(FocusNavigation.Top);
+    }
+
+    public SetFocus(target: FrameworkElement) {
+        if (!target) throw new Error("element 不能为 null");
+        //TODD焦点的控制涉及到FrameworkElement
+        // // 模拟 UIInvoke
+        // if (this._currentFocusedElement !== target &&
+        //     this.RaiseFocusManagerEvent(target, "PreviewGotFocusEvent") &&
+        //     this.RaiseFocusManagerEvent(target, "GotFocusEvent") &&
+        //     target.Focus()) {
+        //     this.CurrentFocusedElement = target;
+        // } else if (this._currentFocusedElement) {
+        //     this._currentFocusedElement.Focus();
+        // } else {
+        //     this.ReSetFocus();
+        // }
+    }
+
+    public MoveFocus(navigation: FocusNavigation, isRaiseEvent = true): boolean {
+        if (isRaiseEvent) {
+            return this.MoveFocusHost(navigation) ?? false;
+        } else {
+            let targetElement = this._currentFocusedElement;
+            if (this._focusList && targetElement) {
+                const index = 100;// this._focusList.IndexOf(targetElement);//TODO
+                switch (navigation) {
+                    case FocusNavigation.Top:
+                        this.ReSetFocus();
+                        break;
+                    case FocusNavigation.Backward:
+                        const ind = index > 0 ? index - 1 : 0;
+                        targetElement = this._focusList[ind];
+                        break;
+                    case FocusNavigation.Forward:
+                        targetElement = this._focusList[(index + 1) % this._focusList.count];
+                        break;
+                }
+
+                if (targetElement && targetElement !== this._currentFocusedElement) {
+                    this.SetFocus(targetElement);
+                    return true;
+                }
+            }
+            return false;
+        }
+    }
+
+    public Refresh() {
+        if (this._focusList) {
+            this._focusList.refresh();
+        }
+    }
+
+    private OnPreviewMouseDown(sender: any, e: RoutedEventArgs) {
+        if (this._target !== sender) return;
+        if (!this.CanAcceptUserInput) {
+            e.Handled = true;
+            return;
+        }
+
+        let clickedElement = e.Source as FrameworkElement;
+        let originalElement = e.Source as FrameworkElement;
+
+        if (!clickedElement) return;
+
+        if (!getAttachedProperty(clickedElement, "OnlyMouseControlHandled") &&
+            !getAttachedProperty(clickedElement, "IsInternalKeyboardControlling")) {
+            let originalSourceElement = e.OriginalSource as FrameworkElement;
+            if (originalSourceElement) {
+                if (getAttachedProperty(originalSourceElement, "OnlyMouseControlHandled") ||
+                    getAttachedProperty(originalSourceElement, "IsInternalKeyboardControlling")) {
+                    clickedElement = originalSourceElement;
+                } else {
+                    // 模拟 FindVisualTreeAncestor
+                    // if (originalSourceElement.FindVisualTreeAncestor(x => x is Window) == null) { ... }
+                    // clickedElement = originalSourceElement.FindVisualTreeAncestor(d => ...);
+                }
+            }
+        }
+
+        // if (!clickedElement || clickedElement instanceof IPage) {
+        //     e.Handled = true;
+        //     return;
+        // }
+
+        const handled = getAttachedProperty(clickedElement, "OnlyMouseControlHandled");
+        if (handled) {
+            let flag = false;
+            // 模拟判断条件
+            // if (originalElement is ScrollViewer || ...) { ... }
+            // const focusElements = originalElement.FindVisualTreeChildren();
+            // if (focusElements.Contains(this._currentFocusedElement)) { ... }
+
+            if (flag) {
+                handled(clickedElement, e);
+                return;
+            }
+        }
+
+        if (this._focusList && this._currentFocusedElement) {
+            // const currentIndex = this._focusList.IndexOf(this._currentFocusedElement);
+            // let targetIndex = this._focusList.IndexOf(clickedElement);
+
+            // if (targetIndex < 0) {
+            //     while (true) {
+            //         clickedElement = LogicalTreeHelper.GetParent(clickedElement) as FrameworkElement;
+            //         if (!clickedElement || clickedElement instanceof IPage) {
+            //             e.Handled = true;
+            //             return;
+            //         }
+            //         targetIndex = this._focusList.IndexOf(clickedElement);
+            //         if (targetIndex >= 0) break;
+            //     }
+            // }
+
+            // if (currentIndex === targetIndex) {
+            //     if (this.ButtonClickTick(this._currentFocusedElement)) {
+            //         e.Handled = true;
+            //     }
+
+            //     const funcFocusHandled = getAttachedProperty(this._currentFocusedElement, "MouseFocusHandled");
+            //     if (funcFocusHandled) {
+            //         const result = funcFocusHandled(this._currentFocusedElement, e as MouseEventArgs);
+            //         // 处理结果
+            //     }
+            //     return;
+            // }
+
+            //   const result = this.MoveFocusHost(targetIndex > currentIndex ? FocusNavigation.Forward : FocusNavigation.Backward, clickedElement);
+            if (result === false) {
+                e.Handled = true;
+            } else if (!this._isOperator) {
+                this._isOperator = true;
+            }
+        }
+    }
+
+    private OnPreviewKeyDown(sender: any, e: KeyEventArgs) {
+        if (this._target !== sender) return;
+        if (!this.CanAcceptUserInput) {
+            e.Handled = true;
+            return;
+        }
+        if (!this._currentFocusedElement) return;
+
+        if (this._currentFocusedElement instanceof ButtonBase && (e.Key === "Enter" || e.Key === "Space")) {
+            if (this.ButtonClickTick(this._currentFocusedElement)) {
+                e.Handled = true;
+            }
+        }
+
+        const funcFocusHandled = getAttachedProperty(this._currentFocusedElement, "FocusHandled");
+        if (funcFocusHandled) {
+            const pressKey = HotKeyHelper.GetKeyName(e.Key);
+            const result = funcFocusHandled(this._currentFocusedElement, e);
+            // 处理结果
+        }
+
+        let pressKey = "";
+        // 模拟按键判断
+        // if (e.Key == Key.Up || ...) { ... }
+
+        let result: boolean | null = true;
+        if (pressKey === "DOWN") {
+            e.Handled = true;
+            result = this.MoveFocusHost(FocusNavigation.Forward);
+            if (!this._isOperator) this._isOperator = true;
+        } else if (pressKey === "UP") {
+            e.Handled = true;
+            result = this.MoveFocusHost(FocusNavigation.Backward);
+            if (!this._isOperator) this._isOperator = true;
+        }
+
+        if (result === false) {
+            e.Handled = true;
+        }
+    }
+
+    private ButtonClickTick(clickElement: FrameworkElement): boolean {
+        const clickTick = getAttachedProperty(clickElement, "ButtonClickTick") || 0;
+        const clickTickOut = getAttachedProperty(clickElement, "ButtonClickTickOut") || FocusManager.DEFAULT_BUTTON_CLICK_TICK_OUT;
+
+        if (clickTick === 0) {
+            setAttachedProperty(clickElement, "ButtonClickTick", Date.now());
+        } else {
+            const tLeft = (Date.now() - clickTick) / 1000;
+            if (tLeft <= clickTickOut) {
+                return true;
+            } else {
+                setAttachedProperty(clickElement, "ButtonClickTick", Date.now());
+            }
+        }
+
+        return false;
+    }
+
+    private RaiseFocusManagerEvent(target: DependencyObject, routedEvent: string): boolean {
+        this.IsFocusContinue = true;
+        if (!target) return false;
+        // 模拟事件触发
+        return this.IsFocusContinue;
+    }
+
+    private MoveFocusHost(navigation: FocusNavigation = FocusNavigation.Forward, target: FrameworkElement | null = null): boolean | null {
+        if (!this._focusList) {
+            //  this._focusList = FocusList.create(this._target);
+        }
+
+        let currentElement = this._currentFocusedElement;
+        let targetElement: FrameworkElement | null = null;
+
+        //         if (this._focusList) {
+        //             for (let i = 0; i < this._focusList.count; i++) {
+        //                 // if (!currentElement || !this._focusList.contains(currentElement)) {
+        //                 //     navigation = FocusNavigation.Top;
+        //                 // }
+
+        //                 if (this._focusList && currentElement) {
+        //                     // // const index = this._focusList.IndexOf(currentElement);
+        //                     // switch (navigation) {
+        //                     //     case FocusNavigation.Top:
+        //                     //         targetElement = this._focusList[i];
+        //                     //         break;
+        //                     //     case FocusNavigation.Backward:
+        //                     //         const ind = index > 0 ? index - 1 : 0;
+        //                     //         targetElement = this._focusList[ind];
+        //                     //         break;
+        //                     //     case FocusNavigation.Forward:
+        //                     //         targetElement = this._focusList[(index + 1) % this._focusList.Count];
+        //                     //         break;
+        //                     //     default:
+        //                     //         throw new Error("MoveFocus：无效的参数！");
+        //                     // }
+        //                 }
+
+        //                 if (!targetElement) return false;
+        //                 if (targetElement === currentElement) return null;
+
+        //                 if (navigation !== FocusNavigation.Forward) {
+        //                     // const tmpTarget = target || targetElement;
+        //                     // if (this.IsEnableFocus(tmpTarget)) {
+        //                     //     tmpTarget.Focus();
+        //                     //     if (this.RaiseFocusManagerEvent(tmpTarget, "PreviewGotFocusEvent") &&
+        //                     //         this.RaiseFocusManagerEvent(tmpTarget, "GotFocusEvent")) {
+        //                     //         this.CurrentFocusedElement = tmpTarget;
+        //                     //         if (tmpTarget instanceof ButtonBase && navigation !== FocusNavigation.Top) {
+        //                     //             return !this.ButtonClickTick(tmpTarget);
+        //                     //         }
+        //                     //         return true;
+        //                     //     } else {
+        //                     //         return false;
+        //                     //     }
+        //                     // } else if (!target) {
+        //                     //     // currentElement = tmpTarget;
+        //                     // }
+        //                     // continue;
+        //                 } else {
+        //                     return false;
+        //                 }
+        //             } else if (target && FocusManager.GetCanSkipPreviousFocus(target)) {
+        //                 targetElement = target;
+        //             } else {
+        //                 if (currentElement &&
+        //                     this.IsEnableFocus(currentElement) &&
+        //                     (!this.RaiseFocusManagerEvent(currentElement, "PreviewLostFocusEvent") ||
+        //                         !this.RaiseFocusManagerEvent(currentElement, "LostFocusEvent"))) {
+        //                     return false;
+        //                 }
+        //             }
+
+        //             if (this.IsEnableFocus(targetElement)) {
+        //                 targetElement.Focus();
+        //                 if (this.RaiseFocusManagerEvent(targetElement, "PreviewGotFocusEvent") &&
+        //                     this.RaiseFocusManagerEvent(targetElement, "GotFocusEvent")) {
+        //                     this.CurrentFocusedElement = targetElement;
+        //                 } else {
+        //                     return false;
+        //                 }
+        //             } else {
+        //                 currentElement = targetElement;
+        //                 continue;
+        //             }
+
+        //             if (!target || target === targetElement ||
+        //                 (target && FocusManager.GetCanSkipPreviousFocus(target))) {
+        //                 if (target === targetElement && target instanceof ButtonBase) {
+        //                     return !this.ButtonClickTick(target);
+        //                 }
+        //                 return true;
+        //             } else {
+        //                 currentElement = targetElement;
+        //                 continue;
+        //             }
+        //         }
+        //     }
+
+        // return false;
+        //     }
+
+        //     private IsEnableFocus(ele: FrameworkElement): boolean {
+        //     return null;//ele.IsEnabled && ele.IsVisible && (ele.Focusable || getAttachedProperty(ele, "IsInternalKeyboardControlling"));
+        // }
+
+        //     public MoveFocusElement(target: FrameworkElement): boolean {
+        //     if (this._focusList && this._currentFocusedElement) {
+        //         // const currentIndex = this._focusList.IndexOf(this._currentFocusedElement);
+        //         // let targetIndex = this._focusList.IndexOf(target);
+
+        //         // if (targetIndex < 0) {
+        //         //     while (true) {
+        //         //         target = LogicalTreeHelper.GetParent(target) as FrameworkElement;
+        //         //         if (!target || target instanceof IPage) {
+        //         //             return false;
+        //         //         }
+        //         //         targetIndex = this._focusList.IndexOf(target);
+        //         //         if (targetIndex >= 0) break;
+        //         //     }
+        //         // }
+
+        //         // if (currentIndex === targetIndex) return true;
+
+        //         // const result = this.MoveFocusHost(targetIndex > currentIndex ? FocusNavigation.Forward : FocusNavigation.Backward, target);
+        //         return result === true;
+        //     }
+        return false;
+    }
+}
+
+// 模拟其他类和工具函数
+class TextBox extends FrameworkElement {
+    Text = "";
+}
+
+class ButtonBase extends FrameworkElement { }
+
+class LogicalTreeHelper {
+    static GetParent(element: FrameworkElement): FrameworkElement | null {
+        return null;
+    }
+}
+
+class HotKeyHelper {
+    static GetKeyName(key: string): string {
+        return key;
+    }
+}
+
+// 其他模拟类和工具函数可按需添加
+//TODO 焦点控制 后续处理

ant-design-pro-vue3/src/views/front/platfrom/presentation/FocusManagers/FocusManagerExt.ts

@@ -0,0 +1,187 @@
+// // 假设 FieldPolicyCollection 和 TipAdorner 等类型的定义
+// interface FieldPolicy {
+//     Run(d: any, message: string): void;
+// }
+
+// interface FieldPolicyCollection {
+//     [index: number]: FieldPolicy;
+// }
+
+// // 定义焦点管理器实例接口
+// interface FocusManagerInstance {
+//     IsFocusContinue: boolean;
+// }
+
+// // 焦点管理器类
+// class FocusManager {
+//     // 模拟获取焦点管理器实例
+//     static GetManagerInstance(d: any): FocusManagerInstance | null {
+//         return { IsFocusContinue: true };
+//     }
+
+//     // 模拟添加焦点丢失事件处理程序
+//     static AddPreviewLostFocusHandler(d: any, handler: (sender: any, args: any) => void) {
+//         if (d.addEventListener) {
+//             d.addEventListener('blur', handler);
+//         }
+//     }
+
+//     // 模拟移除焦点丢失事件处理程序
+//     static RemovePreviewLostFocusHandler(d: any, handler: (sender: any, args: any) => void) {
+//         if (d.removeEventListener) {
+//             d.removeEventListener('blur', handler);
+//         }
+//     }
+// }
+
+// // 焦点管理器扩展类
+// class FocusManagerExt {
+//     // 定义静态属性
+//     static AssertNotEmptyProperty = Symbol('AssertNotEmpty');
+//     static RegexValidationProperty = Symbol('RegexValidation');
+//     static RegexValidateErrorInfoProperty = Symbol('RegexValidateErrorInfo');
+//     static ValidationFieldProperty = Symbol('ValidationField');
+//     static FieldEmptyPoliciesProperty = Symbol('FieldEmptyPolicies');
+//     static RegexValidateErrorPoliciesProperty = Symbol('RegexValidateErrorPolicies');
+//     static IsFocusAdornerProperty = Symbol('IsFocusAdorner');
+
+//     // Getter 和 Setter 方法
+//     static GetAssertNotEmpty(d: any): boolean {
+//         return d[this.AssertNotEmptyProperty] || false;
+//     }
+
+//     static SetAssertNotEmpty(d: any, value: boolean) {
+//         d[this.AssertNotEmptyProperty] = value;
+//         this.OnAssertNotEmptyChanged(d, value);
+//     }
+
+//     static GetRegexValidation(d: any): string {
+//         return d[this.RegexValidationProperty] || '';
+//     }
+
+//     static SetRegexValidation(d: any, value: string) {
+//         d[this.RegexValidationProperty] = value;
+//         this.OnRegexValidationChanged(d, value);
+//     }
+
+//     static GetRegexValidateErrorInfo(d: any): string {
+//         return d[this.RegexValidateErrorInfoProperty] || '';
+//     }
+
+//     static SetRegexValidateErrorInfo(d: any, value: string) {
+//         d[this.RegexValidateErrorInfoProperty] = value;
+//     }
+
+//     static GetValidationField(d: any): string {
+//         return d[this.ValidationFieldProperty] || '';
+//     }
+
+//     static SetValidationField(d: any, value: string) {
+//         d[this.ValidationFieldProperty] = value;
+//     }
+
+//     static GetFieldEmptyPolicies(d: any): FieldPolicyCollection | null {
+//         return d[this.FieldEmptyPoliciesProperty] || null;
+//     }
+
+//     static SetFieldEmptyPolicies(d: any, value: FieldPolicyCollection) {
+//         d[this.FieldEmptyPoliciesProperty] = value;
+//     }
+
+//     static GetRegexValidateErrorPolicies(d: any): FieldPolicyCollection | null {
+//         return d[this.RegexValidateErrorPoliciesProperty] || null;
+//     }
+
+//     static SetRegexValidateErrorPolicies(d: any, value: FieldPolicyCollection) {
+//         d[this.RegexValidateErrorPoliciesProperty] = value;
+//     }
+
+//     static GetIsFocusAdorner(d: any): boolean {
+//         return d[this.IsFocusAdornerProperty] || false;
+//     }
+
+//     static SetIsFocusAdorner(d: any, value: boolean) {
+//         d[this.IsFocusAdornerProperty] = value;
+//     }
+
+//     // 属性变化处理方法
+//     private static OnAssertNotEmptyChanged(d: any, newValue: boolean) {
+//         if (newValue) {
+//             FocusManager.AddPreviewLostFocusHandler(d, this.handler);
+//         } else {
+//             FocusManager.RemovePreviewLostFocusHandler(d, this.handler);
+//         }
+//     }
+
+//     private static handler = (sender: any, args: any) => {
+//         const d = sender;
+//         const focus = FocusManager.GetManagerInstance(d);
+//         if (!focus) return;
+
+//         const propertyName = this.GetValidationField(d);
+//         if (!propertyName) return;
+
+//         const propertyInfo = d[propertyName];
+//         if (propertyInfo) {
+//             const strValue = String(propertyInfo);
+//             if (strValue.trim() !== '') return;
+//         }
+
+//         const fieldEmptyPolicies = this.GetFieldEmptyPolicies(d);
+//         if (fieldEmptyPolicies) {
+//             for (const policy of fieldEmptyPolicies) {
+//                 policy.Run(d, '该输入要素不能为空');
+//             }
+//         }
+
+//         focus.IsFocusContinue = false;
+//         args.preventDefault();
+//     };
+
+//     private static OnRegexValidationChanged(dp: any, newRegexValidation: string) {
+//         const handler = (sender: any, args: any) => {
+//             const d = sender;
+//             const focus = FocusManager.GetManagerInstance(d);
+//             if (!focus) return;
+
+//             const propertyName = this.GetValidationField(d);
+//             if (!propertyName) return;
+
+//             const propertyInfo = d[propertyName];
+//             if (!propertyInfo) return;
+
+//             const strValue = String(propertyInfo);
+//             if (!this.GetAssertNotEmpty(d) && strValue === '') return;
+
+//             const reg = this.GetRegexValidation(d);
+//             if (!reg) return;
+
+//             const regex = new RegExp(reg);
+//             if (regex.test(strValue)) return;
+
+//             const fieldPolicies = this.GetFieldEmptyPolicies(d);
+//             let regexValidateErrorInfo = this.GetRegexValidateErrorInfo(d);
+//             if (!regexValidateErrorInfo) {
+//                 regexValidateErrorInfo = `输入场要求输入值满足正则表达式：${reg}，输入值：${strValue}不满足此要求！`;
+//             }
+
+//             if (fieldPolicies) {
+//                 for (const policy of fieldPolicies) {
+//                     policy.Run(d, regexValidateErrorInfo);
+//                 }
+//             }
+
+//             focus.IsFocusContinue = false;
+//             args.preventDefault();
+//         };
+
+//         if (newRegexValidation) {
+//             FocusManager.AddPreviewLostFocusHandler(dp, handler);
+//         } else {
+//             FocusManager.RemovePreviewLostFocusHandler(dp, handler);
+//         }
+//     }
+// }
+
+// export default FocusManagerExt;
+//焦点控制TODO后续处理

ant-design-pro-vue3/src/views/front/platfrom/presentation/Interfaces/Ipage.ts

@@ -0,0 +1,42 @@
+// 定义 Disposable 接口，模拟 C# 的 IDisposable
+interface Disposable {
+    dispose(): void;
+}
+
+// 假设 PageContainer 类型定义
+class PageContainer {}
+
+// 定义 IPage 接口
+export interface IPage extends Disposable {
+    /**
+     * 实例化ID
+     */
+    readonly InstanceId: string;
+    /**
+     * 设置ID
+     * @param guid 要设置的实例化 ID
+     */
+    SetInstanceId(guid: string): void;
+    /**
+     * 视图状态数据集合
+     */
+    readonly ViewStateData: { [key: string]: any };
+    /**
+     * 设置视图状态数据集合
+     * @param viewStateData 要设置的视图状态数据集合
+     */
+    SetViewStateData(viewStateData: { [key: string]: any }): void;
+    /**
+     * 交易父容器
+     */
+    readonly OwnerContainer: PageContainer;
+    /**
+     * 设置交易父容器
+     * @param pageContainer 要设置的交易父容器
+     */
+    SetOwnerContainer(pageContainer: PageContainer): void;
+    /**
+     * 释放资源
+     */
+    dispose(): void;
+}

ant-design-pro-vue3/src/views/front/platfrom/presentation/PageFunctions/PageClosedEventArgs.ts

@@ -0,0 +1,21 @@
+// 定义一个模拟的 Guid 类型，在 TypeScript 中没有内置的 Guid，用字符串模拟
+type Guid = string;
+
+// 定义 EventArgs 基类
+class EventArgs {
+    constructor() {}
+}
+
+// 定义 PageClosedEventArgs 类
+export class PageClosedEventArgs extends EventArgs {
+    // 页面实例 ID
+    public readonly InstanceId: Guid;
+    // 页面关闭时要导出的参数
+    public readonly ExportArgs: { [key: string]: any };
+
+    constructor(instanceId: Guid, exportArgs: { [key: string]: any }) {
+        super();
+        this.InstanceId = instanceId;
+        this.ExportArgs = exportArgs;
+    }
+}

ant-design-pro-vue3/src/views/front/platfrom/presentation/PageFunctions/PageContainer.ts

@@ -0,0 +1,265 @@
+import { ConfigManager } from "../../common/RunningParameters/ConfigManager";
+// import FocusManager from "../FocusManagers/FocusManager";
+import PlatformLogger from "../../common/RunningParameters/PlatformSettings";
+// 定义 IPage 接口
+interface IPage {
+    InstanceId: string;
+    SetOwnerContainer(container: PageContainer): void;
+    SetInstanceId(id: string): void;
+    ViewStateData: { [key: string]: any };
+}
+
+// 定义 PageClosedEventArgs 接口
+interface PageClosedEventArgs {
+    InstanceId: string;
+    ViewStateData: { [key: string]: any };
+}
+
+// 定义 FocusManager 接口
+enum ConfigType {
+    System,
+    Client,
+    User
+}
+
+// 定义 PageContainer 类
+class PageContainer {
+    private _pageStack: IPage[] = [];
+    public AllPagesClosed: ((sender: PageContainer, args: PageClosedEventArgs) => void) | null = null;
+    private _currentPage: IPage | null = null;
+    public get CurrentPage(): IPage | null {
+        return this._currentPage;
+    }
+    private set CurrentPage(value: IPage | null) {
+        this._currentPage = value;
+        this.RaisePropertyChanged("CurrentPage");
+    }
+
+    private _ClosedCallbackList: { [key: string]: (page: IPage) => void } = {};
+
+    public IsShowInfo: boolean = false;
+    public DisplayInfoList: any[] = [];
+    public BusyStateTip: string = "数据处理中...";
+    public IsBusy: boolean = false;
+    public IsOverlay: boolean = false;
+
+    private _busyAdorner: HTMLElement | null = null;
+    private _sprocket: HTMLElement | null = null;
+
+    constructor() {
+        // 模拟 WPF 的静态构造函数逻辑
+        // 在 TypeScript 中无法直接实现静态构造函数，这里可以在实例构造函数中初始化一些静态相关的逻辑
+    }
+
+    public OnContentChanged(oldContent: any, newContent: any): void {
+        const page = newContent as IPage;
+        if (page === null && newContent !== null) {
+            throw new Error("Content必须继承IPage对象");
+        }
+
+        if (page !== null && page.InstanceId !== "") {
+            this.CurrentPage = page;
+
+            if (!this._pageStack.includes(page)) {
+                page.SetOwnerContainer(this);
+                this._pageStack.push(page);
+            }
+        }
+    }
+
+    public PushPage(page: IPage, closedCallback: ((page: IPage) => void) | null = null): string {
+        if (page === null) {
+            return "";
+        } else {
+            if (page.InstanceId === "") {
+                page.SetInstanceId(this.generateGuid());
+            }
+            if (closedCallback !== null) {
+                this._ClosedCallbackList[page.InstanceId] = closedCallback;
+            }
+            // 模拟移除父元素的逻辑
+            // 在 Web 环境中，可能需要根据具体情况实现
+            this.OnContentChanged(null, page);
+            return page.InstanceId;
+        }
+    }
+
+    public ClosePage(): { [key: string]: any } | null {
+        if (this._currentPage !== null) {
+            const closePage = this._currentPage;
+            this._pageStack.pop();
+
+            if (this._pageStack.length > 0) {
+                this.OnContentChanged(null, this._pageStack[this._pageStack.length - 1]);
+            } else {
+                if (this.AllPagesClosed !== null) {
+                    this.AllPagesClosed(this, {
+                        InstanceId: closePage.InstanceId,
+                        ViewStateData: closePage.ViewStateData
+                    });
+                }
+            }
+            if (this._ClosedCallbackList[closePage.InstanceId]) {
+                this._ClosedCallbackList[closePage.InstanceId](closePage);
+            }
+            closePage.SetInstanceId("");
+            return closePage.ViewStateData;
+        }
+
+        return null;
+    }
+
+    public CloseAndOpenPage(page: IPage): string {
+        if (page === null) {
+            return "";
+        } else {
+            if (this._currentPage !== null) {
+                this._currentPage.SetInstanceId("");
+                this._pageStack.pop();
+            }
+
+            return this.PushPage(page);
+        }
+    }
+
+    public OnApplyTemplate(): void {
+        this._busyAdorner = document.getElementById("BusyAdorner");
+        this._sprocket = document.getElementById("sprocketControl");
+    }
+
+    public SetBusyAdorner(isBusy: boolean, tip: string | null): void {
+        if (this._busyAdorner !== null) {
+            this._busyAdorner.textContent = tip ?? "正在处理...";
+            this._busyAdorner.style.display = isBusy ? "block" : "none";
+            if (this._sprocket !== null) {
+                // 模拟 IsIndeterminate 属性
+                // 在 Web 环境中，可能需要根据具体情况实现
+            }
+        }
+    }
+
+    public set IsBusyValue(value: boolean) {
+        this.IsBusy = value;
+        this.OnIsBusyChanged();
+    }
+
+    private OnIsBusyChanged(): void {
+        //TODO焦点控制需要用到微软的框架
+        const focusManager = null;//FocusManager.GetManagerInstance(this);
+        if (focusManager !== null) {
+            focusManager.CanAcceptUserInput = !this.IsBusy;
+        } else {
+            const handler = (e: KeyboardEvent) => {
+                e.preventDefault();
+            };
+            if (this.IsBusy) {
+                document.addEventListener("keydown", handler);
+            } else {
+                document.removeEventListener("keydown", handler);
+            }
+
+            const mouseHandler = (e: MouseEvent) => {
+                e.preventDefault();
+            };
+            if (this.IsBusy) {
+                document.addEventListener("mousedown", mouseHandler);
+                document.addEventListener("mouseup", mouseHandler);
+            } else {
+                document.removeEventListener("mousedown", mouseHandler);
+                document.removeEventListener("mouseup", mouseHandler);
+            }
+        }
+        this.SetBusyAdorner(this.IsBusy, this.BusyStateTip);
+    }
+
+    public async ModalInvoke(action: () => Promise<void>, busyStateTip: string): Promise<void> {
+        this.BusyStateTip = busyStateTip;
+        this.IsBusyValue = true;
+
+        if (ConfigManager.GetInstance().GetConfigValue("ModalInvoke", ConfigType.Client) !== "Legacy") {
+            try {
+                const win = new ModalWindow(action);
+                win.DelayCancel = 120;
+                await win.showDialog();
+                this.IsBusyValue = false;
+                if (win.IsCancel) {
+                    throw new Error("用户强制中断了操作！");
+                }
+                return;
+            } catch (ex) {
+                PlatformLogger.SystemErrorInfo("ModalInvoke:初始化ModalWindow发生异常！", ex as Error);
+            }
+        }
+
+        try {
+            await action();
+        } finally {
+            this.IsBusyValue = false;
+        }
+    }
+
+    private RaisePropertyChanged(propertyName: string): void {
+        // 模拟属性变更通知
+        // 在 Vue 中，可以使用事件或响应式系统实现
+    }
+
+    private generateGuid(): string {
+        return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, function (c) {
+            const r = Math.random() * 16 | 0,
+                v = c === 'x' ? r : (r & 0x3 | 0x8);
+            return v.toString(16);
+        });
+    }
+}
+
+// 定义 ModalWindow 类
+class ModalWindow {
+    private action: () => Promise<void>;
+    private thread: NodeJS.Timeout | null = null;
+    private watch: number = Date.now();
+    public DelayCancel: number = 30;
+    public IsCancel: boolean = false;
+
+    constructor(action: () => Promise<void>) {
+        this.action = action;
+    }
+
+    public async showDialog(): Promise<void> {
+        const dialog = document.createElement("div");
+        dialog.style.position = "fixed";
+        dialog.style.bottom = "0";
+        dialog.style.left = "0";
+        dialog.style.backgroundColor = "rgba(0, 0, 0, 0.5)";
+        dialog.style.color = "white";
+        dialog.style.padding = "10px";
+        dialog.textContent = "系统处理中...";
+        document.body.appendChild(dialog);
+
+        try {
+            this.thread = setTimeout(() => {
+                this.action().then(() => {
+                    dialog.remove();
+                }).catch((ex) => {
+                    PlatformLogger.SystemErrorInfo("ModalInvoke2Dialog:调用发生异常！", ex);
+                    dialog.remove();
+                });
+            }, 0);
+
+            document.addEventListener("keydown", this.handleKeyDown.bind(this));
+        } finally {
+            document.removeEventListener("keydown", this.handleKeyDown.bind(this));
+        }
+    }
+
+    private handleKeyDown(e: KeyboardEvent): void {
+        if ((Date.now() - this.watch) / 1000 < this.DelayCancel) return;
+        if (e.key === "x" && e.ctrlKey) {
+            if (this.thread !== null) {
+                clearTimeout(this.thread);
+                this.IsCancel = true;
+            }
+        }
+    }
+}
+
+export { PageContainer };

ant-design-pro-vue3/src/views/front/platfrom/presentation/PageFunctions/PageExtension.ts

@@ -0,0 +1,84 @@
+// 定义 IPage 接口
+interface IPage {
+    OwnerContainer: PageContainer | null;
+}
+
+// 定义 PageContainer 接口
+interface PageContainer {
+    ClosePage(): void;
+    PushPage(actionName: string, importArgs?: Record<string, any>): string;
+    PushPage(page: IPage): string;
+}
+
+// 定义 PageExtension 类
+export class PageExtension {
+    /**
+     * 关闭并打开新的交易 - 扩展方法
+     * @param target 当前的交易
+     * @param actionName 交易的全名（例如:PlatformManage.T7801）
+     * @param importArgs 维护视图数据
+     */
+    static CloseAndOpenTradePage(target: IPage, actionName: string, importArgs?: Record<string, any>): string {
+        const tradePageContainer = target.OwnerContainer;
+        if (!tradePageContainer) {
+            return '00000000-0000-0000-0000-000000000000';
+        }
+        tradePageContainer.ClosePage();
+        return tradePageContainer.PushPage(actionName, importArgs);
+    }
+
+    /**
+     * 关闭并打开新的交易 - 扩展方法
+     * @param target 当前的交易
+     * @param page 要打开的页面
+     */
+    static CloseAndOpenTradePageWithPage(target: IPage, page: IPage): string {
+        const tradePageContainer = target.OwnerContainer;
+        if (!tradePageContainer) {
+            return '00000000-0000-0000-0000-000000000000';
+        }
+        tradePageContainer.ClosePage();
+        return tradePageContainer.PushPage(page);
+    }
+
+    /**
+     * 打开交易 - 扩展方法
+     * @param target 当前交易
+     * @param actionName 交易的全名（例如:PlatformManage.T7801）
+     * @param importArgs 维护视图数据
+     */
+    static OpenPage(target: IPage, actionName: string, importArgs?: Record<string, any>): string {
+        const tradePageContainer = target.OwnerContainer;
+        if (!tradePageContainer) {
+            return '00000000-0000-0000-0000-000000000000';
+        }
+        return tradePageContainer.PushPage(actionName, importArgs);
+    }
+
+    /**
+     * 打开交易 - 扩展方法
+     * @param target 当前交易
+     * @param page 要打开的页面
+     */
+    static OpenPageWithPage(target: IPage, page: IPage): string {
+        if (!page) {
+            throw new Error('page is not null');
+        }
+        const tradePageContainer = target.OwnerContainer;
+        if (!tradePageContainer) {
+            return '00000000-0000-0000-0000-000000000000';
+        }
+        return tradePageContainer.PushPage(page);
+    }
+
+    /**
+     * 关闭页面
+     * @param target 当前页面
+     */
+    static Close(target: IPage): void {
+        const tradePageContainer = target.OwnerContainer;
+        if (tradePageContainer) {
+            tradePageContainer.ClosePage();
+        }
+    }
+}

ant-design-pro-vue3/src/views/front/platfrom/presentation/PageFunctions/PageFactory.ts

@@ -0,0 +1,175 @@
+import * as fs from 'fs';
+import * as path from 'path';
+import * as crypto from 'crypto';
+
+// 假设 IPage 接口定义如下
+interface IPage {
+    SetInstanceId(id: string): void;
+}
+
+// 假设 PageContainer 类定义如下
+class PageContainer {
+    ModalInvoke(action: () => void, message: string) {
+        action();
+    }
+}
+
+// 假设 PlatformSettings 类定义如下
+class PlatformSettings {
+    static IsDebugMode = false;
+    static PagesDirectory = 'pages';
+}
+
+// 假设 ConfigManager 类定义如下
+class ConfigManager {
+    private static instance: ConfigManager;
+
+    static GetInstance() {
+        if (!this.instance) {
+            this.instance = new ConfigManager();
+        }
+        return this.instance;
+    }
+
+    GetConfigValue(key: string, configType: any) {
+        return 'false';
+    }
+}
+
+// 假设 ConfigType 枚举定义如下
+enum ConfigType {
+    System
+}
+
+// 假设 FilesHandle 类定义如下
+class FilesHandle {
+    static UpdateAssemblys: { [key: string]: boolean } = {};
+
+    static UpdateTradeDll(actionName: string) {
+        return true;
+    }
+}
+
+// 假设 FileHandle 类定义如下
+class FileHandle {
+    static GetFileMD5(fileInfo: { path: string }) {
+        const data = fs.readFileSync(fileInfo.path);
+        return crypto.createHash('md5').update(data).digest('hex');
+    }
+}
+
+// 假设 PlatformLogger 类定义如下
+class PlatformLogger {
+    static SystemInfo(message: string) {
+        console.log(message);
+    }
+}
+
+class PageFactory {
+    private static Logger = {
+        Error(message: string) {
+            console.error(message);
+        }
+    };
+
+    private static LoadedActionTypes: { [key: string]: any } = {};
+    private static LoadedActionMD5: { [key: string]: string } = {};
+
+    static CreatePage(actionName: string, pageContainer?: PageContainer): IPage | null {
+        let actionType: any = null;
+        if (!pageContainer) {
+            actionType = this.GetActionType(actionName);
+        } else {
+            pageContainer.ModalInvoke(() => {
+                actionType = this.GetActionType(actionName);
+            }, "正在加载交易页面，请稍后...");
+        }
+        if (!actionType) {
+            this.Logger.Error(`加载文件名为：【${actionName}】的交易失败！`);
+            return null;
+        } else {
+            const page = new actionType() as IPage;
+            if (page) {
+                page.SetInstanceId(this.generateGuid());
+            }
+            return page;
+        }
+    }
+
+    private static GetActionType(actionName: string): any {
+        let actionType: any = null;
+
+        if (!PlatformSettings.IsDebugMode) {
+            let flag = false;
+            flag = Boolean(ConfigManager.GetInstance().GetConfigValue("IsFromProjectDownLoadTradeDll", ConfigType.System));
+            if (!flag) {
+                PlatformLogger.SystemInfo(`Update Trade File,FileName:[${actionName}]`);
+                if (!FilesHandle.UpdateTradeDll(actionName)) {
+                    return null;
+                }
+            } else {
+                PlatformLogger.SystemInfo(`已由项目层检测和下载交易的dll:[${actionName}]`);
+            }
+        }
+
+        if (PlatformSettings.IsDebugMode || !this.LoadedActionTypes[actionName]
+            || (FilesHandle.UpdateAssemblys[actionName] && FilesHandle.UpdateAssemblys[actionName])) {
+            const fileName = `${actionName}.dll`;
+            const pagesDirectory = PlatformSettings.PagesDirectory;
+            const filePath = path.join(process.cwd(), pagesDirectory, fileName);
+            if (fs.existsSync(filePath)) {
+                const fileMD5 = FileHandle.GetFileMD5({ path: filePath });
+                if (PlatformSettings.IsDebugMode && this.LoadedActionMD5[actionName] && this.LoadedActionMD5[actionName] === fileMD5
+                    && this.LoadedActionTypes[actionName]) {
+                    return this.LoadedActionTypes[actionName];
+                } else {
+                    this.LoadedActionMD5[actionName] = fileMD5;
+                }
+
+                const rawAssembly = this.loadFile(filePath);
+                // 这里无法直接加载 DLL，仅作示例
+                // 假设存在一个模块加载函数
+                const assembly = this.loadModule(rawAssembly);
+                if (!assembly) return null;
+                for (const key in assembly) {
+                    if (assembly.hasOwnProperty(key)) {
+                        const type = assembly[key];
+                        if (this.isIPage(type)) {
+                            this.LoadedActionTypes[type.name] = type;
+                        }
+                    }
+                }
+                actionType = this.LoadedActionTypes[actionName];
+            }
+        }
+
+        return actionType;
+    }
+
+    private static loadFile(filename: string): Buffer {
+        if (!fs.existsSync(filename)) {
+            return Buffer.alloc(0);
+        }
+        return fs.readFileSync(filename);
+    }
+
+    private static generateGuid() {
+        return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, function (c) {
+            const r = Math.random() * 16 | 0;
+            const v = c === 'x' ? r : (r & 0x3 | 0x8);
+            return v.toString(16);
+        });
+    }
+
+    private static isIPage(type: any): boolean {
+        // 简单判断是否实现了 IPage 接口
+        return typeof type.prototype.SetInstanceId === 'function';
+    }
+
+    private static loadModule(rawAssembly: Buffer): any {
+        // 这里无法直接加载 DLL，仅作示例
+        return {};
+    }
+}
+
+export { PageFactory };

ant-design-pro-vue3/src/views/front/platfrom/presentation/PageFunctions/SprocketControl.ts

@@ -0,0 +1,384 @@
+// 定义旋转方向枚举
+export enum Direction {
+  CLOCKWISE,
+  ANTICLOCKWISE
+}
+
+// 定义辐条结构体
+interface Spoke {
+  StartPoint: { x: number; y: number };
+  EndPoint: { x: number; y: number };
+}
+
+export class SprocketControl {
+  // 常量
+  private static readonly DEFAULT_INTERVAL = 60;
+  private static readonly DEFAULT_TICK_COLOR = { r: 58, g: 58, b: 58, a: 255 };
+  private static readonly DEFAULT_TICK_WIDTH = 3;
+  private static readonly DEFAULT_TICK_COUNT = 12;
+  private static readonly MINIMUM_INNER_RADIUS = 5;
+  private static readonly MINIMUM_OUTER_RADIUS = 8;
+  private static readonly MINIMUM_CONTROL_SIZE = { width: 28, height: 28 };
+  private static readonly MINIMUM_PEN_WIDTH = 2;
+  private static readonly DEFAULT_START_ANGLE = 270;
+  private static readonly INNER_RADIUS_FACTOR = 0.175;
+  private static readonly OUTER_RADIUS_FACTOR = 0.3125;
+  private static readonly ALPHA_UPPER_LIMIT = 250;
+  private static readonly ALPHA_LOWER_LIMIT = 0;
+  private static readonly ALPHA_TICK_PERCENTAGE_LOWER_LIMIT = 10;
+  private static readonly DEFAULT_PROGRESS_ALPHA = 10;
+  private static readonly DEFAULT_PROGRESS = 0.0;
+
+  // 字段
+  private centerPoint = { x: 0, y: 0 };
+  private innerRadius = 0;
+  private outerRadius = 0;
+  private alphaChange = 0;
+  private angleIncrement = 0;
+  private renderStartAngle = 0;
+  private renderTimer: number | null = null;
+  private spokes: Spoke[] = [];
+
+  // 依赖属性
+  private _interval = SprocketControl.DEFAULT_INTERVAL;
+  private _isIndeterminate = true;
+  private _progress = SprocketControl.DEFAULT_PROGRESS;
+  private _rotation = Direction.CLOCKWISE;
+  private _startAngle = SprocketControl.DEFAULT_START_ANGLE;
+  private _tickColor = SprocketControl.DEFAULT_TICK_COLOR;
+  private _tickCount = SprocketControl.DEFAULT_TICK_COUNT;
+  private _tickStyle: CanvasLineCap = 'round';
+  private _tickWidth = SprocketControl.DEFAULT_TICK_WIDTH;
+  private _lowestAlpha = SprocketControl.ALPHA_LOWER_LIMIT;
+  private _alphaTicksPercentage = 100.0;
+
+  // 构造函数
+  constructor(private canvas: HTMLCanvasElement) {
+    this.calculateSpokesPoints();
+    this.canvas.addEventListener('resize', () => this.onRenderSizeChanged());
+  }
+
+  // 属性访问器
+  get Interval() {
+    return this._interval;
+  }
+  set Interval(value: number) {
+    const oldValue = this._interval;
+    this._interval = value;
+    this.onIntervalChanged(oldValue, value);
+  }
+
+  get IsIndeterminate() {
+    return this._isIndeterminate;
+  }
+  set IsIndeterminate(value: boolean) {
+    const oldValue = this._isIndeterminate;
+    this._isIndeterminate = value;
+    this.onIsIndeterminateChanged(oldValue, value);
+  }
+
+  get Progress() {
+    return this._progress;
+  }
+  set Progress(value: number) {
+    const coercedValue = this.coerceProgress(value);
+    const oldValue = this._progress;
+    this._progress = coercedValue;
+    this.onProgressChanged(oldValue, coercedValue);
+  }
+
+  get Rotation() {
+    return this._rotation;
+  }
+  set Rotation(value: Direction) {
+    const oldValue = this._rotation;
+    this._rotation = value;
+    this.onRotationChanged(oldValue, value);
+  }
+
+  get StartAngle() {
+    return this._startAngle;
+  }
+  set StartAngle(value: number) {
+    const oldValue = this._startAngle;
+    this._startAngle = value;
+    this.onStartAngleChanged(oldValue, value);
+  }
+
+  get TickColor() {
+    return this._tickColor;
+  }
+  set TickColor(value: { r: number; g: number; b: number; a: number }) {
+    const oldValue = this._tickColor;
+    this._tickColor = value;
+    this.onTickColorChanged(oldValue, value);
+  }
+
+  get TickCount() {
+    return this._tickCount;
+  }
+  set TickCount(value: number) {
+    const coercedValue = this.coerceTickCount(value);
+    const oldValue = this._tickCount;
+    this._tickCount = coercedValue;
+    this.onTickCountChanged(oldValue, coercedValue);
+  }
+
+  get TickStyle() {
+    return this._tickStyle;
+  }
+  set TickStyle(value: CanvasLineCap) {
+    const oldValue = this._tickStyle;
+    this._tickStyle = value;
+    this.onTickStyleChanged(oldValue, value);
+  }
+
+  get TickWidth() {
+    return this._tickWidth;
+  }
+  set TickWidth(value: number) {
+    const coercedValue = this.coerceTickWidth(value);
+    const oldValue = this._tickWidth;
+    this._tickWidth = coercedValue;
+    this.onTickWidthChanged(oldValue, coercedValue);
+  }
+
+  get LowestAlpha() {
+    return this._lowestAlpha;
+  }
+  set LowestAlpha(value: number) {
+    const coercedValue = this.coerceLowestAlpha(value);
+    const oldValue = this._lowestAlpha;
+    this._lowestAlpha = coercedValue;
+    this.onLowestAlphaChanged(oldValue, coercedValue);
+  }
+
+  get AlphaTicksPercentage() {
+    return this._alphaTicksPercentage;
+  }
+  set AlphaTicksPercentage(value: number) {
+    const coercedValue = this.coerceAlphaTicksPercentage(value);
+    const oldValue = this._alphaTicksPercentage;
+    this._alphaTicksPercentage = coercedValue;
+    this.onAlphaTicksPercentageChanged(oldValue, coercedValue);
+  }
+
+  // 辅助方法
+  private start() {
+    if (!this.renderTimer) {
+      this.renderTimer = window.setInterval(() => this.onRenderTimerElapsed(), this._interval);
+    }
+  }
+
+  private stop() {
+    if (this.renderTimer) {
+      window.clearInterval(this.renderTimer);
+      this.renderTimer = null;
+    }
+  }
+
+  private convertDegreesToRadians(degrees: number) {
+    return (Math.PI / 180) * degrees;
+  }
+
+  private calculateSpokesPoints() {
+    this.spokes = [];
+    this.angleIncrement = 360 / this._tickCount;
+    this.alphaChange = (255 - this._lowestAlpha) / ((this._alphaTicksPercentage / 100) * this._tickCount);
+    this.renderStartAngle = this._startAngle;
+
+    const width = Math.min(this.canvas.width, this.canvas.height);
+    this.centerPoint = { x: this.canvas.width / 2, y: this.canvas.height / 2 };
+    this.innerRadius = width * SprocketControl.INNER_RADIUS_FACTOR;
+    if (this.innerRadius < SprocketControl.MINIMUM_INNER_RADIUS) {
+      this.innerRadius = SprocketControl.MINIMUM_INNER_RADIUS;
+    }
+    this.outerRadius = width * SprocketControl.OUTER_RADIUS_FACTOR;
+    if (this.outerRadius < SprocketControl.MINIMUM_OUTER_RADIUS) {
+      this.outerRadius = SprocketControl.MINIMUM_OUTER_RADIUS;
+    }
+
+    let angle = 0;
+    for (let i = 0; i < this._tickCount; i++) {
+      const pt1 = {
+        x: this.innerRadius * Math.cos(this.convertDegreesToRadians(angle)),
+        y: this.innerRadius * Math.sin(this.convertDegreesToRadians(angle))
+      };
+      const pt2 = {
+        x: this.outerRadius * Math.cos(this.convertDegreesToRadians(angle)),
+        y: this.outerRadius * Math.sin(this.convertDegreesToRadians(angle))
+      };
+      this.spokes.push({ StartPoint: pt1, EndPoint: pt2 });
+
+      if (!this._isIndeterminate) {
+        angle += this.angleIncrement;
+      } else {
+        if (this._rotation === Direction.CLOCKWISE) {
+          angle -= this.angleIncrement;
+        } else {
+          angle += this.angleIncrement;
+        }
+      }
+    }
+  }
+
+  // 重写方法
+  private onRenderSizeChanged() {
+    this.calculateSpokesPoints();
+    this.render();
+  }
+
+  private render() {
+    const ctx = this.canvas.getContext('2d');
+    if (!ctx || !this.spokes) return;
+
+    ctx.clearRect(0, 0, this.canvas.width, this.canvas.height);
+    ctx.translate(this.centerPoint.x, this.centerPoint.y);
+    ctx.rotate(this.convertDegreesToRadians(this.renderStartAngle));
+
+    let alpha = 255;
+    const progressSpokes = Math.floor((this._progress * this._tickCount) / 100);
+
+    for (let i = 0; i < this._tickCount; i++) {
+      if (!this._isIndeterminate) {
+        if (progressSpokes > 0) {
+          alpha = i < progressSpokes ? 255 : SprocketControl.DEFAULT_PROGRESS_ALPHA;
+        } else {
+          alpha = SprocketControl.DEFAULT_PROGRESS_ALPHA;
+        }
+      }
+
+      ctx.strokeStyle = `rgba(${this._tickColor.r}, ${this._tickColor.g}, ${this._tickColor.b}, ${alpha / 255})`;
+      ctx.lineWidth = this._tickWidth;
+      ctx.lineCap = this._tickStyle;
+      ctx.beginPath();
+      ctx.moveTo(this.spokes[i].StartPoint.x, this.spokes[i].StartPoint.y);
+      ctx.lineTo(this.spokes[i].EndPoint.x, this.spokes[i].EndPoint.y);
+      ctx.stroke();
+
+      if (this._isIndeterminate) {
+        alpha -= this.alphaChange;
+        if (alpha < this._lowestAlpha) {
+          alpha = this._lowestAlpha;
+        }
+      }
+    }
+
+    ctx.setTransform(1, 0, 0, 1, 0, 0);
+  }
+
+  // 事件处理方法
+  private onRenderTimerElapsed() {
+    if (this._rotation === Direction.CLOCKWISE) {
+      this.renderStartAngle += this.angleIncrement;
+      if (this.renderStartAngle >= 360) {
+        this.renderStartAngle -= 360;
+      }
+    } else {
+      this.renderStartAngle -= this.angleIncrement;
+      if (this.renderStartAngle <= -360) {
+        this.renderStartAngle += 360;
+      }
+    }
+    this.render();
+  }
+
+  private onVisibilityChanged(isVisible: boolean) {
+    if (this._isIndeterminate) {
+      if (isVisible) {
+        this.start();
+      } else {
+        this.stop();
+      }
+    }
+  }
+
+  // 属性更改回调方法
+  private onIntervalChanged(oldValue: number, newValue: number) {
+    if (this.renderTimer) {
+      this.stop();
+      this.start();
+    }
+  }
+
+  private onIsIndeterminateChanged(oldValue: boolean, newValue: boolean) {
+    if (oldValue !== newValue) {
+      if (newValue) {
+        this.start();
+      } else {
+        this.stop();
+        this.render();
+      }
+    }
+  }
+
+  private onProgressChanged(oldValue: number, newValue: number) {
+    this.render();
+  }
+
+  private onRotationChanged(oldValue: Direction, newValue: Direction) {
+    this.calculateSpokesPoints();
+  }
+
+  private onStartAngleChanged(oldValue: number, newValue: number) {
+    this.calculateSpokesPoints();
+  }
+
+  private onTickColorChanged(oldValue: { r: number; g: number; b: number; a: number }, newValue: { r: number; g: number; b: number; a: number }) {
+    this.render();
+  }
+
+  private onTickCountChanged(oldValue: number, newValue: number) {
+    this.calculateSpokesPoints();
+  }
+
+  private onTickStyleChanged(oldValue: CanvasLineCap, newValue: CanvasLineCap) {
+    this.render();
+  }
+
+  private onTickWidthChanged(oldValue: number, newValue: number) {
+    this.render();
+  }
+
+  private onLowestAlphaChanged(oldValue: number, newValue: number) {
+    // 可根据需求添加逻辑
+  }
+
+  private onAlphaTicksPercentageChanged(oldValue: number, newValue: number) {
+    // 可根据需求添加逻辑
+  }
+
+  // 强制值回调方法
+  private coerceProgress(value: number) {
+    if (value < 0) return 0;
+    if (value > 100) return 100;
+    return value;
+  }
+
+  private coerceTickCount(value: number) {
+    if (value <= 0) return SprocketControl.DEFAULT_TICK_COUNT;
+    return value;
+  }
+
+  private coerceTickWidth(value: number) {
+    if (value < 0) return SprocketControl.DEFAULT_TICK_WIDTH;
+    return value;
+  }
+
+  private coerceLowestAlpha(value: number) {
+    if (value < SprocketControl.ALPHA_LOWER_LIMIT) return SprocketControl.ALPHA_LOWER_LIMIT;
+    if (value > SprocketControl.ALPHA_UPPER_LIMIT) return SprocketControl.ALPHA_UPPER_LIMIT;
+    return value;
+  }
+
+  private coerceAlphaTicksPercentage(value: number) {
+    if (value > 100) return 100;
+    if (value < SprocketControl.ALPHA_TICK_PERCENTAGE_LOWER_LIMIT) return SprocketControl.ALPHA_TICK_PERCENTAGE_LOWER_LIMIT;
+    return value;
+  }
+
+  // 销毁方法
+  dispose() {
+    this.stop();
+  }
+}

ant-design-pro-vue3/src/views/front/platfrom/presentation/PageFunctions/TradePage.ts

@@ -0,0 +1,135 @@
+// 定义相关类型
+interface TradeModel {}
+interface PageContainer {}
+interface IPage {
+    Dispose(): void;
+    OwnerContainer: PageContainer;
+    SetOwnerContainer(pageContainer: PageContainer): void;
+    InstanceId: string;
+    SetInstanceId(guid: string): void;
+    ViewStateData: { [key: string]: any };
+    SetViewStateData(viewStateData: { [key: string]: any }): void;
+}
+
+interface EventHandler {
+    (sender: any, e: any): void;
+}
+
+interface PropertyChangedEventHandler {
+    (sender: any, e: { propertyName: string }): void;
+}
+
+// 模拟辅助类
+class PageHelper {
+    static GetTradeModel(sender: any): TradeModel {
+        return {} as TradeModel;
+    }
+    static SetTradeModel(sender: any, value: TradeModel) {}
+    static SetOwnerPage(sender: any, page: any) {}
+    static GetViewStateData(sender: any): { [key: string]: any } {
+        return {};
+    }
+    static SetViewStateData(sender: any, viewStateData: { [key: string]: any }) {}
+}
+
+class PageContainerHelper {
+    static GetOwnerContainer(sender: any): PageContainer {
+        return {} as PageContainer;
+    }
+    static SetOwnerContainer(sender: any, pageContainer: PageContainer) {}
+    static GetInstanceId(sender: any): string {
+        return "";
+    }
+    static SetInstanceId(sender: any, guid: string) {}
+}
+
+class TradePage implements IPage {
+    private _ready: EventHandler | null = null;
+    private _propertyChanged: PropertyChangedEventHandler | null = null;
+
+    constructor() {
+        // 模拟加载事件
+        this.triggerLoad();
+    }
+
+    get TradeModel(): TradeModel {
+        return PageHelper.GetTradeModel(this);
+    }
+
+    set TradeModel(value: TradeModel) {
+        PageHelper.SetTradeModel(this, value);
+    }
+
+    get Ready() {
+        return {
+            add: (handler: EventHandler) => {
+                this._ready = handler;
+            },
+            remove: (handler: EventHandler) => {
+                if (this._ready === handler) {
+                    this._ready = null;
+                }
+            },
+        };
+    }
+
+    private triggerLoad() {
+        PageHelper.SetOwnerPage(this, this);
+        if (this._ready) {
+            this._ready(this, {});
+        }
+        this.onTradePageLoaded();
+    }
+
+    protected onTradePageLoaded() {}
+
+    Dispose() {}
+
+    get OwnerContainer(): PageContainer {
+        return PageContainerHelper.GetOwnerContainer(this);
+    }
+
+    SetOwnerContainer(pageContainer: PageContainer) {
+        PageContainerHelper.SetOwnerContainer(this, pageContainer);
+    }
+
+    get InstanceId(): string {
+        return PageContainerHelper.GetInstanceId(this);
+    }
+
+    SetInstanceId(guid: string) {
+        PageContainerHelper.SetInstanceId(this, guid);
+    }
+
+    get ViewStateData(): { [key: string]: any } {
+        return PageHelper.GetViewStateData(this);
+    }
+
+    SetViewStateData(viewStateData: { [key: string]: any }) {
+        if (!viewStateData) {
+            viewStateData = {};
+        }
+        PageHelper.SetViewStateData(this, viewStateData);
+    }
+
+    get PropertyChanged() {
+        return {
+            add: (handler: PropertyChangedEventHandler) => {
+                this._propertyChanged = handler;
+            },
+            remove: (handler: PropertyChangedEventHandler) => {
+                if (this._propertyChanged === handler) {
+                    this._propertyChanged = null;
+                }
+            },
+        };
+    }
+
+    protected raisePropertyChanged(propertyName: string) {
+        if (this._propertyChanged) {
+            this._propertyChanged(this, { propertyName });
+        }
+    }
+}
+
+export default TradePage;

ant-design-pro-vue3/src/views/front/platfrom/presentation/PagesHelper/PageContainerHelper.ts

@@ -0,0 +1,50 @@
+// 模拟 DependencyObject
+class DependencyObject {
+    // 这里只是简单模拟，实际可能需要更复杂的实现
+}
+
+// 模拟 PageContainer
+class PageContainer {
+    // 这里只是简单模拟，实际可能需要更复杂的实现
+}
+
+// 模拟 Guid
+class Guid {
+    static Empty = new Guid();
+}
+
+// 存储附加属性的值
+const attachedProperties = new WeakMap<DependencyObject, { [key: string]: any }>();
+
+export class PageContainerHelper {
+    private static readonly OwnerContainerKey = "OwnerContainer";
+    private static readonly InstanceIdKey = "InstanceId";
+
+    public static GetOwnerContainer(d: DependencyObject): PageContainer {
+        const props = attachedProperties.get(d);
+        return props ? props[this.OwnerContainerKey] as PageContainer : null;
+    }
+
+    public static SetOwnerContainer(d: DependencyObject, value: PageContainer): void {
+        let props = attachedProperties.get(d);
+        if (!props) {
+            props = {};
+            attachedProperties.set(d, props);
+        }
+        props[this.OwnerContainerKey] = value;
+    }
+
+    public static GetInstanceId(d: DependencyObject): Guid {
+        const props = attachedProperties.get(d);
+        return props ? props[this.InstanceIdKey] as Guid : Guid.Empty;
+    }
+
+    public static SetInstanceId(d: DependencyObject, value: Guid): void {
+        let props = attachedProperties.get(d);
+        if (!props) {
+            props = {};
+            attachedProperties.set(d, props);
+        }
+        props[this.InstanceIdKey] = value;
+    }
+}

ant-design-pro-vue3/src/views/front/platfrom/presentation/PagesHelper/PageHelper.ts

@@ -0,0 +1,51 @@
+// 假设 IPage 接口定义如下
+interface IPage {}
+
+// 假设 TradeModel 类型定义如下
+interface TradeModel {}
+
+// 定义一个全局对象来存储附加属性的值
+const attachedProperties = new WeakMap<object, { [key: string]: any }>();
+
+function getAttachedProperty<T>(obj: object, propertyName: string): T | undefined {
+    const properties = attachedProperties.get(obj);
+    return properties?.[propertyName];
+}
+
+function setAttachedProperty(obj: object, propertyName: string, value: any) {
+    let properties = attachedProperties.get(obj);
+    if (!properties) {
+        properties = {};
+        attachedProperties.set(obj, properties);
+    }
+    properties[propertyName] = value;
+}
+
+export class PageHelper {
+    // OwnerPage 附加属性
+    static get OwnerPageProperty() { return "OwnerPage"; }
+    static GetOwnerPage(d: object): IPage | undefined {
+        return getAttachedProperty<IPage>(d, this.OwnerPageProperty);
+    }
+    static SetOwnerPage(d: object, value: IPage) {
+        setAttachedProperty(d, this.OwnerPageProperty, value);
+    }
+
+    // ViewStateData 附加属性
+    static get ViewStateDataProperty() { return "ViewStateData"; }
+    static GetViewStateData(obj: object): Record<string, object> | undefined {
+        return getAttachedProperty<Record<string, object>>(obj, this.ViewStateDataProperty);
+    }
+    static SetViewStateData(obj: object, value: Record<string, object>) {
+        setAttachedProperty(obj, this.ViewStateDataProperty, value);
+    }
+
+    // TradeModel 附加属性
+    static get TradeModelProperty() { return "TradeModel"; }
+    static GetTradeModel(obj: object): TradeModel | undefined {
+        return getAttachedProperty<TradeModel>(obj, this.TradeModelProperty);
+    }
+    static SetTradeModel(obj: object, value: TradeModel) {
+        setAttachedProperty(obj, this.TradeModelProperty, value);
+    }
+}

ant-design-pro-vue3/src/views/front/platfrom/presentation/Themes/Generic.xaml

@@ -0,0 +1,8 @@
+<ResourceDictionary xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
+                    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
+                    xmlns:Presentation="clr-namespace:Platform.Presentation.PageFunctions">
+    <ResourceDictionary.MergedDictionaries>
+        <ResourceDictionary Source="/Platform.Presentation;component/Themes/PageContainer.Generic.xaml" />
+        <ResourceDictionary Source="/Platform.Presentation;component/Themes/TradePage.Generic.xaml"/>
+    </ResourceDictionary.MergedDictionaries>
+</ResourceDictionary>

ant-design-pro-vue3/src/views/front/platfrom/presentation/Themes/PageContainer.Generic.xaml

@@ -0,0 +1,76 @@
+<ResourceDictionary xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
+                    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
+                    xmlns:dhcc="http://www.dhcc.com.cn"
+                    xmlns:Presentation="clr-namespace:Platform.Presentation.PageFunctions">
+    <dhcc:BoolToVisibilityConverter x:Key="BoolToVisibility" />
+
+    <Style TargetType="Presentation:PageContainer">
+        <!--  PageContainer不设置FocusManager.EnableFocusControl附加属性，延迟由TradePage来指定  -->
+        <!--  <Setter Property="dhcc:FocusManager.EnableFocusControl" Value="true"/>  -->
+        <Setter Property="VerticalAlignment" Value="Stretch" />
+        <Setter Property="HorizontalAlignment" Value="Stretch" />
+        <Setter Property="Template">
+            <Setter.Value>
+                <ControlTemplate TargetType="Presentation:PageContainer">
+                    <Border>
+                        <Grid>
+                            <AdornerDecorator>
+                                <ContentPresenter Margin="{TemplateBinding BorderThickness}"
+                                              HorizontalAlignment="{TemplateBinding HorizontalAlignment}"
+                                              VerticalAlignment="{TemplateBinding VerticalAlignment}"
+                                              Content="{TemplateBinding Content}" />
+                            </AdornerDecorator>
+                            <Grid x:Name="Overlay"
+                                  Margin="0"
+                                  Background="#7F000000"
+                                  Opacity="1"
+                                  Visibility="{TemplateBinding IsOverlay, Converter={StaticResource BoolToVisibility}}" />
+                            <Border x:Name="BusyAdorner"
+                                    Tag="正在处理数据..."
+                                    Visibility="Collapsed">
+                                <Grid>
+                                    <Border Background="Black" Opacity="0.1" />
+                                    <!--  缓冲动画  -->
+                                    <Border HorizontalAlignment="Center"
+                                            VerticalAlignment="Center"
+                                            Background="White"
+                                            BorderBrush="Blue"
+                                            BorderThickness="2"
+                                            TextBlock.FontSize="20">
+                                        <StackPanel Margin="5" Orientation="Horizontal">
+                                            <Presentation:SprocketControl x:Name="sprocketControl"
+                                                                          Width="30"
+                                                                          Height="30"
+                                                                          HorizontalAlignment="Center"
+                                                                          VerticalAlignment="Top"
+                                                                          AlphaTicksPercentage="50"
+                                                                          Interval="100"
+                                                                          IsIndeterminate="False"
+                                                                          LowestAlpha="50"
+                                                                          StartAngle="-90"
+                                                                          TickColor="Blue"
+                                                                          TickCount="10"
+                                                                          TickWidth="3" />
+                                            <TextBlock VerticalAlignment="Center" Text="{Binding ElementName=BusyAdorner, Path=Tag}" />
+                                        </StackPanel>
+                                    </Border>
+                                </Grid>
+                            </Border>
+                        </Grid>
+                    </Border>
+                    <!--  不通过触发器触发缓冲动画  -->
+                    <!--
+                        <ControlTemplate.Triggers>
+                        <Trigger Property="IsBusy" Value="True">
+                        <Setter TargetName="cover" Property="Visibility" Value="Visible" />
+                        </Trigger>
+                        <Trigger Property="IsBusy" Value="False">
+                        <Setter TargetName="cover" Property="Visibility" Value="Collapsed" />
+                        </Trigger>
+                        </ControlTemplate.Triggers>
+                    -->
+                </ControlTemplate>
+            </Setter.Value>
+        </Setter>
+    </Style>
+</ResourceDictionary>

ant-design-pro-vue3/src/views/front/platfrom/presentation/Themes/TradePage.Generic.xaml

@@ -0,0 +1,29 @@
+<ResourceDictionary xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
+                    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
+                    xmlns:Presentation="clr-namespace:Platform.Presentation.PageFunctions">
+    <Style TargetType="{x:Type Presentation:TradePage}">
+        <Setter Property="HorizontalContentAlignment" Value="Stretch" />
+        <!--<Setter Property="FocusManager.IsFocusScope" Value="True" />-->
+        <Setter Property="KeyboardNavigation.TabNavigation" Value="None" />
+        <Setter Property="VerticalContentAlignment" Value="Stretch" />       
+        <Setter Property="Template">
+            <Setter.Value>
+                <ControlTemplate TargetType="{x:Type Presentation:TradePage}">
+                    <Border Background="{TemplateBinding Background}"
+                            BorderBrush="{TemplateBinding BorderBrush}"
+                            BorderThickness="{TemplateBinding BorderThickness}">
+                        <ContentPresenter HorizontalAlignment="{TemplateBinding HorizontalAlignment}"
+                                          VerticalAlignment="{TemplateBinding VerticalAlignment}"
+                                          Content="{TemplateBinding Content}" />
+                    </Border>
+                    <!--<ControlTemplate.Triggers>
+                        <EventTrigger RoutedEvent="Loaded">
+                            <BeginStoryboard Storyboard="{DynamicResource TradePage_Loaded_Storyboard}" />
+                        </EventTrigger>
+                    </ControlTemplate.Triggers>-->
+                </ControlTemplate>
+            </Setter.Value>
+        </Setter>
+        <!--<Setter Property="OpacityMask" Value="{DynamicResource TradePage_Transition_OpacityMask}" />-->
+    </Style>
+</ResourceDictionary>