File : main/travelNotes/EventListenersLoader.js

/*
Copyright - 2017 2023 - wwwouaiebe - Contact: https://www.ouaie.be/

This  program is free software;
you can redistribute it and/or modify it under the terms of the
GNU General Public License as published by the Free Software Foundation;
either version 3 of the License, or any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
*/
/*
Changes:
    - v4.0.0:
        - created from v3.6.0
Doc reviewed 202208
 */

import theMapEditor from '../../core/mapEditor/MapEditor.js';
import theIndexedDb from '../../core/uiLib/IndexedDb.js';
import theProfileDialogsManager from '../../core/ProfileDialogsManager.js';
import theTravelNotesData from '../../data/TravelNotesData.js';
import theConfig from '../../data/Config.js';
import theDockableDialogsManager from '../../core/DockableDialogsManager.js';
import theProvidersToolbar from '../../toolbars/providersToolbar/ProvidersToolbar.js';
import RoadbookUpdateEL from './RoadbookUpdateEL.js';
import ResizeEL from './ResizeEL.js';

/* ------------------------------------------------------------------------------------------------------------------------- */
/**
Simple static methods for the loading of event listeners
*/
/* ------------------------------------------------------------------------------------------------------------------------- */

class EventListenersLoader {

    /**
    Loading event listeners
    */

    static addEventsListeners ( ) {
        document.addEventListener (
            'additinerarypointmarker',
            addItineraryPointMarkerEvent => {
                if ( addItineraryPointMarkerEvent.data ) {
                    theMapEditor.addItineraryPointMarker (
                        addItineraryPointMarkerEvent.data.objId,
                        addItineraryPointMarkerEvent.data.latLng
                    );
                }
            }
        );
        document.addEventListener (
            'addrectangle',
            addRectangleEvent => {
                if ( addRectangleEvent.data ) {
                    theMapEditor.addRectangle (
                        addRectangleEvent.data.objId,
                        addRectangleEvent.data.bounds,
                        addRectangleEvent.data.properties
                    );
                }
            }
        );
        document.addEventListener (
            'addsearchpointmarker',
            addSearchPointMarkerEvent => {
                if ( addSearchPointMarkerEvent.data ) {
                    theMapEditor.addSearchPointMarker (
                        addSearchPointMarkerEvent.data.objId,
                        addSearchPointMarkerEvent.data.latLng,
                        addSearchPointMarkerEvent.data.geometry
                    );
                }
            }
        );
        document.addEventListener (
            'addwaypoint',
            addWayPointEvent => {
                if ( addWayPointEvent.data ) {
                    theMapEditor.addWayPoint (
                        addWayPointEvent.data.wayPoint,
                        addWayPointEvent.data.letter
                    );
                }
            }
        );
        document.addEventListener (
            'geolocationpositionchanged',
            geoLocationPositionChangedEvent => {
                if ( geoLocationPositionChangedEvent.data ) {
                    theMapEditor.onGeolocationPositionChanged ( geoLocationPositionChangedEvent.data.position );
                }
            }
        );
        document.addEventListener (
            'geolocationstatuschanged',
            geoLocationStatusChangedEvent => {
                if ( geoLocationStatusChangedEvent.data ) {
                    theMapEditor.onGeolocationStatusChanged ( geoLocationStatusChangedEvent.data.status );
                }
            }
        );
        document.addEventListener (
            'layerchange',
            layerChangeEvent => {
                if ( layerChangeEvent.data ) {
                    theMapEditor.setLayer ( layerChangeEvent.data.layer );
                }
            }
        );
        document.addEventListener (
            'noteupdated',
            updateNoteEvent => {
                if ( updateNoteEvent.data ) {
                    theMapEditor.updateNote (
                        updateNoteEvent.data.removedNoteObjId,
                        updateNoteEvent.data.addedNoteObjId
                    );
                }
            }
        );
        document.addEventListener (
            'profileclosed',
            profileClosedEvent => {
                if ( profileClosedEvent.data ) {
                    theProfileDialogsManager.onProfileClosed ( profileClosedEvent.data.objId );
                }
            }
        );
        document.addEventListener (
            'providersadded',
            ( ) => theProvidersToolbar.providersAdded ( )
        );
        document.addEventListener (
            'removeallobjects',
            ( ) => theMapEditor.removeAllObjects ( )
        );
        document.addEventListener (
            'removeobject',
            removeObjectEvent => {
                if ( removeObjectEvent.data ) {
                    theMapEditor.removeObject (
                        removeObjectEvent.data.objId
                    );
                }
            }
        );
        document.addEventListener (
            'routepropertiesupdated',
            updateRoutePropertiesEvent => {
                if ( updateRoutePropertiesEvent.data ) {
                    theMapEditor.updateRouteProperties (
                        updateRoutePropertiesEvent.data.routeObjId
                    );
                }
            }
        );
        document.addEventListener (
            'routeupdated',
            updateRouteEvent => {
                if ( updateRouteEvent.data ) {
                    theMapEditor.updateRoute (
                        updateRouteEvent.data.removedRouteObjId,
                        updateRouteEvent.data.addedRouteObjId
                    );
                }
            }
        );
        document.addEventListener (
            'setprovider',
            setProviderEvent => {
                if ( setProviderEvent?.data?.provider ) {
                    theProvidersToolbar.provider = setProviderEvent.data.provider;
                }
            }
        );
        document.addEventListener (
            'settransitmode',
            setTransitModeEvent => {
                if ( setTransitModeEvent?.data?.transitMode ) {
                    theProvidersToolbar.transitMode = setTransitModeEvent.data.transitMode;
                }
            }
        );
        document.addEventListener (
            'showtravelproperties',
            ( ) => theDockableDialogsManager.showTravelProperties ( )
        );
        document.addEventListener (
            'updateosmsearch',
            ( ) => theDockableDialogsManager.osmSearchDialog.updateContent ( )
        );
        document.addEventListener (
            'updateprofilename',
            updateProfileNameEvent => {
                if ( updateProfileNameEvent.data ) {
                    theProfileDialogsManager.updateProfileName (
                        updateProfileNameEvent.data.routeObjId
                    );
                }
            }
        );
        document.addEventListener (
            'updateroadbook',
            new RoadbookUpdateEL ( )
        );
        document.addEventListener (
            'updatetravelnotes',
            ( ) => theDockableDialogsManager.travelNotesDialog.updateContent ( )
        );
        document.addEventListener (
            'updatetravelproperties',
            ( ) => theDockableDialogsManager.travelPropertiesDialog.updateContent ( )
        );
        document.addEventListener (
            'zoomto',
            zoomToEvent => {
                if ( zoomToEvent.data ) {
                    theMapEditor.zoomTo (
                        zoomToEvent.data.latLng,
                        zoomToEvent.data.geometry
                    );
                }
            }
        );
        window.visualViewport.addEventListener ( 'resize', new ResizeEL ( ) );
    }

    /**
    Loading unload and beforeunload event listeners
    */

    static addUnloadEventsListeners ( ) {
        window.addEventListener ( 'unload', ( ) => localStorage.removeItem ( theTravelNotesData.UUID ) );
        window.addEventListener (
            'beforeunload',
            beforeUnloadEvent => {
                theIndexedDb.closeDb ( theTravelNotesData.UUID );
                if ( theConfig.travelNotes.haveBeforeUnloadWarning ) {
                    beforeUnloadEvent.returnValue = 'x';
                    return 'x';
                }
            }
        );
    }
}

export default EventListenersLoader;

/* --- End of file --------------------------------------------------------------------------------------------------------- */


1	/*
2	Copyright - 2017 2023 - wwwouaiebe - Contact: https://www.ouaie.be/
3
4	This program is free software;
5	you can redistribute it and/or modify it under the terms of the
6	GNU General Public License as published by the Free Software Foundation;
7	either version 3 of the License, or any later version.
8
9	This program is distributed in the hope that it will be useful,
10	but WITHOUT ANY WARRANTY; without even the implied warranty of
11	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12	GNU General Public License for more details.
13
14	You should have received a copy of the GNU General Public License
15	along with this program; if not, write to the Free Software
16	Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
17	*/
18	/*
19	Changes:
20	- v4.0.0:
21	- created from v3.6.0
22	Doc reviewed 202208
23	*/
24
25	import theMapEditor from '../../core/mapEditor/MapEditor.js';
26	import theIndexedDb from '../../core/uiLib/IndexedDb.js';
27	import theProfileDialogsManager from '../../core/ProfileDialogsManager.js';
28	import theTravelNotesData from '../../data/TravelNotesData.js';
29	import theConfig from '../../data/Config.js';
30	import theDockableDialogsManager from '../../core/DockableDialogsManager.js';
31	import theProvidersToolbar from '../../toolbars/providersToolbar/ProvidersToolbar.js';
32	import RoadbookUpdateEL from './RoadbookUpdateEL.js';
33	import ResizeEL from './ResizeEL.js';
34
35	/* ------------------------------------------------------------------------------------------------------------------------- */
36	/**
37	Simple static methods for the loading of event listeners
38	*/
39	/* ------------------------------------------------------------------------------------------------------------------------- */
40
41	class EventListenersLoader {
42
43	/**
44	Loading event listeners
45	*/
46
47	static addEventsListeners ( ) {
48	document.addEventListener (
49	'additinerarypointmarker',
50	addItineraryPointMarkerEvent => {
51	if ( addItineraryPointMarkerEvent.data ) {
52	theMapEditor.addItineraryPointMarker (
53	addItineraryPointMarkerEvent.data.objId,
54	addItineraryPointMarkerEvent.data.latLng
55	);
56	}
57	}
58	);
59	document.addEventListener (
60	'addrectangle',
61	addRectangleEvent => {
62	if ( addRectangleEvent.data ) {
63	theMapEditor.addRectangle (
64	addRectangleEvent.data.objId,
65	addRectangleEvent.data.bounds,
66	addRectangleEvent.data.properties
67	);
68	}
69	}
70	);
71	document.addEventListener (
72	'addsearchpointmarker',
73	addSearchPointMarkerEvent => {
74	if ( addSearchPointMarkerEvent.data ) {
75	theMapEditor.addSearchPointMarker (
76	addSearchPointMarkerEvent.data.objId,
77	addSearchPointMarkerEvent.data.latLng,
78	addSearchPointMarkerEvent.data.geometry
79	);
80	}
81	}
82	);
83	document.addEventListener (
84	'addwaypoint',
85	addWayPointEvent => {
86	if ( addWayPointEvent.data ) {
87	theMapEditor.addWayPoint (
88	addWayPointEvent.data.wayPoint,
89	addWayPointEvent.data.letter
90	);
91	}
92	}
93	);
94	document.addEventListener (
95	'geolocationpositionchanged',
96	geoLocationPositionChangedEvent => {
97	if ( geoLocationPositionChangedEvent.data ) {
98	theMapEditor.onGeolocationPositionChanged ( geoLocationPositionChangedEvent.data.position );
99	}
100	}
101	);
102	document.addEventListener (
103	'geolocationstatuschanged',
104	geoLocationStatusChangedEvent => {
105	if ( geoLocationStatusChangedEvent.data ) {
106	theMapEditor.onGeolocationStatusChanged ( geoLocationStatusChangedEvent.data.status );
107	}
108	}
109	);
110	document.addEventListener (
111	'layerchange',
112	layerChangeEvent => {
113	if ( layerChangeEvent.data ) {
114	theMapEditor.setLayer ( layerChangeEvent.data.layer );
115	}
116	}
117	);
118	document.addEventListener (
119	'noteupdated',
120	updateNoteEvent => {
121	if ( updateNoteEvent.data ) {
122	theMapEditor.updateNote (
123	updateNoteEvent.data.removedNoteObjId,
124	updateNoteEvent.data.addedNoteObjId
125	);
126	}
127	}
128	);
129	document.addEventListener (
130	'profileclosed',
131	profileClosedEvent => {
132	if ( profileClosedEvent.data ) {
133	theProfileDialogsManager.onProfileClosed ( profileClosedEvent.data.objId );
134	}
135	}
136	);
137	document.addEventListener (
138	'providersadded',
139	( ) => theProvidersToolbar.providersAdded ( )
140	);
141	document.addEventListener (
142	'removeallobjects',
143	( ) => theMapEditor.removeAllObjects ( )
144	);
145	document.addEventListener (
146	'removeobject',
147	removeObjectEvent => {
148	if ( removeObjectEvent.data ) {
149	theMapEditor.removeObject (
150	removeObjectEvent.data.objId
151	);
152	}
153	}
154	);
155	document.addEventListener (
156	'routepropertiesupdated',
157	updateRoutePropertiesEvent => {
158	if ( updateRoutePropertiesEvent.data ) {
159	theMapEditor.updateRouteProperties (
160	updateRoutePropertiesEvent.data.routeObjId
161	);
162	}
163	}
164	);
165	document.addEventListener (
166	'routeupdated',
167	updateRouteEvent => {
168	if ( updateRouteEvent.data ) {
169	theMapEditor.updateRoute (
170	updateRouteEvent.data.removedRouteObjId,
171	updateRouteEvent.data.addedRouteObjId
172	);
173	}
174	}
175	);
176	document.addEventListener (
177	'setprovider',
178	setProviderEvent => {
179	if ( setProviderEvent?.data?.provider ) {
180	theProvidersToolbar.provider = setProviderEvent.data.provider;
181	}
182	}
183	);
184	document.addEventListener (
185	'settransitmode',
186	setTransitModeEvent => {
187	if ( setTransitModeEvent?.data?.transitMode ) {
188	theProvidersToolbar.transitMode = setTransitModeEvent.data.transitMode;
189	}
190	}
191	);
192	document.addEventListener (
193	'showtravelproperties',
194	( ) => theDockableDialogsManager.showTravelProperties ( )
195	);
196	document.addEventListener (
197	'updateosmsearch',
198	( ) => theDockableDialogsManager.osmSearchDialog.updateContent ( )
199	);
200	document.addEventListener (
201	'updateprofilename',
202	updateProfileNameEvent => {
203	if ( updateProfileNameEvent.data ) {
204	theProfileDialogsManager.updateProfileName (
205	updateProfileNameEvent.data.routeObjId
206	);
207	}
208	}
209	);
210	document.addEventListener (
211	'updateroadbook',
212	new RoadbookUpdateEL ( )
213	);
214	document.addEventListener (
215	'updatetravelnotes',
216	( ) => theDockableDialogsManager.travelNotesDialog.updateContent ( )
217	);
218	document.addEventListener (
219	'updatetravelproperties',
220	( ) => theDockableDialogsManager.travelPropertiesDialog.updateContent ( )
221	);
222	document.addEventListener (
223	'zoomto',
224	zoomToEvent => {
225	if ( zoomToEvent.data ) {
226	theMapEditor.zoomTo (
227	zoomToEvent.data.latLng,
228	zoomToEvent.data.geometry
229	);
230	}
231	}
232	);
233	window.visualViewport.addEventListener ( 'resize', new ResizeEL ( ) );
234	}
235
236	/**
237	Loading unload and beforeunload event listeners
238	*/
239
240	static addUnloadEventsListeners ( ) {
241	window.addEventListener ( 'unload', ( ) => localStorage.removeItem ( theTravelNotesData.UUID ) );
242	window.addEventListener (
243	'beforeunload',
244	beforeUnloadEvent => {
245	theIndexedDb.closeDb ( theTravelNotesData.UUID );
246	if ( theConfig.travelNotes.haveBeforeUnloadWarning ) {
247	beforeUnloadEvent.returnValue = 'x';
248	return 'x';
249	}
250	}
251	);
252	}
253	}
254
255	export default EventListenersLoader;
256
257	/* --- End of file --------------------------------------------------------------------------------------------------------- */
258