vis-rails 0.0.1

data/vendor/assets/vis/timeline/component/ContentPanel.js

@@ -0,0 +1,113 @@
+/**
+ * A content panel can contain a groupset or an itemset, and can handle
+ * vertical scrolling
+ * @param {Component} [parent]
+ * @param {Component[]} [depends]   Components on which this components depends
+ *                                  (except for the parent)
+ * @param {Object} [options]    Available parameters:
+ *                              {String | Number | function} [left]
+ *                              {String | Number | function} [top]
+ *                              {String | Number | function} [width]
+ *                              {String | Number | function} [height]
+ *                              {String | function} [className]
+ * @constructor ContentPanel
+ * @extends Panel
+ */
+function ContentPanel(parent, depends, options) {
+  this.id = util.randomUUID();
+  this.parent = parent;
+  this.depends = depends;
+
+  this.options = options || {};
+}
+
+ContentPanel.prototype = new Component();
+
+/**
+ * Set options. Will extend the current options.
+ * @param {Object} [options]    Available parameters:
+ *                              {String | function} [className]
+ *                              {String | Number | function} [left]
+ *                              {String | Number | function} [top]
+ *                              {String | Number | function} [width]
+ *                              {String | Number | function} [height]
+ */
+ContentPanel.prototype.setOptions = Component.prototype.setOptions;
+
+/**
+ * Get the container element of the panel, which can be used by a child to
+ * add its own widgets.
+ * @returns {HTMLElement} container
+ */
+ContentPanel.prototype.getContainer = function () {
+  return this.frame;
+};
+
+/**
+ * Repaint the component
+ * @return {Boolean} changed
+ */
+ContentPanel.prototype.repaint = function () {
+  var changed = 0,
+      update = util.updateProperty,
+      asSize = util.option.asSize,
+      options = this.options,
+      frame = this.frame;
+  if (!frame) {
+    frame = document.createElement('div');
+    frame.className = 'content-panel';
+
+    var className = options.className;
+    if (className) {
+      if (typeof className == 'function') {
+        util.addClassName(frame, String(className()));
+      }
+      else {
+        util.addClassName(frame, String(className));
+      }
+    }
+
+    this.frame = frame;
+    changed += 1;
+  }
+  if (!frame.parentNode) {
+    if (!this.parent) {
+      throw new Error('Cannot repaint panel: no parent attached');
+    }
+    var parentContainer = this.parent.getContainer();
+    if (!parentContainer) {
+      throw new Error('Cannot repaint panel: parent has no container element');
+    }
+    parentContainer.appendChild(frame);
+    changed += 1;
+  }
+
+  changed += update(frame.style, 'top',    asSize(options.top, '0px'));
+  changed += update(frame.style, 'left',   asSize(options.left, '0px'));
+  changed += update(frame.style, 'width',  asSize(options.width, '100%'));
+  changed += update(frame.style, 'height', asSize(options.height, '100%'));
+
+  return (changed > 0);
+};
+
+/**
+ * Reflow the component
+ * @return {Boolean} resized
+ */
+ContentPanel.prototype.reflow = function () {
+  var changed = 0,
+      update = util.updateProperty,
+      frame = this.frame;
+
+  if (frame) {
+    changed += update(this, 'top', frame.offsetTop);
+    changed += update(this, 'left', frame.offsetLeft);
+    changed += update(this, 'width', frame.offsetWidth);
+    changed += update(this, 'height', frame.offsetHeight);
+  }
+  else {
+    changed += 1;
+  }
+
+  return (changed > 0);
+};

data/vendor/assets/vis/timeline/component/CurrentTime.js

@@ -0,0 +1,101 @@
+/**
+ * A current time bar
+ * @param {Component} parent
+ * @param {Component[]} [depends]   Components on which this components depends
+ *                                  (except for the parent)
+ * @param {Object} [options]        Available parameters:
+ *                                  {Boolean} [showCurrentTime]
+ * @constructor CurrentTime
+ * @extends Component
+ */
+
+function CurrentTime (parent, depends, options) {
+  this.id = util.randomUUID();
+  this.parent = parent;
+  this.depends = depends;
+
+  this.options = options || {};
+  this.defaultOptions = {
+    showCurrentTime: false
+  };
+}
+
+CurrentTime.prototype = new Component();
+
+CurrentTime.prototype.setOptions = Component.prototype.setOptions;
+
+/**
+ * Get the container element of the bar, which can be used by a child to
+ * add its own widgets.
+ * @returns {HTMLElement} container
+ */
+CurrentTime.prototype.getContainer = function () {
+  return this.frame;
+};
+
+/**
+ * Repaint the component
+ * @return {Boolean} changed
+ */
+CurrentTime.prototype.repaint = function () {
+  var bar = this.frame,
+      parent = this.parent,
+      parentContainer = parent.parent.getContainer();
+
+  if (!parent) {
+    throw new Error('Cannot repaint bar: no parent attached');
+  }
+
+  if (!parentContainer) {
+    throw new Error('Cannot repaint bar: parent has no container element');
+  }
+
+  if (!this.getOption('showCurrentTime')) {
+    if (bar) {
+      parentContainer.removeChild(bar);
+      delete this.frame;
+    }
+
+    return;
+  }
+
+  if (!bar) {
+    bar = document.createElement('div');
+    bar.className = 'currenttime';
+    bar.style.position = 'absolute';
+    bar.style.top = '0px';
+    bar.style.height = '100%';
+
+    parentContainer.appendChild(bar);
+    this.frame = bar;
+  }
+
+  if (!parent.conversion) {
+    parent._updateConversion();
+  }
+
+  var now = new Date();
+  var x = parent.toScreen(now);
+
+  bar.style.left = x + 'px';
+  bar.title = 'Current time: ' + now;
+
+  // start a timer to adjust for the new time
+  if (this.currentTimeTimer !== undefined) {
+    clearTimeout(this.currentTimeTimer);
+    delete this.currentTimeTimer;
+  }
+
+  var timeline = this;
+  var interval = 1 / parent.conversion.scale / 2;
+
+  if (interval < 30) {
+    interval = 30;
+  }
+
+  this.currentTimeTimer = setTimeout(function() {
+    timeline.repaint();
+  }, interval);
+
+  return false;
+};

data/vendor/assets/vis/timeline/component/CustomTime.js

@@ -0,0 +1,255 @@
+/**
+ * A custom time bar
+ * @param {Component} parent
+ * @param {Component[]} [depends]   Components on which this components depends
+ *                                  (except for the parent)
+ * @param {Object} [options]        Available parameters:
+ *                                  {Boolean} [showCustomTime]
+ * @constructor CustomTime
+ * @extends Component
+ */
+
+function CustomTime (parent, depends, options) {
+  this.id = util.randomUUID();
+  this.parent = parent;
+  this.depends = depends;
+
+  this.options = options || {};
+  this.defaultOptions = {
+    showCustomTime: false
+  };
+
+  this.listeners = [];
+  this.customTime = new Date();
+}
+
+CustomTime.prototype = new Component();
+
+CustomTime.prototype.setOptions = Component.prototype.setOptions;
+
+/**
+ * Get the container element of the bar, which can be used by a child to
+ * add its own widgets.
+ * @returns {HTMLElement} container
+ */
+CustomTime.prototype.getContainer = function () {
+  return this.frame;
+};
+
+/**
+ * Repaint the component
+ * @return {Boolean} changed
+ */
+CustomTime.prototype.repaint = function () {
+  var bar = this.frame,
+      parent = this.parent,
+      parentContainer = parent.parent.getContainer();
+
+  if (!parent) {
+    throw new Error('Cannot repaint bar: no parent attached');
+  }
+
+  if (!parentContainer) {
+    throw new Error('Cannot repaint bar: parent has no container element');
+  }
+
+  if (!this.getOption('showCustomTime')) {
+    if (bar) {
+      parentContainer.removeChild(bar);
+      delete this.frame;
+    }
+
+    return;
+  }
+
+  if (!bar) {
+    bar = document.createElement('div');
+    bar.className = 'customtime';
+    bar.style.position = 'absolute';
+    bar.style.top = '0px';
+    bar.style.height = '100%';
+
+    parentContainer.appendChild(bar);
+
+    var drag = document.createElement('div');
+    drag.style.position = 'relative';
+    drag.style.top = '0px';
+    drag.style.left = '-10px';
+    drag.style.height = '100%';
+    drag.style.width = '20px';
+    bar.appendChild(drag);
+
+    this.frame = bar;
+
+    this.subscribe(this, 'movetime');
+  }
+
+  if (!parent.conversion) {
+    parent._updateConversion();
+  }
+
+  var x = parent.toScreen(this.customTime);
+
+  bar.style.left = x + 'px';
+  bar.title = 'Time: ' + this.customTime;
+
+  return false;
+};
+
+/**
+ * Set custom time.
+ * @param {Date} time
+ */
+CustomTime.prototype._setCustomTime = function(time) {
+  this.customTime = new Date(time.valueOf());
+  this.repaint();
+};
+
+/**
+ * Retrieve the current custom time.
+ * @return {Date} customTime
+ */
+CustomTime.prototype._getCustomTime = function() {
+  return new Date(this.customTime.valueOf());
+};
+
+/**
+ * Add listeners for mouse and touch events to the component
+ * @param {Component} component
+ */
+CustomTime.prototype.subscribe = function (component, event) {
+  var me = this;
+  var listener = {
+    component: component,
+    event: event,
+    callback: function (event) {
+      me._onMouseDown(event, listener);
+    },
+    params: {}
+  };
+
+  component.on('mousedown', listener.callback);
+  me.listeners.push(listener);
+
+};
+
+/**
+ * Event handler
+ * @param {String} event       name of the event, for example 'click', 'mousemove'
+ * @param {function} callback  callback handler, invoked with the raw HTML Event
+ *                             as parameter.
+ */
+CustomTime.prototype.on = function (event, callback) {
+  var bar = this.frame;
+  if (!bar) {
+    throw new Error('Cannot add event listener: no parent attached');
+  }
+
+  events.addListener(this, event, callback);
+  util.addEventListener(bar, event, callback);
+};
+
+/**
+ * Start moving horizontally
+ * @param {Event} event
+ * @param {Object} listener   Listener containing the component and params
+ * @private
+ */
+CustomTime.prototype._onMouseDown = function(event, listener) {
+  event = event || window.event;
+  var params = listener.params;
+
+  // only react on left mouse button down
+  var leftButtonDown = event.which ? (event.which == 1) : (event.button == 1);
+  if (!leftButtonDown) {
+    return;
+  }
+
+  // get mouse position
+  params.mouseX = util.getPageX(event);
+  params.moved = false;
+
+  params.customTime = this.customTime;
+
+  // add event listeners to handle moving the custom time bar
+  var me = this;
+  if (!params.onMouseMove) {
+    params.onMouseMove = function (event) {
+      me._onMouseMove(event, listener);
+    };
+    util.addEventListener(document, 'mousemove', params.onMouseMove);
+  }
+  if (!params.onMouseUp) {
+    params.onMouseUp = function (event) {
+      me._onMouseUp(event, listener);
+    };
+    util.addEventListener(document, 'mouseup', params.onMouseUp);
+  }
+
+  util.stopPropagation(event);
+  util.preventDefault(event);
+};
+
+/**
+ * Perform moving operating.
+ * This function activated from within the funcion CustomTime._onMouseDown().
+ * @param {Event} event
+ * @param {Object} listener
+ * @private
+ */
+CustomTime.prototype._onMouseMove = function (event, listener) {
+  event = event || window.event;
+  var params = listener.params;
+  var parent = this.parent;
+
+  // calculate change in mouse position
+  var mouseX = util.getPageX(event);
+
+  if (params.mouseX === undefined) {
+    params.mouseX = mouseX;
+  }
+
+  var diff = mouseX - params.mouseX;
+
+  // if mouse movement is big enough, register it as a "moved" event
+  if (Math.abs(diff) >= 1) {
+    params.moved = true;
+  }
+
+  var x = parent.toScreen(params.customTime);
+  var xnew = x + diff;
+  var time = parent.toTime(xnew);
+  this._setCustomTime(time);
+
+  // fire a timechange event
+  events.trigger(this, 'timechange', {customTime: this.customTime});
+
+  util.preventDefault(event);
+};
+
+/**
+ * Stop moving operating.
+ * This function activated from within the function CustomTime._onMouseDown().
+ * @param {event} event
+ * @param {Object} listener
+ * @private
+ */
+CustomTime.prototype._onMouseUp = function (event, listener) {
+  event = event || window.event;
+  var params = listener.params;
+
+  // remove event listeners here, important for Safari
+  if (params.onMouseMove) {
+    util.removeEventListener(document, 'mousemove', params.onMouseMove);
+    params.onMouseMove = null;
+  }
+  if (params.onMouseUp) {
+    util.removeEventListener(document, 'mouseup', params.onMouseUp);
+    params.onMouseUp = null;
+  }
+
+  if (params.moved) {
+    // fire a timechanged event
+    events.trigger(this, 'timechanged', {customTime: this.customTime});
+  }
+};

data/vendor/assets/vis/timeline/component/Group.js

@@ -0,0 +1,129 @@
+/**
+ * @constructor Group
+ * @param {GroupSet} parent
+ * @param {Number | String} groupId
+ * @param {Object} [options]  Options to set initial property values
+ *                            // TODO: describe available options
+ * @extends Component
+ */
+function Group (parent, groupId, options) {
+  this.id = util.randomUUID();
+  this.parent = parent;
+
+  this.groupId = groupId;
+  this.itemset = null;    // ItemSet
+  this.options = options || {};
+  this.options.top = 0;
+
+  this.props = {
+    label: {
+      width: 0,
+      height: 0
+    }
+  };
+
+  this.top = 0;
+  this.left = 0;
+  this.width = 0;
+  this.height = 0;
+}
+
+Group.prototype = new Component();
+
+// TODO: comment
+Group.prototype.setOptions = Component.prototype.setOptions;
+
+/**
+ * Get the container element of the panel, which can be used by a child to
+ * add its own widgets.
+ * @returns {HTMLElement} container
+ */
+Group.prototype.getContainer = function () {
+  return this.parent.getContainer();
+};
+
+/**
+ * Set item set for the group. The group will create a view on the itemset,
+ * filtered by the groups id.
+ * @param {DataSet | DataView} items
+ */
+Group.prototype.setItems = function setItems(items) {
+  if (this.itemset) {
+    // remove current item set
+    this.itemset.hide();
+    this.itemset.setItems();
+
+    this.parent.controller.remove(this.itemset);
+    this.itemset = null;
+  }
+
+  if (items) {
+    var groupId = this.groupId;
+
+    var itemsetOptions = Object.create(this.options);
+    this.itemset = new ItemSet(this, null, itemsetOptions);
+    this.itemset.setRange(this.parent.range);
+
+    this.view = new DataView(items, {
+      filter: function (item) {
+        return item.group == groupId;
+      }
+    });
+    this.itemset.setItems(this.view);
+
+    this.parent.controller.add(this.itemset);
+  }
+};
+
+/**
+ * Set selected items by their id. Replaces the current selection.
+ * Unknown id's are silently ignored.
+ * @param {Array} [ids] An array with zero or more id's of the items to be
+ *                      selected. If ids is an empty array, all items will be
+ *                      unselected.
+ */
+Group.prototype.setSelection = function setSelection(ids) {
+  if (this.itemset) this.itemset.setSelection(ids);
+};
+
+/**
+ * Get the selected items by their id
+ * @return {Array} ids  The ids of the selected items
+ */
+Group.prototype.getSelection = function getSelection() {
+  return this.itemset ? this.itemset.getSelection() : [];
+};
+
+/**
+ * Repaint the item
+ * @return {Boolean} changed
+ */
+Group.prototype.repaint = function repaint() {
+  return false;
+};
+
+/**
+ * Reflow the item
+ * @return {Boolean} resized
+ */
+Group.prototype.reflow = function reflow() {
+  var changed = 0,
+      update = util.updateProperty;
+
+  changed += update(this, 'top',    this.itemset ? this.itemset.top : 0);
+  changed += update(this, 'height', this.itemset ? this.itemset.height : 0);
+
+  // TODO: reckon with the height of the group label
+
+  if (this.label) {
+    var inner = this.label.firstChild;
+    changed += update(this.props.label, 'width', inner.clientWidth);
+    changed += update(this.props.label, 'height', inner.clientHeight);
+  }
+  else {
+    changed += update(this.props.label, 'width', 0);
+    changed += update(this.props.label, 'height', 0);
+  }
+
+  return (changed > 0);
+};