MD Settings: Languages model for language pages

third_party/polymer/v1_0/components-chromium/iron-selector/iron-selectable-extracted.js

-/** @polymerBehavior */
+
+
+  /** @polymerBehavior */
   Polymer.IronSelectableBehavior = {
 
+      /**
+       *  Fired when iron-selector is activated (selected or deselected).
+       *  It is fired before the selected items are changed.
+       *  Cancel the event to abort selection.
+       *
+       * @event iron-activate
+       *
+       **/
+      /**
+       *  Fired when an item is selected
+       *
+       * @event iron-select
+       *
+       **/
+      /**
+       *  Fired when an item is deselected
+       *
+       * @event iron-deselect
+       *
+       **/
+
     properties: {
 
       /**
        * If you want to use the attribute value of an element for `selected` instead of the index,
        * set this to the name of the attribute.
        *
        * @attribute attrForSelected
        * @type {string}
        */
       attrForSelected: {
@@ skipping 33 matching lines @@
        * @type {string}
        * @default 'tap'
        */
       activateEvent: {
         type: String,
         value: 'tap',
         observer: '_activateEventChanged'
       },
 
       /**
-       * This is a CSS selector sting.  If this is set, only items that matches the CSS selector
+       * This is a CSS selector string.  If this is set, only items that match the CSS selector
        * are selectable.
        *
        * @attribute selectable
        * @type {string}
        */
       selectable: String,
 
       /**
        * The class to set on elements when selected.
        *
        * @attribute selectedClass
        * @type {string}
        */
       selectedClass: {
         type: String,
         value: 'iron-selected'
       },
 
       /**
        * The attribute to set on elements when selected.
        *
        * @attribute selectedAttribute
        * @type {string}
        */
       selectedAttribute: {
         type: String,
         value: null
+      },
+
+      /**
+       * The set of excluded elements where the key is the `localName` 
+       * of the element that will be ignored from the item list.
+       *
+       * @type {object}
+       * @default {template: 1}
+       */
+
+      excludedLocalNames: {
+        type: Object,
+        value: function() {
+          return {
+            'template': 1
+          };
+        }
       }
-
     },
 
     observers: [
       '_updateSelected(attrForSelected, selected)'
     ],
 
-    excludedLocalNames: {
-      'template': 1
-    },
-
     created: function() {
       this._bindFilterItem = this._filterItem.bind(this);
       this._selection = new Polymer.IronSelection(this._applySelection.bind(this));
     },
 
     attached: function() {
       this._observer = this._observeItems(this);
       this._contentObserver = this._observeContent(this);
     },
 
@@ skipping 58 matching lines @@
     selectNext: function() {
       var index = (Number(this._valueToIndex(this.selected)) + 1) % this.items.length;
       this.selected = this._indexToValue(index);
     },
 
     _addListener: function(eventName) {
       this.listen(this, eventName, '_activateHandler');
     },
 
     _removeListener: function(eventName) {
-      // There is no unlisten yet...
-      // https://github.com/Polymer/polymer/issues/1639
-      //this.removeEventListener(eventName, this._bindActivateHandler);
+      this.unlisten(this, eventName, '_activateHandler');
     },
 
     _activateEventChanged: function(eventName, old) {
       this._removeListener(old);
       this._addListener(eventName);
     },
 
     _updateSelected: function() {
       this._selectSelected(this.selected);
     },
@@ skipping 68 matching lines @@
         }
       }.bind(this));
       observer.observe(node, {
         childList: true,
         subtree: true
       });
       return observer;
     },
 
     _activateHandler: function(e) {
-      // TODO: remove this when https://github.com/Polymer/polymer/issues/1639 is fixed so we
-      // can just remove the old event listener.
-      if (e.type !== this.activateEvent) {
-        return;
-      }
       var t = e.target;
       var items = this.items;
       while (t && t != this) {
         var i = items.indexOf(t);
         if (i >= 0) {
           var value = this._indexToValue(i);
           this._itemActivate(value, t);
           return;
         }
         t = t.parentNode;
       }
     },
 
     _itemActivate: function(value, item) {
       if (!this.fire('iron-activate',
           {selected: value, item: item}, {cancelable: true}).defaultPrevented) {
         this.select(value);
       }
     }
 
-  };
+  };
+