plugins/scheduler/static/js/scheduler.js

   1 /**
   2  * Description: display a query result in a Google map
   3  * Copyright (c) 2012-2013 UPMC Sorbonne Universite - INRIA
   4  * License: GPLv3
   5  */
   6
   7 /* based on the leases.js code in PLE WWW interface for MyPLC by Thierry Parmentelat -- INRIA */
   8
   9 /* XXX Those declarations should not be part of the js file... */
  10
  11 /* decorations / headers */
  12 /* note: looks like the 'font' attr is not effective... */
  13
  14 // vertical rules
  15 var attr_rules={'fill':"#888", 'stroke-dasharray':'- ', 'stroke-width':0.5};
  16 // set font-size separately in here rather than depend on the height
  17 var txt_timelabel = {"font": 'Times, "Trebuchet MS", Verdana, Arial, Helvetica, sans-serif',
  18              stroke: "none", fill: "#008", 'font-size': 9};
  19 var txt_allnodes = {"font": '"Trebuchet MS", Verdana, Arial, Helvetica, sans-serif', stroke: "none", fill: "#404"};
  20 var txt_nodelabel = {"font": '"Trebuchet MS", Verdana, Arial, Helvetica, sans-serif', stroke: "none", fill: "#008"};
  21
  22 var attr_timebutton = {'fill':'#bbf', 'stroke': '#338','stroke-width':1,
  23                'stroke-linecap':'round', 'stroke-linejoin':'miter', 'stroke-miterlimit':3};
  24 var attr_daymarker = {'stroke':'#000','stroke-width':2};
  25 var attr_half_daymarker = {'stroke':'#444','stroke-width':2};
  26
  27 /* lease dimensions and colors */
  28 /* refrain from using gradient color, seems to not be animated properly */
  29 /* lease was originally free and is still free */
  30 var attr_lease_free_free={'fill':"#def", 'stroke-width':0.5, 'stroke-dasharray':''};
  31 /* lease was originally free and is now set for our usage */
  32 var attr_lease_free_mine={'fill':"green", 'stroke-width':1, 'stroke-dasharray':'-..'};
  33 /* was mine and is still mine */
  34 var attr_lease_mine_mine={'fill':"#beb", 'stroke-width':0.5, 'stroke-dasharray':''};
  35 /* was mine and is about to be released */
  36 var attr_lease_mine_free={'fill':"white", 'stroke-width':1, 'stroke-dasharray':'-..'};
  37 var attr_lease_other={'fill':"#f88"};
  38
  39 /* other slices name */
  40 var txt_otherslice = {"font": '"Trebuchet MS", Verdana, Arial, Helvetica, sans-serif', stroke: "none", fill: "#444", "font-size": "12px"};
  41
  42 (function($){
  43
  44     var Scheduler = Plugin.extend({
  45
  46         init: function(options, element)
  47         {
  48             this.classname="scheduler";
  49             this._super(options, element);
  50
  51             /* Member variables */
  52             this._canvas_id = this.id('leases_area');
  53
  54             this.query_uuid = options.query_uuid;
  55             this.rows = null;
  56             // XXX TODEL
  57             //this.current_resources = Array();
  58             //this.current_leases = Array();
  59
  60             /* Managing asynchronous reception of resources and leases */
  61             this._resources          = Array();
  62             this._leases             = Array();
  63             this._received_resources = false;
  64             this._received_leases    = false;
  65
  66             this._axisx              = Array();
  67             this._nodelabels         = Array();
  68             this._lease_elements     = Array();
  69             //this.myLeases = Array();
  70             //this.allLeases = Array();
  71
  72             /* The time axis is an array of tuple (time, printable time) representing timeslots */
  73
  74             this.data = Array();
  75             this.default_granularity = 1800; /* 30 min */
  76             this._initial_timestamp = null;
  77
  78             /* This should be updated to be the ppcm of all granularities */
  79             this.min_granularity = this.default_granularity;
  80
  81             // the data contains slice names, and lease_id, we need this to find our own leases (mine)
  82             this._paper=null;
  83
  84
  85             /* XXX Events */
  86
  87             /* XXX Keys */
  88
  89             /* Listening to queries */
  90             this.listen_query(options.query_uuid);
  91             this.listen_query(options.query_all_resources_uuid, 'all_resources');
  92             this.listen_query(options.query_lease_uuid, 'lease');
  93
  94             /* XXX GUI setup and event binding */
  95             jQuery("#datepicker").datetimepicker({
  96                 //Timezone wise selection option
  97                 //timeFormat: 'hh:mm tt z',
  98                 //showTimezone: true,
  99
 100                 onSelect: function(value) {
 101                     //console.log(value);
 102                     //converting time to timestamp
 103                     currentDate= Math.round(Date.parse(value)/ 1000);
 104                     // TODO -- DONE
 105                     // convert value to timestamp --done
 106                     // Get jQuery("#timepicker").val(); - no need anymore
 107                     // convert timepicker into seconds - no need
 108                     // Add time to date - done
 109                     // pass the result to init_axisx - done
 110                     //console.log(currentDate);
 111                     s.clear();
 112                     s._init_axisx(currentDate);
 113                     s._draw();
 114                     // Do we need to populate the timeslots with existing leases?
 115                     // Look how to populate with initial_leases [we have to show the leases]
 116
 117                 }
 118             });
 119
 120             this._init_axisx('');
 121             this._draw();
 122
 123         }, /* init */
 124
 125         /* Default settings */
 126         default_options: {
 127             leases_offset:       0,
 128             leases_slots:        36,
 129             leases_w:            180,
 130             leases_granularity:  3600,
 131
 132             x_nodelabel:         200,   /* space for the nodenames */
 133             x_sep:               20,    /* right space after the nodename - removed from the above */
 134             y_header:            12,    /* height for the (two) rows of timelabels */
 135             y_sep:               10,    /* space between nodes */
 136             leases_w:            20,    /* 1-grain leases attributes */
 137             y_node:              15,
 138             radius:              6,
 139             anim_delay:          350,
 140             checkboxes:          false,
 141         },
 142
 143         /* PLUGIN EVENTS */
 144
 145         /* GUI EVENTS */
 146
 147         /************************** GUI MANIPULATION **************************/
 148
 149         /* NOTE: All Raphael-dependent code should go here. Performance issues
 150          * are suspected, it might be improved by a move to d3.js. The more
 151          * general problem to solve is how to manipulate lots of svg objects.
 152          */
 153
 154         /*************************** RECORD HANDLER ***************************/
 155
 156         /* ------------------------------------------------------------------
 157          * Resources
 158          * ------------------------------------------------------------------ */
 159
 160         on_query_in_progress: function() {
 161             this.spin();
 162         },
 163
 164         on_query_done: function() {
 165             /* We have received all leases */
 166             if (this._received_resources) {
 167                 this._draw(this._canvas_id);
 168                 this.unspin();
 169             }
 170             this._received_leases = true;
 171         },
 172
 173         /* ------------------------------------------------------------------
 174          * All resources
 175          * ------------------------------------------------------------------ */
 176
 177         on_all_resources_query_in_progress: function() {
 178             console.log("all resources query in progress");
 179         },
 180
 181         on_all_resources_new_record: function(record)
 182         {
 183             if ((typeof record.exclusive != 'undefined') && (record.exclusive)) {
 184                 this._resources.push(Array(record.urn, record.hrn, record.type));
 185             }
 186             // ... if we do not have information about slivers (first update), update it
 187             if (typeof record.sliver != 'undefined') {
 188                 // XXX
 189             }
 190         },
 191
 192         /* ------------------------------------------------------------------
 193          * Leases
 194          * ------------------------------------------------------------------ */
 195
 196         on_lease_new_record: function(record)
 197         {
 198             this._leases.push(record);
 199             // this.initial_leases=leases;
 200         },
 201
 202         on_lease_field_state_changed: function(data)
 203         {
 204             var lease = data.value;
 205             var urn = lease[0];
 206             var start_time = lease[1];
 207
 208             var lease_element = this._lease_element_find(urn, start_time);
 209             if (!lease_element) {
 210                 console.log("Alert: lease element not found");
 211                 return;
 212             }
 213
 214             switch(data.request) {
 215                 case FIELD_REQUEST_ADD:
 216                 case FIELD_REQUEST_ADD_RESET:
 217                     this._leases.push(data.value);
 218                     this._lease_init_mine(lease_element);
 219                     break;
 220                 case FIELD_REQUEST_REMOVE:
 221                 case FIELD_REQUEST_REMOVE_RESET:
 222                     // We remove data.value (aka keep those leases different from data.value
 223                     this._leases = $.grep(this._leases, function(x) { return x != data.value; });
 224                     this._lease_init_free(lease_element);
 225                     break;
 226                 default:
 227                     break;
 228
 229             }
 230         },
 231
 232         on_lease_query_done: function(record)
 233         {
 234             /* We have received all resources */
 235             if (this._received_leases) {
 236                 this._draw(this._canvas_id);
 237                 this.unspin();
 238             }
 239             this._received_resources = true;
 240         },
 241
 242         /************************** PRIVATE METHODS ***************************/
 243
 244         /**
 245          * @brief Return the number of time slots
 246          */
 247         nb_grains: function ()
 248         {
 249             return this._axisx.length;
 250         },
 251
 252         /**
 253          * @brief Returns whether there is a pending lease at this timestamp
 254          */
 255         _lease_find: function(urn, timestamp)
 256         {
 257             var scheduler = this;
 258             var result = null;
 259
 260             $.each(scheduler._leases, function(i, lease) {
 261                     if ((lease[0] == urn) &&
 262                         ((timestamp >= lease[1]) && (timestamp < (lease[1] + lease[2] * 1800)))) {
 263                             result = lease;
 264                             return false; // stop each
 265                     }
 266             });
 267
 268 /*
 269             $.each(Array(scheduler.myLeases, scheduler.allLeases), function(i, array) {
 270                 $.each(array, function(i, lease) {
 271                     if (lease[0] == urn) {
 272                         if ((timestamp >= lease[1]) && (timestamp < (lease[1] + lease[2] * 1800))) {
 273                             result = lease;
 274
 275                             return false;
 276                         }
 277                     }
 278                 });
 279                 if (result)
 280                     return false;
 281             });
 282 */
 283             return result;
 284         },
 285
 286         /* Iterative search through raphael.js objects, no forEach, no getById in the current version */
 287         _lease_element_find: function(urn, start_time)
 288         {
 289             var date = new Date(start_time*1000);
 290             var pos = this._paper.top;
 291             while (pos) {
 292                  if (pos.key == urn + "-" + date)
 293                     return pos;
 294                  pos = pos.prev;
 295             }
 296             return null;
 297         },
 298
 299         /**
 300          * @brief Draw
 301          */
 302         _draw: function()
 303         {
 304             var canvas_id = this._canvas_id;
 305             var o = this.options;
 306
 307             var total_width = o.x_nodelabel + this.nb_grains() * this.options.leases_w;
 308             var total_height = 2 * o.y_header /* the timelabels */
 309                              + 2 * o.y_sep    /* extra space */
 310                              + o.y_node          /* all-nodes & timebuttons row */
 311                              + (this._resources.length) * (o.y_node + o.y_sep);  /* the regular nodes and preceding space */
 312
 313             /* reuse for paper if exists with same size, or (re-)create otherwise */
 314             var paper;
 315             if (this._paper == null) {
 316                 paper = Raphael (canvas_id, total_width + o.x_sep, total_height);
 317             } else if (this._paper.width==total_width && this._paper.height==total_height) {
 318                 paper=this._paper;
 319                 paper.clear();
 320             } else {
 321                 $("#"+canvas_id)[0].innerHTML="";
 322                 //this.elmt().html();
 323                 paper = Raphael (canvas_id, total_width + o.x_sep, total_height);
 324             }
 325             this._paper = paper;
 326
 327             /* the path for the triangle-shaped buttons */
 328             var timebutton_path = "M1,0L"+(this.options.leases_w-1)+",0L"+(this.options.leases_w/2)+","+o.y_header+"L1,0";
 329
 330             var axisx = this._axisx;
 331             var axisy = this._resources;
 332
 333             /* maintain the list of nodelabels for the 'all nodes' button */
 334             this._nodelabels = [];
 335
 336
 337             /* create the time slots legend */
 338             var top = 0;
 339             var left = o.x_nodelabel;
 340
 341             var daymarker_height = 2*o.y_header + 2*o.y_sep + (axisy.length + 1) * (o.y_node + o.y_sep);
 342             var daymarker_path = "M0,0L0," + daymarker_height;
 343
 344             var half_daymarker_off= 2*o.y_header + o.y_sep;
 345             var half_daymarker_path="M0," + half_daymarker_off + "L0," + daymarker_height;
 346
 347             var col=0;
 348             for (var i=0, len = axisx.length; i < len; ++i) {
 349                 /* pick the printable part */
 350                 var timelabel = axisx[i][1];
 351                 var y = top + o.y_header;
 352                 if (col % 2 == 0)
 353                     y += o.y_header;
 354                 col +=1;
 355                 /* display time label */
 356                 var timelabel = paper.text(left, y, timelabel).attr(txt_timelabel).attr({"text-anchor": "middle"});
 357                 /* draw vertical line */
 358                 var path_spec = "M" + left + " " + (y+o.y_header / 2) + "L" + left + " " + this.total_height;
 359                 var rule = paper.path(path_spec).attr(attr_rules);
 360                 /* show a day marker when relevant */
 361                 var timestamp = parseInt(axisx[i][0]);
 362                 if ((timestamp % (24 * 3600)) == 0) {
 363                     paper.path(daymarker_path).attr({'translation': left + ',' + top}).attr(attr_daymarker);
 364                 } else if ( (timestamp%(12*3600))==0) {
 365                     paper.path(half_daymarker_path).attr({'translation': left + ',' + top}).attr(attr_daymarker);
 366                 }
 367                 left += o.leases_w;
 368             }
 369
 370             ////////// the row with the timeslot buttons (the one labeled 'All nodes')
 371             this.granularity = this.min_granularity; // XXX axisx[1][0]-axisx[0][0];
 372
 373             // move two lines down
 374             top += 2 * o.y_header + 2 * o.y_sep;
 375             left = o.x_nodelabel;
 376             // all nodes buttons
 377             var allnodes = paper.text(o.x_nodelabel - o.x_sep, top + o.y_node / 2, "All nodes").attr(txt_allnodes)
 378                 .attr({"font-size": o.y_node, "text-anchor": "end", "baseline": "bottom"});
 379             //allnodes.scheduler = this;
 380             allnodes.click(this._allnodes_click); // XXX click
 381
 382             // timeslot buttons [it's the triangles above the slots]
 383             for (var i = 0, len = axisx.length; i < len; ++i) {
 384                 var timebutton = paper.path(timebutton_path).attr({'translation':left + ',' + top}).attr(attr_timebutton);
 385                 timebutton.from_time = axisx[i][0];
 386                 timebutton.scheduler = this;
 387                 timebutton.click(this._timebutton_click);
 388                 left += (o.leases_w);
 389             }
 390
 391             //////// the body of the scheduler : loop on nodes
 392             top += o.y_node + o.y_sep;
 393
 394             var data_index = 0;
 395             this.leases = []; /* XXX ??? XXX */
 396
 397             for (var i = 0, len = axisy.length; i < len; ++i) {
 398                 var urn = axisy[i][0];
 399                 var nodename = axisy[i][1];
 400                 var type = axisy[i][2];
 401                 left = 0;
 402                 /*
 403                  *  MODIFIED font-size
 404                 var nodelabel = paper.text(o.x_nodelabel-x_sep,top+y_node/2,nodename).attr(txt_nodelabel)
 405                 .attr ({"font-size":y_node, "text-anchor":"end","baseline":"bottom"});
 406                 */
 407                 var nodelabel = paper.text(o.x_nodelabel - o.x_sep, top + o.y_node / 3, nodename).attr(txt_nodelabel)
 408                     .attr({"font-size": "12px", "text-anchor": "end","baseline": "bottom"});
 409
 410                 this._nodelabel_select(nodelabel, 1); // By default we select all nodes
 411                 nodelabel.scheduler = this;
 412                 nodelabel.click(this._nodelabel_click); //click action works here
 413                 this._nodelabels.push(nodelabel);
 414
 415                // lease_methods.init_free(nodelabel.click, lease_methods.click_mine);
 416                //lease_methods.init_free(nodelabel.lease);
 417
 418                 left += o.x_nodelabel;
 419
 420                 // data index contains the full array of leases
 421                 // not the same amount of grains per node
 422
 423                 // NOTE: remembering the previous lease might help for long leases.
 424                 var grain=0;
 425                 while (grain < this.nb_grains()) {
 426
 427                     if (l = this._lease_find(urn, this._initial_timestamp + grain * 1800)) {
 428                         slicename = l.slice_id;
 429                     } else {
 430                         slicename = "";
 431                     }
 432
 433                     //lease_id  = this.data[data_index][0];
 434                     //slicename = this.data[data_index][1];
 435                     /* Duration should not be the lease duration, but the grain */
 436                     var duration = 1; // this.data[data_index][2];
 437
 438                     var lease = paper.rect(left, top, o.leases_w * duration, o.y_node, o.radius);
 439                     lease.scheduler = this; // we record a pointer to the scheduler in the lease element
 440                     //lease.lease_id=lease_id;
 441                     lease.nodename  = nodename;
 442                     lease.urn       = urn;
 443                     lease.nodelabel = nodelabel;
 444
 445                     if (slicename == "") {
 446                         lease.initial = "free";
 447                         this._lease_init_free(lease);
 448                     } else if (slicename == o.slicename) {
 449                         lease.initial = "mine";
 450                         this._lease_init_mine(lease);
 451                     } else {
 452                         lease.initial = "other";
 453                         this._lease_init_other(lease, slicename);
 454                     }
 455
 456                     lease.from_time = axisx[grain % this.nb_grains()][0];
 457                     grain += duration;
 458                     lease.until_time = axisx[grain % this.nb_grains()][0];
 459
 460                     /* We set a key to the lease element to find it later in the paper thanks to this._lease_element_find() */
 461                     lease.key        = urn + '-' + lease.from_time;
 462
 463                     // and vice versa
 464                     this._lease_elements.push(lease);
 465                     // move on with the loop
 466                     left += o.leases_w * duration;
 467                     data_index += 1;
 468                 }
 469                 top += o.y_node + o.y_sep;
 470             };
 471         }, /* _draw */
 472
 473         _init_axisx: function(currentDate)
 474         {
 475             this._axisx = Array();
 476
 477             if(currentDate == "") {
 478                 // creating timestamp of the current time
 479                 currentDate = new Date().getTime() / 1000;
 480             }
 481             this._initial_timestamp = currentDate;
 482             //console.log(currentDate);
 483
 484             // round it by granularity (becomes an Int)
 485             var rounded = Math.round(currentDate / this.min_granularity) * this.min_granularity;
 486             // Convert Int to Date
 487             rounded = new Date(rounded * 1000);
 488             // get hours and minutes in a 24h format 00:00
 489             var roundedHours   = (rounded.getHours()   < 10 ? '0' : '') + rounded.getHours();
 490             var roundedMinutes = (rounded.getMinutes() < 10 ? '0' : '') + rounded.getMinutes();
 491
 492             this._axisx.push(Array(rounded, roundedHours + ":" + roundedMinutes));
 493
 494             // Generate as many slots as we need
 495             for(i = 0; i < this.options.leases_slots; i++) {
 496                 rounded = this.min_granularity + (rounded.getTime() / 1000);
 497                 rounded = new Date(rounded * 1000);
 498                 roundedHours   = (rounded.getHours()   < 10 ? '0' : '') + rounded.getHours();
 499                 roundedMinutes = (rounded.getMinutes() < 10 ? '0' : '') + rounded.getMinutes();
 500
 501                 this._axisx.push(Array(rounded, roundedHours + ":" + roundedMinutes));
 502             }
 503         },
 504
 505         clear: function ()
 506         {
 507             for (var i=0, len = this.leases.length; i<len; ++i) {
 508                 var lease = this.leases[i];
 509                 if (lease.current != lease.initial) {
 510                     if (lease.initial == 'free')
 511                         this._lease_init_free(lease, this._lease_click_mine);
 512                     else
 513                         this._lease_init_mine(lease, this._lease_methods.click_free);
 514                 }
 515             }
 516         },
 517
 518         // XXX Couldn't find how to inhererit from the raphael objects...
 519
 520         /* ---------------------------------------------------------------------
 521          * The 'all nodes' button
 522          */
 523         _allnodes_click: function (event) {
 524             var scheduler=this.scheduler;
 525
 526             /* decide what to do */
 527             var unselected = 0;
 528             for (var i = 0, len = this._nodelabels.length; i < len; ++i)
 529                 if (!this._nodelabels[i].selected)
 530                     unselected++;
 531
 532             /* if at least one is not selected : select all */
 533             var new_state = (unselected >0) ? 1 : 0;
 534             for (var i=0, len=this._nodelabels.length; i<len; ++i)
 535                 this._nodelabel_select(this._nodelabels[i], new_state);
 536         },
 537
 538         /* ---------------------------------------------------------------------
 539          * The buttons for managing the whole timeslot
 540          */
 541
 542         /* clicking */
 543         _timebutton_click: function (event)
 544         {
 545             var scheduler  = this.scheduler;
 546             var from_time  = this.from_time;
 547             var until_time = new Date(from_time.getTime() + scheduler.granularity);
 548             /* scan leases on selected nodes, store in two arrays */
 549             var relevant_free = [], relevant_mine = [];
 550             for (var i = 0, len = scheduler._lease_elements.length; i < len; ++i) {
 551                 var scan = scheduler._lease_elements[i];
 552                 if (!scan.nodelabel.selected)
 553                     continue;
 554                 // overlap ?
 555                 if (scan.from_time <= from_time && scan.until_time >= until_time) {
 556                     if (scan.current == "free")
 557                         relevant_free.push(scan);
 558                     else if (scan.current == "mine")
 559                         relevant_mine.push(scan);
 560                 }
 561             }
 562             // window.console.log("Found " + relevant_free.length + " free and " + relevant_mine.length + " mine");
 563             /* decide what to do, whether book or release */
 564             if (relevant_mine.length == 0 && relevant_free.length == 0) {
 565                 alert ("Nothing to do in this timeslot on the selected nodes");
 566                 return;
 567             }
 568             // if at least one is free, let's book
 569             if (relevant_free.length > 0) {
 570                 for (var i = 0, len = relevant_free.length; i < len; ++i) {
 571                     var lease = relevant_free[i];
 572                     scheduler._lease_init_mine(lease, scheduler._lease_click_free);
 573                 }
 574             // otherwise we unselect
 575             } else {
 576                 for (var i = 0, len = relevant_mine.length; i < len; ++i) {
 577                     var lease = relevant_mine[i];
 578                     scheduler._lease_init_free(lease, scheduler._lease_click_mine);
 579                 }
 580             }
 581         }, /* _timebutton_click */
 582
 583         /* ---------------------------------------------------------------------
 584          * The nodelabel buttons
 585          */
 586
 587         // set selected mode and render visually
 588         _nodelabel_select: function (nodelabel, flag)
 589         {
 590             nodelabel.selected = flag;
 591             nodelabel.attr({'font-weight': (flag ? 'bold' : 'normal')});
 592             // TODO
 593             //
 594             // loop on axis x and select each timebutton
 595             // for (var i=0, len=axisx.length; i < len; ++i)
 596             // figure out how to use timebutton_methods.click();
 597
 598         },
 599
 600         // toggle selected
 601         _nodelabel_click: function (event)
 602         {
 603             this.scheduler._nodelabel_select( this, ! this.selected );
 604         },
 605
 606
 607         /* ---------------------------------------------------------------------
 608          * The lease buttons
 609          */
 610         _lease_init_free: function (lease, unclick)
 611         {
 612             var o = lease.scheduler.options;
 613             lease.current = "free";
 614             // set color
 615             lease.animate((lease.initial == "free") ? attr_lease_free_free : attr_lease_mine_free, o.anim_delay);
 616             // keep track of the current status
 617             // record action
 618             lease.click(this._lease_click_free);
 619             if (unclick) lease.unclick(unclick);
 620         },
 621
 622         // find out all the currently free leases that overlap this one
 623         _lease_click_free: function (event)
 624         {
 625             var scheduler = this.scheduler;
 626
 627             scheduler._lease_init_mine(this, scheduler._lease_click_free);
 628             //publish
 629             //this.from_time
 630             //this.urn
 631             //this.until_time
 632             var urn        = this.urn
 633             var start_time = this.from_time.getTime() / 1000;
 634             var end_time   = this.until_time.getTime() / 1000;
 635             var duration   = (end_time - start_time) / 1800; // XXX HARDCODED LEASE GRAIN
 636
 637             /* Add a new lease : XXX should be replaced by a dictionary */
 638             /*
 639             // Do we have a lease with the same urn  just before or just after ?
 640             //var removeIdBefore = null;
 641             //var removeIdAfter  = null;
 642             var remove_lease_before = null;
 643             var remove_lease_after  = null;
 644             // It is important to group leases,  while this is technically
 645             // equivalent, some testbeds such as IotLab limit the number of
 646             // leases a user can have.
 647             // XXX we might have several leases before or after if they have
 648             // XXX not been grouped like this tool does
 649             $.each(scheduler._leases, function(i, lease) {
 650                 if (lease[0] == urn) {
 651                     if (lease[1] + lease[2] * 1800 == start_time) { // XXX HARDCODED LEASE GRAIN
 652                         // Merge with previous lease
 653                         // removeIdBefore = i;
 654                         remove_lease_before = lease;
 655                         start_time          = lease[1];
 656                         duration           += lease[2];
 657                     }
 658                     if (lease[1] == end_time) {
 659                         // Merge with following lease
 660                         // removeIdAfter = i;
 661                         remove_lease_after  = lease;
 662                         duration           += lease[2];
 663                     }
 664                 }
 665             });
 666             //if (removeIdBefore != null) {
 667             //    scheduler._leases.splice(removeIdBefore , 1);
 668             //    if (removeIdAfter != null)
 669             //        removeIdAfter -= 1;
 670             //}
 671             //if (removeIdAfter != null) {
 672             //    scheduler._leases.splice(removeIdAfter , 1);
 673             //}
 674
 675             // We add the new lease, no need to push
 676             var new_lease = [this.urn, start_time, duration];
 677
 678             // We send events, manifold will inform us about the change and we will react accordingly
 679             /*
 680             if (remove_lease_before != null)
 681                 manifold.raise_event(scheduler.options.query_lease_uuid, SET_REMOVED, remove_lease_before);
 682             if (remove_lease_after != null)
 683                 manifold.raise_event(scheduler.options.query_lease_uuid, SET_REMOVED, remove_lease_after);
 684             */
 685             manifold.raise_event(scheduler.options.query_lease_uuid, SET_ADD,     new_lease);
 686             //scheduler._leases.push([this.urn, start_time, duration]);
 687
 688             //console.log(scheduler._leases);
 689             //jQuery.publish('/update-set/' + scheduler.options.query_uuid, [scheduler._leases]);
 690
 691             /* We need to inform manifold about the whole diff, in addition to maintaining our own structure */
 692             event.preventDefault();
 693         },
 694
 695         _lease_init_mine: function (lease, unclick)
 696         {
 697             var o = lease.scheduler.options;
 698             lease.current = "mine";
 699             lease.animate((lease.initial == "mine") ? attr_lease_mine_mine : attr_lease_free_mine, o.anim_delay);
 700             lease.click(this._lease_click_mine);
 701             if (unclick)
 702                 lease.unclick(unclick);
 703         },
 704
 705         /* TODO: remove selected lease from array _leases and publish change */
 706         _lease_click_mine: function (event)
 707         {
 708             var scheduler = this.scheduler;
 709             // this lease was originally free but is now marked for booking
 710             // we free just this lease
 711             //console.log('this is mine');
 712             scheduler._lease_init_free(this, scheduler._lease_click_mine);
 713             event.preventDefault();
 714         },
 715
 716
 717         lease_init_other: function (lease, slicename)
 718         {
 719             lease.animate (attr_lease_other,anim_delay);
 720             /* a text obj to display the name of the slice that owns that lease */
 721             var otherslicelabel = lease.scheduler.paper.text (lease.attr("x")+lease.attr("width")/2,
 722                                       // xxx
 723                                       lease.attr("y")+lease.attr("height")/2,slicename).attr(txt_otherslice);
 724             /* hide it right away */
 725             otherslicelabel.hide();
 726             /* record it */
 727             lease.label=otherslicelabel;
 728             lease.hover ( function (e) {this.label.toFront();this.label.show();},
 729                       function (e) {this.label.hide();} );
 730         }
 731
 732     });
 733
 734     $.plugin('Scheduler', Scheduler);
 735
 736 })(jQuery);