Would provide a convenient way to bind the instance as a context to an instance method and arguments.

INSTEAD OF...

setTimeout (function () {m.hideMenu ()},0);

USE...

setTimeout (m.bind ('hideMenu'),0);

IMPLEMENTATION

var _bind = Uize.nop.bind || function (_context) {
  var
    _args = [].slice.call (arguments,1),
    _function = this
  ;
  return function () {
    return _function.apply (_context,_args.concat (Uize.copyList (arguments)));
  };
};

_class.prototype.bind = function (_method) {
  var
    _context = this,
    _args = arguments
  ;
  _args = _args.length > 1 && [].slice.call (_args,1);
  if (typeof _function == 'string')
    _function = _context [_function]
  ;
  return _args ? _bind.apply (_function,[_context].concat (_args)) : _bind.call (_function,_context);
};

1.1. Impact

Similar to the system of virtual DOM events.

Virtual events can be parameterized. When multiple handlers are wired for the same virtual event, the setup for the event is shared amongst all handlers.

2.1. Representing Conditions as Virtual Events

myWidget.wire (
  Uize.Class.virtualEvent ('whenever','theme => theme == "bottle"'),
  function () {
    // do stuff whenever condition is met
  }
);

myWidget.wire (
  Uize.Class.virtualEvent ('whenever',function (theme) {return theme == 'bottle'}),
  function () {
    // do stuff whenever condition is met
  }
);

myWidget.wire (
  'whenever("theme => theme == \'bottle\'")',
  function () {
    // do stuff whenever condition is met
  }
);

2.2. The next Virtual Event

myWidget.wire (
  'next("Click")',
  function () {
    // do something for only the very next click
  }
);

myWidget.onNext(
  'Click',
  function () {
    // do something for only the very next click
  }
);

SYNTAX

propertiesExpressionFUNC = Uize.propertiesExpression (expressionFUNC);

INSTEAD OF...

function (object) {
  return object.get ('width') * object.get ('height');
}

USE...

Uize.propertiesExpression (
  function (width,height) {return width * height};
}

A derived property is a special type of state property whose value is derived from the values of other state properties of the same instance.

EXAMPLE

_class.stateProperties ({
  _allSelected:{
    name:'allSelected',
    derived:'totalSelected,totalItems: totalSelected > 0 && totalSelected == totalItems'
  },
  _oneSelected:{
    name:'oneSelected',
    derived:'totalSelected: totalSelected == 1'
  },
  _someSelected:{
    name:'someSelected',
    derived:'totalSelected: totalSelected > 0'
  },
  _totalSelected:{
    name:'totalSelected',
    value:0
  },
  _totalItems:{
    name:'totalItems',
    value:0
  }
});

In the above example, the allSelected, oneSelected, and someSelected state properties are all derived properties. A state property is indicated as being a derived property by the presence of the derived property in the property profile. The derived property serves both to indicate that a state property is derived, as well to provide the deriver function that indicates from which other state properties the derived property is derived and how to calculate the derived value.

4.1. Implementation Questions

4.2. Implementation Approaches

Provide a way in the Uize.Class base class to bind two state properties together, in order to keep their values synchronized.

This would provide a more concise and lightweight way of binding properties than using an instance of the Uize.Util.PropertyAdapter class.

INSTEAD OF...

Uize.Util.PropertyAdapter ({propertyA:[this,'prop'],propertyB:[slider,'prop']});

USE...

m.bindProperty ('prop',[slider,'prop']);

BENEFITS

NOTES

Copy ability, for initial values of state properties that are arrays or objects.

Have a property that can be specified in a state property's profile, which can be used to cause properties whose initial values are object types to be initialized by cloning the initial value rather than simply setting a reference to a shared object.

Variation on constructor, where specifying a non-object for the properties has the effect of setting the value property.

For example, if Uize.Color were to become a subclass of Uize.Class...

EXAMPLE

Uize.Color ({value:'#ffffff'});  // old form
Uize.Color ('#ffffff');          // new form

Or, in the case of an existing widget class that supports the value interface...

EXAMPLE

Uize.Widget.Bar.Slider ({value:50});  // old form
Uize.Widget.Bar.Slider (50);          // old form

8.1. New Profile Features

The originator of a property set knows that the property is being set, so doesn't want to be informed of a change in the value?

A way to provide an ID for the originator of a set? The basic ongoing problem is when multiple sources want to be able to change and also be informed of changes in a particular property. How does one make this more efficient and eliminate multiple redundant execution triggered by events?