← Back to branch summary

~didrocks/+junk/face-detection-15.04

« back to all changes in this revision

Viewing changes to facedetection/www/bower_components/iron-resizable-behavior/iron-resizable-behavior.html

  • Committer: Didier Roche
  • Date: 2016-05-10 23:09:11 UTC
  • Revision ID: didier.roche@canonical.com-20160510230911-c7xr490zrj3yrzxd
New version

Show diffs side-by-side

added added

removed removed

Lines of Context:
facedetection/www/bower_components/iron-resizable-behavior/iron-resizable-behavior.html
 
1
<!--
 
2
@license
 
3
Copyright (c) 2015 The Polymer Project Authors. All rights reserved.
 
4
This code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt
 
5
The complete set of authors may be found at http://polymer.github.io/AUTHORS.txt
 
6
The complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt
 
7
Code distributed by Google as part of the polymer project is also
 
8
subject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt
 
9
-->
 
10
 
 
11
<link rel="import" href="../polymer/polymer.html">
 
12
 
 
13
<script>
 
14
  /**
 
15
   * `IronResizableBehavior` is a behavior that can be used in Polymer elements to
 
16
   * coordinate the flow of resize events between "resizers" (elements that control the
 
17
   * size or hidden state of their children) and "resizables" (elements that need to be
 
18
   * notified when they are resized or un-hidden by their parents in order to take
 
19
   * action on their new measurements).
 
20
   * 
 
21
   * Elements that perform measurement should add the `IronResizableBehavior` behavior to
 
22
   * their element definition and listen for the `iron-resize` event on themselves.
 
23
   * This event will be fired when they become showing after having been hidden,
 
24
   * when they are resized explicitly by another resizable, or when the window has been
 
25
   * resized.
 
26
   * 
 
27
   * Note, the `iron-resize` event is non-bubbling.
 
28
   *
 
29
   * @polymerBehavior Polymer.IronResizableBehavior
 
30
   * @demo demo/index.html
 
31
   **/
 
32
  Polymer.IronResizableBehavior = {
 
33
    properties: {
 
34
      /**
 
35
       * The closest ancestor element that implements `IronResizableBehavior`.
 
36
       */
 
37
      _parentResizable: {
 
38
        type: Object,
 
39
        observer: '_parentResizableChanged'
 
40
      },
 
41
 
 
42
      /**
 
43
       * True if this element is currently notifying its descedant elements of
 
44
       * resize.
 
45
       */
 
46
      _notifyingDescendant: {
 
47
        type: Boolean,
 
48
        value: false
 
49
      }
 
50
    },
 
51
 
 
52
    listeners: {
 
53
      'iron-request-resize-notifications': '_onIronRequestResizeNotifications'
 
54
    },
 
55
 
 
56
    created: function() {
 
57
      // We don't really need property effects on these, and also we want them
 
58
      // to be created before the `_parentResizable` observer fires:
 
59
      this._interestedResizables = [];
 
60
      this._boundNotifyResize = this.notifyResize.bind(this);
 
61
    },
 
62
 
 
63
    attached: function() {
 
64
      this.fire('iron-request-resize-notifications', null, {
 
65
        node: this,
 
66
        bubbles: true,
 
67
        cancelable: true
 
68
      });
 
69
 
 
70
      if (!this._parentResizable) {
 
71
        window.addEventListener('resize', this._boundNotifyResize);
 
72
        this.notifyResize();
 
73
      }
 
74
    },
 
75
 
 
76
    detached: function() {
 
77
      if (this._parentResizable) {
 
78
        this._parentResizable.stopResizeNotificationsFor(this);
 
79
      } else {
 
80
        window.removeEventListener('resize', this._boundNotifyResize);
 
81
      }
 
82
 
 
83
      this._parentResizable = null;
 
84
    },
 
85
 
 
86
    /**
 
87
     * Can be called to manually notify a resizable and its descendant
 
88
     * resizables of a resize change.
 
89
     */
 
90
    notifyResize: function() {
 
91
      if (!this.isAttached) {
 
92
        return;
 
93
      }
 
94
 
 
95
      this._interestedResizables.forEach(function(resizable) {
 
96
        if (this.resizerShouldNotify(resizable)) {
 
97
          this._notifyDescendant(resizable);
 
98
        }
 
99
      }, this);
 
100
 
 
101
      this._fireResize();
 
102
    },
 
103
 
 
104
    /**
 
105
     * Used to assign the closest resizable ancestor to this resizable
 
106
     * if the ancestor detects a request for notifications.
 
107
     */
 
108
    assignParentResizable: function(parentResizable) {
 
109
      this._parentResizable = parentResizable;
 
110
    },
 
111
 
 
112
    /**
 
113
     * Used to remove a resizable descendant from the list of descendants
 
114
     * that should be notified of a resize change.
 
115
     */
 
116
    stopResizeNotificationsFor: function(target) {
 
117
      var index = this._interestedResizables.indexOf(target);
 
118
 
 
119
      if (index > -1) {
 
120
        this._interestedResizables.splice(index, 1);
 
121
        this.unlisten(target, 'iron-resize', '_onDescendantIronResize');
 
122
      }
 
123
    },
 
124
 
 
125
    /**
 
126
     * This method can be overridden to filter nested elements that should or
 
127
     * should not be notified by the current element. Return true if an element
 
128
     * should be notified, or false if it should not be notified.
 
129
     *
 
130
     * @param {HTMLElement} element A candidate descendant element that
 
131
     * implements `IronResizableBehavior`.
 
132
     * @return {boolean} True if the `element` should be notified of resize.
 
133
     */
 
134
    resizerShouldNotify: function(element) { return true; },
 
135
 
 
136
    _onDescendantIronResize: function(event) {
 
137
      if (this._notifyingDescendant) {
 
138
        event.stopPropagation();
 
139
        return;
 
140
      }
 
141
 
 
142
      // NOTE(cdata): In ShadowDOM, event retargetting makes echoing of the
 
143
      // otherwise non-bubbling event "just work." We do it manually here for
 
144
      // the case where Polymer is not using shadow roots for whatever reason:
 
145
      if (!Polymer.Settings.useShadow) {
 
146
        this._fireResize();
 
147
      }
 
148
    },
 
149
 
 
150
    _fireResize: function() {
 
151
      this.fire('iron-resize', null, {
 
152
        node: this,
 
153
        bubbles: false
 
154
      });
 
155
    },
 
156
 
 
157
    _onIronRequestResizeNotifications: function(event) {
 
158
      var target = event.path ? event.path[0] : event.target;
 
159
 
 
160
      if (target === this) {
 
161
        return;
 
162
      }
 
163
 
 
164
      if (this._interestedResizables.indexOf(target) === -1) {
 
165
        this._interestedResizables.push(target);
 
166
        this.listen(target, 'iron-resize', '_onDescendantIronResize');
 
167
      }
 
168
 
 
169
      target.assignParentResizable(this);
 
170
      this._notifyDescendant(target);
 
171
 
 
172
      event.stopPropagation();
 
173
    },
 
174
 
 
175
    _parentResizableChanged: function(parentResizable) {
 
176
      if (parentResizable) {
 
177
        window.removeEventListener('resize', this._boundNotifyResize);
 
178
      }
 
179
    },
 
180
 
 
181
    _notifyDescendant: function(descendant) {
 
182
      // NOTE(cdata): In IE10, attached is fired on children first, so it's
 
183
      // important not to notify them if the parent is not attached yet (or
 
184
      // else they will get redundantly notified when the parent attaches).
 
185
      if (!this.isAttached) {
 
186
        return;
 
187
      }
 
188
 
 
189
      this._notifyingDescendant = true;
 
190
      descendant.notifyResize();
 
191
      this._notifyingDescendant = false;
 
192
    }
 
193
  };
 
194
</script>
 
195