Feature Request: Set Ruler Origin Location in Photoshop

Forum|Forum|6 years ago
January 8, 2020
3 replies
7386 views

I'd love to see an option in preferences under Units and Rulers to set the Ruler Origin (0,0) to be in a different location than the top left corner of the artboard, either on a document by document basis, or as a default - maybe with a toggle. A 3x3 grid of radio button selections such as top left, middle left, bottom left; top center, middle center, bottom center; top right, middle right, bottom right would be ideal, but a drop down list would work also. This would save having to zoom waaaaayyy in to the appropriate location and dragging the corner box of the ruler to (hopefully) line up with the exact pixel you're aiming for on each new artboard/file.

If there's already a simple way to do this that I'm unaware of, I'd love to know what it is!

Thanks!

mscureman

Correct answer mscureman

Thanks for the feedback, kstohlmeyer! I knew about dragging the upper left corner, but didn't know about the Shift key modifier. Helpful!

Also, I submitted this as an "Idea" on the feedback forum here:

Set Ruler Origin Location in Preferences, New Document Dialog or Menu

Stephen Marsh

Community Expert

A similar topic here: Feature Request: Set Origin Point

mscuremanAuthor

Inspiring

I'd love to have an option to set where the 0,0 point is for the X and Y axes. Top Left is fine for many projects, but it'd be nice to have, perhaps, a radio button-style interface, either in preferences or in the document properties (or both!), where you had a 3x3 grid of buttons so you could choose to set the reference origin point at the:

Top Left, Top Middle, Top Right

Middle Left, Center, Middle Right

Bottom Left, Bottom Middle, Bottom Right

See attached photo

Stephen Marsh

Community Expert

Here is a new 1.3 version, including X & Y entry fields in addition to the original 9 preset locations. The intention/expectation is that either the radio buttons are used, or the fields are used instead - not both at the same time. There may be a way to make the use of one disable the other?

Set-Ruler-Origin-to-User-Input-GUI.jsx

/* 
https://community.adobe.com/t5/photoshop/feature-request-set-origin-point/td-p/12037399
Feature Request: Set Origin Point

Set Ruler Origin to User Input.jsx
Version 1.3, 19th May 2021
Stephen Marsh
*/

#target photoshop

if (app.documents.length > 0) {

    // Save the current ruler units and set to pixels
    var savedRuler = app.preferences.rulerUnits;
    app.preferences.rulerUnits = Units.PIXELS;

    /////////////////////////////// joonas scriptUI ///////////////////////////////

    // DIALOGWINDOW
    // ============
    var dialogWindow = new Window("dialog", undefined, undefined, {
        closeButton: false
    });
    dialogWindow.text = "Set Ruler Origin - v1.3"; // Remember to update this to match the header!
    dialogWindow.preferredSize.width = 410;
    dialogWindow.preferredSize.height = 100;
    dialogWindow.orientation = "row";
    dialogWindow.alignChildren = ["left", "center"];
    dialogWindow.spacing = 10;
    dialogWindow.margins = 15;

    // GROUP1
    // ======
    var group1 = dialogWindow.add("group", undefined, {
        name: "group1"
    });
    group1.orientation = "row";
    group1.alignChildren = ["left", "center"];
    group1.spacing = 10;
    group1.margins = 0;

    // UPPERGROUP
    // ==========
    var upperGroup = group1.add("group", undefined, {
        name: "upperGroup"
    });
    upperGroup.orientation = "column";
    upperGroup.alignChildren = ["left", "center"];
    upperGroup.spacing = 10;
    upperGroup.margins = 0;

    var upperLeft = upperGroup.add("radiobutton", undefined, undefined, {
        name: "upperLeft"
    });
    upperLeft.text = "Upper Left";
    upperLeft.helpTip = "Radio buttons override the X & Y fields";


    var middleLeft = upperGroup.add("radiobutton", undefined, undefined, {
        name: "middleLeft"
    });
    middleLeft.text = "Middle Left";
    middleLeft.helpTip = "Radio buttons override the X & Y fields";


    var lowerLeft = upperGroup.add("radiobutton", undefined, undefined, {
        name: "lowerLeft"
    });
    lowerLeft.text = "Lower Left";
    lowerLeft.helpTip = "Radio buttons override the X & Y fields";

    // MIDDLEGROUP
    // ===========
    var middleGroup = group1.add("group", undefined, {
        name: "middleGroup"
    });
    middleGroup.orientation = "column";
    middleGroup.alignChildren = ["left", "center"];
    middleGroup.spacing = 10;
    middleGroup.margins = 0;

    var upperCenter = middleGroup.add("radiobutton", undefined, undefined, {
        name: "upperCenter"
    });
    upperCenter.text = "Upper Center";
    upperCenter.helpTip = "Radio buttons override the X & Y fields";

    var middleCenter = middleGroup.add("radiobutton", undefined, undefined, {
        name: "middleCenter"
    });
    middleCenter.text = "Middle Center";
    middleCenter.helpTip = "Radio buttons override the X & Y fields";

    var lowerCenter = middleGroup.add("radiobutton", undefined, undefined, {
        name: "lowerCenter"
    });
    lowerCenter.text = "Lower Center";
    lowerCenter.helpTip = "Radio buttons override the X & Y fields";

    // LOWERGROUP
    // ==========
    var lowerGroup = group1.add("group", undefined, {
        name: "lowerGroup"
    });
    lowerGroup.orientation = "column";
    lowerGroup.alignChildren = ["left", "center"];
    lowerGroup.spacing = 10;
    lowerGroup.margins = 0;

    var upperRight = lowerGroup.add("radiobutton", undefined, undefined, {
        name: "upperRight"
    });
    upperRight.text = "Upper Right";
    upperRight.helpTip = "Radio buttons override the X & Y fields";

    var middleRight = lowerGroup.add("radiobutton", undefined, undefined, {
        name: "middleRight"
    });
    middleRight.text = "Middle Right";
    middleRight.helpTip = "Radio buttons override the X & Y fields";

    var lowerRight = lowerGroup.add("radiobutton", undefined, undefined, {
        name: "lowerRight"
    });
    lowerRight.text = "Lower Right";
    lowerRight.helpTip = "Radio buttons override the X & Y fields";

    // XYGROUP
    // =======
    var xyGroup = dialogWindow.add("group", undefined, {
        name: "xyGroup"
    });
    xyGroup.orientation = "row";
    xyGroup.alignChildren = ["left", "center"];
    xyGroup.spacing = 0;
    xyGroup.margins = [0, 0, 0, 0];
    xyGroup.alignment = ["left", "center"];

    // XYPANEL
    // =======
    var xyPanel = xyGroup.add("panel", undefined, undefined, {
        name: "xyPanel"
    });
    xyPanel.text = "X & Y Position";
    xyPanel.orientation = "column";
    xyPanel.alignChildren = ["left", "center"];
    xyPanel.spacing = 5;
    xyPanel.margins = [10, 10, 10, 10];
    xyPanel.alignment = ["left", "center"];

    var xValue = xyPanel.add('edittext {properties: {name: "xValue"}}');
    xValue.helpTip = "Enter the X value";
    xValue.preferredSize.width = 75;
    xValue.text = "";
    // Call the function to imit keyboard entry to digits
    xyPanel.xValue.addEventListener('keydown', NumericEditKeyboardHandler);

    ////////////////////// peter kahrel scriptUI for dummies //////////////////////
    // Preset the X field as active
    xValue.active = true;
    ////////////////////// peter kahrel scriptUI for dummies //////////////////////

    var yValue = xyPanel.add('edittext {properties: {name: "yValue"}}');
    yValue.helpTip = "Enter the Y value";
    yValue.preferredSize.width = 75;
    yValue.text = "";
    // Call the function to imit keyboard entry to digits
    xyPanel.yValue.addEventListener('keydown', NumericEditKeyboardHandler);

    ////////////////////// peter kahrel scriptUI for dummies //////////////////////
    // Make multiple groups act as one group
    upperGroup.addEventListener("click", function () {
        for (var i = 0; i < middleGroup.children.length; i++)
            middleGroup.children[i].value = false;
    });
    upperGroup.addEventListener("click", function () {
        for (var i = 0; i < lowerGroup.children.length; i++)
            lowerGroup.children[i].value = false;
    });

    middleGroup.addEventListener("click", function () {
        for (var i = 0; i < upperGroup.children.length; i++)
            upperGroup.children[i].value = false;
    });
    middleGroup.addEventListener("click", function () {
        for (var i = 0; i < lowerGroup.children.length; i++)
            lowerGroup.children[i].value = false;
    });

    lowerGroup.addEventListener("click", function () {
        for (var i = 0; i < middleGroup.children.length; i++)
            middleGroup.children[i].value = false;
    });
    lowerGroup.addEventListener("click", function () {
        for (var i = 0; i < upperGroup.children.length; i++)
            upperGroup.children[i].value = false;
    });
    ////////////////////// peter kahrel scriptUI for dummies //////////////////////

    /////////////////////////////// joonas scriptUI ///////////////////////////////
    // OKGROUP
    // =======
    var okGroup = dialogWindow.add("group", undefined, {
        name: "okGroup"
    });
    okGroup.orientation = "column";
    okGroup.alignChildren = ["left", "center"];
    okGroup.spacing = 12;
    okGroup.margins = [1, 1, 1, 1];
    okGroup.alignment = ["left", "center"];

    var okButton = okGroup.add("button", undefined, undefined, {
        name: "okButton"
    });
    okButton.text = "OK";

    var cancelButton = okGroup.add("button", undefined, undefined, {
        name: "cancelButton"
    });
    cancelButton.text = "Cancel";
    /////////////////////////////// joonas scriptUI ///////////////////////////////

    ////////////////////////////// tom_ruark @ adobe //////////////////////////////
    /* https://feedback.photoshop.com/conversations/photoshop/photoshop-ability-to-ruler-origin-by-script/5f5f45bb4b561a3d425c7b32 */
    // Version 2016.11.18
    // Show how to get and set the ruler origin point for the current document
    // Values are in pixels shifted 16 bits
    // some constants to make it more readable

    const classProperty = app.stringIDToTypeID("property");
    const krulerOriginHStr = app.stringIDToTypeID("rulerOriginH");
    const krulerOriginVStr = app.stringIDToTypeID("rulerOriginV");
    const classDocument = app.stringIDToTypeID("document");
    const typeOrdinal = app.stringIDToTypeID("ordinal");
    const enumTarget = app.stringIDToTypeID("targetEnum");
    const typeNULL = app.stringIDToTypeID("null");
    const keyTo = app.stringIDToTypeID("to");
    const eventSet = app.stringIDToTypeID("set");

    // get the current values
    GetRulerOrigin().toSource();

    function GetRulerOrigin() {
        var ro = {};
        ro.horizontal = GetInfo(classDocument, krulerOriginHStr) >> 16;
        ro.vertical = GetInfo(classDocument, krulerOriginVStr) >> 16;
        return ro;
    }

    function SetRulerOrigin_Horiz(horiz) {
        var desc = new ActionDescriptor();
        var ref = new ActionReference();
        ref.putProperty(classProperty, krulerOriginHStr);
        ref.putEnumerated(classDocument, typeOrdinal, enumTarget);
        desc.putReference(typeNULL, ref);
        desc.putInteger(keyTo, horiz << 16);
        executeAction(eventSet, desc, DialogModes.NO);
    }

    function SetRulerOrigin_Vert(vert) {
        var desc = new ActionDescriptor();
        var ref = new ActionReference();
        ref.putProperty(classProperty, krulerOriginVStr);
        ref.putEnumerated(classDocument, typeOrdinal, enumTarget);
        desc.putReference(typeNULL, ref);
        desc.putInteger(keyTo, vert << 16);
        executeAction(eventSet, desc, DialogModes.NO);
    }

    ///////////////////////////////////////////////////////////////////////////////
    // Function: GetInfo
    // Usage:    Get information from Photoshop
    // Input:    desiredClass, classApplication, classLayer, etc.
    //           desiredKey, optional specific key to get instead of everything
    //           this is recommended as all keys is an expensive call
    // Return:   ActionDescriptor or single value depending on what is asked for
    ///////////////////////////////////////////////////////////////////////////////
    function GetInfo(desiredClass, desiredKey) {
        var reference = new ActionReference();
        if (typeof desiredKey != "undefined") {
            reference.putProperty(stringIDToTypeID("property"), desiredKey);
        }
        reference.putEnumerated(desiredClass, stringIDToTypeID("ordinal"), stringIDToTypeID("targetEnum"));
        var desc = executeActionGet(reference);
        if (typeof desiredKey != "undefined") {
            return GetItemFromDescriptor(desc, desiredKey);
        }
        return desc;
    }

    ///////////////////////////////////////////////////////////////////////////////
    // Function: GetItemFromDescriptor
    // Usage:    Get a specific key from an ActionDescriptor
    // Input:    desc (ActionDescriptor), valid ActionDescriptor to pull info from
    //           desiredKey (Number), key in question, use charIDToTypeID() or
    //           stringIDToTypeID()
    // Return:   ActionDescriptor or single value depending on what is asked for
    ///////////////////////////////////////////////////////////////////////////////
    function GetItemFromDescriptor(desc, desiredKey) {
        if (desc.hasKey(desiredKey)) {
            var typeID = desc.getType(desiredKey);
            switch (typeID) {
                case DescValueType.BOOLEANTYPE:
                    return desc.getBoolean(desiredKey);
                    break;
                case DescValueType.STRINGTYPE:
                    return desc.getString(desiredKey);
                    break;
                case DescValueType.DOUBLETYPE:
                    return desc.getDouble(desiredKey);
                    break;
                case DescValueType.INTEGERTYPE:
                    return desc.getInteger(desiredKey);
                    break;
                case DescValueType.LARGEINTEGERTYPE:
                    return desc.getLargeInteger(desiredKey);
                    break;
                case DescValueType.OBJECTTYPE:
                    return desc.getObjectValue(desiredKey);
                    break;
                case DescValueType.UNITDOUBLE:
                    var newT = desc.getUnitDoubleType(desiredKey);
                    var newV = desc.getUnitDoubleValue(desiredKey);
                    return new UnitValue(newV, newT);
                    break;
                case DescValueType.ENUMERATEDTYPE:
                    return desc.getEnumerationValue(desiredKey);
                    break;
                case DescValueType.CLASSTYPE:
                    return desc.getClass(desiredKey);
                    break;
                case DescValueType.ALIASTYPE:
                    return desc.getPath(desiredKey);
                    break;
                case DescValueType.RAWTYPE:
                    var tempStr = desc.getData(desiredKey);
                    var rawData = new Array();
                    for (var tempi = 0; tempi < tempStr.length; tempi++) {
                        rawData[tempi] = tempStr.charCodeAt(tempi);
                    }
                    return rawData;
                    break;
                case DescValueType.REFERENCETYPE:
                    return desc.getReference(desiredKey);
                    break;
                case DescValueType.LISTTYPE:
                    return desc.getList(desiredKey);
                    break;
                default:
                    return;
            }
        }
        return;
    }
    ////////////////////////////// tom_ruark @ adobe //////////////////////////////

    /////////////////////////////// joonas scriptUI ///////////////////////////////
    okButton.onClick = function () {
        dialogWindow.close();
        /////////////////////////////// joonas scriptUI ///////////////////////////////

        // Link function parameters to X & Y field values
        if (xValue.text.length > 0) {
            // Reset ruler origin to zero for a known start point
            SetRulerOrigin_Horiz(0);
            // Set ruler origin to variables
            SetRulerOrigin_Horiz(xValue.text);
        }

        if (yValue.text.length > 0) {
            // Reset ruler origin to zero for a known start point
            SetRulerOrigin_Vert(0);
            // Set ruler origin to variables
            SetRulerOrigin_Vert(yValue.text);
        }

        // Canvas variables
        var rE = app.activeDocument.width; // rightEdge
        var hC = app.activeDocument.width / 2; // horizontalCenter
        var vC = app.activeDocument.height / 2; // verticalCenter
        var bE = app.activeDocument.height; // bottomEdge

        // Link function parameters to radio buttons
        if (upperLeft.value === true) {
            // Reset ruler origin to zero for a known start point
            SetRulerOrigin_Horiz(0);
            SetRulerOrigin_Vert(0);
        }

        if (upperCenter.value === true) {
            // Reset ruler origin to zero for a known start point
            SetRulerOrigin_Horiz(0);
            SetRulerOrigin_Vert(0);
            // Set ruler origin to variables
            SetRulerOrigin_Horiz(hC);
            SetRulerOrigin_Vert(0);
        }

        if (upperRight.value === true) {
            // Reset ruler origin to zero for a known start point
            SetRulerOrigin_Horiz(0);
            SetRulerOrigin_Vert(0);
            // Set ruler origin to variables
            SetRulerOrigin_Horiz(rE);
            SetRulerOrigin_Vert(0);
        }

        if (middleLeft.value === true) {
            // Reset ruler origin to zero for a known start point
            SetRulerOrigin_Horiz(0);
            SetRulerOrigin_Vert(0);
            // Set ruler origin to variables
            SetRulerOrigin_Horiz(0);
            SetRulerOrigin_Vert(vC);
        }

        if (middleCenter.value === true) {
            // Reset ruler origin to zero for a known start point
            SetRulerOrigin_Horiz(0);
            SetRulerOrigin_Vert(0);
            // Set ruler origin to variables
            SetRulerOrigin_Horiz(hC);
            SetRulerOrigin_Vert(vC);
        }

        if (middleRight.value === true) {
            // Reset ruler origin to zero for a known start point
            SetRulerOrigin_Horiz(0);
            SetRulerOrigin_Vert(0);
            // Set ruler origin to variables
            SetRulerOrigin_Horiz(rE);
            SetRulerOrigin_Vert(vC);
        }

        if (lowerLeft.value === true) {
            // Reset ruler origin to zero for a known start point
            SetRulerOrigin_Horiz(0);
            SetRulerOrigin_Vert(0);
            // Set ruler origin to variables
            SetRulerOrigin_Horiz(0);
            SetRulerOrigin_Vert(bE);
        }

        if (lowerCenter.value === true) {
            // Reset ruler origin to zero for a known start point
            SetRulerOrigin_Horiz(0);
            SetRulerOrigin_Vert(0);
            // Set ruler origin to variables
            SetRulerOrigin_Horiz(hC);
            SetRulerOrigin_Vert(bE);
        }

        if (lowerRight.value === true) {
            // Reset ruler origin to zero for a known start point
            SetRulerOrigin_Horiz(0);
            SetRulerOrigin_Vert(0);
            // Set ruler origin to variables
            SetRulerOrigin_Horiz(rE);
            SetRulerOrigin_Vert(bE);
        }
    }

    /////////////////////////////// joonas scriptUI ///////////////////////////////
    // Execute window
    dialogWindow.show();
    /////////////////////////////// joonas scriptUI ///////////////////////////////

    ////////////////////////////// tom_ruark @ adobe //////////////////////////////
    // Function to limit keyboard entry to digits
    function NumericEditKeyboardHandler(event) {
        try {
            var keyIsOK = KeyIsNumeric(event) ||
                KeyIsDelete(event) ||
                KeyIsLRArrow(event) ||
                KeyIsTabEnterEscape(event);

            if (!keyIsOK) {
                // Bad input: tell ScriptUI not to accept the keydown event
                event.preventDefault();
                /*
                Notify user of invalid input: make sure NOT
                to put up an alert dialog or do anything which
                requires user interaction, because that
                interferes with preventing the 'default'
                action for the keydown event */
                app.beep();
            }
        } catch (e) {
            // alert ("Ack! bug in NumericEditKeyboardHandler: " + e);
        }
    }

    function KeyHasModifier(event) {
        return event.shiftKey || event.ctrlKey || event.altKey || event.metaKey;
    }

    function KeyIsNumeric(event) {
        return (event.keyName >= '0') && (event.keyName <= '9') && !KeyHasModifier(event);
    }

    function KeyIsDelete(event) {
        return (event.keyName == 'Backspace') && !(event.ctrlKey);
    }

    function KeyIsLRArrow(event) {
        return ((event.keyName == 'Left') || (event.keyName == 'Right')) && !(event.altKey || event.metaKey);
    }

    function KeyIsTabEnterEscape(event) {
        return event.keyName == 'Tab' || event.keyName == 'Enter' || event.keyName == 'Escape';
    }
    ////////////////////////////// tom_ruark @ adobe //////////////////////////////

    // Restore the ruler units
    app.preferences.rulerUnits = savedRuler;

}

else {
    alert('A document must be open to use this script!');
}

Tom Ruark

Inspiring

Yes, it is the visibility and discoverability that I had in mind.

I suggested to Paul Riggott to create a Github of his creation, which he did.

Not sure about the legality of creating a community Github, listing all the scripts/Scriptlets shared here.

I know it would be quite an endeavour.

I'm afraid of the fact that we've not heard from him for far too long.

"but the Action did not record my dragging the origin to the lower left corner." The drag or using the arrow keys when the move tool is selected puts Photoshop into a "follow on" or "reusable" action. Instead of recording "move one pixel down" over and over and over again Photoshop keeps track and just ends up with "move 4 pixels down." If you have actions panel recording you can see this, select move tool, move with arrow or mouse, then do something else, like select another layer, and you get two entries in actions panel, the final resting spot of the move and the layer select. If you can get the dimensions and location of the thing you are moving then just move it to "0, x" for left, "x, 0" for top. Does that work?

But I DO like the idea of a command that says, "move to the top" have you played with the alignment options in the move tool bar. Select two layers and pick: "Align vertical centers" that records in the actions panel.