MLightCAD
    Preparing search index...

    Class AcApPropertiesCmd

    Abstract base class for all CAD commands.

    This class provides the foundation for implementing CAD commands with:

    • Command name management (global and localized names)
    • Lifecycle event handling (command start/end)
    • Execution framework with context access
    • Event notification system

    Commands are the primary way users interact with the CAD system. Each command represents a specific operation like drawing lines, selecting objects, zooming, etc.

    1. Command is triggered via trigger() method
    2. AcEditor.commandWillStart event is fired
    3. execute() method is called with current context
    4. AcEditor.commandEnded event is fired
    class MyDrawCommand extends AcEdCommand {
      constructor() {
        super();
        this.globalName = 'DRAW';
        this.localName = 'Draw Line';
      }

      execute(context: AcApContext) {
        // Implement command logic here
        const view = context.view;
        const document = context.doc;
        // ... drawing logic
      }
    }

    // Usage
    const command = new MyDrawCommand();
    command.events.commandWillStart.addEventListener(args => {
      console.log('Command starting:', args.command.globalName);
    });
    command.trigger(context);

    Hierarchy (View Summary)

    Index

    Constructors

    constructor

    Accessors

    globalName localName mode userData

    Methods

    execute onCommandEnded onCommandWillStart trigger

    Constructors

    • Creates a new command instance.

      Initializes the command with empty names. Subclasses should set appropriate global and local names in their constructors.

      Returns AcApPropertiesCmd

    Accessors

    • get globalName(): string

      Gets the global (untranslated) name of the command.

      The global name is typically used for programmatic access and should remain consistent across different language localizations.

      Returns string

      The global command name

    • set globalName(value: string): void

      Sets the global (untranslated) name of the command.

      Parameters

      • value: string

        The global command name (e.g., 'LINE', 'CIRCLE', 'ZOOM')

      Returns void

    • get localName(): string

      Gets the local (translated) name of the command.

      The local name is displayed to users and should be localized to the current language/region.

      Returns string

      The localized command name

    • set localName(value: string): void

      Sets the local (translated) name of the command.

      Parameters

      • value: string

        The localized command name (e.g., 'Draw Line', 'Zoom In')

      Returns void

    • get mode(): AcEdOpenMode

      Gets the minimum access mode required to execute this command.

      Commands with higher mode requirements can only be executed when the document is opened in a compatible mode. Higher value modes are compatible with lower value modes.

      Returns AcEdOpenMode

      The minimum access mode required

    • set mode(value: AcEdOpenMode): void

      Sets the minimum access mode required to execute this command.

      Parameters

      • value: AcEdOpenMode

        The minimum access mode (Read, Review, or Write)

      Returns void

    • get userData(): TUserData

      Gets the custom user-defined data associated with this command.

      userData is a generic, strongly-typed container that allows consumers of the command to attach arbitrary metadata without modifying the command class itself.

      The shape of userData is defined by the generic parameter TUserData when the command is declared:

      Returns TUserData

      The user-defined data object associated with this command

      interface MyCommandData {
        sourceLayerId: string
        isPreview: boolean
      }

      class MyCommand extends AcEdCommand<MyCommandData> {}

      const cmd = new MyCommand()
      cmd.userData.sourceLayerId = 'Layer-01'
      cmd.userData.isPreview = true

      This design provides flexibility similar to THREE.Object3D.userData while preserving full compile-time type safety.

    Methods

    • Executes the command logic.

      This abstract method must be implemented by subclasses to define the specific behavior of the command. The method receives the current application context providing access to the view and document.

      Parameters

      Returns Promise<void>

      execute(context: AcApContext) {
        const view = context.view;
        const doc = context.doc;

        // Get user input
        const point = await view.editor.getPoint();

        // Create entity in document
        const entity = new SomeEntity(point);
        doc.database.addEntity(entity);
      }

    • Called after the command has finished executing.

      This lifecycle hook is intended for cleanup or follow-up logic, such as:

      • Releasing resources
      • Resetting editor state
      • Finalizing transactions

      The default implementation does nothing.

      Parameters

      Returns void

    • Called right before the command starts executing.

      This lifecycle hook is intended for subclasses that need to perform setup work before execute() runs, such as:

      • Initializing temporary state
      • Locking resources
      • Preparing UI or editor state

      The default implementation does nothing.

      Parameters

      Returns void

    • Triggers the command execution with proper event handling.

      This method should not be overridden by subclasses as it handles the event notification workflow. Subclasses should implement the execute() method instead.

      The execution flow:

      1. Fires commandWillStart event
      2. Calls the execute() method
      3. Fires commandEnded event

      Parameters

      • context: AcApContext

        The current application context containing view and document

      Returns Promise<void>

      const command = new MyCommand();
      command.trigger(docManager.context);

    Settings

    Member Visibility

    On This Page

    Command Lifecycle
    Constructors
    Accessors
    Methods