-
101 | *
- 'c' (CENTER): Contenido centrado (por defecto). 102 | *
- 't' (TOP): Contenido centrado con texto arriba de una imágen. 103 | *
- 'l' (LEFT): Contenido en la izquierda [Si tiene imágen y texto la imágen se posiciona primero]. 104 | *
- 'r' (RIGHT): Contenido en la derecha [Si tiene imágen y texto el texto se posiciona primero]. 105 | *
- 'b' (BOTTOM): Contenido centrado con texto abajo de una imágen. 106 | *
-
217 | *
- 'l' (LEFT): Contenido en la izquierda (por defecto). 218 | *
- 'c' (CENTER): Contenido centrado [Si tiene imágen y texto la imágen se posiciona primero]. 219 | *
- 't' (TOP): Contenido centrado con texto arriba de una imágen. 220 | *
- 'r' (RIGHT): Contenido en la derecha [Si tiene imágen y texto el texto se posiciona primero]. 221 | *
- 'b' (BOTTOM): Contenido centrado con texto abajo de una imágen. 222 | *
-
280 | *
- 'l' (LEFT): Contenido en la izquierda (por defecto). 281 | *
- 'c' (CENTER): Contenido centrado. 282 | *
- 'r' (RIGHT): Contenido en la derecha. 283 | *
-
327 | *
- 'l' (LEFT): Contenido en la izquierda (por defecto). 328 | *
- 'c' (CENTER): Contenido centrado. 329 | *
- 'r' (RIGHT): Contenido en la derecha. 330 | *
-
402 | *
- 'l' (LEFT): Contenido en la izquierda (por defecto). 403 | *
- 'c' (CENTER): Contenido centrado. 404 | *
- 'r' (RIGHT): Contenido en la derecha. 405 | *
23 | 
24 |
26 |
27 | # Eventos de Mouse
28 |
29 | A continuación se mostrará el uso de los eventos del Mouse y estos están divididos en 3 grandes grupos, estos grupos se derivan de las diferentes interfaces que se ocupan de la escucha de eventos por Mouse:
30 |
31 | * **Eventos MouseListener**
32 | * **Eventos MouseMotionListener**
33 | * **Eventos MouseWheelListener**
34 |
35 | Esta sesión se concentra en identificar las características de todos los métodos implementados por cada uno de los 3 grandes grupos para lo cual se va a construir el componente **configuraciones**. Dentro de este, se experimentará con cada uno de los eventos y asi reconocer cuando usar cada evento, como se activan, en que momento dejan de funcionar, casos particulares etc.
36 | Una vez reconocida la función de cada tipo de evento en la siguiente lección se identificarán las partes en el proyecto donde será util implementar estos eventos para darle más interactividad a la aplicación.
37 |
38 | ***Nota:** Estos eventos tienen la particularidad de ser usados comúnmente para una alta variedad de objetos gráficos a diferencia de los eventos por acción donde casi siempre suele usarse exclusivamente a los botones. Los eventos de Mouse buscan darle interactividad a más objetos gráficos.*
39 |
40 | # Construcción Componente Gráfico Configuraciones
41 |
42 | En esta sección se va a ver de manera rápida la construcción del componente **configuraciones** que va a servir como medio para poder reconocer las características de cada uno de los eventos. Cuando hablamos de eventos por Mouse un aspecto importante a resaltar es el **posicionamiento del puntero**, este sera el enfoque con el cual se va a identificar las características de cada tipo de evento.
43 |
44 | Para lo anterior el componente **Configuraciones** va tomar el papel de una herramienta para configuración de la sensibilidad y funcionamiento del Mouse, donde el usuario podrá interactuar a manera de prueba con el mouse sobre un panel y comprobar que este funciona adecuadamente.
45 |
46 | El componente **Configuraciones** contendrá:
47 |
48 | * **Panel de interacción:** Un panel vacío que tendrá las propiedades de interactividad con las que el usuario podrá probar su Mouse.
49 | * **Panel de control:** Un panel que contiene una serie de **JLabels** y que le darán al usuario información importante relacionada con el posicionamiento del puntero del mouse y entre varios de sus datos esta:
50 | * Posición (x,y) una vez se realiza un click.
51 | * Posición (x,y) una vez se presiona el botón izquierdo del mouse.
52 | * Posición (x,y) una vez se suelta el botón izquierdo del mouse.
53 | * Posición (x,y) en tiempo real del puntero del Mouse.
54 | * Posición (x,y) en tiempo real del puntero del Mouse una vez se tiene presionado el botón izquierdo del mouse.
55 | * La cantidad de Zoom hacia el panel una vez se mueve el scroll del mouse.
56 | * El estado de **Adentro o Afuera** del mouse con respecto al panel de interacción.
57 |
58 | ## Construcción de objetos gráficos dentro de Configuraciones
59 |
60 | El componente **Configuraciones** puede ser visible en pantalla gracias a la gestión de **navegación** realizada en previas lecciones por lo que se puede directamente iniciar con la construcción del componente, en la clase **configuracionesTemplate** primero se van a obtener los servicios **ObjGraficosService** y **RecursosService** para la creación los objetos gráficos:
61 |
62 | * **Declaración:**
63 | ```javascript
64 | private ObjGraficosService sObjGraficos;
65 | private RecursosService sRecursosService;
66 | ```
67 |
68 | * **Obtención de servicios:**
69 | ```javascript
70 | // Dentro del constructor
71 | sObjGraficos = ObjGraficosService.getService();
72 | sRecursosService = RecursosService.getService();
73 | ```
74 |
75 | Ahora se da un cambio de color al componente:
76 | ```javascript
77 | // Dentro del constructor
78 | this.setBackground(sRecursosService.getColorGrisClaro());
79 | ```
80 |
81 | ## Objetos Decoradores
82 |
83 | A continuación se muestra la creación de los objetos decoradores necesarios, en este caso solo se creara un **Cursor**:
84 |
85 | * **Declaración:**
86 | ```javascript
87 | private Cursor cCruz;
88 | ```
89 |
90 | * **método CrearObjetosDecoradores:**
91 | ```javascript
92 | public void crearObjetosDecoradores(){
93 | this.cCruz = new Cursor(Cursor.CROSSHAIR_CURSOR);
94 | }
95 | ```
96 |
97 | * **llamada del método dentro del constructor:**
98 | ```javascript
99 | // Dentro del constructor
100 | this.crearObjetosDecoradores();
101 | ```
102 |
103 | ## Paneles
104 |
105 | A continuación se muestra la creación de los paneles necesarios para realizar la funcionalidad del componente.
106 |
107 | * **Declaración:**
108 | ```javascript
109 | private JPanel pDibujo, pDatos;
110 | ```
111 |
112 | * **método crearJPanels:**
113 | ```javascript
114 | public void crearJPanels(){
115 | // PANEL P-DIBUJO---------------------------------
116 | pDibujo = sObjGraficos.construirJPanel(
117 | 15, 15, 500, 570,
118 | Color.WHITE,
119 | sRecursosService.getBorderGris()
120 | );
121 | pDibujo.setCursor(cCruz);
122 | this.add(pDibujo);
123 |
124 | // PANEL P-DATOS---------------------------------
125 | pDatos = sObjGraficos.construirJPanel(
126 | 530, 15, 305, 570,
127 | Color.WHITE,
128 | sRecursosService.getBorderGris()
129 | );
130 | this.add(pDatos);
131 | }
132 | ```
133 | Note que al panel de interacción pDibujo se le agrega el cursor previamente creado mediante el método de configuración **setCursor**.
134 |
135 | * **llamada del método dentro del constructor:**
136 | ```javascript
137 | // Dentro del constructor
138 | this.crearJPanels();
139 | ```
140 |
141 | Hasta el momento el componente se ve asi:
142 |
143 |
24 | Resultado de construcción de componente Inicio
25 |
144 | 
145 |
147 |
148 | ## Labels
149 |
150 | A continuación se muestra la creación de los **JLabel** necesarios para la funcionalidad del componente, en este caso se va crear una gran cantidad de JLabels, así que estos serán divididos en 2 categorías:
151 |
152 | * **Labels Estáticos:** Son aquellos que representan información que no va a cambiar con el tiempo, pueden ser títulos, indicaciones etc.
153 | * **Labels Dinámicos:** Son aquellos que representan valores y que con seguridad va a cambiar su contenido a medida que el usuarió interactué.
154 |
155 | Es decir que se va a realizar la modularizacion de código con los JLabel a través de 2 métodos **crearJLabelsEstaticos** y **crearJLabelsDinamicos**.
156 |
157 | * **Declaración:**
158 | ```javascript
159 | // Declaración Labels Estáticos
160 | private JLabel lTitulo, lTituloPosicion, lTituloEstado;
161 | private JLabel lPOnClickX, lPOnClickY, lPInicialX, lPInicialY, lPFinalX, lPFinalY;
162 | private JLabel lPActualX, lPActualY, lLadoX, lLadoY, lZoom, lEstado;
163 |
164 | // Declaración Labels Dinámicos
165 | private JLabel lPOnClickXValor, lPOnClickYValor, lPInicialXValor, lPInicialYValor;
166 | private JLabel lPFinalXValor, lPFinalYValor, lPActualXValor, lPActualYValor;
167 | private JLabel lLadoXValor, lLadoYValor, lZoomValor, lEstadoValor;
168 | ```
169 |
170 | * **Método crearJLabelsEstaticos:**
171 | ```javascript
172 | public void crearJLabelsEstaticos(){
173 | // LABEL TITULO -------------------------------------------------------------------------
174 | lTitulo = sObjGraficos.construirJLabel(
175 | "Datos de Eventos",
176 | (this.pDatos.getWidth() - 200) / 2, 15, 200, 40,
177 | null, null,
178 | sRecursosService.getFontTitulo(),
179 | null,
180 | sRecursosService.getColorPrincipal(),
181 | null,
182 | "c"
183 | );
184 | pDatos.add(lTitulo);
185 |
186 | // LABEL TITULO POSICIÓN-----------------------------------------------------------------
187 | lTituloPosicion = sObjGraficos.construirJLabel(
188 | "Datos de Posiciones",
189 | 20, 60, 180, 40,
190 | null, null,
191 | sRecursosService.getFontTitulo(),
192 | null,
193 | sRecursosService.getColorSecundario(),
194 | null,
195 | "l"
196 | );
197 | pDatos.add(lTituloPosicion);
198 |
199 | // LABEL TITULO ESTADO--------------------------------------------------------------------
200 | lTituloEstado = sObjGraficos.construirJLabel(
201 | "Datos de Estado",
202 | 20, 440, 180, 40,
203 | null, null,
204 | sRecursosService.getFontTitulo(),
205 | null,
206 | sRecursosService.getColorSecundario(),
207 | null,
208 | "l"
209 | );
210 | pDatos.add(lTituloEstado);
211 |
212 | // LABEL POSICIÓN EN X CON CLICK----------------------------------------------------------
213 | lPOnClickX = sObjGraficos.construirJLabel(
214 | "Posición en X al dar click: ",
215 | 40, 100, 160, 40,
216 | null, null,
217 | sRecursosService.getFontLigera(),
218 | null,
219 | sRecursosService.getColorPrincipal(),
220 | null,
221 | "l"
222 | );
223 | pDatos.add(lPOnClickX);
224 |
225 | // LABEL POSICIÓN EN Y CON CLICK----------------------------------------------------------
226 | lPOnClickY = sObjGraficos.construirJLabel(
227 | "Posición en Y al dar click: ",
228 | 40, 120, 160, 40,
229 | null, null,
230 | sRecursosService.getFontLigera(),
231 | null,
232 | sRecursosService.getColorPrincipal(),
233 | null,
234 | "l"
235 | );
236 | pDatos.add(lPOnClickY);
237 |
238 | // LABEL POSICIÓN EN X INICIAL----------------------------------------------------------
239 | lPInicialX = sObjGraficos.construirJLabel(
240 | "Posición en X inicial: ",
241 | 40, 160, 160, 40,
242 | null, null,
243 | sRecursosService.getFontLigera(),
244 | null,
245 | sRecursosService.getColorPrincipal(),
246 | null,
247 | "l"
248 | );
249 | pDatos.add(lPInicialX);
250 |
251 | // LABEL POSICIÓN EN Y INICIAL----------------------------------------------------------
252 | lPInicialY = sObjGraficos.construirJLabel(
253 | "Posición en Y inicial: ",
254 | 40, 180, 160, 40,
255 | null, null,
256 | sRecursosService.getFontLigera(),
257 | null,
258 | sRecursosService.getColorPrincipal(),
259 | null,
260 | "l"
261 | );
262 | pDatos.add(lPInicialY);
263 |
264 | // LABEL POSICIÓN EN X FINAL----------------------------------------------------------
265 | lPFinalX = sObjGraficos.construirJLabel(
266 | "Posición en X final: ",
267 | 40, 220, 160, 40,
268 | null, null,
269 | sRecursosService.getFontLigera(),
270 | null,
271 | sRecursosService.getColorPrincipal(),
272 | null,
273 | "l"
274 | );
275 | pDatos.add(lPFinalX);
276 |
277 | // LABEL POSICIÓN EN Y FINAL----------------------------------------------------------
278 | lPFinalY = sObjGraficos.construirJLabel(
279 | "Posición en Y final: ",
280 | 40, 240, 160, 40,
281 | null, null,
282 | sRecursosService.getFontLigera(),
283 | null,
284 | sRecursosService.getColorPrincipal(),
285 | null,
286 | "l"
287 | );
288 | pDatos.add(lPFinalY);
289 |
290 | // LABEL POSICIÓN EN X ACTUAL----------------------------------------------------------
291 | lPActualX = sObjGraficos.construirJLabel(
292 | "Posición en X actual: ",
293 | 40, 280, 160, 40,
294 | null, null,
295 | sRecursosService.getFontLigera(),
296 | null,
297 | sRecursosService.getColorPrincipal(),
298 | null,
299 | "l"
300 | );
301 | pDatos.add(lPActualX);
302 |
303 | // LABEL POSICIÓN EN Y ACTUAL----------------------------------------------------------
304 | lPActualY = sObjGraficos.construirJLabel(
305 | "Posición en Y actual: ",
306 | 40, 300, 160, 40,
307 | null, null,
308 | sRecursosService.getFontLigera(),
309 | null,
310 | sRecursosService.getColorPrincipal(),
311 | null,
312 | "l"
313 | );
314 | pDatos.add(lPActualY);
315 |
316 | // LABEL LADO EN X -------------------------------------------------------------------
317 | lLadoX = sObjGraficos.construirJLabel(
318 | "Valor lado X: ",
319 | 40, 340, 160, 40,
320 | null, null,
321 | sRecursosService.getFontLigera(),
322 | null,
323 | sRecursosService.getColorPrincipal(),
324 | null,
325 | "l"
326 | );
327 | pDatos.add(lLadoX);
328 |
329 | // LABEL LADO EN Y --------------------------------------------------------------------
330 | lLadoY = sObjGraficos.construirJLabel(
331 | "Valor lado Y: ",
332 | 40, 360, 160, 40,
333 | null, null,
334 | sRecursosService.getFontLigera(),
335 | null,
336 | sRecursosService.getColorPrincipal(),
337 | null,
338 | "l"
339 | );
340 | pDatos.add(lLadoY);
341 |
342 | // LABEL ZOOM --------------------------------------------------------------------------
343 | lZoom = sObjGraficos.construirJLabel(
344 | "Zoom en el panel: ",
345 | 40, 400, 160, 40,
346 | null, null,
347 | sRecursosService.getFontLigera(),
348 | null,
349 | sRecursosService.getColorPrincipal(),
350 | null,
351 | "l"
352 | );
353 | pDatos.add(lZoom);
354 |
355 | // LABEL ESTADO ------------------------------------------------------------------------
356 | lEstado = sObjGraficos.construirJLabel(
357 | "Estado: ",
358 | 40, 480, 160, 40,
359 | null, null,
360 | sRecursosService.getFontLigera(),
361 | null,
362 | sRecursosService.getColorPrincipal(),
363 | null,
364 | "l"
365 | );
366 | pDatos.add(lEstado);
367 | }
368 | ```
369 |
370 | * **Método crearJLabelsDinamicos:**
371 | ```javascript
372 | public void crearJLabelsDinamicos() {
373 | // LABEL POSICIÓN EN X CON CLICK VALOR -----------------------------------------------------
374 | lPOnClickXValor = sObjGraficos.construirJLabel(
375 | "0",
376 | 200, 100, 160, 40,
377 | null, null,
378 | sRecursosService.getFontLigera(),
379 | null,
380 | sRecursosService.getColorPrincipal(),
381 | null,
382 | "l"
383 | );
384 | pDatos.add(lPOnClickXValor);
385 |
386 | // LABEL POSICIÓN EN Y CON CLICK VALOR -----------------------------------------------------
387 | lPOnClickYValor = sObjGraficos.construirJLabel(
388 | "0",
389 | 200, 120, 160, 40,
390 | null, null,
391 | sRecursosService.getFontLigera(),
392 | null,
393 | sRecursosService.getColorPrincipal(),
394 | null,
395 | "l"
396 | );
397 | pDatos.add(lPOnClickYValor);
398 |
399 | // LABEL POSICIÓN EN X INICIAL VALOR -----------------------------------------------------
400 | lPInicialXValor = sObjGraficos.construirJLabel(
401 | "0",
402 | 200, 160, 160, 40,
403 | null, null,
404 | sRecursosService.getFontLigera(),
405 | null,
406 | sRecursosService.getColorPrincipal(),
407 | null,
408 | "l"
409 | );
410 | pDatos.add(lPInicialXValor);
411 |
412 | // LABEL POSICIÓN EN Y INICIAL VALOR -----------------------------------------------------
413 | lPInicialYValor = sObjGraficos.construirJLabel(
414 | "0",
415 | 200, 180, 160, 40,
416 | null, null,
417 | sRecursosService.getFontLigera(),
418 | null,
419 | sRecursosService.getColorPrincipal(),
420 | null,
421 | "l"
422 | );
423 | pDatos.add(lPInicialYValor);
424 |
425 | // LABEL POSICIÓN EN X FINAL VALOR -----------------------------------------------------
426 | lPFinalXValor = sObjGraficos.construirJLabel(
427 | "0",
428 | 200, 220, 160, 40,
429 | null, null,
430 | sRecursosService.getFontLigera(),
431 | null,
432 | sRecursosService.getColorPrincipal(),
433 | null,
434 | "l"
435 | );
436 | pDatos.add(lPFinalXValor);
437 |
438 | // LABEL POSICIÓN EN Y FINAL VALOR -----------------------------------------------------
439 | lPFinalYValor = sObjGraficos.construirJLabel(
440 | "0",
441 | 200, 240, 160, 40,
442 | null, null,
443 | sRecursosService.getFontLigera(),
444 | null,
445 | sRecursosService.getColorPrincipal(),
446 | null,
447 | "l"
448 | );
449 | pDatos.add(lPFinalYValor);
450 |
451 | // LABEL POSICIÓN EN X ACTUAL VALOR -----------------------------------------------------
452 | lPActualXValor = sObjGraficos.construirJLabel(
453 | "0",
454 | 200, 280, 160, 40,
455 | null, null,
456 | sRecursosService.getFontLigera(),
457 | null,
458 | sRecursosService.getColorPrincipal(),
459 | null,
460 | "l"
461 | );
462 | pDatos.add(lPActualXValor);
463 |
464 | // LABEL POSICIÓN EN Y ACTUAL VALOR -----------------------------------------------------
465 | lPActualYValor = sObjGraficos.construirJLabel(
466 | "0",
467 | 200, 300, 160, 40,
468 | null, null,
469 | sRecursosService.getFontLigera(),
470 | null,
471 | sRecursosService.getColorPrincipal(),
472 | null,
473 | "l"
474 | );
475 | pDatos.add(lPActualYValor);
476 |
477 | // LABEL LADO EN X VALOR --------------------------------------------------------------
478 | lLadoXValor = sObjGraficos.construirJLabel(
479 | "0",
480 | 200, 340, 160, 40,
481 | null, null,
482 | sRecursosService.getFontLigera(),
483 | null,
484 | sRecursosService.getColorPrincipal(),
485 | null,
486 | "l"
487 | );
488 | pDatos.add(lLadoXValor);
489 |
490 | // LABEL LADO EN Y VALOR ---------------------------------------------------------------
491 | lLadoYValor = sObjGraficos.construirJLabel(
492 | "0",
493 | 200, 360, 160, 40,
494 | null, null,
495 | sRecursosService.getFontLigera(),
496 | null,
497 | sRecursosService.getColorPrincipal(),
498 | null,
499 | "l"
500 | );
501 | pDatos.add(lLadoYValor);
502 |
503 | // LABEL ZOOM VALOR ----------------------------------------------------------------------
504 | lZoomValor = sObjGraficos.construirJLabel(
505 | "0",
506 | 200, 400, 160, 40,
507 | null, null,
508 | sRecursosService.getFontLigera(),
509 | null,
510 | sRecursosService.getColorPrincipal(),
511 | null,
512 | "l"
513 | );
514 | pDatos.add(lZoomValor);
515 |
516 | // LABEL ESTADO VALOR -------------------------------------------------------------------
517 | lEstadoValor = sObjGraficos.construirJLabel(
518 | "NINGUNO",
519 | 80, 520, 160, 40,
520 | null, null,
521 | sRecursosService.getFontTitulo(),
522 | null,
523 | sRecursosService.getColorPrincipal(),
524 | null,
525 | "l"
526 | );
527 | pDatos.add(lEstadoValor);
528 | }
529 | ```
530 |
531 | * **llamada de métodos dentro del constructor:**
532 | ```javascript
533 | // Dentro del Constructor
534 | this.crearJLabelsEstaticos();
535 | this.crearJLabelsDinamicos();
536 | ```
537 |
538 | Al ejecutar la aplicación, el componente **Configuraciones** se vera de la siguiente manera:
539 |
540 |
145 | Componente Configuraciones con los paneles creados
146 |
541 | 
542 |
544 |
545 | Por ultimo y para acabar con la clase **Template** del componente **Configuraciones** se crean los métodos **get** necesarios, en este caso se crean unicamente para los **JLabel dinámicos**:
546 |
547 | ```javascript
548 | public JLabel getLPOnClickXValor() { return lPOnClickXValor; }
549 |
550 | public JLabel getLPOnClickYValor() { return lPOnClickYValor; }
551 |
552 | public JLabel getLPInicialXValor() { return lPInicialXValor; }
553 |
554 | public JLabel getLPInicialYValor() { return lPInicialYValor; }
555 |
556 | public JLabel getLPFinalXValor() { return lPFinalXValor; }
557 |
558 | public JLabel getLPFinalYValor() { return lPFinalYValor; }
559 |
560 | public JLabel getLPActualXValor() { return lPActualXValor; }
561 |
562 | public JLabel getLPActualYValor() { return lPActualYValor; }
563 |
564 | public JLabel getLLadoXValor() { return lLadoXValor; }
565 |
566 | public JLabel getLLadoYValor() { return lLadoYValor; }
567 |
568 | public JLabel getLZoomValor() { return lZoomValor; }
569 |
570 | public JLabel getLEstadoValor() { return lEstadoValor; }
571 | ```
572 |
573 | # Eventos MouseListener
574 |
575 | Dentro de la clase **ConfiguracionesComponent** específicamente en la declaración de la clase se va a implementar de la interfaz **MouseListener**:
576 |
577 |
542 | Componente Configuraciones con la creación de todos los JLabels
543 |
578 | 
579 |
581 |
582 | ***Nota:** Se debe tener en cuenta la importación de las librerías que soporta la implementación de la interfaz.*
583 |
584 | Al igual que con la implementación de la interfaz **ActionListener** esta va a pedir que se importen todos los métodos por defecto, por lo general el mismo editor de código va a mostrar el error y va a sugerir la importación automática de estos.
585 |
586 |
579 | Implementación de la interfaz MouseListener en la clase ConfiguracionesComponent
580 |
587 | 
588 |
590 |
591 | Se puede observar que esta vez la interfaz **MouseListener** implementa un total de 5 métodos por defecto y cada uno de ellos será explicado en esta sección.
592 |
593 | Antes de continuar con la explicación se debe adicionar la capacidad de escuchar los eventos tipo **MouseListener** al panel de interacción **pDibujo**, el proceso es muy parecido a cuando se agregaba un **ActionListener** solo que esta vez se usa el método **addMouseListener**:
594 | ```javascript
595 | // Dentro del método crearJPanels
596 | pDibujo.addMouseListener(this.configuracionesComponent);
597 | ```
598 |
599 | Como la clase **configuracionesComponent** implementa de la interfaz **MouseListener** es posible pasar como argumento el objeto de esta clase igual como se haría con una clase que implementa un **ActionListener**.
600 |
601 | ***Nota:** Como este método hace parte de la etapa de configuración debe ir entre la construcción del panel y la adición de este en el componente.*
602 |
603 |
588 | Métodos implementados por defecto de la interfaz MouseListener
589 |
604 | 
605 |
607 |
608 | ## MouseClicked
609 |
610 | Un evento **MouseClicked** se activa una vez el usuario da un "**Click**" en el objeto gráfico al cual fue proporcionado la adición del **MouseListener** en este caso el panel de interacción **pDibujo**. Cuando se menciona hacer un "*Click*" se hace referencia a la acción de **Oprimir** el botón del Mouse (por lo general el botón izquierdo) y luego **Soltarlo**.
611 |
612 | Esto tiene varias implicaciones, por ejemplo si se **oprime** el botón del Mouse, luego se **arrastra** el Mouse manteniendo oprimido el botón y luego se **suelta**, este ya no va a funcionar. Es decir que para que se considere que se ha dado un **click** el Mouse se debe mantener en la misma posición una vez se **presiona** y se **suelta**.
613 |
614 | Se procede a configurar el evento, en este caso se quiere que cuando el usuario de un **Click** sobre el panel de interacción **pDibujo**, se muestre las coordenadas en X,Y de donde estaba el puntero al momento de realizar esa acción. Para esto se debe mostrar esos valores en los labels **lPOnClickXValor** y **lPOnClickYValor**.
615 |
616 | Existen dos métodos para encontrar la coordenada del puntero una vez se realiza una acción, es necesario usar el objeto recibido como parámetro **MouseEvent** para hacer esto, los métodos en cuestión son:
617 |
618 | * **e.getX() / e.getY():** Que darán la coordenada del puntero cuando se activo la acción en X o en Y con respecto al objeto gráfico que activo la función.
619 | * **e.getXOnScreen() / e.getYOnScreen():** Que darán la coordenada del puntero cuando se activo la acción en X o en Y con respecto a la pantalla total del monitor del usuario.
620 |
621 | Hay que tener esto en cuenta ya que ambos métodos arrojaran datos diferentes debido a la perspectiva como se puede evidenciar en la siguiente imagen:
622 |
623 |
605 | Método de configuración entre su construcción y su agregación
606 |
624 | 
625 |
627 |
628 | Por ahora solo es de interés la posición con respecto al objeto gráfico que activa la acción (**pDibujo**) por lo que se va a usar unicamente los métodos **e.getX() / e.getY()**.
629 |
630 | * Como se quiere cambiar el texto de los Labels **lPOnClickXValor y lPOnClickYValor** se obtienen a través del objeto que referencia a la clase **Template** y sus métodos **get** correspondientes:
631 | ```javascript
632 | public void mouseClicked(MouseEvent e) {
633 | this.configuracionesTemplate.getLPOnClickXValor();
634 | this.configuracionesTemplate.getLPOnClickYValor();
635 | }
636 | ```
637 |
638 | * Se le indica ahora que va a cambiar el texto con el método:
639 | * **setText():** Que recibe como parámetro un String y representa el nuevo texto que tendrá el Label.
640 | ```javascript
641 | public void mouseClicked(MouseEvent e) {
642 | this.configuracionesTemplate.getLPOnClickXValor().setText();
643 | this.configuracionesTemplate.getLPOnClickYValor().setText();
644 | }
645 | ```
646 |
647 | * Ahora dentro de los paréntesis se pasan las coordenadas correspondientes:
648 | ```javascript
649 | public void mouseClicked(MouseEvent e) {
650 | this.configuracionesTemplate.getLPOnClickXValor().setText(e.getX());
651 | this.configuracionesTemplate.getLPOnClickYValor().setText(e.getY());
652 | }
653 | ```
654 |
655 | * Sin embargo como el método recibe por parámetro un **String** y se esta enviando como argumento un **entero** el IDE o editor de código indicará un error. Para pasar de un entero a String simplemente se puede usar la notación de: **(numeroEntero + "")** de esta forma Java entenderá que se esta haciendo una suma de caracteres y se hará la conversion automáticamente.
656 |
657 | ```javascript
658 | public void mouseClicked(MouseEvent e) {
659 | this.configuracionesTemplate.getLPOnClickXValor().setText(e.getX() + "");
660 | this.configuracionesTemplate.getLPOnClickYValor().setText(e.getY() + "");
661 | }
662 | ```
663 |
664 | Una vez se ejecuta la aplicación, se muestra el componente **Configuraciones** y se da click en cualquier parte del panel de interacción **pDibujo** se cambiara automáticamente la información de la posición de X,Y cuando se da Click:
665 |
666 |
625 | Comparación perspectivas entre métodos que nos dan la posición del puntero
626 |
667 | 
668 |
670 |
671 | Ahora bien, cabe recalcar que si se oprime click en cualquier otra parte que no sea el panel de interacción **pDibujo** o si se oprime el botón izquierdo del Mouse pero se suelta en otra posición no se verá reflejado el evento:
672 |
673 | ***Nota:** En las siguientes secuencias se ve reflejado que el botón izquierdo del Mouse se mantiene oprimido cuando este tiene una circunferencia amarilla alrededor. Como ya se explico previamente es de esa forma en que el evento **MouseClicked** deja de funcionar.*
674 |
675 |
668 | Componente Configuraciones con la implementación de MouseClicked
669 |
676 | 
677 |
679 |
680 | ## MousePressed
681 |
682 | Un evento **MousePressed** se activa una vez el usuario presiona el botón izquierdo del Mouse, no ve la necesidad de saber cuando es soltado el botón, ni si se ha movido el Mouse posteriormente a la presión del botón, este solo se enfoca netamente al momento en que se presiono el botón del Mouse. La única condición de activación es que el puntero se encuentre dentro del objeto gráfico que tiene adicionada la escucha del **MouseListener** al momento de presionar el botón del Mouse, en este caso el panel de interacción **pDibujo**.
683 |
684 | Se va a configurar este método y esta vez se que al presionar el botón del Mouse cambie la información de los Labels **LPInicialXValor y LPInicialYValor**:
685 |
686 | ```javascript
687 | public void mousePressed(MouseEvent e) {
688 | this.configuracionesTemplate.getLPInicialXValor().setText(e.getX() + "");
689 | this.configuracionesTemplate.getLPInicialYValor().setText(e.getY() + "");
690 | }
691 | ```
692 |
693 | Una vez se ejecuta la aplicación se evidencia la función de este evento:
694 |
695 |
677 | Forma incorrecta de activar el evento MouseClicked
678 |
696 | 
697 |
699 |
700 | En el anterior video se ven varias particularidades:
701 | * Siempre se va a ver reflejado primero el evento **MousePressed** ya que las milésimas de segundo en las que el usuario se demora en soltar el botón del mouse retrasa un poco al **MouseClicked**.
702 | * Si se oprime el botón del Mouse y se espera unos segundos sin mover el mouse se va a ver reflejado primero el evento en el **MousePressed** y hasta que se suelte el botón del mouse se vera en el **MouseClicked**.
703 | * Si se oprime el botón del Mouse y mientras se mantiene presionado se mueve el Mouse solo se vera reflejado el evento **MousePressed**.
704 | * Si se oprime el botón afuera del panel de interacción **pDibujo** no se vera reflejado ningún evento.
705 |
706 | ## MouseReleased
707 |
708 | Un evento **MouseReleased** se activa una vez el usuario suelta el botón del Mouse siempre y cuando este haya sido presionado previamente dentro del objeto gráfico que escucha los eventos **MouseListener**, no ve la necesidad de saber en que momento se oprimió el botón ni si se ha movido el mouse previamente de soltar el botón, este solo se enfoca netamente al momento en que se ha soltado el botón del Mouse. Una particularidad a mencionar es que si el botón del Mouse se suelta en alguna parte afuera del panel de interacción **pDibujo** puede funcionar siempre y cuando se haya presionado previamente el botón del Mouse dentro de el objeto gráfico que activo el evento.
709 |
710 | Se va a configurar este método y esta vez se quiere que al soltar el botón del Mouse cambie la información de los Labels **LPFinalXValor y LPFinalYValor**:
711 | ```javascript
712 | public void mouseReleased(MouseEvent e) {
713 | this.configuracionesTemplate.getLPFinalXValor().setText(e.getX() + "");
714 | this.configuracionesTemplate.getLPFinalYValor().setText(e.getY() + "");
715 | }
716 | ```
717 |
718 | Se ejecuta la aplicación se es posible dar cuenta de la función de este evento:
719 |
720 |
697 | Componente Configuraciones con la implementación de MousePressed
698 |
721 | 
722 |
724 |
725 | En la anterior secuencia se ven varias particularidades:
726 | * Si se presiona y suelta el botón del Mouse en la misma posición (Hacer un Click), los tres eventos van a reflejar las mismas coordenadas.
727 | * Si se presiona el botón del Mouse y se arrastra el Mouse mientras se tiene presionado el botón y luego se suelta se vera reflejado el evento **MousePressed** y el evento **MouseReleased** pero no el evento **MouseClicked**.
728 | * Si se presiona el botón dentro del panel de interacción **pDibujo** y se suelta el botón del Mouse cuando este esta afuera del panel de interacción se vera reflejado el evento **MouseReleased** aun asi.
729 | * Si se oprime el botón afuera del panel de interacción **pDibujo** no se vera reflejado ningún evento.
730 |
731 | ## MouseEntered
732 |
733 | Este evento se activa una vez el usuario entra a través del puntero del Mouse al objeto gráfico que agrego al **MouseListener**, en este caso el panel de interacción **pDibujo**. No tiene la necesidad de oprimir ningún botón del Mouse, el simple hecho de que este sobre el objeto gráfico activa este evento.
734 |
735 | Se va a configurar este método y esta vez se quiere que al entrar al panel **pDibujo** cambie el valor de **lEstadoValor** para indicar que el estado ahora es *ADENTRO*:
736 |
737 | ```javascript
738 | public void mouseEntered(MouseEvent e) {
739 | this.configuracionesTemplate.getLEstadoValor().setText("ADENTRO");
740 | }
741 | ```
742 |
743 | Una vez se ejecuta la aplicación se evidencia la función de este evento:
744 |
745 |
722 | Componente Configuraciones con la implementación de MouseReleased
723 |
746 | 
747 |
749 |
750 | Es posible ver que una vez el usuario ingresa con el puntero del mouse al panel de interacción **pDatos** el estado en el panel de datos pasa de **NINGUNO** a **ADENTRO**, sin embargo, este no parece cambiar más, se queda en el ultimo estado incluso si vuelve a salir y entrar de nuevo. Esto es por que aun no se ha configurado el evento en caso de que se salga del objeto gráfico.
751 |
752 | ## MouseExited
753 |
754 | Este evento se activa una vez el usuario sale a través del puntero del Mouse del objeto gráfico que agrego al **MouseListener**, en este caso el panel de interacción **pDibujo** siempre y cuando haya entrado en el previamente. No tiene la necesidad de oprimir ningún botón del Mouse, el simple hecho de que este salga del objeto gráfico activa este evento.
755 |
756 | Se va a configurar este método y esta vez se quiere que al salir del panel **pDibujo** cambie el valor de **lEstadoValor** para indicar que el estado ahora es *AFUERA*:
757 | ```javascript
758 | @Override
759 | public void mouseExited(MouseEvent e) {
760 | this.configuracionesTemplate.getLEstadoValor().setText("AFUERA");
761 | }
762 | ```
763 |
764 | Una vez se ejecuta la aplicación se puede dar cuenta la función de este evento:
765 |
766 |
747 | Componente Configuraciones con la implementación de MouseEntered
748 |
767 | 
768 |
770 |
771 | Como se observa una vez se abre el componente **Configuraciones** el estado está en **NINGUNO**, cada vez que se entra al panel de interacción **pDibujo** el estado cambia a **ADENTRO** y una vez se sale del panel el estado ahora es **AFUERA**.
772 |
773 | # MouseMotionListener
774 |
775 | Este grupo de eventos para el Mouse da unas características especiales, ya que están enfocados en la muestra de información en tiempo real de acciónes con el Mouse. Estos eventos son útiles para acciones como las de arrastrar objetos, dibujar en tiempo real figuras por pantalla o crear efectos con el movimiento del Mouse.
776 |
777 | En la clase **ConfiguracionesComponent**, específicamente en la declaración de esta se va a implementar la interfaz **MouseMotionListener**. Una ventaja con uso de interfaces para implementar es que una clase puede **implementar varias interfaces** al tiempo, esto no es posible con la herencia ya que en java no existe **Herencia Multiple**.
778 |
779 |
768 | Componente Configuraciones con la implementación de MouseExited
769 |
780 | 
781 |
783 |
784 | ***Nota:** Se debe tener en cuenta la importación de la librería que soporta la implementación de la interfaz.*
785 |
786 | Al igual que con la implementación de las demás interfaces esta va a pedir que se importen los métodos por defecto, por lo general el mismo IDE o editor de código va a mostrar el error y va a sugerir la importación automática de estos.
787 |
788 |
781 | Implementación de la interfaz MouseMotionListener en la clase ConfiguracionesComponent
782 |
789 | 
790 |
792 |
793 | Se puede observar que esta vez la interfaz **MouseMotionListener** implementa un total de 2 métodos por defecto y cada uno de ellos serán explicados en esta sección.
794 |
795 | Antes de continuar con la explicación se debe adicionar la capacidad de escuchar los eventos de tipo **MouseMotionListener** a la panel de interacción **pDibujo**, esta vez se usara el método **addMouseMotionListener**:
796 | ```javascript
797 | // Dentro del método crearJPanels
798 | pDibujo.addMouseMotionListener(this.configuracionesComponent);
799 | ```
800 |
801 | Como la clase **configuracionesComponent** implementa de la interfaz **MouseMotionListener** es posible pasar como argumento el objeto de esta clase.
802 |
803 | ***Nota:** Como este método hace parte de la etapa de configuración debe ir entre la construcción del panel y la adición de este en el componente.*
804 |
805 | ## MouseMoved
806 |
807 | Este evento se activa cada vez que el usuario mueve el puntero del Mouse y este se encuentra dentro del objeto gráfico al cual se le adiciono el **MouseMotionListener**, en este caso el panel de interacción **pDibujo**. No tiene la necesidad de oprimir el botón del mouse, con el hecho de estar dentro del objeto gráfico y moverse dentro, este evento se va a activar.
808 |
809 | Se va a configurar el método y esta vez se quiere que cada vez que el usuario este moviendo el Mouse dentro del panel **pDibujo** actualice la posición actual en tiempo real del Mouse, para eso se va a cambiar la información de los label **lPActualXValor y lPActualYValor**:
810 | ```javascript
811 | public void mouseMoved(MouseEvent e) {
812 | this.configuracionesTemplate.getLPActualXValor().setText(e.getX() + "");
813 | this.configuracionesTemplate.getLPActualYValor().setText(e.getY() + "");
814 | }
815 | ```
816 |
817 | Una vez se ejecuta la aplicación se evidencia la función de este evento:
818 |
819 |
790 | Métodos implementados por defecto de la interfaz MouseMotionListener
791 |
820 | 
821 |
823 |
824 | ## MouseDragged
825 |
826 | Este evento se activa una vez se oprime el botón del Mouse dentro del objeto gráfico que tiene agregado el **MouseMotionListener** en este caso el panel de interacción **pDibujo** y se mueve el puntero del Mouse mientras se mantiene oprimido el botón del Mouse, por otro lado termina de accionarse una vez se suelta el botón del Mouse. Se debe oprimir el botón del Mouse dentro del objeto gráfico o de lo contrario no funcionará este evento.
827 |
828 | Se va a configurar el método y esta vez se quiere que cada vez que el usuario oprima el botón del Mouse y empiece a mover el Mouse actualice la posición actual en tiempo real del Mouse, para eso se va a cambiar la información de los label **lLadoXValor y lLadoYValor**:
829 | ```javascript
830 | public void mouseDragged(MouseEvent e) {
831 | this.configuracionesTemplate.getLLadoXValor().setText(e.getX() + "");
832 | this.configuracionesTemplate.getLLadoYValor().setText(e.getY() + "");
833 | }
834 | ```
835 |
836 | Una vez se ejecute la aplicación es posible ver la función de este evento:
837 |
838 |
821 | Componente Configuraciones con la implementación de MouseMoved
822 |
839 | 
840 |
842 |
843 | De la anterior secuencia se puede notar algunas particularidades:
844 | * Una vez el usuario oprime el botón del mouse dentro del panel de interacción **pDibujo** y empieza a arrastrar el mouse sin soltar aun el botón, deja de funcionar el evento **MouseMoved** y empieza a funcionar el evento **MouseDragged**.
845 | * Una vez el usuario suelta el botón del Mouse y está dentro del panel de interacción **pDibujo** dejara de funcionar el evento **MouseDragged** y empieza a funcionar el evento **MouseMoved**.
846 | * Si el usuario presiono el botón del Mouse dentro del panel de interacción **pDibujo** previamente y se mantiene presionado el evento **MouseDragged** seguirá funcionando incluso si se sale del panel todo mientras se siga manteniendo presionado el botón del mouse.
847 | * Si se presiona desde afuera del panel de interacción **pDibujo** ningún evento tendrán efecto.
848 |
849 | # MouseWheelListener
850 |
851 | Este grupo de eventos se concentran unicamente en el movimiento del **scroll del Mouse** (la rueda que por lo general tiene el Mouse en medio de los dos botones). Este evento se fija unicamente del movimiento de este Scroll, es decir que no tiene en cuenta cuando se **hace un click** con el Scroll, solo cuando el usuario lo mueve hacia arriba o hacia abajo.
852 |
853 | En la clase **ConfiguracionesComponent**, específicamente en la declaración de la clase, se va a implementar la interfaz **MouseWheelListener**. Recordar que esto es posible ya que una clase puede **implementar varias interfaces** al tiempo.
854 |
855 |
840 | Componente Configuraciones con la implementación de mouseDragged
841 |
856 | 
857 |
859 |
860 | Como con todas las demás interfaces, se debe implementar los métodos por defecto que trae esta interfaz.
861 |
862 |
857 | Implementación de la interfaz MouseWheelListener en la clase ConfiguracionesComponent
858 |
863 | 
864 |
866 |
867 | Se puede observar que la interfaz **MouseWheelListener** implementa un solo método por defecto y este será explicado en esta sección.
868 |
869 | Antes de continuar con la explicación se debe adicionar la capacidad de escuchar los eventos tipo **MouseWheelListener** al panel de interacción **pDibujo**, esta vez se usará el método **addMouseWheelListener**:
870 | ```javascript
871 | // Dentro del método crearJPanels
872 | pDibujo.addMouseWheelListener(this.configuracionesComponent);
873 | ```
874 |
875 | Como la clase **configuracionesComponent** implementa de la interfaz **MouseWheelListener** es posible pasar como argumento el objeto de esta clase.
876 |
877 | ***Nota:** Como este método hace parte de la etapa de configuración debe ir entre la construcción del panel y la adición de este en el componente.*
878 |
879 | ## MouseWheelMoved
880 |
881 | Este evento se activa una vez el usuario mueve el **Scroll del Mouse**, es decir lo desliza hacia arriba o hacia abajo, para que este evento pueda ser activado debe estar dentro del objeto gráfico que tiene agregado la escucha de eventos tipo **MouseWheelListener** en este caso el panel de interacción **pDatos**. Si se realiza afuera de este no tendrá ningún efecto.
882 |
883 | Se va a configurar el método y esta vez se quiere que cada vez que el usuario deslice el Scroll hacia arriba o hacia abajo se realice la simulación de acercamiento y alejamiento, esto se realiza cambiando el valor del label **lZoomValor**. Cuando el usuario mueva el Scroll hacia arriba va a aumentar el numero del zoom mientras que cuando el usuario mueva hacia abajo este numero va a disminuir.
884 |
885 | Para saber si el usuario esta subiendo o bajando el scroll del Mouse se debe usar el método:
886 | * **e.getWheelRotation():** Que retorna un numero entero.
887 | * Si el usuario esta subiendo con el scroll va a retornar el numero **-1**.
888 | * Si el usuario esta bajando con el scroll va a retornar el numero **1**.
889 |
890 | Con este método se puede realizar la configuración del zoom explicada anteriormente:
891 | ```javascript
892 | public void mouseWheelMoved(MouseWheelEvent e) {
893 | if(e.getWheelRotation() == -1)
894 | // Acción Cuando el usuario sube con el Scroll
895 | if(e.getWheelRotation() == 1)
896 | // Acción Cuando el usuario baja con el Scroll
897 | }
898 | ```
899 |
900 | * Como se quiere cambiar el valor del label **lZoomValor**, se debe obtener a traves del objeto de la clase **Template** y su respectivo método **get**, una vez obtenido se debe indicar que cambiará su contenido con el método **setText**:
901 | ```javascript
902 | public void mouseWheelMoved(MouseWheelEvent e) {
903 | if(e.getWheelRotation() == -1)
904 | this.configuracionesTemplate.getLZoomValor().setText();
905 | if(e.getWheelRotation() == 1)
906 | this.configuracionesTemplate.getLZoomValor().setText();
907 | }
908 | ```
909 |
910 | * Ahora se debe indicar en cada caso que se le va a sumar o restar el valor de 1, pero para eso es necesario obtener antes el valor actual que tiene el label **lZoomValor**, ya que si solo se le indica que sume o reste 1 el valor del Label **lZoomValor** solo podría ser 1 o -1. Para obtener su valor nuevamente se debe llamar al Label a través del objeto de la clase **Template** y su respectivo método **get** seguido del método **getText()** que retorna en un String el contenido del Label:
911 | ```javascript
912 | public void mouseWheelMoved(MouseWheelEvent e) {
913 | if(e.getWheelRotation() == -1)
914 | this.configuracionesTemplate.getLZoomValor().setText(
915 | this.configuracionesTemplate.getLZoomValor().getText()
916 | );
917 | if(e.getWheelRotation() == 1)
918 | this.configuracionesTemplate.getLZoomValor().setText(
919 | this.configuracionesTemplate.getLZoomValor().getText()
920 | );
921 | }
922 | ```
923 |
924 | * Como se quiere sumar o restar un 1 al contenido actual del Label **lZoomValor** se debe convertir el dato de String a entero y de esta forma se puede realizar una suma o resta entre números:
925 | ```javascript
926 | public void mouseWheelMoved(MouseWheelEvent e) {
927 | if(e.getWheelRotation() == -1)
928 | this.configuracionesTemplate.getLZoomValor().setText(
929 | Integer.parseInt(this.configuracionesTemplate.getLZoomValor().getText())
930 | );
931 | if(e.getWheelRotation() == 1)
932 | this.configuracionesTemplate.getLZoomValor().setText(
933 | Integer.parseInt(this.configuracionesTemplate.getLZoomValor().getText())
934 | );
935 | }
936 | ```
937 |
938 | * Es posible notar que hasta el momento en ambos casos se esta haciendo el mismo proceso, se puede entonces encapsular el proceso de obtención y conversion del zoom actual en una variable antes de que empiecen las condiciones, para que no quede tan confuso el código:
939 |
940 | ```javascript
941 | public void mouseWheelMoved(MouseWheelEvent e) {
942 | int valorZoomActual = Integer.parseInt(this.configuracionesTemplate.getLZoomValor().getText());
943 | if(e.getWheelRotation() == -1)
944 | this.configuracionesTemplate.getLZoomValor().setText(valorZoomActual);
945 | if(e.getWheelRotation() == 1)
946 | this.configuracionesTemplate.getLZoomValor().setText(valorZoomActual);
947 | }
948 | ```
949 |
950 | * Ahora si se va a sumar y restar un 1 según sea el caso:
951 |
952 | ```javascript
953 | public void mouseWheelMoved(MouseWheelEvent e) {
954 | int valorZoomActual = Integer.parseInt(this.configuracionesTemplate.getLZoomValor().getText());
955 | if(e.getWheelRotation() == -1)
956 | this.configuracionesTemplate.getLZoomValor().setText(valorZoomActual + 1);
957 | if(e.getWheelRotation() == 1)
958 | this.configuracionesTemplate.getLZoomValor().setText(valorZoomActual - 1);
959 | }
960 | ```
961 |
962 | * Sin embargo el método **setText** exige enviar como argumento un String asi que se realiza otra conversion, esta vez de entero a String como se menciono antes:
963 | ```javascript
964 | public void mouseWheelMoved(MouseWheelEvent e) {
965 | int valorZoomActual = Integer.parseInt(this.configuracionesTemplate.getLZoomValor().getText());
966 | if(e.getWheelRotation() == -1)
967 | this.configuracionesTemplate.getLZoomValor().setText(valorZoomActual + 1 + "");
968 | if(e.getWheelRotation() == 1)
969 | this.configuracionesTemplate.getLZoomValor().setText(valorZoomActual - 1 + "");
970 | }
971 | ```
972 |
973 | Si se ejecuta la aplicación se puede ver el evento funcionando:
974 |
975 |
864 | Métodos implementados por defecto de la interfaz MouseWheelListener
865 |
976 | 
977 |
979 |
980 | Sin embargo, es posible notar que si se baja demasiado con el scroll este empieza a mostrar números negativos y esto en términos de zoom no es correcto, por lo que seria bueno dejar un limite en caso de bajar el scroll para que no pueda pasar a menos de 0:
981 |
982 | * Primero se debe indicar en el condicional que controla cuando el Scroll esta bajando que se va a realizar otra condición, esto se hace con el separador **&&**.
983 |
984 | ```javascript
985 | public void mouseWheelMoved(MouseWheelEvent e) {
986 | int valorZoomActual = Integer.parseInt(this.configuracionesTemplate.getLZoomValor().getText());
987 | if(e.getWheelRotation() == -1)
988 | this.configuracionesTemplate.getLZoomValor().setText(valorZoomActual + 1 + "");
989 | if(e.getWheelRotation() == 1 &&)
990 | this.configuracionesTemplate.getLZoomValor().setText(valorZoomActual - 1 + "");
991 | }
992 | ```
993 |
994 | * Ahora se debe obtener el valor actual del zoom para poder ser comparado, sin embargo, este proceso de obtención y conversion del Zoom actual ya está encapsulado en la variable **valorZoomActual** por lo que se usa esta:
995 |
996 | ```javascript
997 | public void mouseWheelMoved(MouseWheelEvent e) {
998 | int valorZoomActual = Integer.parseInt(this.configuracionesTemplate.getLZoomValor().getText());
999 | if(e.getWheelRotation() == -1)
1000 | this.configuracionesTemplate.getLZoomValor().setText(valorZoomActual + 1 + "");
1001 | if(e.getWheelRotation() == 1 && valorZoomActual)
1002 | this.configuracionesTemplate.getLZoomValor().setText(valorZoomActual - 1 + "");
1003 | }
1004 | ```
1005 |
1006 | * Ahora solo nos hace falta realizar la comparación:
1007 |
1008 | ```javascript
1009 | public void mouseWheelMoved(MouseWheelEvent e) {
1010 | int valorZoomActual = Integer.parseInt(this.configuracionesTemplate.getLZoomValor().getText());
1011 | if(e.getWheelRotation() == -1)
1012 | this.configuracionesTemplate.getLZoomValor().setText(valorZoomActual + 1 + "");
1013 | if(e.getWheelRotation() == 1 && valorZoomActual > 0)
1014 | this.configuracionesTemplate.getLZoomValor().setText(valorZoomActual - 1 + "");
1015 | }
1016 | ```
1017 |
1018 | En la anterior condición se indicando al programa que solo cuando el valor del Zoom actual sea mayor a 0 este podrá ser restado, de lo contrario este valor será 0 y por ende no podrá entrar a la condición.
1019 |
1020 | Si se ejecuta de nuevo la aplicación se puede notar que se cumple la condición que queríamos:
1021 |
1022 |
977 | Componente Configuraciones con la implementación de mouseWheelMoved
978 |
1023 | 
1024 |
1026 |
1027 | # Resultado
1028 |
1029 | Si llegaste hasta aquí **!Felicidades!**, se ha aprendido las características principales de los diferentes eventos del mouse. Se ha revisado en que momentos se activa y deja de funcionar cada uno de ellos, además de algunas particularidades que tienen los eventos del mouse. En la siguiente clase se van a implementar estos eventos al resto del proyecto para darle una interactividad mayor a la interfaz gráfica de usuario.
1030 |
1031 | # Actividad
1032 |
1033 | Revisa los diferentes tipos de eventos poniendo comentarios a la funcionalidad, particularidades y en que casos no funciona cada uno de estos.
--------------------------------------------------------------------------------
/gifs/MouseClick.gif:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/CrissUD/InterfazGraficaJavaClase8/e68b7991cd4c0c92bee94055f2f39ccd02c2eff2/gifs/MouseClick.gif
--------------------------------------------------------------------------------
/gifs/MouseClickFail.gif:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/CrissUD/InterfazGraficaJavaClase8/e68b7991cd4c0c92bee94055f2f39ccd02c2eff2/gifs/MouseClickFail.gif
--------------------------------------------------------------------------------
/gifs/MouseDragged.gif:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/CrissUD/InterfazGraficaJavaClase8/e68b7991cd4c0c92bee94055f2f39ccd02c2eff2/gifs/MouseDragged.gif
--------------------------------------------------------------------------------
/gifs/MouseEntered.gif:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/CrissUD/InterfazGraficaJavaClase8/e68b7991cd4c0c92bee94055f2f39ccd02c2eff2/gifs/MouseEntered.gif
--------------------------------------------------------------------------------
/gifs/MouseExited.gif:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/CrissUD/InterfazGraficaJavaClase8/e68b7991cd4c0c92bee94055f2f39ccd02c2eff2/gifs/MouseExited.gif
--------------------------------------------------------------------------------
/gifs/MouseMoved.gif:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/CrissUD/InterfazGraficaJavaClase8/e68b7991cd4c0c92bee94055f2f39ccd02c2eff2/gifs/MouseMoved.gif
--------------------------------------------------------------------------------
/gifs/MousePressed.gif:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/CrissUD/InterfazGraficaJavaClase8/e68b7991cd4c0c92bee94055f2f39ccd02c2eff2/gifs/MousePressed.gif
--------------------------------------------------------------------------------
/gifs/MouseReleased.gif:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/CrissUD/InterfazGraficaJavaClase8/e68b7991cd4c0c92bee94055f2f39ccd02c2eff2/gifs/MouseReleased.gif
--------------------------------------------------------------------------------
/gifs/MouseWheel.gif:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/CrissUD/InterfazGraficaJavaClase8/e68b7991cd4c0c92bee94055f2f39ccd02c2eff2/gifs/MouseWheel.gif
--------------------------------------------------------------------------------
/gifs/MouseWheelFinal.gif:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/CrissUD/InterfazGraficaJavaClase8/e68b7991cd4c0c92bee94055f2f39ccd02c2eff2/gifs/MouseWheelFinal.gif
--------------------------------------------------------------------------------
1024 | Restricción en la resta del zoom
1025 |