Slate Config

.slate.js

$ = (function() {
    $ = function() {
        var args = _.toArray(arguments);
        var sequence = false;
        var func;
        if (args.length == 1 && _.isArray(args[0])) {
            sequence = true;
        } else {
            func = args.shift();
        }

        function call(win, func, args) {
            try {
                ret = win[func].apply(win, args);
            } finally {
                if (win.isOffscreen())
                    win.rescue();
            }
        }
        function dispatch(win) {
            if (sequence) {
                _.each(args, function(sub) {
                    var func = sub.shift();
                    call(win, func, sub);
                });
            } else {
                call(win, func, args);
            }
        }
        return dispatch;
    };

    function Proxy(parent, keys, base) {
        var proxy = {};
        var _super = {};
        _.each(keys, function(key) {
            var value = parent[key];
            if (_.isFunction(value)) {
                _super[key] = proxy[key] = (function() {
                    var func = value;
                    return function() {
                        return func.apply(parent, arguments);
                    };
                })();
            } else {
                _super[key] = proxy[key] = parent[key];
            }
        });
        $.addNames(base, function(member, key) {
            var parent = base.name;
            if (proxy.title) {
                var title = '"' + proxy.title() + '"';
                if (proxy.app) {
                    var name = proxy.app().name();
                    title = '[' + name + ']: ' + title;
                }
                parent += '(' + title + ')';
            }
            return parent + '.' + key;
        });
        _.extend(proxy, base);
        proxy._super = _super;
        if (proxy.update)
            proxy.update();
        return proxy;
    }

    function ProxyMember() {
        function wrapper() {
            return wrapper._init.apply(wrapper, arguments);
        }
        return wrapper;
    }

    _.extend($, {
        debug: false,
        log: function() {
            if (this.debug) {
                S.log.apply(S, arguments);
            }
        },
        addNames: function(obj, extra) {
            _.each(obj, function(member, key) {
                if (_.isFunction(member)) {
                    if (_.isFunction(extra)) {
                        member._name = extra(member, key);
                    } else {
                        member._name = key + '()';
                    }
                }
            });
        },
        backtrace: function(error) {
            if (error) {
                if (error instanceof Error) {
                    $.log('Error (line ' + error.line + ')  : ' + error);
                } else {
                    $.log('Error: ' + error);
                }
            }
            var stack = [];
            var current = arguments.callee.caller;
            var iterations = 0;
            while (current) {
                iterations++;
                if (iterations > 10) {
                    break; // nope nope nope
                }
                var fn = current;
                var name = fn._name;

                // determine the function name
                if (! name)
                    name = (fn.name || fn);
                var args = JSON.stringify(_.toArray(current.arguments));
                args = args.replace(/^\[/, '(').replace(/]$/, ')');
                var pretty = name + args;
                stack.push(pretty);

                // add a hotkey line to the stacktrace when we get to that point
                if (fn._hotkey) {
                    var key = fn._hotkey;
                    if (_.contains(key, ':')) {
                        var parts = key.split(':');
                        key = parts[0];
                        mods = parts[1].replace(/;/g, '+');
                        if (mods) {
                            key = mods + '-' + key;
                        }
                    }
                    key = key.replace(/\b\S/g, function(a) { return a.toUpperCase(); });
                    stack.push('Hotkey Pressed: "' + key + '"');
                }
                current = current.caller;
            }
            $.log('Backtrace:');
            for (var i = 0; i < stack.length; i++) {
                $.log(' - ' + i + ': ' + stack[i]);
            }
        },
        focus: function(name) {
            name = name.replace('"', '\"');
            return 'focus "' + name + '"';
        },
        chain: function() {
            var ops = [];
            _.each(arguments, function(op) {
                if (_.isString(op)) {
                    op = slate.operationFromString(op);
                }
                if (_.isFunction(op)) {
                    var call = op;
                    op = function(win) {
                        return call($.window(win));
                    };
                }
                ops.push(op);
            });
            return slate.operation('chain', {operations: ops});
        },
        rect: ProxyMember(),
        window: ProxyMember(),
        screen: ProxyMember()
    });

    $.addNames($);

    _.extend($.rect, {
        _keys: ['x', 'y', 'width', 'height'],
        _init: function(rect) {
            if (rect === undefined) {
                $.log('slate.js - warning: offscreen window?');
                rect = {x: 0, y: 0, width: 1, height: 1};
            }
            return Proxy(rect, this._keys, $.rect);
        }
    });

    _.extend($.screen, {
        _keys: ['id', 'rect', 'visibleRect', 'isMain'],
        _init: function(screen) {
            if (screen == undefined) {
                screen = S.screen();
            }
            return Proxy(screen, this._keys, $.screen);
        },
        rect: function() {
            return $.rect(this._super.visibleRect());
        },
        update: function() {
            var _super = this._super;
            _.extend(this, this.rect());
            this._super = _super;
        }
    });

    _.extend($.window, {
        _keys: [
            'title', 'topLeft', 'size', 'rect', 'pid',
            'focus', 'isMinimizedOrHidden', 'isMain',
            'move', 'isMovable', 'resize', 'isResizable',
            'doOperation', 'screen', 'app'
        ],
        _init: function(win) {
            if (win == undefined) {
                win = S.window();
            }
            var keys = 
            win = Proxy(win, this._keys, $.window);
            if (win.isOffscreen())
                win.rescue();
            return win;
        },
        // internals
        rect: function() {
            return $.rect(this._super.rect());
        },
        screen: function() {
            return $.screen(this._super.screen());
        },
        update: function() {
            // make sure to update if you use any internal move/resize ops
            var _super = this._super;
            _.extend(this, this.rect());
            this._super = _super;
        },
        isOffscreen: function() {
            return this.screen().visibleRect() === undefined;
        },
        rescue: function() {
            this.op('throw 0 resize');
            this.op('throw 0 resize');
        },
        op: function(cmd, args) {
            var op;
            if (args === undefined) {
                op = slate.operationFromString(cmd);
            } else {
                op = slate.operation(cmd, args);
            }
            return this.doOperation(op);
        }
    });
    return $;
})();

/* Slate monkeypatching
 *
 * Here, we replace slate commands and add some new ones.
 *
 * slate.alias(alias, modifier):
 *      Binds 'alias' to 'modifier'.
 *
 *      Example:
 *          slate.alias('hyper', 'cmd;alt;shift');
 *          slate.bind('u:hyper', 'throw 0');
 *
 * slate.removeAlias(alias):
 *      Removes a previously created alias.
 *
 * slate.bind(key, operation):
 *      Bind a key to operation(s).
 *
 *      Enhanced as follows:
 *
 *        * Enables 'chain' functionality via array:
 *          slate.bind('a': ['throw 0', 'throw 1']);
 *
 *        * Allows usage of string ops without calling operationFromString()
 *        * Overloads window objects passed to function callbacks.
 *        * Adds backtrace metadata.
 *
 * slate.bindAll(object):
 *      Bind key(s) to operation(s).
 *
 *      Enhanced as follows:
 *        * Allows deeply nested bindings with inherited modifiers:
 *          slate.bind({
 *              hyper: {
 *                  u: 'throw 0',    // hyper+u
 *                  shift: {         // hyper+shift
 *                      u: 'throw 1' // hyper+shift+u
 *                  }
 *              }
 *          });
 *
 */
(function() {
    var windows = {};
    var aliases = {};
    var preHooks = [];
    var postHooks = [];

    function appendModifier(key, modifier) {
        modifier = modifier.replace(':', ';');
        if (key.indexOf(':') !== -1) {
            return key + ';' + modifier;
        } else {
            return key + ':' + modifier;
        }
    }

    function makeCallback(key, op) {
        var func;
        if (_.isArray(op)) {
            var ops = [];
            _.each(op, function(o) {
                o = makeCallback(key, o);
                ops.push(o);
            });
            return $.chain.apply(null, ops);
        } else if (_.isString(op)) {
            var strOp = op;
            func = function(win) {
                win.op(strOp);
            };
        } else if (_.isFunction(op)) {
            func = op;
        } else {
            S.log('unknown op:', op, typeof op);
            return null;
        }

        return function(win) {
            try {
                _.each(preHooks, function(callback) {
                    callback(key, win);
                });
            } catch (e) {
                $.backtrace(e);
                S.log('supressing exception in pre-hook.');
            }
            try {
                return func(win);
            } catch (e) {
                $.backtrace(e);
                throw e;
            } finally {
                try {
                    _.each(postHooks, function(callback) {
                        callback(key, win);
                    });
                } catch (e) {
                    throw e;
                }
            }
        };
    }

    var _bind = slate.bind;
    _.extend(slate, {
        alias: function(alias, mod) {
            aliases[alias] = mod;
        },
        removeAlias: function(alias) {
            delete aliases[alias];
        },
        pre: function(func) {
            preHooks.push(func);
        },
        post: function(func) {
            postHooks.push(func);
        },
        bind: function(key, op) {
            _.each(aliases, function(mod, alias) {
                key = key.replace(alias, mod);
            });
            if (_.isObject(op) && !(_.isArray(op) || _.isFunction(op))) {
                // nested modifiers
                slate.bindAll(op, key);
                return;
            }
            op = makeCallback(key, op);
            if (_.isFunction(op)) {
                function callback(win) {
                    if (win === undefined) {
                        // this won't go well
                        return false;
                    }
                    // reuse proxy objects in callbacks
                    // this means you can store persistent data on a $.window()
                    var pid = win.pid();
                    if (_.has(windows, pid)) {
                        win = _.extend(windows[pid], $.window(win));
                    } else {
                        win = windows[pid] = $.window(win);
                    }
                    return op(win);
                }
                callback._hotkey = key;
                _bind(key, callback);
            } else if (op) {
                _bind(key, op);
            }
        },
        bindAll: function(obj, modifier) {
            _.each(obj, function(op, key) {
                if (modifier !== undefined) {
                    key = appendModifier(key, modifier);
                }
                slate.bind(key, op);
            });
        }
    });
})();

// prototype+extensions

/* Rect methods.
 * Keep in mind 'Window objects' and 'Screen objects'
 * inherit all properties from their rect.
 *
 * rect.bordered(borderSize):
 *      Shrink the rect by a border and return it.
 *
 * rect.left():
 * rect.right():
 * rect.top():
 * rect.bottom():
 *      Read the code below. It's simple wrapping/math.
 *
 * rect.midY():
 *      Returns the rect's vertical center.
 *
 * rect.midX():
 *      Returns the rect's horizontal center.
 *      
 */
_.extend($.rect, {
    bordered: function(border) {
        this.x += border / 2;
        this.y += border / 2;
        this.width -= border;
        this.height -= border;
        return this;
    },
    left: function() {
        return this.x;
    },
    right: function() {
        return this.x + this.width;
    },
    top: function() {
        return this.y;
    },
    bottom: function() {
        return this.y + this.height;
    },
    midY: function() {
        return this.y + (this.height / 2);
    },
    midX: function() {
        return this.x + (this.width / 2);
    }
});

/* Window methods
 *
 * A few standard methods are replaced, and some operations
 * are completely replaced with very similar object methods.
 *
 * window.barResize(dir, div, pos):
 *      Turns a window into a full-height or width bar across the screen,
 *      and pushes it to an edge.
 *
 *      @dir = (left, right, top, bottom)
 *      @div (default=2) resizes the perpindicular side,
 *      with size based on the corresponding screen dimension
 *      @pos (default=0) can be used to place the resulting bar
 *      somewhere in the middle of the screen.
 *
 * window.center(dir, horiz, vert):
 *      Centers a window in direction, optionally changing the dimensions
 *      by a screen division horizontally/vertically.
 *
 *      @dir: Pick one of the following:
 *          1. any combination of (top, left, right, bottom).
 *          2. one of "horiz", "vert", 'center"
 *          Valid choices include (but aren't limited to):
 *              "left", "top-left", "right", "bottom-right", "center", "horiz"
 *
 *      @horiz, @vert (optional): see window.divResize() for details
 *      (You must provide both @horiz and @vert for the resize to take place).
 *
 * window.corner(dir, horiz, vert):
 *      Places a window in a corner, resizing by horiz and vert.
 *
 *      @corner: Pick from:
 *          "top-left", "top-right", "bottom-left", "bottom-right"
 *
 *      @horiz, @vert (optional): see window.divResize() for details
 *
 * window.divResize(horiz, vert):
 *      Resizes a window by dividing the current screen.
 *
 *      @horiz (default=1): width  = screen.width  / @horiz
 *      @vert  (default=1): height = screen.height / @vert
 *  
 * window.move(args):
 *      Moves a window to args.x, args.y.
 *
 *      Better than default .move() in the following ways:
 *        * Logs calls.
 *        * Refuses bogus coordinates, which can:
 *            * Crash Slate.
 *            * Lose your window into the ether.
 *        * Updates rect properties on the window (x, y, width, height).
 *
 * window.push(dir):
 *      Alias for window.snap(dir).
 *
 * window.resize(args):
 *      Resizes a window to args.width, args.height.
 *
 *      Better than the default .resize() in the following ways:
 *        * Logs calls.
 *        * Refuses bogus width/height.
 *        * Guaranteed to end up <= your specified size, even in Terminal.app.
 *        * Won't get confused if the Window is in a weird position.
 *        * Updates rect properties on the window.
 *
 * window.snap(dir):
 *      Snaps a window to a direction, with slight bias
 *      to the top left of the screen for consistency.
 *
 *      @dir: any combination of "left", "top", "right", "bottom"
 *      Examples: "left", "top-left", "left-top", "bottom", "bottom-right"
 *
 * window.throw(screen, resize):
 *      Aliased to 'toss'. Throw is a reserved keyword in JS.
 *
 * window.toss(screen, resize):
 *      Throws a window to a screen, resizing if desired.
 *
 *      Advantages over default 'throw':
 *        * Resize consistently works the first time.
 *        * Better resize heuristics.
 */
_.extend($.window, {
    barResize: function(dir, div, pos) {
        div = (div || 2);
        var s = this.screen();
        if (dir == 'left' || dir == 'right') {
            this.divResize(div, 1, pos, 0);
        } else if (dir == 'top' || dir == 'bottom') {
            this.divResize(1, div, 0, pos);
        }
    },
    center: function(dir, horiz, vert) {
        $.log('center', dir, horiz, vert);
        if (horiz && vert)
            this.divResize(horiz, vert);
        var s = this.screen();
        var width, height;
        var x = this.x;
        var y = this.y;
        if (dir == 'left' || dir == 'right') {
            this.center('vert');
            this.snap(dir);
        } else if (dir == 'top' || dir == 'bottom') {
            this.center('horiz');
            this.snap(dir);
        } else if (dir == 'center') {
            this.center('horiz');
            this.center('vert');
        } else if (dir == 'horiz') {
            width = this.width;
            x = s.midX() - (width / 2);
            this.move({x: x, y: y});
        } else if (dir == 'vert') {
            height = this.height;
            y = s.midY() - (height / 2);
            this.move({x: x, y: y});
        } else {
            return;
        }
    },
    corner: function(corner, horiz, vert) {
        $.log('corner', JSON.stringify([corner, horiz, vert]));
        this.divResize(horiz || 2, vert || 2);
        this.snap(corner);
    },
    divResize: function(horiz, vert, horizPos, vertPos) {
        var s = this.screen();
        var width = s.width / (horiz || 1);
        var height = s.height / (vert || 1);
        this.resize({width: width, height: height});
        if ( horizPos && ( ( horiz > 1 && horiz < 2) || horizPos == horiz - 1 ) )
            width = s.width - width;
        else
            width = width * (horizPos || 0);
        if ( vertPos && ( (vert > 1 && vert < 2) || vertPos && vertPos == vert - 1 ) )
            height = s.height - height;
        else
            height = height * (vertPos || 0);
        this.move({x: width, y: height});
    },
    move: function(args) {
        // TODO: also allow calling with (x, y)
        $.log('move', JSON.stringify(args));
        var x = args.x;
        var y = args.y;
        if ((x !== 0 && !x) || (y !== 0 && !y)) {
            $.backtrace('Invalid move destination.');
            return;
        }
        this._super.move(args);
        this.update();
    },
    push: function(dir) {
        this.snap(dir);
    },
    resize: function(args) {
        // TODO: allow calling with (width, height)
        $.log('resize', JSON.stringify(args));
        var width = args.width;
        var height = args.height;
        if ((width !== 0 && !width || width < 0) ||
            (height !== 0 && !height || height < 0)) {
            $.backtrace('Invalid resize.');
            return;
        }

        var s = this.screen();
        // give ourselves enough room to resize
        var x = Math.min(this.x, s.right() - width);
        var y = Math.min(this.y, s.bottom() - height);
        this.move({x: x, y: y});
        this._super.resize(args);
        while (this.rect().height > height + 1) {
            args.height -= 1;
            if (args.height < 0)
                break;
            this._super.resize(args);
        }
        while (this.rect().width > width + 1) {
            args.width -= 1;
            if (args.width < 0)
                break;
            this._super.resize(args);
        }
        this.update();
    },
    snap: function(dir) {
        // like slate's push, but rounds left/top to screen border/center
        $.log('snap', dir);
        var s = this.screen();
        var x = this.x;
        var y = this.y;
        // corners
        var match = dir.match(/^([^-]+)-([^-]+)$/);
        if (match) {
            this.snap(match[1]);
            this.snap(match[2]);
            return;
        }
        // cardinal directions
        var mid;
        if (dir == 'left') {
            x = s.left();
        } else if (dir == 'top') {
            y = s.top();
        } else if (dir == 'right') {
            x = s.right() - this.width;
            mid = Math.abs(x - s.midX());
            if (this.width / mid < 0.05) {
                x = s.midX();
            }
        } else if (dir == 'bottom') {
            y = s.bottom() - this.height;
            mid = Math.abs(y - s.midY());
            if (this.height / mid < 0.05) {
                x = s.midY();
            }
        }
        this.move({x: x, y: y});
    },
    'throw': function() {
        return this.toss.apply(this, arguments);
    },
    toss: function(num, resize) {
        var count, current;
        if (num === '+' || num === '-') {
            count = slate.screenCount();
            $.log('count', count);
            current = this.screen().id();
            $.log('current', current);
            num = (num === '+') ? ++current : --current;
            count--;
            if (num > count) num = 0;
            if (num < 0) num = count;
            $.log('selected', num);
        }
        var screen = slate.screenForRef(num.toString());
        var s = $.screen(screen);
        if (resize)
            this.resize(s.rect());
        this.move(s.rect());
        if (resize)
            this.resize(s.rect());
    }
});



/* File: slate.example.js
 * Author: lunixbochs (Ryan Hileman) and ProLoser (Dean Sofer)
 * Project: http://github.com/lunixbochs/reslate https://github.com/ProLoser/reslate
 */
// enable to see debug messages in Console.app
// $.debug = true;
 
slate.alias('hyper', 'ctrl;alt;cmd');
 
// begin config
slate.configAll({
    defaultToCurrentScreen: true,
    nudgePercentOf: 'screenSize',
    resizePercentOf: 'screenSize',
    undoOps: [
        'active-snapshot',
        'chain',
        'grid',
        'layout',
        'move',
        'resize',
        'sequence',
        'shell',
        'push'
    ]
});

function position(win) {
    $.log('position', 'cols:', win.splitx, 'rows:', win.splity, 'x:', win.offx, 'y:', win.offy);
    var snapRight = (win.offx > 1 && win.offx < 2) && win.offx > 0,
        snapBottom = (win.offy > 1 && win.offy < 2) && win.offy > 0;
    win.divResize(win.splitx, win.splity, win.offx, win.offy, snapRight, snapBottom);
}
function reset(win, hard) {
    if (!win.splitx || hard) {
        win.splitx = 1;
        win.splity = 1;
        win.offx = 0;
        win.offy = 0;
    }
}


var screenCount = slate.screenCount();
steps = [1.5, 2, 3];
var lastStep = steps[steps.length-1];
function nextStep(step) {
    var index = steps.indexOf(step);
    return (index >= steps.length-1) ? steps[0] : steps[++index];
}

// bindings
slate.bindAll({
    hyper: {
        shift: {
            left: function(win) {
                reset(win);
                if (win.offx === 0) {
                    if (screenCount > 1)
                        win.toss('-');
                    win.offx = Math.ceil(win.splitx) - 1;
                } else {
                    win.offx--;
                }
                position(win);
            },
            right: function(win) {
                reset(win);
                win.offx++;
                if (win.offx >= Math.ceil(win.splitx)) {
                    if (screenCount > 1)
                        win.toss('+');
                    win.offx = 0;
                }
                position(win);
            },
            up: function(win) {
                reset(win);
                if (win.offy === 0) {
                    win.offy = Math.ceil(win.splity) - 1;
                } else {
                    win.offy--;
                }
                position(win);
            },
            down: function(win) {
                reset(win);
                win.offy++;
                if (win.offy >= Math.ceil(win.splity))
                    win.offy = 0;
                position(win);
            }
        },
        left: function(win) {
            reset(win);
            if (win.offx === 0) {
                if (screenCount > 1 && win.splitx === lastStep) {
                    reset(win, true);
                    win.toss('-', 'resize');
                } else {
                    win.splitx = nextStep(win.splitx);
                    position(win);
                }
            } else {
                win.offx--;
                position(win);
            }
        },
        j: function(win){this.left(win);},
        right: function(win) {
            reset(win);
            if (win.offx === win.splitx - 1 || win.offx && win.splitx > 1 && win.splitx < 2) {
                if (screenCount > 1 && win.splitx === lastStep) {
                    reset(win, true);
                    win.toss('+', 'resize');
                } else {
                    var nextSplit = nextStep(win.splitx);
                    if (nextSplit > 2 || !win.offx)
                        win.offx++;
                    if (nextSplit < win.splitx)
                        win.offx = Math.ceil(nextSplit) - 1;
                    win.splitx = nextSplit;
                    position(win);
                }
            } else {
                win.offx++;
                position(win);
            }
        },
        l: function(win){this.right(win);},
        up: function(win) {
            reset(win);
            if (win.offy === 0) {
                win.splity = nextStep(win.splity);
            } else {
                win.offy--;
            }
            position(win);
        },
        i: function(win){this.up(win);},
        down: function(win) {
            reset(win);
            if (win.offy === win.splity - 1 || win.offy && win.splity > 1 && win.splity < 2) {
                var nextSplit = nextStep(win.splity);
                if (nextSplit > 2 || !win.offy)
                    win.offy++;
                if (nextSplit < win.splity) 
                    win.offy = Math.ceil(nextSplit) - 1;
                win.splity = nextSplit;
            } else {
                win.offy++;
            }
            position(win);
        },
        k: function(win){this.down(win);},
        space: function(win) {
            reset(win, true);
            position(win);
        },
        'return': [
            $('barResize', 'left', 1),
            $('center', 'center', 1.5, 1.25)
        ],
        // throw to monitor
        '`': ['throw 0 resize',
              'throw 1 resize'],
        // direct focus 
        // utility functions
        f1: 'relaunch',
        z: 'undo'
    }
});
 
// Auto Snapshotting
 
// Returns name generated from screen resolutions
function getName() {
  var name = [];
  slate.eachScreen(function(screen){
    var rect = screen.rect();
    name.push(rect.width+'x'+rect.height);
  });
  return name;
}
 

// Save snapshot
function save(event, win){
  $.log('saved', getName());
  slate.operation("snapshot", {
    name: getName().join('y'),
    save: true
  }).run();
  // slate.default(getName(), getName().join('y'));
}
 
// Load snapshot
function load(event, win){
  $.log('loaded', getName());
  slate.operation("activate-snapshot", {
    name: getName().join('y')
  }).run();
}

// slate.on('windowMoved', save);
// slate.on('windowResized', save);
// slate.on('appOpened', load);
// TODO: Requires 'screenConfigurationChanged' for some reason
slate.on('screenConfigurationChanged', function(){
    screenCount = slate.screenCount();
});