Merge branch 'master' of github.com:highfidelity/hifi into head-controller

interface/src/Application.cpp

@@ -2830,6 +2830,17 @@ void Application::keyPressEvent(QKeyEvent* event) {
                 if (isShifted && isMeta && !isOption) {
                     Menu::getInstance()->triggerOption(MenuOption::SuppressShortTimings);
                 } else if (!isOption && !isShifted && isMeta) {
+                    AudioInjectorOptions options;
+                    options.localOnly = true;
+                    options.stereo = true;
+
+                    if (_snapshotSoundInjector) {
+                        _snapshotSoundInjector->setOptions(options);
+                        _snapshotSoundInjector->restart();
+                    } else {
+                        QByteArray samples = _snapshotSound->getByteArray();
+                        _snapshotSoundInjector = AudioInjector::playSound(samples, options);
+                    }
                     takeSnapshot(true);
                 }
                 break;
@@ -6364,21 +6375,6 @@ void Application::loadAddAvatarBookmarkDialog() const {
 }
 
 void Application::takeSnapshot(bool notify, bool includeAnimated, float aspectRatio) {
-    
-    //keep sound thread out of event loop scope
-
-    AudioInjectorOptions options;
-    options.localOnly = true;
-    options.stereo = true;
-
-    if (_snapshotSoundInjector) {
-        _snapshotSoundInjector->setOptions(options);
-        _snapshotSoundInjector->restart();
-    } else {
-        QByteArray samples = _snapshotSound->getByteArray();
-        _snapshotSoundInjector = AudioInjector::playSound(samples, options);
-    }
-
     postLambdaEvent([notify, includeAnimated, aspectRatio, this] {
         // Get a screenshot and save it
         QString path = Snapshot::saveSnapshot(getActiveDisplayPlugin()->getScreenshot(aspectRatio));

interface/src/main.cpp

@@ -190,7 +190,7 @@ int main(int argc, const char* argv[]) {
 
     int exitCode;
     {
-        RunningMarker runningMarker(nullptr, RUNNING_MARKER_FILENAME);
+        RunningMarker runningMarker(RUNNING_MARKER_FILENAME);
         bool runningMarkerExisted = runningMarker.fileExists();
         runningMarker.writeRunningMarkerFile();
 
@@ -199,14 +199,11 @@ int main(int argc, const char* argv[]) {
         bool serverContentPathOptionIsSet = parser.isSet(serverContentPathOption);
         QString serverContentPath = serverContentPathOptionIsSet ? parser.value(serverContentPathOption) : QString();
         if (runServer) {
-            SandboxUtils::runLocalSandbox(serverContentPath, true, RUNNING_MARKER_FILENAME, noUpdater);
+            SandboxUtils::runLocalSandbox(serverContentPath, true, noUpdater);
         }
 
         Application app(argc, const_cast<char**>(argv), startupTime, runningMarkerExisted);
 
-        // Now that the main event loop is setup, launch running marker thread
-        runningMarker.startRunningMarker();
-
         // If we failed the OpenGLVersion check, log it.
         if (override) {
             auto accountManager = DependencyManager::get<AccountManager>();

libraries/networking/src/SandboxUtils.cpp

@@ -52,9 +52,8 @@ bool readStatus(QByteArray statusData) {
     return false;
 }
 
-void runLocalSandbox(QString contentPath, bool autoShutdown, QString runningMarkerName, bool noUpdater) {
+void runLocalSandbox(QString contentPath, bool autoShutdown, bool noUpdater) {
     QString serverPath = "./server-console/server-console.exe";
-    qCDebug(networking) << "Running marker path is: " << runningMarkerName;
     qCDebug(networking) << "Server path is: " << serverPath;
     qCDebug(networking) << "autoShutdown: " << autoShutdown;
     qCDebug(networking) << "noUpdater: " << noUpdater;
@@ -74,8 +73,8 @@ void runLocalSandbox(QString contentPath, bool autoShutdown, QString runningMark
     }
 
     if (autoShutdown) {
-        QString interfaceRunningStateFile = RunningMarker::getMarkerFilePath(runningMarkerName);
-        args << "--shutdownWatcher" << interfaceRunningStateFile;
+        auto pid = QCoreApplication::applicationPid();
+        args << "--shutdownWith" << QString::number(pid);
     }
 
     if (noUpdater) {

libraries/networking/src/SandboxUtils.h

@@ -21,7 +21,7 @@ namespace SandboxUtils {
 
     QNetworkReply* getStatus();
     bool readStatus(QByteArray statusData);
-    void runLocalSandbox(QString contentPath, bool autoShutdown, QString runningMarkerName, bool noUpdater);
+    void runLocalSandbox(QString contentPath, bool autoShutdown, bool noUpdater);
 };
 
 #endif // hifi_SandboxUtils_h

libraries/shared/src/Extents.h

@@ -69,7 +69,7 @@ public:
     glm::vec3 size() const { return maximum - minimum; }
     float largestDimension() const { return glm::compMax(size()); }
 
-    /// \return new Extents which is original rotated around orign by rotation
+    /// \return new Extents which is original rotated around origin by rotation
     Extents getRotated(const glm::quat& rotation) const {
         Extents temp(minimum, maximum);
         temp.rotate(rotation);

libraries/shared/src/RunningMarker.cpp

@@ -13,44 +13,16 @@
 
 #include <QFile>
 #include <QStandardPaths>
-#include <QThread>
-#include <QTimer>
 
-#include "NumericalConstants.h"
 #include "PathUtils.h"
 
-RunningMarker::RunningMarker(QObject* parent, QString name) :
-    _parent(parent),
+RunningMarker::RunningMarker(QString name) :
     _name(name)
 {
 }
 
-void RunningMarker::startRunningMarker() {
-    static const int RUNNING_STATE_CHECK_IN_MSECS = MSECS_PER_SECOND;
-
-    // start the nodeThread so its event loop is running
-    _runningMarkerThread = new QThread(_parent);
-    _runningMarkerThread->setObjectName("Running Marker Thread");
-    _runningMarkerThread->start();
-
-    writeRunningMarkerFile(); // write the first file, even before timer
-
-    _runningMarkerTimer = new QTimer();
-    QObject::connect(_runningMarkerTimer, &QTimer::timeout, [=](){
-        writeRunningMarkerFile();
-    });
-    _runningMarkerTimer->start(RUNNING_STATE_CHECK_IN_MSECS);
-
-    // put the time on the thread
-    _runningMarkerTimer->moveToThread(_runningMarkerThread);
-}
-
 RunningMarker::~RunningMarker() {
     deleteRunningMarkerFile();
-    QMetaObject::invokeMethod(_runningMarkerTimer, "stop", Qt::BlockingQueuedConnection);
-    _runningMarkerThread->quit();
-    _runningMarkerTimer->deleteLater();
-    _runningMarkerThread->deleteLater();
 }
 
 bool RunningMarker::fileExists() const {
@@ -77,8 +49,3 @@ void RunningMarker::deleteRunningMarkerFile() {
 QString RunningMarker::getFilePath() const {
     return QStandardPaths::writableLocation(QStandardPaths::DataLocation) + "/" + _name;
 }
-
-QString RunningMarker::getMarkerFilePath(QString name) {
-    return QStandardPaths::writableLocation(QStandardPaths::DataLocation) + "/" + name;
-}
-

libraries/shared/src/RunningMarker.h

@@ -12,21 +12,14 @@
 #ifndef hifi_RunningMarker_h
 #define hifi_RunningMarker_h
 
-#include <QObject>
 #include <QString>
 
-class QThread;
-class QTimer;
-
 class RunningMarker {
 public:
-    RunningMarker(QObject* parent, QString name);
+    RunningMarker(QString name);
     ~RunningMarker();
 
-    void startRunningMarker();
-
     QString getFilePath() const;
-    static QString getMarkerFilePath(QString name);
 
     bool fileExists() const;
 
@@ -34,10 +27,7 @@ public:
     void deleteRunningMarkerFile();
 
 private:
-    QObject* _parent { nullptr };
     QString _name;
-    QThread* _runningMarkerThread { nullptr };
-    QTimer* _runningMarkerTimer { nullptr };
 };
 
 #endif // hifi_RunningMarker_h

scripts/system/edit.js

@@ -217,6 +217,32 @@ function hideMarketplace() {
 //     }
 // }
 
+function adjustPositionPerBoundingBox(position, direction, registration, dimensions, orientation) {
+    // Adjust the position such that the bounding box (registration, dimenions, 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 TOOLS_PATH = Script.resolvePath("assets/images/tools/");
 var GRABBABLE_ENTITIES_MENU_CATEGORY = "Edit";
 var GRABBABLE_ENTITIES_MENU_ITEM = "Create Entities As Grabbable";
@@ -234,6 +260,32 @@ var toolBar = (function () {
         var position = getPositionToCreateEntity();
         var entityID = null;
         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", "Web"];
+            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) {
+                    var DEFAULT_ORIENTATION = Quat.fromPitchYawRollDegrees(0, 0, 0);
+                    orientation = DEFAULT_ORIENTATION;
+                }
+
+                position = adjustPositionPerBoundingBox(position, direction, registration, dimensions, orientation);
+            }
+
             position = grid.snapToSurface(grid.snapToGrid(position, false, dimensions), dimensions);
             properties.position = position;
             if (Menu.isOptionChecked(GRABBABLE_ENTITIES_MENU_ITEM)) {
@@ -243,6 +295,32 @@ var toolBar = (function () {
             if (properties.type == "ParticleEffect") {
                 selectParticleEntity(entityID);
             }
+
+            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();
+                    } else if (dimensionsCheckCount < MAX_DIMENSIONS_CHECKS) {
+                        Script.setTimeout(dimensionsCheckFunction, DIMENSIONS_CHECK_INTERVAL);
+                    }
+                };
+                Script.setTimeout(dimensionsCheckFunction, DIMENSIONS_CHECK_INTERVAL);
+            }
         } else {
             Window.notifyEditError("Can't create " + properties.type + ": " +
                                    properties.type + " would be out of bounds.");
@@ -1407,40 +1485,26 @@ function handeMenuEvent(menuItem) {
     }
     tooltip.show(false);
 }
-function getPositionToCreateEntity() {
-    var HALF_TREE_SCALE = 16384;
-    var direction = Quat.getForward(MyAvatar.orientation);
-    var distance = 1;
-    var position = Vec3.sum(MyAvatar.position, Vec3.multiply(direction, distance));
 
+var HALF_TREE_SCALE = 16384;
+
+function getPositionToCreateEntity(extra) {
+    var CREATE_DISTANCE = 2;
+    var position;
+    var delta = extra !== undefined ? extra : 0;
     if (Camera.mode === "entity" || Camera.mode === "independent") {
-        position = Vec3.sum(Camera.position, Vec3.multiply(Quat.getForward(Camera.orientation), distance));
+        position = Vec3.sum(Camera.position, Vec3.multiply(Quat.getForward(Camera.orientation), CREATE_DISTANCE + delta));
+    } else {
+        position = Vec3.sum(MyAvatar.position, Vec3.multiply(Quat.getForward(MyAvatar.orientation), CREATE_DISTANCE + delta));
+        position.y += 0.5;
     }
-    position.y += 0.5;
+
     if (position.x > HALF_TREE_SCALE || position.y > HALF_TREE_SCALE || position.z > HALF_TREE_SCALE) {
         return null;
     }
     return position;
 }
 
-function getPositionToImportEntity() {
-    var dimensions = Clipboard.getContentsDimensions();
-    var HALF_TREE_SCALE = 16384;
-    var direction = Quat.getForward(MyAvatar.orientation);
-    var longest = 1;
-    longest = Math.sqrt(Math.pow(dimensions.x, 2) + Math.pow(dimensions.z, 2));
-    var position = Vec3.sum(MyAvatar.position, Vec3.multiply(direction, longest));
-
-    if (Camera.mode === "entity" || Camera.mode === "independent") {
-        position = Vec3.sum(Camera.position, Vec3.multiply(Quat.getForward(Camera.orientation), longest));
-    }
-
-    if (position.x > HALF_TREE_SCALE || position.y > HALF_TREE_SCALE || position.z > HALF_TREE_SCALE) {
-        return null;
-    }
-
-    return position;
-}
 function importSVO(importURL) {
     if (!Entities.canRez() && !Entities.canRezTmp()) {
         Window.notifyEditError(INSUFFICIENT_PERMISSIONS_IMPORT_ERROR_MSG);
@@ -1458,22 +1522,73 @@ function importSVO(importURL) {
 
     if (success) {
         var VERY_LARGE = 10000;
-        var position = {
-            x: 0,
-            y: 0,
-            z: 0
-        };
-        if (Clipboard.getClipboardContentsLargestDimension() < VERY_LARGE) {
-            position = getPositionToImportEntity();
+        var isLargeImport = Clipboard.getClipboardContentsLargestDimension() >= VERY_LARGE;
+        var position = Vec3.ZERO;
+        if (!isLargeImport) {
+            position = getPositionToCreateEntity(Clipboard.getClipboardContentsLargestDimension() / 2);
         }
         if (position !== null && position !== undefined) {
             var pastedEntityIDs = Clipboard.pasteEntities(position);
+            if (!isLargeImport) {
+                // The first entity in Clipboard gets the specified position with the rest being relative to it. Therefore, move
+                // entities after they're imported so that they're all the correct distance in front of and with geometric mean
+                // centered on the avatar/camera direction.
+                var deltaPosition = Vec3.ZERO;
+
+                var properties = Entities.getEntityProperties(pastedEntityIDs[0], ["type"]);
+                var NO_ADJUST_ENTITY_TYPES = ["Zone", "Light", "ParticleEffect"];
+                if (NO_ADJUST_ENTITY_TYPES.indexOf(properties.type) === -1) {
+                    var targetDirection;
+                    if (Camera.mode === "entity" || Camera.mode === "independent") {
+                        targetDirection = Camera.orientation;
+                    } else {
+                        targetDirection = MyAvatar.orientation;
+                    }
+                    targetDirection = Vec3.multiplyQbyV(targetDirection, Vec3.UNIT_Z);
+
+                    var targetPosition = getPositionToCreateEntity();
+                    var deltaParallel = HALF_TREE_SCALE;  // Distance to move entities parallel to targetDirection.
+                    var deltaPerpendicular = Vec3.ZERO;  // Distance to move entities perpendicular to targetDirection.
+                    var entityPositions = [];
+                    for (var i = 0, length = pastedEntityIDs.length; i < length; i++) {
+                        var properties = Entities.getEntityProperties(pastedEntityIDs[i], ["position", "dimensions",
+                            "registrationPoint", "rotation"]);
+                        var adjustedPosition = adjustPositionPerBoundingBox(targetPosition, targetDirection,
+                            properties.registrationPoint, properties.dimensions, properties.rotation);
+                        var delta = Vec3.subtract(adjustedPosition, properties.position);
+                        var distance = Vec3.dot(delta, targetDirection);
+                        deltaParallel = Math.min(distance, deltaParallel);
+                        deltaPerpendicular = Vec3.sum(Vec3.subtract(delta, Vec3.multiply(distance, targetDirection)),
+                            deltaPerpendicular);
+                        entityPositions[i] = properties.position;
+                    }
+                    deltaPerpendicular = Vec3.multiply(1 / pastedEntityIDs.length, deltaPerpendicular);
+                    deltaPosition = Vec3.sum(Vec3.multiply(deltaParallel, targetDirection), deltaPerpendicular);
+                }
+
+                if (grid.getSnapToGrid()) {
+                    var properties = Entities.getEntityProperties(pastedEntityIDs[0], ["position", "dimensions",
+                        "registrationPoint"]);
+                    var position = Vec3.sum(deltaPosition, properties.position);
+                    position = grid.snapToSurface(grid.snapToGrid(position, false, properties.dimensions, 
+                            properties.registrationPoint), properties.dimensions, properties.registrationPoint);
+                    deltaPosition = Vec3.subtract(position, properties.position);
+                }
+
+                if (!Vec3.equal(deltaPosition, Vec3.ZERO)) {
+                    for (var i = 0, length = pastedEntityIDs.length; i < length; i++) {
+                        Entities.editEntity(pastedEntityIDs[i], {
+                            position: Vec3.sum(deltaPosition, entityPositions[i])
+                        });
+                    }
+                }
+            }
 
             if (isActive) {
                 selectionManager.setSelections(pastedEntityIDs);
             }
         } else {
-            Window.notifyEditError("Can't import objects: objects would be out of bounds.");
+            Window.notifyEditError("Can't import entities: entities would be out of bounds.");
         }
     } else {
         Window.notifyEditError("There was an error importing the entity file.");

scripts/system/libraries/gridTool.js

@@ -79,7 +79,7 @@ Grid = function(opts) {
         }
     }
 
-    that.snapToSurface = function(position, dimensions) {
+    that.snapToSurface = function(position, dimensions, registration) {
         if (!snapToGrid) {
             return position;
         }
@@ -88,14 +88,18 @@ Grid = function(opts) {
             dimensions = { x: 0, y: 0, z: 0 };
         }
 
+        if (registration === undefined) {
+            registration = { x: 0.5, y: 0.5, z: 0.5 };
+        }
+
         return {
             x: position.x,
-            y: origin.y + (dimensions.y / 2),
+            y: origin.y + (registration.y * dimensions.y),
             z: position.z
         };
     }
 
-    that.snapToGrid = function(position, majorOnly, dimensions) {
+    that.snapToGrid = function(position, majorOnly, dimensions, registration) {
         if (!snapToGrid) {
             return position;
         }
@@ -104,6 +108,10 @@ Grid = function(opts) {
             dimensions = { x: 0, y: 0, z: 0 };
         }
 
+        if (registration === undefined) {
+            registration = { x: 0.5, y: 0.5, z: 0.5 };
+        }
+
         var spacing = majorOnly ? majorGridEvery : minorGridEvery;
 
         position = Vec3.subtract(position, origin);
@@ -112,7 +120,7 @@ Grid = function(opts) {
         position.y = Math.round(position.y / spacing) * spacing;
         position.z = Math.round(position.z / spacing) * spacing;
 
-        return Vec3.sum(Vec3.sum(position, Vec3.multiply(0.5, dimensions)), origin);
+        return Vec3.sum(Vec3.sum(position, Vec3.multiplyVbyV(registration, dimensions)), origin);
     }
 
     that.snapToSpacing = function(delta, majorOnly) {
@@ -161,9 +169,9 @@ Grid = function(opts) {
 
         if (data.origin) {
             var pos = data.origin;
-            pos.x = pos.x === undefined ? origin.x : pos.x;
-            pos.y = pos.y === undefined ? origin.y : pos.y;
-            pos.z = pos.z === undefined ? origin.z : pos.z;
+            pos.x = pos.x === undefined ? origin.x : parseFloat(pos.x);
+            pos.y = pos.y === undefined ? origin.y : parseFloat(pos.y);
+            pos.z = pos.z === undefined ? origin.z : parseFloat(pos.z);
             that.setPosition(pos, true);
         }
 

scripts/system/snapshot.js

@@ -410,8 +410,15 @@ function takeSnapshot() {
         Menu.setIsOptionChecked("Overlays", false);
     }
 
+    var snapActivateSound = SoundCache.getSound(Script.resolvePath("../../resources/sounds/snap.wav"));
+
     // take snapshot (with no notification)
     Script.setTimeout(function () {
+        Audio.playSound(snapActivateSound, {
+            position: { x: MyAvatar.position.x, y: MyAvatar.position.y, z: MyAvatar.position.z },
+            localOnly: true,
+            volume: 1.0
+        });
         HMD.closeTablet();
         Script.setTimeout(function () {
             Window.takeSnapshot(false, includeAnimated, 1.91);

server-console/src/main.js

@@ -821,6 +821,17 @@ for (var key in trayIcons) {
 
 const notificationIcon = path.join(__dirname, '../resources/console-notification.png');
 
+function isProcessRunning(pid) {
+    try {
+        // Sending a signal of 0 is effectively a NOOP.
+        // If sending the signal is successful, kill will return true.
+        // If the process is not running, an exception will be thrown.
+        return process.kill(pid, 0);
+    } catch (e) {
+    }
+    return false;
+}
+
 function onContentLoaded() {
     // Disable splash window for now.
     // maybeShowSplash();
@@ -882,31 +893,18 @@ function onContentLoaded() {
         startInterface();
     }
 
-    // If we were launched with the shutdownWatcher option, then we need to watch for the interface app
-    // shutting down. The interface app will regularly update a running state file which we will check.
-    // If the file doesn't exist or stops updating for a significant amount of time, we will shut down.
-    if (argv.shutdownWatcher) {
-        log.debug("Shutdown watcher requested... argv.shutdownWatcher:", argv.shutdownWatcher);
-        var MAX_TIME_SINCE_EDIT = 5000; // 5 seconds between updates
-        var firstAttemptToCheck = new Date().getTime();
-        var shutdownWatchInterval = setInterval(function(){
-            var stats = fs.stat(argv.shutdownWatcher, function(err, stats) {
-                if (err) {
-                    var sinceFirstCheck = new Date().getTime() - firstAttemptToCheck;
-                    if (sinceFirstCheck > MAX_TIME_SINCE_EDIT) {
-                        log.debug("Running state file is missing, assume interface has shutdown... shutting down snadbox.");
-                        forcedShutdown();
-                        clearTimeout(shutdownWatchInterval);
-                    }
-                } else {
-                    var sinceEdit = new Date().getTime() - stats.mtime.getTime();
-                    if (sinceEdit > MAX_TIME_SINCE_EDIT) {
-                        log.debug("Running state of interface hasn't updated in MAX time... shutting down.");
-                        forcedShutdown();
-                        clearTimeout(shutdownWatchInterval);
-                    }
-                }
-            });
+    // If we were launched with the shutdownWith option, then we need to shutdown when that process (pid)
+    // is no longer running.
+    if (argv.shutdownWith) {
+        let pid = argv.shutdownWith;
+        console.log("Shutting down with process: ", pid);
+        let checkProcessInterval = setInterval(function() {
+            let isRunning = isProcessRunning(pid);
+            if (!isRunning) {
+                log.debug("Watched process is no longer running, shutting down");
+                clearTimeout(checkProcessInterval);
+                forcedShutdown();
+            }
         }, 1000);
     }
 }

unpublishedScripts/marketplace/record/html/fonts/FiraSans.license

@@ -0,0 +1,94 @@
+Digitized data copyright (c) 2012-2015, The Mozilla Foundation and Telefonica S.A.
+with Reserved Font Name < Fira >, 
+
+This Font Software is licensed under the SIL Open Font License, Version 1.1.
+This license is copied below, and is also available with a FAQ at:
+http://scripts.sil.org/OFL
+
+
+-----------------------------------------------------------
+SIL OPEN FONT LICENSE Version 1.1 - 26 February 2007
+-----------------------------------------------------------
+
+PREAMBLE
+The goals of the Open Font License (OFL) are to stimulate worldwide
+development of collaborative font projects, to support the font creation
+efforts of academic and linguistic communities, and to provide a free and
+open framework in which fonts may be shared and improved in partnership
+with others.
+
+The OFL allows the licensed fonts to be used, studied, modified and
+redistributed freely as long as they are not sold by themselves. The
+fonts, including any derivative works, can be bundled, embedded, 
+redistributed and/or sold with any software provided that any reserved
+names are not used by derivative works. The fonts and derivatives,
+however, cannot be released under any other type of license. The
+requirement for fonts to remain under this license does not apply
+to any document created using the fonts or their derivatives.
+
+DEFINITIONS
+"Font Software" refers to the set of files released by the Copyright
+Holder(s) under this license and clearly marked as such. This may
+include source files, build scripts and documentation.
+
+"Reserved Font Name" refers to any names specified as such after the
+copyright statement(s).
+
+"Original Version" refers to the collection of Font Software components as
+distributed by the Copyright Holder(s).
+
+"Modified Version" refers to any derivative made by adding to, deleting,
+or substituting -- in part or in whole -- any of the components of the
+Original Version, by changing formats or by porting the Font Software to a
+new environment.
+
+"Author" refers to any designer, engineer, programmer, technical
+writer or other person who contributed to the Font Software.
+
+PERMISSION & CONDITIONS
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of the Font Software, to use, study, copy, merge, embed, modify,
+redistribute, and sell modified and unmodified copies of the Font
+Software, subject to the following conditions:
+
+1) Neither the Font Software nor any of its individual components,
+in Original or Modified Versions, may be sold by itself.
+
+2) Original or Modified Versions of the Font Software may be bundled,
+redistributed and/or sold with any software, provided that each copy
+contains the above copyright notice and this license. These can be
+included either as stand-alone text files, human-readable headers or
+in the appropriate machine-readable metadata fields within text or
+binary files as long as those fields can be easily viewed by the user.
+
+3) No Modified Version of the Font Software may use the Reserved Font
+Name(s) unless explicit written permission is granted by the corresponding
+Copyright Holder. This restriction only applies to the primary font name as
+presented to the users.
+
+4) The name(s) of the Copyright Holder(s) or the Author(s) of the Font
+Software shall not be used to promote, endorse or advertise any
+Modified Version, except to acknowledge the contribution(s) of the
+Copyright Holder(s) and the Author(s) or with their explicit written
+permission.
+
+5) The Font Software, modified or unmodified, in part or in whole,
+must be distributed entirely under this license, and must not be
+distributed under any other license. The requirement for fonts to
+remain under this license does not apply to any document created
+using the Font Software.
+
+TERMINATION
+This license becomes null and void if any of the above conditions are
+not met.
+
+DISCLAIMER
+THE FONT SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO ANY WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT
+OF COPYRIGHT, PATENT, TRADEMARK, OR OTHER RIGHT. IN NO EVENT SHALL THE
+COPYRIGHT HOLDER BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+INCLUDING ANY GENERAL, SPECIAL, INDIRECT, INCIDENTAL, OR CONSEQUENTIAL
+DAMAGES, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+FROM, OUT OF THE USE OR INABILITY TO USE THE FONT SOFTWARE OR FROM
+OTHER DEALINGS IN THE FONT SOFTWARE.

unpublishedScripts/marketplace/record/html/fonts/Raleway.license

@@ -0,0 +1,94 @@
+Copyright (c) 2010, Matt McInerney (matt@pixelspread.com),
+Copyright (c) 2011, Pablo Impallari (www.impallari.com|impallari@gmail.com),
+Copyright (c) 2011, Rodrigo Fuenzalida (www.rfuenzalida.com|hello@rfuenzalida.com), with Reserved Font Name Raleway
+This Font Software is licensed under the SIL Open Font License, Version 1.1.
+This license is copied below, and is also available with a FAQ at:
+http://scripts.sil.org/OFL
+
+
+-----------------------------------------------------------
+SIL OPEN FONT LICENSE Version 1.1 - 26 February 2007
+-----------------------------------------------------------
+
+PREAMBLE
+The goals of the Open Font License (OFL) are to stimulate worldwide
+development of collaborative font projects, to support the font creation
+efforts of academic and linguistic communities, and to provide a free and
+open framework in which fonts may be shared and improved in partnership
+with others.
+
+The OFL allows the licensed fonts to be used, studied, modified and
+redistributed freely as long as they are not sold by themselves. The
+fonts, including any derivative works, can be bundled, embedded, 
+redistributed and/or sold with any software provided that any reserved
+names are not used by derivative works. The fonts and derivatives,
+however, cannot be released under any other type of license. The
+requirement for fonts to remain under this license does not apply
+to any document created using the fonts or their derivatives.
+
+DEFINITIONS
+"Font Software" refers to the set of files released by the Copyright
+Holder(s) under this license and clearly marked as such. This may
+include source files, build scripts and documentation.
+
+"Reserved Font Name" refers to any names specified as such after the
+copyright statement(s).
+
+"Original Version" refers to the collection of Font Software components as
+distributed by the Copyright Holder(s).
+
+"Modified Version" refers to any derivative made by adding to, deleting,
+or substituting -- in part or in whole -- any of the components of the
+Original Version, by changing formats or by porting the Font Software to a
+new environment.
+
+"Author" refers to any designer, engineer, programmer, technical
+writer or other person who contributed to the Font Software.
+
+PERMISSION & CONDITIONS
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of the Font Software, to use, study, copy, merge, embed, modify,
+redistribute, and sell modified and unmodified copies of the Font
+Software, subject to the following conditions:
+
+1) Neither the Font Software nor any of its individual components,
+in Original or Modified Versions, may be sold by itself.
+
+2) Original or Modified Versions of the Font Software may be bundled,
+redistributed and/or sold with any software, provided that each copy
+contains the above copyright notice and this license. These can be
+included either as stand-alone text files, human-readable headers or
+in the appropriate machine-readable metadata fields within text or
+binary files as long as those fields can be easily viewed by the user.
+
+3) No Modified Version of the Font Software may use the Reserved Font
+Name(s) unless explicit written permission is granted by the corresponding
+Copyright Holder. This restriction only applies to the primary font name as
+presented to the users.
+
+4) The name(s) of the Copyright Holder(s) or the Author(s) of the Font
+Software shall not be used to promote, endorse or advertise any
+Modified Version, except to acknowledge the contribution(s) of the
+Copyright Holder(s) and the Author(s) or with their explicit written
+permission.
+
+5) The Font Software, modified or unmodified, in part or in whole,
+must be distributed entirely under this license, and must not be
+distributed under any other license. The requirement for fonts to
+remain under this license does not apply to any document created
+using the Font Software.
+
+TERMINATION
+This license becomes null and void if any of the above conditions are
+not met.
+
+DISCLAIMER
+THE FONT SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO ANY WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT
+OF COPYRIGHT, PATENT, TRADEMARK, OR OTHER RIGHT. IN NO EVENT SHALL THE
+COPYRIGHT HOLDER BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+INCLUDING ANY GENERAL, SPECIAL, INDIRECT, INCIDENTAL, OR CONSEQUENTIAL
+DAMAGES, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+FROM, OUT OF THE USE OR INABILITY TO USE THE FONT SOFTWARE OR FROM
+OTHER DEALINGS IN THE FONT SOFTWARE.