diff options
| author | Peter Bengtsson <mail@peterbe.com> | 2020-12-08 14:41:45 -0500 |
|---|---|---|
| committer | Peter Bengtsson <mail@peterbe.com> | 2020-12-08 14:41:45 -0500 |
| commit | 1109132f09d75da9a28b649c7677bb6ce07c40c0 (patch) | |
| tree | 0dd8b084480983cf9f9680e8aedb92782a921b13 /files/es/web/api/globaleventhandlers | |
| parent | 4b1a9203c547c019fc5398082ae19a3f3d4c3efe (diff) | |
| download | translated-content-1109132f09d75da9a28b649c7677bb6ce07c40c0.tar.gz translated-content-1109132f09d75da9a28b649c7677bb6ce07c40c0.tar.bz2 translated-content-1109132f09d75da9a28b649c7677bb6ce07c40c0.zip | |
initial commit
Diffstat (limited to 'files/es/web/api/globaleventhandlers')
19 files changed, 1806 insertions, 0 deletions
diff --git a/files/es/web/api/globaleventhandlers/index.html b/files/es/web/api/globaleventhandlers/index.html new file mode 100644 index 0000000000..7cc46be5aa --- /dev/null +++ b/files/es/web/api/globaleventhandlers/index.html @@ -0,0 +1,272 @@ +--- +title: GlobalEventHandlers +slug: Web/API/GlobalEventHandlers +tags: + - API + - DOM HTML + - GlobalEventHandlers + - Mixin + - Referencia + - combinación + - eventos +translation_of: Web/API/GlobalEventHandlers +--- +<div>{{ApiRef("DOM HTML")}}</div> + +<p><span class="seoSummary">La combinación («<em>mixin</em>» en inglés) <strong><code>GlobalEventHandlers</code> </strong> describe los controladores de eventos comunes a varias interfaces como {{DOMxRef("HTMLElement")}}, {{DOMxRef("Document")}} o {{DOMxRef("Window")}}.</span> Cada una de estas interfaces puede, por supuesto, agregar más controladores de eventos además de los que se enumeran a continuación.</p> + +<div class="note"> +<p><strong>Nota</strong>: <code>GlobalEventHandlers</code> es una combinación («<em>mixin</em>») y no una interfaz; en realidad, no puedes crear un objeto de tipo <code>GlobalEventHandlers</code>.</p> +</div> + +<h2 id="Propiedades_2">Propiedades</h2> + +<p><em>Esta interfaz no incluye ninguna propiedad excepto los controladores de eventos que se enumeran a continuación.</em></p> + +<h3 id="Controladores_de_eventos">Controladores de eventos</h3> + +<p>Estos controladores de eventos se definen en el mixin {{DOMxRef("GlobalEventHandlers")}} y se implementan mediante {{DOMxRef("HTMLElement")}}, {{DOMxRef("Document")}}, {{DOMxRef("Window ")}}, así como por {{DOMxRef("WorkerGlobalScope")}} para «<em>Web Workers</em>».</p> + +<div id="Propiedades"> +<dl> + <dt>{{DOMxRef("GlobalEventHandlers.onabort")}}</dt> + <dd>Es un {{DOMxRef("EventHandler")}} que representa el código que se llamará cuando se genere el evento {{DOMxRef("HTMLMediaElement/abort_event", "abort")}}.</dd> + <dt>{{DOMxRef("GlobalEventHandlers.onanimationcancel")}} {{Non-standard_inline}}</dt> + <dd>Se llama a {{DOMxRef("EventHandler")}} cuando se envía un evento {{event("animationcancel")}}, lo cual indica que una {{web.link("/s/docs/Web/CSS/CSS_Animations", "animación CSS")}} se ha cancelado.</dd> + <dt>{{DOMxRef("GlobalEventHandlers.onanimationend")}} {{Non-standard_inline}}</dt> + <dd>Se llama a {{DOMxRef("EventHandler")}} cuando se envía un evento {{event("animationend")}}, lo cual indica que {{web.link("/es/docs/Web/CSS/CSS_Animations", "la animación CSS")}} se ha detenido.</dd> + <dt>{{DOMxRef("GlobalEventHandlers.onanimationiteration")}} {{Non-standard_inline}}</dt> + <dd>Un {{DOMxRef("EventHandler")}} llamado cuando se ha enviado un evento {{event("animationiteration")}}, indica que una {{web.link("/es/docs/Web/CSS/CSS_Animations", "animación CSS")}} ha comenzado a reproducir una nueva iteración de la secuencia de animación.</dd> + <dt>{{DOMxRef("GlobalEventHandlers.onanimationstart")}} {{Non-standard_inline}}</dt> + <dd>Se llama a {{DOMxRef("EventHandler")}} cuando se envía un evento {{event("animationstart")}}, lo cual indica que una {{web.link("/es/docs/Web/CSS/CSS_Animations", "animación CSS")}} se ha comenzado a reproducir.</dd> + <dt>{{DOMxRef("GlobalEventHandlers.onauxclick")}} {{Non-standard_inline}}</dt> + <dd>Se llama a {{DOMxRef("EventHandler")}} cuando se envía un evento {{event("auxclick")}}, el cual indica que se ha presionado un botón no principal en un dispositivo de entrada (por ejemplo, un botón central del ratón).</dd> + <dt>{{DOMxRef("GlobalEventHandlers.onblur")}}</dt> + <dd>Es un {{DOMxRef("EventHandler")}} que representa el código que se llamará cuando se genere el evento {{event("blur")}}.</dd> + <dt>{{DOMxRef("GlobalEventHandlers.onerror")}}</dt> + <dd>Es un {{DOMxRef("OnErrorEventHandler")}} que representa el código que se llamará cuando se genere el evento {{event("error")}}.</dd> + <dt>{{DOMxRef("GlobalEventHandlers.onfocus")}}</dt> + <dd>Es un {{DOMxRef("EventHandler")}} que representa el código que se llamará cuando se genere el evento {{event("focus")}}.</dd> + <dt>{{DOMxRef("GlobalEventHandlers.oncancel")}}</dt> + <dd>Es un {{DOMxRef("EventHandler")}} que representa el código que se llamará cuando se genere el evento {{event("cancel")}}.</dd> + <dt>{{DOMxRef("GlobalEventHandlers.oncanplay")}}</dt> + <dd>Es un {{DOMxRef("EventHandler")}} que representa el código que se llamará cuando se genere el evento {{event("canplay")}}.</dd> + <dt>{{DOMxRef("GlobalEventHandlers.oncanplaythrough")}}</dt> + <dd>Es un {{DOMxRef("EventHandler")}} que representa el código que se llamará cuando se genere el evento {{event("canplaythrough")}}.</dd> + <dt>{{DOMxRef("GlobalEventHandlers.onchange")}}</dt> + <dd>Es un {{DOMxRef("EventHandler")}} que representa el código que se llamará cuando se genere el evento {{event("change")}}.</dd> + <dt>{{DOMxRef("GlobalEventHandlers.onclick")}}</dt> + <dd>Es un {{DOMxRef("EventHandler")}} que representa el código que se llamará cuando se genere el evento {{event("click")}}.</dd> + <dt>{{DOMxRef("GlobalEventHandlers.onclose")}}</dt> + <dd>Es un {{DOMxRef("EventHandler")}} que representa el código que se llamará cuando se genere el evento {{event("close")}}.</dd> + <dt>{{DOMxRef("GlobalEventHandlers.oncontextmenu")}}</dt> + <dd>Es un {{DOMxRef("EventHandler")}} que representa el código que se llamará cuando se genere el evento {{event("contextmenu")}}.</dd> + <dt>{{DOMxRef("GlobalEventHandlers.oncuechange")}}</dt> + <dd>Es un {{DOMxRef("EventHandler")}} que representa el código que se llamará cuando se genere el evento {{event("cuechange")}}.</dd> + <dt>{{DOMxRef("GlobalEventHandlers.ondblclick")}}</dt> + <dd>Es un {{DOMxRef("EventHandler")}} que representa el código que se llamará cuando se genere el evento {{event("dblclick")}}.</dd> + <dt>{{DOMxRef("GlobalEventHandlers.ondrag")}}</dt> + <dd>Es un {{DOMxRef("EventHandler")}} que representa el código que se llamará cuando se genere el evento {{event("drag")}}.</dd> + <dt>{{DOMxRef("GlobalEventHandlers.ondragend")}}</dt> + <dd>Es un {{DOMxRef("EventHandler")}} que representa el código que se llamará cuando se genere el evento {{event("dragend")}}.</dd> + <dt>{{DOMxRef("GlobalEventHandlers.ondragenter")}}</dt> + <dd>Es un {{DOMxRef("EventHandler")}} que representa el código que se llamará cuando se genere el evento {{event("dragenter")}}.</dd> + <dt>{{DOMxRef("GlobalEventHandlers.ondragexit")}}</dt> + <dd>Es un {{DOMxRef("EventHandler")}} que representa el código que se llamará cuando se genere el evento {{event("dragexit")}}.</dd> + <dt>{{DOMxRef("GlobalEventHandlers.ondragleave")}}</dt> + <dd>Es un {{DOMxRef("EventHandler")}} que representa el código que se llamará cuando se genere el evento {{event("dragleave")}}.</dd> + <dt>{{DOMxRef("GlobalEventHandlers.ondragover")}}</dt> + <dd>Es un {{DOMxRef("EventHandler")}} que representa el código que se llamará cuando se genere el evento {{event("dragover")}}.</dd> + <dt>{{DOMxRef("GlobalEventHandlers.ondragstart")}}</dt> + <dd>Es un {{DOMxRef("EventHandler")}} que representa el código que se llamará cuando se genere el evento {{event("dragstart")}}.</dd> + <dt>{{DOMxRef("GlobalEventHandlers.ondrop")}}</dt> + <dd>Es un {{DOMxRef("EventHandler")}} que representa el código que se llamará cuando se genere el evento {{event("drop")}}.</dd> + <dt>{{DOMxRef("GlobalEventHandlers.ondurationchange")}}</dt> + <dd>Es un {{DOMxRef("EventHandler")}} que representa el código que se llamará cuando se genere el evento {{event("durationchange")}}.</dd> + <dt>{{DOMxRef("GlobalEventHandlers.onemptied")}}</dt> + <dd>Es un {{DOMxRef("EventHandler")}} que representa el código que se llamará cuando se genere el evento {{event("emptied")}}.</dd> + <dt>{{DOMxRef("GlobalEventHandlers.onended")}}</dt> + <dd>Es un {{DOMxRef("EventHandler")}} que representa el código que se llamará cuando se genere el evento {{event("ended")}}.</dd> + <dt>{{DOMxRef("GlobalEventHandlers.onformdata")}}</dt> + <dd>Es un {{DOMxRef("EventHandler")}} para procesar eventos {{event("formdata")}}, que se activa después de que se construye la lista de entrada que representa los datos del formulario.</dd> + <dt>{{DOMxRef("GlobalEventHandlers.ongotpointercapture")}}</dt> + <dd>Es un {{DOMxRef("EventHandler")}} que representa el código que se llamará cuando se genere el tipo de evento {{event("gotpointercapture")}}.</dd> + <dt>{{DOMxRef("GlobalEventHandlers.oninput")}}</dt> + <dd>Es un {{DOMxRef("EventHandler")}} que representa el código que se llamará cuando se genere el evento {{event("input")}}.</dd> + <dt>{{DOMxRef("GlobalEventHandlers.oninvalid")}}</dt> + <dd>Es un {{DOMxRef("EventHandler")}} que representa el código que se llamará cuando se genere el evento {{event("invalid")}}.</dd> + <dt>{{DOMxRef("GlobalEventHandlers.onkeydown")}}</dt> + <dd>Es un {{DOMxRef("EventHandler")}} que representa el código que se llamará cuando se genere el evento {{event("keydown")}}.</dd> + <dt>{{DOMxRef("GlobalEventHandlers.onkeypress")}}</dt> + <dd>Es un {{DOMxRef("EventHandler")}} que representa el código que se llamará cuando se genere el evento {{event("keypress")}}.</dd> + <dt>{{DOMxRef("GlobalEventHandlers.onkeyup")}}</dt> + <dd>Es un {{DOMxRef("EventHandler")}} que representa el código que se llamará cuando se genere el evento {{event("keyup")}}.</dd> + <dt>{{DOMxRef("GlobalEventHandlers.onload")}}</dt> + <dd>Is an {{domxref("EventHandler")}} representing the code to be called when the {{event("load")}} event is raised.</dd> + <dt>{{DOMxRef("GlobalEventHandlers.onloadeddata")}}</dt> + <dd>Es un {{DOMxRef("EventHandler")}} que representa el código que se llamará cuando se genere el evento {{event("loadeddata ")}}.</dd> + <dt>{{DOMxRef("GlobalEventHandlers.onloadedmetadata")}}</dt> + <dd>Es un {{DOMxRef("EventHandler")}} que representa el código que se llamará cuando se genere el evento {{event("loadedmetadata")}}.</dd> + <dt>{{DOMxRef("GlobalEventHandlers.onloadend")}}</dt> + <dd>Es un {{DOMxRef("EventHandler")}} que representa el código que se llamará cuando se genere el evento {{event("loadend")}} (cuando el progreso se haya detenido en la carga de un recurso).</dd> + <dt>{{DOMxRef("GlobalEventHandlers.onloadstart")}}</dt> + <dd>Es un {{DOMxRef("EventHandler")}} que representa el código que se llamará cuando se genere el evento {{event("loadstart")}} (cuando el progreso ha comenzado a cargar un recurso).</dd> + <dt>{{DOMxRef("GlobalEventHandlers.onlostpointercapture")}}</dt> + <dd>Es un {{DOMxRef("EventHandler")}} que representa el código que se llamará cuando se genere el tipo de evento {{event("lostpointercapture")}}.</dd> + <dt>{{DOMxRef("GlobalEventHandlers.onmousedown")}}</dt> + <dd>Es un {{DOMxRef("EventHandler")}} que representa el código que se llamará cuando se genere el evento {{event("mousedown")}}.</dd> + <dt>{{DOMxRef("GlobalEventHandlers.onmouseenter")}}</dt> + <dd>Es un {{DOMxRef("EventHandler")}} que representa el código que se llamará cuando se genere el evento {{event("mouseenter")}}.</dd> + <dt>{{DOMxRef("GlobalEventHandlers.onmouseleave")}}</dt> + <dd>Es un {{DOMxRef("EventHandler")}} que representa el código que se llamará cuando se genere el evento {{event("mouseleave")}}.</dd> + <dt>{{DOMxRef("GlobalEventHandlers.onmousemove")}}</dt> + <dd>Es un {{DOMxRef("EventHandler")}} que representa el código que se llamará cuando se genere el evento {{event("mousemove")}}.</dd> + <dt>{{DOMxRef("GlobalEventHandlers.onmouseout")}}</dt> + <dd>Es un {{DOMxRef("EventHandler")}} que representa el código que se llamará cuando se genere el evento {{event("mouseout")}}.</dd> + <dt>{{DOMxRef("GlobalEventHandlers.onmouseover")}}</dt> + <dd>Es un {{DOMxRef("EventHandler")}} que representa el código que se llamará cuando se genere el evento {{event("mouseover")}}.</dd> + <dt>{{DOMxRef("GlobalEventHandlers.onmouseup")}}</dt> + <dd>Es un {{DOMxRef("EventHandler")}} que representa el código que se llamará cuando se genere el evento {{event("mouseup")}}.</dd> + <dt>{{DOMxRef("GlobalEventHandlers.onmousewheel")}} {{Non-standard_inline}} {{Deprecated_inline}}</dt> + <dd>Es un {{DOMxRef("EventHandler")}} que representa el código que se llamará cuando se genere el evento {{event("mousewheel")}}. Desaprobado. Utiliza <code>onwheel</code> en su lugar.</dd> + <dt>{{DOMxRef("GlobalEventHandlers.onwheel")}}</dt> + <dd>Es un {{DOMxRef("EventHandler")}} que representa el código que se llamará cuando se genere el evento {{event("wheel")}}.</dd> + <dt>{{DOMxRef("GlobalEventHandlers.onpause")}}</dt> + <dd>Es un {{DOMxRef("EventHandler")}} que representa el código que se llamará cuando se genere el evento {{event("pause")}}.</dd> + <dt>{{DOMxRef("GlobalEventHandlers.onplay")}}</dt> + <dd>Es un {{DOMxRef("EventHandler")}} que representa el código que se llamará cuando se genere el evento {{event("play")}}.</dd> + <dt>{{DOMxRef("GlobalEventHandlers.onplaying")}}</dt> + <dd>Es un {{DOMxRef("EventHandler")}} que representa el código que se llamará cuando se genere el evento {{event("playing")}}.</dd> + <dt>{{DOMxRef("GlobalEventHandlers.onpointerdown")}}</dt> + <dd>Es un {{DOMxRef("EventHandler")}} que representa el código que se llamará cuando se genere el evento {{event("pointerdown")}}.</dd> + <dt>{{DOMxRef("GlobalEventHandlers.onpointermove")}}</dt> + <dd>Es un {{DOMxRef("EventHandler")}} que representa el código que se llamará cuando se genere el evento {{event("pointermove")}}.</dd> + <dt>{{DOMxRef("GlobalEventHandlers.onpointerup")}}</dt> + <dd>Es un {{DOMxRef("EventHandler")}} que representa el código que se llamará cuando se genere el evento {{event("pointerup")}}.</dd> + <dt>{{DOMxRef("GlobalEventHandlers.onpointercancel")}}</dt> + <dd>Es un {{DOMxRef("EventHandler")}} que representa el código que se llamará cuando se genere el evento {{event("pointercancel")}}.</dd> + <dt>{{DOMxRef("GlobalEventHandlers.onpointerover")}}</dt> + <dd>Es un {{DOMxRef("EventHandler")}} que representa el código que se llamará cuando se genere el evento {{event("pointerover")}}.</dd> + <dt>{{DOMxRef("GlobalEventHandlers.onpointerout")}}</dt> + <dd>Es un {{DOMxRef("EventHandler")}} que representa el código que se llamará cuando se genere el evento {{event("pointerout")}}.</dd> + <dt>{{DOMxRef("GlobalEventHandlers.onpointerenter")}}</dt> + <dd>Es un {{DOMxRef("EventHandler")}} que representa el código que se llamará cuando se genere el evento {{event("pointerenter")}}.</dd> + <dt>{{DOMxRef("GlobalEventHandlers.onpointerleave")}}</dt> + <dd>Es un {{DOMxRef("EventHandler")}} que representa el código que se llamará cuando se genere el evento {{event("pointerleave")}}.</dd> + <dt>{{DOMxRef("GlobalEventHandlers.onpointerlockchange")}} {{experimental_inline}}</dt> + <dd>Es un {{DOMxRef("EventHandler")}} que representa el código que se llamará cuando se genere el evento {{event("pointerlockchange")}}.</dd> + <dt>{{DOMxRef("GlobalEventHandlers.onpointerlockerror")}} {{experimental_inline}}</dt> + <dd>Es un {{DOMxRef("EventHandler")}} que representa el código que se llamará cuando se genere el evento {{event("pointerlockerror")}}.</dd> + <dt>{{DOMxRef("GlobalEventHandlers.onprogress")}}</dt> + <dd>Es un {{DOMxRef("EventHandler")}} que representa el código que se llamará cuando se genere el evento {{event("progress")}}.</dd> + <dt>{{DOMxRef("GlobalEventHandlers.onratechange")}}</dt> + <dd>Es un {{DOMxRef("EventHandler")}} que representa el código que se llamará cuando se genere el evento {{event("ratechange")}}.</dd> + <dt>{{DOMxRef("GlobalEventHandlers.onreset")}}</dt> + <dd>Es un {{DOMxRef("EventHandler")}} que representa el código que se llamará cuando se genere el evento {{event("reset")}}.</dd> + <dt>{{DOMxRef("GlobalEventHandlers.onresize")}}</dt> + <dd>Es un {{DOMxRef("EventHandler")}} que representa el código que se llamará cuando se genere el evento {{event("resize")}}.</dd> + <dt>{{DOMxRef("GlobalEventHandlers.onscroll")}}</dt> + <dd>Es un {{DOMxRef("EventHandler")}} que representa el código que se llamará cuando se genere el evento {{event("scroll")}}.</dd> + <dt>{{DOMxRef("GlobalEventHandlers.onseeked")}}</dt> + <dd>Es un {{DOMxRef("EventHandler")}} que representa el código que se llamará cuando se genere el evento {{event("seeked")}}.</dd> + <dt>{{DOMxRef("GlobalEventHandlers.onseeking")}}</dt> + <dd>Es un {{DOMxRef("EventHandler")}} que representa el código que se llamará cuando se genere el evento {{event("seek")}}.</dd> + <dt>{{DOMxRef("GlobalEventHandlers.onselect")}}</dt> + <dd>Es un {{DOMxRef("EventHandler")}} que representa el código que se llamará cuando se genere el evento {{event("select")}}.</dd> + <dt>{{DOMxRef("GlobalEventHandlers.onselectstart")}}</dt> + <dd>Es un {{DOMxRef("EventHandler")}} que representa el código que se llamará cuando se genere el evento {{event("selectionchange")}}, es decir, cuando el usuario comience a realizar una nueva selección de texto en una página web.</dd> + <dt>{{DOMxRef("GlobalEventHandlers.onselectionchange")}}</dt> + <dd>Es un {{DOMxRef("EventHandler")}} que representa el código que se llamará cuando se genera el evento {{event("selectionchange")}}, es decir, cuando cambia el texto seleccionado en una página web.</dd> + <dt>{{DOMxRef("GlobalEventHandlers.onshow")}}</dt> + <dd>Es un {{DOMxRef("EventHandler")}} que representa el código que se llamará cuando se genere el evento {{event("show")}}.</dd> + <dt>{{DOMxRef("GlobalEventHandlers.onsort")}} {{experimental_inline}}</dt> + <dd>Es un {{DOMxRef("EventHandler")}} que representa el código que se llamará cuando se genere el evento {{event("sort")}}.</dd> + <dt>{{DOMxRef("GlobalEventHandlers.onstalled")}}</dt> + <dd>Es un {{DOMxRef("EventHandler")}} que representa el código que se llamará cuando se genere el evento {{event("stalled")}}.</dd> + <dt>{{DOMxRef("GlobalEventHandlers.onsubmit")}}</dt> + <dd>Es un {{DOMxRef("EventHandler")}} que representa el código que se llamará cuando se genere el evento {{event("submit")}}.</dd> + <dt>{{DOMxRef("GlobalEventHandlers.onsuspend")}}</dt> + <dd>Es un {{DOMxRef("EventHandler")}} que representa el código que se llamará cuando se genere el evento {{event("suspend")}}.</dd> + <dt>{{DOMxRef("GlobalEventHandlers.ontimeupdate")}}</dt> + <dd>Es un {{DOMxRef("EventHandler")}} que representa el código que se llamará cuando se genere el evento {{event("timeupdate")}}.</dd> + <dt>{{DOMxRef("GlobalEventHandlers.onvolumechange")}}</dt> + <dd>Es un {{DOMxRef("EventHandler")}} que representa el código que se llamará cuando se genere el evento {{event("volumechange")}}.</dd> + <dt>{{DOMxRef("GlobalEventHandlers.ontouchcancel")}} {{Non-standard_inline}} {{Experimental_inline}}</dt> + <dd>Es un {{DOMxRef("EventHandler")}} que representa el código que se llamará cuando se genere el evento {{event("touchcancel")}}.</dd> + <dt>{{DOMxRef("GlobalEventHandlers.ontouchend")}} {{Non-standard_inline}} {{Experimental_inline}}</dt> + <dd>Es un {{DOMxRef("EventHandler")}} que representa el código que se llamará cuando se genere el evento {{event("touchend")}}.</dd> + <dt>{{DOMxRef("GlobalEventHandlers.ontouchmove")}} {{Non-standard_inline}} {{Experimental_inline}}</dt> + <dd>Es un {{DOMxRef("EventHandler")}} que representa el código que se llamará cuando se genere el evento {{event("touchmove")}}.</dd> + <dt>{{DOMxRef("GlobalEventHandlers.ontouchstart")}} {{Non-standard_inline}} {{Experimental_inline}}</dt> + <dd>Es un {{DOMxRef("EventHandler")}} que representa el código que se llamará cuando se genere el evento {{event("touchstart")}}.</dd> + <dt>{{DOMxRef("GlobalEventHandlers.ontransitioncancel")}}</dt> + <dd>Se llama a {{DOMxRef("EventHandler")}} cuando se envía un evento {{event("transitioncancel")}}, lo cual indica que {{web.link("/es/docs/Web/CSS/CSS_Transitions", "se canceló la transición CSS")}}.</dd> + <dt>{{DOMxRef("GlobalEventHandlers.ontransitionend")}}</dt> + <dd>Se llama a {{DOMxRef("EventHandler")}} cuando se envía un evento {{event("transitionend")}}, lo cual indica que {{web.link("/es/docs/Web/CSS/CSS_Transitions", "la transición CSS")}} se ha terminado de reproducir.</dd> + <dt>{{DOMxRef("GlobalEventHandlers.ontransitionrun")}}</dt> + <dd>Se llama a {{DOMxRef("EventHandler")}} cuando se envía un evento {{event("transitionrun")}}, lo cual indica que {{web.link("/es/docs/Web/CSS/CSS_Transitions", "la transición CSS")}} se está ejecutando, aunque no necesariamente se inició.</dd> + <dt>{{DOMxRef("GlobalEventHandlers.ontransitionstart")}}</dt> + <dd>Se llama a {{DOMxRef("EventHandler")}} cuando se envía un evento {{event("transitionstart")}}, lo cual indica que {{web.link("/es/docs/Web/CSS/CSS_Transitions", "la transición CSS")}} ha comenzado a realizar la transición.</dd> + <dt>{{DOMxRef("GlobalEventHandlers.onwaiting")}}</dt> + <dd>Es un {{DOMxRef("EventHandler")}} que representa el código que se llamará cuando se genere el evento {{event("waiting")}}.</dd> +</dl> +</div> + +<h2 id="Métodos">Métodos</h2> + +<p><em>Esta interfaz no define métodos</em></p> + +<h2 id="Especificaciones">Especificaciones</h2> + +<table class="standard-table"> + <thead> + <tr> + <th scope="col">Especificación</th> + <th scope="col">Estado</th> + <th scope="col">Comentario</th> + </tr> + </thead> + <tbody> + <tr> + <td>{{SpecName("Selection API",'', 'Extensión a GlobalEventHandlers')}}</td> + <td>{{Spec2('Selection API')}}</td> + <td>Agrega <code>en el cambio de selección.</code></td> + </tr> + <tr> + <td>{{SpecName('Pointer Lock', '#extensions-to-the-document-interface', 'Extensión de Document')}}</td> + <td>{{Spec2('Pointer Lock')}}</td> + <td>Agrega <code>onpointerlockchange</code> y <code>onpointerlockerror</code> en {{DOMxRef("Document")}}. Está implementado experimentalmente en <code>GlobalEventHandlers</code>.</td> + </tr> + <tr> + <td>{{SpecName('HTML WHATWG', '#globaleventhandlers', 'GlobalEventHandlers')}}</td> + <td>{{ Spec2('HTML WHATWG') }}</td> + <td>Sin cambios desde la última instantánea, {{SpecName("HTML5.1")}}.</td> + </tr> + <tr> + <td>{{SpecName('HTML5.1', '#globaleventhandlers', 'GlobalEventHandlers')}}</td> + <td>{{Spec2('HTML5.1')}}</td> + <td>Instantánea de {{SpecName("HTML WHATWG")}}. Agregó <code>onsort</code> desde la instantánea de {{SpecName("HTML5 W3C")}}.</td> + </tr> + <tr> + <td>{{SpecName("HTML5 W3C", "#globaleventhandlers", "GlobalEventHandlers")}}</td> + <td>{{ Spec2('HTML5 W3C') }}</td> + <td>Instantánea de {{SpecName("HTML WHATWG")}}. Creación de <code>GlobalEventHandlers</code> (propiedades en el destino anterior).</td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilidad_del_navegador">Compatibilidad del navegador</h2> + +<div> +<div class="hidden">La tabla de compatibilidad de esta página se genera a partir de datos estructurados. Si deseas contribuir con los datos, consulta <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a> y envíanos una solicitud de extracción.</div> + +<p>{{Compat("api.GlobalEventHandlers")}}</p> +</div> + +<h2 id="Ve_también">Ve también</h2> + +<ul> + <li>{{DOMxRef("Element")}}</li> + <li>{{DOMxRef("EventHandler")}}</li> + <li>{{DOMxRef("Event")}}</li> +</ul> diff --git a/files/es/web/api/globaleventhandlers/onblur/index.html b/files/es/web/api/globaleventhandlers/onblur/index.html new file mode 100644 index 0000000000..204cce4ab1 --- /dev/null +++ b/files/es/web/api/globaleventhandlers/onblur/index.html @@ -0,0 +1,90 @@ +--- +title: GlobalEventHandlers.onblur +slug: Web/API/GlobalEventHandlers/onblur +translation_of: Web/API/GlobalEventHandlers/onblur +--- +<div>{{ApiRef("HTML DOM")}}</div> + +<p>La propiedad <strong>onblur</strong> retorna el código del manejador de evento onBlur, si existe, en el elemento actual.</p> + +<h2 id="Sintaxis">Sintaxis</h2> + +<pre class="syntaxbox">element.onblur = function; +</pre> + +<ul> + <li><code>function</code> es el nombre de una función definida por el usuario, sin el sufijo () ni ningún parámetro, o una declaración de función anónima, como:</li> +</ul> + +<pre class="syntaxbox">element.onblur = function() { console.log("¡evento onblur detectado!"); }; +</pre> + +<h2 id="Ejemplo">Ejemplo</h2> + +<pre class="brush: html"><html> + +<head> +<title>ejemplo de evento onblur</title> + +<script type="text/javascript"> + +var elem = null; + +function initElement() +{ + elem = document.getElementById("foo"); + // NOTA: doEvent(); ó doEvent(param); no funcionará aquí. + // Debe ser una referencia a un nombre de función, no una llamada a función. + elem.onblur = doEvent; +}; + +function doEvent() +{ + elem.value = 'Bye-Bye'; + console.log("¡Evento onblur detectado!") +} +</script> + +<style type="text/css"> +<!-- +#foo { +border: solid blue 2px; +} +--> +</style> +</head> + +<body onload="initElement();"> +<form> +<input type="text" id="foo" value="Hola!" /> +</form> + +<p>Haga click en el elemento superior to darle el foco, luego click fuera del elemento.<br /> +Recarge la página desde la barra de navegación.</p> + +</body> +</html> +</pre> + +<h2 id="Notas">Notas</h2> + +<p>El evento blur es generado cuando un elemento pierde el foco.</p> + +<p>A diferencia de MSIE --en el cual la mayoría de tipos de elementos reciben el evento blur-- la mayoría de elementos de los navegadores basados en Gecko NO funcionan con este evento.</p> + +<h2 id="Especificación">Especificación</h2> + +<table class="spectable standard-table"> + <tbody> + <tr> + <th scope="col">Especificación</th> + <th scope="col">Estado</th> + <th scope="col">Observaciones</th> + </tr> + <tr> + <td>{{SpecName('HTML WHATWG','webappapis.html#handler-onblur','onblur')}}</td> + <td>{{Spec2('HTML WHATWG')}}</td> + <td> </td> + </tr> + </tbody> +</table> diff --git a/files/es/web/api/globaleventhandlers/onchange/index.html b/files/es/web/api/globaleventhandlers/onchange/index.html new file mode 100644 index 0000000000..a51f7d25d8 --- /dev/null +++ b/files/es/web/api/globaleventhandlers/onchange/index.html @@ -0,0 +1,97 @@ +--- +title: GlobalEventHandlers.onchange +slug: Web/API/GlobalEventHandlers/onchange +translation_of: Web/API/GlobalEventHandlers/onchange +--- +<div> +<div>{{ ApiRef("HTML DOM") }}</div> +</div> + +<p>La propiedad <code>onchange</code> establece y devuelve el <a href="/docs/Web/Guide/Events/Event_handlers" title="/en-US/docs/Web/Guide/DOM/Events/Event_handlers">event handler</a> para el evento {{event("change")}}.</p> + +<h2 id="Syntax" name="Syntax">Sintaxis</h2> + +<pre class="syntaxbox"><em><var>element</var></em>.onchange = <em>handlerFunction</em>; +var <em>handlerFunction</em> = <em><var>element</var></em>.onchange; +</pre> + +<p><code><em>handlerFunction</em></code> debería ser <em>null</em> o una <a href="/en-US/docs/Web/JavaScript/Reference/Functions" title="/en-US/docs/JavaScript/Reference/Functions_and_function_scope">Función de javascript</a> espeficiando el manejador para el evento.</p> + +<h2 id="Notes" name="Notes">Notas</h2> + +<p>Mir el la págna <a href="/en-US/docs/Web/Guide/Events/Event_handlers" title="/en-US/docs/Web/Guide/DOM/Events/Event_handlers">Manejadores de eventos DOM</a> para más información sobre cómo trabajar con los manejadore <code>on</code>.</p> + +<p>Mira la documentación para el evento {{event("change")}}.</p> + +<h2 id="Specification" name="Specification">Especificaciones</h2> + +<table class="spectable standard-table"> + <tbody> + <tr> + <th scope="col">Especificación</th> + <th scope="col">Estatus</th> + <th scope="col">Comentario</th> + </tr> + <tr> + <td>{{SpecName('HTML WHATWG','webappapis.html#handler-onchange','onchange')}}</td> + <td>{{Spec2('HTML WHATWG')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilidad_de_navegadores">Compatibilidad de navegadores</h2> + +<div>{{CompatibilityTable}}</div> + +<div id="compat-desktop"> +<table class="compat-table"> + <tbody> + <tr> + <th>Feature</th> + <th>Chrome</th> + <th>Firefox (Gecko)</th> + <th>Internet Explorer</th> + <th>Opera</th> + <th>Safari (WebKit)</th> + </tr> + <tr> + <td>Soporte báico</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatUnknown}}</td> + </tr> + </tbody> +</table> +</div> + +<div id="compat-mobile"> +<table class="compat-table"> + <tbody> + <tr> + <th>Feature</th> + <th>Android</th> + <th>Android Webview</th> + <th>Chrome for Android</th> + <th>Firefox Mobile (Gecko)</th> + <th>Firefox OS</th> + <th>IE Mobile</th> + <th>Opera Mobile</th> + <th>Safari Mobile</th> + </tr> + <tr> + <td>Soporte básico</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatUnknown}}</td> + </tr> + </tbody> +</table> +</div> diff --git a/files/es/web/api/globaleventhandlers/onclick/index.html b/files/es/web/api/globaleventhandlers/onclick/index.html new file mode 100644 index 0000000000..62d6c622ec --- /dev/null +++ b/files/es/web/api/globaleventhandlers/onclick/index.html @@ -0,0 +1,139 @@ +--- +title: GlobalEventHandlers.onclick +slug: Web/API/GlobalEventHandlers/onclick +translation_of: Web/API/GlobalEventHandlers/onclick +--- +<div> +<div>{{ ApiRef("HTML DOM") }}</div> +</div> + +<div></div> + +<p>La propiedad <strong>onclick</strong> devuelve el manejador del evento <code>click</code> del elemento actual.</p> + +<div class="note"><strong>Note:</strong> Cuando uses el evento <code>click</code> para ejecutar algo, considera agregar la misma acción al evento <code>keydown</code>, para permitirle el uso a personas que no usan mouse o pantalla táctil.</div> + +<h2 id="Syntax" name="Syntax">Sintaxis</h2> + +<pre class="syntaxbox"><var>element</var>.onclick = <var>functionRef</var>; +</pre> + +<p>Donde <em>functionRef</em> es una función - muchas veces el nombre de la función está declarado ya en otro sitio o como una <em>expresión de la función</em> .Ver "<a href="/en-US/docs/JavaScript/Guide/Functions">JavaScript Guide:Functions</a>" para más detalles.</p> + +<p>el único argumento pasado a la función manejador de evento especificamente {{domxref("MouseEvent")}} object. Dentro del manejador, <code>this</code> será el elemento sobre él el evento ha sido invocado.</p> + +<h2 id="Example" name="Example">Ejemplo</h2> + +<pre class="brush:html"><!DOCTYPE html> +<html lang="en"> + <head> + <meta charset="UTF-8" /> + <title>onclick event example</title> + <script> + function initElement() { + var p = document.getElementById("foo"); + // NOTE: showAlert(); or showAlert(param); will NOT work here. + // Must be a reference to a function name, not a function call. + p.onclick = showAlert; + }; + + function showAlert(event) { + alert("onclick Event detected!"); + } + </script> + <style> + #foo { + border: solid blue 2px; + } + </style> + </head> + <body onload="initElement();"> + <span id="foo">My Event Element</span> + <p>click on the above element.</p> + </body> +</html> +</pre> + +<p>O se puede usar una función anoníma, como esa:</p> + +<pre class="brush:js">p.onclick = function(event) { alert("moot!"); }; +</pre> + +<h2 id="Notes" name="Notes">Notas</h2> + +<p>El evento <code>click</code> se genera cuando el usuario hace clic en un elemento. El evento clic ocurrirá después de los eventos <code>mousedown</code> y <code>mouseup</code>.</p> + +<p>Solo se puede asignar un controlador <code>click</code> a un objeto a la vez con esta propiedad. Puede que prefiera utilizar el método {{domxref ("EventTarget.addEventListener()")}} en su lugar, ya que es más flexible y forma parte de la especificación DOM Events.</p> + +<h2 id="Specification" name="Specification">Especificación</h2> + +<table class="spectable standard-table"> + <tbody> + <tr> + <th scope="col">Especificación</th> + <th scope="col">Estatus</th> + <th scope="col">Comentario</th> + </tr> + <tr> + <td>{{SpecName('HTML WHATWG','webappapis.html#handler-onclick','onclick')}}</td> + <td>{{Spec2('HTML WHATWG')}}</td> + <td></td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilidad_de_Navegadores">Compatibilidad de Navegadores</h2> + +<div>{{CompatibilityTable}}</div> + +<div id="compat-desktop"> +<table class="compat-table"> + <tbody> + <tr> + <th>Feature</th> + <th>Chrome</th> + <th>Firefox (Gecko)</th> + <th>Internet Explorer</th> + <th>Opera</th> + <th>Safari (WebKit)</th> + </tr> + <tr> + <td>Soporte básico</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatUnknown}}</td> + </tr> + </tbody> +</table> +</div> + +<div id="compat-mobile"> +<table class="compat-table"> + <tbody> + <tr> + <th>Feature</th> + <th>Android</th> + <th>Android Webview</th> + <th>Chrome for Android</th> + <th>Firefox Mobile (Gecko)</th> + <th>Firefox OS</th> + <th>IE Mobile</th> + <th>Opera Mobile</th> + <th>Safari Mobile</th> + </tr> + <tr> + <td>Soporte básico</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatUnknown}}</td> + </tr> + </tbody> +</table> +</div> diff --git a/files/es/web/api/globaleventhandlers/onclose/index.html b/files/es/web/api/globaleventhandlers/onclose/index.html new file mode 100644 index 0000000000..20ddb639f5 --- /dev/null +++ b/files/es/web/api/globaleventhandlers/onclose/index.html @@ -0,0 +1,52 @@ +--- +title: GlobalEventHandlers.onclose +slug: Web/API/GlobalEventHandlers/onclose +tags: + - Propiedad + - Referencia +translation_of: Web/API/GlobalEventHandlers/onclose +--- +<div>{{ApiRef("HTML DOM")}}</div> + +<p>Un gestor de eventos para los eventos de cerrar enviados a la ventana. (No disponible con Firefox 2 o Safari)</p> + +<h2 id="Sintaxis">Sintaxis</h2> + +<pre class="syntaxbox">window.onclose = funcRef; +</pre> + +<h3 id="Parámetros">Parámetros</h3> + +<ul> + <li><code>funcRef</code> es una referencia a una función.</li> +</ul> + +<h2 id="Ejemplo">Ejemplo</h2> + +<pre class="brush: js">window.onclose = resetThatServerThing; +</pre> + +<h2 id="Especificaciones">Especificaciones</h2> + +<table class="spectable standard-table"> + <tbody> + <tr> + <th scope="col">Especificación</th> + <th scope="col">Estado</th> + <th scope="col">Comentario</th> + </tr> + <tr> + <td>{{SpecName('HTML WHATWG','webappapis.html#handler-onclose','onclose')}}</td> + <td>{{Spec2('HTML WHATWG')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilidad_con_Navegadores">Compatibilidad con Navegadores</h2> + +<div> +<div class="hidden">La tabla de compatibilidad en esta pagina es generada de datos estructurados. Si te gustaría contribuir a los datos, por favor haz check out de <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a> y envianos una petición pull.</div> + +<p>{{Compat("api.GlobalEventHandlers.onclose")}}</p> +</div> diff --git a/files/es/web/api/globaleventhandlers/onerror/index.html b/files/es/web/api/globaleventhandlers/onerror/index.html new file mode 100644 index 0000000000..44c921b4ad --- /dev/null +++ b/files/es/web/api/globaleventhandlers/onerror/index.html @@ -0,0 +1,65 @@ +--- +title: GlobalEventHandlers.onerror +slug: Web/API/GlobalEventHandlers/onerror +translation_of: Web/API/GlobalEventHandlers/onerror +--- +<div>{{ ApiRef("HTML DOM") }}</div> + +<p>Un manejador de eventos para errores en scripts en tiempo de ejecución.</p> + +<p>Note that some/many <code>error</code> events do not trigger <code>window.onerror</code>, you have to listen for them specifically.</p> + +<h2 id="Syntax" name="Syntax">Sintaxis</h2> + +<pre>window.onerror = funcRef; +</pre> + +<h3 id="Parameters" name="Parameters">Parámetros</h3> + +<ul> + <li><code>funcRef</code> es una referencia a una función. Cuando la función devuelva <code>true</code>, se prevendrá el disparado del manejador de eventos por defecto. Parámetros de la función: + + <ul> + <li>Mensaje de error (string)</li> + <li>Url en la que el error fue lanzado (string)</li> + <li>Número de línea en la que el error fue lanzado (number)</li> + <li>Dentro de la línea en la que el error ocurrió, número de columna correspondiente (number) {{gecko_minversion_inline("31.0")}}</li> + <li><a href="/en-US/docs/Web/JavaScript/Reference/Global_Objects/Error">Error Object</a> (object) {{gecko_minversion_inline("31.0")}}</li> + </ul> + </li> +</ul> + +<h2 id="Example" name="Example">Ejemplos</h2> + +<pre class="brush: js">// Example 1: + +// Prevent error dialogs from displaying -which is the window's normal +// behavior- by overriding the default event handler for error events that +// go to the window. +window.onerror = null; + +// Example 2: + +var gOldOnError = window.onerror; +// Override previous handler. +window.onerror = function myErrorHandler(errorMsg, url, lineNumber) { + if (gOldOnError) + // Call previous handler. + return gOldOnError(errorMsg, url, lineNumber); + + // Just let default handler run. + return false; +} +</pre> + +<h2 id="Notes" name="Notes">Notas</h2> + +<p>El evento de error es lanzado cuando ocurre un error en el script.</p> + +<p>Cuando se use el marcado html en línea (<span class="nowiki"><body onerror="alert('an error occurred')>...</span>), los argumentos son anónimos. Pueden ser referenciados usando desde <code>arguments{{ mediawiki.external(0) }}</code> hasta <code>arguments{{ mediawiki.external(2) }}</code>.</p> + +<p>No hay llamante <code><a class="external" href="/en/Components.stack" title="https://developer.mozilla.org/En/Components.stack">Components.stack</a>.caller</code> que recuperar. (Vea <a class="link-https" href="https://bugzilla.mozilla.org/show_bug.cgi?id=355430"><strong>bug 355430</strong></a>.)</p> + +<h2 id="Specification" name="Specification">Especificación</h2> + +<p><a class="external" href="http://devedge-temp.mozilla.org/library/manuals/2000/javascript/1.3/reference/handlers.html#1120097" title="http://devedge-temp.mozilla.org/library/manuals/2000/javascript/1.3/reference/handlers.html#1120097">JavaScript 1.1</a></p> diff --git a/files/es/web/api/globaleventhandlers/onfocus/index.html b/files/es/web/api/globaleventhandlers/onfocus/index.html new file mode 100644 index 0000000000..e29b3fb84b --- /dev/null +++ b/files/es/web/api/globaleventhandlers/onfocus/index.html @@ -0,0 +1,94 @@ +--- +title: GlobalEventHandlers.onfocus +slug: Web/API/GlobalEventHandlers/onfocus +translation_of: Web/API/GlobalEventHandlers/onfocus +--- +<div>{{ApiRef("HTML DOM")}}</div> + +<p>La propiedad <strong>onfocus</strong> devuelve un manejador de eventos para el evento onFocus en el elemento actual.</p> + +<h2 id="Sintaxis">Sintaxis</h2> + +<pre class="syntaxbox">element.onfocus = <em>event handling code</em> +</pre> + +<h2 id="Notas">Notas</h2> + +<p>El evento focus se dispara cuando el usuario establece el foco en el elemento.</p> + +<p>Para que el evento <code>onfocus</code> se dispare en elementos que no sean inputs, los mismos deben establecerse con el atributo {{htmlattrxref("tabindex")}} (vea <a href="/en-US/docs/Learn/Accessibility/HTML#Building_keyboard_accessibility_back_in">Building keyboard accessibility back in</a> para mas detalles).</p> + +<p>A diferencia de MSIE, en que casi toda clase de elemento puede recibir el evento focus, en los navegadores Gecko en los que casi todos los elementos NO reciben este evento.</p> + +<h2 id="Especificaciones">Especificaciones</h2> + +<table class="spectable standard-table"> + <tbody> + <tr> + <th scope="col">Specification</th> + <th scope="col">Status</th> + <th scope="col">Comment</th> + </tr> + <tr> + <td>{{SpecName('HTML WHATWG','webappapis.html#handler-onfocus','onfocus')}}</td> + <td>{{Spec2('HTML WHATWG')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilidad_con_los_Navegadores">Compatibilidad con los Navegadores</h2> + +<div>{{CompatibilityTable}}</div> + +<div id="compat-desktop"> +<table class="compat-table"> + <tbody> + <tr> + <th>Feature</th> + <th>Chrome</th> + <th>Firefox (Gecko)</th> + <th>Internet Explorer</th> + <th>Opera</th> + <th>Safari (WebKit)</th> + </tr> + <tr> + <td>Basic support</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatUnknown}}</td> + </tr> + </tbody> +</table> +</div> + +<div id="compat-mobile"> +<table class="compat-table"> + <tbody> + <tr> + <th>Feature</th> + <th>Android</th> + <th>Android Webview</th> + <th>Chrome for Android</th> + <th>Firefox Mobile (Gecko)</th> + <th>Firefox OS</th> + <th>IE Mobile</th> + <th>Opera Mobile</th> + <th>Safari Mobile</th> + </tr> + <tr> + <td>Basic support</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatUnknown}}</td> + </tr> + </tbody> +</table> +</div> diff --git a/files/es/web/api/globaleventhandlers/oninput/index.html b/files/es/web/api/globaleventhandlers/oninput/index.html new file mode 100644 index 0000000000..18785b9fe3 --- /dev/null +++ b/files/es/web/api/globaleventhandlers/oninput/index.html @@ -0,0 +1,86 @@ +--- +title: GlobalEventHandlers.oninput +slug: Web/API/GlobalEventHandlers/oninput +translation_of: Web/API/GlobalEventHandlers/oninput +--- +<div>{{ ApiRef("HTML DOM") }}</div> + +<p>Un controlador de eventos para el evento input en la ventana. El evento input es llamado cuando el valor de un elemento {{ HTMLElement("input") }} ha cambiado. </p> + +<p>Este evento se propaga. Si está soportado en la ventana, también estará soportado en elementos {{ HTMLElement("input") }}.</p> + +<h2 id="Example" name="Example">Ejemplo</h2> + +<pre class="brush: html"><script> + +window.addEventListener('input', function (e) { + console.log("Evento keyup detectado! proveniente de este elemento:", e.target); +}, false); + +</script> + +<input placeholder="Tipee aquí y vea la consola."> +</pre> + +<h2 id="Specification" name="Specification">Especificaciones</h2> + +<p><a class="external" href="http://www.whatwg.org/specs/web-apps/current-work/multipage/common-input-element-attributes.html#event-input-input" title="http://www.whatwg.org/specs/web-apps/current-work/multipage/common-input-element-attributes.html#event-input-input">HTML - APIs de elementos de entrada comunes (<code>input</code>)</a></p> + +<h2 id="Compatibilidad_con_navegadores">Compatibilidad con navegadores</h2> + +<p>{{ CompatibilityTable() }}</p> + +<div id="compat-desktop"> +<table class="compat-table"> + <tbody> + <tr> + <th>Característica</th> + <th>Chrome</th> + <th>Firefox (Gecko)</th> + <th>Internet Explorer</th> + <th>Opera</th> + <th>Safari</th> + </tr> + <tr> + <td>Soporte básico</td> + <td>{{ CompatVersionUnknown() }}</td> + <td>2</td> + <td>9</td> + <td>10</td> + <td>{{ CompatVersionUnknown() }}</td> + </tr> + </tbody> +</table> +</div> + +<div id="compat-mobile"> +<table class="compat-table"> + <tbody> + <tr> + <th>Característica</th> + <th>Android</th> + <th>Firefox Mobile (Gecko)</th> + <th>IE Mobile</th> + <th>Opera Mobile</th> + <th>Safari Mobile</th> + </tr> + <tr> + <td>Soporte básico</td> + <td>{{ CompatUnknown() }}</td> + <td>{{ CompatUnknown() }}</td> + <td>{{ CompatUnknown() }}</td> + <td>{{ CompatUnknown() }}</td> + <td>{{ CompatVersionUnknown() }}</td> + </tr> + </tbody> +</table> +</div> + +<h2 id="Vea_también">Vea también</h2> + +<ul> + <li><a class="external" href="http://blog.danielfriesen.name/2010/02/16/html5-browser-maze-oninput-support/">Un laberinto de navegadores HTML5, soporte para oninput</a></li> + <li><a class="external" href="http://www.useragentman.com/blog/2011/05/12/fixing-oninput-in-ie9-using-html5widgets/">Corrigiendo oninput en IE con html5Widgets</a> incluye cobertura para IE6-8</li> + <li>Mathias Bynens sugiere <a class="external" href="http://mathiasbynens.be/notes/oninput" title="http://mathiasbynens.be/notes/oninput">enlazando a input y keydown</a></li> + <li><a class="external" href="http://help.dottoro.com/ljhxklln.php" title="http://help.dottoro.com/ljhxklln.php">evento oninput | dottoro</a> posee notas acerca de bugs en IE9</li> +</ul> diff --git a/files/es/web/api/globaleventhandlers/onkeydown/index.html b/files/es/web/api/globaleventhandlers/onkeydown/index.html new file mode 100644 index 0000000000..4eea7b0c68 --- /dev/null +++ b/files/es/web/api/globaleventhandlers/onkeydown/index.html @@ -0,0 +1,93 @@ +--- +title: GlobalEventHandlers.onkeydown +slug: Web/API/GlobalEventHandlers/onkeydown +translation_of: Web/API/GlobalEventHandlers/onkeydown +--- +<div>{{ApiRef("HTML DOM")}}</div> + +<p>La propiedad <code><strong>onkeydown</strong></code> devuelve un manejador para el evento <code>onKeyDown</code> del elemento actual.</p> + +<h2 id="Sintaxis">Sintaxis</h2> + +<pre class="syntaxbox">element.onkeydown = <var>event handling code</var></pre> + +<h2 id="Notas">Notas</h2> + +<p>El evento <code>keydown</code> se lanza cuando el usuario presiona una tecla.</p> + +<h2 id="Especificaciones">Especificaciones</h2> + +<table class="spectable standard-table"> + <tbody> + <tr> + <th scope="col">Specification</th> + <th scope="col">Status</th> + <th scope="col">Comment</th> + </tr> + <tr> + <td>{{SpecName('HTML WHATWG','webappapis.html#handler-onkeydown','onkeydown')}}</td> + <td>{{Spec2('HTML WHATWG')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilidad_con_navegadores">Compatibilidad con navegadores</h2> + +<div>{{CompatibilityTable}}</div> + +<div id="compat-desktop"> +<table class="compat-table"> + <tbody> + <tr> + <th>Feature</th> + <th>Chrome</th> + <th>Edge</th> + <th>Firefox (Gecko)</th> + <th>Internet Explorer</th> + <th>Opera</th> + <th>Safari (WebKit)</th> + </tr> + <tr> + <td>Basic support</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatUnknown}}</td> + </tr> + </tbody> +</table> +</div> + +<div id="compat-mobile"> +<table class="compat-table"> + <tbody> + <tr> + <th>Feature</th> + <th>Android</th> + <th>Android Webview</th> + <th>Edge</th> + <th>Firefox Mobile (Gecko)</th> + <th>Firefox OS</th> + <th>IE Mobile</th> + <th>Opera Mobile</th> + <th>Safari Mobile</th> + <th>Chrome for Android</th> + </tr> + <tr> + <td>Basic support</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + </tr> + </tbody> +</table> +</div> diff --git a/files/es/web/api/globaleventhandlers/onkeyup/index.html b/files/es/web/api/globaleventhandlers/onkeyup/index.html new file mode 100644 index 0000000000..f6b97819eb --- /dev/null +++ b/files/es/web/api/globaleventhandlers/onkeyup/index.html @@ -0,0 +1,100 @@ +--- +title: GlobalEventHandlers.onkeyup +slug: Web/API/GlobalEventHandlers/onkeyup +translation_of: Web/API/GlobalEventHandlers/onkeyup +--- +<div>{{ApiRef("HTML DOM")}}</div> + +<p>La propiedad <strong>onkeyup</strong> devuelve un manejador para el evento onKeyUp del elemento actual.</p> + +<h2 id="Sintaxis">Sintaxis</h2> + +<pre class="syntaxbox">element.onkeyup = <em>event handling code</em> +</pre> + +<h2 id="Ejemplo">Ejemplo</h2> + +<pre class="brush: js"> <input type="text" onKeyUp="keyWasPressed(event)"> + <script>function keyWasPressed(evt){ console.log(evt.keyCode) }</script> +</pre> + +<h2 id="Notas">Notas</h2> + +<p>El evento keyup se lanza cuando el usuario suelta la tecla que ha sido presionada.</p> + +<h2 id="Especificaciones">Especificaciones</h2> + +<table class="spectable standard-table"> + <tbody> + <tr> + <th scope="col">Specification</th> + <th scope="col">Status</th> + <th scope="col">Comment</th> + </tr> + <tr> + <td>{{SpecName('HTML WHATWG','webappapis.html#handler-onkeyup','onkeyup')}}</td> + <td>{{Spec2('HTML WHATWG')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilidad_con_navegadores">Compatibilidad con navegadores</h2> + +<div>{{CompatibilityTable}}</div> + +<div id="compat-desktop"> +<table class="compat-table"> + <tbody> + <tr> + <th>Feature</th> + <th>Chrome</th> + <th>Edge</th> + <th>Firefox (Gecko)</th> + <th>Internet Explorer</th> + <th>Opera</th> + <th>Safari (WebKit)</th> + </tr> + <tr> + <td>Basic support</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatUnknown}}</td> + </tr> + </tbody> +</table> +</div> + +<div id="compat-mobile"> +<table class="compat-table"> + <tbody> + <tr> + <th>Feature</th> + <th>Android</th> + <th>Android Webview</th> + <th>Edge</th> + <th>Firefox Mobile (Gecko)</th> + <th>Firefox OS</th> + <th>IE Mobile</th> + <th>Opera Mobile</th> + <th>Safari Mobile</th> + <th>Chrome for Android</th> + </tr> + <tr> + <td>Basic support</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + </tr> + </tbody> +</table> +</div> diff --git a/files/es/web/api/globaleventhandlers/onload/index.html b/files/es/web/api/globaleventhandlers/onload/index.html new file mode 100644 index 0000000000..b97cf40b4f --- /dev/null +++ b/files/es/web/api/globaleventhandlers/onload/index.html @@ -0,0 +1,51 @@ +--- +title: window.onload +slug: Web/API/GlobalEventHandlers/onload +tags: + - window.onload +translation_of: Web/API/GlobalEventHandlers/onload +--- +<p>{{ ApiRef() }}</p> +<h3 id="Summary" name="Summary">Sumario</h3> +<p>Un evento tipo handler para el evento <code>load</code> event de el {{ domxref("window") }}.</p> +<h3 id="Syntax" name="Syntax">Syntax</h3> +<pre class="eval">window.onload = <em>funcRef</em>; +</pre> +<ul> + <li><code>funcRef</code> es la función tipo handler function a ser llamada cuando el evento <code>load</code> de window se dispara.</li> +</ul> +<h3 id="Example" name="Example">Ejemplos</h3> +<pre class="brush: js">window.onload = function() { + init(); + doSomethingElse(); +}; +</pre> +<pre class="brush: html"><!doctype html> +<html> + <head> + <title>Ejemplo Onload</title> + <script> + function load() { + alert("evento load detectado!"); + } + window.onload = load; + </script> + </head> + <body> + <p>El Evento load se dispara cuando el documento ha terminado de cargarse!</p> + </body> +</html> +</pre> +<h3 id="Notes" name="Notes">Notas</h3> +<p>El evento <code>load</code> dispara el evento al final del proceso de carga del documento. En este punto, todos los objetos del documento son DOM, y todas las imágenes y sub-frames han terminado de cargarse.</p> +<p>Existen también los <a href="/en/Gecko-Specific_DOM_Events" title="en/Gecko-Specific_DOM_Events">Eventos DOM Específicos</a> como <code>DOMContentLoaded</code> y <code>DOMFrameContentLoaded</code> (los cuales pueden ser manejados usando {{ domxref("element.addEventListener()") }}) y son ejecutados despues de que el DOM de la página ha sido construido, pero no esperear a que otros recursos terminen de cargar.</p> +<h3 id="Specification" name="Specification">Especificación</h3> +<p>Este evento tipo handler se encuentra especificado en <a class="external" href="http://www.whatwg.org/html/#handler-window-onload" title="http://www.whatwg.org/html/#handler-window-onload">HTML</a>.</p> +<h3 id="Ver_También">Ver También</h3> +<ul> + <li> + <div class="syntaxbox"> + Evento <code>DOMContentLoaded</code> en <a href="/En/Listening_to_events#Simple_DOM.c2.a0events" title="En/Listening to events#Simple DOM.c2.a0events">Escuchando los Evento:Eventos DOM Simples</a></div> + </li> +</ul> +<p>{{ languages( { "fr": "fr/DOM/window.onload", "pl": "pl/DOM/window.onload" } ) }}</p> diff --git a/files/es/web/api/globaleventhandlers/onloadedmetadata/index.html b/files/es/web/api/globaleventhandlers/onloadedmetadata/index.html new file mode 100644 index 0000000000..01bbdcefd8 --- /dev/null +++ b/files/es/web/api/globaleventhandlers/onloadedmetadata/index.html @@ -0,0 +1,48 @@ +--- +title: GlobalEventHandlers.onloadedmetadata +slug: Web/API/GlobalEventHandlers/onloadedmetadata +translation_of: Web/API/GlobalEventHandlers/onloadedmetadata +--- +<div>{{ ApiRef("HTML DOM") }}</div> + +<p>The <strong><code>onloadedmetadata</code></strong> property of the {{domxref("GlobalEventHandlers")}} mixin is the {{domxref("EventHandler")}} for processing {{event("loadedmetadata")}} events.</p> + +<p>The <code>loadedmetadata</code> event is fired when the metadata has been loaded.</p> + +<h2 id="Syntax">Syntax</h2> + +<pre class="syntaxbox notranslate"><em><var>element</var></em>.onloadedmetadata = <em>handlerFunction</em>; +var <em>handlerFunction</em> = <em><var>element</var></em>.onloadedmetadata; +</pre> + +<p><code>handlerFunction</code> should be either <code>null</code> or a <a href="/en-US/docs/Web/JavaScript/Reference/Functions" title="/en-US/docs/JavaScript/Reference/Functions_and_function_scope">JavaScript function</a> specifying the handler for the event.</p> + +<h2 id="Specification">Specification</h2> + +<table class="spectable standard-table"> + <tbody> + <tr> + <th scope="col">Specification</th> + <th scope="col">Status</th> + <th scope="col">Comment</th> + </tr> + <tr> + <td>{{SpecName('HTML WHATWG','#handler-onloadedmetadata','onloadedmetadata')}}</td> + <td>{{Spec2('HTML WHATWG')}}</td> + <td></td> + </tr> + </tbody> +</table> + +<h2 id="Browser_compatibility">Browser compatibility</h2> + + + +<p>{{Compat("api.GlobalEventHandlers.onloadedmetadata")}}</p> + +<h2 id="See_also">See also</h2> + +<ul> + <li>{{event("loadedmetadata")}}</li> + <li><a href="/en-US/docs/Web/Guide/Events/Event_handlers" title="/en-US/docs/Web/Guide/DOM/Events/Event_handlers">DOM event handlers</a></li> +</ul> diff --git a/files/es/web/api/globaleventhandlers/onresize/index.html b/files/es/web/api/globaleventhandlers/onresize/index.html new file mode 100644 index 0000000000..5d18902f04 --- /dev/null +++ b/files/es/web/api/globaleventhandlers/onresize/index.html @@ -0,0 +1,71 @@ +--- +title: GlobalEventHandlers.onresize +slug: Web/API/GlobalEventHandlers/onresize +tags: + - API + - DOM + - Propiedad +translation_of: Web/API/GlobalEventHandlers/onresize +--- +<p>{{ ApiRef() }}</p> + +<p>La propiedad <strong>GlobalEventHandlers.onresize</strong> contiene un {{domxref("EventHandler")}} desencadenado cuando un evento {{event("resize")}} es recibido.</p> + +<h2 id="Syntax" name="Syntax">Sintaxis</h2> + +<pre class="eval">window.onresize = <em>funcRef</em>; +</pre> + +<h3 id="Parameters" name="Parameters">Parametros</h3> + +<ul> + <li><code>funcRef</code> es una referencia a una función.</li> +</ul> + +<h2 id="Example" name="Example">Ejemplo</h2> + +<pre>window.onresize = doFunc; +</pre> + +<pre><html> +<head> + +<title>onresize test</title> + +<script type="text/javascript"> + +window.onresize = resize; + +function resize() +{ + alert("resize event detected!"); +} +</script> +</head> + +<body> +<p>Resize the browser window to fire the resize event.</p> +</body> +</html> +</pre> + +<h2 id="Notes" name="Notes">Notas</h2> + +<p>El evento <u>resize</u> es activado después de que la ventana ha sido redimensionada.</p> + +<h2 id="Specification" name="Specification">Especificación</h2> + +<table class="spectable standard-table"> + <tbody> + <tr> + <th scope="col">Especificación</th> + <th scope="col">Status</th> + <th scope="col">Comentario</th> + </tr> + <tr> + <td>{{SpecName('HTML WHATWG','webappapis.html#handler-onresize','onresize')}}</td> + <td>{{Spec2('HTML WHATWG')}}</td> + <td> </td> + </tr> + </tbody> +</table> diff --git a/files/es/web/api/globaleventhandlers/onscroll/index.html b/files/es/web/api/globaleventhandlers/onscroll/index.html new file mode 100644 index 0000000000..017085065a --- /dev/null +++ b/files/es/web/api/globaleventhandlers/onscroll/index.html @@ -0,0 +1,80 @@ +--- +title: GlobalEventHandlers.onscroll +slug: Web/API/GlobalEventHandlers/onscroll +translation_of: Web/API/GlobalEventHandlers/onscroll +--- +<div>{{ApiRef("HTML DOM")}}</div> + +<p>Un manejador de eventos para desplazamiento en <code>element</code>.</p> + +<h2 id="Sintaxis">Sintaxis</h2> + +<pre class="syntaxbox">element.onscroll = <var>functionReference</var> +</pre> + +<h3 id="Parámetros">Parámetros</h3> + +<p><code>functionReference</code> es una referencia a una función para ser ejecutada cuando <code>element</code> es desplazado (enrollado).</p> + +<h2 id="Example">Example</h2> + +<pre class="brush: html"><!DOCTYPE html> +<html lang="en"> + <head> + <meta charset="UTF-8" /> + <style> + #container { + position: absolute; + height: auto; + top: 0; + bottom: 0; + width: auto; + left: 0; + right: 0; + overflow: auto; + } + + #foo { + height:1000px; + width:1000px; + background-color: #777; + display: block; + } + + </style> + </head> + <body> + <div id="container"> + <div id="foo"></div> + </div> + + <script type="text/javascript"> + document.getElementById('container').onscroll = function() { + console.log("scrolling"); + }; + </script> + </body> +</html></pre> + +<h2 id="Notas">Notas</h2> + +<p>El evento es generado cuando el usuario realiza desplazamiento (scrolls) sobre el contenido de un elemento. <code>Element.onscroll</code> es equivalente a <code>element.addEventListener("scroll" ... )</code>.</p> + +<h2 id="Especificaciones">Especificaciones</h2> + +<table class="standard-table"> + <thead> + <tr> + <th scope="col">Especificación</th> + <th scope="col">Estado</th> + <th scope="col">Observaciones</th> + </tr> + </thead> + <tbody> + <tr> + <td>{{SpecName("DOM3 Events", "#event-type-scroll", "onscroll")}}</td> + <td>{{Spec2("DOM3 Events")}}</td> + <td>Definición inicial</td> + </tr> + </tbody> +</table> diff --git a/files/es/web/api/globaleventhandlers/onselect/index.html b/files/es/web/api/globaleventhandlers/onselect/index.html new file mode 100644 index 0000000000..a97e18c74a --- /dev/null +++ b/files/es/web/api/globaleventhandlers/onselect/index.html @@ -0,0 +1,74 @@ +--- +title: GlobalEventHandlers.onselect +slug: Web/API/GlobalEventHandlers/onselect +translation_of: Web/API/GlobalEventHandlers/onselect +--- +<div> +<div>{{ ApiRef("HTML DOM") }}</div> + +<div>Un manejador de evento para el evento select en la ventana.</div> +</div> + +<p> </p> + +<h2 id="Syntax" name="Syntax">Sintaxis</h2> + +<pre class="syntaxbox">window.onselect = <em>funcRef</em>; +</pre> + +<ul> + <li><code>funcRef</code> es una función</li> +</ul> + +<h2 id="Example" name="Example">Ejemplo</h2> + +<pre class="brush: html"><html> +<head> + +<title>onselect test</title> + +<style type="text/css"> +.text1 { border: 2px solid red; } +</style> + +<script type="text/javascript"> + +window.onselect = selectText; + +function selectText() +{ + alert("¡detectado evento select!"); +} +</script> +</head> + +<body> +<textarea class="text1" cols="30" rows="3"> +Resalte algo de este texto +con el puntero del ratón +para disparar el evento onselect. +</textarea> +</body> +</html> +</pre> + +<h2 id="Notes" name="Notes">Notas</h2> + +<p>El evento select sólo se genera cuando es seleccionado texto dentro de un control de entrada (INPUT) de tipo text o textarea. El evento es disparado <em>después</em> de que el texto haya sido seleccionado.</p> + +<h2 id="Specification" name="Specification">Especificación</h2> + +<table class="spectable standard-table"> + <tbody> + <tr> + <th scope="col">Especifiación</th> + <th scope="col">Estado</th> + <th scope="col">Observaciones</th> + </tr> + <tr> + <td>{{SpecName('HTML WHATWG','webappapis.html#handler-onselect','onselect')}}</td> + <td>{{Spec2('HTML WHATWG')}}</td> + <td> </td> + </tr> + </tbody> +</table> diff --git a/files/es/web/api/globaleventhandlers/onselectstart/index.html b/files/es/web/api/globaleventhandlers/onselectstart/index.html new file mode 100644 index 0000000000..9ef1886a4f --- /dev/null +++ b/files/es/web/api/globaleventhandlers/onselectstart/index.html @@ -0,0 +1,98 @@ +--- +title: GlobalEventHandlers.onselectstart +slug: Web/API/GlobalEventHandlers/onselectstart +translation_of: Web/API/GlobalEventHandlers/onselectstart +--- +<div>{{ApiRef('DOM')}}{{SeeCompatTable}}</div> + +<p>La propiedad <code><strong>GlobalEventHandlers.onselectstart</strong></code> representa el manejador de evento que es invocado cuando un evento {{event("selectstart")}} alcanza el objeto.</p> + +<h2 id="Sintaxis">Sintaxis</h2> + +<pre class="syntaxbox"><em>obj</em>.onselectstart = <em>function</em>; +</pre> + +<ul> + <li><code>function</code> es el nombre de una función definida por el usuario, sin el sufijo () ni ningún parámetro, o una declaración de función anónima.</li> +</ul> + +<h2 id="Ejemplo">Ejemplo</h2> + +<pre class="brush: html">document.onselectstart = function() { console.log("¡Selección iniciada!"); }; +</pre> + +<h2 id="Especificaciones">Especificaciones</h2> + +<table class="spectable standard-table"> + <tbody> + <tr> + <th scope="col">Especificación</th> + <th scope="col">Estado</th> + <th scope="col">Observaciones</th> + </tr> + <tr> + <td>{{SpecName('Selection API','','GlobalEventHandlers.onselectstart')}}</td> + <td>{{Spec2('Selection API')}}</td> + <td>Definición inicial</td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilidad_con_navegadores">Compatibilidad con navegadores</h2> + +<p>{{CompatibilityTable}}</p> + +<div id="compat-desktop"> +<table class="compat-table"> + <tbody> + <tr> + <th>Prestación</th> + <th>Firefox (Gecko)</th> + <th>Chrome</th> + <th>Internet Explorer</th> + <th>Opera</th> + <th>Safari</th> + </tr> + <tr> + <td>Soporte básico</td> + <td>{{CompatGeckoDesktop(43)}}<sup>[1]</sup></td> + <td>{{CompatUnknown}}</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatUnknown}}</td> + </tr> + </tbody> +</table> +</div> + +<div id="compat-mobile"> +<table class="compat-table"> + <tbody> + <tr> + <th>Feature</th> + <th>Firefox Mobile (Gecko)</th> + <th>Android</th> + <th>IE Mobile</th> + <th>Opera Mobile</th> + <th>Safari Mobile</th> + </tr> + <tr> + <td><code>onselectionchange</code></td> + <td>{{CompatGeckoMobile(43)}}<sup>[1]</sup></td> + <td>{{CompatUnknown}}</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatUnknown}}</td> + </tr> + </tbody> +</table> +</div> + +<p>[1] Esto está implementado subordinado a la preferencia <code>dom.select_events.enabled</code>, que por defecto es <code>false</code>, excepto en las versiones Nightly.</p> + +<h2 id="Ver_también">Ver también</h2> + +<ul> + <li>{{event("selectstart")}}</li> + <li>{{domxref("Document.onselectionchange")}} and {{event('selectionchange')}}.</li> +</ul> diff --git a/files/es/web/api/globaleventhandlers/onsubmit/index.html b/files/es/web/api/globaleventhandlers/onsubmit/index.html new file mode 100644 index 0000000000..948f7c9e57 --- /dev/null +++ b/files/es/web/api/globaleventhandlers/onsubmit/index.html @@ -0,0 +1,125 @@ +--- +title: GlobalEventHandlers.onsubmit +slug: Web/API/GlobalEventHandlers/onsubmit +translation_of: Web/API/GlobalEventHandlers/onsubmit +--- +<div>{{ApiRef("HTML DOM")}}</div> + +<p>Manejador de eventos del evento submit para el objeto window.</p> + +<h2 id="Sintaxis">Sintaxis</h2> + +<pre class="eval">window.onsubmit = <em>funcRef</em>; +</pre> + +<h3 id="Parametros">Parametros</h3> + +<ul> + <li><code>funcRef</code> es una referencia a una función.</li> +</ul> + +<h2 id="Ejemplo">Ejemplo</h2> + +<pre class="eval"><html> +<script> +function reg() { + window.captureEvents(Event.SUBMIT); + window.onsubmit = hit; +} + +function hit() { + console.log('hit'); +} +</script> + +<body onload="reg();"> +<form> + <input type="submit" value="submit" /> +</form> +<div id="d"> </div> +</body> +</html> +</pre> + +<h2 id="Notas">Notas</h2> + +<p>El evento submit se genera cuando el usuario hace click en el boton submit en un formulario (<code><input type="submit"/></code>).</p> + +<p>El evento submit no se genera cuando el usuario llama a la función <code>form.submit()</code> directamente.</p> + +<h2 id="Especificaciones">Especificaciones</h2> + +<table class="spectable standard-table"> + <tbody> + <tr> + <th scope="col">Specification</th> + <th scope="col">Status</th> + <th scope="col">Comment</th> + </tr> + <tr> + <td>{{SpecName('HTML WHATWG','webappapis.html#handler-onsubmit','onsubmit')}}</td> + <td>{{Spec2('HTML WHATWG')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Browser_Compatibility">Browser Compatibility</h2> + +<div>{{CompatibilityTable}}</div> + +<div id="compat-desktop"> +<table class="compat-table"> + <tbody> + <tr> + <th>Feature</th> + <th>Chrome</th> + <th>Edge</th> + <th>Firefox (Gecko)</th> + <th>Internet Explorer</th> + <th>Opera</th> + <th>Safari (WebKit)</th> + </tr> + <tr> + <td>Basic support</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatUnknown}}</td> + </tr> + </tbody> +</table> +</div> + +<div id="compat-mobile"> +<table class="compat-table"> + <tbody> + <tr> + <th>Feature</th> + <th>Android</th> + <th>Android Webview</th> + <th>Chrome for Android</th> + <th>Edge</th> + <th>Firefox Mobile (Gecko)</th> + <th>Firefox OS</th> + <th>IE Mobile</th> + <th>Opera Mobile</th> + <th>Safari Mobile</th> + </tr> + <tr> + <td>Basic support</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatUnknown}}</td> + </tr> + </tbody> +</table> +</div> diff --git a/files/es/web/api/globaleventhandlers/ontouchstart/index.html b/files/es/web/api/globaleventhandlers/ontouchstart/index.html new file mode 100644 index 0000000000..db51db726f --- /dev/null +++ b/files/es/web/api/globaleventhandlers/ontouchstart/index.html @@ -0,0 +1,126 @@ +--- +title: GlobalEventHandlers.ontouchstart +slug: Web/API/GlobalEventHandlers/ontouchstart +translation_of: Web/API/GlobalEventHandlers/ontouchstart +--- +<div>{{ApiRef("HTML DOM")}}</div> + +<p>Un {{domxref("GlobalEventHandlers","global event handler")}} para el evento {{event("touchstart")}}.</p> + +<p>{{SeeCompatTable}}</p> + +<div class="note"> +<p><strong>Nota:</strong> Este atributo <em>no</em> ha sido estandarizado formalmente. Está especificado en la especificación {{SpecName('Touch Events 2')}} {{Spec2('Touch Events 2')}} y no en {{SpecName('Touch Events')}} {{Spec2('Touch Events')}}. Este atributo no está totalmente implementado.</p> +</div> + +<h2 id="Syntax" name="Syntax">Sintaxis</h2> + +<pre class="eval">var startHandler = cualquierElemento.ontouchstart; +</pre> + +<h3 id="Return_Value" name="Return_Value">Valor devuelto</h3> + +<dl> + <dt><code>startHandler</code></dt> + <dd>El manejador del evento <code>touchstart</code> para el elemento <code>cualquierElemento</code>.</dd> +</dl> + +<h2 id="Ejemplo">Ejemplo</h2> + +<p>Este ejemplo muestra dos formas de utilizar <code>ontouchstart</code> para establecer un manejador de evento <code>touchstart</code>.</p> + +<pre class="brush: js"><html> +<script> +function startTouch(ev) { + // Procesar el evento +} +function init() { + var el=document.getElementById("target1"); + el.ontouchstart = startTouch; +} +</script> +<body onload="init();"> +<div id="target1"> Tócame ... </div> +<div id="target2" ontouchstart="startTouch(event)"> Tócame ... </div> +</body> +</html> +</pre> + +<h2 id="Especificaciones">Especificaciones</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Especificación</th> + <th scope="col">Estado</th> + <th scope="col">Comentario</th> + </tr> + <tr> + <td>{{SpecName('Touch Events 2','#widl-GlobalEventHandlers-ontouchstart')}}</td> + <td>{{Spec2('Touch Events 2')}}</td> + <td>Versión no estable.</td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilidad_en_navegadores">Compatibilidad en navegadores</h2> + +<p>{{CompatibilityTable}}</p> + +<div id="compat-desktop"> +<table class="compat-table"> + <tbody> + <tr> + <th>Característica</th> + <th>Chrome</th> + <th>Firefox (Gecko)</th> + <th>Internet Explorer</th> + <th>Opera</th> + <th>Safari (WebKit)</th> + </tr> + <tr> + <td>Basic support</td> + <td> </td> + <td> </td> + <td> </td> + <td> </td> + <td> </td> + </tr> + </tbody> +</table> +</div> + +<div id="compat-mobile"> +<table class="compat-table"> + <tbody> + <tr> + <th>Feature</th> + <th>Android</th> + <th>Android Webview</th> + <th>Chrome para Android</th> + <th>Firefox Mobile (Gecko)</th> + <th>Firefox OS</th> + <th>IE Mobile</th> + <th>Opera Mobile</th> + <th>Safari Mobile</th> + </tr> + <tr> + <td>Basic support</td> + <td> </td> + <td> </td> + <td> </td> + <td> </td> + <td> </td> + <td> </td> + <td> </td> + <td> </td> + </tr> + </tbody> +</table> +</div> + +<h2 id="Ver_también">Ver también</h2> + +<ul> + <li>{{ event("touchstart") }}</li> +</ul> diff --git a/files/es/web/api/globaleventhandlers/onunload/index.html b/files/es/web/api/globaleventhandlers/onunload/index.html new file mode 100644 index 0000000000..a665fc2027 --- /dev/null +++ b/files/es/web/api/globaleventhandlers/onunload/index.html @@ -0,0 +1,45 @@ +--- +title: window.onunload +slug: Web/API/GlobalEventHandlers/onunload +translation_of: Web/API/WindowEventHandlers/onunload +--- +<p>{{ ApiRef() }}</p> +<h3 id="Summary" name="Summary">Test Summary</h3> +<p>The unload event is raised when the document is unloaded.</p> +<h3 id="Syntax" name="Syntax">Syntax</h3> +<pre class="eval">window.onunload = <em>funcRef</em>; +</pre> +<ul> + <li><code>funcRef</code> is a reference to a function.</li> +</ul> +<h3 id="Example" name="Example">Example</h3> +<pre><html> +<head> + +<title>onunload test</title> + +<script type="text/javascript"> + +window.onunload = unloadPage; + +function unloadPage() +{ + alert("unload event detected!"); +} +</script> +</head> + +<body> +<p>Reload a new page into the browser<br /> + to fire the unload event for this page.</p> +<p>You can also use the back or forward buttons<br /> + to load a new page and fire this event.</p> +</body> +</html> +</pre> +<h3 id="Notes" name="Notes">Notes</h3> +<p>Note that using this event handler in your page prevents Firefox 1.5 from caching the page in the in-memory bfcache. See <a href="/En/Using_Firefox_1.5_caching" title="En/Using_Firefox_1.5_caching">Using Firefox 1.5 caching</a> for details.</p> +<p>Browsers equipped with pop-up window blockers will ignore all window.open() method calls in onunload event handler functions.</p> +<h3 id="Specification" name="Specification">Specification</h3> +<p>{{ DOM0() }}</p> +<p>{{ languages( {"zh-cn": "zh-cn/DOM/window.onunload" } ) }}</p> |