Unify/framework/client/eventManager.js

/*

	Copyright (c) 2020, 2023, The Unified Company.

	This code is part of Unify.

	This program is free software; you can redistribute it and/or modify
	it under the terms of the GNU AFFERO GENERAL PUBLIC LICENSE,
	as published by the Free Software Foundation.
	See the GNU AFFERO GENERAL PUBLIC LICENSE, for more details.

	https://unifyjs.org 

*/

import vector2			from '../unify/math/vector2.js';

import event			from './event.js';

import tools			from '../unify/tools.js';


export default class eventManager{

	events 			= new Array();

	eventTerms 		= new Array();

	constructor() {

		var prototype 			= Object.getPrototypeOf( document.body );

		var innerPrototype 		= Object.getPrototypeOf( prototype );

		var objectProperties	= Object.getOwnPropertyNames( innerPrototype  );

		var eventProperties 	= objectProperties.filter( this.filterEvent );

		var properEventTerms	= eventProperties.map( this.removeOn );

		// console.log( "properEventTerms", JSON.stringify( properEventTerms ) );

		this.eventTerms 		= properEventTerms;

	}

	filterEvent( name ) { 

		if( name[0] == "o" && name[1] == "n" ){

			return true;

		} else {

			return false;

		} 

	}

	removeOn( name ) {

		return name.substr( 2, name.length );

	}

	addClientEvent( className, eventName, callback ) {
	
		var newEvent 		= new event();

		newEvent.className 	= className;

		newEvent.name 		= eventName;

		newEvent.callback  	= callback;

		this.events.push(newEvent);

	}
	
	getClientEvents( classname, eventName ){
	
		var events = [];
		
		for(var c = 0; c<this.events.length; c++) {
		
			var event = this.events[c];

			if( event.className == classname &&  event.name == eventName ) {
	
				events.push( event );
			
			}
		}

		return events;

	}


	parentHasEvent( object, eventTerm ) {
		
		if( !object ) {

			return false;
		}
		
		if( object[ eventTerm ] ) {

			return true;
			
		}
		
		if( object.parent ){
		
			return this.parentHasEvent( object.parent, eventTerm );
		
		} else {
		
			return false;
			
		}

	}
	
	update_value( object ) {

		if( object.value && object.value != "undefined" ) {
	
			object._value = object.value;
			
		}

	}

	createInputSetter( object, element ) {

		object.__defineSetter__( "value", function( value ){ 

			if( object.datatype == "BOOLEAN" ) {

				object._value = value;

				element.value = object._value;

			}
		
			if( value && value != undefined && value != "undefined" ) {
			
				object._value = value;

				element.value = object._value;

			} 

			if( value == "" ) {
			
				object._value = "";

				element.value = "";
				
			}

			if( typeof value == "number" ) {

				object._value = value;

				element.value = object._value;

			}
			
		});

	}

	createUploadSetter( object, element ) {

		object.__defineSetter__( "value", function( value ){ 

			if( value != "undefined" ) {
			
				object._value = value;
				
			}
			
			if( element.value ) {
			
				//element.value = value;
			
			}

		});

	}

	createSetter( object, element ) {
	
		this.update_value( object );
		
		if( object.inputType != "file" ) {

			this.createInputSetter( object, element );
		
		}  else {
		
			this.createUploadSetter( object, element );
		
		}
	}
	
	createGetter( object ) {
	
		object.__defineGetter__( "value", function( value ){ 

			if( typeof object._value == "undefined" ) {

				return "";

			} else {
			
				return object._value;
				
			}

		});

	}
	

	parseEvents( object ){

		if( object.defaultElement ) {

			this.createSetter( object, object.defaultElement );
			this.createGetter( object );
			
		}
		
		if( object.customElement ) {

			this.createSetter( object, object.customElement );
			this.createGetter( object );
			
		}

		var eventTerms = this.eventTerms;
		
		for(var c = 0; c<eventTerms.length; c++) {
		
			var eventTerm = eventTerms[ c ];
			
			this.parseEvent( object, eventTerm );

		}
		
	}
	
	defineEventCallback( object, element, eventTerm ) {

		var eventManager = this;

		if( !this.parentHasEvent( object.parent, eventTerm ) || object.selector ) {

			var eventNormalized		= eventTerm.replace("box", "");

			if( object.getClassName() != "fileChooserSelectButton" ){
	
				element[ "on" + eventNormalized ] = function( event ) { eventManager.createEventCallback( event, eventManager ); };

			}
		
		}

	}

	createWindowResizeEventListener( object ) {
/*
		if( object.parent && object.parent["windowResize"] ) {

			window.addEventListener("resize", function(){

				object.parent.windowResize();

			})

			object.parent.windowResize();

		}

		if( object["windowResize"] ) {

			window.onresize = function() {

				object.windowResize();

			}

			object.windowResize();
		}
*/
	}
	
	parseElement( object, element, eventTerm, box = false ) {
	
		element.object 		= object;

		element.eventTerm 	= eventTerm;

		this.defineEventCallback( object, element, eventTerm );

		//this.createWindowResizeEventListener( object );

	}

	parseDefaultElement( object, eventTerm ) {

		if( object[ eventTerm ] ) {
			
			this.parseElement( object, object.defaultElement, eventTerm );

			if( object.customElement ) {
			
				this.parseElement( object, object.customElement, eventTerm );
				
			}
			
		}

	}

	parseBoxElement( object, eventTerm ) {

		if( object[ "box" + tools.CamelCase( eventTerm ) ] ) {

			if( object.boxElement ) {

				var element = object.boxElement;

			} else {

				var element = object.defaultElement;

			}

			this.parseElement( object, element, "box" + tools.CamelCase( eventTerm ), true );

		}

	}
	
	parseEvent( object, eventTerm ) {
	
		this.parseDefaultElement( object, eventTerm );

		this.parseBoxElement( object, eventTerm );

	}

	callMethod( object, event, eventTerm ) {

		if( object[ eventTerm ] ) {

			object.lastEvent = eventTerm;

			object[ eventTerm ]( event, object );

		}

	}

	createEventListener( event, object, box = false ) {

		var eventTerm = event.type.replace("on", ""); 

		if( box ) {

			eventTerm = "box" + tools.CamelCase( eventTerm );

		}

		this.callMethod( object, event, eventTerm );

		if( !object.isRoot && object.parent ) {
		
			if( object.propegateEvent ) {
			
				this.createEventListener( event, object.parent );
			
			}
		
		}

	}

	createEventListeners( event, target, eventManager, object ) {

		if( object.boxElement && target.className == object.boxElement.className ) {

			eventManager.createEventListener( event, object, true );

		} else if( target.className == object.defaultElement.className ) {
		
			eventManager.createEventListener( event, object );
			
		} else if( target.className == object.customElement.className ) {
		
			eventManager.createEventListener( event, object );
			
		}

	}

	logEvent( event, target ) {

		//console.log( "Event triggered", event.type.replace("on", ""), target, target.object );

	}

	createEventCallback( event, eventManager ) {
		
		var target 		= event.target;

		var object 		= target.object;

		if( !object ) {

			console.error("This element does not have an object", target);

			return false;

		}

		this.logEvent( event, target );

		this.createEventListeners( event, target, eventManager, object );
	
	}

}