edit.js

//  edit.js
//
//  Created by Brad Hefta-Gaub on 10/2/14.
//  Persist toolbar by HRS 6/11/15.
//  Copyright 2014 High Fidelity, Inc.
//
//  This script allows you to edit entities with a new UI/UX for mouse and trackpad based editing
//
//  Distributed under the Apache License, Version 2.0.
//  See the accompanying file LICENSE or http://www.apache.org/licenses/LICENSE-2.0.html
//

/* global Script, SelectionDisplay, LightOverlayManager, CameraManager, Grid, GridTool, EntityListTool, Vec3, SelectionManager,
   Overlays, OverlayWebWindow, UserActivityLogger, Settings, Entities, Tablet, Toolbars, Messages, Menu, Camera,
   progressDialog, tooltip, MyAvatar, Quat, Controller, Clipboard, HMD, UndoStack, OverlaySystemWindow,
   keyUpEventFromUIWindow:true */

(function() { // BEGIN LOCAL_SCOPE

"use strict";

var EDIT_TOGGLE_BUTTON = "com.highfidelity.interface.system.editButton";

var CONTROLLER_MAPPING_NAME = "com.highfidelity.editMode";

Script.include([
    "../libraries/stringHelpers.js",
    "../libraries/dataViewHelpers.js",
    "../libraries/progressDialog.js",
    "../libraries/ToolTip.js",
    "../libraries/entityCameraTool.js",
    "../libraries/utils.js",
    "../libraries/entityIconOverlayManager.js",
    "../libraries/gridTool.js",
    "entityList/entityList.js",
    "entitySelectionTool/entitySelectionTool.js"
]);

var CreateWindow = Script.require('./modules/createWindow.js');

var TITLE_OFFSET = 60;
var CREATE_TOOLS_WIDTH = 490;
var MAX_DEFAULT_ENTITY_LIST_HEIGHT = 942;

var DEFAULT_IMAGE = "https://hifi-content.s3.amazonaws.com/DomainContent/production/no-image.jpg";

var createToolsWindow = new CreateWindow(
    Script.resolvePath("qml/EditTools.qml"),
    'Create Tools',
    'com.highfidelity.create.createToolsWindow',
    function () {
        var windowHeight = Window.innerHeight - TITLE_OFFSET;
        if (windowHeight > MAX_DEFAULT_ENTITY_LIST_HEIGHT) {
            windowHeight = MAX_DEFAULT_ENTITY_LIST_HEIGHT;
        }
        return {
            size: {
                x: CREATE_TOOLS_WIDTH,
                y: windowHeight
            },
            position: {
                x: Window.x + Window.innerWidth - CREATE_TOOLS_WIDTH,
                y: Window.y + TITLE_OFFSET
            }
        }
    },
    false
);

/**
 * @description Returns true in case we should use the tablet version of the CreateApp
 * @returns boolean
 */
var shouldUseEditTabletApp = function() {
    return HMD.active || (!HMD.active && !Settings.getValue("desktopTabletBecomesToolbar", true));
};


var selectionDisplay = SelectionDisplay;
var selectionManager = SelectionManager;

var PARTICLE_SYSTEM_URL = Script.resolvePath("assets/images/icon-particles.svg");
var POINT_LIGHT_URL = Script.resolvePath("assets/images/icon-point-light.svg");
var SPOT_LIGHT_URL = Script.resolvePath("assets/images/icon-spot-light.svg");
var ZONE_URL = Script.resolvePath("assets/images/icon-zone.svg");

var entityIconOverlayManager = new EntityIconOverlayManager(['Light', 'ParticleEffect', 'Zone'], function(entityID) {
    var properties = Entities.getEntityProperties(entityID, ['type', 'isSpotlight']);
    if (properties.type === 'Light') {
        return {
            url: properties.isSpotlight ? SPOT_LIGHT_URL : POINT_LIGHT_URL,
        };
    } else if (properties.type === 'Zone') {
        return {
            url: ZONE_URL,
        };
    } else {
        return {
            url: PARTICLE_SYSTEM_URL,
        };
    }
});

var cameraManager = new CameraManager();

var grid = new Grid();
var gridTool = new GridTool({
    horizontalGrid: grid,
    createToolsWindow: createToolsWindow,
    shouldUseEditTabletApp: shouldUseEditTabletApp
});
gridTool.setVisible(false);

var EntityShapeVisualizer = Script.require('./modules/entityShapeVisualizer.js');
var entityShapeVisualizer = new EntityShapeVisualizer(["Zone"]);

var entityListTool = new EntityListTool(shouldUseEditTabletApp);

selectionManager.addEventListener(function () {
    selectionDisplay.updateHandles();
    entityIconOverlayManager.updatePositions();
    entityShapeVisualizer.setEntities(selectionManager.selections);
});

var DEGREES_TO_RADIANS = Math.PI / 180.0;
var RADIANS_TO_DEGREES = 180.0 / Math.PI;

var MIN_ANGULAR_SIZE = 2;
var MAX_ANGULAR_SIZE = 45;
var allowLargeModels = true;
var allowSmallModels = true;

var DEFAULT_DIMENSION = 0.20;

var DEFAULT_DIMENSIONS = {
    x: DEFAULT_DIMENSION,
    y: DEFAULT_DIMENSION,
    z: DEFAULT_DIMENSION
};

var DEFAULT_LIGHT_DIMENSIONS = Vec3.multiply(20, DEFAULT_DIMENSIONS);

var MENU_AUTO_FOCUS_ON_SELECT = "Auto Focus on Select";
var MENU_EASE_ON_FOCUS = "Ease Orientation on Focus";
var MENU_SHOW_LIGHTS_AND_PARTICLES_IN_EDIT_MODE = "Show Lights and Particle Systems in Create Mode";
var MENU_SHOW_ZONES_IN_EDIT_MODE = "Show Zones in Create Mode";

var MENU_CREATE_ENTITIES_GRABBABLE = "Create Entities As Grabbable (except Zones, Particles, and Lights)";
var MENU_ALLOW_SELECTION_LARGE = "Allow Selecting of Large Models";
var MENU_ALLOW_SELECTION_SMALL = "Allow Selecting of Small Models";
var MENU_ALLOW_SELECTION_LIGHTS = "Allow Selecting of Lights";

var SETTING_AUTO_FOCUS_ON_SELECT = "autoFocusOnSelect";
var SETTING_EASE_ON_FOCUS = "cameraEaseOnFocus";
var SETTING_SHOW_LIGHTS_AND_PARTICLES_IN_EDIT_MODE = "showLightsAndParticlesInEditMode";
var SETTING_SHOW_ZONES_IN_EDIT_MODE = "showZonesInEditMode";

var SETTING_EDIT_PREFIX = "Edit/";


var CREATE_ENABLED_ICON = "icons/tablet-icons/edit-i.svg";
var CREATE_DISABLED_ICON = "icons/tablet-icons/edit-disabled.svg";

// marketplace info, etc.  not quite ready yet.
var SHOULD_SHOW_PROPERTY_MENU = false;
var INSUFFICIENT_PERMISSIONS_ERROR_MSG = "You do not have the necessary permissions to edit on this domain.";
var INSUFFICIENT_PERMISSIONS_IMPORT_ERROR_MSG = "You do not have the necessary permissions to place items on this domain.";

var isActive = false;
var createButton = null;

var IMPORTING_SVO_OVERLAY_WIDTH = 144;
var IMPORTING_SVO_OVERLAY_HEIGHT = 30;
var IMPORTING_SVO_OVERLAY_MARGIN = 5;
var IMPORTING_SVO_OVERLAY_LEFT_MARGIN = 34;
var importingSVOImageOverlay = Overlays.addOverlay("image", {
    imageURL: Script.resolvePath("assets/images/hourglass.svg"),
    width: 20,
    height: 20,
    alpha: 1.0,
    x: Window.innerWidth - IMPORTING_SVO_OVERLAY_WIDTH,
    y: Window.innerHeight - IMPORTING_SVO_OVERLAY_HEIGHT,
    visible: false
});
var importingSVOTextOverlay = Overlays.addOverlay("text", {
    font: {
        size: 14
    },
    text: "Importing SVO...",
    leftMargin: IMPORTING_SVO_OVERLAY_LEFT_MARGIN,
    x: Window.innerWidth - IMPORTING_SVO_OVERLAY_WIDTH - IMPORTING_SVO_OVERLAY_MARGIN,
    y: Window.innerHeight - IMPORTING_SVO_OVERLAY_HEIGHT - IMPORTING_SVO_OVERLAY_MARGIN,
    width: IMPORTING_SVO_OVERLAY_WIDTH,
    height: IMPORTING_SVO_OVERLAY_HEIGHT,
    backgroundColor: {
        red: 80,
        green: 80,
        blue: 80
    },
    backgroundAlpha: 0.7,
    visible: false
});

var MARKETPLACE_URL = Account.metaverseServerURL + "/marketplace";
var marketplaceWindow = new OverlayWebWindow({
    title: 'Marketplace',
    source: "about:blank",
    width: 900,
    height: 700,
    visible: false
});

function showMarketplace(marketplaceID) {
    var url = MARKETPLACE_URL;
    if (marketplaceID) {
        url = url + "/items/" + marketplaceID;
    }
    marketplaceWindow.setURL(url);
    marketplaceWindow.setVisible(true);
    marketplaceWindow.raise();

    UserActivityLogger.logAction("opened_marketplace");
}

function hideMarketplace() {
    marketplaceWindow.setVisible(false);
    marketplaceWindow.setURL("about:blank");
}

// function toggleMarketplace() {
//     if (marketplaceWindow.visible) {
//         hideMarketplace();
//     } else {
//         showMarketplace();
//     }
// }

function adjustPositionPerBoundingBox(position, direction, registration, dimensions, orientation) {
    // Adjust the position such that the bounding box (registration, dimensions and orientation) lies behind the original
    // position in the given direction.
    var CORNERS = [
        { x: 0, y: 0, z: 0 },
        { x: 0, y: 0, z: 1 },
        { x: 0, y: 1, z: 0 },
        { x: 0, y: 1, z: 1 },
        { x: 1, y: 0, z: 0 },
        { x: 1, y: 0, z: 1 },
        { x: 1, y: 1, z: 0 },
        { x: 1, y: 1, z: 1 },
    ];

    // Go through all corners and find least (most negative) distance in front of position.
    var distance = 0;
    for (var i = 0, length = CORNERS.length; i < length; i++) {
        var cornerVector =
            Vec3.multiplyQbyV(orientation, Vec3.multiplyVbyV(Vec3.subtract(CORNERS[i], registration), dimensions));
        var cornerDistance = Vec3.dot(cornerVector, direction);
        distance = Math.min(cornerDistance, distance);
    }
    position = Vec3.sum(Vec3.multiply(distance, direction), position);
    return position;
}

var GRABBABLE_ENTITIES_MENU_CATEGORY = "Edit";

// Handles any edit mode updates required when domains have switched
function checkEditPermissionsAndUpdate() {
    if ((createButton === null) || (createButton === undefined)) {
        //--EARLY EXIT--( nothing to safely update )
        return;
    }

    var hasRezPermissions = (Entities.canRez() || Entities.canRezTmp() || Entities.canRezCertified() || Entities.canRezTmpCertified());
    createButton.editProperties({
        icon: (hasRezPermissions ? CREATE_ENABLED_ICON : CREATE_DISABLED_ICON),
        captionColor: (hasRezPermissions ? "#ffffff" : "#888888"),
    });

    if (!hasRezPermissions && isActive) {
        that.setActive(false);
        tablet.gotoHomeScreen();
    }
}

// Copies the properties in `b` into `a`. `a` will be modified.
function copyProperties(a, b) {
    for (var key in b) {
        a[key] = b[key];
    }
    return a;
}

const DEFAULT_DYNAMIC_PROPERTIES = {
    dynamic: true,
    damping: 0.39347,
    angularDamping: 0.39347,
    gravity: { x: 0, y: -9.8, z: 0 },
};

const DEFAULT_NON_DYNAMIC_PROPERTIES = {
    dynamic: false,
    damping: 0,
    angularDamping: 0,
    gravity: { x: 0, y: 0, z: 0 },
};

const DEFAULT_ENTITY_PROPERTIES = {
    All: {
        description: "",
        rotation: { x: 0, y: 0, z: 0, w: 1 },
        collidesWith: "static,dynamic,kinematic,otherAvatar,myAvatar",
        collisionSoundURL: "",
        cloneable: false,
        ignoreIK: true,
        canCastShadow: true,
        href: "",
        script: "",
        serverScripts:"",
        velocity: {
            x: 0,
            y: 0,
            z: 0
        },
        angularVelocity: {
            x: 0,
            y: 0,
            z: 0
        },
        restitution: 0.5,
        friction: 0.5,
        density: 1000,
        dynamic: false,
    },
    Shape: {
        shape: "Box",
        dimensions: { x: 0.2, y: 0.2, z: 0.2 },
        color: { red: 0, green: 180, blue: 239 },
    },
    Text: {
        text: "Text",
        dimensions: {
            x: 0.65,
            y: 0.3,
            z: 0.01
        },
        textColor: { red: 255, green: 255, blue: 255 },
        backgroundColor: { red: 0, green: 0, blue: 0 },
        lineHeight: 0.06,
        faceCamera: false,
    },
    Zone: {
        dimensions: {
            x: 10,
            y: 10,
            z: 10
        },
        flyingAllowed: true,
        ghostingAllowed: true,
        filter: "",
        keyLightMode: "inherit",
        keyLightColor: { red: 255, green: 255, blue: 255 },
        keyLight: {
            intensity: 1.0,
            direction: {
                x: 0.0,
                y: -0.707106769084930, // 45 degrees
                z: 0.7071067690849304
            },
            castShadows: true
        },
        ambientLightMode: "inherit",
        ambientLight: {
            ambientIntensity: 0.5,
            ambientURL: ""
        },
        hazeMode: "inherit",
        haze: {
            hazeRange: 1000,
            hazeAltitudeEffect: false,
            hazeBaseRef: 0,
            hazeColor: {
                red: 128,
                green: 154,
                blue: 179
            },
            hazeBackgroundBlend: 0,
            hazeEnableGlare: false,
            hazeGlareColor: {
                red: 255,
                green: 229,
                blue: 179
            },
        },
        shapeType: "box",
        bloomMode: "inherit",
        avatarPriority: "inherit",
        screenshare: "inherit",
    },
    Model: {
        collisionShape: "none",
        compoundShapeURL: "",
        animation: {
            url: "",
            running: false,
            allowTranslation: false,
            loop: true,
            hold: false,
            currentFrame: 0,
            firstFrame: 0,
            lastFrame: 100000,
            fps: 30.0,
        }
    },
    Image: {
        dimensions: {
            x: 0.5385,
            y: 0.2819,
            z: 0.0092
        },
        shapeType: "box",
        collisionless: true,
        keepAspectRatio: false,
        imageURL: DEFAULT_IMAGE
    },
    Web: {
        dimensions: {
            x: 1.6,
            y: 0.9,
            z: 0.01
        },
        sourceUrl: "https://highfidelity.com/",
        dpi: 30,
    },
    ParticleEffect: {
        lifespan: 1.5,
        maxParticles: 10,
        textures: "https://content.highfidelity.com/DomainContent/production/Particles/wispy-smoke.png",
        emitRate: 5.5,
        emitSpeed: 0,
        speedSpread: 0,
        emitDimensions: { x: 0, y: 0, z: 0 },
        emitOrientation: { x: 0, y: 0, z: 0, w: 1 },
        emitterShouldTrail: true,
        particleRadius: 0.25,
        radiusStart: 0,
        radiusSpread: 0,
        particleColor: {
            red: 255,
            green: 255,
            blue: 255
        },
        colorSpread: {
            red: 0,
            green: 0,
            blue: 0
        },
        alpha: 0,
        alphaStart: 1,
        alphaSpread: 0,
        emitAcceleration: {
            x: 0,
            y: 2.5,
            z: 0
        },
        accelerationSpread: {
            x: 0,
            y: 0,
            z: 0
        },
        particleSpin: 0,
        spinSpread: 0,
        rotateWithEntity: false,
        polarStart: 0,
        polarFinish: Math.PI,
        azimuthStart: -Math.PI,
        azimuthFinish: Math.PI
    },
    Light: {
        color: { red: 255, green: 255, blue: 255 },
        intensity: 5.0,
        dimensions: DEFAULT_LIGHT_DIMENSIONS,
        falloffRadius: 1.0,
        isSpotlight: false,
        exponent: 1.0,
        cutoff: 75.0,
    },
};

var toolBar = (function () {
    var EDIT_SETTING = "io.highfidelity.isEditing"; // for communication with other scripts
    var that = {},
        toolBar,
        activeButton = null,
        systemToolbar = null,
        dialogWindow = null,
        tablet = null;

    function createNewEntity(requestedProperties) {
        var dimensions = requestedProperties.dimensions ? requestedProperties.dimensions : DEFAULT_DIMENSIONS;
        var position = getPositionToCreateEntity();
        var entityID = null;

        var properties = {};

        copyProperties(properties, DEFAULT_ENTITY_PROPERTIES.All);

        var type = requestedProperties.type;
        if (type === "Box" || type === "Sphere") {
            copyProperties(properties, DEFAULT_ENTITY_PROPERTIES.Shape);
        } else {
            copyProperties(properties, DEFAULT_ENTITY_PROPERTIES[type]);
        }

        // We apply the requested properties first so that they take priority over any default properties.
        copyProperties(properties, requestedProperties);

        if (properties.dynamic) {
            copyProperties(properties, DEFAULT_DYNAMIC_PROPERTIES);
        } else {
            copyProperties(properties, DEFAULT_NON_DYNAMIC_PROPERTIES);
        }


        if (position !== null && position !== undefined) {
            var direction;
            if (Camera.mode === "entity" || Camera.mode === "independent") {
                direction = Camera.orientation;
            } else {
                direction = MyAvatar.orientation;
            }
            direction = Vec3.multiplyQbyV(direction, Vec3.UNIT_Z);

            var PRE_ADJUST_ENTITY_TYPES = ["Box", "Sphere", "Shape", "Text", "Image", "Web", "Material"];
            if (PRE_ADJUST_ENTITY_TYPES.indexOf(properties.type) !== -1) {

                // Adjust position of entity per bounding box prior to creating it.
                var registration = properties.registration;
                if (registration === undefined) {
                    var DEFAULT_REGISTRATION = { x: 0.5, y: 0.5, z: 0.5 };
                    registration = DEFAULT_REGISTRATION;
                }

                var orientation = properties.orientation;
                if (orientation === undefined) {
                    properties.orientation = MyAvatar.orientation;
                    var DEFAULT_ORIENTATION = properties.orientation;
                    orientation = DEFAULT_ORIENTATION;
                } else {
                    // If the orientation is already defined, we perform the corresponding rotation assuming that
                    //  our start referential is the avatar referential.
                    properties.orientation = Quat.multiply(MyAvatar.orientation, properties.orientation);
                    var DEFAULT_ORIENTATION = properties.orientation;
                    orientation = DEFAULT_ORIENTATION;
                }

                position = adjustPositionPerBoundingBox(position, direction, registration, dimensions, orientation);
            }

            position = grid.snapToSurface(grid.snapToGrid(position, false, dimensions), dimensions);
            properties.position = position;

            if (!properties.grab) {
                properties.grab = {};
                if (Menu.isOptionChecked(MENU_CREATE_ENTITIES_GRABBABLE) &&
                    !(properties.type === "Zone" || properties.type === "Light"
                    || properties.type === "ParticleEffect" || properties.type === "Web")) {
                    properties.grab.grabbable = true;
                } else {
                    properties.grab.grabbable = false;
                }
            }

            if (type === "Model") {
                properties.visible = false;
            }

            entityID = Entities.addEntity(properties);

            var dimensionsCheckCallback = function(){
                var POST_ADJUST_ENTITY_TYPES = ["Model"];
                if (POST_ADJUST_ENTITY_TYPES.indexOf(properties.type) !== -1) {
                    // Adjust position of entity per bounding box after it has been created and auto-resized.
                    var initialDimensions = Entities.getEntityProperties(entityID, ["dimensions"]).dimensions;
                    var DIMENSIONS_CHECK_INTERVAL = 200;
                    var MAX_DIMENSIONS_CHECKS = 10;
                    var dimensionsCheckCount = 0;
                    var dimensionsCheckFunction = function () {
                        dimensionsCheckCount++;
                        var properties = Entities.getEntityProperties(entityID, ["dimensions", "registrationPoint", "rotation"]);
                        if (!Vec3.equal(properties.dimensions, initialDimensions)) {
                            position = adjustPositionPerBoundingBox(position, direction, properties.registrationPoint,
                                properties.dimensions, properties.rotation);
                            position = grid.snapToSurface(grid.snapToGrid(position, false, properties.dimensions),
                                properties.dimensions);
                            Entities.editEntity(entityID, {
                                position: position
                            });
                            selectionManager._update(false, this);
                        } else if (dimensionsCheckCount < MAX_DIMENSIONS_CHECKS) {
                            Script.setTimeout(dimensionsCheckFunction, DIMENSIONS_CHECK_INTERVAL);
                        }
                    };
                    Script.setTimeout(dimensionsCheckFunction, DIMENSIONS_CHECK_INTERVAL);
                }
            }
            // Make sure the entity is loaded before we try to figure out
            // its dimensions.
            var MAX_LOADED_CHECKS = 10;
            var LOADED_CHECK_INTERVAL = 100;
            var isLoadedCheckCount = 0;
            var entityIsLoadedCheck = function() {
                isLoadedCheckCount++;
                if (isLoadedCheckCount === MAX_LOADED_CHECKS || Entities.isLoaded(entityID)) {
                    var naturalDimensions = Entities.getEntityProperties(entityID, "naturalDimensions").naturalDimensions
                    Entities.editEntity(entityID, {
                        visible: true,
                        dimensions: naturalDimensions
                    })
                    dimensionsCheckCallback();
                    return;
                }
                Script.setTimeout(entityIsLoadedCheck, LOADED_CHECK_INTERVAL);
            }
            Script.setTimeout(entityIsLoadedCheck, LOADED_CHECK_INTERVAL);

            SelectionManager.addEntity(entityID, false, this);
            SelectionManager.saveProperties();
            pushCommandForSelections([{
                entityID: entityID,
                properties: properties
            }], [], true);

        } else {
            Window.notifyEditError("Can't create " + properties.type + ": " +
                                   properties.type + " would be out of bounds.");
        }

        selectionManager.clearSelections(this);
        entityListTool.sendUpdate();
        selectionManager.setSelections([entityID], this);

        Window.setFocus();

        return entityID;
    }

    function closeExistingDialogWindow() {
        if (dialogWindow) {
            dialogWindow.close();
            dialogWindow = null;
        }
    }

    function cleanup() {
        that.setActive(false);
        if (tablet) {
            tablet.removeButton(activeButton);
        }
        if (systemToolbar) {
            systemToolbar.removeButton(EDIT_TOGGLE_BUTTON);
        }
    }

    var buttonHandlers = {}; // only used to tablet mode

    function addButton(name, handler) {
        buttonHandlers[name] = handler;
    }

    var SHAPE_TYPE_NONE = 0;
    var SHAPE_TYPE_SIMPLE_HULL = 1;
    var SHAPE_TYPE_SIMPLE_COMPOUND = 2;
    var SHAPE_TYPE_STATIC_MESH = 3;
    var SHAPE_TYPE_BOX = 4;
    var SHAPE_TYPE_SPHERE = 5;
    var DYNAMIC_DEFAULT = false;

    var MATERIAL_MODE_UV = 0;
    var MATERIAL_MODE_PROJECTED = 1;

    function handleNewModelDialogResult(result) {
        if (result) {
            var url = result.url;
            var shapeType;
            switch (result.collisionShapeIndex) {
            case SHAPE_TYPE_SIMPLE_HULL:
                shapeType = "simple-hull";
                break;
            case SHAPE_TYPE_SIMPLE_COMPOUND:
                shapeType = "simple-compound";
                break;
            case SHAPE_TYPE_STATIC_MESH:
                shapeType = "static-mesh";
                break;
            case SHAPE_TYPE_BOX:
                shapeType = "box";
                break;
            case SHAPE_TYPE_SPHERE:
                shapeType = "sphere";
                break;
            default:
                shapeType = "none";
            }

            var dynamic = result.dynamic !== null ? result.dynamic : DYNAMIC_DEFAULT;
            if (shapeType === "static-mesh" && dynamic) {
                // The prompt should prevent this case
                print("Error: model cannot be both static mesh and dynamic.  This should never happen.");
            } else if (url) {
                createNewEntity({
                    type: "Model",
                    modelURL: url,
                    shapeType: shapeType,
                    grab: {
                        grabbable: result.grabbable
                    },
                    dynamic: dynamic,
                });
            }
        }
    }

    function handleNewMaterialDialogResult(result) {
        if (result) {
            var materialURL = result.textInput;
            //var materialMappingMode;
            //switch (result.comboBox) {
            //    case MATERIAL_MODE_PROJECTED:
            //        materialMappingMode = "projected";
            //        break;
            //    default:
            //        shapeType = "uv";
            //}
            var materialData = "";
            if (materialURL.startsWith("materialData")) {
                materialData = JSON.stringify({
                    "materials": {}
                });
            }

            var DEFAULT_LAYERED_MATERIAL_PRIORITY = 1;
            if (materialURL) {
                createNewEntity({
                    type: "Material",
                    materialURL: materialURL,
                    //materialMappingMode: materialMappingMode,
                    priority: DEFAULT_LAYERED_MATERIAL_PRIORITY,
                    materialData: materialData
                });
            }
        }
    }

    function fromQml(message) { // messages are {method, params}, like json-rpc. See also sendToQml.
        var tablet = Tablet.getTablet("com.highfidelity.interface.tablet.system");
        tablet.popFromStack();
        switch (message.method) {
            case "newModelDialogAdd":
                handleNewModelDialogResult(message.params);
                closeExistingDialogWindow();
                break;
            case "newModelDialogCancel":
                closeExistingDialogWindow();
                break;
            case "newEntityButtonClicked":
                buttonHandlers[message.params.buttonName]();
                break;
            case "newMaterialDialogAdd":
                handleNewMaterialDialogResult(message.params);
                closeExistingDialogWindow();
                break;
            case "newMaterialDialogCancel":
                closeExistingDialogWindow();
                break;
        }
    }

    var entitiesToDelete = [];
    var deletedEntityTimer = null;
    var DELETE_ENTITY_TIMER_TIMEOUT = 100;

    function checkDeletedEntityAndUpdate(entityID) {
        // Allow for multiple entity deletes before updating the entities selected.
        entitiesToDelete.push(entityID);
        if (deletedEntityTimer !== null) {
            Script.clearTimeout(deletedEntityTimer);
        }
        deletedEntityTimer = Script.setTimeout(function () {
            if (entitiesToDelete.length > 0) {
                selectionManager.removeEntities(entitiesToDelete, this);
            }
            entityListTool.removeEntities(entitiesToDelete, selectionManager.selections);
            entitiesToDelete = [];
            deletedEntityTimer = null;
        }, DELETE_ENTITY_TIMER_TIMEOUT);
    }

    function initialize() {
        Script.scriptEnding.connect(cleanup);
        Window.domainChanged.connect(function () {
            if (isActive) {
                tablet.gotoHomeScreen();
            }
            that.setActive(false);
            that.clearEntityList();
            checkEditPermissionsAndUpdate();
        });

        HMD.displayModeChanged.connect(function() {
            if (isActive) {
                tablet.gotoHomeScreen();
            }
            that.setActive(false);
        });

        Entities.canAdjustLocksChanged.connect(function (canAdjustLocks) {
            if (isActive && !canAdjustLocks) {
                that.setActive(false);
            }
            checkEditPermissionsAndUpdate();
        });

        Entities.canRezChanged.connect(checkEditPermissionsAndUpdate);
        Entities.canRezTmpChanged.connect(checkEditPermissionsAndUpdate);
        Entities.canRezCertifiedChanged.connect(checkEditPermissionsAndUpdate);
        Entities.canRezTmpCertifiedChanged.connect(checkEditPermissionsAndUpdate);
        var hasRezPermissions = (Entities.canRez() || Entities.canRezTmp() || Entities.canRezCertified() || Entities.canRezTmpCertified());

        Entities.deletingEntity.connect(checkDeletedEntityAndUpdate);

        var createButtonIconRsrc = (hasRezPermissions ? CREATE_ENABLED_ICON : CREATE_DISABLED_ICON);
        tablet = Tablet.getTablet("com.highfidelity.interface.tablet.system");
        activeButton = tablet.addButton({
            captionColor: hasRezPermissions ? "#ffffff" : "#888888",
            icon: createButtonIconRsrc,
            activeIcon: "icons/tablet-icons/edit-a.svg",
            text: "CREATE",
            sortOrder: 10
        });
        createButton = activeButton;
        tablet.screenChanged.connect(function (type, url) {
            var isGoingToHomescreenOnDesktop = (!shouldUseEditTabletApp() &&
                (url === 'hifi/tablet/TabletHome.qml' || url === ''));
            if (isActive && (type !== "QML" || url !== Script.resolvePath("qml/Edit.qml")) && !isGoingToHomescreenOnDesktop) {
                that.setActive(false);
            }
        });
        tablet.fromQml.connect(fromQml);
        createToolsWindow.fromQml.addListener(fromQml);

        createButton.clicked.connect(function() {
            if ( ! (Entities.canRez() || Entities.canRezTmp() || Entities.canRezCertified() || Entities.canRezTmpCertified()) ) {
                Window.notifyEditError(INSUFFICIENT_PERMISSIONS_ERROR_MSG);
                return;
            }

            that.toggle();
        });

        addButton("importEntitiesButton", function() {
            Window.browseChanged.connect(onFileOpenChanged);
            Window.browseAsync("Select Model to Import", "", "*.json");
        });

        addButton("openAssetBrowserButton", function() {
            Window.showAssetServer();
        });
        function createNewEntityDialogButtonCallback(entityType) {
            return function() {
                if (shouldUseEditTabletApp()) {
                    // tablet version of new-model dialog
                    var tablet = Tablet.getTablet("com.highfidelity.interface.tablet.system");
                    tablet.pushOntoStack(Script.resolvePath("qml/New" + entityType + "Dialog.qml"));
                } else {
                    closeExistingDialogWindow();
                    var qmlPath = Script.resolvePath("qml/New" + entityType + "Window.qml");
                    var DIALOG_WINDOW_SIZE = { x: 500, y: 300 };
                    dialogWindow = Desktop.createWindow(qmlPath, {
                        title: "New " + entityType + " Entity",
                        additionalFlags: Desktop.ALWAYS_ON_TOP | Desktop.CLOSE_BUTTON_HIDES,
                        presentationMode: Desktop.PresentationMode.NATIVE,
                        size: DIALOG_WINDOW_SIZE,
                        visible: true
                    });
                    dialogWindow.fromQml.connect(fromQml);
                }
            };
        }

        addButton("newModelButton", createNewEntityDialogButtonCallback("Model"));

        addButton("newShapeButton", function () {
            createNewEntity({
                type: "Shape",
                shape: "Cube",
            });
        });

        addButton("newLightButton", function () {
            createNewEntity({
                type: "Light",
            });
        });

        addButton("newTextButton", function () {
            createNewEntity({
                type: "Text",
            });
        });

        addButton("newImageButton", function () {
            createNewEntity({
                type: "Image",
            });
        });

        addButton("newWebButton", function () {
            createNewEntity({
                type: "Web",
            });
        });

        addButton("newZoneButton", function () {
            createNewEntity({
                type: "Zone",
            });
        });

        addButton("newParticleButton", function () {
            createNewEntity({
                type: "ParticleEffect",
            });
        });

        addButton("newMaterialButton", createNewEntityDialogButtonCallback("Material"));

        var deactivateCreateIfDesktopWindowsHidden = function() {
            if (!shouldUseEditTabletApp() && !entityListTool.isVisible() && !createToolsWindow.isVisible()) {
                that.setActive(false);
            }
        };
        entityListTool.interactiveWindowHidden.addListener(this, deactivateCreateIfDesktopWindowsHidden);
        createToolsWindow.interactiveWindowHidden.addListener(this, deactivateCreateIfDesktopWindowsHidden);

        that.setActive(false);
    }

    that.clearEntityList = function () {
        entityListTool.clearEntityList();
    };

    that.toggle = function () {
        that.setActive(!isActive);
        if (!isActive) {
            tablet.gotoHomeScreen();
        }
    };

    that.setActive = function (active) {
        ContextOverlay.enabled = !active;
        Settings.setValue(EDIT_SETTING, active);
        if (active) {
            Controller.captureEntityClickEvents();
        } else {
            Controller.releaseEntityClickEvents();

            closeExistingDialogWindow();
        }
        if (active === isActive) {
            return;
        }
        if (active && !Entities.canRez() && !Entities.canRezTmp() && !Entities.canRezCertified() && !Entities.canRezTmpCertified()) {
            Window.notifyEditError(INSUFFICIENT_PERMISSIONS_ERROR_MSG);
            return;
        }
        Messages.sendLocalMessage("edit-events", JSON.stringify({
            enabled: active
        }));
        isActive = active;
        activeButton.editProperties({isActive: isActive});
        undoHistory.setEnabled(isActive);

        var tablet = Tablet.getTablet("com.highfidelity.interface.tablet.system");

        if (!isActive) {
            entityListTool.setVisible(false);
            gridTool.setVisible(false);
            grid.setEnabled(false);
            propertiesTool.setVisible(false);
            selectionManager.clearSelections(this);
            cameraManager.disable();
            selectionDisplay.disableTriggerMapping();
            tablet.landscape = false;
            Controller.disableMapping(CONTROLLER_MAPPING_NAME);
        } else {
            if (shouldUseEditTabletApp()) {
                tablet.loadQMLSource(Script.resolvePath("qml/Edit.qml"), true);
            } else {
                // make other apps inactive while in desktop mode
                tablet.gotoHomeScreen();