concerto-behaviors.html

<script>
  var ConcertoBehaviors = ConcertoBehaviors || {};

  ConcertoBehaviors.Utils = {
    /**
     * Prepend a base path to a URL as needed.
     *
     * If a base is supplied and the URL is not absolute, prepend the base to
     * return an absolute URL.
     */
    resolveURL: function(url, base) {
      var r = new RegExp('^(?:[a-z]+:)?//', 'i');
      if (!url || !base || r.test(url)) {
        return url;
      }
      return base + url;
    },

    /**
     * Prepends a base to a path if not already prefixed with it
     *
     * Does not care about absolute URLs.
     */
    prefixWithBase: function(path, base) {
      bl = base.length;
      pl = path.length;
      if (pl > bl && bl != 0 && path.substring(0, bl) == base)
      {
        return path;
      }
      return base + path;
    },


    /**
     * Use iterative binary search to find optimal content font size given
     * the element's dimensions as constraints.
     */
    optimalFontSize: function(element, content) {
      var disable = !!parseInt(element.config['disable_text_autosize']);
      var maxSize = parseInt(element.config['max_text_autosize']);
      if (element.parentNode && !disable) {
        // Font size and container constraints
        maxSize = (!isNaN(maxSize) && typeof maxSize !== 'undefined' && maxSize > 4) ? maxSize : 200;
        var minSize = 4;
        var maxWidth = element.parentNode.offsetWidth;
        var maxHeight = element.parentNode.offsetHeight;

        // Binary search to find optimal font size
        while (maxSize > minSize + 1) {
          // calculate mid point of max and min font sizes
          midSize = Math.floor((maxSize - minSize) / 2) + minSize;
          // set content node font size to mid point
          content.style.fontSize = midSize + "px";

          // check if content node exceeds height constraint
          if (!(content.offsetHeight <= maxHeight && content.offsetWidth <= maxWidth)) {
            // continue search on smaller font sizes
            maxSize = midSize;
          } else {
            // continue search on larger font sizes
            minSize = midSize;
          }
        }

        // Set final font size
        content.style.fontSize = minSize + "px";
      }
    }
  };

  ConcertoBehaviors.ContentFactory = {

    types: {},

    /**
     *  Normalize the type names for consistent registration / lookup.
     *  We use a lower case non-punctuated string because some content types are
     *  CamelCase on the server but Regularcase in JavaScript (like HtmlText).
     */
    normalizeTypeName: function(typeName) {
      var basicName =  typeName.replace(/\W/g, '');
      return basicName.toLowerCase();
    },

    /**
     * Initialize a new content element.
     */
    getType: function (typeName) {
      typeName = this.normalizeTypeName(typeName);
      return this.types[typeName] ? new this.types[typeName] : undefined;
    },

    /**
     * Register the content type described by the current page in the
     * ContentFactory.
     *
     * This method should be called from each piece of content which inherits from
     * concerto-content. It attempts to automatically determine what Polymer
     * element is being defined and setup an event listener to register it once
     * Polymer has finished loading all elements.
     *
     * Registers a content element class with a type.
     */
    registerContent: function(contentName, klass) {
      var name = contentName.replace(/^concerto-/, '');
      var content = window[klass];
      if (!content) {
        // Do not register content types which do not have a public constructor.
        console.warn("Content type '" + contentName + "' does not appear to have a public constructor and cannot be registered");
        return;
      }
      var proto = content.prototype;
      name = this.normalizeTypeName(name);
      this.types[name] = content;
      console.info("Registered content type " + name);
    }
  };

  ConcertoBehaviors.BaseContent = {

    properties: {
      baseUrl: {
        type: String,
        reflectToAttribute: true
      },
      title: String,
      contentId: {
        type: Number,
        reflectToAttribute: true
      },
      duration: {
        type: Number,
        reflectToAttribute: true
      },
      cssText: {
        type: String,
        observer: '_cssTextChanged'
      },
      autoLoad: {
        type: Boolean,
        value: true
      },
      opened: {
        type: Boolean,
        value: false,
        reflectToAttribute: true
      },
      config: {
        type: Object,
        reflectToAttribute: true
      }
    },

    /**
     * Apply the new cssText back to the element.
     */
    _cssTextChanged: function() {
      this.style.cssText = this.cssText;
    },

    /**
     * Indicate that this content has finished loaded and can be displayed
     * in the field.
     *
     * Currently this involves firing the `load` event, but the details may
     * change.
     */
    _loaded: function() {
      this.fire('load', this);
    },

    /**
     * Load the values from a JSON Map which map to attributes
     * of this element.
     */
    fromJSON: function(data) {
      Object.keys(data).forEach(function(key) {
        if (key in this) {
          if (typeof data[key] == 'object') {
            this.setAttribute(key.toLowerCase(), JSON.stringify(data[key]));
          } else {
            this.setAttribute(key.toLowerCase(), data[key]);
            // TODO! @gabe please look at this and see why the prior line is not setting all the base properties
            // I had to add the following line so that the contentId property
            // would be set on the content types. The "contentId" property must
            // be set here so we prevent reloading the same content in the
            // loadNextContent method in ConcertoField.
            this[key] = data[key];
          }
        }
      }.bind(this));

      if (this.autoLoad) {
        this._loaded();
      }
    }
  };
</script>