Debian Codegraph @

tests/android/webview/dom/element.py

raw
1 import logging
2 from collections import defaultdict
3 from functools import wraps
4 from typing import Any, Callable, Dict, Iterable, List, Optional, Union
5
6 from webview.dom import DOMEventHandler, ManipulationMode, _dnd_state
7 from webview.dom.classlist import ClassList
8 from webview.dom.propsdict import DOMPropType, PropsDict
9 from webview.errors import JavascriptException
10 from webview.event import EventContainer
11
12 logger = logging.getLogger('pywebview')
13
14
15 def _ignore_window_document(func):
16 @wraps(func)
17 def wrapper(*args, **kwargs):
18 if args[0]._node_id in ('window', 'document'):
19 return None
20
21 return func(*args, **kwargs)
22
23 return wrapper
24
25
26 def _exists(func):
27 @wraps(func)
28 def wrapper(*args, **kwargs):
29 if not args[0]._exists:
30 logger.warning(f'Element with id {args[0]._node_id} has been removed')
31 return
32
33 try:
34 return func(*args, **kwargs)
35 except JavascriptException as e:
36 if e.args[0].get('cause') == 'ELEMENT_NOT_FOUND':
37 logger.warning(f'Element with id {args[0]._node_id} has been removed')
38 else:
39 logger.exception(e)
40 return
41
42 return wrapper
43
44
45 class Element:
46 def __init__(self, window, node_id) -> None:
47 self._window = window
48 self.events = EventContainer()
49 self._node_id = node_id
50 self._query_command = rf"""
51 var element;
52
53 if ('{self._node_id}' === 'document') {{
54 element = document;
55 }} else if ('{self._node_id}' === 'window') {{
56 element = window;
57 }} else if ('{self._node_id}' === 'body') {{
58 element = document.body;
59 }} else {{
60 element = document.querySelector('[data-pywebview-id="{self._node_id}"]');
61 }}
62
63 if (!element) {{
64 throw new Error('Element with pywebview-id {self._node_id} not found', {{ cause: 'ELEMENT_NOT_FOUND' }});
65 }}
66 """.replace('\n', '')
67 self._event_handlers = defaultdict(list)
68 self._event_handler_ids = {}
69 self._exists = True
70 self._classes = ClassList(self)
71 self._style = PropsDict(self, DOMPropType.Style)
72 self._attributes = PropsDict(self, DOMPropType.Attribute)
73
74 self.__original_display = None
75 self.__generate_events()
76
77 @property
78 @_exists
79 @_ignore_window_document
80 def tag(self) -> str:
81 return self._window.evaluate_js(f'{self._query_command}; element.tagName').lower()
82
83 @property
84 @_exists
85 @_ignore_window_document
86 def id(self) -> Optional[str]:
87 return self._window.evaluate_js(f'{self._query_command}; element.id')
88
89 @id.setter
90 @_exists
91 @_ignore_window_document
92 def id(self, id: str) -> None:
93 self._window.run_js(f"{self._query_command}; element.id = '{id}'")
94
95 @property
96 @_exists
97 @_ignore_window_document
98 def classes(self) -> ClassList:
99 return self._classes
100
101 @classes.setter
102 def classes(self, classes: Iterable) -> None:
103 self._classes = ClassList(self, classes)
104
105 @property
106 @_exists
107 @_ignore_window_document
108 def attributes(self) -> Dict[str, Any]:
109 return self._attributes
110
111 @attributes.setter
112 @_exists
113 @_ignore_window_document
114 def attributes(self, attributes: Dict[str, Any]) -> None:
115 self._attributes = PropsDict(self, DOMPropType.Attribute, attributes)
116
117 @property
118 @_exists
119 def node(self) -> Dict[str, Any]:
120 return self._window.evaluate_js(
121 f'{self._query_command}; var r2 = pywebview._processElements([element])[0]; r2'
122 )
123
124 @property
125 @_exists
126 @_ignore_window_document
127 def style(self) -> Dict[str, Any]:
128 return self._style
129
130 @style.setter
131 @_exists
132 @_ignore_window_document
133 def style(self, style: Dict[str, Any]) -> None:
134 self._style = PropsDict(self, DOMPropType.Style, style)
135
136 @property
137 @_exists
138 @_ignore_window_document
139 def tabindex(self) -> int:
140 return self._window.evaluate_js(f'{self._query_command}; element.tabIndex')
141
142 @tabindex.setter
143 @_exists
144 @_ignore_window_document
145 def tabindex(self, tab_index: int) -> None:
146 self._window.run_js(f'{self._query_command}; element.tabIndex = {tab_index}')
147
148 @property
149 @_exists
150 @_ignore_window_document
151 def text(self) -> str:
152 return self._window.evaluate_js(f'{self._query_command}; element.textContent')
153
154 @text.setter
155 @_exists
156 @_ignore_window_document
157 def text(self, text: str) -> None:
158 self._window.run_js(f"{self._query_command}; element.textContent = '{text}'")
159
160 @property
161 @_exists
162 @_ignore_window_document
163 def value(self) -> str:
164 return self._window.evaluate_js(f'{self._query_command}; element.value')
165
166 @property
167 @_exists
168 @_ignore_window_document
169 def visible(self) -> bool:
170 return self._window.evaluate_js(f'{self._query_command}; element.offsetParent !== null')
171
172 @property
173 @_exists
174 @_ignore_window_document
175 def focused(self) -> bool:
176 return self._window.evaluate_js(
177 f'{self._query_command}; document.activeElement === element'
178 )
179
180 @value.setter
181 @_exists
182 @_ignore_window_document
183 def value(self, value: str) -> None:
184 self._window.run_js(
185 f"{self._query_command}; if ('value' in element) {{ element.value = '{value}' }}"
186 )
187
188 @_exists
189 @_ignore_window_document
190 def blur(self) -> None:
191 self._window.run_js(f'{self._query_command}; element.blur()')
192
193 @_exists
194 @_ignore_window_document
195 def focus(self) -> None:
196 self._window.run_js(f'{self._query_command}; element.focus()')
197
198 @property
199 @_exists
200 @_ignore_window_document
201 def children(self) -> List['Element']:
202 children = self._window.evaluate_js(
203 f"""
204 {self._query_command};
205 var children = element.children;
206 var nodeIds = []
207 for (var i = 0; i < children.length; i++) {{
208 var nodeId = pywebview._getNodeId(children[i]);
209 nodeIds.push(nodeId);
210 }}
211
212 nodeIds
213 """
214 )
215 return [Element(self._window, node_id) for node_id in children]
216
217 @property
218 @_exists
219 @_ignore_window_document
220 def parent(self) -> Union['Element', None]:
221 node_id = self._window.evaluate_js(
222 f"""
223 {self._query_command};
224 var parent = element.parentElement;
225 parent ? pywebview._getNodeId(parent) : null
226 """
227 )
228 return Element(self._window, node_id) if node_id else None
229
230 @property
231 @_exists
232 @_ignore_window_document
233 def next(self) -> Union['Element', None]:
234 node_id = self._window.evaluate_js(
235 f"""
236 {self._query_command};
237 var nextSibling = element.nextElementSibling;
238 nextSibling ? pywebview._getNodeId(nextSibling) : null
239 """
240 )
241 return Element(self._window, node_id) if node_id else None
242
243 @property
244 @_exists
245 @_ignore_window_document
246 def previous(self) -> Union['Element', None]:
247 node_id = self._window.evaluate_js(
248 f"""
249 {self._query_command};
250 var previousSibling = element.previousElementSibling;
251 previousSibling ? pywebview._getNodeId(previousSibling) : null
252 """
253 )
254 return Element(self._window, node_id) if node_id else None
255
256 @_exists
257 @_ignore_window_document
258 def hide(self) -> None:
259 self.__original_display = self._window.evaluate_js(
260 f'{self._query_command}; element.style.display'
261 )
262 self._window.run_js(f"{self._query_command}; element.style.display = 'none'")
263
264 @_exists
265 @_ignore_window_document
266 def show(self) -> None:
267 current_display = self._window.evaluate_js(f'{self._query_command}; element.style.display')
268
269 if current_display == 'none':
270 display = self.__original_display or 'block'
271 self._window.run_js(f"{self._query_command}; element.style.display = '{display}'")
272
273 @_exists
274 @_ignore_window_document
275 def toggle(self) -> None:
276 current_display = self._window.evaluate_js(f'{self._query_command}; element.style.display')
277
278 if current_display == 'none':
279 self.show()
280 else:
281 self.hide()
282
283 @_exists
284 @_ignore_window_document
285 def append(self, html: str, mode=ManipulationMode.LastChild) -> 'Element':
286 return self._window.dom.create_element(html, self, mode)
287
288 @_exists
289 @_ignore_window_document
290 def empty(self) -> None:
291 self._window.run_js(f"{self._query_command}; element.innerHTML = ''")
292
293 @_exists
294 @_ignore_window_document
295 def remove(self) -> None:
296 self._window.run_js(f'{self._query_command}; element.remove()')
297
298 if self._node_id in self._window.dom._elements:
299 self._window.dom._elements.pop(self._node_id)
300
301 handler_ids = ','.join(
302 [f'"{handler_id}"' for handler_id in self._event_handler_ids.values()]
303 )
304 self._window.run_js(
305 f"""
306 var handlerIds = [{handler_ids}];
307 handlerIds.forEach(function(handlerId) {{
308 delete pywebview._eventHandlers[handler_id]
309 }})
310 """
311 )
312 self._event_handler_ids = {}
313 self._event_handlers = defaultdict(list)
314 self._exists = False
315
316 @_exists
317 @_ignore_window_document
318 def copy(
319 self, target: Union[str, 'Element'] = None, mode=ManipulationMode.LastChild, id: str = None
320 ) -> 'Element':
321 if isinstance(target, str):
322 target = self._window.dom.get_element(target)
323 elif target is None:
324 target = self.parent
325
326 if id:
327 id_command = f'newElement.id = "{id}"'
328 else:
329 id_command = 'newElement.removeAttribute("id")'
330
331 node_id = self._window.evaluate_js(
332 f"""
333 {self._query_command};
334 var target = document.querySelector('[data-pywebview-id=\"{target._node_id}\"]');
335 var newElement = element.cloneNode(true);
336 newElement.removeAttribute('data-pywebview-id');
337 {id_command};
338
339 var nodeId = pywebview._getNodeId(newElement);
340 pywebview._insertNode(newElement, target, '{mode.value}')
341 nodeId;
342 """
343 )
344
345 new_element = Element(self._window, node_id)
346 for event, handlers in self._event_handlers.items():
347 for handler in handlers:
348 new_element.on(event, handler)
349
350 return new_element
351
352 @_exists
353 @_ignore_window_document
354 def move(self, target: Union[str, 'Element'], mode=ManipulationMode.LastChild) -> 'Element':
355 if isinstance(target, str):
356 target = self._window.dom.get_element(target)
357
358 self._window.run_js(
359 f"""
360 {self._query_command};
361 var target = document.querySelector('[data-pywebview-id=\"{target._node_id}\"]');
362 pywebview._insertNode(element, target, '{mode.value}')
363 """
364 )
365 return self
366
367 @_exists
368 def on(self, event: str, callback: Union[Callable, DOMEventHandler]) -> None:
369 if self._node_id not in self._window.dom._elements:
370 self._window.dom._elements[self._node_id] = self
371
372 if isinstance(callback, DOMEventHandler):
373 prevent_default = 'e.preventDefault();' if callback.prevent_default else ''
374 stop_propagation = 'e.stopPropagation();' if callback.stop_propagation else ''
375 debounce = callback.debounce
376 callback = callback.callback
377 else:
378 prevent_default = ''
379 stop_propagation = ''
380 debounce = 0
381
382 callback_func = f"window.pywebview._jsApiCallback('pywebviewEventHandler', {{ event: e, nodeId: '{self._node_id}' }}, 'eventHandler')"
383 debounced_func = (
384 f'pywebview._debounce(function() {{ {callback_func} }}, {debounce})'
385 if debounce > 0
386 else callback_func
387 )
388
389 handler_id = self._window.evaluate_js(
390 f"""
391 {self._query_command};
392 var handlerId = null
393
394 if (element) {{
395 handlerId = Math.random().toString(36).substr(2, 11);
396 pywebview._eventHandlers[handlerId] = function(e) {{
397 {prevent_default}
398 {stop_propagation}
399 {debounced_func};
400 }}
401
402 element.addEventListener('{event}', pywebview._eventHandlers[handlerId]);
403 }};
404 handlerId;
405 """
406 )
407
408 if handler_id:
409 self._event_handlers[event].append(callback)
410 self._event_handler_ids[callback] = handler_id
411
412 if event == 'drop':
413 _dnd_state['num_listeners'] += 1
414
415 @_exists
416 def off(self, event: str, callback: Callable) -> None:
417 handler_id = self._event_handler_ids.get(callback)
418
419 if not handler_id:
420 return
421
422 self._window.run_js(
423 f"""
424 {self._query_command};
425 var callback = pywebview._eventHandlers['{handler_id}'];
426 if (element) {{
427 element.removeEventListener('{event}', callback);
428 delete pywebview._eventHandlers['{handler_id}'];
429 }}
430 """
431 )
432
433 del self._event_handler_ids[callback]
434 del self._window.dom._elements[self._node_id]
435
436 for handler in self._event_handlers[event]:
437 if handler == callback:
438 self._event_handlers[event].remove(handler)
439
440 if event == 'drop':
441 _dnd_state['num_listeners'] = max(0, _dnd_state['num_listeners'] - 1)
442
443 @_exists
444 def __generate_events(self):
445 from webview.dom.event import DOMEvent
446
447 events = self._window.evaluate_js(
448 f"""
449 {self._query_command};
450 Object
451 .getOwnPropertyNames(element)
452 .concat(
453 Object.getOwnPropertyNames(
454 Object.getPrototypeOf(
455 Object.getPrototypeOf(element)
456 )
457 )
458 )
459 .filter(function(i){{
460 return !i.indexOf('on') && (element[i] == null || typeof element[i]=='function');
461 }})
462 .map(function(f) {{ return f.substr(2) }});
463 """
464 )
465
466 for event in events:
467 setattr(self.events, event, DOMEvent(event, self))
468
469 @_exists
470 def __str__(self) -> str:
471 return repr(self)
472
473 @_exists
474 def __repr__(self) -> str:
475 if self.node['nodeName'] == '#document':
476 return 'document'
477 elif self.node['nodeName'] == '#window':
478 return 'window'
479 else:
480 return self.node['outerHTML']
481
482 @_exists
483 def __eq__(self, other: 'Element') -> bool:
484 return hasattr(other, '_node_id') and self._node_id == other._node_id