hashcut: comparison integration/js/model.js

Mercurial Mercurial > hashcut / comparison

summary | shortlog | changelog | graph | tags | bookmarks | branches | files | changeset | file | latest | revisions | annotate | diff | comparison | raw | help

integration/js/model.js

changeset 27	b2d068afdbd8
parent 25	eea45f9b124b
child 41	3ec2343f2b85

equal deleted inserted replaced

-:7c394ea40f28
+:b2d068afdbd8
 this.milliseconds = 0;
 this.setMilliseconds(_milliseconds);
 }
 Model.Time.prototype.setMilliseconds = function(_milliseconds) {
-var _ante = _milliseconds;
+var _ante = this.milliseconds;
 switch(typeof _milliseconds) {
 case "string":
-this.milliseconds = parseFloat(_milliseconds);
+this.milliseconds = parseInt(_milliseconds);
 break;
 case "number":
-this.milliseconds = _milliseconds;
+this.milliseconds = Math.floor(_milliseconds);
 break;
 case "object":
-this.milliseconds = parseFloat(_milliseconds.valueOf());
+this.milliseconds = parseInt(_milliseconds.valueOf());
 break;
 default:
 this.milliseconds = 0;
 }
 if (this.milliseconds === NaN) {
 Model.Time.prototype.getHMS = function() {
 var _totalSeconds = Math.abs(Math.floor(this.getSeconds()));
 return {
 hours : Math.floor(_totalSeconds / 3600),
 minutes : (Math.floor(_totalSeconds / 60) % 60),
-seconds : _totalSeconds % 60
+seconds : _totalSeconds % 60,
+milliseconds: this.milliseconds % 1000
 }
 }
 Model.Time.prototype.add = function(_milliseconds) {
 this.milliseconds += new Model.Time(_milliseconds).milliseconds;
 Model.Time.prototype.valueOf = function() {
 return this.milliseconds;
 }
-Model.Time.prototype.toString = function() {
+Model.Time.prototype.toString = function(showCs) {
 function pad(_n) {
 var _res = _n.toString();
 while (_res.length < 2) {
 _res = '0' + _res;
 }
 _res = '';
 if (_hms.hours) {
 _res += _hms.hours + ':'
 }
 _res += pad(_hms.minutes) + ':' + pad(_hms.seconds);
+if (showCs) {
+_res += "." + Math.round(_hms.milliseconds / 100)
+}
 return _res;
 }
 /* Model.Reference handles references between elements
 */
 Model.Playable.prototype.pause = function() {
 this.trigger("setpause");
 }
+Model.Playable.prototype.show = function() {}
+Model.Playable.prototype.hide = function() {}
 /* */
 Model.Media = function(_id, _source) {
 Model.Playable.call(this, _id, _source);
 this.annotation = _annotation;
 this.begin = new Model.Time();
 this.end = new Model.Time();
 this.duration = new Model.Time();
 this.title = this.annotation.title;
-this.media_title = this.getMedia().title;
 this.description = this.annotation.description;
 this.color = this.annotation.color;
 var _this = this;
 this.on("click", function() {
 _mashup.setCurrentTime(_this.begin);
+});
+this.on("enter", function() {
+_this.annotation.trigger("enter");
+});
+this.on("leave", function() {
+_this.annotation.trigger("leave");
 });
 }
 Model.MashedAnnotation.prototype = new Model.Element(null);
 Model.Mashup = function(_id, _source) {
 Model.Playable.call(this, _id, _source);
 this.elementType = 'mashup';
 this.duration = new Model.Time();
 this.segments = new Model.List(_source.directory);
+this.loaded = false;
 var _currentMedia = null;
 var _this = this;
 this.on("timeupdate", function(_time) {
-_this.getAnnotations().filter(function(_a) {
+_this.getSegments().filter(function(_a) {
 return (_a.end <= _time || _a.begin > _time) && _a.playing
 }).forEach(function(_a) {
 _a.playing = false;
 _a.trigger("leave");
 });
-_this.getAnnotations().filter(function(_a) {
+_this.getSegments().filter(function(_a) {
 return _a.begin <= _time && _a.end > _time && !_a.playing
 }).forEach(function(_a) {
 _a.playing = true;
 _a.trigger("enter");
 var _m = _a.getMedia();
 }
 });
 });
 this._updateTimes = function() {
 _this.updateTimes();
-}
+_this.trigger("change");
-this.on("add-segments", this._updateTimes);
+}
-this.on("remove-segments", this._updateTimes);
+this.on("add", this._updateTimes);
+this.on("remove", this._updateTimes);
 }
 Model.Mashup.prototype = new Model.Playable();
+Model.Mashup.prototype.checkLoaded = function() {
+var loaded = !!this.segments.length;
+this.getMedias().forEach(function(_m) {
+loaded = loaded && _m.loaded;
+});
+this.loaded = loaded;
+if (loaded) {
+this.trigger("loadedmetadata");
+}
+}
 Model.Mashup.prototype.updateTimes = function() {
 var _time = 0;
 this.segments.forEach(function(_segment) {
 _segment.setBegin(_time);
 _time = _segment.end;
 });
 this.duration.setMilliseconds(_time);
 }
-Model.Mashup.prototype.addSegment = function(_annotation, _defer) {
+Model.Mashup.prototype.addAnnotation = function(_annotation, _defer) {
 var _mashedAnnotation = new Model.MashedAnnotation(this, _annotation),
 _defer = _defer || false;
 this.segments.push(_mashedAnnotation);
 _annotation.on("change-begin", this._updateTimes);
 _annotation.on("change-end", this._updateTimes);
 if (!_defer) {
-this.trigger("add-segments");
+this.trigger("add");
 }
 }
-Model.Mashup.prototype.addSegmentById = function(_elId, _defer) {
+Model.Mashup.prototype.addAnnotationById = function(_elId, _defer) {
 var _annotation = this.source.getElement(_elId),
 _defer = _defer || false;
 if (typeof _annotation !== "undefined") {
-this.addSegment(_annotation, _defer);
+this.addAnnotation(_annotation, _defer);
 }
 }
-Model.Mashup.prototype.addSegments = function(_segments) {
+Model.Mashup.prototype.addAnnotations = function(_segments) {
 var _this = this;
 ns._(_segments).forEach(function(_segment) {
-_this.addSegment(_segment, true);
+_this.addAnnotation(_segment, true);
 });
-this.trigger("add-segments");
+this.trigger("add");
 }
-Model.Mashup.prototype.addSegmentsById = function(_segments) {
+Model.Mashup.prototype.addAnnotationsById = function(_segments) {
 var _this = this;
 ns._(_segments).forEach(function(_segment) {
-_this.addSegmentById(_segment, true);
+_this.addAnnotationById(_segment, true);
 });
-this.trigger("add-segments");
+this.trigger("add");
 }
-Model.Mashup.prototype.removeSegment = function(_annotation, _defer) {
+Model.Mashup.prototype.removeAnnotation = function(_annotation, _defer) {
 var _defer = _defer || false;
 _annotation.off("change-begin", this._updateTimes);
 _annotation.off("change-end", this._updateTimes);
-this.segments.removeElement(_annotation);
+this.segments.removeId(this.id + "_" + _annotation.id);
 if (!_defer) {
-this.trigger("remove-segments");
+this.trigger("remove");
 }
 }
-Model.Mashup.prototype.removeSegmentById = function(_annId, _defer) {
+Model.Mashup.prototype.removeAnnotationById = function(_annId, _defer) {
 var _defer = _defer || false;
-var _annotation = this.source.getElementById(_annId);
+var _annotation = this.source.getElement(_annId);
 if (_annotation) {
-this.removeSegment(_annotation, _defer);
+this.removeAnnotation(_annotation, _defer);
 }
-this.segments.removeElement(_annotation);
 if (!_defer) {
-this.trigger("remove-segments");
+this.trigger("remove");
 }
 }
-Model.Mashup.prototype.getAnnotations = function() {
+Model.Mashup.prototype.setAnnotations = function(_segments) {
+while (this.segments.length) {
+this.removeAnnotation(this.segments[0].annotation, true);
+}
+this.addAnnotations(_segments);
+}
+Model.Mashup.prototype.setAnnotationsById = function(_segments) {
+while (this.segments.length) {
+this.removeAnnotation(this.segments[0].annotation, true);
+}
+this.addAnnotationsById(_segments);
+}
+Model.Mashup.prototype.hasAnnotation = function(_annotation) {
+return !!ns._(this.segments).find(function(_s) {
+return _s.annotation === _annotation
+});
+}
+Model.Mashup.prototype.getAnnotation = function(_annotation) {
+return ns._(this.segments).find(function(_s) {
+return _s.annotation === _annotation
+});
+}
+Model.Mashup.prototype.getAnnotationById = function(_id) {
+return ns._(this.segments).find(function(_s) {
+return _s.annotation.id === _id
+});
+}
+Model.Mashup.prototype.getSegments = function() {
 return this.segments;
 }
 Model.Mashup.prototype.getMedias = function() {
-var medias = new Model.List(_source.directory);
+var medias = new Model.List(this.source.directory);
-this.segments.each(function(_annotation) {
+this.segments.forEach(function(_annotation) {
 medias.push(_annotation.getMedia())
 })
 return medias;
 }

hashcut