daggerheart/module/canvas/placeables/templateLayer.mjs

export default class DhTemplateLayer extends foundry.canvas.layers.TemplateLayer {
    static prepareSceneControls() {
        const sc = foundry.applications.ui.SceneControls;
        return {
            name: 'templates',
            order: 2,
            title: 'CONTROLS.GroupMeasure',
            icon: 'fa-solid fa-ruler-combined',
            visible: game.user.can('TEMPLATE_CREATE'),
            onChange: (event, active) => {
                if (active) canvas.templates.activate();
            },
            onToolChange: () => canvas.templates.setAllRenderFlags({ refreshState: true }),
            tools: {
                circle: {
                    name: 'circle',
                    order: 1,
                    title: 'CONTROLS.MeasureCircle',
                    icon: 'fa-regular fa-circle',
                    toolclip: {
                        src: 'toolclips/tools/measure-circle.webm',
                        heading: 'CONTROLS.MeasureCircle',
                        items: sc.buildToolclipItems(['create', 'move', 'edit', 'hide', 'delete'])
                    }
                },
                cone: {
                    name: 'cone',
                    order: 2,
                    title: 'CONTROLS.MeasureCone',
                    icon: 'fa-solid fa-angle-left',
                    toolclip: {
                        src: 'toolclips/tools/measure-cone.webm',
                        heading: 'CONTROLS.MeasureCone',
                        items: sc.buildToolclipItems(['create', 'move', 'edit', 'hide', 'delete', 'rotate'])
                    }
                },
                inFront: {
                    name: 'inFront',
                    order: 3,
                    title: 'CONTROLS.inFront',
                    icon: 'fa-solid fa-eye',
                    toolclip: {
                        src: 'toolclips/tools/measure-cone.webm',
                        heading: 'CONTROLS.inFront',
                        items: sc.buildToolclipItems(['create', 'move', 'edit', 'hide', 'delete', 'rotate'])
                    }
                },
                rect: {
                    name: 'rect',
                    order: 4,
                    title: 'CONTROLS.MeasureRect',
                    icon: 'fa-solid fa-square',
                    toolclip: {
                        src: 'toolclips/tools/measure-rect.webm',
                        heading: 'CONTROLS.MeasureRect',
                        items: sc.buildToolclipItems(['create', 'move', 'edit', 'hide', 'delete', 'rotate'])
                    }
                },
                ray: {
                    name: 'ray',
                    order: 5,
                    title: 'CONTROLS.MeasureRay',
                    icon: 'fa-solid fa-up-down',
                    toolclip: {
                        src: 'toolclips/tools/measure-ray.webm',
                        heading: 'CONTROLS.MeasureRay',
                        items: sc.buildToolclipItems(['create', 'move', 'edit', 'hide', 'delete', 'rotate'])
                    }
                },
                presets: {
                    name: 'presets',
                    order: 6,
                    title: 'CONTROLS.Presets',
                    icon: 'fa-solid fa-stamp',
                    onChange: (event) => DhTemplateLayer.handlePreset(event),
                    button: true
                },
                settings: {
                    name: 'settings',
                    order: 7,
                    title: 'CONTROLS.PresetsSettings',
                    icon: 'fa-solid fa-gear',
                    onChange: (event) => DhTemplateLayer.handlePresetSettings(event),
                    button: true
                },
                clear: {
                    name: 'clear',
                    order: 8,
                    title: 'CONTROLS.MeasureClear',
                    icon: 'fa-solid fa-trash',
                    visible: game.user.isGM,
                    onChange: () => canvas.templates.deleteAll(),
                    button: true
                }
            },
            activeTool: 'circle'
        };
    }

    static handlePresetSettings(event) {
        console.log("Preset settings handling goes here, event, active is: ", event);
        ui.presetTemplates.open();
    }


    static handlePreset(event, active) {
        console.log("Preset handling goes here, event, active is: ", event, active);
        if (game.activeTool) {
            ui.controls.activate("toggles");
        }
        // if (CONFIG.ux.TemplateManager.getActivePreview()) {
        //     return;
        // }
        const { width, height } = game.canvas.scene.dimensions;
        const data = {
            x: width / 2,
            y: height / 2,
            t: 'circle',
            distance: 30,
            fillColor: game.user.color || '#FF0000'
        };

        CONFIG.ux.TemplateManager.createPreview(data);
    }

    _onDragLeftStart(event) {
        const interaction = event.interactionData;

        // Snap the origin to the grid
        if (!event.shiftKey) interaction.origin = this.getSnappedPoint(interaction.origin);

        // Create a pending MeasuredTemplateDocument
        const tool = game.activeTool === 'inFront' ? 'cone' : game.activeTool;
        const previewData = {
            user: game.user.id,
            t: tool,
            x: interaction.origin.x,
            y: interaction.origin.y,
            sort: Math.max(this.getMaxSort() + 1, 0),
            distance: 1,
            direction: 0,
            fillColor: game.user.color || '#FF0000',
            hidden: event.altKey
        };
        const defaults = CONFIG.MeasuredTemplate.defaults;
        if (game.activeTool === 'cone') previewData.angle = defaults.angle;
        else if (game.activeTool === 'inFront') previewData.angle = 180;
        else if (game.activeTool === 'ray') previewData.width = defaults.width * canvas.dimensions.distance;
        const cls = foundry.utils.getDocumentClass('MeasuredTemplate');
        const doc = new cls(previewData, { parent: canvas.scene });

        // Create a preview MeasuredTemplate object
        const template = new this.constructor.placeableClass(doc);
        doc._object = template;
        interaction.preview = this.preview.addChild(template);
        template.draw();
    }
}