svghmi/widgets_common.ysl2
changeset 3600 c9ecf7d50888
parent 3596 9c725829d8f0
child 3603 f1a00aa8cb3b
equal deleted inserted replaced
3599:0d7c41546854 3600:c9ecf7d50888
    59 };
    59 };
    60 
    60 
    61 in xsl decl widget_defs(%name, match="widget[@type='%name']", mode="widget_defs") alias template {
    61 in xsl decl widget_defs(%name, match="widget[@type='%name']", mode="widget_defs") alias template {
    62     param "hmi_element";
    62     param "hmi_element";
    63     // all widget potentially has a "disabled" labeled element
    63     // all widget potentially has a "disabled" labeled element
    64     const "disability" optional_labels("disabled");
    64     const "disability" optional_labels("/disabled");
    65     value "$disability";
    65     value "$disability";
    66     const "has_disability","string-length($disability)>0";
    66     const "has_disability","string-length($disability)>0";
    67     content;
    67     content;
    68 };
    68 };
    69 
    69 
   370                 /* dispatch current cache in newly opened page widgets */
   370                 /* dispatch current cache in newly opened page widgets */
   371                 let realindex = this.get_variable_index(index);
   371                 let realindex = this.get_variable_index(index);
   372                 if(realindex == undefined) continue;
   372                 if(realindex == undefined) continue;
   373                 let cached_val = cache[realindex];
   373                 let cached_val = cache[realindex];
   374                 if(cached_val != undefined)
   374                 if(cached_val != undefined)
   375                     this._dispatch(cached_val, cached_val, index);
   375                     this.feed_data_for_dispatch(cached_val, cached_val, index);
   376             }
   376             }
   377         }
   377         }
   378 
   378 
   379         get_variable_index(varnum) {
   379         get_variable_index(varnum) {
   380             let index = this.indexes[varnum];
   380             let index = this.indexes[varnum];
   461             for(let i = 0; i < this.indexes_length; i++) {
   461             for(let i = 0; i < this.indexes_length; i++) {
   462                 let refindex = this.get_variable_index(i);
   462                 let refindex = this.get_variable_index(i);
   463                 if(refindex == undefined) continue;
   463                 if(refindex == undefined) continue;
   464 
   464 
   465                 if(index == refindex) {
   465                 if(index == refindex) {
   466                     this._dispatch(value, oldval, i);
   466                     this.feed_data_for_dispatch(value, oldval, i);
   467                     break;
   467                     break;
   468                 }
   468                 }
   469             }
   469             }
   470         }
   470         }
   471         
   471         
   472         undeafen(index){
   472         undeafen(index){
   473             this.deafen[index] = undefined;
   473             this.deafen[index] = undefined;
   474             let [new_val, old_val] = this.incoming[index];
   474             let [new_val, old_val] = this.incoming[index];
   475             this.incoming[index] = undefined;
   475             this.incoming[index] = undefined;
   476             if(this.dispatch)
   476             this.do_dispatch(new_val, old_val, index);
   477                 this.dispatch(new_val, old_val, index);
       
   478         }
   477         }
   479 
   478 
   480         enable(enabled){
   479         enable(enabled){
   481             if(this.enable_state != enabled){
   480             if(this.enable_state != enabled){
   482                 this.enable_state = enabled;
   481                 this.enable_state = enabled;
   514                 // once disabled activity display is lost
   513                 // once disabled activity display is lost
   515                 this.activity_displayed_state = undefined;
   514                 this.activity_displayed_state = undefined;
   516             }
   515             }
   517         }
   516         }
   518 
   517 
   519         _dispatch(value, oldval, varnum) {
   518         feed_data_for_dispatch(value, oldval, varnum) {
   520             let dispatch = this.dispatch;
   519             if(this.dispatch || this.enable_expr){
   521             let has_dispatch = dispatch != undefined;
       
   522             if(has_dispatch || this.enable_expr){
       
   523                 if(this.deafen[varnum] == undefined){
   520                 if(this.deafen[varnum] == undefined){
   524                     let now = Date.now();
   521                     let now = Date.now();
   525                     let min_interval = 1000/this.frequency;
   522                     let min_interval = 1000/this.frequency;
   526                     let lastdispatch = this.lastdispatch[varnum];
   523                     let lastdispatch = this.lastdispatch[varnum];
   527                     if(lastdispatch == undefined || now > lastdispatch + min_interval){
   524                     if(lastdispatch == undefined || now > lastdispatch + min_interval){
   528                         this.lastdispatch[varnum] = now;
   525                         this.lastdispatch[varnum] = now;
   529                         if(has_dispatch) try {
   526                         this.do_dispatch(value, oldval, varnum)
   530                             dispatch.call(this, value, oldval, varnum);
       
   531                         } catch(err) {
       
   532                             console.log(err);
       
   533                         }
       
   534                         if(this.enable_expr) try {
       
   535                             this.compute_enable(value, oldval, varnum);
       
   536                         } catch(err) {
       
   537                             console.log(err);
       
   538                         }
       
   539                     }
   527                     }
   540                     else {
   528                     else {
   541                         let elapsed = now - lastdispatch;
   529                         let elapsed = now - lastdispatch;
   542                         this.incoming[varnum] = [value, oldval];
   530                         this.incoming[varnum] = [value, oldval];
   543                         this.deafen[varnum] = setTimeout(this.bound_undeafen, min_interval - elapsed, varnum);
   531                         this.deafen[varnum] = setTimeout(this.bound_undeafen, min_interval - elapsed, varnum);
   544                     }
   532                     }
   545                 }
   533                 }
   546                 else {
   534                 else {
   547                     this.incoming[varnum] = [value, oldval];
   535                     this.incoming[varnum] = [value, oldval];
   548                 }
   536                 }
       
   537             }
       
   538         }
       
   539 
       
   540         do_dispatch(value, oldval, varnum) {
       
   541             if(this.dispatch) try {
       
   542                 this.dispatch(value, oldval, varnum);
       
   543             } catch(err) {
       
   544                 console.log(err);
       
   545             }
       
   546             if(this.enable_expr) try {
       
   547                 this.compute_enable(value, oldval, varnum);
       
   548             } catch(err) {
       
   549                 console.log(err);
   549             }
   550             }
   550         }
   551         }
   551 
   552 
   552         _animate(){
   553         _animate(){
   553             if(this.enable_expr)
   554             if(this.enable_expr)