polymer-paper-rails 0.1.0

data/app/assets/components/paper-focusable/paper-focusable.html

@@ -0,0 +1,144 @@
+<!--
+Copyright (c) 2014 The Polymer Project Authors. All rights reserved.
+This code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt
+The complete set of authors may be found at http://polymer.github.io/AUTHORS.txt
+The complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt
+Code distributed by Google as part of the polymer project is also
+subject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt
+-->
+
+<!--
+/**
+ * @group Paper Elements
+ *
+ * paper-focusable is a base class for paper elements that can be focused.
+ *
+ * @element paper-focusable
+ * @status beta
+ * @homepage github.io
+ */
+-->
+
+<polymer-element name="paper-focusable" attributes="active focused disabled isToggle" tabindex="0" on-down="{{downAction}}" on-up="{{upAction}}" on-focus="{{focusAction}}" on-blur="{{blurAction}}" on-contextmenu="{{contextMenuAction}}">
+
+  <template>
+    <style>
+      :host([disabled]) {
+        pointer-events: none;
+      }
+    </style>
+    <content></content>
+  </template>
+
+  <script>
+    Polymer('paper-focusable', {
+
+      publish: {
+
+        /**
+         * If true, the button is currently active either because the
+         * user is holding down the button, or the button is a toggle
+         * and is currently in the active state.
+         *
+         * @attribute active
+         * @type boolean
+         * @default false
+         */
+        active: {value: false, reflect: true},
+
+        /**
+         * If true, the element currently has focus due to keyboard
+         * navigation.
+         *
+         * @attribute focused
+         * @type boolean
+         * @default false
+         */
+        focused: {value: false, reflect: true},
+
+        /**
+         * If true, the user is currently holding down the button.
+         *
+         * @attribute pressed
+         * @type boolean
+         * @default false
+         */
+        pressed: {value: false, reflect: true},
+
+        /**
+         * If true, the user cannot interact with this element.
+         *
+         * @attribute disabled
+         * @type boolean
+         * @default false
+         */
+        disabled: {value: false, reflect: true},
+
+        /**
+         * If true, the button toggles the active state with each tap.
+         * Otherwise, the button becomes active when the user is holding
+         * it down.
+         *
+         * @attribute isToggle
+         * @type boolean
+         * @default false
+         */
+        isToggle: {value: false, reflect: false}
+
+      },
+
+      disabledChanged: function() {
+        if (this.disabled) {
+          this.removeAttribute('tabindex');
+        } else {
+          this.setAttribute('tabindex', 0);
+        }
+      },
+
+      downAction: function() {
+        this.pressed = true;
+        this.focused = false;
+
+        if (this.isToggle) {
+          this.active = !this.active;
+        } else {
+          this.active = true;
+        }
+      },
+
+      // Pulling up the context menu for an item should focus it; but we need to
+      // be careful about how we deal with down/up events surrounding context
+      // menus. The up event typically does not fire until the context menu
+      // closes: so we focus immediately.
+      //
+      // This fires _after_ downAction.
+      contextMenuAction: function(e) {
+        // Note that upAction may fire _again_ on the actual up event.
+        this.upAction(e);
+        this.focusAction();
+      },
+
+      upAction: function() {
+        this.pressed = false;
+
+        if (!this.isToggle) {
+          this.active = false;
+        }
+      },
+
+      focusAction: function() {
+        if (!this.pressed) {
+          // Only render the "focused" state if the element gains focus due to
+          // keyboard navigation.
+          this.focused = true;
+        }
+      },
+
+      blurAction: function() {
+        this.focused = false;
+      }
+
+    });
+
+  </script>
+</polymer-element>

data/app/assets/components/paper-icon-button/paper-icon-button.css

@@ -0,0 +1,17 @@
+/*
+Copyright 2013 The Polymer Authors. All rights reserved.
+Use of this source code is governed by a BSD-style
+license that can be found in the LICENSE file.
+*/
+
+:host([disabled]) {
+  background: none !important;
+}
+
+:host([disabled]) /deep/ #icon {
+  fill: #c9c9c9;
+}
+
+:host(:not([fill])) /deep/ #focusBg {
+  border-radius: 50%;
+}

data/app/assets/components/paper-icon-button/paper-icon-button.html.erb

@@ -0,0 +1,87 @@
+<!--
+Copyright (c) 2014 The Polymer Project Authors. All rights reserved.
+This code may only be used under the BSD style license found at http://polymer.github.io/LICENSE
+The complete set of authors may be found at http://polymer.github.io/AUTHORS
+The complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS
+Code distributed by Google as part of the polymer project is also
+subject to an additional IP rights grant found at http://polymer.github.io/PATENTS
+-->
+
+<!--
+@group Paper Elements
+`paper-icon-button` is a button with an image placed at the center.
+
+Example:
+
+    <paper-icon-button iconSrc="star.png"></paper-icon-button>
+
+`paper-icon-button` includes a default icon set.  Use `icon` to specify
+which icon from the icon set to use.
+
+Example:
+
+    <paper-icon-button icon="menu"></paper-icon-button>
+
+The icons provided by `core-icons` are SVG, and you can style them with CSS.
+
+Example:
+
+    <paper-icon-button icon="favorite" style="fill:red;"></paper-icon-button>
+
+See `core-iconset` for more information about how to use a custom icon set.
+
+@element paper-icon-button
+@extends paper-button
+@homepage github.io
+-->
+
+<%= html_import_tag "core/icon/core-icon" %>
+<%= html_import_tag "paper-button/paper-button" %>
+
+<polymer-element name="paper-icon-button" extends="paper-button" attributes="fill">
+
+  <template>
+
+    <%= stylesheet_link_tag "paper-icon-button/paper-icon-button" %>
+
+    <shadow></shadow>
+
+  </template>
+
+  <script>
+
+    Polymer('paper-icon-button', {
+
+      publish: {
+
+        /**
+         * If true, the ripple expands to a square to fill the containing box.
+         *
+         * @attribute fill
+         * @type boolean
+         * @default false
+         */
+        fill: {value: false, reflect: true}
+
+      },
+
+      ready: function() {
+        this.$.ripple.classList.add('recenteringTouch');
+        this.fillChanged();
+      },
+
+      fillChanged: function() {
+        this.$.ripple.classList.toggle('circle', !this.fill);
+      },
+
+      iconChanged: function(oldIcon) {
+        if (!this.label) {
+          this.setAttribute('aria-label', this.icon);
+        }
+      }
+
+    });
+
+  </script>
+
+</polymer-element>

data/app/assets/components/paper-input/paper-input.html.erb

@@ -0,0 +1,398 @@
+<!--
+Copyright (c) 2014 The Polymer Project Authors. All rights reserved.
+This code may only be used under the BSD style license found at http://polymer.github.io/LICENSE
+The complete set of authors may be found at http://polymer.github.io/AUTHORS
+The complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS
+Code distributed by Google as part of the polymer project is also
+subject to an additional IP rights grant found at http://polymer.github.io/PATENTS
+-->
+
+<!--
+`paper-input` is a single- or multi-line text field where user can enter input.
+It can optionally have a label.
+
+Example:
+
+    <paper-input label="Your Name"></paper-input>
+    <paper-input multiline label="Enter multiple lines here"></paper-input>
+
+Theming
+--------
+
+Set `CoreStyle.g.paperInput.focusedColor` and `CoreStyle.g.paperInput.invalidColor` to theme
+the focused and invalid states.
+
+@group Paper Elements
+@element paper-input
+@extends core-input
+@homepage github.io
+-->
+
+<%= html_import_tag "core/input/core-input" %>
+<%= html_import_tag "core/style/core-style" %>
+
+<core-style id="paper-input">
+
+#label.focused,
+#floatedLabel.focused {
+  color: {{g.paperInput.focusedColor}};
+}
+
+#underlineHighlight.focused,
+#caretInner {
+  background-color: {{g.paperInput.focusedColor}};
+}
+
+#error,
+:host(.invalid) #label.focused,
+:host(.invalid) #floatedLabel.focused {
+  color: {{g.paperInput.invalidColor}};
+}
+:host(.invalid) #underlineHighlight.focused,
+:host(.invalid) #caretInner {
+  background-color: {{g.paperInput.invalidColor}};
+}
+
+</core-style>
+
+<polymer-element name="paper-input" extends="core-input" attributes="label floatingLabel maxRows error" on-down="{{downAction}}" on-up="{{upAction}}">
+
+  <template>
+
+    <%= stylesheet_link_tag "paper-input/paper-input" %>
+
+    <core-style ref="paper-input"></core-style>
+
+    <div id="floatedLabel" class="hidden" hidden?="{{!floatingLabel}}"><span id="floatedLabelSpan">{{label}}</span></div>
+
+    <div id="container" on-transitionend="{{transitionEndAction}}" on-webkitTransitionEnd="{{transitionEndAction}}">
+
+      <div id="label"><span id="labelSpan">{{label}}</span></div>
+
+      <div id="inputContainer">
+
+        <div id="inputClone">
+          <span id="inputCloneSpan" aria-hidden="true">&nbsp;</span>
+        </div>
+
+        <template if="{{multiline}}">
+          <div id="minInputHeight"></div>
+          <div id="maxInputHeight"></div>
+        </template>
+
+        <shadow></shadow>
+
+      </div>
+
+      <div id="underlineContainer">
+        <div id="underline"></div>
+        <div id="underlineHighlight" class="focusedColor"></div>
+      </div>
+
+      <div id="caret">
+        <div id="caretInner" class="focusedColor"></div>
+      </div>
+
+    </div>
+
+    <div id="errorContainer">
+      <div id="error" role="alert" aria-hidden="{{!invalid}}">{{error}}</div>
+      <div id="errorIcon"></div>
+    </div>
+
+  </template>
+
+  <script>
+
+  (function() {
+
+    var paperInput = CoreStyle.g.paperInput = CoreStyle.g.paperInput || {};
+    paperInput.focusedColor = '#4059a9';
+    paperInput.invalidColor = '#d34336';
+
+    Polymer('paper-input', {
+
+      /**
+       * The label for this input. It normally appears as grey text inside
+       * the text input and disappears once the user enters text.
+       *
+       * @attribute label
+       * @type string
+       * @default ''
+       */
+      label: '',
+
+      /**
+       * If true, the label will "float" above the text input once the
+       * user enters text instead of disappearing.
+       *
+       * @attribute floatingLabel
+       * @type boolean
+       * @default false
+       */
+      floatingLabel: false,
+
+      /**
+       * (multiline only) If set to a non-zero value, the height of this
+       * text input will grow with the value changes until it is maxRows
+       * rows tall. If the maximum size does not fit the value, the text
+       * input will scroll internally.
+       *
+       * @attribute maxRows
+       * @type number
+       * @default 0
+       */
+      maxRows: 0,
+
+      focused: false,
+      pressed: false,
+
+      attached: function() {
+        if (this.multiline) {
+          this.resizeInput();
+          window.requestAnimationFrame(function() {
+            this.$.underlineContainer.classList.add('animating');
+          }.bind(this));
+        }
+      },
+
+      resizeInput: function() {
+        var height = this.$.inputClone.getBoundingClientRect().height;
+        var bounded = this.maxRows > 0 || this.rows > 0;
+        if (bounded) {
+          var minHeight = this.$.minInputHeight.getBoundingClientRect().height;
+          var maxHeight = this.$.maxInputHeight.getBoundingClientRect().height;
+          height = Math.max(minHeight, Math.min(height, maxHeight));
+        }
+        this.$.inputContainer.style.height = height + 'px';
+        this.$.underlineContainer.style.top = height + 'px';
+      },
+
+      prepareLabelTransform: function() {
+        var toRect = this.$.floatedLabelSpan.getBoundingClientRect();
+        var fromRect = this.$.labelSpan.getBoundingClientRect();
+        if (toRect.width !== 0) {
+          this.$.label.cachedTransform = 'scale(' + (toRect.width / fromRect.width) + ') ' +
+            'translateY(' + (toRect.bottom - fromRect.bottom) + 'px)';
+        }
+      },
+
+      rowsChanged: function() {
+        if (this.multiline && !isNaN(parseInt(this.rows))) {
+          this.$.minInputHeight.innerHTML = '';
+          for (var i = 0; i < this.rows; i++) {
+            this.$.minInputHeight.appendChild(document.createElement('br'));
+          }
+          this.resizeInput();
+        }
+      },
+
+      maxRowsChanged: function() {
+        if (this.multiline && !isNaN(parseInt(this.maxRows))) {
+          this.$.maxInputHeight.innerHTML = '';
+          for (var i = 0; i < this.maxRows; i++) {
+            this.$.maxInputHeight.appendChild(document.createElement('br'));
+          }
+          this.resizeInput();
+        }
+      },
+
+      inputValueChanged: function() {
+        this.super();
+
+        if (this.multiline) {
+          var escaped = this.inputValue.replace(/\n/gm, '<br>');
+          if (!escaped || escaped.lastIndexOf('<br>') === escaped.length - 4) {
+            escaped += '&nbsp';
+          }
+          this.$.inputCloneSpan.innerHTML = escaped;
+          this.resizeInput();
+        }
+
+        if (!this.floatingLabel) {
+          this.$.label.classList.toggle('hidden', this.inputValue);
+        }
+
+        if (this.floatingLabel && !this.focused) {
+          this.$.label.classList.toggle('hidden', this.inputValue);
+          this.$.floatedLabel.classList.toggle('hidden', !this.inputValue);
+        }
+      },
+
+      labelChanged: function() {
+        if (this.floatingLabel && this.$.floatedLabel && this.$.label) {
+          // If the element is created programmatically, labelChanged is called before
+          // binding. Run the measuring code in async so the DOM is ready.
+          this.async(function() {
+            this.prepareLabelTransform();
+          });
+        }
+      },
+
+      placeholderChanged: function() {
+        this.label = this.placeholder;
+      },
+
+      inputFocusAction: function() {
+        if (!this.pressed) {
+          if (this.floatingLabel) {
+            this.$.floatedLabel.classList.remove('hidden');
+            this.$.floatedLabel.classList.add('focused');
+            this.$.floatedLabel.classList.add('focusedColor');
+          }
+          this.$.label.classList.add('hidden');
+          this.$.underlineHighlight.classList.add('focused');
+          this.$.caret.classList.add('focused');
+
+          this.super(arguments);
+        }
+        this.focused = true;
+      },
+
+      inputBlurAction: function() {
+        this.super(arguments);
+
+        this.$.underlineHighlight.classList.remove('focused');
+        this.$.caret.classList.remove('focused');
+        if (this.floatingLabel) {
+          this.$.floatedLabel.classList.remove('focused');
+          this.$.floatedLabel.classList.remove('focusedColor');
+          if (!this.inputValue) {
+            this.$.floatedLabel.classList.add('hidden');
+          }
+        }
+        if (!this.inputValue) {
+          this.$.label.classList.remove('hidden');
+          this.$.label.classList.add('animating');
+          this.async(function() {
+            this.$.label.style.webkitTransform = 'none';
+            this.$.label.style.transform = 'none';
+          });
+        }
+        this.focused = false;
+      },
+
+      downAction: function(e) {
+        if (this.disabled) {
+          return;
+        }
+
+        if (this.focused) {
+          return;
+        }
+
+        this.pressed = true;
+        var rect = this.$.underline.getBoundingClientRect();
+        var right = e.x - rect.left;
+        this.$.underlineHighlight.style.webkitTransformOriginX = right + 'px';
+        this.$.underlineHighlight.style.transformOriginX = right + 'px';
+        this.$.underlineHighlight.classList.remove('focused');
+        this.underlineAsync = this.async(function() {
+          this.$.underlineHighlight.classList.add('pressed');
+        }, null, 200);
+
+        // No caret animation if there is text in the input.
+        if (!this.inputValue) {
+          var width = this.$.inputCloneSpan.getBoundingClientRect().width;
+          if (width < right) {
+            this.$.caret.style.left = width + 'px';
+            this.$.caret.classList.remove('focused');
+          }
+        }
+      },
+
+      upAction: function(e) {
+        if (this.disabled) {
+          return;
+        }
+
+        if (!this.pressed) {
+          return;
+        }
+
+        // if a touchevent caused the up, the synthentic mouseevents will blur
+        // the input, make sure to prevent those from being generated.
+        if (e._source === 'touch') {
+          e.preventDefault();
+        }
+
+        if (this.underlineAsync) {
+          clearTimeout(this.underlineAsync);
+          this.underlineAsync = null;
+        }
+
+        // Focus the input here to bring up the virtual keyboard.
+        this.$.input.focus();
+        this.pressed = false;
+        this.animating = true;
+
+        this.$.underlineHighlight.classList.remove('pressed');
+        this.$.underlineHighlight.classList.add('animating');
+        this.async(function() {
+          this.$.underlineHighlight.classList.add('focused');
+        });
+
+        // No caret animation if there is text in the input.
+        if (!this.inputValue) {
+          this.$.caret.classList.add('animating');
+          this.async(function() {
+            this.$.caret.classList.add('focused');
+          }, null, 100);
+        }
+
+        if (this.floatingLabel) {
+          this.$.label.classList.add('focusedColor');
+          this.$.label.classList.add('animating');
+          if (!this.$.label.cachedTransform) {
+            this.prepareLabelTransform();
+          }
+          this.$.label.style.webkitTransform = this.$.label.cachedTransform;
+          this.$.label.style.transform = this.$.label.cachedTransform;
+        }
+      },
+
+      keypressAction: function() {
+        if (this.animating) {
+          this.transitionEndAction();
+        }
+      },
+
+      transitionEndAction: function(e) {
+        this.animating = false;
+        if (this.pressed) {
+          return;
+        }
+
+        if (this.focused) {
+
+          if (this.floatingLabel || this.inputValue) {
+            this.$.label.classList.add('hidden');
+          }
+
+          if (this.floatingLabel) {
+            this.$.label.classList.remove('focusedColor');
+            this.$.label.classList.remove('animating');
+            this.$.floatedLabel.classList.remove('hidden');
+            this.$.floatedLabel.classList.add('focused');
+            this.$.floatedLabel.classList.add('focusedColor');
+          }
+
+          this.async(function() {
+            this.$.underlineHighlight.classList.remove('animating');
+            this.$.caret.classList.remove('animating');
+          }, null, 100);
+
+        } else {
+
+          this.$.label.classList.remove('animating');
+
+        }
+      }
+
+    });
+
+  }());
+
+  </script>
+
+</polymer-element>