EventSystem

class webix.EventSystem()

Eventsystem mixin

External references

Official documentation page.

Code

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 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
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
webix.EventSystem={
    $init:function(){
        if (!this._evs_events){
            this._evs_events = {};        //hash of event handlers, name => handler
            this._evs_handlers = {};    //hash of event handlers, ID => handler
            this._evs_map = {};
        }
    },
    //temporary block event triggering
    blockEvent : function(){
        this._evs_events._block = true;
    },
    //re-enable event triggering
    unblockEvent : function(){
        this._evs_events._block = false;
    },
    mapEvent:function(map){
        webix.extend(this._evs_map, map, true);
    },
    on_setter:function(config){
        if(config){
            for(var i in config){
                var method = webix.toFunctor(config[i], this.$scope);
                var sub = i.indexOf("->");
                if (sub !== -1){
                    this[i.substr(0,sub)].attachEvent(i.substr(sub+2), webix.bind(method, this));
                } else
                    this.attachEvent(i, method);
            }
        }
    },
    //trigger event
    callEvent:function(type,params){
        if (this._evs_events._block) return true;

        type = type.toLowerCase();
        var event_stack =this._evs_events[type.toLowerCase()];    //all events for provided name
        var return_value = true;

        if (webix.log)
            if ((webix.debug || this.debug) && !webix.debug_blacklist[type])    //can slowdown a lot
                webix.log("info","["+this.name+"@"+((this._settings||{}).id)+"] event:"+type,params);

        if (event_stack)
            for(var i=0; i<event_stack.length; i++){
                /*
                    Call events one by one
                    If any event return false - result of whole event will be false
                    Handlers which are not returning anything - counted as positive
                */
                if (event_stack[i].apply(this,(params||[]))===false) return_value=false;
            }
        if (this._evs_map[type]){
            var target = this._evs_map[type];
            target.$eventSource = this;
            if (!target.callEvent(type,params))
                return_value =    false;
            target.$eventSource = null;
        }

        return return_value;
    },
    //assign handler for some named event
    attachEvent:function(type,functor,id){
        webix.assert(functor, "Invalid event handler for "+type);

        type=type.toLowerCase();

        id=id||webix.uid(); //ID can be used for detachEvent
        functor = webix.toFunctor(functor, this.$scope);    //functor can be a name of method

        var event_stack=this._evs_events[type]||webix.toArray();
        //save new event handler
        if (arguments[3])
            event_stack.unshift(functor);
        else
            event_stack.push(functor);
        this._evs_events[type]=event_stack;
        this._evs_handlers[id]={ f:functor,t:type };

        return id;
    },
    //remove event handler
    detachEvent:function(id){
        if(!this._evs_handlers[id]){
            var name = (id+"").toLowerCase();
            if (this._evs_events[name]){
                this._evs_events[name] = webix.toArray();
            }
            return;
        }
        var type=this._evs_handlers[id].t;
        var functor=this._evs_handlers[id].f;

        //remove from all collections
        var event_stack=this._evs_events[type];
        event_stack.remove(functor);
        delete this._evs_handlers[id];
    },
    hasEvent:function(type){
        type=type.toLowerCase();
        var stack = this._evs_events[type];
        return (stack && stack.length) ? true : false;
    }
};

webix.extend(webix, webix.EventSystem, true);

//array helper
//can be used by webix.toArray()