kiwi

• create Solver0ms ‣

  var solver = new kiwi.Solver();
  assert(solver);

• Variable

  • new Variable() => value: 00ms ‣

    variable = new kiwi.Variable();
    assert(variable);
    assert.equal(0, variable.value());

  • new Variable("somename") => name: "somename"0ms ‣

    var var2 = new kiwi.Variable('somename');
    assert.equal(var2.name(), 'somename');

  • variable.setName("skiwi") => name: "skiwi"0ms ‣

    var var2 = new kiwi.Variable();
    var2.setName('skiwi');
    assert.equal(var2.name(), 'skiwi');

  • solver.addEditVariable(variable, Strength.strong) => solver.hasEditVariable(): true1ms ‣

    solver.addEditVariable(variable, kiwi.Strength.strong);
    assert(solver.hasEditVariable(variable));

  • solver.suggestValue(variable, 200) => value: 2000ms ‣

    solver.suggestValue(variable, 200);
    solver.updateVariables();
    assert.equal(200, variable.value());

  • solver.removeEditVariable(variable) => solver.hasEditVariable(): false0ms ‣

    assert(solver.hasEditVariable(variable));
    solver.removeEditVariable(variable);
    assert(!solver.hasEditVariable(variable));

  • solver.addEditVariable(variable) => throw exception: "duplicate edit variable"0ms ‣

    assert(!solver.hasEditVariable(variable));
    solver.addEditVariable(variable, kiwi.Strength.strong);
    assert(solver.hasEditVariable(variable));
    try {
        solver.addEditVariable(variable, kiwi.Strength.strong);
        assert(false);
    }
    catch (err) {
        assert.equal(err.message, 'duplicate edit variable');
    }

  • solver.addEditVariable(variable) => throw exception: "unknown edit variable"0ms ‣

    assert(solver.hasEditVariable(variable));
    solver.removeEditVariable(variable);
    assert(!solver.hasEditVariable(variable));
    try {
        solver.removeEditVariable(variable);
        assert(false);
    }
    catch (err) {
        assert.equal(err.message, 'unknown edit variable');
    }

• Expression

  • new Expression()0ms ‣

    assert(new kiwi.Expression());

  • new Expression(variable)0ms ‣

    assert(new kiwi.Expression(new kiwi.Variable()));

  • new Expression([-1, new Variable()])0ms ‣

    assert(new kiwi.Expression([-1, new kiwi.Variable()]));

  • new Expression([variable, -1]) => throw exception: "array item 0 must be a number"0ms ‣

    try {
        new kiwi.Expression([new kiwi.Variable(), -1]);
        assert(false);
    }
    catch (err) {
        assert.equal(err.message, 'array item 0 must be a number');
    }

  • new Expression([-1, 100]) => throw exception: "array item 1 must be a variable or expression"0ms ‣

    try {
        new kiwi.Expression([-1, 100]);
        assert(false);
    }
    catch (err) {
        assert.equal(err.message, 'array item 1 must be a variable or expression');
    }

  • new Expression(10, 20, 30, 40) => constant: 1001ms ‣

    assert.equal((new kiwi.Expression(10, 20, 30, 40)).constant(), 100);

  • new Expression([-1, new Expression(10)]) => constant: -100ms ‣

    assert.equal((new kiwi.Expression([-1, new kiwi.Expression(10)])).constant(), -10);

  • new Expression(new Expression(10), new Expression(20)) => constant: 300ms ‣

    assert.equal((new kiwi.Expression(new kiwi.Expression(10), new kiwi.Expression(20))).constant(), 30);

  • new Expression(20, [0.5, new Expression(10), -10]) => constant: 150ms ‣

    assert.equal((new kiwi.Expression(20, [0.5, new kiwi.Expression(10)], -10)).constant(), 15);

• Constraint

  • new Constraint(expr, ...) == constraint.expression()0ms ‣

    var expr = new kiwi.Expression(10);
    var cn = new kiwi.Constraint(expr, kiwi.Operator.Eq);
    assert.equal(cn.expression(), expr);

  • new Constraint(..., Operator.Ge, ...) == constraint.op()0ms ‣

    var cn = new kiwi.Constraint(new kiwi.Expression(10), kiwi.Operator.Ge);
    assert.equal(cn.op(), kiwi.Operator.Ge);

  • new Constraint(..., ..., ..., Strength.medium) == constraint.strength()0ms ‣

    var cn = new kiwi.Constraint(new kiwi.Expression(10), kiwi.Operator.Le, undefined, kiwi.Strength.medium);
    assert.equal(cn.strength(), kiwi.Strength.medium);

  • Optional strength => constraint.strength(): Strength.required0ms ‣

    var cn = new kiwi.Constraint(new kiwi.Expression(1), kiwi.Operator.Eq);
    assert.equal(cn.strength(), kiwi.Strength.required);

  • solver.addConstraint() => solver.hasConstraint(): true0ms ‣

    var cn = new kiwi.Constraint(new kiwi.Expression(1, -1), kiwi.Operator.Eq);
    assert(!solver.hasConstraint(cn));
    solver.addConstraint(cn);
    assert(solver.hasConstraint(cn));

  • solver.removeConstraint() => solver.hasConstraint(): false0ms ‣

    var cn = new kiwi.Constraint(new kiwi.Expression(1, -1), kiwi.Operator.Eq);
    assert(!solver.hasConstraint(cn));
    solver.addConstraint(cn);
    assert(solver.hasConstraint(cn));
    solver.removeConstraint(cn);
    assert(!solver.hasConstraint(cn));

  • solver.addConstraint() 2x => throw exception: "duplicate constraint"0ms ‣

    var cn = new kiwi.Constraint(new kiwi.Expression(1, -1), kiwi.Operator.Eq);
    solver.addConstraint(cn);
    try {
        solver.addConstraint(cn);
        assert(false);
    } catch(err) {
        assert.equal(err.message, 'duplicate constraint');
    }

  • solver.addConstraint() 2x => throw exception: "unsatisfiable constraint"0ms ‣

    // a constraint consisting of all numbers which are not 0
    var cn = new kiwi.Constraint(new kiwi.Expression(1, -1, 10), kiwi.Operator.Eq);
    try {
        solver.addConstraint(cn);
        assert(false);
    } catch(err) {
        assert.equal(err.message, 'unsatisfiable constraint');
    }

  • solver.addConstraint() 2x => throw exception: "unsatisfiable constraint"1ms ‣

    solver = new kiwi.Solver();
    var width = new kiwi.Variable();
    var width2 = new kiwi.Variable();
    var cn = new kiwi.Constraint(new kiwi.Expression(width, 100), kiwi.Operator.Eq);
    solver.addConstraint(cn);
    cn = new kiwi.Constraint(new kiwi.Expression(width2, 100), kiwi.Operator.Eq);
    solver.addConstraint(cn);
    try {
        cn = new kiwi.Constraint(new kiwi.Expression(width, width2), kiwi.Operator.Eq);
        solver.addConstraint(cn);
        assert(false);
    } catch(err) {
        assert.equal(err.message, 'unsatisfiable constraint');
    }

• Constraint raw syntax: (expr, operator, undefined, strength)

  • Constant left constraint (10)0ms ‣

    vars.left = new kiwi.Variable();
    var left = new kiwi.Constraint(new kiwi.Expression([-1, vars.left], 10), kiwi.Operator.Eq);
    solver.addConstraint(left);
    solver.updateVariables();
    assert.equal(vars.left.value(), 10);

  • Width edit variable (200)0ms ‣

    vars.width = new kiwi.Variable();
    solver.addEditVariable(vars.width, kiwi.Strength.strong);
    solver.suggestValue(vars.width, 200);
    solver.updateVariables();
    assert.equal(vars.width.value(), 200);

  • Right === left + width (210)0ms ‣

    vars.right = new kiwi.Variable();
    var right = new kiwi.Constraint(new kiwi.Expression([-1, vars.right], vars.left, vars.width), kiwi.Operator.Eq);
    solver.addConstraint(right);
    solver.updateVariables();
    assert.equal(vars.right.value(), 210);

  • centerX === left + (width / 2) (110)0ms ‣

    vars.centerX = new kiwi.Variable();
    var centerX = new kiwi.Constraint(new kiwi.Expression([-1, vars.centerX], vars.left, [0.5, vars.width]), kiwi.Operator.Eq);
    solver.addConstraint(centerX);
    solver.updateVariables();
    assert.equal(vars.centerX.value(), 110);

• Constraint new syntax: (lhs, operator, rhs, strength)

  • right == left.plus(width) => 5000ms ‣

    solver.addConstraint(new kiwi.Constraint(right, kiwi.Operator.Eq, left.plus(width)));
    solver.updateVariables();
    assert.equal(right.value(), 500);

  • centerX == left.plus(width.divide(2)) => 2500ms ‣

    solver.addConstraint(new kiwi.Constraint(centerX, kiwi.Operator.Eq, left.plus(width.divide(2))));
    solver.updateVariables();
    assert.equal(centerX.value(), 250);

  • leftOfCenterX == left.plus(width.divide(2)).minus(10) => 2400ms ‣

    solver.addConstraint(new kiwi.Constraint(leftOfCenterX, kiwi.Operator.Eq, left.plus(width.divide(2)).minus(10)));
    solver.updateVariables();
    assert.equal(leftOfCenterX.value(), 240);

  • createConstraint(bottom, Operator.Eq, top.plus(height)) => 3000ms ‣

    solver.createConstraint(bottom, kiwi.Operator.Eq, top.plus(height));
    solver.updateVariables();
    assert.equal(bottom.value(), 300);