Saltar navegación

GUI Eventos - Contenido educativo

Ajuste de pantalla

El ajuste de pantalla se aprecia al ver el vídeo en pantalla completa. Elige la presentación que más te guste:

Subido el 15 de abril de 2026 por Stefano C.

3 visualizaciones

Más información Transcripción

Descargar la transcripción

Entonces, vamos a ir, voy a grabar esta clase, por lo tanto si habláis o escribís algo, pues será grabado para siempre en mis vídeos, ¿vale? 00:00:00
Ok, entonces, repito porque antes no lo he dicho, tenemos instalados el SimBuilder instalado, ¿vale? 00:00:09
Tenemos este zip de aquí, que estos dos se pueden bajar desde el sitio de Gluon, o sea que se bajan tranquilamente, o desde mi aula virtual, si queréis. 00:00:17
Esta carpeta aquí la tenemos por algún lado, nosotros la tenemos en el Workspace y tenemos instalado el plugin de JavaFX aquí dentro, ¿vale? 00:00:30
Aquí estamos, así se queda grabado. Es este de aquí. Yo busco aquí JavaFX y aquí dentro esto, ¿vale? 00:00:38
Que está instalado. A partir de aquí es donde empezamos, ¿vale? 00:00:49
Entonces, nosotros lo que vamos a hacer es crear un nuevo proyecto, ¿vale? 00:00:53
Pero en vez de un proyecto Java, vamos a Over, la instalación del plugin me ha dado esta nueva carpetita aquí, 00:00:57
donde vienen cosas de Java CX. Yo voy a utilizar el proyecto Java CX, ¿vale? 00:01:07
Esto le doy un nombre, por ejemplo, GUI botones, ¿vale? 00:01:16
Y entonces me crea un nuevo proyecto. Este proyecto de aquí tiene esta estructura, ¿vale? 00:01:22
Algunas cosas ya están. 00:01:27
Lo que le falta al proyecto es todo lo que está relacionado con JavaFX. 00:01:29
¿Vale? 00:01:35
Entonces, se lo tengo que añadir. 00:01:35
Para añadírselo, en el proyecto Maven, pues, habría el pom.xml que me dice, 00:01:37
importame lo que tenga que importar, pero como nosotros no lo usamos todavía, 00:01:42
pues, vamos a Properties, vamos a Java Build Path, vamos a Librerías, 00:01:46
y aquí donde está el Modul Path, añadimos los Jara externos. 00:01:52
estos tengo que navegar a buscar la carpeta esta que había extraído dentro 00:01:56
de la carpeta que había extraído está la carpeta lib y dentro lib están estos 00:02:03
jar estos son todos los jar que me sirven son las colecciones de clases 00:02:07
relacionadas con javas x que sustancialmente me sirven vale algunas 00:02:11
de estas serán demasiadas y no la uso pero para estar seguro selecciono todos 00:02:19
y lo conecto vale aquí le doy a aplicar el clave cerrar y por lo tanto ahora me reconoce todas 00:02:26
estas claves una pregunta si dice algo o alguien de los que están conectados desde casa me lo decís 00:02:34
vamos a ver qué dice 00:02:42
lo tendremos que hacer pues depende antes del examen ya se os dirá cómo se va a hacer vale 00:02:49
si se os dice podéis usar lo que os da la gana si se os dice podéis usar la librería 00:02:59
si tenéis que usar llave pero todavía es pronto porque tanto esto no será el próximo examen más 00:03:04
el examen siguiente por lo tanto por ahora esto lo tenemos todavía que decidir vale la idea que 00:03:09
en clase veremos las dos cosas o podréis hacer las dos cosas luego más adelante para el examen 00:03:16
el problema de maven es que necesita internet entonces el día del examen por algún lado hay 00:03:22
problemas con internet o tenemos que quitaros el cable y cosas por eso para tener maven puede ser 00:03:27
más complejo entonces a lo mejor os daremos simplemente la librería de java px vosotros 00:03:32
como programadores que sois vais a aprender las dos cosas vale entonces una vez que tengo esta 00:03:37
cosa de aquí hecha vale ya en teoría funciona vale este es un proyecto básico de fx que es una 00:03:45
ventana vale pero no es lo que me interesa a mí me interesa crear aquí un par de cosas más primero 00:03:56
un fichero que será mi interfaz o interfaz.fxml esto será el fichero donde estará la interfaz 00:04:04
gráfica que editaremos con SimBuilder y por otro lado un controlador que 00:04:15
estará, dónde estarán los métodos que vienen llamados desde la interfaz. 00:04:27
Esto es normal que es de error porque por ahora está vacío y como es un fichero xml debería 00:04:33
tener algo, pues por ahora no lo es. Entonces vamos a hacer botón derecho sobre la interfaz 00:04:39
de fxml y aquí me da la opción de abrirlo con SimBuilder. Pincho aquí y me debería abrir 00:04:47
ahí entonces ahora aquí tengo por un lado aquí contenedores y controles vale este de aquí son 00:04:54
los dos principales que vamos a utilizar hay otras opciones como para hacer menús para ver 00:05:06
en este chat gráficos y cosas por el estilo por ahora nosotros nos centraremos en los primeros 00:05:13
dos por otro lado siempre de aquí utilizamos el inspector la parte que a la derecha principalmente 00:05:20
el properties y el code vale esto será la pestaña que me permite digamos hacer de puente entre lo 00:05:27
que veo aquí y lo que veo en el lado de modificación en el eclipse y luego aquí abajo el controller que 00:05:34
me permite decir si esta es la parte digamos frontal la parte de front-end de la parte que 00:05:42
que el usuario ve esta la conexión con sí vale más cuando hay un evento quién es el que recupera este 00:05:50
evento y hace algo pues esta clase de controller allí dentro encontraré los métodos que lo que 00:05:56
asignaré a los varios votos vamos a empezar por ejemplo hacer algo sencillo vale allá que aquí 00:06:01
haya unos botones entonces eso es un pain es sólo un panel es un corcho donde luego apuntaré pondré 00:06:09
todos los varios controles y pongo unos botones vale esto podría poner más esto es para hacerlo 00:06:19
de forma visual vale en teoría esto si yo podría hacer comandos aquí de java para que me añada 00:06:27
botones meten los botones las posiciones en algún lado cosas y de hecho este tipo de ejercicio aquí 00:06:41
donde hay 24 botones llama más a que no se haga así más se haga con un Ford vale que pero está 00:06:46
fuera de lo que estamos viendo por ahora por lo tanto por ahora lo dejo así vale quiero 24 botones 00:06:56
me ponga aquí hago 24 botones este es el botón 1 y este es el último muy vale entonces la idea es 00:07:01
que luego puede tener 3 4 5 lo que quiero hacer es que cuando hago clic en este botón este botón 00:07:10
de alguna forma se desactive 00:07:15
y marque aquí que ha sido pulsado. 00:07:17
¿Vale? Esto luego 00:07:20
si uno le ha hecho un poco 00:07:21
de fantasía, a partir de una cosa así 00:07:23
puede intentar hacer algún juego 00:07:25
como por ejemplo el 00:07:28
Buscaminas 00:07:29
o cosas por el estilo. ¿Vale? 00:07:32
Con un poco de fantasía y un poco de trabajo. 00:07:34
¿Vale? Esto sería como 00:07:36
el ancestro 00:07:37
de un Buscaminas. ¿Sí? 00:07:39
Vale. 00:07:42
ahora lo que yo quiero es que cuando pinche aquí estos botones hagan algo vale entonces para eso 00:07:42
necesito un controlador el me ve de controlador no vale entonces me voy a aquí donde creado el 00:07:49
controller vale y le digo le creó al menos un método vale por ahora lo vamos a hacer mal luego 00:07:56
después lo intentamos hacer mejor. Entonces hago un fxml, mongoprivate, por ejemplo, private, void, click1, que hará cosas. Por ahora lo que quiero que haga es simplemente escribir click en pantalla. 00:08:03
Ahora veis que esto se enfada, me dice oye mira no sé qué es, entonces le tenemos que decir oye mira quiero que en el módulo info pues requiera javacx.xml 00:08:25
porque se puede ver en javainfo aquí todavía esto no está el required, está solo el controls pero le falta esta otra cosa. 00:08:50
Pues como me ayuda él a hacerlo, tampoco es un problema, le digo sí, sí, sí, hazlo. 00:08:58
Entonces ahora me ha añadido aquí esta cosa aquí también, sigue enfadándose porque dice, vale, tengo que importar también aquí esta parte de aquí, ¿vale? 00:09:04
Esta línea de aquí, lo que hace es una llamada al preprocesador que me dice, oye, mira, esta cosa de aquí juega en el mundo de JavaFX. 00:09:13
entonces cuando tú vas a entrelazar el mundo que está creando en el sim builder con el mundo que 00:09:23
se existe aquí en la parte de eclipse pues esta es una parte fundamental esto tiene que estar 00:09:32
disponible también al otro lado en un cierto sentido quiero juntar esto con lo que viene 00:09:38
aquí. Que no lo he guardado todavía 00:09:44
y por lo tanto no está. ¿Vale? 00:09:49
Lo voy a guardar. Y entonces con 00:09:51
esta cosa aquí. ¿Vale? De alguna 00:09:56
forma aquí pondré cosas 00:09:58
que hacen referencia 00:10:00
a esta cosa de aquí. ¿Vale? 00:10:01
Ahora, 00:10:05
si tengo un poco de suerte, a un cierto 00:10:06
momento esto debería aparecer aquí. 00:10:08
Debería aparecer la clase. 00:10:10
Como a veces no se actualiza, 00:10:11
vamos a hacerlo 00:10:15
distinto. Que lo cierro 00:10:16
y lo vuelvo a abrir. 00:10:18
Ahora se va a dar cuenta que existe este controlador, que este controlador tiene esta etiqueta AFX y me debería decir, 00:10:20
ah, sí, ok, lo reconozco como una clase posible de controlador y que si tú la seleccionas, pues entonces yo sé que el controlador de esta interfaz es esta clase. 00:10:29
si esto lo reconoce 00:10:40
como ha pasado aquí, entonces cuando yo me voy 00:10:43
a un botón, selecciono el botón 00:10:45
y me voy al on action 00:10:47
él 00:10:49
me enseña 00:10:51
cuáles son los métodos que se pueden utilizar 00:10:53
al momento de hacer clic 00:10:56
¿vale? entonces por ejemplo 00:10:57
yo puedo pillar este de aquí y ahora 00:10:59
he apuntado que 00:11:01
esta interfaz tiene 00:11:03
una clase 00:11:05
controladora que es esta de aquí 00:11:07
Y, en particular, este botón, cuando lo clico, lo que hace es ejecutar este método. 00:11:09
Tened en cuenta que esto no se refleja en ningún lado aquí, por ahora. 00:11:16
Si lo busco, no veo nada de estas cosas, porque tengo que guardar todavía. 00:11:23
Entonces, guardo esto, vuelvo aquí, lo recargo en S5, o con un poco de suerte ya lo he hecho, 00:11:27
y si ahora voy a mirar, por algún lado veo esta referencia. 00:11:35
ahora tengo este botón 00:11:39
que al hacer on action 00:11:42
al hacer click pues llamará 00:11:44
este método de aquí 00:11:45
y aquí por algún lado 00:11:46
el controlador 00:11:49
de esta ventana 00:11:52
es esta clase de aquí 00:11:53
dudas 00:11:57
con esta cosa maravillosa si yo la lanzo 00:11:58
que pasa nada como siempre 00:12:04
vale porque mi main 00:12:06
todavía está cargando 00:12:08
esta ventana vacía 00:12:10
vale no está haciendo nada con este xml para que funcione este xml no tengo que crearme una 00:12:11
escena de esta forma mantengo que cargar este fichero de aquí vale ahora yo tengo mala memoria 00:12:21
siempre se me olvida como se carga por lo tanto lo uniré en otro proyecto pero vosotros lo aprendéis 00:12:30
memoria esta cosa aquí porque estas cosas de aquí lanzan a posibles excepciones por lo tanto esto es 00:12:37
protegido con un proyecto lo que yo quiero es esto vale este de aquí que es es un fichero es un 00:12:50
objeto de JavaFX que es fxmlLoader, el cargador de un objeto fxml, que 00:12:58
sustancialmente lo que me crea es un objeto Loader que con el método load 00:13:07
importa, lee, entiende, importa este xml. Este es un lenguaje xml, yo podría 00:13:12
esto editarlo a mano, pero tengo un editor visual, un editor gráfico, por lo tanto soy más feliz, 00:13:22
pero luego esta información de aquí tiene que ser procesada por alguien para que entienda que 00:13:30
esta de aquí es esta interfaz. Y quien lo hace es, a punto, este objeto de aquí. Me creo un nuevo 00:13:37
de este tipo y lo analizo al otro lado vale entonces esto lo pongo aquí 00:13:47
veis que el start pilla un objeto stage vale que aquí se llama primary stage mientras que aquí 00:13:59
estoy usando stage o cambio esto cambio esto pero sería este el objeto que quiero utilizar 00:14:06
entonces este de aquí es un cargador una cosa que puede cargar un este objeto de aquí fijaos 00:14:11
que esto se llama google.xml pero en mi proyecto yo lo llamando interfaz por lo tanto esto tendrá 00:14:22
que ser fichero interfaz si no me dice no consigo encontrar el fichero y luego un parent root esto 00:14:27
aquí es como el elemento raíz de mi interfaz. A partir de allí construiré todo el resto. Sería 00:14:36
este. En la jerarquía este señor de aquí. Esto sería mi root. Y cuando tú llamas el loader.load 00:14:44
lo que hace él es cargarte toda la interfaz leyendo este fichero de aquí y luego a partir 00:14:54
de haber leído este pichón aquí, te devuelve 00:15:01
un puntero 00:15:03
un handler 00:15:05
un elemento 00:15:06
un manejador 00:15:09
que me permite 00:15:10
que apunta 00:15:12
al objeto raíz 00:15:15
de mi interfaz 00:15:17
sustancialmente después de haberlo cargado 00:15:19
me devuelve un puntero 00:15:21
a este señor de aquí 00:15:23
para que yo lo pueda luego utilizar como decir 00:15:24
mira, ahora dibújame la interfaz 00:15:27
a partir de este 00:15:29
elemento 00:15:30
¿sí? ¿por qué? 00:15:32
porque cuando luego creo una 00:15:35
escena, ¿vale? 00:15:37
una escena se basa sobre 00:15:39
dame 00:15:40
un elemento raíz 00:15:41
a partir del que yo podré mirar 00:15:44
qué componentes has puesto tú dentro 00:15:47
yo por ejemplo he puesto dos botones 00:15:49
pero habría podido poner un tap panel 00:15:51
podría haber pues otra cosa, pero a partir 00:15:53
de este root, que es 00:15:55
digamos la raíz, yo podré tirar 00:15:57
diciendo dame sus hijos dame los que es como un contenedor dame los que el contenido y a 00:15:58
partir del contenido puede tirar el contenido del contenido del contenido de proteína y ir 00:16:04
dibujando todo pero todo tiene que empezar desde un punto y este es mi punto de empiezo digamos 00:16:08
para dibujar la la interfaz y el tamaño de la ventana que quiero crear vale os decía ayer que 00:16:13
Y JavaFX se usa como una analogía de un teatro. 00:16:24
Yo por un lado tengo un stage, que es el palco. 00:16:27
Y por otro lado tengo escenas. 00:16:34
Mis ventanas, mi interfaz, son escenas de un palco. 00:16:36
En cada momento yo puedo decir, mira, ahora va a empezar la escena A, 00:16:40
pues cárdala en el palco y que se vea. 00:16:46
Entonces yo tengo este stage hecho. 00:16:49
Voy a cargar esta escena creando una nueva escena basándome sobre la raíz que me ha dado el cargador del fichero XML y el tamaño que quiero que tenga esta escena. 00:16:52
Y a este punto, bueno, esto es opcional, le doy un título a lo que se ve ahora, ¿vale? 00:17:06
Y luego en el palco seto una determinada escena y la enseño, ¿vale? 00:17:15
Este de aquí será botones. 00:17:22
Entonces, si todo funciona ahora, pues me carga este fichero, 00:17:27
me lo selecciona como una escena y luego lo enseña en el barco. 00:17:32
¿Leí? 00:17:38
Vaya, una maravilla. 00:17:42
Fijaos que esto, botones, es esta cosa aquí. 00:17:43
Es el nombrecito que pongo a la venta. 00:17:49
Entonces, como ahora tengo dos botones y este botón de aquí 00:17:53
tenía también un método 00:17:56
del controlador, cuando yo 00:17:59
clico este botón de aquí, en teoría 00:18:00
me hace algo. 00:18:03
¿Dudas? 00:18:09
Este no hace 00:18:11
nada porque todavía no le he dicho que haga nada. 00:18:12
¿Eh? Vale. 00:18:15
¿Dudas? Hasta aquí. 00:18:17
No sé nunca dónde está. 00:18:22
¿Dónde está? 00:18:23
Ahí. 00:18:25
¿Por qué? 00:18:29
Pero si le cae información de un fichero, 00:18:30
eso también tiraría yo de la excepción. 00:18:32
no habría que meterlo dentro del try técnicamente yo creo que el quien lanza el este es sólo un 00:18:35
constructor vale el constructor pillará los recursos desde desde este fichero no sé si 00:18:45
este constructor lanza una excepción o no pero me da la impresión que no o que no sé o que sea 00:18:51
posible no controlarla vale el problema serio es cuando lo vas a utilizar es como si este aquí 00:18:57
se almacena hace por algún lado donde lo va a leer pero todavía no lo va a leer en el momento 00:19:04
en que lo lee es cuando efectivamente lo cargas entonces es aquí donde podría lanzar la ejecución 00:19:09
pero entonces muy bien por ahora me olvido del botón 2 lo que quiere que cuando pincho 00:19:16
el botón 1 haga algo y se sienta como aplicado entonces como yo quiero modificar este señor 00:19:32
quiero editar su contenido porque cuando lo pincho quiero que ponga click vale entonces 00:19:38
necesito una referencia el mismo entonces me voy a ir y lo llamo de alguna forma como ve uno si 00:19:44
alguno está sufriendo es normal vale lo estoy haciendo mal ya lo he dicho igual una vez guardado 00:19:55
aquí lo tengo que recargar fijaos que ahora se llama b1 este señor vale entonces desde el 00:20:08
controlador yo lo que puedo hacer es oye mira ahora tengo una referencia al botón 1 vale 00:20:16
entonces le puedo decir oye mira esta es como como lo hemos hecho hasta ayer más o menos aquí 00:20:22
yo tengo un botón B1, este botón de aquí es un JavaFX sin botón. Cuidado cuando importáis así 00:20:30
de leer bien, ¿vale? Porque hay otras clases que se llaman botón, como por ejemplo el Java AWT, 00:20:41
¿vale? Entonces, si importáis esto en vez que este de aquí, pues a lo mejor luego no nos funciona, 00:20:47
¿vale? Entonces, tengo este botón, lo que hago es que cuando se haga el clic 1, pues lo que quiero 00:20:52
hacer es cambiar este botón. Entonces b1 punto b para text, set text, set algo, set idea, set text, 00:20:59
set text, esto me podría funcionar y lo cambio a clicked. Vamos a ver si esto funciona. Lanzo, 00:21:16
tengo el botón 1, si lo pincho, clic. Fenomenal. Me gustaría también B1.7 enable, está enable, 00:21:31
no está, lo conseguiremos. Enable Focus, porque para darle este efecto de... 00:21:46
pero no lo encuentro 00:22:03
¿vale? 00:22:08
orden 00:22:11
estable 00:22:14
is disabled 00:22:15
is disabled 00:22:23
no sé muy bien 00:22:24
tiene que haber una 00:22:35
esta habría que verlo ¿vale? 00:22:37
porque normalmente los controles pueden ser deshabilitados aquí esto parece como deshabilitado 00:22:42
en el en el enunciado entonces la idea sería hacer clic y deshabilitarlo solo que no sé 00:22:48
exactamente cuál es el método 00:22:57
los estables 00:23:01
ay true 00:23:06
vamos a ver cómo funciona 00:23:10
y me queda como de solitaria no lo puedo explicar 00:23:16
muy bien esto funciona si todo perfecto entonces vosotros con los 150 botones que hacéis que 00:23:22
tenéis que hacéis pues hacéis esta cosa aquí le cambiáis todos los unos con dos 00:23:34
y ya está vais a este de aquí al botón 2 le dais el clic 2 y ya está ya lo he hecho lo 00:23:42
entrego y saco un cero. Muy bien. Esa era mi pregunta. ¿Esa era tu pregunta? Si sacas un cero, sí. 00:23:53
A ver, ha sido mi respuesta. A tu pregunta yo te he dicho, si me lo haces así, yo mañana te pido 00:24:03
150. Y si me salen los 150 así, yo te pido 1200. Pero los 1200 ya me pongo detrás tuya y miro que 00:24:11
lo hagas tú manualmente. Que a lo mejor luego lo pides a HGPT o a CERAVIL. 00:24:25
Ah, porque no he dado el nombre al botón 2. El botón 2 se debería llamar B2. Guardo aquí. Lo recargo. Estoy seguro de que se ha recargado. 00:24:41
Nada. Entonces, este de aquí es, digamos, lo que deberíais haber hecho vosotros en los 10 minutos que me he ido, ¿vale? En el sentido que con lo que sabéis hacer hasta ahora, con lo que hemos visto hasta ahora y con vuestra gran vaguería de no mirar en casa algo más que se podría hacer, pues esto es lo máximo que podríais hacer, ¿vale? 00:25:02
Ahora, como todas las cosas de este tipo, no es bueno, ¿vale? No es bonito, ¿vale? 00:25:31
¿En qué sentido? Cuando hay cosas iguales que se repiten, cuando vosotros os encontráis en un sitio donde habéis escrito un código 00:25:40
y lo vais a copiar igual, cambiando un numerito, pues lo más probable es que lo estéis haciendo mal, ¿vale? 00:25:50
en la idea es que mañana yo te digo mira en vez que cliquen de lo quiero yo es distinto lo quiero 00:26:01
poner de otra forma pues tú tienes que ir a cambiar todos estas cosas aquí ha puesto pico 00:26:08
no funciona además esto es un método único es está haciendo algo el solo entonces la idea de 00:26:13
que esté repetido etcétera habría que encontrar una forma para que esto sea un poquito más 00:26:21
genérico entonces nosotros hasta ahora hemos hecho métodos así pero yo hace aquí me permite 00:26:32
hacer métodos así. Esta cosa de aquí debería estar por algún lado. A ver cuál tendría que importar ahora. 00:26:46
Este señor de aquí es una pequeña maravilla de la naturaleza, que es cuando yo llamo este método 00:27:07
de aquí en vez de no tener parámetros va a tener un parámetro que es una acción de evento o sea 00:27:22
algo que ha pasado y esta cosa de aquí no se la tengo que pasar yo se va a encargar java fx con 00:27:31
todos los cableados que está porque tal que tiene por debajo de gestionar de tal forma que cuando se 00:27:42
llame este método de aquí el genere un objeto acción event que representa el evento que ha 00:27:49
causado ese clic o sea que este de aquí es un objeto que tendrá dentro información sobre la 00:27:59
la origen de ese evento que en automático se va a crear dentro la maquinaria de java fx para crear 00:28:08
un objeto con la información necesaria y me lo pasa a este método de aquí cuando se tiene que 00:28:19
ejecutar o sea que estos tipos de métodos de aquí se usan cuando lo importante es que haya pasado 00:28:26
un evento pero no me interesa tanto quien ha generado el evento o las características de 00:28:37
este evento. Me interesa que cuando se origina este evento, haz algo. Entonces no necesito 00:28:43
saber nada de información sobre quién lo ha hecho, cómo se ha hecho, por qué se ha 00:28:49
hecho. Sin embargo, otras veces yo puedo generar un controlador, un método, que pero dice 00:28:54
oye, mira, necesito saber quién ha hecho este evento. Necesito decir por qué ha salido 00:29:02
este evento, es decir, que ha pasado 00:29:08
¿sí? entonces 00:29:10
le pongo esta cosa aquí, esto 00:29:12
luego no lo tengo que rellenar yo 00:29:14
me lo rellena automáticamente yo a hacer 00:29:16
¿sí? 00:29:18
una vez que yo estoy aquí dentro, puedo hacer 00:29:23
algo con este 00:29:25
e. ¿vale? 00:29:26
y si os fijáis 00:29:29
hay unas cuantas opciones 00:29:30
en particular 00:29:32
este señor, getSource 00:29:34
o sea 00:29:36
pillar la origen 00:29:38
GetSource me devuelve un objeto, un object en general, pero en particular se va a leer que es 00:29:40
the object on which the event initially occurred. 00:29:50
Esto es el objeto sobre el que ha pasado algo que me lo devuelve. 00:29:55
En nuestro caso, si este de aquí se lo ponga un botón, esta cosa de aquí será un botón. 00:30:02
Por ahora. Escribamos este. Entonces, ¿cómo lo cambiamos? Pues, acordaos, si no, no se da cuenta que lo puedo utilizar al otro lado. 00:30:07
Guardo esta cosa aquí, me voy aquí y digo, mira, al botón, en vez de darle el B1, no, perdón, en vez de darle el click 1, que era el que solo funciona con el botón 1, le voy a dar click, que es el general, el genérico. 00:30:29
Vamos a ver qué hace. 00:30:52
Sabe. 00:30:55
Vuelvo aquí. 00:30:57
Recargo esta cosa. 00:30:59
Lo lanzo. 00:31:01
Y ahora sigo teniendo el botón 2 que funciona consigo mismo. 00:31:03
Pero el botón 1, cuando lo pincho, me lanza esto. 00:31:08
Lo veis que la origen es un botón de identificador B1. 00:31:12
Que me está identificando el botón que se ha pinchado. 00:31:19
Entonces, con esta cosa mágica aquí, yo ya no necesito tener B1, B2, B3. 00:31:26
Puedo borrar toda esta cosa aquí. 00:31:33
Tener solo este método de aquí. 00:31:38
Y a través de este, saber si es aplicado con el botón 1 o con el botón 2. 00:31:41
¿Cómo? 00:31:48
Sí. 00:31:49
Pero en este builder, por cada botón que tú crees, el ID del botón tienes que ponerle B1, B2, B3. 00:31:49
No. Ahora lo hacemos. 00:31:58
Button B es igual a A, A. Button de E.de. 00:32:03
Esto, independientemente de quién haya generado este objeto, me lo pillará. 00:32:10
y como yo esta cosa aquí la doy 00:32:20
solo a los botones, sé que son botones 00:32:22
si yo hiciera esto dándoselo 00:32:24
a un botón y a otros elementos pues 00:32:26
esto sería más complejo de organizar 00:32:28
a lo mejor debería hacer un 00:32:30
instance of o cosas por el estilo 00:32:32
pero como ahora se lo estoy dando solo a botones 00:32:34
pues no me importa 00:32:37
le digo, mira, pilla el origen 00:32:38
es un objeto, este objeto es un botón 00:32:40
lo hemos visto aquí que es un botón 00:32:43
¿vale? 00:32:44
entonces, este botón 00:32:46
me lo pones aquí y es el botón B 00:32:48
Y ahora, a este botón de aquí, le cambias el text con clicker y luego lo desactivas. 00:32:50
Me da aceptable, que busca aceptable en vez de aceptable. Justo. Esto ahora es un método que no 00:33:02
me depende de crear al botón 1 ponerle botón 1, al botón 2 ponerle botón 2, al botón 3 botón 2, 00:33:19
porque no está usando un identificador. De hecho, yo puedo irme aquí y quitarse los identificadores. 00:33:25
Ya no me sirven los identificadores. Y esto, todos los botones tendrán el mismo action click. 00:33:34
Guardo, espero no explote, voy aquí, lo recargo bien esta cosa aquí, veo que ahora ningún botón tiene un 00:33:48
identificador y lo que pasará ahora es que cuando lo lanzó al hacer clic ese 00:33:56
botón generará un evento este evento me dará la como source ese botón concreto y 00:34:03
ese cambiará y ese cambiará ese se declara independientemente es lo absoluto 00:34:09
sólo un sueldo entiende ahora con poca suerte que no sé si lo hará esto 00:34:15
Si yo lo copio este de aquí, veis que me viene ya, y yo en realidad a estos de aquí no le tengo que hacer mucho, no le tengo que poner ni identificador ni nada, lo único que tengo que hacer es que tenga un action click. 00:34:24
Y yo puedo hacer cuantas copias me da la gana, este de aquí, y esto ya funcionará. 00:34:40
Ahora se llaman todos botón 2, pero... 00:34:49
Entonces, ahora yo guardo, vuelvo aquí, aquí están todas estas maravillas de aquí, ahora 00:34:50
lo lanzo y esto ya funciona, o sea, esto, cuando pinche el que pinche, si yo pillara 00:35:01
este button, le hago un extend y me creo button mina, que tiene sus parámetros para saber 00:35:14
si tiene una mina o no, pues ya me estoy acercando al Buscaminas. Luego tendré que hacer un 00:35:23
array o algo por el estilo para distribuir las minas, para hacer la parte más difícil 00:35:34
del Buscaminas, que es que cuando le doy un clic a un sitio que no hay mina, me tiene 00:35:39
que mirar alrededor cuántas minas hay. Esa es la parte más difícil del Buscaminas. 00:35:44
O en la funcionalidad esta que cuando pincho en una casilla que tiene cero minas, pues me abre todas las que están alrededor. 00:35:52
Esto es un poco de flexibilidad y un poco de baile, forre, cosas por el estilo. 00:36:01
Pero, ahora los mecanismos gráficos para hacerlos ya los tengo. 00:36:09
Lo único que me falta ahora es paciencia y gana para hacer toda la parte detrás del algoritmo. 00:36:16
Da igual. Lo que pasa aquí ahora nosotros es que estos botones de aquí, si tú quieres poner 100 00:36:26
botones, no puedes ponerlos de uno en uno manualmente. Deberías hacer, parecido al 00:36:39
main que nos crea él, pues un bucle que te cree todos los botones uno al lado de otro. 00:36:46
y nosotros por ahora no lo hacemos porque no nos interesa ese tipo de interfaz o nos interesa más 00:36:52
los interfaces gestionales que hacemos con este vas aquí bueno también no sé yo sí 00:36:57
hay una fila y luego la selección pero el problema es que si lo haces así a lo mejor 00:37:07
puedes hacer un campo 100% ya por 10 vale con 100 botones ok es ese campo allí no lo puedes 00:37:17
modificar lo bonito a nivel de programación podría ser hacer estas cosas de aquí con 00:37:23
tú dices qué tamaño quieres que era un 5 x 5 un 20 x 20 00:37:32
de esta clase concreta dudas vale entonces lo que hemos aprendido ahora es que hay 00:37:37
dos tipos de métodos que hacen de controlador de un evento. Hay los métodos que no le interesa 00:37:54
nada de la información del evento, le interesa sólo que el evento se haya verificado, que son 00:38:08
los que no tienen 00:38:16
esto 00:38:17
y los que en vez dicen, oye, mira, no 00:38:19
necesito más información sobre el 00:38:22
evento, al menos saber quién ha lanzado 00:38:24
este evento para poder hacer algo 00:38:26
sobre ese 00:38:28
en concreto. 00:38:29
¿Sí? Y podéis 00:38:32
usar los dos, dependiendo de cuál queréis 00:38:34
utilizar. Si lo usáis mal, 00:38:36
os suspendo. 00:38:38
¿Sí? 00:38:40
¿Sí? 00:38:40
Gracias. 00:38:47
Materias:
Programación
Niveles educativos:
▼ Mostrar / ocultar niveles
  • Formación Profesional
    • Ciclo formativo de grado superior
      • Primer Curso
Autor/es:
Stefano Chiesa
Subido por:
Stefano C.
Licencia:
Reconocimiento - No comercial
Visualizaciones:
3
Fecha:
15 de abril de 2026 - 12:22
Visibilidad:
Clave
Centro:
IES ROSA CHACEL
Duración:
38′ 48″
Relación de aspecto:
1.78:1
Resolución:
1920x1080 píxeles
Tamaño:
325.52 MBytes

Del mismo autor…

Ver más del mismo autor

EducaMadrid, Plataforma Educativa de la Comunidad de Madrid

Plataforma Educativa EducaMadrid