5 

     4 import _ from "lodash";

     6 IriSP.Model = (function (ns) {

     5 import jQuery from "jquery";

     7     

     6 

     8     function pad(n, x, b) {

     7 const Model = function (ns) {

     9         b = b || 10;

     8   function pad(n, x, b) {

    10         var s = (x).toString(b);

     9     b = b || 10;

    11         while (s.length < n) {

    10     var s = x.toString(b);

    12             s = "0" + s;

    11     while (s.length < n) {

    12       s = "0" + s;

    13     }

    14     return s;

    15   }

    16 

    17   function rand16(n) {

    18     return pad(n, Math.floor(Math.random() * Math.pow(16, n)), 16);

    19   }

    20 

    21   var uidbase = rand16(8) + "-" + rand16(4) + "-",

    22     uidincrement = Math.floor(Math.random() * 0x10000);

    23 

    24   var charsub = ["[aáàâä]", "[cç]", "[eéèêë]", "[iíìîï]", "[oóòôö]", "[uùûü]"];

    25 

    26   var removeChars = [

    27     String.fromCharCode(768),

    28     String.fromCharCode(769),

    29     String.fromCharCode(770),

    30     String.fromCharCode(771),

    31     String.fromCharCode(807),

    32     "｛",

    33     "｝",

    34     "（",

    35     "）",

    36     "［",

    37     "］",

    38     "【",

    39     "】",

    40     "、",

    41     "・",

    42     "‥",

    43     "。",

    44     "「",

    45     "」",

    46     "『",

    47     "』",

    48     "〜",

    49     "：",

    50     "！",

    51     "？",

    52     "　",

    53     ",",

    54     " ",

    55     ";",

    56     "(",

    57     ")",

    58     ".",

    59     "*",

    60     "+",

    61     "\\",

    62     "?",

    63     "|",

    64     "{",

    65     "}",

    66     "[",

    67     "]",

    68     "^",

    69     "#",

    70     "/",

    71   ];

    72 

    73   var Model = {},

    74     _SOURCE_STATUS_EMPTY = (Model._SOURCE_STATUS_EMPTY = 0),

    75     _SOURCE_STATUS_WAITING = (Model._SOURCE_STATUS_WAITING = 1),

    76     _SOURCE_STATUS_READY = (Model._SOURCE_STATUS_READY = 2),

    77     extendPrototype = (Model.extendPrototype = function (toClass, fromClass) {

    78       var fromP = fromClass.prototype,

    79         toP = toClass.prototype;

    80       for (var k in fromP) {

    81         if (fromP.hasOwnProperty(k)) {

    82           toP[k] = fromP[k];

    14         return s;

    84       }

    15     }

    85     }),

    16     

    86     getUID = (Model.getUID = function () {

    17     function rand16(n) {

    87       return (

    18         return pad(n, Math.floor(Math.random()*Math.pow(16,n)), 16);

    88         uidbase +

    19     }

    89         pad(4, ++uidincrement % 0x10000, 16) +

    20     

    90         "-" +

    21     var uidbase = rand16(8) + "-" + rand16(4) + "-", uidincrement = Math.floor(Math.random()*0x10000);

    91         rand16(4) +

    22     

    92         "-" +

    23     var charsub = [

    93         rand16(6) +

    24         '[aáàâä]',

    94         rand16(6)

    25         '[cç]',

    95       );

    26         '[eéèêë]',

    96     }),

    27         '[iíìîï]',

    97     isLocalURL = (Model.isLocalURL = function (url) {

    28         '[oóòôö]',

    98       var matches = url.match(/^(\w+:)\/\/([^/]+)/);

    29         '[uùûü]'

    99       if (matches) {

    30     ];

   100         return (

    31     

   101           matches[1] === document.location.protocol &&

    32     var removeChars = [

   102           matches[2] === document.location.host

    33         String.fromCharCode(768), String.fromCharCode(769), String.fromCharCode(770), String.fromCharCode(771), String.fromCharCode(807),

   103         );

    34         "｛", "｝", "（", "）", "［", "］", "【", "】", "、", "・", "‥", "。", "「", "」", "『", "』", "〜", "：", "！", "？", "　",

   104       }

    35         ",", " ", ";", "(", ")", ".", "*", "+", "\\", "?", "|", "{", "}", "[", "]", "^", "#", "/"

   105       return true;

    36     ];

   106     }),

    37     

   107     regexpFromTextOrArray = (Model.regexpFromTextOrArray = function (

    38 var Model = {},

   108       _textOrArray,

    39     _SOURCE_STATUS_EMPTY = Model._SOURCE_STATUS_EMPTY = 0,

   109       _testOnly,

    40     _SOURCE_STATUS_WAITING = Model._SOURCE_STATUS_WAITING = 1,

   110       _iexact

    41     _SOURCE_STATUS_READY = Model._SOURCE_STATUS_READY = 2,

   111     ) {

    42     extendPrototype = Model.extendPrototype = function(toClass, fromClass) {

   112       var _testOnly = _testOnly || false,

    43         var fromP = fromClass.prototype,

   113         _iexact = _iexact || false;

    44             toP = toClass.prototype;

   114       function escapeText(_text) {

    45         for (var k in fromP) {

   115         return _text.replace(/([\\\*\+\?\|\{\[\}\]\(\)\^\$\.\#\/])/gm, "\\$1");

    46             if (fromP.hasOwnProperty(k)) {

   116       }

    47                 toP[k] = fromP[k];

   117       var _source =

    48             }

   118           typeof _textOrArray === "string"

   119             ? escapeText(_textOrArray)

   120             : _(_textOrArray).map(escapeText).join("|"),

   121         _flags = "im";

   122       if (!_testOnly) {

   123         _source = "(" + _source + ")";

   124         _flags += "g";

   125       }

   126       if (_iexact) {

   127         _source = "^" + _source + "$";

   128       }

   129       return new RegExp(_source, _flags);

   130     }),

   131     fullTextRegexps = (Model.fullTextRegexps = function (_text) {

   132       var remsrc = "[\\" + removeChars.join("\\") + "]",

   133         remrx = new RegExp(remsrc, "gm"),

   134         txt = _text.toLowerCase().replace(remrx, ""),

   135         res = [],

   136         charsrx = _(charsub).map(function (c) {

   137           return new RegExp(c);

   138         }),

   139         src = "";

   140       for (var j = 0; j < txt.length; j++) {

   141         if (j) {

   142           src += remsrc + "*";

    50     },

   144         var l = txt[j];

    51     getUID = Model.getUID = function() {

   145         _(charsub).each(function (v, k) {

    52         return uidbase + pad(4, (++uidincrement % 0x10000), 16) + "-" + rand16(4) + "-" + rand16(6) + rand16(6);

   146           l = l.replace(charsrx[k], v);

    53     },

   147         });

    54     isLocalURL = Model.isLocalURL = function(url) {

   148         src += l;

    55         var matches = url.match(/^(\w+:)\/\/([^/]+)/);

   149       }

    56         if (matches) {

   150       return "(" + src + ")";

    57             return(matches[1] === document.location.protocol && matches[2] === document.location.host);

   151     }),

    58         }

   152     isoToDate = (Model.isoToDate = function (_str) {

    59         return true;

   153       // http://delete.me.uk/2005/03/iso8601.html

    60     },

   154       var regexp =

    61     regexpFromTextOrArray = Model.regexpFromTextOrArray = function(_textOrArray, _testOnly, _iexact) {

   155         "([0-9]{4})(-([0-9]{2})(-([0-9]{2})(T([0-9]{2}):([0-9]{2})(:([0-9]{2})(.([0-9]+))?)?(Z|(([-+])([0-9]{2}):([0-9]{2})))?)?)?)?";

    62         var _testOnly = _testOnly || false,

   156       var d = _str.match(new RegExp(regexp));

    63             _iexact = _iexact || false;

   157 

    64         function escapeText(_text) {

   158       var offset = 0;

    65             return _text.replace(/([\\\*\+\?\|\{\[\}\]\(\)\^\$\.\#\/])/gm, '\\$1');

   159       var date = new Date(d[1], 0, 1);

    66         }

   160 

    67         var _source = 

   161       if (d[3]) {

    68             typeof _textOrArray === "string"

   162         date.setMonth(d[3] - 1);

    69             ? escapeText(_textOrArray)

   163       }

    70             : ns._(_textOrArray).map(escapeText).join("|"),

   164       if (d[5]) {

    71             _flags = 'im';

   165         date.setDate(d[5]);

    72         if (!_testOnly) {

   166       }

    73             _source = '(' + _source + ')';

   167       if (d[7]) {

    74             _flags += 'g';

   168         date.setHours(d[7]);

    75         }

   169       }

    76         if (_iexact) {

   170       if (d[8]) {

    77             _source = '^' + _source + '$';

   171         date.setMinutes(d[8]);

    78         }

   172       }

    79         return new RegExp( _source, _flags);

   173       if (d[10]) {

    80     },

   174         date.setSeconds(d[10]);

    81     fullTextRegexps = Model.fullTextRegexps = function(_text) {

   175       }

    82         var remsrc = "[\\" + removeChars.join("\\") + "]",

   176       if (d[12]) {

    83             remrx = new RegExp(remsrc,"gm"),

   177         date.setMilliseconds(Number("0." + d[12]) * 1000);

    84             txt = _text.toLowerCase().replace(remrx,""),

   178       }

    85             res = [],

   179       if (d[14]) {

    86             charsrx = ns._(charsub).map(function(c) {

   180         offset = Number(d[16]) * 60 + Number(d[17]);

    87                 return new RegExp(c);

   181         offset *= d[15] == "-" ? 1 : -1;

    88             }),

   182       }

    89             src = "";

   183 

    90         for (var j = 0; j < txt.length; j++) {

   184       offset -= date.getTimezoneOffset();

    91             if (j) {

   185       const time = Number(date) + offset * 60 * 1000;

    92                 src += remsrc + "*";

   186       var _res = new Date();

    93             }

   187       _res.setTime(Number(time));

    94             var l = txt[j];

   188       return _res;

    95             ns._(charsub).each(function(v, k) {

   189     }),

    96                 l = l.replace(charsrx[k], v);

   190     dateToIso = (Model.dateToIso = function (_d) {

    97             });

   191       var d = _d ? new Date(_d) : new Date();

    98             src += l;

   192       return (

    99         }

   193         d.getUTCFullYear() +

   100         return "(" + src + ")";

   194         "-" +

   101     },

   195         pad(2, d.getUTCMonth() + 1) +

   102     isoToDate = Model.isoToDate = function(_str) {

   196         "-" +

   103         // http://delete.me.uk/2005/03/iso8601.html

   197         pad(2, d.getUTCDate()) +

   104         var regexp = "([0-9]{4})(-([0-9]{2})(-([0-9]{2})(T([0-9]{2}):([0-9]{2})(:([0-9]{2})(\.([0-9]+))?)?(Z|(([-+])([0-9]{2}):([0-9]{2})))?)?)?)?";

   198         "T" +

   105         var d = _str.match(new RegExp(regexp));

   199         pad(2, d.getUTCHours()) +

   106     

   200         ":" +

   107         var offset = 0;

   201         pad(2, d.getUTCMinutes()) +

   108         var date = new Date(d[1], 0, 1);

   202         ":" +

   109     

   203         pad(2, d.getUTCSeconds()) +

   110         if (d[3]) { date.setMonth(d[3] - 1); }

   204         "Z"

   111         if (d[5]) { date.setDate(d[5]); }

   205       );

   112         if (d[7]) { date.setHours(d[7]); }

   206     });

   113         if (d[8]) { date.setMinutes(d[8]); }

   207 

   114         if (d[10]) { date.setSeconds(d[10]); }

   208   /*

   115         if (d[12]) { date.setMilliseconds(Number("0." + d[12]) * 1000); }

   209    * List is a class for a list of elements (e.g. annotations, medias, etc. that each have a distinct ID)

   116         if (d[14]) {

   210    */

   117             offset = (Number(d[16]) * 60) + Number(d[17]);

   211   var List = (Model.List = function (_directory) {

   118             offset *= ((d[15] == '-') ? 1 : -1);

   119         }

   120     

   121         offset -= date.getTimezoneOffset();

   122         time = (Number(date) + (offset * 60 * 1000));

   123         var _res = new Date();

   124         _res.setTime(Number(time));

   125         return _res;

   126     },

   127     dateToIso = Model.dateToIso = function(_d) {

   128         var d = _d ? new Date(_d) : new Date();

   129         return d.getUTCFullYear()+'-'  

   130             + pad(2, d.getUTCMonth()+1)+'-'  

   131             + pad(2, d.getUTCDate())+'T'  

   132             + pad(2, d.getUTCHours())+':'  

   133             + pad(2, d.getUTCMinutes())+':'  

   134             + pad(2, d.getUTCSeconds())+'Z'  ;

   135     };

   136 

   137 /*

   138  * List is a class for a list of elements (e.g. annotations, medias, etc. that each have a distinct ID)

   139  */

   140 var List = Model.List = function(_directory) {

   146         console.trace();

   217       console.trace();

   147         throw "Error : new List(directory): directory is undefined";

   218       throw "Error : new List(directory): directory is undefined";

   148     }

   219     }

   149     var _this =  this;

   220     var _this = this;

   150     this.on("clear-search", function() {

   221     this.on("clear-search", function () {

   151         _this.searching = false;

   222       _this.searching = false;

   152         _this.regexp = undefined;

   223       _this.regexp = undefined;

   153         _this.forEach(function(_element) {

   224       _this.forEach(function (_element) {

   154             _element.found = undefined;

   225         _element.found = undefined;

   155         });

   226       });

   156         _this.trigger("search-cleared");

   227       _this.trigger("search-cleared");

   157     });

   228     });

   158 };

   229   });

   159 

   230 

   160 List.prototype = new Array();

   231   List.prototype = new Array();

   161 

   232 

   162 List.prototype.hasId = function(_id) {

   233   List.prototype.hasId = function (_id) {

   163     return ns._(this.idIndex).include(_id);

   234     return _(this.idIndex).includes(_id);

   164 };

   235   };

   165 

   236 

   166 /* On recent browsers, forEach and map are defined and do what we want.

   237   /* On recent browsers, forEach and map are defined and do what we want.

   167  * Otherwise, we'll use the Underscore.js functions

   238    * Otherwise, we'll use the Underscore.js functions

   168  */

   239    */

   169 if (typeof Array.prototype.forEach === "undefined") {

   240   if (typeof Array.prototype.forEach === "undefined") {

   170     List.prototype.forEach = function(_callback) {

   241     List.prototype.forEach = function (_callback) {

   171         var _this = this;

   242       var _this = this;

   172         ns._(this).forEach(function(_value, _key) {

   243       _(this).forEach(function (_value, _key) {

   173             _callback(_value, _key, _this);

   244         _callback(_value, _key, _this);

   174         });

   245       });

   176 };

   247   }

   177 

   248 

   178 if (typeof Array.prototype.map === "undefined") {

   249   if (typeof Array.prototype.map === "undefined") {

   179     List.prototype.map = function(_callback) {

   250     List.prototype.map = function (_callback) {

   180         var _this = this;

   251       var _this = this;

   181         return ns._(this).map(function(_value, _key) {

   252       return _(this).map(function (_value, _key) {

   182             return _callback(_value, _key, _this);

   253         return _callback(_value, _key, _this);

   183         });

   254       });

   185 };

   256   }

   186 

   257 

   187 List.prototype.pluck = function(_key) {

   258   List.prototype.pluck = function (_key) {

   188     return this.map(function(_value) {

   259     return this.map(function (_value) {

   189         return _value[_key];

   260       return _value[_key];

   190     });

   261     });

   191 };

   262   };

   192 

   263 

   193 /* We override Array's filter function because it doesn't return an List

   264   /* We override Array's filter function because it doesn't return an List

   194  */

   265    */

   195 List.prototype.filter = function(_callback) {

   266   List.prototype.filter = function (_callback) {

   197         _res = new List(this.directory);

   268       _res = new List(this.directory);

   198     _res.addElements(ns._(this).filter(function(_value, _key) {

   269     _res.addElements(

   270       _(this).filter(function (_value, _key) {

   200     }));

   272       })

   273     );

   202 };

   275   };

   203 

   276 

   204 List.prototype.slice = function(_start, _end) {

   277   List.prototype.slice = function (_start, _end) {

   208 };

   281   };

   209 

   282 

   210 List.prototype.splice = function(_start, _end) {

   283   List.prototype.splice = function (_start, _end) {

   215 };

   288   };

   216 

   289 

   217 /* Array has a sort function, but it's not as interesting as Underscore.js's sortBy

   290   /* Array has a sort function, but it's not as interesting as Underscore.js's sortBy

   218  * and won't return a new List

   291    * and won't return a new List

   219  */

   292    */

   220 List.prototype.sortBy = function(_callback) {

   293   List.prototype.sortBy = function (_callback) {

   222         _res = new List(this.directory);

   295       _res = new List(this.directory);

   223     _res.addElements(ns._(this).sortBy(function(_value, _key) {

   296     _res.addElements(

   297       _(this).sortBy(function (_value, _key) {

   225     }));

   299       })

   300     );

   227 };

   302   };

   228 

   303 

   229 /* Title and Description are basic information for (almost) all element types,

   304   /* Title and Description are basic information for (almost) all element types,

   230  * here we can search by these criteria

   305    * here we can search by these criteria

   231  */

   306    */

   232 List.prototype.searchByTitle = function(_text, _iexact) {

   307   List.prototype.searchByTitle = function (_text, _iexact) {

   234         _rgxp = regexpFromTextOrArray(_text, true, _iexact);

   309       _rgxp = regexpFromTextOrArray(_text, true, _iexact);

   235     return this.filter(function(_element) {

   310     return this.filter(function (_element) {

   236         return _rgxp.test(_element.title);

   311       return _rgxp.test(_element.title);

   237     });

   312     });

   238 };

   313   };

   239 

   314 

   240 List.prototype.searchByDescription = function(_text, _iexact) {

   315   List.prototype.searchByDescription = function (_text, _iexact) {

   242         _rgxp = regexpFromTextOrArray(_text, true, _iexact);

   317       _rgxp = regexpFromTextOrArray(_text, true, _iexact);

   243     return this.filter(function(_element) {

   318     return this.filter(function (_element) {

   244         return _rgxp.test(_element.description);

   319       return _rgxp.test(_element.description);

   245     });

   320     });

   246 };

   321   };

   247 

   322 

   248 List.prototype.searchByTextFields = function(_text, _iexact) {

   323   List.prototype.searchByTextFields = function (_text, _iexact) {

   250         _rgxp =  regexpFromTextOrArray(_text, true, _iexact);

   325       _rgxp = regexpFromTextOrArray(_text, true, _iexact);

   251     return this.filter(function(_element) {

   326     return this.filter(function (_element) {

   252         var keywords = (_element.keywords || _element.getTagTexts() || []).join(", ");

   327       var keywords = (_element.keywords || _element.getTagTexts() || []).join(

   253         return _rgxp.test(_element.description) || _rgxp.test(_element.title) || _rgxp.test(keywords);

   328         ", "

   254     });

   329       );

   255 };

   330       return (

   256 

   331         _rgxp.test(_element.description) ||

   257 List.prototype.search = function(_text) {

   332         _rgxp.test(_element.title) ||

   333         _rgxp.test(keywords)

   334       );

   335     });

   336   };

   337 

   338   List.prototype.search = function (_text) {

   259         this.trigger("clear-search");

   340       this.trigger("clear-search");

   260         return this;

   341       return this;

   265         rgxp = new RegExp(rxsource,"im");

   346       rgxp = new RegExp(rxsource, "im");

   266     this.regexp = new RegExp(rxsource,"gim");

   347     this.regexp = new RegExp(rxsource, "gim");

   267     var res = this.filter(function(_element, _k) {

   348     var res = this.filter(function (_element, _k) {

   268         var titlematch = rgxp.test(_element.title),

   349       var titlematch = rgxp.test(_element.title),

   269             descmatch = rgxp.test(_element.description),

   350         descmatch = rgxp.test(_element.description),

   270             _isfound = !!(titlematch || descmatch);

   351         _isfound = !!(titlematch || descmatch);

   271         _element.found = _isfound;

   352       _element.found = _isfound;

   272         _element.trigger(_isfound ? "found" : "not-found");

   353       _element.trigger(_isfound ? "found" : "not-found");

   273         return _isfound;

   354       return _isfound;

   274     });

   355     });

   275     this.trigger(res.length ? "found" : "not-found",res);

   356     this.trigger(res.length ? "found" : "not-found", res);

   277 };

   358   };

   278 

   359 

   279 List.prototype.searchByTags = function(_text) {

   360   List.prototype.searchByTags = function (_text) {

   281         this.trigger("clear-search");

   362       this.trigger("clear-search");

   282         return this;

   363       return this;

   287         rgxp = new RegExp(rxsource,"im");

   368       rgxp = new RegExp(rxsource, "im");

   288     this.regexp = new RegExp(rxsource,"gim");

   369     this.regexp = new RegExp(rxsource, "gim");

   289     var res = this.filter(function(_element, _k) {

   370     var res = this.filter(function (_element, _k) {

   290         var _isfound = rgxp.test(_element.getTagTexts());

   371       var _isfound = rgxp.test(_element.getTagTexts());

   291         _element.found = _isfound;

   372       _element.found = _isfound;

   292         _element.trigger(_isfound ? "found" : "not-found");

   373       _element.trigger(_isfound ? "found" : "not-found");

   293         return _isfound;

   374       return _isfound;

   294     });

   375     });

   295     this.trigger(res.length ? "found" : "not-found",res);

   376     this.trigger(res.length ? "found" : "not-found", res);

   297 };

   378   };

   298 

   379 

   299 List.prototype.getTitles = function() {

   380   List.prototype.getTitles = function () {

   300     return this.map(function(_el) {

   381     return this.map(function (_el) {

   301         return _el.title;

   382       return _el.title;

   302     });

   383     });

   303 };

   384   };

   304 

   385 

   305 List.prototype.addId = function(_id) {

   386   List.prototype.addId = function (_id) {

   308         this.idIndex.push(_id);

   389       this.idIndex.push(_id);

   309         Array.prototype.push.call(this, _el);

   390       Array.prototype.push.call(this, _el);

   310     }

   391     }

   311 };

   392   };

   312 

   393 

   313 List.prototype.push = function(_el) {

   394   List.prototype.push = function (_el) {

   315         return;

   396       return;

   316     }

   397     }

   317     var _index = (ns._(this.idIndex).indexOf(_el.id));

   398     var _index = _(this.idIndex).indexOf(_el.id);

   319         this.idIndex.push(_el.id);

   400       this.idIndex.push(_el.id);

   320         Array.prototype.push.call(this, _el);

   401       Array.prototype.push.call(this, _el);

   322         this[_index] = _el;

   403       this[_index] = _el;

   323     }

   404     }

   324 };

   405   };

   325 

   406 

   326 List.prototype.addIds = function(_array) {

   407   List.prototype.addIds = function (_array) {

   328         _this = this;

   409       _this = this;

   329     ns._(_array).forEach(function(_id) {

   410     _(_array).forEach(function (_id) {

   330         _this.addId(_id);

   411       _this.addId(_id);

   331     });

   412     });

   332 };

   413   };

   333 

   414 

   334 List.prototype.addElements = function(_array) {

   415   List.prototype.addElements = function (_array) {

   336     ns._(_array).forEach(function(_el) {

   417     _(_array).forEach(function (_el) {

   337         _this.push(_el);

   418       _this.push(_el);

   338     });

   419     });

   339 };

   420   };

   340 

   421 

   341 List.prototype.removeId = function(_id, _deleteFromDirectory) {

   422   List.prototype.removeId = function (_id, _deleteFromDirectory) {

   343         _index = (ns._(this.idIndex).indexOf(_id));

   424       _index = _(this.idIndex).indexOf(_id);

   345         this.splice(_index,1);

   426       this.splice(_index, 1);

   348         delete this.directory.elements[_id];

   429       delete this.directory.elements[_id];

   349     }

   430     }

   350 };

   431   };

   351 

   432 

   352 List.prototype.removeElement = function(_el, _deleteFromDirectory) {

   433   List.prototype.removeElement = function (_el, _deleteFromDirectory) {

   355 };

   436   };

   356 

   437 

   357 List.prototype.removeIds = function(_list, _deleteFromDirectory) {

   438   List.prototype.removeIds = function (_list, _deleteFromDirectory) {

   359         _this = this;

   440       _this = this;

   360     ns._(_list).forEach(function(_id) {

   441     _(_list).forEach(function (_id) {

   361         _this.removeId(_id);

   442       _this.removeId(_id);

   362     });

   443     });

   363 };

   444   };

   364 

   445 

   365 List.prototype.removeElements = function(_list, _deleteFromDirectory) {

   446   List.prototype.removeElements = function (_list, _deleteFromDirectory) {

   367         _this = this;

   448       _this = this;

   368     ns._(_list).forEach(function(_el) {

   449     _(_list).forEach(function (_el) {

   369         _this.removeElement(_el);

   450       _this.removeElement(_el);

   370     });

   451     });

   371 };

   452   };

   372 

   453 

   373 List.prototype.on = function(_event, _callback) {

   454   List.prototype.on = function (_event, _callback) {

   375         this.__events[_event] = [];

   456       this.__events[_event] = [];

   378 };

   459   };

   379 

   460 

   380 List.prototype.off = function(_event, _callback) {

   461   List.prototype.off = function (_event, _callback) {

   382         this.__events[_event] = ns._(this.__events[_event]).reject(function(_fn) {

   463       this.__events[_event] = ns

   383             return _fn === _callback;

   464         ._(this.__events[_event])

   465         .reject(function (_fn) {

   466           return _fn === _callback;

   386 };

   469   };

   387 

   470 

   388 List.prototype.trigger = function(_event, _data) {

   471   List.prototype.trigger = function (_event, _data) {

   390     ns._(this.__events[_event]).each(function(_callback) {

   473     _(this.__events[_event]).each(function (_callback) {

   391         _callback.call(_list, _data);

   474       _callback.call(_list, _data);

   392     });

   475     });

   393 };

   476   };

   394 

   477 

   395 /* A simple time management object, that helps converting millisecs to seconds and strings,

   478   /* A simple time management object, that helps converting millisecs to seconds and strings,

   396  * without the clumsiness of the original Date object.

   479    * without the clumsiness of the original Date object.

   397  */

   480    */

   398 

   481 

   399 var Time = Model.Time = function(_milliseconds) {

   482   var Time = (Model.Time = function (_milliseconds) {

   402 };

   485   });

   403 

   486 

   404 Time.prototype.setMilliseconds = function(_milliseconds) {

   487   Time.prototype.setMilliseconds = function (_milliseconds) {

   406     switch(typeof _milliseconds) {

   489     switch (typeof _milliseconds) {

   407         case "string":

   490       case "string":

   408             this.milliseconds = parseInt(_milliseconds);

   491         this.milliseconds = parseInt(_milliseconds);

   409             break;

   492         break;

   410         case "number":

   493       case "number":

   411             this.milliseconds = Math.floor(_milliseconds);

   494         this.milliseconds = Math.floor(_milliseconds);

   412             break;

   495         break;

   413         case "object":

   496       case "object":

   414             this.milliseconds = parseInt(_milliseconds.valueOf());

   497         this.milliseconds = parseInt(_milliseconds.valueOf());

   415             break;

   498         break;

   416         default:

   499       default:

   417             this.milliseconds = 0;

   500         this.milliseconds = 0;

   420         this.milliseconds = _ante;

   503       this.milliseconds = _ante;

   421     }

   504     }

   422 };

   505   };

   423 

   506 

   424 Time.prototype.setSeconds = function(_seconds) {

   507   Time.prototype.setSeconds = function (_seconds) {

   426 };

   509   };

   427 

   510 

   428 Time.prototype.getSeconds = function() {

   511   Time.prototype.getSeconds = function () {

   430 };

   513   };

   431 

   514 

   432 Time.prototype.getHMS = function() {

   515   Time.prototype.getHMS = function () {

   435         hours : Math.floor(_totalSeconds / 3600),

   518       hours: Math.floor(_totalSeconds / 3600),

   436         minutes : (Math.floor(_totalSeconds / 60) % 60),

   519       minutes: Math.floor(_totalSeconds / 60) % 60,

   437         seconds : _totalSeconds % 60,

   520       seconds: _totalSeconds % 60,

   438         milliseconds: this.milliseconds % 1000

   521       milliseconds: this.milliseconds % 1000,

   440 };

   523   };

   441 

   524 

   442 Time.prototype.add = function(_milliseconds) {

   525   Time.prototype.add = function (_milliseconds) {

   444 };

   527   };

   445 

   528 

   446 Time.prototype.valueOf = function() {

   529   Time.prototype.valueOf = function () {

   448 };

   531   };

   449 

   532 

   450 Time.prototype.toString = function(showCs) {

   533   Time.prototype.toString = function (showCs) {

   452         _res = '';

   535       _res = "";

   454         _res += _hms.hours + ':';

   537       _res += _hms.hours + ":";

   455     }

   538     }

   456     _res += pad(2, _hms.minutes) + ':' + pad(2, _hms.seconds);

   539     _res += pad(2, _hms.minutes) + ":" + pad(2, _hms.seconds);

   458         _res += "." + Math.floor(_hms.milliseconds / 100);

   541       _res += "." + Math.floor(_hms.milliseconds / 100);

   461 };

   544   };

   462 

   545 

   463 /* Reference handles references between elements

   546   /* Reference handles references between elements

   464  */

   547    */

   465 

   548 

   466 var Reference = Model.Reference = function(_source, _idRef) {

   549   var Reference = (Model.Reference = function (_source, _idRef) {

   470         this.isList = true;

   553       this.isList = true;

   472         this.isList = false;

   555       this.isList = false;

   475 };

   558   });

   476 

   559 

   477 Reference.prototype.refresh = function() {

   560   Reference.prototype.refresh = function () {

   479         this.contents = new List(this.source.directory);

   562       this.contents = new List(this.source.directory);

   480         this.contents.addIds(this.id);

   563       this.contents.addIds(this.id);

   482         this.contents = this.source.getElement(this.id);

   565       this.contents = this.source.getElement(this.id);

   483     }

   566     }

   484     

   567   };

   485 };

   568 

   486 

   569   Reference.prototype.getContents = function () {

   487 Reference.prototype.getContents = function() {

   570     if (

   488     if (typeof this.contents === "undefined" || (this.isList && this.contents.length != this.id.length)) {

   571       typeof this.contents === "undefined" ||

   489         this.refresh();

   572       (this.isList && this.contents.length != this.id.length)

   573     ) {

   574       this.refresh();

   492 };

   577   };

   493 

   578 

   494 Reference.prototype.isOrHasId = function(_idRef) {

   579   Reference.prototype.isOrHasId = function (_idRef) {

   496         return (ns._(this.id).indexOf(_idRef) !== -1);

   581       return _(this.id).indexOf(_idRef) !== -1;

   498         return (this.id == _idRef);

   583       return this.id == _idRef;

   499     }

   584     }

   500 };

   585   };

   501 

   586 

   502 /* */

   587   /* */

   503 

   588 

   504 var BaseElement = Model.Element = function(_id, _source) {

   589   var BaseElement = (Model.Element = function (_id, _source) {

   505     this.elementType = 'element';

   590     this.elementType = "element";

   510         return;

   595       return;

   513         _id = getUID();

   598       _id = getUID();

   518         this.source.directory.addElement(this);

   603       this.source.directory.addElement(this);

   519     }

   604     }

   520 };

   605   });

   521 

   606 

   522 BaseElement.prototype.toString = function() {

   607   BaseElement.prototype.toString = function () {

   523     return this.elementType + (this.elementType !== 'element' ? ', id=' + this.id + ', title="' + this.title + '"' : '');

   608     return (

   524 };

   609       this.elementType +

   525 

   610       (this.elementType !== "element"

   526 BaseElement.prototype.setReference = function(_elementType, _idRef) {

   611         ? ", id=" + this.id + ', title="' + this.title + '"'

   612         : "")

   613     );

   614   };

   615 

   616   BaseElement.prototype.setReference = function (_elementType, _idRef) {

   528 };

   618   };

   529 

   619 

   530 BaseElement.prototype.getReference = function(_elementType) {

   620   BaseElement.prototype.getReference = function (_elementType) {

   532         return this[_elementType].getContents();

   622       return this[_elementType].getContents();

   533     }

   623     }

   534 };

   624   };

   535 

   625 

   536 BaseElement.prototype.getRelated = function(_elementType, _global) {

   626   BaseElement.prototype.getRelated = function (_elementType, _global) {

   537     _global = (typeof _global !== "undefined" && _global);

   627     _global = typeof _global !== "undefined" && _global;

   539     return this.source.getList(_elementType, _global).filter(function(_el) {

   629     return this.source.getList(_elementType, _global).filter(function (_el) {

   540         var _ref = _el[_this.elementType];

   630       var _ref = _el[_this.elementType];

   541         return _ref && _ref.isOrHasId(_this.id);

   631       return _ref && _ref.isOrHasId(_this.id);

   542     });

   632     });

   543 };

   633   };

   544 

   634 

   545 BaseElement.prototype.on = function(_event, _callback) {

   635   BaseElement.prototype.on = function (_event, _callback) {

   547         this.__events[_event] = [];

   637       this.__events[_event] = [];

   550 };

   640   };

   551 

   641 

   552 BaseElement.prototype.off = function(_event, _callback) {

   642   BaseElement.prototype.off = function (_event, _callback) {

   554         this.__events[_event] = ns._(this.__events[_event]).reject(function(_fn) {

   644       this.__events[_event] = _(this.__events[_event]).reject(function (_fn) {

   555             return _fn === _callback;

   645         return _fn === _callback;

   556         });

   646       });

   557     }

   647     }

   558 };

   648   };

   559 

   649 

   560 BaseElement.prototype.trigger = function(_event, _data) {

   650   BaseElement.prototype.trigger = function (_event, _data) {

   562     ns._(this.__events[_event]).each(function(_callback) {

   652     _(this.__events[_event]).each(function (_callback) {

   563         _callback.call(_element, _data);

   653       _callback.call(_element, _data);

   564     });

   654     });

   565 };

   655   };

   566 

   656 

   567 /* */

   657   /* */

   568 

   658 

   569 var Playable = Model.Playable = function(_id, _source) {

   659   var Playable = (Model.Playable = function (_id, _source) {

   572         return;

   662       return;

   573     }

   663     }

   574     this.elementType = 'playable';

   664     this.elementType = "playable";

   576     this.volume = .5;

   666     this.volume = 0.5;

   582     this.on("play", function() {

   672     this.on("play", function () {

   583         _this.paused = false;

   673       _this.paused = false;

   584     });

   674     });

   585     this.on("pause", function() {

   675     this.on("pause", function () {

   586         _this.paused = true;

   676       _this.paused = true;

   587     });

   677     });

   588     this.on("timeupdate", function(_time) {

   678     this.on("timeupdate", function (_time) {

   589         _this.currentTime = _time;

   679       _this.currentTime = _time;

   590         _this.getAnnotations().filter(function(_a) {

   680       _this

   591             return (_a.end <= _time || _a.begin > _time) && _a.playing;

   681         .getAnnotations()

   592         }).forEach(function(_a) {

   682         .filter(function (_a) {

   593             _a.playing = false;

   683           return (_a.end <= _time || _a.begin > _time) && _a.playing;

   594             _a.trigger("leave");

   684         })

   595             _this.trigger("leave-annotation",_a);

   685         .forEach(function (_a) {

   686           _a.playing = false;

   687           _a.trigger("leave");

   688           _this.trigger("leave-annotation", _a);

   597         _this.getAnnotations().filter(function(_a) {

   690       _this

   598             return _a.begin <= _time && _a.end > _time && !_a.playing;

   691         .getAnnotations()

   599         }).forEach(function(_a) {

   692         .filter(function (_a) {

   600             _a.playing = true;

   693           return _a.begin <= _time && _a.end > _time && !_a.playing;

   601             _a.trigger("enter");

   694         })

   602             _this.trigger("enter-annotation",_a);

   695         .forEach(function (_a) {

   696           _a.playing = true;

   697           _a.trigger("enter");

   698           _this.trigger("enter-annotation", _a);

   604         

   700 

   605         if (_this.getTimeRange()){

   701       if (_this.getTimeRange()) {

   606             if (_this.getTimeRange()[0] > _time) {

   702         if (_this.getTimeRange()[0] > _time) {

   607                 _this.pause();

   703           _this.pause();

   608                 _this.setCurrentTime(_this.getTimeRange()[0]);

   704           _this.setCurrentTime(_this.getTimeRange()[0]);

   609             }

   610             if (_this.getTimeRange()[1] < _time){

   611                 _this.pause();

   612                 _this.setCurrentTime(_this.getTimeRange()[1]);

   613             }

   615         

   706         if (_this.getTimeRange()[1] < _time) {

   616     });

   707           _this.pause();

   617     this.on("loadedmetadata", function() {

   708           _this.setCurrentTime(_this.getTimeRange()[1]);

   618         _this.loadedMetadata = true;

   709         }

   619     });

   710       }

   620 };

   711     });

   621 

   712     this.on("loadedmetadata", function () {

   622 extendPrototype(Playable, BaseElement);

   713       _this.loadedMetadata = true;

   623 

   714     });

   624 Playable.prototype.getCurrentTime = function() { 

   715   });

   716 

   717   extendPrototype(Playable, BaseElement);

   718 

   719   Playable.prototype.getCurrentTime = function () {

   626 };

   721   };

   627 

   722 

   628 Playable.prototype.getVolume = function() {

   723   Playable.prototype.getVolume = function () {

   630 };

   725   };

   631 

   726 

   632 Playable.prototype.getPaused = function() {

   727   Playable.prototype.getPaused = function () {

   634 };

   729   };

   635 

   730 

   636 Playable.prototype.getMuted = function() {

   731   Playable.prototype.getMuted = function () {

   638 };

   733   };

   639 

   734 

   640 Playable.prototype.getTimeRange = function() {

   735   Playable.prototype.getTimeRange = function () {

   642 }

   737   };

   643 

   738 

   644 Playable.prototype.setCurrentTime = function(_time) {

   739   Playable.prototype.setCurrentTime = function (_time) {

   645     this.trigger("setcurrenttime",_time);

   740     this.trigger("setcurrenttime", _time);

   646 };

   741   };

   647 

   742 

   648 Playable.prototype.setVolume = function(_vol) {

   743   Playable.prototype.setVolume = function (_vol) {

   649     this.trigger("setvolume",_vol);

   744     this.trigger("setvolume", _vol);

   650 };

   745   };

   651 

   746 

   652 Playable.prototype.setMuted = function(_muted) {

   747   Playable.prototype.setMuted = function (_muted) {

   653     this.trigger("setmuted",_muted);

   748     this.trigger("setmuted", _muted);

   654 };

   749   };

   655 

   750 

   656 Playable.prototype.setTimeRange = function(_timeBegin, _timeEnd) {

   751   Playable.prototype.setTimeRange = function (_timeBegin, _timeEnd) {

   657     if ((_timeBegin < _timeEnd)&&(_timeBegin >= 0)&&(_timeEnd>0)){

   752     if (_timeBegin < _timeEnd && _timeBegin >= 0 && _timeEnd > 0) {

   658         return this.trigger("settimerange", [_timeBegin, _timeEnd]);

   753       return this.trigger("settimerange", [_timeBegin, _timeEnd]);

   659     }

   754     }

   660 }

   755   };

   661 

   756 

   662 Playable.prototype.resetTimeRange = function() {

   757   Playable.prototype.resetTimeRange = function () {

   664 }

   759   };

   665 

   760 

   666 Playable.prototype.play = function() {

   761   Playable.prototype.play = function () {

   668 };

   763   };

   669 

   764 

   670 Playable.prototype.pause = function() {

   765   Playable.prototype.pause = function () {

   672 };

   767   };

   673 

   768 

   674 Playable.prototype.show = function() {};

   769   Playable.prototype.show = function () {};

   675 

   770 

   676 Playable.prototype.hide = function() {};

   771   Playable.prototype.hide = function () {};

   677 

   772 

   678 /* */

   773   /* */

   679 

   774 

   680 var Media = Model.Media = function(_id, _source) {

   775   var Media = (Model.Media = function (_id, _source) {

   682     this.elementType = 'media';

   777     this.elementType = "media";

   684     this.video = '';

   779     this.video = "";

   686 };

   781   });

   687 

   782 

   688 extendPrototype(Media, Playable);

   783   extendPrototype(Media, Playable);

   689 /* */

   784   /* */

   690 

   785 

   691 var Media = Model.Media = function(_id, _source) {

   786   var Media = (Model.Media = function (_id, _source) {

   693     this.elementType = 'media';

   788     this.elementType = "media";

   695     this.video = '';

   790     this.video = "";

   697 };

   792   });

   698 

   793 

   699 extendPrototype(Media, Playable);

   794   extendPrototype(Media, Playable);

   700 

   795 

   701 /* Default functions to be overriden by players */

   796   /* Default functions to be overriden by players */

   702     

   797 

   703 Media.prototype.setDuration = function(_durationMs) {

   798   Media.prototype.setDuration = function (_durationMs) {

   705 };

   800   };

   706 

   801 

   707 Media.prototype.getAnnotations = function() {

   802   Media.prototype.getAnnotations = function () {

   709 };

   804   };

   710 

   805 

   711 Media.prototype.getAnnotationsByTypeTitle = function(_title) {

   806   Media.prototype.getAnnotationsByTypeTitle = function (_title) {

   712     var _annTypes = this.source.getAnnotationTypes().searchByTitle(_title).pluck("id");

   807     var _annTypes = this.source

   808       .getAnnotationTypes()

   809       .searchByTitle(_title)

   810       .pluck("id");

   714         return this.getAnnotations().filter(function(_annotation) {

   812       return this.getAnnotations().filter(function (_annotation) {

   715             return ns._(_annTypes).indexOf(_annotation.getAnnotationType().id) !== -1;

   813         return _(_annTypes).indexOf(_annotation.getAnnotationType().id) !== -1;

   716         });

   814       });

   718         return new List(this.source.directory);

   816       return new List(this.source.directory);

   719     }

   817     }

   720 };

   818   };

   721 

   819 

   722 /* */

   820   /* */

   723 

   821 

   724 var Tag = Model.Tag = function(_id, _source) {

   822   var Tag = (Model.Tag = function (_id, _source) {

   726     this.elementType = 'tag';

   824     this.elementType = "tag";

   727 };

   825   });

   728 

   826 

   729 extendPrototype(Tag, BaseElement);

   827   extendPrototype(Tag, BaseElement);

   730 

   828 

   731 Tag.prototype.getAnnotations = function() {

   829   Tag.prototype.getAnnotations = function () {

   733 };

   831   };

   734 

   832 

   735 /* */

   833   /* */

   736 var AnnotationType = Model.AnnotationType = function(_id, _source) {

   834   var AnnotationType = (Model.AnnotationType = function (_id, _source) {

   738     this.elementType = 'annotationType';

   836     this.elementType = "annotationType";

   739 };

   837   });

   740 

   838 

   741 extendPrototype(AnnotationType, BaseElement);

   839   extendPrototype(AnnotationType, BaseElement);

   742 

   840 

   743 AnnotationType.prototype.getAnnotations = function() {

   841   AnnotationType.prototype.getAnnotations = function () {

   745 };

   843   };

   746 

   844 

   747 /* Annotation

   845   /* Annotation

   748  * */

   846    * */

   749 

   847 

   750 var Annotation = Model.Annotation = function(_id, _source) {

   848   var Annotation = (Model.Annotation = function (_id, _source) {

   752     this.elementType = 'annotation';

   850     this.elementType = "annotation";

   758     this.on("click", function() {

   856     this.on("click", function () {

   759         _this.getMedia().setCurrentTime(_this.begin);

   857       _this.getMedia().setCurrentTime(_this.begin);

   760     });

   858     });

   761 };

   859   });

   762 

   860 

   763 extendPrototype(Annotation, BaseElement);

   861   extendPrototype(Annotation, BaseElement);

   764 

   862 

   765 /* Set begin and end in one go, to avoid undesired side-effects in

   863   /* Set begin and end in one go, to avoid undesired side-effects in

   766  * setBegin/setEnd interaction */

   864    * setBegin/setEnd interaction */

   767 Annotation.prototype.setBeginEnd = function(_beginMs, _endMs) {

   865   Annotation.prototype.setBeginEnd = function (_beginMs, _endMs) {

   768     _beginMs = Math.max(0,_beginMs);

   866     _beginMs = Math.max(0, _beginMs);

   769     _endMs = Math.max(0,_endMs);

   867     _endMs = Math.max(0, _endMs);

   770     if (_endMs < _beginMs)

   868     if (_endMs < _beginMs) _endMs = _beginMs;

   771         _endMs = _beginMs;

   776 };

   873   };

   777 

   874 

   778 Annotation.prototype.setBegin = function(_beginMs) {

   875   Annotation.prototype.setBegin = function (_beginMs) {

   779     this.begin.setMilliseconds(Math.max(0,_beginMs));

   876     this.begin.setMilliseconds(Math.max(0, _beginMs));

   782         this.setEnd(this.begin);

   879       this.setEnd(this.begin);

   783     }

   880     }

   784 };

   881   };

   785 

   882 

   786 Annotation.prototype.setEnd = function(_endMs) {

   883   Annotation.prototype.setEnd = function (_endMs) {

   787     this.end.setMilliseconds(Math.min(_endMs, this.getMedia().duration.milliseconds));

   884     this.end.setMilliseconds(

   885       Math.min(_endMs, this.getMedia().duration.milliseconds)

   886     );

   790         this.setBegin(this.end);

   889       this.setBegin(this.end);

   791     }

   890     }

   792 };

   891   };

   793 

   892 

   794 Annotation.prototype.setDuration = function(_durMs) {

   893   Annotation.prototype.setDuration = function (_durMs) {

   796 };

   895   };

   797 

   896 

   798 Annotation.prototype.setMedia = function(_idRef) {

   897   Annotation.prototype.setMedia = function (_idRef) {

   800 };

   899   };

   801 

   900 

   802 Annotation.prototype.getMedia = function() {

   901   Annotation.prototype.getMedia = function () {

   804 };

   903   };

   805 

   904 

   806 Annotation.prototype.setAnnotationType = function(_idRef) {

   905   Annotation.prototype.setAnnotationType = function (_idRef) {

   808 };

   907   };

   809 

   908 

   810 Annotation.prototype.getAnnotationType = function() {

   909   Annotation.prototype.getAnnotationType = function () {

   812 };

   911   };

   813 

   912 

   814 Annotation.prototype.setTags = function(_idRefs) {

   913   Annotation.prototype.setTags = function (_idRefs) {

   816 };

   915   };

   817 

   916 

   818 Annotation.prototype.getTags = function() {

   917   Annotation.prototype.getTags = function () {

   820 };

   919   };

   821 

   920 

   822 Annotation.prototype.getTagTexts = function() {

   921   Annotation.prototype.getTagTexts = function () {

   824 };

   923   };

   825 

   924 

   826 Annotation.prototype.getDuration = function() {

   925   Annotation.prototype.getDuration = function () {

   828 };

   927   };

   829 

   928 

   830 /* */

   929   /* */

   831 

   930 

   832 var MashedAnnotation = Model.MashedAnnotation = function(_mashup, _annotation) {

   931   var MashedAnnotation = (Model.MashedAnnotation = function (

   833     BaseElement.call(this, _mashup.id + "_" + _annotation.id, _annotation.source);

   932     _mashup,

   834     this.elementType = 'mashedAnnotation';

   933     _annotation

   934   ) {

   935     BaseElement.call(

   936       this,

   937       _mashup.id + "_" + _annotation.id,

   938       _annotation.source

   939     );

   940     this.elementType = "mashedAnnotation";

   843     this.on("click", function() {

   949     this.on("click", function () {

   844         _mashup.setCurrentTime(_this.begin);

   950       _mashup.setCurrentTime(_this.begin);

   845     });

   951     });

   846     this.on("enter", function() {

   952     this.on("enter", function () {

   847         _this.annotation.trigger("enter");

   953       _this.annotation.trigger("enter");

   848     });

   954     });

   849     this.on("leave", function() {

   955     this.on("leave", function () {

   850         _this.annotation.trigger("leave");

   956       _this.annotation.trigger("leave");

   851     });

   957     });

   852 };

   958   });

   853 

   959 

   854 extendPrototype(MashedAnnotation, BaseElement);

   960   extendPrototype(MashedAnnotation, BaseElement);

   855 

   961 

   856 MashedAnnotation.prototype.getMedia = function() {

   962   MashedAnnotation.prototype.getMedia = function () {

   858 };

   964   };

   859 

   965 

   860 MashedAnnotation.prototype.getAnnotationType = function() {

   966   MashedAnnotation.prototype.getAnnotationType = function () {

   862 };

   968   };

   863 

   969 

   864 MashedAnnotation.prototype.getTags = function() {

   970   MashedAnnotation.prototype.getTags = function () {

   866 };

   972   };

   867 

   973 

   868 MashedAnnotation.prototype.getTagTexts = function() {

   974   MashedAnnotation.prototype.getTagTexts = function () {

   870 };

   976   };

   871 

   977 

   872 MashedAnnotation.prototype.getDuration = function() {

   978   MashedAnnotation.prototype.getDuration = function () {

   874 };

   980   };

   875 

   981 

   876 MashedAnnotation.prototype.setBegin = function(_begin) {

   982   MashedAnnotation.prototype.setBegin = function (_begin) {

   880 };

   986   };

   881 

   987 

   882 /* */

   988   /* */

   883 

   989 

   884 var Mashup = Model.Mashup = function(_id, _source) {

   990   var Mashup = (Model.Mashup = function (_id, _source) {

   886     this.elementType = 'mashup';

   992     this.elementType = "mashup";

   891     this._updateTimes = function() {

   997     this._updateTimes = function () {

   892         _this.updateTimes();

   998       _this.updateTimes();

   893         _this.trigger("change");

   999       _this.trigger("change");

   897 };

  1003   });

   898 

  1004 

   899 extendPrototype(Mashup, Playable);

  1005   extendPrototype(Mashup, Playable);

   900 

  1006 

   901 Mashup.prototype.updateTimes = function() {

  1007   Mashup.prototype.updateTimes = function () {

   903     this.segments.forEach(function(_segment) {

  1009     this.segments.forEach(function (_segment) {

   904         _segment.setBegin(_time);

  1010       _segment.setBegin(_time);

   905         _time = _segment.end;

  1011       _time = _segment.end;

   908 };

  1014   };

   909 

  1015 

   910 Mashup.prototype.addAnnotation = function(_annotation, _defer) {

  1016   Mashup.prototype.addAnnotation = function (_annotation, _defer) {

   912         _defer = _defer || false;

  1018       _defer = _defer || false;

   917         this.trigger("add");

  1023       this.trigger("add");

   918     }

  1024     }

   919 };

  1025   };

   920 

  1026 

   921 Mashup.prototype.addAnnotationById = function(_elId, _defer) {

  1027   Mashup.prototype.addAnnotationById = function (_elId, _defer) {

   923         _defer = _defer || false;

  1029       _defer = _defer || false;

   925         this.addAnnotation(_annotation, _defer);

  1031       this.addAnnotation(_annotation, _defer);

   926     }

  1032     }

   927 };

  1033   };

   928 

  1034 

   929 Mashup.prototype.addAnnotations = function(_segments) {

  1035   Mashup.prototype.addAnnotations = function (_segments) {

   931     ns._(_segments).forEach(function(_segment) {

  1037     _(_segments).forEach(function (_segment) {

   932         _this.addAnnotation(_segment, true);

  1038       _this.addAnnotation(_segment, true);

   935 };

  1041   };

   936 

  1042 

   937 Mashup.prototype.addAnnotationsById = function(_segments) {

  1043   Mashup.prototype.addAnnotationsById = function (_segments) {

   939     ns._(_segments).forEach(function(_segment) {

  1045     _(_segments).forEach(function (_segment) {

   940         _this.addAnnotationById(_segment, true);

  1046       _this.addAnnotationById(_segment, true);

   943 };

  1049   };

   944 

  1050 

   945 Mashup.prototype.removeAnnotation = function(_annotation, _defer) {

  1051   Mashup.prototype.removeAnnotation = function (_annotation, _defer) {

   951         this.trigger("remove");

  1057       this.trigger("remove");

   952     }

  1058     }

   953 };

  1059   };

   954 

  1060 

   955 Mashup.prototype.removeAnnotationById = function(_annId, _defer) {

  1061   Mashup.prototype.removeAnnotationById = function (_annId, _defer) {

   960         this.removeAnnotation(_annotation, _defer);

  1066       this.removeAnnotation(_annotation, _defer);

   963         this.trigger("remove");

  1069       this.trigger("remove");

   964     }

  1070     }

   965 };

  1071   };

   966 

  1072 

   967 Mashup.prototype.setAnnotations = function(_segments) {

  1073   Mashup.prototype.setAnnotations = function (_segments) {

   969         this.removeAnnotation(this.segments[0].annotation, true);

  1075       this.removeAnnotation(this.segments[0].annotation, true);

   972 };

  1078   };

   973 

  1079 

   974 Mashup.prototype.setAnnotationsById = function(_segments) {

  1080   Mashup.prototype.setAnnotationsById = function (_segments) {

   976         this.removeAnnotation(this.segments[0].annotation, true);

  1082       this.removeAnnotation(this.segments[0].annotation, true);

   979 };

  1085   };

   980 

  1086 

   981 Mashup.prototype.hasAnnotation = function(_annotation) {

  1087   Mashup.prototype.hasAnnotation = function (_annotation) {

   982     return !!ns._(this.segments).find(function(_s) {

  1088     return !!_(this.segments).find(function (_s) {

   983         return _s.annotation === _annotation;

  1089       return _s.annotation === _annotation;

   984     });

  1090     });

   985 };

  1091   };

   986 

  1092 

   987 Mashup.prototype.getAnnotation = function(_annotation) {

  1093   Mashup.prototype.getAnnotation = function (_annotation) {

   988     return ns._(this.segments).find(function(_s) {

  1094     return _(this.segments).find(function (_s) {

   989         return _s.annotation === _annotation;

  1095       return _s.annotation === _annotation;

   990     });

  1096     });

   991 };

  1097   };

   992 

  1098 

   993 Mashup.prototype.getAnnotationById = function(_id) {

  1099   Mashup.prototype.getAnnotationById = function (_id) {

   994     return ns._(this.segments).find(function(_s) {

  1100     return _(this.segments).find(function (_s) {

   995         return _s.annotation.id === _id;

  1101       return _s.annotation.id === _id;

   996     });

  1102     });

   997 };

  1103   };

   998 

  1104 

   999 Mashup.prototype.getAnnotations = function() {

  1105   Mashup.prototype.getAnnotations = function () {