Skip to content


Subversion checkout URL

You can clone with
Download ZIP
Commits on Jan 13, 2011
  1. Huge cleanup.

    - lsd-base is now gone. No more Widget global, everything is now inside LSD namespace. Everything is more lean and nice.
    - Widgets are moved into lsd-widgets submodule
    - New kind of a class - Mixin. It looks like a regular class, but it can be mixed in to the instance of some other class in realtime AND removed from the instance in realtime. Moving most of the features that can be enabled and disabled to mixins. We have following mixins now:
       - Resizable
       - Draggable
       - Focus
       - Position
       - Scrollable
       - Touchable
      From the API standpoint it looks like this: 
       var widget = new LSD.Widget; 
       widget.activate(); //method from LSD.Mixin.Touchable
      Or even like this:
      widget.setAttribute('draggable', true);
      The states are getting transfered into instances transparently. 
    - Command modules are now gone. There is a single module that can attach and detach commands in realtime. States, events and behaviour and proxied to widget.
    - Managed to remove all .Ignore libraries. 
    - Added hooks for LSD initialization. LSD is officially started when atleast one stylesheet is added.
    - Focus is reworked as mixin. Plenty of other traits are now mixins too, but man this one is tough. Who could think it is even possible.
    - Events module was simplified greatly. Added new entity named Event target. All selector-based event assignments should be wrapped into exptected: {} now. (There're inline docs for that!)
    - New module Actions and a new class LSD.Action. Yeah, we had them before, but now they are much cleaner and powerful.
    - Some more 1.3 transition
    - Few regressions...
Commits on Dec 11, 2010
  1. It's been 1.5 months of work. Tons of tasty cool features.

    * Got our own namespace now (LSD), everything that was -art art. or ART. and was not related to actual mootools-art library is lsd now.
    * Layer rendering is redone from scratch. We used to have array of layers that were created when widget was built and every time render is triggered, every one of them would getStyles for what it needs and then decides if it needs to render or not. Adding another layer would just increase the getStyles load.
      Now, layers define their properties like this:
    LSD.Layer.Shadow = new Class({
      Extends: LSD.Layer,
      properties: {
        required: ['shadowColor'],
        numerical: ['shadowBlur', 'shadowOffsetX', 'shadowOffsetY'],
        optional: ['strokeWidth', 'shadowMethod']
      When widget is initialized, the map of properties and layers is built. Layers module checks what
    properties were changed from the last time, determines what layers were affected and only THEN creates (or reuses) layer object. It also validates styles against every group of properties. So, a shadow requires 
    shadow color. If the widget doesnt have shadow color, other properties will not even be getStyle'd. You can
    add your own property group definitions.
      Wooping 20% render speedup. Side effect: getChangedStyles is gone!
    * Got rid of custom properties in class definitions that needs mutations to merge. Now everything (events, layout, hotkeys) is in options. The implementation is now simplier and it's actually faster.
    * HTML5 is now unconditional and forced everywhere. We use html5 tags for everything (except for windows and panels now, which is TODO). The tags are kept unchanged when converted from markup to LSD when possible (menu stays menu after conversion)
    * HTML5 command specification is in. Command is a special html5 tag that creates abstract command object that can be linked to a number of widgets. This allows you add checkbox/radio behaviour to any widget (useful for on/off buttons, simple ad hoc switchers, etc). Every active widget generates the command by looking at the attributes it has. So to connect three buttons, you can just add :radiogroup => "my_button_set" attribute to all of them. The thing is 80% implemented, but it'll be done soon.
    * Menus got some love. Each of the menus now has a tree of possible widgets it can contain (e.g. toolbar can have buttons, hrs, commands). Event delegation is used for events that trigger selection/deselection of items, which is also a big win.
    * Child node personalization is shifted to the new level. So a <window> that has a direct descendant <header> will have .header accessor linking to that widget. More than that, document object also contains named links to children.
          %section Title
        var header = LSD.document.getElement('header');     //=> section#top
        header.buttons //=> [button, button]
        header.section //=> section 
        When widget is appended as child the semantic to that widget
        is set. The name of the link is determined by these rules:
        - If widget has id, use id
        - Use tag name
          - If the link is not taken, write tag name link
          - If the link is taken, append widget to a pluralized array link
            - When pluralized link is added, original link is not removed
    * There's a way to fire bubbling events now - dispatchEvent. One of those events is nodeInserted that fires on each parent (used to be hello event)
    * Dimensions module is revamped. Leaner now and has less conditions.
    * Added LSD.Document.Resizable base class (refreshes widgets when browser window is resized). There's also LSD.Widget.Body widget that allows to convert usual <body> element to a widget tree (with all the children) Example:
    $d =;
    * New Expectations module (ex Aware) that allows widgets to do some jobs when the specific widget was added as a children (and even undo things, when it was removed). This is also not a trait, because it brings the new level of asynchronous interactions and is fast enough at the same time to be used in every widget.
      You can add identifier expectations (faster) and selector expectations (slower, more powerful). It adds the listener to the nodeInserted even and each time widget event is fired it loops through all expectations it has to check if the inserted node fullfils one of them. When all expectations are satisfied, callbacks are removed.
    * Proxies module is rewritten. Less code, faster and now, because of the new expectatios module.
    * New behaviour module that lets you add class-based behaviours that add event tree to the widget:
    LSD.Widget.Module.Behaviours.define('.autoselect', {
      self: {
        blur: 'unselectItem'
      focused: {
        element: {
          'mouseover:on(button:not(:selected))': function() {
    Good thing it works in real time, so adding a class 'autofocus' to any widget would result in those events added. The events will be detached when class is removed.
    * Added LSD.Node, the lightweight ancestor for all non-widget nodes (Document, meta-data)
    * Say bye to:
      LSD.Widget.Module.Styles.prototype.postpone (duplication)
      LSD.Widget.Module.Styles.prototype.getChangedStyles (inlined)
      LSD.Widget.Module.Styles.prototype.resetElementStyle (inlined)
      LSD.Widget.Paint.States.outdated (inlined)
      LSD.Widget.Paint.prototype.getCanvasOffset (obsolete)
      LSD.Widget.Paint.prototype.getPaintOffset (obsolete)
      LSD.Widget.Paint.prototype.getOffset (duplication)
      LSD.Widget.Paint.prototype.getPadding (inlined)
      LSD.Widget.Paint.prototype.getInsideOffset (inlined)
      LSD.Widget.Module.LayoutEvents (built in to Layout module now)
      LSD.Widget.Module.Position (now trait)
      LSD.Widget.Module.Aware (now expectations)
    * Addresses the issue with upstream ART (ART.uniquieID -> String.uniqueID)
    * Uses mootools mobile for the cool gestures emulation
    * More files are UNLICENSEd now
Commits on Oct 14, 2010
  1. Update changelog

Commits on Oct 7, 2010
Something went wrong with that request. Please try again.